[sdl_omap.git] / src / video / SDL_blit_0.c

/*
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997-2009 Sam Lantinga

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library 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
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    Sam Lantinga
    slouken@libsdl.org
*/
#include "SDL_config.h"

#include "SDL_video.h"
#include "SDL_blit.h"

/* Functions to blit from bitmaps to other surfaces */

static void BlitBto1(SDL_BlitInfo *info)
{
	int c;
	int width, height;
	Uint8 *src, *map, *dst;
	int srcskip, dstskip;

	/* Set up some basic variables */
	width = info->d_width;
	height = info->d_height;
	src = info->s_pixels;
	srcskip = info->s_skip;
	dst = info->d_pixels;
	dstskip = info->d_skip;
	map = info->table;
	srcskip += width-(width+7)/8;

	if ( map ) {
		while ( height-- ) {
		        Uint8 byte = 0, bit;
	    		for ( c=0; c<width; ++c ) {
				if ( (c&7) == 0 ) {
					byte = *src++;
				}
				bit = (byte&0x80)>>7;
				if ( 1 ) {
				  *dst = map[bit];
				}
				dst++;
				byte <<= 1;
			}
			src += srcskip;
			dst += dstskip;
		}
	} else {
		while ( height-- ) {
		        Uint8 byte = 0, bit;
	    		for ( c=0; c<width; ++c ) {
				if ( (c&7) == 0 ) {
					byte = *src++;
				}
				bit = (byte&0x80)>>7;
				if ( 1 ) {
				  *dst = bit;
				}
				dst++;
				byte <<= 1;
			}
			src += srcskip;
			dst += dstskip;
		}
	}
}
static void BlitBto2(SDL_BlitInfo *info)
{
	int c;
	int width, height;
	Uint8 *src;
	Uint16 *map, *dst;
	int srcskip, dstskip;

	/* Set up some basic variables */
	width = info->d_width;
	height = info->d_height;
	src = info->s_pixels;
	srcskip = info->s_skip;
	dst = (Uint16 *)info->d_pixels;
	dstskip = info->d_skip/2;
	map = (Uint16 *)info->table;
	srcskip += width-(width+7)/8;

	while ( height-- ) {
	        Uint8 byte = 0, bit;
	    	for ( c=0; c<width; ++c ) {
			if ( (c&7) == 0 ) {
				byte = *src++;
			}
			bit = (byte&0x80)>>7;
			if ( 1 ) {
				*dst = map[bit];
			}
			byte <<= 1;
			dst++;
		}
		src += srcskip;
		dst += dstskip;
	}
}
static void BlitBto3(SDL_BlitInfo *info)
{
	int c, o;
	int width, height;
	Uint8 *src, *map, *dst;
	int srcskip, dstskip;

	/* Set up some basic variables */
	width = info->d_width;
	height = info->d_height;
	src = info->s_pixels;
	srcskip = info->s_skip;
	dst = info->d_pixels;
	dstskip = info->d_skip;
	map = info->table;
	srcskip += width-(width+7)/8;

	while ( height-- ) {
	        Uint8 byte = 0, bit;
	    	for ( c=0; c<width; ++c ) {
			if ( (c&7) == 0 ) {
				byte = *src++;
			}
			bit = (byte&0x80)>>7;
			if ( 1 ) {
				o = bit * 4;
				dst[0] = map[o++];
				dst[1] = map[o++];
				dst[2] = map[o++];
			}
			byte <<= 1;
			dst += 3;
		}
		src += srcskip;
		dst += dstskip;
	}
}
static void BlitBto4(SDL_BlitInfo *info)
{
	int width, height;
	Uint8 *src;
	Uint32 *map, *dst;
	int srcskip, dstskip;
	int c;

	/* Set up some basic variables */
	width = info->d_width;
	height = info->d_height;
	src = info->s_pixels;
	srcskip = info->s_skip;
	dst = (Uint32 *)info->d_pixels;
	dstskip = info->d_skip/4;
	map = (Uint32 *)info->table;
	srcskip += width-(width+7)/8;

	while ( height-- ) {
	        Uint8 byte = 0, bit;
	    	for ( c=0; c<width; ++c ) {
			if ( (c&7) == 0 ) {
				byte = *src++;
			}
			bit = (byte&0x80)>>7;
			if ( 1 ) {
				*dst = map[bit];
			}
			byte <<= 1;
			dst++;
		}
		src += srcskip;
		dst += dstskip;
	}
}

