codebuf.cpp

一个编码器

// codebuf.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <assert.h>

typedef unsigned char u_char;
typedef unsigned short u_short;
typedef unsigned int u_int;

const int FLAG_BIT_COUNT = 2;
const int LEN_BIT_COUNT = 14;
const int CODE_BIT_COUNT = 32;

class codebuf
{
public:
	//	
	bool output(u_char flag, u_short len, u_int code){
		if (!output_bits(flag, FLAG_BIT_COUNT))
			return false;
		if (!output_bits(len, LEN_BIT_COUNT))
			return false;
		if (!output_bits(code>>16, CODE_BIT_COUNT-16))
			return false;
		return output_bits(code&0xffff, 16);
	}
	//	
	bool input(u_char& flag, u_short& len, u_int& code){
		u_int val = 0;
		if (!input_bits(val, FLAG_BIT_COUNT))
			return false;
		flag = (u_char)val;
		if (!input_bits(val, LEN_BIT_COUNT))
			return false;
		len = (u_short)val;
		if (!input_bits(val, CODE_BIT_COUNT-16))
			return false;
		u_int high = val;
		if (!input_bits(val, 16))
			return false;
		code = (high << 16) | val;
		return true;
	}
	bool flush(){	//刷新编码器
		return output_bits(0, 16) && output_bits(0, 16);		
	}

	bool output_bits(u_int val, int bitCount){	//输出若干位
		assert(bitCount <= 16);
		//	先把多余的位移除，使其清零
		val <<= 32-bitCount;
		val >>= 32-bitCount;
		//	将所有的位移入位缓存，跟在残余数据位后面
		m_bitBuf |= val << (32-bitCount-m_bitCount);
		m_bitCount += bitCount;
		//	一旦缓存中的位超过8位，输出到输出缓冲区中
		while(m_bitCount >= 8)
		{
			if (m_count >= m_bufSize)		//缓冲区不够用了
				return false;
			m_pBuf[m_count++] = (u_char)(m_bitBuf >> 24);
			m_bitBuf <<= 8;
			m_bitCount -= 8;
		}
		return true;		
	}
	bool input_bits(u_int& val, int bitCount){	//输入若干位
		assert(bitCount <= 16);
		
		while (m_bitCount <= bitCount)
		{
			if (m_count >= m_bufSize)
				return false;
			m_bitBuf |= (u_int)m_pBuf[m_count++] << (24-m_bitCount);
			m_bitCount += 8;
		}
		val = m_bitBuf >> (32-bitCount);
		m_bitBuf <<= bitCount;
		m_bitCount -= bitCount;
		return true;
	}

	void set_buf(u_char* pBuf, size_t bufSize){
		m_bitCount = 0;
		m_bitBuf = 0L;
		m_pBuf = pBuf;
		m_bufSize = bufSize;
		m_count = 0;
	}
	size_t get_count() const{
		return m_count;
	}
protected:
	u_char* m_pBuf;
	size_t m_bufSize;
	size_t m_count;

	int m_bitCount;
	u_int m_bitBuf;
};


int main(int argc, char* argv[])
{
	u_char buf[1024];

	codebuf coder;

	coder.set_buf(buf, sizeof(buf));

	assert(coder.output(0x1, 0x3344, 0x1000));
	assert(coder.output(0x0, 0x5566, 0xffff));
	assert(coder.output(0x1, 0x6677, 0x1234567));
	assert(coder.flush());

	size_t count = coder.get_count();

	u_char flag;
	u_short len;
	u_int value;

	coder.set_buf(buf, count);

	assert(coder.input(flag, len, value));
	printf("flag: 0x%x, len: 0x%x, value: 0x%x\n", flag, len, value);
	assert(coder.input(flag, len, value));
	printf("flag: 0x%x, len: 0x%x, value: 0x%x\n", flag, len, value);
	assert(coder.input(flag, len, value));
	printf("flag: 0x%x, len: 0x%x, value: 0x%x\n", flag, len, value);

	return 0;
}