void
videoFinish ( videoData *vdata )
{
dbgprintf ( "video finishing" ) ;
static s32 i ;
/* make sure no flip is in progress */
gcmSetWaitFlip ( vdata->context ) ;
/* free rsx buffers */
for ( i = 0 ; i < MAX_BUFFERS ; i++ )
{
rsxFree ( vdata->rsx_buffers[i].ptr ) ;
}
/* finish rsx context */
rsxFinish ( vdata->context, 1 ) ;
/* free host_addr memory */
free ( vdata->host_addr ) ;
/* destroy semaphore */
sysSemDestroy ( vdata->sem ) ;
/* destroy cond */
sysCondDestroy ( vdata->cond ) ;
/* destroy mutex */
sysMutexDestroy ( vdata->mutex ) ;
}
/* release controller */
inline void
padFinish ( padBtnData *pdata )
{
dbgprintf ( "pad finishing" ) ;
/* destroy semaphore */
sysSemDestroy ( pdata->sem ) ;
/* destroy cond */
sysCondDestroy ( pdata->cond ) ;
/* destroy mutex */
sysMutexDestroy ( pdata->mutex ) ;
ioPadEnd () ;
dbgprintf ( "pad finished" ) ;
}
pte_osResult pte_osMutexDelete(pte_osMutexHandle handle)
{
sysMutexDestroy(handle);
return PTE_OS_OK;
}
int destroy_sac_accessor(void)
{
int ret = 0;
if (sa == NULL)
{
return 0;
}
if (sa->module_buffer)
{
free(sa->module_buffer);
sa->module_buffer = 0;
}
if (sa->id != -1)
{
ret = sysSpuRawReadProblemStorage(sa->id, SPU_Status);
EIEIO;
if (ret & 0x1)
{
sysSpuRawWriteProblemStorage(sa->id, SPU_In_MBox, EXIT_SAC_CMD);
EIEIO;
sysSpuRawWriteProblemStorage(sa->id, SPU_In_MBox, 0);
EIEIO;
}
}
if ((ret = sysInterruptThreadDisestablish(sa->ih)) != 0)
{
LOG(lm_main, LOG_ERROR, ("sysInterruptThreadDisestablish returned %d\n", ret));
}
if ((ret = sysInterruptTagDestroy(sa->intrtag)) != 0)
{
LOG(lm_main, LOG_ERROR, ("sys_interrupt_tag_destroy returned %d\n", ret));
}
if (sa->id != -1)
{
#ifdef USE_ISOSELF
if ((ret = sys_isoself_spu_destroy(sa->id)) != 0)
{
LOG(lm_main, LOG_ERROR, ("sys_isoself_spu_destroy returned %d\n", ret));
}
#else
if ((ret = sysSpuRawDestroy(sa->id)) != 0)
{
LOG(lm_main, LOG_ERROR, ("sys_raw_spu_destroy returned %d\n", ret));
}
#endif
}
if (sa->buffer)
{
free(sa->buffer);
sa->buffer = 0;
}
if (sa->read_buffer)
{
free(sa->read_buffer);
sa->read_buffer = 0;
}
if (sa->write_buffer)
{
free(sa->write_buffer);
sa->write_buffer = 0;
}
if ((ret = sysCondDestroy(sa->mmio_cond)) != 0)
{
LOG(lm_main, LOG_ERROR, ("destroy mmio_cond failed.\n"));
}
if ((ret = sysMutexDestroy(sa->mmio_mutex)) != 0)
{
LOG(lm_main, LOG_ERROR, ("destroy mmio_mutex failed.\n"));
}
free(sa);
sa = NULL;
return ret;
}
int main(s32 argc, const char* argv[]) {
//Mutex.
sys_mutex_attr_t attr;
memset(&attr, 0, sizeof(attr));
attr.attr_protocol = SYS_MUTEX_PROTOCOL_FIFO;
attr.attr_recursive = SYS_MUTEX_ATTR_NOT_RECURSIVE;
attr.attr_pshared = SYS_MUTEX_ATTR_PSHARED;
attr.attr_adaptive = SYS_MUTEX_ATTR_NOT_ADAPTIVE;
strcpy(attr.name, "mutex");
sysMutexCreate(&thread_mutex, &attr);
//Threads.
THREADS_RUNNING = 2;
sys_ppu_thread_t pad_id, program_id;
sysThreadCreate(&pad_id, pad_thread, (void*) &GLOBAL_EXIT, 1500, 0x400, 0, "pad");
sysThreadCreate(&program_id, program_thread, (void*) &GLOBAL_EXIT, 1337, 0x400, 0, "program");
//Create buffers.
gcmContextData *context;
void *host_addr = NULL;
rsxBuffer buffers[MAX_BUFFERS];
int currentBuffer = 0;
//Allocate a 1Mb buffer, alligned to a 1Mb boundary to be our shared IO memory with the RSX.
host_addr = memalign(1024*1024, HOST_SIZE);
context = initScreen(host_addr, HOST_SIZE);
//Get resolution.
u16 width, height;
getResolution(&width, &height);
//Create buffers.
int i;
for(i = 0; i < MAX_BUFFERS; i++) {
makeBuffer(&buffers[i], width, height, i);
}
flip(context, MAX_BUFFERS - 1);
//Main loop.
while(THREADS_RUNNING > 0) {
//Prepare buffer.
setRenderTarget(context, &buffers[currentBuffer]);
waitFlip();
//Flip buffer onto screen.
flip(context, buffers[currentBuffer].id);
//Change buffer.
currentBuffer++;
if(currentBuffer >= MAX_BUFFERS) {
currentBuffer = 0;
}
}
//Free buffers.
gcmSetWaitFlip(context);
for(i = 0; i < MAX_BUFFERS; i++) {
rsxFree(buffers[i].ptr);
}
rsxFinish(context, 1);
free(host_addr);
//Mutex destroy.
sysMutexDestroy(thread_mutex);
return 0;
}