static void BlitBto1Key(SDL_BlitInfo *info)
{
        int width = info->d_width;
	int height = info->d_height;
	Uint8 *src = info->s_pixels;
	Uint8 *dst = info->d_pixels;
	int srcskip = info->s_skip;
	int dstskip = info->d_skip;
	Uint32 ckey = info->src->colorkey;
	Uint8 *palmap = info->table;
	int c;

	/* Set up some basic variables */
	srcskip += width-(width+7)/8;

	if ( palmap ) {
		while ( height-- ) {
		        Uint8  byte = 0, bit;
	    		for ( c=0; c<width; ++c ) {
				if ( (c&7) == 0 ) {
					byte = *src++;
				}
				bit = (byte&0x80)>>7;
				if ( bit != ckey ) {
				  *dst = palmap[bit];
				}
				dst++;
				byte <<= 1;
			}
			src += srcskip;
			dst += dstskip;
		}
	} else {
		while ( height-- ) {
		        Uint8  byte = 0, bit;
	    		for ( c=0; c<width; ++c ) {
				if ( (c&7) == 0 ) {
					byte = *src++;
				}
				bit = (byte&0x80)>>7;
				if ( bit != ckey ) {
				  *dst = bit;
				}
				dst++;
				byte <<= 1;
			}
			src += srcskip;
			dst += dstskip;
		}
	}
}

static void BlitBto2Key(SDL_BlitInfo *info)
{
        int width = info->d_width;
	int height = info->d_height;
	Uint8 *src = info->s_pixels;
	Uint16 *dstp = (Uint16 *)info->d_pixels;
	int srcskip = info->s_skip;
	int dstskip = info->d_skip;
	Uint32 ckey = info->src->colorkey;
	Uint8 *palmap = info->table;
	int c;

	/* Set up some basic variables */
	srcskip += width-(width+7)/8;
	dstskip /= 2;

	while ( height-- ) {
	        Uint8 byte = 0, bit;
	    	for ( c=0; c<width; ++c ) {
			if ( (c&7) == 0 ) {
				byte = *src++;
			}
			bit = (byte&0x80)>>7;
			if ( bit != ckey ) {
				*dstp=((Uint16 *)palmap)[bit];
			}
			byte <<= 1;
			dstp++;
		}
		src += srcskip;
		dstp += dstskip;
	}
}

static void BlitBto3Key(SDL_BlitInfo *info)
{
        int width = info->d_width;
	int height = info->d_height;
	Uint8 *src = info->s_pixels;
	Uint8 *dst = info->d_pixels;
	int srcskip = info->s_skip;
	int dstskip = info->d_skip;
	Uint32 ckey = info->src->colorkey;
	Uint8 *palmap = info->table;
	int c;

	/* Set up some basic variables */
	srcskip += width-(width+7)/8;

	while ( height-- ) {
	        Uint8  byte = 0, bit;
	    	for ( c=0; c<width; ++c ) {
			if ( (c&7) == 0 ) {
				byte = *src++;
			}
			bit = (byte&0x80)>>7;
			if ( bit != ckey ) {
				SDL_memcpy(dst, &palmap[bit*4], 3);
			}
			byte <<= 1;
			dst += 3;
		}
		src += srcskip;
		dst += dstskip;
	}
}

