third_party/libwebp/enc/vp8l.c

   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 // main entry for the lossless encoder.
  11 //
  12 // Author: Vikas Arora (vikaas.arora@gmail.com)
  13 //
  14
  15 #include <assert.h>
  16 #include <stdio.h>
  17 #include <stdlib.h>
  18
  19 #include "./backward_references.h"
  20 #include "./vp8enci.h"
  21 #include "./vp8li.h"
  22 #include "../dsp/lossless.h"
  23 #include "../utils/bit_writer.h"
  24 #include "../utils/huffman_encode.h"
  25 #include "../utils/utils.h"
  26 #include "../webp/format_constants.h"
  27
  28 #define PALETTE_KEY_RIGHT_SHIFT   22  // Key for 1K buffer.
  29 #define MAX_HUFF_IMAGE_SIZE       (16 * 1024 * 1024)
  30 #define MAX_COLORS_FOR_GRAPH      64
  31
  32 // -----------------------------------------------------------------------------
  33 // Palette
  34
  35 static int CompareColors(const void* p1, const void* p2) {
  36   const uint32_t a = *(const uint32_t*)p1;
  37   const uint32_t b = *(const uint32_t*)p2;
  38   assert(a != b);
  39   return (a < b) ? -1 : 1;
  40 }
  41
  42 // If number of colors in the image is less than or equal to MAX_PALETTE_SIZE,
  43 // creates a palette and returns true, else returns false.
  44 static int AnalyzeAndCreatePalette(const WebPPicture* const pic,
  45                                    uint32_t palette[MAX_PALETTE_SIZE],
  46                                    int* const palette_size) {
  47   int i, x, y, key;
  48   int num_colors = 0;
  49   uint8_t in_use[MAX_PALETTE_SIZE * 4] = { 0 };
  50   uint32_t colors[MAX_PALETTE_SIZE * 4];
  51   static const uint32_t kHashMul = 0x1e35a7bd;
  52   const uint32_t* argb = pic->argb;
  53   const int width = pic->width;
  54   const int height = pic->height;
  55   uint32_t last_pix = ~argb[0];   // so we're sure that last_pix != argb[0]
  56
  57   for (y = 0; y < height; ++y) {
  58     for (x = 0; x < width; ++x) {
  59       if (argb[x] == last_pix) {
  60         continue;
  61       }
  62       last_pix = argb[x];
  63       key = (kHashMul * last_pix) >> PALETTE_KEY_RIGHT_SHIFT;
  64       while (1) {
  65         if (!in_use[key]) {
  66           colors[key] = last_pix;
  67           in_use[key] = 1;
  68           ++num_colors;
  69           if (num_colors > MAX_PALETTE_SIZE) {
  70             return 0;
  71           }
  72           break;
  73         } else if (colors[key] == last_pix) {
  74           // The color is already there.
  75           break;
  76         } else {
  77           // Some other color sits there.
  78           // Do linear conflict resolution.
  79           ++key;
  80           key &= (MAX_PALETTE_SIZE * 4 - 1);  // key mask for 1K buffer.
  81         }
  82       }
  83     }
  84     argb += pic->argb_stride;
  85   }
  86
  87   // TODO(skal): could we reuse in_use[] to speed up EncodePalette()?
  88   num_colors = 0;
  89   for (i = 0; i < (int)(sizeof(in_use) / sizeof(in_use[0])); ++i) {
  90     if (in_use[i]) {
  91       palette[num_colors] = colors[i];
  92       ++num_colors;
  93     }
  94   }
  95
  96   qsort(palette, num_colors, sizeof(*palette), CompareColors);
  97   *palette_size = num_colors;
  98   return 1;
  99 }
 100
 101 static int AnalyzeEntropy(const uint32_t* argb,
 102                           int width, int height, int argb_stride,
 103                           double* const nonpredicted_bits,
 104                           double* const predicted_bits) {
 105   int x, y;
 106   const uint32_t* last_line = NULL;
 107   uint32_t last_pix = argb[0];    // so we're sure that pix_diff == 0
 108
 109   VP8LHistogramSet* const histo_set = VP8LAllocateHistogramSet(2, 0);
 110   if (histo_set == NULL) return 0;
 111
 112   for (y = 0; y < height; ++y) {
 113     for (x = 0; x < width; ++x) {
 114       const uint32_t pix = argb[x];
 115       const uint32_t pix_diff = VP8LSubPixels(pix, last_pix);
 116       if (pix_diff == 0) continue;
 117       if (last_line != NULL && pix == last_line[x]) {
 118         continue;
 119       }
 120       last_pix = pix;
 121       {
 122         const PixOrCopy pix_token = PixOrCopyCreateLiteral(pix);
 123         const PixOrCopy pix_diff_token = PixOrCopyCreateLiteral(pix_diff);
 124         VP8LHistogramAddSinglePixOrCopy(histo_set->histograms[0], &pix_token);
 125         VP8LHistogramAddSinglePixOrCopy(histo_set->histograms[1],
 126                                         &pix_diff_token);
 127       }
 128     }
 129     last_line = argb;
 130     argb += argb_stride;
 131   }
 132   *nonpredicted_bits = VP8LHistogramEstimateBitsBulk(histo_set->histograms[0]);
 133   *predicted_bits = VP8LHistogramEstimateBitsBulk(histo_set->histograms[1]);
 134   VP8LFreeHistogramSet(histo_set);
 135   return 1;
 136 }
 137
 138 static int AnalyzeAndInit(VP8LEncoder* const enc, WebPImageHint image_hint) {
 139   const WebPPicture* const pic = enc->pic_;
 140   const int width = pic->width;
 141   const int height = pic->height;
 142   const int pix_cnt = width * height;
 143   // we round the block size up, so we're guaranteed to have
 144   // at max MAX_REFS_BLOCK_PER_IMAGE blocks used:
 145   int refs_block_size = (pix_cnt - 1) / MAX_REFS_BLOCK_PER_IMAGE + 1;
 146   assert(pic != NULL && pic->argb != NULL);
 147
 148   enc->use_palette_ =
 149       AnalyzeAndCreatePalette(pic, enc->palette_, &enc->palette_size_);
 150
 151   if (image_hint == WEBP_HINT_GRAPH) {
 152     if (enc->use_palette_ && enc->palette_size_ < MAX_COLORS_FOR_GRAPH) {
 153       enc->use_palette_ = 0;
 154     }
 155   }
 156
 157   if (!enc->use_palette_) {
 158     if (image_hint == WEBP_HINT_PHOTO) {
 159       enc->use_predict_ = 1;
 160       enc->use_cross_color_ = 1;
 161     } else {
 162       double non_pred_entropy, pred_entropy;
 163       if (!AnalyzeEntropy(pic->argb, width, height, pic->argb_stride,
 164                           &non_pred_entropy, &pred_entropy)) {
 165         return 0;
 166       }
 167       if (pred_entropy < 0.95 * non_pred_entropy) {
 168         enc->use_predict_ = 1;
 169         enc->use_cross_color_ = 1;
 170       }
 171     }
 172   }
 173   if (!VP8LHashChainInit(&enc->hash_chain_, pix_cnt)) return 0;
 174
 175   // palette-friendly input typically uses less literals
 176   //  -> reduce block size a bit
 177   if (enc->use_palette_) refs_block_size /= 2;
 178   VP8LBackwardRefsInit(&enc->refs_[0], refs_block_size);
 179   VP8LBackwardRefsInit(&enc->refs_[1], refs_block_size);
 180
 181   return 1;
 182 }
 183
 184 // Returns false in case of memory error.
 185 static int GetHuffBitLengthsAndCodes(
 186     const VP8LHistogramSet* const histogram_image,
 187     HuffmanTreeCode* const huffman_codes) {
 188   int i, k;
 189   int ok = 0;
 190   uint64_t total_length_size = 0;
 191   uint8_t* mem_buf = NULL;
 192   const int histogram_image_size = histogram_image->size;
 193   int max_num_symbols = 0;
 194   uint8_t* buf_rle = NULL;
 195   HuffmanTree* huff_tree = NULL;
 196
 197   // Iterate over all histograms and get the aggregate number of codes used.
 198   for (i = 0; i < histogram_image_size; ++i) {
 199     const VP8LHistogram* const histo = histogram_image->histograms[i];
 200     HuffmanTreeCode* const codes = &huffman_codes[5 * i];
 201     for (k = 0; k < 5; ++k) {
 202       const int num_symbols =
 203           (k == 0) ? VP8LHistogramNumCodes(histo->palette_code_bits_) :
 204           (k == 4) ? NUM_DISTANCE_CODES : 256;
 205       codes[k].num_symbols = num_symbols;
 206       total_length_size += num_symbols;
 207     }
 208   }
 209
 210   // Allocate and Set Huffman codes.
 211   {
 212     uint16_t* codes;
 213     uint8_t* lengths;
 214     mem_buf = (uint8_t*)WebPSafeCalloc(total_length_size,
 215                                        sizeof(*lengths) + sizeof(*codes));
 216     if (mem_buf == NULL) goto End;
 217
 218     codes = (uint16_t*)mem_buf;
 219     lengths = (uint8_t*)&codes[total_length_size];
 220     for (i = 0; i < 5 * histogram_image_size; ++i) {
 221       const int bit_length = huffman_codes[i].num_symbols;
 222       huffman_codes[i].codes = codes;
 223       huffman_codes[i].code_lengths = lengths;
 224       codes += bit_length;
 225       lengths += bit_length;
 226       if (max_num_symbols < bit_length) {
 227         max_num_symbols = bit_length;
 228       }
 229     }
 230   }
 231
 232   buf_rle = (uint8_t*)WebPSafeMalloc(1ULL, max_num_symbols);
 233   huff_tree = (HuffmanTree*)WebPSafeMalloc(3ULL * max_num_symbols,
 234                                            sizeof(*huff_tree));
 235   if (buf_rle == NULL || huff_tree == NULL) goto End;
 236
 237   // Create Huffman trees.
 238   for (i = 0; i < histogram_image_size; ++i) {
 239     HuffmanTreeCode* const codes = &huffman_codes[5 * i];
 240     VP8LHistogram* const histo = histogram_image->histograms[i];
 241     VP8LCreateHuffmanTree(histo->literal_, 15, buf_rle, huff_tree, codes + 0);
 242     VP8LCreateHuffmanTree(histo->red_, 15, buf_rle, huff_tree, codes + 1);
 243     VP8LCreateHuffmanTree(histo->blue_, 15, buf_rle, huff_tree, codes + 2);
 244     VP8LCreateHuffmanTree(histo->alpha_, 15, buf_rle, huff_tree, codes + 3);
 245     VP8LCreateHuffmanTree(histo->distance_, 15, buf_rle, huff_tree, codes + 4);
 246   }
 247   ok = 1;
 248  End:
 249   WebPSafeFree(huff_tree);
 250   WebPSafeFree(buf_rle);
 251   if (!ok) {
 252     WebPSafeFree(mem_buf);
 253     memset(huffman_codes, 0, 5 * histogram_image_size * sizeof(*huffman_codes));
 254   }
 255   return ok;
 256 }
 257
 258 static void StoreHuffmanTreeOfHuffmanTreeToBitMask(
 259     VP8LBitWriter* const bw, const uint8_t* code_length_bitdepth) {
 260   // RFC 1951 will calm you down if you are worried about this funny sequence.
 261   // This sequence is tuned from that, but more weighted for lower symbol count,
 262   // and more spiking histograms.
 263   static const uint8_t kStorageOrder[CODE_LENGTH_CODES] = {
 264     17, 18, 0, 1, 2, 3, 4, 5, 16, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
 265   };
 266   int i;
 267   // Throw away trailing zeros:
 268   int codes_to_store = CODE_LENGTH_CODES;
 269   for (; codes_to_store > 4; --codes_to_store) {
 270     if (code_length_bitdepth[kStorageOrder[codes_to_store - 1]] != 0) {
 271       break;
 272     }
 273   }
 274   VP8LWriteBits(bw, 4, codes_to_store - 4);
 275   for (i = 0; i < codes_to_store; ++i) {
 276     VP8LWriteBits(bw, 3, code_length_bitdepth[kStorageOrder[i]]);
 277   }
 278 }
 279
 280 static void ClearHuffmanTreeIfOnlyOneSymbol(
 281     HuffmanTreeCode* const huffman_code) {
 282   int k;
 283   int count = 0;
 284   for (k = 0; k < huffman_code->num_symbols; ++k) {
 285     if (huffman_code->code_lengths[k] != 0) {
 286       ++count;
 287       if (count > 1) return;
 288     }
 289   }
 290   for (k = 0; k < huffman_code->num_symbols; ++k) {
 291     huffman_code->code_lengths[k] = 0;
 292     huffman_code->codes[k] = 0;
 293   }
 294 }
 295
 296 static void StoreHuffmanTreeToBitMask(
 297     VP8LBitWriter* const bw,
 298     const HuffmanTreeToken* const tokens, const int num_tokens,
 299     const HuffmanTreeCode* const huffman_code) {
 300   int i;
 301   for (i = 0; i < num_tokens; ++i) {
 302     const int ix = tokens[i].code;
 303     const int extra_bits = tokens[i].extra_bits;
 304     VP8LWriteBits(bw, huffman_code->code_lengths[ix], huffman_code->codes[ix]);
 305     switch (ix) {
 306       case 16:
 307         VP8LWriteBits(bw, 2, extra_bits);
 308         break;
 309       case 17:
 310         VP8LWriteBits(bw, 3, extra_bits);
 311         break;
 312       case 18:
 313         VP8LWriteBits(bw, 7, extra_bits);
 314         break;
 315     }
 316   }
 317 }
 318
 319 // 'huff_tree' and 'tokens' are pre-alloacted buffers.
 320 static void StoreFullHuffmanCode(VP8LBitWriter* const bw,
 321                                  HuffmanTree* const huff_tree,
 322                                  HuffmanTreeToken* const tokens,
 323                                  const HuffmanTreeCode* const tree) {
 324   uint8_t code_length_bitdepth[CODE_LENGTH_CODES] = { 0 };
 325   uint16_t code_length_bitdepth_symbols[CODE_LENGTH_CODES] = { 0 };
 326   const int max_tokens = tree->num_symbols;
 327   int num_tokens;
 328   HuffmanTreeCode huffman_code;
 329   huffman_code.num_symbols = CODE_LENGTH_CODES;
 330   huffman_code.code_lengths = code_length_bitdepth;
 331   huffman_code.codes = code_length_bitdepth_symbols;
 332
 333   VP8LWriteBits(bw, 1, 0);
 334   num_tokens = VP8LCreateCompressedHuffmanTree(tree, tokens, max_tokens);
 335   {
 336     uint32_t histogram[CODE_LENGTH_CODES] = { 0 };
 337     uint8_t buf_rle[CODE_LENGTH_CODES] = { 0 };
 338     int i;
 339     for (i = 0; i < num_tokens; ++i) {
 340       ++histogram[tokens[i].code];
 341     }
 342
 343     VP8LCreateHuffmanTree(histogram, 7, buf_rle, huff_tree, &huffman_code);
 344   }
 345
 346   StoreHuffmanTreeOfHuffmanTreeToBitMask(bw, code_length_bitdepth);
 347   ClearHuffmanTreeIfOnlyOneSymbol(&huffman_code);
 348   {
 349     int trailing_zero_bits = 0;
 350     int trimmed_length = num_tokens;
 351     int write_trimmed_length;
 352     int length;
 353     int i = num_tokens;
 354     while (i-- > 0) {
 355       const int ix = tokens[i].code;
 356       if (ix == 0 || ix == 17 || ix == 18) {
 357         --trimmed_length;   // discount trailing zeros
 358         trailing_zero_bits += code_length_bitdepth[ix];
 359         if (ix == 17) {
 360           trailing_zero_bits += 3;
 361         } else if (ix == 18) {
 362           trailing_zero_bits += 7;
 363         }
 364       } else {
 365         break;
 366       }
 367     }
 368     write_trimmed_length = (trimmed_length > 1 && trailing_zero_bits > 12);
 369     length = write_trimmed_length ? trimmed_length : num_tokens;
 370     VP8LWriteBits(bw, 1, write_trimmed_length);
 371     if (write_trimmed_length) {
 372       const int nbits = VP8LBitsLog2Ceiling(trimmed_length - 1);
 373       const int nbitpairs = (nbits == 0) ? 1 : (nbits + 1) / 2;
 374       VP8LWriteBits(bw, 3, nbitpairs - 1);
 375       assert(trimmed_length >= 2);
 376       VP8LWriteBits(bw, nbitpairs * 2, trimmed_length - 2);
 377     }
 378     StoreHuffmanTreeToBitMask(bw, tokens, length, &huffman_code);
 379   }
 380 }
 381
 382 // 'huff_tree' and 'tokens' are pre-alloacted buffers.
 383 static void StoreHuffmanCode(VP8LBitWriter* const bw,
 384                              HuffmanTree* const huff_tree,
 385                              HuffmanTreeToken* const tokens,
 386                              const HuffmanTreeCode* const huffman_code) {
 387   int i;
 388   int count = 0;
 389   int symbols[2] = { 0, 0 };
 390   const int kMaxBits = 8;
 391   const int kMaxSymbol = 1 << kMaxBits;
 392
 393   // Check whether it's a small tree.
 394   for (i = 0; i < huffman_code->num_symbols && count < 3; ++i) {
 395     if (huffman_code->code_lengths[i] != 0) {
 396       if (count < 2) symbols[count] = i;
 397       ++count;
 398     }
 399   }
 400
 401   if (count == 0) {   // emit minimal tree for empty cases
 402     // bits: small tree marker: 1, count-1: 0, large 8-bit code: 0, code: 0
 403     VP8LWriteBits(bw, 4, 0x01);
 404   } else if (count <= 2 && symbols[0] < kMaxSymbol && symbols[1] < kMaxSymbol) {
 405     VP8LWriteBits(bw, 1, 1);  // Small tree marker to encode 1 or 2 symbols.
 406     VP8LWriteBits(bw, 1, count - 1);
 407     if (symbols[0] <= 1) {
 408       VP8LWriteBits(bw, 1, 0);  // Code bit for small (1 bit) symbol value.
 409       VP8LWriteBits(bw, 1, symbols[0]);
 410     } else {
 411       VP8LWriteBits(bw, 1, 1);
 412       VP8LWriteBits(bw, 8, symbols[0]);
 413     }
 414     if (count == 2) {
 415       VP8LWriteBits(bw, 8, symbols[1]);
 416     }
 417   } else {
 418     StoreFullHuffmanCode(bw, huff_tree, tokens, huffman_code);
 419   }
 420 }
 421
 422 static void WriteHuffmanCode(VP8LBitWriter* const bw,
 423                              const HuffmanTreeCode* const code,
 424                              int code_index) {
 425   const int depth = code->code_lengths[code_index];
 426   const int symbol = code->codes[code_index];
 427   VP8LWriteBits(bw, depth, symbol);
 428 }
 429
 430 static WebPEncodingError StoreImageToBitMask(
 431     VP8LBitWriter* const bw, int width, int histo_bits,
 432     VP8LBackwardRefs* const refs,
 433     const uint16_t* histogram_symbols,
 434     const HuffmanTreeCode* const huffman_codes) {
 435   // x and y trace the position in the image.
 436   int x = 0;
 437   int y = 0;
 438   const int histo_xsize = histo_bits ? VP8LSubSampleSize(width, histo_bits) : 1;
 439   VP8LRefsCursor c = VP8LRefsCursorInit(refs);
 440   while (VP8LRefsCursorOk(&c)) {
 441     const PixOrCopy* const v = c.cur_pos;
 442     const int histogram_ix = histogram_symbols[histo_bits ?
 443                                                (y >> histo_bits) * histo_xsize +
 444                                                (x >> histo_bits) : 0];
 445     const HuffmanTreeCode* const codes = huffman_codes + 5 * histogram_ix;
 446     if (PixOrCopyIsCacheIdx(v)) {
 447       const int code = PixOrCopyCacheIdx(v);
 448       const int literal_ix = 256 + NUM_LENGTH_CODES + code;
 449       WriteHuffmanCode(bw, codes, literal_ix);
 450     } else if (PixOrCopyIsLiteral(v)) {
 451       static const int order[] = { 1, 2, 0, 3 };
 452       int k;
 453       for (k = 0; k < 4; ++k) {
 454         const int code = PixOrCopyLiteral(v, order[k]);
 455         WriteHuffmanCode(bw, codes + k, code);
 456       }
 457     } else {
 458       int bits, n_bits;
 459       int code, distance;
 460
 461       VP8LPrefixEncode(v->len, &code, &n_bits, &bits);
 462       WriteHuffmanCode(bw, codes, 256 + code);
 463       VP8LWriteBits(bw, n_bits, bits);
 464
 465       distance = PixOrCopyDistance(v);
 466       VP8LPrefixEncode(distance, &code, &n_bits, &bits);
 467       WriteHuffmanCode(bw, codes + 4, code);
 468       VP8LWriteBits(bw, n_bits, bits);
 469     }
 470     x += PixOrCopyLength(v);
 471     while (x >= width) {
 472       x -= width;
 473       ++y;
 474     }
 475     VP8LRefsCursorNext(&c);
 476   }
 477   return bw->error_ ? VP8_ENC_ERROR_OUT_OF_MEMORY : VP8_ENC_OK;
 478 }
 479
 480 // Special case of EncodeImageInternal() for cache-bits=0, histo_bits=31
 481 static WebPEncodingError EncodeImageNoHuffman(VP8LBitWriter* const bw,
 482                                               const uint32_t* const argb,
 483                                               VP8LHashChain* const hash_chain,
 484                                               VP8LBackwardRefs refs_array[2],
 485                                               int width, int height,
 486                                               int quality) {
 487   int i;
 488   int max_tokens = 0;
 489   WebPEncodingError err = VP8_ENC_OK;
 490   VP8LBackwardRefs* refs;
 491   HuffmanTreeToken* tokens = NULL;
 492   HuffmanTreeCode huffman_codes[5] = { { 0, NULL, NULL } };
 493   const uint16_t histogram_symbols[1] = { 0 };    // only one tree, one symbol
 494   VP8LHistogramSet* const histogram_image = VP8LAllocateHistogramSet(1, 0);
 495   HuffmanTree* const huff_tree = (HuffmanTree*)WebPSafeMalloc(
 496         3ULL * CODE_LENGTH_CODES, sizeof(*huff_tree));
 497   if (histogram_image == NULL || huff_tree == NULL) {
 498     err = VP8_ENC_ERROR_OUT_OF_MEMORY;
 499     goto Error;
 500   }
 501
 502   // Calculate backward references from ARGB image.
 503   refs = VP8LGetBackwardReferences(width, height, argb, quality, 0, 1,
 504                                    hash_chain, refs_array);
 505   if (refs == NULL) {
 506     err = VP8_ENC_ERROR_OUT_OF_MEMORY;
 507     goto Error;
 508   }
 509   // Build histogram image and symbols from backward references.
 510   VP8LHistogramStoreRefs(refs, histogram_image->histograms[0]);
 511
 512   // Create Huffman bit lengths and codes for each histogram image.
 513   assert(histogram_image->size == 1);
 514   if (!GetHuffBitLengthsAndCodes(histogram_image, huffman_codes)) {
 515     err = VP8_ENC_ERROR_OUT_OF_MEMORY;
 516     goto Error;
 517   }
 518
 519   // No color cache, no Huffman image.
 520   VP8LWriteBits(bw, 1, 0);
 521
 522   // Find maximum number of symbols for the huffman tree-set.
 523   for (i = 0; i < 5; ++i) {
 524     HuffmanTreeCode* const codes = &huffman_codes[i];
 525     if (max_tokens < codes->num_symbols) {
 526       max_tokens = codes->num_symbols;
 527     }
 528   }
 529
 530   tokens = (HuffmanTreeToken*)WebPSafeMalloc(max_tokens, sizeof(*tokens));
 531   if (tokens == NULL) {
 532     err = VP8_ENC_ERROR_OUT_OF_MEMORY;
 533     goto Error;
 534   }
 535
 536   // Store Huffman codes.
 537   for (i = 0; i < 5; ++i) {
 538     HuffmanTreeCode* const codes = &huffman_codes[i];
 539     StoreHuffmanCode(bw, huff_tree, tokens, codes);
 540     ClearHuffmanTreeIfOnlyOneSymbol(codes);
 541   }
 542
 543   // Store actual literals.
 544   err = StoreImageToBitMask(bw, width, 0, refs, histogram_symbols,
 545                             huffman_codes);
 546
 547  Error:
 548   WebPSafeFree(tokens);
 549   WebPSafeFree(huff_tree);
 550   VP8LFreeHistogramSet(histogram_image);
 551   WebPSafeFree(huffman_codes[0].codes);
 552   return err;
 553 }
 554
 555 static WebPEncodingError EncodeImageInternal(VP8LBitWriter* const bw,
 556                                              const uint32_t* const argb,
 557                                              VP8LHashChain* const hash_chain,
 558                                              VP8LBackwardRefs refs_array[2],
 559                                              int width, int height, int quality,
 560                                              int cache_bits,
 561                                              int histogram_bits) {
 562   WebPEncodingError err = VP8_ENC_OK;
 563   const int use_2d_locality = 1;
 564   const int use_color_cache = (cache_bits > 0);
 565   const uint32_t histogram_image_xysize =
 566       VP8LSubSampleSize(width, histogram_bits) *
 567       VP8LSubSampleSize(height, histogram_bits);
 568   VP8LHistogramSet* histogram_image =
 569       VP8LAllocateHistogramSet(histogram_image_xysize, cache_bits);
 570   int histogram_image_size = 0;
 571   size_t bit_array_size = 0;
 572   HuffmanTree* huff_tree = NULL;
 573   HuffmanTreeToken* tokens = NULL;
 574   HuffmanTreeCode* huffman_codes = NULL;
 575   VP8LBackwardRefs refs;
 576   VP8LBackwardRefs* best_refs;
 577   uint16_t* const histogram_symbols =
 578       (uint16_t*)WebPSafeMalloc(histogram_image_xysize,
 579                                 sizeof(*histogram_symbols));
 580   assert(histogram_bits >= MIN_HUFFMAN_BITS);
 581   assert(histogram_bits <= MAX_HUFFMAN_BITS);
 582
 583   VP8LBackwardRefsInit(&refs, refs_array[0].block_size_);
 584   if (histogram_image == NULL || histogram_symbols == NULL) {
 585     VP8LFreeHistogramSet(histogram_image);
 586     WebPSafeFree(histogram_symbols);
 587     return 0;
 588   }
 589
 590   // 'best_refs' is the reference to the best backward refs and points to one
 591   // of refs_array[0] or refs_array[1].
 592   // Calculate backward references from ARGB image.
 593   best_refs = VP8LGetBackwardReferences(width, height, argb, quality,
 594                                         cache_bits, use_2d_locality,
 595                                         hash_chain, refs_array);
 596   if (best_refs == NULL || !VP8LBackwardRefsCopy(best_refs, &refs)) {
 597     goto Error;
 598   }
 599   // Build histogram image and symbols from backward references.
 600   if (!VP8LGetHistoImageSymbols(width, height, &refs,
 601                                 quality, histogram_bits, cache_bits,
 602                                 histogram_image,
 603                                 histogram_symbols)) {
 604     goto Error;
 605   }
 606   // Create Huffman bit lengths and codes for each histogram image.
 607   histogram_image_size = histogram_image->size;
 608   bit_array_size = 5 * histogram_image_size;
 609   huffman_codes = (HuffmanTreeCode*)WebPSafeCalloc(bit_array_size,
 610                                                    sizeof(*huffman_codes));
 611   if (huffman_codes == NULL ||
 612       !GetHuffBitLengthsAndCodes(histogram_image, huffman_codes)) {
 613     goto Error;
 614   }
 615   // Free combined histograms.
 616   VP8LFreeHistogramSet(histogram_image);
 617   histogram_image = NULL;
 618
 619   // Color Cache parameters.
 620   VP8LWriteBits(bw, 1, use_color_cache);
 621   if (use_color_cache) {
 622     VP8LWriteBits(bw, 4, cache_bits);
 623   }
 624
 625   // Huffman image + meta huffman.
 626   {
 627     const int write_histogram_image = (histogram_image_size > 1);
 628     VP8LWriteBits(bw, 1, write_histogram_image);
 629     if (write_histogram_image) {
 630       uint32_t* const histogram_argb =
 631           (uint32_t*)WebPSafeMalloc(histogram_image_xysize,
 632                                     sizeof(*histogram_argb));
 633       int max_index = 0;
 634       uint32_t i;
 635       if (histogram_argb == NULL) goto Error;
 636       for (i = 0; i < histogram_image_xysize; ++i) {
 637         const int symbol_index = histogram_symbols[i] & 0xffff;
 638         histogram_argb[i] = 0xff000000 | (symbol_index << 8);
 639         if (symbol_index >= max_index) {
 640           max_index = symbol_index + 1;
 641         }
 642       }
 643       histogram_image_size = max_index;
 644
 645       VP8LWriteBits(bw, 3, histogram_bits - 2);
 646       err = EncodeImageNoHuffman(bw, histogram_argb, hash_chain, refs_array,
 647                                  VP8LSubSampleSize(width, histogram_bits),
 648                                  VP8LSubSampleSize(height, histogram_bits),
 649                                  quality);
 650       WebPSafeFree(histogram_argb);
 651       if (err != VP8_ENC_OK) goto Error;
 652     }
 653   }
 654
 655   // Store Huffman codes.
 656   {
 657     int i;
 658     int max_tokens = 0;
 659     huff_tree = (HuffmanTree*)WebPSafeMalloc(3ULL * CODE_LENGTH_CODES,
 660                                              sizeof(*huff_tree));
 661     if (huff_tree == NULL) goto Error;
 662     // Find maximum number of symbols for the huffman tree-set.
 663     for (i = 0; i < 5 * histogram_image_size; ++i) {
 664       HuffmanTreeCode* const codes = &huffman_codes[i];
 665       if (max_tokens < codes->num_symbols) {
 666         max_tokens = codes->num_symbols;
 667       }
 668     }
 669     tokens = (HuffmanTreeToken*)WebPSafeMalloc(max_tokens,
 670                                                sizeof(*tokens));
 671     if (tokens == NULL) goto Error;
 672     for (i = 0; i < 5 * histogram_image_size; ++i) {
 673       HuffmanTreeCode* const codes = &huffman_codes[i];
 674       StoreHuffmanCode(bw, huff_tree, tokens, codes);
 675       ClearHuffmanTreeIfOnlyOneSymbol(codes);
 676     }
 677   }
 678
 679   // Store actual literals.
 680   err = StoreImageToBitMask(bw, width, histogram_bits, &refs,
 681                             histogram_symbols, huffman_codes);
 682
 683  Error:
 684   WebPSafeFree(tokens);
 685   WebPSafeFree(huff_tree);
 686   VP8LFreeHistogramSet(histogram_image);
 687   VP8LBackwardRefsClear(&refs);
 688   if (huffman_codes != NULL) {
 689     WebPSafeFree(huffman_codes->codes);
 690     WebPSafeFree(huffman_codes);
 691   }
 692   WebPSafeFree(histogram_symbols);
 693   return err;
 694 }
 695
 696 // -----------------------------------------------------------------------------
 697 // Transforms
 698
 699 // Check if it would be a good idea to subtract green from red and blue. We
 700 // only impact entropy in red/blue components, don't bother to look at others.
 701 static WebPEncodingError EvalAndApplySubtractGreen(VP8LEncoder* const enc,
 702                                                    int width, int height,
 703                                                    VP8LBitWriter* const bw) {
 704   if (!enc->use_palette_) {
 705     int i;
 706     const uint32_t* const argb = enc->argb_;
 707     double bit_cost_before, bit_cost_after;
 708     // Allocate histogram with cache_bits = 1.
 709     VP8LHistogram* const histo = VP8LAllocateHistogram(1);
 710     if (histo == NULL) return VP8_ENC_ERROR_OUT_OF_MEMORY;
 711     for (i = 0; i < width * height; ++i) {
 712       const uint32_t c = argb[i];
 713       ++histo->red_[(c >> 16) & 0xff];
 714       ++histo->blue_[(c >> 0) & 0xff];
 715     }
 716     bit_cost_before = VP8LHistogramEstimateBits(histo);
 717
 718     VP8LHistogramInit(histo, 1);
 719     for (i = 0; i < width * height; ++i) {
 720       const uint32_t c = argb[i];
 721       const int green = (c >> 8) & 0xff;
 722       ++histo->red_[((c >> 16) - green) & 0xff];
 723       ++histo->blue_[((c >> 0) - green) & 0xff];
 724     }
 725     bit_cost_after = VP8LHistogramEstimateBits(histo);
 726     VP8LFreeHistogram(histo);
 727
 728     // Check if subtracting green yields low entropy.
 729     enc->use_subtract_green_ = (bit_cost_after < bit_cost_before);
 730     if (enc->use_subtract_green_) {
 731       VP8LWriteBits(bw, 1, TRANSFORM_PRESENT);
 732       VP8LWriteBits(bw, 2, SUBTRACT_GREEN);
 733       VP8LSubtractGreenFromBlueAndRed(enc->argb_, width * height);
 734     }
 735   }
 736   return VP8_ENC_OK;
 737 }
 738
 739 static WebPEncodingError ApplyPredictFilter(const VP8LEncoder* const enc,
 740                                             int width, int height, int quality,
 741                                             VP8LBitWriter* const bw) {
 742   const int pred_bits = enc->transform_bits_;
 743   const int transform_width = VP8LSubSampleSize(width, pred_bits);
 744   const int transform_height = VP8LSubSampleSize(height, pred_bits);
 745
 746   VP8LResidualImage(width, height, pred_bits, enc->argb_, enc->argb_scratch_,
 747                     enc->transform_data_);
 748   VP8LWriteBits(bw, 1, TRANSFORM_PRESENT);
 749   VP8LWriteBits(bw, 2, PREDICTOR_TRANSFORM);
 750   assert(pred_bits >= 2);
 751   VP8LWriteBits(bw, 3, pred_bits - 2);
 752   return EncodeImageNoHuffman(bw, enc->transform_data_,
 753                               (VP8LHashChain*)&enc->hash_chain_,
 754                               (VP8LBackwardRefs*)enc->refs_,  // cast const away
 755                               transform_width, transform_height,
 756                               quality);
 757 }
 758
 759 static WebPEncodingError ApplyCrossColorFilter(const VP8LEncoder* const enc,
 760                                                int width, int height,
 761                                                int quality,
 762                                                VP8LBitWriter* const bw) {
 763   const int ccolor_transform_bits = enc->transform_bits_;
 764   const int transform_width = VP8LSubSampleSize(width, ccolor_transform_bits);
 765   const int transform_height = VP8LSubSampleSize(height, ccolor_transform_bits);
 766
 767   VP8LColorSpaceTransform(width, height, ccolor_transform_bits, quality,
 768                           enc->argb_, enc->transform_data_);
 769   VP8LWriteBits(bw, 1, TRANSFORM_PRESENT);
 770   VP8LWriteBits(bw, 2, CROSS_COLOR_TRANSFORM);
 771   assert(ccolor_transform_bits >= 2);
 772   VP8LWriteBits(bw, 3, ccolor_transform_bits - 2);
 773   return EncodeImageNoHuffman(bw, enc->transform_data_,
 774                               (VP8LHashChain*)&enc->hash_chain_,
 775                               (VP8LBackwardRefs*)enc->refs_,  // cast const away
 776                               transform_width, transform_height,
 777                               quality);
 778 }
 779
 780 // -----------------------------------------------------------------------------
 781
 782 static WebPEncodingError WriteRiffHeader(const WebPPicture* const pic,
 783                                          size_t riff_size, size_t vp8l_size) {
 784   uint8_t riff[RIFF_HEADER_SIZE + CHUNK_HEADER_SIZE + VP8L_SIGNATURE_SIZE] = {
 785     'R', 'I', 'F', 'F', 0, 0, 0, 0, 'W', 'E', 'B', 'P',
 786     'V', 'P', '8', 'L', 0, 0, 0, 0, VP8L_MAGIC_BYTE,
 787   };
 788   PutLE32(riff + TAG_SIZE, (uint32_t)riff_size);
 789   PutLE32(riff + RIFF_HEADER_SIZE + TAG_SIZE, (uint32_t)vp8l_size);
 790   if (!pic->writer(riff, sizeof(riff), pic)) {
 791     return VP8_ENC_ERROR_BAD_WRITE;
 792   }
 793   return VP8_ENC_OK;
 794 }
 795
 796 static int WriteImageSize(const WebPPicture* const pic,
 797                           VP8LBitWriter* const bw) {
 798   const int width = pic->width - 1;
 799   const int height = pic->height - 1;
 800   assert(width < WEBP_MAX_DIMENSION && height < WEBP_MAX_DIMENSION);
 801
 802   VP8LWriteBits(bw, VP8L_IMAGE_SIZE_BITS, width);
 803   VP8LWriteBits(bw, VP8L_IMAGE_SIZE_BITS, height);
 804   return !bw->error_;
 805 }
 806
 807 static int WriteRealAlphaAndVersion(VP8LBitWriter* const bw, int has_alpha) {
 808   VP8LWriteBits(bw, 1, has_alpha);
 809   VP8LWriteBits(bw, VP8L_VERSION_BITS, VP8L_VERSION);
 810   return !bw->error_;
 811 }
 812
 813 static WebPEncodingError WriteImage(const WebPPicture* const pic,
 814                                     VP8LBitWriter* const bw,
 815                                     size_t* const coded_size) {
 816   WebPEncodingError err = VP8_ENC_OK;
 817   const uint8_t* const webpll_data = VP8LBitWriterFinish(bw);
 818   const size_t webpll_size = VP8LBitWriterNumBytes(bw);
 819   const size_t vp8l_size = VP8L_SIGNATURE_SIZE + webpll_size;
 820   const size_t pad = vp8l_size & 1;
 821   const size_t riff_size = TAG_SIZE + CHUNK_HEADER_SIZE + vp8l_size + pad;
 822
 823   err = WriteRiffHeader(pic, riff_size, vp8l_size);
 824   if (err != VP8_ENC_OK) goto Error;
 825
 826   if (!pic->writer(webpll_data, webpll_size, pic)) {
 827     err = VP8_ENC_ERROR_BAD_WRITE;
 828     goto Error;
 829   }
 830
 831   if (pad) {
 832     const uint8_t pad_byte[1] = { 0 };
 833     if (!pic->writer(pad_byte, 1, pic)) {
 834       err = VP8_ENC_ERROR_BAD_WRITE;
 835       goto Error;
 836     }
 837   }
 838   *coded_size = CHUNK_HEADER_SIZE + riff_size;
 839   return VP8_ENC_OK;
 840
 841  Error:
 842   return err;
 843 }
 844
 845 // -----------------------------------------------------------------------------
 846
 847 // Allocates the memory for argb (W x H) buffer, 2 rows of context for
 848 // prediction and transform data.
 849 static WebPEncodingError AllocateTransformBuffer(VP8LEncoder* const enc,
 850                                                  int width, int height) {
 851   WebPEncodingError err = VP8_ENC_OK;
 852   const int tile_size = 1 << enc->transform_bits_;
 853   const uint64_t image_size = width * height;
 854   const uint64_t argb_scratch_size = tile_size * width + width;
 855   const int transform_data_size =
 856       VP8LSubSampleSize(width, enc->transform_bits_) *
 857       VP8LSubSampleSize(height, enc->transform_bits_);
 858   const uint64_t total_size =
 859       image_size + argb_scratch_size + (uint64_t)transform_data_size;
 860   uint32_t* mem = (uint32_t*)WebPSafeMalloc(total_size, sizeof(*mem));
 861   if (mem == NULL) {
 862     err = VP8_ENC_ERROR_OUT_OF_MEMORY;
 863     goto Error;
 864   }
 865   enc->argb_ = mem;
 866   mem += image_size;
 867   enc->argb_scratch_ = mem;
 868   mem += argb_scratch_size;
 869   enc->transform_data_ = mem;
 870   enc->current_width_ = width;
 871
 872  Error:
 873   return err;
 874 }
 875
 876 static void ApplyPalette(uint32_t* src, uint32_t* dst,
 877                          uint32_t src_stride, uint32_t dst_stride,
 878                          const uint32_t* palette, int palette_size,
 879                          int width, int height, int xbits, uint8_t* row) {
 880   int i, x, y;
 881   int use_LUT = 1;
 882   for (i = 0; i < palette_size; ++i) {
 883     if ((palette[i] & 0xffff00ffu) != 0) {
 884       use_LUT = 0;
 885       break;
 886     }
 887   }
 888
 889   if (use_LUT) {
 890     uint8_t inv_palette[MAX_PALETTE_SIZE] = { 0 };
 891     for (i = 0; i < palette_size; ++i) {
 892       const int color = (palette[i] >> 8) & 0xff;
 893       inv_palette[color] = i;
 894     }
 895     for (y = 0; y < height; ++y) {
 896       for (x = 0; x < width; ++x) {
 897         const int color = (src[x] >> 8) & 0xff;
 898         row[x] = inv_palette[color];
 899       }
 900       VP8LBundleColorMap(row, width, xbits, dst);
 901       src += src_stride;
 902       dst += dst_stride;
 903     }
 904   } else {
 905     // Use 1 pixel cache for ARGB pixels.
 906     uint32_t last_pix = palette[0];
 907     int last_idx = 0;
 908     for (y = 0; y < height; ++y) {
 909       for (x = 0; x < width; ++x) {
 910         const uint32_t pix = src[x];
 911         if (pix != last_pix) {
 912           for (i = 0; i < palette_size; ++i) {
 913             if (pix == palette[i]) {
 914               last_idx = i;
 915               last_pix = pix;
 916               break;
 917             }
 918           }
 919         }
 920         row[x] = last_idx;
 921       }
 922       VP8LBundleColorMap(row, width, xbits, dst);
 923       src += src_stride;
 924       dst += dst_stride;
 925     }
 926   }
 927 }
 928
 929 // Note: Expects "enc->palette_" to be set properly.
 930 // Also, "enc->palette_" will be modified after this call and should not be used
 931 // later.
 932 static WebPEncodingError EncodePalette(VP8LBitWriter* const bw,
 933                                        VP8LEncoder* const enc, int quality) {
 934   WebPEncodingError err = VP8_ENC_OK;
 935   int i;
 936   const WebPPicture* const pic = enc->pic_;
 937   uint32_t* src = pic->argb;
 938   uint32_t* dst;
 939   const int width = pic->width;
 940   const int height = pic->height;
 941   uint32_t* const palette = enc->palette_;
 942   const int palette_size = enc->palette_size_;
 943   uint8_t* row = NULL;
 944   int xbits;
 945
 946   // Replace each input pixel by corresponding palette index.
 947   // This is done line by line.
 948   if (palette_size <= 4) {
 949     xbits = (palette_size <= 2) ? 3 : 2;
 950   } else {
 951     xbits = (palette_size <= 16) ? 1 : 0;
 952   }
 953
 954   err = AllocateTransformBuffer(enc, VP8LSubSampleSize(width, xbits), height);
 955   if (err != VP8_ENC_OK) goto Error;
 956   dst = enc->argb_;
 957
 958   row = (uint8_t*)WebPSafeMalloc(width, sizeof(*row));
 959   if (row == NULL) return VP8_ENC_ERROR_OUT_OF_MEMORY;
 960
 961   ApplyPalette(src, dst, pic->argb_stride, enc->current_width_,
 962                palette, palette_size, width, height, xbits, row);
 963
 964   // Save palette to bitstream.
 965   VP8LWriteBits(bw, 1, TRANSFORM_PRESENT);
 966   VP8LWriteBits(bw, 2, COLOR_INDEXING_TRANSFORM);
 967   assert(palette_size >= 1);
 968   VP8LWriteBits(bw, 8, palette_size - 1);
 969   for (i = palette_size - 1; i >= 1; --i) {
 970     palette[i] = VP8LSubPixels(palette[i], palette[i - 1]);
 971   }
 972   err = EncodeImageNoHuffman(bw, palette, &enc->hash_chain_, enc->refs_,
 973                              palette_size, 1, quality);
 974
 975  Error:
 976   WebPSafeFree(row);
 977   return err;
 978 }
 979
 980 // -----------------------------------------------------------------------------
 981
 982 static int GetHistoBits(int method, int use_palette, int width, int height) {
 983   const int hist_size = VP8LGetHistogramSize(MAX_COLOR_CACHE_BITS);
 984   // Make tile size a function of encoding method (Range: 0 to 6).
 985   int histo_bits = (use_palette ? 9 : 7) - method;
 986   while (1) {
 987     const int huff_image_size = VP8LSubSampleSize(width, histo_bits) *
 988                                 VP8LSubSampleSize(height, histo_bits);
 989     if ((uint64_t)huff_image_size * hist_size <= MAX_HUFF_IMAGE_SIZE) break;
 990     ++histo_bits;
 991   }
 992   return (histo_bits < MIN_HUFFMAN_BITS) ? MIN_HUFFMAN_BITS :
 993          (histo_bits > MAX_HUFFMAN_BITS) ? MAX_HUFFMAN_BITS : histo_bits;
 994 }
 995
 996 static int GetTransformBits(int method, int histo_bits) {
 997   const int max_transform_bits = (method < 4) ? 6 : (method > 4) ? 4 : 5;
 998   return (histo_bits > max_transform_bits) ? max_transform_bits : histo_bits;
 999 }
