github.com/cellofellow/gopkg@v0.0.0-20140722061823-eec0544a62ad/image/webp/libwebp/src/utils/bit_writer.h (about)

     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  // 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  #ifdef __cplusplus
   122  }    // extern "C"
   123  #endif
   124  
   125  #endif  /* WEBP_UTILS_BIT_WRITER_H_ */