[pcsx_rearmed.git] / plugins / gpu_unai / gpu_blit.h

/***************************************************************************
*   Copyright (C) 2010 PCSX4ALL Team                                      *
*   Copyright (C) 2010 Unai                                               *
*                                                                         *
*   This program is free software; you can redistribute it and/or modify  *
*   it under the terms of the GNU General Public License as published by  *
*   the Free Software Foundation; either version 2 of the License, or     *
*   (at your option) any later version.                                   *
*                                                                         *
*   This program is distributed in the hope that it will be useful,       *
*   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
*   GNU General Public License for more details.                          *
*                                                                         *
*   You should have received a copy of the GNU General Public License     *
*   along with this program; if not, write to the                         *
*   Free Software Foundation, Inc.,                                       *
*   51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA.           *
***************************************************************************/

#ifndef _INNER_BLIT_H_
#define _INNER_BLIT_H_

#ifndef USE_BGR15
#define RGB24(R,G,B)	(((((R)&0xF8)<<8)|(((G)&0xFC)<<3)|(((B)&0xF8)>>3)))
#define RGB16X2(C)      (((C)&(0x1f001f<<10))>>10) | (((C)&(0x1f001f<<5))<<1) | (((C)&(0x1f001f<<0))<<11)
#define RGB16(C)		(((C)&(0x1f<<10))>>10) | (((C)&(0x1f<<5))<<1) | (((C)&(0x1f<<0))<<11)
#else
#define RGB24(R,G,B)  	((((R)&0xF8)>>3)|(((G)&0xF8)<<2)|(((B)&0xF8)<<7))
#endif

///////////////////////////////////////////////////////////////////////////////
//  GPU Blitting code with rescale and interlace support.

INLINE void GPU_BlitWW(const void* src, u16* dst16, u32 isRGB24)
{
	u32 uCount;
	if(isRGB24 == 0)
	{
		#ifndef USE_BGR15
			uCount = 20;
			const u32* src32 = (const u32*) src; 
			u32* dst32 = (u32*)(void*) dst16;
			do{
				dst32[0] = RGB16X2(src32[0]);
				dst32[1] = RGB16X2(src32[1]);
				dst32[2] = RGB16X2(src32[2]);
				dst32[3] = RGB16X2(src32[3]);
				dst32[4] = RGB16X2(src32[4]);
				dst32[5] = RGB16X2(src32[5]);
				dst32[6] = RGB16X2(src32[6]);
				dst32[7] = RGB16X2(src32[7]);
				dst32 += 8;
				src32 += 8;
			}while(--uCount);
		#else
			memcpy(dst16,src,640);
		#endif
	}
	else
	{
		uCount = 20;
		const u8* src8 = (const u8*)src;
		do{
			dst16[ 0] = RGB24(src8[ 0], src8[ 1], src8[ 2] );
			dst16[ 1] = RGB24(src8[ 3], src8[ 4], src8[ 5] );
			dst16[ 2] = RGB24(src8[ 6], src8[ 7], src8[ 8] );
			dst16[ 3] = RGB24(src8[ 9], src8[10], src8[11] );
			dst16[ 4] = RGB24(src8[12], src8[13], src8[14] );
			dst16[ 5] = RGB24(src8[15], src8[16], src8[17] );
			dst16[ 6] = RGB24(src8[18], src8[19], src8[20] );
			dst16[ 7] = RGB24(src8[21], src8[22], src8[23] );

			dst16[ 8] = RGB24(src8[24], src8[25], src8[26] );
			dst16[ 9] = RGB24(src8[27], src8[28], src8[29] );
			dst16[10] = RGB24(src8[30], src8[31], src8[32] );
			dst16[11] = RGB24(src8[33], src8[34], src8[35] );
			dst16[12] = RGB24(src8[36], src8[37], src8[38] );
			dst16[13] = RGB24(src8[39], src8[40], src8[41] );
			dst16[14] = RGB24(src8[42], src8[43], src8[44] );
			dst16[15] = RGB24(src8[45], src8[46], src8[47] );
			dst16 += 16;
			src8  += 48;
		}while(--uCount);
	}
}

