void BackgroundRemovedImage::writeHeader(std::ofstream& os) {

    HeaderInfoT hi;

    hi.headersize = headerSizeInBytes;
    hi.idcode = idCode();


    //fill in header with 0s
    std::ofstream::pos_type cur_loc = os.tellp();
    char zero[headerSizeInBytes] = {0};
    os.write(zero, headerSizeInBytes);
    std::ofstream::pos_type end_loc = os.tellp();

    //return to the beginning of the header and write data
    os.seekp(cur_loc);

    if (differencesFromBackground.empty()) {
        hi.depth = 0;
        hi.nchannels = 0;
        hi.numims = 0;
    } else {
        hi.depth = differencesFromBackground.front().second->depth;
        hi.nchannels = differencesFromBackground.front().second->nChannels;
        hi.numims = differencesFromBackground.size();
    }
    os.write((char *) &hi, sizeof(hi));
    if (metadata != NULL) {
        metadata->toDisk(os);
    }
    os.seekp(end_loc);
    
}
示例#2
0
文件: PeLibAux.cpp 项目: CBaiz/PeLib
	unsigned int fileSize(std::ofstream& file)
	{
		unsigned int oldpos = file.tellp();
		file.seekp(0, std::ios::end);
		unsigned int filesize = file.tellp();
		file.seekp(oldpos, std::ios::beg);
		return filesize;
	}
示例#3
0
 static void writeArrayToBinaryFileStream(std::ofstream& fileStream,
         const T* array, const size_t sizeOfArray) {
     assert_gt(sizeOfArray, 0);
     auto bufferSize = (std::streamsize)(sizeOfArray * sizeof(T));
     auto previousNumberOfBytes = fileStream.tellp();
     assert_true(fileStream.write(reinterpret_cast<const char*>(array), bufferSize));
     auto currentNumberOfBytes = fileStream.tellp();
     assert_eq(bufferSize, currentNumberOfBytes - previousNumberOfBytes);
 }
// Write out the LLVM symbol table as an archive member to the file.
void
Archive::writeSymbolTable(std::ofstream& ARFile) {

  // Construct the symbol table's header
  ArchiveMemberHeader Hdr;
  Hdr.init();
  memcpy(Hdr.name,ARFILE_LLVM_SYMTAB_NAME,16);
  uint64_t secondsSinceEpoch = sys::TimeValue::now().toEpochTime();
  char buffer[32];
  sprintf(buffer, "%-8o", 0644);
  memcpy(Hdr.mode,buffer,8);
  sprintf(buffer, "%-6u", sys::Process::GetCurrentUserId());
  memcpy(Hdr.uid,buffer,6);
  sprintf(buffer, "%-6u", sys::Process::GetCurrentGroupId());
  memcpy(Hdr.gid,buffer,6);
  sprintf(buffer,"%-12u", unsigned(secondsSinceEpoch));
  memcpy(Hdr.date,buffer,12);
  sprintf(buffer,"%-10u",symTabSize);
  memcpy(Hdr.size,buffer,10);

  // Write the header
  ARFile.write((char*)&Hdr, sizeof(Hdr));

#ifndef NDEBUG
  // Save the starting position of the symbol tables data content.
  unsigned startpos = ARFile.tellp();
#endif

  // Write out the symbols sequentially
  for ( Archive::SymTabType::iterator I = symTab.begin(), E = symTab.end();
        I != E; ++I)
  {
    // Write out the file index
    writeInteger(I->second, ARFile);
    // Write out the length of the symbol
    writeInteger(I->first.length(), ARFile);
    // Write out the symbol
    ARFile.write(I->first.data(), I->first.length());
  }

#ifndef NDEBUG
  // Now that we're done with the symbol table, get the ending file position
  unsigned endpos = ARFile.tellp();
#endif

  // Make sure that the amount we wrote is what we pre-computed. This is
  // critical for file integrity purposes.
  assert(endpos - startpos == symTabSize && "Invalid symTabSize computation");

  // Make sure the symbol table is even sized
  if (symTabSize % 2 != 0 )
    ARFile << ARFILE_PAD;
}
std::streamoff
fileSize(std::ofstream& file)
{
  std::streamoff curr = file.tellp();

  file.seekp(0, std::ios::end);
  std::streamoff size = file.tellp();
  file.seekp(0, std::ios::beg);
  size -= file.tellp();

  file.seekp(curr, std::ios::beg);
  return size;
}
示例#6
0
		void end(char*,std::size_t){
			file
				<<"{"
				<<"\"type\":\"FeatureCollection\","
				<<"\"features\":[";

			bool done=false;
			for(std::size_t idx=0;idx<lon.size()&&!done;++idx){
				file
					<<"{"
					<<"\"type\":\"Feature\","
					<<"\"geometry\":"
					<<"{"
					<<"\"type\":\"Point\","
					<<"\"coordinates\":["<<lon[idx]<<","<<lat[idx]<<"]"
					<<"}"
					<<"}";
				file.flush();
				if((std::size_t)(file.tellp())+file_thresh>=file_lim)
					done=true;
				else
					file<<",";
			}

			file
				<<"]"
				<<"}";
		}
  void BezierCurves::write(std::ofstream& file)
  {
    int type = BEZIER_CURVES;
    file.write((char*)&type,sizeof(int));
    file.write((char*)&numTimeSteps,sizeof(int));
    file.write((char*)&numVertices,sizeof(int));
    file.write((char*)&numCurves,sizeof(int));

    for (size_t j=0; j<numTimeSteps; j++) {
      while ((file.tellp() % 16) != 0) { char c = 0; file.write(&c,1); }
      for (size_t i=0; i<numVertices; i++) file.write((char*)&vertex(i,j),sizeof(Vec3fa));  
    }

    while ((file.tellp() % 16) != 0) { char c = 0; file.write(&c,1); }
    for (size_t i=0; i<numCurves; i++) file.write((char*)&curve(i),sizeof(int));  
  }
