From 3e21f5f67791751b6564fb24f6a6cdeef175968b Mon Sep 17 00:00:00 2001 From: bank Date: Tue, 13 May 2014 18:25:47 +0400 Subject: [PATCH] Rename all member variables to follow the style guidelines (prefixed with the 'm') - class BitStream --- Engine/source/core/stream/bitStream.cpp | 124 ++++++++++++------------ Engine/source/core/stream/bitStream.h | 38 ++++---- 2 files changed, 81 insertions(+), 81 deletions(-) diff --git a/Engine/source/core/stream/bitStream.cpp b/Engine/source/core/stream/bitStream.cpp index 4ea46b6f5..56e0c85c8 100644 --- a/Engine/source/core/stream/bitStream.cpp +++ b/Engine/source/core/stream/bitStream.cpp @@ -78,18 +78,18 @@ ResizeBitStream::ResizeBitStream(U32 minSpace, U32 initialSize) : BitStream(NULL ResizeBitStream::~ResizeBitStream() { - dFree(dataPtr); + dFree(mDataPtr); } void ResizeBitStream::validate() { - if(getPosition() + mMinSpace > bufSize) + if(getPosition() + mMinSpace > mBufSize) { - bufSize = getPosition() + mMinSpace * 2; - dataPtr = (U8 *) dRealloc(dataPtr, bufSize); + mBufSize = getPosition() + mMinSpace * 2; + mDataPtr = (U8 *) dRealloc(mDataPtr, mBufSize); - maxReadBitNum = bufSize << 3; - maxWriteBitNum = bufSize << 3; + mMaxReadBitNum = mBufSize << 3; + mMaxWriteBitNum = mBufSize << 3; } } @@ -148,53 +148,53 @@ HuffmanProcessor HuffmanProcessor::g_huffProcessor; void BitStream::setBuffer(void *bufPtr, S32 size, S32 maxSize) { - dataPtr = (U8 *) bufPtr; - bitNum = 0; - bufSize = size; - maxReadBitNum = size << 3; + mDataPtr = (U8 *) bufPtr; + mBitNum = 0; + mBufSize = size; + mMaxReadBitNum = size << 3; if(maxSize < 0) maxSize = size; - maxWriteBitNum = maxSize << 3; - error = false; + mMaxWriteBitNum = maxSize << 3; + mError = false; clearCompressionPoint(); } U32 BitStream::getPosition() const { - return (bitNum + 7) >> 3; + return (mBitNum + 7) >> 3; } bool BitStream::setPosition(const U32 pos) { - bitNum = pos << 3; + mBitNum = pos << 3; return (true); } U32 BitStream::getStreamSize() { - return bufSize; + return mBufSize; } U8 *BitStream::getBytePtr() { - return dataPtr + getPosition(); + return mDataPtr + getPosition(); } U32 BitStream::getReadByteSize() { - return (maxReadBitNum >> 3) - getPosition(); + return (mMaxReadBitNum >> 3) - getPosition(); } U32 BitStream::getWriteByteSize() { - return (maxWriteBitNum >> 3) - getPosition(); + return (mMaxWriteBitNum >> 3) - getPosition(); } void BitStream::clear() { - dMemset(dataPtr, 0, bufSize); + dMemset(mDataPtr, 0, mBufSize); } void BitStream::writeClassId(U32 classId, U32 classType, U32 classGroup) @@ -228,9 +228,9 @@ void BitStream::writeBits(S32 bitCount, const void *bitPtr) if(!bitCount) return; - if(bitCount + bitNum > maxWriteBitNum) + if(bitCount + mBitNum > mMaxWriteBitNum) { - error = true; + mError = true; AssertFatal(false, "Out of range write"); return; } @@ -242,39 +242,39 @@ void BitStream::writeBits(S32 bitCount, const void *bitPtr) for(S32 srcBitNum = 0;srcBitNum < bitCount;srcBitNum++) { if((*(ptr + (srcBitNum >> 3)) & (1 << (srcBitNum & 0x7))) != 0) - *(dataPtr + (bitNum >> 3)) |= (1 << (bitNum & 0x7)); + *(mDataPtr + (mBitNum >> 3)) |= (1 << (mBitNum & 0x7)); else - *(dataPtr + (bitNum >> 3)) &= ~(1 << (bitNum & 0x7)); - bitNum++; + *(mDataPtr + (mBitNum >> 3)) &= ~(1 << (mBitNum & 0x7)); + mBitNum++; } } void BitStream::setBit(S32 bitCount, bool set) { if(set) - *(dataPtr + (bitCount >> 3)) |= (1 << (bitCount & 0x7)); + *(mDataPtr + (bitCount >> 3)) |= (1 << (bitCount & 0x7)); else - *(dataPtr + (bitCount >> 3)) &= ~(1 << (bitCount & 0x7)); + *(mDataPtr + (bitCount >> 3)) &= ~(1 << (bitCount & 0x7)); } bool BitStream::testBit(S32 bitCount) { - return (*(dataPtr + (bitCount >> 3)) & (1 << (bitCount & 0x7))) != 0; + return (*(mDataPtr + (bitCount >> 3)) & (1 << (bitCount & 0x7))) != 0; } bool BitStream::writeFlag(bool val) { - if(bitNum + 1 > maxWriteBitNum) + if(mBitNum + 1 > mMaxWriteBitNum) { - error = true; + mError = true; AssertFatal(false, "Out of range write"); return false; } if(val) - *(dataPtr + (bitNum >> 3)) |= (1 << (bitNum & 0x7)); + *(mDataPtr + (mBitNum >> 3)) |= (1 << (mBitNum & 0x7)); else - *(dataPtr + (bitNum >> 3)) &= ~(1 << (bitNum & 0x7)); - bitNum++; + *(mDataPtr + (mBitNum >> 3)) &= ~(1 << (mBitNum & 0x7)); + mBitNum++; return (val); } @@ -282,23 +282,23 @@ void BitStream::readBits(S32 bitCount, void *bitPtr) { if(!bitCount) return; - if(bitCount + bitNum > maxReadBitNum) + if(bitCount + mBitNum > mMaxReadBitNum) { - error = true; + mError = true; //AssertFatal(false, "Out of range read"); AssertWarn(false, "Out of range read"); return; } - U8 *stPtr = dataPtr + (bitNum >> 3); + U8 *stPtr = mDataPtr + (mBitNum >> 3); S32 byteCount = (bitCount + 7) >> 3; U8 *ptr = (U8 *) bitPtr; - S32 downShift = bitNum & 0x7; + S32 downShift = mBitNum & 0x7; S32 upShift = 8 - downShift; U8 curB = *stPtr; - const U8 *stEnd = dataPtr + bufSize; + const U8 *stEnd = mDataPtr + mBufSize; while(byteCount--) { stPtr++; @@ -307,7 +307,7 @@ void BitStream::readBits(S32 bitCount, void *bitPtr) curB = nextB; } - bitNum += bitCount; + mBitNum += bitCount; } bool BitStream::_read(U32 size, void *dataPtr) @@ -625,69 +625,69 @@ void InfiniteBitStream::reset() void InfiniteBitStream::validate(U32 upcomingBytes) { - if(getPosition() + upcomingBytes + mMinSpace > bufSize) + if(getPosition() + upcomingBytes + mMinSpace > mBufSize) { - bufSize = getPosition() + upcomingBytes + mMinSpace; - dataPtr = (U8 *) dRealloc(dataPtr, bufSize); + mBufSize = getPosition() + upcomingBytes + mMinSpace; + mDataPtr = (U8 *) dRealloc(mDataPtr, mBufSize); - maxReadBitNum = bufSize << 3; - maxWriteBitNum = bufSize << 3; + mMaxReadBitNum = mBufSize << 3; + mMaxWriteBitNum = mBufSize << 3; } } void InfiniteBitStream::compact() { // Prepare to copy... - U32 oldSize = bufSize; - U8 *tmp = (U8*)dMalloc(bufSize); + U32 oldSize = mBufSize; + U8 *tmp = (U8*)dMalloc(mBufSize); // Copy things... - bufSize = getPosition() + mMinSpace * 2; - dMemcpy(tmp, dataPtr, oldSize); + mBufSize = getPosition() + mMinSpace * 2; + dMemcpy(tmp, mDataPtr, oldSize); // And clean up. - dFree(dataPtr); - dataPtr = tmp; + dFree(mDataPtr); + mDataPtr = tmp; - maxReadBitNum = bufSize << 3; - maxWriteBitNum = bufSize << 3; + mMaxReadBitNum = mBufSize << 3; + mMaxWriteBitNum = mBufSize << 3; } void InfiniteBitStream::writeToStream(Stream &s) { - s.write(getPosition(), dataPtr); + s.write(getPosition(), mDataPtr); } //------------------------------------------------------------------------------ void BitStream::readString(char buf[256]) { - if(stringBuffer) + if(mStringBuffer) { if(readFlag()) { S32 offset = readInt(8); - HuffmanProcessor::g_huffProcessor.readHuffBuffer(this, stringBuffer + offset); - dStrcpy(buf, stringBuffer); + HuffmanProcessor::g_huffProcessor.readHuffBuffer(this, mStringBuffer + offset); + dStrcpy(buf, mStringBuffer); return; } } HuffmanProcessor::g_huffProcessor.readHuffBuffer(this, buf); - if(stringBuffer) - dStrcpy(stringBuffer, buf); + if(mStringBuffer) + dStrcpy(mStringBuffer, buf); } void BitStream::writeString(const char *string, S32 maxLen) { if(!string) string = ""; - if(stringBuffer) + if(mStringBuffer) { S32 j; - for(j = 0; j < maxLen && stringBuffer[j] == string[j] && string[j];j++) + for(j = 0; j < maxLen && mStringBuffer[j] == string[j] && string[j];j++) ; - dStrncpy(stringBuffer, string, maxLen); - stringBuffer[maxLen] = 0; + dStrncpy(mStringBuffer, string, maxLen); + mStringBuffer[maxLen] = 0; if(writeFlag(j > 2)) { @@ -781,7 +781,7 @@ void HuffmanProcessor::generateCodes(BitStream& rBS, S32 index, S32 depth) // leaf node, copy the code in, and back out... HuffLeaf& rLeaf = m_huffLeaves[-(index + 1)]; - dMemcpy(&rLeaf.code, rBS.dataPtr, sizeof(rLeaf.code)); + dMemcpy(&rLeaf.code, rBS.mDataPtr, sizeof(rLeaf.code)); rLeaf.numBits = depth; } else { HuffNode& rNode = m_huffNodes[index]; diff --git a/Engine/source/core/stream/bitStream.h b/Engine/source/core/stream/bitStream.h index 7f6fe82ca..666fb960b 100644 --- a/Engine/source/core/stream/bitStream.h +++ b/Engine/source/core/stream/bitStream.h @@ -48,13 +48,13 @@ class QuatF; class BitStream : public Stream { protected: - U8 *dataPtr; - S32 bitNum; - S32 bufSize; - bool error; - S32 maxReadBitNum; - S32 maxWriteBitNum; - char *stringBuffer; + U8 *mDataPtr; + S32 mBitNum; + S32 mBufSize; + bool mError; + S32 mMaxReadBitNum; + S32 mMaxWriteBitNum; + char *mStringBuffer; Point3F mCompressPoint; friend class HuffmanProcessor; @@ -63,7 +63,7 @@ public: static void sendPacketStream(const NetAddress *addr); void setBuffer(void *bufPtr, S32 bufSize, S32 maxSize = 0); - U8* getBuffer() { return dataPtr; } + U8* getBuffer() { return mDataPtr; } U8* getBytePtr(); U32 getReadByteSize(); @@ -83,7 +83,7 @@ public: S32 getBitPosition() const { return getCurPos(); } void clearStringBuffer(); - BitStream(void *bufPtr, S32 bufSize, S32 maxWriteSize = -1) { setBuffer(bufPtr, bufSize,maxWriteSize); stringBuffer = NULL; } + BitStream(void *bufPtr, S32 bufSize, S32 maxWriteSize = -1) { setBuffer(bufPtr, bufSize,maxWriteSize); mStringBuffer = NULL; } void clear(); void setStringBuffer(char buffer[256]); @@ -241,8 +241,8 @@ public: void setBit(S32 bitCount, bool set); bool testBit(S32 bitCount); - bool isFull() { return bitNum > (bufSize << 3); } - bool isValid() { return !error; } + bool isFull() { return mBitNum > (mBufSize << 3); } + bool isValid() { return !mError; } bool _read (const U32 size,void* d); bool _write(const U32 size,const void* d); @@ -313,26 +313,26 @@ public: // inline S32 BitStream::getCurPos() const { - return bitNum; + return mBitNum; } inline void BitStream::setCurPos(const U32 in_position) { - AssertFatal(in_position < (U32)(bufSize << 3), "Out of range bitposition"); - bitNum = S32(in_position); + AssertFatal(in_position < (U32)(mBufSize << 3), "Out of range bitposition"); + mBitNum = S32(in_position); } inline bool BitStream::readFlag() { - if(bitNum > maxReadBitNum) + if(mBitNum > mMaxReadBitNum) { - error = true; + mError = true; AssertFatal(false, "Out of range read"); return false; } - S32 mask = 1 << (bitNum & 0x7); - bool ret = (*(dataPtr + (bitNum >> 3)) & mask) != 0; - bitNum++; + S32 mask = 1 << (mBitNum & 0x7); + bool ret = (*(mDataPtr + (mBitNum >> 3)) & mask) != 0; + mBitNum++; return ret; }