void ToolCapabilities::deSerialize(std::istream &is)
{
int version = readU8(is);
if(version != 1 && version != 2) throw SerializationError(
"unsupported ToolCapabilities version");
full_punch_interval = readF1000(is);
max_drop_level = readS16(is);
groupcaps.clear();
u32 groupcaps_size = readU32(is);
for(u32 i=0; i<groupcaps_size; i++){
std::string name = deSerializeString(is);
ToolGroupCap cap;
cap.uses = readS16(is);
cap.maxlevel = readS16(is);
u32 times_size = readU32(is);
for(u32 i=0; i<times_size; i++){
int level = readS16(is);
float time = readF1000(is);
cap.times[level] = time;
}
groupcaps[name] = cap;
}
if(version == 2)
{
u32 damage_groups_size = readU32(is);
for(u32 i=0; i<damage_groups_size; i++){
std::string name = deSerializeString(is);
s16 rating = readS16(is);
damageGroups[name] = rating;
}
}
}
void libvisio::VSDMetaData::readPropertySetStream(librevenge::RVNGInputStream *input)
{
// ByteOrder
input->seek(2, librevenge::RVNG_SEEK_CUR);
// Version
input->seek(2, librevenge::RVNG_SEEK_CUR);
// SystemIdentifier
input->seek(4, librevenge::RVNG_SEEK_CUR);
// CLSID
input->seek(16, librevenge::RVNG_SEEK_CUR);
// NumPropertySets
input->seek(4, librevenge::RVNG_SEEK_CUR);
// FMTID0
//input->seek(16, librevenge::RVNG_SEEK_CUR);
uint32_t data1 = readU32(input);
uint16_t data2 = readU16(input);
uint16_t data3 = readU16(input);
uint8_t data4[8];
for (int i = 0; i < 8; i++)
{
data4[i] = readU8(input);
}
char FMTID0[36];
sprintf(FMTID0, "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x", data1, data2, data3,
data4[0], data4[1], data4[2], data4[3], data4[4], data4[5], data4[6], data4[7]);
uint32_t offset0 = readU32(input);
readPropertySet(input, offset0, FMTID0);
}
void libvisio::VSDMetaData::readPropertySetStream(librevenge::RVNGInputStream *input)
{
// ByteOrder
input->seek(2, librevenge::RVNG_SEEK_CUR);
// Version
input->seek(2, librevenge::RVNG_SEEK_CUR);
// SystemIdentifier
input->seek(4, librevenge::RVNG_SEEK_CUR);
// CLSID
input->seek(16, librevenge::RVNG_SEEK_CUR);
// NumPropertySets
input->seek(4, librevenge::RVNG_SEEK_CUR);
// FMTID0
//input->seek(16, librevenge::RVNG_SEEK_CUR);
uint32_t data1 = readU32(input);
uint16_t data2 = readU16(input);
uint16_t data3 = readU16(input);
uint8_t data4[8];
for (unsigned char &i : data4)
{
i = readU8(input);
}
// Pretty-printed GUID is 36 bytes + the terminating null-character.
char FMTID0[37];
sprintf(FMTID0, "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x", data1, data2, data3,
data4[0], data4[1], data4[2], data4[3], data4[4], data4[5], data4[6], data4[7]);
uint32_t offset0 = readU32(input);
readPropertySet(input, offset0, FMTID0);
}
/*
Parse voice header chunk.
*/
status IFFFile::parseVHDR(const Tag &type, size_t size)
{
assert(type == "VHDR");
Track *track = getTrack();
uint32_t oneShotSamples, repeatSamples, samplesPerRepeat;
uint16_t sampleRate;
uint8_t octaves, compression;
uint32_t volume;
readU32(&oneShotSamples);
readU32(&repeatSamples);
readU32(&samplesPerRepeat);
readU16(&sampleRate);
readU8(&octaves);
readU8(&compression);
readU32(&volume);
track->f.sampleWidth = 8;
track->f.sampleRate = sampleRate;
track->f.sampleFormat = AF_SAMPFMT_TWOSCOMP;
track->f.compressionType = AF_COMPRESSION_NONE;
track->f.byteOrder = AF_BYTEORDER_BIGENDIAN;
track->f.channelCount = 1;
track->f.framesPerPacket = 1;
track->f.computeBytesPerPacketPCM();
_af_set_sample_format(&track->f, track->f.sampleFormat, track->f.sampleWidth);
return AF_SUCCEED;
}
/* Parse an adtl sub-chunk within a LIST chunk. */
status WAVEFile::parseADTLSubChunk(const Tag &id, uint32_t size)
{
Track *track = getTrack();
AFfileoffset endPos = fh->tell() + size;
while (fh->tell() < endPos)
{
Tag chunkID;
uint32_t chunkSize;
readTag(&chunkID);
readU32(&chunkSize);
if (chunkID == "labl" || chunkID == "note")
{
uint32_t id;
long length=chunkSize-4;
char *p = (char *) _af_malloc(length);
readU32(&id);
fh->read(p, length);
Marker *marker = track->getMarker(id);
if (marker)
{
if (chunkID == "labl")
{
free(marker->name);
marker->name = p;
}
else if (chunkID == "note")
{
free(marker->comment);
marker->comment = p;
}
else
free(p);
}
else
free(p);
/*
If chunkSize is odd, skip an extra byte
at the end of the chunk.
*/
if ((chunkSize % 2) != 0)
fh->seek(1, File::SeekFromCurrent);
}
else
{
/* If chunkSize is odd, skip an extra byte. */
fh->seek(chunkSize + (chunkSize % 2), File::SeekFromCurrent);
}
}
return AF_SUCCEED;
}
U32 PGRFPaxosLeaderKeepAliveReq::deserialize( const S8 * buf, S32 offset )
{
U32 cur_pos = PPacketBase::deserialize(buf, offset);
const S8 * buff = buf + offset;
readU32(buff + cur_pos, m_iServerID);
cur_pos += sizeof(U32);
readU32(buff + cur_pos, m_iEpoch);
cur_pos += sizeof(U32);
return cur_pos;
}
status SampleVisionFile::parseLoops()
{
for (int i=0; i<8; i++)
{
uint32_t startFrame, endFrame;
uint8_t type;
uint16_t count;
readU32(&startFrame);
readU32(&endFrame);
readU8(&type);
readU16(&count);
}
return AF_SUCCEED;
}
static plString readString(const unsigned char*& buffer, size_t& size) {
size_t len = readU32(buffer, size);
plString v = plString((pl_wchar_t*)buffer, (len-1) / sizeof(pl_wchar_t));
buffer += len;
size -= len;
return v;
}
bool WPGHeader::load(WPXInputStream *input)
{
input->seek(0, WPX_SEEK_SET);
size_t n = 0;
unsigned char * prefix = (unsigned char *) input->read(26, n);
if(n < 26)
return false;
m_identifier[0] = prefix[0];
m_identifier[1] = prefix[1];
m_identifier[2] = prefix[2];
m_identifier[3] = prefix[3];
m_startOfDocument = readU32(prefix+4);
m_productType = prefix[8];
m_fileType = prefix[9];
m_majorVersion = prefix[10];
m_minorVersion = prefix[11];
m_encryptionKey = readU16(prefix+12);
m_startOfPacketData = readU16(prefix+14);
WPG_DEBUG_MSG(("Header Identifier = %c%c%c\n", m_identifier[1],
m_identifier[2], m_identifier[3]));
WPG_DEBUG_MSG(("Product type = 0x%x\n", m_productType));
WPG_DEBUG_MSG(("File type = 0x%x\n", m_fileType));
WPG_DEBUG_MSG(("Major version = 0x%x\n", m_majorVersion));
WPG_DEBUG_MSG(("Minor version = 0x%x\n", m_minorVersion));
WPG_DEBUG_MSG(("Encryption key = 0x%x\n", m_encryptionKey));
return true;
}
int FClient::requestID(const char *desc)
{
int socketfd;
unsigned char buf[128];
int i;
unsigned int uret;
FILE *f;
int hid;
hid = gethostid();
/* connect to the server */
socketfd = connectServer();
if (socketfd<0) {
return 0;
}
/* send the request */
sendMessage(socketfd,"",FGETMACHINEID);
/* read the id */
uret = readU32(socketfd);
/* close the socket */
close(socketfd);
return uret;
}
bool DecoSchematic::loadSchematicFile() {
std::ifstream is(filename.c_str(), std::ios_base::binary);
u32 signature = readU32(is);
if (signature != MTSCHEM_FILE_SIGNATURE) {
errorstream << "loadSchematicFile: invalid schematic "
"file" << std::endl;
return false;
}
u16 version = readU16(is);
if (version != 1) {
errorstream << "loadSchematicFile: unsupported schematic "
"file version" << std::endl;
return false;
}
size = readV3S16(is);
int nodecount = size.X * size.Y * size.Z;
u16 nidmapcount = readU16(is);
node_names = new std::vector<std::string>;
for (int i = 0; i != nidmapcount; i++) {
std::string name = deSerializeString(is);
node_names->push_back(name);
}
delete schematic;
schematic = new MapNode[nodecount];
MapNode::deSerializeBulk(is, SER_FMT_VER_HIGHEST, schematic,
nodecount, 2, 2, true);
return true;
}
/**
Analyzes the content of an input stream to see if it can be parsed
\param input The input stream
\return A value that indicates whether the content from the input
stream is a Corel Draw Document that libcdr is able to parse
*/
CDRAPI bool libcdr::CMXDocument::isSupported(librevenge::RVNGInputStream *input)
try
{
if (!input)
return false;
input->seek(0, librevenge::RVNG_SEEK_SET);
unsigned riff = readU32(input);
if (riff != CDR_FOURCC_RIFF && riff != CDR_FOURCC_RIFX)
return false;
input->seek(4, librevenge::RVNG_SEEK_CUR);
char signature_c = (char)readU8(input);
if (signature_c != 'C' && signature_c != 'c')
return false;
char signature_d = (char)readU8(input);
if (signature_d != 'M' && signature_d != 'm')
return false;
char signature_r = (char)readU8(input);
if (signature_r != 'X' && signature_r != 'x')
return false;
return true;
}
catch (...)
{
return false;
}
void ContentFeatures::deSerialize(std::istream &is)
{
int version = readU8(is);
if(version != 5)
throw SerializationError("unsupported ContentFeatures version");
name = deSerializeString(is);
groups.clear();
u32 groups_size = readU16(is);
for(u32 i=0; i<groups_size; i++){
std::string name = deSerializeString(is);
int value = readS16(is);
groups[name] = value;
}
drawtype = (enum NodeDrawType)readU8(is);
visual_scale = readF1000(is);
if(readU8(is) != 6)
throw SerializationError("unsupported tile count");
for(u32 i=0; i<6; i++)
tiledef[i].deSerialize(is);
if(readU8(is) != CF_SPECIAL_COUNT)
throw SerializationError("unsupported CF_SPECIAL_COUNT");
for(u32 i=0; i<CF_SPECIAL_COUNT; i++)
tiledef_special[i].deSerialize(is);
alpha = readU8(is);
post_effect_color.setAlpha(readU8(is));
post_effect_color.setRed(readU8(is));
post_effect_color.setGreen(readU8(is));
post_effect_color.setBlue(readU8(is));
param_type = (enum ContentParamType)readU8(is);
param_type_2 = (enum ContentParamType2)readU8(is);
is_ground_content = readU8(is);
light_propagates = readU8(is);
sunlight_propagates = readU8(is);
walkable = readU8(is);
pointable = readU8(is);
diggable = readU8(is);
climbable = readU8(is);
buildable_to = readU8(is);
deSerializeString(is); // legacy: used to be metadata_name
liquid_type = (enum LiquidType)readU8(is);
liquid_alternative_flowing = deSerializeString(is);
liquid_alternative_source = deSerializeString(is);
liquid_viscosity = readU8(is);
light_source = readU8(is);
damage_per_second = readU32(is);
node_box.deSerialize(is);
selection_box.deSerialize(is);
legacy_facedir_simple = readU8(is);
legacy_wallmounted = readU8(is);
deSerializeSimpleSoundSpec(sound_footstep, is);
deSerializeSimpleSoundSpec(sound_dig, is);
deSerializeSimpleSoundSpec(sound_dug, is);
// If you add anything here, insert it primarily inside the try-catch
// block to not need to increase the version.
try{
// Stuff below should be moved to correct place in a version that
// otherwise changes the protocol version
liquid_renewable = readU8(is);
}catch(SerializationError &e) {};
}
void ClientMediaDownloader::deSerializeHashSet(const std::string &data,
std::set<std::string> &result)
{
if (data.size() < 6 || data.size() % 20 != 6) {
throw SerializationError(
"ClientMediaDownloader::deSerializeHashSet: "
"invalid hash set file size");
}
const u8 *data_cstr = (const u8*) data.c_str();
u32 signature = readU32(&data_cstr[0]);
if (signature != MTHASHSET_FILE_SIGNATURE) {
throw SerializationError(
"ClientMediaDownloader::deSerializeHashSet: "
"invalid hash set file signature");
}
u16 version = readU16(&data_cstr[4]);
if (version != 1) {
throw SerializationError(
"ClientMediaDownloader::deSerializeHashSet: "
"unsupported hash set file version");
}
for (u32 pos = 6; pos < data.size(); pos += 20) {
result.insert(data.substr(pos, 20));
}
}
bool FlcPlayer::isValidFrame(Uint8 *frameHeader, Uint32 &frameSize, Uint16 &frameType)
{
readU32(frameSize, frameHeader);
readU16(frameType, frameHeader + 4);
return (frameType == FRAME_TYPE || frameType == AUDIO_CHUNK || frameType == PREFIX_CHUNK);
}
U32 PGRFAttrSetResPkt::deserialize( const S8 * buf, S32 offset )
{
U32 cur_pos = PPacketBase::deserialize(buf, offset);
const S8 * buff = buf + offset;
readU32(buff + cur_pos, m_event);
cur_pos += sizeof(U32);
readU32(buff + cur_pos, m_iHandle);
cur_pos += sizeof(U32);
m_bOk = readB8(buff + cur_pos);
cur_pos += sizeof(B8);
//cur_pos += m_oAddr.deserialize(buff + cur_pos,0);
return cur_pos;
}
void read_chunk_header(unsigned char* input, size_t input_size, int* pos, int* id, int* options, unsigned long* size,
unsigned long* checksum, unsigned long* extra)
{
unsigned char buffer[16];
int c;
for (c=0;c<16;c++)
{
buffer[c] = input[*pos];
*pos = *pos + 1;
}
*id = readU16(buffer) & 0xffff;
*options = readU16(buffer+2) & 0xffff;
*size = readU32(buffer+4) & 0xffffffff;
*checksum = readU32(buffer+8) & 0xffffffff;
*extra = readU32(buffer+12) & 0xffffffff;
}
U32 PGRFCloseReqPkt::deserialize( const S8 * buf, S32 offset )
{
U32 cur_pos = PPacketBase::deserialize(buf, offset);
const S8 * buff = buf + offset;
readU32(buff + cur_pos, m_event);
cur_pos += sizeof(U32);
readU32(buff + cur_pos, m_iSessionID);
cur_pos += sizeof(U32);
readU32(buff + cur_pos, m_iHandle);
cur_pos += sizeof(U32);
//cur_pos += m_oAddr.deserialize(buff + cur_pos,0);
return cur_pos;
}
void ContentFeatures::deSerializeOld(std::istream &is, int version)
{
if(version == 5) // In PROTOCOL_VERSION 13
{
name = deSerializeString(is);
groups.clear();
u32 groups_size = readU16(is);
for(u32 i=0; i<groups_size; i++){
std::string name = deSerializeString(is);
int value = readS16(is);
groups[name] = value;
}
drawtype = (enum NodeDrawType)readU8(is);
visual_scale = readF1000(is);
if(readU8(is) != 6)
throw SerializationError("unsupported tile count");
for(u32 i=0; i<6; i++)
tiledef[i].deSerialize(is);
if(readU8(is) != CF_SPECIAL_COUNT)
throw SerializationError("unsupported CF_SPECIAL_COUNT");
for(u32 i=0; i<CF_SPECIAL_COUNT; i++)
tiledef_special[i].deSerialize(is);
alpha = readU8(is);
post_effect_color.setAlpha(readU8(is));
post_effect_color.setRed(readU8(is));
post_effect_color.setGreen(readU8(is));
post_effect_color.setBlue(readU8(is));
param_type = (enum ContentParamType)readU8(is);
param_type_2 = (enum ContentParamType2)readU8(is);
is_ground_content = readU8(is);
light_propagates = readU8(is);
sunlight_propagates = readU8(is);
walkable = readU8(is);
pointable = readU8(is);
diggable = readU8(is);
climbable = readU8(is);
buildable_to = readU8(is);
deSerializeString(is); // legacy: used to be metadata_name
liquid_type = (enum LiquidType)readU8(is);
liquid_alternative_flowing = deSerializeString(is);
liquid_alternative_source = deSerializeString(is);
liquid_viscosity = readU8(is);
light_source = readU8(is);
damage_per_second = readU32(is);
node_box.deSerialize(is);
selection_box.deSerialize(is);
legacy_facedir_simple = readU8(is);
legacy_wallmounted = readU8(is);
deSerializeSimpleSoundSpec(sound_footstep, is);
deSerializeSimpleSoundSpec(sound_dig, is);
deSerializeSimpleSoundSpec(sound_dug, is);
}
else
{
throw SerializationError("unsupported ContentFeatures version");
}
}
void FlcPlayer::readFileHeader()
{
readU32(_headerSize, _fileBuf);
readU16(_headerType, _fileBuf + 4);
readU16(_headerFrames, _fileBuf + 6);
readU16(_headerWidth, _fileBuf + 8);
readU16(_headerHeight, _fileBuf + 10);
readU16(_headerDepth, _fileBuf + 12);
readU16(_headerSpeed, _fileBuf + 16);
}
librevenge::RVNGString libvisio::VSDMetaData::readCodePageString(librevenge::RVNGInputStream *input)
{
uint32_t size = readU32(input);
if (size > getRemainingLength(input))
size = getRemainingLength(input);
if (size == 0)
return librevenge::RVNGString();
std::vector<unsigned char> characters;
for (uint32_t i = 0; i < size; ++i)
characters.push_back(readU8(input));
uint32_t codepage = getCodePage();
librevenge::RVNGString string;
if (codepage == 65001)
{
// http://msdn.microsoft.com/en-us/library/windows/desktop/dd374130%28v=vs.85%29.aspx
// says this is UTF-8.
characters.push_back(0);
string.append(reinterpret_cast<const char *>(characters.data()));
}
else
{
UErrorCode status = U_ZERO_ERROR;
UConverter *conv = nullptr;
switch (codepage)
{
case 1252:
// http://msdn.microsoft.com/en-us/goglobal/bb964654
conv = ucnv_open("windows-1252", &status);
break;
}
if (U_SUCCESS(status) && conv)
{
assert(!characters.empty());
const auto *src = (const char *)&characters[0];
const char *srcLimit = (const char *)src + characters.size();
while (src < srcLimit)
{
UChar32 ucs4Character = ucnv_getNextUChar(conv, &src, srcLimit, &status);
if (U_SUCCESS(status) && U_IS_UNICODE_CHAR(ucs4Character))
appendUCS4(string, ucs4Character);
}
}
if (conv)
ucnv_close(conv);
}
return string;
}
status WAVEFile::parseFrameCount(const Tag &id, uint32_t size)
{
Track *track = getTrack();
uint32_t totalFrames;
readU32(&totalFrames);
track->totalfframes = totalFrames;
return AF_SUCCEED;
}
void FlcPlayer::playVideoFrame()
{
++_frameCount;
if (SDL_LockSurface(_mainScreen) < 0)
return;
int chunkCount = _frameChunks;
for (int i = 0; i < chunkCount; ++i)
{
readU32(_chunkSize, _chunkData);
readU16(_chunkType, _chunkData + 4);
switch (_chunkType)
{
case COLOR_256:
color256();
break;
case FLI_SS2:
fliSS2();
break;
case COLOR_64:
color64();
break;
case FLI_LC:
fliLC();
break;
case BLACK:
black();
break;
case FLI_BRUN:
fliBRun();
break;
case FLI_COPY:
fliCopy();
break;
case 18:
break;
default:
Log(LOG_WARNING) << "Ieek an non implemented chunk type:" << _chunkType;
break;
}
_chunkData += _chunkSize;
}
SDL_UnlockSurface(_mainScreen);
/* TODO: Track which rectangles have really changed */
//SDL_UpdateRect(_mainScreen, 0, 0, 0, 0);
if (_mainScreen != _realScreen->getSurface()->getSurface())
SDL_BlitSurface(_mainScreen, 0, _realScreen->getSurface()->getSurface(), 0);
_realScreen->flip();
}
/************************************************************************************
*
* ***********************************************************************************/
bool ScopeDome::SetupParms()
{
targetAz = 0;
readU32(GetImpPerTurn, stepsPerTurn);
LOGF_INFO("Steps per turn read as %d", stepsPerTurn);
StepsPerRevolutionN[0].value = stepsPerTurn;
StepsPerRevolutionNP.s = IPS_OK;
IDSetNumber(&StepsPerRevolutionNP, nullptr);
readS32(GetHomeSensorPosition, homePosition);
LOGF_INFO("Home position read as %d", homePosition);
if (UpdatePosition())
IDSetNumber(&DomeAbsPosNP, nullptr);
if (UpdateShutterStatus())
IDSetSwitch(&DomeShutterSP, nullptr);
UpdateSensorStatus();
UpdateRelayStatus();
if (InitPark())
{
// If loading parking data is successful, we just set the default parking
// values.
SetAxis1ParkDefault(0);
}
else
{
// Otherwise, we set all parking data to default in case no parking data is
// found.
SetAxis1Park(0);
SetAxis1ParkDefault(0);
}
uint8_t calibrationNeeded = false;
readU8(IsFullSystemCalReq, calibrationNeeded);
CalibrationNeededS[0].s = calibrationNeeded ? ISS_ON : ISS_OFF;
CalibrationNeededSP.s = IPS_OK;
IDSetSwitch(&CalibrationNeededSP, nullptr);
uint16_t fwVersion;
readU16(GetVersionFirmware, fwVersion);
FirmwareVersionsN[0].value = fwVersion / 100.0;
uint8_t fwVersionRotary;
readU8(GetVersionFirmwareRotary, fwVersionRotary);
FirmwareVersionsN[1].value = (fwVersionRotary + 9) / 10.0;
FirmwareVersionsNP.s = IPS_OK;
IDSetNumber(&FirmwareVersionsNP, nullptr);
return true;
}
void NodeMetadata::deSerialize(std::istream &is)
{
m_stringvars.clear();
int num_vars = readU32(is);
for(int i=0; i<num_vars; i++){
std::string name = deSerializeString(is);
std::string var = deSerializeLongString(is);
m_stringvars[name] = var;
}
m_inventory->deSerialize(is);
}
status SampleVisionFile::parseMarkers()
{
for (int i=0; i<8; i++)
{
char name[kSMPMarkerNameLength + 1];
m_fh->read(name, kSMPMarkerNameLength);
name[kSMPMarkerNameLength] = '\0';
uint32_t position;
readU32(&position);
}
return AF_SUCCEED;
}
void WP1VariableLengthGroup::_read(librevenge::RVNGInputStream *input, WPXEncryption *encryption)
{
long startPosition = input->tell();
if (startPosition < 0)
throw FileException();
WPD_DEBUG_MSG(("WordPerfect: handling a variable length group\n"));
m_size = readU32(input, encryption, true); // the length is the number of data bytes minus 4 (ie. the function codes)
if ((long)(m_size + startPosition) < startPosition)
throw FileException();
WPD_DEBUG_MSG(("WordPerfect: Read variable group header (start_position: %li, size: %u)\n", startPosition, m_size));
_readContents(input, encryption);
if ((m_size + (unsigned long)startPosition + 4 < m_size + (unsigned long)startPosition) ||
(m_size + (unsigned long)startPosition + 4) > ((std::numeric_limits<unsigned>::max)() / 2))
throw FileException();
input->seek(startPosition + m_size + 4, librevenge::RVNG_SEEK_SET);
if (m_size != readU32(input, encryption, true))
{
WPD_DEBUG_MSG(("WordPerfect: Possible corruption detected. Bailing out!\n"));
throw FileException();
}
if (m_group != readU8(input, encryption))
{
WPD_DEBUG_MSG(("WordPerfect: Possible corruption detected. Bailing out!\n"));
throw FileException();
}
if ((m_size + (unsigned long)startPosition + 9 < m_size + (unsigned long)startPosition) ||
(m_size + (unsigned long)startPosition + 9) > ((std::numeric_limits<unsigned>::max)() / 2))
throw FileException();
input->seek(startPosition + m_size + 9, librevenge::RVNG_SEEK_SET);
}
/* Parse an INFO sub-chunk within a LIST chunk. */
status WAVEFile::parseINFOSubChunk(const Tag &id, uint32_t size)
{
AFfileoffset endPos = fh->tell() + size;
while (fh->tell() < endPos)
{
int misctype = AF_MISC_UNRECOGNIZED;
Tag miscid;
uint32_t miscsize;
readTag(&miscid);
readU32(&miscsize);
if (miscid == "IART")
misctype = AF_MISC_AUTH;
else if (miscid == "INAM")
misctype = AF_MISC_NAME;
else if (miscid == "ICOP")
misctype = AF_MISC_COPY;
else if (miscid == "ICMT")
misctype = AF_MISC_ICMT;
else if (miscid == "ICRD")
misctype = AF_MISC_ICRD;
else if (miscid == "ISFT")
misctype = AF_MISC_ISFT;
if (misctype != AF_MISC_UNRECOGNIZED)
{
char *string = (char *) _af_malloc(miscsize);
fh->read(string, miscsize);
miscellaneousCount++;
miscellaneous = (Miscellaneous *) _af_realloc(miscellaneous, sizeof (Miscellaneous) * miscellaneousCount);
miscellaneous[miscellaneousCount-1].id = miscellaneousCount;
miscellaneous[miscellaneousCount-1].type = misctype;
miscellaneous[miscellaneousCount-1].size = miscsize;
miscellaneous[miscellaneousCount-1].position = 0;
miscellaneous[miscellaneousCount-1].buffer = string;
}
else
{
fh->seek(miscsize, File::SeekFromCurrent);
}
/* Make the current position an even number of bytes. */
if (miscsize % 2 != 0)
fh->seek(1, File::SeekFromCurrent);
}
return AF_SUCCEED;
}
U32 PGRFBroadcastEventPkt::deserialize( const S8 * buf, S32 offset )
{
U32 cur_pos = PPacketBase::deserialize(buf, offset);
const S8 * buff = buf + offset;
readU32(buff + cur_pos, m_iPaxosType);
cur_pos += sizeof(U32);
readU32(buff + cur_pos, m_iID);
cur_pos += sizeof(U32);
readU32(buff + cur_pos, m_iEpoch);
cur_pos += sizeof(U32);
readU64(buff + cur_pos, m_lTxid);
cur_pos += sizeof(U64);
cur_pos += readString(buff + cur_pos, m_sKey);
cur_pos += readString(buff + cur_pos, m_sValue);
return cur_pos;
}
bool SFX::readHeader(const char* filename, uint8_t* nChannels, uint32_t* nSamplesPerSec, uint32_t* lengthMillis)
{
File file = SD.open(filename);
if (file) {
Log.p(filename).eol();
file.seek(22);
*nChannels = readU32(file, 2);
Log.p("channels: ").p(*nChannels).eol();
*nSamplesPerSec = readU32(file, 4);
Log.p("nSamplesPerSec: ").p(*nSamplesPerSec).eol();
uint32_t nAvgBytesPerSec = readU32(file, 4);
//Serial.print("nAvgBytesPerSec: "); Serial.println(nAvgBytesPerSec);
//Serial.print("nBlockAlign: "); Serial.println(readU32(file, 2));
//Serial.print("wBitsPerSample: "); Serial.println(readU32(file, 2));
*lengthMillis = (file.size() - 44u) * 1000u / (nAvgBytesPerSec);
Log.p("length millis: ").p(*lengthMillis).eol();
file.close();
return true;
}
return false;
}
