1 // Copyright 2011 Google Inc. All Rights Reserved.
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 // -----------------------------------------------------------------------------
10 // Paginated token buffer
12 // A 'token' is a bit value associated with a probability, either fixed
13 // or a later-to-be-determined after statistics have been collected.
14 // For dynamic probability, we just record the slot id (idx) for the probability
15 // value in the final probability array (uint8_t* probas in VP8EmitTokens).
17 // Author: Skal (pascal.massimino@gmail.com)
24 #include "./vp8enci.h"
25 #include "../utils/utils.h"
27 #if !defined(DISABLE_TOKEN_BUFFER)
29 // we use pages to reduce the number of memcpy()
30 #define MIN_PAGE_SIZE 8192 // minimum number of token per page
31 #define FIXED_PROBA_BIT (1u << 14)
33 typedef uint16_t token_t; // bit#15: bit
34 // bit #14: constant proba or idx
35 // bits 0..13: slot or constant proba
37 VP8Tokens* next_; // pointer to next page
39 // Token data is located in memory just after the next_ field.
40 // This macro is used to return their address and hide the trick.
41 #define TOKEN_DATA(p) ((token_t*)&(p)[1])
43 //------------------------------------------------------------------------------
45 void VP8TBufferInit(VP8TBuffer* const b, int page_size) {
48 b->last_page_ = &b->pages_;
50 b->page_size_ = (page_size < MIN_PAGE_SIZE) ? MIN_PAGE_SIZE : page_size;
54 void VP8TBufferClear(VP8TBuffer* const b) {
56 const VP8Tokens* p = b->pages_;
58 const VP8Tokens* const next = p->next_;
59 WebPSafeFree((void*)p);
62 VP8TBufferInit(b, b->page_size_);
66 static int TBufferNewPage(VP8TBuffer* const b) {
67 VP8Tokens* page = NULL;
68 const size_t size = sizeof(*page) + b->page_size_ * sizeof(token_t);
70 page = (VP8Tokens*)WebPSafeMalloc(1ULL, size);
78 *b->last_page_ = page;
79 b->last_page_ = &page->next_;
80 b->left_ = b->page_size_;
81 b->tokens_ = TOKEN_DATA(page);
85 //------------------------------------------------------------------------------
87 #define TOKEN_ID(t, b, ctx, p) \
88 ((p) + NUM_PROBAS * ((ctx) + NUM_CTX * ((b) + NUM_BANDS * (t))))
90 static WEBP_INLINE int AddToken(VP8TBuffer* const b,
91 int bit, uint32_t proba_idx) {
92 assert(proba_idx < FIXED_PROBA_BIT);
93 assert(bit == 0 || bit == 1);
94 if (b->left_ > 0 || TBufferNewPage(b)) {
95 const int slot = --b->left_;
96 b->tokens_[slot] = (bit << 15) | proba_idx;
101 static WEBP_INLINE void AddConstantToken(VP8TBuffer* const b,
102 int bit, int proba) {
104 assert(bit == 0 || bit == 1);
105 if (b->left_ > 0 || TBufferNewPage(b)) {
106 const int slot = --b->left_;
107 b->tokens_[slot] = (bit << 15) | FIXED_PROBA_BIT | proba;
111 int VP8RecordCoeffTokens(int ctx, int coeff_type, int first, int last,
112 const int16_t* const coeffs,
113 VP8TBuffer* const tokens) {
115 uint32_t base_id = TOKEN_ID(coeff_type, n, ctx, 0);
116 if (!AddToken(tokens, last >= 0, base_id + 0)) {
121 const int c = coeffs[n++];
122 const int sign = c < 0;
123 int v = sign ? -c : c;
124 if (!AddToken(tokens, v != 0, base_id + 1)) {
126 base_id = TOKEN_ID(coeff_type, VP8EncBands[n], ctx, 0);
129 if (!AddToken(tokens, v > 1, base_id + 2)) {
132 if (!AddToken(tokens, v > 4, base_id + 3)) {
133 if (AddToken(tokens, v != 2, base_id + 4))
134 AddToken(tokens, v == 4, base_id + 5);
135 } else if (!AddToken(tokens, v > 10, base_id + 6)) {
136 if (!AddToken(tokens, v > 6, base_id + 7)) {
137 AddConstantToken(tokens, v == 6, 159);
139 AddConstantToken(tokens, v >= 9, 165);
140 AddConstantToken(tokens, !(v & 1), 145);
145 if (v < 3 + (8 << 1)) { // VP8Cat3 (3b)
146 AddToken(tokens, 0, base_id + 8);
147 AddToken(tokens, 0, base_id + 9);
151 } else if (v < 3 + (8 << 2)) { // VP8Cat4 (4b)
152 AddToken(tokens, 0, base_id + 8);
153 AddToken(tokens, 1, base_id + 9);
157 } else if (v < 3 + (8 << 3)) { // VP8Cat5 (5b)
158 AddToken(tokens, 1, base_id + 8);
159 AddToken(tokens, 0, base_id + 10);
163 } else { // VP8Cat6 (11b)
164 AddToken(tokens, 1, base_id + 8);
165 AddToken(tokens, 1, base_id + 10);
171 AddConstantToken(tokens, !!(v & mask), *tab++);
177 AddConstantToken(tokens, sign, 128);
178 base_id = TOKEN_ID(coeff_type, VP8EncBands[n], ctx, 0);
179 if (n == 16 || !AddToken(tokens, n <= last, base_id + 0)) {
188 //------------------------------------------------------------------------------
189 // This function works, but isn't currently used. Saved for later.
193 static void Record(int bit, proba_t* const stats) {
195 if (p >= 0xffff0000u) { // an overflow is inbound.
196 p = ((p + 1u) >> 1) & 0x7fff7fffu; // -> divide the stats by 2.
198 // record bit count (lower 16 bits) and increment total count (upper 16 bits).
199 p += 0x00010000u + bit;
203 void VP8TokenToStats(const VP8TBuffer* const b, proba_t* const stats) {
204 const VP8Tokens* p = b->pages_;
206 const int N = (p->next_ == NULL) ? b->left_ : 0;
207 int n = MAX_NUM_TOKEN;
208 const token_t* const tokens = TOKEN_DATA(p);
210 const token_t token = tokens[n];
211 if (!(token & FIXED_PROBA_BIT)) {
212 Record((token >> 15) & 1, stats + (token & 0x3fffu));
221 //------------------------------------------------------------------------------
222 // Final coding pass, with known probabilities
224 int VP8EmitTokens(VP8TBuffer* const b, VP8BitWriter* const bw,
225 const uint8_t* const probas, int final_pass) {
226 const VP8Tokens* p = b->pages_;
230 const VP8Tokens* const next = p->next_;
231 const int N = (next == NULL) ? b->left_ : 0;
232 int n = b->page_size_;
233 const token_t* const tokens = TOKEN_DATA(p);
235 const token_t token = tokens[n];
236 const int bit = (token >> 15) & 1;
237 if (token & FIXED_PROBA_BIT) {
238 VP8PutBit(bw, bit, token & 0xffu); // constant proba
240 VP8PutBit(bw, bit, probas[token & 0x3fffu]);
243 if (final_pass) WebPSafeFree((void*)p);
246 if (final_pass) b->pages_ = NULL;
251 size_t VP8EstimateTokenSize(VP8TBuffer* const b, const uint8_t* const probas) {
253 const VP8Tokens* p = b->pages_;
256 const VP8Tokens* const next = p->next_;
257 const int N = (next == NULL) ? b->left_ : 0;
258 int n = b->page_size_;
259 const token_t* const tokens = TOKEN_DATA(p);
261 const token_t token = tokens[n];
262 const int bit = token & (1 << 15);
263 if (token & FIXED_PROBA_BIT) {
264 size += VP8BitCost(bit, token & 0xffu);
266 size += VP8BitCost(bit, probas[token & 0x3fffu]);
274 //------------------------------------------------------------------------------
276 #else // DISABLE_TOKEN_BUFFER
278 void VP8TBufferInit(VP8TBuffer* const b) {
281 void VP8TBufferClear(VP8TBuffer* const b) {
285 #endif // !DISABLE_TOKEN_BUFFER