Does anyone know how to get the EBOOT Title from an EBOOT. I've searched and found code to get the ICON0.PNG and modified it to load the image into memory and display with a modded graphics.h but I cannot figure out how to get the title. Preferably a way without having to decompress and parse the PARAM.SFO...
My goal is to do it quicker than the XMB.
EBOOT Title
It's apparently not in the BPB itself.
http://hitmen.c02.at/files/yapspd/psp_d ... ml#sec26.3
The next section in the same doc shows the SFO info, which is where I think your going to have to go, even though you said you didn't want to go there.
You can try to build a hello world type app and pack it onto a PBP, open it with a hex editor and search for the title you gave it to see if there's any possibility at all.
http://hitmen.c02.at/files/yapspd/psp_d ... ml#sec26.3
The next section in the same doc shows the SFO info, which is where I think your going to have to go, even though you said you didn't want to go there.
You can try to build a hello world type app and pack it onto a PBP, open it with a hex editor and search for the title you gave it to see if there's any possibility at all.
-
roe-ur-boat
- Posts: 5
- Joined: Wed Aug 22, 2007 4:54 am
AFAIK the only way to get the eboot name is by parsing the sfo that's packed in with the rest of the files in the pbp.
Edit: With pbps compiled with the latest toolchain I think the name is at the same offset in every file. You could get it by seeking to that offset and just reading it till you reach a NULL byte. However, this method isn't as accurate as parsing it properly.
Edit: With pbps compiled with the latest toolchain I think the name is at the same offset in every file. You could get it by seeking to that offset and just reading it till you reach a NULL byte. However, this method isn't as accurate as parsing it properly.
-
roe-ur-boat
- Posts: 5
- Joined: Wed Aug 22, 2007 4:54 am
Unpack.. unjoin.. whatever I still need to do it...?roe-ur-boat wrote:It's not compressed, all the files in the pbp are just joined together.
Can you post code to get Title data? :Dne0h wrote:Ooblik, cau you post the code for get the ICON0.PNG data?
Here you go...
Remember most of the code is NOT mine just modified by me.
Thank the people in these forums:D ..Living (well not living..) proof that search works!
Take a look at: extern Image* GetEBOOTIcon(const char * path);
and extern Image* loadImageMemory(const void *buffer, int bufsize);
The code may be a little messy or have some errors.. compiles fine though :)
graphics.h
Code: Select all
#ifndef GRAPHICS_H
#define GRAPHICS_H
#include <psptypes.h>
#define PSP_LINE_SIZE 512
#define SCREEN_WIDTH 480
#define SCREEN_HEIGHT 272
typedef u32 Color;
#define A(color) ((u8)(color >> 24 & 0xFF))
#define B(color) ((u8)(color >> 16 & 0xFF))
#define G(color) ((u8)(color >> 8 & 0xFF))
#define R(color) ((u8)(color & 0xFF))
#define RGB(r, g, b) (0xFF000000 | ((b)<<16) | ((g)<<8) | (r))
enum colors {
RED = 0xFF0000FF,
GREEN = 0xFF00FF00,
BLUE = 0xFFFF0000,
WHITE = 0xFFFFFFFF,
LITEGRAY = 0xFFBFBFBF,
GRAY = 0xFF7F7F7F,
DARKGRAY = 0xFF3F3F3F ,
BLACK = 0xFF000000,
YELLOW = 0xFF00FFFF,
ORANGE = 0xFF0080FF,
LITEORANGE = 0xFF88C4FF,
VANILLA = 0xFFA8F7FB,
PURPLE = 0xFFCE00CE,
DARKRED = 0xFF000080,
PINK = 0xFFCD00CD
};
typedef struct
{
int textureWidth; // the real width of data, 2^n with n>=0
int textureHeight; // the real height of data, 2^n with n>=0
int imageWidth; // the image width
int imageHeight;
Color* data;
} Image;
typedef struct
{
u32 signature;
int version;
int offset[8];
} HEADER;
extern Image* loadImageMemory(const void *buffer, int bufsize);
extern Image* GetEBOOTIcon(const char * path);
/**
* Load a PNG image.
*
* @pre filename != NULL
* @param filename - filename of the PNG image to load
* @return pointer to a new allocated Image struct, or NULL on failure
*/
extern Image* loadImage(const char* filename);
extern Image* loadJpegImage(const char* filename, int offset);
void PutGFX(int sx, int sy, int width, int height, Image* source, int dx, int dy);
/**
* Blit a rectangle part of an image to another image.
*
* @pre source != NULL && destination != NULL &&
* sx >= 0 && sy >= 0 &&
* width > 0 && height > 0 &&
* sx + width <= source->width && sy + height <= source->height &&
* dx + width <= destination->width && dy + height <= destination->height
* @param sx - left position of rectangle in source image
* @param sy - top position of rectangle in source image
* @param width - width of rectangle in source image
* @param height - height of rectangle in source image
* @param source - pointer to Image struct of the source image
* @param dx - left target position in destination image
* @param dy - top target position in destination image
* @param destination - pointer to Image struct of the destination image
*/
extern void blitImageToImage(int sx, int sy, int width, int height, Image* source, int dx, int dy, Image* destination);
/**
* Blit a rectangle part of an image to screen.
*
* @pre source != NULL && destination != NULL &&
* sx >= 0 && sy >= 0 &&
* width > 0 && height > 0 &&
* sx + width <= source->width && sy + height <= source->height &&
* dx + width <= SCREEN_WIDTH && dy + height <= SCREEN_HEIGHT
* @param sx - left position of rectangle in source image
* @param sy - top position of rectangle in source image
* @param width - width of rectangle in source image
* @param height - height of rectangle in source image
* @param source - pointer to Image struct of the source image
* @param dx - left target position in destination image
* @param dy - top target position in destination image
*/
extern void blitImageToScreen(int sx, int sy, int width, int height, Image* source, int dx, int dy);
/**
* Blit a rectangle part of an image to another image without alpha pixels in source image.
*
* @pre source != NULL && destination != NULL &&
* sx >= 0 && sy >= 0 &&
* width > 0 && height > 0 &&
* sx + width <= source->width && sy + height <= source->height &&
* dx + width <= destination->width && dy + height <= destination->height
* @param sx - left position of rectangle in source image
* @param sy - top position of rectangle in source image
* @param width - width of rectangle in source image
* @param height - height of rectangle in source image
* @param source - pointer to Image struct of the source image
* @param dx - left target position in destination image
* @param dy - top target position in destination image
* @param destination - pointer to Image struct of the destination image
*/
extern void blitAlphaImageToImage(int sx, int sy, int width, int height, Image* source, int dx, int dy, Image* destination);
/**
* Blit a rectangle part of an image to screen without alpha pixels in source image.
*
* @pre source != NULL && destination != NULL &&
* sx >= 0 && sy >= 0 &&
* width > 0 && height > 0 &&
* sx + width <= source->width && sy + height <= source->height &&
* dx + width <= SCREEN_WIDTH && dy + height <= SCREEN_HEIGHT
* @param sx - left position of rectangle in source image
* @param sy - top position of rectangle in source image
* @param width - width of rectangle in source image
* @param height - height of rectangle in source image
* @param source - pointer to Image struct of the source image
* @param dx - left target position in destination image
* @param dy - top target position in destination image
*/
extern void blitAlphaImageToScreen(int sx, int sy, int width, int height, Image* source, int dx, int dy);
/**
* Create an empty image.
*
* @pre width > 0 && height > 0 && width <= 512 && height <= 512
* @param width - width of the new image
* @param height - height of the new image
* @return pointer to a new allocated Image struct, all pixels initialized to color 0, or NULL on failure
*/
extern Image* createImage(int width, int height);
/**
* Frees an allocated image.
*
* @pre image != null
* @param image a pointer to an image struct
*/
extern void freeImage(Image* image);
/**
* Initialize all pixels of an image with a color.
*
* @pre image != NULL
* @param color - new color for the pixels
* @param image - image to clear
*/
extern void clearImage(Color color, Image* image);
/**
* Initialize all pixels of the screen with a color.
*
* @param color - new color for the pixels
*/
extern void clearScreen(Color color);
/**
* Fill a rectangle of an image with a color.
*
* @pre image != NULL
* @param color - new color for the pixels
* @param x0 - left position of rectangle in image
* @param y0 - top position of rectangle in image
* @param width - width of rectangle in image
* @param height - height of rectangle in image
* @param image - image
*/
extern void fillImageRect(Color color, int x0, int y0, int width, int height, Image* image);
/**
* Fill a rectangle of an image with a color.
*
* @pre image != NULL
* @param color - new color for the pixels
* @param x0 - left position of rectangle in image
* @param y0 - top position of rectangle in image
* @param width - width of rectangle in image
* @param height - height of rectangle in image
*/
extern void fillScreenRect(Color color, int x0, int y0, int width, int height);
/**
* Set a pixel on screen to the specified color.
*
* @pre x >= 0 && x < SCREEN_WIDTH && y >= 0 && y < SCREEN_HEIGHT
* @param color - new color for the pixels
* @param x - left position of the pixel
* @param y - top position of the pixel
*/
extern void putPixelScreen(Color color, int x, int y);
/**
* Set a pixel in an image to the specified color.
*
* @pre x >= 0 && x < image->imageWidth && y >= 0 && y < image->imageHeight && image != NULL
* @param color - new color for the pixels
* @param x - left position of the pixel
* @param y - top position of the pixel
*/
extern void putPixelImage(Color color, int x, int y, Image* image);
/**
* Get the color of a pixel on screen.
*
* @pre x >= 0 && x < SCREEN_WIDTH && y >= 0 && y < SCREEN_HEIGHT
* @param x - left position of the pixel
* @param y - top position of the pixel
* @return the color of the pixel
*/
extern Color getPixelScreen(int x, int y);
/**
* Get the color of a pixel of an image.
*
* @pre x >= 0 && x < image->imageWidth && y >= 0 && y < image->imageHeight && image != NULL
* @param x - left position of the pixel
* @param y - top position of the pixel
* @return the color of the pixel
*/
extern Color getPixelImage(int x, int y, Image* image);
/**
* Print a text (pixels out of the screen or image are clipped).
*
* @param x - left position of text
* @param y - top position of text
* @param text - the text to print
* @param color - new color for the pixels
*/
extern void printTextScreen(int x, int y, const char* text, u32 color);
extern void printTextCenterScreen(int x, int y, const char* text, u32 color);
/**
* Print a text (pixels out of the screen or image are clipped).
*
* @param x - left position of text
* @param y - top position of text
* @param text - the text to print
* @param color - new color for the pixels
* @param image - image
*/
extern void printTextImage(int x, int y, const char* text, u32 color, Image* image);
/**
* Save an image or the screen in PNG format.
*
* @pre filename != NULL
* @param filename - filename of the PNG image
* @param data - start of Color type pixel data (can be getVramDisplayBuffer())
* @param width - logical width of the image or SCREEN_WIDTH
* @param height - height of the image or SCREEN_HEIGHT
* @param lineSize - physical width of the image or PSP_LINE_SIZE
* @param saveAlpha - if 0, image is saved without alpha channel
*/
extern void saveImage(const char* filename, Color* data, int width, int height, int lineSize, int saveAlpha);
/**
* Exchange display buffer and drawing buffer.
*/
extern void flipScreen();
/**
* Initialize the graphics.
*/
extern void initGraphics();
/**
* Disable graphics, used for debug text output.
*/
extern void disableGraphics();
/**
* Draw a line to screen.
*
* @pre x0 >= 0 && x0 < SCREEN_WIDTH && y0 >= 0 && y0 < SCREEN_HEIGHT &&
* x1 >= 0 && x1 < SCREEN_WIDTH && y1 >= 0 && y1 < SCREEN_HEIGHT
* @param x0 - x line start position
* @param y0 - y line start position
* @param x1 - x line end position
* @param y1 - y line end position
*/
void drawLineScreen(int x0, int y0, int x1, int y1, Color color);
/**
* Draw a line to screen.
*
* @pre x0 >= 0 && x0 < image->imageWidth && y0 >= 0 && y0 < image->imageHeight &&
* x1 >= 0 && x1 < image->imageWidth && y1 >= 0 && y1 < image->imageHeight
* @param x0 - x line start position
* @param y0 - y line start position
* @param x1 - x line end position
* @param y1 - y line end position
*/
extern void drawLineImage(int x0, int y0, int x1, int y1, Color color, Image* image);
/**
* Get the current draw buffer for fast unchecked access.
*
* @return the start address of the current draw buffer
*/
extern Color* getVramDrawBuffer();
/**
* Get the current display buffer for fast unchecked access.
*
* @return the start address of the current display buffer
*/
extern Color* getVramDisplayBuffer();
extern void guStart();
extern void guEnd();
#endif
Code: Select all
#include <stdlib.h>
#include <malloc.h>
#include <pspdisplay.h>
#include <psputils.h>
#include <png.h>
#include <pspgu.h>
#include <jpeglib.h>
#include <jerror.h>
#include "graphics.h"
#include "framebuffer.h"
#define IS_ALPHA(color) (((color)&0xff000000)==0xff000000?0:1)
#define FRAMEBUFFER_SIZE (PSP_LINE_SIZE*SCREEN_HEIGHT*4)
#define MAX(X, Y) ((X) > (Y) ? (X) : (Y))
typedef struct
{
const unsigned char *buffer;
png_uint_32 bufsize;
png_uint_32 current_pos;
} MEMORY_READER_STATE;
typedef struct
{
unsigned short u, v;
short x, y, z;
} Vertex;
extern u8 msx[];
unsigned int __attribute__((aligned(16))) list[262144];
static int dispBufferNumber;
static int initialized = 0;
static int getNextPower2(int width)
{
int b = width;
int n;
for (n = 0; b != 0; n++) b >>= 1;
b = 1 << n;
if (b == 2 * width) b >>= 1;
return b;
}
Color* getVramDrawBuffer()
{
Color* vram = (Color*) g_vram_base;
if (dispBufferNumber == 0) vram += FRAMEBUFFER_SIZE / sizeof(Color);
return vram;
}
Color* getVramDisplayBuffer()
{
Color* vram = (Color*) g_vram_base;
if (dispBufferNumber == 1) vram += FRAMEBUFFER_SIZE / sizeof(Color);
return vram;
}
void user_warning_fn(png_structp png_ptr, png_const_charp warning_msg)
{
}
static void read_data_memory(png_structp png_ptr, png_bytep data, png_uint_32 length)
{
MEMORY_READER_STATE *f = (MEMORY_READER_STATE *)png_get_io_ptr(png_ptr);
if (length > (f->bufsize - f->current_pos)) png_error(png_ptr, "read error in read_data_memory (loadpng)");
memcpy(data, f->buffer + f->current_pos, length);
f->current_pos += length;
}
Image* loadImageMemory(const void *buffer, int bufsize)
{
png_structp png_ptr;
png_infop info_ptr;
MEMORY_READER_STATE memory_reader_state;
unsigned int sig_read = 0;
png_uint_32 width, height;
int bit_depth, color_type, interlace_type, x, y;
u32* line;
if (!buffer || (bufsize <= 0)) return NULL;
Image* image = (Image*) malloc(sizeof(Image));
if (!image) return NULL;
png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (png_ptr == NULL) {
free(image);
return NULL;;
}
png_set_error_fn(png_ptr, (png_voidp) NULL, (png_error_ptr) NULL, user_warning_fn);
info_ptr = png_create_info_struct(png_ptr);
if (info_ptr == NULL) {
free(image);
png_destroy_read_struct(&png_ptr, png_infopp_NULL, png_infopp_NULL);
return NULL;
}
memory_reader_state.buffer = (unsigned char *)buffer;
memory_reader_state.bufsize = bufsize;
memory_reader_state.current_pos = 0;
png_set_read_fn(png_ptr, &memory_reader_state, (png_rw_ptr)read_data_memory);
png_read_info(png_ptr, info_ptr);
png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, NULL, NULL);
image->imageWidth = width;
image->imageHeight = height;
image->textureWidth = getNextPower2(width);
image->textureHeight = getNextPower2(height);
png_set_sig_bytes(png_ptr, sig_read);
png_set_strip_16(png_ptr);
png_set_packing(png_ptr);
if (color_type == PNG_COLOR_TYPE_PALETTE) png_set_palette_to_rgb(png_ptr);
if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) png_set_gray_1_2_4_to_8(png_ptr);
if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) png_set_tRNS_to_alpha(png_ptr);
png_set_filler(png_ptr, 0xff, PNG_FILLER_AFTER);
image->data = (Color*) memalign(16, image->textureWidth * image->textureHeight * sizeof(Color));
if (!image->data) {
free(image);
png_destroy_read_struct(&png_ptr, png_infopp_NULL, png_infopp_NULL);
return NULL;
}
line = (u32*) malloc(width * 4);
if (!line) {
free(image->data);
free(image);
png_destroy_read_struct(&png_ptr, png_infopp_NULL, png_infopp_NULL);
return NULL;
}
for (y = 0; y < height; y++) {
png_read_row(png_ptr, (u8*) line, png_bytep_NULL);
for (x = 0; x < width; x++) {
u32 color = line[x];
image->data[x + y * image->textureWidth] = color;
}
}
free(line);
png_read_end(png_ptr, info_ptr);
png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL);
return image;
}
Image* loadImage(const char* filename)
{
png_structp png_ptr;
png_infop info_ptr;
unsigned int sig_read = 0;
png_uint_32 width, height;
int bit_depth, color_type, interlace_type, x, y;
u32* line;
FILE *fp;
Image* image = (Image*) malloc(sizeof(Image));
if (!image) return NULL;
if ((fp = fopen(filename, "rb")) == NULL) return NULL;
png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (png_ptr == NULL) {
free(image);
fclose(fp);
return NULL;;
}
png_set_error_fn(png_ptr, (png_voidp) NULL, (png_error_ptr) NULL, user_warning_fn);
info_ptr = png_create_info_struct(png_ptr);
if (info_ptr == NULL) {
free(image);
fclose(fp);
png_destroy_read_struct(&png_ptr, png_infopp_NULL, png_infopp_NULL);
return NULL;
}
png_init_io(png_ptr, fp);
png_set_sig_bytes(png_ptr, sig_read);
png_read_info(png_ptr, info_ptr);
png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, int_p_NULL, int_p_NULL);
/*
if (width > 512 || height > 512) {
free(image);
fclose(fp);
png_destroy_read_struct(&png_ptr, png_infopp_NULL, png_infopp_NULL);
return NULL;
}
*/
image->imageWidth = width;
image->imageHeight = height;
image->textureWidth = getNextPower2(width);
image->textureHeight = getNextPower2(height);
png_set_strip_16(png_ptr);
png_set_packing(png_ptr);
if (color_type == PNG_COLOR_TYPE_PALETTE) png_set_palette_to_rgb(png_ptr);
if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) png_set_gray_1_2_4_to_8(png_ptr);
if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) png_set_tRNS_to_alpha(png_ptr);
png_set_filler(png_ptr, 0xff, PNG_FILLER_AFTER);
image->data = (Color*) memalign(16, image->textureWidth * image->textureHeight * sizeof(Color));
if (!image->data) {
free(image);
fclose(fp);
png_destroy_read_struct(&png_ptr, png_infopp_NULL, png_infopp_NULL);
return NULL;
}
line = (u32*) malloc(width * 4);
if (!line) {
free(image->data);
free(image);
fclose(fp);
png_destroy_read_struct(&png_ptr, png_infopp_NULL, png_infopp_NULL);
return NULL;
}
for (y = 0; y < height; y++) {
png_read_row(png_ptr, (u8*) line, png_bytep_NULL);
for (x = 0; x < width; x++) {
u32 color = line[x];
image->data[x + y * image->textureWidth] = color;
}
}
free(line);
png_read_end(png_ptr, info_ptr);
png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL);
fclose(fp);
return image;
}
Image* loadJpegImage(const char* filename, int offset)
{
int x;
struct jpeg_decompress_struct dinfo;
struct jpeg_error_mgr jerr;
dinfo.err = jpeg_std_error(&jerr);
jpeg_create_decompress(&dinfo);
FILE* inFile = fopen(filename, "rb");
if (!inFile) {
jpeg_destroy_decompress(&dinfo);
return NULL;
}
fseek(inFile, offset, SEEK_SET);
jpeg_stdio_src(&dinfo, inFile);
jpeg_read_header(&dinfo, TRUE);
int width = dinfo.image_width;
int height = dinfo.image_height;
jpeg_start_decompress(&dinfo);
Image* image = (Image*) malloc(sizeof(Image));
if (!image) {
jpeg_destroy_decompress(&dinfo);
fclose(inFile);
return NULL;
}
image->imageWidth = width;
image->imageHeight = height;
image->textureWidth = getNextPower2(width);
image->textureHeight = getNextPower2(height);
image->data = (Color*) memalign(16, image->textureWidth * image->textureHeight * sizeof(Color));
u8* line = (u8*) malloc(width * 3);
if (!line) {
jpeg_destroy_decompress(&dinfo);
fclose(inFile);
return NULL;
}
if (dinfo.jpeg_color_space == JCS_GRAYSCALE) {
while (dinfo.output_scanline < dinfo.output_height) {
int y = dinfo.output_scanline;
jpeg_read_scanlines(&dinfo, &line, 1);
for (x = 0; x < width; x++) {
Color c = line[x];
image->data[x + image->textureWidth * y] = c | (c << 8) | (c << 16) | 0xff000000;;
}
}
} else {
while (dinfo.output_scanline < dinfo.output_height) {
int y = dinfo.output_scanline;
jpeg_read_scanlines(&dinfo, &line, 1);
u8* linePointer = line;
for (x = 0; x < width; x++) {
Color c = *(linePointer++);
c |= (*(linePointer++)) << 8;
c |= (*(linePointer++)) << 16;
image->data[x + image->textureWidth * y] = c | 0xff000000;
}
}
}
jpeg_finish_decompress(&dinfo);
jpeg_destroy_decompress(&dinfo);
free(line);
fclose(inFile);
return image;
}
void PutGFX(int sx, int sy, int width, int height, Image* source, int dx, int dy)
{
if (!initialized) return;
sceKernelDcacheWritebackInvalidateAll();
guStart();
sceGuTexImage(0, source->textureWidth, source->textureHeight, source->textureWidth, (void*) source->data);
float u = 1.0f / ((float)source->textureWidth);
float v = 1.0f / ((float)source->textureHeight);
sceGuTexScale(u, v);
int j = 0;
while (j < width) {
Vertex* vertices = (Vertex*) sceGuGetMemory(2 * sizeof(Vertex));
int sliceWidth = 64;
if (j + sliceWidth > width) sliceWidth = width - j;
vertices[0].u = sx + j;
vertices[0].v = sy;
vertices[0].x = dx + j;
vertices[0].y = dy;
vertices[0].z = 0;
vertices[1].u = sx + j + sliceWidth;
vertices[1].v = sy + height;
vertices[1].x = dx + j + sliceWidth;
vertices[1].y = dy + height;
vertices[1].z = 0;
sceGuDrawArray(GU_SPRITES, GU_TEXTURE_16BIT | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 2, 0, vertices);
j += sliceWidth;
}
sceGuFinish();
sceGuSync(0, 0);
}
void blitImageToImage(int sx, int sy, int width, int height, Image* source, int dx, int dy, Image* destination)
{
Color* destinationData = &destination->data[destination->textureWidth * dy + dx];
int destinationSkipX = destination->textureWidth - width;
Color* sourceData = &source->data[source->textureWidth * sy + sx];
int sourceSkipX = source->textureWidth - width;
int x, y;
for (y = 0; y < height; y++, destinationData += destinationSkipX, sourceData += sourceSkipX) {
for (x = 0; x < width; x++, destinationData++, sourceData++) {
*destinationData = *sourceData;
}
}
}
void blitImageToScreen(int sx, int sy, int width, int height, Image* source, int dx, int dy)
{
if (!initialized) return;
Color* vram = getVramDrawBuffer();
sceKernelDcacheWritebackInvalidateAll();
guStart();
sceGuCopyImage(GU_PSM_8888, sx, sy, width, height, source->textureWidth, source->data, dx, dy, PSP_LINE_SIZE, vram);
sceGuFinish();
sceGuSync(0,0);
}
void blitAlphaImageToImage(int sx, int sy, int width, int height, Image* source, int dx, int dy, Image* destination)
{
// TODO Blend!
Color* destinationData = &destination->data[destination->textureWidth * dy + dx];
int destinationSkipX = destination->textureWidth - width;
Color* sourceData = &source->data[source->textureWidth * sy + sx];
int sourceSkipX = source->textureWidth - width;
int x, y;
for (y = 0; y < height; y++, destinationData += destinationSkipX, sourceData += sourceSkipX) {
for (x = 0; x < width; x++, destinationData++, sourceData++) {
Color color = *sourceData;
if (!IS_ALPHA(color)) *destinationData = color;
}
}
}
void blitAlphaImageToScreen(int sx, int sy, int width, int height, Image* source, int dx, int dy)
{
if (!initialized) return;
sceKernelDcacheWritebackInvalidateAll();
guStart();
sceGuTexImage(0, source->textureWidth, source->textureHeight, source->textureWidth, (void*) source->data);
float u = 1.0f / ((float)source->textureWidth);
float v = 1.0f / ((float)source->textureHeight);
sceGuTexScale(u, v);
int j = 0;
while (j < width) {
Vertex* vertices = (Vertex*) sceGuGetMemory(2 * sizeof(Vertex));
int sliceWidth = 64;
if (j + sliceWidth > width) sliceWidth = width - j;
vertices[0].u = sx + j;
vertices[0].v = sy;
vertices[0].x = dx + j;
vertices[0].y = dy;
vertices[0].z = 0;
vertices[1].u = sx + j + sliceWidth;
vertices[1].v = sy + height;
vertices[1].x = dx + j + sliceWidth;
vertices[1].y = dy + height;
vertices[1].z = 0;
sceGuDrawArray(GU_SPRITES, GU_TEXTURE_16BIT | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 2, 0, vertices);
j += sliceWidth;
}
sceGuFinish();
sceGuSync(0, 0);
}
Image* createImage(int width, int height)
{
Image* image = (Image*) malloc(sizeof(Image));
if (!image) return NULL;
image->imageWidth = width;
image->imageHeight = height;
image->textureWidth = getNextPower2(width);
image->textureHeight = getNextPower2(height);
image->data = (Color*) memalign(16, image->textureWidth * image->textureHeight * sizeof(Color));
if (!image->data) return NULL;
memset(image->data, 0, image->textureWidth * image->textureHeight * sizeof(Color));
return image;
}
void freeImage(Image* image)
{
free(image->data);
free(image);
}
void clearImage(Color color, Image* image)
{
int i;
int size = image->textureWidth * image->textureHeight;
Color* data = image->data;
for (i = 0; i < size; i++, data++) *data = color;
}
void clearScreen(Color color)
{
if (!initialized) return;
guStart();
sceGuClearColor(color);
sceGuClearDepth(0);
sceGuClear(GU_COLOR_BUFFER_BIT|GU_DEPTH_BUFFER_BIT);
sceGuFinish();
sceGuSync(0, 0);
}
void fillImageRect(Color color, int x0, int y0, int width, int height, Image* image)
{
int skipX = image->textureWidth - width;
int x, y;
Color* data = image->data + x0 + y0 * image->textureWidth;
for (y = 0; y < height; y++, data += skipX) {
for (x = 0; x < width; x++, data++) *data = color;
}
}
void fillScreenRect(Color color, int x0, int y0, int width, int height)
{
if (!initialized) return;
int skipX = PSP_LINE_SIZE - width;
int x, y;
Color* data = getVramDrawBuffer() + x0 + y0 * PSP_LINE_SIZE;
for (y = 0; y < height; y++, data += skipX) {
for (x = 0; x < width; x++, data++) *data = color;
}
}
void putPixelScreen(Color color, int x, int y)
{
Color* vram = getVramDrawBuffer();
vram[PSP_LINE_SIZE * y + x] = color;
}
void putPixelImage(Color color, int x, int y, Image* image)
{
image->data[x + y * image->textureWidth] = color;
}
Color getPixelScreen(int x, int y)
{
Color* vram = getVramDrawBuffer();
return vram[PSP_LINE_SIZE * y + x];
}
Color getPixelImage(int x, int y, Image* image)
{
return image->data[x + y * image->textureWidth];
}
void printTextScreen(int x, int y, const char* text, u32 color)
{
int c, i, j, l;
u8 *font;
Color *vram_ptr;
Color *vram;
if (!initialized) return;
for (c = 0; c < strlen(text); c++) {
if (x < 0 || x + 8 > SCREEN_WIDTH || y < 0 || y + 8 > SCREEN_HEIGHT) break;
char ch = text[c];
vram = getVramDrawBuffer() + x + y * PSP_LINE_SIZE;
font = &msx[ (int)ch * 8];
for (i = l = 0; i < 8; i++, l += 8, font++) {
vram_ptr = vram;
for (j = 0; j < 8; j++) {
if ((*font & (128 >> j))) *vram_ptr = color;
vram_ptr++;
}
vram += PSP_LINE_SIZE;
}
x += 8;
}
}
void printTextImage(int x, int y, const char* text, u32 color, Image* image)
{
int c, i, j, l;
u8 *font;
Color *data_ptr;
Color *data;
if (!initialized) return;
for (c = 0; c < strlen(text); c++) {
if (x < 0 || x + 8 > image->imageWidth || y < 0 || y + 8 > image->imageHeight) break;
char ch = text[c];
data = image->data + x + y * image->textureWidth;
font = &msx[ (int)ch * 8];
for (i = l = 0; i < 8; i++, l += 8, font++) {
data_ptr = data;
for (j = 0; j < 8; j++) {
if ((*font & (128 >> j))) *data_ptr = color;
data_ptr++;
}
data += image->textureWidth;
}
x += 8;
}
}
void saveImage(const char* filename, Color* data, int width, int height, int lineSize, int saveAlpha)
{
png_structp png_ptr;
png_infop info_ptr;
FILE* fp;
int i, x, y;
u8* line;
if ((fp = fopen(filename, "wb")) == NULL) return;
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (!png_ptr) return;
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
return;
}
png_init_io(png_ptr, fp);
png_set_IHDR(png_ptr, info_ptr, width, height, 8,
saveAlpha ? PNG_COLOR_TYPE_RGBA : PNG_COLOR_TYPE_RGB,
PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
png_write_info(png_ptr, info_ptr);
line = (u8*) malloc(width * (saveAlpha ? 4 : 3));
for (y = 0; y < height; y++) {
for (i = 0, x = 0; x < width; x++) {
Color color = data[x + y * lineSize];
u8 r = color & 0xff;
u8 g = (color >> 8) & 0xff;
u8 b = (color >> 16) & 0xff;
u8 a = saveAlpha ? (color >> 24) & 0xff : 0xff;
line[i++] = r;
line[i++] = g;
line[i++] = b;
if (saveAlpha) line[i++] = a;
}
png_write_row(png_ptr, line);
}
free(line);
png_write_end(png_ptr, info_ptr);
png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
fclose(fp);
}
void flipScreen()
{
if (!initialized) return;
sceGuSwapBuffers();
dispBufferNumber ^= 1;
}
static void drawLine(int x0, int y0, int x1, int y1, int color, Color* destination, int width)
{
int dy = y1 - y0;
int dx = x1 - x0;
int stepx, stepy;
if (dy < 0) { dy = -dy; stepy = -width; } else { stepy = width; }
if (dx < 0) { dx = -dx; stepx = -1; } else { stepx = 1; }
dy <<= 1;
dx <<= 1;
y0 *= width;
y1 *= width;
destination[x0+y0] = color;
if (dx > dy) {
int fraction = dy - (dx >> 1);
while (x0 != x1) {
if (fraction >= 0) {
y0 += stepy;
fraction -= dx;
}
x0 += stepx;
fraction += dy;
destination[x0+y0] = color;
}
} else {
int fraction = dx - (dy >> 1);
while (y0 != y1) {
if (fraction >= 0) {
x0 += stepx;
fraction -= dy;
}
y0 += stepy;
fraction += dx;
destination[x0+y0] = color;
}
}
}
void drawLineScreen(int x0, int y0, int x1, int y1, Color color)
{
drawLine(x0, y0, x1, y1, color, getVramDrawBuffer(), PSP_LINE_SIZE);
}
void drawLineImage(int x0, int y0, int x1, int y1, Color color, Image* image)
{
drawLine(x0, y0, x1, y1, color, image->data, image->textureWidth);
}
#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? */
void initGraphics()
{
dispBufferNumber = 0;
sceGuInit();
guStart();
sceGuDrawBuffer(GU_PSM_8888, (void*)FRAMEBUFFER_SIZE, PSP_LINE_SIZE);
sceGuDispBuffer(SCREEN_WIDTH, SCREEN_HEIGHT, (void*)0, PSP_LINE_SIZE);
sceGuClear(GU_COLOR_BUFFER_BIT | GU_DEPTH_BUFFER_BIT);
sceGuDepthBuffer((void*) (FRAMEBUFFER_SIZE*2), PSP_LINE_SIZE);
sceGuOffset(2048 - (SCREEN_WIDTH / 2), 2048 - (SCREEN_HEIGHT / 2));
sceGuViewport(2048, 2048, SCREEN_WIDTH, SCREEN_HEIGHT);
sceGuDepthRange(0xc350, 0x2710);
sceGuScissor(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
sceGuEnable(GU_SCISSOR_TEST);
sceGuAlphaFunc(GU_GREATER, 0, 0xff);
sceGuEnable(GU_ALPHA_TEST);
sceGuDepthFunc(GU_GEQUAL);
sceGuEnable(GU_DEPTH_TEST);
sceGuFrontFace(GU_CW);
sceGuShadeModel(GU_SMOOTH);
sceGuEnable(GU_CULL_FACE);
sceGuEnable(GU_TEXTURE_2D);
sceGuEnable(GU_CLIP_PLANES);
sceGuTexMode(GU_PSM_8888, 0, 0, 0);
sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGBA);
sceGuTexFilter(GU_NEAREST, GU_NEAREST);
sceGuAmbientColor(0xffffffff);
sceGuEnable(GU_BLEND);
sceGuBlendFunc(GU_ADD, GU_SRC_ALPHA, GU_ONE_MINUS_SRC_ALPHA, 0, 0);
sceGuFinish();
sceGuSync(0, 0);
sceDisplayWaitVblankStart();
sceGuDisplay(GU_TRUE);
initialized = 1;
}
void disableGraphics()
{
initialized = 0;
}
void guStart()
{
sceGuStart(GU_DIRECT, list);
}
void guEnd(void) {
sceGuFinish();
sceGuSync(0, 0);
guStart();
sceGuTexMode(GU_PSM_8888, 0, 0, 0);
sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGBA);
sceGuTexFilter(GU_NEAREST, GU_NEAREST);
sceGuFinish();
sceGuSync(0, 0);
}
void printTextCenterScreen(int x, int y, const char* text, u32 color)
{
printTextScreen(x - ((strlen(text) * 8) / 2), y, text, color);
}
Image* GetEBOOTIcon(const char * path) {
Image* imgSource = NULL;
int loop0;
FILE *infile;
HEADER header;
infile = fopen(path, "rb");
fseek(infile, 0, SEEK_SET);
if (fread(&header, sizeof(HEADER), 1, infile) < 0) { return NULL; }
if (header.signature != 0x50425000) return NULL;
for (loop0=0; loop0<2; loop0++) {
void *buffer; int size;
size = header.offset[loop0 + 1] - header.offset[loop0];
buffer = malloc(size);
if (buffer == NULL) { return NULL; }
if (fread(buffer, size, 1, infile) < 0) { return NULL; }
if (loop0==1) {
imgSource = loadImageMemory(buffer, size);
}
free(buffer);
}
fclose(infile);
if (!imgSource) {
imgSource = createImage(144, 80); //Or point to another image...
}
return (imgSource);
}
-
Insert_witty_name
- Posts: 376
- Joined: Wed May 10, 2006 11:31 pm
Something I hacked up to get the title from the sfo. And when I say hacked I mean it.
It's all based on the sfo info at the link I gave above. Since sfo files are so small I don't know if this way or loading the whole thing into memory and going off array offsets would be faster, but it would not be hard to convert this code to that method. Maybe if I have time tomorrow night I'll try.
The only thing that's REMOTELY interesting here in terms of speed of finding the title; we look throught the key / value pairs backwards since the doc says that they are alpha sorted, and we bail our loop early if it's not a type 2 value (TXT).
2/3 of it is error code, and if you feel lucky you can chop most out. I only tested it on 2 sfo's since that's all I had handy. It should be trivial to mod it to read an eboot.
EDIT: maybe comments tomorrow night too, it's late.
It's all based on the sfo info at the link I gave above. Since sfo files are so small I don't know if this way or loading the whole thing into memory and going off array offsets would be faster, but it would not be hard to convert this code to that method. Maybe if I have time tomorrow night I'll try.
The only thing that's REMOTELY interesting here in terms of speed of finding the title; we look throught the key / value pairs backwards since the doc says that they are alpha sorted, and we bail our loop early if it's not a type 2 value (TXT).
2/3 of it is error code, and if you feel lucky you can chop most out. I only tested it on 2 sfo's since that's all I had handy. It should be trivial to mod it to read an eboot.
EDIT: maybe comments tomorrow night too, it's late.
Code: Select all
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int getTitle(const char * fileName, char * gameTitle){
int keyTableOffset;
int valueTableOffset;
short keyOffset;
char keyType;
char keyTest[6];
int valueLen;
int valueOffset;
int numberOfPairs;
int curPairLoc;
int i;
FILE * fp = fopen(fileName, "rb");
if(!fp){
return -1;
}
if(fseek(fp, 8, SEEK_SET) != 0){
fclose(fp);
return -1;
}
if(fread(&keyTableOffset, 4, 1, fp) != 1){
fclose(fp);
return -1;
}
if(fread(&valueTableOffset, 4, 1, fp) != 1){
fclose(fp);
return -1;
}
if(fread(&numberOfPairs, 4, 1, fp) != 1){
fclose(fp);
return -1;
}
for(i = numberOfPairs - 1; i >= 0; i--){
if(fseek(fp, (16 * i) + 20, SEEK_SET) != 0){
fclose(fp);
return -1;
}
if(fread(&keyOffset, 2, 1, fp) != 1){
fclose(fp);
return -1;
}
if(fseek(fp, 1, SEEK_CUR) != 0){
fclose(fp);
return -1;
}
if(fread(&keyType, 1, 1, fp) != 1){
fclose(fp);
return -1;
}
if(keyType != 2){
continue;
}
curPairLoc = ftell(fp);
if(fseek(fp, keyTableOffset + keyOffset, SEEK_SET) != 0){
fclose(fp);
return -1;
}
if(fread(&keyTest, 1, 6, fp) != 6){
continue;
}
if(strcmp("TITLE", keyTest) != 0){
continue;
}
if(fseek(fp, curPairLoc, SEEK_SET) != 0){
fclose(fp);
return -1;
}
if(fseek(fp, 4, SEEK_CUR) != 0){
fclose(fp);
return -1;
}
if(fread(&valueLen, 4, 1, fp) != 1){
fclose(fp);
return -1;
}
if(fread(&valueOffset, 4, 1, fp) != 1){
fclose(fp);
return -1;
}
if(fseek(fp, valueTableOffset + valueOffset, SEEK_SET) != 0){
fclose(fp);
return -1;
}
if(fread(gameTitle, 1, valueLen, fp) != valueLen){
fclose(fp);
return -1;
};
fclose(fp);
return 1;
}
fclose(fp);
strcpy(gameTitle, "Title not found.");
return 0;
}
int main(int argc, char* argv[]){
char * gameName = malloc(400);
if(getTitle("PARAM.SFO", gameName) > 0){
printf("%s\n", gameName);
}else{
printf("Error\n");
}
free(gameName);
}
Code: Select all
int fd = sceIoOpen("EBOOT.PBP", PSP_O_RDONLY, 0777);
params.datasize = sceIoLseek32(fd, 0, PSP_SEEK_END);
unsigned char *fileBuffer = memalign(64, params.datasize);
sceIoLseek32(fd, 0, PSP_SEEK_SET);
sceIoRead(fd, fileBuffer, params.datasize);
sceIoClose(fd);
// Manually patch the PARAM.SFO in the EBOOT
fileBuffer[276] = 0x57;
// And add a custom filename
strncpy((char *) &fileBuffer[320], "PSPSDK GameShare", 127);
memcpy(¶ms.name, "GameShar", 8);
BTW Thanks Insert_witty_name
Umm that's a really bad way to set the title. That only works on homebrews and completely ignores the SFO header data. If your new title is longer than the old one it will write over your terminating 0 byte and stomp over the next piece of data in the sfo. (though since it's not written back to the file, if that's the only thing you use the filebuffer for, it's okay)
I'll modify my code in a few minutes to read the title reliably, not just from homebrew eboots.
I'll modify my code in a few minutes to read the title reliably, not just from homebrew eboots.
Last edited by Onii on Wed Oct 08, 2008 11:58 am, edited 1 time in total.
Here's the version that works on eboots. This also has much less memory overhead than the snip you posted, as it does not load the whole eboot into memory. I also added comments so it's more transparent. It should be trivial to switch it over to use the sceIO functions if you want to do that. Let me know if you'd like a version that has less reads and seeks. I can mod it to just load the SFO data into a temp buffer and just use memory offsets over a char array. That method may be even faster. Just say the word and I'll be happy to write that version too.
Code: Select all
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int getTitle(const char * fileName, char * gameTitle){
int keyTableOffset;
int valueTableOffset;
int SFOOffset;
short keyOffset;
char keyType;
char keyTest[6];
int valueLen;
int valueOffset;
int numberOfPairs;
int curPairLoc;
int i;
FILE * fp = fopen(fileName, "rb");
if(!fp){
return -1;
}
// Skip the EBOOT header
//
if(fseek(fp, 8, SEEK_SET) != 0){
fclose(fp);
return -1;
}
// Read the offset to the sfo data in the eboot
//
if(fread(&SFOOffset, 4, 1, fp) != 1){
fclose(fp);
return -1;
}
// Skip to the sfo data
//
if(fseek(fp, SFOOffset + 8, SEEK_SET) != 0){
fclose(fp);
return -1;
}
// Read the offset to the keytable in the sfo data
//
if(fread(&keyTableOffset, 4, 1, fp) != 1){
fclose(fp);
return -1;
}
// Normalize the keytable to the EBOOT
//
keyTableOffset += SFOOffset;
// Read the offset to the valuetable in the sfo data
//
if(fread(&valueTableOffset, 4, 1, fp) != 1){
fclose(fp);
return -1;
}
// Normalize the valuetable to the EBOOT
//
valueTableOffset += SFOOffset;
// Read the number of value / key pairs present in the sfo
//
if(fread(&numberOfPairs, 4, 1, fp) != 1){
fclose(fp);
return -1;
}
// Set up a backwards loop to iterate over the key value index
//
for(i = numberOfPairs - 1; i >= 0; i--){
// Skip to the current (EBOOT normalized) keyvalue index
//
if(fseek(fp, SFOOffset + (16 * i) + 20, SEEK_SET) != 0){
fclose(fp);
return -1;
}
// Read key offset (normalized to the keytable) from the current key / value index
//
if(fread(&keyOffset, 2, 1, fp) != 1){
fclose(fp);
return -1;
}
// Skip the unknown byte (might be an alignment indicator)
//
if(fseek(fp, 1, SEEK_CUR) != 0){
fclose(fp);
return -1;
}
// Read key type
//
if(fread(&keyType, 1, 1, fp) != 1){
fclose(fp);
return -1;
}
// If the key type is not 2 (TXT) this key / value pair cant be the title so continue to the next index
//
if(keyType != 2){
continue;
}
// Since we will need to jump out of the index and go look at the actual data, record where we were.
//
curPairLoc = ftell(fp);
// Skip to the key in the keytable
//
if(fseek(fp, keyTableOffset + keyOffset, SEEK_SET) != 0){
fclose(fp);
return -1;
}
// Read the key into memory (we only read 6 bytes because we are specifically looking for TITLE\0)
// if we can't read the whole 6 bytes, move on to the next index
//
if(fread(&keyTest, 1, 6, fp) != 6){
continue;
}
// Compare the current key to "TITLE"
// if it doesn't match, move on to the next index
//
if(strcmp("TITLE", keyTest) != 0){
continue;
}
// If we're here, we have the proper key, skip back to our index
//
if(fseek(fp, curPairLoc, SEEK_SET) != 0){
fclose(fp);
return -1;
}
// Skip the raw data length in the index
//
if(fseek(fp, 4, SEEK_CUR) != 0){
fclose(fp);
return -1;
}
// Read the length of the data and the padding
//
if(fread(&valueLen, 4, 1, fp) != 1){
fclose(fp);
return -1;
}
// Read the offset of the actual value normalized to the value table
//
if(fread(&valueOffset, 4, 1, fp) != 1){
fclose(fp);
return -1;
}
// Skip to the actual value
//
if(fseek(fp, valueTableOffset + valueOffset, SEEK_SET) != 0){
fclose(fp);
return -1;
}
// Read the value from the value table into the char array that was passed into the function
//
if(fread(gameTitle, 1, valueLen, fp) != valueLen){
fclose(fp);
return -1;
};
// Close the EBOOT
//
fclose(fp);
// Return success
//
return 1;
}
// If we're here we never found a key that matched TITLE
//
fclose(fp);
// Return a catch all string
//
strcpy(gameTitle, "Title not found.");
// Return failure
//
return 0;
}
int main(int argc, char* argv[]){
// A char array to hold the game name (arbitrarily sized)
//
char * gameName = malloc(400);
// Get the title from the eboot
//
if(getTitle("EBOOT.PBP", gameName) > 0){
printf("%s\n", gameName);
}else{
printf("Error\n");
}
// Release our title buffer
//
free(gameName);
}
I couldn't leave well enough alone.
I made a new version that loads the SFO data into memory and processes it that way. It also uses the sceIo calls.
Here are my benchmarking finds (all benchmarks 10000 iterations @ 222mhz from ms0:):
62KB homebrew EBOOT.PBP
Original code with fread and fseek no memory: 74 seconds
Intermediate code with fread fseek and memory*: 35 seconds
Final code with sceIo calls and memory: 21 seconds
75MB ps1 EBOOT.PBP
Original code with fread and fseek no memory: 75 seconds
Intermediate code with fread fseek and memory*: 34 seconds
Final code with sceIo calls and memory: 21 seconds
25MB Official 4.01 firmware update EBOOT.PBP
Original code with fread and fseek no memory: 388 seconds
Intermediate code with fread fseek and memory*: 35 seconds
Final code with sceIo calls and memory: 21 seconds
*I didn't post the intermediate code, it's the same as the final code but using fread and fseek instead of the sceIo equivalent.
I'm pretty happy with the speed at this point. The lag on the firmware test can be attributed to a very large SFO to be parsed, but was included so that we can see that the code works on all sorts of EBOOTS. Notice that the new code treats this as efficiently as a stripped down homebrew EBOOT. I doubt anyone will be doing 10000 loads of any game titles so I'm sure the performance will be up to task.
Anyway here's the final code:
Edit: bug fix, sceIoLseek32() should == 0 not != 0
I made a new version that loads the SFO data into memory and processes it that way. It also uses the sceIo calls.
Here are my benchmarking finds (all benchmarks 10000 iterations @ 222mhz from ms0:):
62KB homebrew EBOOT.PBP
Original code with fread and fseek no memory: 74 seconds
Intermediate code with fread fseek and memory*: 35 seconds
Final code with sceIo calls and memory: 21 seconds
75MB ps1 EBOOT.PBP
Original code with fread and fseek no memory: 75 seconds
Intermediate code with fread fseek and memory*: 34 seconds
Final code with sceIo calls and memory: 21 seconds
25MB Official 4.01 firmware update EBOOT.PBP
Original code with fread and fseek no memory: 388 seconds
Intermediate code with fread fseek and memory*: 35 seconds
Final code with sceIo calls and memory: 21 seconds
*I didn't post the intermediate code, it's the same as the final code but using fread and fseek instead of the sceIo equivalent.
I'm pretty happy with the speed at this point. The lag on the firmware test can be attributed to a very large SFO to be parsed, but was included so that we can see that the code works on all sorts of EBOOTS. Notice that the new code treats this as efficiently as a stripped down homebrew EBOOT. I doubt anyone will be doing 10000 loads of any game titles so I'm sure the performance will be up to task.
Anyway here's the final code:
Code: Select all
u32 pspGetTitleFromEBOOT(const char * fileName, char * gameTitle, const char * defaultTitle){
u32 SFOOffset = 0;
u32 SFOEndOffset = 0;
u32 SFODataLength = 0;
char * SFOData = NULL;
u32 i = 0;
u32 curIndexOffset = 0;
SceUID fp = sceIoOpen(fileName, PSP_O_RDONLY, 0777);
if(!fp){
return -1;
}
// Skip the EBOOT header
//
if(sceIoLseek32(fp, 8, SEEK_SET) == 0){
sceIoClose(fp);
return -1;
}
// Read the offset to the sfo data in the eboot
//
if(sceIoRead(fp, &SFOOffset, 4) != 4){
sceIoClose(fp);
return -1;
}
// Read the offset to the end of the sfo data in the eboot
//
if(sceIoRead(fp, &SFOEndOffset, 4) != 4){
sceIoClose(fp);
return -1;
}
// Calculate the length of the SFO data
//
SFODataLength = SFOEndOffset - SFOOffset;
// Create a buffer just big enough for the sfo data
//
SFOData = malloc(SFODataLength);
// If we ran out of memory
//
if(!SFOData){
sceIoClose(fp);
return -1;
}
// Skip to the SFO
//
if(sceIoLseek32(fp, SFOOffset, SEEK_SET) == 0){
sceIoClose(fp);
return -1;
}
// Read the offset to the end of the sfo data in the eboot
// return error if we couldn't read it all
//
if(sceIoRead(fp, SFOData, SFODataLength) != SFODataLength){
sceIoClose(fp);
return -1;
}
// Close the EBOOT now that we're done with it
//
sceIoClose(fp);
// Set up a backwards loop to iterate over the key / value index
// 16 is the offset in the SFO header to get the number of index entries
//
for(i = *((u32 *)(SFOData + 16)) - 1; i >= 0; i--){
// Set the current index's offset, normalized tot he buffer start.
// 20 is the offset just past the SFO header
//
curIndexOffset = (16 * i) + 20;
// First Expression:
// If the key type is 2 (TXT) this key / value pair might be the title so continue to the expression
// 3 is the offset within the header for the key type
//
// Second Expression:
// Compare the current key to "TITLE"
// if it matches, we have the proper key
// 8 is the offset in the SFO header for the key table offset
//
if(*(SFOData + curIndexOffset + 3) == 2 && strcmp("TITLE", SFOData + (*((u32 *)(SFOData + 8))) + (*((u16 *)(SFOData + curIndexOffset)))) == 0){
// Copy our found string into the char * passed in
// the first 12 is the offset in the SFO header for the value table offset
// the second 12 is the offset in the current index for the value offset within the value table
//
strcpy(gameTitle, SFOData + (*((u32 *)(SFOData + 12))) + (*((u32 *)(SFOData + curIndexOffset + 12))));
// Return success
//
return 1;
}
}
// If we're here we never found a key that matched TITLE
// Return the default title
//
strcpy(gameTitle, defaultTitle);
// Return failure
//
return 0;
}
Last edited by Onii on Thu Oct 09, 2008 10:40 am, edited 1 time in total.
I was thinking about this one on my commute today. I was thinking that it was too fast to be correct. I was right. It was failing out early and my test script failed to detect the error condition.
I updated the code and statistics above. It's still the fastest by a good margin but not an order of magnitude faster, which makes sense.
The bug fix is that both of the seeks need to == 0 not != 0. Flip those two (or copy the updated code above), and let me know if it works.
The new third argument will be returned if no TITLE is found. It can be easily modified to return that string in all the error conditions, by putting the strcpy just before the returns, which is probably what should be done.
Sorry about the bug. Let me know how it goes.
J.F.: Why wouldn't we optimize this? The OP asked for a fast implementation. If we become complacent on the easy things (i.e. it took me about 5 minutes to convert form posix to sce for a ~40% speed increase) what happens when we get to the tough ones?
I updated the code and statistics above. It's still the fastest by a good margin but not an order of magnitude faster, which makes sense.
The bug fix is that both of the seeks need to == 0 not != 0. Flip those two (or copy the updated code above), and let me know if it works.
The new third argument will be returned if no TITLE is found. It can be easily modified to return that string in all the error conditions, by putting the strcpy just before the returns, which is probably what should be done.
Sorry about the bug. Let me know how it goes.
J.F.: Why wouldn't we optimize this? The OP asked for a fast implementation. If we become complacent on the easy things (i.e. it took me about 5 minutes to convert form posix to sce for a ~40% speed increase) what happens when we get to the tough ones?