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 "src/webp/types.h" |
19 | #include "src/webp/decode.h" |
20 | |
21 | #include "src/enc/histogram_enc.h" |
22 | #include "src/utils/utils.h" |
23 | |
24 | #ifdef __cplusplus |
25 | extern "C" { |
26 | #endif |
27 | |
28 | //------------------------------------------------------------------------------ |
29 | // Decoding |
30 | |
31 | typedef uint32_t (*VP8LPredictorFunc)(const uint32_t* const left, |
32 | const uint32_t* const top); |
33 | extern VP8LPredictorFunc VP8LPredictors[16]; |
34 | |
35 | uint32_t VP8LPredictor0_C(const uint32_t* const left, |
36 | const uint32_t* const top); |
37 | uint32_t VP8LPredictor1_C(const uint32_t* const left, |
38 | const uint32_t* const top); |
39 | uint32_t VP8LPredictor2_C(const uint32_t* const left, |
40 | const uint32_t* const top); |
41 | uint32_t VP8LPredictor3_C(const uint32_t* const left, |
42 | const uint32_t* const top); |
43 | uint32_t VP8LPredictor4_C(const uint32_t* const left, |
44 | const uint32_t* const top); |
45 | uint32_t VP8LPredictor5_C(const uint32_t* const left, |
46 | const uint32_t* const top); |
47 | uint32_t VP8LPredictor6_C(const uint32_t* const left, |
48 | const uint32_t* const top); |
49 | uint32_t VP8LPredictor7_C(const uint32_t* const left, |
50 | const uint32_t* const top); |
51 | uint32_t VP8LPredictor8_C(const uint32_t* const left, |
52 | const uint32_t* const top); |
53 | uint32_t VP8LPredictor9_C(const uint32_t* const left, |
54 | const uint32_t* const top); |
55 | uint32_t VP8LPredictor10_C(const uint32_t* const left, |
56 | const uint32_t* const top); |
57 | uint32_t VP8LPredictor11_C(const uint32_t* const left, |
58 | const uint32_t* const top); |
59 | uint32_t VP8LPredictor12_C(const uint32_t* const left, |
60 | const uint32_t* const top); |
61 | uint32_t VP8LPredictor13_C(const uint32_t* const left, |
62 | const uint32_t* const top); |
63 | |
64 | // These Add/Sub function expects upper[-1] and out[-1] to be readable. |
65 | typedef void (*VP8LPredictorAddSubFunc)(const uint32_t* in, |
66 | const uint32_t* upper, int num_pixels, |
67 | uint32_t* out); |
68 | extern VP8LPredictorAddSubFunc VP8LPredictorsAdd[16]; |
69 | extern VP8LPredictorAddSubFunc VP8LPredictorsAdd_C[16]; |
70 | |
71 | typedef void (*VP8LProcessDecBlueAndRedFunc)(const uint32_t* src, |
72 | int num_pixels, uint32_t* dst); |
73 | extern VP8LProcessDecBlueAndRedFunc VP8LAddGreenToBlueAndRed; |
74 | |
75 | typedef struct { |
76 | // Note: the members are uint8_t, so that any negative values are |
77 | // automatically converted to "mod 256" values. |
78 | uint8_t green_to_red_; |
79 | uint8_t green_to_blue_; |
80 | uint8_t red_to_blue_; |
81 | } VP8LMultipliers; |
82 | typedef void (*VP8LTransformColorInverseFunc)(const VP8LMultipliers* const m, |
83 | const uint32_t* src, |
84 | int num_pixels, uint32_t* dst); |
85 | extern VP8LTransformColorInverseFunc VP8LTransformColorInverse; |
86 | |
87 | struct VP8LTransform; // Defined in dec/vp8li.h. |
88 | |
89 | // Performs inverse transform of data given transform information, start and end |
90 | // rows. Transform will be applied to rows [row_start, row_end[. |
91 | // The *in and *out pointers refer to source and destination data respectively |
92 | // corresponding to the intermediate row (row_start). |
93 | void VP8LInverseTransform(const struct VP8LTransform* const transform, |
94 | int row_start, int row_end, |
95 | const uint32_t* const in, uint32_t* const out); |
96 | |
97 | // Color space conversion. |
98 | typedef void (*VP8LConvertFunc)(const uint32_t* src, int num_pixels, |
99 | uint8_t* dst); |
100 | extern VP8LConvertFunc VP8LConvertBGRAToRGB; |
101 | extern VP8LConvertFunc VP8LConvertBGRAToRGBA; |
102 | extern VP8LConvertFunc VP8LConvertBGRAToRGBA4444; |
103 | extern VP8LConvertFunc VP8LConvertBGRAToRGB565; |
104 | extern VP8LConvertFunc VP8LConvertBGRAToBGR; |
105 | |
106 | // Converts from BGRA to other color spaces. |
107 | void VP8LConvertFromBGRA(const uint32_t* const in_data, int num_pixels, |
108 | WEBP_CSP_MODE out_colorspace, uint8_t* const rgba); |
109 | |
110 | typedef void (*VP8LMapARGBFunc)(const uint32_t* src, |
111 | const uint32_t* const color_map, |
112 | uint32_t* dst, int y_start, |
113 | int y_end, int width); |
114 | typedef void (*VP8LMapAlphaFunc)(const uint8_t* src, |
115 | const uint32_t* const color_map, |
116 | uint8_t* dst, int y_start, |
117 | int y_end, int width); |
118 | |
119 | extern VP8LMapARGBFunc VP8LMapColor32b; |
120 | extern VP8LMapAlphaFunc VP8LMapColor8b; |
121 | |
122 | // Similar to the static method ColorIndexInverseTransform() that is part of |
123 | // lossless.c, but used only for alpha decoding. It takes uint8_t (rather than |
124 | // uint32_t) arguments for 'src' and 'dst'. |
125 | void VP8LColorIndexInverseTransformAlpha( |
126 | const struct VP8LTransform* const transform, int y_start, int y_end, |
127 | const uint8_t* src, uint8_t* dst); |
128 | |
129 | // Expose some C-only fallback functions |
130 | void VP8LTransformColorInverse_C(const VP8LMultipliers* const m, |
131 | const uint32_t* src, int num_pixels, |
132 | uint32_t* dst); |
133 | |
134 | void VP8LConvertBGRAToRGB_C(const uint32_t* src, int num_pixels, uint8_t* dst); |
135 | void VP8LConvertBGRAToRGBA_C(const uint32_t* src, int num_pixels, uint8_t* dst); |
136 | void VP8LConvertBGRAToRGBA4444_C(const uint32_t* src, |
137 | int num_pixels, uint8_t* dst); |
138 | void VP8LConvertBGRAToRGB565_C(const uint32_t* src, |
139 | int num_pixels, uint8_t* dst); |
140 | void VP8LConvertBGRAToBGR_C(const uint32_t* src, int num_pixels, uint8_t* dst); |
141 | void VP8LAddGreenToBlueAndRed_C(const uint32_t* src, int num_pixels, |
142 | uint32_t* dst); |
143 | |
144 | // Must be called before calling any of the above methods. |
145 | void VP8LDspInit(void); |
146 | |
147 | //------------------------------------------------------------------------------ |
148 | // Encoding |
149 | |
150 | typedef void (*VP8LProcessEncBlueAndRedFunc)(uint32_t* dst, int num_pixels); |
151 | extern VP8LProcessEncBlueAndRedFunc VP8LSubtractGreenFromBlueAndRed; |
152 | typedef void (*VP8LTransformColorFunc)(const VP8LMultipliers* const m, |
153 | uint32_t* dst, int num_pixels); |
154 | extern VP8LTransformColorFunc VP8LTransformColor; |
155 | typedef void (*VP8LCollectColorBlueTransformsFunc)( |
156 | const uint32_t* argb, int stride, |
157 | int tile_width, int tile_height, |
158 | int green_to_blue, int red_to_blue, int histo[]); |
159 | extern VP8LCollectColorBlueTransformsFunc VP8LCollectColorBlueTransforms; |
160 | |
161 | typedef void (*VP8LCollectColorRedTransformsFunc)( |
162 | const uint32_t* argb, int stride, |
163 | int tile_width, int tile_height, |
164 | int green_to_red, int histo[]); |
165 | extern VP8LCollectColorRedTransformsFunc VP8LCollectColorRedTransforms; |
166 | |
167 | // Expose some C-only fallback functions |
168 | void VP8LTransformColor_C(const VP8LMultipliers* const m, |
169 | uint32_t* data, int num_pixels); |
170 | void VP8LSubtractGreenFromBlueAndRed_C(uint32_t* argb_data, int num_pixels); |
171 | void VP8LCollectColorRedTransforms_C(const uint32_t* argb, int stride, |
172 | int tile_width, int tile_height, |
173 | int green_to_red, int histo[]); |
174 | void VP8LCollectColorBlueTransforms_C(const uint32_t* argb, int stride, |
175 | int tile_width, int tile_height, |
176 | int green_to_blue, int red_to_blue, |
177 | int histo[]); |
178 | |
179 | extern VP8LPredictorAddSubFunc [16]; |
180 | extern VP8LPredictorAddSubFunc [16]; |
181 | |
182 | // ----------------------------------------------------------------------------- |
183 | // Huffman-cost related functions. |
184 | |
185 | typedef float (*VP8LCostFunc)(const uint32_t* population, int length); |
186 | typedef float (*VP8LCostCombinedFunc)(const uint32_t* X, const uint32_t* Y, |
187 | int length); |
188 | typedef float (*VP8LCombinedShannonEntropyFunc)(const int X[256], |
189 | const int Y[256]); |
190 | |
191 | extern VP8LCostFunc ; |
192 | extern VP8LCostCombinedFunc ; |
193 | extern VP8LCombinedShannonEntropyFunc VP8LCombinedShannonEntropy; |
194 | |
195 | typedef struct { // small struct to hold counters |
196 | int counts[2]; // index: 0=zero streak, 1=non-zero streak |
197 | int streaks[2][2]; // [zero/non-zero][streak<3 / streak>=3] |
198 | } VP8LStreaks; |
199 | |
200 | typedef struct { // small struct to hold bit entropy results |
201 | float entropy; // entropy |
202 | uint32_t sum; // sum of the population |
203 | int nonzeros; // number of non-zero elements in the population |
204 | uint32_t max_val; // maximum value in the population |
205 | uint32_t nonzero_code; // index of the last non-zero in the population |
206 | } VP8LBitEntropy; |
207 | |
208 | void VP8LBitEntropyInit(VP8LBitEntropy* const entropy); |
209 | |
210 | // Get the combined symbol bit entropy and Huffman cost stats for the |
211 | // distributions 'X' and 'Y'. Those results can then be refined according to |
212 | // codec specific heuristics. |
213 | typedef void (*VP8LGetCombinedEntropyUnrefinedFunc)( |
214 | const uint32_t X[], const uint32_t Y[], int length, |
215 | VP8LBitEntropy* const bit_entropy, VP8LStreaks* const stats); |
216 | extern VP8LGetCombinedEntropyUnrefinedFunc VP8LGetCombinedEntropyUnrefined; |
217 | |
218 | // Get the entropy for the distribution 'X'. |
219 | typedef void (*VP8LGetEntropyUnrefinedFunc)(const uint32_t X[], int length, |
220 | VP8LBitEntropy* const bit_entropy, |
221 | VP8LStreaks* const stats); |
222 | extern VP8LGetEntropyUnrefinedFunc VP8LGetEntropyUnrefined; |
223 | |
224 | void VP8LBitsEntropyUnrefined(const uint32_t* const array, int n, |
225 | VP8LBitEntropy* const entropy); |
226 | |
227 | typedef void (*VP8LAddVectorFunc)(const uint32_t* a, const uint32_t* b, |
228 | uint32_t* out, int size); |
229 | extern VP8LAddVectorFunc VP8LAddVector; |
230 | typedef void (*VP8LAddVectorEqFunc)(const uint32_t* a, uint32_t* out, int size); |
231 | extern VP8LAddVectorEqFunc VP8LAddVectorEq; |
232 | void VP8LHistogramAdd(const VP8LHistogram* const a, |
233 | const VP8LHistogram* const b, |
234 | VP8LHistogram* const out); |
235 | |
236 | // ----------------------------------------------------------------------------- |
237 | // PrefixEncode() |
238 | |
239 | typedef int (*VP8LVectorMismatchFunc)(const uint32_t* const array1, |
240 | const uint32_t* const array2, int length); |
241 | // Returns the first index where array1 and array2 are different. |
242 | extern VP8LVectorMismatchFunc VP8LVectorMismatch; |
243 | |
244 | typedef void (*VP8LBundleColorMapFunc)(const uint8_t* const row, int width, |
245 | int xbits, uint32_t* dst); |
246 | extern VP8LBundleColorMapFunc VP8LBundleColorMap; |
247 | void VP8LBundleColorMap_C(const uint8_t* const row, int width, int xbits, |
248 | uint32_t* dst); |
249 | |
250 | // Must be called before calling any of the above methods. |
251 | void VP8LEncDspInit(void); |
252 | |
253 | //------------------------------------------------------------------------------ |
254 | |
255 | #ifdef __cplusplus |
256 | } // extern "C" |
257 | #endif |
258 | |
259 | #endif // WEBP_DSP_LOSSLESS_H_ |
260 | |