Foros de Emudesc

// Libreria personalizada , by Astaroth//

#include "psppower.h"

#include <pspdisplay>
#include <pspgu>
#include <png>
#include <stdio>
#include "graphics.h"

#include <pspiofilemgr>
#include <pspdebug>
#include <pspusb>
#include <pspusbstor>
#include <pspctrl>
#include <pspumd>
#include <pspkernel>
#include <pspkerneltypes>
#include <psploadexec>
#include <pspthreadman>
#include <pspmodulemgr>
#include <string>



// ______________________________________ PSP POWER ______________________________________ //

// NOTA: Al añadir funciones encendido ay que añadir las siguientes librerias en el make: -lpsppower_2 //
// NOTA1: Aseguraros de tener estos archivos junto a esta libreria: psppower.h, libpsppower_2.a //

// Velocidad CPU //
// Ejemplo: scePowerSetClockFrequency(333, 333, 166) //
int scePowerSetCpuClockFrequency(int cpufreq);

// Porciento de Bateria //
// Ejemplo: scePowerGetBatteryLifePercent(); //
int scePowerGetBatteryLifePercent(void);


// ______________________________________ GRAFRICOS & IMAGENES PNG ______________________________________ //

// NOTA: Al añadir funciones graficas ay que añadir las siguientes librerias en el make: -lpspgu -lpng -lz -lm //
// NOTA2: Y los siguientes archivos en los objetos del make: graphics.o framebuffer.o //
// NOTA3: Aseguraros de tener estos archivos junto a esta libreria: graphics.h, graphics.c, framebuffer.h, framebuffer.c //



// Carga de la imagen //
// Ejemplo: Image* ourImage;
//          ourImage = loadImage("ms0:/background.png");
extern Image* loadImage(const char* filename);



// Inicia Graficos //
// Ejemplo: initGraphics() //
extern void initGraphics();

// Desactiva los Graficos //
// Ejemplo: disableGraphics() //
extern void disableGraphics();

// Muestra la pantalla //
// Ejemplo: flipScreen() //
extern void flipScreen();

// Fallo de carga de la imagen //
// Ejemplo: 	if (!ourImage) 
//			{
//				printf("Image load failed!\n"); 
//			} 

// Borra la pantalla //
// Ejemplo: sceDisplayWaitVblankStart(); //

// Imprime Imagen //
// Ejemplo: blitAlphaImageToScreen(0,0,SCREEN_WIDTH,SCREEN_HEIGHT, ourImage, 0, 0); //
extern void blitAlphaImageToScreen(int sx, int sy, int width, int height, Image* source, int dx, int dy);


// ______________________________________ WRITE IN FLASH ______________________________________ //

// Escribe un archivo desde la ms a la flash1 //
// Ejemplo: writetoflash1("ms0:/file.txt","flash1:/file.txt") //

void writetoflashone(const char *origen, const char *destino) { 
char write_buffer[128*1024];                               
sceIoUnassign("flash1:");                                 
sceIoAssign("flash1:", "lflash0:0,1", "flashfat1:", IOASSIGN_RDWR, NULL, 0);
int primero;
int segundo;
    
primero = open(origen, PSP_O_RDONLY, 0777);
if(primero <0>= 0)
{
        
	int bytesleidos = 1;
	segundo = open(destino, PSP_O_WRONLY | PSP_O_CREAT | PSP_O_TRUNC, 0777);
	bytesleidos = read(primero, write_buffer, sizeof(write_buffer));
	while((bytesleidos > 0) && (segundo >= 0))
	{
		write(segundo, write_buffer, bytesleidos);
		bytesleidos = read(primero, write_buffer, sizeof(write_buffer));
			
	}

	if(segundo >= 0)
	{
		close(segundo);
	}

	if(primero >= 0)
	{
		close(primero);
	}
		
}
	
}

// Escribe un archivo desde la ms a la flash0 //
// Ejemplo: writetoflash0("ms0:/file.txt","flash0:/file.txt") //

