--- np2/generic/cmndraw.c	2004/03/25 10:41:13	1.6
+++ np2/generic/cmndraw.c	2004/04/08 13:51:52	1.9
@@ -48,312 +48,77 @@ void cmndraw_makegrad(RGB32 *pal, int pa
 	pal[i].d = fg.d;
 }
 
-#if defined(SUPPORT_8BPP)
-void cmndraw8_fill(const CMNVRAM *vram, int x, int y,
-										int cx, int cy, BYTE fg) {
-
-	BYTE	*p;
-	int		dalign;
-	int		r;
-
-	p = vram->ptr + (x * vram->xalign) + (y * vram->yalign);
-	dalign = vram->yalign - (vram->xalign * cx);
-	do {
-		r = cx;
-		do {
-			*p = fg;
-			p += vram->xalign;
-		} while(--r);
-		p += dalign;
-	} while(--cy);
-}
-
-void cmndraw8_setfg(const CMNVRAM *vram, const BYTE *src,
-										int x, int y, BYTE fg) {
-
-const BYTE	*p;
-	BYTE	*q;
-	BYTE	cy;
-	int		dalign;
-	BYTE	c;
-	BYTE	bit;
-	BYTE	cx;
-
-	p = src + 2;
-	q = vram->ptr + (x * vram->xalign) + (y * vram->yalign);
-	dalign = vram->yalign - (vram->xalign * src[0]);
-	cy = src[1];
-	do {
-		cx = src[0];
-		bit = 0;
-		c = 0;
-		do {
-			if (!bit) {
-				bit = 0x80;
-				c = *p++;
-			}
-			if (c & bit) {
-				*q = fg;
-			}
-			bit >>= 1;
-			q += vram->xalign;
-		} while(--cx);
-		q += dalign;
-	} while(--cy);
-}
-
-void cmndraw8_setpat(const CMNVRAM *vram, const BYTE *src,
-										int x, int y, BYTE bg, BYTE fg) {
-
-const BYTE	*p;
-	BYTE	*q;
-	BYTE	cy;
-	int		dalign;
-	BYTE	c;
-	BYTE	bit;
-	BYTE	cx;
 
-	p = src + 2;
-	q = vram->ptr + (x * vram->xalign) + (y * vram->yalign);
-	dalign = vram->yalign - (vram->xalign * src[0]);
-	cy = src[1];
-	do {
-		cx = src[0];
-		bit = 0;
-		c = 0;
-		do {
-			if (!bit) {
-				bit = 0x80;
-				c = *p++;
-			}
-			if (c & bit) {
-				*q = fg;
-			}
-			else {
-				*q = bg;
-			}
-			bit >>= 1;
-			q += vram->xalign;
-		} while(--cx);
-		q += dalign;
-	} while(--cy);
-}
-#endif
+// ----
 