INLINE void GPU_BlitWWSWWSWS(const void* src, u16* dst16, u32 isRGB24)
{
	u32 uCount;
	if(isRGB24 == 0)
	{
		#ifndef USE_BGR15
			uCount = 32;
			const u16* src16 = (const u16*) src; 
			do{
				dst16[ 0] = RGB16(src16[0]);
				dst16[ 1] = RGB16(src16[1]);
				dst16[ 2] = RGB16(src16[3]);
				dst16[ 3] = RGB16(src16[4]);
				dst16[ 4] = RGB16(src16[6]);
				dst16[ 5] = RGB16(src16[8]);
				dst16[ 6] = RGB16(src16[9]);
				dst16[ 7] = RGB16(src16[11]);
				dst16[ 8] = RGB16(src16[12]);
				dst16[ 9] = RGB16(src16[14]);
				dst16 += 10;
				src16 += 16;
			}while(--uCount);
		#else
			uCount = 64;
			const u16* src16 = (const u16*) src; 
			do{
				*dst16++ = *src16++;
				*dst16++ = *src16;
				src16+=2;
				*dst16++ = *src16++;
				*dst16++ = *src16;
				src16+=2;
				*dst16++ = *src16;
				src16+=2;
			}while(--uCount);
		#endif
	}
	else
	{
		uCount = 32;
		const u8* src8 = (const u8*)src;
		do{
			dst16[ 0] = RGB24(src8[ 0], src8[ 1], src8[ 2] );
			dst16[ 1] = RGB24(src8[ 3], src8[ 4], src8[ 5] );
			dst16[ 2] = RGB24(src8[ 9], src8[10], src8[11] );
			dst16[ 3] = RGB24(src8[12], src8[13], src8[14] );
			dst16[ 4] = RGB24(src8[18], src8[19], src8[20] );

			dst16[ 5] = RGB24(src8[24], src8[25], src8[26] );
			dst16[ 6] = RGB24(src8[27], src8[28], src8[29] );
			dst16[ 7] = RGB24(src8[33], src8[34], src8[35] );
			dst16[ 8] = RGB24(src8[36], src8[37], src8[38] );
			dst16[ 9] = RGB24(src8[42], src8[43], src8[44] );

			dst16 += 10;
			src8  += 48;
		}while(--uCount);
	}
}

INLINE void GPU_BlitWWWWWS(const void* src, u16* dst16, u32 isRGB24)
{
	u32 uCount;
	if(isRGB24 == 0)
	{
		#ifndef USE_BGR15
			uCount = 32;
			const u16* src16 = (const u16*) src; 
			do{
				dst16[ 0] = RGB16(src16[0]);
				dst16[ 1] = RGB16(src16[1]);
				dst16[ 2] = RGB16(src16[2]);
				dst16[ 3] = RGB16(src16[3]);
				dst16[ 4] = RGB16(src16[4]);
				dst16[ 5] = RGB16(src16[6]);
				dst16[ 6] = RGB16(src16[7]);
				dst16[ 7] = RGB16(src16[8]);
				dst16[ 8] = RGB16(src16[9]);
				dst16[ 9] = RGB16(src16[10]);
				dst16 += 10;
				src16 += 12;
			}while(--uCount);
		#else
			uCount = 64;
			const u16* src16 = (const u16*) src; 
			do{
				*dst16++ = *src16++;
				*dst16++ = *src16++;
				*dst16++ = *src16++;
				*dst16++ = *src16++;
				*dst16++ = *src16;
				src16+=2;
			}while(--uCount);
		#endif
	}
	else
	{
		uCount = 32;
		const u8* src8 = (const u8*)src;
		do{
			dst16[0] = RGB24(src8[ 0], src8[ 1], src8[ 2] );
			dst16[1] = RGB24(src8[ 3], src8[ 4], src8[ 5] );
			dst16[2] = RGB24(src8[ 6], src8[ 7], src8[ 8] );
			dst16[3] = RGB24(src8[ 9], src8[10], src8[11] );
			dst16[4] = RGB24(src8[12], src8[13], src8[14] );
			dst16[5] = RGB24(src8[18], src8[19], src8[20] );
			dst16[6] = RGB24(src8[21], src8[22], src8[23] );
			dst16[7] = RGB24(src8[24], src8[25], src8[26] );
			dst16[8] = RGB24(src8[27], src8[28], src8[29] );
			dst16[9] = RGB24(src8[30], src8[31], src8[32] );
			dst16 += 10;
			src8  += 36;
		}while(--uCount);
	}
}

