removing compression from VoxelNodeData to eventually move it into VoxelPacket where it belongs

interface/src/VoxelPacketProcessor.cpp

@@ -58,20 +58,7 @@ void VoxelPacketProcessor::processPacket(sockaddr& senderAddress, unsigned char*
                 app->_environment.parseData(&senderAddress, packetData, messageLength);
             } else {
                 app->_voxels.setDataSourceUUID(voxelServer->getUUID());
-                
+                app->_voxels.parseData(packetData, messageLength);
-                // these packets are commpressed...
-                if (VOXEL_PACKETS_COMPRESSED) {
-                    int numBytesPacketHeader = numBytesForPacketHeader(packetData);
-                    QByteArray compressedData((const char*)packetData + numBytesPacketHeader, 
-                                            messageLength - numBytesPacketHeader);
-                    QByteArray uncompressedData = qUncompress(compressedData);
-                    QByteArray uncompressedPacket((const char*)packetData, numBytesPacketHeader);
-                    uncompressedPacket.append(uncompressedData);
-
-                    app->_voxels.parseData((unsigned char*)uncompressedPacket.data(), uncompressedPacket.size());
-                } else {
-                    app->_voxels.parseData(packetData, messageLength);
-                }
                 app->_voxels.setDataSourceUUID(QUuid());
             }
         }

libraries/voxel-server-library/src/VoxelNodeData.cpp

