// Copyright 2012 Google Inc. All Rights Reserved.

//

// Use of this source code is governed by a BSD-style license

// that can be found in the COPYING file in the root of the source

// tree. An additional intellectual property rights grant can be found

// in the file PATENTS. All contributing project authors may

// be found in the AUTHORS file in the root of the source tree.

// -----------------------------------------------------------------------------

//

// main entry for the lossless encoder.

//

// Author: Vikas Arora (vikaas.arora@gmail.com)

//

#include <assert.h>

#include <stdlib.h>

#include "src/enc/backward_references_enc.h"

#include "src/enc/histogram_enc.h"

#include "src/enc/vp8i_enc.h"

#include "src/enc/vp8li_enc.h"

#include "src/dsp/lossless.h"

#include "src/dsp/lossless_common.h"

#include "src/utils/bit_writer_utils.h"

#include "src/utils/huffman_encode_utils.h"

#include "src/utils/utils.h"

#include "src/webp/format_constants.h"

// Maximum number of histogram images (sub-blocks).

#define MAX_HUFF_IMAGE_SIZE       2600

// Palette reordering for smaller sum of deltas (and for smaller storage).

static int PaletteCompareColorsForQsort(const void* p1, const void* p2) {

  const uint32_t a = WebPMemToUint32((uint8_t*)p1);

  const uint32_t b = WebPMemToUint32((uint8_t*)p2);

  assert(a != b);

  return (a < b) ? -1 : 1;

}

static WEBP_INLINE uint32_t PaletteComponentDistance(uint32_t v) {

  return (v <= 128) ? v : (256 - v);

}

// Computes a value that is related to the entropy created by the

// palette entry diff.

//

// Note that the last & 0xff is a no-operation in the next statement, but

// removed by most compilers and is here only for regularity of the code.

static WEBP_INLINE uint32_t PaletteColorDistance(uint32_t col1, uint32_t col2) {

  const uint32_t diff = VP8LSubPixels(col1, col2);

  const int kMoreWeightForRGBThanForAlpha = 9;

  uint32_t score;

  score =  PaletteComponentDistance((diff >>  0) & 0xff);

  score += PaletteComponentDistance((diff >>  8) & 0xff);

  score += PaletteComponentDistance((diff >> 16) & 0xff);

  score *= kMoreWeightForRGBThanForAlpha;

  score += PaletteComponentDistance((diff >> 24) & 0xff);

  return score;

}

static WEBP_INLINE void SwapColor(uint32_t* const col1, uint32_t* const col2) {

  const uint32_t tmp = *col1;

  *col1 = *col2;

  *col2 = tmp;

}

static void GreedyMinimizeDeltas(uint32_t palette[], int num_colors) {

  // Find greedily always the closest color of the predicted color to minimize

  // deltas in the palette. This reduces storage needs since the

  // palette is stored with delta encoding.

  uint32_t predict = 0x00000000;

  int i, k;

  for (i = 0; i < num_colors; ++i) {

    int best_ix = i;

    uint32_t best_score = ~0U;

    for (k = i; k < num_colors; ++k) {

      const uint32_t cur_score = PaletteColorDistance(palette[k], predict);

      if (best_score > cur_score) {

        best_score = cur_score;

        best_ix = k;

      }

    }

    SwapColor(&palette[best_ix], &palette[i]);

    predict = palette[i];

  }

}

// The palette has been sorted by alpha. This function checks if the other

// components of the palette have a monotonic development with regards to

// position in the palette. If all have monotonic development, there is

// no benefit to re-organize them greedily. A monotonic development

// would be spotted in green-only situations (like lossy alpha) or gray-scale

// images.

static int PaletteHasNonMonotonousDeltas(uint32_t palette[], int num_colors) {

  uint32_t predict = 0x000000;

  int i;

  uint8_t sign_found = 0x00;

  for (i = 0; i < num_colors; ++i) {

    const uint32_t diff = VP8LSubPixels(palette[i], predict);

    const uint8_t rd = (diff >> 16) & 0xff;

    const uint8_t gd = (diff >>  8) & 0xff;

    const uint8_t bd = (diff >>  0) & 0xff;

    if (rd != 0x00) {

      sign_found |= (rd < 0x80) ? 1 : 2;

    }

    if (gd != 0x00) {

      sign_found |= (gd < 0x80) ? 8 : 16;

    }

    if (bd != 0x00) {

      sign_found |= (bd < 0x80) ? 64 : 128;

    }

    predict = palette[i];

  }

  return (sign_found & (sign_found << 1)) != 0;  // two consequent signs.

}

// -----------------------------------------------------------------------------

// Palette

// If number of colors in the image is less than or equal to MAX_PALETTE_SIZE,

