framework/common/tcuPixelFormat.hpp

#ifndef _TCUPIXELFORMAT_HPP
#define _TCUPIXELFORMAT_HPP
/*-------------------------------------------------------------------------
 * drawElements Quality Program Tester Core
 * ----------------------------------------
 *
 * Copyright 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *//*!
 * \file
 * \brief Pixel format descriptor.
 *//*--------------------------------------------------------------------*/

#include "tcuDefs.hpp"
#include "tcuRGBA.hpp"

namespace tcu
{

/*--------------------------------------------------------------------*//*!
 * \brief Fixed-point render target pixel format
 *//*--------------------------------------------------------------------*/
struct PixelFormat
{
	int redBits;
	int greenBits;
	int blueBits;
	int alphaBits;

	PixelFormat (int red, int green, int blue, int alpha)
		: redBits(red)
		, greenBits(green)
		, blueBits(blue)
		, alphaBits(alpha)
	{
	}

	PixelFormat (void)
		: redBits(0)
		, greenBits(0)
		, blueBits(0)
		, alphaBits(0)
	{
	}

	static inline int channelThreshold(int bits)
	{
		if (bits <= 8)
		{
			// Threshold is 2^(8 - bits)
			return 1 << (8 - bits);
		}
		else
		{
			// Threshold is bound by the 8-bit buffer value
			return 1;
		}
	}

	/*--------------------------------------------------------------------*//*!
	 * \brief Get default threshold for per-pixel comparison for this format
	 *
	 * Per-channel threshold is 2^(8-bits). If alpha channel bits are zero,
	 * threshold for that channel is 0.
	 *//*--------------------------------------------------------------------*/
	inline RGBA getColorThreshold (void) const
	{
		return RGBA(
			channelThreshold(redBits),
			channelThreshold(greenBits),
			channelThreshold(blueBits),
			alphaBits ? channelThreshold(alphaBits) : 0);
	}

	static inline int convertChannel (int val, int bits)
	{
		if (bits == 0)
		{
			return 0;
		}
		else if (bits == 1)
		{
			return (val & 0x80) ? 0xff : 0;
		}
		else if (bits < 8)
		{
			// Emulate precision reduction by replicating the upper bits as the fractional component
			int intComp   = val >> (8 - bits);
			int fractComp = (intComp << (24 - bits)) | (intComp << (24 - 2 * bits)) | (intComp << (24 - 3 * bits));
			return (intComp << (8 - bits)) | (fractComp >> (bits + 16));
		}
		else
		{
			// Bits greater than or equal to 8 will have full precision, so no reduction
			return val;
		}
	}

	/*--------------------------------------------------------------------*//*!
	 * \brief Emulate reduced bit depth
	 *
	 * The color value bit depth is reduced and converted back. The lowest
	 * bits are filled by replicating the upper bits.
	 *//*--------------------------------------------------------------------*/
	inline RGBA convertColor (const RGBA& col) const
	{
		return RGBA(convertChannel(col.getRed(),	redBits),
					convertChannel(col.getGreen(),	greenBits),
					convertChannel(col.getBlue(),	blueBits),
					alphaBits ? convertChannel(col.getAlpha(), alphaBits) : 0xff);
	}

	inline bool operator== (const PixelFormat& other) const
	{
		return redBits		== other.redBits	&&
			   greenBits	== other.greenBits	&&
			   blueBits		== other.blueBits	&&
			   alphaBits	== other.alphaBits;
	}

	inline bool operator!= (const PixelFormat& other) const
	{
		return !(*this == other);
	}
} DE_WARN_UNUSED_TYPE;

} // namespace tcu

#endif // _TCUPIXELFORMAT_HPP