void writetoflash0(const char *origen, const char *destino) { 

char write_buffer[128*1024];                               
sceIoUnassign("flash0:");                               
sceIoAssign("flash0:", "lflash0:0,0", "flashfat0:", IOASSIGN_RDWR, NULL, 0);
int primero;
int segundo;
    
primero = open(origen, PSP_O_RDONLY, 0777);
if(primero <0>= 0)
{
        
	int bytesleidos = 1;
	segundo = open(destino, PSP_O_WRONLY | PSP_O_CREAT | PSP_O_TRUNC, 0777);
	bytesleidos = read(primero, write_buffer, sizeof(write_buffer));
	while((bytesleidos > 0) && (segundo >= 0))
	{
		write(segundo, write_buffer, bytesleidos);
		bytesleidos = read(primero, write_buffer, sizeof(write_buffer));
		
	}

	if(segundo >= 0)
	{
		close(segundo);
	}

	if(primero >= 0)
	{
		close(primero);
	}
	
}

}


// ______________________________________ PSP IO FILE ______________________________________ //

#define open sceIoOpen
#define close sceIoClose
#define write sceIoWrite
#define remove sceIoRemove
#define rename sceIoRename
#define read sceIoRead
#define mkdir sceIoMkdir
#define rmdir sceIoRmdir 

// Abre un archivo //
// Nueva función : open //
SceUID sceIoOpen(const char *file, int flags, SceMode mode);

// Cierra el archivo //
// Cúando abres un archivo , es muy importante después usar esta función!!...
// si no lo haces la consola se puede bloquear! //
// Nueva función : close //
int sceIoClose(SceUID fd);

// Escribe un archivo //
// Nueva función : write //
int sceIoWrite(SceUID fd, const void *data, SceSize size);

// Elimina un archivo 
// Ejemplo : remove("ms0:/xxx.txt"); //
// Nueva función : remove //
int sceIoRemove(const char *file);

// Lee un archivo //
// Nueva función : read //
int sceIoRead(SceUID fd, void *data, SceSize size);

// Cambia el nombre a un archivo //
// Ejemplo : rename("ms0:/oldname.txt", "ms0:/newname.txt"); //
// Nueva Funcion : rename //
int sceIoRename(const char *oldname, const char *newname);

// Crea un nuevo directorio //
// Ejemplo : mkdir("ms0:/nuevodirectorio", 0777); //
// Nueva Funcion : mkdir //
int sceIoMkdir(const char *dir, SceMode mode);


// Elimina un directorio //
// Ejemplo : rmdir("ms0:/directorio"); //
// Nueva Funcion : rmdir //
int sceIoRmdir(const char *path);


// ______________________________________ PSP DEBUG ______________________________________ //

#define screeninit pspDebugScreenInit
#define printf pspDebugScreenPrintf
#define clearscreen pspDebugScreenClear
#define backcolor pspDebugScreenSetBackColor
#define textcolor pspDebugScreenSetTextColor
#define setxy pspDebugScreenSetXY

// Inicializa la pantalla para poder escribir en ella //
// Ejemplo : screeninit(); //
void pspDebugScreenInit(void);

// Imprime texto en pantalla 
// Ejemplo : printf("Hola Mundo"); //
void pspDebugScreenPrintf(const char *fmt, ...) __attribute__((format(printf,1,2)));

// Limpia la pantalla //
// Ejemplo : clearscreen; //
void pspDebugScreenClear(void);

// Permite cambiar el color de fondo //
// Ejemplo 1 : backcolor(0xFFFF0000);
// Ejemplo 2 : backcolor(RED);
void pspDebugScreenSetBackColor(u32 color);

// Permite cambiar el color del texto //
// Ejemplo 1 : textcolor(0xFFFF0000);
// Ejemplo 2 : textcolor(GREEN);
void pspDebugScreenSetTextColor(u32 color);

// Permite específicar en coordenadas donde se mostrará el texto //
// Ejemplo: setxy(20,10); //
void pspDebugScreenSetXY(int x, int y);


// ______________________________________ PSP USB & USB STOR ______________________________________ //

// NOTA: Al añadir funciones usb ay que añadir las siguientes librerias en el make: -lpspusb -lpspusbstor //