示例#8
0
	static void
	_mark_session (std::ofstream& fs)
	{
		if (!fs) return;
		
		std::time_t t = std::time (nullptr);
		struct tm lt;
		localtime_r (&t, &lt);
		
		if (fs.tellp () > 0)
			fs << "\n\n" << std::flush;
		
		fs <<
"********************************************************************************\n"
"    New Session:\n"
"      @ " << std::setfill ('0')
 					 << std::setw (2) << lt.tm_hour << ":"
 					 << std::setw (2) << lt.tm_min << ":"
 					 << std::setw (2) << lt.tm_sec << "   "
 					 << std::setw (2) << lt.tm_mon << "/"
 					 << std::setw (2) << lt.tm_mday << "/"
 					 << (lt.tm_year + 1900) << std::setfill (' ') << "\n" <<
"********************************************************************************\n"
			 << std::endl;
	}
示例#9
0
  std::ostream& LoggerImpl::getAppender()
  {
    if (pipe)
      return *pipe;
    else if (!fname.empty())
    {
      if (!outfile.is_open())
      {
        outfile.clear();
        outfile.open(fname.c_str(), std::ios::out | std::ios::app);
        counter.resetCount(outfile.tellp());
      }

      if (maxfilesize > 0)
      {
        if (counter.getCount() > maxfilesize)
        {
          doRotate();
          counter.resetCount();
        }
        return tee;
      }
      else
        return outfile;
    }
    else if (loghost.isConnected())
      return udpmessage;
    else
      return std::cerr;
  }
示例#10
0
			static void append(
				std::ofstream & out, std::string const & filename,
				std::vector< IndexEntry > & index
			)
			{
				uint64_t const indexpos = IndexLoader::getIndexPos(filename);
				libmaus2::autoarray::AutoArray< IndexEntry > subindex = IndexLoader::loadIndex(filename);
				
				if ( subindex.size() )
				{
					uint64_t const datapos = subindex[0].pos;
					uint64_t const datalen = indexpos-datapos;
					
					// shift all towards zero
					for ( uint64_t i = 0; i < subindex.size(); ++i )
						subindex[i].pos -= datapos;
						
					uint64_t const ndatapos = out.tellp();

					for ( uint64_t i = 0; i < subindex.size(); ++i )
						subindex[i].pos += ndatapos;
						
					std::ifstream istr(filename.c_str(),std::ios::binary);
					istr.seekg(datapos,std::ios::beg);
					::libmaus2::util::GetFileSize::copy ( istr, out, datalen, 1 );
					
					for ( uint64_t i = 0; i < subindex.size(); ++i )
						index.push_back(subindex[i]);
				}
			}
