2 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
3 SOFTWARE CORPORATION ("PARALLAX"). PARALLAX, IN DISTRIBUTING THE CODE TO
4 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
5 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
6 IN USING, DISPLAYING, AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
7 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
8 FREE PURPOSES. IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
9 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES. THE END-USER UNDERSTANDS
10 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
11 COPYRIGHT 1993-1998 PARALLAX SOFTWARE CORPORATION. ALL RIGHTS RESERVED.
14 * $Source: /cvs/cvsroot/d2x/2d/scale.c,v $
15 * $Revision: 1.1.1.1 $
17 * $Date: 2001-01-19 03:29:57 $
19 * Routines for scaling a bitmap.
21 * $Log: not supported by cvs2svn $
22 * Revision 1.1.1.1 1999/06/14 21:57:36 donut
23 * Import of d1x 1.37 source.
25 * Revision 1.12 1995/03/14 15:14:11 john
26 * Increased max scanline length to 640.
29 * Revision 1.11 1994/11/27 12:56:39 matt
30 * Took out unneeded include of 3d.h
32 * Revision 1.10 1994/11/18 22:50:25 john
33 * Changed shorts to ints in parameters.
35 * Revision 1.9 1994/11/09 16:35:02 john
36 * First version with working RLE bitmaps.
38 * Revision 1.8 1994/06/09 13:15:17 john
39 * *** empty log message ***
41 * Revision 1.7 1994/06/07 11:47:02 john
42 * Added back in the fast code for scaling up bitmaps.
44 * Revision 1.6 1994/02/18 15:32:36 john
45 * *** empty log message ***
47 * Revision 1.5 1994/01/22 14:35:01 john
48 * Added transparency as color index 255.
50 * Revision 1.4 1994/01/17 16:59:12 john
53 * Revision 1.3 1994/01/17 16:51:17 john
54 * Added check so we don't draw outsibe
55 * the source bitmap's v coordinate... kind
56 * of a hack, but works.
58 * Revision 1.2 1994/01/12 18:03:26 john
59 * The first iteration of fast scaler..
61 * Revision 1.1 1994/01/11 14:48:42 john
69 static char rcsid[] = "$Id: scale.c,v 1.1.1.1 2001-01-19 03:29:57 bradleyb Exp $";
85 #define TRANSPARENCY_COLOR 255;
88 static int Transparency_color = TRANSPARENCY_COLOR;
92 void rls_stretch_scanline( char * source, char * dest, int XDelta, int YDelta );
93 void rls_stretch_scanline_setup( int XDelta, int YDelta );
94 void scale_bitmap_asm(grs_bitmap *source_bmp, grs_bitmap *dest_bmp, int x0, int y0, int x1, int y1, fix u0, fix v0, fix u1, fix v1 );
95 void scale_bitmap_asm_rle(grs_bitmap *source_bmp, grs_bitmap *dest_bmp, int x0, int y0, int x1, int y1, fix u0, fix v0, fix u1, fix v1 );
96 void scale_bitmap_cc_asm(grs_bitmap *source_bmp, grs_bitmap *dest_bmp, int x0, int y0, int x1, int y1, fix u0, fix v0, fix u1, fix v1 );
97 void scale_bitmap_cc_asm_rle(grs_bitmap *source_bmp, grs_bitmap *dest_bmp, int x0, int y0, int x1, int y1, fix u0, fix v0, fix u1, fix v1 );
99 void scale_row_c( ubyte * sbits, ubyte * dbits, int width, fix u, fix du )
104 for ( i=0; i<width; i++ ) {
107 if ( c != Transparency_color )
115 #define FIND_SCALED_NUM(x,x0,x1,y0,y1) (fixmuldiv((x)-(x0),(y1)-(y0),(x1)-(x0))+(y0))
117 // Scales bitmap, bp, into vertbuf[0] to vertbuf[1]
118 void scale_bitmap(grs_bitmap *bp, grs_point *vertbuf ,int orientation)
120 grs_bitmap * dbp = &grd_curcanv->cv_bitmap;
123 fix clipped_x0, clipped_y0, clipped_x1, clipped_y1;
124 fix clipped_u0, clipped_v0, clipped_u1, clipped_v1;
125 fix xmin, xmax, ymin, ymax;
126 int dx0, dy0, dx1, dy1;
128 // Set initial variables....
130 x0 = vertbuf[0].x; y0 = vertbuf[0].y;
131 x1 = vertbuf[2].x; y1 = vertbuf[2].y;
134 xmax = i2f(dbp->bm_w)-fl2f(.5); ymax = i2f(dbp->bm_h)-fl2f(.5);
136 u0 = i2f(0); v0 = i2f(0);
137 u1 = i2f(bp->bm_w-1); v1 = i2f(bp->bm_h-1);
139 // Check for obviously offscreen bitmaps...
140 if ( (y1<=y0) || (x1<=x0) ) return;
141 if ( (x1<0 ) || (x0>=xmax) ) return;
142 if ( (y1<0 ) || (y0>=ymax) ) return;
144 clipped_u0 = u0; clipped_v0 = v0;
145 clipped_u1 = u1; clipped_v1 = v1;
147 clipped_x0 = x0; clipped_y0 = y0;
148 clipped_x1 = x1; clipped_y1 = y1;
150 // Clip the left, moving u0 right as necessary
152 clipped_u0 = FIND_SCALED_NUM(xmin,x0,x1,u0,u1);
156 // Clip the right, moving u1 left as necessary
158 clipped_u1 = FIND_SCALED_NUM(xmax,x0,x1,u0,u1);
162 // Clip the top, moving v0 down as necessary
164 clipped_v0 = FIND_SCALED_NUM(ymin,y0,y1,v0,v1);
168 // Clip the bottom, moving v1 up as necessary
170 clipped_v1 = FIND_SCALED_NUM(ymax,y0,y1,v0,v1);
174 dx0 = f2i(clipped_x0); dx1 = f2i(clipped_x1);
175 dy0 = f2i(clipped_y0); dy1 = f2i(clipped_y1);
177 if (dx1<=dx0) return;
178 if (dy1<=dy0) return;
182 Assert( dx1<dbp->bm_w );
183 Assert( dy1<dbp->bm_h );
184 Assert( f2i(u0)<=f2i(u1) );
185 Assert( f2i(v0)<=f2i(v1) );
186 Assert( f2i(u0)>=0 );
187 Assert( f2i(v0)>=0 );
188 Assert( u1<i2f(bp->bm_w) );
189 Assert( v1<i2f(bp->bm_h) );
191 //mprintf( 0, "(%.2f,%.2f) to (%.2f,%.2f) using (%.2f,%.2f) to (%.2f,%.2f)\n", f2fl(clipped_x0), f2fl(clipped_y0), f2fl(clipped_x1), f2fl(clipped_y1), f2fl(clipped_u0), f2fl(clipped_v0), f2fl(clipped_u1), f2fl(clipped_v1) );
193 dtemp = f2i(clipped_u1)-f2i(clipped_u0);
195 if ( bp->bm_flags & BM_FLAG_RLE ) {
196 if ( (dtemp < (f2i(clipped_x1)-f2i(clipped_x0))) && (dtemp>0) )
197 scale_bitmap_cc_asm_rle(bp, dbp, dx0, dy0, dx1, dy1, clipped_u0, clipped_v0, clipped_u1, clipped_v1 );
199 scale_bitmap_asm_rle(bp, dbp, dx0, dy0, dx1, dy1, clipped_u0, clipped_v0, clipped_u1, clipped_v1 );
201 if ( (dtemp < (f2i(clipped_x1)-f2i(clipped_x0))) && (dtemp>0) )
202 scale_bitmap_cc_asm(bp, dbp, dx0, dy0, dx1, dy1, clipped_u0, clipped_v0, clipped_u1, clipped_v1 );
204 scale_bitmap_asm(bp, dbp, dx0, dy0, dx1, dy1, clipped_u0, clipped_v0, clipped_u1, clipped_v1 );
209 void scale_bitmap_c(grs_bitmap *source_bmp, grs_bitmap *dest_bmp, int x0, int y0, int x1, int y1, fix u0, fix v0, fix u1, fix v1 )
213 ubyte * sbits, * dbits;
215 du = (u1-u0) / (x1-x0);
216 dv = (v1-v0) / (y1-y0);
220 for (y=y0; y<=y1; y++ ) {
221 sbits = &source_bmp->bm_data[source_bmp->bm_rowsize*f2i(v)];
222 dbits = &dest_bmp->bm_data[dest_bmp->bm_rowsize*y+x0];
225 for (x=x0; x<=x1; x++ ) {
226 *dbits++ = sbits[ u >> 16 ];
232 void scale_bitmap_asm(grs_bitmap *source_bmp, grs_bitmap *dest_bmp, int x0, int y0, int x1, int y1, fix u0, fix v0, fix u1, fix v1 )
237 du = (u1-u0) / (x1-x0);
238 dv = (v1-v0) / (y1-y0);
242 for (y=y0; y<=y1; y++ ) {
243 scale_row_asm_transparent( &source_bmp->bm_data[source_bmp->bm_rowsize*f2i(v)], &dest_bmp->bm_data[dest_bmp->bm_rowsize*y+x0], x1-x0+1, u0, du );
248 ubyte scale_rle_data[640];
250 void decode_row( grs_bitmap * bmp, int y )
252 int i, offset=4+bmp->bm_h;
255 offset += bmp->bm_data[4+i];
256 gr_rle_decode( &bmp->bm_data[offset], scale_rle_data );
259 void scale_bitmap_asm_rle(grs_bitmap *source_bmp, grs_bitmap *dest_bmp, int x0, int y0, int x1, int y1, fix u0, fix v0, fix u1, fix v1 )
264 du = (u1-u0) / (x1-x0);
265 dv = (v1-v0) / (y1-y0);
269 for (y=y0; y<=y1; y++ ) {
270 if ( f2i(v) != last_row ) {
272 decode_row( source_bmp, last_row );
274 scale_row_asm_transparent( scale_rle_data, &dest_bmp->bm_data[dest_bmp->bm_rowsize*y+x0], x1-x0+1, u0, du );
280 void scale_bitmap_cc_asm(grs_bitmap *source_bmp, grs_bitmap *dest_bmp, int x0, int y0, int x1, int y1, fix u0, fix v0, fix u1, fix v1 )
285 dv = (v1-v0) / (y1-y0);
287 rls_stretch_scanline_setup( (int)(x1-x0), f2i(u1)-f2i(u0) );
288 if ( scale_ydelta_minus_1 < 1 ) return;
289 rls_do_cc_setup_asm();
293 for (y=y0; y<=y1; y++ ) {
294 scale_source_ptr = &source_bmp->bm_data[source_bmp->bm_rowsize*f2i(v)+f2i(u0)];
295 scale_dest_ptr = &dest_bmp->bm_data[dest_bmp->bm_rowsize*y+x0];
296 scale_do_cc_scanline();
301 void scale_bitmap_cc_asm_rle(grs_bitmap *source_bmp, grs_bitmap *dest_bmp, int x0, int y0, int x1, int y1, fix u0, fix v0, fix u1, fix v1 )
304 int y, last_row = -1;
306 dv = (v1-v0) / (y1-y0);
308 rls_stretch_scanline_setup( (int)(x1-x0), f2i(u1)-f2i(u0) );
309 if ( scale_ydelta_minus_1 < 1 ) return;
310 rls_do_cc_setup_asm();
314 for (y=y0; y<=y1; y++ ) {
315 if ( f2i(v) != last_row ) {
317 decode_row( source_bmp, last_row );
319 //scale_source_ptr = &source_bmp->bm_data[source_bmp->bm_rowsize*f2i(v)+f2i(u0)];
320 scale_source_ptr = &scale_rle_data[f2i(u0)];
321 scale_dest_ptr = &dest_bmp->bm_data[dest_bmp->bm_rowsize*y+x0];
322 scale_do_cc_scanline();
329 // Run-length slice bitmap scan line stretcher
331 void DrawHorizontalRun(char *ScreenPtr, int RunLength, int Color)
335 for (i=0; i<RunLength; i++)
336 *ScreenPtr++ = Color;
339 void rls_stretch_scanline( char * source, char * dest, int XDelta, int YDelta )
341 int AdjUp, AdjDown, ErrorTerm;
342 int WholeStep, InitialPixelCount, FinalPixelCount, i, RunLength;
345 /* Minimum # of pixels in a run in this line */
346 WholeStep = XDelta / YDelta;
348 /* Error term adjust each time Y steps by 1; used to tell when one
349 extra pixel should be drawn as part of a run, to account for
350 fractional steps along the X axis per 1-pixel steps along Y */
351 AdjUp = (XDelta % YDelta) * 2;
353 /* Error term adjust when the error term turns over, used to factor
354 out the X step made at that time */
355 AdjDown = YDelta * 2;
357 /* Initial error term; reflects an initial step of 0.5 along the Y
359 ErrorTerm = (XDelta % YDelta) - (YDelta * 2);
361 /* The initial and last runs are partial, because Y advances only 0.5
362 for these runs, rather than 1. Divide one full run, plus the
363 initial pixel, between the initial and last runs */
364 InitialPixelCount = (WholeStep / 2) + 1;
365 FinalPixelCount = InitialPixelCount;
367 /* If the basic run length is even and there's no fractional
368 advance, we have one pixel that could go to either the initial
369 or last partial run, which we'll arbitrarily allocate to the
371 if ((AdjUp == 0) && ((WholeStep & 0x01) == 0))
375 /* If there're an odd number of pixels per run, we have 1 pixel that can't
376 be allocated to either the initial or last partial run, so we'll add 0.5
377 to error term so this pixel will be handled by the normal full-run loop */
378 if ((WholeStep & 0x01) != 0)
382 /* Draw the first, partial run of pixels */
383 //if ( *source != Transparency_color )
384 rep_stosb(dest, InitialPixelCount, *source );
385 dest += InitialPixelCount;
388 /* Draw all full runs */
389 for (i=0; i<(YDelta-1); i++)
391 RunLength = WholeStep; /* run is at least this long */
393 /* Advance the error term and add an extra pixel if the error term so indicates */
394 if ((ErrorTerm += AdjUp) > 0)
397 ErrorTerm -= AdjDown; /* reset the error term */
399 /* Draw this scan line's run */
401 //if ( *source != Transparency_color )
402 rep_stosb(dest, RunLength, *source );
408 /* Draw the final run of pixels */
409 //if ( *source != Transparency_color )
410 rep_stosb(dest, FinalPixelCount, *source );
418 void rls_stretch_scanline_setup( int XDelta, int YDelta )
420 scale_trans_color = Transparency_color & 0xFF;
421 scale_ydelta_minus_1 = YDelta - 1;
424 /* Minimum # of pixels in a run in this line */
425 scale_whole_step = XDelta / YDelta;
427 /* Error term adjust each time Y steps by 1; used to tell when one
428 extra pixel should be drawn as part of a run, to account for
429 fractional steps along the X axis per 1-pixel steps along Y */
430 scale_adj_up = (XDelta % YDelta) * 2;
432 /* Error term adjust when the error term turns over, used to factor
433 out the X step made at that time */
434 scale_adj_down = YDelta * 2;
436 /* Initial error term; reflects an initial step of 0.5 along the Y
438 scale_error_term = (XDelta % YDelta) - (YDelta * 2);
440 /* The initial and last runs are partial, because Y advances only 0.5
441 for these runs, rather than 1. Divide one full run, plus the
442 initial pixel, between the initial and last runs */
443 scale_initial_pixel_count = (scale_whole_step / 2) + 1;
444 scale_final_pixel_count = scale_initial_pixel_count;
446 /* If the basic run length is even and there's no fractional
447 advance, we have one pixel that could go to either the initial
448 or last partial run, which we'll arbitrarily allocate to the
450 if ((scale_adj_up == 0) && ((scale_whole_step & 0x01) == 0))
452 scale_initial_pixel_count--;
454 /* If there're an odd number of pixels per run, we have 1 pixel that can't
455 be allocated to either the initial or last partial run, so we'll add 0.5
456 to error term so this pixel will be handled by the normal full-run loop */
457 if ((scale_whole_step & 0x01) != 0)
459 scale_error_term += YDelta;