void NULLVC::receive_data_from_comm_port( BYTE *recvBuf, int recvLen, void *scope) { NULLVC *myThis = (NULLVC *)scope; DWORD time = GetTickCount(); BitStream bstream(recvBuf, MaxHeaderSize); if(!myThis) return; log_file.log("NULLVC::receive_data_from_comm_port: %lx bytes, state %lx",recvLen,myThis->getState()); // is it a game info packet? if(!bstream.readFlag()) { myThis->mySession->onReceive(NULL, myThis->addressString, recvBuf, recvLen); } else { myThis->receivePacket(recvBuf, recvLen, time); if(myThis->getState() == VC::Unbound) { log_file.log("NULLVC::Unbound VC in receive_data_from_comm_port"); myThis->deleteVC(); } } }
static void test_buffer(skiatest::Reporter* reporter) { SkRandom rand; SkAutoMalloc am(MAX_SIZE * 2); char* storage = (char*)am.get(); char* storage2 = storage + MAX_SIZE; random_fill(rand, storage, MAX_SIZE); for (int sizeTimes = 0; sizeTimes < 100; sizeTimes++) { int size = rand.nextU() % MAX_SIZE; if (size == 0) { size = MAX_SIZE; } for (int times = 0; times < 100; times++) { int bufferSize = 1 + (rand.nextU() & 0xFFFF); SkMemoryStream mstream(storage, size); SkBufferStream bstream(&mstream, bufferSize); int bytesRead = 0; while (bytesRead < size) { int s = 17 + (rand.nextU() & 0xFFFF); int ss = bstream.read(storage2, s); REPORTER_ASSERT(reporter, ss > 0 && ss <= s); REPORTER_ASSERT(reporter, bytesRead + ss <= size); REPORTER_ASSERT(reporter, memcmp(storage + bytesRead, storage2, ss) == 0); bytesRead += ss; } REPORTER_ASSERT(reporter, bytesRead == size); } } }
void encodeDynamicVector(float *buffer, size_t componentsCount, size_t count, const GLTFConverterContext& converterContext) { GLTFOutputStream *outputStream = converterContext._compressionOutputStream; Real max[32]; Real min[32]; O3DGCStreamType streamType = converterContext.compressionMode == "ascii" ? O3DGC_STREAM_TYPE_ASCII : O3DGC_STREAM_TYPE_BINARY; DynamicVector dynamicVector; dynamicVector.SetVectors(buffer); dynamicVector.SetDimVector(componentsCount); dynamicVector.SetMax(max); dynamicVector.SetMin(min); dynamicVector.SetNVector(count); dynamicVector.SetStride(componentsCount); dynamicVector.ComputeMinMax(O3DGC_SC3DMC_MAX_SEP_DIM);//O3DGC_SC3DMC_MAX_ALL_DIMS DVEncodeParams params; params.SetQuantBits(componentsCount == 1 ? 11 : 17); //HACK, if that's 1 component it is the TIME and 10 bits is OK params.SetStreamType(streamType); DynamicVectorEncoder encoder; encoder.SetStreamType(streamType); Timer timer; timer.Tic(); BinaryStream bstream(componentsCount * count * 16); encoder.Encode(params, dynamicVector, bstream); timer.Toc(); outputStream->write((const char*)bstream.GetBuffer(), bstream.GetSize()); /* if (componentsCount == 4) { DynamicVector dynamicVector1; DynamicVectorDecoder decoder; decoder.DecodeHeader(dynamicVector1, bstream); dynamicVector1.SetStride(dynamicVector1.GetDimVector()); std::vector<Real> oDV; std::vector<Real> oDVMin; std::vector<Real> oDVMax; oDV.resize(dynamicVector1.GetNVector() * dynamicVector1.GetDimVector()); oDVMin.resize(dynamicVector1.GetDimVector()); oDVMax.resize(dynamicVector1.GetDimVector()); dynamicVector1.SetVectors(& oDV[0]); dynamicVector1.SetMin(& oDVMin[0]); dynamicVector1.SetMax(& oDVMax[0]); decoder.DecodePlayload(dynamicVector1, bstream); float* dbuffer = (float*)dynamicVector1.GetVectors(); printf("****dump axis-angle. Axis[3] / Angle[1]\n"); for (int i = 0 ; i < count ; i++) { int offset = i * 4; printf("[raw]%f %f %f %f [10bits]%f %f %f %f\n", buffer[offset+0],buffer[offset+1],buffer[offset+2],buffer[offset+3], dbuffer[offset+0],dbuffer[offset+1],dbuffer[offset+2],dbuffer[offset+3]); } } */ }
inline void get_pid_str(pid_str_t &pid_str, OS_process_id_t pid) { bufferstream bstream(pid_str, sizeof(pid_str)); bstream << pid << std::ends; }
void stringtable::update(const uint32_t& entries, const std::string& data) const { // create bitstream for data field bitstream bstream(data); // if true, list contains no names only updates const uint32_t full = bstream.read(1); // index for consecutive incrementing int32_t index = -1; // key history for key deltas std::vector<std::string> keys; // read all the entries in the string table for (uint32_t i = 0; i < entries; ++i) { char key[STRINGTABLE_MAX_KEY_SIZE] = {'\0'}; char value[STRINGTABLE_MAX_VALUE_SIZE] = {'\0'}; const bool increment = bstream.read(1); if (increment) { ++index; } else { index = bstream.read(std::ceil(log2(maxEntries))); } // read name const bool hasName = bstream.read(1); if (hasName) { if (full && bstream.read(1)) { // this should never happen because we cant reference the entry from this point onwards BOOST_THROW_EXCEPTION( stringtableKeyMissing() ); return; } // check for key delta const bool substring = bstream.read(1); if (substring) { // read substring const uint32_t sIndex = bstream.read(5); // index of substr in keyhistory const uint32_t sLength = bstream.read(5); // prefix length to new key if (sIndex >= STRINGTABLE_KEY_HISTORY || sLength >= STRINGTABLE_MAX_KEY_SIZE) BOOST_THROW_EXCEPTION( stringtableMalformedSubstring() << (EArgT<1, uint32_t>::info(sIndex)) << (EArgT<1, uint32_t>::info(sLength)) ); keys[sIndex].copy(key, sLength, 0); bstream.readString(key + sLength, STRINGTABLE_MAX_KEY_SIZE - sLength); } else { bstream.readString(reinterpret_cast<char*>(&key), STRINGTABLE_MAX_KEY_SIZE); } // check the key history if (keys.size() >= STRINGTABLE_KEY_HISTORY) detail::pop_front(keys); keys.push_back(std::string(key)); } // read value const bool hasValue = bstream.read(1); uint32_t length = 0; if (hasValue) { uint32_t valsize = 0; if (userDataFixed) { length = userDataSize; valsize = userDataSizeBits; } else { length = bstream.read(14); valsize = length * 8; } if (length > STRINGTABLE_MAX_VALUE_SIZE) BOOST_THROW_EXCEPTION( stringtableValueOverflow() << (EArgT<1, uint32_t>::info(length)) ); bstream.readBits((char*)&value, valsize); } // insert entry std::string k(key); std::string v(value, length); if (hasName && db.hasKey(k)) { db.set(std::move(k), std::move(v)); } else if (hasName) { db.insert(storage::entry_type{std::move(k), index, std::move(v)}); } else if (hasValue && db.hasIndex(index)) { db.set(index, std::move(v)); } else { db.insert(storage::entry_type{"anonymous", index, std::move(v)}); } } }
void encodeOpen3DGCMesh(shared_ptr <GLTFMesh> mesh, shared_ptr<JSONObject> floatAttributeIndexMapping, const GLTFConverterContext& converterContext) { o3dgc::SC3DMCEncodeParams params; o3dgc::IndexedFaceSet <unsigned short> ifs; //setup options int qcoord = 12; int qtexCoord = 10; int qnormal = 10; int qcolor = 10; int qWeights = 8; GLTFOutputStream *outputStream = converterContext._compressionOutputStream; size_t bufferOffset = outputStream->length(); O3DGCSC3DMCPredictionMode floatAttributePrediction = O3DGC_SC3DMC_PARALLELOGRAM_PREDICTION; unsigned int nFloatAttributes = 0; PrimitiveVector primitives = mesh->getPrimitives(); unsigned int primitivesCount = (unsigned int)primitives.size(); unsigned int allIndicesCount = 0; unsigned int allTrianglesCount = 0; std::vector <unsigned int> trianglesPerPrimitive; //First run through primitives to gather the number of indices and infer the number of triangles. for (unsigned int i = 0 ; i < primitivesCount ; i++) { shared_ptr<GLTF::GLTFPrimitive> primitive = primitives[i]; shared_ptr <GLTF::GLTFIndices> uniqueIndices = primitive->getUniqueIndices(); unsigned int indicesCount = (unsigned int)(uniqueIndices->getCount()); //FIXME: assumes triangles, but we are guarded from issues by canEncodeOpen3DGCMesh allIndicesCount += indicesCount; trianglesPerPrimitive.push_back(indicesCount / 3); } //Then we setup the matIDs array and at the same time concatenate all triangle indices unsigned long *primitiveIDs = (unsigned long*)malloc(sizeof(unsigned long) * (allIndicesCount / 3)); unsigned long *primitiveIDsPtr = primitiveIDs; unsigned short* allConcatenatedIndices = (unsigned short*)malloc(allIndicesCount * sizeof(unsigned short)); unsigned short* allConcatenatedIndicesPtr = allConcatenatedIndices; for (unsigned int i = 0 ; i < trianglesPerPrimitive.size() ; i++) { unsigned int trianglesCount = trianglesPerPrimitive[i]; for (unsigned int j = 0 ; j < trianglesCount ; j++) { primitiveIDsPtr[j] = i; } primitiveIDsPtr += trianglesCount; allTrianglesCount += trianglesCount; shared_ptr<GLTF::GLTFPrimitive> primitive = primitives[i]; shared_ptr <GLTF::GLTFIndices> uniqueIndices = primitive->getUniqueIndices(); unsigned int indicesCount = (unsigned int)(uniqueIndices->getCount()); unsigned int* indicesPtr = (unsigned int*)uniqueIndices->getBufferView()->getBufferDataByApplyingOffset(); for (unsigned int j = 0 ; j < indicesCount ; j++) { allConcatenatedIndicesPtr[j] = indicesPtr[j]; } allConcatenatedIndicesPtr += indicesCount; } //FIXME:Open3DGC SetNCoordIndex is not a good name here (file against o3dgc) ifs.SetNCoordIndex(allTrianglesCount); ifs.SetCoordIndex((unsigned short * const ) allConcatenatedIndices); ifs.SetIndexBufferID(primitiveIDs); size_t vertexCount = 0; std::vector <GLTF::Semantic> semantics = mesh->allSemantics(); for (unsigned int i = 0 ; i < semantics.size() ; i ++) { GLTF::Semantic semantic = semantics[i]; size_t attributesCount = mesh->getMeshAttributesCountForSemantic(semantic); for (size_t j = 0 ; j < attributesCount ; j++) { shared_ptr <GLTFMeshAttribute> meshAttribute = mesh->getMeshAttribute(semantic, j); vertexCount = meshAttribute->getCount(); size_t componentsPerAttribute = meshAttribute->getComponentsPerAttribute(); char *buffer = (char*)meshAttribute->getBufferView()->getBufferDataByApplyingOffset(); switch (semantic) { case POSITION: params.SetCoordQuantBits(qcoord); params.SetCoordPredMode(floatAttributePrediction); ifs.SetNCoord(vertexCount); ifs.SetCoord((Real * const)buffer); break; case NORMAL: params.SetNormalQuantBits(qnormal); params.SetNormalPredMode(O3DGC_SC3DMC_SURF_NORMALS_PREDICTION); ifs.SetNNormal(vertexCount); ifs.SetNormal((Real * const)buffer); break; case TEXCOORD: params.SetFloatAttributeQuantBits(nFloatAttributes, qtexCoord); params.SetFloatAttributePredMode(nFloatAttributes, floatAttributePrediction); ifs.SetNFloatAttribute(nFloatAttributes, vertexCount); ifs.SetFloatAttributeDim(nFloatAttributes, componentsPerAttribute); ifs.SetFloatAttributeType(nFloatAttributes, O3DGC_IFS_FLOAT_ATTRIBUTE_TYPE_TEXCOORD); ifs.SetFloatAttribute(nFloatAttributes, (Real * const)buffer); floatAttributeIndexMapping->setUnsignedInt32(meshAttribute->getID(), nFloatAttributes); nFloatAttributes++; break; case COLOR: params.SetFloatAttributeQuantBits(nFloatAttributes, qcolor); params.SetFloatAttributePredMode(nFloatAttributes, floatAttributePrediction); ifs.SetNFloatAttribute(nFloatAttributes, vertexCount); ifs.SetFloatAttributeDim(nFloatAttributes, componentsPerAttribute); ifs.SetFloatAttributeType(nFloatAttributes, O3DGC_IFS_FLOAT_ATTRIBUTE_TYPE_COLOR); ifs.SetFloatAttribute(nFloatAttributes, (Real * const)buffer); floatAttributeIndexMapping->setUnsignedInt32(meshAttribute->getID(), nFloatAttributes); nFloatAttributes++; break; case WEIGHT: params.SetFloatAttributeQuantBits(nFloatAttributes, qWeights); params.SetFloatAttributePredMode(nFloatAttributes, O3DGC_SC3DMC_DIFFERENTIAL_PREDICTION); ifs.SetNFloatAttribute(nFloatAttributes, vertexCount); ifs.SetFloatAttributeDim(nFloatAttributes, componentsPerAttribute); ifs.SetFloatAttributeType(nFloatAttributes, O3DGC_IFS_FLOAT_ATTRIBUTE_TYPE_WEIGHT); ifs.SetFloatAttribute(nFloatAttributes, (Real * const)buffer); floatAttributeIndexMapping->setUnsignedInt32(meshAttribute->getID(), nFloatAttributes); nFloatAttributes++; break; case JOINT: /* params.SetIntAttributePredMode(nIntAttributes, O3DGC_SC3DMC_DIFFERENTIAL_PREDICTION); ifs.SetNIntAttribute(nIntAttributes, jointIDs.size() / numJointsPerVertex); ifs.SetIntAttributeDim(nIntAttributes, numJointsPerVertex); ifs.SetIntAttributeType(nIntAttributes, O3DGC_IFS_INT_ATTRIBUTE_TYPE_JOINT_ID); ifs.SetIntAttribute(nIntAttributes, (long * const ) & (jointIDs[0])); nIntAttributes++; */ params.SetFloatAttributeQuantBits(nFloatAttributes, 10); params.SetFloatAttributePredMode(nFloatAttributes, O3DGC_SC3DMC_PARALLELOGRAM_PREDICTION); ifs.SetNFloatAttribute(nFloatAttributes, vertexCount); ifs.SetFloatAttributeDim(nFloatAttributes, componentsPerAttribute); ifs.SetFloatAttributeType(nFloatAttributes, O3DGC_IFS_FLOAT_ATTRIBUTE_TYPE_UNKOWN); ifs.SetFloatAttribute(nFloatAttributes, (Real * const)buffer); floatAttributeIndexMapping->setUnsignedInt32(meshAttribute->getID(), nFloatAttributes); nFloatAttributes++; break; default: break; } } } params.SetNumFloatAttributes(nFloatAttributes); ifs.SetNumFloatAttributes(nFloatAttributes); shared_ptr<JSONObject> compressionObject = static_pointer_cast<JSONObject>(mesh->getExtensions()->createObjectIfNeeded("Open3DGC-compression")); ifs.ComputeMinMax(O3DGC_SC3DMC_MAX_ALL_DIMS); BinaryStream bstream(vertexCount * 8); SC3DMCEncoder <unsigned short> encoder; shared_ptr<JSONObject> compressedData(new JSONObject()); compressedData->setInt32("verticesCount", vertexCount); compressedData->setInt32("indicesCount", allIndicesCount); //Open3DGC binary is disabled params.SetStreamType(converterContext.compressionMode == "binary" ? O3DGC_STREAM_TYPE_BINARY : O3DGC_STREAM_TYPE_ASCII); #if DUMP_O3DGC_OUTPUT static int dumpedId = 0; COLLADABU::URI outputURI(converterContext.outputFilePath.c_str()); std::string outputFilePath = outputURI.getPathDir() + GLTFUtils::toString(dumpedId) + ".txt"; dumpedId++; SaveIFS(outputFilePath, ifs); #endif encoder.Encode(params, ifs, bstream); compressedData->setString("mode", converterContext.compressionMode); compressedData->setUnsignedInt32("count", bstream.GetSize()); compressedData->setUnsignedInt32("type", converterContext.profile->getGLenumForString("UNSIGNED_BYTE")); compressedData->setUnsignedInt32("byteOffset", bufferOffset); compressedData->setValue("floatAttributesIndexes", floatAttributeIndexMapping); compressionObject->setValue("compressedData", compressedData); //testDecode(mesh, bstream); outputStream->write((const char*)bstream.GetBuffer(0), bstream.GetSize()); if (ifs.GetCoordIndex()) { free(ifs.GetCoordIndex()); } if (primitiveIDs) { free(primitiveIDs); } }