bool DsdiffFileReader::readChunk_DIIN(dsf2flac_uint64 chunkStart)
{
// read the header so that we are certain we are in the correct place.
dsf2flac_int8 ident[5];
ident[4]='\0';
dsf2flac_uint64 chunkSz;
if (!readChunkHeader(ident,chunkStart,&chunkSz))
return false;
// check the ident
if ( !checkIdent(ident,const_cast<dsf2flac_int8*>("DIIN")) ) {
errorMsg = "dsdiffFileReader::readChunk_DIIN:chunk ident error";
return false;
}
// read all sub chunks in the FRM8 chunk
dsf2flac_uint64 subChunkStart = file.tellg();
dsf2flac_uint64 subChunkSz;
bool emidRead = false;
while (subChunkStart < chunkStart + chunkSz) {
// read the header
if (!readChunkHeader(ident,subChunkStart,&subChunkSz))
return false;
// see if we know how to read this chunk
if ( !emidRead && checkIdent(ident,const_cast<dsf2flac_int8*>("EMID")) ) {
emidRead = readChunk_EMID(subChunkStart);
} else if ( checkIdent(ident,const_cast<dsf2flac_int8*>("MARK")) ) {
readChunk_MARK(subChunkStart);
} else
printf("WARNING: unknown chunk type: %s\n",ident);
// move to the next chunk
subChunkStart = subChunkStart + subChunkSz;
}
return true;
}
bool FliPlayer::decodeFrame() {
FrameTypeChunkHeader frameHeader;
ChunkHeader cHeader = readChunkHeader(fli_data_);
do {
switch (cHeader.type) {
case 4:
setPalette(fli_data_ + 6);
g_System.setPalette8b3(palette_);
break;
case 7:
decodeDeltaFLC(fli_data_ + 6);
break;
case 15:
decodeByteRun(fli_data_ + 6);
break;
case FRAME_TYPE:
frameHeader = readFrameTypeChunkHeader(cHeader, fli_data_);
fli_info_.numFrames--;
//printf("Frames Remaining: %d\n", fli_info_.numFrames);
break;
default:
break;
}
if (cHeader.type != FRAME_TYPE)
fli_data_ += cHeader.size;
cHeader = readChunkHeader(fli_data_);
} while (isValidChunk(cHeader.type) && cHeader.type != FRAME_TYPE);
return isValidChunk(cHeader.type);
}
bool DsdiffFileReader::readChunk_CMPR(dsf2flac_uint64 chunkStart)
{
// read the header so that we are certain we are in the correct place.
dsf2flac_int8 ident[5];
ident[4]='\0';
if (!readChunkHeader(ident,chunkStart))
return false;
// check the ident
if ( !checkIdent(ident,const_cast<dsf2flac_int8*>("CMPR")) ) {
errorMsg = "dsdiffFileReader::readChunk_CMPR:chunk ident error";
return false;
}
// type of compression
compressionType[4] = '\0';
if (file.read_int8(compressionType,4)) {
errorMsg = "dsdiffFileReader::readChunk_CMPR:file read error";
return false;
}
// read length of next entry
dsf2flac_uint8 n;
if (file.read_uint8(&n,1)) {
errorMsg = "dsdiffFileReader::readChunk_CMPR:file read error";
return false;
}
compressionName = new dsf2flac_int8[n+1];
compressionName[n] = '\0';
if (file.read_int8(compressionName,n)) {
errorMsg = "dsdiffFileReader::readChunk_CMPR:file read error";
return false;
}
return true;
}
bool DsdiffFileReader::readChunk_CHNL(dsf2flac_uint64 chunkStart)
{
// read the header so that we are certain we are in the correct place.
dsf2flac_int8 ident[5];
ident[4]='\0';
if (!readChunkHeader(ident,chunkStart))
return false;
// check the ident
if ( !checkIdent(ident,const_cast<dsf2flac_int8*>("CHNL")) ) {
errorMsg = "dsdiffFileReader::readChunk_CHNL:chunk ident error";
return false;
}
// read number of channels
if (file.read_uint16_rev(&chanNum,1)) {
errorMsg = "dsdiffFileReader::readChunk_CHNL:file read error";
return false;
}
// read channel identifiers
chanIdents = new dsf2flac_int8*[chanNum];
for (dsf2flac_uint16 i=0; i<chanNum; i++) {
chanIdents[i] = new dsf2flac_int8[5];
if (file.read_int8(chanIdents[i],4)) {
errorMsg = "dsdiffFileReader::readChunk_CHNL:file read error";
return false;
};
chanIdents[i][4] = '\0';
}
return true;
}
bool DsdiffFileReader::readChunk_ABSS(dsf2flac_uint64 chunkStart)
{
// read the header so that we are certain we are in the correct place.
dsf2flac_int8 ident[5];
ident[4]='\0';
if (!readChunkHeader(ident,chunkStart))
return false;
// check the ident
if ( !checkIdent(ident,const_cast<dsf2flac_int8*>("ABSS")) ) {
errorMsg = "dsdiffFileReader::readChunk_ABSS:chunk ident error";
return false;
}
// hours
if (file.read_uint16_rev(&ast.hours,1)) {
errorMsg = "dsdiffFileReader::readChunk_ABSS:file read error";
return false;
}
// mins
if (file.read_uint8(&ast.minutes,1)) {
errorMsg = "dsdiffFileReader::readChunk_ABSS:file read error";
return false;
}
// secs
if (file.read_uint8(&ast.seconds,1)) {
errorMsg = "dsdiffFileReader::readChunk_ABSS:file read error";
return false;
}
// samples
if (file.read_uint32_rev(&ast.samples,1)) {
errorMsg = "dsdiffFileReader::readChunk_ABSS:file read error";
return false;
}
return true;
}
void Model3DS::parseMain()
{
cout << "parseMain" << endl;
DWord length = currentChunk.length;
DWord n = cfg3ds::chunkHeaderSize;
while (n < length)
{
readChunkHeader();
n += currentChunk.length;
switch (currentChunk.id)
{
case chunks::EDIT:
parseEdit();
break;
case chunks::KEYFRAMER:
parseKeyframer();
break;
default:
skipChunk();
}
}
}
RecorderEvent PlaybackFile::getNextEvent() {
assert(_mode == kRead);
if (isEventsBufferEmpty()) {
PlaybackFile::ChunkHeader header;
header.id = kFormatIdTag;
while (header.id != kEventTag) {
if (!readChunkHeader(header) || _readStream->eos()) {
break;
}
switch (header.id) {
case kEventTag:
readEventsToBuffer(header.len);
break;
case kScreenShotTag:
_readStream->seek(-4, SEEK_CUR);
header.len = _readStream->readUint32BE();
_readStream->skip(header.len-8);
break;
case kMD5Tag:
checkRecordedMD5();
break;
default:
_readStream->skip(header.len);
break;
}
}
}
RecorderEvent result;
readEvent(result);
return result;
}
bool DsdiffFileReader::readChunk_DSTI(dsf2flac_uint64 chunkStart)
{
// read the header so that we are certain we are in the correct place.
dsf2flac_int8 ident[5];
ident[4]='\0';
dsf2flac_uint64 chunkSz;
if (!readChunkHeader(ident,chunkStart,&chunkSz))
return false;
// check the ident
if ( !checkIdent(ident,const_cast<dsf2flac_int8*>("DSTI")) ) {
errorMsg = "dsdiffFileReader::readChunk_DSTI:chunk ident error";
return false;
}
dsf2flac_uint64 n = (chunkSz - 12)/(32+64);
for (dsf2flac_uint64 i=0; i<n; i++) {
DSTFrameIndex in;
if (file.read_uint64_rev(&in.offset,1)) {
errorMsg = "dsdiffFileReader::readChunk_DSTI:file read error";
return false;
}
if (file.read_uint32_rev(&in.length,1)) {
errorMsg = "dsdiffFileReader::readChunk_DSTI:file read error";
return false;
}
dstFrameIndices.push_back(in);
}
return true;
}
void Model3DS::parseObject()
{
cout << "parseObject" << endl;
DWord length = currentChunk.length;
Object *object = new Object(textures, currentSelectName++);
DWord n = cfg3ds::chunkHeaderSize;
n += readString(object->name);
cout << "\tname: " << object->name << endl;
while (n < length)
{
readChunkHeader();
n += currentChunk.length;
switch (currentChunk.id)
{
case chunks::OBJECT_MESH:
parseMesh(object);
break;
default:
skipChunk();
}
}
for (int i=0; i<object->numVertices; ++i)
object->normals[i].normalize();
objects.push_back(object);
}
void Model3DS::parseTexmap(Material *material)
{
cout << "parseTexmap" << endl;
DWord length = currentChunk.length;
DWord n = cfg3ds::chunkHeaderSize;
while (n < length)
{
readChunkHeader();
n += currentChunk.length;
switch (currentChunk.id)
{
case chunks::TEXMAP_FILE:
{
readString(material->texmapFile);
cout << material->texmapFile << endl;
material->textureRef = numTextures++;
break;
}
default:
skipChunk();
}
}
}
void
OgreMeshReader::readGeometryVertexBuffer(UInt32 vertCount,
VertexElementStore &vertexElements,
BufferVertexMap &bufferMap )
{
OSG_OGRE_LOG(("OgreMeshReader::readGeometryVertexBuffer\n"));
UInt16 bindIdx = readUInt16(_is);
#ifndef OSG_OGRE_SILENT
UInt16 vertSize =
#endif
readUInt16(_is);
OSG_OGRE_LOG(("OgreMeshReader::readGeometryVertexBuffer: "
"bindIdx '%d' vertSize '%d'\n", bindIdx, vertSize));
readChunkHeader(_is);
if(_header.chunkId == CHUNK_GEOMETRY_VERTEX_BUFFER_DATA)
{
readGeometryVertexBufferData(vertCount, bindIdx,
vertexElements, bufferMap);
}
else
{
skip(_is, -_chunkHeaderSize);
}
}
void
OgreMeshReader::readSubMeshNameTable(SubMeshStore &subMeshInfo)
{
OSG_OGRE_LOG(("OgreMeshReader::readSubMeshNameTable\n"));
bool stop = false;
while(_is)
{
readChunkHeader(_is);
switch(_header.chunkId)
{
case CHUNK_SUBMESH_NAME_TABLE_ELEMENT:
readSubMeshNameTableElement(subMeshInfo);
break;
default:
OSG_OGRE_LOG(("OgreMeshReader::readSubMeshNameTable: Unknown chunkId '0x%x'\n",
_header.chunkId));
stop = true;
break;
}
if(stop == true)
{
skip(_is, -_chunkHeaderSize);
break;
}
}
}
void Model3DS::parseColor(Color &color)
{
cout << "parseColor" << endl;
DWord length = currentChunk.length;
DWord n = cfg3ds::chunkHeaderSize;
while (n < length)
{
readChunkHeader();
n += currentChunk.length;
switch (currentChunk.id)
{
case chunks::COLOR_FLOAT:
case chunks::COLOR_FLOATG:
fread(&color, sizeof(float), 3, fp);
break;
case chunks::COLOR_BYTE:
case chunks::COLOR_BYTEG:
Byte r, g, b;
read(r);
read(g);
read(b);
color.r = r/255.0;
color.g = g/255.0;
color.b = b/255.0;
break;
default:
skipChunk();
}
}
}
void
OgreMeshReader::readGeometryVertexDeclaration(VertexElementStore &vertexElements,
BufferVertexMap &bufferMap )
{
OSG_OGRE_LOG(("OgreMeshReader::readGeometryVertexDeclaration\n"));
bool stop = false;
while(_is)
{
readChunkHeader(_is);
switch(_header.chunkId)
{
case CHUNK_GEOMETRY_VERTEX_ELEMENT:
readGeometryVertexElement(vertexElements, bufferMap);
break;
default:
OSG_OGRE_LOG(("OgreMeshReader::readGeometryVertexDeclaration: Unknown chunkId '0x%x'\n",
_header.chunkId));
stop = true;
break;
}
if(stop == true)
{
skip(_is, -_chunkHeaderSize);
break;
}
}
}
bool DsdiffFileReader::readHeaders()
{
// look for the FRM8 chunk (probably at the start of the data).
dsf2flac_int8 ident[5];
ident[4]='\0';
dsf2flac_uint64 chunkStart;
dsf2flac_uint64 chunkSz;
bool frm8read = false;
bool frm8valid = false;
// assum first chunk is at the start of the file.
chunkStart = 0;
// stop once one frm8 chunk is read
while (!frm8read) {
// read the chunk header
if (!readChunkHeader(ident,chunkStart,&chunkSz))
return false;
// did we find a FRM8 chunk??
if ( checkIdent(ident,const_cast<dsf2flac_int8*>("FRM8")) ) {
frm8valid = readChunk_FRM8(chunkStart);
frm8read = true;
}
// otherwise, move to the next chunk
chunkStart +=chunkSz;
}
return frm8valid;
}
bool PlaybackFile::processSettingsRecord() {
ChunkHeader keyChunk;
if (!readChunkHeader(keyChunk) || (keyChunk.id != kSettingsRecordKeyTag)) {
warning("Invalid format of settings section");
return false;
}
String key = readString(keyChunk.len);
ChunkHeader valueChunk;
if (!readChunkHeader(valueChunk) || (valueChunk.id != kSettingsRecordValueTag)) {
warning("Invalid format of settings section");
return false;
}
String value = readString(valueChunk.len);
_header.settingsRecords[key] = value;
return true;
}
// ---------------------------------------------------------------------------
// readContainer
// ---------------------------------------------------------------------------
//
static void
readContainer( std::istream & s )
{
ContainerCk ck;
try
{
// read chunk header:
readChunkHeader( s, ck.header );
if( ck.header.id != ContainerId )
Throw( FileIOException, "Found no Container chunk." );
// read FORM type
BigEndian::read( s, 1, sizeof(ID), (char *)&ck.formType );
}
catch( FileIOException & ex )
{
ex.append( "Failed to read badly-formatted Lemur file (bad Container chunk)." );
throw;
}
// make sure its really a Dr. Lemur file:
if ( ck.formType != LEMR_ID )
{
Throw( ImportException, "File is not formatted correctly for Lemur 5 import." );
}
}
bool DsdiffFileReader::readChunk_FRTE(dsf2flac_uint64 chunkStart)
{
// read the header so that we are certain we are in the correct place.
dsf2flac_int8 ident[5];
ident[4]='\0';
dsf2flac_uint64 chunkSz;
if (!readChunkHeader(ident,chunkStart,&chunkSz))
return false;
// check the ident
if ( !checkIdent(ident,const_cast<dsf2flac_int8*>("FRTE")) ) {
errorMsg = "dsdiffFileReader::readChunk_FRTE:chunk ident error";
return false;
}
if (file.read_uint32_rev(&dstInfo.numFrames,1)) {
errorMsg = "dsdiffFileReader::readChunk_FRTE:file read error";
return false;
}
if (file.read_uint16_rev(&dstInfo.frameRate,1)) {
errorMsg = "dsdiffFileReader::readChunk_FRTE:file read error";
return false;
}
dstInfo.frameSizeInSamplesPerChan = getSamplingFreq()/dstInfo.frameRate;
dstInfo.frameSizeInBytesPerChan = dstInfo.frameSizeInSamplesPerChan/samplesPerChar;
return true;
}
bool DsdiffFileReader::readChunk_DSTF(dsf2flac_uint64 chunkStart)
{
// read the header so that we are certain we are in the correct place.
dsf2flac_int8 ident[5];
ident[4]='\0';
dsf2flac_uint64 chunkLen;
if (!readChunkHeader(ident,chunkStart,&chunkLen))
return false;
// check the ident
if ( !checkIdent(ident,const_cast<dsf2flac_int8*>("DSTF")) ) {
errorMsg = "dsdiffFileReader::readChunk_DSTF:chunk ident error";
return false;
}
dsf2flac_uint64 dst_framesize = chunkLen-12;
dsf2flac_uint8* dst_data = new dsf2flac_uint8[dst_framesize];
if (file.read_uint8_rev(dst_data,dst_framesize)) {
errorMsg = "dsdiffFileReader::readChunk_DSTF:file read error";
return false;
}
if (DST_FramDSTDecode(dst_data, sampleBuffer,dst_framesize, dstInfo.numFrames, &dstEbunch))
return false;
return true;
}
void Model3DS::parseMesh(Object *object)
{
cout << "parseMesh" << endl;
DWord length = currentChunk.length;
DWord n = cfg3ds::chunkHeaderSize;
while (n < length)
{
readChunkHeader();
n += currentChunk.length;
switch (currentChunk.id)
{
case chunks::MESH_VERTICES:
read(object->numVertices);
object->vertices = new Vertex[object->numVertices];
object->normals = new Vector[object->numVertices];
memset(object->normals, 0, sizeof(Vector)*object->numVertices);
for (int i=0; i<object->numVertices; ++i) {
read(object->vertices[i].x);
read(object->vertices[i].y);
read(object->vertices[i].z);
}
break;
case chunks::MESH_FACES:
parseFaces(object);
break;
case chunks::MESH_MAPCOORDS:
Word numEntries;
read(numEntries);
object->mapCoords = new MapCoord[numEntries];
for (int i=0; i<numEntries; ++i) {
read(object->mapCoords[i].u);
read(object->mapCoords[i].v);
}
break;
case chunks::MESH_LOCALCOORDS:
read(object->u);
read(object->v);
read(object->w);
read(object->origin);
object->u.normalize();
object->v.normalize();
object->w.normalize();
break;
default:
skipChunk();
}
}
}
bool PlaybackFile::parseHeader() {
PlaybackFileHeader result;
ChunkHeader nextChunk;
_playbackParseState = kFileStateCheckFormat;
if (!readChunkHeader(nextChunk)) {
_playbackParseState = kFileStateError;
return false;
}
while ((_playbackParseState != kFileStateDone) && (_playbackParseState != kFileStateError)) {
if (processChunk(nextChunk)) {
if (!readChunkHeader(nextChunk)) {
warning("Error in header parsing");
_playbackParseState = kFileStateError;
}
}
}
return _playbackParseState == kFileStateDone;
}
void Model3DS::parse()
{
readChunkHeader();
if (currentChunk.id == chunks::MAIN)
parseMain();
else
exit(1);
}
bool DsdiffFileReader::readChunk_DST(dsf2flac_uint64 chunkStart)
{
// read the header so that we are certain we are in the correct place.
dsf2flac_int8 ident[5];
ident[4]='\0';
dsf2flac_uint64 chunkSz;
if (!readChunkHeader(ident,chunkStart,&chunkSz))
return false;
// check the ident
if ( !checkIdent(ident,const_cast<dsf2flac_int8*>("DST ")) ) {
errorMsg = "dsdiffFileReader::readChunk_DST:chunk ident error";
return false;
}
// record the end of the chunk
dstChunkEnd = chunkStart + chunkSz -1;
// read all sub chunks in the DST chunk
dsf2flac_uint64 subChunkStart = file.tellg();
dsf2flac_uint64 subChunkSz;
bool found_frte = false;
bool found_dstf = false;
//
while (!(found_frte && found_dstf) && subChunkStart < chunkStart + chunkSz) {
// read the header
if (!readChunkHeader(ident,subChunkStart,&subChunkSz))
return false;
// see if we know how to read this chunk
if ( !found_frte && checkIdent(ident,const_cast<dsf2flac_int8*>("FRTE")) ) {
found_frte = readChunk_FRTE(subChunkStart);
} else if ( !found_dstf && checkIdent(ident,const_cast<dsf2flac_int8*>("DSTF")) ) {
found_dstf = true;
sampleDataPointer = subChunkStart;
} else
printf("WARNING: unknown chunk type: %s\n",ident);
// move to the next chunk
subChunkStart = subChunkStart + subChunkSz;
}
if (found_frte) {
sampleCountPerChan = (dsf2flac_uint64)dstInfo.numFrames * (dsf2flac_uint64)dstInfo.frameSizeInSamplesPerChan;
sampleBufferLenPerChan = dstInfo.frameSizeInBytesPerChan;
}
return found_frte && found_dstf;
}
bool PlaybackFile::readSaveRecord() {
ChunkHeader fileNameChunk;
if (!readChunkHeader(fileNameChunk) || (fileNameChunk.id != kSaveRecordNameTag)) {
warning("Invalid format of save section");
return false;
}
String fileName = readString(fileNameChunk.len);
ChunkHeader saveBufferChunk;
if (!readChunkHeader(saveBufferChunk) || (saveBufferChunk.id != kSaveRecordBufferTag)) {
warning("Invalid format of save section");
return false;
}
SaveFileBuffer buf;
buf.size = saveBufferChunk.len;
buf.buffer = (byte *)malloc(saveBufferChunk.len);
_readStream->read(buf.buffer, buf.size);
_header.saveFiles[fileName] = buf;
debugC(1, kDebugLevelEventRec, "playback:action=\"Load save file\" filename=%s len=%d", fileName.c_str(), buf.size);
return true;
}
// ---------------------------------------------------------------------------
// importPartials
// ---------------------------------------------------------------------------
// Clients should be prepared to catch ImportExceptions.
//
// THIS WON'T WORK IF CHUNKS ARE IN A DIFFERENT ORDER!!!
// Fortunately, they never will be, since only the research
// version of Lemur ever wrote these files anyway.
//
static void
importPartials( std::istream & s, PartialList & partials, double bweCutoff )
{
try
{
// the Container chunk must be first, read it:
readContainer( s );
// read other chunks:
bool foundParams = false, foundTracks = false;
while ( ! foundParams || ! foundTracks )
{
// read a chunk header, if it isn't the one we want, skip over it.
CkHeader h;
readChunkHeader( s, h );
if ( h.id == AnalysisParamsID )
{
readParamsChunk( s );
foundParams = true;
}
else if ( h.id == TrackDataID )
{
if (! foundParams) // I hope this doesn't happen
{
Throw( ImportException,
"Mia culpa! I am not smart enough to read the Track data before the Analysis Parameters data." );
}
// read Partials:
for ( long counter = readTracksChunk( s ); counter > 0; --counter )
{
getPartial(s, partials, bweCutoff);
}
foundTracks = true;
}
else
{
s.ignore( h.size );
}
}
}
catch ( Exception & ex )
{
if ( s.eof() )
{
ex.append("Reached end of file before finding both a Tracks chunk and a Parameters chunk.");
}
ex.append( "Import failed." );
Throw( ImportException, ex.str() );
}
}
HTTP_RESULT HttpTcpConnection::chunkedRecv(char * buffer, size_t & bufsiz)
{
HTTP_RESULT res = HTTP_OK;
// Read the chunked header
// <size in hex> <chunk ext>\r\n
//<data... upto size>\r\n
// 0\r\n
// \r\n
unsigned int totalrecv = 0;
int n;
do {
n = readChunkHeader();
if (n < 0)
return HTTP_RECV_ERROR;
if (n == 0) // terminate chunk
{
// Read the training \r\n
bufsiz = totalrecv;
consumeLine();
return res;
}
// terminate if we don't have enough
// buffer to hold the data
if ((totalrecv + n) > bufsiz)
{
bufsiz = totalrecv;
return HTTP_RECV_BUFF_ERROR;
}
res = receive(buffer + totalrecv, (size_t &) n);
if (res != HTTP_OK)
{
bufsiz = totalrecv + n;
return res;
}
totalrecv += n;
}while(totalrecv < bufsiz);
return res;
}
bool DsdiffFileReader::readChunk_LSCO(dsf2flac_uint64 chunkStart)
{
// read the header so that we are certain we are in the correct place.
dsf2flac_int8 ident[5];
ident[4]='\0';
if (!readChunkHeader(ident,chunkStart))
return false;
// check the ident
if ( !checkIdent(ident,const_cast<dsf2flac_int8*>("LSCO")) ) {
errorMsg = "dsdiffFileReader::readChunk_LSCO:chunk ident error";
return false;
}
if (file.read_uint16(&lsConfig,1)) {
errorMsg = "dsdiffFileReader::readChunk_LSCO:file read error";
return false;
}
return true;
}
bool DsdiffFileReader::readChunk_FS(dsf2flac_uint64 chunkStart)
{
// read the header so that we are certain we are in the correct place.
dsf2flac_int8 ident[5];
ident[4]='\0';
if (!readChunkHeader(ident,chunkStart))
return false;
// check the ident
if ( !checkIdent(ident,const_cast<dsf2flac_int8*>("FS ")) ) {
errorMsg = "dsdiffFileReader::readChunk_FS:chunk ident error";
return false;
}
if (file.read_uint32_rev(&samplingFreq,1)) {
errorMsg = "dsdiffFileReader::readChunk_FS:File read error";
return false;
}
return true;
}
bool DsdiffFileReader::readChunk_DSD(dsf2flac_uint64 chunkStart)
{
// read the header so that we are certain we are in the correct place.
dsf2flac_int8 ident[5];
ident[4]='\0';
dsf2flac_uint64 chunkLen;
if (!readChunkHeader(ident,chunkStart,&chunkLen))
return false;
// check the ident
if ( !checkIdent(ident,const_cast<dsf2flac_int8*>("DSD ")) ) {
errorMsg = "dsdiffFileReader::readChunk_DSD:chunk ident error";
return false;
}
// we are now at the start of the dsd data, record the position
sampleDataPointer = file.tellg();
// chunkLen contains the number of samples
sampleCountPerChan = (chunkLen - 12)/chanNum*samplesPerChar;
return true;
}
bool DsdiffFileReader::readChunk_FVER(dsf2flac_uint64 chunkStart)
{
// read the header so that we are certain we are in the correct place.
dsf2flac_int8 ident[5];
ident[4]='\0';
if (!readChunkHeader(ident,chunkStart))
return false;
// check the ident
if ( !checkIdent(ident,const_cast<dsf2flac_int8*>("FVER")) ) {
errorMsg = "dsdiffFileReader::readChunk_FVER:chunk ident error";
return false;
}
// read the file version
if (file.read_uint32_rev(&dsdiffVersion,1)) {
errorMsg = "dsdiffFileReader::readChunk_FVER:file read error";
return false;
};
return true;
}