// creates a palette and returns true, else returns false.

static int AnalyzeAndCreatePalette(const WebPPicture* const pic,

                                   int low_effort,

                                   uint32_t palette[MAX_PALETTE_SIZE],

                                   int* const palette_size) {

  const int num_colors = WebPGetColorPalette(pic, palette);

  if (num_colors > MAX_PALETTE_SIZE) {

    *palette_size = 0;

    return 0;

  }

  *palette_size = num_colors;

  qsort(palette, num_colors, sizeof(*palette), PaletteCompareColorsForQsort);

  if (!low_effort && PaletteHasNonMonotonousDeltas(palette, num_colors)) {

    GreedyMinimizeDeltas(palette, num_colors);

  }

  return 1;

}

// These five modes are evaluated and their respective entropy is computed.

typedef enum {

  kDirect = 0,

  kSpatial = 1,

  kSubGreen = 2,

  kSpatialSubGreen = 3,

  kPalette = 4,

  kNumEntropyIx = 5

} EntropyIx;

typedef enum {

  kHistoAlpha = 0,

  kHistoAlphaPred,

  kHistoGreen,

  kHistoGreenPred,

  kHistoRed,

  kHistoRedPred,

  kHistoBlue,

  kHistoBluePred,

  kHistoRedSubGreen,

  kHistoRedPredSubGreen,

  kHistoBlueSubGreen,

  kHistoBluePredSubGreen,

  kHistoPalette,

  kHistoTotal  // Must be last.

} HistoIx;

static void AddSingleSubGreen(int p, uint32_t* const r, uint32_t* const b) {

  const int green = p >> 8;  // The upper bits are masked away later.

  ++r[((p >> 16) - green) & 0xff];

  ++b[((p >>  0) - green) & 0xff];

}

static void AddSingle(uint32_t p,

                      uint32_t* const a, uint32_t* const r,

                      uint32_t* const g, uint32_t* const b) {

  ++a[(p >> 24) & 0xff];

  ++r[(p >> 16) & 0xff];

  ++g[(p >>  8) & 0xff];

  ++b[(p >>  0) & 0xff];

}

static WEBP_INLINE uint32_t HashPix(uint32_t pix) {

  // Note that masking with 0xffffffffu is for preventing an

  // 'unsigned int overflow' warning. Doesn't impact the compiled code.

  return ((((uint64_t)pix + (pix >> 19)) * 0x39c5fba7ull) & 0xffffffffu) >> 24;

}

