GrpcPrint/PrintS/job/BPBinary.cpp

#include "BPBinary.h"

BPBinary::BPBinary(BFileInfo info)
:m_root(NULL)
,m_layers(NULL)
, m_file_info(info)
{
}

BPBinary::~BPBinary()
{
	if (m_root)delete m_root;
	if (m_layers)delete m_layers;
}

bool BPBinary::LoadFile() 
{
	ifstream  binaryFile(m_file_info.file_path, ios::binary| ios::in);
	if (!binaryFile.is_open())return false;
	if (m_root)delete m_root;
	if (m_layers)delete m_layers;
	m_root = new Root;
	m_layers = new Layers;
	//QDataStream qds(&binaryFile);
	//qds.setByteOrder(QDataStream::LittleEndian);
	//qds.setVersion(QDataStream::Qt_5_10);
	ReadRoot(binaryFile);
	ReadLayers(binaryFile);
	binaryFile.close();
	return true;
}

void BPBinary::ReadRoot(ifstream& dataSteam)
{
	char buffer[512];
	dataSteam.read((char*)m_root->header, sizeof(BHeader));
	dataSteam.read((char*)m_root->fixed_header->header, sizeof(BHeader));
	memset(buffer, '\0', sizeof(buffer));
	dataSteam.read(buffer, m_root->fixed_header->header->datasize);
	m_root->fixed_header->description_of_content = string(buffer);
	dataSteam.read((char*)m_root->version->header, sizeof(BHeader));
	dataSteam.read((char*)&m_root->version->major, sizeof(m_root->version->major));
	dataSteam.read((char*)&m_root->version->minor, sizeof(m_root->version->minor));
	dataSteam.read((char*)m_root->file_path->header, sizeof(BHeader));
	memset(buffer, '\0', sizeof(buffer));
	dataSteam.read(buffer, m_root->file_path->header->datasize);
	m_root->file_path->path = string(buffer);
}

void BPBinary::ReadLayers(ifstream& dataSteam)
{
	dataSteam.read((char*)m_layers->header, sizeof(BHeader));
	while (!dataSteam.eof()) {
		Layer* player = new Layer;
		dataSteam.read((char*)player->header, sizeof(BHeader));
		if (player->header->datasize != 13189) {
			printf("df");
		}
		if (player->header->id == 0x15) {
			ReadLayer(dataSteam, player);
			m_layers->layers.push_back(player);
		}
		else {
			delete player;
		}
	}
}

void BPBinary::ReadLayer(ifstream& dataSteam, Layer* layer)
{
	unsigned int readcount = 0;
	unsigned int layersize = sizeof(BHeader) + layer->header->datasize;
	B210Session* pb210 = new B210Session;
	dataSteam.read((char*)pb210->header, sizeof(BHeader));
	char* pb210data = new char[pb210->header->datasize];
	dataSteam.read(pb210data, pb210->header->datasize);
	pb210->pdata = pb210data;
	layer->b210 = pb210;
	readcount += (sizeof(BHeader) + pb210->header->datasize);
	while (!dataSteam.eof() && layersize>(readcount+8)) {
		DataBlock* pdatablock = new DataBlock;
		
		unsigned int pos = (unsigned int)dataSteam.tellg();
		dataSteam.read((char*)pdatablock->header, sizeof(BHeader));
		if (pdatablock->header->id == 0xD4) {
			ReadDataBlock(dataSteam, pdatablock);
			layer->data_blocks.push_back(pdatablock);
			readcount += (sizeof(BHeader) + pdatablock->header->datasize);
			m_data_block_map[pos] = pdatablock;
		}
		else {
			delete pdatablock;
			break;
		}
		
	}

}

void BPBinary::ReadDataBlock(ifstream& dataSteam, DataBlock* datablock)
{
	DataBlockType* pdbt = new DataBlockType;
	datablock->data_block_type = pdbt;
	dataSteam.read((char*)pdbt->header, sizeof(BHeader));
	char datablocktype=0;
	dataSteam.read(&datablocktype, 1);
	pdbt->btype = DBT(datablocktype);
	B2121Session* pb2121 = new B2121Session;
	datablock->b2121 = pb2121;
	dataSteam.read((char*)pb2121->header, sizeof(BHeader));
	dataSteam.read((char*)&pb2121->ivalue, sizeof(pb2121->header->datasize));
	B2122Session* pb2122 = new B2122Session;
	datablock->b2122 = pb2122;
	dataSteam.read((char*)pb2122->header, sizeof(BHeader));
	dataSteam.read((char*)&pb2122->ivalue, sizeof(pb2122->header->datasize));
	B2123Session* pb2123 = new B2123Session;
	datablock->b2123 = pb2123;
	dataSteam.read((char*)pb2123->header, sizeof(BHeader));
	dataSteam.read((char*)&pb2123->ivalue, sizeof(pb2123->header->datasize));
	Coordinates* pc = new Coordinates;
	datablock->coordinates = pc;
	dataSteam.read((char*)pc->header, sizeof(BHeader));
	if (pdbt->btype == VECTOR) {
		unsigned int count = 0;
		while (count< pc->header->datasize)
		{
			VectorPoint* pvp = new VectorPoint;
			dataSteam.read((char*)(&pvp->x1), sizeof(pvp->x1));
			dataSteam.read((char*)(&pvp->y1), sizeof(pvp->y1));
			dataSteam.read((char*)(&pvp->x2), sizeof(pvp->x2));
			dataSteam.read((char*)(&pvp->y2), sizeof(pvp->y2));
			pc->point_indexs.push_back(pvp);
			count += 16;
		}
	}
	else if (pdbt->btype == CHAIN) {
		unsigned int datalenth = 0;
		do {
			dataSteam.read((char*)&datalenth, sizeof(datalenth));
			if (datalenth > 0) {
				ChainPoint* pcp = new ChainPoint;
				pc->point_indexs.push_back(pcp);
				pcp->num_of_point = datalenth;
				ReadChains(dataSteam, pcp);
			}
		} while (datalenth != 0);
	}
	else {
		char* pdata = new char[pc->header->datasize];
		dataSteam.read(pdata, sizeof(pc->header->datasize));
		delete[] pdata;
	}
}

void BPBinary::ReadChains(ifstream& dataSteam, ChainPoint* chainPoint)
{
	//chainPoint->points = new BPoint[chainPoint->num_of_point];
	for (unsigned int i = 0; i < chainPoint->num_of_point;++i) {
		BPoint* pb = new BPoint;
		dataSteam.read((char*)&(pb->x), sizeof(float));
		dataSteam.read((char*)&(pb->y), sizeof(float));
		chainPoint->points.push_back(pb);
	}
}