home *** CD-ROM | disk | FTP | other *** search
/ MACD 9 / MACD9.iso / Skanery / BetaScan / ScannerDev / MakeILBM.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-06-02  |  11.4 KB  |  451 lines
  1. /************************************************************************/
  2. /*                                                                      */
  3. /* Write image as ilbm                                                  */
  4. /*                                                                      */
  5. /*                                                                      */
  6. /*                                                                      */
  7. /*                                                                      */
  8. /************************************************************************/
  9.  
  10. #include <stdlib.h>
  11. #include <stdio.h>
  12. #include <string.h>
  13.  
  14. #include <exec/types.h>
  15. #include <datatypes/pictureclass.h>
  16.  
  17. #include "MakeILBM.h"
  18. #include "packer.h"
  19.  
  20. #define ID_XBMI MAKE_ID('X','B','M','I')
  21. #define ILBM_BUFLEN 1500000
  22.  
  23. struct ImageBuf
  24. {
  25.   UBYTE* buf;
  26.   ULONG  actualLen;
  27.   FILE*  fh;
  28. };
  29.  
  30. struct ILBMFile
  31. {
  32.   char* fileName;
  33.   int   formLenOffset;
  34.   int   bodyLenOffset;
  35.   UBYTE flags;
  36.   
  37.   UBYTE depth;
  38.   UWORD width;
  39.   UWORD height;
  40.   UWORD xdpi;
  41.   UWORD ydpi;
  42.  
  43.   ULONG scanLineWidth;
  44.   ULONG bufLen;
  45.   struct ImageBuf buf[3];
  46. };
  47.  
  48. #define ILBMFLAGS_COMPRESS  (0x01 << 0)
  49. #define ILBMFLAGS_TEMPFILE  (0x01 << 1)
  50.  
  51. struct xbmi
  52. {
  53.   WORD xbmi_type;   /* ILBM_PAL, ILBM_RGB, ... (se below) */
  54.   WORD xbmi_xdpi;
  55.   WORD xbmi_ydpi;
  56. };
  57.  
  58.  
  59. #define ILBM_PAL        0       /* BODY data = indexes into the palette (CMAP)
  60.                                  * numcolors = 1<<depth;
  61.                                  */
  62.  
  63. #define ILBM_GREY       1       /* BODY =  grayscale values
  64.                                  * Bits per sample = number of bitplanes.
  65.                                  * Samples per pixel = 1.
  66.                                  * black = 0, white = (1<<depth)-1;
  67.                                  */
  68.  
  69. #define ILBM_RGB        2       /* BODY data = red, green, and blue values.
  70.                                  * Bits per sample = depth/3.
  71.                                  * Samples per pixel = 3.
  72.                                  */
  73.  
  74. #define ILBM_RGBA       3       /* BODY data = red, green, blue, and alpha
  75.                                  * channel values.
  76.                                  * Bits per sample = depth/4.
  77.                                  * Samples per pixel = 4.
  78.                                  */
  79.  
  80. #define ILBM_CMYK       4       /* BODY data = cyan, magenta, yellow, and black
  81.                                  * values.
  82.                                  * Bits per sample = depth/4.
  83.                                  * Samples per pixel = 4.
  84.                                  */
  85.  
  86. #define ILBM_CMYKA      5       /* BODY data = cyan, magenta, yellow, black,
  87.                                  * and alpha channel values.
  88.                                  * Bits per sample = depth/5.
  89.                                  * Samples per pixel = 5.
  90.                                  */
  91.  
  92. #define ILBM_BW         6       /* BODY data = black and white bits.
  93.                                  * Bits per sample = 1.
  94.                                  * Samples per pixel = 1.
  95.                                  * white = 0, black = 1.
  96.                                  */
  97.  
  98. static char* tempfile[3] = {"temp.red","temp.green","temp.blue"};
  99.  
  100. static void makePlane(UBYTE* source,UBYTE* dest,int bit,int length)
  101. {
  102.   int   bitNum,byteNum;
  103.   UBYTE b,sourceMask;
  104.  
  105.   sourceMask = 0x01 << bit;
  106.   
  107.   for( byteNum = 0 ; byteNum < length ; byteNum++ )
  108.   {
  109.     UBYTE destMask;
  110.     
  111.     destMask = 0x80;
  112.     b = 0;
  113.     for( bitNum = 0 ; bitNum < 8 ; bitNum++ )
  114.     {
  115.       if( (*source) & sourceMask )
  116.         b |= destMask;
  117.  
  118.       destMask >>= 1;
  119.       source++;
  120.     }
  121.     *(dest++) = b;
  122.   }
  123. } 
  124.  
  125. static void makeILBM(struct ILBMFile* ilbmfh)
  126. {
  127.   struct BitMapHeader BMHD;
  128.   struct xbmi         XBMI;
  129.   FILE*  fh;
  130.   int    c;
  131.   
  132.   if( ilbmfh->flags & ILBMFLAGS_TEMPFILE )
  133.   {
  134.     for( c = 0 ; c < 3 ; c++ )
  135.     {
  136.       ilbmfh->buf[c].fh = fopen(tempfile[c],"r");
  137.       setvbuf(ilbmfh->buf[c].fh,ilbmfh->buf[c].buf,_IOFBF,ilbmfh->bufLen);
  138.     }
  139.   }
  140.   
  141.   BMHD.bmh_Width = ilbmfh->width;
  142.   BMHD.bmh_Height = ilbmfh->height;
  143.   BMHD.bmh_Left = 0;
  144.   BMHD.bmh_Top = 0;
  145.   BMHD.bmh_Depth = ilbmfh->depth;
  146.   BMHD.bmh_Masking = 0;
  147.   BMHD.bmh_Pad = 0;
  148.   BMHD.bmh_Transparent = 0;
  149.   BMHD.bmh_XAspect = 1;
  150.   BMHD.bmh_YAspect = 1;
  151.   BMHD.bmh_PageWidth = ilbmfh->width;
  152.   BMHD.bmh_PageHeight = ilbmfh->height;
  153.   
  154.   switch( ilbmfh->depth )
  155.   {
  156.     case 1:
  157.       XBMI.xbmi_type = ILBM_BW;
  158.       break;
  159.     case 8:
  160.       XBMI.xbmi_type = ILBM_GREY;
  161.       break;
  162.     case 24:
  163.       XBMI.xbmi_type = ILBM_RGB;
  164.       break;
  165.   }        
  166.   XBMI.xbmi_xdpi = ilbmfh->xdpi;
  167.   XBMI.xbmi_ydpi = ilbmfh->ydpi;
  168.  
  169.   if( fh = fopen(ilbmfh->fileName,"w") )
  170.   {
  171.     int scanLine,color,bitNum;
  172.     ULONG lineLen,bodyLen,formLen;
  173.     ULONG temp,psize;
  174.     UBYTE *line;
  175.     UBYTE *pline = NULL;
  176.     UBYTE *scanbuf = NULL;
  177.  
  178.     lineLen = ((ilbmfh->width+7)/8+1) & 0xFFFFFFFE;
  179.     line = malloc(lineLen);
  180.     if( (ilbmfh->flags & ILBMFLAGS_COMPRESS) && (pline = malloc(lineLen*2)) )
  181.       BMHD.bmh_Compression = 1;
  182.     else
  183.       BMHD.bmh_Compression = 0;
  184.       
  185.     temp = ID_FORM;
  186.     fwrite(&temp,4,1,fh);
  187.     ilbmfh->formLenOffset = ftell(fh);
  188.     temp = 0;
  189.     fwrite(&temp,4,1,fh);
  190.  
  191.     temp = ID_ILBM;
  192.     fwrite(&temp,4,1,fh);
  193.  
  194.     temp = ID_BMHD;
  195.     fwrite(&temp,4,1,fh);
  196.     temp = sizeof(struct BitMapHeader);
  197.     fwrite(&temp,4,1,fh);
  198.     fwrite(&BMHD,sizeof(struct BitMapHeader),1,fh);
  199.     
  200.     temp = ID_XBMI;
  201.     fwrite(&temp,4,1,fh);
  202.     temp = sizeof(struct xbmi);
  203.     
  204.     fwrite(&temp,4,1,fh);
  205.     fwrite(&XBMI,sizeof(struct xbmi),1,fh);
  206.  
  207.     if( ilbmfh->depth == 1 )
  208.     {
  209.       UBYTE b;
  210.       
  211.       temp = ID_CMAP;
  212.       fwrite(&temp,4,1,fh);
  213.       temp = 3*2;;
  214.       fwrite(&temp,4,1,fh);
  215.  
  216.       b = 0xFF;
  217.       fwrite(&b,1,1,fh);
  218.       fwrite(&b,1,1,fh);
  219.       fwrite(&b,1,1,fh);
  220.  
  221.       b = 0;
  222.       fwrite(&b,1,1,fh);
  223.       fwrite(&b,1,1,fh);
  224.       fwrite(&b,1,1,fh);
  225.     }
  226.     else if( ilbmfh->depth == 8 )
  227.     {
  228.       UBYTE b;
  229.       int   i;
  230.       
  231.       temp = ID_CMAP;
  232.       fwrite(&temp,4,1,fh);
  233.       temp = 3*256;;
  234.       fwrite(&temp,4,1,fh);
  235.       for( i = 0 ;  i < 256 ; i++ )
  236.       {
  237.         b = (UBYTE)i;
  238.         fwrite(&b,1,1,fh);
  239.         fwrite(&b,1,1,fh);
  240.         fwrite(&b,1,1,fh);
  241.       }
  242.     }
  243.     
  244.     temp = ID_BODY;
  245.     fwrite(&temp,4,1,fh);
  246.     ilbmfh->bodyLenOffset = ftell(fh);
  247.     temp = 0;
  248.     fwrite(&temp,4,1,fh);
  249.  
  250.     if( ilbmfh->flags & ILBMFLAGS_TEMPFILE )
  251.       scanbuf = malloc(ilbmfh->scanLineWidth);
  252.     
  253.     switch( ilbmfh->depth )
  254.     {
  255.       case 1:
  256.         for( scanLine = 0 ; scanLine < ilbmfh->height ; scanLine++ )
  257.         {
  258.           if( ilbmfh->flags & ILBMFLAGS_TEMPFILE )
  259.             fread(scanbuf,ilbmfh->scanLineWidth,1,ilbmfh->buf[0].fh);
  260.           else
  261.             scanbuf = ilbmfh->buf[0].buf + scanLine*ilbmfh->scanLineWidth;
  262.  
  263.           if( pline == NULL )
  264.             fwrite(scanbuf,lineLen,1,fh);
  265.           else
  266.           {
  267.             psize = PackRow(scanbuf,pline,lineLen);
  268.             fwrite(pline,psize,1,fh);
  269.           }
  270.         }
  271.         break;
  272.       case 8:
  273.         for( scanLine = 0 ; scanLine < ilbmfh->height ; scanLine++ )
  274.         {
  275.           if( ilbmfh->flags & ILBMFLAGS_TEMPFILE )
  276.             fread(scanbuf,ilbmfh->scanLineWidth,1,ilbmfh->buf[0].fh);
  277.           else
  278.             scanbuf = ilbmfh->buf[0].buf + scanLine*ilbmfh->scanLineWidth;
  279.           for( bitNum = 0 ; bitNum < 8 ; bitNum++ )
  280.           {
  281.             makePlane(scanbuf,line,bitNum,lineLen);
  282.             if( pline == NULL )
  283.               fwrite(line,lineLen,1,fh);
  284.             else
  285.             {
  286.               psize = PackRow(line,pline,lineLen);
  287.               fwrite(pline,psize,1,fh);
  288.             }
  289.           }
  290.         }
  291.         break;
  292.       case 24:
  293.         for( scanLine = 0 ; scanLine < ilbmfh->height ; scanLine++ )
  294.         {
  295.           for( color = 0 ; color < 3 ; color++ )
  296.           {
  297.             if( ilbmfh->buf[color].buf )
  298.             {
  299.               if( ilbmfh->flags & ILBMFLAGS_TEMPFILE )
  300.                 fread(scanbuf,ilbmfh->scanLineWidth,1,ilbmfh->buf[color].fh);
  301.               else
  302.                 scanbuf = ilbmfh->buf[color].buf + scanLine*ilbmfh->scanLineWidth;
  303.               for( bitNum = 0 ; bitNum < 8 ; bitNum++ )
  304.               {
  305.                 makePlane(scanbuf,line,bitNum,lineLen);
  306.                 if( pline == NULL )
  307.                   fwrite(line,lineLen,1,fh);
  308.                 else
  309.                 {
  310.                   psize = PackRow(line,pline,lineLen);
  311.                   fwrite(pline,psize,1,fh);
  312.                 }
  313.               }
  314.             }
  315.           }
  316.         }
  317.         break;
  318.     }        
  319.     free(line);
  320.     if( pline )
  321.       free(pline);
  322.     if( ilbmfh->flags & ILBMFLAGS_TEMPFILE )
  323.       free(scanbuf);
  324.  
  325.     for( color = 0 ; color < 3 ; color++ )
  326.     {
  327.       if( ilbmfh->buf[color].fh )
  328.         fclose(ilbmfh->buf[color].fh);
  329.       if( ilbmfh->buf[color].buf )
  330.         free(ilbmfh->buf[color].buf);
  331.     }
  332.  
  333.     // Write FORM and BODY length
  334.     formLen = ftell(fh) - ilbmfh->formLenOffset - 4;
  335.     bodyLen = ftell(fh) - ilbmfh->bodyLenOffset - 4;
  336.  
  337.     fseek(fh,ilbmfh->formLenOffset,SEEK_SET);
  338.     fwrite(&formLen,4,1,fh);
  339.  
  340.     fseek(fh,ilbmfh->bodyLenOffset,SEEK_SET);
  341.     fwrite(&bodyLen,4,1,fh);
  342.     
  343.     fclose(fh);
  344.   }
  345. }
  346.  
  347.  
  348. struct ILBMFile *openILBM(char* name,int width,int height,int depth,int xdpi,int ydpi,short compr)
  349. {
  350.   struct ILBMFile* fh;
  351.   
  352.   if( fh = calloc(1,sizeof(struct ILBMFile)) )
  353.   {
  354.     fh->fileName = name;
  355.     if( compr )
  356.       fh->flags = ILBMFLAGS_COMPRESS;
  357.     else
  358.       fh->flags = 0;
  359.     fh->depth = depth;
  360.     fh->width = width;
  361.     fh->height = height;
  362.     fh->xdpi = xdpi;
  363.     fh->ydpi = ydpi;
  364.  
  365.     switch( depth )
  366.     {
  367.       case 1:
  368.         fh->scanLineWidth = (width+7)/8;
  369.         fh->bufLen = fh->scanLineWidth*height;
  370.         if( fh->bufLen > ILBM_BUFLEN )
  371.           fh->bufLen = ILBM_BUFLEN;
  372.         fh->buf[0].buf = malloc(fh->bufLen);
  373.         break;
  374.       case 8:
  375.         fh->scanLineWidth = width;
  376.         fh->bufLen = fh->scanLineWidth*height;
  377.         if( fh->bufLen > ILBM_BUFLEN )
  378.           fh->bufLen = ILBM_BUFLEN;
  379.         fh->buf[0].buf = malloc(fh->bufLen);
  380.         break;
  381.       case 24:
  382.         {
  383.           int c;
  384.           
  385.         fh->scanLineWidth = width;
  386.         fh->bufLen = fh->scanLineWidth*height;
  387.           if( 3*fh->bufLen > ILBM_BUFLEN )
  388.             fh->bufLen = ILBM_BUFLEN/3;
  389.             
  390.           for( c = 0 ; c < 3 ; c++ )
  391.             fh->buf[c].buf = malloc(fh->bufLen);
  392.         }
  393.         break;
  394.       default:
  395.         free(fh);
  396.         return NULL;
  397.     }
  398.   }
  399.         
  400.   return fh;
  401. }
  402.  
  403. void closeILBM(struct ILBMFile* ilbmfh,short error)
  404. {
  405.   int    c;
  406.   
  407.   if( ilbmfh->flags & ILBMFLAGS_TEMPFILE )
  408.   {
  409.     for( c = 0 ; c < 3 ; c++ )
  410.     {
  411.       if( ilbmfh->buf[c].fh )
  412.       {
  413.         fwrite(ilbmfh->buf[c].buf,ilbmfh->buf[c].actualLen,1,ilbmfh->buf[c].fh);
  414.         fclose(ilbmfh->buf[c].fh);
  415.         ilbmfh->buf[c].fh = NULL;
  416.       }
  417.     }
  418.   }
  419.  
  420.   if( !error )
  421.     makeILBM(ilbmfh);
  422.  
  423.   if( ilbmfh->flags & ILBMFLAGS_TEMPFILE )
  424.   {
  425.     for( c = 0 ; c < 3 ; c++ )
  426.       remove(tempfile[c]);
  427.   }
  428.  
  429.   free(ilbmfh);
  430. }
  431.  
  432. void writeILBM(struct ILBMFile* fh,UBYTE* buf,int cPlane)
  433. {
  434.   if( fh->buf[cPlane].actualLen + fh->scanLineWidth > fh->bufLen )
  435.   {
  436.     if( fh->buf[cPlane].fh == NULL )
  437.     {
  438.       if( fh->buf[cPlane].fh = fopen(tempfile[cPlane],"w") )
  439.         fh->flags |= ILBMFLAGS_TEMPFILE;
  440.       else
  441.         return;
  442.     }
  443.           
  444.     fwrite(fh->buf[cPlane].buf,fh->buf[cPlane].actualLen,1,fh->buf[cPlane].fh);
  445.     fh->buf[cPlane].actualLen = 0;
  446.   }
  447.  
  448.   memcpy(fh->buf[cPlane].buf+fh->buf[cPlane].actualLen,buf,fh->scanLineWidth);
  449.   fh->buf[cPlane].actualLen += fh->scanLineWidth;
  450. }
  451.