-#if defined(SUPPORT_16BPP)
-void cmndraw16_fill(const CMNVRAM *vram, int x, int y,
-										int cx, int cy, UINT16 fg) {
+void cmndraw_fill(const CMNVRAM *vram, int x, int y,
+										int cx, int cy, CMNPAL fg) {
 
 	BYTE	*p;
 	int		dalign;
 	int		r;
 
+	if (vram == NULL) {
+		return;
+	}
 	p = vram->ptr + (x * vram->xalign) + (y * vram->yalign);
 	dalign = vram->yalign - (vram->xalign * cx);
-	do {
-		r = cx;
-		do {
-			*(UINT16 *)p = fg;
-			p += vram->xalign;
-		} while(--r);
-		p += dalign;
-	} while(--cy);
-}
-
-void cmndraw16_setfg(const CMNVRAM *vram, const BYTE *src,
-										int x, int y, UINT16 fg) {
-
-const BYTE	*p;
-	BYTE	*q;
-	BYTE	cy;
-	int		dalign;
-	BYTE	c;
-	BYTE	bit;
-	BYTE	cx;
-
-	p = src + 2;
-	q = vram->ptr + (x * vram->xalign) + (y * vram->yalign);
-	dalign = vram->yalign - (vram->xalign * src[0]);
-	cy = src[1];
-	do {
-		cx = src[0];
-		bit = 0;
-		c = 0;
-		do {
-			if (!bit) {
-				bit = 0x80;
-				c = *p++;
-			}
-			if (c & bit) {
-				*(UINT16 *)q = fg;
-			}
-			bit >>= 1;
-			q += vram->xalign;
-		} while(--cx);
-		q += dalign;
-	} while(--cy);
-}
-
-void cmndraw16_setpat(const CMNVRAM *vram, const BYTE *src,
-										int x, int y, UINT16 bg, UINT16 fg) {
-
-const BYTE	*p;
-	BYTE	*q;
-	BYTE	cy;
-	int		dalign;
-	BYTE	c;
-	BYTE	bit;
-	BYTE	cx;
-
-	p = src + 2;
-	q = vram->ptr + (x * vram->xalign) + (y * vram->yalign);
-	dalign = vram->yalign - (vram->xalign * src[0]);
-	cy = src[1];
-	do {
-		cx = src[0];
-		bit = 0;
-		c = 0;
-		do {
-			if (!bit) {
-				bit = 0x80;
-				c = *p++;
-			}
-			if (c & bit) {
-				*(UINT16 *)q = fg;
-			}
-			else {
-				*(UINT16 *)q = bg;
-			}
-			bit >>= 1;
-			q += vram->xalign;
-		} while(--cx);
-		q += dalign;
-	} while(--cy);
-}
+	switch(vram->bpp) {
+#if defined(SUPPORT_8BPP)
+		case 8:
+			do {
+				r = cx;
+				do {
+					*p = fg.pal8;
+					p += vram->xalign;
+				} while(--r);
+				p += dalign;
+			} while(--cy);
+			break;
+#endif
+#if defined(SUPPORT_16BPP)
+		case 16:
+			do {
+				r = cx;
+				do {
+					*(UINT16 *)p = fg.pal16;
+					p += vram->xalign;
+				} while(--r);
+				p += dalign;
+			} while(--cy);
+			break;
 #endif
-
 #if defined(SUPPORT_24BPP)
-void cmndraw24_fill(const CMNVRAM *vram, int x, int y,
-										int cx, int cy, RGB32 fg) {
-
-	BYTE	*p;
-	int		dalign;
-	int		r;
-
-	p = vram->ptr + (x * vram->xalign) + (y * vram->yalign);
-	dalign = vram->yalign - (vram->xalign * cx);
-	do {
-		r = cx;
-		do {
-			p[RGB24_R] = fg.p.r;
-			p[RGB24_G] = fg.p.g;
-			p[RGB24_B] = fg.p.b;
-			p += vram->xalign;
-		} while(--r);
-		p += dalign;
-	} while(--cy);
-}
-
-void cmndraw24_setfg(const CMNVRAM *vram, const BYTE *src,
-										int x, int y, RGB32 fg) {
-
-const BYTE	*p;
-	BYTE	*q;
-	BYTE	cy;
-	int		dalign;
-	BYTE	c;
-	BYTE	bit;
-	BYTE	cx;
-
-	p = src + 2;
-	q = vram->ptr + (x * vram->xalign) + (y * vram->yalign);
-	dalign = vram->yalign - (vram->xalign * src[0]);
-	cy = src[1];
-	do {
-		cx = src[0];
-		bit = 0;
-		c = 0;
-		do {
-			if (!bit) {
-				bit = 0x80;
-				c = *p++;
-			}
-			if (c & bit) {
-				q[RGB24_R] = fg.p.r;
-				q[RGB24_G] = fg.p.g;
-				q[RGB24_B] = fg.p.b;
-			}
-			bit >>= 1;
-			q += vram->xalign;
-		} while(--cx);
-		q += dalign;
-	} while(--cy);
-}
-
-void cmndraw24_setpat(const CMNVRAM *vram, const BYTE *src,
-										int x, int y, RGB32 bg, RGB32 fg) {
-
-const BYTE	*p;
-	BYTE	*q;
-	BYTE	cy;
-	int		dalign;
-	BYTE	c;
-	BYTE	bit;
-	BYTE	cx;
-
-	p = src + 2;
-	q = vram->ptr + (x * vram->xalign) + (y * vram->yalign);
-	dalign = vram->yalign - (vram->xalign * src[0]);
-	cy = src[1];
-	do {
-		cx = src[0];
-		bit = 0;
-		c = 0;
-		do {
-			if (!bit) {
-				bit = 0x80;
-				c = *p++;
-			}
-			if (c & bit) {
-				q[RGB24_R] = fg.p.r;
-				q[RGB24_G] = fg.p.g;
-				q[RGB24_B] = fg.p.b;
-			}
-			else {
-				q[RGB24_R] = bg.p.r;
-				q[RGB24_G] = bg.p.g;
-				q[RGB24_B] = bg.p.b;
-			}
-			bit >>= 1;
-			q += vram->xalign;
-		} while(--cx);
-		q += dalign;
-	} while(--cy);
-}
+		case 24:
+			do {
+				r = cx;
+				do {
+					p[RGB24_R] = fg.pal32.p.r;
+					p[RGB24_G] = fg.pal32.p.g;
+					p[RGB24_B] = fg.pal32.p.b;
+					p += vram->xalign;
+				} while(--r);
+				p += dalign;
+			} while(--cy);
+			break;
 #endif
-
 #if defined(SUPPORT_32BPP)
-void cmndraw32_fill(const CMNVRAM *vram, int x, int y,
-										int cx, int cy, RGB32 fg) {
-
-	BYTE	*p;
-	int		dalign;
-	int		r;
-
-	p = vram->ptr + (x * vram->xalign) + (y * vram->yalign);
-	dalign = vram->yalign - (vram->xalign * cx);
-	do {
-		r = cx;
-		do {
-			*(UINT32 *)p = fg.d;
-			p += vram->xalign;
-		} while(--r);
-		p += dalign;
-	} while(--cy);
+		case 32:
+			do {
+				r = cx;
+				do {
+					*(UINT32 *)p = fg.pal32.d;
+					p += vram->xalign;
+				} while(--r);
+				p += dalign;
+			} while(--cy);
+			break;
+#endif
+	}
 }
 
-void cmndraw32_setfg(const CMNVRAM *vram, const BYTE *src,
-										int x, int y, RGB32 fg) {
+void cmndraw_setfg(const CMNVRAM *vram, const BYTE *src,
+										int x, int y, CMNPAL fg) {
 
 const BYTE	*p;
 	BYTE	*q;
@@ -363,6 +128,9 @@ const BYTE	*p;
 	BYTE	bit;
 	BYTE	cx;
 
+	if (vram == NULL) {
+		return;
+	}
 	p = src + 2;
 	q = vram->ptr + (x * vram->xalign) + (y * vram->yalign);
 	dalign = vram->yalign - (vram->xalign * src[0]);
@@ -371,23 +139,76 @@ const BYTE	*p;
 		cx = src[0];
 		bit = 0;
 		c = 0;
-		do {
-			if (!bit) {
-				bit = 0x80;
-				c = *p++;
-			}
-			if (c & bit) {
-				*(UINT32 *)q = fg.d;
-			}
-			bit >>= 1;
-			q += vram->xalign;
-		} while(--cx);
+		switch(vram->bpp) {
+#if defined(SUPPORT_8BPP)
+			case 8:
+				do {
+					if (!bit) {
+						bit = 0x80;
+						c = *p++;
+					}
+					if (c & bit) {
+						*q = fg.pal8;
+					}
+					bit >>= 1;
+					q += vram->xalign;
+				} while(--cx);
+				break;
+#endif
+#if defined(SUPPORT_16BPP)
+			case 16:
+				do {
+					if (!bit) {
+						bit = 0x80;
+						c = *p++;
+					}
+					if (c & bit) {
+						*(UINT16 *)q = fg.pal16;
+					}
+					bit >>= 1;
+					q += vram->xalign;
+				} while(--cx);
+				break;
+#endif
+#if defined(SUPPORT_24BPP)
+			case 24:
+				do {
+					if (!bit) {
+						bit = 0x80;
+						c = *p++;
+					}
+					if (c & bit) {
+						q[RGB24_R] = fg.pal32.p.r;
+						q[RGB24_G] = fg.pal32.p.g;
+						q[RGB24_B] = fg.pal32.p.b;
+					}
+					bit >>= 1;
+					q += vram->xalign;
+				} while(--cx);
+				break;
+#endif
+#if defined(SUPPORT_32BPP)
+			case 32:
+				do {
+					if (!bit) {
+						bit = 0x80;
+						c = *p++;
+					}
+					if (c & bit) {
+						*(UINT32 *)q = fg.pal32.d;
+					}
+					bit >>= 1;
+					q += vram->xalign;
+				} while(--cx);
+				break;
+#endif
+		}
 		q += dalign;
 	} while(--cy);
 }
 
-void cmndraw32_setpat(const CMNVRAM *vram, const BYTE *src,
-										int x, int y, RGB32 bg, RGB32 fg) {
+void cmndraw_setpat(const CMNVRAM *vram, const BYTE *src,
+										int x, int y, CMNPAL bg, CMNPAL fg) {
 
 const BYTE	*p;
 	BYTE	*q;
@@ -405,65 +226,98 @@ const BYTE	*p;
 		cx = src[0];
 		bit = 0;
 		c = 0;
-		do {
-			if (!bit) {
-				bit = 0x80;
-				c = *p++;
-			}
-			if (c & bit) {
-				*(UINT32 *)q = fg.d;
-			}
-			else {
-				*(UINT32 *)q = bg.d;
-			}
-			bit >>= 1;
-			q += vram->xalign;
-		} while(--cx);
-		q += dalign;
-	} while(--cy);
-}
-#endif
-
-
-
-// ----
-
-void cmddraw_fill(CMNVRAM *vram, int x, int y, int cx, int cy, CMNPALS *pal) {
-
-	if ((vram == NULL) || (pal == NULL)) {
-		return;
-	}
-	switch(vram->bpp) {
+		switch(vram->bpp) {
 #if defined(SUPPORT_8BPP)
-		case 8:
-			cmndraw8_fill(vram, x, y, cx, cy, pal->pal8);
-			break;
+			case 8:
+				do {
+					if (!bit) {
+						bit = 0x80;
+						c = *p++;
+					}
+					if (c & bit) {
+						*q = fg.pal8;
+					}
+					else {
+						*q = bg.pal8;
+					}
+					bit >>= 1;
+					q += vram->xalign;
+				} while(--cx);
+				break;
 #endif
 #if defined(SUPPORT_16BPP)
-		case 16:
-			cmndraw16_fill(vram, x, y, cx, cy, pal->pal16);
-			break;
+			case 16:
+				do {
+					if (!bit) {
+						bit = 0x80;
+						c = *p++;
+					}
+					if (c & bit) {
+						*(UINT16 *)q = fg.pal16;
+					}
+					else {
+						*(UINT16 *)q = bg.pal16;
+					}
+					bit >>= 1;
+					q += vram->xalign;
+				} while(--cx);
+				break;
 #endif
 #if defined(SUPPORT_24BPP)
-		case 24:
-			cmndraw24_fill(vram, x, y, cx, cy, pal->pal32);
-			break;
+			case 24:
+				do {
+					if (!bit) {
+						bit = 0x80;
+						c = *p++;
+					}
+					if (c & bit) {
+						q[RGB24_R] = fg.pal32.p.r;
+						q[RGB24_G] = fg.pal32.p.g;
+						q[RGB24_B] = fg.pal32.p.b;
+					}
+					else {
+						q[RGB24_R] = bg.pal32.p.r;
+						q[RGB24_G] = bg.pal32.p.g;
+						q[RGB24_B] = bg.pal32.p.b;
+					}
+					bit >>= 1;
+					q += vram->xalign;
+				} while(--cx);
+				break;
 #endif
 #if defined(SUPPORT_32BPP)
-		case 32:
-			cmndraw32_fill(vram, x, y, cx, cy, pal->pal32);
-			break;
+			case 32:
+				do {
+					if (!bit) {
+						bit = 0x80;
+						c = *p++;
+					}
+					if (c & bit) {
+						*(UINT32 *)q = fg.pal32.d;
+					}
+					else {
+						*(UINT32 *)q = bg.pal32.d;
+					}
+					bit >>= 1;
+					q += vram->xalign;
+				} while(--cx);
+				break;
 #endif
-	}
+		}
+		q += dalign;
+	} while(--cy);
 }
 
