98e75f2d |
1 | /* |
2 | * Texture Filtering |
3 | * Version: 1.0 |
4 | * |
5 | * Copyright (C) 2007 Hiroshi Morii All Rights Reserved. |
6 | * Email koolsmoky(at)users.sourceforge.net |
7 | * Web http://www.3dfxzone.it/koolsmoky |
8 | * |
9 | * this is free software; you can redistribute it and/or modify |
10 | * it under the terms of the GNU General Public License as published by |
11 | * the Free Software Foundation; either version 2, or (at your option) |
12 | * any later version. |
13 | * |
14 | * this is distributed in the hope that it will be useful, |
15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
17 | * GNU General Public License for more details. |
18 | * |
19 | * You should have received a copy of the GNU General Public License |
20 | * along with GNU Make; see the file COPYING. If not, write to |
21 | * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. |
22 | */ |
23 | |
24 | /* Based on Maxim Stepin and Rice1964 hq4x code */ |
25 | |
26 | #include <math.h> |
27 | #include <stdlib.h> |
28 | #include "TextureFilters.h" |
29 | |
30 | #if !_16BPP_HACK |
31 | static uint32 RGB444toYUV[4096]; |
32 | #define RGB444toYUV(val) RGB444toYUV[val & 0x0FFF] /* val = ARGB4444 */ |
33 | |
34 | /*inline static uint32 RGB444toYUV(uint32 val) |
35 | { |
36 | uint32 r, g, b, Y, u, v; |
37 | |
38 | r = (val & 0x0F00) >> 4; |
39 | g = (val & 0x00F0); |
40 | b = val & 0x000F; |
41 | r |= r >> 4; |
42 | g |= g >> 4; |
43 | b |= b << 4; |
44 | |
45 | Y = (r + g + b) >> 2; |
46 | u = 128 + ((r - b) >> 2); |
47 | v = 128 + ((2*g - r - b)>>3); |
48 | |
49 | return ((Y << 16) | (u << 8) | v); |
50 | }*/ |
51 | |
52 | static uint32 RGB555toYUV(uint32 val) |
53 | { |
54 | uint32 r, g, b, Y, u, v; |
55 | |
56 | r = (val & 0x7C00) >> 7; |
57 | g = (val & 0x03E0) >> 2; |
58 | b = (val & 0x001F) << 3; |
59 | r |= r >> 5; |
60 | g |= g >> 5; |
61 | b |= b >> 5; |
62 | |
63 | Y = (r + g + b) >> 2; |
64 | u = 128 + ((r - b) >> 2); |
65 | v = 128 + ((2*g - r - b)>>3); |
66 | |
67 | return ((Y << 16) | (u << 8) | v); |
68 | } |
69 | |
70 | static uint32 RGB565toYUV(uint32 val) |
71 | { |
72 | uint32 r, g, b, Y, u, v; |
73 | |
74 | r = (val & 0xF800) >> 8; |
75 | g = (val & 0x07E0) >> 3; |
76 | b = (val & 0x001F) << 3; |
77 | r |= r >> 5; |
78 | g |= g >> 6; |
79 | b |= b >> 5; |
80 | |
81 | Y = (r + g + b) >> 2; |
82 | u = 128 + ((r - b) >> 2); |
83 | v = 128 + ((2*g - r - b)>>3); |
84 | |
85 | return ((Y << 16) | (u << 8) | v); |
86 | } |
87 | #endif /* !_16BPP_HACK */ |
88 | |
89 | static uint32 RGB888toYUV(uint32 val) |
90 | { |
91 | #if 0 |
92 | uint32 Yuv; |
93 | |
94 | __asm { |
95 | mov eax, dword ptr [val]; |
96 | mov ebx, eax; |
97 | mov ecx, eax; |
98 | and ebx, 0x000000ff; // b |
99 | and eax, 0x00ff0000; // r |
100 | and ecx, 0x0000ff00; // g |
101 | shl ebx, 14; |
102 | shr eax, 2; |
103 | shl ecx, 6; |
104 | mov edx, ebx; |
105 | add edx, eax; |
106 | add edx, ecx; |
107 | and edx, 0xffff0000; |
108 | |
109 | sub eax, ebx; |
110 | add eax, 0x00800000; |
111 | shr eax, 8; |
112 | or edx, eax; |
113 | sub eax, 0x00800000; |
114 | and edx, 0xffffff00; |
115 | |
116 | add ecx, 0x00800000; |
117 | shr ecx, 5; |
118 | shr ebx, 7; |
119 | add eax, ebx; |
120 | sub ecx, eax; |
121 | shr ecx, 11; |
122 | or edx, ecx; |
123 | |
124 | mov dword ptr [Yuv], edx; |
125 | } |
126 | |
127 | return Yuv; |
128 | #else |
129 | uint32 r, g, b, Y, u, v; |
130 | |
131 | r = (val & 0x00ff0000) >> 16; |
132 | g = (val & 0x0000ff00) >> 8; |
133 | b = val & 0x000000ff; |
134 | |
135 | Y = (r + g + b) >> 2; |
136 | u = (0x00000200 + r - b) >> 2; |
137 | v = (0x00000400 + (g << 1) - r - b) >> 3; |
138 | |
139 | return ((Y << 16) | (u << 8) | v); |
140 | #endif |
141 | } |
142 | |
143 | #define Ymask 0x00FF0000 |
144 | #define Umask 0x0000FF00 |
145 | #define Vmask 0x000000FF |
146 | #define trY 0x00300000 // ? |
147 | #define trU 0x00000700 // ?? |
148 | #define trV 0x00000006 // ??? |
149 | |
150 | #define HQ4X_INTERP1(n, b) \ |
151 | static void hq4x_Interp1_##n (uint8 * pc, uint##b p1, uint##b p2) \ |
152 | { \ |
153 | /* *((uint##b*)pc) = (p1*3+p2) >> 2; */ \ |
154 | *((uint##b*)pc) = INTERP_##n##_MASK_1_3((INTERP_##n##_MASK_1_3(p1)*3 + INTERP_##n##_MASK_1_3(p2)) / 4) \ |
155 | | INTERP_##n##_MASK_SHIFTBACK_2_4((INTERP_##n##_MASK_SHIFT_2_4(p1)*3 + INTERP_##n##_MASK_SHIFT_2_4(p2)) / 4 ); \ |
156 | } |
157 | |
158 | #define HQ4X_INTERP2(n, b) \ |
159 | static void hq4x_Interp2_##n (uint8 * pc, uint##b p1, uint##b p2, uint##b p3) \ |
160 | { \ |
161 | /**((uint##b*)pc) = (p1*2+p2+p3) >> 2;*/ \ |
162 | *((uint##b*)pc) = INTERP_##n##_MASK_1_3((INTERP_##n##_MASK_1_3(p1)*2 + INTERP_##n##_MASK_1_3(p2) + INTERP_##n##_MASK_1_3(p3)) / 4) \ |
163 | | INTERP_##n##_MASK_SHIFTBACK_2_4((INTERP_##n##_MASK_SHIFT_2_4(p1)*2 + INTERP_##n##_MASK_SHIFT_2_4(p2) + INTERP_##n##_MASK_SHIFT_2_4(p3)) / 4); \ |
164 | } |
165 | |
166 | #define HQ4X_INTERP3(n, b) \ |
167 | static void hq4x_Interp3_##n (uint8 * pc, uint##b p1, uint##b p2) \ |
168 | { \ |
169 | /**((uint##b*)pc) = (p1*7+p2)/8;*/ \ |
170 | *((uint##b*)pc) = INTERP_##n##_MASK_1_3((INTERP_##n##_MASK_1_3(p1)*7 + INTERP_##n##_MASK_1_3(p2)) / 8) \ |
171 | | INTERP_##n##_MASK_SHIFTBACK_2_4((INTERP_##n##_MASK_SHIFT_2_4(p1)*7 + INTERP_##n##_MASK_SHIFT_2_4(p2)) / 8); \ |
172 | } |
173 | |
174 | #define HQ4X_INTERP5(n, b) \ |
175 | static void hq4x_Interp5_##n (uint8 * pc, uint##b p1, uint##b p2) \ |
176 | { \ |
177 | /**((uint##b*)pc) = (p1+p2) >> 1;*/ \ |
178 | *((uint##b*)pc) = INTERP_##n##_MASK_1_3((INTERP_##n##_MASK_1_3(p1) + INTERP_##n##_MASK_1_3(p2)) / 2) \ |
179 | | INTERP_##n##_MASK_SHIFTBACK_2_4((INTERP_##n##_MASK_SHIFT_2_4(p1) + INTERP_##n##_MASK_SHIFT_2_4(p2)) / 2); \ |
180 | } |
181 | |
182 | #define HQ4X_INTERP6(n, b) \ |
183 | static void hq4x_Interp6_##n (uint8 * pc, uint##b p1, uint##b p2, uint##b p3) \ |
184 | { \ |
185 | /**((uint##b*)pc) = (p1*5+p2*2+p3)/8;*/ \ |
186 | *((uint##b*)pc) = INTERP_##n##_MASK_1_3((INTERP_##n##_MASK_1_3(p1)*5 + INTERP_##n##_MASK_1_3(p2)*2 + INTERP_##n##_MASK_1_3(p3)) / 8) \ |
187 | | INTERP_##n##_MASK_SHIFTBACK_2_4((INTERP_##n##_MASK_SHIFT_2_4(p1)*5 + INTERP_##n##_MASK_SHIFT_2_4(p2)*2 + INTERP_##n##_MASK_SHIFT_2_4(p3)) / 8); \ |
188 | } |
189 | |
190 | #define HQ4X_INTERP7(n, b) \ |
191 | static void hq4x_Interp7_##n (uint8 * pc, uint##b p1, uint##b p2, uint##b p3) \ |
192 | { \ |
193 | /**((uint##b*)pc) = (p1*6+p2+p3)/8;*/ \ |
194 | *((uint##b*)pc) = INTERP_##n##_MASK_1_3((INTERP_##n##_MASK_1_3(p1)*6 + INTERP_##n##_MASK_1_3(p2) + INTERP_##n##_MASK_1_3(p3)) / 8) \ |
195 | | INTERP_##n##_MASK_SHIFTBACK_2_4((INTERP_##n##_MASK_SHIFT_2_4(p1)*6 + INTERP_##n##_MASK_SHIFT_2_4(p2) + INTERP_##n##_MASK_SHIFT_2_4(p3)) / 8); \ |
196 | } |
197 | |
198 | #define HQ4X_INTERP8(n, b) \ |
199 | static void hq4x_Interp8_##n (uint8 * pc, uint##b p1, uint##b p2) \ |
200 | { \ |
201 | /**((uint##b*)pc) = (p1*5+p2*3)/8;*/ \ |
202 | *((uint##b*)pc) = INTERP_##n##_MASK_1_3((INTERP_##n##_MASK_1_3(p1)*5 + INTERP_##n##_MASK_1_3(p2)*3) / 8) \ |
203 | | INTERP_##n##_MASK_SHIFTBACK_2_4((INTERP_##n##_MASK_SHIFT_2_4(p1)*5 + INTERP_##n##_MASK_SHIFT_2_4(p2)*3) / 8); \ |
204 | } |
205 | |
206 | #if !_16BPP_HACK |
207 | #define INTERP_4444_MASK_1_3(v) (v & 0x0F0F) |
208 | #define INTERP_4444_MASK_SHIFT_2_4(v) ((v & 0xF0F0) >> 4) |
209 | #define INTERP_4444_MASK_SHIFTBACK_2_4(v) (INTERP_4444_MASK_1_3(v) << 4) |
210 | HQ4X_INTERP1(4444, 16) |
211 | HQ4X_INTERP2(4444, 16) |
212 | HQ4X_INTERP3(4444, 16) |
213 | HQ4X_INTERP5(4444, 16) |
214 | HQ4X_INTERP6(4444, 16) |
215 | HQ4X_INTERP7(4444, 16) |
216 | HQ4X_INTERP8(4444, 16) |
217 | |
218 | #define INTERP_1555_MASK_1_3(v) (v & 0x7C1F) |
219 | #define INTERP_1555_MASK_SHIFT_2_4(v) ((v & 0x83E0) >> 5) |
220 | #define INTERP_1555_MASK_SHIFTBACK_2_4(v) (INTERP_1555_MASK_1_3(v) << 5) |
221 | HQ4X_INTERP1(1555, 16) |
222 | HQ4X_INTERP2(1555, 16) |
223 | HQ4X_INTERP3(1555, 16) |
224 | HQ4X_INTERP5(1555, 16) |
225 | HQ4X_INTERP6(1555, 16) |
226 | HQ4X_INTERP7(1555, 16) |
227 | HQ4X_INTERP8(1555, 16) |
228 | |
229 | #define INTERP_565_MASK_1_3(v) (v & 0xF81F) |
230 | #define INTERP_565_MASK_SHIFT_2_4(v) ((v & 0x7E0) >> 5) |
231 | #define INTERP_565_MASK_SHIFTBACK_2_4(v) (INTERP_565_MASK_1_3(v) << 5) |
232 | HQ4X_INTERP1(565, 16) |
233 | HQ4X_INTERP2(565, 16) |
234 | HQ4X_INTERP3(565, 16) |
235 | HQ4X_INTERP5(565, 16) |
236 | HQ4X_INTERP6(565, 16) |
237 | HQ4X_INTERP7(565, 16) |
238 | HQ4X_INTERP8(565, 16) |
239 | #endif /* !_16BPP_HACK */ |
240 | |
241 | #define INTERP_8888_MASK_1_3(v) (v & 0x00FF00FF) |
242 | #define INTERP_8888_MASK_SHIFT_2_4(v) ((v & 0xFF00FF00) >> 8) |
243 | #define INTERP_8888_MASK_SHIFTBACK_2_4(v) (INTERP_8888_MASK_1_3(v) << 8) |
244 | HQ4X_INTERP1(8888, 32) |
245 | HQ4X_INTERP2(8888, 32) |
246 | HQ4X_INTERP3(8888, 32) |
247 | HQ4X_INTERP5(8888, 32) |
248 | HQ4X_INTERP6(8888, 32) |
249 | HQ4X_INTERP7(8888, 32) |
250 | HQ4X_INTERP8(8888, 32) |
251 | |
252 | #define PIXEL00_0 *((int*)(pOut)) = c[5]; |
253 | #define PIXEL00_11 hq4x_Interp1(pOut, c[5], c[4]); |
254 | #define PIXEL00_12 hq4x_Interp1(pOut, c[5], c[2]); |
255 | #define PIXEL00_20 hq4x_Interp2(pOut, c[5], c[2], c[4]); |
256 | #define PIXEL00_50 hq4x_Interp5(pOut, c[2], c[4]); |
257 | #define PIXEL00_80 hq4x_Interp8(pOut, c[5], c[1]); |
258 | #define PIXEL00_81 hq4x_Interp8(pOut, c[5], c[4]); |
259 | #define PIXEL00_82 hq4x_Interp8(pOut, c[5], c[2]); |
260 | #define PIXEL01_0 *((int*)(pOut+BPP)) = c[5]; |
261 | #define PIXEL01_10 hq4x_Interp1(pOut+BPP, c[5], c[1]); |
262 | #define PIXEL01_12 hq4x_Interp1(pOut+BPP, c[5], c[2]); |
263 | #define PIXEL01_14 hq4x_Interp1(pOut+BPP, c[2], c[5]); |
264 | #define PIXEL01_21 hq4x_Interp2(pOut+BPP, c[2], c[5], c[4]); |
265 | #define PIXEL01_31 hq4x_Interp3(pOut+BPP, c[5], c[4]); |
266 | #define PIXEL01_50 hq4x_Interp5(pOut+BPP, c[2], c[5]); |
267 | #define PIXEL01_60 hq4x_Interp6(pOut+BPP, c[5], c[2], c[4]); |
268 | #define PIXEL01_61 hq4x_Interp6(pOut+BPP, c[5], c[2], c[1]); |
269 | #define PIXEL01_82 hq4x_Interp8(pOut+BPP, c[5], c[2]); |
270 | #define PIXEL01_83 hq4x_Interp8(pOut+BPP, c[2], c[4]); |
271 | #define PIXEL02_0 *((int*)(pOut+BPP2)) = c[5]; |
272 | #define PIXEL02_10 hq4x_Interp1(pOut+BPP2, c[5], c[3]); |
273 | #define PIXEL02_11 hq4x_Interp1(pOut+BPP2, c[5], c[2]); |
274 | #define PIXEL02_13 hq4x_Interp1(pOut+BPP2, c[2], c[5]); |
275 | #define PIXEL02_21 hq4x_Interp2(pOut+BPP2, c[2], c[5], c[6]); |
276 | #define PIXEL02_32 hq4x_Interp3(pOut+BPP2, c[5], c[6]); |
277 | #define PIXEL02_50 hq4x_Interp5(pOut+BPP2, c[2], c[5]); |
278 | #define PIXEL02_60 hq4x_Interp6(pOut+BPP2, c[5], c[2], c[6]); |
279 | #define PIXEL02_61 hq4x_Interp6(pOut+BPP2, c[5], c[2], c[3]); |
280 | #define PIXEL02_81 hq4x_Interp8(pOut+BPP2, c[5], c[2]); |
281 | #define PIXEL02_83 hq4x_Interp8(pOut+BPP2, c[2], c[6]); |
282 | #define PIXEL03_0 *((int*)(pOut+BPP3)) = c[5]; |
283 | #define PIXEL03_11 hq4x_Interp1(pOut+BPP3, c[5], c[2]); |
284 | #define PIXEL03_12 hq4x_Interp1(pOut+BPP3, c[5], c[6]); |
285 | #define PIXEL03_20 hq4x_Interp2(pOut+BPP3, c[5], c[2], c[6]); |
286 | #define PIXEL03_50 hq4x_Interp5(pOut+BPP3, c[2], c[6]); |
287 | #define PIXEL03_80 hq4x_Interp8(pOut+BPP3, c[5], c[3]); |
288 | #define PIXEL03_81 hq4x_Interp8(pOut+BPP3, c[5], c[2]); |
289 | #define PIXEL03_82 hq4x_Interp8(pOut+BPP3, c[5], c[6]); |
290 | #define PIXEL10_0 *((int*)(pOut+BpL)) = c[5]; |
291 | #define PIXEL10_10 hq4x_Interp1(pOut+BpL, c[5], c[1]); |
292 | #define PIXEL10_11 hq4x_Interp1(pOut+BpL, c[5], c[4]); |
293 | #define PIXEL10_13 hq4x_Interp1(pOut+BpL, c[4], c[5]); |
294 | #define PIXEL10_21 hq4x_Interp2(pOut+BpL, c[4], c[5], c[2]); |
295 | #define PIXEL10_32 hq4x_Interp3(pOut+BpL, c[5], c[2]); |
296 | #define PIXEL10_50 hq4x_Interp5(pOut+BpL, c[4], c[5]); |
297 | #define PIXEL10_60 hq4x_Interp6(pOut+BpL, c[5], c[4], c[2]); |
298 | #define PIXEL10_61 hq4x_Interp6(pOut+BpL, c[5], c[4], c[1]); |
299 | #define PIXEL10_81 hq4x_Interp8(pOut+BpL, c[5], c[4]); |
300 | #define PIXEL10_83 hq4x_Interp8(pOut+BpL, c[4], c[2]); |
301 | #define PIXEL11_0 *((int*)(pOut+BpL+BPP)) = c[5]; |
302 | #define PIXEL11_30 hq4x_Interp3(pOut+BpL+BPP, c[5], c[1]); |
303 | #define PIXEL11_31 hq4x_Interp3(pOut+BpL+BPP, c[5], c[4]); |
304 | #define PIXEL11_32 hq4x_Interp3(pOut+BpL+BPP, c[5], c[2]); |
305 | #define PIXEL11_70 hq4x_Interp7(pOut+BpL+BPP, c[5], c[4], c[2]); |
306 | #define PIXEL12_0 *((int*)(pOut+BpL+BPP2)) = c[5]; |
307 | #define PIXEL12_30 hq4x_Interp3(pOut+BpL+BPP2, c[5], c[3]); |
308 | #define PIXEL12_31 hq4x_Interp3(pOut+BpL+BPP2, c[5], c[2]); |
309 | #define PIXEL12_32 hq4x_Interp3(pOut+BpL+BPP2, c[5], c[6]); |
310 | #define PIXEL12_70 hq4x_Interp7(pOut+BpL+BPP2, c[5], c[6], c[2]); |
311 | #define PIXEL13_0 *((int*)(pOut+BpL+BPP3)) = c[5]; |
312 | #define PIXEL13_10 hq4x_Interp1(pOut+BpL+BPP3, c[5], c[3]); |
313 | #define PIXEL13_12 hq4x_Interp1(pOut+BpL+BPP3, c[5], c[6]); |
314 | #define PIXEL13_14 hq4x_Interp1(pOut+BpL+BPP3, c[6], c[5]); |
315 | #define PIXEL13_21 hq4x_Interp2(pOut+BpL+BPP3, c[6], c[5], c[2]); |
316 | #define PIXEL13_31 hq4x_Interp3(pOut+BpL+BPP3, c[5], c[2]); |
317 | #define PIXEL13_50 hq4x_Interp5(pOut+BpL+BPP3, c[6], c[5]); |
318 | #define PIXEL13_60 hq4x_Interp6(pOut+BpL+BPP3, c[5], c[6], c[2]); |
319 | #define PIXEL13_61 hq4x_Interp6(pOut+BpL+BPP3, c[5], c[6], c[3]); |
320 | #define PIXEL13_82 hq4x_Interp8(pOut+BpL+BPP3, c[5], c[6]); |
321 | #define PIXEL13_83 hq4x_Interp8(pOut+BpL+BPP3, c[6], c[2]); |
322 | #define PIXEL20_0 *((int*)(pOut+BpL+BpL)) = c[5]; |
323 | #define PIXEL20_10 hq4x_Interp1(pOut+BpL+BpL, c[5], c[7]); |
324 | #define PIXEL20_12 hq4x_Interp1(pOut+BpL+BpL, c[5], c[4]); |
325 | #define PIXEL20_14 hq4x_Interp1(pOut+BpL+BpL, c[4], c[5]); |
326 | #define PIXEL20_21 hq4x_Interp2(pOut+BpL+BpL, c[4], c[5], c[8]); |
327 | #define PIXEL20_31 hq4x_Interp3(pOut+BpL+BpL, c[5], c[8]); |
328 | #define PIXEL20_50 hq4x_Interp5(pOut+BpL+BpL, c[4], c[5]); |
329 | #define PIXEL20_60 hq4x_Interp6(pOut+BpL+BpL, c[5], c[4], c[8]); |
330 | #define PIXEL20_61 hq4x_Interp6(pOut+BpL+BpL, c[5], c[4], c[7]); |
331 | #define PIXEL20_82 hq4x_Interp8(pOut+BpL+BpL, c[5], c[4]); |
332 | #define PIXEL20_83 hq4x_Interp8(pOut+BpL+BpL, c[4], c[8]); |
333 | #define PIXEL21_0 *((int*)(pOut+BpL+BpL+BPP)) = c[5]; |
334 | #define PIXEL21_30 hq4x_Interp3(pOut+BpL+BpL+BPP, c[5], c[7]); |
335 | #define PIXEL21_31 hq4x_Interp3(pOut+BpL+BpL+BPP, c[5], c[8]); |
336 | #define PIXEL21_32 hq4x_Interp3(pOut+BpL+BpL+BPP, c[5], c[4]); |
337 | #define PIXEL21_70 hq4x_Interp7(pOut+BpL+BpL+BPP, c[5], c[4], c[8]); |
338 | #define PIXEL22_0 *((int*)(pOut+BpL+BpL+BPP2)) = c[5]; |
339 | #define PIXEL22_30 hq4x_Interp3(pOut+BpL+BpL+BPP2, c[5], c[9]); |
340 | #define PIXEL22_31 hq4x_Interp3(pOut+BpL+BpL+BPP2, c[5], c[6]); |
341 | #define PIXEL22_32 hq4x_Interp3(pOut+BpL+BpL+BPP2, c[5], c[8]); |
342 | #define PIXEL22_70 hq4x_Interp7(pOut+BpL+BpL+BPP2, c[5], c[6], c[8]); |
343 | #define PIXEL23_0 *((int*)(pOut+BpL+BpL+BPP3)) = c[5]; |
344 | #define PIXEL23_10 hq4x_Interp1(pOut+BpL+BpL+BPP3, c[5], c[9]); |
345 | #define PIXEL23_11 hq4x_Interp1(pOut+BpL+BpL+BPP3, c[5], c[6]); |
346 | #define PIXEL23_13 hq4x_Interp1(pOut+BpL+BpL+BPP3, c[6], c[5]); |
347 | #define PIXEL23_21 hq4x_Interp2(pOut+BpL+BpL+BPP3, c[6], c[5], c[8]); |
348 | #define PIXEL23_32 hq4x_Interp3(pOut+BpL+BpL+BPP3, c[5], c[8]); |
349 | #define PIXEL23_50 hq4x_Interp5(pOut+BpL+BpL+BPP3, c[6], c[5]); |
350 | #define PIXEL23_60 hq4x_Interp6(pOut+BpL+BpL+BPP3, c[5], c[6], c[8]); |
351 | #define PIXEL23_61 hq4x_Interp6(pOut+BpL+BpL+BPP3, c[5], c[6], c[9]); |
352 | #define PIXEL23_81 hq4x_Interp8(pOut+BpL+BpL+BPP3, c[5], c[6]); |
353 | #define PIXEL23_83 hq4x_Interp8(pOut+BpL+BpL+BPP3, c[6], c[8]); |
354 | #define PIXEL30_0 *((int*)(pOut+BpL+BpL+BpL)) = c[5]; |
355 | #define PIXEL30_11 hq4x_Interp1(pOut+BpL+BpL+BpL, c[5], c[8]); |
356 | #define PIXEL30_12 hq4x_Interp1(pOut+BpL+BpL+BpL, c[5], c[4]); |
357 | #define PIXEL30_20 hq4x_Interp2(pOut+BpL+BpL+BpL, c[5], c[8], c[4]); |
358 | #define PIXEL30_50 hq4x_Interp5(pOut+BpL+BpL+BpL, c[8], c[4]); |
359 | #define PIXEL30_80 hq4x_Interp8(pOut+BpL+BpL+BpL, c[5], c[7]); |
360 | #define PIXEL30_81 hq4x_Interp8(pOut+BpL+BpL+BpL, c[5], c[8]); |
361 | #define PIXEL30_82 hq4x_Interp8(pOut+BpL+BpL+BpL, c[5], c[4]); |
362 | #define PIXEL31_0 *((int*)(pOut+BpL+BpL+BpL+BPP)) = c[5]; |
363 | #define PIXEL31_10 hq4x_Interp1(pOut+BpL+BpL+BpL+BPP, c[5], c[7]); |
364 | #define PIXEL31_11 hq4x_Interp1(pOut+BpL+BpL+BpL+BPP, c[5], c[8]); |
365 | #define PIXEL31_13 hq4x_Interp1(pOut+BpL+BpL+BpL+BPP, c[8], c[5]); |
366 | #define PIXEL31_21 hq4x_Interp2(pOut+BpL+BpL+BpL+BPP, c[8], c[5], c[4]); |
367 | #define PIXEL31_32 hq4x_Interp3(pOut+BpL+BpL+BpL+BPP, c[5], c[4]); |
368 | #define PIXEL31_50 hq4x_Interp5(pOut+BpL+BpL+BpL+BPP, c[8], c[5]); |
369 | #define PIXEL31_60 hq4x_Interp6(pOut+BpL+BpL+BpL+BPP, c[5], c[8], c[4]); |
370 | #define PIXEL31_61 hq4x_Interp6(pOut+BpL+BpL+BpL+BPP, c[5], c[8], c[7]); |
371 | #define PIXEL31_81 hq4x_Interp8(pOut+BpL+BpL+BpL+BPP, c[5], c[8]); |
372 | #define PIXEL31_83 hq4x_Interp8(pOut+BpL+BpL+BpL+BPP, c[8], c[4]); |
373 | #define PIXEL32_0 *((int*)(pOut+BpL+BpL+BpL+BPP2)) = c[5]; |
374 | #define PIXEL32_10 hq4x_Interp1(pOut+BpL+BpL+BpL+BPP2, c[5], c[9]); |
375 | #define PIXEL32_12 hq4x_Interp1(pOut+BpL+BpL+BpL+BPP2, c[5], c[8]); |
376 | #define PIXEL32_14 hq4x_Interp1(pOut+BpL+BpL+BpL+BPP2, c[8], c[5]); |
377 | #define PIXEL32_21 hq4x_Interp2(pOut+BpL+BpL+BpL+BPP2, c[8], c[5], c[6]); |
378 | #define PIXEL32_31 hq4x_Interp3(pOut+BpL+BpL+BpL+BPP2, c[5], c[6]); |
379 | #define PIXEL32_50 hq4x_Interp5(pOut+BpL+BpL+BpL+BPP2, c[8], c[5]); |
380 | #define PIXEL32_60 hq4x_Interp6(pOut+BpL+BpL+BpL+BPP2, c[5], c[8], c[6]); |
381 | #define PIXEL32_61 hq4x_Interp6(pOut+BpL+BpL+BpL+BPP2, c[5], c[8], c[9]); |
382 | #define PIXEL32_82 hq4x_Interp8(pOut+BpL+BpL+BpL+BPP2, c[5], c[8]); |
383 | #define PIXEL32_83 hq4x_Interp8(pOut+BpL+BpL+BpL+BPP2, c[8], c[6]); |
384 | #define PIXEL33_0 *((int*)(pOut+BpL+BpL+BpL+BPP3)) = c[5]; |
385 | #define PIXEL33_11 hq4x_Interp1(pOut+BpL+BpL+BpL+BPP3, c[5], c[6]); |
386 | #define PIXEL33_12 hq4x_Interp1(pOut+BpL+BpL+BpL+BPP3, c[5], c[8]); |
387 | #define PIXEL33_20 hq4x_Interp2(pOut+BpL+BpL+BpL+BPP3, c[5], c[8], c[6]); |
388 | #define PIXEL33_50 hq4x_Interp5(pOut+BpL+BpL+BpL+BPP3, c[8], c[6]); |
389 | #define PIXEL33_80 hq4x_Interp8(pOut+BpL+BpL+BpL+BPP3, c[5], c[9]); |
390 | #define PIXEL33_81 hq4x_Interp8(pOut+BpL+BpL+BpL+BPP3, c[5], c[6]); |
391 | #define PIXEL33_82 hq4x_Interp8(pOut+BpL+BpL+BpL+BPP3, c[5], c[8]); |
392 | |
393 | #define HQ4X_DIFF(n, b) \ |
394 | static int Diff_##n (uint##b w1, uint##b w2) \ |
395 | { \ |
396 | int YUV1, YUV2; \ |
397 | YUV1 = RGB##n##toYUV(w1); \ |
398 | YUV2 = RGB##n##toYUV(w2); \ |
399 | return ( ( abs((YUV1 & Ymask) - (YUV2 & Ymask)) > trY ) || \ |
400 | ( abs((YUV1 & Umask) - (YUV2 & Umask)) > trU ) || \ |
401 | ( abs((YUV1 & Vmask) - (YUV2 & Vmask)) > trV ) ); \ |
402 | } |
403 | |
404 | HQ4X_DIFF(888, 32) |
405 | |
406 | #if !_16BPP_HACK |
407 | HQ4X_DIFF(444, 16) |
408 | HQ4X_DIFF(555, 16) |
409 | HQ4X_DIFF(565, 16) |
410 | |
411 | void hq4x_4444(unsigned char * pIn, unsigned char * pOut, int Xres, int Yres, int SrcPPL, int BpL) |
412 | { |
413 | #define hq4x_Interp1 hq4x_Interp1_4444 |
414 | #define hq4x_Interp2 hq4x_Interp2_4444 |
415 | #define hq4x_Interp3 hq4x_Interp3_4444 |
416 | #define hq4x_Interp4 hq4x_Interp4_4444 |
417 | #define hq4x_Interp5 hq4x_Interp5_4444 |
418 | #define hq4x_Interp6 hq4x_Interp6_4444 |
419 | #define hq4x_Interp7 hq4x_Interp7_4444 |
420 | #define hq4x_Interp8 hq4x_Interp8_4444 |
421 | #define Diff Diff_444 |
422 | #define BPP 2 |
423 | #define BPP2 4 |
424 | #define BPP3 6 |
425 | |
426 | int i, j, k; |
427 | int prevline, nextline; |
428 | uint16 w[10]; |
429 | uint16 c[10]; |
430 | |
431 | int pattern; |
432 | int flag; |
433 | |
434 | int YUV1, YUV2; |
435 | |
436 | // +----+----+----+ |
437 | // | | | | |
438 | // | w1 | w2 | w3 | |
439 | // +----+----+----+ |
440 | // | | | | |
441 | // | w4 | w5 | w6 | |
442 | // +----+----+----+ |
443 | // | | | | |
444 | // | w7 | w8 | w9 | |
445 | // +----+----+----+ |
446 | |
447 | for (j = 0; j < Yres; j++) { |
448 | if (j>0) prevline = -SrcPPL*2; else prevline = 0; |
449 | if (j<Yres-1) nextline = SrcPPL*2; else nextline = 0; |
450 | |
451 | for (i=0; i<Xres; i++) { |
452 | w[2] = *((uint16*)(pIn + prevline)); |
453 | w[5] = *((uint16*)pIn); |
454 | w[8] = *((uint16*)(pIn + nextline)); |
455 | |
456 | if (i>0) { |
457 | w[1] = *((uint16*)(pIn + prevline - 2)); |
458 | w[4] = *((uint16*)(pIn - 2)); |
459 | w[7] = *((uint16*)(pIn + nextline - 2)); |
460 | } else { |
461 | w[1] = w[2]; |
462 | w[4] = w[5]; |
463 | w[7] = w[8]; |
464 | } |
465 | |
466 | if (i<Xres-1) { |
467 | w[3] = *((uint16*)(pIn + prevline + 2)); |
468 | w[6] = *((uint16*)(pIn + 2)); |
469 | w[9] = *((uint16*)(pIn + nextline + 2)); |
470 | } else { |
471 | w[3] = w[2]; |
472 | w[6] = w[5]; |
473 | w[9] = w[8]; |
474 | } |
475 | |
476 | pattern = 0; |
477 | flag = 1; |
478 | |
479 | YUV1 = RGB444toYUV(w[5]); |
480 | |
481 | for (k=1; k<=9; k++) { |
482 | if (k==5) continue; |
483 | |
484 | if ( w[k] != w[5] ) { |
485 | YUV2 = RGB444toYUV(w[k]); |
486 | if ( ( abs((YUV1 & Ymask) - (YUV2 & Ymask)) > trY ) || |
487 | ( abs((YUV1 & Umask) - (YUV2 & Umask)) > trU ) || |
488 | ( abs((YUV1 & Vmask) - (YUV2 & Vmask)) > trV ) ) |
489 | pattern |= flag; |
490 | } |
491 | flag <<= 1; |
492 | } |
493 | |
494 | for (k=1; k<=9; k++) |
495 | c[k] = w[k]; |
496 | |
497 | #include "TextureFilters_hq4x.h" |
498 | |
499 | pIn+=2; |
500 | pOut+=8; |
501 | } |
502 | pIn += 2*(SrcPPL-Xres); |
503 | pOut+= 8*(SrcPPL-Xres); |
504 | pOut+=BpL; |
505 | pOut+=BpL; |
506 | pOut+=BpL; |
507 | } |
508 | |
509 | #undef BPP |
510 | #undef BPP2 |
511 | #undef BPP3 |
512 | #undef Diff |
513 | #undef hq4x_Interp1 |
514 | #undef hq4x_Interp2 |
515 | #undef hq4x_Interp3 |
516 | #undef hq4x_Interp4 |
517 | #undef hq4x_Interp5 |
518 | #undef hq4x_Interp6 |
519 | #undef hq4x_Interp7 |
520 | #undef hq4x_Interp8 |
521 | } |
522 | |
523 | void hq4x_1555(unsigned char * pIn, unsigned char * pOut, int Xres, int Yres, int SrcPPL, int BpL) |
524 | { |
525 | #define hq4x_Interp1 hq4x_Interp1_1555 |
526 | #define hq4x_Interp2 hq4x_Interp2_1555 |
527 | #define hq4x_Interp3 hq4x_Interp3_1555 |
528 | #define hq4x_Interp4 hq4x_Interp4_1555 |
529 | #define hq4x_Interp5 hq4x_Interp5_1555 |
530 | #define hq4x_Interp6 hq4x_Interp6_1555 |
531 | #define hq4x_Interp7 hq4x_Interp7_1555 |
532 | #define hq4x_Interp8 hq4x_Interp8_1555 |
533 | #define Diff Diff_555 |
534 | #define BPP 2 |
535 | #define BPP2 4 |
536 | #define BPP3 6 |
537 | |
538 | int i, j, k; |
539 | int prevline, nextline; |
540 | uint16 w[10]; |
541 | uint16 c[10]; |
542 | |
543 | int pattern; |
544 | int flag; |
545 | |
546 | int YUV1, YUV2; |
547 | |
548 | // +----+----+----+ |
549 | // | | | | |
550 | // | w1 | w2 | w3 | |
551 | // +----+----+----+ |
552 | // | | | | |
553 | // | w4 | w5 | w6 | |
554 | // +----+----+----+ |
555 | // | | | | |
556 | // | w7 | w8 | w9 | |
557 | // +----+----+----+ |
558 | |
559 | for (j = 0; j < Yres; j++) { |
560 | if (j>0) prevline = -SrcPPL*2; else prevline = 0; |
561 | if (j<Yres-1) nextline = SrcPPL*2; else nextline = 0; |
562 | |
563 | for (i=0; i<Xres; i++) { |
564 | w[2] = *((uint16*)(pIn + prevline)); |
565 | w[5] = *((uint16*)pIn); |
566 | w[8] = *((uint16*)(pIn + nextline)); |
567 | |
568 | if (i>0) { |
569 | w[1] = *((uint16*)(pIn + prevline - 2)); |
570 | w[4] = *((uint16*)(pIn - 2)); |
571 | w[7] = *((uint16*)(pIn + nextline - 2)); |
572 | } else { |
573 | w[1] = w[2]; |
574 | w[4] = w[5]; |
575 | w[7] = w[8]; |
576 | } |
577 | |
578 | if (i<Xres-1) { |
579 | w[3] = *((uint16*)(pIn + prevline + 2)); |
580 | w[6] = *((uint16*)(pIn + 2)); |
581 | w[9] = *((uint16*)(pIn + nextline + 2)); |
582 | } else { |
583 | w[3] = w[2]; |
584 | w[6] = w[5]; |
585 | w[9] = w[8]; |
586 | } |
587 | |
588 | pattern = 0; |
589 | flag = 1; |
590 | |
591 | YUV1 = RGB555toYUV(w[5]); |
592 | |
593 | for (k=1; k<=9; k++) { |
594 | if (k==5) continue; |
595 | |
596 | if ( w[k] != w[5] ) { |
597 | YUV2 = RGB555toYUV(w[k]); |
598 | if ( ( abs((YUV1 & Ymask) - (YUV2 & Ymask)) > trY ) || |
599 | ( abs((YUV1 & Umask) - (YUV2 & Umask)) > trU ) || |
600 | ( abs((YUV1 & Vmask) - (YUV2 & Vmask)) > trV ) ) |
601 | pattern |= flag; |
602 | } |
603 | flag <<= 1; |
604 | } |
605 | |
606 | for (k=1; k<=9; k++) |
607 | c[k] = w[k]; |
608 | |
609 | #include "TextureFilters_hq4x.h" |
610 | |
611 | pIn+=2; |
612 | pOut+=8; |
613 | } |
614 | pIn += 2*(SrcPPL-Xres); |
615 | pOut+= 8*(SrcPPL-Xres); |
616 | pOut+=BpL; |
617 | pOut+=BpL; |
618 | pOut+=BpL; |
619 | } |
620 | |
621 | #undef BPP |
622 | #undef BPP2 |
623 | #undef BPP3 |
624 | #undef Diff |
625 | #undef hq4x_Interp1 |
626 | #undef hq4x_Interp2 |
627 | #undef hq4x_Interp3 |
628 | #undef hq4x_Interp4 |
629 | #undef hq4x_Interp5 |
630 | #undef hq4x_Interp6 |
631 | #undef hq4x_Interp7 |
632 | #undef hq4x_Interp8 |
633 | } |
634 | |
635 | void hq4x_565(unsigned char * pIn, unsigned char * pOut, int Xres, int Yres, int SrcPPL, int BpL) |
636 | { |
637 | #define hq4x_Interp1 hq4x_Interp1_565 |
638 | #define hq4x_Interp2 hq4x_Interp2_565 |
639 | #define hq4x_Interp3 hq4x_Interp3_565 |
640 | #define hq4x_Interp4 hq4x_Interp4_565 |
641 | #define hq4x_Interp5 hq4x_Interp5_565 |
642 | #define hq4x_Interp6 hq4x_Interp6_565 |
643 | #define hq4x_Interp7 hq4x_Interp7_565 |
644 | #define hq4x_Interp8 hq4x_Interp8_565 |
645 | #define Diff Diff_565 |
646 | #define BPP 2 |
647 | #define BPP2 4 |
648 | #define BPP3 6 |
649 | |
650 | int i, j, k; |
651 | int prevline, nextline; |
652 | uint16 w[10]; |
653 | uint16 c[10]; |
654 | |
655 | int pattern; |
656 | int flag; |
657 | |
658 | int YUV1, YUV2; |
659 | |
660 | // +----+----+----+ |
661 | // | | | | |
662 | // | w1 | w2 | w3 | |
663 | // +----+----+----+ |
664 | // | | | | |
665 | // | w4 | w5 | w6 | |
666 | // +----+----+----+ |
667 | // | | | | |
668 | // | w7 | w8 | w9 | |
669 | // +----+----+----+ |
670 | |
671 | for (j = 0; j < Yres; j++) { |
672 | if (j>0) prevline = -SrcPPL*2; else prevline = 0; |
673 | if (j<Yres-1) nextline = SrcPPL*2; else nextline = 0; |
674 | |
675 | for (i=0; i<Xres; i++) { |
676 | w[2] = *((uint16*)(pIn + prevline)); |
677 | w[5] = *((uint16*)pIn); |
678 | w[8] = *((uint16*)(pIn + nextline)); |
679 | |
680 | if (i>0) { |
681 | w[1] = *((uint16*)(pIn + prevline - 2)); |
682 | w[4] = *((uint16*)(pIn - 2)); |
683 | w[7] = *((uint16*)(pIn + nextline - 2)); |
684 | } else { |
685 | w[1] = w[2]; |
686 | w[4] = w[5]; |
687 | w[7] = w[8]; |
688 | } |
689 | |
690 | if (i<Xres-1) { |
691 | w[3] = *((uint16*)(pIn + prevline + 2)); |
692 | w[6] = *((uint16*)(pIn + 2)); |
693 | w[9] = *((uint16*)(pIn + nextline + 2)); |
694 | } else { |
695 | w[3] = w[2]; |
696 | w[6] = w[5]; |
697 | w[9] = w[8]; |
698 | } |
699 | |
700 | pattern = 0; |
701 | flag = 1; |
702 | |
703 | YUV1 = RGB565toYUV(w[5]); |
704 | |
705 | for (k=1; k<=9; k++) { |
706 | if (k==5) continue; |
707 | |
708 | if ( w[k] != w[5] ) { |
709 | YUV2 = RGB565toYUV(w[k]); |
710 | if ( ( abs((YUV1 & Ymask) - (YUV2 & Ymask)) > trY ) || |
711 | ( abs((YUV1 & Umask) - (YUV2 & Umask)) > trU ) || |
712 | ( abs((YUV1 & Vmask) - (YUV2 & Vmask)) > trV ) ) |
713 | pattern |= flag; |
714 | } |
715 | flag <<= 1; |
716 | } |
717 | |
718 | for (k=1; k<=9; k++) |
719 | c[k] = w[k]; |
720 | |
721 | #include "TextureFilters_hq4x.h" |
722 | |
723 | pIn+=2; |
724 | pOut+=8; |
725 | } |
726 | pIn += 2*(SrcPPL-Xres); |
727 | pOut+= 8*(SrcPPL-Xres); |
728 | pOut+=BpL; |
729 | pOut+=BpL; |
730 | pOut+=BpL; |
731 | } |
732 | |
733 | #undef BPP |
734 | #undef BPP2 |
735 | #undef BPP3 |
736 | #undef Diff |
737 | #undef hq4x_Interp1 |
738 | #undef hq4x_Interp2 |
739 | #undef hq4x_Interp3 |
740 | #undef hq4x_Interp4 |
741 | #undef hq4x_Interp5 |
742 | #undef hq4x_Interp6 |
743 | #undef hq4x_Interp7 |
744 | #undef hq4x_Interp8 |
745 | } |
746 | #endif /* !_16BPP_HACK */ |
747 | |
748 | void hq4x_8888(unsigned char * pIn, unsigned char * pOut, int Xres, int Yres, int SrcPPL, int BpL) |
749 | { |
750 | #define hq4x_Interp1 hq4x_Interp1_8888 |
751 | #define hq4x_Interp2 hq4x_Interp2_8888 |
752 | #define hq4x_Interp3 hq4x_Interp3_8888 |
753 | #define hq4x_Interp4 hq4x_Interp4_8888 |
754 | #define hq4x_Interp5 hq4x_Interp5_8888 |
755 | #define hq4x_Interp6 hq4x_Interp6_8888 |
756 | #define hq4x_Interp7 hq4x_Interp7_8888 |
757 | #define hq4x_Interp8 hq4x_Interp8_8888 |
758 | #define Diff Diff_888 |
759 | #define BPP 4 |
760 | #define BPP2 8 |
761 | #define BPP3 12 |
762 | |
763 | int i, j, k; |
764 | int prevline, nextline; |
765 | uint32 w[10]; |
766 | uint32 c[10]; |
767 | |
768 | int pattern; |
769 | int flag; |
770 | |
771 | int YUV1, YUV2; |
772 | |
773 | // +----+----+----+ |
774 | // | | | | |
775 | // | w1 | w2 | w3 | |
776 | // +----+----+----+ |
777 | // | | | | |
778 | // | w4 | w5 | w6 | |
779 | // +----+----+----+ |
780 | // | | | | |
781 | // | w7 | w8 | w9 | |
782 | // +----+----+----+ |
783 | |
784 | for (j = 0; j < Yres; j++) { |
785 | if (j>0) prevline = -SrcPPL*4; else prevline = 0; |
786 | if (j<Yres-1) nextline = SrcPPL*4; else nextline = 0; |
787 | |
788 | for (i=0; i<Xres; i++) { |
789 | w[2] = *((uint32*)(pIn + prevline)); |
790 | w[5] = *((uint32*)pIn); |
791 | w[8] = *((uint32*)(pIn + nextline)); |
792 | |
793 | if (i>0) { |
794 | w[1] = *((uint32*)(pIn + prevline - 4)); |
795 | w[4] = *((uint32*)(pIn - 4)); |
796 | w[7] = *((uint32*)(pIn + nextline - 4)); |
797 | } else { |
798 | w[1] = w[2]; |
799 | w[4] = w[5]; |
800 | w[7] = w[8]; |
801 | } |
802 | |
803 | if (i<Xres-1) { |
804 | w[3] = *((uint32*)(pIn + prevline + 4)); |
805 | w[6] = *((uint32*)(pIn + 4)); |
806 | w[9] = *((uint32*)(pIn + nextline + 4)); |
807 | } else { |
808 | w[3] = w[2]; |
809 | w[6] = w[5]; |
810 | w[9] = w[8]; |
811 | } |
812 | |
813 | pattern = 0; |
814 | flag = 1; |
815 | |
816 | YUV1 = RGB888toYUV(w[5]); |
817 | |
818 | for (k=1; k<=9; k++) { |
819 | if (k==5) continue; |
820 | |
821 | if ( w[k] != w[5] ) { |
822 | YUV2 = RGB888toYUV(w[k]); |
823 | if ( ( abs((YUV1 & Ymask) - (YUV2 & Ymask)) > trY ) || |
824 | ( abs((YUV1 & Umask) - (YUV2 & Umask)) > trU ) || |
825 | ( abs((YUV1 & Vmask) - (YUV2 & Vmask)) > trV ) ) |
826 | pattern |= flag; |
827 | } |
828 | flag <<= 1; |
829 | } |
830 | |
831 | for (k=1; k<=9; k++) |
832 | c[k] = w[k]; |
833 | |
834 | #include "TextureFilters_hq4x.h" |
835 | |
836 | pIn+=4; |
837 | pOut+=16; |
838 | } |
839 | |
840 | pIn += 4*(SrcPPL-Xres); |
841 | pOut+= 16*(SrcPPL-Xres); |
842 | pOut+=BpL; |
843 | pOut+=BpL; |
844 | pOut+=BpL; |
845 | } |
846 | |
847 | #undef BPP |
848 | #undef BPP2 |
849 | #undef BPP3 |
850 | #undef Diff |
851 | #undef hq4x_Interp1 |
852 | #undef hq4x_Interp2 |
853 | #undef hq4x_Interp3 |
854 | #undef hq4x_Interp4 |
855 | #undef hq4x_Interp5 |
856 | #undef hq4x_Interp6 |
857 | #undef hq4x_Interp7 |
858 | #undef hq4x_Interp8 |
859 | } |
860 | |
861 | #if !_16BPP_HACK |
862 | void hq4x_init(void) |
863 | { |
864 | static int done = 0; |
865 | int r, g, b, Y, u, v, i, j, k; |
866 | |
867 | if (done ) return; |
868 | |
869 | for (i = 0; i < 16; i++) { |
870 | for (j = 0; j < 16; j++) { |
871 | for (k = 0; k < 16; k++) { |
872 | r = (i << 4) | i; |
873 | g = (j << 4) | j; |
874 | b = (k << 4) | k; |
875 | |
876 | /* Microsoft's RGB888->YUV conversion */ |
877 | /*Y = ((( 66 * r + 129 * g + 25 * b + 128) >> 8) + 16) & 0xFF; |
878 | u = ((( -38 * r - 74 * g + 112 * b + 128) >> 8) + 128) & 0xFF; |
879 | v = ((( 112 * r - 94 * g - 18 * b + 128) >> 8) + 128) & 0xFF;*/ |
880 | |
881 | Y = (r + g + b) >> 2; |
882 | u = 128 + ((r - b) >> 2); |
883 | v = 128 + ((-r + 2*g -b)>>3); |
884 | |
885 | RGB444toYUV[(i << 8) | (j << 4) | k] = (Y << 16) | (u << 8) | v; |
886 | } |
887 | } |
888 | } |
889 | |
890 | done = 1; |
891 | } |
892 | #endif /* !_16BPP_HACK */ |