示例#11
0
//Function that writes the line with name age sex and time taken by the player into the file puzzle_NxNyyy
void write_resultes_into_the_file(std::ofstream& myfile, string time){
	int ii = 0;
	vector<string> vec = Tokenize(time);
	int here = myfile.tellp();
	myfile << "                               ";
	for (std::vector<std::string>::size_type a = 0; a < vec.size(); ++a){
		switch (ii)
		{		
		case 0:
			myfile.seekp ((here + 4) );
			myfile << vec.at(a);
			break;
		case 1:
			myfile.seekp ((here + 25 ));
			myfile << vec.at(a);
			break;
		case 2: 
			myfile.seekp ((here + 29 ));
			myfile << vec.at(a);
			break;
		case 3: 
			myfile.seekp ((here + 31 ));
			myfile << vec.at(a);
			break;
		}
		ii++;
	}
}
示例#12
0
std::ofstream& Logger::LogStart(TLogLevel level){ 
	char buffer[64];
	
	if (logger_os.tellp() >= logger_max_file_size){
		logger_os.close();
		std::string renamed_file = logger_filename;
		renamed_file.append(".backup");
		
		if (file_exists(renamed_file.c_str())) remove (renamed_file.c_str());

		rename(logger_filename.c_str(), renamed_file.c_str());
		remove (logger_filename.c_str());
	}	

	if (!file_exists(logger_filename.c_str())){
		logger_os.close();
		logger_os.open(logger_filename.c_str(),  std::ios::out | std::ios::app);
		if (logger_os.is_open()){
			logger_messageLevel = loggger_wantedLevel;
		}else{
			logger_messageLevel = logNone; //prevent from sending data into the not opened stream
		}
	}

	time_t thetime = time(0);
	tm * ptm = std::localtime(& thetime);
	strftime(buffer, sizeof(buffer), "%d.%m.%Y %H:%M:%S", ptm);// Format: 15.06.2009 20:20:00 

	logger_os << "-" << buffer << " " << ToString(level) << ": ";

	return logger_os;
}
示例#13
0
bool ZipArchive::writeCentralDirectory(std::ofstream& ofs,
                                       const std::vector<ZipArchive::ArchivedFile>& files)
{
    std::streampos offsetCD = ofs.tellp();
    size_t sizeCD = 0;
    bool error = false;
    for (size_t i = 0; i < files.size(); ++i) {
        const ZipFileHeader& fileHeader = files[i].zipFileHader_;
        ofs.write(reinterpret_cast<const char*>(&fileHeader), SIZE_ZIPFILEHEADER);
        sizeCD += SIZE_ZIPFILEHEADER;
        error = ofs.fail();

        size_t stringSize = files[i].fileName_.size();
        sizeCD += stringSize;
        if ((error == false) && (stringSize > 0) && (stringSize == fileHeader.filenameLength)) {
            ofs.write(files[i].fileName_.c_str(), stringSize);
            error = ofs.fail();
        }

        stringSize = files[i].fileExtra_.size();
        sizeCD += stringSize;
        if ((error == false) && (stringSize > 0) && (stringSize == fileHeader.extraFieldLength)) {
            ofs.write(files[i].fileExtra_.c_str(), stringSize);
            error = ofs.fail();
        }

        stringSize = files[i].fileComment_.size();
        sizeCD += stringSize;
        if ((error == false) && (stringSize > 0) && (stringSize == fileHeader.fileCommentLength)) {
            ofs.write(files[i].fileComment_.c_str(), stringSize);
            error = ofs.fail();
        }

        if (error == true) {
            LERROR("writeCentralDirectory(): failed to write Central Directory Entry in zip archive!");
            break;
        }
    }   // for

    ZipEOCDHeaderRecord eocd;
    eocd.signature = SIGNATURE_ZIPEOCDHEADERRECORD;
    eocd.numberOfDisk = 0;
    eocd.numberOfDiskWithStartOfCD = 0;
    eocd.numberOfEntriesInThisCD = static_cast<uint16_t>(files.size());
    eocd.numberOfEntriesInCD = static_cast<uint16_t>(files.size());
    eocd.sizeOfCD = static_cast<uint32_t>(sizeCD);
    eocd.offsetStartCD = (offsetCD >= 0) ? static_cast<uint32_t>(offsetCD) : 0;
    eocd.commmentLength = 0;

    if (error == false) {
        ofs.write(reinterpret_cast<char*>(&eocd), SIZE_ZIPEOCDRECORD);
        error = ofs.fail();
    }

    return (! error);
}
示例#14
0
  void QuadMesh::write(std::ofstream& file)
  {
    int type = QUAD_MESH;
    file.write((char*)&type,sizeof(int));
    file.write((char*)&numTimeSteps,sizeof(int));
    int numVerts = numVertices();
    file.write((char*)&numVerts,sizeof(int));
    int numQuads = quads.size();
    file.write((char*)&numQuads,sizeof(int));

    for (size_t j=0; j<numTimeSteps; j++) {
      while ((file.tellp() % 16) != 0) { char c = 0; file.write(&c,1); }
      for (size_t i=0; i<numVerts; i++) file.write((char*)vertexPtr(i,j),sizeof(Vec3fa));  
    }

    while ((file.tellp() % 16) != 0) { char c = 0; file.write(&c,1); }
    for (size_t i=0; i<numQuads; i++) file.write((char*)&quad(i),sizeof(Quad));  

  }
示例#15
0
  void TriangleMesh::write(std::ofstream& file)
  {
    int type = TRIANGLE_MESH;
    file.write((char*)&type,sizeof(int));
    file.write((char*)&numTimeSteps,sizeof(int));
    int numVerts = numVertices();
    file.write((char*)&numVerts,sizeof(int));
    int numTriangles = triangles.size();
    file.write((char*)&numTriangles,sizeof(int));

    for (size_t j=0; j<numTimeSteps; j++) {
      while ((file.tellp() % 16) != 0) { char c = 0; file.write(&c,1); }
      for (size_t i=0; i<numVerts; i++) file.write((char*)vertexPtr(i,j),sizeof(Vec3fa));  
    }

    while ((file.tellp() % 16) != 0) { char c = 0; file.write(&c,1); }
    for (size_t i=0; i<numTriangles; i++) file.write((char*)&triangle(i),sizeof(Triangle));  

  }