-void cmddraw_text8(CMNVRAM *vram, int x, int y, const char *str, CMNPALS *pal) {
+
+// ----
+
+void cmddraw_text8(CMNVRAM *vram, int x, int y, const char *str, CMNPAL fg) {
 
 	UINT	s;
 const BYTE	*ptr;
 	BYTE	src[10];
 
-	if ((vram == NULL) || (str == NULL) || (pal == NULL)) {
+	if ((vram == NULL) || (str == NULL)) {
 		return;
 	}
 	src[0] = 0;
@@ -482,28 +336,7 @@ const BYTE	*ptr;
 		}
 		src[0] = ptr[0];
 		CopyMemory(src + 2, ptr + 1, 7);
-		switch(vram->bpp) {
-#if defined(SUPPORT_8BPP)
-			case 8:
-				cmndraw8_setfg(vram, src, x, y, pal->pal8);
-				break;
-#endif
-#if defined(SUPPORT_16BPP)
-			case 16:
-				cmndraw16_setfg(vram, src, x, y, pal->pal16);
-				break;
-#endif
-#if defined(SUPPORT_24BPP)
-			case 24:
-				cmndraw24_setfg(vram, src, x, y, pal->pal32);
-				break;
-#endif
-#if defined(SUPPORT_32BPP)
-			case 32:
-				cmndraw32_setfg(vram, src, x, y, pal->pal32);
-				break;
-#endif
-		}
+		cmndraw_setfg(vram, src, x, y, fg);
 		x += ptr[0] + 1;
 	}
 }
