| 1 | ///////////////////////////////////////////////////////////////////////////// |
| 2 | // Name: src/common/imagtiff.cpp |
| 3 | // Purpose: wxImage TIFF handler |
| 4 | // Author: Robert Roebling |
| 5 | // RCS-ID: $Id$ |
| 6 | // Copyright: (c) Robert Roebling |
| 7 | // Licence: wxWindows licence |
| 8 | ///////////////////////////////////////////////////////////////////////////// |
| 9 | |
| 10 | // ============================================================================ |
| 11 | // declarations |
| 12 | // ============================================================================ |
| 13 | |
| 14 | // ---------------------------------------------------------------------------- |
| 15 | // headers |
| 16 | // ---------------------------------------------------------------------------- |
| 17 | |
| 18 | // For compilers that support precompilation, includes "wx.h". |
| 19 | #include "wx/wxprec.h" |
| 20 | |
| 21 | #ifdef __BORLANDC__ |
| 22 | #pragma hdrstop |
| 23 | #endif |
| 24 | |
| 25 | #if wxUSE_IMAGE && wxUSE_LIBTIFF |
| 26 | |
| 27 | #include "wx/imagtiff.h" |
| 28 | #include "wx/versioninfo.h" |
| 29 | |
| 30 | #ifndef WX_PRECOMP |
| 31 | #include "wx/log.h" |
| 32 | #include "wx/app.h" |
| 33 | #include "wx/intl.h" |
| 34 | #include "wx/bitmap.h" |
| 35 | #include "wx/module.h" |
| 36 | #include "wx/wxcrtvararg.h" |
| 37 | #endif |
| 38 | |
| 39 | extern "C" |
| 40 | { |
| 41 | #ifdef __DMC__ |
| 42 | #include "tif_config.h" |
| 43 | #endif |
| 44 | #include "tiff.h" |
| 45 | #include "tiffio.h" |
| 46 | } |
| 47 | #include "wx/filefn.h" |
| 48 | #include "wx/wfstream.h" |
| 49 | |
| 50 | #ifndef TIFFLINKAGEMODE |
| 51 | #if defined(__WATCOMC__) && defined(__WXMGL__) |
| 52 | #define TIFFLINKAGEMODE cdecl |
| 53 | #else |
| 54 | #define TIFFLINKAGEMODE LINKAGEMODE |
| 55 | #endif |
| 56 | #endif |
| 57 | |
| 58 | // ============================================================================ |
| 59 | // implementation |
| 60 | // ============================================================================ |
| 61 | |
| 62 | // ---------------------------------------------------------------------------- |
| 63 | // TIFF library error/warning handlers |
| 64 | // ---------------------------------------------------------------------------- |
| 65 | |
| 66 | static wxString |
| 67 | FormatTiffMessage(const char *module, const char *fmt, va_list ap) |
| 68 | { |
| 69 | char buf[512]; |
| 70 | if ( wxCRT_VsnprintfA(buf, WXSIZEOF(buf), fmt, ap) <= 0 ) |
| 71 | { |
| 72 | // this isn't supposed to happen, but if it does, it's better |
| 73 | // than nothing |
| 74 | strcpy(buf, "Incorrectly formatted TIFF message"); |
| 75 | } |
| 76 | buf[WXSIZEOF(buf)-1] = 0; // make sure it is always NULL-terminated |
| 77 | |
| 78 | wxString msg(buf); |
| 79 | if ( module ) |
| 80 | msg += wxString::Format(_(" (in module \"%s\")"), module); |
| 81 | |
| 82 | return msg; |
| 83 | } |
| 84 | |
| 85 | extern "C" |
| 86 | { |
| 87 | |
| 88 | static void |
| 89 | TIFFwxWarningHandler(const char* module, const char *fmt, va_list ap) |
| 90 | { |
| 91 | wxLogWarning("%s", FormatTiffMessage(module, fmt, ap)); |
| 92 | } |
| 93 | |
| 94 | static void |
| 95 | TIFFwxErrorHandler(const char* module, const char *fmt, va_list ap) |
| 96 | { |
| 97 | wxLogError("%s", FormatTiffMessage(module, fmt, ap)); |
| 98 | } |
| 99 | |
| 100 | } // extern "C" |
| 101 | |
| 102 | //----------------------------------------------------------------------------- |
| 103 | // wxTIFFHandler |
| 104 | //----------------------------------------------------------------------------- |
| 105 | |
| 106 | IMPLEMENT_DYNAMIC_CLASS(wxTIFFHandler,wxImageHandler) |
| 107 | |
| 108 | wxTIFFHandler::wxTIFFHandler() |
| 109 | { |
| 110 | m_name = wxT("TIFF file"); |
| 111 | m_extension = wxT("tif"); |
| 112 | m_altExtensions.Add(wxT("tiff")); |
| 113 | m_type = wxBITMAP_TYPE_TIF; |
| 114 | m_mime = wxT("image/tiff"); |
| 115 | TIFFSetWarningHandler((TIFFErrorHandler) TIFFwxWarningHandler); |
| 116 | TIFFSetErrorHandler((TIFFErrorHandler) TIFFwxErrorHandler); |
| 117 | } |
| 118 | |
| 119 | #if wxUSE_STREAMS |
| 120 | |
| 121 | // helper to translate our, possibly 64 bit, wxFileOffset to TIFF, always 32 |
| 122 | // bit, toff_t |
| 123 | static toff_t wxFileOffsetToTIFF(wxFileOffset ofs) |
| 124 | { |
| 125 | if ( ofs == wxInvalidOffset ) |
| 126 | return (toff_t)-1; |
| 127 | |
| 128 | toff_t tofs = wx_truncate_cast(toff_t, ofs); |
| 129 | wxCHECK_MSG( (wxFileOffset)tofs == ofs, (toff_t)-1, |
| 130 | wxT("TIFF library doesn't support large files") ); |
| 131 | |
| 132 | return tofs; |
| 133 | } |
| 134 | |
| 135 | // another helper to convert standard seek mode to our |
| 136 | static wxSeekMode wxSeekModeFromTIFF(int whence) |
| 137 | { |
| 138 | switch ( whence ) |
| 139 | { |
| 140 | case SEEK_SET: |
| 141 | return wxFromStart; |
| 142 | |
| 143 | case SEEK_CUR: |
| 144 | return wxFromCurrent; |
| 145 | |
| 146 | case SEEK_END: |
| 147 | return wxFromEnd; |
| 148 | |
| 149 | default: |
| 150 | return wxFromCurrent; |
| 151 | } |
| 152 | } |
| 153 | |
| 154 | extern "C" |
| 155 | { |
| 156 | |
| 157 | tsize_t TIFFLINKAGEMODE |
| 158 | wxTIFFNullProc(thandle_t WXUNUSED(handle), |
| 159 | tdata_t WXUNUSED(buf), |
| 160 | tsize_t WXUNUSED(size)) |
| 161 | { |
| 162 | return (tsize_t) -1; |
| 163 | } |
| 164 | |
| 165 | tsize_t TIFFLINKAGEMODE |
| 166 | wxTIFFReadProc(thandle_t handle, tdata_t buf, tsize_t size) |
| 167 | { |
| 168 | wxInputStream *stream = (wxInputStream*) handle; |
| 169 | stream->Read( (void*) buf, (size_t) size ); |
| 170 | return wx_truncate_cast(tsize_t, stream->LastRead()); |
| 171 | } |
| 172 | |
| 173 | tsize_t TIFFLINKAGEMODE |
| 174 | wxTIFFWriteProc(thandle_t handle, tdata_t buf, tsize_t size) |
| 175 | { |
| 176 | wxOutputStream *stream = (wxOutputStream*) handle; |
| 177 | stream->Write( (void*) buf, (size_t) size ); |
| 178 | return wx_truncate_cast(tsize_t, stream->LastWrite()); |
| 179 | } |
| 180 | |
| 181 | toff_t TIFFLINKAGEMODE |
| 182 | wxTIFFSeekIProc(thandle_t handle, toff_t off, int whence) |
| 183 | { |
| 184 | wxInputStream *stream = (wxInputStream*) handle; |
| 185 | |
| 186 | return wxFileOffsetToTIFF(stream->SeekI((wxFileOffset)off, |
| 187 | wxSeekModeFromTIFF(whence))); |
| 188 | } |
| 189 | |
| 190 | toff_t TIFFLINKAGEMODE |
| 191 | wxTIFFSeekOProc(thandle_t handle, toff_t off, int whence) |
| 192 | { |
| 193 | wxOutputStream *stream = (wxOutputStream*) handle; |
| 194 | |
| 195 | return wxFileOffsetToTIFF(stream->SeekO((wxFileOffset)off, |
| 196 | wxSeekModeFromTIFF(whence))); |
| 197 | } |
| 198 | |
| 199 | int TIFFLINKAGEMODE |
| 200 | wxTIFFCloseIProc(thandle_t WXUNUSED(handle)) |
| 201 | { |
| 202 | // there is no need to close the input stream |
| 203 | return 0; |
| 204 | } |
| 205 | |
| 206 | int TIFFLINKAGEMODE |
| 207 | wxTIFFCloseOProc(thandle_t handle) |
| 208 | { |
| 209 | wxOutputStream *stream = (wxOutputStream*) handle; |
| 210 | |
| 211 | return stream->Close() ? 0 : -1; |
| 212 | } |
| 213 | |
| 214 | toff_t TIFFLINKAGEMODE |
| 215 | wxTIFFSizeProc(thandle_t handle) |
| 216 | { |
| 217 | wxStreamBase *stream = (wxStreamBase*) handle; |
| 218 | return (toff_t) stream->GetSize(); |
| 219 | } |
| 220 | |
| 221 | int TIFFLINKAGEMODE |
| 222 | wxTIFFMapProc(thandle_t WXUNUSED(handle), |
| 223 | tdata_t* WXUNUSED(pbase), |
| 224 | toff_t* WXUNUSED(psize)) |
| 225 | { |
| 226 | return 0; |
| 227 | } |
| 228 | |
| 229 | void TIFFLINKAGEMODE |
| 230 | wxTIFFUnmapProc(thandle_t WXUNUSED(handle), |
| 231 | tdata_t WXUNUSED(base), |
| 232 | toff_t WXUNUSED(size)) |
| 233 | { |
| 234 | } |
| 235 | |
| 236 | } // extern "C" |
| 237 | |
| 238 | TIFF* |
| 239 | TIFFwxOpen(wxInputStream &stream, const char* name, const char* mode) |
| 240 | { |
| 241 | TIFF* tif = TIFFClientOpen(name, mode, |
| 242 | (thandle_t) &stream, |
| 243 | wxTIFFReadProc, wxTIFFNullProc, |
| 244 | wxTIFFSeekIProc, wxTIFFCloseIProc, wxTIFFSizeProc, |
| 245 | wxTIFFMapProc, wxTIFFUnmapProc); |
| 246 | |
| 247 | return tif; |
| 248 | } |
| 249 | |
| 250 | TIFF* |
| 251 | TIFFwxOpen(wxOutputStream &stream, const char* name, const char* mode) |
| 252 | { |
| 253 | TIFF* tif = TIFFClientOpen(name, mode, |
| 254 | (thandle_t) &stream, |
| 255 | wxTIFFNullProc, wxTIFFWriteProc, |
| 256 | wxTIFFSeekOProc, wxTIFFCloseOProc, wxTIFFSizeProc, |
| 257 | wxTIFFMapProc, wxTIFFUnmapProc); |
| 258 | |
| 259 | return tif; |
| 260 | } |
| 261 | |
| 262 | bool wxTIFFHandler::LoadFile( wxImage *image, wxInputStream& stream, bool verbose, int index ) |
| 263 | { |
| 264 | if (index == -1) |
| 265 | index = 0; |
| 266 | |
| 267 | image->Destroy(); |
| 268 | |
| 269 | TIFF *tif = TIFFwxOpen( stream, "image", "r" ); |
| 270 | |
| 271 | if (!tif) |
| 272 | { |
| 273 | if (verbose) |
| 274 | { |
| 275 | wxLogError( _("TIFF: Error loading image.") ); |
| 276 | } |
| 277 | |
| 278 | return false; |
| 279 | } |
| 280 | |
| 281 | if (!TIFFSetDirectory( tif, (tdir_t)index )) |
| 282 | { |
| 283 | if (verbose) |
| 284 | { |
| 285 | wxLogError( _("Invalid TIFF image index.") ); |
| 286 | } |
| 287 | |
| 288 | TIFFClose( tif ); |
| 289 | |
| 290 | return false; |
| 291 | } |
| 292 | |
| 293 | uint32 w, h; |
| 294 | uint32 *raster; |
| 295 | |
| 296 | TIFFGetField( tif, TIFFTAG_IMAGEWIDTH, &w ); |
| 297 | TIFFGetField( tif, TIFFTAG_IMAGELENGTH, &h ); |
| 298 | |
| 299 | uint16 extraSamples; |
| 300 | uint16* samplesInfo; |
| 301 | TIFFGetFieldDefaulted(tif, TIFFTAG_EXTRASAMPLES, |
| 302 | &extraSamples, &samplesInfo); |
| 303 | const bool hasAlpha = (extraSamples == 1 && |
| 304 | (samplesInfo[0] == EXTRASAMPLE_ASSOCALPHA || |
| 305 | samplesInfo[0] == EXTRASAMPLE_UNASSALPHA)); |
| 306 | |
| 307 | // guard against integer overflow during multiplication which could result |
| 308 | // in allocating a too small buffer and then overflowing it |
| 309 | const double bytesNeeded = (double)w * (double)h * sizeof(uint32); |
| 310 | if ( bytesNeeded >= wxUINT32_MAX ) |
| 311 | { |
| 312 | if ( verbose ) |
| 313 | { |
| 314 | wxLogError( _("TIFF: Image size is abnormally big.") ); |
| 315 | } |
| 316 | |
| 317 | TIFFClose(tif); |
| 318 | |
| 319 | return false; |
| 320 | } |
| 321 | |
| 322 | raster = (uint32*) _TIFFmalloc( (uint32)bytesNeeded ); |
| 323 | |
| 324 | if (!raster) |
| 325 | { |
| 326 | if (verbose) |
| 327 | { |
| 328 | wxLogError( _("TIFF: Couldn't allocate memory.") ); |
| 329 | } |
| 330 | |
| 331 | TIFFClose( tif ); |
| 332 | |
| 333 | return false; |
| 334 | } |
| 335 | |
| 336 | image->Create( (int)w, (int)h ); |
| 337 | if (!image->Ok()) |
| 338 | { |
| 339 | if (verbose) |
| 340 | { |
| 341 | wxLogError( _("TIFF: Couldn't allocate memory.") ); |
| 342 | } |
| 343 | |
| 344 | _TIFFfree( raster ); |
| 345 | TIFFClose( tif ); |
| 346 | |
| 347 | return false; |
| 348 | } |
| 349 | |
| 350 | if ( hasAlpha ) |
| 351 | image->SetAlpha(); |
| 352 | |
| 353 | if (!TIFFReadRGBAImage( tif, w, h, raster, 0 )) |
| 354 | { |
| 355 | if (verbose) |
| 356 | { |
| 357 | wxLogError( _("TIFF: Error reading image.") ); |
| 358 | } |
| 359 | |
| 360 | _TIFFfree( raster ); |
| 361 | image->Destroy(); |
| 362 | TIFFClose( tif ); |
| 363 | |
| 364 | return false; |
| 365 | } |
| 366 | |
| 367 | unsigned char *ptr = image->GetData(); |
| 368 | ptr += w*3*(h-1); |
| 369 | |
| 370 | unsigned char *alpha = hasAlpha ? image->GetAlpha() : NULL; |
| 371 | if ( hasAlpha ) |
| 372 | alpha += w*(h-1); |
| 373 | |
| 374 | uint32 pos = 0; |
| 375 | |
| 376 | for (uint32 i = 0; i < h; i++) |
| 377 | { |
| 378 | for (uint32 j = 0; j < w; j++) |
| 379 | { |
| 380 | *(ptr++) = (unsigned char)TIFFGetR(raster[pos]); |
| 381 | *(ptr++) = (unsigned char)TIFFGetG(raster[pos]); |
| 382 | *(ptr++) = (unsigned char)TIFFGetB(raster[pos]); |
| 383 | if ( hasAlpha ) |
| 384 | *(alpha++) = (unsigned char)TIFFGetA(raster[pos]); |
| 385 | |
| 386 | pos++; |
| 387 | } |
| 388 | |
| 389 | // subtract line we just added plus one line: |
| 390 | ptr -= 2*w*3; |
| 391 | if ( hasAlpha ) |
| 392 | alpha -= 2*w; |
| 393 | } |
| 394 | |
| 395 | // set the image resolution if it's available |
| 396 | uint16 tiffRes; |
| 397 | if ( TIFFGetField(tif, TIFFTAG_RESOLUTIONUNIT, &tiffRes) ) |
| 398 | { |
| 399 | wxImageResolution res; |
| 400 | switch ( tiffRes ) |
| 401 | { |
| 402 | default: |
| 403 | wxLogWarning(_("Unknown TIFF resolution unit %d ignored"), |
| 404 | tiffRes); |
| 405 | // fall through |
| 406 | |
| 407 | case RESUNIT_NONE: |
| 408 | res = wxIMAGE_RESOLUTION_NONE; |
| 409 | break; |
| 410 | |
| 411 | case RESUNIT_INCH: |
| 412 | res = wxIMAGE_RESOLUTION_INCHES; |
| 413 | break; |
| 414 | |
| 415 | case RESUNIT_CENTIMETER: |
| 416 | res = wxIMAGE_RESOLUTION_CM; |
| 417 | break; |
| 418 | } |
| 419 | |
| 420 | if ( res != wxIMAGE_RESOLUTION_NONE ) |
| 421 | { |
| 422 | float xres, yres; |
| 423 | if ( TIFFGetField(tif, TIFFTAG_XRESOLUTION, &xres) ) |
| 424 | image->SetOption(wxIMAGE_OPTION_RESOLUTIONX, wxRound(xres)); |
| 425 | |
| 426 | if ( TIFFGetField(tif, TIFFTAG_YRESOLUTION, &yres) ) |
| 427 | image->SetOption(wxIMAGE_OPTION_RESOLUTIONY, wxRound(yres)); |
| 428 | } |
| 429 | } |
| 430 | |
| 431 | |
| 432 | _TIFFfree( raster ); |
| 433 | |
| 434 | TIFFClose( tif ); |
| 435 | |
| 436 | return true; |
| 437 | } |
| 438 | |
| 439 | int wxTIFFHandler::DoGetImageCount( wxInputStream& stream ) |
| 440 | { |
| 441 | TIFF *tif = TIFFwxOpen( stream, "image", "r" ); |
| 442 | |
| 443 | if (!tif) |
| 444 | return 0; |
| 445 | |
| 446 | int dircount = 0; // according to the libtiff docs, dircount should be set to 1 here??? |
| 447 | do { |
| 448 | dircount++; |
| 449 | } while (TIFFReadDirectory(tif)); |
| 450 | |
| 451 | TIFFClose( tif ); |
| 452 | |
| 453 | // NOTE: this function modifies the current stream position but it's ok |
| 454 | // (see wxImageHandler::GetImageCount) |
| 455 | |
| 456 | return dircount; |
| 457 | } |
| 458 | |
| 459 | bool wxTIFFHandler::SaveFile( wxImage *image, wxOutputStream& stream, bool verbose ) |
| 460 | { |
| 461 | TIFF *tif = TIFFwxOpen( stream, "image", "w" ); |
| 462 | |
| 463 | if (!tif) |
| 464 | { |
| 465 | if (verbose) |
| 466 | { |
| 467 | wxLogError( _("TIFF: Error saving image.") ); |
| 468 | } |
| 469 | |
| 470 | return false; |
| 471 | } |
| 472 | |
| 473 | TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT); |
| 474 | TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, (uint32)image->GetWidth()); |
| 475 | TIFFSetField(tif, TIFFTAG_IMAGELENGTH, (uint32)image->GetHeight()); |
| 476 | TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT); |
| 477 | TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG); |
| 478 | |
| 479 | // save the image resolution if we have it |
| 480 | int xres, yres; |
| 481 | const wxImageResolution res = GetResolutionFromOptions(*image, &xres, &yres); |
| 482 | uint16 tiffRes; |
| 483 | switch ( res ) |
| 484 | { |
| 485 | default: |
| 486 | wxFAIL_MSG( wxT("unknown image resolution units") ); |
| 487 | // fall through |
| 488 | |
| 489 | case wxIMAGE_RESOLUTION_NONE: |
| 490 | tiffRes = RESUNIT_NONE; |
| 491 | break; |
| 492 | |
| 493 | case wxIMAGE_RESOLUTION_INCHES: |
| 494 | tiffRes = RESUNIT_INCH; |
| 495 | break; |
| 496 | |
| 497 | case wxIMAGE_RESOLUTION_CM: |
| 498 | tiffRes = RESUNIT_CENTIMETER; |
| 499 | break; |
| 500 | } |
| 501 | |
| 502 | if ( tiffRes != RESUNIT_NONE ) |
| 503 | { |
| 504 | TIFFSetField(tif, TIFFTAG_RESOLUTIONUNIT, tiffRes); |
| 505 | TIFFSetField(tif, TIFFTAG_XRESOLUTION, (float)xres); |
| 506 | TIFFSetField(tif, TIFFTAG_YRESOLUTION, (float)yres); |
| 507 | } |
| 508 | |
| 509 | |
| 510 | int spp = image->GetOptionInt(wxIMAGE_OPTION_SAMPLESPERPIXEL); |
| 511 | if ( !spp ) |
| 512 | spp = 3; |
| 513 | |
| 514 | int bpp = image->GetOptionInt(wxIMAGE_OPTION_BITSPERSAMPLE); |
| 515 | if ( !bpp ) |
| 516 | bpp = 8; |
| 517 | |
| 518 | int compression = image->GetOptionInt(wxIMAGE_OPTION_COMPRESSION); |
| 519 | if ( !compression ) |
| 520 | { |
| 521 | // we can't use COMPRESSION_LZW because current version of libtiff |
| 522 | // doesn't implement it ("no longer implemented due to Unisys patent |
| 523 | // enforcement") and other compression methods are lossy so we |
| 524 | // shouldn't use them by default -- and the only remaining one is none |
| 525 | compression = COMPRESSION_NONE; |
| 526 | } |
| 527 | |
| 528 | TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, spp); |
| 529 | TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, bpp); |
| 530 | TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, spp*bpp == 1 ? PHOTOMETRIC_MINISBLACK |
| 531 | : PHOTOMETRIC_RGB); |
| 532 | TIFFSetField(tif, TIFFTAG_COMPRESSION, compression); |
| 533 | |
| 534 | // scanlinesize if determined by spp and bpp |
| 535 | tsize_t linebytes = (tsize_t)image->GetWidth() * spp * bpp / 8; |
| 536 | |
| 537 | if ( (image->GetWidth() % 8 > 0) && (spp * bpp < 8) ) |
| 538 | linebytes+=1; |
| 539 | |
| 540 | unsigned char *buf; |
| 541 | |
| 542 | if (TIFFScanlineSize(tif) > linebytes || (spp * bpp < 24)) |
| 543 | { |
| 544 | buf = (unsigned char *)_TIFFmalloc(TIFFScanlineSize(tif)); |
| 545 | if (!buf) |
| 546 | { |
| 547 | if (verbose) |
| 548 | { |
| 549 | wxLogError( _("TIFF: Couldn't allocate memory.") ); |
| 550 | } |
| 551 | |
| 552 | TIFFClose( tif ); |
| 553 | |
| 554 | return false; |
| 555 | } |
| 556 | } |
| 557 | else |
| 558 | { |
| 559 | buf = NULL; |
| 560 | } |
| 561 | |
| 562 | TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP,TIFFDefaultStripSize(tif, (uint32) -1)); |
| 563 | |
| 564 | unsigned char *ptr = image->GetData(); |
| 565 | for ( int row = 0; row < image->GetHeight(); row++ ) |
| 566 | { |
| 567 | if ( buf ) |
| 568 | { |
| 569 | if ( spp * bpp > 1 ) |
| 570 | { |
| 571 | // color image |
| 572 | memcpy(buf, ptr, image->GetWidth()); |
| 573 | } |
| 574 | else // black and white image |
| 575 | { |
| 576 | for ( int column = 0; column < linebytes; column++ ) |
| 577 | { |
| 578 | uint8 reverse = 0; |
| 579 | for ( int bp = 0; bp < 8; bp++ ) |
| 580 | { |
| 581 | if ( ptr[column*24 + bp*3] > 0 ) |
| 582 | { |
| 583 | // check only red as this is sufficient |
| 584 | reverse = (uint8)(reverse | 128 >> bp); |
| 585 | } |
| 586 | } |
| 587 | |
| 588 | buf[column] = reverse; |
| 589 | } |
| 590 | } |
| 591 | } |
| 592 | |
| 593 | if ( TIFFWriteScanline(tif, buf ? buf : ptr, (uint32)row, 0) < 0 ) |
| 594 | { |
| 595 | if (verbose) |
| 596 | { |
| 597 | wxLogError( _("TIFF: Error writing image.") ); |
| 598 | } |
| 599 | |
| 600 | TIFFClose( tif ); |
| 601 | if (buf) |
| 602 | _TIFFfree(buf); |
| 603 | |
| 604 | return false; |
| 605 | } |
| 606 | |
| 607 | ptr += image->GetWidth()*3; |
| 608 | } |
| 609 | |
| 610 | (void) TIFFClose(tif); |
| 611 | |
| 612 | if (buf) |
| 613 | _TIFFfree(buf); |
| 614 | |
| 615 | return true; |
| 616 | } |
| 617 | |
| 618 | bool wxTIFFHandler::DoCanRead( wxInputStream& stream ) |
| 619 | { |
| 620 | unsigned char hdr[2]; |
| 621 | |
| 622 | if ( !stream.Read(&hdr[0], WXSIZEOF(hdr)) ) // it's ok to modify the stream position here |
| 623 | return false; |
| 624 | |
| 625 | return (hdr[0] == 'I' && hdr[1] == 'I') || |
| 626 | (hdr[0] == 'M' && hdr[1] == 'M'); |
| 627 | } |
| 628 | |
| 629 | #endif // wxUSE_STREAMS |
| 630 | |
| 631 | /*static*/ wxVersionInfo wxTIFFHandler::GetLibraryVersionInfo() |
| 632 | { |
| 633 | int major, |
| 634 | minor, |
| 635 | micro; |
| 636 | |
| 637 | const wxString ver(::TIFFGetVersion()); |
| 638 | if ( wxSscanf(ver, "LIBTIFF, Version %d.%d.%d", &major, &minor, µ) != 3 ) |
| 639 | { |
| 640 | wxLogDebug("Unrecognized libtiff version string \"%s\"", ver); |
| 641 | |
| 642 | major = |
| 643 | minor = |
| 644 | micro = 0; |
| 645 | } |
| 646 | |
| 647 | wxString copyright; |
| 648 | const wxString desc = ver.BeforeFirst('\n', ©right); |
| 649 | copyright.Replace("\n", ""); |
| 650 | |
| 651 | return wxVersionInfo("libtiff", major, minor, micro, desc, copyright); |
| 652 | } |
| 653 | |
| 654 | #endif // wxUSE_LIBTIFF |