示例#16
0
int _LogAppenderBase::getLogSizeKBytes()
{
  if (!out.is_open())
    {
      return 0;
    }
  else
    {
      return out.tellp() / 1024;
    }
}
示例#17
0
  void LineSegments::write(std::ofstream& file)
  {
    int type = LINE_SEGMENTS;
    file.write((char*)&type,sizeof(int));
    file.write((char*)&numTimeSteps,sizeof(int));
    size_t numVerts = numVertices();
    file.write((char*)&numVerts,sizeof(int));
    file.write((char*)&numPrimitives,sizeof(int));

    for (size_t j=0; j<numTimeSteps; j++) {
      while ((file.tellp() % 16) != 0) { char c = 0; file.write(&c,1); }
      for (size_t i=0; i<vertices[j].size(); i++) {
        Vec3fa v = vertex(i,j);
        file.write((char*)&v,sizeof(Vec3fa));
      }
    }

    while ((file.tellp() % 16) != 0) { char c = 0; file.write(&c,1); }
    for (size_t i=0; i<numPrimitives; i++) file.write((char*)&segment(i),sizeof(int));
  }
示例#18
0
 void open(const std::string& a_fname, bool a_append = false) {
     using std::ios;
     using std::ios_base;
     if (m_open) return;
     m_file.exceptions(ios::failbit | ios::badbit);
     ios_base::openmode l_mode = ios::out | ios::binary;
     if (a_append)
         l_mode |= ios::app;
     else
         l_mode |= ios::trunc;
     m_file.open(a_fname.c_str(), l_mode);
     m_offset = m_file.tellp();
     m_open = true;
     m_fname = a_fname;
     m_buf.reset();
     BOOST_ASSERT(m_buf.capacity() > 0);
 }
示例#19
0
void create_header(std::vector<fs::path> const& files, std::vector<boost::uintmax_t> const& file_sizes, std::ofstream& archive)
{
  std::uint32_t const body_end = static_cast<std::uint32_t>(archive.tellp());
  write_trivial(archive, files.size());
  auto const size = files.size();
  std::int32_t pos = 0;
  for (auto i = 0U; i < size; ++i) {
    write_trivial(archive, pos);
    std::uint32_t s = static_cast<std::uint32_t>(file_sizes[i]);
    write_trivial(archive, s);
    s = static_cast<std::uint32_t>(files[i].string().size());
    write_trivial(archive, s);
    archive.write(files[i].string().c_str(), files[i].string().size());
    pos += static_cast<int>(file_sizes[i]);
  }
  write_trivial(archive, body_end);
}
示例#20
0
void HistoryManager::appendEntryToFile(std::ofstream &os, bool isSent, const boost::posix_time::ptime &saveTime, const std::string &content)
{
    if(saveTime.is_not_a_date_time())
        return;
    if(os.tellp() != 0)
        os << std::endl;
    os << "[" << FormattingUtils::dateToStr(saveTime) << "]";
    if(isSent)
    {
        os << "-S-";
    }
    else
    {
        os << "-R-";
    }
    os << content;
}
示例#21
0
 /*
     Handles Parameter creation / addition / write
  */
 static void __SetupAndWriteAnimationParameter(shared_ptr <GLTFAnimation> cvtAnimation,
                                               const std::string& parameterSID,
                                               const std::string& parameterType,
                                               shared_ptr <GLTFBufferView> bufferView,
                                               std::ofstream &animationsOutputStream) {
     //setup
     shared_ptr <GLTFAnimation::Parameter> parameter(new GLTFAnimation::Parameter(parameterSID));
     parameter->setCount(cvtAnimation->getCount());
     parameter->setType(parameterType);
     __SetupSamplerForParameter(cvtAnimation, parameter.get());
     
     cvtAnimation->parameters()->push_back(parameter);
     
     //write
     parameter->setByteOffset(static_cast<size_t>(animationsOutputStream.tellp()));
     animationsOutputStream.write((const char*)( bufferView->getBufferDataByApplyingOffset()),
                                  bufferView->getByteLength());
 }
示例#22
0
	Printer(std::string f){
		i=0;
		sub = n.subscribe("/icp/world", 20, &Printer::CloudPrinter_Callback_onefile,this);
		
		
		ply_file.open (f.data());
		ply_file << "ply\n";
		ply_file << "format ascii 1.0\n";
		ply_file << "element vertex ";  pos=ply_file.tellp();
		ply_file << "                                           \n";
		
		ply_file << "property float x\n";
		ply_file << "property float y\n";
		ply_file << "property float z\n";
		ply_file << "property uchar red\n";
		ply_file << "property uchar green\n";
		ply_file << "property uchar blue\n";
		ply_file << "end_header\n";
	
	}
