The-Homebrew-Cloud/WiiFlow_Lite
2
0
Fork 0
mirror of https://github.com/Fledge68/WiiFlow_Lite.git synced 2024-11-27 13:44:15 +01:00
Code Issues Packages Projects Releases Wiki Activity

Making things ready for official wiiflow svn ;)

Browse Source 
-made wait animation faster
-removed a few unneeded lines in the wait message code
-fixed booting wii games from disc
-fixed possible bug in wii game launching in general
-gecko output again on wii game booting
-converted alot of spaces to tabs, fitting the general wiiflow
coding style
-general cleaning up things
This commit is contained in:
fix94.1 2012-07-25 22:12:17 +00:00
parent 6cb919c7ae
commit a36fab3cdd
39 changed files with 1649 additions and 1680 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
portlibs/include/fat.h
View File

@ -1,7 +1,7 @@
/*
fat.h
Simple functionality for startup, mounting and unmounting of FAT-based devices.
Copyright (c) 2006 - 2009
Michael "Chishm" Chisholm
Dave "WinterMute" Murphy
@ -71,7 +71,7 @@ extern bool fatInitDefault (void);
/*
Mount the device pointed to by interface, and set up a devoptab entry for it as "name:".
You can then access the filesystem using "name:/".
This will mount the active partition or the first valid partition on the disc,
This will mount the active partition or the first valid partition on the disc,
and will use a cache size optimized for the host system.
*/
extern bool fatMountSimple (const char* name, const DISC_INTERFACE* interface);

10
source/channel/channel_launcher.c
View File

@ -14,17 +14,9 @@
#include "gecko.h"
#include "mem2.hpp"
#define STACK_ALIGN(type, name, cnt, alignment) \
u8 _al__##name[((sizeof(type)*(cnt)) + (alignment) + \
(((sizeof(type)*(cnt))%(alignment)) > 0 ? ((alignment) - \
((sizeof(type)*(cnt))%(alignment))) : 0))]; \
type *name = (type*)(((u32)(_al__##name)) + ((alignment) - (( \
(u32)(_al__##name))&((alignment)-1))))
void __Disc_SetLowMem(void);
void __Disc_SetTime(void);
void _unstub_start();
u32 entryPoint;
extern void __exception_closeall();
@ -41,6 +33,8 @@ typedef struct _dolheader
u32 padding[7];
} __attribute__((packed)) dolheader;
u32 entryPoint;
s32 BootChannel(u32 entry, u64 chantitle, u32 ios, u8 vidMode, bool vipatch, bool countryString, u8 patchVidMode, int aspectRatio)
{
gprintf("Loading Channel...\n");

77
source/channel/nand.cpp
View File

@ -315,7 +315,7 @@ s32 Nand::__configread(void)
configloaded = configloaded ? false : true;
if(tbdec && configloaded)
return 1;
return 1;
return 0;
}
@ -422,10 +422,10 @@ u32 Nand::__configsetsetting(const char *item, const char *val)
void Nand::__FATify(char *ptr, const char *str)
{
char ctr;
while ((ctr = *(str++)) != '\0')
while((ctr = *(str++)) != '\0')
{
const char *esc;
switch (ctr)
switch(ctr)
{
case '"':
esc = "&qt;";
@ -468,13 +468,20 @@ void Nand::__NANDify(char *str)
{
if(c == '&')
{
if(!strncmp(src, "qt;", 3)) c = '"';
else if (!strncmp(src, "st;", 3)) c = '*';
else if (!strncmp(src, "cl;", 3)) c = ':';
else if (!strncmp(src, "lt;", 3)) c = '<';
else if (!strncmp(src, "gt;", 3)) c = '>';
else if (!strncmp(src, "qm;", 3)) c = '?';
else if (!strncmp(src, "vb;", 3)) c = '|';
if(!strncmp(src, "qt;", 3))
c = '"';
else if(!strncmp(src, "st;", 3))
c = '*';
else if(!strncmp(src, "cl;", 3))
c = ':';
else if(!strncmp(src, "lt;", 3))
c = '<';
else if(!strncmp(src, "gt;", 3))
c = '>';
else if(!strncmp(src, "qm;", 3))
c = '?';
else if(!strncmp(src, "vb;", 3))
c = '|';
if (c != '&')
src += 3;
@ -558,7 +565,7 @@ s32 Nand::__FlashNandFile(const char *source, const char *dest)
const char *file = strrchr(dest, '/')+1;
dumper(NandDone, NandSize, fsize, FileDone, FilesDone, FoldersDone, (char *)file, data);
}
}
}
gprintf(" done!\n");
FilesDone++;
if(showprogress)
@ -568,13 +575,13 @@ s32 Nand::__FlashNandFile(const char *source, const char *dest)
}
ISFS_Close(fd);
MEM2_free(buffer);
fclose(file);
fclose(file);
return 1;
}
s32 Nand::__DumpNandFile(const char *source, const char *dest)
{
FileDone = 0;
FileDone = 0;
s32 fd = ISFS_Open(source, ISFS_OPEN_READ);
if (fd < 0)
{
@ -667,8 +674,8 @@ s32 Nand::__DumpNandFile(const char *source, const char *dest)
dumper(NandDone, NandSize, status->file_length, FileDone, FilesDone, FoldersDone, (char *)file, data);
}
gprintf(" done!\n");
fclose(file);
ISFS_Close(fd);
fclose(file);
ISFS_Close(fd);
MEM2_free(status);
MEM2_free(buffer);
@ -705,16 +712,16 @@ s32 Nand::__FlashNandFolder(const char *source, const char *dest)
if(ent->d_type == DT_DIR)
{
__NANDify(ndest);
__NANDify(ndest);
if(!fake)
{
ISFS_CreateDir(ndest, 0, 3, 3, 3);
FoldersDone++;
}
__FlashNandFolder(nsource, ndest);
__FlashNandFolder(nsource, ndest);
}
else
{
{
__NANDify(ndest);
__FlashNandFile(nsource, ndest);
}
@ -730,18 +737,18 @@ s32 Nand::__DumpNandFolder(const char *source, const char *dest)
char ndest[MAX_FAT_PATH];
char tdest[MAX_FAT_PATH];
__GetNameList(source, &names, &cnt);
__GetNameList(source, &names, &cnt);
for(i = 0; i < cnt; i++)
{
if(source[strlen(source)-1] == '/')
snprintf(nsource, sizeof(nsource), "%s%s", source, names[i].name);
else
snprintf(nsource, sizeof(nsource), "%s/%s", source, names[i].name);
snprintf(nsource, sizeof(nsource), "%s/%s", source, names[i].name);
if(!names[i].type)
{
__FATify(tdest, nsource);
__FATify(tdest, nsource);
snprintf(ndest, sizeof(ndest), "%s%s", dest, tdest);
__DumpNandFile(nsource, ndest);
}
@ -749,7 +756,7 @@ s32 Nand::__DumpNandFolder(const char *source, const char *dest)
{
if(!fake)
{
__FATify(tdest, nsource);
__FATify(tdest, nsource);
CreatePath("%s%s", dest, tdest);
FoldersDone++;
}
@ -769,7 +776,7 @@ void Nand::CreatePath(const char *path, ...)
if((vasprintf(&folder, path, args) >= 0) && folder)
{
if(folder[strlen(folder)-1] == '/')
folder[strlen(folder)-1] = 0;
folder[strlen(folder)-1] = 0;
char *check = folder;
while (true)
@ -840,9 +847,9 @@ s32 Nand::FlashToNAND(const char *source, const char *dest, dump_callback_t i_du
data = i_data;
dumper = i_dumper;
fake = false;
showprogress = true;
showprogress = true;
__FlashNandFolder(source, dest);
return 0;
return 0;
}
s32 Nand::DoNandDump(const char *source, const char *dest, dump_callback_t i_dumper, void *i_data)
@ -851,7 +858,7 @@ s32 Nand::DoNandDump(const char *source, const char *dest, dump_callback_t i_dum
dumper = i_dumper;
fake = false;
showprogress = true;
u32 temp = 0;
u32 temp = 0;
s32 ret = ISFS_ReadDir(source, NULL, &temp);
if(ret < 0)
{
@ -862,10 +869,8 @@ s32 Nand::DoNandDump(const char *source, const char *dest, dump_callback_t i_dum
__DumpNandFile(source, ndest);
}
else
{
__DumpNandFolder(source, dest);
}
return 0;
return 0;
}
s32 Nand::CalcFlashSize(const char *source, dump_callback_t i_dumper, void *i_data)
@ -874,8 +879,8 @@ s32 Nand::CalcFlashSize(const char *source, dump_callback_t i_dumper, void *i_da
dumper = i_dumper;
fake = true;
showprogress = true;
__FlashNandFolder(source, "");
return NandSize;
__FlashNandFolder(source, "");
return NandSize;
}
s32 Nand::CalcDumpSpace(const char *source, dump_callback_t i_dumper, void *i_data)
@ -883,17 +888,17 @@ s32 Nand::CalcDumpSpace(const char *source, dump_callback_t i_dumper, void *i_da
data = i_data;
dumper = i_dumper;
fake = true;
showprogress = true;
showprogress = true;
u32 temp = 0;
u32 temp = 0;
s32 ret = ISFS_ReadDir(source, NULL, &temp);
if(ret < 0)
if(ret < 0)
__DumpNandFile(source, "");
else
__DumpNandFolder(source, "");
return NandSize;
return NandSize;
}
void Nand::ResetCounters(void)
@ -1021,5 +1026,5 @@ s32 Nand::Do_Region_Change(string id)
}
}
__configwrite();
return 1;
return 1;
}

5
source/devicemounter/libwbfs/libwbfs.c
View File

@ -12,8 +12,6 @@
#define likely(x) __builtin_expect(!!(x), 1)
#define unlikely(x) __builtin_expect(!!(x), 0)
#define read_le32_unaligned(x) ((x)[0]|((x)[1]<<8)|((x)[2]<<16)|((x)[3]<<24))
#define ERROR(x) do {wbfs_error(x);goto error;}while(0)
#define ALIGN_LBA(x) (((x)+p->hd_sec_sz-1)&(~(p->hd_sec_sz-1)))
@ -37,6 +35,8 @@ static u8 size_to_shift(u32 size)
return ret - 1;
}
#define read_le32_unaligned(x) ((x)[0]|((x)[1]<<8)|((x)[2]<<16)|((x)[3]<<24))
wbfs_t *wbfs_open_hd(rw_sector_callback_t read_hdsector, rw_sector_callback_t write_hdsector, void *callback_data, int hd_sector_size, int num_hd_sector __attribute((unused)), int reset)
{
int i=num_hd_sector,ret;
@ -64,7 +64,6 @@ wbfs_t *wbfs_open_hd(rw_sector_callback_t read_hdsector, rw_sector_callback_t wr
wbfs_iofree(tmp_buffer);
if(reset)// XXX make a empty hd partition..
{
}
return 0;
}

8
source/devicemounter/libwbfs/rijndael.c
View File

@ -382,6 +382,7 @@ void aes_decrypt(u8 *iv, u8 *inbuf, u8 *outbuf, unsigned long long len)
}
else fraction = 16;
// debug_printf("block %d: fraction = %d\n", blockno, fraction);
memcpy(block, inbuf + blockno * sizeof(block), fraction);
decrypt((char*) block);
u8 *ctext_ptr;
@ -391,6 +392,8 @@ void aes_decrypt(u8 *iv, u8 *inbuf, u8 *outbuf, unsigned long long len)
for (i = 0; i < fraction; i++)
outbuf[blockno * sizeof(block) + i] = ctext_ptr[i] ^ block[i];
// debug_printf("Block %d output: ", blockno);
// hexdump(outbuf + blockno*sizeof(block), 16);
}
}
@ -400,6 +403,8 @@ void aes_encrypt(u8 *iv, u8 *inbuf, u8 *outbuf, unsigned long long len)
u8 block[16];
unsigned int blockno = 0, i;
// debug_printf("aes_decrypt(%p, %p, %p, %lld)\n", iv, inbuf, outbuf, len);
for (blockno = 0; blockno <= (len / sizeof(block)); blockno++)
{
unsigned int fraction;
@ -411,6 +416,7 @@ void aes_encrypt(u8 *iv, u8 *inbuf, u8 *outbuf, unsigned long long len)
}
else fraction = 16;
// debug_printf("block %d: fraction = %d\n", blockno, fraction);
memcpy(block, inbuf + blockno * sizeof(block), fraction);
for (i = 0; i < fraction; i++)
@ -419,6 +425,8 @@ void aes_encrypt(u8 *iv, u8 *inbuf, u8 *outbuf, unsigned long long len)
encrypt((char*) block);
memcpy(iv, block, sizeof(block));
memcpy(outbuf + blockno * sizeof(block), block, sizeof(block));
// debug_printf("Block %d output: ", blockno);
// hexdump(outbuf + blockno*sizeof(block), 16);
}
}

8
source/gecko/gecko.c
View File

@ -16,7 +16,6 @@
/* init-globals */
bool geckoinit = false;
bool textVideoInit = false;
bool geckoDisable = false;
bool bufferMessages = true;
bool WriteToSD = false;
@ -108,8 +107,6 @@ void WriteToFile(char* tmp)
//using the gprintf from crediar because it is smaller than mine
void gprintf( const char *format, ... )
{
if(geckoDisable)
return;
char *tmp = NULL;
va_list va;
va_start(va, format);
@ -184,11 +181,6 @@ bool InitGecko()
return false;
}
void GeckoDisable()
{
geckoDisable = true;
}
void AllocSDGeckoBuffer()
{
tmpfilebuffer = (char*)MEM2_alloc(filebuffer + 1 * sizeof(char));

20
source/gecko/gecko.h
View File

@ -1,5 +1,4 @@
#ifndef _GECKO_H_
#define _GECKO_H_
@ -7,17 +6,16 @@
extern "C" {
#endif
extern bool geckoinit;
extern bool bufferMessages;
extern bool WriteToSD;
extern bool geckoinit;
extern bool bufferMessages;
extern bool WriteToSD;
//use this just like printf();
void gprintf(const char *format, ...);
void ghexdump(void *d, int len);
bool InitGecko();
void AllocSDGeckoBuffer();
void ClearLogBuffer();
void GeckoDisable();
//use this just like printf();
void gprintf(const char *format, ...);
void ghexdump(void *d, int len);
bool InitGecko();
void AllocSDGeckoBuffer();
void ClearLogBuffer();
#ifdef __cplusplus
}

1372
source/gui/GameTDB.cpp
View File

File diff suppressed because it is too large Load Diff

27
source/gui/video.cpp
View File

@ -489,7 +489,7 @@ void CVideo::_showWaitMessages(CVideo *m)
m->m_showingWaitMessages = true;
u32 frames = m->m_waitMessageDelay * 50;
u32 waitFrames = frames;
u8 fadeStep = 2 * (u32) (255.f / (waitFrames * m->m_waitMessages.size()));
s8 fadeDirection = 1;
s8 PNGfadeDirection = 1;
@ -497,10 +497,11 @@ void CVideo::_showWaitMessages(CVideo *m)
vector<STexture>::iterator waitItr = m->m_waitMessages.begin();
gprintf("Going to show a wait message screen, delay: %d, # images: %d\n", waitFrames, m->m_waitMessages.size());
m->_clearScreen();
m->waitMessage(*waitItr);
waitItr += PNGfadeDirection;
m->prepare();
m->setup2DProjection();
GX_SetNumChans(0);
wiiLightSetLevel(0);
wiiLightOn();
@ -523,16 +524,15 @@ void CVideo::_showWaitMessages(CVideo *m)
{
m->waitMessage(*waitItr);
waitItr += PNGfadeDirection;
if(waitItr == m->m_waitMessages.end())
waitItr = m->m_waitMessages.begin();
waitFrames = frames;
}
waitFrames--;
VIDEO_WaitVSync();
waitFrames--;
}
wiiLightOff();
GX_SetNumChans(1);
m->m_showingWaitMessages = false;
gprintf("Stop showing images\n");
}
@ -584,26 +584,23 @@ void CVideo::waitMessage(float delay)
void CVideo::waitMessage(const vector<STexture> &tex, float delay)
{
hideWaitMessage();
if(tex.size() == 0)
{
m_waitMessages = m_defaultWaitMessages;
m_waitMessageDelay = 0.2f;
m_waitMessageDelay = 0.1f;
}
else
{
m_waitMessages = tex;
m_waitMessageDelay = delay;
}
_clearScreen();
if (m_waitMessages.size() == 1)
if(m_waitMessages.size() == 1)
waitMessage(m_waitMessages[0]);
else if(m_waitMessages.size() > 1)
{
CheckWaitThread();
m_showWaitMessage = true;
unsigned int stack_size = (unsigned int)32768;
u32 stack_size = (u32)32768;
waitThreadStack = smartMem2Alloc(stack_size);
LWP_CreateThread(&waitThread, (void *(*)(void *))CVideo::_showWaitMessages, (void *)this, waitThreadStack.get(), stack_size, LWP_PRIO_IDLE);
}
@ -614,9 +611,6 @@ void CVideo::waitMessage(const STexture &tex)
Mtx modelViewMtx;
GXTexObj texObj;
prepare();
setup2DProjection();
GX_SetNumChans(0);
GX_ClearVtxDesc();
GX_SetVtxDesc(GX_VA_POS, GX_DIRECT);
GX_SetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XYZ, GX_F32, 0);
@ -648,7 +642,6 @@ void CVideo::waitMessage(const STexture &tex)
GX_TexCoord2f32(0.f, 1.f);
GX_End();
render();
GX_SetNumChans(1);
}
s32 CVideo::TakeScreenshot(const char *path)