static int AnalyzeEntropy(const uint32_t* argb,

                          int width, int height, int argb_stride,

                          int use_palette,

                          int palette_size, int transform_bits,

                          EntropyIx* const min_entropy_ix,

                          int* const red_and_blue_always_zero) {

  // Allocate histogram set with cache_bits = 0.

  uint32_t* histo;

  if (use_palette && palette_size <= 16) {

    // In the case of small palettes, we pack 2, 4 or 8 pixels together. In

    // practice, small palettes are better than any other transform.

    *min_entropy_ix = kPalette;

    *red_and_blue_always_zero = 1;

    return 1;

  }

  histo = (uint32_t*)WebPSafeCalloc(kHistoTotal, sizeof(*histo) * 256);

  if (histo != NULL) {

    int i, x, y;

    const uint32_t* prev_row = NULL;

    const uint32_t* curr_row = argb;

    uint32_t pix_prev = argb[0];  // Skip the first pixel.

    for (y = 0; y < height; ++y) {

      for (x = 0; x < width; ++x) {

        const uint32_t pix = curr_row[x];

        const uint32_t pix_diff = VP8LSubPixels(pix, pix_prev);

        pix_prev = pix;

        if ((pix_diff == 0) || (prev_row != NULL && pix == prev_row[x])) {

          continue;

        }

        AddSingle(pix,

                  &histo[kHistoAlpha * 256],

                  &histo[kHistoRed * 256],

                  &histo[kHistoGreen * 256],

                  &histo[kHistoBlue * 256]);

        AddSingle(pix_diff,

                  &histo[kHistoAlphaPred * 256],

                  &histo[kHistoRedPred * 256],

                  &histo[kHistoGreenPred * 256],

                  &histo[kHistoBluePred * 256]);

        AddSingleSubGreen(pix,

                          &histo[kHistoRedSubGreen * 256],

                          &histo[kHistoBlueSubGreen * 256]);

        AddSingleSubGreen(pix_diff,

                          &histo[kHistoRedPredSubGreen * 256],

                          &histo[kHistoBluePredSubGreen * 256]);

        {

          // Approximate the palette by the entropy of the multiplicative hash.

          const uint32_t hash = HashPix(pix);

          ++histo[kHistoPalette * 256 + hash];

        }

      }

      prev_row = curr_row;

      curr_row += argb_stride;

    }

    {

      double entropy_comp[kHistoTotal];

      double entropy[kNumEntropyIx];

      int k;

      int last_mode_to_analyze = use_palette ? kPalette : kSpatialSubGreen;

      int j;

      // Let's add one zero to the predicted histograms. The zeros are removed

      // too efficiently by the pix_diff == 0 comparison, at least one of the

      // zeros is likely to exist.

      ++histo[kHistoRedPredSubGreen * 256];

      ++histo[kHistoBluePredSubGreen * 256];

      ++histo[kHistoRedPred * 256];

      ++histo[kHistoGreenPred * 256];

      ++histo[kHistoBluePred * 256];

      ++histo[kHistoAlphaPred * 256];

      for (j = 0; j < kHistoTotal; ++j) {

        entropy_comp[j] = VP8LBitsEntropy(&histo[j * 256], 256);

      }

      entropy[kDirect] = entropy_comp[kHistoAlpha] +

          entropy_comp[kHistoRed] +

          entropy_comp[kHistoGreen] +

          entropy_comp[kHistoBlue];

      entropy[kSpatial] = entropy_comp[kHistoAlphaPred] +

          entropy_comp[kHistoRedPred] +

          entropy_comp[kHistoGreenPred] +

          entropy_comp[kHistoBluePred];

      entropy[kSubGreen] = entropy_comp[kHistoAlpha] +

          entropy_comp[kHistoRedSubGreen] +

          entropy_comp[kHistoGreen] +

          entropy_comp[kHistoBlueSubGreen];

      entropy[kSpatialSubGreen] = entropy_comp[kHistoAlphaPred] +

          entropy_comp[kHistoRedPredSubGreen] +

          entropy_comp[kHistoGreenPred] +

          entropy_comp[kHistoBluePredSubGreen];

      entropy[kPalette] = entropy_comp[kHistoPalette];

      // When including transforms, there is an overhead in bits from

      // storing them. This overhead is small but matters for small images.

      // For spatial, there are 14 transformations.

      entropy[kSpatial] += VP8LSubSampleSize(width, transform_bits) *

                           VP8LSubSampleSize(height, transform_bits) *

                           VP8LFastLog2(14);

      // For color transforms: 24 as only 3 channels are considered in a

      // ColorTransformElement.

      entropy[kSpatialSubGreen] += VP8LSubSampleSize(width, transform_bits) *

                                   VP8LSubSampleSize(height, transform_bits) *

                                   VP8LFastLog2(24);

      // For palettes, add the cost of storing the palette.

      // We empirically estimate the cost of a compressed entry as 8 bits.

      // The palette is differential-coded when compressed hence a much

      // lower cost than sizeof(uint32_t)*8.

      entropy[kPalette] += palette_size * 8;

      *min_entropy_ix = kDirect;

      for (k = kDirect + 1; k <= last_mode_to_analyze; ++k) {

        if (entropy[*min_entropy_ix] > entropy[k]) {

          *min_entropy_ix = (EntropyIx)k;

        }

      }

      assert((int)*min_entropy_ix <= last_mode_to_analyze);

      *red_and_blue_always_zero = 1;

      // Let's check if the histogram of the chosen entropy mode has

      // non-zero red and blue values. If all are zero, we can later skip

      // the cross color optimization.

      {

        static const uint8_t kHistoPairs[5][2] = {

          { kHistoRed, kHistoBlue },

          { kHistoRedPred, kHistoBluePred },

          { kHistoRedSubGreen, kHistoBlueSubGreen },

          { kHistoRedPredSubGreen, kHistoBluePredSubGreen },

          { kHistoRed, kHistoBlue }

        };

        const uint32_t* const red_histo =

            &histo[256 * kHistoPairs[*min_entropy_ix][0]];

        const uint32_t* const blue_histo =

            &histo[256 * kHistoPairs[*min_entropy_ix][1]];

        for (i = 1; i < 256; ++i) {

          if ((red_histo[i] | blue_histo[i]) != 0) {

            *red_and_blue_always_zero = 0;

            break;

          }

        }

      }

    }

    WebPSafeFree(histo);

    return 1;

  } else {

    return 0;

  }

}

static int GetHistoBits(int method, int use_palette, int width, int height) {

  // Make tile size a function of encoding method (Range: 0 to 6).

  int histo_bits = (use_palette ? 9 : 7) - method;

  while (1) {

    const int huff_image_size = VP8LSubSampleSize(width, histo_bits) *

                                VP8LSubSampleSize(height, histo_bits);

    if (huff_image_size <= MAX_HUFF_IMAGE_SIZE) break;

    ++histo_bits;

  }

  return (histo_bits < MIN_HUFFMAN_BITS) ? MIN_HUFFMAN_BITS :

         (histo_bits > MAX_HUFFMAN_BITS) ? MAX_HUFFMAN_BITS : histo_bits;

}

