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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 传真(Fax)编程 > 查看源码
dibtiff.cpp
资源名称：GTIFFSample.zip　[点击查看]
上传用户：lbr_007
上传日期：2019-05-31
资源大小：282k
文件大小：18k
源码类别：

传真(Fax)编程

开发平台：

Visual C++

dibtiff.cpp：源码内容
  1. // dibtif.cpp
  2. //
  4. #include "stdafx.h"
  5. #include "dibtiff.h"
  6. #include <math.h>
  9. #include "tiffio.h"
  10. #include "geotiffio.h"
  11. #include "geo_normalize.h"
  12. #include "geo_tiffp.h"
  13. //#include "geoproj.h"
  15. #include <string>
  16. #include <UtilProcess.h>
  17. #include <UtilityParser.h>
  18. #include <StringUtil.h>
  20. using namespace std;
  22. extern char * GetInitialFolder(void);
  24. #define ROUND(x)    (u_short) ((x) + 0.5)
  25. #define TIFF_GAMMA  2.2
  27. void ConvertToPDF(const char * tiffName, const char * pdfName)
  28. {
  29. const char * args[4];
  30. args[0] = "tiff2pdf";
  31. args[1] = "-o";
  32. args[2] = pdfName;
  33. args[3] = tiffName;
  35. string cmd = "tiff2pdf -o ";
  36. cmd += pdfName;
  37. cmd += " ";
  38. cmd += tiffName;
  40. //system(cmd.c_str());
  41. UtilProcess p;
  42. p.CreateProcess("tiff2pdf.exe", cmd.c_str(), false);
  43. }
  45. int ReadTIFFDirectories(const char * filename, ArrayContainer<TIFFSubImage>& images)
  46. {
  47. int result = 0;
  49. TIFF * tiff = TIFFOpen((char *)filename,"r");
  50. if (tiff)
  51. {
  52. int m_num_items = TIFFNumberOfDirectories(tiff);
  53. if (m_num_items > 0)
  54. {
  55. for (int i=0;i<m_num_items;i++){
  56. tdir_t d = (tdir_t)i;
  57. TIFFSetDirectory(tiff,d);
  59. int w=0, h=0;
  60. int bpp = 0;
  61. char name[256];
  63. memset(name,0,(size_t)256);
  64. sprintf(name,"image%d",i);
  66.   // 2)
  67.   // Get the width and height of the image
  68. TIFFGetField(tiff,TIFFTAG_IMAGEWIDTH, &w);
  69. TIFFGetField(tiff,TIFFTAG_IMAGELENGTH, &h);
  70. TIFFGetField(tiff, TIFFTAG_BITSPERSAMPLE, &bpp);
  72. TIFFSubImage ti(w,h,i,bpp,name);
  73. if (ti.IsCreated())
  74. {
  75. images.AddElement(ti);
  76. result++;
  77. }
  78. }
  79. }
  81. TIFFClose(tiff);
  82. }
  84. return result;
  85. }
  87. void RGBA_to_BGRA(BYTE* data,int width,int height)
  88. {
  89.   int   i;
  90.   int   j;
  91.   int   line_width;
  92.   BYTE  r, g, b, a;
  93.   BYTE* ptr;
  95.   ptr = data;
  96.   line_width = width * 4;
  98.   for(i = 0; i < height; i++)
  99.   {
  100.     ptr = data + line_width*i;
  101.     for(j = 0; j < width; j++)
  102.     {
  103.       r = ptr[0];
  104.       g = ptr[1];
  105.       b = ptr[2];
  106.       a = ptr[3];
  107.       ptr[2] = (BYTE)( (r*a+1) >> 8 );
  108.       ptr[1] = (BYTE)( (g*a+1) >> 8 );
  109.       ptr[0] = (BYTE)( (b*a+1) >> 8 );
  110.       ptr += 4;
  111.     }
  112.   }
  114.   return;
  115. }
  117. void BGRA_to_RGBA(BYTE* data,int width,int height, int pad)
  118. {
  119.   int   i;
  120.   int   j;
  121.   int   line_width;
  122.   BYTE  r, g, b, a;
  123.   BYTE* ptr;
  125.   ptr = data;
  126.   line_width = width * 4;
  128.   for(i = 0; i < height; i++)
  129.   {
  130.     ptr = data + line_width*i;
  131.     for(j = 0; j < width; j++)
  132.     {
  133.       b = ptr[0];
  134.       g = ptr[1];
  135.       r = ptr[2];
  136.       a = ptr[3];
  137.       ptr[0] = r;
  138.       ptr[1] = g;
  139.       ptr[2] = b;
  140.       ptr += 4;
  141.     }
  142.   }
  144.   return;
  145. }
  147. int OpenTIFF2DIB(const char * filename, DIBSection& dib, int directory)
  148. {
  149. int result = 0;
  151. TIFF * tiff = TIFFOpen((char *)filename,"r");
  152. if (tiff)
  153. {
  154. int w=0, h=0;
  156. tdir_t d = (tdir_t)directory;
  157. TIFFSetDirectory(tiff,d);
  159. TIFFGetField(tiff,TIFFTAG_IMAGEWIDTH, &w);
  160. TIFFGetField(tiff,TIFFTAG_IMAGELENGTH, &h);
  162. if ((w > 0) && (h > 0))
  163. {
  164. UINT32 * raster = new UINT32[(w*h)];
  165. if (raster)
  166. {
  167. dib.Create(w,h,24);
  168. UINT32 tw = dib.GetTotalWidth();
  170. if (TIFFReadRGBAImage(tiff, w, h, (unsigned long *)raster, 0))
  171. {
  172. RGBA_to_BGRA((BYTE *)raster,w,h);
  174. unsigned char * dest = (unsigned char *)dib.GetBits();
  175. unsigned char * src = (unsigned char *)raster;
  177. unsigned char * ptr_dest;
  178. unsigned char * ptr_src;
  180. int row, col;
  182. for (row=0; row < h; row++){
  183. ptr_dest = dest + row * tw * 3;
  184. ptr_src = src + row * w * 4;
  186. for (col=0; col < w; col++){
  187. memcpy(ptr_dest,ptr_src,3);
  188. ptr_dest += 3;
  189. ptr_src += 4;
  190. }
  191. }
  193. result++;
  194. }
  196. delete [] raster;
  197. }
  198. }
  200. TIFFClose(tiff);
  202. GEORef gr;
  203. if (ReadGeoInfo(filename,gr))
  204. {
  205. gr.m_rows = h;
  206. gr.m_cols = w;
  207. dib.SetGeoReference(gr);
  208. }
  209. }
  211. return result;
  212. }
  214. bool ReadGeoInfo(const char * filename, GEORef& gr)
  215. {
  216. bool result = false;
  218. TIFF * tiff = 0;
  219. GTIF * gtif = 0;
  221. tiff = XTIFFOpen(filename,"r");
  222. if (tiff)
  223. {
  224. gtif = GTIFNew(tiff);
  225. if (gtif)
  226. {
  227. const int key_size = 2048;
  228. char key_data[key_size];
  229. memset(key_data,0,(size_t)key_size);
  230. tagtype_t cit_type;
  231. int cit_size;
  232. INT32 ellps = 1;
  234. string geoCitationKey;
  236. double * d_list = 0;
  237. int d_list_count = 0;
  239. int cit_len = GTIFKeyInfo(gtif,GTCitationGeoKey, &cit_size, &cit_type);
  240. if (cit_len)
  241. {
  242. if (GTIFKeyGet(gtif,GTCitationGeoKey,key_data,0,cit_len))
  243. {
  244. geoCitationKey = (char *)key_data;
  245. }
  246. }
  247. if (geoCitationKey.length() == 0)
  248. {
  249. char * gt_ascii = 0;
  251. if (TIFFGetField(tiff, GTIFF_ASCIIPARAMS, &gt_ascii))
  252. {
  253. geoCitationKey = (char *)gt_ascii;
  254. }
  255. }
  257. if (geoCitationKey.length() > 0)
  258. {
  259. UtilityParser p;
  260. p.ParseString(geoCitationKey);
  262. if (p.GetSize() > 0)
  263. {
  264. vector<string> * pArgs = p.GetData();
  266. UINT32 argSize = pArgs->size();
  268. bool utmproj = false;
  270. for (UINT32 i = 0; i < argSize; i++){
  271. string iArg = (*pArgs)[i];
  272. StringUtil::Uppercase(iArg);
  274. if (iArg == "UTM")
  275. {
  276. utmproj = true;
  277. }
  279. if (utmproj && StringUtil::IsIntNumber(iArg))
  280. {
  281. gr.m_proj = GEORef::UTM;
  282. gr.m_zone = atoi(iArg.c_str());
  283. gr.m_ellipse = GEORef::Clarke1866;
  284. result = true;
  285. }
  287. if ((iArg == "ZONE") && (i < (argSize-1)) && (utmproj))
  288. {
  289. iArg = (*pArgs)[i+1];
  291. char cZone[3];
  292. cZone[0] = iArg.c_str()[0];
  293. cZone[1] = iArg.c_str()[1];
  294. cZone[2] = 0;
  296. int zone = atoi(cZone);
  298. gr.m_proj = GEORef::UTM;
  299. gr.m_zone = zone;
  300. result = true;
  301. }
  303. if (StringUtil::StartsWith(iArg,"WGS84"))
  304. {
  305. //
  306. // USGS digital raster graphics say WGS84, but
  307. // they appear to actually be NAD27 using Clarke's
  308. // ellipsoid of 1866. Use GEORef::WGS84 if you 
  309. // are sure that your map is WGS84
  310. //
  311. gr.m_ellipse = GEORef::Clarke1866;//GEORef::WGS84;
  312. }
  313. if (StringUtil::StartsWith(iArg,"NAD27"))
  314. {
  315. gr.m_ellipse = GEORef::Clarke1866;
  316. }
  317. }
  318. }
  319. }
  321. if (TIFFGetField(tiff, GTIFF_TIEPOINTS, &d_list_count, &d_list))
  322. {
  323. gr.m_tieX = d_list[3];
  324. gr.m_tieY = d_list[4];
  325. }
  326. if (TIFFGetField(tiff, GTIFF_PIXELSCALE, &d_list_count, &d_list))
  327. {
  328. gr.m_resX = d_list[0];
  329. gr.m_resY = d_list[1];
  330. }
  332. XTIFFClose(tiff);
  333. GTIFFree(gtif);
  334. }
  335. }
  337. return result;
  338. }
  340. void GetTIFFProperties(const char * tiffName, UINT32 subImage,
  341.    ArrayContainer<std::string>& properties)
  342. {
  343. TIFF * tiff = TIFFOpen((char *)tiffName,"r");
  344. if (tiff)
  345. {
  346. int w=0, h=0, bps=0, packbits=0, photo=0, spp=0, rps=0;
  347. int orient=0;
  349. tdir_t d = (tdir_t)subImage;
  350. TIFFSetDirectory( tiff, d );
  352. TIFFGetField(tiff,TIFFTAG_IMAGEWIDTH, &w);
  353. TIFFGetField(tiff,TIFFTAG_IMAGELENGTH, &h);
  354. TIFFGetField(tiff, TIFFTAG_BITSPERSAMPLE, &bps);
  355. TIFFGetField(tiff, TIFFTAG_COMPRESSION, &packbits);
  356. TIFFGetField(tiff, TIFFTAG_PHOTOMETRIC, &photo);
  357. TIFFGetField(tiff, TIFFTAG_SAMPLESPERPIXEL, &spp);
  358. TIFFGetField(tiff, TIFFTAG_ROWSPERSTRIP, &rps);
  359. TIFFGetField(tiff, TIFFTAG_ORIENTATION, &orient);
  361. string s;
  362. char txt[256];
  364. memset(txt, 0, (size_t)256);
  365. sprintf(txt,"TIFFTAG_IMAGEWIDTH = %d",w);
  366. s = txt;
  367. properties.AddElement(s);
  369. memset(txt, 0, (size_t)256);
  370. sprintf(txt,"TIFFTAG_IMAGELENGTH = %d",h);
  371. s = txt;
  372. properties.AddElement(s);
  374. memset(txt, 0, (size_t)256);
  375. sprintf(txt,"TIFFTAG_BITSPERSAMPLE = %d",bps);
  376. s = txt;
  377. properties.AddElement(s);
  379. memset(txt, 0, (size_t)256);
  380. sprintf(txt,"TIFFTAG_COMPRESSION = ");
  381. s = txt;
  383. switch (packbits){
  384. case COMPRESSION_NONE: s += "NONE"; break;
  385. case COMPRESSION_CCITTRLE: s += "CCITTRLE"; break;
  386. case COMPRESSION_CCITTFAX3: s += "CCITTFAX3 or CCITT_T4"; break;
  387. case COMPRESSION_CCITTFAX4: s += "CCITTFAX4 or CCITT_T6"; break;
  388. case COMPRESSION_LZW: s += "LZW"; break;
  389. case COMPRESSION_OJPEG: s += "OJPEG"; break;
  390. case COMPRESSION_JPEG: s += "JPEG"; break;
  391. case COMPRESSION_NEXT: s += "NEXT"; break;
  392. case COMPRESSION_CCITTRLEW: s += "CCITTRLEW"; break;
  393. case COMPRESSION_PACKBITS: s += "PACKBITS"; break;
  394. case COMPRESSION_THUNDERSCAN: s += "THUNDERSCAN"; break;
  395. /* codes 32895-32898 are reserved for ANSI IT8 TIFF/IT <dkelly@apago.com) */
  396. case COMPRESSION_IT8CTPAD: s += "IT8CTPAD"; break;
  397. case COMPRESSION_IT8LW: s += "IT8LW"; break;
  398. case COMPRESSION_IT8MP: s += "IT8MP"; break;
  399. case COMPRESSION_IT8BL: s += "IT8BL"; break;
  400. /* compression codes 32908-32911 are reserved for Pixar */
  401. case COMPRESSION_PIXARFILM: s += "PIXARFILM"; break;
  402. case COMPRESSION_PIXARLOG: s += "PIXARLOG"; break;
  403. case COMPRESSION_DEFLATE: s += "DEFLATE"; break;
  404. case COMPRESSION_ADOBE_DEFLATE: s += "ADOBE_DEFLATE"; break;
  405. /* compression code 32947 is reserved for Oceana Matrix <dev@oceana.com> */
  406. case COMPRESSION_DCS: s += "DCS"; break;
  407. case COMPRESSION_JBIG: s += "JBIG"; break;
  408. case COMPRESSION_SGILOG: s += "SGILOG"; break;
  409. case COMPRESSION_SGILOG24: s += "SGILOG24"; break;
  410. //case COMPRESSION_JP2000: s += "JP2000"; break;
  411. }
  412. properties.AddElement(s);
  414. memset(txt, 0, (size_t)256);
  415. sprintf(txt,"TIFFTAG_PHOTOMETRIC = ");
  416. s = txt;
  418. switch (photo){
  419. case PHOTOMETRIC_MINISWHITE: s += "MINISWHITE"; break;
  420. case PHOTOMETRIC_MINISBLACK: s += "MINISBLACK"; break;
  421. case PHOTOMETRIC_RGB: s += "RGB"; break;
  422. case PHOTOMETRIC_PALETTE: s += "PALETTE"; break;
  423. case PHOTOMETRIC_MASK: s += "MASK"; break;
  424. case PHOTOMETRIC_SEPARATED: s += "SEPARATED"; break;
  425. case PHOTOMETRIC_YCBCR: s += "YCBCR"; break;
  426. case PHOTOMETRIC_CIELAB: s += "CIELAB"; break;
  427. //case PHOTOMETRIC_ICCLAB: s += "ICCLAB"; break;
  428. case PHOTOMETRIC_ITULAB: s += "ITULAB"; break;
  429. case PHOTOMETRIC_LOGL: s += "LOGL"; break;
  430. case PHOTOMETRIC_LOGLUV: s += "LOGLUV"; break;
  431. }
  432. properties.AddElement(s);
  434. memset(txt, 0, (size_t)256);
  435. sprintf(txt,"TIFFTAG_SAMPLESPERPIXEL = %d",spp);
  436. s = txt;
  437. properties.AddElement(s);
  439. TIFFClose(tiff);
  441. GEORef gr;
  442. if (ReadGeoInfo(tiffName,gr))
  443. {
  444. memset(txt, 0, (size_t)256);
  445. sprintf(txt,"GTIFF_TIEPOINTS = ( %.2f, %.2f )",gr.m_tieX,gr.m_tieY);
  446. s = txt;
  447. properties.AddElement(s);
  449. memset(txt, 0, (size_t)256);
  450. sprintf(txt,"GTIFF_PIXELSCALE = ( %.7f, %.7f )",gr.m_resX,gr.m_resY);
  451. s = txt;
  452. properties.AddElement(s);
  454. memset(txt, 0, (size_t)256);
  455. sprintf(txt,"UTM Zone = %d",gr.m_zone);
  456. s = txt;
  457. properties.AddElement(s);
  458. }
  459. }
  460. }
  462. int SaveDIB2TIFF(const char * output_file, DIBSection& dib)
  463. {
  464. int result = 0;
  466. UINT32 w = dib.Width();
  467. UINT32 h = dib.Height();
  468. UINT32 total_width = dib.GetTotalWidth();
  469. UINT32 bitcount = dib.GetBitCount();
  470. UINT32 bytecount = bitcount / 8;
  472. if (dib.IsCreated() && (w > 0) && (h > 0))
  473. {
  475. double image_gamma = TIFF_GAMMA;
  477. TIFF * tif;
  479. if ((tif = TIFFOpen(output_file, "w")) == NULL)
  480. {
  481. return result;
  482. }
  484.   // setup the image tags
  485. TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, w);
  486. TIFFSetField(tif, TIFFTAG_IMAGELENGTH, h);
  487. TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 8);
  488. TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_PACKBITS);
  489. TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
  490. TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 3);
  491. TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, 1);
  492. TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
  493. TIFFSetField(tif, TIFFTAG_RESOLUTIONUNIT, RESUNIT_NONE);
  494. TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
  496. unsigned char * psrc = (unsigned char *)dib.GetBits();
  497. unsigned char * pdst = new unsigned char[(w * 3)];
  499. UINT32 src_index;
  500. UINT32 dst_index;
  502.   // now go line by line to write out the image data
  503. for (int row = 0; row < h; row++ ){
  505.   // initialize the scan line to zero
  506. memset(pdst,0,(size_t)(w * 3));
  508.   // moving the data from the dib to a row structure that can
  509.   // be used by the tiff library
  510. for (int col = 0; col < w; col++){
  511. src_index = (h - row - 1) * total_width * bytecount + col * bytecount;
  512. dst_index = col * 3;
  513. pdst[dst_index++] = psrc[src_index+2];
  514. pdst[dst_index++] = psrc[src_index+1];
  515. pdst[dst_index] = psrc[src_index];
  516. result++;
  517. }
  519.   // now actually write the row data
  520. TIFFWriteScanline(tif, pdst, row, 0);
  521. }
  523. TIFFClose(tif);
  524. }
  526. return result;
  527. }
  529. int OpenBigTIFF2DIB(const char * lpFileName, DIBSection& dib, int directory)    
  530. {
  531. int result = 0;
  533.     TIFF *tif;
  534.     unsigned long imageLength; 
  535.     unsigned long imageWidth; 
  536.     unsigned int BitsPerSample;
  537.     unsigned long LineSize;
  538.     unsigned int SamplePerPixel;
  539.     unsigned long RowsPerStrip;  
  540.     int PhotometricInterpretation;
  541.     long nrow;
  542. unsigned long row;
  543.     char *buf;          
  544.     char *lpBits;
  545.     HGLOBAL hStrip;
  546.     int i,l;
  547.     int Align; 
  548. bool bigTiff = false;
  549.     
  550.     tif = TIFFOpen(lpFileName, "r");
  551.     
  552.     if (!tif)
  553. {
  554.         return result;
  555. }
  557. tdir_t d = (tdir_t)directory;
  558. TIFFSetDirectory(tif,d);
  559.     
  560.     TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &imageWidth);
  561.     TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &imageLength);  
  562.     TIFFGetField(tif, TIFFTAG_BITSPERSAMPLE, &BitsPerSample);
  563.     TIFFGetField(tif, TIFFTAG_ROWSPERSTRIP, &RowsPerStrip);  
  564.     TIFFGetField(tif, TIFFTAG_ROWSPERSTRIP, &RowsPerStrip);   
  565.     TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &PhotometricInterpretation);
  566.            
  567.     LineSize = TIFFScanlineSize(tif); //Number of byte in ine line
  569.     SamplePerPixel = (int) (LineSize/imageWidth);
  571.     //Align = Number of byte to add at the end of each line of the DIB
  572.     Align = 4 - (LineSize % 4);
  573.     if (Align == 4) Align = 0;
  575.     
  576.     //Create a new DIB
  577. double dw = imageWidth;
  578. double dh = imageLength;
  579. double img_scale = 1.0;
  580. double hscale, vscale;
  582. const double MaxImageDimension = 4096;
  584. if ((imageWidth > MaxImageDimension) || (imageLength > MaxImageDimension))
  585. {
  586. bigTiff = true;
  587. if (dw > dh)
  588. {
  589. img_scale = (dw/MaxImageDimension);
  590. dh /= img_scale;
  591. dw = MaxImageDimension;
  592. hscale = (double)imageWidth/dw;
  593. vscale = (double)imageLength/dh;
  594. }
  595. else if (dw < dh)
  596. {
  597. img_scale = (dh/MaxImageDimension);
  598. dw /= img_scale;
  599. dh = MaxImageDimension;
  600. hscale = (double)imageWidth/dw;
  601. vscale = (double)imageLength/dh;
  602. }
  603. else
  604. {
  605. img_scale = (dh/MaxImageDimension);
  606. dw = MaxImageDimension;
  607. dh = MaxImageDimension;
  608. hscale = (double)imageWidth/dw;
  609. vscale = (double)imageLength/dh;
  610. }
  612. INT32 w = (INT32)(dw + 0.50);
  613. INT32 h = (INT32)(dh + 0.50);
  615. dib.Create(w,h,24);
  616.           
  617. lpBits = (char *)dib.GetBits();
  619. //In the tiff file the lines are save from up to down 
  620. //In a DIB the lines must be save from down to up
  621. if (lpBits)
  622. {
  623. hStrip = GlobalAlloc(GHND,TIFFStripSize(tif));
  624. buf = (char *)GlobalLock(hStrip);           
  626. if (!buf)
  627. goto OutOfBufMemory;
  629. //read the tiff lines and save them in the DIB
  630. //with RGB mode, we have to change the order of the 3 samples RGB
  631. // <=> BGR
  633. UINT32 next_row = 0;
  634. UINT32 current_row = 0;
  635. UINT32 img_row = 0;
  636. UINT32 src_col, src_row, dst_ndx, total_width;
  637. UINT32 row_incr = (UINT32)(vscale + 0.50);
  639. total_width = dib.GetTotalWidth();
  641. for (row = 0; row < imageLength; row += row_incr){
  642. nrow = (row + RowsPerStrip > imageLength ? imageLength - row :
  643. RowsPerStrip);
  645. if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, row, 0),
  646. buf, nrow*LineSize)==-1)
  647. {
  648. goto TiffReadError;
  649. } 
  650. else
  651. {  
  652. for (l = 0; l < nrow; l++){
  653. if (SamplePerPixel  == 3)
  654. {
  655. for (i=0;i<w;i++){
  656. src_col = (UINT32)(hscale * i + 0.50);
  657. if (src_col > imageWidth) src_col = imageWidth;
  658. src_row = l*LineSize;
  659. dst_ndx = 3 * (i + (h - img_row - 1) * total_width);
  660. lpBits[dst_ndx] = buf[src_row+src_col*SamplePerPixel+2];
  661. lpBits[++dst_ndx] = buf[src_row+src_col*SamplePerPixel+1];
  662. lpBits[++dst_ndx] = buf[src_row+src_col*SamplePerPixel+0];
  663. }
  665. img_row++;
  666. if (img_row == h) break;
  667. }
  668. }
  670. if (img_row == h) break;
  671. }
  672. }
  674. result++;
  676. GlobalUnlock(hStrip);
  677. GlobalFree(hStrip);
  678. }
  680. TIFFClose(tif);
  681. }
  682. else
  683. {
  684. /*
  685. INT32 w = imageWidth;
  686. INT32 h = imageLength;
  688. dib.Create(w,h,24);
  689.           
  690. lpBits = (char *)dib.GetBits();
  692. if (lpBits)
  693. {
  694. hStrip = GlobalAlloc(GHND,TIFFStripSize(tif));
  695. buf = (char *)GlobalLock(hStrip);           
  697. if (!buf)
  698. goto OutOfBufMemory;
  700. //read the tiff lines and save them in the DIB
  701. //with RGB mode, we have to change the order of the 3 samples RGB
  702. // <=> BGR
  704. UINT32 next_row = 0;
  705. UINT32 current_row = 0;
  706. UINT32 img_row = 0;
  707. UINT32 src_col, src_row, dst_ndx, total_width;
  708. UINT32 row_incr = 1;
  710. total_width = dib.GetTotalWidth();
  712. for (row = 0; row < imageLength; row++){
  713. nrow = ((row + RowsPerStrip) > imageLength) ? (imageLength - row) :
  714. (RowsPerStrip);
  716. if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, row, 0),
  717. buf, nrow*LineSize) == -1)
  718. {
  719. goto TiffReadError;
  720. } 
  721. else
  722. {
  723. if (SamplePerPixel  == 3)
  724. {
  725. for (l = 0; l < nrow; l++){
  726. for (i=0;i<w;i++){
  727. src_col = i;
  728. if (src_col > imageWidth) src_col = imageWidth;
  729. src_row = l*LineSize;
  730. dst_ndx = 3 * (i + (h - img_row - 1) * total_width);
  731. lpBits[dst_ndx] = buf[src_row+src_col*SamplePerPixel+2];
  732. lpBits[++dst_ndx] = buf[src_row+src_col*SamplePerPixel+1];
  733. lpBits[++dst_ndx] = buf[src_row+src_col*SamplePerPixel+0];
  734. }
  736. img_row++;
  737. if (img_row == h) break;
  738. }
  739. }
  741. if (img_row == h) break;
  742. }
  743. }
  744. }
  746. result++;
  748. GlobalUnlock(hStrip);
  749. GlobalFree(hStrip);
  750. */
  752. TIFFClose(tif);
  753. return OpenTIFF2DIB(lpFileName,dib,directory);
  754. }
  756. return result;
  758. OutOfBufMemory:
  760. TiffReadError:
  761. GlobalFree(hStrip); 
  762. }