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;
}
WideString TankFile::readWNString()
{
auto lenInChars = readU16();
if (lenInChars == 0)
{
readU16(); // Waste another word to make this a dword
return WideString();
}
// NSTRINGs are stored aligned at dword boundary:
lenInChars = alignToDword(lenInChars + 2) - 2; // 2 for the word we've just read
assert(((lenInChars + 2) % sizeof(uint32_t)) == 0);
if (lenInChars >= utils::MaxTempStringLen)
{
SiegeThrow(TankFile::Error, "String overflow in TankFile::readWNString()! "
<< lenInChars << " >= " << utils::MaxTempStringLen);
}
WideChar buffer[utils::MaxTempStringLen];
readBytes(buffer, lenInChars * sizeof(WideChar));
buffer[lenInChars] = 0;
return buffer;
}
void deSerialize(std::istream &is)
{
clear();
int version = readU8(is);
if(version != 1)
throw SerializationError("unsupported NodeDefinitionManager version");
u16 count = readU16(is);
std::istringstream is2(deSerializeLongString(is), std::ios::binary);
for(u16 n=0; n<count; n++){
u16 i = readU16(is2);
if(i > MAX_CONTENT){
errorstream<<"ContentFeatures::deSerialize(): "
<<"Too large content id: "<<i<<std::endl;
continue;
}
/*// Do not deserialize special types
if(i == CONTENT_IGNORE || i == CONTENT_AIR)
continue;*/
ContentFeatures *f = &m_content_features[i];
// Read it from the string wrapper
std::string wrapper = deSerializeString(is2);
std::istringstream wrapper_is(wrapper, std::ios::binary);
f->deSerialize(wrapper_is);
verbosestream<<"deserialized "<<f->name<<std::endl;
if(f->name != "")
addNameIdMapping(i, f->name);
}
}
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;
}
void deSerialize(std::istream &is)
{
// Clear everything
clear();
// Deserialize
int version = readU8(is);
if(version != 0)
throw SerializationError("unsupported ItemDefManager version");
u16 count = readU16(is);
for(u16 i=0; i<count; i++)
{
// Deserialize a string and grab an ItemDefinition from it
std::istringstream tmp_is(deSerializeString(is), std::ios::binary);
ItemDefinition def;
def.deSerialize(tmp_is);
// Register
registerItem(def);
}
u16 num_aliases = readU16(is);
for(u16 i=0; i<num_aliases; i++)
{
std::string name = deSerializeString(is);
std::string convert_to = deSerializeString(is);
registerAlias(name, convert_to);
}
}
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 ObjectProperties::deSerialize(std::istream &is)
{
int version = readU8(is);
if(version != 1) throw SerializationError(
"unsupported ObjectProperties version");
hp_max = readS16(is);
physical = readU8(is);
weight = readF1000(is);
collisionbox.MinEdge = readV3F1000(is);
collisionbox.MaxEdge = readV3F1000(is);
visual = deSerializeString(is);
meshfile = deSerializeString(is);
visual_size = readV2F1000(is);
textures.clear();
u32 texture_count = readU16(is);
for(u32 i=0; i<texture_count; i++){
textures.push_back(deSerializeString(is));
}
textures_3d.clear();
u32 texture_3d_count = readU16(is);
for(u32 i=0; i<texture_3d_count; i++){
textures_3d.push_back(deSerializeString(is));
}
spritediv = readV2S16(is);
initial_sprite_basepos = readV2S16(is);
is_visible = readU8(is);
makes_footstep_sound = readU8(is);
try{
automatic_rotate = readF1000(is);
}catch(SerializationError &e){}
}
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);
}
void WP6GraphicsFilenamePacket::_readContents(librevenge::RVNGInputStream *input, WPXEncryption *encryption)
{
if ((m_flags & 0x01) == 0x00)
return;
unsigned short tmpNumChildIds = readU16(input, encryption);
for (unsigned short i = 0; i < tmpNumChildIds; i++)
m_childIds.push_back(readU16(input, encryption));
}
void FlcPlayer::decodeVideo(bool skipLastFrame)
{
bool videoFrameFound = false;
while (!videoFrameFound)
{
if (!isValidFrame(_videoFrameData, _videoFrameSize, _videoFrameType))
{
_playingState = FINISHED;
break;
}
switch (_videoFrameType)
{
case FRAME_TYPE:
Uint32 delay;
readU16(_frameChunks, _videoFrameData + 6);
readU16(_delayOverride, _videoFrameData + 8);
if (_headerType == FLI_TYPE)
{
delay = _delayOverride > 0 ? _delayOverride : _headerSpeed * (1000.0 / 70.0);
}
else
{
delay = _videoDelay;
}
waitForNextFrame(delay);
// Skip the frame header, we are not interested in the rest
_chunkData = _videoFrameData + 16;
_videoFrameData += _videoFrameSize;
// If this frame is the last one, don't play it
if(isEndOfFile(_videoFrameData))
_playingState = FINISHED;
if(!shouldQuit() || !skipLastFrame)
playVideoFrame();
videoFrameFound = true;
break;
case AUDIO_CHUNK:
_videoFrameData += _videoFrameSize + 16;
break;
case PREFIX_CHUNK:
// Just skip it
_videoFrameData += _videoFrameSize;
break;
}
}
}
void NodeTimerList::deSerialize(std::istream &is, u8 map_format_version)
{
m_data.clear();
if(map_format_version == 24){
u8 timer_version = readU8(is);
if(timer_version == 0)
return;
if(timer_version != 1)
throw SerializationError("unsupported NodeTimerList version");
}
if(map_format_version >= 25){
u8 timer_data_len = readU8(is);
if(timer_data_len != 2+4+4)
throw SerializationError("unsupported NodeTimer data length");
}
u16 count = readU16(is);
for(u16 i=0; i<count; i++)
{
u16 p16 = readU16(is);
v3s16 p;
p.Z = p16 / MAP_BLOCKSIZE / MAP_BLOCKSIZE;
p16 &= MAP_BLOCKSIZE * MAP_BLOCKSIZE - 1;
p.Y = p16 / MAP_BLOCKSIZE;
p16 &= MAP_BLOCKSIZE - 1;
p.X = p16;
NodeTimer t;
t.deSerialize(is);
if(t.timeout <= 0)
{
infostream<<"WARNING: NodeTimerList::deSerialize(): "
<<"invalid data at position"
<<"("<<p.X<<","<<p.Y<<","<<p.Z<<"): Ignoring."
<<std::endl;
continue;
}
if(m_data.find(p) != m_data.end())
{
infostream<<"WARNING: NodeTimerList::deSerialize(): "
<<"already set data at position"
<<"("<<p.X<<","<<p.Y<<","<<p.Z<<"): Ignoring."
<<std::endl;
continue;
}
m_data.insert(std::make_pair(p, t));
}
}
void TileDef::deSerialize(std::istream &is)
{
int version = readU8(is);
name = deSerializeString(is);
animation.type = (TileAnimationType)readU8(is);
animation.aspect_w = readU16(is);
animation.aspect_h = readU16(is);
animation.length = readF1000(is);
if(version >= 1)
backface_culling = readU8(is);
}
void TileDef::deSerialize(std::istream &is)
{
int version = readU8(is);
if(version != 0)
throw SerializationError("unsupported TileDef version");
name = deSerializeString(is);
animation.type = (TileAnimationType)readU8(is);
animation.aspect_w = readU16(is);
animation.aspect_h = readU16(is);
animation.length = readF1000(is);
}
void STTBF::init( U16 lid, OLEStreamReader* reader, const U8* ptr )
{
bool extended = false;
U16 count = readU16( reader, &ptr );
// "extended" characters?
if ( count == 0xffff ) {
extended = true;
// read the real size
count = readU16( reader, &ptr );
}
m_extraDataLength = readU16( reader, &ptr );
// If we don't read unicode strings we have to set up a text converter
TextConverter* textconverter = 0;
if ( !extended )
textconverter = new TextConverter( lid );
// read one string after the other
for ( U16 i = 0; i < count; ++i ) {
U16 len = 0;
if ( extended ) // double byte count!
len = readU16( reader, &ptr );
else
len = readU8( reader, &ptr );
if ( len != 0 ) {
if ( extended ) {
XCHAR* string = new XCHAR[ len ];
for ( U16 j = 0; j < len; ++j )
string[ j ] = readU16( reader, &ptr );
UString ustring( reinterpret_cast<const wvWare::UChar *>( string ), len );
delete [] string;
m_strings.push_back( ustring );
}
else {
U8* string = new U8[ len ];
read( reader, &ptr, string, len );
UString ustring( textconverter->convert( reinterpret_cast<char*>( string ),
static_cast<unsigned int>( len ) ) );
delete [] string;
m_strings.push_back( ustring );
}
}
else
m_strings.push_back( UString("") );
if ( m_extraDataLength != 0 ) {
U8* extra = new U8[ m_extraDataLength ];
read( reader, &ptr, extra, m_extraDataLength );
m_extraData.push_back( extra );
}
}
delete textconverter;
}
void CraftDefinitionShaped::deSerializeBody(std::istream &is, int version)
{
if(version != 1) throw SerializationError(
"unsupported CraftDefinitionShaped version");
output = deSerializeString(is);
width = readU16(is);
recipe.clear();
u32 count = readU16(is);
for(u32 i=0; i<count; i++)
recipe.push_back(deSerializeString(is));
replacements.deSerialize(is);
}
void FlcPlayer::fliLC()
{
Uint8 *pSrc, *pDst, *pTmpDst;
Sint8 countData;
Uint8 countSkip;
Uint8 fill;
Uint16 lines, tmp;
int packetsCount;
pSrc = _chunkData + 6;
pDst = (Uint8*)_mainScreen->pixels + _offset;
readU16(tmp, pSrc);
pSrc += 2;
pDst += tmp*_mainScreen->pitch;
readU16(lines, pSrc);
pSrc += 2;
while (lines--)
{
pTmpDst = pDst;
packetsCount = *(pSrc++);
while (packetsCount--)
{
countSkip = *(pSrc++);
pTmpDst += countSkip;
countData = *(pSrc++);
if (countData > 0)
{
while (countData--)
{
*(pTmpDst++) = *(pSrc++);
}
}
else
{
if (countData < 0)
{
countData = -countData;
fill = *(pSrc++);
while (countData--)
{
*(pTmpDst++) = fill;
}
}
}
}
pDst += _mainScreen->pitch;
}
}
bool analyzeStyle(const uint8_t* os2_data, size_t os2_size, int* weight, bool* italic) {
const size_t kUsWeightClassOffset = 4;
const size_t kFsSelectionOffset = 62;
const uint16_t kItalicFlag = (1 << 0);
if (os2_size < kFsSelectionOffset + 2) {
return false;
}
uint16_t weightClass = readU16(os2_data, kUsWeightClassOffset);
*weight = weightClass / 100;
uint16_t fsSelection = readU16(os2_data, kFsSelectionOffset);
*italic = (fsSelection & kItalicFlag) != 0;
return true;
}
void NodeMetadataList::deSerialize(std::istream &is)
{
{
JMutexAutoLock lock(m_mutex);
m_data.clear();
}
u8 buf[6];
is.read((char*)buf, 2);
u16 version = readU16(buf);
if (version > 1) {
infostream<<__FUNCTION_NAME<<": version "<<version<<" not supported"
<<std::endl;
throw SerializationError("NodeMetadataList::deSerialize");
}
is.read((char*)buf, 2);
u16 count = readU16(buf);
for (u16 i=0; i<count; i++) {
is.read((char*)buf, 2);
u16 p16 = readU16(buf);
v3s16 p(0,0,0);
p.Z += p16 / MAP_BLOCKSIZE / MAP_BLOCKSIZE;
p16 -= p.Z * MAP_BLOCKSIZE * MAP_BLOCKSIZE;
p.Y += p16 / MAP_BLOCKSIZE;
p16 -= p.Y * MAP_BLOCKSIZE;
p.X += p16;
NodeMetadata *data = NodeMetadata::deSerialize(is);
if (data == NULL)
continue;
if (m_data.find(p)) {
infostream<<"WARNING: NodeMetadataList::deSerialize(): "
<<"already set data at position"
<<"("<<p.X<<","<<p.Y<<","<<p.Z<<"): Ignoring."
<<std::endl;
delete data;
continue;
}
m_data.insert(p, data);
}
}
void NameIdMapping::deSerialize(std::istream &is)
{
int version = readU8(is);
if(version != 0)
throw SerializationError("unsupported NameIdMapping version");
u32 count = readU16(is);
m_id_to_name.clear();
m_name_to_id.clear();
for(u32 i=0; i<count; i++){
u16 id = readU16(is);
std::string name = deSerializeString(is);
m_id_to_name[id] = name;
m_name_to_id[name] = id;
}
}
void CNodeDefManager::deSerialize(std::istream &is)
{
clear();
int version = readU8(is);
if (version != 1)
throw SerializationError("unsupported NodeDefinitionManager version");
u16 count = readU16(is);
std::istringstream is2(deSerializeLongString(is), std::ios::binary);
ContentFeatures f;
for (u16 n = 0; n < count; n++) {
u16 i = readU16(is2);
// Read it from the string wrapper
std::string wrapper = deSerializeString(is2);
std::istringstream wrapper_is(wrapper, std::ios::binary);
f.deSerialize(wrapper_is);
// Check error conditions
if (i == CONTENT_IGNORE || i == CONTENT_AIR || i == CONTENT_UNKNOWN) {
warningstream << "NodeDefManager::deSerialize(): "
"not changing builtin node " << i << std::endl;
continue;
}
if (f.name.empty()) {
warningstream << "NodeDefManager::deSerialize(): "
"received empty name" << std::endl;
continue;
}
// Ignore aliases
u16 existing_id;
if (m_name_id_mapping.getId(f.name, existing_id) && i != existing_id) {
warningstream << "NodeDefManager::deSerialize(): "
"already defined with different ID: " << f.name << std::endl;
continue;
}
// All is ok, add node definition with the requested ID
if (i >= m_content_features.size())
m_content_features.resize((u32)(i) + 1);
m_content_features[i] = f;
addNameIdMapping(i, f.name);
verbosestream << "deserialized " << f.name << std::endl;
getNodeBoxUnion(f.selection_box, f, &m_selection_box_union);
fixSelectionBoxIntUnion();
}
}
void TileDef::deSerialize(std::istream &is, u8 contentfeatures_version,
NodeDrawType drawtype)
{
int version = readU8(is);
if (version < 6)
throw SerializationError("unsupported TileDef version");
name = deSerializeString(is);
animation.deSerialize(is, version);
u16 flags = readU16(is);
backface_culling = flags & TILE_FLAG_BACKFACE_CULLING;
tileable_horizontal = flags & TILE_FLAG_TILEABLE_HORIZONTAL;
tileable_vertical = flags & TILE_FLAG_TILEABLE_VERTICAL;
has_color = flags & TILE_FLAG_HAS_COLOR;
bool has_scale = flags & TILE_FLAG_HAS_SCALE;
bool has_align_style = flags & TILE_FLAG_HAS_ALIGN_STYLE;
if (has_color) {
color.setRed(readU8(is));
color.setGreen(readU8(is));
color.setBlue(readU8(is));
}
scale = has_scale ? readU8(is) : 0;
if (has_align_style)
align_style = static_cast<AlignStyle>(readU8(is));
else
align_style = ALIGN_STYLE_NODE;
}
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) {};
}
/*
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;
}
void FlcPlayer::color64()
{
Uint8 *pSrc;
Uint16 NumColors, NumColorPackets;
Uint8 NumColorsSkip;
pSrc = _chunkData + 6;
readU16(NumColorPackets, pSrc);
pSrc += 2;
while (NumColorPackets--)
{
NumColorsSkip = *(pSrc++);
NumColors = *(pSrc++);
if (NumColors == 0)
{
NumColors = 256;
}
for (int i = 0; i < NumColors; ++i)
{
_colors[i].r = *(pSrc++) << 2;
_colors[i].g = *(pSrc++) << 2;
_colors[i].b = *(pSrc++) << 2;
}
_realScreen->setPalette(_colors, NumColorsSkip, NumColors, true);
}
}
void FlcPlayer::color256()
{
Uint8 *pSrc;
Uint16 numColorPackets;
Uint16 numColors = 0;
Uint8 numColorsSkip;
pSrc = _chunkData + 6;
readU16(numColorPackets, pSrc);
pSrc += 2;
while (numColorPackets--)
{
numColorsSkip = *(pSrc++) + numColors;
numColors = *(pSrc++);
if (numColors == 0)
{
numColors = 256;
}
for (int i = 0; i < numColors; ++i)
{
_colors[i].r = *(pSrc++);
_colors[i].g = *(pSrc++);
_colors[i].b = *(pSrc++);
}
_realScreen->setPalette(_colors, numColorsSkip, numColors, true);
if (numColorPackets >= 1)
{
++numColors;
}
}
}
void FlcPlayer::decodeAudio(int frames)
{
int audioFramesFound = 0;
while (audioFramesFound < frames && !isEndOfFile(_audioFrameData))
{
if (!isValidFrame(_audioFrameData, _audioFrameSize, _audioFrameType))
{
_playingState = FINISHED;
break;
}
switch (_audioFrameType)
{
case FRAME_TYPE:
case PREFIX_CHUNK:
_audioFrameData += _audioFrameSize;
break;
case AUDIO_CHUNK:
Uint16 sampleRate;
readU16(sampleRate, _audioFrameData + 8);
_chunkData = _audioFrameData + 16;
playAudioFrame(sampleRate);
_audioFrameData += _audioFrameSize + 16;
++audioFramesFound;
break;
}
}
}
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));
}
}
void ItemDefinition::deSerialize(std::istream &is)
{
// Reset everything
reset();
// Deserialize
int version = readU8(is);
if(version != 1)
throw SerializationError("unsupported ItemDefinition version");
type = (enum ItemType)readU8(is);
name = deSerializeString(is);
description = deSerializeString(is);
inventory_image = deSerializeString(is);
wield_image = deSerializeString(is);
wield_scale = readV3F1000(is);
stack_max = readS16(is);
usable = readU8(is);
liquids_pointable = readU8(is);
eatable = readU8(is);
std::string tool_capabilities_s = deSerializeString(is);
if(!tool_capabilities_s.empty())
{
std::istringstream tmp_is(tool_capabilities_s, std::ios::binary);
tool_capabilities = new ToolCapabilities;
tool_capabilities->deSerialize(tmp_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;
}
}
void NodeBox::deSerialize(std::istream &is)
{
int version = readU8(is);
if(version < 1 || version > 2)
throw SerializationError("unsupported NodeBox version");
reset();
type = (enum NodeBoxType)readU8(is);
if(type == NODEBOX_FIXED || type == NODEBOX_LEVELED)
{
u16 fixed_count = readU16(is);
while(fixed_count--)
{
aabb3f box;
box.MinEdge = readV3F1000(is);
box.MaxEdge = readV3F1000(is);
fixed.push_back(box);
}
}
else if(type == NODEBOX_WALLMOUNTED)
{
wall_top.MinEdge = readV3F1000(is);
wall_top.MaxEdge = readV3F1000(is);
wall_bottom.MinEdge = readV3F1000(is);
wall_bottom.MaxEdge = readV3F1000(is);
wall_side.MinEdge = readV3F1000(is);
wall_side.MaxEdge = readV3F1000(is);
}
}
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);
}
