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)
20extern "C" {
21#endif
22
23//------------------------------------------------------------------------------
24// Bit-writing
25
26typedef struct VP8BitWriter VP8BitWriter;
27struct 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.
39int VP8BitWriterInit(VP8BitWriter* const bw, size_t expected_size);
40// Finalize the bitstream coding. Returns a pointer to the internal buffer.
41uint8_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!
44void VP8BitWriterWipeOut(VP8BitWriter* const bw);
45
46int VP8PutBit(VP8BitWriter* const bw, int bit, int prob);
47int VP8PutBitUniform(VP8BitWriter* const bw, int bit);
48void VP8PutValue(VP8BitWriter* const bw, int value, int nb_bits);
49void VP8PutSignedValue(VP8BitWriter* const bw, int value, int nb_bits);
50
51// Appends some bytes to the internal buffer. Data is copied.
52int VP8BitWriterAppend(VP8BitWriter* const bw,
53                       const uint8_t* data, size_t size);
54
55// return approximate write position (in bits)
56static 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.
61static WEBP_INLINE uint8_t* VP8BitWriterBuf(const VP8BitWriter* const bw) {
62  return bw->buf_;
63}
64// Returns the size of the internal buffer.
65static 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
75typedef 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
87static WEBP_INLINE size_t VP8LBitWriterNumBytes(VP8LBitWriter* const bw) {
88  return (bw->bit_pos_ + 7) >> 3;
89}
90
91static WEBP_INLINE uint8_t* VP8LBitWriterFinish(VP8LBitWriter* const bw) {
92  return bw->buf_;
93}
94
95// Returns 0 in case of memory allocation error.
96int VP8LBitWriterInit(VP8LBitWriter* const bw, size_t expected_size);
97
98void 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.
117void 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_ */
126