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 (at) 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 VP8PutBits(VP8BitWriter* const bw, uint32_t value, int nb_bits); 49 void VP8PutSignedBits(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) 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. 61 static WEBP_INLINE uint8_t* VP8BitWriterBuf(const VP8BitWriter* const bw) { 62 return bw->buf_; 63 } 64 // Returns the size of the internal buffer. 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 #define VP8L_WRITER_BYTES 4 // sizeof(vp8l_wtype_t) 77 #define VP8L_WRITER_BITS 32 // 8 * sizeof(vp8l_wtype_t) 78 #define VP8L_WRITER_MAX_BITS 64 // 8 * sizeof(vp8l_atype_t) 79 #else 80 typedef uint32_t vp8l_atype_t; 81 typedef uint16_t vp8l_wtype_t; 82 #define WSWAP HToLE16 83 #define VP8L_WRITER_BYTES 2 84 #define VP8L_WRITER_BITS 16 85 #define VP8L_WRITER_MAX_BITS 32 86 #endif 87 88 typedef struct { 89 vp8l_atype_t bits_; // bit accumulator 90 int used_; // number of bits used in accumulator 91 uint8_t* buf_; // start of buffer 92 uint8_t* cur_; // current write position 93 uint8_t* end_; // end of buffer 94 95 // After all bits are written (VP8LBitWriterFinish()), the caller must observe 96 // the state of error_. A value of 1 indicates that a memory allocation 97 // failure has happened during bit writing. A value of 0 indicates successful 98 // writing of bits. 99 int error_; 100 } VP8LBitWriter; 101 102 static WEBP_INLINE size_t VP8LBitWriterNumBytes(VP8LBitWriter* const bw) { 103 return (bw->cur_ - bw->buf_) + ((bw->used_ + 7) >> 3); 104 } 105 106 // Returns false in case of memory allocation error. 107 int VP8LBitWriterInit(VP8LBitWriter* const bw, size_t expected_size); 108 // Finalize the bitstream coding. Returns a pointer to the internal buffer. 109 uint8_t* VP8LBitWriterFinish(VP8LBitWriter* const bw); 110 // Release any pending memory and zeroes the object. 111 void VP8LBitWriterWipeOut(VP8LBitWriter* const bw); 112 113 // Internal function for VP8LPutBits flushing 32 bits from the written state. 114 void VP8LPutBitsFlushBits(VP8LBitWriter* const bw); 115 116 // PutBits internal function used in the 16 bit vp8l_wtype_t case. 117 void VP8LPutBitsInternal(VP8LBitWriter* const bw, uint32_t bits, int n_bits); 118 119 // This function writes bits into bytes in increasing addresses (little endian), 120 // and within a byte least-significant-bit first. 121 // This function can write up to 32 bits in one go, but VP8LBitReader can only 122 // read 24 bits max (VP8L_MAX_NUM_BIT_READ). 123 // VP8LBitWriter's error_ flag is set in case of memory allocation error. 124 static WEBP_INLINE void VP8LPutBits(VP8LBitWriter* const bw, 125 uint32_t bits, int n_bits) { 126 if (sizeof(vp8l_wtype_t) == 4) { 127 if (n_bits > 0) { 128 if (bw->used_ >= 32) { 129 VP8LPutBitsFlushBits(bw); 130 } 131 bw->bits_ |= (vp8l_atype_t)bits << bw->used_; 132 bw->used_ += n_bits; 133 } 134 } else { 135 VP8LPutBitsInternal(bw, bits, n_bits); 136 } 137 } 138 139 //------------------------------------------------------------------------------ 140 141 #ifdef __cplusplus 142 } // extern "C" 143 #endif 144 145 #endif /* WEBP_UTILS_BIT_WRITER_H_ */ 146