INLINE void GPU_BlitWWWWWWWWS(const void* src, u16* dst16, u32 isRGB24, u32 uClip_src)
{
	u32 uCount;
	if(isRGB24 == 0)
	{
		#ifndef USE_BGR15
			uCount = 20;
			const u16* src16 = ((const u16*) src) + uClip_src; 
			do{
				dst16[ 0] = RGB16(src16[0]);
				dst16[ 1] = RGB16(src16[1]);
				dst16[ 2] = RGB16(src16[2]);
				dst16[ 3] = RGB16(src16[3]);
				dst16[ 4] = RGB16(src16[4]);
				dst16[ 5] = RGB16(src16[5]);
				dst16[ 6] = RGB16(src16[6]);
				dst16[ 7] = RGB16(src16[7]);

				dst16[ 8] = RGB16(src16[9]);
				dst16[ 9] = RGB16(src16[10]);
				dst16[10] = RGB16(src16[11]);
				dst16[11] = RGB16(src16[12]);
				dst16[12] = RGB16(src16[13]);
				dst16[13] = RGB16(src16[14]);
				dst16[14] = RGB16(src16[15]);
				dst16[15] = RGB16(src16[16]);
				dst16 += 16;
				src16 += 18;
			}while(--uCount);
		#else
			uCount = 40;
			const u16* src16 = ((const u16*) src) + uClip_src; 
			do{
				*dst16++ = *src16++;
				*dst16++ = *src16++;
				*dst16++ = *src16++;
				*dst16++ = *src16++;
				*dst16++ = *src16++;
				*dst16++ = *src16++;
				*dst16++ = *src16++;
				*dst16++ = *src16;
				src16+=2;
			}while(--uCount);
		#endif
	}
	else
	{
		uCount = 20;
		const u8* src8 = (const u8*)src + (uClip_src<<1) + uClip_src;
		do{
			dst16[ 0] = RGB24(src8[ 0], src8[ 1], src8[ 2] );
			dst16[ 1] = RGB24(src8[ 3], src8[ 4], src8[ 5] );
			dst16[ 2] = RGB24(src8[ 6], src8[ 7], src8[ 8] );
			dst16[ 3] = RGB24(src8[ 9], src8[10], src8[11] );
			dst16[ 4] = RGB24(src8[12], src8[13], src8[14] );
			dst16[ 5] = RGB24(src8[15], src8[16], src8[17] );
			dst16[ 6] = RGB24(src8[18], src8[19], src8[20] );
			dst16[ 7] = RGB24(src8[21], src8[22], src8[23] );

			dst16[ 8] = RGB24(src8[27], src8[28], src8[29] );
			dst16[ 9] = RGB24(src8[30], src8[31], src8[32] );
			dst16[10] = RGB24(src8[33], src8[34], src8[35] );
			dst16[11] = RGB24(src8[36], src8[37], src8[38] );
			dst16[12] = RGB24(src8[39], src8[40], src8[41] );
			dst16[13] = RGB24(src8[42], src8[43], src8[44] );
			dst16[14] = RGB24(src8[45], src8[46], src8[47] );
			dst16[15] = RGB24(src8[48], src8[49], src8[50] );
			dst16 += 16;
			src8  += 54;
		}while(--uCount);
	}
}

INLINE void GPU_BlitWWDWW(const void* src, u16* dst16, u32 isRGB24)
{
	u32 uCount;
	if(isRGB24 == 0)
	{
		#ifndef USE_BGR15
			uCount = 32;
			const u16* src16 = (const u16*) src; 
			do{
				dst16[ 0] = RGB16(src16[0]);
				dst16[ 1] = RGB16(src16[1]);
				dst16[ 2] = dst16[1];
				dst16[ 3] = RGB16(src16[2]);
				dst16[ 4] = RGB16(src16[3]);
				dst16[ 5] = RGB16(src16[4]);
				dst16[ 6] = RGB16(src16[5]);
				dst16[ 7] = dst16[6];
				dst16[ 8] = RGB16(src16[6]);
				dst16[ 9] = RGB16(src16[7]);
				dst16 += 10;
				src16 +=  8;
			}while(--uCount);
		#else
			uCount = 64;
			const u16* src16 = (const u16*) src; 
			do{
				*dst16++ = *src16++;
				*dst16++ = *src16;
				*dst16++ = *src16++;
				*dst16++ = *src16++;
				*dst16++ = *src16++;
			}while(--uCount);
		#endif
	}
	else
	{
		uCount = 32;
		const u8* src8 = (const u8*)src;
		do{
			dst16[ 0] = RGB24(src8[0], src8[ 1], src8[ 2] );
			dst16[ 1] = RGB24(src8[3], src8[ 4], src8[ 5] );
			dst16[ 2] = dst16[1];
			dst16[ 3] = RGB24(src8[6], src8[ 7], src8[ 8] );
			dst16[ 4] = RGB24(src8[9], src8[10], src8[11] );

			dst16[ 5] = RGB24(src8[12], src8[13], src8[14] );
			dst16[ 6] = RGB24(src8[15], src8[16], src8[17] );
			dst16[ 7] = dst16[6];
			dst16[ 8] = RGB24(src8[18], src8[19], src8[20] );
			dst16[ 9] = RGB24(src8[21], src8[22], src8[23] );
			dst16 += 10;
			src8  += 24;
		}while(--uCount);
	}
}


