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 // Paginated token buffer 11 // 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). 16 // 17 // Author: Skal (pascal.massimino (at) gmail.com) 18 19 #include <assert.h> 20 #include <stdlib.h> 21 #include <string.h> 22 23 #include "./cost.h" 24 #include "./vp8enci.h" 25 #include "../utils/utils.h" 26 27 #if !defined(DISABLE_TOKEN_BUFFER) 28 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) 32 33 typedef uint16_t token_t; // bit#15: bit 34 // bit #14: constant proba or idx 35 // bits 0..13: slot or constant proba 36 struct VP8Tokens { 37 VP8Tokens* next_; // pointer to next page 38 }; 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]) 42 43 //------------------------------------------------------------------------------ 44 45 void VP8TBufferInit(VP8TBuffer* const b, int page_size) { 46 b->tokens_ = NULL; 47 b->pages_ = NULL; 48 b->last_page_ = &b->pages_; 49 b->left_ = 0; 50 b->page_size_ = (page_size < MIN_PAGE_SIZE) ? MIN_PAGE_SIZE : page_size; 51 b->error_ = 0; 52 } 53 54 void VP8TBufferClear(VP8TBuffer* const b) { 55 if (b != NULL) { 56 const VP8Tokens* p = b->pages_; 57 while (p != NULL) { 58 const VP8Tokens* const next = p->next_; 59 WebPSafeFree((void*)p); 60 p = next; 61 } 62 VP8TBufferInit(b, b->page_size_); 63 } 64 } 65 66 static int TBufferNewPage(VP8TBuffer* const b) { 67 VP8Tokens* page = NULL; 68 const size_t size = sizeof(*page) + b->page_size_ * sizeof(token_t); 69 if (!b->error_) { 70 page = (VP8Tokens*)WebPSafeMalloc(1ULL, size); 71 } 72 if (page == NULL) { 73 b->error_ = 1; 74 return 0; 75 } 76 page->next_ = NULL; 77 78 *b->last_page_ = page; 79 b->last_page_ = &page->next_; 80 b->left_ = b->page_size_; 81 b->tokens_ = TOKEN_DATA(page); 82 return 1; 83 } 84 85 //------------------------------------------------------------------------------ 86 87 #define TOKEN_ID(t, b, ctx, p) \ 88 ((p) + NUM_PROBAS * ((ctx) + NUM_CTX * ((b) + NUM_BANDS * (t)))) 89 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; 97 } 98 return bit; 99 } 100 101 static WEBP_INLINE void AddConstantToken(VP8TBuffer* const b, 102 int bit, int proba) { 103 assert(proba < 256); 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; 108 } 109 } 110 111 int VP8RecordCoeffTokens(int ctx, int coeff_type, int first, int last, 112 const int16_t* const coeffs, 113 VP8TBuffer* const tokens) { 114 int n = first; 115 uint32_t base_id = TOKEN_ID(coeff_type, n, ctx, 0); 116 if (!AddToken(tokens, last >= 0, base_id + 0)) { 117 return 0; 118 } 119 120 while (n < 16) { 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)) { 125 ctx = 0; 126 base_id = TOKEN_ID(coeff_type, VP8EncBands[n], ctx, 0); 127 continue; 128 } 129 if (!AddToken(tokens, v > 1, base_id + 2)) { 130 ctx = 1; 131 } else { 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); 138 } else { 139 AddConstantToken(tokens, v >= 9, 165); 140 AddConstantToken(tokens, !(v & 1), 145); 141 } 142 } else { 143 int mask; 144 const uint8_t* tab; 145 if (v < 3 + (8 << 1)) { // VP8Cat3 (3b) 146 AddToken(tokens, 0, base_id + 8); 147 AddToken(tokens, 0, base_id + 9); 148 v -= 3 + (8 << 0); 149 mask = 1 << 2; 150 tab = VP8Cat3; 151 } else if (v < 3 + (8 << 2)) { // VP8Cat4 (4b) 152 AddToken(tokens, 0, base_id + 8); 153 AddToken(tokens, 1, base_id + 9); 154 v -= 3 + (8 << 1); 155 mask = 1 << 3; 156 tab = VP8Cat4; 157 } else if (v < 3 + (8 << 3)) { // VP8Cat5 (5b) 158 AddToken(tokens, 1, base_id + 8); 159 AddToken(tokens, 0, base_id + 10); 160 v -= 3 + (8 << 2); 161 mask = 1 << 4; 162 tab = VP8Cat5; 163 } else { // VP8Cat6 (11b) 164 AddToken(tokens, 1, base_id + 8); 165 AddToken(tokens, 1, base_id + 10); 166 v -= 3 + (8 << 3); 167 mask = 1 << 10; 168 tab = VP8Cat6; 169 } 170 while (mask) { 171 AddConstantToken(tokens, !!(v & mask), *tab++); 172 mask >>= 1; 173 } 174 } 175 ctx = 2; 176 } 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)) { 180 return 1; // EOB 181 } 182 } 183 return 1; 184 } 185 186 #undef TOKEN_ID 187 188 //------------------------------------------------------------------------------ 189 // This function works, but isn't currently used. Saved for later. 190 191 #if 0 192 193 static void Record(int bit, proba_t* const stats) { 194 proba_t p = *stats; 195 if (p >= 0xffff0000u) { // an overflow is inbound. 196 p = ((p + 1u) >> 1) & 0x7fff7fffu; // -> divide the stats by 2. 197 } 198 // record bit count (lower 16 bits) and increment total count (upper 16 bits). 199 p += 0x00010000u + bit; 200 *stats = p; 201 } 202 203 void VP8TokenToStats(const VP8TBuffer* const b, proba_t* const stats) { 204 const VP8Tokens* p = b->pages_; 205 while (p != NULL) { 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); 209 while (n-- > N) { 210 const token_t token = tokens[n]; 211 if (!(token & FIXED_PROBA_BIT)) { 212 Record((token >> 15) & 1, stats + (token & 0x3fffu)); 213 } 214 } 215 p = p->next_; 216 } 217 } 218 219 #endif // 0 220 221 //------------------------------------------------------------------------------ 222 // Final coding pass, with known probabilities 223 224 int VP8EmitTokens(VP8TBuffer* const b, VP8BitWriter* const bw, 225 const uint8_t* const probas, int final_pass) { 226 const VP8Tokens* p = b->pages_; 227 (void)final_pass; 228 assert(!b->error_); 229 while (p != NULL) { 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); 234 while (n-- > N) { 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 239 } else { 240 VP8PutBit(bw, bit, probas[token & 0x3fffu]); 241 } 242 } 243 if (final_pass) WebPSafeFree((void*)p); 244 p = next; 245 } 246 if (final_pass) b->pages_ = NULL; 247 return 1; 248 } 249 250 // Size estimation 251 size_t VP8EstimateTokenSize(VP8TBuffer* const b, const uint8_t* const probas) { 252 size_t size = 0; 253 const VP8Tokens* p = b->pages_; 254 assert(!b->error_); 255 while (p != NULL) { 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); 260 while (n-- > N) { 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); 265 } else { 266 size += VP8BitCost(bit, probas[token & 0x3fffu]); 267 } 268 } 269 p = next; 270 } 271 return size; 272 } 273 274 //------------------------------------------------------------------------------ 275 276 #else // DISABLE_TOKEN_BUFFER 277 278 void VP8TBufferInit(VP8TBuffer* const b) { 279 (void)b; 280 } 281 void VP8TBufferClear(VP8TBuffer* const b) { 282 (void)b; 283 } 284 285 #endif // !DISABLE_TOKEN_BUFFER 286 287