示例#23
0
  void LoggerImpl::doRotate()
  {
    outfile.clear();
    outfile.close();

    // ignore unlink- and rename-errors. In case of failure the
    // original file is reopened

    std::string newfilename = mkfilename(maxbackupindex);
    ::unlink(newfilename.c_str());
    for (unsigned idx = maxbackupindex; idx > 0; --idx)
    {
      std::string oldfilename = mkfilename(idx - 1);
      ::rename(oldfilename.c_str(), newfilename.c_str());
      newfilename = oldfilename;
    }

    ::rename(fname.c_str(), newfilename.c_str());

    outfile.open(fname.c_str(), std::ios::out | std::ios::app);
    counter.resetCount(outfile.tellp());
  }
示例#24
0
文件: main.cpp 项目: 9heart/DT3
void processFileProcess (std::ofstream &outfile, FileProcess &f, std::list<std::string> &compression_types, int64_t &total_compressed_size, int64_t &total_uncompressed_size)
{
    unsigned char buffer[1024*8];

    // Get location of beginning of file
    f.start = outfile.tellp();

    std::cout << "Processing " << f.file << " at location " << f.start << std::endl;


    // Check if this is an extension that should be compressed
    std::string ext = f.file.substr(f.file.find_last_of('.')+1);
    if ( std::find(compression_types.begin(), compression_types.end(), ext) != compression_types.end()) {

        std::cout << "  Compressing... ";

        // Read the entire file into a buffer
        std::vector<unsigned char> uncompressed_buffer;
        std::vector<unsigned char> compressed_buffer;

        std::string path = f.path + SEP + f.file;
        std::ifstream infile( path.c_str(), std::ios::in | std::ios::binary );

        int size = -1;
        while (!infile.eof() && size) {
            infile.read((char *) buffer, sizeof(buffer));
            size = infile.gcount();

            uncompressed_buffer.insert(uncompressed_buffer.end(), buffer, buffer+size);
        }

        // Use zlib to compress the buffer
        z_stream strm;
        strm.zalloc = 0;
        strm.zfree = 0;
        strm.next_in = reinterpret_cast<Bytef *>(&uncompressed_buffer[0]);
        strm.avail_in = uncompressed_buffer.size();
        strm.next_out = buffer;
        strm.avail_out = sizeof(buffer);

        deflateInit(&strm, Z_BEST_COMPRESSION);

        // Compress file
        while (strm.avail_in != 0) {
            int res = deflate(&strm, Z_NO_FLUSH);
            assert(res == Z_OK);

            if (strm.avail_out == 0) {
                compressed_buffer.insert(compressed_buffer.end(), buffer, buffer + sizeof(buffer));
                strm.next_out = buffer;
                strm.avail_out = sizeof(buffer);
            }
        }

        // Finish off
        int deflate_res = Z_OK;
        while (deflate_res == Z_OK) {
            if (strm.avail_out == 0) {
                compressed_buffer.insert(compressed_buffer.end(), buffer, buffer + sizeof(buffer));
                strm.next_out = buffer;
                strm.avail_out = sizeof(buffer);
            }
            deflate_res = deflate(&strm, Z_FINISH);
        }

        // End the stream
        assert(deflate_res == Z_STREAM_END);
        compressed_buffer.insert(compressed_buffer.end(), buffer, buffer + sizeof(buffer) - strm.avail_out);
        deflateEnd(&strm);

        // write compressed file to package
        outfile.write( (char*) &compressed_buffer[0], compressed_buffer.size());

        // Location of end of file
        f.length = (int64_t) (outfile.tellp()) - f.start;
        f.uncompressed_length = (int64_t) uncompressed_buffer.size();

        std::cout   << "Done! Before " << uncompressed_buffer.size() << " bytes, after " << compressed_buffer.size()
                    << " bytes (" << compressed_buffer.size() * 100 / uncompressed_buffer.size() << "%)" << std::endl;

        total_compressed_size += compressed_buffer.size();
        total_uncompressed_size += uncompressed_buffer.size();

    } else {

        // Copy file into package

        std::string path = f.path + SEP + f.file;
        std::ifstream infile( path.c_str(), std::ios::in | std::ios::binary );

        assert(infile.good());

        int size = -1;
        while (!infile.eof() && size) {
            infile.read((char *) buffer, sizeof(buffer));
            size = infile.gcount();

            outfile.write((char *) buffer, size);
        }

        infile.close();

        // Location of end of file
        f.length = (int64_t) (outfile.tellp()) - f.start;
        f.uncompressed_length = (int64_t) f.length;

        total_compressed_size += f.length;
        total_uncompressed_size += f.length;
    }
}
示例#25
0
    bool GLTFMesh::writeAllBuffers(std::ofstream& verticesOutputStream, std::ofstream& indicesOutputStream)
    {
        typedef map<std::string , shared_ptr<GLTF::GLTFBuffer> > IDToBufferDef;
        IDToBufferDef IDToBuffer;
        
        shared_ptr <AccessorVector> allAccessors = this->accessors();
        
        shared_ptr <GLTFBufferView> dummyBuffer(new GLTFBufferView());
        
        PrimitiveVector primitives = this->getPrimitives();
        unsigned int primitivesCount =  (unsigned int)primitives.size();
        for (unsigned int i = 0 ; i < primitivesCount ; i++) {            
            shared_ptr<GLTF::GLTFPrimitive> primitive = primitives[i];            
            shared_ptr <GLTF::GLTFIndices> uniqueIndices = primitive->getUniqueIndices();
            
            /*
                Convert the indices to unsigned short and write the blob 
             */
            unsigned int indicesCount = (unsigned int)uniqueIndices->getCount();
            
            shared_ptr <GLTFBufferView> indicesBufferView = uniqueIndices->getBufferView();
            unsigned char* uniqueIndicesBufferPtr = (unsigned char*)indicesBufferView->getBuffer()->getData();
            uniqueIndicesBufferPtr += indicesBufferView->getByteOffset();
            
            unsigned int* uniqueIndicesBuffer = (unsigned int*) uniqueIndicesBufferPtr;
            if (indicesCount <= 0) {
                // FIXME: report error
            } else {
                size_t indicesLength = sizeof(unsigned short) * indicesCount;
                unsigned short* ushortIndices = (unsigned short*)calloc(indicesLength, 1);
                for (unsigned int idx = 0 ; idx < indicesCount ; idx++) {
                    ushortIndices[idx] = (unsigned short)uniqueIndicesBuffer[idx];
                }
                    
                uniqueIndices->setByteOffset(static_cast<size_t>(indicesOutputStream.tellp()));
                indicesOutputStream.write((const char*)ushortIndices, indicesLength);
                
                //now that we wrote to the stream we can release the buffer.
                uniqueIndices->setBufferView(dummyBuffer);
                
                free(ushortIndices);
            }
        }
        
        for (unsigned int j = 0 ; j < allAccessors->size() ; j++) {
            shared_ptr <GLTFAccessor> accessor = (*allAccessors)[j];
            shared_ptr <GLTFBufferView> bufferView = accessor->getBufferView();
            shared_ptr <GLTFBuffer> buffer = bufferView->getBuffer();
            
            if (!bufferView.get()) {
                // FIXME: report error
                return false;
            }
                        
            if (!IDToBuffer[bufferView->getBuffer()->getID().c_str()].get()) {
                // FIXME: this should be internal to accessor when a Data buffer is set
                // for this, add a type to buffers , and check this type in setBuffer , then call computeMinMax
                accessor->computeMinMax();
                
                accessor->setByteOffset(static_cast<size_t>(verticesOutputStream.tellp()));
                verticesOutputStream.write((const char*)(static_pointer_cast <GLTFBuffer> (buffer)->getData()), buffer->getByteLength());

                //now that we wrote to the stream we can release the buffer.
                accessor->setBufferView(dummyBuffer);
                
                IDToBuffer[bufferView->getBuffer()->getID().c_str()] = buffer;
            } 
        }
                
        return true;
    }
