home *** CD-ROM | disk | FTP | other *** search
/ Il CD di internet / CD.iso / SOURCE / D / SVGALIB / SVGALIB1.TAR / svgalib / demos / testaccel.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-12-17  |  15.5 KB  |  808 lines
  1. /* Program to test all accelerator functions and the 8 bit
  2.    per color color lookup functions. */
  3. /* written by Michael Weller (eowmob@exp-math.uni-essen.de) */
  4.  
  5. #include <stdio.h>
  6. #include <stdlib.h>
  7. #include <unistd.h>
  8. #include <math.h>
  9. #include <string.h>
  10. #include <time.h>
  11. #include "vga.h"
  12. #include "clut.xbm"
  13. #include "sixbpp.xbm"
  14. #include "eightbpp.xbm"
  15. #include "fish_monster.h"
  16.  
  17. #define RED(i)        (0)
  18. #define GREEN(i)    (0)
  19. #define BLUE(i)        (i)
  20.  
  21. #define LOGO_NAME    "linuxlogo.bmp"
  22. #define LOGO_WIDTH    201
  23. #define LOGO_HEIGHT    85
  24.  
  25. #undef BITFRAME
  26.  
  27. typedef struct {
  28.     int n;
  29.     int pels;
  30.     int width;
  31.     int offset;
  32.     /*
  33.     int xmin[n];
  34.     int xmax[n]; */
  35.     } hlinelst;
  36.  
  37. /*Adjust hlist for new xcoord*/
  38. inline void adj_hlilst(hlinelst *lst,register int x)
  39. {
  40. register int i,*ptr;
  41.  
  42. i=x;
  43. x-=lst->offset;
  44. lst->offset=i;
  45.  
  46. i=(lst->n)<<1;
  47. ptr=(int *)(((char *)lst)+sizeof(hlinelst));
  48.  
  49. while(i--)
  50.     *ptr++ += x;
  51. }
  52.  
  53. inline int sizhlilst(int n)
  54. {
  55. return sizeof(hlinelst)+(sizeof(int)*(n<1?2:(n<<1)));
  56. }
  57.  
  58. inline int isqr(int i)
  59. {
  60. return i*i;
  61. }
  62.  
  63. int waitmode=1;
  64.  
  65. void my_wait(void)
  66. {
  67. if(waitmode)
  68.     vga_getch();
  69. else    sleep(1);
  70. }
  71.  
  72. void setcol(vga_modeinfo *modeinfo)
  73. {
  74. int i;
  75.  
  76. if(modeinfo->colors==256)
  77.     for(i=0;i<256;i++)
  78.         vga_setpalette(i,(i&7)*0x9,((i>>3)&7)*0x9,((i>>6)&3)*0x15);
  79. else if(modeinfo->colors<256)
  80.     for(i=0;i<16;i++)
  81.         vga_setegacolor(i);
  82. }
  83.  
  84. int colorcol(int column,int width,int xmax)
  85. {
  86. int color;
  87.  
  88. color=((column<<8)-column)/xmax;
  89. if(width!=8)
  90.     color&=0xfc;
  91. return color;
  92. }
  93.  
  94. void drawtwidth(vga_modeinfo *modeinfo,char *bits,int x,int y,int tw,int th,int width)
  95. {
  96. unsigned char color;
  97. int i, j, k, xmax, offset;
  98.  
  99. tw=(tw+7)>>3;
  100. th<<=1;
  101. th+=x;
  102. xmax = vga_getxdim() - 1;
  103. y*=modeinfo->linewidth;
  104.  
  105. for(i=x;i<th;i++)
  106.     {
  107.     color=colorcol(xmax-i,width,xmax);
  108.     offset=y+i;
  109.  
  110.     if((i-x)&1)
  111.         bits-=tw;
  112.     j=tw;
  113.     while(j--)
  114.         {
  115.         k=1;
  116.         do    {
  117.             if(*bits & k)
  118.                 {
  119.                 vga_setpage(offset >> 16);
  120.                 graph_mem[offset&0xffff]=color;
  121.                 }
  122.             offset+=modeinfo->linewidth;
  123.             if(*bits & k)
  124.                 {
  125.                 vga_setpage(offset >> 16);
  126.                 graph_mem[offset&0xffff]=color;
  127.                 }
  128.             offset+=modeinfo->linewidth;
  129.             k<<=1;
  130.             }
  131.         while(k&0xff);
  132.         bits++;
  133.         }
  134.     }
  135. }
  136.  
  137. void drawwidth(int mode,vga_modeinfo *modeinfo,int line,int height,int width)
  138. {
  139. unsigned char color;
  140. int i, xmax, j, offset;
  141.  
  142. xmax = vga_getxdim() - 1;
  143.  
  144. for(i=0; i<xmax; i++)
  145.     {
  146.     color=colorcol(i,width,xmax);
  147.     offset=line*(modeinfo->linewidth)+i;
  148.  
  149.     j=height;
  150.     while(j--)
  151.         {
  152.         vga_setpage(offset >> 16);
  153.         graph_mem[offset&0xffff]=color;
  154.         offset+=modeinfo->linewidth;
  155.         }
  156.     }
  157.  
  158. j=clut_width+sixbpp_width;
  159. j=height-j-j;
  160. j/=3;
  161.  
  162. drawtwidth(modeinfo,clut_bits,(xmax-2*clut_height)>>1,j+line,clut_width,clut_height,width);
  163. j+=j+clut_width;
  164. if(width==6)
  165.     drawtwidth(modeinfo,sixbpp_bits,(xmax-2*sixbpp_height)>>1,j+line,sixbpp_width,sixbpp_height,width);
  166. else
  167.     drawtwidth(modeinfo,eightbpp_bits,(xmax-2*eightbpp_height)>>1,j+line,eightbpp_width,eightbpp_height,width);
  168. }
  169.  
  170. void testwidth(int mode,vga_modeinfo *modeinfo)
  171. {
  172. int ymax, i, old_flags;
  173.  
  174. ymax=vga_getydim();
  175.  
  176. if(vga_getxdim()<640)
  177.     puts("  Warning: Resolution too small, displayed text is\n"
  178.          "           probably scrambled.\n");
  179. if(vga_ext_set(VGA_EXT_AVAILABLE,VGA_AVAIL_FLAGS)&VGA_CLUT8)
  180.     {
  181.     old_flags=vga_ext_set(VGA_EXT_SET,VGA_CLUT8);
  182.  
  183.     for(i=0; i<256; i++)
  184.         vga_setpalette(i,RED(i),GREEN(i),BLUE(i));
  185.  
  186.     puts("  Has support for CLUT width 8 bit");
  187.     drawwidth(mode,modeinfo,0,ymax>>1,6);
  188.     drawwidth(mode,modeinfo,ymax>>1,ymax>>1,8);
  189.     my_wait();
  190.     vga_clear();
  191.     vga_ext_set(VGA_EXT_RESET,old_flags);
  192.     }
  193. else    {
  194.     
  195.     for(i=0; i<256; i++)
  196.         vga_setpalette(i,RED(i)>>2,GREEN(i)>>2,BLUE(i)>>2);
  197.  
  198.     puts("  No support for CLUT width 8 bit");
  199.     drawwidth(mode,modeinfo,0,ymax,6);
  200.     my_wait();
  201.     }
  202. }
  203.  
  204. void testfill(vga_modeinfo *modeinfo)
  205. {
  206. clock_t clk;
  207. unsigned long pels=0;
  208. int xmax,ymax,lw,i,start,lim,x,y,w,h,mask;
  209.  
  210. lw=modeinfo->linewidth;
  211. setcol(modeinfo);
  212. vga_clear();
  213.  
  214. ymax=vga_getydim();
  215. xmax=vga_getxdim();
  216.  
  217. srand(time(0));
  218. clk=clock();
  219. mask=modeinfo->colors-1;
  220. lim=((xmax<ymax)?xmax:ymax)>>1;
  221.  
  222. for(i=0,start=0;i<lim;i++,start+=lw+modeinfo->bytesperpixel)
  223.     {
  224.     vga_fillblt(start,xmax-(i<<1),ymax-(i<<1),lw,mask&i);
  225.     pels+=(xmax-(i<<1))*(ymax-(i<<1));
  226.     }
  227. for(i=0;i<10000;i++)
  228.     {
  229.     x=rand()%xmax;
  230.     y=rand()%ymax;
  231.     w=rand()%(xmax-x);
  232.     h=rand()%(ymax-y);
  233.     switch(modeinfo->bytesperpixel)
  234.         {
  235.         case 2:
  236.             x<<=1;
  237.             break;
  238.         case 3:
  239.             x+= (x<<1);
  240.             break;
  241.         case 4:
  242.             x<<=2;
  243.             break;
  244.         }
  245.  
  246.     vga_fillblt(x+y*lw,w,h,lw,mask&rand());
  247.     pels+=w*h;
  248.     }
  249. clk=clock()-clk;
  250. printf("  Has FillBlt: %11lu Pixels in %.2f seconds -> %.2f Megapels\n",
  251.         pels,((double)clk)/CLOCKS_PER_SEC,(pels/1.0e6)/(((double)clk)/CLOCKS_PER_SEC));
  252. my_wait();
  253. }
  254.  
  255. void getlogo(void *blitimage,vga_modeinfo *modeinfo)
  256. {
  257. int i;
  258. FILE *fd;
  259.  
  260. fd=fopen(LOGO_NAME,"r");
  261. if(!fd)    {
  262.     read_err:
  263.     perror("Problems reading linuxlogo.bmp");
  264.     exit(2);
  265.     }
  266. if(1!=fread(blitimage,LOGO_WIDTH*LOGO_HEIGHT,1,fd))
  267.     goto read_err;
  268. fclose(fd);
  269. switch(modeinfo->bytesperpixel)
  270.     {
  271.     /* Nothing todo for 256 colors! */
  272.     case 2:
  273.         {
  274.         unsigned char *bmp=(void *)blitimage;
  275.         unsigned short *bmpsh=(void *)blitimage;
  276.         bmp+=LOGO_WIDTH*LOGO_HEIGHT;
  277.         bmpsh+=LOGO_WIDTH*LOGO_HEIGHT;
  278.         i=LOGO_WIDTH*LOGO_HEIGHT;
  279.     
  280.         if(modeinfo->colors==32768)
  281.             {
  282.             while(i--)
  283.                 {
  284.                 bmp--;
  285.                 *--bmpsh=((((unsigned short)*bmp)&7)<<12) |
  286.                      ((((unsigned short)*bmp)&0x38)<<4) |
  287.                      ((((unsigned short)*bmp)&0xc0)>>3);
  288.                 }
  289.             }
  290.         else    {
  291.             while(i--)
  292.                 {
  293.                 bmp--;
  294.                 *--bmpsh=((((unsigned short)*bmp)&7)<<13) |
  295.                      ((((unsigned short)*bmp)&0x38)<<5) |
  296.                      ((((unsigned short)*bmp)&0xc0)>>3);
  297.                 }
  298.             }
  299.         }
  300.         break;
  301.     case 3:
  302.         {
  303.         unsigned char *bmp=(void *)blitimage;
  304.         unsigned char *bmp3=(void *)blitimage;
  305.         bmp+=LOGO_WIDTH*LOGO_HEIGHT;
  306.         bmp3+=3*LOGO_WIDTH*LOGO_HEIGHT;
  307.         i=LOGO_WIDTH*LOGO_HEIGHT;
  308.     
  309.         while(i--)
  310.             {
  311.             bmp--;
  312.             *--bmp3=((((unsigned int)*bmp)&7)<<5);
  313.             *--bmp3=((((unsigned int)*bmp)&0x38)<<2);
  314.             *--bmp3=((((unsigned int)*bmp)&0xc0));
  315.             }
  316.         }
  317.         break;
  318.     case 4:
  319.         {
  320.         unsigned char *bmp=(void *)blitimage;
  321.         unsigned int *bmpi=(void *)blitimage;
  322.         bmp+=LOGO_WIDTH*LOGO_HEIGHT;
  323.         bmpi+=LOGO_WIDTH*LOGO_HEIGHT;
  324.         i=LOGO_WIDTH*LOGO_HEIGHT;
  325.     
  326.         if(modeinfo->flags&RGB_MISORDERED)
  327.             {
  328.             while(i--)
  329.                 {
  330.                 bmp--;
  331.                 *--bmpi=((((unsigned int)*bmp)&7) << 29)    |
  332.                         ((((unsigned int)*bmp)&0x38) << 18) |
  333.                     ((((unsigned int)*bmp)&0xc0) << 8);
  334.                 }
  335.             }
  336.         else    {
  337.             while(i--)
  338.                 {
  339.                 bmp--;
  340.                 *--bmpi=((((unsigned int)*bmp)&7) << 21)    |
  341.                         ((((unsigned int)*bmp)&0x38) << 10) |
  342.                     ((((unsigned int)*bmp)&0xc0)     );
  343.                 }
  344.             }
  345.         }
  346.         break;
  347.     }
  348. }
  349.  
  350. void testbit(vga_modeinfo *modeinfo)
  351. {
  352. clock_t clk;
  353. unsigned long pels=0,*blitimage;
  354. int xmax,ymax,lw,i,x,y,dx,dy,nx,ny;
  355.  
  356. if((modeinfo->bytesperpixel!=1)&&(modeinfo->bytesperpixel!=2))
  357.     {
  358.     puts("  Has BitBlt, but no test code for this pixelwidth implemented.");
  359.     return;
  360.     }
  361.  
  362. ymax=vga_getydim();
  363. xmax=vga_getxdim();
  364. lw=modeinfo->linewidth;
  365.  
  366. if((xmax<210)||(ymax<90))
  367.     {
  368.     puts("  Has BitBlt, but no test code for this small resolution implemented.");
  369.     return;
  370.     }
  371.  
  372. setcol(modeinfo);
  373. vga_clear();
  374.  
  375. pels=0;
  376. blitimage=alloca(modeinfo->bytesperpixel*LOGO_WIDTH*LOGO_HEIGHT);
  377. getlogo(blitimage,modeinfo);
  378.  
  379. if(modeinfo->bytesperpixel==1)
  380.     {
  381.     unsigned char *ptr=(void *)blitimage;
  382.     for(y=1;y<=LOGO_HEIGHT;y++)
  383.         for(x=1;x<=LOGO_WIDTH;x++)
  384.             {
  385.             vga_setcolor((int)*ptr++);
  386.             vga_drawpixel(x,y);
  387.             }
  388.     }
  389. else    {
  390.     unsigned short *ptr=(void *)blitimage;
  391.     for(y=1;y<=LOGO_HEIGHT;y++)
  392.         for(x=1;x<=LOGO_WIDTH;x++)
  393.             {
  394.             vga_setcolor((int)*ptr++);
  395.             vga_drawpixel(x,y);
  396.             }
  397.     }
  398. #ifdef BITFRAME
  399. vga_setcolor(200);
  400. vga_drawline(0,0,0,LOGO_HEIGHT+1);
  401. vga_drawline(0,0,LOGO_WIDTH+1,0);
  402. vga_drawline(LOGO_WIDTH+1,0,LOGO_WIDTH+1,LOGO_HEIGHT+1);
  403. vga_drawline(0,LOGO_HEIGHT+1,LOGO_WIDTH+1,LOGO_HEIGHT+1);
  404. #endif
  405.  
  406. x=0;
  407. y=0;
  408. dx=1;
  409. dy=1;
  410. clk=clock();
  411.  
  412. for(i=0;i<10000;i++)
  413.     {
  414.     nx=x+dx;
  415.     ny=y+dy;
  416.     if((nx+LOGO_WIDTH+2>xmax)||(nx<0))
  417.         {
  418.         dx= -dx;
  419.         nx=x+dx;
  420.         }
  421.     if((ny+LOGO_HEIGHT+2>ymax)||(ny<0))
  422.         {
  423.         dy= -dy;
  424.         ny=y+dy;
  425.         }
  426.     if(modeinfo->bytesperpixel==2)
  427.         {
  428.         vga_bitblt((x+y*(lw>>1))<<1,
  429.                (nx+ny*(lw>>1))<<1,
  430.                LOGO_WIDTH+2,LOGO_HEIGHT+2,lw);
  431.         }
  432.     else    {
  433.         vga_bitblt(x+y*lw,nx+ny*lw,LOGO_WIDTH+2,LOGO_HEIGHT+2,lw);
  434.         }
  435.  
  436.     pels+=(LOGO_WIDTH+2)*(LOGO_HEIGHT+2);
  437.     x=nx;
  438.     y=ny;
  439.     }
  440.  
  441. clk=clock()-clk;
  442. printf("  Has BitBlt: %12lu Pixels in %.2f seconds -> %.2f Megapels\n",
  443.         pels,((double)clk)/CLOCKS_PER_SEC,(pels/1.0e6)/(((double)clk)/CLOCKS_PER_SEC));
  444. my_wait();
  445. }
  446.  
  447. void testimage(vga_modeinfo *modeinfo)
  448. {
  449. clock_t clk;
  450. unsigned long pels=0,*blitimage;
  451. int xmax,ymax,lw,i,x,y;
  452.  
  453. if((modeinfo->bytesperpixel<1)||(modeinfo->bytesperpixel>4))
  454.     {
  455.     puts("  Has ImageBlt, but no test code for this pixelwidth implemented.");
  456.     return;
  457.     }
  458.  
  459. ymax=vga_getydim();
  460. xmax=vga_getxdim();
  461. lw=modeinfo->linewidth;
  462.  
  463. if((xmax<210)||(ymax<90))
  464.     {
  465.     puts("  Has ImageBlt, but no test code for this small resolution implemented.");
  466.     return;
  467.     }
  468.  
  469. /* Prepare a simple test pattern for testuse: */
  470. switch(modeinfo->bytesperpixel)
  471.     {
  472.     default:
  473.         {
  474.         /* 8bpp: */
  475.         register unsigned char *ptr,*pt_fish=fish_monster;
  476.  
  477.         blitimage=alloca(fish_monster_w*fish_monster_h);
  478.         ptr=(unsigned char *)blitimage;
  479.  
  480.         for(i=0;i<(fish_monster_w*fish_monster_h);i++)
  481.             *ptr++ = fish_monster233[ (*pt_fish++) - '`'];
  482.         }
  483.         break;
  484.     case 2:
  485.         {
  486.         register unsigned char *pt_fish=fish_monster;
  487.         register unsigned short *ptr,*coltab;
  488.  
  489.         blitimage=alloca(sizeof(unsigned short)*fish_monster_w*fish_monster_h);
  490.         ptr=(unsigned short *)blitimage;
  491.  
  492.         if(modeinfo->colors==32768)
  493.             coltab=fish_monster555;
  494.         else    coltab=fish_monster565;
  495.         for(i=0;i<(fish_monster_w*fish_monster_h);i++)
  496.             *ptr++ = coltab[ (*pt_fish++) - '`'];
  497.         }
  498.         break;
  499.     case 3:
  500.         {
  501.         register unsigned char *pt_fish=fish_monster;
  502.         register unsigned char *ptr,*coltab;
  503.  
  504.         blitimage=alloca(3*fish_monster_w*fish_monster_h);
  505.         ptr=(unsigned char *)blitimage;
  506.  
  507.         coltab=(unsigned char *)fish_monster888;
  508.  
  509.         for(i=0;i<(fish_monster_w*fish_monster_h);i++)
  510.             {
  511.             *ptr++ = coltab[ (((*pt_fish  ) - '`') << 2)    ];
  512.             *ptr++ = coltab[ (((*pt_fish  ) - '`') << 2) + 1];
  513.             *ptr++ = coltab[ (((*pt_fish++) - '`') << 2) + 2];
  514.             }
  515.         }
  516.         break;
  517.     case 4:
  518.         {
  519.         register unsigned char *pt_fish=fish_monster;
  520.         register unsigned int *ptr,*coltab;
  521.  
  522.         blitimage=alloca(sizeof(unsigned int)*fish_monster_w*fish_monster_h);
  523.         ptr=(unsigned int *)blitimage;
  524.  
  525.         coltab=fish_monster888;
  526.         if(modeinfo->flags&RGB_MISORDERED)
  527.             {
  528.             for(i=0;i<(fish_monster_w*fish_monster_h);i++)
  529.                 *ptr++ = (coltab[ (*pt_fish++) - '`'] << 8);
  530.             }
  531.         else    {
  532.             for(i=0;i<(fish_monster_w*fish_monster_h);i++)
  533.                 *ptr++ = coltab[ (*pt_fish++) - '`'];
  534.             }
  535.         }
  536.         break;
  537.     }
  538. setcol(modeinfo);
  539. vga_clear();
  540.  
  541. srand(time(0));
  542. for(i=0;i<10000;i++)
  543.     {
  544.     x=rand()%(xmax-fish_monster_w);
  545.     y=rand()%(ymax-fish_monster_h);
  546.     if(modeinfo->bytesperpixel>1)
  547.         x*=modeinfo->bytesperpixel;
  548.  
  549.     vga_imageblt(blitimage,x+y*lw,fish_monster_w,fish_monster_h,lw);
  550.     pels+=fish_monster_w*fish_monster_h;
  551.     }
  552. pels=0;
  553. blitimage=alloca(modeinfo->bytesperpixel*LOGO_WIDTH*LOGO_HEIGHT);
  554. getlogo(blitimage,modeinfo);
  555.  
  556. clk=clock();
  557.  
  558. for(i=0;i<1000;i++)
  559.     {
  560.     x=rand()%(xmax-LOGO_WIDTH);
  561.     y=rand()%(ymax-LOGO_HEIGHT);
  562.     if(modeinfo->bytesperpixel>1)
  563.         x*=modeinfo->bytesperpixel;
  564.  
  565.     vga_imageblt(blitimage,x+y*lw,LOGO_WIDTH,LOGO_HEIGHT,lw);
  566.     pels+=LOGO_WIDTH*LOGO_HEIGHT;
  567.     }
  568.  
  569. clk=clock()-clk;
  570. printf("  Has ImageBlt: %10lu Pixels in %.2f seconds -> %.2f Megapels\n",
  571.         pels,((double)clk)/CLOCKS_PER_SEC,(pels/1.0e6)/(((double)clk)/CLOCKS_PER_SEC));
  572. my_wait();
  573. }
  574.  
  575. void hlinesquare(hlinelst *des, register int n)
  576. {
  577. register int *xmin, *xmax;
  578.  
  579. if(n<1)    n=1;
  580.  
  581. des->n=n;
  582. des->width=n;
  583. des->offset=0;
  584. des->pels=n*n;
  585.  
  586. xmin=(int *)((char *)des+sizeof(hlinelst));
  587. xmax=xmin+n;
  588.  
  589. while(n--)
  590.     {
  591.     *xmin++ = 0;
  592.     *xmax++ = des->width-1;
  593.     }
  594. }
  595.  
  596. void hlinedisk(hlinelst *des, register int n)
  597. {
  598. register int *xmin, *xmax, radsq, rad, x;
  599.  
  600. if(!(n&1)) n--;
  601. if(n<1)    n=1;
  602.  
  603. des->n=n;
  604. des->width=n;
  605. des->offset=0;
  606. des->pels=n*n;
  607. rad=(n>>1);
  608. radsq=rad*rad;
  609.  
  610. xmin=(int *)((char *)des+sizeof(hlinelst));
  611. xmax=xmin+n;
  612.  
  613. while(n--)
  614.     {
  615.     x=sqrt(radsq-isqr(n-rad));
  616.     *xmin++ = rad-x;
  617.     *xmax++ = rad+x;
  618.     }
  619. }
  620.  
  621. void hlinecaro(hlinelst *des, register int n)
  622. {
  623. register int *xmin, *xmax, i, j;
  624.  
  625. if(!(n&1)) n--;
  626. if(n<1)    n=1;
  627.  
  628. des->n=n;
  629. des->width=n;
  630. des->offset=0;
  631. des->pels=(n*n)/2;
  632.  
  633. xmin=(int *)((char *)des+sizeof(hlinelst));
  634. xmax=xmin+n;
  635.  
  636. i=1+(n>>1);
  637. j=0;
  638.  
  639. while(i--)
  640.     {
  641.     *xmin++ = (n>>1)-j;
  642.     *xmax++ = (n>>1)+j;
  643.     j++;
  644.     }
  645. i=(n>>1);
  646. j-=2;
  647. while(i--)
  648.     {
  649.     *xmin++ = (n>>1)-j;
  650.     *xmax++ = (n>>1)+j;
  651.     j--;
  652.     }
  653. }
  654.  
  655. void testhline(vga_modeinfo *modeinfo)
  656. {
  657. #define SHAPES 9
  658. clock_t clk;
  659. unsigned long pels=0;
  660. hlinelst *shape[SHAPES],*curs;
  661. int xmax,ymax,lw,i,x,y,mask;
  662.  
  663. setcol(modeinfo);
  664. vga_clear();
  665.  
  666. ymax=vga_getydim();
  667. xmax=vga_getxdim();
  668. lw=modeinfo->linewidth;
  669. mask=modeinfo->colors-1;
  670.  
  671. srand(time(0));
  672.  
  673. i=0;
  674. shape[i]=alloca(sizhlilst(ymax/2));
  675. hlinesquare(shape[i++],ymax/2);
  676. shape[i]=alloca(sizhlilst(ymax/4));
  677. hlinesquare(shape[i++],ymax/4);
  678. shape[i]=alloca(sizhlilst(ymax/8));
  679. hlinesquare(shape[i++],ymax/8);
  680.  
  681. shape[i]=alloca(sizhlilst(ymax/2));
  682. hlinecaro(shape[i++],ymax/2);
  683. shape[i]=alloca(sizhlilst(ymax/4));
  684. hlinecaro(shape[i++],ymax/4);
  685. shape[i]=alloca(sizhlilst(ymax/8));
  686. hlinecaro(shape[i++],ymax/8);
  687.  
  688. shape[i]=alloca(sizhlilst(ymax/2));
  689. hlinedisk(shape[i++],ymax/2);
  690. shape[i]=alloca(sizhlilst(ymax/4));
  691. hlinedisk(shape[i++],ymax/4);
  692. shape[i]=alloca(sizhlilst(ymax/8));
  693. hlinedisk(shape[i++],ymax/8);
  694.  
  695.  
  696. clk=clock();
  697.  
  698. for(i=0;i<1000;i++)
  699.     {
  700.     curs=shape[rand()%SHAPES];
  701.     x=rand()%(xmax-(curs->width));
  702.     y=rand()%(ymax-(curs->n));
  703.     adj_hlilst(curs,x);
  704.     pels+=curs->pels;
  705.     vga_hlinelistblt(y,curs->n,
  706.             (int *)(((char *)curs)+sizeof(hlinelst)),
  707.             (int *)(((char *)curs)+sizeof(hlinelst)+(curs->n)*sizeof(int)),
  708.             lw,mask&rand());
  709.     }
  710. clk=clock()-clk;
  711. clk++;
  712. printf("  Has HlineLst: %10lu Pixels in %.2f seconds -> %.2f Megapels\n",
  713.         pels,((double)clk)/CLOCKS_PER_SEC,(pels/1.0e6)/(((double)clk)/CLOCKS_PER_SEC));
  714. my_wait();
  715. }
  716.  
  717. void testmode(int mode)
  718. {
  719. vga_modeinfo *modeinfo;
  720.  
  721. printf("Testing mode %2d: %s...",mode,vga_getmodename(mode));
  722. if(!vga_hasmode(mode))
  723.     {
  724.     puts(" not available");
  725.     return;
  726.     }
  727. puts("");
  728.  
  729. vga_setmode(mode);
  730. modeinfo = vga_getmodeinfo(mode);
  731.  
  732. if((modeinfo->colors==256)&& !(modeinfo->flags&IS_MODEX))
  733.     {
  734.     testwidth(mode,modeinfo);
  735.     }
  736. else    puts("  Dacwidth test not applicable.");
  737. if(modeinfo->haveblit&HAVE_BITBLIT)
  738.     testbit(modeinfo);
  739. if(modeinfo->haveblit&HAVE_FILLBLIT)
  740.     testfill(modeinfo);
  741. if(modeinfo->haveblit&HAVE_IMAGEBLIT)
  742.     testimage(modeinfo);
  743. if(modeinfo->haveblit&HAVE_HLINELISTBLIT)
  744.     testhline(modeinfo);
  745. vga_setmode(TEXT);
  746. }
  747.  
  748. void usage(void)
  749. {
  750. puts("Usage: testaccel [-nowait] {all|[mode [mode [mode...]]]}\n"
  751. "\ttests accelerated features and extended options in\n"
  752. "\tall or the given modes.\n"
  753. "\tAll standard svgalib ways of writing modenames are understood.\n"
  754. "\tIf no parameters are given the defaultmode or G640x480x256 is\n"
  755. "\tused.\n"
  756. "\tIf -nowait is given, don't wait for a keypress after each test.");
  757. exit(2);
  758. }
  759.  
  760. int main(int argc, char *argv[])
  761. {
  762. int mode;
  763.  
  764. vga_init();
  765.  
  766. puts(
  767. "Note: Timings include main cpu calculations (random numbers and such\n"
  768. "      things). Thus they are esp. for lower resolutions much too slow!");
  769.  
  770. if((argc>1)&& !strcmp(argv[1],"-nowait"))
  771.     {
  772.     argc--;
  773.     argv++;
  774.     waitmode=0;
  775.     }
  776. if((argc==2) && !strcmp(argv[1],"all"))
  777.     {
  778.     int flag=0;
  779.     for(mode=1;mode<=GLASTMODE;mode++)
  780.         if(vga_hasmode(mode))
  781.             {
  782.             flag=1;
  783.             testmode(mode);
  784.             }
  785.     if(!flag)puts("testaccel: Not any graphicsmode available!");
  786.     }
  787. else if(argc>1)
  788.     {
  789.     for(mode=1;mode<argc;mode++)
  790.         if(vga_getmodenumber(argv[mode])<0)
  791.             {
  792.             printf("testaccel: Parameter %s is not a valid graphicsmode.\n",argv[mode]);
  793.             usage();
  794.             }
  795.     for(mode=1;mode<argc;mode++)
  796.         testmode(vga_getmodenumber(argv[mode]));
  797.     }
  798. else    {
  799.     mode=vga_getdefaultmode();
  800.     if(mode<0)
  801.         mode=G640x480x256;
  802.     if(vga_hasmode(mode))
  803.         testmode(mode);
  804.     else    puts("testaccel: could not set defaultmode or G640x480x256!");
  805.     }
  806. return 0;
  807. }
  808.