lossless.h revision af51b94a435132e9014c324e25fb686b3d07a8c8 
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