示例#26
0
bool const JSONMesh::writeAllBuffers(std::ofstream& fileOutputStream)
{
    typedef map<std::string , shared_ptr<JSONExport::JSONBuffer> > IDToBufferDef;
    IDToBufferDef IDToBuffer;

    vector <shared_ptr< JSONExport::JSONAccessor> > allAccessors = this->remappedAccessors();

    shared_ptr <JSONBuffer> dummyBuffer(new JSONBuffer(0));

    std::vector< shared_ptr<JSONExport::JSONPrimitive> > primitives = this->getPrimitives();
    unsigned int primitivesCount =  (unsigned int)primitives.size();
    for (unsigned int i = 0 ; i < primitivesCount ; i++) {
        shared_ptr<JSONExport::JSONPrimitive> primitive = primitives[i];
        shared_ptr <JSONExport::JSONIndices> uniqueIndices = primitive->getUniqueIndices();

        /*
         Convert the indices to unsigned short and write the blob
         */

        unsigned int indicesCount = (unsigned int)uniqueIndices->getCount();
        unsigned int* uniqueIndicesBuffer = (unsigned int*) static_pointer_cast <JSONDataBuffer> (uniqueIndices->getBuffer())->getData();
        if (indicesCount <= 0) {
            // FIXME: report error
        } else {
            size_t indicesLength = sizeof(unsigned short) * indicesCount;
            unsigned short* ushortIndices = (unsigned short*)malloc(indicesLength);
            for (unsigned int idx = 0 ; idx < indicesCount ; idx++) {
                ushortIndices[idx] = (unsigned short)uniqueIndicesBuffer[idx];
            }

            uniqueIndices->setByteOffset(static_cast<size_t>(fileOutputStream.tellp()));
            fileOutputStream.write((const char*)ushortIndices, indicesLength);

            //now that we wrote to the stream we can release the buffer.
            uniqueIndices->setBuffer(dummyBuffer);

            free(ushortIndices);
        }
    }

    for (unsigned int j = 0 ; j < allAccessors.size() ; j++) {
        shared_ptr <JSONExport::JSONAccessor> accessor = allAccessors[j];
        shared_ptr <JSONExport::JSONBuffer> buffer = accessor->getBuffer();

        if (!buffer.get()) {
            // FIXME: report error
            return false;
        }

        if (!IDToBuffer[buffer->getID().c_str()].get()) {
            // FIXME: this should be internal to accessor when a Data buffer is set
            // for this, add a type to buffers , and check this type in setBuffer , then call computeMinMax
            accessor->computeMinMax();

            accessor->setByteOffset(static_cast<size_t>(fileOutputStream.tellp()));
            fileOutputStream.write((const char*)(static_pointer_cast <JSONDataBuffer> (buffer)->getData()), buffer->getByteSize());

            //now that we wrote to the stream we can release the buffer.
            accessor->setBuffer(dummyBuffer);

            IDToBuffer[buffer->getID()] = buffer;
        }
    }

    return true;
}
示例#27
0
unsigned int ilf::createILF( std::istream &infile, std::ofstream &outfile )
{
    unsigned int total = 0;
    char temp[512];

    // Write form with dummy size
    unsigned int form0Position = outfile.tellp();
    writeFormHeader( outfile, 0, "INLY" );
    // Write form with dummy size
    unsigned int form1Position = outfile.tellp();
    writeFormHeader( outfile, 0, "0000" );

    while( !infile.eof() )
    {
	unsigned int nodeSize = 0;

	infile.getline( temp, 512, ':' );
	if( infile.eof() ) { break; };
	std::string objectFilename;
	infile >> objectFilename;
	std::cout << objectFilename << std::endl;
	nodeSize += static_cast<unsigned int>( objectFilename.size() + 1 );

	infile.getline( temp, 512, ':' );
	std::string objectZone;
	infile >> objectZone;
	std::cout << objectZone << std::endl;
	nodeSize += static_cast<unsigned int>( objectZone.size() + 1 );

	// 'Transform matrix:' line
	infile.getline( temp, 512, ':' );

	std::cout.flags ( std::ios_base::showpoint );
	std::cout << std::dec;
	std::cout.flags( std::ios_base::fixed );
	float x[12];
	for( unsigned int i = 0; i < 12; ++i )
	{
	    std::cout.width( 10 );
	    infile >> x[i];
	    nodeSize += sizeof( float );
	    std::cout << x[i] << " ";
	}
	std::cout << std::endl;

	// Blank line
	infile.getline( temp, 512 );

	total += writeRecordHeader( outfile, "NODE", nodeSize );
	outfile.write( objectFilename.c_str(),
		       static_cast<unsigned int>( objectFilename.size()+1 )
	    );
	outfile.write( objectZone.c_str(),
		       static_cast<unsigned int>( objectZone.size()+1 )
	    );
	outfile.write( (char*)x, sizeof( float ) * 12 );
	total += nodeSize;
    }

    // Rewrite form with proper size.
    outfile.seekp( form1Position, std::ios_base::beg );
    total += writeFormHeader( outfile, total+4, "0000" );

    // Rewrite form with proper size.
    outfile.seekp( form0Position, std::ios_base::beg );
    total += writeFormHeader( outfile, total+4, "INLY" );

    return total;
}
void DataSetHeaderWriter::WriteNextDataSetOffset(std::ofstream &os, u_int32_t pos)
{
	nextDataSetPos = os.tellp();
	FileOutput::WriteInt32(os, pos);
}
示例#29
0
int main(int argc, char *argv[]) {
  UDPConnectionServer connection(2368);
  AcquisitionThread<DataPacket> thread(connection);
  Calibration calib;
  std::shared_ptr<DataPacket> packet;
  IPC_RETURN_TYPE err;
  char dump_filename[4096];

  carmen_velodyne_ipc_initialize(argc, argv);

  carmen_velodyne_read_parameters(argc, argv);

  carmen_velodyne_set_spin_rate(spin_rate);
  
  calib_file.open(calib_path);
  if (!calib_file.is_open())
    carmen_die("\nError: Could not open %s for reading\n", calib_filename);
  calib_file >> calib;
  calib_file.close();
  
  signal(SIGINT, carmen_velodyne_sigint_handler);
  thread.start();

  double time;
  double start_time = carmen_get_time();
  int num_packets = 0;
  int start_num_packets = 0;
  int num_lost_packets = 0;
  int start_num_lost_packets = 0;
  
  while (!quit) {
    try {
      while (dump_enabled || points_publish) {
        packet = thread.getBuffer().dequeue();
        ++num_packets;

        if (dump_enabled) {
          if (!dump_file.is_open()) {
            char dump_time[1024];
            time_t local = packet->getTimestamp();
            struct tm* time = localtime(&local);

            strftime(dump_time, sizeof(dump_time), "%Y-%m-%d-%H%M%S", time);
            sprintf(dump_filename, "%s/%s.bin", dump_path, dump_time);
            dump_file.open(dump_filename, std::ios::out | std::ios::binary);
          }

          if (dump_file.is_open()) {
            long dump_filepos = dump_file.tellp();
            dump_file << *packet;
            carmen_velodyne_publish_packet(id, dump_filename,
              dump_filepos, packet->getTimestamp());
          }
          else {
            carmen_warn("\nWarning: Could not open %s for writing\n",
              dump_filename);
          }
        }

        if (points_publish) {
          VdynePointCloud pointCloud;
          Converter::toPointCloud(*packet, calib, pointCloud);
          int num_points = pointCloud.getSize();
          float x[num_points], y[num_points], z[num_points];
          std::vector<VdynePointCloud::Point3D>::const_iterator it;
          int i = 0;

          for (it = pointCloud.getPointBegin();
              it != pointCloud.getPointEnd(); ++it, ++i) {
            x[i] = it->mX;
            y[i] = it->mY;
            z[i] = it->mZ;
          }
          carmen_velodyne_publish_pointcloud(id, num_points, x, y, z,
            packet->getTimestamp());
        }

        double time = carmen_get_time();
        if (time-start_time >= 1.0) {
          num_lost_packets = thread.getBuffer().getNumDroppedElements();
          float period_num_packets = num_packets-start_num_packets;
          float period_num_lost_packets = num_lost_packets-
            start_num_lost_packets;
          
          double packet_loss = period_num_lost_packets/
            (period_num_packets+period_num_lost_packets);
          fprintf(stdout, "\rPacket loss: %6.2f%%", packet_loss*100.0);
          fflush(stdout);

          start_time = time;
          start_num_packets = num_packets;
          start_num_lost_packets = num_lost_packets;          
        }
      }
    }
    catch (IOException& exception) {
      // buffer underrun
    }

    carmen_ipc_sleep(0.0);
  }

  if (dump_file.is_open())
    dump_file.close();

  fprintf(stdout, "\n");

  return 0;
}
// Write one member out to the file.
bool
Archive::writeMember(
  const ArchiveMember& member,
  std::ofstream& ARFile,
  bool CreateSymbolTable,
  bool TruncateNames,
  bool ShouldCompress,
  std::string* ErrMsg
) {

  unsigned filepos = ARFile.tellp();
  filepos -= 8;

  // Get the data and its size either from the
  // member's in-memory data or directly from the file.
  size_t fSize = member.getSize();
  const char *data = (const char*)member.getData();
  MemoryBuffer *mFile = 0;
  if (!data) {
    mFile = MemoryBuffer::getFile(member.getPath().c_str(), ErrMsg);
    if (mFile == 0)
      return true;
    data = mFile->getBufferStart();
    fSize = mFile->getBufferSize();
  }

  // Now that we have the data in memory, update the
  // symbol table if its a bitcode file.
  if (CreateSymbolTable && member.isBitcode()) {
    std::vector<std::string> symbols;
    std::string FullMemberName = archPath.str() + "(" + member.getPath().str()
      + ")";
    Module* M = 
      GetBitcodeSymbols((const unsigned char*)data,fSize,
                        FullMemberName, Context, symbols, ErrMsg);

    // If the bitcode parsed successfully
    if ( M ) {
      for (std::vector<std::string>::iterator SI = symbols.begin(),
           SE = symbols.end(); SI != SE; ++SI) {

        std::pair<SymTabType::iterator,bool> Res =
          symTab.insert(std::make_pair(*SI,filepos));

        if (Res.second) {
          symTabSize += SI->length() +
                        numVbrBytes(SI->length()) +
                        numVbrBytes(filepos);
        }
      }
      // We don't need this module any more.
      delete M;
    } else {
      delete mFile;
      if (ErrMsg)
        *ErrMsg = "Can't parse bitcode member: " + member.getPath().str()
          + ": " + *ErrMsg;
      return true;
    }
  }

  int hdrSize = fSize;

  // Compute the fields of the header
  ArchiveMemberHeader Hdr;
  bool writeLongName = fillHeader(member,Hdr,hdrSize,TruncateNames);

  // Write header to archive file
  ARFile.write((char*)&Hdr, sizeof(Hdr));

  // Write the long filename if its long
  if (writeLongName) {
    ARFile.write(member.getPath().str().data(),
                 member.getPath().str().length());
  }

  // Write the (possibly compressed) member's content to the file.
  ARFile.write(data,fSize);

  // Make sure the member is an even length
  if ((ARFile.tellp() & 1) == 1)
    ARFile << ARFILE_PAD;

  // Close the mapped file if it was opened
  delete mFile;
  return false;
}