86aad47b |
1 | /*************************************************************************** |
2 | * Copyright (C) 2010 PCSX4ALL Team * |
3 | * Copyright (C) 2010 Unai * |
4 | * * |
5 | * This program is free software; you can redistribute it and/or modify * |
6 | * it under the terms of the GNU General Public License as published by * |
7 | * the Free Software Foundation; either version 2 of the License, or * |
8 | * (at your option) any later version. * |
9 | * * |
10 | * This program is distributed in the hope that it will be useful, * |
11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of * |
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * |
13 | * GNU General Public License for more details. * |
14 | * * |
15 | * You should have received a copy of the GNU General Public License * |
16 | * along with this program; if not, write to the * |
17 | * Free Software Foundation, Inc., * |
18 | * 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA. * |
19 | ***************************************************************************/ |
20 | |
21 | #ifndef _INNER_BLIT_H_ |
22 | #define _INNER_BLIT_H_ |
23 | |
24 | #ifndef USE_BGR15 |
25 | #define RGB24(R,G,B) (((((R)&0xF8)<<8)|(((G)&0xFC)<<3)|(((B)&0xF8)>>3))) |
26 | #define RGB16X2(C) (((C)&(0x1f001f<<10))>>10) | (((C)&(0x1f001f<<5))<<1) | (((C)&(0x1f001f<<0))<<11) |
27 | #define RGB16(C) (((C)&(0x1f<<10))>>10) | (((C)&(0x1f<<5))<<1) | (((C)&(0x1f<<0))<<11) |
28 | #else |
29 | #define RGB24(R,G,B) ((((R)&0xF8)>>3)|(((G)&0xF8)<<2)|(((B)&0xF8)<<7)) |
30 | #endif |
31 | |
32 | /////////////////////////////////////////////////////////////////////////////// |
33 | // GPU Blitting code with rescale and interlace support. |
34 | |
030d1121 |
35 | INLINE void GPU_BlitWW(const void* src, u16* dst16, bool isRGB24) |
86aad47b |
36 | { |
37 | u32 uCount; |
030d1121 |
38 | if(!isRGB24) |
86aad47b |
39 | { |
40 | #ifndef USE_BGR15 |
41 | uCount = 20; |
42 | const u32* src32 = (const u32*) src; |
43 | u32* dst32 = (u32*)(void*) dst16; |
44 | do{ |
45 | dst32[0] = RGB16X2(src32[0]); |
46 | dst32[1] = RGB16X2(src32[1]); |
47 | dst32[2] = RGB16X2(src32[2]); |
48 | dst32[3] = RGB16X2(src32[3]); |
49 | dst32[4] = RGB16X2(src32[4]); |
50 | dst32[5] = RGB16X2(src32[5]); |
51 | dst32[6] = RGB16X2(src32[6]); |
52 | dst32[7] = RGB16X2(src32[7]); |
53 | dst32 += 8; |
54 | src32 += 8; |
55 | }while(--uCount); |
56 | #else |
57 | memcpy(dst16,src,640); |
58 | #endif |
59 | } |
60 | else |
61 | { |
62 | uCount = 20; |
63 | const u8* src8 = (const u8*)src; |
64 | do{ |
65 | dst16[ 0] = RGB24(src8[ 0], src8[ 1], src8[ 2] ); |
66 | dst16[ 1] = RGB24(src8[ 3], src8[ 4], src8[ 5] ); |
67 | dst16[ 2] = RGB24(src8[ 6], src8[ 7], src8[ 8] ); |
68 | dst16[ 3] = RGB24(src8[ 9], src8[10], src8[11] ); |
69 | dst16[ 4] = RGB24(src8[12], src8[13], src8[14] ); |
70 | dst16[ 5] = RGB24(src8[15], src8[16], src8[17] ); |
71 | dst16[ 6] = RGB24(src8[18], src8[19], src8[20] ); |
72 | dst16[ 7] = RGB24(src8[21], src8[22], src8[23] ); |
73 | |
74 | dst16[ 8] = RGB24(src8[24], src8[25], src8[26] ); |
75 | dst16[ 9] = RGB24(src8[27], src8[28], src8[29] ); |
76 | dst16[10] = RGB24(src8[30], src8[31], src8[32] ); |
77 | dst16[11] = RGB24(src8[33], src8[34], src8[35] ); |
78 | dst16[12] = RGB24(src8[36], src8[37], src8[38] ); |
79 | dst16[13] = RGB24(src8[39], src8[40], src8[41] ); |
80 | dst16[14] = RGB24(src8[42], src8[43], src8[44] ); |
81 | dst16[15] = RGB24(src8[45], src8[46], src8[47] ); |
82 | dst16 += 16; |
83 | src8 += 48; |
84 | }while(--uCount); |
85 | } |
86 | } |
87 | |
030d1121 |
88 | INLINE void GPU_BlitWWSWWSWS(const void* src, u16* dst16, bool isRGB24) |
86aad47b |
89 | { |
90 | u32 uCount; |
030d1121 |
91 | if(!isRGB24) |
86aad47b |
92 | { |
93 | #ifndef USE_BGR15 |
94 | uCount = 32; |
95 | const u16* src16 = (const u16*) src; |
96 | do{ |
97 | dst16[ 0] = RGB16(src16[0]); |
98 | dst16[ 1] = RGB16(src16[1]); |
99 | dst16[ 2] = RGB16(src16[3]); |
100 | dst16[ 3] = RGB16(src16[4]); |
101 | dst16[ 4] = RGB16(src16[6]); |
102 | dst16[ 5] = RGB16(src16[8]); |
103 | dst16[ 6] = RGB16(src16[9]); |
104 | dst16[ 7] = RGB16(src16[11]); |
105 | dst16[ 8] = RGB16(src16[12]); |
106 | dst16[ 9] = RGB16(src16[14]); |
107 | dst16 += 10; |
108 | src16 += 16; |
109 | }while(--uCount); |
110 | #else |
111 | uCount = 64; |
112 | const u16* src16 = (const u16*) src; |
113 | do{ |
114 | *dst16++ = *src16++; |
115 | *dst16++ = *src16; |
116 | src16+=2; |
117 | *dst16++ = *src16++; |
118 | *dst16++ = *src16; |
119 | src16+=2; |
120 | *dst16++ = *src16; |
121 | src16+=2; |
122 | }while(--uCount); |
123 | #endif |
124 | } |
125 | else |
126 | { |
127 | uCount = 32; |
128 | const u8* src8 = (const u8*)src; |
129 | do{ |
130 | dst16[ 0] = RGB24(src8[ 0], src8[ 1], src8[ 2] ); |
131 | dst16[ 1] = RGB24(src8[ 3], src8[ 4], src8[ 5] ); |
132 | dst16[ 2] = RGB24(src8[ 9], src8[10], src8[11] ); |
133 | dst16[ 3] = RGB24(src8[12], src8[13], src8[14] ); |
134 | dst16[ 4] = RGB24(src8[18], src8[19], src8[20] ); |
135 | |
136 | dst16[ 5] = RGB24(src8[24], src8[25], src8[26] ); |
137 | dst16[ 6] = RGB24(src8[27], src8[28], src8[29] ); |
138 | dst16[ 7] = RGB24(src8[33], src8[34], src8[35] ); |
139 | dst16[ 8] = RGB24(src8[36], src8[37], src8[38] ); |
140 | dst16[ 9] = RGB24(src8[42], src8[43], src8[44] ); |
141 | |
142 | dst16 += 10; |
143 | src8 += 48; |
144 | }while(--uCount); |
145 | } |
146 | } |
147 | |
030d1121 |
148 | INLINE void GPU_BlitWWWWWS(const void* src, u16* dst16, bool isRGB24) |
86aad47b |
149 | { |
150 | u32 uCount; |
030d1121 |
151 | if(!isRGB24) |
86aad47b |
152 | { |
153 | #ifndef USE_BGR15 |
154 | uCount = 32; |
155 | const u16* src16 = (const u16*) src; |
156 | do{ |
157 | dst16[ 0] = RGB16(src16[0]); |
158 | dst16[ 1] = RGB16(src16[1]); |
159 | dst16[ 2] = RGB16(src16[2]); |
160 | dst16[ 3] = RGB16(src16[3]); |
161 | dst16[ 4] = RGB16(src16[4]); |
162 | dst16[ 5] = RGB16(src16[6]); |
163 | dst16[ 6] = RGB16(src16[7]); |
164 | dst16[ 7] = RGB16(src16[8]); |
165 | dst16[ 8] = RGB16(src16[9]); |
166 | dst16[ 9] = RGB16(src16[10]); |
167 | dst16 += 10; |
168 | src16 += 12; |
169 | }while(--uCount); |
170 | #else |
171 | uCount = 64; |
172 | const u16* src16 = (const u16*) src; |
173 | do{ |
174 | *dst16++ = *src16++; |
175 | *dst16++ = *src16++; |
176 | *dst16++ = *src16++; |
177 | *dst16++ = *src16++; |
178 | *dst16++ = *src16; |
179 | src16+=2; |
180 | }while(--uCount); |
181 | #endif |
182 | } |
183 | else |
184 | { |
185 | uCount = 32; |
186 | const u8* src8 = (const u8*)src; |
187 | do{ |
188 | dst16[0] = RGB24(src8[ 0], src8[ 1], src8[ 2] ); |
189 | dst16[1] = RGB24(src8[ 3], src8[ 4], src8[ 5] ); |
190 | dst16[2] = RGB24(src8[ 6], src8[ 7], src8[ 8] ); |
191 | dst16[3] = RGB24(src8[ 9], src8[10], src8[11] ); |
192 | dst16[4] = RGB24(src8[12], src8[13], src8[14] ); |
193 | dst16[5] = RGB24(src8[18], src8[19], src8[20] ); |
194 | dst16[6] = RGB24(src8[21], src8[22], src8[23] ); |
195 | dst16[7] = RGB24(src8[24], src8[25], src8[26] ); |
196 | dst16[8] = RGB24(src8[27], src8[28], src8[29] ); |
197 | dst16[9] = RGB24(src8[30], src8[31], src8[32] ); |
198 | dst16 += 10; |
199 | src8 += 36; |
200 | }while(--uCount); |
201 | } |
202 | } |
203 | |
030d1121 |
204 | INLINE void GPU_BlitWWWWWWWWS(const void* src, u16* dst16, bool isRGB24, u32 uClip_src) |
86aad47b |
205 | { |
206 | u32 uCount; |
030d1121 |
207 | if(!isRGB24) |
86aad47b |
208 | { |
209 | #ifndef USE_BGR15 |
210 | uCount = 20; |
211 | const u16* src16 = ((const u16*) src) + uClip_src; |
212 | do{ |
213 | dst16[ 0] = RGB16(src16[0]); |
214 | dst16[ 1] = RGB16(src16[1]); |
215 | dst16[ 2] = RGB16(src16[2]); |
216 | dst16[ 3] = RGB16(src16[3]); |
217 | dst16[ 4] = RGB16(src16[4]); |
218 | dst16[ 5] = RGB16(src16[5]); |
219 | dst16[ 6] = RGB16(src16[6]); |
220 | dst16[ 7] = RGB16(src16[7]); |
221 | |
222 | dst16[ 8] = RGB16(src16[9]); |
223 | dst16[ 9] = RGB16(src16[10]); |
224 | dst16[10] = RGB16(src16[11]); |
225 | dst16[11] = RGB16(src16[12]); |
226 | dst16[12] = RGB16(src16[13]); |
227 | dst16[13] = RGB16(src16[14]); |
228 | dst16[14] = RGB16(src16[15]); |
229 | dst16[15] = RGB16(src16[16]); |
230 | dst16 += 16; |
231 | src16 += 18; |
232 | }while(--uCount); |
233 | #else |
234 | uCount = 40; |
235 | const u16* src16 = ((const u16*) src) + uClip_src; |
236 | do{ |
237 | *dst16++ = *src16++; |
238 | *dst16++ = *src16++; |
239 | *dst16++ = *src16++; |
240 | *dst16++ = *src16++; |
241 | *dst16++ = *src16++; |
242 | *dst16++ = *src16++; |
243 | *dst16++ = *src16++; |
244 | *dst16++ = *src16; |
245 | src16+=2; |
246 | }while(--uCount); |
247 | #endif |
248 | } |
249 | else |
250 | { |
251 | uCount = 20; |
252 | const u8* src8 = (const u8*)src + (uClip_src<<1) + uClip_src; |
253 | do{ |
254 | dst16[ 0] = RGB24(src8[ 0], src8[ 1], src8[ 2] ); |
255 | dst16[ 1] = RGB24(src8[ 3], src8[ 4], src8[ 5] ); |
256 | dst16[ 2] = RGB24(src8[ 6], src8[ 7], src8[ 8] ); |
257 | dst16[ 3] = RGB24(src8[ 9], src8[10], src8[11] ); |
258 | dst16[ 4] = RGB24(src8[12], src8[13], src8[14] ); |
259 | dst16[ 5] = RGB24(src8[15], src8[16], src8[17] ); |
260 | dst16[ 6] = RGB24(src8[18], src8[19], src8[20] ); |
261 | dst16[ 7] = RGB24(src8[21], src8[22], src8[23] ); |
262 | |
263 | dst16[ 8] = RGB24(src8[27], src8[28], src8[29] ); |
264 | dst16[ 9] = RGB24(src8[30], src8[31], src8[32] ); |
265 | dst16[10] = RGB24(src8[33], src8[34], src8[35] ); |
266 | dst16[11] = RGB24(src8[36], src8[37], src8[38] ); |
267 | dst16[12] = RGB24(src8[39], src8[40], src8[41] ); |
268 | dst16[13] = RGB24(src8[42], src8[43], src8[44] ); |
269 | dst16[14] = RGB24(src8[45], src8[46], src8[47] ); |
270 | dst16[15] = RGB24(src8[48], src8[49], src8[50] ); |
271 | dst16 += 16; |
272 | src8 += 54; |
273 | }while(--uCount); |
274 | } |
275 | } |
276 | |
030d1121 |
277 | INLINE void GPU_BlitWWDWW(const void* src, u16* dst16, bool isRGB24) |
86aad47b |
278 | { |
279 | u32 uCount; |
030d1121 |
280 | if(!isRGB24) |
86aad47b |
281 | { |
282 | #ifndef USE_BGR15 |
283 | uCount = 32; |
284 | const u16* src16 = (const u16*) src; |
285 | do{ |
286 | dst16[ 0] = RGB16(src16[0]); |
287 | dst16[ 1] = RGB16(src16[1]); |
288 | dst16[ 2] = dst16[1]; |
289 | dst16[ 3] = RGB16(src16[2]); |
290 | dst16[ 4] = RGB16(src16[3]); |
291 | dst16[ 5] = RGB16(src16[4]); |
292 | dst16[ 6] = RGB16(src16[5]); |
293 | dst16[ 7] = dst16[6]; |
294 | dst16[ 8] = RGB16(src16[6]); |
295 | dst16[ 9] = RGB16(src16[7]); |
296 | dst16 += 10; |
297 | src16 += 8; |
298 | }while(--uCount); |
299 | #else |
300 | uCount = 64; |
301 | const u16* src16 = (const u16*) src; |
302 | do{ |
303 | *dst16++ = *src16++; |
304 | *dst16++ = *src16; |
305 | *dst16++ = *src16++; |
306 | *dst16++ = *src16++; |
307 | *dst16++ = *src16++; |
308 | }while(--uCount); |
309 | #endif |
310 | } |
311 | else |
312 | { |
313 | uCount = 32; |
314 | const u8* src8 = (const u8*)src; |
315 | do{ |
316 | dst16[ 0] = RGB24(src8[0], src8[ 1], src8[ 2] ); |
317 | dst16[ 1] = RGB24(src8[3], src8[ 4], src8[ 5] ); |
318 | dst16[ 2] = dst16[1]; |
319 | dst16[ 3] = RGB24(src8[6], src8[ 7], src8[ 8] ); |
320 | dst16[ 4] = RGB24(src8[9], src8[10], src8[11] ); |
321 | |
322 | dst16[ 5] = RGB24(src8[12], src8[13], src8[14] ); |
323 | dst16[ 6] = RGB24(src8[15], src8[16], src8[17] ); |
324 | dst16[ 7] = dst16[6]; |
325 | dst16[ 8] = RGB24(src8[18], src8[19], src8[20] ); |
326 | dst16[ 9] = RGB24(src8[21], src8[22], src8[23] ); |
327 | dst16 += 10; |
328 | src8 += 24; |
329 | }while(--uCount); |
330 | } |
331 | } |
332 | |
333 | |
030d1121 |
334 | INLINE void GPU_BlitWS(const void* src, u16* dst16, bool isRGB24) |
86aad47b |
335 | { |
336 | u32 uCount; |
030d1121 |
337 | if(!isRGB24) |
86aad47b |
338 | { |
339 | #ifndef USE_BGR15 |
340 | uCount = 20; |
341 | const u16* src16 = (const u16*) src; |
342 | do{ |
343 | dst16[ 0] = RGB16(src16[0]); |
344 | dst16[ 1] = RGB16(src16[2]); |
345 | dst16[ 2] = RGB16(src16[4]); |
346 | dst16[ 3] = RGB16(src16[6]); |
347 | |
348 | dst16[ 4] = RGB16(src16[8]); |
349 | dst16[ 5] = RGB16(src16[10]); |
350 | dst16[ 6] = RGB16(src16[12]); |
351 | dst16[ 7] = RGB16(src16[14]); |
352 | |
353 | dst16[ 8] = RGB16(src16[16]); |
354 | dst16[ 9] = RGB16(src16[18]); |
355 | dst16[10] = RGB16(src16[20]); |
356 | dst16[11] = RGB16(src16[22]); |
357 | |
358 | dst16[12] = RGB16(src16[24]); |
359 | dst16[13] = RGB16(src16[26]); |
360 | dst16[14] = RGB16(src16[28]); |
361 | dst16[15] = RGB16(src16[30]); |
362 | |
363 | dst16 += 16; |
364 | src16 += 32; |
365 | }while(--uCount); |
366 | #else |
367 | uCount = 320; |
368 | const u16* src16 = (const u16*) src; |
369 | do{ |
370 | *dst16++ = *src16; src16+=2; |
371 | }while(--uCount); |
372 | #endif |
373 | } |
374 | else |
375 | { |
376 | uCount = 20; |
377 | const u8* src8 = (const u8*) src; |
378 | do{ |
379 | dst16[ 0] = RGB24(src8[ 0], src8[ 1], src8[ 2] ); |
380 | dst16[ 1] = RGB24(src8[ 6], src8[ 7], src8[ 8] ); |
381 | dst16[ 2] = RGB24(src8[12], src8[13], src8[14] ); |
382 | dst16[ 3] = RGB24(src8[18], src8[19], src8[20] ); |
383 | |
384 | dst16[ 4] = RGB24(src8[24], src8[25], src8[26] ); |
385 | dst16[ 5] = RGB24(src8[30], src8[31], src8[32] ); |
386 | dst16[ 6] = RGB24(src8[36], src8[37], src8[38] ); |
387 | dst16[ 7] = RGB24(src8[42], src8[43], src8[44] ); |
388 | |
389 | dst16[ 8] = RGB24(src8[48], src8[49], src8[50] ); |
390 | dst16[ 9] = RGB24(src8[54], src8[55], src8[56] ); |
391 | dst16[10] = RGB24(src8[60], src8[61], src8[62] ); |
392 | dst16[11] = RGB24(src8[66], src8[67], src8[68] ); |
393 | |
394 | dst16[12] = RGB24(src8[72], src8[73], src8[74] ); |
395 | dst16[13] = RGB24(src8[78], src8[79], src8[80] ); |
396 | dst16[14] = RGB24(src8[84], src8[85], src8[86] ); |
397 | dst16[15] = RGB24(src8[90], src8[91], src8[92] ); |
398 | |
399 | dst16 += 16; |
400 | src8 += 96; |
401 | }while(--uCount); |
402 | } |
403 | } |
404 | |
405 | #endif //_INNER_BLIT_H_ |