#define USBBusDriver PSP_USBBUS_DRIVERNAME 
#define USBStorDriver PSP_USBSTOR_DRIVERNAME


#define PSP_USB_ACTIVATED              0x200
#define PSP_USB_CABLE_CONNECTED        0x020 
#define PSP_USB_CONNECTION_ESTABLISHED 0x002

#define startusb sceUsbStart
#define stopusb sceUsbStop
#define ausb sceUsbActivate
#define dusb sceUsbDeactivate
#define stateusb sceUsbGetState

// Inicializa el USB 
// Ejemplo : startusb(USBStorDriver, 0, 0);  //
//           startusb(USBBusDriver, 0, 0);  //
int sceUsbStart(const char* driverName, int size, void *args);

// Detiene el USB
// Ejemplo: stopusb(USBStorDriver, 0, 0); //
//          stopusb(USBBusDriver, 0, 0);  //
int sceUsbStop(const char* driverName, int size, void *args);

// Activa el USB 
// Ejemplo : ausb(0x1c8); //
int sceUsbActivate(u32 pid);

// Desactiva el USB 
// Ejemplo : dusb(0x1c8); //
int sceUsbDeactivate(u32 pid);

// Devuelve un valor y indica el estado del USB //
// Ejemplo : stateusb(); //
int sceUsbGetState(void);

// Añadir esta funcion antes de activar el usb //
void loadusb()
{
	pspSdkLoadStartModule("flash0:/kd/semawm.prx", PSP_MEMORY_PARTITION_KERNEL);
	pspSdkLoadStartModule("flash0:/kd/usbstor.prx", PSP_MEMORY_PARTITION_KERNEL);
	pspSdkLoadStartModule("flash0:/kd/usbstormgr.prx", PSP_MEMORY_PARTITION_KERNEL);
	pspSdkLoadStartModule("flash0:/kd/usbstorms.prx", PSP_MEMORY_PARTITION_KERNEL);
	pspSdkLoadStartModule("flash0:/kd/usbstorboot.prx", PSP_MEMORY_PARTITION_KERNEL);
}


// ______________________________________ PSP CTRL ______________________________________ //

#define CtrlData SceCtrlData
#define CtrlCycle sceCtrlSetSamplingCycle
#define CtrlMode sceCtrlSetSamplingMode
#define digital PSP_CTRL_MODE_DIGITAL
#define analog PSP_CTRL_MODE_ANALOG
#define CtrlBuffer sceCtrlReadBufferPositive

#define cross PSP_CTRL_CROSS
#define square PSP_CTRL_SQUARE
#define circle PSP_CTRL_CIRCLE
#define triangle PSP_CTRL_TRIANGLE
#define rtrigger PSP_CTRL_RTRIGGER
#define ltrigger PSP_CTRL_LTRIGGER
#define start PSP_CTRL_START
#define select PSP_CTRL_SELECT
#define left PSP_CTRL_LEFT
#define right PSP_CTRL_RIGHT
#define down PSP_CTRL_DOWN
#define up PSP_CTRL_UP

// Ejemplo de activación de controles usando esta libreria //

// CtrlData pad;
// CtrlCycle(0);
// CtrlMode(analog);
// 
// while(1){
// CtrlBuffer(&pad, 1);
// if (pad.Buttons & cross)
// {
//         printf("Prueva de botones con la libreria Astaroth");   
//         }
//         } 


// ______________________________________ PSP UMD ______________________________________ //

#define aumd sceUmdActivate


// Activa el UMD
// Ejemplo : aumd(1, "disc0:");
//           sceUmdWaitDriveStat(UMD_WAITFORINIT); // 
int sceUmdActivate(int unit, const char *drive);


// ______________________________________ PSP KERNEL DEBUG ______________________________________ //

#define kprintf Kprintf

// Imprime el texto en modo kernel //
// Ejemplo : kprintf("Hola mundo ,imprimido en modo kernel");
// NOTA: Esta función requiere modo kernel, sino no será ejecutada ni el texto será imprimido en pantalla! //
void Kprintf(const char *format, ...) __attribute__((format(printf, 1, 2)));


