src/common/imagtiff.cpp

   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 // For compilers that support precompilation, includes "wx.h".
  11 #include "wx/wxprec.h"
  12
  13 #ifdef __BORLANDC__
  14     #pragma hdrstop
  15 #endif
  16
  17 #if wxUSE_IMAGE && wxUSE_LIBTIFF
  18
  19 #include "wx/imagtiff.h"
  20
  21 #ifndef WX_PRECOMP
  22     #include "wx/log.h"
  23     #include "wx/app.h"
  24     #include "wx/intl.h"
  25     #include "wx/bitmap.h"
  26     #include "wx/module.h"
  27 #endif
  28
  29 extern "C"
  30 {
  31     #include "tiff.h"
  32     #include "tiffio.h"
  33 }
  34 #include "wx/filefn.h"
  35 #include "wx/wfstream.h"
  36
  37 #ifndef TIFFLINKAGEMODE
  38     #if defined(__WATCOMC__) && defined(__WXMGL__)
  39         #define TIFFLINKAGEMODE cdecl
  40     #else
  41         #define TIFFLINKAGEMODE LINKAGEMODE
  42     #endif
  43 #endif
  44
  45 //-----------------------------------------------------------------------------
  46 // wxTIFFHandler
  47 //-----------------------------------------------------------------------------
  48
  49 IMPLEMENT_DYNAMIC_CLASS(wxTIFFHandler,wxImageHandler)
  50
  51 #if wxUSE_STREAMS
  52
  53 // helper to translate our, possibly 64 bit, wxFileOffset to TIFF, always 32
  54 // bit, toff_t
  55 static toff_t wxFileOffsetToTIFF(wxFileOffset ofs)
  56 {
  57     if ( ofs == wxInvalidOffset )
  58         return (toff_t)-1;
  59
  60     toff_t tofs = wx_truncate_cast(toff_t, ofs);
  61     wxCHECK_MSG( (wxFileOffset)tofs == ofs, (toff_t)-1,
  62                     _T("TIFF library doesn't support large files") );
  63
  64     return tofs;
  65 }
  66
  67 // another helper to convert standard seek mode to our
  68 static wxSeekMode wxSeekModeFromTIFF(int whence)
  69 {
  70     switch ( whence )
  71     {
  72         case SEEK_SET:
  73             return wxFromStart;
  74
  75         case SEEK_CUR:
  76             return wxFromCurrent;
  77
  78         case SEEK_END:
  79             return wxFromEnd;
  80
  81         default:
  82             return wxFromCurrent;
  83     }
  84 }
  85
  86 extern "C"
  87 {
  88
  89 tsize_t TIFFLINKAGEMODE
  90 wxTIFFNullProc(thandle_t WXUNUSED(handle),
  91           tdata_t WXUNUSED(buf),
  92           tsize_t WXUNUSED(size))
  93 {
  94     return (tsize_t) -1;
  95 }
  96
  97 tsize_t TIFFLINKAGEMODE
  98 wxTIFFReadProc(thandle_t handle, tdata_t buf, tsize_t size)
  99 {
 100     wxInputStream *stream = (wxInputStream*) handle;
 101     stream->Read( (void*) buf, (size_t) size );
 102     return wx_truncate_cast(tsize_t, stream->LastRead());
 103 }
 104
 105 tsize_t TIFFLINKAGEMODE
 106 wxTIFFWriteProc(thandle_t handle, tdata_t buf, tsize_t size)
 107 {
 108     wxOutputStream *stream = (wxOutputStream*) handle;
 109     stream->Write( (void*) buf, (size_t) size );
 110     return wx_truncate_cast(tsize_t, stream->LastWrite());
 111 }
 112
 113 toff_t TIFFLINKAGEMODE
 114 wxTIFFSeekIProc(thandle_t handle, toff_t off, int whence)
 115 {
 116     wxInputStream *stream = (wxInputStream*) handle;
 117
 118     return wxFileOffsetToTIFF(stream->SeekI((wxFileOffset)off,
 119                                             wxSeekModeFromTIFF(whence)));
 120 }
 121
 122 toff_t TIFFLINKAGEMODE
 123 wxTIFFSeekOProc(thandle_t handle, toff_t off, int whence)
 124 {
 125     wxOutputStream *stream = (wxOutputStream*) handle;
 126
 127     return wxFileOffsetToTIFF(stream->SeekO((wxFileOffset)off,
 128                                             wxSeekModeFromTIFF(whence)));
 129 }
 130
 131 int TIFFLINKAGEMODE
 132 wxTIFFCloseIProc(thandle_t WXUNUSED(handle))
 133 {
 134     // there is no need to close the input stream
 135     return 0;
 136 }
 137
 138 int TIFFLINKAGEMODE
 139 wxTIFFCloseOProc(thandle_t handle)
 140 {
 141     wxOutputStream *stream = (wxOutputStream*) handle;
 142
 143     return stream->Close() ? 0 : -1;
 144 }
 145
 146 toff_t TIFFLINKAGEMODE
 147 wxTIFFSizeProc(thandle_t handle)
 148 {
 149     wxStreamBase *stream = (wxStreamBase*) handle;
 150     return (toff_t) stream->GetSize();
 151 }
 152
 153 int TIFFLINKAGEMODE
 154 wxTIFFMapProc(thandle_t WXUNUSED(handle),
 155              tdata_t* WXUNUSED(pbase),
 156              toff_t* WXUNUSED(psize))
 157 {
 158     return 0;
 159 }
 160
 161 void TIFFLINKAGEMODE
 162 wxTIFFUnmapProc(thandle_t WXUNUSED(handle),
 163                tdata_t WXUNUSED(base),
 164                toff_t WXUNUSED(size))
 165 {
 166 }
 167
 168 static void
 169 TIFFwxWarningHandler(const char* module,
 170                      const char* WXUNUSED_IN_UNICODE(fmt),
 171                      va_list WXUNUSED_IN_UNICODE(ap))
 172 {
 173     if (module != NULL)
 174         wxLogWarning(_("tiff module: %s"), wxString::FromAscii(module).c_str());
 175
 176     // FIXME: this is not terrible informative but better than crashing!
 177 #if wxUSE_UNICODE
 178     wxLogWarning(_("TIFF library warning."));
 179 #else
 180     wxVLogWarning(fmt, ap);
 181 #endif
 182 }
 183
 184 static void
 185 TIFFwxErrorHandler(const char* module,
 186                    const char* WXUNUSED_IN_UNICODE(fmt),
 187                    va_list WXUNUSED_IN_UNICODE(ap))
 188 {
 189     if (module != NULL)
 190         wxLogError(_("tiff module: %s"), wxString::FromAscii(module).c_str());
 191
 192     // FIXME: as above
 193 #if wxUSE_UNICODE
 194     wxLogError(_("TIFF library error."));
 195 #else
 196     wxVLogError(fmt, ap);
 197 #endif
 198 }
 199
 200 } // extern "C"
 201
 202 TIFF*
 203 TIFFwxOpen(wxInputStream &stream, const char* name, const char* mode)
 204 {
 205     TIFF* tif = TIFFClientOpen(name, mode,
 206         (thandle_t) &stream,
 207         wxTIFFReadProc, wxTIFFNullProc,
 208         wxTIFFSeekIProc, wxTIFFCloseIProc, wxTIFFSizeProc,
 209         wxTIFFMapProc, wxTIFFUnmapProc);
 210
 211     return tif;
 212 }
 213
 214 TIFF*
 215 TIFFwxOpen(wxOutputStream &stream, const char* name, const char* mode)
 216 {
 217     TIFF* tif = TIFFClientOpen(name, mode,
 218         (thandle_t) &stream,
 219         wxTIFFNullProc, wxTIFFWriteProc,
 220         wxTIFFSeekOProc, wxTIFFCloseOProc, wxTIFFSizeProc,
 221         wxTIFFMapProc, wxTIFFUnmapProc);
 222
 223     return tif;
 224 }
 225
 226 wxTIFFHandler::wxTIFFHandler()
 227 {
 228     m_name = wxT("TIFF file");
 229     m_extension = wxT("tif");
 230     m_type = wxBITMAP_TYPE_TIF;
 231     m_mime = wxT("image/tiff");
 232     TIFFSetWarningHandler((TIFFErrorHandler) TIFFwxWarningHandler);
 233     TIFFSetErrorHandler((TIFFErrorHandler) TIFFwxErrorHandler);
 234 }
 235
 236 bool wxTIFFHandler::LoadFile( wxImage *image, wxInputStream& stream, bool verbose, int index )
 237 {
 238     if (index == -1)
 239         index = 0;
 240
 241     image->Destroy();
 242
 243     TIFF *tif = TIFFwxOpen( stream, "image", "r" );
 244
 245     if (!tif)
 246     {
 247         if (verbose)
 248             wxLogError( _("TIFF: Error loading image.") );
 249
 250         return false;
 251     }
 252
 253     if (!TIFFSetDirectory( tif, (tdir_t)index ))
 254     {
 255         if (verbose)
 256             wxLogError( _("Invalid TIFF image index.") );
 257
 258         TIFFClose( tif );
 259
 260         return false;
 261     }
 262
 263     uint32 w, h;
 264     uint32 npixels;
 265     uint32 *raster;
 266
 267     TIFFGetField( tif, TIFFTAG_IMAGEWIDTH, &w );
 268     TIFFGetField( tif, TIFFTAG_IMAGELENGTH, &h );
 269
 270     npixels = w * h;
 271
 272     raster = (uint32*) _TIFFmalloc( npixels * sizeof(uint32) );
 273
 274     if (!raster)
 275     {
 276         if (verbose)
 277             wxLogError( _("TIFF: Couldn't allocate memory.") );
 278
 279         TIFFClose( tif );
 280
 281         return false;
 282     }
 283
 284     image->Create( (int)w, (int)h );
 285     if (!image->Ok())
 286     {
 287         if (verbose)
 288             wxLogError( _("TIFF: Couldn't allocate memory.") );
 289
 290         _TIFFfree( raster );
 291         TIFFClose( tif );
 292
 293         return false;
 294     }
 295
 296     if (!TIFFReadRGBAImage( tif, w, h, raster, 0 ))
 297     {
 298         if (verbose)
 299             wxLogError( _("TIFF: Error reading image.") );
 300
 301         _TIFFfree( raster );
 302         image->Destroy();
 303         TIFFClose( tif );
 304
 305         return false;
 306     }
 307
 308     bool hasmask = false;
 309
 310     unsigned char *ptr = image->GetData();
 311     ptr += w*3*(h-1);
 312     uint32 pos = 0;
 313
 314     for (uint32 i = 0; i < h; i++)
 315     {
 316         for (uint32 j = 0; j < w; j++)
 317         {
 318             unsigned char alpha = (unsigned char)TIFFGetA(raster[pos]);
 319             if (alpha < 127)
 320             {
 321                 hasmask = true;
 322                 ptr[0] = image->GetMaskRed();
 323                 ptr++;
 324                 ptr[0] = image->GetMaskGreen();
 325                 ptr++;
 326                 ptr[0] = image->GetMaskBlue();
 327                 ptr++;
 328             }
 329             else
 330             {
 331                 ptr[0] = (unsigned char)TIFFGetR(raster[pos]);
 332                 ptr++;
 333                 ptr[0] = (unsigned char)TIFFGetG(raster[pos]);
 334                 ptr++;
 335                 ptr[0] = (unsigned char)TIFFGetB(raster[pos]);
 336                 ptr++;
 337             }
 338             pos++;
 339         }
 340         ptr -= 2*w*3; // subtract line we just added plus one line
 341     }
 342
 343     _TIFFfree( raster );
 344
 345     TIFFClose( tif );
 346
 347     image->SetMask( hasmask );
 348
 349     return true;
 350 }
 351
 352 int wxTIFFHandler::GetImageCount( wxInputStream& stream )
 353 {
 354     TIFF *tif = TIFFwxOpen( stream, "image", "r" );
 355
 356     if (!tif)
 357         return 0;
 358
 359     int dircount = 0;  // according to the libtiff docs, dircount should be set to 1 here???
 360     do {
 361         dircount++;
 362     } while (TIFFReadDirectory(tif));
 363
 364     TIFFClose( tif );
 365
 366     return dircount;
 367 }
 368
 369 bool wxTIFFHandler::SaveFile( wxImage *image, wxOutputStream& stream, bool verbose )
 370 {
 371     TIFF *tif = TIFFwxOpen( stream, "image", "w" );
 372
 373     if (!tif)
 374     {
 375         if (verbose)
 376             wxLogError( _("TIFF: Error saving image.") );
 377
 378         return false;
 379     }
 380
 381     TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
 382     TIFFSetField(tif, TIFFTAG_IMAGEWIDTH,  (uint32)image->GetWidth());
 383     TIFFSetField(tif, TIFFTAG_IMAGELENGTH, (uint32)image->GetHeight());
 384     TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
 385     TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
 386
 387     if ( image->HasOption(wxIMAGE_OPTION_RESOLUTIONX) &&
 388             image->HasOption(wxIMAGE_OPTION_RESOLUTIONY) )
 389     {
 390         TIFFSetField(tif, TIFFTAG_XRESOLUTION,
 391                         (float)image->GetOptionInt(wxIMAGE_OPTION_RESOLUTIONX));
 392         TIFFSetField(tif, TIFFTAG_YRESOLUTION,
 393                         (float)image->GetOptionInt(wxIMAGE_OPTION_RESOLUTIONY));
 394     }
 395
 396     int spp = image->GetOptionInt(wxIMAGE_OPTION_SAMPLESPERPIXEL);
 397     if ( !spp )
 398         spp = 3;
 399
 400     int bpp = image->GetOptionInt(wxIMAGE_OPTION_BITSPERSAMPLE);
 401     if ( !bpp )
 402         bpp=8;
 403
 404     int compression = image->GetOptionInt(wxIMAGE_OPTION_COMPRESSION);
 405     if ( !compression )
 406     {
 407         // we can't use COMPRESSION_LZW because current version of libtiff
 408         // doesn't implement it ("no longer implemented due to Unisys patent
 409         // enforcement") and other compression methods are lossy so we
 410         // shouldn't use them by default -- and the only remaining one is none
 411         compression = COMPRESSION_NONE;
 412     }
 413
 414     TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, spp);
 415     TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, bpp);
 416     TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, spp*bpp == 1 ? PHOTOMETRIC_MINISBLACK
 417                                                         : PHOTOMETRIC_RGB);
 418     TIFFSetField(tif, TIFFTAG_COMPRESSION, compression);
 419
 420     // scanlinesize if determined by spp and bpp
 421     tsize_t linebytes = (tsize_t)image->GetWidth() * spp * bpp / 8;
 422
 423     if ( (image->GetWidth() % 8 > 0) && (spp * bpp < 8) )
 424         linebytes+=1;
 425
 426     unsigned char *buf;
 427
 428     if (TIFFScanlineSize(tif) > linebytes || (spp * bpp < 24))
 429     {
 430         buf = (unsigned char *)_TIFFmalloc(TIFFScanlineSize(tif));
 431         if (!buf)
 432         {
 433             if (verbose)
 434                 wxLogError( _("TIFF: Couldn't allocate memory.") );
 435
 436             TIFFClose( tif );
 437
 438             return false;
 439         }
 440     }
 441     else
 442     {
 443         buf = NULL;
 444     }
 445
 446     TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP,TIFFDefaultStripSize(tif, (uint32) -1));
 447
 448     unsigned char *ptr = image->GetData();
 449     for ( int row = 0; row < image->GetHeight(); row++ )
 450     {
 451         if ( buf )
 452         {
 453             if ( spp * bpp > 1 )
 454             {
 455                 // color image
 456                 memcpy(buf, ptr, image->GetWidth());
 457             }
 458             else // black and white image
 459             {
 460                 for ( int column = 0; column < linebytes; column++ )
 461                 {
 462                     uint8 reverse = 0;
 463                     for ( int bp = 0; bp < 8; bp++ )
 464                     {
 465                         if ( ptr[column*24 + bp*3] > 0 )
 466                         {
 467                             // check only red as this is sufficient
 468                             reverse = (uint8)(reverse | 128 >> bp);
 469                         }
 470                     }
 471
 472                     buf[column] = reverse;
 473                 }
 474             }
 475         }
 476
 477         if ( TIFFWriteScanline(tif, buf ? buf : ptr, (uint32)row, 0) < 0 )
 478         {
 479             if (verbose)
 480                 wxLogError( _("TIFF: Error writing image.") );
 481
 482             TIFFClose( tif );
 483             if (buf)
 484                 _TIFFfree(buf);
 485
 486             return false;
 487         }
 488
 489         ptr += image->GetWidth()*3;
 490     }
 491
 492     (void) TIFFClose(tif);
 493
 494     if (buf)
 495         _TIFFfree(buf);
 496
 497     return true;
 498 }
 499
 500 bool wxTIFFHandler::DoCanRead( wxInputStream& stream )
 501 {
 502     unsigned char hdr[2];
 503
 504     if ( !stream.Read(&hdr[0], WXSIZEOF(hdr)) )
 505         return false;
 506
 507     return (hdr[0] == 'I' && hdr[1] == 'I') ||
 508            (hdr[0] == 'M' && hdr[1] == 'M');
 509 }
 510
 511 #endif  // wxUSE_STREAMS
 512
 513 #endif  // wxUSE_LIBTIFF