开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 打印编程 > 查看源码
bmpf.cpp
资源名称：PopFaxPrinter_src_v2.01.zip　[点击查看]
上传用户：looem2003
上传日期：2014-07-20
资源大小：13733k
文件大小：26k
源码类别：

打印编程

开发平台：

Visual C++

bmpf.cpp：源码内容
  1. /*
  2.    Copyright (C) 2007    Ibadov Tariel   <itk@bk.ru>
  3. */
  5. #include <fstream.h>
  6. #include "bmpf.h"
  7. #include "tchar.h"
  9. static unsigned char bmpHeader[62]; 
  11. static unsigned char bmpHeader1[62] =
  12. {        'B',  'M', 0xBE, 0x48, 0x28, 0x00, 0x00, 0x00,
  13.         0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x28, 0x00,
  14.         0x00, 0x00, 0xA4, 0x01, 0x00, 0x00, 0x9D, 0x00,
  15.         0x00, 0x00, 0x01, 0x00, 0x18, 0x00, 0x00, 0x00,
  16.         0x00, 0x00, 0xBC, 0x04, 0x03, 0x00, 0x00, 0x00,
  17.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  18.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  19.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00
  20. };
  22. static unsigned char bmpHeader2[62] =
  23. {        'B',  'M', 0x3E, 0xF9, 0x15, 0x00, 0x00, 0x00,
  24.         0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x28, 0x00,
  25.         0x00, 0x00, 0xA4, 0x01, 0x00, 0x00, 0x9D, 0x00,
  26.         0x00, 0x00, 0x01, 0x00, 0x18, 0x00, 0x00, 0x00,
  27.         0x00, 0x00, 0xBC, 0x04, 0x03, 0x00, 0x00, 0x00,
  28.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  29.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  30.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00
  31. };
  34. //==========================================================================================
  35. //PDF
  36. //==========================================================================================
  39. static unsigned char pdfHeader[9] =
  40. {        '%',  'P', 'D', 'F', '-', '1', '.', '2',0x0a};
  43. int pdf_save( char *filename, BMPINFO *pbmpinfo )
  44. {
  45. std::string  namepdf; 
  46. namepdf=filename;
  47. namepdf +=".pdf";
  48.     ofstream ofPdf;
  49.     ofPdf.open((const char *)namepdf.c_str(), ios::out | ios::binary );
  50. //-----------
  51. ofPdf.write((const char *) pdfHeader, 9 );
  53. ofPdf.write("1 0 objn", 8 );
  54. ofPdf.write("<<n", 3 );
  55. ofPdf.write("/Type /Catalogn", 15 );
  56. ofPdf.write("/Pages 2 0 Rn", 13 );
  57. ofPdf.write("/OpenAction [3 0 R /XYZ -32768 -32768 1 ]n", 42 );
  58.     ofPdf.write(">>n", 3 );
  59. ofPdf.write("endobjn", 7 );
  61. ofPdf.write("2 0 objn", 8 );
  62. ofPdf.write("<<n", 3 );
  63. ofPdf.write("/Type /Pagesn", 13 );
  64. ofPdf.write("/Kids [ 3 0 R ]n", 16 );
  65. ofPdf.write("/Count 1n", 9 );
  66.     ofPdf.write(">>n", 3 );
  67. ofPdf.write("endobjn", 7 ); 
  69. ofPdf.write("3 0 objn", 8 );
  70. ofPdf.write("<<n", 3 );
  71. ofPdf.write("/Type /Pagen", 12 );
  72. ofPdf.write("/Parent 2 0 Rn", 14 );
  73. ofPdf.write("/Resourcesn", 11 );
  74.     ofPdf.write("<<n", 3 );
  75. ofPdf.write("/XObject << /Im0 4 0 R >>n", 26 );
  76. ofPdf.write("/ProcSet [ /PDF /ImageC ]n", 26 );
  77.     ofPdf.write(">>n", 3 );
  78. if (pbmpinfo->height==600)
  79. ofPdf.write("/MediaBox [ 0 0 800 600 ]n", 26 );
  80. else
  81. ofPdf.write("/MediaBox [ 0 0 800 1100 ]n", 27 );
  82. ofPdf.write("/Contents 5 0 Rn", 16 );
  83. ofPdf.write(">>n", 3 );
  84. ofPdf.write("endobjn", 7 ); 
  86. ofPdf.write("4 0 objn", 8 );
  87. ofPdf.write("<<n", 3 );
  88. ofPdf.write("/Type /XObjectn", 15 );
  89. ofPdf.write("/Subtype /Imagen", 16 );
  90. ofPdf.write("/Name /Im0n", 11 );
  91.     ofPdf.write("/Width 800n", 11 );
  93. if (pbmpinfo->height==600)
  94. ofPdf.write("/Height 600n", 12 );
  95. else
  96. ofPdf.write("/Height 1100n", 13 );
  98.     ofPdf.write("/BitsPerComponent 8n", 20 );
  99. ofPdf.write("/Filter []n", 11 );
  100. ofPdf.write("/ColorSpace /DeviceRGBn", 23 );
  102. if (pbmpinfo->height==600)
  103. ofPdf.write("/Length 1440000 >>n", 19 );
  104. else
  105. ofPdf.write("/Length 2640000 >>n", 19 );
  106. ofPdf.write("streamn", 7 );
  108. ///==============================================================
  109. ///==============================================================
  111. unsigned long w = pbmpinfo->width;
  112.         unsigned long h = pbmpinfo->height;
  113. int bpl2 = w * 3;
  114. //unsigned char *p = pbmpinfo->bits + (bpl2 * h);
  115. unsigned char *p = pbmpinfo->bits;
  117.         for( unsigned y = 0; y < h; y++ ) {
  118. p += bpl2;
  119. ofPdf.write( (const char *)p, bpl2 );
  120. }
  122. ///==============================================================
  123. ///==============================================================
  124.     
  125. ofPdf.write("endstreamn", 10 );
  126. ofPdf.write("endobjn", 7 );
  128. ofPdf.write("5 0 objn", 8 );
  129. ofPdf.write("<< /Length 32 >>n", 17 );
  130. ofPdf.write("streamn", 7 );
  132. ofPdf.write("qn", 2 );
  134. if (pbmpinfo->height==600)
  135. ofPdf.write("800 0 0 600 0 0 cmn", 19 );
  136. else
  137. ofPdf.write("800 0 0 1100 0 0 cmn", 20 );
  139. ofPdf.write("/Im0 Don", 8 );
  140. ofPdf.write("Qn", 2 );
  141.     
  143. ofPdf.write("endstreamn", 10 );
  144. ofPdf.write("endobjn", 7 );
  146.     ofPdf.write("xrefn", 5 );
  147. ofPdf.write("0 6n", 4 );
  148. ofPdf.write("0000000000 65535 fn", 19 );
  149. ofPdf.write("0000000009 00000 nn", 19 );
  150. ofPdf.write("0000000100 00000 nn", 19 );
  151. ofPdf.write("0000000159 00000 nn", 19 );
  152. ofPdf.write("0000000318 00000 nn", 19 );
  153. ofPdf.write("0002640492 00000 nn", 19 );     
  155. ofPdf.write("trailern", 8 );
  156. ofPdf.write("<<n", 3 );
  157. ofPdf.write("/Size 6n", 8 );
  158. ofPdf.write("/Root 1 0 Rn", 12 );
  159. ofPdf.write(">>n", 3 );
  160. ofPdf.write("startxrefn", 10 );
  161. ofPdf.write("2640573n", 8 );
  162. ofPdf.write("%%EOF", 5 );
  164. //-----------
  165. ofPdf.close();
  166.     return 0;
  167. }
  169. int bmp_save( char *filename, BMPINFO *pbmpinfo )
  170. {
  172.         if (pbmpinfo->height==600){
  173.              for(int i=0;i<62;i++)                       
  174.                 bmpHeader[i]=bmpHeader2[i];
  175.         }else {
  176.                for(int i=0;i<62;i++)                       
  177.                 bmpHeader[i]=bmpHeader1[i];
  178.         }       
  180.         int endy = pbmpinfo->height - 1;
  181. int bpl = pbmpinfo->width*3; 
  182.         ofstream ofBmp;
  183.         ofBmp.open( filename, ios::out | ios::binary );
  184.         
  185. unsigned long w = pbmpinfo->width;
  186.         unsigned long h = endy + 1;
  187.         
  188. ofBmp.write((const char *) bmpHeader, 18 );
  189.         
  190. ofBmp.put( char( w      & 0x000000FF) );
  191. ofBmp.put( char((w>> 8) & 0x000000FF) );
  192.         ofBmp.put( char((w>>16) & 0x000000FF) );
  193.         ofBmp.put( char((w>>24) & 0x000000FF) );
  195.         ofBmp.put( char( h      & 0x000000FF) );
  196.         ofBmp.put( char((h>> 8) & 0x000000FF) );
  197.         ofBmp.put( char((h>>16) & 0x000000FF) );
  198.         ofBmp.put( char((h>>24) & 0x000000FF) );
  200.         ofBmp.write((const char *) bmpHeader + 26, sizeof(bmpHeader) - 26 );
  202. unsigned char *p = pbmpinfo->bits + bpl * h;
  203. int bpl2 = w * 3;
  205.         for( unsigned y = 0; y < h; y++ ) {
  206. p -= bpl;
  207. ofBmp.write( (const char *)p, bpl2 );
  208. }
  209.         ofBmp.close();
  210.         return 0;
  211. }
  213. //================================================================
  214. //                          TIFF                                                                                                    
  215. //================================================================
  217. enum BMPType
  218. {
  219.     BMPT_WIN4,      /* BMP used in Windows 3.0/NT 3.51/95 */
  220.     BMPT_WIN5,      /* BMP used in Windows NT 4.0/98/Me/2000/XP */
  221.     BMPT_OS21,      /* BMP used in OS/2 PM 1.x */
  222.     BMPT_OS22       /* BMP used in OS/2 PM 2.x */
  223. };
  225. enum BMPComprMethod
  226. {
  227.     BMPC_RGB = 0L,          /* Uncompressed */
  228.     BMPC_RLE8 = 1L,         /* RLE for 8 bpp images */
  229.     BMPC_RLE4 = 2L,         /* RLE for 4 bpp images */
  230.     BMPC_BITFIELDS = 3L,    /* Bitmap is not compressed and the colour table
  231.      * consists of three DWORD color masks that specify
  232.      * the red, green, and blue components of each
  233.      * pixel. This is valid when used with
  234.      * 16- and 32-bpp bitmaps. */
  235.     BMPC_JPEG = 4L,         /* Indicates that the image is a JPEG image. */
  236.     BMPC_PNG = 5L           /* Indicates that the image is a PNG image. */
  237. };
  239. enum BMPLCSType                 /* Type of logical color space. */
  240. {
  241.     BMPLT_CALIBRATED_RGB = 0, /* This value indicates that endpoints and
  242.  * gamma values are given in the appropriate
  243.  * fields. */
  244.     BMPLT_DEVICE_RGB = 1,
  245.     BMPLT_DEVICE_CMYK = 2
  246. };
  248. typedef struct
  249. {
  250.     int32   iCIEX;
  251.     int32   iCIEY;
  252.     int32   iCIEZ;
  253. } BMPCIEXYZ;
  255. typedef struct                  /* This structure contains the x, y, and z */
  256. { /* coordinates of the three colors that */
  257. /* correspond */
  258.     BMPCIEXYZ   iCIERed;        /* to the red, green, and blue endpoints for */
  259.     BMPCIEXYZ   iCIEGreen;      /* a specified logical color space. */
  260.     BMPCIEXYZ iCIEBlue;
  261. } BMPCIEXYZTriple;
  263. typedef struct
  264. {
  265.     char bType[2];       /* Signature "BM" */
  266.     uint32 iSize;          /* Size in bytes of the bitmap file. Should
  267.  * always be ignored while reading because
  268.  * of error in Windows 3.0 SDK's description
  269.  * of this field */
  270.     uint16 iReserved1;     /* Reserved, set as 0 */
  271.     uint16 iReserved2;     /* Reserved, set as 0 */
  272.     uint32 iOffBits;       /* Offset of the image from file start in bytes */
  273. } BMPFileHeader;
  275. /* File header size in bytes: */
  276. const int       BFH_SIZE = 14;
  278. typedef struct
  279. {
  280.     uint32 iSize;          /* Size of BMPInfoHeader structure in bytes.
  281.  * Should be used to determine start of the
  282.  * colour table */
  283.     int32 iWidth;         /* Image width */
  284.     int32 iHeight;        /* Image height. If positive, image has bottom
  285.  * left origin, if negative --- top left. */
  286.     int16 iPlanes;        /* Number of image planes (must be set to 1) */
  287.     int16 iBitCount;      /* Number of bits per pixel (1, 4, 8, 16, 24
  288.  * or 32). If 0 then the number of bits per
  289.  * pixel is specified or is implied by the
  290.  * JPEG or PNG format. */
  291.     uint32 iCompression; /* Compression method */
  292.     uint32 iSizeImage;     /* Size of uncomressed image in bytes. May
  293.  * be 0 for BMPC_RGB bitmaps. If iCompression
  294.  * is BI_JPEG or BI_PNG, iSizeImage indicates
  295.  * the size of the JPEG or PNG image buffer. */
  296.     int32 iXPelsPerMeter; /* X resolution, pixels per meter (0 if not used) */
  297.     int32 iYPelsPerMeter; /* Y resolution, pixels per meter (0 if not used) */
  298.     uint32 iClrUsed;       /* Size of colour table. If 0, iBitCount should
  299.  * be used to calculate this value
  300.  * (1<<iBitCount). This value should be
  301.  * unsigned for proper shifting. */
  302.     int32 iClrImportant;  /* Number of important colours. If 0, all
  303.  * colours are required */
  305.     /*
  306.      * Fields above should be used for bitmaps, compatible with Windows NT 3.51
  307.      * and earlier. Windows 98/Me, Windows 2000/XP introduces additional fields:
  308.      */
  310.     int32 iRedMask;       /* Colour mask that specifies the red component
  311.  * of each pixel, valid only if iCompression
  312.  * is set to BI_BITFIELDS. */
  313.     int32 iGreenMask;     /* The same for green component */
  314.     int32 iBlueMask;      /* The same for blue component */
  315.     int32 iAlphaMask;     /* Colour mask that specifies the alpha
  316.  * component of each pixel. */
  317.     uint32 iCSType;        /* Colour space of the DIB. */
  318.     BMPCIEXYZTriple sEndpoints; /* This member is ignored unless the iCSType
  319.  * member specifies BMPLT_CALIBRATED_RGB. */
  320.     int32 iGammaRed;      /* Toned response curve for red. This member
  321.  * is ignored unless color values are
  322.  * calibrated RGB values and iCSType is set to
  323.  * BMPLT_CALIBRATED_RGB. Specified
  324.  * in 16^16 format. */
  325.     int32 iGammaGreen;    /* Toned response curve for green. */
  326.     int32 iGammaBlue;     /* Toned response curve for blue. */
  327. } BMPInfoHeader;
  329. /*
  330.  * Info header size in bytes:
  331.  */
  332. const unsigned int  BIH_WIN4SIZE = 40; /* for BMPT_WIN4 */
  333. const unsigned int  BIH_WIN5SIZE = 57; /* for BMPT_WIN5 */
  334. const unsigned int  BIH_OS21SIZE = 12; /* for BMPT_OS21 */
  335. const unsigned int  BIH_OS22SIZE = 64; /* for BMPT_OS22 */
  337. /*
  338.  * We will use plain byte array instead of this structure, but declaration
  339.  * provided for reference
  340.  */
  341. typedef struct
  342. {
  343.     char       bBlue;
  344.     char       bGreen;
  345.     char       bRed;
  346.     char       bReserved;      /* Must be 0 */
  347. } BMPColorEntry;
  349. static uint16 compression = (uint16) -1;
  350. static int jpegcolormode = JPEGCOLORMODE_RGB;
  351. static int quality = 75; /* JPEG quality */
  352. static uint16 predictor = 0;
  354. static void usage(void);
  355. static int processCompressOptions(char*);
  356. static void rearrangePixels(char *, uint32, uint32);
  358. int start_toTiff(char *NameBmp, char *NameTiff, uint16 _compression)
  359. {
  360.     std::string  nametiff; 
  361. nametiff=NameBmp;
  362. nametiff +=".tif";
  364. uint32 width, length;
  365. uint16 nbands = 1; /* number of bands in input image */
  366.     uint16 depth = 8; /* bits per pixel in input image */
  367. uint32 rowsperstrip = (uint32) -1;
  368.     uint16 photometric = PHOTOMETRIC_MINISBLACK;
  369. int fd;
  370. struct stat instat;
  371. char *outfilename = NULL, *infilename = NULL;
  372. TIFF *out = NULL;
  374. BMPFileHeader file_hdr;
  375.         BMPInfoHeader info_hdr;
  376.         int     bmp_type;
  377.         uint32  clr_tbl_size, n_clr_elems = 3;
  378.         unsigned char *clr_tbl;
  379. unsigned short *red_tbl = NULL, *green_tbl = NULL, *blue_tbl = NULL;
  380. uint32 row, clr;
  382. int c;
  383. extern int optind;
  384. extern char* optarg;
  385. predictor =2;
  386.     compression = _compression;
  388. infilename =NameBmp;
  389. fd = open(infilename, O_RDONLY|O_BINARY, 0);
  390. if (fd < 0) {
  391. return -1;
  392. }
  394. read(fd, file_hdr.bType, 2);
  395. if(file_hdr.bType[0] != 'B' || file_hdr.bType[1] != 'M') {
  396. goto bad;
  397. }
  399. /* -------------------------------------------------------------------- */
  400. /*      Read the BMPFileHeader. We need iOffBits value only             */
  401. /* -------------------------------------------------------------------- */
  403. lseek(fd, 10, SEEK_SET);
  404. read(fd, &file_hdr.iOffBits, 4);
  405. fstat(fd, &instat);
  406. file_hdr.iSize = instat.st_size;
  408. /* -------------------------------------------------------------------- */
  409. /*      Read the BMPInfoHeader.                                         */
  410. /* -------------------------------------------------------------------- */
  412.         lseek(fd, BFH_SIZE, SEEK_SET);
  413.         read(fd, &info_hdr.iSize, 4);
  415.         if (info_hdr.iSize == BIH_WIN4SIZE)
  416.                 bmp_type = BMPT_WIN4;
  417.         else if (info_hdr.iSize == BIH_OS21SIZE)
  418.                 bmp_type = BMPT_OS21;
  419.         else if (info_hdr.iSize == BIH_OS22SIZE || info_hdr.iSize == 16)
  420.                 bmp_type = BMPT_OS22;
  421.         else
  422.                 bmp_type = BMPT_WIN5;
  424.         if (bmp_type == BMPT_WIN4 || bmp_type == BMPT_WIN5 || bmp_type == BMPT_OS22) {
  425.                 read(fd, &info_hdr.iWidth, 4);
  426.                 read(fd, &info_hdr.iHeight, 4);
  427.                 read(fd, &info_hdr.iPlanes, 2);
  428.                 read(fd, &info_hdr.iBitCount, 2);
  429.                 read(fd, &info_hdr.iCompression, 4);
  430.                 read(fd, &info_hdr.iSizeImage, 4);
  431.                 read(fd, &info_hdr.iXPelsPerMeter, 4);
  432.                 read(fd, &info_hdr.iYPelsPerMeter, 4);
  433.                 read(fd, &info_hdr.iClrUsed, 4);
  434.                 read(fd, &info_hdr.iClrImportant, 4);
  435.                 n_clr_elems = 4;
  436.         }
  438.         if (info_hdr.iBitCount != 1  && info_hdr.iBitCount != 4  &&
  439.             info_hdr.iBitCount != 8  && info_hdr.iBitCount != 16 &&
  440.             info_hdr.iBitCount != 24 && info_hdr.iBitCount != 32) {
  441.             close(fd);
  442.             return 0;
  443.         }
  444.         width = info_hdr.iWidth;
  445.         length = (info_hdr.iHeight > 0) ? info_hdr.iHeight : -info_hdr.iHeight;
  447. switch (info_hdr.iBitCount)
  448.         {
  449.                 case 1:
  450.                 case 4:
  451.                 case 8:
  452.                         nbands = 1;
  453. depth = info_hdr.iBitCount;
  454.                         photometric = PHOTOMETRIC_PALETTE;
  455.                         /* Allocate memory for colour table and read it. */
  456.                         if (info_hdr.iClrUsed)
  457.                             clr_tbl_size = ((uint32)(1 << depth) < info_hdr.iClrUsed) ?
  458.     (uint32) (1 << depth) : info_hdr.iClrUsed;
  459.                         else
  460.                             clr_tbl_size = 1 << depth;
  461.                         clr_tbl = (unsigned char *)
  462. _TIFFmalloc(n_clr_elems * clr_tbl_size);
  463. if (!clr_tbl) {
  464. goto bad;
  465. }
  467. lseek(fd, BFH_SIZE + info_hdr.iSize, SEEK_SET);
  468.                         read(fd, clr_tbl, n_clr_elems * clr_tbl_size);
  470. red_tbl = (unsigned short*)
  471. _TIFFmalloc(1<<depth * sizeof(unsigned short));
  472. if (!red_tbl) {
  473. goto bad1;
  474. }
  475. green_tbl = (unsigned short*)
  476. _TIFFmalloc(1<<depth * sizeof(unsigned short));
  477. if (!green_tbl) {
  478. goto bad2;
  479. }
  480. blue_tbl = (unsigned short*)
  481. _TIFFmalloc(1<<depth * sizeof(unsigned short));
  482. if (!blue_tbl) {
  483. goto bad3;
  484. }
  486.                         for(clr = 0; clr < clr_tbl_size; clr++) {
  487.                             red_tbl[clr] = 257 * clr_tbl[clr*n_clr_elems+2];
  488.                             green_tbl[clr] = 257 * clr_tbl[clr*n_clr_elems+1];
  489.                             blue_tbl[clr] = 257 * clr_tbl[clr*n_clr_elems];
  490.                         }
  492.                         _TIFFfree(clr_tbl);
  493.                         break;
  494.                 case 16:
  495.                 case 24:
  496.                         nbands = 3;
  497. depth = info_hdr.iBitCount / nbands;
  498.                         photometric = PHOTOMETRIC_RGB;
  499.                         break;
  500.                 case 32:
  501.                         nbands = 3;
  502. depth = 8;
  503.                         photometric = PHOTOMETRIC_RGB;
  504.                         break;
  505.                 default:
  506.                         break;
  507.         }
  509. /* -------------------------------------------------------------------- */
  510. /*  Create output file.                                                 */
  511. /* -------------------------------------------------------------------- */
  514. if (outfilename == NULL)
  515. outfilename =  (char *)nametiff.c_str();
  516. out = TIFFOpen(outfilename, "w");
  517. if (out == NULL) {
  518. goto bad3;
  519. }
  521. TIFFSetField(out, TIFFTAG_IMAGEWIDTH, width);
  522. TIFFSetField(out, TIFFTAG_IMAGELENGTH, length);
  523. TIFFSetField(out, TIFFTAG_SAMPLESPERPIXEL, nbands);
  524. TIFFSetField(out, TIFFTAG_BITSPERSAMPLE, depth);
  525. TIFFSetField(out, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
  527.     switch( compression )
  528.     {
  529.     case COMPRESSION_CCITTFAX3:
  530.          {
  531.   TIFFSetField(out, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
  532.           TIFFSetField(out, TIFFTAG_SUBFILETYPE, 0); 
  533.           TIFFSetField(out, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISWHITE);          
  534.           TIFFSetField(out, TIFFTAG_ROWSPERSTRIP, TIFFDefaultStripSize(out, rowsperstrip));
  535.           TIFFSetField(out, TIFFTAG_COMPRESSION, compression);
  536.   TIFFSetField(out, TIFFTAG_GROUP3OPTIONS, GROUP3OPT_2DENCODING|GROUP3OPT_FILLBITS);
  537.   TIFFSetField(out, TIFFTAG_FAXMODE, FAXMODE_CLASSIC/* generate "classic" g3 format */);
  538.           TIFFSetField( out, TIFFTAG_FILLORDER, FILLORDER_LSB2MSB);
  539.           TIFFSetField(out, TIFFTAG_RESOLUTIONUNIT, RESUNIT_INCH);
  540.           TIFFSetField(out, TIFFTAG_XRESOLUTION, 204.0);
  541.           TIFFSetField(out, TIFFTAG_YRESOLUTION, 196.0);          
  542.          }break;
  543.     case COMPRESSION_CCITTFAX4:
  544.          {
  545. TIFFSetField(out, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
  546.           TIFFSetField(out, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISWHITE);
  547.           TIFFSetField(out, TIFFTAG_ROWSPERSTRIP, TIFFDefaultStripSize(out, rowsperstrip));
  548.       TIFFSetField(out, TIFFTAG_COMPRESSION, compression);
  549.           TIFFSetField(out, TIFFTAG_SUBFILETYPE, 0);
  550.       TIFFSetField(out, TIFFTAG_GROUP4OPTIONS, 0);
  551.       TIFFSetField(out, TIFFTAG_FAXMODE, FAXMODE_CLASSF);
  552.       TIFFSetField(out, TIFFTAG_FILLORDER, FILLORDER_MSB2LSB);
  553.           TIFFSetField(out, TIFFTAG_RESOLUTIONUNIT, RESUNIT_INCH);
  554.           TIFFSetField(out, TIFFTAG_XRESOLUTION, 1.0);
  555.           TIFFSetField(out, TIFFTAG_YRESOLUTION, 1.0);
  556.           break;
  557.           }
  558.     default:
  559.     {
  560. TIFFSetField(out, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
  561. TIFFSetField(out, TIFFTAG_PHOTOMETRIC, photometric);
  562.         TIFFSetField(out, TIFFTAG_ROWSPERSTRIP, TIFFDefaultStripSize(out, rowsperstrip));
  564.         if (red_tbl && green_tbl && blue_tbl)
  565.    TIFFSetField(out, TIFFTAG_COLORMAP, red_tbl, green_tbl, blue_tbl);
  567.        if (compression == (uint16) -1)
  568.    compression = COMPRESSION_PACKBITS;
  569.     TIFFSetField(out, TIFFTAG_COMPRESSION, compression);
  570.     switch (compression) {
  571.         case COMPRESSION_JPEG:
  572. if (photometric == PHOTOMETRIC_RGB
  573.     && jpegcolormode == JPEGCOLORMODE_RGB)
  574. photometric = PHOTOMETRIC_YCBCR;
  575. TIFFSetField(out, TIFFTAG_JPEGQUALITY, quality);
  576. TIFFSetField(out, TIFFTAG_JPEGCOLORMODE, jpegcolormode);
  577. break;
  578.     case COMPRESSION_LZW:
  579.         case COMPRESSION_DEFLATE:
  580. if (predictor != 0)
  581. TIFFSetField(out, TIFFTAG_PREDICTOR, predictor);
  582. break;
  583. }
  584.     }
  585.     }
  586. /* -------------------------------------------------------------------- */
  587. /*  Read uncompressed image data.                                       */
  588. /* -------------------------------------------------------------------- */
  590.         if (info_hdr.iCompression == BMPC_RGB) {
  591.                 uint32 offset, size;
  592.                 char *scanbuf;
  594. /* XXX: Avoid integer overflow. We can calculate size in one
  595.  * step using
  596.  *
  597.  *   size = ((width * info_hdr.iBitCount + 31) & ~31) / 8
  598.  *
  599.  * formulae, but we should check for overflow conditions
  600.  * during calculation.
  601.  */
  602. size = width * info_hdr.iBitCount + 31;
  603. if (!width || !info_hdr.iBitCount
  604.     || (size - 31) / info_hdr.iBitCount != width ) {
  605. goto bad3;
  606. }
  607.                 size = (size & ~31) / 8;
  609.                 scanbuf = (char *) _TIFFmalloc(size);
  610. if (!scanbuf) {
  611. goto bad3;
  612. }
  614.                 for (row = 0; row < length; row++) {
  615.                         if (info_hdr.iHeight > 0)
  616.                                 offset = file_hdr.iOffBits + (length - row - 1) * size;
  617.                         else
  618.                                 offset = file_hdr.iOffBits + row * size;
  619.                         if (lseek(fd, offset, SEEK_SET) == (off_t)-1) {
  620. break;
  621.                         }
  623. if (read(fd, scanbuf, size) < 0) {
  624. break;
  625.                         }
  627.                         rearrangePixels(scanbuf, width, info_hdr.iBitCount);
  629.                         if (TIFFWriteScanline(out, scanbuf, row, 0) < 0) {
  630. break;
  631.                         }
  632.                 }
  634.                 _TIFFfree(scanbuf);
  636. /* -------------------------------------------------------------------- */
  637. /*  Read compressed image data.                                         */
  638. /* -------------------------------------------------------------------- */
  640.         } else if ( info_hdr.iCompression == BMPC_RLE8
  641.     || info_hdr.iCompression == BMPC_RLE4 ) {
  642. uint32 i, j, k, runlength;
  643. uint32 compr_size, uncompr_size;
  644. unsigned char   *comprbuf;
  645. unsigned char   *uncomprbuf;
  647. compr_size = file_hdr.iSize - file_hdr.iOffBits;
  648. uncompr_size = width * length;
  649. comprbuf = (unsigned char *) _TIFFmalloc( compr_size );
  650. if (!comprbuf) {
  651. goto bad3;
  652. }
  653. uncomprbuf = (unsigned char *) _TIFFmalloc( uncompr_size );
  654. if (!uncomprbuf) {
  655. goto bad3;
  656. }
  658. lseek(fd, file_hdr.iOffBits, SEEK_SET);
  659. read(fd, comprbuf, compr_size);
  660. i = 0;
  661. j = 0;
  662. if (info_hdr.iBitCount == 8) {     /* RLE8 */
  663.     while( j < uncompr_size && i < compr_size ) {
  664. if ( comprbuf[i] ) {
  665.     runlength = comprbuf[i++];
  666.     while( runlength > 0
  667.    && j < uncompr_size
  668.    && i < compr_size ) {
  669. uncomprbuf[j++] = comprbuf[i];
  670. runlength--;
  671.     }
  672.     i++;
  673. } else {
  674.     i++;
  675.     if ( comprbuf[i] == 0 )         /* Next scanline */
  676. i++;
  677.     else if ( comprbuf[i] == 1 )    /* End of image */
  678. break;
  679.     else if ( comprbuf[i] == 2 ) {  /* Move to... */
  680. i++;
  681. if ( i < compr_size - 1 ) {
  682.     j += comprbuf[i] + comprbuf[i+1] * width;
  683.     i += 2;
  684. }
  685. else
  686.     break;
  687.     } else {                         /* Absolute mode */
  688. runlength = comprbuf[i++];
  689. for ( k = 0; k < runlength && j < uncompr_size && i < compr_size; k++ )
  690.     uncomprbuf[j++] = comprbuf[i++];
  691. if ( k & 0x01 )
  692.     i++;
  693.     }
  694. }
  695.     }
  696. }
  697. else {     /* RLE4 */
  698.     while( j < uncompr_size && i < compr_size ) {
  699. if ( comprbuf[i] ) {
  700.     runlength = comprbuf[i++];
  701.     while( runlength > 0 && j < uncompr_size && i < compr_size ) {
  702. if ( runlength & 0x01 )
  703.     uncomprbuf[j++] = (comprbuf[i] & 0xF0) >> 4;
  704. else
  705.     uncomprbuf[j++] = comprbuf[i] & 0x0F;
  706. runlength--;
  707.     }
  708.     i++;
  709. } else {
  710.     i++;
  711.     if ( comprbuf[i] == 0 )         /* Next scanline */
  712. i++;
  713.     else if ( comprbuf[i] == 1 )    /* End of image */
  714. break;
  715.     else if ( comprbuf[i] == 2 ) {  /* Move to... */
  716. i++;
  717. if ( i < compr_size - 1 ) {
  718.     j += comprbuf[i] + comprbuf[i+1] * width;
  719.     i += 2;
  720. }
  721. else
  722.     break;
  723.     } else {                        /* Absolute mode */
  724. runlength = comprbuf[i++];
  725. for ( k = 0; k < runlength && j < uncompr_size && i < compr_size; k++) {
  726.     if ( k & 0x01 )
  727. uncomprbuf[j++] = comprbuf[i++] & 0x0F;
  728.     else
  729. uncomprbuf[j++] = (comprbuf[i] & 0xF0) >> 4;
  730. }
  731. if ( k & 0x01 )
  732.     i++;
  733.     }
  734. }
  735.     }
  736. }
  738. _TIFFfree(comprbuf);
  740. for (row = 0; row < length; row++) {
  741.                         if (TIFFWriteScanline(out, uncomprbuf + (length - row - 1) * width, row, 0) < 0) 
  742.                         {}
  743. }
  745. _TIFFfree(uncomprbuf);
  746. }
  748. bad3:
  749. if (blue_tbl)
  750. _TIFFfree(blue_tbl);
  751. bad2:
  752. if (green_tbl)
  753. _TIFFfree(green_tbl);
  754. bad1:
  755. if (red_tbl)
  756. _TIFFfree(red_tbl);
  757. bad:
  758.         close(fd);
  760. if (out)
  761. TIFFClose(out);
  762.         return 0;
  763. }
  765. /*
  766.  * Image data in BMP file stored in BGR (or ABGR) format. We should rearrange
  767.  * pixels to RGB (RGBA) format.
  768.  */
  770. static void
  771. rearrangePixels(char *buf, uint32 width, uint32 bit_count)
  772. {
  773. char tmp;
  774. uint32 i;
  776.         switch(bit_count) {
  777. case 16:    /* FIXME: need a sample file */
  778.                         break;
  779.                 case 24:
  780. for (i = 0; i < width; i++, buf += 3) {
  781. tmp = *buf;
  782. *buf = *(buf + 2);
  783. *(buf + 2) = tmp;
  784. }
  785.                         break;
  786.                 case 32:
  787. {
  788. char *buf1 = buf;
  790. for (i = 0; i < width; i++, buf += 4) {
  791. tmp = *buf;
  792. *buf1++ = *(buf + 2);
  793. *buf1++ = *(buf + 1);
  794. *buf1++ = tmp;
  795. }
  796. }
  797.                         break;
  798.                 default:
  799.                         break;
  800.         }
  801. }