summaryrefslogtreecommitdiff
path: root/Build/source/utils/asymptote/prc/PRCbitStream.cc
diff options
context:
space:
mode:
Diffstat (limited to 'Build/source/utils/asymptote/prc/PRCbitStream.cc')
-rw-r--r--Build/source/utils/asymptote/prc/PRCbitStream.cc404
1 files changed, 404 insertions, 0 deletions
diff --git a/Build/source/utils/asymptote/prc/PRCbitStream.cc b/Build/source/utils/asymptote/prc/PRCbitStream.cc
new file mode 100644
index 00000000000..9b18186a469
--- /dev/null
+++ b/Build/source/utils/asymptote/prc/PRCbitStream.cc
@@ -0,0 +1,404 @@
+/************
+*
+* This file is part of a tool for producing 3D content in the PRC format.
+* Copyright (C) 2008 Orest Shardt <shardtor (at) gmail dot com> and
+* Michail Vidiassov <master@iaas.msu.ru>
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with this program. If not, see <http://www.gnu.org/licenses/>.
+*
+*************/
+
+#include <iostream>
+#include <zlib.h>
+#include <stdlib.h>
+#include <string.h>
+#include <cassert>
+#include "PRCbitStream.h"
+#include "PRCdouble.h"
+
+using std::string;
+using std::cerr;
+using std::endl;
+
+void PRCbitStream::compress()
+{
+ const int CHUNK= 1024; // is this reasonable?
+ compressedDataSize = 0;
+
+ z_stream strm;
+ strm.zalloc = Z_NULL;
+ strm.zfree = Z_NULL;
+ strm.opaque = Z_NULL;
+ if(deflateInit(&strm,Z_DEFAULT_COMPRESSION) != Z_OK)
+ {
+ cerr << "Compression initialization failed" << endl;
+ return;
+ }
+ unsigned int sizeAvailable = deflateBound(&strm,getSize());
+ uint8_t *compressedData = (uint8_t*) malloc(sizeAvailable);
+ strm.avail_in = getSize();
+ strm.next_in = (unsigned char*)data;
+ strm.next_out = (unsigned char*)compressedData;
+ strm.avail_out = sizeAvailable;
+
+ int code;
+ unsigned int chunks = 0;
+ while((code = deflate(&strm,Z_FINISH)) == Z_OK)
+ {
+ ++chunks;
+ // strm.avail_out should be 0 if we got Z_OK
+ compressedDataSize = sizeAvailable - strm.avail_out;
+ compressedData = (uint8_t*) realloc(compressedData,CHUNK*chunks);
+ strm.next_out = (Bytef*)(compressedData + compressedDataSize);
+ strm.avail_out += CHUNK;
+ sizeAvailable += CHUNK;
+ }
+ compressedDataSize = sizeAvailable-strm.avail_out;
+
+ if(code != Z_STREAM_END)
+ {
+ cerr << "Compression error" << endl;
+ deflateEnd(&strm);
+ free(compressedData);
+ return;
+ }
+
+ compressed = true;
+
+ free(data);
+ data = compressedData;
+
+ deflateEnd(&strm);
+}
+
+void PRCbitStream::write(std::ostream &out) const
+{
+ if(compressed)
+ {
+ out.write((char*)data,compressedDataSize);
+ }
+ else
+ {
+ cerr << "Attempt to write stream before compression." << endl;
+ exit(1);
+ }
+}
+
+unsigned int PRCbitStream::getSize() const
+{
+ if(compressed)
+ return compressedDataSize;
+ else
+ return byteIndex+1;
+}
+
+uint8_t* PRCbitStream::getData()
+{
+ return data;
+}
+
+PRCbitStream& PRCbitStream::operator <<(bool b)
+{
+ writeBit(b);
+ return *this;
+}
+
+PRCbitStream& PRCbitStream::operator <<(uint32_t u)
+{
+ while(u != 0)
+ {
+ writeBit(1);
+ writeByte(u & 0xFF);
+ u >>= 8;
+ }
+ writeBit(0);
+ return *this;
+}
+
+PRCbitStream& PRCbitStream::operator <<(uint8_t u)
+{
+ writeByte(u);
+ return *this;
+}
+
+PRCbitStream& PRCbitStream::operator <<(int32_t i)
+{
+ uint8_t lastByte = 0;
+ //while(!((current value is 0 and last byte was positive) OR (current value is -1 and last value was negative)))
+ while(!(((i == 0)&&((lastByte & 0x80)==0))||((i == -1)&&((lastByte & 0x80) != 0))))
+ {
+ writeBit(1);
+ lastByte = i & 0xFF;
+ writeByte(lastByte);
+ i >>= 8;
+ }
+ writeBit(0);
+ return *this;
+}
+
+PRCbitStream& PRCbitStream::operator <<(double value)
+{
+ // write a double
+ if(compressed)
+ {
+ cerr << "Cannot write to a stream that has been compressed." << endl;
+ return *this;
+ }
+ union ieee754_double *pid=(union ieee754_double *)&value;
+ int
+ i,
+ fSaveAtEnd;
+ PRCbyte
+ *pb,
+ *pbStart,
+ *pbStop,
+ *pbEnd,
+ *pbResult,
+ bSaveAtEnd = 0;
+ struct sCodageOfFrequentDoubleOrExponent
+ cofdoe,
+ *pcofdoe;
+
+ cofdoe.u2uod.Value=value;
+ pcofdoe = (struct sCodageOfFrequentDoubleOrExponent *)bsearch(
+ &cofdoe,
+ acofdoe,
+ sizeof(acofdoe)/sizeof(pcofdoe[0]),
+ sizeof(pcofdoe[0]),
+ stCOFDOECompare);
+
+ while(pcofdoe>acofdoe && EXPONENT(pcofdoe->u2uod.Value)==EXPONENT((pcofdoe-1)->u2uod.Value))
+ pcofdoe--;
+
+ assert(pcofdoe);
+ while(pcofdoe->Type==VT_double)
+ {
+ if(fabs(value)==pcofdoe->u2uod.Value)
+ break;
+ pcofdoe++;
+ }
+
+ for(i=1<<(pcofdoe->NumberOfBits-1);i>=1;i>>=1)
+ writeBit((pcofdoe->Bits&i)!=0);
+
+ if
+ (
+ !memcmp(&value,stadwZero,sizeof(value))
+ || !memcmp(&value,stadwNegativeZero,sizeof(value))
+ )
+ return *this;
+
+ writeBit(pid->ieee.negative);
+
+ if(pcofdoe->Type==VT_double)
+ return *this;
+
+ if(pid->ieee.mantissa0==0 && pid->ieee.mantissa1==0)
+ {
+ writeBit(0);
+ return *this;
+ }
+
+ writeBit(1);
+
+#ifdef WORDS_BIGENDIAN
+ pb=((PRCbyte *)&value)+1;
+#else
+ pb=((PRCbyte *)&value)+6;
+#endif
+ //add_bits((*pb)&0x0f,4 STAT_V STAT_DOUBLE);
+ writeBits((*pb)&0x0F,4);
+
+ NEXTBYTE(pb);
+ pbStart=pb;
+#ifdef WORDS_BIGENDIAN
+ pbEnd=
+ pbStop= ((PRCbyte *)(&value+1))-1;
+#else
+ pbEnd=
+ pbStop= ((PRCbyte *)&value);
+#endif
+
+ if((fSaveAtEnd=(*pbStop!=*BEFOREBYTE(pbStop)))!=0)
+ bSaveAtEnd=*pbEnd;
+ PREVIOUSBYTE(pbStop);
+
+ while(*pbStop==*BEFOREBYTE(pbStop))
+ PREVIOUSBYTE(pbStop);
+
+ for(;MOREBYTE(pb,pbStop);NEXTBYTE(pb))
+ {
+ if(pb!=pbStart && (pbResult=SEARCHBYTE(BEFOREBYTE(pb),*pb,DIFFPOINTERS(pb,pbStart)))!=NULL)
+ {
+ writeBit(0);
+ writeBits(DIFFPOINTERS(pb,pbResult),3);
+ }
+ else
+ {
+ writeBit(1);
+ writeByte(*pb);
+ }
+ }
+
+ if(!MOREBYTE(BEFOREBYTE(pbEnd),pbStop))
+ {
+ if(fSaveAtEnd)
+ {
+ writeBit(0);
+ writeBits(6,3);
+ writeByte(bSaveAtEnd);
+ }
+ else
+ {
+ writeBit(0);
+ writeBits(0,3);
+ }
+ }
+ else
+ {
+ if((pbResult=SEARCHBYTE(BEFOREBYTE(pb),*pb,DIFFPOINTERS(pb,pbStart)))!=NULL)
+ {
+ writeBit(0);
+ writeBits(DIFFPOINTERS(pb,pbResult),3);
+ }
+ else
+ {
+ writeBit(1);
+ writeByte(*pb);
+ }
+ }
+
+ return *this;
+}
+
+PRCbitStream& PRCbitStream::operator <<(const char* s)
+{
+ if (s == NULL)
+ {
+ writeBit(false); // string is NULL
+ return *this;
+ }
+ string str(s);
+ *this << str;
+ return *this;
+}
+
+PRCbitStream& PRCbitStream::operator <<(const string& s)
+{
+ if(s == "")
+ {
+ writeBit(false); // string is NULL
+ return *this;
+ }
+ writeBit(true);
+ size_t l = s.length();
+ *this << static_cast<uint32_t>(l);
+ for(size_t i = 0; i < l; ++i)
+ writeByte(s[i]);
+ return *this;
+}
+
+void PRCbitStream::writeBit(bool b)
+{
+ if(compressed)
+ {
+ cerr << "Cannot write to a stream that has been compressed." << endl;
+ return;
+ }
+
+ if(b)
+ {
+ data[byteIndex] |= (0x80 >> bitIndex);
+ }
+ nextBit();
+}
+
+void PRCbitStream::writeBits(uint32_t u, uint8_t bits)
+{
+ if(bits > 32)
+ return;
+ else
+ {
+ for(uint32_t mask = (1 << (bits-1)); mask != 0; mask >>= 1)
+ {
+ writeBit((u&mask) != 0);
+ }
+ }
+}
+
+void PRCbitStream::writeByte(uint8_t u)
+{
+ if(compressed)
+ {
+ cerr << "Cannot write to a stream that has been compressed." << endl;
+ return;
+ }
+
+ if(bitIndex == 0)
+ {
+ data[byteIndex] = u;
+ nextByte();
+ }
+ else
+ {
+ data[byteIndex] |= (u >> bitIndex);
+ unsigned int obi = bitIndex;
+ nextByte();
+ data[byteIndex] |= (u << (8-obi));
+ bitIndex = obi; // bit index is not changed by writing 8 bits
+ }
+}
+
+void PRCbitStream::nextBit()
+{
+ ++bitIndex;
+ if(bitIndex == 8)
+ {
+ nextByte();
+ }
+}
+
+void PRCbitStream::nextByte()
+{
+ ++byteIndex;
+ if(byteIndex >= allocatedLength)
+ getAChunk();
+ data[byteIndex] = 0; // clear the garbage data
+ bitIndex = 0;
+}
+
+void PRCbitStream::getAChunk()
+{
+ if(allocatedLength==0)
+ data = (uint8_t*)realloc((void*)data,CHUNK_SIZE);
+ else
+ data = (uint8_t*)realloc((void*)data,2*allocatedLength);
+
+ if(data != NULL)
+ {
+ if(allocatedLength==0)
+ {
+ allocatedLength = CHUNK_SIZE;
+ *data = 0; // clear first byte
+ }
+ else
+ allocatedLength *= 2;
+ }
+ else
+ {
+ // warn about memory problem!
+ cerr << "Memory allocation error." << endl;
+ exit(1);
+ }
+}