projects / reactos.git / blob
? search:


caf6e530cc73a4b8d9407ae81e36895c68778bf5
[reactos.git] / reactos / subsys / win32k / dib / dib4bpp.c
1 /*
2 * ReactOS W32 Subsystem
3 * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
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 Free Software
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 */
19 /* $Id$ */
20
21 #include <w32k.h>
22
23 #define NDEBUG
24 #include <debug.h>
25
26 VOID
27 DIB_4BPP_PutPixel(SURFOBJ *SurfObj, LONG x, LONG y, ULONG c)
28 {
29 PBYTE addr = (PBYTE)SurfObj->pvScan0 + (x>>1) + y * SurfObj->lDelta;
30 *addr = (*addr & notmask[x&1]) | (c << ((1-(x&1))<<2));
31 }
32
33 ULONG
34 DIB_4BPP_GetPixel(SURFOBJ *SurfObj, LONG x, LONG y)
35 {
36 PBYTE addr = (PBYTE)SurfObj->pvScan0 + (x>>1) + y * SurfObj->lDelta;
37 return (*addr >> ((1-(x&1))<<2)) & 0x0f;
38 }
39
40 VOID
41 DIB_4BPP_HLine(SURFOBJ *SurfObj, LONG x1, LONG x2, LONG y, ULONG c)
42 {
43 PBYTE addr = (PBYTE)SurfObj->pvScan0 + (x1>>1) + y * SurfObj->lDelta;
44 LONG cx = x1;
45
46 while(cx < x2) {
47 *addr = (*addr & notmask[x1&1]) | (c << ((1-(x1&1))<<2));
48 if((++x1 & 1) == 0)
49 ++addr;
50 ++cx;
51 }
52 }
53
54 VOID
55 DIB_4BPP_VLine(SURFOBJ *SurfObj, LONG x, LONG y1, LONG y2, ULONG c)
56 {
57 PBYTE addr = SurfObj->pvScan0;
58 int lDelta = SurfObj->lDelta;
59
60 addr += (x>>1) + y1 * lDelta;
61 while(y1++ < y2) {
62 *addr = (*addr & notmask[x&1]) | (c << ((1-(x&1))<<2));
63 addr += lDelta;
64 }
65 }
66
67 BOOLEAN
68 DIB_4BPP_BitBltSrcCopy(PBLTINFO BltInfo)
69 {
70 LONG i, j, sx, sy, f2, xColor;
71 PBYTE SourceBits_24BPP, SourceLine_24BPP;
72 PBYTE DestBits, DestLine, SourceBits_8BPP, SourceLine_8BPP;
73 PBYTE SourceBits, SourceLine;
74
75 DestBits = (PBYTE)BltInfo->DestSurface->pvScan0 +
76 (BltInfo->DestRect.left >> 1) +
77 BltInfo->DestRect.top * BltInfo->DestSurface->lDelta;
78
79 switch (BltInfo->SourceSurface->iBitmapFormat)
80 {
81 case BMF_1BPP:
82 sx = BltInfo->SourcePoint.x;
83 sy = BltInfo->SourcePoint.y;
84
85 for (j=BltInfo->DestRect.top; j<BltInfo->DestRect.bottom; j++)
86 {
87 sx = BltInfo->SourcePoint.x;
88 for (i=BltInfo->DestRect.left; i<BltInfo->DestRect.right; i++)
89 {
90 if(DIB_1BPP_GetPixel(BltInfo->SourceSurface, sx, sy) == 0)
91 {
92 DIB_4BPP_PutPixel(BltInfo->DestSurface, i, j, XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, 0));
93 } else {
94 DIB_4BPP_PutPixel(BltInfo->DestSurface, i, j, XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, 1));
95 }
96 sx++;
97 }
98 sy++;
99 }
100 break;
101
102 case BMF_4BPP:
103 sy = BltInfo->SourcePoint.y;
104
105 for (j=BltInfo->DestRect.top; j<BltInfo->DestRect.bottom; j++)
106 {
107 sx = BltInfo->SourcePoint.x;
108
109 for (i=BltInfo->DestRect.left; i<BltInfo->DestRect.right; i++)
110 {
111 if (NULL != BltInfo->XlateSourceToDest)
112 {
113 DIB_4BPP_PutPixel(BltInfo->DestSurface, i, j, XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, DIB_4BPP_GetPixel(BltInfo->SourceSurface, sx, sy)));
114 }
115 else
116 {
117 DIB_4BPP_PutPixel(BltInfo->DestSurface, i, j, DIB_4BPP_GetPixel(BltInfo->SourceSurface, sx, sy));
118 }
119 sx++;
120 }
121 sy++;
122 }
123 break;
124
125 case BMF_8BPP:
126 SourceBits_8BPP = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + BltInfo->SourcePoint.x;
127
128 for (j=BltInfo->DestRect.top; j<BltInfo->DestRect.bottom; j++)
129 {
130 SourceLine_8BPP = SourceBits_8BPP;
131 DestLine = DestBits;
132 f2 = BltInfo->DestRect.left & 1;
133
134 for (i=BltInfo->DestRect.left; i<BltInfo->DestRect.right; i++)
135 {
136 *DestLine = (*DestLine & notmask[f2]) |
137 ((XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, *SourceLine_8BPP)) << ((4 * (1 - f2))));
138 if(f2 == 1) { DestLine++; f2 = 0; } else { f2 = 1; }
139 SourceLine_8BPP++;
140 }
141
142 SourceBits_8BPP += BltInfo->SourceSurface->lDelta;
143 DestBits += BltInfo->DestSurface->lDelta;
144 }
145 break;
146
147 case BMF_16BPP:
148 SourceLine = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + 2 * BltInfo->SourcePoint.x;
149 DestLine = DestBits;
150
151 for (j = BltInfo->DestRect.top; j < BltInfo->DestRect.bottom; j++)
152 {
153 SourceBits = SourceLine;
154 DestBits = DestLine;
155 f2 = BltInfo->DestRect.left & 1;
156
157 for (i = BltInfo->DestRect.left; i < BltInfo->DestRect.right; i++)
158 {
159 xColor = *((PWORD) SourceBits);
160 *DestBits = (*DestBits & notmask[f2]) |
161 ((XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, xColor)) << ((4 * (1 - f2))));
162 if(f2 == 1) { DestBits++; f2 = 0; } else { f2 = 1; }
163 SourceBits += 2;
164 }
165
166 SourceLine += BltInfo->SourceSurface->lDelta;
167 DestLine += BltInfo->DestSurface->lDelta;
168 }
169 break;
170
171 case BMF_24BPP:
172 SourceBits_24BPP = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + BltInfo->SourcePoint.x * 3;
173
174 for (j=BltInfo->DestRect.top; j<BltInfo->DestRect.bottom; j++)
175 {
176 SourceLine_24BPP = SourceBits_24BPP;
177 DestLine = DestBits;
178 f2 = BltInfo->DestRect.left & 1;
179
180 for (i=BltInfo->DestRect.left; i<BltInfo->DestRect.right; i++)
181 {
182 xColor = (*(SourceLine_24BPP + 2) << 0x10) +
183 (*(SourceLine_24BPP + 1) << 0x08) +
184 (*(SourceLine_24BPP));
185 *DestLine = (*DestLine & notmask[f2]) |
186 ((XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, xColor)) << ((4 * (1 - f2))));
187 if(f2 == 1) { DestLine++; f2 = 0; } else { f2 = 1; }
188 SourceLine_24BPP+=3;
189 }
190
191 SourceBits_24BPP += BltInfo->SourceSurface->lDelta;
192 DestBits += BltInfo->DestSurface->lDelta;
193 }
194 break;
195
196 case BMF_32BPP:
197 SourceLine = (PBYTE)BltInfo->SourceSurface->pvScan0 + (BltInfo->SourcePoint.y * BltInfo->SourceSurface->lDelta) + 4 * BltInfo->SourcePoint.x;
198 DestLine = DestBits;
199
200 for (j = BltInfo->DestRect.top; j < BltInfo->DestRect.bottom; j++)
201 {
202 SourceBits = SourceLine;
203 DestBits = DestLine;
204 f2 = BltInfo->DestRect.left & 1;
205
206 for (i = BltInfo->DestRect.left; i < BltInfo->DestRect.right; i++)
207 {
208 xColor = *((PDWORD) SourceBits);
209 *DestBits = (*DestBits & notmask[f2]) |
210 ((XLATEOBJ_iXlate(BltInfo->XlateSourceToDest, xColor)) << ((4 * (1 - f2))));
211 if(f2 == 1) { DestBits++; f2 = 0; } else { f2 = 1; }
212 SourceBits += 4;
213 }
214
215 SourceLine += BltInfo->SourceSurface->lDelta;
216 DestLine += BltInfo->DestSurface->lDelta;
217 }
218 break;
219
220 default:
221 DbgPrint("DIB_4BPP_Bitblt: Unhandled Source BPP: %u\n", BitsPerFormat(BltInfo->SourceSurface->iBitmapFormat));
222 return FALSE;
223 }
224 return(TRUE);
225 }
226
227 BOOLEAN
228 DIB_4BPP_BitBlt(PBLTINFO BltInfo)
229 {
230 ULONG DestX, DestY;
231 ULONG SourceX, SourceY;
232 ULONG PatternY = 0;
233 ULONG Dest, Source = 0, Pattern = 0;
234 BOOLEAN UsesSource;
235 BOOLEAN UsesPattern;
236 PULONG DestBits;
237 LONG RoundedRight;
238 static const ULONG ExpandSolidColor[16] =
239 {
240 0x00000000 /* 0 */,
241 0x11111111 /* 1 */,
242 0x22222222 /* 2 */,
243 0x33333333 /* 3 */,
244 0x44444444 /* 4 */,
245 0x55555555 /* 5 */,
246 0x66666666 /* 6 */,
247 0x77777777 /* 7 */,
248 0x88888888 /* 8 */,
249 0x99999999 /* 9 */,
250 0xAAAAAAAA /* 10 */,
251 0xBBBBBBBB /* 11 */,
252 0xCCCCCCCC /* 12 */,
253 0xDDDDDDDD /* 13 */,
254 0xEEEEEEEE /* 14 */,
255 0xFFFFFFFF /* 15 */,
256 };
257
258 UsesSource = ROP4_USES_SOURCE(BltInfo->Rop4);
259 UsesPattern = ROP4_USES_PATTERN(BltInfo->Rop4);
260
261 SourceY = BltInfo->SourcePoint.y;
262 RoundedRight = BltInfo->DestRect.right -
263 ((BltInfo->DestRect.right - BltInfo->DestRect.left) & 0x7);
264
265 if (UsesPattern)
266 {
267 if (BltInfo->PatternSurface)
268 {
269 PatternY = (BltInfo->DestRect.top + BltInfo->BrushOrigin.y) %
270 BltInfo->PatternSurface->sizlBitmap.cy;
271 }
272 else
273 {
274 Pattern = ExpandSolidColor[BltInfo->Brush->iSolidColor];
275 }
276 }
277
278 for (DestY = BltInfo->DestRect.top; DestY < BltInfo->DestRect.bottom; DestY++)
279 {
280 DestBits = (PULONG)(
281 (PBYTE)BltInfo->DestSurface->pvScan0 +
282 (BltInfo->DestRect.left >> 1) +
283 DestY * BltInfo->DestSurface->lDelta);
284 SourceX = BltInfo->SourcePoint.x;
285 DestX = BltInfo->DestRect.left;
286
287 if (DestX & 0x1)
288 {
289 Dest = DIB_4BPP_GetPixel(BltInfo->DestSurface, DestX, DestY);
290
291 if (UsesSource)
292 {
293 Source = DIB_GetSource(BltInfo->SourceSurface, SourceX, SourceY, BltInfo->XlateSourceToDest);
294 }
295
296 if (BltInfo->PatternSurface)
297 {
298 Pattern = DIB_GetSource(BltInfo->PatternSurface, (DestX + BltInfo->BrushOrigin.x) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY, BltInfo->XlatePatternToDest);
299 }
300
301 DIB_4BPP_PutPixel(BltInfo->DestSurface, DestX, DestY, DIB_DoRop(BltInfo->Rop4, Dest, Source, Pattern) & 0xF);
302
303 DestX++;
304 SourceX++;
305 DestBits = (PULONG)((ULONG_PTR)DestBits + 1);
306 }
307
308 for (; DestX < RoundedRight; DestX += 8, SourceX += 8, DestBits++)
309 {
310 Dest = *DestBits;
311 if (UsesSource)
312 {
313 Source =
314 (DIB_GetSource(BltInfo->SourceSurface, SourceX + 1, SourceY, BltInfo->XlateSourceToDest)) |
315 (DIB_GetSource(BltInfo->SourceSurface, SourceX + 0, SourceY, BltInfo->XlateSourceToDest) << 4) |
316 (DIB_GetSource(BltInfo->SourceSurface, SourceX + 3, SourceY, BltInfo->XlateSourceToDest) << 8) |
317 (DIB_GetSource(BltInfo->SourceSurface, SourceX + 2, SourceY, BltInfo->XlateSourceToDest) << 12) |
318 (DIB_GetSource(BltInfo->SourceSurface, SourceX + 5, SourceY, BltInfo->XlateSourceToDest) << 16) |
319 (DIB_GetSource(BltInfo->SourceSurface, SourceX + 4, SourceY, BltInfo->XlateSourceToDest) << 20) |
320 (DIB_GetSource(BltInfo->SourceSurface, SourceX + 7, SourceY, BltInfo->XlateSourceToDest) << 24) |
321 (DIB_GetSource(BltInfo->SourceSurface, SourceX + 6, SourceY, BltInfo->XlateSourceToDest) << 28);
322 }
323 if (BltInfo->PatternSurface)
324 {
325 Pattern = DIB_GetSource(BltInfo->PatternSurface, (DestX + BltInfo->BrushOrigin.x + 1) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY, BltInfo->XlatePatternToDest);
326 Pattern |= DIB_GetSource(BltInfo->PatternSurface, (DestX + BltInfo->BrushOrigin.x + 0) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY, BltInfo->XlatePatternToDest) << 4;
327 Pattern |= DIB_GetSource(BltInfo->PatternSurface, (DestX + BltInfo->BrushOrigin.x + 3) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY, BltInfo->XlatePatternToDest) << 8;
328 Pattern |= DIB_GetSource(BltInfo->PatternSurface, (DestX + BltInfo->BrushOrigin.x + 2) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY, BltInfo->XlatePatternToDest) << 12;
329 Pattern |= DIB_GetSource(BltInfo->PatternSurface, (DestX + BltInfo->BrushOrigin.x + 5) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY, BltInfo->XlatePatternToDest) << 16;
330 Pattern |= DIB_GetSource(BltInfo->PatternSurface, (DestX + BltInfo->BrushOrigin.x + 4) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY, BltInfo->XlatePatternToDest) << 20;
331 Pattern |= DIB_GetSource(BltInfo->PatternSurface, (DestX + BltInfo->BrushOrigin.x + 7) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY, BltInfo->XlatePatternToDest) << 24;
332 Pattern |= DIB_GetSource(BltInfo->PatternSurface, (DestX + BltInfo->BrushOrigin.x + 6) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY, BltInfo->XlatePatternToDest) << 28;
333 }
334 *DestBits = DIB_DoRop(BltInfo->Rop4, Dest, Source, Pattern);
335 }
336
337 /* Process the rest of pixel on the line */
338 for (; DestX < BltInfo->DestRect.right; DestX++, SourceX++)
339 {
340 Dest = DIB_4BPP_GetPixel(BltInfo->DestSurface, DestX, DestY);
341 if (UsesSource)
342 {
343 Source = DIB_GetSource(BltInfo->SourceSurface, SourceX, SourceY, BltInfo->XlateSourceToDest);
344 }
345 if (BltInfo->PatternSurface)
346 {
347 Pattern = DIB_GetSource(BltInfo->PatternSurface, (DestX + BltInfo->BrushOrigin.x) % BltInfo->PatternSurface->sizlBitmap.cx, PatternY, BltInfo->XlatePatternToDest);
348 }
349 DIB_4BPP_PutPixel(BltInfo->DestSurface, DestX, DestY, DIB_DoRop(BltInfo->Rop4, Dest, Source, Pattern) & 0xF);
350 }
351
352 SourceY++;
353 if (BltInfo->PatternSurface)
354 {
355 PatternY++;
356 PatternY %= BltInfo->PatternSurface->sizlBitmap.cy;
357 }
358 }
359
360 return TRUE;
361 }
362
363 /* BitBlt Optimize */
364 BOOLEAN
365 DIB_4BPP_ColorFill(SURFOBJ* DestSurface, RECTL* DestRect, ULONG color)
366 {
367 ULONG DestY;
368
369 for (DestY = DestRect->top; DestY< DestRect->bottom; DestY++)
370 {
371 DIB_4BPP_HLine(DestSurface, DestRect->left, DestRect->right, DestY, color);
372 }
373
374 return TRUE;
375 }
376
377 //NOTE: If you change something here, please do the same in other dibXXbpp.c files!
378 BOOLEAN DIB_4BPP_StretchBlt(SURFOBJ *DestSurf, SURFOBJ *SourceSurf,
379 RECTL* DestRect, RECTL *SourceRect,
380 POINTL* MaskOrigin, POINTL BrushOrigin,
381 CLIPOBJ *ClipRegion, XLATEOBJ *ColorTranslation,
382 ULONG Mode)
383 {
384 int SrcSizeY;
385 int SrcSizeX;
386 int DesSizeY;
387 int DesSizeX;
388 int sx;
389 int sy;
390 int DesX;
391 int DesY;
392 int color;
393 int zoomX;
394 int zoomY;
395 int count;
396 int saveX;
397 int saveY;
398 BOOLEAN DesIsBiggerY=FALSE;
399
400
401 SrcSizeY = SourceRect->bottom;
402 SrcSizeX = SourceRect->right;
403
404 DesSizeY = DestRect->bottom;
405 DesSizeX = DestRect->right;
406
407 zoomX = DesSizeX / SrcSizeX;
408 if (zoomX==0) zoomX=1;
409
410 zoomY = DesSizeY / SrcSizeY;
411 if (zoomY==0) zoomY=1;
412
413 if (DesSizeY>SrcSizeY)
414 DesIsBiggerY = TRUE;
415
416 switch(SourceSurf->iBitmapFormat)
417 {
418 case BMF_1BPP:
419 /* FIXME : MaskOrigin, BrushOrigin, ClipRegion, Mode ? */
420 /* This is a reference implementation, it hasn't been optimized for speed */
421 if (zoomX>1)
422 {
423 /* Draw one Hline on X - Led to the Des Zoom In*/
424 if (DesSizeX>SrcSizeX)
425 {
426 for (DesY=DestRect->bottom-zoomY; DesY>=0; DesY-=zoomY)
427 {
428 if (DesIsBiggerY)
429 sy = (int) ((ULONG) SrcSizeY * (ULONG) DesY) / ((ULONG) DesSizeY);
430 else
431 sy = (int) ((ULONG) DesSizeY * (ULONG) DesY) / ((ULONG) SrcSizeY);
432
433 if (sy > SourceRect->bottom) break;
434
435 saveY = DesY+zoomY;
436
437 for (DesX=DestRect->right-zoomX; DesX>=0; DesX-=zoomX)
438 {
439 sx = (int) ((ULONG) SrcSizeX * (ULONG) DesX) / ((ULONG) DesSizeX);
440
441 if (sx > SourceRect->right) break;
442
443 saveX = DesX + zoomX;
444
445 if (DIB_1BPP_GetPixel(SourceSurf, sx, sy) == 0)
446 for (count=DesY;count<saveY;count++)
447 DIB_4BPP_HLine(DestSurf, DesX, saveX, count, 0);
448 else
449 for (count=DesY;count<saveY;count++)
450 DIB_4BPP_HLine(DestSurf, DesX, saveX, count, 1);
451
452 }
453 }
454 }
455 else
456 {
457 /* Draw one Hline on X - Led to the Des Zoom Out*/
458
459 for (DesY=DestRect->bottom-zoomY; DesY>=0; DesY-=zoomY)
460 {
461 if (DesIsBiggerY)
462 sy = (int) ((ULONG) SrcSizeY * (ULONG) DesY) / ((ULONG) DesSizeY);
463 else
464 sy = (int) ((ULONG) DesSizeY * (ULONG) DesY) / ((ULONG) SrcSizeY);
465
466 if (sy > SourceRect->bottom) break;
467
468 saveY = DesY+zoomY;
469
470 for (DesX=DestRect->right-zoomX; DesX>=0; DesX-=zoomX)
471 {
472 sx = (int) ((ULONG) DesSizeX * (ULONG) DesX) / ((ULONG) SrcSizeX);
473
474 if (sx > SourceRect->right) break;
475
476 saveX = DesX + zoomX;
477
478 if (DIB_1BPP_GetPixel(SourceSurf, sx, sy) == 0)
479 for (count=DesY;count<saveY;count++)
480 DIB_4BPP_HLine(DestSurf, DesX, saveX, count, 0);
481 else
482 for (count=DesY;count<saveY;count++)
483 DIB_4BPP_HLine(DestSurf, DesX, saveX, count, 1);
484
485 }
486 }
487 }
488 }
489 else
490 {
491
492 if (DesSizeX>SrcSizeX)
493 {
494 /* Draw one pixel on X - Led to the Des Zoom In*/
495 for (DesY=DestRect->bottom-zoomY; DesY>=0; DesY-=zoomY)
496 {
497 if (DesIsBiggerY)
498 sy = (int) ((ULONG) SrcSizeY * (ULONG) DesY) / ((ULONG) DesSizeY);
499 else
500 sy = (int) ((ULONG) DesSizeY * (ULONG) DesY) / ((ULONG) SrcSizeY);
501
502 if (sy > SourceRect->bottom) break;
503
504 saveY = DesY+zoomY;
505
506 for (DesX=DestRect->right-zoomX; DesX>=0; DesX-=zoomX)
507 {
508 sx = (int) ((ULONG) SrcSizeX * (ULONG) DesX) / ((ULONG) DesSizeX);
509
510 if (sx > SourceRect->right) break;
511
512 if (DIB_1BPP_GetPixel(SourceSurf, sx, sy) == 0)
513 for (count=DesY;count<saveY;count++)
514 DIB_4BPP_PutPixel(DestSurf, DesX, count, 0);
515 else
516 for (count=DesY;count<saveY;count++)
517 DIB_4BPP_PutPixel(DestSurf, DesX, count, 1);
518
519
520 }
521 }
522 }
523 else
524 {
525 /* Draw one pixel on X - Led to the Des Zoom Out*/
526 for (DesY=DestRect->bottom-zoomY; DesY>=0; DesY-=zoomY)
527 {
528 if (DesIsBiggerY)
529 sy = (int) ((ULONG) SrcSizeY * (ULONG) DesY) / ((ULONG) DesSizeY);
530 else
531 sy = (int) ((ULONG) DesSizeY * (ULONG) DesY) / ((ULONG) SrcSizeY);
532
533 if (sy > SourceRect->bottom) break;
534
535 saveY = DesY+zoomY;
536
537 for (DesX=DestRect->right-zoomX; DesX>=0; DesX-=zoomX)
538 {
539 sx = (int) ((ULONG) DesSizeX * (ULONG) DesX) / ((ULONG) SrcSizeX);
540
541 if (sx > SourceRect->right) break;
542
543 if (DIB_1BPP_GetPixel(SourceSurf, sx, sy) == 0)
544 for (count=DesY;count<saveY;count++)
545 DIB_4BPP_PutPixel(DestSurf, DesX, count, 0);
546 else
547 for (count=DesY;count<saveY;count++)
548 DIB_4BPP_PutPixel(DestSurf, DesX, count, 1);
549
550 }
551 }
552 }
553 }
554 break;
555
556 case BMF_4BPP:
557 /* FIXME : MaskOrigin, BrushOrigin, ClipRegion, Mode ? */
558 /* This is a reference implementation, it hasn't been optimized for speed */
559 if (zoomX>1)
560 {
561 /* Draw one Hline on X - Led to the Des Zoom In*/
562 if (DesSizeX>SrcSizeX)
563 {
564 for (DesY=DestRect->bottom-zoomY; DesY>=0; DesY-=zoomY)
565 {
566 if (DesIsBiggerY)
567 sy = (int) ((ULONG) SrcSizeY * (ULONG) DesY) / ((ULONG) DesSizeY);
568 else
569 sy = (int) ((ULONG) DesSizeY * (ULONG) DesY) / ((ULONG) SrcSizeY);
570
571 if (sy > SourceRect->bottom) break;
572
573 saveY = DesY+zoomY;
574
575 for (DesX=DestRect->right-zoomX; DesX>=0; DesX-=zoomX)
576 {
577 sx = (int) ((ULONG) SrcSizeX * (ULONG) DesX) / ((ULONG) DesSizeX);
578
579 if (sx > SourceRect->right) break;
580
581 color = DIB_4BPP_GetPixel(SourceSurf, sx, sy);
582
583 saveX = DesX + zoomX;
584 for (count=DesY;count<saveY;count++)
585 DIB_4BPP_HLine(DestSurf, DesX, saveX, count, color);
586 }
587 }
588 }
589 else
590 {
591 /* Draw one Hline on X - Led to the Des Zoom Out*/
592
593 for (DesY=DestRect->bottom-zoomY; DesY>=0; DesY-=zoomY)
594 {
595 if (DesIsBiggerY)
596 sy = (int) ((ULONG) SrcSizeY * (ULONG) DesY) / ((ULONG) DesSizeY);
597 else
598 sy = (int) ((ULONG) DesSizeY * (ULONG) DesY) / ((ULONG) SrcSizeY);
599
600 if (sy > SourceRect->bottom) break;
601
602 saveY = DesY+zoomY;
603
604 for (DesX=DestRect->right-zoomX; DesX>=0; DesX-=zoomX)
605 {
606 sx = (int) ((ULONG) DesSizeX * (ULONG) DesX) / ((ULONG) SrcSizeX);
607
608 if (sx > SourceRect->right) break;
609
610 color = DIB_4BPP_GetPixel(SourceSurf, sx, sy);
611
612 saveX = DesX + zoomX;
613 for (count=DesY;count<saveY;count++)
614 DIB_4BPP_HLine(DestSurf, DesX, saveX, count, color);
615 }
616 }
617 }
618 }
619
620 else
621 {
622
623 if (DesSizeX>SrcSizeX)
624 {
625 /* Draw one pixel on X - Led to the Des Zoom In*/
626 for (DesY=DestRect->bottom-zoomY; DesY>=0; DesY-=zoomY)
627 {
628 if (DesIsBiggerY)
629 sy = (int) ((ULONG) SrcSizeY * (ULONG) DesY) / ((ULONG) DesSizeY);
630 else
631 sy = (int) ((ULONG) DesSizeY * (ULONG) DesY) / ((ULONG) SrcSizeY);
632
633 if (sy > SourceRect->bottom) break;
634
635 saveY = DesY+zoomY;
636
637 for (DesX=DestRect->right-zoomX; DesX>=0; DesX-=zoomX)
638 {
639 sx = (int) ((ULONG) SrcSizeX * (ULONG) DesX) / ((ULONG) DesSizeX);
640
641 if (sx > SourceRect->right) break;
642
643 color = DIB_4BPP_GetPixel(SourceSurf, sx, sy);
644
645 for (count=DesY;count<saveY;count++)
646 DIB_4BPP_PutPixel(DestSurf, DesX, count, color);
647 }
648 }
649 }
650 else
651 {
652 /* Draw one pixel on X - Led to the Des Zoom Out*/
653 for (DesY=DestRect->bottom-zoomY; DesY>=0; DesY-=zoomY)
654 {
655 if (DesIsBiggerY)
656 sy = (int) ((ULONG) SrcSizeY * (ULONG) DesY) / ((ULONG) DesSizeY);
657 else
658 sy = (int) ((ULONG) DesSizeY * (ULONG) DesY) / ((ULONG) SrcSizeY);
659
660 if (sy > SourceRect->bottom) break;
661
662 saveY = DesY+zoomY;
663
664 for (DesX=DestRect->right-zoomX; DesX>=0; DesX-=zoomX)
665 {
666 sx = (int) ((ULONG) DesSizeX * (ULONG) DesX) / ((ULONG) SrcSizeX);
667
668 if (sx > SourceRect->right) break;
669
670 color = DIB_4BPP_GetPixel(SourceSurf, sx, sy);
671
672 for (count=DesY;count<saveY;count++)
673 DIB_4BPP_PutPixel(DestSurf, DesX, count, color);
674 }
675 }
676 }
677 }
678 break;
679
680 case BMF_8BPP:
681 /* FIXME : MaskOrigin, BrushOrigin, ClipRegion, Mode ? */
682 /* This is a reference implementation, it hasn't been optimized for speed */
683 if (zoomX>1)
684 {
685 /* Draw one Hline on X - Led to the Des Zoom In*/
686 if (DesSizeX>SrcSizeX)
687 {
688 for (DesY=DestRect->bottom-zoomY; DesY>=0; DesY-=zoomY)
689 {
690 if (DesIsBiggerY)
691 sy = (int) ((ULONG) SrcSizeY * (ULONG) DesY) / ((ULONG) DesSizeY);
692 else
693 sy = (int) ((ULONG) DesSizeY * (ULONG) DesY) / ((ULONG) SrcSizeY);
694
695 if (sy > SourceRect->bottom) break;
696
697 saveY = DesY+zoomY;
698
699 for (DesX=DestRect->right-zoomX; DesX>=0; DesX-=zoomX)
700 {
701 sx = (int) ((ULONG) SrcSizeX * (ULONG) DesX) / ((ULONG) DesSizeX);
702
703 if (sx > SourceRect->right) break;
704
705 color = XLATEOBJ_iXlate(ColorTranslation, DIB_8BPP_GetPixel(SourceSurf, sx, sy));
706
707 saveX = DesX + zoomX;
708 for (count=DesY;count<saveY;count++)
709 DIB_4BPP_HLine(DestSurf, DesX, saveX, count, color);
710 }
711 }
712 }
713 else
714 {
715 /* Draw one Hline on X - Led to the Des Zoom Out*/
716
717 for (DesY=DestRect->bottom-zoomY; DesY>=0; DesY-=zoomY)
718 {
719 if (DesIsBiggerY)
720 sy = (int) ((ULONG) SrcSizeY * (ULONG) DesY) / ((ULONG) DesSizeY);
721 else
722 sy = (int) ((ULONG) DesSizeY * (ULONG) DesY) / ((ULONG) SrcSizeY);
723
724 if (sy > SourceRect->bottom) break;
725
726 saveY = DesY+zoomY;
727
728 for (DesX=DestRect->right-zoomX; DesX>=0; DesX-=zoomX)
729 {
730 sx = (int) ((ULONG) DesSizeX * (ULONG) DesX) / ((ULONG) SrcSizeX);
731
732 if (sx > SourceRect->right) break;
733
734 color = XLATEOBJ_iXlate(ColorTranslation, DIB_8BPP_GetPixel(SourceSurf, sx, sy));
735
736 saveX = DesX + zoomX;
737 for (count=DesY;count<saveY;count++)
738 DIB_4BPP_HLine(DestSurf, DesX, saveX, count, color);
739 }
740 }
741 }
742 }
743
744 else
745 {
746
747 if (DesSizeX>SrcSizeX)
748 {
749 /* Draw one pixel on X - Led to the Des Zoom In*/
750 for (DesY=DestRect->bottom-zoomY; DesY>=0; DesY-=zoomY)
751 {
752 if (DesIsBiggerY)
753 sy = (int) ((ULONG) SrcSizeY * (ULONG) DesY) / ((ULONG) DesSizeY);
754 else
755 sy = (int) ((ULONG) DesSizeY * (ULONG) DesY) / ((ULONG) SrcSizeY);
756
757 if (sy > SourceRect->bottom) break;
758
759 saveY = DesY+zoomY;
760
761 for (DesX=DestRect->right-zoomX; DesX>=0; DesX-=zoomX)
762 {
763 sx = (int) ((ULONG) SrcSizeX * (ULONG) DesX) / ((ULONG) DesSizeX);
764
765 if (sx > SourceRect->right) break;
766
767 color = XLATEOBJ_iXlate(ColorTranslation, DIB_8BPP_GetPixel(SourceSurf, sx, sy));
768
769 for (count=DesY;count<saveY;count++)
770 DIB_4BPP_PutPixel(DestSurf, DesX, count, color);
771 }
772 }
773 }
774 else
775 {
776 /* Draw one pixel on X - Led to the Des Zoom Out*/
777 for (DesY=DestRect->bottom-zoomY; DesY>=0; DesY-=zoomY)
778 {
779 if (DesIsBiggerY)
780 sy = (int) ((ULONG) SrcSizeY * (ULONG) DesY) / ((ULONG) DesSizeY);
781 else
782 sy = (int) ((ULONG) DesSizeY * (ULONG) DesY) / ((ULONG) SrcSizeY);
783
784 if (sy > SourceRect->bottom) break;
785
786 saveY = DesY+zoomY;
787
788 for (DesX=DestRect->right-zoomX; DesX>=0; DesX-=zoomX)
789 {
790 sx = (int) ((ULONG) DesSizeX * (ULONG) DesX) / ((ULONG) SrcSizeX);
791
792 if (sx > SourceRect->right) break;
793
794 color = XLATEOBJ_iXlate(ColorTranslation, DIB_8BPP_GetPixel(SourceSurf, sx, sy));
795
796 for (count=DesY;count<saveY;count++)
797 DIB_4BPP_PutPixel(DestSurf, DesX, count, color);
798 }
799 }
800 }
801 }
802 break;
803
804 case BMF_16BPP:
805 /* FIXME : MaskOrigin, BrushOrigin, ClipRegion, Mode ? */
806 /* This is a reference implementation, it hasn't been optimized for speed */
807 if (zoomX>1)
808 {
809 /* Draw one Hline on X - Led to the Des Zoom In*/
810 if (DesSizeX>SrcSizeX)
811 {
812 for (DesY=DestRect->bottom-zoomY; DesY>=0; DesY-=zoomY)
813 {
814 if (DesIsBiggerY)
815 sy = (int) ((ULONG) SrcSizeY * (ULONG) DesY) / ((ULONG) DesSizeY);
816 else
817 sy = (int) ((ULONG) DesSizeY * (ULONG) DesY) / ((ULONG) SrcSizeY);
818
819 if (sy > SourceRect->bottom) break;
820
821 saveY = DesY+zoomY;
822
823 for (DesX=DestRect->right-zoomX; DesX>=0; DesX-=zoomX)
824 {
825 sx = (int) ((ULONG) SrcSizeX * (ULONG) DesX) / ((ULONG) DesSizeX);
826
827 if (sx > SourceRect->right) break;
828
829 color = XLATEOBJ_iXlate(ColorTranslation, DIB_16BPP_GetPixel(SourceSurf, sx, sy));
830
831 saveX = DesX + zoomX;
832 for (count=DesY;count<saveY;count++)
833 DIB_4BPP_HLine(DestSurf, DesX, saveX, count, color);
834 }
835 }
836 }
837 else
838 {
839 /* Draw one Hline on X - Led to the Des Zoom Out*/
840
841 for (DesY=DestRect->bottom-zoomY; DesY>=0; DesY-=zoomY)
842 {
843 if (DesIsBiggerY)
844 sy = (int) ((ULONG) SrcSizeY * (ULONG) DesY) / ((ULONG) DesSizeY);
845 else
846 sy = (int) ((ULONG) DesSizeY * (ULONG) DesY) / ((ULONG) SrcSizeY);
847
848 if (sy > SourceRect->bottom) break;
849
850 saveY = DesY+zoomY;
851
852 for (DesX=DestRect->right-zoomX; DesX>=0; DesX-=zoomX)
853 {
854 sx = (int) ((ULONG) DesSizeX * (ULONG) DesX) / ((ULONG) SrcSizeX);
855
856 if (sx > SourceRect->right) break;
857
858 color = XLATEOBJ_iXlate(ColorTranslation, DIB_16BPP_GetPixel(SourceSurf, sx, sy));
859
860 saveX = DesX + zoomX;
861 for (count=DesY;count<saveY;count++)
862 DIB_4BPP_HLine(DestSurf, DesX, saveX, count, color);
863 }
864 }
865 }
866 }
867
868 else
869 {
870
871 if (DesSizeX>SrcSizeX)
872 {
873 /* Draw one pixel on X - Led to the Des Zoom In*/
874 for (DesY=DestRect->bottom-zoomY; DesY>=0; DesY-=zoomY)
875 {
876 if (DesIsBiggerY)
877 sy = (int) ((ULONG) SrcSizeY * (ULONG) DesY) / ((ULONG) DesSizeY);
878 else
879 sy = (int) ((ULONG) DesSizeY * (ULONG) DesY) / ((ULONG) SrcSizeY);
880
881 if (sy > SourceRect->bottom) break;
882
883 saveY = DesY+zoomY;
884
885 for (DesX=DestRect->right-zoomX; DesX>=0; DesX-=zoomX)
886 {
887 sx = (int) ((ULONG) SrcSizeX * (ULONG) DesX) / ((ULONG) DesSizeX);
888
889 if (sx > SourceRect->right) break;
890
891 color = XLATEOBJ_iXlate(ColorTranslation, DIB_16BPP_GetPixel(SourceSurf, sx, sy));
892
893 for (count=DesY;count<saveY;count++)
894 DIB_4BPP_PutPixel(DestSurf, DesX, count, color);
895 }
896 }
897 }
898 else
899 {
900 /* Draw one pixel on X - Led to the Des Zoom Out*/
901 for (DesY=DestRect->bottom-zoomY; DesY>=0; DesY-=zoomY)
902 {
903 if (DesIsBiggerY)
904 sy = (int) ((ULONG) SrcSizeY * (ULONG) DesY) / ((ULONG) DesSizeY);
905 else
906 sy = (int) ((ULONG) DesSizeY * (ULONG) DesY) / ((ULONG) SrcSizeY);
907
908 if (sy > SourceRect->bottom) break;
909
910 saveY = DesY+zoomY;
911
912 for (DesX=DestRect->right-zoomX; DesX>=0; DesX-=zoomX)
913 {
914 sx = (int) ((ULONG) DesSizeX * (ULONG) DesX) / ((ULONG) SrcSizeX);
915
916 if (sx > SourceRect->right) break;
917
918 color = XLATEOBJ_iXlate(ColorTranslation, DIB_16BPP_GetPixel(SourceSurf, sx, sy));
919
920 for (count=DesY;count<saveY;count++)
921 DIB_4BPP_PutPixel(DestSurf, DesX, count, color);
922 }
923 }
924 }
925 }
926 break;
927
928 case BMF_24BPP:
929 /* FIXME : MaskOrigin, BrushOrigin, ClipRegion, Mode ? */
930 /* This is a reference implementation, it hasn't been optimized for speed */
931 if (zoomX>1)
932 {
933 /* Draw one Hline on X - Led to the Des Zoom In*/
934 if (DesSizeX>SrcSizeX)
935 {
936 for (DesY=DestRect->bottom-zoomY; DesY>=0; DesY-=zoomY)
937 {
938 if (DesIsBiggerY)
939 sy = (int) ((ULONG) SrcSizeY * (ULONG) DesY) / ((ULONG) DesSizeY);
940 else
941 sy = (int) ((ULONG) DesSizeY * (ULONG) DesY) / ((ULONG) SrcSizeY);
942
943 if (sy > SourceRect->bottom) break;
944
945 saveY = DesY+zoomY;
946
947 for (DesX=DestRect->right-zoomX; DesX>=0; DesX-=zoomX)
948 {
949 sx = (int) ((ULONG) SrcSizeX * (ULONG) DesX) / ((ULONG) DesSizeX);
950
951 if (sx > SourceRect->right) break;
952
953 color = XLATEOBJ_iXlate(ColorTranslation, DIB_24BPP_GetPixel(SourceSurf, sx, sy));
954
955 saveX = DesX + zoomX;
956 for (count=DesY;count<saveY;count++)
957 DIB_4BPP_HLine(DestSurf, DesX, saveX, count, color);
958 }
959 }
960 }
961 else
962 {
963 /* Draw one Hline on X - Led to the Des Zoom Out*/
964
965 for (DesY=DestRect->bottom-zoomY; DesY>=0; DesY-=zoomY)
966 {
967 if (DesIsBiggerY)
968 sy = (int) ((ULONG) SrcSizeY * (ULONG) DesY) / ((ULONG) DesSizeY);
969 else
970 sy = (int) ((ULONG) DesSizeY * (ULONG) DesY) / ((ULONG) SrcSizeY);
971
972 if (sy > SourceRect->bottom) break;
973
974 saveY = DesY+zoomY;
975
976 for (DesX=DestRect->right-zoomX; DesX>=0; DesX-=zoomX)
977 {
978 sx = (int) ((ULONG) DesSizeX * (ULONG) DesX) / ((ULONG) SrcSizeX);
979
980 if (sx > SourceRect->right) break;
981
982 color = XLATEOBJ_iXlate(ColorTranslation, DIB_24BPP_GetPixel(SourceSurf, sx, sy));
983
984 saveX = DesX + zoomX;
985 for (count=DesY;count<saveY;count++)
986 DIB_4BPP_HLine(DestSurf, DesX, saveX, count, color);
987 }
988 }
989 }
990 }
991
992 else
993 {
994
995 if (DesSizeX>SrcSizeX)
996 {
997 /* Draw one pixel on X - Led to the Des Zoom In*/
998 for (DesY=DestRect->bottom-zoomY; DesY>=0; DesY-=zoomY)
999 {
1000 if (DesIsBiggerY)
1001 sy = (int) ((ULONG) SrcSizeY * (ULONG) DesY) / ((ULONG) DesSizeY);
1002 else
1003 sy = (int) ((ULONG) DesSizeY * (ULONG) DesY) / ((ULONG) SrcSizeY);
1004
1005 if (sy > SourceRect->bottom) break;
1006
1007 saveY = DesY+zoomY;
1008
1009 for (DesX=DestRect->right-zoomX; DesX>=0; DesX-=zoomX)
1010 {
1011 sx = (int) ((ULONG) SrcSizeX * (ULONG) DesX) / ((ULONG) DesSizeX);
1012
1013 if (sx > SourceRect->right) break;
1014
1015 color = XLATEOBJ_iXlate(ColorTranslation, DIB_24BPP_GetPixel(SourceSurf, sx, sy));
1016
1017 for (count=DesY;count<saveY;count++)
1018 DIB_4BPP_PutPixel(DestSurf, DesX, count, color);
1019 }
1020 }
1021 }
1022 else
1023 {
1024 /* Draw one pixel on X - Led to the Des Zoom Out*/
1025 for (DesY=DestRect->bottom-zoomY; DesY>=0; DesY-=zoomY)
1026 {
1027 if (DesIsBiggerY)
1028 sy = (int) ((ULONG) SrcSizeY * (ULONG) DesY) / ((ULONG) DesSizeY);
1029 else
1030 sy = (int) ((ULONG) DesSizeY * (ULONG) DesY) / ((ULONG) SrcSizeY);
1031
1032 if (sy > SourceRect->bottom) break;
1033
1034 saveY = DesY+zoomY;
1035
1036 for (DesX=DestRect->right-zoomX; DesX>=0; DesX-=zoomX)
1037 {
1038 sx = (int) ((ULONG) DesSizeX * (ULONG) DesX) / ((ULONG) SrcSizeX);
1039
1040 if (sx > SourceRect->right) break;
1041
1042 color = XLATEOBJ_iXlate(ColorTranslation, DIB_24BPP_GetPixel(SourceSurf, sx, sy));
1043
1044 for (count=DesY;count<saveY;count++)
1045 DIB_4BPP_PutPixel(DestSurf, DesX, count, color);
1046 }
1047 }
1048 }
1049 }
1050 break;
1051
1052 case BMF_32BPP:
1053 /* FIXME : MaskOrigin, BrushOrigin, ClipRegion, Mode ? */
1054 /* This is a reference implementation, it hasn't been optimized for speed */
1055 if (zoomX>1)
1056 {
1057 /* Draw one Hline on X - Led to the Des Zoom In*/
1058 if (DesSizeX>SrcSizeX)
1059 {
1060 for (DesY=DestRect->bottom-zoomY; DesY>=0; DesY-=zoomY)
1061 {
1062 if (DesIsBiggerY)
1063 sy = (int) ((ULONG) SrcSizeY * (ULONG) DesY) / ((ULONG) DesSizeY);
1064 else
1065 sy = (int) ((ULONG) DesSizeY * (ULONG) DesY) / ((ULONG) SrcSizeY);
1066
1067 if (sy > SourceRect->bottom) break;
1068
1069 saveY = DesY+zoomY;
1070
1071 for (DesX=DestRect->right-zoomX; DesX>=0; DesX-=zoomX)
1072 {
1073 sx = (int) ((ULONG) SrcSizeX * (ULONG) DesX) / ((ULONG) DesSizeX);
1074
1075 if (sx > SourceRect->right) break;
1076
1077 color = XLATEOBJ_iXlate(ColorTranslation, DIB_32BPP_GetPixel(SourceSurf, sx, sy));
1078
1079 saveX = DesX + zoomX;
1080 for (count=DesY;count<saveY;count++)
1081 DIB_4BPP_HLine(DestSurf, DesX, saveX, count, color);
1082 }
1083 }
1084 }
1085 else
1086 {
1087 /* Draw one Hline on X - Led to the Des Zoom Out*/
1088
1089 for (DesY=DestRect->bottom-zoomY; DesY>=0; DesY-=zoomY)
1090 {
1091 if (DesIsBiggerY)
1092 sy = (int) ((ULONG) SrcSizeY * (ULONG) DesY) / ((ULONG) DesSizeY);
1093 else
1094 sy = (int) ((ULONG) DesSizeY * (ULONG) DesY) / ((ULONG) SrcSizeY);
1095
1096 if (sy > SourceRect->bottom) break;
1097
1098 saveY = DesY+zoomY;
1099
1100 for (DesX=DestRect->right-zoomX; DesX>=0; DesX-=zoomX)
1101 {
1102 sx = (int) ((ULONG) DesSizeX * (ULONG) DesX) / ((ULONG) SrcSizeX);
1103
1104 if (sx > SourceRect->right) break;
1105
1106 color = XLATEOBJ_iXlate(ColorTranslation, DIB_32BPP_GetPixel(SourceSurf, sx, sy));
1107
1108 saveX = DesX + zoomX;
1109 for (count=DesY;count<saveY;count++)
1110 DIB_4BPP_HLine(DestSurf, DesX, saveX, count, color);
1111 }
1112 }
1113 }
1114 }
1115
1116 else
1117 {
1118
1119 if (DesSizeX>SrcSizeX)
1120 {
1121 /* Draw one pixel on X - Led to the Des Zoom In*/
1122 for (DesY=DestRect->bottom-zoomY; DesY>=0; DesY-=zoomY)
1123 {
1124 if (DesIsBiggerY)
1125 sy = (int) ((ULONG) SrcSizeY * (ULONG) DesY) / ((ULONG) DesSizeY);
1126 else
1127 sy = (int) ((ULONG) DesSizeY * (ULONG) DesY) / ((ULONG) SrcSizeY);
1128
1129 if (sy > SourceRect->bottom) break;
1130
1131 saveY = DesY+zoomY;
1132
1133 for (DesX=DestRect->right-zoomX; DesX>=0; DesX-=zoomX)
1134 {
1135 sx = (int) ((ULONG) SrcSizeX * (ULONG) DesX) / ((ULONG) DesSizeX);
1136
1137 if (sx > SourceRect->right) break;
1138
1139 color = XLATEOBJ_iXlate(ColorTranslation, DIB_32BPP_GetPixel(SourceSurf, sx, sy));
1140
1141 for (count=DesY;count<saveY;count++)
1142 DIB_4BPP_PutPixel(DestSurf, DesX, count, color);
1143 }
1144 }
1145 }
1146 else
1147 {
1148 /* Draw one pixel on X - Led to the Des Zoom Out*/
1149 for (DesY=DestRect->bottom-zoomY; DesY>=0; DesY-=zoomY)
1150 {
1151 if (DesIsBiggerY)
1152 sy = (int) ((ULONG) SrcSizeY * (ULONG) DesY) / ((ULONG) DesSizeY);
1153 else
1154 sy = (int) ((ULONG) DesSizeY * (ULONG) DesY) / ((ULONG) SrcSizeY);
1155
1156 if (sy > SourceRect->bottom) break;
1157
1158 saveY = DesY+zoomY;
1159
1160 for (DesX=DestRect->right-zoomX; DesX>=0; DesX-=zoomX)
1161 {
1162 sx = (int) ((ULONG) DesSizeX * (ULONG) DesX) / ((ULONG) SrcSizeX);
1163
1164 if (sx > SourceRect->right) break;
1165
1166 color = XLATEOBJ_iXlate(ColorTranslation, DIB_32BPP_GetPixel(SourceSurf, sx, sy));
1167
1168 for (count=DesY;count<saveY;count++)
1169 DIB_4BPP_PutPixel(DestSurf, DesX, count, color);
1170 }
1171 }
1172 }
1173 }
1174 break;
1175
1176
1177 default:
1178 //DPRINT1("DIB_4BPP_StretchBlt: Unhandled Source BPP: %u\n", BitsPerFormat(SourceSurf->iBitmapFormat));
1179 return FALSE;
1180 }
1181
1182 return TRUE;
1183 }
1184
1185 BOOLEAN
1186 DIB_4BPP_TransparentBlt(SURFOBJ *DestSurf, SURFOBJ *SourceSurf,
1187 RECTL* DestRect, POINTL *SourcePoint,
1188 XLATEOBJ *ColorTranslation, ULONG iTransColor)
1189 {
1190 return FALSE;
1191 }
1192
1193 /* EOF */
A free Windows-compatible Operating System