16/w_modex/XBLITBUF.CPP

   1 #include <conio.h>\r
   2 #include <mem.h>\r
   3 #include <stdio.h>\r
   4 \r
   5 #include "xtypes.hpp"\r
   6 #include "modex.hpp"\r
   7 #include "xpal.hpp"\r
   8 #include "xblitbuf.hpp"\r
   9 \r
  10 #define SEQU_ADDR       0x3C4\r
  11 #define GRACON_ADDR     0x3CE\r
  12 \r
  13 \r
  14 void\r
  15 clear_blitbuf(blitbuf *buf)\r
  16 {\r
  17     buf->xsize = 0;\r
  18     buf->ysize = 0;\r
  19 \r
  20     delete buf->image;\r
  21 }\r
  22 \r
  23 \r
  24 void\r
  25 fill_blitbuf(BYTE color, blitbuf *buf)\r
  26 {\r
  27     memset(buf->image, color, buf->xsize * buf->ysize);\r
  28 }\r
  29 \r
  30 \r
  31 void\r
  32 alloc_blitbuf(blitbuf *buf, DIST xsize, DIST ysize)\r
  33 {\r
  34     buf->xsize = xsize;\r
  35     buf->ysize = ysize;\r
  36     buf->image = new BYTE[xsize * ysize];\r
  37 }\r
  38 \r
  39 \r
  40 void\r
  41 lin_2_pln_blitbuf(blitbuf *buf)\r
  42 {\r
  43     int i, j, size;\r
  44     BYTE *oldbuf;\r
  45     BYTE *newbuf;\r
  46     BYTE *src_ptr;\r
  47     BYTE *dest_ptr;\r
  48 \r
  49     oldbuf = buf->image;\r
  50 \r
  51     size = (buf->xsize * buf->ysize);\r
  52     newbuf = new BYTE[size];\r
  53     size = (size >> 2);\r
  54 \r
  55     dest_ptr = newbuf;\r
  56 \r
  57     for (i=0; i < 4; i++) {\r
  58         src_ptr = oldbuf + i;\r
  59 \r
  60         j=size;\r
  61         while (j--) {\r
  62             *dest_ptr++ = *src_ptr;\r
  63             src_ptr += 4;\r
  64         }\r
  65     }\r
  66 \r
  67     buf->image = newbuf;\r
  68     delete oldbuf;\r
  69 }\r
  70 \r
  71 \r
  72 void\r
  73 pln_2_lin_blitbuf(blitbuf *buf)\r
  74 {\r
  75     int i, j, size;\r
  76     BYTE *oldbuf;\r
  77     BYTE *newbuf;\r
  78     BYTE *src_ptr;\r
  79     BYTE *dest_ptr;\r
  80 \r
  81     oldbuf = buf->image;\r
  82 \r
  83     size = (buf->xsize * buf->ysize);\r
  84     newbuf = new BYTE[size];\r
  85     size = (size >> 2);\r
  86 \r
  87     src_ptr = oldbuf;\r
  88     for (i=0; i < 4; i++) {\r
  89         dest_ptr = newbuf + i;\r
  90 \r
  91         j=size;\r
  92         while (j--) {\r
  93             *dest_ptr = *src_ptr++;\r
  94             dest_ptr += 4;\r
  95         }\r
  96     }\r
  97 \r
  98     buf->image = newbuf;\r
  99     delete oldbuf;\r
 100 }\r
 101 \r
 102 \r
 103 void\r
 104 vanilla_bitblitX(COORD x, COORD y, blitbuf *buf)\r
 105 {\r
 106     short int ysize, plane, i, j, loop, skip, rewind, len;\r
 107     short int xsize[4];\r
 108     BYTE *base_vga;\r
 109     BYTE *vga_ptr;\r
 110     BYTE *buf_ptr;\r
 111 \r
 112     // Length of bitmap in each plane\r
 113     plane = (x & 3);\r
 114     i = buf->xsize + plane - 1;\r
 115     xsize[0] = ((i--) >> 2);\r
 116     xsize[1] = ((i--) >> 2);\r
 117     xsize[2] = ((i--) >> 2);\r
 118     xsize[3] = (i >> 2) + 1;\r
 119 \r
 120     for (i=plane; i < 3; i++) {\r
 121         xsize[i]++;\r
 122     }\r
 123 \r
 124     ysize = buf->ysize;\r
 125     base_vga = RowsX[y] + (x >> 2) + activeStart;\r
 126     write_plane = -1;\r
 127 \r
 128     for (loop = 0; loop < 4; loop++) {\r
 129         len = xsize[plane];\r
 130         rewind = buf->xsize - (len << 2);\r
 131         skip = widthBytes - len;\r
 132         buf_ptr = buf->image + loop;\r
 133         vga_ptr = base_vga;\r
 134 \r
 135         outpw(SEQU_ADDR, plane_mask[plane++]);\r
 136         if (plane == 4) {\r
 137             plane = 0;\r
 138             base_vga++;\r
 139         }\r
 140 \r
 141         i=ysize;\r
 142         while (i--) {\r
 143             j=len;\r
 144             while (j--) {\r
 145                 *vga_ptr++ = *buf_ptr;\r
 146                 buf_ptr += 4;\r
 147             }\r
 148 \r
 149             buf_ptr += rewind;\r
 150             vga_ptr += skip;\r
 151         }\r
 152     }\r
 153 }\r
 154 \r
 155 \r
 156 void\r
 157 vanilla_getblitX(COORD x, COORD y, blitbuf *buf)\r
 158 {\r
 159     // Do nothing\r
 160 }\r
 161 \r
 162 \r
 163 void\r
 164 aligned_bitblitX(COORD x, COORD y, blitbuf *buf)\r
 165 {\r
 166     short int i, j, plane, skip, xsize, ysize;\r
 167     BYTE *base_vga;\r
 168     BYTE *vga_ptr;\r
 169     BYTE *buf_ptr;\r
 170 \r
 171     xsize = (buf->xsize >> 2);\r
 172     ysize = buf->ysize;\r
 173     skip = widthBytes - xsize;\r
 174     base_vga = RowsX[y] + (x >> 2) + activeStart;\r
 175 \r
 176     for (plane=0; plane < 4; plane++) {\r
 177         buf_ptr = buf->image + plane;\r
 178         vga_ptr = base_vga;\r
 179 \r
 180         outpw(SEQU_ADDR, plane_mask[plane]);\r
 181 \r
 182         i=ysize;\r
 183         while (i--) {\r
 184             j=xsize;\r
 185             while (j--) {\r
 186                 *vga_ptr++ = *buf_ptr;\r
 187                 buf_ptr += 4;\r
 188             }\r
 189             vga_ptr += skip;\r
 190         }\r
 191     }\r
 192 \r
 193     write_plane = 3;\r
 194 }\r
 195 \r
 196 \r
 197 void\r
 198 aligned_getblitX(COORD x, COORD y, blitbuf *buf)\r
 199 {\r
 200     short int i, j, plane, skip, xsize, ysize;\r
 201     BYTE *base_vga;\r
 202     BYTE *vga_ptr;\r
 203     BYTE *buf_ptr;\r
 204 \r
 205     xsize = (buf->xsize >> 2);\r
 206     ysize = buf->ysize;\r
 207     skip = widthBytes - xsize;\r
 208     base_vga = RowsX[y] + (x >> 2) + activeStart;\r
 209 \r
 210     for (plane=0; plane < 4; plane++) {\r
 211         buf_ptr = buf->image + plane;\r
 212         vga_ptr = base_vga;\r
 213 \r
 214         outpw(GRACON_ADDR, read_mask[plane]);\r
 215 \r
 216         i=ysize;\r
 217         while (i--) {\r
 218             j=xsize;\r
 219             while (j--) {\r
 220                 *buf_ptr = *vga_ptr++;\r
 221                 buf_ptr += 4;\r
 222             }\r
 223             vga_ptr += skip;\r
 224         }\r
 225     }\r
 226 \r
 227     read_plane = 3;\r
 228 }\r
 229 \r
 230 \r
 231 void\r
 232 transparent_bitblitX(COORD x, COORD y, blitbuf *buf)\r
 233 {\r
 234     short int i, j, plane, skip, xsize, ysize;\r
 235     BYTE *base_vga;\r
 236     BYTE *vga_ptr;\r
 237     BYTE *buf_ptr;\r
 238 \r
 239     xsize = (buf->xsize >> 2);\r
 240     ysize = buf->ysize;\r
 241     skip = widthBytes - xsize;\r
 242     base_vga = RowsX[y] + (x >> 2) + activeStart;\r
 243 \r
 244     for (plane=0; plane < 4; plane++) {\r
 245         buf_ptr = buf->image + plane;\r
 246         vga_ptr = base_vga;\r
 247 \r
 248         outpw(SEQU_ADDR, plane_mask[plane]);\r
 249 \r
 250         i=ysize;\r
 251         while (i--) {\r
 252             j=xsize;\r
 253             while (j--) {\r
 254                 if (*buf_ptr) {\r
 255                     *vga_ptr = *buf_ptr;\r
 256                 }\r
 257                 vga_ptr++;\r
 258                 buf_ptr += 4;\r
 259             }\r
 260             vga_ptr += skip;\r
 261         }\r
 262     }\r
 263 \r
 264     write_plane = 3;\r
 265 }\r
 266 \r
 267 \r
 268 void\r
 269 planar_bitblitX(COORD x, COORD y, blitbuf *buf)\r
 270 {\r
 271     short int i, plane, xsize, ysize;\r
 272     BYTE *base_vga;\r
 273     BYTE *vga_ptr;\r
 274     BYTE *buf_ptr;\r
 275 \r
 276     xsize = (buf->xsize >> 2);\r
 277     ysize = buf->ysize;\r
 278     base_vga = RowsX[y] + (x >> 2) + activeStart;\r
 279     buf_ptr = buf->image;\r
 280 \r
 281     for (plane=0; plane < 4; plane++) {\r
 282         vga_ptr = base_vga;\r
 283 \r
 284         outpw(SEQU_ADDR, plane_mask[plane]);\r
 285 \r
 286         i=ysize;\r
 287         while (i--) {\r
 288             memcpy(vga_ptr, buf_ptr, xsize);\r
 289             vga_ptr += widthBytes;\r
 290             buf_ptr += xsize;\r
 291         }\r
 292     }\r
 293 \r
 294     write_plane = 3;\r
 295 }\r
 296 \r
 297 \r
 298 void\r
 299 planar_getblitX(COORD x, COORD y, blitbuf *buf)\r
 300 {\r
 301     short int i, plane, xsize, ysize;\r
 302     BYTE *base_vga;\r
 303     BYTE *vga_ptr;\r
 304     BYTE *buf_ptr;\r
 305 \r
 306     xsize = (buf->xsize >> 2);\r
 307     ysize = buf->ysize;\r
 308     base_vga = RowsX[y] + (x >> 2) + activeStart;\r
 309     buf_ptr = buf->image;\r
 310 \r
 311     for (plane=0; plane < 4; plane++) {\r
 312         vga_ptr = base_vga;\r
 313 \r
 314         outpw(GRACON_ADDR, read_mask[plane]);\r
 315 \r
 316         i=ysize;\r
 317         while (i--) {\r
 318             memcpy(buf_ptr, vga_ptr, xsize);\r
 319             vga_ptr += widthBytes;\r
 320             buf_ptr += xsize;\r
 321         }\r
 322     }\r
 323 \r
 324     read_plane = 3;\r
 325 }\r
 326 \r
 327 \r
 328 void\r
 329 wide_bitblitX(COORD y, blitbuf *buf)\r
 330 {\r
 331     short int bufsize;\r
 332     BYTE *vga_ptr;\r
 333     BYTE *buf_ptr;\r
 334 \r
 335     write_plane = 3;\r
 336     buf_ptr = buf->image;\r
 337     vga_ptr = RowsX[y] + activeStart;\r
 338     bufsize = (buf->ysize * widthBytes);\r
 339 \r
 340     outpw(SEQU_ADDR, PLANE_0);\r
 341     memcpy(vga_ptr, buf_ptr, bufsize);\r
 342     buf_ptr += bufsize;\r
 343 \r
 344     outpw(SEQU_ADDR, PLANE_1);\r
 345     memcpy(vga_ptr, buf_ptr, bufsize);\r
 346     buf_ptr += bufsize;\r
 347 \r
 348     outpw(SEQU_ADDR, PLANE_2);\r
 349     memcpy(vga_ptr, buf_ptr, bufsize);\r
 350     buf_ptr += bufsize;\r
 351 \r
 352     outpw(SEQU_ADDR, PLANE_3);\r
 353     memcpy(vga_ptr, buf_ptr, bufsize);\r
 354 }\r
 355 \r
 356 \r
 357 void\r
 358 wide_getblitX(COORD y, blitbuf *buf)\r
 359 {\r
 360     short int bufsize;\r
 361     BYTE *vga_ptr;\r
 362     BYTE *buf_ptr;\r
 363 \r
 364     read_plane = 3;\r
 365     buf_ptr = buf->image;\r
 366     vga_ptr = RowsX[y] + activeStart;\r
 367     bufsize = (buf->ysize * widthBytes);\r
 368 \r
 369     outpw(GRACON_ADDR, READ_PLANE_0);\r
 370     memcpy(buf_ptr, vga_ptr, bufsize);\r
 371     buf_ptr += bufsize;\r
 372 \r
 373     outpw(GRACON_ADDR, READ_PLANE_1);\r
 374     memcpy(buf_ptr, vga_ptr, bufsize);\r
 375     buf_ptr += bufsize;\r
 376 \r
 377     outpw(GRACON_ADDR, READ_PLANE_2);\r
 378     memcpy(buf_ptr, vga_ptr, bufsize);\r
 379     buf_ptr += bufsize;\r
 380 \r
 381     outpw(GRACON_ADDR, READ_PLANE_3);\r
 382     memcpy(buf_ptr, vga_ptr, bufsize);\r
 383 }\r
 384 \r
 385 \r
 386 void\r
 387 save_blitbufPCX(char *fname, blitbuf *buf)\r
 388 {\r
 389     FILE *fp;\r
 390     unsigned int i, size, temp_int;\r
 391     BYTE VGA_pal[768];\r
 392     BYTE *buf_ptr;\r
 393     BYTE temp_char, match, count;\r
 394 \r
 395     fp = fopen(fname, "wb");\r
 396 \r
 397     if (fp != NULL) {\r
 398         // Write manufacturer's byte\r
 399         temp_char = 10;\r
 400         fwrite(&temp_char, 1, 1, fp);\r
 401 \r
 402         // Write version of PCX.  5 = 256 color (PCX Version 5.0)\r
 403         temp_char = 5;\r
 404         fwrite(&temp_char, 1, 1, fp);\r
 405 \r
 406         // Write encoding type, always 1 for RLE.\r
 407         temp_char = 1;\r
 408         fwrite(&temp_char, 1, 1, fp);\r
 409 \r
 410         // Write bits_per_pixel = 8.\r
 411         temp_char = 8;\r
 412         fwrite(&temp_char, 1, 1, fp);\r
 413 \r
 414         // Write starting X and Y coords\r
 415         temp_int = 0;\r
 416         fwrite(&temp_int, 2, 1, fp);\r
 417         fwrite(&temp_int, 2, 1, fp);\r
 418 \r
 419         // Write X size\r
 420         temp_int = (buf->xsize - 1);\r
 421         fwrite(&temp_int, 2, 1, fp);\r
 422 \r
 423         // Write Y size\r
 424         temp_int = (buf->ysize - 1);\r
 425         fwrite(&temp_int, 2, 1, fp);\r
 426 \r
 427         // Do HRES and VRES **\r
 428         temp_int = buf->xsize;\r
 429         fwrite(&temp_int, 2, 1, fp);\r
 430         temp_int = buf->ysize;\r
 431         fwrite(&temp_int, 2, 1, fp);\r
 432 \r
 433         // Write 16 color palette, not used.\r
 434         temp_int = 0;\r
 435         i=24;\r
 436         while (i--) {\r
 437             fwrite(&temp_int, 2, 1, fp);\r
 438         }\r
 439 \r
 440         // Write vmode byte.\r
 441         temp_char = 0;\r
 442         fwrite(&temp_char, 1, 1, fp);\r
 443 \r
 444         // Write bit_planes\r
 445         temp_char = 1;\r
 446         fwrite(&temp_char, 1, 1, fp);\r
 447 \r
 448         // Write bytes_per_line\r
 449         temp_int = buf->xsize;\r
 450         fwrite(&temp_int, 2, 1, fp);\r
 451 \r
 452         // Write palette type\r
 453         temp_int = 1;\r
 454         fwrite(&temp_int, 2, 1, fp);\r
 455 \r
 456         // Write junk filler\r
 457         temp_int = 0;\r
 458         i=29;\r
 459         while (i--) {\r
 460             fwrite(&temp_int, 2, 1, fp);\r
 461         }\r
 462 \r
 463         // Write the actual image\r
 464         buf_ptr = buf->image;\r
 465         size = (buf->xsize * buf->ysize);\r
 466 \r
 467         count = 0;\r
 468         match = *buf_ptr;\r
 469 \r
 470         i=size;\r
 471         while (i--) {\r
 472             temp_char = *buf_ptr++;\r
 473 \r
 474             if ((temp_char == match) && (count < 63)) {\r
 475                count++;\r
 476             } else {\r
 477                 if ((count == 1) && (match < 192)) {\r
 478                     // Write single byte\r
 479                     fwrite(&match,1,1,fp);\r
 480                 } else {\r
 481                     // Write run of pixels\r
 482                     count += 192;\r
 483                     fwrite(&count, 1, 1, fp);\r
 484                     fwrite(&match, 1, 1, fp);\r
 485                 }\r
 486                 count = 1;\r
 487                 match = temp_char;\r
 488             }\r
 489         }\r
 490 \r
 491         if ((count == 1) && (match < 192)) {\r
 492             // Write single byte\r
 493             fwrite(&match,1,1,fp);\r
 494         } else {\r
 495             // Write run of pixels\r
 496             count += 192;\r
 497             fwrite(&count, 1, 1, fp);\r
 498             fwrite(&match, 1, 1, fp);\r
 499         }\r
 500 \r
 501         // Write palette verification byte\r
 502         temp_char = 12;\r
 503         fwrite(&temp_char, 1, 1, fp);\r
 504 \r
 505         get_paletteX(VGA_pal);\r
 506 \r
 507         // Write 256 color palette\r
 508         fwrite(VGA_pal, 1, 768, fp);\r
 509 \r
 510         fclose(fp);\r
 511     }\r
 512 }\r
 513 \r
 514 \r
 515 int\r
 516 load_blitbufPCX(char *fname, blitbuf *buf)\r
 517 {\r
 518     FILE *fp;\r
 519     int size;\r
 520     BYTE VGA_pal[768];\r
 521     BYTE PCX_byte, RLE_byte;\r
 522     BYTE *buf_ptr;\r
 523     BYTE *end_of_buf;\r
 524 \r
 525     fp = fopen(fname, "rb");\r
 526 \r
 527     if (fp == NULL) {\r
 528         buf->xsize = 0;\r
 529         buf->ysize = 0;\r
 530         buf->image = NULL;\r
 531         return 0;\r
 532     } else {\r
 533         fseek(fp, 8, SEEK_SET);\r
 534         fread(&buf->xsize, 2, 1, fp);\r
 535         fread(&buf->ysize, 2, 1, fp);\r
 536 \r
 537         buf->xsize++;\r
 538         buf->ysize++;\r
 539 \r
 540         size = (buf->xsize * buf->ysize);\r
 541 \r
 542         buf->image = new BYTE[size];\r
 543         buf_ptr = buf->image;\r
 544         end_of_buf = buf_ptr + size;\r
 545 \r
 546         // Load 256 color PCX palette\r
 547         fseek(fp, -768, SEEK_END);\r
 548         fread(VGA_pal, 1, 768, fp);\r
 549 \r
 550         set_paletteX(VGA_pal);\r
 551 \r
 552         fseek(fp, 128, SEEK_SET);\r
 553 \r
 554         while (buf_ptr < end_of_buf) {\r
 555             // Read next packet\r
 556             fread(&PCX_byte, 1, 1, fp);\r
 557 \r
 558             if (PCX_byte < 192) {\r
 559                 // Raw Pixel\r
 560                 *buf_ptr++ = PCX_byte;\r
 561             } else {\r
 562                 // RLE Pixels\r
 563                 PCX_byte = PCX_byte & 0x3F;\r
 564                 fread(&RLE_byte, 1, 1, fp);\r
 565                 memset(buf_ptr, RLE_byte, PCX_byte);\r
 566                 buf_ptr += PCX_byte;\r
 567             }\r
 568         }\r
 569 \r
 570         fclose(fp);\r
 571         return 1;\r
 572     }\r
 573 }\r
 574 \r
 575 \r
 576 void\r
 577 scale_blitbuf(DIST dest_x, DIST dest_y, blitbuf *buf1, blitbuf *buf2)\r
 578 {\r
 579     unsigned long ErrorAccX, ErrorAccY, ErrorAdjX, ErrorAdjY;\r
 580     DIST oldx, oldy, newx, newy;\r
 581     short int i, j, count;\r
 582     BYTE *src_base;\r
 583     BYTE *src_ptr;\r
 584     BYTE *dest_ptr;\r
 585     BYTE *newbuf;\r
 586 \r
 587     oldx = buf1->xsize;\r
 588     oldy = buf1->ysize;\r
 589     newx = dest_x;\r
 590     newy = dest_y;\r
 591 \r
 592     newbuf = new BYTE[newx * newy];\r
 593 \r
 594     src_base = buf1->image;\r
 595     dest_ptr = newbuf;\r
 596 \r
 597     // My bitmap scaling routine.  As you probably noticed, it's\r
 598     // pretty Bresenhammy!\r
 599 \r
 600     ErrorAccY = 0x8000;\r
 601 \r
 602     if (newx > oldx) {\r
 603         // Biggering\r
 604         ErrorAdjX = ((((unsigned long)newx) << 16) /\r
 605                      (((unsigned long)oldx)));\r
 606 \r
 607         ErrorAdjY = ((((unsigned long)newy) << 16) /\r
 608                      (((unsigned long)oldy)));\r
 609 \r
 610         i=oldy;\r
 611         while (i--) {\r
 612             ErrorAccX = 0x8000;\r
 613             src_ptr = src_base;\r
 614 \r
 615             j=oldx;\r
 616             while (j--) {\r
 617                 ErrorAccX += ErrorAdjX;\r
 618                 if (count = (ErrorAccX >> 16)) {\r
 619                     ErrorAccX &= 0xFFFFL;\r
 620                     while (count--) {\r
 621                         *dest_ptr++ = *src_ptr;\r
 622                     }\r
 623                 }\r
 624                 src_ptr++;\r
 625             }\r
 626 \r
 627             ErrorAccY += ErrorAdjY;\r
 628             count = (ErrorAccY >> 16) - 1;\r
 629             while (count--) {\r
 630                 memcpy(dest_ptr, dest_ptr - newx, newx);\r
 631                 dest_ptr += newx;\r
 632             }\r
 633             ErrorAccY &= 0xFFFFL;\r
 634             src_base += oldx;\r
 635         }\r
 636     } else {\r
 637         // Smallering\r
 638         ErrorAdjX = ((((unsigned long)oldx) << 16) /\r
 639                      (((unsigned long)newx)));\r
 640 \r
 641         ErrorAdjY = ((((unsigned long)oldy) << 16) /\r
 642                      (((unsigned long)newy)));\r
 643 \r
 644         i=newy;\r
 645         while (i--) {\r
 646             ErrorAccX = 0x8000;\r
 647             src_ptr = src_base;\r
 648 \r
 649             j=newx;\r
 650             while (j--) {\r
 651                 *dest_ptr++ = *src_ptr;\r
 652                 ErrorAccX += ErrorAdjX;\r
 653                 src_ptr += (ErrorAccX >> 16);\r
 654                 ErrorAccX &= 0xFFFFL;\r
 655             }\r
 656 \r
 657             ErrorAccY += ErrorAdjY;\r
 658             src_base += (oldx * (ErrorAccY >> 16));\r
 659             ErrorAccY &= 0xFFFFL;\r
 660         }\r
 661     }\r
 662 \r
 663     if (buf2 == NULL) {\r
 664         delete buf1->image;\r
 665         buf1->xsize = newx;\r
 666         buf1->ysize = newy;\r
 667         buf1->image = newbuf;\r
 668     } else {\r
 669         if (buf2->image != NULL) {\r
 670             delete buf2->image;\r
 671         }\r
 672         buf2->xsize = newx;\r
 673         buf2->ysize = newy;\r
 674         buf2->image = newbuf;\r
 675     }\r
 676 }\r
 677 \r
 678 \r
 679 void\r
 680 vertical_scale_blitbuf(DIST dest_y, blitbuf *buf1, blitbuf *buf2)\r
 681 {\r
 682     unsigned long ErrorAccY, ErrorAdjY;\r
 683     DIST xsize, oldy, newy;\r
 684     short int i, count;\r
 685     BYTE *src_ptr;\r
 686     BYTE *dest_ptr;\r
 687     BYTE *newbuf;\r
 688 \r
 689     xsize = buf1->xsize;\r
 690     oldy = buf1->ysize;\r
 691     newy = dest_y;\r
 692 \r
 693     newbuf = new BYTE[xsize * newy];\r
 694 \r
 695     src_ptr = buf1->image;\r
 696     dest_ptr = newbuf;\r
 697 \r
 698     // My bitmap scaling routine.  As you probably noticed, it's\r
 699     // pretty Bresenhammy!\r
 700 \r
 701     ErrorAccY = 0x8000;\r
 702     ErrorAdjY = ((((unsigned long)newy) << 16) /\r
 703                  (((unsigned long)oldy)));\r
 704 \r
 705     if (newy >= oldy) {\r
 706         // Biggering\r
 707         i=oldy;\r
 708         while (i--) {\r
 709             ErrorAccY += ErrorAdjY;\r
 710             if (count = (ErrorAccY >> 16)) {\r
 711                 ErrorAccY &= 0xFFFFL;\r
 712 \r
 713                 while (count--) {\r
 714                     memcpy(dest_ptr, src_ptr, xsize);\r
 715                     dest_ptr += xsize;\r
 716                 }\r
 717             }\r
 718 \r
 719             src_ptr += xsize;\r
 720         }\r
 721     } else {\r
 722         // Smallering\r
 723         i=oldy;\r
 724         while (i--) {\r
 725             ErrorAccY += ErrorAdjY;\r
 726             if (ErrorAccY & ~0xFFFFL) {\r
 727                 ErrorAccY &= 0xFFFFL;\r
 728                 memcpy(dest_ptr, src_ptr, xsize);\r
 729                 dest_ptr += xsize;\r
 730             }\r
 731 \r
 732             src_ptr += xsize;\r
 733         }\r
 734     }\r
 735 \r
 736     if (buf2 == NULL) {\r
 737         delete buf1->image;\r
 738         buf1->ysize = newy;\r
 739         buf1->image = newbuf;\r
 740     } else {\r
 741         if (buf2->image != NULL) {\r
 742             delete buf2->image;\r
 743         }\r
 744         buf2->xsize = xsize;\r
 745         buf2->ysize = newy;\r
 746         buf2->image = newbuf;\r
 747     }\r
 748 }\r
 749 \r
 750 \r
 751 void\r
 752 greyscale_blitbuf(blitbuf *buf)\r
 753 {\r
 754     BYTE temp_pal[768];\r
 755     BYTE *buf_ptr;\r
 756     BYTE *temp;\r
 757     BYTE r, g;\r
 758     unsigned int i;\r
 759 \r
 760     buf_ptr = buf->image;\r
 761 \r
 762     get_paletteX(temp_pal, 0);\r
 763 \r
 764     for (i = (buf->xsize * buf->ysize); i; i--) {\r
 765         temp = temp_pal + ((*buf_ptr) * 3);\r
 766         r = *temp++;\r
 767         g = *temp++;\r
 768 \r
 769         *buf_ptr++ = ((r * 19) + (g * 37) + (*temp << 3)) >> 6;\r
 770     }\r
 771 }\r
 772 \r
 773 \r
 774 void\r
 775 RGB_blitbuf(blitbuf *buf)\r
 776 {\r
 777     BYTE temp_pal[768];\r
 778     BYTE *buf_ptr;\r
 779     BYTE *temp;\r
 780     BYTE r, g, b;\r
 781     unsigned int i;\r
 782 \r
 783     buf_ptr = buf->image;\r
 784 \r
 785     get_paletteX(temp_pal, 0);\r
 786 \r
 787     for (i = (buf->xsize * buf->ysize); i; i--) {\r
 788         temp = temp_pal + ((*buf_ptr) * 3);\r
 789         r = (*temp) + 4;\r
 790         temp++;\r
 791         g = (*temp) + 4;\r
 792         temp++;\r
 793         b = (*temp) + 8;\r
 794 \r
 795         *buf_ptr++ = ((r >> 3) << 5) + ((g >> 3) << 2) + (b >> 4);\r
 796     }\r
 797 }\r
 798 \r
 799 \r
 800 void\r
 801 flip_vertical_blitbuf(blitbuf *buf)\r
 802 {\r
 803     BYTE *top;\r
 804     BYTE *bottom;\r
 805     BYTE *temp;\r
 806     DIST i, x, y;;\r
 807 \r
 808     x = buf->xsize;\r
 809     y = buf->ysize;\r
 810 \r
 811     temp = new BYTE[x];\r
 812 \r
 813     top = buf->image;\r
 814     bottom = buf->image + (x * (y-1));\r
 815 \r
 816     i = (y >> 1);\r
 817     while (i--) {\r
 818         memcpy(temp, top, x);\r
 819         memcpy(top, bottom, x);\r
 820         memcpy(bottom, temp, x);\r
 821         top += x;\r
 822         bottom -= x;\r
 823     }\r
 824 \r
 825     delete temp;\r
 826 }\r
 827 \r
 828 \r
 829 void\r
 830 flip_horizontal_blitbuf(blitbuf *buf)\r
 831 {\r
 832     BYTE *buf_ptr;\r
 833     BYTE *temp_ptr;\r
 834     BYTE *temp;\r
 835     DIST i, j, x;\r
 836 \r
 837     x = buf->xsize;\r
 838 \r
 839     temp = new BYTE[x];\r
 840 \r
 841     buf_ptr = buf->image;\r
 842 \r
 843     i = buf->ysize;\r
 844     while (i--) {\r
 845         memcpy(temp, buf_ptr, x);\r
 846         temp_ptr = temp + (x - 1);\r
 847         j=x;\r
 848         while (j--) {\r
 849             *buf_ptr++ = *temp_ptr--;\r
 850         }\r
 851     }\r
 852 \r
 853     delete temp;\r
 854 }\r
 855 \r
 856 \r
 857 void\r
 858 brighten_blitbuf(SBYTE factor, blitbuf *buf)\r
 859 {\r
 860     BYTE *buf_ptr;\r
 861     short int scratch;\r
 862     unsigned int i;\r
 863 \r
 864     buf_ptr = buf->image;\r
 865 \r
 866     for (i = (buf->xsize * buf->ysize); i; i--) {\r
 867         scratch = (*buf_ptr + factor);\r
 868         if (scratch <= 0) {\r
 869             *buf_ptr++ = 0;\r
 870         } else if (scratch >= 63) {\r
 871             *buf_ptr++ = 63;\r
 872         } else {\r
 873             *buf_ptr++ = scratch;\r
 874         }\r
 875     }\r
 876 }\r
 877 \r
 878 \r
 879 void\r
 880 stretch_blitbuf(BYTE factor, blitbuf *buf)\r
 881 {\r
 882     BYTE *buf_ptr;\r
 883     short int scratch;\r
 884     unsigned int i;\r
 885 \r
 886     buf_ptr = buf->image;\r
 887 \r
 888     for (i = (buf->xsize * buf->ysize); i; i--) {\r
 889         scratch = ((((*buf_ptr - 32) * factor) + 8) >> 4) + 32;\r
 890         if (scratch <= 0) {\r
 891             *buf_ptr++ = 0;\r
 892         } else if (scratch >= 63) {\r
 893             *buf_ptr++ = 63;\r
 894         } else {\r
 895             *buf_ptr++ = scratch;\r
 896         }\r
 897     }\r
 898 }\r
 899 \r
 900 \r
 901 void\r
 902 pixelize(DIST pixfactor, blitbuf *buf)\r
 903 {\r
 904     // Do nothing\r
 905 }\r
 906 \r
 907 \r
 908 void\r
 909 GREYconvolve_blitbuf(BYTE *kernel, blitbuf *buf)\r
 910 {\r
 911     // Do nothing\r
 912 }\r
 913 \r
 914 \r
 915 void\r
 916 RGBconvolve_blitbuf(BYTE *kernel, blitbuf *buf)\r
 917 {\r
 918     // Do nothing\r
 919 }\r
 920 \r
 921 \r
 922 void\r
 923 scale_scanline(BYTE *source, BYTE *dest, DIST smap_size, DIST dmap_size,\r
 924     DIST dline_size)\r
 925 {\r
 926     unsigned long ErrorAcc, ErrorAdj;\r
 927     short int i, temp, invert;\r
 928 \r
 929     ErrorAcc = 0x8000;\r
 930 \r
 931     // Prepare for backwards scanlines\r
 932     if (dline_size >= 0) {\r
 933         invert = 0;\r
 934     } else {\r
 935         invert = 1;\r
 936         dline_size = -dline_size;\r
 937     }\r
 938 \r
 939     if (dline_size > smap_size) {\r
 940         // Biggering\r
 941         if (smap_size == 0) {\r
 942             return;\r
 943         }\r
 944         ErrorAdj = ((((unsigned long)dline_size) << 16) /\r
 945                     (((unsigned long)smap_size)));\r
 946 \r
 947         i=smap_size;\r
 948         while (i--) {\r
 949             ErrorAcc += ErrorAdj;\r
 950             temp = (ErrorAcc >> 16);\r
 951             ErrorAcc &= 0xFFFFL;\r
 952             while (temp--) {\r
 953                 *dest++ = *source;\r
 954             }\r
 955             source++;\r
 956         }\r
 957     } else {\r
 958         // Smallering\r
 959         if (dline_size == 0) {\r
 960             memset(dest, 0, dmap_size);\r
 961         } else {\r
 962             temp = dmap_size - dline_size;\r
 963             i = temp >> 1;\r
 964             temp -= i;\r
 965             while (i--) {\r
 966                 *dest++ = 0;\r
 967             }\r
 968 \r
 969             ErrorAdj = ((((unsigned long)smap_size) << 16) /\r
 970                         (((unsigned long)dline_size)));\r
 971 \r
 972             i=dline_size;\r
 973 \r
 974             while (i--) {\r
 975                 *dest++ = *source;\r
 976                 ErrorAcc += ErrorAdj;\r
 977                 source += (ErrorAcc >> 16);\r
 978                 ErrorAcc &= 0xFFFFL;\r
 979             }\r
 980 \r
 981             while (temp--) {\r
 982                 *dest++ = 0;\r
 983             }\r
 984         }\r
 985     }\r
 986 }\r
 987 \r
 988 \r
 989 int\r
 990 load_blitbufRAW(char *rawname, char *palname, blitbuf *buf)\r
 991 {\r
 992     FILE *fp;\r
 993     BYTE VGA_pal[768];\r
 994 \r
 995     fp = fopen(rawname, "rb");\r
 996 \r
 997     if (fp == NULL) {\r
 998         buf->xsize = 0;\r
 999         buf->ysize = 0;\r
1000         buf->image = NULL;\r
1001         return 0;\r
1002     } else {\r
1003         buf->xsize = 320;\r
1004         buf->ysize = 200;\r
1005         buf->image = new BYTE[64000L];\r
1006 \r
1007         // Load image\r
1008         fread(buf->image, 64000L, 1, fp);\r
1009 \r
1010         if (palname == NULL) {\r
1011             fread(VGA_pal, 1, 768, fp);\r
1012             set_paletteX(VGA_pal);\r
1013             fclose(fp);\r
1014         } else {\r
1015             fclose(fp);\r
1016             fp = fopen(palname, "rb");\r
1017             if (fp != NULL) {\r
1018                 fread(VGA_pal, 1, 768, fp);\r
1019                 set_paletteX(VGA_pal);\r
1020                 fclose(fp);\r
1021             }\r
1022         }\r
1023 \r
1024         return 1;\r
1025     }\r
1026 }\r
1027 \r