External/pspsdk
1
0
Fork 0
mirror of https://github.com/pspdev/pspsdk.git synced 2026-01-04 22:30:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
Dan Peori
2010-10-18 12:54:49 -03:00
commit 8a3bef9012
612 changed files with 74685 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
src/samples/savedata/decrypt/Makefile.sample Normal file
View File

@@ -0,0 +1,20 @@
TARGET = main
OBJS = main.o decrypt.o
INCDIR =
CFLAGS = -O2 -G0 -Wall
CXXFLAGS = $(CFLAGS) -fno-exceptions -fno-rtti
ASFLAGS = $(CFLAGS)
LIBDIR =
LIBS = -lpspchnnlsv
LDFLAGS =
EXTRA_TARGETS = EBOOT.PBP
PSP_EBOOT_TITLE = Save Decrypt Sample
PSPSDK=$(shell psp-config --pspsdk-path)
include $(PSPSDK)/lib/build.mak
main.c : decrypt.h
decrypt.c : decrypt.h

5
src/samples/savedata/decrypt/README.txt Normal file
View File

@@ -0,0 +1,5 @@
This sample uses the sceChnnlsv module directly to do savegame
decryption. It currently works only in VSH mode (e.g., via the TIFF
exploit). It can handle both old and new format saves (SaveParam
structure sizes 0x5c8, 0x5dc, 0x600). New format saves require a
game-specific encryption key.

162
src/samples/savedata/decrypt/decrypt.c Normal file
View File

@@ -0,0 +1,162 @@
/*
* PSP Software Development Kit - http://www.pspdev.org
* -----------------------------------------------------------------------
* Licensed under the BSD license, see LICENSE in PSPSDK root for details.
*
* decrypt.c - Decryption routines using sceChnnlsv
*
* Copyright (c) 2005 Jim Paris <jim@jtan.com>
* Coypright (c) 2005 psp123
*
* $Id: decrypt.c 1562 2005-12-10 20:52:45Z jim $
*/
#include "decrypt.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>
#include <pspchnnlsv.h>
unsigned int align16(unsigned int v)
{
return ((v + 0xF) >> 4) << 4;
}
/* Read, decrypt, and write a savedata file. See main.c for example usage. */
int decrypt_file(const char *decrypted_filename,
const char *encrypted_filename,
const unsigned char *gamekey)
{
FILE *in, *out;
int len, aligned_len;
unsigned char *data, *cryptkey;
int retval;
/* Open file and get size */
if ((in = fopen(encrypted_filename, "r")) == NULL) {
retval = -1;
goto out;
}
fseek(in, 0, SEEK_END);
len = ftell(in);
fseek(in, 0, SEEK_SET);
if (len <= 0) {
retval = -2;
goto out1;
}
/* Allocate buffers */
aligned_len = align16(len);
if ((data = (unsigned char *) memalign(0x10, aligned_len)) == NULL) {
retval = -3;
goto out1;
}
if ((cryptkey = (unsigned char *) memalign(0x10, 0x10)) == NULL) {
retval = -4;
goto out2;
}
/* Fill buffers */
if (gamekey != NULL)
memcpy(cryptkey, gamekey, 0x10);
memset(data + len, 0, aligned_len - len);
if (fread(data, 1, len, in) != len) {
retval = -5;
goto out3;
}
/* Do the decryption */
if ((retval = decrypt_data( gamekey ? 3 : 1,
data, &len, &aligned_len,
gamekey ? cryptkey : NULL)) < 0) {
retval -= 100;
goto out3;
}
/* Write the data out. decrypt_data has set len correctly. */
if ((out = fopen(decrypted_filename, "w")) == NULL) {
retval = -6;
goto out3;
}
if (fwrite(data, 1, len, out) != len) {
retval = -7;
goto out4;
}
/* All done. Return file length. */
retval = len;
out4:
fclose(out);
out3:
free(cryptkey);
out2:
free(data);
out1:
fclose(in);
out:
return retval;
}
/* Do the actual hardware decryption.
mode is 3 for saves with a cryptkey, or 1 otherwise
data, dataLen, and cryptkey must be multiples of 0x10.
cryptkey is NULL if mode == 1.
*/
int decrypt_data(unsigned int mode,
unsigned char *data,
int *dataLen,
int *alignedLen,
unsigned char *cryptkey)
{
pspChnnlsvContext1 ctx1;
pspChnnlsvContext2 ctx2;
/* Need a 16-byte IV plus some data */
if (*alignedLen <= 0x10)
return -1;
*dataLen -= 0x10;
*alignedLen -= 0x10;
/* Set up buffers */
memset(&ctx1, 0, sizeof(pspChnnlsvContext1));
memset(&ctx2, 0, sizeof(pspChnnlsvContext2));
/* Perform the magic */
if (sceChnnlsv_E7833020(&ctx1, mode) < 0)
return -2;
if (sceChnnlsv_ABFDFC8B(&ctx2, mode, 2, data, cryptkey) < 0)
return -3;
if (sceChnnlsv_F21A1FCA(&ctx1, data, 0x10) < 0)
return -4;
if (sceChnnlsv_F21A1FCA(&ctx1, data + 0x10, *alignedLen) < 0)
return -5;
if (sceChnnlsv_850A7FA1(&ctx2, data + 0x10, *alignedLen) < 0)
return -6;
/* Verify that it decrypted correctly */
if (sceChnnlsv_21BE78B4(&ctx2) < 0)
return -7;
/* If desired, a new file hash from this PSP can be computed now:
if (sceChnnlsv_C4C494F8(ctx1, newhash, cryptkey) < 0)
return -8;
*/
/* The decrypted data starts at data + 0x10, so shift it back. */
memmove(data, data + 0x10, *dataLen);
/* All done */
return 0;
}

30
src/samples/savedata/decrypt/decrypt.h Normal file
View File

@@ -0,0 +1,30 @@
/*
* PSP Software Development Kit - http://www.pspdev.org
* -----------------------------------------------------------------------
* Licensed under the BSD license, see LICENSE in PSPSDK root for details.
*
* decrypt.h - Declarations for functions in decrypt.c
*
* Copyright (c) 2005 Jim Paris <jim@jtan.com>
* Coypright (c) 2005 psp123
*
* $Id: decrypt.h 1562 2005-12-10 20:52:45Z jim $
*/
#include <pspchnnlsv.h>
/* Detect the samegame format and decrypt it. See main.c for an example. */
int decrypt_file(const char *decrypted_filename,
const char *encrypted_filename,
const unsigned char *gamekey);
/* Do the actual hardware decryption.
mode is 3 for saves with a cryptkey, or 1 otherwise.
data, alignedLen, and cryptkey must be multiples of 0x10.
cryptkey is NULL if mode == 1.
*/
int decrypt_data(unsigned int mode,
unsigned char *data,
int *dataLen,
int *alignedLen,
unsigned char *cryptkey);

100
src/samples/savedata/decrypt/main.c Normal file
View File

@@ -0,0 +1,100 @@
/*
* PSP Software Development Kit - http://www.pspdev.org
* -----------------------------------------------------------------------
* Licensed under the BSD license, see LICENSE in PSPSDK root for details.
*
* main.c - Sample to demonstrate savedata decryption using sceChnnlsv
*
* Copyright (c) 2005 Jim Paris <jim@jtan.com>
* Coypright (c) 2005 psp123
*
* $Id: main.c 1996 2006-09-05 01:31:55Z jim $
*/
#include <pspkernel.h>
#include <pspctrl.h>
#include <pspdebug.h>
#include <pspdisplay.h>
#include <psptypes.h>
#include <psputility.h>
#include <stdio.h>
#include <string.h>
#include "decrypt.h"
PSP_MODULE_INFO("SaveDecrypt", 0, 1, 1);
#define printf pspDebugScreenPrintf
#if 0
/* Old format save with no key, supported by 1.0+ firmware */
const char *decrypted = "ms0:/PLAIN.BIN";
const char *encrypted = "ms0:/PSP/SAVEDATA/DATA111110000/DATA.BIN";
const unsigned char *gamekey = NULL;
#else
/* New format save with a key, supported by 2.0+ firmware */
const char *decrypted = "ms0:/PLAIN.BIN";
const char *encrypted = "ms0:/PSP/SAVEDATA/DATA222220000/DATA.BIN";
const unsigned char gamekey[] = {
0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
0xFA, 0xCA, 0xDE, 0x00, 0xDE, 0xAD, 0xBE, 0xEF
};
#endif
int waitbutton(int mask) {
SceCtrlData paddata;
do {
sceDisplayWaitVblankStart();
sceCtrlReadBufferPositive(&paddata, 1);
} while((paddata.Buttons & mask));
do {
sceDisplayWaitVblankStart();
sceCtrlReadBufferPositive(&paddata, 1);
} while(!(paddata.Buttons & mask));
return paddata.Buttons;
}
int main(int argc, char *argv[])
{
int i, ret;
pspDebugScreenInit();
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(PSP_CTRL_MODE_DIGITAL);
printf("Save Decrypt Sample\n");
printf("by Jim Paris and psp123\n\n");
printf("Will decrypt: %s\n", encrypted);
printf(" Using key:");
if(gamekey) {
for (i = 0; i < 0x10; i++)
printf(" %02x", gamekey[i]);
} else {
printf(" none");
}
printf("\n\n");
printf(" Output file: %s\n\n", decrypted);
printf("Press X to continue, or O to quit.\n\n");
if (waitbutton(PSP_CTRL_CROSS | PSP_CTRL_CIRCLE) & PSP_CTRL_CIRCLE)
goto out;
printf("Working...\n\n");
ret = decrypt_file(decrypted, encrypted, gamekey);
if(ret < 0) {
printf("Error: decrypt_file() returned %d\n\n", ret);
} else {
printf("Successfully wrote %d bytes to\n", ret);
printf(" %s\n\n", decrypted);
}
printf("Press any button to quit\n");
waitbutton(-1);
out:
sceKernelExitGame();
return 0;
}

23
src/samples/savedata/encrypt/Makefile.sample Normal file
View File

@@ -0,0 +1,23 @@
TARGET = main
OBJS = main.o encrypt.o hash.o psf.o
INCDIR =
CFLAGS = -O2 -G0 -Wall
CXXFLAGS = $(CFLAGS) -fno-exceptions -fno-rtti
ASFLAGS = $(CFLAGS)
LIBDIR =
LIBS = -lpspchnnlsv
LDFLAGS =
EXTRA_TARGETS = EBOOT.PBP
PSP_EBOOT_TITLE = Save Encrypt Sample
PSPSDK=$(shell psp-config --pspsdk-path)
include $(PSPSDK)/lib/build.mak
main.c : encrypt.h
encrypt.c : encrypt.h hash.h
hash.c : hash.h psf.h
psf.c : psf.h

5
src/samples/savedata/encrypt/README.txt Normal file
View File

@@ -0,0 +1,5 @@
This sample uses the sceChnnlsv module directly to do savegame
encryption. It currently works only in VSH mode (e.g., via the TIFF
exploit). It can handle both old and new format saves (SaveParam
structure sizes 0x5c8, 0x5dc, 0x600). New format saves require a
game-specific encryption key.

230
src/samples/savedata/encrypt/encrypt.c Normal file
View File