static int GetTransformBits(int method, int histo_bits) {

  const int max_transform_bits = (method < 4) ? 6 : (method > 4) ? 4 : 5;

  const int res =

      (histo_bits > max_transform_bits) ? max_transform_bits : histo_bits;

  assert(res <= MAX_TRANSFORM_BITS);

  return res;

}

// Set of parameters to be used in each iteration of the cruncher.

#define CRUNCH_CONFIGS_LZ77_MAX 2

typedef struct {

  int entropy_idx_;

  int lz77s_types_to_try_[CRUNCH_CONFIGS_LZ77_MAX];

  int lz77s_types_to_try_size_;

} CrunchConfig;

#define CRUNCH_CONFIGS_MAX kNumEntropyIx

static int EncoderAnalyze(VP8LEncoder* const enc,

                          CrunchConfig crunch_configs[CRUNCH_CONFIGS_MAX],

                          int* const crunch_configs_size,

                          int* const red_and_blue_always_zero) {

  const WebPPicture* const pic = enc->pic_;

  const int width = pic->width;

  const int height = pic->height;

  const WebPConfig* const config = enc->config_;

  const int method = config->method;

  const int low_effort = (config->method == 0);

  int i;

  int use_palette;

  int n_lz77s;

  assert(pic != NULL && pic->argb != NULL);

  use_palette =

      AnalyzeAndCreatePalette(pic, low_effort,

                              enc->palette_, &enc->palette_size_);

  // Empirical bit sizes.

  enc->histo_bits_ = GetHistoBits(method, use_palette,

                                  pic->width, pic->height);

  enc->transform_bits_ = GetTransformBits(method, enc->histo_bits_);

  if (low_effort) {

    // AnalyzeEntropy is somewhat slow.

    crunch_configs[0].entropy_idx_ = use_palette ? kPalette : kSpatialSubGreen;

    n_lz77s = 1;

    *crunch_configs_size = 1;

  } else {

    EntropyIx min_entropy_ix;

    // Try out multiple LZ77 on images with few colors.

    n_lz77s = (enc->palette_size_ > 0 && enc->palette_size_ <= 16) ? 2 : 1;

    if (!AnalyzeEntropy(pic->argb, width, height, pic->argb_stride, use_palette,

                        enc->palette_size_, enc->transform_bits_,

                        &min_entropy_ix, red_and_blue_always_zero)) {

      return 0;

    }

    if (method == 6 && config->quality == 100) {

      // Go brute force on all transforms.

      *crunch_configs_size = 0;

      for (i = 0; i < kNumEntropyIx; ++i) {

        if (i != kPalette || use_palette) {

          assert(*crunch_configs_size < CRUNCH_CONFIGS_MAX);

          crunch_configs[(*crunch_configs_size)++].entropy_idx_ = i;

        }

      }

    } else {

      // Only choose the guessed best transform.

      *crunch_configs_size = 1;

      crunch_configs[0].entropy_idx_ = min_entropy_ix;

    }

  }

  // Fill in the different LZ77s.

  assert(n_lz77s <= CRUNCH_CONFIGS_LZ77_MAX);

  for (i = 0; i < *crunch_configs_size; ++i) {

    int j;

    for (j = 0; j < n_lz77s; ++j) {

      crunch_configs[i].lz77s_types_to_try_[j] =

          (j == 0) ? kLZ77Standard | kLZ77RLE : kLZ77Box;

    }

    crunch_configs[i].lz77s_types_to_try_size_ = n_lz77s;

  }

  return 1;

}

static int EncoderInit(VP8LEncoder* const enc) {

  const WebPPicture* const pic = enc->pic_;

  const int width = pic->width;

  const int height = pic->height;

  const int pix_cnt = width * height;

  // we round the block size up, so we're guaranteed to have

  // at most MAX_REFS_BLOCK_PER_IMAGE blocks used:

  const int refs_block_size = (pix_cnt - 1) / MAX_REFS_BLOCK_PER_IMAGE + 1;

  int i;

  if (!VP8LHashChainInit(&enc->hash_chain_, pix_cnt)) return 0;

  for (i = 0; i < 3; ++i) VP8LBackwardRefsInit(&enc->refs_[i], refs_block_size);

  return 1;

}

// Returns false in case of memory error.