1000
1001 static int GetCacheBits(float quality) {
1002   return (quality <= 25.f) ? 0 : 7;
1003 }
1004
1005 static void FinishEncParams(VP8LEncoder* const enc) {
1006   const WebPConfig* const config = enc->config_;
1007   const WebPPicture* const pic = enc->pic_;
1008   const int method = config->method;
1009   const float quality = config->quality;
1010   const int use_palette = enc->use_palette_;
1011   enc->histo_bits_ = GetHistoBits(method, use_palette, pic->width, pic->height);
1012   enc->transform_bits_ = GetTransformBits(method, enc->histo_bits_);
1013   enc->cache_bits_ = GetCacheBits(quality);
1014 }
1015
1016 // -----------------------------------------------------------------------------
1017 // VP8LEncoder
1018
1019 static VP8LEncoder* VP8LEncoderNew(const WebPConfig* const config,
1020                                    const WebPPicture* const picture) {
1021   VP8LEncoder* const enc = (VP8LEncoder*)WebPSafeCalloc(1ULL, sizeof(*enc));
1022   if (enc == NULL) {
1023     WebPEncodingSetError(picture, VP8_ENC_ERROR_OUT_OF_MEMORY);
1024     return NULL;
1025   }
1026   enc->config_ = config;
1027   enc->pic_ = picture;
1028
1029   VP8LDspInit();
1030
1031   return enc;
1032 }
1033
1034 static void VP8LEncoderDelete(VP8LEncoder* enc) {
1035   if (enc != NULL) {
1036     VP8LHashChainClear(&enc->hash_chain_);
1037     VP8LBackwardRefsClear(&enc->refs_[0]);
1038     VP8LBackwardRefsClear(&enc->refs_[1]);
1039     WebPSafeFree(enc->argb_);
1040     WebPSafeFree(enc);
1041   }
1042 }
1043
1044 // -----------------------------------------------------------------------------
1045 // Main call
1046
1047 WebPEncodingError VP8LEncodeStream(const WebPConfig* const config,
1048                                    const WebPPicture* const picture,
1049                                    VP8LBitWriter* const bw) {
1050   WebPEncodingError err = VP8_ENC_OK;
1051   const int quality = (int)config->quality;
1052   const int width = picture->width;
1053   const int height = picture->height;
1054   VP8LEncoder* const enc = VP8LEncoderNew(config, picture);
1055   const size_t byte_position = VP8LBitWriterNumBytes(bw);
1056
1057   if (enc == NULL) {
1058     err = VP8_ENC_ERROR_OUT_OF_MEMORY;
1059     goto Error;
1060   }
1061
1062   // ---------------------------------------------------------------------------
1063   // Analyze image (entropy, num_palettes etc)
1064
1065   if (!AnalyzeAndInit(enc, config->image_hint)) {
1066     err = VP8_ENC_ERROR_OUT_OF_MEMORY;
1067     goto Error;
1068   }
1069
1070   FinishEncParams(enc);
1071
1072   if (enc->use_palette_) {
1073     err = EncodePalette(bw, enc, quality);
1074     if (err != VP8_ENC_OK) goto Error;
1075     // Color cache is disabled for palette.
1076     enc->cache_bits_ = 0;
1077   }
1078
1079   // In case image is not packed.
1080   if (enc->argb_ == NULL) {
1081     int y;
1082     err = AllocateTransformBuffer(enc, width, height);
1083     if (err != VP8_ENC_OK) goto Error;
1084     assert(enc->argb_ != NULL);
1085     for (y = 0; y < height; ++y) {
1086       memcpy(enc->argb_ + y * width,
1087              picture->argb + y * picture->argb_stride,
1088              width * sizeof(*enc->argb_));
1089     }
1090     enc->current_width_ = width;
1091   }
1092
1093   // ---------------------------------------------------------------------------
1094   // Apply transforms and write transform data.
1095
1096   err = EvalAndApplySubtractGreen(enc, enc->current_width_, height, bw);
1097   if (err != VP8_ENC_OK) goto Error;
1098
1099   if (enc->use_predict_) {
1100     err = ApplyPredictFilter(enc, enc->current_width_, height, quality, bw);
1101     if (err != VP8_ENC_OK) goto Error;
1102   }
1103
1104   if (enc->use_cross_color_) {
1105     err = ApplyCrossColorFilter(enc, enc->current_width_, height, quality, bw);
1106     if (err != VP8_ENC_OK) goto Error;
1107   }
1108
1109   VP8LWriteBits(bw, 1, !TRANSFORM_PRESENT);  // No more transforms.
1110
1111   // ---------------------------------------------------------------------------
1112   // Estimate the color cache size.
1113
1114   if (enc->cache_bits_ > 0) {
1115     if (!VP8LCalculateEstimateForCacheSize(enc->argb_, enc->current_width_,
1116                                            height, quality, &enc->hash_chain_,
1117                                            &enc->refs_[0], &enc->cache_bits_)) {
1118       err = VP8_ENC_ERROR_OUT_OF_MEMORY;
1119       goto Error;
1120     }
1121   }
1122
1123   // ---------------------------------------------------------------------------
1124   // Encode and write the transformed image.
1125
1126   err = EncodeImageInternal(bw, enc->argb_, &enc->hash_chain_, enc->refs_,
1127                             enc->current_width_, height, quality,
1128                             enc->cache_bits_, enc->histo_bits_);
1129   if (err != VP8_ENC_OK) goto Error;
1130
1131   if (picture->stats != NULL) {
1132     WebPAuxStats* const stats = picture->stats;
1133     stats->lossless_features = 0;
1134     if (enc->use_predict_) stats->lossless_features |= 1;
1135     if (enc->use_cross_color_) stats->lossless_features |= 2;
1136     if (enc->use_subtract_green_) stats->lossless_features |= 4;
1137     if (enc->use_palette_) stats->lossless_features |= 8;
1138     stats->histogram_bits = enc->histo_bits_;
1139     stats->transform_bits = enc->transform_bits_;
1140     stats->cache_bits = enc->cache_bits_;
1141     stats->palette_size = enc->palette_size_;
1142     stats->lossless_size = (int)(VP8LBitWriterNumBytes(bw) - byte_position);
1143   }
1144
1145  Error:
1146   VP8LEncoderDelete(enc);
1147   return err;
1148 }
1149
1150 int VP8LEncodeImage(const WebPConfig* const config,
1151                     const WebPPicture* const picture) {
1152   int width, height;
1153   int has_alpha;
1154   size_t coded_size;
1155   int percent = 0;
1156   int initial_size;
1157   WebPEncodingError err = VP8_ENC_OK;
1158   VP8LBitWriter bw;
1159
1160   if (picture == NULL) return 0;
1161
1162   if (config == NULL || picture->argb == NULL) {
1163     err = VP8_ENC_ERROR_NULL_PARAMETER;
1164     WebPEncodingSetError(picture, err);
1165     return 0;
1166   }
1167
1168   width = picture->width;
1169   height = picture->height;
1170   // Initialize BitWriter with size corresponding to 16 bpp to photo images and
1171   // 8 bpp for graphical images.
1172   initial_size = (config->image_hint == WEBP_HINT_GRAPH) ?
1173                  width * height : width * height * 2;
1174   if (!VP8LBitWriterInit(&bw, initial_size)) {
1175     err = VP8_ENC_ERROR_OUT_OF_MEMORY;
1176     goto Error;
1177   }
1178
1179   if (!WebPReportProgress(picture, 1, &percent)) {
1180  UserAbort:
1181     err = VP8_ENC_ERROR_USER_ABORT;
1182     goto Error;
1183   }
1184   // Reset stats (for pure lossless coding)
1185   if (picture->stats != NULL) {
1186     WebPAuxStats* const stats = picture->stats;
1187     memset(stats, 0, sizeof(*stats));
1188     stats->PSNR[0] = 99.f;
1189     stats->PSNR[1] = 99.f;
1190     stats->PSNR[2] = 99.f;
1191     stats->PSNR[3] = 99.f;
1192     stats->PSNR[4] = 99.f;
1193   }
1194
1195   // Write image size.
1196   if (!WriteImageSize(picture, &bw)) {
1197     err = VP8_ENC_ERROR_OUT_OF_MEMORY;
1198     goto Error;
1199   }
1200
1201   has_alpha = WebPPictureHasTransparency(picture);
1202   // Write the non-trivial Alpha flag and lossless version.
1203   if (!WriteRealAlphaAndVersion(&bw, has_alpha)) {
1204     err = VP8_ENC_ERROR_OUT_OF_MEMORY;
1205     goto Error;
1206   }
1207
1208   if (!WebPReportProgress(picture, 5, &percent)) goto UserAbort;
1209
1210   // Encode main image stream.
1211   err = VP8LEncodeStream(config, picture, &bw);
1212   if (err != VP8_ENC_OK) goto Error;
1213
1214   // TODO(skal): have a fine-grained progress report in VP8LEncodeStream().
1215   if (!WebPReportProgress(picture, 90, &percent)) goto UserAbort;
1216
1217   // Finish the RIFF chunk.
1218   err = WriteImage(picture, &bw, &coded_size);
1219   if (err != VP8_ENC_OK) goto Error;
1220
1221   if (!WebPReportProgress(picture, 100, &percent)) goto UserAbort;
1222
1223   // Save size.
1224   if (picture->stats != NULL) {
1225     picture->stats->coded_size += (int)coded_size;
1226     picture->stats->lossless_size = (int)coded_size;
1227   }
1228
1229   if (picture->extra_info != NULL) {
1230     const int mb_w = (width + 15) >> 4;
1231     const int mb_h = (height + 15) >> 4;
1232     memset(picture->extra_info, 0, mb_w * mb_h * sizeof(*picture->extra_info));
1233   }
1234
1235  Error:
1236   if (bw.error_) err = VP8_ENC_ERROR_OUT_OF_MEMORY;
1237   VP8LBitWriterDestroy(&bw);
1238   if (err != VP8_ENC_OK) {
1239     WebPEncodingSetError(picture, err);
1240     return 0;
1241   }
1242   return 1;
1243 }
1244
1245 //------------------------------------------------------------------------------