@@ -0,0 +1,230 @@
/*
* PSP Software Development Kit - http://www.pspdev.org
* -----------------------------------------------------------------------
* Licensed under the BSD license, see LICENSE in PSPSDK root for details.
*
* encrypt.c - Encryption routines using sceChnnlsv
*
* Copyright (c) 2005 Jim Paris <jim@jtan.com>
* Coypright (c) 2005 psp123
*
* $Id: encrypt.c 1560 2005-12-10 01:16:32Z jim $
*/
#include "encrypt.h"
#include "hash.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>
#include <pspchnnlsv.h>
static inline int align16(unsigned int v)
{
return ((v + 0xF) >> 4) << 4;
}
int fopen_getsize(const char *filename, FILE **fd, int *size)
{
if ((*fd = fopen(filename, "r")) == NULL)
return -1;
fseek(*fd, 0, SEEK_END);
*size = ftell(*fd);
fseek(*fd, 0, SEEK_SET);
if (*size <= 0) {
fclose(*fd);
return -2;
}
return 0;
}
/* Encrypt the given plaintext file, and update the message
authentication hashes in the param.sfo. The data_filename is
usually the final component of encrypted_filename, e.g. "DATA.BIN".
See main.c for an example of usage. */
int encrypt_file(const char *plaintext_filename,
const char *encrypted_filename,
const char *data_filename,
const char *paramsfo_filename,
const unsigned char *gamekey)
{
FILE *in = NULL, *out = NULL, *sfo = NULL;
unsigned char *data = NULL, *cryptkey = NULL, *hash = NULL;
unsigned char paramsfo[0x1330];
int len, aligned_len, tmp;
int retval;
/* Open plaintext and param.sfo files and get size */
if (fopen_getsize(plaintext_filename, &in, &len) < 0) {
retval = -1;
goto out;
}
if (fopen_getsize(paramsfo_filename, &sfo, &tmp) < 0) {
retval = -2;
goto out;
}
/* Verify size of param.sfo; all known saves use this size */
if (tmp != 0x1330) {
retval = -3;
goto out;
}
/* Allocate buffers. data has 0x10 bytes extra for the IV. */
aligned_len = align16(len);
if ((data =
(unsigned char *) memalign(0x10, aligned_len + 0x10)) == NULL) {
retval = -4;
goto out;
}
if ((cryptkey = (unsigned char *) memalign(0x10, 0x10)) == NULL) {
retval = -5;
goto out;
}
if ((hash = (unsigned char *) memalign(0x10, 0x10)) == NULL) {
retval = -6;
goto out;
}
/* Fill buffers. */
memset(data + len, 0, aligned_len - len);
if (fread(data, 1, len, in) != len) {
retval = -7;
goto out;
}
if (fread(paramsfo, 1, 0x1330, sfo) != 0x1330) {
retval = -8;
goto out;
}
if (gamekey != NULL)
memcpy(cryptkey, gamekey, 0x10);
/* Do the encryption */
if ((retval = encrypt_data( gamekey ? 3 : 1,
data,
&len, &aligned_len,
hash,
gamekey ? cryptkey : NULL)) < 0) {
retval -= 1000;
goto out;
}
/* Update the param.sfo hashes */
if ((retval = update_hashes(paramsfo, 0x1330,
data_filename, hash,
gamekey ? 3 : 1)) < 0) {
retval -= 2000;
goto out;
}
/* Write the data to the file. encrypt_data has already set len. */
if ((out = fopen(encrypted_filename, "w")) == NULL) {
retval = -9;
goto out;
}
if (fwrite(data, 1, len, out) != len) {
retval = -10;
goto out;
}
/* Reopen param.sfo, and write the updated copy out. */
fclose(sfo);
if ((sfo = fopen(paramsfo_filename, "w")) == NULL) {
retval = -11;
goto out;
}
if (fwrite(paramsfo, 1, 0x1330, sfo) != 0x1330) {
retval = -12;
goto out;
}
/* All done. Return file length. */
retval = len;
out:
if(out) fclose(out);
if(hash) free(hash);
if(cryptkey) free(cryptkey);
if(data) free(data);
if(sfo) fclose(sfo);
if(in) fclose(in);
return retval;
}
/* Do the actual hardware encryption.
mode is 3 for saves with a cryptkey, or 1 otherwise
data, dataLen, and cryptkey must be multiples of 0x10.
cryptkey is NULL if mode == 1.
*/
int encrypt_data(unsigned int mode,
unsigned char *data,
int *dataLen,
int *alignedLen,
unsigned char *hash,
unsigned char *cryptkey)
{
pspChnnlsvContext1 ctx1;
pspChnnlsvContext2 ctx2;
/* Make room for the IV in front of the data. */
memmove(data + 0x10, data, *alignedLen);
/* Set up buffers */
memset(&ctx1, 0, sizeof(pspChnnlsvContext1));
memset(&ctx2, 0, sizeof(pspChnnlsvContext2));
memset(hash, 0, 0x10);
memset(data, 0, 0x10);
/* Build the 0x10-byte IV and setup encryption */
if (sceChnnlsv_ABFDFC8B(&ctx2, mode, 1, data, cryptkey) < 0)
return -1;
if (sceChnnlsv_E7833020(&ctx1, mode) < 0)
return -2;
if (sceChnnlsv_F21A1FCA(&ctx1, data, 0x10) < 0)
return -3;
if (sceChnnlsv_850A7FA1(&ctx2, data + 0x10, *alignedLen) < 0)
return -4;
/* Clear any extra bytes left from the previous steps */
memset(data + 0x10 + *dataLen, 0, *alignedLen - *dataLen);
/* Encrypt the data */
if (sceChnnlsv_F21A1FCA(&ctx1, data + 0x10, *alignedLen) < 0)
return -5;
/* Verify encryption */
if (sceChnnlsv_21BE78B4(&ctx2) < 0)
return -6;
/* Build the file hash from this PSP */
if (sceChnnlsv_C4C494F8(&ctx1, hash, cryptkey) < 0)
return -7;
/* Adjust sizes to account for IV */
*alignedLen += 0x10;
*dataLen += 0x10;
/* All done */
return 0;
}

36
src/samples/savedata/encrypt/encrypt.h Normal file
View File

@@ -0,0 +1,36 @@
/*
* PSP Software Development Kit - http://www.pspdev.org
* -----------------------------------------------------------------------
* Licensed under the BSD license, see LICENSE in PSPSDK root for details.
*
* encrypt.h - Declarations for functions in encrypt.c
*
* Copyright (c) 2005 Jim Paris <jim@jtan.com>
* Coypright (c) 2005 psp123
*
* $Id: encrypt.h 1559 2005-12-10 01:10:11Z jim $
*/
#include <pspchnnlsv.h>
/* Encrypt the given plaintext file, and update the message
authentication hashes in the param.sfo. The data_filename is
usually the final component of encrypted_filename, e.g. "DATA.BIN".
See main.c for an example of usage. */
int encrypt_file(const char *plaintext_filename,
const char *encrypted_filename,
const char *data_filename,
const char *paramsfo_filename,
const unsigned char *gamekey);
/* Do the actual hardware encryption.
mode is 3 for saves with a cryptkey, or 1 otherwise.
data, alignedLen, cryptkey, and hash must be multiples of 0x10.
cryptkey is NULL if mode == 1.
*/
int encrypt_data(unsigned int mode,
unsigned char *data,
int *dataLen,
int *alignedLen,
unsigned char *hash,
unsigned char *cryptkey);

128
src/samples/savedata/encrypt/hash.c Normal file
View File

@@ -0,0 +1,128 @@
/*
* PSP Software Development Kit - http://www.pspdev.org
* -----------------------------------------------------------------------
* Licensed under the BSD license, see LICENSE in PSPSDK root for details.
*
* hash.c - Hashing routines using sceChnnlsv
*
* Copyright (c) 2005 Jim Paris <jim@jtan.com>
* Coypright (c) 2005 psp123
*
* $Id: hash.c 1560 2005-12-10 01:16:32Z jim $
*/
#include "hash.h"
#include "psf.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>
#include <pspchnnlsv.h>
static inline int align16(unsigned int v)
{
return ((v + 0xF) >> 4) << 4;
}
/* Update the hashes in the param.sfo data, using
the given file hash, and by computing the param.sfo hashes.
filehash must be a multiple of 16 bytes, and is reused to
store other hashes. The filename is e.g. "DATA.BIN". */
int update_hashes(unsigned char *data,
int len,
const char *filename,
unsigned char *filehash,
int encryptmode)
{
int alignedLen = align16(len);
unsigned char *datafile, *savedata_params;
int listLen, paramsLen;
int ret;
/* Locate SAVEDATA_PARAM section in the param.sfo. */
if ((ret = find_psf_section("SAVEDATA_PARAMS", data, 0x1330,
&savedata_params, &paramsLen)) < 0) {
return ret - 100;
}
/* Locate the pointer for this DATA.BIN equivalent */
if ((ret = find_psf_section("SAVEDATA_FILE_LIST", data, 0x1330,
&datafile, &listLen)) < 0) {
return ret - 200;
}
if ((ret = find_psf_datafile(filename, datafile,
listLen, &datafile)) < 0) {
return ret - 300;
}
/* Check minimum sizes based on where we want to write */
if ((listLen < 0x20) || (paramsLen < 0x80)) {
return -1;
}
/* Clear params and insert file hash */
memset(savedata_params, 0, paramsLen);
memcpy(datafile + 0x0D, filehash, 0x10);
/* Compute 11D0 hash over entire file */
if ((ret = build_hash(filehash, data, len, alignedLen,
(encryptmode & 2) ? 4 : 2, NULL)) < 0) {
return ret - 400;
}
/* Copy 11D0 hash to param.sfo and set flag indicating it's there */
memcpy(savedata_params + 0x20, filehash, 0x10);
*savedata_params |= 0x01;
/* If new encryption mode, compute and insert the 1220 hash. */
if (encryptmode & 2) {
/* Enable the hash bit first */
*savedata_params |= 0x20;
if ((ret = build_hash(filehash, data, len, alignedLen,
3, 0)) < 0) {
return ret - 500;
}
memcpy(savedata_params + 0x70, filehash, 0x10);
}
/* Compute and insert the 11C0 hash. */
if ((ret = build_hash(filehash, data, len, alignedLen, 1, 0)) < 0) {
return ret - 600;
}
memcpy(savedata_params + 0x10, filehash, 0x10);
/* All done. */
return 0;
}
/* Build a single hash using the given data and mode.
data and alignedLen must be multiples of 0x10.
cryptkey is NULL for savedata. */
int build_hash(unsigned char *output,
unsigned char *data,
unsigned int len,
unsigned int alignedLen,
int mode,
unsigned char *cryptkey)
{
pspChnnlsvContext1 ctx1;
/* Set up buffers */
memset(&ctx1, 0, sizeof(pspChnnlsvContext1));
memset(output, 0, 0x10);
memset(data + len, 0, alignedLen - len);
/* Perform the magic */
if (sceChnnlsv_E7833020(&ctx1, mode & 0xFF) < 0)
return -1;
if (sceChnnlsv_F21A1FCA(&ctx1, data, alignedLen) < 0)
return -2;
if (sceChnnlsv_C4C494F8(&ctx1, output, cryptkey) < 0)
return -3;
/* All done. */
return 0;
}

34
src/samples/savedata/encrypt/hash.h Normal file
View File

@@ -0,0 +1,34 @@
/*
* PSP Software Development Kit - http://www.pspdev.org
* -----------------------------------------------------------------------
* Licensed under the BSD license, see LICENSE in PSPSDK root for details.
*
* hash.h - Declarations for functions in hash.c
*
* Copyright (c) 2005 Jim Paris <jim@jtan.com>
* Coypright (c) 2005 psp123
*
* $Id: hash.h 1559 2005-12-10 01:10:11Z jim $
*/
#include <pspchnnlsv.h>
/* Update the hashes in the param.sfo data, using
the given file hash, and by computing the param.sfo hashes.
filehash must be a multiple of 16 bytes, and is reused to
store other hashes. The filename is e.g. "DATA.BIN". */
int update_hashes(unsigned char *data,
int len,
const char *filename,
unsigned char *filehash,
int encryptmode);
/* Build a single hash using the given data and mode.
data, and alignedLen must be multiples of 0x10.
cryptkey is NULL for savedata.*/
int build_hash(unsigned char *output,
unsigned char *data,
unsigned int len,
unsigned int alignedLen,
int mode,
unsigned char *cryptkey);

107
src/samples/savedata/encrypt/main.c Normal file
View File

@@ -0,0 +1,107 @@
/*
* PSP Software Development Kit - http://www.pspdev.org
* -----------------------------------------------------------------------
* Licensed under the BSD license, see LICENSE in PSPSDK root for details.
*
* main.c - Sample to demonstrate savedata encryption using sceChnnlsv
*
* Copyright (c) 2005 Jim Paris <jim@jtan.com>
* Coypright (c) 2005 psp123
*
* $Id: main.c 1559 2005-12-10 01:10:11Z jim $
*/
#include <pspkernel.h>
#include <pspctrl.h>
#include <pspdebug.h>
#include <pspdisplay.h>
#include <psptypes.h>
#include <psputility.h>
#include <stdio.h>
#include <string.h>
#include "encrypt.h"
PSP_MODULE_INFO("SaveEncrypt", 0, 1, 1);
#define printf pspDebugScreenPrintf
#if 0
/* Old format save with no key, supported by 1.0+ firmware */
const char *plaintext = "ms0:/PLAIN.BIN";
const char *encrypted = "ms0:/PSP/SAVEDATA/DATA111110000/DATA.BIN";
const char *datafile = "DATA.BIN";
const char *paramsfo = "ms0:/PSP/SAVEDATA/DATA111110000/PARAM.SFO";
const unsigned char *gamekey = NULL;
#else
/* New format save with a key (GTA:LCS) */
const char *plaintext = "ms0:/PLAIN.BIN";
const char *encrypted = "ms0:/PSP/SAVEDATA/DATA222220000/DATA.BIN";
const char *datafile = "DATA.BIN";
const char *paramsfo = "ms0:/PSP/SAVEDATA/DATA222220000/PARAM.SFO";
const unsigned char gamekey[] = {
0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
0xFA, 0xCA, 0xDE, 0x00, 0xDE, 0xAD, 0xBE, 0xEF
};
#endif
int waitbutton(int mask) {
SceCtrlData paddata;
do {
sceDisplayWaitVblankStart();
sceCtrlReadBufferPositive(&paddata, 1);
} while((paddata.Buttons & mask));
do {
sceDisplayWaitVblankStart();
sceCtrlReadBufferPositive(&paddata, 1);
} while(!(paddata.Buttons & mask));
return paddata.Buttons;
}
int main(int argc, char *argv[])
{
int i, ret;
pspDebugScreenInit();
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(PSP_CTRL_MODE_DIGITAL);
printf("Save Encrypt Sample\n");
printf("by Jim Paris and psp123\n\n");
printf(" Will encrypt: %s\n", plaintext);
printf(" Using key:");
if(gamekey) {
for (i = 0; i < 0x10; i++)
printf(" %02x", gamekey[i]);
} else {
printf(" none");
}
printf("\n\n");
printf(" Output file: %s\n", encrypted);
printf("Update hashes: %s\n\n", paramsfo);
printf("Press X to continue, or O to quit.\n\n");
if (waitbutton(PSP_CTRL_CROSS | PSP_CTRL_CIRCLE) & PSP_CTRL_CIRCLE)
goto out;
printf("Working...\n\n");
ret = encrypt_file(plaintext, encrypted, datafile, paramsfo, gamekey);
if(ret < 0) {
printf("Error: encrypt_file() returned %d\n\n", ret);
} else {
printf("Successfully wrote %d bytes to\n", ret);
printf(" %s\n", encrypted);
printf("and updated hashes in\n");
printf(" %s\n\n", paramsfo);
}
printf("Press any button to quit\n");
waitbutton(-1);
out:
sceKernelExitGame();
return 0;
}

