1// Copyright 2012 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// Author: Jyrki Alakuijala (jyrki@google.com)
11//
12
13#include <assert.h>
14#include <math.h>
15
16#include "./backward_references_enc.h"
17#include "./histogram_enc.h"
18#include "../dsp/lossless.h"
19#include "../dsp/lossless_common.h"
20#include "../dsp/dsp.h"
21#include "../utils/color_cache_utils.h"
22#include "../utils/utils.h"
23
24#define VALUES_IN_BYTE 256
25
26#define MIN_BLOCK_SIZE 256 // minimum block size for backward references
27
28#define MAX_ENTROPY (1e30f)
29
30// 1M window (4M bytes) minus 120 special codes for short distances.
31#define WINDOW_SIZE_BITS 20
32#define WINDOW_SIZE ((1 << WINDOW_SIZE_BITS) - 120)
33
34// Minimum number of pixels for which it is cheaper to encode a
35// distance + length instead of each pixel as a literal.
36#define MIN_LENGTH 4
37// If you change this, you need MAX_LENGTH_BITS + WINDOW_SIZE_BITS <= 32 as it
38// is used in VP8LHashChain.
39#define MAX_LENGTH_BITS 12
40// We want the max value to be attainable and stored in MAX_LENGTH_BITS bits.
41#define MAX_LENGTH ((1 << MAX_LENGTH_BITS) - 1)
42#if MAX_LENGTH_BITS + WINDOW_SIZE_BITS > 32
43#error "MAX_LENGTH_BITS + WINDOW_SIZE_BITS > 32"
44#endif
45
46// -----------------------------------------------------------------------------
47
48static const uint8_t plane_to_code_lut[128] = {
49 96, 73, 55, 39, 23, 13, 5, 1, 255, 255, 255, 255, 255, 255, 255, 255,
50 101, 78, 58, 42, 26, 16, 8, 2, 0, 3, 9, 17, 27, 43, 59, 79,
51 102, 86, 62, 46, 32, 20, 10, 6, 4, 7, 11, 21, 33, 47, 63, 87,
52 105, 90, 70, 52, 37, 28, 18, 14, 12, 15, 19, 29, 38, 53, 71, 91,
53 110, 99, 82, 66, 48, 35, 30, 24, 22, 25, 31, 36, 49, 67, 83, 100,
54 115, 108, 94, 76, 64, 50, 44, 40, 34, 41, 45, 51, 65, 77, 95, 109,
55 118, 113, 103, 92, 80, 68, 60, 56, 54, 57, 61, 69, 81, 93, 104, 114,
56 119, 116, 111, 106, 97, 88, 84, 74, 72, 75, 85, 89, 98, 107, 112, 117
57};
58
59static int DistanceToPlaneCode(int xsize, int dist) {
60 const int yoffset = dist / xsize;
61 const int xoffset = dist - yoffset * xsize;
62 if (xoffset <= 8 && yoffset < 8) {
63 return plane_to_code_lut[yoffset * 16 + 8 - xoffset] + 1;
64 } else if (xoffset > xsize - 8 && yoffset < 7) {
65 return plane_to_code_lut[(yoffset + 1) * 16 + 8 + (xsize - xoffset)] + 1;
66 }
67 return dist + 120;
68}
69
70// Returns the exact index where array1 and array2 are different. For an index
71// inferior or equal to best_len_match, the return value just has to be strictly
72// inferior to best_len_match. The current behavior is to return 0 if this index
73// is best_len_match, and the index itself otherwise.
74// If no two elements are the same, it returns max_limit.
75static WEBP_INLINE int FindMatchLength(const uint32_t* const array1,
76 const uint32_t* const array2,
77 int best_len_match, int max_limit) {
78 // Before 'expensive' linear match, check if the two arrays match at the
79 // current best length index.
80 if (array1[best_len_match] != array2[best_len_match]) return 0;
81
82 return VP8LVectorMismatch(array1, array2, max_limit);
83}
84
85// -----------------------------------------------------------------------------
86// VP8LBackwardRefs
87
88struct PixOrCopyBlock {
89 PixOrCopyBlock* next_; // next block (or NULL)
90 PixOrCopy* start_; // data start
91 int size_; // currently used size
92};
93
94static void ClearBackwardRefs(VP8LBackwardRefs* const refs) {
95 assert(refs != NULL);
96 if (refs->tail_ != NULL) {
97 *refs->tail_ = refs->free_blocks_; // recycle all blocks at once
98 }
99 refs->free_blocks_ = refs->refs_;
100 refs->tail_ = &refs->refs_;
101 refs->last_block_ = NULL;
102 refs->refs_ = NULL;
103}
104
105void VP8LBackwardRefsClear(VP8LBackwardRefs* const refs) {
106 assert(refs != NULL);
107 ClearBackwardRefs(refs);
108 while (refs->free_blocks_ != NULL) {
109 PixOrCopyBlock* const next = refs->free_blocks_->next_;
110 WebPSafeFree(refs->free_blocks_);
111 refs->free_blocks_ = next;
112 }
113}
114
115void VP8LBackwardRefsInit(VP8LBackwardRefs* const refs, int block_size) {
116 assert(refs != NULL);
117 memset(refs, 0, sizeof(*refs));
118 refs->tail_ = &refs->refs_;
119 refs->block_size_ =
120 (block_size < MIN_BLOCK_SIZE) ? MIN_BLOCK_SIZE : block_size;
121}
122
123VP8LRefsCursor VP8LRefsCursorInit(const VP8LBackwardRefs* const refs) {
124 VP8LRefsCursor c;
125 c.cur_block_ = refs->refs_;
126 if (refs->refs_ != NULL) {
127 c.cur_pos = c.cur_block_->start_;
128 c.last_pos_ = c.cur_pos + c.cur_block_->size_;
129 } else {
130 c.cur_pos = NULL;
131 c.last_pos_ = NULL;
132 }
133 return c;
134}
135
136void VP8LRefsCursorNextBlock(VP8LRefsCursor* const c) {
137 PixOrCopyBlock* const b = c->cur_block_->next_;
138 c->cur_pos = (b == NULL) ? NULL : b->start_;
139 c->last_pos_ = (b == NULL) ? NULL : b->start_ + b->size_;
140 c->cur_block_ = b;
141}
142
143// Create a new block, either from the free list or allocated
144static PixOrCopyBlock* BackwardRefsNewBlock(VP8LBackwardRefs* const refs) {
145 PixOrCopyBlock* b = refs->free_blocks_;
146 if (b == NULL) { // allocate new memory chunk
147 const size_t total_size =
148 sizeof(*b) + refs->block_size_ * sizeof(*b->start_);
149 b = (PixOrCopyBlock*)WebPSafeMalloc(1ULL, total_size);
150 if (b == NULL) {
151 refs->error_ |= 1;
152 return NULL;
153 }
154 b->start_ = (PixOrCopy*)((uint8_t*)b + sizeof(*b)); // not always aligned
155 } else { // recycle from free-list
156 refs->free_blocks_ = b->next_;
157 }
158 *refs->tail_ = b;
159 refs->tail_ = &b->next_;
160 refs->last_block_ = b;
161 b->next_ = NULL;
162 b->size_ = 0;
163 return b;
164}
165
166static WEBP_INLINE void BackwardRefsCursorAdd(VP8LBackwardRefs* const refs,
167 const PixOrCopy v) {
168 PixOrCopyBlock* b = refs->last_block_;
169 if (b == NULL || b->size_ == refs->block_size_) {
170 b = BackwardRefsNewBlock(refs);
171 if (b == NULL) return; // refs->error_ is set
172 }
173 b->start_[b->size_++] = v;
174}
175
176int VP8LBackwardRefsCopy(const VP8LBackwardRefs* const src,
177 VP8LBackwardRefs* const dst) {
178 const PixOrCopyBlock* b = src->refs_;
179 ClearBackwardRefs(dst);
180 assert(src->block_size_ == dst->block_size_);
181 while (b != NULL) {
182 PixOrCopyBlock* const new_b = BackwardRefsNewBlock(dst);
183 if (new_b == NULL) return 0; // dst->error_ is set
184 memcpy(new_b->start_, b->start_, b->size_ * sizeof(*b->start_));
185 new_b->size_ = b->size_;
186 b = b->next_;
187 }
188 return 1;
189}
190
191// -----------------------------------------------------------------------------
192// Hash chains
193
194int VP8LHashChainInit(VP8LHashChain* const p, int size) {
195 assert(p->size_ == 0);
196 assert(p->offset_length_ == NULL);
197 assert(size > 0);
198 p->offset_length_ =
199 (uint32_t*)WebPSafeMalloc(size, sizeof(*p->offset_length_));
200 if (p->offset_length_ == NULL) return 0;
201 p->size_ = size;
202
203 return 1;
204}
205
206void VP8LHashChainClear(VP8LHashChain* const p) {
207 assert(p != NULL);
208 WebPSafeFree(p->offset_length_);
209
210 p->size_ = 0;
211 p->offset_length_ = NULL;
212}
213
214// -----------------------------------------------------------------------------
215
216#define HASH_MULTIPLIER_HI (0xc6a4a793ULL)
217#define HASH_MULTIPLIER_LO (0x5bd1e996ULL)
218
219static WEBP_INLINE uint32_t GetPixPairHash64(const uint32_t* const argb) {
220 uint32_t key;
221 key = (argb[1] * HASH_MULTIPLIER_HI) & 0xffffffffu;
222 key += (argb[0] * HASH_MULTIPLIER_LO) & 0xffffffffu;
223 key = key >> (32 - HASH_BITS);
224 return key;
225}
226
227// Returns the maximum number of hash chain lookups to do for a
228// given compression quality. Return value in range [8, 86].
229static int GetMaxItersForQuality(int quality) {
230 return 8 + (quality * quality) / 128;
231}
232
233static int GetWindowSizeForHashChain(int quality, int xsize) {
234 const int max_window_size = (quality > 75) ? WINDOW_SIZE
235 : (quality > 50) ? (xsize << 8)
236 : (quality > 25) ? (xsize << 6)
237 : (xsize << 4);
238 assert(xsize > 0);
239 return (max_window_size > WINDOW_SIZE) ? WINDOW_SIZE : max_window_size;
240}
241
242static WEBP_INLINE int MaxFindCopyLength(int len) {
243 return (len < MAX_LENGTH) ? len : MAX_LENGTH;
244}
245
246int VP8LHashChainFill(VP8LHashChain* const p, int quality,
247 const uint32_t* const argb, int xsize, int ysize,
248 int low_effort) {
249 const int size = xsize * ysize;
250 const int iter_max = GetMaxItersForQuality(quality);
251 const uint32_t window_size = GetWindowSizeForHashChain(quality, xsize);
252 int pos;
253 int argb_comp;
254 uint32_t base_position;
255 int32_t* hash_to_first_index;
256 // Temporarily use the p->offset_length_ as a hash chain.
257 int32_t* chain = (int32_t*)p->offset_length_;
258 assert(size > 0);
259 assert(p->size_ != 0);
260 assert(p->offset_length_ != NULL);
261
262 if (size <= 2) {
263 p->offset_length_[0] = p->offset_length_[size - 1] = 0;
264 return 1;
265 }
266
267 hash_to_first_index =
268 (int32_t*)WebPSafeMalloc(HASH_SIZE, sizeof(*hash_to_first_index));
269 if (hash_to_first_index == NULL) return 0;
270
271 // Set the int32_t array to -1.
272 memset(hash_to_first_index, 0xff, HASH_SIZE * sizeof(*hash_to_first_index));
273 // Fill the chain linking pixels with the same hash.
274 argb_comp = (argb[0] == argb[1]);
275 for (pos = 0; pos < size - 2;) {
276 uint32_t hash_code;
277 const int argb_comp_next = (argb[pos + 1] == argb[pos + 2]);
278 if (argb_comp && argb_comp_next) {
279 // Consecutive pixels with the same color will share the same hash.
280 // We therefore use a different hash: the color and its repetition
281 // length.
282 uint32_t tmp[2];
283 uint32_t len = 1;
284 tmp[0] = argb[pos];
285 // Figure out how far the pixels are the same.
286 // The last pixel has a different 64 bit hash, as its next pixel does
287 // not have the same color, so we just need to get to the last pixel equal
288 // to its follower.
289 while (pos + (int)len + 2 < size && argb[pos + len + 2] == argb[pos]) {
290 ++len;
291 }
292 if (len > MAX_LENGTH) {
293 // Skip the pixels that match for distance=1 and length>MAX_LENGTH
294 // because they are linked to their predecessor and we automatically
295 // check that in the main for loop below. Skipping means setting no
296 // predecessor in the chain, hence -1.
297 memset(chain + pos, 0xff, (len - MAX_LENGTH) * sizeof(*chain));
298 pos += len - MAX_LENGTH;
299 len = MAX_LENGTH;
300 }
301 // Process the rest of the hash chain.
302 while (len) {
303 tmp[1] = len--;
304 hash_code = GetPixPairHash64(tmp);
305 chain[pos] = hash_to_first_index[hash_code];
306 hash_to_first_index[hash_code] = pos++;
307 }
308 argb_comp = 0;
309 } else {
310 // Just move one pixel forward.
311 hash_code = GetPixPairHash64(argb + pos);
312 chain[pos] = hash_to_first_index[hash_code];
313 hash_to_first_index[hash_code] = pos++;
314 argb_comp = argb_comp_next;
315 }
316 }
317 // Process the penultimate pixel.
318 chain[pos] = hash_to_first_index[GetPixPairHash64(argb + pos)];
319
320 WebPSafeFree(hash_to_first_index);
321
322 // Find the best match interval at each pixel, defined by an offset to the
323 // pixel and a length. The right-most pixel cannot match anything to the right
324 // (hence a best length of 0) and the left-most pixel nothing to the left
325 // (hence an offset of 0).
326 assert(size > 2);
327 p->offset_length_[0] = p->offset_length_[size - 1] = 0;
328 for (base_position = size - 2; base_position > 0;) {
329 const int max_len = MaxFindCopyLength(size - 1 - base_position);
330 const uint32_t* const argb_start = argb + base_position;
331 int iter = iter_max;
332 int best_length = 0;
333 uint32_t best_distance = 0;
334 uint32_t best_argb;
335 const int min_pos =
336 (base_position > window_size) ? base_position - window_size : 0;
337 const int length_max = (max_len < 256) ? max_len : 256;
338 uint32_t max_base_position;
339
340 pos = chain[base_position];
341 if (!low_effort) {
342 int curr_length;
343 // Heuristic: use the comparison with the above line as an initialization.
344 if (base_position >= (uint32_t)xsize) {
345 curr_length = FindMatchLength(argb_start - xsize, argb_start,
346 best_length, max_len);
347 if (curr_length > best_length) {
348 best_length = curr_length;
349 best_distance = xsize;
350 }
351 --iter;
352 }
353 // Heuristic: compare to the previous pixel.
354 curr_length =
355 FindMatchLength(argb_start - 1, argb_start, best_length, max_len);
356 if (curr_length > best_length) {
357 best_length = curr_length;
358 best_distance = 1;
359 }
360 --iter;
361 // Skip the for loop if we already have the maximum.
362 if (best_length == MAX_LENGTH) pos = min_pos - 1;
363 }
364 best_argb = argb_start[best_length];
365
366 for (; pos >= min_pos && --iter; pos = chain[pos]) {
367 int curr_length;
368 assert(base_position > (uint32_t)pos);
369
370 if (argb[pos + best_length] != best_argb) continue;
371
372 curr_length = VP8LVectorMismatch(argb + pos, argb_start, max_len);
373 if (best_length < curr_length) {
374 best_length = curr_length;
375 best_distance = base_position - pos;
376 best_argb = argb_start[best_length];
377 // Stop if we have reached a good enough length.
378 if (best_length >= length_max) break;
379 }
380 }
381 // We have the best match but in case the two intervals continue matching
382 // to the left, we have the best matches for the left-extended pixels.
383 max_base_position = base_position;
384 while (1) {
385 assert(best_length <= MAX_LENGTH);
386 assert(best_distance <= WINDOW_SIZE);
387 p->offset_length_[base_position] =
388 (best_distance << MAX_LENGTH_BITS) | (uint32_t)best_length;
389 --base_position;
390 // Stop if we don't have a match or if we are out of bounds.
391 if (best_distance == 0 || base_position == 0) break;
392 // Stop if we cannot extend the matching intervals to the left.
393 if (base_position < best_distance ||
394 argb[base_position - best_distance] != argb[base_position]) {
395 break;
396 }
397 // Stop if we are matching at its limit because there could be a closer
398 // matching interval with the same maximum length. Then again, if the
399 // matching interval is as close as possible (best_distance == 1), we will
400 // never find anything better so let's continue.
401 if (best_length == MAX_LENGTH && best_distance != 1 &&
402 base_position + MAX_LENGTH < max_base_position) {
403 break;
404 }
405 if (best_length < MAX_LENGTH) {
406 ++best_length;
407 max_base_position = base_position;
408 }
409 }
410 }
411 return 1;
412}
413
414static WEBP_INLINE int HashChainFindOffset(const VP8LHashChain* const p,
415 const int base_position) {
416 return p->offset_length_[base_position] >> MAX_LENGTH_BITS;
417}
418
419static WEBP_INLINE int HashChainFindLength(const VP8LHashChain* const p,
420 const int base_position) {
421 return p->offset_length_[base_position] & ((1U << MAX_LENGTH_BITS) - 1);
422}
423
424static WEBP_INLINE void HashChainFindCopy(const VP8LHashChain* const p,
425 int base_position,
426 int* const offset_ptr,
427 int* const length_ptr) {
428 *offset_ptr = HashChainFindOffset(p, base_position);
429 *length_ptr = HashChainFindLength(p, base_position);
430}
431
432static WEBP_INLINE void AddSingleLiteral(uint32_t pixel, int use_color_cache,
433 VP8LColorCache* const hashers,
434 VP8LBackwardRefs* const refs) {
435 PixOrCopy v;
436 if (use_color_cache) {
437 const uint32_t key = VP8LColorCacheGetIndex(hashers, pixel);
438 if (VP8LColorCacheLookup(hashers, key) == pixel) {
439 v = PixOrCopyCreateCacheIdx(key);
440 } else {
441 v = PixOrCopyCreateLiteral(pixel);
442 VP8LColorCacheSet(hashers, key, pixel);
443 }
444 } else {
445 v = PixOrCopyCreateLiteral(pixel);
446 }
447 BackwardRefsCursorAdd(refs, v);
448}
449
450static int BackwardReferencesRle(int xsize, int ysize,
451 const uint32_t* const argb,
452 int cache_bits, VP8LBackwardRefs* const refs) {
453 const int pix_count = xsize * ysize;
454 int i, k;
455 const int use_color_cache = (cache_bits > 0);
456 VP8LColorCache hashers;
457
458 if (use_color_cache && !VP8LColorCacheInit(&hashers, cache_bits)) {
459 return 0;
460 }
461 ClearBackwardRefs(refs);
462 // Add first pixel as literal.
463 AddSingleLiteral(argb[0], use_color_cache, &hashers, refs);
464 i = 1;
465 while (i < pix_count) {
466 const int max_len = MaxFindCopyLength(pix_count - i);
467 const int rle_len = FindMatchLength(argb + i, argb + i - 1, 0, max_len);
468 const int prev_row_len = (i < xsize) ? 0 :
469 FindMatchLength(argb + i, argb + i - xsize, 0, max_len);
470 if (rle_len >= prev_row_len && rle_len >= MIN_LENGTH) {
471 BackwardRefsCursorAdd(refs, PixOrCopyCreateCopy(1, rle_len));
472 // We don't need to update the color cache here since it is always the
473 // same pixel being copied, and that does not change the color cache
474 // state.
475 i += rle_len;
476 } else if (prev_row_len >= MIN_LENGTH) {
477 BackwardRefsCursorAdd(refs, PixOrCopyCreateCopy(xsize, prev_row_len));
478 if (use_color_cache) {
479 for (k = 0; k < prev_row_len; ++k) {
480 VP8LColorCacheInsert(&hashers, argb[i + k]);
481 }
482 }
483 i += prev_row_len;
484 } else {
485 AddSingleLiteral(argb[i], use_color_cache, &hashers, refs);
486 i++;
487 }
488 }
489 if (use_color_cache) VP8LColorCacheClear(&hashers);
490 return !refs->error_;
491}
492
493static int BackwardReferencesLz77(int xsize, int ysize,
494 const uint32_t* const argb, int cache_bits,
495 const VP8LHashChain* const hash_chain,
496 VP8LBackwardRefs* const refs) {
497 int i;
498 int i_last_check = -1;
499 int ok = 0;
500 int cc_init = 0;
501 const int use_color_cache = (cache_bits > 0);
502 const int pix_count = xsize * ysize;
503 VP8LColorCache hashers;
504
505 if (use_color_cache) {
506 cc_init = VP8LColorCacheInit(&hashers, cache_bits);
507 if (!cc_init) goto Error;
508 }
509 ClearBackwardRefs(refs);
510 for (i = 0; i < pix_count;) {
511 // Alternative#1: Code the pixels starting at 'i' using backward reference.
512 int offset = 0;
513 int len = 0;
514 int j;
515 HashChainFindCopy(hash_chain, i, &offset, &len);
516 if (len >= MIN_LENGTH) {
517 const int len_ini = len;
518 int max_reach = 0;
519 assert(i + len < pix_count);
520 // Only start from what we have not checked already.
521 i_last_check = (i > i_last_check) ? i : i_last_check;
522 // We know the best match for the current pixel but we try to find the
523 // best matches for the current pixel AND the next one combined.
524 // The naive method would use the intervals:
525 // [i,i+len) + [i+len, length of best match at i+len)
526 // while we check if we can use:
527 // [i,j) (where j<=i+len) + [j, length of best match at j)
528 for (j = i_last_check + 1; j <= i + len_ini; ++j) {
529 const int len_j = HashChainFindLength(hash_chain, j);
530 const int reach =
531 j + (len_j >= MIN_LENGTH ? len_j : 1); // 1 for single literal.
532 if (reach > max_reach) {
533 len = j - i;
534 max_reach = reach;
535 }
536 }
537 } else {
538 len = 1;
539 }
540 // Go with literal or backward reference.
541 assert(len > 0);
542 if (len == 1) {
543 AddSingleLiteral(argb[i], use_color_cache, &hashers, refs);
544 } else {
545 BackwardRefsCursorAdd(refs, PixOrCopyCreateCopy(offset, len));
546 if (use_color_cache) {
547 for (j = i; j < i + len; ++j) VP8LColorCacheInsert(&hashers, argb[j]);
548 }
549 }
550 i += len;
551 }
552
553 ok = !refs->error_;
554 Error:
555 if (cc_init) VP8LColorCacheClear(&hashers);
556 return ok;
557}
558
559// -----------------------------------------------------------------------------
560
561typedef struct {
562 double alpha_[VALUES_IN_BYTE];
563 double red_[VALUES_IN_BYTE];
564 double blue_[VALUES_IN_BYTE];
565 double distance_[NUM_DISTANCE_CODES];
566 double* literal_;
567} CostModel;
568
569static int BackwardReferencesTraceBackwards(
570 int xsize, int ysize, const uint32_t* const argb, int quality,
571 int cache_bits, const VP8LHashChain* const hash_chain,
572 VP8LBackwardRefs* const refs);
573
574static void ConvertPopulationCountTableToBitEstimates(
575 int num_symbols, const uint32_t population_counts[], double output[]) {
576 uint32_t sum = 0;
577 int nonzeros = 0;
578 int i;
579 for (i = 0; i < num_symbols; ++i) {
580 sum += population_counts[i];
581 if (population_counts[i] > 0) {
582 ++nonzeros;
583 }
584 }
585 if (nonzeros <= 1) {
586 memset(output, 0, num_symbols * sizeof(*output));
587 } else {
588 const double logsum = VP8LFastLog2(sum);
589 for (i = 0; i < num_symbols; ++i) {
590 output[i] = logsum - VP8LFastLog2(population_counts[i]);
591 }
592 }
593}
594
595static int CostModelBuild(CostModel* const m, int cache_bits,
596 VP8LBackwardRefs* const refs) {
597 int ok = 0;
598 VP8LHistogram* const histo = VP8LAllocateHistogram(cache_bits);
599 if (histo == NULL) goto Error;
600
601 VP8LHistogramCreate(histo, refs, cache_bits);
602
603 ConvertPopulationCountTableToBitEstimates(
604 VP8LHistogramNumCodes(histo->palette_code_bits_),
605 histo->literal_, m->literal_);
606 ConvertPopulationCountTableToBitEstimates(
607 VALUES_IN_BYTE, histo->red_, m->red_);
608 ConvertPopulationCountTableToBitEstimates(
609 VALUES_IN_BYTE, histo->blue_, m->blue_);
610 ConvertPopulationCountTableToBitEstimates(
611 VALUES_IN_BYTE, histo->alpha_, m->alpha_);
612 ConvertPopulationCountTableToBitEstimates(
613 NUM_DISTANCE_CODES, histo->distance_, m->distance_);
614 ok = 1;
615
616 Error:
617 VP8LFreeHistogram(histo);
618 return ok;
619}
620
621static WEBP_INLINE double GetLiteralCost(const CostModel* const m, uint32_t v) {
622 return m->alpha_[v >> 24] +
623 m->red_[(v >> 16) & 0xff] +
624 m->literal_[(v >> 8) & 0xff] +
625 m->blue_[v & 0xff];
626}
627
628static WEBP_INLINE double GetCacheCost(const CostModel* const m, uint32_t idx) {
629 const int literal_idx = VALUES_IN_BYTE + NUM_LENGTH_CODES + idx;
630 return m->literal_[literal_idx];
631}
632
633static WEBP_INLINE double GetLengthCost(const CostModel* const m,
634 uint32_t length) {
635 int code, extra_bits;
636 VP8LPrefixEncodeBits(length, &code, &extra_bits);
637 return m->literal_[VALUES_IN_BYTE + code] + extra_bits;
638}
639
640static WEBP_INLINE double GetDistanceCost(const CostModel* const m,
641 uint32_t distance) {
642 int code, extra_bits;
643 VP8LPrefixEncodeBits(distance, &code, &extra_bits);
644 return m->distance_[code] + extra_bits;
645}
646
647static void AddSingleLiteralWithCostModel(const uint32_t* const argb,
648 VP8LColorCache* const hashers,
649 const CostModel* const cost_model,
650 int idx, int use_color_cache,
651 double prev_cost, float* const cost,
652 uint16_t* const dist_array) {
653 double cost_val = prev_cost;
654 const uint32_t color = argb[0];
655 const int ix = use_color_cache ? VP8LColorCacheContains(hashers, color) : -1;
656 if (ix >= 0) {
657 // use_color_cache is true and hashers contains color
658 const double mul0 = 0.68;
659 cost_val += GetCacheCost(cost_model, ix) * mul0;
660 } else {
661 const double mul1 = 0.82;
662 if (use_color_cache) VP8LColorCacheInsert(hashers, color);
663 cost_val += GetLiteralCost(cost_model, color) * mul1;
664 }
665 if (cost[idx] > cost_val) {
666 cost[idx] = (float)cost_val;
667 dist_array[idx] = 1; // only one is inserted.
668 }
669}
670
671// -----------------------------------------------------------------------------
672// CostManager and interval handling
673
674// Empirical value to avoid high memory consumption but good for performance.
675#define COST_CACHE_INTERVAL_SIZE_MAX 100
676
677// To perform backward reference every pixel at index index_ is considered and
678// the cost for the MAX_LENGTH following pixels computed. Those following pixels
679// at index index_ + k (k from 0 to MAX_LENGTH) have a cost of:
680// distance_cost_ at index_ + GetLengthCost(cost_model, k)
681// (named cost) (named cached cost)
682// and the minimum value is kept. GetLengthCost(cost_model, k) is cached in an
683// array of size MAX_LENGTH.
684// Instead of performing MAX_LENGTH comparisons per pixel, we keep track of the
685// minimal values using intervals, for which lower_ and upper_ bounds are kept.
686// An interval is defined by the index_ of the pixel that generated it and
687// is only useful in a range of indices from start_ to end_ (exclusive), i.e.
688// it contains the minimum value for pixels between start_ and end_.
689// Intervals are stored in a linked list and ordered by start_. When a new
690// interval has a better minimum, old intervals are split or removed.
691typedef struct CostInterval CostInterval;
692struct CostInterval {
693 double lower_;
694 double upper_;
695 int start_;
696 int end_;
697 double distance_cost_;
698 int index_;
699 CostInterval* previous_;
700 CostInterval* next_;
701};
702
703// The GetLengthCost(cost_model, k) part of the costs is also bounded for
704// efficiency in a set of intervals of a different type.
705// If those intervals are small enough, they are not used for comparison and
706// written into the costs right away.
707typedef struct {
708 double lower_; // Lower bound of the interval.
709 double upper_; // Upper bound of the interval.
710 int start_;
711 int end_; // Exclusive.
712 int do_write_; // If !=0, the interval is saved to cost instead of being kept
713 // for comparison.
714} CostCacheInterval;
715
716// This structure is in charge of managing intervals and costs.
717// It caches the different CostCacheInterval, caches the different
718// GetLengthCost(cost_model, k) in cost_cache_ and the CostInterval's (whose
719// count_ is limited by COST_CACHE_INTERVAL_SIZE_MAX).
720#define COST_MANAGER_MAX_FREE_LIST 10
721typedef struct {
722 CostInterval* head_;
723 int count_; // The number of stored intervals.
724 CostCacheInterval* cache_intervals_;
725 size_t cache_intervals_size_;
726 double cost_cache_[MAX_LENGTH]; // Contains the GetLengthCost(cost_model, k).
727 double min_cost_cache_; // The minimum value in cost_cache_[1:].
728 double max_cost_cache_; // The maximum value in cost_cache_[1:].
729 float* costs_;
730 uint16_t* dist_array_;
731 // Most of the time, we only need few intervals -> use a free-list, to avoid
732 // fragmentation with small allocs in most common cases.
733 CostInterval intervals_[COST_MANAGER_MAX_FREE_LIST];
734 CostInterval* free_intervals_;
735 // These are regularly malloc'd remains. This list can't grow larger than than
736 // size COST_CACHE_INTERVAL_SIZE_MAX - COST_MANAGER_MAX_FREE_LIST, note.
737 CostInterval* recycled_intervals_;
738 // Buffer used in BackwardReferencesHashChainDistanceOnly to store the ends
739 // of the intervals that can have impacted the cost at a pixel.
740 int* interval_ends_;
741 int interval_ends_size_;
742} CostManager;
743
744static int IsCostCacheIntervalWritable(int start, int end) {
745 // 100 is the length for which we consider an interval for comparison, and not
746 // for writing.
747 // The first intervals are very small and go in increasing size. This constant
748 // helps merging them into one big interval (up to index 150/200 usually from
749 // which intervals start getting much bigger).
750 // This value is empirical.
751 return (end - start + 1 < 100);
752}
753
754static void CostIntervalAddToFreeList(CostManager* const manager,
755 CostInterval* const interval) {
756 interval->next_ = manager->free_intervals_;
757 manager->free_intervals_ = interval;
758}
759
760static int CostIntervalIsInFreeList(const CostManager* const manager,
761 const CostInterval* const interval) {
762 return (interval >= &manager->intervals_[0] &&
763 interval <= &manager->intervals_[COST_MANAGER_MAX_FREE_LIST - 1]);
764}
765
766static void CostManagerInitFreeList(CostManager* const manager) {
767 int i;
768 manager->free_intervals_ = NULL;
769 for (i = 0; i < COST_MANAGER_MAX_FREE_LIST; ++i) {
770 CostIntervalAddToFreeList(manager, &manager->intervals_[i]);
771 }
772}
773
774static void DeleteIntervalList(CostManager* const manager,
775 const CostInterval* interval) {
776 while (interval != NULL) {
777 const CostInterval* const next = interval->next_;
778 if (!CostIntervalIsInFreeList(manager, interval)) {
779 WebPSafeFree((void*)interval);
780 } // else: do nothing
781 interval = next;
782 }
783}
784
785static void CostManagerClear(CostManager* const manager) {
786 if (manager == NULL) return;
787
788 WebPSafeFree(manager->costs_);
789 WebPSafeFree(manager->cache_intervals_);
790 WebPSafeFree(manager->interval_ends_);
791
792 // Clear the interval lists.
793 DeleteIntervalList(manager, manager->head_);
794 manager->head_ = NULL;
795 DeleteIntervalList(manager, manager->recycled_intervals_);
796 manager->recycled_intervals_ = NULL;
797
798 // Reset pointers, count_ and cache_intervals_size_.
799 memset(manager, 0, sizeof(*manager));
800 CostManagerInitFreeList(manager);
801}
802
803static int CostManagerInit(CostManager* const manager,
804 uint16_t* const dist_array, int pix_count,
805 const CostModel* const cost_model) {
806 int i;
807 const int cost_cache_size = (pix_count > MAX_LENGTH) ? MAX_LENGTH : pix_count;
808 // This constant is tied to the cost_model we use.
809 // Empirically, differences between intervals is usually of more than 1.
810 const double min_cost_diff = 0.1;
811
812 manager->costs_ = NULL;
813 manager->cache_intervals_ = NULL;
814 manager->interval_ends_ = NULL;
815 manager->head_ = NULL;
816 manager->recycled_intervals_ = NULL;
817 manager->count_ = 0;
818 manager->dist_array_ = dist_array;
819 CostManagerInitFreeList(manager);
820
821 // Fill in the cost_cache_.
822 manager->cache_intervals_size_ = 1;
823 manager->cost_cache_[0] = 0;
824 for (i = 1; i < cost_cache_size; ++i) {
825 manager->cost_cache_[i] = GetLengthCost(cost_model, i);
826 // Get an approximation of the number of bound intervals.
827 if (fabs(manager->cost_cache_[i] - manager->cost_cache_[i - 1]) >
828 min_cost_diff) {
829 ++manager->cache_intervals_size_;
830 }
831 // Compute the minimum of cost_cache_.
832 if (i == 1) {
833 manager->min_cost_cache_ = manager->cost_cache_[1];
834 manager->max_cost_cache_ = manager->cost_cache_[1];
835 } else if (manager->cost_cache_[i] < manager->min_cost_cache_) {
836 manager->min_cost_cache_ = manager->cost_cache_[i];
837 } else if (manager->cost_cache_[i] > manager->max_cost_cache_) {
838 manager->max_cost_cache_ = manager->cost_cache_[i];
839 }
840 }
841
842 // With the current cost models, we have 15 intervals, so we are safe by
843 // setting a maximum of COST_CACHE_INTERVAL_SIZE_MAX.
844 if (manager->cache_intervals_size_ > COST_CACHE_INTERVAL_SIZE_MAX) {
845 manager->cache_intervals_size_ = COST_CACHE_INTERVAL_SIZE_MAX;
846 }
847 manager->cache_intervals_ = (CostCacheInterval*)WebPSafeMalloc(
848 manager->cache_intervals_size_, sizeof(*manager->cache_intervals_));
849 if (manager->cache_intervals_ == NULL) {
850 CostManagerClear(manager);
851 return 0;
852 }
853
854 // Fill in the cache_intervals_.
855 {
856 double cost_prev = -1e38f; // unprobably low initial value
857 CostCacheInterval* prev = NULL;
858 CostCacheInterval* cur = manager->cache_intervals_;
859 const CostCacheInterval* const end =
860 manager->cache_intervals_ + manager->cache_intervals_size_;
861
862 // Consecutive values in cost_cache_ are compared and if a big enough
863 // difference is found, a new interval is created and bounded.
864 for (i = 0; i < cost_cache_size; ++i) {
865 const double cost_val = manager->cost_cache_[i];
866 if (i == 0 ||
867 (fabs(cost_val - cost_prev) > min_cost_diff && cur + 1 < end)) {
868 if (i > 1) {
869 const int is_writable =
870 IsCostCacheIntervalWritable(cur->start_, cur->end_);
871 // Merge with the previous interval if both are writable.
872 if (is_writable && cur != manager->cache_intervals_ &&
873 prev->do_write_) {
874 // Update the previous interval.
875 prev->end_ = cur->end_;
876 if (cur->lower_ < prev->lower_) {
877 prev->lower_ = cur->lower_;
878 } else if (cur->upper_ > prev->upper_) {
879 prev->upper_ = cur->upper_;
880 }
881 } else {
882 cur->do_write_ = is_writable;
883 prev = cur;
884 ++cur;
885 }
886 }
887 // Initialize an interval.
888 cur->start_ = i;
889 cur->do_write_ = 0;
890 cur->lower_ = cost_val;
891 cur->upper_ = cost_val;
892 } else {
893 // Update the current interval bounds.
894 if (cost_val < cur->lower_) {
895 cur->lower_ = cost_val;
896 } else if (cost_val > cur->upper_) {
897 cur->upper_ = cost_val;
898 }
899 }
900 cur->end_ = i + 1;
901 cost_prev = cost_val;
902 }
903 manager->cache_intervals_size_ = cur + 1 - manager->cache_intervals_;
904 }
905
906 manager->costs_ = (float*)WebPSafeMalloc(pix_count, sizeof(*manager->costs_));
907 if (manager->costs_ == NULL) {
908 CostManagerClear(manager);
909 return 0;
910 }
911 // Set the initial costs_ high for every pixel as we will keep the minimum.
912 for (i = 0; i < pix_count; ++i) manager->costs_[i] = 1e38f;
913
914 // The cost at pixel is influenced by the cost intervals from previous pixels.
915 // Let us take the specific case where the offset is the same (which actually
916 // happens a lot in case of uniform regions).
917 // pixel i contributes to j>i a cost of: offset cost + cost_cache_[j-i]
918 // pixel i+1 contributes to j>i a cost of: 2*offset cost + cost_cache_[j-i-1]
919 // pixel i+2 contributes to j>i a cost of: 3*offset cost + cost_cache_[j-i-2]
920 // and so on.
921 // A pixel i influences the following length(j) < MAX_LENGTH pixels. What is
922 // the value of j such that pixel i + j cannot influence any of those pixels?
923 // This value is such that:
924 // max of cost_cache_ < j*offset cost + min of cost_cache_
925 // (pixel i + j 's cost cannot beat the worst cost given by pixel i).
926 // This value will be used to optimize the cost computation in
927 // BackwardReferencesHashChainDistanceOnly.
928 {
929 // The offset cost is computed in GetDistanceCost and has a minimum value of
930 // the minimum in cost_model->distance_. The case where the offset cost is 0
931 // will be dealt with differently later so we are only interested in the
932 // minimum non-zero offset cost.
933 double offset_cost_min = 0.;
934 int size;
935 for (i = 0; i < NUM_DISTANCE_CODES; ++i) {
936 if (cost_model->distance_[i] != 0) {
937 if (offset_cost_min == 0.) {
938 offset_cost_min = cost_model->distance_[i];
939 } else if (cost_model->distance_[i] < offset_cost_min) {
940 offset_cost_min = cost_model->distance_[i];
941 }
942 }
943 }
944 // In case all the cost_model->distance_ is 0, the next non-zero cost we
945 // can have is from the extra bit in GetDistanceCost, hence 1.
946 if (offset_cost_min < 1.) offset_cost_min = 1.;
947
948 size = 1 + (int)ceil((manager->max_cost_cache_ - manager->min_cost_cache_) /
949 offset_cost_min);
950 // Empirically, we usually end up with a value below 100.
951 if (size > MAX_LENGTH) size = MAX_LENGTH;
952
953 manager->interval_ends_ =
954 (int*)WebPSafeMalloc(size, sizeof(*manager->interval_ends_));
955 if (manager->interval_ends_ == NULL) {
956 CostManagerClear(manager);
957 return 0;
958 }
959 manager->interval_ends_size_ = size;
960 }
961
962 return 1;
963}
964
965// Given the distance_cost for pixel 'index', update the cost at pixel 'i' if it
966// is smaller than the previously computed value.
967static WEBP_INLINE void UpdateCost(CostManager* const manager, int i, int index,
968 double distance_cost) {
969 int k = i - index;
970 double cost_tmp;
971 assert(k >= 0 && k < MAX_LENGTH);
972 cost_tmp = distance_cost + manager->cost_cache_[k];
973
974 if (manager->costs_[i] > cost_tmp) {
975 manager->costs_[i] = (float)cost_tmp;
976 manager->dist_array_[i] = k + 1;
977 }
978}
979
980// Given the distance_cost for pixel 'index', update the cost for all the pixels
981// between 'start' and 'end' excluded.
982static WEBP_INLINE void UpdateCostPerInterval(CostManager* const manager,
983 int start, int end, int index,
984 double distance_cost) {
985 int i;
986 for (i = start; i < end; ++i) UpdateCost(manager, i, index, distance_cost);
987}
988
989// Given two intervals, make 'prev' be the previous one of 'next' in 'manager'.
990static WEBP_INLINE void ConnectIntervals(CostManager* const manager,
991 CostInterval* const prev,
992 CostInterval* const next) {
993 if (prev != NULL) {
994 prev->next_ = next;
995 } else {
996 manager->head_ = next;
997 }
998
999 if (next != NULL) next->previous_ = prev;
1000}
1001
1002// Pop an interval in the manager.
1003static WEBP_INLINE void PopInterval(CostManager* const manager,
1004 CostInterval* const interval) {
1005 CostInterval* const next = interval->next_;
1006
1007 if (interval == NULL) return;
1008
1009 ConnectIntervals(manager, interval->previous_, next);
1010 if (CostIntervalIsInFreeList(manager, interval)) {
1011 CostIntervalAddToFreeList(manager, interval);
1012 } else { // recycle regularly malloc'd intervals too
1013 interval->next_ = manager->recycled_intervals_;
1014 manager->recycled_intervals_ = interval;
1015 }
1016 --manager->count_;
1017 assert(manager->count_ >= 0);
1018}
1019
1020// Update the cost at index i by going over all the stored intervals that
1021// overlap with i.
1022static WEBP_INLINE void UpdateCostPerIndex(CostManager* const manager, int i) {
1023 CostInterval* current = manager->head_;
1024
1025 while (current != NULL && current->start_ <= i) {
1026 if (current->end_ <= i) {
1027 // We have an outdated interval, remove it.
1028 CostInterval* next = current->next_;
1029 PopInterval(manager, current);
1030 current = next;
1031 } else {
1032 UpdateCost(manager, i, current->index_, current->distance_cost_);
1033 current = current->next_;
1034 }
1035 }
1036}
1037
1038// Given a current orphan interval and its previous interval, before
1039// it was orphaned (which can be NULL), set it at the right place in the list
1040// of intervals using the start_ ordering and the previous interval as a hint.
1041static WEBP_INLINE void PositionOrphanInterval(CostManager* const manager,
1042 CostInterval* const current,
1043 CostInterval* previous) {
1044 assert(current != NULL);
1045
1046 if (previous == NULL) previous = manager->head_;
1047 while (previous != NULL && current->start_ < previous->start_) {
1048 previous = previous->previous_;
1049 }
1050 while (previous != NULL && previous->next_ != NULL &&
1051 previous->next_->start_ < current->start_) {
1052 previous = previous->next_;
1053 }
1054
1055 if (previous != NULL) {
1056 ConnectIntervals(manager, current, previous->next_);
1057 } else {
1058 ConnectIntervals(manager, current, manager->head_);
1059 }
1060 ConnectIntervals(manager, previous, current);
1061}
1062
1063// Insert an interval in the list contained in the manager by starting at
1064// interval_in as a hint. The intervals are sorted by start_ value.
1065static WEBP_INLINE void InsertInterval(CostManager* const manager,
1066 CostInterval* const interval_in,
1067 double distance_cost, double lower,
1068 double upper, int index, int start,
1069 int end) {
1070 CostInterval* interval_new;
1071
1072 if (IsCostCacheIntervalWritable(start, end) ||
1073 manager->count_ >= COST_CACHE_INTERVAL_SIZE_MAX) {
1074 // Write down the interval if it is too small.
1075 UpdateCostPerInterval(manager, start, end, index, distance_cost);
1076 return;
1077 }
1078 if (manager->free_intervals_ != NULL) {
1079 interval_new = manager->free_intervals_;
1080 manager->free_intervals_ = interval_new->next_;
1081 } else if (manager->recycled_intervals_ != NULL) {
1082 interval_new = manager->recycled_intervals_;
1083 manager->recycled_intervals_ = interval_new->next_;
1084 } else { // malloc for good
1085 interval_new = (CostInterval*)WebPSafeMalloc(1, sizeof(*interval_new));
1086 if (interval_new == NULL) {
1087 // Write down the interval if we cannot create it.
1088 UpdateCostPerInterval(manager, start, end, index, distance_cost);
1089 return;
1090 }
1091 }
1092
1093 interval_new->distance_cost_ = distance_cost;
1094 interval_new->lower_ = lower;
1095 interval_new->upper_ = upper;
1096 interval_new->index_ = index;
1097 interval_new->start_ = start;
1098 interval_new->end_ = end;
1099 PositionOrphanInterval(manager, interval_new, interval_in);
1100
1101 ++manager->count_;
1102}
1103
1104// When an interval has its start_ or end_ modified, it needs to be
1105// repositioned in the linked list.
1106static WEBP_INLINE void RepositionInterval(CostManager* const manager,
1107 CostInterval* const interval) {
1108 if (IsCostCacheIntervalWritable(interval->start_, interval->end_)) {
1109 // Maybe interval has been resized and is small enough to be removed.
1110 UpdateCostPerInterval(manager, interval->start_, interval->end_,
1111 interval->index_, interval->distance_cost_);
1112 PopInterval(manager, interval);
1113 return;
1114 }
1115
1116 // Early exit if interval is at the right spot.
1117 if ((interval->previous_ == NULL ||
1118 interval->previous_->start_ <= interval->start_) &&
1119 (interval->next_ == NULL ||
1120 interval->start_ <= interval->next_->start_)) {
1121 return;
1122 }
1123
1124 ConnectIntervals(manager, interval->previous_, interval->next_);
1125 PositionOrphanInterval(manager, interval, interval->previous_);
1126}
1127
1128// Given a new cost interval defined by its start at index, its last value and
1129// distance_cost, add its contributions to the previous intervals and costs.
1130// If handling the interval or one of its subintervals becomes to heavy, its
1131// contribution is added to the costs right away.
1132static WEBP_INLINE void PushInterval(CostManager* const manager,
1133 double distance_cost, int index,
1134 int last) {
1135 size_t i;
1136 CostInterval* interval = manager->head_;
1137 CostInterval* interval_next;
1138 const CostCacheInterval* const cost_cache_intervals =
1139 manager->cache_intervals_;
1140
1141 for (i = 0; i < manager->cache_intervals_size_ &&
1142 cost_cache_intervals[i].start_ < last;
1143 ++i) {
1144 // Define the intersection of the ith interval with the new one.
1145 int start = index + cost_cache_intervals[i].start_;
1146 const int end = index + (cost_cache_intervals[i].end_ > last
1147 ? last
1148 : cost_cache_intervals[i].end_);
1149 const double lower_in = cost_cache_intervals[i].lower_;
1150 const double upper_in = cost_cache_intervals[i].upper_;
1151 const double lower_full_in = distance_cost + lower_in;
1152 const double upper_full_in = distance_cost + upper_in;
1153
1154 if (cost_cache_intervals[i].do_write_) {
1155 UpdateCostPerInterval(manager, start, end, index, distance_cost);
1156 continue;
1157 }
1158
1159 for (; interval != NULL && interval->start_ < end && start < end;
1160 interval = interval_next) {
1161 const double lower_full_interval =
1162 interval->distance_cost_ + interval->lower_;
1163 const double upper_full_interval =
1164 interval->distance_cost_ + interval->upper_;
1165
1166 interval_next = interval->next_;
1167
1168 // Make sure we have some overlap
1169 if (start >= interval->end_) continue;
1170
1171 if (lower_full_in >= upper_full_interval) {
1172 // When intervals are represented, the lower, the better.
1173 // [**********************************************************]
1174 // start end
1175 // [----------------------------------]
1176 // interval->start_ interval->end_
1177 // If we are worse than what we already have, add whatever we have so
1178 // far up to interval.
1179 const int start_new = interval->end_;
1180 InsertInterval(manager, interval, distance_cost, lower_in, upper_in,
1181 index, start, interval->start_);
1182 start = start_new;
1183 continue;
1184 }
1185
1186 // We know the two intervals intersect.
1187 if (upper_full_in >= lower_full_interval) {
1188 // There is no clear cut on which is best, so let's keep both.
1189 // [*********[*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*]***********]
1190 // start interval->start_ interval->end_ end
1191 // OR
1192 // [*********[*-*-*-*-*-*-*-*-*-*-*-]----------------------]
1193 // start interval->start_ end interval->end_
1194 const int end_new = (interval->end_ <= end) ? interval->end_ : end;
1195 InsertInterval(manager, interval, distance_cost, lower_in, upper_in,
1196 index, start, end_new);
1197 start = end_new;
1198 } else if (start <= interval->start_ && interval->end_ <= end) {
1199 // [----------------------------------]
1200 // interval->start_ interval->end_
1201 // [**************************************************************]
1202 // start end
1203 // We can safely remove the old interval as it is fully included.
1204 PopInterval(manager, interval);
1205 } else {
1206 if (interval->start_ <= start && end <= interval->end_) {
1207 // [--------------------------------------------------------------]
1208 // interval->start_ interval->end_
1209 // [*****************************]
1210 // start end
1211 // We have to split the old interval as it fully contains the new one.
1212 const int end_original = interval->end_;
1213 interval->end_ = start;
1214 InsertInterval(manager, interval, interval->distance_cost_,
1215 interval->lower_, interval->upper_, interval->index_,
1216 end, end_original);
1217 } else if (interval->start_ < start) {
1218 // [------------------------------------]
1219 // interval->start_ interval->end_
1220 // [*****************************]
1221 // start end
1222 interval->end_ = start;
1223 } else {
1224 // [------------------------------------]
1225 // interval->start_ interval->end_
1226 // [*****************************]
1227 // start end
1228 interval->start_ = end;
1229 }
1230
1231 // The interval has been modified, we need to reposition it or write it.
1232 RepositionInterval(manager, interval);
1233 }
1234 }
1235 // Insert the remaining interval from start to end.
1236 InsertInterval(manager, interval, distance_cost, lower_in, upper_in, index,
1237 start, end);
1238 }
1239}
1240
1241static int BackwardReferencesHashChainDistanceOnly(
1242 int xsize, int ysize, const uint32_t* const argb, int quality,
1243 int cache_bits, const VP8LHashChain* const hash_chain,
1244 VP8LBackwardRefs* const refs, uint16_t* const dist_array) {
1245 int i;
1246 int ok = 0;
1247 int cc_init = 0;
1248 const int pix_count = xsize * ysize;
1249 const int use_color_cache = (cache_bits > 0);
1250 const size_t literal_array_size = sizeof(double) *
1251 (NUM_LITERAL_CODES + NUM_LENGTH_CODES +
1252 ((cache_bits > 0) ? (1 << cache_bits) : 0));
1253 const size_t cost_model_size = sizeof(CostModel) + literal_array_size;
1254 CostModel* const cost_model =
1255 (CostModel*)WebPSafeCalloc(1ULL, cost_model_size);
1256 VP8LColorCache hashers;
1257 const int skip_length = 32 + quality;
1258 const int skip_min_distance_code = 2;
1259 CostManager* cost_manager =
1260 (CostManager*)WebPSafeMalloc(1ULL, sizeof(*cost_manager));
1261
1262 if (cost_model == NULL || cost_manager == NULL) goto Error;
1263
1264 cost_model->literal_ = (double*)(cost_model + 1);
1265 if (use_color_cache) {
1266 cc_init = VP8LColorCacheInit(&hashers, cache_bits);
1267 if (!cc_init) goto Error;
1268 }
1269
1270 if (!CostModelBuild(cost_model, cache_bits, refs)) {
1271 goto Error;
1272 }
1273
1274 if (!CostManagerInit(cost_manager, dist_array, pix_count, cost_model)) {
1275 goto Error;
1276 }
1277
1278 // We loop one pixel at a time, but store all currently best points to
1279 // non-processed locations from this point.
1280 dist_array[0] = 0;
1281 // Add first pixel as literal.
1282 AddSingleLiteralWithCostModel(argb + 0, &hashers, cost_model, 0,
1283 use_color_cache, 0.0, cost_manager->costs_,
1284 dist_array);
1285
1286 for (i = 1; i < pix_count - 1; ++i) {
1287 int offset = 0, len = 0;
1288 double prev_cost = cost_manager->costs_[i - 1];
1289 HashChainFindCopy(hash_chain, i, &offset, &len);
1290 if (len >= 2) {
1291 // If we are dealing with a non-literal.
1292 const int code = DistanceToPlaneCode(xsize, offset);
1293 const double offset_cost = GetDistanceCost(cost_model, code);
1294 const int first_i = i;
1295 int j_max = 0, interval_ends_index = 0;
1296 const int is_offset_zero = (offset_cost == 0.);
1297
1298 if (!is_offset_zero) {
1299 j_max = (int)ceil(
1300 (cost_manager->max_cost_cache_ - cost_manager->min_cost_cache_) /
1301 offset_cost);
1302 if (j_max < 1) {
1303 j_max = 1;
1304 } else if (j_max > cost_manager->interval_ends_size_ - 1) {
1305 // This could only happen in the case of MAX_LENGTH.
1306 j_max = cost_manager->interval_ends_size_ - 1;
1307 }
1308 } // else j_max is unused anyway.
1309
1310 // Instead of considering all contributions from a pixel i by calling:
1311 // PushInterval(cost_manager, prev_cost + offset_cost, i, len);
1312 // we optimize these contributions in case offset_cost stays the same for
1313 // consecutive pixels. This describes a set of pixels similar to a
1314 // previous set (e.g. constant color regions).
1315 for (; i < pix_count - 1; ++i) {
1316 int offset_next, len_next;
1317 prev_cost = cost_manager->costs_[i - 1];
1318
1319 if (is_offset_zero) {
1320 // No optimization can be made so we just push all of the
1321 // contributions from i.
1322 PushInterval(cost_manager, prev_cost, i, len);
1323 } else {
1324 // j_max is chosen as the smallest j such that:
1325 // max of cost_cache_ < j*offset cost + min of cost_cache_
1326 // Therefore, the pixel influenced by i-j_max, cannot be influenced
1327 // by i. Only the costs after the end of what i contributed need to be
1328 // updated. cost_manager->interval_ends_ is a circular buffer that
1329 // stores those ends.
1330 const double distance_cost = prev_cost + offset_cost;
1331 int j = cost_manager->interval_ends_[interval_ends_index];
1332 if (i - first_i <= j_max ||
1333 !IsCostCacheIntervalWritable(j, i + len)) {
1334 PushInterval(cost_manager, distance_cost, i, len);
1335 } else {
1336 for (; j < i + len; ++j) {
1337 UpdateCost(cost_manager, j, i, distance_cost);
1338 }
1339 }
1340 // Store the new end in the circular buffer.
1341 assert(interval_ends_index < cost_manager->interval_ends_size_);
1342 cost_manager->interval_ends_[interval_ends_index] = i + len;
1343 if (++interval_ends_index > j_max) interval_ends_index = 0;
1344 }
1345
1346 // Check whether i is the last pixel to consider, as it is handled
1347 // differently.
1348 if (i + 1 >= pix_count - 1) break;
1349 HashChainFindCopy(hash_chain, i + 1, &offset_next, &len_next);
1350 if (offset_next != offset) break;
1351 len = len_next;
1352 UpdateCostPerIndex(cost_manager, i);
1353 AddSingleLiteralWithCostModel(argb + i, &hashers, cost_model, i,
1354 use_color_cache, prev_cost,
1355 cost_manager->costs_, dist_array);
1356 }
1357 // Submit the last pixel.
1358 UpdateCostPerIndex(cost_manager, i + 1);
1359
1360 // This if is for speedup only. It roughly doubles the speed, and
1361 // makes compression worse by .1 %.
1362 if (len >= skip_length && code <= skip_min_distance_code) {
1363 // Long copy for short distances, let's skip the middle
1364 // lookups for better copies.
1365 // 1) insert the hashes.
1366 if (use_color_cache) {
1367 int k;
1368 for (k = 0; k < len; ++k) {
1369 VP8LColorCacheInsert(&hashers, argb[i + k]);
1370 }
1371 }
1372 // 2) jump.
1373 {
1374 const int i_next = i + len - 1; // for loop does ++i, thus -1 here.
1375 for (; i <= i_next; ++i) UpdateCostPerIndex(cost_manager, i + 1);
1376 i = i_next;
1377 }
1378 goto next_symbol;
1379 }
1380 if (len > 2) {
1381 // Also try the smallest interval possible (size 2).
1382 double cost_total =
1383 prev_cost + offset_cost + GetLengthCost(cost_model, 1);
1384 if (cost_manager->costs_[i + 1] > cost_total) {
1385 cost_manager->costs_[i + 1] = (float)cost_total;
1386 dist_array[i + 1] = 2;
1387 }
1388 }
1389 } else {
1390 // The pixel is added as a single literal so just update the costs.
1391 UpdateCostPerIndex(cost_manager, i + 1);
1392 }
1393
1394 AddSingleLiteralWithCostModel(argb + i, &hashers, cost_model, i,
1395 use_color_cache, prev_cost,
1396 cost_manager->costs_, dist_array);
1397
1398 next_symbol: ;
1399 }
1400 // Handle the last pixel.
1401 if (i == (pix_count - 1)) {
1402 AddSingleLiteralWithCostModel(
1403 argb + i, &hashers, cost_model, i, use_color_cache,
1404 cost_manager->costs_[pix_count - 2], cost_manager->costs_, dist_array);
1405 }
1406
1407 ok = !refs->error_;
1408 Error:
1409 if (cc_init) VP8LColorCacheClear(&hashers);
1410 CostManagerClear(cost_manager);
1411 WebPSafeFree(cost_model);
1412 WebPSafeFree(cost_manager);
1413 return ok;
1414}
1415
1416// We pack the path at the end of *dist_array and return
1417// a pointer to this part of the array. Example:
1418// dist_array = [1x2xx3x2] => packed [1x2x1232], chosen_path = [1232]
1419static void TraceBackwards(uint16_t* const dist_array,
1420 int dist_array_size,
1421 uint16_t** const chosen_path,
1422 int* const chosen_path_size) {
1423 uint16_t* path = dist_array + dist_array_size;
1424 uint16_t* cur = dist_array + dist_array_size - 1;
1425 while (cur >= dist_array) {
1426 const int k = *cur;
1427 --path;
1428 *path = k;
1429 cur -= k;
1430 }
1431 *chosen_path = path;
1432 *chosen_path_size = (int)(dist_array + dist_array_size - path);
1433}
1434
1435static int BackwardReferencesHashChainFollowChosenPath(
1436 const uint32_t* const argb, int cache_bits,
1437 const uint16_t* const chosen_path, int chosen_path_size,
1438 const VP8LHashChain* const hash_chain, VP8LBackwardRefs* const refs) {
1439 const int use_color_cache = (cache_bits > 0);
1440 int ix;
1441 int i = 0;
1442 int ok = 0;
1443 int cc_init = 0;
1444 VP8LColorCache hashers;
1445
1446 if (use_color_cache) {
1447 cc_init = VP8LColorCacheInit(&hashers, cache_bits);
1448 if (!cc_init) goto Error;
1449 }
1450
1451 ClearBackwardRefs(refs);
1452 for (ix = 0; ix < chosen_path_size; ++ix) {
1453 const int len = chosen_path[ix];
1454 if (len != 1) {
1455 int k;
1456 const int offset = HashChainFindOffset(hash_chain, i);
1457 BackwardRefsCursorAdd(refs, PixOrCopyCreateCopy(offset, len));
1458 if (use_color_cache) {
1459 for (k = 0; k < len; ++k) {
1460 VP8LColorCacheInsert(&hashers, argb[i + k]);
1461 }
1462 }
1463 i += len;
1464 } else {
1465 PixOrCopy v;
1466 const int idx =
1467 use_color_cache ? VP8LColorCacheContains(&hashers, argb[i]) : -1;
1468 if (idx >= 0) {
1469 // use_color_cache is true and hashers contains argb[i]
1470 // push pixel as a color cache index
1471 v = PixOrCopyCreateCacheIdx(idx);
1472 } else {
1473 if (use_color_cache) VP8LColorCacheInsert(&hashers, argb[i]);
1474 v = PixOrCopyCreateLiteral(argb[i]);
1475 }
1476 BackwardRefsCursorAdd(refs, v);
1477 ++i;
1478 }
1479 }
1480 ok = !refs->error_;
1481 Error:
1482 if (cc_init) VP8LColorCacheClear(&hashers);
1483 return ok;
1484}
1485
1486// Returns 1 on success.
1487static int BackwardReferencesTraceBackwards(
1488 int xsize, int ysize, const uint32_t* const argb, int quality,
1489 int cache_bits, const VP8LHashChain* const hash_chain,
1490 VP8LBackwardRefs* const refs) {
1491 int ok = 0;
1492 const int dist_array_size = xsize * ysize;
1493 uint16_t* chosen_path = NULL;
1494 int chosen_path_size = 0;
1495 uint16_t* dist_array =
1496 (uint16_t*)WebPSafeMalloc(dist_array_size, sizeof(*dist_array));
1497
1498 if (dist_array == NULL) goto Error;
1499
1500 if (!BackwardReferencesHashChainDistanceOnly(
1501 xsize, ysize, argb, quality, cache_bits, hash_chain,
1502 refs, dist_array)) {
1503 goto Error;
1504 }
1505 TraceBackwards(dist_array, dist_array_size, &chosen_path, &chosen_path_size);
1506 if (!BackwardReferencesHashChainFollowChosenPath(
1507 argb, cache_bits, chosen_path, chosen_path_size, hash_chain, refs)) {
1508 goto Error;
1509 }
1510 ok = 1;
1511 Error:
1512 WebPSafeFree(dist_array);
1513 return ok;
1514}
1515
1516static void BackwardReferences2DLocality(int xsize,
1517 const VP8LBackwardRefs* const refs) {
1518 VP8LRefsCursor c = VP8LRefsCursorInit(refs);
1519 while (VP8LRefsCursorOk(&c)) {
1520 if (PixOrCopyIsCopy(c.cur_pos)) {
1521 const int dist = c.cur_pos->argb_or_distance;
1522 const int transformed_dist = DistanceToPlaneCode(xsize, dist);
1523 c.cur_pos->argb_or_distance = transformed_dist;
1524 }
1525 VP8LRefsCursorNext(&c);
1526 }
1527}
1528
1529// Computes the entropies for a color cache size (in bits) between 0 (unused)
1530// and cache_bits_max (inclusive).
1531// Returns 1 on success, 0 in case of allocation error.
1532static int ComputeCacheEntropies(const uint32_t* argb,
1533 const VP8LBackwardRefs* const refs,
1534 int cache_bits_max, double entropies[]) {
1535 int cc_init[MAX_COLOR_CACHE_BITS + 1] = { 0 };
1536 VP8LColorCache hashers[MAX_COLOR_CACHE_BITS + 1];
1537 VP8LRefsCursor c = VP8LRefsCursorInit(refs);
1538 VP8LHistogram* histos[MAX_COLOR_CACHE_BITS + 1] = { NULL };
1539 int ok = 0;
1540 int i;
1541
1542 for (i = 0; i <= cache_bits_max; ++i) {
1543 histos[i] = VP8LAllocateHistogram(i);
1544 if (histos[i] == NULL) goto Error;
1545 if (i == 0) continue;
1546 cc_init[i] = VP8LColorCacheInit(&hashers[i], i);
1547 if (!cc_init[i]) goto Error;
1548 }
1549
1550 assert(cache_bits_max >= 0);
1551 // Do not use the color cache for cache_bits=0.
1552 while (VP8LRefsCursorOk(&c)) {
1553 VP8LHistogramAddSinglePixOrCopy(histos[0], c.cur_pos);
1554 VP8LRefsCursorNext(&c);
1555 }
1556 if (cache_bits_max > 0) {
1557 c = VP8LRefsCursorInit(refs);
1558 while (VP8LRefsCursorOk(&c)) {
1559 const PixOrCopy* const v = c.cur_pos;
1560 if (PixOrCopyIsLiteral(v)) {
1561 const uint32_t pix = *argb++;
1562 // The keys of the caches can be derived from the longest one.
1563 int key = HashPix(pix, 32 - cache_bits_max);
1564 for (i = cache_bits_max; i >= 1; --i, key >>= 1) {
1565 if (VP8LColorCacheLookup(&hashers[i], key) == pix) {
1566 ++histos[i]->literal_[NUM_LITERAL_CODES + NUM_LENGTH_CODES + key];
1567 } else {
1568 VP8LColorCacheSet(&hashers[i], key, pix);
1569 ++histos[i]->blue_[pix & 0xff];
1570 ++histos[i]->literal_[(pix >> 8) & 0xff];
1571 ++histos[i]->red_[(pix >> 16) & 0xff];
1572 ++histos[i]->alpha_[pix >> 24];
1573 }
1574 }
1575 } else {
1576 // Update the histograms for distance/length.
1577 int len = PixOrCopyLength(v);
1578 int code_dist, code_len, extra_bits;
1579 uint32_t argb_prev = *argb ^ 0xffffffffu;
1580 VP8LPrefixEncodeBits(len, &code_len, &extra_bits);
1581 VP8LPrefixEncodeBits(PixOrCopyDistance(v), &code_dist, &extra_bits);
1582 for (i = 1; i <= cache_bits_max; ++i) {
1583 ++histos[i]->literal_[NUM_LITERAL_CODES + code_len];
1584 ++histos[i]->distance_[code_dist];
1585 }
1586 // Update the colors caches.
1587 do {
1588 if (*argb != argb_prev) {
1589 // Efficiency: insert only if the color changes.
1590 int key = HashPix(*argb, 32 - cache_bits_max);
1591 for (i = cache_bits_max; i >= 1; --i, key >>= 1) {
1592 hashers[i].colors_[key] = *argb;
1593 }
1594 argb_prev = *argb;
1595 }
1596 argb++;
1597 } while (--len != 0);
1598 }
1599 VP8LRefsCursorNext(&c);
1600 }
1601 }
1602 for (i = 0; i <= cache_bits_max; ++i) {
1603 entropies[i] = VP8LHistogramEstimateBits(histos[i]);
1604 }
1605 ok = 1;
1606Error:
1607 for (i = 0; i <= cache_bits_max; ++i) {
1608 if (cc_init[i]) VP8LColorCacheClear(&hashers[i]);
1609 VP8LFreeHistogram(histos[i]);
1610 }
1611 return ok;
1612}
1613
1614// Evaluate optimal cache bits for the local color cache.
1615// The input *best_cache_bits sets the maximum cache bits to use (passing 0
1616// implies disabling the local color cache). The local color cache is also
1617// disabled for the lower (<= 25) quality.
1618// Returns 0 in case of memory error.
1619static int CalculateBestCacheSize(const uint32_t* const argb,
1620 int xsize, int ysize, int quality,
1621 const VP8LHashChain* const hash_chain,
1622 VP8LBackwardRefs* const refs,
1623 int* const lz77_computed,
1624 int* const best_cache_bits) {
1625 int i;
1626 int cache_bits_high = (quality <= 25) ? 0 : *best_cache_bits;
1627 double entropy_min = MAX_ENTROPY;
1628 double entropies[MAX_COLOR_CACHE_BITS + 1];
1629
1630 assert(cache_bits_high <= MAX_COLOR_CACHE_BITS);
1631
1632 *lz77_computed = 0;
1633 if (cache_bits_high == 0) {
1634 *best_cache_bits = 0;
1635 // Local color cache is disabled.
1636 return 1;
1637 }
1638 // Compute LZ77 with no cache (0 bits), as the ideal LZ77 with a color cache
1639 // is not that different in practice.
1640 if (!BackwardReferencesLz77(xsize, ysize, argb, 0, hash_chain, refs)) {
1641 return 0;
1642 }
1643 // Find the cache_bits giving the lowest entropy. The search is done in a
1644 // brute-force way as the function (entropy w.r.t cache_bits) can be
1645 // anything in practice.
1646 if (!ComputeCacheEntropies(argb, refs, cache_bits_high, entropies)) {
1647 return 0;
1648 }
1649 for (i = 0; i <= cache_bits_high; ++i) {
1650 if (i == 0 || entropies[i] < entropy_min) {
1651 entropy_min = entropies[i];
1652 *best_cache_bits = i;
1653 }
1654 }
1655 return 1;
1656}
1657
1658// Update (in-place) backward references for specified cache_bits.
1659static int BackwardRefsWithLocalCache(const uint32_t* const argb,
1660 int cache_bits,
1661 VP8LBackwardRefs* const refs) {
1662 int pixel_index = 0;
1663 VP8LColorCache hashers;
1664 VP8LRefsCursor c = VP8LRefsCursorInit(refs);
1665 if (!VP8LColorCacheInit(&hashers, cache_bits)) return 0;
1666
1667 while (VP8LRefsCursorOk(&c)) {
1668 PixOrCopy* const v = c.cur_pos;
1669 if (PixOrCopyIsLiteral(v)) {
1670 const uint32_t argb_literal = v->argb_or_distance;
1671 const int ix = VP8LColorCacheContains(&hashers, argb_literal);
1672 if (ix >= 0) {
1673 // hashers contains argb_literal
1674 *v = PixOrCopyCreateCacheIdx(ix);
1675 } else {
1676 VP8LColorCacheInsert(&hashers, argb_literal);
1677 }
1678 ++pixel_index;
1679 } else {
1680 // refs was created without local cache, so it can not have cache indexes.
1681 int k;
1682 assert(PixOrCopyIsCopy(v));
1683 for (k = 0; k < v->len; ++k) {
1684 VP8LColorCacheInsert(&hashers, argb[pixel_index++]);
1685 }
1686 }
1687 VP8LRefsCursorNext(&c);
1688 }
1689 VP8LColorCacheClear(&hashers);
1690 return 1;
1691}
1692
1693static VP8LBackwardRefs* GetBackwardReferencesLowEffort(
1694 int width, int height, const uint32_t* const argb,
1695 int* const cache_bits, const VP8LHashChain* const hash_chain,
1696 VP8LBackwardRefs refs_array[2]) {
1697 VP8LBackwardRefs* refs_lz77 = &refs_array[0];
1698 *cache_bits = 0;
1699 if (!BackwardReferencesLz77(width, height, argb, 0, hash_chain, refs_lz77)) {
1700 return NULL;
1701 }
1702 BackwardReferences2DLocality(width, refs_lz77);
1703 return refs_lz77;
1704}
1705
1706static VP8LBackwardRefs* GetBackwardReferences(
1707 int width, int height, const uint32_t* const argb, int quality,
1708 int* const cache_bits, const VP8LHashChain* const hash_chain,
1709 VP8LBackwardRefs refs_array[2]) {
1710 int lz77_is_useful;
1711 int lz77_computed;
1712 double bit_cost_lz77, bit_cost_rle;
1713 VP8LBackwardRefs* best = NULL;
1714 VP8LBackwardRefs* refs_lz77 = &refs_array[0];
1715 VP8LBackwardRefs* refs_rle = &refs_array[1];
1716 VP8LHistogram* histo = NULL;
1717
1718 if (!CalculateBestCacheSize(argb, width, height, quality, hash_chain,
1719 refs_lz77, &lz77_computed, cache_bits)) {
1720 goto Error;
1721 }
1722
1723 if (lz77_computed) {
1724 // Transform refs_lz77 for the optimized cache_bits.
1725 if (*cache_bits > 0) {
1726 if (!BackwardRefsWithLocalCache(argb, *cache_bits, refs_lz77)) {
1727 goto Error;
1728 }
1729 }
1730 } else {
1731 if (!BackwardReferencesLz77(width, height, argb, *cache_bits, hash_chain,
1732 refs_lz77)) {
1733 goto Error;
1734 }
1735 }
1736
1737 if (!BackwardReferencesRle(width, height, argb, *cache_bits, refs_rle)) {
1738 goto Error;
1739 }
1740
1741 histo = VP8LAllocateHistogram(*cache_bits);
1742 if (histo == NULL) goto Error;
1743
1744 {
1745 // Evaluate LZ77 coding.
1746 VP8LHistogramCreate(histo, refs_lz77, *cache_bits);
1747 bit_cost_lz77 = VP8LHistogramEstimateBits(histo);
1748 // Evaluate RLE coding.
1749 VP8LHistogramCreate(histo, refs_rle, *cache_bits);
1750 bit_cost_rle = VP8LHistogramEstimateBits(histo);
1751 // Decide if LZ77 is useful.
1752 lz77_is_useful = (bit_cost_lz77 < bit_cost_rle);
1753 }
1754
1755 // Choose appropriate backward reference.
1756 if (lz77_is_useful) {
1757 // TraceBackwards is costly. Don't execute it at lower quality.
1758 const int try_lz77_trace_backwards = (quality >= 25);
1759 best = refs_lz77; // default guess: lz77 is better
1760 if (try_lz77_trace_backwards) {
1761 VP8LBackwardRefs* const refs_trace = refs_rle;
1762 if (!VP8LBackwardRefsCopy(refs_lz77, refs_trace)) {
1763 best = NULL;
1764 goto Error;
1765 }
1766 if (BackwardReferencesTraceBackwards(width, height, argb, quality,
1767 *cache_bits, hash_chain,
1768 refs_trace)) {
1769 double bit_cost_trace;
1770 // Evaluate LZ77 coding.
1771 VP8LHistogramCreate(histo, refs_trace, *cache_bits);
1772 bit_cost_trace = VP8LHistogramEstimateBits(histo);
1773 if (bit_cost_trace < bit_cost_lz77) {
1774 best = refs_trace;
1775 }
1776 }
1777 }
1778 } else {
1779 best = refs_rle;
1780 }
1781
1782 BackwardReferences2DLocality(width, best);
1783
1784 Error:
1785 VP8LFreeHistogram(histo);
1786 return best;
1787}
1788
1789VP8LBackwardRefs* VP8LGetBackwardReferences(
1790 int width, int height, const uint32_t* const argb, int quality,
1791 int low_effort, int* const cache_bits,
1792 const VP8LHashChain* const hash_chain, VP8LBackwardRefs refs_array[2]) {
1793 if (low_effort) {
1794 return GetBackwardReferencesLowEffort(width, height, argb, cache_bits,
1795 hash_chain, refs_array);
1796 } else {
1797 return GetBackwardReferences(width, height, argb, quality, cache_bits,
1798 hash_chain, refs_array);
1799 }
1800}
1801