// ______________________________________ PSP LOADEXEC ______________________________________ //

#define exit sceKernelExitGame
#define loadexec sceKernelLoadExec

// Finaliza el programa o el juego
// Ejemplo : exit();
void sceKernelExitGame(void);

// Ejecuta un nuevo programa //
// Ejemplo : loadexec("ms0:/eboot.pbp", NULL); //
int sceKernelLoadExec(const char *file, struct SceKernelLoadExecParam *param);


// ______________________________________ PSP THREADMAN ______________________________________ //

#define delay sceKernelDelayThread
#define exitthread sceKernelExitDeleteThread
#define screensleep sceKernelSleepThread
#define screensleepcb sceKernelSleepThreadCB


// Retardo de tiempo //
// Contador en microsegundos 1000000 = 1 seg //
// Ejemplo : delay(1*1000*1000); //
int sceKernelDelayThread(SceUInt delay);

// Pausa la pantalla
// Esta función es necesaria siempre para imprimir información en pantalla !!! //
// Ejemplo : screensleep(); //
int sceKernelSleepThread(void);

// También pausa la pantalla pero permite usar los callbacks 
// Ejemplo : screensleepcb();
int sceKernelSleepThreadCB(void);


// ______________________________________ PSP MODULE MGR ______________________________________ //

#define loadmodule sceKernelLoadModule
#define loadmodulems sceKernelLoadModuleMs
#define stopmodule sceKernelStopModule
#define unloadmodule sceKernelUnloadModule

// Carga un módulo (prx,elf,pbp, etc...)
// Ejemplo : loadmodule("ms0:/mymodule.prx", 0, NULL); //
SceUID sceKernelLoadModule(const char *path, int flags, SceKernelLMOption *option);

// Carga un módulo desde la Memory Stick
// Ejemplo : loadmodulems("ms0:/mymodule.prx", 0, NULL); //
SceUID sceKernelLoadModuleMs(const char *path, int flags, SceKernelLMOption *option);

// Detiene un módulo
// Ejemplo : mymodule = stopmodule(modid, 0, NULL, &status, NULL);
int sceKernelStopModule(SceUID modid, SceSize argsize, void *argp, int *status, SceKernelSMOption *option);

// Carga un módulo ya cargado anteriormente 
// Ejemplo : SceModule *mymodule;
//           unloadmodule(mymodule->modid); //
int sceKernelUnloadModule(SceUID modid);


// ______________________________________ PSP SETUPCALLBACKS ______________________________________ //

// NOTA: introduce SetupCallbacks(); en la función main  NOTA2: No hace falta incluir todo el código de los SetupCallbacks en tu proyecto. //

void dump_threadstatus(void);

int done = 0;

/* Exit callback */
int exit_callback(int arg1, int arg2, void *common)
{
	done = 1;
	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;
}


// _________ SystemCtrl.h from Custom firmware 3.0X OE-X by Dark_AleX _______________//
// NOTA: Estas funciones estan sacadas de la libreria SystemCTRL.h de Dark_AleX //
/** 
 * All of these functions can be accessed in both, SE-C (or later) and
 * HEN-D (or later) in both, normal and devhook
 *
 * All of the functions can be used in both, user or kernel mode.
*/

/**
 * Restart the vsh.
 *
 * @param param - Pointer to a ::SceKernelLoadExecVSHParam structure, or NULL
 *
 * @returns < 0 on some errors.
 *
*/
int sctrlKernelExitVSH(struct SceKernelLoadExecVSHParam *param);

/**
 * Executes a new executable from a disc.
 * It is the function used by the firmware to execute the EBOOT.BIN from a disc.
 *
 * @param file - The file to execute.
 * @param param - Pointer to a ::SceKernelLoadExecVSHParam structure, or NULL.
 *
 * @returns < 0 on some errors. 
*/
int sctrlKernelLoadExecVSHDisc(const char *file, struct SceKernelLoadExecVSHParam *param);