114
src/samples/savedata/encrypt/psf.c Normal file
View File

@@ -0,0 +1,114 @@
/*
* PSP Software Development Kit - http://www.pspdev.org
* -----------------------------------------------------------------------
* Licensed under the BSD license, see LICENSE in PSPSDK root for details.
*
* psf.c - PSF parsing routines
*
* Copyright (c) 2005 Jim Paris <jim@jtan.com>
* Coypright (c) 2005 psp123
*
* $Id: psf.c 1560 2005-12-10 01:16:32Z jim $
*/
#include "psf.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>
#include <pspchnnlsv.h>
/* Find to the named section in the PSF file, and return an
absolute pointer to it and the section size. */
int find_psf_section(const char *name,
unsigned char *data,
int dataLen,
unsigned char **location,
int *size)
{
unsigned short int nameLoc;
int i, magicHead, strLoc, headLen, numSects;
int sectCurLen, sectBufLen, sectBufLoc, curPos;
if (dataLen < 0x14)
return -1;
/* Get the basics from the header */
magicHead = *(unsigned int *)&data[0x00];
strLoc = *(unsigned int *)&data[0x08];
headLen = *(unsigned int *)&data[0x0C];
numSects = *(unsigned int *)&data[0x10];
/* Do some error checking */
if (magicHead != 0x46535000)
return -2;
/* Verify strLoc is proper */
if ((strLoc > headLen) || (strLoc >= dataLen))
return -3;
/* Verify headLen is proper */
if (headLen >= dataLen)
return -4;
/* Verify numSects is proper */
if (numSects != ((strLoc - 0x14) / 0x10))
return -5;
/* Process all sections */
for (i = 0; i < numSects; i++)
{
/* Get the curPos */
curPos = 0x14 + (i * 0x10);
/* Verify curPos is proper */
if (curPos >= strLoc)
return -6;
/* Get some basic info about this section */
nameLoc = *(unsigned short *)&data[curPos];
sectCurLen = *(unsigned short *)&data[curPos + 0x04];
sectBufLen = *(unsigned short *)&data[curPos + 0x08];
sectBufLoc = *(unsigned short *)&data[curPos + 0x0C];
/* Do some error checking */
if ((nameLoc < dataLen) && (sectCurLen < dataLen)
&& (sectBufLen < dataLen) && (sectBufLoc < dataLen))
{
/* Check if this is the section we want */
if (!stricmp((char *)&data[strLoc + nameLoc], name))
{
/* Update the location and size */
*location = &data[headLen + sectBufLoc];
*size = sectBufLen;
return 0;
}
}
}
/* Section was not found if it makes it here */
return -7;
}
/* Find the named file inside the FILE_LIST, and return
an absolute pointer to it. */
int find_psf_datafile(const char *name,
unsigned char *filelist,
int size,
unsigned char **location)
{
int i;
/* Process all files */
for (i = 0; (i + 0x0d) <= size; i += 0x20)
{
/* Check if this is the filename we want */
if (!strncasecmp((char *)&filelist[i], name, 0x0d)) {
*location = &filelist[i];
return 0;
}
}
/* File was not found if it makes it here */
return -1;
}

29
src/samples/savedata/encrypt/psf.h Normal file
View File

@@ -0,0 +1,29 @@
/*
* PSP Software Development Kit - http://www.pspdev.org
* -----------------------------------------------------------------------
* Licensed under the BSD license, see LICENSE in PSPSDK root for details.
*
* psf.h - Declarations for functions in psf.c
*
* Copyright (c) 2005 Jim Paris <jim@jtan.com>
* Coypright (c) 2005 psp123
*
* $Id: psf.h 1559 2005-12-10 01:10:11Z jim $
*/
#include <pspchnnlsv.h>
/* Find the named section in the PSF file, and return an
absolute pointer to it and the section size. */
int find_psf_section(const char *name,
unsigned char *data,
int dataLen,
unsigned char **location,
int *size);
/* Find the named file inside the FILE_LIST, and return
an absolute pointer to it. */
int find_psf_datafile(const char *name,
unsigned char *filelist,
int size,
unsigned char **location);

18
src/samples/savedata/utility/Makefile.sample Normal file
View File

@@ -0,0 +1,18 @@
TARGET = savedata
OBJS = main.o
# For custom firmware uncomment the following lines:
#PSP_FW_VERSION = 200
#BUILD_PRX = 1
LIBS = -lpsputility -lpspgum -lpspgu -lm
CFLAGS = -O2 -Wall
CXXFLAGS = $(CFLAGS) -fno-exceptions -fno-rtti
ASFLAGS = $(CFLAGS)
EXTRA_TARGETS = EBOOT.PBP
PSP_EBOOT_TITLE = PSPSDK Savedata Sample
PSPSDK = $(shell psp-config --pspsdk-path)
include $(PSPSDK)/lib/build.mak

314
src/samples/savedata/utility/data.h Normal file
View File