static int GetHuffBitLengthsAndCodes(

    const VP8LHistogramSet* const histogram_image,

    HuffmanTreeCode* const huffman_codes) {

  int i, k;

  int ok = 0;

  uint64_t total_length_size = 0;

  uint8_t* mem_buf = NULL;

  const int histogram_image_size = histogram_image->size;

  int max_num_symbols = 0;

  uint8_t* buf_rle = NULL;

  HuffmanTree* huff_tree = NULL;

  // Iterate over all histograms and get the aggregate number of codes used.

  for (i = 0; i < histogram_image_size; ++i) {

    const VP8LHistogram* const histo = histogram_image->histograms[i];

    HuffmanTreeCode* const codes = &huffman_codes[5 * i];

    for (k = 0; k < 5; ++k) {

      const int num_symbols =

          (k == 0) ? VP8LHistogramNumCodes(histo->palette_code_bits_) :

          (k == 4) ? NUM_DISTANCE_CODES : 256;

      codes[k].num_symbols = num_symbols;

      total_length_size += num_symbols;

    }

  }

  // Allocate and Set Huffman codes.

  {

    uint16_t* codes;

    uint8_t* lengths;

    mem_buf = (uint8_t*)WebPSafeCalloc(total_length_size,

                                       sizeof(*lengths) + sizeof(*codes));

    if (mem_buf == NULL) goto End;

    codes = (uint16_t*)mem_buf;

    lengths = (uint8_t*)&codes[total_length_size];

    for (i = 0; i < 5 * histogram_image_size; ++i) {

      const int bit_length = huffman_codes[i].num_symbols;

      huffman_codes[i].codes = codes;

      huffman_codes[i].code_lengths = lengths;

      codes += bit_length;

      lengths += bit_length;

      if (max_num_symbols < bit_length) {

        max_num_symbols = bit_length;

      }

    }

  }

  buf_rle = (uint8_t*)WebPSafeMalloc(1ULL, max_num_symbols);

  huff_tree = (HuffmanTree*)WebPSafeMalloc(3ULL * max_num_symbols,

                                           sizeof(*huff_tree));

  if (buf_rle == NULL || huff_tree == NULL) goto End;

  // Create Huffman trees.

  for (i = 0; i < histogram_image_size; ++i) {

    HuffmanTreeCode* const codes = &huffman_codes[5 * i];

    VP8LHistogram* const histo = histogram_image->histograms[i];

    VP8LCreateHuffmanTree(histo->literal_, 15, buf_rle, huff_tree, codes + 0);

    VP8LCreateHuffmanTree(histo->red_, 15, buf_rle, huff_tree, codes + 1);

    VP8LCreateHuffmanTree(histo->blue_, 15, buf_rle, huff_tree, codes + 2);

    VP8LCreateHuffmanTree(histo->alpha_, 15, buf_rle, huff_tree, codes + 3);

    VP8LCreateHuffmanTree(histo->distance_, 15, buf_rle, huff_tree, codes + 4);

  }

  ok = 1;

 End:

  WebPSafeFree(huff_tree);

  WebPSafeFree(buf_rle);

  if (!ok) {

    WebPSafeFree(mem_buf);

    memset(huffman_codes, 0, 5 * histogram_image_size * sizeof(*huffman_codes));

  }

  return ok;

}

static void StoreHuffmanTreeOfHuffmanTreeToBitMask(

    VP8LBitWriter* const bw, const uint8_t* code_length_bitdepth) {

  // RFC 1951 will calm you down if you are worried about this funny sequence.

  // This sequence is tuned from that, but more weighted for lower symbol count,

  // and more spiking histograms.

  static const uint8_t kStorageOrder[CODE_LENGTH_CODES] = {

    17, 18, 0, 1, 2, 3, 4, 5, 16, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15

  };

  int i;

  // Throw away trailing zeros:

  int codes_to_store = CODE_LENGTH_CODES;

  for (; codes_to_store > 4; --codes_to_store) {

    if (code_length_bitdepth[kStorageOrder[codes_to_store - 1]] != 0) {

      break;

    }

  }

  VP8LPutBits(bw, codes_to_store - 4, 4);

  for (i = 0; i < codes_to_store; ++i) {

    VP8LPutBits(bw, code_length_bitdepth[kStorageOrder[i]], 3);

  }

}

static void ClearHuffmanTreeIfOnlyOneSymbol(

    HuffmanTreeCode* const huffman_code) {

  int k;

  int count = 0;

  for (k = 0; k < huffman_code->num_symbols; ++k) {

    if (huffman_code->code_lengths[k] != 0) {

      ++count;

      if (count > 1) return;

    }

  }

  for (k = 0; k < huffman_code->num_symbols; ++k) {

    huffman_code->code_lengths[k] = 0;

    huffman_code->codes[k] = 0;

  }

}

