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

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");

27
source/channel/nand.cpp
View File

@ -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;
@ -862,9 +869,7 @@ s32 Nand::DoNandDump(const char *source, const char *dest, dump_callback_t i_dum
__DumpNandFile(source, ndest);
}
else
{
__DumpNandFolder(source, dest);
}
return 0;
}

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
}

1358
source/gui/GameTDB.cpp
View File

File diff suppressed because it is too large Load Diff

25
source/gui/video.cpp
View File

@ -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/loader/apploader.c
View File

@ -22,7 +22,7 @@ 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
@ -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)

6
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);

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

71
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 == NULL)
return;
if (g->sound != NULL)
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);
}
@ -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,15 +199,14 @@ 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;
@ -214,9 +218,7 @@ bool GuiSound::Load(const u8 * snd, u32 len, bool isallocated)
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,13 +307,14 @@ 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();
@ -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