@@ -0,0 +1,314 @@
#ifndef __data__
#define __data__
unsigned int size_icon0 = 1666;
unsigned char icon0[] __attribute__((aligned(16))) = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x90, 0x00, 0x00, 0x00, 0x50, 0x08, 0x02, 0x00, 0x00, 0x00, 0x79, 0xcc, 0x6b,
0x5b, 0x00, 0x00, 0x00, 0x04, 0x67, 0x41, 0x4d, 0x41, 0x00, 0x00, 0xd6, 0xd8, 0xd4, 0x4f, 0x58,
0x32, 0x00, 0x00, 0x00, 0x19, 0x74, 0x45, 0x58, 0x74, 0x53, 0x6f, 0x66, 0x74, 0x77, 0x61, 0x72,
0x65, 0x00, 0x41, 0x64, 0x6f, 0x62, 0x65, 0x20, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x52, 0x65, 0x61,
0x64, 0x79, 0x71, 0xc9, 0x65, 0x3c, 0x00, 0x00, 0x06, 0x14, 0x49, 0x44, 0x41, 0x54, 0x78, 0xda,
0xec, 0x5c, 0x2d, 0x6c, 0x1c, 0x47, 0x14, 0x7e, 0xae, 0x1c, 0x10, 0x70, 0x07, 0x02, 0x12, 0x70,
0x91, 0x5c, 0x60, 0x10, 0x9f, 0x64, 0x90, 0x00, 0x3b, 0x0a, 0x09, 0x72, 0x55, 0x95, 0x26, 0x20,
0x85, 0x0d, 0x28, 0x4d, 0x81, 0x4d, 0x0d, 0x52, 0xe8, 0x80, 0x1a, 0xd6, 0x20, 0x86, 0x09, 0x88,
0x61, 0x0b, 0x62, 0xd8, 0xb4, 0xb2, 0x0d, 0x5a, 0x10, 0x29, 0x17, 0x10, 0xa9, 0x89, 0x94, 0x03,
0x31, 0x08, 0xb0, 0x41, 0x40, 0x0d, 0xfa, 0x79, 0x47, 0xfb, 0xf4, 0xee, 0x76, 0x77, 0x76, 0x76,
0xf6, 0x7e, 0xf6, 0x92, 0xef, 0xd3, 0x01, 0xeb, 0x6e, 0x67, 0x76, 0xe6, 0x7d, 0xef, 0x7d, 0xf3,
0xde, 0xcc, 0xc8, 0x73, 0xff, 0xca, 0xb7, 0x42, 0xcc, 0x0e, 0xbe, 0xa2, 0x09, 0x48, 0x18, 0x41,
0xc2, 0x08, 0x12, 0x46, 0xc2, 0x08, 0x12, 0x46, 0x90, 0x30, 0x12, 0x46, 0x90, 0x30, 0x82, 0x84,
0x91, 0x30, 0x82, 0x84, 0x11, 0x24, 0x8c, 0x84, 0x11, 0x24, 0x8c, 0x20, 0x61, 0x24, 0x8c, 0x20,
0x61, 0x04, 0x09, 0x23, 0x61, 0x04, 0x09, 0x23, 0x48, 0xd8, 0x17, 0x85, 0xf9, 0x69, 0xbd, 0xf8,
0x95, 0x9c, 0xbc, 0x97, 0x4f, 0xaf, 0xe4, 0x54, 0xbf, 0xb9, 0x29, 0x97, 0xae, 0xca, 0x45, 0x7c,
0x02, 0x9b, 0xa3, 0x2d, 0x7a, 0x88, 0x68, 0x3b, 0xd3, 0x98, 0xab, 0x79, 0x2f, 0xf1, 0x40, 0x3e,
0x7e, 0x2f, 0x47, 0xee, 0xef, 0x27, 0xb2, 0x02, 0xc3, 0x95, 0x3e, 0xff, 0x4c, 0xfa, 0xcf, 0xe5,
0xc3, 0xa9, 0x9c, 0xe5, 0x3e, 0xd0, 0x91, 0x8b, 0x77, 0xa5, 0xf3, 0x93, 0x2c, 0xe6, 0xfe, 0x0a,
0x86, 0x1e, 0xcb, 0x5b, 0xf4, 0x90, 0xdb, 0x7c, 0x49, 0x5a, 0xf7, 0xe5, 0x6b, 0x34, 0xf7, 0x8f,
0xe1, 0x9e, 0x1c, 0x1d, 0xca, 0x47, 0xf7, 0xf7, 0xaf, 0x72, 0xfd, 0x1b, 0xb9, 0x52, 0x3a, 0x4d,
0x6d, 0xf2, 0x40, 0x16, 0x8b, 0xc6, 0xe6, 0x70, 0x22, 0xff, 0x61, 0x8e, 0xce, 0x11, 0xe1, 0x40,
0xce, 0x93, 0x66, 0x32, 0xc2, 0x10, 0x13, 0x0f, 0xe5, 0xb5, 0x5a, 0xaa, 0x08, 0x7d, 0xf9, 0x04,
0x3a, 0x73, 0x8d, 0x02, 0xaa, 0x7e, 0x91, 0x37, 0x45, 0x4c, 0x03, 0x3d, 0x39, 0xdd, 0x90, 0x97,
0x78, 0xe6, 0x91, 0x2c, 0x97, 0xba, 0x8e, 0xc3, 0xba, 0xbc, 0x7c, 0x21, 0x97, 0xda, 0x72, 0xa1,
0xfe, 0x04, 0xe1, 0x4c, 0x78, 0xf5, 0x1e, 0x66, 0x30, 0x88, 0x3b, 0xd2, 0xd9, 0x94, 0x6b, 0x23,
0x79, 0xc5, 0xe4, 0x08, 0x43, 0x4c, 0xc0, 0x94, 0x43, 0xd1, 0xd0, 0x95, 0xb6, 0xf5, 0xbe, 0xc4,
0x31, 0x4f, 0xc0, 0x47, 0x6e, 0x88, 0xc0, 0xb2, 0xd6, 0x16, 0xb0, 0x82, 0x3a, 0xaf, 0x73, 0x6a,
0x0d, 0x3b, 0x50, 0x8e, 0xa0, 0xdf, 0x92, 0xe5, 0xd2, 0x50, 0x03, 0xd0, 0x04, 0x6e, 0x04, 0x82,
0xeb, 0xbb, 0x23, 0xa2, 0x30, 0xd7, 0x99, 0xf6, 0x12, 0x45, 0x79, 0x2a, 0x2b, 0x98, 0xef, 0x6c,
0x10, 0x86, 0xc8, 0xf8, 0x59, 0x5e, 0x5b, 0x5b, 0x23, 0x80, 0x8a, 0x84, 0x02, 0xa6, 0xcf, 0xfe,
0x64, 0xd9, 0x5a, 0x93, 0xcb, 0x9b, 0xb2, 0x34, 0xf4, 0x0c, 0x64, 0x0d, 0x5f, 0xc2, 0xc1, 0xb7,
0xe5, 0x8d, 0xfb, 0xc6, 0xf9, 0x47, 0x08, 0x67, 0xe8, 0xf9, 0x6e, 0x42, 0xff, 0x48, 0xd8, 0x6a,
0xc9, 0xbc, 0x0e, 0x0f, 0x3e, 0xe4, 0x86, 0x8d, 0x9f, 0x7e, 0x94, 0x7f, 0x7e, 0x97, 0x5b, 0xf5,
0xe3, 0x6c, 0xec, 0x59, 0x22, 0x9c, 0x4b, 0xd9, 0xc2, 0x64, 0x7e, 0x93, 0x5b, 0x70, 0x67, 0x8f,
0xac, 0x67, 0x45, 0x1f, 0x7c, 0x2b, 0x5b, 0x20, 0x7b, 0x47, 0x6e, 0x14, 0x35, 0x87, 0x1f, 0x6c,
0x99, 0x58, 0x79, 0x28, 0x3d, 0xcd, 0x4a, 0x72, 0xb1, 0x9a, 0x92, 0x04, 0x87, 0x40, 0x98, 0x46,
0xcf, 0x11, 0x31, 0xea, 0xd8, 0xc2, 0x02, 0xfc, 0x42, 0x6e, 0x3b, 0xfa, 0xf1, 0xc1, 0x4c, 0x75,
0x3c, 0xfd, 0x44, 0x30, 0x9b, 0x9e, 0xd6, 0xc3, 0x5e, 0xeb, 0xa9, 0x12, 0x82, 0x2d, 0x4c, 0xa6,
0xaa, 0x2c, 0xc0, 0x8e, 0x3a, 0x4f, 0xa8, 0x68, 0xa9, 0x76, 0xc1, 0x58, 0x3f, 0xc8, 0x82, 0xca,
0xdd, 0xfa, 0xa0, 0x0e, 0x0f, 0xe1, 0xbe, 0x2c, 0xb4, 0x12, 0x8d, 0xe9, 0x9f, 0xe7, 0x32, 0xef,
0xa2, 0xd5, 0x5e, 0x17, 0x66, 0x0c, 0x6f, 0x28, 0x86, 0xec, 0x78, 0x76, 0xe5, 0x9d, 0xdf, 0x81,
0xa6, 0x4f, 0x98, 0xcd, 0x11, 0x20, 0xe2, 0x11, 0x82, 0x00, 0x3b, 0x6a, 0x0f, 0x90, 0x9a, 0x90,
0x26, 0x88, 0xb3, 0x4e, 0x1a, 0x82, 0x87, 0xc9, 0xba, 0x58, 0xf4, 0x24, 0xc6, 0x83, 0xac, 0xd2,
0xfd, 0x0d, 0x2d, 0xf5, 0x3c, 0xe9, 0x27, 0x4c, 0xe3, 0x35, 0x57, 0x57, 0xf5, 0x15, 0x4e, 0x6f,
0x9a, 0x4b, 0x18, 0x82, 0xc3, 0x4a, 0x59, 0xdc, 0x92, 0x0b, 0x3d, 0xd4, 0xa5, 0x2b, 0x70, 0x99,
0x01, 0x0d, 0x36, 0xc9, 0x7c, 0x96, 0x49, 0xdb, 0xec, 0xda, 0xa3, 0x41, 0xe6, 0x94, 0x2d, 0x42,
0x42, 0x34, 0xbc, 0x8a, 0xd6, 0x4b, 0x08, 0xb8, 0x6a, 0xef, 0x73, 0x39, 0x6e, 0x2e, 0x61, 0xd6,
0x52, 0xfe, 0xda, 0xc5, 0xb3, 0xfe, 0x69, 0x78, 0x85, 0xa4, 0x0f, 0x26, 0x07, 0xb9, 0x6c, 0x3a,
0x39, 0x2e, 0x76, 0xa9, 0x33, 0x1b, 0x64, 0x30, 0xbd, 0xfa, 0x47, 0x78, 0x19, 0x9a, 0xfb, 0xd2,
0xec, 0xc2, 0xac, 0xaf, 0x68, 0x2e, 0x61, 0x6a, 0x29, 0xac, 0x3d, 0x71, 0xc5, 0xa3, 0xdd, 0x07,
0x09, 0x29, 0x6f, 0x6d, 0x90, 0xa9, 0x53, 0x63, 0x7d, 0xf2, 0xaf, 0x1c, 0x56, 0x42, 0xa1, 0xe1,
0x95, 0x96, 0x19, 0x55, 0x51, 0xcc, 0xd1, 0x23, 0xf8, 0x56, 0x1b, 0xe2, 0x84, 0x77, 0x12, 0x84,
0xe9, 0xc8, 0xa2, 0x33, 0x66, 0xf5, 0x5f, 0x98, 0xa3, 0x6a, 0x5b, 0xfb, 0xd2, 0x52, 0x0e, 0x34,
0x97, 0x49, 0xca, 0xb2, 0x5e, 0x84, 0x4b, 0x85, 0x2f, 0xcf, 0x27, 0xc5, 0x85, 0xff, 0x34, 0x09,
0xc3, 0x02, 0xa6, 0x6a, 0x16, 0x5d, 0x30, 0x6a, 0xaa, 0x1d, 0xd1, 0x43, 0xd7, 0x70, 0x5c, 0xea,
0xd4, 0x60, 0x77, 0x2d, 0x15, 0xb4, 0x7d, 0x39, 0x0e, 0x4f, 0x0d, 0xcc, 0x08, 0x5b, 0x81, 0xde,
0xd3, 0xd0, 0x08, 0xb3, 0x6a, 0x16, 0xbd, 0x99, 0xd6, 0x4b, 0x3b, 0x89, 0xe8, 0xc1, 0xba, 0x7c,
0x88, 0x53, 0x23, 0x05, 0xb5, 0xd9, 0x47, 0x60, 0x59, 0xd6, 0xfb, 0x6c, 0x22, 0x6c, 0xe6, 0x00,
0x9f, 0xd0, 0xec, 0x63, 0x54, 0x45, 0xee, 0x38, 0x40, 0xc2, 0x06, 0xb2, 0x0f, 0x5d, 0x2c, 0x51,
0xe4, 0xd6, 0xd4, 0xae, 0x19, 0x23, 0xac, 0x6d, 0x76, 0x29, 0xa3, 0x77, 0x7d, 0x54, 0xa3, 0x22,
0x7a, 0xb0, 0x89, 0x46, 0x37, 0x38, 0x67, 0xb1, 0x3b, 0x29, 0xfe, 0x5d, 0x92, 0xcf, 0x8d, 0x30,
0x9b, 0x26, 0xd8, 0xf5, 0x2c, 0xae, 0x93, 0x88, 0x1e, 0x2c, 0x61, 0xe1, 0x0b, 0x0c, 0xde, 0xa8,
0x3b, 0x49, 0x58, 0x9f, 0x3c, 0x45, 0x77, 0xa5, 0xf4, 0xd5, 0x3a, 0x5c, 0xb7, 0x7a, 0xc6, 0x3b,
0x21, 0x49, 0xd4, 0xe2, 0xe6, 0x20, 0xb6, 0x5a, 0xbc, 0x6a, 0x76, 0x98, 0xa2, 0x4b, 0x82, 0xaa,
0x75, 0x85, 0x2d, 0xcb, 0x90, 0xe2, 0x3b, 0x5b, 0xb7, 0x0b, 0x8e, 0x35, 0xd4, 0x15, 0xfc, 0x73,
0xb4, 0x0e, 0x57, 0x73, 0xc3, 0x7e, 0x8c, 0x84, 0xd9, 0xf2, 0x3e, 0x4e, 0x15, 0xad, 0xa1, 0x2b,
0xed, 0xc2, 0xe1, 0x75, 0x87, 0xb1, 0x35, 0x1c, 0x0c, 0xba, 0x29, 0xd7, 0xb4, 0x2c, 0x73, 0x9b,
0xc2, 0x45, 0x75, 0x85, 0xba, 0x94, 0x7f, 0x82, 0xf6, 0xd7, 0x9a, 0x07, 0xd0, 0x63, 0x24, 0xcc,
0x6e, 0xd5, 0xc4, 0xed, 0x85, 0x0f, 0x12, 0x56, 0x61, 0x17, 0xce, 0x4a, 0x59, 0xa5, 0x3d, 0x2d,
0xdd, 0x55, 0xd1, 0xb2, 0x6c, 0xdb, 0xbb, 0xf7, 0xa1, 0x23, 0xec, 0x79, 0x45, 0x5b, 0xe3, 0x0f,
0xab, 0x72, 0x93, 0x09, 0xbb, 0xa2, 0xda, 0xf2, 0x58, 0xde, 0x46, 0x9c, 0x2c, 0x60, 0x6e, 0x6a,
0xb8, 0x3d, 0xe9, 0x07, 0xa6, 0x6d, 0x70, 0x67, 0xeb, 0x1f, 0x11, 0x84, 0x0d, 0x95, 0x65, 0x9e,
0x14, 0x3f, 0x50, 0x03, 0x94, 0xb0, 0x3a, 0xc7, 0xa4, 0x93, 0x48, 0xeb, 0x75, 0xcf, 0x37, 0x39,
0x72, 0xfd, 0x3b, 0x42, 0x18, 0xed, 0xd9, 0x44, 0x60, 0xda, 0x06, 0xfb, 0xf6, 0x53, 0xe7, 0x78,
0x20, 0x8b, 0x71, 0x6b, 0x06, 0x7c, 0x45, 0x07, 0x0f, 0x5f, 0x29, 0xf2, 0x36, 0x3c, 0xa6, 0x92,
0x5b, 0xa4, 0x01, 0x68, 0xab, 0xf1, 0x57, 0x69, 0x47, 0x74, 0x0a, 0x84, 0xc1, 0xbb, 0x57, 0x8d,
0x68, 0xdc, 0x93, 0xa3, 0xaa, 0x71, 0x06, 0x97, 0xbc, 0x93, 0x86, 0x08, 0x7a, 0x28, 0xe5, 0x0c,
0x62, 0xb8, 0x9b, 0x86, 0x57, 0xe7, 0xbc, 0x16, 0x5e, 0x88, 0x1e, 0x3c, 0x7c, 0x45, 0xc9, 0xf0,
0x04, 0xb7, 0xba, 0x54, 0x91, 0x06, 0x68, 0x80, 0x22, 0x64, 0xe3, 0xc2, 0x7d, 0xa2, 0x85, 0xf3,
0x8e, 0x5c, 0x57, 0x6d, 0x81, 0xc5, 0xbf, 0x93, 0x3f, 0xfd, 0x3b, 0xe2, 0x07, 0x99, 0x23, 0x47,
0xa4, 0x00, 0x6a, 0x38, 0x18, 0x05, 0x91, 0x9a, 0xdb, 0xdc, 0x9d, 0x4d, 0x6f, 0x98, 0x03, 0x6e,
0xbc, 0xba, 0x66, 0x4a, 0xa6, 0x65, 0x99, 0x67, 0x89, 0x02, 0x07, 0xaa, 0xfc, 0xd9, 0xab, 0x06,
0x7a, 0xad, 0x43, 0x62, 0xcf, 0x98, 0x86, 0x30, 0xf6, 0x4b, 0x38, 0x30, 0xd9, 0x53, 0x59, 0xc1,
0x4c, 0xdc, 0x9c, 0xa1, 0x8d, 0xdb, 0xc9, 0x55, 0x19, 0x70, 0x70, 0x73, 0xf0, 0x7e, 0x99, 0xde,
0x9a, 0x82, 0x8e, 0xd9, 0xac, 0xcc, 0xf5, 0x80, 0xe8, 0x74, 0x3d, 0xec, 0xcb, 0x31, 0x3e, 0x9e,
0x5b, 0x53, 0x8e, 0xad, 0x91, 0xdc, 0x52, 0x42, 0x0f, 0x18, 0xcc, 0x76, 0xd9, 0x36, 0x15, 0x78,
0x75, 0x97, 0x33, 0x13, 0x8f, 0xfc, 0x4b, 0xaf, 0x18, 0x59, 0xb6, 0xa0, 0x34, 0x56, 0xde, 0x9b,
0x4b, 0x98, 0x9b, 0x36, 0xcc, 0x07, 0xf7, 0xdf, 0x35, 0xb9, 0x00, 0xe6, 0x56, 0xe4, 0xb6, 0xd9,
0x9a, 0x46, 0x59, 0xdf, 0x4f, 0xd7, 0x89, 0x3d, 0x63, 0x8b, 0x21, 0xac, 0x26, 0xb7, 0x5f, 0x46,
0x75, 0x7d, 0x13, 0xa2, 0x0a, 0xbb, 0xf7, 0xbd, 0x4a, 0x0e, 0xd7, 0xd9, 0x92, 0x65, 0x17, 0xdc,
0x78, 0x72, 0x23, 0xa3, 0xdb, 0xf0, 0x4e, 0x84, 0x7b, 0xa3, 0x77, 0x3a, 0xf2, 0x8a, 0x9b, 0xa5,
0x3f, 0xe4, 0x36, 0x22, 0xa3, 0xe5, 0xf5, 0x12, 0xcc, 0x2d, 0xf7, 0xe8, 0x16, 0x3d, 0xec, 0xc8,
0x8d, 0x27, 0xb2, 0xb2, 0x56, 0x7c, 0xb0, 0x8b, 0x9f, 0xf0, 0x00, 0xa8, 0x1d, 0xe1, 0x65, 0x5b,
0xbc, 0x37, 0xe4, 0xd6, 0x22, 0x84, 0x11, 0xaf, 0xce, 0xd6, 0x7c, 0x98, 0x2c, 0x62, 0x34, 0xee,
0x3e, 0x4b, 0x2e, 0xe6, 0xa6, 0xf2, 0x2f, 0x64, 0xb3, 0x17, 0xeb, 0xdd, 0xcd, 0xf8, 0xae, 0xf7,
0xdc, 0x36, 0xbb, 0xd4, 0xb9, 0xa3, 0x8a, 0xb6, 0xcc, 0x23, 0x88, 0xc3, 0xdb, 0x8e, 0x7b, 0x6a,
0x07, 0xe7, 0x1b, 0x05, 0x67, 0x2e, 0xf2, 0xea, 0xe7, 0xf1, 0x8d, 0x20, 0x8c, 0x68, 0xba, 0x24,
0x12, 0x24, 0x8c, 0x84, 0x11, 0x24, 0x8c, 0x20, 0x61, 0x24, 0x8c, 0x20, 0x61, 0x04, 0x09, 0x23,
0x48, 0x18, 0x09, 0x23, 0x48, 0x18, 0x41, 0xc2, 0x48, 0x18, 0x41, 0xc2, 0x08, 0x12, 0x46, 0xc2,
0x08, 0x12, 0x46, 0x90, 0x30, 0x12, 0x46, 0x90, 0x30, 0x82, 0x84, 0x91, 0x30, 0x82, 0x84, 0x11,
0x24, 0x8c, 0x84, 0x11, 0x24, 0x8c, 0x20, 0x61, 0x5f, 0x12, 0xfe, 0x17, 0x60, 0x00, 0xed, 0xf6,
0x47, 0x4c, 0x1c, 0x54, 0x4d, 0x28, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42,
0x60, 0x82,
};
unsigned int size_pic1 = 3150;
unsigned char pic1[] __attribute__((aligned(16))) = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x01, 0xe0, 0x00, 0x00, 0x01, 0x10, 0x08, 0x02, 0x00, 0x00, 0x00, 0xe7, 0x24, 0x30,
0xdb, 0x00, 0x00, 0x00, 0x04, 0x67, 0x41, 0x4d, 0x41, 0x00, 0x00, 0xd6, 0xd8, 0xd4, 0x4f, 0x58,
0x32, 0x00, 0x00, 0x00, 0x19, 0x74, 0x45, 0x58, 0x74, 0x53, 0x6f, 0x66, 0x74, 0x77, 0x61, 0x72,
0x65, 0x00, 0x41, 0x64, 0x6f, 0x62, 0x65, 0x20, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x52, 0x65, 0x61,
0x64, 0x79, 0x71, 0xc9, 0x65, 0x3c, 0x00, 0x00, 0x0b, 0xe0, 0x49, 0x44, 0x41, 0x54, 0x78, 0xda,
0xec, 0xdd, 0x7d, 0x56, 0x5b, 0x65, 0x1e, 0xc0, 0xf1, 0xf2, 0x12, 0x42, 0x43, 0x81, 0x14, 0x8a,
0x65, 0x68, 0x3d, 0xe4, 0x74, 0xf4, 0x1f, 0xff, 0x81, 0x59, 0x41, 0xe9, 0x0a, 0xca, 0x0e, 0xc4,
0x15, 0x48, 0x57, 0x50, 0x5c, 0x81, 0xb8, 0x02, 0x71, 0x05, 0xe2, 0x0a, 0x06, 0x56, 0x30, 0xf4,
0xbf, 0x99, 0xe3, 0x51, 0xe9, 0x54, 0x99, 0x62, 0x0b, 0xe5, 0xa5, 0x8d, 0xbc, 0x33, 0xbf, 0x12,
0x45, 0xac, 0x36, 0xf7, 0x42, 0x21, 0xb9, 0x09, 0x9f, 0xcf, 0xc9, 0xe9, 0xa9, 0x1a, 0x20, 0x3c,
0xc4, 0x6f, 0x9e, 0x3c, 0x3c, 0xf7, 0xde, 0x96, 0xe1, 0xc3, 0x8f, 0xae, 0x00, 0x90, 0x3d, 0xad,
0x86, 0x00, 0x40, 0xa0, 0x01, 0x10, 0x68, 0x00, 0x81, 0x06, 0x40, 0xa0, 0x01, 0x04, 0x1a, 0x00,
0x81, 0x06, 0x40, 0xa0, 0x01, 0x04, 0x1a, 0x00, 0x81, 0x06, 0x10, 0x68, 0x00, 0x04, 0x1a, 0x00,
0x81, 0x06, 0x10, 0x68, 0x00, 0x04, 0x1a, 0x40, 0xa0, 0x01, 0x10, 0x68, 0x00, 0x81, 0x06, 0x40,
0xa0, 0x01, 0x10, 0x68, 0x00, 0x81, 0x06, 0x40, 0xa0, 0x01, 0x04, 0x1a, 0x00, 0x81, 0x06, 0x40,
0xa0, 0x01, 0x04, 0x1a, 0x00, 0x81, 0x06, 0x10, 0x68, 0x00, 0x04, 0x1a, 0x40, 0xa0, 0x01, 0x10,
0x68, 0x00, 0x04, 0x1a, 0x40, 0xa0, 0x01, 0x10, 0x68, 0x00, 0x81, 0x06, 0x40, 0xa0, 0x01, 0x10,
0x68, 0x00, 0x81, 0x06, 0x40, 0xa0, 0x01, 0x04, 0x1a, 0x00, 0x81, 0x06, 0x10, 0x68, 0x00, 0x04,
0x1a, 0x00, 0x81, 0x06, 0x10, 0x68, 0x00, 0x04, 0x1a, 0x40, 0xa0, 0x01, 0x10, 0x68, 0x00, 0x04,
0x1a, 0x40, 0xa0, 0x01, 0x10, 0x68, 0x00, 0x81, 0x06, 0x40, 0xa0, 0x01, 0x10, 0x68, 0x00, 0x81,
0x06, 0x40, 0xa0, 0x01, 0x04, 0x1a, 0x00, 0x81, 0x06, 0x10, 0x68, 0x00, 0x04, 0x1a, 0x00, 0x81,
0x06, 0x10, 0x68, 0x00, 0x04, 0x1a, 0x40, 0xa0, 0x01, 0x10, 0x68, 0x00, 0x04, 0x1a, 0x40, 0xa0,
0x01, 0x10, 0x68, 0x00, 0x81, 0x06, 0x40, 0xa0, 0x01, 0x04, 0x1a, 0x00, 0x81, 0x06, 0x40, 0xa0,
0x01, 0x04, 0x1a, 0x00, 0x81, 0x06, 0x10, 0x68, 0x00, 0x04, 0x1a, 0x00, 0x81, 0x06, 0x10, 0x68,
0x00, 0x04, 0x1a, 0x40, 0xa0, 0x01, 0x10, 0x68, 0x00, 0x81, 0x06, 0x20, 0x8b, 0xda, 0x0d, 0x01,
0xa4, 0xb1, 0x35, 0xf7, 0xea, 0xf8, 0xef, 0x9d, 0x63, 0x5d, 0x06, 0x04, 0x81, 0xe6, 0x14, 0x76,
0x16, 0xb6, 0x0e, 0xd6, 0xf6, 0x4f, 0xfe, 0x9b, 0xbd, 0xc5, 0xdd, 0xb8, 0x9d, 0xc8, 0x4a, 0x41,
0x62, 0xaa, 0xdb, 0x5b, 0xdc, 0x89, 0x61, 0xdc, 0x59, 0xd8, 0xae, 0x0c, 0x66, 0xfc, 0x79, 0xb8,
0x7e, 0x50, 0xfd, 0x43, 0x72, 0x23, 0xf9, 0xd6, 0x62, 0x5b, 0xc7, 0x68, 0x67, 0xfc, 0x19, 0x23,
0x5c, 0xf9, 0x8b, 0x91, 0xe4, 0x5c, 0xb4, 0x0c, 0x1f, 0x7e, 0x64, 0x14, 0x1a, 0xab, 0xc2, 0x47,
0x11, 0xd9, 0xae, 0xe4, 0xa3, 0xf2, 0x6f, 0x12, 0x23, 0xf2, 0x36, 0xf9, 0xbb, 0x85, 0x4a, 0x5c,
0xa2, 0x2c, 0x17, 0x9a, 0xec, 0x98, 0x7e, 0x2e, 0xdf, 0x7b, 0x5c, 0xe5, 0x0e, 0xbd, 0x0f, 0x07,
0x8a, 0x53, 0x03, 0xf5, 0x8a, 0xf2, 0xd6, 0x5c, 0x39, 0x1e, 0x61, 0xfc, 0xb9, 0xff, 0x78, 0xf7,
0xdd, 0x3f, 0x61, 0xdb, 0x70, 0xae, 0x32, 0x9e, 0x85, 0xf1, 0x6e, 0xb1, 0x46, 0xa0, 0x2f, 0x85,
0xa5, 0xd1, 0xef, 0x76, 0x1f, 0x6d, 0x5f, 0xe8, 0x97, 0xb8, 0x7a, 0xbf, 0x3b, 0xca, 0x72, 0x6d,
0xa2, 0x78, 0xee, 0x59, 0xc9, 0x60, 0xa0, 0xe3, 0x15, 0xae, 0x3c, 0xbb, 0xb9, 0x31, 0xbd, 0x72,
0xa1, 0xa3, 0x1a, 0x43, 0x1a, 0x99, 0x8e, 0x21, 0xf5, 0x04, 0xe6, 0x0c, 0xfc, 0x92, 0xb0, 0x61,
0x5c, 0x74, 0x9d, 0xc3, 0x2f, 0xdf, 0x6c, 0xbe, 0x78, 0xb0, 0xfc, 0xe4, 0xfa, 0x7f, 0x7e, 0x1e,
0x7f, 0x72, 0x72, 0xc9, 0xb5, 0xf9, 0xde, 0x85, 0x3c, 0x9f, 0xf8, 0x29, 0xbe, 0xcd, 0x95, 0x4f,
0x96, 0x2e, 0x7a, 0x54, 0x63, 0x48, 0xe3, 0xab, 0xfc, 0xb7, 0xf8, 0xef, 0xca, 0xdb, 0x1d, 0x38,
0x15, 0x6b, 0xd0, 0xfc, 0x75, 0x56, 0xe2, 0x96, 0xbf, 0x5b, 0x88, 0x59, 0x6d, 0x33, 0xad, 0x56,
0xc7, 0xab, 0xce, 0xda, 0xd4, 0xb3, 0xed, 0xf9, 0x72, 0x8d, 0xbf, 0xee, 0xe1, 0xfa, 0x41, 0x7b,
0x29, 0x77, 0xa1, 0x5f, 0xe2, 0xe5, 0xcc, 0x5a, 0x7c, 0x6b, 0x6f, 0x5b, 0xa2, 0x89, 0x1f, 0xe5,
0xe0, 0x5c, 0xc9, 0x13, 0xdb, 0x0c, 0x9a, 0xe6, 0x11, 0x21, 0x5b, 0xbe, 0xf7, 0x78, 0x75, 0xf2,
0xe9, 0x1b, 0xbf, 0x7b, 0x6c, 0x44, 0x7b, 0x8b, 0x3b, 0x31, 0x6b, 0x8e, 0x6f, 0xa7, 0xf6, 0x75,
0xbe, 0x72, 0xb4, 0xd0, 0x71, 0x71, 0x8b, 0xd1, 0x91, 0xe6, 0x1f, 0x4b, 0xdf, 0xc6, 0x3c, 0xfd,
0x5c, 0x16, 0xd0, 0x11, 0x68, 0x1a, 0xc9, 0xe6, 0x17, 0xab, 0x4b, 0xa3, 0xdf, 0x37, 0xf4, 0x3b,
0xf4, 0x8d, 0xe9, 0x95, 0xf8, 0x16, 0x5e, 0x7d, 0xb5, 0x5e, 0xaf, 0x07, 0x50, 0x18, 0xef, 0xbe,
0xa0, 0x37, 0x04, 0x4f, 0xc7, 0x16, 0xa5, 0xb9, 0x89, 0x59, 0xe2, 0x20, 0x59, 0xfc, 0xff, 0x1f,
0x21, 0x78, 0x6f, 0xf6, 0xfd, 0x86, 0x5b, 0xee, 0x38, 0x9a, 0x38, 0x2f, 0xd5, 0x65, 0xd6, 0x7c,
0xd2, 0xc9, 0x0d, 0x8e, 0xe7, 0x95, 0xe6, 0xba, 0xac, 0xd5, 0x20, 0xd0, 0x64, 0xd1, 0xe1, 0xfa,
0xc1, 0xf2, 0xbd, 0xc7, 0x03, 0x5f, 0xdf, 0x2e, 0x8c, 0xf7, 0x34, 0xca, 0x63, 0x2e, 0xcf, 0x6e,
0x44, 0x9d, 0xcf, 0xbc, 0x07, 0xf1, 0x0d, 0x95, 0xfd, 0xce, 0xbf, 0x75, 0x7f, 0x37, 0xfd, 0xa4,
0x35, 0x3e, 0xb0, 0xbd, 0xd4, 0x71, 0x8e, 0x2f, 0x39, 0xab, 0x93, 0xcb, 0xbf, 0x7c, 0xb3, 0xe9,
0x39, 0x29, 0xd0, 0x34, 0x8c, 0x96, 0xde, 0xd6, 0x8e, 0xd1, 0xce, 0xca, 0x51, 0x12, 0x1d, 0xa3,
0xbf, 0xa7, 0xe4, 0xe4, 0x9c, 0xb7, 0x72, 0xf0, 0xc5, 0xd1, 0x06, 0xea, 0xed, 0xa3, 0xc3, 0x31,
0xb6, 0x4e, 0xfb, 0xd6, 0x38, 0x7a, 0x37, 0x38, 0xd7, 0x11, 0x5f, 0x25, 0xfb, 0x03, 0xb2, 0x31,
0xbd, 0xf2, 0xe2, 0xc1, 0xf2, 0x99, 0x5b, 0x1c, 0xe3, 0xd6, 0x5e, 0xca, 0x1d, 0x0f, 0x69, 0x95,
0x5c, 0x46, 0xac, 0x8f, 0x36, 0xa7, 0xef, 0xc6, 0xac, 0xf6, 0x2f, 0xf7, 0x84, 0x9c, 0xd7, 0x1e,
0xbb, 0xf8, 0x5a, 0x31, 0x6b, 0xae, 0xe3, 0x42, 0x0d, 0x02, 0xcd, 0x19, 0xf5, 0x4c, 0xf6, 0x27,
0xee, 0x23, 0x3e, 0x0e, 0x6b, 0x61, 0xfc, 0xf7, 0x64, 0x97, 0x67, 0x37, 0x5f, 0xce, 0xac, 0xa5,
0x2c, 0x75, 0xcc, 0x46, 0x7f, 0x1e, 0x7f, 0x32, 0xb4, 0x70, 0x27, 0xe3, 0xc7, 0x5f, 0x3c, 0x9f,
0xf8, 0xe9, 0x0c, 0x21, 0xab, 0xec, 0x59, 0x3e, 0xd5, 0xd1, 0x25, 0x31, 0x35, 0x8e, 0xdb, 0xf1,
0xab, 0x60, 0xbc, 0xf8, 0x45, 0xa6, 0x63, 0x48, 0xe3, 0x76, 0x3c, 0x73, 0x7f, 0xf7, 0x05, 0xe8,
0xf8, 0xb4, 0x1b, 0xd3, 0xab, 0xeb, 0x9f, 0x3d, 0xf3, 0x3c, 0x17, 0x68, 0x2e, 0x91, 0xca, 0x0c,
0x31, 0xca, 0x5e, 0x7d, 0x93, 0xd6, 0x49, 0x71, 0x9f, 0xb8, 0x67, 0xdf, 0xf4, 0x60, 0xd3, 0xd4,
0xb9, 0x6d, 0x38, 0xd7, 0x33, 0xd9, 0x77, 0x2e, 0x87, 0xe7, 0xc4, 0x67, 0x28, 0x8c, 0xf7, 0x54,
0x56, 0x81, 0x62, 0x48, 0xe3, 0x16, 0x33, 0xeb, 0x77, 0x59, 0xdf, 0xa8, 0xa4, 0x39, 0xde, 0x0d,
0x9c, 0xd7, 0x42, 0x0d, 0x8d, 0xc5, 0x2e, 0x0e, 0x7e, 0x7d, 0x1b, 0x7e, 0x7b, 0xf1, 0xc3, 0xde,
0x87, 0xa9, 0x8e, 0xe5, 0xdb, 0xfc, 0x62, 0x35, 0xb3, 0x87, 0xb1, 0x9c, 0xaa, 0xce, 0x91, 0xe6,
0xfe, 0x2f, 0x87, 0xe2, 0x1b, 0x8f, 0xf7, 0x1f, 0xe7, 0xfe, 0x9e, 0x20, 0x86, 0x74, 0x70, 0xae,
0x34, 0x38, 0x37, 0x7c, 0xe6, 0xcf, 0x10, 0x5d, 0xfe, 0xb1, 0xf4, 0x6d, 0x4c, 0x9c, 0xd5, 0x59,
0xa0, 0xe1, 0x4a, 0x4c, 0xa5, 0x07, 0xbe, 0xbe, 0xdd, 0xd2, 0x9b, 0xfc, 0xac, 0x88, 0x49, 0x74,
0x06, 0x1f, 0x7f, 0x14, 0x2d, 0x7d, 0x9d, 0xe3, 0xd5, 0x68, 0x68, 0xe1, 0xce, 0x45, 0x1f, 0x84,
0x7d, 0xe6, 0xe9, 0x73, 0x8c, 0xf0, 0x8b, 0x07, 0xcb, 0xd2, 0x2c, 0xd0, 0xf0, 0xbb, 0x78, 0x7b,
0xfe, 0xde, 0xec, 0xfb, 0x89, 0x77, 0xdb, 0x9e, 0x2f, 0x67, 0x6d, 0x67, 0x74, 0x79, 0x76, 0x23,
0xe5, 0x6f, 0x05, 0x63, 0xe2, 0xfc, 0xb7, 0x7f, 0xdd, 0x89, 0x57, 0xa3, 0x2c, 0xaf, 0xa4, 0x77,
0x8c, 0xe6, 0x53, 0xde, 0x33, 0x5e, 0x50, 0xe3, 0xc5, 0x26, 0x37, 0x92, 0xf7, 0xec, 0x15, 0x68,
0x9a, 0x5f, 0xe7, 0x58, 0xd7, 0xf5, 0xcf, 0x6f, 0xa6, 0x99, 0xae, 0x66, 0xe7, 0x31, 0x57, 0xf6,
0x3b, 0xa7, 0xb9, 0xe7, 0xd5, 0xfb, 0xdd, 0x31, 0x71, 0xce, 0xfe, 0x46, 0x94, 0x94, 0x5b, 0xce,
0xbb, 0x3e, 0xee, 0x8d, 0x6f, 0x27, 0xe3, 0x2f, 0x36, 0x08, 0x34, 0xe7, 0xa9, 0x67, 0xb2, 0x3f,
0x7f, 0xb7, 0x90, 0x34, 0x63, 0xcd, 0xd0, 0x56, 0xdc, 0x9f, 0xc7, 0x9f, 0xa4, 0x59, 0x0d, 0x88,
0x9c, 0xc5, 0xfb, 0x83, 0x86, 0x68, 0x59, 0x3c, 0xc8, 0xea, 0x93, 0xe2, 0x78, 0xa5, 0xb9, 0xf5,
0xc3, 0x07, 0x37, 0x66, 0x6e, 0x9d, 0xe3, 0x26, 0x6b, 0x04, 0x9a, 0xc6, 0x90, 0xb8, 0x69, 0x2f,
0x82, 0x98, 0x91, 0x5f, 0x15, 0xae, 0x4d, 0x3d, 0x4b, 0x73, 0x52, 0xba, 0xa8, 0x73, 0xe4, 0xac,
0x81, 0x7e, 0x04, 0x6f, 0x3b, 0x26, 0x28, 0x5e, 0x3b, 0x6f, 0xfe, 0x73, 0x38, 0x5e, 0x69, 0xa4,
0x59, 0xa0, 0xb9, 0xa4, 0xe2, 0x2d, 0x76, 0xe2, 0x24, 0x7a, 0x6b, 0xae, 0xfe, 0x87, 0x1a, 0xef,
0x2d, 0xee, 0xa4, 0xd9, 0x20, 0xdc, 0x70, 0x75, 0xbe, 0xf2, 0x57, 0x07, 0x88, 0xb7, 0x0d, 0xe7,
0x22, 0xcd, 0x83, 0x73, 0x25, 0x17, 0xc4, 0x11, 0x68, 0x2e, 0xbb, 0xc4, 0x1d, 0x0e, 0x59, 0x98,
0x41, 0xa7, 0x59, 0x7a, 0xce, 0x8d, 0xe4, 0xb3, 0xbc, 0x71, 0xbb, 0xca, 0x6b, 0xe4, 0xc9, 0x34,
0x57, 0x76, 0x04, 0x4a, 0xf3, 0xa5, 0xe2, 0x40, 0x15, 0x4e, 0x31, 0x83, 0xfb, 0xd3, 0xec, 0xb5,
0xce, 0x27, 0x51, 0x8b, 0x57, 0x88, 0xc4, 0x13, 0x06, 0xb5, 0xf4, 0xb6, 0x36, 0xca, 0xba, 0xf3,
0x9f, 0xc5, 0x9b, 0x98, 0x9d, 0x85, 0xad, 0x9e, 0xc9, 0xfe, 0x9e, 0xc9, 0x3e, 0xbf, 0x06, 0x14,
0x68, 0x38, 0xf1, 0xe4, 0x28, 0x75, 0x44, 0xdd, 0xaa, 0xfc, 0xf2, 0xad, 0xee, 0x67, 0xb9, 0x4c,
0xb3, 0x1d, 0xbb, 0x38, 0x35, 0xd0, 0xb8, 0x6b, 0xb5, 0x31, 0xf1, 0x6f, 0x2f, 0xe5, 0xa4, 0xf9,
0xd2, 0xb2, 0xc4, 0x41, 0x35, 0x59, 0xde, 0x8e, 0x96, 0x66, 0xfa, 0x1c, 0x33, 0xd0, 0x98, 0x7e,
0x36, 0xf4, 0xf8, 0xab, 0xb3, 0x40, 0x43, 0xe3, 0xd9, 0x98, 0x5e, 0x4d, 0x33, 0x03, 0x35, 0x50,
0x08, 0x34, 0x66, 0xd0, 0x35, 0xb5, 0xb7, 0xb8, 0x93, 0x78, 0x4e, 0xe4, 0xae, 0x8f, 0x7b, 0x1b,
0xe2, 0xcc, 0xa8, 0x20, 0xd0, 0x9c, 0x45, 0x66, 0xaf, 0x46, 0x98, 0xe6, 0x30, 0x99, 0xc4, 0xad,
0xdc, 0x20, 0xd0, 0x34, 0xb0, 0xba, 0xef, 0xd3, 0x78, 0x9b, 0xc4, 0xf5, 0x8d, 0xfc, 0xdd, 0x82,
0xe3, 0x38, 0x10, 0x68, 0xa8, 0xb5, 0x34, 0xd7, 0x82, 0xb9, 0xe8, 0xd3, 0xd4, 0x81, 0x40, 0x53,
0xff, 0x14, 0x56, 0xf9, 0xaf, 0x6d, 0xc3, 0xb9, 0xba, 0x3c, 0xaa, 0xc4, 0x03, 0x64, 0x5a, 0x7a,
0x5b, 0x05, 0x1a, 0x81, 0xa6, 0x99, 0xed, 0x2d, 0xee, 0x54, 0x3f, 0x03, 0x51, 0x7b, 0xa9, 0x3e,
0x81, 0x4e, 0x5c, 0x80, 0x7e, 0xf7, 0xab, 0x4c, 0x81, 0x40, 0x93, 0x69, 0x89, 0x1d, 0xac, 0xd7,
0x61, 0xc7, 0x89, 0xdb, 0x9f, 0x1d, 0x0f, 0x8d, 0x40, 0xd3, 0xe4, 0x5e, 0xce, 0xac, 0x55, 0xbf,
0x43, 0xfa, 0x93, 0xca, 0x9f, 0xa3, 0x34, 0x27, 0x00, 0x49, 0x3c, 0x48, 0x1d, 0x04, 0x9a, 0x06,
0x16, 0x1d, 0x4c, 0x3c, 0x87, 0x67, 0x5d, 0x26, 0xaa, 0x89, 0x57, 0x72, 0x69, 0x1b, 0xce, 0xd9,
0xbf, 0x81, 0x40, 0xd3, 0xcc, 0x12, 0x4f, 0x73, 0x91, 0x1b, 0xc9, 0xd7, 0xe5, 0x28, 0xe4, 0xc4,
0x40, 0x3b, 0x38, 0x05, 0x81, 0xa6, 0x99, 0x95, 0x67, 0x37, 0x12, 0xd7, 0x79, 0xeb, 0x75, 0x8e,
0x8b, 0xc4, 0xad, 0xd9, 0x02, 0x8d, 0x40, 0xd3, 0xb4, 0x62, 0x8a, 0x9a, 0x78, 0x92, 0xe5, 0x96,
0xde, 0xd6, 0x7a, 0xed, 0x94, 0x48, 0x31, 0x83, 0x76, 0xf9, 0x54, 0x04, 0x9a, 0x66, 0xb4, 0xb7,
0xb8, 0x93, 0xe6, 0xfa, 0x7e, 0x31, 0x7d, 0xae, 0xd7, 0x59, 0xd6, 0x12, 0x1f, 0x9b, 0xd3, 0xbf,
0xd1, 0x34, 0x9c, 0x0f, 0x9a, 0x3f, 0x4c, 0x4e, 0x9f, 0x8e, 0x2d, 0x26, 0x16, 0x30, 0xa6, 0xcf,
0x3d, 0x93, 0x7d, 0xf5, 0x7a, 0xfd, 0x48, 0xbc, 0x8f, 0x25, 0x0e, 0xcc, 0xa0, 0x69, 0x36, 0x6b,
0x53, 0xcf, 0xfe, 0xf7, 0x8f, 0xef, 0xd3, 0x5c, 0x1b, 0xbb, 0x6f, 0x7a, 0xb0, 0x5e, 0xb3, 0xd4,
0x34, 0xe7, 0x06, 0x31, 0x83, 0xc6, 0x0c, 0x9a, 0xe6, 0xf1, 0x72, 0x66, 0x2d, 0xea, 0x9c, 0xf2,
0xf2, 0x28, 0x57, 0xef, 0x77, 0x3b, 0x8a, 0x1a, 0x04, 0x9a, 0x8b, 0xb5, 0xb3, 0xb0, 0x15, 0x69,
0x2e, 0xcf, 0x6e, 0xa6, 0xbf, 0x72, 0x55, 0x6e, 0x24, 0x7f, 0x63, 0x66, 0xc8, 0xd0, 0x81, 0x40,
0x73, 0x0a, 0x1b, 0xd3, 0x2b, 0x5b, 0x73, 0xaf, 0x3a, 0xc7, 0xba, 0x5a, 0x8b, 0xad, 0xc7, 0x8b,
0xb0, 0xc7, 0x07, 0x92, 0x1c, 0xac, 0xed, 0x57, 0x36, 0x3f, 0xec, 0x2d, 0xee, 0xc6, 0x2d, 0xee,
0x19, 0xff, 0x98, 0x66, 0x35, 0xe3, 0x8d, 0x3a, 0x0f, 0xce, 0x95, 0x2c, 0x20, 0x80, 0x40, 0x73,
0x3a, 0x51, 0xdb, 0xed, 0xf9, 0x72, 0xe2, 0xe6, 0xe5, 0x33, 0x3b, 0x9a, 0x3b, 0xdf, 0x52, 0x67,
0x10, 0x68, 0xb2, 0xc5, 0xdc, 0x19, 0xea, 0xc2, 0x2e, 0x0e, 0x12, 0x74, 0x7f, 0xda, 0x37, 0xb4,
0xf0, 0x77, 0x75, 0x06, 0x33, 0x68, 0x32, 0xa4, 0x6d, 0x38, 0x77, 0x63, 0x66, 0xc8, 0xa9, 0x3b,
0x41, 0xa0, 0xc9, 0x90, 0xa3, 0x43, 0x51, 0xfa, 0x5d, 0x74, 0x15, 0x04, 0x9a, 0x6c, 0xcd, 0x9a,
0x7b, 0x26, 0xfb, 0xae, 0x4d, 0x14, 0xb3, 0xb9, 0xa6, 0x91, 0xe6, 0x51, 0x55, 0x76, 0xb3, 0xf8,
0x51, 0x22, 0xd0, 0x34, 0x4f, 0x97, 0x0b, 0xe3, 0xaf, 0x8f, 0x40, 0xc9, 0xf8, 0x71, 0xd2, 0x0e,
0xe3, 0x46, 0xa0, 0xb9, 0x14, 0x72, 0x23, 0xf9, 0xe8, 0x5d, 0xdc, 0x62, 0xbe, 0xd9, 0x4c, 0xe1,
0xdb, 0x9a, 0x2b, 0x9b, 0x41, 0x23, 0xd0, 0x64, 0x48, 0xef, 0xc3, 0x81, 0x6b, 0x13, 0xbd, 0x95,
0xe3, 0x50, 0xaa, 0x9c, 0xb0, 0xa2, 0xbd, 0x94, 0x8b, 0x5b, 0x6b, 0xb1, 0xad, 0x71, 0x8b, 0x9c,
0xbf, 0x5b, 0xa8, 0xbe, 0xdd, 0x3b, 0xcd, 0x09, 0x95, 0x40, 0xa0, 0xa9, 0xed, 0xcf, 0xb2, 0xd4,
0x71, 0x19, 0x2e, 0xf5, 0x94, 0xb8, 0x0c, 0x1d, 0x33, 0x68, 0x4f, 0x06, 0x9a, 0xe4, 0xd9, 0x6e,
0x08, 0x68, 0x2c, 0x89, 0x73, 0xff, 0xfd, 0xc7, 0xbb, 0x07, 0x6b, 0xfb, 0x06, 0x0a, 0x81, 0x86,
0x5a, 0x4b, 0x73, 0xc5, 0xee, 0xf2, 0xec, 0xa6, 0x81, 0x42, 0xa0, 0x21, 0x73, 0x33, 0xe8, 0x2b,
0x47, 0x3b, 0xed, 0x0c, 0x14, 0x02, 0x0d, 0x35, 0x7f, 0xca, 0x16, 0xdb, 0x72, 0x23, 0x79, 0x33,
0x68, 0x04, 0x1a, 0xb2, 0x28, 0x71, 0x17, 0xdd, 0xe1, 0xfa, 0x41, 0x79, 0x76, 0xc3, 0x40, 0x21,
0xd0, 0x50, 0xfb, 0x40, 0x27, 0x2f, 0x43, 0x6f, 0x4c, 0xaf, 0x1a, 0x28, 0x04, 0x1a, 0x6a, 0xad,
0x30, 0xde, 0xd3, 0xd2, 0x9b, 0xf0, 0xd4, 0xdd, 0x9e, 0x2f, 0xdb, 0x10, 0x8d, 0x40, 0x43, 0x5d,
0x1a, 0xdd, 0x9d, 0x78, 0x9f, 0xb5, 0xa9, 0x67, 0x06, 0x0a, 0x81, 0x86, 0x5a, 0x4b, 0x73, 0xe1,
0xda, 0x57, 0x5f, 0xad, 0x57, 0x2e, 0xf4, 0x05, 0x02, 0x0d, 0xb5, 0xd3, 0x39, 0xd6, 0xd5, 0x36,
0x9c, 0x4b, 0xbc, 0xdb, 0xea, 0xe4, 0x53, 0x63, 0x85, 0x40, 0x43, 0xad, 0xa5, 0x39, 0x5d, 0xf5,
0xf6, 0x7c, 0x79, 0x63, 0x7a, 0xc5, 0x58, 0x21, 0xd0, 0x50, 0x53, 0xd7, 0x26, 0x8a, 0x69, 0x26,
0xd1, 0x6b, 0x53, 0xcf, 0x2c, 0x74, 0x20, 0xd0, 0x90, 0xc5, 0x49, 0xf4, 0xe1, 0xfa, 0xc1, 0xf3,
0x89, 0x9f, 0x9c, 0x9d, 0x03, 0x81, 0x86, 0x2c, 0x4e, 0xa2, 0x77, 0x1f, 0x6d, 0x3f, 0x1d, 0x5b,
0x34, 0x5c, 0x08, 0x34, 0xd4, 0xd4, 0x8d, 0x99, 0xa1, 0x34, 0x77, 0x8b, 0x46, 0xc7, 0x3c, 0xda,
0x70, 0x21, 0xd0, 0x50, 0x3b, 0x9d, 0x63, 0x5d, 0x57, 0xef, 0x77, 0xa7, 0xb9, 0xe7, 0xab, 0xaf,
0xd6, 0x97, 0x46, 0xbf, 0xb3, 0xd6, 0x81, 0x40, 0x43, 0x4d, 0x27, 0xd1, 0x69, 0x16, 0x3a, 0xae,
0xfc, 0xb6, 0xd6, 0xe1, 0x77, 0x86, 0x08, 0x34, 0xd4, 0xea, 0x49, 0x5c, 0x6c, 0x7b, 0x6f, 0xf6,
0xfd, 0x94, 0x77, 0xae, 0x34, 0xda, 0xde, 0x3b, 0x04, 0x1a, 0x6a, 0xa4, 0x63, 0xb4, 0xb3, 0xff,
0xcb, 0xa1, 0x94, 0x77, 0x3e, 0x5c, 0x3f, 0x78, 0xf1, 0x60, 0x39, 0x32, 0xed, 0xb4, 0xd1, 0x08,
0x34, 0xd4, 0xc2, 0xb5, 0x89, 0x62, 0xf7, 0xa7, 0x7d, 0xe9, 0xef, 0xbf, 0x3d, 0x5f, 0x5e, 0xbe,
0xf7, 0xf8, 0x42, 0x33, 0x1d, 0x9f, 0xd9, 0x0e, 0x3f, 0x04, 0x1a, 0x5e, 0xeb, 0x9b, 0x1e, 0xec,
0xfa, 0xb8, 0xf7, 0x54, 0x1f, 0x52, 0xc9, 0xf4, 0xd2, 0xe8, 0x77, 0x2f, 0x67, 0xd6, 0xce, 0xab,
0xa4, 0x3b, 0x0b, 0x5b, 0x1b, 0xd3, 0x2b, 0x3f, 0x96, 0xbe, 0x8d, 0xcf, 0xfc, 0xea, 0xab, 0x75,
0xf3, 0x74, 0xce, 0xcc, 0x55, 0xbd, 0x69, 0x2a, 0x37, 0x66, 0x6e, 0x5d, 0x39, 0xda, 0xb0, 0x71,
0xaa, 0x8f, 0xda, 0x7d, 0xb4, 0xbd, 0xf2, 0xc9, 0xd2, 0xca, 0x27, 0x57, 0x72, 0x23, 0xf9, 0xc2,
0x78, 0x4f, 0xe7, 0x58, 0xa1, 0x63, 0xb4, 0x33, 0xf1, 0xf2, 0xe1, 0x6f, 0x4c, 0x96, 0xa3, 0xcb,
0x71, 0xdb, 0x9a, 0x2b, 0xef, 0x3f, 0xde, 0xfd, 0xe3, 0x7f, 0x2a, 0xc7, 0xe7, 0xf4, 0xa3, 0x41,
0xa0, 0xe1, 0x75, 0xa3, 0x23, 0xaf, 0x2f, 0x1e, 0x2c, 0x9f, 0xe1, 0x63, 0xa3, 0xd4, 0xeb, 0x8f,
0x9e, 0xad, 0x7f, 0xf6, 0xfa, 0xef, 0x2d, 0xbd, 0xad, 0xf1, 0x79, 0xda, 0x4b, 0xb9, 0xf6, 0x52,
0xc7, 0xdb, 0xa2, 0x5c, 0x99, 0x2f, 0x1f, 0xae, 0x1f, 0x54, 0x6f, 0xb7, 0x1f, 0x0a, 0x02, 0x0d,
0xbf, 0xea, 0x99, 0xec, 0x8f, 0xb0, 0x3e, 0x9f, 0x58, 0xaa, 0x9e, 0xce, 0xea, 0xe2, 0x63, 0xb7,
0xe7, 0xcb, 0xdb, 0xf3, 0xef, 0xfa, 0x60, 0x22, 0xfa, 0x07, 0x6b, 0xfb, 0xa7, 0x9a, 0x8f, 0x43,
0x85, 0x35, 0x68, 0x9a, 0x53, 0x61, 0xbc, 0x67, 0x68, 0xe1, 0x4e, 0xfe, 0x6e, 0x21, 0x0b, 0x0f,
0xc6, 0x24, 0x1a, 0x81, 0x86, 0x3f, 0xbe, 0x3d, 0x2c, 0x75, 0x0c, 0xce, 0x95, 0xae, 0x7f, 0x7e,
0x33, 0xf1, 0xfa, 0x58, 0x17, 0x1f, 0xe8, 0xb2, 0x1f, 0x07, 0x02, 0x0d, 0x6f, 0xea, 0x99, 0xec,
0xbf, 0xbd, 0xf8, 0xe1, 0x69, 0x77, 0x77, 0x98, 0x41, 0x23, 0xd0, 0x50, 0x93, 0x67, 0x79, 0xb1,
0xed, 0xc6, 0xcc, 0xad, 0x5b, 0x3f, 0x7c, 0x50, 0xaf, 0x4c, 0xef, 0x2d, 0xee, 0xfa, 0x29, 0x20,
0xd0, 0xf0, 0x56, 0xed, 0xa5, 0x8e, 0x4a, 0xa6, 0x7b, 0x1f, 0x0e, 0xa4, 0x3c, 0x77, 0xc7, 0xbb,
0x8b, 0x2f, 0x74, 0xfd, 0xf3, 0x9b, 0x31, 0x85, 0x37, 0xfe, 0x9c, 0xe5, 0x49, 0x6b, 0x08, 0xb8,
0x6c, 0x99, 0x2e, 0x4e, 0x0d, 0xc4, 0x6d, 0x67, 0x61, 0xeb, 0xe5, 0xcc, 0x5a, 0x79, 0x76, 0xf3,
0x8d, 0x6d, 0xcb, 0xe7, 0x22, 0x7f, 0xb7, 0x50, 0x18, 0xef, 0xee, 0x1c, 0xeb, 0xea, 0x18, 0xed,
0x34, 0xe6, 0x9c, 0x59, 0xcb, 0xf0, 0xe1, 0x47, 0x46, 0xa1, 0x21, 0x54, 0x5f, 0xc7, 0xac, 0xb2,
0x5d, 0x37, 0x0b, 0x0e, 0xd6, 0xf6, 0xab, 0x9f, 0x43, 0xae, 0x8e, 0x8f, 0x7f, 0x6f, 0x71, 0x67,
0x6b, 0xae, 0x5c, 0x39, 0xcc, 0x64, 0x7b, 0xfe, 0x2c, 0xbf, 0xcd, 0xab, 0xec, 0x98, 0xae, 0x6c,
0x9a, 0xae, 0x57, 0x94, 0xe3, 0xc1, 0x57, 0x39, 0x12, 0xb2, 0xb5, 0xd8, 0xe6, 0xa5, 0x42, 0xa0,
0xa1, 0xe1, 0x1d, 0xbf, 0x96, 0x54, 0xd9, 0x7a, 0xd1, 0x5a, 0x6c, 0xad, 0xf4, 0x4e, 0xf8, 0x10,
0x68, 0x80, 0xcb, 0xc8, 0x2f, 0x09, 0x01, 0x04, 0x1a, 0x00, 0x81, 0x06, 0x10, 0x68, 0x00, 0x04,
0x1a, 0x40, 0xa0, 0x01, 0x10, 0x68, 0x00, 0x04, 0x1a, 0x40, 0xa0, 0x01, 0x10, 0x68, 0x00, 0x81,
0x06, 0x40, 0xa0, 0x01, 0x10, 0x68, 0x00, 0x81, 0x06, 0x40, 0xa0, 0x01, 0x04, 0x1a, 0x00, 0x81,
0x06, 0x10, 0x68, 0x00, 0x04, 0x1a, 0x00, 0x81, 0x06, 0x10, 0x68, 0x00, 0x04, 0x1a, 0x40, 0xa0,
0x01, 0x10, 0x68, 0x00, 0x04, 0x1a, 0x40, 0xa0, 0x01, 0x10, 0x68, 0x00, 0x81, 0x06, 0x40, 0xa0,
0x01, 0x04, 0x1a, 0x00, 0x81, 0x06, 0x40, 0xa0, 0x01, 0x04, 0x1a, 0x00, 0x81, 0x06, 0x10, 0x68,
0x00, 0x04, 0x1a, 0x00, 0x81, 0x06, 0x10, 0x68, 0x00, 0x04, 0x1a, 0x40, 0xa0, 0x01, 0x10, 0x68,
0x00, 0x81, 0x36, 0x04, 0x00, 0x02, 0x0d, 0x80, 0x40, 0x03, 0x08, 0x34, 0x00, 0x02, 0x0d, 0x20,
0xd0, 0x00, 0x08, 0x34, 0x00, 0x02, 0x0d, 0x20, 0xd0, 0x00, 0x08, 0x34, 0x80, 0x40, 0x03, 0x20,
0xd0, 0x00, 0x08, 0x34, 0x80, 0x40, 0x03, 0x20, 0xd0, 0x00, 0x02, 0x0d, 0x80, 0x40, 0x03, 0x08,
0x34, 0x00, 0x02, 0x0d, 0x80, 0x40, 0x03, 0x08, 0x34, 0x00, 0x02, 0x0d, 0x20, 0xd0, 0x00, 0x08,
0x34, 0x00, 0x02, 0x0d, 0x20, 0xd0, 0x00, 0x08, 0x34, 0x80, 0x40, 0x03, 0x20, 0xd0, 0x00, 0x02,
0x0d, 0x80, 0x40, 0x03, 0x20, 0xd0, 0x00, 0x02, 0x0d, 0x80, 0x40, 0x03, 0x08, 0x34, 0x00, 0x02,
0x0d, 0x80, 0x40, 0x03, 0x08, 0x34, 0x00, 0x02, 0x0d, 0x20, 0xd0, 0x00, 0x08, 0x34, 0x80, 0x40,
0x03, 0x20, 0xd0, 0x00, 0x08, 0x34, 0x80, 0x40, 0x03, 0x20, 0xd0, 0x00, 0x02, 0x0d, 0x80, 0x40,
0x03, 0x20, 0xd0, 0x00, 0x02, 0x0d, 0x80, 0x40, 0x03, 0x08, 0x34, 0x00, 0x02, 0x0d, 0x80, 0x40,
0x03, 0x08, 0x34, 0x00, 0x02, 0x0d, 0x20, 0xd0, 0x00, 0x08, 0x34, 0x80, 0x40, 0x03, 0x20, 0xd0,
0x00, 0x08, 0x34, 0x40, 0x23, 0xfa, 0xbf, 0x00, 0x03, 0x00, 0x60, 0x2f, 0x3c, 0xc6, 0xbd, 0xc0,
0x07, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
#endif

