// Copyright 2016 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. // ----------------------------------------------------------------------------- // // Image transform methods for lossless encoder. // // Authors: Vikas Arora ([email protected]) // Jyrki Alakuijala ([email protected]) // Urvang Joshi ([email protected]) // Vincent Rabaud ([email protected]) #include "src/dsp/lossless.h" #include "src/dsp/lossless_common.h" #include "src/enc/vp8i_enc.h" #include "src/enc/vp8li_enc.h" #define MAX_DIFF_COST … static const float kSpatialPredictorBias = …; static const int kPredLowEffort = …; static const uint32_t kMaskAlpha = …; // Mostly used to reduce code size + readability static WEBP_INLINE int GetMin(int a, int b) { … } //------------------------------------------------------------------------------ // Methods to calculate Entropy (Shannon). static float PredictionCostSpatial(const int counts[256], int weight_0, float exp_val) { … } static float PredictionCostSpatialHistogram(const int accumulated[4][256], const int tile[4][256]) { … } static WEBP_INLINE void UpdateHisto(int histo_argb[4][256], uint32_t argb) { … } //------------------------------------------------------------------------------ // Spatial transform functions. static WEBP_INLINE void PredictBatch(int mode, int x_start, int y, int num_pixels, const uint32_t* current, const uint32_t* upper, uint32_t* out) { … } #if (WEBP_NEAR_LOSSLESS == 1) static WEBP_INLINE int GetMax(int a, int b) { return (a < b) ? b : a; } static int MaxDiffBetweenPixels(uint32_t p1, uint32_t p2) { const int diff_a = abs((int)(p1 >> 24) - (int)(p2 >> 24)); const int diff_r = abs((int)((p1 >> 16) & 0xff) - (int)((p2 >> 16) & 0xff)); const int diff_g = abs((int)((p1 >> 8) & 0xff) - (int)((p2 >> 8) & 0xff)); const int diff_b = abs((int)(p1 & 0xff) - (int)(p2 & 0xff)); return GetMax(GetMax(diff_a, diff_r), GetMax(diff_g, diff_b)); } static int MaxDiffAroundPixel(uint32_t current, uint32_t up, uint32_t down, uint32_t left, uint32_t right) { const int diff_up = MaxDiffBetweenPixels(current, up); const int diff_down = MaxDiffBetweenPixels(current, down); const int diff_left = MaxDiffBetweenPixels(current, left); const int diff_right = MaxDiffBetweenPixels(current, right); return GetMax(GetMax(diff_up, diff_down), GetMax(diff_left, diff_right)); } static uint32_t AddGreenToBlueAndRed(uint32_t argb) { const uint32_t green = (argb >> 8) & 0xff; uint32_t red_blue = argb & 0x00ff00ffu; red_blue += (green << 16) | green; red_blue &= 0x00ff00ffu; return (argb & 0xff00ff00u) | red_blue; } static void MaxDiffsForRow(int width, int stride, const uint32_t* const argb, uint8_t* const max_diffs, int used_subtract_green) { uint32_t current, up, down, left, right; int x; if (width <= 2) return; current = argb[0]; right = argb[1]; if (used_subtract_green) { current = AddGreenToBlueAndRed(current); right = AddGreenToBlueAndRed(right); } // max_diffs[0] and max_diffs[width - 1] are never used. for (x = 1; x < width - 1; ++x) { up = argb[-stride + x]; down = argb[stride + x]; left = current; current = right; right = argb[x + 1]; if (used_subtract_green) { up = AddGreenToBlueAndRed(up); down = AddGreenToBlueAndRed(down); right = AddGreenToBlueAndRed(right); } max_diffs[x] = MaxDiffAroundPixel(current, up, down, left, right); } } // Quantize the difference between the actual component value and its prediction // to a multiple of quantization, working modulo 256, taking care not to cross // a boundary (inclusive upper limit). static uint8_t NearLosslessComponent(uint8_t value, uint8_t predict, uint8_t boundary, int quantization) { const int residual = (value - predict) & 0xff; const int boundary_residual = (boundary - predict) & 0xff; const int lower = residual & ~(quantization - 1); const int upper = lower + quantization; // Resolve ties towards a value closer to the prediction (i.e. towards lower // if value comes after prediction and towards upper otherwise). const int bias = ((boundary - value) & 0xff) < boundary_residual; if (residual - lower < upper - residual + bias) { // lower is closer to residual than upper. if (residual > boundary_residual && lower <= boundary_residual) { // Halve quantization step to avoid crossing boundary. This midpoint is // on the same side of boundary as residual because midpoint >= residual // (since lower is closer than upper) and residual is above the boundary. return lower + (quantization >> 1); } return lower; } else { // upper is closer to residual than lower. if (residual <= boundary_residual && upper > boundary_residual) { // Halve quantization step to avoid crossing boundary. This midpoint is // on the same side of boundary as residual because midpoint <= residual // (since upper is closer than lower) and residual is below the boundary. return lower + (quantization >> 1); } return upper & 0xff; } } static WEBP_INLINE uint8_t NearLosslessDiff(uint8_t a, uint8_t b) { return (uint8_t)((((int)(a) - (int)(b))) & 0xff); } // Quantize every component of the difference between the actual pixel value and // its prediction to a multiple of a quantization (a power of 2, not larger than // max_quantization which is a power of 2, smaller than max_diff). Take care if // value and predict have undergone subtract green, which means that red and // blue are represented as offsets from green. static uint32_t NearLossless(uint32_t value, uint32_t predict, int max_quantization, int max_diff, int used_subtract_green) { int quantization; uint8_t new_green = 0; uint8_t green_diff = 0; uint8_t a, r, g, b; if (max_diff <= 2) { return VP8LSubPixels(value, predict); } quantization = max_quantization; while (quantization >= max_diff) { quantization >>= 1; } if ((value >> 24) == 0 || (value >> 24) == 0xff) { // Preserve transparency of fully transparent or fully opaque pixels. a = NearLosslessDiff((value >> 24) & 0xff, (predict >> 24) & 0xff); } else { a = NearLosslessComponent(value >> 24, predict >> 24, 0xff, quantization); } g = NearLosslessComponent((value >> 8) & 0xff, (predict >> 8) & 0xff, 0xff, quantization); if (used_subtract_green) { // The green offset will be added to red and blue components during decoding // to obtain the actual red and blue values. new_green = ((predict >> 8) + g) & 0xff; // The amount by which green has been adjusted during quantization. It is // subtracted from red and blue for compensation, to avoid accumulating two // quantization errors in them. green_diff = NearLosslessDiff(new_green, (value >> 8) & 0xff); } r = NearLosslessComponent(NearLosslessDiff((value >> 16) & 0xff, green_diff), (predict >> 16) & 0xff, 0xff - new_green, quantization); b = NearLosslessComponent(NearLosslessDiff(value & 0xff, green_diff), predict & 0xff, 0xff - new_green, quantization); return ((uint32_t)a << 24) | ((uint32_t)r << 16) | ((uint32_t)g << 8) | b; } #endif // (WEBP_NEAR_LOSSLESS == 1) // Stores the difference between the pixel and its prediction in "out". // In case of a lossy encoding, updates the source image to avoid propagating // the deviation further to pixels which depend on the current pixel for their // predictions. static WEBP_INLINE void GetResidual( int width, int height, uint32_t* const upper_row, uint32_t* const current_row, const uint8_t* const max_diffs, int mode, int x_start, int x_end, int y, int max_quantization, int exact, int used_subtract_green, uint32_t* const out) { … } // Returns best predictor and updates the accumulated histogram. // If max_quantization > 1, assumes that near lossless processing will be // applied, quantizing residuals to multiples of quantization levels up to // max_quantization (the actual quantization level depends on smoothness near // the given pixel). static int GetBestPredictorForTile(int width, int height, int tile_x, int tile_y, int bits, int accumulated[4][256], uint32_t* const argb_scratch, const uint32_t* const argb, int max_quantization, int exact, int used_subtract_green, const uint32_t* const modes) { … } // Converts pixels of the image to residuals with respect to predictions. // If max_quantization > 1, applies near lossless processing, quantizing // residuals to multiples of quantization levels up to max_quantization // (the actual quantization level depends on smoothness near the given pixel). static void CopyImageWithPrediction(int width, int height, int bits, uint32_t* const modes, uint32_t* const argb_scratch, uint32_t* const argb, int low_effort, int max_quantization, int exact, int used_subtract_green) { … } // Finds the best predictor for each tile, and converts the image to residuals // with respect to predictions. If near_lossless_quality < 100, applies // near lossless processing, shaving off more bits of residuals for lower // qualities. int VP8LResidualImage(int width, int height, int bits, int low_effort, uint32_t* const argb, uint32_t* const argb_scratch, uint32_t* const image, int near_lossless_quality, int exact, int used_subtract_green, const WebPPicture* const pic, int percent_range, int* const percent) { … } //------------------------------------------------------------------------------ // Color transform functions. static WEBP_INLINE void MultipliersClear(VP8LMultipliers* const m) { … } static WEBP_INLINE void ColorCodeToMultipliers(uint32_t color_code, VP8LMultipliers* const m) { … } static WEBP_INLINE uint32_t MultipliersToColorCode( const VP8LMultipliers* const m) { … } static float PredictionCostCrossColor(const int accumulated[256], const int counts[256]) { … } static float GetPredictionCostCrossColorRed( const uint32_t* argb, int stride, int tile_width, int tile_height, VP8LMultipliers prev_x, VP8LMultipliers prev_y, int green_to_red, const int accumulated_red_histo[256]) { … } static void GetBestGreenToRed( const uint32_t* argb, int stride, int tile_width, int tile_height, VP8LMultipliers prev_x, VP8LMultipliers prev_y, int quality, const int accumulated_red_histo[256], VP8LMultipliers* const best_tx) { … } static float GetPredictionCostCrossColorBlue( const uint32_t* argb, int stride, int tile_width, int tile_height, VP8LMultipliers prev_x, VP8LMultipliers prev_y, int green_to_blue, int red_to_blue, const int accumulated_blue_histo[256]) { … } #define kGreenRedToBlueNumAxis … #define kGreenRedToBlueMaxIters … static void GetBestGreenRedToBlue( const uint32_t* argb, int stride, int tile_width, int tile_height, VP8LMultipliers prev_x, VP8LMultipliers prev_y, int quality, const int accumulated_blue_histo[256], VP8LMultipliers* const best_tx) { … } #undef kGreenRedToBlueMaxIters #undef kGreenRedToBlueNumAxis static VP8LMultipliers GetBestColorTransformForTile( int tile_x, int tile_y, int bits, VP8LMultipliers prev_x, VP8LMultipliers prev_y, int quality, int xsize, int ysize, const int accumulated_red_histo[256], const int accumulated_blue_histo[256], const uint32_t* const argb) { … } static void CopyTileWithColorTransform(int xsize, int ysize, int tile_x, int tile_y, int max_tile_size, VP8LMultipliers color_transform, uint32_t* argb) { … } int VP8LColorSpaceTransform(int width, int height, int bits, int quality, uint32_t* const argb, uint32_t* image, const WebPPicture* const pic, int percent_range, int* const percent) { … }
Codebase Browser
chromium