Пример #1
0
int main(void) {
	//change clock rate to 333mhz
	scePowerSetClockFrequency(333, 333, 166);

	PowerManager::instance();	// Setup power manager

	SetupCallbacks();

	static const char *argv[] = { "scummvm", NULL };
	static int argc = sizeof(argv) / sizeof(char *) - 1;

	g_system = new OSystem_PSP();
	assert(g_system);

#ifdef DYNAMIC_MODULES
	PluginManager::instance().addPluginProvider(new PSPPluginProvider());
#endif

/* unit/speed tests */
#if defined (PSP_ENABLE_UNIT_TESTS) || defined (PSP_ENABLE_SPEED_TESTS)
	PSP_INFO_PRINT("running tests\n");
	psp_tests();
	sceKernelSleepThread();	// that's it. That's all we're doing
#endif

	int res = scummvm_main(argc, argv);

	g_system->quit();	// TODO: Consider removing / replacing this!

	PowerManager::destroy();	// get rid of PowerManager

	sceKernelSleepThread();

	return res;
}
Пример #2
0
void loadTheme()
{
	int i, bytesRead;

	SceUID fp;
	fp = sceIoOpen("ms0:/lockdown.thm", PSP_O_RDONLY, 0777);

	if (fp < 0)
	{
		fp = sceIoOpen("flash0:/lockdown.thm", PSP_O_RDONLY, 0777);

		if (fp < 0)
		{
			printTextScreen(0, 0, "Error loading flash0:/lockdown.thm.", RGB(255, 0, 0));
			printTextScreen(0, 8, "Place theme at ms0:/lockdown.thm to load from memory stick.", RGB(255, 0, 0));
			sceDisplayWaitVblankStart();
			flipScreen();
			sceKernelSleepThread();
		}
	}

	for (i = 0; i < NUMFILES; i++)
	{
		bytesRead = sceIoRead(fp, &images[i].hdr, sizeof(imagehdr));
		if (bytesRead != sizeof(imagehdr))
		{
			printTextScreen(0, 0, "Unexpected end of header.", RGB(255, 0, 0));
			sceDisplayWaitVblankStart();
			flipScreen();
			sceKernelSleepThread();
		}
		images[i].blockid = sceKernelAllocPartitionMemory(2, "block", 0, (sizeof(unsigned char) * images[i].hdr.size), NULL);
		if (images[i].blockid < 0)
		{
			printTextScreen(0, 0, "Memory allocation error.", RGB(255, 0, 0));
			sceDisplayWaitVblankStart();
			flipScreen();
			sceKernelSleepThread();
		}
		images[i].data = (unsigned char*) sceKernelGetBlockHeadAddr(images[i].blockid);
		bytesRead = sceIoRead(fp, images[i].data, images[i].hdr.size);
		if (bytesRead != images[i].hdr.size)
		{
			printTextScreen(0, 0, "Unexpected end of data.", RGB(255, 0, 0));
			sceDisplayWaitVblankStart();
			flipScreen();
			sceKernelSleepThread();
		}
	}

	sceIoClose(fp);
}
Пример #3
0
int JNetwork::connect(const string& serverIP) {
#ifdef NETWORK_SUPPORT
    int err;
    char buffer[4096];
    if(netthread) return 0;


    sceUtilityLoadNetModule(1);
    sceUtilityLoadNetModule(3);

    if((err = pspSdkInetInit())) {
        sprintf(buffer, "JGE Error, could not initialise the network %08X", err);
        printf(buffer);
        printf("\n");
        error = buffer;
        return err;
    }

    if(JNetwork::connect_to_apctl(1)) {
        JNetwork::serverIP = serverIP;
        /* Create a user thread to do the real work */
        netthread = sceKernelCreateThread("net_thread", net_thread, 0x18, 0x10000, PSP_THREAD_ATTR_USER, NULL);

        if(netthread < 0)
        {
            printf("Error, could not create thread\n");
            sceKernelSleepThread();
        }

        sceKernelStartThread(netthread, 0, NULL);
        return netthread;
    }
#endif
    return 0;
}
Пример #4
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 );
}
Пример #5
0
static int cpu_thread_entry(SceSize args, void* argp)
{
   sceKernelSleepThread();

   execute_arm_translate(reg[EXECUTE_CYCLES]);

   return 0;
}
Пример #6
0
/* Simple thread */
int main_thread(SceSize args, void *argp)
{
	initialise(args, argp);

	shellParseThread(0, NULL);
	sceKernelSleepThread();

	return 0;
}
Пример #7
0
int main()
{
  SetupCallbacks();

  initLanguage();
  initLevel();
  initGame();
  initDisp();

  sceKernelSleepThread();
  return 0;
}
Пример #8
0
int main(int argc, char *argv[])
{
	pspDebugScreenInit();
	if (argc > 0) {
		printf("Bootpath: %s\n", argv[0]);
	}
	SetupCallbacks();
	printf("\nMain Thread Status:\n");
	dump_threadstatus();
	sceKernelSleepThread();

	return 0;
}
Пример #9
0
int main(){	
pspDebugScreenInit();
SetupCallbacks(); 
	printf("I Love you Mariah!");
	printf("I Love you Mariah!");
	printf("I Love you Mariah!");
	printf("I Love you Mariah!");
	printf("I Love you Mariah!");
	printf("I Love you Mariah!");
	printf("I Love you Mariah!");
	printf("I Love you Mariah!");
	sceKernelSleepThread(); 
	return 0;
}
Пример #10
0
int main(int argc, char **argv)
{
	int i;
	
	printf(WELCOME_MESSAGE);

	for(i = 0; i < argc; i++)
	{
		printf("Arg %d: %s\n", i, argv[i]);
	}

	sceKernelSleepThread();

	return 0;
}
Пример #11
0
void pspAudioSetChannelCallback(int channel, pspAudioCallback_t callback, void *pdata)
{
	
	
  volatile psp_audio_channelinfo *pci = &AudioStatus[channel];
  if (callback == 0)
  { 
   deletingthread = sceKernelGetThreadId();;
   pci->callback = 0;
   sceKernelSleepThread();
  }
	else {
	pci->callback=callback;
  sceKernelWakeupThread(pci->threadhandle);
  }
}
Пример #12
0
static int MP3Thread(SceSize args, void *argp)
{
	while (mp3_active)
	{
		sceKernelSleepThread();

		if (mp3_newfile)
		{
			mp3_newfile = 0;

			mp3_running = 1;
			MP3Update();
			mp3_running = 0;
		}
	}

	return 0;
}
Пример #13
0
int main(int argc, char* argv[])
{
  SetupCallbacks();
  #ifdef DEBUG
    usbStorage();
  #endif

  strcpy(cwd,argv[0]);
  cwd[strlen(cwd)-strlen("/eboot.pbp")] = '\0';

  configLoad();
  initLanguage();
  initAudio();
  initLua();
  initGame();
  initDisp();

  sceKernelSleepThread();
  return 0;
}
Пример #14
0
int receiveMbxThread(SceSize args, void *argp) {
	while (!done) {
		sceKernelSleepThread();

		MyMessage *msg;
		int result = sceKernelReceiveMbx(mbxId, (void **) &msg, NULL);
		pspDebugScreenPrintf("sceKernelReceiveMbx = 0x%08X\n", result);
		if (result == 0) {
			pspDebugScreenPrintf(" msg = 0x%08X\n", (int) msg);
			pspDebugScreenPrintf(" msg.header.next = 0x%08X\n", (int) msg->header.next);
			pspDebugScreenPrintf(" msg.header.msgPriority = %d\n", msg->header.msgPriority);
			pspDebugScreenPrintf(" msg.header.dummy[3] = 0x%02X 0x%02X 0x%02X\n", msg->header.dummy[0], msg->header.dummy[1], msg->header.dummy[2]);
			pspDebugScreenPrintf(" msg.text = '%s'\n", msg->text);
			free(msg);
			printMbxStatus(mbxId);
		}
	}

	return 0;
}
Пример #15
0
static int AudioChannelThread(int args, void *argp)
{
	volatile int bufidx=0;
	int channel=*(int *)argp;
	
	while (audio_terminate==0) {
		void *bufptr=&audio_sndbuf[channel][bufidx];
		pspAudioCallback_t callback;
		callback=AudioStatus[channel].callback;
		if (callback) {
		  char*c = bufptr;
		  
		  c[0]='s';
		  c[1]='I';
		  c[2]='b';
		  c[3]='E';
		  
			callback(bufptr, PSP_NUM_AUDIO_SAMPLES, AudioStatus[channel].pdata);
			
			
			if (c[0] != 's'+10 ||
				  c[1] != 'I'+10 ||
				  c[2] != 'b'+10 ||
				  c[3] != 'E'+10 )
      pspAudioOutBlocking(channel,AudioStatus[channel].volumeleft,AudioStatus[channel].volumeright,bufptr);
		} else { 
      sceKernelWakeupThread(deletingthread);
      sceKernelSleepThread();
   //   pspAudioOutBlocking(channel,AudioStatus[channel].volumeleft,AudioStatus[channel].volumeright,audio_zerobuf);
      
      
      
    }

		
    bufidx=(bufidx?0:1);
		
	}
	sceKernelExitThread(0);
	return 0;
}
Пример #16
0
int main(void) {
    unsigned char buffer[0x1e]; /* Buffer */

    pspDebugScreenInit();
    SetupCallbacks();

    pspDebugScreenPrintf("Idstorage sample by harleyg\nThanks to Dark_AleX and Mathieulh\n\n");
    /* Read idstorage key 0x050 (serial) */
    sceIdStorageLookup(0x050, 0x0, buffer, 0x1e); /* key, offset, buffer, length */

    /* Print the serial */
    pspDebugScreenPrintf("Serial: %c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c",
                         buffer[0], buffer[1], buffer[2], buffer[3], buffer[4], buffer[5],
                         buffer[6], buffer[7], buffer[8], buffer[9], buffer[10], buffer[11],
                         buffer[12], buffer[13], buffer[14], buffer[15], buffer[16], buffer[17],
                         buffer[18], buffer[19], buffer[20], buffer[21], buffer[22], buffer[23],
                         buffer[24], buffer[25], buffer[26], buffer[27], buffer[28], buffer[29]);

    sceKernelSleepThread();
    return 0;
}
Пример #17
0
int main() 
{
	//call psp stuff
	pspDebugScreenInit();
    SetupCallbacks();
    initGraphics();
    
	char bafer[200];
	
	//Image definido no graphics.h
    Image* nossaImage;
	
	//joga caminho no bafer
	sprintf(bafer, "media/prince_ascii.png");
	nossaImage = loadImage(bafer);
    
    	//checar se imagem existe!!
    	if (!nossaImage) 
    	{
        	//Image load failed
        	printf("Ta lah nao! \n");
        } 
        else 
        {
        	
        	int x = 0;
            int y = 0;
            
            sceDisplayWaitVblankStart();
                      
           	blitAlphaImageToScreen(0 ,0 , 480, 272, nossaImage, x, y);
            
            flipScreen();
            
         } 
	
	sceKernelSleepThread();
    return 0;
}
Пример #18
0
int main() {
    pspDebugScreenInit();
    SetupCallbacks();
    scePowerSetClockFrequency(333, 333, 166);
    
    pspAudioInit();
    SceCtrlData pad;
    int i;

    tzset();
    printf("Hello World\n");
    time_t now;
    now = time(NULL);
    printf("Started %s\n", ctime(&now));

    MP3_Init(1);
    MP3_Load("test.mp3");
    MP3_Play();
    while(1) {
            sceCtrlReadBufferPositive(&pad, 1);
            if(pad.Buttons & PSP_CTRL_CROSS) {
                      break;
            } else if(pad.Buttons & PSP_CTRL_CIRCLE) {
                      MP3_Pause();
                      for(i=0; i<10; i++) {
                                sceDisplayWaitVblankStart();
                      }
            }

            if (MP3_EndOfStream() == 1) {
                      MP3_Stop();
            }
    }
    MP3_Stop();
    MP3_FreeTune();
    sceKernelSleepThread();
    return 0;
    }
