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_UTILS_H_ 15 #define WEBP_UTILS_BIT_WRITER_UTILS_H_ 16 17 #include "src/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 const uint64_t nb_bits = 8 + bw->nb_bits_; // bw->nb_bits_ is <= 0, note 58 return (bw->pos_ + bw->run_) * 8 + nb_bits; 59 } 60 61 // Returns a pointer to the internal buffer. 62 static WEBP_INLINE uint8_t* VP8BitWriterBuf(const VP8BitWriter* const bw) { 63 return bw->buf_; 64 } 65 // Returns the size of the internal buffer. 66 static WEBP_INLINE size_t VP8BitWriterSize(const VP8BitWriter* const bw) { 67 return bw->pos_; 68 } 69 70 //------------------------------------------------------------------------------ 71 // VP8LBitWriter 72 73 #if defined(__x86_64__) || defined(_M_X64) // 64bit 74 typedef uint64_t vp8l_atype_t; // accumulator type 75 typedef uint32_t vp8l_wtype_t; // writing type 76 #define WSWAP HToLE32 77 #define VP8L_WRITER_BYTES 4 // sizeof(vp8l_wtype_t) 78 #define VP8L_WRITER_BITS 32 // 8 * sizeof(vp8l_wtype_t) 79 #define VP8L_WRITER_MAX_BITS 64 // 8 * sizeof(vp8l_atype_t) 80 #else 81 typedef uint32_t vp8l_atype_t; 82 typedef uint16_t vp8l_wtype_t; 83 #define WSWAP HToLE16 84 #define VP8L_WRITER_BYTES 2 85 #define VP8L_WRITER_BITS 16 86 #define VP8L_WRITER_MAX_BITS 32 87 #endif 88 89 typedef struct { 90 vp8l_atype_t bits_; // bit accumulator 91 int used_; // number of bits used in accumulator 92 uint8_t* buf_; // start of buffer 93 uint8_t* cur_; // current write position 94 uint8_t* end_; // end of buffer 95 96 // After all bits are written (VP8LBitWriterFinish()), the caller must observe 97 // the state of error_. A value of 1 indicates that a memory allocation 98 // failure has happened during bit writing. A value of 0 indicates successful 99 // writing of bits. 100 int error_; 101 } VP8LBitWriter; 102 103 static WEBP_INLINE size_t VP8LBitWriterNumBytes(const VP8LBitWriter* const bw) { 104 return (bw->cur_ - bw->buf_) + ((bw->used_ + 7) >> 3); 105 } 106 107 // Returns false in case of memory allocation error. 108 int VP8LBitWriterInit(VP8LBitWriter* const bw, size_t expected_size); 109 // Returns false in case of memory allocation error. 110 int VP8LBitWriterClone(const VP8LBitWriter* const src, 111 VP8LBitWriter* const dst); 112 // Finalize the bitstream coding. Returns a pointer to the internal buffer. 113 uint8_t* VP8LBitWriterFinish(VP8LBitWriter* const bw); 114 // Release any pending memory and zeroes the object. 115 void VP8LBitWriterWipeOut(VP8LBitWriter* const bw); 116 // Resets the cursor of the BitWriter bw to when it was like in bw_init. 117 void VP8LBitWriterReset(const VP8LBitWriter* const bw_init, 118 VP8LBitWriter* const bw); 119 // Swaps the memory held by two BitWriters. 120 void VP8LBitWriterSwap(VP8LBitWriter* const src, VP8LBitWriter* const dst); 121 122 // Internal function for VP8LPutBits flushing 32 bits from the written state. 123 void VP8LPutBitsFlushBits(VP8LBitWriter* const bw); 124 125 // PutBits internal function used in the 16 bit vp8l_wtype_t case. 126 void VP8LPutBitsInternal(VP8LBitWriter* const bw, uint32_t bits, int n_bits); 127 128 // This function writes bits into bytes in increasing addresses (little endian), 129 // and within a byte least-significant-bit first. 130 // This function can write up to 32 bits in one go, but VP8LBitReader can only 131 // read 24 bits max (VP8L_MAX_NUM_BIT_READ). 132 // VP8LBitWriter's error_ flag is set in case of memory allocation error. 133 static WEBP_INLINE void VP8LPutBits(VP8LBitWriter* const bw, 134 uint32_t bits, int n_bits) { 135 if (sizeof(vp8l_wtype_t) == 4) { 136 if (n_bits > 0) { 137 if (bw->used_ >= 32) { 138 VP8LPutBitsFlushBits(bw); 139 } 140 bw->bits_ |= (vp8l_atype_t)bits << bw->used_; 141 bw->used_ += n_bits; 142 } 143 } else { 144 VP8LPutBitsInternal(bw, bits, n_bits); 145 } 146 } 147 148 //------------------------------------------------------------------------------ 149 150 #ifdef __cplusplus 151 } // extern "C" 152 #endif 153 154 #endif /* WEBP_UTILS_BIT_WRITER_UTILS_H_ */ 155