static void StoreHuffmanTreeToBitMask(

    VP8LBitWriter* const bw,

    const HuffmanTreeToken* const tokens, const int num_tokens,

    const HuffmanTreeCode* const huffman_code) {

  int i;

  for (i = 0; i < num_tokens; ++i) {

    const int ix = tokens[i].code;

    const int extra_bits = tokens[i].extra_bits;

    VP8LPutBits(bw, huffman_code->codes[ix], huffman_code->code_lengths[ix]);

    switch (ix) {

      case 16:

        VP8LPutBits(bw, extra_bits, 2);

        break;

      case 17:

        VP8LPutBits(bw, extra_bits, 3);

        break;

      case 18:

        VP8LPutBits(bw, extra_bits, 7);

        break;

    }

  }

}

// 'huff_tree' and 'tokens' are pre-alloacted buffers.

static void StoreFullHuffmanCode(VP8LBitWriter* const bw,

                                 HuffmanTree* const huff_tree,

                                 HuffmanTreeToken* const tokens,

                                 const HuffmanTreeCode* const tree) {

  uint8_t code_length_bitdepth[CODE_LENGTH_CODES] = { 0 };

  uint16_t code_length_bitdepth_symbols[CODE_LENGTH_CODES] = { 0 };

  const int max_tokens = tree->num_symbols;

  int num_tokens;

  HuffmanTreeCode huffman_code;

  huffman_code.num_symbols = CODE_LENGTH_CODES;

  huffman_code.code_lengths = code_length_bitdepth;

  huffman_code.codes = code_length_bitdepth_symbols;

  VP8LPutBits(bw, 0, 1);

  num_tokens = VP8LCreateCompressedHuffmanTree(tree, tokens, max_tokens);

  {

    uint32_t histogram[CODE_LENGTH_CODES] = { 0 };

    uint8_t buf_rle[CODE_LENGTH_CODES] = { 0 };

    int i;

    for (i = 0; i < num_tokens; ++i) {

      ++histogram[tokens[i].code];

    }

    VP8LCreateHuffmanTree(histogram, 7, buf_rle, huff_tree, &huffman_code);

  }

  StoreHuffmanTreeOfHuffmanTreeToBitMask(bw, code_length_bitdepth);

  ClearHuffmanTreeIfOnlyOneSymbol(&huffman_code);

  {

    int trailing_zero_bits = 0;

    int trimmed_length = num_tokens;

    int write_trimmed_length;

    int length;

    int i = num_tokens;

    while (i-- > 0) {

      const int ix = tokens[i].code;

      if (ix == 0 || ix == 17 || ix == 18) {

        --trimmed_length;   // discount trailing zeros

        trailing_zero_bits += code_length_bitdepth[ix];

        if (ix == 17) {

          trailing_zero_bits += 3;

        } else if (ix == 18) {

          trailing_zero_bits += 7;

        }

      } else {

        break;

      }

    }

    write_trimmed_length = (trimmed_length > 1 && trailing_zero_bits > 12);

    length = write_trimmed_length ? trimmed_length : num_tokens;

    VP8LPutBits(bw, write_trimmed_length, 1);

    if (write_trimmed_length) {

      if (trimmed_length == 2) {

        VP8LPutBits(bw, 0, 3 + 2);     // nbitpairs=1, trimmed_length=2

      } else {

        const int nbits = BitsLog2Floor(trimmed_length - 2);

        const int nbitpairs = nbits / 2 + 1;

        assert(trimmed_length > 2);

        assert(nbitpairs - 1 < 8);

        VP8LPutBits(bw, nbitpairs - 1, 3);

        VP8LPutBits(bw, trimmed_length - 2, nbitpairs * 2);

      }

    }

    StoreHuffmanTreeToBitMask(bw, tokens, length, &huffman_code);

  }

}

// 'huff_tree' and 'tokens' are pre-alloacted buffers.

static void StoreHuffmanCode(VP8LBitWriter* const bw,

                             HuffmanTree* const huff_tree,

                             HuffmanTreeToken* const tokens,

                             const HuffmanTreeCode* const huffman_code) {

  int i;

  int count = 0;

  int symbols[2] = { 0, 0 };

  const int kMaxBits = 8;

  const int kMaxSymbol = 1 << kMaxBits;

  // Check whether it's a small tree.

  for (i = 0; i < huffman_code->num_symbols && count < 3; ++i) {

    if (huffman_code->code_lengths[i] != 0) {

      if (count < 2) symbols[count] = i;

      ++count;

    }

  }

  if (count == 0) {   // emit minimal tree for empty cases

    // bits: small tree marker: 1, count-1: 0, large 8-bit code: 0, code: 0

    VP8LPutBits(bw, 0x01, 4);

  } else if (count <= 2 && symbols[0] < kMaxSymbol && symbols[1] < kMaxSymbol) {

    VP8LPutBits(bw, 1, 1);  // Small tree marker to encode 1 or 2 symbols.

    VP8LPutBits(bw, count - 1, 1);

    if (symbols[0] <= 1) {

      VP8LPutBits(bw, 0, 1);  // Code bit for small (1 bit) symbol value.

      VP8LPutBits(bw, symbols[0], 1);

    } else {

      VP8LPutBits(bw, 1, 1);

      VP8LPutBits(bw, symbols[0], 8);

    }

    if (count == 2) {

      VP8LPutBits(bw, symbols[1], 8);

    }

  } else {

    StoreFullHuffmanCode(bw, huff_tree, tokens, huffman_code);

  }

}

