void RTMFPWriter::flush(BinaryWriter& writer,UInt64 stage,UInt8 flags,bool header,const UInt8* data,UInt16 size) {
if(_stageAck==0 && header)
flags |= MESSAGE_HEADER;
if(size==0)
flags |= MESSAGE_ABANDONMENT;
if(state()==CLOSED && _messages.size()==1) // On LAST message
flags |= MESSAGE_END;
// TRACE("RTMFPWriter ",id," stage ",stage);
writer.write8(flags);
if(header) {
writer.write7BitLongValue(id);
writer.write7BitLongValue(stage);
writer.write7BitLongValue(stage-_stageAck);
// signature
if(_stageAck==0) {
writer.writeString8(signature);
// No write this in the case where it's a new flow!
if(flowId>0) {
writer.write8(1+Util::Get7BitValueSize(flowId)); // following size
writer.write8(0x0a); // Unknown!
writer.write7BitLongValue(flowId);
}
writer.write8(0); // marker of end for this part
}
}
if (size > 0)
writer.writeRaw(data, size);
}
void TxIOPair::serializeDbValue(BinaryWriter& bw) const
{
uint8_t sersize = 17; //bit pack + amount + txout key
if (hasTxIn())
sersize += 8;
bw.put_uint8_t(sersize);
BitPacker<uint8_t> bitpacker;
bitpacker.putBit(isTxOutFromSelf_);
bitpacker.putBit(isFromCoinbase_);
bitpacker.putBit(hasTxIn());
bitpacker.putBit(isMultisig_);
bitpacker.putBit(isUTXO_);
bitpacker.putBit(isFromSameBlock_);
bw.put_BitPacker(bitpacker);
bw.put_uint64_t(amount_);
bw.put_BinaryData(getDBKeyOfOutput());
if (hasTxIn())
{
bw.put_BinaryData(getDBKeyOfInput());
}
}
void FlowWriter::writeResponseHeader(BinaryWriter& writer,const string& name,double callbackHandle) {
writer.write8(Message::AMF_WITH_HANDLER);writer.write32(0);
writer.write8(AMF_STRING);writer.writeString16(name);
writer.write8(AMF_NUMBER); // marker
writer << callbackHandle;
writer.write8(AMF_NULL);
}
bool Model_IO::Save(BinaryWriter& writer, const achar* path)
{
// ヘッダー
uint8_t header[] = "MDL";
for (int32_t i = 0; i < 4; i++)
{
writer.Push(header[i]);
}
// バージョン
writer.Push(0);
// ボーン
SaveDeformer(Deformer_, writer, path);
// メッシュ
SaveMeshes(Meshes, writer, path);
// アニメーション
writer.Push((int32_t)AnimationSources.size());
for (int32_t i = 0; i < AnimationSources.size(); i++)
{
SaveAnimationSource(AnimationSources[i], writer, path);
}
writer.Push((int32_t) AnimationClips.size());
for (int32_t i = 0; i <AnimationClips.size(); i++)
{
SaveAnimationClip(AnimationClips[i], writer, path);
}
return true;
}
BinaryData TransactionVerifier::serializeAllOutpoints() const
{
BinaryWriter bw;
for (unsigned i = 0; i < theTx_.txins_.size(); i++)
bw.put_BinaryDataRef(getOutpoint(i));
return bw.getData();
}
void ProgressData::serialize(BinaryWriter& bw) const
{
bw.put_uint8_t(PROGRESSDATA_CODE);
bw.put_uint8_t((uint8_t)phase_);
bw.put_double(progress_);
bw.put_uint32_t(time_);
bw.put_uint32_t(numericProgress_);
}
BinaryData StackItem_OpCode::serialize(void) const
{
BinaryWriter bw;
bw.put_uint32_t(id_);
bw.put_uint8_t(STACKITEM_OPCODE_PREFIX);
bw.put_uint8_t(opcode_);
return bw.getData();
}
void Model_IO::SaveAnimationSource(AnimationSource& as, BinaryWriter& writer, const achar* path)
{
writer.Push(as.Name);
writer.Push((int32_t) as.KeyframeAnimations.size());
for (int32_t i = 0; i < as.KeyframeAnimations.size(); i++)
{
SaveKeyframeAnimation(as.KeyframeAnimations[i], writer, path);
}
}
unsigned char WriteString(TrieNode* node, BinaryWriter& writer) {
if(node->Parent == rootNode_) {
writer.WriteByte(node->Value);
return node->Value;
}
else {
unsigned char first = WriteString(node->Parent, writer);
writer.WriteByte(node->Value);
return first;
}
}
void PositionPacket::writeRawPacket(BinaryWriter& stream) const {
stream.write(reinterpret_cast<const char*>(&mNotUsed1), sizeof(mNotUsed1));
stream << mGyro1 << mTemp1 << mAccel1X << mAccel1Y << mGyro2 << mTemp2 <<
mAccel2X << mAccel2Y << mGyro3 << mTemp3 << mAccel3X << mAccel3Y;
stream.write(reinterpret_cast<const char*>(&mNotUsed2), sizeof(mNotUsed2));
stream << mGPSTimestamp;
stream.write(reinterpret_cast<const char*>(&mNotUsed3), sizeof(mNotUsed3));
stream.write(reinterpret_cast<const char*>(&mNMEASentence),
sizeof(mNMEASentence));
stream.write(reinterpret_cast<const char*>(&mNotUsed4), sizeof(mNotUsed4));
}
BinaryData TransactionVerifier::serializeAllSequences() const
{
BinaryWriter bw;
for (auto& txinOnS : theTx_.txins_)
{
auto sequenceOffset = txinOnS.first + txinOnS.second - 4;
BinaryDataRef bdr(theTx_.data_ + sequenceOffset, 4);
bw.put_BinaryDataRef(bdr);
}
return bw.getData();
}
void Model_IO::SaveDeformer(Deformer& deformer, BinaryWriter& writer, const achar* path)
{
writer.Push((int32_t)deformer.Bones.size());
for (auto i = 0; i < deformer.Bones.size(); i++)
{
auto& bone = deformer.Bones[i];
writer.Push(deformer.Bones[i].Name);
writer.Push(deformer.Bones[i].ParentBoneIndex);
writer.Push((int32_t)deformer.Bones[i].RotationType);
writer.Push(deformer.Bones[i].LocalMat);
}
}
const string& Arguments::serialize()
{
if (argStr_.size() != 0)
return argStr_;
BinaryWriter bw;
for (auto& arg : argData_)
arg->serialize(bw);
auto& bdser = bw.getData();
argStr_ = bdser.toHexStr();
return argStr_;
}
void GeoSaver::SaveMesh(Scene3DMesh *mesh, BinaryWriter &bw)
{
bw.Write(mesh ->id);
bw.Write(mesh ->name);
for (int i = 0; i < 16; i++)
bw.Write(mesh->m_worldInverseMatrix.a[i]);
bw.Write((int)mesh ->meshParts.size());
for (int i = 0; i < (int)mesh ->meshParts.size(); i++)
SaveMeshPart(mesh ->meshParts[i], bw);
SaveProperties(mesh, bw);
}
BinaryWriter& AFXAPI operator<<(BinaryWriter& wr, const IPAddress& ha) {
wr << (short)ha.get_AddressFamily();
switch ((int)ha.get_AddressFamily()) {
case AF_INET:
wr.Write(&ha.m_sin.sin_addr, sizeof(ha.m_sin.sin_addr));
break;
case AF_INET6:
wr.Write(&ha.m_sin6.sin6_addr, sizeof(ha.m_sin6.sin6_addr));
break;
default:
wr.Write(&ha.m_sockaddr, sizeof(ha.m_sockaddr)); //!!! unknown size
break;
}
return wr;
}
void Namespace::Write(BinaryWriter &w) const
{
Node::Write(w);
w.WriteID(m_Parent);
w.WriteAs<uint32_t>(m_Functions.size());
for (auto &kvp : m_Functions)
{
w.WriteAs<uint32_t>(kvp.second.size());
for (auto &kvp : kvp.second)
kvp.second->Write(w);
}
w.WriteAs<uint32_t>(m_Children.size());
for (auto &kvp : m_Children)
kvp.second->Write(w);
w.WriteAs<uint32_t>(m_Types.size());
for (auto &kvp : m_Types)
kvp.second->Write(w);
w.WriteAs<uint32_t>(m_Variables.size());
for (auto &kvp : m_Variables)
kvp.second->Write(w);
w.WriteAs<uint32_t>(m_EnumConstants.size());
for (auto &kvp : m_EnumConstants)
kvp.second->Write(w);
}
void GeoSaver::SaveProperties(Scene3DMesh *mesh, BinaryWriter &bw)
{
bw.Write((int)mesh->properties.size());
for (unsigned i = 0; i < mesh->properties.size(); i++)
SaveProperty(mesh->properties[i], bw);
}
void Document::write(BinaryWriter& writer)
{
if ( _elements.empty() )
{
writer << 5;
}
else
{
std::stringstream sstream;
Poco::BinaryWriter tempWriter(sstream);
for(ElementSet::iterator it = _elements.begin(); it != _elements.end(); ++it)
{
tempWriter << static_cast<unsigned char>((*it)->type());
BSONWriter(tempWriter).writeCString((*it)->name());
Element::Ptr element = *it;
element->write(tempWriter);
}
tempWriter.flush();
Poco::Int32 len = static_cast<Poco::Int32>(5 + sstream.tellp()); /* 5 = sizeof(len) + 0-byte */
writer << len;
writer.writeRaw(sstream.str());
}
writer << '\0';
}
void BinaryDataVector::serialize(BinaryWriter& bw) const
{
bw.put_uint8_t(BINARYDATAVECTOR_CODE);
size_t size = 0;
for (auto& bdo : bdVec_)
size += bdo.getSize();
bw.put_var_int(size);
bw.put_var_int(bdVec_.size());
for (auto& bdo : bdVec_)
{
bw.put_var_int(bdo.getSize());
bw.put_BinaryData(bdo);
}
}
void Generator::GenerateFontFile(
astring fontPath,
astring textPath)
{
auto result = RenderPng(fontPath, textPath);
BinaryWriter writer;
PushAff(writer, result);
#ifdef _WIN32
ofstream file(m_sheetName + L".aff", ios::out | ios::binary);
#else
ofstream file(ToUtf8String(m_sheetName.c_str()) + ".aff", ios::out | ios::binary);
#endif
writer.WriteOut(file);
}
/*
* 解析結果をバイナリ形式のファイルに出力する。
* 内部コードを別ファイルにする用途で使用する。
*
* 各アセンブリは以下のフォーマット形式で保存される
* [AssemblyName : string ] アセンブリの名前
* [StackFrame : u32 ] スタックフレーム
* [Address : u32 ] 関数アドレス
* [Args : u32 ] 関数パラメータ数
* [CodeSize : u32 ] コード領域サイズ
* [Code : byte[ContentSize]] コード領域
*/
VMAssembleOutput::VMAssembleOutput( IAssembleReader* reader , const char* fileName ){
BinaryWriter bw;
int index = 0;
AsmInfo* assemblyInfo = reader->getAssembly(0);
while( assemblyInfo ){
bw.writeString( assemblyInfo->name() );
bw.writeUInt32( assemblyInfo->stackFrame() );
bw.writeUInt32( assemblyInfo->addr() );
bw.writeUInt32( assemblyInfo->Args() );
bw.writeUInt32( assemblyInfo->CodeSize() );
for( size_t i = 0 ; i < assemblyInfo->CodeSize() ; i++ ){
bw.write( assemblyInfo->getCommand(i) );
}
assemblyInfo = reader->getAssembly(++index);
}
CStream stream = bw.getStream();
FILE* fp = NULL;
fopen_s( &fp , fileName , "wb" );
assert( fp );
while( stream->hasNext() ){
unsigned char content[1];
content[0] = static_cast<unsigned char>( stream->getByte() );
fwrite( content , sizeof( unsigned char ) , sizeof( content ) , fp );
}
fclose( fp );
}
void Model_IO::SaveMeshes(std::vector<Mesh>& meshes, BinaryWriter& writer, const achar* path)
{
writer.Push((int32_t) meshes.size());
for (auto i = 0; i < meshes.size(); i++)
{
SaveMesh(meshes[i], writer, path);
}
}
void Model_IO::SaveMaterials(std::vector<Material>& materials, BinaryWriter& writer, const achar* path)
{
writer.Push((int32_t) materials.size());
for (int32_t i = 0; i < materials.size(); i++)
{
SaveMaterial(materials[i], writer, path);
}
}
void Model_IO::SaveMesh(Mesh& mesh, BinaryWriter& writer, const achar* path)
{
writer.Push((int32_t)mesh.DividedMeshes.size());
for (auto i = 0; i < mesh.DividedMeshes.size(); i++)
{
SaveDividedMesh(mesh.DividedMeshes[i], writer, path);
}
SaveMaterials(mesh.Materials, writer, path);
}
BinaryData StackItem_MultiSig::serialize(void) const
{
BinaryWriter bw;
bw.put_uint32_t(id_);
bw.put_uint8_t(STACKITEM_MULTISIG_PREFIX);
bw.put_uint16_t(m_);
bw.put_var_int(sigs_.size());
for (auto& sig_pair : sigs_)
{
bw.put_uint16_t(sig_pair.first);
bw.put_var_int(sig_pair.second.getSize());
bw.put_BinaryData(sig_pair.second);
}
return bw.getData();
}
void AffIndexTable::Push(BinaryWriter& writer)
{
array<int16_t, CHARCODE_MAX> indexes;
for (auto& x : m_indexes)
{
indexes[(int)(x.first)] = x.second;
}
for (auto& x : indexes)
{
writer.Push(x);
}
}
void GeoSaver::SavePropertiesTxt(Scene3DMesh *mesh, BinaryWriter &bw)
{
std::stringstream data;
data << "\n";
data << "<properties count=\"" << mesh->properties.size() << "\">\n";
for (unsigned i = 0; i < mesh->properties.size(); i++)
SavePropertyTxt(mesh->properties[i], bw, data);
data << "</properties>\n";
bw.Write(data.str().c_str(), static_cast<uint32_t>(data.str().size()));
}
BinaryData StackItem_PushData::serialize(void) const
{
BinaryWriter bw;
bw.put_uint32_t(id_);
bw.put_uint8_t(STACKITEM_PUSHDATA_PREFIX);
bw.put_var_int(data_.getSize());
bw.put_BinaryData(data_);
return bw.getData();
}
BinaryData StackItem_SerializedScript::serialize(void) const
{
BinaryWriter bw;
bw.put_uint32_t(id_);
bw.put_uint8_t(STACKITEM_SERSCRIPT_PREFIX);
bw.put_var_int(data_.getSize());
bw.put_BinaryData(data_);
return bw.getData();
}
BinaryData BlockHeaderRef::serializeWholeBlock(bool withLead8Bytes) const
{
BinaryWriter serializedBlock;
uint32_t blksize = getBlockSize();
if(withLead8Bytes)
{
serializedBlock.reserve(blksize + 8);
serializedBlock.put_BinaryData(BtcUtils::MagicBytes_);
serializedBlock.put_uint32_t(blksize);
}
else
serializedBlock.reserve(blksize);
serializedBlock.put_BinaryData(self_);
serializedBlock.put_var_int(getNumTx());
for(uint32_t i=0; i<getNumTx(); i++)
serializedBlock.put_BinaryData(txPtrList_[i]->serialize());
return serializedBlock.getData();
}