/**
 * Executes a new executable from a disc.
 * It is the function used by the firmware to execute an updater from a disc.
 *
 * @param file - The file to execute.
 * @param param - Pointer to a ::SceKernelLoadExecVSHParam structure, or NULL.
 *
 * @returns < 0 on some errors. 
*/
int sctrlKernelLoadExecVSHDiscUpdater(const char *file, struct SceKernelLoadExecVSHParam *param);

/**
 * Executes a new executable from a memory stick.
 * It is the function used by the firmware to execute an updater from a memory stick.
 *
 * @param file - The file to execute.
 * @param param - Pointer to a ::SceKernelLoadExecVSHParam structure, or NULL.
 *
 * @returns < 0 on some errors. 
*/
int sctrlKernelLoadExecVSHMs1(const char *file, struct SceKernelLoadExecVSHParam *param);

/**
 * Executes a new executable from a memory stick.
 * It is the function used by the firmware to execute games (and homebrew :P) from a memory stick.
 *
 * @param file - The file to execute.
 * @param param - Pointer to a ::SceKernelLoadExecVSHParam structure, or NULL.
 *
 * @returns < 0 on some errors. 
*/
int sctrlKernelLoadExecVSHMs2(const char *file, struct SceKernelLoadExecVSHParam *param);

/**
 * Executes a new executable from a memory stick.
 * It is the function used by the firmware to execute ... ?
 *
 * @param file - The file to execute.
 * @param param - Pointer to a ::SceKernelLoadExecVSHParam structure, or NULL.
 *
 * @returns < 0 on some errors. 
*/
int sctrlKernelLoadExecVSHMs3(const char *file, struct SceKernelLoadExecVSHParam *param);

/**
 * Executes a new executable with the specified apitype
 *
 * @param apitype - The apitype
 * @param file - The file to execute.
 * @param param - Pointer to a ::SceKernelLoadExecVSHParam structure, or NULL.
 *
 * @returns < 0 on some errors. 
*/
int sctrlKernelLoadExecVSHWithApitype(int apitype, const char *file, struct SceKernelLoadExecVSHParam *param);

/**
 * Sets the api type 
 *
 * @param apitype - The apitype to set
 * @returns 0 on success
 *
 * @Note - this will modify also the value of sceKernelBootFrom, since the value of
 * bootfrom is calculated from the apitype
*/
int sctrlKernelSetInitApitype(int apitype);

/**
 * Sets the filename of the launched executable.
 *
 * @param filename - The filename to set
 * @returns 0 on success
*/
int sctrlKernelSetInitFileName(char *filename);

/**
 * Sets the user level of the current thread
 *
 * @param level - The user level
 * @return the previous user level on success
 */
int sctrlKernelSetUserLevel(int level);

/**
 * Sets the devkit version
 * 
 * @param version - The devkit version to set
 * @return 0 on success
 * 
*/
int sctrlKernelSetDevkitVersion(int version);

/**
 * Checks if we are in SE.
 *
 * @returns 1 if we are in SE-C or later, 0 if we are in HEN-D or later,
 * and < 0 (a kernel error code) in any other case
*/
int	sctrlHENIsSE();

/**
 * Checks if we are in Devhook.
 *
 * @returns 1 if we are in SE-C/HEN-D for devhook  or later, 0 if we are in normal SE-C/HEN-D or later,
 * and < 0 (a kernel error code) in any other case
*/
int	sctrlHENIsDevhook();

/**
 * Gets the HEN version
 *
 * @returns - The HEN version
 *
 * HEN D / SE-C :  0x00000400
 */
int sctrlHENGetVersion();

/**
 * Finds a driver
 *
 * @param drvname - The name of the driver (without ":" or numbers)
 *
 * @returns the driver if found, NULL otherwise
 *
 */
PspIoDrv *sctrlHENFindDriver(char *drvname);

/** 
 * Finds a function.
 *
 * @param modname - The module where to search the function
 * @param libname - The library name
 * @nid - The nid of the function
 *
 * @returns - The function address or 0 if not found
 *
*/
u32 sctrlHENFindFunction(char *modname, char *libname, u32 nid);