1 // Copyright 2011 Google Inc. All Rights Reserved.
2 //
3 // Use of this source code is governed by a BSD-style license
4 // that can be found in the COPYING file in the root of the source
5 // tree. An additional intellectual property rights grant can be found
6 // in the file PATENTS. All contributing project authors may
7 // be found in the AUTHORS file in the root of the source tree.
8 // -----------------------------------------------------------------------------
9 //
10 // Bit writing and boolean coder
11 //
12 // Author: Skal (pascal.massimino@gmail.com)
13
14 #ifndef WEBP_UTILS_BIT_WRITER_H_
15 #define WEBP_UTILS_BIT_WRITER_H_
16
17 #include "../webp/types.h"
18
19 #ifdef __cplusplus
20 extern "C" {
21 #endif
22
23 //------------------------------------------------------------------------------
24 // Bit-writing
25
26 typedef struct VP8BitWriter VP8BitWriter;
27 struct VP8BitWriter {
28 int32_t range_; // range-1
29 int32_t value_;
30 int run_; // number of outstanding bits
31 int nb_bits_; // number of pending bits
32 uint8_t* buf_; // internal buffer. Re-allocated regularly. Not owned.
33 size_t pos_;
34 size_t max_pos_;
35 int error_; // true in case of error
36 };
37
38 // Initialize the object. Allocates some initial memory based on expected_size.
39 int VP8BitWriterInit(VP8BitWriter* const bw, size_t expected_size);
40 // Finalize the bitstream coding. Returns a pointer to the internal buffer.
41 uint8_t* VP8BitWriterFinish(VP8BitWriter* const bw);
42 // Release any pending memory and zeroes the object. Not a mandatory call.
43 // Only useful in case of error, when the internal buffer hasn't been grabbed!
44 void VP8BitWriterWipeOut(VP8BitWriter* const bw);
45
46 int VP8PutBit(VP8BitWriter* const bw, int bit, int prob);
47 int VP8PutBitUniform(VP8BitWriter* const bw, int bit);
48 void VP8PutValue(VP8BitWriter* const bw, int value, int nb_bits);
49 void VP8PutSignedValue(VP8BitWriter* const bw, int value, int nb_bits);
50
51 // Appends some bytes to the internal buffer. Data is copied.
52 int VP8BitWriterAppend(VP8BitWriter* const bw,
53 const uint8_t* data, size_t size);
54
55 // return approximate write position (in bits)
VP8BitWriterPos(const VP8BitWriter * const bw)56 static WEBP_INLINE uint64_t VP8BitWriterPos(const VP8BitWriter* const bw) {
57 return (uint64_t)(bw->pos_ + bw->run_) * 8 + 8 + bw->nb_bits_;
58 }
59
60 // Returns a pointer to the internal buffer.
VP8BitWriterBuf(const VP8BitWriter * const bw)61 static WEBP_INLINE uint8_t* VP8BitWriterBuf(const VP8BitWriter* const bw) {
62 return bw->buf_;
63 }
64 // Returns the size of the internal buffer.
VP8BitWriterSize(const VP8BitWriter * const bw)65 static WEBP_INLINE size_t VP8BitWriterSize(const VP8BitWriter* const bw) {
66 return bw->pos_;
67 }
68
69 //------------------------------------------------------------------------------
70 // VP8LBitWriter
71
72 #if defined(__x86_64__) || defined(_M_X64) // 64bit
73 typedef uint64_t vp8l_atype_t; // accumulator type
74 typedef uint32_t vp8l_wtype_t; // writing type
75 #define WSWAP HToLE32
76 #else
77 typedef uint32_t vp8l_atype_t;
78 typedef uint16_t vp8l_wtype_t;
79 #define WSWAP HToLE16
80 #endif
81
82 typedef struct {
83 vp8l_atype_t bits_; // bit accumulator
84 int used_; // number of bits used in accumulator
85 uint8_t* buf_; // start of buffer
86 uint8_t* cur_; // current write position
87 uint8_t* end_; // end of buffer
88
89 // After all bits are written (VP8LBitWriterFinish()), the caller must observe
90 // the state of error_. A value of 1 indicates that a memory allocation
91 // failure has happened during bit writing. A value of 0 indicates successful
92 // writing of bits.
93 int error_;
94 } VP8LBitWriter;
95
VP8LBitWriterNumBytes(VP8LBitWriter * const bw)96 static WEBP_INLINE size_t VP8LBitWriterNumBytes(VP8LBitWriter* const bw) {
97 return (bw->cur_ - bw->buf_) + ((bw->used_ + 7) >> 3);
98 }
99
100 uint8_t* VP8LBitWriterFinish(VP8LBitWriter* const bw);
101
102 // Returns 0 in case of memory allocation error.
103 int VP8LBitWriterInit(VP8LBitWriter* const bw, size_t expected_size);
104
105 void VP8LBitWriterDestroy(VP8LBitWriter* const bw);
106
107 // This function writes bits into bytes in increasing addresses (little endian),
108 // and within a byte least-significant-bit first.
109 // This function can write up to 32 bits in one go, but VP8LBitReader can only
110 // read 24 bits max (VP8L_MAX_NUM_BIT_READ).
111 // VP8LBitWriter's error_ flag is set in case of memory allocation error.
112 void VP8LWriteBits(VP8LBitWriter* const bw, int n_bits, uint32_t bits);
113
114 //------------------------------------------------------------------------------
115
116 #ifdef __cplusplus
117 } // extern "C"
118 #endif
119
120 #endif /* WEBP_UTILS_BIT_WRITER_H_ */
121