Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: downloads/OgreMain/src/OgreDDSCodec.cpp @ 1

Last change on this file since 1 was 1, checked in by landauf, 17 years ago

File size: 22.0 KB

Rev	Line
[1]	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 "OgreDDSCodec.h"
	35	#include "OgreImage.h"
	36	#include "OgreException.h"
	37
	38	#include "OgreLogManager.h"
	39	#include "OgreStringConverter.h"
	40
	41
	42	namespace Ogre {
	43	// Internal DDS structure definitions
	44	#define FOURCC(c0, c1, c2, c3) (c0 \| (c1 << 8) \| (c2 << 16) \| (c3 << 24))
	45
	46	#if OGRE_COMPILER == OGRE_COMPILER_MSVC
	47	#pragma pack (push, 1)
	48	#else
	49	#pragma pack (1)
	50	#endif
	51
	52	// Nested structure
	53	struct DDSPixelFormat
	54	{
	55	uint32 size;
	56	uint32 flags;
	57	uint32 fourCC;
	58	uint32 rgbBits;
	59	uint32 redMask;
	60	uint32 greenMask;
	61	uint32 blueMask;
	62	uint32 alphaMask;
	63	};
	64
	65	// Nested structure
	66	struct DDSCaps
	67	{
	68	uint32 caps1;
	69	uint32 caps2;
	70	uint32 reserved[2];
	71	};
	72	// Main header, note preceded by 'DDS '
	73	struct DDSHeader
	74	{
	75	uint32 size;
	76	uint32 flags;
	77	uint32 height;
	78	uint32 width;
	79	uint32 sizeOrPitch;
	80	uint32 depth;
	81	uint32 mipMapCount;
	82	uint32 reserved1[11];
	83	DDSPixelFormat pixelFormat;
	84	DDSCaps caps;
	85	uint32 reserved2;
	86	};
	87
	88	// An 8-byte DXT colour block, represents a 4x4 texel area. Used by all DXT formats
	89	struct DXTColourBlock
	90	{
	91	// 2 colour ranges
	92	uint16 colour_0;
	93	uint16 colour_1;
	94	// 16 2-bit indexes, each byte here is one row
	95	uint8 indexRow[4];
	96	};
	97	// An 8-byte DXT explicit alpha block, represents a 4x4 texel area. Used by DXT2/3
	98	struct DXTExplicitAlphaBlock
	99	{
	100	// 16 4-bit values, each 16-bit value is one row
	101	uint16 alphaRow[4];
	102	};
	103	// An 8-byte DXT interpolated alpha block, represents a 4x4 texel area. Used by DXT4/5
	104	struct DXTInterpolatedAlphaBlock
	105	{
	106	// 2 alpha ranges
	107	uint8 alpha_0;
	108	uint8 alpha_1;
	109	// 16 3-bit indexes. Unfortunately 3 bits doesn't map too well to row bytes
	110	// so just stored raw
	111	uint8 indexes[6];
	112	};
	113
	114	#if OGRE_COMPILER == OGRE_COMPILER_MSVC
	115	#pragma pack (pop)
	116	#else
	117	#pragma pack ()
	118	#endif
	119
	120	const uint32 DDS_PIXELFORMAT_SIZE = 8 * sizeof(uint32);
	121	const uint32 DDS_CAPS_SIZE = 4 * sizeof(uint32);
	122	const uint32 DDS_HEADER_SIZE = 19 * sizeof(uint32) + DDS_PIXELFORMAT_SIZE + DDS_CAPS_SIZE;
	123
	124	const uint32 DDSD_CAPS = 0x00000001;
	125	const uint32 DDSD_HEIGHT = 0x00000002;
	126	const uint32 DDSD_WIDTH = 0x00000004;
	127	const uint32 DDSD_PITCH = 0x00000008;
	128	const uint32 DDSD_PIXELFORMAT = 0x00001000;
	129	const uint32 DDSD_MIPMAPCOUNT = 0x00020000;
	130	const uint32 DDSD_LINEARSIZE = 0x00080000;
	131	const uint32 DDSD_DEPTH = 0x00800000;
	132	const uint32 DDPF_ALPHAPIXELS = 0x00000001;
	133	const uint32 DDPF_FOURCC = 0x00000004;
	134	const uint32 DDPF_RGB = 0x00000040;
	135	const uint32 DDSCAPS_COMPLEX = 0x00000008;
	136	const uint32 DDSCAPS_TEXTURE = 0x00001000;
	137	const uint32 DDSCAPS_MIPMAP = 0x00400000;
	138	const uint32 DDSCAPS2_CUBEMAP = 0x00000200;
	139	const uint32 DDSCAPS2_CUBEMAP_POSITIVEX = 0x00000400;
	140	const uint32 DDSCAPS2_CUBEMAP_NEGATIVEX = 0x00000800;
	141	const uint32 DDSCAPS2_CUBEMAP_POSITIVEY = 0x00001000;
	142	const uint32 DDSCAPS2_CUBEMAP_NEGATIVEY = 0x00002000;
	143	const uint32 DDSCAPS2_CUBEMAP_POSITIVEZ = 0x00004000;
	144	const uint32 DDSCAPS2_CUBEMAP_NEGATIVEZ = 0x00008000;
	145	const uint32 DDSCAPS2_VOLUME = 0x00200000;
	146
	147	// Special FourCC codes
	148	const uint32 D3DFMT_R16F = 111;
	149	const uint32 D3DFMT_G16R16F = 112;
	150	const uint32 D3DFMT_A16B16G16R16F = 113;
	151	const uint32 D3DFMT_R32F = 114;
	152	const uint32 D3DFMT_G32R32F = 115;
	153	const uint32 D3DFMT_A32B32G32R32F = 116;
	154
	155
	156	//---------------------------------------------------------------------
	157	DDSCodec* DDSCodec::msInstance = 0;
	158	//---------------------------------------------------------------------
	159	void DDSCodec::startup(void)
	160	{
	161	if (!msInstance)
	162	{
	163
	164	LogManager::getSingleton().logMessage(
	165	LML_NORMAL,
	166	"DDS codec registering");
	167
	168	msInstance = new DDSCodec();
	169	Codec::registerCodec(msInstance);
	170	}
	171
	172	}
	173	//---------------------------------------------------------------------
	174	void DDSCodec::shutdown(void)
	175	{
	176	if(msInstance)
	177	{
	178	Codec::unRegisterCodec(msInstance);
	179	delete msInstance;
	180	msInstance = 0;
	181	}
	182
	183	}
	184	//---------------------------------------------------------------------
	185	DDSCodec::DDSCodec():
	186	mType("dds")
	187	{
	188	}
	189	//---------------------------------------------------------------------
	190	DataStreamPtr DDSCodec::code(MemoryDataStreamPtr& input, Codec::CodecDataPtr& pData) const
	191	{
	192	OGRE_EXCEPT(Exception::ERR_NOT_IMPLEMENTED,
	193	"DDS encoding not supported",
	194	"DDSCodec::code" ) ;
	195	}
	196	//---------------------------------------------------------------------
	197	void DDSCodec::codeToFile(MemoryDataStreamPtr& input,
	198	const String& outFileName, Codec::CodecDataPtr& pData) const
	199	{
	200	OGRE_EXCEPT(Exception::ERR_NOT_IMPLEMENTED,
	201	"DDS encoding not supported",
	202	"DDSCodec::codeToFile" ) ;
	203	}
	204	//---------------------------------------------------------------------
	205	PixelFormat DDSCodec::convertFourCCFormat(uint32 fourcc) const
	206	{
	207	// convert dxt pixel format
	208	switch(fourcc)
	209	{
	210	case FOURCC('D','X','T','1'):
	211	return PF_DXT1;
	212	case FOURCC('D','X','T','2'):
	213	return PF_DXT2;
	214	case FOURCC('D','X','T','3'):
	215	return PF_DXT3;
	216	case FOURCC('D','X','T','4'):
	217	return PF_DXT4;
	218	case FOURCC('D','X','T','5'):
	219	return PF_DXT5;
	220	case D3DFMT_R16F:
	221	return PF_FLOAT16_R;
	222	case D3DFMT_G16R16F:
	223	return PF_FLOAT16_GR;
	224	case D3DFMT_A16B16G16R16F:
	225	return PF_FLOAT16_RGBA;
	226	case D3DFMT_R32F:
	227	return PF_FLOAT32_R;
	228	case D3DFMT_G32R32F:
	229	return PF_FLOAT32_GR;
	230	case D3DFMT_A32B32G32R32F:
	231	return PF_FLOAT32_RGBA;
	232	// We could support 3Dc here, but only ATI cards support it, not nVidia
	233	default:
	234	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
	235	"Unsupported FourCC format found in DDS file",
	236	"DDSCodec::decode");
	237	};
	238
	239	}
	240	//---------------------------------------------------------------------
	241	PixelFormat DDSCodec::convertPixelFormat(uint32 rgbBits, uint32 rMask,
	242	uint32 gMask, uint32 bMask, uint32 aMask) const
	243	{
	244	// General search through pixel formats
	245	for (int i = PF_UNKNOWN + 1; i < PF_COUNT; ++i)
	246	{
	247	PixelFormat pf = static_cast<PixelFormat>(i);
	248	if (PixelUtil::getNumElemBits(pf) == rgbBits)
	249	{
	250	uint32 testMasks[4];
	251	PixelUtil::getBitMasks(pf, testMasks);
	252	int testBits[4];
	253	PixelUtil::getBitDepths(pf, testBits);
	254	if (testMasks[0] == rMask && testMasks[1] == gMask &&
	255	testMasks[2] == bMask &&
	256	// for alpha, deal with 'X8' formats by checking bit counts
	257	(testMasks[3] == aMask \|\| (aMask == 0 && testBits[3] == 0)))
	258	{
	259	return pf;
	260	}
	261	}
	262
	263	}
	264
	265	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "Cannot determine pixel format",
	266	"DDSCodec::convertPixelFormat");
	267
	268	}
	269	//---------------------------------------------------------------------
	270	void DDSCodec::unpackDXTColour(PixelFormat pf, const DXTColourBlock& block,
	271	ColourValue* pCol) const
	272	{
	273	// Note - we assume all values have already been endian swapped
	274
	275	// Colour lookup table
	276	ColourValue derivedColours[4];
	277
	278	if (pf == PF_DXT1 && block.colour_0 <= block.colour_1)
	279	{
	280	// 1-bit alpha
	281	PixelUtil::unpackColour(&(derivedColours[0]), PF_R5G6B5, &(block.colour_0));
	282	PixelUtil::unpackColour(&(derivedColours[1]), PF_R5G6B5, &(block.colour_1));
	283	// one intermediate colour, half way between the other two
	284	derivedColours[2] = (derivedColours[0] + derivedColours[1]) / 2;
	285	// transparent colour
	286	derivedColours[3] = ColourValue::ZERO;
	287	}
	288	else
	289	{
	290	PixelUtil::unpackColour(&(derivedColours[0]), PF_R5G6B5, &(block.colour_0));
	291	PixelUtil::unpackColour(&(derivedColours[1]), PF_R5G6B5, &(block.colour_1));
	292	// first interpolated colour, 1/3 of the way along
	293	derivedColours[2] = (2 * derivedColours[0] + derivedColours[1]) / 3;
	294	// second interpolated colour, 2/3 of the way along
	295	derivedColours[3] = (derivedColours[0] + 2 * derivedColours[1]) / 3;
	296	}
	297
	298	// Process 4x4 block of texels
	299	for (size_t row = 0; row < 4; ++row)
	300	{
	301	for (size_t x = 0; x < 4; ++x)
	302	{
	303	// LSB come first
	304	uint8 colIdx = static_cast<uint8>(block.indexRow[row] >> (x * 2) & 0x3);
	305	if (pf == PF_DXT1)
	306	{
	307	// Overwrite entire colour
	308	pCol[(row * 4) + x] = derivedColours[colIdx];
	309	}
	310	else
	311	{
	312	// alpha has already been read (alpha precedes colour)
	313	ColourValue& col = pCol[(row * 4) + x];
	314	col.r = derivedColours[colIdx].r;
	315	col.g = derivedColours[colIdx].g;
	316	col.b = derivedColours[colIdx].b;
	317	}
	318	}
	319
	320	}
	321
	322
	323	}
	324	//---------------------------------------------------------------------
	325	void DDSCodec::unpackDXTAlpha(
	326	const DXTExplicitAlphaBlock& block, ColourValue* pCol) const
	327	{
	328	// Note - we assume all values have already been endian swapped
	329
	330	// This is an explicit alpha block, 4 bits per pixel, LSB first
	331	for (size_t row = 0; row < 4; ++row)
	332	{
	333	for (size_t x = 0; x < 4; ++x)
	334	{
	335	// Shift and mask off to 4 bits
	336	uint8 val = static_cast<uint8>(block.alphaRow[row] >> (x * 4) & 0xF);
	337	// Convert to [0,1]
	338	pCol->a = (Real)val / (Real)0xF;
	339	pCol++;
	340
	341	}
	342
	343	}
	344
	345	}
	346	//---------------------------------------------------------------------
	347	void DDSCodec::unpackDXTAlpha(
	348	const DXTInterpolatedAlphaBlock& block, ColourValue* pCol) const
	349	{
	350	// 8 derived alpha values to be indexed
	351	Real derivedAlphas[8];
	352
	353	// Explicit extremes
	354	derivedAlphas[0] = block.alpha_0 / (Real)0xFF;
	355	derivedAlphas[1] = block.alpha_1 / (Real)0xFF;
	356
	357
	358	if (block.alpha_0 <= block.alpha_1)
	359	{
	360	// 4 interpolated alphas, plus zero and one
	361	// full range including extremes at [0] and [5]
	362	// we want to fill in [1] through [4] at weights ranging
	363	// from 1/5 to 4/5
	364	Real denom = 1.0f / 5.0f;
	365	for (size_t i = 0; i < 4; ++i)
	366	{
	367	Real factor0 = (4 - i) * denom;
	368	Real factor1 = (i + 1) * denom;
	369	derivedAlphas[i + 2] =
	370	(factor0 * block.alpha_0) + (factor1 * block.alpha_1);
	371	}
	372	derivedAlphas[6] = 0.0f;
	373	derivedAlphas[7] = 1.0f;
	374
	375	}
	376	else
	377	{
	378	// 6 interpolated alphas
	379	// full range including extremes at [0] and [7]
	380	// we want to fill in [1] through [6] at weights ranging
	381	// from 1/7 to 6/7
	382	Real denom = 1.0f / 7.0f;
	383	for (size_t i = 0; i < 6; ++i)
	384	{
	385	Real factor0 = (6 - i) * denom;
	386	Real factor1 = (i + 1) * denom;
	387	derivedAlphas[i + 2] =
	388	(factor0 * block.alpha_0) + (factor1 * block.alpha_1);
	389	}
	390
	391	}
	392
	393	// Ok, now we've built the reference values, process the indexes
	394	for (size_t i = 0; i < 16; ++i)
	395	{
	396	size_t baseByte = (i * 3) / 8;
	397	size_t baseBit = (i * 3) % 8;
	398	uint8 bits = static_cast<uint8>(block.indexes[baseByte] >> baseBit & 0x7);
	399	// do we need to stitch in next byte too?
	400	if (baseBit > 5)
	401	{
	402	uint8 extraBits = static_cast<uint8>(
	403	(block.indexes[baseByte+1] << (8 - baseBit)) & 0xFF);
	404	bits \|= extraBits & 0x7;
	405	}
	406	pCol[i].a = derivedAlphas[bits];
	407
	408	}
	409
	410	}
	411	//---------------------------------------------------------------------
	412	Codec::DecodeResult DDSCodec::decode(DataStreamPtr& stream) const
	413	{
	414	// Read 4 character code
	415	uint32 fileType;
	416	stream->read(&fileType, sizeof(uint32));
	417	flipEndian(&fileType, sizeof(uint32), 1);
	418
	419	if (FOURCC('D', 'D', 'S', ' ') != fileType)
	420	{
	421	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
	422	"This is not a DDS file!", "DDSCodec::decode");
	423	}
	424
	425	// Read header in full
	426	DDSHeader header;
	427	stream->read(&header, sizeof(DDSHeader));
	428
	429	// Endian flip if required, all 32-bit values
	430	flipEndian(&header, 4, sizeof(DDSHeader) / 4);
	431
	432	// Check some sizes
	433	if (header.size != DDS_HEADER_SIZE)
	434	{
	435	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
	436	"DDS header size mismatch!", "DDSCodec::decode");
	437	}
	438	if (header.pixelFormat.size != DDS_PIXELFORMAT_SIZE)
	439	{
	440	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
	441	"DDS header size mismatch!", "DDSCodec::decode");
	442	}
	443
	444	ImageData* imgData = new ImageData();
	445	MemoryDataStreamPtr output;
	446
	447	imgData->depth = 1; // (deal with volume later)
	448	imgData->width = header.width;
	449	imgData->height = header.height;
	450	size_t numFaces = 1; // assume one face until we know otherwise
	451
	452	if (header.caps.caps1 & DDSCAPS_MIPMAP)
	453	{
	454	imgData->num_mipmaps = header.mipMapCount - 1;
	455	}
	456	else
	457	{
	458	imgData->num_mipmaps = 0;
	459	}
	460	imgData->flags = 0;
	461
	462	bool decompressDXT = false;
	463	// Figure out basic image type
	464	if (header.caps.caps2 & DDSCAPS2_CUBEMAP)
	465	{
	466	imgData->flags \|= IF_CUBEMAP;
	467	numFaces = 6;
	468	}
	469	else if (header.caps.caps2 & DDSCAPS2_VOLUME)
	470	{
	471	imgData->flags \|= IF_3D_TEXTURE;
	472	imgData->depth = header.depth;
	473	}
	474	// Pixel format
	475	PixelFormat sourceFormat = PF_UNKNOWN;
	476
	477	if (header.pixelFormat.flags & DDPF_FOURCC)
	478	{
	479	sourceFormat = convertFourCCFormat(header.pixelFormat.fourCC);
	480	}
	481	else
	482	{
	483	sourceFormat = convertPixelFormat(header.pixelFormat.rgbBits,
	484	header.pixelFormat.redMask, header.pixelFormat.greenMask,
	485	header.pixelFormat.blueMask,
	486	header.pixelFormat.flags & DDPF_ALPHAPIXELS ?
	487	header.pixelFormat.alphaMask : 0);
	488	}
	489
	490	if (PixelUtil::isCompressed(sourceFormat))
	491	{
	492	if (!Root::getSingleton().getRenderSystem()->getCapabilities()
	493	->hasCapability(RSC_TEXTURE_COMPRESSION_DXT))
	494	{
	495	// We'll need to decompress
	496	decompressDXT = true;
	497	// Convert format
	498	switch (sourceFormat)
	499	{
	500	case PF_DXT1:
	501	// source can be either 565 or 5551 depending on whether alpha present
	502	// unfortunately you have to read a block to figure out which
	503	// Note that we upgrade to 32-bit pixel formats here, even
	504	// though the source is 16-bit; this is because the interpolated
	505	// values will benefit from the 32-bit results, and the source
	506	// from which the 16-bit samples are calculated may have been
	507	// 32-bit so can benefit from this.
	508	DXTColourBlock block;
	509	stream->read(&block, sizeof(DXTColourBlock));
	510	flipEndian(&(block.colour_0), sizeof(uint16), 1);
	511	flipEndian(&(block.colour_1), sizeof(uint16), 1);
	512	// skip back since we'll need to read this again
	513	stream->skip(0 - sizeof(DXTColourBlock));
	514	// colour_0 <= colour_1 means transparency in DXT1
	515	if (block.colour_0 <= block.colour_1)
	516	{
	517	imgData->format = PF_BYTE_RGBA;
	518	}
	519	else
	520	{
	521	imgData->format = PF_BYTE_RGB;
	522	}
	523	break;
	524	case PF_DXT2:
	525	case PF_DXT3:
	526	case PF_DXT4:
	527	case PF_DXT5:
	528	// full alpha present, formats vary only in encoding
	529	imgData->format = PF_BYTE_RGBA;
	530	break;
	531	default:
	532	// all other cases need no special format handling
	533	break;
	534	}
	535	}
	536	else
	537	{
	538	// Use original format
	539	imgData->format = sourceFormat;
	540	// Keep DXT data compressed
	541	imgData->flags \|= IF_COMPRESSED;
	542	}
	543	}
	544	else // not compressed
	545	{
	546	// Don't test against DDPF_RGB since greyscale DDS doesn't set this
	547	// just derive any other kind of format
	548	imgData->format = sourceFormat;
	549	}
	550
	551	// Calculate total size from number of mipmaps, faces and size
	552	imgData->size = Image::calculateSize(imgData->num_mipmaps, numFaces,
	553	imgData->width, imgData->height, imgData->depth, imgData->format);
	554
	555	// Bind output buffer
	556	output.bind(new MemoryDataStream(imgData->size));
	557
	558
	559	// Now deal with the data
	560	void* destPtr = output->getPtr();
	561
	562	// all mips for a face, then each face
	563	for(size_t i = 0; i < numFaces; ++i)
	564	{
	565	size_t width = imgData->width;
	566	size_t height = imgData->height;
	567	size_t depth = imgData->depth;
	568
	569	for(size_t mip = 0; mip <= imgData->num_mipmaps; ++mip)
	570	{
	571	size_t dstPitch = width * PixelUtil::getNumElemBytes(imgData->format);
	572
	573	if (PixelUtil::isCompressed(sourceFormat))
	574	{
	575	// Compressed data
	576	if (decompressDXT)
	577	{
	578	DXTColourBlock col;
	579	DXTInterpolatedAlphaBlock iAlpha;
	580	DXTExplicitAlphaBlock eAlpha;
	581	// 4x4 block of decompressed colour
	582	ColourValue tempColours[16];
	583	size_t destBpp = PixelUtil::getNumElemBytes(imgData->format);
	584	size_t destPitchMinus4 = dstPitch - destBpp * 4;
	585	// slices are done individually
	586	for(size_t z = 0; z < depth; ++z)
	587	{
	588	// 4x4 blocks in x/y
	589	for (size_t y = 0; y < height; y += 4)
	590	{
	591	for (size_t x = 0; x < width; x += 4)
	592	{
	593	if (sourceFormat == PF_DXT2 \|\|
	594	sourceFormat == PF_DXT3)
	595	{
	596	// explicit alpha
	597	stream->read(&eAlpha, sizeof(DXTExplicitAlphaBlock));
	598	flipEndian(eAlpha.alphaRow, sizeof(uint16), 4);
	599	unpackDXTAlpha(eAlpha, tempColours) ;
	600	}
	601	else if (sourceFormat == PF_DXT4 \|\|
	602	sourceFormat == PF_DXT5)
	603	{
	604	// interpolated alpha
	605	stream->read(&iAlpha, sizeof(DXTInterpolatedAlphaBlock));
	606	flipEndian(&(iAlpha.alpha_0), sizeof(uint16), 1);
	607	flipEndian(&(iAlpha.alpha_1), sizeof(uint16), 1);
	608	unpackDXTAlpha(iAlpha, tempColours) ;
	609	}
	610	// always read colour
	611	stream->read(&col, sizeof(DXTColourBlock));
	612	flipEndian(&(col.colour_0), sizeof(uint16), 1);
	613	flipEndian(&(col.colour_1), sizeof(uint16), 1);
	614	unpackDXTColour(sourceFormat, col, tempColours);
	615
	616	// write 4x4 block to uncompressed version
	617	for (size_t by = 0; by < 4; ++by)
	618	{
	619	for (size_t bx = 0; bx < 4; ++bx)
	620	{
	621	PixelUtil::packColour(tempColours[by*4+bx],
	622	imgData->format, destPtr);
	623	destPtr = static_cast<void*>(
	624	static_cast<uchar*>(destPtr) + destBpp);
	625	}
	626	// advance to next row
	627	destPtr = static_cast<void*>(
	628	static_cast<uchar*>(destPtr) + destPitchMinus4);
	629	}
	630	// next block. Our dest pointer is 4 lines down
	631	// from where it started
	632	if (x + 4 == width)
	633	{
	634	// Jump back to the start of the line
	635	destPtr = static_cast<void*>(
	636	static_cast<uchar*>(destPtr) - destPitchMinus4);
	637	}
	638	else
	639	{
	640	// Jump back up 4 rows and 4 pixels to the
	641	// right to be at the next block to the right
	642	destPtr = static_cast<void*>(
	643	static_cast<uchar>(destPtr) - dstPitch 4 + destBpp * 4);
	644
	645	}
	646
	647	}
	648
	649	}
	650	}
	651
	652	}
	653	else
	654	{
	655	// load directly
	656	// DDS format lies! sizeOrPitch is not always set for DXT!!
	657	size_t dxtSize = PixelUtil::getMemorySize(width, height, depth, imgData->format);
	658	stream->read(destPtr, dxtSize);
	659	destPtr = static_cast<void>(static_cast<uchar>(destPtr) + dxtSize);
	660	}
	661
	662	}
	663	else
	664	{
	665	// Final data - trim incoming pitch
	666	size_t srcPitch;
	667	if (header.flags & DDSD_PITCH)
	668	{
	669	srcPitch = header.sizeOrPitch /
	670	std::max((size_t)1, mip * 2);
	671	}
	672	else
	673	{
	674	// assume same as final pitch
	675	srcPitch = dstPitch;
	676	}
	677	assert (dstPitch <= srcPitch);
	678	long srcAdvance = static_cast<long>(srcPitch) - static_cast<long>(dstPitch);
	679
	680	for (size_t z = 0; z < imgData->depth; ++z)
	681	{
	682	for (size_t y = 0; y < imgData->height; ++y)
	683	{
	684	stream->read(destPtr, dstPitch);
	685	if (srcAdvance > 0)
	686	stream->skip(srcAdvance);
	687
	688	destPtr = static_cast<void>(static_cast<uchar>(destPtr) + dstPitch);
	689	}
	690	}
	691
	692	}
	693
	694
	695	/// Next mip
	696	if(width!=1) width /= 2;
	697	if(height!=1) height /= 2;
	698	if(depth!=1) depth /= 2;
	699	}
	700
	701	}
	702
	703	DecodeResult ret;
	704	ret.first = output;
	705	ret.second = CodecDataPtr(imgData);
	706	return ret;
	707
	708
	709
	710	}
	711	//---------------------------------------------------------------------
	712	String DDSCodec::getType() const
	713	{
	714	return mType;
	715	}
	716	//---------------------------------------------------------------------
	717	void DDSCodec::flipEndian(void * pData, size_t size, size_t count) const
	718	{
	719	#if OGRE_ENDIAN == OGRE_ENDIAN_BIG
	720	for(unsigned int index = 0; index < count; index++)
	721	{
	722	flipEndian((void )((long)pData + (index size)), size);
	723	}
	724	#endif
	725	}
	726	//---------------------------------------------------------------------
	727	void DDSCodec::flipEndian(void * pData, size_t size) const
	728	{
	729	#if OGRE_ENDIAN == OGRE_ENDIAN_BIG
	730	char swapByte;
	731	for(unsigned int byteIndex = 0; byteIndex < size/2; byteIndex++)
	732	{
	733	swapByte = (char )((long)pData + byteIndex);
	734	(char )((long)pData + byteIndex) = (char )((long)pData + size - byteIndex - 1);
	735	(char )((long)pData + size - byteIndex - 1) = swapByte;
	736	}
	737	#endif
	738	}
	739
	740	}
	741

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

Download in other formats: