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