third_party/libwebp/utils/bit_writer.h

   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)
  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 #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
  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_ */