void encodeNode(HuffmanNode* node, obitstream& output) {
if (node->isLeaf()) {
output.writeBit(1);
output.put(node->character);
} else {
output.writeBit(0);
encodeNode(node->zero, output);
encodeNode(node->one, output);
}
}
void Huffman::startHuffman(map<char32_t, int>& letters, BitOutput*& writer, map<char32_t, string> &huffmanCodes) {
struct Node* left, * right, * top;
priority_queue<Node*, vector<Node*>, compare> queue;
for (auto it = letters.begin(); it != letters.end(); ++it) {
queue.push(new Node(it->first, it->second));
countOfOperations += 1;
}
while (queue.size() != 1) {
left = queue.top();
queue.pop();
right = queue.top();
queue.pop();
top = new Node(0, left->freq + right->freq);
top->left = left;
top->right = right;
queue.push(top);
countOfOperations += 9;
}
root = queue.top();
makeCodes(root, "", huffmanCodes);
encodeNode(root, writer);
countOfOperations += 7;
}
void Huffman::encodeNode(Node* node, BitOutput*& writer) {
if (node->isLeafNode()) {
(*writer).writeBit(1);
(*writer).writeChar32(node->data);
countOfOperations += 2;
} else {
(*writer).writeBit(0);
encodeNode(node->left, writer);
encodeNode(node->right, writer);
countOfOperations += 3;
}
countOfOperations += 1;
}
void FBXWriter::encodeNode(QDataStream& out, const FBXNode& node) {
auto device = out.device();
auto nodeStartPos = device->pos();
// endOffset (temporary, updated later)
out << (FBXEndOffset)0;
// Property count
out << (FBXPropertyCount)node.properties.size();
// Property list length (temporary, updated later)
out << (FBXListLength)0;
out << (quint8)node.name.size();
out.writeRawData(node.name, node.name.size());
auto nodePropertiesStartPos = device->pos();
for (const auto& prop : node.properties) {
encodeFBXProperty(out, prop);
}
// Go back and write property list length
auto nodePropertiesEndPos = device->pos();
device->seek(nodeStartPos + sizeof(FBXEndOffset) + sizeof(FBXPropertyCount));
out << (FBXListLength)(nodePropertiesEndPos - nodePropertiesStartPos);
device->seek(nodePropertiesEndPos);
for (auto& child : node.children) {
encodeNode(out, child);
}
if (node.children.length() > 0) {
encodeNode(out, FBXNode());
}
// Go back and write actual endOffset
auto nodeEndPos = device->pos();
device->seek(nodeStartPos);
out << (FBXEndOffset)(nodeEndPos);
device->seek(nodeEndPos);
}
QByteArray FBXWriter::encodeFBX(const FBXNode& root) {
QByteArray data;
QDataStream out(&data, QIODevice::WriteOnly);
out.setByteOrder(QDataStream::LittleEndian);
out.setVersion(QDataStream::Qt_4_5);
out.writeRawData(FBX_BINARY_PROLOG, FBX_BINARY_PROLOG.size());
out.writeRawData(FBX_BINARY_PROLOG2, FBX_BINARY_PROLOG2.size());
#ifdef USE_FBX_2016_FORMAT
out << FBX_VERSION_2016;
#else
out << FBX_VERSION_2015;
#endif
for (auto& child : root.children) {
encodeNode(out, child);
}
encodeNode(out, FBXNode());
return data;
}
typename BVHN<N>::NodeRef BVHN<N>::layoutLargeNodesRecursion(NodeRef& node, FastAllocator::ThreadLocal& allocator)
{
if (node.isBarrier()) {
node.clearBarrier();
return node;
}
else if (node.isNode())
{
Node* oldnode = node.node();
Node* newnode = (BVHN::Node*) allocator.malloc(sizeof(BVHN::Node),byteNodeAlignment);
*newnode = *oldnode;
for (size_t c=0; c<N; c++)
newnode->child(c) = layoutLargeNodesRecursion(oldnode->child(c),allocator);
return encodeNode(newnode);
}
else return node;
}
BVH4::NodeRef BVH4::layoutLargeNodesRecursion(NodeRef& node)
{
if (node.isBarrier()) {
node.clearBarrier();
return node;
}
else if (node.isNode())
{
Node* oldnode = node.node();
Node* newnode = (BVH4::Node*) alloc.threadLocal2()->alloc0.malloc(sizeof(BVH4::Node)); // FIXME: optimize access to threadLocal2
*newnode = *oldnode;
for (size_t c=0; c<BVH4::N; c++)
newnode->child(c) = layoutLargeNodesRecursion(oldnode->child(c));
return encodeNode(newnode);
}
else return node;
}
void writeHeader(HuffmanNode* encodingTree, obitstream& output) {
encodeNode(encodingTree, output);
}