INLINE void GPU_BlitWS(const void* src, u16* dst16, u32 isRGB24)
{
	u32 uCount;
	if(isRGB24 == 0)
	{
		#ifndef USE_BGR15
			uCount = 20;
			const u16* src16 = (const u16*) src; 
			do{
				dst16[ 0] = RGB16(src16[0]);
				dst16[ 1] = RGB16(src16[2]);
				dst16[ 2] = RGB16(src16[4]);
				dst16[ 3] = RGB16(src16[6]);

				dst16[ 4] = RGB16(src16[8]);
				dst16[ 5] = RGB16(src16[10]);
				dst16[ 6] = RGB16(src16[12]);
				dst16[ 7] = RGB16(src16[14]);

				dst16[ 8] = RGB16(src16[16]);
				dst16[ 9] = RGB16(src16[18]);
				dst16[10] = RGB16(src16[20]);
				dst16[11] = RGB16(src16[22]);

				dst16[12] = RGB16(src16[24]);
				dst16[13] = RGB16(src16[26]);
				dst16[14] = RGB16(src16[28]);
				dst16[15] = RGB16(src16[30]);

				dst16 += 16;
				src16 += 32;
			}while(--uCount);
		#else
			uCount = 320;
			const u16* src16 = (const u16*) src; 
			do{
				*dst16++ = *src16; src16+=2;
			}while(--uCount);
		#endif
	}
	else
	{
		uCount = 20;
		const u8* src8 = (const u8*) src; 
		do{
			dst16[ 0] = RGB24(src8[ 0], src8[ 1], src8[ 2] );
			dst16[ 1] = RGB24(src8[ 6], src8[ 7], src8[ 8] );
			dst16[ 2] = RGB24(src8[12], src8[13], src8[14] );
			dst16[ 3] = RGB24(src8[18], src8[19], src8[20] );

			dst16[ 4] = RGB24(src8[24], src8[25], src8[26] );
			dst16[ 5] = RGB24(src8[30], src8[31], src8[32] );
			dst16[ 6] = RGB24(src8[36], src8[37], src8[38] );
			dst16[ 7] = RGB24(src8[42], src8[43], src8[44] );

			dst16[ 8] = RGB24(src8[48], src8[49], src8[50] );
			dst16[ 9] = RGB24(src8[54], src8[55], src8[56] );
			dst16[10] = RGB24(src8[60], src8[61], src8[62] );
			dst16[11] = RGB24(src8[66], src8[67], src8[68] );

			dst16[12] = RGB24(src8[72], src8[73], src8[74] );
			dst16[13] = RGB24(src8[78], src8[79], src8[80] );
			dst16[14] = RGB24(src8[84], src8[85], src8[86] );
			dst16[15] = RGB24(src8[90], src8[91], src8[92] );

			dst16 += 16;
			src8  += 96;
		}while(--uCount);
	}
}

#endif //_INNER_BLIT_H_
Commit	Line	Data
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
	35	INLINE void GPU_BlitWW(const void* src, u16* dst16, u32 isRGB24)
	36	{
	37	u32 uCount;
	38	if(isRGB24 == 0)
	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
88	INLINE void GPU_BlitWWSWWSWS(const void* src, u16* dst16, u32 isRGB24)
89	{
90	u32 uCount;
91	if(isRGB24 == 0)
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
148	INLINE void GPU_BlitWWWWWS(const void* src, u16* dst16, u32 isRGB24)
149	{
150	u32 uCount;
151	if(isRGB24 == 0)
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
204	INLINE void GPU_BlitWWWWWWWWS(const void* src, u16* dst16, u32 isRGB24, u32 uClip_src)
205	{
206	u32 uCount;
207	if(isRGB24 == 0)
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
277	INLINE void GPU_BlitWWDWW(const void* src, u16* dst16, u32 isRGB24)
278	{
279	u32 uCount;
280	if(isRGB24 == 0)
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
334	INLINE void GPU_BlitWS(const void* src, u16* dst16, u32 isRGB24)
335	{
336	u32 uCount;
337	if(isRGB24 == 0)
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_