From 38d6d37f2d982fa959e9e8a4a3f7e1ccfad7b5d4 Mon Sep 17 00:00:00 2001
From: Jacek Antonelli
Date: Fri, 15 Aug 2008 23:44:46 -0500
Subject: Second Life viewer sources 1.13.2.12

---
 linden/indra/llimage/llimagebmp.cpp | 643 ++++++++++++++++++++++++++++++++++++
 1 file changed, 643 insertions(+)
 create mode 100644 linden/indra/llimage/llimagebmp.cpp

(limited to 'linden/indra/llimage/llimagebmp.cpp')

diff --git a/linden/indra/llimage/llimagebmp.cpp b/linden/indra/llimage/llimagebmp.cpp
new file mode 100644
index 0000000..fc9532e
--- /dev/null
+++ b/linden/indra/llimage/llimagebmp.cpp
@@ -0,0 +1,643 @@
+/** 
+ * @file llimagebmp.cpp
+ *
+ * Copyright (c) 2001-2007, Linden Research, Inc.
+ * 
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ */
+
+#include "linden_common.h"
+
+#include "llimagebmp.h"
+#include "llerror.h"
+
+#include "llendianswizzle.h"
+
+
+/**
+ * @struct LLBMPHeader
+ *
+ * This struct helps deal with bmp files.
+ */
+struct LLBMPHeader
+{
+	S32 mSize;
+	S32 mWidth;
+	S32 mHeight;
+	S16 mPlanes;
+	S16 mBitsPerPixel;
+	S16 mCompression;
+	S16 mAlignmentPadding; // pads out to next word boundary
+	S32 mImageSize;
+	S32 mHorzPelsPerMeter;
+	S32 mVertPelsPerMeter;
+	S32 mNumColors;
+	S32 mNumColorsImportant;
+};
+
+/**
+ * @struct Win95BmpHeaderExtension
+ */
+struct Win95BmpHeaderExtension
+{
+	U32 mReadMask;
+	U32 mGreenMask;
+	U32 mBlueMask;
+	U32 mAlphaMask;
+	U32 mColorSpaceType;
+	U16	mRed[3];	// Red CIE endpoint
+	U16 mGreen[3];	// Green CIE endpoint
+	U16 mBlue[3];	// Blue CIE endpoint
+	U32 mGamma[3];  // Gamma scale for r g and b
+};
+
+/**
+ * LLImageBMP
+ */
+LLImageBMP::LLImageBMP() 
+	:
+	LLImageFormatted(IMG_CODEC_BMP),
+	mColorPaletteColors( 0 ),
+	mColorPalette( NULL ),
+	mBitmapOffset( 0 ),
+	mBitsPerPixel( 0 ),
+	mOriginAtTop( FALSE )
+{
+	mBitfieldMask[0] = 0;
+	mBitfieldMask[1] = 0;
+	mBitfieldMask[2] = 0;
+	mBitfieldMask[3] = 0;
+}
+
+LLImageBMP::~LLImageBMP()
+{
+	delete[] mColorPalette;
+}
+
+
+BOOL LLImageBMP::updateData()
+{
+	resetLastError();
+
+	// Check to make sure that this instance has been initialized with data
+	U8* mdata = getData();
+	if (!mdata || (0 == getDataSize()))
+	{
+		setLastError("Uninitialized instance of LLImageBMP");
+		return FALSE;
+	}
+
+	// Read the bitmap headers in order to get all the useful info
+	// about this image
+
+	////////////////////////////////////////////////////////////////////
+	// Part 1: "File Header"
+	// 14 bytes consisting of
+	// 2 bytes: either BM or BA
+	// 4 bytes: file size in bytes
+	// 4 bytes: reserved (always 0)
+	// 4 bytes: bitmap offset (starting position of image data in bytes)
+	const S32 FILE_HEADER_SIZE = 14;
+	if ((mdata[0] != 'B') || (mdata[1] != 'M'))
+    {
+		if ((mdata[0] != 'B') || (mdata[1] != 'A'))
+		{
+			setLastError("OS/2 bitmap array BMP files are not supported");
+			return FALSE;
+		}
+		else
+		{
+			setLastError("Does not appear to be a bitmap file");
+			return FALSE;
+		}
+	}
+
+	mBitmapOffset = mdata[13];
+	mBitmapOffset <<= 8; mBitmapOffset += mdata[12];
+	mBitmapOffset <<= 8; mBitmapOffset += mdata[11];
+	mBitmapOffset <<= 8; mBitmapOffset += mdata[10];
+
+
+	////////////////////////////////////////////////////////////////////
+	// Part 2: "Bitmap Header"
+	const S32 BITMAP_HEADER_SIZE = 40;
+	LLBMPHeader header;
+	llassert( sizeof( header ) == BITMAP_HEADER_SIZE );
+
+	memcpy((void *)&header, mdata + FILE_HEADER_SIZE, BITMAP_HEADER_SIZE);
+
+	// convert BMP header from little endian (no-op on little endian builds)
+	llendianswizzleone(header.mSize);
+	llendianswizzleone(header.mWidth);
+	llendianswizzleone(header.mHeight);
+	llendianswizzleone(header.mPlanes);
+	llendianswizzleone(header.mBitsPerPixel);
+	llendianswizzleone(header.mCompression);
+	llendianswizzleone(header.mAlignmentPadding);
+	llendianswizzleone(header.mImageSize);
+	llendianswizzleone(header.mHorzPelsPerMeter);
+	llendianswizzleone(header.mVertPelsPerMeter);
+	llendianswizzleone(header.mNumColors);
+	llendianswizzleone(header.mNumColorsImportant);
+
+	BOOL windows_nt_version = FALSE;
+	BOOL windows_95_version = FALSE;
+	if( 12 == header.mSize )
+	{
+		setLastError("Windows 2.x and OS/2 1.x BMP files are not supported");
+		return FALSE;
+	}
+	else
+	if( 40 == header.mSize )
+	{
+		if( 3 == header.mCompression )
+		{
+			// Windows NT
+			windows_nt_version = TRUE;
+		}
+		else
+		{
+			// Windows 3.x
+		}
+	}
+	else
+	if( 12 <= header.mSize && 64 <= header.mSize )
+	{
+		setLastError("OS/2 2.x BMP files are not supported");
+		return FALSE;
+	}
+	else
+	if( 108 == header.mSize )
+	{
+		// BITMAPV4HEADER
+		windows_95_version = TRUE;
+	}
+	else
+	if( 108 < header.mSize )
+	{
+		// BITMAPV5HEADER or greater
+		// Should work as long at Microsoft maintained backwards compatibility (which they did in V4 and V5)
+		windows_95_version = TRUE;
+	}
+
+	S32 width = header.mWidth;
+	S32 height = header.mHeight;
+	if (height < 0)
+	{
+		mOriginAtTop = TRUE;
+		height = -height;
+	}
+	else
+	{
+		mOriginAtTop = FALSE;
+	}
+
+	mBitsPerPixel = header.mBitsPerPixel;
+	S32 components;
+	switch( mBitsPerPixel )
+	{
+	case 8:
+		components = 1;
+		break;
+	case 24:
+	case 32:
+		components = 3;
+		break;
+	case 1:
+	case 4:
+	case 16: // Started work on 16, but doesn't work yet
+		// These are legal, but we don't support them yet.
+		setLastError("Unsupported bit depth");
+		return FALSE;
+	default:
+		setLastError("Unrecognized bit depth");
+		return FALSE;
+	}
+
+	setSize(width, height, components);
+	
+	switch( header.mCompression )
+	{
+	case 0:
+		// Uncompressed
+		break;
+
+	case 1:
+		setLastError("8 bit RLE compression not supported.");
+		return FALSE;
+
+	case 2: 
+		setLastError("4 bit RLE compression not supported.");
+		return FALSE;
+
+	case 3:
+		// Windows NT or Windows 95
+		break;
+
+	default:
+		setLastError("Unsupported compression format.");
+		return FALSE;
+	}
+
+	////////////////////////////////////////////////////////////////////
+	// Part 3: Bitfield Masks and other color data
+	S32 extension_size = 0;
+	if( windows_nt_version )
+	{
+		if( (16 != header.mBitsPerPixel) && (32 != header.mBitsPerPixel) )
+		{
+			setLastError("Bitfield encoding requires 16 or 32 bits per pixel.");
+			return FALSE;
+		}
+
+		if( 0 != header.mNumColors )
+		{
+			setLastError("Bitfield encoding is not compatible with a color table.");
+			return FALSE;
+		}
+
+		
+		extension_size = 4 * 3;
+		memcpy( mBitfieldMask, mdata + FILE_HEADER_SIZE + BITMAP_HEADER_SIZE, extension_size);
+	}
+	else
+	if( windows_95_version )
+	{
+		Win95BmpHeaderExtension win_95_extension;
+		extension_size = sizeof( win_95_extension );
+
+		llassert( sizeof( win_95_extension ) + BITMAP_HEADER_SIZE == 108 );
+		memcpy( &win_95_extension, mdata + FILE_HEADER_SIZE + BITMAP_HEADER_SIZE, sizeof( win_95_extension ) );
+
+		if( 3 == header.mCompression )
+		{
+			memcpy( mBitfieldMask, mdata + FILE_HEADER_SIZE + BITMAP_HEADER_SIZE, 4 * 4);
+		}
+
+		// Color correction ignored for now
+	}
+	
+
+	////////////////////////////////////////////////////////////////////
+	// Part 4: Color Palette (optional)
+	// Note: There's no color palette if there are 16 or more bits per pixel
+	S32 color_palette_size = 0;
+	mColorPaletteColors = 0;
+	if( header.mBitsPerPixel < 16 )
+	{
+		if( 0 == header.mNumColors )
+		{
+			mColorPaletteColors = (1 << header.mBitsPerPixel);
+		}
+		else
+		{
+			mColorPaletteColors = header.mNumColors;
+		}
+	}
+	color_palette_size = mColorPaletteColors * 4;
+
+	if( 0 != mColorPaletteColors )
+	{
+		mColorPalette = new U8[color_palette_size];
+		memcpy( mColorPalette, mdata + FILE_HEADER_SIZE + BITMAP_HEADER_SIZE + extension_size, color_palette_size );
+	}
+
+	return TRUE;
+}
+
+BOOL LLImageBMP::decode(LLImageRaw* raw_image, F32 decode_time)
+{
+	llassert_always(raw_image);
+	
+	resetLastError();
+
+	// Check to make sure that this instance has been initialized with data
+	U8* mdata = getData();
+	if (!mdata || (0 == getDataSize()))
+	{
+		setLastError("llimagebmp trying to decode an image with no data!");
+		return FALSE;
+	}
+	
+	raw_image->resize(getWidth(), getHeight(), 3);
+
+	U8* src = mdata + mBitmapOffset;
+	U8* dst = raw_image->getData();
+
+	BOOL success = FALSE;
+
+	switch( mBitsPerPixel )
+	{
+	case 8:
+		if( mColorPaletteColors >= 256 )
+		{
+			success = decodeColorTable8( dst, src );
+		}
+		break;
+	
+	case 16:
+		success = decodeColorMask16( dst, src );
+		break;
+	
+	case 24:
+		success = decodeTruecolor24( dst, src );
+		break;
+
+	case 32:
+		success = decodeColorMask32( dst, src );
+		break;
+	}
+
+	if( success && mOriginAtTop )
+	{
+		raw_image->verticalFlip();
+	}
+
+	return success;
+}
+
+U32 LLImageBMP::countTrailingZeros( U32 m )
+{
+	U32 shift_count = 0;
+	while( !(m & 1) )
+	{
+		shift_count++;
+		m >>= 1;
+	}
+	return shift_count;
+}
+
+
+BOOL LLImageBMP::decodeColorMask16( U8* dst, U8* src )
+{
+	llassert( 16 == mBitsPerPixel );
+
+	if( !mBitfieldMask[0] && !mBitfieldMask[1] && !mBitfieldMask[2] )
+	{
+		// Use default values
+		mBitfieldMask[0] = 0x00007C00;
+		mBitfieldMask[1] = 0x000003E0;
+		mBitfieldMask[2] = 0x0000001F;
+	}
+
+	S32 src_row_span = getWidth() * 2;
+	S32 alignment_bytes = (3 * src_row_span) % 4;  // round up to nearest multiple of 4
+
+	U32 r_shift = countTrailingZeros( mBitfieldMask[2] );
+	U32 g_shift = countTrailingZeros( mBitfieldMask[1] );
+	U32 b_shift = countTrailingZeros( mBitfieldMask[0] );
+
+	for( S32 row = 0; row < getHeight(); row++ )
+	{
+		for( S32 col = 0; col < getWidth(); col++ )
+		{
+			U32 value = *((U16*)src);
+			dst[0] = U8((value & mBitfieldMask[2]) >> r_shift); // Red
+			dst[1] = U8((value & mBitfieldMask[1]) >> g_shift); // Green
+			dst[2] = U8((value & mBitfieldMask[0]) >> b_shift); // Blue
+			src += 2;
+			dst += 3;
+		}
+		src += alignment_bytes;
+	}
+
+	return TRUE;
+}
+
+BOOL LLImageBMP::decodeColorMask32( U8* dst, U8* src )
+{
+	// Note: alpha is not supported
+
+	llassert( 32 == mBitsPerPixel );
+
+	if( !mBitfieldMask[0] && !mBitfieldMask[1] && !mBitfieldMask[2] )
+	{
+		// Use default values
+		mBitfieldMask[0] = 0x00FF0000;
+		mBitfieldMask[1] = 0x0000FF00;
+		mBitfieldMask[2] = 0x000000FF;
+	}
+
+
+	S32 src_row_span = getWidth() * 4;
+	S32 alignment_bytes = (3 * src_row_span) % 4;  // round up to nearest multiple of 4
+
+	U32 r_shift = countTrailingZeros( mBitfieldMask[0] );
+	U32 g_shift = countTrailingZeros( mBitfieldMask[1] );
+	U32 b_shift = countTrailingZeros( mBitfieldMask[2] );
+
+	for( S32 row = 0; row < getHeight(); row++ )
+	{
+		for( S32 col = 0; col < getWidth(); col++ )
+		{
+			U32 value = *((U32*)src);
+			dst[0] = U8((value & mBitfieldMask[0]) >> r_shift); // Red
+			dst[1] = U8((value & mBitfieldMask[1]) >> g_shift); // Green
+			dst[2] = U8((value & mBitfieldMask[2]) >> b_shift); // Blue
+			src += 4;
+			dst += 3;
+		}
+		src += alignment_bytes;
+	}
+
+	return TRUE;
+}
+
+
+BOOL LLImageBMP::decodeColorTable8( U8* dst, U8* src )
+{
+	llassert( (8 == mBitsPerPixel) && (mColorPaletteColors >= 256) );
+
+	S32 src_row_span = getWidth() * 1;
+	S32 alignment_bytes = (3 * src_row_span) % 4;  // round up to nearest multiple of 4
+
+	for( S32 row = 0; row < getHeight(); row++ )
+	{
+		for( S32 col = 0; col < getWidth(); col++ )
+		{
+			S32 index = 4 * src[0];
+			dst[0] = mColorPalette[index + 2];	// Red
+			dst[1] = mColorPalette[index + 1];	// Green
+			dst[2] = mColorPalette[index + 0];	// Blue
+			src++;
+			dst += 3;
+		}
+		src += alignment_bytes;
+	}
+
+	return TRUE;
+}
+
+
+BOOL LLImageBMP::decodeTruecolor24( U8* dst, U8* src )
+{
+	llassert( 24 == mBitsPerPixel );
+	llassert( 3 == getComponents() );
+	S32 src_row_span = getWidth() * 3;
+	S32 alignment_bytes = (3 * src_row_span) % 4;  // round up to nearest multiple of 4
+
+	for( S32 row = 0; row < getHeight(); row++ )
+	{
+		for( S32 col = 0; col < getWidth(); col++ )
+		{
+			dst[0] = src[2];	// Red
+			dst[1] = src[1];	// Green
+			dst[2] = src[0];	// Blue
+			src += 3;
+			dst += 3;
+		}
+		src += alignment_bytes;
+	}
+
+	return TRUE;
+}
+
+BOOL LLImageBMP::encode(const LLImageRaw* raw_image, F32 encode_time)
+{
+	llassert_always(raw_image);
+	
+	resetLastError();
+
+	S32 src_components = raw_image->getComponents();
+	S32 dst_components =  ( src_components < 3 ) ? 1 : 3;
+
+	if( (2 == src_components) || (4 == src_components) )
+	{
+		llinfos << "Dropping alpha information during BMP encoding" << llendl;
+	}
+
+	setSize(raw_image->getWidth(), raw_image->getHeight(), dst_components);
+	
+	U8 magic[14];
+	LLBMPHeader header;
+	int header_bytes = 14+sizeof(header);
+	llassert(header_bytes == 54);
+	if (getComponents() == 1)
+	{
+		header_bytes += 1024; // Need colour LUT.
+	}
+	int line_bytes = getComponents() * getWidth();
+	int alignment_bytes = (3 * line_bytes) % 4;
+	line_bytes += alignment_bytes;
+	int file_bytes = line_bytes*getHeight() + header_bytes;
+
+	// Allocate the new buffer for the data.
+	allocateData(file_bytes);
+
+	magic[0] = 'B'; magic[1] = 'M';
+	magic[2] = (U8) file_bytes;
+	magic[3] = (U8)(file_bytes>>8);
+	magic[4] = (U8)(file_bytes>>16);
+	magic[5] = (U8)(file_bytes>>24);
+	magic[6] = magic[7] = magic[8] = magic[9] = 0;
+	magic[10] = (U8) header_bytes;
+	magic[11] = (U8)(header_bytes>>8);
+	magic[12] = (U8)(header_bytes>>16);
+	magic[13] = (U8)(header_bytes>>24);
+	header.mSize = 40;
+	header.mWidth = getWidth();
+	header.mHeight = getHeight();
+	header.mPlanes = 1;
+	header.mBitsPerPixel = (getComponents()==1)?8:24;
+	header.mCompression = 0;
+	header.mAlignmentPadding = 0;
+	header.mImageSize = 0;
+#if LL_DARWIN
+	header.mHorzPelsPerMeter = header.mVertPelsPerMeter = 2834;	// 72dpi
+#else
+	header.mHorzPelsPerMeter = header.mVertPelsPerMeter = 0;
+#endif
+	header.mNumColors = header.mNumColorsImportant = 0;
+
+	// convert BMP header to little endian (no-op on little endian builds)
+	llendianswizzleone(header.mSize);
+	llendianswizzleone(header.mWidth);
+	llendianswizzleone(header.mHeight);
+	llendianswizzleone(header.mPlanes);
+	llendianswizzleone(header.mBitsPerPixel);
+	llendianswizzleone(header.mCompression);
+	llendianswizzleone(header.mAlignmentPadding);
+	llendianswizzleone(header.mImageSize);
+	llendianswizzleone(header.mHorzPelsPerMeter);
+	llendianswizzleone(header.mVertPelsPerMeter);
+	llendianswizzleone(header.mNumColors);
+	llendianswizzleone(header.mNumColorsImportant);
+
+	U8* mdata = getData();
+	
+	// Output magic, then header, then the palette table, then the data.
+	U32 cur_pos = 0;
+	memcpy(mdata, magic, 14);
+	cur_pos += 14;
+	memcpy(mdata+cur_pos, &header, 40);
+	cur_pos += 40;
+	if (getComponents() == 1)
+	{
+		S32 n;
+		for (n=0; n < 256; n++)
+		{
+			mdata[cur_pos++] = (U8)n;
+			mdata[cur_pos++] = (U8)n;
+			mdata[cur_pos++] = (U8)n;
+			mdata[cur_pos++] = 0;
+		}
+	}
+	
+	// Need to iterate through, because we need to flip the RGB.
+	const U8* src = raw_image->getData();
+	U8* dst = mdata + cur_pos;
+
+	for( S32 row = 0; row < getHeight(); row++ )
+	{
+		for( S32 col = 0; col < getWidth(); col++ )
+		{
+			switch( src_components )
+			{
+			case 1:
+				*dst++ = *src++;
+				break;
+			case 2:
+				{
+					U32 lum = src[0];
+					U32 alpha = src[1];
+					*dst++ = (U8)(lum * alpha / 255);
+					src += 2;
+					break;
+				}
+			case 3:
+			case 4:
+				dst[0] = src[2];
+				dst[1] = src[1];
+				dst[2] = src[0];
+				src += src_components;
+				dst += 3;
+				break;
+			}
+
+			for( S32 i = 0; i < alignment_bytes; i++ )
+			{
+				*dst++ = 0;
+			}
+		}
+	}
+
+	return TRUE;
+}
-- 
cgit v1.1