static void BlitBto4Key(SDL_BlitInfo *info)
{
        int width = info->d_width;
	int height = info->d_height;
	Uint8 *src = info->s_pixels;
	Uint32 *dstp = (Uint32 *)info->d_pixels;
	int srcskip = info->s_skip;
	int dstskip = info->d_skip;
	Uint32 ckey = info->src->colorkey;
	Uint8 *palmap = info->table;
	int c;

	/* Set up some basic variables */
	srcskip += width-(width+7)/8;
	dstskip /= 4;

	while ( height-- ) {
	        Uint8 byte = 0, bit;
	    	for ( c=0; c<width; ++c ) {
			if ( (c&7) == 0 ) {
				byte = *src++;
			}
			bit = (byte&0x80)>>7;
			if ( bit != ckey ) {
				*dstp=((Uint32 *)palmap)[bit];
			}
			byte <<= 1;
			dstp++;
		}
		src += srcskip;
		dstp += dstskip;
	}
}

static void BlitBtoNAlpha(SDL_BlitInfo *info)
{
        int width = info->d_width;
	int height = info->d_height;
	Uint8 *src = info->s_pixels;
	Uint8 *dst = info->d_pixels;
	int srcskip = info->s_skip;
	int dstskip = info->d_skip;
	const SDL_Color *srcpal	= info->src->palette->colors;
	SDL_PixelFormat *dstfmt = info->dst;
	int  dstbpp;
	int c;
	const int A = info->src->alpha;

	/* Set up some basic variables */
	dstbpp = dstfmt->BytesPerPixel;
	srcskip += width-(width+7)/8;

	while ( height-- ) {
	        Uint8 byte = 0, bit;
	    	for ( c=0; c<width; ++c ) {
			if ( (c&7) == 0 ) {
				byte = *src++;
			}
			bit = (byte&0x80)>>7;
			if ( 1 ) {
			        Uint32 pixel;
			        unsigned sR, sG, sB;
				unsigned dR, dG, dB;
				sR = srcpal[bit].r;
				sG = srcpal[bit].g;
				sB = srcpal[bit].b;
				DISEMBLE_RGB(dst, dstbpp, dstfmt,
							pixel, dR, dG, dB);
				ALPHA_BLEND(sR, sG, sB, A, dR, dG, dB);
			  	ASSEMBLE_RGB(dst, dstbpp, dstfmt, dR, dG, dB);
			}
			byte <<= 1;
			dst += dstbpp;
		}
		src += srcskip;
		dst += dstskip;
	}
}

static void BlitBtoNAlphaKey(SDL_BlitInfo *info)
{
        int width = info->d_width;
	int height = info->d_height;
	Uint8 *src = info->s_pixels;
	Uint8 *dst = info->d_pixels;
	int srcskip = info->s_skip;
	int dstskip = info->d_skip;
	SDL_PixelFormat *srcfmt = info->src;
	SDL_PixelFormat *dstfmt = info->dst;
	const SDL_Color *srcpal	= srcfmt->palette->colors;
	int dstbpp;
	int c;
	const int A = srcfmt->alpha;
	Uint32 ckey = srcfmt->colorkey;

	/* Set up some basic variables */
	dstbpp = dstfmt->BytesPerPixel;
	srcskip += width-(width+7)/8;

	while ( height-- ) {
	        Uint8  byte = 0, bit;
	    	for ( c=0; c<width; ++c ) {
			if ( (c&7) == 0 ) {
				byte = *src++;
			}
			bit = (byte&0x80)>>7;
			if ( bit != ckey ) {
			        int sR, sG, sB;
				int dR, dG, dB;
				Uint32 pixel;
				sR = srcpal[bit].r;
				sG = srcpal[bit].g;
				sB = srcpal[bit].b;
				DISEMBLE_RGB(dst, dstbpp, dstfmt,
							pixel, dR, dG, dB);
				ALPHA_BLEND(sR, sG, sB, A, dR, dG, dB);
			  	ASSEMBLE_RGB(dst, dstbpp, dstfmt, dR, dG, dB);
			}
			byte <<= 1;
			dst += dstbpp;
		}
		src += srcskip;
		dst += dstskip;
	}
}

