void checkMutex(int doDispatch) {
SceUID mutex = sceKernelCreateMutex("mutex", 0, 1, NULL);
dispatchCheckpoint("sceKernelCreateMutex: %08x", mutex >= 0 ? 1 : mutex);
dispatchCheckpoint("sceKernelUnlockMutex: %08x", sceKernelUnlockMutex(mutex, 1));
dispatchCheckpoint("sceKernelLockMutex: %08x", sceKernelLockMutex(mutex, 1, NULL));
dispatchCheckpoint("sceKernelLockMutex invalid: %08x", sceKernelLockMutex(mutex, -1, NULL));
dispatchCheckpoint("sceKernelDeleteMutex: %08x", sceKernelDeleteMutex(mutex));
mutex = sceKernelCreateMutex("test", 0, 1, NULL);
dispatchCheckpoint("sceKernelCreateMutex: %08x", mutex >= 0 ? 1 : mutex);
startLockThreadMutex(mutex);
int state;
if (doDispatch) {
++ignoreResched;
state = sceKernelSuspendDispatchThread();
dispatchCheckpoint("sceKernelSuspendDispatchThread: %08x", state);
}
SceUInt timeout = 300;
dispatchCheckpoint("sceKernelLockMutex: %08x", sceKernelLockMutex(mutex, 1, &timeout));
dispatchCheckpoint("sceKernelUnlockMutex: %08x", sceKernelUnlockMutex(mutex, 1));
if (doDispatch) {
dispatchCheckpoint("sceKernelResumeDispatchThread: %08x", sceKernelResumeDispatchThread(state));
--ignoreResched;
}
endLockThreadMutex(mutex);
dispatchCheckpoint("sceKernelTryLockMutex: %08x", sceKernelTryLockMutex(mutex, 1));
dispatchCheckpoint("sceKernelDeleteMutex: %08x", sceKernelDeleteMutex(mutex));
}
int main(int argc, char **argv) {
SceUID mutex;
int i;
u32 options[32];
memset(options, 0, sizeof(options));
checkpointNext("Names:");
createTest(" NULL name", NULL, 0, 0, NULL);
createTest(" Blank name", "", 0, 0, NULL);
createTest(" Long name", "1234567890123456789012345678901234567890123456789012345678901234", 0, 0, NULL);
SceUID mutex1 = sceKernelCreateMutex("create", 0, 0, NULL);
SceUID mutex2 = sceKernelCreateMutex("create", 0, 0, NULL);
if (mutex1 > 0 && mutex2 > 0) {
checkpoint(" Two with same name: OK");
} else {
checkpoint(" Two with same name: Failed (%X, %X)", mutex1, mutex2);
}
sceKernelDeleteMutex(mutex1);
sceKernelDeleteMutex(mutex2);
checkpointNext("Attributes:");
const static int attrs[] = {1, 0x100, 0x200, 0x400, 0x800, 0xB00, 0xBFF, 0xC00, 0x1000, 0x2000, 0x4000, 0x8000, 0x10000};
for (i = 0; i < ARRAY_SIZE(attrs); ++i) {
char temp[32];
sprintf(temp, " %x", attrs[i]);
createTest(temp, "create", attrs[i], 0, NULL);
}
checkpointNext("Counts:");
createTest(" Negative count", "create", 0, -1, NULL);
createTest(" Positive count", "create", 0, 1, NULL);
createTest(" Large count", "create", 0, 65537, NULL);
checkpointNext("Option sizes:");
const static int optionSizes[] = {-1, 0, 1, 4, 8, 16, 32, 64, 256, 0x7FFFFFFF};
for (i = 0; i < ARRAY_SIZE(optionSizes); ++i) {
char temp[32];
sprintf(temp, " %d", optionSizes[i]);
options[0] = optionSizes[i];
createTest(temp, "create", 0, 1, options);
}
checkpointNext("Scheduling:");
BASIC_SCHED_TEST("NULL name",
mutex = sceKernelCreateMutex(NULL, 0, 0, NULL);
result = mutex > 0 ? 1 : mutex;
);
int main(int argc, char **argv) {
LOCK_TEST("Lock 0 => 0", PSP_MUTEX_ATTR_FIFO, 0, 0);
LOCK_TEST("Lock 0 => 1", PSP_MUTEX_ATTR_FIFO, 0, 1);
LOCK_TEST("Lock 0 => 2", PSP_MUTEX_ATTR_FIFO, 0, 2);
LOCK_TEST("Lock 0 => -1", PSP_MUTEX_ATTR_FIFO, 0, -1);
LOCK_TEST("Lock 1 => 1", PSP_MUTEX_ATTR_FIFO, 1, 1);
LOCK_TEST("Lock 0 => 2 (recursive)", PSP_MUTEX_ATTR_ALLOW_RECURSIVE, 0, 2);
LOCK_TEST("Lock 0 => -1 (recursive)", PSP_MUTEX_ATTR_ALLOW_RECURSIVE, 0, -1);
LOCK_TEST("Lock 1 => 1 (recursive)", PSP_MUTEX_ATTR_ALLOW_RECURSIVE, 1, 1);
LOCK_TEST("Lock 1 => INT_MAX - 1 (recursive)", PSP_MUTEX_ATTR_ALLOW_RECURSIVE, 1, INT_MAX - 1);
LOCK_TEST("Lock 1 => INT_MAX (recursive)", PSP_MUTEX_ATTR_ALLOW_RECURSIVE, 1, INT_MAX);
LOCK_TEST("Lock INT_MAX => INT_MAX (recursive)", PSP_MUTEX_ATTR_ALLOW_RECURSIVE, INT_MAX, INT_MAX);
SceUID lockThread = CREATE_SIMPLE_THREAD(lockFunc);
LOCK_TEST_THREAD("Locked 1 => 1", PSP_MUTEX_ATTR_FIFO, 1, 1);
LOCK_TEST_THREAD("Locked 0 => 1", PSP_MUTEX_ATTR_FIFO, 0, 1);
LOCK_TEST_THREAD("Locked 1 => 1 (recursive)", PSP_MUTEX_ATTR_ALLOW_RECURSIVE, 1, 1);
LOCK_TEST_THREAD("Locked 0 => 1 (recursive)", PSP_MUTEX_ATTR_ALLOW_RECURSIVE, 0, 1);
// Probably we can't manage to delete it at the same time.
SceUID deleteThread = CREATE_SIMPLE_THREAD(deleteMeFunc);
SceUID mutex = sceKernelCreateMutex("lock", 0, 1, NULL);
sceKernelStartThread(deleteThread, sizeof(int), &mutex);
sceKernelDeleteMutex(mutex);
LOCK_TEST_SIMPLE("NULL => 0", 0, 0);
LOCK_TEST_SIMPLE("NULL => 1", 0, 1);
LOCK_TEST_SIMPLE("Invalid => 1", 0xDEADBEEF, 1);
LOCK_TEST_SIMPLE("Deleted => 1", mutex, 1);
BASIC_SCHED_TEST("NULL",
result = sceKernelTryLockMutex(0, 1);
);
void console_init()
{
SceNetInitParam initparam;
if (console_initialzed) {
return;
}
console_mtx = sceKernelCreateMutex("console_mutex", 0, 0, NULL);
if (sceSysmoduleIsLoaded(SCE_SYSMODULE_NET) != SCE_SYSMODULE_LOADED)
sceSysmoduleLoadModule(SCE_SYSMODULE_NET);
if (sceNetShowNetstat() == SCE_NET_ERROR_ENOTINIT) {
net_memory = malloc(NET_INIT_SIZE);
initparam.memory = net_memory;
initparam.size = NET_INIT_SIZE;
initparam.flags = 0;
sceNetInit(&initparam);
}
sock = sceNetSocket("netdbg", SCE_NET_AF_INET, SCE_NET_SOCK_DGRAM, 0);
memset(&target, 0, sizeof(target));
target.sin_family = SCE_NET_AF_INET;
target.sin_port = sceNetHtons(3490);
sceNetInetPton(SCE_NET_AF_INET, "192.168.1.104", &target.sin_addr);
console_initialzed = 1;
}
void initThreadmgr()
{
globals_t *globals = getGlobals();
globals->threadmgrSema = sceKernelCreateSema("vhlThreadmgrSema", 0,
MAX_THREADS_NUM, MAX_THREADS_NUM, NULL);
globals->threadmgrMutex = sceKernelCreateMutex("vhlThreadmgrMutex", 0, 0, NULL);
}
void ftp_init(char *vita_ip, unsigned short int *vita_port)
{
int ret;
UNUSED(ret);
SceNetInitParam initparam;
SceNetCtlInfo info;
if (ftp_initialized) {
return;
}
/* Init Net */
if (sceNetShowNetstat() == PSP2_NET_ERROR_ENOTINIT) {
net_memory = malloc(NET_INIT_SIZE);
initparam.memory = net_memory;
initparam.size = NET_INIT_SIZE;
initparam.flags = 0;
ret = sceNetInit(&initparam);
DEBUG("sceNetInit(): 0x%08X\n", ret);
} else {
DEBUG("Net is already initialized.\n");
}
/* Init NetCtl */
ret = sceNetCtlInit();
DEBUG("sceNetCtlInit(): 0x%08X\n", ret);
/* Get IP address */
ret = sceNetCtlInetGetInfo(PSP2_NETCTL_INFO_GET_IP_ADDRESS, &info);
DEBUG("sceNetCtlInetGetInfo(): 0x%08X\n", ret);
/* Return data */
strcpy(vita_ip, info.ip_address);
*vita_port = FTP_PORT;
/* Save the IP of PSVita to a global variable */
sceNetInetPton(PSP2_NET_AF_INET, info.ip_address, &vita_addr);
/* Create server thread */
server_thid = sceKernelCreateThread("FTPVita_server_thread",
server_thread, 0x10000100, 0x10000, 0, 0, NULL);
DEBUG("Server thread UID: 0x%08X\n", server_thid);
/* Create the client list mutex */
client_list_mtx = sceKernelCreateMutex("FTPVita_client_list_mutex", 0, 0, NULL);
DEBUG("Client list mutex UID: 0x%08X\n", client_list_mtx);
/* Start the server thread */
sceKernelStartThread(server_thid, 0, NULL);
ftp_initialized = 1;
}
void simpleTest() {
int mutexid;
printf("sceKernelCreateMutex:0x%08X\n", mutexid = sceKernelCreateMutex("test", PSP_MUTEX_ATTR_FIFO, 0));
{
printf("sceKernelLockMutex:0x%08X\n", sceKernelLockMutex(mutexid, 1, NULL));
printf("sceKernelUnlockMutex:0x%08X\n", sceKernelUnlockMutex(mutexid, 1));
printf("sceKernelUnlockMutex:0x%08X\n", sceKernelUnlockMutex(mutexid, 1));
}
printf("sceKernelDeleteMutex:0x%08X\n", sceKernelDeleteMutex(mutexid));
printf("sceKernelDeleteMutex:0x%08X\n", sceKernelDeleteMutex(mutexid));
}
inline void createTest(const char *title, const char *name, u32 attr, int count, void *options) {
SceUID mutex = sceKernelCreateMutex(name, attr, count, options);
if (mutex > 0) {
checkpoint(NULL);
schedf("%s: ", title);
schedfMutex(mutex);
sceKernelDeleteMutex(mutex);
} else {
checkpoint("%s: Failed (%X)", title, mutex);
}
}
int initRpc()
{
meRpc.mutex = sceKernelCreateMutex("SceMediaEngineRpc", 0x101, 0, 0);
if (meRpc.mutex < 0)
return meRpc.mutex;
meRpc.sema = sceKernelCreateSema("SceMediaEngineAvcPower" , 0x101, 1, 1, 0);
if (meRpc.sema < 0)
return meRpc.sema;
meRpc.event = sceKernelCreateEventFlag("SceMediaEngineRpcWait", 0x201, 0, 0);
if (meRpc.event < 0)
return meRpc.event;
sceSysregIntrEnd();
int ret = sceKernelRegisterIntrHandler(SCE_MECODEC_INT, 2, (void*)&interruptHandler, (void*)meRpc.event, 0);
if (ret < 0)
return ret;
return sceKernelEnableIntr(SCE_MECODEC_INT);
}
void recursiveTest() {
int mutexid;
printf("sceKernelCreateMutex:0x%08X\n", mutexid = sceKernelCreateMutex("test", PSP_MUTEX_ATTR_FIFO | PSP_MUTEX_ATTR_ALLOW_RECURSIVE, 0));
{
printf("[0]sceKernelLockMutex:0x%08X\n", sceKernelLockMutex(mutexid, 1, NULL));
{
printf("[1]sceKernelLockMutex:0x%08X\n", sceKernelLockMutex(mutexid, 1, NULL));
{
printf("[2]sceKernelLockMutex:0x%08X\n", sceKernelLockMutex(mutexid, 1, NULL));
printf("[2]sceKernelUnlockMutex:0x%08X\n", sceKernelUnlockMutex(mutexid, 1));
}
printf("[1]sceKernelUnlockMutex:0x%08X\n", sceKernelUnlockMutex(mutexid, 1));
}
printf("[0]sceKernelUnlockMutex:0x%08X\n", sceKernelUnlockMutex(mutexid, 1));
}
printf("sceKernelDeleteMutex:0x%08X\n", sceKernelDeleteMutex(mutexid));
printf("sceKernelDeleteMutex:0x%08X\n", sceKernelDeleteMutex(mutexid));
}
void multipleTest() {
int threads[N_THREADS];
int n;
semaid = sceKernelCreateSema("sema1", 0, 0, 255, NULL);
mutexid = sceKernelCreateMutex("mutex", PSP_MUTEX_ATTR_FIFO | PSP_MUTEX_ATTR_ALLOW_RECURSIVE, 0);
{
for (n = 0; n < N_THREADS; n++) {
sceKernelStartThread(threads[n] = sceKernelCreateThread("multipleTestThread", (void *)&multipleTestThread, 0x12, 0x10000, 0, NULL), sizeof(int), &n);
}
sceKernelSignalSema(semaid, N_THREADS);
for (n = 0; n < N_THREADS; n++) {
sceKernelWaitThreadEnd(threads[n], NULL);
}
}
sceKernelDeleteMutex(mutexid);
}
/***
* 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;
}