@@ -30,11 +30,7 @@ VoxelNodeData::VoxelNodeData(Node* owningNode) :
     _lodChanged(false),
     _lodInitialized(false)
 {
-    if (VOXEL_PACKETS_COMPRESSED) {
+    _voxelPacketAvailableBytes = MAX_VOXEL_PACKET_SIZE;
-        _voxelPacketAvailableBytes = MAX_VOXEL_PACKET_SIZE * UNCOMPRESSED_SIZE_MULTIPLE;
-    } else {
-        _voxelPacketAvailableBytes = MAX_VOXEL_PACKET_SIZE;
-    }
     _voxelPacket = new unsigned char[_voxelPacketAvailableBytes];
     _voxelPacketAt = _voxelPacket;
     _lastVoxelPacket = new unsigned char[_voxelPacketAvailableBytes];
@@ -108,89 +104,15 @@ void VoxelNodeData::resetVoxelPacket() {
     int numBytesPacketHeader = populateTypeAndVersion(_voxelPacket, voxelPacketType);
     _voxelPacketAt = _voxelPacket + numBytesPacketHeader;
     
-    if (VOXEL_PACKETS_COMPRESSED) {
+    _voxelPacketAvailableBytes = MAX_VOXEL_PACKET_SIZE - numBytesPacketHeader;
-        _voxelPacketAvailableBytes = (MAX_VOXEL_PACKET_SIZE * UNCOMPRESSED_SIZE_MULTIPLE) - numBytesPacketHeader;
-        compressPacket();
-    } else {
-        _voxelPacketAvailableBytes = MAX_VOXEL_PACKET_SIZE - numBytesPacketHeader;
-    }
     _voxelPacketWaiting = false;
 }
 
-bool VoxelNodeData::willFit(unsigned char* buffer, int bytes) {
-    bool wouldFit = false;
-    if (VOXEL_PACKETS_COMPRESSED) {
-        int uncompressedLength = getPacketLengthUncompressed();
-        const int MAX_COMPRESSION = 9;
-        // we only want to compress the data payload, not the message header
-        int numBytesPacketHeader = numBytesForPacketHeader(_voxelPacket);
-    
-        // start with the current uncompressed data
-        QByteArray uncompressedTestData((const char*)_voxelPacket + numBytesPacketHeader, 
-                                        uncompressedLength - numBytesPacketHeader);
-
-        // append this next buffer...
-        uncompressedTestData.append((const char*)buffer, bytes);
-
-        // test compress it
-        QByteArray compressedData = qCompress(uncompressedTestData, MAX_COMPRESSION);
-    
-        wouldFit = (compressedData.size() + numBytesPacketHeader) <= MAX_VOXEL_PACKET_SIZE;
-    
-        /*
-        if (!wouldFit) {
-            printf("would not fit... previous size: %d, buffer size: %d, would be:%d MAX_VOXEL_PACKET_SIZE: %d\n",
-                getPacketLength(), bytes, (compressedData.size() + numBytesPacketHeader), MAX_VOXEL_PACKET_SIZE);
-        } else {
-            printf("would fit... previous size: %d, buffer size: %d, would be:%d MAX_VOXEL_PACKET_SIZE: %d\n",
-                getPacketLength(), bytes, (compressedData.size() + numBytesPacketHeader), MAX_VOXEL_PACKET_SIZE);
-        }
-        */
-    } else {
-        wouldFit = bytes <= _voxelPacketAvailableBytes;
-    }
-    return wouldFit;
-}
-
 void VoxelNodeData::writeToPacket(unsigned char* buffer, int bytes) {
     memcpy(_voxelPacketAt, buffer, bytes);
     _voxelPacketAvailableBytes -= bytes;
     _voxelPacketAt += bytes;
     _voxelPacketWaiting = true;
-    compressPacket();
-}
-
-const unsigned char* VoxelNodeData::getPacket() const { 
-    if (VOXEL_PACKETS_COMPRESSED) {
-        return (const unsigned char*)_compressedPacket.constData(); 
-    }
-    return _voxelPacket;
-}
-
-int VoxelNodeData::getPacketLength() const { 
-    if (VOXEL_PACKETS_COMPRESSED) {
-        return _compressedPacket.size(); 
-    }
-    return getPacketLengthUncompressed();
-}
-
-int VoxelNodeData::getPacketLengthUncompressed() const { 
-    if (VOXEL_PACKETS_COMPRESSED) {
-        return (MAX_VOXEL_PACKET_SIZE * UNCOMPRESSED_SIZE_MULTIPLE) - _voxelPacketAvailableBytes;
-    }
-    return MAX_VOXEL_PACKET_SIZE - _voxelPacketAvailableBytes;
-}
-
-void VoxelNodeData::compressPacket() { 
-    int uncompressedLength = getPacketLengthUncompressed();
-    const int MAX_COMPRESSION = 9;
-    // we only want to compress the data payload, not the message header
-    int numBytesPacketHeader = numBytesForPacketHeader(_voxelPacket);
-    QByteArray compressedData = qCompress(_voxelPacket+numBytesPacketHeader, 
-                                    uncompressedLength-numBytesPacketHeader, MAX_COMPRESSION);
-    _compressedPacket.clear();
-    _compressedPacket.append((const char*)_voxelPacket, numBytesPacketHeader);
-    _compressedPacket.append(compressedData);
 }
 
 VoxelNodeData::~VoxelNodeData() {

libraries/voxel-server-library/src/VoxelNodeData.h

@@ -29,11 +29,10 @@ public:
     void resetVoxelPacket();  // resets voxel packet to after "V" header
 
     void writeToPacket(unsigned char* buffer, int bytes); // writes to end of packet
-    bool willFit(unsigned char* buffer, int bytes); // tests to see if the bytes will fit
+    bool willFit(unsigned char* buffer, int bytes) { return (bytes <= _voxelPacketAvailableBytes); }
 
-    const unsigned char* getPacket() const;
+    const unsigned char* getPacket() const {  return _voxelPacket; }
-    int getPacketLength() const;
+    int getPacketLength() const { return MAX_VOXEL_PACKET_SIZE - _voxelPacketAvailableBytes; }
-    int getPacketLengthUncompressed() const;
 
     bool isPacketWaiting() const { return _voxelPacketWaiting; }
 
@@ -112,9 +111,6 @@ private:
     float _lastClientVoxelSizeScale;
     bool _lodChanged;
     bool _lodInitialized;
-    
-    QByteArray _compressedPacket;
-    void compressPacket();
 };
 
 #endif /* defined(__hifi__VoxelNodeData__) */

libraries/voxel-server-library/src/VoxelSendThread.cpp

@@ -112,14 +112,14 @@ int VoxelSendThread::handlePacketSend(Node* node, VoxelNodeData* nodeData, int&
 
             int thisWastedBytes = MAX_PACKET_SIZE - statsMessageLength; // the statsMessageLength at this point includes data
             ::totalWastedBytes += thisWastedBytes;
-            ::totalUncompressed += nodeData->getPacketLengthUncompressed();
+            ::totalUncompressed += nodeData->getPacketLength();
             ::totalCompressed += nodeData->getPacketLength();
             ::totalPackets++;
             if (debug) {
                 qDebug("line: %d - Adding stats to packet [%d]: uncompress size:%d [%d], compressed size:%d [%d] thisWastedBytes:%d [%d]\n",
                     __LINE__,
                     totalPackets,
-                    nodeData->getPacketLengthUncompressed(), ::totalUncompressed,
+                    nodeData->getPacketLength(), ::totalUncompressed,
                     nodeData->getPacketLength(), ::totalCompressed,
                     thisWastedBytes, ::totalWastedBytes);
             }
@@ -156,14 +156,14 @@ int VoxelSendThread::handlePacketSend(Node* node, VoxelNodeData* nodeData, int&
 
             thisWastedBytes = MAX_PACKET_SIZE - nodeData->getPacketLength();
             ::totalWastedBytes += thisWastedBytes;
-            ::totalUncompressed += nodeData->getPacketLengthUncompressed();
+            ::totalUncompressed += nodeData->getPacketLength();
             ::totalCompressed += nodeData->getPacketLength();
             ::totalPackets++;
             if (debug) {
                 qDebug("line: %d - Sending packet [%d]: uncompress size:%d [%d], compressed size:%d [%d] thisWastedBytes:%d [%d]\n",
                     __LINE__,
                     totalPackets,
-                    nodeData->getPacketLengthUncompressed(), ::totalUncompressed,
+                    nodeData->getPacketLength(), ::totalUncompressed,
                     nodeData->getPacketLength(), ::totalCompressed,
                     thisWastedBytes, ::totalWastedBytes);
             }
@@ -179,14 +179,14 @@ int VoxelSendThread::handlePacketSend(Node* node, VoxelNodeData* nodeData, int&
 
             int thisWastedBytes = MAX_PACKET_SIZE - nodeData->getPacketLength();
             ::totalWastedBytes += thisWastedBytes;
-            ::totalUncompressed += nodeData->getPacketLengthUncompressed();
+            ::totalUncompressed += nodeData->getPacketLength();
             ::totalCompressed += nodeData->getPacketLength();
             ::totalPackets++;
             if (debug) {
                 qDebug("line: %d - Sending packet [%d]: uncompress size:%d [%d], compressed size:%d [%d] thisWastedBytes:%d [%d]\n",
                     __LINE__,
                     totalPackets,
-                    nodeData->getPacketLengthUncompressed(), ::totalUncompressed,
+                    nodeData->getPacketLength(), ::totalUncompressed,
                     nodeData->getPacketLength(), ::totalCompressed,
                     thisWastedBytes, ::totalWastedBytes);
             }

libraries/voxels/src/VoxelPacket.cpp

@@ -129,3 +129,29 @@ bool VoxelPacket::appendColor(rgbColor color) {
     return success;
 }
 
+/***
+void VoxelPacket::compressPacket() { 
+    int uncompressedLength = getPacketLengthUncompressed();
+    const int MAX_COMPRESSION = 9;
+    // we only want to compress the data payload, not the message header
+    int numBytesPacketHeader = numBytesForPacketHeader(_voxelPacket);
+    QByteArray compressedData = qCompress(_voxelPacket+numBytesPacketHeader, 
+                                    uncompressedLength-numBytesPacketHeader, MAX_COMPRESSION);
+    _compressedPacket.clear();
+    _compressedPacket.append((const char*)_voxelPacket, numBytesPacketHeader);
+    _compressedPacket.append(compressedData);
+}
+
+void VoxelPacket::uncompressPacket() { 
+    int numBytesPacketHeader = numBytesForPacketHeader(packetData);
+    QByteArray compressedData((const char*)packetData + numBytesPacketHeader, 
+                            messageLength - numBytesPacketHeader);
+    QByteArray uncompressedData = qUncompress(compressedData);
+    QByteArray uncompressedPacket((const char*)packetData, numBytesPacketHeader);
+    uncompressedPacket.append(uncompressedData);
+    //app->_voxels.parseData((unsigned char*)uncompressedPacket.data(), uncompressedPacket.size());
+}
+***/
+
+
+

libraries/voxels/src/VoxelTree.cpp

@@ -1247,7 +1247,7 @@ int VoxelTree::encodeTreeBitstreamRecursion(VoxelNode* node,
     unsigned char childrenExistInTreeBits = 0;
     unsigned char childrenExistInPacketBits = 0;
     unsigned char childrenColoredBits = 0;
-        const int BYTES_PER_COLOR = 3;
+    const int BYTES_PER_COLOR = 3;
 
     // Make our local buffer large enough to handle writing at this level in case we need to.
     int thisLevelKey = packet->startLevel();