Пример #19
0
void *orpGetValue(char *key, SceSize *key_size)
{
	void *value = NULL;

	REGHANDLE rh;
	struct RegParam reg = {
		.regtype = 1,
		.namelen = strlen(SYSTEM_REGISTRY),
		.unk2 = 1,
		.unk3 = 1,
	};
	strcpy(reg.name, SYSTEM_REGISTRY);

	int rc;
	if ((rc = sceRegOpenRegistry(&reg, 1, &rh)) < 0) {
		printf("Error opening registry.\n");
		return value;
	}

	REGHANDLE cat;
	if ((rc = sceRegOpenCategory(rh, "/CONFIG/PREMO", 1, &cat)) < 0) {
		printf("Error opening: /CONFIG/PREMO\n");
		goto _orpGetValue_exit1;
	}

	unsigned int key_type;
	if ((rc = sceRegGetKeyInfoByName(cat, key, &key_type, key_size)) < 0)
		printf("Key info failed: %s: %d\n", key, rc);
	else {
//		printf("%s: type: %d, size: %d\n", key, key_type, *key_size);
		value = malloc(*key_size);
		if ((rc = sceRegGetKeyValueByName(cat, key, value, *key_size)) < 0) {
			free(value);
			value = NULL;
			printf("Key look-up failed: %s\n", key);
			goto _orpGetValue_exit2;
		}
	}

_orpGetValue_exit2:
	sceRegCloseCategory(cat);

_orpGetValue_exit1:
	sceRegCloseRegistry(rh);
	return value;
}