1
source/gui/video.hpp
View File

@ -64,6 +64,7 @@ public:
bool wide(void) const { return m_wide; }
bool vid_50hz(void) const { return m_50hz; }
u8 getAA(void) const { return m_aa; }
bool showingWaitMessage() { return m_showingWaitMessages; }
void set2DViewport(u32 w, u32 h, int x, int y);
void prepareStencil(void);
void renderStencil(void);

8
source/list/cachedlist.cpp
View File

@ -38,13 +38,13 @@ void CachedList<T>::Load(string path, string containing, string m_lastLanguage,
struct stat filestat, discinfo, cache;
gprintf("%s\n", path.c_str());
if(stat(path.c_str(), &filestat) == -1)
return;
return;
bool update_lang = m_lastLanguage != m_curLanguage;
bool noDB = stat(m_database.c_str(), &cache) == -1;
bool mtimes = filestat.st_mtime > cache.st_mtime;
if(strcasestr(m_discinf.c_str(), "wbfs") != NULL && stat(m_discinf.c_str(), &discinfo) != -1)
ditimes = discinfo.st_mtime > cache.st_mtime;
ditimes = discinfo.st_mtime > cache.st_mtime;
m_update = update_lang || noDB || mtimes || ditimes;
if(m_update)
@ -94,7 +94,7 @@ void CachedList<T>::Load(string path, string containing, string m_lastLanguage,
remove(path.c_str());
m_loaded = true;
m_update = false;
m_update = false;
if(!music && pathlist.size() > 0)
{
@ -103,7 +103,7 @@ void CachedList<T>::Load(string path, string containing, string m_lastLanguage,
}
}
else
{
{
CCache<T>(*this, m_database, LOAD);
m_loaded = true;
}

10
source/loader/apploader.c
View File

@ -22,10 +22,10 @@ typedef void *(*app_final)();
typedef void (*app_entry)(void (**init)(void (*report)(const char *fmt, ...)), int (**main)(), void *(**final)());
/* Apploader pointers */
static u8 *appldr = (u8 *) 0x81200000;
static u8 *appldr = (u8 *)0x81200000;
/* Constants */
#define APPLDR_OFFSET 0x2440
#define APPLDR_OFFSET 0x2440
/* Variables */
static u32 buffer[0x20] ATTRIBUTE_ALIGN(32);
@ -57,11 +57,15 @@ s32 Apploader_Run(entry_point *entry, u8 vidMode, GXRModeObj *vmode, bool vipatc
/* Calculate apploader length */
appldr_len = buffer[5] + buffer[6];
SYS_SetArena1Hi((void *)0x816FFFF0); //Kills the possibility of codedumps with gprintf
/* Read apploader code */
ret = WDVD_Read(appldr, appldr_len, APPLDR_OFFSET + 0x20);
if (ret < 0)
if(ret < 0)
return ret;
DCFlushRange(appldr, appldr_len);
/* Set apploader entry function */
app_entry appldr_entry = (app_entry)buffer[4];

6
source/loader/frag.c
View File

@ -241,7 +241,7 @@ int get_frag_list(u8 *id, char *path, const u32 hdd_sector_size)
frag_concat(fa, fs);
}
frag_list = MEM1_memalign(32, sizeof(FragList));
frag_list = MEM1_alloc(ALIGN32(sizeof(FragList)));
if(frag_list == NULL)
goto out;
@ -307,10 +307,12 @@ int set_frag_list(u8 *id)
DCFlushRange(frag_list, size);
gprintf("Calling WDVD_SetFragList, frag list size %d\n", size);
/* if (size > 400) ghexdump(frag_list, 400);
else ghexdump(frag_list, size); */
int ret = WDVD_SetFragList(wbfsDev, frag_list, size);
MEM1_free(frag_list);
free(frag_list);
frag_list = NULL;
if(ret)

8
source/loader/splits.c
View File

@ -12,7 +12,7 @@
#include <ctype.h>
#include "splits.h"
#include "gecko/gecko.h"
#include "gecko.h"
#define off64_t off_t
#define FMT_llu "%llu"
@ -21,7 +21,7 @@
#define split_error(x) do { gprintf("\nsplit error: %s\n\n",x); } while(0)
// 1 cluster less than 4gb
u64 OPT_split_size = (u64) 4LL * 1024 * 1024 * 1024 - 32 * 1024;
u64 OPT_split_size = (u64)4LL * 1024 * 1024 * 1024 - 32 * 1024;
// 1 cluster less than 2gb
//u64 OPT_split_size = (u64)2LL * 1024 * 1024 * 1024 - 32 * 1024;
@ -88,7 +88,7 @@ int split_fill(split_info_t *s, int idx, u64 size)
int fd = split_open_file(s, idx);
off64_t fsize = lseek(fd, 0, SEEK_END);
if ((u64)fsize < size)
if((u64)fsize < size)
{
// gprintf("TRUNC %d "FMT_lld" "FMT_lld"\n", idx, size, fsize); // Wpad_WaitButtons();
ftruncate(fd, size);
@ -149,7 +149,7 @@ int split_get_file(split_info_t *s, u32 lba, u32 *sec_count, int fill)
int split_read_sector(void *_fp, u32 lba, u32 count, void *buf)
{
split_info_t *s = _fp;
int fd;
int fd;
u64 off = lba;
off *= 512ULL;
int i;

2
source/loader/wbfs_ext.c
View File

@ -53,6 +53,8 @@ wbfs_disc_t* WBFS_Ext_OpenDisc(u8 *discid, char *fname)
if (fd == -1) return NULL;
wbfs_disc_t *iso_file = MEM2_alloc(sizeof(wbfs_disc_t));
memset(iso_file, 0, sizeof(wbfs_disc_t));
if (iso_file == NULL)
return NULL;

141
source/loader/wip.c
View File

@ -14,42 +14,42 @@ static u32 Counter = 0;
void do_wip_code(u8 * dst, u32 len)
{
if(!CodeList)
return;
if(!CodeList)
return;
if(Counter < 3)
{
Counter++;
return;
}
if(Counter < 3)
{
Counter++;
return;
}
u32 i = 0;
s32 n = 0;
s32 offset = 0;
u32 i = 0;
s32 n = 0;
s32 offset = 0;
for(i = 0; i < CodesCount; i++)
{
for(n = 0; n < 4; n++)
{
offset = CodeList[i].offset+n-ProcessedLength;
for(i = 0; i < CodesCount; i++)
{
for(n = 0; n < 4; n++)
{
offset = CodeList[i].offset+n-ProcessedLength;
if(offset < 0 || (u32)offset >= len)
continue;
if(offset < 0 || (u32)offset >= len)
continue;
if(dst[offset] == ((u8 *)&CodeList[i].srcaddress)[n])
{
dst[offset] = ((u8 *)&CodeList[i].dstaddress)[n];
gprintf("WIP: %08X Address Patched.\n", CodeList[i].offset + n);
}
else
{
gprintf("WIP: %08X Address does not match with WIP entry.\n", CodeList[i].offset+n);
gprintf("Destination: %02X | Should be: %02X.\n", dst[offset], ((u8 *)&CodeList[i].srcaddress)[n]);
}
}
}
ProcessedLength += len;
Counter++;
if(dst[offset] == ((u8 *)&CodeList[i].srcaddress)[n])
{
dst[offset] = ((u8 *)&CodeList[i].dstaddress)[n];
gprintf("WIP: %08X Address Patched.\n", CodeList[i].offset + n);
}
else
{
gprintf("WIP: %08X Address does not match with WIP entry.\n", CodeList[i].offset+n);
gprintf("Destination: %02X | Should be: %02X.\n", dst[offset], ((u8 *)&CodeList[i].srcaddress)[n]);
}
}
}
ProcessedLength += len;
Counter++;
}
//! for internal patches only
@ -58,7 +58,7 @@ void do_wip_code(u8 * dst, u32 len)
//! if set was successful the codelist will be freed when it's done
bool set_wip_list(WIP_Code * list, int size)
{
if (!CodeList && size > 0)
if(!CodeList && size > 0)
{
CodeList = list;
CodesCount = size;
@ -70,18 +70,18 @@ bool set_wip_list(WIP_Code * list, int size)
void wip_reset_counter()
{
ProcessedLength = 0;
//alternative dols don't need a skip. only main.dol.
Counter = 3;
ProcessedLength = 0;
//alternative dols don't need a skip. only main.dol.
Counter = 3;
}
void free_wip()
{
if(CodeList)
MEM2_free(CodeList);
MEM2_free(CodeList);
CodesCount = 0;
ProcessedLength = 0;
CodesCount = 0;
ProcessedLength = 0;
}
int load_wip_patches(u8 *dir, u8 *gameid)
@ -89,54 +89,53 @@ int load_wip_patches(u8 *dir, u8 *gameid)
char filepath[150];
char GameID[8];
memset(GameID, 0, sizeof(GameID));
memcpy(GameID, gameid, 6);
memcpy(GameID, gameid, 6);
snprintf(filepath, sizeof(filepath), "%s/%s.wip", dir, GameID);
FILE * fp = fopen(filepath, "rb");
if (!fp)
FILE *fp = fopen(filepath, "rb");
if(!fp)
{
memset(GameID, 0, sizeof(GameID));
memcpy(GameID, gameid, 3);
memset(GameID, 0, sizeof(GameID));
memcpy(GameID, gameid, 3);
snprintf(filepath, sizeof(filepath), "%s/%s.wip", dir, GameID);
fp = fopen(filepath, "rb");
}
if (!fp)
return -1;
if(!fp)
return -1;
char line[255];
gprintf("\nLoading WIP code from %s.\n", filepath);
char line[255];
gprintf("\nLoading WIP code from %s.\n", filepath);
while (fgets(line, sizeof(line), fp))
{
if (line[0] == '#') continue;
while(fgets(line, sizeof(line), fp))
{
if(line[0] == '#' || strlen(line) < 26)
continue;
if(strlen(line) < 26) continue;
u32 offset = (u32) strtoul(line, NULL, 16);
u32 srcaddress = (u32) strtoul(line+9, NULL, 16);
u32 dstaddress = (u32) strtoul(line+18, NULL, 16);
u32 offset = (u32) strtoul(line, NULL, 16);
u32 srcaddress = (u32) strtoul(line+9, NULL, 16);
u32 dstaddress = (u32) strtoul(line+18, NULL, 16);
if(!CodeList)
if(!CodeList)
CodeList = MEM2_alloc(sizeof(WIP_Code));
WIP_Code *tmp = MEM2_realloc(CodeList, (CodesCount+1)*sizeof(WIP_Code));
if(!tmp)
{
MEM2_free(CodeList);
fclose(fp);
return -1;
}
WIP_Code *tmp = MEM2_realloc(CodeList, (CodesCount+1)*sizeof(WIP_Code));
if(!tmp)
{
MEM2_free(CodeList);
fclose(fp);
return -1;
}
CodeList = tmp;
CodeList = tmp;
CodeList[CodesCount].offset = offset;
CodeList[CodesCount].srcaddress = srcaddress;
CodeList[CodesCount].dstaddress = dstaddress;
CodesCount++;
}
fclose(fp);
gprintf("\n");
CodeList[CodesCount].offset = offset;
CodeList[CodesCount].srcaddress = srcaddress;
CodeList[CodesCount].dstaddress = dstaddress;
CodesCount++;
}
fclose(fp);
gprintf("\n");
return 0;
}

2
source/main.cpp
View File

@ -37,7 +37,7 @@ int main(int argc, char **argv)
vid.init();
MEM2_init(47); //Should be safe to use
vid.waitMessage(0.2f);
vid.waitMessage(0.1f);
AllocSDGeckoBuffer();
gprintf(" \nWelcome to %s (%s-r%s)!\nThis is the debug output.\n", APP_NAME, APP_VERSION, SVN_REV);

3
source/menu/menu.cpp
View File

@ -1812,8 +1812,9 @@ void CMenu::_mainLoopCommon(bool withCF, bool blockReboot, bool adjusting)
m_btnMgr.draw();
ScanInput();
if(!m_vid.showingWaitMessage())
m_vid.render();
m_vid.render();
if(!blockReboot)
{
if(withCF && Sys_Exiting())

1
source/menu/menu_game.cpp
View File

@ -1427,7 +1427,6 @@ void CMenu::_launchGame(dir_discHdr *hdr, bool dvd)
if(currentPartition == 0)
SDHC_Init();
GeckoDisable();
#endif
RunApploader(offset, videoMode, vipatch, countryPatch, patchVidMode, aspectRatio, returnTo);

11
source/menu/menu_main.cpp
View File

@ -188,11 +188,12 @@ int CMenu::GetCoverStatusAsync(CMenu *m)
void CMenu::LoadView(void)
{
_showWaitMessage();
_hideMain();
m_curGameId = m_cf.getId();
_hideMain(true);
m_cf.clear();
_showWaitMessage();
_loadList();
_showMain();
_initCF();
@ -418,8 +419,10 @@ int CMenu::main(void)
}
else if(m_btnMgr.selected(m_mainBtnDVD))
{
_showWaitMessage();
_hideMain(true);
m_cf.clear();
_showWaitMessage();
dir_discHdr hdr;
memset(&hdr, 0, sizeof(dir_discHdr));
memcpy(&hdr.id, "dvddvd", 6);

40
source/music/AifDecoder.cpp
View File

@ -53,37 +53,39 @@ typedef struct
# define UnsignedToFloat(u) (((double)((long)(u - 2147483647L - 1))) + 2147483648.0)
static double ConvertFromIeeeExtended(const unsigned char* bytes)
static double ConvertFromIeeeExtended(const u8* bytes)
{
double f;
int expon;
unsigned long hiMant, loMant;
u64 hiMant, loMant;
expon = ((bytes[0] & 0x7F) << 8) | (bytes[1] & 0xFF);
hiMant = ((unsigned long)(bytes[2] & 0xFF) << 24)
| ((unsigned long)(bytes[3] & 0xFF) << 16)
| ((unsigned long)(bytes[4] & 0xFF) << 8)
| ((unsigned long)(bytes[5] & 0xFF));
loMant = ((unsigned long)(bytes[6] & 0xFF) << 24)
| ((unsigned long)(bytes[7] & 0xFF) << 16)
| ((unsigned long)(bytes[8] & 0xFF) << 8)
| ((unsigned long)(bytes[9] & 0xFF));
if (expon == 0 && hiMant == 0 && loMant == 0) {
hiMant = ((u64)(bytes[2] & 0xFF) << 24)
| ((u64)(bytes[3] & 0xFF) << 16)
| ((u64)(bytes[4] & 0xFF) << 8)
| ((u64)(bytes[5] & 0xFF));
loMant = ((u64)(bytes[6] & 0xFF) << 24)
| ((u64)(bytes[7] & 0xFF) << 16)
| ((u64)(bytes[8] & 0xFF) << 8)
| ((u64)(bytes[9] & 0xFF));
if(expon == 0 && hiMant == 0 && loMant == 0)
f = 0;
}
else {
if (expon == 0x7FFF) {
else
{
if(expon == 0x7FFF)
f = HUGE_VAL;
}
else {
else
{
expon -= 16383;
f = ldexp(UnsignedToFloat(hiMant), expon-=31);
f = ldexp(UnsignedToFloat(hiMant), expon-=31);
f += ldexp(UnsignedToFloat(loMant), expon-=32);
}
}
if (bytes[0] & 0x80)
if(bytes[0] & 0x80)
return -f;
else
return f;
@ -227,9 +229,7 @@ int AifDecoder::Read(u8 * buffer, int buffer_size, int)
int read = file_fd->read(buffer, buffer_size);
if(read > 0)
{
CurPos += read;
}
return read;
}

28
source/music/AifDecoder.hpp
View File

@ -31,20 +31,20 @@
class AifDecoder : public SoundDecoder
{
public:
AifDecoder(const char * filepath);
AifDecoder(const u8 * snd, int len);
~AifDecoder();
int GetFormat() { return Format; };
int GetSampleRate() { return SampleRate; };
int Read(u8 * buffer, int buffer_size, int pos);
protected:
void OpenFile();
void CloseFile();
u32 DataOffset;
u32 DataSize;
u32 SampleRate;
u8 Format;
public:
AifDecoder(const char *filepath);
AifDecoder(const u8 *snd, int len);
~AifDecoder();
int GetFormat() { return Format; };
int GetSampleRate() { return SampleRate; };
int Read(u8 *buffer, int buffer_size, int pos);
protected:
void OpenFile();
void CloseFile();
u32 DataOffset;
u32 DataSize;
u32 SampleRate;
u8 Format;
};
#endif

136
source/music/BNSDecoder.cpp
View File

@ -32,109 +32,109 @@
#include "BNSDecoder.hpp"
BNSDecoder::BNSDecoder(const char * filepath)
: SoundDecoder(filepath)
: SoundDecoder(filepath)
{
SoundType = SOUND_BNS;
memset(&SoundData, 0, sizeof(SoundBlock));
SoundType = SOUND_BNS;
memset(&SoundData, 0, sizeof(SoundBlock));
if(!file_fd)
return;
if(!file_fd)
return;
OpenFile();
OpenFile();
}
BNSDecoder::BNSDecoder(const u8 * snd, int len)
: SoundDecoder(snd, len)
: SoundDecoder(snd, len)
{
SoundType = SOUND_BNS;
memset(&SoundData, 0, sizeof(SoundBlock));
SoundType = SOUND_BNS;
memset(&SoundData, 0, sizeof(SoundBlock));
if(!file_fd)
return;
if(!file_fd)
return;
OpenFile();
OpenFile();
}
BNSDecoder::~BNSDecoder()
{
ExitRequested = true;
while(Decoding)
usleep(100);
ExitRequested = true;
while(Decoding)
usleep(100);
MEM2_free(SoundData.buffer);
MEM2_free(SoundData.buffer);
}
void BNSDecoder::OpenFile()
{
u8 * tempbuff = new (std::nothrow) u8[file_fd->size()];
if(!tempbuff)
{
CloseFile();
return;
}
u8 *tempbuff = new (std::nothrow) u8[file_fd->size()];
if(!tempbuff)
{
CloseFile();
return;
}
int done = 0;
int done = 0;
while(done < file_fd->size())
{
int read = file_fd->read(tempbuff, file_fd->size());
if(read > 0)
done += read;
else
{
CloseFile();
return;
}
}
while(done < file_fd->size())
{
int read = file_fd->read(tempbuff, file_fd->size());
if(read > 0)
done += read;
else
{
CloseFile();
return;
}
}
SoundData = DecodefromBNS(tempbuff, done);
if(SoundData.buffer == NULL)
{
CloseFile();
return;
}
SoundData = DecodefromBNS(tempbuff, done);
if(SoundData.buffer == NULL)
{
CloseFile();
return;
}
delete [] tempbuff;
tempbuff = NULL;
delete [] tempbuff;
tempbuff = NULL;
Decode();
Decode();
}
void BNSDecoder::CloseFile()
{
if(file_fd)
delete file_fd;
if(file_fd)
delete file_fd;
file_fd = NULL;
file_fd = NULL;
}
int BNSDecoder::Read(u8 * buffer, int buffer_size, int)
{
if(!SoundData.buffer)
return -1;
if(!SoundData.buffer)
return -1;
if(SoundData.loopFlag)
{
int factor = SoundData.format == VOICE_STEREO_16BIT ? 4 : 2;
if(CurPos >= (int) SoundData.loopEnd*factor)
CurPos = SoundData.loopStart*factor;
if(SoundData.loopFlag)
{
int factor = SoundData.format == VOICE_STEREO_16BIT ? 4 : 2;
if(CurPos >= (int) SoundData.loopEnd*factor)
CurPos = SoundData.loopStart*factor;
if(buffer_size > (int) SoundData.loopEnd*factor-CurPos)
buffer_size = SoundData.loopEnd*factor-CurPos;
}
else
{
if(CurPos >= (int) SoundData.size)
return 0;
if(buffer_size > (int) SoundData.loopEnd*factor-CurPos)
buffer_size = SoundData.loopEnd*factor-CurPos;
}
else
{
if(CurPos >= (int) SoundData.size)
return 0;
if(buffer_size > (int) SoundData.size-CurPos)
buffer_size = SoundData.size-CurPos;
}
if(buffer_size > (int) SoundData.size-CurPos)
buffer_size = SoundData.size-CurPos;
}
memcpy(buffer, SoundData.buffer+CurPos, buffer_size);
CurPos += buffer_size;
memcpy(buffer, SoundData.buffer+CurPos, buffer_size);
CurPos += buffer_size;
return buffer_size;
return buffer_size;
}
struct BNSHeader
@ -306,8 +306,8 @@ static u8 * decodeBNS(u32 &size, const BNSInfo &bnsInfo, const BNSData &bnsData)
SoundBlock DecodefromBNS(const u8 *buffer, u32 size)
{
SoundBlock OutBlock;
memset(&OutBlock, 0, sizeof(SoundBlock));
SoundBlock OutBlock;
memset(&OutBlock, 0, sizeof(SoundBlock));
const BNSHeader &hdr = *(BNSHeader *)buffer;
if (size < sizeof hdr)

24
source/music/BNSDecoder.hpp
View File

@ -30,7 +30,7 @@
typedef struct _SoundBlock
{
u8 * buffer;
u8 *buffer;
u32 size;
u8 format;
u32 frequency;
@ -41,17 +41,17 @@ typedef struct _SoundBlock
class BNSDecoder : public SoundDecoder
{
public:
BNSDecoder(const char * filepath);
BNSDecoder(const u8 * snd, int len);
~BNSDecoder();
int GetFormat() { return SoundData.format; };
int GetSampleRate() { return SoundData.frequency; };
int Read(u8 * buffer, int buffer_size, int pos);
protected:
void OpenFile();
void CloseFile();
SoundBlock SoundData;
public:
BNSDecoder(const char * filepath);
BNSDecoder(const u8 * snd, int len);
~BNSDecoder();
int GetFormat() { return SoundData.format; };
int GetSampleRate() { return SoundData.frequency; };
int Read(u8 * buffer, int buffer_size, int pos);
protected:
void OpenFile();
void CloseFile();
SoundBlock SoundData;
};
SoundBlock DecodefromBNS(const u8 *buffer, u32 size);

110
source/music/BufferCircle.hpp
View File

@ -32,62 +32,62 @@
class BufferCircle
{
public:
//!> Constructor
BufferCircle();
//!> Destructor
~BufferCircle();
//!> Set circle size
void Resize(int size);
//!> Get the circle size
int Size() { return SoundBuffer.size(); };
//!> Set/resize the buffer size
void SetBufferBlockSize(int size);
//!> Remove a buffer
void RemoveBuffer(int pos);
//!> Set all buffers clear
void ClearBuffer();
//!> Free all buffers
void FreeBuffer();
//!> Switch to next buffer
void LoadNext();
//!> Get the current buffer
u8 * GetBuffer() { if(!Valid(which)) return 0; return SoundBuffer[which]; };
//!> Get a buffer at a position
u8 * GetBuffer(int pos) { if(!Valid(pos)) return NULL; else return SoundBuffer[pos]; };
//!> Get next buffer
u8 * GetNextBuffer() { if(Size() <= 0) return 0; else return SoundBuffer[(which+1) % Size()]; };
//!> Get previous buffer
u8 * GetLastBuffer() { if(Size() <= 0) return 0; else return SoundBuffer[(which+Size()-1) % Size()]; };
//!> Get current buffer size
u32 GetBufferSize() { if(!Valid(which)) return 0; else return BufferSize[which]; };
//!> Get buffer size at position
u32 GetBufferSize(int pos) { if(!Valid(pos)) return 0; else return BufferSize[pos]; };
//!> Get previous buffer size
u32 GetLastBufferSize() { if(Size() <= 0) return 0; else return BufferSize[(which+Size()-1) % Size()]; };
//!> Is current buffer ready
bool IsBufferReady() { if(!Valid(which)) return false; else return BufferReady[which]; };
//!> Is a buffer at a position ready
bool IsBufferReady(int pos) { if(!Valid(pos)) return false; else return BufferReady[pos]; };
//!> Is next buffer ready
bool IsNextBufferReady() { if(Size() <= 0) return false; else return BufferReady[(which+1) % Size()]; };
//!> Is last buffer ready
bool IsLastBufferReady() { if(Size() <= 0) return false; else return BufferReady[(which+Size()-1) % Size()]; };
//!> Set a buffer at a position to a ready state
void SetBufferReady(int pos, bool st);
//!> Set the buffersize at a position
void SetBufferSize(int pos, int size);
//!> Get the current position in the circle
u16 Which() { return which; };
protected:
//!> Check if the position is a valid position in the vector
bool Valid(int pos) { return !(pos < 0 || pos >= Size()); };
public:
//!> Constructor
BufferCircle();
//!> Destructor
~BufferCircle();
//!> Set circle size
void Resize(int size);
//!> Get the circle size
int Size() { return SoundBuffer.size(); };
//!> Set/resize the buffer size
void SetBufferBlockSize(int size);
//!> Remove a buffer
void RemoveBuffer(int pos);
//!> Set all buffers clear
void ClearBuffer();
//!> Free all buffers
void FreeBuffer();
//!> Switch to next buffer
void LoadNext();
//!> Get the current buffer
u8 * GetBuffer() { if(!Valid(which)) return 0; return SoundBuffer[which]; };
//!> Get a buffer at a position
u8 * GetBuffer(int pos) { if(!Valid(pos)) return NULL; else return SoundBuffer[pos]; };
//!> Get next buffer
u8 * GetNextBuffer() { if(Size() <= 0) return 0; else return SoundBuffer[(which+1) % Size()]; };
//!> Get previous buffer
u8 * GetLastBuffer() { if(Size() <= 0) return 0; else return SoundBuffer[(which+Size()-1) % Size()]; };
//!> Get current buffer size
u32 GetBufferSize() { if(!Valid(which)) return 0; else return BufferSize[which]; };
//!> Get buffer size at position
u32 GetBufferSize(int pos) { if(!Valid(pos)) return 0; else return BufferSize[pos]; };
//!> Get previous buffer size
u32 GetLastBufferSize() { if(Size() <= 0) return 0; else return BufferSize[(which+Size()-1) % Size()]; };
//!> Is current buffer ready
bool IsBufferReady() { if(!Valid(which)) return false; else return BufferReady[which]; };
//!> Is a buffer at a position ready
bool IsBufferReady(int pos) { if(!Valid(pos)) return false; else return BufferReady[pos]; };
//!> Is next buffer ready
bool IsNextBufferReady() { if(Size() <= 0) return false; else return BufferReady[(which+1) % Size()]; };
//!> Is last buffer ready
bool IsLastBufferReady() { if(Size() <= 0) return false; else return BufferReady[(which+Size()-1) % Size()]; };
//!> Set a buffer at a position to a ready state
void SetBufferReady(int pos, bool st);
//!> Set the buffersize at a position
void SetBufferSize(int pos, int size);
//!> Get the current position in the circle
u16 Which() { return which; };
protected:
//!> Check if the position is a valid position in the vector
bool Valid(int pos) { return !(pos < 0 || pos >= Size()); };
u16 which;
u32 BufferBlockSize;
std::vector<u8 *> SoundBuffer;
std::vector<u32> BufferSize;
std::vector<bool> BufferReady;
u16 which;
u32 BufferBlockSize;
std::vector<u8 *> SoundBuffer;
std::vector<u32> BufferSize;
std::vector<bool> BufferReady;
};
#endif

157
source/music/File.cpp
View File

@ -3,143 +3,134 @@
CFile::CFile()
{
file_fd = NULL;
mem_file = NULL;
filesize = 0;
Pos = 0;
file_fd = NULL;
mem_file = NULL;
filesize = 0;
Pos = 0;
}
CFile::CFile(const char * filepath, const char * mode)
{
file_fd = NULL;
open(filepath, mode);
file_fd = NULL;
open(filepath, mode);
}
CFile::CFile(const u8 * mem, int size)
{
file_fd = NULL;
open(mem, size);
file_fd = NULL;
open(mem, size);
}
CFile::~CFile()
{
close();
close();
}
int CFile::open(const char * filepath, const char * mode)
{
close();
close();
file_fd = fopen(filepath, mode);
if(!file_fd)
return -1;
file_fd = fopen(filepath, mode);
if(!file_fd)
return -1;
fseek(file_fd, 0, SEEK_END);
filesize = ftell(file_fd);
rewind();
fseek(file_fd, 0, SEEK_END);
filesize = ftell(file_fd);
rewind();
return 0;
return 0;
}
int CFile::open(const u8 * mem, int size)
{
close();
close();
mem_file = mem;
filesize = size;
mem_file = mem;
filesize = size;
return 0;
return 0;
}
void CFile::close()
{
if(file_fd)
fclose(file_fd);
if(file_fd)
fclose(file_fd);
file_fd = NULL;
mem_file = NULL;
filesize = 0;
Pos = 0;
file_fd = NULL;
mem_file = NULL;
filesize = 0;
Pos = 0;
}
int CFile::read(u8 * ptr, size_t size)
{
if(file_fd)
{
int ret = fread(ptr, 1, size, file_fd);
if(ret > 0)
Pos += ret;
return ret;
}
if(file_fd)
{
int ret = fread(ptr, 1, size, file_fd);
if(ret > 0)
Pos += ret;
return ret;
}
int readsize = size;
int readsize = size;
if(readsize > (long int) filesize-Pos)
readsize = filesize-Pos;
if(readsize > (long int) filesize-Pos)
readsize = filesize-Pos;
if(readsize <= 0)
return readsize;
if(readsize <= 0)
return readsize;
if(mem_file != NULL)
{
memcpy(ptr, mem_file+Pos, readsize);
Pos += readsize;
return readsize;
}
if(mem_file != NULL)
{
memcpy(ptr, mem_file+Pos, readsize);
Pos += readsize;
return readsize;
}
return -1;
return -1;
}
int CFile::write(const u8 * ptr, size_t size)
{
/*
if(size < 0)
return size;
if(size < 0)
return size;
*/
if(file_fd)
{
int ret = fwrite(ptr, 1, size, file_fd);
if(ret > 0)
Pos += ret;
return ret;
}
if(file_fd)
{
int ret = fwrite(ptr, 1, size, file_fd);
if(ret > 0)
Pos += ret;
return ret;
}
return -1;
return -1;
}
int CFile::seek(long int offset, int origin)
{
int ret = 0;
if(origin == SEEK_SET)
{
Pos = offset;
}
else if(origin == SEEK_CUR)
{
Pos += offset;
}
else if(origin == SEEK_END)
{
Pos = filesize+offset;
}
if(Pos < 0)
{
Pos = 0;
return -1;
}
if(origin == SEEK_SET)
Pos = offset;
else if(origin == SEEK_CUR)
Pos += offset;
else if(origin == SEEK_END)
Pos = filesize+offset;
if(Pos < 0)
{
Pos = 0;
return -1;
}
if(file_fd)
ret = fseek(file_fd, Pos, SEEK_SET);
if(file_fd)
ret = fseek(file_fd, Pos, SEEK_SET);
if(mem_file != NULL)
{
if(Pos > (long int) filesize)
{
Pos = filesize;
return -1;
}
}
if(mem_file != NULL && Pos > (long int)filesize)
{
Pos = filesize;
return -1;
}
return ret;
}

38
source/music/File.hpp
View File

@ -6,25 +6,25 @@
class CFile
{
public:
CFile();
CFile(const char * filepath, const char * mode);
CFile(const u8 * memory, int memsize);
~CFile();
int open(const char * filepath, const char * mode);
int open(const u8 * memory, int memsize);
void close();
int read(u8 * ptr, size_t size);
int write(const u8 * ptr, size_t size);
int seek(long int offset, int origin);
long int tell() { return Pos; };
long int size() { return filesize; };
void rewind() { seek(0, SEEK_SET); };
protected:
FILE * file_fd;
const u8 * mem_file;
u64 filesize;
long int Pos;
public:
CFile();
CFile(const char * filepath, const char * mode);
CFile(const u8 * memory, int memsize);
~CFile();
int open(const char * filepath, const char * mode);
int open(const u8 * memory, int memsize);
void close();
int read(u8 * ptr, size_t size);
int write(const u8 * ptr, size_t size);
int seek(long int offset, int origin);
long int tell() { return Pos; };
long int size() { return filesize; };
void rewind() { seek(0, SEEK_SET); };
protected:
FILE * file_fd;
const u8 * mem_file;
u64 filesize;
long int Pos;
};
#endif

172
source/music/Mp3Decoder.cpp
View File

@ -33,94 +33,94 @@
#include "mem2.hpp"
Mp3Decoder::Mp3Decoder(const char * filepath)
: SoundDecoder(filepath)
: SoundDecoder(filepath)
{
SoundType = SOUND_MP3;
SoundType = SOUND_MP3;
ReadBuffer = NULL;
mad_timer_reset(&Timer);
mad_timer_reset(&Timer);
mad_stream_init(&Stream);
mad_frame_init(&Frame);
mad_synth_init(&Synth);
if(!file_fd)
return;
return;
OpenFile();
OpenFile();
}
Mp3Decoder::Mp3Decoder(const u8 * snd, int len)
: SoundDecoder(snd, len)
: SoundDecoder(snd, len)
{
SoundType = SOUND_MP3;
SoundType = SOUND_MP3;
ReadBuffer = NULL;
mad_timer_reset(&Timer);
mad_timer_reset(&Timer);
mad_stream_init(&Stream);
mad_frame_init(&Frame);
mad_synth_init(&Synth);
if(!file_fd)
return;
return;
OpenFile();
OpenFile();
}
Mp3Decoder::~Mp3Decoder()
{
ExitRequested = true;
while(Decoding)
usleep(100);
ExitRequested = true;
while(Decoding)
usleep(100);
mad_synth_finish(&Synth);
mad_frame_finish(&Frame);
mad_stream_finish(&Stream);
mad_synth_finish(&Synth);
mad_frame_finish(&Frame);
mad_stream_finish(&Stream);
MEM2_free(ReadBuffer);
MEM2_free(ReadBuffer);
}
void Mp3Decoder::OpenFile()
{
GuardPtr = NULL;
ReadBuffer = (u8 *)MEM2_alloc(SoundBlockSize * SoundBlocks);
if(!ReadBuffer)
{
if(file_fd)
delete file_fd;
file_fd = NULL;
return;
}
GuardPtr = NULL;
ReadBuffer = (u8 *)MEM2_alloc(SoundBlockSize * SoundBlocks);
if(!ReadBuffer)
{
if(file_fd)
delete file_fd;
file_fd = NULL;
return;
}
u8 dummybuff[4096];
int ret = Read((u8 *) &dummybuff, 4096, 0);
if(ret <= 0)
{
if(file_fd)
delete file_fd;
file_fd = NULL;
return;
}
u8 dummybuff[4096];
int ret = Read((u8 *) &dummybuff, 4096, 0);
if(ret <= 0)
{
if(file_fd)
delete file_fd;
file_fd = NULL;
return;
}
SampleRate = (u32) Frame.header.samplerate;
Format = ((MAD_NCHANNELS(&Frame.header) == 2) ? VOICE_STEREO_16BIT : VOICE_MONO_16BIT);
Rewind();
Decode();
SampleRate = (u32) Frame.header.samplerate;
Format = ((MAD_NCHANNELS(&Frame.header) == 2) ? VOICE_STEREO_16BIT : VOICE_MONO_16BIT);
Rewind();
Decode();
}
int Mp3Decoder::Rewind()
{
mad_synth_finish(&Synth);
mad_frame_finish(&Frame);
mad_stream_finish(&Stream);
mad_timer_reset(&Timer);
mad_synth_finish(&Synth);
mad_frame_finish(&Frame);
mad_stream_finish(&Stream);
mad_timer_reset(&Timer);
mad_stream_init(&Stream);
mad_frame_init(&Frame);
mad_synth_init(&Synth);
SynthPos = 0;
GuardPtr = NULL;
SynthPos = 0;
GuardPtr = NULL;
if(!file_fd)
return -1;
return -1;
return SoundDecoder::Rewind();
return SoundDecoder::Rewind();
}
static inline s16 FixedToShort(mad_fixed_t Fixed)
@ -137,38 +137,38 @@ static inline s16 FixedToShort(mad_fixed_t Fixed)
int Mp3Decoder::Read(u8 * buffer, int buffer_size, int)
{
if(!file_fd)
return -1;
if(!file_fd)
return -1;
if(Format == VOICE_STEREO_16BIT)
buffer_size &= ~0x0003;
else
buffer_size &= ~0x0001;
if(Format == VOICE_STEREO_16BIT)
buffer_size &= ~0x0003;
else
buffer_size &= ~0x0001;
u8 * write_pos = buffer;
u8 * write_end = buffer+buffer_size;
u8 * write_pos = buffer;
u8 * write_end = buffer+buffer_size;
while(1)
{
while(SynthPos < Synth.pcm.length)
{
if(write_pos >= write_end)
return write_pos-buffer;
while(1)
{
while(SynthPos < Synth.pcm.length)
{
if(write_pos >= write_end)
return write_pos-buffer;
*((s16 *) write_pos) = FixedToShort(Synth.pcm.samples[0][SynthPos]);
write_pos += 2;
*((s16 *)write_pos) = FixedToShort(Synth.pcm.samples[0][SynthPos]);
write_pos += 2;
if(MAD_NCHANNELS(&Frame.header) == 2)
{
*((s16 *) write_pos) = FixedToShort(Synth.pcm.samples[1][SynthPos]);
write_pos += 2;
}
SynthPos++;
}
if(MAD_NCHANNELS(&Frame.header) == 2)
{
*((s16 *)write_pos) = FixedToShort(Synth.pcm.samples[1][SynthPos]);
write_pos += 2;
}
SynthPos++;
}
if(Stream.buffer == NULL || Stream.error == MAD_ERROR_BUFLEN)
{
u8 * ReadStart = ReadBuffer;
if(Stream.buffer == NULL || Stream.error == MAD_ERROR_BUFLEN)
{
u8 *ReadStart = ReadBuffer;
int ReadSize = SoundBlockSize*SoundBlocks;
int Remaining = 0;
@ -181,14 +181,14 @@ int Mp3Decoder::Read(u8 * buffer, int buffer_size, int)
}
ReadSize = file_fd->read(ReadStart, ReadSize);
if(ReadSize <= 0)
{
if(ReadSize <= 0)
{
GuardPtr = ReadStart;
memset(GuardPtr, 0, MAD_BUFFER_GUARD);
ReadSize = MAD_BUFFER_GUARD;
}
}
CurPos += ReadSize;
CurPos += ReadSize;
mad_stream_buffer(&Stream, ReadBuffer, Remaining+ReadSize);
}
@ -196,20 +196,20 @@ int Mp3Decoder::Read(u8 * buffer, int buffer_size, int)
{
if(MAD_RECOVERABLE(Stream.error))
{
if(Stream.error != MAD_ERROR_LOSTSYNC || !GuardPtr)
continue;
if(Stream.error != MAD_ERROR_LOSTSYNC || !GuardPtr)
continue;
}
else
{
if(Stream.error != MAD_ERROR_BUFLEN)
return -1;
else if(Stream.error == MAD_ERROR_BUFLEN && GuardPtr)
return -1;
return -1;
else if(Stream.error == MAD_ERROR_BUFLEN && GuardPtr)
return -1;
}
}
mad_timer_add(&Timer,Frame.header.duration);
mad_synth_frame(&Synth,&Frame);
SynthPos = 0;
}
mad_timer_add(&Timer,Frame.header.duration);
mad_synth_frame(&Synth,&Frame);
SynthPos = 0;
}
}

38
source/music/Mp3Decoder.hpp
View File

@ -29,23 +29,23 @@
class Mp3Decoder : public SoundDecoder
{
public:
Mp3Decoder(const char * filepath);
Mp3Decoder(const u8 * sound, int len);
~Mp3Decoder();
int GetFormat() { return Format; };
int GetSampleRate() { return SampleRate; };
int Rewind();
int Read(u8 * buffer, int buffer_size, int pos);
protected:
void OpenFile();
struct mad_stream Stream;
struct mad_frame Frame;
struct mad_synth Synth;
mad_timer_t Timer;
u8 * GuardPtr;
u8 * ReadBuffer;
u8 Format;
u32 SampleRate;
u32 SynthPos;
public:
Mp3Decoder(const char * filepath);
Mp3Decoder(const u8 * sound, int len);
~Mp3Decoder();
int GetFormat() { return Format; };
int GetSampleRate() { return SampleRate; };
int Rewind();
int Read(u8 * buffer, int buffer_size, int pos);
protected:
void OpenFile();
struct mad_stream Stream;
struct mad_frame Frame;
struct mad_synth Synth;
mad_timer_t Timer;
u8 * GuardPtr;
u8 * ReadBuffer;
u8 Format;
u32 SampleRate;
u32 SynthPos;
};

98
source/music/OggDecoder.cpp
View File

@ -28,7 +28,7 @@
extern "C" int ogg_read(void * punt, int bytes, int blocks, int *f)
{
return ((CFile *) f)->read((u8 *) punt, bytes*blocks);
return ((CFile *) f)->read((u8 *) punt, bytes*blocks);
}
extern "C" int ogg_seek(int *f, ogg_int64_t offset, int mode)
@ -38,106 +38,106 @@ extern "C" int ogg_seek(int *f, ogg_int64_t offset, int mode)
extern "C" int ogg_close(int *f)
{
((CFile *) f)->close();
((CFile*)f)->close();
return 0;
}
extern "C" long ogg_tell(int *f)
{
return (long) ((CFile *) f)->tell();
return (long)((CFile *)f)->tell();
}
static ov_callbacks callbacks = {
(size_t (*)(void *, size_t, size_t, void *)) ogg_read,
(int (*)(void *, ogg_int64_t, int)) ogg_seek,
(int (*)(void *)) ogg_close,
(long (*)(void *)) ogg_tell
(size_t (*)(void *, size_t, size_t, void *)) ogg_read,
(int (*)(void *, ogg_int64_t, int)) ogg_seek,
(int (*)(void *)) ogg_close,
(long (*)(void *)) ogg_tell
};
OggDecoder::OggDecoder(const char * filepath)
: SoundDecoder(filepath)
: SoundDecoder(filepath)
{
SoundType = SOUND_OGG;
SoundType = SOUND_OGG;
if(!file_fd)
return;
if(!file_fd)
return;
OpenFile();
OpenFile();
}
OggDecoder::OggDecoder(const u8 * snd, int len)
: SoundDecoder(snd, len)
: SoundDecoder(snd, len)
{
SoundType = SOUND_OGG;
SoundType = SOUND_OGG;
if(!file_fd)
return;
if(!file_fd)
return;
OpenFile();
OpenFile();
}
OggDecoder::~OggDecoder()
{
ExitRequested = true;
while(Decoding)
usleep(100);
ExitRequested = true;
while(Decoding)
usleep(100);
if(file_fd)
ov_clear(&ogg_file);
if(file_fd)
ov_clear(&ogg_file);
}
void OggDecoder::OpenFile()
{
if (ov_open_callbacks(file_fd, &ogg_file, NULL, 0, callbacks) < 0)
{
delete file_fd;
file_fd = NULL;
return;
}
if(ov_open_callbacks(file_fd, &ogg_file, NULL, 0, callbacks) < 0)
{
delete file_fd;
file_fd = NULL;
return;
}
ogg_info = ov_info(&ogg_file, -1);
Decode();
ogg_info = ov_info(&ogg_file, -1);
Decode();
}
int OggDecoder::GetFormat()
{
if(!file_fd)
return VOICE_STEREO_16BIT;
if(!file_fd)
return VOICE_STEREO_16BIT;
return ((ogg_info->channels == 2) ? VOICE_STEREO_16BIT : VOICE_MONO_16BIT);
return ((ogg_info->channels == 2) ? VOICE_STEREO_16BIT : VOICE_MONO_16BIT);
}
int OggDecoder::GetSampleRate()
{
if(!file_fd)
return 0;
if(!file_fd)
return 0;
return (int) ogg_info->rate;
return (int) ogg_info->rate;
}
int OggDecoder::Rewind()
{
if(!file_fd)
return -1;
if(!file_fd)
return -1;
int ret = ov_time_seek(&ogg_file, 0);
CurPos = 0;
EndOfFile = false;
int ret = ov_time_seek(&ogg_file, 0);
CurPos = 0;
EndOfFile = false;
return ret;
return ret;
}
int OggDecoder::Read(u8 * buffer, int buffer_size, int)
{
if(!file_fd)
return -1;
if(!file_fd)
return -1;
int bitstream = 0;
int bitstream = 0;
int read = ov_read(&ogg_file, (char *) buffer, buffer_size, &bitstream);
int read = ov_read(&ogg_file, (char *) buffer, buffer_size, &bitstream);
if(read > 0)
CurPos += read;
if(read > 0)
CurPos += read;
return read;
return read;
}

24
source/music/OggDecoder.hpp
View File

@ -30,16 +30,16 @@
class OggDecoder : public SoundDecoder
{
public:
OggDecoder(const char * filepath);
OggDecoder(const u8 * snd, int len);
~OggDecoder();
int GetFormat();
int GetSampleRate();
int Rewind();
int Read(u8 * buffer, int buffer_size, int pos);
protected:
void OpenFile();
OggVorbis_File ogg_file;
vorbis_info *ogg_info;
public:
OggDecoder(const char * filepath);
OggDecoder(const u8 * snd, int len);
~OggDecoder();
int GetFormat();
int GetSampleRate();
int Rewind();
int Read(u8 * buffer, int buffer_size, int pos);
protected:
void OpenFile();
OggVorbis_File ogg_file;
vorbis_info *ogg_info;
};

150
source/music/SoundDecoder.cpp
View File

@ -32,123 +32,123 @@
SoundDecoder::SoundDecoder()
{
file_fd = NULL;
Init();
file_fd = NULL;
Init();
}
SoundDecoder::SoundDecoder(const char * filepath)
{
file_fd = new CFile(filepath, "rb");
Init();
file_fd = new CFile(filepath, "rb");
Init();
}
SoundDecoder::SoundDecoder(const u8 * buffer, int size)
{
file_fd = new CFile(buffer, size);
Init();
file_fd = new CFile(buffer, size);
Init();
}
SoundDecoder::~SoundDecoder()
{
ExitRequested = true;
while(Decoding)
usleep(100);
ExitRequested = true;
while(Decoding)
usleep(100);
if(file_fd)
delete file_fd;
file_fd = NULL;
if(file_fd)
delete file_fd;
file_fd = NULL;
}
void SoundDecoder::Init()
{
SoundType = SOUND_RAW;
SoundBlocks = 8; //Settings.SoundblockCount;
SoundBlockSize = 8092; //Settings.SoundblockSize;
CurPos = 0;
Loop = false;
EndOfFile = false;
Decoding = false;
ExitRequested = false;
SoundBuffer.SetBufferBlockSize(SoundBlockSize);
SoundBuffer.Resize(SoundBlocks);
SoundType = SOUND_RAW;
SoundBlocks = 8; //Settings.SoundblockCount;
SoundBlockSize = 8092; //Settings.SoundblockSize;
CurPos = 0;
Loop = false;
EndOfFile = false;
Decoding = false;
ExitRequested = false;
SoundBuffer.SetBufferBlockSize(SoundBlockSize);
SoundBuffer.Resize(SoundBlocks);
}
int SoundDecoder::Rewind()
{
CurPos = 0;
EndOfFile = false;
file_fd->rewind();
CurPos = 0;
EndOfFile = false;
file_fd->rewind();
return 0;
return 0;
}
int SoundDecoder::Read(u8 * buffer, int buffer_size, int)
{
int ret = file_fd->read(buffer, buffer_size);
CurPos += ret;
int ret = file_fd->read(buffer, buffer_size);
CurPos += ret;
return ret;
return ret;
}
void SoundDecoder::Decode()
{
if(!file_fd || ExitRequested || EndOfFile)
return;
if(!file_fd || ExitRequested || EndOfFile)
return;
u16 newWhich = SoundBuffer.Which();
u16 i = 0;
for (i = 0; i < SoundBuffer.Size()-2; i++)
{
if(!SoundBuffer.IsBufferReady(newWhich))
break;
u16 newWhich = SoundBuffer.Which();
u16 i = 0;
for(i = 0; i < SoundBuffer.Size()-2; i++)
{
if(!SoundBuffer.IsBufferReady(newWhich))
break;
newWhich = (newWhich+1) % SoundBuffer.Size();
}
newWhich = (newWhich+1) % SoundBuffer.Size();
}
if(i == SoundBuffer.Size()-2)
return;
if(i == SoundBuffer.Size()-2)
return;
Decoding = true;
Decoding = true;
int done = 0;
u8 * write_buf = SoundBuffer.GetBuffer(newWhich);
if(!write_buf)
{
ExitRequested = true;
Decoding = false;
return;
}
int done = 0;
u8 *write_buf = SoundBuffer.GetBuffer(newWhich);
if(!write_buf)
{
ExitRequested = true;
Decoding = false;
return;
}
while(done < SoundBlockSize)
{
int ret = Read(&write_buf[done], SoundBlockSize-done, Tell());
while(done < SoundBlockSize)
{
int ret = Read(&write_buf[done], SoundBlockSize-done, Tell());
if(ret <= 0)
{
if(Loop)
{
Rewind();
continue;
}
else
{
EndOfFile = true;
break;
}
}
if(ret <= 0)
{
if(Loop)
{
Rewind();
continue;
}
else
{
EndOfFile = true;
break;
}
}
done += ret;
}
done += ret;
}
if(done > 0)
{
SoundBuffer.SetBufferSize(newWhich, done);
SoundBuffer.SetBufferReady(newWhich, true);
}
if(done > 0)
{
SoundBuffer.SetBufferSize(newWhich, done);
SoundBuffer.SetBufferReady(newWhich, true);
}
if(!SoundBuffer.IsBufferReady((newWhich+1) % SoundBuffer.Size()))
Decode();
Decode();
Decoding = false;
Decoding = false;
}

50
source/music/SoundHandler.hpp
View File

@ -34,35 +34,35 @@
class SoundHandler
{
public:
static SoundHandler * Instance();
static void DestroyInstance();
public:
static SoundHandler * Instance();
static void DestroyInstance();
void AddDecoder(int voice, const char * filepath);
void AddDecoder(int voice, const u8 * snd, int len);
void RemoveDecoder(int voice);
void DestroyDecoder(SoundDecoder * decoder);
void AddDecoder(int voice, const char * filepath);
void AddDecoder(int voice, const u8 * snd, int len);
void RemoveDecoder(int voice);
void DestroyDecoder(SoundDecoder * decoder);
SoundDecoder * Decoder(int i) { return ((i < 0 || i >= MAX_DECODERS) ? NULL : DecoderList[i]); };
void ThreadSignal() { LWP_ThreadSignal(ThreadQueue); };
bool IsDecoding() { return Decoding; };
protected:
SoundHandler();
~SoundHandler();
static void * UpdateThread(void *arg);
void InternalSoundUpdates();
void ClearDecoderList();
SoundDecoder * GetSoundDecoder(const char * filepath);
SoundDecoder * GetSoundDecoder(const u8 * sound, int length);
SoundDecoder * Decoder(int i) { return ((i < 0 || i >= MAX_DECODERS) ? NULL : DecoderList[i]); };
void ThreadSignal() { LWP_ThreadSignal(ThreadQueue); };
bool IsDecoding() { return Decoding; };
protected:
SoundHandler();
~SoundHandler();
static void * UpdateThread(void *arg);
void InternalSoundUpdates();
void ClearDecoderList();
SoundDecoder * GetSoundDecoder(const char * filepath);
SoundDecoder * GetSoundDecoder(const u8 * sound, int length);
static SoundHandler * instance;
u8 * ThreadStack;
lwp_t SoundThread;
lwpq_t ThreadQueue;
bool Decoding;
bool ExitRequested;
static SoundHandler * instance;
u8 * ThreadStack;
lwp_t SoundThread;
lwpq_t ThreadQueue;
bool Decoding;
bool ExitRequested;
SoundDecoder * DecoderList[MAX_DECODERS];
SoundDecoder * DecoderList[MAX_DECODERS];
};
#endif

113
source/music/WavDecoder.cpp
View File

@ -27,46 +27,47 @@
#include "WavDecoder.hpp"
WavDecoder::WavDecoder(const char * filepath)
: SoundDecoder(filepath)
: SoundDecoder(filepath)
{
SoundType = SOUND_WAV;
SampleRate = 48000;
Format = VOICE_STEREO_16BIT;
SoundType = SOUND_WAV;
SampleRate = 48000;
Format = VOICE_STEREO_16BIT;
if(!file_fd)
return;
if(!file_fd)
return;
OpenFile();
OpenFile();
}
WavDecoder::WavDecoder(const u8 * snd, int len)
: SoundDecoder(snd, len)
: SoundDecoder(snd, len)
{
SoundType = SOUND_WAV;
SampleRate = 48000;
Format = VOICE_STEREO_16BIT;
SoundType = SOUND_WAV;
SampleRate = 48000;
Format = VOICE_STEREO_16BIT;
if(!file_fd)
return;
if(!file_fd)
return;
OpenFile();
OpenFile();
}
WavDecoder::~WavDecoder()
{
CloseFile();
}
void WavDecoder::OpenFile()
{
SWaveHdr Header;
SWaveFmtChunk FmtChunk;
memset(&Header, 0, sizeof(SWaveHdr));
memset(&FmtChunk, 0, sizeof(SWaveFmtChunk));
SWaveHdr Header;
SWaveFmtChunk FmtChunk;
memset(&Header, 0, sizeof(SWaveHdr));
memset(&FmtChunk, 0, sizeof(SWaveFmtChunk));
file_fd->read((u8 *) &Header, sizeof(SWaveHdr));
file_fd->read((u8 *) &FmtChunk, sizeof(SWaveFmtChunk));
file_fd->read((u8 *) &Header, sizeof(SWaveHdr));
file_fd->read((u8 *) &FmtChunk, sizeof(SWaveFmtChunk));
if (Header.magicRIFF != 'RIFF')
if(Header.magicRIFF != 'RIFF')
{
CloseFile();
return;
@ -82,10 +83,10 @@ void WavDecoder::OpenFile()
return;
}
DataOffset = sizeof(SWaveHdr)+le32(FmtChunk.size)+8;
file_fd->seek(DataOffset, SEEK_SET);
SWaveChunk DataChunk;
file_fd->read((u8 *) &DataChunk, sizeof(SWaveChunk));
DataOffset = sizeof(SWaveHdr)+le32(FmtChunk.size)+8;
file_fd->seek(DataOffset, SEEK_SET);
SWaveChunk DataChunk;
file_fd->read((u8 *) &DataChunk, sizeof(SWaveChunk));
while(DataChunk.magicDATA != 'data')
{
@ -99,56 +100,56 @@ void WavDecoder::OpenFile()
}
}
DataOffset += 8;
DataSize = le32(DataChunk.size);
Is16Bit = (le16(FmtChunk.bps) == 16);
SampleRate = le32(FmtChunk.freq);
DataOffset += 8;
DataSize = le32(DataChunk.size);
Is16Bit = (le16(FmtChunk.bps) == 16);
SampleRate = le32(FmtChunk.freq);
if (le16(FmtChunk.channels) == 1 && le16(FmtChunk.bps) == 8 && le16(FmtChunk.alignment) <= 1)
if(le16(FmtChunk.channels) == 1 && le16(FmtChunk.bps) == 8 && le16(FmtChunk.alignment) <= 1)
Format = VOICE_MONO_8BIT;
else if (le16(FmtChunk.channels) == 1 && le16(FmtChunk.bps) == 16 && le16(FmtChunk.alignment) <= 2)
else if(le16(FmtChunk.channels) == 1 && le16(FmtChunk.bps) == 16 && le16(FmtChunk.alignment) <= 2)
Format = VOICE_MONO_16BIT;
else if (le16(FmtChunk.channels) == 2 && le16(FmtChunk.bps) == 8 && le16(FmtChunk.alignment) <= 2)
else if(le16(FmtChunk.channels) == 2 && le16(FmtChunk.bps) == 8 && le16(FmtChunk.alignment) <= 2)
Format = VOICE_STEREO_8BIT;
else if (le16(FmtChunk.channels) == 2 && le16(FmtChunk.bps) == 16 && le16(FmtChunk.alignment) <= 4)
else if(le16(FmtChunk.channels) == 2 && le16(FmtChunk.bps) == 16 && le16(FmtChunk.alignment) <= 4)
Format = VOICE_STEREO_16BIT;
Decode();
Decode();
}
void WavDecoder::CloseFile()
{
if(file_fd)
delete file_fd;
if(file_fd)
delete file_fd;
file_fd = NULL;
file_fd = NULL;
}
int WavDecoder::Read(u8 * buffer, int buffer_size, int)
{
if(!file_fd)
return -1;
if(!file_fd)
return -1;
if(CurPos >= (int) DataSize)
return 0;
if(CurPos >= (int) DataSize)
return 0;
file_fd->seek(DataOffset+CurPos, SEEK_SET);
file_fd->seek(DataOffset+CurPos, SEEK_SET);
if(buffer_size > (int) DataSize-CurPos)
buffer_size = DataSize-CurPos;
if(buffer_size > (int) DataSize-CurPos)
buffer_size = DataSize-CurPos;
int read = file_fd->read(buffer, buffer_size);
if(read > 0)
{
if (Is16Bit)
{
read &= ~0x0001;
int read = file_fd->read(buffer, buffer_size);
if(read > 0)
{
if(Is16Bit)
{
read &= ~0x0001;
for (u32 i = 0; i < (u32) (read / sizeof (u16)); ++i)
((u16 *) buffer)[i] = le16(((u16 *) buffer)[i]);
}
CurPos += read;
}
for(u32 i = 0; i < (u32) (read / sizeof (u16)); ++i)
((u16 *)buffer)[i] = le16(((u16 *)buffer)[i]);
}
CurPos += read;
}
return read;
return read;
}

30
source/music/WavDecoder.hpp
View File

@ -55,21 +55,21 @@ typedef struct
class WavDecoder : public SoundDecoder
{
public:
WavDecoder(const char * filepath);
WavDecoder(const u8 * snd, int len);
~WavDecoder();
int GetFormat() { return Format; };
int GetSampleRate() { return SampleRate; };
int Read(u8 * buffer, int buffer_size, int pos);
protected:
void OpenFile();
void CloseFile();
u32 DataOffset;
u32 DataSize;
u32 SampleRate;
u8 Format;
bool Is16Bit;
public:
WavDecoder(const char * filepath);
WavDecoder(const u8 * snd, int len);
~WavDecoder();
int GetFormat() { return Format; };
int GetSampleRate() { return SampleRate; };
int Read(u8 * buffer, int buffer_size, int pos);
protected:
void OpenFile();
void CloseFile();
u32 DataOffset;
u32 DataSize;
u32 SampleRate;
u8 Format;
bool Is16Bit;
};
#endif

81
source/music/gui_sound.cpp
View File

@ -55,8 +55,9 @@ static inline int GetFirstUnusedVoice()
extern "C" void SoundCallback(s32 voice)
{
SoundDecoder * decoder = SoundHandler::Instance()->Decoder(voice);
if(!decoder) return;
SoundDecoder *decoder = SoundHandler::Instance()->Decoder(voice);
if(!decoder)
return;
if(decoder->IsBufferReady())
{
@ -98,11 +99,12 @@ GuiSound::GuiSound(GuiSound *g)
voice = -1;
Init();
if (g == NULL) return;
if (g->sound != NULL)
if(g == NULL)
return;
if(g->sound != NULL)
{
u8 * snd = (u8 *) malloc(g->length);
u8 *snd = (u8 *) malloc(g->length);
memcpy(snd, g->sound, g->length);
Load(snd, g->length, true);
}
@ -125,7 +127,7 @@ void GuiSound::Init()
voice = GetFirstUnusedVoice();
if(voice > 0)
VoiceUsed[voice] = true;
volume = 255;
SoundEffectLength = 0;
loop = false;
@ -161,7 +163,8 @@ bool GuiSound::Load(const char * filepath)
FILE * f = fopen(filepath, "rb");
if(!f)
{ gprintf("Failed to load file %s!!\n", filepath);
{
gprintf("Failed to load file %s!!\n", filepath);
return false;
}
@ -173,12 +176,14 @@ bool GuiSound::Load(const char * filepath)
gprintf("Loading %s using voice %d\n", filepath, voice);
SoundDecoder * decoder = SoundHandler::Instance()->Decoder(voice);
if(!decoder)
{ gprintf("No Decoder!!!\n");
{
gprintf("No Decoder!!!\n");
return false;
}
if(!decoder->IsBufferReady())
{ gprintf("Buffer not ready!!n");
{
gprintf("Buffer not ready!!\n");
SoundHandler::Instance()->RemoveDecoder(voice);
return false;
}
@ -194,29 +199,26 @@ bool GuiSound::Load(const u8 * snd, u32 len, bool isallocated)
FreeMemory();
this->voice = voice;
if(!snd) return false;
if(!snd)
return false;
if(!isallocated && *((u32 *) snd) == 'RIFF')
return LoadSoundEffect(snd, len);
if(*((u32 *) snd) == 'IMD5')
{
UncompressSoundbin(snd, len, isallocated);
}
else
{
sound = (u8 *) snd;
length = len;
allocated = isallocated;
}
SoundHandler::Instance()->AddDecoder(this->voice, sound, length);
SoundDecoder * decoder = SoundHandler::Instance()->Decoder(voice);
if(!decoder)
{
return false;
}
if(!decoder->IsBufferReady())
{
@ -274,10 +276,12 @@ void GuiSound::Play(int vol, bool restart)
return;
}
if((IsPlaying() && !restart) || voice < 0 || voice >= 16) return;
if((IsPlaying() && !restart) || voice < 0 || voice >= 16)
return;
SoundDecoder * decoder = SoundHandler::Instance()->Decoder(voice);
if(!decoder) return;
SoundDecoder *decoder = SoundHandler::Instance()->Decoder(voice);
if(!decoder)
return;
ASND_StopVoice(voice);
if(decoder->IsEOF())
@ -303,17 +307,18 @@ void GuiSound::Play()
void GuiSound::Stop()
{
volume = 0;
if (!IsPlaying() || voice < 0 || voice >= 16)
if(!IsPlaying() || voice < 0 || voice >= 16)
return;
ASND_StopVoice(voice);
SoundDecoder * decoder = SoundHandler::Instance()->Decoder(voice);
if(!decoder) return;
SoundDecoder *decoder = SoundHandler::Instance()->Decoder(voice);
if(!decoder)
return;
decoder->ClearBuffer();
Rewind();
SoundHandler::Instance()->ThreadSignal();
}
@ -361,24 +366,26 @@ void GuiSound::SetLoop(u8 l)
{
loop = l;
SoundDecoder * decoder = SoundHandler::Instance()->Decoder(voice);
if(!decoder) return;
SoundDecoder *decoder = SoundHandler::Instance()->Decoder(voice);
if(!decoder)
return;
decoder->SetLoop(l == 1);
}
void GuiSound::Rewind()
{
SoundDecoder * decoder = SoundHandler::Instance()->Decoder(voice);
if(!decoder) return;
SoundDecoder *decoder = SoundHandler::Instance()->Decoder(voice);
if(!decoder)
return;
decoder->Rewind();
}
struct _LZ77Info
{
u16 length : 4;
u16 offset : 12;
u16 length : 4;
u16 offset : 12;
} __attribute__((packed));
typedef struct _LZ77Info LZ77Info;
@ -397,24 +404,25 @@ u8 * uncompressLZ77(const u8 *inBuf, u32 inLength, u32 * size)
buffer = (u8 *)malloc(uncSize);
if (!buffer) return buffer;
if(!buffer)
return buffer;
u8 *bufCur = buffer;
u8 *bufEnd = buffer + uncSize;
while (bufCur < bufEnd && inBuf < inBufEnd)
while(bufCur < bufEnd && inBuf < inBufEnd)
{
u8 flags = *inBuf;
++inBuf;
int i = 0;
for (i = 0; i < 8 && bufCur < bufEnd && inBuf < inBufEnd; ++i)
for(i = 0; i < 8 && bufCur < bufEnd && inBuf < inBufEnd; ++i)
{
if ((flags & 0x80) != 0)
if((flags & 0x80) != 0)
{
const LZ77Info * info = (const LZ77Info *)inBuf;
inBuf += sizeof (LZ77Info);
int length = info->length + 3;
if (bufCur - info->offset - 1 < buffer || bufCur + length > bufEnd)
if(bufCur - info->offset - 1 < buffer || bufCur + length > bufEnd)
return buffer;
memcpy(bufCur, bufCur - info->offset - 1, length);
bufCur += length;
@ -439,7 +447,8 @@ void GuiSound::UncompressSoundbin(const u8 * snd, u32 len, bool isallocated)
const u8 * file = snd+32;
length = len-32;
if (length <= 0) return;
if(length <= 0)
return;
if(*((u32 *) file) == 'LZ77')
{

126
source/music/gui_sound.h
View File

@ -32,69 +32,69 @@
//!Sound conversion and playback. A wrapper for other sound libraries - ASND, libmad, ltremor, etc
class GuiSound
{
public:
//!Constructor
GuiSound();
//!Copy Constructor
GuiSound(GuiSound *g);
//!Constructor
//!\param sound Pointer to the sound data
//!\param filesize Length of sound data
GuiSound(std::string filepath, int voice = -1);
GuiSound(const u8 * snd, u32 len, std::string name, bool allocated = false, int voice = -1);
//!Stops sound and frees all memory/closes files
void FreeMemory();
//!Destructor
~GuiSound();
//!Load a file and replace the old one
bool Load(const char * filepath);
//!Load a file and replace the old one
bool Load(const u8 * snd, u32 len, bool allocated = true);
//!For quick playback of the internal soundeffects
bool LoadSoundEffect(const u8 * snd, u32 len);
//!Start sound playback
void Play();
//!Start sound playback
void Play(int vol, bool restart = false);
//!Stop sound playback
void Stop();
//!Pause sound playback
void Pause();
//!Resume sound playback
void Resume();
//!Checks if a sound is currently loaded
//!\return true if sound is loaded, false otherwise
bool IsLoaded() { return sound != NULL; };
//!Get the filepath for finding sounds which already have an instance.
//!\return the current instance's filepath
std::string GetName() { return filepath; };
//!Checks if the sound is currently playing
//!\return true if sound is playing, false otherwise
bool IsPlaying();
//!Rewind the music
void Rewind();
//!Get sound volume
//!\returns the current sound volume
int GetVolume();
//!Set sound volume
//!\param v Sound volume (0-100)
void SetVolume(int v);
//!\param l Loop (true to loop)
void SetLoop(u8 l);
private:
//!Initializes the GuiSound object by setting the default values
void Init();
//!Special sound case for sound.bin
void UncompressSoundbin(const u8 * snd, u32 len, bool isallocated);
protected:
std::string filepath;
u8 *sound; //!< Pointer to the sound data
u32 length; //!< Length of sound data
s32 voice; //!< Currently assigned ASND voice channel
int volume; //!< Sound volume (0-100)
u8 loop; //!< Loop sound playback
u32 SoundEffectLength; //!< Check if it is an app soundeffect for faster playback
bool allocated; //!< Is the file allocated or not
public:
//!Constructor
GuiSound();
//!Copy Constructor
GuiSound(GuiSound *g);
//!Constructor
//!\param sound Pointer to the sound data
//!\param filesize Length of sound data
GuiSound(std::string filepath, int voice = -1);
GuiSound(const u8 * snd, u32 len, std::string name, bool allocated = false, int voice = -1);
//!Stops sound and frees all memory/closes files
void FreeMemory();
//!Destructor
~GuiSound();
//!Load a file and replace the old one
bool Load(const char * filepath);
//!Load a file and replace the old one
bool Load(const u8 * snd, u32 len, bool allocated = true);
//!For quick playback of the internal soundeffects
bool LoadSoundEffect(const u8 * snd, u32 len);
//!Start sound playback
void Play();
//!Start sound playback
void Play(int vol, bool restart = false);
//!Stop sound playback
void Stop();
//!Pause sound playback
void Pause();
//!Resume sound playback
void Resume();
//!Checks if a sound is currently loaded
//!\return true if sound is loaded, false otherwise
bool IsLoaded() { return sound != NULL; };
//!Get the filepath for finding sounds which already have an instance.
//!\return the current instance's filepath
std::string GetName() { return filepath; };
//!Checks if the sound is currently playing
//!\return true if sound is playing, false otherwise
bool IsPlaying();
//!Rewind the music
void Rewind();
//!Get sound volume
//!\returns the current sound volume
int GetVolume();
//!Set sound volume
//!\param v Sound volume (0-100)
void SetVolume(int v);
//!\param l Loop (true to loop)
void SetLoop(u8 l);
private:
//!Initializes the GuiSound object by setting the default values
void Init();
//!Special sound case for sound.bin
void UncompressSoundbin(const u8 * snd, u32 len, bool isallocated);
protected:
std::string filepath;
u8 *sound; //!< Pointer to the sound data
u32 length; //!< Length of sound data
s32 voice; //!< Currently assigned ASND voice channel
int volume; //!< Sound volume (0-100)
u8 loop; //!< Loop sound playback
u32 SoundEffectLength; //!< Check if it is an app soundeffect for faster playback
bool allocated; //!< Is the file allocated or not
};
void soundInit(void);

156
source/unzip/ZipFile.cpp
View File

@ -39,140 +39,96 @@
ZipFile::ZipFile(const char *filepath)
{
File = unzOpen(filepath);
if (File) this->LoadList();
File = unzOpen(filepath);
if(File)
this->LoadList();
}
ZipFile::~ZipFile()
{
unzClose(File);
unzClose(File);
}
bool ZipFile::LoadList()
{
return true;
}
/*
bool ZipFile::FindFile(const char *file)
{
if (!File) return false;
char filename[MAXPATHLEN];
int ret = unzGoToFirstFile(File);
if (ret != UNZ_OK) return false;
do
{
if(unzGetCurrentFileInfo(File, &cur_file_info, filename, sizeof(filename), NULL, 0, NULL, 0) != UNZ_OK)
continue;
const char *realfilename = strrchr(filename, '/');
if(!realfilename || strlen(realfilename) == 0)
realfilename = filename;
if(strcasecmp(realfilename, file) == 0)
return true;
}
while(unzGoToNextFile(File) == UNZ_OK);
return false;
return true;
}
bool ZipFile::FindFilePart(const char *partfilename, std::string &realname)
{
if (!File) return false;
char filename[MAXPATHLEN];
int ret = unzGoToFirstFile(File);
if (ret != UNZ_OK) return false;
do
{
if(unzGetCurrentFileInfo(File, &cur_file_info, filename, sizeof(filename), NULL, 0, NULL, 0) != UNZ_OK)
continue;
if(strcasestr(filename, partfilename) != 0)
{
realname = filename;
return true;
}
}
while(unzGoToNextFile(File) == UNZ_OK);
return false;
}
*/
bool ZipFile::ExtractAll(const char *dest)
{
if (!File) return false;
if(!File)
return false;
bool Stop = false;
bool Stop = false;
u32 blocksize = 1024 * 50;
u8 *buffer = new u8[blocksize];
u32 blocksize = 1024 * 50;
u8 *buffer = new u8[blocksize];
if (!buffer) return false;
if(!buffer)
return false;
char writepath[MAXPATHLEN];
char filename[MAXPATHLEN];
memset(filename, 0, sizeof(filename));
char writepath[MAXPATHLEN];
char filename[MAXPATHLEN];
memset(filename, 0, sizeof(filename));
int ret = unzGoToFirstFile(File);
if (ret != UNZ_OK) Stop = true;
int ret = unzGoToFirstFile(File);
if(ret != UNZ_OK)
Stop = true;
while (!Stop)
{
if (unzGetCurrentFileInfo(File, &cur_file_info, filename, sizeof(filename), NULL, 0, NULL, 0) != UNZ_OK)
while(!Stop)
{
if(unzGetCurrentFileInfo(File, &cur_file_info, filename, sizeof(filename), NULL, 0, NULL, 0) != UNZ_OK)
Stop = true;
if (!Stop && filename[strlen(filename) - 1] != '/')
{
u32 uncompressed_size = cur_file_info.uncompressed_size;
if(!Stop && filename[strlen(filename) - 1] != '/')
{
u32 uncompressed_size = cur_file_info.uncompressed_size;
u32 done = 0;
char *pointer = NULL;
u32 done = 0;
char *pointer = NULL;
ret = unzOpenCurrentFile(File);
ret = unzOpenCurrentFile(File);
snprintf(writepath, sizeof(writepath), "%s/%s", dest, filename);
snprintf(writepath, sizeof(writepath), "%s/%s", dest, filename);
pointer = strrchr(writepath, '/');
int position = pointer - writepath + 2;
pointer = strrchr(writepath, '/');
int position = pointer - writepath + 2;
char temppath[strlen(writepath)];
snprintf(temppath, position, "%s", writepath);
char temppath[strlen(writepath)];
snprintf(temppath, position, "%s", writepath);
fsop_MakeFolder(temppath);
fsop_MakeFolder(temppath);
if (ret == UNZ_OK)
{
FILE *pfile = fopen(writepath, "wb");
if(ret == UNZ_OK)
{
FILE *pfile = fopen(writepath, "wb");
do
{
if (uncompressed_size - done < blocksize) blocksize = uncompressed_size - done;
do
{
if(uncompressed_size - done < blocksize)
blocksize = uncompressed_size - done;
ret = unzReadCurrentFile(File, buffer, blocksize);
ret = unzReadCurrentFile(File, buffer, blocksize);
if (ret == 0) break;
if(ret == 0)
break;
fwrite(buffer, 1, blocksize, pfile);
fwrite(buffer, 1, blocksize, pfile);
done += ret;
done += ret;
} while (done < uncompressed_size);
} while(done < uncompressed_size);
fclose(pfile);
unzCloseCurrentFile(File);
}
}
if (unzGoToNextFile(File) != UNZ_OK) Stop = true;
}
fclose(pfile);
unzCloseCurrentFile(File);
}
}
if(unzGoToNextFile(File) != UNZ_OK)
Stop = true;
}
delete[] buffer;
buffer = NULL;
delete[] buffer;
buffer = NULL;
return true;
return true;
}

34
source/unzip/ZipFile.h
View File

@ -32,27 +32,27 @@
typedef struct
{
u64 offset; // ZipFile offset
u64 length; // uncompressed file length in 64 bytes for sizes higher than 4GB
bool isdir; // 0 - file, 1 - directory
char filename[256]; // full filename
u64 offset; // ZipFile offset
u64 length; // uncompressed file length in 64 bytes for sizes higher than 4GB
bool isdir; // 0 - file, 1 - directory
char filename[256]; // full filename
} FileStructure;
class ZipFile
{
public:
//!Constructor
ZipFile(const char *filepath);
//!Destructor
~ZipFile();
//!Extract all files from a zip file to a directory
//!\param dest Destination path to where to extract
bool ExtractAll(const char *dest);
protected:
bool LoadList();
unzFile File;
unz_file_info cur_file_info;
FileStructure *FileList;
public:
//!Constructor
ZipFile(const char *filepath);
//!Destructor
~ZipFile();
//!Extract all files from a zip file to a directory
//!\param dest Destination path to where to extract
bool ExtractAll(const char *dest);
protected:
bool LoadList();
unzFile File;
unz_file_info cur_file_info;
FileStructure *FileList;
};
#endif