static WEBP_INLINE void WriteHuffmanCode(VP8LBitWriter* const bw,

                             const HuffmanTreeCode* const code,

                             int code_index) {

  const int depth = code->code_lengths[code_index];

  const int symbol = code->codes[code_index];

  VP8LPutBits(bw, symbol, depth);

}

static WEBP_INLINE void WriteHuffmanCodeWithExtraBits(

    VP8LBitWriter* const bw,

    const HuffmanTreeCode* const code,

    int code_index,

    int bits,

    int n_bits) {

  const int depth = code->code_lengths[code_index];

  const int symbol = code->codes[code_index];

  VP8LPutBits(bw, (bits << depth) | symbol, depth + n_bits);

}

static WebPEncodingError StoreImageToBitMask(

    VP8LBitWriter* const bw, int width, int histo_bits,

    const VP8LBackwardRefs* const refs,

    const uint16_t* histogram_symbols,

    const HuffmanTreeCode* const huffman_codes) {

  const int histo_xsize = histo_bits ? VP8LSubSampleSize(width, histo_bits) : 1;

  const int tile_mask = (histo_bits == 0) ? 0 : -(1 << histo_bits);

  // x and y trace the position in the image.

  int x = 0;

  int y = 0;

  int tile_x = x & tile_mask;

  int tile_y = y & tile_mask;

  int histogram_ix = histogram_symbols[0];

  const HuffmanTreeCode* codes = huffman_codes + 5 * histogram_ix;

  VP8LRefsCursor c = VP8LRefsCursorInit(refs);

  while (VP8LRefsCursorOk(&c)) {

    const PixOrCopy* const v = c.cur_pos;

    if ((tile_x != (x & tile_mask)) || (tile_y != (y & tile_mask))) {

      tile_x = x & tile_mask;

      tile_y = y & tile_mask;

      histogram_ix = histogram_symbols[(y >> histo_bits) * histo_xsize +

                                       (x >> histo_bits)];

      codes = huffman_codes + 5 * histogram_ix;

    }

    if (PixOrCopyIsLiteral(v)) {

      static const uint8_t order[] = { 1, 2, 0, 3 };

      int k;

      for (k = 0; k < 4; ++k) {

        const int code = PixOrCopyLiteral(v, order[k]);

        WriteHuffmanCode(bw, codes + k, code);

      }

    } else if (PixOrCopyIsCacheIdx(v)) {

      const int code = PixOrCopyCacheIdx(v);

      const int literal_ix = 256 + NUM_LENGTH_CODES + code;

      WriteHuffmanCode(bw, codes, literal_ix);

    } else {

      int bits, n_bits;

      int code;

      const int distance = PixOrCopyDistance(v);

      VP8LPrefixEncode(v->len, &code, &n_bits, &bits);

      WriteHuffmanCodeWithExtraBits(bw, codes, 256 + code, bits, n_bits);

      // Don't write the distance with the extra bits code since

      // the distance can be up to 18 bits of extra bits, and the prefix

      // 15 bits, totaling to 33, and our PutBits only supports up to 32 bits.

      VP8LPrefixEncode(distance, &code, &n_bits, &bits);

      WriteHuffmanCode(bw, codes + 4, code);

      VP8LPutBits(bw, bits, n_bits);

    }

    x += PixOrCopyLength(v);

    while (x >= width) {

      x -= width;

      ++y;

    }

    VP8LRefsCursorNext(&c);

  }

  return bw->error_ ? VP8_ENC_ERROR_OUT_OF_MEMORY : VP8_ENC_OK;

}

// Special case of EncodeImageInternal() for cache-bits=0, histo_bits=31

