5d4d8a9b620bf9cc3c20dd3fccfcaeae70bd5b44
[occt.git] / src / Image / Image_AlienPixMap.cxx
1 // Created on: 2010-09-16
2 // Created by: KGV
3 // Copyright (c) 2010-2014 OPEN CASCADE SAS
4 //
5 // This file is part of Open CASCADE Technology software library.
6 //
7 // This library is free software; you can redistribute it and/or modify it under
8 // the terms of the GNU Lesser General Public License version 2.1 as published
9 // by the Free Software Foundation, with special exception defined in the file
10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11 // distribution for complete text of the license and disclaimer of any warranty.
12 //
13 // Alternatively, this file may be used under the terms of Open CASCADE
14 // commercial license or contractual agreement.
15
16 #if !defined(HAVE_FREEIMAGE) && defined(_WIN32)
17   #define HAVE_WINCODEC
18 #endif
19
20 #ifdef HAVE_FREEIMAGE
21   #include <FreeImage.h>
22
23   #ifdef _MSC_VER
24     #pragma comment( lib, "FreeImage.lib" )
25   #endif
26 #elif defined(HAVE_WINCODEC)
27   #include <wincodec.h>
28   // prevent warnings on MSVC10
29   #include <Standard_WarningsDisable.hxx>
30   #include <Standard_TypeDef.hxx>
31   #include <Standard_WarningsRestore.hxx>
32   #undef min
33   #undef max
34
35   #ifdef _MSC_VER
36     #pragma comment(lib, "Ole32.lib")
37   #endif
38 #endif
39
40 #include <Image_AlienPixMap.hxx>
41 #include <gp.hxx>
42 #include <Message.hxx>
43 #include <Message_Messenger.hxx>
44 #include <NCollection_Array1.hxx>
45 #include <Standard_ArrayStreamBuffer.hxx>
46 #include <TCollection_AsciiString.hxx>
47 #include <TCollection_ExtendedString.hxx>
48 #include <OSD_OpenFile.hxx>
49
50 #include <fstream>
51 #include <algorithm>
52
53 IMPLEMENT_STANDARD_RTTIEXT(Image_AlienPixMap,Image_PixMap)
54
55 namespace
56 {
57 #ifdef HAVE_FREEIMAGE
58   static Image_Format convertFromFreeFormat (FREE_IMAGE_TYPE       theFormatFI,
59                                              FREE_IMAGE_COLOR_TYPE theColorTypeFI,
60                                              unsigned              theBitsPerPixel)
61   {
62     switch (theFormatFI)
63     {
64       case FIT_RGBF:   return Image_Format_RGBF;
65       case FIT_RGBAF:  return Image_Format_RGBAF;
66       case FIT_FLOAT:  return Image_Format_GrayF;
67       case FIT_BITMAP:
68       {
69         switch (theColorTypeFI)
70         {
71           case FIC_MINISBLACK:
72           {
73             return Image_Format_Gray;
74           }
75           case FIC_RGB:
76           {
77             if (Image_PixMap::IsBigEndianHost())
78             {
79               return (theBitsPerPixel == 32) ? Image_Format_RGB32 : Image_Format_RGB;
80             }
81             else
82             {
83               return (theBitsPerPixel == 32) ? Image_Format_BGR32 : Image_Format_BGR;
84             }
85           }
86           case FIC_RGBALPHA:
87           {
88             return Image_PixMap::IsBigEndianHost() ? Image_Format_RGBA : Image_Format_BGRA;
89           }
90           default:
91             return Image_Format_UNKNOWN;
92         }
93       }
94       default:
95         return Image_Format_UNKNOWN;
96     }
97   }
98
99   static FREE_IMAGE_TYPE convertToFreeFormat (Image_Format theFormat)
100   {
101     switch (theFormat)
102     {
103       case Image_Format_GrayF:
104       case Image_Format_AlphaF:
105         return FIT_FLOAT;
106       case Image_Format_RGBAF:
107         return FIT_RGBAF;
108       case Image_Format_RGBF:
109         return FIT_RGBF;
110       case Image_Format_RGBA:
111       case Image_Format_BGRA:
112       case Image_Format_RGB32:
113       case Image_Format_BGR32:
114       case Image_Format_RGB:
115       case Image_Format_BGR:
116       case Image_Format_Gray:
117       case Image_Format_Alpha:
118         return FIT_BITMAP;
119       default:
120         return FIT_UNKNOWN;
121     }
122   }
123
124   //! Wrapper for accessing C++ stream from FreeImage.
125   class Image_FreeImageStream
126   {
127   public:
128     //! Construct wrapper over input stream.
129     Image_FreeImageStream (std::istream& theStream)
130     : myIStream (&theStream), myOStream (NULL), myInitPos (theStream.tellg()) {}
131
132     //! Get io object.
133     FreeImageIO GetFiIO() const
134     {
135       FreeImageIO anIo;
136       memset (&anIo, 0, sizeof(anIo));
137       if (myIStream != NULL)
138       {
139         anIo.read_proc = readProc;
140         anIo.seek_proc = seekProc;
141         anIo.tell_proc = tellProc;
142       }
143       if (myOStream != NULL)
144       {
145         anIo.write_proc = writeProc;
146       }
147       return anIo;
148     }
149   public:
150     //! Simulate fread().
151     static unsigned int DLL_CALLCONV readProc (void* theBuffer, unsigned int theSize, unsigned int theCount, fi_handle theHandle)
152     {
153       Image_FreeImageStream* aThis = (Image_FreeImageStream* )theHandle;
154       if (aThis->myIStream == NULL)
155       {
156         return 0;
157       }
158
159       if (!aThis->myIStream->read ((char* )theBuffer, std::streamsize(theSize) * std::streamsize(theCount)))
160       {
161         //aThis->myIStream->clear();
162       }
163       const std::streamsize aNbRead = aThis->myIStream->gcount();
164       return (unsigned int )(aNbRead / theSize);
165     }
166
167     //! Simulate fwrite().
168     static unsigned int DLL_CALLCONV writeProc (void* theBuffer, unsigned int theSize, unsigned int theCount, fi_handle theHandle)
169     {
170       Image_FreeImageStream* aThis = (Image_FreeImageStream* )theHandle;
171       if (aThis->myOStream != NULL
172        && aThis->myOStream->write ((const char* )theBuffer, std::streamsize(theSize) * std::streamsize(theCount)))
173       {
174         return theCount;
175       }
176       return 0;
177     }
178
179     //! Simulate fseek().
180     static int DLL_CALLCONV seekProc (fi_handle theHandle, long theOffset, int theOrigin)
181     {
182       Image_FreeImageStream* aThis = (Image_FreeImageStream* )theHandle;
183       if (aThis->myIStream == NULL)
184       {
185         return -1;
186       }
187
188       bool isSeekDone = false;
189       switch (theOrigin)
190       {
191         case SEEK_SET:
192           if (aThis->myIStream->seekg ((std::streamoff )aThis->myInitPos + theOffset, std::ios::beg))
193           {
194             isSeekDone = true;
195           }
196           break;
197         case SEEK_CUR:
198           if (aThis->myIStream->seekg (theOffset, std::ios::cur))
199           {
200             isSeekDone = true;
201           }
202           break;
203         case SEEK_END:
204           if (aThis->myIStream->seekg (theOffset, std::ios::end))
205           {
206             isSeekDone = true;
207           }
208           break;
209       }
210       return isSeekDone ? 0 : -1;
211     }
212
213     //! Simulate ftell().
214     static long DLL_CALLCONV tellProc (fi_handle theHandle)
215     {
216       Image_FreeImageStream* aThis = (Image_FreeImageStream* )theHandle;
217       const long aPos = aThis->myIStream != NULL ? (long )(aThis->myIStream->tellg() - aThis->myInitPos) : 0;
218       return aPos;
219     }
220   private:
221     std::istream*  myIStream;
222     std::ostream*  myOStream;
223     std::streampos myInitPos;
224   };
225
226 #elif defined(HAVE_WINCODEC)
227
228   //! Return a zero GUID
229   static GUID getNullGuid()
230   {
231     GUID aGuid = { 0, 0, 0, { 0, 0, 0, 0, 0, 0, 0, 0 } };
232     return aGuid;
233   }
234
235   //! Sentry over IUnknown pointer.
236   template<class T> class Image_ComPtr
237   {
238   public:
239     //! Empty constructor.
240     Image_ComPtr()
241     : myPtr (NULL) {}
242
243     //! Destructor.
244     ~Image_ComPtr()
245     {
246       Nullify();
247     }
248
249     //! Return TRUE if pointer is NULL.
250     bool IsNull() const { return myPtr == NULL; }
251
252     //! Release the pointer.
253     void Nullify()
254     {
255       if (myPtr != NULL)
256       {
257         myPtr->Release();
258         myPtr = NULL;
259       }
260     }
261
262     //! Return pointer for initialization.
263     T*& ChangePtr()
264     {
265       Standard_ASSERT_RAISE (myPtr == NULL, "Pointer cannot be initialized twice!");
266       return myPtr;
267     }
268
269     //! Return pointer.
270     T* get() { return myPtr; }
271
272     //! Return pointer.
273     T* operator->() { return get(); }
274
275     //! Cast handle to contained type
276     T& operator*() { return *get(); }
277
278   private:
279     T* myPtr;
280   };
281
282   //! Convert WIC GUID to Image_Format.
283   static Image_Format convertFromWicFormat (const WICPixelFormatGUID& theFormat)
284   {
285     if (theFormat == GUID_WICPixelFormat32bppBGRA)
286     {
287       return Image_Format_BGRA;
288     }
289     else if (theFormat == GUID_WICPixelFormat32bppBGR)
290     {
291       return Image_Format_BGR32;
292     }
293     else if (theFormat == GUID_WICPixelFormat24bppRGB)
294     {
295       return Image_Format_RGB;
296     }
297     else if (theFormat == GUID_WICPixelFormat24bppBGR)
298     {
299       return Image_Format_BGR;
300     }
301     else if (theFormat == GUID_WICPixelFormat8bppGray)
302     {
303       return Image_Format_Gray;
304     }
305     return Image_Format_UNKNOWN;
306   }
307
308   //! Convert Image_Format to WIC GUID.
309   static WICPixelFormatGUID convertToWicFormat (Image_Format theFormat)
310   {
311     switch (theFormat)
312     {
313       case Image_Format_BGRA:   return GUID_WICPixelFormat32bppBGRA;
314       case Image_Format_BGR32:  return GUID_WICPixelFormat32bppBGR;
315       case Image_Format_RGB:    return GUID_WICPixelFormat24bppRGB;
316       case Image_Format_BGR:    return GUID_WICPixelFormat24bppBGR;
317       case Image_Format_Gray:   return GUID_WICPixelFormat8bppGray;
318       case Image_Format_Alpha:  return GUID_WICPixelFormat8bppGray; // GUID_WICPixelFormat8bppAlpha
319       case Image_Format_GrayF:  // GUID_WICPixelFormat32bppGrayFloat
320       case Image_Format_AlphaF:
321       case Image_Format_RGBAF:  // GUID_WICPixelFormat128bppRGBAFloat
322       case Image_Format_RGBF:   // GUID_WICPixelFormat96bppRGBFloat
323       case Image_Format_RGBA:   // GUID_WICPixelFormat32bppRGBA
324       case Image_Format_RGB32:  // GUID_WICPixelFormat32bppRGB
325       default:
326         return getNullGuid();
327     }
328   }
329
330 #endif
331 }
332
333 // =======================================================================
334 // function : Image_AlienPixMap
335 // purpose  :
336 // =======================================================================
337 Image_AlienPixMap::Image_AlienPixMap()
338 : myLibImage (NULL)
339 {
340   SetTopDown (false);
341 }
342
343 // =======================================================================
344 // function : ~Image_AlienPixMap
345 // purpose  :
346 // =======================================================================
347 Image_AlienPixMap::~Image_AlienPixMap()
348 {
349   Clear();
350 }
351
352 // =======================================================================
353 // function : InitWrapper
354 // purpose  :
355 // =======================================================================
356 bool Image_AlienPixMap::InitWrapper (Image_Format,
357                                      Standard_Byte*,
358                                      const Standard_Size,
359                                      const Standard_Size,
360                                      const Standard_Size)
361 {
362   Clear();
363   return false;
364 }
365
366 // =======================================================================
367 // function : InitTrash
368 // purpose  :
369 // =======================================================================
370 #ifdef HAVE_FREEIMAGE
371 bool Image_AlienPixMap::InitTrash (Image_Format        thePixelFormat,
372                                    const Standard_Size theSizeX,
373                                    const Standard_Size theSizeY,
374                                    const Standard_Size /*theSizeRowBytes*/)
375 {
376   Clear();
377   FREE_IMAGE_TYPE aFormatFI = convertToFreeFormat (thePixelFormat);
378   int aBitsPerPixel = (int )Image_PixMap::SizePixelBytes (thePixelFormat) * 8;
379   if (aFormatFI == FIT_UNKNOWN)
380   {
381     aFormatFI     = FIT_BITMAP;
382     aBitsPerPixel = 24;
383   }
384
385   FIBITMAP* anImage = FreeImage_AllocateT (aFormatFI, (int )theSizeX, (int )theSizeY, aBitsPerPixel);
386   Image_Format aFormat = convertFromFreeFormat (FreeImage_GetImageType(anImage),
387                                                 FreeImage_GetColorType(anImage),
388                                                 FreeImage_GetBPP      (anImage));
389   if (thePixelFormat == Image_Format_BGR32
390    || thePixelFormat == Image_Format_RGB32)
391   {
392     //FreeImage_SetTransparent (anImage, FALSE);
393     aFormat = (aFormat == Image_Format_BGRA) ? Image_Format_BGR32 : Image_Format_RGB32;
394   }
395
396   Image_PixMap::InitWrapper (aFormat, FreeImage_GetBits (anImage),
397                              FreeImage_GetWidth (anImage), FreeImage_GetHeight (anImage), FreeImage_GetPitch (anImage));
398   SetTopDown (false);
399
400   // assign image after wrapper initialization (virtual Clear() called inside)
401   myLibImage = anImage;
402   return true;
403 }
404 #elif defined(HAVE_WINCODEC)
405 bool Image_AlienPixMap::InitTrash (Image_Format        thePixelFormat,
406                                    const Standard_Size theSizeX,
407                                    const Standard_Size theSizeY,
408                                    const Standard_Size theSizeRowBytes)
409 {
410   Clear();
411   Image_Format aFormat = thePixelFormat;
412   switch (aFormat)
413   {
414     case Image_Format_RGB:
415       aFormat = Image_Format_BGR;
416       break;
417     case Image_Format_RGB32:
418       aFormat = Image_Format_BGR32;
419       break;
420     case Image_Format_RGBA:
421       aFormat = Image_Format_BGRA;
422       break;
423     default:
424       break;
425   }
426
427   if (!Image_PixMap::InitTrash (aFormat, theSizeX, theSizeY, theSizeRowBytes))
428   {
429     return false;
430   }
431   SetTopDown (true);
432   return true;
433 }
434 #else
435 bool Image_AlienPixMap::InitTrash (Image_Format        thePixelFormat,
436                                    const Standard_Size theSizeX,
437                                    const Standard_Size theSizeY,
438                                    const Standard_Size theSizeRowBytes)
439 {
440   return Image_PixMap::InitTrash (thePixelFormat, theSizeX, theSizeY, theSizeRowBytes);
441 }
442 #endif
443
444 // =======================================================================
445 // function : InitCopy
446 // purpose  :
447 // =======================================================================
448 bool Image_AlienPixMap::InitCopy (const Image_PixMap& theCopy)
449 {
450   if (&theCopy == this)
451   {
452     // self-copying disallowed
453     return false;
454   }
455   if (!InitTrash (theCopy.Format(), theCopy.SizeX(), theCopy.SizeY(), theCopy.SizeRowBytes()))
456   {
457     return false;
458   }
459
460   if (myImgFormat == theCopy.Format())
461   {
462     if (SizeRowBytes() == theCopy.SizeRowBytes()
463      && TopDownInc()   == theCopy.TopDownInc())
464     {
465       // copy with one call
466       memcpy (ChangeData(), theCopy.Data(), std::min (SizeBytes(), theCopy.SizeBytes()));
467       return true;
468     }
469
470     // copy row-by-row
471     const Standard_Size aRowSizeBytes = std::min (SizeRowBytes(), theCopy.SizeRowBytes());
472     for (Standard_Size aRow = 0; aRow < myData.SizeY; ++aRow)
473     {
474       memcpy (ChangeRow (aRow), theCopy.Row (aRow), aRowSizeBytes);
475     }
476     return true;
477   }
478
479   // pixel format conversion required
480   Clear();
481   return false;
482 }
483
484 // =======================================================================
485 // function : Clear
486 // purpose  :
487 // =======================================================================
488 void Image_AlienPixMap::Clear()
489 {
490   Image_PixMap::Clear();
491 #ifdef HAVE_FREEIMAGE
492   if (myLibImage != NULL)
493   {
494     FreeImage_Unload (myLibImage);
495     myLibImage = NULL;
496   }
497 #endif
498 }
499
500 // =======================================================================
501 // function : IsTopDownDefault
502 // purpose  :
503 // =======================================================================
504 bool Image_AlienPixMap::IsTopDownDefault()
505 {
506 #ifdef HAVE_FREEIMAGE
507   return false;
508 #elif defined(HAVE_WINCODEC)
509   return true;
510 #else
511   return false;
512 #endif
513 }
514
515 // =======================================================================
516 // function : Load
517 // purpose  :
518 // =======================================================================
519 #ifdef HAVE_FREEIMAGE
520 bool Image_AlienPixMap::Load (const Standard_Byte* theData,
521                               Standard_Size theLength,
522                               const TCollection_AsciiString& theImagePath)
523 {
524   Clear();
525
526 #ifdef _WIN32
527   const TCollection_ExtendedString aFileNameW (theImagePath);
528 #endif
529   FREE_IMAGE_FORMAT aFIF = FIF_UNKNOWN;
530   FIMEMORY* aFiMem = NULL;
531   if (theData != NULL)
532   {
533     aFiMem = FreeImage_OpenMemory ((BYTE* )theData, (DWORD )theLength);
534     aFIF = FreeImage_GetFileTypeFromMemory (aFiMem, 0);
535   }
536   else
537   {
538   #ifdef _WIN32
539     aFIF = FreeImage_GetFileTypeU (aFileNameW.ToWideString(), 0);
540   #else
541     aFIF = FreeImage_GetFileType (theImagePath.ToCString(), 0);
542   #endif
543   }
544   if (aFIF == FIF_UNKNOWN)
545   {
546     // no signature? try to guess the file format from the file extension
547     aFIF = FreeImage_GetFIFFromFilename (theImagePath.ToCString());
548   }
549   if ((aFIF == FIF_UNKNOWN) || !FreeImage_FIFSupportsReading (aFIF))
550   {
551     ::Message::DefaultMessenger()->Send (TCollection_AsciiString ("Error: image '") + theImagePath + "' has unsupported file format.",
552                                          Message_Fail);
553     if (aFiMem != NULL)
554     {
555       FreeImage_CloseMemory (aFiMem);
556     }
557     return false;
558   }
559
560   int aLoadFlags = 0;
561   if (aFIF == FIF_GIF)
562   {
563     // 'Play' the GIF to generate each frame (as 32bpp) instead of returning raw frame data when loading
564     aLoadFlags = GIF_PLAYBACK;
565   }
566   else if (aFIF == FIF_ICO)
567   {
568     // convert to 32bpp and create an alpha channel from the AND-mask when loading
569     aLoadFlags = ICO_MAKEALPHA;
570   }
571
572   FIBITMAP* anImage = NULL;
573   if (theData != NULL)
574   {
575     anImage = FreeImage_LoadFromMemory (aFIF, aFiMem, aLoadFlags);
576     FreeImage_CloseMemory (aFiMem);
577     aFiMem = NULL;
578   }
579   else
580   {
581   #ifdef _WIN32
582     anImage = FreeImage_LoadU (aFIF, aFileNameW.ToWideString(), aLoadFlags);
583   #else
584     anImage = FreeImage_Load  (aFIF, theImagePath.ToCString(), aLoadFlags);
585   #endif
586   }
587   if (anImage == NULL)
588   {
589     TCollection_AsciiString aMessage = "Error: image file '";
590     aMessage.AssignCat (theImagePath);
591     aMessage.AssignCat ("' is missing or invalid.");
592     ::Message::DefaultMessenger()->Send (aMessage, Message_Fail);
593     return false;
594   }
595
596   if (FreeImage_GetBPP (anImage) == 1)
597   {
598     FIBITMAP* aTmpImage = FreeImage_ConvertTo8Bits (anImage);
599     FreeImage_Unload (anImage);
600     anImage = aTmpImage;
601   }
602
603   Image_Format aFormat = convertFromFreeFormat (FreeImage_GetImageType(anImage),
604                                                 FreeImage_GetColorType(anImage),
605                                                 FreeImage_GetBPP      (anImage));
606   if (aFormat == Image_Format_UNKNOWN)
607   {
608     //anImage = FreeImage_ConvertTo24Bits (anImage);
609     ::Message::DefaultMessenger()->Send (    TCollection_AsciiString ("Error: image '") + theImagePath + "' has unsupported pixel format.",
610                                          Message_Fail);
611     return false;
612   }
613
614   Image_PixMap::InitWrapper (aFormat, FreeImage_GetBits (anImage),
615                              FreeImage_GetWidth (anImage), FreeImage_GetHeight (anImage), FreeImage_GetPitch (anImage));
616   SetTopDown (false);
617
618   // assign image after wrapper initialization (virtual Clear() called inside)
619   myLibImage = anImage;
620   return true;
621 }
622
623 bool Image_AlienPixMap::Load (std::istream& theStream,
624                               const TCollection_AsciiString& theFileName)
625 {
626   Clear();
627
628   Image_FreeImageStream aStream (theStream);
629   FreeImageIO aFiIO = aStream.GetFiIO();
630
631   FREE_IMAGE_FORMAT aFIF = FreeImage_GetFileTypeFromHandle (&aFiIO, &aStream, 0);
632   if (aFIF == FIF_UNKNOWN)
633   {
634     // no signature? try to guess the file format from the file extension
635     aFIF = FreeImage_GetFIFFromFilename (theFileName.ToCString());
636   }
637   if ((aFIF == FIF_UNKNOWN) || !FreeImage_FIFSupportsReading (aFIF))
638   {
639     ::Message::DefaultMessenger()->Send (TCollection_AsciiString ("Error: image stream '") + theFileName + "' has unsupported file format.",
640                                          Message_Fail);
641     return false;
642   }
643
644   int aLoadFlags = 0;
645   if (aFIF == FIF_GIF)
646   {
647     // 'Play' the GIF to generate each frame (as 32bpp) instead of returning raw frame data when loading
648     aLoadFlags = GIF_PLAYBACK;
649   }
650   else if (aFIF == FIF_ICO)
651   {
652     // convert to 32bpp and create an alpha channel from the AND-mask when loading
653     aLoadFlags = ICO_MAKEALPHA;
654   }
655
656   FIBITMAP* anImage = FreeImage_LoadFromHandle (aFIF, &aFiIO, &aStream, aLoadFlags);
657   if (anImage == NULL)
658   {
659     ::Message::DefaultMessenger()->Send (TCollection_AsciiString ("Error: image stream '") + theFileName + "' is missing or invalid.",
660                                          Message_Fail);
661     return false;
662   }
663
664   Image_Format aFormat = convertFromFreeFormat (FreeImage_GetImageType(anImage),
665                                                 FreeImage_GetColorType(anImage),
666                                                 FreeImage_GetBPP      (anImage));
667   if (aFormat == Image_Format_UNKNOWN)
668   {
669     ::Message::DefaultMessenger()->Send (TCollection_AsciiString ("Error: image stream '") + theFileName + "' has unsupported pixel format.",
670                                          Message_Fail);
671     return false;
672   }
673
674   Image_PixMap::InitWrapper (aFormat, FreeImage_GetBits (anImage),
675                              FreeImage_GetWidth (anImage), FreeImage_GetHeight (anImage), FreeImage_GetPitch (anImage));
676   SetTopDown (false);
677
678   // assign image after wrapper initialization (virtual Clear() called inside)
679   myLibImage = anImage;
680   return true;
681 }
682
683 #elif defined(HAVE_WINCODEC)
684 bool Image_AlienPixMap::Load (const Standard_Byte* theData,
685                               Standard_Size theLength,
686                               const TCollection_AsciiString& theFileName)
687 {
688   Clear();
689
690   Image_ComPtr<IWICImagingFactory> aWicImgFactory;
691   CoInitializeEx (NULL, COINIT_MULTITHREADED);
692   if (CoCreateInstance (CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&aWicImgFactory.ChangePtr())) != S_OK)
693   {
694     Message::DefaultMessenger()->Send ("Error: cannot initialize WIC Imaging Factory", Message_Fail);
695     return false;
696   }
697
698   Image_ComPtr<IWICBitmapDecoder> aWicDecoder;
699   Image_ComPtr<IWICStream> aWicStream;
700   if (theData != NULL)
701   {
702     if (aWicImgFactory->CreateStream (&aWicStream.ChangePtr()) != S_OK
703      || aWicStream->InitializeFromMemory ((BYTE* )theData, (DWORD )theLength) != S_OK)
704     {
705       Message::DefaultMessenger()->Send ("Error: cannot initialize WIC Stream", Message_Fail);
706       return false;
707     }
708     if (aWicImgFactory->CreateDecoderFromStream (aWicStream.get(), NULL, WICDecodeMetadataCacheOnDemand, &aWicDecoder.ChangePtr()) != S_OK)
709     {
710       Message::DefaultMessenger()->Send ("Error: cannot create WIC Image Decoder", Message_Fail);
711       return false;
712     }
713   }
714   else
715   {
716     const TCollection_ExtendedString aFileNameW (theFileName);
717     if (aWicImgFactory->CreateDecoderFromFilename (aFileNameW.ToWideString(), NULL, GENERIC_READ, WICDecodeMetadataCacheOnDemand, &aWicDecoder.ChangePtr()) != S_OK)
718     {
719       Message::DefaultMessenger()->Send ("Error: cannot create WIC Image Decoder", Message_Fail);
720       return false;
721     }
722   }
723
724   UINT aFrameCount = 0, aFrameSizeX = 0, aFrameSizeY = 0;
725   WICPixelFormatGUID aWicPixelFormat = getNullGuid();
726   Image_ComPtr<IWICBitmapFrameDecode> aWicFrameDecode;
727   if (aWicDecoder->GetFrameCount (&aFrameCount) != S_OK
728    || aFrameCount < 1
729    || aWicDecoder->GetFrame (0, &aWicFrameDecode.ChangePtr()) != S_OK
730    || aWicFrameDecode->GetSize (&aFrameSizeX, &aFrameSizeY) != S_OK
731    || aWicFrameDecode->GetPixelFormat (&aWicPixelFormat))
732   {
733     Message::DefaultMessenger()->Send ("Error: cannot get WIC Image Frame", Message_Fail);
734     return false;
735   }
736
737   Image_ComPtr<IWICFormatConverter> aWicConvertedFrame;
738   Image_Format aPixelFormat = convertFromWicFormat (aWicPixelFormat);
739   if (aPixelFormat == Image_Format_UNKNOWN)
740   {
741     aPixelFormat = Image_Format_RGB;
742     if (aWicImgFactory->CreateFormatConverter (&aWicConvertedFrame.ChangePtr()) != S_OK
743      || aWicConvertedFrame->Initialize (aWicFrameDecode.get(), convertToWicFormat (aPixelFormat), WICBitmapDitherTypeNone, NULL, 0.0f, WICBitmapPaletteTypeCustom) != S_OK)
744     {
745       Message::DefaultMessenger()->Send ("Error: cannot convert WIC Image Frame to RGB format", Message_Fail);
746       return false;
747     }
748     aWicFrameDecode.Nullify();
749   }
750
751   if (!Image_PixMap::InitTrash (aPixelFormat, aFrameSizeX, aFrameSizeY))
752   {
753     Message::DefaultMessenger()->Send ("Error: cannot initialize memory for image", Message_Fail);
754     return false;
755   }
756
757   IWICBitmapSource* aWicSrc = aWicFrameDecode.get();
758   if(!aWicConvertedFrame.IsNull())
759   {
760     aWicSrc = aWicConvertedFrame.get();
761   }
762   if (aWicSrc->CopyPixels (NULL, (UINT )SizeRowBytes(), (UINT )SizeBytes(), ChangeData()) != S_OK)
763   {
764     Message::DefaultMessenger()->Send ("Error: cannot copy pixels from WIC Image", Message_Fail);
765     return false;
766   }
767   SetTopDown (true);
768   return true;
769 }
770 bool Image_AlienPixMap::Load (std::istream& theStream,
771                               const TCollection_AsciiString& theFilePath)
772 {
773   Clear();
774
775   // fallback copying stream data into transient buffer
776   const std::streamoff aStart = theStream.tellg();
777   theStream.seekg (0, std::ios::end);
778   const Standard_Integer aLen = Standard_Integer(theStream.tellg() - aStart);
779   theStream.seekg (aStart);
780   if (aLen <= 0)
781   {
782     Message::DefaultMessenger()->Send ("Error: empty stream", Message_Fail);
783     return false;
784   }
785
786   NCollection_Array1<Standard_Byte> aBuff (1, aLen);
787   if (!theStream.read ((char* )&aBuff.ChangeFirst(), aBuff.Size()))
788   {
789     Message::DefaultMessenger()->Send ("Error: unable to read stream", Message_Fail);
790     return false;
791   }
792
793   return Load (&aBuff.ChangeFirst(), aBuff.Size(), theFilePath);
794 }
795 #else
796 bool Image_AlienPixMap::Load (std::istream& ,
797                               const TCollection_AsciiString& )
798 {
799   Clear();
800   Message::DefaultMessenger()->Send ("Error: no image library available", Message_Fail);
801   return false;
802 }
803 bool Image_AlienPixMap::Load (const Standard_Byte* ,
804                               Standard_Size ,
805                               const TCollection_AsciiString& )
806 {
807   Clear();
808   Message::DefaultMessenger()->Send ("Error: no image library available", Message_Fail);
809   return false;
810 }
811 #endif
812
813 // =======================================================================
814 // function : savePPM
815 // purpose  :
816 // =======================================================================
817 bool Image_AlienPixMap::savePPM (const TCollection_AsciiString& theFileName) const
818 {
819   if (IsEmpty())
820   {
821     return false;
822   }
823
824   // Open file
825   FILE* aFile = OSD_OpenFile (theFileName.ToCString(), "wb");
826   if (aFile == NULL)
827   {
828     return false;
829   }
830
831   // Write header
832   fprintf (aFile, "P6\n%d %d\n255\n", (int )SizeX(), (int )SizeY());
833   fprintf (aFile, "# Image stored by OpenCASCADE framework in linear RGB colorspace\n");
834
835   // Write pixel data
836   Standard_Byte aByte;
837   for (Standard_Size aRow = 0; aRow < SizeY(); ++aRow)
838   {
839     for (Standard_Size aCol = 0; aCol < SizeX(); ++aCol)
840     {
841       // extremely SLOW but universal (implemented for all supported pixel formats)
842       const Quantity_ColorRGBA aColor = PixelColor ((Standard_Integer )aCol, (Standard_Integer )aRow);
843       aByte = Standard_Byte(aColor.GetRGB().Red()   * 255.0); fwrite (&aByte, 1, 1, aFile);
844       aByte = Standard_Byte(aColor.GetRGB().Green() * 255.0); fwrite (&aByte, 1, 1, aFile);
845       aByte = Standard_Byte(aColor.GetRGB().Blue()  * 255.0); fwrite (&aByte, 1, 1, aFile);
846     }
847   }
848
849   // Close file
850   fclose (aFile);
851   return true;
852 }
853
854 // =======================================================================
855 // function : Save
856 // purpose  :
857 // =======================================================================
858 bool Image_AlienPixMap::Save (const TCollection_AsciiString& theFileName)
859 {
860 #ifdef HAVE_FREEIMAGE
861   if (myLibImage == NULL)
862   {
863     return false;
864   }
865
866 #ifdef _WIN32
867   const TCollection_ExtendedString aFileNameW (theFileName.ToCString(), Standard_True);
868   FREE_IMAGE_FORMAT anImageFormat = FreeImage_GetFIFFromFilenameU (aFileNameW.ToWideString());
869 #else
870   FREE_IMAGE_FORMAT anImageFormat = FreeImage_GetFIFFromFilename (theFileName.ToCString());
871 #endif
872   if (anImageFormat == FIF_UNKNOWN)
873   {
874 #ifdef OCCT_DEBUG
875     std::cerr << "Image_PixMap, image format doesn't supported!\n";
876 #endif
877     return false;
878   }
879
880   if (IsTopDown())
881   {
882     FreeImage_FlipVertical (myLibImage);
883     SetTopDown (false);
884   }
885
886   // FreeImage doesn't provide flexible format conversion API
887   // so we should perform multiple conversions in some cases!
888   FIBITMAP* anImageToDump = myLibImage;
889   switch (anImageFormat)
890   {
891     case FIF_PNG:
892     case FIF_BMP:
893     {
894       if (Format() == Image_Format_BGR32
895        || Format() == Image_Format_RGB32)
896       {
897         // stupid FreeImage treats reserved byte as alpha if some bytes not set to 0xFF
898         for (Standard_Size aRow = 0; aRow < SizeY(); ++aRow)
899         {
900           for (Standard_Size aCol = 0; aCol < SizeX(); ++aCol)
901           {
902             myData.ChangeValue (aRow, aCol)[3] = 0xFF;
903           }
904         }
905       }
906       else if (FreeImage_GetImageType (myLibImage) != FIT_BITMAP)
907       {
908         anImageToDump = FreeImage_ConvertToType (myLibImage, FIT_BITMAP);
909       }
910       break;
911     }
912     case FIF_GIF:
913     {
914       FIBITMAP* aTmpBitmap = myLibImage;
915       if (FreeImage_GetImageType (myLibImage) != FIT_BITMAP)
916       {
917         aTmpBitmap = FreeImage_ConvertToType (myLibImage, FIT_BITMAP);
918         if (aTmpBitmap == NULL)
919         {
920           return false;
921         }
922       }
923
924       if (FreeImage_GetBPP (aTmpBitmap) != 24)
925       {
926         FIBITMAP* aTmpBitmap24 = FreeImage_ConvertTo24Bits (aTmpBitmap);
927         if (aTmpBitmap != myLibImage)
928         {
929           FreeImage_Unload (aTmpBitmap);
930         }
931         if (aTmpBitmap24 == NULL)
932         {
933           return false;
934         }
935         aTmpBitmap = aTmpBitmap24;
936       }
937
938       // need conversion to image with palette (requires 24bit bitmap)
939       anImageToDump = FreeImage_ColorQuantize (aTmpBitmap, FIQ_NNQUANT);
940       if (aTmpBitmap != myLibImage)
941       {
942         FreeImage_Unload (aTmpBitmap);
943       }
944       break;
945     }
946     case FIF_HDR:
947     case FIF_EXR:
948     {
949       if (Format() == Image_Format_Gray
950        || Format() == Image_Format_Alpha)
951       {
952         anImageToDump = FreeImage_ConvertToType (myLibImage, FIT_FLOAT);
953       }
954       else if (Format() == Image_Format_RGBA
955             || Format() == Image_Format_BGRA)
956       {
957         anImageToDump = FreeImage_ConvertToType (myLibImage, FIT_RGBAF);
958       }
959       else
960       {
961         FREE_IMAGE_TYPE aImgTypeFI = FreeImage_GetImageType (myLibImage);
962         if (aImgTypeFI != FIT_RGBF
963          && aImgTypeFI != FIT_RGBAF
964          && aImgTypeFI != FIT_FLOAT)
965         {
966           anImageToDump = FreeImage_ConvertToType (myLibImage, FIT_RGBF);
967         }
968       }
969       break;
970     }
971     default:
972     {
973       if (FreeImage_GetImageType (myLibImage) != FIT_BITMAP)
974       {
975         anImageToDump = FreeImage_ConvertToType (myLibImage, FIT_BITMAP);
976         if (anImageToDump == NULL)
977         {
978           return false;
979         }
980       }
981
982       if (FreeImage_GetBPP (anImageToDump) != 24)
983       {
984         FIBITMAP* aTmpBitmap24 = FreeImage_ConvertTo24Bits (anImageToDump);
985         if (anImageToDump != myLibImage)
986         {
987           FreeImage_Unload (anImageToDump);
988         }
989         if (aTmpBitmap24 == NULL)
990         {
991           return false;
992         }
993         anImageToDump = aTmpBitmap24;
994       }
995       break;
996     }
997   }
998
999   if (anImageToDump == NULL)
1000   {
1001     return false;
1002   }
1003
1004 #ifdef _WIN32
1005   bool isSaved = (FreeImage_SaveU (anImageFormat, anImageToDump, aFileNameW.ToWideString()) != FALSE);
1006 #else
1007   bool isSaved = (FreeImage_Save  (anImageFormat, anImageToDump, theFileName.ToCString()) != FALSE);
1008 #endif
1009   if (anImageToDump != myLibImage)
1010   {
1011     FreeImage_Unload (anImageToDump);
1012   }
1013   return isSaved;
1014
1015 #elif defined(HAVE_WINCODEC)
1016
1017   TCollection_AsciiString aFileNameLower = theFileName;
1018   aFileNameLower.LowerCase();
1019   GUID aFileFormat = getNullGuid();
1020   if (aFileNameLower.EndsWith (".ppm"))
1021   {
1022     return savePPM (theFileName);
1023   }
1024   else if (aFileNameLower.EndsWith (".bmp"))
1025   {
1026     aFileFormat = GUID_ContainerFormatBmp;
1027   }
1028   else if (aFileNameLower.EndsWith (".png"))
1029   {
1030     aFileFormat = GUID_ContainerFormatPng;
1031   }
1032   else if (aFileNameLower.EndsWith (".jpg")
1033         || aFileNameLower.EndsWith (".jpeg"))
1034   {
1035     aFileFormat = GUID_ContainerFormatJpeg;
1036   }
1037   else if (aFileNameLower.EndsWith (".tiff"))
1038   {
1039     aFileFormat = GUID_ContainerFormatTiff;
1040   }
1041   else if (aFileNameLower.EndsWith (".gif"))
1042   {
1043     aFileFormat = GUID_ContainerFormatGif;
1044   }
1045
1046   if (aFileFormat == getNullGuid())
1047   {
1048     Message::DefaultMessenger()->Send ("Error: unsupported image format", Message_Fail);
1049     return false;
1050   }
1051
1052   Image_ComPtr<IWICImagingFactory> aWicImgFactory;
1053   CoInitializeEx (NULL, COINIT_MULTITHREADED);
1054   if (CoCreateInstance (CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&aWicImgFactory.ChangePtr())) != S_OK)
1055   {
1056     Message::DefaultMessenger()->Send ("Error: cannot initialize WIC Imaging Factory", Message_Fail);
1057     return false;
1058   }
1059
1060   Image_ComPtr<IWICStream> aWicFileStream;
1061   Image_ComPtr<IWICBitmapEncoder> aWicEncoder;
1062   const TCollection_ExtendedString aFileNameW (theFileName);
1063   if (aWicImgFactory->CreateStream (&aWicFileStream.ChangePtr()) != S_OK
1064    || aWicFileStream->InitializeFromFilename (aFileNameW.ToWideString(), GENERIC_WRITE) != S_OK)
1065   {
1066     Message::DefaultMessenger()->Send ("Error: cannot create WIC File Stream", Message_Fail);
1067     return false;
1068   }
1069   if (aWicImgFactory->CreateEncoder (aFileFormat, NULL, &aWicEncoder.ChangePtr()) != S_OK
1070    || aWicEncoder->Initialize (aWicFileStream.get(), WICBitmapEncoderNoCache) != S_OK)
1071   {
1072     Message::DefaultMessenger()->Send ("Error: cannot create WIC Encoder", Message_Fail);
1073     return false;
1074   }
1075
1076   const WICPixelFormatGUID aWicPixelFormat = convertToWicFormat (myImgFormat);
1077   if (aWicPixelFormat == getNullGuid())
1078   {
1079     Message::DefaultMessenger()->Send ("Error: unsupported pixel format", Message_Fail);
1080     return false;
1081   }
1082
1083   WICPixelFormatGUID aWicPixelFormatRes = aWicPixelFormat;
1084   Image_ComPtr<IWICBitmapFrameEncode> aWicFrameEncode;
1085   if (aWicEncoder->CreateNewFrame (&aWicFrameEncode.ChangePtr(), NULL) != S_OK
1086    || aWicFrameEncode->Initialize (NULL) != S_OK
1087    || aWicFrameEncode->SetSize ((UINT )SizeX(), (UINT )SizeY()) != S_OK
1088    || aWicFrameEncode->SetPixelFormat (&aWicPixelFormatRes) != S_OK)
1089   {
1090     Message::DefaultMessenger()->Send ("Error: cannot create WIC Frame", Message_Fail);
1091     return false;
1092   }
1093
1094   if (aWicPixelFormatRes != aWicPixelFormat)
1095   {
1096     Message::DefaultMessenger()->Send ("Error: pixel format is unsupported by image format", Message_Fail);
1097     return false;
1098   }
1099
1100   if (IsTopDown())
1101   {
1102     if (aWicFrameEncode->WritePixels ((UINT )SizeY(), (UINT )SizeRowBytes(), (UINT )SizeBytes(), (BYTE* )Data()) != S_OK)
1103     {
1104       Message::DefaultMessenger()->Send ("Error: cannot write pixels to WIC Frame", Message_Fail);
1105       return false;
1106     }
1107   }
1108   else
1109   {
1110     for (Standard_Size aRow = 0; aRow < SizeY(); ++aRow)
1111     {
1112       if (aWicFrameEncode->WritePixels (1, (UINT )SizeRowBytes(), (UINT )SizeRowBytes(), (BYTE* )Row (aRow)) != S_OK)
1113       {
1114         Message::DefaultMessenger()->Send ("Error: cannot write pixels to WIC Frame", Message_Fail);
1115         return false;
1116       }
1117     }
1118   }
1119
1120   if (aWicFrameEncode->Commit() != S_OK
1121    || aWicEncoder->Commit() != S_OK)
1122   {
1123     Message::DefaultMessenger()->Send ("Error: cannot commit data to WIC Frame", Message_Fail);
1124     return false;
1125   }
1126   if (aWicFileStream->Commit (STGC_DEFAULT) != S_OK)
1127   {
1128     //Message::DefaultMessenger()->Send ("Error: cannot commit data to WIC File Stream", Message_Fail);
1129     //return false;
1130   }
1131   return true;
1132 #else
1133   const Standard_Integer aLen = theFileName.Length();
1134   if ((aLen >= 4) && (theFileName.Value (aLen - 3) == '.')
1135       && strcasecmp( theFileName.ToCString() + aLen - 3, "ppm") == 0 )
1136   {
1137     return savePPM (theFileName);
1138   }
1139 #ifdef OCCT_DEBUG
1140   std::cerr << "Image_PixMap, no image library available! Image saved in PPM format.\n";
1141 #endif
1142   return savePPM (theFileName);
1143 #endif
1144 }
1145
1146 // =======================================================================
1147 // function : AdjustGamma
1148 // purpose  :
1149 // =======================================================================
1150 bool Image_AlienPixMap::AdjustGamma (const Standard_Real theGammaCorr)
1151 {
1152 #ifdef HAVE_FREEIMAGE
1153   return FreeImage_AdjustGamma (myLibImage, theGammaCorr) != FALSE;
1154 #else
1155   (void )theGammaCorr;
1156   return false;
1157 #endif
1158 }