int main()
{
	pspDebugScreenInit();
	SetupCallbacks();

	printf("Open Remote Play Exporter!\n\n");

	int rc;
	struct orpConfigRecord_t record;
	memset(&record, 0, sizeof(struct orpConfigRecord_t));
	record.ps3_port = ORP_PORT;
	strcpy((char *)record.ps3_hostname, "0.0.0.0");

	SceSize key_size;
	unsigned char *value;
	if ((value = orpGetValue("ps3_name", &key_size)) != NULL) {
		printf("%16s: %s\n", "Name", value);
		strncpy((char *)record.ps3_nickname,
			(const char *)value, ORP_NICKNAME_LEN);
		free(value);
	} else {
		printf("This PSP has not been registered for Remote Play!\n");
		printf("\nPress HOME to quit.\n");

		sceKernelSleepThread();
		return 0;
	}

	if ((rc =
		sceUtilityGetSystemParamString(PSP_SYSTEMPARAM_ID_STRING_NICKNAME,
		(char *)record.psp_owner, ORP_NICKNAME_LEN)) == 0) {
		printf("%16s: %s\n", "PSP Owner", record.psp_owner);
	}

	if ((value = orpGetValue("ps3_mac", &key_size)) != NULL) {
		printf("%16s: ", "PS3 MAC Address");
		int i;
		for (i = 0; i < key_size - 1; i++)
			printf("%02x:", value[i]);
		printf("%02x\n", value[key_size - 1]);
		memcpy(record.ps3_mac, value, ORP_MAC_LEN);
		free(value);
	}

	u8 mac[8];
	if ((rc = sceWlanGetEtherAddr(mac)) == 0) {
		printf("%16s: ", "PSP MAC Address");
		int i;
		memcpy(record.psp_mac, mac, ORP_MAC_LEN);
		for (i = 0; i < ORP_MAC_LEN - 1; i++)
			printf("%02x:", record.psp_mac[i]);
		printf("%02x\n", record.psp_mac[ORP_MAC_LEN - 1]);
	}

	PspOpenPSID psid;
	memset(&psid, 0, sizeof(psid));
	if ((rc = sceOpenPSIDGetOpenPSID(&psid) == 0)) {
		printf("%16s: ", "PSP ID");
		int i;
		for (i = 0; i < sizeof(psid.data) - 1; i++)
			printf("%02x", psid.data[i]);
		printf("%02x\n", psid.data[sizeof(psid.data) - 1]);
		memcpy(record.psp_id, psid.data, ORP_KEY_LEN);
	}

	if ((value = orpGetValue("ps3_key", &key_size)) != NULL) {
		printf("%16s: ", "Private Key");
		int i;
		for (i = 0; i < key_size; i++)
			printf("%02x", value[i]);
		printf("\n");
		memcpy(record.pkey, value, ORP_KEY_LEN);
		free(value);
	}

	char path[] = { "ms0:/export.orp" };
	sceIoRemove(path);
	SceUID fd = sceIoOpen(path,
		PSP_O_WRONLY | PSP_O_CREAT, 0777);
	if (fd < 0)
		printf("\nUnable to open: %s\n", path);
	else {
		struct orpConfigHeader_t header;
		memset(&header, 0, sizeof(struct orpConfigHeader_t));
		header.magic[0] = 'O'; header.magic[1] = 'R'; header.magic[2] = 'P';
		header.version = ORP_CONFIG_VER;
		header.flags = ORP_CONFIG_EXPORT;
		sceIoWrite(fd, &header, sizeof(struct orpConfigHeader_t));
		sceIoWrite(fd, &record, sizeof(struct orpConfigRecord_t));
		sceIoClose(fd);
		printf("\nConfiguration saved to: %s\n", path);
	}

	printf("\nPress HOME to quit.\n");

	sceKernelSleepThread();
	return 0;
}
Пример #20
0
static inline void switch_to_cpu_thread(void)
{
   sceKernelWakeupThread(cpu_thread);
   sceKernelSleepThread();
}
Пример #21
0
int slumberFunc(SceSize argc, void *argv) {
	sceKernelSleepThread();
	schedf(" ** slumber woke up\n");
	return 8;
}
Пример #22
0
int main(int argc, char *argv[])
{
	SceUID thid;
	int error;
	void *data;

	pspDebugScreenInit();
	if (argc > 0) {
		printf("Bootpath: %s\n", argv[0]);
	}
	SetupCallbacks();

	/* Create a messagebox */
	myMessagebox = sceKernelCreateMbx("pspSDK-testMBX", 0, 0);
	printf("MAIN: created messagebox %08x\n", myMessagebox);

	/* Create a task that will post in the messagebox */
	thid = sceKernelCreateThread("subthread", SubThread, 17, 8192, THREAD_ATTR_USER, 0);
	sceKernelStartThread(thid, 0, NULL);
	printf("MAIN: started task %08x\n", thid);

	/* Wait for a message */
	printf("MAIN: waiting for message\n");
	error = sceKernelReceiveMbx(myMessagebox, &data, NULL);
	if(error < 0)
		printf("MAIN: ERROR %08x\n", error);
	else
		printf("MAIN: got message: \"%s\"\n", ((MyMessage *)data)->text);

	/* Wait for a message with timeout */
	printf("MAIN: waiting with timeout (will fail the first couple of times)\n");
	for(;;) {
		SceUInt timeout = 300000; /* microseconds */
		error = sceKernelReceiveMbx(myMessagebox, &data, &timeout);
		if(error < 0)
			printf("MAIN: ERROR %08x\n", error);
		else {
			printf("MAIN: got message: \"%s\" (timeout remaining %d us)\n",
			       ((MyMessage *)data)->text, timeout);
			break;
		}
	}

	/* Poll for messages */
	printf("MAIN: polling for message (non-blocking)\n");
	for(;;) {
		error = sceKernelPollMbx(myMessagebox, &data);
		if(error < 0) {
			printf("MAIN: ERROR %08x\n", error);
			/* Sleep for a little while to give the message
			   a chance to arrive */
			sceKernelDelayThread(300000);			
		} else {
			printf("MAIN: got message: \"%s\"\n", ((MyMessage *)data)->text);
			break;
		}		
	}

	/* This call to sceKernelReceiveMbx() will be interrupted
	   by the sub task without a message being sent */
	printf("MAIN: waiting for a message that will not arrive\n");
	error = sceKernelReceiveMbx(myMessagebox, &data, NULL);
	if(error < 0)
		printf("MAIN: ERROR %08x\n", error);
	else
		printf("MAIN: got message: \"%s\"\n", ((MyMessage *)data)->text);	

	/* Prepare to shutdown */
	printf("MAIN: waiting for sub task to exit\n");
	sceKernelWaitThreadEnd(thid, NULL);
	printf("MAIN: sub task exited, deleting messagebox\n");
	error = sceKernelDeleteMbx(myMessagebox);
	if(error < 0)
		printf("MAIN: ERROR %08x\n", error);
	else
		printf("MAIN: all done\n");

	sceKernelSleepThread();

	return 0;
}
Пример #23
0
int main_thread( SceSize args, void *argp )
{
	char ip[16], * argv[5];
	int port, entry;
	parseArgs( argv, args, ( char * )argp );
	//sceUtilityGetNetParam
	strcpy( ip, argv[1] );
	port = atoi( argv[2] );
	entry = atoi( argv[3] );
	block_size = atoi( argv[4] );
	log( "%s:%d entry %d\n", ip, port, entry );
	
	/*ctrl_opts.inited = sceUtilityLoadNetModule( PSP_NET_MODULE_COMMON );
	if ( ctrl_opts.inited != 0 )
	{
		log( "Error loading Net modules (0x%08x)\n", ctrl_opts.inited );
		goto net_term;
	}
	ctrl_opts.inited = sceUtilityLoadNetModule( PSP_NET_MODULE_INET );
	if ( ctrl_opts.inited != 0 )
	{
		log( "Error loading iNet module (0x%08x)\n", ctrl_opts.inited );
		goto net_term;
	}*/
	ctrl_opts.inited = sceNetInit( 0x10000, 0x20, 0x1000, 0x20, 0x1000 );
	if ( ctrl_opts.inited != 0 )
	{
		log( "Error Initing pspnet (0x%08x)\n", ctrl_opts.inited );
		goto net_term;
	}
	ctrl_opts.inited = sceNetInetInit();
	if ( ctrl_opts.inited != 0 )
	{
		log( "Error initing Inet (0x%08x)\n", ctrl_opts.inited );
		goto net_term;
	}
	ctrl_opts.inited = sceNetResolverInit();
	if( ctrl_opts.inited != 0 )
	{
		log( "Error initing Resolver (0x%08x)\n", ctrl_opts.inited );
		goto net_term;
	}
	ctrl_opts.inited = sceNetApctlInit( 0x1400, 0x42 );
	if ( ctrl_opts.inited != 0 )
	{
		log( "Error initing Apctl (0x%08x)\n", ctrl_opts.inited );
		goto net_term;
	}
	log( "pspnet init OK!\n" );
	
	ctrl_opts.inited = connectApctl( entry );
	if ( ctrl_opts.inited != 0 )
	{
		log( "Error connecting Apctl (0x%08x)\n", ctrl_opts.inited );
		goto net_term;
	}
	
	ctrl_opts.inited = connectSocket( ip, ( unsigned short )port );
	if ( ctrl_opts.inited != 0 )
	{
		log( "Error connecting Socket\n" );
		goto net_term;
	}
	ctrl_opts.inited = 1;
	
	sceKernelSleepThread();
	
net_term:
	log( "stopping wifi...\n" );
	disconnectSocket();
	disconnectApctl();
	sceNetApctlTerm();
	sceNetResolverTerm();
	sceNetInetTerm();
	sceNetTerm();
	//sceUtilityUnloadNetModule( PSP_NET_MODULE_INET );
	//sceUtilityUnloadNetModule( PSP_NET_MODULE_COMMON );
	ctrl_opts.thid = -1;
	ctrl_opts.inited = -1;
	return sceKernelExitDeleteThread( 0 );
}
Пример #24
0
int video_thread(SceSize args, void *argp) {
	// Pixel coordinates: first = first luminant pixel to breach threshhold, last = ..., mid = ...
	Coord first, last, mid;
	int bufsize; int threshold = 200; // Luminance threshold.
	int showvideo = 0; // Show the actual video input? 0: No, 1: Yes

	// Camera buffers.
	PspUsbCamSetupVideoParam videoparam;
	static u8  buffer[MAX_STILL_IMAGE_SIZE] __attribute__((aligned(64)));
	static u8  work[68*1024] __attribute__((aligned(64)));
	static u32 framebuffer[480*272] __attribute__((aligned(64)));

	// Startup cursor position.
	cursor.x = 237, cursor.y = 50; old.x = 237, old.y = 50;

	// Setup the screenmap size and position.
	screenmap.x = 20; screenmap.y = 200;
	screenmap.w = 60; screenmap.h = 60;
	screenmap.gridcolor = 0xFFC09090;
	screenmap.fillcolor = 0xFFF0F0F0;
	screenmap.selcolor = 0xFFC0FFFF;

	// Create a start button.
	Button btnStart;
	btnStart.x = 420; btnStart.y = 250;
	btnStart.w = 50; btnStart.h = 12;
	btnStart.fillcolor = 0xFF00FFFF;
	btnStart.textcolor = 0xFF000000;
	btnStart.bordercolor = 0xFF000000;
	btnStart.shadowcolor = 0xFF888888;
	btnStart.bordersize = 1;
	btnStart.borderbevel = 0;
	btnStart.shadowsize = 0;
	btnStart.shadowdistance = 0;
	strcpy(btnStart.text, "Start");
	strcpy(btnStart.name, "btnStart");

	// Wait for camera to be connected.
	while (!connected) {
		clearScreen(0xFFF0F0F0);
		printTextScreenCenter(132, "Please connect the camera and press any button.", 0xFF009900);
		flipScreen(); sceDisplayWaitVblankStart();
		sceKernelDelayThread(20000);
	}

	// Load the camera modules and start the decoder.
	if (LoadModules() < 0) sceKernelSleepThread();
	if (StartUsb() < 0) sceKernelSleepThread();
	if (sceUsbActivate(PSP_USBCAM_PID) < 0) sceKernelSleepThread();
	if (InitJpegDecoder() < 0) sceKernelSleepThread();
	while (1) {
		if ((sceUsbGetState() & 0xF) == PSP_USB_CONNECTION_ESTABLISHED) break;
		sceKernelDelayThread(50000);
	}

	//Setup video parameters and start video capture.
	memset(&videoparam, 0, sizeof(videoparam));
	videoparam.size = sizeof(videoparam);
	videoparam.resolution = PSP_USBCAM_RESOLUTION_480_272;
	videoparam.framerate = PSP_USBCAM_FRAMERATE_30_FPS;
	videoparam.wb = PSP_USBCAM_WB_INCANDESCENT;
	videoparam.saturation = 125;
	videoparam.brightness = 100;
	videoparam.contrast = 64;
	videoparam.sharpness = 0;
	videoparam.effectmode = PSP_USBCAM_EFFECTMODE_NORMAL;
	videoparam.framesize = MAX_VIDEO_FRAME_SIZE;
	videoparam.evlevel = PSP_USBCAM_EVLEVEL_0_0;	
	if (sceUsbCamSetupVideo(&videoparam, work, sizeof(work)) < 0) sceKernelExitDeleteThread(0);
	sceUsbCamAutoImageReverseSW(1);
	if (sceUsbCamStartVideo() < 0) sceKernelExitDeleteThread(0);

	while (running) {
		int i, j, lum = 0, tracking = 0;
		first.x = 0; first.y = 0; last.x = 0; last.y = 0; mid.x = old.x; mid.y = old.y;
		clearScreen(0xFFFFFFFF);

		// Capture the camera image into the framebuffer.
		bufsize = sceUsbCamReadVideoFrameBlocking(buffer, MAX_VIDEO_FRAME_SIZE);
		if (bufsize > 0) sceJpegDecodeMJpeg(buffer, bufsize, framebuffer, 0);

		// Analyze the camera image.
		for (i = 0; i < 272; i++) {
			for (j = 0; j < 480; j++) {
				if (showvideo) putPixelScreen(framebuffer[i * CAM_LINE_SIZE + j], j, i); // Show video input.
				// Calculate luminance (brightness as perceived by the eye) and compare versus threshhold. 
				lum = (299 * R(framebuffer[i * CAM_LINE_SIZE + j]) + 587 * G(framebuffer[i * CAM_LINE_SIZE + j]) + 114 * B(framebuffer[i * CAM_LINE_SIZE + j])) / 1000;
				if (lum > threshold) {
					tracking = 1; if (aligned) putPixelScreen(0xFF0000FF, j, i);
					if ((first.x == 0) || (j < first.x)) first.x = j;
					if ((first.y == 0) || (i < first.y)) first.y = i;
					if ((last.x == 0) || (j > last.x)) last.x = j;
					if ((last.y == 0) || (i > last.y)) last.y = i;
				}
			}
		}

		if (tracking) {
			// Calculate directional movement and determine cursor position.
			mid.x = first.x + (abs((last.x - first.x)) / 2); mid.y = first.y + (abs((last.y - first.y)) / 2);
			checkDirection(mid, old);
			switch (direction) {
				case 0: cursor.x = old.x; cursor.y = old.y; break;
				case 1: cursor.x = first.x; cursor.y = first.y + (abs((last.y - first.y)) / 2); break;
				case 2: cursor.x = first.x; cursor.y = first.y; break;
				case 3: cursor.x = first.x + (abs((last.x - first.x)) / 2); cursor.y = first.y; break;
				case 4: cursor.x = last.x; cursor.y = first.y; break;
				case 5: cursor.x = last.x; cursor.y = first.y + (abs((last.y - first.y)) / 2); break;
				case 6: cursor.x = last.x; cursor.y = last.y; break;
				case 7: cursor.x = first.x + (abs((last.x - first.x)) / 2); cursor.y = last.y; break;
				case 8: cursor.x = first.x; cursor.y = last.y; break;		
			};
			
			//Uncomment the following lines to draw 'directional' markers on screen.
			/*if ((abs(last.x - first.x) > 15) || (abs(last.y - first.y) > 15)) {
				if ((direction > 0) && (direction <= 4)) {
					drawLineScreen(first.x, first.y, last.x, last.y, 0xFFC0C0C0);
				} else {
					drawLineScreen(last.x, last.y, first.x, first.y, 0xFFC0C0C0);
				}
				switch (direction) {
					case 0: break;
					case 1: drawLineScreen(last.x, last.y + ((last.y - first.y) / 2), first.x, first.y + ((last.y - first.y) / 2), 0xFFC0C0C0); break; // W
					case 2: drawLineScreen(last.x, last.y, first.x, first.y, 0xFFC0C0C0); break; // NW
					case 3: drawLineScreen(first.x + ((last.x - first.x) / 2), last.y, first.x + ((last.x - first.x) / 2), first.y, 0xFFC0C0C0); break; // N
					case 4: drawLineScreen(first.x, last.y, last.x, first.y, 0xFFC0C0C0); break; // NE
					case 5: drawLineScreen(first.x, first.y + ((last.y - first.y) / 2), last.x, first.y + ((last.y - first.y) / 2), 0xFFC0C0C0); break; // E
					case 6: drawLineScreen(first.x, first.y, last.x, last.y, 0xFFC0C0C0); break; // SE
					case 7: drawLineScreen(first.x + ((last.x - first.x) / 2), first.y, first.x + ((last.x - first.x) / 2), last.y, 0xFFC0C0C0); break; // S
					case 8: drawLineScreen(last.x, first.y, first.x, last.y, 0xFFC0C0C0); break; // SW
				};
				drawLineScreen((first.x > last.x) ? last.x : first.x, (first.y > last.y) ? last.y : first.y, (first.x < last.x) ? last.x : first.x, (first.y < last.y) ? last.y : first.y, 0xFFC0C0C0);
			} else {
				drawRectScreen(0xFFC0C0C0, first.x, first.y, last.x - first.x, last.y - first.y);
			}*/
		} else {
			printTextScreenCenter(10, "Please return to the playing area.", 0xFF0000FF);
			if (lastdirection == 0) { cursor.x = old.x; cursor.y = old.y; }
			//if ((aligned) && (!menu) && (_gameState = GAME_RUNNING)) HandlePauseGame();
		}

		if (!aligned) {
			showvideo = 1;
			// Alignment Screen: wait for camera to be aligned to the playing area.
			printTextScreenCenter(126, "Please align the camera to the playing area.", 0xFFFFFFFF);
			printTextScreenCenter(136, "Drag the cursor to the \"Start\" button to continue.", 0xFFFFFFFF);

			if (checkCoordButton(cursor, btnStart)) { btnStart.fillcolor = 0xFF00FF00; aligned = 1; menu = 1; }
			drawButtonScreen(btnStart);
			if (aligned) { btnStart.fillcolor = 0xFF00FFFF; btnStart.x = 240 - (btnStart.w / 2); btnStart.y = 200; }
		} else if (menu) {
			showvideo = 0;
			// Menu Screen: show a splash, logo, menu, etc.
			printTextScreenCenter(126, "eyePSP Pong", 0xFF009900);
			printTextScreenCenter(136, "Please press the \"Start\" button to continue.", 0xFFFF0000);

			if (checkCoordButton(cursor, btnStart)) { btnStart.fillcolor = 0xFFC0FFC0; menu = 0; }
			drawButtonScreen(btnStart);
		} else {
			// Draw any game objects here.
			if (_gameState == GAME_PAUSED) {
				printTextScreenCenter(100, "Game Paused", COLOR_RED);
				if (tracking) _gameState = GAME_RUNNING;
			} else if (_gameState == GAME_RUNNING) {
				DrawMainText(); // Draw main graphics and supporting text to the screen.
				DrawPaddle(&_paddle); // Draws the paddle to the screen
			} else if (_gameState == GAME_CONTINUE) {
				char sbuffer[50];
				sprintf(sbuffer, "%d Ball%s Remaining...", _resBalls, (_resBalls == 1) ? "" : "s");
				printTextScreenCenter(100, sbuffer, 0xFF000088);

				if (checkCoordButton(cursor, btnStart)) { btnStart.fillcolor = 0xFFC0FFC0; _gameState = GAME_RUNNING; }
				drawButtonScreen(btnStart);
			} else if (_gameState == GAME_OVER) {
				// Draws game over graphics and waits for user to continue
				DrawGameOverMenu();

				if (checkCoordButton(cursor, btnStart)) { btnStart.fillcolor = 0xFFC0FFC0; _gameState = GAME_RUNNING; }
				drawButtonScreen(btnStart);
			}
		}

		// Draw cursor (within boundaries) .
		if (tracking) {
			for (i = cursor.y - 5; i <= cursor.y + 5; i++) { if ((i > 0) && (i < 272)) putPixelScreen(!tracking ? 0xFF0000FF : 0xFF009900, cursor.x, i); } // y-axis
			for (j = cursor.x - 5; j <= cursor.x + 5; j++) { if ((j > 0) && (j < 480)) putPixelScreen(!tracking ? 0xFF0000FF : 0xFF009900, j, cursor.y); } // x-axis
		}

		old.x = cursor.x; old.y = cursor.y; lastdirection = direction;
		flipScreen(); sceDisplayWaitVblankStart();
		sceKernelDelayThread(2000);
	}
	sceKernelExitDeleteThread(0);
	return 0;	
}
Пример #25
0
void switch_to_main_thread(void)
{
   sceKernelWakeupThread(main_thread);
   sceKernelSleepThread();
}
Пример #26
0
static void MP3Update(void)
{
	int flip;
	UINT8 *GuardPtr;
	INT16 *OutputPtr, *OutputEnd;
	struct mad_stream Stream;
	struct mad_frame Frame;
	struct mad_synth Synth;
	mad_timer_t Timer;

	mad_stream_init(&Stream);
	mad_frame_init(&Frame);
	mad_synth_init(&Synth);
	mad_timer_reset(&Timer);

	OutputPtr = (INT16 *)mp3_out[0];
	OutputEnd = (INT16 *)(mp3_out[0] + MP3_BUFFER_SIZE);
	GuardPtr = NULL;

	mp3_filepos = 0;
	mp3_frame = 0;
	flip = 0;
	cdda_command_ack = 1;

	while (mp3_active && mp3_status != MP3_STOP)
	{
		if (Stream.buffer == NULL || Stream.error == MAD_ERROR_BUFLEN)
		{
			UINT32 ReadSize, Remaining;
			UINT8 *ReadStart;

			if (Stream.next_frame != NULL)
			{
				Remaining = Stream.bufend - Stream.next_frame;
				ReadStart = mp3_in + Remaining;
				ReadSize  = (2 * MP3_BUFFER_SIZE) - Remaining;
				memmove(mp3_in, Stream.next_frame, Remaining);
			}
			else
			{
				ReadSize  = 2 * MP3_BUFFER_SIZE;
				ReadStart = mp3_in;
				Remaining = 0;
			}

			if (MP3SleepCheck()) break;

			ReadSize = sceIoRead(mp3_fd, ReadStart, ReadSize);
			mp3_filepos += ReadSize;
			if (mp3_filepos == mp3_fsize)
			{
				if (cdda_autoloop)
				{
					mp3_filepos = 0;
					sceIoLseek(mp3_fd, 0, PSP_SEEK_SET);
				}
				else
				{
					cdda_playing = CDDA_STOP;
					mp3_status = MP3_STOP;
				}
			}

			if (mp3_filepos == mp3_fsize)
			{
				GuardPtr = ReadStart + ReadSize;
				memset(GuardPtr, 0, MAD_BUFFER_GUARD);
				ReadSize += MAD_BUFFER_GUARD;
			}

			mad_stream_buffer(&Stream, mp3_in, ReadSize + Remaining);

			Stream.error = 0;
		}

		if (mad_frame_decode(&Frame, &Stream))
		{
			if (MAD_RECOVERABLE(Stream.error))
			{
//				if (Stream.error != MAD_ERROR_LOSTSYNC || Stream.this_frame != GuardPtr)
				continue;
			}
			else if (Stream.error == MAD_ERROR_BUFLEN)
			{
				continue;
			}
			else
			{
				ui_popup(TEXT(MP3_DECODE_ERROR));
				mp3_status = MP3_STOP;
				break;
			}
		}

		mp3_frame++;
		mad_timer_add(&Timer, Frame.header.duration);
		mad_synth_frame(&Synth, &Frame);

		if (mp3_status == MP3_PLAY)
		{
			int i;

			for (i = 0; i < Synth.pcm.length; i++)
			{
				if (MAD_NCHANNELS(&Frame.header) == 2)
				{
					*OutputPtr++ = MP3Limit(Synth.pcm.samples[0][i]);
					*OutputPtr++ = MP3Limit(Synth.pcm.samples[1][i]);
				}
				else
				{
					INT16 data = MP3Limit(Synth.pcm.samples[0][i]);

					*OutputPtr++ = data;
					*OutputPtr++ = data;
				}

				if (OutputPtr == OutputEnd)
				{
					sceAudioOutputPannedBlocking(mp3_handle, mp3_volume, mp3_volume, mp3_out[flip]);
					flip ^= 1;
					OutputPtr = (INT16 *)mp3_out[flip];
					OutputEnd = (INT16 *)(mp3_out[flip] + MP3_BUFFER_SIZE);
				}
			}
		}
		else if (mp3_status == MP3_SEEK)
		{
			if (mp3_frame >= mp3_start_frame)
			{
				mp3_start_frame = 0;
				mp3_status = MP3_SLEEP;
				sceKernelSleepThread();
			}
		}
	}

	mad_synth_finish(&Synth);
	mad_frame_finish(&Frame);
	mad_stream_finish(&Stream);

	if (mp3_fd >= 0)
	{
		sceIoClose(mp3_fd);
		mp3_fd = -1;
	}
}
Пример #27
0
int sleepingThread(SceSize args, void *argp)
{
    sceKernelSleepThread();
    strcat(msg, "Sleeping Thread\n");
    return 0;
}
Пример #28
0
int main_thread(SceSize args, void *argp) {
sceKernelDelayThread(3000000);
        u32 keycombination;
    SceCtrlData pad;
    u32 oldButtons = 0;
       int extra = 0;
         keycombination = PSP_CTRL_RTRIGGER; //Button to start interpreter (Basic)
         u32 keycombination2 = PSP_CTRL_RTRIGGER + PSP_CTRL_LTRIGGER; // Button to start interpreter (Extra PSP Go)
        while(1){
            oldButtons = pad.Buttons;
            if (go==0){
             sceCtrlPeekBufferPositive(&pad, 1);
                          if(oldButtons != pad.Buttons)
                          {
            if(pad.Buttons & keycombination2)
			{
			pauseGame(thid1);
                    go=1;
					extra=1;
                    pspDebugScreenInit();
                    pspDebugScreenClear();
                    oldButtons = pad.Buttons;
			}else if(pad.Buttons & keycombination)
            {
                	pauseGame(thid1);
                    go=1;
                    pspDebugScreenInit();
                    pspDebugScreenClear();
                    oldButtons = pad.Buttons;
            }
            }
            }
                if (go ==1){
    pspDebugScreenSetXY(0,0);
    pspDebugScreenSetTextColor(0xffffff);
       
        int go2=1;
        SceUID id;
        if (((kuKernelGetModel() + 1) == 4) || ((kuKernelGetModel() + 1) == 5)){
		if (extra==1){
		id = sceIoDopen("ms0:/seplugins/script"); //PSP Go MS Support
		}else{
        id = sceIoDopen("ef0:/seplugins/script"); //PSP Go Internal HD Support
		}
        }else{
        id = sceIoDopen("ms0:/seplugins/script");
        }
                                 SceIoDirent entry;
                                 int script_files = -2;
                                 memset(&entry, 0, sizeof(SceIoDirent));
                             while (sceIoDread(id, &entry) > 0)
                                {
                                        script_files = script_files+1;
                                        memset(&entry, 0, sizeof(SceIoDirent));
                                }
                                sceIoDclose(id);
                                char script[256];
                                if (((kuKernelGetModel() + 1) == 4) || ((kuKernelGetModel() + 1) == 5)){
								if (extra==1){
								strcpy(script,"ms0:/seplugins/script/index.lua"); //PSP Go MS Support
								}else{
                                strcpy(script,"ef0:/seplugins/script/index.lua"); //PSP Go Internal HD Support
                                }
								}else{
                                 strcpy(script,"ms0:/seplugins/script/index.lua");
                                 }
        while(go2==1)
        {
                                 
                                const char *errMsg;
                                if (script_files>1){            
                                errMsg = runScript(extralibs, true);
                                }else{
    SceUID fp = sceIoOpen(script, PSP_O_RDONLY,0777);  
    int size = sceIoLseek(fp, 0, SEEK_END);
    sceIoLseek(fp, 0, SEEK_SET);
    unsigned char *buffer;
    buffer = malloc((size+1) * sizeof (char));
    sceIoRead(fp, buffer, size);
        buffer[size]=0;
    sceIoClose(fp);
    errMsg = runScript(buffer, true);
    free(buffer);
    }
	// System.restart sourcecode
	if (strstr(errMsg, "lpp_restart")){
    go2=0;
	// End System.restart sources
    // Temp replacing for loadfile/dofile functions: System.protodofile
    }else if (strstr(errMsg, "lpp_open")){
    char dum1[20], dum2[20], dum3[20];
    char script_path2[256];
    sscanf( errMsg, "%s %s %s %s", dum1, dum2, dum3, script_path2 );
    strcpy(script,script_path2);
    script_files=1;
    // End System.protodofile sources
                                }else if (strstr(errMsg, "resumeThread")){
                                go=0;
                                go2=0;
                                }else{
                if (errMsg != NULL);
                {
                                                pspDebugScreenClear();
                                                pspDebugScreenSetTextColor(0xffffff);
                        debugOutput("\nError: %s\n", errMsg);
                }
                debugOutput("\nPress start to restart\nPress select to resume thread\n");
                SceCtrlData pad;
               
                                int restore = 0;
                while(restore==0){
                                sceCtrlPeekBufferPositive(&pad, 1);
                                if (pad.Buttons&PSP_CTRL_START){
                                restore=1;
                                go2=0;
                                }
                                if (pad.Buttons&PSP_CTRL_SELECT){
                                resumeGame(thid1);
                                restore=1;
                                go=0;
                                go2=0;
                                }
                                }
                                }
        }


}
sceDisplayWaitVblankStart();
        }
       
        sceKernelSleepThread();
return 0;
}