home *** CD-ROM | disk | FTP | other *** search
/ Computer Panoráma / computer_panorama_1997-12-hibas.iso / SHARE / GRAPH / PTC051.ZIP / EXAMPLES / PROFILE.CPP < prev    next >
C/C++ Source or Header  |  1997-09-23  |  10KB  |  301 lines
  1. /////////////////////////////
  2. // ptc conversion profiler //
  3. /////////////////////////////
  4. #include "ptc.h"
  5. #include <conio.h>
  6. #include <iostream.h>
  7. #include <stdlib.h>
  8.  
  9.  
  10.  
  11.  
  12.  
  13.  
  14.  
  15.  
  16. float Profile32(int x,int y,int format)
  17. {
  18.     // initialize ptc
  19.     PTC ptc(x,y,format);
  20.     if (!ptc.ok()) return (float)0;
  21.  
  22.     // create fullscreen surface
  23.     Surface surface(ptc,x,y,ARGB8888);
  24.     if (!surface.ok()) return (float)0;
  25.  
  26.     // fill surface with random crap ;)
  27.     uint *p=(uint*)surface.Lock();
  28.     uint *pstop=p+x*y;
  29.     while (p<pstop) 
  30.     {
  31.         *p=RGB32(random(256),random(256),random(256));
  32.         p++;
  33.     }
  34.     surface.Unlock();
  35.  
  36.     // profile 1000 updates
  37.     int reps=1000;
  38.     clock_t time_start=clock();
  39.     for (int i=0; i<reps; i++) 
  40.     {
  41.         if (!surface.Update()) return (float)0;
  42.     }
  43.     clock_t time_end=clock();
  44.  
  45.     // calculate time taken
  46.     float dt=(time_end-time_start);
  47.     float t=dt/(float)CLOCKS_PER_SEC/(float)reps;
  48.     return t;
  49. }
  50.  
  51.  
  52. float Profile16(int x,int y,int format)
  53. {
  54.     // initialize ptc
  55.     PTC ptc(x,y,format);
  56.     if (!ptc.ok()) return (float)0;
  57.  
  58.     // create fullscreen surface
  59.     Surface surface(ptc,x,y,RGB565);
  60.     if (!surface.ok()) return (float)0;
  61.  
  62.     // fill surface with random crap ;)
  63.     ushort *p=(ushort*)surface.Lock();
  64.     ushort *pstop=p+x*y;
  65.     while (p<pstop) 
  66.     {
  67.         *p=RGB16(random(256),random(256),random(256));
  68.         p++;
  69.     }
  70.     surface.Unlock();
  71.  
  72.     // profile 1000 updates
  73.     int reps=1000;
  74.     clock_t time_start=clock();
  75.     for (int i=0; i<reps; i++) 
  76.     {
  77.         if (!surface.Update()) return (float)0;
  78.     }
  79.     clock_t time_end=clock();
  80.  
  81.     // calculate time taken
  82.     float dt=(time_end-time_start);
  83.     float t=dt/(float)CLOCKS_PER_SEC/(float)reps;
  84.     return t;
  85. }
  86.  
  87.  
  88. float Profile8(int x,int y,int format)
  89. {
  90.     // interator
  91.     int i=0;
  92.  
  93.     // initialize ptc
  94.     PTC ptc(x,y,format);
  95.     if (!ptc.ok()) return (float)0;
  96.  
  97.     // create fullscreen surface
  98.     Surface surface(ptc,x,y,INDEX8);
  99.     if (!surface.ok()) return (float)0;
  100.     
  101.     // create palette
  102.     Palette palette;
  103.     uint *data=(uint*)palette.Lock();
  104.     for (i=0; i<256; i++)
  105.     {
  106.         *data=RGB32(i,i,i);
  107.         data++;
  108.     }
  109.     palette.Unlock();
  110.     
  111.     // set surface palette
  112.     surface.SetPalette(palette);
  113.  
  114.     // set display palette (if required)
  115.     FORMAT output=ptc.GetFormat();
  116.     if (output.type==INDEXED && output.model!=GREYSCALE) ptc.SetPalette(palette);
  117.  
  118.     // fill surface with random pixels
  119.     char *p=(char*)surface.Lock();
  120.     char *pstop=p+x*y;
  121.     while (p<pstop) 
  122.     {
  123.         *p=random(256);
  124.         p++;
  125.     }
  126.     surface.Unlock();
  127.  
  128.     // profile 1000 updates
  129.     int reps=1000;
  130.     clock_t time_start=clock();
  131.     for (i=0; i<reps; i++) 
  132.     {
  133.         if (!surface.Update()) return (float)0;
  134.     }
  135.     clock_t time_end=clock();
  136.  
  137.     // calculate time taken
  138.     float dt=(time_end-time_start);
  139.     float t=dt/(float)CLOCKS_PER_SEC/(float)reps;
  140.     return t;
  141. }
  142.  
  143.  
  144. void PrintResult(char format[],float dt)
  145. {
  146.     cout << format << "= ";
  147.     if (dt>0.000001) cout << 1/dt << " fps\n";
  148.     else cout << "n/a\n";
  149. }
  150.  
  151.  
  152.  
  153.  
  154.  
  155.  
  156.  
  157.  
  158. int main(int argc,char *argv[])
  159. {
  160.     // parse command line for profile resolution
  161.     int xres=320;
  162.     int yres=200;
  163.     if (argc>=3)
  164.     {
  165.         xres=atoi(argv[1]);
  166.         yres=atoi(argv[2]);
  167.     }
  168.  
  169.     // profile all 32bit -> X converters
  170.     float Time32_ARGB8888   = Profile32(xres,yres,ARGB8888);
  171.     float Time32_ABGR8888   = Profile32(xres,yres,ABGR8888);
  172.     float Time32_RGBA8888   = Profile32(xres,yres,RGBA8888);
  173.     float Time32_BGRA8888   = Profile32(xres,yres,BGRA8888);
  174.     float Time32_RGB888     = Profile32(xres,yres,RGB888);
  175.     float Time32_BGR888     = Profile32(xres,yres,BGR888);
  176.     float Time32_RGB565     = Profile32(xres,yres,RGB565);
  177.     float Time32_BGR565     = Profile32(xres,yres,BGR565);
  178.     float Time32_ARGB1555   = Profile32(xres,yres,ARGB1555);
  179.     float Time32_ABGR1555   = Profile32(xres,yres,ABGR1555);
  180.     float Time32_FAKEMODE1A = Profile32(xres,yres,FAKEMODE1A);
  181.     float Time32_FAKEMODE1B = Profile32(xres,yres,FAKEMODE1B);
  182.     float Time32_FAKEMODE1C = Profile32(xres,yres,FAKEMODE1C);
  183.     float Time32_FAKEMODE2A = Profile32(xres,yres,FAKEMODE2A);
  184.     float Time32_FAKEMODE2B = Profile32(xres,yres,FAKEMODE2B);
  185.     float Time32_FAKEMODE2C = Profile32(xres,yres,FAKEMODE2C);
  186.     float Time32_FAKEMODE3A = Profile32(xres,yres,FAKEMODE3A);
  187.     float Time32_FAKEMODE3B = Profile32(xres,yres,FAKEMODE3B);
  188.     float Time32_FAKEMODE3C = Profile32(xres,yres,FAKEMODE3C);
  189.     float Time32_GREY8      = Profile32(xres,yres,GREY8);
  190.     float Time32_RGB332     = Profile32(xres,yres,RGB332);
  191.  
  192.     // profile all 16bit -> X converters
  193.     float Time16_ARGB8888   = Profile16(xres,yres,ARGB8888);
  194.     float Time16_ABGR8888   = Profile16(xres,yres,ABGR8888);
  195.     float Time16_RGBA8888   = Profile16(xres,yres,RGBA8888);
  196.     float Time16_BGRA8888   = Profile16(xres,yres,BGRA8888);
  197.     float Time16_RGB888     = Profile16(xres,yres,RGB888);
  198.     float Time16_BGR888     = Profile16(xres,yres,BGR888);
  199.     float Time16_RGB565     = Profile16(xres,yres,RGB565);
  200.     float Time16_BGR565     = Profile16(xres,yres,BGR565);
  201.     float Time16_ARGB1555   = Profile16(xres,yres,ARGB1555);
  202.     float Time16_ABGR1555   = Profile16(xres,yres,ABGR1555);
  203.     float Time16_FAKEMODE1A = Profile16(xres,yres,FAKEMODE1A);
  204.     float Time16_FAKEMODE1B = Profile16(xres,yres,FAKEMODE1B);
  205.     float Time16_FAKEMODE1C = Profile16(xres,yres,FAKEMODE1C);
  206.     float Time16_FAKEMODE2A = Profile16(xres,yres,FAKEMODE2A);
  207.     float Time16_FAKEMODE2B = Profile16(xres,yres,FAKEMODE2B);
  208.     float Time16_FAKEMODE2C = Profile16(xres,yres,FAKEMODE2C);
  209.     float Time16_FAKEMODE3A = Profile16(xres,yres,FAKEMODE3A);
  210.     float Time16_FAKEMODE3B = Profile16(xres,yres,FAKEMODE3B);
  211.     float Time16_FAKEMODE3C = Profile16(xres,yres,FAKEMODE3C);
  212.     float Time16_GREY8      = Profile16(xres,yres,GREY8);
  213.     float Time16_RGB332     = Profile16(xres,yres,RGB332);
  214.  
  215.     // profile all 8bit -> X converters
  216.     float Time8_INDEX8     = Profile8(xres,yres,INDEX8);
  217.     float Time8_4BYTE      = Profile8(xres,yres,32);
  218.     float Time8_3BYTE      = Profile8(xres,yres,24);
  219.     float Time8_2BYTE      = Profile8(xres,yres,16);
  220.     float Time8_FAKEMODE1A = Profile8(xres,yres,FAKEMODE1A);
  221.     float Time8_FAKEMODE1B = Profile8(xres,yres,FAKEMODE1B);
  222.     float Time8_FAKEMODE1C = Profile8(xres,yres,FAKEMODE1C);
  223.     float Time8_FAKEMODE2A = Profile8(xres,yres,FAKEMODE2A);
  224.     float Time8_FAKEMODE2B = Profile8(xres,yres,FAKEMODE2B);
  225.     float Time8_FAKEMODE2C = Profile8(xres,yres,FAKEMODE2C);
  226.     float Time8_FAKEMODE3A = Profile8(xres,yres,FAKEMODE3A);
  227.     float Time8_FAKEMODE3B = Profile8(xres,yres,FAKEMODE3B);
  228.     float Time8_FAKEMODE3C = Profile8(xres,yres,FAKEMODE3C);
  229.     float Time8_GREY8      = Profile8(xres,yres,GREY8);
  230.     float Time8_RGB332     = Profile8(xres,yres,RGB332);
  231.  
  232.     // output results
  233.     cout << "PTC PROFILE RESULTS (" << xres << "," << yres << ")\n\n\n";
  234.     cout << "32bit -> X\n";
  235.     cout << "----------\n";
  236.     PrintResult("ARGB8888   ",Time32_ARGB8888);
  237.     PrintResult("ABGR8888   ",Time32_ABGR8888);
  238.     PrintResult("RGBA8888   ",Time32_RGBA8888);
  239.     PrintResult("BGRA8888   ",Time32_BGRA8888);
  240.     PrintResult("RGB888     ",Time32_RGB888);
  241.     PrintResult("BGR888     ",Time32_BGR888);
  242.     PrintResult("RGB565     ",Time32_RGB565);
  243.     PrintResult("BGR565     ",Time32_BGR565);
  244.     PrintResult("ARGB1555   ",Time32_ARGB1555);
  245.     PrintResult("ABGR1555   ",Time32_ABGR1555);
  246.     PrintResult("FAKEMODE1A ",Time32_FAKEMODE1A);
  247.     PrintResult("FAKEMODE1B ",Time32_FAKEMODE1B);
  248.     PrintResult("FAKEMODE1C ",Time32_FAKEMODE1C);
  249.     PrintResult("FAKEMODE2A ",Time32_FAKEMODE2A);
  250.     PrintResult("FAKEMODE2B ",Time32_FAKEMODE2B);
  251.     PrintResult("FAKEMODE2C ",Time32_FAKEMODE2C);
  252.     PrintResult("FAKEMODE3A ",Time32_FAKEMODE3A);
  253.     PrintResult("FAKEMODE3B ",Time32_FAKEMODE3B);
  254.     PrintRe