blob: daf6d11ecd17040f66d5b0524946aac680cd68bb (
plain)
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
|
// Copyright (C) 2003 Davis E. King (davis@dlib.net)
// License: Boost Software License See LICENSE.txt for the full license.
#ifndef DLIB_ENTROPY_DECODER_KERNEl_1_
#define DLIB_ENTROPY_DECODER_KERNEl_1_
#include "../algs.h"
#include "entropy_decoder_kernel_abstract.h"
#include <iosfwd>
#include "../uintn.h"
namespace dlib
{
class entropy_decoder_kernel_1
{
/*!
GENERAL NOTES
this decoder is implemented using arithmetic coding
INITIAL VALUE
in == 0
buf_used == 0
buf == 0
initial_low == 0x00000001 (slightly more than zero)
initial_high == 0xffffffff (slightly less than one, 0.99999999976717)
target == 0x00000000 (zero)
low == initial_low
high == initial_high
r == 0
CONVENTION
if (in != 0)
*in == get_stream()
true == stream_is_set()
streambuf == in->rdbuf()
else
false == stream_is_set()
buf == used to hold fractional byte values which are fed to target.
buf_used == the number of low order bits in buf that are currently
in use
low == the low end of the range used for arithmetic encoding.
this number is used as a 32bit fixed point real number.
the point is fixed just before the first bit, so it is
always in the range [0,1)
low is also never allowed to be zero to avoid overflow
in the calculation (high-low+1)/total.
high == the high end of the range - 1 used for arithmetic encoding.
this number is used as a 32bit fixed point real number.
the point is fixed just before the first bit, so when we
interpret high as a real number then it is always in the
range [0,1)
the range for arithmetic encoding is always
[low,high + 0.9999999...) the 0.9999999... is why
high == real upper range - 1
target == 32 bits of the fraction produced from an arithmetic encoder.
this number is used as a 32bit fixed point real number.
the point is fixed just before the first bit, so it is
always in the range [0,1)
r == the value (high-low+1)/total from the last call to
get_target() or 0 if get_target_called() should be false
get_target_called() == (r != 0)
!*/
public:
entropy_decoder_kernel_1 (
);
virtual ~entropy_decoder_kernel_1 (
);
void clear(
);
void set_stream (
std::istream& in
);
bool stream_is_set (
) const;
std::istream& get_stream (
) const;
void decode (
uint32 low_count,
uint32 high_count
);
bool get_target_called (
) const;
uint32 get_target (
uint32 total
);
private:
// restricted functions
entropy_decoder_kernel_1(entropy_decoder_kernel_1&); // copy constructor
entropy_decoder_kernel_1& operator=(entropy_decoder_kernel_1&); // assignment operator
// data members
const uint32 initial_low;
const uint32 initial_high;
std::istream* in;
uint32 low;
uint32 high;
unsigned char buf;
uint32 buf_used;
uint32 target;
uint32 r;
std::streambuf* streambuf;
};
}
#ifdef NO_MAKEFILE
#include "entropy_decoder_kernel_1.cpp"
#endif
#endif // DLIB_ENTROPY_DECODER_KERNEl_1_
|
