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 #if defined(__cplusplus) || defined(c_plusplus)
  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 // TODO(vikasa): VP8LBitWriter is copied as-is from lossless code. There's scope
  72 // of re-using VP8BitWriter. Will evaluate once basic lossless encoder is
  73 // implemented.
  74
  75 typedef struct {
  76   uint8_t* buf_;
  77   size_t bit_pos_;
  78   size_t max_bytes_;
  79
  80   // After all bits are written, the caller must observe the state of
  81   // error_. A value of 1 indicates that a memory allocation failure
  82   // has happened during bit writing. A value of 0 indicates successful
  83   // writing of bits.
  84   int error_;
  85 } VP8LBitWriter;
  86
  87 static WEBP_INLINE size_t VP8LBitWriterNumBytes(VP8LBitWriter* const bw) {
  88   return (bw->bit_pos_ + 7) >> 3;
  89 }
  90
  91 static WEBP_INLINE uint8_t* VP8LBitWriterFinish(VP8LBitWriter* const bw) {
  92   return bw->buf_;
  93 }
  94
  95 // Returns 0 in case of memory allocation error.
  96 int VP8LBitWriterInit(VP8LBitWriter* const bw, size_t expected_size);
  97
  98 void VP8LBitWriterDestroy(VP8LBitWriter* const bw);
  99
 100 // This function writes bits into bytes in increasing addresses, and within
 101 // a byte least-significant-bit first.
 102 //
 103 // The function can write up to 16 bits in one go with WriteBits
 104 // Example: let's assume that 3 bits (Rs below) have been written already:
 105 //
 106 // BYTE-0     BYTE+1       BYTE+2
 107 //
 108 // 0000 0RRR    0000 0000    0000 0000
 109 //
 110 // Now, we could write 5 or less bits in MSB by just sifting by 3
 111 // and OR'ing to BYTE-0.
 112 //
 113 // For n bits, we take the last 5 bytes, OR that with high bits in BYTE-0,
 114 // and locate the rest in BYTE+1 and BYTE+2.
 115 //
 116 // VP8LBitWriter's error_ flag is set in case of  memory allocation error.
 117 void VP8LWriteBits(VP8LBitWriter* const bw, int n_bits, uint32_t bits);
 118
 119 //------------------------------------------------------------------------------
 120
 121 #if defined(__cplusplus) || defined(c_plusplus)
 122 }    // extern "C"
 123 #endif
 124
 125 #endif  /* WEBP_UTILS_BIT_WRITER_H_ */