static WebPEncodingError EncodeImageNoHuffman(VP8LBitWriter* const bw,

                                              const uint32_t* const argb,

                                              VP8LHashChain* const hash_chain,

                                              VP8LBackwardRefs* const refs_tmp1,

                                              VP8LBackwardRefs* const refs_tmp2,

                                              int width, int height,

                                              int quality, int low_effort) {

  int i;

  int max_tokens = 0;

  WebPEncodingError err = VP8_ENC_OK;

  VP8LBackwardRefs* refs;

  HuffmanTreeToken* tokens = NULL;

  HuffmanTreeCode huffman_codes[5] = { { 0, NULL, NULL } };

  const uint16_t histogram_symbols[1] = { 0 };    // only one tree, one symbol

  int cache_bits = 0;

  VP8LHistogramSet* histogram_image = NULL;

  HuffmanTree* const huff_tree = (HuffmanTree*)WebPSafeMalloc(

        3ULL * CODE_LENGTH_CODES, sizeof(*huff_tree));

  if (huff_tree == NULL) {

    err = VP8_ENC_ERROR_OUT_OF_MEMORY;

    goto Error;

  }

  // Calculate backward references from ARGB image.

  if (!VP8LHashChainFill(hash_chain, quality, argb, width, height,

                         low_effort)) {

    err = VP8_ENC_ERROR_OUT_OF_MEMORY;

    goto Error;

  }

  refs = VP8LGetBackwardReferences(width, height, argb, quality, 0,

                                   kLZ77Standard | kLZ77RLE, &cache_bits,

                                   hash_chain, refs_tmp1, refs_tmp2);

  if (refs == NULL) {

    err = VP8_ENC_ERROR_OUT_OF_MEMORY;

    goto Error;

  }

  histogram_image = VP8LAllocateHistogramSet(1, cache_bits);

  if (histogram_image == NULL) {

    err = VP8_ENC_ERROR_OUT_OF_MEMORY;

    goto Error;

  }

  // Build histogram image and symbols from backward references.

  VP8LHistogramStoreRefs(refs, histogram_image->histograms[0]);

  // Create Huffman bit lengths and codes for each histogram image.

  assert(histogram_image->size == 1);

  if (!GetHuffBitLengthsAndCodes(histogram_image, huffman_codes)) {

    err = VP8_ENC_ERROR_OUT_OF_MEMORY;

    goto Error;

  }

  // No color cache, no Huffman image.

  VP8LPutBits(bw, 0, 1);

  // Find maximum number of symbols for the huffman tree-set.

  for (i = 0; i < 5; ++i) {

    HuffmanTreeCode* const codes = &huffman_codes[i];

    if (max_tokens < codes->num_symbols) {

      max_tokens = codes->num_symbols;

    }

  }

  tokens = (HuffmanTreeToken*)WebPSafeMalloc(max_tokens, sizeof(*tokens));

  if (tokens == NULL) {

    err = VP8_ENC_ERROR_OUT_OF_MEMORY;

    goto Error;

  }

  // Store Huffman codes.

  for (i = 0; i < 5; ++i) {

    HuffmanTreeCode* const codes = &huffman_codes[i];

    StoreHuffmanCode(bw, huff_tree, tokens, codes);

    ClearHuffmanTreeIfOnlyOneSymbol(codes);

  }

  // Store actual literals.

  err = StoreImageToBitMask(bw, width, 0, refs, histogram_symbols,

                            huffman_codes);

 Error:

  WebPSafeFree(tokens);

  WebPSafeFree(huff_tree);

  VP8LFreeHistogramSet(histogram_image);

  WebPSafeFree(huffman_codes[0].codes);

  return err;

}

static WebPEncodingError EncodeImageInternal(

    VP8LBitWriter* const bw, const uint32_t* const argb,

    VP8LHashChain* const hash_chain, VP8LBackwardRefs refs_array[3], int width,

    int height, int quality, int low_effort, int use_cache,

    const CrunchConfig* const config, int* cache_bits, int histogram_bits,

    size_t init_byte_position, int* const hdr_size, int* const data_size) {

  WebPEncodingError err = VP8_ENC_OK;

  const uint32_t histogram_image_xysize =

      VP8LSubSampleSize(width, histogram_bits) *

      VP8LSubSampleSize(height, histogram_bits);

  VP8LHistogramSet* histogram_image = NULL;

  VP8LHistogram* tmp_histo = NULL;

  int histogram_image_size = 0;

  size_t bit_array_size = 0;

  HuffmanTree* const huff_tree = (HuffmanTree*)WebPSafeMalloc(

      3ULL * CODE_LENGTH_CODES, sizeof(*huff_tree));

  HuffmanTreeToken* tokens = NULL;

  HuffmanTreeCode* huffman_codes = NULL;

  VP8LBackwardRefs* refs_best;

  VP8LBackwardRefs* refs_tmp;

  uint16_t* const histogram_symbols =

      (uint16_t*)WebPSafeMalloc(histogram_image_xysize,