Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: downloads/OgreMain/src/OgreFreeImageCodec.cpp @ 3

Last change on this file since 3 was 3, checked in by anonymous, 17 years ago
=update
File size: 13.7 KB

Line
1	/*
2	-----------------------------------------------------------------------------
3	This source file is part of OGRE
4	(Object-oriented Graphics Rendering Engine)
5	For the latest info, see http://www.ogre3d.org/
6
7	Copyright (c) 2000-2006 Torus Knot Software Ltd
8	Also see acknowledgements in Readme.html
9
10	This program is free software; you can redistribute it and/or modify it under
11	the terms of the GNU Lesser General Public License as published by the Free Software
12	Foundation; either version 2 of the License, or (at your option) any later
13	version.
14
15	This program is distributed in the hope that it will be useful, but WITHOUT
16	ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
17	FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
18
19	You should have received a copy of the GNU Lesser General Public License along with
20	this program; if not, write to the Free Software Foundation, Inc., 59 Temple
21	Place - Suite 330, Boston, MA 02111-1307, USA, or go to
22	http://www.gnu.org/copyleft/lesser.txt.
23
24	You may alternatively use this source under the terms of a specific version of
25	the OGRE Unrestricted License provided you have obtained such a license from
26	Torus Knot Software Ltd.
27	-----------------------------------------------------------------------------
28	*/
29
30	#include "OgreStableHeaders.h"
31
32	#include "OgreRoot.h"
33	#include "OgreRenderSystem.h"
34	#include "OgreFreeImageCodec.h"
35	#include "OgreImage.h"
36	#include "OgreException.h"
37
38	#include "OgreLogManager.h"
39	#include "OgreStringConverter.h"
40
41	#include <FreeImage.h>
42
43	namespace Ogre {
44
45	FreeImageCodec::RegisteredCodecList FreeImageCodec::msCodecList;
46	//---------------------------------------------------------------------
47	void FreeImageErrorHandler(FREE_IMAGE_FORMAT fif, const char *message)
48	{
49	// Callback method as required by FreeImage to report problems
50	StringUtil::StrStreamType str;
51	str << "FreeImage error: '" << message << "'";
52
53	const char* typeName = FreeImage_GetFormatFromFIF(fif);
54	if (typeName)
55	{
56	str << " when loading format " << typeName;
57	}
58
59	LogManager::getSingleton().logMessage(str.str());
60
61	}
62	//---------------------------------------------------------------------
63	void FreeImageCodec::startup(void)
64	{
65	FreeImage_Initialise(false);
66
67	LogManager::getSingleton().logMessage(
68	LML_NORMAL,
69	"FreeImage version: " + String(FreeImage_GetVersion()));
70	LogManager::getSingleton().logMessage(
71	LML_NORMAL,
72	FreeImage_GetCopyrightMessage());
73
74	// Register codecs
75	StringUtil::StrStreamType strExt;
76	strExt << "Supported formats: ";
77	bool first = true;
78	for (int i = 0; i < FreeImage_GetFIFCount(); ++i)
79	{
80
81	// Skip DDS codec since FreeImage does not have the option
82	// to keep DXT data compressed, we'll use our own codec
83	if ((FREE_IMAGE_FORMAT)i == FIF_DDS)
84	continue;
85
86	String exts(FreeImage_GetFIFExtensionList((FREE_IMAGE_FORMAT)i));
87	if (!first)
88	{
89	strExt << ",";
90	}
91	first = false;
92	strExt << exts;
93
94	// Pull off individual formats (separated by comma by FI)
95	StringVector extsVector = StringUtil::split(exts, ",");
96	for (StringVector::iterator v = extsVector.begin(); v != extsVector.end(); ++v)
97	{
98	ImageCodec* codec = new FreeImageCodec(*v, i);
99	msCodecList.push_back(codec);
100	Codec::registerCodec(codec);
101	}
102	}
103	LogManager::getSingleton().logMessage(
104	LML_NORMAL,
105	strExt.str());
106
107	// Set error handler
108	FreeImage_SetOutputMessage(FreeImageErrorHandler);
109
110
111
112
113	}
114	//---------------------------------------------------------------------
115	void FreeImageCodec::shutdown(void)
116	{
117	FreeImage_DeInitialise();
118
119	for (RegisteredCodecList::iterator i = msCodecList.begin();
120	i != msCodecList.end(); ++i)
121	{
122	Codec::unRegisterCodec(*i);
123	delete *i;
124	}
125	msCodecList.clear();
126
127	}
128	//---------------------------------------------------------------------
129	FreeImageCodec::FreeImageCodec(const String &type, unsigned int fiType):
130	mType(type),
131	mFreeImageType(fiType)
132	{
133	}
134	//---------------------------------------------------------------------
135	FIBITMAP* FreeImageCodec::encode(MemoryDataStreamPtr& input, CodecDataPtr& pData) const
136	{
137	FIBITMAP* ret = 0;
138
139	ImageData* pImgData = static_cast< ImageData * >( pData.getPointer() );
140	PixelBox src(pImgData->width, pImgData->height, pImgData->depth, pImgData->format, input->getPtr());
141
142	// The required format, which will adjust to the format
143	// actually supported by FreeImage.
144	PixelFormat requiredFormat = pImgData->format;
145
146	// determine the settings
147	FREE_IMAGE_TYPE imageType;
148	switch(pImgData->format)
149	{
150	case PF_R5G6B5:
151	case PF_B5G6R5:
152	case PF_R8G8B8:
153	case PF_B8G8R8:
154	case PF_A8R8G8B8:
155	case PF_X8R8G8B8:
156	case PF_A8B8G8R8:
157	case PF_X8B8G8R8:
158	case PF_B8G8R8A8:
159	case PF_R8G8B8A8:
160	case PF_A4L4:
161	case PF_BYTE_LA:
162	case PF_R3G3B2:
163	case PF_A4R4G4B4:
164	case PF_A1R5G5B5:
165	case PF_A2R10G10B10:
166	case PF_A2B10G10R10:
167	// I'd like to be able to use r/g/b masks to get FreeImage to load the data
168	// in it's existing format, but that doesn't work, FreeImage needs to have
169	// data in RGB[A] (big endian) and BGR[A] (little endian), always.
170	if (PixelUtil::hasAlpha(pImgData->format))
171	{
172	#if OGRE_ENDIAN == OGRE_ENDIAN_BIG
173	requiredFormat = PF_BYTE_RGBA;
174	#else
175	requiredFormat = PF_BYTE_BGRA;
176	#endif
177	}
178	else
179	{
180	#if OGRE_ENDIAN == OGRE_ENDIAN_BIG
181	requiredFormat = PF_BYTE_RGB;
182	#else
183	requiredFormat = PF_BYTE_BGR;
184	#endif
185	}
186	// fall through
187	case PF_L8:
188	case PF_A8:
189	imageType = FIT_BITMAP;
190	break;
191
192	case PF_L16:
193	imageType = FIT_UINT16;
194	break;
195
196	case PF_SHORT_GR:
197	requiredFormat = PF_SHORT_RGB;
198	// fall through
199	case PF_SHORT_RGB:
200	imageType = FIT_RGB16;
201	break;
202
203	case PF_SHORT_RGBA:
204	imageType = FIT_RGBA16;
205	break;
206
207	case PF_FLOAT16_R:
208	requiredFormat = PF_FLOAT32_R;
209	// fall through
210	case PF_FLOAT32_R:
211	imageType = FIT_FLOAT;
212	break;
213
214	case PF_FLOAT16_GR:
215	case PF_FLOAT16_RGB:
216	case PF_FLOAT32_GR:
217	requiredFormat = PF_FLOAT32_RGB;
218	// fall through
219	case PF_FLOAT32_RGB:
220	imageType = FIT_RGBF;
221	break;
222
223	case PF_FLOAT16_RGBA:
224	requiredFormat = PF_FLOAT32_RGBA;
225	// fall through
226	case PF_FLOAT32_RGBA:
227	imageType = FIT_RGBAF;
228	break;
229
230	default:
231	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "Invalid image format", "FreeImageCodec::encode");
232	};
233
234	bool conversionRequired = false;
235
236	unsigned char* srcData = input->getPtr();
237	PixelBox convBox(pImgData->width, pImgData->height, 1, requiredFormat);
238	if (requiredFormat != pImgData->format)
239	{
240	conversionRequired = true;
241	// Allocate memory
242	convBox.data = new uchar[convBox.getConsecutiveSize()];
243	// perform conversion and reassign source
244	PixelBox src(pImgData->width, pImgData->height, 1, pImgData->format, input->getPtr());
245	PixelUtil::bulkPixelConversion(src, convBox);
246	srcData = static_cast<unsigned char*>(convBox.data);
247
248	}
249
250	unsigned bpp = static_cast<unsigned>(PixelUtil::getNumElemBits(requiredFormat));
251
252	ret = FreeImage_AllocateT(
253	imageType,
254	static_cast<int>(pImgData->width),
255	static_cast<int>(pImgData->height),
256	bpp);
257
258	if (requiredFormat == PF_L8 \|\| requiredFormat == PF_A8)
259	{
260	// Must explicitly tell FreeImage that this is greyscale by setting
261	// a "grey" palette (otherwise it will save as a normal RGB
262	// palettized image).
263	FIBITMAP *tmp = FreeImage_ConvertToGreyscale(ret);
264	FreeImage_Unload(ret);
265	ret = tmp;
266	}
267
268	size_t dstPitch = FreeImage_GetPitch(ret);
269	size_t srcPitch = pImgData->width * PixelUtil::getNumElemBytes(requiredFormat);
270
271
272	// Copy data, invert scanlines and respect FreeImage pitch
273	uchar* pSrc;
274	uchar* pDst = FreeImage_GetBits(ret);
275	for (size_t y = 0; y < pImgData->height; ++y)
276	{
277	pSrc = srcData + (pImgData->height - y - 1) * srcPitch;
278	memcpy(pDst, pSrc, srcPitch);
279	pDst += dstPitch;
280	}
281
282	if (conversionRequired)
283	{
284	// delete temporary conversion area
285	delete [] static_cast<uchar*>(convBox.data);
286	}
287
288	return ret;
289	}
290	//---------------------------------------------------------------------
291	DataStreamPtr FreeImageCodec::code(MemoryDataStreamPtr& input, Codec::CodecDataPtr& pData) const
292	{
293	FIBITMAP* fiBitmap = encode(input, pData);
294
295	// open memory chunk allocated by FreeImage
296	FIMEMORY* mem = FreeImage_OpenMemory();
297	// write data into memory
298	FreeImage_SaveToMemory((FREE_IMAGE_FORMAT)mFreeImageType, fiBitmap, mem);
299	// Grab data information
300	BYTE* data;
301	DWORD size;
302	FreeImage_AcquireMemory(mem, &data, &size);
303	// Copy data into our own buffer
304	BYTE* ourData = new BYTE[size];
305	memcpy(ourData, data, size);
306	// Wrap data in stream, tell it to free on close
307	DataStreamPtr outstream(new MemoryDataStream(ourData, size, true));
308	// Now free FreeImage memory buffers
309	FreeImage_CloseMemory(mem);
310	// Unload bitmap
311	FreeImage_Unload(fiBitmap);
312
313	return outstream;
314
315
316	}
317	//---------------------------------------------------------------------
318	void FreeImageCodec::codeToFile(MemoryDataStreamPtr& input,
319	const String& outFileName, Codec::CodecDataPtr& pData) const
320	{
321	FIBITMAP* fiBitmap = encode(input, pData);
322
323	FreeImage_Save((FREE_IMAGE_FORMAT)mFreeImageType, fiBitmap, outFileName.c_str());
324	FreeImage_Unload(fiBitmap);
325
326
327	}
328	//---------------------------------------------------------------------
329	Codec::DecodeResult FreeImageCodec::decode(DataStreamPtr& input) const
330	{
331	// Buffer stream into memory (TODO: override IO functions instead?)
332	MemoryDataStream memStream(input, true);
333
334	FIMEMORY* fiMem =
335	FreeImage_OpenMemory(memStream.getPtr(), static_cast<DWORD>(memStream.size()));
336
337	FIBITMAP* fiBitmap = FreeImage_LoadFromMemory(
338	(FREE_IMAGE_FORMAT)mFreeImageType, fiMem);
339	if (!fiBitmap)
340	{
341	OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR,
342	"Error decoding image",
343	"FreeImageCodec::decode");
344	}
345
346
347	ImageData* imgData = new ImageData();
348	MemoryDataStreamPtr output;
349
350	imgData->depth = 1; // only 2D formats handled by this codec
351	imgData->width = FreeImage_GetWidth(fiBitmap);
352	imgData->height = FreeImage_GetHeight(fiBitmap);
353	imgData->num_mipmaps = 0; // no mipmaps in non-DDS
354	imgData->flags = 0;
355
356	// Must derive format first, this may perform conversions
357
358	FREE_IMAGE_TYPE imageType = FreeImage_GetImageType(fiBitmap);
359	FREE_IMAGE_COLOR_TYPE colourType = FreeImage_GetColorType(fiBitmap);
360	unsigned bpp = FreeImage_GetBPP(fiBitmap);
361
362	switch(imageType)
363	{
364	case FIT_UNKNOWN:
365	case FIT_COMPLEX:
366	case FIT_UINT32:
367	case FIT_INT32:
368	case FIT_DOUBLE:
369	default:
370	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
371	"Unknown or unsupported image format",
372	"FreeImageCodec::decode");
373
374	break;
375	case FIT_BITMAP:
376	// Standard image type
377	// Perform any colour conversions for greyscale
378	if (colourType == FIC_MINISWHITE \|\| colourType == FIC_MINISBLACK)
379	{
380	FIBITMAP* newBitmap = FreeImage_ConvertToGreyscale(fiBitmap);
381	// free old bitmap and replace
382	FreeImage_Unload(fiBitmap);
383	fiBitmap = newBitmap;
384	// get new formats
385	bpp = FreeImage_GetBPP(fiBitmap);
386	colourType = FreeImage_GetColorType(fiBitmap);
387	}
388	// Perform any colour conversions for RGB
389	else if (bpp < 8 \|\| colourType == FIC_PALETTE \|\| colourType == FIC_CMYK)
390	{
391	FIBITMAP* newBitmap = FreeImage_ConvertTo24Bits(fiBitmap);
392	// free old bitmap and replace
393	FreeImage_Unload(fiBitmap);
394	fiBitmap = newBitmap;
395	// get new formats
396	bpp = FreeImage_GetBPP(fiBitmap);
397	colourType = FreeImage_GetColorType(fiBitmap);
398	}
399
400	// by this stage, 8-bit is greyscale, 16/24/32 bit are RGB[A]
401	switch(bpp)
402	{
403	case 8:
404	imgData->format = PF_L8;
405	break;
406	case 16:
407	// Determine 555 or 565 from green mask
408	// cannot be 16-bit greyscale since that's FIT_UINT16
409	if(FreeImage_GetGreenMask(fiBitmap) == FI16_565_GREEN_MASK)
410	{
411	imgData->format = PF_R5G6B5;
412	}
413	else
414	{
415	// FreeImage doesn't support 4444 format so must be 1555
416	imgData->format = PF_A1R5G5B5;
417	}
418	break;
419	case 24:
420	// FreeImage differs per platform
421	// PF_BYTE_BGR[A] for little endian (== PF_ARGB native)
422	// PF_BYTE_RGB[A] for big endian (== PF_RGBA native)
423	#if OGRE_ENDIAN == OGRE_ENDIAN_BIG
424	imgData->format = PF_BYTE_RGB;
425	#else
426	imgData->format = PF_BYTE_BGR;
427	#endif
428	break;
429	case 32:
430	#if OGRE_ENDIAN == OGRE_ENDIAN_BIG
431	imgData->format = PF_BYTE_RGBA;
432	#else
433	imgData->format = PF_BYTE_BGRA;
434	#endif
435	break;
436
437
438	};
439	break;
440	case FIT_UINT16:
441	case FIT_INT16:
442	// 16-bit greyscale
443	imgData->format = PF_L16;
444	break;
445	case FIT_FLOAT:
446	// Single-component floating point data
447	imgData->format = PF_FLOAT32_R;
448	break;
449	case FIT_RGB16:
450	imgData->format = PF_SHORT_RGB;
451	break;
452	case FIT_RGBA16:
453	imgData->format = PF_SHORT_RGBA;
454	break;
455	case FIT_RGBF:
456	imgData->format = PF_FLOAT32_RGB;
457	break;
458	case FIT_RGBAF:
459	imgData->format = PF_FLOAT32_RGBA;
460	break;
461
462
463	};
464
465	unsigned char* srcData = FreeImage_GetBits(fiBitmap);
466	unsigned srcPitch = FreeImage_GetPitch(fiBitmap);
467
468	// Final data - invert image and trim pitch at the same time
469	size_t dstPitch = imgData->width * PixelUtil::getNumElemBytes(imgData->format);
470	imgData->size = dstPitch * imgData->height;
471	// Bind output buffer
472	output.bind(new MemoryDataStream(imgData->size));
473
474	uchar* pSrc;
475	uchar* pDst = output->getPtr();
476	for (size_t y = 0; y < imgData->height; ++y)
477	{
478	pSrc = srcData + (imgData->height - y - 1) * srcPitch;
479	memcpy(pDst, pSrc, dstPitch);
480	pDst += dstPitch;
481	}
482
483
484	FreeImage_Unload(fiBitmap);
485	FreeImage_CloseMemory(fiMem);
486
487
488	DecodeResult ret;
489	ret.first = output;
490	ret.second = CodecDataPtr(imgData);
491	return ret;
492
493	}
494	//---------------------------------------------------------------------
495	String FreeImageCodec::getType() const
496	{
497	return mType;
498	}
499	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: