arcoder/BitStream.cpp at master · DeeSee/arcoder · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
#include "BitStream.h"

#include "assert.h"


static const int kBitsInByte = 8;


class OutputBitStream : public IOutputBitStream // implements basic logic of bits accumulation
{
  int m_unflushedBitsCount;

protected:

  OutputBitStream() : m_unflushedBitsCount(0),
                      m_bitsBuffer(0)
  {}

  char m_bitsBuffer;

  virtual void FlushBuffer() = 0; // should flush byte from m_bitsBuffer to data container

public:

  // inherited methods

  virtual void Finish();

  virtual void PutBit(char bit);

};

/**************************************************************************************************/
void OutputBitStream::PutBit(char bit)
{
  assert(bit == 0 || bit == 1);

  m_unflushedBitsCount++;
  m_bitsBuffer = (m_bitsBuffer << 1) | bit;

  if (m_unflushedBitsCount == kBitsInByte)
  {
    FlushBuffer();
    m_unflushedBitsCount = 0;
    m_bitsBuffer = 0;
  }
}

/**************************************************************************************************/
void OutputBitStream::Finish()
{
  if (m_unflushedBitsCount != 0)
  {
    m_bitsBuffer <<= (kBitsInByte - m_unflushedBitsCount);
    FlushBuffer();
  }
}

class StdOutputBitStream : public OutputBitStream
{
  StdOutputBitStream(); // disable default constructor

  std::ostream& m_stream;

protected:

  virtual void FlushBuffer();

public:

  // constructor

  StdOutputBitStream(std::ostream& i_stream) : m_stream(i_stream) {}
};

/**************************************************************************************************/
void StdOutputBitStream::FlushBuffer()
{
  m_stream.write(&m_bitsBuffer, sizeof(m_bitsBuffer));
}

/**************************************************************************************************/
IOutputBitStream* CreateOutputBitStream(std::ostream& i_stream)
{
  return new StdOutputBitStream(i_stream);
}


class InputBitStream : public IInputBitStream // implements basic logic of bits accumulation
{
  int m_storedBitsCount;

protected:

  InputBitStream() : m_storedBitsCount(0),
                     m_bitsBuffer(0)
  {}

  char m_bitsBuffer;

  virtual void LoadBuffer() = 0; // should load byte from data container to m_bitsBuffer

public:

  virtual char GetBit();

};

/**************************************************************************************************/
char InputBitStream::GetBit()
{
  if (m_storedBitsCount == 0)
  {
    LoadBuffer();
    m_storedBitsCount = kBitsInByte;
  }

  char result = (m_bitsBuffer & 0x80) >> (kBitsInByte - 1);

  m_bitsBuffer <<= 1;
  m_storedBitsCount--;

  return result;
}

class StdInputBitStream : public InputBitStream
{
  StdInputBitStream(); // disable default constructor

  std::istream& m_stream;

protected:

  virtual void LoadBuffer();

public:

  // Constructor

  StdInputBitStream(std::istream& i_stream) : m_stream(i_stream) {}
};

/**************************************************************************************************/
void StdInputBitStream::LoadBuffer()
{
  m_stream.read(&m_bitsBuffer, sizeof(m_bitsBuffer));
}

/**************************************************************************************************/
IInputBitStream* CreateInputBitStream(std::istream& i_stream)
{
  return new StdInputBitStream(i_stream);
}