/* * The ebscClass class contructor (EBSC table) */ ebscClass *New_ebscClass( tsiMemObject *mem, InputStream *in ) { F16Dot16 version; register int i, j; ebscClass *t = NULL; version = ReadInt32(in); /* Assume we understand this version number range. */ if ( version >= 0x00020000 && version < 0x00030000 ) { t = (ebscClass *) tsi_AllocMem( mem, sizeof( ebscClass ) ); t->mem = mem; t->version = version; t->numSizes = (tt_uint32)ReadInt32(in); t->table = (bitmapScaleEntry *) tsi_AllocArray(mem, t->numSizes, sizeof(bitmapScaleEntry)); for ( i = 0; i < (int)t->numSizes; i++ ) { for ( j = 0; j < NUM_SBIT_METRICS_BYTES; j++ ) { t->table[i].hori[j] = ReadUnsignedByteMacro( in ); } for ( j = 0; j < NUM_SBIT_METRICS_BYTES; j++ ) { t->table[i].vert[j] = ReadUnsignedByteMacro( in ); } t->table[i].ppemX = ReadUnsignedByteMacro( in ); t->table[i].ppemY = ReadUnsignedByteMacro( in ); t->table[i].substitutePpemX = ReadUnsignedByteMacro( in ); t->table[i].substitutePpemY = ReadUnsignedByteMacro( in ); } } return t; /*****/ }
uint64_t StormMessageReaderCursor::ReadInt64() { if (m_DataLength < 8) { throw std::runtime_error("Read buffer underflow"); } if (m_ReadOffset + 8 > m_FixedBlockSize) { uint64_t v1 = ReadInt32(); uint64_t v2 = ReadInt32(); return (uint64_t)((v2 << 32) | v1); } uint64_t v = Marshal::ReadInt64(m_CurBlock, m_ReadOffset); m_ReadOffset += 8; m_DataLength -= 8; if (m_ReadOffset >= m_FixedBlockSize) { m_CurBlock = m_Allocator->GetNextBlock(m_CurBlock); m_ReadOffset = 0; } return v; }
/* * Read the PACK directory into memory. The optional offset to the * start of the PACK file is given in "offset". The number of files in * the directory is returned in *dirsize_r. */ PACKDirPtr ReadPACKDirectory(FILE *packfile, UInt32 offset, UInt16 *dirsize_r) { PACKDirPtr dir; UInt32 pos, size; UInt16 max, i; *dirsize_r = 0; if (packfile == NULL) return NULL; if ((fseek(packfile, offset, SEEK_SET) < 0) || (ReadMagic(packfile) != FTYPE_PACK) || (ReadInt32(packfile, &pos) == FALSE) || (ReadInt32(packfile, &size) == FALSE) || (size == 0L) || (size / sizeof(struct PACKDirectory) > 65535L) || (fseek(packfile, offset + pos, SEEK_SET) < 0)) return NULL; dir = (PACKDirPtr)__qmalloc(size); max = (UInt16)(size / sizeof(struct PACKDirectory)); for (i = 0; i < max; i++) { if (ReadBytes(packfile, &dir[i], sizeof(struct PACKDirectory)) == FALSE) { free(dir); return NULL; } ConvertFilePath(dir[i].name); dir[i].offset = SwapInt32(dir[i].offset); dir[i].size = SwapInt32(dir[i].size); } *dirsize_r = max; return dir; }
bool VCFont::ParseKerning(std::ifstream& f) { char blockType = ReadInt8(f); int blockSize = ReadInt32(f); int kerningCount = blockSize / 10; // Pre-Buffer data ( Used to be a bottleneck - Profiled ) KerningPairIMR* pairsIMR = (KerningPairIMR*) malloc (sizeof(KerningPairIMR) * kerningCount); int size = sizeof(KerningPairIMR); //f.read((char*)pairsIMR, sizeof(KerningPairIMR) * kerningCount); for ( int i = 0; i < kerningCount; i++ ) { // Truncated Endian swap ( Truncated to 8 bits, hopefully enough ) //KerningPairIMR p = pairsIMR[i]; //p.first = p.first >> 28; //p.second = p.second >> 28; //p.ammount = p.ammount >> 8; // //Charaters[p.second].KerningPairs[p.first] = p.ammount; unsigned int first = ReadInt32(f); unsigned int second = ReadInt32(f); short ammount = ReadInt16(f); //Int8 sh = 0; Charaters[second].KerningPairs[first] = ammount; } free(pairsIMR); return true; }
// ------------------------------------- // Initialization functions // bool QTAtom_ctts::Initialize() { // Temporary vars UInt32 tempInt32; // // Parse this atom's fields. ReadInt32(cttsPos_VersionFlags, &tempInt32); fVersion = (UInt8)((tempInt32 >> 24) & 0x000000ff); fFlags = tempInt32 & 0x00ffffff; ReadInt32(cttsPos_NumEntries, &fNumEntries); // // Validate the size of the sample table. if ((UInt32)(fNumEntries * 8) != (fTOCEntry.AtomDataLength - 8)) return false; // // Read in the time-to-sample table. fTimeToSampleTable = new char[fNumEntries * 8]; if (fTimeToSampleTable == NULL) return false; ReadBytes(cttsPos_SampleTable, fTimeToSampleTable, fNumEntries * 8); // // This atom has been successfully read in. return true; }
/* Parse and store the dump time range from a dump header */ static afs_uint32 parse_dumptimes(XFILE * X, unsigned char *tag, tagged_field * field, afs_uint32 value, tag_parse_info * pi, void *g_refcon, void *l_refcon) { dump_parser *p = (dump_parser *) g_refcon; afs_dump_header *hdr = (afs_dump_header *) l_refcon; afs_uint16 count; afs_uint32 r; if ((r = ReadInt16(X, &count))) return r; if (count != 2) { if (p->cb_error) (p->cb_error) (DSERR_FMT, 1, p->err_refcon, "Incorrect array count (%d) in dump times", count); return DSERR_FMT; } if ((r = ReadInt32(X, &hdr->from_date))) return r; if ((r = ReadInt32(X, &hdr->to_date))) return r; hdr->field_mask |= (F_DUMPHDR_FROM | F_DUMPHDR_TO); if (p->print_flags & DSPRINT_DUMPHDR) printf("%s%d => %d\n", field->label, hdr->from_date, hdr->to_date); return ReadByte(X, tag); }
/* Parse a dump header, including its tagged attributes, and call the * dump-header callback, if one is defined. */ static afs_uint32 parse_dumphdr(XFILE * X, unsigned char *tag, tagged_field * field, afs_uint32 value, tag_parse_info * pi, void *g_refcon, void *l_refcon) { dump_parser *p = (dump_parser *) g_refcon; afs_dump_header hdr; dt_uint64 where; afs_uint32 r; memset(&hdr, 0, sizeof(hdr)); if ((r = xftell(X, &where))) return r; sub64_32(hdr.offset, where, 1); if ((r = ReadInt32(X, &hdr.magic))) return r; if ((r = ReadInt32(X, &hdr.version))) return r; if (hdr.magic != DUMPBEGINMAGIC) { if (p->cb_error) (p->cb_error) (DSERR_MAGIC, 1, p->err_refcon, "Invalid magic number (0x%08x) in dump header", hdr.magic); return DSERR_MAGIC; } if (hdr.version != DUMPVERSION) { if (p->cb_error) (p->cb_error) (DSERR_MAGIC, 1, p->err_refcon, "Unknown dump format version (%d) in dump header", hdr.version); return DSERR_MAGIC; } if (p->print_flags & DSPRINT_DUMPHDR) printf("%s [%s = 0x%s]\n", field->label, decimate_int64(&hdr.offset, 0), hexify_int64(&hdr.offset, 0)); if (p->print_flags & DSPRINT_DUMPHDR) { printf(" Magic number: 0x%08x\n", hdr.magic); printf(" Version: %d\n", hdr.version); } r = ParseTaggedData(X, dumphdr_fields, tag, pi, g_refcon, (void *)&hdr); if (!r && p->cb_dumphdr) { r = xftell(X, &where); if (!r) r = (p->cb_dumphdr) (&hdr, X, p->refcon); if (p->flags & DSFLAG_SEEK) { if (!r) r = xfseek(X, &where); else xfseek(X, &where); } } if (hdr.field_mask & F_DUMPHDR_VOLNAME) free(hdr.volname); return r; }
sRect cBinaryFile::ReadSRect() { sRect tmpRect; tmpRect.x = ReadInt32(); tmpRect.y = ReadInt32(); tmpRect.w = ReadInt32(); tmpRect.h = ReadInt32(); return tmpRect; }
size_t AttachEntity::deserialize(const Buffer& _src, size_t _offset) { _offset = _pm_checkPacketId(_src, _offset); _offset = ReadInt32(_src, _offset, _pf_entityId); _offset = ReadInt32(_src, _offset, _pf_vehicleId); _pf_initialized = true; return _offset; }
// ------------------------------------- // Initialization functions // Bool16 QTAtom_mdhd::Initialize() { // Temporary vars UInt32 tempInt32; // // Parse this atom's fields. ReadInt32(mdhdPos_VersionFlags, &tempInt32); fVersion = (UInt8)((tempInt32 >> 24) & 0x000000ff); fFlags = tempInt32 & 0x00ffffff; if (0 == fVersion) { // Verify that this atom is the correct length. if( fTOCEntry.AtomDataLength != 24 ) { DEEP_DEBUG_PRINT(("QTAtom_mdhd::Initialize failed. Expected AtomDataLength == 24 version: %d AtomDataLength: %" _64BITARG_ "u\n",fVersion, fTOCEntry.AtomDataLength)); return false; } ReadInt32To64(mdhdPos_CreationTime, &fCreationTime); ReadInt32To64(mdhdPos_ModificationTime, &fModificationTime); ReadInt32(mdhdPos_TimeScale, &fTimeScale); ReadInt32To64(mdhdPos_Duration, &fDuration); ReadInt16(mdhdPos_Language, &fLanguage); ReadInt16(mdhdPos_Quality, &fQuality); } else if (1 == fVersion) { // Verify that this atom is the correct length. if( fTOCEntry.AtomDataLength != 36 ) { DEEP_DEBUG_PRINT(("QTAtom_mdhd::Initialize failed. Expected AtomDataLength == 36 version: %d AtomDataLength: %" _64BITARG_ "u\n",fVersion, fTOCEntry.AtomDataLength)); return false; } ReadInt64(mdhdPosV1_CreationTime, &fCreationTime); ReadInt64(mdhdPosV1_ModificationTime, &fModificationTime); ReadInt32(mdhdPosV1_TimeScale, &fTimeScale); ReadInt64(mdhdPosV1_Duration, &fDuration); ReadInt16(mdhdPosV1_Language, &fLanguage); ReadInt16(mdhdPosV1_Quality, &fQuality); } else { DEEP_DEBUG_PRINT(("QTAtom_mdhd::Initialize failed. Version unsupported: %d\n",fVersion)); return false; } // // Compute the reciprocal of the timescale. fTimeScaleRecip = 1 / (Float64)fTimeScale; // // This atom has been successfully read in. return true; }
size_t CollectItem::deserialize(const Buffer& _src, size_t _offset) { _offset = _pm_checkPacketId(_src, _offset); _offset = ReadInt32(_src, _offset, _pf_collectedEID); _offset = ReadInt32(_src, _offset, _pf_collectorEID); _pf_initialized = true; return _offset; }
size_t RemoveEntityEffect::deserialize(const Buffer& _src, size_t _offset) { _offset = _pm_checkPacketId(_src, _offset); _offset = ReadInt32(_src, _offset, _pf_entityId); _offset = ReadInt32(_src, _offset, _pf_effectId); _pf_initialized = true; return _offset; }
// ------------------------------------- // Initialization functions // Bool16 QTAtom_stsd::Initialize(void) { // Temporary vars UInt32 tempInt32; // General vars char *pSampleDescriptionTable; // // Parse this atom's fields. ReadInt32(stsdPos_VersionFlags, &tempInt32); fVersion = (UInt8)((tempInt32 >> 24) & 0x000000ff); fFlags = tempInt32 & 0x00ffffff; ReadInt32(stsdPos_NumEntries, &fNumEntries); // // Read in all of the sample descriptions. if( fNumEntries > 0 ) { // // Allocate our description tables. UInt64 tableSize = fTOCEntry.AtomDataLength - 8; Assert(tableSize < kSInt32_Max); fSampleDescriptionTable = NEW char[ (SInt32) tableSize]; if( fSampleDescriptionTable == NULL ) return false; fTable = NEW char *[fNumEntries]; if( fTable == NULL ) return false; // // Read in the sample description table. ReadBytes(stsdPos_SampleTable, fSampleDescriptionTable, (UInt32) tableSize); // // Read them all in.. pSampleDescriptionTable = fSampleDescriptionTable; char *maxSampleDescriptionPtr = pSampleDescriptionTable + tableSize; for( UInt32 CurDesc = 0; CurDesc < fNumEntries; CurDesc++ ) { // // Associate this entry in our Table with the actual location of // this sample description. fTable[CurDesc] = pSampleDescriptionTable; // // Skip over this mini-atom. memcpy(&tempInt32, pSampleDescriptionTable, 4); pSampleDescriptionTable += ntohl(tempInt32); if (pSampleDescriptionTable > maxSampleDescriptionPtr) { return false; } } }
uint64_t StormHttpBodyReader::ReadInt64() { if (m_Reader.GetRemainingLength() < 8) { uint64_t v1 = ReadInt32() & 0xFFFFFFFF; uint64_t v2 = ReadInt32() & 0xFFFFFFFF; return (uint64_t)((v2 << 32) | v1); } return m_Reader.ReadInt64(); }
size_t SpawnGlobalEntity::deserialize(const Buffer& _src, size_t _offset) { _offset = _pm_checkPacketId(_src, _offset); _offset = ReadInt32(_src, _offset, _pf_entityId); _offset = ReadInt8(_src, _offset, _pf_type); _offset = ReadInt32(_src, _offset, _pf_x); _offset = ReadInt32(_src, _offset, _pf_y); _offset = ReadInt32(_src, _offset, _pf_z); _pf_initialized = true; return _offset; }
bool VCFont::ParseCharacters(std::ifstream& f) { char blockType = ReadInt8(f); int blockSize = ReadInt32(f); int charCount = blockSize / 20; for ( int i = 0; i < charCount; i++ ) { unsigned int id = ReadInt32(f); f.read((char*) &Charaters[id], 16); } return true; }
void FSEQFile::Load(const std::string& filename) { Close(); _fh = new wxFile(filename); if (_fh->IsOpened()) { char tag[5]; memset(tag, 0x00, sizeof(tag)); _fh->Read(tag, sizeof(tag)-1); if (std::string(tag) == "PSEQ") { _frame0Offset = ReadInt16(_fh); _fh->Read(&_minorVersion, sizeof(_minorVersion)); _fh->Read(&_majorVersion, sizeof(_majorVersion)); ReadInt16(_fh); // fixed header length _channelsPerFrame = ReadInt32(_fh); _frames = ReadInt32(_fh); _frameMS = ReadInt16(_fh); ReadInt16(_fh); // universes ReadInt16(_fh); // universe size _gamma = _fh->Read(&_gamma, sizeof(_gamma)); _fh->Read(&_colourEncoding, sizeof(_colourEncoding)); ReadInt16(_fh); // fill int mediafilenamelength = ReadInt16(_fh); if (mediafilenamelength > 0) { char* buf = (char*)malloc(mediafilenamelength + 1); memset(buf, 0x00, mediafilenamelength + 1); ReadInt16(_fh); // mf _fh->Read(buf, mediafilenamelength); _audiofilename = std::string(buf); free(buf); } _currentFrame = 0; _frameBuffer = (wxByte*)malloc(_channelsPerFrame); } else { Close(); } } else { Close(); } }
uint32 nf_getparameter(int i) { if (i < 0) return 0; return ReadInt32(context + i*4); }
// Reads the manifest of what types are contained in this XNB file. void ContentReader::ReadTypeManifest() { Log.WriteLine("Type readers:"); Log.Indent(); // How many type readers does this .xnb use? uint32_t typeReaderCount = Read7BitEncodedInt(); typeReaders.clear(); for (uint32_t i = 0; i < typeReaderCount; i++) { // Read the type reader metadata. wstring readerName = ReadString(); int32_t readerVersion = ReadInt32(); Log.WriteLine("%S (version %d)", readerName.c_str(), readerVersion); // Look up and store this type reader implementation class. TypeReader* reader = typeReaderManager->GetByReaderName(readerName); typeReaders.push_back(reader); } // Initialize the readers in a separate pass after they are all registered, in case there are // circular dependencies between them (eg. an array of classes which themselves contain arrays). for (vector<TypeReader*>::iterator iter = typeReaders.begin(); iter != typeReaders.end(); iter++) { TypeReader* reader = *iter; reader->Initialize(typeReaderManager); } Log.Unindent(); }
/* Parse and store the week use data from a volume header */ static afs_uint32 parse_weekuse(XFILE * X, unsigned char *tag, tagged_field * field, afs_uint32 value, tag_parse_info * pi, void *g_refcon, void *l_refcon) { dump_parser *p = (dump_parser *) g_refcon; afs_vol_header *hdr = (afs_vol_header *) l_refcon; afs_uint16 count; afs_uint32 r; unsigned int i; if (r = ReadInt16(X, &count)) return r; if (count != 7) { if (p->cb_error) (p->cb_error) (DSERR_FMT, 1, p->err_refcon, "Incorrect array count (%d) in weekuse data", count); return DSERR_FMT; } for (i = 0; i < count; i++) if (r = ReadInt32(X, hdr->weekuse + i)) return r; hdr->field_mask |= F_VOLHDR_WEEKUSE; if (p->print_flags & DSPRINT_VOLHDR) { printf("%s%10d %10d %10d %10d\n", field->label, hdr->weekuse[0], hdr->weekuse[1], hdr->weekuse[2], hdr->weekuse[3]); printf("%s%10d %10d %10d\n", field->label, hdr->weekuse[4], hdr->weekuse[5], hdr->weekuse[6]); } return ReadByte(X, tag); }
bool AtomMFHD::ReadData() { if (!ReadInt32(_sequenceNumber)) { FATAL("Unable to read creation time"); return false; } return true; }
//General "Network" / Gamemode AMX Code void CNetwork::OnServerChangeMap() { printf("OnServerChangeMap() has been called.\n"); int idx; cell ret = 0; CBaseEntity *entity = new CBaseEntity; Precache *precache = new Precache; CBasePlayer *pPlayer = new CBasePlayer(); //Dump all the clients from the table because the map was changed.. for(size_t i=0; i<ReadInt32(SVS_MAXCLIENTS); i++) { if(pPlayer->IsClientConnected(i)) { if(pPlayer->IsClientOnTable(i)) { OnClientDisconnect(i, REASON_MAPCHANGE); } } } delete pPlayer; //amx push would go below here.. (So we can push the OnServerChangeMap data to the loaded AMX script later) if (!amx_FindPublic(&inimod_amx, "OnServerChangeMap", &idx)) { amx_Exec(&inimod_amx, &ret, idx); precache->PreloadCached(false); //Don't delete anything the users precached.. } if((long)ret == 1) { printf("ret returned %d\n", ret); } entity->OnServerChangeMap(); delete entity; delete precache; }
float ReadStream::ReadFloat() { int32 value; ASSERT(sizeof(float) == sizeof(value)); value = ReadInt32(); return *(float*)&value; }
bool DataIndex::DecodeFromString(const std::string &str) { if (!StringStartsWith(str, kIndexBlockMagic)) { LOG(ERROR)<< "invalid data index header"; return false; } block_info_.clear(); const char *begin = str.c_str() + kIndexBlockMagic.size(); const char *end = str.c_str() + str.size(); while (begin < end) { DataBlockInfo info; info.offset = ReadInt64(&begin); info.data_size = ReadInt32(&begin); int key_len = ReadVint(&begin, end); info.key = std::string(begin, key_len); begin += key_len; block_info_.push_back(info); } // Check if the content is overflow if (begin > end) { LOG(ERROR) << "incomplete file, " << StringPrint("begin: %p, end: %p", begin, end); return false; } return true; }
size_t SpawnObject::deserialize(const Buffer& _src, size_t _offset) { _offset = _pm_checkPacketId(_src, _offset); _offset = ReadInt32(_src, _offset, _pf_entityId); _offset = ReadInt8(_src, _offset, _pf_type); _offset = ReadInt32(_src, _offset, _pf_x); _offset = ReadInt32(_src, _offset, _pf_y); _offset = ReadInt32(_src, _offset, _pf_z); _offset = ReadInt8(_src, _offset, _pf_pitch); _offset = ReadInt8(_src, _offset, _pf_yaw); _offset = _pf_objectData.deserialize(_src, _offset); _pf_initialized = true; return _offset; }
static void CAL_SetupAudioFile() { int handle; long length; char fname[13]; int i; strcpy(fname, aheadname); strcat(fname, extension); handle = OpenRead(fname); if (handle == -1) CA_CannotOpen(fname); length = ReadLength(handle); MM_GetPtr((memptr)&audiostarts, length); for (i = 0; i < (length/4); i++) audiostarts[i] = ReadInt32(handle); CloseRead(handle); /* open the data file */ strcpy(fname, afilename); strcat(fname, extension); audiohandle = OpenRead(fname); if (audiohandle == -1) CA_CannotOpen(fname); }
// ------------------------------------- // Initialization functions // Bool16 QTAtom_stsz::Initialize(void) { // Temporary vars UInt32 tempInt32; // // Parse this atom's fields. ReadInt32(stszPos_VersionFlags, &tempInt32); fVersion = (UInt8)((tempInt32 >> 24) & 0x000000ff); fFlags = tempInt32 & 0x00ffffff; ReadInt32(stszPos_SampleSize, &fCommonSampleSize); // // We don't need to read in the table (it doesn't exist anyway) if the // SampleSize field is non-zero. if( fCommonSampleSize != 0 ) return true; // // Build the table.. ReadInt32(stszPos_NumEntries, &fNumEntries); // // Validate the size of the sample table. if( (UInt32)(fNumEntries * 4) != (fTOCEntry.AtomDataLength - 12) ) return false; // // Read in the sample size table. fSampleSizeTable = NEW char[(fNumEntries * 4) + 1]; if( fSampleSizeTable == NULL ) return false; if( ((PointerSizedInt)fSampleSizeTable & (PointerSizedInt)0x3) == 0) fTable = (UInt32 *)fSampleSizeTable; else fTable = (UInt32 *)(((PointerSizedInt)fSampleSizeTable + 4) & ~((PointerSizedInt)0x3)); ReadBytes(stszPos_SampleTable, (char *)fTable, fNumEntries * 4); // // This atom has been successfully read in. return true; }
float InteropInputStream::ReadFloat() { BinaryInt32Float u; u.i = ReadInt32(); return u.f; }
size_t EntityStatus::deserialize(const Buffer& _src, size_t _offset) { _offset = _pm_checkPacketId(_src, _offset); _offset = ReadInt32(_src, _offset, _pf_entityId); _offset = ReadInt8(_src, _offset, _pf_entityStatus); _pf_initialized = true; return _offset; }
bool VCFont::ParseCommon(std::ifstream& f) { char blockType = ReadInt8(f); int blockSize = ReadInt32(f); f.read((char*) &Common, 15); return true; }