home *** CD-ROM | disk | FTP | other *** search
/ Dream 44 / Amiga_Dream_44.iso / Amiga / workbench / pilotes / scanners / StScan.lha / StScan / imginout.c < prev    next >
C/C++ Source or Header  |  1997-08-16  |  49KB  |  873 lines
  1. /*
  2. **      $VER: imginout.c 3.00D (11.8.97)
  3. **
  4. **      STScan input/output routines
  5. **
  6. **      Written by Frank-Christian Kruegel, Henning Peters, Andreas R. Kleinert
  7. **      GNU General Public License V2
  8. */
  9.  
  10. #include "stscan.h"
  11.  
  12. #define ST400LUN 96
  13. #define FORM 0x464f524d
  14. #define ILBM 0x494c424d
  15. #define BMHD 0x424d4844
  16. #define BODY 0x424f4459
  17. #define DIR_READ  1
  18. #define DIR_WRITE 0
  19.  
  20. /* Scanner specific sizes and commands */
  21.  
  22. static UWORD cornerxval[]={  22,  33,  44, 266, 399, 535, 432, 652, 868};
  23. static UWORD corneryval[]={   6,   6,   6,   6,   6,   6,   6,   6,   6};
  24. static UWORD widthval[]=  {1664,2496,3312,1168,1760,2336, 816,1248,1648};
  25. static UWORD heightval[]= {2336,3504,4672,1656,2484,3312,1168,1760,2336};
  26.  
  27. static UBYTE cmd_scan[]={0x1b,ST400LUN,0,0,0,0};
  28. static UBYTE cmd_read[]={0x28,ST400LUN,0,0,0,0,0,0,0,0};
  29. static UBYTE cmd_dwin[]={0x24,ST400LUN,0,0,0,0,0,0,40,0};
  30. static UBYTE cmd_mdon[]={0x15,ST400LUN,0,0,0,128};
  31. static UBYTE cmd_mdoff[]={0x15,ST400LUN,0,0,0,0};
  32. static UBYTE cmd_inqu[]={0x12,ST400LUN,0,0,96,0};
  33.  
  34. /* IFF-ILBM Constants */
  35.  
  36. static UBYTE iff_cmap_bw[]=
  37. {'C','M','A','P',0,0,0,6,0,0,0,255,255,255};
  38.  
  39. static UBYTE iff_cmap_gray[]=
  40. {'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,
  41.  96,96,96,112,112,112,128,128,128,144,144,144,160,160,160,176,176,176,
  42.  192,192,192,208,208,208,224,224,224,240,240,240};
  43.  
  44. static UBYTE iff_cmap_ext[]=
  45. {'C','M','A','P',0,0,3,0,
  46.  0x00,0x00,0x00,0x01,0x01,0x01,0x02,0x02,0x02,0x03,0x03,0x03,
  47.  0x04,0x04,0x04,0x05,0x05,0x05,0x06,0x06,0x06,0x07,0x07,0x07,
  48.  0x08,0x08,0x08,0x09,0x09,0x09,0x0a,0x0a,0x0a,0x0b,0x0b,0x0b,
  49.  0x0c,0x0c,0x0c,0x0d,0x0d,0x0d,0x0e,0x0e,0x0e,0x0f,0x0f,0x0f,
  50.  0x10,0x10,0x10,0x11,0x11,0x11,0x12,0x12,0x12,0x13,0x13,0x13,
  51.  0x14,0x14,0x14,0x15,0x15,0x15,0x16,0x16,0x16,0x17,0x17,0x17,
  52.  0x18,0x18,0x18,0x19,0x19,0x19,0x1a,0x1a,0x1a,0x1b,0x1b,0x1b,
  53.  0x1c,0x1c,0x1c,0x1d,0x1d,0x1d,0x1e,0x1e,0x1e,0x1f,0x1f,0x1f,
  54.  0x20,0x20,0x20,0x21,0x21,0x21,0x22,0x22,0x22,0x23,0x23,0x23,
  55.  0x24,0x24,0x24,0x25,0x25,0x25,0x26,0x26,0x26,0x27,0x27,0x27,
  56.  0x28,0x28,0x28,0x29,0x29,0x29,0x2a,0x2a,0x2a,0x2b,0x2b,0x2b,
  57.  0x2c,0x2c,0x2c,0x2d,0x2d,0x2d,0x2e,0x2e,0x2e,0x2f,0x2f,0x2f,
  58.  0x30,0x30,0x30,0x31,0x31,0x31,0x32,0x32,0x32,0x33,0x33,0x33,
  59.  0x34,0x34,0x34,0x35,0x35,0x35,0x36,0x36,0x36,0x37,0x37,0x37,
  60.  0x38,0x38,0x38,0x39,0x39,0x39,0x3a,0x3a,0x3a,0x3b,0x3b,0x3b,
  61.  0x3c,0x3c,0x3c,0x3d,0x3d,0x3d,0x3e,0x3e,0x3e,0x3f,0x3f,0x3f,
  62.  0x40,0x40,0x40,0x41,0x41,0x41,0x42,0x42,0x42,0x43,0x43,0x43,
  63.  0x44,0x44,0x44,0x45,0x45,0x45,0x46,0x46,0x46,0x47,0x47,0x47,
  64.  0x48,0x48,0x48,0x49,0x49,0x49,0x4a,0x4a,0x4a,0x4b,0x4b,0x4b,
  65.  0x4c,0x4c,0x4c,0x4d,0x4d,0x4d,0x4e,0x4e,0x4e,0x4f,0x4f,0x4f,
  66.  0x50,0x50,0x50,0x51,0x51,0x51,0x52,0x52,0x52,0x53,0x53,0x53,
  67.  0x54,0x54,0x54,0x55,0x55,0x55,0x56,0x56,0x56,0x57,0x57,0x57,
  68.  0x58,0x58,0x58,0x59,0x59,0x59,0x5a,0x5a,0x5a,0x5b,0x5b,0x5b,
  69.  0x5c,0x5c,0x5c,0x5d,0x5d,0x5d,0x5e,0x5e,0x5e,0x5f,0x5f,0x5f,
  70.  0x60,0x60,0x60,0x61,0x61,0x61,0x62,0x62,0x62,0x63,0x63,0x63,
  71.  0x64,0x64,0x64,0x65,0x65,0x65,0x66,0x66,0x66,0x67,0x67,0x67,
  72.  0x68,0x68,0x68,0x69,0x69,0x69,0x6a,0x6a,0x6a,0x6b,0x6b,0x6b,
  73.  0x6c,0x6c,0x6c,0x6d,0x6d,0x6d,0x6e,0x6e,0x6e,0x6f,0x6f,0x6f,
  74.  0x70,0x70,0x70,0x71,0x71,0x71,0x72,0x72,0x72,0x73,0x73,0x73,
  75.  0x74,0x74,0x74,0x75,0x75,0x75,0x76,0x76,0x76,0x77,0x77,0x77,
  76.  0x78,0x78,0x78,0x79,0x79,0x79,0x7a,0x7a,0x7a,0x7b,0x7b,0x7b,
  77.  0x7c,0x7c,0x7c,0x7d,0x7d,0x7d,0x7e,0x7e,0x7e,0x7f,0x7f,0x7f,
  78.  0x80,0x80,0x80,0x81,0x81,0x81,0x82,0x82,0x82,0x83,0x83,0x83,
  79.  0x84,0x84,0x84,0x85,0x85,0x85,0x86,0x86,0x86,0x87,0x87,0x87,
  80.  0x88,0x88,0x88,0x89,0x89,0x89,0x8a,0x8a,0x8a,0x8b,0x8b,0x8b,
  81.  0x8c,0x8c,0x8c,0x8d,0x8d,0x8d,0x8e,0x8e,0x8e,0x8f,0x8f,0x8f,
  82.  0x90,0x90,0x90,0x91,0x91,0x91,0x92,0x92,0x92,0x93,0x93,0x93,
  83.  0x94,0x94,0x94,0x95,0x95,0x95,0x96,0x96,0x96,0x97,0x97,0x97,
  84.  0x98,0x98,0x98,0x99,0x99,0x99,0x9a,0x9a,0x9a,0x9b,0x9b,0x9b,
  85.  0x9c,0x9c,0x9c,0x9d,0x9d,0x9d,0x9e,0x9e,0x9e,0x9f,0x9f,0x9f,
  86.  0xa0,0xa0,0xa0,0xa1,0xa1,0xa1,0xa2,0xa2,0xa2,0xa3,0xa3,0xa3,
  87.  0xa4,0xa4,0xa4,0xa5,0xa5,0xa5,0xa6,0xa6,0xa6,0xa7,0xa7,0xa7,
  88.  0xa8,0xa8,0xa8,0xa9,0xa9,0xa9,0xaa,0xaa,0xaa,0xab,0xab,0xab,
  89.  0xac,0xac,0xac,0xad,0xad,0xad,0xae,0xae,0xae,0xaf,0xaf,0xaf,
  90.  0xb0,0xb0,0xb0,0xb1,0xb1,0xb1,0xb2,0xb2,0xb2,0xb3,0xb3,0xb3,
  91.  0xb4,0xb4,0xb4,0xb5,0xb5,0xb5,0xb6,0xb6,0xb6,0xb7,0xb7,0xb7,
  92.  0xb8,0xb8,0xb8,0xb9,0xb9,0xb9,0xba,0xba,0xba,0xbb,0xbb,0xbb,
  93.  0xbc,0xbc,0xbc,0xbd,0xbd,0xbd,0xbe,0xbe,0xbe,0xbf,0xbf,0xbf,
  94.  0xc0,0xc0,0xc0,0xc1,0xc1,0xc1,0xc2,0xc2,0xc2,0xc3,0xc3,0xc3,
  95.  0xc4,0xc4,0xc4,0xc5,0xc5,0xc5,0xc6,0xc6,0xc6,0xc7,0xc7,0xc7,
  96.  0xc8,0xc8,0xc8,0xc9,0xc9,0xc9,0xca,0xca,0xca,0xcb,0xcb,0xcb,
  97.  0xcc,0xcc,0xcc,0xcd,0xcd,0xcd,0xce,0xce,0xce,0xcf,0xcf,0xcf,
  98.  0xd0,0xd0,0xd0,0xd1,0xd1,0xd1,0xd2,0xd2,0xd2,0xd3,0xd3,0xd3,
  99.  0xd4,0xd4,0xd4,0xd5,0xd5,0xd5,0xd6,0xd6,0xd6,0xd7,0xd7,0xd7,
  100.  0xd8,0xd8,0xd8,0xd9,0xd9,0xd9,0xda,0xda,0xda,0xdb,0xdb,0xdb,
  101.  0xdc,0xdc,0xdc,0xdd,0xdd,0xdd,0xde,0xde,0xde,0xdf,0xdf,0xdf,
  102.  0xe0,0xe0,0xe0,0xe1,0xe1,0xe1,0xe2,0xe2,0xe2,0xe3,0xe3,0xe3,
  103.  0xe4,0xe4,0xe4,0xe5,0xe5,0xe5,0xe6,0xe6,0xe6,0xe7,0xe7,0xe7,
  104.  0xe8,0xe8,0xe8,0xe9,0xe9,0xe9,0xea,0xea,0xea,0xeb,0xeb,0xeb,
  105.  0xec,0xec,0xec,0xed,0xed,0xed,0xee,0xee,0xee,0xef,0xef,0xef,
  106.  0xf0,0xf0,0xf0,0xf1,0xf1,0xf1,0xf2,0xf2,0xf2,0xf3,0xf3,0xf3,
  107.  0xf4,0xf4,0xf4,0xf5,0xf5,0xf5,0xf6,0xf6,0xf6,0xf7,0xf7,0xf7,
  108.  0xf8,0xf8,0xf8,0xf9,0xf9,0xf9,0xfa,0xfa,0xfa,0xfb,0xfb,0xfb,
  109.  0xfc,0xfc,0xfc,0xfd,0xfd,0xfd,0xfe,0xfe,0xfe,0xff,0xff,0xff
  110. };
  111.  
  112. static ULONG iff_head[]={FORM,0,ILBM,BMHD,20,0,0,0,0x00000101,0x02800200};
  113.  
  114. static ULONG iff_body[]={BODY,0};
  115.  
  116. static ULONG chunk_hd[2];
  117.  
  118. typedef struct iffhead
  119. { ULONG iff_magic;
  120.         ULONG filelen;
  121.         ULONG ilbm_magic;
  122.         ULONG bmhd_magic;
  123.         ULONG bmhd_len;
  124.         UWORD w,h,x,y;
  125.         UBYTE d, mask, cmp, pad;
  126.         UWORD transparent,aspect,pw,ph;
  127. } iffhead;
  128.  
  129. static struct iffhead iffheader;
  130.  
  131. UBYTE sk;
  132. UWORD vx,vy;
  133. static char str_filenam[256] = "";
  134.  
  135. USHORT filerequest(char *titel,char *str_filenam)
  136. {
  137.         struct rtFileRequester *filereq;
  138.         char filename[34];
  139.  
  140.         if ((filereq=rtAllocRequestA(RT_FILEREQ, NULL))) {
  141.                 if (rtFileRequest(filereq, filename, titel, TAG_END)) {
  142.                         strcpy(str_filenam,filereq->Dir);
  143.                         strcat(str_filenam,filename);
  144.                         return 1;
  145.                 }
  146.         }
  147.         return 0;
  148. }
  149.  
  150. void MessReq(UBYTE *string) {
  151.   rtEZRequest(string, "Ok", NULL, NULL);
  152. }
  153.  
  154. void NotAvailable(void)
  155. {  MessReq((UBYTE *)"Funktion nicht da!");
  156. }
  157.  
  158. UBYTE DoScsi(UBYTE *cmd, UWORD cmdlen, UWORD *data, ULONG datalen, UBYTE flags)
  159. { struct SCSICmd scmd;
  160.         scmd.scsi_Command=cmd;
  161.         scmd.scsi_CmdLength=cmdlen;
  162.         scmd.scsi_Data=data;
  163.         scmd.scsi_Length=datalen;
  164.         scmd.scsi_Flags=flags;
  165.         diskreq->io_Length = sizeof(struct SCSICmd);
  166.         diskreq->io_Data = &scmd;
  167.         diskreq->io_Command = 28;
  168.         DoIO(diskreq);
  169.         return(scmd.scsi_Status);
  170. }
  171.  
  172.  
  173. void inquiry(void)
  174. { UBYTE string[96],inq_txt[45];
  175.  
  176.         DoScsi(&cmd_inqu[0],6,(UWORD *)&string,96,DIR_READ);
  177.         strncpy(&inq_txt[0],&string[8],39);
  178.         MessReq(&inq_txt[0]);
  179. }
  180.  
  181. void scan(void)
  182. { ULONG memsize,memadd,blsize;
  183.         short tabindex,blocks,rest,i,glin,rlin;
  184.         UBYTE *rdptr;
  185.  
  186.         if (memptr) free(memptr);
  187.         memneed=0;
  188.         tabindex=((winpar.resx/100)-2)+(winpar.size-4)*3;
  189.         winpar.cornerx=cornerxval[tabindex];
  190.         winpar.cornery=corneryval[tabindex];
  191.         winpar.width=widthval[tabindex];
  192.         winpar.height=heightval[tabindex];
  193.         memsize=(winpar.halftone)?((ULONG)winpar.width*(ULONG)winpar.height)>>1:
  194.                                                                                                                 ((ULONG)winpar.width*(ULONG)winpar.height)>>3;
  195.         memadd=(memgray)?((ULONG)memwidth*ADDLIN)>>1:
  196.                                                                          ((ULONG)memwidth*ADDLIN)>>3;
  197.         if ((memptr=(UBYTE*)malloc(memsize+memadd/*+32768*/))==NULL)
  198.                 MessReq((UBYTE*)"Kein Speicher!");
  199.         else
  200.         { memneed=memsize;
  201.                 memwidth=winpar.width;
  202.                 memheight=winpar.height;
  203.                 memgray=winpar.halftone;
  204.                 rdptr=memptr;
  205.                 if (!(winpar.halftone))
  206.                 { DoScsi(&cmd_mdon[0],6,(UWORD *)NULL,0,0);
  207.                         Delay(100);
  208.                         DoScsi(&cmd_dwin[0],10,(UWORD *)&winpar,40,DIR_WRITE);
  209.                         DoScsi(&cmd_scan[0],6,(UWORD *)NULL,0,0);
  210.                         blocks=memsize/0x8000;
  211.                         rest=memsize%0x8000;
  212.                         cmd_read[7]=128; cmd_read[8]=0;
  213.                         for (i=0;i<blocks;i++)
  214.                         { /* DoScsi(&cmd_read[0],10,(UWORD *)rdptr,0x8000,DIR_READ); */
  215.                                 DoScsi(&cmd_read[0],10,(UWORD *)bufptr,0x8000,DIR_READ);
  216.         memcpy(rdptr,bufptr,0x8000);
  217.                                 rdptr+=0x8000;
  218.                         }
  219.                         cmd_read[7]=(rest>>8)&0xff; cmd_read[8]=rest&0xff;
  220.                         /* DoScsi(&cmd_read[0],10,(UWORD *)rdptr,rest,DIR_READ); */
  221.                         DoScsi(&cmd_read[0],10,(UWORD *)bufptr,rest,DIR_READ);
  222.                         memcpy(rdptr,bufptr,rest);
  223.                         rdptr+=rest;
  224.                 }
  225.                 else
  226.                 { glin=winpar.height;
  227.                         rlin=0x200000L/(ULONG)winpar.width;
  228.                         do
  229.                         { if (rlin>glin) rlin=glin;
  230.                                 winpar.height=rlin;
  231.                                 glin-=rlin;
  232.                                 DoScsi(&cmd_mdon[0],6,(UWORD *)NULL,0,0);
  233.                                 Delay(100);
  234.                                 DoScsi(&cmd_dwin[0],10,(UWORD *)&winpar,40,DIR_WRITE);
  235.                                 DoScsi(&cmd_scan[0],6,(UWORD *)NULL,0,0);
  236.         winpar.cornery+=rlin;
  237.                                 blsize=((ULONG)winpar.height*(ULONG)winpar.width)>>1;
  238.                                 blocks=blsize/0x4000;
  239.                                 rest=blsize%0x4000;
  240.                                 cmd_read[7]=128; cmd_read[8]=0;
  241.                                 for (i=0;i<blocks;i++)
  242.                                 { DoScsi(&cmd_read[0],10,(UWORD *)bufptr,0x8000,DIR_READ);
  243.                                         p64to16(bufptr,rdptr,0x4000);
  244.                                         rdptr+=0x4000;
  245.                                 }
  246.                                 cmd_read[7]=(rest>>7)&0xff; cmd_read[8]=(rest<<1)&0xff;
  247.                                 DoScsi(&cmd_read[0],10,(UWORD *)bufptr,rest<<1,DIR_READ);
  248.                                 p64to16(bufptr,rdptr,rest);
  249.         rdptr+=rest;
  250.                         } while (glin);
  251.                 }
  252.                 DoScsi(&cmd_mdoff[0],6,(UWORD *)NULL,0,0);
  253.         }
  254.         if (!(memptr=(UBYTE *)realloc(memptr,memsize+memadd)))
  255.         { memneed=0;
  256.                 MessReq((UBYTE *)"Kein Speicher");
  257.         }
  258.  
  259. }
  260.  
  261. void diskscan(void)
  262. { FILE *qdatei;
  263.         ULONG totlen,bmlen;
  264.         UWORD width,height,i,j,k;
  265.         UBYTE msk;
  266.         UBYTE planes[8][500];
  267.         struct DefWindow dskwinpar;
  268.         short tabindex,glin,rlin;
  269.  
  270.         if (filerequest("Speichere IFF File",str_filenam))
  271.         { width=memwidth;
  272.                 height=memheight;
  273.         }
  274.         width&=0xfff0;
  275.         qdatei=fopen(str_filenam,"wb");
  276.         bmlen=width*height;
  277.         totlen=bmlen+40+776;
  278.         iff_head[1]=totlen;
  279.         iff_head[5]=(width<<16)|height;
  280.         iff_head[7]=0x08000000;
  281.         iff_body[1]=bmlen;
  282.         fwrite(&iff_head[0],sizeof(iff_head),1,qdatei);
  283.         fwrite(iff_cmap_ext,sizeof(iff_cmap_ext),1,qdatei);
  284.         fwrite(iff_body,sizeof(iff_body),1,qdatei);
  285.         memcpy(&dskwinpar,&winpar,sizeof(winpar));
  286.         tabindex=((dskwinpar.resx/100)-2)+(dskwinpar.size-4)*3;
  287.         dskwinpar.cornerx=cornerxval[tabindex];
  288.         dskwinpar.cornery=corneryval[tabindex];
  289.         dskwinpar.width=widthval[tabindex];
  290.         dskwinpar.height=heightval[tabindex];
  291.         dskwinpar.halftone=2;
  292.         dskwinpar.bitspixel=8;
  293.         glin=dskwinpar.height;
  294.         rlin=0x200000L/(ULONG)dskwinpar.width;
  295.         do
  296.         { if (rlin>glin) rlin=glin;
  297.                 winpar.height=rlin;
  298.                 glin-=rlin;
  299.                 DoScsi(&cmd_mdon[0],6,(UWORD *)NULL,0,0);
  300.                 Delay(100);
  301.                 DoScsi(&cmd_dwin[0],10,(UWORD *)&dskwinpar,40,DIR_WRITE);
  302.                 DoScsi(&cmd_scan[0],6,(UWORD *)NULL,0,0);
  303.                 dskwinpar.cornery+=rlin;
  304.                 cmd_read[7]=(dskwinpar.width>>8)&0xff; cmd_read[8]=dskwinpar.width&0xff;
  305.                 for (i=0;i<dskwinpar.height;i++)
  306.                 { DoScsi(&cmd_read[0],10,(UWORD *)bufptr,dskwinpar.width,DIR_READ);
  307.                         memset(planes,0,sizeof(planes));
  308.                         for(k=0;k<6;k++)
  309.                         { msk=64>>k;
  310.                                 for(j=0;j<dskwinpar.width;j++)
  311.                                 { if (*(bufptr+j)&msk)
  312.                                                 planes[k][j>>3]|=0x80>>(j&7);
  313.                                 }
  314.                                 fwrite(planes[k],dskwinpar.width,1,qdatei);
  315.                         }
  316.                 }
  317.         } while (glin);
  318.         DoScsi(&cmd_mdoff[0],6,(UWORD *)NULL,0,0);
  319.         fclose(qdatei);
  320. }
  321.  
  322.  
  323. static ULONG cmpline(UBYTE *zeile, UWORD len, UWORD pnum, FILE *qdatei)
  324. { ULONG count;
  325.         UWORD plen,p;
  326.         UBYTE m;
  327.         WORD i,j;
  328.         static UBYTE cplane[6000];
  329.  
  330.         count=0;
  331.         plen=len/pnum;
  332.         for (p=0;p<pnum;p++)
  333.         { i=0;
  334.                 while(i<plen)
  335.                 { m=(*(zeile+i));
  336.                         for (j=i+1;((m==(*(zeile+j)))&&(j<plen)&&(j<(i+125)));j++);
  337.                         if (j!=(i+1))
  338.                         { cplane[count++]=(UBYTE)((257-j+i)&0xff);
  339.                                 cplane[count++]=m;
  340.                                 i=j;
  341.                         }
  342.                         else
  343.                         { for (;(m!=(*(zeile+j))&&(j<=plen)&&(j<(i+125)));m=(*(zeile+(j++))));
  344.                                 if (j<plen) j-=2;
  345.                                 j=((plen-1)<j)?(plen-1):j;
  346.                                 cplane[count++]=(UBYTE)(j-i);
  347.                                 for(;i<=j;cplane[count++]=(*(zeile+(i++))));
  348.                         }
  349.                 }
  350.                 zeile+=plen;
  351.         }
  352.         fwrite(&cplane[0],count,1,qdatei);
  353.         return(count);
  354. }
  355.  
  356.  
  357. void load(void)
  358. { FILE *sdatei;
  359.         ULONG memsize,memadd;
  360.         UWORD i,t;
  361.         UBYTE *loadptr;
  362.         UBYTE planes[4000];
  363.         UBYTE cnt,cval;
  364.         UWORD bflag=1;
  365.  
  366.         if (filerequest("Lade IFF File",str_filenam))
  367.         { sdatei=fopen(str_filenam,"rb");
  368.                 fread(&iffheader,sizeof(iffheader),1,sdatei);
  369.                 if ((iffheader.iff_magic!=FORM)||(iffheader.ilbm_magic!=ILBM)||
  370.                                 (iffheader.bmhd_magic!=BMHD)||(iffheader.bmhd_len!=20))
  371.                 { MessReq("Kein IFF-ILBM File!");
  372.                         fclose(sdatei);
  373.                 }
  374.                 else
  375.                 { if (memptr) free(memptr);
  376.                         memneed=0;
  377.                         memgray=((iffheader.d)!=1);
  378.                         memwidth=iffheader.w;
  379.                         memheight=iffheader.h;
  380.                         memsize=(memgray)?((ULONG)memwidth*(ULONG)memheight)>>1:
  381.                                                                                                 ((ULONG)memwidth*(ULONG)memheight)>>3;
  382.                         memadd=(memgray)?((ULONG)memwidth*ADDLIN)>>1:
  383.                                                                                          ((ULONG)memwidth*ADDLIN)>>3;
  384.                         if ((memptr=(UBYTE*)malloc(memsize+memadd))==NULL)
  385.                         { MessReq((UBYTE*)"Kein Speicher");
  386.                                 fclose(sdatei);
  387.                         }
  388.                         else
  389.                         { memneed=memsize;
  390.                                 while (bflag) /* hier CMAP und Body suchen */
  391.                                 { fread(&chunk_hd[0],8,1,sdatei);
  392.                                         if (chunk_hd[0]==BODY) bflag=0;
  393.                                         else fseek(sdatei,chunk_hd[1],SEEK_CUR);
  394.                                 }
  395.                                 if (memgray)
  396.                                 { loadptr=memptr;
  397.                                         memset(&planes[0],0,4000);
  398.                                         if (iffheader.cmp) for (i=0;i<memheight;i++)
  399.                                         { t=0;
  400.                                                 while (t<iffheader.d*(memwidth<<3))
  401.                                                 { fread(&cnt,1,1,sdatei);
  402.                                                         if (cnt>128)
  403.                                                         { fread(&cval,1,1,sdatei);
  404.                                                                 for (i=0;i<(257-cnt);i++) planes[t++]=cval;
  405.                                                         }
  406.                                                         if (cnt<128)
  407.                                                         { fread(&planes[t],++cnt,1,sdatei);
  408.                                                                 t+=cnt;
  409.                                                         }
  410.                                                 }
  411.                                                 fplanegen(loadptr,&planes[0],&planes[memwidth>>3],
  412.                                                                                         &planes[2*(memwidth>>3)],&planes[3*(memwidth>>3)],(memwidth>>3));
  413.                                                 loadptr+=(memwidth>>1);
  414.                                         }
  415.                                         else for (i=0;i<memheight;i++)
  416.                                         { fread(&planes[0],iffheader.d*(memwidth>>3),1,sdatei);
  417.                                                 fplanegen(loadptr,&planes[0],&planes[memwidth>>3],
  418.                                                                                         &planes[2*(memwidth>>3)],&planes[3*(memwidth>>3)],(memwidth>>3));
  419.                                                 loadptr+=(memwidth>>1);
  420.                                         }
  421.                                 }
  422.                                 else
  423.                                 { if (iffheader.cmp)
  424.                                         { loadptr=memptr;
  425.                                                 while ((fread(&cnt,1,1,sdatei)))
  426.                                                 { if (cnt>128)
  427.                                                         { fread(&cval,1,1,sdatei);
  428.                                                                 for (i=0;i<(257-cnt);i++) *(loadptr++)=cval;
  429.                                                         }
  430.                                                         if (cnt<128)
  431.                                                         { fread(loadptr,++cnt,1,sdatei);
  432.                                                                 loadptr+=cnt;
  433.                                                         }
  434.                                                 }
  435.                                         }
  436.                                         else fread(memptr,(iffheader.w>>3)*iffheader.h,1,sdatei);
  437.                                 }
  438.                                 fclose(sdatei);
  439.                         }
  440.                 }
  441.         }
  442. }
  443.  
  444. void save(UWORD wx1,UWORD wy1,UWORD wx2,UWORD wy2,UBYTE cmp,UBYTE mf)
  445. { FILE *qdatei;
  446.         ULONG totlen,bmlen;
  447.         UWORD width,height,i,t;
  448.         ULONG startofs,cmplen;
  449.         UBYTE *saveptr;
  450.         UBYTE planes[4000];
  451.         UBYTE sf;
  452.         UBYTE dummy=0;
  453.  
  454.         if (filerequest("Speichere IFF File",str_filenam))
  455.         { sf=(memgray)?1:3;
  456.                 if (mf==2)
  457.                 { if (wx1>wx2) {t=wx2; wx2=wx1; wx1=t;}
  458.                         if (wy1>wy2) {t=wy2; wy2=wy1; wy1=t;}
  459.                         width=(wx2-wx1);
  460.                         height=(wy2-wy1);
  461.                         startofs=wy1*(memwidth>>sf)+(wx1>>sf);
  462.                 }
  463.                 else
  464.                 { width=memwidth;
  465.                         height=memheight;
  466.                         startofs=0;
  467.                 }
  468.                 width&=0xfff0;
  469.                 qdatei=fopen(str_filenam,"wb");
  470.                 bmlen=(memgray)?((width>>1)*height):((width>>3)*height);
  471.                 totlen=bmlen+40+((memgray)?56:14);
  472.                 iff_head[1]=totlen;
  473.                 iff_head[5]=(width<<16)|height;
  474.                 iff_head[7]=((memgray)?0x04000000:0x01000000)|((cmp)?0x0100:0);
  475.                 iff_body[1]=bmlen;
  476.                 fwrite(&iff_head[0],sizeof(iff_head),1,qdatei);
  477.                 if (memgray) fwrite(iff_cmap_gray,sizeof(iff_cmap_gray),1,qdatei);
  478.                 else fwrite(iff_cmap_bw,sizeof(iff_cmap_bw),1,qdatei);
  479.                 fwrite(iff_body,sizeof(iff_body),1,qdatei);
  480.                 saveptr=memptr+startofs;
  481.                 cmplen=0;
  482.                 if (memgray) for (i=0;i<height;i++)
  483.                 { fplanesep(saveptr,&planes[0],&planes[width>>3],&planes[2*(width>>3)],&planes[3*(width>>3)],(width>>3));
  484.                         if (cmp) cmplen+=cmpline(&planes[0],width>>1,4,qdatei);
  485.                         else fwrite(&planes[0],width>>1,1,qdatei);
  486.                         saveptr+=(ULONG)(memwidth>>1);
  487.                 }
  488.                 else for (i=0;i<height;i++)
  489.                 { if (cmp) cmplen+=cmpline(saveptr,width>>3,1,qdatei);
  490.                         else fwrite(saveptr,width>>3,1,qdatei);
  491.                         saveptr+=(ULONG)(memwidth>>3);
  492.                 }
  493.                 if (cmp)
  494.                 { if (cmplen&1) fwrite(&dummy,1,1,qdatei);
  495.                         fseek(qdatei,sizeof(iff_head)+((memgray)?(sizeof(iff_cmap_gray)):
  496.                                                 (sizeof(iff_cmap_bw)))+4,SEEK_SET);
  497.                         fwrite(&cmplen,4,1,qdatei);
  498.                         if (cmplen&1) cmplen++;
  499.                         fseek(qdatei,4,SEEK_SET);
  500.                         cmplen+=((memgray)?96:54);
  501.                         fwrite(&cmplen,4,1,qdatei);
  502.                 }
  503.                 fclose(qdatei);
  504.         }
  505. }
  506.  
  507. void view(UWORD x, UWORD y, UBYTE zoom)
  508. {
  509.         UBYTE *vptr;
  510.         UBYTE *plptr[4];
  511.         ULONG vinc;
  512.         ULONG vicr[13];
  513.         UWORD i,j,k,n1,n2,n3,n4,zeile,pwidth,bwidth,plins,blins;
  514.         UBYTE linebuf[2000];
  515.  
  516.         if (numcols==16)
  517.                 { for (i=0;i<4;i++) plptr[i]=(UBYTE *)(rp->BitMap->Planes[i]+viewoffset);
  518.                 }
  519.         else
  520.                 { for (i=0;i<2;i++) plptr[i]=(UBYTE *)(rp->BitMap->Planes[i]+viewoffset);
  521.                         plptr[2]=0; plptr[3]=0;
  522.                 }
  523.         vptr=(memgray)?
  524.                          (UBYTE*)(memptr+((((memwidth>>1)*y)+(x>>1)))):
  525.                          (UBYTE*)(memptr+((((memwidth>>3)*y)+(x>>3))));
  526.         vinc=((memgray)?(ULONG)(memwidth>>1):(ULONG)(memwidth>>3));
  527.         if ((zoom)&&(memheight>viewheight)&&(memwidth>viewwidth))
  528.         { if (((memheight/2)<viewheight)&&((memwidth/2)<viewwidth)) sk=2;
  529.                 else if (((memheight/4)<viewheight)&&((memwidth/4)<viewwidth)) sk=4;
  530.                 else if (((memheight/8)<viewheight)&&((memwidth/8)<viewwidth)) sk=8;
  531.                 else if (((memheight/12)<viewheight)&&((memwidth/12)<viewwidth)) sk=12;
  532.                 vptr=memptr;
  533.                 vicr[0]=0; vicr[1]=vinc;
  534.                 for (i=2;i<13;i++) vicr[i]=vicr[i-1]+vinc;
  535.                 if (numcols==16) clrscr16(plptr[0],plptr[1],plptr[2],plptr[3],viewheight,(screenwidth>>3)-2);
  536.                 else clrscr4(plptr[0],plptr[1],viewheight,(screenwidth>>3)-2);
  537.                 zeile=0; vx=vy=0;
  538.                 if (memgray)
  539.                 switch (sk)
  540.                 { case 2: while(zeile<memheight)
  541.                                                         { zeile+=2;
  542.                                                                 for (i=0;i<(memwidth>>1);i+=2)
  543.                                                                 { n1=n2=0; j=i;
  544.                                                                         for (k=0;k<2;k++)
  545.                                                                         { n1+=((*(vptr+j  )>>4)+(*(vptr+j  )&15));
  546.                                                                                 n2+=((*(vptr+j+1)>>4)+(*(vptr+j+1)&15));
  547.                                                                                 j+=vinc;
  548.                                                                         }
  549.                                                                         linebuf[i>>1]=((n1<<2)&0xf0)|(n2>>2);
  550.                                                                 }
  551.                                                                 if (numcols==16) vplanesep16(&linebuf[0],plptr[0],plptr[1],plptr[2],plptr[3],memwidth>>4);
  552.                                                                 else vplanesep4(&linebuf[0],plptr[0],plptr[1],memwidth>>4);
  553.                                                                 plptr[0]+=lineoffset; plptr[1]+=lineoffset; plptr[2]+=lineoffset; plptr[3]+=lineoffset;
  554.                                                                 vptr+=vicr[2];
  555.                                                         }
  556.                                                         break;
  557.                         case 4: while(zeile<memheight)
  558.                                                         { zeile+=4;
  559.                                                                 for (i=0;i<(memwidth>>1);i+=4)
  560.                                                                 { n1=n2=0; j=i;
  561.                                                                         for (k=0;k<4;k++)
  562.                                                                         { n1+=((*(vptr+j  )>>4)+(*(vptr+j  )&15)+(*(vptr+j+1)>>4)+(*(vptr+j+1)&15));
  563.                                                                                 n2+=((*(vptr+j+2)>>4)+(*(vptr+j+2)&15)+(*(vptr+j+3)>>4)+(*(vptr+j+3)&15));
  564.                                                                                 j+=vinc;
  565.                                                                         }
  566.                                                                         linebuf[i>>2]=(n1&0xf0)|(n2>>4);
  567.                                                                 }
  568.                                                                 if (numcols==16) vplanesep16(&linebuf[0],plptr[0],plptr[1],plptr[2],plptr[3],memwidth>>5);
  569.                                                                 else vplanesep4(&linebuf[0],plptr[0],plptr[1],memwidth>>5);
  570.                                                                 plptr[0]+=lineoffset; plptr[1]+=lineoffset; plptr[2]+=lineoffset; plptr[3]+=lineoffset;
  571.                                                                 vptr+=vicr[4];
  572.                                                         }
  573.                                                         break;
  574.                         case 8: while(zeile<memheight)
  575.                                                         { zeile+=8;
  576.                                                                 for (i=0;i<(memwidth>>1);i+=8)
  577.                                                                 { n1=n2=0; j=i;
  578.                                                                         for (k=0;k<8;k++)
  579.                                                                         { n1+=((*(vptr+j  )>>4)+(*(vptr+j  )&15)+(*(vptr+j+1)>>4)+(*(vptr+j+1)&15)
  580.                                                                                                 +(*(vptr+j+2)>>4)+(*(vptr+j+2)&15)+(*(vptr+j+3)>>4)+(*(vptr+j+3)&15));
  581.                                                                                 n2+=((*(vptr+j+4)>>4)+(*(vptr+j+4)&15)+(*(vptr+j+5)>>4)+(*(vptr+j+5)&15)
  582.                                                                                                 +(*(vptr+j+6)>>4)+(*(vptr+j+6)&15)+(*(vptr+j+7)>>4)+(*(vptr+j+7)&15));
  583.                                                                                 j+=vinc;
  584.                                                                         }
  585.                                                                         linebuf[i>>3]=((n1>>2)&0xf0)|((n2>>6)&0x0f);
  586.                                                                 }
  587.                                                                 if (numcols==16) vplanesep16(&linebuf[0],plptr[0],plptr[1],plptr[2],plptr[3],memwidth>>6);
  588.                                                                 else vplanesep4(&linebuf[0],plptr[0],plptr[1],memwidth>>6);
  589.                                                                 plptr[0]+=lineoffset; plptr[1]+=lineoffset; plptr[2]+=lineoffset; plptr[3]+=lineoffset;
  590.                                                                 vptr+=vicr[8];
  591.                                                         }
  592.                                                         break;
  593.                         case 12:while(zeile<memheight)
  594.                                                         { zeile+=12;
  595.                                                                 for (i=0;i<(memwidth>>1);i+=12)
  596.                                                                 { n1=n2=0; j=i;
  597.                                                                         for (k=0;k<12;k++)
  598.                                                                         { n1+=((*(vptr+j   )>>4)+(*(vptr+j   )&15)+(*(vptr+j+ 1)>>4)+(*(vptr+j+ 1)&15)
  599.                                                                                                 +(*(vptr+j+ 2)>>4)+(*(vptr+j+ 2)&15)+(*(vptr+j+ 3)>>4)+(*(vptr+j+ 3)&15)
  600.                                                                                                 +(*(vptr+j+ 4)>>4)+(*(vptr+j+ 4)&15)+(*(vptr+j+ 5)>>4)+(*(vptr+j+ 5)&15));
  601.                                                                                 n2+=((*(vptr+j+ 6)>>4)+(*(vptr+j+ 6)&15)+(*(vptr+j+ 7)>>4)+(*(vptr+j+ 7)&15)
  602.                                                                                                 +(*(vptr+j+ 8)>>4)+(*(vptr+j+ 8)&15)+(*(vptr+j+ 9)>>4)+(*(vptr+j+ 9)&15)
  603.                                                                                                 +(*(vptr+j+10)>>4)+(*(vptr+j+10)&15)+(*(vptr+j+11)>>4)+(*(vptr+j+11)&15));
  604.                                                                                 j+=vinc;
  605.                                                                         }
  606.                                                                         linebuf[i/12]=(((n1/144)<<4)&0xf0)|((n2/144)&0x0f);
  607.                                                                 }
  608.                                                                 if (numcols==16) vplanesep16(&linebuf[0],plptr[0],plptr[1],plptr[2],plptr[3],(memwidth>>5)/3);
  609.                                                                 else vplanesep4(&linebuf[0],plptr[0],plptr[1],(memwidth>>5)/3);
  610.                                                                 plptr[0]+=lineoffset; plptr[1]+=lineoffset; plptr[2]+=lineoffset; plptr[3]+=lineoffset;
  611.                                                                 vptr+=vicr[12];
  612.                                                         }
  613.                                                         break;
  614.                 }
  615.                 else
  616.                 switch (sk)
  617.                 { case 2: while(zeile<memheight)
  618.                                                         { zeile+=2;
  619.                                                                 for (i=0;i<(memwidth>>3);i++)
  620.                                                                 { n1=numbits[ (*(vptr+i        ))>>6   ]+numbits[ (*(vptr+i+vicr[1]))>>6   ];
  621.                                                                         if (n1==4) n1=3;
  622.                                                                         n2=numbits[((*(vptr+i        ))>>4)&3]+numbits[((*(vptr+i+vicr[1]))>>4)&3];
  623.                                                                         if (n2==4) n2=3;
  624.                                                                         n3=numbits[((*(vptr+i        ))>>2)&3]+numbits[((*(vptr+i+vicr[1]))>>2)&3];
  625.                                                                         if (n3==4) n3=3;
  626.                                                                         n4=numbits[ (*(vptr+i        ))    &3]+numbits[ (*(vptr+i+vicr[1]))    &3];
  627.                                                                         if (n4==4) n4=3;
  628.                                                                         linebuf[i<<1]=(~((n1<<6)|(n2<<2)));
  629.                                                                         linebuf[(i<<1)+1]=(~((n3<<6)|(n4<<2)));
  630.                                                                 }
  631.                                                                 if (numcols==16) vplanesep16(&linebuf[0],plptr[0],plptr[1],plptr[2],plptr[3],memwidth>>4);
  632.                                                                 else vplanesep4(&linebuf[0],plptr[0],plptr[1],memwidth>>4);
  633.                                                                 plptr[0]+=lineoffset; plptr[1]+=lineoffset; plptr[2]+=lineoffset; plptr[3]+=lineoffset;
  634.                                                                 vptr+=vicr[2];
  635.                                                         }
  636.                                                         break;
  637.                         case 4: while(zeile<memheight)
  638.                                                         { zeile+=4;
  639.                                                                 for (i=0;i<(memwidth>>3);i++)
  640.                                                                 { n1=numbits[(*(vptr+i        ))>>4]+numbits[(*(vptr+i+vicr[1]))>>4]
  641.                                                                                 +numbits[(*(vptr+i+vicr[2]))>>4]+numbits[(*(vptr+i+vicr[3]))>>4];
  642.                                                                         if (n1==16) n1=15;
  643.                                                                         n2=numbits[(*(vptr+i        ))&15]+numbits[(*(vptr+i+vicr[1]))&15]
  644.                                                                                 +numbits[(*(vptr+i+vicr[2]))&15]+numbits[(*(vptr+i+vicr[3]))&15];
  645.                                                                         if (n2==16) n2=15;
  646.                                                                         linebuf[i]=(~((n1<<4)|n2));
  647.                                                                 }
  648.                                                                 if (numcols==16) vplanesep16(&linebuf[0],plptr[0],plptr[1],plptr[2],plptr[3],memwidth>>5);
  649.                                                                 else vplanesep4(&linebuf[0],plptr[0],plptr[1],memwidth>>5);
  650.                                                                 plptr[0]+=lineoffset; plptr[1]+=lineoffset; plptr[2]+=lineoffset; plptr[3]+=lineoffset;
  651.                                                                 vptr+=vicr[4];
  652.                                                         }
  653.                                                         break;
  654.                         case 8: while(zeile<memheight)
  655.                                                         { zeile+=8;
  656.                                                                 for (i=0;i<(memwidth>>3);i+=2)
  657.                                                                 { n1=(numbits[(*(vptr+i        ))]
  658.                                                                                  +numbits[(*(vptr+i+vicr[1]))]
  659.                                                                                  +numbits[(*(vptr+i+vicr[2]))]
  660.                                                                                  +numbits[(*(vptr+i+vicr[3]))]
  661.                                                                                  +numbits[(*(vptr+i+vicr[4]))]
  662.                                                                                  +numbits[(*(vptr+i+vicr[5]))]
  663.                                                                                  +numbits[(*(vptr+i+vicr[6]))]
  664.                                                                                  +numbits[(*(vptr+i+vicr[7]))])>>2;
  665.                                                                         if (n1==16) n1=15;
  666.                                                                         n2=(numbits[(*(vptr+i+1        ))]
  667.                                                                                  +numbits[(*(vptr+i+1+vicr[1]))]
  668.                                                                                  +numbits[(*(vptr+i+1+vicr[2]))]
  669.                                                                                  +numbits[(*(vptr+i+1+vicr[3]))]
  670.                                                                                  +numbits[(*(vptr+i+1+vicr[4]))]
  671.                                                                                  +numbits[(*(vptr+i+1+vicr[5]))]
  672.                                                                                  +numbits[(*(vptr+i+1+vicr[6]))]
  673.                                                                                  +numbits[(*(vptr+i+1+vicr[7]))])>>2;
  674.                                                                         if (n2==16) n2=15;
  675.                                                                         linebuf[i>>1]=(~((n1<<4)|n2));
  676.                                                                 }
  677.                                                                 if (numcols==16) vplanesep16(&linebuf[0],plptr[0],plptr[1],plptr[2],plptr[3],memwidth>>6);
  678.                                                                 else vplanesep4(&linebuf[0],plptr[0],plptr[1],memwidth>>6);
  679.                                                                 plptr[0]+=lineoffset; plptr[1]+=lineoffset; plptr[2]+=lineoffset; plptr[3]+=lineoffset;
  680.                                                                 vptr+=vicr[8];
  681.                                                         }
  682.                                                         break;
  683.                         case 12:while(zeile<memheight)
  684.                                                         { zeile+=12;
  685.                                                                 for (i=0;i<(memwidth>>3);i+=3)
  686.                                                                 { n1=(numbits[(*(vptr+i           ))]
  687.                                                                                  +numbits[(*(vptr+i+  vicr[ 1]))]
  688.                                                                                  +numbits[(*(vptr+i+  vicr[ 2]))]
  689.                                                                                  +numbits[(*(vptr+i+  vicr[ 3]))]
  690.                                                                                  +numbits[(*(vptr+i+  vicr[ 4]))]
  691.                                                                                  +numbits[(*(vptr+i+  vicr[ 5]))]
  692.                                                                                  +numbits[(*(vptr+i+  vicr[ 6]))]
  693.                                                                                  +numbits[(*(vptr+i+  vicr[ 7]))]
  694.                                                                                  +numbits[(*(vptr+i+  vicr[ 8]))]
  695.                                                                                  +numbits[(*(vptr+i+  vicr[ 9]))]
  696.                                                                                  +numbits[(*(vptr+i+  vicr[10]))]
  697.                                                                                  +numbits[(*(vptr+i+  vicr[11]))]
  698.                                                                                  +numbits[(*(vptr+i+1         ))>>4]
  699.                                                                                  +numbits[(*(vptr+i+1+vicr[ 1]))>>4]
  700.                                                                                  +numbits[(*(vptr+i+1+vicr[ 2]))>>4]
  701.                                                                                  +numbits[(*(vptr+i+1+vicr[ 3]))>>4]
  702.                                                                                  +numbits[(*(vptr+i+1+vicr[ 4]))>>4]
  703.                                                                                  +numbits[(*(vptr+i+1+vicr[ 5]))>>4]
  704.                                                                                  +numbits[(*(vptr+i+1+vicr[ 6]))>>4]
  705.                                                                                  +numbits[(*(vptr+i+1+vicr[ 7]))>>4]
  706.                                                                                  +numbits[(*(vptr+i+1+vicr[ 8]))>>4]
  707.                                                                                  +numbits[(*(vptr+i+1+vicr[ 9]))>>4]
  708.                                                                                  +numbits[(*(vptr+i+1+vicr[10]))>>4]
  709.                                                                                  +numbits[(*(vptr+i+1+vicr[11]))>>4]);
  710.                                                                         n2=(numbits[(*(vptr+i+2         ))]
  711.                                                                                  +numbits[(*(vptr+i+2+vicr[ 1]))]
  712.                                                                                  +numbits[(*(vptr+i+2+vicr[ 2]))]
  713.                                                                                  +numbits[(*(vptr+i+2+vicr[ 3]))]
  714.                                                                                  +numbits[(*(vptr+i+2+vicr[ 4]))]
  715.                                                                                  +numbits[(*(vptr+i+2+vicr[ 5]))]
  716.                                                                                  +numbits[(*(vptr+i+2+vicr[ 6]))]
  717.                                                                                  +numbits[(*(vptr+i+2+vicr[ 7]))]
  718.                                                                                  +numbits[(*(vptr+i+2+vicr[ 8]))]
  719.                                                                                  +numbits[(*(vptr+i+2+vicr[ 9]))]
  720.                                                                                  +numbits[(*(vptr+i+2+vicr[10]))]
  721.                                                                                  +numbits[(*(vptr+i+2+vicr[11]))]
  722.                                                                                  +numbits[(*(vptr+i+1         ))&15]
  723.                                                                                  +numbits[(*(vptr+i+1+vicr[ 1]))&15]
  724.                                                                                  +numbits[(*(vptr+i+1+vicr[ 2]))&15]
  725.                                                                                  +numbits[(*(vptr+i+1+vicr[ 3]))&15]
  726.                                                                                  +numbits[(*(vptr+i+1+vicr[ 4]))&15]
  727.                                                                                  +numbits[(*(vptr+i+1+vicr[ 5]))&15]
  728.                                                                                  +numbits[(*(vptr+i+1+vicr[ 6]))&15]
  729.                                                                                  +numbits[(*(vptr+i+1+vicr[ 7]))&15]
  730.                                                                                  +numbits[(*(vptr+i+1+vicr[ 8]))&15]
  731.                                                                                  +numbits[(*(vptr+i+1+vicr[ 9]))&15]
  732.                                                                                  +numbits[(*(vptr+i+1+vicr[10]))&15]
  733.                                                                                  +numbits[(*(vptr+i+1+vicr[11]))&15]);
  734.                                                                         n1=n1/9;
  735.                                                                         n2=n2/9;
  736.                                                                         if (n1==16) n1=15;
  737.                                                                         if (n2==16) n2=15;
  738.                                                                         linebuf[i/3]=(~((n1<<4)|n2));
  739.                                                                 }
  740.                                                                 if (numcols==16) vplanesep16(&linebuf[0],plptr[0],plptr[1],plptr[2],plptr[3],(memwidth>>5)/3);
  741.                                                                 else vplanesep4(&linebuf[0],plptr[0],plptr[1],(memwidth>>5)/3);
  742.                                                                 plptr[0]+=lineoffset; plptr[1]+=lineoffset; plptr[2]+=lineoffset; plptr[3]+=lineoffset;
  743.                                                                 vptr+=vicr[12];
  744.                                                         }
  745.                                                         break;
  746.                 }
  747.         }
  748.         else
  749.         { vx=x&0xfff0; vy=y&0xfffe; sk=1;
  750.                 plins=viewheight; blins=0;
  751.                 if (plins>memheight)
  752.                 { plins=memheight;
  753.                         blins=viewheight-plins;
  754.                 }
  755.                 pwidth=(screenwidth>>3)-2; bwidth=0;
  756.                 if (pwidth>(memwidth>>3))
  757.                 { pwidth=(memwidth>>3)&0xfffe;
  758.                         bwidth=((screenwidth>>3)-2)-pwidth;
  759.                 }
  760.                 if (numcols==16)
  761.                 { if (memgray) grayview16(vptr,plptr[0],plptr[1],plptr[2],plptr[3],vinc,plins,blins,pwidth,bwidth);
  762.                         else bwview16(vptr,plptr[0],plptr[1],plptr[2],plptr[3],vinc,plins,blins,pwidth,bwidth);
  763.                 }
  764.                 else
  765.                 { if (memgray) grayview4(vptr,plptr[0],plptr[1],vinc,plins,blins,pwidth,bwidth);
  766.                         else bwview4(vptr,plptr[0],plptr[1],vinc,plins,blins,pwidth,bwidth);
  767.                 }
  768.         }
  769. }
  770.  
  771. UWORD s2px(UWORD x)
  772. { int t;
  773.  
  774.         t=x*sk+vx;
  775.         if (t>=memwidth) t=memwidth-1;
  776.         if (t<0) t=0;
  777.         return((UWORD)t);
  778. }
  779.  
  780. UWORD s2py(UWORD y)
  781. { int t;
  782.  
  783.         t=y*sk+vy;
  784.         if (t>=memheight) t=memheight-1;
  785.         if (t<0) t=0;
  786.         return((UWORD)t);
  787. }
  788.  
  789. UWORD p2sx(UWORD x)
  790. { int t;
  791.  
  792.         t=(x-vx)/sk;
  793.         if (t>viewwidth-1) t=viewwidth-1;
  794.         if (t<0) t=0;
  795.         return((UWORD)t);
  796. }
  797.  
  798. UWORD p2sy(UWORD y)
  799. { int t;
  800.  
  801.         t=(y-vy)/sk;
  802.         if (t>(viewheight-1)) t=viewheight-1;
  803.         if (t<0) t=0;
  804.         return((UWORD)t);
  805. }
  806.  
  807. void drawbox(UWORD wx1,UWORD wy1,UWORD wx2,UWORD wy2,struct RastPort *wrp)
  808. { UWORD sx1,sy1,sx2,sy2;
  809.  
  810.         sx1=p2sx(wx1); sy1=p2sy(wy1)+11;
  811.         sx2=p2sx(wx2); sy2=p2sy(wy2)+11;
  812.         SetWrMsk(wrp,8);
  813.         SetAPen(wrp,8);
  814.         SetDrMd(wrp,COMPLEMENT|JAM1);
  815.         SetDrPt(wrp,0xcccc);
  816.         Move(wrp,sx1,sy1);
  817.         Draw(wrp,sx1,sy2);
  818.         Draw(wrp,sx2,sy2);
  819.         Draw(wrp,sx2,sy1);
  820.         Draw(wrp,sx1,sy1);
  821.         SetWrMsk(wrp,1);
  822.         SetAPen(wrp,1);
  823.         SetDrMd(wrp,COMPLEMENT|JAM1);
  824.         SetDrPt(wrp,0x3333);
  825.         Move(wrp,sx1,sy1);
  826.         Draw(wrp,sx1,sy2);
  827.         Draw(wrp,sx2,sy2);
  828.         Draw(wrp,sx2,sy1);
  829.         Draw(wrp,sx1,sy1);
  830.         SetWrMsk(wrp,15);
  831. }
  832.  
  833. void cut(UWORD wx1,UWORD wy1,UWORD wx2,UWORD wy2,UBYTE mf)
  834. { UWORD width,height,x,y,t;
  835.         ULONG startofs;
  836.         UBYTE *picptr,*cpyptr;
  837.         UBYTE sf;
  838.  
  839.         sf=(memgray)?1:3;
  840. /*  if ((memwidth<=screenwidth)||(memheight<=screenheight)) MessReq("Bereich hat kleinste Gr÷▀e"); */
  841.         if (mf!=2) MessReq("Kein Bereich gewΣhlt!");
  842.         else
  843.         { if (wx1>wx2) {t=wx2; wx2=wx1; wx1=t;}
  844.                 if (wy1>wy2) {t=wy2; wy2=wy1; wy1=t;}
  845.                 width=(wx2-wx1);
  846.                 height=(wy2-wy1);
  847. /*
  848.                 if (height<screenheight)
  849.                 { height=screenheight;
  850.                         if ((wy1+height)>memheight) wy1=memheight-height;
  851.                 }
  852.                 if (width<screenwidth)
  853.                 { width=screenwidth;
  854.                         if ((wx1+width)>memwidth) wx1=memwidth-width;
  855.                 }
  856. */
  857.                 startofs=wy1*(memwidth>>sf)+(wx1>>sf);
  858.                 picptr=memptr;
  859.                 for (y=0;y<height;y++)
  860.                 { cpyptr=memptr+startofs;
  861.                         for(x=0;x<(width>>sf);x++) *(picptr++)=*(cpyptr++);
  862.                         startofs+=(ULONG)(memwidth>>sf);
  863.                 }
  864.                 mf=0;
  865.                 memwidth=width;
  866.                 memheight=height;
  867. /*    if (!(memptr=(UBYTE *)realloc(memptr,(memwidth*(memheight+ADDLIN))>>sf)))
  868.                 { memneed=0;
  869.                         MessReq((UBYTE *)"Kein Speicher");
  870.                 }
  871. */  }
  872. }
  873.