369
src/samples/savedata/utility/main.c Normal file
View File

@@ -0,0 +1,369 @@
/*
* PSP Software Development Kit - http://www.pspdev.org
* -----------------------------------------------------------------------
* Licensed under the BSD license, see LICENSE in PSPSDK root for details.
*
* main.c - Sample to demonstrate how to use savedata utility
*
* Copyright (c) 2005 weltall (weltall@consoleworld.org)
* (c) 2007 InsertWittyName (tias_dp@hotmail.com)
* Based on work by Shine
*
* $Id: main.c 2364 2008-02-16 22:07:09Z iwn $
*/
#include <pspkernel.h>
#include <pspdisplay.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <pspmoduleinfo.h>
#include <pspdebug.h>
#include <pspgu.h>
#include <pspgum.h>
#include <psputility.h>
#include <pspctrl.h>
#include "data.h"
PSP_MODULE_INFO("Savedata Sample", 0, 1, 1);
#if _PSP_FW_VERSION >= 200
PSP_HEAP_SIZE_KB(20480);
#endif
#define BUF_WIDTH (512)
#define SCR_WIDTH (480)
#define SCR_HEIGHT (272)
#define PIXEL_SIZE (4) /* change this if you change to another screenmode */
#define FRAME_SIZE (BUF_WIDTH * SCR_HEIGHT * PIXEL_SIZE)
#define ZBUF_SIZE (BUF_WIDTH SCR_HEIGHT * 2) /* zbuffer seems to be 16-bit? */
#define DATABUFFLEN 0x20
static int running = 1;
char string[128];
// Exit callback
int exit_callback(int arg1, int arg2, void *common)
{
running = 0;
return 0;
}
// Callback thread
int CallbackThread(SceSize args, void *argp)
{
int cbid;
cbid = sceKernelCreateCallback("Exit Callback", exit_callback, NULL);
sceKernelRegisterExitCallback(cbid);
sceKernelSleepThreadCB();
return 0;
}
// Sets up the callback thread and returns its thread id
int SetupCallbacks(void)
{
int thid = 0;
thid = sceKernelCreateThread("update_thread", CallbackThread, 0x11, 0xFA0, 0, 0);
if (thid >= 0)
sceKernelStartThread(thid, 0, 0);
return thid;
}
// Graphics stuff, based on cube sample
static unsigned int __attribute__((aligned(16))) list[262144];
struct Vertex
{
float u, v;
unsigned int color;
float x, y, z;
};
struct Vertex __attribute__((aligned(16))) vertices[12*3] =
{
{0, 0, 0xff7f0000,-1,-1, 1}, // 0
{1, 0, 0xff7f0000,-1, 1, 1}, // 4
{1, 1, 0xff7f0000, 1, 1, 1}, // 5
{0, 0, 0xff7f0000,-1,-1, 1}, // 0
{1, 1, 0xff7f0000, 1, 1, 1}, // 5
{0, 1, 0xff7f0000, 1,-1, 1}, // 1
{0, 0, 0xff7f0000,-1,-1,-1}, // 3
{1, 0, 0xff7f0000, 1,-1,-1}, // 2
{1, 1, 0xff7f0000, 1, 1,-1}, // 6
{0, 0, 0xff7f0000,-1,-1,-1}, // 3
{1, 1, 0xff7f0000, 1, 1,-1}, // 6
{0, 1, 0xff7f0000,-1, 1,-1}, // 7
{0, 0, 0xff007f00, 1,-1,-1}, // 0
{1, 0, 0xff007f00, 1,-1, 1}, // 3
{1, 1, 0xff007f00, 1, 1, 1}, // 7
{0, 0, 0xff007f00, 1,-1,-1}, // 0
{1, 1, 0xff007f00, 1, 1, 1}, // 7
{0, 1, 0xff007f00, 1, 1,-1}, // 4
{0, 0, 0xff007f00,-1,-1,-1}, // 0
{1, 0, 0xff007f00,-1, 1,-1}, // 3
{1, 1, 0xff007f00,-1, 1, 1}, // 7
{0, 0, 0xff007f00,-1,-1,-1}, // 0
{1, 1, 0xff007f00,-1, 1, 1}, // 7
{0, 1, 0xff007f00,-1,-1, 1}, // 4
{0, 0, 0xff00007f,-1, 1,-1}, // 0
{1, 0, 0xff00007f, 1, 1,-1}, // 1
{1, 1, 0xff00007f, 1, 1, 1}, // 2
{0, 0, 0xff00007f,-1, 1,-1}, // 0
{1, 1, 0xff00007f, 1, 1, 1}, // 2
{0, 1, 0xff00007f,-1, 1, 1}, // 3
{0, 0, 0xff00007f,-1,-1,-1}, // 4
{1, 0, 0xff00007f,-1,-1, 1}, // 7
{1, 1, 0xff00007f, 1,-1, 1}, // 6
{0, 0, 0xff00007f,-1,-1,-1}, // 4
{1, 1, 0xff00007f, 1,-1, 1}, // 6
{0, 1, 0xff00007f, 1,-1,-1}, // 5
};
static void SetupGu()
{
sceGuInit();
sceGuStart(GU_DIRECT,list);
sceGuDrawBuffer(GU_PSM_8888,(void*)0,BUF_WIDTH);
sceGuDispBuffer(SCR_WIDTH,SCR_HEIGHT,(void*)0x88000,BUF_WIDTH);
sceGuDepthBuffer((void*)0x110000,BUF_WIDTH);
sceGuOffset(2048 - (SCR_WIDTH/2),2048 - (SCR_HEIGHT/2));
sceGuViewport(2048,2048,SCR_WIDTH,SCR_HEIGHT);
sceGuDepthRange(0xc350,0x2710);
sceGuScissor(0,0,SCR_WIDTH,SCR_HEIGHT);
sceGuEnable(GU_SCISSOR_TEST);
sceGuDepthFunc(GU_GEQUAL);
sceGuEnable(GU_DEPTH_TEST);
sceGuFrontFace(GU_CW);
sceGuShadeModel(GU_SMOOTH);
sceGuEnable(GU_CULL_FACE);
sceGuEnable(GU_CLIP_PLANES);
sceGuFinish();
sceGuSync(0,0);
sceDisplayWaitVblankStart();
sceGuDisplay(GU_TRUE);
}
static void DrawStuff(void)
{
static int val = 0;
sceGuStart(GU_DIRECT,list);
// Clear screen
sceGuClearColor(0xff554433);
sceGuClearDepth(0);
sceGuClear(GU_COLOR_BUFFER_BIT|GU_DEPTH_BUFFER_BIT);
// Setup matrices for cube
sceGumMatrixMode(GU_PROJECTION);
sceGumLoadIdentity();
sceGumPerspective(75.0f,16.0f/9.0f,0.5f,1000.0f);
sceGumMatrixMode(GU_VIEW);
sceGumLoadIdentity();
sceGumMatrixMode(GU_MODEL);
sceGumLoadIdentity();
{
ScePspFVector3 pos = { 0, 0, -2.5f };
ScePspFVector3 rot = { val * 0.79f * (M_PI/180.0f), val * 0.98f * (M_PI/180.0f), val * 1.32f * (M_PI/180.0f) };
sceGumRotateXYZ(&rot);
sceGumTranslate(&pos);
}
// Draw cube
sceGuAmbientColor(0xffffffff);
sceGumDrawArray(GU_TRIANGLES,GU_TEXTURE_32BITF|GU_COLOR_8888|GU_VERTEX_32BITF|GU_TRANSFORM_3D,12*3,0,vertices);
sceGuFinish();
sceGuSync(0,0);
val ++;
}
PspUtilitySavedataListSaveNewData newData;
char *titleShow = "New Save";
char nameMultiple[][20] = // End list with ""
{
"0000",
"0001",
"0002",
"0003",
"0004",
""
};
char key[] = "QTAK319JQKJ952HA"; // Key to encrypt or decrypt savedata
void initSavedata(SceUtilitySavedataParam * savedata, int mode)
{
memset(savedata, 0, sizeof(SceUtilitySavedataParam));
savedata->base.size = sizeof(SceUtilitySavedataParam);
savedata->base.language = PSP_SYSTEMPARAM_LANGUAGE_ENGLISH;
savedata->base.buttonSwap = PSP_UTILITY_ACCEPT_CROSS;
savedata->base.graphicsThread = 0x11;
savedata->base.accessThread = 0x13;
savedata->base.fontThread = 0x12;
savedata->base.soundThread = 0x10;
savedata->mode = mode;
savedata->overwrite = 1;
savedata->focus = PSP_UTILITY_SAVEDATA_FOCUS_LATEST; // Set initial focus to the newest file (for loading)
#if _PSP_FW_VERSION >= 200
strncpy(savedata->key, key, 16);
#endif
strcpy(savedata->gameName, "DEMO11111"); // First part of the save name, game identifier name
strcpy(savedata->saveName, "0000"); // Second part of the save name, save identifier name
// List of multiple names
savedata->saveNameList = nameMultiple;
strcpy(savedata->fileName, "DATA.BIN"); // name of the data file
// Allocate buffers used to store various parts of the save data
savedata->dataBuf = malloc(DATABUFFLEN);
savedata->dataBufSize = DATABUFFLEN;
savedata->dataSize = DATABUFFLEN;
// Set some data
if (mode == PSP_UTILITY_SAVEDATA_LISTSAVE)
{
memset(savedata->dataBuf, 0, DATABUFFLEN);
strcpy(savedata->dataBuf,"score: 10");
strcpy(savedata->sfoParam.title,"Title");
strcpy(savedata->sfoParam.savedataTitle,"Title 2");
strcpy(savedata->sfoParam.detail,"Details");
savedata->sfoParam.parentalLevel = 1;
// No icon1
savedata->icon1FileData.buf = NULL;
savedata->icon1FileData.bufSize = 0;
savedata->icon1FileData.size = 0;
savedata->pic1FileData.buf = pic1;
savedata->pic1FileData.bufSize = size_pic1;
savedata->pic1FileData.size = size_pic1;
savedata->icon0FileData.buf = icon0;
savedata->icon0FileData.bufSize = size_icon0;
savedata->icon0FileData.size = size_icon0;
// No snd0
savedata->snd0FileData.buf = NULL;
savedata->snd0FileData.bufSize = 0;
savedata->snd0FileData.size = 0;
// Set title
newData.title = titleShow;
// Set new data
savedata->newData = &newData;
savedata->focus = PSP_UTILITY_SAVEDATA_FOCUS_FIRSTEMPTY; // If saving, set inital focus to the first empty slot
}
}
static void ShowSaveDialog (int mode)
{
SceUtilitySavedataParam dialog;
initSavedata(&dialog, mode);
sceUtilitySavedataInitStart(&dialog);
while(running) {
DrawStuff();
switch(sceUtilitySavedataGetStatus()) {
case PSP_UTILITY_DIALOG_VISIBLE :
sceUtilitySavedataUpdate(1);
break;
case PSP_UTILITY_DIALOG_QUIT :
sceUtilitySavedataShutdownStart();
break;
case PSP_UTILITY_DIALOG_FINISHED :
if(mode == PSP_UTILITY_SAVEDATA_LISTSAVE)
sprintf(string, "Saved: score = 10");
else
sprintf(string, "Loaded: %s\n", (char*)dialog.dataBuf); // The actual data in the savedata file that was saved previously
case PSP_UTILITY_DIALOG_NONE :
return;
}
sceDisplayWaitVblankStart();
sceGuSwapBuffers();
}
}
int main(int argc, char *argv[])
{
SceCtrlData pad;
SetupCallbacks();
SetupGu();
pspDebugScreenInit();
int mode = 0;
memset(string, 0, sizeof(string));
while(running)
{
pspDebugScreenSetXY(0, 0);
pspDebugScreenPrintf("Press X to Save, O to Load\n");
pspDebugScreenPrintf(string);
sceCtrlReadBufferPositive(&pad, 1);
if(pad.Buttons & PSP_CTRL_CROSS)
mode = PSP_UTILITY_SAVEDATA_LISTSAVE;
else if(pad.Buttons & PSP_CTRL_CIRCLE)
mode = PSP_UTILITY_SAVEDATA_LISTLOAD;
if(mode)
{
ShowSaveDialog(mode);
pspDebugScreenInit();
mode = 0;
}
}
sceKernelExitGame();
return 0;
}