struct GPatch * gusload(char * filename)
{
struct GPatch * gp = (struct GPatch *)malloc(sizeof(struct GPatch));
rb->memset(gp, 0, sizeof(struct GPatch));
int file = rb->open(filename, O_RDONLY);
if(file < 0)
{
char message[50];
rb->snprintf(message, 50, "Error opening %s", filename);
rb->splash(HZ*2, message);
return NULL;
}
gp->header=readData(file, 12);
gp->gravisid=readData(file, 10);
gp->desc=readData(file, 60);
gp->inst=readChar(file);
gp->voc=readChar(file);
gp->chan=readChar(file);
gp->numWaveforms=readWord(file);
gp->vol=readWord(file);
gp->datSize=readDWord(file);
gp->res=readData(file, 36);
gp->instrID=readWord(file);
gp->instrName=readData(file,16);
gp->instrSize=readDWord(file);
gp->layers=readChar(file);
gp->instrRes=readData(file,40);
gp->layerDup=readChar(file);
gp->layerID=readChar(file);
gp->layerSize=readDWord(file);
gp->numWaves=readChar(file);
gp->layerRes=readData(file,40);
/* printf("\nFILE: %s", filename); */
/* printf("\nlayerSamples=%d", gp->numWaves); */
int a=0;
for(a=0; a<gp->numWaves; a++)
gp->waveforms[a] = loadWaveform(file);
/* printf("\nPrecomputing note table"); */
for(a=0; a<128; a++)
{
gp->noteTable[a] = selectWaveform(gp, a);
}
rb->close(file);
return gp;
}
struct GWaveform * loadWaveform(int file)
{
struct GWaveform * wav = &waveforms[curr_waveform++];
rb->memset(wav, 0, sizeof(struct GWaveform));
wav->name=readData(file, 7);
/* printf("\nWAVE NAME = [%s]", wav->name); */
wav->fractions=readChar(file);
wav->wavSize=readDWord(file);
wav->startLoop=readDWord(file);
wav->endLoop=readDWord(file);
wav->sampRate=readWord(file);
wav->lowFreq=readDWord(file);
wav->highFreq=readDWord(file);
wav->rootFreq=readDWord(file);
wav->tune=readWord(file);
wav->balance=readChar(file);
wav->envRate=readData(file, 6);
wav->envOffset=readData(file, 6);
wav->tremSweep=readChar(file);
wav->tremRate=readChar(file);
wav->tremDepth=readChar(file);
wav->vibSweep=readChar(file);
wav->vibRate=readChar(file);
wav->vibDepth=readChar(file);
wav->mode=readChar(file);
wav->scaleFreq=readWord(file);
wav->scaleFactor=readWord(file);
/* printf("\nScaleFreq = %d ScaleFactor = %d RootFreq = %d", wav->scaleFreq, wav->scaleFactor, wav->rootFreq); */
wav->res=readData(file, 36);
wav->data=readData(file, wav->wavSize);
wav->numSamples = wav->wavSize / 2;
wav->startLoop = wav->startLoop >> 1;
wav->endLoop = wav->endLoop >> 1;
unsigned int a=0;
/* half baked 8 bit conversion UNFINISHED*/
/*
if(wav->mode & 1 == 0) //Whoops, 8 bit
{
wav->numSamples = wav->wavSize;
//Allocate a block for the rest of it
//It should end up right after the previous one.
wav->wavSize = wav->wavSize * 2;
void * foo = allocate(wav->wavSize);
for(a=0; a<1000; a++)
printf("\n!!!!!!!!!!!!!!!!!!!!!!!!!!!");
for(a=wav->wavSize-1; a>0; a-=2)
{
}
// int b1=wf->data[s]+((wf->mode & 2) << 6);
// return b1<<8;
}
*/
#ifdef ROCKBOX_BIG_ENDIAN
/* Byte-swap if necessary. Gus files are little endian */
for(a=0; a<wav->numSamples; a++)
{
((uint16_t*) wav->data)[a] = letoh16(((uint16_t *) wav->data)[a]);
}
#endif
/* Convert unsigned to signed by subtracting 32768 */
if(wav->mode & 2)
{
for(a=0; a<wav->numSamples; a++)
((int16_t *) wav->data)[a] = ((uint16_t *) wav->data)[a] - 32768;
}
return wav;
}
//--------------------------------------------------------
// open a BMP file to be read
BOOL mgBMPRead::open(
const char* fileName) // name of file to open
{
// if file name exists
m_inFile = mgOSFileOpen(fileName, "rb");
if (m_inFile == NULL)
throw new mgErrorMsg("imgBadOpen", "", "");
BitmapFileHeader fileHeader;
fileHeader.bfType = readWord(m_inFile);
fileHeader.bfSize = readDWord(m_inFile);
fileHeader.bfReserved1 = readWord(m_inFile);
fileHeader.bfReserved2 = readWord(m_inFile);
fileHeader.bfOffBits = readDWord(m_inFile);
if (fileHeader.bfType != 0x4D42)
throw new mgErrorMsg("imgNotBmp", "filename", "%s", (const char*) fileName);
BitmapInfoHeader infoHeader;
infoHeader.biSize = readDWord(m_inFile);
infoHeader.biWidth = (int) readDWord(m_inFile);
infoHeader.biHeight = (int) readDWord(m_inFile);
infoHeader.biPlanes = readWord(m_inFile);
infoHeader.biBitCount = readWord(m_inFile);
infoHeader.biCompression = readDWord(m_inFile);
infoHeader.biSizeImage = readDWord(m_inFile);
// handle uncompressed 24 and 32 bit images
if (infoHeader.biCompression != BITMAP_COMPRESSION_RGB ||
(infoHeader.biBitCount != 24 && infoHeader.biBitCount != 32))
throw new mgErrorMsg("imgBMPDepth", "filename", "%s", (const char*) fileName);
m_width = infoHeader.biWidth;
m_height = abs(infoHeader.biHeight);
m_bitCount = infoHeader.biBitCount;
m_reverse = infoHeader.biHeight > 0;
// read the image data
DWORD imageSize = m_height * m_width * m_bitCount/8;
if (infoHeader.biSizeImage != 0 && infoHeader.biSizeImage != imageSize)
throw new mgErrorMsg("imgBmpSize", "filename,calcSize,declSize", "%s,%d,%d",
(const char*) fileName, imageSize, infoHeader.biSizeImage);
m_data = new BYTE[imageSize];
fseek(m_inFile, fileHeader.bfOffBits, SEEK_SET);
size_t bytesRead = fread(m_data, 1, imageSize, m_inFile);
if (bytesRead != imageSize)
throw new mgErrorMsg("imgBmpRead", "filename,size", "%s,%d", (const char*) fileName, imageSize);
fclose(m_inFile);
m_inFile = NULL;
m_RGBAline = new BYTE[m_width * 4];
m_y = 0;
m_lineLen = m_width * m_bitCount/8;
m_lineLen = 4*((m_lineLen+3)/4);
if (!m_writer->outputStart(m_width, m_height))
return false;
return true;
}
void parseBmp (char *fileName, BMP *bmp) {
int i, j, k;
char b, g, r;
int pixels, rowOffset, offset;
short int fh;
fh = openFile(fileName);
//Parse BMP header
bmp->header.type = readWord(fh);
bmp->header.size = readDWord(fh);
bmp->header.reserved1 = readWord(fh);
bmp->header.reserved2 = readWord(fh);
bmp->header.offset = readDWord(fh);
//Parse BMP info header
bmp->infoheader.size = readDWord(fh);
bmp->infoheader.width = readDWord(fh);
bmp->infoheader.height = readDWord(fh);
bmp->infoheader.planes = readWord(fh);
bmp->infoheader.bits = readWord(fh);
bmp->infoheader.compression = readDWord(fh);
bmp->infoheader.imagesize = readDWord(fh);
bmp->infoheader.xresolution = readDWord(fh);
bmp->infoheader.yresolution = readDWord(fh);
bmp->infoheader.ncolors = readDWord(fh);
bmp->infoheader.importantcolors = readDWord(fh);
pixels = bmp->infoheader.width * bmp->infoheader.height;
bmp->color = malloc(BYTES_PER_PIXEL * pixels);
for(i = 0; i < bmp->infoheader.height; i++) {
rowOffset = i*bmp->infoheader.width;
for(j = 0; j < bmp->infoheader.width; j++ ){
offset = pixels - rowOffset - j - 1;
/*
*RGB values are stored in reverse (BGR) in the .bmp file
*BMP is saved as 24 bit RGB, pixel buffer dma takes 16 bit RGB values
*/
b = (readByte(fh) & 0xF1) >> 3;
g = (readByte(fh) & 0xFC) >> 2;
r = (readByte(fh) & 0xF1) >> 3;
//Filter out the pink pixels
if(b == 0x1E && g == 0 && r == 0x1E) {
bmp->color[offset] = 0x0;
} else {
bmp->color[offset] = (r << 11) | (g << 5) | b;
}
}
//Each pixel row is padded so the amount of pixels is a multiple of 4
if((BYTES_PER_PIXEL*bmp->infoheader.width) % 4 != 0) {
for (k = 0; k < (4 - ((BYTES_PER_PIXEL*bmp->infoheader.width) % 4)); k++) {
readByte(fh);
}
}
}
closeFile(fh);
}
//purpose: parse a BMP file and package in a BMP structure
void parseBmp (char *fileName, BMP *bmp) {
int i, j, k;
char b, g, r;
int pixels, rowOffset, offset;
short int fh;
fh = openFile(fileName);
bmp->header.type = readWord(fh);
bmp->header.size = readDWord(fh);
bmp->header.reserved1 = readWord(fh);
bmp->header.reserved2 = readWord(fh);
bmp->header.offset = readDWord(fh);
bmp->infoheader.size = readDWord(fh);
bmp->infoheader.width = readDWord(fh);
bmp->infoheader.height = readDWord(fh);
bmp->infoheader.planes = readWord(fh);
bmp->infoheader.bits = readWord(fh);
bmp->infoheader.compression = readDWord(fh);
bmp->infoheader.imagesize = readDWord(fh);
bmp->infoheader.xresolution = readDWord(fh);
bmp->infoheader.yresolution = readDWord(fh);
bmp->infoheader.ncolors = readDWord(fh);
bmp->infoheader.importantcolors = readDWord(fh);
pixels = bmp->infoheader.width * bmp->infoheader.height;
bmp->color = malloc(BYTES_PER_PIXEL * pixels);
for(i = 0; i < bmp->infoheader.height; i++) {
rowOffset = i*bmp->infoheader.width;
for(j = 0; j < bmp->infoheader.width; j++ ){
offset = pixels - rowOffset - j - 1;
b = (readByte(fh) & 0xF1) >> 3;
g = (readByte(fh) & 0xFC) >> 2;
r = (readByte(fh) & 0xF1) >> 3;
//Filter out the pink pixels
if(b == 0x1E && g == 0 && r == 0x1E) {
bmp->color[offset] = 0x0;
} else {
bmp->color[offset] = (r << 11) | (g << 5) | b;
}
}
if((BYTES_PER_PIXEL*bmp->infoheader.width) % 4 != 0) {
for (k = 0; k < (4 - ((BYTES_PER_PIXEL*bmp->infoheader.width) % 4)); k++) {
readByte(fh);
}
}
}
closeFile(fh);
}
void MergeFile::copyFormTo( MergeFile& out, dr_section sect,
uint_32& off, uint_32 form, uint_8 addrSize )
//-----------------------------------------------------------------------
{
uint_32 num;
char * buffer;
uint_32 bufLen;
uint_8 buf8[ 8 ];
switch( form ) {
/* do all simple numeric forms */
case DW_FORM_addr:
case DW_FORM_flag:
case DW_FORM_data1:
case DW_FORM_ref1:
case DW_FORM_data2:
case DW_FORM_ref2:
case DW_FORM_data4:
case DW_FORM_ref4:
case DW_FORM_sdata:
case DW_FORM_udata:
case DW_FORM_ref_udata:
case DW_FORM_ref_addr:
num = readForm( sect, off, form, addrSize );
out.writeForm( form, num, addrSize );
break;
case DW_FORM_block1:
bufLen = readByte( sect, off );
out.writeByte( (uint_8) bufLen );
if( bufLen ) {
buffer = new char[ bufLen ];
readBlock( sect, off, buffer, bufLen );
out.writeBlock( buffer, bufLen );
delete [] buffer;
}
break;
case DW_FORM_block2:
bufLen = readWord( sect, off );
out.writeWord( (uint_16) bufLen );
if( bufLen ) {
buffer = new char[ bufLen ];
readBlock( sect, off, buffer, bufLen );
out.writeBlock( buffer, bufLen );
delete [] buffer;
}
break;
case DW_FORM_block4:
bufLen = readDWord( sect, off );
out.writeDWord( bufLen );
if( bufLen ) {
buffer = new char[ bufLen ];
readBlock( sect, off, buffer, bufLen );
out.writeBlock( buffer, bufLen );
delete [] buffer;
}
break;
case DW_FORM_block:
bufLen = readULEB128( sect, off );
if( bufLen ) {
buffer = new char[ bufLen ];
readBlock( sect, off, buffer, bufLen );
out.writeBlock( buffer, bufLen );
delete [] buffer;
}
break;
case DW_FORM_data8:
readBlock( sect, off, buf8, 8 );
out.writeBlock( buf8, 8 );
break;
case DW_FORM_string:
do {
num = readByte( sect, off );
out.writeByte( (uint_8) num );
} while( num != 0 );
break;
case DW_FORM_indirect:
num = readULEB128( sect, off );
out.writeULEB128( num );
copyFormTo( out, sect, off, num, addrSize );
break;
default:
#if DEBUG
printf( "ACK -- form %#x\n", form );
#endif
InternalAssert( 0 );
}
}
void MergeFile::skipForm( dr_section sect, uint_32& off, uint_32 form,
uint_8 addrSize )
//---------------------------------------------------------------------
{
uint_32 value;
switch( form ) {
case DW_FORM_addr:
off += addrSize;
break;
case DW_FORM_block1:
off += readByte( sect, off );
break;
case DW_FORM_block2:
off += readWord( sect, off );
break;
case DW_FORM_block4:
off += readDWord( sect, off );
break;
case DW_FORM_block:
value = readULEB128( sect, off );
off += value;
break;
case DW_FORM_flag:
case DW_FORM_data1:
case DW_FORM_ref1:
off += 1;
break;
case DW_FORM_data2:
case DW_FORM_ref2:
off += 2;
break;
case DW_FORM_ref_addr: // NYI: non-standard behaviour for form_ref
case DW_FORM_data4:
case DW_FORM_ref4:
off += 4;
break;
case DW_FORM_data8:
off += 8;
break;
case DW_FORM_sdata:
readSLEB128( sect, off );
break;
case DW_FORM_udata:
case DW_FORM_ref_udata:
readULEB128( sect, off );
break;
case DW_FORM_string:
while( readByte( sect, off ) != 0 );
break;
case DW_FORM_indirect:
value = readULEB128( sect, off );
skipForm( sect, off, value, addrSize );
break;
default:
#if DEBUG
printf( "ACK -- form %#x\n", form );
#endif
InternalAssert( 0 );
}
}