@@ -511,7 +344,7 @@ const BYTE	*ptr;
 
 // ---- bmp
 
-void cmddraw_bmp16(CMNVRAM *vram, const void *bmp, CMNPALCNV cnv, UINT flag) {
+BOOL cmndraw_bmp4inf(CMNBMP *bmp, const void *ptr) {
 
 const BMPFILE	*bf;
 const BMPINFO	*bi;
@@ -521,69 +354,86 @@ const BYTE		*palptr;
 	int			bmpalign;
 	UINT		pals;
 	UINT		c;
-	RGB32		paltbl[16];
-	CMNPAL		pal[16];
-	BYTE		*dst;
-	int			yalign;
-	int			x;
-	int			y;
 
-	if ((vram == NULL) || (bmp == NULL) || (cnv == NULL)) {
-		return;
+	if ((bmp == NULL) || (ptr == NULL)) {
+		return(FAILURE);
 	}
-	bf = (BMPFILE *)bmp;
+	bf = (BMPFILE *)ptr;
 	bi = (BMPINFO *)(bf + 1);
 	palptr = (BYTE *)(bi + 1);
 	if (((bf->bfType[0] != 'B') && (bf->bfType[1] != 'M')) ||
 		(bmpdata_getinfo(bi, &inf) != SUCCESS) || (inf.bpp != 4)) {
-		return;
+		return(FAILURE);
 	}
+	pals = min(LOADINTELDWORD(bi->biClrUsed), 16);
+
 	src = (BYTE *)bf + (LOADINTELDWORD(bf->bfOffBits));
 	bmpalign = bmpdata_getalign(bi);
 	if (inf.height > 0) {
-		src += (inf.height - 1) * bmpalign;
-		bmpalign *= -1;
+		bmp->ptr = src + ((inf.height - 1) * bmpalign);
+		bmp->width = inf.width;
+		bmp->height = inf.height;
+		bmp->align = bmpalign * -1;
 	}
 	else {
-		inf.height *= -1;
+		bmp->ptr = src;
+		bmp->width = inf.width;
+		bmp->height = inf.height * -1;
+		bmp->align = bmpalign;
 	}
-	if ((vram->width < inf.width) || (vram->height < inf.height)) {
-		return;
-	}
-	pals = LOADINTELDWORD(bi->biClrUsed);
-	pals = min(pals, 16);
-	ZeroMemory(paltbl, sizeof(paltbl));
+	bmp->pals = pals;
+	ZeroMemory(bmp->paltbl, sizeof(bmp->paltbl));
 	for (c=0; c<pals; c++) {
-		paltbl[c].p.b = palptr[c*4+0];
-		paltbl[c].p.g = palptr[c*4+1];
-		paltbl[c].p.r = palptr[c*4+2];
+		bmp->paltbl[c].p.b = palptr[c*4+0];
+		bmp->paltbl[c].p.g = palptr[c*4+1];
+		bmp->paltbl[c].p.r = palptr[c*4+2];
+	}
+	return(SUCCESS);
+}
+
+void cmndraw_bmp16(CMNVRAM *vram, const void *ptr, CMNPALCNV cnv, UINT flag) {
+
+	CMNBMP	bmp;
+	CMNPAL	pal[16];
+	BYTE	*src;
+	BYTE	*dst;
+	int		yalign;
+	int		x;
+	int		y;
+	UINT	c;
+
+	if ((vram == NULL) || (cnv == NULL) ||
+		(cmndraw_bmp4inf(&bmp, ptr) != SUCCESS) ||
+		(vram->width < bmp.width) || (vram->height < bmp.height)) {
+		return;
 	}
-	(*cnv)(pal, paltbl, pals, vram->bpp);
+	(*cnv)(pal, bmp.paltbl, bmp.pals, vram->bpp);
+	src = bmp.ptr;
 	dst = vram->ptr;
 	switch(flag & 0x03) {
 		case CMNBMP_CENTER:
-			dst += ((vram->width - inf.width) / 2) * vram->xalign;
+			dst += ((vram->width - bmp.width) / 2) * vram->xalign;
 			break;
 
 		case CMNBMP_RIGHT:
-			dst += (vram->width - inf.width) * vram->xalign;
+			dst += (vram->width - bmp.width) * vram->xalign;
 			break;
 	}
 	switch(flag & 0x0c) {
 		case CMNBMP_MIDDLE:
-			dst += ((vram->height - inf.height) / 2) * vram->yalign;
+			dst += ((vram->height - bmp.height) / 2) * vram->yalign;
 			break;
 
 		case CMNBMP_BOTTOM:
-			dst += (vram->height - inf.height) * vram->yalign;
+			dst += (vram->height - bmp.height) * vram->yalign;
 			break;
 	}
-	yalign = vram->yalign - (inf.width * vram->xalign);
-	switch(vram->bpp) {
+	yalign = vram->yalign - (bmp.width * vram->xalign);
+	for (y=0; y<bmp.height; y++) {
+		switch(vram->bpp) {
 #if defined(SUPPORT_8BPP)
-		case 8:
-			for (y=0; y<inf.height; y++) {
-				for (x=0; x<inf.width; x++) {
+			case 8:
+				for (x=0; x<bmp.width; x++) {
 					if (!(x & 1)) {
 						c = src[x >> 1] >> 4;
 					}
@@ -593,15 +443,11 @@ const BYTE		*palptr;
 					*dst = pal[c].pal8;
 					dst += vram->xalign;
 				}
-				src += bmpalign;
-				dst += yalign;
-			}
-			break;
+				break;
 #endif
 #if defined(SUPPORT_16BPP)
-		case 16:
-			for (y=0; y<inf.height; y++) {
-				for (x=0; x<inf.width; x++) {
+			case 16:
+				for (x=0; x<bmp.width; x++) {
 					if (!(x & 1)) {
 						c = src[x >> 1] >> 4;
 					}
@@ -611,15 +457,11 @@ const BYTE		*palptr;
 					*(UINT16 *)dst = pal[c].pal16;
 					dst += vram->xalign;
 				}
-				src += bmpalign;
-				dst += yalign;
-			}
-			break;
+				break;
 #endif
 #if defined(SUPPORT_24BPP)
-		case 24:
-			for (y=0; y<inf.height; y++) {
-				for (x=0; x<inf.width; x++) {
+			case 24:
+				for (x=0; x<bmp.width; x++) {
 					if (!(x & 1)) {
 						c = src[x >> 1] >> 4;
 					}
@@ -631,15 +473,11 @@ const BYTE		*palptr;
 					dst[RGB24_B] = pal[c].pal32.p.b;
 					dst += vram->xalign;
 				}
-				src += bmpalign;
-				dst += yalign;
-			}
-			break;
+				break;
 #endif
 #if defined(SUPPORT_32BPP)
-		case 32:
-			for (y=0; y<inf.height; y++) {
-				for (x=0; x<inf.width; x++) {
+			case 32:
+				for (x=0; x<bmp.width; x++) {
 					if (!(x & 1)) {
 						c = src[x >> 1] >> 4;
 					}
@@ -649,11 +487,11 @@ const BYTE		*palptr;
 					*(UINT32 *)dst = pal[c].pal32.d;
 					dst += vram->xalign;
 				}
-				src += bmpalign;
-				dst += yalign;
-			}
-			break;
+				break;
 #endif
+		}
+		src += bmp.align;
+		dst += yalign;
 	}
 }