void Source::serialize(const Vector3 &from, const Vector3 &to, float voxelWidth, Real maxClampedAbsoluteDensity, const String &file) { Timer t; // Compress DataStreamPtr stream = Root::getSingleton().createFileStream(file); DataStreamPtr compressStream(OGRE_NEW DeflateStream(file, stream)); StreamSerialiser ser(compressStream); ser.writeChunkBegin(VOLUME_CHUNK_ID, VOLUME_CHUNK_VERSION); // Write Metadata ser.write(&from); ser.write(&to); ser.write<float>(&voxelWidth); Vector3 diagonal = to - from; size_t gridWidth = (size_t)(diagonal.x / voxelWidth); size_t gridHeight = (size_t)(diagonal.y / voxelWidth); size_t gridDepth = (size_t)(diagonal.z / voxelWidth); ser.write<size_t>(&gridWidth); ser.write<size_t>(&gridHeight); ser.write<size_t>(&gridDepth); // Go over the volume and write the density data. Vector3 pos; Real realVal; size_t x; size_t y; uint16 buffer[SERIALIZATION_CHUNK_SIZE]; size_t bufferI = 0; for (size_t z = 0; z < gridDepth; ++z) { for (x = 0; x < gridWidth; ++x) { for (y = 0; y < gridHeight; ++y) { pos.x = x * voxelWidth + from.x; pos.y = y * voxelWidth + from.y; pos.z = z * voxelWidth + from.z; realVal = Math::Clamp<Real>(getValue(pos), -maxClampedAbsoluteDensity, maxClampedAbsoluteDensity); buffer[bufferI] = Bitwise::floatToHalf(realVal); bufferI++; if (bufferI == SERIALIZATION_CHUNK_SIZE) { ser.write<uint16>(buffer, SERIALIZATION_CHUNK_SIZE); bufferI = 0; } } } } if (bufferI > 0) { ser.write<uint16>(buffer, bufferI); } LogManager::getSingleton().stream() << "Time for serialization: " << t.getMilliseconds() << "ms"; ser.writeChunkEnd(VOLUME_CHUNK_ID); }
bool BSCLib::compressData(uint8 *& out, size_t & outSize, const uint8 * in, size_t inSize) { Stream::MemoryBlockStream inStream(in, inSize); if (out == 0) { Stream::NullOutputStream outStream; if (!compressStream(outStream, inStream)) return false; if (outSize) { outSize = (size_t)outStream.fullSize(); return setError(UnexpectedEOD); } // Then allocate the output buffer size out = new uint8[outStream.fullSize()]; outSize = (size_t)outStream.fullSize(); inStream.setPosition(0); } // Compress the stream now Stream::MemoryBlockOutStream finalStream(out, (uint64)outSize); return compressStream(finalStream, inStream); }
void ManipulatorTerrain::Serialize( rapidxml::xml_document<>* doc, rapidxml::xml_node<>* XMLNode ) { String strWorldSize = Ogre::StringConverter::toString(GetWorldSize()); String strTerrainSize = Ogre::StringConverter::toString(GetMapSize()); float pixelError = ManipulatorSystem.GetScene()->GetTerrainOption()->getMaxPixelError(); String strPixelError = Ogre::StringConverter::toString(pixelError); XMLNode->append_attribute(doc->allocate_attribute("worldSize", doc->allocate_string(strWorldSize.c_str()))); XMLNode->append_attribute(doc->allocate_attribute("mapSize", doc->allocate_string(strTerrainSize.c_str()))); XMLNode->append_attribute(doc->allocate_attribute("tuningMaxPixelError", doc->allocate_string(strPixelError.c_str()))); //保存地形数据 std::wstring fullPath(ManipulatorSystem.GenerateSceneFullPath()); fullPath += L"terrain.dat"; Ogre::DataStreamPtr stream = Ogre::Root::getSingleton().createFileStream(Utility::UnicodeToEngine(fullPath), Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, true); Ogre::DataStreamPtr compressStream(new Ogre::DeflateStream(Utility::UnicodeToEngine(fullPath), stream)); Ogre::StreamSerialiser ser(compressStream); ManipulatorSystem.GetScene()->GetTerrain()->save(ser); }
//---------- void Sender::compressLoop() { uint32_t frameIndex = 0; while (this->threadsRunning) { Message message; while (this->appToCompressor->receive(message)) { Packet packet; packet.header.packetIndex = 0; packet.header.frameIndex = frameIndex; struct { size_t offset = 0; size_t availableBytes = Packet::MaxPayloadSize; } payloadState; if (!this->getCodec().isValid()) { OFXSQUASHBUDDIES_ERROR << "Codec [" << this->getCodec().getName() << "] is not valid. Are you sure you have the plugins installed correctly?"; continue; } ofxSquash::Stream compressStream(this->getCodec(), ofxSquash::Direction::Compress, [this, &packet, &payloadState](const ofxSquash::WriteFunctionArguments & args) { //copy incoming data and split into packets struct { uint8_t * readPosition; size_t availableBytes; } inputState; inputState.readPosition = (uint8_t*)args.data; inputState.availableBytes = args.size; while (inputState.availableBytes > 0) { auto bytesToCopy = min<size_t>(inputState.availableBytes, payloadState.availableBytes); memcpy(packet.payload + payloadState.offset, inputState.readPosition, bytesToCopy); inputState.readPosition += bytesToCopy; inputState.availableBytes -= bytesToCopy; payloadState.offset += bytesToCopy; payloadState.availableBytes -= bytesToCopy; if (payloadState.availableBytes == 0) { //finish off the packet header and send whenever we have a full packet { if (payloadState.offset > numeric_limits<uint32_t>::max()) { OFXSQUASHBUDDIES_ERROR << "Payload is too big! Sorry baby."; } else { packet.header.payloadSize = (uint32_t)payloadState.offset; this->compressorToSocket->send(packet); } packet.header.packetIndex++; packet.header.payloadSize = 0; } //reset the packet for next use { payloadState.offset = 0; payloadState.availableBytes = Packet::MaxPayloadSize; } } } }); compressStream << message.getMessageString() << ofxSquash::Stream::Finish(); //send whatever is left over if (payloadState.offset > numeric_limits<uint32_t>::max()) { OFXSQUASHBUDDIES_ERROR << "Payload is too big! Sorry baby."; } else { packet.header.payloadSize = (uint32_t) payloadState.offset; packet.header.isLastPacket = true; this->compressorToSocket->send(packet); } frameIndex++; } } }
void spec_compress(int in, int out, int lev) { blockSize100k = lev; compressStream ( in, out ); }