[-p ps2|gc|xbox|cross] [-f vag|gcadpcm|xadpcm|pcm|source] [-m s|m|i] [-d] [-r 0|1] [-h] [-b] [-?] [-a]
+
+ -o dest Destination FSB file/directory
+ source Source directory or list file
+ -p ps2|gc|xbox|cross Target platform (default = cross)
+ -f vag|gcadpcm|xadpcm|pcm|source|adpcm Target format (default = pcm)
+ -m s|m|i Build mode :
+ s = Single FSB (default)
+ m = Multiple FSBs
+ i = single Interleaved FSB
+ -d Rebuild dir structure (Multiple FSB only) (default = off)
+ -r 0|1 Disable reverbcore 0 or 1 (ps2 only) (default = both enabled)
+ -h Hidden mode - don't display the FSBank window at all (default = off)
+ -b Use small headers (default = off)
+ -a Abort compilation if an error is encountered (default = off)
+ -? Display command line help
+
+OutputDebugString is used to display errors and progress while in hidden mode.
+
+
+8. Support
+----------
+Write to support@fmod.org for questions and help.
diff --git a/freeimage241/Docs/10.html b/freeimage241/Docs/10.html
new file mode 100644
index 0000000..fe8b3b8
--- /dev/null
+++ b/freeimage241/Docs/10.html
@@ -0,0 +1,184 @@
+
+Plugin functions
+
+
+From version 2.1.0 on FreeImage provides a new, simplified interface besides the old style API.
+
+
+
+The new API, known as the plugin API, treats bitmap formats and their accompanied loader and saver routines as plugin modules. A new series of functions provides access to these plugins. For example the new functions provide the means to retrieve a list of supported bitmap formats, as well as their descriptions and their possible file extensions. The new API has many advantages over the old one.
+
+
+
+For a start the plugin interface will enable FreeImage's hot swap technology: a feature that allows you to compile and link the library only once in your program making instantly profit from bug fixes, newly supported bitmap formats and more without ever recompiling again. Second it opens the way to use plugins. You won't have these advantages when you use the standard API.
+
+
+
Subsections FreeImage_GetFIFByIndex
+
+
+FREE_IMAGE_FORMAT FreeImage_GetFIFByIndex(int index);
+
+
+
+Returns the needed plugin id in the plugin list. The plugin list is sorted on the format string.
+
+
FreeImage_GetFIFCount
+
+
+int FreeImage_GetFIFCount();
+
+
+
+Returns the number of supported bitmap formats.
+
+
FreeImage_GetFIFFromFormat
+
+
+FREE_IMAGE_FORMAT FreeImage_GetFIFFromFormat(const char *format);
+
+
+
+Returns the FreeImage format ID for the given format string.
+
+
FreeImage_GetFormatFromFIF
+
+
+const char *FreeImage_GetFormatFromFIF(FREE_IMAGE_FORMAT fif);
+
+
+
+Returns a format string for the given FreeImage Format ID.
+
+
FreeImage_GetFIFExtensionList
+
+
+const char *FreeImage_GetFIFExtensionList(FREE_IMAGE_FORMAT fif);
+
+
+
+Returns a list of possible file extension for the given FreeImage Format ID. The extension list is a string containing one or more comma separated file extensions.
+
+
+FreeImage_GetFIFDescription
+
+
+
+const char *FreeImage_GetFIFDescription(FREE_IMAGE_FORMAT fif);
+
+
+
+Returns a descriptive string for the given FreeImage Format ID.
+
+
FreeImage_GetFIFRegExpr
+
+
+const char *FreeImage_GetFIFRegExpr(FREE_IMAGE_FORMAT fif);
+
+
+
+Returns a regular expression for the given FreeImage Format ID, assisting external libraries to identify the bitmap format. Currently FreeImageQt uses this function.
+
+
+FreeImage_GetFIFFromFilename
+
+
+
+FREE_IMAGE_FORMAT FreeImage_GetFIFFromFilename(const char *filename);
+
+
+
+Tries to identify a bitmap type by looking at the filename or a file extension. FreeImage_GetFIFFromFilename returns a valid FreeImage Format ID on success and FIF_UNKNOWN on failure.
+
+
+FreeImage_FIFSupportsReading
+
+
+
+BOOL FreeImage_FIFSupportsReading(FREE_IMAGE_FORMAT fif);
+
+
+
+Returns true if the plugin belonging to this FreeImage Format ID supports reading, false otherwise.
+
+
FreeImage_FIFSupportsWriting
+
+
+BOOL FreeImage_FIFSupportsWriting(FREE_IMAGE_FORMAT fif);
+
+
+
+Returns true if the plugin belonging to this FreeImage Format ID supports writing, false otherwise.
+
+
FreeImage_LoadFromHandle
+
+
+FIBITMAP * FreeImage_LoadFromHandle(FREE_IMAGE_FORMAT fif, FreeImageIO *io, fi_handle handle, int flags FI_DEFAULT(0));
+
+
+
+Loads a bitmap file into a FreeImage bitmap using the specified FreeImageIO struct and fi_handle. If the file is loaded successfully, memory for it is allocated and a bitmap pointer is returned. If the file couldn't be loaded, FreeImage_LoadFromHandle returns NULL.
+
+
+
+The fif parameter specifies the desired bitmap format to be loaded. The parameter accepts any valid FreeImage Format ID, such as FIF_BMP or FIF_JPEG, or an integer value obtained from any of the plugin interface functions.
+
+
+FreeImage_Load
+
+
+
+FIBITMAP *DLL_CALLCONV FreeImage_Load(FREE_IMAGE_FORMAT fif, const char *filename, int flags FI_DEFAULT(0));
+
+
+
+Loads the bitmap file into a FreeImage bitmap. If the bitmap is loaded successfully, memory for it is allocated and a bitmap pointer is returned. If the bitmap couldn't be loaded, FreeImage_Load returns NULL.
+
+
FreeImage_SaveToHandle
+
+
+BOOL FreeImage_SaveToHandle(FREE_IMAGE_FORMAT fif, FIBITMAP *dib, FreeImageIO *io, fi_handle handle, int flags FI_DEFAULT(0));
+
+
+
+Saves the FreeImage DIB to a bitmap file of the given type.
+
+
FreeImage_Save
+
+
+BOOL FreeImage_Save(FREE_IMAGE_FORMAT fif, FIBITMAP *dib, const char *filename, int flags FI_DEFAULT(0));
+
+
+
+Saves the FreeImage DIB to a bitmap file of the given type.
+
+
diff --git a/freeimage241/Docs/102.html b/freeimage241/Docs/102.html
new file mode 100644
index 0000000..ba47ea0
--- /dev/null
+++ b/freeimage241/Docs/102.html
@@ -0,0 +1,25 @@
+
+Extra functions
+
+
+FreeImage supports a number of additional functions you can use to manipulate FIBITMAPs.
+
+
+
Subsections FreeImage_Combine
+
+
+void FreeImage_Combine(FIBITMAP *target, FIBITMAP *source, int x, int y, int alpha FI_DEFAULT(255));
+
+
+
+Combines the source and target bitmap and stores the result in the target bitmap. Optionally an alpha blend value can be specified to blend the two bitmaps together.
+
+
diff --git a/freeimage241/Docs/104.html b/freeimage241/Docs/104.html
new file mode 100644
index 0000000..bec247a
--- /dev/null
+++ b/freeimage241/Docs/104.html
@@ -0,0 +1,30 @@
+
+FreeImageQt functions
+
+
Subsections Introduction
+
+
+FreeImageQt is the binding of the DLL to TrollTech's Qt library. Qt is a sophisticated c++ programming framework for Windows and Unix, used primarily for the creation of graphical user interface. The framework many powerful objects, better known as widgets, which make programming GUIs considerably easier.
+
+
+
+Qt provides several objects used to deal with graphics. The most interesting objects to FreeImage are Qimage and QimageIO, because these are the objects that FreeImage hooks. By hooking these two objects, FreeImage provides its enormous list of supported bitmap types to Qt, while keeping the generic interface for loading bitmaps in that library intact. As a Qt programmer you won't notice that you are using FreeImage. And that is the strength of it.
+
+
diff --git a/freeimage241/Docs/106.html b/freeimage241/Docs/106.html
new file mode 100644
index 0000000..be50fd6
--- /dev/null
+++ b/freeimage241/Docs/106.html
@@ -0,0 +1,180 @@
+
+
+Functions
+
+
+
+FreeImageQt supports the following functions. Note that in average use you only need FIQT_Register to use this library.
+
+
+
Subsections FIQT_Register
+
+
+bool FIQT_Register(bool new_formats_only = false);
+
+
+
+Registers the FreeImage load functions in Qt and returns true if successful. If new_formats_only is true, only the bitmap formats not supported by Qt are registered. Else all bitmap formats supported by FreeImage are registered. You have to call this function to take advantage of FreeImage.
+
+
FIQT_Unregister
+
+
+void FIQT_Unregister();
+
+
+
+Removes all binding between FreeImage and Qt. You shouldn't normally have to call this function. It is called automatically on program exit.
+
+
FIQT_IsLoaded
+
+
+Bool FIQT_IsLoaded();
+
+
+
+Returns true if FreeImage was successfully registered into Qt's bitmap functionality handler, false otherwise.
+
+
FIQT_GetVersion
+
+
+const char *FIQT_GetVersion();
+
+
+
+Returns the version string of the library.
+
+
FIQT_GetCopyrightMessage
+
+
+const char *FIQT_GetVersion();
+
+
+
+Returns a short copyright message you can include in your program.
+
+
FIQT_GetFIFCount
+
+
+int FIQT_GetFIFCount();
+
+
+
+Returns the number of supported bitmap formats.
+
+
FIQT_GetFIFFromFormat
+
+
+FREE_IMAGE_FORMAT FIQT_GetFIFFromFormat(const char *format);
+
+
+
+Returns the FreeImage format ID for the given format string.
+
+
FIQT_GetFormatFromFIF
+
+
+const char *FIQT_GetFormatFromFIF(FREE_IMAGE_FORMAT fif);
+
+
+
+Returns a format string for the given FreeImage Format ID.
+
+
FIQT_GetFIFExtensionList
+
+
+const char *FIQT_GetFIFExtensionList(FREE_IMAGE_FORMAT fif);
+
+
+
+Returns a list of possible file extension for the given FreeImage Format ID. The extension list is a string containing one or more comma separated file extensions.
+
+
FIQT_GetFIFDescription
+
+
+const char *FIQT_GetFIFDescription(FREE_IMAGE_FORMAT fif);
+
+
+
+Returns a descriptive string for the given FreeImage Format ID.
+
+
FIQT_GetFIFFromFilename
+
+
+FREE_IMAGE_FORMAT FIQT_GetFIFFromFilename(const char *filename);
+
+
+
+Tries to identify a bitmap type by looking at the filename or a file extension. FreeImage_GetFIFFromFilename returns a valid FreeImage Format ID on success and FIF_UNKNOWN on failure.
+
+
FIQT_FIFSupportsReading
+
+
+BOOL FIQT_FIFSupportsReading(FREE_IMAGE_FORMAT fif);
+
+
+
+Returns true if the plugin belonging to this FreeImage Format ID supports reading, false otherwise.
+
+
FIQT_FIFSupportsWriting
+
+
+BOOL FIQT_FIFSupportsWriting(FREE_IMAGE_FORMAT fif);
+
+
+
+Returns true if the plugin belonging to this FreeImage Format ID supports writing, false otherwise.
+
+
FIQT_GetFileTypeFromFormat
+
+
+const char *FIQT_GetFileTypeFromFormat(FREE_IMAGE_FORMAT fif);
+
+
+
+This function is deprecated. FIQT_GetFIFFromFormat has replaced its functionality.
+
+
FIQT_GetFormatFromExtension
+
+
+const char *FIQT_GetFormatFromExtension(const char *extension);
+
+
+
+Returns a FreeImage Format string for the given file extension.
+
+
diff --git a/freeimage241/Docs/122.html b/freeimage241/Docs/122.html
new file mode 100644
index 0000000..8a8766e
--- /dev/null
+++ b/freeimage241/Docs/122.html
@@ -0,0 +1,4 @@
+
+Index
+[ A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z ]
+
\ No newline at end of file
diff --git a/freeimage241/Docs/2.html b/freeimage241/Docs/2.html
new file mode 100644
index 0000000..c14f4bc
--- /dev/null
+++ b/freeimage241/Docs/2.html
@@ -0,0 +1,148 @@
+
+
+FreeImage functions
+
+
+
Subsections Simple load functions
+
+
Subsections FreeImage_LoadBMP
+
+
+FIBITMAP *FreeImage_LoadBMP(const char *filename, int flags = BMP_DEFAULT);
+
+
+
+Loads the given Windows Bitmap file or OS/2 Bitmap file into a FreeImage bitmap. If the bitmap is loaded successfully, memory for it is allocated and a bitmap pointer is returned. If the bitmap couldn't be loaded, FreeImage_LoadBMP returns NULL.
+
+
+
+FIBITMAP *dib = FreeImage_LoadBMP("test.bmp");
+
+
FreeImage_LoadICO
+
+
+FIBITMAP *FreeImage_LoadICO(const char *filename, int flags = ICO_DEFAULT);
+
+
+
+Loads the given Windows ICON file into a FreeImage bitmap. If the icon is loaded successfully, memory for it is allocated and a bitmap pointer is returned. If the bitmap couldn't be loaded, FreeImage_LoadICO returns NULL.
+
+
+
+Flags defaults to ICO_DEFAULT. The following parameters can be passed to change the behaviour of the load routine:
+
+
+
+FIBITMAP *dib = FreeImage_LoadICO("test.ico");
+
+
Value Meaning
+
+
+
+
+
ICO_FIRST Loads the first icon in the cabinet ICO_SECOND Loads the second icon in the cabinet ICO_THIRD Loads the third icon in the cabinet
+
FreeImage_LoadJPEG
+
+
+FIBITMAP *FreeImage_LoadJPEG(const char *filename, int flags = JPEG_DEFAULT);
+
+
+
+Loads the given JPEG or JIF file into a FreeImage bitmap. If the file is loaded successfully, memory for it is allocated and a bitmap pointer is returned. If the file couldn't be loaded, FreeImage_LoadJPEG returns NULL.
+
+
+
+Flags defaults to JPEG_DEFAULT. The following parameters can be passed to the flags parameter to change the behaviour of the load routine:
+
+
+
+FIBITMAP *dib = FreeImage_LoadJPEG("test.jpg");
+
+
Value Meaning
+
+
+
+
+
JPEG_FAST Loads the file as fast as possible, sacrificing some quality. JPEG_ACCURATE Loads the file as accurate as possible, sacrificing some speed.
FreeImage_LoadKOALA
+
+
+FIBITMAP *FreeImage_LoadKOALA(const char *filename, int flags = KOALA_DEFAULT);
+
+
+
+Loads the given KOALA file into a FreeImage bitmap. If the file is loaded successfully, memory for it is allocated and a bitmap pointer is returned. If the file couldn't be loaded, FreeImage_LoadKOALA returns NULL
+
+
+
+KOALA is a 4-bit bitmap format developed for and supported by ancient commodore 64 computers and emulators. The format is supported for nostalgic reasons of the author.
+
+
+
+FIBITMAP *dib = FreeImage_LoadKOALA("test.koa");
+
+
FreeImage_LoadLBM
+
+
+FIBITMAP *FreeImage_LoadLBM(const char *filename, int flags = LBM_DEFAULT);
+
+
+
+Loads the given Deluxe Paint LBM file into a FreeImage bitmap. If the file is loaded successfully, memory for it is allocated and a bitmap pointer is returned. If the file couldn't be loaded, FreeImage_LoadLBM returns NULL
+
+
+FreeImage_LoadMNG
+
+
+
+FIBITMAP *FreeImage_LoadMNG(const char *filename, int flags = MNG_DEFAULT);
+
+
+
+Loads the given Multi Network Graphics (MNG) or JPEG Network Graphics (JNG) file into a FreeImage bitmap. If the file is loaded successfully, memory for it is allocated and a bitmap pointer is returned. If the file couldn't be loaded, FreeImage_LoadMNG returns NULL
+
+
FreeImage_LoadPCD
+
+
+FIBITMAP *FreeImage_LoadPCD(const char *filename, int flags = PCD_DEFAULT);
+
+
+
+Loads the given Kodak PhotoCD file into a FreeImage bitmap. If the file is loaded successfully, memory for it is allocated and a bitmap pointer is returned. If the file couldn't be loaded, FreeImage_LoadPCD returns NULL.
+
+
+
+PhotoCD images are so called cabinet files, where several versions of the same bitmap exist in one file. By default FreeImage loads the image marked in the flags as PCD_BASE. By using the flags parameter other image versions can be obtained:
+
+
+
+FIBITMAP *dib = FreeImage_LoadPCD("test.pcd");
+
+
Value Meaning
+
+
+
+
+
PCD_BASE 24-bit, 768 x 512 pixels PCD_BASEDIV4 24-bit, 192 x 128 pixels PCD_BASEDIV16 24-bit. 384 x 256 pixels
+
FreeImage_LoadPCX
+
+
+FIBITMAP *FreeImage_LoadPCX(const char *filename, int flags = PCX_DEFAULT);
+
+
+
+Loads the given PCX file into a FreeImage bitmap. If the file is loaded successfully, memory for it is allocated and a bitmap pointer is returned. If the file couldn't be loaded, FreeImage_LoadPCX returns NULL.
+
+
+
+FIBITMAP *dib = FreeImage_LoadPCX("test.pcx");
+
+
FreeImage_LoadPNM
+
+
+FIBITMAP *FreeImage_LoadPNM(const char *filename, PNMFlags flags = PNM_DEFAULT);
+
+
+
+Loads one of the PNM supported bitmap files into a FreeImage bitmap. If the file is loaded successfully, memory for it is allocated and a bitmap pointer is returned. If the file couldn't be loaded, FreeImage_LoadPNM returns NULL.
+
+
+
+PNM is a descriptive name for a collection of ASCII based bitmap types: PBM, PGM and PPM. PBM (Portable Bitmap format) is a 1-bit, black and white bitmap type, PGM (Portable Greymap format) is an 8-bit greyscale bitmap type and PPM (Portable Pixelmap format) is a 24-bit full colour bitmap. FreeImage automatically detects if you are dealing with a PBM, PGM or PPM bitmap and will load it in the default bit depth of that particular image.
+
+
+
+FIBITMAP *dib = FreeImage_LoadPNM("test.ppm");
FreeImage_LoadPNG
+
+
+FIBITMAP *FreeImage_LoadPNG(const char *filename, int flags = PNG_DEFAULT);
+
+
+
+Loads the given PNG file into a FreeImage bitmap. If the file is loaded successfully, memory for it is allocated and a bitmap pointer is returned. If the file couldn't be loaded, FreeImage_LoadPNG returns NULL.
+
+
+
+FIBITMAP *dib = FreeImage_LoadPNG("test.png");
+
+
FreeImage_LoadRAS
+
+
+FIBITMAP *FreeImage_LoadRAS(const char *filename, int flags = RAS_DEFAULT);
+
+
+
+Loads the given Sun rasterfile into a FreeImage bitmap. If the file is loaded successfully, memory for it is allocated and a bitmap pointer is returned. If the file couldn't be loaded, FreeImage_LoadRAS returns NULL.
+
+
+
+FIBITMAP *dib = FreeImage_LoadRAS("test.ras");
+
+
FreeImage_LoadTARGA
+
+
+FIBITMAP *FreeImage_LoadTARGA(const char *filename, int flags = TARGA_DEFAULT);
+
+
+
+Loads the given TARGA file into a FreeImage bitmap. If the file is loaded successfully, memory for it is allocated and a bitmap pointer is returned. If the file couldn't be loaded, FreeImage_LoadTARGA returns NULL.
+
+
+
+Flags defaults to TARGA_DEFAULT. The flags parameter can be passed the following values to change the behaviour of the load plugin:
+
+
+
+FIBITMAP *dib = FreeImage_LoadTARGA("test.tga");
+
+
Value Meaning
+
+
+
+
+
TARGA_LOAD_RGB888 If the TARGA file is 16 or 32-bit, it is automatically converted to 24-bit.
FreeImage_LoadTIFF
+
+
+FIBITMAP *FreeImage_LoadTIFF(const char *filename, int flags = TIFF_DEFAULT);
+
+
+
+Loads the given TIFF file into a FreeImage bitmap. If the file is loaded successfully, memory for it is allocated and a bitmap pointer is returned. If the file couldn't be loaded, FreeImage_LoadTIFF returns NULL.
+
+
+
+FIBITMAP *dib = FreeImage_LoadTIFF("test.tiff");
+
+
FreeImage_LoadWBMP
+
+
+FIBITMAP *FreeImage_LoadWBMP(const char *filename, int flags = WBMP_DEFAULT);
+
+
+
+Loads the given WBMP or WAP file into a FreeImage bitmap. If the file is loaded successfully, memory for it is allocated and a bitmap pointer is returned. If the file couldn't be loaded, FreeImage_LoadWBMP returns NULL.
+
+
diff --git a/freeimage241/Docs/3.html b/freeimage241/Docs/3.html
new file mode 100644
index 0000000..5edae25
--- /dev/null
+++ b/freeimage241/Docs/3.html
@@ -0,0 +1,37 @@
+
+Initialisation
+
+
+When the FreeImage is loaded, there has to be allocated data internally to address the various plugins. The initialisation functions are responsible for that task. Note that in the precompiled DLL version the initialisation functions are automatically called. You normally don't need to initialise FreeImage (but it doesn't hurt when you do)
+
+
+
Subsections
+FreeImage_Initialise
+
+
+
+void FreeImage_Initialise();
+
+
+
+Initialises the library.
+
+
FreeImage_DeInitialise
+
+
+void FreeImage_DeInitialise();
+
+
+
+DeInitialises the library.
+
+
diff --git a/freeimage241/Docs/40.html b/freeimage241/Docs/40.html
new file mode 100644
index 0000000..ab824be
--- /dev/null
+++ b/freeimage241/Docs/40.html
@@ -0,0 +1,297 @@
+
+
+Advanced load functions
+
+
+
+FreeImage_LoadFromHandle functions are slightly more advanced than the simple load functions, but still quite easy to use. The idea of these functions is that FreeImage doesn't care how it gets its data as long as it gets it. It shouldn't matter if the bitmap is loaded from file, memory or the Internet since data is data not matter where it comes from.
+
+
+
+To make this idea of data abstraction work a new, abstract file I/O system is used: FreeImageIO . FreeImageIO is a structure containing pointers to 4 functions: a read function, write function, seek function and tell function. All these functions have to be implemented so that data is delivered. The handle representing the data is made abstract as well and is named fi_handle .
+
+
+
+Loading a bitmap using the ...FromHandle functions involves four things. First the 4 file I/O functions are implemented and a FreeImageIO structure is filled with the pointers. Then the file is opened (that is, if we are in fact dealing with a file). After that one of the ...LoadFromHandle functions can be called. If the bitmap is successfully loaded the file has to be closed.
+
+
+
+unsigned
+
+
+
+_ReadProc(FIBITMAP *buffer, unsigned s, unsigned c, fi_handle handle) {
+
+
+
+return fread(buffer, s, c, (FILE *)handle);
+
+
+
+}
+
+
+
+unsigned
+
+
+
+_WriteProc(FIBITMAP *buffer, unsigned s, unsigned c, fi_handle handle){
+
+
+
+return fwrite(buffer, s, c, (FILE *)handle);
+
+
+
+}
+
+
+
+int
+
+
+
+_SeekProc(fi_handle handle, long offset, int origin) {
+
+
+
+return fseek((FILE *)handle, offset, origin);
+
+
+
+}
+
+
+
+long
+
+
+
+_TellProc(fi_handle handle) {
+
+
+
+return ftell((FILE *)handle);
+
+
+
+}
+
+
+
+FreeImageIO io;
+
+
+
+io.read_proc = _ReadProc;
+
+
+
+io.write_proc = _WriteProc;
+
+
+
+io.seek_proc = _SeekProc;
+
+
+
+io.tell_proc = _TellProc;
+
+
+
+FILE *file = fopen("test.bmp", "rb");
+
+
+
+if (file != NULL) {
+
+
+
+FIBITMAP *dib = FreeImage_LoadBMPFromHandle(&io, (fi_handle)file);
+
+
+
+FreeImage_Free(dib);
+
+
+
+fclose(file);
+
+
+
+}
+
+
+
Subsections FreeImage_LoadBMPFromHandle
+
+
+FIBITMAP *FreeImage_LoadBMPFromHandle(FreeImageIO *io, fi_handle handle, int flags = BMP_DEFAULT);
+
+
+
+Loads the given BMP file into a FreeImage bitmap using the specified FreeImageIO struct and fi_handle. If the file is loaded successfully, memory for it is allocated and a bitmap pointer is returned. If the file couldn't be loaded, FreeImage_LoadBMPFromHandle returns NULL.
+
+
+FreeImage_LoadICOFromHandle
+
+
+
+FIBITMAP *FreeImage_LoadICOFromHandle(FreeImageIO *io, fi_handle handle, int flags = ICO_DEFAULT);
+
+
+
+Loads the given ICO file into a FreeImage bitmap using the given FreeImageIO struct and fi_handle. If the file is loaded successfully, memory for it is allocated and a bitmap pointer is returned. If the file couldn't be loaded, FreeImage_LoadICOFromHandle returns NULL.
+
+
FreeImage_LoadJPEGFromHandle
+
+
+FIBITMAP *FreeImage_LoadJPEGFromHandle(FreeImageIO *io, fi_handle handle, int flags = JPEG_DEFAULT);
+
+
+
+Loads the given JPEG file into a FreeImage bitmap using the specified FreeImageIO struct and fi_handle. If the file is loaded successfully, memory for it is allocated and a bitmap pointer is returned. If the file couldn't be loaded, FreeImage_LoadJPEGFromHandle returns NULL.
+
+
+FreeImage_LoadKOALAFromHandle
+
+
+
+FIBITMAP *FreeImage_LoadKOALAFromHandle(FreeImageIO *io, fi_handle handle, int flags = KOALA_DEFAULT);
+
+
+
+Loads the given KOALA file into a FreeImage bitmap using the specified FreeImageIO struct and fi_handle. If the file is loaded successfully, memory for it is allocated and a bitmap pointer is returned. If the file couldn't be loaded, FreeImage_LoadKOALAFromHandle returns NULL.
+
+
+FreeImage_LoadLBMFromHandle
+
+
+
+FIBITMAP *FreeImage_LoadLBMFromHandle(FreeImageIO *io, fi_handle handle, int flags = LBM_DEFAULT);
+
+
+
+Loads the given Deluxe Paint LBM file into a FreeImage bitmap using the specified FreeImageIO struct and fi_handle. If the file is loaded successfully, memory for it is allocated and a bitmap pointer is returned. If the file couldn't be loaded, FreeImage_LoadLBMFromHandle returns NULL.
+
+
+FreeImage_LoadMNGFromHandle
+
+
+
+FIBITMAP *FreeImage_LoadMNGFromHandle(FreeImageIO *io, fi_handle handle, int flags = MNG_DEFAULT);
+
+
+
+Loads the Multi Network Graphics (MNG) or JPEG Network Graphics (JNG) file into a FreeImage bitmap using the specified FreeImageIO struct and fi_handle. If the file is loaded successfully, memory for it is allocated and a bitmap pointer is returned. If the file couldn't be loaded, FreeImage_LoadMNGFromHandle returns NULL.
+
+
+FreeImage_LoadPCDFromHandle
+
+
+
+FIBITMAP *FreeImage_LoadPCDFromHandle(FreeImageIO *io, fi_handle handle, int flags = PCD_DEFAULT);
+
+
+
+Loads the given Kodak PhotoCD file into a FreeImage bitmap using the specified FreeImageIO struct and fi_handle. If the file is loaded successfully, memory for it is allocated and a bitmap pointer is returned. If the file couldn't be loaded, FreeImage_LoadPCDFromHandle returns NULL.
+
+
+FreeImage_LoadPCXFromHandle
+
+
+
+FIBITMAP *FreeImage_LoadPCXFromHandle(FreeImageIO *io, fi_handle handle, int flags = PCX_DEFAULT);
+
+
+
+Loads the given PCX file into a FreeImage bitmap using the specified FreeImageIO struct and fi_handle. If the file is loaded successfully, memory for it is allocated and a bitmap pointer is returned. If the file couldn't be loaded, FreeImage_LoadPCXFromHandle returns NULL.
+
+
+FreeImage_LoadPNMFromHandle
+
+
+
+FIBITMAP *FreeImage_LoadPNMFromHandle(FreeImageIO *io, fi_handle handle, int flags = PNM_DEFAULT);
+
+
+
+Loads the given PBM, PGM or PPM file into a FreeImage bitmap using the specified FreeImageIO struct and fi_handle. If the file is loaded successfully, memory for it is allocated and a bitmap pointer is returned. If the file couldn't be loaded, FreeImage_LoadPNMFromHandle returns NULL.
+
+
+FreeImage_LoadPNGFromHandle
+
+
+
+FIBITMAP *FreeImage_LoadPNGFromHandle(FreeImageIO *io, fi_handle handle, int flags = PNG_DEFAULT);
+
+
+
+Loads the given PNG file into a FreeImage bitmap using the specified FreeImageIO struct and fi_handle. If the file is loaded successfully, memory for it is allocated and a bitmap pointer is returned. If the file couldn't be loaded, FreeImage_LoadPNGFromHandle returns NULL.
+
+
+FreeImage_LoadRASFromHandle
+
+
+
+FIBITMAP *FreeImage_LoadRASFromHandle(FreeImageIO *io, fi_handle handle, int flags = RAS_DEFAULT);
+
+
+
+Loads the given Sun Rasterfile into a FreeImage bitmap using the specified FreeImageIO struct and fi_handle. If the file is loaded successfully, memory for it is allocated and a bitmap pointer is returned. If the file couldn't be loaded, FreeImage_LoadRASFromHandle returns NULL.
+
+
+FreeImage_LoadTARGAFromHandle
+
+
+
+FIBITMAP *FreeImage_LoadTARGAFromHandle(FreeImageIO *io, fi_handle handle, int flags = TARGA_DEFAULT);
+
+
+
+Loads the given TARGA file into a FreeImage bitmap using the specified FreeImageIO struct and fi_handle. If the file is loaded successfully, memory for it is allocated and a bitmap pointer is returned. If the file couldn't be loaded, FreeImage_LoadTARGAFromHandle returns NULL.
+
+
+FreeImage_LoadTIFFFromHandle
+
+
+
+FIBITMAP *FreeImage_LoadTIFFFromHandle(FreeImageIO *io, fi_handle handle, int flags = TIFF_DEFAULT);
+
+
+
+Loads the given TIFF file into a FreeImage bitmap using the specified FreeImageIO struct and fi_handle. If the file is loaded successfully, memory for it is allocated and a bitmap pointer is returned. If the file couldn't be loaded, FreeImage_LoadTIFFFromHandle returns NULL.
+
+
+FreeImage_LoadWBMPFromHandle
+
+
+
+FIBITMAP *FreeImage_LoadWBMPFromHandle(FreeImageIO *io, fi_handle handle, int flags = WBMP_DEFAULT);
+
+
+
+Loads the given WBMP file into a FreeImage bitmap using the specified FreeImageIO struct and fi_handle. If the file is loaded successfully, memory for it is allocated and a bitmap pointer is returned. If the file couldn't be loaded, FreeImage_LoadWBMPFromHandle returns NULL.
+
+
diff --git a/freeimage241/Docs/55.html b/freeimage241/Docs/55.html
new file mode 100644
index 0000000..d5acded
--- /dev/null
+++ b/freeimage241/Docs/55.html
@@ -0,0 +1,105 @@
+
+
+Simple save functions
+
+
+
Subsections FreeImage_SaveBMP
+
+
+bool FreeImage_SaveBMP(FIBITMAP *dib, const char *filename, int flags = BMP_DEFAULT);
+
+
+
+Saves the FreeImage DIB to a Windows Bitmap file. The BMP file is always saved in the Windows format. No compression is used.
+
+
+
+FIBITMAP *dib = FreeImage_LoadBMP("test.bmp");
FreeImage_SaveJPEG
+
+
+bool FreeImage_SaveJPEG(FIBITMAP *dib, const char *filename, int flags = JPEG_DEFAULT);
+
+
+
+Saves the FreeImage DIB to a JPEG file. . Only 24-bit bitmaps can be saved as JPEG. Bitmaps in bit depths will have to be converted.
+
+
+
+FIBITMAP *dib = FreeImage_LoadBMP("test.bmp");
FreeImage_SavePNG
+
+
+bool FreeImage_SavePNG(FIBITMAP *dib, const char *filename, int flags = PNG_DEFAULT);
+
+
+
+Saves the FreeImage DIB to a PNG file.
+
+
+
+FIBITMAP *dib = FreeImage_LoadBMP("test.bmp");
FreeImage_SavePNM
+
+
+bool FreeImage_SavePNM(FIBITMAP *dib, const char *filename, PNMFlags flags = PNM_DEFAULT);
+
+
+
+Saves the FreeImage DIB to a PNM file. PNM is a descriptive name for a collection of ASCII based bitmap types: PBM, PGM and PPM. If the bitmap has a bit depth of 1, the file is saved as a PBM file. If the bitmap has a bit depth of 8, the file is saved as a PGM file. If the bitmap has a bit depth of 24, the file is saved as a PPM file. Other bit depths are not supported.
+
+
+
+FIBITMAP *dib = FreeImage_LoadBMP("test.bmp");
+
+
+
+if (dib != NULL) {
FreeImage_SaveTIFF
+
+
+bool FreeImage_SaveTIFF(FIBITMAP *dib, const char *filename, int flags = TIFF_DEFAULT);
+
+
+
+Saves the FreeImage DIB to a TIFF file.
+
+
+
+FIBITMAP *dib = FreeImage_LoadBMP("test.bmp");
FreeImage_SaveWBMP
+
+
+bool FreeImage_SaveWBMP(FIBITMAP *dib, const char *filename, int flags = WBMP_DEFAULT);
+
+
+
+Saves the FreeImage DIB to a WBMP file.
+
+
+
+FIBITMAP *dib = FreeImage_LoadBMP("test.bmp");
diff --git a/freeimage241/Docs/6.html b/freeimage241/Docs/6.html
new file mode 100644
index 0000000..b67be96
--- /dev/null
+++ b/freeimage241/Docs/6.html
@@ -0,0 +1,43 @@
+
+Bitmap Allocation functions
+
+
Subsections FreeImage_Allocate
+
+
+FIBITMAP *FreeImage_Allocate(int width, int height, int bpp, int red_mask = 0, int green_mask = 0, int blue_mask = 0);
+
+
+
+Allocates a new FreeImage bitmap using the given width, height and bits per pixel and optional red, green and blue mask. The mask is stored in BGR order.
+
+
FreeImage_Free
+
+
+void FreeImage_Free(FIBITMAP *dib);
+
+
+
+Disposes the given bitmap from memory.
+
+
FreeImage_Unload
+
+
+void FreeImage_Unload(FIBITMAP *dib);
+
+
+
+Alias for FreeImage_Free.
+
+
diff --git a/freeimage241/Docs/62.html b/freeimage241/Docs/62.html
new file mode 100644
index 0000000..144530d
--- /dev/null
+++ b/freeimage241/Docs/62.html
@@ -0,0 +1,196 @@
+
+Advanced save functions
+
+
+Saving bitmaps using the ...SaveToHandle functions is almost identical to loading bitmap via the ...LoadFromHandle functions. Information about the FreeImageIO and fi_handle can therefore be obtained from the information belonging to these functions.
+
+
+
+unsigned
+
+
+
+_ReadProc(FIBITMAP *buffer, unsigned s, unsigned c, fi_handle handle) {
+
+
+
+return fread(buffer, s, c, (FILE *)handle);
+
+
+
+}
+
+
+
+unsigned
+
+
+
+_WriteProc(FIBITMAP *buffer, unsigned s, unsigned c, fi_handle handle){
+
+
+
+return fwrite(buffer, s, c, (FILE *)handle);
+
+
+
+}
+
+
+
+int
+
+
+
+_SeekProc(fi_handle handle, long offset, int origin) {
+
+
+
+return fseek((FILE *)handle, offset, origin);
+
+
+
+}
+
+
+
+long
+
+
+
+_TellProc(fi_handle handle) {
+
+
+
+return ftell((FILE *)handle);
+
+
+
+}
+
+
+
+FreeImageIO io;
+
+
+
+io.read_proc = _ReadProc;
+
+
+
+io.write_proc = _WriteProc;
+
+
+
+io.seek_proc = _SeekProc;
+
+
+
+io.tell_proc = _TellProc;
+
+
+
+
+
+FIBITMAP *dib = FreeImage_LoadBMPFromHandle(&io, (fi_handle)file);
+
+
+
+
+
+
+if (dib != NULL) {
+
+
+
+file = fopen("saved.bmp", "wb");
+
+
+FreeImage_SavePNGToHandle(dib, &io, (fi_handle)file);
+
+
+FreeImage_Free(dib);
+
+
+
Subsections FreeImage_SaveBMPToHandle
+
+
+bool FreeImage_SaveBMPToHandle(FIBITMAP *dib, FreeImageIO *io, fi_handle handle, int flags = BMP_DEFAULT);
+
+
+
+Saves the FreeImage DIB to a Windows Bitmap file. The BMP file is always saved in the Windows format. No compression is used.
+
+
FreeImage_SaveJPEGToHandle
+
+
+bool FreeImage_SaveJPEGToHandle(FIBITMAP *dib, FreeImageIO *io, fi_handle handle, int flags = JPEG_DEFAULT);
+
+
+
+Saves the FreeImage DIB to a JPEG file. Only 24-bit bitmaps can be saved as JPEG. Bitmaps in bit depths will have to be converted.
+
+
FreeImage_SavePNGToHandle
+
+
+bool FreeImage_SavePNGToHandle(FIBITMAP *dib, FreeImageIO *io, fi_handle handle, int flags = PNG_DEFAULT);
+
+
+
+Saves the FreeImage DIB to a PNG file.
+
+
FreeImage_SavePNMToHandle
+
+
+bool FreeImage_SavePNMToHandle(FIBITMAP *dib, FreeImageIO *io, fi_handle handle, int flags = PNM_DEFAULT);
+
+
+
+Saves the FreeImage DIB to a PNM file. PNM is a descriptive name for a collection of ASCII based bitmap types: PBM, PGM and PPM. If the bitmap has a bitdepth of 1, the file is saved as a PBM file. If the bitmap has a bitdepth of 8, the file is saved as a PGM file. If the bitmap has a bitdepth of 24, the file is saved as a PPM file. Other bitdepths are not supported.
+
+
+FreeImage_SaveTIFFToHandle
+
+
+
+bool FreeImage_SaveTIFFToHandle(FIBITMAP *dib, FreeImageIO *io, fi_handle handle, int flags = TIFF_DEFAULT);
+
+
+
+Saves the FreeImage DIB to a TIFF file.
+
+
FreeImage_SaveWBMPToHandle
+
+
+bool FreeImage_SaveWBMPToHandle(FIBITMAP *dib, FreeImageIO *io, fi_handle handle, int flags = WBMP_DEFAULT);
+
+
+
+Saves the FreeImage DIB to a WBMP file.
+
+
diff --git a/freeimage241/Docs/69.html b/freeimage241/Docs/69.html
new file mode 100644
index 0000000..1a25e21
--- /dev/null
+++ b/freeimage241/Docs/69.html
@@ -0,0 +1,149 @@
+
+Filetype functions
+
+
Subsections FreeImage_GetFileType
+
+
+FREE_IMAGE_FORMAT FreeImage_GetFileType(const char *filename, int size);
+
+
+
+Investigates the bitmap data from the given bitmap and returns the FreeImage Format ID for it. FreeImage_GetFileType will read the first size bytes of the file but not more than 16. FreeImage_GetFileType will return one of the following values:
+
+
+
+
Type Bitmap
+
+
+
+
+
FIF_UNKNOWN Unidentified bitmap type FIF_BMP Windows or OS/2 Bitmap FIF_ICO Windows Icon
+FIF_JPEG JPEG - JFIF Compliant FIF_JNG JPEG Network Graphics FIF_KOALA C64 Koala Graphics FIF_LBM
+ Deluxe Paint LBM FIF_MNG Multiple Network Graphics FIF_PBM Portable Bitmap FIF_PCD
+Kodak PhotoCD FIF_PCX Zsoft Paintbrush FIF_PGM Portable Greymap FIF_PNG Portable Network Graphics
+ FIF_PPM Portable Pixmap FIF_RAS Sun Raster Image FIF_TARGA Truevision Targa
+FIF_TIFF Tagged Image File Format FIF_WBMP Wireless Bitmap
FreeImage_GetFileTypeFromHandle
+
+
+FREE_IMAGE_FORMAT FreeImage_GetFileTypeFromHandle(FreeImageIO *io, fi_handle handle, int size);
+
+
+
+Investigates the bitmap data from the given bitmap and returns the FreeImage Format ID for it. Code example:
+
+
+
+unsigned
+
+
+
+_ReadProc(FIBITMAP *buffer, unsigned s, unsigned c, fi_handle handle) {
+
+
+
+return fread(buffer, s, c, (FILE *)handle);
+
+
+
+}
+
+
+
+unsigned
+
+
+
+_WriteProc(FIBITMAP *buffer, unsigned s, unsigned c, fi_handle handle){
+
+
+
+return fwrite(buffer, s, c, (FILE *)handle);
+
+
+
+}
+
+
+
+int
+
+
+
+_SeekProc(fi_handle handle, long offset, int origin) {
+
+
+
+return fseek((FILE *)handle, offset, origin);
+
+
+
+}
+
+
+
+long
+
+
+
+_TellProc(fi_handle handle) {
+
+
+
+return ftell((FILE *)handle);
+
+
+
+}
+
+
+
+FreeImageIO io;
+
+
+
+io.read_proc = _ReadProc;
+
+
+
+io.write_proc = _WriteProc;
+
+
+
+io.seek_proc = _SeekProc;
+
+
+
+io.tell_proc = _TellProc;
+
+
+
+
+
+FREE_IMAGE_TYPE type;
FreeImage_GetFileTypeFromExt
+
+
+FREE_IMAGE_FORMAT FreeImage_GetFileTypeFromExt(const char *ext);
+
+
+
+This function is deprecated. FreeImage_GetFIFFromFilename has replaced its functionality.
+
+
diff --git a/freeimage241/Docs/73.html b/freeimage241/Docs/73.html
new file mode 100644
index 0000000..064c3e0
--- /dev/null
+++ b/freeimage241/Docs/73.html
@@ -0,0 +1,77 @@
+
+FreeImage bitmap information functions
+
+
Subsections FreeImage_GetRedMask
+
+
+unsigned FreeImage_GetRedMask(FIBITMAP *dib);
+
+
+
+Returns the red bitmask for the bitmap. If the bitmap is palletised 0 is returned.
+
+
FreeImage_GetGreenMask
+
+
+unsigned FreeImage_GetGreenMask(FIBITMAP *dib);
+
+
+
+Returns the green bitmask for the bitmap. If the bitmap is palletised 0 is returned.
+
+
FreeImage_GetBlueMask
+
+
+unsigned FreeImage_GetBlueMask(FIBITMAP *dib);
+
+
+
+Returns the blue bitmask for the bitmap. If the bitmap is palletised 0 is returned.
+
+
FreeImage_GetTransparencyCount
+
+
+BYTE FreeImage_GetTransparencyCount(FIBITMAP *dib);
+
+
+
+Returns the number of transparent colours stored into the transparency colour table of the given bitmap. Every palletised bitmap includes a transparency table containing up to 256 alpha values.
+
+
FreeImage_GetTransparencyTable
+
+
+BYTE *FreeImage_GetTransparencyTable(FIBITMAP *dib);
+
+
+
+Returns the transparency table assigned to this bitmap. If the bitmap doesn't contain a transparency table NULL is returned.
+
+
FreeImage_SetTransparencyTable
+
+
+void FreeImage_SetTransparencyTable(FIBITMAP *dib, BYTE *table, BYTE count);
+
+
+
+Assigns a new transparency table to the bitmap. A transparency table consists of up to 256 bytes in an array, where a value of 0xFF in that table stands for completely opaque and 0x00 stands for completely invisible. The transparency table is used in TrollTech Qt to draw transparent bitmaps on a widget.
+
+
diff --git a/freeimage241/Docs/80.html b/freeimage241/Docs/80.html
new file mode 100644
index 0000000..64935ce
--- /dev/null
+++ b/freeimage241/Docs/80.html
@@ -0,0 +1,175 @@
+
+
+DIB information functions
+
+
+
Subsections FreeImage_GetColorsUsed
+
+
+unsigned FreeImage_GetColorsUsed(FIBITMAP *dib);
+
+
+
+Retrieves the number of colours used in the bitmap. If the bitmap is non-palletised, 0 is returned.
+
+
FreeImage_GetBits
+
+
+BYTE * FreeImage_GetBits(FIBITMAP *dib);
+
+
+
+Returns a pointer to the bitmap bits.
+
+
FreeImage_GetBitsRowCol
+
+
+BYTE * FreeImage_GetBitsRowCol(FIBITMAP *dib, int col, int row);
+
+
+
+Returns a pointer to the bitmap bits on the given column and row.
+
+
FreeImage_GetScanLine
+
+
+BYTE * FreeImage_GetScanLine(FIBITMAP *dib, int scanline);
+
+
+
+Returns a pointer to the beginning of the bits of the given scanline.
+
+
FreeImage_GetBPP
+
+
+unsigned FreeImage_GetBPP(FIBITMAP *dib);
+
+
+
+Returns the bitdepth of the bitmap.
+
+
FreeImage_GetWidth
+
+
+unsigned FreeImage_GetWidth(FIBITMAP *dib);
+
+
+
+Returns the width of the bitmap in pixels.
+
+
FreeImage_GetHeight
+
+
+unsigned FreeImage_GetHeight(FIBITMAP *dib);
+
+
+
+Returns the height of the bitmap in pixels.
+
+
FreeImage_GetLine
+
+
+unsigned FreeImage_GetLine(FIBITMAP *dib);
+
+
+
+Returns the width of the bitmap in bytes.
+
+
FreeImage_GetPitch
+
+
+unsigned FreeImage_GetPitch(FIBITMAP *dib);
+
+
+
+Returns the width of the bitmap in bytes rounded to the nearest DWORD.
+
+
FreeImage_GetDIBSize
+
+
+unsigned FreeImage_GetDIBSize(FIBITMAP *dib);
+
+
+
+Returns the size of the bitmap in bytes. The size of the bitmap is the BITMAPINFOHEADER + the size of the palette + the size of the bitmap data.
+
+
FreeImage_GetPalette
+
+
+RGBQUAD *FreeImage_GetPalette(FIBITMAP *dib);
+
+
+
+Returns a pointer to the bitmap's palette. If the bitmap doesn't have a palette, FreeImage_GetPalette returns NULL.
+
+
FreeImage_GetInfoHeader
+
+
+BITMAPINFOHEADER *FreeImage_GetInfoHeader(FIBITMAP *dib);
+
+
+
+Returns a pointer to the bitmap's BITMAPINFOHEADER.
+
+
FreeImage_GetInfo
+
+
+BITMAPINFO *FreeImage_GetInfo(FIBITMAP *dib);
+
+
+
+Returns a pointer to the bitmap's BITMAPINFO header.
+
+
FreeImage_GetColorType
+
+
+FREE_IMAGE_COLOR_TYPE FreeImage_GetColorType(FIBITMAP *dib);
+
+
+
+Investigates the colour type of the bitmap and returns one of the following values:
+
+
+
+
Value Description
+
+
+
+
+
FIC_MINISWHITE 1-bit bitmap. The min value is white FIC_MINISBLACK 1-bit bitmap. The min value is black 8-bit grayscale. The min value is black FIC_RGB 24/32-bit RGB
+FIC_PALETTE 1/4/8-bit palletised
diff --git a/freeimage241/Docs/95.html b/freeimage241/Docs/95.html
new file mode 100644
index 0000000..ca560fa
--- /dev/null
+++ b/freeimage241/Docs/95.html
@@ -0,0 +1,93 @@
+
+Conversion functions
+
+
+Bitmaps in FreeImage are always loaded in their default bit depth. If you want the bitmap to be stored in another bit depth, the library provides several conversion functions.
+
+
+
Subsections FreeImage_ConvertTo8Bits
+
+
+FIBITMAP *FreeImage_ConvertTo8Bits(FIBITMAP *dib);
+
+
+
+Converts the given bitmap to 8 bits. If the bitmap is 24 or 32-bit RGB, the colour values are converted to greyscale.
+
+
FreeImage_ConvertTo16Bits 555
+
+
+FIBITMAP *FreeImage_ConvertTo16Bits555(FIBITMAP *dib);
+
+
+
+Converts the given bitmap to 16 bits. The resulting bitmap has a layout of 5 bits red, 5 bits green, 5 bits red and 1 unused bit.
+
+
FreeImage_ConvertTo16Bits565
+
+
+FIBITMAP *FreeImage_ConvertTo16Bits565(FIBITMAP *dib);
+
+
+
+Converts the given bitmap to 16 bits. The resulting bitmap has a layout of 5 bits red, 6 bits green and 5 bits red.
+
+
FreeImage_ConvertTo24Bits
+
+
+FIBITMAP *FreeImage_ConvertTo24Bits(FIBITMAP *dib);
+
+
+
+Converts the given bitmap to 24 bits.
+
+
FreeImage_ConvertTo32Bits
+
+
+FIBITMAP *FreeImage_ConvertTo32Bits(FIBITMAP *dib);
+
+
+
+Converts the given bitmap to 32 bits.
+
+
FreeImage_ColorQuantize
+
+
+FIBITMAP *FreeImage_ColorQuantize(FIBITMAP *dib, FREE_IMAGE_QUANTIZE quantize);
+
+
+
+Quantizes a full colour 24-bit bitmap to a palletised 8-bit bitmap. The quantize parameter specifies which colour reduction algorithm should be used.
+
+
+
+
Parameter Description
+
+
+
+
+
FIQ_WUQUANT Wu's color quantization algorithm FIQ_NNQUANT NeuQuant quantization algorithm
+
+
+
+
diff --git a/freeimage241/Docs/contents.xml b/freeimage241/Docs/contents.xml
new file mode 100644
index 0000000..3f85eb6
--- /dev/null
+++ b/freeimage241/Docs/contents.xml
@@ -0,0 +1,249 @@
+
+
+
+ FreeImage functions
+ Initialisation
+ FreeImage_Initialise
+
+ FreeImage_DeInitialise
+
+
+ Bitmap Allocation functions
+ FreeImage_Allocate
+
+ FreeImage_Free
+
+ FreeImage_Unload
+
+
+ Plugin functions
+ FreeImage_GetFIFByIndex
+
+ FreeImage_GetFIFCount
+
+ FreeImage_GetFIFFromFormat
+
+ FreeImage_GetFormatFromFIF
+
+ FreeImage_GetFIFExtensionList
+
+ FreeImage_GetFIFDescription
+
+ FreeImage_GetFIFRegExpr
+
+ FreeImage_GetFIFFromFilename
+
+ FreeImage_FIFSupportsReading
+
+ FreeImage_FIFSupportsWriting
+
+ FreeImage_LoadFromHandle
+
+ FreeImage_Load
+
+ FreeImage_SaveToHandle
+
+ FreeImage_Save
+
+
+ Simple load functions
+ FreeImage_LoadBMP
+
+ FreeImage_LoadICO
+
+ FreeImage_LoadJPEG
+
+ FreeImage_LoadKOALA
+
+ FreeImage_LoadLBM
+
+ FreeImage_LoadMNG
+
+ FreeImage_LoadPCD
+
+ FreeImage_LoadPCX
+
+ FreeImage_LoadPNM
+
+ FreeImage_LoadPNG
+
+ FreeImage_LoadRAS
+
+ FreeImage_LoadTARGA
+
+ FreeImage_LoadTIFF
+
+ FreeImage_LoadWBMP
+
+
+ Advanced load functions
+ FreeImage_LoadBMPFromHandle
+
+ FreeImage_LoadICOFromHandle
+
+ FreeImage_LoadJPEGFromHandle
+
+ FreeImage_LoadKOALAFromHandle
+
+ FreeImage_LoadLBMFromHandle
+
+ FreeImage_LoadMNGFromHandle
+
+ FreeImage_LoadPCDFromHandle
+
+ FreeImage_LoadPCXFromHandle
+
+ FreeImage_LoadPNMFromHandle
+
+ FreeImage_LoadPNGFromHandle
+
+ FreeImage_LoadRASFromHandle
+
+ FreeImage_LoadTARGAFromHandle
+
+ FreeImage_LoadTIFFFromHandle
+
+ FreeImage_LoadWBMPFromHandle
+
+
+ Simple save functions
+ FreeImage_SaveBMP
+
+ FreeImage_SaveJPEG
+
+ FreeImage_SavePNG
+
+ FreeImage_SavePNM
+
+ FreeImage_SaveTIFF
+
+ FreeImage_SaveWBMP
+
+
+ Advanced save functions
+ FreeImage_SaveBMPToHandle
+
+ FreeImage_SaveJPEGToHandle
+
+ FreeImage_SavePNGToHandle
+
+ FreeImage_SavePNMToHandle
+
+ FreeImage_SaveTIFFToHandle
+
+ FreeImage_SaveWBMPToHandle
+
+
+ Filetype functions
+ FreeImage_GetFileType
+
+ FreeImage_GetFileTypeFromHandle
+
+ FreeImage_GetFileTypeFromExt
+
+
+ FreeImage bitmap information functions
+ FreeImage_GetRedMask
+
+ FreeImage_GetGreenMask
+
+ FreeImage_GetBlueMask
+
+ FreeImage_GetTransparencyCount
+
+ FreeImage_GetTransparencyTable
+
+ FreeImage_SetTransparencyTable
+
+
+ DIB information functions
+ FreeImage_GetColorsUsed
+
+ FreeImage_GetBits
+
+ FreeImage_GetBitsRowCol
+
+ FreeImage_GetScanLine
+
+ FreeImage_GetBPP
+
+ FreeImage_GetWidth
+
+ FreeImage_GetHeight
+
+ FreeImage_GetLine
+
+ FreeImage_GetPitch
+
+ FreeImage_GetDIBSize
+
+ FreeImage_GetPalette
+
+ FreeImage_GetInfoHeader
+
+ FreeImage_GetInfo
+
+ FreeImage_GetColorType
+
+
+ Conversion functions
+ FreeImage_ConvertTo8Bits
+
+ FreeImage_ConvertTo16Bits 555
+
+ FreeImage_ConvertTo16Bits565
+
+ FreeImage_ConvertTo24Bits
+
+ FreeImage_ConvertTo32Bits
+
+ FreeImage_ColorQuantize
+
+
+ Extra functions
+ FreeImage_Combine
+
+
+
+ FreeImageQt functions
+ Introduction
+
+ Functions
+ FIQT_Register
+
+ FIQT_Unregister
+
+ FIQT_IsLoaded
+
+ FIQT_GetVersion
+
+ FIQT_GetCopyrightMessage
+
+ FIQT_GetFIFCount
+
+ FIQT_GetFIFFromFormat
+
+ FIQT_GetFormatFromFIF
+
+ FIQT_GetFIFExtensionList
+
+ FIQT_GetFIFDescription
+
+ FIQT_GetFIFFromFilename
+
+ FIQT_FIFSupportsReading
+
+ FIQT_FIFSupportsWriting
+
+ FIQT_GetFileTypeFromFormat
+
+ FIQT_GetFormatFromExtension
+
+
+
+ Index
+
+
+
+
+
diff --git a/freeimage241/Docs/index.html b/freeimage241/Docs/index.html
new file mode 100644
index 0000000..3587278
--- /dev/null
+++ b/freeimage241/Docs/index.html
@@ -0,0 +1,190 @@
+
+
+
+FreeImage 2.3.0
+
+Thank you for downloading FreeImage, an Open Source image library for multimedia and game programmers. The goal of FreeImage is to create a sophisticated, easy to use library to serve all your bitmap manipulation needs. The library is already in use by many companies and individuals, and the user base is still rapidly growing.
+
+
+
+If you have any questions about this manual, or about FreeImage, please don't hesitate to send an e-mail to freeimage@6ixsoft.com . You can also browse the FreeImage forum or sign up on the FreeImage mailing list via the FreeImage website: http://www.6ixsoft.com
+
+
+
+Floris
+
+
+
Subsections
+#include
+#include
+#include
+#include
+
+#include "FreeImage.h"
+
+// ----------------------------------------------------------
+
+int __cdecl
+main(int argc, char *argv[]) {
+ FIBITMAP *dib = NULL;
+ int id = 1;
+
+ printf(FreeImage_GetVersion());
+ printf(FreeImage_GetCopyrightMessage());
+
+ // open the log file
+
+ FILE *log_file = fopen("log_file.txt", "w");
+
+ // batch convert all supported bitmaps
+
+ _finddata_t finddata;
+
+ long handle;
+
+ if ((handle = _findfirst("d:\\images\\*.*", &finddata)) != -1) {
+ do {
+ // grab the extension
+
+ char *ext = new char[4];
+ ext[3] = 0;
+ strncpy(ext, finddata.name + strlen(finddata.name) - 3, 3);
+
+ // make a path to a directory
+
+ char *directory = new char[128];
+ strcpy(directory, "d:\\images\\");
+ strcat(directory, finddata.name);
+
+ // make a unique filename
+
+ char *unique = new char[128];
+ itoa(id, unique, 10);
+ strcat(unique, ".bmp");
+
+ // open the file
+
+ switch(FreeImage_GetFileTypeFromExt(ext)) {
+ case FIF_BMP :
+ dib = FreeImage_LoadBMP(directory);
+ break;
+
+ case FIF_ICO :
+ dib = FreeImage_LoadICO(directory);
+ break;
+
+ case FIF_JPEG :
+ dib = FreeImage_LoadJPEG(directory);
+ break;
+
+ case FIF_KOALA :
+ dib = FreeImage_LoadKOALA(directory);
+ break;
+
+ case FIF_PCD :
+ dib = FreeImage_LoadPCD(directory);
+ break;
+
+ case FIF_PCX :
+ dib = FreeImage_LoadPCX(directory);
+ break;
+
+ case FIF_PNG :
+ dib = FreeImage_LoadPNG(directory);
+ break;
+
+ case FIF_PBM :
+ dib = FreeImage_LoadPNM(directory);
+ break;
+
+ case FIF_PGM :
+ dib = FreeImage_LoadPNM(directory);
+ break;
+
+ case FIF_PPM :
+ dib = FreeImage_LoadPNM(directory);
+ break;
+
+ case FIF_RAS :
+ dib = FreeImage_LoadRAS(directory);
+ break;
+
+ case FIF_TARGA :
+ dib = FreeImage_LoadTARGA(directory);
+ break;
+
+ case FIF_TIFF :
+ dib = FreeImage_LoadTIFF(directory);
+ break;
+ };
+
+ if (dib != NULL) {
+ FreeImage_SaveBMP(dib, unique);
+
+ FreeImage_Free(dib);
+
+ fwrite(unique, strlen(unique), 1, log_file);
+ fwrite(" >> ", 4, 1, log_file);
+ fwrite(directory, strlen(directory), 1, log_file);
+ fwrite("\n", 1, 1, log_file);
+
+ id++;
+ }
+
+ delete [] unique;
+ delete [] directory;
+ delete [] ext;
+
+ } while (_findnext(handle, &finddata) == 0);
+
+ _findclose(handle);
+ }
+
+ fclose(log_file);
+
+ return 0;
+}
\ No newline at end of file
diff --git a/freeimage241/Examples/Generic/LoadFromHandle.cpp b/freeimage241/Examples/Generic/LoadFromHandle.cpp
new file mode 100644
index 0000000..498b1f5
--- /dev/null
+++ b/freeimage241/Examples/Generic/LoadFromHandle.cpp
@@ -0,0 +1,66 @@
+// ==========================================================
+// Load From Handle Example
+//
+// Design and implementation by Floris van den Berg
+//
+// This file is part of FreeImage
+//
+// Use at own risk!
+// ==========================================================
+//
+// This example shows how to load a bitmap from a
+// user allocated FILE pointer.
+//
+// ==========================================================
+
+#include
+#include
+#include
+
+#include "FreeImage.h"
+
+// ----------------------------------------------------------
+
+unsigned
+_ReadProc(void *buffer, unsigned size, unsigned count, fi_handle handle) {
+ return fread(buffer, size, count, (FILE *)handle);
+}
+
+unsigned
+_WriteProc(void *buffer, unsigned size, unsigned count, fi_handle handle) {
+ return fwrite(buffer, size, count, (FILE *)handle);
+}
+
+int
+_SeekProc(fi_handle handle, long offset, int origin) {
+ return fseek((FILE *)handle, offset, origin);
+}
+
+long
+_TellProc(fi_handle handle) {
+ return ftell((FILE *)handle);
+}
+
+// ----------------------------------------------------------
+
+int __cdecl
+main(int argc, char *argv[]) {
+ FreeImageIO io;
+
+ io.read_proc = _ReadProc;
+ io.write_proc = _WriteProc;
+ io.seek_proc = _SeekProc;
+ io.tell_proc = _TellProc;
+
+ FILE *file = fopen("d:\\images\\money-256.bmp", "rb");
+
+ if (file != NULL) {
+ FIBITMAP *dib = FreeImage_LoadBMPFromHandle(&io, (fi_handle)file);
+
+ FreeImage_Free(dib);
+
+ fclose(file);
+ }
+
+ return 0;
+}
\ No newline at end of file
diff --git a/freeimage241/Examples/Generic/LoadFromMemory.cpp b/freeimage241/Examples/Generic/LoadFromMemory.cpp
new file mode 100644
index 0000000..72acc73
--- /dev/null
+++ b/freeimage241/Examples/Generic/LoadFromMemory.cpp
@@ -0,0 +1,112 @@
+// ==========================================================
+// Load From Memory Example
+//
+// Design and implementation by Floris van den Berg
+//
+// This file is part of FreeImage
+//
+// Use at own risk!
+// ==========================================================
+//
+// This example shows how to load a bitmap from memory
+// rather than from a file. To do this we make use of the
+// FreeImage_LoadXXXFromHandle functions where we override
+// the i/o functions to simulate FILE* access in memory.
+//
+// For seeking purposes the fi_handle passed to the i/o
+// functions contain the start of the data block where the
+// bitmap is stored.
+//
+// ==========================================================
+
+#include
+#include
+#include
+
+#include "FreeImage.h"
+
+// ----------------------------------------------------------
+
+fi_handle g_load_address;
+
+// ----------------------------------------------------------
+
+inline unsigned
+_ReadProc(void *buffer, unsigned size, unsigned count, fi_handle handle) {
+ BYTE *tmp = (BYTE *)buffer;
+
+ for (unsigned c = 0; c < count; c++) {
+ memcpy(tmp, g_load_address, size);
+
+ g_load_address = (BYTE *)g_load_address + size;
+
+ tmp += size;
+ }
+
+ return count;
+}
+
+inline unsigned
+_WriteProc(void *buffer, unsigned size, unsigned count, fi_handle handle) {
+ // there's not much use for saving the bitmap into memory now, is there?
+
+ return size;
+}
+
+inline int
+_SeekProc(fi_handle handle, long offset, int origin) {
+ assert(origin != SEEK_END);
+
+ if (origin == SEEK_SET) {
+ g_load_address = (BYTE *)handle + offset;
+ } else {
+ g_load_address = (BYTE *)g_load_address + offset;
+ }
+
+ return 0;
+}
+
+inline long
+_TellProc(fi_handle handle) {
+ assert((int)handle > (int)g_load_address);
+
+ return ((int)g_load_address - (int)handle);
+}
+
+// ----------------------------------------------------------
+
+int __cdecl
+main(int argc, char *argv[]) {
+ FreeImageIO io;
+
+ io.read_proc = _ReadProc;
+ io.write_proc = _WriteProc;
+ io.tell_proc = _TellProc;
+ io.seek_proc = _SeekProc;
+
+ // allocate some memory for the bitmap
+
+ BYTE *test = new BYTE[159744];
+
+ if (test != NULL) {
+ // load the bitmap into memory. ofcourse you can do this any way you want
+
+ FILE *file = fopen("e:\\projects\\images\\money-256.tif", "rb");
+ fread(test, 159744, 1, file);
+ fclose(file);
+
+ // we store the load address of the bitmap for internal reasons
+
+ g_load_address = test;
+
+ // convert the bitmap
+
+ FIBITMAP *dib = FreeImage_LoadTIFFFromHandle(&io, (fi_handle)test);
+
+ FreeImage_Free(dib);
+
+ delete [] test;
+ }
+
+ return 0;
+}
\ No newline at end of file
diff --git a/freeimage241/Examples/Linux/Makefile b/freeimage241/Examples/Linux/Makefile
new file mode 100644
index 0000000..10282ab
--- /dev/null
+++ b/freeimage241/Examples/Linux/Makefile
@@ -0,0 +1,26 @@
+include ../../Makefile.cfg
+
+
+
+INCLUDE = -I../../Source
+VGALIBRARIES = -lfreeimage -lvga
+GTKLIBRARIES = -lfreeimage -lgtk -lgdk
+GTKINCLUDE = -I/usr/lib/glib/include
+CFLAGS = $(COMPILERFLAGS) $(INCLUDE)
+
+
+
+all: default
+
+default: linux-svgalib linux-gtk
+
+linux-svgalib: linux-svgalib.c
+ $(CC) $(CFLAGS) $< -o $@ $(VGALIBRARIES)
+ strip $@
+
+linux-gtk: linux-gtk.c
+ $(CC) $(CFLAGS) $< -o $@ $(GTKLIBRARIES) $(GTKINCLUDE)
+ strip $@
+
+clean:
+ rm -f core linux-svgalib linux-gtk
diff --git a/freeimage241/Examples/Linux/linux-gtk.c b/freeimage241/Examples/Linux/linux-gtk.c
new file mode 100644
index 0000000..016acc3
--- /dev/null
+++ b/freeimage241/Examples/Linux/linux-gtk.c
@@ -0,0 +1,91 @@
+#include
+#include "FreeImage.h"
+
+void destroy(GtkWidget * widget, gpointer data) {
+ gtk_main_quit();
+}
+
+int main(int argc, char *argv[])
+{
+ GtkWidget *window, *imagebox;
+ GdkVisual *visual;
+ GdkImage *image;
+ FIBITMAP *dib;
+ int y;
+
+ dib = FreeImage_LoadPNG("freeimage.png",PNG_DEFAULT);
+
+ gtk_init(&argc, &argv);
+
+ window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+
+ gtk_signal_connect(GTK_OBJECT(window), "destroy",
+ GTK_SIGNAL_FUNC(destroy), NULL);
+
+ visual = gdk_visual_get_system();
+
+ image = gdk_image_new(GDK_IMAGE_NORMAL,visual,
+ FreeImage_GetWidth(dib),FreeImage_GetHeight(dib));
+
+ g_print("picture: %d bpp\n"
+ "system: %d bpp byteorder: %d\n"
+ " redbits: %d greenbits: %d bluebits: %d\n"
+ "image: %d bpp %d bytes/pixel\n",
+ FreeImage_GetBPP(dib),
+ visual->depth,visual->byte_order,
+ visual->red_prec,visual->green_prec,visual->blue_prec,
+ image->depth,image->bpp );
+
+ if (FreeImage_GetBPP(dib) != (image->bpp << 3)) {
+ FIBITMAP *ptr;
+
+ switch (image->bpp) {
+ case 1:
+ ptr = FreeImage_ConvertTo8Bits(dib);
+ break;
+
+ case 2:
+ if (image->depth == 15) {
+ ptr = FreeImage_ConvertTo16Bits555(dib);
+ } else {
+ ptr = FreeImage_ConvertTo16Bits565(dib);
+ }
+
+ break;
+ case 3:
+ ptr = FreeImage_ConvertTo24Bits(dib);
+ break;
+
+ default:
+ case 4:
+ ptr = FreeImage_ConvertTo32Bits(dib);
+ break;
+ }
+
+ FreeImage_Free(dib);
+ dib = ptr;
+ }
+
+//makes it upside down :(
+// memcpy(image->mem, FreeImage_GetBits(dib), image->bpl * image->height);
+
+ BYTE *ptr = FreeImage_GetBits(dib);
+
+ for (y = 0; y < image->height; y++) {
+ memcpy(image->mem + (y * image->bpl),
+ ptr + ((image->height - y - 1) * image->bpl),
+ image->bpl);
+ }
+
+ FreeImage_Free(dib);
+
+ imagebox = gtk_image_new(image, NULL);
+ gtk_container_add(GTK_CONTAINER(window), imagebox);
+
+ gtk_widget_show(imagebox);
+ gtk_widget_show(window);
+
+ gtk_main();
+
+ return 0;
+}
diff --git a/freeimage241/Examples/Linux/linux-svgalib.c b/freeimage241/Examples/Linux/linux-svgalib.c
new file mode 100644
index 0000000..820329b
--- /dev/null
+++ b/freeimage241/Examples/Linux/linux-svgalib.c
@@ -0,0 +1,91 @@
+#include
+#include "FreeImage.h"
+
+int main(void)
+{
+ FIBITMAP *dib,*ptr;
+ vga_modeinfo *inf;
+ int length,height,bpp,y;
+
+ dib = FreeImage_LoadPNG("freeimage.png",PNG_DEFAULT);
+
+ vga_init();
+ vga_setmode(vga_getdefaultmode());
+
+ inf = vga_getmodeinfo(vga_getcurrentmode());
+
+ switch(inf->colors) {
+ default:
+ printf("Must be at least 256color mode!\n");
+ return;
+
+ case 1 << 8:
+ bpp = 8;
+ break;
+
+ case 1 << 15:
+ bpp = 15;
+ break;
+
+ case 1 << 16:
+ bpp = 16;
+ break;
+
+ case 1 << 24:
+ if( inf->bytesperpixel == 3 ) {
+ bpp = 24;
+ } else {
+ bpp = 32;
+ }
+ break;
+ }
+
+ if(FreeImage_GetBPP(dib) != bpp) {
+ switch(bpp) {
+ case 8:
+ ptr = FreeImage_ConvertTo8Bits(dib);
+ break;
+
+ case 15:
+ ptr = FreeImage_ConvertTo16Bits555(dib);
+ break;
+
+ case 16:
+ ptr = FreeImage_ConvertTo16Bits565(dib);
+ break;
+
+ case 24:
+ ptr = FreeImage_ConvertTo24Bits(dib);
+ break;
+
+ default:
+ case 32:
+ ptr = FreeImage_ConvertTo32Bits(dib);
+ break;
+ }
+
+ FreeImage_Free(dib);
+ dib = ptr;
+ }
+
+ length = FreeImage_GetWidth(dib);
+ if( inf->width < length ) {
+ length = inf->width;
+ }
+ height = FreeImage_GetHeight(dib);
+ if( inf->height < height ) {
+ height = inf->height;
+ }
+
+ for(y = 0; y < height; y++) {
+ vga_drawscansegment(FreeImage_GetScanLine(dib, y),
+ 0,y,length);
+ }
+
+ FreeImage_Free(dib);
+
+ vga_getch();
+ vga_setmode(TEXT);
+
+ return 0;
+}
diff --git a/freeimage241/Examples/Plugin/PluginCradle.cpp b/freeimage241/Examples/Plugin/PluginCradle.cpp
new file mode 100644
index 0000000..f082efd
--- /dev/null
+++ b/freeimage241/Examples/Plugin/PluginCradle.cpp
@@ -0,0 +1,130 @@
+// ==========================================================
+// Loader/Saver Plugin Cradle
+//
+// Design and implementation by
+// - Floris van den Berg (flvdberg@wxs.nl)
+//
+// This file is part of FreeImage 2
+//
+// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
+// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
+// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
+// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
+// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
+// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
+// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+// THIS DISCLAIMER.
+//
+// Use at your own risk!
+// ==========================================================
+
+#include
+#include
+
+#include "FreeImage.h"
+#include "Utilities.h"
+
+// ==========================================================
+
+BOOL APIENTRY
+DllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {
+ switch (ul_reason_for_call) {
+ case DLL_PROCESS_ATTACH :
+ case DLL_PROCESS_DETACH :
+ case DLL_THREAD_ATTACH :
+ case DLL_THREAD_DETACH :
+ break;
+ }
+
+ return TRUE;
+}
+
+// ==========================================================
+// Plugin Interface
+// ==========================================================
+
+static int s_format_id;
+
+// ==========================================================
+// Plugin Implementation
+// ==========================================================
+
+static const char * DLL_CALLCONV
+Format() {
+ return "CRADLE";
+}
+
+static const char * DLL_CALLCONV
+Description() {
+ return "Here comes the description for your image loader/saver";
+}
+
+// the extension list is always a chain of extensions
+// seperated by commas. no spaces or whatsoever are allowed.
+
+static const char * DLL_CALLCONV
+Extension() {
+ return "ext1,ext2";
+}
+
+// RegExpr is only needed for the Qt wrapper
+// It allows the Qt mechanism for loading bitmaps to identify the bitmap
+
+static const char * DLL_CALLCONV
+RegExpr() {
+ return NULL;
+}
+
+// FreeImage's internal way of seeing if a bitmap is of the desired type.
+// When the type of a bitmap is to be retrieved, FreeImage runs Validate
+// for each registered plugin until one returns true. If a plugin doesn't
+// have a validate function, a return value of false is assumed.
+//
+// You can always force to use a particular plugin by directly specifying
+// it on the command line, but this can result in a dead DLL if the plugin
+// was not made for the bitmap.
+
+static BOOL DLL_CALLCONV
+Validate(FreeImageIO &io, fi_handle handle) {
+ return FALSE;
+}
+
+// ----------------------------------------------------------
+
+// NEVER EVER use direct function calls to FreeImage when writing
+// a plugin. Always use the function pointers provides in the FreeImage
+// structure. Using this indirect approach ensures that plugins run
+// from the FreeImage DLL, an external DLL or within the application
+// code with a simple recompile. Also NEVER EVER allocate memory in
+// a plugin and return it. Memory allocated in one DLL can't be freed
+// in another DLL unless they share the same c runtime library (which
+// usually is not the case). Always use freeimage.allocate_proc to
+// allocate memory for a bitmap.
+
+static FIBITMAP * DLL_CALLCONV
+Load(FreeImage &freeimage, FreeImageIO &io, fi_handle handle, int page, int flags, void *data) {
+ return NULL;
+}
+
+static BOOL DLL_CALLCONV
+Save(FreeImage &freeimage, FreeImageIO &io, FIBITMAP *dib, fi_handle handle, int page, int flags, void *data) {
+ return FALSE;
+}
+
+// ==========================================================
+// Init
+// ==========================================================
+
+void DLL_CALLCONV
+Init(Plugin &plugin, int format_id) {
+ s_format_id = format_id;
+
+ plugin.format_proc = Format;
+ plugin.description_proc = Description;
+ plugin.extension_proc = Extension;
+ plugin.regexpr_proc = RegExpr;
+ plugin.load_proc = Load;
+ plugin.save_proc = Save;
+ plugin.validate_proc = Validate;
+}
diff --git a/freeimage241/Examples/Plugin/PluginCradle.h b/freeimage241/Examples/Plugin/PluginCradle.h
new file mode 100644
index 0000000..ec0b8f6
--- /dev/null
+++ b/freeimage241/Examples/Plugin/PluginCradle.h
@@ -0,0 +1,45 @@
+// ==========================================================
+// JBIG Plugin
+//
+// Design and implementation by
+// - Floris van den Berg (flvdberg@wxs.nl)
+//
+// This file is part of FreeImage 2
+//
+// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
+// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
+// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
+// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
+// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
+// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
+// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+// THIS DISCLAIMER.
+//
+// Use at your own risk!
+// ==========================================================
+
+#ifndef PLUGINCRADLE_H
+#define PLUGINCRADLE_H
+
+#ifdef PLUGINCRADLE_EXPORTS
+#define PLUGIN_API __declspec(dllexport)
+#else
+#define PLUGIN_API __declspec(dllimport)
+#endif
+
+// ----------------------------------------------------------
+
+struct Plugin;
+
+// ----------------------------------------------------------
+
+#define DLL_CALLCONV __stdcall
+
+// ----------------------------------------------------------
+
+extern "C" {
+ PLUGIN_API void DLL_CALLCONV Init(Plugin &plugin, int format_id);
+}
+
+#endif
diff --git a/freeimage241/FreeImage.dsp b/freeimage241/FreeImage.dsp
new file mode 100644
index 0000000..1f752c9
--- /dev/null
+++ b/freeimage241/FreeImage.dsp
@@ -0,0 +1,274 @@
+# Microsoft Developer Studio Project File - Name="FreeImage" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
+
+CFG=FreeImage - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "FreeImage.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "FreeImage.mak" CFG="FreeImage - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "FreeImage - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "FreeImage - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "FreeImage - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "FREEIMAGE_EXPORTS" /YX /FD /c
+# ADD CPP /nologo /G6 /Gd /MT /W3 /GX /O1 /I "Source" /I "Source\ZLib" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "FREEIMAGE_EXPORTS" /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
+# Begin Special Build Tool
+SOURCE="$(InputPath)"
+PostBuild_Cmds=copy Release\FreeImage.dll Dist copy Release\FreeImage.lib Dist copy Source\FreeImage.h Dist
+# End Special Build Tool
+
+!ELSEIF "$(CFG)" == "FreeImage - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "FREEIMAGE_EXPORTS" /YX /FD /GZ /c
+# ADD CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /I "Source" /I "Source\ZLib" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "FREEIMAGE_EXPORTS" /FD /GZ /c
+# SUBTRACT CPP /YX
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /out:"Debug/FreeImaged.dll" /pdbtype:sept
+# SUBTRACT LINK32 /incremental:no
+# Begin Special Build Tool
+SOURCE="$(InputPath)"
+PostBuild_Cmds=copy Debug\FreeImaged.dll Dist copy Debug\FreeImaged.lib Dist copy Source\FreeImage.h Dist
+# End Special Build Tool
+
+!ENDIF
+
+# Begin Target
+
+# Name "FreeImage - Win32 Release"
+# Name "FreeImage - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Group "Plugins"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\Source\FreeImage\Plugin.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Source\FreeImage\PluginBMP.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Source\FreeImage\PluginICO.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Source\FreeImage\PluginIFF.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Source\FreeImage\PluginJPEG.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Source\FreeImage\PluginKOALA.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Source\FreeImage\PluginMNG.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Source\FreeImage\PluginPCD.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Source\FreeImage\PluginPCX.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Source\FreeImage\PluginPNG.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Source\FreeImage\PluginPNM.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Source\FreeImage\PluginPSD.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Source\FreeImage\PluginRAS.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Source\FreeImage\PluginTARGA.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Source\FreeImage\PluginTIFF.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Source\FreeImage\PluginWBMP.cpp
+# End Source File
+# End Group
+# Begin Group "Conversion"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\Source\FreeImage\Conversion.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Source\FreeImage\Conversion16_555.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Source\FreeImage\Conversion16_565.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Source\FreeImage\Conversion24.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Source\FreeImage\Conversion32.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Source\FreeImage\Conversion8.cpp
+# End Source File
+# End Group
+# Begin Group "Quantizers"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\Source\FreeImage\NNQuantizer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Source\FreeImage\WuQuantizer.cpp
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=.\Source\FreeImage\BitmapAccess.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Source\FreeImage\FreeImage.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Source\FreeImage\FreeImageIO.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Source\FreeImage\GetType.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Source\FreeImage\LoadFunctions.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=.\Source\FreeImage.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Source\FreeImageIO.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Source\Plugin.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Source\Quantizers.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Source\Utilities.h
+# End Source File
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
+# End Group
+# Begin Source File
+
+SOURCE=.\KnownBugs.txt
+# End Source File
+# Begin Source File
+
+SOURCE=.\Todo.txt
+# End Source File
+# Begin Source File
+
+SOURCE=.\Whatsnew.txt
+# End Source File
+# End Target
+# End Project
diff --git a/freeimage241/FreeImage.dsw b/freeimage241/FreeImage.dsw
new file mode 100644
index 0000000..0ddecc0
--- /dev/null
+++ b/freeimage241/FreeImage.dsw
@@ -0,0 +1,158 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "FreeImage"=.\FreeImage.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+ Begin Project Dependency
+ Project_Dep_Name LibJPEG
+ End Project Dependency
+ Begin Project Dependency
+ Project_Dep_Name LibPNG
+ End Project Dependency
+ Begin Project Dependency
+ Project_Dep_Name LibTIFF
+ End Project Dependency
+ Begin Project Dependency
+ Project_Dep_Name ZLib
+ End Project Dependency
+ Begin Project Dependency
+ Project_Dep_Name LibMNG
+ End Project Dependency
+}}}
+
+###############################################################################
+
+Project: "FreeImageLib"=.\SOURCE\FreeImageLib\FreeImageLib.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+ Begin Project Dependency
+ Project_Dep_Name LibJPEG
+ End Project Dependency
+ Begin Project Dependency
+ Project_Dep_Name LibMNG
+ End Project Dependency
+ Begin Project Dependency
+ Project_Dep_Name LibPNG
+ End Project Dependency
+ Begin Project Dependency
+ Project_Dep_Name LibTIFF
+ End Project Dependency
+}}}
+
+###############################################################################
+
+Project: "FreeImageQt"=.\Source\FreeImageQt\FreeImageQt.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Project: "LibJPEG"=.\Source\LibJPEG\LibJPEG.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Project: "LibMNG"=.\Source\LibMNG\LibMNG.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+ Begin Project Dependency
+ Project_Dep_Name ZLib
+ End Project Dependency
+}}}
+
+###############################################################################
+
+Project: "LibPNG"=.\Source\LibPNG\LibPNG.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Project: "LibTIFF"=.\Source\LibTIFF\LibTIFF.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Project: "Test"=.\Source\Test\Test.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+ Begin Project Dependency
+ Project_Dep_Name FreeImage
+ End Project Dependency
+}}}
+
+###############################################################################
+
+Project: "ZLib"=.\Source\ZLib\ZLib.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/freeimage241/KnownBugs.txt b/freeimage241/KnownBugs.txt
new file mode 100644
index 0000000..fb8e85e
--- /dev/null
+++ b/freeimage241/KnownBugs.txt
@@ -0,0 +1,27 @@
+Known bugs for FreeImage
+
+- PHOTOSHOP AND ALPHA-CHANNELED TIFF ------------------------------------
+
+LibTIFF doesn't load the alpha channel when that file is created
+with Adobe Photoshop. This is a bug in Photoshop as it writes
+the TIFF in a non-standard, non-documented way. According to
+the LibTIFF mailing list:
+
+"Photoshop's PSD file format allows for a number of layers, alpha
+channels, etc. In such a sceme, there is no such thing as a single alpha
+channel, but only a number of channels, some of which represent colors
+in layers, or in a global picture, others alpha's that can have just
+about any local layers or global image meaning and must even considered
+to be editable and enablable/disablable by users all the time. I guess
+this makes adobe reluctant to define such a thing as a single alpha
+channel, including when they write out other formats that allow for
+something else/more than a single alpha."
+
+On the same libTIFF mailing a semi-solution is provided:
+
+"If I create a 32-bit (24-bit + 8 bit alpha) TGA image in another
+program, and load it into Photoshop, Photoshop shows it as RGBA.
+If I then save it to TIFF, Photoshop properly flags it as an Alpha
+channel, and TIFFReadRGBAImage reads it fine. I'm not sure what
+Photoshop does differently when you create an Alpha channel by hand
+versus loading it with the image."
diff --git a/freeimage241/Makefile b/freeimage241/Makefile
new file mode 100644
index 0000000..f9e2275
--- /dev/null
+++ b/freeimage241/Makefile
@@ -0,0 +1,38 @@
+
+# configure your options in Makefile.cfg
+
+include Makefile.cfg
+
+
+
+all: default
+
+default: dist examples
+
+dist: FreeImage
+ cp Source/FreeImage/*.a Dist
+ cp Source/FreeImage/*.so Dist
+
+examples: FreeImage
+ make -C Examples/Linux all
+
+FreeImage:
+ @if [ ! -f .nodos2unix ]; then \
+ $(DOS2UNIX) Source/*.[ch]* Source/FreeImage/*.[ch]* \
+ Source/LibJPEG/*.[ch]* Source/LibMNG/*.[ch]* Source/LibPNG/*.[ch]* \
+ Source/LibTIFF/*.[ch]* Source/ZLib/*.[ch]* \
+ Examples/Linux/*.[ch]* ; \
+ touch .nodos2unix; \
+ fi
+ make -C Source/FreeImage all
+
+refix:
+ rm .nodos2unix
+
+install:
+ make -C Source/FreeImage install
+
+clean:
+ rm -f Dist/* u2dtmp* .nodos2unix
+ make -C Source/FreeImage clean
+ make -C Examples clean
diff --git a/freeimage241/Makefile.cfg b/freeimage241/Makefile.cfg
new file mode 100644
index 0000000..7d2ee8e
--- /dev/null
+++ b/freeimage241/Makefile.cfg
@@ -0,0 +1,10 @@
+CC = gcc
+CPP = g++
+
+INSTALLDIR = /usr/lib
+
+#converts cr/lf to just lf
+DOS2UNIX = dos2unix
+
+COMPILERFLAGS = -O3
+LIBRARIES = -ljpeg -lpng -ltiff -lmng
diff --git a/freeimage241/README.linux b/freeimage241/README.linux
new file mode 100644
index 0000000..de3b83a
--- /dev/null
+++ b/freeimage241/README.linux
@@ -0,0 +1,23 @@
+Check Makefile.cfg and set the variables in there if things dont work.
+This compiles with no warnings at all with the default options on
+Redhat 6.2 / Linux-2.2.16 with glibc6 and the pre-installed libjpeg,
+libpng, libtiff, and libz libraries that were already installed in my
+/usr/lib directory.
+I tested the GTK example I wrote under X11R6 running 1024x768x24bit but
+the machine I was using does not allow switching to other modes, so
+I am unsure if the picture would be displayed properly in other video
+modes.
+You should be able to link progams with the -lfreeimage options after
+it is compiled and installed, which will require that libjpeg, libpng,
+libtiff, and libz are installed as well. If you statically link with
+libfreeimage.a you must also link with libjpeg.a, libpng.a, libtiff.a,
+and libz.a.
+If you unzip a new snapshot over old code, it will need to be reran
+thru dos2unix to strip the CR's from it. `make refix` or just
+rm .nodos2unix yourself to allow make to rerun dos2unix next time
+the library is build.
+Please let me know how this works for you under Linux or any other *nix
+
+- Ryan "Ark" Rubley
+- ark@lhq.com / rubleyr@csis.gvsu.edu
+
diff --git a/freeimage241/README.txt b/freeimage241/README.txt
new file mode 100644
index 0000000..e69de29
diff --git a/freeimage241/Source/FreeImage/BitmapAccess.cpp b/freeimage241/Source/FreeImage/BitmapAccess.cpp
new file mode 100644
index 0000000..5c51426
--- /dev/null
+++ b/freeimage241/Source/FreeImage/BitmapAccess.cpp
@@ -0,0 +1,323 @@
+// ==========================================================
+// FreeImage implementation
+//
+// Design and implementation by
+// - Floris van den Berg (flvdberg@wxs.nl)
+// - Hervé Drolon (drolon@iut.univ-lehavre.fr)
+//
+// This file is part of FreeImage 2
+//
+// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
+// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
+// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
+// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
+// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
+// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
+// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+// THIS DISCLAIMER.
+//
+// Use at your own risk!
+// ==========================================================
+
+#pragma warning (disable : 4786)
+
+#include
+
+#include "FreeImage.h"
+#include "FreeImageIO.h"
+#include "Utilities.h"
+
+// ----------------------------------------------------------
+
+FI_STRUCT (FREEIMAGEHEADER) {
+ unsigned red_mask;
+ unsigned green_mask;
+ unsigned blue_mask;
+ BOOL transparent;
+ BYTE transparency_count;
+ BYTE transparent_table[256];
+ BYTE filler[3];
+};
+
+// ----------------------------------------------------------
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_Allocate(int width, int height, int bpp, unsigned red_mask, unsigned green_mask, unsigned blue_mask) {
+ FIBITMAP *bitmap = (FIBITMAP *)malloc(sizeof(FIBITMAP));
+
+ if (bitmap != NULL) {
+ height = abs(height);
+
+ int dib_size = sizeof(FREEIMAGEHEADER) + sizeof(BITMAPINFOHEADER);
+ dib_size += sizeof(RGBQUAD) * CalculateUsedColors(bpp);
+ dib_size += CalculatePitch(CalculateLine(width, bpp)) * height;
+
+ bitmap->data = (BYTE *)malloc(dib_size);
+
+ if (bitmap->data != NULL) {
+ memset(bitmap->data, 0, dib_size);
+
+ // write out the FREEIMAGEHEADER
+
+ FREEIMAGEHEADER *fih = (FREEIMAGEHEADER *)bitmap->data;
+ fih->red_mask = red_mask;
+ fih->green_mask = green_mask;
+ fih->blue_mask = blue_mask;
+ fih->transparent = FALSE;
+ fih->transparency_count = 0;
+
+ // write out the BITMAPINFOHEADER
+
+ BITMAPINFOHEADER *bih = FreeImage_GetInfoHeader(bitmap);
+ bih->biSize = sizeof(BITMAPINFOHEADER);
+ bih->biWidth = width;
+ bih->biHeight = height;
+ bih->biPlanes = 1;
+ bih->biCompression = 0;
+ bih->biBitCount = bpp;
+ bih->biClrUsed = CalculateUsedColors(bpp);
+ bih->biClrImportant = bih->biClrUsed;
+
+ return bitmap;
+ } else {
+ free(bitmap);
+ }
+ }
+
+ return NULL;
+}
+
+void DLL_CALLCONV
+FreeImage_Free(FIBITMAP *dib) {
+ if (dib != NULL) {
+ if (dib->data != NULL)
+ free(dib->data);
+
+ free(dib);
+ }
+}
+
+void DLL_CALLCONV
+FreeImage_Unload(FIBITMAP *dib) {
+ FreeImage_Free(dib);
+}
+
+// ----------------------------------------------------------
+
+FREE_IMAGE_COLOR_TYPE DLL_CALLCONV
+FreeImage_GetColorType(FIBITMAP *dib) {
+ RGBQUAD *rgb;
+
+ switch (FreeImage_GetBPP(dib)) {
+ case 1:
+ {
+ rgb = FreeImage_GetPalette(dib);
+
+ if ((rgb->rgbRed == 0) && (rgb->rgbGreen == 0) && (rgb->rgbBlue == 0)) {
+ rgb++;
+
+ if ((rgb->rgbRed == 255) && (rgb->rgbGreen == 255) && (rgb->rgbBlue == 255))
+ return FIC_MINISBLACK;
+ }
+
+ if ((rgb->rgbRed == 255) && (rgb->rgbGreen == 255) && (rgb->rgbBlue == 255)) {
+ rgb++;
+
+ if ((rgb->rgbRed == 0) && (rgb->rgbGreen == 0) && (rgb->rgbBlue == 0))
+ return FIC_MINISWHITE;
+ }
+
+ return FIC_PALETTE;
+ }
+
+ case 4:
+ case 8: // Check if the DIB has a color or a greyscale palette
+ {
+ rgb = FreeImage_GetPalette(dib);
+
+ for (unsigned i = 0; i < FreeImage_GetColorsUsed(dib); i++) {
+ if ((rgb->rgbRed != rgb->rgbGreen) || (rgb->rgbRed != rgb->rgbBlue))
+ return FIC_PALETTE;
+
+ // The DIB has a color palette if the greyscale isn't a linear ramp
+
+ if (rgb->rgbRed != i)
+ return FIC_PALETTE;
+
+ rgb++;
+ }
+
+ return FIC_MINISBLACK;
+ }
+
+ case 16:
+ case 24:
+ return FIC_RGB;
+
+ case 32:
+ {
+ for (unsigned y = 0; y < FreeImage_GetHeight(dib); ++y) {
+ rgb = (RGBQUAD *)FreeImage_GetScanLine(dib, y);
+
+ for (unsigned x = 0; x < FreeImage_GetWidth(dib); ++x)
+ if (rgb[x].rgbReserved != 0)
+ return FIC_RGBALPHA;
+ }
+
+ return FIC_RGB;
+ }
+
+ default :
+ return FIC_MINISBLACK;
+ }
+}
+
+// ----------------------------------------------------------
+
+unsigned DLL_CALLCONV
+FreeImage_GetRedMask(FIBITMAP *dib) {
+ return dib ? ((FREEIMAGEHEADER *)dib->data)->red_mask : 0;
+}
+
+unsigned DLL_CALLCONV
+FreeImage_GetGreenMask(FIBITMAP *dib) {
+ return dib ? ((FREEIMAGEHEADER *)dib->data)->green_mask : 0;
+}
+
+unsigned DLL_CALLCONV
+FreeImage_GetBlueMask(FIBITMAP *dib) {
+ return dib ? ((FREEIMAGEHEADER *)dib->data)->blue_mask : 0;
+}
+
+BOOL DLL_CALLCONV
+FreeImage_IsTransparent(FIBITMAP *dib) {
+ return (dib != NULL) ? ((FREEIMAGEHEADER *)dib->data)->transparent : FALSE;
+}
+
+BYTE * DLL_CALLCONV
+FreeImage_GetTransparencyTable(FIBITMAP *dib) {
+ return dib ? ((FREEIMAGEHEADER *)dib->data)->transparent_table : NULL;
+}
+
+void DLL_CALLCONV
+FreeImage_SetTransparent(FIBITMAP *dib, BOOL enabled) {
+ if (dib) {
+ if ((FreeImage_GetBPP(dib) == 8) || (FreeImage_GetBPP(dib) == 32)) {
+ ((FREEIMAGEHEADER *)dib->data)->transparent = enabled;
+ } else {
+ ((FREEIMAGEHEADER *)dib->data)->transparent = FALSE;
+ }
+ }
+}
+
+unsigned DLL_CALLCONV
+FreeImage_GetTransparencyCount(FIBITMAP *dib) {
+ return dib ? ((FREEIMAGEHEADER *)dib->data)->transparency_count : 0;
+}
+
+void DLL_CALLCONV
+FreeImage_SetTransparencyTable(FIBITMAP *dib, BYTE *table, BYTE count) {
+ if (dib) {
+ if (FreeImage_GetBPP(dib) == 8) {
+ ((FREEIMAGEHEADER *)dib->data)->transparent = TRUE;
+ ((FREEIMAGEHEADER *)dib->data)->transparency_count = count;
+
+ if (table != NULL) {
+ memcpy(((FREEIMAGEHEADER *)dib->data)->transparent_table, table, count);
+ } else {
+ memset(((FREEIMAGEHEADER *)dib->data)->transparent_table, 0xff, count);
+ }
+ } else {
+ ((FREEIMAGEHEADER *)dib->data)->transparency_count = 0;
+ }
+ }
+}
+
+// ----------------------------------------------------------
+
+unsigned DLL_CALLCONV
+FreeImage_GetWidth(FIBITMAP *dib) {
+ return dib ? FreeImage_GetInfoHeader(dib)->biWidth : 0;
+}
+
+unsigned DLL_CALLCONV
+FreeImage_GetHeight(FIBITMAP *dib) {
+ return (dib) ? FreeImage_GetInfoHeader(dib)->biHeight : 0;
+}
+
+unsigned DLL_CALLCONV
+FreeImage_GetBPP(FIBITMAP *dib) {
+ return dib ? FreeImage_GetInfoHeader(dib)->biBitCount : 0;
+}
+
+unsigned DLL_CALLCONV
+FreeImage_GetLine(FIBITMAP *dib) {
+ return dib ? ((FreeImage_GetWidth(dib) * FreeImage_GetBPP(dib)) + 7) / 8 : 0;
+}
+
+unsigned DLL_CALLCONV
+FreeImage_GetPitch(FIBITMAP *dib) {
+ return dib ? FreeImage_GetLine(dib) + 3 & ~3 : 0;
+}
+
+unsigned DLL_CALLCONV
+FreeImage_GetColorsUsed(FIBITMAP *dib) {
+ return dib ? FreeImage_GetInfoHeader(dib)->biClrUsed : 0;
+}
+
+BYTE * DLL_CALLCONV
+FreeImage_GetBits(FIBITMAP *dib) {
+ return dib ? ((BYTE *)FreeImage_GetInfoHeader(dib) + sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * FreeImage_GetInfoHeader(dib)->biClrUsed) : NULL;
+}
+
+BYTE * DLL_CALLCONV
+FreeImage_GetBitsRowCol(FIBITMAP *dib, int col, int row) {
+ if (dib) {
+ int width = FreeImage_GetWidth(dib);
+
+ if (FreeImage_GetBPP(dib) == 4)
+ width /= 2;
+ else if (FreeImage_GetBPP(dib) == 1)
+ width /= 8;
+
+ return FreeImage_GetBits(dib) + ((FreeImage_GetHeight(dib) - row - 1) * FreeImage_GetPitch(dib)) + (col * FreeImage_GetBPP(dib) / 8);
+ } else {
+ return NULL;
+ }
+}
+
+BYTE * DLL_CALLCONV
+FreeImage_GetScanLine(FIBITMAP *dib, int scanline) {
+ return (dib) ? CalculateScanLine(FreeImage_GetBits(dib), FreeImage_GetPitch(dib), scanline) : NULL;
+}
+
+unsigned DLL_CALLCONV
+FreeImage_GetDIBSize(FIBITMAP *dib) {
+ return (dib) ? sizeof(BITMAPINFOHEADER) + (FreeImage_GetColorsUsed(dib) * sizeof(RGBQUAD)) + (FreeImage_GetPitch(dib) * FreeImage_GetHeight(dib)) : 0;
+}
+
+RGBQUAD * DLL_CALLCONV
+FreeImage_GetPalette(FIBITMAP *dib) {
+ return (dib && FreeImage_GetBPP(dib) < 16) ? (RGBQUAD *)((BYTE *)dib->data + sizeof(FREEIMAGEHEADER) + sizeof(BITMAPINFOHEADER)) : NULL;
+}
+
+unsigned DLL_CALLCONV
+FreeImage_GetDotsPerMeterX(FIBITMAP *dib) {
+ return FreeImage_GetInfoHeader(dib)->biXPelsPerMeter;
+}
+
+unsigned DLL_CALLCONV
+FreeImage_GetDotsPerMeterY(FIBITMAP *dib) {
+ return (dib) ? FreeImage_GetInfoHeader(dib)->biYPelsPerMeter : 0;
+}
+
+BITMAPINFOHEADER * DLL_CALLCONV
+FreeImage_GetInfoHeader(FIBITMAP *dib) {
+ return (dib) ? (BITMAPINFOHEADER *)((BYTE *)dib->data + sizeof(FREEIMAGEHEADER)) : NULL;
+}
+
+BITMAPINFO * DLL_CALLCONV
+FreeImage_GetInfo(FIBITMAP *dib) {
+ return (dib) ? (BITMAPINFO *)((BYTE *)dib->data + sizeof(FREEIMAGEHEADER)) : NULL;
+}
diff --git a/freeimage241/Source/FreeImage/Conversion.cpp b/freeimage241/Source/FreeImage/Conversion.cpp
new file mode 100644
index 0000000..a6b148d
--- /dev/null
+++ b/freeimage241/Source/FreeImage/Conversion.cpp
@@ -0,0 +1,185 @@
+// ==========================================================
+// Bitmap conversion routines
+//
+// Design and implementation by
+// - Floris van den Berg (flvdberg@wxs.nl)
+// - Hervé Drolon (drolon@iut.univ-lehavre.fr)
+// - Jani Kajala (janik@remedy.fi)
+//
+// This file is part of FreeImage 2
+//
+// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
+// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
+// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
+// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
+// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
+// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
+// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+// THIS DISCLAIMER.
+//
+// Use at your own risk!
+// ==========================================================
+
+#include
+
+#include "FreeImage.h"
+#include "Quantizers.h"
+
+// ----------------------------------------------------------
+
+#define CONVERT(from, to) case to : FreeImage_ConvertLine##from##To##to(bits, scanline, FreeImage_GetWidth(dib)); break;
+#define CONVERTWITHPALETTE(from, to) case to : FreeImage_ConvertLine##from##To##to(bits, scanline, FreeImage_GetWidth(dib), FreeImage_GetPalette(dib)); break;
+
+#define CONVERTTO16(from) \
+ case 16 : \
+ if ((red_mask == 0x7C00) && (green_mask == 0x3E0) && (blue_mask == 0x1F)) { \
+ FreeImage_ConvertLine##from##To16_555(bits, scanline, FreeImage_GetWidth(dib)); \
+ } else { \
+ FreeImage_ConvertLine##from##To16_565(bits, scanline, FreeImage_GetWidth(dib)); \
+ } \
+ break;
+
+#define CONVERTTO16WITHPALETTE(from) \
+ case 16 : \
+ if ((red_mask == 0x7C00) && (green_mask == 0x3E0) && (blue_mask == 0x1F)) { \
+ FreeImage_ConvertLine##from##To16_555(bits, scanline, FreeImage_GetWidth(dib), FreeImage_GetPalette(dib)); \
+ } else { \
+ FreeImage_ConvertLine##from##To16_565(bits, scanline, FreeImage_GetWidth(dib), FreeImage_GetPalette(dib)); \
+ } \
+ break;
+
+// ==========================================================
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_ColorQuantize(FIBITMAP *dib, FREE_IMAGE_QUANTIZE quantize) {
+ if (dib) {
+ if (FreeImage_GetBPP(dib) == 24) {
+ switch(quantize) {
+ case FIQ_WUQUANT :
+ try {
+ WuQuantizer Q (dib);
+ return (FIBITMAP *) Q.Quantize();
+ } catch (char *) {
+ return NULL;
+ }
+
+ case FIQ_NNQUANT :
+ return NNQuantizer(dib, 15);
+ }
+ }
+ }
+
+ return NULL;
+}
+
+// ==========================================================
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_ConvertFromRawBits(BYTE *bits, int width, int height, int pitch, unsigned bpp, unsigned red_mask, unsigned green_mask, unsigned blue_mask, BOOL topdown) {
+ FIBITMAP *dib = FreeImage_Allocate(width, height, bpp, red_mask, green_mask, blue_mask);
+
+ if (dib != NULL) {
+ if (topdown) {
+ for (int i = 0; i < height; ++i) {
+ memcpy(FreeImage_GetScanLine(dib, i), bits, FreeImage_GetLine(dib));
+
+ bits += pitch;
+ }
+ } else {
+ for (int i = height - 1; i >= 0; --i) {
+ memcpy(FreeImage_GetScanLine(dib, i), bits, FreeImage_GetLine(dib));
+
+ bits += pitch;
+ }
+ }
+ }
+
+ return dib;
+}
+
+void DLL_CALLCONV
+FreeImage_ConvertToRawBits(BYTE *bits, FIBITMAP *dib, int pitch, unsigned bpp, unsigned red_mask, unsigned green_mask, unsigned blue_mask, BOOL topdown) {
+ if ((dib != NULL) && (bits != NULL)) {
+ for (unsigned i = 0; i < FreeImage_GetHeight(dib); ++i) {
+ BYTE *scanline;
+
+ if (topdown) {
+ scanline = FreeImage_GetScanLine(dib, i);
+ } else {
+ scanline = FreeImage_GetScanLine(dib, FreeImage_GetHeight(dib) - i - 1);
+ }
+
+ if ((bpp == 16) && (FreeImage_GetBPP(dib) == 16)) {
+ // convert 555 to 565 or vice versa
+
+ if ((red_mask == 0x7C00) && (green_mask == 0x3E0) && (blue_mask == 0x1F)) {
+ if ((FreeImage_GetRedMask(dib) == 0xF800) && (FreeImage_GetGreenMask(dib) == 0x7E0) && (FreeImage_GetBlueMask(dib) == 0x1F)) {
+ FreeImage_ConvertLine16_555_To16_565(bits, scanline, FreeImage_GetWidth(dib));
+ } else {
+ memcpy(bits, scanline, FreeImage_GetLine(dib));
+ }
+ } else {
+ if ((FreeImage_GetRedMask(dib) == 0x7C00) && (FreeImage_GetGreenMask(dib) == 0x3E0) && (FreeImage_GetBlueMask(dib) == 0x1F)) {
+ FreeImage_ConvertLine16_565_To16_555(bits, scanline, FreeImage_GetWidth(dib));
+ } else {
+ memcpy(bits, scanline, FreeImage_GetLine(dib));
+ }
+ }
+ } else if (FreeImage_GetBPP(dib) != bpp) {
+ switch(FreeImage_GetBPP(dib)) {
+ case 1 :
+ switch(bpp) {
+ CONVERT(1, 8)
+ CONVERTTO16WITHPALETTE(1)
+ CONVERTWITHPALETTE(1, 24)
+ CONVERTWITHPALETTE(1, 32)
+ };
+
+ break;
+
+ case 4 :
+ switch(bpp) {
+ CONVERT(4, 8)
+ CONVERTTO16WITHPALETTE(4)
+ CONVERTWITHPALETTE(4, 24)
+ CONVERTWITHPALETTE(4, 32)
+ };
+
+ break;
+
+ case 8 :
+ switch(bpp) {
+ CONVERTTO16WITHPALETTE(8)
+ CONVERTWITHPALETTE(8, 24)
+ CONVERTWITHPALETTE(8, 32)
+ };
+
+ break;
+
+ case 24 :
+ switch(bpp) {
+ CONVERT(24, 8)
+ CONVERTTO16(24)
+ CONVERT(24, 32)
+ };
+
+ break;
+
+ case 32 :
+ switch(bpp) {
+ CONVERT(32, 8)
+ CONVERTTO16(32)
+ CONVERT(32, 24)
+ };
+
+ break;
+ };
+ } else {
+ memcpy(bits, scanline, FreeImage_GetLine(dib));
+ }
+
+ bits += pitch;
+ }
+ }
+}
diff --git a/freeimage241/Source/FreeImage/Conversion16_555.cpp b/freeimage241/Source/FreeImage/Conversion16_555.cpp
new file mode 100644
index 0000000..9f5ded5
--- /dev/null
+++ b/freeimage241/Source/FreeImage/Conversion16_555.cpp
@@ -0,0 +1,211 @@
+// ==========================================================
+// Bitmap conversion routines
+//
+// Design and implementation by
+// - Floris van den Berg (flvdberg@wxs.nl)
+// - Hervé Drolon (drolon@iut.univ-lehavre.fr)
+// - Jani Kajala (janik@remedy.fi)
+//
+// This file is part of FreeImage 2
+//
+// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
+// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
+// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
+// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
+// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
+// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
+// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+// THIS DISCLAIMER.
+//
+// Use at your own risk!
+// ==========================================================
+
+#include "FreeImage.h"
+#include "Utilities.h"
+
+// ----------------------------------------------------------
+
+#define RGB555(r, g, b) (((r) >> 3) | (((g) >> 3) << 5) | (((b) >> 3) << 10))
+
+// ----------------------------------------------------------
+// internal conversions X to 16 bits (555)
+// ----------------------------------------------------------
+
+void DLL_CALLCONV
+FreeImage_ConvertLine1To16_555(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette) {
+ WORD *new_bits = (WORD *)target;
+
+ for (int cols = 0; cols < width_in_pixels; cols++) {
+ int index = (source[cols >> 3] & (0x80 >> (cols & 0x07))) != 0 ? 1 : 0;
+
+ new_bits[cols] = RGB555(palette[index].rgbBlue, palette[index].rgbGreen, palette[index].rgbRed);
+ }
+}
+
+void DLL_CALLCONV
+FreeImage_ConvertLine4To16_555(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette) {
+ WORD *new_bits = (WORD *)target;
+ BOOL lonibble = FALSE;
+ int x = 0;
+
+ for (int cols = 0; cols < width_in_pixels; cols++) {
+ RGBQUAD *grab_palette;
+
+ if (lonibble) {
+ grab_palette = palette + LOWNIBBLE(source[x++]);
+ } else {
+ grab_palette = palette + (HINIBBLE(source[x]) >> 4);
+ }
+
+ new_bits[cols] = RGB555(grab_palette->rgbBlue, grab_palette->rgbGreen, grab_palette->rgbRed);
+
+ lonibble = !lonibble;
+ }
+}
+
+void DLL_CALLCONV
+FreeImage_ConvertLine8To16_555(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette) {
+ WORD *new_bits = (WORD *)target;
+
+ for (int cols = 0; cols < width_in_pixels; cols++) {
+ RGBQUAD *grab_palette = palette + source[cols];
+
+ new_bits[cols] = RGB555(grab_palette->rgbBlue, grab_palette->rgbGreen, grab_palette->rgbRed);
+ }
+}
+
+void DLL_CALLCONV
+FreeImage_ConvertLine16_565_To16_555(BYTE *target, BYTE *source, int width_in_pixels) {
+ WORD *src_bits = (WORD *)source;
+ WORD *new_bits = (WORD *)target;
+
+ for (int cols = 0; cols < width_in_pixels; cols++) {
+ new_bits[cols] = RGB555((((src_bits[cols] & 0x7C00) >> 10) * 0xFF) / 0x1F,
+ (((src_bits[cols] & 0x3E0) >> 5) * 0xFF) / 0x1F,
+ ((src_bits[cols] & 0x1F) * 0xFF) / 0x1F);
+ }
+}
+
+void DLL_CALLCONV
+FreeImage_ConvertLine24To16_555(BYTE *target, BYTE *source, int width_in_pixels) {
+ WORD *new_bits = (WORD *)target;
+
+ for (int cols = 0; cols < width_in_pixels; cols++) {
+ new_bits[cols] = RGB555(source[0], source[1], source[2]);
+
+ source += 3;
+ }
+}
+
+void DLL_CALLCONV
+FreeImage_ConvertLine32To16_555(BYTE *target, BYTE *source, int width_in_pixels) {
+ WORD *new_bits = (WORD *)target;
+
+ for (int cols = 0; cols < width_in_pixels; cols++) {
+ new_bits[cols] = RGB555(source[0], source[1], source[2]);
+
+ source += 4;
+ }
+}
+
+// ----------------------------------------------------------
+// smart convert X to 16 bits
+// ----------------------------------------------------------
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_ConvertTo16Bits555(FIBITMAP *dib) {
+ if (dib != NULL) {
+ int width = FreeImage_GetWidth(dib);
+ int height = FreeImage_GetHeight(dib);
+
+ switch (FreeImage_GetBPP(dib)) {
+ case 1 :
+ {
+ FIBITMAP *new_dib = FreeImage_Allocate(width, height, 16, 0x1F, 0x3E0, 0x7C00);
+
+ if (new_dib) {
+ for (int rows = 0; rows < height; rows++)
+ FreeImage_ConvertLine1To16_555(FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), width, FreeImage_GetPalette(dib));
+
+ return new_dib;
+ }
+
+ break;
+ }
+
+ case 4 :
+ {
+ FIBITMAP *new_dib = FreeImage_Allocate(width, height, 16, 0x1F, 0x3E0, 0x7C00);
+
+ if (new_dib) {
+ for (int rows = 0; rows < height; rows++)
+ FreeImage_ConvertLine4To16_555(FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), width, FreeImage_GetPalette(dib));
+
+ return new_dib;
+ }
+
+ break;
+ }
+
+ case 8 :
+ {
+ FIBITMAP *new_dib = FreeImage_Allocate(width, height, 16, 0x1F, 0x3E0, 0x7C00);
+
+ if (new_dib) {
+ for (int rows = 0; rows < height; rows++)
+ FreeImage_ConvertLine8To16_555(FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), width, FreeImage_GetPalette(dib));
+
+ return new_dib;
+ }
+
+ break;
+ }
+
+ case 16 :
+ {
+
+ FIBITMAP *new_dib = FreeImage_Allocate(width, height, 16, 0x1F, 0x3E0, 0x7C00);
+
+ if (new_dib) {
+ for (int rows = 0; rows < height; rows++)
+ FreeImage_ConvertLine16_565_To16_555(FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), width);
+
+ return new_dib;
+ }
+
+ break;
+ }
+
+ case 24 :
+ {
+ FIBITMAP *new_dib = FreeImage_Allocate(width, height, 16, 0x1F, 0x3E0, 0x7C00);
+
+ if (new_dib) {
+ for (int rows = 0; rows < height; rows++)
+ FreeImage_ConvertLine24To16_555(FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), width);
+
+ return new_dib;
+ }
+
+ break;
+ }
+
+ case 32 :
+ {
+ FIBITMAP *new_dib = FreeImage_Allocate(width, height, 16, 0x1F, 0x3E0, 0x7C00);
+
+ if (new_dib) {
+ for (int rows = 0; rows < height; rows++)
+ FreeImage_ConvertLine32To16_555(FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), width);
+
+ return new_dib;
+ }
+
+ break;
+ }
+ }
+ }
+
+ return NULL;
+}
diff --git a/freeimage241/Source/FreeImage/Conversion16_565.cpp b/freeimage241/Source/FreeImage/Conversion16_565.cpp
new file mode 100644
index 0000000..6529c28
--- /dev/null
+++ b/freeimage241/Source/FreeImage/Conversion16_565.cpp
@@ -0,0 +1,214 @@
+// ==========================================================
+// Bitmap conversion routines
+//
+// Design and implementation by
+// - Floris van den Berg (flvdberg@wxs.nl)
+// - Hervé Drolon (drolon@iut.univ-lehavre.fr)
+// - Jani Kajala (janik@remedy.fi)
+//
+// This file is part of FreeImage 2
+//
+// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
+// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
+// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
+// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
+// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
+// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
+// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+// THIS DISCLAIMER.
+//
+// Use at your own risk!
+// ==========================================================
+
+#include "FreeImage.h"
+#include "Utilities.h"
+
+// ----------------------------------------------------------
+
+#define RGB565(r, g, b) (((r) >> 3) | (((g) >> 2) << 5) | (((b) >> 3) << 11))
+
+// ----------------------------------------------------------
+// internal conversions X to 16 bits (565)
+// ----------------------------------------------------------
+
+void DLL_CALLCONV
+FreeImage_ConvertLine1To16_565(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette) {
+ WORD *new_bits = (WORD *)target;
+
+ for (int cols = 0; cols < width_in_pixels; cols++) {
+ int index = (source[cols >> 3] & (0x80 >> (cols & 0x07))) != 0 ? 1 : 0;
+
+ new_bits[cols] = RGB565(palette[index].rgbBlue, palette[index].rgbGreen, palette[index].rgbRed);
+ }
+}
+
+void DLL_CALLCONV
+FreeImage_ConvertLine4To16_565(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette) {
+ WORD *new_bits = (WORD *)target;
+ BOOL lonibble = FALSE;
+ int x = 0;
+
+ for (int cols = 0; cols < width_in_pixels; cols++) {
+ RGBQUAD *grab_palette;
+
+ if (lonibble) {
+ grab_palette = palette + LOWNIBBLE(source[x++]);
+ } else {
+ grab_palette = palette + (HINIBBLE(source[x]) >> 4);
+ }
+
+ new_bits[cols] = RGB565(grab_palette->rgbBlue, grab_palette->rgbGreen, grab_palette->rgbRed);
+
+ lonibble = !lonibble;
+ }
+}
+
+void DLL_CALLCONV
+FreeImage_ConvertLine8To16_565(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette) {
+ WORD *new_bits = (WORD *)target;
+
+ for (int cols = 0; cols < width_in_pixels; cols++) {
+ RGBQUAD *grab_palette = palette + source[cols];
+
+ new_bits[cols] = RGB565(grab_palette->rgbBlue, grab_palette->rgbGreen, grab_palette->rgbRed);
+ }
+}
+
+void DLL_CALLCONV
+FreeImage_ConvertLine16_555_To16_565(BYTE *target, BYTE *source, int width_in_pixels) {
+ WORD *new_bits = (WORD *)target;
+
+ for (int cols = 0; cols < width_in_pixels; cols++) {
+ RGBQUAD quad;
+
+ quad.rgbBlue = (((source[cols] & 0xF800) >> 11) * 0xFF) / 0x1F;
+ quad.rgbGreen = (((source[cols] & 0x7E0) >> 5) * 0xFF) / 0x3F;
+ quad.rgbRed = ((source[cols] & 0x1F) * 0xFF) / 0x1F;
+
+ new_bits[cols] = RGB565(quad.rgbBlue, quad.rgbGreen, quad.rgbRed);
+ }
+}
+
+void DLL_CALLCONV
+FreeImage_ConvertLine24To16_565(BYTE *target, BYTE *source, int width_in_pixels) {
+ WORD *new_bits = (WORD *)target;
+
+ for (int cols = 0; cols < width_in_pixels; cols++) {
+ new_bits[cols] = RGB565(source[0], source[1], source[2]);
+
+ source += 3;
+ }
+}
+
+void DLL_CALLCONV
+FreeImage_ConvertLine32To16_565(BYTE *target, BYTE *source, int width_in_pixels) {
+ WORD *new_bits = (WORD *)target;
+
+ for (int cols = 0; cols < width_in_pixels; cols++) {
+ new_bits[cols] = RGB565(source[0], source[1], source[2]);
+
+ source += 4;
+ }
+}
+
+// ----------------------------------------------------------
+// smart convert X to 16 bits (565)
+// ----------------------------------------------------------
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_ConvertTo16Bits565(FIBITMAP *dib) {
+ if (dib != NULL) {
+ int width = FreeImage_GetWidth(dib);
+ int height = FreeImage_GetHeight(dib);
+
+ switch (FreeImage_GetBPP(dib)) {
+ case 1 :
+ {
+ FIBITMAP *new_dib = FreeImage_Allocate(width, height, 16, 0x1F, 0x7E0, 0xF800);
+
+ if (new_dib) {
+ for (int rows = 0; rows < height; rows++)
+ FreeImage_ConvertLine1To16_565(FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), width, FreeImage_GetPalette(dib));
+
+ return new_dib;
+ }
+
+ break;
+ }
+
+ case 4 :
+ {
+ FIBITMAP *new_dib = FreeImage_Allocate(width, height, 16, 0x1F, 0x7E0, 0xF800);
+
+ if (new_dib) {
+ for (int rows = 0; rows < height; rows++)
+ FreeImage_ConvertLine4To16_565(FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), width, FreeImage_GetPalette(dib));
+
+ return new_dib;
+ }
+
+ break;
+ }
+
+ case 8 :
+ {
+ FIBITMAP *new_dib = FreeImage_Allocate(width, height, 16, 0x1F, 0x7E0, 0xF800);
+
+ if (new_dib) {
+ for (int rows = 0; rows < height; rows++)
+ FreeImage_ConvertLine8To16_565(FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), width, FreeImage_GetPalette(dib));
+
+ return new_dib;
+ }
+
+ break;
+ }
+
+ case 16 :
+ {
+
+ FIBITMAP *new_dib = FreeImage_Allocate(width, height, 16, 0x1F, 0x7E0, 0xF800);
+
+ if (new_dib) {
+ for (int rows = 0; rows < height; rows++)
+ FreeImage_ConvertLine16_555_To16_565(FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), width);
+
+ return new_dib;
+ }
+
+ break;
+ }
+
+ case 24 :
+ {
+ FIBITMAP *new_dib = FreeImage_Allocate(width, height, 16, 0x1F, 0x7E0, 0xF800);
+
+ if (new_dib) {
+ for (int rows = 0; rows < height; rows++)
+ FreeImage_ConvertLine24To16_565(FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), width);
+
+ return new_dib;
+ }
+
+ break;
+ }
+
+ case 32 :
+ {
+ FIBITMAP *new_dib = FreeImage_Allocate(width, height, 16, 0x1F, 0x7E0, 0xF800);
+
+ if (new_dib) {
+ for (int rows = 0; rows < height; rows++)
+ FreeImage_ConvertLine32To16_565(FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), width);
+
+ return new_dib;
+ }
+
+ break;
+ }
+ }
+ }
+
+ return NULL;
+}
diff --git a/freeimage241/Source/FreeImage/Conversion24.cpp b/freeimage241/Source/FreeImage/Conversion24.cpp
new file mode 100644
index 0000000..fad494a
--- /dev/null
+++ b/freeimage241/Source/FreeImage/Conversion24.cpp
@@ -0,0 +1,193 @@
+// ==========================================================
+// Bitmap conversion routines
+//
+// Design and implementation by
+// - Floris van den Berg (flvdberg@wxs.nl)
+// - Dale Larson (dlarson@norsesoft.com)
+// - Hervé Drolon (drolon@iut.univ-lehavre.fr)
+// - Jani Kajala (janik@remedy.fi)
+//
+// This file is part of FreeImage 2
+//
+// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
+// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
+// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
+// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
+// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
+// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
+// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+// THIS DISCLAIMER.
+//
+// Use at your own risk!
+// ==========================================================
+
+#include "FreeImage.h"
+#include "Utilities.h"
+
+// ----------------------------------------------------------
+// internal conversions X to 24 bits
+// ----------------------------------------------------------
+
+void DLL_CALLCONV
+FreeImage_ConvertLine1To24(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette) {
+ for (int cols = 0; cols < width_in_pixels; cols++) {
+ BYTE index = (source[cols >> 3] & (0x80 >> (cols & 0x07))) != 0 ? 1 : 0;
+
+ target[0] = palette[index].rgbBlue;
+ target[1] = palette[index].rgbGreen;
+ target[2] = palette[index].rgbRed;
+
+ target += 3;
+ }
+}
+
+void DLL_CALLCONV
+FreeImage_ConvertLine4To24(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette) {
+ BOOL low_nibble = FALSE;
+ int x = 0;
+
+ for (int cols = 0; cols < width_in_pixels; ++cols ) {
+ if (low_nibble) {
+ target[0] = palette[LOWNIBBLE(source[x])].rgbBlue;
+ target[1] = palette[LOWNIBBLE(source[x])].rgbGreen;
+ target[2] = palette[LOWNIBBLE(source[x])].rgbRed;
+
+ x++;
+ } else {
+ target[0] = palette[HINIBBLE(source[x]) >> 4].rgbBlue;
+ target[1] = palette[HINIBBLE(source[x]) >> 4].rgbGreen;
+ target[2] = palette[HINIBBLE(source[x]) >> 4].rgbRed;
+ }
+
+ low_nibble = !low_nibble;
+
+ target += 3;
+ }
+}
+
+void DLL_CALLCONV
+FreeImage_ConvertLine8To24(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette) {
+ for (int cols = 0; cols < width_in_pixels; cols++) {
+ target[0] = palette[source[cols]].rgbBlue;
+ target[1] = palette[source[cols]].rgbGreen;
+ target[2] = palette[source[cols]].rgbRed;
+
+ target += 3;
+ }
+}
+
+void DLL_CALLCONV
+FreeImage_ConvertLine16To24_555(BYTE *target, BYTE *source, int width_in_pixels) {
+ WORD *bits = (WORD *)source;
+
+ for (int cols = 0; cols < width_in_pixels; cols++) {
+ target[2] = (((bits[cols] & 0x7C00) >> 10) * 0xFF) / 0x1F;
+ target[1] = (((bits[cols] & 0x3E0) >> 5) * 0xFF) / 0x1F;
+ target[0] = ((bits[cols] & 0x1F) * 0xFF) / 0x1F;
+
+ target += 3;
+ }
+}
+
+void DLL_CALLCONV
+FreeImage_ConvertLine16To24_565(BYTE *target, BYTE *source, int width_in_pixels) {
+ WORD *bits = (WORD *)source;
+
+ for (int cols = 0; cols < width_in_pixels; cols++) {
+ target[2] = (((bits[cols] & 0xF800) >> 11) * 0xFF) / 0x1F;
+ target[1] = (((bits[cols] & 0x7E0) >> 5) * 0xFF) / 0x3F;
+ target[0] = ((bits[cols] & 0x1F) * 0xFF) / 0x1F;
+
+ target += 3;
+ }
+}
+
+void DLL_CALLCONV
+FreeImage_ConvertLine32To24(BYTE *target, BYTE *source, int width_in_pixels) {
+ for (int cols = 0; cols < width_in_pixels; cols++) {
+ target[0] = source[0];
+ target[1] = source[1];
+ target[2] = source[2];
+
+ target += 3;
+ source += 4;
+ }
+}
+
+// ----------------------------------------------------------
+// smart convert X to 24 bits
+// ----------------------------------------------------------
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_ConvertTo24Bits(FIBITMAP *dib) {
+ if (dib != NULL) {
+ int width = FreeImage_GetWidth(dib);
+ int height = FreeImage_GetHeight(dib);
+
+ switch (FreeImage_GetBPP(dib)) {
+ case 1 :
+ {
+ FIBITMAP *new_dib = FreeImage_Allocate(width, height, 24, 0xFF, 0xFF00, 0xFF0000);
+
+ if (new_dib != NULL)
+ for (int rows = 0; rows < height; rows++)
+ FreeImage_ConvertLine1To24(FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), width, FreeImage_GetPalette(dib));
+
+ return new_dib;
+ }
+
+ case 4 :
+ {
+ FIBITMAP *new_dib = FreeImage_Allocate(width, height, 24, 0xFF, 0xFF00, 0xFF0000);
+
+ if (new_dib != NULL)
+ for (int rows = 0; rows < height; rows++)
+ FreeImage_ConvertLine4To24(FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), width, FreeImage_GetPalette(dib));
+
+ return new_dib;
+ }
+
+ case 8 :
+ {
+ FIBITMAP *new_dib = FreeImage_Allocate(width, height, 24, 0xFF, 0xFF00, 0xFF0000);
+
+ if (new_dib != NULL)
+ for (int rows = 0; rows < height; rows++)
+ FreeImage_ConvertLine8To24(FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), width, FreeImage_GetPalette(dib));
+
+ return new_dib;
+ }
+
+ case 16 :
+ {
+ FIBITMAP *new_dib = FreeImage_Allocate(width, height, 24, 0xFF, 0xFF00, 0xFF0000);
+
+ if (new_dib != NULL) {
+ for (int rows = 0; rows < height; rows++) {
+ if ((FreeImage_GetRedMask(dib) == 0x1F) && (FreeImage_GetGreenMask(dib) == 0x3E0) && (FreeImage_GetBlueMask(dib) == 0x7C00)) {
+ FreeImage_ConvertLine16To24_555(FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), width);
+ } else {
+ FreeImage_ConvertLine16To24_565(FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), width);
+ }
+ }
+ }
+
+ return new_dib;
+ }
+
+ case 32 :
+ {
+ FIBITMAP *new_dib = FreeImage_Allocate(width, height, 24, 0xFF, 0xFF00, 0xFF0000);
+
+ if (new_dib != NULL)
+ for (int rows = 0; rows < height; rows++)
+ FreeImage_ConvertLine32To24(FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), width);
+
+ return new_dib;
+ }
+ }
+ }
+
+ return NULL;
+}
diff --git a/freeimage241/Source/FreeImage/Conversion32.cpp b/freeimage241/Source/FreeImage/Conversion32.cpp
new file mode 100644
index 0000000..b7c45da
--- /dev/null
+++ b/freeimage241/Source/FreeImage/Conversion32.cpp
@@ -0,0 +1,214 @@
+// ==========================================================
+// Bitmap conversion routines
+//
+// Design and implementation by
+// - Floris van den Berg (flvdberg@wxs.nl)
+// - Hervé Drolon (drolon@iut.univ-lehavre.fr)
+// - Jani Kajala (janik@remedy.fi)
+//
+// This file is part of FreeImage 2
+//
+// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
+// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
+// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
+// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
+// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
+// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
+// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+// THIS DISCLAIMER.
+//
+// Use at your own risk!
+// ==========================================================
+
+#include "FreeImage.h"
+#include "Utilities.h"
+
+// ----------------------------------------------------------
+// internal conversions X to 32 bits
+// ----------------------------------------------------------
+
+void DLL_CALLCONV
+FreeImage_ConvertLine1To32(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette) {
+ for (int cols = 0; cols < width_in_pixels; cols++) {
+ int index = (source[cols>>3] & (0x80 >> (cols & 0x07))) != 0 ? 1 : 0;
+
+ target[0] = palette[index].rgbBlue;
+ target[1] = palette[index].rgbGreen;
+ target[2] = palette[index].rgbRed;
+
+ target += 4;
+ }
+}
+
+void DLL_CALLCONV
+FreeImage_ConvertLine4To32(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette) {
+ BOOL low_nibble = FALSE;
+ int x = 0;
+
+ for (int cols = 0 ; cols < width_in_pixels ; ++cols) {
+ if (low_nibble) {
+ target[0] = palette[LOWNIBBLE(source[x])].rgbBlue;
+ target[1] = palette[LOWNIBBLE(source[x])].rgbGreen;
+ target[2] = palette[LOWNIBBLE(source[x])].rgbRed;
+
+ x++;
+ } else {
+ target[0] = palette[HINIBBLE(source[x]) >> 4].rgbBlue;
+ target[1] = palette[HINIBBLE(source[x]) >> 4].rgbGreen;
+ target[2] = palette[HINIBBLE(source[x]) >> 4].rgbRed;
+ }
+
+ low_nibble = !low_nibble;
+
+ target += 4;
+ }
+}
+
+void DLL_CALLCONV
+FreeImage_ConvertLine8To32(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette) {
+ for (int cols = 0; cols < width_in_pixels; cols++) {
+ target[0] = palette[source[cols]].rgbBlue;
+ target[1] = palette[source[cols]].rgbGreen;
+ target[2] = palette[source[cols]].rgbRed;
+
+ target += 4;
+ }
+}
+
+void DLL_CALLCONV
+FreeImage_ConvertLine16To32_555(BYTE *target, BYTE *source, int width_in_pixels) {
+ WORD *bits = (WORD *)source;
+
+ for (int cols = 0; cols < width_in_pixels; cols++) {
+ target[2] = (((bits[cols] & 0x7C00) >> 10) * 0xFF) / 0x1F;
+ target[1] = (((bits[cols] & 0x3E0) >> 5) * 0xFF) / 0x1F;
+ target[0] = ((bits[cols] & 0x1F) * 0xFF) / 0x1F;
+
+ target += 4;
+ }
+}
+
+void DLL_CALLCONV
+FreeImage_ConvertLine16To32_565(BYTE *target, BYTE *source, int width_in_pixels) {
+ WORD *bits = (WORD *)source;
+
+ for (int cols = 0; cols < width_in_pixels; cols++) {
+ target[2] = ((bits[cols] & 0xF800) >> 11) << 3;
+ target[1] = ((bits[cols] & 0x7E0) >> 5) << 2;
+ target[0] = (bits[cols] & 0x1F) << 3;
+
+ target += 4;
+ }
+}
+
+void DLL_CALLCONV
+FreeImage_ConvertLine24To32(BYTE *target, BYTE *source, int width_in_pixels) {
+ for (int cols = 0; cols < width_in_pixels; cols++) {
+// *(DWORD *)target = *(DWORD *) source & 0x00FFFFFF; //this does an extra READ!
+ target[0]=source[0];
+ target[1]=source[1];
+ target[2]=source[2];
+ target[3]=0;
+ target += 4;
+ source += 3;
+ }
+}
+
+// ----------------------------------------------------------
+
+static void DLL_CALLCONV
+MapTransparentTableToAlpha(RGBQUAD *target, BYTE *source, BYTE *table, int transparent_pixels, int width_in_pixels) {
+ for (int cols = 0; cols < width_in_pixels; cols++) {
+ target[cols].rgbReserved = (source[cols] < transparent_pixels) ? table[source[cols]] : 255;
+ }
+}
+
+// ----------------------------------------------------------
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_ConvertTo32Bits(FIBITMAP *dib) {
+ if (dib != NULL) {
+ int width = FreeImage_GetWidth(dib);
+ int height = FreeImage_GetHeight(dib);
+
+ switch (FreeImage_GetBPP(dib)) {
+ case 1 :
+ {
+ FIBITMAP *new_dib = FreeImage_Allocate(width, height, 32, 0xFF, 0xFF00, 0xFF0000);
+
+ if (new_dib != NULL)
+ for (int rows = 0; rows < height; rows++)
+ FreeImage_ConvertLine1To32(FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), width, FreeImage_GetPalette(dib));
+
+ return new_dib;
+ }
+
+ case 4 :
+ {
+ FIBITMAP *new_dib = FreeImage_Allocate(width, height, 32, 0xFF, 0xFF00, 0xFF0000);
+
+ if (new_dib != NULL) {
+ for (int rows = 0; rows < height; rows++) {
+ FreeImage_ConvertLine4To32(FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), width, FreeImage_GetPalette(dib));
+
+ if (FreeImage_IsTransparent(dib)) {
+ MapTransparentTableToAlpha((RGBQUAD *)FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), FreeImage_GetTransparencyTable(dib), FreeImage_GetTransparencyCount(dib), width);
+ }
+ }
+
+ return new_dib;
+ }
+ }
+
+ case 8 :
+ {
+ FIBITMAP *new_dib = FreeImage_Allocate(width, height, 32, 0xFF, 0xFF00, 0xFF0000);
+
+ if (new_dib != NULL) {
+ for (int rows = 0; rows < height; rows++) {
+ FreeImage_ConvertLine8To32(FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), width, FreeImage_GetPalette(dib));
+
+ if (FreeImage_IsTransparent(dib)) {
+ MapTransparentTableToAlpha((RGBQUAD *)FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), FreeImage_GetTransparencyTable(dib), FreeImage_GetTransparencyCount(dib), width);
+ }
+ }
+
+ return new_dib;
+ }
+ }
+
+ case 16 :
+ {
+ FIBITMAP *new_dib = FreeImage_Allocate(width, height, 32, 0xFF, 0xFF00, 0xFF0000);
+
+ if (new_dib != NULL) {
+ for (int rows = 0; rows < height; rows++) {
+ if ((FreeImage_GetRedMask(dib) == 0x1F) && (FreeImage_GetGreenMask(dib) == 0x3E0) && (FreeImage_GetBlueMask(dib) == 0x7C00)) {
+ FreeImage_ConvertLine16To32_555(FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), width);
+ } else {
+ FreeImage_ConvertLine16To32_565(FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), width);
+ }
+ }
+ }
+
+ return new_dib;
+ }
+
+ case 24 :
+ {
+ FIBITMAP *new_dib = FreeImage_Allocate(width, height, 32, 0xFF, 0xFF00, 0xFF0000);
+
+ if (new_dib != NULL){
+ for (int rows = 0; rows < height; rows++){
+ FreeImage_ConvertLine24To32(FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), width);
+ }
+ }
+
+ return new_dib;
+ }
+ }
+ }
+
+ return NULL;
+}
diff --git a/freeimage241/Source/FreeImage/Conversion8.cpp b/freeimage241/Source/FreeImage/Conversion8.cpp
new file mode 100644
index 0000000..b3196ef
--- /dev/null
+++ b/freeimage241/Source/FreeImage/Conversion8.cpp
@@ -0,0 +1,245 @@
+// ==========================================================
+// Bitmap conversion routines
+//
+// Design and implementation by
+// - Floris van den Berg (flvdberg@wxs.nl)
+// - Hervé Drolon (drolon@iut.univ-lehavre.fr)
+// - Jani Kajala (janik@remedy.fi)
+//
+// This file is part of FreeImage 2
+//
+// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
+// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
+// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
+// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
+// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
+// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
+// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+// THIS DISCLAIMER.
+//
+// Use at your own risk!
+// ==========================================================
+
+#include "FreeImage.h"
+
+// ----------------------------------------------------------
+
+#define GREY1(r,g,b) (BYTE)(((WORD)r*77 + (WORD)g*150 + (WORD)b*29) >> 8) // .299R + .587G + .114B
+#define GREY2(r,g,b) (BYTE)(((WORD)r*169 + (WORD)g*256 + (WORD)b*87) >> 9) // .33R + 0.5G + .17B
+
+// ----------------------------------------------------------
+// internal conversions X to 8 bits
+// ----------------------------------------------------------
+
+void DLL_CALLCONV
+FreeImage_ConvertLine1To8(BYTE *target, BYTE *source, int width_in_pixels) {
+ for (int cols = 0; cols < width_in_pixels; cols++)
+ target[cols] = (source[cols >> 3] & (0x80 >> (cols & 0x07))) != 0;
+}
+
+void DLL_CALLCONV
+FreeImage_ConvertLine4To8(BYTE *target, BYTE *source, int width_in_pixels) {
+ int count_new = 0;
+ int count_org = 0;
+ BOOL hinibble = TRUE;
+
+ while (count_new < width_in_pixels) {
+ if (hinibble) {
+ target[count_new] = (source[count_org] & 0xf0) >> 4;
+ } else {
+ target[count_new] = (source[count_org] & 0x0f);
+
+ count_org++;
+ }
+
+ hinibble = !hinibble;
+
+ count_new++;
+ }
+}
+
+void DLL_CALLCONV
+FreeImage_ConvertLine16To8_555(BYTE *target, BYTE *source, int width_in_pixels) {
+ WORD *bits = (WORD *)source;
+
+ for (int cols = 0; cols < width_in_pixels; cols++) {
+ target[cols] = GREY1((((bits[cols] & 0x7C00) >> 10) * 0xFF) / 0x1F,
+ (((bits[cols] & 0x3E0) >> 5) * 0xFF) / 0x1F,
+ ((bits[cols] & 0x1F) * 0xFF) / 0x1F);
+ }
+}
+
+void DLL_CALLCONV
+FreeImage_ConvertLine16To8_565(BYTE *target, BYTE *source, int width_in_pixels) {
+ WORD *bits = (WORD *)source;
+
+ for (int cols = 0; cols < width_in_pixels; cols++)
+ target[cols] = GREY1((((bits[cols] & 0xF800) >> 11) * 0xFF) / 0x1F,
+ (((bits[cols] & 0x7E0) >> 5) * 0xFF) / 0x3F,
+ ((bits[cols] & 0x1F) * 0xFF) / 0x1F);
+}
+
+void DLL_CALLCONV
+FreeImage_ConvertLine24To8(BYTE *target, BYTE *source, int width_in_pixels) {
+ for (int cols = 0; cols < width_in_pixels; cols++) {
+ target[cols] = GREY1(source[2], source[1], source[0]);
+
+ source += 3;
+ }
+}
+
+void DLL_CALLCONV
+FreeImage_ConvertLine32To8(BYTE *target, BYTE *source, int width_in_pixels) {
+ for (int cols = 0; cols < width_in_pixels; cols++) {
+ target[cols] = GREY1(source[2], source[1], source[0]);
+
+ source += 4;
+ }
+}
+
+// ----------------------------------------------------------
+// smart convert X to 8 bits
+// ----------------------------------------------------------
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_ConvertTo8Bits(FIBITMAP *dib) {
+ if(dib) {
+ int width = FreeImage_GetWidth(dib);
+ int height = FreeImage_GetHeight(dib);
+
+ switch(FreeImage_GetBPP(dib)) {
+ case 1:
+ {
+ FIBITMAP *new_dib = FreeImage_Allocate(width, height, 8);
+
+ if (new_dib != NULL) {
+ // Copy the palette
+
+ RGBQUAD *new_pal = FreeImage_GetPalette(new_dib);
+ RGBQUAD *old_pal = FreeImage_GetPalette(dib);
+
+ for (int i = 0; i < 2; i++) {
+ new_pal[i].rgbRed = old_pal[i].rgbRed;
+ new_pal[i].rgbGreen = old_pal[i].rgbGreen;
+ new_pal[i].rgbBlue = old_pal[i].rgbBlue;
+ }
+
+ // Expand and copy the bitmap data
+
+ for (int rows = 0; rows < height; rows++)
+ FreeImage_ConvertLine1To8(FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), width);
+
+ }
+
+ return new_dib;
+ }
+
+ case 4 :
+ {
+ FIBITMAP *new_dib = FreeImage_Allocate(width, height, 8);
+
+ if (new_dib != NULL) {
+ // Copy the palette
+
+ RGBQUAD *new_pal = FreeImage_GetPalette(new_dib);
+ RGBQUAD *old_pal = FreeImage_GetPalette(dib);
+
+ for (int i = 0; i < 16; i++) {
+ new_pal[i].rgbRed = old_pal[i].rgbRed;
+ new_pal[i].rgbGreen = old_pal[i].rgbGreen;
+ new_pal[i].rgbBlue = old_pal[i].rgbBlue;
+ }
+
+ // Expand and copy the bitmap data
+
+ for (int rows = 0; rows < height; rows++)
+ FreeImage_ConvertLine4To8(FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), width);
+ }
+
+ return new_dib;
+ }
+
+ case 16 :
+ {
+ FIBITMAP *new_dib = FreeImage_Allocate(width, height, 8);
+
+ if (new_dib != NULL) {
+ // Build a greyscale palette
+
+ RGBQUAD *new_pal = FreeImage_GetPalette(new_dib);
+
+ for (int i = 0; i < 256; i++) {
+ new_pal[i].rgbRed = i;
+ new_pal[i].rgbGreen = i;
+ new_pal[i].rgbBlue = i;
+ }
+
+ // Expand and copy the bitmap data
+
+ for (int rows = 0; rows < height; rows++) {
+ if ((FreeImage_GetRedMask(dib) == 0x1F) && (FreeImage_GetGreenMask(dib) == 0x3E0) && (FreeImage_GetBlueMask(dib) == 0x7C00)) {
+ FreeImage_ConvertLine16To8_555(FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), width);
+ } else {
+ FreeImage_ConvertLine16To8_565(FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), width);
+ }
+ }
+
+ return new_dib;
+ }
+
+ return NULL;
+ }
+
+ case 24 :
+ {
+ FIBITMAP *new_dib = FreeImage_Allocate(width, height, 8);
+
+ if (new_dib != NULL) {
+ // Build a greyscale palette
+
+ RGBQUAD *new_pal = FreeImage_GetPalette(new_dib);
+
+ for (int i = 0; i < 256; i++) {
+ new_pal[i].rgbRed = i;
+ new_pal[i].rgbGreen = i;
+ new_pal[i].rgbBlue = i;
+ }
+
+ // Expand and copy the bitmap data
+
+ for (int rows = 0; rows < height; rows++)
+ FreeImage_ConvertLine24To8(FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), width);
+ }
+
+ return new_dib;
+ }
+
+ case 32 :
+ {
+ FIBITMAP *new_dib = FreeImage_Allocate(width, height, 8);
+
+ if (new_dib != NULL) {
+ // Build a greyscale palette
+
+ RGBQUAD *new_pal = FreeImage_GetPalette(new_dib);
+
+ for (int i = 0; i < 256; i++) {
+ new_pal[i].rgbRed = i;
+ new_pal[i].rgbGreen = i;
+ new_pal[i].rgbBlue = i;
+ }
+
+ // Expand and copy the bitmap data
+
+ for (int rows = 0; rows < height; rows++)
+ FreeImage_ConvertLine32To8(FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), width);
+ }
+
+ return new_dib;
+ }
+ }
+ }
+
+ return NULL;
+}
diff --git a/freeimage241/Source/FreeImage/FreeImage.cpp b/freeimage241/Source/FreeImage/FreeImage.cpp
new file mode 100644
index 0000000..b56ca59
--- /dev/null
+++ b/freeimage241/Source/FreeImage/FreeImage.cpp
@@ -0,0 +1,83 @@
+// ==========================================================
+// FreeImage implementation
+//
+// Design and implementation by
+// - Floris van den Berg (flvdberg@wxs.nl)
+//
+// This file is part of FreeImage 2
+//
+// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
+// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
+// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
+// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
+// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
+// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
+// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+// THIS DISCLAIMER.
+//
+// Use at your own risk!
+// ==========================================================
+
+#ifdef WIN32
+#include
+#endif
+
+#include "FreeImage.h"
+
+//----------------------------------------------------------------------
+
+static const char *s_version = "2.4.1";
+static const char *s_copyright = "This program uses FreeImage, an open source image library supporting all common bitmap formats. Get your free copy now from http://www.6ixsoft.com.";
+
+//----------------------------------------------------------------------
+
+#ifdef WIN32
+#ifndef _LIB
+BOOL APIENTRY
+DllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {
+ switch (ul_reason_for_call) {
+ case DLL_PROCESS_ATTACH :
+ FreeImage_Initialise(FALSE);
+ break;
+
+ case DLL_PROCESS_DETACH :
+ FreeImage_DeInitialise();
+ break;
+
+ case DLL_THREAD_ATTACH :
+ case DLL_THREAD_DETACH :
+ break;
+ }
+
+ return TRUE;
+}
+#endif
+#endif
+
+//----------------------------------------------------------------------
+
+const char * DLL_CALLCONV
+FreeImage_GetVersion() {
+ return s_version;
+}
+
+const char * DLL_CALLCONV
+FreeImage_GetCopyrightMessage() {
+ return s_copyright;
+}
+
+//----------------------------------------------------------------------
+
+FreeImage_OutputMessageFunction FreeImage_OutputMessageProc = NULL;
+
+void DLL_CALLCONV
+FreeImage_SetOutputMessage(FreeImage_OutputMessageFunction omf) {
+ FreeImage_OutputMessageProc = omf;
+}
+
+void DLL_CALLCONV
+FreeImage_OutputMessage(int fif, const char *message) {
+ if (FreeImage_OutputMessageProc != NULL)
+ FreeImage_OutputMessageProc((FREE_IMAGE_FORMAT)fif, message);
+}
diff --git a/freeimage241/Source/FreeImage/FreeImageIO.cpp b/freeimage241/Source/FreeImage/FreeImageIO.cpp
new file mode 100644
index 0000000..d64d704
--- /dev/null
+++ b/freeimage241/Source/FreeImage/FreeImageIO.cpp
@@ -0,0 +1,56 @@
+// ==========================================================
+// Input/Output functions
+//
+// Design and implementation by
+// - Floris van den Berg (flvdberg@wxs.nl)
+//
+// This file is part of FreeImage
+//
+// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
+// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
+// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
+// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
+// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
+// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
+// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+// THIS DISCLAIMER.
+//
+// Use at your own risk!
+// ==========================================================
+
+#include
+
+#include "FreeImageIO.h"
+
+// ----------------------------------------------------------
+
+unsigned
+_ReadProc(void *buffer, unsigned size, unsigned count, fi_handle handle) {
+ return fread(buffer, size, count, (FILE *)handle);
+}
+
+unsigned
+_WriteProc(void *buffer, unsigned size, unsigned count, fi_handle handle) {
+ return fwrite(buffer, size, count, (FILE *)handle);
+}
+
+int
+_SeekProc(fi_handle handle, long offset, int origin) {
+ return fseek((FILE *)handle, offset, origin);
+}
+
+long
+_TellProc(fi_handle handle) {
+ return ftell((FILE *)handle);
+}
+
+// ----------------------------------------------------------
+
+void
+SetDefaultIO(FreeImageIO *io) {
+ io->read_proc = _ReadProc;
+ io->seek_proc = _SeekProc;
+ io->tell_proc = _TellProc;
+ io->write_proc = _WriteProc;
+}
diff --git a/freeimage241/Source/FreeImage/GetType.cpp b/freeimage241/Source/FreeImage/GetType.cpp
new file mode 100644
index 0000000..dbada96
--- /dev/null
+++ b/freeimage241/Source/FreeImage/GetType.cpp
@@ -0,0 +1,74 @@
+// ==========================================================
+// GetType
+//
+// Design and implementation by
+// - Floris van den Berg (flvdberg@wxs.nl)
+//
+// This file is part of FreeImage 2
+//
+// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
+// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
+// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
+// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
+// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
+// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
+// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+// THIS DISCLAIMER.
+//
+// Use at your own risk!
+// ==========================================================
+
+#include
+#include
+
+#include "FreeImage.h"
+#include "FreeImageIO.h"
+#include "Plugin.h"
+
+// ----------------------------------------------------------
+
+FREE_IMAGE_FORMAT DLL_CALLCONV
+FreeImage_GetFileType(const char *filename, int size) {
+ FreeImageIO io;
+ SetDefaultIO(&io);
+
+ FILE *handle = fopen(filename, "rb");
+
+ if (handle != NULL) {
+ FREE_IMAGE_FORMAT format = FreeImage_GetFileTypeFromHandle(&io, (fi_handle)handle, size);
+
+ fclose(handle);
+
+ return format;
+ } else {
+ return FIF_UNKNOWN;
+ }
+}
+
+// ----------------------------------------------------------
+
+FREE_IMAGE_FORMAT DLL_CALLCONV
+FreeImage_GetFileTypeFromHandle(FreeImageIO *io, fi_handle handle, int size) {
+ if (handle != NULL) {
+ for (int i = FreeImage_GetFIFCount() - 1; i >= 0; --i) {
+ if (FreeImage_Validate((FREE_IMAGE_FORMAT)i, *io, handle)) {
+ return (FREE_IMAGE_FORMAT)i;
+ }
+ }
+ }
+
+ return FIF_UNKNOWN;
+}
+
+// ALIASES FOR BACKWARDS COMPATIBILITY ----------------------
+
+const char * DLL_CALLCONV
+FreeImage_GetFileTypeFromFormat(FREE_IMAGE_FORMAT fif) {
+ return FreeImage_GetFormatFromFIF(fif);
+}
+
+FREE_IMAGE_FORMAT DLL_CALLCONV
+FreeImage_GetFileTypeFromExt(const char *filename) {
+ return FreeImage_GetFIFFromFilename(filename);
+}
diff --git a/freeimage241/Source/FreeImage/LoadFunctions.cpp b/freeimage241/Source/FreeImage/LoadFunctions.cpp
new file mode 100644
index 0000000..98dec3e
--- /dev/null
+++ b/freeimage241/Source/FreeImage/LoadFunctions.cpp
@@ -0,0 +1,274 @@
+// ==========================================================
+// Simplified load functions
+//
+// Design and implementation by
+// - Floris van den Berg (flvdberg@wxs.nl)
+//
+// This file is part of FreeImage 2
+//
+// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
+// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
+// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
+// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
+// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
+// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
+// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+// THIS DISCLAIMER.
+//
+// Use at your own risk!
+// ==========================================================
+
+#include "FreeImage.h"
+
+// ----------------------------------------------------------
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_LoadBMP(const char *filename, int flags) {
+ return FreeImage_Load(FreeImage_GetFIFFromFormat("BMP"), filename, flags);
+}
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_LoadBMPFromHandle(FreeImageIO *io, fi_handle handle, int flags) {
+ return FreeImage_LoadFromHandle(FreeImage_GetFIFFromFormat("BMP"), io, handle, flags);
+}
+
+BOOL DLL_CALLCONV
+FreeImage_SaveBMP(FIBITMAP *dib, const char *filename, int flags) {
+ return FreeImage_Save(FreeImage_GetFIFFromFormat("BMP"), dib, filename, flags);
+}
+
+BOOL DLL_CALLCONV
+FreeImage_SaveBMPToHandle(FIBITMAP *dib, FreeImageIO *io, fi_handle handle, int flags) {
+ return FreeImage_SaveToHandle(FreeImage_GetFIFFromFormat("BMP"), dib, io, handle, flags);
+}
+
+// ----------------------------------------------------------
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_LoadICO(const char *filename, int flags) {
+ return FreeImage_Load(FreeImage_GetFIFFromFormat("ICO"), filename, flags);
+}
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_LoadICOFromHandle(FreeImageIO *io, fi_handle handle, int flags) {
+ return FreeImage_LoadFromHandle(FreeImage_GetFIFFromFormat("ICO"), io, handle, flags);
+}
+
+// ----------------------------------------------------------
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_LoadIFF(const char *filename, int flags) {
+ return FreeImage_Load(FreeImage_GetFIFFromFormat("IFF"), filename, flags);
+}
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_LoadIFFFromHandle(FreeImageIO *io, fi_handle handle, int flags) {
+ return FreeImage_LoadFromHandle(FreeImage_GetFIFFromFormat("IFF"), io, handle, flags);
+}
+
+// ----------------------------------------------------------
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_LoadJPEG(const char *filename, int flags) {
+ return FreeImage_Load(FreeImage_GetFIFFromFormat("JPEG"), filename, flags);
+}
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_LoadJPEGFromHandle(FreeImageIO *io, fi_handle handle, int flags) {
+ return FreeImage_LoadFromHandle(FreeImage_GetFIFFromFormat("JPEG"), io, handle, flags);
+}
+
+BOOL DLL_CALLCONV
+FreeImage_SaveJPEG(FIBITMAP *dib, const char *filename, int flags) {
+ return FreeImage_Save(FreeImage_GetFIFFromFormat("JPEG"), dib, filename, flags);
+}
+
+BOOL DLL_CALLCONV
+FreeImage_SaveJPEGToHandle(FIBITMAP *dib, FreeImageIO *io, fi_handle handle, int flags) {
+ return FreeImage_SaveToHandle(FreeImage_GetFIFFromFormat("JPEG"), dib, io, handle, flags);
+}
+
+// ----------------------------------------------------------
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_LoadKOALA(const char *filename, int flags) {
+ return FreeImage_Load(FreeImage_GetFIFFromFormat("KOALA"), filename, flags);
+}
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_LoadKOALAFromHandle(FreeImageIO *io, fi_handle handle, int flags) {
+ return FreeImage_LoadFromHandle(FreeImage_GetFIFFromFormat("KOALA"), io, handle, flags);
+}
+
+// ----------------------------------------------------------
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_LoadLBM(const char *filename, int flags) {
+ return FreeImage_Load(FreeImage_GetFIFFromFormat("IFF"), filename, flags);
+}
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_LoadLBMFromHandle(FreeImageIO *io, fi_handle handle, int flags) {
+ return FreeImage_LoadFromHandle(FreeImage_GetFIFFromFormat("IFF"), io, handle, flags);
+}
+
+// ----------------------------------------------------------
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_LoadMNG(const char *filename, int flags) {
+ return FreeImage_Load(FreeImage_GetFIFFromFormat("MNG"), filename, flags);
+}
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_LoadMNGFromHandle(FreeImageIO *io, fi_handle handle, int flags) {
+ return FreeImage_LoadFromHandle(FreeImage_GetFIFFromFormat("MNG"), io, handle, flags);
+}
+
+// ----------------------------------------------------------
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_LoadPCD(const char *filename, int flags) {
+ return FreeImage_Load(FreeImage_GetFIFFromFormat("PCD"), filename, flags);
+}
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_LoadPCDFromHandle(FreeImageIO *io, fi_handle handle, int flags) {
+ return FreeImage_LoadFromHandle(FreeImage_GetFIFFromFormat("PCD"), io, handle, flags);
+}
+
+// ----------------------------------------------------------
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_LoadPCX(const char *filename, int flags) {
+ return FreeImage_Load(FreeImage_GetFIFFromFormat("PCX"), filename, flags);
+}
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_LoadPCXFromHandle(FreeImageIO *io, fi_handle handle, int flags) {
+ return FreeImage_LoadFromHandle(FreeImage_GetFIFFromFormat("PCX"), io, handle, flags);
+}
+
+// ----------------------------------------------------------
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_LoadPNG(const char *filename, int flags) {
+ return FreeImage_Load(FreeImage_GetFIFFromFormat("PNG"), filename, flags);
+}
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_LoadPNGFromHandle(FreeImageIO *io, fi_handle handle, int flags) {
+ return FreeImage_LoadFromHandle(FreeImage_GetFIFFromFormat("PNG"), io, handle, flags);
+}
+
+BOOL DLL_CALLCONV
+FreeImage_SavePNG(FIBITMAP *dib, const char *filename, int flags) {
+ return FreeImage_Save(FreeImage_GetFIFFromFormat("PNG"), dib, filename, flags);
+}
+
+BOOL DLL_CALLCONV
+FreeImage_SavePNGToHandle(FIBITMAP *dib, FreeImageIO *io, fi_handle handle, int flags) {
+ return FreeImage_SaveToHandle(FreeImage_GetFIFFromFormat("PNG"), dib, io, handle, flags);
+}
+
+// ----------------------------------------------------------
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_LoadPNM(const char *filename, int flags) {
+ return FreeImage_Load(FreeImage_GetFIFFromFormat("PGM"), filename, flags);
+}
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_LoadPNMFromHandle(FreeImageIO *io, fi_handle handle, int flags) {
+ return FreeImage_LoadFromHandle(FreeImage_GetFIFFromFormat("PGM"), io, handle, flags);
+}
+
+BOOL DLL_CALLCONV
+FreeImage_SavePNM(FIBITMAP *dib, const char *filename, int flags) {
+ return FreeImage_Save(FreeImage_GetFIFFromFormat("PGM"), dib, filename, flags);
+}
+
+BOOL DLL_CALLCONV
+FreeImage_SavePNMToHandle(FIBITMAP *dib, FreeImageIO *io, fi_handle handle, int flags) {
+ return FreeImage_SaveToHandle(FreeImage_GetFIFFromFormat("PGM"), dib, io, handle, flags);
+}
+
+// ----------------------------------------------------------
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_LoadPSD(const char *filename, int flags) {
+ return FreeImage_Load(FreeImage_GetFIFFromFormat("PSD"), filename, flags);
+}
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_LoadPSDFromHandle(FreeImageIO *io, fi_handle handle, int flags) {
+ return FreeImage_LoadFromHandle(FreeImage_GetFIFFromFormat("PSD"), io, handle, flags);
+}
+
+// ----------------------------------------------------------
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_LoadRAS(const char *filename, int flags) {
+ return FreeImage_Load(FreeImage_GetFIFFromFormat("RAS"), filename, flags);
+}
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_LoadRASFromHandle(FreeImageIO *io, fi_handle handle, int flags) {
+ return FreeImage_LoadFromHandle(FreeImage_GetFIFFromFormat("RAS"), io, handle, flags);
+}
+
+// ----------------------------------------------------------
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_LoadTARGA(const char *filename, int flags) {
+ return FreeImage_Load(FreeImage_GetFIFFromFormat("TARGA"), filename, flags);
+}
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_LoadTARGAFromHandle(FreeImageIO *io, fi_handle handle, int flags) {
+ return FreeImage_LoadFromHandle(FreeImage_GetFIFFromFormat("TARGA"), io, handle, flags);
+}
+
+// ----------------------------------------------------------
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_LoadTIFF(const char *filename, int flags) {
+ return FreeImage_Load(FreeImage_GetFIFFromFormat("TIFF"), filename, flags);
+}
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_LoadTIFFFromHandle(FreeImageIO *io, fi_handle handle, int flags) {
+ return FreeImage_LoadFromHandle(FreeImage_GetFIFFromFormat("TIFF"), io, handle, flags);
+}
+
+BOOL DLL_CALLCONV
+FreeImage_SaveTIFF(FIBITMAP *dib, const char *filename, int flags) {
+ return FreeImage_Save(FreeImage_GetFIFFromFormat("TIFF"), dib, filename, flags);
+}
+
+BOOL DLL_CALLCONV
+FreeImage_SaveTIFFToHandle(FIBITMAP *dib, FreeImageIO *io, fi_handle handle, int flags) {
+ return FreeImage_SaveToHandle(FreeImage_GetFIFFromFormat("TIFF"), dib, io, handle, flags);
+}
+
+// ----------------------------------------------------------
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_LoadWBMP(const char *filename, int flags) {
+ return FreeImage_Load(FreeImage_GetFIFFromFormat("WBMP"), filename, flags);
+}
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_LoadWBMPFromHandle(FreeImageIO *io, fi_handle handle, int flags) {
+ return FreeImage_LoadFromHandle(FreeImage_GetFIFFromFormat("WBMP"), io, handle, flags);
+}
+
+BOOL DLL_CALLCONV
+FreeImage_SaveWBMP(FIBITMAP *dib, const char *filename, int flags) {
+ return FreeImage_Save(FreeImage_GetFIFFromFormat("WBMP"), dib, filename, flags);
+}
+
+BOOL DLL_CALLCONV
+FreeImage_SaveWBMPToHandle(FIBITMAP *dib, FreeImageIO *io, fi_handle handle, int flags) {
+ return FreeImage_SaveToHandle(FreeImage_GetFIFFromFormat("WBMP"), dib, io, handle, flags);
+}
diff --git a/freeimage241/Source/FreeImage/Makefile b/freeimage241/Source/FreeImage/Makefile
new file mode 100644
index 0000000..461dd59
--- /dev/null
+++ b/freeimage241/Source/FreeImage/Makefile
@@ -0,0 +1,43 @@
+include ../../Makefile.cfg
+
+INCLUDE = -I../
+CFLAGS = $(COMPILERFLAGS) $(INCLUDE)
+
+TARGET = freeimage
+VER_MAJOR = 2
+VER_MINOR = 0.0
+MODULES = BitmapAccess.o Conversion.o Conversion16_555.o Conversion16_565.o \
+ Conversion24.o Conversion32.o Conversion8.o FreeImage.o GetType.o Plugin.o \
+ PluginBMP.o PluginICO.o PluginJPEG.o PluginKOALA.o PluginMNG.o PluginPCD.o \
+ PluginPCX.o PluginPNG.o PluginPNM.o PluginRAS.o PluginTARGA.o PluginTIFF.o \
+ PluginWBMP.o PluginLBM.o OldLoadFunctions.o NNQuantizer.o WuQuantizer.o Combine.o
+
+STATICLIB = lib$(TARGET).a
+SHAREDLIB = lib$(TARGET)-$(VER_MAJOR).$(VER_MINOR).so
+LIBNAME = lib$(TARGET).so.$(VER_MAJOR)
+
+all: default
+
+default: $(STATICLIB) $(SHAREDLIB)
+
+.c.o:
+ $(CC) $(CFLAGS) -c $<
+
+.cpp.o:
+ $(CPP) $(CFLAGS) -c $<
+
+$(STATICLIB): $(MODULES)
+ ar r $@ $?
+
+$(SHAREDLIB): $(MODULES)
+ $(CC) -s -shared -Wl,-soname,$(LIBNAME) -o $@ $? $(LIBRARIES)
+ ln -sf $(SHAREDLIB) $(LIBNAME)
+
+install: $(STATICLIB) $(SHAREDLIB)
+ install -m 644 -o root -g root $(STATICLIB) $(INSTALLDIR)
+ install -m 755 -o root -g root $(SHAREDLIB) $(INSTALLDIR)
+ ln -sf $(SHAREDLIB) $(INSTALLDIR)/$(LIBNAME)
+ ldconfig
+
+clean:
+ rm -f *.o core d2utmp* $(STATICLIB) $(SHAREDLIB) $(LIBNAME)
diff --git a/freeimage241/Source/FreeImage/NNQuantizer.cpp b/freeimage241/Source/FreeImage/NNQuantizer.cpp
new file mode 100644
index 0000000..7dcf930
--- /dev/null
+++ b/freeimage241/Source/FreeImage/NNQuantizer.cpp
@@ -0,0 +1,510 @@
+// NeuQuant Neural-Net Quantization Algorithm
+// ------------------------------------------
+//
+// Copyright (c) 1994 Anthony Dekker
+//
+// NEUQUANT Neural-Net quantization algorithm by Anthony Dekker, 1994.
+// See "Kohonen neural networks for optimal colour quantization"
+// in "Network: Computation in Neural Systems" Vol. 5 (1994) pp 351-367.
+// for a discussion of the algorithm.
+//
+// Any party obtaining a copy of these files from the author, directly or
+// indirectly, is granted, free of charge, a full and unrestricted irrevocable,
+// world-wide, paid up, royalty-free, nonexclusive right and license to deal
+// in this software and documentation files (the "Software"), including without
+// limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons who receive
+// copies from any such party to do so, with the only requirement being
+// that this copyright notice remain intact.
+
+///////////////////////////////////////////////////////////////////////
+// History
+// -------
+// January 2001: Adaptation of the Neural-Net Quantization Algorithm
+// for the FreeImage 2 library
+// Author: Hervé Drolon (drolon@infonie.fr)
+///////////////////////////////////////////////////////////////////////
+
+#include "FreeImage.h"
+
+const int netsize = 256; // number of colours used
+
+
+// For 256 colours, fixed arrays need 8kb, plus space for the image
+// ----------------------------------------------------------------
+
+
+// Four primes near 500 - assume no image has a length so large
+// that it is divisible by all four primes
+// ==========================================================
+
+#define prime1 499
+#define prime2 491
+#define prime3 487
+#define prime4 503
+
+// Prototypes
+// ==========================================================
+
+static void initnet(BYTE *thepic, DWORD len, int sample);
+static void unbiasnet(); // can edit this function to do output of colour map
+static void inxbuild();
+static int inxsearch(int b, int g, int r);
+static int contest(int b, int g, int r);
+static void altersingle(int alpha, int i, int b, int g, int r);
+static void alterneigh(int rad, int i, int b, int g, int r);
+static void learn();
+
+// Network Definitions
+// ==========================================================
+
+#define maxnetpos (netsize-1)
+#define netbiasshift 4 // bias for colour values
+#define ncycles 100 // no. of learning cycles
+
+// defs for freq and bias
+
+#define intbiasshift 16 // bias for fractions
+#define intbias (((int) 1)<>betashift) // beta = 1 / 1024
+#define betagamma (intbias<<(gammashift-betashift))
+
+// defs for decreasing radius factor
+
+#define initrad (netsize>>3) // for 256 cols, radius starts
+#define radiusbiasshift 6 // at 32.0 biased by 6 bits
+#define radiusbias (((int) 1)<>= netbiasshift;
+ }
+ network[i][3] = i; // record colour no
+ }
+}
+
+//////////////////////////////////////////////////////////////////////////////////
+// Insertion sort of network and building of netindex[0..255] (to do after unbias)
+// -------------------------------------------------------------------------------
+
+static void inxbuild()
+{
+ int i,j,smallpos,smallval;
+ int *p,*q;
+ int previouscol,startpos;
+
+ previouscol = 0;
+ startpos = 0;
+ for (i = 0; i < netsize; i++) {
+ p = network[i];
+ smallpos = i;
+ smallval = p[1]; // index on g
+ // find smallest in i..netsize-1
+ for (j = i+1; j < netsize; j++) {
+ q = network[j];
+ if (q[1] < smallval) { // index on g
+ smallpos = j;
+ smallval = q[1]; // index on g
+ }
+ }
+ q = network[smallpos];
+ // swap p (i) and q (smallpos) entries
+ if (i != smallpos) {
+ j = q[0]; q[0] = p[0]; p[0] = j;
+ j = q[1]; q[1] = p[1]; p[1] = j;
+ j = q[2]; q[2] = p[2]; p[2] = j;
+ j = q[3]; q[3] = p[3]; p[3] = j;
+ }
+ // smallval entry is now in position i
+ if (smallval != previouscol) {
+ netindex[previouscol] = (startpos+i)>>1;
+ for (j = previouscol+1; j < smallval; j++)
+ netindex[j] = i;
+ previouscol = smallval;
+ startpos = i;
+ }
+ }
+ netindex[previouscol] = (startpos+maxnetpos)>>1;
+ for (j = previouscol+1; j < 256; j++)
+ netindex[j] = maxnetpos; // really 256
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Search for BGR values 0..255 (after net is unbiased) and return colour index
+// ----------------------------------------------------------------------------
+
+static int inxsearch(int b, int g, int r)
+{
+ int i, j, dist, a, bestd;
+ int *p;
+ int best;
+
+ bestd = 1000; // biggest possible dist is 256*3
+ best = -1;
+ i = netindex[g]; // index on g
+ j = i-1; // start at netindex[g] and work outwards
+
+ while ((i < netsize) || (j >= 0)) {
+ if (i < netsize) {
+ p = network[i];
+ dist = p[1] - g; // inx key
+ if (dist >= bestd)
+ i = netsize; // stop iter
+ else {
+ i++;
+ if (dist < 0)
+ dist = -dist;
+ a = p[0] - b;
+ if (a < 0)
+ a = -a;
+ dist += a;
+ if (dist < bestd) {
+ a = p[2] - r;
+ if (a<0)
+ a = -a;
+ dist += a;
+ if (dist < bestd) {
+ bestd = dist;
+ best = p[3];
+ }
+ }
+ }
+ }
+ if (j >= 0) {
+ p = network[j];
+ dist = g - p[1]; // inx key - reverse dif
+ if (dist >= bestd)
+ j = -1; // stop iter
+ else {
+ j--;
+ if (dist < 0)
+ dist = -dist;
+ a = p[0] - b;
+ if (a<0)
+ a = -a;
+ dist += a;
+ if (dist < bestd) {
+ a = p[2] - r;
+ if (a<0)
+ a = -a;
+ dist += a;
+ if (dist < bestd) {
+ bestd = dist;
+ best = p[3];
+ }
+ }
+ }
+ }
+ }
+ return best;
+}
+
+///////////////////////////////
+// Search for biased BGR values
+// ----------------------------
+
+static int contest(int b, int g, int r)
+{
+ // finds closest neuron (min dist) and updates freq
+ // finds best neuron (min dist-bias) and returns position
+ // for frequently chosen neurons, freq[i] is high and bias[i] is negative
+ // bias[i] = gamma*((1/netsize)-freq[i])
+
+ int i,dist,a,biasdist,betafreq;
+ int bestpos,bestbiaspos,bestd,bestbiasd;
+ int *p,*f, *n;
+
+ bestd = ~(((int) 1)<<31);
+ bestbiasd = bestd;
+ bestpos = -1;
+ bestbiaspos = bestpos;
+ p = bias;
+ f = freq;
+
+ for (i = 0; i < netsize; i++) {
+ n = network[i];
+ dist = n[0] - b;
+ if (dist < 0)
+ dist = -dist;
+ a = n[1] - g;
+ if (a < 0)
+ a = -a;
+ dist += a;
+ a = n[2] - r;
+ if (a < 0)
+ a = -a;
+ dist += a;
+ if (dist < bestd) {
+ bestd = dist;
+ bestpos = i;
+ }
+ biasdist = dist - ((*p)>>(intbiasshift-netbiasshift));
+ if (biasdist < bestbiasd) {
+ bestbiasd = biasdist;
+ bestbiaspos = i;
+ }
+ betafreq = (*f >> betashift);
+ *f++ -= betafreq;
+ *p++ += (betafreq << gammashift);
+ }
+ freq[bestpos] += beta;
+ bias[bestpos] -= betagamma;
+ return bestbiaspos;
+}
+
+///////////////////////////////////////////////////////
+// Move neuron i towards biased (b,g,r) by factor alpha
+// ----------------------------------------------------
+
+static void altersingle(int alpha, int i, int b, int g, int r)
+{
+ int *n;
+
+ n = network[i]; // alter hit neuron
+ *n -= (alpha * (*n - b)) / initalpha;
+ n++;
+ *n -= (alpha * (*n - g)) / initalpha;
+ n++;
+ *n -= (alpha * (*n - r)) / initalpha;
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// Move adjacent neurons by precomputed alpha*(1-((i-j)^2/[r]^2)) in radpower[|i-j|]
+// ---------------------------------------------------------------------------------
+
+static void alterneigh(int rad, int i, int b, int g, int r)
+{
+ int j, k, lo, hi, a;
+ int *p, *q;
+
+ lo = i - rad; if (lo < -1) lo = -1;
+ hi = i + rad; if (hi > netsize) hi = netsize;
+
+ j = i+1;
+ k = i-1;
+ q = radpower;
+ while ((j < hi) || (k > lo)) {
+ a = (*(++q));
+ if (j < hi) {
+ p = network[j];
+ *p -= (a * (*p - b)) / alpharadbias;
+ p++;
+ *p -= (a * (*p - g)) / alpharadbias;
+ p++;
+ *p -= (a * (*p - r)) / alpharadbias;
+ j++;
+ }
+ if (k > lo) {
+ p = network[k];
+ *p -= (a * (*p - b)) / alpharadbias;
+ p++;
+ *p -= (a * (*p - g)) / alpharadbias;
+ p++;
+ *p -= (a * (*p - r)) / alpharadbias;
+ k--;
+ }
+ }
+}
+
+/////////////////////
+// Main Learning Loop
+// ------------------
+
+static void learn()
+{
+ int i, j, b, g, r;
+ int radius, rad, alpha, step, delta, samplepixels;
+ int alphadec; // biased by 10 bits
+ BYTE *p;
+ BYTE *lim;
+
+ alphadec = 30 + ((samplefac - 1) / 3);
+ p = thepicture;
+ lim = thepicture + lengthcount;
+ samplepixels = lengthcount / (3*samplefac);
+ delta = samplepixels / ncycles;
+ alpha = initalpha;
+ radius = initradius;
+
+ rad = radius >> radiusbiasshift;
+ if (rad <= 1) rad = 0;
+ for (i = 0; i < rad; i++)
+ radpower[i] = alpha*(((rad*rad - i*i)*radbias)/(rad*rad));
+
+ if ((lengthcount % prime1) != 0)
+ step = 3*prime1;
+ else {
+ if ((lengthcount % prime2) != 0)
+ step = 3*prime2;
+ else {
+ if ((lengthcount % prime3) != 0)
+ step = 3*prime3;
+ else
+ step = 3*prime4;
+ }
+ }
+
+ i = 0;
+ while (i < samplepixels) {
+ b = p[0] << netbiasshift;
+ g = p[1] << netbiasshift;
+ r = p[2] << netbiasshift;
+ j = contest(b,g,r);
+
+ altersingle(alpha,j,b,g,r);
+ if (rad) alterneigh(rad,j,b,g,r); // alter neighbours
+
+ p += step;
+ if (p >= lim) p -= lengthcount;
+
+ i++;
+ if (i % delta == 0) {
+ alpha -= alpha / alphadec;
+ radius -= radius / radiusdec;
+ rad = radius >> radiusbiasshift;
+ if (rad <= 1) rad = 0;
+ for (j = 0; j < rad; j++)
+ radpower[j] = alpha * (((rad*rad - j*j) * radbias) / (rad*rad));
+ }
+ }
+}
+
+///////////////////////////
+// FreeImage implementation
+// ------------------------
+
+// Input parameters:
+// - void* dib: DIB 24-bit to be quantized
+// - int sampling: a sampling factor in range 1..30
+// 1 => slower, 30 => faster. Default value is 15
+// Return value:
+// - NULL if the DIB is not valid or if it's not a 24-bit DIB
+// - the quantized 8-bit (color palette) DIB otherwise
+
+FIBITMAP *
+NNQuantizer(FIBITMAP *dib, int sampling)
+{
+ LONG width, height;
+ BYTE *dib_bits; // the input image itself
+ DWORD length;
+
+ if ((!dib) || (FreeImage_GetBPP(dib) != 24)) {
+ return NULL;
+ }
+
+ // 1) select a sampling factor in range 1..30 (input parameter 'sampling')
+ // 1 => slower, 30 => faster. Default value is 15
+
+
+ // 2) Get DIB parameters
+
+ width = FreeImage_GetWidth(dib); // DIB width
+ height = FreeImage_GetHeight(dib); // DIB height
+ dib_bits = FreeImage_GetBits(dib); // pointer to DIB pixels
+ length = 3L * width * height; // image size in bytes
+
+ // 3) Initialize the network and apply the learning algorithm
+
+ initnet(dib_bits, length, sampling);
+ learn();
+ unbiasnet();
+
+ // 4) Allocate a new 8-bit DIB
+
+ FIBITMAP *new_dib = FreeImage_Allocate(width, height, 8);
+
+ if (new_dib == NULL)
+ return NULL;
+
+ // 5) Write the quantized palette
+
+ RGBQUAD *new_pal = FreeImage_GetPalette(new_dib);
+
+ for (int j = 0; j < netsize; j++) {
+ new_pal[j].rgbBlue = (BYTE)network[j][0];
+ new_pal[j].rgbGreen = (BYTE)network[j][1];
+ new_pal[j].rgbRed = (BYTE)network[j][2];
+ }
+
+ inxbuild();
+
+ // 6) Write output image using inxsearch(b,g,r)
+
+ for (WORD rows = 0; rows < height; rows++) {
+ BYTE *new_bits = FreeImage_GetScanLine(new_dib, rows);
+ BYTE *bits = FreeImage_GetScanLine(dib, rows);
+
+ for (WORD cols = 0; cols < FreeImage_GetWidth(dib); cols++) {
+ new_bits[cols] = (BYTE)inxsearch(bits[0], bits[1], bits[2]);
+
+ bits += 3;
+ }
+ }
+
+ return (FIBITMAP*) new_dib;
+}
diff --git a/freeimage241/Source/FreeImage/Plugin.cpp b/freeimage241/Source/FreeImage/Plugin.cpp
new file mode 100644
index 0000000..02cb47c
--- /dev/null
+++ b/freeimage241/Source/FreeImage/Plugin.cpp
@@ -0,0 +1,713 @@
+// =====================================================================
+// FreeImage Plugin Interface
+//
+// Design and implementation by
+// - Floris van den Berg (flvdberg@wxs.nl)
+// - Rui Lopes (ruiglopes@yahoo.com)
+//
+// This file is part of FreeImage 2
+//
+// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
+// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
+// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
+// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
+// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
+// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
+// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+// THIS DISCLAIMER.
+//
+// Use at your own risk!
+// ================== ===================================================
+
+#ifdef WIN32
+#pragma warning (disable : 4786)
+#include
+#else
+#include
+#endif
+
+#include
+#include
+#include
+#include
+#include
+
+#include "FreeImage.h"
+#include "FreeImageIO.h"
+#include "Plugin.h"
+
+// =====================================================================
+
+using namespace std;
+
+// =====================================================================
+// Plugin search list
+// =====================================================================
+
+const char *
+s_search_list[] = {
+ "",
+ "plugins\\",
+};
+
+static int s_search_list_size = sizeof(s_search_list) / sizeof(char *);
+
+// =====================================================================
+// Reimplementation of stricmp (it is not supported on some systems)
+// =====================================================================
+
+int
+FreeImage_stricmp(const char *s1, const char *s2) {
+ int c1, c2;
+
+ do {
+ c1 = tolower(*s1++);
+ c2 = tolower(*s2++);
+ } while (c1 && c1 == c2);
+
+ return c1 - c2;
+}
+
+// =====================================================================
+// Declaration of the FreeImage function pointer structure
+// =====================================================================
+
+static FreeImage s_freeimage;
+
+// =====================================================================
+// Plugin Node
+// =====================================================================
+
+FI_STRUCT (PluginNode) {
+ int m_id;
+ void *m_instance;
+ Plugin *m_plugin;
+ PluginNode *m_next;
+ BOOL m_enabled;
+
+ const char *m_format;
+ const char *m_description;
+ const char *m_extension;
+ const char *m_regexpr;
+};
+
+// =====================================================================
+// Internal Plugin List
+// =====================================================================
+
+class PluginList {
+public :
+ PluginList();
+ ~PluginList();
+
+ FREE_IMAGE_FORMAT AddNode(FI_InitProc proc, void *instance = NULL, const char *format = 0, const char *description = 0, const char *extension = 0, const char *regexpr = 0);
+ PluginNode *FindNodeFromFormat(const char *format);
+ PluginNode *FindNodeFromMime(const char *mime);
+ PluginNode *FindNodeFromFIF(int node_id);
+
+ int Size() const;
+ BOOL IsEmpty() const;
+
+private :
+ map m_plugin_map;
+ int m_node_count;
+};
+
+// ---------------------------------------------------------------------
+
+PluginList::PluginList() :
+m_plugin_map() {
+}
+
+FREE_IMAGE_FORMAT
+PluginList::AddNode(FI_InitProc init_proc, void *instance, const char *format, const char *description, const char *extension, const char *regexpr) {
+ if (init_proc != NULL) {
+ PluginNode *node = new PluginNode;
+ Plugin *plugin = new Plugin;
+ memset(plugin, 0, sizeof(Plugin));
+
+ // fill-in the plugin structure
+
+ init_proc(*plugin, m_plugin_map.size());
+
+ // get the format string (two possible ways)
+
+ const char *the_format = NULL;
+
+ if (format != NULL)
+ the_format = format;
+ else if (plugin->format_proc != NULL)
+ the_format = plugin->format_proc();
+
+ // add the node if it wasn't there already
+
+ if (the_format != NULL) {
+ if (FindNodeFromFormat(the_format) == NULL) {
+ node->m_id = m_plugin_map.size();
+ node->m_instance = instance;
+ node->m_plugin = plugin;
+ node->m_format = format;
+ node->m_description = description;
+ node->m_extension = extension;
+ node->m_regexpr = regexpr;
+ node->m_next = NULL;
+ node->m_enabled = TRUE;
+
+ m_plugin_map[m_plugin_map.size()] = node;
+
+ return (FREE_IMAGE_FORMAT)node->m_id;
+ }
+ }
+
+ // something went wrong while allocating the plugin... cleanup
+
+ delete plugin;
+ delete node;
+ }
+
+ return FIF_UNKNOWN;
+}
+
+PluginNode *
+PluginList::FindNodeFromFormat(const char *format) {
+ int count = 0;
+
+ for (map::iterator i = m_plugin_map.begin(); i != m_plugin_map.end(); ++i) {
+ const char *the_format = ((*i).second->m_format != NULL) ? (*i).second->m_format : (*i).second->m_plugin->format_proc();
+
+ if (strcmp(the_format, format) == 0)
+ return (*i).second;
+
+ count++;
+ }
+
+ return NULL;
+}
+
+PluginNode *
+PluginList::FindNodeFromMime(const char *mime) {
+ int count = 0;
+
+ for (map::iterator i = m_plugin_map.begin(); i != m_plugin_map.end(); ++i) {
+ const char *the_mime = ((*i).second->m_plugin->mime_proc != NULL) ? (*i).second->m_plugin->mime_proc() : "";
+
+ if (strcmp(the_mime, mime) == 0)
+ return (*i).second;
+
+ count++;
+ }
+
+ return NULL;
+}
+
+PluginNode *
+PluginList::FindNodeFromFIF(int node_id) {
+ map::iterator i = m_plugin_map.find(node_id);
+
+ if (i != m_plugin_map.end())
+ return (*i).second;
+
+ return NULL;
+}
+
+int
+PluginList::Size() const {
+ return m_plugin_map.size();
+}
+
+BOOL
+PluginList::IsEmpty() const {
+ return m_plugin_map.empty();
+}
+
+PluginList::~PluginList() {
+ for (map::iterator i = m_plugin_map.begin(); i != m_plugin_map.end(); ++i) {
+#ifdef WIN32
+ if ((*i).second->m_instance != NULL)
+ FreeLibrary((HINSTANCE)(*i).second->m_instance);
+#endif
+ delete (*i).second->m_plugin; /*CORRECTED*/
+ delete ((*i).second);
+ }
+}
+
+// =====================================================================
+// Plugin System Initialization
+// =====================================================================
+
+static PluginList *s_plugins = NULL;
+static int s_plugin_reference_count = 0;
+
+// ---------------------------------------------------------------------
+
+void DLL_CALLCONV
+FreeImage_Initialise(BOOL load_local_plugins_only) {
+ if (s_plugin_reference_count++ == 0) {
+ // initialize the freeimage function pointer table
+
+ s_freeimage.allocate_proc = FreeImage_Allocate;
+ s_freeimage.free_proc = FreeImage_Free;
+ s_freeimage.get_bits_proc = FreeImage_GetBits;
+ s_freeimage.get_bits_row_col_proc = FreeImage_GetBitsRowCol;
+ s_freeimage.get_blue_mask_proc = FreeImage_GetBlueMask;
+ s_freeimage.get_bpp_proc = FreeImage_GetBPP;
+ s_freeimage.get_color_type_proc = FreeImage_GetColorType;
+ s_freeimage.get_colors_used_proc = FreeImage_GetColorsUsed;
+ s_freeimage.get_dib_size_proc = FreeImage_GetDIBSize;
+ s_freeimage.get_dots_per_meter_x_proc = FreeImage_GetDotsPerMeterX;
+ s_freeimage.get_dots_per_meter_y_proc = FreeImage_GetDotsPerMeterY;
+ s_freeimage.get_green_mask_proc = FreeImage_GetGreenMask;
+ s_freeimage.get_height_proc = FreeImage_GetHeight;
+ s_freeimage.get_info_header_proc = FreeImage_GetInfoHeader;
+ s_freeimage.get_info_proc = FreeImage_GetInfo;
+ s_freeimage.get_line_proc = FreeImage_GetLine;
+ s_freeimage.get_palette_proc = FreeImage_GetPalette;
+ s_freeimage.get_pitch_proc = FreeImage_GetPitch;
+ s_freeimage.get_red_mask_proc = FreeImage_GetRedMask;
+ s_freeimage.get_scanline_proc = FreeImage_GetScanLine;
+ s_freeimage.get_transparency_count_proc = FreeImage_GetTransparencyCount;
+ s_freeimage.get_transparency_table_proc = FreeImage_GetTransparencyTable;
+ s_freeimage.get_width_proc = FreeImage_GetWidth;
+ s_freeimage.output_message_proc = FreeImage_OutputMessage;
+ s_freeimage.set_transparency_table_proc = FreeImage_SetTransparencyTable;
+ s_freeimage.is_transparent_proc = FreeImage_IsTransparent;
+ s_freeimage.set_transparent_proc = FreeImage_SetTransparent;
+ s_freeimage.unload_proc = FreeImage_Unload;
+ s_freeimage.convert_line1to8_proc = FreeImage_ConvertLine1To8;
+ s_freeimage.convert_line_4to8_proc = FreeImage_ConvertLine4To8;
+ s_freeimage.convert_line_16to8_555_proc = FreeImage_ConvertLine16To8_555;
+ s_freeimage.convert_line_16to8_565_proc = FreeImage_ConvertLine16To8_565;
+ s_freeimage.convert_line_24to8_proc = FreeImage_ConvertLine24To8;
+ s_freeimage.convert_line_32to8_proc = FreeImage_ConvertLine32To8;
+ s_freeimage.convert_line_1to16_555_proc = FreeImage_ConvertLine1To16_555;
+ s_freeimage.convert_line_4to16_555_proc = FreeImage_ConvertLine4To16_555;
+ s_freeimage.convert_line_8to16_555_proc = FreeImage_ConvertLine8To16_555;
+ s_freeimage.convert_line_16_565_to_16_555_proc = FreeImage_ConvertLine16_565_To16_555;
+ s_freeimage.convert_line_24to16_555_proc = FreeImage_ConvertLine24To16_555;
+ s_freeimage.convert_line_32to16_555_proc = FreeImage_ConvertLine32To16_555;
+ s_freeimage.convert_line_1to16_565_proc = FreeImage_ConvertLine1To16_565;
+ s_freeimage.convert_line_4to16_565_proc = FreeImage_ConvertLine4To16_565;
+ s_freeimage.convert_line_8to16_565_proc = FreeImage_ConvertLine8To16_565;
+ s_freeimage.convert_line_16_555_to_16_565_proc = FreeImage_ConvertLine16_555_To16_565;
+ s_freeimage.convert_line_24to16_565_proc = FreeImage_ConvertLine24To16_565;
+ s_freeimage.convert_line_32to16_565_proc = FreeImage_ConvertLine32To16_565;
+ s_freeimage.convert_line_1to24_proc = FreeImage_ConvertLine1To24;
+ s_freeimage.convert_line_4to24_proc = FreeImage_ConvertLine4To24;
+ s_freeimage.convert_line_8to24_proc = FreeImage_ConvertLine8To24;
+ s_freeimage.convert_line_16to24_555_proc = FreeImage_ConvertLine16To24_555;
+ s_freeimage.convert_line_16to24_565_proc = FreeImage_ConvertLine16To24_565;
+ s_freeimage.convert_line_32to24_proc = FreeImage_ConvertLine32To24;
+ s_freeimage.convert_line_1to32_proc = FreeImage_ConvertLine1To32;
+ s_freeimage.convert_line_4to32_proc = FreeImage_ConvertLine4To32;
+ s_freeimage.convert_line_8to32_proc = FreeImage_ConvertLine8To32;
+ s_freeimage.convert_line_16to32_555_proc = FreeImage_ConvertLine16To32_555;
+ s_freeimage.convert_line_16to32_565_proc = FreeImage_ConvertLine16To32_565;
+ s_freeimage.convert_line_24to32_proc = FreeImage_ConvertLine24To32;
+
+ // internal plugin initialization
+
+ s_plugins = new PluginList;
+
+ s_plugins->AddNode(InitBMP);
+// s_plugins->AddNode(InitICO);
+ s_plugins->AddNode(InitJPEG);
+// s_plugins->AddNode(InitMNG, NULL, "JNG", "JPEG Network Graphics", "jng", "");
+// s_plugins->AddNode(InitKOALA);
+ s_plugins->AddNode(InitIFF);
+// s_plugins->AddNode(InitMNG);
+// s_plugins->AddNode(InitPNM, NULL, "PBM", "Portable Bitmap (ASCII)", "pbm", "^P1");
+// s_plugins->AddNode(InitPNM, NULL, "PBMRAW", "Portable Bitmap (RAW)", "pbm", "^P4");
+// s_plugins->AddNode(InitPCD);
+ s_plugins->AddNode(InitPCX);
+// s_plugins->AddNode(InitPNM, NULL, "PGM", "Portable Greymap (ASCII)", "pgm", "^P2");
+// s_plugins->AddNode(InitPNM, NULL, "PGMRAW", "Portable Greymap (RAW)", "pgm", "^P5");
+ s_plugins->AddNode(InitPNG);
+// s_plugins->AddNode(InitPNM, NULL, "PPM", "Portable Pixelmap (ASCII)", "ppm", "^P3");
+// s_plugins->AddNode(InitPNM, NULL, "PPMRAW", "Portable Pixelmap (RAW)", "ppm", "^P6");
+// s_plugins->AddNode(InitRAS);
+ s_plugins->AddNode(InitTARGA);
+// s_plugins->AddNode(InitTIFF);
+// s_plugins->AddNode(InitWBMP);
+// s_plugins->AddNode(InitPSD);
+
+ // external plugin initialization
+
+#ifdef WIN32
+ if (!load_local_plugins_only) {
+ int count = 0;
+ char buffer[MAX_PATH + 200];
+
+ while (count < s_search_list_size) {
+ _finddata_t find_data;
+ long find_handle;
+
+ strcpy(buffer, s_search_list[count]);
+ strcat(buffer, "*.fip");
+
+ if ((find_handle= _findfirst(buffer, &find_data)) != -1L) {
+ do {
+ strcpy(buffer, s_search_list[count]);
+ strncat(buffer, find_data.name, MAX_PATH + 200);
+
+ HINSTANCE instance = LoadLibrary(buffer);
+
+ if (instance != NULL) {
+ FARPROC proc_address = GetProcAddress(instance, "_Init@8");
+
+ if (proc_address != NULL)
+ s_plugins->AddNode((FI_InitProc)proc_address, (void *)instance);
+ else
+ FreeLibrary(instance);
+ }
+ } while (_findnext(find_handle, &find_data) != -1L);
+
+ _findclose(find_handle);
+ }
+
+ count++;
+ }
+ }
+#endif
+ }
+}
+
+void DLL_CALLCONV
+FreeImage_DeInitialise() {
+ --s_plugin_reference_count;
+
+ if (s_plugin_reference_count == 0)
+ delete s_plugins;
+}
+
+// =====================================================================
+// Plugin System Load/Save Functions
+// =====================================================================
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_LoadFromHandle(FREE_IMAGE_FORMAT fif, FreeImageIO *io, fi_handle handle, int flags) {
+ if ((fif >= 0) && (fif < FreeImage_GetFIFCount())) {
+ PluginNode *node = s_plugins->FindNodeFromFIF(fif);
+
+ if (node != NULL) {
+ if (node->m_enabled) {
+ FIBITMAP *bitmap = NULL;
+
+ if (node->m_plugin->open_proc != NULL) {
+ void *data = node->m_plugin->open_proc(*io, handle, TRUE);
+
+ bitmap = node->m_plugin->load_proc(s_freeimage, *io, handle, -1, flags, data);
+
+ if (node->m_plugin->close_proc != NULL)
+ node->m_plugin->close_proc(*io, handle, data);
+
+ return bitmap;
+ } else {
+ return node->m_plugin->load_proc(s_freeimage, *io, handle, -1, flags, NULL);
+ }
+ }
+ }
+ }
+
+ return NULL;
+}
+
+FIBITMAP * DLL_CALLCONV
+FreeImage_Load(FREE_IMAGE_FORMAT fif, const char *filename, int flags) {
+ FreeImageIO io;
+ SetDefaultIO(&io);
+
+ FILE *handle = fopen(filename, "rb");
+
+ if (handle) {
+ FIBITMAP *bitmap = FreeImage_LoadFromHandle(fif, &io, (fi_handle)handle, flags);
+
+ fclose(handle);
+
+ return bitmap;
+ }
+
+ return NULL;
+}
+
+BOOL DLL_CALLCONV
+FreeImage_SaveToHandle(FREE_IMAGE_FORMAT fif, FIBITMAP *dib, FreeImageIO *io, fi_handle handle, int flags) {
+ if ((fif >= 0) && (fif < FreeImage_GetFIFCount())) {
+ PluginNode *node = s_plugins->FindNodeFromFIF(fif);
+
+ if (node != NULL) {
+ if (node->m_enabled) {
+ BOOL result = FALSE;
+
+ if (node->m_plugin->open_proc != NULL) {
+ void *data = node->m_plugin->open_proc(*io, handle, FALSE);
+
+ result = node->m_plugin->save_proc(s_freeimage, *io, dib, handle, -1, flags, data);
+
+ if (node->m_plugin->close_proc != NULL)
+ node->m_plugin->close_proc(*io, handle, data);
+ } else {
+ result = node->m_plugin->save_proc(s_freeimage, *io, dib, handle, -1, flags, NULL);
+ }
+
+ return result;
+ }
+ }
+ }
+
+ return NULL;
+}
+
+
+BOOL DLL_CALLCONV
+FreeImage_Save(FREE_IMAGE_FORMAT fif, FIBITMAP *dib, const char *filename, int flags) {
+ FreeImageIO io;
+ SetDefaultIO(&io);
+
+ FILE *handle = fopen(filename, "wb");
+
+ if (handle) {
+ BOOL success = FreeImage_SaveToHandle(fif, dib, &io, (fi_handle)handle, flags);
+
+ fclose(handle);
+
+ return success;
+ }
+
+ return FALSE;
+}
+
+// =====================================================================
+// Plugin Creation / Enabling Functions
+// =====================================================================
+
+FREE_IMAGE_FORMAT DLL_CALLCONV
+FreeImage_RegisterLocalPlugin(FI_InitProc proc_address, const char *format, const char *description, const char *extension, const char *regexpr) {
+ return s_plugins->AddNode(proc_address, NULL, format, description, extension, regexpr);
+}
+
+FREE_IMAGE_FORMAT DLL_CALLCONV
+FreeImage_RegisterExternalPlugin(const char *path, const char *format, const char *description, const char *extension, const char *regexpr) {
+ if (path != NULL) {
+ HINSTANCE instance = LoadLibrary(path);
+
+ if (instance != NULL) {
+ FARPROC proc_address = GetProcAddress(instance, "_Init@8");
+
+ FREE_IMAGE_FORMAT result = s_plugins->AddNode((FI_InitProc)proc_address, (void *)instance, format, description, extension, regexpr);
+
+ if (result == FIF_UNKNOWN)
+ FreeLibrary(instance);
+
+ return result;
+ }
+ }
+
+ return FIF_UNKNOWN;
+}
+
+int DLL_CALLCONV
+FreeImage_SetPluginEnabled(FREE_IMAGE_FORMAT fif, BOOL enable) {
+ if (s_plugins != NULL) {
+ PluginNode *node = s_plugins->FindNodeFromFIF(fif);
+
+ if (node != NULL) {
+ BOOL previous_state = node->m_enabled;
+
+ node->m_enabled = enable;
+
+ return previous_state;
+ }
+ }
+
+ return -1;
+}
+
+int DLL_CALLCONV
+FreeImage_IsPluginEnabled(FREE_IMAGE_FORMAT fif) {
+ if (s_plugins != NULL) {
+ PluginNode *node = s_plugins->FindNodeFromFIF(fif);
+
+ return (node != NULL) ? node->m_enabled : FALSE;
+ }
+
+ return -1;
+}
+
+// =====================================================================
+// Plugin Access Functions
+// =====================================================================
+
+int DLL_CALLCONV
+FreeImage_GetFIFCount() {
+ return (s_plugins != NULL) ? s_plugins->Size() : 0;
+}
+
+FREE_IMAGE_FORMAT DLL_CALLCONV
+FreeImage_GetFIFFromFormat(const char *format) {
+ if (s_plugins != NULL) {
+ PluginNode *node = s_plugins->FindNodeFromFormat(format);
+
+ return (node != NULL) ? (node->m_enabled) ? (FREE_IMAGE_FORMAT)node->m_id : FIF_UNKNOWN : FIF_UNKNOWN;
+ }
+
+ return FIF_UNKNOWN;
+}
+
+FREE_IMAGE_FORMAT DLL_CALLCONV
+FreeImage_GetFIFFromMime(const char *mime) {
+ if (s_plugins != NULL) {
+ PluginNode *node = s_plugins->FindNodeFromMime(mime);
+
+ return (node != NULL) ? (node->m_enabled) ? (FREE_IMAGE_FORMAT)node->m_id : FIF_UNKNOWN : FIF_UNKNOWN;
+ }
+
+ return FIF_UNKNOWN;
+}
+
+const char * DLL_CALLCONV
+FreeImage_GetFormatFromFIF(FREE_IMAGE_FORMAT fif) {
+ if (s_plugins != NULL) {
+ PluginNode *node = s_plugins->FindNodeFromFIF(fif);
+
+ return (node != NULL) ? (node->m_format != NULL) ? node->m_format : node->m_plugin->format_proc() : NULL;
+ }
+
+ return NULL;
+}
+
+const char * DLL_CALLCONV
+FreeImage_GetFIFExtensionList(FREE_IMAGE_FORMAT fif) {
+ if (s_plugins != NULL) {
+ PluginNode *node = s_plugins->FindNodeFromFIF(fif);
+
+ return (node != NULL) ? (node->m_extension != NULL) ? node->m_extension : (node->m_plugin->extension_proc != NULL) ? node->m_plugin->extension_proc() : NULL : NULL;
+ }
+
+ return NULL;
+}
+
+const char * DLL_CALLCONV
+FreeImage_GetFIFDescription(FREE_IMAGE_FORMAT fif) {
+ if (s_plugins != NULL) {
+ PluginNode *node = s_plugins->FindNodeFromFIF(fif);
+
+ return (node != NULL) ? (node->m_description != NULL) ? node->m_description : (node->m_plugin->description_proc != NULL) ? node->m_plugin->description_proc() : NULL : NULL;
+ }
+
+ return NULL;
+}
+
+const char * DLL_CALLCONV
+FreeImage_GetFIFRegExpr(FREE_IMAGE_FORMAT fif) {
+ if (s_plugins != NULL) {
+ PluginNode *node = s_plugins->FindNodeFromFIF(fif);
+
+ return (node != NULL) ? (node->m_regexpr != NULL) ? node->m_regexpr : (node->m_plugin->regexpr_proc != NULL) ? node->m_plugin->regexpr_proc() : NULL : NULL;
+ }
+
+ return NULL;
+}
+
+BOOL DLL_CALLCONV
+FreeImage_FIFSupportsReading(FREE_IMAGE_FORMAT fif) {
+ if (s_plugins != NULL) {
+ PluginNode *node = s_plugins->FindNodeFromFIF(fif);
+
+ return (node != NULL) ? (node->m_enabled) ? node->m_plugin->load_proc != NULL : FALSE : FALSE;
+ }
+
+ return FALSE;
+}
+
+BOOL DLL_CALLCONV
+FreeImage_FIFSupportsWriting(FREE_IMAGE_FORMAT fif) {
+ if (s_plugins != NULL) {
+ PluginNode *node = s_plugins->FindNodeFromFIF(fif);
+
+ return (node != NULL) ? (node->m_enabled) ? node->m_plugin->save_proc != NULL : FALSE : FALSE;
+ }
+
+ return FALSE;
+}
+
+FREE_IMAGE_FORMAT DLL_CALLCONV
+FreeImage_GetFIFFromFilename(const char *filename) {
+ if (filename != NULL) {
+ const char *extension;
+
+ // get the proper extension if we received a filename
+
+ char *place = strrchr((char *)filename, '.');
+
+ if (place != NULL)
+ extension = ++place;
+ else
+ extension = filename;
+
+ // look for the extension in the plugin table
+
+ for (int i = 0; i < FreeImage_GetFIFCount(); ++i) {
+ // compare the format id with the extension
+
+ if (FreeImage_stricmp(FreeImage_GetFormatFromFIF((FREE_IMAGE_FORMAT)i), extension) == 0) {
+ if (s_plugins->FindNodeFromFIF(i)->m_enabled) {
+ return (FREE_IMAGE_FORMAT)i;
+ } else {
+ return FIF_UNKNOWN;
+ }
+ } else {
+ // make a copy of the extension list and split it
+
+ char *copy = (char *)malloc(strlen(FreeImage_GetFIFExtensionList((FREE_IMAGE_FORMAT)i)) + 1);
+ memset(copy, 0, strlen(FreeImage_GetFIFExtensionList((FREE_IMAGE_FORMAT)i)) + 1);
+ memcpy(copy, FreeImage_GetFIFExtensionList((FREE_IMAGE_FORMAT)i), strlen(FreeImage_GetFIFExtensionList((FREE_IMAGE_FORMAT)i)));
+
+ // get the first token
+
+ char *token = strtok(copy, ",");
+
+ while (token != NULL) {
+ if (FreeImage_stricmp(token, extension) == 0) {
+ free(copy);
+
+ if (s_plugins->FindNodeFromFIF(i)->m_enabled) {
+ return (FREE_IMAGE_FORMAT)i;
+ } else {
+ return FIF_UNKNOWN;
+ }
+ }
+
+ token = strtok(NULL, ",");
+ }
+
+ // free the copy of the extension list
+
+ free(copy);
+ }
+ }
+ }
+
+ return FIF_UNKNOWN;
+}
+
+BOOL DLL_CALLCONV
+FreeImage_Validate(FREE_IMAGE_FORMAT fif, FreeImageIO &io, fi_handle handle) {
+ if (s_plugins != NULL) {
+ BOOL validated = FALSE;
+
+ PluginNode *node = s_plugins->FindNodeFromFIF(fif);
+
+ if (node) {
+ long tell = io.tell_proc(handle);
+
+ validated = (node != NULL) ? (node->m_enabled) ? (node->m_plugin->validate_proc != NULL) ? node->m_plugin->validate_proc(io, handle) : FALSE : FALSE : FALSE;
+
+ io.seek_proc(handle, tell, SEEK_SET);
+ }
+
+ return validated;
+ }
+
+ return FALSE;
+}
diff --git a/freeimage241/Source/FreeImage/PluginBMP.cpp b/freeimage241/Source/FreeImage/PluginBMP.cpp
new file mode 100644
index 0000000..13979f2
--- /dev/null
+++ b/freeimage241/Source/FreeImage/PluginBMP.cpp
@@ -0,0 +1,1031 @@
+ // ==========================================================
+// BMP Loader and Writer
+//
+// Design and implementation by
+// - Floris van den Berg (flvdberg@wxs.nl)
+// - Markus Loibl (markus.loibl@epost.de)
+// - Martin Weber (martweb@gmx.net)
+//
+// This file is part of FreeImage 2
+//
+// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
+// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
+// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
+// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
+// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
+// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
+// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+// THIS DISCLAIMER.
+//
+// Use at your own risk!
+// ==========================================================
+
+#include
+
+#include "FreeImage.h"
+#include "Utilities.h"
+
+// ----------------------------------------------------------
+// Constants + headers
+// ----------------------------------------------------------
+
+const RLE_COMMAND = 0;
+const RLE_ENDOFLINE = 0;
+const RLE_ENDOFBITMAP = 1;
+const RLE_DELTA = 2;
+
+#define BI_RGB 0L
+#define BI_RLE8 1L
+#define BI_RLE4 2L
+#define BI_BITFIELDS 3L
+
+// ----------------------------------------------------------
+
+#ifdef WIN32
+#pragma pack(push, 1)
+#else
+#pragma pack(1)
+#endif
+
+typedef struct tagBITMAPCOREHEADER {
+ DWORD bcSize;
+ WORD bcWidth;
+ WORD bcHeight;
+ WORD bcPlanes;
+ WORD bcBitCnt;
+} BITMAPCOREHEADER, *PBITMAPCOREHEADER;
+
+typedef struct tagBITMAPINFOOS2_1X_HEADER {
+ DWORD biSize;
+ WORD biWidth;
+ WORD biHeight;
+ WORD biPlanes;
+ WORD biBitCount;
+} BITMAPINFOOS2_1X_HEADER, *PBITMAPINFOOS2_1X_HEADER;
+
+typedef struct tagBITMAPFILEHEADER {
+ WORD bfType;
+ DWORD bfSize;
+ WORD bfReserved1;
+ WORD bfReserved2;
+ DWORD bfOffBits;
+} BITMAPFILEHEADER, *PBITMAPFILEHEADER;
+
+typedef struct tagRGBTRIPLE {
+ BYTE rgbtBlue;
+ BYTE rgbtGreen;
+ BYTE rgbtRed;
+} RGBTRIPLE;
+
+#ifdef WIN32
+#pragma pack(pop)
+#else
+#pragma pack(4)
+#endif
+
+// ==========================================================
+// Plugin Interface
+// ==========================================================
+
+static int s_format_id;
+
+// ==========================================================
+// Internal functions
+// ==========================================================
+
+static FIBITMAP *
+LoadWindowsBMP(FreeImage &freeimage, FreeImageIO &io, fi_handle handle, int flags, unsigned bitmap_bits_offset) {
+ FIBITMAP *dib;
+
+ try {
+ // load the info header
+
+ BITMAPINFOHEADER bih;
+
+ io.read_proc(&bih, sizeof(BITMAPINFOHEADER), 1, handle);
+
+ // keep some general information about the bitmap
+
+ int used_colors = bih.biClrUsed;
+ int width = bih.biWidth;
+ int height = bih.biHeight;
+ int bit_count = bih.biBitCount;
+ int compression = bih.biCompression;
+ int pitch = CalculatePitch(CalculateLine(width, bit_count));
+
+ switch (bit_count) {
+ case 1 :
+ case 4 :
+ case 8 :
+ {
+ if ((used_colors <= 0) || (used_colors > CalculateUsedColors(bit_count)))
+ used_colors = CalculateUsedColors(bit_count);
+
+ // allocate enough memory to hold the bitmap (header, palette, pixels) and read the palette
+
+ dib = freeimage.allocate_proc(width, height, bit_count);
+
+ if (dib == NULL)
+ throw "DIB allocation failed";
+
+ BITMAPINFOHEADER *pInfoHeader = freeimage.get_info_header_proc(dib);
+ pInfoHeader->biXPelsPerMeter = bih.biXPelsPerMeter;
+ pInfoHeader->biYPelsPerMeter = bih.biYPelsPerMeter;
+
+ // load the palette
+
+ io.read_proc(freeimage.get_palette_proc(dib), used_colors * sizeof(RGBQUAD), 1, handle);
+
+ // seek to the actual pixel data.
+ // this is needed because sometimes the palette is larger than the entries it contains predicts
+
+ if (bitmap_bits_offset > (sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + (used_colors * sizeof(RGBQUAD))))
+ io.seek_proc(handle, bitmap_bits_offset, SEEK_SET);
+
+ // read the pixel data
+
+ switch (compression) {
+ case BI_RGB :
+ if (height > 0) {
+ io.read_proc((void *)freeimage.get_bits_proc(dib), height * pitch, 1, handle);
+ } else {
+ for (int c = 0; c < abs(height); ++c) {
+ io.read_proc((void *)freeimage.get_scanline_proc(dib, height - c - 1), pitch, 1, handle);
+ }
+ }
+
+ return dib;
+
+ case BI_RLE4 :
+ {
+ BYTE status_byte = 0;
+ BYTE second_byte = 0;
+ int scanline = 0;
+ int bits = 0;
+ BOOL low_nibble = FALSE;
+
+ for (;;) {
+ io.read_proc(&status_byte, sizeof(BYTE), 1, handle);
+
+ switch (status_byte) {
+ case RLE_COMMAND :
+ io.read_proc(&status_byte, sizeof(BYTE), 1, handle);
+
+ switch (status_byte) {
+ case RLE_ENDOFLINE :
+ bits = 0;
+ scanline++;
+ low_nibble = FALSE;
+ break;
+
+ case RLE_ENDOFBITMAP :
+ return (FIBITMAP *)dib;
+
+ case RLE_DELTA :
+ {
+ // read the delta values
+
+ BYTE delta_x;
+ BYTE delta_y;
+
+ io.read_proc(&delta_x, sizeof(BYTE), 1, handle);
+ io.read_proc(&delta_y, sizeof(BYTE), 1, handle);
+
+ // apply them
+
+ bits += delta_x / 2;
+ scanline += delta_y;
+ break;
+ }
+
+ default :
+ io.read_proc(&second_byte, sizeof(BYTE), 1, handle);
+
+ BYTE *sline = freeimage.get_scanline_proc(dib, scanline);
+
+ for (int i = 0; i < status_byte; i++) {
+ if (low_nibble) {
+ *(sline + bits) |= LOWNIBBLE(second_byte);
+
+ if (i != status_byte - 1)
+ io.read_proc(&second_byte, sizeof(BYTE), 1, handle);
+
+ bits++;
+ } else {
+ *(sline + bits) |= HINIBBLE(second_byte);
+ }
+
+ low_nibble = !low_nibble;
+ }
+
+ if (((status_byte / 2) & 1 )== 1)
+ io.read_proc(&second_byte, sizeof(BYTE), 1, handle);
+
+ break;
+ };
+
+ break;
+
+ default :
+ {
+ BYTE *sline = freeimage.get_scanline_proc(dib, scanline);
+
+ io.read_proc(&second_byte, sizeof(BYTE), 1, handle);
+
+ for (unsigned i = 0; i < status_byte; i++) {
+ if (low_nibble) {
+ *(sline + bits) |= LOWNIBBLE(second_byte);
+
+ bits++;
+ } else {
+ *(sline + bits) |= HINIBBLE(second_byte);
+ }
+
+ low_nibble = !low_nibble;
+ }
+ }
+
+ break;
+ };
+ }
+
+ break;
+ }
+
+ case BI_RLE8 :
+ {
+ BYTE status_byte = 0;
+ BYTE second_byte = 0;
+ int scanline = 0;
+ int bits = 0;
+
+ for (;;) {
+ io.read_proc(&status_byte, sizeof(BYTE), 1, handle);
+
+ switch (status_byte) {
+ case RLE_COMMAND :
+ io.read_proc(&status_byte, sizeof(BYTE), 1, handle);
+
+ switch (status_byte) {
+ case RLE_ENDOFLINE :
+ bits = 0;
+ scanline++;
+ break;
+
+ case RLE_ENDOFBITMAP :
+ return (FIBITMAP *)dib;
+
+ case RLE_DELTA :
+ {
+ // read the delta values
+
+ BYTE delta_x;
+ BYTE delta_y;
+
+ io.read_proc(&delta_x, sizeof(BYTE), 1, handle);
+ io.read_proc(&delta_y, sizeof(BYTE), 1, handle);
+
+ // apply them
+
+ bits += delta_x;
+ scanline += delta_y;
+ break;
+ }
+
+ default :
+ io.read_proc((void *)(freeimage.get_scanline_proc(dib, scanline) + bits), sizeof(BYTE) * status_byte, 1, handle);
+
+ // align run length to even number of bytes
+
+ if ((status_byte & 1) == 1)
+ io.read_proc(&second_byte, sizeof(BYTE), 1, handle);
+
+ bits += status_byte;
+
+ break;
+ };
+
+ break;
+
+ default :
+ BYTE *sline = freeimage.get_scanline_proc(dib, scanline);
+
+ io.read_proc(&second_byte, sizeof(BYTE), 1, handle);
+
+ for (unsigned i = 0; i < status_byte; i++) {
+ *(sline + bits) = second_byte;
+
+ bits++;
+ }
+
+ break;
+ };
+ }
+
+ break;
+ }
+
+ default :
+ throw "compression type not supported";
+ }
+
+ break;
+ }
+
+ case 16 :
+ {
+ if (bih.biCompression == BI_BITFIELDS) {
+ DWORD bitfields[3];
+
+ io.read_proc(bitfields, 3 * sizeof(DWORD), 1, handle);
+
+ dib = freeimage.allocate_proc(width, height, bit_count, bitfields[2], bitfields[1], bitfields[0]);
+ } else {
+ dib = freeimage.allocate_proc(width, height, bit_count, 0x1F, 0x3E0, 0x7C00);
+ }
+
+ if (dib == NULL)
+ throw "DIB allocation failed";
+
+ BITMAPINFOHEADER *pInfoHeader = freeimage.get_info_header_proc(dib);
+ pInfoHeader->biXPelsPerMeter = bih.biXPelsPerMeter;
+ pInfoHeader->biYPelsPerMeter = bih.biYPelsPerMeter;
+
+ io.read_proc(freeimage.get_bits_proc(dib), height * pitch, 1, handle);
+
+ return dib;
+ }
+
+ case 24 :
+ case 32 :
+ {
+ if (bih.biCompression == BI_BITFIELDS) {
+ throw "bitfields in 32-bit BMPs are currently unsupported";
+ } else {
+ dib = freeimage.allocate_proc(width, height, bit_count, 0xFF, 0xFF00, 0xFF0000);
+
+ if (dib == NULL)
+ throw "DIB allocation failed";
+
+ BITMAPINFOHEADER *pInfoHeader = freeimage.get_info_header_proc(dib);
+ pInfoHeader->biXPelsPerMeter = bih.biXPelsPerMeter;
+ pInfoHeader->biYPelsPerMeter = bih.biYPelsPerMeter;
+
+ // Skip over the optional palette
+ // A 24 or 32 bit DIB may contain a palette for faster color reduction
+
+ if (pInfoHeader->biClrUsed > 0)
+ io.seek_proc(handle, pInfoHeader->biClrUsed * sizeof(RGBQUAD), SEEK_CUR);
+
+ // read in the bitmap bits
+
+ io.read_proc(freeimage.get_bits_proc(dib), height * pitch, 1, handle);
+
+ // check if the bitmap contains transparency, if so enable it in the header
+
+ freeimage.set_transparent_proc(dib, (freeimage.get_color_type_proc(dib) == FIC_RGBALPHA));
+
+ return dib;
+ }
+ }
+ }
+ } catch(const char *message) {
+ freeimage.output_message_proc(s_format_id, message);
+ }
+
+ return NULL;
+}
+
+static FIBITMAP *
+LoadOS22XBMP(FreeImage &freeimage, FreeImageIO &io, fi_handle handle, int flags, unsigned bitmap_bits_offset) {
+ FIBITMAP *dib = NULL;
+
+ try {
+ // load the info header
+
+ BITMAPINFOHEADER bih;
+
+ io.read_proc(&bih, sizeof(BITMAPINFOHEADER), 1, handle);
+
+ // keep some general information about the bitmap
+
+ int used_colors = bih.biClrUsed;
+ int width = bih.biWidth;
+ int height = bih.biHeight;
+ int bit_count = bih.biBitCount;
+ int compression = bih.biCompression;
+ int pitch = CalculatePitch(CalculateLine(width, bit_count));
+
+ switch (bit_count) {
+ case 1 :
+ case 4 :
+ case 8 :
+ {
+ if ((used_colors <= 0) || (used_colors > CalculateUsedColors(bit_count)))
+ used_colors = CalculateUsedColors(bit_count);
+
+ // allocate enough memory to hold the bitmap (header, palette, pixels) and read the palette
+
+ dib = freeimage.allocate_proc(width, height, bit_count);
+
+ if (dib == NULL)
+ throw "DIB allocation failed";
+
+ BITMAPINFOHEADER *pInfoHeader = freeimage.get_info_header_proc(dib);
+ pInfoHeader->biXPelsPerMeter = bih.biXPelsPerMeter;
+ pInfoHeader->biYPelsPerMeter = bih.biYPelsPerMeter;
+
+ // load the palette
+
+ io.seek_proc(handle, sizeof(BITMAPFILEHEADER) + bih.biSize, SEEK_SET);
+
+ RGBQUAD *pal = freeimage.get_palette_proc(dib);
+
+ for (int count = 0; count < used_colors; count++) {
+ RGBTRIPLE triple;
+
+ io.read_proc(&triple, sizeof(RGBTRIPLE), 1, handle);
+
+ pal[count].rgbRed = triple.rgbtRed;
+ pal[count].rgbGreen = triple.rgbtGreen;
+ pal[count].rgbBlue = triple.rgbtBlue;
+ }
+
+ // seek to the actual pixel data.
+ // this is needed because sometimes the palette is larger than the entries it contains predicts
+
+ if (bitmap_bits_offset > (sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + (used_colors * 3)))
+ io.seek_proc(handle, bitmap_bits_offset, SEEK_SET);
+
+ // read the pixel data
+
+ switch (compression) {
+ case BI_RGB :
+ if (height > 0) {
+ io.read_proc((void *)freeimage.get_bits_proc(dib), height * pitch, 1, handle);
+ } else {
+ for (int c = 0; c < abs(height); ++c) {
+ io.read_proc((void *)freeimage.get_scanline_proc(dib, height - c - 1), pitch, 1, handle);
+ }
+ }
+
+ return dib;
+
+ case BI_RLE4 :
+ {
+ BYTE status_byte = 0;
+ BYTE second_byte = 0;
+ int scanline = 0;
+ int bits = 0;
+ BOOL low_nibble = FALSE;
+
+ for (;;) {
+ io.read_proc(&status_byte, sizeof(BYTE), 1, handle);
+
+ switch (status_byte) {
+ case RLE_COMMAND :
+ io.read_proc(&status_byte, sizeof(BYTE), 1, handle);
+
+ switch (status_byte) {
+ case RLE_ENDOFLINE :
+ bits = 0;
+ scanline++;
+ low_nibble = FALSE;
+ break;
+
+ case RLE_ENDOFBITMAP :
+ return (FIBITMAP *)dib;
+
+ case RLE_DELTA :
+ {
+ // read the delta values
+
+ BYTE delta_x;
+ BYTE delta_y;
+
+ io.read_proc(&delta_x, sizeof(BYTE), 1, handle);
+ io.read_proc(&delta_y, sizeof(BYTE), 1, handle);
+
+ // apply them
+
+ bits += delta_x / 2;
+ scanline += delta_y;
+ break;
+ }
+
+ default :
+ io.read_proc(&second_byte, sizeof(BYTE), 1, handle);
+
+ BYTE *sline = freeimage.get_scanline_proc(dib, scanline);
+
+ for (int i = 0; i < status_byte; i++) {
+ if (low_nibble) {
+ *(sline + bits) |= LOWNIBBLE(second_byte);
+
+ if (i != status_byte - 1)
+ io.read_proc(&second_byte, sizeof(BYTE), 1, handle);
+
+ bits++;
+ } else {
+ *(sline + bits) |= HINIBBLE(second_byte);
+ }
+
+ low_nibble = !low_nibble;
+ }
+
+ if (((status_byte / 2) & 1 ) == 1)
+ io.read_proc(&second_byte, sizeof(BYTE), 1, handle);
+
+ break;
+ };
+
+ break;
+
+ default :
+ {
+ BYTE *sline = freeimage.get_scanline_proc(dib, scanline);
+
+ io.read_proc(&second_byte, sizeof(BYTE), 1, handle);
+
+ for (unsigned i = 0; i < status_byte; i++) {
+ if (low_nibble) {
+ *(sline + bits) |= LOWNIBBLE(second_byte);
+
+ bits++;
+ } else {
+ *(sline + bits) |= HINIBBLE(second_byte);
+ }
+
+ low_nibble = !low_nibble;
+ }
+ }
+
+ break;
+ };
+ }
+
+ break;
+ }
+
+ case BI_RLE8 :
+ {
+ BYTE status_byte = 0;
+ BYTE second_byte = 0;
+ int scanline = 0;
+ int bits = 0;
+
+ for (;;) {
+ io.read_proc(&status_byte, sizeof(BYTE), 1, handle);
+
+ switch (status_byte) {
+ case RLE_COMMAND :
+ io.read_proc(&status_byte, sizeof(BYTE), 1, handle);
+
+ switch (status_byte) {
+ case RLE_ENDOFLINE :
+ bits = 0;
+ scanline++;
+ break;
+
+ case RLE_ENDOFBITMAP :
+ return (FIBITMAP *)dib;
+
+ case RLE_DELTA :
+ {
+ // read the delta values
+
+ BYTE delta_x;
+ BYTE delta_y;
+
+ io.read_proc(&delta_x, sizeof(BYTE), 1, handle);
+ io.read_proc(&delta_y, sizeof(BYTE), 1, handle);
+
+ // apply them
+
+ bits += delta_x;
+ scanline += delta_y;
+ break;
+ }
+
+ default :
+ io.read_proc((void *)(freeimage.get_scanline_proc(dib, scanline) + bits), sizeof(BYTE) * status_byte, 1, handle);
+
+ // align run length to even number of bytes
+
+ if (status_byte & 1 == 1)
+ io.read_proc(&second_byte, sizeof(BYTE), 1, handle);
+
+ bits += status_byte;
+
+ break;
+ };
+
+ break;
+
+ default :
+ BYTE *sline = freeimage.get_scanline_proc(dib, scanline);
+
+ io.read_proc(&second_byte, sizeof(BYTE), 1, handle);
+
+ for (unsigned i = 0; i < status_byte; i++) {
+ *(sline + bits) = second_byte;
+
+ bits++;
+ }
+
+ break;
+ };
+ }
+
+ break;
+ }
+
+ default :
+ throw "compression type not supported";
+ }
+
+ break;
+ }
+
+ case 16 :
+ {
+ if (bih.biCompression == 3) {
+ DWORD bitfields[3];
+
+ io.read_proc(bitfields, 3 * sizeof(DWORD), 1, handle);
+
+ dib = freeimage.allocate_proc(width, height, bit_count, bitfields[2], bitfields[1], bitfields[0]);
+ } else {
+ dib = freeimage.allocate_proc(width, height, bit_count, 0x1F, 0x3E0, 0x7C00);
+ }
+
+ if (dib == NULL)
+ throw "DIB allocation failed";
+
+ BITMAPINFOHEADER *pInfoHeader = freeimage.get_info_header_proc(dib);
+ pInfoHeader->biXPelsPerMeter = bih.biXPelsPerMeter;
+ pInfoHeader->biYPelsPerMeter = bih.biYPelsPerMeter;
+
+ if (bitmap_bits_offset > (sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + (used_colors * 3)))
+ io.seek_proc(handle, bitmap_bits_offset, SEEK_SET);
+
+ io.read_proc(freeimage.get_bits_proc(dib), height * pitch, 1, handle);
+
+ return dib;
+ }
+
+ case 24 :
+ case 32 :
+ {
+ dib = freeimage.allocate_proc(width, height, bit_count, 0xFF, 0xFF00, 0xFF0000);
+
+ if (dib == NULL)
+ throw "DIB allocation failed";
+
+ BITMAPINFOHEADER *pInfoHeader = freeimage.get_info_header_proc(dib);
+ pInfoHeader->biXPelsPerMeter = bih.biXPelsPerMeter;
+ pInfoHeader->biYPelsPerMeter = bih.biYPelsPerMeter;
+
+ // Skip over the optional palette
+ // A 24 or 32 bit DIB may contain a palette for faster color reduction
+
+ if (bitmap_bits_offset > (sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + (used_colors * 3)))
+ io.seek_proc(handle, bitmap_bits_offset, SEEK_SET);
+
+ // read in the bitmap bits
+
+ io.read_proc(freeimage.get_bits_proc(dib), height * pitch, 1, handle);
+
+ // check if the bitmap contains transparency, if so enable it in the header
+
+ if (freeimage.get_color_type_proc(dib) == FIC_RGBALPHA)
+ freeimage.set_transparent_proc(dib, TRUE);
+ else
+ freeimage.set_transparent_proc(dib, FALSE);
+
+ return dib;
+ }
+ }
+ } catch(const char *message) {
+ freeimage.output_message_proc(s_format_id, message);
+ }
+
+ return NULL;
+}
+
+static FIBITMAP *
+LoadOS21XBMP(FreeImage &freeimage, FreeImageIO &io, fi_handle handle, int flags, unsigned bitmap_bits_offset) {
+ FIBITMAP *dib = NULL;
+
+ try {
+ BITMAPINFOOS2_1X_HEADER bios2_1x;
+
+ io.read_proc(&bios2_1x, sizeof(BITMAPINFOOS2_1X_HEADER), 1, handle);
+
+ // keep some general information about the bitmap
+
+ int used_colors = 0;
+ int width = bios2_1x.biWidth;
+ int height = bios2_1x.biHeight;
+ int bit_count = bios2_1x.biBitCount;
+ int compression = 0;
+ int pitch = CalculatePitch(CalculateLine(width, bit_count));
+
+ switch (bit_count) {
+ case 1 :
+ case 4 :
+ case 8 :
+ {
+ used_colors = CalculateUsedColors(bit_count);
+
+ // allocate enough memory to hold the bitmap (header, palette, pixels) and read the palette
+
+ dib = freeimage.allocate_proc(width, height, bit_count);
+
+ if (dib == NULL)
+ throw "DIB allocation failed";
+
+ BITMAPINFOHEADER *pInfoHeader = freeimage.get_info_header_proc(dib);
+ pInfoHeader->biXPelsPerMeter = 0;
+ pInfoHeader->biYPelsPerMeter = 0;
+
+ // load the palette
+
+ RGBQUAD *pal = freeimage.get_palette_proc(dib);
+
+ for (int count = 0; count < used_colors; count++) {
+ RGBTRIPLE triple;
+
+ io.read_proc(&triple, sizeof(RGBTRIPLE), 1, handle);
+
+ pal[count].rgbRed = triple.rgbtRed;
+ pal[count].rgbGreen = triple.rgbtGreen;
+ pal[count].rgbBlue = triple.rgbtBlue;
+ }
+
+ // Skip over the optional palette
+ // A 24 or 32 bit DIB may contain a palette for faster color reduction
+
+ io.seek_proc(handle, bitmap_bits_offset, SEEK_SET);
+
+ // read the pixel data
+
+ if (height > 0) {
+ io.read_proc((void *)freeimage.get_bits_proc(dib), height * pitch, 1, handle);
+ } else {
+ for (int c = 0; c < abs(height); ++c) {
+ io.read_proc((void *)freeimage.get_scanline_proc(dib, height - c - 1), pitch, 1, handle);
+ }
+ }
+
+ return dib;
+ }
+
+ case 16 :
+ {
+ dib = freeimage.allocate_proc(width, height, bit_count, 0x1F, 0x3E0, 0x7C00);
+
+ if (dib == NULL)
+ throw "DIB allocation failed";
+
+ BITMAPINFOHEADER *pInfoHeader = freeimage.get_info_header_proc(dib);
+ pInfoHeader->biXPelsPerMeter = 0;
+ pInfoHeader->biYPelsPerMeter = 0;
+
+ io.read_proc(freeimage.get_bits_proc(dib), height * pitch, 1, handle);
+
+ return dib;
+ }
+
+ case 24 :
+ case 32 :
+ {
+ dib = freeimage.allocate_proc(width, height, bit_count, 0xFF, 0xFF00, 0xFF0000);
+
+ if (dib == NULL)
+ throw "DIB allocation failed";
+
+ BITMAPINFOHEADER *pInfoHeader = freeimage.get_info_header_proc(dib);
+ pInfoHeader->biXPelsPerMeter = 0;
+ pInfoHeader->biYPelsPerMeter = 0;
+
+ // Skip over the optional palette
+ // A 24 or 32 bit DIB may contain a palette for faster color reduction
+
+ io.read_proc(freeimage.get_bits_proc(dib), height * pitch, 1, handle);
+
+ // check if the bitmap contains transparency, if so enable it in the header
+
+ freeimage.set_transparent_proc(dib, (freeimage.get_color_type_proc(dib) == FIC_RGBALPHA));
+
+ return dib;
+ }
+ }
+ } catch(const char *message) {
+ freeimage.output_message_proc(s_format_id, message);
+ }
+
+ return NULL;
+}
+
+// ==========================================================
+// Plugin Implementation
+// ==========================================================
+
+static const char * DLL_CALLCONV
+Format() {
+ return "BMP";
+}
+
+static const char * DLL_CALLCONV
+Description() {
+ return "Windows or OS/2 Bitmap";
+}
+
+static const char * DLL_CALLCONV
+Extension() {
+ return "bmp";
+}
+
+static const char * DLL_CALLCONV
+RegExpr() {
+ return "^BM";
+}
+
+static BOOL DLL_CALLCONV
+Validate(FreeImageIO &io, fi_handle handle) {
+ BYTE bmp_signature1[] = { 0x42, 0x4D };
+ BYTE bmp_signature2[] = { 0x42, 0x41 };
+ BYTE signature[2];
+
+ int items_read = io.read_proc(signature, 1, sizeof(bmp_signature1), handle);
+
+ if (memcmp(bmp_signature1, signature, sizeof(bmp_signature1)) == 0)
+ return TRUE;
+
+ if (memcmp(bmp_signature2, signature, sizeof(bmp_signature2)) == 0)
+ return TRUE;
+
+ return FALSE;
+}
+
+// ----------------------------------------------------------
+
+static FIBITMAP * DLL_CALLCONV
+Load(FreeImage &freeimage, FreeImageIO &io, fi_handle handle, int page, int flags, void *data) {
+ if (handle != NULL) {
+ BITMAPFILEHEADER bitmapfileheader;
+ DWORD type = 0;
+ WORD magic;
+
+ // we use this offset value to make seemingly absolute seeks relative in the file
+
+ long offset_in_file = io.tell_proc(handle);
+
+ // read the magic
+
+ io.read_proc(&magic, sizeof(WORD), 1, handle);
+
+ // compare the magic with the number we know
+
+ while (memcmp(&magic, "BA", 2) == 0) {
+ io.read_proc(&bitmapfileheader.bfSize, sizeof(DWORD), 1, handle);
+ io.read_proc(&bitmapfileheader.bfReserved1, sizeof(WORD), 1, handle);
+ io.read_proc(&bitmapfileheader.bfReserved2, sizeof(WORD), 1, handle);
+ io.read_proc(&bitmapfileheader.bfOffBits, sizeof(DWORD), 1, handle);
+ io.read_proc(&magic, sizeof(WORD), 1, handle);
+ }
+
+ // read the fileheader
+
+ io.seek_proc(handle, 0 - sizeof(WORD), SEEK_CUR);
+ io.read_proc(&bitmapfileheader, sizeof(BITMAPFILEHEADER), 1, handle);
+
+ // read the first byte of the infoheader
+
+ io.read_proc(&type, sizeof(DWORD), 1, handle);
+ io.seek_proc(handle, 0 - sizeof(DWORD), SEEK_CUR);
+
+ // call the appropriate load function for the found bitmap type
+
+ if (type == 40)
+ return LoadWindowsBMP(freeimage, io, handle, flags, offset_in_file + bitmapfileheader.bfOffBits);
+
+ if (type == 12)
+ return LoadOS21XBMP(freeimage, io, handle, flags, offset_in_file + bitmapfileheader.bfOffBits);
+
+ if (type <= 64)
+ return LoadOS22XBMP(freeimage, io, handle, flags, offset_in_file + bitmapfileheader.bfOffBits);
+ }
+
+ return NULL;
+}
+
+// ----------------------------------------------------------
+
+static BOOL DLL_CALLCONV
+Save(FreeImage &freeimage, FreeImageIO &io, FIBITMAP *dib, fi_handle handle, int page, int flags, void *data) {
+ if ((dib != NULL) && (handle != NULL)) {
+ bool bit_fields = (freeimage.get_bpp_proc(dib) == 16);
+
+ // write the file header
+
+ BITMAPFILEHEADER bitmapfileheader;
+ bitmapfileheader.bfType = 0x4D42;
+ bitmapfileheader.bfSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + freeimage.get_height_proc(dib) * freeimage.get_pitch_proc(dib);
+ bitmapfileheader.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + freeimage.get_colors_used_proc(dib) * sizeof(RGBQUAD);
+ bitmapfileheader.bfReserved1 = 0;
+ bitmapfileheader.bfReserved2 = 0;
+
+ if (bit_fields) {
+ bitmapfileheader.bfSize += 3 * sizeof(DWORD);
+ bitmapfileheader.bfOffBits += 3 * sizeof(DWORD);
+ }
+
+ if (io.write_proc(&bitmapfileheader, sizeof(BITMAPFILEHEADER), 1, handle) != 1)
+ return FALSE;
+
+ // write the info header
+
+ BITMAPINFOHEADER bih = *freeimage.get_info_header_proc(dib);
+
+ bih.biCompression = (bit_fields) ? 3 : 0;
+ bih.biBitCount = ((freeimage.get_bpp_proc(dib) == 32) && (!freeimage.is_transparent_proc(dib))) ? 24 : bih.biBitCount;
+
+ if (io.write_proc(&bih, sizeof(BITMAPINFOHEADER), 1, handle) != 1) {
+ return FALSE;
+ }
+
+ // write the bit fields when we are dealing with a 16 bit BMP
+
+ if (bit_fields) {
+ DWORD d;
+
+ d = freeimage.get_blue_mask_proc(dib);
+
+ if (io.write_proc(&d, sizeof(DWORD), 1, handle) != 1)
+ return FALSE;
+
+ d = freeimage.get_green_mask_proc(dib);
+
+ if (io.write_proc(&d, sizeof(DWORD), 1, handle) != 1)
+ return FALSE;
+
+ d = freeimage.get_red_mask_proc(dib);
+
+ if (io.write_proc(&d, sizeof(DWORD), 1, handle) != 1)
+ return FALSE;
+ }
+
+ // write the palette
+
+ if (freeimage.get_palette_proc(dib) != NULL)
+ if (io.write_proc(freeimage.get_palette_proc(dib), sizeof(RGBQUAD) * freeimage.get_colors_used_proc(dib), 1, handle) != 1)
+ return FALSE;
+
+ // write the bitmap data
+
+ if ((freeimage.get_bpp_proc(dib) == 32) && (!freeimage.is_transparent_proc(dib))) {
+ int pitch = CalculatePitch(CalculateLine(freeimage.get_width_proc(dib), 24));
+
+ BYTE *buffer = (BYTE *)malloc(pitch);
+
+ for (unsigned i = 0; i < freeimage.get_height_proc(dib); ++i) {
+ freeimage.convert_line_32to24_proc(buffer, freeimage.get_scanline_proc(dib, i), freeimage.get_width_proc(dib));
+
+ if (io.write_proc(buffer, pitch, 1, handle) != 1) {
+ free(buffer);
+ return FALSE;
+ }
+ }
+
+ free(buffer);
+ } else {
+ if (io.write_proc(freeimage.get_bits_proc(dib), freeimage.get_height_proc(dib) * freeimage.get_pitch_proc(dib), 1, handle) != 1) {
+ return FALSE;
+ }
+ }
+
+ return TRUE;
+ } else {
+ return FALSE;
+ }
+}
+
+// ==========================================================
+// Init
+// ==========================================================
+
+void DLL_CALLCONV
+InitBMP(Plugin &plugin, int format_id) {
+ s_format_id = format_id;
+
+ plugin.format_proc = Format;
+ plugin.description_proc = Description;
+ plugin.extension_proc = Extension;
+ plugin.regexpr_proc = RegExpr;
+ plugin.load_proc = Load;
+ plugin.save_proc = 0; //Save;
+ plugin.validate_proc = Validate;
+}
diff --git a/freeimage241/Source/FreeImage/PluginICO.cpp b/freeimage241/Source/FreeImage/PluginICO.cpp
new file mode 100644
index 0000000..2084a1e
--- /dev/null
+++ b/freeimage241/Source/FreeImage/PluginICO.cpp
@@ -0,0 +1,217 @@
+// ==========================================================
+// ICO Loader
+//
+// Design and implementation by
+// - Floris van den Berg (flvdberg@wxs.nl)
+//
+// This file is part of FreeImage 2
+//
+// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
+// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
+// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
+// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
+// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
+// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
+// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+// THIS DISCLAIMER.
+//
+// Use at your own risk!
+// ==========================================================
+
+#include
+
+#include "FreeImage.h"
+#include "Utilities.h"
+
+// ----------------------------------------------------------
+// Constants + headers
+// ----------------------------------------------------------
+
+#ifdef WIN32
+#pragma pack(push, 1)
+#else
+#pragma pack(1)
+#endif
+
+typedef struct tagIconDirectoryEntry {
+ BYTE bWidth;
+ BYTE bHeight;
+ BYTE bColorCount;
+ BYTE bReserved;
+ WORD wPlanes;
+ WORD wBitCount;
+ DWORD dwBytesInRes;
+ DWORD dwImageOffset;
+} ICONDIRENTRY;
+
+typedef struct tagIconDir {
+ WORD idReserved;
+ WORD idType;
+ WORD idCount;
+} ICONHEADER;
+
+#ifdef WIN32
+#pragma pack(pop)
+#else
+#pragma pack(4)
+#endif
+
+// ==========================================================
+// Plugin Interface
+// ==========================================================
+
+static int s_format_id;
+
+// ==========================================================
+// Plugin Implementation
+// ==========================================================
+
+static const char * DLL_CALLCONV
+Format() {
+ return "ICO";
+}
+
+static const char * DLL_CALLCONV
+Description() {
+ return "Windows Icon";
+}
+
+static const char * DLL_CALLCONV
+Extension() {
+ return "ico";
+}
+
+static const char * DLL_CALLCONV
+RegExpr() {
+ return NULL;
+}
+
+static BOOL DLL_CALLCONV
+Validate(FreeImageIO &io, fi_handle handle) {
+ ICONHEADER icon_header;
+
+ long read = io.read_proc(&icon_header, 1, sizeof(ICONHEADER), handle);
+
+ return ((icon_header.idReserved == 0) && (icon_header.idType == 1));
+}
+
+// ----------------------------------------------------------
+
+static FIBITMAP * DLL_CALLCONV
+Load(FreeImage &freeimage, FreeImageIO &io, fi_handle handle, int page, int flags, void *data) {
+ if (page == -1)
+ page = 0;
+
+ if (handle != NULL) {
+ FIBITMAP *dib;
+
+ // we use this offset value to make seemingly absolute seeks relative in the file
+
+ long start_of_file = io.tell_proc(handle);
+
+ // read the icon header
+
+ ICONHEADER icon_header;
+
+ io.read_proc(&icon_header, sizeof(ICONHEADER), 1, handle);
+
+ if ((icon_header.idReserved == 0) && (icon_header.idType == 1)) {
+ // load the icon descriptions
+
+ ICONDIRENTRY *icon_list = (ICONDIRENTRY *)malloc(icon_header.idCount * sizeof(ICONDIRENTRY));
+
+ io.read_proc(icon_list, icon_header.idCount * sizeof(ICONDIRENTRY), 1, handle);
+
+ // load the specified icon
+
+ if (page < icon_header.idCount) {
+ // seek to the start of the bitmap data for the icon
+
+ io.seek_proc(handle, start_of_file, SEEK_SET);
+ io.seek_proc(handle, icon_list[(int)flags].dwImageOffset, SEEK_CUR);
+
+ // load the BITMAPINFOHEADER
+
+ BITMAPINFOHEADER header;
+ io.read_proc(&header, sizeof(BITMAPINFOHEADER), 1, handle);
+
+ // allocate the bitmap
+
+ int width = header.biWidth;
+ int height = header.biHeight / 2; // height == xor + and mask
+ int bit_count = header.biBitCount;
+ int line = CalculateLine(width, bit_count);
+ int pitch = CalculatePitch(line);
+
+ // allocate memory for one icon
+
+ dib = freeimage.allocate_proc(width, height, bit_count);
+
+ if (dib == NULL) {
+ free(icon_list);
+
+ return NULL;
+ }
+
+ // black and white cursors look much better on white
+
+ if (icon_header.idType == 2)
+ if (bit_count == 1)
+ memset(FreeImage_GetBits(dib), 255, pitch * height);
+
+ // read the palette data
+
+ io.read_proc(freeimage.get_palette_proc(dib), CalculateUsedColors(bit_count) * sizeof(RGBQUAD), 1, handle);
+
+ // apply the AND and XOR masks
+
+ BYTE *xor_mask = (BYTE *)malloc(pitch * height);
+ BYTE *and_mask = (BYTE *)malloc(pitch * height);
+ BYTE *copy_xor_mask = xor_mask;
+ BYTE *copy_and_mask = and_mask;
+
+ io.read_proc(xor_mask, pitch * height, 1, handle);
+ io.read_proc(and_mask, pitch * height, 1, handle);
+
+ for (int row = 0; row < height; row++) {
+ for (int column = 0; column < line; column++) {
+ *(freeimage.get_scanline_proc(dib, row) + column) &= copy_and_mask[column];
+ *(freeimage.get_scanline_proc(dib, row) + column) ^= copy_xor_mask[column];
+ }
+
+ copy_xor_mask += pitch;
+ copy_and_mask += pitch;
+ }
+
+ free(icon_list);
+ free(and_mask);
+ free(xor_mask);
+
+ // bitmap has been loaded successfully!
+
+ return (FIBITMAP *)dib;
+ }
+ } else {
+ freeimage.output_message_proc(s_format_id, "file is not an ICO file");
+ }
+ }
+
+ return NULL;
+}
+
+// ==========================================================
+// Init
+// ==========================================================
+
+void DLL_CALLCONV
+InitICO(Plugin &plugin, int format_id) {
+ s_format_id = format_id;
+
+ plugin.format_proc = Format;
+ plugin.description_proc = Description;
+ plugin.extension_proc = Extension;
+ plugin.regexpr_proc = RegExpr;
+ plugin.load_proc = Load;
+ plugin.validate_proc = Validate;
+}
diff --git a/freeimage241/Source/FreeImage/PluginIFF.cpp b/freeimage241/Source/FreeImage/PluginIFF.cpp
new file mode 100644
index 0000000..1adf06b
--- /dev/null
+++ b/freeimage241/Source/FreeImage/PluginIFF.cpp
@@ -0,0 +1,318 @@
+// ==========================================================
+// Deluxe Paint Loader
+//
+// Design and implementation by
+// - Floris van den Berg (flvdberg@wxs.nl)
+// - Mark Sibly (marksibly@blitzbasic.com)
+//
+// This file is part of FreeImage 2
+//
+// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
+// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
+// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
+// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
+// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
+// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
+// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+// THIS DISCLAIMER.
+//
+// Use at your own risk!
+// ==========================================================
+
+#include "FreeImage.h"
+#include "Utilities.h"
+
+// ----------------------------------------------------------
+// Internal typedefs and structures
+// ----------------------------------------------------------
+
+#ifdef WIN32
+#pragma pack(push, 1)
+#else
+#pragma pack(1)
+#endif
+
+typedef struct {
+ WORD w, h; /* raster width & height in pixels */
+ WORD x, y; /* position for this image */
+ BYTE nPlanes; /* # source bitplanes */
+ BYTE masking; /* masking technique */
+ BYTE compression; /* compression algorithm */
+ BYTE pad1; /* UNUSED. For consistency, put 0 here.*/
+ WORD transparentColor; /* transparent "color number" */
+ BYTE xAspect, yAspect; /* aspect ratio, a rational number x/y */
+ WORD pageWidth, pageHeight; /* source "page" size in pixels */
+} BMHD;
+
+#ifdef WIN32
+#pragma pack(pop)
+#else
+#pragma pack(4)
+#endif
+
+// ----------------------------------------------------------
+
+static BOOL big_endian = TRUE;
+
+// ----------------------------------------------------------
+
+static WORD swapWORD( WORD n ){
+ return big_endian ? (n >> 8) | (n << 8) : n;
+}
+
+static DWORD swapDWORD( DWORD n ){
+ return big_endian ? (n >> 24) | (n << 24) | ((n >> 8) & 0xff00) | ((n << 8) & 0xff0000) : n;
+}
+
+// ==========================================================
+// Plugin Interface
+// ==========================================================
+
+static int s_format_id;
+
+// ==========================================================
+// Plugin Implementation
+// ==========================================================
+
+static const char * DLL_CALLCONV
+Format() {
+ return "IFF";
+}
+
+static const char * DLL_CALLCONV
+Description() {
+ return "IFF Interleaved Bitmap";
+}
+
+static const char * DLL_CALLCONV
+Extension() {
+ return "iff,lbm";
+}
+
+static const char * DLL_CALLCONV
+RegExpr() {
+ return NULL;
+}
+
+static BOOL DLL_CALLCONV
+Validate(FreeImageIO &io, fi_handle handle) {
+ unsigned type = 0;
+
+ io.read_proc(&type, 4, 1, handle);
+
+ return (swapDWORD(type) == 'FORM');
+}
+
+// ----------------------------------------------------------
+
+static FIBITMAP * DLL_CALLCONV
+Load(FreeImage &freeimage, FreeImageIO &io, fi_handle handle, int page, int flags, void *data) {
+ if (handle != NULL) {
+ FIBITMAP *dib = 0;
+
+ unsigned type, size;
+
+ io.read_proc(&type, 4, 1, handle);
+
+ if (swapDWORD(type) != 'FORM')
+ return NULL;
+
+ io.read_proc( &size,4,1,handle );
+
+ size = swapDWORD(size);
+
+ io.read_proc(&type, 4, 1, handle);
+
+ if ((swapDWORD(type) != 'ILBM') && (swapDWORD(type) != 'PBM '))
+ return NULL;
+
+ size -= 4;
+
+ unsigned width, height, planes, depth, comp;
+
+ while (size) {
+ unsigned ch_type,ch_size;
+
+ io.read_proc(&ch_type, 4, 1, handle);
+ ch_type = swapDWORD(ch_type);
+
+ io.read_proc(&ch_size,4,1,handle );
+ ch_size = swapDWORD(ch_size);
+
+ unsigned ch_end = io.tell_proc(handle) + ch_size;
+
+ if (ch_type == 'BMHD') {
+ if (dib)
+ FreeImage_Unload(dib);
+
+ BMHD bmhd;
+
+ io.read_proc(&bmhd, sizeof(bmhd), 1, handle);
+
+ width = swapWORD(bmhd.w);
+ height = swapWORD(bmhd.h);
+ planes = bmhd.nPlanes;
+ comp = bmhd.compression;
+
+ if (planes > 8 && planes != 24)
+ return NULL;
+
+ depth = planes > 8 ? 24 : 8;
+
+ unsigned mask = planes > 8 ? 0xff : 0;
+
+ dib = freeimage.allocate_proc(width, height, depth, mask << 16, mask << 8, mask);
+ } else if (ch_type == 'CMAP') {
+ if (!dib)
+ return NULL;
+
+ RGBQUAD *pal = freeimage.get_palette_proc(dib);
+
+ for (unsigned k = 0; k < ch_size / 3;++k ){
+ io.read_proc(&pal[k].rgbRed, 1, 1, handle );
+ io.read_proc(&pal[k].rgbGreen, 1, 1, handle );
+ io.read_proc(&pal[k].rgbBlue, 1, 1, handle );
+ }
+
+ } else if (ch_type == 'BODY') {
+ if (!dib)
+ return NULL;
+
+ if (swapDWORD(type) == 'PBM ') {
+ // NON INTERLACED (LBM)
+
+ unsigned line = freeimage.get_line_proc(dib) + 1 & ~1;
+
+ for (unsigned i = 0; i < freeimage.get_height_proc(dib); ++i) {
+ BYTE *bits = freeimage.get_scanline_proc(dib, freeimage.get_height_proc(dib) - i - 1);
+
+ if (comp == 1) {
+ // use RLE compression
+
+ DWORD number_of_bytes_written = 0;
+ BYTE rle_count;
+ BYTE byte;
+
+ while (number_of_bytes_written < line) {
+ io.read_proc(&rle_count, 1, 1, handle);
+
+ if (rle_count < 128) {
+ for (int k = 0; k < rle_count + 1; k++) {
+ io.read_proc(&byte, 1, 1, handle);
+
+ bits[number_of_bytes_written++] += byte;
+ }
+ } else if (rle_count > 128) {
+ io.read_proc(&byte, 1, 1, handle);
+
+ for (int k = 0; k < 257 - rle_count; k++) {
+ bits[number_of_bytes_written++] += byte;
+ }
+ }
+ }
+ } else {
+ // don't use compression
+
+ io.read_proc(bits, line, 1, handle);
+ }
+ }
+
+ return dib;
+ } else {
+ // INTERLACED (ILBM)
+
+ unsigned pixel_size = depth/8;
+ unsigned n_width=(width+15)&~15;
+ unsigned plane_size = n_width/8;
+ unsigned src_size = plane_size * planes;
+ unsigned char *src = (unsigned char*)malloc(src_size);
+ unsigned char *dest = freeimage.get_bits_proc(dib);
+
+ dest += freeimage.get_pitch_proc(dib) * height;
+
+ for (unsigned y = 0; y < height; ++y) {
+ dest -= freeimage.get_pitch_proc(dib);
+
+ // read all planes in one hit,
+ // 'coz PSP compresses across planes...
+
+ if (comp) {
+ for(unsigned x = 0; x < src_size;){
+ signed char t;
+
+ io.read_proc(&t, 1, 1, handle);
+
+ if (t >= 0) {
+ ++t;
+
+ io.read_proc(src + x, t, 1, handle);
+
+ x += t;
+ } else if( t!=-128 ){
+ signed char b;
+
+ io.read_proc( &b,1,1,handle );
+
+ t =- t +1;
+
+ memset(src + x, b, t);
+
+ x += t;
+ }
+ }
+ } else {
+ io.read_proc(src, src_size, 1, handle);
+ }
+
+ // lazy planar->chunky...
+
+ for (unsigned x = 0; x < width; ++x) {
+ for (unsigned n = 0; n < planes; ++n) {
+ char bit = src[n * plane_size + (x / 8)] >> ((x^7) & 7);
+ dest[x * pixel_size + (n / 8)] |= (bit & 1) << (n & 7);
+ }
+ }
+
+ if (depth == 24){
+ for(unsigned x = 0; x < width; ++x){
+ char t = dest[x * 3];
+ dest[x * 3] = dest[x * 3 + 2];
+ dest[x * 3 + 2] = t;
+ }
+ }
+ }
+
+ free(src);
+
+ return dib;
+ }
+ }
+
+ io.seek_proc(handle, ch_end - io.tell_proc(handle), SEEK_CUR);
+
+ size -= ch_size+8;
+ }
+
+ if (dib)
+ freeimage.unload_proc(dib);
+ }
+
+ return 0;
+}
+
+// ==========================================================
+// Init
+// ==========================================================
+
+void DLL_CALLCONV
+InitIFF(Plugin &plugin, int format_id) {
+ s_format_id = format_id;
+
+ plugin.format_proc = Format;
+ plugin.description_proc = Description;
+ plugin.extension_proc = Extension;
+ plugin.regexpr_proc = RegExpr;
+ plugin.load_proc = Load;
+ plugin.validate_proc = Validate;
+}
diff --git a/freeimage241/Source/FreeImage/PluginJPEG.cpp b/freeimage241/Source/FreeImage/PluginJPEG.cpp
new file mode 100644
index 0000000..4e39c2b
--- /dev/null
+++ b/freeimage241/Source/FreeImage/PluginJPEG.cpp
@@ -0,0 +1,625 @@
+// ==========================================================
+// JPEG Loader
+//
+// Design and implementation by
+// - Floris van den Berg (flvdberg@wxs.nl)
+// - Jan L. Nauta (jln@magentammt.com)
+// - Markus Loibl (markus.loibl@epost.de)
+//
+// Based on code developed by The Independent JPEG Group
+//
+// This file is part of FreeImage 2
+//
+// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
+// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
+// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
+// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
+// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
+// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
+// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+// THIS DISCLAIMER.
+//
+// Use at your own risk!
+// ==========================================================
+
+#include "FreeImage.h"
+#include "Utilities.h"
+
+extern "C" {
+#define XMD_H
+#undef FAR
+#include
+#include "../LibJPEG/jpeglib.h"
+}
+
+// ----------------------------------------------------------
+
+#define INPUT_BUF_SIZE 4096 /* choose an efficiently fread'able size */
+#define OUTPUT_BUF_SIZE 4096 /* choose an efficiently fwrite'able size */
+
+typedef struct my_error_mgr * my_error_ptr;
+
+// ----------------------------------------------------------
+// Constants + headers
+// ----------------------------------------------------------
+
+METHODDEF(void)
+jpeg_error_exit (j_common_ptr cinfo) {
+ (*cinfo->err->output_message)(cinfo);
+
+ jpeg_destroy(cinfo);
+
+ throw FIF_JPEG;
+}
+
+METHODDEF(void)
+jpeg_output_message (j_common_ptr cinfo) {
+ char buffer[JMSG_LENGTH_MAX];
+
+ (*cinfo->err->format_message)(cinfo, buffer);
+
+ //FreeImage_OutputMessage(FreeImage_GetFIFFromFormat("JPEG"), buffer);
+}
+
+//===========================================================
+/*
+ * jdatasrc.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains decompression data source routines for the case of
+ * reading JPEG data from a file (or any stdio stream). While these routines
+ * are sufficient for most applications, some will want to use a different
+ * source manager.
+ * IMPORTANT: we assume that fread() will correctly transcribe an array of
+ * JOCTETs from 8-bit-wide elements on external storage. If char is wider
+ * than 8 bits on your machine, you may need to do some tweaking.
+ */
+
+#include "../libjpeg/jinclude.h"
+#include "../libjpeg/jpeglib.h"
+#include "../libjpeg/jerror.h"
+
+// Expanded data source object for stdio input --------------
+
+struct my_error_mgr {
+ struct jpeg_error_mgr pub; /* "public" fields */
+
+ jmp_buf setjmp_buffer; /* for return to caller */
+};
+
+// ----------------------------------------------------------
+
+typedef struct {
+ struct jpeg_source_mgr pub; /* public fields */
+
+ fi_handle infile; /* source stream */
+ FreeImageIO *m_io;
+
+ JOCTET * buffer; /* start of buffer */
+ boolean start_of_file; /* have we gotten any data yet? */
+} my_source_mgr;
+
+typedef struct {
+ struct jpeg_destination_mgr pub; /* public fields */
+
+ fi_handle outfile; /* destination stream */
+ FreeImageIO *m_io;
+
+ JOCTET * buffer; /* start of buffer */
+} my_destination_mgr;
+
+// ----------------------------------------------------------
+
+typedef my_source_mgr * freeimage_src_ptr;
+typedef my_destination_mgr * freeimage_dst_ptr;
+
+// ----------------------------------------------------------
+
+METHODDEF(void)
+init_source (j_decompress_ptr cinfo) {
+ freeimage_src_ptr src = (freeimage_src_ptr) cinfo->src;
+
+ /* We reset the empty-input-file flag for each image,
+ * but we don't clear the input buffer.
+ * This is correct behavior for reading a series of images from one source.
+ */
+
+ src->start_of_file = TRUE;
+}
+
+METHODDEF(void)
+init_destination (j_compress_ptr cinfo) {
+ freeimage_dst_ptr dest = (freeimage_dst_ptr) cinfo->dest;
+
+ dest->buffer = (JOCTET *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ OUTPUT_BUF_SIZE * SIZEOF(JOCTET));
+
+ dest->pub.next_output_byte = dest->buffer;
+ dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
+}
+
+// ----------------------------------------------------------
+
+/*
+ * Fill the input buffer --- called whenever buffer is emptied.
+ *
+ * In typical applications, this should read fresh data into the buffer
+ * (ignoring the current state of next_input_byte & bytes_in_buffer),
+ * reset the pointer & count to the start of the buffer, and return TRUE
+ * indicating that the buffer has been reloaded. It is not necessary to
+ * fill the buffer entirely, only to obtain at least one more byte.
+ *
+ * There is no such thing as an EOF return. If the end of the file has been
+ * reached, the routine has a choice of ERREXIT() or inserting fake data into
+ * the buffer. In most cases, generating a warning message and inserting a
+ * fake EOI marker is the best course of action --- this will allow the
+ * decompressor to output however much of the image is there. However,
+ * the resulting error message is misleading if the real problem is an empty
+ * input file, so we handle that case specially.
+ *
+ * In applications that need to be able to suspend compression due to input
+ * not being available yet, a FALSE return indicates that no more data can be
+ * obtained right now, but more may be forthcoming later. In this situation,
+ * the decompressor will return to its caller (with an indication of the
+ * number of scanlines it has read, if any). The application should resume
+ * decompression after it has loaded more data into the input buffer. Note
+ * that there are substantial restrictions on the use of suspension --- see
+ * the documentation.
+ *
+ * When suspending, the decompressor will back up to a convenient restart point
+ * (typically the start of the current MCU). next_input_byte & bytes_in_buffer
+ * indicate where the restart point will be if the current call returns FALSE.
+ * Data beyond this point must be rescanned after resumption, so move it to
+ * the front of the buffer rather than discarding it.
+ */
+
+METHODDEF(boolean)
+fill_input_buffer (j_decompress_ptr cinfo) {
+ freeimage_src_ptr src = (freeimage_src_ptr) cinfo->src;
+
+ size_t nbytes = src->m_io->read_proc(src->buffer, 1, INPUT_BUF_SIZE, src->infile);
+
+ if (nbytes <= 0) {
+ if (src->start_of_file) /* Treat empty input file as fatal error */
+ ERREXIT(cinfo, JERR_INPUT_EMPTY);
+
+ WARNMS(cinfo, JWRN_JPEG_EOF);
+
+ /* Insert a fake EOI marker */
+
+ src->buffer[0] = (JOCTET) 0xFF;
+ src->buffer[1] = (JOCTET) JPEG_EOI;
+
+ nbytes = 2;
+ }
+
+ src->pub.next_input_byte = src->buffer;
+ src->pub.bytes_in_buffer = nbytes;
+ src->start_of_file = FALSE;
+
+ return TRUE;
+}
+
+METHODDEF(boolean)
+empty_output_buffer (j_compress_ptr cinfo) {
+ freeimage_dst_ptr dest = (freeimage_dst_ptr) cinfo->dest;
+
+ if (dest->m_io->write_proc(dest->buffer, 1, OUTPUT_BUF_SIZE, dest->outfile) != OUTPUT_BUF_SIZE)
+ ERREXIT(cinfo, JERR_FILE_WRITE);
+
+ dest->pub.next_output_byte = dest->buffer;
+ dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
+
+ return TRUE;
+}
+
+/*
+ * Skip data --- used to skip over a potentially large amount of
+ * uninteresting data (such as an APPn marker).
+ *
+ * Writers of suspendable-input applications must note that skip_input_data
+ * is not granted the right to give a suspension return. If the skip extends
+ * beyond the data currently in the buffer, the buffer can be marked empty so
+ * that the next read will cause a fill_input_buffer call that can suspend.
+ * Arranging for additional bytes to be discarded before reloading the input
+ * buffer is the application writer's problem.
+ */
+
+METHODDEF(void)
+skip_input_data (j_decompress_ptr cinfo, long num_bytes) {
+ freeimage_src_ptr src = (freeimage_src_ptr) cinfo->src;
+
+ /* Just a dumb implementation for now. Could use fseek() except
+ * it doesn't work on pipes. Not clear that being smart is worth
+ * any trouble anyway --- large skips are infrequent.
+ */
+
+ if (num_bytes > 0) {
+ while (num_bytes > (long) src->pub.bytes_in_buffer) {
+ num_bytes -= (long) src->pub.bytes_in_buffer;
+
+ (void) fill_input_buffer(cinfo);
+
+ /* note we assume that fill_input_buffer will never return FALSE,
+ * so suspension need not be handled.
+ */
+ }
+
+ src->pub.next_input_byte += (size_t) num_bytes;
+ src->pub.bytes_in_buffer -= (size_t) num_bytes;
+ }
+}
+
+/*
+ * Terminate source --- called by jpeg_finish_decompress
+ * after all data has been read. Often a no-op.
+ *
+ * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding
+ * application must deal with any cleanup that should happen even
+ * for error exit.
+ */
+
+METHODDEF(void)
+term_source (j_decompress_ptr cinfo) {
+ /* no work necessary here */
+}
+
+METHODDEF(void)
+term_destination (j_compress_ptr cinfo) {
+ freeimage_dst_ptr dest = (freeimage_dst_ptr) cinfo->dest;
+
+ size_t datacount = OUTPUT_BUF_SIZE - dest->pub.free_in_buffer;
+
+ /* Write any data remaining in the buffer */
+
+ if (datacount > 0) {
+ if (dest->m_io->write_proc(dest->buffer, 1, datacount, dest->outfile) != datacount)
+ ERREXIT(cinfo, JERR_FILE_WRITE);
+ }
+}
+
+/*
+ * Prepare for input from a stdio stream.
+ * The caller must have already opened the stream, and is responsible
+ * for closing it after finishing decompression.
+ */
+
+GLOBAL(void)
+jpeg_freeimage_src (j_decompress_ptr cinfo, fi_handle infile, FreeImageIO &io) {
+ freeimage_src_ptr src;
+
+ // allocate memory for the buffer. is released automatically in the end
+
+ if (cinfo->src == NULL) {
+ cinfo->src = (struct jpeg_source_mgr *) (*cinfo->mem->alloc_small)
+ ((j_common_ptr) cinfo, JPOOL_PERMANENT, SIZEOF(my_source_mgr));
+
+ src = (freeimage_src_ptr) cinfo->src;
+
+ src->buffer = (JOCTET *) (*cinfo->mem->alloc_small)
+ ((j_common_ptr) cinfo, JPOOL_PERMANENT, INPUT_BUF_SIZE * SIZEOF(JOCTET));
+ }
+
+ // initialize the jpeg pointer struct with pointers to functions
+
+ src = (freeimage_src_ptr) cinfo->src;
+ src->pub.init_source = init_source;
+ src->pub.fill_input_buffer = fill_input_buffer;
+ src->pub.skip_input_data = skip_input_data;
+ src->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */
+ src->pub.term_source = term_source;
+ src->infile = infile;
+ src->m_io = &io;
+ src->pub.bytes_in_buffer = 0; /* forces fill_input_buffer on first read */
+ src->pub.next_input_byte = NULL; /* until buffer loaded */
+}
+
+GLOBAL(void)
+jpeg_freeimage_dst (j_compress_ptr cinfo, fi_handle outfile, FreeImageIO &io) {
+ freeimage_dst_ptr dest;
+
+ if (cinfo->dest == NULL) {
+ cinfo->dest = (struct jpeg_destination_mgr *)(*cinfo->mem->alloc_small)
+ ((j_common_ptr) cinfo, JPOOL_PERMANENT, SIZEOF(my_destination_mgr));
+ }
+
+ dest = (freeimage_dst_ptr) cinfo->dest;
+ dest->pub.init_destination = init_destination;
+ dest->pub.empty_output_buffer = empty_output_buffer;
+ dest->pub.term_destination = term_destination;
+ dest->outfile = outfile;
+ dest->m_io = &io;
+}
+
+// ==========================================================
+// Plugin Interface
+// ==========================================================
+
+static int s_format_id;
+
+// ==========================================================
+// Plugin Implementation
+// ==========================================================
+
+static const char * DLL_CALLCONV
+Format() {
+ return "JPEG";
+}
+
+static const char * DLL_CALLCONV
+Description() {
+ return "JPEG - JFIF Compliant";
+}
+
+static const char * DLL_CALLCONV
+Extension() {
+ return "jpg,jif,jpeg";
+}
+
+static const char * DLL_CALLCONV
+RegExpr() {
+ return "^\377\330\377";
+}
+
+static const char * DLL_CALLCONV
+MimeType() {
+ return "image/jpeg";
+}
+
+static BOOL DLL_CALLCONV
+Validate(FreeImageIO &io, fi_handle handle) {
+ BYTE jpeg_signature[] = { 0xFF, 0xD8 };
+ BYTE signature[2] = { 0, 0 };
+
+ io.read_proc(signature, 1, sizeof(jpeg_signature), handle);
+
+ return (memcmp(jpeg_signature, signature, sizeof(jpeg_signature)) == 0);
+}
+
+// ----------------------------------------------------------
+
+static FIBITMAP * DLL_CALLCONV
+Load(FreeImage &freeimage, FreeImageIO &io, fi_handle handle, int page, int flags, void *data) {
+ if (handle) {
+ FIBITMAP *dib = NULL;
+
+ try {
+ struct jpeg_decompress_struct cinfo;
+ struct jpeg_error_mgr jerr;
+
+ // Step 1: allocate and initialize JPEG decompression object
+
+ cinfo.err = jpeg_std_error(&jerr);
+
+ jerr.error_exit = jpeg_error_exit;
+ jerr.output_message = jpeg_output_message;
+
+ jpeg_create_decompress(&cinfo);
+
+ // Step 2: specify data source (eg, a handle)
+
+ jpeg_freeimage_src(&cinfo, handle, io);
+
+ // Step 3: read handle parameters with jpeg_read_header()
+
+ jpeg_read_header(&cinfo, TRUE);
+
+ // Step 4a: set parameters for decompression
+
+ if ((flags != JPEG_ACCURATE)) {
+ cinfo.dct_method = JDCT_IFAST;
+ cinfo.do_fancy_upsampling = FALSE;
+ }
+
+ // Step 4b: allocate dib and init header
+
+ dib = freeimage.allocate_proc(cinfo.image_width, cinfo.image_height, 8 * cinfo.num_components, 0xFF00, 0xFF, 0xFF0000);
+
+ if (cinfo.num_components == 1) {
+ RGBQUAD *colors = freeimage.get_palette_proc(dib);
+
+ for (int i = 0; i < 256; i++) {
+ colors[i].rgbRed = i;
+ colors[i].rgbGreen = i;
+ colors[i].rgbBlue = i;
+ }
+ }
+
+ // Step 4c: handle metrices
+
+ BITMAPINFOHEADER *pInfoHeader = freeimage.get_info_header_proc(dib);
+
+ if (cinfo.density_unit == 1) {
+ // dots/inch
+
+ pInfoHeader->biXPelsPerMeter = (int) (((float)cinfo.X_density) / 0.0254000 + 0.5);
+ pInfoHeader->biYPelsPerMeter = (int) (((float)cinfo.Y_density) / 0.0254000 + 0.5);
+ } else if (cinfo.density_unit == 2) {
+ // dots/cm
+
+ pInfoHeader->biXPelsPerMeter = cinfo.X_density * 100;
+ pInfoHeader->biYPelsPerMeter = cinfo.Y_density * 100;
+ }
+
+ // Step 5: start decompressor
+
+ jpeg_start_decompress(&cinfo);
+
+ // Step 6: while (scan lines remain to be read) jpeg_read_scanlines(...);
+
+ while (cinfo.output_scanline < cinfo.output_height) {
+ JSAMPROW b = freeimage.get_scanline_proc(dib, cinfo.output_height - cinfo.output_scanline - 1);
+
+ jpeg_read_scanlines(&cinfo, &b, 1);
+ }
+
+ // Step 7: finish decompression
+
+ jpeg_finish_decompress(&cinfo);
+
+ // Step 8: release JPEG decompression object
+
+ jpeg_destroy_decompress(&cinfo);
+
+ return (FIBITMAP *)dib;
+ } catch (...) {
+ freeimage.unload_proc(dib);
+ }
+ }
+
+ return NULL;
+}
+
+static BOOL DLL_CALLCONV
+Save(FreeImage &freeimage, FreeImageIO &io, FIBITMAP *dib, fi_handle handle, int page, int flags, void *data) {
+ if ((dib) && (handle)) {
+ try {
+ // Check dib format
+
+ WORD bpp = freeimage.get_bpp_proc(dib);
+
+ if ((bpp == 32) && (freeimage.is_transparent_proc(dib)))
+ throw "JPEG does not support alpha channels";
+ else if (((bpp != 24) && (bpp != 32)) && (!((bpp == 8) && (FreeImage_GetColorType(dib) == FIC_MINISBLACK))))
+ throw "only 24-bit highcolor or 8-bit greyscale bitmaps can be saved as JPEG";
+
+ struct jpeg_compress_struct cinfo;
+ struct jpeg_error_mgr jerr;
+
+ // Step 1: allocate and initialize JPEG compression object
+
+ cinfo.err = jpeg_std_error(&jerr);
+
+ jerr.error_exit = jpeg_error_exit;
+ jerr.output_message = jpeg_output_message;
+
+ /* Now we can initialize the JPEG compression object. */
+
+ jpeg_create_compress(&cinfo);
+
+ /* Step 2: specify data destination (eg, a file) */
+
+ jpeg_freeimage_dst(&cinfo, handle, io);
+
+ /* Step 3: set parameters for compression */
+
+ cinfo.image_width = freeimage.get_width_proc(dib);
+ cinfo.image_height = freeimage.get_height_proc(dib);
+
+ switch(FreeImage_GetColorType(dib)) {
+ case FIC_MINISBLACK :
+ cinfo.in_color_space = JCS_GRAYSCALE;
+ cinfo.input_components = 1;
+ break;
+
+ default :
+ cinfo.in_color_space = JCS_RGB;
+ cinfo.input_components = 3;
+ break;
+ }
+
+ jpeg_set_defaults(&cinfo);
+
+ // Set JFIF density parameters from the DIB data
+
+ BITMAPINFOHEADER *pInfoHeader = freeimage.get_info_header_proc(dib);
+ cinfo.X_density = (WORD)(pInfoHeader->biXPelsPerMeter / 100.0F + 0.5);
+ cinfo.Y_density = (WORD)(pInfoHeader->biYPelsPerMeter / 100.0F + 0.5);
+ cinfo.density_unit = 2; // dots / cm
+
+ // Step 4: set quality
+ // the first 7 bits are reserved for low level quality settings
+ // the other bits are high level (i.e. enum-ish)
+
+ int quality;
+
+ if ((flags & JPEG_QUALITYBAD) == JPEG_QUALITYBAD) {
+ quality = 10;
+ } else if ((flags & JPEG_QUALITYAVERAGE) == JPEG_QUALITYAVERAGE) {
+ quality = 25;
+ } else if ((flags & JPEG_QUALITYNORMAL) == JPEG_QUALITYNORMAL) {
+ quality = 50;
+ } else if ((flags & JPEG_QUALITYGOOD) == JPEG_QUALITYGOOD) {
+ quality = 75;
+ } else if ((flags & JPEG_QUALITYSUPERB) == JPEG_QUALITYSUPERB) {
+ quality = 100;
+ } else {
+ if ((flags & 0x7F) == 0) {
+ quality = 75;
+ } else {
+ quality = flags & 0x7F;
+ }
+ }
+
+ jpeg_set_quality(&cinfo, quality, TRUE); /* limit to baseline-JPEG values */
+
+ /* Step 5: Start compressor */
+
+ jpeg_start_compress(&cinfo, TRUE);
+
+ /* Step 6: while (scan lines remain to be written) */
+
+ if (freeimage.get_bpp_proc(dib) == 32) {
+ int pitch = CalculatePitch(CalculateLine(freeimage.get_width_proc(dib), 24));
+
+ JSAMPROW b = (BYTE *)malloc(pitch);
+
+ for (unsigned i = 0; i < freeimage.get_height_proc(dib); ++i) {
+ freeimage.convert_line_32to24_proc(b, freeimage.get_scanline_proc(dib, freeimage.get_height_proc(dib) - cinfo.next_scanline - 1), freeimage.get_width_proc(dib));
+
+ jpeg_write_scanlines(&cinfo, &b, 1);
+ }
+
+ free(b);
+ } else {
+ while (cinfo.next_scanline < cinfo.image_height) {
+ JSAMPROW b = freeimage.get_scanline_proc(dib, freeimage.get_height_proc(dib) - cinfo.next_scanline - 1);
+
+ jpeg_write_scanlines(&cinfo, &b, 1);
+ }
+ }
+
+ /* Step 7: Finish compression */
+
+ jpeg_finish_compress(&cinfo);
+
+ /* Step 8: release JPEG compression object */
+
+ jpeg_destroy_compress(&cinfo);
+
+ return TRUE;
+
+ } catch (char *text) {
+ freeimage.output_message_proc(s_format_id, text);
+
+ return FALSE;
+ } catch (FREE_IMAGE_FORMAT) {
+ return FALSE;
+ }
+ }
+
+ return FALSE;
+}
+
+// ==========================================================
+// Init
+// ==========================================================
+
+void DLL_CALLCONV
+InitJPEG(Plugin &plugin, int format_id) {
+ s_format_id = format_id;
+
+ plugin.format_proc = Format;
+ plugin.description_proc = Description;
+ plugin.extension_proc = Extension;
+ plugin.regexpr_proc = RegExpr;
+ plugin.load_proc = Load;
+ plugin.save_proc = 0; //Save;
+ plugin.validate_proc = Validate;
+ plugin.mime_proc = MimeType;
+}
diff --git a/freeimage241/Source/FreeImage/PluginKOALA.cpp b/freeimage241/Source/FreeImage/PluginKOALA.cpp
new file mode 100644
index 0000000..d369169
--- /dev/null
+++ b/freeimage241/Source/FreeImage/PluginKOALA.cpp
@@ -0,0 +1,218 @@
+// ==========================================================
+// KOALA Loader
+//
+// Design and implementation by
+// - Floris van den Berg (flvdberg@wxs.nl)
+//
+// This file is part of FreeImage 2
+//
+// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
+// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
+// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
+// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
+// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
+// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
+// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+// THIS DISCLAIMER.
+//
+// Use at your own risk!
+// ==========================================================
+
+#include "FreeImage.h"
+#include "Utilities.h"
+
+// ----------------------------------------------------------
+// Constants + headers
+// ----------------------------------------------------------
+
+#ifdef WIN32
+#pragma pack(push, 1)
+#else
+#pragma pack(1)
+#endif
+
+typedef struct tagKOALA {
+ BYTE image[8000]; // pixmap image
+ BYTE colour1[1000]; // first colourmap (colour 1 and 2)
+ BYTE colour2[1000]; // second colourmap (colour 3)
+ BYTE background; // background colour
+} koala_t;
+
+struct colour_t {
+ int r;
+ int g;
+ int b;
+};
+
+#ifdef WIN32
+#pragma pack(pop)
+#else
+#pragma pack(4)
+#endif
+
+// ----------------------------------------------------------
+
+#define CBM_WIDTH 320
+#define CBM_HEIGHT 200
+
+// ----------------------------------------------------------
+
+const colour_t c64colours[16] = {
+ { 0, 0, 0 }, // Black
+ { 255, 255, 255 }, // White
+ { 170, 17, 17 }, // Red
+ { 12, 204, 204 }, // Cyan
+ { 221, 51, 221 }, // Purple
+ { 0, 187, 0 }, // Green
+ { 0, 0, 204 }, // Blue
+ { 255, 255, 140 }, // Yellow
+ { 204, 119, 34 }, // Orange
+ { 136, 68, 0 }, // Brown
+ { 255, 153, 136 }, // Light red
+ { 92, 92, 92 }, // Gray 1
+ { 170, 170, 170 }, // Gray 2
+ { 140, 255, 178 }, // Light green
+ { 39, 148, 255 }, // Light blue
+ { 196, 196, 196 } // Gray 3
+};
+
+// ==========================================================
+// Plugin Interface
+// ==========================================================
+
+static int s_format_id;
+
+// ==========================================================
+// Plugin Implementation
+// ==========================================================
+
+const char * DLL_CALLCONV
+Format() {
+ return "KOALA";
+}
+
+const char * DLL_CALLCONV
+Description() {
+ return "C64 Koala Graphics";
+}
+
+const char * DLL_CALLCONV
+Extension() {
+ return "koa";
+}
+
+const char * DLL_CALLCONV
+RegExpr() {
+ return NULL;
+}
+
+static BOOL DLL_CALLCONV
+Validate(FreeImageIO &io, fi_handle handle) {
+ BYTE koala_signature[] = { 0x00, 0x60 };
+ BYTE signature[2] = { 0, 0 };
+
+ int items_read = io.read_proc(signature, 1, sizeof(koala_signature), handle);
+
+ return (memcmp(koala_signature, signature, sizeof(koala_signature)) == 0);
+}
+
+// ----------------------------------------------------------
+
+FIBITMAP * DLL_CALLCONV
+Load(FreeImage &freeimage, FreeImageIO &io, fi_handle handle, int page, int flags, void *data) {
+ if (handle) {
+ koala_t image;
+
+ // read the load address
+
+ unsigned char load_address[2]; // highbit, lowbit
+ io.read_proc(&load_address, 1, 2, handle);
+
+ // if the load address is correct, skip it. otherwise ignore the load address
+
+ if ((load_address[0] != 0x00) || (load_address[1] != 0x60)) {
+ ((BYTE *)&image)[0] = load_address[0];
+ ((BYTE *)&image)[1] = load_address[1];
+
+ io.read_proc((BYTE *)&image + 2, 1, 10001 - 2, handle);
+ } else {
+ io.read_proc(&image, 1, 10001, handle);
+ }
+
+ // build DIB in memory
+
+ FIBITMAP *dib = freeimage.allocate_proc(CBM_WIDTH, CBM_HEIGHT, 4);
+
+ if (dib) {
+ // write out the commodore 64 color palette
+
+ RGBQUAD *palette = freeimage.get_palette_proc(dib);
+
+ for (int i = 0; i < 16; i++) {
+ palette[i].rgbBlue = c64colours[i].b;
+ palette[i].rgbGreen = c64colours[i].g;
+ palette[i].rgbRed = c64colours[i].r;
+ }
+
+ // write out bitmap data
+
+ BYTE pixel_mask[4] = { 0xc0, 0x30, 0x0c, 0x03 };
+ BYTE pixel_displacement[4] = { 6, 4, 2, 0 };
+ int pixel, index, colourindex;
+ unsigned char found_color = 0;
+
+ for (int y = 0; y < 200; y++) {
+ for (int x = 0; x < 160; x++) {
+ // Get value of pixel at (x,y)
+
+ index = (x / 4) * 8 + (y % 8) + (y / 8) * CBM_WIDTH;
+ colourindex = (x / 4) + (y / 8) * 40;
+ pixel = (image.image[index] & pixel_mask[x % 4]) >> pixel_displacement[x % 4];
+
+ // Retrieve RGB values
+
+ switch (pixel) {
+ case 0: // Background
+ found_color = image.background;
+ break;
+
+ case 1: // Colour 1
+ found_color = image.colour1[colourindex] >> 4;
+ break;
+
+ case 2: // Colour 2
+ found_color = image.colour1[colourindex] & 0xf;
+ break;
+
+ case 3: // Colour 3
+ found_color = image.colour2[colourindex] & 0xf;
+ break;
+ };
+
+ *(freeimage.get_scanline_proc(dib, CBM_HEIGHT - y - 1) + x) = (found_color << 4) | found_color;
+ }
+ }
+
+ return dib;
+ }
+ }
+
+ return NULL;
+}
+
+// ==========================================================
+// Init
+// ==========================================================
+
+void DLL_CALLCONV
+InitKOALA(Plugin &plugin, int format_id) {
+ s_format_id = format_id;
+
+ plugin.format_proc = Format;
+ plugin.description_proc = Description;
+ plugin.extension_proc = Extension;
+ plugin.regexpr_proc = RegExpr;
+ plugin.load_proc = Load;
+ plugin.validate_proc = Validate;
+}
diff --git a/freeimage241/Source/FreeImage/PluginMNG.cpp b/freeimage241/Source/FreeImage/PluginMNG.cpp
new file mode 100644
index 0000000..3f8b8d9
--- /dev/null
+++ b/freeimage241/Source/FreeImage/PluginMNG.cpp
@@ -0,0 +1,235 @@
+// ==========================================================
+// MNG Loader
+//
+// Design and implementation by
+// - Floris van den Berg (flvdberg@wxs.nl)
+//
+// This file is part of FreeImage 2
+//
+// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
+// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
+// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
+// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
+// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
+// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
+// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+// THIS DISCLAIMER.
+//
+// Use at your own risk!
+// ==========================================================
+
+#include "FreeImage.h"
+#include "Utilities.h"
+
+#include
+#include
+
+#include "../LibMNG/libmng.h"
+
+// ----------------------------------------------------------
+// Constants + headers
+// ----------------------------------------------------------
+
+typedef struct {
+ FIBITMAP *bitmap; // pointer to the bitmap data
+ FreeImage &freeimage; // pointer to the freeimage access functions
+ FreeImageIO &io; // pointer to the io functions
+ fi_handle file; // pointer to the file we're decoding
+} mngstuff;
+
+// ----------------------------------------------------------
+// Callbacks for the mng decoder
+// ----------------------------------------------------------
+
+mng_ptr
+mymngalloc(mng_uint32 size) {
+ return (mng_ptr)calloc(1, size);
+}
+
+void
+mymngfree(mng_ptr p, mng_uint32 size) {
+ free(p);
+}
+
+mng_bool
+mymngopenstream(mng_handle mng) {
+ // since the user is responsible for opening and closing the file,
+ // we leave the default implementation open
+
+ return MNG_TRUE;
+}
+
+mng_bool
+mymngclosestream(mng_handle mng) {
+ // since the user is responsible for opening and closing the file,
+ // we leave the default implementation open
+
+ return MNG_TRUE;
+}
+
+mng_bool
+mymngreadstream(mng_handle mng, mng_ptr buffer, mng_uint32 size, mng_uint32 *bytesread) {
+ mngstuff *mymng = (mngstuff *)mng_get_userdata(mng);
+
+ *bytesread = mymng->io.read_proc(buffer, 1, size, mymng->file);
+
+ return MNG_TRUE;
+}
+
+mng_bool
+mymngprocessheader(mng_handle mng, mng_uint32 width, mng_uint32 height) {
+ // allocate a bitmap with the given dimensions
+
+ FreeImage &freeimage = ((mngstuff *)mng_get_userdata(mng))->freeimage;
+
+ ((mngstuff *)mng_get_userdata(mng))->bitmap = freeimage.allocate_proc(width, height, 24, 0xFF, 0xFF00, 0xFF0000);
+
+ // tell the mng decoder about our bit-depth choice
+
+ mng_set_canvasstyle(mng, MNG_CANVAS_BGR8);
+
+ return MNG_TRUE;
+}
+
+mng_ptr
+mymnggetcanvasline(mng_handle mng, mng_uint32 line) {
+ FreeImage &freeimage = ((mngstuff *)mng_get_userdata(mng))->freeimage;
+
+ FIBITMAP *bitmap = ((mngstuff *)mng_get_userdata(mng))->bitmap;
+
+ return freeimage.get_scanline_proc(bitmap, freeimage.get_height_proc(bitmap) - line - 1);
+}
+
+mng_bool
+mymngrefresh(mng_handle mng, mng_uint32 x, mng_uint32 y, mng_uint32 w, mng_uint32 h) {
+ return MNG_TRUE;
+}
+
+mng_uint32
+mymnggetticks(mng_handle mng) {
+ return 0;
+}
+
+mng_bool
+mymngsettimer(mng_handle mng, mng_uint32 msecs) {
+ return MNG_TRUE;
+}
+
+mng_bool
+mymngerror(mng_handle mng, mng_int32 code, mng_int8 severity, mng_chunkid chunktype, mng_uint32 chunkseq, mng_int32 extra1, mng_int32 extra2, mng_pchar text) {
+ throw (const char *)text;
+}
+
+// ==========================================================
+// Plugin Interface
+// ==========================================================
+
+static int s_format_id;
+
+// ==========================================================
+// Plugin Implementation
+// ==========================================================
+
+static const char * DLL_CALLCONV
+Format() {
+ return "MNG";
+}
+
+static const char * DLL_CALLCONV
+Description() {
+ return "Multiple Network Graphics";
+}
+
+static const char * DLL_CALLCONV
+Extension() {
+ return "mng";
+}
+
+static const char * DLL_CALLCONV
+RegExpr() {
+ return NULL;
+}
+
+// ----------------------------------------------------------
+
+static void * DLL_CALLCONV
+Open(FreeImageIO &io, fi_handle handle, BOOL read) {
+ mngstuff *mymng = (mngstuff *)calloc(1, sizeof(*mymng));
+ mymng->io = io;
+ mymng->file = handle;
+
+ return mymng;
+}
+
+static void DLL_CALLCONV
+Close(FreeImageIO &io, fi_handle handle, void *data) {
+ free((mngstuff *)data);
+}
+
+// ----------------------------------------------------------
+
+static FIBITMAP * DLL_CALLCONV
+Load(FreeImage &freeimage, FreeImageIO &io, fi_handle handle, int page, int flags, void *data) {
+ if (handle != NULL) {
+ try {
+ // allocate our stream data structure
+
+ mngstuff *mymng = (mngstuff *)data;
+
+ // set up the mng decoder for our stream
+
+ mng_handle mng = mng_initialize(mymng, mymngalloc, mymngfree, MNG_NULL);
+
+ if (mng == MNG_NULL)
+ throw "could not initialize libmng";
+
+ // set the callbacks
+
+ mng_setcb_errorproc(mng, mymngerror);
+ mng_setcb_openstream(mng, mymngopenstream);
+ mng_setcb_closestream(mng, mymngclosestream);
+ mng_setcb_readdata(mng, mymngreadstream);
+ mng_setcb_processheader(mng, mymngprocessheader);
+ mng_setcb_getcanvasline(mng, mymnggetcanvasline);
+ mng_setcb_refresh(mng, mymngrefresh);
+ mng_setcb_gettickcount(mng, mymnggetticks);
+ mng_setcb_settimer(mng, mymngsettimer);
+
+ // read in the bitmap
+
+ mng_readdisplay(mng);
+
+ // temp store the newly created bitmap
+
+ FIBITMAP *bitmap = mymng->bitmap;
+
+ // cleanup and return the temp stored bitmap
+
+ mng_cleanup(&mng);
+
+ return bitmap;
+ } catch (const char *message) {
+ freeimage.output_message_proc(s_format_id, message);
+ }
+ }
+
+ return NULL;
+}
+
+// ==========================================================
+// Init
+// ==========================================================
+
+void DLL_CALLCONV
+InitMNG(Plugin &plugin, int format_id) {
+ s_format_id = format_id;
+
+ plugin.format_proc = Format;
+ plugin.description_proc = Description;
+ plugin.extension_proc = Extension;
+ plugin.regexpr_proc = RegExpr;
+ plugin.open_proc = Open;
+ plugin.close_proc = Close;
+ plugin.load_proc = Load;
+}
diff --git a/freeimage241/Source/FreeImage/PluginPCD.cpp b/freeimage241/Source/FreeImage/PluginPCD.cpp
new file mode 100644
index 0000000..71042ba
--- /dev/null
+++ b/freeimage241/Source/FreeImage/PluginPCD.cpp
@@ -0,0 +1,207 @@
+// ==========================================================
+// Kodak PhotoCD Loader
+//
+// Design and implementation by
+// - Floris van den Berg (flvdberg@wxs.nl)
+//
+// Based on pascal code developed by Alex Kwak
+//
+// This file is part of FreeImage 2
+//
+// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
+// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
+// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
+// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
+// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
+// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
+// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+// THIS DISCLAIMER.
+//
+// Use at your own risk!
+// ==========================================================
+
+#pragma warning (disable : 4244)
+
+#include
+#include
+
+#include "FreeImage.h"
+#include "Utilities.h"
+
+// ==========================================================
+// Internal functions
+// ==========================================================
+
+inline float
+fix(float a) {
+ return (a < 0) ? 0 : (a > 255) ? 255 : a;
+}
+
+static void
+YUV2RGB(int y, int cb, int cr, int &r, int &g, int &b) {
+ const float c = 256;
+
+ float c11 = 0.0054980 * c;
+ float c12 = 0.0000001 * c;
+ float c13 = 0.0051681 * c;
+ float c21 = 0.0054980 * c;
+ float c22 = -0.0015446 * c;
+ float c23 = -0.0026325 * c;
+ float c31 = 0.0054980 * c;
+ float c32 = 0.0079533 * c;
+ float c33 = 0.0000001 * c;
+
+ r = fix(round(c11 * y + c12 * (cb - 156) + c13 * (cr - 137)));
+ g = fix(round(c21 * y + c22 * (cb - 156) + c23 * (cr - 137)));
+ b = fix(round(c31 * y + c32 * (cb - 156) + c33 * (cr - 137)));
+}
+
+static BOOL
+VerticalOrientation(FreeImageIO &io, fi_handle handle) {
+ char buffer[128];
+
+ io.read_proc(buffer, 128, 1, handle);
+
+ return (buffer[72] & 63) == 8;
+}
+
+// ==========================================================
+// Plugin Interface
+// ==========================================================
+
+static int s_format_id;
+
+// ==========================================================
+// Plugin Implementation
+// ==========================================================
+
+static const char * DLL_CALLCONV
+Format() {
+ return "PCD";
+}
+
+static const char * DLL_CALLCONV
+Description() {
+ return "Kodak PhotoCD";
+}
+
+static const char * DLL_CALLCONV
+Extension() {
+ return "pcd";
+}
+
+static const char * DLL_CALLCONV
+RegExpr() {
+ return NULL;
+}
+
+// ----------------------------------------------------------
+
+static FIBITMAP * DLL_CALLCONV
+Load(FreeImage &freeimage, FreeImageIO &io, fi_handle handle, int page, int flags, void *data) {
+ int width;
+ int height;
+ int line;
+ int pitch;
+ int bpp = 24;
+ int scan_line_add = 1;
+ int start_scan_line = 0;
+
+ // to make absolute seeks possible we store the current position in the file
+
+ long offset_in_file = io.tell_proc(handle);
+ long seek;
+
+ switch (flags) {
+ case PCD_BASEDIV4 :
+ seek = 0x2000;
+ width = 192;
+ height = 128;
+ line = CalculateLine(width, bpp);
+ pitch = CalculatePitch(line);
+ break;
+
+ case PCD_BASEDIV16 :
+ seek = 0xB800;
+ width = 384;
+ height = 256;
+ line = CalculateLine(width, bpp);
+ pitch = CalculatePitch(line);
+ break;
+
+ default :
+ seek = 0x30000;
+ width = 768;
+ height = 512;
+ line = CalculateLine(width, bpp);
+ pitch = CalculatePitch(line);
+ break;
+ }
+
+ // allocate the dib and write out the header
+
+ FIBITMAP *dib = freeimage.allocate_proc(width, height, bpp, 0xFF, 0xFF00, 0xFF0000);
+
+ // check if the PCD is bottom-up
+
+ if (VerticalOrientation(io, handle)) {
+ scan_line_add = -1;
+ start_scan_line = height - 1;
+ }
+
+ // temporary stuff to load PCD
+
+ BYTE *y1 = (BYTE *)malloc(width);
+ BYTE *y2 = (BYTE *)malloc(width);
+ BYTE *cbcr = (BYTE *)malloc(width);
+ BYTE *yl[] = { y1, y2 };
+
+ // seek to the part where the bitmap data begins
+
+ io.seek_proc(handle, offset_in_file, SEEK_SET);
+ io.seek_proc(handle, seek, SEEK_CUR);
+
+ // read the data
+
+ for (int y = 0; y < height / 2; ++y) {
+ io.read_proc(y1, width, 1, handle);
+ io.read_proc(y2, width, 1, handle);
+ io.read_proc(cbcr, width, 1, handle);
+
+ for (int i = 0; i < 2; ++i) {
+ for (int x = 0; x < width; ++x) {
+ int r, g, b;
+
+ YUV2RGB(yl[i][x], cbcr[x / 2], cbcr[(width / 2) + (x / 2)], r, g, b);
+
+ *(freeimage.get_scanline_proc(dib, start_scan_line) + (x * 3) + 0) = b;
+ *(freeimage.get_scanline_proc(dib, start_scan_line) + (x * 3) + 1) = g;
+ *(freeimage.get_scanline_proc(dib, start_scan_line) + (x * 3) + 2) = r;
+ }
+
+ start_scan_line += scan_line_add;
+ }
+ }
+
+ free(cbcr);
+ free(y2);
+ free(y1);
+
+ return dib;
+}
+
+// ==========================================================
+// Init
+// ==========================================================
+
+void DLL_CALLCONV
+InitPCD(Plugin &plugin, int format_id) {
+ s_format_id = format_id;
+
+ plugin.format_proc = Format;
+ plugin.description_proc = Description;
+ plugin.extension_proc = Extension;
+ plugin.regexpr_proc = RegExpr;
+ plugin.load_proc = Load;
+}
diff --git a/freeimage241/Source/FreeImage/PluginPCX.cpp b/freeimage241/Source/FreeImage/PluginPCX.cpp
new file mode 100644
index 0000000..1d65b73
--- /dev/null
+++ b/freeimage241/Source/FreeImage/PluginPCX.cpp
@@ -0,0 +1,398 @@
+// ==========================================================
+// PCX Loader
+//
+// Design and implementation by
+// - Floris van den Berg (flvdberg@wxs.nl)
+// - Jani Kajala (janik@remedy.fi)
+// - Markus Loibl (markus.loibl@epost.de)
+// - Hervé Drolon (drolon@infonie.fr)
+//
+// This file is part of FreeImage 2
+//
+// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
+// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
+// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
+// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
+// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
+// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
+// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+// THIS DISCLAIMER.
+//
+// Use at your own risk!
+// ==========================================================
+
+#include "FreeImage.h"
+#include "Utilities.h"
+
+// ----------------------------------------------------------
+// Constants + headers
+// ----------------------------------------------------------
+
+#ifdef WIN32
+#pragma pack(push, 1)
+#else
+#pragma pack(1)
+#endif
+
+typedef struct tagPCXHEADER {
+ BYTE manufacturer; // Magic number (0x0A = ZSoft Z)
+ BYTE version; // Version 0 == 2.5
+ // 2 == 2.8 with palette info
+ // 3 == 2.8 without palette info
+ // 5 == 3.0 with palette info
+ BYTE encoding; // Encoding: 0 = uncompressed, 1 = PCX rle compressed
+ BYTE bpp; // Bits per pixel per plane (only 1 or 8)
+ WORD window[4]; // left, upper, right,lower pixel coord.
+ WORD hdpi; // Horizontal resolution
+ WORD vdpi; // Vertical resolution
+ BYTE color_map[48]; // Colormap for 16-color images
+ BYTE reserved;
+ BYTE planes; // Number of planes (1, 3 or 4)
+ WORD bytes_per_line; // Bytes per row (always even)
+ WORD palette_info; // Palette information (1 = color or b&w; 2 = gray scale)
+ WORD h_screen_size;
+ WORD v_screen_size;
+ BYTE filler[54]; // Reserved filler
+} PCXHEADER;
+
+#ifdef WIN32
+#pragma pack(pop)
+#else
+#pragma pack(4)
+#endif
+
+// ==========================================================
+// Internal functions
+// ==========================================================
+
+static WORD
+readline(FreeImageIO &io, fi_handle handle, BYTE *buffer, WORD length, BOOL rle) {
+ // -----------------------------------------------------------//
+ // Read either run-length encoded or normal image data //
+ // //
+ // THIS IS HOW RUNTIME LENGTH ENCODING WORKS IN PCX: //
+ // //
+ // 1) If the upper 2 bits of a byte are set, //
+ // the lower 6 bits specify the count for the next byte //
+ // //
+ // 2) If the upper 2 bits of the byte are clear, //
+ // the byte is actual data with a count of 1 //
+ // //
+ // Note that a scanline always has an even number of bytes //
+ // -------------------------------------------------------------
+
+ BYTE count = 0, value = 0;
+ WORD written = 0;
+
+ if (rle) {
+ // run-length encoded read
+
+ while (length--) {
+ if (count == 0) {
+ io.read_proc(&value, 1, 1, handle);
+
+ if ((value & 0xC0) == 0xC0) {
+ count = value & 0x3F;
+ io.read_proc(&value, 1, 1, handle);
+ } else {
+ count = 1;
+ }
+ }
+
+ count--;
+
+ *(buffer + written++) = value;
+ }
+ } else {
+ // normal read
+
+ written = io.read_proc(buffer, length, 1, handle);
+ }
+
+ return written;
+}
+
+// ==========================================================
+// Plugin Interface
+// ==========================================================
+
+static int s_format_id;
+
+// ==========================================================
+// Plugin Implementation
+// ==========================================================
+
+static const char * DLL_CALLCONV
+Format() {
+ return "PCX";
+}
+
+static const char * DLL_CALLCONV
+Description() {
+ return "Zsoft Paintbrush";
+}
+
+static const char * DLL_CALLCONV
+Extension() {
+ return "pcx";
+}
+
+static const char * DLL_CALLCONV
+RegExpr() {
+ return NULL;
+}
+
+static BOOL DLL_CALLCONV
+Validate(FreeImageIO &io, fi_handle handle) {
+ BYTE pcx_signature = 0x0A;
+ BYTE signature = 0;
+
+ io.read_proc(&signature, 1, 1, handle);
+
+ return (pcx_signature == signature);
+}
+
+// ----------------------------------------------------------
+
+static FIBITMAP * DLL_CALLCONV
+Load(FreeImage &freeimage, FreeImageIO &io, fi_handle handle, int page, int flags, void *data) {
+ FIBITMAP *dib = NULL;
+ BYTE *bits; // Pointer to dib data
+ RGBQUAD *pal; // Pointer to dib palette
+ BYTE *line = NULL; // PCX raster line
+ WORD linelength; // Length of raster line in bytes
+ WORD pitch; // Length of DIB line in bytes
+ BOOL rle; // True if the file is run-length encoded
+
+ if (handle) {
+ try {
+ // process the header
+
+ PCXHEADER header;
+
+ io.read_proc(&header, sizeof(PCXHEADER), 1, handle);
+
+ // check PCX identifier
+
+ if ((header.manufacturer != 0x0A) || (header.version > 5))
+ throw "Invalid PCX file";
+
+ // allocate a new DIB
+
+ WORD width = header.window[2] - header.window[0] + 1;
+ WORD height = header.window[3] - header.window[1] + 1;
+ WORD bitcount = header.bpp * header.planes;
+
+ if (bitcount == 24)
+ dib = freeimage.allocate_proc(width, height, bitcount, 0xFF, 0xFF00, 0xFF0000);
+ else
+ dib = freeimage.allocate_proc(width, height, bitcount);
+
+ // if the dib couldn't be allocated, throw an error
+
+ if (!dib)
+ throw "DIB allocation failed";
+
+ // metrics handling code
+
+ BITMAPINFOHEADER *pInfoHeader = freeimage.get_info_header_proc(dib);
+ pInfoHeader->biXPelsPerMeter = (int) (((float)header.hdpi) / 0.0254000 + 0.5);
+ pInfoHeader->biYPelsPerMeter = (int) (((float)header.vdpi) / 0.0254000 + 0.5);
+
+ // Set up the palette if needed
+ // ----------------------------
+
+ switch(bitcount) {
+ case 1:
+ {
+ pal = freeimage.get_palette_proc(dib);
+ pal[0].rgbRed = pal[0].rgbGreen = pal[0].rgbBlue = 0;
+ pal[1].rgbRed = pal[1].rgbGreen = pal[1].rgbBlue = 255;
+ break;
+ }
+
+ case 4:
+ {
+ pal = freeimage.get_palette_proc(dib);
+
+ BYTE *pColormap = &header.color_map[0];
+
+ for(int i = 0; i < 16; i++) {
+ pal[i].rgbRed = pColormap[0];
+ pal[i].rgbGreen = pColormap[1];
+ pal[i].rgbBlue = pColormap[2];
+ pColormap += 3;
+ }
+
+ break;
+ }
+
+ case 8:
+ {
+ BYTE palette_id;
+
+ io.seek_proc(handle, -769L, SEEK_END);
+ io.read_proc(&palette_id, 1, 1, handle);
+
+ if (palette_id == 0x0C) {
+ BYTE *cmap = (BYTE*)malloc(768 * sizeof(BYTE));
+ io.read_proc(cmap, 768, 1, handle);
+
+ pal = freeimage.get_palette_proc(dib);
+ BYTE *pColormap = &cmap[0];
+
+ for(int i = 0; i < 256; i++) {
+ pal[i].rgbRed = pColormap[0];
+ pal[i].rgbGreen = pColormap[1];
+ pal[i].rgbBlue = pColormap[2];
+ pColormap += 3;
+ }
+
+ free(cmap);
+ }
+
+ // wrong palette ID, perhaps a gray scale is needed ?
+
+ else if (header.palette_info == 2) {
+ pal = freeimage.get_palette_proc(dib);
+
+ for(int i = 0; i < 256; i++) {
+ pal[i].rgbRed = i;
+ pal[i].rgbGreen = i;
+ pal[i].rgbBlue = i;
+ }
+ }
+
+ io.seek_proc(handle, (long)sizeof(PCXHEADER), SEEK_SET);
+ }
+ break;
+ }
+
+ // calculate the line length for the PCX and the DIB
+
+ linelength = header.bytes_per_line * header.planes;
+ pitch = freeimage.get_pitch_proc(dib);
+
+ // run-length encoding ?
+
+ rle = (header.encoding == 1) ? TRUE : FALSE;
+
+ // load image data
+ // ---------------
+
+ line = (BYTE*) malloc(linelength * sizeof(BYTE));
+ bits = freeimage.get_scanline_proc(dib, height - 1);
+
+ if ((header.planes == 1) && ((header.bpp == 1) || (header.bpp == 8))) {
+ BYTE skip;
+ WORD written;
+
+ for (WORD y = 0; y < height; y++) {
+ written = readline(io, handle, line, linelength, rle);
+ memcpy(bits, line, linelength);
+
+ // skip trailing garbage at the end of the scanline
+
+ for (int count = written; count < linelength; count++)
+ io.read_proc(&skip, sizeof(BYTE), 1, handle);
+
+ bits -= pitch;
+ }
+ }
+ else if ((header.planes == 4) && (header.bpp == 1)) {
+ BYTE bit, index, mask, skip;
+ BYTE *buffer;
+ WORD x, y, written;
+ buffer = (BYTE*)malloc(width * sizeof(BYTE));
+
+ for (y = 0; y < height; y++) {
+ written = readline(io, handle, line, linelength, rle);
+
+ // build a nibble using the 4 planes
+
+ memset(buffer, 0, width * sizeof(BYTE));
+
+ for(int plane = 0; plane < 4; plane++) {
+ bit = 1 << plane;
+
+ for(x = 0; x < width; x++) {
+ index = (x / 8) + plane * header.bytes_per_line;
+ mask = 0x80 >> (x & 0x07);
+ buffer[x] |= (line[index] & mask) ? bit : 0;
+ }
+ }
+
+ // then write the DIB row
+
+ for (x = 0; x < width / 2; x++)
+ bits[x] = (buffer[2*x] << 4) | buffer[2*x+1];
+
+ // skip trailing garbage at the end of the scanline
+
+ for (int count = written; count < linelength; count++)
+ io.read_proc(&skip, sizeof(BYTE), 1, handle);
+
+ bits -= pitch;
+ }
+
+ free(buffer);
+ } else if((header.planes == 3) && (header.bpp == 8)) {
+ BYTE *pline;
+
+ for (WORD y = 0; y < height; y++) {
+ readline(io, handle, line, linelength, rle);
+
+ // convert the plane stream to BGR (RRRRGGGGBBBB -> BGRBGRBGRBGR)
+
+ pline = line;
+
+ for (int plane = 2; plane >= 0; plane--) {
+ for (WORD x = 0; x < width; x++)
+ bits[x * 3 + plane] = pline[x];
+
+ pline += header.bytes_per_line;
+ }
+
+ bits -= pitch;
+ }
+ } else {
+ throw "Unable to read this file";
+ }
+
+ free(line);
+ return dib;
+
+ } catch (char *text) {
+ // free allocated memory
+
+ if (dib != NULL)
+ freeimage.free_proc(dib);
+
+ if (line != NULL)
+ free(line);
+
+ freeimage.output_message_proc(s_format_id, text);
+
+ return NULL;
+ }
+ }
+
+ return NULL;
+}
+
+// ==========================================================
+// Init
+// ==========================================================
+
+void DLL_CALLCONV
+InitPCX(Plugin &plugin, int format_id) {
+ s_format_id = format_id;
+
+ plugin.format_proc = Format;
+ plugin.description_proc = Description;
+ plugin.extension_proc = Extension;
+ plugin.validate_proc = Validate;
+ plugin.regexpr_proc = RegExpr;
+ plugin.load_proc = Load;
+}
diff --git a/freeimage241/Source/FreeImage/PluginPNG.cpp b/freeimage241/Source/FreeImage/PluginPNG.cpp
new file mode 100644
index 0000000..d42fbc8
--- /dev/null
+++ b/freeimage241/Source/FreeImage/PluginPNG.cpp
@@ -0,0 +1,610 @@
+// ==========================================================
+// PNG Loader and Writer
+//
+// Design and implementation by
+// - Floris van den Berg (flvdberg@wxs.nl)
+// - Herve Drolon (drolon@infonie.fr)
+//
+// This file is part of FreeImage 2
+//
+// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
+// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
+// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
+// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
+// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
+// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
+// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+// THIS DISCLAIMER.
+//
+// Use at your own risk!
+// ==========================================================
+
+#include "FreeImage.h"
+#include "Utilities.h"
+
+#include
+#include
+
+// ----------------------------------------------------------
+
+#define PNG_ASSEMBLER_CODE_SUPPORTED
+#define PNG_BYTES_TO_CHECK 8
+
+// ----------------------------------------------------------
+
+#include "../LibPNG/png.h"
+
+// ----------------------------------------------------------
+
+static FreeImageIO *s_io;
+static fi_handle s_handle;
+
+/////////////////////////////////////////////////////////////////////////////
+// libpng interface
+//
+
+static void
+_ReadProc(struct png_struct_def *, unsigned char *data, unsigned int size) {
+ s_io->read_proc(data, size, 1, s_handle);
+}
+
+static void
+_WriteProc(struct png_struct_def *, unsigned char *data, unsigned int size) {
+ s_io->write_proc(data, size, 1, s_handle);
+}
+
+static void
+_FlushProc(png_structp png_ptr) {
+ // empty flush implementation
+}
+
+static void
+error_handler(struct png_struct_def *, const char *error) {
+ throw error;
+}
+
+// in FreeImage warnings disabled
+
+static void
+warning_handler(struct png_struct_def *, const char *warning) {
+}
+
+// ==========================================================
+// Plugin Interface
+// ==========================================================
+
+static int s_format_id;
+
+// ==========================================================
+// Plugin Implementation
+// ==========================================================
+
+static const char * DLL_CALLCONV
+Format() {
+ return "PNG";
+}
+
+static const char * DLL_CALLCONV
+Description() {
+ return "Portable Network Graphics";
+}
+
+static const char * DLL_CALLCONV
+Extension() {
+ return "png";
+}
+
+static const char * DLL_CALLCONV
+RegExpr() {
+ return "^.PNG\r";
+}
+
+static const char * DLL_CALLCONV
+MimeType() {
+ return "image/png";
+}
+
+static BOOL DLL_CALLCONV
+Validate(FreeImageIO &io, fi_handle handle) {
+ BYTE png_signature[8] = { 137, 80, 78, 71, 13, 10, 26, 10 };
+ BYTE signature[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
+
+ io.read_proc(&signature, 1, 8, handle);
+
+ return (memcmp(png_signature, signature, 8) == 0);
+}
+
+// ----------------------------------------------------------
+
+static FIBITMAP * DLL_CALLCONV
+Load(FreeImage &freeimage, FreeImageIO &io, fi_handle handle, int page, int flags, void *data) {
+ png_structp png_ptr;
+ png_infop info_ptr;
+ png_uint_32 width, height;
+ png_colorp png_palette;
+ int bpp, color_type, palette_entries;
+
+ FIBITMAP *dib = NULL;
+ RGBQUAD *palette; // pointer to dib palette
+ png_bytepp row_pointers = NULL;
+ int i;
+
+ s_io = &io;
+ s_handle = handle;
+
+ if (handle) {
+ try {
+ // check to see if the file is in fact a PNG file
+
+ unsigned char png_check[PNG_BYTES_TO_CHECK];
+
+ io.read_proc(png_check, 1, PNG_BYTES_TO_CHECK, handle);
+
+ if (png_sig_cmp(png_check, (png_size_t)0, PNG_BYTES_TO_CHECK) != 0)
+ return NULL; // Bad signature
+
+ // create the chunk manage structure
+
+ png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, (png_voidp)error_handler, error_handler, warning_handler);
+
+ if (!png_ptr)
+ return NULL;
+
+ // create the info structure
+
+ info_ptr = png_create_info_struct(png_ptr);
+
+ if (!info_ptr) {
+ png_destroy_read_struct(&png_ptr, (png_infopp)NULL, (png_infopp)NULL);
+ return NULL;
+ }
+
+ // init the IO
+
+ png_set_read_fn(png_ptr, info_ptr, _ReadProc);
+
+ if (setjmp(png_jmpbuf(png_ptr))) {
+ png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+ return NULL;
+ }
+
+ // Because we have already read the signature...
+
+ png_set_sig_bytes(png_ptr, PNG_BYTES_TO_CHECK);
+
+ // read the IHDR chunk
+
+ png_read_info(png_ptr, info_ptr);
+ png_get_IHDR(png_ptr, info_ptr, &width, &height, &bpp, &color_type, NULL, NULL, NULL);
+
+ // DIB's don't support >8 bits per sample
+ // => tell libpng to strip 16 bit/color files down to 8 bits/color
+
+ if (bpp == 16) {
+ png_set_strip_16(png_ptr);
+ bpp = 8;
+ }
+
+ // Set some additional flags
+
+ switch(color_type) {
+ case PNG_COLOR_TYPE_RGB:
+ case PNG_COLOR_TYPE_RGB_ALPHA:
+ // Flip the RGB pixels to BGR (or RGBA to BGRA)
+
+ png_set_bgr(png_ptr);
+ break;
+
+ case PNG_COLOR_TYPE_PALETTE:
+ // Expand palette images to the full 8 bits from 2 or 4 bits/pixel
+
+ if ((bpp == 2) || (bpp == 4)) {
+ png_set_packing(png_ptr);
+ bpp = 8;
+ }
+
+ break;
+
+ case PNG_COLOR_TYPE_GRAY:
+ case PNG_COLOR_TYPE_GRAY_ALPHA:
+ // Expand grayscale images to the full 8 bits from 2 or 4 bits/pixel
+
+ if ((bpp == 2) || (bpp == 4)) {
+ png_set_expand(png_ptr);
+ bpp = 8;
+ }
+
+ break;
+
+ default:
+ throw "PNG format not supported";
+ }
+
+ // Set the background color to draw transparent and alpha images over.
+ // It is possible to set the red, green, and blue components directly
+ // for paletted images instead of supplying a palette index. Note that
+ // even if the PNG file supplies a background, you are not required to
+ // use it - you should use the (solid) application background if it has one.
+
+ if (color_type != PNG_COLOR_TYPE_RGB_ALPHA) {
+ png_color_16 my_background= { 0, 255, 255, 255, 0 };
+ png_color_16 *image_background;
+
+ if (png_get_bKGD(png_ptr, info_ptr, &image_background))
+ png_set_background(png_ptr, image_background, PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
+ else
+ png_set_background(png_ptr, &my_background, PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
+ }
+
+ // if this image has transparency, store the trns values
+
+ png_bytep trans = NULL;
+ int num_trans = 0;
+ png_color_16p trans_values = NULL;
+ png_uint_32 transparent_value = png_get_tRNS(png_ptr, info_ptr, &trans, &num_trans, &trans_values);
+
+ // unlike the example in the libpng documentation, we have *no* idea where
+ // this file may have come from--so if it doesn't have a file gamma, don't
+ // do any correction ("do no harm")
+
+ double gamma = 0;
+ double screen_gamma = 2.2;
+
+ if (png_get_gAMA(png_ptr, info_ptr, &gamma))
+ png_set_gamma(png_ptr, screen_gamma, gamma);
+
+ // All transformations have been registered; now update info_ptr data
+
+ png_read_update_info(png_ptr, info_ptr);
+
+ // Create a DIB and write the bitmap header
+ // set up the DIB palette, if needed
+
+ switch (color_type) {
+ case PNG_COLOR_TYPE_RGB:
+ png_set_invert_alpha(png_ptr);
+
+ dib = freeimage.allocate_proc(width, height, 24, 0xFF, 0xFF00, 0xFF0000);
+ break;
+
+ case PNG_COLOR_TYPE_RGB_ALPHA :
+ dib = freeimage.allocate_proc(width, height, 32, 0xFF, 0xFF00, 0xFF0000);
+ break;
+
+ case PNG_COLOR_TYPE_PALETTE :
+ dib = freeimage.allocate_proc(width, height, bpp);
+
+ png_get_PLTE(png_ptr,info_ptr, &png_palette,&palette_entries);
+
+ palette = freeimage.get_palette_proc(dib);
+
+ // store the palette
+
+ for (i = 0; i < palette_entries; i++) {
+ palette[i].rgbRed = png_palette[i].red;
+ palette[i].rgbGreen = png_palette[i].green;
+ palette[i].rgbBlue = png_palette[i].blue;
+ }
+
+ // store the transparency table
+
+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
+ freeimage.set_transparency_table_proc(dib, (BYTE *)trans, num_trans);
+
+ break;
+
+ case PNG_COLOR_TYPE_GRAY:
+ case PNG_COLOR_TYPE_GRAY_ALPHA:
+ dib = freeimage.allocate_proc(width, height, bpp);
+
+ palette = freeimage.get_palette_proc(dib);
+ palette_entries = 1 << bpp;
+
+ for (i = 0; i < palette_entries; i++) {
+ palette[i].rgbRed =
+ palette[i].rgbGreen =
+ palette[i].rgbBlue = (i * 255) / (palette_entries - 1);
+ }
+
+ // store the transparency table
+
+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
+ freeimage.set_transparency_table_proc(dib, (BYTE *)trans, num_trans);
+
+ break;
+ }
+
+ // DIBs *do* support physical resolution
+
+ if (png_get_valid(png_ptr,info_ptr,PNG_INFO_pHYs)) {
+ png_uint_32 res_x, res_y;
+
+ // We'll overload this var and use 0 to mean no phys data,
+ // since if it's not in meters we can't use it anyway
+
+ int res_unit_type = 0;
+
+ png_get_pHYs(png_ptr,info_ptr,&res_x,&res_y,&res_unit_type);
+
+ if (res_unit_type == 1) {
+ BITMAPINFOHEADER *bih = freeimage.get_info_header_proc(dib);
+
+ bih->biXPelsPerMeter = res_x;
+ bih->biYPelsPerMeter = res_y;
+ }
+ }
+
+ // set the individual row_pointers to point at the correct offsets
+
+ row_pointers = (png_bytepp)malloc(height * sizeof(png_bytep));
+
+ if (!row_pointers) {
+ if (palette)
+ png_free(png_ptr, palette);
+
+ png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+
+ freeimage.free_proc(dib);
+ free(row_pointers);
+ return NULL;
+ }
+
+ // read in the bitmap bits via the pointer table
+
+ for (png_uint_32 k = 0; k < height; k++)
+ row_pointers[height - 1 - k] = freeimage.get_scanline_proc(dib, k);
+
+ png_read_image(png_ptr, row_pointers);
+
+ // check if the bitmap contains transparency, if so enable it in the header
+
+ if (freeimage.get_bpp_proc(dib) == 32)
+ if (freeimage.get_color_type_proc(dib) == FIC_RGBALPHA)
+ freeimage.set_transparent_proc(dib, TRUE);
+ else
+ freeimage.set_transparent_proc(dib, FALSE);
+
+ // cleanup
+
+ if (row_pointers)
+ free(row_pointers);
+
+ png_read_end(png_ptr, info_ptr);
+
+ if (png_ptr)
+ png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
+
+ return dib;
+ } catch (const char *text) {
+ if (png_ptr)
+ png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
+
+ if (row_pointers)
+ free(row_pointers);
+
+ if (dib)
+ freeimage.free_proc(dib);
+
+ freeimage.output_message_proc(s_format_id, text);
+
+ return NULL;
+ }
+ }
+
+ return NULL;
+}
+
+static BOOL DLL_CALLCONV
+Save(FreeImage &freeimage, FreeImageIO &io, FIBITMAP *dib, fi_handle handle, int page, int flags, void *data) {
+ png_structp png_ptr;
+ png_infop info_ptr;
+ png_colorp palette = NULL;
+ png_uint_32 width, height, bpp;
+ BOOL has_alpha_channel = FALSE;
+
+ RGBQUAD *pal; // pointer to dib palette
+ int bit_depth;
+ int palette_entries;
+ int interlace_type;
+
+ s_io = &io;
+ s_handle = handle;
+
+ if ((dib) && (handle)) {
+ try {
+ // create the chunk manage structure
+
+ png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, (png_voidp)error_handler, error_handler, warning_handler);
+
+ if (!png_ptr) {
+ return FALSE;
+ }
+
+ // Allocate/initialize the image information data.
+
+ info_ptr = png_create_info_struct(png_ptr);
+
+ if (!info_ptr) {
+ png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
+ return FALSE;
+ }
+
+ // Set error handling. REQUIRED if you aren't supplying your own
+ // error handling functions in the png_create_write_struct() call.
+
+ if (setjmp(png_jmpbuf(png_ptr))) {
+ // If we get here, we had a problem reading the file
+
+ png_destroy_write_struct(&png_ptr, &info_ptr);
+
+ return FALSE;
+ }
+
+ // init the IO
+
+ png_set_write_fn(png_ptr, info_ptr, _WriteProc, _FlushProc);
+
+ // DIBs *do* support physical resolution
+
+ BITMAPINFOHEADER *bih = freeimage.get_info_header_proc(dib);
+ png_uint_32 res_x = bih->biXPelsPerMeter;
+ png_uint_32 res_y = bih->biYPelsPerMeter;
+
+ if ((res_x > 0) && (res_y > 0)) {
+ png_set_pHYs(png_ptr, info_ptr, res_x, res_y, 1);
+ }
+
+ // Set the image information here. Width and height are up to 2^31,
+ // bit_depth is one of 1, 2, 4, 8, or 16, but valid values also depend on
+ // the color_type selected. color_type is one of PNG_COLOR_TYPE_GRAY,
+ // PNG_COLOR_TYPE_GRAY_ALPHA, PNG_COLOR_TYPE_PALETTE, PNG_COLOR_TYPE_RGB,
+ // or PNG_COLOR_TYPE_RGB_ALPHA. interlace is either PNG_INTERLACE_NONE or
+ // PNG_INTERLACE_ADAM7, and the compression_type and filter_type MUST
+ // currently be PNG_COMPRESSION_TYPE_BASE and PNG_FILTER_TYPE_BASE. REQUIRED
+
+ width = freeimage.get_width_proc(dib);
+ height = freeimage.get_height_proc(dib);
+ bpp = bit_depth = freeimage.get_bpp_proc(dib);
+
+ if (bit_depth == 16) {
+ png_destroy_write_struct(&png_ptr, &info_ptr);
+
+ throw "Format not supported"; // Note: this could be enhanced here...
+ }
+
+ bit_depth = (bit_depth > 8) ? 8 : bit_depth;
+
+ interlace_type = PNG_INTERLACE_NONE; // Default value
+
+ switch (freeimage.get_color_type_proc(dib)) {
+ case FIC_MINISWHITE:
+ // Invert monochrome files to have 0 as black and 1 as white
+ // (no break here)
+ png_set_invert_mono(png_ptr);
+
+ case FIC_MINISBLACK:
+ png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth,
+ PNG_COLOR_TYPE_GRAY, interlace_type,
+ PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
+ break;
+
+ case FIC_PALETTE:
+ {
+ png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth,
+ PNG_COLOR_TYPE_PALETTE, interlace_type,
+ PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
+
+ // set the palette
+
+ palette_entries = 1 << bit_depth;
+ palette = (png_colorp)png_malloc(png_ptr, palette_entries * sizeof (png_color));
+ pal = freeimage.get_palette_proc(dib);
+
+ for (int i = 0; i < palette_entries; i++) {
+ palette[i].red = pal[i].rgbRed;
+ palette[i].green = pal[i].rgbGreen;
+ palette[i].blue = pal[i].rgbBlue;
+ }
+
+ png_set_PLTE(png_ptr, info_ptr, palette, palette_entries);
+
+ // You must not free palette here, because png_set_PLTE only makes a link to
+ // the palette that you malloced. Wait until you are about to destroy
+ // the png structure.
+
+ break;
+ }
+
+ case FIC_RGBALPHA :
+ if (freeimage.is_transparent_proc(dib)) {
+ has_alpha_channel = TRUE;
+
+ png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth,
+ PNG_COLOR_TYPE_RGBA, interlace_type,
+ PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
+
+ png_set_bgr(png_ptr); // flip BGR pixels to RGB
+ break;
+ }
+
+ // intentionally no break here...
+
+ case FIC_RGB:
+ png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth,
+ PNG_COLOR_TYPE_RGB, interlace_type,
+ PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
+
+ png_set_bgr(png_ptr); // flip BGR pixels to RGB
+ break;
+ }
+
+ // Optional gamma chunk is strongly suggested if you have any guess
+ // as to the correct gamma of the image.
+ // png_set_gAMA(png_ptr, info_ptr, gamma);
+
+ if ((freeimage.get_bpp_proc(dib) == 8) && (freeimage.is_transparent_proc(dib)) && (freeimage.get_transparency_count_proc(dib) > 0))
+ png_set_tRNS(png_ptr, info_ptr, freeimage.get_transparency_table_proc(dib), freeimage.get_transparency_count_proc(dib), NULL);
+
+ // Write the file header information.
+
+ png_write_info(png_ptr, info_ptr);
+
+ // write out the image data
+
+ if ((bpp == 32) && (!has_alpha_channel)) {
+ BYTE *buffer = (BYTE *)malloc(width * 3);
+
+ for (png_uint_32 k = 0; k < height; k++) {
+ freeimage.convert_line_32to24_proc(buffer, freeimage.get_scanline_proc(dib, height - k - 1), width);
+
+ png_write_row(png_ptr, buffer);
+ }
+
+ free(buffer);
+ } else {
+ for (png_uint_32 k = 0; k < height; k++) {
+ png_write_row(png_ptr, freeimage.get_scanline_proc(dib, height - k - 1));
+ }
+ }
+
+ // It is REQUIRED to call this to finish writing the rest of the file
+ // Bug with png_flush
+
+ png_write_end(png_ptr, info_ptr);
+
+ // clean up after the write, and free any memory allocated
+
+ png_destroy_write_struct(&png_ptr, &info_ptr);
+
+ if (palette)
+ png_free(png_ptr, palette);
+
+ return TRUE;
+ } catch (const char *text) {
+ freeimage.output_message_proc(s_format_id, text);
+ }
+ }
+
+ return FALSE;
+}
+
+// ==========================================================
+// Init
+// ==========================================================
+
+void DLL_CALLCONV
+InitPNG(Plugin &plugin, int format_id) {
+ s_format_id = format_id;
+
+ plugin.format_proc = Format;
+ plugin.description_proc = Description;
+ plugin.extension_proc = Extension;
+ plugin.regexpr_proc = RegExpr;
+ plugin.pagecount_proc = NULL;
+ plugin.pagecapability_proc = NULL;
+ plugin.load_proc = Load;
+ plugin.save_proc = 0; //Save;
+ plugin.validate_proc = Validate;
+ plugin.mime_proc = MimeType;
+}
diff --git a/freeimage241/Source/FreeImage/PluginPNM.cpp b/freeimage241/Source/FreeImage/PluginPNM.cpp
new file mode 100644
index 0000000..87e02af
--- /dev/null
+++ b/freeimage241/Source/FreeImage/PluginPNM.cpp
@@ -0,0 +1,599 @@
+// ==========================================================
+// PNM (PPM, PGM, PBM) Loader and Writer
+//
+// Design and implementation by
+// - Floris van den Berg (flvdberg@wxs.nl)
+// - Hervé Drolon (drolon@infonie.fr)
+//
+// This file is part of FreeImage 2
+//
+// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
+// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
+// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
+// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
+// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
+// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
+// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+// THIS DISCLAIMER.
+//
+// Use at your own risk!
+// ==========================================================
+
+#include // for sprintf()
+#include
+
+#include "FreeImage.h"
+#include "Utilities.h"
+
+// ==========================================================
+// Internal functions
+// ==========================================================
+
+static int
+GetInt(FreeImageIO &io, fi_handle handle) {
+ // get an integer value from the actual position pointed by handle
+
+ char c = 0;
+ BOOL firstchar;
+
+ // skip forward to start of next number
+
+ io.read_proc(&c, 1, 1, handle);
+
+ while (1) {
+ // eat comments
+
+ if (c == '#') {
+ // if we're at a comment, read to end of line
+
+ firstchar = TRUE;
+
+ while (1) {
+ io.read_proc(&c, 1, 1, handle);
+
+ if (firstchar && c == ' ') {
+ // loop off 1 sp after #
+
+ firstchar = FALSE;
+ } else if(c == '\n') {
+ break;
+ }
+ }
+ }
+
+ if (c >= '0' && c <='9') {
+ // we've found what we were looking for
+
+ break;
+ }
+
+ io.read_proc(&c, 1, 1, handle);
+ }
+
+ // we're at the start of a number, continue until we hit a non-number
+
+ int i = 0;
+
+ while (1) {
+ i = (i*10) + (c - '0');
+
+ io.read_proc(&c, 1, 1, handle);
+
+ if (c < '0' || c > '9')
+ break;
+ }
+
+ return i;
+}
+
+// ==========================================================
+// Plugin Interface
+// ==========================================================
+
+static int s_format_id;
+
+// ==========================================================
+// Plugin Implementation
+// ==========================================================
+
+static const char * DLL_CALLCONV
+Format() {
+ return "PNM";
+}
+
+static const char * DLL_CALLCONV
+Description() {
+ return "Portable Network Media";
+}
+
+static const char * DLL_CALLCONV
+Extension() {
+ return "pbm,pgm,ppm";
+}
+
+static const char * DLL_CALLCONV
+RegExpr() {
+ return NULL;
+}
+
+static BOOL DLL_CALLCONV
+Validate(FreeImageIO &io, fi_handle handle) {
+ BYTE pbm_id1[] = { 0x50, 0x31 };
+ BYTE pbm_id2[] = { 0x50, 0x34 };
+ BYTE pgm_id1[] = { 0x50, 0x32 };
+ BYTE pgm_id2[] = { 0x50, 0x35 };
+ BYTE ppm_id1[] = { 0x50, 0x33 };
+ BYTE ppm_id2[] = { 0x50, 0x36 };
+ BYTE signature[2] = { 0, 0 };
+
+ io.read_proc(signature, 1, sizeof(pbm_id1), handle);
+
+ if (memcmp(pbm_id1, signature, sizeof(pbm_id1)) == 0)
+ return TRUE;
+
+ if (memcmp(pbm_id1, signature, sizeof(pbm_id2)) == 0)
+ return TRUE;
+
+ if (memcmp(pbm_id1, signature, sizeof(pgm_id1)) == 0)
+ return TRUE;
+
+ if (memcmp(pbm_id1, signature, sizeof(pgm_id2)) == 0)
+ return TRUE;
+
+ if (memcmp(pbm_id1, signature, sizeof(ppm_id1)) == 0)
+ return TRUE;
+
+ if (memcmp(pbm_id1, signature, sizeof(ppm_id2)) == 0)
+ return TRUE;
+
+ return FALSE;
+}
+
+// ----------------------------------------------------------
+
+static FIBITMAP * DLL_CALLCONV
+Load(FreeImage &freeimage, FreeImageIO &io, fi_handle handle, int page, int flags, void *data) {
+ char id_one, id_two;
+ WORD x, y;
+ FIBITMAP *dib;
+ BYTE *bits; // pointer to dib data
+ RGBQUAD *pal; // pointer to dib palette
+ int i, max, level;
+
+ if (!handle)
+ return NULL;
+
+ try {
+ // Read the first two bytes of the file to determine the file format
+ // "P1" = ascii bitmap, "P2" = ascii greymap, "P3" = ascii pixmap,
+ // "P4" = raw bitmap, "P5" = raw greymap, "P6" = raw pixmap
+
+ io.read_proc(&id_one, 1, 1, handle);
+ io.read_proc(&id_two, 1, 1, handle);
+
+ if (id_one != 'P' || id_two < '1' || id_two > '6') {
+ throw "Invalid magic number";
+ }
+
+ // Read the header information
+
+ int width = GetInt(io, handle);
+ int height = GetInt(io, handle);
+
+ // Create a new DIB
+
+ switch (id_two) {
+ case '1':
+ case '4':
+ dib = freeimage.allocate_proc(width, height, 1);
+ break;
+
+ case '2':
+ case '5':
+ dib = freeimage.allocate_proc(width, height, 8);
+ break;
+
+ case '3':
+ case '6':
+ dib = freeimage.allocate_proc(width, height, 24, 0xFF, 0xFF00, 0xFF0000);
+ break;
+ }
+
+ if (dib == NULL)
+ throw "DIB allocation failed";
+
+ // Read the image...
+
+ int pitch = freeimage.get_pitch_proc(dib);
+
+ switch(id_two) {
+ case '1':
+ case '4':
+ // write the palette data
+
+ pal = freeimage.get_palette_proc(dib);
+ pal[0].rgbRed = pal[0].rgbGreen = pal[0].rgbBlue = 0;
+ pal[1].rgbRed = pal[1].rgbGreen = pal[1].rgbBlue = 255;
+
+ // write the bitmap data
+
+ if (id_two == '1') { // ASCII bitmap
+ for (y = 0; y < height; y++) {
+ bits = freeimage.get_bits_proc(dib) + (height - 1 - y) * pitch;
+
+ for (x = 0; x < width; x++) {
+ if (GetInt(io, handle) == 0)
+ bits[x >> 3] |= (0x80 >> (x & 0x7));
+ else
+ bits[x >> 3] &= (0xFF7F >> (x & 0x7));
+ }
+ }
+ } else { // Raw bitmap
+ int line = CalculateLine(width, 1);
+
+ for (y = 0; y < height; y++) {
+ bits = freeimage.get_bits_proc(dib) + (height - 1 - y) * pitch;
+
+ for (x = 0; x < line; x++) {
+ io.read_proc(&bits[x], 1, 1, handle);
+
+ bits[x] = ~bits[x];
+ }
+ }
+ }
+
+ return dib;
+
+ case '2':
+ case '5':
+ // Build a greyscale palette
+
+ pal = freeimage.get_palette_proc(dib);
+
+ for (i = 0; i < 256; i++) {
+ pal[i].rgbRed =
+ pal[i].rgbGreen =
+ pal[i].rgbBlue = i;
+ }
+
+ max = GetInt(io, handle); // read the 'max' value
+
+ // write the bitmap data
+
+ if(id_two == '2') { // ASCII greymap
+ for (y = 0; y < height; y++) {
+ bits = freeimage.get_bits_proc(dib) + (height - 1 - y) * pitch;
+ for (x = 0; x < width; x++) {
+ level = GetInt(io, handle);
+ bits[x] = (BYTE)((255 * level) / max);
+ }
+ }
+ } else { // Raw greymap
+ level = 0;
+
+ for (y = 0; y < height; y++) {
+ bits = freeimage.get_bits_proc(dib) + (height - 1 - y) * pitch;
+
+ for (x = 0; x < width; x++) {
+ io.read_proc(&level, 1, 1, handle);
+ bits[x] = (BYTE)((255 * level) / max);
+ }
+ }
+ }
+
+ return dib;
+
+ case '3':
+ case '6':
+ max = GetInt(io, handle); // read the 'max' value
+
+ // write the bitmap data
+
+ if (id_two == '3') { // ASCII pixmap
+ for (y = 0; y < height; y++) {
+ bits = freeimage.get_bits_proc(dib) + (height - 1 - y) * pitch;
+
+ for (x = 0; x < width; x++) {
+ bits[2] = (BYTE)((255 * GetInt(io, handle)) / max); // R
+ bits[1] = (BYTE)((255 * GetInt(io, handle)) / max); // G
+ bits[0] = (BYTE)((255 * GetInt(io, handle)) / max); // B
+
+ bits += 3;
+ }
+ }
+ } else { // Raw pixmap
+ level = 0;
+
+ for (y = 0; y < height; y++) {
+ bits = freeimage.get_bits_proc(dib) + (height - 1 - y) * pitch;
+
+ for (x = 0; x < width; x++) {
+ io.read_proc(&level, 1, 1, handle);
+ bits[2] = (BYTE)((255 * level) / max); // R
+
+ io.read_proc(&level, 1, 1, handle);
+ bits[1] = (BYTE)((255 * level) / max); // G
+
+ io.read_proc(&level, 1, 1, handle);
+ bits[0] = (BYTE)((255 * level) / max); // B
+
+ bits += 3;
+ }
+ }
+ }
+
+ return dib;
+ }
+
+ } catch(char *text) {
+ switch(id_two) {
+ case '1':
+ case '4':
+ freeimage.output_message_proc(s_format_id, text);
+ break;
+ case '2':
+ case '5':
+ freeimage.output_message_proc(s_format_id, text);
+ break;
+ case '3':
+ case '6':
+ freeimage.output_message_proc(s_format_id, text);
+ break;
+ }
+
+ return NULL;
+ }
+
+ return NULL;
+}
+
+static BOOL DLL_CALLCONV
+Save(FreeImage &freeimage, FreeImageIO &io, FIBITMAP *dib, fi_handle handle, int page, int flags, void *data) {
+ // ----------------------------------------------------------
+ // PNM Saving
+ // ----------------------------------------------------------
+ //
+ // Output format :
+ //
+ // Bit depth flags file format
+ // ------------- -------------- -----------
+ // 1-bit / pixel PNM_SAVE_ASCII PBM (P1)
+ // 1-bit / pixel PNM_SAVE_RAW PBM (P4)
+ // 8-bit / pixel PNM_SAVE_ASCII PGM (P2)
+ // 8-bit / pixel PNM_SAVE_RAW PGM (P5)
+ // 24-bit / pixel PNM_SAVE_ASCII PPM (P3)
+ // 24-bit / pixel PNM_SAVE_RAW PPM (P6)
+ // ----------------------------------------------------------
+
+ int magic, bpp;
+ WORD x, y, width, height;
+ BYTE *bits; // pointer to dib data
+
+ if ((dib) && (handle)) {
+ bpp = freeimage.get_bpp_proc(dib);
+ width = freeimage.get_width_proc(dib);
+ height = freeimage.get_height_proc(dib);
+
+ // Find the appropriate magic number for this file type
+
+ magic = 0;
+
+ switch (bpp) {
+ case 1 :
+ magic = 1; // PBM file (B & W)
+ break;
+ case 8 :
+ magic = 2; // PGM file (Greyscale)
+ break;
+
+ case 24 :
+ magic = 3; // PPM file (RGB)
+ break;
+
+ case 32 :
+ if (!freeimage.is_transparent_proc(dib))
+ magic = 3;
+ else
+ throw "PNM does not support alpha channels";
+
+ break;
+
+ default:
+ return FALSE; // Invalid bit depth
+ }
+
+ if (flags == PNM_SAVE_RAW)
+ magic += 3;
+
+ // Write the header info
+
+ char buffer[20];
+ sprintf(buffer, "P%d\n%d %d\n", magic, width, height);
+ io.write_proc(&buffer, strlen(buffer), 1, handle);
+
+ if (bpp != 1) {
+ sprintf(buffer, "255\n");
+ io.write_proc(&buffer, strlen(buffer), 1, handle);
+ }
+
+ // Write the image data
+ ///////////////////////
+
+ int pitch = (bpp == 32) ? CalculatePitch(CalculateLine(width, 24)) : freeimage.get_pitch_proc(dib);
+
+ switch(bpp) {
+ case 32 :
+ case 24 : // 24-bit RGB, 3 bytes per pixel
+ {
+ if (flags == PNM_SAVE_RAW) {
+ BYTE *buffer = (BYTE *)malloc(pitch);
+
+ for (y = 0; y < height; y++) {
+ // get a pointer to the (converted) scanline
+
+ if (bpp == 32)
+ freeimage.convert_line_32to24_proc(buffer, freeimage.get_scanline_proc(dib, height - y - 1), width);
+ else
+ memcpy(buffer, freeimage.get_scanline_proc(dib, height - 1 - y), pitch);
+
+ // write the scanline to disc
+
+ BYTE *bits = buffer;
+
+ for (x = 0; x < width; x++) {
+ io.write_proc(&bits[2], 1, 1, handle); // R
+ io.write_proc(&bits[1], 1, 1, handle); // G
+ io.write_proc(&bits[0], 1, 1, handle); // B
+
+ bits += 3;
+ }
+ }
+
+ free(buffer);
+ } else {
+ int length = 0;
+
+ BYTE *buffer = (BYTE *)malloc(pitch);
+
+ for (y = 0; y < height; y++) {
+ // get a pointer to the (converted) scanline
+
+ if (bpp == 32)
+ freeimage.convert_line_32to24_proc(buffer, freeimage.get_scanline_proc(dib, height - 1 - y), width);
+ else
+ memcpy(buffer, freeimage.get_scanline_proc(dib, height - 1 - y), pitch);
+
+ // write the scanline to disc
+
+ BYTE *bits = buffer;
+
+ for (x = 0; x < width; x++) {
+ char buffer[20];
+
+ sprintf(buffer, "%3d %3d %3d ", bits[2], bits[1], bits[0]);
+
+ io.write_proc(&buffer, strlen(buffer), 1, handle);
+
+ length += 12;
+
+ if(length > 58) {
+ sprintf(buffer, "\n");
+
+ io.write_proc(&buffer, strlen(buffer), 1, handle);
+
+ length = 0;
+ }
+
+ bits += 3;
+ }
+ }
+
+ free(buffer);
+ }
+
+ break;
+ }
+
+ case 8: // 8-bit greyscale
+ {
+ if (flags == PNM_SAVE_RAW) {
+ for (y = 0; y < height; y++) {
+ bits = freeimage.get_bits_proc(dib) + (height - 1 - y) * pitch;
+
+ for (x = 0; x < width; x++) {
+ io.write_proc(&bits[x], 1, 1, handle);
+ }
+ }
+ } else {
+ int length = 0;
+
+ for (y = 0; y < height; y++) {
+ bits = freeimage.get_bits_proc(dib) + (height - 1 - y) * pitch;
+
+ for (x = 0; x < width; x++) {
+ sprintf(buffer, "%3d ", bits[x]);
+
+ io.write_proc(&buffer, strlen(buffer), 1, handle);
+
+ length += 4;
+
+ if (length > 66) {
+ sprintf(buffer, "\n");
+
+ io.write_proc(&buffer, strlen(buffer), 1, handle);
+
+ length = 0;
+ }
+ }
+ }
+ }
+
+ break;
+ }
+
+ case 1: // 1-bit B & W
+ {
+ RGBQUAD *pal = freeimage.get_palette_proc(dib);
+ int color;
+
+ if (flags == PNM_SAVE_RAW) {
+ for(y = 0; y < height; y++) {
+ bits = freeimage.get_bits_proc(dib) + (height - 1 - y) * pitch;
+
+ for(x = 0; x < freeimage.get_line_proc(dib); x++)
+ io.write_proc(&bits[x], 1, 1, handle);
+ }
+ } else {
+ int length = 0;
+
+ for (y = 0; y < height; y++) {
+ bits = freeimage.get_bits_proc(dib) + (height - 1 - y) * pitch;
+
+ for (x = 0; x < freeimage.get_line_proc(dib) * 8; x++) {
+ color = (bits[x>>3] & (0x80 >> (x & 0x07))) != 0;
+
+ sprintf(buffer, "%c ", color ? '1':'0');
+
+ io.write_proc(&buffer, strlen(buffer), 1, handle);
+
+ length += 2;
+
+ if (length > 68) {
+ sprintf(buffer, "\n");
+
+ io.write_proc(&buffer, strlen(buffer), 1, handle);
+
+ length = 0;
+ }
+ }
+ }
+ }
+ }
+
+ break;
+ }
+
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+// ==========================================================
+// Init
+// ==========================================================
+
+void DLL_CALLCONV
+InitPNM(Plugin &plugin, int format_id) {
+ s_format_id = format_id;
+
+ plugin.format_proc = Format;
+ plugin.description_proc = Description;
+ plugin.extension_proc = Extension;
+ plugin.regexpr_proc = RegExpr;
+ plugin.load_proc = Load;
+ plugin.save_proc = Save;
+ plugin.validate_proc = Validate;
+}
+
diff --git a/freeimage241/Source/FreeImage/PluginPSD.cpp b/freeimage241/Source/FreeImage/PluginPSD.cpp
new file mode 100644
index 0000000..eaa55cb
--- /dev/null
+++ b/freeimage241/Source/FreeImage/PluginPSD.cpp
@@ -0,0 +1,389 @@
+// ==========================================================
+// Photoshop Loader
+//
+// Design and implementation by
+// - Floris van den Berg (flvdberg@wxs.nl)
+//
+// Based on public domain code created and
+// published by Thatcher Ulrich (ulrich@world.std.com)
+//
+// This file is part of FreeImage 2
+//
+// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
+// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
+// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
+// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
+// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
+// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
+// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+// THIS DISCLAIMER.
+//
+// Use at your own risk!
+// ==========================================================
+
+#include "FreeImage.h"
+
+// ==========================================================
+// Bitmap pointer access macros
+// ==========================================================
+
+#define BP_START(DIB, WIDTH, HEIGHT) \
+ int scanline = 0; \
+ unsigned *bits = (unsigned *)freeimage.get_scanline_proc(DIB, HEIGHT - 1 - scanline); \
+ unsigned *p = bits;
+
+#define BP_NEXT(DIB, WIDTH, HEIGHT) \
+ p++; \
+ if (p - bits == width) { \
+ scanline++; \
+ bits = (unsigned *)freeimage.get_scanline_proc(DIB, HEIGHT - 1 - scanline); \
+ p = bits; \
+ }
+
+#define BP_SETVALUE(VALUE) \
+ *p |= VALUE;
+
+// ==========================================================
+// Internal functions
+// ==========================================================
+
+static unsigned
+Read8(FreeImageIO &io, fi_handle handle) {
+ unsigned i = 0;
+ io.read_proc(&i, 1, 1, handle);
+ return i;
+}
+
+static unsigned
+Read16(FreeImageIO &io, fi_handle handle) {
+ // reads a two-byte big-endian integer from the given file and returns its value.
+ // assumes unsigned.
+
+ unsigned hi = Read8(io, handle);
+ unsigned lo = Read8(io, handle);
+ return lo + (hi << 8);
+}
+
+static unsigned
+Read32(FreeImageIO &io, fi_handle handle) {
+ // reads a four-byte big-endian integer from the given file and returns its value.
+ // assumes unsigned.
+
+ unsigned b3 = Read8(io, handle);
+ unsigned b2 = Read8(io, handle);
+ unsigned b1 = Read8(io, handle);
+ unsigned b0 = Read8(io, handle);
+ return (b3 << 24) + (b2 << 16) + (b1 << 8) + b0;
+}
+
+// ----------------------------------------------------------
+
+static void
+ScanForResolution(float* hres, float* vres, FreeImageIO &io, fi_handle handle, int width, int height, int channel_count, int byte_count) {
+ // scans through the next byte_count bytes of the file, looking for an
+ // image resource block encoding the image's resolution. Returns the resolution(s),
+ // if found, in the pointed-to floats. Units are in pixels/meter.
+
+ while (byte_count) {
+ // read the image resource block header.
+
+ if (Read32(io, handle) != 0x3842494D /* "8BIM" */)
+ throw "image resource block has unknown signature";
+
+ int id = Read16(io, handle);
+
+ // skip the name.
+
+ int name_length = Read8(io, handle) | 1; // name_length must be odd, so that total including size byte is even.
+
+ io.seek_proc(handle, name_length, SEEK_CUR);
+
+ // get the size of the data block.
+
+ int data_size = Read32(io, handle);
+
+ if (data_size & 1 == 1)
+ data_size += 1; // block size must be even.
+
+ // account for header size.
+
+ byte_count -= 11 + name_length;
+
+ // if this block is a resolution info structure, then get the resolution.
+
+ if (id == 0x03ED) {
+ int junk;
+
+ int hres_fixed = Read32(io, handle);
+ junk = Read16(io, handle); // display units of hres.
+ junk = Read16(io, handle); // display units of width.
+
+ int vres_fixed = Read32(io, handle);
+ junk = Read16(io, handle); // display units of vres.
+ junk = Read16(io, handle); // display units of height.
+
+ byte_count -= data_size;
+ data_size -= 16;
+
+ // skip any extra bytes at the end of this block...
+
+ if (data_size > 0)
+ io.seek_proc(handle, data_size, SEEK_CUR);
+
+ // need to convert resolution figures from fixed point, pixels/inch
+ // to floating point, pixels/meter.
+
+ *hres = hres_fixed * ((float)39.4 / (float)65536.0);
+ *vres = vres_fixed * ((float)39.4 / (float)65536.0);
+ } else {
+ // skip the rest of this block.
+
+ io.seek_proc(handle, data_size, SEEK_CUR);
+
+ byte_count -= data_size;
+ }
+ }
+}
+
+// ----------------------------------------------------------
+
+static FIBITMAP *
+LoadPSDRGB(FreeImage &freeimage, FreeImageIO &io, fi_handle handle, int width, int height, int channel_count) {
+ // skip the mode data. (it's the palette for indexed color; other info for other modes.)
+
+ int mode_data_count = Read32(io, handle);
+
+ if (mode_data_count)
+ io.seek_proc(handle, mode_data_count, SEEK_CUR);
+
+ // skip the image resources. (resolution, pen tool paths, alpha channel names, etc)
+
+ int resource_data_count = Read32(io, handle);
+
+ if (resource_data_count)
+ io.seek_proc(handle, resource_data_count, SEEK_CUR);
+
+ // skip the reserved data
+
+ int reserved_data_count = Read32(io, handle);
+
+ if (reserved_data_count)
+ io.seek_proc(handle, reserved_data_count, SEEK_CUR);
+
+ // find out if the data is compressed
+ // 0: no compressiod
+ // 1: RLE compressed
+
+ unsigned compression = Read16(io, handle);
+
+ if ((compression > 1) || (compression < 0))
+ return NULL;
+
+ // some formatting information about the channels
+
+ const struct ChannelInfo {
+ int shift, mask, deflt;
+ } Channel[4] = {
+ { 16, 0x00FF0000, 0 }, // red
+ { 8, 0x0000FF00, 0 }, // green
+ { 0, 0x000000FF, 0 }, // blue
+ { 24, 0xFF000000, 255 } // alpha
+ };
+
+ // Create the destination bitmap
+
+ FIBITMAP *dib = freeimage.allocate_proc(width, height, 32, 0xFF, 0xFF00, 0xFF0000);
+
+ // finally, read the image data.
+
+ if (compression) {
+ // the RLE-compressed data is preceeded by a 2-byte data count for each row in the data
+
+ io.seek_proc(handle, height * channel_count * 2, SEEK_CUR);
+
+ // read the RLE data by channel
+
+ for (int channel = 0; channel < (channel_count > 4 ? 4 : channel_count); channel++) {
+ const ChannelInfo &c = Channel[channel];
+
+ BP_START(dib, width, height)
+
+ if (channel >= channel_count) {
+ // fill this channel with default data.
+
+ unsigned def = (c.deflt << c.shift) & c.mask;
+
+ for (int i = 0; i < width * height; i++) {
+ BP_SETVALUE(def);
+ BP_NEXT(dib, width, height)
+ }
+ } else {
+ // read the RLE data.
+
+ int count = 0;
+
+ while (count < width * height) {
+ int len = Read8(io, handle);
+
+ if (len == 128) {
+ // nop
+ } else if (len < 128) {
+ // copy next len + 1 bytes literally.
+
+ len++;
+ count += len;
+
+ while (len) {
+ BP_SETVALUE(((Read8(io, handle) << c.shift) & c.mask));
+ BP_NEXT(dib, width, height)
+
+ len--;
+ }
+ } else if (len > 128) {
+ // next -len + 1 bytes in the dest are replicated from next source byte.
+ // (interpret len as a negative 8-bit int.)
+
+ len ^= 0x0FF;
+ len += 2;
+ count += len;
+
+ unsigned val = (Read8(io, handle) << c.shift) & c.mask;
+
+ while (len) {
+ BP_SETVALUE(val);
+ BP_NEXT(dib, width, height)
+
+ len--;
+ }
+ }
+ }
+ }
+ }
+ } else {
+ // we're at the raw image data. it's each channel in order (Red, Green, Blue, Alpha, ...)
+ // where each channel consists of an 8-bit value for each pixel in the image.
+
+ for (int channel = 0; channel < 4; channel++) {
+ const ChannelInfo &c = Channel[channel];
+
+ BP_START(dib, width, height)
+
+ if (channel > channel_count) {
+ // fill this channel with default data.
+
+ unsigned def = (c.deflt << c.shift) & c.mask;
+
+ for (int i = 0; i < width * height; i++) {
+ BP_SETVALUE(def);
+ BP_NEXT(dib, width, height)
+ }
+ } else {
+ // read the data
+
+ for (int i = 0; i < width * height; i++) {
+ BP_SETVALUE((Read8(io, handle) << c.shift) & c.mask);
+ BP_NEXT(dib, width, height)
+ }
+ }
+ }
+ }
+
+ return dib;
+}
+
+// ==========================================================
+// Plugin Interface
+// ==========================================================
+
+static int s_format_id;
+
+// ==========================================================
+// Plugin Implementation
+// ==========================================================
+
+static const char * DLL_CALLCONV
+Format() {
+ return "PSD";
+}
+
+static const char * DLL_CALLCONV
+Description() {
+ return "Adobe Photoshop";
+}
+
+static const char * DLL_CALLCONV
+Extension() {
+ return "psd";
+}
+
+static BOOL DLL_CALLCONV
+Validate(FreeImageIO &io, fi_handle handle) {
+ return (Read32(io, handle) == 0x38425053);
+}
+
+// ----------------------------------------------------------
+
+static FIBITMAP * DLL_CALLCONV
+Load(FreeImage &freeimage, FreeImageIO &io, fi_handle handle, int page, int flags, void *data) {
+ try {
+ if (Read32(io, handle) == 0x38425053) {
+ if (Read16(io, handle) == 1) {
+ // 6 reserved bytes.
+
+ Read32(io, handle);
+ Read16(io, handle);
+
+ // Read the number of channels (R, G, B, A, etc).
+
+ unsigned channel_count = Read16(io, handle);
+
+ if (channel_count >= 0 && channel_count <= 16) {
+ unsigned height = Read32(io, handle);
+ unsigned width = Read32(io, handle);
+
+ if (Read16(io, handle) == 8) {
+ unsigned mode = Read16(io, handle);
+
+ // Valid options are:
+ // 0: Bitmap (not implemented)
+ // 1: Grayscale (not implemented)
+ // 2: Indexed color (not implemented)
+ // 3: RGB color
+ // 4: CMYK color (not implemented)
+ // 7: Multichannel (not implemented)
+ // 8: Duotone (not implemented)
+ // 9: Lab color (not implemented)
+
+ switch (mode) {
+ case 3 :
+ return LoadPSDRGB(freeimage, io, handle, width, height, channel_count);
+
+ default :
+ throw "color mode not supported";
+ }
+ }
+ }
+ }
+ }
+ } catch(const char *message) {
+ freeimage.output_message_proc(s_format_id, message);
+ }
+
+ return NULL;
+}
+
+// ==========================================================
+// Init
+// ==========================================================
+
+void DLL_CALLCONV
+InitPSD(Plugin &plugin, int format_id) {
+ s_format_id = format_id;
+
+ plugin.format_proc = Format;
+ plugin.description_proc = Description;
+ plugin.extension_proc = Extension;
+ plugin.validate_proc = Validate;
+ plugin.load_proc = Load;
+}
diff --git a/freeimage241/Source/FreeImage/PluginRAS.cpp b/freeimage241/Source/FreeImage/PluginRAS.cpp
new file mode 100644
index 0000000..a8bd01b
--- /dev/null
+++ b/freeimage241/Source/FreeImage/PluginRAS.cpp
@@ -0,0 +1,470 @@
+// ==========================================================
+// Sun rasterfile Loader
+//
+// Design and implementation by
+// - Hervé Drolon (drolon@infonie.fr)
+//
+// This file is part of FreeImage 2
+//
+// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
+// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
+// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
+// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
+// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
+// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
+// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+// THIS DISCLAIMER.
+//
+// Use at your own risk!
+// ==========================================================
+
+#include
+#include
+
+#include "FreeImage.h"
+#include "Utilities.h"
+
+// ----------------------------------------------------------
+// Constants + headers
+// ----------------------------------------------------------
+
+#ifdef WIN32
+#pragma pack(push, 1)
+#else
+#pragma pack(1)
+#endif
+
+typedef struct {
+ DWORD magic; // Magic number
+ DWORD width; // Image width in pixels
+ DWORD height; // Image height in pixels
+ DWORD depth; // Depth (1, 8, 24 or 32 bits) of each pixel
+ DWORD length; // Image length (in bytes)
+ DWORD type; // Format of file (see RT_* below)
+ DWORD maptype; // Type of colormap (see RMT_* below)
+ DWORD maplength; // Length of colormap (in bytes)
+} Sun_Header;
+
+#ifdef WIN32
+#pragma pack(pop)
+#else
+#pragma pack(4)
+#endif
+
+// ----------------------------------------------------------
+
+// Following the header is the colormap, for maplength bytes (unless maplength is zero),
+// then the image. Each row of the image is rounded to 2 bytes.
+
+#define RAS_MAGIC 0x59A66A95 // Magic number for Sun rasterfiles
+
+// Sun supported type's
+
+#define RT_OLD 0 // Old format (raw image in 68000 byte order)
+#define RT_STANDARD 1 // Raw image in 68000 byte order
+#define RT_BYTE_ENCODED 2 // Run-length encoding of bytes
+#define RT_FORMAT_RGB 3 // XRGB or RGB instead of XBGR or BGR
+#define RT_FORMAT_TIFF 4 // TIFF <-> standard rasterfile
+#define RT_FORMAT_IFF 5 // IFF (TAAC format) <-> standard rasterfile
+
+#define RT_EXPERIMENTAL 0xffff // Reserved for testing
+
+// These are the possible colormap types.
+// if it's in RGB format, the map is made up of three byte arrays
+// (red, green, then blue) that are each 1/3 of the colormap length.
+
+#define RMT_NONE 0 // maplength is expected to be 0
+#define RMT_EQUAL_RGB 1 // red[maplength/3], green[maplength/3], blue[maplength/3]
+#define RMT_RAW 2 // Raw colormap
+#define RESC 128 // Run-length encoding escape character
+
+// ----- NOTES -----
+// Each line of the image is rounded out to a multiple of 16 bits.
+// This corresponds to the rounding convention used by the memory pixrect
+// package (/usr/include/pixrect/memvar.h) of the SunWindows system.
+// The ras_encoding field (always set to 0 by Sun's supported software)
+// was renamed to ras_length in release 2.0. As a result, rasterfiles
+// of type 0 generated by the old software claim to have 0 length; for
+// compatibility, code reading rasterfiles must be prepared to compute the
+// TRUE length from the width, height, and depth fields.
+
+// ==========================================================
+// Internal functions
+// ==========================================================
+
+static void
+SwapLong(DWORD *lp) {
+ // Byte Swapping Support
+
+ register BYTE *cp = (BYTE*) lp;
+
+ BYTE t;
+
+ t = cp[3]; cp[3] = cp[0]; cp[0] = t;
+ t = cp[2]; cp[2] = cp[1]; cp[1] = t;
+}
+
+static void
+ReadData(FreeImageIO &io, fi_handle handle, BYTE *buf, DWORD length, BOOL rle) {
+ // Read either Run-Length Encoded or normal image data
+
+ static BYTE repchar, remaining= 0;
+
+ if (rle) {
+ // Run-length encoded read
+
+ while(length--) {
+ if (remaining) {
+ remaining--;
+ *(buf++)= repchar;
+ } else {
+ io.read_proc(&repchar, 1, 1, handle);
+
+ if (repchar == RESC) {
+ io.read_proc(&remaining, 1, 1, handle);
+
+ if (remaining == 0) {
+ *(buf++)= RESC;
+ } else {
+ io.read_proc(&repchar, 1, 1, handle);
+
+ *(buf++)= repchar;
+ }
+ } else {
+ *(buf++)= repchar;
+ }
+ }
+ }
+ } else {
+ // Normal read
+
+ io.read_proc(buf, length, 1, handle);
+ }
+}
+
+// ==========================================================
+// Plugin Interface
+// ==========================================================
+
+static int s_format_id;
+
+// ==========================================================
+// Plugin Implementation
+// ==========================================================
+
+static const char * DLL_CALLCONV
+Format() {
+ return "RAS";
+}
+
+static const char * DLL_CALLCONV
+Description() {
+ return "Sun Raster Image";
+}
+
+static const char * DLL_CALLCONV
+Extension() {
+ return "ras";
+}
+
+static const char * DLL_CALLCONV
+RegExpr() {
+ return NULL;
+}
+
+static BOOL DLL_CALLCONV
+Validate(FreeImageIO &io, fi_handle handle) {
+ BYTE ras_signature[] = { 0x59, 0xA6, 0x6A, 0x95 };
+ BYTE signature[4] = { 0, 0, 0, 0 };
+
+ io.read_proc(signature, 1, sizeof(ras_signature), handle);
+
+ return (memcmp(ras_signature, signature, sizeof(ras_signature)) == 0);
+}
+
+// ----------------------------------------------------------
+
+static FIBITMAP * DLL_CALLCONV
+Load(FreeImage &freeimage, FreeImageIO &io, fi_handle handle, int page, int flags, void *data) {
+ Sun_Header header; // Sun file header
+ WORD linelength; // Length of raster line in bytes
+ WORD fill; // Number of fill bytes per raster line
+ BOOL rle; // TRUE if RLE file
+ BOOL isRGB; // TRUE if file type is RT_FORMAT_RGB
+ BYTE fillchar;
+
+ FIBITMAP *dib = NULL;
+ BYTE *bits; // Pointer to dib data
+ WORD x, y;
+
+ if (handle) {
+ try {
+ // Read SUN raster header
+
+ io.read_proc(&header, sizeof(Sun_Header), 1, handle);
+
+ // SUN rasterfiles are big endian only
+
+ SwapLong(&header.magic);
+ SwapLong(&header.width);
+ SwapLong(&header.height);
+ SwapLong(&header.depth);
+ SwapLong(&header.length);
+ SwapLong(&header.type);
+ SwapLong(&header.maptype);
+ SwapLong(&header.maplength);
+
+ // Verify SUN identifier
+
+ if (header.magic != RAS_MAGIC)
+ throw "Invalid magic number";
+
+ // Allocate a new DIB
+
+ switch(header.depth) {
+ case 1:
+ case 8:
+ dib = freeimage.allocate_proc(header.width, header.height, header.depth);
+ break;
+
+ case 24:
+ case 32:
+ dib = freeimage.allocate_proc(header.width, header.height, header.depth, 0xFF, 0xFF00, 0xFF0000);
+ break;
+ }
+
+ if (dib == NULL)
+ throw "DIB allocation failed";
+
+ // Check the file format
+
+ rle = FALSE;
+ isRGB = FALSE;
+
+ switch(header.type) {
+ case RT_OLD:
+ case RT_STANDARD:
+ break;
+
+ case RT_BYTE_ENCODED:
+ rle = TRUE;
+ break;
+
+ case RT_FORMAT_RGB:
+ isRGB = TRUE;
+ break;
+
+ case RT_FORMAT_TIFF: // I don't even know what these format are...
+ case RT_FORMAT_IFF:
+
+ default:
+ throw "Unsupported Sun rasterfile";
+ }
+
+ // set up the colormap if needed
+
+ switch(header.maptype) {
+ case RMT_NONE :
+ {
+ if (header.depth < 24) {
+ // Create linear color ramp
+
+ RGBQUAD *pal = freeimage.get_palette_proc(dib);
+
+ int numcolors = 1 << header.depth;
+
+ for (int i = 0; i < numcolors; i++) {
+ pal[i].rgbRed = (255 * i) / (numcolors - 1);
+ pal[i].rgbGreen = (255 * i) / (numcolors - 1);
+ pal[i].rgbBlue = (255 * i) / (numcolors - 1);
+ }
+ }
+
+ break;
+ }
+
+ case RMT_EQUAL_RGB:
+ {
+ BYTE *r, *g, *b;
+
+ // Read SUN raster colormap
+
+ int numcolors = 1 << header.depth;
+
+ r = (BYTE*)malloc(3 * numcolors * sizeof(BYTE));
+ g = r + numcolors;
+ b = g + numcolors;
+
+ RGBQUAD *pal = freeimage.get_palette_proc(dib);
+
+ io.read_proc(r, 3 * numcolors, 1, handle);
+
+ for (int i = 0; i < numcolors; i++) {
+ pal[i].rgbRed = r[i];
+ pal[i].rgbGreen = g[i];
+ pal[i].rgbBlue = b[i];
+ }
+
+ free(r);
+ break;
+ }
+
+ case RMT_RAW:
+ {
+ BYTE *colormap;
+
+ // Read (skip) SUN raster colormap.
+
+ colormap = (BYTE *)malloc(header.maplength * sizeof(BYTE));
+
+ io.read_proc(colormap, header.maplength, 1, handle);
+
+ free(colormap);
+ break;
+ }
+ }
+
+ // Calculate the line + pitch
+ // Each row is multiple of 16 bits (2 bytes).
+
+ if (header.depth == 1)
+ linelength = (WORD)((header.width / 8) + (header.width % 8 ? 1 : 0));
+ else
+ linelength = (WORD)header.width;
+
+ fill = (linelength % 2) ? 1 : 0;
+
+ int pitch = freeimage.get_pitch_proc(dib);
+
+ // Read the image data
+
+ switch(header.depth) {
+ case 1:
+ case 8:
+ {
+ bits = freeimage.get_bits_proc(dib) + (header.height - 1) * pitch;
+
+ for (y = 0; y < header.height; y++) {
+ ReadData(io, handle, bits, linelength, rle);
+
+ bits -= pitch;
+
+ if (fill)
+ ReadData(io, handle, &fillchar, fill, rle);
+ }
+
+ break;
+ }
+
+ case 24:
+ {
+ BYTE *buf, *bp;
+
+ buf = (BYTE*)malloc(header.width * 3);
+
+ for (y = 0; y < header.height; y++) {
+ bits = freeimage.get_bits_proc(dib) + (header.height - 1 - y) * pitch;
+
+ ReadData(io, handle, buf, header.width * 3, rle);
+
+ bp = buf;
+
+ if (isRGB) {
+ for (x = 0; x < header.width; x++) {
+ bits[2] = *(bp++); // red
+ bits[1] = *(bp++); // green
+ bits[0] = *(bp++); // blue
+
+ bits += 3;
+ }
+ } else {
+ for (x = 0; x < header.width; x++) {
+ bits[2] = *(bp + 2); // red
+ bits[1] = *(bp + 1); // green
+ bits[0] = *bp; // blue
+
+ bits += 3; bp += 3;
+ }
+ }
+
+ if (fill)
+ ReadData(io, handle, &fillchar, fill, rle);
+ }
+
+ free(buf);
+ break;
+ }
+
+ case 32:
+ {
+ BYTE *buf, *bp;
+
+ buf = (BYTE*)malloc(header.width * 4);
+
+ for (y = 0; y < header.height; y++) {
+ bits = freeimage.get_bits_proc(dib) + (header.height - 1 - y) * pitch;
+
+ ReadData(io, handle, buf, header.width * 4, rle);
+
+ bp = buf;
+
+ if (isRGB) {
+ for (x = 0; x < header.width; x++) {
+ bp++; // skip byte
+
+ bits[2] = *(bp++); // red
+ bits[1] = *(bp++); // green
+ bits[0] = *(bp++); // blue
+
+ bits += 4;
+ }
+ }
+ else {
+ for (x = 0; x < header.width; x++) {
+ bits[2] = *(bp + 3); // red
+ bits[1] = *(bp + 2); // green
+ bits[0] = *(bp + 1); // blue
+
+ bits += 4;
+ bp += 4;
+ }
+ }
+
+ if (fill)
+ ReadData(io, handle, &fillchar, fill, rle);
+ }
+
+ free(buf);
+ break;
+ }
+ }
+
+ return dib;
+
+ } catch (char *text) {
+ freeimage.output_message_proc(s_format_id, text);
+
+ return NULL;
+ }
+
+ }
+
+ return NULL;
+}
+
+// ==========================================================
+// Init
+// ==========================================================
+
+void DLL_CALLCONV
+InitRAS(Plugin &plugin, int format_id) {
+ s_format_id = format_id;
+
+ plugin.format_proc = Format;
+ plugin.description_proc = Description;
+ plugin.extension_proc = Extension;
+ plugin.regexpr_proc = RegExpr;
+ plugin.load_proc = Load;
+ plugin.validate_proc = Validate;
+}
diff --git a/freeimage241/Source/FreeImage/PluginTARGA.cpp b/freeimage241/Source/FreeImage/PluginTARGA.cpp
new file mode 100644
index 0000000..7f6fd9b
--- /dev/null
+++ b/freeimage241/Source/FreeImage/PluginTARGA.cpp
@@ -0,0 +1,839 @@
+// ==========================================================
+// TARGA Loader
+//
+// Design and implementation by
+// - Floris van den Berg (flvdberg@wxs.nl)
+// - Jani Kajala (janik@remedy.fi)
+// - Martin Weber (martweb@gmx.net)
+// - Machiel ten Brinke (brinkem@uni-one.nl)
+//
+// This file is part of FreeImage 2
+//
+// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
+// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
+// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
+// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
+// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
+// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
+// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+// THIS DISCLAIMER.
+//
+// Use at your own risk!
+// ==========================================================
+
+#include
+
+#include "FreeImage.h"
+#include "Utilities.h"
+
+// ----------------------------------------------------------
+// Constants + headers
+// ----------------------------------------------------------
+
+#ifdef WIN32
+#pragma pack(push, 1)
+#else
+#pragma pack(1)
+#endif
+
+typedef struct tagRGBTRIPLE {
+ BYTE rgbtBlue;
+ BYTE rgbtGreen;
+ BYTE rgbtRed;
+} RGBTRIPLE;
+
+typedef struct tagBGRAQUAD {
+ BYTE bgraBlue;
+ BYTE bgraGreen;
+ BYTE bgraRed;
+ BYTE bgraAlpha;
+} BGRAQUAD;
+
+struct tagTGAHEADER {
+ BYTE id_length;
+ BYTE color_map_type;
+ BYTE image_type;
+
+ WORD cm_first_entry;
+ WORD cm_length;
+ BYTE cm_size;
+
+ WORD is_xorigin;
+ WORD is_yorigin;
+ WORD is_width;
+ WORD is_height;
+ BYTE is_pixel_depth;
+ BYTE is_image_descriptor;
+};
+
+#ifdef WIN32
+#pragma pack(pop)
+#else
+#pragma pack(4)
+#endif
+
+// ==========================================================
+// Internal functions
+// ==========================================================
+
+static BYTE *
+Internal_GetScanLine(FreeImage &freeimage, FIBITMAP *dib, int scanline, int flipvert) {
+ //assert ((scanline >= 0) && (scanline < (int)freeimage.get_height_proc(dib)));
+
+ if (flipvert) {
+ return freeimage.get_scanline_proc(dib, scanline);
+ } else {
+ return freeimage.get_scanline_proc(dib, freeimage.get_height_proc(dib) - scanline - 1);
+ }
+}
+
+// ==========================================================
+// Plugin Interface
+// ==========================================================
+
+static int s_format_id;
+
+// ==========================================================
+// Plugin Implementation
+// ==========================================================
+
+static const char * DLL_CALLCONV
+Format() {
+ return "TARGA";
+}
+
+static const char * DLL_CALLCONV
+Description() {
+ return "Truevision Targa";
+}
+
+static const char * DLL_CALLCONV
+Extension() {
+ return "tga,targa";
+}
+
+static const char * DLL_CALLCONV
+RegExpr() {
+ return NULL;
+}
+
+// ----------------------------------------------------------
+
+static FIBITMAP * DLL_CALLCONV
+Load(FreeImage &freeimage, FreeImageIO &io, fi_handle handle, int page, int flags, void *data) {
+ if (handle) {
+ try {
+ // remember the start offset
+
+ long start_offset = io.tell_proc(handle);
+
+ // read and process the bitmap's header
+
+ FIBITMAP *dib = NULL;
+ tagTGAHEADER header;
+
+ io.read_proc(&header, sizeof(tagTGAHEADER), 1, handle);
+
+ int line = CalculateLine(header.is_width, header.is_pixel_depth);
+ int pitch = CalculatePitch(line);
+ int alphabits = header.is_image_descriptor & 0x0f;
+ int fliphoriz = (header.is_image_descriptor & 0x10) ? 0 : 1;
+ int flipvert = (header.is_image_descriptor & 0x20) ? 1 : 0;
+
+ io.seek_proc(handle, header.id_length, SEEK_CUR);
+ switch (header.is_pixel_depth) {
+ case 8 :
+ {
+ dib = freeimage.allocate_proc(header.is_width, header.is_height, 8);
+
+ if (dib == NULL) {
+ throw "DIB allocation failed";
+ }
+
+ // read the palette
+
+ RGBQUAD *palette = freeimage.get_palette_proc(dib);
+
+ if (header.color_map_type == 0)
+ for (unsigned i = 0; i < 256; i++) {
+ palette[i].rgbRed = i;
+ palette[i].rgbGreen = i;
+ palette[i].rgbBlue = i;
+ }
+ else if (alphabits) {
+ for (unsigned count = header.cm_first_entry; count < header.cm_length; count++) {
+ BGRAQUAD quad;
+
+ io.read_proc(&quad, sizeof(RGBTRIPLE), 1, handle);
+
+ palette[count].rgbBlue = quad.bgraBlue;
+ palette[count].rgbRed = quad.bgraRed;
+ palette[count].rgbGreen = quad.bgraGreen;
+ palette[count].rgbReserved = quad.bgraAlpha;
+ }
+ }
+ else {
+ for (unsigned count = header.cm_first_entry; count < header.cm_length; count++) {
+ RGBTRIPLE triple;
+
+ io.read_proc(&triple, sizeof(RGBTRIPLE), 1, handle);
+
+ palette[count].rgbRed = triple.rgbtRed;
+ palette[count].rgbGreen = triple.rgbtGreen;
+ palette[count].rgbBlue = triple.rgbtBlue;
+ }
+ }
+
+ // read in the bitmap bits
+ switch (header.image_type) {
+ case 1 :
+ case 3 :
+ {
+ if (fliphoriz) {
+ for (unsigned count = header.is_height; count > 0; count--)
+ io.read_proc(Internal_GetScanLine(freeimage, dib, count - 1, flipvert), line, 1, handle);
+
+ }
+ else {
+ for (unsigned count = 0; count < header.is_height; count++)
+ io.read_proc(Internal_GetScanLine(freeimage, dib, count, flipvert), line, 1, handle);
+
+ }
+
+ break;
+ }
+
+ case 9 :
+ case 11:
+ {
+ int x = 0;
+ int y = 0;
+ BYTE *bits;
+
+ if (fliphoriz)
+ bits = Internal_GetScanLine(freeimage, dib, header.is_height - y - 1, flipvert);
+ else
+ bits = Internal_GetScanLine(freeimage, dib, y, flipvert);
+
+ BYTE rle;
+
+ while(1) {
+ io.read_proc(&rle,1, 1, handle);
+
+ if (rle>127) {
+ rle -= 127;
+
+ BYTE triple;
+
+ io.read_proc(&triple, 1, 1, handle);
+
+ for (int ix = 0; ix < rle; ix++) {
+ bits[x++] = triple;
+
+ if (x >= line) {
+ x = 0;
+
+ y++;
+
+ if (y >= header.is_height)
+ goto done89;
+
+ if(fliphoriz)
+ bits = Internal_GetScanLine(freeimage, dib, header.is_height-y-1, flipvert);
+ else
+ bits = Internal_GetScanLine(freeimage, dib, y, flipvert);
+ }
+ }
+ } else {
+ rle++;
+
+ for (int ix = 0; ix < rle; ix++) {
+ BYTE triple;
+
+ io.read_proc(&triple, 1, 1, handle);
+
+ bits[x++] = triple;
+
+ if (x >= line) {
+ x = 0;
+
+ y++;
+
+ if (y >= header.is_height)
+ goto done89;
+
+ if(fliphoriz)
+ bits = Internal_GetScanLine(freeimage, dib, header.is_height-y-1, flipvert);
+ else
+ bits = Internal_GetScanLine(freeimage, dib, y, flipvert);
+ }
+ }
+ }
+ }
+ done89 :
+ break;
+ }
+
+ default :
+ freeimage.free_proc(dib);
+ return NULL;
+ }
+
+ break;
+ }
+
+ case 15 :
+ case 16 :
+ {
+ int pixel_bits;
+
+ // allocate the dib
+
+ if (TARGA_LOAD_RGB888 & flags) {
+ pixel_bits = 24;
+
+ dib = freeimage.allocate_proc(header.is_width, header.is_height, pixel_bits, 0xFF, 0xFF00, 0xFF0000);
+ } else {
+ pixel_bits = 16;
+
+ dib = freeimage.allocate_proc(header.is_width, header.is_height, pixel_bits, 0x1F, 0x3E0, 0x7C00);
+ }
+
+ if (dib == NULL)
+ throw "DIB allocation failed";
+
+ int line = CalculateLine(header.is_width, pixel_bits);
+ int pitch = CalculatePitch(line);
+
+ const unsigned pixel_size = unsigned(pixel_bits) / 8;
+
+ // note header.cm_size is a misleading name, it should be seen as header.cm_bits
+ // ignore current position in file and set filepointer explicitly from the beginning of the file
+
+ int garblen = 0;
+
+ if (header.color_map_type != 0)
+ garblen = (int)((header.cm_size + 7) / 8) * header.cm_length; /* should byte align */
+ else
+ garblen = 0;
+
+ io.seek_proc(handle, start_offset, SEEK_SET);
+ io.seek_proc(handle, sizeof(tagTGAHEADER) + header.id_length + garblen, SEEK_SET);
+
+ // read in the bitmap bits
+
+ WORD pixel;
+
+ switch (header.image_type) {
+ case 2 :
+ {
+ for (int y = 0; y < header.is_height; y++) {
+ BYTE *bits;
+ if(fliphoriz)
+ bits = Internal_GetScanLine(freeimage, dib, header.is_height-y-1, flipvert);
+ else
+ bits = Internal_GetScanLine(freeimage, dib, y, flipvert);
+
+ for (int x = 0; x < line; ) {
+ io.read_proc(&pixel, sizeof(WORD), 1, handle);
+
+ if (TARGA_LOAD_RGB888 & flags) {
+ bits[x + 0] = ((pixel & 0x1F) * 0xFF) / 0x1F;
+ bits[x + 1] = (((pixel & 0x3E0) >> 5) * 0xFF) / 0x1F;
+ bits[x + 2] = (((pixel & 0x7C00) >> 10) * 0xFF) / 0x1F;
+ } else {
+ *reinterpret_cast(bits + x) = 0x7FFF & pixel;
+ }
+
+ x += pixel_size;
+ }
+ }
+
+ break;
+ }
+
+ case 10 :
+ {
+ int x = 0;
+ int y = 0;
+ BYTE rle;
+ WORD pixel;
+
+ while(1) {
+ BYTE *bits;
+
+ if(fliphoriz)
+ bits = Internal_GetScanLine(freeimage, dib, header.is_height-y-1, flipvert);
+ else
+ bits = Internal_GetScanLine(freeimage, dib, y, flipvert);
+
+ io.read_proc(&rle,1, 1, handle);
+
+ // compressed block
+
+ if (rle > 127) {
+ rle -= 127;
+
+ io.read_proc(&pixel, sizeof(WORD), 1, handle);
+
+ for (int ix = 0; ix < rle; ix++) {
+ if (TARGA_LOAD_RGB888 & flags) {
+ bits[x + 0] = ((pixel & 0x1F) * 0xFF) / 0x1F;
+ bits[x + 1] = (((pixel & 0x3E0) >> 5) * 0xFF) / 0x1F;
+ bits[x + 2] = (((pixel & 0x7C00) >> 10) * 0xFF) / 0x1F;
+ } else {
+ *reinterpret_cast(bits + x) = 0x7FFF & pixel;
+ }
+
+ x += pixel_size;
+
+ if (x >= line) {
+ x = 0;
+ y++;
+
+ if (y >= header.is_height)
+ goto done2;
+ }
+ }
+ } else {
+ rle++;
+
+ for (int ix = 0; ix < rle; ix++) {
+ io.read_proc(&pixel, sizeof(WORD), 1, handle);
+
+ if (TARGA_LOAD_RGB888 & flags) {
+ bits[x + 0] = ((pixel & 0x1F) * 0xFF) / 0x1F;
+ bits[x + 1] = (((pixel & 0x3E0) >> 5) * 0xFF) / 0x1F;
+ bits[x + 2] = (((pixel & 0x7C00) >> 10) * 0xFF) / 0x1F;
+ } else {
+ *reinterpret_cast(bits + x) = 0x7FFF & pixel;
+ }
+
+ x += pixel_size;
+
+ if (x >= line) {
+ x = 0;
+ y++;
+
+ if (y >= header.is_height)
+ goto done2;
+ }
+ }
+ }
+ }
+
+ done2 :
+ break;
+ }
+
+ default :
+ freeimage.free_proc(dib);
+ return NULL;
+ }
+
+ break;
+ }
+
+ case 24 :
+ {
+ dib = freeimage.allocate_proc(header.is_width, header.is_height, 24, 0xFF, 0xFF00, 0xFF0000);
+
+ if (dib == 0)
+ throw "DIB allocation failed";
+
+ // read in the bitmap bits
+
+ switch (header.image_type) {
+ case 2 :
+ {
+ if (fliphoriz)
+ for (unsigned count = header.is_height; count > 0; count--) {
+ BYTE *bits = bits = Internal_GetScanLine(freeimage, dib, count-1, flipvert);
+
+ io.read_proc(bits, line, 1, handle);
+
+ bits += pitch;
+ }
+ else
+ for (unsigned count = 0; count < header.is_height; count++) {
+ BYTE *bits = bits = Internal_GetScanLine(freeimage, dib, count, flipvert);
+
+ io.read_proc(bits, line, 1, handle);
+
+ bits += pitch;
+ }
+
+ break;
+ }
+
+ case 10 :
+ {
+ int x = 0;
+ int y = 0;
+ BYTE rle;
+ BYTE *bits;
+
+ if(fliphoriz)
+ bits = Internal_GetScanLine(freeimage, dib, header.is_height-y-1, flipvert);
+ else
+ bits = Internal_GetScanLine(freeimage, dib, y, flipvert);
+
+ if (alphabits) {
+ while(1) {
+ io.read_proc(&rle,1, 1, handle);
+
+ if (rle>127) {
+ rle -= 127;
+
+ BGRAQUAD quad;
+
+ io.read_proc(&quad, sizeof(BGRAQUAD), 1, handle);
+
+ for (int ix = 0; ix < rle; ix++) {
+ bits[x++] = quad.bgraBlue;
+ bits[x++] = quad.bgraGreen;
+ bits[x++] = quad.bgraRed;
+ bits[x++] = quad.bgraAlpha;
+
+ if (x >= line) {
+ x = 0;
+ y++;
+
+ if (y >= header.is_height)
+ goto done243;
+
+ if(fliphoriz)
+ bits = Internal_GetScanLine(freeimage, dib, header.is_height-y-1, flipvert);
+ else
+ bits = Internal_GetScanLine(freeimage, dib, y, flipvert);
+ }
+ }
+ } else {
+ rle++;
+
+ for (int ix = 0; ix < rle; ix++) {
+ BGRAQUAD quad;
+
+ io.read_proc(&quad, sizeof(BGRAQUAD), 1, handle);
+
+ bits[x++] = quad.bgraBlue;
+ bits[x++] = quad.bgraGreen;
+ bits[x++] = quad.bgraRed;
+ bits[x++] = quad.bgraAlpha;
+
+ if (x >= line) {
+ x = 0;
+ y++;
+
+ if (y >= header.is_height)
+ goto done243;
+
+ if(fliphoriz)
+ bits = Internal_GetScanLine(freeimage, dib, header.is_height-y-1, flipvert);
+ else
+ bits = Internal_GetScanLine(freeimage, dib, y, flipvert);
+ }
+ }
+ }
+ }
+ } else {
+ while (1) {
+ io.read_proc(&rle,1, 1, handle);
+
+ if (rle>127) {
+ rle -= 127;
+
+ RGBTRIPLE triple;
+
+ io.read_proc(&triple, sizeof(RGBTRIPLE), 1, handle);
+
+ for (int ix = 0; ix < rle; ix++) {
+ bits[x++] = triple.rgbtBlue;
+ bits[x++] = triple.rgbtGreen;
+ bits[x++] = triple.rgbtRed;
+
+ if (x >= line) {
+ x = 0;
+ y++;
+
+ if (y >= header.is_height)
+ goto done243;
+
+ if(fliphoriz)
+ bits = Internal_GetScanLine(freeimage, dib, header.is_height-y-1, flipvert);
+ else
+ bits = Internal_GetScanLine(freeimage, dib, y, flipvert);
+ }
+ }
+ } else {
+ rle++;
+
+ for (int ix = 0; ix < rle; ix++) {
+ RGBTRIPLE triple;
+
+ io.read_proc(&triple, sizeof(RGBTRIPLE), 1, handle);
+
+ bits[x++] = triple.rgbtBlue;
+ bits[x++] = triple.rgbtGreen;
+ bits[x++] = triple.rgbtRed;
+
+ if (x >= line) {
+ x = 0;
+ y++;
+
+ if (y >= header.is_height)
+ goto done243;
+
+ if(fliphoriz)
+ bits = Internal_GetScanLine(freeimage, dib, header.is_height-y-1, flipvert);
+ else
+ bits = Internal_GetScanLine(freeimage, dib, y, flipvert);
+ }
+ }
+ }
+ }
+ }
+ done243 :
+ break;
+ }
+
+ default :
+ freeimage.free_proc(dib);
+ return NULL;
+ }
+
+ break;
+ }
+
+ case 32 :
+ {
+ int pixel_bits;
+
+ if (TARGA_LOAD_RGB888 & flags) {
+ pixel_bits = 24;
+
+ line = CalculateLine(header.is_width, pixel_bits);
+ pitch = CalculatePitch(line);
+ } else {
+ pixel_bits = 32;
+ }
+
+ const unsigned pixel_size = unsigned (pixel_bits) / 8;
+
+ // Allocate the DIB
+
+ dib = freeimage.allocate_proc(header.is_width, header.is_height, pixel_bits, 0xFF, 0xFF00, 0xFF0000);
+
+ if (dib == 0)
+ throw "DIB allocation failed";
+
+ // read in the bitmap bits
+
+ switch (header.image_type) {
+ case 2 :
+ {
+ // uncompressed
+
+ if (alphabits) {
+ if (fliphoriz)
+ for (unsigned count = header.is_height; count > 0; count--) {
+ BYTE *bits = bits = Internal_GetScanLine(freeimage, dib, count-1, flipvert);
+
+ for (unsigned cols = 0; cols < header.is_width; cols++) {
+ RGBQUAD rgb;
+
+ io.read_proc(&rgb, sizeof(RGBQUAD), 1, handle);
+
+ bits[0] = rgb.rgbBlue;
+ bits[1] = rgb.rgbGreen;
+ bits[2] = rgb.rgbRed;
+
+ if ((TARGA_LOAD_RGB888 & flags) != TARGA_LOAD_RGB888)
+ bits[3] = rgb.rgbReserved;
+
+ bits += pixel_size;
+ }
+ }
+ else
+ for (unsigned count = 0; count < header.is_height; count++) {
+ BYTE *bits = Internal_GetScanLine(freeimage, dib, count, flipvert);
+
+ for (unsigned cols = 0; cols < header.is_width; cols++) {
+ RGBQUAD rgb;
+
+ io.read_proc(&rgb, sizeof(RGBQUAD), 1, handle);
+
+ bits[0] = rgb.rgbBlue;
+ bits[1] = rgb.rgbGreen;
+ bits[2] = rgb.rgbRed;
+
+ if ((TARGA_LOAD_RGB888 & flags) != TARGA_LOAD_RGB888)
+ bits[3] = rgb.rgbReserved;
+
+ bits += pixel_size;
+ }
+ }
+
+ } else {
+ if (fliphoriz)
+ for (unsigned count = header.is_height; count > 0; count--) {
+ BYTE *bits;
+
+ if (fliphoriz)
+ bits = Internal_GetScanLine(freeimage, dib, header.is_height-count, flipvert);
+ else
+ bits = Internal_GetScanLine(freeimage, dib, count-1, flipvert);
+
+ for (unsigned cols = 0; cols < header.is_width; cols++) {
+ RGBQUAD rgb;
+
+ io.read_proc(&rgb, sizeof(RGBQUAD), 1, handle);
+
+ bits[0] = rgb.rgbBlue;
+ bits[1] = rgb.rgbGreen;
+ bits[2] = rgb.rgbRed;
+
+ if ((TARGA_LOAD_RGB888 & flags) != TARGA_LOAD_RGB888)
+ bits[3] = rgb.rgbReserved;
+
+ bits += pixel_size;
+ }
+ }
+ else
+ for (unsigned count = 0; count < header.is_height; count++) {
+ BYTE *bits;
+
+ if(fliphoriz)
+ bits = Internal_GetScanLine(freeimage, dib, header.is_height-count-1, flipvert);
+ else
+ bits = Internal_GetScanLine(freeimage, dib, count, flipvert);
+
+ for (unsigned cols = 0; cols < header.is_width; cols++) {
+ RGBQUAD rgb;
+
+ io.read_proc(&rgb, sizeof(RGBQUAD), 1, handle);
+
+ bits[0] = rgb.rgbBlue;
+ bits[1] = rgb.rgbGreen;
+ bits[2] = rgb.rgbRed;
+
+ if ((TARGA_LOAD_RGB888 & flags) != TARGA_LOAD_RGB888)
+ bits[3] = rgb.rgbReserved;
+
+ bits += pixel_size;
+ }
+ }
+ }
+
+ break;
+ }
+ case 10:
+ {
+ int x = 0;
+ int y = 0;
+ BYTE rle;
+ BYTE *bits;
+
+ if(fliphoriz)
+ bits = Internal_GetScanLine(freeimage, dib, header.is_height-y-1, flipvert);
+ else
+ bits = Internal_GetScanLine(freeimage, dib, y, flipvert);
+
+ while(1) {
+ io.read_proc(&rle,1, 1, handle);
+
+ if (rle>127) {
+ rle -= 127;
+
+ BGRAQUAD quad;
+
+ io.read_proc(&quad, sizeof(BGRAQUAD), 1, handle);
+
+ for (int ix = 0; ix < rle; ix++) {
+ bits[x++] = quad.bgraBlue;
+ bits[x++] = quad.bgraGreen;
+ bits[x++] = quad.bgraRed;
+ bits[x++] = quad.bgraAlpha;
+
+ if (x >= line) {
+ x = 0;
+ y++;
+
+ if (y >= header.is_height)
+ goto done3210;
+
+ if(fliphoriz)
+ bits = Internal_GetScanLine(freeimage, dib, header.is_height-y-1, flipvert);
+ else
+ bits = Internal_GetScanLine(freeimage, dib, y, flipvert);
+ }
+ }
+ } else {
+ rle++;
+
+ for (int ix = 0; ix < rle; ix++) {
+ BGRAQUAD quad;
+
+ io.read_proc(&quad, sizeof(BGRAQUAD), 1, handle);
+
+ bits[x++] = quad.bgraBlue;
+ bits[x++] = quad.bgraGreen;
+ bits[x++] = quad.bgraRed;
+ bits[x++] = quad.bgraAlpha;
+
+ if (x >= line) {
+ x = 0;
+ y++;
+
+ if (y >= header.is_height)
+ goto done3210;
+
+ if(fliphoriz)
+ bits = Internal_GetScanLine(freeimage, dib, header.is_height-y-1, flipvert);
+ else
+ bits = Internal_GetScanLine(freeimage, dib, y, flipvert);
+ }
+ }
+ }
+ }
+
+ done3210 :
+ break;
+ }
+
+ default :
+ freeimage.free_proc(dib);
+ return NULL;
+ }
+
+ break;
+ }
+ }
+
+ return (FIBITMAP *)dib;
+
+ } catch(char *message) {
+ freeimage.output_message_proc(s_format_id, message);
+
+ return NULL;
+ }
+ }
+
+ return NULL;
+}
+
+// ==========================================================
+// Init
+// ==========================================================
+
+void DLL_CALLCONV
+InitTARGA(Plugin &plugin, int format_id) {
+ s_format_id = format_id;
+
+ plugin.format_proc = Format;
+ plugin.description_proc = Description;
+ plugin.extension_proc = Extension;
+ plugin.regexpr_proc = RegExpr;
+ plugin.load_proc = Load;
+}
diff --git a/freeimage241/Source/FreeImage/PluginTIFF.cpp b/freeimage241/Source/FreeImage/PluginTIFF.cpp
new file mode 100644
index 0000000..f6d8736
--- /dev/null
+++ b/freeimage241/Source/FreeImage/PluginTIFF.cpp
@@ -0,0 +1,789 @@
+// ==========================================================
+// TIFF Loader and Writer
+//
+// Design and implementation by
+// - Floris van den Berg (flvdberg@wxs.nl)
+// - Hervé Drolon (drolon@iut.univ-lehavre.fr)
+// - Markus Loibl (markus.loibl@epost.de)
+// - Luca Piergentili (l.pierge@terra.es)
+//
+// This file is part of FreeImage 2
+//
+// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
+// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
+// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
+// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
+// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
+// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
+// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+// THIS DISCLAIMER.
+//
+// Use at your own risk!
+// ==========================================================
+
+#ifdef unix
+#undef unix
+#endif
+#ifdef __unix
+#undef __unix
+#endif
+
+#include "../LibTIFF/tiffiop.h"
+
+#include "FreeImage.h"
+#include "Utilities.h"
+
+// ----------------------------------------------------------
+
+static FreeImageIO *g_io = NULL;
+
+// ----------------------------------------------------------
+// libtiff interface
+// ----------------------------------------------------------
+
+static tsize_t
+_tiffReadProc(thandle_t file, tdata_t buf, tsize_t size) {
+ return g_io->read_proc(buf, size, 1, (fi_handle)file) * size;
+}
+
+static tsize_t
+_tiffWriteProc(thandle_t file, tdata_t buf, tsize_t size) {
+ return g_io->write_proc(buf, size, 1, (fi_handle)file) * size;
+}
+
+static toff_t
+_tiffSeekProc(thandle_t file, toff_t off, int whence) {
+ g_io->seek_proc((fi_handle)file, off, whence);
+ return g_io->tell_proc((fi_handle)file);
+}
+
+static int
+_tiffCloseProc(thandle_t fd) {
+ return 0;
+}
+
+#include
+
+static toff_t
+_tiffSizeProc(thandle_t file) {
+ struct stat sb;
+ return (fstat((int) file, &sb) < 0 ? 0 : sb.st_size);
+}
+
+static int
+_tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize) {
+ return 0;
+}
+
+static void
+_tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size) {
+}
+
+// ----------------------------------------------------------
+// Open a TIFF file descriptor for read/writing.
+// ----------------------------------------------------------
+
+TIFF *
+TIFFFdOpen(thandle_t handle, const char *name, const char *mode) {
+ TIFF *tif;
+
+ tif = TIFFClientOpen(name, mode, handle,
+ _tiffReadProc, _tiffWriteProc, _tiffSeekProc, _tiffCloseProc,
+ _tiffSizeProc, _tiffMapProc, _tiffUnmapProc);
+
+ if (tif)
+ tif->tif_fd = (int)handle;
+
+ return tif;
+}
+
+// ----------------------------------------------------------
+// Open a TIFF file for read/writing.
+// ----------------------------------------------------------
+
+TIFF*
+TIFFOpen(const char* name, const char* mode) {
+ return 0;
+}
+
+tdata_t
+_TIFFmalloc(tsize_t s) {
+ return malloc(s);
+}
+
+void
+_TIFFfree(tdata_t p) {
+ free(p);
+}
+
+tdata_t
+_TIFFrealloc(tdata_t p, tsize_t s) {
+ return realloc(p, s);
+}
+
+void
+_TIFFmemset(tdata_t p, int v, tsize_t c) {
+ memset(p, v, (size_t) c);
+}
+
+void
+_TIFFmemcpy(tdata_t d, const tdata_t s, tsize_t c) {
+ memcpy(d, s, (size_t) c);
+}
+
+int
+_TIFFmemcmp(const tdata_t p1, const tdata_t p2, tsize_t c) {
+ return (memcmp(p1, p2, (size_t) c));
+}
+
+// ----------------------------------------------------------
+// in FreeImage warnings and errors are disabled
+// ----------------------------------------------------------
+
+static void
+msdosWarningHandler(const char* module, const char* fmt, va_list ap) {
+}
+
+TIFFErrorHandler _TIFFwarningHandler = msdosWarningHandler;
+
+static void
+msdosErrorHandler(const char* module, const char* fmt, va_list ap) {
+}
+
+TIFFErrorHandler _TIFFerrorHandler = msdosErrorHandler;
+
+// ----------------------------------------------------------
+
+#define CVT(x) (((x) * 255L) / ((1L<<16)-1))
+#define SCALE(x) (((x)*((1L<<16)-1))/255)
+
+// ==========================================================
+// Internal functions
+// ==========================================================
+
+static uint16
+CheckColormap(int n, uint16* r, uint16* g, uint16* b) {
+ while (n-- > 0) {
+ if (*r++ >= 256 || *g++ >= 256 || *b++ >= 256) {
+ return 16;
+ }
+ }
+
+ return 8;
+}
+
+static uint16
+CheckPhotometric(FreeImage &freeimage, FIBITMAP *dib, uint16 bitspersample) {
+ RGBQUAD *rgb;
+ uint16 i;
+
+ switch(bitspersample) {
+ case 1:
+ {
+ rgb = freeimage.get_palette_proc(dib);
+
+ if ((rgb->rgbRed == 0) && (rgb->rgbGreen == 0) && (rgb->rgbBlue == 0)) {
+ rgb++;
+
+ if ((rgb->rgbRed == 255) && (rgb->rgbGreen == 255) && (rgb->rgbBlue == 255))
+ return PHOTOMETRIC_MINISBLACK;
+ }
+
+ if ((rgb->rgbRed == 255) && (rgb->rgbGreen == 255) && (rgb->rgbBlue == 255)) {
+ rgb++;
+
+ if ((rgb->rgbRed == 0) && (rgb->rgbGreen == 0) && (rgb->rgbBlue == 0))
+ return PHOTOMETRIC_MINISWHITE;
+ }
+
+ return PHOTOMETRIC_PALETTE;
+ }
+
+ case 4: // Check if the DIB has a color or a greyscale palette
+ case 8:
+ rgb = freeimage.get_palette_proc(dib);
+
+ for (i = 0; i < freeimage.get_colors_used_proc(dib); i++) {
+ if ((rgb->rgbRed != rgb->rgbGreen) || (rgb->rgbRed != rgb->rgbBlue))
+ return PHOTOMETRIC_PALETTE;
+
+ // The DIB has a color palette if the greyscale isn't a linear ramp
+
+ if (rgb->rgbRed != i)
+ return PHOTOMETRIC_PALETTE;
+
+ rgb++;
+ }
+
+ return PHOTOMETRIC_MINISBLACK;
+
+ case 24:
+ return PHOTOMETRIC_RGB;
+ }
+
+ return PHOTOMETRIC_MINISBLACK;
+}
+
+// ==========================================================
+// Plugin Interface
+// ==========================================================
+
+static int s_format_id;
+
+// ==========================================================
+// Plugin Implementation
+// ==========================================================
+
+static const char * DLL_CALLCONV
+Format() {
+ return "TIFF";
+}
+
+static const char * DLL_CALLCONV
+Description() {
+ return "Tagged Image File Format";
+}
+
+static const char * DLL_CALLCONV
+Extension() {
+ return "tif,tiff";
+}
+
+static const char * DLL_CALLCONV
+RegExpr() {
+ return "^[MI][MI][\\x01*][\\x01*]";
+}
+
+static const char * DLL_CALLCONV
+MimeType() {
+ return "image/tiff";
+}
+
+static BOOL DLL_CALLCONV
+Validate(FreeImageIO &io, fi_handle handle) {
+ BYTE tiff_id1[] = { 0x49, 0x49 };
+ BYTE tiff_id2[] = { 0x4D, 0x4D };
+ BYTE signature[2] = { 0, 0 };
+
+ io.read_proc(signature, 1, sizeof(tiff_id1), handle);
+
+ if (memcmp(tiff_id1, signature, sizeof(tiff_id1)) == 0)
+ return TRUE;
+
+ if (memcmp(tiff_id2, signature, sizeof(tiff_id1)) == 0)
+ return TRUE;
+
+ return FALSE;
+}
+
+// ----------------------------------------------------------
+
+static void * DLL_CALLCONV
+Open(FreeImageIO &io, fi_handle handle, BOOL read) {
+ g_io = &io;
+
+ if (read)
+ return TIFFFdOpen((thandle_t)handle, "", "r");
+ else
+ return TIFFFdOpen((thandle_t)handle, "", "w");
+}
+
+static void DLL_CALLCONV
+Close(FreeImageIO &io, fi_handle handle, void *data) {
+ TIFFClose((TIFF *)data);
+
+ g_io = NULL;
+}
+
+// ----------------------------------------------------------
+
+static int DLL_CALLCONV
+PageCount(FreeImageIO &io, fi_handle handle, void *data) {
+ int nr_ifd = 0;
+
+ TIFF *tif = (TIFF *)data;
+
+ do {
+ nr_ifd++;
+ } while (TIFFReadDirectory(tif));
+
+ return nr_ifd;
+}
+
+// ----------------------------------------------------------
+
+static FIBITMAP * DLL_CALLCONV
+Load(FreeImage &freeimage, FreeImageIO &io, fi_handle handle, int page, int flags, void *data) {
+ if ((handle != NULL) && (data != NULL)) {
+ TIFF *tif;
+ uint32 height;
+ uint32 width;
+ uint16 bitspersample;
+ uint16 samplesperpixel;
+ uint32 rowsperstrip;
+ uint16 photometric;
+ uint16 compression;
+ uint32 x, y;
+ BOOL isRGB;
+
+ int32 nrow;
+ BYTE *buf;
+ FIBITMAP *dib;
+ BYTE *bits; // pointer to dib data
+ RGBQUAD *pal; // pointer to dib palette
+
+ if (handle) {
+ try {
+ tif = (TIFF *)data;
+
+ if (page != -1)
+ if (!tif || !TIFFSetDirectory(tif, page))
+ throw "Error encountered while opening TIFF file";
+
+ TIFFGetField(tif, TIFFTAG_COMPRESSION, &compression);
+ TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &width);
+ TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &height);
+ TIFFGetField(tif, TIFFTAG_SAMPLESPERPIXEL, &samplesperpixel);
+ TIFFGetField(tif, TIFFTAG_BITSPERSAMPLE, &bitspersample);
+ TIFFGetField(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
+ TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &photometric);
+
+ if (compression == COMPRESSION_LZW)
+ throw "LZW compression is no longer supported due to Unisys patent enforcement";
+
+ // Convert to 24 or 32 bits RGB if the image is full color
+
+ isRGB = (bitspersample >= 8) &&
+ (photometric == PHOTOMETRIC_RGB) ||
+ (photometric == PHOTOMETRIC_YCBCR) ||
+ (photometric == PHOTOMETRIC_SEPARATED) ||
+ (photometric == PHOTOMETRIC_LOGLUV);
+
+ if (isRGB) {
+ // Read the whole image into one big RGBA buffer and then
+ // convert it to a DIB. This is using the traditional
+ // TIFFReadRGBAImage() API that we trust.
+
+ uint32* raster; // retrieve RGBA image
+ uint32 *row;
+
+ raster = (uint32*)_TIFFmalloc(width * height * sizeof (uint32));
+
+ if (raster == NULL) {
+ throw "No space for raster buffer";
+ }
+
+ // Read the image in one chunk into an RGBA array
+
+ if(!TIFFReadRGBAImage(tif, width, height, raster, 0)) {
+ _TIFFfree(raster);
+ return NULL;
+ }
+
+ // create a new DIB
+
+ if (samplesperpixel == 4)
+ dib = freeimage.allocate_proc(width, height, 32, 0xFF, 0xFF00, 0xFF0000);
+ else
+ dib = freeimage.allocate_proc(width, height, 24, 0xFF, 0xFF00, 0xFF0000);
+
+ if (dib == NULL) {
+ _TIFFfree(raster);
+
+ throw "DIB allocation failed";
+ }
+
+ // fill in the metrics (english or universal)
+
+ float fResX, fResY;
+ uint16 resUnit;
+ TIFFGetField(tif, TIFFTAG_RESOLUTIONUNIT, &resUnit);
+ TIFFGetField(tif, TIFFTAG_XRESOLUTION, &fResX);
+ TIFFGetField(tif, TIFFTAG_YRESOLUTION, &fResY);
+
+ BITMAPINFOHEADER *pInfoHeader = freeimage.get_info_header_proc(dib);
+
+ if (resUnit == RESUNIT_INCH) {
+ pInfoHeader->biXPelsPerMeter = (int) (fResX/0.0254000 + 0.5);
+ pInfoHeader->biYPelsPerMeter = (int) (fResY/0.0254000 + 0.5);
+ } else if(resUnit == RESUNIT_CENTIMETER) {
+ pInfoHeader->biXPelsPerMeter = (int) (fResX*100.0 + 0.5);
+ pInfoHeader->biYPelsPerMeter = (int) (fResY*100.0 + 0.5);
+ }
+
+ // read the raster lines and save them in the DIB
+ // with RGB mode, we have to change the order of the 3 samples RGB
+ // We use macros for extracting components from the packed ABGR
+ // form returned by TIFFReadRGBAImage.
+
+ BOOL has_alpha = FALSE;
+ row = &raster[0];
+
+ for (y = 0; y < height; y++) {
+ bits = freeimage.get_scanline_proc(dib, y);
+
+ for (x = 0; x < width; x++) {
+ bits[0] = (BYTE)TIFFGetB(row[x]);
+ bits[1] = (BYTE)TIFFGetG(row[x]);
+ bits[2] = (BYTE)TIFFGetR(row[x]);
+
+ if (samplesperpixel == 4) {
+ bits[3] = (BYTE)TIFFGetA(row[x]);
+
+ if (bits[3] != 0) {
+ has_alpha = TRUE;
+ }
+
+ bits += 4;
+ } else {
+ bits += 3;
+ }
+ }
+
+ row += width;
+ }
+
+ freeimage.set_transparent_proc(dib, has_alpha);
+
+ _TIFFfree(raster);
+
+ return (FIBITMAP *)dib;
+ } else {
+ // calculate the line + pitch
+
+ int line = CalculateLine(width, bitspersample * samplesperpixel);
+ int pitch = CalculatePitch(line);
+
+ // create a new DIB
+
+ dib = freeimage.allocate_proc(width, height, bitspersample * samplesperpixel);
+
+ if (dib == NULL) {
+ throw "No space for DIB image";
+ }
+
+ float fResX, fResY;
+ uint16 resUnit;
+ TIFFGetField(tif, TIFFTAG_RESOLUTIONUNIT, &resUnit);
+ TIFFGetField(tif, TIFFTAG_XRESOLUTION, &fResX);
+ TIFFGetField(tif, TIFFTAG_YRESOLUTION, &fResY);
+
+ BITMAPINFOHEADER *pInfoHeader = freeimage.get_info_header_proc(dib);
+
+ if (resUnit == RESUNIT_INCH) {
+ /* english */
+
+ pInfoHeader->biXPelsPerMeter = (int) (fResX/0.0254000 + 0.5);
+ pInfoHeader->biYPelsPerMeter = (int) (fResY/0.0254000 + 0.5);
+ } else if (resUnit== RESUNIT_CENTIMETER) {
+ /* metric */
+
+ pInfoHeader->biXPelsPerMeter = (int) (fResX*100.0 + 0.5);
+ pInfoHeader->biYPelsPerMeter = (int) (fResY*100.0 + 0.5);
+ }
+
+ // In the tiff file the lines are save from up to down
+ // In a DIB the lines must be save from down to up
+
+ bits = freeimage.get_bits_proc(dib) + height * pitch;
+
+ // now lpBits pointe on the bottom line
+
+ // set up the colormap based on photometric
+
+ pal = freeimage.get_palette_proc(dib);
+
+ switch(photometric) {
+ case PHOTOMETRIC_MINISBLACK: // bitmap and greyscale image types
+ case PHOTOMETRIC_MINISWHITE:
+ // Monochrome image
+
+ if (bitspersample == 1) {
+ if (photometric == PHOTOMETRIC_MINISBLACK) {
+ pal[0].rgbRed = 0;
+ pal[0].rgbGreen = 0;
+ pal[0].rgbBlue = 0;
+ pal[1].rgbRed = 255;
+ pal[1].rgbGreen = 255;
+ pal[1].rgbBlue = 255;
+ } else {
+ pal[0].rgbRed = 255;
+ pal[0].rgbGreen = 255;
+ pal[0].rgbBlue = 255;
+ pal[1].rgbRed = 0;
+ pal[1].rgbGreen = 0;
+ pal[1].rgbBlue = 0;
+ }
+ } else {
+ // need to build the scale for greyscale images
+
+ if (photometric == PHOTOMETRIC_MINISBLACK) {
+ for (int i = 0; i < 256; i++) {
+ pal[i].rgbRed =
+ pal[i].rgbGreen =
+ pal[i].rgbBlue = i;
+ }
+ } else {
+ for (int i = 0; i < 256; i++) {
+ pal[i].rgbRed =
+ pal[i].rgbGreen =
+ pal[i].rgbBlue = 255 - i;
+ }
+ }
+ }
+
+ break;
+
+ case PHOTOMETRIC_PALETTE: // color map indexed
+ uint16 *red;
+ uint16 *green;
+ uint16 *blue;
+ BOOL Palette16Bits;
+
+ TIFFGetField(tif, TIFFTAG_COLORMAP, &red, &green, &blue);
+
+ // Is the palette 16 or 8 bits ?
+
+ if (CheckColormap(1<= 0; i--) {
+ if (Palette16Bits) {
+ pal[i].rgbRed =(BYTE) CVT(red[i]);
+ pal[i].rgbGreen = (BYTE) CVT(green[i]);
+ pal[i].rgbBlue = (BYTE) CVT(blue[i]);
+ } else {
+ pal[i].rgbRed = (BYTE) red[i];
+ pal[i].rgbGreen = (BYTE) green[i];
+ pal[i].rgbBlue = (BYTE) blue[i];
+ }
+ }
+
+ break;
+
+ }
+
+ // read the tiff lines and save them in the DIB
+
+ buf = new BYTE[TIFFStripSize(tif)];
+
+ for (y = 0; y < height; y += rowsperstrip) {
+ nrow = (y + rowsperstrip > height ? height - y : rowsperstrip);
+
+ if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, y, 0), buf, nrow * line) == -1) {
+ delete [] buf;
+
+ return NULL;
+ } else {
+ for (int l = 0; l < nrow; l++) {
+ bits -= pitch;
+
+ memcpy(bits, buf + l * line, line);
+ }
+ }
+ }
+
+ delete [] buf;
+
+ return (FIBITMAP *)dib;
+
+ }
+ } catch (char *message) {
+ freeimage.output_message_proc(s_format_id, message);
+
+ return NULL;
+ }
+ }
+ }
+
+ return NULL;
+}
+
+static BOOL DLL_CALLCONV
+Save(FreeImage &freeimage, FreeImageIO &io, FIBITMAP *dib, fi_handle handle, int page, int flags, void *data) {
+ if (dib != NULL) {
+ TIFF *out = (TIFF *)data;
+
+ uint32 height;
+ uint32 width;
+ uint32 rowsperstrip = (uint32) -1;
+ uint16 bitspersample;
+ uint16 samplesperpixel;
+ uint16 photometric;
+ uint16 compression;
+ uint16 pitch;
+
+ uint32 x, y;
+
+ width = freeimage.get_width_proc(dib);
+ height = freeimage.get_height_proc(dib);
+ bitspersample = freeimage.get_bpp_proc(dib);
+ samplesperpixel = ((bitspersample == 24) || (bitspersample == 32)) ? 3 : 1;
+ photometric = CheckPhotometric(freeimage, dib, (bitspersample == 32) ? 24 : bitspersample);
+
+ // don't accept ALPHA at this moment
+
+ if ((bitspersample == 32) && (freeimage.is_transparent_proc(dib)))
+ throw "alpha channels are currently unsupported";
+
+ // handle standard width/height/bpp stuff
+
+ TIFFSetField(out, TIFFTAG_IMAGEWIDTH, width);
+ TIFFSetField(out, TIFFTAG_IMAGELENGTH, height);
+ TIFFSetField(out, TIFFTAG_SAMPLESPERPIXEL, samplesperpixel);
+ TIFFSetField(out, TIFFTAG_BITSPERSAMPLE, ((bitspersample == 32) ? 24 : bitspersample) / samplesperpixel);
+ TIFFSetField(out, TIFFTAG_PHOTOMETRIC, photometric);
+ TIFFSetField(out, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG); // single image plane
+ TIFFSetField(out, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
+ TIFFSetField(out, TIFFTAG_ROWSPERSTRIP, TIFFDefaultStripSize(out, rowsperstrip));
+
+ // handle metrics
+
+ BITMAPINFOHEADER *pInfoHeader = freeimage.get_info_header_proc(dib);
+ TIFFSetField(out, TIFFTAG_RESOLUTIONUNIT, RESUNIT_INCH);
+ TIFFSetField(out, TIFFTAG_XRESOLUTION, 0.0254*((float)pInfoHeader->biXPelsPerMeter));
+ TIFFSetField(out, TIFFTAG_YRESOLUTION, 0.0254*((float)pInfoHeader->biYPelsPerMeter));
+
+ // multi-paging
+
+ if (page >= 0) {
+ char page_number[20];
+ sprintf(page_number, "Page %d", page);
+
+ TIFFSetField(out, TIFFTAG_SUBFILETYPE, FILETYPE_PAGE);
+ TIFFSetField(out, TIFFTAG_PAGENUMBER, page);
+ TIFFSetField(out, TIFFTAG_PAGENAME, page_number);
+ } else {
+ TIFFSetField(out, TIFFTAG_SUBFILETYPE, 0);
+ }
+
+ // palettes (image colormaps are automatically scaled to 16-bits)
+
+ if (photometric == PHOTOMETRIC_PALETTE) {
+ uint16 *r, *g, *b;
+ uint16 nColors = freeimage.get_colors_used_proc(dib);
+ RGBQUAD *pal = freeimage.get_palette_proc(dib);
+
+ r = (uint16 *) _TIFFmalloc(sizeof(uint16) * 3 * nColors);
+ g = r + nColors;
+ b = g + nColors;
+
+ for (int i = nColors - 1; i >= 0; i--) {
+ r[i] = SCALE((uint16)pal[i].rgbRed);
+ g[i] = SCALE((uint16)pal[i].rgbGreen);
+ b[i] = SCALE((uint16)pal[i].rgbBlue);
+ }
+
+ TIFFSetField(out, TIFFTAG_COLORMAP, r, g, b);
+
+ _TIFFfree(r);
+ }
+
+ // compression
+
+ switch(bitspersample) {
+ case 1 :
+ compression = COMPRESSION_CCITTFAX4;
+ break;
+
+ case 8 :
+ case 24 :
+ case 32 :
+ compression = COMPRESSION_PACKBITS;
+ break;
+
+ default :
+ compression = COMPRESSION_NONE;
+ break;
+ }
+
+ TIFFSetField(out, TIFFTAG_COMPRESSION, compression);
+
+ // read the DIB lines from bottom to top
+ // and save them in the TIF
+ // -------------------------------------
+
+ pitch = freeimage.get_pitch_proc(dib);
+
+ switch(bitspersample) {
+ case 1 :
+ case 4 :
+ case 8 :
+ {
+ for (y = 0; y < height; y++) {
+ BYTE *bits = freeimage.get_bits_row_col_proc(dib, 0, y);
+
+ TIFFWriteScanline(out,bits, y, 0);
+ }
+
+ break;
+ }
+
+ case 24:
+ case 32 :
+ {
+ BYTE *buffer = (BYTE *)malloc(CalculatePitch(CalculateLine(width, 24)));
+
+ for (y = 0; y < height; y++) {
+ // get a pointer to the (converted) scanline
+
+ if (bitspersample == 32)
+ freeimage.convert_line_32to24_proc(buffer, freeimage.get_scanline_proc(dib, height - y - 1), width);
+ else
+ memcpy(buffer, freeimage.get_scanline_proc(dib, height - y - 1), pitch);
+
+ // TIFFs store color data RGB instead of BGR
+
+ BYTE *pBuf = buffer;
+
+ for (x = 0; x < width; x++) {
+ BYTE tmp = pBuf[0];
+ pBuf[0] = pBuf[2];
+ pBuf[2] = tmp;
+
+ pBuf += 3;
+ }
+
+ // write the scanline to disc
+
+ TIFFWriteScanline(out, buffer, y, 0);
+ }
+
+ free(buffer);
+
+ break;
+ }
+ }
+
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+// ==========================================================
+// Init
+// ==========================================================
+
+void DLL_CALLCONV
+InitTIFF(Plugin &plugin, int format_id) {
+ s_format_id = format_id;
+
+ plugin.format_proc = Format;
+ plugin.description_proc = Description;
+ plugin.extension_proc = Extension;
+ plugin.regexpr_proc = RegExpr;
+ plugin.open_proc = Open;
+ plugin.close_proc = Close;
+ plugin.pagecount_proc = PageCount;
+ plugin.load_proc = Load;
+ plugin.save_proc = Save;
+ plugin.validate_proc = Validate;
+ plugin.mime_proc = MimeType;
+}
diff --git a/freeimage241/Source/FreeImage/PluginWBMP.cpp b/freeimage241/Source/FreeImage/PluginWBMP.cpp
new file mode 100644
index 0000000..b46bc1d
--- /dev/null
+++ b/freeimage241/Source/FreeImage/PluginWBMP.cpp
@@ -0,0 +1,356 @@
+// ==========================================================
+// Wireless Bitmap Format Loader and Writer
+//
+// Design and implementation by
+// - Hervé Drolon
+//
+// This file is part of FreeImage 2
+//
+// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
+// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
+// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
+// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
+// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
+// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
+// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+// THIS DISCLAIMER.
+//
+// Use at your own risk!
+// ==========================================================
+
+#include "FreeImage.h"
+#include "Utilities.h"
+
+// ----------------------------------------------------------
+// Wireless Bitmap Format
+// ----------------------
+// The WBMP format enables graphical information to be sent to a variety of handsets.
+// The WBMP format is terminal independent and describes only graphical information.
+
+// IMPLEMENTATION NOTES:
+// ------------------------
+// The WBMP format is configured according to a type field value (TypeField below),
+// which maps to all relevant image encoding information, such as:
+// · Pixel organisation and encoding
+// · Palette organisation and encoding
+// · Compression characteristics
+// · Animation encoding
+// For each TypeField value, all relevant image characteristics are
+// fully specified as part of the WAP documentation.
+// Currently, a simple compact, monochrome image format is defined
+// within the WBMP type space :
+//
+// Image Type Identifier, multi-byte integer 0
+// Image Format description 0 B/W, no compression
+// -------------------------------------------------------------------------------
+
+// WBMP Header
+
+#ifdef WIN32
+#pragma pack(push, 1)
+#else
+#pragma pack(1)
+#endif
+
+typedef struct {
+ WORD TypeField; // Image type identifier of multi-byte length
+ BYTE FixHeaderField; // Octet of general header information
+ BYTE ExtHeaderFields; // Zero or more extension header fields
+ WORD Width; // Multi-byte width field
+ WORD Height; // Multi-byte height field
+} WBMPHEADER;
+
+#ifdef WIN32
+#pragma pack(pop)
+#else
+#pragma pack(4)
+#endif
+
+// The extension headers may be of type binary 00 through binary 11, defined as follows.
+
+// - Type 00 indicates a multi-byte bitfield used to specify additional header information.
+// The first bit is set if a type 00, extension header is set if more data follows.
+// The other bits are reserved for future use.
+// - Type 01 - reserved for future use.
+// - Type 10 - reserved for future use.
+// - Type 11 indicates a sequence of parameter/value pairs. These can be used for
+// optimisations and special purpose extensions, eg, animation image formats.
+// The parameter size tells the length (1-8 bytes) of the following parameter name.
+// The value size gives the length (1-16 bytes) of the following parameter value.
+// The concatenation flag indicates whether another parameter/value pair will follow
+// after reading the specified bytes of data.
+
+// ==========================================================
+// Internal functions
+// ==========================================================
+
+static DWORD
+multiByteRead(FreeImageIO &io, fi_handle handle) {
+ // Multi-byte encoding / decoding
+ // -------------------------------
+ // A multi-byte integer consists of a series of octets, where the most significant bit
+ // is the continuation flag, and the remaining seven bits are a scalar value.
+ // The continuation flag is used to indicate that an octet is not the end of the multi-byte
+ // sequence.
+
+ DWORD Out = 0;
+ BYTE In = 0;
+
+ while (io.read_proc(&In, 1, 1, handle)) {
+ Out += (In & 0x7F);
+
+ if ((In & 0x80) == 0x00) {
+ // Last byte to read
+
+ break;
+ }
+
+ Out <<= 7;
+ }
+
+ return Out;
+}
+
+static void
+multiByteWrite(FreeImageIO &io, fi_handle handle, DWORD In) {
+ BYTE Out, k = 1;
+
+ while(In & (0x7F << 7*k))
+ k++;
+
+ while(k > 1) {
+ k--;
+ Out = (BYTE)(0x80 | (In >> 7*k) & 0xFF);
+ io.write_proc(&Out, 1, 1, handle);
+ }
+
+ // Last byte to write
+
+ Out = (BYTE)(In & 0x7F);
+
+ io.write_proc(&Out, 1, 1, handle);
+}
+
+static void
+readExtHeader(FreeImageIO &io, fi_handle handle, BYTE b) {
+ // Extension header fields
+ // ------------------------
+ // Read the extension header fields
+ // (since we don't use them for the moment, we skip them).
+
+ switch(b & 0x60) {
+ // Type 00: read multi-byte bitfield
+
+ case 0x00:
+ {
+ DWORD info = multiByteRead(io, handle);
+ }
+ break;
+
+ // Type 11: read a sequence of parameter/value pairs.
+
+ case 0x60:
+ {
+ BYTE sizeParamIdent = (b & 0x70) >> 4; // Size of Parameter Identifier (in bytes)
+ BYTE sizeParamValue = (b & 0x0F); // Size of Parameter Value (in bytes)
+
+ BYTE *Ident = (BYTE*)malloc(sizeParamIdent * sizeof(BYTE));
+ BYTE *Value = (BYTE*)malloc(sizeParamValue * sizeof(BYTE));
+
+ io.read_proc(Ident, sizeParamIdent, 1, handle);
+ io.read_proc(Value, sizeParamValue, 1, handle);
+
+ free(Ident);
+ free(Value);
+ }
+
+ break;
+
+ // reserved for future use
+ case 0x20: // Type 01
+ case 0x40: // Type 10
+ break;
+ }
+}
+
+// ==========================================================
+// Plugin Interface
+// ==========================================================
+
+static int s_format_id;
+
+// ==========================================================
+// Plugin Implementation
+// ==========================================================
+
+static const char * DLL_CALLCONV
+Format() {
+ return "WBMP";
+}
+
+static const char * DLL_CALLCONV
+Description() {
+ return "Wireless Bitmap";
+}
+
+static const char * DLL_CALLCONV
+Extension() {
+ return "wbmp,wap";
+}
+
+static const char * DLL_CALLCONV
+RegExpr() {
+ return NULL;
+}
+
+static const char * DLL_CALLCONV
+MimeType() {
+ return "image/vnd.wap.wbmp";
+}
+
+// ----------------------------------------------------------
+
+static FIBITMAP * DLL_CALLCONV
+Load(FreeImage &freeimage, FreeImageIO &io, fi_handle handle, int page, int flags, void *dataa) {
+ WORD x, y, width, height;
+ FIBITMAP *dib;
+ BYTE *bits; // pointer to dib data
+ RGBQUAD *pal; // pointer to dib palette
+
+ WBMPHEADER header;
+
+ if(handle) {
+ try {
+ // Read header information
+ // -----------------------
+
+ // Type
+
+ header.TypeField = (WORD)multiByteRead(io, handle);
+
+ if (header.TypeField != 0)
+ throw "Unsupported WBMP type";
+
+ // FixHeaderField
+
+ io.read_proc(&header.FixHeaderField, 1, 1, handle);
+
+ // ExtHeaderFields
+ // 1 = More will follow, 0 = Last octet
+
+ if (header.FixHeaderField & 0x80) {
+ header.ExtHeaderFields = 0x80;
+
+ while(header.ExtHeaderFields & 0x80) {
+ io.read_proc(&header.ExtHeaderFields, 1, 1, handle);
+
+ readExtHeader(io, handle, header.ExtHeaderFields);
+ }
+ }
+
+ // Width & Height
+
+ width = (WORD)multiByteRead(io, handle);
+ height = (WORD)multiByteRead(io, handle);
+
+ // Allocate a new dib
+
+ dib = freeimage.allocate_proc(width, height, 1);
+
+ if (!dib) {
+ throw "DIB allocation failed";
+ }
+
+ // write the palette data
+
+ pal = freeimage.get_palette_proc(dib);
+ pal[0].rgbRed = pal[0].rgbGreen = pal[0].rgbBlue = 0;
+ pal[1].rgbRed = pal[1].rgbGreen = pal[1].rgbBlue = 255;
+
+ // read the bitmap data
+
+ int pitch = freeimage.get_pitch_proc(dib);
+ int line = freeimage.get_line_proc(dib);
+
+ for (y = 0; y < height; y++) {
+ bits = freeimage.get_scanline_proc(dib, height - 1 - y);
+
+ for (x = 0; x < line; x++) {
+ io.read_proc(&bits[x], 1, 1, handle);
+ }
+ }
+
+ return dib;
+
+ } catch(char *text) {
+ freeimage.output_message_proc(s_format_id, text);
+
+ return NULL;
+ }
+
+ }
+
+ return NULL;
+}
+
+static BOOL DLL_CALLCONV
+Save(FreeImage &freeimage, FreeImageIO &io, FIBITMAP *dib, fi_handle handle, int page, int flags, void *data) {
+ BYTE *bits; // pointer to dib data
+
+ if ((dib) && (handle)) {
+ try {
+ if (freeimage.get_bpp_proc(dib) != 1)
+ throw "Only 1-bit depth bitmaps can be saved as WBMP";
+
+ // Write the header
+
+ WBMPHEADER header;
+ header.TypeField = 0; // Type 0: B/W, no compression
+ header.FixHeaderField = 0; // No ExtHeaderField
+ header.Width = freeimage.get_width_proc(dib); // Image width
+ header.Height = freeimage.get_height_proc(dib); // Image height
+
+ multiByteWrite(io, handle, header.TypeField);
+
+ io.write_proc(&header.FixHeaderField, 1, 1, handle);
+
+ multiByteWrite(io, handle, header.Width);
+ multiByteWrite(io, handle, header.Height);
+
+ // write the bitmap data
+
+ WORD linelength = freeimage.get_line_proc(dib);
+
+ for (WORD y = 0; y < header.Height; y++) {
+ bits = freeimage.get_scanline_proc(dib, header.Height - 1 - y);
+
+ io.write_proc(&bits[0], linelength, 1, handle);
+ }
+
+ return TRUE;
+
+ } catch (char* text) {
+ freeimage.output_message_proc(s_format_id, text);
+ }
+ }
+
+ return FALSE;
+}
+
+// ==========================================================
+// Init
+// ==========================================================
+
+void DLL_CALLCONV
+InitWBMP(Plugin &plugin, int format_id) {
+ s_format_id = format_id;
+
+ plugin.format_proc = Format;
+ plugin.description_proc = Description;
+ plugin.extension_proc = Extension;
+ plugin.regexpr_proc = RegExpr;
+ plugin.load_proc = Load;
+ plugin.save_proc = Save;
+ plugin.mime_proc = MimeType;
+}
diff --git a/freeimage241/Source/FreeImage/WuQuantizer.cpp b/freeimage241/Source/FreeImage/WuQuantizer.cpp
new file mode 100644
index 0000000..74cf1d0
--- /dev/null
+++ b/freeimage241/Source/FreeImage/WuQuantizer.cpp
@@ -0,0 +1,530 @@
+///////////////////////////////////////////////////////////////////////
+// C Implementation of Wu's Color Quantizer (v. 2)
+// (see Graphics Gems vol. II, pp. 126-133)
+//
+// Author: Xiaolin Wu
+// Dept. of Computer Science
+// Univ. of Western Ontario
+// London, Ontario N6A 5B7
+// wu@csd.uwo.ca
+//
+// Algorithm: Greedy orthogonal bipartition of RGB space for variance
+// minimization aided by inclusion-exclusion tricks.
+// For speed no nearest neighbor search is done. Slightly
+// better performance can be expected by more sophisticated
+// but more expensive versions.
+//
+// The author thanks Tom Lane at Tom_Lane@G.GP.CS.CMU.EDU for much of
+// additional documentation and a cure to a previous bug.
+//
+// Free to distribute, comments and suggestions are appreciated.
+///////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////
+// History
+// -------
+// July 2000: C++ Implementation of Wu's Color Quantizer
+// and adaptation for the FreeImage 2 Library
+// Author: Hervé Drolon (drolon@iut.univ-lehavre.fr)
+///////////////////////////////////////////////////////////////////////
+
+#include
+#include
+
+#include "Quantizers.h"
+#include "FreeImage.h"
+
+///////////////////////////////////////////////////////////////////////
+
+// 3D array indexation
+
+#define INDEX(r, g, b) ((r << 10) + (r << 6) + r + (g << 5) + g + b)
+
+#define MAXCOLOR 256
+#define RED 2
+#define GREEN 1
+#define BLUE 0
+
+
+// Constructor / Destructor
+
+WuQuantizer::WuQuantizer(FIBITMAP *dib)
+{
+ width = FreeImage_GetWidth(dib);
+ height = FreeImage_GetHeight(dib);
+ pitch = FreeImage_GetPitch(dib);
+ m_dib = dib;
+
+ gm2 = NULL;
+ wt = mr = mg = mb = NULL;
+ Qadd = NULL;
+
+ // Allocate 3D arrays
+ gm2 = (float*)malloc(33 * 33 * 33 * sizeof(float));
+ wt = (int32*)malloc(33 * 33 * 33 * sizeof(int32));
+ mr = (int32*)malloc(33 * 33 * 33 * sizeof(int32));
+ mg = (int32*)malloc(33 * 33 * 33 * sizeof(int32));
+ mb = (int32*)malloc(33 * 33 * 33 * sizeof(int32));
+
+ // Allocate Qadd
+ Qadd = (uint16 *)malloc(sizeof(uint16) * width * height);
+
+ if(!gm2 || !wt || !mr || !mg || !mb || !Qadd)
+ {
+ if(gm2) free(gm2);
+ if(wt) free(wt);
+ if(mr) free(mr);
+ if(mg) free(mg);
+ if(mb) free(mb);
+ if(Qadd) free(Qadd);
+ throw "Not enough memory";
+ }
+ memset(gm2, 0, 35937 * sizeof(float));
+ memset(wt, 0, 35937 * sizeof(int32));
+ memset(mr, 0, 35937 * sizeof(int32));
+ memset(mg, 0, 35937 * sizeof(int32));
+ memset(mb, 0, 35937 * sizeof(int32));
+ memset(Qadd, 0, sizeof(uint16) * width * height);
+}
+
+WuQuantizer::~WuQuantizer()
+{
+ if(gm2) free(gm2);
+ if(wt) free(wt);
+ if(mr) free(mr);
+ if(mg) free(mg);
+ if(mb) free(mb);
+ if(Qadd) free(Qadd);
+}
+
+
+// Histogram is in elements 1..HISTSIZE along each axis,
+// element 0 is for base or marginal value
+// NB: these must start out 0!
+
+// Build 3-D color histogram of counts, r/g/b, c^2
+void WuQuantizer::Hist3D(int32 *vwt, int32 *vmr, int32 *vmg, int32 *vmb, float *m2)
+{
+ int ind;
+ int inr, ing, inb, table[256];
+ int i;
+ uint16 y, x;
+
+ for(i = 0; i < 256; i++)
+ table[i] = i * i;
+
+ for(y = 0; y < height; y++)
+ {
+ uint8 *bits = FreeImage_GetBits(m_dib) + (y * pitch);
+ for(x = 0; x < width; x++)
+ {
+ inr = (bits[2] >> 3) + 1;
+ ing = (bits[1] >> 3) + 1;
+ inb = (bits[0] >> 3) + 1;
+ Qadd[y*width + x] = ind = INDEX(inr, ing, inb);
+ // [inr][ing][inb]
+ vwt[ind]++;
+ vmr[ind] += bits[2];
+ vmg[ind] += bits[1];
+ vmb[ind] += bits[0];
+ m2[ind] += (float)(table[bits[2]] + table[bits[1]] + table[bits[0]]);
+ bits += 3;
+ }
+ }
+}
+
+
+// At conclusion of the histogram step, we can interpret
+// wt[r][g][b] = sum over voxel of P(c)
+// mr[r][g][b] = sum over voxel of r*P(c) , similarly for mg, mb
+// m2[r][g][b] = sum over voxel of c^2*P(c)
+// Actually each of these should be divided by 'ImageSize' to give the usual
+// interpretation of P() as ranging from 0 to 1, but we needn't do that here.
+
+
+// We now convert histogram into moments so that we can rapidly calculate
+// the sums of the above quantities over any desired box.
+
+// Compute cumulative moments
+void WuQuantizer::M3D(int32 *vwt, int32 *vmr, int32 *vmg, int32 *vmb, float *m2)
+{
+ uint16 ind1, ind2;
+ uint8 i, r, g, b;
+ int32 line, line_r, line_g, line_b;
+ int32 area[33], area_r[33], area_g[33], area_b[33];
+ float line2, area2[33];
+
+ for(r = 1; r <= 32; r++)
+ {
+ for(i = 0; i <= 32; i++)
+ {
+ area2[i] = 0;
+ area[i] = area_r[i] = area_g[i] = area_b[i] = 0;
+ }
+ for(g = 1; g <= 32; g++)
+ {
+ line2 = 0;
+ line = line_r = line_g = line_b = 0;
+ for(b = 1; b <= 32; b++)
+ {
+ ind1 = INDEX(r, g, b); // [r][g][b]
+ line += vwt[ind1];
+ line_r += vmr[ind1];
+ line_g += vmg[ind1];
+ line_b += vmb[ind1];
+ line2 += m2[ind1];
+ area[b] += line;
+ area_r[b] += line_r;
+ area_g[b] += line_g;
+ area_b[b] += line_b;
+ area2[b] += line2;
+ ind2 = ind1 - 1089; // [r-1][g][b]
+ vwt[ind1] = vwt[ind2] + area[b];
+ vmr[ind1] = vmr[ind2] + area_r[b];
+ vmg[ind1] = vmg[ind2] + area_g[b];
+ vmb[ind1] = vmb[ind2] + area_b[b];
+ m2[ind1] = m2[ind2] + area2[b];
+ }
+ }
+ }
+}
+
+// Compute sum over a box of any given statistic
+int32 WuQuantizer::Vol( Box *cube, int32 *mmt )
+{
+ return( mmt[INDEX(cube->r1, cube->g1, cube->b1)]
+ - mmt[INDEX(cube->r1, cube->g1, cube->b0)]
+ - mmt[INDEX(cube->r1, cube->g0, cube->b1)]
+ + mmt[INDEX(cube->r1, cube->g0, cube->b0)]
+ - mmt[INDEX(cube->r0, cube->g1, cube->b1)]
+ + mmt[INDEX(cube->r0, cube->g1, cube->b0)]
+ + mmt[INDEX(cube->r0, cube->g0, cube->b1)]
+ - mmt[INDEX(cube->r0, cube->g0, cube->b0)] );
+}
+
+// The next two routines allow a slightly more efficient calculation
+// of Vol() for a proposed subbox of a given box. The sum of Top()
+// and Bottom() is the Vol() of a subbox split in the given direction
+// and with the specified new upper bound.
+
+
+// Compute part of Vol(cube, mmt) that doesn't depend on r1, g1, or b1
+// (depending on dir)
+
+int32 WuQuantizer::Bottom(Box *cube, uint8 dir, int32 *mmt)
+{
+ switch(dir)
+ {
+ case RED:
+ return( - mmt[INDEX(cube->r0, cube->g1, cube->b1)]
+ + mmt[INDEX(cube->r0, cube->g1, cube->b0)]
+ + mmt[INDEX(cube->r0, cube->g0, cube->b1)]
+ - mmt[INDEX(cube->r0, cube->g0, cube->b0)] );
+ break;
+ case GREEN:
+ return( - mmt[INDEX(cube->r1, cube->g0, cube->b1)]
+ + mmt[INDEX(cube->r1, cube->g0, cube->b0)]
+ + mmt[INDEX(cube->r0, cube->g0, cube->b1)]
+ - mmt[INDEX(cube->r0, cube->g0, cube->b0)] );
+ break;
+ case BLUE:
+ return( - mmt[INDEX(cube->r1, cube->g1, cube->b0)]
+ + mmt[INDEX(cube->r1, cube->g0, cube->b0)]
+ + mmt[INDEX(cube->r0, cube->g1, cube->b0)]
+ - mmt[INDEX(cube->r0, cube->g0, cube->b0)] );
+ break;
+ }
+
+ return 0;
+}
+
+
+// Compute remainder of Vol(cube, mmt), substituting pos for
+// r1, g1, or b1 (depending on dir)
+
+int32 WuQuantizer::Top(Box *cube, uint8 dir, int pos, int32 *mmt)
+{
+ switch(dir)
+ {
+ case RED:
+ return( mmt[INDEX(pos, cube->g1, cube->b1)]
+ -mmt[INDEX(pos, cube->g1, cube->b0)]
+ -mmt[INDEX(pos, cube->g0, cube->b1)]
+ +mmt[INDEX(pos, cube->g0, cube->b0)] );
+ break;
+ case GREEN:
+ return( mmt[INDEX(cube->r1, pos, cube->b1)]
+ -mmt[INDEX(cube->r1, pos, cube->b0)]
+ -mmt[INDEX(cube->r0, pos, cube->b1)]
+ +mmt[INDEX(cube->r0, pos, cube->b0)] );
+ break;
+ case BLUE:
+ return( mmt[INDEX(cube->r1, cube->g1, pos)]
+ -mmt[INDEX(cube->r1, cube->g0, pos)]
+ -mmt[INDEX(cube->r0, cube->g1, pos)]
+ +mmt[INDEX(cube->r0, cube->g0, pos)] );
+ break;
+ }
+
+ return 0;
+}
+
+// Compute the weighted variance of a box
+// NB: as with the raw statistics, this is really the variance * ImageSize
+
+float
+WuQuantizer::Var(Box *cube) {
+ float dr = (float) Vol(cube, mr);
+ float dg = (float) Vol(cube, mg);
+ float db = (float) Vol(cube, mb);
+ float xx = gm2[INDEX(cube->r1, cube->g1, cube->b1)]
+ -gm2[INDEX(cube->r1, cube->g1, cube->b0)]
+ -gm2[INDEX(cube->r1, cube->g0, cube->b1)]
+ +gm2[INDEX(cube->r1, cube->g0, cube->b0)]
+ -gm2[INDEX(cube->r0, cube->g1, cube->b1)]
+ +gm2[INDEX(cube->r0, cube->g1, cube->b0)]
+ +gm2[INDEX(cube->r0, cube->g0, cube->b1)]
+ -gm2[INDEX(cube->r0, cube->g0, cube->b0)];
+
+ return (xx - (dr*dr+dg*dg+db*db)/(float)Vol(cube,wt));
+}
+
+// We want to minimize the sum of the variances of two subboxes.
+// The sum(c^2) terms can be ignored since their sum over both subboxes
+// is the same (the sum for the whole box) no matter where we split.
+// The remaining terms have a minus sign in the variance formula,
+// so we drop the minus sign and MAXIMIZE the sum of the two terms.
+
+float
+WuQuantizer::Maximize(Box *cube, uint8 dir, int first, int last , int *cut, int32 whole_r, int32 whole_g, int32 whole_b, int32 whole_w) {
+ int32 half_r, half_g, half_b, half_w;
+ int i;
+ float temp;
+
+ int32 base_r = Bottom(cube, dir, mr);
+ int32 base_g = Bottom(cube, dir, mg);
+ int32 base_b = Bottom(cube, dir, mb);
+ int32 base_w = Bottom(cube, dir, wt);
+
+ float max = 0.0;
+
+ *cut = -1;
+
+ for (i = first; i < last; i++) {
+ half_r = base_r + Top(cube, dir, i, mr);
+ half_g = base_g + Top(cube, dir, i, mg);
+ half_b = base_b + Top(cube, dir, i, mb);
+ half_w = base_w + Top(cube, dir, i, wt);
+
+ // now half_x is sum over lower half of box, if split at i
+
+ if (half_w == 0) { // subbox could be empty of pixels!
+ continue; // never split into an empty box
+ } else {
+ temp = ((float)half_r*half_r + (float)half_g*half_g + (float)half_b*half_b)/half_w;
+ }
+
+ half_r = whole_r - half_r;
+ half_g = whole_g - half_g;
+ half_b = whole_b - half_b;
+ half_w = whole_w - half_w;
+
+ if (half_w == 0) { // subbox could be empty of pixels!
+ continue; // never split into an empty box
+ } else {
+ temp += ((float)half_r*half_r + (float)half_g*half_g + (float)half_b*half_b)/half_w;
+ }
+
+ if (temp > max) {
+ max=temp;
+ *cut=i;
+ }
+ }
+
+ return max;
+}
+
+bool
+WuQuantizer::Cut(Box *set1, Box *set2) {
+ uint8 dir;
+ int cutr, cutg, cutb;
+
+ int32 whole_r = Vol(set1, mr);
+ int32 whole_g = Vol(set1, mg);
+ int32 whole_b = Vol(set1, mb);
+ int32 whole_w = Vol(set1, wt);
+
+ float maxr = Maximize(set1, RED, set1->r0+1, set1->r1, &cutr, whole_r, whole_g, whole_b, whole_w);
+ float maxg = Maximize(set1, GREEN, set1->g0+1, set1->g1, &cutg, whole_r, whole_g, whole_b, whole_w);
+ float maxb = Maximize(set1, BLUE, set1->b0+1, set1->b1, &cutb, whole_r, whole_g, whole_b, whole_w);
+
+ if ((maxr >= maxg) && (maxr >= maxb)) {
+ dir = RED;
+
+ if (cutr < 0) {
+ return false; // can't split the box
+ }
+ } else if ((maxg >= maxr) && (maxg>=maxb)) {
+ dir = GREEN;
+ } else {
+ dir = BLUE;
+ }
+
+ set2->r1 = set1->r1;
+ set2->g1 = set1->g1;
+ set2->b1 = set1->b1;
+
+ switch (dir) {
+ case RED:
+ set2->r0 = set1->r1 = cutr;
+ set2->g0 = set1->g0;
+ set2->b0 = set1->b0;
+ break;
+
+ case GREEN:
+ set2->g0 = set1->g1 = cutg;
+ set2->r0 = set1->r0;
+ set2->b0 = set1->b0;
+ break;
+
+ case BLUE:
+ set2->b0 = set1->b1 = cutb;
+ set2->r0 = set1->r0;
+ set2->g0 = set1->g0;
+ break;
+ }
+
+ set1->vol = (set1->r1-set1->r0)*(set1->g1-set1->g0)*(set1->b1-set1->b0);
+ set2->vol = (set2->r1-set2->r0)*(set2->g1-set2->g0)*(set2->b1-set2->b0);
+
+ return true;
+}
+
+
+void
+WuQuantizer::Mark(Box *cube, int label, uint8 *tag) {
+ for (int r = cube->r0 + 1; r <= cube->r1; r++) {
+ for (int g = cube->g0 + 1; g <= cube->g1; g++) {
+ for (int b = cube->b0 + 1; b <= cube->b1; b++) {
+ tag[INDEX(r, g, b)] = label;
+ }
+ }
+ }
+}
+
+// Wu Quantization algorithm
+
+FIBITMAP *
+WuQuantizer::Quantize() {
+ uint8 *tag = NULL;
+
+ try {
+ int PalSize = 256; // Color look-up table size
+ Box cube[MAXCOLOR];
+ int next;
+ int32 i, weight;
+ int k;
+ float vv[MAXCOLOR], temp;
+
+ // Compute 3D histogram
+
+ Hist3D(wt, mr, mg, mb, gm2);
+
+ // Compute moments
+
+ M3D(wt, mr, mg, mb, gm2);
+
+ cube[0].r0 = cube[0].g0 = cube[0].b0 = 0;
+ cube[0].r1 = cube[0].g1 = cube[0].b1 = 32;
+ next = 0;
+
+ for (i = 1; i < PalSize; i++) {
+ if(Cut(&cube[next], &cube[i])) {
+ // volume test ensures we won't try to cut one-cell box
+ vv[next] = (cube[next].vol > 1) ? Var(&cube[next]) : 0;
+ vv[i] = (cube[i].vol > 1) ? Var(&cube[i]) : 0;
+ } else {
+ vv[next] = 0.0; // don't try to split this box again
+ i--; // didn't create box i
+ }
+
+ next = 0; temp = vv[0];
+
+ for (k = 1; k <= i; k++) {
+ if (vv[k] > temp) {
+ temp = vv[k]; next = k;
+ }
+ }
+
+ if (temp <= 0.0) {
+ PalSize = i + 1;
+
+ // Error: "Only got 'PalSize' boxes"
+
+ break;
+ }
+ }
+
+ // Partition done
+
+ // the space for array gm2 can be freed now
+
+ free(gm2);
+
+ gm2 = NULL;
+
+ // Allocate a new dib
+
+ FIBITMAP *new_dib = FreeImage_Allocate(width, height, 8);
+
+ if (new_dib == NULL) {
+ throw "Not enough memory";
+ }
+
+ // create an optimized palette
+
+ RGBQUAD *new_pal = FreeImage_GetPalette(new_dib);
+
+ tag = (uint8*) malloc(33 * 33 * 33 * sizeof(uint8));
+
+ if (tag == NULL) {
+ throw "Not enough memory";
+ }
+
+ for (k = 0; k < PalSize; k++) {
+ Mark(&cube[k], k, tag);
+ weight = Vol(&cube[k], wt);
+
+ if (weight) {
+ new_pal[k].rgbRed = (uint8)(Vol(&cube[k], mr) / weight);
+ new_pal[k].rgbGreen = (uint8)(Vol(&cube[k], mg) / weight);
+ new_pal[k].rgbBlue = (uint8)(Vol(&cube[k], mb) / weight);
+ } else {
+ // Error: bogus box 'k'
+
+ new_pal[k].rgbRed = new_pal[k].rgbGreen = new_pal[k].rgbBlue = 0;
+ }
+ }
+
+ int npitch = FreeImage_GetPitch(new_dib);
+
+ for (uint16 y = 0; y < height; y++) {
+ uint8 *new_bits = FreeImage_GetBits(new_dib) + (y * npitch);
+
+ for (uint16 x = 0; x < width; x++) {
+ new_bits[x] = tag[Qadd[y*width + x]];
+ }
+ }
+
+ // output 'new_pal' as color look-up table contents,
+ // 'new_bits' as the quantized image (array of table addresses).
+
+ free(tag);
+
+ return (FIBITMAP*) new_dib;
+ } catch(...) {
+ free(tag);
+ }
+
+ return NULL;
+}
diff --git a/freeimage241/Source/FreeImageIO.h b/freeimage241/Source/FreeImageIO.h
new file mode 100644
index 0000000..b157427
--- /dev/null
+++ b/freeimage241/Source/FreeImageIO.h
@@ -0,0 +1,33 @@
+// ==========================================================
+// Input/Output functions
+//
+// Design and implementation by
+// - Floris van den Berg (flvdberg@wxs.nl)
+//
+// This file is part of FreeImage
+//
+// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
+// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
+// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
+// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
+// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
+// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
+// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+// THIS DISCLAIMER.
+//
+// Use at your own risk!
+// ==========================================================
+
+#ifndef FREEIMAGEIO_H
+#define FREEIMAGEIO_H
+
+#ifndef FREEIMAGE_H
+#include "FreeImage.h"
+#endif
+
+// ----------------------------------------------------------
+
+void SetDefaultIO(FreeImageIO *io);
+
+#endif // !FREEIMAGEIO_H
diff --git a/freeimage241/Source/FreeImageLib/FreeImageLib.dsp b/freeimage241/Source/FreeImageLib/FreeImageLib.dsp
new file mode 100644
index 0000000..28fccb8
--- /dev/null
+++ b/freeimage241/Source/FreeImageLib/FreeImageLib.dsp
@@ -0,0 +1,240 @@
+# Microsoft Developer Studio Project File - Name="FreeImageLib" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+CFG=FreeImageLib - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "FreeImageLib.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "FreeImageLib.mak" CFG="FreeImageLib - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "FreeImageLib - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "FreeImageLib - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "FreeImageLib - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
+# ADD CPP /nologo /G6 /Gd /MT /W3 /GX /O1 /I "..\\" /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
+# ADD BASE RSC /l 0x413 /d "NDEBUG"
+# ADD RSC /l 0x413 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:"Release\FreeImage.lib"
+
+!ELSEIF "$(CFG)" == "FreeImageLib - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
+# ADD CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /I "..\\" /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
+# ADD BASE RSC /l 0x413 /d "_DEBUG"
+# ADD RSC /l 0x413 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:"Debug\FreeImaged.lib"
+
+!ENDIF
+
+# Begin Target
+
+# Name "FreeImageLib - Win32 Release"
+# Name "FreeImageLib - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Group "Quantizers"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\FreeImage\NNQuantizer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FreeImage\WuQuantizer.cpp
+# End Source File
+# End Group
+# Begin Group "Conversion"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\FreeImage\Conversion.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FreeImage\Conversion16_555.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FreeImage\Conversion16_565.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FreeImage\Conversion24.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FreeImage\Conversion32.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FreeImage\Conversion8.cpp
+# End Source File
+# End Group
+# Begin Group "Plugins"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\FreeImage\Plugin.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FreeImage\PluginBMP.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FreeImage\PluginICO.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FreeImage\PluginIFF.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FreeImage\PluginJPEG.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FreeImage\PluginKOALA.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FreeImage\PluginMNG.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FreeImage\PluginPCD.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FreeImage\PluginPCX.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FreeImage\PluginPNG.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FreeImage\PluginPNM.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FreeImage\PluginPSD.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FreeImage\PluginRAS.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FreeImage\PluginTARGA.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FreeImage\PluginTIFF.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FreeImage\PluginWBMP.cpp
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=..\FreeImage\BitmapAccess.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FreeImage\FreeImage.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FreeImage\FreeImageIO.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FreeImage\GetType.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FreeImage\LoadFunctions.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=..\FreeImage.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\FreeImageIO.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Plugin.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Quantizers.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Utilities.h
+# End Source File
+# End Group
+# End Target
+# End Project
diff --git a/freeimage241/Source/FreeImageQt/FreeImageQt.cpp b/freeimage241/Source/FreeImageQt/FreeImageQt.cpp
new file mode 100644
index 0000000..2e66206
--- /dev/null
+++ b/freeimage241/Source/FreeImageQt/FreeImageQt.cpp
@@ -0,0 +1,714 @@
+// ==========================================================
+// FreeImage Qt
+//
+// Design and implementation by
+// - Floris van den Berg (flvdberg@wxs.nl)
+//
+// Based on tiffIO code written by Markus L. Noga
+//
+// This file is part of FreeImage 2
+//
+// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
+// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
+// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
+// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
+// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
+// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
+// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+// THIS DISCLAIMER.
+//
+// Use at your own risk!
+// ==========================================================
+
+#pragma warning(disable : 4541)
+
+#include
+
+#include
+#include
+#include
+#include
+#include
+
+#include "FreeImageQt.h"
+
+// ==========================================================
+
+#define DLL_CALLCONV __stdcall
+
+// For C compatility ----------------------------------------
+
+#ifdef __cplusplus
+#define FI_DEFAULT(x) = x
+#define FI_ENUM(x) enum x
+#define FI_STRUCT(x) struct x
+#else
+#define FI_DEFAULT(x)
+#define FI_ENUM(x) typedef int x; enum x
+#define FI_STRUCT(x) typedef struct x x; struct x
+#endif
+
+// File IO routines -----------------------------------------
+
+#ifndef FREEIMAGE_IO
+#define FREEIMAGE_IO
+
+#define fi_handle void*
+
+typedef unsigned (*FI_ReadProc) (void *buffer, unsigned size, unsigned count, fi_handle handle);
+typedef unsigned (*FI_WriteProc) (void *buffer, unsigned size, unsigned count, fi_handle handle);
+typedef int (*FI_SeekProc) (fi_handle handle, long offset, int origin);
+typedef long (*FI_TellProc) (fi_handle handle);
+
+#ifdef WIN32
+#pragma pack(push, 1)
+#else
+#pragma pack(1)
+#endif
+
+struct FreeImageIO {
+ FI_ReadProc read_proc; //! pointer to the function used to read data
+ FI_WriteProc write_proc; //! pointer to the function used to write data
+ FI_SeekProc seek_proc; //! pointer to the function used to seek
+ FI_TellProc tell_proc; //! pointer to the function used to aquire the current position
+};
+
+#ifdef WIN32
+#pragma pack(pop)
+#else
+#pragma pack(4)
+#endif
+
+#endif //!FREEIMAGE_IO
+
+// ----------------------------------------------------------
+// WINDOWS STUFF FOR DLL HANDLING
+// ----------------------------------------------------------
+
+static HMODULE s_library_handle;
+static bool s_library_loaded = false;
+
+// ----------------------------------------------------------
+// DLL FUNCTION DECLARATIONS
+// ----------------------------------------------------------
+
+typedef void (DLL_CALLCONV *FreeImage_SetOutputMessageProc)(FreeImage_OutputMessageFunction omf);
+typedef FIBITMAP *(DLL_CALLCONV *FreeImage_AllocateProc)(int width, int height, int bpp, int red_mask = 0, int green_mask = 0, int blue_mask = 0);
+typedef void (DLL_CALLCONV *FreeImage_UnloadProc)(FIBITMAP *dib);
+typedef int (DLL_CALLCONV *FreeImage_GetFIFCountProc)();
+typedef FREE_IMAGE_FORMAT (DLL_CALLCONV *FreeImage_GetFIFFromFormatProc)(const char *format);
+typedef const char * (DLL_CALLCONV *FreeImage_GetFormatFromFIFProc)(int id);
+typedef const char * (DLL_CALLCONV *FreeImage_GetFIFDescriptionProc)(int id);
+typedef const char * (DLL_CALLCONV *FreeImage_GetFIFRegExprProc)(int id);
+typedef const char * (DLL_CALLCONV *FreeImage_GetFIFExtensionListProc)(int id);
+typedef FREE_IMAGE_FORMAT (DLL_CALLCONV *FreeImage_GetFIFFromFilenameProc)(const char *filename);
+typedef BOOL (DLL_CALLCONV *FreeImage_FIFSupportsReadingProc)(FREE_IMAGE_FORMAT id);
+typedef BOOL (DLL_CALLCONV *FreeImage_FIFSupportsWritingProc)(FREE_IMAGE_FORMAT id);
+typedef FIBITMAP * (DLL_CALLCONV *FreeImage_LoadFromHandleProc)(FREE_IMAGE_FORMAT fif, FreeImageIO *io, fi_handle handle, int flags = 0);
+typedef BOOL (DLL_CALLCONV *FreeImage_SaveToHandleProc)(FREE_IMAGE_FORMAT fif, FIBITMAP *dib, FreeImageIO *io, fi_handle handle, int flags = 0);
+typedef unsigned (DLL_CALLCONV *FreeImage_GetHeightProc) (FIBITMAP *dib);
+typedef unsigned (DLL_CALLCONV *FreeImage_GetWidthProc) (FIBITMAP *dib);
+typedef unsigned (DLL_CALLCONV *FreeImage_GetBPPProc) (FIBITMAP *dib);
+typedef unsigned (DLL_CALLCONV *FreeImage_GetDotsPerMeterXProc) (FIBITMAP *dib);
+typedef unsigned (DLL_CALLCONV *FreeImage_GetDotsPerMeterYProc) (FIBITMAP *dib);
+typedef unsigned (DLL_CALLCONV *FreeImage_GetTransparencyCountProc) (FIBITMAP *dib);
+typedef unsigned (DLL_CALLCONV *FreeImage_GetColorsUsedProc)(FIBITMAP *dib);
+typedef unsigned (DLL_CALLCONV *FreeImage_GetPitchProc)(FIBITMAP *dib);
+typedef unsigned (DLL_CALLCONV *FreeImage_GetRedMaskProc)(FIBITMAP *dib);
+typedef unsigned (DLL_CALLCONV *FreeImage_GetGreenMaskProc)(FIBITMAP *dib);
+typedef unsigned (DLL_CALLCONV *FreeImage_GetBlueMaskProc)(FIBITMAP *dib);
+typedef const char *(DLL_CALLCONV *FreeImage_GetVersionProc)();
+typedef const char *(DLL_CALLCONV *FreeImage_GetCopyrightMessageProc)();
+typedef FREE_IMAGE_FORMAT (DLL_CALLCONV *FreeImage_GetFileTypeFromHandleProc)(FreeImageIO *io, fi_handle handle, int size);
+typedef void (DLL_CALLCONV *FreeImage_SetTransparentProc) (FIBITMAP *dib, BOOL enable);
+typedef BOOL (DLL_CALLCONV *FreeImage_IsTransparentProc) (FIBITMAP *dib);
+typedef BYTE *(DLL_CALLCONV *FreeImage_GetScanLineProc) (FIBITMAP *dib, int scanline);
+typedef BYTE *(DLL_CALLCONV *FreeImage_GetTransparencyTableProc) (FIBITMAP *dib);
+typedef RGBQUAD *(DLL_CALLCONV *FreeImage_GetPaletteProc)(FIBITMAP *dib);
+typedef BITMAPINFOHEADER *(DLL_CALLCONV *FreeImage_GetInfoHeaderProc) (FIBITMAP *dib);
+typedef void (DLL_CALLCONV *FreeImage_ConvertLine16To32_555Proc)(BYTE *target, BYTE *source, int width_in_pixels);
+typedef void (DLL_CALLCONV *FreeImage_ConvertLine16To32_565Proc)(BYTE *target, BYTE *source, int width_in_pixels);
+typedef void (DLL_CALLCONV *FreeImage_ConvertLine4To8Proc) (BYTE *target, BYTE *source, int width_in_pixels);
+typedef void (DLL_CALLCONV *FreeImage_ConvertLine24To32Proc) (BYTE *target, BYTE *source, int width_in_pixels);
+typedef void (DLL_CALLCONV *FreeImage_ConvertLine32To24Proc) (BYTE *target, BYTE *source, int width_in_pixels);
+
+// ----------------------------------------------------------
+// DLL FUNCTION ÍNSTANTIATONS
+// ----------------------------------------------------------
+
+FreeImage_SetOutputMessageProc FI_SetOutputMessageProc;
+FreeImage_AllocateProc FI_AllocateProc;
+FreeImage_UnloadProc FI_UnloadProc;
+FreeImage_GetFIFCountProc FI_GetFIFCountProc;
+FreeImage_GetFIFFromFormatProc FI_GetFIFFromFormatProc;
+FreeImage_GetFormatFromFIFProc FI_GetFormatFromFIFProc;
+FreeImage_GetFIFDescriptionProc FI_GetFIFDescriptionProc;
+FreeImage_GetFIFRegExprProc FI_GetFIFRegExprProc;
+FreeImage_GetFIFExtensionListProc FI_GetFIFExtensionListProc;
+FreeImage_GetFIFFromFilenameProc FI_GetFIFFromFilenameProc;
+FreeImage_FIFSupportsReadingProc FI_FIFSupportsReadingProc;
+FreeImage_FIFSupportsWritingProc FI_FIFSupportsWritingProc;
+FreeImage_LoadFromHandleProc FI_LoadFromHandleProc;
+FreeImage_SaveToHandleProc FI_SaveToHandleProc;
+FreeImage_GetHeightProc FI_GetHeightProc;
+FreeImage_GetWidthProc FI_GetWidthProc;
+FreeImage_GetBPPProc FI_GetBPPProc;
+FreeImage_GetDotsPerMeterXProc FI_GetDotsPerMeterXProc;
+FreeImage_GetDotsPerMeterYProc FI_GetDotsPerMeterYProc;
+FreeImage_SetTransparentProc FI_SetTransparentProc;
+FreeImage_IsTransparentProc FI_IsTransparentProc;
+FreeImage_GetTransparencyCountProc FI_GetTransparencyCountProc;
+FreeImage_GetColorsUsedProc FI_GetColorsUsedProc;
+FreeImage_GetPitchProc FI_GetPitchProc;
+FreeImage_GetRedMaskProc FI_GetRedMaskProc;
+FreeImage_GetGreenMaskProc FI_GetGreenMaskProc;
+FreeImage_GetBlueMaskProc FI_GetBlueMaskProc;
+FreeImage_GetVersionProc FI_GetVersionProc;
+FreeImage_GetCopyrightMessageProc FI_GetCopyrightMessageProc;
+FreeImage_GetFileTypeFromHandleProc FI_GetFileTypeFromHandleProc;
+FreeImage_GetScanLineProc FI_GetScanLineProc;
+FreeImage_GetTransparencyTableProc FI_GetTransparencyTableProc;
+FreeImage_GetPaletteProc FI_GetPaletteProc;
+FreeImage_GetInfoHeaderProc FI_GetInfoHeaderProc;
+FreeImage_ConvertLine4To8Proc FI_ConvertLine4To8Proc;
+FreeImage_ConvertLine16To32_555Proc FI_ConvertLine16To32_555Proc;
+FreeImage_ConvertLine16To32_565Proc FI_ConvertLine16To32_565Proc;
+FreeImage_ConvertLine24To32Proc FI_ConvertLine24To32Proc;
+FreeImage_ConvertLine32To24Proc FI_ConvertLine32To24Proc;
+
+// ----------------------------------------------------------
+// INTERNAL QT BITMAP HANDLING FUNCTIONS
+// ----------------------------------------------------------
+
+BOOL
+FormatSupportedByQt(QStrList &list, const char *format) {
+ for (const char *qtformat = list.first(); qtformat != 0; qtformat = list.next()) {
+ if (stricmp(format, qtformat) == 0)
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+unsigned
+GetDotsPerMeterX(FIBITMAP *dib) {
+ return (FI_GetDotsPerMeterXProc != NULL) ? FI_GetDotsPerMeterXProc(dib) : 0;
+}
+
+unsigned
+GetDotsPerMeterY(FIBITMAP *dib) {
+ return (FI_GetDotsPerMeterYProc != NULL) ? FI_GetDotsPerMeterYProc(dib) : 0;
+}
+
+// ----------------------------------------------------------
+// FREEIMAGEIO FUNCTIONS SUITABLE FOR USE WITH QIODEVICE
+// ----------------------------------------------------------
+
+inline unsigned
+_ReadProc(void *buffer, unsigned size, unsigned count, fi_handle handle) {
+ char *b = static_cast(buffer);
+
+ for (unsigned c = 0; c < count; c++) {
+ QIODevice *iod = static_cast(handle);
+
+ iod->readBlock(b, size);
+
+ b += size;
+ }
+
+ return count;
+}
+
+inline unsigned
+_WriteProc(void *buffer, unsigned size, unsigned count, fi_handle handle) {
+ char *b = static_cast(buffer);
+
+ for (unsigned c = 0; c < count; c++) {
+ QIODevice *iod = static_cast(handle);
+
+ iod->writeBlock(b, size);
+
+ b += size;
+ }
+
+ return count;
+}
+
+inline int
+_SeekProc(fi_handle handle, long offset, int origin) {
+ QIODevice *iod = static_cast(handle);
+
+ switch(origin) {
+ case SEEK_SET :
+ iod->at(offset);
+ break;
+
+ case SEEK_CUR :
+ iod->at(iod->at() + offset);
+ break;
+
+ default :
+ return 1;
+ }
+
+ return 0;
+}
+
+inline long
+_TellProc(fi_handle handle) {
+ QIODevice *iod = static_cast(handle);
+
+ return iod->at();
+}
+
+// ----------------------------------------------------------
+// PLUGIN INTERFACE
+// ----------------------------------------------------------
+
+int
+FIQT_GetFIFCount() {
+ return (FI_GetFIFCountProc != NULL) ? FI_GetFIFCountProc() : 0;
+}
+
+FREE_IMAGE_FORMAT
+FIQT_GetFIFFromFormat(const char *format) {
+ return (FI_GetFIFFromFormatProc != NULL) ? FI_GetFIFFromFormatProc(format) : FIF_UNKNOWN;
+}
+
+const char *
+FIQT_GetFormatFromFIF(FREE_IMAGE_FORMAT id) {
+ return (FI_GetFormatFromFIFProc != NULL) ? FI_GetFormatFromFIFProc(id) : NULL;
+}
+
+const char *
+FIQT_GetFIFDescription(FREE_IMAGE_FORMAT id) {
+ return (FI_GetFIFDescriptionProc != NULL) ? FI_GetFIFDescriptionProc(id) : NULL;
+}
+
+const char *
+FIQT_GetFIFExtensionList(FREE_IMAGE_FORMAT id) {
+ return (FI_GetFIFExtensionListProc != NULL) ? FI_GetFIFExtensionListProc(id) : NULL;
+}
+
+bool
+FIQT_FIFSupportsReading(FREE_IMAGE_FORMAT id) {
+ return (FI_FIFSupportsReadingProc != NULL) ? FI_FIFSupportsReadingProc(id) : false;
+}
+
+bool
+FIQT_FIFSupportsWriting(FREE_IMAGE_FORMAT id) {
+ return (FI_FIFSupportsWritingProc != NULL) ? FI_FIFSupportsWritingProc(id) : false;
+}
+
+FREE_IMAGE_FORMAT
+FIQT_GetFIFFromFilename(const char *filename) {
+ return (FI_GetFIFFromFilenameProc != NULL) ? FI_GetFIFFromFilenameProc(filename) : FIF_UNKNOWN;
+}
+
+const char *
+FIQT_GetFileTypeFromFormat(FREE_IMAGE_FORMAT fif) {
+ return FIQT_GetFormatFromFIF(fif);
+}
+
+const char *
+FIQT_GetFileTypeFromExtension(const char *format) {
+ FREE_IMAGE_FORMAT fif = FIQT_GetFIFFromFilename(format);
+
+ return (fif != FIF_UNKNOWN) ? FIQT_GetFormatFromFIF(fif) : NULL;
+}
+
+FREE_IMAGE_FORMAT
+FIQT_GetFileTypeFromHandle(FreeImageIO *io, fi_handle handle, int size) {
+ return (FI_GetFileTypeFromHandleProc != NULL) ? FI_GetFileTypeFromHandleProc(io, handle, size) : FIF_UNKNOWN;
+}
+
+// ----------------------------------------------------------
+// LOAD/SAVE FUNCTIONS
+// ----------------------------------------------------------
+
+static void
+FIQT_Load(QImageIO *iio) {
+ FreeImageIO io;
+
+ io.read_proc = _ReadProc;
+ io.seek_proc = _SeekProc;
+ io.tell_proc = _TellProc;
+ io.write_proc = _WriteProc;
+
+ // because we don't always receive the format string here, we need to do some of our own investigation...
+ // first try to identify the image by looking at the filename/extension
+
+ FREE_IMAGE_FORMAT fif = FIQT_GetFIFFromFilename(iio->format());
+
+ if (fif == FIF_UNKNOWN) {
+ // format id based image lookup failed... try to identify the bitmap by looking at the header
+
+ fif = FIQT_GetFileTypeFromHandle(&io, (fi_handle)iio->ioDevice(), 16);
+
+ if (fif == FIF_UNKNOWN) {
+ // failed again... look at the complete filename as a last resort
+
+ if (!iio->fileName().isEmpty()) {
+ fif = FIQT_GetFIFFromFilename(iio->fileName());
+
+ if (fif == FIF_UNKNOWN) {
+ iio->setStatus(-1);
+ return;
+ }
+ } else {
+ iio->setStatus(-1);
+ return;
+ }
+ }
+ }
+
+ assert(fif != FIF_UNKNOWN);
+
+ // if we come here, we have a valid FIF id
+
+ if (FI_FIFSupportsReadingProc(fif)) {
+ FIBITMAP *bitmap = FI_LoadFromHandleProc(fif, &io, (fi_handle)iio->ioDevice(), 0);
+
+ if (bitmap != NULL) {
+ QImage image;
+
+ switch(FI_GetBPPProc(bitmap)) {
+ case 1 :
+ image.create(FI_GetWidthProc(bitmap), FI_GetHeightProc(bitmap), 1, FI_GetColorsUsedProc(bitmap), QImage::BigEndian);
+ break;
+
+ case 4 :
+ image.create(FI_GetWidthProc(bitmap), FI_GetHeightProc(bitmap), 8, 256);
+ break;
+
+ case 16 :
+ case 24 :
+ image.create(FI_GetWidthProc(bitmap), FI_GetHeightProc(bitmap), 32, 0);
+ break;
+
+ default :
+ image.create(FI_GetWidthProc(bitmap), FI_GetHeightProc(bitmap), FI_GetBPPProc(bitmap), FI_GetColorsUsedProc(bitmap));
+ break;
+ }
+
+ // set metrics data
+
+ image.setDotsPerMeterX(GetDotsPerMeterX(bitmap));
+ image.setDotsPerMeterY(GetDotsPerMeterY(bitmap));
+
+ // if there is a palette, copy it
+
+ if (FI_IsTransparentProc(bitmap)) {
+ image.setAlphaBuffer(TRUE);
+
+ if (FI_GetBPPProc(bitmap) < 16) {
+ RGBQUAD *palette = FI_GetPaletteProc(bitmap);
+ BYTE *trans_table = FI_GetTransparencyTableProc(bitmap);
+
+ unsigned i;
+
+ for (i = 0; i < FI_GetTransparencyCountProc(bitmap); ++i) {
+ image.setColor(i, qRgba(palette[i].rgbRed, palette[i].rgbGreen, palette[i].rgbBlue, trans_table[i]));
+ }
+
+ for (; i < FI_GetColorsUsedProc(bitmap); ++i) {
+ image.setColor(i, qRgba(palette[i].rgbRed, palette[i].rgbGreen, palette[i].rgbBlue, 0xff));
+ }
+ }
+ } else {
+ image.setAlphaBuffer(FALSE);
+
+ if (FI_GetBPPProc(bitmap) < 16) {
+ RGBQUAD *palette = FI_GetPaletteProc(bitmap);
+
+ for (unsigned i = 0; i < FI_GetColorsUsedProc(bitmap); ++i) {
+ image.setColor(i, qRgb(palette[i].rgbRed, palette[i].rgbGreen, palette[i].rgbBlue));
+ }
+ }
+ }
+
+ // copy the bitmap data and convert if neccesary
+
+ for (unsigned y = 0; y < FI_GetHeightProc(bitmap); y++) {
+ if (FI_GetBPPProc(bitmap) == 4) {
+ FI_ConvertLine4To8Proc(image.scanLine(FI_GetHeightProc(bitmap) - 1 - y), FI_GetScanLineProc(bitmap, y), FI_GetWidthProc(bitmap));
+ } else if (FI_GetBPPProc(bitmap) == 16) {
+ if ((FI_GetRedMaskProc(bitmap) == 0x1F) && (FI_GetGreenMaskProc(bitmap) == 0x3E0) && (FI_GetBlueMaskProc(bitmap) == 0x7C00)) {
+ FI_ConvertLine16To32_555Proc(image.scanLine(FI_GetHeightProc(bitmap) - 1 - y), FI_GetScanLineProc(bitmap, y), FI_GetWidthProc(bitmap));
+ } else {
+ FI_ConvertLine16To32_565Proc(image.scanLine(FI_GetHeightProc(bitmap) - 1 - y), FI_GetScanLineProc(bitmap, y), FI_GetWidthProc(bitmap));
+ }
+ } else if (FI_GetBPPProc(bitmap) == 24) {
+ FI_ConvertLine24To32Proc(image.scanLine(FI_GetHeightProc(bitmap) - 1 - y), FI_GetScanLineProc(bitmap, y), FI_GetWidthProc(bitmap));
+ } else {
+ memcpy(image.scanLine(FI_GetHeightProc(bitmap) - y - 1), FI_GetScanLineProc(bitmap, y), FI_GetPitchProc(bitmap));
+ }
+ }
+
+ iio->setImage(image);
+ iio->setStatus(0);
+
+ FI_UnloadProc(bitmap);
+
+ return;
+ }
+ }
+
+ iio->setStatus(-1);
+}
+
+static void
+FIQT_Save(QImageIO *iio) {
+ FreeImageIO io;
+
+ io.read_proc = _ReadProc;
+ io.seek_proc = _SeekProc;
+ io.tell_proc = _TellProc;
+ io.write_proc = _WriteProc;
+
+ // get the save pointer for the needed bitmap format
+
+ FREE_IMAGE_FORMAT fif = FIQT_GetFIFFromFilename(iio->format());
+
+ if (fif != FIF_UNKNOWN) {
+ if (FIQT_FIFSupportsWriting(fif)) {
+ FIBITMAP *bitmap;
+
+ switch(fif) {
+ case FIF_BMP :
+ if ((!iio->image().hasAlphaBuffer()) && (iio->image().depth() == 32)) {
+ bitmap = FI_AllocateProc(iio->image().width(), iio->image().height(), 24);
+ } else {
+ bitmap = FI_AllocateProc(iio->image().width(), iio->image().height(), iio->image().depth());
+ }
+
+ break;
+
+ case FIF_JPEG :
+ if (iio->image().depth() == 32) {
+ bitmap = FI_AllocateProc(iio->image().width(), iio->image().height(), 24);
+ } else {
+ bitmap = FI_AllocateProc(iio->image().width(), iio->image().height(), iio->image().depth());
+ }
+
+ break;
+
+ default :
+ bitmap = FI_AllocateProc(iio->image().width(), iio->image().height(), iio->image().depth());
+ break;
+ };
+
+ // enable alpha channels in the DIB when we must
+
+ if (iio->image().hasAlphaBuffer()) {
+ FI_SetTransparentProc(bitmap, TRUE);
+ } else {
+ FI_SetTransparentProc(bitmap, FALSE);
+ }
+
+ // copy the palette
+
+ RGBQUAD *palette = FI_GetPaletteProc(bitmap);
+ QRgb *colorTable = iio->image().colorTable();
+
+ for (int i = 0; i < iio->image().numColors(); ++i) {
+ palette[i].rgbBlue = qBlue(colorTable[i]);
+ palette[i].rgbGreen = qGreen(colorTable[i]);
+ palette[i].rgbRed = qRed(colorTable[i]);
+ }
+
+ // copy the metrics data
+
+ BITMAPINFOHEADER *header = FI_GetInfoHeaderProc(bitmap);
+ header->biXPelsPerMeter = iio->image().dotsPerMeterX();
+ header->biYPelsPerMeter = iio->image().dotsPerMeterY();
+
+ // copy the bits
+
+ for (unsigned y = 0; y < FI_GetHeightProc(bitmap); y++) {
+ switch(fif) {
+ case FIF_BMP :
+ if ((!iio->image().hasAlphaBuffer()) && (iio->image().depth() == 32)) {
+ FI_ConvertLine32To24Proc(FI_GetScanLineProc(bitmap, y), iio->image().scanLine(FI_GetHeightProc(bitmap) - 1 - y), iio->image().width());
+ } else {
+ memcpy(FI_GetScanLineProc(bitmap, y), iio->image().scanLine(FI_GetHeightProc(bitmap) - 1 - y), FI_GetPitchProc(bitmap));
+ }
+
+ break;
+
+ case FIF_JPEG :
+ if (iio->image().depth() == 32) {
+ FI_ConvertLine32To24Proc(FI_GetScanLineProc(bitmap, y), iio->image().scanLine(FI_GetHeightProc(bitmap) - 1 - y), iio->image().width());
+ } else {
+ memcpy(FI_GetScanLineProc(bitmap, y), iio->image().scanLine(FI_GetHeightProc(bitmap) - 1 - y), FI_GetPitchProc(bitmap));
+ }
+
+ break;
+
+ default :
+ memcpy(FI_GetScanLineProc(bitmap, y), iio->image().scanLine(FI_GetHeightProc(bitmap) - 1 - y), FI_GetPitchProc(bitmap));
+ break;
+ };
+ }
+
+ // save the bitmap
+
+ if (FI_SaveToHandleProc(fif, bitmap, &io, (fi_handle)iio->ioDevice())) {
+ iio->setStatus(0); // status 0 == SUCCESS
+ } else {
+ iio->setStatus(-1); // status -1 == FAILURE
+ }
+
+ FI_UnloadProc(bitmap);
+
+ return;
+ }
+ }
+
+ iio->setStatus(-1);
+}
+
+// ----------------------------------------------------------
+// OUTPUT MESSAGE FUNCTIONS
+// ----------------------------------------------------------
+
+void
+FIQT_SetOutputMessage(FreeImage_OutputMessageFunction omf) {
+ if (FI_SetOutputMessageProc != NULL) {
+ FI_SetOutputMessageProc(omf);
+ }
+}
+
+// ----------------------------------------------------------
+// VERSION HANDLING / COPYRIGHT
+// ----------------------------------------------------------
+
+const char *
+FIQT_GetVersion() {
+ return (FI_GetVersionProc != NULL) ? FI_GetVersionProc() : NULL;
+}
+
+const char *
+FIQT_GetCopyrightMessage() {
+ return (FI_GetCopyrightMessageProc != NULL) ? FI_GetCopyrightMessageProc() : NULL;
+}
+
+// ----------------------------------------------------------
+// REGISTRATION OF FREEIMAGE IN THE QT MECHANISM
+// ----------------------------------------------------------
+
+bool
+FIQT_Register(bool new_formats_only) {
+ if (!s_library_loaded) {
+#ifdef _DEBUG
+ if ((s_library_handle = LoadLibrary("freeimaged.dll")) != NULL) {
+#else
+ if ((s_library_handle = LoadLibrary("freeimage.dll")) != NULL) {
+#endif
+ // extract the functions from the FreeImage library
+
+ FI_SetOutputMessageProc = reinterpret_cast(GetProcAddress(s_library_handle, "_FreeImage_SetOutputMessage@4"));
+ FI_AllocateProc = reinterpret_cast(GetProcAddress(s_library_handle, "_FreeImage_Allocate@24"));
+ FI_UnloadProc = reinterpret_cast(GetProcAddress(s_library_handle, "_FreeImage_Unload@4"));
+ FI_GetFIFCountProc = reinterpret_cast(GetProcAddress(s_library_handle, "_FreeImage_GetFIFCount@0"));
+ FI_GetFIFFromFormatProc = reinterpret_cast(GetProcAddress(s_library_handle, "_FreeImage_GetFIFFromFormat@4"));
+ FI_GetFormatFromFIFProc = reinterpret_cast(GetProcAddress(s_library_handle, "_FreeImage_GetFormatFromFIF@4"));
+ FI_GetFIFDescriptionProc = reinterpret_cast(GetProcAddress(s_library_handle, "_FreeImage_GetFIFDescription@4"));
+ FI_GetFIFRegExprProc = reinterpret_cast(GetProcAddress(s_library_handle, "_FreeImage_GetFIFRegExpr@4"));
+ FI_GetFIFExtensionListProc = reinterpret_cast(GetProcAddress(s_library_handle, "_FreeImage_GetFIFExtensionList@4"));
+ FI_GetFIFFromFilenameProc = reinterpret_cast(GetProcAddress(s_library_handle, "_FreeImage_GetFIFFromFilename@4"));
+ FI_FIFSupportsReadingProc = reinterpret_cast(GetProcAddress(s_library_handle, "_FreeImage_FIFSupportsReading@4"));
+ FI_FIFSupportsWritingProc = reinterpret_cast(GetProcAddress(s_library_handle, "_FreeImage_FIFSupportsWriting@4"));
+ FI_LoadFromHandleProc = reinterpret_cast(GetProcAddress(s_library_handle, "_FreeImage_LoadFromHandle@16"));
+ FI_SaveToHandleProc = reinterpret_cast(GetProcAddress(s_library_handle, "_FreeImage_SaveToHandle@20"));
+ FI_GetHeightProc = reinterpret_cast(GetProcAddress(s_library_handle, "_FreeImage_GetHeight@4"));
+ FI_GetWidthProc = reinterpret_cast(GetProcAddress(s_library_handle, "_FreeImage_GetWidth@4"));
+ FI_GetBPPProc = reinterpret_cast(GetProcAddress(s_library_handle, "_FreeImage_GetBPP@4"));
+ FI_GetDotsPerMeterXProc = reinterpret_cast