home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 625.lha / STScan_v2.0 / imginout.c < prev    next >
C/C++ Source or Header  |  1992-02-22  |  23KB  |  696 lines
  1. /* imginout.c input/output routines for stscan.c */
  2. #include <exec/exec.h>
  3. #include <exec/types.h>
  4. #include <intuition/intuition.h>
  5. #include <intuition/intuitionbase.h>
  6. #include <libraries/dos.h>
  7. #include <libraries/dosextens.h>
  8. #include <graphics/rastport.h>
  9. #include <libraries/reqbase.h>
  10. #include <req_pragmas.h>
  11. #include <stdio.h>
  12. #include <string.h>
  13. #include <functions.h>
  14. #include "stscan.h"
  15.  
  16. #define ST400LUN 96
  17. #define DEV_NAME (char*)"scsi.device" /* <- change for other SCSI controller */
  18. #define FORM 0x464f524d
  19. #define ILBM 0x494c424d
  20. #define BMHD 0x424d4844
  21. #define BODY 0x424f4459
  22. #define DIR_READ  1
  23. #define DIR_WRITE 0
  24.  
  25. /* Scanner specific sizes and commands */
  26.  
  27. static UWORD cornerxval[]={  22,  33,  44, 266, 399, 535};
  28. static UWORD corneryval[]={   6,   6,   6,   6,   6,   6};
  29. static UWORD widthval[]=  {1664,2496,3312,1168,1760,2336};
  30. static UWORD heightval[]= {2336,3504,4672,1656,2484,3312};
  31.  
  32. static UBYTE cmd_scan[]={0x1b,ST400LUN,0,0,0,0};
  33. static UBYTE cmd_read[]={0x28,ST400LUN,0,0,0,0,0,0,0,0};
  34. static UBYTE cmd_dwin[]={0x24,ST400LUN,0,0,0,0,0,0,40,0};
  35. static UBYTE cmd_mdon[]={0x15,ST400LUN,0,0,0,128};
  36. static UBYTE cmd_mdoff[]={0x15,ST400LUN,0,0,0,0};
  37. static UBYTE cmd_inqu[]={0x12,ST400LUN,0,0,96,0};
  38.  
  39. /* IFF-ILBM Constants */
  40.  
  41. static UBYTE iff_cmap_bw[]=
  42. {'C','M','A','P',0,0,0,6,0,0,0,255,255,255};
  43.  
  44. static UBYTE iff_cmap_gray[]=
  45. {'C','M','A','P',0,0,0,48,0,0,0,16,16,16,32,32,32,48,48,48,64,64,64,80,80,80,
  46.  96,96,96,112,112,112,128,128,128,144,144,144,160,160,160,176,176,176,
  47.  192,192,192,208,208,208,224,224,224,240,240,240};
  48.  
  49. static ULONG iff_head[]={FORM,0,ILBM,BMHD,20,0,0,0,0x00000101,0x02800200};
  50.  
  51. static ULONG iff_body[]={BODY,0};
  52.  
  53. static ULONG chunk_hd[2];
  54.  
  55. typedef struct iffhead
  56. { ULONG iff_magic;
  57.   ULONG filelen;
  58.   ULONG ilbm_magic;
  59.   ULONG bmhd_magic;
  60.   ULONG bmhd_len;
  61.   UWORD w,h,x,y;
  62.   UBYTE d, mask, cmp, pad;
  63.   UWORD transparent,aspect,pw,ph;
  64. };
  65.  
  66. static struct iffhead iffheader;
  67.  
  68. UBYTE sk;
  69. UWORD vx,vy;
  70.  
  71. /* Call of the File Requester */
  72.  
  73. struct IntuiText text_na;
  74. struct IntuiText text_aha;
  75.  
  76. static char def_name[REQ_FCHARS]="";
  77. static char def_dir[REQ_DSIZE]="";
  78. static char str_filenam[REQ_FCHARS+REQ_DSIZE]="";
  79.  
  80. USHORT filerequest(char *titel,char *str_filenam)
  81. { struct Process *OurTask;
  82.   struct Window    *old_pr_WindowPtr;
  83.   struct FileReq freq;
  84.  
  85.   OurTask = (struct Process *)FindTask((char *)0L);
  86.   old_pr_WindowPtr = OurTask->pr_WindowPtr;
  87.   OurTask->pr_WindowPtr = win;
  88.   
  89.   memset(&freq,0,sizeof(freq));
  90.   str_filenam[0]=0;
  91.   freq.Title=titel;
  92.   freq.PathName=str_filenam;
  93.   freq.Dir=def_dir;
  94.   freq.File=def_name;
  95.   if (FileRequester(&freq))
  96.   { OurTask->pr_WindowPtr = old_pr_WindowPtr;
  97.     return(1);
  98.   }
  99.   else
  100.   {
  101.     OurTask->pr_WindowPtr = old_pr_WindowPtr;
  102.     return(0);
  103.   }
  104. } 
  105.  
  106. void MessReq(UBYTE *string)
  107. { struct Process *OurTask;
  108.   struct Window    *old_pr_WindowPtr;
  109.   struct TRStructure tr;
  110.  
  111.   OurTask = (struct Process *)FindTask((char *)0L);
  112.   old_pr_WindowPtr = OurTask->pr_WindowPtr;
  113.   OurTask->pr_WindowPtr = win;
  114.   memset(&tr,0,sizeof(tr));
  115.   tr.Text=string;
  116.   tr.Title="Program Message";
  117.   TextRequest(&tr);
  118.   OurTask->pr_WindowPtr = old_pr_WindowPtr;
  119. }
  120.  
  121. void NotAvailable()
  122. {  MessReq((UBYTE *)"Funktion not available!");
  123. }
  124.  
  125. UBYTE DoScsi(UBYTE *cmd, UWORD cmdlen, UWORD *data, ULONG datalen, UBYTE flags)
  126. { struct SCSICmd scmd;
  127.   scmd.scsi_Command=cmd;
  128.   scmd.scsi_CmdLength=cmdlen;
  129.   scmd.scsi_Data=data;
  130.   scmd.scsi_Length=datalen;
  131.   scmd.scsi_Flags=flags;
  132.   diskreq->io_Length = sizeof(struct SCSICmd);
  133.   diskreq->io_Data = &scmd;
  134.   diskreq->io_Command = 28;
  135.   DoIO(diskreq);
  136.   return(scmd.scsi_Status);
  137. }
  138.  
  139.  
  140. void inquiry()
  141. { UBYTE string[96],inq_txt[45];
  142.  
  143.   DoScsi(&cmd_inqu,6,(UWORD *)&string,96,DIR_READ);
  144.   strncpy(&inq_txt[0],&string[8],39);
  145.   MessReq(&inq_txt[0]);
  146. }
  147.  
  148. void scan()
  149. { ULONG memsize,memadd,blsize;
  150.   short tabindex,blocks,rest,i,glin,rlin;
  151.   UBYTE *rdptr;
  152.  
  153.   if (memptr) free(memptr);
  154.   memneed=0;
  155.   tabindex=((winpar.resx/100)-2)+(winpar.size-4)*3;
  156.   winpar.cornerx=cornerxval[tabindex];
  157.   winpar.cornery=corneryval[tabindex];
  158.   winpar.width=widthval[tabindex];
  159.   winpar.height=heightval[tabindex];
  160.   memsize=(winpar.halftone)?((ULONG)winpar.width*(ULONG)winpar.height)>>1:
  161.                             ((ULONG)winpar.width*(ULONG)winpar.height)>>3;
  162.   memadd=(memgray)?((ULONG)memwidth*ADDLIN)>>1:
  163.                    ((ULONG)memwidth*ADDLIN)>>3;
  164.   if ((memptr=(UBYTE*)malloc(memsize+memadd))==NULL)
  165.     MessReq((UBYTE*)"Out of Memmory!");
  166.   else 
  167.   { memneed=memsize;
  168.     memwidth=winpar.width;
  169.     memheight=winpar.height;
  170.     memgray=winpar.halftone;
  171.     rdptr=memptr;
  172.     if (!(winpar.halftone))
  173.     { DoScsi(&cmd_mdon,6,NULL,0,0);
  174.       Delay(100);
  175.       DoScsi(&cmd_dwin,10,&winpar,40,DIR_WRITE);
  176.       DoScsi(&cmd_scan,6,NULL,0,0);
  177.       blocks=memsize/0x8000;
  178.       rest=memsize%0x8000;
  179.       cmd_read[7]=128; cmd_read[8]=0;
  180.       for (i=0;i<blocks;i++) 
  181.       { DoScsi(&cmd_read,10,rdptr,0x8000,DIR_READ);
  182.         rdptr+=0x8000;
  183.       }
  184.       cmd_read[7]=(rest>>8)&0xff; cmd_read[8]=rest&0xff;
  185.       DoScsi(&cmd_read,10,rdptr,rest,DIR_READ);
  186.       rdptr+=rest;
  187.     }
  188.     else
  189.     { glin=winpar.height;
  190.       rlin=0x200000L/(ULONG)winpar.width; 
  191.       do 
  192.       { if (rlin>glin) rlin=glin;
  193.         winpar.height=rlin;
  194.         glin-=rlin;
  195.         DoScsi(&cmd_mdon,6,NULL,0,0);
  196.         Delay(100);
  197.         DoScsi(&cmd_dwin,10,&winpar,40,DIR_WRITE);
  198.         DoScsi(&cmd_scan,6,NULL,0,0);
  199.     winpar.cornery+=rlin;
  200.         blsize=((ULONG)winpar.height*(ULONG)winpar.width)>>1;
  201.         blocks=blsize/0x4000;
  202.         rest=blsize%0x4000;
  203.         cmd_read[7]=128; cmd_read[8]=0;
  204.         for (i=0;i<blocks;i++) 
  205.         { DoScsi(&cmd_read,10,rdptr,0x8000,DIR_READ);
  206.           p64to16(rdptr,0x4000);
  207.           rdptr+=0x4000;
  208.         }
  209.         cmd_read[7]=(rest>>7)&0xff; cmd_read[8]=(rest<<1)&0xff;
  210.         DoScsi(&cmd_read,10,rdptr,rest<<1,DIR_READ);
  211.         p64to16(rdptr,rest);
  212.     rdptr+=rest;
  213.       } while (glin);
  214.     }
  215.     DoScsi(&cmd_mdoff,6,NULL,0,0); 
  216.   }
  217. }  
  218.     
  219.  
  220. static ULONG cmpline(UBYTE *zeile, UWORD len, UWORD pnum, FILE *qdatei)
  221. { ULONG count;
  222.   UWORD plen,p;
  223.   UBYTE m;
  224.   WORD i,j;
  225.   static UBYTE cplane[6000];
  226.  
  227.   count=0;
  228.   plen=len/pnum;
  229.   for (p=0;p<pnum;p++)
  230.   { i=0;
  231.     while(i<plen)
  232.     { m=(*(zeile+i));
  233.       for (j=i+1;((m==(*(zeile+j)))&&(j<plen)&&(j<(i+125)));j++);
  234.       if (j!=(i+1))
  235.       { cplane[count++]=(UBYTE)((257-j+i)&0xff);
  236.         cplane[count++]=m;
  237.         i=j;
  238.       }
  239.       else
  240.       { for (;(m!=(*(zeile+j))&&(j<=plen)&&(j<(i+125)));m=(*(zeile+(j++))));
  241.         if (j<plen) j-=2;
  242.         j=((plen-1)<j)?(plen-1):j;
  243.         cplane[count++]=(UBYTE)(j-i);
  244.         for(;i<=j;cplane[count++]=(*(zeile+(i++))));
  245.       }
  246.     }
  247.     zeile+=plen;
  248.   }
  249.   fwrite(&cplane[0],count,1,qdatei);
  250.   return(count);
  251. }
  252.  
  253.  
  254. void load()
  255. { FILE *sdatei;
  256.   ULONG memsize,memadd;
  257.   UWORD i,j,t;
  258.   UBYTE *loadptr;
  259.   UBYTE planes[4000];
  260.   UBYTE b,cflag,rflag,cnt,cval;
  261.   UWORD bflag=1;
  262.  
  263.   if (filerequest("Load IFF File",str_filenam))
  264.   { sdatei=fopen(str_filenam,"rb");
  265.     fread(&iffheader,sizeof(iffheader),1,sdatei);
  266.     if ((iffheader.iff_magic!=FORM)||(iffheader.ilbm_magic!=ILBM)||
  267.         (iffheader.bmhd_magic!=BMHD)||(iffheader.bmhd_len!=20))
  268.     { MessReq("No IFF-ILBM File!");
  269.       fclose(sdatei);
  270.     }
  271.     else
  272.     { if (memptr) free(memptr);
  273.       memneed=0;
  274.       memgray=((iffheader.d)!=1);
  275.       memwidth=iffheader.w;
  276.       memheight=iffheader.h;
  277.       memsize=(memgray)?((ULONG)memwidth*(ULONG)memheight)>>1:
  278.                         ((ULONG)memwidth*(ULONG)memheight)>>3;
  279.       memadd=(memgray)?((ULONG)memwidth*ADDLIN)>>1:
  280.                        ((ULONG)memwidth*ADDLIN)>>3;
  281.       if ((memptr=(UBYTE*)malloc(memsize+memadd))==NULL)
  282.       { MessReq((UBYTE*)"Out of Memmory!");
  283.         fclose(sdatei);
  284.       }
  285.       else
  286.       { memneed=memsize;
  287.         while (bflag) /* hier CMAP und Body suchen */
  288.         { fread(&chunk_hd[0],8,1,sdatei);
  289.           if (chunk_hd[0]==BODY) bflag=0;
  290.           else fseek(sdatei,chunk_hd[1],SEEK_CUR);
  291.         }
  292.         if (memgray)
  293.         { loadptr=memptr;
  294.           memset(&planes[0],0,4000);
  295.           if (iffheader.cmp) for (i=0;i<memheight;i++)
  296.           { t=0;
  297.             while (t<iffheader.d*(memwidth<<3))
  298.             { fread(&cnt,1,1,sdatei);
  299.               if (cnt>128)
  300.               { fread(&cval,1,1,sdatei);
  301.                 for (i=0;i<(257-cnt);i++) planes[t++]=cval;
  302.               }
  303.               if (cnt<128)
  304.               { fread(&planes[t],++cnt,1,sdatei);
  305.                 t+=cnt;
  306.               }
  307.             }
  308.             fplanegen(loadptr,&planes[0],&planes[memwidth>>3],
  309.                       &planes[2*(memwidth>>3)],&planes[3*(memwidth>>3)],(memwidth>>3));
  310.             loadptr+=(memwidth>>1);
  311.           }
  312.           else for (i=0;i<memheight;i++)
  313.           { fread(&planes[0],iffheader.d*(memwidth>>3),1,sdatei);
  314.             fplanegen(loadptr,&planes[0],&planes[memwidth>>3],
  315.                       &planes[2*(memwidth>>3)],&planes[3*(memwidth>>3)],(memwidth>>3));
  316.             loadptr+=(memwidth>>1);
  317.           }
  318.         }
  319.         else
  320.         { if (iffheader.cmp)
  321.           { loadptr=memptr;
  322.             while ((fread(&cnt,1,1,sdatei)))
  323.             { if (cnt>128)
  324.               { fread(&cval,1,1,sdatei);
  325.                 for (i=0;i<(257-cnt);i++) *(loadptr++)=cval;
  326.               }
  327.               if (cnt<128)
  328.               { fread(loadptr,++cnt,1,sdatei);
  329.                 loadptr+=cnt;
  330.               }
  331.             }
  332.           }
  333.           else fread(memptr,(iffheader.w>>3)*iffheader.h,1,sdatei);
  334.         }
  335.         fclose(sdatei);
  336.       }
  337.     }
  338.   }
  339. }
  340.  
  341. void save(UWORD wx1,UWORD wy1,UWORD wx2,UWORD wy2,UBYTE cmp,UBYTE mf)
  342. { FILE *qdatei;
  343.   ULONG totlen,bmlen;
  344.   UWORD width,height,i,t;
  345.   ULONG startofs,cmplen;
  346.   UBYTE *saveptr;
  347.   UBYTE planes[4000];
  348.   UBYTE sf;
  349.   UBYTE dummy=0;
  350.  
  351.   if (filerequest("Save IFF File",str_filenam))
  352.   { sf=(memgray)?1:3;
  353.     if (mf==2)
  354.     { if (wx1>wx2) {t=wx2; wx2=wx1; wx1=t;}
  355.       if (wy1>wy2) {t=wy2; wy2=wy1; wy1=t;}
  356.       width=(wx2-wx1);
  357.       height=(wy2-wy1);
  358.       startofs=wy1*(memwidth>>sf)+(wx1>>sf);
  359.     }
  360.     else 
  361.     { width=memwidth;
  362.       height=memheight;
  363.       startofs=0;
  364.     }
  365.     width&=0xfff0;
  366.     qdatei=fopen(str_filenam,"wb");
  367.     bmlen=(memgray)?((width>>1)*height):((width>>3)*height);
  368.     totlen=bmlen+40+((memgray)?56:14);
  369.     iff_head[1]=totlen; 
  370.     iff_head[5]=(width<<16)|height;
  371.     iff_head[7]=((memgray)?0x04000000:0x01000000)|((cmp)?0x0100:0);
  372.     iff_body[1]=bmlen;
  373.     fwrite(&iff_head[0],sizeof(iff_head),1,qdatei);
  374.     if (memgray) fwrite(iff_cmap_gray,sizeof(iff_cmap_gray),1,qdatei);
  375.     else fwrite(iff_cmap_bw,sizeof(iff_cmap_bw),1,qdatei);
  376.     fwrite(iff_body,sizeof(iff_body),1,qdatei);
  377.     saveptr=memptr+startofs;
  378.     cmplen=0;
  379.     if (memgray) for (i=0;i<height;i++)
  380.     { fplanesep(saveptr,&planes[0],&planes[width>>3],&planes[2*(width>>3)],&planes[3*(width>>3)],(width>>3));
  381.       if (cmp) cmplen+=cmpline(&planes[0],width>>1,4,qdatei);
  382.       else fwrite(&planes[0],width>>1,1,qdatei);
  383.       saveptr+=(ULONG)(memwidth>>1);
  384.     }
  385.     else for (i=0;i<height;i++)
  386.     { if (cmp) cmplen+=cmpline(saveptr,width>>3,1,qdatei);
  387.       else fwrite(saveptr,width>>3,1,qdatei);
  388.       saveptr+=(ULONG)(memwidth>>3);
  389.     }
  390.     if (cmp)
  391.     { if (cmplen&1) fwrite(&dummy,1,1,qdatei);
  392.       fseek(qdatei,sizeof(iff_head)+((memgray)?(sizeof(iff_cmap_gray)):
  393.             (sizeof(iff_cmap_bw)))+4,SEEK_SET);
  394.       fwrite(&cmplen,4,1,qdatei);
  395.       if (cmplen&1) cmplen++;
  396.       fseek(qdatei,4,SEEK_SET);
  397.       cmplen+=((memgray)?96:54);
  398.       fwrite(&cmplen,4,1,qdatei);
  399.     }
  400.     fclose(qdatei); 
  401.   }
  402. }
  403.  
  404. void view(UWORD x, UWORD y, UBYTE zoom)
  405. { UBYTE *vptr;
  406.   UBYTE *plptr[4];
  407.   ULONG vinc;
  408.   ULONG vicr[13];
  409.   UWORD i,j,k,n1,n2,zeile;
  410.   UBYTE linebuf[1000];
  411.  
  412.   for (i=0;i<4;i++) plptr[i]=(UBYTE *)(rp->BitMap->Planes[i]+1680);
  413.   vptr=(memgray)?
  414.        (UBYTE*)(memptr+(((memwidth>>1)*y)+(x>>1))):
  415.        (UBYTE*)(memptr+(((memwidth>>3)*y)+(x>>3)));
  416.   vinc=(memgray)?(ULONG)(memwidth>>1):(ULONG)(memwidth>>3);
  417.   if (zoom)
  418.   { if ((memheight/4)<VIEWHEIGHT) sk=4;
  419.     else if ((memheight/8)<VIEWHEIGHT) sk=8;
  420.     else if ((memheight/12)<VIEWHEIGHT) sk=12;
  421.     vptr=memptr;
  422.     vicr[0]=0; vicr[1]=vinc;
  423.     for (i=2;i<13;i++) vicr[i]=vicr[i-1]+vinc;
  424.     clrscr(plptr[0],plptr[1],plptr[2],plptr[3]);
  425.     zeile=0; vx=vy=0;
  426.     if (memgray)
  427.     switch (sk)
  428.     { case 4: while(zeile<memheight)
  429.               { zeile+=4;
  430.                 for (i=0;i<(memwidth>>1);i+=4)
  431.                 { n1=n2=0; j=i;
  432.                   for (k=0;k<4;k++)
  433.                   { n1+=((*(vptr+j  )>>4)+(*(vptr+j  )&15)+(*(vptr+j+1)>>4)+(*(vptr+j+1)&15));
  434.                     n2+=((*(vptr+j+2)>>4)+(*(vptr+j+2)&15)+(*(vptr+j+3)>>4)+(*(vptr+j+3)&15));
  435.                     j+=vinc;
  436.                   }
  437.                   linebuf[i>>2]=(n1&0xf0)|(n2>>4);
  438.                 }
  439.                 vplanesep(&linebuf[0],plptr[0],plptr[1],plptr[2],plptr[3],memwidth>>5);
  440.                 plptr[0]+=80; plptr[1]+=80; plptr[2]+=80; plptr[3]+=80;
  441.                 vptr+=vicr[4];
  442.               } 
  443.               break;
  444.       case 8: while(zeile<memheight)
  445.               { zeile+=8;
  446.                 for (i=0;i<(memwidth>>1);i+=8)
  447.                 { n1=n2=0; j=i;
  448.                   for (k=0;k<8;k++)
  449.                   { n1+=((*(vptr+j  )>>4)+(*(vptr+j  )&15)+(*(vptr+j+1)>>4)+(*(vptr+j+1)&15)
  450.                         +(*(vptr+j+2)>>4)+(*(vptr+j+2)&15)+(*(vptr+j+3)>>4)+(*(vptr+j+3)&15));
  451.                     n2+=((*(vptr+j+4)>>4)+(*(vptr+j+4)&15)+(*(vptr+j+5)>>4)+(*(vptr+j+5)&15)
  452.                         +(*(vptr+j+6)>>4)+(*(vptr+j+6)&15)+(*(vptr+j+7)>>4)+(*(vptr+j+7)&15));
  453.                     j+=vinc;
  454.                   }
  455.                   linebuf[i>>3]=((n1>>2)&0xf0)|((n2>>6)&0x0f);
  456.                 }
  457.                 vplanesep(&linebuf[0],plptr[0],plptr[1],plptr[2],plptr[3],memwidth>>6);
  458.                 plptr[0]+=80; plptr[1]+=80; plptr[2]+=80; plptr[3]+=80;
  459.                 vptr+=vicr[8];
  460.               } 
  461.               break;
  462.       case 12:while(zeile<memheight)
  463.               { zeile+=12;
  464.                 for (i=0;i<(memwidth>>1);i+=12)
  465.                 { n1=n2=0; j=i;
  466.                   for (k=0;k<12;k++)
  467.                   { n1+=((*(vptr+j   )>>4)+(*(vptr+j   )&15)+(*(vptr+j+ 1)>>4)+(*(vptr+j+ 1)&15)
  468.                         +(*(vptr+j+ 2)>>4)+(*(vptr+j+ 2)&15)+(*(vptr+j+ 3)>>4)+(*(vptr+j+ 3)&15)
  469.                         +(*(vptr+j+ 4)>>4)+(*(vptr+j+ 4)&15)+(*(vptr+j+ 5)>>4)+(*(vptr+j+ 5)&15));
  470.                     n2+=((*(vptr+j+ 6)>>4)+(*(vptr+j+ 6)&15)+(*(vptr+j+ 7)>>4)+(*(vptr+j+ 7)&15)
  471.                         +(*(vptr+j+ 8)>>4)+(*(vptr+j+ 8)&15)+(*(vptr+j+ 9)>>4)+(*(vptr+j+ 9)&15)
  472.                         +(*(vptr+j+10)>>4)+(*(vptr+j+10)&15)+(*(vptr+j+11)>>4)+(*(vptr+j+11)&15));
  473.                     j+=vinc;
  474.                   }
  475.                   linebuf[i/12]=(((n1/144)<<4)&0xf0)|((n2/144)&0x0f);
  476.                 }
  477.                 vplanesep(&linebuf[0],plptr[0],plptr[1],plptr[2],plptr[3],memwidth/96);
  478.                 plptr[0]+=80; plptr[1]+=80; plptr[2]+=80; plptr[3]+=80;
  479.                 vptr+=vicr[12];
  480.               } 
  481.               break;
  482.     }
  483.     else
  484.     switch (sk)
  485.     { case 4: while(zeile<memheight)
  486.               { zeile+=4;
  487.                 for (i=0;i<(memwidth>>3);i++)
  488.                 { n1=numbits[(*(vptr+i        ))>>4]+numbits[(*(vptr+i+vicr[1]))>>4]
  489.                     +numbits[(*(vptr+i+vicr[2]))>>4]+numbits[(*(vptr+i+vicr[3]))>>4];
  490.                   if (n1==16) n1=15;
  491.                   n2=numbits[(*(vptr+i        ))&15]+numbits[(*(vptr+i+vicr[1]))&15]
  492.                     +numbits[(*(vptr+i+vicr[2]))&15]+numbits[(*(vptr+i+vicr[3]))&15];
  493.                   if (n2==16) n2=15;
  494.                   linebuf[i]=(~((n1<<4)|n2));
  495.                 }
  496.                 vplanesep(&linebuf[0],plptr[0],plptr[1],plptr[2],plptr[3],memwidth>>5);
  497.                 plptr[0]+=80; plptr[1]+=80; plptr[2]+=80; plptr[3]+=80;
  498.                 vptr+=vicr[4];
  499.               } 
  500.               break;
  501.       case 8: while(zeile<memheight)
  502.               { zeile+=8;
  503.                 for (i=0;i<(memwidth>>3);i+=2)
  504.                 { n1=(numbits[(*(vptr+i        ))]
  505.                      +numbits[(*(vptr+i+vicr[1]))]
  506.                      +numbits[(*(vptr+i+vicr[2]))]
  507.                      +numbits[(*(vptr+i+vicr[3]))]
  508.                      +numbits[(*(vptr+i+vicr[4]))]
  509.                      +numbits[(*(vptr+i+vicr[5]))]
  510.                      +numbits[(*(vptr+i+vicr[6]))]
  511.                      +numbits[(*(vptr+i+vicr[7]))])>>2;
  512.                   if (n1==16) n1=15;
  513.                   n2=(numbits[(*(vptr+i+1        ))]
  514.                      +numbits[(*(vptr+i+1+vicr[1]))]
  515.                      +numbits[(*(vptr+i+1+vicr[2]))]
  516.                      +numbits[(*(vptr+i+1+vicr[3]))]
  517.                      +numbits[(*(vptr+i+1+vicr[4]))]
  518.                      +numbits[(*(vptr+i+1+vicr[5]))]
  519.                      +numbits[(*(vptr+i+1+vicr[6]))]
  520.                      +numbits[(*(vptr+i+1+vicr[7]))])>>2;
  521.                   if (n2==16) n2=15;
  522.                   linebuf[i>>1]=(~((n1<<4)|n2));
  523.                 }
  524.                 vplanesep(&linebuf[0],plptr[0],plptr[1],plptr[2],plptr[3],memwidth>>6);
  525.                 plptr[0]+=80; plptr[1]+=80; plptr[2]+=80; plptr[3]+=80;
  526.                 vptr+=vicr[8];
  527.               } 
  528.               break;
  529.       case 12:while(zeile<memheight)
  530.               { zeile+=12;
  531.                 for (i=0;i<(memwidth>>3);i+=3)
  532.                 { n1=(numbits[(*(vptr+i           ))]
  533.                      +numbits[(*(vptr+i+  vicr[ 1]))]
  534.                      +numbits[(*(vptr+i+  vicr[ 2]))]
  535.                      +numbits[(*(vptr+i+  vicr[ 3]))]
  536.                      +numbits[(*(vptr+i+  vicr[ 4]))]
  537.                      +numbits[(*(vptr+i+  vicr[ 5]))]
  538.                      +numbits[(*(vptr+i+  vicr[ 6]))]
  539.                      +numbits[(*(vptr+i+  vicr[ 7]))]
  540.                      +numbits[(*(vptr+i+  vicr[ 8]))]
  541.                      +numbits[(*(vptr+i+  vicr[ 9]))]
  542.                      +numbits[(*(vptr+i+  vicr[10]))]
  543.                      +numbits[(*(vptr+i+  vicr[11]))]
  544.                      +numbits[(*(vptr+i+1         ))>>4]
  545.                      +numbits[(*(vptr+i+1+vicr[ 1]))>>4]
  546.                      +numbits[(*(vptr+i+1+vicr[ 2]))>>4]
  547.                      +numbits[(*(vptr+i+1+vicr[ 3]))>>4]
  548.                      +numbits[(*(vptr+i+1+vicr[ 4]))>>4]
  549.                      +numbits[(*(vptr+i+1+vicr[ 5]))>>4]
  550.                      +numbits[(*(vptr+i+1+vicr[ 6]))>>4]
  551.                      +numbits[(*(vptr+i+1+vicr[ 7]))>>4]
  552.                      +numbits[(*(vptr+i+1+vicr[ 8]))>>4]
  553.                      +numbits[(*(vptr+i+1+vicr[ 9]))>>4]
  554.                      +numbits[(*(vptr+i+1+vicr[10]))>>4]
  555.                      +numbits[(*(vptr+i+1+vicr[11]))>>4]);
  556.                   n2=(numbits[(*(vptr+i+2         ))]
  557.                      +numbits[(*(vptr+i+2+vicr[ 1]))]
  558.                      +numbits[(*(vptr+i+2+vicr[ 2]))]
  559.                      +numbits[(*(vptr+i+2+vicr[ 3]))]
  560.                      +numbits[(*(vptr+i+2+vicr[ 4]))]
  561.                      +numbits[(*(vptr+i+2+vicr[ 5]))]
  562.                      +numbits[(*(vptr+i+2+vicr[ 6]))]
  563.                      +numbits[(*(vptr+i+2+vicr[ 7]))]
  564.                      +numbits[(*(vptr+i+2+vicr[ 8]))]
  565.                      +numbits[(*(vptr+i+2+vicr[ 9]))]
  566.                      +numbits[(*(vptr+i+2+vicr[10]))]
  567.                      +numbits[(*(vptr+i+2+vicr[11]))]
  568.                      +numbits[(*(vptr+i+1         ))&15]
  569.                      +numbits[(*(vptr+i+1+vicr[ 1]))&15]
  570.                      +numbits[(*(vptr+i+1+vicr[ 2]))&15]
  571.                      +numbits[(*(vptr+i+1+vicr[ 3]))&15]
  572.                      +numbits[(*(vptr+i+1+vicr[ 4]))&15]
  573.                      +numbits[(*(vptr+i+1+vicr[ 5]))&15]
  574.                      +numbits[(*(vptr+i+1+vicr[ 6]))&15]
  575.                      +numbits[(*(vptr+i+1+vicr[ 7]))&15]
  576.                      +numbits[(*(vptr+i+1+vicr[ 8]))&15]
  577.                      +numbits[(*(vptr+i+1+vicr[ 9]))&15]
  578.                      +numbits[(*(vptr+i+1+vicr[10]))&15]
  579.                      +numbits[(*(vptr+i+1+vicr[11]))&15]);
  580.                   n1=n1/9;
  581.                   n2=n2/9;
  582.                   if (n1==16) n1=15;
  583.                   if (n2==16) n2=15;
  584.                   linebuf[i/3]=(~((n1<<4)|n2));
  585.                 }
  586.                 vplanesep(&linebuf[0],plptr[0],plptr[1],plptr[2],plptr[3],memwidth/96);
  587.                 plptr[0]+=80; plptr[1]+=80; plptr[2]+=80; plptr[3]+=80;
  588.                 vptr+=vicr[12];
  589.               } 
  590.               break;
  591.     }    
  592.   }
  593.   else
  594.   { vx=x&0xfff0; vy=y&0xfffe; sk=1;
  595.     if (memgray) grayview(vptr,plptr[0],plptr[1],plptr[2],plptr[3],vinc); 
  596.     else bwview(vptr,plptr[0],plptr[1],plptr[2],plptr[3],vinc); 
  597.   } 
  598. }
  599.  
  600. UWORD s2px(UWORD x)
  601. { int t;
  602.   t=x*sk+vx;
  603.   if (t>=memwidth) t=memwidth-1;
  604.   if (t<0) t=0;
  605.   return((UWORD)t);
  606. }
  607.  
  608. UWORD s2py(UWORD y)
  609. { int t;
  610.   t=y*sk+vy;
  611.   if (t>=memheight) t=memheight-1;
  612.   if (t<0) t=0;
  613.   return((UWORD)t);
  614. }
  615.  
  616. UWORD p2sx(UWORD x)
  617. { int t;
  618.   t=(x-vx)/sk;
  619.   if (t>623) t=623;
  620.   if (t<0) t=0;
  621.   return((UWORD)t);
  622. }
  623.  
  624. UWORD p2sy(UWORD y)
  625. { int t;
  626.   t=(y-vy)/sk;
  627.   if (t>(VIEWHEIGHT-1)) t=VIEWHEIGHT-1;
  628.   if (t<0) t=0;
  629.   return((UWORD)t);
  630. }
  631.  
  632. void drawbox(UWORD wx1,UWORD wy1,UWORD wx2,UWORD wy2,struct RastPort *wrp)
  633. { UWORD sx1,sy1,sx2,sy2;
  634.   
  635.   sx1=p2sx(wx1); sy1=p2sy(wy1)+11;
  636.   sx2=p2sx(wx2); sy2=p2sy(wy2)+11; 
  637.   SetWrMsk(wrp,8);
  638.   SetAPen(wrp,8);
  639.   SetDrMd(wrp,COMPLEMENT|JAM1);
  640.   SetDrPt(wrp,0xcccc);
  641.   Move(wrp,sx1,sy1);
  642.   Draw(wrp,sx1,sy2);
  643.   Draw(wrp,sx2,sy2);
  644.   Draw(wrp,sx2,sy1);
  645.   Draw(wrp,sx1,sy1);
  646.   SetWrMsk(wrp,1);
  647.   SetAPen(wrp,1);
  648.   SetDrMd(wrp,COMPLEMENT|JAM1);
  649.   SetDrPt(wrp,0x3333);
  650.   Move(wrp,sx1,sy1);
  651.   Draw(wrp,sx1,sy2);
  652.   Draw(wrp,sx2,sy2);
  653.   Draw(wrp,sx2,sy1);
  654.   Draw(wrp,sx1,sy1);
  655.   SetWrMsk(wrp,15);
  656. }
  657.  
  658. void cut(UWORD wx1,UWORD wy1,UWORD wx2,UWORD wy2,UBYTE mf)
  659. { UWORD width,height,x,y,t;
  660.   ULONG startofs;
  661.   UBYTE *picptr,*cpyptr;
  662.   UBYTE sf;
  663.  
  664.   sf=(memgray)?1:3;
  665.   if ((memwidth<=640)||(memheight<=512)) MessReq("Area already has minimal size");
  666.   if (mf!=2) MessReq("No Area selected!");
  667.   else
  668.   { if (wx1>wx2) {t=wx2; wx2=wx1; wx1=t;}
  669.     if (wy1>wy2) {t=wy2; wy2=wy1; wy1=t;}
  670.     width=(wx2-wx1);
  671.     height=(wy2-wy1);
  672.     if (height<512) 
  673.     { height=512;
  674.       if ((wy1+height)>memheight) wy1=memheight-height;
  675.     }
  676.     if (width<640) 
  677.     { width=640;
  678.       if ((wx1+width)>memwidth) wx1=memwidth-width;
  679.     }
  680.     startofs=wy1*(memwidth>>sf)+(wx1>>sf);
  681.     picptr=memptr;
  682.     for (y=0;y<height;y++)
  683.     { cpyptr=memptr+startofs;
  684.       for(x=0;x<(width>>sf);x++) *(picptr++)=*(cpyptr++);
  685.       startofs+=(ULONG)(memwidth>>sf);
  686.     }
  687.     mf=0;
  688.     memwidth=width;
  689.     memheight=height;
  690.     if (!(memptr=(UBYTE *)realloc(memptr,(memwidth*(memheight+ADDLIN))>>sf)))
  691.     { memneed=0;
  692.       MessReq((UBYTE *)"Out Of Memory!");
  693.     }
  694.   }
  695. }
  696.