static SDL_loblit bitmap_blit[] = {
	NULL, BlitBto1, BlitBto2, BlitBto3, BlitBto4
};

static SDL_loblit colorkey_blit[] = {
    NULL, BlitBto1Key, BlitBto2Key, BlitBto3Key, BlitBto4Key
};

SDL_loblit SDL_CalculateBlit0(SDL_Surface *surface, int blit_index)
{
	int which;

	if ( surface->format->BitsPerPixel != 1 ) {
		/* We don't support sub 8-bit packed pixel modes */
		return NULL;
	}
	if ( surface->map->dst->format->BitsPerPixel < 8 ) {
		which = 0;
	} else {
		which = surface->map->dst->format->BytesPerPixel;
	}
	switch(blit_index) {
	case 0:			/* copy */
	    return bitmap_blit[which];

	case 1:			/* colorkey */
	    return colorkey_blit[which];

	case 2:			/* alpha */
	    return which >= 2 ? BlitBtoNAlpha : NULL;

	case 4:			/* alpha + colorkey */
	    return which >= 2 ? BlitBtoNAlphaKey : NULL;
	}
	return NULL;
}
Commit	Line	Data
e14743d1	1	/*
	2	SDL - Simple DirectMedia Layer
	3	Copyright (C) 1997-2009 Sam Lantinga
	4
	5	This library is free software; you can redistribute it and/or
	6	modify it under the terms of the GNU Lesser General Public
	7	License as published by the Free Software Foundation; either
	8	version 2.1 of the License, or (at your option) any later version.
	9
	10	This library 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 GNU
	13	Lesser General Public License for more details.
	14
	15	You should have received a copy of the GNU Lesser General Public
	16	License along with this library; if not, write to the Free Software
	17	Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	18
	19	Sam Lantinga
	20	slouken@libsdl.org
	21	*/
	22	#include "SDL_config.h"
	23
	24	#include "SDL_video.h"
	25	#include "SDL_blit.h"
	26
	27	/* Functions to blit from bitmaps to other surfaces */
	28
	29	static void BlitBto1(SDL_BlitInfo *info)
	30	{
	31	int c;
	32	int width, height;
	33	Uint8 src, map, *dst;
	34	int srcskip, dstskip;
	35
	36	/* Set up some basic variables */
	37	width = info->d_width;
	38	height = info->d_height;
	39	src = info->s_pixels;
	40	srcskip = info->s_skip;
	41	dst = info->d_pixels;
	42	dstskip = info->d_skip;
	43	map = info->table;
	44	srcskip += width-(width+7)/8;
	45
	46	if ( map ) {
	47	while ( height-- ) {
	48	Uint8 byte = 0, bit;
	49	for ( c=0; c<width; ++c ) {
	50	if ( (c&7) == 0 ) {
	51	byte = *src++;
	52	}
	53	bit = (byte&0x80)>>7;
	54	if ( 1 ) {
	55	*dst = map[bit];
	56	}
	57	dst++;
	58	byte <<= 1;
	59	}
	60	src += srcskip;
	61	dst += dstskip;
	62	}
	63	} else {
	64	while ( height-- ) {
65	Uint8 byte = 0, bit;
66	for ( c=0; c<width; ++c ) {
67	if ( (c&7) == 0 ) {
68	byte = *src++;
69	}
70	bit = (byte&0x80)>>7;
71	if ( 1 ) {
72	*dst = bit;
73	}
74	dst++;
75	byte <<= 1;
76	}
77	src += srcskip;
78	dst += dstskip;
79	}
80	}
81	}
82	static void BlitBto2(SDL_BlitInfo *info)
83	{
84	int c;
85	int width, height;
86	Uint8 *src;
87	Uint16 map, dst;
88	int srcskip, dstskip;
89
90	/* Set up some basic variables */
91	width = info->d_width;
92	height = info->d_height;
93	src = info->s_pixels;
94	srcskip = info->s_skip;
95	dst = (Uint16 *)info->d_pixels;
96	dstskip = info->d_skip/2;
97	map = (Uint16 *)info->table;
98	srcskip += width-(width+7)/8;
99
100	while ( height-- ) {
101	Uint8 byte = 0, bit;
102	for ( c=0; c<width; ++c ) {
103	if ( (c&7) == 0 ) {
104	byte = *src++;
105	}
106	bit = (byte&0x80)>>7;
107	if ( 1 ) {
108	*dst = map[bit];
109	}
110	byte <<= 1;
111	dst++;
112	}
113	src += srcskip;
114	dst += dstskip;
115	}
116	}
117	static void BlitBto3(SDL_BlitInfo *info)
118	{
119	int c, o;
120	int width, height;
121	Uint8 src, map, *dst;
122	int srcskip, dstskip;
123
124	/* Set up some basic variables */
125	width = info->d_width;
126	height = info->d_height;
127	src = info->s_pixels;
128	srcskip = info->s_skip;
129	dst = info->d_pixels;
130	dstskip = info->d_skip;
131	map = info->table;
132	srcskip += width-(width+7)/8;
133
134	while ( height-- ) {
135	Uint8 byte = 0, bit;
136	for ( c=0; c<width; ++c ) {
137	if ( (c&7) == 0 ) {
138	byte = *src++;
139	}
140	bit = (byte&0x80)>>7;
141	if ( 1 ) {
142	o = bit * 4;
143	dst[0] = map[o++];
144	dst[1] = map[o++];
145	dst[2] = map[o++];
146	}
147	byte <<= 1;
148	dst += 3;
149	}
150	src += srcskip;
151	dst += dstskip;
152	}
153	}
154	static void BlitBto4(SDL_BlitInfo *info)
155	{
156	int width, height;
157	Uint8 *src;
158	Uint32 map, dst;
159	int srcskip, dstskip;
160	int c;
161
162	/* Set up some basic variables */
163	width = info->d_width;
164	height = info->d_height;
165	src = info->s_pixels;
166	srcskip = info->s_skip;
167	dst = (Uint32 *)info->d_pixels;
168	dstskip = info->d_skip/4;
169	map = (Uint32 *)info->table;
170	srcskip += width-(width+7)/8;
171
172	while ( height-- ) {
173	Uint8 byte = 0, bit;
174	for ( c=0; c<width; ++c ) {
175	if ( (c&7) == 0 ) {
176	byte = *src++;
177	}
178	bit = (byte&0x80)>>7;
179	if ( 1 ) {
180	*dst = map[bit];
181	}
182	byte <<= 1;
183	dst++;
184	}
185	src += srcskip;
186	dst += dstskip;
187	}
188	}
189
190	static void BlitBto1Key(SDL_BlitInfo *info)
191	{
192	int width = info->d_width;
193	int height = info->d_height;
194	Uint8 *src = info->s_pixels;
195	Uint8 *dst = info->d_pixels;
196	int srcskip = info->s_skip;
197	int dstskip = info->d_skip;
198	Uint32 ckey = info->src->colorkey;
199	Uint8 *palmap = info->table;
200	int c;
201
202	/* Set up some basic variables */
203	srcskip += width-(width+7)/8;
204
205	if ( palmap ) {
206	while ( height-- ) {
207	Uint8 byte = 0, bit;
208	for ( c=0; c<width; ++c ) {
209	if ( (c&7) == 0 ) {
210	byte = *src++;
211	}
212	bit = (byte&0x80)>>7;
213	if ( bit != ckey ) {
214	*dst = palmap[bit];
215	}
216	dst++;
217	byte <<= 1;
218	}
219	src += srcskip;
220	dst += dstskip;
221	}
222	} else {
223	while ( height-- ) {
224	Uint8 byte = 0, bit;
225	for ( c=0; c<width; ++c ) {
226	if ( (c&7) == 0 ) {
227	byte = *src++;
228	}
229	bit = (byte&0x80)>>7;
230	if ( bit != ckey ) {
231	*dst = bit;
232	}
233	dst++;
234	byte <<= 1;
235	}
236	src += srcskip;
237	dst += dstskip;
238	}
239	}
240	}
241
242	static void BlitBto2Key(SDL_BlitInfo *info)
243	{
244	int width = info->d_width;
245	int height = info->d_height;
246	Uint8 *src = info->s_pixels;
247	Uint16 dstp = (Uint16 )info->d_pixels;
248	int srcskip = info->s_skip;
249	int dstskip = info->d_skip;
250	Uint32 ckey = info->src->colorkey;
251	Uint8 *palmap = info->table;
252	int c;
253
254	/* Set up some basic variables */
255	srcskip += width-(width+7)/8;
256	dstskip /= 2;
257
258	while ( height-- ) {
259	Uint8 byte = 0, bit;
260	for ( c=0; c<width; ++c ) {
261	if ( (c&7) == 0 ) {
262	byte = *src++;
263	}
264	bit = (byte&0x80)>>7;
265	if ( bit != ckey ) {
266	dstp=((Uint16 )palmap)[bit];
267	}
268	byte <<= 1;
269	dstp++;
270	}
271	src += srcskip;
272	dstp += dstskip;
273	}
274	}
275
276	static void BlitBto3Key(SDL_BlitInfo *info)
277	{
278	int width = info->d_width;
279	int height = info->d_height;
280	Uint8 *src = info->s_pixels;
281	Uint8 *dst = info->d_pixels;
282	int srcskip = info->s_skip;
283	int dstskip = info->d_skip;
284	Uint32 ckey = info->src->colorkey;
285	Uint8 *palmap = info->table;
286	int c;
287
288	/* Set up some basic variables */
289	srcskip += width-(width+7)/8;
290
291	while ( height-- ) {
292	Uint8 byte = 0, bit;
293	for ( c=0; c<width; ++c ) {
294	if ( (c&7) == 0 ) {
295	byte = *src++;
296	}
297	bit = (byte&0x80)>>7;
298	if ( bit != ckey ) {
299	SDL_memcpy(dst, &palmap[bit*4], 3);
300	}
301	byte <<= 1;
302	dst += 3;
303	}
304	src += srcskip;
305	dst += dstskip;
306	}
307	}
308
309	static void BlitBto4Key(SDL_BlitInfo *info)
310	{
311	int width = info->d_width;
312	int height = info->d_height;
313	Uint8 *src = info->s_pixels;
314	Uint32 dstp = (Uint32 )info->d_pixels;
315	int srcskip = info->s_skip;
316	int dstskip = info->d_skip;
317	Uint32 ckey = info->src->colorkey;
318	Uint8 *palmap = info->table;
319	int c;
320
321	/* Set up some basic variables */
322	srcskip += width-(width+7)/8;
323	dstskip /= 4;
324
325	while ( height-- ) {
326	Uint8 byte = 0, bit;
327	for ( c=0; c<width; ++c ) {
328	if ( (c&7) == 0 ) {
329	byte = *src++;
330	}
331	bit = (byte&0x80)>>7;
332	if ( bit != ckey ) {
333	dstp=((Uint32 )palmap)[bit];
334	}
335	byte <<= 1;
336	dstp++;
337	}
338	src += srcskip;
339	dstp += dstskip;
340	}
341	}
342
343	static void BlitBtoNAlpha(SDL_BlitInfo *info)
344	{
345	int width = info->d_width;
346	int height = info->d_height;
347	Uint8 *src = info->s_pixels;
348	Uint8 *dst = info->d_pixels;
349	int srcskip = info->s_skip;
350	int dstskip = info->d_skip;
351	const SDL_Color *srcpal = info->src->palette->colors;
352	SDL_PixelFormat *dstfmt = info->dst;
353	int dstbpp;
354	int c;
355	const int A = info->src->alpha;
356
357	/* Set up some basic variables */
358	dstbpp = dstfmt->BytesPerPixel;
359	srcskip += width-(width+7)/8;
360
361	while ( height-- ) {
362	Uint8 byte = 0, bit;
363	for ( c=0; c<width; ++c ) {
364	if ( (c&7) == 0 ) {
365	byte = *src++;
366	}
367	bit = (byte&0x80)>>7;
368	if ( 1 ) {
369	Uint32 pixel;
370	unsigned sR, sG, sB;
371	unsigned dR, dG, dB;
372	sR = srcpal[bit].r;
373	sG = srcpal[bit].g;
374	sB = srcpal[bit].b;
375	DISEMBLE_RGB(dst, dstbpp, dstfmt,
376	pixel, dR, dG, dB);
377	ALPHA_BLEND(sR, sG, sB, A, dR, dG, dB);
378	ASSEMBLE_RGB(dst, dstbpp, dstfmt, dR, dG, dB);
379	}
380	byte <<= 1;
381	dst += dstbpp;
382	}
383	src += srcskip;
384	dst += dstskip;
385	}
386	}
387
388	static void BlitBtoNAlphaKey(SDL_BlitInfo *info)
389	{
390	int width = info->d_width;
391	int height = info->d_height;
392	Uint8 *src = info->s_pixels;
393	Uint8 *dst = info->d_pixels;
394	int srcskip = info->s_skip;
395	int dstskip = info->d_skip;
396	SDL_PixelFormat *srcfmt = info->src;
397	SDL_PixelFormat *dstfmt = info->dst;
398	const SDL_Color *srcpal = srcfmt->palette->colors;
399	int dstbpp;
400	int c;
401	const int A = srcfmt->alpha;
402	Uint32 ckey = srcfmt->colorkey;
403
404	/* Set up some basic variables */
405	dstbpp = dstfmt->BytesPerPixel;
406	srcskip += width-(width+7)/8;
407
408	while ( height-- ) {
409	Uint8 byte = 0, bit;
410	for ( c=0; c<width; ++c ) {
411	if ( (c&7) == 0 ) {
412	byte = *src++;
413	}
414	bit = (byte&0x80)>>7;
415	if ( bit != ckey ) {
416	int sR, sG, sB;
417	int dR, dG, dB;
418	Uint32 pixel;
419	sR = srcpal[bit].r;
420	sG = srcpal[bit].g;
421	sB = srcpal[bit].b;
422	DISEMBLE_RGB(dst, dstbpp, dstfmt,
423	pixel, dR, dG, dB);
424	ALPHA_BLEND(sR, sG, sB, A, dR, dG, dB);
425	ASSEMBLE_RGB(dst, dstbpp, dstfmt, dR, dG, dB);
426	}
427	byte <<= 1;
428	dst += dstbpp;
429	}
430	src += srcskip;
431	dst += dstskip;
432	}
433	}
434
435	static SDL_loblit bitmap_blit[] = {
436	NULL, BlitBto1, BlitBto2, BlitBto3, BlitBto4
437	};
438
439	static SDL_loblit colorkey_blit[] = {
440	NULL, BlitBto1Key, BlitBto2Key, BlitBto3Key, BlitBto4Key
441	};
442
443	SDL_loblit SDL_CalculateBlit0(SDL_Surface *surface, int blit_index)
444	{
445	int which;
446
447	if ( surface->format->BitsPerPixel != 1 ) {
448	/* We don't support sub 8-bit packed pixel modes */
449	return NULL;
450	}
451	if ( surface->map->dst->format->BitsPerPixel < 8 ) {
452	which = 0;
453	} else {
454	which = surface->map->dst->format->BytesPerPixel;
455	}
456	switch(blit_index) {
457	case 0: /* copy */
458	return bitmap_blit[which];
459
460	case 1: /* colorkey */
461	return colorkey_blit[which];
462
463	case 2: /* alpha */
464	return which >= 2 ? BlitBtoNAlpha : NULL;
465
466	case 4: /* alpha + colorkey */
467	return which >= 2 ? BlitBtoNAlphaKey : NULL;
468	}
469	return NULL;
470	}
471