1 | // Copyright 2010 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 | // YUV->RGB conversion functions |
11 | // |
12 | // Author: Skal (pascal.massimino@gmail.com) |
13 | |
14 | #include "src/dsp/yuv.h" |
15 | |
16 | #include <assert.h> |
17 | #include <stdlib.h> |
18 | |
19 | //----------------------------------------------------------------------------- |
20 | // Plain-C version |
21 | |
22 | #define ROW_FUNC(FUNC_NAME, FUNC, XSTEP) \ |
23 | static void FUNC_NAME(const uint8_t* y, \ |
24 | const uint8_t* u, const uint8_t* v, \ |
25 | uint8_t* dst, int len) { \ |
26 | const uint8_t* const end = dst + (len & ~1) * (XSTEP); \ |
27 | while (dst != end) { \ |
28 | FUNC(y[0], u[0], v[0], dst); \ |
29 | FUNC(y[1], u[0], v[0], dst + (XSTEP)); \ |
30 | y += 2; \ |
31 | ++u; \ |
32 | ++v; \ |
33 | dst += 2 * (XSTEP); \ |
34 | } \ |
35 | if (len & 1) { \ |
36 | FUNC(y[0], u[0], v[0], dst); \ |
37 | } \ |
38 | } \ |
39 | |
40 | // All variants implemented. |
41 | ROW_FUNC(YuvToRgbRow, VP8YuvToRgb, 3) |
42 | ROW_FUNC(YuvToBgrRow, VP8YuvToBgr, 3) |
43 | ROW_FUNC(YuvToRgbaRow, VP8YuvToRgba, 4) |
44 | ROW_FUNC(YuvToBgraRow, VP8YuvToBgra, 4) |
45 | ROW_FUNC(YuvToArgbRow, VP8YuvToArgb, 4) |
46 | ROW_FUNC(YuvToRgba4444Row, VP8YuvToRgba4444, 2) |
47 | ROW_FUNC(YuvToRgb565Row, VP8YuvToRgb565, 2) |
48 | |
49 | #undef ROW_FUNC |
50 | |
51 | // Main call for processing a plane with a WebPSamplerRowFunc function: |
52 | void WebPSamplerProcessPlane(const uint8_t* y, int y_stride, |
53 | const uint8_t* u, const uint8_t* v, int uv_stride, |
54 | uint8_t* dst, int dst_stride, |
55 | int width, int height, WebPSamplerRowFunc func) { |
56 | int j; |
57 | for (j = 0; j < height; ++j) { |
58 | func(y, u, v, dst, width); |
59 | y += y_stride; |
60 | if (j & 1) { |
61 | u += uv_stride; |
62 | v += uv_stride; |
63 | } |
64 | dst += dst_stride; |
65 | } |
66 | } |
67 | |
68 | //----------------------------------------------------------------------------- |
69 | // Main call |
70 | |
71 | WebPSamplerRowFunc WebPSamplers[MODE_LAST]; |
72 | |
73 | extern void (void); |
74 | extern void (void); |
75 | extern void WebPInitSamplersMIPS32(void); |
76 | extern void WebPInitSamplersMIPSdspR2(void); |
77 | |
78 | WEBP_DSP_INIT_FUNC(WebPInitSamplers) { |
79 | WebPSamplers[MODE_RGB] = YuvToRgbRow; |
80 | WebPSamplers[MODE_RGBA] = YuvToRgbaRow; |
81 | WebPSamplers[MODE_BGR] = YuvToBgrRow; |
82 | WebPSamplers[MODE_BGRA] = YuvToBgraRow; |
83 | WebPSamplers[MODE_ARGB] = YuvToArgbRow; |
84 | WebPSamplers[MODE_RGBA_4444] = YuvToRgba4444Row; |
85 | WebPSamplers[MODE_RGB_565] = YuvToRgb565Row; |
86 | WebPSamplers[MODE_rgbA] = YuvToRgbaRow; |
87 | WebPSamplers[MODE_bgrA] = YuvToBgraRow; |
88 | WebPSamplers[MODE_Argb] = YuvToArgbRow; |
89 | WebPSamplers[MODE_rgbA_4444] = YuvToRgba4444Row; |
90 | |
91 | // If defined, use CPUInfo() to overwrite some pointers with faster versions. |
92 | if (VP8GetCPUInfo != NULL) { |
93 | #if defined(WEBP_USE_SSE2) |
94 | if (VP8GetCPUInfo(kSSE2)) { |
95 | WebPInitSamplersSSE2(); |
96 | } |
97 | #endif // WEBP_USE_SSE2 |
98 | #if defined(WEBP_USE_SSE41) |
99 | if (VP8GetCPUInfo(kSSE4_1)) { |
100 | WebPInitSamplersSSE41(); |
101 | } |
102 | #endif // WEBP_USE_SSE41 |
103 | #if defined(WEBP_USE_MIPS32) |
104 | if (VP8GetCPUInfo(kMIPS32)) { |
105 | WebPInitSamplersMIPS32(); |
106 | } |
107 | #endif // WEBP_USE_MIPS32 |
108 | #if defined(WEBP_USE_MIPS_DSP_R2) |
109 | if (VP8GetCPUInfo(kMIPSdspR2)) { |
110 | WebPInitSamplersMIPSdspR2(); |
111 | } |
112 | #endif // WEBP_USE_MIPS_DSP_R2 |
113 | } |
114 | } |
115 | |
116 | //----------------------------------------------------------------------------- |
117 | // ARGB -> YUV converters |
118 | |
119 | static void ConvertARGBToY_C(const uint32_t* argb, uint8_t* y, int width) { |
120 | int i; |
121 | for (i = 0; i < width; ++i) { |
122 | const uint32_t p = argb[i]; |
123 | y[i] = VP8RGBToY((p >> 16) & 0xff, (p >> 8) & 0xff, (p >> 0) & 0xff, |
124 | YUV_HALF); |
125 | } |
126 | } |
127 | |
128 | void WebPConvertARGBToUV_C(const uint32_t* argb, uint8_t* u, uint8_t* v, |
129 | int src_width, int do_store) { |
130 | // No rounding. Last pixel is dealt with separately. |
131 | const int uv_width = src_width >> 1; |
132 | int i; |
133 | for (i = 0; i < uv_width; ++i) { |
134 | const uint32_t v0 = argb[2 * i + 0]; |
135 | const uint32_t v1 = argb[2 * i + 1]; |
136 | // VP8RGBToU/V expects four accumulated pixels. Hence we need to |
137 | // scale r/g/b value by a factor 2. We just shift v0/v1 one bit less. |
138 | const int r = ((v0 >> 15) & 0x1fe) + ((v1 >> 15) & 0x1fe); |
139 | const int g = ((v0 >> 7) & 0x1fe) + ((v1 >> 7) & 0x1fe); |
140 | const int b = ((v0 << 1) & 0x1fe) + ((v1 << 1) & 0x1fe); |
141 | const int tmp_u = VP8RGBToU(r, g, b, YUV_HALF << 2); |
142 | const int tmp_v = VP8RGBToV(r, g, b, YUV_HALF << 2); |
143 | if (do_store) { |
144 | u[i] = tmp_u; |
145 | v[i] = tmp_v; |
146 | } else { |
147 | // Approximated average-of-four. But it's an acceptable diff. |
148 | u[i] = (u[i] + tmp_u + 1) >> 1; |
149 | v[i] = (v[i] + tmp_v + 1) >> 1; |
150 | } |
151 | } |
152 | if (src_width & 1) { // last pixel |
153 | const uint32_t v0 = argb[2 * i + 0]; |
154 | const int r = (v0 >> 14) & 0x3fc; |
155 | const int g = (v0 >> 6) & 0x3fc; |
156 | const int b = (v0 << 2) & 0x3fc; |
157 | const int tmp_u = VP8RGBToU(r, g, b, YUV_HALF << 2); |
158 | const int tmp_v = VP8RGBToV(r, g, b, YUV_HALF << 2); |
159 | if (do_store) { |
160 | u[i] = tmp_u; |
161 | v[i] = tmp_v; |
162 | } else { |
163 | u[i] = (u[i] + tmp_u + 1) >> 1; |
164 | v[i] = (v[i] + tmp_v + 1) >> 1; |
165 | } |
166 | } |
167 | } |
168 | |
169 | //----------------------------------------------------------------------------- |
170 | |
171 | static void ConvertRGB24ToY_C(const uint8_t* rgb, uint8_t* y, int width) { |
172 | int i; |
173 | for (i = 0; i < width; ++i, rgb += 3) { |
174 | y[i] = VP8RGBToY(rgb[0], rgb[1], rgb[2], YUV_HALF); |
175 | } |
176 | } |
177 | |
178 | static void ConvertBGR24ToY_C(const uint8_t* bgr, uint8_t* y, int width) { |
179 | int i; |
180 | for (i = 0; i < width; ++i, bgr += 3) { |
181 | y[i] = VP8RGBToY(bgr[2], bgr[1], bgr[0], YUV_HALF); |
182 | } |
183 | } |
184 | |
185 | void WebPConvertRGBA32ToUV_C(const uint16_t* rgb, |
186 | uint8_t* u, uint8_t* v, int width) { |
187 | int i; |
188 | for (i = 0; i < width; i += 1, rgb += 4) { |
189 | const int r = rgb[0], g = rgb[1], b = rgb[2]; |
190 | u[i] = VP8RGBToU(r, g, b, YUV_HALF << 2); |
191 | v[i] = VP8RGBToV(r, g, b, YUV_HALF << 2); |
192 | } |
193 | } |
194 | |
195 | //----------------------------------------------------------------------------- |
196 | |
197 | #if !WEBP_NEON_OMIT_C_CODE |
198 | #define MAX_Y ((1 << 10) - 1) // 10b precision over 16b-arithmetic |
199 | static uint16_t clip_y(int v) { |
200 | return (v < 0) ? 0 : (v > MAX_Y) ? MAX_Y : (uint16_t)v; |
201 | } |
202 | |
203 | static uint64_t SharpYUVUpdateY_C(const uint16_t* ref, const uint16_t* src, |
204 | uint16_t* dst, int len) { |
205 | uint64_t diff = 0; |
206 | int i; |
207 | for (i = 0; i < len; ++i) { |
208 | const int diff_y = ref[i] - src[i]; |
209 | const int new_y = (int)dst[i] + diff_y; |
210 | dst[i] = clip_y(new_y); |
211 | diff += (uint64_t)abs(diff_y); |
212 | } |
213 | return diff; |
214 | } |
215 | |
216 | static void SharpYUVUpdateRGB_C(const int16_t* ref, const int16_t* src, |
217 | int16_t* dst, int len) { |
218 | int i; |
219 | for (i = 0; i < len; ++i) { |
220 | const int diff_uv = ref[i] - src[i]; |
221 | dst[i] += diff_uv; |
222 | } |
223 | } |
224 | |
225 | static void SharpYUVFilterRow_C(const int16_t* A, const int16_t* B, int len, |
226 | const uint16_t* best_y, uint16_t* out) { |
227 | int i; |
228 | for (i = 0; i < len; ++i, ++A, ++B) { |
229 | const int v0 = (A[0] * 9 + A[1] * 3 + B[0] * 3 + B[1] + 8) >> 4; |
230 | const int v1 = (A[1] * 9 + A[0] * 3 + B[1] * 3 + B[0] + 8) >> 4; |
231 | out[2 * i + 0] = clip_y(best_y[2 * i + 0] + v0); |
232 | out[2 * i + 1] = clip_y(best_y[2 * i + 1] + v1); |
233 | } |
234 | } |
235 | #endif // !WEBP_NEON_OMIT_C_CODE |
236 | |
237 | #undef MAX_Y |
238 | |
239 | //----------------------------------------------------------------------------- |
240 | |
241 | void (*WebPConvertRGB24ToY)(const uint8_t* rgb, uint8_t* y, int width); |
242 | void (*WebPConvertBGR24ToY)(const uint8_t* bgr, uint8_t* y, int width); |
243 | void (*WebPConvertRGBA32ToUV)(const uint16_t* rgb, |
244 | uint8_t* u, uint8_t* v, int width); |
245 | |
246 | void (*WebPConvertARGBToY)(const uint32_t* argb, uint8_t* y, int width); |
247 | void (*WebPConvertARGBToUV)(const uint32_t* argb, uint8_t* u, uint8_t* v, |
248 | int src_width, int do_store); |
249 | |
250 | uint64_t (*WebPSharpYUVUpdateY)(const uint16_t* ref, const uint16_t* src, |
251 | uint16_t* dst, int len); |
252 | void (*WebPSharpYUVUpdateRGB)(const int16_t* ref, const int16_t* src, |
253 | int16_t* dst, int len); |
254 | void (*WebPSharpYUVFilterRow)(const int16_t* A, const int16_t* B, int len, |
255 | const uint16_t* best_y, uint16_t* out); |
256 | |
257 | extern void WebPInitConvertARGBToYUVSSE2(void); |
258 | extern void WebPInitConvertARGBToYUVSSE41(void); |
259 | extern void WebPInitConvertARGBToYUVNEON(void); |
260 | extern void WebPInitSharpYUVSSE2(void); |
261 | extern void WebPInitSharpYUVNEON(void); |
262 | |
263 | WEBP_DSP_INIT_FUNC(WebPInitConvertARGBToYUV) { |
264 | WebPConvertARGBToY = ConvertARGBToY_C; |
265 | WebPConvertARGBToUV = WebPConvertARGBToUV_C; |
266 | |
267 | WebPConvertRGB24ToY = ConvertRGB24ToY_C; |
268 | WebPConvertBGR24ToY = ConvertBGR24ToY_C; |
269 | |
270 | WebPConvertRGBA32ToUV = WebPConvertRGBA32ToUV_C; |
271 | |
272 | #if !WEBP_NEON_OMIT_C_CODE |
273 | WebPSharpYUVUpdateY = SharpYUVUpdateY_C; |
274 | WebPSharpYUVUpdateRGB = SharpYUVUpdateRGB_C; |
275 | WebPSharpYUVFilterRow = SharpYUVFilterRow_C; |
276 | #endif |
277 | |
278 | if (VP8GetCPUInfo != NULL) { |
279 | #if defined(WEBP_USE_SSE2) |
280 | if (VP8GetCPUInfo(kSSE2)) { |
281 | WebPInitConvertARGBToYUVSSE2(); |
282 | WebPInitSharpYUVSSE2(); |
283 | } |
284 | #endif // WEBP_USE_SSE2 |
285 | #if defined(WEBP_USE_SSE41) |
286 | if (VP8GetCPUInfo(kSSE4_1)) { |
287 | WebPInitConvertARGBToYUVSSE41(); |
288 | } |
289 | #endif // WEBP_USE_SSE41 |
290 | } |
291 | |
292 | #if defined(WEBP_USE_NEON) |
293 | if (WEBP_NEON_OMIT_C_CODE || |
294 | (VP8GetCPUInfo != NULL && VP8GetCPUInfo(kNEON))) { |
295 | WebPInitConvertARGBToYUVNEON(); |
296 | WebPInitSharpYUVNEON(); |
297 | } |
298 | #endif // WEBP_USE_NEON |
299 | |
300 | assert(WebPConvertARGBToY != NULL); |
301 | assert(WebPConvertARGBToUV != NULL); |
302 | assert(WebPConvertRGB24ToY != NULL); |
303 | assert(WebPConvertBGR24ToY != NULL); |
304 | assert(WebPConvertRGBA32ToUV != NULL); |
305 | assert(WebPSharpYUVUpdateY != NULL); |
306 | assert(WebPSharpYUVUpdateRGB != NULL); |
307 | assert(WebPSharpYUVFilterRow != NULL); |
308 | } |
309 | |