double readDouble(istream& in) { int num = sizeof(int64_t)/sizeof(char); char* s = new char [num]; in.read(s, num); int64_t d = *((int64_t*)s); swap_endian(d); double ans = *((double*)&d); delete[] s; return ans; }
void quake3_bsp_map::read_visibility_data(istream& stream) { #ifndef NDEBUG std::cout << "Reading visibility data" << std::endl; #endif int visibility_length = m_lumps[iVisibleDataOffset].length; //Only read the visibility data if it exists if (visibility_length) { stream.seekg(m_lumps[iVisibleDataOffset].offset, std::ios_base::beg); stream.read(reinterpret_cast<char*>(&m_raw_cluster_data.totalClusters), sizeof(int)); stream.read(reinterpret_cast<char*>(&m_raw_cluster_data.size), sizeof(int)); uint num_clusters = m_raw_cluster_data.totalClusters * m_raw_cluster_data.size; m_raw_cluster_data.bitSet.resize(num_clusters); stream.read(reinterpret_cast<char*>(&m_raw_cluster_data.bitSet[0]), sizeof(unsigned char) * num_clusters); } }
/*! @brief Constructs a SaveJob from stream data @param time the time in ms to perform the save @param input the stream from which to read the job specific data */ SaveJob::SaveJob(double time, istream& input) : MotionJob(Job::MOTION_SAVE) { m_job_time = time; // Temporary read buffers. unsigned int uintBuffer; float floatBuffer; // read in the save_position size input.read(reinterpret_cast<char*>(&uintBuffer), sizeof(unsigned int)); unsigned int m_save_position_size = uintBuffer; // read in the save position vector m_save_position = vector<float>(m_save_position_size, 0); for (unsigned int i=0; i<m_save_position_size; i++) { input.read(reinterpret_cast<char*>(&floatBuffer), sizeof(float)); m_save_position[i] = floatBuffer; } }
void load(istream &in){ ulint a_size; in.read((char*)&a_size,sizeof(a_size)); in.read((char*)&terminator_position,sizeof(terminator_position)); for(ulint i=0;i<a_size;++i){ char_type a; in.read((char*)&a,sizeof(a)); alphabet.insert(a); } F.load(in); L.load(in); }
bool SDKMeshHandler::doCanRead(istream& stream) const noexcept { SDKMESH_HEADER hdr; if (stream.read((char*)&hdr, sizeof(hdr))) { return hdr.Version == SDKMESH_FILE_VERSION; } return false; }
inline string GetString(istream& input,const char terminator='\0') { // TODO: make this check for FEOF condition! and also more efficient char c=' '; string s; while (c!=terminator && input) { input.read(&c,sizeof(char)); s += c; } return s; }
void readImageData( istream& is, cv::Mat_<cv::Vec3b>& cimg, cv::Mat_<cv::Vec3f>& points, cv::Mat_<float>& dimg) { string ln; getline( is, ln); istringstream iss(ln); cv::Size imgSz; iss >> imgSz.height >> imgSz.width; cimg = cv::Mat_<cv::Vec3b>( imgSz); points = cv::Mat_<cv::Vec3f>( imgSz); dimg = cv::Mat_<float>( imgSz); const int sz = imgSz.width * imgSz.height; const int pxlChunk = 3*sizeof(float) + 3*sizeof(byte); const int totalBytes = sz * pxlChunk; char* buff = (char*)malloc( totalBytes); int readBytes = 0; while ( readBytes < totalBytes) { is.read( &buff[readBytes], totalBytes-readBytes); const int numBytesRead = is.gcount(); if ( numBytesRead <= 0) break; readBytes += numBytesRead; } // end while assert( readBytes == totalBytes); for ( int i = 0; i < sz; ++i) { int j = i * pxlChunk; // Offset into read in buffer // Read in points (with respect to origin) cv::Vec3f p( *(float*)&buff[j], // X *(float*)&buff[j+sizeof(float)], // Y *(float*)&buff[j+2*sizeof(float)]); // Z (depth) j += 3*sizeof(float); // Skip to colour bytes cv::Vec3b c( (byte)buff[j], (byte)buff[j+1], (byte)buff[j+2]); const int row = i / imgSz.width; // Integer division const int col = i % imgSz.width; cimg.at<cv::Vec3b>(row,col) = c; points.at<cv::Vec3f>(row,col) = p; dimg.at<float>(row,col) = p[2]; // Depth is just the Z value } // end for free(buff); getline( is, ln); // Read end of line } // end readImageData
int FixedLengthBuffer::read(istream& stream){ int recAddr = stream.tellg(); stream.clear(); this->clear(); this->packing = 0; //FALSE stream.read(this->buffer, this->bufferSize); if(!stream.good()){ stream.clear(); return recAddr; } return recAddr; }
void VHP_RowInfo::readData(istream &in) { unsigned short n; in.read((char *)&n,sizeof(n)); if (n != nbin) { if (nbin > 0) { delete [] pix; delete [] org; nbin = 0; } } if (n < 1) { return; } if (!nbin) { nbin = n; pix = new unsigned short [nbin+1]; org = new unsigned char [nbin]; } in.read((char *)pix,(nbin+1)*sizeof(unsigned short)); in.read((char *)org,nbin*sizeof(unsigned char)); }
//-------------------------------------------------- bool ofBuffer::set(istream & stream){ clear(); if( stream.bad() ) return false; char aux_buffer[1024]; std::streamsize size = 0; stream.read(aux_buffer, 1024); std::streamsize n = stream.gcount(); while( n > 0 ){ // we resize to size+1 initialized to 0 to have a 0 at the end for strings buffer.resize(size+n+1,0); memcpy(&(buffer[0])+size,aux_buffer,n); size += n; if( stream ){ stream.read(aux_buffer, 1024); n = stream.gcount(); } else n = 0; } return true; }
PWIZ_API_DECL string SHA1Calculator::hash(istream& is) { CSHA1 sha1; is.clear(); is.seekg(0); unsigned char buffer[65535]; while (is && is.read(reinterpret_cast<char*>(buffer), 65535)) sha1.Update(buffer, 65535u); sha1.Update(buffer, is.gcount()); sha1.Final(); return formatHash(sha1); }
static bool unserialize(string &str,istream &input) { static int len; if (!Serialize::unserialize(len,input)) { cerr << "Could not read the length of the string" << endl; return false; } str.resize(len); input.read(const_cast<char*>(str.data()),len); return true; };
void Mach::ReadParams(istream &inpf, bool with_alloc) { debug0("*** read params of type Mach\n"); switch (Mach::fileid) { case file_header_version1: // read int but store ulong unsigned int itmp; inpf.read((char*) &itmp, sizeof(int)); nb_forw = (ulong) itmp; inpf.read((char*) &itmp, sizeof(int)); nb_backw = (ulong) itmp; debug2("V1 read int counters %lu/%lu\n",nb_forw,nb_backw); break; case file_header_version2: case file_header_version3: case file_header_version4: inpf.read((char*) &nb_forw, sizeof(ulong)); inpf.read((char*) &nb_backw, sizeof(ulong)); debug2("V2 to V4 read ulong counters %lu/%lu\n",nb_forw,nb_backw); break; default: Error("internal error, fileid is unset"); } }
void MidiEvent::ReadStandard(istream &stream) { switch (Type()) { case MidiEventType_NoteOff: case MidiEventType_NoteOn: case MidiEventType_Aftertouch: case MidiEventType_Controller: case MidiEventType_PitchWheel: stream.read(reinterpret_cast<char*>(&m_data1), sizeof(unsigned char)); stream.read(reinterpret_cast<char*>(&m_data2), sizeof(unsigned char)); break; case MidiEventType_ProgramChange: case MidiEventType_ChannelPressure: stream.read(reinterpret_cast<char*>(&m_data1), sizeof(unsigned char)); m_data2 = 0; break; default: throw MidiError(MidiError_UnknownEventType); } }
DecisionTreePtr DecisionTree::readC5(istream& in, AttributeSpec* spec) { int tag; in.read((char*)&tag, sizeof(int)); if (memcmp((char *)&tag, "id=", 3) == 0) { in.seekg (0, ios::beg); return readC5Text(in, spec); } in.seekg(0, ios::beg); return readC5Bin(in, spec); }
void MatchIndex::Load(istream &ifs) { size_t size; ifs.read(( char*)&size, sizeof(size)); Context.resize(size); size_t len; for(size_t i=0; i<size; i++) { ifs.read(( char*)&len, sizeof(len)); std::string str; str.resize(len); ifs.read(( char*)&str[0], len); Context[i]=UString(str,UString::UTF_8); } ifs.read(( char*)&size, sizeof(size)); for(size_t i=0; i<size; i++) { size_t len; ifs.read(( char*)&len, sizeof(len)); std::string str; str.resize(len); ifs.read(( char*)&str[0], len); PostingList ps; ifs>>ps; prefixVec.insert(make_pair(UString(str,UString::UTF_8), ps) ); } build=true; }
int MessageProcessHelper::ProcessMessageStream( istream& istrm ) { PackageHajackStream hajack; int ret; unsigned have; z_stream strm; unsigned char in[CHUNK]; unsigned char out[CHUNK]; /* 初始化压缩状态 */ strm.zalloc = Z_NULL; strm.zfree = Z_NULL; strm.opaque = Z_NULL; strm.avail_in = 0; strm.next_in = Z_NULL; ret = inflateInit(&strm); if (ret != Z_OK) return ret; /* 解压,直到流的结尾 */ do { istrm.read((char*)in,CHUNK); strm.avail_in = istrm.gcount(); if (strm.avail_in == 0) break; strm.next_in = in; do { strm.avail_out = CHUNK; strm.next_out = out; ret = inflate(&strm, Z_NO_FLUSH); switch (ret) { case Z_NEED_DICT: ret = Z_DATA_ERROR; /* and fall through */ case Z_DATA_ERROR: case Z_MEM_ERROR: (void)inflateEnd(&strm); return ret; } have = CHUNK - strm.avail_out; if(!hajack.WriteBlock((const char*)out,have,0)) { (void)inflateEnd(&strm); return Z_ERRNO; } } while (strm.avail_out == 0); } while (ret != Z_STREAM_END); (void)inflateEnd(&strm); return ret == Z_STREAM_END ? Z_OK : Z_DATA_ERROR; }
NetStream::STREAM_TYPE NetStream::classifyStream(istream& s) { char buf[3]; s.read(buf,3); STREAM_TYPE ret; if(strncmp(buf,"FLV",3)==0) ret=FLV_STREAM; else threadAbort(); s.seekg(0); return ret; }
string ReadString( istream &in ) { unsigned int len = ReadUInt( in ); string out; if ( len > 0x4000 ) throw runtime_error("String too long. Not a NIF file or unsupported format?"); if ( len > 0 ) { out.resize(len); in.read( (char*)&out[0], len ); if (in.fail()) throw runtime_error("premature end of stream"); } return out; }
NetStream::STREAM_TYPE NetStream::classifyStream(istream& s) { char buf[3]; s.read(buf,3); STREAM_TYPE ret; if(strncmp(buf,"FLV",3)==0) ret=FLV_STREAM; else throw ParseException("File signature not recognized"); s.seekg(0); return ret; }
bool drwnDataRecord::read(istream& is) { int rows = 0; int cols = 0; is.read((char *)&rows, sizeof(int)); DRWN_ASSERT_MSG(!is.fail() && (rows >= 0), (_owner ? _owner->name().c_str() : "<unknown>")); _structure.resize(rows); if (rows > 0) { is.read((char *)_structure.data(), rows * sizeof(int)); } DRWN_ASSERT(!is.fail()); is.read((char *)&rows, sizeof(int)); is.read((char *)&cols, sizeof(int)); DRWN_ASSERT(!is.fail() && (rows >= 0) && (cols >= 0)); _data.resize(rows, cols); if (rows > 0) { is.read((char *)_data.data(), rows * cols * sizeof(double)); } DRWN_ASSERT(!is.fail()); is.read((char *)&rows, sizeof(int)); DRWN_ASSERT(!is.fail() && (rows >= 0)); _objective.resize(rows); if (rows > 0) { is.read((char *)_objective.data(), rows * sizeof(double)); } is.read((char *)&rows, sizeof(int)); is.read((char *)&cols, sizeof(int)); DRWN_ASSERT(!is.fail() && (rows >= 0) && (cols >= 0)); _gradient.resize(rows, cols); if (rows > 0) { is.read((char *)_gradient.data(), rows * cols * sizeof(double)); } DRWN_ASSERT(!is.fail()); _bDirty = false; return true; }
void ezw_decoder::initial_decode(vector<unsigned char>& dest, istream& in, const ezw_header& header) { if (header.enc_type == HUFFMAN) { // --- Need to read in huffman buffer then decode to rle buffer. -- // vector<unsigned char> huff_buffer(header.enc_size); in.read((char*)&huff_buffer[0], header.enc_size); dest.resize(header.rle_size); Huffman_Uncompress(&huff_buffer[0], &dest[0], header.enc_size, header.rle_size); } else { dest.resize(header.rle_size); in.read((char*)&dest[0], header.rle_size); } vector<unsigned char> rle_buffer(header.ezw_size); rle_buffer.swap(dest); const size_t derle = RLE_Uncompress(&rle_buffer[0], &dest[0], header.rle_size); if (derle != header.ezw_size) { cerr << derle << " != " << header.ezw_size << endl; exit(1); } }
const char* LgScriptReader::read(State&, size_t *sz) { if (extraline) { extraline = false; *sz = 1; return "\n"; } if (infile->eof()) return NULL; infile->read(buff, sizeof(buff)); *sz = infile->gcount(); return buff; }
bool DSA1Intro_Entry::read(istream& strm) { u8 length; char buf[13]; length = read8(strm); if (length < 1 || length > 12) { // Eintrag überspringen strm.seekg(0x20-1, std::ios::cur); return false; } strm.read(buf, 12); buf[length] = '\0'; name = buf; length = read8(strm); if (length < 1 || length > 12) { // Eintrag überspringen strm.seekg(0x20-14, std::ios::cur); return false; } strm.read(buf, 12); buf[length] = '\0'; volname = buf; offset = read32(strm); size = read16(strm); return true; }
_NAME_BEGIN bool BMPHandler::doCanRead(istream& stream) const noexcept { std::uint8_t hdr[2]; if (stream.read((char*)hdr, sizeof(hdr))) { return hdr[0] == 'B' && hdr[1] == 'M'; } return false; }
string ReadString(istream& input) { int16_t len = ReadSwap<int16_t>(input); if( len == 0 ) return string(""); char *buf = new char[len+1]; wchar_t *wbuf = new wchar_t[len+1]; input.read(buf,len); buf[len] = '\0'; mbstowcs( wbuf , buf , len+1 ); wstring wstr(wbuf); delete[] wbuf; delete[] buf; return string(wstr.begin(),wstr.end() ); }
void readMaterial( istream &is, chunkSize size) { TAB(1); DOUT(1) << "material : "; char *material = readString(is); DOUT(1) << '\'' << material << '\''; unsigned short number; is.read((char *) (void *) &number,2); DOUT(1) << ' ' << number << " faces." << endl; for (int n=0; n<number; n++) { unsigned short index; is.read((char *) (void *) &index,2); TAB(2); DOUT(2) << index << endl; } }
int VariableLengthBuffer::Read(istream & stream) // write the number of bytes in the buffer field definitions // the record length is represented by an unsigned short value { if(stream.eof()) return -1; int recaddr = stream.tellg(); Clear(); unsigned short bufferSize; stream.read((char *) &bufferSize, sizeof(bufferSize)); if(!stream.good()){ stream.clear(); return -1; } BufferSize = bufferSize; if(BufferSize > MaxBytes) return -1; // buffer overflow stream.read(Buffer, BufferSize); if(!stream.good()){ stream.clear(); return -1; } return recaddr; }
void LineBuffer::read(istream &stream) { while (true) { streamsize space = bufferSize - fill; stream.read(buffer + fill, space); streamsize bytes = stream.gcount(); if (!bytes) break; fill += bytes; extractLines(); if (bytes < space) break; } }
bool CanberraCnfDataSet::check(istream &f, string*) { int acq_offset = 0; f.ignore(112); int pos = 112; char buf[48]; while (!f.eof()) { f.read(buf, 48); if (f.gcount() != 48) return false; if ((buf[1] != 0x20 || buf[2] != 0x01) && buf[1] != 0 && buf[2] != 0) return false; pos += 48; if (buf[0] == 0) { acq_offset = from_le<uint32_t>(buf+10); break; } } if (acq_offset <= pos) return false; f.ignore(acq_offset - pos); f.read(buf, 48); return (!f.eof() && f.gcount() == 48 && buf[0] == 0 && buf[1] == 0x20); }