void WAVStream::readFormatSubchunk(int size) { format_.audioFormat = readInt16(); format_.channelCount = readInt16(); format_.sampleRate = readInt32(); format_.byteRate = readInt32(); format_.blockAlign = readInt16(); format_.bitsPerSample = readInt16(); streamInfo_.sampleRate = format_.sampleRate; }
int WAVStream::readSubchunk() { string subchunkId = readString(4); int size = readInt32(); //cerr << "CHUNK " << subchunkId << ", SIZE = " << size << endl; if (subchunkId.compare(WAVFormat::FORMAT_SUBCHUNK_ID) == 0) { readFormatSubchunk(size); } else if (subchunkId.compare(WAVFormat::INF1_SUBCHUNK_ID) == 0) { readInf1Subchunk(size); } else if (subchunkId.compare(WAVFormat::DATA_SUBCHUNK_ID) == 0) { if (!dataRead_) { startStream(); //if (backend_.isNotNull()) // backend_->startStream(streamInfo_); dataRead_ = true; } readDataSubchunk(size); } else { readUnknownSubchunk(size); } return size + 4; }
int32_t BinaryReader::readInt32(const BinaryReader::BigEndian&) { const int32_t value = readInt32(BinaryReader::LittleEndian()); const int32_t swapped = swapEndian(value); return swapped; }
//------------------------------------------------------------------------ bool PresetFile::readChunkList () { seekTo (0); entryCount = 0; char8 classString[kClassIDSize + 1] = {0}; // Read header int32 version = 0; TSize listOffset = 0; if (!(readEqualID (getChunkID (kHeader)) && readInt32 (version) && verify (stream->read (classString, kClassIDSize)) && readSize (listOffset) && listOffset > 0 && seekTo (listOffset))) return false; classID.fromString (classString); // Read list int32 count = 0; if (!readEqualID (getChunkID (kChunkList))) return false; if (!readInt32 (count)) return false; if (count > kMaxEntries) count = kMaxEntries; for (int32 i = 0; i < count; i++) { Entry& e = entries[i]; if (!(readID (e.id) && readSize (e.offset) && readSize (e.size))) break; entryCount++; } return entryCount > 0; }
void BaseSerializedObj::readInt32Array(int32_t** o) { uint64_t size = readUInt64(); *o = (int32_t *) malloc(size*byteSize_writeInt32); uint64_t i = 0; while(i != size) { (*o)[i] = readInt32(); i++; } }
void BaseSerializedObj::readChars(char** p) { int length = readInt32(); *p = (char*) malloc(length+1); int i = 0; while(i != length) { (*p)[i] = readByte(); i++; } (*p)[length] = '\0'; }
std::string BaseSerializedObj::readString() { int length = readInt32(); std::string r = ""; int i = 0; while(i != length) { r.push_back(readByte()); i++; } return r; }
//------------------------------------------------------------------------ bool PresetFile::getUnitProgramListID (int32& unitProgramListID) { const Entry* e = getEntry (kProgramData); if (e && seekTo (e->offset)) { if (readInt32 (unitProgramListID)) { return true; } } return false; }
int WaveReader::readSample(int bytes) { switch (bytes) { case 1: return readInt8(); case 2: return readInt16(); case 4: return readInt32(); } return 0; }
WaveInfo WaveReader::readHeader() { int chunkId = 0; bool dataChunk = false; WaveInfo info; while (!dataChunk) { chunkId = readInt32(); switch (chunkId) { case FORMAT: //printf("Format\n"); info.formatSize = readInt32(); info.format = readInt16(); info.channels = readInt16(); info.sampleRate = readInt32(); info.bitsPerSecond = readInt32(); info.formatBlockAlign = readInt16(); info.bitDepth = readInt16(); if (info.formatSize == 18) { int extraData = readInt16(); fseek(mWavFile, extraData, SEEK_CUR); } break; case RIFF_HEADER: //printf("Riff Header\n"); info.headerId = chunkId; info.memSize = readInt32(); info.riffStyle = readInt32(); break; case DATA: //printf("Data\n"); dataChunk = true; info.dataSize = readInt32(); break; default: int skipSize = readInt32(); //printf("Skip Size = %d\n", skipSize); fseek(mWavFile, skipSize, SEEK_CUR); break; } } return info; }
//------------------------------------------------------------------------ bool PresetFile::restoreProgramData (IUnitData* unitData, UnitID* unitId) { const Entry* e = getEntry (kProgramData); UnitID savedUnitID = -1; if (e && seekTo (e->offset)) { if (readInt32 (savedUnitID)) { if (unitId && *unitId != savedUnitID) return false; int32 alreadyRead = sizeof (int32); ReadOnlyBStream* readOnlyBStream = new ReadOnlyBStream (stream, e->offset + alreadyRead, e->size - alreadyRead); FReleaser readOnlyStreamReleaser (readOnlyBStream); return (unitData && verify (unitData->setUnitData (savedUnitID, readOnlyBStream))); } } return false; }
//------------------------------------------------------------------------ bool PresetFile::restoreProgramData (IUnitInfo* unitInfo, int32 unitProgramListID, int32 programIndex) { const Entry* e = getEntry (kProgramData); int32 savedProgramListID = -1; if (e && seekTo (e->offset)) { if (readInt32 (savedProgramListID)) { if (unitProgramListID != savedProgramListID) return false; int32 alreadyRead = sizeof (int32); ReadOnlyBStream* readOnlyBStream = new ReadOnlyBStream (stream, e->offset + alreadyRead, e->size - alreadyRead); FReleaser readOnlyStreamReleaser (readOnlyBStream); return (unitInfo && unitInfo->setUnitProgramData (unitProgramListID, programIndex, readOnlyBStream)); } } return false; }
//------------------------------------------------------------------------ bool PresetFile::restoreProgramData (IProgramListData* programListData, ProgramListID* programListID, int32 programIndex) { const Entry* e = getEntry (kProgramData); ProgramListID savedProgramListID = -1; if (e && seekTo (e->offset)) { if (readInt32 (savedProgramListID)) { if (programListID && *programListID != savedProgramListID) return false; int32 alreadyRead = sizeof (int32); ReadOnlyBStream* readOnlyBStream = new ReadOnlyBStream (stream, e->offset + alreadyRead, e->size - alreadyRead); FReleaser readOnlyBStreamReleaser (readOnlyBStream); return programListData && verify (programListData->setProgramData (savedProgramListID, programIndex, readOnlyBStream)); } } return false; }
bool IfdFileContainer::_locateDirs(void) { if (!locateDirsPreHook()) { return false; } Trace(DEBUG1) << "_locateDirs()\n"; if (m_endian == ENDIAN_NULL) { char buf[4]; m_file->seek(m_offset, SEEK_SET); m_file->read(buf, 4); m_endian = isMagicHeader(buf, 4); if (m_endian == ENDIAN_NULL) { // FIXME set error code return false; } } m_file->seek(m_offset + 4, SEEK_SET); int32_t dir_offset = 0; readInt32(m_file, dir_offset); m_dirs.clear(); do { if (dir_offset != 0) { // std::cerr.setf(std::ios_base::hex, // std::ios_base::basefield); Trace(DEBUG1) << "push offset =0x" << dir_offset << "\n"; // we assume the offset is relative to the begining of // the IFD. IfdDir::Ref dir( std::make_shared<IfdDir>(m_offset + dir_offset, *this)); m_dirs.push_back(dir); // std::cerr.setf((std::ios_base::fmtflags)0, // std::ios_base::basefield); dir_offset = dir->nextIFD(); } } while (dir_offset != 0); Trace(DEBUG1) << "# dir found = " << m_dirs.size() << "\n"; return (m_dirs.size() != 0); }
void WAVStream::run() { //char chunkID[5]; //chunkID[4] = 0; //input_->getStream()->read(chunkID, 4); //cout << "CHUNK ID: " << chunkID << endl; streamInfo_ = StreamInfo(); string chunkId = readString(4); if (chunkId.compare(WAVFormat::CHUNK_ID) != 0) { cerr << "ERROR: Invalid chunk ID. Stream may not be in WAV format." << endl; return; } int32_t chunkSize = readInt32(); string chunkFormat = readString(4); if (chunkFormat.compare(WAVFormat::CHUNK_FORMAT) != 0) { cerr << "ERROR: Invalid chunk format. Stream may not be in WAV format." << endl; return; } chunkSize -= 4; formatRead_ = false; dataRead_ = false; dataInfo_ = DataInfo(); while (chunkSize > 0) { chunkSize -= readSubchunk(); } endStream(); //if (backend_.isNotNull()) // backend_->endStream(); }
size_t IfdFileContainer::getDirectoryDataSize() { // TODO move to IFDirectory Trace(DEBUG1) << "getDirectoryDataSize()" << "\n"; off_t dir_offset = m_current_dir->offset(); // FIXME check error Trace(DEBUG1) << "offset = " << dir_offset << " m_numTags = " << m_current_dir->numTags() << "\n"; off_t begin = dir_offset + 2 + (m_current_dir->numTags() * 12); Trace(DEBUG1) << "begin = " << begin << "\n"; m_file->seek(begin, SEEK_SET); begin += 2; int32_t nextIFD; readInt32(m_file, nextIFD); Trace(DEBUG1) << "nextIFD = " << nextIFD << "\n"; if (nextIFD == 0) { // FIXME not good } return nextIFD - begin; }
BeingId MessageIn::readBeingId(const char *const str) { return fromInt(readInt32(str), BeingId); }
string psoCat::odbcFieldToStr( uint32_t length ) { psoFieldDefinition * fieldODBC; int numFields, i; string outStr; fieldODBC = (psoFieldDefinition *) fieldDef; numFields = fieldDefLength / sizeof(psoFieldDefinition); psoaGetFieldOffsets( fieldODBC, numFields, fieldOffsets ); for ( i = 0; i < numFields; ++i ) { string s; switch( fieldODBC[i].type ) { case PSO_TINYINT: s = readInt8( &buffer[fieldOffsets[i]] ); break; case PSO_SMALLINT: s = readInt16( &buffer[fieldOffsets[i]] ); break; case PSO_INTEGER: s = readInt32( &buffer[fieldOffsets[i]] ); break; case PSO_BIGINT: s = readInt64( &buffer[fieldOffsets[i]] ); break; case PSO_BINARY: readBinary( s, fieldODBC[i].vals.length, &buffer[fieldOffsets[i]] ); break; case PSO_CHAR: readString( s, fieldODBC[i].vals.length, &buffer[fieldOffsets[i]] ); break; case PSO_NUMERIC: s = readDecimal( fieldODBC[i].vals.decimal.precision, fieldODBC[i].vals.decimal.scale, &buffer[fieldOffsets[i]] ); break; case PSO_VARCHAR: case PSO_LONGVARCHAR: readString( s, length - fieldOffsets[i], &buffer[fieldOffsets[i]] ); break; case PSO_VARBINARY: case PSO_LONGVARBINARY: readBinary( s, length - fieldOffsets[i], &buffer[fieldOffsets[i]] ); break; case PSO_REAL: s = readFloat32( &buffer[fieldOffsets[i]] ); break; case PSO_DOUBLE: s = readFloat64( &buffer[fieldOffsets[i]] ); break; case PSO_DATE: s = readDate( &buffer[fieldOffsets[i]] ); break; case PSO_TIME: s = readTime( &buffer[fieldOffsets[i]] ); break; case PSO_TIMESTAMP: s = readTimeStamp( &buffer[fieldOffsets[i]] ); break; } outStr += s; if ( i < numFields-1) outStr += ", "; } return outStr; }
void initFileObject(lua_State* L) { luaL_newmetatable(L, meta<File>()); // Duplicate the metatable on the stack. lua_pushvalue(L, -1); // metatable.__index = metatable lua_setfield(L, -2, "__index"); // Put the members into the metatable. const luaL_Reg functions[] = { {"__gc", [](lua_State* L) { return script::wrapped<File>(L, 1)->gc(L); }}, {"__index", [](lua_State* L) { return script::wrapped<File>(L, 1)->index(L); }}, {"__newindex", [](lua_State* L) { return script::wrapped<File>(L, 1)->newindex(L); }}, {"__tostring", [](lua_State* L) { return script::wrapped<File>(L, 1)->tostring(L); }}, {"__pairs", [](lua_State* L) { return script::wrapped<File>(L, 1)->pairs(L); }}, {"close", [](lua_State* L) { auto file = script::ptr<File>(L, 1); file->close(); return 0; }}, {"readUnsigned8", [](lua_State* L) { auto file = script::ptr<File>(L, 1); uint8_t value; if(file->readUnsigned8(value)) { script::push(L, value); return 1; } return 0; }}, {"readUnsigned16", [](lua_State* L) { auto file = script::ptr<File>(L, 1); uint16_t value; if(file->readUnsigned16(value)) { script::push(L, value); return 1; } return 0; }}, {"readUnsigned32", [](lua_State* L) { auto file = script::ptr<File>(L, 1); uint32_t value; if(file->readUnsigned32(value)) { script::push(L, value); return 1; } return 0; }}, {"readInt8", [](lua_State* L) { auto file = script::ptr<File>(L, 1); int8_t value; if(file->readInt8(value)) { script::push(L, value); return 1; } return 0; }}, {"readInt16", [](lua_State* L) { auto file = script::ptr<File>(L, 1); int16_t value; if(file->readInt16(value)) { script::push(L, value); return 1; } return 0; }}, {"readInt32", [](lua_State* L) { auto file = script::ptr<File>(L, 1); int32_t value; if(file->readInt32(value)) { script::push(L, value); return 1; } return 0; }}, {"readFloat", [](lua_State* L) { auto file = script::ptr<File>(L, 1); float value; if(file->readFloat(value)) { script::push(L, value); return 1; } return 0; }}, {"readDouble", [](lua_State* L) { auto file = script::ptr<File>(L, 1); double value; if(file->readDouble(value)) { script::push(L, value); return 1; } return 0; }}, {"readString", [](lua_State* L) { auto file = script::ptr<File>(L, 1); auto blockSize = script::get<int>(L, 2); std::string buffer(blockSize, 0); if(file->readString(buffer)) { lua_pushlstring(L, buffer.data(), buffer.size()); return 1; } return 0; }}, {"readLine", [](lua_State* L) { auto file = script::ptr<File>(L, 1); std::string value; if(file->readLine(value)) { script::push(L, value.c_str()); return 1; } return 0; }}, {"readFully", [](lua_State* L) { auto file = script::ptr<File>(L, 1); // Get current position. auto pos = file->tell(); if(pos == -1) { return 0; } // Length to read = position of end - current. auto length = 0; if(!file->seek(pos, FileSeekMode::End)) { return 0; } length = file->tell() - pos; if(!file->seek(pos, FileSeekMode::Start)) { return 0; } // Read the entire file into a string. std::string buf(length, 0); if(file->readString(buf)) { lua_pushlstring(L, buf.data(), buf.size()); return 1; } return 0; }}, {"writeUnsigned8", [](lua_State* L) { auto file = script::ptr<File>(L, 1); auto value = script::get<int>(L, 2); script::push(L, file->writeUnsigned8(value)); return 1; }}, {"writeUnsigned16", [](lua_State* L) { auto file = script::ptr<File>(L, 1); auto value = script::get<int>(L, 2); script::push(L, file->writeUnsigned16(value)); return 1; }}, {"writeUnsigned32", [](lua_State* L) { auto file = script::ptr<File>(L, 1); auto value = script::get<int>(L, 2); script::push(L, file->writeUnsigned32(value)); return 1; }}, {"writeInt8", [](lua_State* L) { auto file = script::ptr<File>(L, 1); auto value = script::get<int>(L, 2); script::push(L, file->writeInt8(value)); return 1; }}, {"writeInt16", [](lua_State* L) { auto file = script::ptr<File>(L, 1); auto value = script::get<int>(L, 2); script::push(L, file->writeInt16(value)); return 1; }}, {"writeInt32", [](lua_State* L) { auto file = script::ptr<File>(L, 1); auto value = script::get<int>(L, 2); script::push(L, file->writeInt32(value)); return 1; }}, {"writeFloat", [](lua_State* L) { auto file = script::ptr<File>(L, 1); auto value = script::get<double>(L, 2); script::push(L, file->writeFloat((float) value)); return 1; }}, {"writeDouble", [](lua_State* L) { auto file = script::ptr<File>(L, 1); auto value = script::get<double>(L, 2); script::push(L, file->writeDouble(value)); return 1; }}, {"writeString", [](lua_State* L) { auto file = script::ptr<File>(L, 1); size_t length = 0; const char* buffer = luaL_checklstring(L, 2, &length); std::string value(buffer, buffer + length); script::push(L, file->writeString(value)); return 1; }}, {"writeLine", [](lua_State* L) { auto file = script::ptr<File>(L, 1); size_t length = 0; const char* buffer = luaL_checklstring(L, 2, &length); std::string value(buffer, buffer + length); script::push(L, file->writeLine(value)); return 1; }}, {"tell", [](lua_State* L) { auto file = script::ptr<File>(L, 1); script::push(L, int(file->tell())); return 1; }}, {"seek", [](lua_State* L) { auto file = script::ptr<File>(L, 1); auto position = script::get<int>(L, 2); auto mode = FileSeekMode(script::get<int>(L, 3)); script::push(L, file->seek(position, mode)); return 1; }}, {"flush", [](lua_State* L) { auto file = script::ptr<File>(L, 1); file->flush(); return 0; }}, {nullptr, nullptr}, }; luaL_setfuncs(L, functions, 0); lua_pop(L, 1); // Push plum namespace. lua_getglobal(L, "plum"); // plum.File = <function create> script::push(L, "File"); lua_pushcfunction(L, [](lua_State* L) { auto filename = script::get<const char*>(L, 1); auto mode = FileOpenMode(script::get<int>(L, 2)); auto f = new File(filename, mode); // Failure. if(!f->isActive()) { delete f; return 0; } script::push(L, f, LUA_NOREF); return 1; }); lua_settable(L, -3); // Pop plum namespace. lua_pop(L, 1); }
float BaseSerializedObj::readFloat() { unsigned char* a = (unsigned char* ) readInt32(); float r = *(float *) &a; return r; }
/* * Internal static function for decoding of the header fields. */ static int decodeHeader(GTPublicationsFile *pubfile) { size_t data_block_size; size_t hash_data_block_size; assert(sizeof(int) >= 4); assert(sizeof(long long) >= 8); if (pubfile->data_length < 1) { return GT_INVALID_FORMAT; } pubfile->version = readUInt16(pubfile->data + GTPublicationsFile_HeaderOffset_version); if (pubfile->version != GTPublicationsFile_CurrentVersion) { return GT_UNSUPPORTED_FORMAT; } if (pubfile->data_length < GTPublicationsFile_HeaderLength) { return GT_INVALID_FORMAT; } pubfile->first_publication_ident = readInt64(pubfile->data + GTPublicationsFile_HeaderOffset_firstPublicationIdent); pubfile->data_block_begin = readInt32(pubfile->data + GTPublicationsFile_HeaderOffset_dataBlockBegin); pubfile->publication_cell_size = readUInt16(pubfile->data + GTPublicationsFile_HeaderOffset_publicationCellSize); pubfile->number_of_publications = readInt32(pubfile->data + GTPublicationsFile_HeaderOffset_numberOfPublications); pubfile->key_hashes_begin = readInt32(pubfile->data + GTPublicationsFile_HeaderOffset_keyHashesBegin); pubfile->key_hash_cell_size = readUInt16(pubfile->data + GTPublicationsFile_HeaderOffset_keyHashCellSize); pubfile->number_of_key_hashes = readUInt16(pubfile->data + GTPublicationsFile_HeaderOffset_numberOfKeyHashes); pubfile->pub_reference_begin = readInt32(pubfile->data + GTPublicationsFile_HeaderOffset_pubReferenceBegin); pubfile->signature_block_begin = readInt32(pubfile->data + GTPublicationsFile_HeaderOffset_signatureBlockBegin); if (pubfile->data_block_begin < GTPublicationsFile_HeaderLength || pubfile->data_block_begin > pubfile->data_length) { return GT_INVALID_FORMAT; } if (pubfile->key_hashes_begin < pubfile->data_block_begin || pubfile->key_hashes_begin > pubfile->data_length) { return GT_INVALID_FORMAT; } if (pubfile->pub_reference_begin < pubfile->key_hashes_begin || pubfile->pub_reference_begin > pubfile->data_length) { return GT_INVALID_FORMAT; } if (pubfile->signature_block_begin < pubfile->pub_reference_begin || pubfile->signature_block_begin > pubfile->data_length) { return GT_INVALID_FORMAT; } data_block_size = pubfile->key_hashes_begin - pubfile->data_block_begin; hash_data_block_size = pubfile->signature_block_begin - pubfile->key_hashes_begin; /* Using integer division instead of multiply ensures that there will * be no overflows and thus no false positives in case of invalid values * of publication_cell_size or number_of_publications. */ if (data_block_size / pubfile->publication_cell_size < pubfile->number_of_publications) { return GT_INVALID_FORMAT; } if (hash_data_block_size / pubfile->key_hash_cell_size < pubfile->number_of_key_hashes) { return GT_INVALID_FORMAT; } return GT_OK; }
string psoCat::odbcKeyToStr( uint32_t length ) { psoKeyFieldDefinition * keyODBC; int numKeys, i; string outStr; keyODBC = (psoKeyFieldDefinition *) keyDef; numKeys = keyDefLength / sizeof(psoKeyFieldDefinition); psoaGetKeyOffsets( keyODBC, numKeys, keyOffsets ); for ( i = 0; i < numKeys; ++i ) { string s; switch( keyODBC[i].type ) { case PSO_KEY_INTEGER: s = readInt32( &key[keyOffsets[i]] ); break; case PSO_KEY_BIGINT: s = readInt64( &key[keyOffsets[i]] ); break; case PSO_KEY_BINARY: readBinary( s, keyODBC[i].length, &key[keyOffsets[i]] ); break; case PSO_KEY_CHAR: readString( s, keyODBC[i].length, &key[keyOffsets[i]] ); break; case PSO_KEY_VARCHAR: case PSO_KEY_LONGVARCHAR: readString( s, length - keyOffsets[i], &key[keyOffsets[i]] ); break; case PSO_KEY_VARBINARY: case PSO_KEY_LONGVARBINARY: readBinary( s, length - keyOffsets[i], &key[keyOffsets[i]] ); break; case PSO_KEY_DATE: s = readDate( &key[keyOffsets[i]] ); break; case PSO_KEY_TIME: s = readTime( &key[keyOffsets[i]] ); break; case PSO_KEY_TIMESTAMP: s = readTimeStamp( &key[keyOffsets[i]] ); break; } outStr += s; if ( i < numKeys-1) outStr += ", "; } return outStr; }
void NmeaParser::packet_GSV(int num_params, char *params[]) { /* * * GSV - Satellites in view * * These sentences describe the sky position of a UPS satellite in view. * Typically they're shipped in a group of 2 or 3. * * 1 2 3 4 5 6 7 n * | | | | | | | | * $--GSV,x,x,x,x,x,x,x,...*hh<CR><LF> * * Field Number: * 1) total number of messages * 2) message number * 3) satellites in view * 4) satellite number * 5) elevation in degrees (0-90) * 6) azimuth in degrees to true north (0-359) * 7) SNR in dB (0-99) * more satellite infos like 4)-7) * n) checksum * * Example: * $GPGSV,3,1,11,03,03,111,00,04,15,270,00,06,01,010,00,13,06,292,00*74 * $GPGSV,3,2,11,14,25,170,00,16,57,208,39,18,67,296,40,19,40,246,00*74 * $GPGSV,3,3,11,22,42,067,42,24,14,311,43,27,05,244,00,,,,*4D * */ /* GSV can come in groups. */ int32 numMsgs = readInt32(params[1]); int32 seqNum = readInt32(params[2]); if (seqNum == 1) { if (m_satInfo) { delete m_satInfo; } m_satInfo = new GpsSatInfoHolder(); m_satInfoSeqId = 0; } if (m_satInfoSeqId + 1 != seqNum) { /* Out of order, abort. */ return; } else { m_satInfoSeqId = seqNum; } uint32 numSat = readInt32(params[3]); int32 index = 4; while (index <= (num_params-3)) { int32 id = readInt32(params[index++]); int32 elev = readInt32(params[index++]); int32 azim = readInt32(params[index++]); int32 snr = readInt32(params[index++]); GpsSatInfo* info = new GpsSatInfo( id, elev, azim, snr ); m_satInfo->addInfo(info); } if (seqNum == numMsgs) { /* Last message in sequence. */ if (m_satInfo->size() != numSat) { DEBUG_PKT("packet_GSV - mismatch in sat num!"); } if (m_consumer) { m_consumer->gpsSatInfo(m_satInfo); } delete m_satInfo; m_satInfo = 0; m_satInfoSeqId = 0; } }
void File::readInt32E(unsigned int *dest, bool big_endian) { if (big_endian) readInt32BE(dest); else readInt32(dest); }