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 (at) gmail.com) 13 // Jyrki Alakuijala (jyrki (at) 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 25 extern "C" { 26 #endif 27 28 //------------------------------------------------------------------------------ 29 // Signatures and generic function-pointers 30 31 typedef uint32_t (*VP8LPredictorFunc)(uint32_t left, const uint32_t* const top); 32 extern VP8LPredictorFunc VP8LPredictors[16]; 33 34 typedef void (*VP8LProcessBlueAndRedFunc)(uint32_t* argb_data, int num_pixels); 35 extern VP8LProcessBlueAndRedFunc VP8LSubtractGreenFromBlueAndRed; 36 extern VP8LProcessBlueAndRedFunc VP8LAddGreenToBlueAndRed; 37 38 typedef 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; 45 typedef void (*VP8LTransformColorFunc)(const VP8LMultipliers* const m, 46 uint32_t* argb_data, int num_pixels); 47 extern VP8LTransformColorFunc VP8LTransformColor; 48 extern VP8LTransformColorFunc VP8LTransformColorInverse; 49 50 typedef void (*VP8LConvertFunc)(const uint32_t* src, int num_pixels, 51 uint8_t* dst); 52 extern VP8LConvertFunc VP8LConvertBGRAToRGB; 53 extern VP8LConvertFunc VP8LConvertBGRAToRGBA; 54 extern VP8LConvertFunc VP8LConvertBGRAToRGBA4444; 55 extern VP8LConvertFunc VP8LConvertBGRAToRGB565; 56 extern VP8LConvertFunc VP8LConvertBGRAToBGR; 57 58 // Expose some C-only fallback functions 59 extern void VP8LTransformColor_C(const VP8LMultipliers* const m, 60 uint32_t* data, int num_pixels); 61 extern void VP8LTransformColorInverse_C(const VP8LMultipliers* const m, 62 uint32_t* data, int num_pixels); 63 64 extern void VP8LConvertBGRAToRGB_C(const uint32_t* src, 65 int num_pixels, uint8_t* dst); 66 extern void VP8LConvertBGRAToRGBA_C(const uint32_t* src, 67 int num_pixels, uint8_t* dst); 68 extern void VP8LConvertBGRAToRGBA4444_C(const uint32_t* src, 69 int num_pixels, uint8_t* dst); 70 extern void VP8LConvertBGRAToRGB565_C(const uint32_t* src, 71 int num_pixels, uint8_t* dst); 72 extern void VP8LConvertBGRAToBGR_C(const uint32_t* src, 73 int num_pixels, uint8_t* dst); 74 extern void VP8LSubtractGreenFromBlueAndRed_C(uint32_t* argb_data, 75 int num_pixels); 76 extern void VP8LAddGreenToBlueAndRed_C(uint32_t* data, int num_pixels); 77 78 // Must be called before calling any of the above methods. 79 void VP8LDspInit(void); 80 81 //------------------------------------------------------------------------------ 82 // Image transforms. 83 84 struct 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). 90 void 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'. 97 void VP8LColorIndexInverseTransformAlpha( 98 const struct VP8LTransform* const transform, int y_start, int y_end, 99 const uint8_t* src, uint8_t* dst); 100 101 void VP8LResidualImage(int width, int height, int bits, 102 uint32_t* const argb, uint32_t* const argb_scratch, 103 uint32_t* const image); 104 105 void 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. 112 void 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'. 119 static 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 127 extern const float kLog2Table[LOG_LOOKUP_IDX_MAX]; 128 extern const float kSLog2Table[LOG_LOOKUP_IDX_MAX]; 129 typedef float (*VP8LFastLog2SlowFunc)(uint32_t v); 130 131 extern VP8LFastLog2SlowFunc VP8LFastLog2Slow; 132 extern VP8LFastLog2SlowFunc VP8LFastSLog2Slow; 133 134 static 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. 138 static 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 145 typedef double (*VP8LCostFunc)(const uint32_t* population, int length); 146 typedef double (*VP8LCostCombinedFunc)(const uint32_t* X, const uint32_t* Y, 147 int length); 148 149 extern VP8LCostFunc VP8LExtraCost; 150 extern VP8LCostCombinedFunc VP8LExtraCostCombined; 151 152 typedef 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 157 typedef VP8LStreaks (*VP8LCostCountFunc)(const uint32_t* population, 158 int length); 159 typedef VP8LStreaks (*VP8LCostCombinedCountFunc)(const uint32_t* X, 160 const uint32_t* Y, int length); 161 162 extern VP8LCostCountFunc VP8LHuffmanCostCount; 163 extern VP8LCostCombinedCountFunc VP8LHuffmanCostCombinedCount; 164 165 typedef void (*VP8LHistogramAddFunc)(const VP8LHistogram* const a, 166 const VP8LHistogram* const b, 167 VP8LHistogram* const out); 168 extern VP8LHistogramAddFunc VP8LHistogramAdd; 169 170 // ----------------------------------------------------------------------------- 171 // PrefixEncode() 172 173 static 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. 184 static 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 192 static 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 203 typedef struct { 204 int8_t code_; 205 int8_t extra_bits_; 206 } VP8LPrefixCode; 207 208 // These tables are derived using VP8LPrefixEncodeNoLUT. 209 extern const VP8LPrefixCode kPrefixEncodeCode[PREFIX_LOOKUP_IDX_MAX]; 210 extern const uint8_t kPrefixEncodeExtraBitsValue[PREFIX_LOOKUP_IDX_MAX]; 211 static 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 222 static 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. 236 static 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 244 void 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
