result WavStream::loadFileToMem(File *aFile)
{
delete[] mFilename;
delete mMemFile;
mStreamFile = 0;
mMemFile = 0;
mFilename = 0;
mSampleCount = 0;
MemoryFile *mf = new MemoryFile();
int res = mf->openFileToMem(aFile);
if (res != SO_NO_ERROR)
{
delete mf;
return res;
}
res = parse(mf);
if (res != SO_NO_ERROR)
{
delete mf;
return res;
}
mMemFile = mf;
return res;
}
//-------------------------------------------------------------------------
bool ReadChunkData(const IwRIFFChunkHeader& header, MemoryFile &memfp, std::vector<short>&data, int samplebits)
{
size_t len = data.size();
if(samplebits == 16)
{
data.resize(len+header.length/2);
if(memfp.Read(&data[len], header.length) != header.length)
{
return false;
}
}
else
{
std::vector<char>bit8data(header.length);
if(memfp.Read(&bit8data[0], header.length) != header.length)
{
return false;
}
data.resize(len+header.length);
for(int i=0; i<header.length; i++)
{
data[len+i] = bit8data[i]*256;
}
}
return true;
}
result WavStream::loadMem(unsigned char *aData, unsigned int aDataLen, bool aCopy, bool aTakeOwnership)
{
delete[] mFilename;
delete mMemFile;
mStreamFile = 0;
mMemFile = 0;
mFilename = 0;
mSampleCount = 0;
if (aData == NULL || aDataLen == 0)
return INVALID_PARAMETER;
MemoryFile *mf = new MemoryFile();
int res = mf->openMem(aData, aDataLen, aCopy, aTakeOwnership);
if (res != SO_NO_ERROR)
{
delete mf;
return res;
}
res = parse(mf);
if (res != SO_NO_ERROR)
{
delete mf;
return res;
}
mMemFile = mf;
return 0;
}
/*---------------------------------------------------------------------*//**
バッファから作成
**//*---------------------------------------------------------------------*/
bool Wave::create(const char* fbuf, int size, u16 cflag)
{
MemoryFile* file = new MemoryFile(fbuf, size);
if(!file->isOpened()) { return false; }
return createFromFile(file, cflag);
}
result Sfxr::loadParamsMem(unsigned char *aMem, unsigned int aLength, bool aCopy, bool aTakeOwnership)
{
MemoryFile mf;
int res = mf.openMem(aMem, aLength, aCopy, aTakeOwnership);
if (res != SO_NO_ERROR)
return res;
return loadParamsFile(&mf);
}
result Wav::loadMem(unsigned char *aMem, unsigned int aLength, bool aCopy, bool aTakeOwnership)
{
if (aMem == NULL || aLength == 0)
return INVALID_PARAMETER;
MemoryFile dr;
dr.openMem(aMem, aLength, aCopy, aTakeOwnership);
return testAndLoadFile(&dr);
}
//
// Reads data from the input file
//
static
void pngReadFunc(png_struct * pngPtr, png_byte * data, png_size_t bytes)
{
MemoryFile * file = (MemoryFile *)pngPtr->io_ptr;
Q_ASSERT(file);
int64 result = file->read((char *)data, bytes);
if (unlikely(result != (int64)bytes))
png_error(pngPtr, "I/O error");
}
WavStreamInstance::WavStreamInstance(WavStream *aParent)
{
mParent = aParent;
mOffset = 0;
mOgg = 0;
mFile = 0;
if (aParent->mMemFile)
{
MemoryFile *mf = new MemoryFile();
mFile = mf;
mf->openMem(aParent->mMemFile->getMemPtr(), aParent->mMemFile->length(), false, false);
}
else
if (aParent->mFilename)
{
DiskFile *df = new DiskFile;
mFile = df;
df->open(aParent->mFilename);
}
else
if (aParent->mStreamFile)
{
mFile = aParent->mStreamFile;
mFile->seek(0); // stb_vorbis assumes file offset to be at start of ogg
}
else
{
return;
}
if (mFile)
{
if (mParent->mOgg)
{
int e;
mOgg = stb_vorbis_open_file((Soloud_Filehack *)mFile, 0, &e, 0);
if (!mOgg)
{
if (mFile != mParent->mStreamFile)
delete mFile;
mFile = 0;
}
mOggFrameSize = 0;
mOggFrameOffset = 0;
mOggOutputs = 0;
}
else
{
mFile->seek(aParent->mDataOffset);
}
}
}
result Wav::loadogg(File *aReader)
{
aReader->seek(0);
MemoryFile memoryFile;
memoryFile.openFileToMem(aReader);
int e = 0;
stb_vorbis *vorbis = 0;
vorbis = stb_vorbis_open_memory(memoryFile.getMemPtr(), memoryFile.length(), &e, 0);
if (0 == vorbis)
{
return FILE_LOAD_FAILED;
}
stb_vorbis_info info = stb_vorbis_get_info(vorbis);
mBaseSamplerate = (float)info.sample_rate;
int samples = stb_vorbis_stream_length_in_samples(vorbis);
int readchannels = 1;
if (info.channels > 1)
{
readchannels = 2;
mChannels = 2;
}
mData = new float[samples * readchannels];
mSampleCount = samples;
samples = 0;
while(1)
{
float **outputs;
int n = stb_vorbis_get_frame_float(vorbis, NULL, &outputs);
if (n == 0)
{
break;
}
if (readchannels == 1)
{
memcpy(mData + samples, outputs[0],sizeof(float) * n);
}
else
{
memcpy(mData + samples, outputs[0],sizeof(float) * n);
memcpy(mData + samples + mSampleCount, outputs[1],sizeof(float) * n);
}
samples += n;
}
stb_vorbis_close(vorbis);
return 0;
}
result Wav::loadFile(File *aFile)
{
if (!aFile)
return INVALID_PARAMETER;
stop();
MemoryFile mr;
result res = mr.openFileToMem(aFile);
if (res != SO_NO_ERROR)
{
return res;
}
return testAndLoadFile(&mr);
}
bool ReadChunkFormat(const IwRIFFChunkHeader& header, MemoryFile &memfp, int &herz, int &samplebits, int &channels)
{
IwWAVEFormatChunkADPCM format;
// Read data from file
if ((header.length < sizeof(IwWAVEFormatChunk)) || (memfp.Read(&format, sizeof(IwWAVEFormatChunkADPCM)) != sizeof(IwWAVEFormatChunkADPCM)))
{
assert(0);
return false;
}
assert(format.channels==1 && format.bitsPerSample==16 && format.samplesPerSec==22050);
if((format.channels!=1&&format.channels!=2) || format.formatTag!=WAVE_FORMAT_PCM)
{
return false;
}
if(format.bitsPerSample != 16 && format.bitsPerSample!=8)
{
return false;
}
samplebits = format.bitsPerSample;
herz = format.samplesPerSec;
channels = format.channels;
return true;
}
//-------------------------------------------------------------------------
bool ReadChunkFact(const IwRIFFChunkHeader& header, MemoryFile &memfp, int &sampleCount)
{
if (memfp.Read(&sampleCount, sizeof(int)) != sizeof(int))
{
return false;
}
return true;
}
//
// Constructor
//
PNGReader::PNGReader(const QString & ext, MemoryFile & file)
: ImageFormatReaderHelper(file)
{
if (file.size() < 8)
return;
byte buf[8];
if (!tryReadFile(buf, sizeof(buf)))
return;
if (png_check_sig((png_bytep)buf, sizeof(buf)))
m_IsValid = true;
}
IFile * AnsiFileSystem::CreateFile(const char8 * filename, uint32 attributes)
{
// find file in attached archives
for (List<ResourceArchiveItem>::iterator ai = resourceArchiveList.begin();
ai != resourceArchiveList.end(); ++ai)
{
ResourceArchiveItem & item = *ai;
String filenamecpp = filename;
String::size_type pos = filenamecpp.find(item.attachPath);
if (pos == 0)
{
String relfilename = filenamecpp.substr(item.attachPath.length());
uint32 size = item.archive->LoadResource(relfilename, 0);
if ( size == -1 )
{
return 0;
}
MemoryFile * file = new MemoryFile(size, attributes);
if (file)
{
item.archive->LoadResource(relfilename, file->GetPointer());
return file;
}
SafeRelease(file);
return 0;
}
}
AnsiFile * file = new AnsiFile();
if (file->Create(filename, attributes))return file;
SafeRelease(file);
return 0;
}
void do_loadxmltobinary(FILE * f, File * outf, BoxcacheData * bd)
{
TiXmlDocument doc;
TiXmlNode *pChild;
if (!doc.LoadFile(f))
{
return;
}
for (pChild = doc.FirstChild(); pChild != 0; pChild = pChild->NextSibling())
{
if (pChild->Type() == TiXmlNode::ELEMENT)
{
if (stricmp(pChild->Value(), "Atanua") == 0)
{
outf->writeint(0x02617441); // 'Ata' + 2
int chipcount = 0;
((TiXmlElement*)pChild)->QueryIntAttribute("ChipCount", &chipcount);
outf->writeint(chipcount);
int wirecount = 0;
((TiXmlElement*)pChild)->QueryIntAttribute("WireCount", &wirecount);
outf->writeint(wirecount);
int scale = 24;
((TiXmlElement*)pChild)->QueryIntAttribute("scale", &scale);
TiXmlNode *part;
for (part = pChild->FirstChild(); part != 0; part = part->NextSibling())
{
if (part->Type() == TiXmlNode::ELEMENT)
{
if (stricmp(part->Value(), "Chip")==0)
{
// we now have the chip id string, but we need to find
// the copy which is always in memory so that we get a
// sane pointer to it for gChipName.
const char *chipname = NULL;
const char *temp = ((TiXmlElement*)part)->Attribute("Name");
if (temp)
{
// boxes are... special.
int i = strlen(temp);
if (i > 7 && stricmp(temp+i-7,".atanua") == 0)
{
chipname = mystrdup(temp);
FILE * f = openfileinsamedir(temp);
if (!f)
{
char temp[1024];
sprintf(temp,"Boxed atanua file '%s' not found.\nTry to continue loading?\n\n(it will show up as box with no pins)", chipname);
if (okcancel(temp) == 0)
{
delete[] chipname;
build_nets();
return;
}
}
else
{
fclose(f);
}
}
else
if (stricmp(temp, "Connection Pin") == 0)
{
// Connection pin is a special case, as you can't create it
// in a "normal" way
chipname = "Connection Pin";
}
else
{
int j, k;
for (k = 0; chipname == NULL && k < 5; k++)
{
for (j = 0; chipname == NULL && j < (signed)gAvailableChip[k].size(); j++)
{
if (gAvailableChip[k][j])
{
if (stricmp(temp, gAvailableChip[k][j]) == 0)
{
chipname = gAvailableChip[k][j];
}
}
}
}
}
if (chipname != NULL)
{
int x, y, key, angle;
x = y = key = angle = 0;
((TiXmlElement*)part)->QueryIntAttribute("xpos", &x);
((TiXmlElement*)part)->QueryIntAttribute("ypos", &y);
((TiXmlElement*)part)->QueryIntAttribute("key", &key);
((TiXmlElement*)part)->QueryIntAttribute("rot", &angle);
int AngleIn90DegreeSteps = angle;
float X = (float)x / (1 << scale);
float Y = (float)y / (1 << scale);
int len = strlen(chipname);
outf->writeword(len);
outf->writechars(chipname, len);
outf->writeint((int)floor((1 << 16) * X));
outf->writeint((int)floor((1 << 16) * Y));
outf->writeint(AngleIn90DegreeSteps);
outf->writeint(0);
TiXmlNode *text;
for (text = part->FirstChild(); text != 0; text = text->NextSibling())
{
if (text->Type() == TiXmlNode::TEXT)
{
const char *v = text->Value();
int wholebyte = 0;
int data = 0;
MemoryFile mf;
while (*v)
{
if (*v >= '0' && *v <= '9')
{
data <<= 4;
data |= *v - '0';
wholebyte++;
}
else
if (*v >= 'A' && *v <= 'F')
{
data <<= 4;
data |= *v - 'A' + 10;
wholebyte++;
}
else
if (*v >= 'a' && *v <= 'f')
{
data <<= 4;
data |= *v - 'a' + 10;
wholebyte++;
}
// ignore other values, including whitespace
if (wholebyte == 2)
{
mf.writebyte(data);
data = 0;
wholebyte = 0;
}
v++;
}
if (stricmp(chipname, "External Pin") == 0)
{
if (bd)
{
mf.seek(0);
mf.readint();
int l = mf.readint();
char *temp = new char[l+1];
memset(temp,0,l+1);
mf.readchars(temp, l);
bd->mTooltips.push_back(temp);
}
}
int i;
for (i = 0; i < (signed)mf.mData.size(); i++)
outf->writebyte(mf.mData[i]);
if (wholebyte != 0)
{
char temp[1024];
sprintf(temp,"Decoding chip-specific data while loading '%s' failed.\nTry to continue loading?", chipname);
if (okcancel(temp) == 0)
{
return;
}
}
}
}
}
else
{
char mtemp[1024];
sprintf(mtemp,"Chip called '%s' requested by savefile but it is\n"
"not supported by this version, or a plugin is missing.\n"
"\n"
"Try to continue loading?", temp);
if (okcancel(mtemp) == 0)
{
build_nets();
return;
}
}
}
}
if (stricmp(part->Value(), "Wire")==0)
{
int chip1, pin1, chip2, pin2;
((TiXmlElement*)part)->QueryIntAttribute("chip1", &chip1);
((TiXmlElement*)part)->QueryIntAttribute("chip2", &chip2);
((TiXmlElement*)part)->QueryIntAttribute("pad1", &pin1);
((TiXmlElement*)part)->QueryIntAttribute("pad2", &pin2);
outf->writeint((chip1<<16) | pin1);
outf->writeint((chip2<<16) | pin2);
outf->writeint(0);
}
}
}
}
}
}
}
//
// tries to open a file from the given framenumber and reads the content into the vector of particles
//
void loadParticles( std::string fileName, std::vector<Particle> &particles )
{
// if the file is a zip file, then we assume that the zip contains the pcl file among other things
if( util::getExtension( fileName ) == ".zip" )
{
// unzip the pcl file into the memory
std::string title = dk::util::PathInfo::getTitle( fileName );
// open the zipfile
HZIP zip = OpenZip( util::toWString( fileName ).c_str(), 0 );
// set base directory for unzipping operations
SetUnzipBaseDir( zip, _T("\\") );
// zip entry for the pcl file
ZIPENTRY ze;
int entryIndex = -1;
// look for the pcl file
FindZipItem( zip, util::toWString( std::string( title ) + ".pcl" ).c_str(), false, &entryIndex, &ze );
if( entryIndex == -1 )
{
printf( "error : zip file doesnt contain %s\n", util::setExtension( fileName, ".pcl" ).c_str() );
// stop everything
return;
}
// prepare memory
MemoryFile file;
file.resize( ze.unc_size );
// we have found the particles -> unpack them into memory
UnzipItem( zip, entryIndex, file.getMemory(), file.size() );
CloseZip( zip );
// now read the particles
int particleCount = 0;
file.read((char *) &particleCount, sizeof(int) );
printf( "number of particles: %i\n", particleCount );
// prepare vector
particles.resize( particleCount );
// now read in (kinda rough)
for( int i=0; i<particleCount; ++i )
{
float pos[3];
file.read((char *) pos, sizeof(float) * 3 );
particles[i].position.x = pos[0];
particles[i].position.y = pos[1];
particles[i].position.z = pos[2];
}
}else
{
// open file from disk
std::ifstream in( fileName.c_str(), std::ios::in | std::ios::binary );
if( !in )
return;
int particleCount = 0;
in.read((char *) &particleCount, sizeof(int) );
printf( "number of particles: %i\n", particleCount );
// prepare vector
particles.resize( particleCount );
// now read in (kinda rough)
for( int i=0; i<particleCount; ++i )
{
float pos[3];
in.read((char *) pos, sizeof(float) * 3 );
particles[i].position.x = pos[0];
particles[i].position.y = pos[1];
particles[i].position.z = pos[2];
}
in.close();
}
}
