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// Image transforms and color space conversion methods for lossless decoder. 11// 12// Authors: Vikas Arora (vikaas.arora@gmail.com) 13// Jyrki Alakuijala (jyrki@google.com) 14 15#ifndef WEBP_DSP_LOSSLESS_H_ 16#define WEBP_DSP_LOSSLESS_H_ 17 18#include "../webp/types.h" 19#include "../webp/decode.h" 20 21#include "../enc/histogram.h" 22#include "../utils/utils.h" 23 24#ifdef __cplusplus 25extern "C" { 26#endif 27 28//------------------------------------------------------------------------------ 29// Signatures and generic function-pointers 30 31typedef uint32_t (*VP8LPredictorFunc)(uint32_t left, const uint32_t* const top); 32extern VP8LPredictorFunc VP8LPredictors[16]; 33 34typedef void (*VP8LProcessBlueAndRedFunc)(uint32_t* argb_data, int num_pixels); 35extern VP8LProcessBlueAndRedFunc VP8LSubtractGreenFromBlueAndRed; 36extern VP8LProcessBlueAndRedFunc VP8LAddGreenToBlueAndRed; 37 38typedef struct { 39 // Note: the members are uint8_t, so that any negative values are 40 // automatically converted to "mod 256" values. 41 uint8_t green_to_red_; 42 uint8_t green_to_blue_; 43 uint8_t red_to_blue_; 44} VP8LMultipliers; 45typedef void (*VP8LTransformColorFunc)(const VP8LMultipliers* const m, 46 uint32_t* argb_data, int num_pixels); 47extern VP8LTransformColorFunc VP8LTransformColor; 48extern VP8LTransformColorFunc VP8LTransformColorInverse; 49 50typedef void (*VP8LConvertFunc)(const uint32_t* src, int num_pixels, 51 uint8_t* dst); 52extern VP8LConvertFunc VP8LConvertBGRAToRGB; 53extern VP8LConvertFunc VP8LConvertBGRAToRGBA; 54extern VP8LConvertFunc VP8LConvertBGRAToRGBA4444; 55extern VP8LConvertFunc VP8LConvertBGRAToRGB565; 56extern VP8LConvertFunc VP8LConvertBGRAToBGR; 57 58// Expose some C-only fallback functions 59extern void VP8LTransformColor_C(const VP8LMultipliers* const m, 60 uint32_t* data, int num_pixels); 61extern void VP8LTransformColorInverse_C(const VP8LMultipliers* const m, 62 uint32_t* data, int num_pixels); 63 64extern void VP8LConvertBGRAToRGB_C(const uint32_t* src, 65 int num_pixels, uint8_t* dst); 66extern void VP8LConvertBGRAToRGBA_C(const uint32_t* src, 67 int num_pixels, uint8_t* dst); 68extern void VP8LConvertBGRAToRGBA4444_C(const uint32_t* src, 69 int num_pixels, uint8_t* dst); 70extern void VP8LConvertBGRAToRGB565_C(const uint32_t* src, 71 int num_pixels, uint8_t* dst); 72extern void VP8LConvertBGRAToBGR_C(const uint32_t* src, 73 int num_pixels, uint8_t* dst); 74extern void VP8LSubtractGreenFromBlueAndRed_C(uint32_t* argb_data, 75 int num_pixels); 76extern void VP8LAddGreenToBlueAndRed_C(uint32_t* data, int num_pixels); 77 78// Must be called before calling any of the above methods. 79void VP8LDspInit(void); 80 81//------------------------------------------------------------------------------ 82// Image transforms. 83 84struct VP8LTransform; // Defined in dec/vp8li.h. 85 86// Performs inverse transform of data given transform information, start and end 87// rows. Transform will be applied to rows [row_start, row_end[. 88// The *in and *out pointers refer to source and destination data respectively 89// corresponding to the intermediate row (row_start). 90void VP8LInverseTransform(const struct VP8LTransform* const transform, 91 int row_start, int row_end, 92 const uint32_t* const in, uint32_t* const out); 93 94// Similar to the static method ColorIndexInverseTransform() that is part of 95// lossless.c, but used only for alpha decoding. It takes uint8_t (rather than 96// uint32_t) arguments for 'src' and 'dst'. 97void VP8LColorIndexInverseTransformAlpha( 98 const struct VP8LTransform* const transform, int y_start, int y_end, 99 const uint8_t* src, uint8_t* dst); 100 101void VP8LResidualImage(int width, int height, int bits, 102 uint32_t* const argb, uint32_t* const argb_scratch, 103 uint32_t* const image); 104 105void VP8LColorSpaceTransform(int width, int height, int bits, int quality, 106 uint32_t* const argb, uint32_t* image); 107 108//------------------------------------------------------------------------------ 109// Color space conversion. 110 111// Converts from BGRA to other color spaces. 112void VP8LConvertFromBGRA(const uint32_t* const in_data, int num_pixels, 113 WEBP_CSP_MODE out_colorspace, uint8_t* const rgba); 114 115//------------------------------------------------------------------------------ 116// Misc methods. 117 118// Computes sampled size of 'size' when sampling using 'sampling bits'. 119static WEBP_INLINE uint32_t VP8LSubSampleSize(uint32_t size, 120 uint32_t sampling_bits) { 121 return (size + (1 << sampling_bits) - 1) >> sampling_bits; 122} 123 124// ----------------------------------------------------------------------------- 125// Faster logarithm for integers. Small values use a look-up table. 126#define LOG_LOOKUP_IDX_MAX 256 127extern const float kLog2Table[LOG_LOOKUP_IDX_MAX]; 128extern const float kSLog2Table[LOG_LOOKUP_IDX_MAX]; 129typedef float (*VP8LFastLog2SlowFunc)(uint32_t v); 130 131extern VP8LFastLog2SlowFunc VP8LFastLog2Slow; 132extern VP8LFastLog2SlowFunc VP8LFastSLog2Slow; 133 134static WEBP_INLINE float VP8LFastLog2(uint32_t v) { 135 return (v < LOG_LOOKUP_IDX_MAX) ? kLog2Table[v] : VP8LFastLog2Slow(v); 136} 137// Fast calculation of v * log2(v) for integer input. 138static WEBP_INLINE float VP8LFastSLog2(uint32_t v) { 139 return (v < LOG_LOOKUP_IDX_MAX) ? kSLog2Table[v] : VP8LFastSLog2Slow(v); 140} 141 142// ----------------------------------------------------------------------------- 143// Huffman-cost related functions. 144 145typedef double (*VP8LCostFunc)(const uint32_t* population, int length); 146typedef double (*VP8LCostCombinedFunc)(const uint32_t* X, const uint32_t* Y, 147 int length); 148 149extern VP8LCostFunc VP8LExtraCost; 150extern VP8LCostCombinedFunc VP8LExtraCostCombined; 151 152typedef struct { // small struct to hold counters 153 int counts[2]; // index: 0=zero steak, 1=non-zero streak 154 int streaks[2][2]; // [zero/non-zero][streak<3 / streak>=3] 155} VP8LStreaks; 156 157typedef VP8LStreaks (*VP8LCostCountFunc)(const uint32_t* population, 158 int length); 159typedef VP8LStreaks (*VP8LCostCombinedCountFunc)(const uint32_t* X, 160 const uint32_t* Y, int length); 161 162extern VP8LCostCountFunc VP8LHuffmanCostCount; 163extern VP8LCostCombinedCountFunc VP8LHuffmanCostCombinedCount; 164 165typedef void (*VP8LHistogramAddFunc)(const VP8LHistogram* const a, 166 const VP8LHistogram* const b, 167 VP8LHistogram* const out); 168extern VP8LHistogramAddFunc VP8LHistogramAdd; 169 170// ----------------------------------------------------------------------------- 171// PrefixEncode() 172 173static WEBP_INLINE int VP8LBitsLog2Ceiling(uint32_t n) { 174 const int log_floor = BitsLog2Floor(n); 175 if (n == (n & ~(n - 1))) // zero or a power of two. 176 return log_floor; 177 else 178 return log_floor + 1; 179} 180 181// Splitting of distance and length codes into prefixes and 182// extra bits. The prefixes are encoded with an entropy code 183// while the extra bits are stored just as normal bits. 184static WEBP_INLINE void VP8LPrefixEncodeBitsNoLUT(int distance, int* const code, 185 int* const extra_bits) { 186 const int highest_bit = BitsLog2Floor(--distance); 187 const int second_highest_bit = (distance >> (highest_bit - 1)) & 1; 188 *extra_bits = highest_bit - 1; 189 *code = 2 * highest_bit + second_highest_bit; 190} 191 192static WEBP_INLINE void VP8LPrefixEncodeNoLUT(int distance, int* const code, 193 int* const extra_bits, 194 int* const extra_bits_value) { 195 const int highest_bit = BitsLog2Floor(--distance); 196 const int second_highest_bit = (distance >> (highest_bit - 1)) & 1; 197 *extra_bits = highest_bit - 1; 198 *extra_bits_value = distance & ((1 << *extra_bits) - 1); 199 *code = 2 * highest_bit + second_highest_bit; 200} 201 202#define PREFIX_LOOKUP_IDX_MAX 512 203typedef struct { 204 int8_t code_; 205 int8_t extra_bits_; 206} VP8LPrefixCode; 207 208// These tables are derived using VP8LPrefixEncodeNoLUT. 209extern const VP8LPrefixCode kPrefixEncodeCode[PREFIX_LOOKUP_IDX_MAX]; 210extern const uint8_t kPrefixEncodeExtraBitsValue[PREFIX_LOOKUP_IDX_MAX]; 211static WEBP_INLINE void VP8LPrefixEncodeBits(int distance, int* const code, 212 int* const extra_bits) { 213 if (distance < PREFIX_LOOKUP_IDX_MAX) { 214 const VP8LPrefixCode prefix_code = kPrefixEncodeCode[distance]; 215 *code = prefix_code.code_; 216 *extra_bits = prefix_code.extra_bits_; 217 } else { 218 VP8LPrefixEncodeBitsNoLUT(distance, code, extra_bits); 219 } 220} 221 222static WEBP_INLINE void VP8LPrefixEncode(int distance, int* const code, 223 int* const extra_bits, 224 int* const extra_bits_value) { 225 if (distance < PREFIX_LOOKUP_IDX_MAX) { 226 const VP8LPrefixCode prefix_code = kPrefixEncodeCode[distance]; 227 *code = prefix_code.code_; 228 *extra_bits = prefix_code.extra_bits_; 229 *extra_bits_value = kPrefixEncodeExtraBitsValue[distance]; 230 } else { 231 VP8LPrefixEncodeNoLUT(distance, code, extra_bits, extra_bits_value); 232 } 233} 234 235// In-place difference of each component with mod 256. 236static WEBP_INLINE uint32_t VP8LSubPixels(uint32_t a, uint32_t b) { 237 const uint32_t alpha_and_green = 238 0x00ff00ffu + (a & 0xff00ff00u) - (b & 0xff00ff00u); 239 const uint32_t red_and_blue = 240 0xff00ff00u + (a & 0x00ff00ffu) - (b & 0x00ff00ffu); 241 return (alpha_and_green & 0xff00ff00u) | (red_and_blue & 0x00ff00ffu); 242} 243 244void VP8LBundleColorMap(const uint8_t* const row, int width, 245 int xbits, uint32_t* const dst); 246 247//------------------------------------------------------------------------------ 248 249#ifdef __cplusplus 250} // extern "C" 251#endif 252 253#endif // WEBP_DSP_LOSSLESS_H_ 254