WebSVN – Kolibri OS – Blame – /contrib/sdk/sources/Mesa/src/mesa/main/pack.c

Rev	Author	Line No.	Line
4358	Serge	1	/*
		2	* Mesa 3-D graphics library
		3	*
		4	* Copyright (C) 1999-2008 Brian Paul All Rights Reserved.
		5	* Copyright (C) 2009-2010 VMware, Inc. All Rights Reserved.
		6	*
		7	* Permission is hereby granted, free of charge, to any person obtaining a
		8	* copy of this software and associated documentation files (the "Software"),
		9	* to deal in the Software without restriction, including without limitation
		10	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
		11	* and/or sell copies of the Software, and to permit persons to whom the
		12	* Software is furnished to do so, subject to the following conditions:
		13	*
		14	* The above copyright notice and this permission notice shall be included
		15	* in all copies or substantial portions of the Software.
		16	*
		17	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
		18	* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		19	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
		20	* THEA AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
		21	* AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
		22	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
		23	*/
		24
		25
		26	/**
		27	* \file pack.c
		28	* Image and pixel span packing and unpacking.
		29	*/
		30
		31
		32	/*
		33	* XXX: MSVC takes forever to compile this module for x86_64 unless we disable
		34	* this global optimization.
		35	*
		36	* See also:
		37	* - http://msdn.microsoft.com/en-us/library/1yk3ydd7.aspx
		38	* - http://msdn.microsoft.com/en-us/library/chh3fb0k.aspx
		39	*/
		40	#if defined(_MSC_VER) && defined(_M_X64)
		41	# pragma optimize( "g", off )
		42	#endif
		43
		44
		45	#include "glheader.h"
		46	#include "colormac.h"
		47	#include "enums.h"
		48	#include "image.h"
		49	#include "imports.h"
		50	#include "macros.h"
		51	#include "mtypes.h"
		52	#include "pack.h"
		53	#include "pixeltransfer.h"
		54	#include "imports.h"
		55	#include "glformats.h"
		56	#include "../../gallium/auxiliary/util/u_format_rgb9e5.h"
		57	#include "../../gallium/auxiliary/util/u_format_r11g11b10f.h"
		58
		59
		60	/**
		61	* Flip the 8 bits in each byte of the given array.
		62	*
		63	* \param p array.
		64	* \param n number of bytes.
		65	*
		66	* \todo try this trick to flip bytes someday:
		67	* \code
		68	* v = ((v & 0x55555555) << 1) \| ((v >> 1) & 0x55555555);
		69	* v = ((v & 0x33333333) << 2) \| ((v >> 2) & 0x33333333);
		70	* v = ((v & 0x0f0f0f0f) << 4) \| ((v >> 4) & 0x0f0f0f0f);
		71	* \endcode
		72	*/
		73	static void
		74	flip_bytes( GLubyte *p, GLuint n )
		75	{
		76	GLuint i, a, b;
		77	for (i = 0; i < n; i++) {
		78	b = (GLuint) p[i]; /* words are often faster than bytes */
		79	a = ((b & 0x01) << 7) \|
		80	((b & 0x02) << 5) \|
		81	((b & 0x04) << 3) \|
		82	((b & 0x08) << 1) \|
		83	((b & 0x10) >> 1) \|
		84	((b & 0x20) >> 3) \|
		85	((b & 0x40) >> 5) \|
		86	((b & 0x80) >> 7);
		87	p[i] = (GLubyte) a;
		88	}
		89	}
		90
		91
		92
		93	/*
		94	* Unpack a 32x32 pixel polygon stipple from user memory using the
		95	* current pixel unpack settings.
		96	*/
		97	void
		98	_mesa_unpack_polygon_stipple( const GLubyte *pattern, GLuint dest[32],
		99	const struct gl_pixelstore_attrib *unpacking )
		100	{
		101	GLubyte ptrn = (GLubyte ) _mesa_unpack_bitmap(32, 32, pattern, unpacking);
		102	if (ptrn) {
		103	/* Convert pattern from GLubytes to GLuints and handle big/little
		104	* endian differences
		105	*/
		106	GLubyte *p = ptrn;
		107	GLint i;
		108	for (i = 0; i < 32; i++) {
		109	dest[i] = (p[0] << 24)
		110	\| (p[1] << 16)
		111	\| (p[2] << 8)
		112	\| (p[3] );
		113	p += 4;
		114	}
		115	free(ptrn);
		116	}
		117	}
		118
		119
		120	/*
		121	* Pack polygon stipple into user memory given current pixel packing
		122	* settings.
		123	*/
		124	void
		125	_mesa_pack_polygon_stipple( const GLuint pattern[32], GLubyte *dest,
		126	const struct gl_pixelstore_attrib *packing )
		127	{
		128	/* Convert pattern from GLuints to GLubytes to handle big/little
		129	* endian differences.
		130	*/
		131	GLubyte ptrn[32*4];
		132	GLint i;
		133	for (i = 0; i < 32; i++) {
		134	ptrn[i * 4 + 0] = (GLubyte) ((pattern[i] >> 24) & 0xff);
		135	ptrn[i * 4 + 1] = (GLubyte) ((pattern[i] >> 16) & 0xff);
		136	ptrn[i * 4 + 2] = (GLubyte) ((pattern[i] >> 8 ) & 0xff);
		137	ptrn[i * 4 + 3] = (GLubyte) ((pattern[i] ) & 0xff);
		138	}
		139
		140	_mesa_pack_bitmap(32, 32, ptrn, dest, packing);
		141	}
		142
		143
		144	/*
		145	* Unpack bitmap data. Resulting data will be in most-significant-bit-first
		146	* order with row alignment = 1 byte.
		147	*/
		148	GLvoid *
		149	_mesa_unpack_bitmap( GLint width, GLint height, const GLubyte *pixels,
		150	const struct gl_pixelstore_attrib *packing )
		151	{
		152	GLint bytes, row, width_in_bytes;
		153	GLubyte buffer, dst;
		154
		155	if (!pixels)
		156	return NULL;
		157
		158	/* Alloc dest storage */
		159	bytes = ((width + 7) / 8 * height);
		160	buffer = malloc( bytes );
		161	if (!buffer)
		162	return NULL;
		163
		164	width_in_bytes = CEILING( width, 8 );
		165	dst = buffer;
		166	for (row = 0; row < height; row++) {
		167	const GLubyte src = (const GLubyte )
		168	_mesa_image_address2d(packing, pixels, width, height,
		169	GL_COLOR_INDEX, GL_BITMAP, row, 0);
		170	if (!src) {
		171	free(buffer);
		172	return NULL;
		173	}
		174
		175	if ((packing->SkipPixels & 7) == 0) {
		176	memcpy( dst, src, width_in_bytes );
		177	if (packing->LsbFirst) {
		178	flip_bytes( dst, width_in_bytes );
		179	}
		180	}
		181	else {
		182	/* handling SkipPixels is a bit tricky (no pun intended!) */
		183	GLint i;
		184	if (packing->LsbFirst) {
		185	GLubyte srcMask = 1 << (packing->SkipPixels & 0x7);
		186	GLubyte dstMask = 128;
		187	const GLubyte *s = src;
		188	GLubyte *d = dst;
		189	*d = 0;
		190	for (i = 0; i < width; i++) {
		191	if (*s & srcMask) {
		192	*d \|= dstMask;
		193	}
		194	if (srcMask == 128) {
		195	srcMask = 1;
		196	s++;
		197	}
		198	else {
		199	srcMask = srcMask << 1;
		200	}
		201	if (dstMask == 1) {
		202	dstMask = 128;
		203	d++;
		204	*d = 0;
		205	}
		206	else {
		207	dstMask = dstMask >> 1;
		208	}
		209	}
		210	}
		211	else {
		212	GLubyte srcMask = 128 >> (packing->SkipPixels & 0x7);
		213	GLubyte dstMask = 128;
		214	const GLubyte *s = src;
		215	GLubyte *d = dst;
		216	*d = 0;
		217	for (i = 0; i < width; i++) {
		218	if (*s & srcMask) {
		219	*d \|= dstMask;
		220	}
		221	if (srcMask == 1) {
		222	srcMask = 128;
		223	s++;
		224	}
		225	else {
		226	srcMask = srcMask >> 1;
		227	}
		228	if (dstMask == 1) {
		229	dstMask = 128;
		230	d++;
		231	*d = 0;
		232	}
		233	else {
		234	dstMask = dstMask >> 1;
		235	}
		236	}
		237	}
		238	}
		239	dst += width_in_bytes;
		240	}
		241
		242	return buffer;
		243	}
		244
		245
		246	/*
		247	* Pack bitmap data.
		248	*/
		249	void
		250	_mesa_pack_bitmap( GLint width, GLint height, const GLubyte *source,
		251	GLubyte dest, const struct gl_pixelstore_attrib packing )
		252	{
		253	GLint row, width_in_bytes;
		254	const GLubyte *src;
		255
		256	if (!source)
		257	return;
		258
		259	width_in_bytes = CEILING( width, 8 );
		260	src = source;
		261	for (row = 0; row < height; row++) {
		262	GLubyte dst = (GLubyte ) _mesa_image_address2d(packing, dest,
		263	width, height, GL_COLOR_INDEX, GL_BITMAP, row, 0);
		264	if (!dst)
		265	return;
		266
		267	if ((packing->SkipPixels & 7) == 0) {
		268	memcpy( dst, src, width_in_bytes );
		269	if (packing->LsbFirst) {
		270	flip_bytes( dst, width_in_bytes );
		271	}
		272	}
		273	else {
		274	/* handling SkipPixels is a bit tricky (no pun intended!) */
		275	GLint i;
		276	if (packing->LsbFirst) {
		277	GLubyte srcMask = 128;
		278	GLubyte dstMask = 1 << (packing->SkipPixels & 0x7);
		279	const GLubyte *s = src;
		280	GLubyte *d = dst;
		281	*d = 0;
		282	for (i = 0; i < width; i++) {
		283	if (*s & srcMask) {
		284	*d \|= dstMask;
		285	}
		286	if (srcMask == 1) {
		287	srcMask = 128;
		288	s++;
		289	}
		290	else {
		291	srcMask = srcMask >> 1;
		292	}
		293	if (dstMask == 128) {
		294	dstMask = 1;
		295	d++;
		296	*d = 0;
		297	}
		298	else {
		299	dstMask = dstMask << 1;
		300	}
		301	}
		302	}
		303	else {
		304	GLubyte srcMask = 128;
		305	GLubyte dstMask = 128 >> (packing->SkipPixels & 0x7);
		306	const GLubyte *s = src;
		307	GLubyte *d = dst;
		308	*d = 0;
		309	for (i = 0; i < width; i++) {
		310	if (*s & srcMask) {
		311	*d \|= dstMask;
		312	}
		313	if (srcMask == 1) {
		314	srcMask = 128;
		315	s++;
		316	}
		317	else {
		318	srcMask = srcMask >> 1;
		319	}
		320	if (dstMask == 1) {
		321	dstMask = 128;
		322	d++;
		323	*d = 0;
		324	}
		325	else {
		326	dstMask = dstMask >> 1;
		327	}
		328	}
		329	}
		330	}
		331	src += width_in_bytes;
		332	}
		333	}
		334
		335
		336	/**
		337	* Get indexes of color components for a basic color format, such as
		338	* GL_RGBA, GL_RED, GL_LUMINANCE_ALPHA, etc. Return -1 for indexes
		339	* that do not apply.
		340	*/
		341	static void
		342	get_component_indexes(GLenum format,
		343	GLint *redIndex,
		344	GLint *greenIndex,
		345	GLint *blueIndex,
		346	GLint *alphaIndex,
		347	GLint *luminanceIndex,
		348	GLint *intensityIndex)
		349	{
		350	*redIndex = -1;
		351	*greenIndex = -1;
		352	*blueIndex = -1;
		353	*alphaIndex = -1;
		354	*luminanceIndex = -1;
		355	*intensityIndex = -1;
		356
		357	switch (format) {
		358	case GL_LUMINANCE:
		359	case GL_LUMINANCE_INTEGER_EXT:
		360	*luminanceIndex = 0;
		361	break;
		362	case GL_LUMINANCE_ALPHA:
		363	case GL_LUMINANCE_ALPHA_INTEGER_EXT:
		364	*luminanceIndex = 0;
		365	*alphaIndex = 1;
		366	break;
		367	case GL_INTENSITY:
		368	*intensityIndex = 0;
		369	break;
		370	case GL_RED:
		371	case GL_RED_INTEGER_EXT:
		372	*redIndex = 0;
		373	break;
		374	case GL_GREEN:
		375	case GL_GREEN_INTEGER_EXT:
		376	*greenIndex = 0;
		377	break;
		378	case GL_BLUE:
		379	case GL_BLUE_INTEGER_EXT:
		380	*blueIndex = 0;
		381	break;
		382	case GL_ALPHA:
		383	case GL_ALPHA_INTEGER_EXT:
		384	*alphaIndex = 0;
		385	break;
		386	case GL_RG:
		387	case GL_RG_INTEGER:
		388	*redIndex = 0;
		389	*greenIndex = 1;
		390	break;
		391	case GL_RGB:
		392	case GL_RGB_INTEGER_EXT:
		393	*redIndex = 0;
		394	*greenIndex = 1;
		395	*blueIndex = 2;
		396	break;
		397	case GL_BGR:
		398	case GL_BGR_INTEGER_EXT:
		399	*blueIndex = 0;
		400	*greenIndex = 1;
		401	*redIndex = 2;
		402	break;
		403	case GL_RGBA:
		404	case GL_RGBA_INTEGER_EXT:
		405	*redIndex = 0;
		406	*greenIndex = 1;
		407	*blueIndex = 2;
		408	*alphaIndex = 3;
		409	break;
		410	case GL_BGRA:
		411	case GL_BGRA_INTEGER:
		412	*redIndex = 2;
		413	*greenIndex = 1;
		414	*blueIndex = 0;
		415	*alphaIndex = 3;
		416	break;
		417	case GL_ABGR_EXT:
		418	*redIndex = 3;
		419	*greenIndex = 2;
		420	*blueIndex = 1;
		421	*alphaIndex = 0;
		422	break;
		423	case GL_DU8DV8_ATI:
		424	case GL_DUDV_ATI:
		425	*redIndex = 0;
		426	*greenIndex = 1;
		427	break;
		428	default:
		429	assert(0 && "bad format in get_component_indexes()");
		430	}
		431	}
		432
		433
		434
		435	/**
		436	* For small integer types, return the min and max possible values.
		437	* Used for clamping floats to unscaled integer types.
		438	* \return GL_TRUE if type is handled, GL_FALSE otherwise.
		439	*/
		440	static GLboolean
		441	get_type_min_max(GLenum type, GLfloat min, GLfloat max)
		442	{
		443	switch (type) {
		444	case GL_BYTE:
		445	*min = -128.0;
		446	*max = 127.0;
		447	return GL_TRUE;
		448	case GL_UNSIGNED_BYTE:
		449	*min = 0.0;
		450	*max = 255.0;
		451	return GL_TRUE;
		452	case GL_SHORT:
		453	*min = -32768.0;
		454	*max = 32767.0;
		455	return GL_TRUE;
		456	case GL_UNSIGNED_SHORT:
		457	*min = 0.0;
		458	*max = 65535.0;
		459	return GL_TRUE;
		460	default:
		461	return GL_FALSE;
		462	}
		463	}
		464
		465	/* Customization of unsigned integer packing.
		466	*/
		467	#define SRC_TYPE GLuint
		468
		469	#define DST_TYPE GLuint
		470	#define SRC_CONVERT(x) (x)
		471	#define FN_NAME pack_uint_from_uint_rgba
		472	#include "pack_tmp.h"
		473	#undef DST_TYPE
		474	#undef SRC_CONVERT
		475	#undef FN_NAME
		476
		477	#define DST_TYPE GLint
		478	#define SRC_CONVERT(x) MIN2(x, 0x7fffffff)
		479	#define FN_NAME pack_int_from_uint_rgba
		480	#include "pack_tmp.h"
		481	#undef DST_TYPE
		482	#undef SRC_CONVERT
		483	#undef FN_NAME
		484
		485	#define DST_TYPE GLushort
		486	#define SRC_CONVERT(x) MIN2(x, 0xffff)
		487	#define FN_NAME pack_ushort_from_uint_rgba
		488	#include "pack_tmp.h"
		489	#undef DST_TYPE
		490	#undef SRC_CONVERT
		491	#undef FN_NAME
		492
		493	#define DST_TYPE GLshort
		494	#define SRC_CONVERT(x) CLAMP((int)x, -32768, 32767)
		495	#define FN_NAME pack_short_from_uint_rgba
		496	#include "pack_tmp.h"
		497	#undef DST_TYPE
		498	#undef SRC_CONVERT
		499	#undef FN_NAME
		500
		501	#define DST_TYPE GLubyte
		502	#define SRC_CONVERT(x) MIN2(x, 0xff)
		503	#define FN_NAME pack_ubyte_from_uint_rgba
		504	#include "pack_tmp.h"
		505	#undef DST_TYPE
		506	#undef SRC_CONVERT
		507	#undef FN_NAME
		508
		509	#define DST_TYPE GLbyte
		510	#define SRC_CONVERT(x) CLAMP((int)x, -128, 127)
		511	#define FN_NAME pack_byte_from_uint_rgba
		512	#include "pack_tmp.h"
		513	#undef DST_TYPE
		514	#undef SRC_CONVERT
		515	#undef FN_NAME
		516
		517	#undef SRC_TYPE
		518
		519	static void
		520	_pack_rgba_span_from_uints_problem(struct gl_context *ctx,
		521	GLenum dstFormat, GLenum dstType)
		522	{
		523	_mesa_problem(ctx,
		524	"Unsupported type (%s) / format (%s) "
		525	"in _mesa_pack_rgba_span_from_uints",
		526	_mesa_lookup_enum_by_nr(dstType),
		527	_mesa_lookup_enum_by_nr(dstFormat));
		528	}
		529
		530	void
		531	_mesa_pack_rgba_span_from_uints(struct gl_context *ctx, GLuint n, GLuint rgba[][4],
		532	GLenum dstFormat, GLenum dstType,
		533	GLvoid *dstAddr)
		534	{
		535	GLuint i;
		536
		537	switch(dstType) {
		538	case GL_UNSIGNED_INT:
		539	pack_uint_from_uint_rgba(ctx, dstAddr, dstFormat, rgba, n);
		540	break;
		541	case GL_INT:
		542	pack_int_from_uint_rgba(ctx, dstAddr, dstFormat, rgba, n);
		543	break;
		544	case GL_UNSIGNED_SHORT:
		545	pack_ushort_from_uint_rgba(ctx, dstAddr, dstFormat, rgba, n);
		546	break;
		547	case GL_SHORT:
		548	pack_short_from_uint_rgba(ctx, dstAddr, dstFormat, rgba, n);
		549	break;
		550	case GL_UNSIGNED_BYTE:
		551	pack_ubyte_from_uint_rgba(ctx, dstAddr, dstFormat, rgba, n);
		552	break;
		553	case GL_BYTE:
		554	pack_byte_from_uint_rgba(ctx, dstAddr, dstFormat, rgba, n);
		555	break;
		556	case GL_UNSIGNED_BYTE_3_3_2:
		557	if ((dstFormat == GL_RGB) \|\| (dstFormat == GL_RGB_INTEGER)) {
		558	GLubyte dst = (GLubyte ) dstAddr;
		559	for (i=0;i
		560	dst[i] = (MIN2(rgba[i][RCOMP], 7) << 5)
		561	\| (MIN2(rgba[i][GCOMP], 7) << 2)
		562	\| (MIN2(rgba[i][BCOMP], 3) );
		563	}
		564	} else {
		565	_pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
		566	}
		567	break;
		568	case GL_UNSIGNED_BYTE_2_3_3_REV:
		569	if ((dstFormat == GL_RGB) \|\| (dstFormat == GL_RGB_INTEGER)) {
		570	GLubyte dst = (GLubyte ) dstAddr;
		571	for (i=0;i
		572	dst[i] = (MIN2(rgba[i][RCOMP], 7) )
		573	\| (MIN2(rgba[i][GCOMP], 7) << 3)
		574	\| (MIN2(rgba[i][BCOMP], 3) << 6);
		575	}
		576	} else {
		577	_pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
		578	}
		579	break;
		580	case GL_UNSIGNED_SHORT_5_6_5:
		581	if ((dstFormat == GL_RGB) \|\| (dstFormat == GL_RGB_INTEGER)) {
		582	GLushort dst = (GLushort ) dstAddr;
		583	for (i=0;i
		584	dst[i] = (MIN2(rgba[i][RCOMP], 31) << 11)
		585	\| (MIN2(rgba[i][GCOMP], 63) << 5)
		586	\| (MIN2(rgba[i][BCOMP], 31) );
		587	}
		588	} else {
		589	_pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
		590	}
		591	break;
		592	case GL_UNSIGNED_SHORT_5_6_5_REV:
		593	if ((dstFormat == GL_RGB) \|\| (dstFormat == GL_RGB_INTEGER)) {
		594	GLushort dst = (GLushort ) dstAddr;
		595	for (i=0;i
		596	dst[i] = (MIN2(rgba[i][RCOMP], 31) )
		597	\| (MIN2(rgba[i][GCOMP], 63) << 5)
		598	\| (MIN2(rgba[i][BCOMP], 31) << 11);
		599	}
		600	} else {
		601	_pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
		602	}
		603	break;
		604	case GL_UNSIGNED_SHORT_4_4_4_4:
		605	if ((dstFormat == GL_RGBA) \|\| (dstFormat == GL_RGBA_INTEGER_EXT)) {
		606	GLushort dst = (GLushort ) dstAddr;
		607	for (i=0;i
		608	dst[i] = (MIN2(rgba[i][RCOMP], 15) << 12)
		609	\| (MIN2(rgba[i][GCOMP], 15) << 8)
		610	\| (MIN2(rgba[i][BCOMP], 15) << 4)
		611	\| (MIN2(rgba[i][ACOMP], 15) );
		612	}
		613	}
		614	else if ((dstFormat == GL_BGRA) \|\| (dstFormat == GL_BGRA_INTEGER)) {
		615	GLushort dst = (GLushort ) dstAddr;
		616	for (i=0;i
		617	dst[i] = (MIN2(rgba[i][BCOMP], 15) << 12)
		618	\| (MIN2(rgba[i][GCOMP], 15) << 8)
		619	\| (MIN2(rgba[i][RCOMP], 15) << 4)
		620	\| (MIN2(rgba[i][ACOMP], 15) );
		621	}
		622	}
		623	else if (dstFormat == GL_ABGR_EXT) {
		624	GLushort dst = (GLushort ) dstAddr;
		625	for (i=0;i
		626	dst[i] = (MIN2(rgba[i][ACOMP], 15) << 12)
		627	\| (MIN2(rgba[i][BCOMP], 15) << 8)
		628	\| (MIN2(rgba[i][GCOMP], 15) << 4)
		629	\| (MIN2(rgba[i][RCOMP], 15) );
		630	}
		631	} else {
		632	_pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
		633	}
		634	break;
		635	case GL_UNSIGNED_SHORT_4_4_4_4_REV:
		636	if ((dstFormat == GL_RGBA) \|\| (dstFormat == GL_RGBA_INTEGER_EXT)) {
		637	GLushort dst = (GLushort ) dstAddr;
		638	for (i=0;i
		639	dst[i] = (MIN2(rgba[i][RCOMP], 15) )
		640	\| (MIN2(rgba[i][GCOMP], 15) << 4)
		641	\| (MIN2(rgba[i][BCOMP], 15) << 8)
		642	\| (MIN2(rgba[i][ACOMP], 15) << 12);
		643	}
		644	}
		645	else if ((dstFormat == GL_BGRA) \|\| (dstFormat == GL_BGRA_INTEGER)) {
		646	GLushort dst = (GLushort ) dstAddr;
		647	for (i=0;i
		648	dst[i] = (MIN2(rgba[i][BCOMP], 15) )
		649	\| (MIN2(rgba[i][GCOMP], 15) << 4)
		650	\| (MIN2(rgba[i][RCOMP], 15) << 8)
		651	\| (MIN2(rgba[i][ACOMP], 15) << 12);
		652	}
		653	}
		654	else if (dstFormat == GL_ABGR_EXT) {
		655	GLushort dst = (GLushort ) dstAddr;
		656	for (i=0;i
		657	dst[i] = (MIN2(rgba[i][ACOMP], 15) )
		658	\| (MIN2(rgba[i][BCOMP], 15) << 4)
		659	\| (MIN2(rgba[i][GCOMP], 15) << 8)
		660	\| (MIN2(rgba[i][RCOMP], 15) << 12);
		661	}
		662	} else {
		663	_pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
		664	}
		665	break;
		666	case GL_UNSIGNED_SHORT_5_5_5_1:
		667	if ((dstFormat == GL_RGBA) \|\| (dstFormat == GL_RGBA_INTEGER_EXT)) {
		668	GLushort dst = (GLushort ) dstAddr;
		669	for (i=0;i
		670	dst[i] = (MIN2(rgba[i][RCOMP], 31) << 11)
		671	\| (MIN2(rgba[i][GCOMP], 31) << 6)
		672	\| (MIN2(rgba[i][BCOMP], 31) << 1)
		673	\| (MIN2(rgba[i][ACOMP], 1) );
		674	}
		675	}
		676	else if ((dstFormat == GL_BGRA) \|\| (dstFormat == GL_BGRA_INTEGER)) {
		677	GLushort dst = (GLushort ) dstAddr;
		678	for (i=0;i
		679	dst[i] = (MIN2(rgba[i][BCOMP], 31) << 11)
		680	\| (MIN2(rgba[i][GCOMP], 31) << 6)
		681	\| (MIN2(rgba[i][RCOMP], 31) << 1)
		682	\| (MIN2(rgba[i][ACOMP], 1) );
		683	}
		684	}
		685	else if (dstFormat == GL_ABGR_EXT) {
		686	GLushort dst = (GLushort ) dstAddr;
		687	for (i=0;i
		688	dst[i] = (MIN2(rgba[i][ACOMP], 31) << 11)
		689	\| (MIN2(rgba[i][BCOMP], 31) << 6)
		690	\| (MIN2(rgba[i][GCOMP], 31) << 1)
		691	\| (MIN2(rgba[i][RCOMP], 1) );
		692	}
		693	} else {
		694	_pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
		695	}
		696	break;
		697	case GL_UNSIGNED_SHORT_1_5_5_5_REV:
		698	if ((dstFormat == GL_RGBA) \|\| (dstFormat == GL_RGBA_INTEGER_EXT)) {
		699	GLushort dst = (GLushort ) dstAddr;
		700	for (i=0;i
		701	dst[i] = (MIN2(rgba[i][RCOMP], 31) )
		702	\| (MIN2(rgba[i][GCOMP], 31) << 5)
		703	\| (MIN2(rgba[i][BCOMP], 31) << 10)
		704	\| (MIN2(rgba[i][ACOMP], 1) << 15);
		705	}
		706	}
		707	else if ((dstFormat == GL_BGRA) \|\| (dstFormat == GL_BGRA_INTEGER)) {
		708	GLushort dst = (GLushort ) dstAddr;
		709	for (i=0;i
		710	dst[i] = (MIN2(rgba[i][BCOMP], 31) )
		711	\| (MIN2(rgba[i][GCOMP], 31) << 5)
		712	\| (MIN2(rgba[i][RCOMP], 31) << 10)
		713	\| (MIN2(rgba[i][ACOMP], 1) << 15);
		714	}
		715	}
		716	else if (dstFormat == GL_ABGR_EXT) {
		717	GLushort dst = (GLushort ) dstAddr;
		718	for (i=0;i
		719	dst[i] = (MIN2(rgba[i][ACOMP], 31) )
		720	\| (MIN2(rgba[i][BCOMP], 31) << 5)
		721	\| (MIN2(rgba[i][GCOMP], 31) << 10)
		722	\| (MIN2(rgba[i][RCOMP], 1) << 15);
		723	}
		724	} else {
		725	_pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
		726	}
		727	break;
		728	case GL_UNSIGNED_INT_8_8_8_8:
		729	if ((dstFormat == GL_RGBA) \|\| (dstFormat == GL_RGBA_INTEGER_EXT)) {
		730	GLuint dst = (GLuint ) dstAddr;
		731	for (i=0;i
		732	dst[i] = (MIN2(rgba[i][RCOMP], 255) << 24)
		733	\| (MIN2(rgba[i][GCOMP], 255) << 16)
		734	\| (MIN2(rgba[i][BCOMP], 255) << 8)
		735	\| (MIN2(rgba[i][ACOMP], 255) );
		736	}
		737	}
		738	else if ((dstFormat == GL_BGRA) \|\| (dstFormat == GL_BGRA_INTEGER)) {
		739	GLuint dst = (GLuint ) dstAddr;
		740	for (i=0;i
		741	dst[i] = (MIN2(rgba[i][BCOMP], 255) << 24)
		742	\| (MIN2(rgba[i][GCOMP], 255) << 16)
		743	\| (MIN2(rgba[i][RCOMP], 255) << 8)
		744	\| (MIN2(rgba[i][ACOMP], 255) );
		745	}
		746	}
		747	else if (dstFormat == GL_ABGR_EXT) {
		748	GLuint dst = (GLuint ) dstAddr;
		749	for (i=0;i
		750	dst[i] = (MIN2(rgba[i][ACOMP], 255) << 24)
		751	\| (MIN2(rgba[i][BCOMP], 255) << 16)
		752	\| (MIN2(rgba[i][GCOMP], 255) << 8)
		753	\| (MIN2(rgba[i][RCOMP], 255) );
		754	}
		755	} else {
		756	_pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
		757	}
		758	break;
		759	case GL_UNSIGNED_INT_8_8_8_8_REV:
		760	if ((dstFormat == GL_RGBA) \|\| (dstFormat == GL_RGBA_INTEGER_EXT)) {
		761	GLuint dst = (GLuint ) dstAddr;
		762	for (i=0;i
		763	dst[i] = (MIN2(rgba[i][RCOMP], 255) )
		764	\| (MIN2(rgba[i][GCOMP], 255) << 8)
		765	\| (MIN2(rgba[i][BCOMP], 255) << 16)
		766	\| (MIN2(rgba[i][ACOMP], 255) << 24);
		767	}
		768	}
		769	else if ((dstFormat == GL_BGRA) \|\| (dstFormat == GL_BGRA_INTEGER)) {
		770	GLuint dst = (GLuint ) dstAddr;
		771	for (i=0;i
		772	dst[i] = (MIN2(rgba[i][BCOMP], 255) )
		773	\| (MIN2(rgba[i][GCOMP], 255) << 8)
		774	\| (MIN2(rgba[i][RCOMP], 255) << 16)
		775	\| (MIN2(rgba[i][ACOMP], 255) << 24);
		776	}
		777	}
		778	else if (dstFormat == GL_ABGR_EXT) {
		779	GLuint dst = (GLuint ) dstAddr;
		780	for (i=0;i
		781	dst[i] = (MIN2(rgba[i][ACOMP], 255) )
		782	\| (MIN2(rgba[i][BCOMP], 255) << 8)
		783	\| (MIN2(rgba[i][GCOMP], 255) << 16)
		784	\| (MIN2(rgba[i][RCOMP], 255) << 24);
		785	}
		786	} else {
		787	_pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
		788	}
		789	break;
		790	case GL_UNSIGNED_INT_10_10_10_2:
		791	if ((dstFormat == GL_RGBA) \|\| (dstFormat == GL_RGBA_INTEGER_EXT)) {
		792	GLuint dst = (GLuint ) dstAddr;
		793	for (i=0;i
		794	dst[i] = (MIN2(rgba[i][RCOMP], 1023) << 22)
		795	\| (MIN2(rgba[i][GCOMP], 1023) << 12)
		796	\| (MIN2(rgba[i][BCOMP], 1023) << 2)
		797	\| (MIN2(rgba[i][ACOMP], 3) );
		798	}
		799	}
		800	else if ((dstFormat == GL_BGRA) \|\| (dstFormat == GL_BGRA_INTEGER)) {
		801	GLuint dst = (GLuint ) dstAddr;
		802	for (i=0;i
		803	dst[i] = (MIN2(rgba[i][BCOMP], 1023) << 22)
		804	\| (MIN2(rgba[i][GCOMP], 1023) << 12)
		805	\| (MIN2(rgba[i][RCOMP], 1023) << 2)
		806	\| (MIN2(rgba[i][ACOMP], 3) );
		807	}
		808	}
		809	else if (dstFormat == GL_ABGR_EXT) {
		810	GLuint dst = (GLuint ) dstAddr;
		811	for (i=0;i
		812	dst[i] = (MIN2(rgba[i][ACOMP], 1023) << 22)
		813	\| (MIN2(rgba[i][BCOMP], 1023) << 12)
		814	\| (MIN2(rgba[i][GCOMP], 1023) << 2)
		815	\| (MIN2(rgba[i][RCOMP], 3) );
		816	}
		817	} else {
		818	_pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
		819	}
		820	break;
		821	case GL_UNSIGNED_INT_2_10_10_10_REV:
		822	if ((dstFormat == GL_RGBA) \|\| (dstFormat == GL_RGBA_INTEGER_EXT)) {
		823	GLuint dst = (GLuint ) dstAddr;
		824	for (i=0;i
		825	dst[i] = (MIN2(rgba[i][RCOMP], 1023) )
		826	\| (MIN2(rgba[i][GCOMP], 1023) << 10)
		827	\| (MIN2(rgba[i][BCOMP], 1023) << 20)
		828	\| (MIN2(rgba[i][ACOMP], 3) << 30);
		829	}
		830	}
		831	else if ((dstFormat == GL_BGRA) \|\| (dstFormat == GL_BGRA_INTEGER)) {
		832	GLuint dst = (GLuint ) dstAddr;
		833	for (i=0;i
		834	dst[i] = (MIN2(rgba[i][BCOMP], 1023) )
		835	\| (MIN2(rgba[i][GCOMP], 1023) << 10)
		836	\| (MIN2(rgba[i][RCOMP], 1023) << 20)
		837	\| (MIN2(rgba[i][ACOMP], 3) << 30);
		838	}
		839	}
		840	else if (dstFormat == GL_ABGR_EXT) {
		841	GLuint dst = (GLuint ) dstAddr;
		842	for (i=0;i
		843	dst[i] = (MIN2(rgba[i][ACOMP], 1023) )
		844	\| (MIN2(rgba[i][BCOMP], 1023) << 10)
		845	\| (MIN2(rgba[i][GCOMP], 1023) << 20)
		846	\| (MIN2(rgba[i][RCOMP], 3) << 30);
		847	}
		848	} else {
		849	_pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
		850	}
		851	break;
		852	default:
		853	_pack_rgba_span_from_uints_problem(ctx, dstFormat, dstType);
		854	return;
		855	}
		856	}
		857
		858
		859	/* Customization of signed integer packing.
		860	*/
		861	#define SRC_TYPE GLint
		862
		863	#define DST_TYPE GLuint
		864	#define SRC_CONVERT(x) MAX2(x, 0)
		865	#define FN_NAME pack_uint_from_int_rgba
		866	#include "pack_tmp.h"
		867	#undef DST_TYPE
		868	#undef SRC_CONVERT
		869	#undef FN_NAME
		870
		871	#define DST_TYPE GLushort
		872	#define SRC_CONVERT(x) MAX2(x, 0)
		873	#define FN_NAME pack_ushort_from_int_rgba
		874	#include "pack_tmp.h"
		875	#undef DST_TYPE
		876	#undef SRC_CONVERT
		877	#undef FN_NAME
		878
		879	#define DST_TYPE GLshort
		880	#define SRC_CONVERT(x) CLAMP(x, -0x8000, 0x7fff)
		881	#define FN_NAME pack_short_from_int_rgba
		882	#include "pack_tmp.h"
		883	#undef DST_TYPE
		884	#undef SRC_CONVERT
		885	#undef FN_NAME
		886
		887	#define DST_TYPE GLubyte
		888	#define SRC_CONVERT(x) MAX2(x, 0)
		889	#define FN_NAME pack_ubyte_from_int_rgba
		890	#include "pack_tmp.h"
		891	#undef DST_TYPE
		892	#undef SRC_CONVERT
		893	#undef FN_NAME
		894
		895	#define DST_TYPE GLbyte
		896	#define SRC_CONVERT(x) CLAMP(x, -0x80, 0x7f)
		897	#define FN_NAME pack_byte_from_int_rgba
		898	#include "pack_tmp.h"
		899	#undef DST_TYPE
		900	#undef SRC_CONVERT
		901	#undef FN_NAME
		902
		903	#undef SRC_TYPE
		904
		905	static void
		906	_pack_rgba_span_from_ints_problem(struct gl_context *ctx,
		907	GLenum dstFormat, GLenum dstType)
		908	{
		909	_mesa_problem(ctx,
		910	"Unsupported type (%s) / format (%s) "
		911	"in _mesa_pack_rgba_span_from_ints",
		912	_mesa_lookup_enum_by_nr(dstType),
		913	_mesa_lookup_enum_by_nr(dstFormat));
		914	}
		915
		916	void
		917	_mesa_pack_rgba_span_from_ints(struct gl_context *ctx, GLuint n, GLint rgba[][4],
		918	GLenum dstFormat, GLenum dstType,
		919	GLvoid *dstAddr)
		920	{
		921	GLuint i;
		922
		923	switch(dstType) {
		924	case GL_UNSIGNED_INT:
		925	pack_uint_from_int_rgba(ctx, dstAddr, dstFormat, rgba, n);
		926	break;
		927	case GL_INT:
		928	/* No conversion necessary. */
		929	pack_uint_from_uint_rgba(ctx, dstAddr, dstFormat, (GLuint (*)[4]) rgba, n);
		930	break;
		931	case GL_UNSIGNED_SHORT:
		932	pack_ushort_from_int_rgba(ctx, dstAddr, dstFormat, rgba, n);
		933	break;
		934	case GL_SHORT:
		935	pack_short_from_int_rgba(ctx, dstAddr, dstFormat, rgba, n);
		936	break;
		937	case GL_UNSIGNED_BYTE:
		938	pack_ubyte_from_int_rgba(ctx, dstAddr, dstFormat, rgba, n);
		939	break;
		940	case GL_BYTE:
		941	pack_byte_from_int_rgba(ctx, dstAddr, dstFormat, rgba, n);
		942	break;
		943	case GL_UNSIGNED_BYTE_3_3_2:
		944	if ((dstFormat == GL_RGB) \|\| (dstFormat == GL_RGB_INTEGER)) {
		945	GLubyte dst = (GLubyte ) dstAddr;
		946	for (i=0;i
		947	dst[i] = (CLAMP(rgba[i][RCOMP], 0, 7) << 5)
		948	\| (CLAMP(rgba[i][GCOMP], 0, 7) << 2)
		949	\| (CLAMP(rgba[i][BCOMP], 0, 3) );
		950	}
		951	} else {
		952	_pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
		953	}
		954	break;
		955	case GL_UNSIGNED_BYTE_2_3_3_REV:
		956	if ((dstFormat == GL_RGB) \|\| (dstFormat == GL_RGB_INTEGER)) {
		957	GLubyte dst = (GLubyte ) dstAddr;
		958	for (i=0;i
		959	dst[i] = (CLAMP(rgba[i][RCOMP], 0, 7) )
		960	\| (CLAMP(rgba[i][GCOMP], 0, 7) << 3)
		961	\| (CLAMP(rgba[i][BCOMP], 0, 3) << 6);
		962	}
		963	} else {
		964	_pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
		965	}
		966	break;
		967	case GL_UNSIGNED_SHORT_5_6_5:
		968	if ((dstFormat == GL_RGB) \|\| (dstFormat == GL_RGB_INTEGER)) {
		969	GLushort dst = (GLushort ) dstAddr;
		970	for (i=0;i
		971	dst[i] = (CLAMP(rgba[i][RCOMP], 0, 31) << 11)
		972	\| (CLAMP(rgba[i][GCOMP], 0, 63) << 5)
		973	\| (CLAMP(rgba[i][BCOMP], 0, 31) );
		974	}
		975	} else {
		976	_pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
		977	}
		978	break;
		979	case GL_UNSIGNED_SHORT_5_6_5_REV:
		980	if ((dstFormat == GL_RGB) \|\| (dstFormat == GL_RGB_INTEGER)) {
		981	GLushort dst = (GLushort ) dstAddr;
		982	for (i=0;i
		983	dst[i] = (CLAMP(rgba[i][RCOMP], 0, 31) )
		984	\| (CLAMP(rgba[i][GCOMP], 0, 63) << 5)
		985	\| (CLAMP(rgba[i][BCOMP], 0, 31) << 11);
		986	}
		987	} else {
		988	_pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
		989	}
		990	break;
		991	case GL_UNSIGNED_SHORT_4_4_4_4:
		992	if ((dstFormat == GL_RGBA) \|\| (dstFormat == GL_RGBA_INTEGER_EXT)) {
		993	GLushort dst = (GLushort ) dstAddr;
		994	for (i=0;i
		995	dst[i] = (CLAMP(rgba[i][RCOMP], 0, 15) << 12)
		996	\| (CLAMP(rgba[i][GCOMP], 0, 15) << 8)
		997	\| (CLAMP(rgba[i][BCOMP], 0, 15) << 4)
		998	\| (CLAMP(rgba[i][ACOMP], 0, 15) );
		999	}
		1000	}
		1001	else if ((dstFormat == GL_BGRA) \|\| (dstFormat == GL_BGRA_INTEGER)) {
		1002	GLushort dst = (GLushort ) dstAddr;
		1003	for (i=0;i
		1004	dst[i] = (CLAMP(rgba[i][BCOMP], 0, 15) << 12)
		1005	\| (CLAMP(rgba[i][GCOMP], 0, 15) << 8)
		1006	\| (CLAMP(rgba[i][RCOMP], 0, 15) << 4)
		1007	\| (CLAMP(rgba[i][ACOMP], 0, 15) );
		1008	}
		1009	}
		1010	else if (dstFormat == GL_ABGR_EXT) {
		1011	GLushort dst = (GLushort ) dstAddr;
		1012	for (i=0;i
		1013	dst[i] = (CLAMP(rgba[i][ACOMP], 0, 15) << 12)
		1014	\| (CLAMP(rgba[i][BCOMP], 0, 15) << 8)
		1015	\| (CLAMP(rgba[i][GCOMP], 0, 15) << 4)
		1016	\| (CLAMP(rgba[i][RCOMP], 0, 15) );
		1017	}
		1018	} else {
		1019	_pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
		1020	}
		1021	break;
		1022	case GL_UNSIGNED_SHORT_4_4_4_4_REV:
		1023	if ((dstFormat == GL_RGBA) \|\| (dstFormat == GL_RGBA_INTEGER_EXT)) {
		1024	GLushort dst = (GLushort ) dstAddr;
		1025	for (i=0;i
		1026	dst[i] = (CLAMP(rgba[i][RCOMP], 0, 15) )
		1027	\| (CLAMP(rgba[i][GCOMP], 0, 15) << 4)
		1028	\| (CLAMP(rgba[i][BCOMP], 0, 15) << 8)
		1029	\| (CLAMP(rgba[i][ACOMP], 0, 15) << 12);
		1030	}
		1031	}
		1032	else if ((dstFormat == GL_BGRA) \|\| (dstFormat == GL_BGRA_INTEGER)) {
		1033	GLushort dst = (GLushort ) dstAddr;
		1034	for (i=0;i
		1035	dst[i] = (CLAMP(rgba[i][BCOMP], 0, 15) )
		1036	\| (CLAMP(rgba[i][GCOMP], 0, 15) << 4)
		1037	\| (CLAMP(rgba[i][RCOMP], 0, 15) << 8)
		1038	\| (CLAMP(rgba[i][ACOMP], 0, 15) << 12);
		1039	}
		1040	}
		1041	else if (dstFormat == GL_ABGR_EXT) {
		1042	GLushort dst = (GLushort ) dstAddr;
		1043	for (i=0;i
		1044	dst[i] = (CLAMP(rgba[i][ACOMP], 0, 15) )
		1045	\| (CLAMP(rgba[i][BCOMP], 0, 15) << 4)
		1046	\| (CLAMP(rgba[i][GCOMP], 0, 15) << 8)
		1047	\| (CLAMP(rgba[i][RCOMP], 0, 15) << 12);
		1048	}
		1049	} else {
		1050	_pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
		1051	}
		1052	break;
		1053	case GL_UNSIGNED_SHORT_5_5_5_1:
		1054	if ((dstFormat == GL_RGBA) \|\| (dstFormat == GL_RGBA_INTEGER_EXT)) {
		1055	GLushort dst = (GLushort ) dstAddr;
		1056	for (i=0;i
		1057	dst[i] = (CLAMP(rgba[i][RCOMP], 0, 31) << 11)
		1058	\| (CLAMP(rgba[i][GCOMP], 0, 31) << 6)
		1059	\| (CLAMP(rgba[i][BCOMP], 0, 31) << 1)
		1060	\| (CLAMP(rgba[i][ACOMP], 0, 1) );
		1061	}
		1062	}
		1063	else if ((dstFormat == GL_BGRA) \|\| (dstFormat == GL_BGRA_INTEGER)) {
		1064	GLushort dst = (GLushort ) dstAddr;
		1065	for (i=0;i
		1066	dst[i] = (CLAMP(rgba[i][BCOMP], 0, 31) << 11)
		1067	\| (CLAMP(rgba[i][GCOMP], 0, 31) << 6)
		1068	\| (CLAMP(rgba[i][RCOMP], 0, 31) << 1)
		1069	\| (CLAMP(rgba[i][ACOMP], 0, 1) );
		1070	}
		1071	}
		1072	else if (dstFormat == GL_ABGR_EXT) {
		1073	GLushort dst = (GLushort ) dstAddr;
		1074	for (i=0;i
		1075	dst[i] = (CLAMP(rgba[i][ACOMP], 0, 31) << 11)
		1076	\| (CLAMP(rgba[i][BCOMP], 0, 31) << 6)
		1077	\| (CLAMP(rgba[i][GCOMP], 0, 31) << 1)
		1078	\| (CLAMP(rgba[i][RCOMP], 0, 1) );
		1079	}
		1080	} else {
		1081	_pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
		1082	}
		1083	break;
		1084	case GL_UNSIGNED_SHORT_1_5_5_5_REV:
		1085	if ((dstFormat == GL_RGBA) \|\| (dstFormat == GL_RGBA_INTEGER_EXT)) {
		1086	GLushort dst = (GLushort ) dstAddr;
		1087	for (i=0;i
		1088	dst[i] = (CLAMP(rgba[i][RCOMP], 0, 31) )
		1089	\| (CLAMP(rgba[i][GCOMP], 0, 31) << 5)
		1090	\| (CLAMP(rgba[i][BCOMP], 0, 31) << 10)
		1091	\| (CLAMP(rgba[i][ACOMP], 0, 1) << 15);
		1092	}
		1093	}
		1094	else if ((dstFormat == GL_BGRA) \|\| (dstFormat == GL_BGRA_INTEGER)) {
		1095	GLushort dst = (GLushort ) dstAddr;
		1096	for (i=0;i
		1097	dst[i] = (CLAMP(rgba[i][BCOMP], 0, 31) )
		1098	\| (CLAMP(rgba[i][GCOMP], 0, 31) << 5)
		1099	\| (CLAMP(rgba[i][RCOMP], 0, 31) << 10)
		1100	\| (CLAMP(rgba[i][ACOMP], 0, 1) << 15);
		1101	}
		1102	}
		1103	else if (dstFormat == GL_ABGR_EXT) {
		1104	GLushort dst = (GLushort ) dstAddr;
		1105	for (i=0;i
		1106	dst[i] = (CLAMP(rgba[i][ACOMP], 0, 31) )
		1107	\| (CLAMP(rgba[i][BCOMP], 0, 31) << 5)
		1108	\| (CLAMP(rgba[i][GCOMP], 0, 31) << 10)
		1109	\| (CLAMP(rgba[i][RCOMP], 0, 1) << 15);
		1110	}
		1111	} else {
		1112	_pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
		1113	}
		1114	break;
		1115	case GL_UNSIGNED_INT_8_8_8_8:
		1116	if ((dstFormat == GL_RGBA) \|\| (dstFormat == GL_RGBA_INTEGER_EXT)) {
		1117	GLuint dst = (GLuint ) dstAddr;
		1118	for (i=0;i
		1119	dst[i] = (CLAMP(rgba[i][RCOMP], 0, 255) << 24)
		1120	\| (CLAMP(rgba[i][GCOMP], 0, 255) << 16)
		1121	\| (CLAMP(rgba[i][BCOMP], 0, 255) << 8)
		1122	\| (CLAMP(rgba[i][ACOMP], 0, 255) );
		1123	}
		1124	}
		1125	else if ((dstFormat == GL_BGRA) \|\| (dstFormat == GL_BGRA_INTEGER)) {
		1126	GLuint dst = (GLuint ) dstAddr;
		1127	for (i=0;i
		1128	dst[i] = (CLAMP(rgba[i][BCOMP], 0, 255) << 24)
		1129	\| (CLAMP(rgba[i][GCOMP], 0, 255) << 16)
		1130	\| (CLAMP(rgba[i][RCOMP], 0, 255) << 8)
		1131	\| (CLAMP(rgba[i][ACOMP], 0, 255) );
		1132	}
		1133	}
		1134	else if (dstFormat == GL_ABGR_EXT) {
		1135	GLuint dst = (GLuint ) dstAddr;
		1136	for (i=0;i
		1137	dst[i] = (CLAMP(rgba[i][ACOMP], 0, 255) << 24)
		1138	\| (CLAMP(rgba[i][BCOMP], 0, 255) << 16)
		1139	\| (CLAMP(rgba[i][GCOMP], 0, 255) << 8)
		1140	\| (CLAMP(rgba[i][RCOMP], 0, 255) );
		1141	}
		1142	} else {
		1143	_pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
		1144	}
		1145	break;
		1146	case GL_UNSIGNED_INT_8_8_8_8_REV:
		1147	if ((dstFormat == GL_RGBA) \|\| (dstFormat == GL_RGBA_INTEGER_EXT)) {
		1148	GLuint dst = (GLuint ) dstAddr;
		1149	for (i=0;i
		1150	dst[i] = (CLAMP(rgba[i][RCOMP], 0, 255) )
		1151	\| (CLAMP(rgba[i][GCOMP], 0, 255) << 8)
		1152	\| (CLAMP(rgba[i][BCOMP], 0, 255) << 16)
		1153	\| (CLAMP(rgba[i][ACOMP], 0, 255) << 24);
		1154	}
		1155	}
		1156	else if ((dstFormat == GL_BGRA) \|\| (dstFormat == GL_BGRA_INTEGER)) {
		1157	GLuint dst = (GLuint ) dstAddr;
		1158	for (i=0;i
		1159	dst[i] = (CLAMP(rgba[i][BCOMP], 0, 255) )
		1160	\| (CLAMP(rgba[i][GCOMP], 0, 255) << 8)
		1161	\| (CLAMP(rgba[i][RCOMP], 0, 255) << 16)
		1162	\| (CLAMP(rgba[i][ACOMP], 0, 255) << 24);
		1163	}
		1164	}
		1165	else if (dstFormat == GL_ABGR_EXT) {
		1166	GLuint dst = (GLuint ) dstAddr;
		1167	for (i=0;i
		1168	dst[i] = (CLAMP(rgba[i][ACOMP], 0, 255) )
		1169	\| (CLAMP(rgba[i][BCOMP], 0, 255) << 8)
		1170	\| (CLAMP(rgba[i][GCOMP], 0, 255) << 16)
		1171	\| (CLAMP(rgba[i][RCOMP], 0, 255) << 24);
		1172	}
		1173	} else {
		1174	_pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
		1175	}
		1176	break;
		1177	case GL_UNSIGNED_INT_10_10_10_2:
		1178	if ((dstFormat == GL_RGBA) \|\| (dstFormat == GL_RGBA_INTEGER_EXT)) {
		1179	GLuint dst = (GLuint ) dstAddr;
		1180	for (i=0;i
		1181	dst[i] = (CLAMP(rgba[i][RCOMP], 0, 1023) << 22)
		1182	\| (CLAMP(rgba[i][GCOMP], 0, 1023) << 12)
		1183	\| (CLAMP(rgba[i][BCOMP], 0, 1023) << 2)
		1184	\| (CLAMP(rgba[i][ACOMP], 0, 3) );
		1185	}
		1186	}
		1187	else if ((dstFormat == GL_BGRA) \|\| (dstFormat == GL_BGRA_INTEGER)) {
		1188	GLuint dst = (GLuint ) dstAddr;
		1189	for (i=0;i
		1190	dst[i] = (CLAMP(rgba[i][BCOMP], 0, 1023) << 22)
		1191	\| (CLAMP(rgba[i][GCOMP], 0, 1023) << 12)
		1192	\| (CLAMP(rgba[i][RCOMP], 0, 1023) << 2)
		1193	\| (CLAMP(rgba[i][ACOMP], 0, 3) );
		1194	}
		1195	}
		1196	else if (dstFormat == GL_ABGR_EXT) {
		1197	GLuint dst = (GLuint ) dstAddr;
		1198	for (i=0;i
		1199	dst[i] = (CLAMP(rgba[i][ACOMP], 0, 1023) << 22)
		1200	\| (CLAMP(rgba[i][BCOMP], 0, 1023) << 12)
		1201	\| (CLAMP(rgba[i][GCOMP], 0, 1023) << 2)
		1202	\| (CLAMP(rgba[i][RCOMP], 0, 3) );
		1203	}
		1204	} else {
		1205	_pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
		1206	}
		1207	break;
		1208	case GL_UNSIGNED_INT_2_10_10_10_REV:
		1209	if ((dstFormat == GL_RGBA) \|\| (dstFormat == GL_RGBA_INTEGER_EXT)) {
		1210	GLuint dst = (GLuint ) dstAddr;
		1211	for (i=0;i
		1212	dst[i] = (CLAMP(rgba[i][RCOMP], 0, 1023) )
		1213	\| (CLAMP(rgba[i][GCOMP], 0, 1023) << 10)
		1214	\| (CLAMP(rgba[i][BCOMP], 0, 1023) << 20)
		1215	\| (CLAMP(rgba[i][ACOMP], 0, 3) << 30);
		1216	}
		1217	}
		1218	else if ((dstFormat == GL_BGRA) \|\| (dstFormat == GL_BGRA_INTEGER)) {
		1219	GLuint dst = (GLuint ) dstAddr;
		1220	for (i=0;i
		1221	dst[i] = (CLAMP(rgba[i][BCOMP], 0, 1023) )
		1222	\| (CLAMP(rgba[i][GCOMP], 0, 1023) << 10)
		1223	\| (CLAMP(rgba[i][RCOMP], 0, 1023) << 20)
		1224	\| (CLAMP(rgba[i][ACOMP], 0, 3) << 30);
		1225	}
		1226	}
		1227	else if (dstFormat == GL_ABGR_EXT) {
		1228	GLuint dst = (GLuint ) dstAddr;
		1229	for (i=0;i
		1230	dst[i] = (CLAMP(rgba[i][ACOMP], 0, 1023) )
		1231	\| (CLAMP(rgba[i][BCOMP], 0, 1023) << 10)
		1232	\| (CLAMP(rgba[i][GCOMP], 0, 1023) << 20)
		1233	\| (CLAMP(rgba[i][RCOMP], 0, 3) << 30);
		1234	}
		1235	} else {
		1236	_pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
		1237	}
		1238	break;
		1239	default:
		1240	_pack_rgba_span_from_ints_problem(ctx, dstFormat, dstType);
		1241	return;
		1242	}
		1243	}
		1244
		1245
		1246	/**
		1247	* Used to pack an array [][4] of RGBA float colors as specified
		1248	* by the dstFormat, dstType and dstPacking. Used by glReadPixels.
		1249	* Historically, the RGBA values were in [0,1] and rescaled to fit
		1250	* into GLubytes, etc. But with new integer formats, the RGBA values
		1251	* may have any value and we don't always rescale when converting to
		1252	* integers.
		1253	*
		1254	* Note: the rgba values will be modified by this function when any pixel
		1255	* transfer ops are enabled.
		1256	*/
		1257	void
		1258	_mesa_pack_rgba_span_float(struct gl_context *ctx, GLuint n, GLfloat rgba[][4],
		1259	GLenum dstFormat, GLenum dstType,
		1260	GLvoid *dstAddr,
		1261	const struct gl_pixelstore_attrib *dstPacking,
		1262	GLbitfield transferOps)
		1263	{
		1264	GLfloat *luminance;
		1265	const GLint comps = _mesa_components_in_format(dstFormat);
		1266	const GLboolean intDstFormat = _mesa_is_enum_format_integer(dstFormat);
		1267	GLuint i;
		1268
		1269	if (dstFormat == GL_LUMINANCE \|\|
		1270	dstFormat == GL_LUMINANCE_ALPHA \|\|
		1271	dstFormat == GL_LUMINANCE_INTEGER_EXT \|\|
		1272	dstFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT) {
		1273	luminance = malloc(n * sizeof(GLfloat));
		1274	if (!luminance) {
		1275	_mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
		1276	return;
		1277	}
		1278	}
		1279	else {
		1280	luminance = NULL;
		1281	}
		1282
		1283	/* EXT_texture_integer specifies no transfer ops on integer
		1284	* types in the resolved issues section. Just set them to 0
		1285	* for integer surfaces.
		1286	*/
		1287	if (intDstFormat)
		1288	transferOps = 0;
		1289
		1290	if (transferOps) {
		1291	_mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
		1292	}
		1293
		1294	/*
		1295	* Component clamping (besides clamping to [0,1] in
		1296	* _mesa_apply_rgba_transfer_ops()).
		1297	*/
		1298	if (intDstFormat) {
		1299	/* clamping to dest type's min/max values */
		1300	GLfloat min, max;
		1301	if (get_type_min_max(dstType, &min, &max)) {
		1302	for (i = 0; i < n; i++) {
		1303	rgba[i][RCOMP] = CLAMP(rgba[i][RCOMP], min, max);
		1304	rgba[i][GCOMP] = CLAMP(rgba[i][GCOMP], min, max);
		1305	rgba[i][BCOMP] = CLAMP(rgba[i][BCOMP], min, max);
		1306	rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], min, max);
		1307	}
		1308	}
		1309	}
		1310	else if (dstFormat == GL_LUMINANCE \|\| dstFormat == GL_LUMINANCE_ALPHA) {
		1311	/* compute luminance values */
		1312	if (transferOps & IMAGE_CLAMP_BIT) {
		1313	for (i = 0; i < n; i++) {
		1314	GLfloat sum = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];
		1315	luminance[i] = CLAMP(sum, 0.0F, 1.0F);
		1316	}
		1317	}
		1318	else {
		1319	for (i = 0; i < n; i++) {
		1320	luminance[i] = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];
		1321	}
		1322	}
		1323	}
		1324
		1325	/*
		1326	* Pack/store the pixels. Ugh! Lots of cases!!!
		1327	*/
		1328	switch (dstType) {
		1329	case GL_UNSIGNED_BYTE:
		1330	{
		1331	GLubyte dst = (GLubyte ) dstAddr;
		1332	switch (dstFormat) {
		1333	case GL_RED:
		1334	for (i=0;i
		1335	dst[i] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
		1336	break;
		1337	case GL_GREEN:
		1338	for (i=0;i
		1339	dst[i] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
		1340	break;
		1341	case GL_BLUE:
		1342	for (i=0;i
		1343	dst[i] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
		1344	break;
		1345	case GL_ALPHA:
		1346	for (i=0;i
		1347	dst[i] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
		1348	break;
		1349	case GL_LUMINANCE:
		1350	for (i=0;i
		1351	dst[i] = FLOAT_TO_UBYTE(luminance[i]);
		1352	break;
		1353	case GL_LUMINANCE_ALPHA:
		1354	for (i=0;i
		1355	dst[i*2+0] = FLOAT_TO_UBYTE(luminance[i]);
		1356	dst[i*2+1] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
		1357	}
		1358	break;
		1359	case GL_RG:
		1360	for (i=0;i
		1361	dst[i*2+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
		1362	dst[i*2+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
		1363	}
		1364	break;
		1365	case GL_RGB:
		1366	for (i=0;i
		1367	dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
		1368	dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
		1369	dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
		1370	}
		1371	break;
		1372	case GL_RGBA:
		1373	for (i=0;i
		1374	dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
		1375	dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
		1376	dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
		1377	dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
		1378	}
		1379	break;
		1380	case GL_BGR:
		1381	for (i=0;i
		1382	dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
		1383	dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
		1384	dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
		1385	}
		1386	break;
		1387	case GL_BGRA:
		1388	for (i=0;i
		1389	dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
		1390	dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
		1391	dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
		1392	dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
		1393	}
		1394	break;
		1395	case GL_ABGR_EXT:
		1396	for (i=0;i
		1397	dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
		1398	dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
		1399	dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
		1400	dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
		1401	}
		1402	break;
		1403	case GL_RED_INTEGER_EXT:
		1404	for (i=0;i
		1405	dst[i] = (GLubyte) rgba[i][RCOMP];
		1406	}
		1407	break;
		1408	case GL_GREEN_INTEGER_EXT:
		1409	for (i=0;i
		1410	dst[i] = (GLubyte) rgba[i][GCOMP];
		1411	}
		1412	break;
		1413	case GL_BLUE_INTEGER_EXT:
		1414	for (i=0;i
		1415	dst[i] = (GLubyte) rgba[i][BCOMP];
		1416	}
		1417	break;
		1418	case GL_ALPHA_INTEGER_EXT:
		1419	for (i=0;i
		1420	dst[i] = (GLubyte) rgba[i][ACOMP];
		1421	}
		1422	break;
		1423	case GL_RG_INTEGER:
		1424	for (i=0;i
		1425	dst[i*2+0] = (GLubyte) rgba[i][RCOMP];
		1426	dst[i*2+1] = (GLubyte) rgba[i][GCOMP];
		1427	}
		1428	break;
		1429	case GL_RGB_INTEGER_EXT:
		1430	for (i=0;i
		1431	dst[i*3+0] = (GLubyte) rgba[i][RCOMP];
		1432	dst[i*3+1] = (GLubyte) rgba[i][GCOMP];
		1433	dst[i*3+2] = (GLubyte) rgba[i][BCOMP];
		1434	}
		1435	break;
		1436	case GL_RGBA_INTEGER_EXT:
		1437	for (i=0;i
		1438	dst[i*4+0] = (GLubyte) rgba[i][RCOMP];
		1439	dst[i*4+1] = (GLubyte) rgba[i][GCOMP];
		1440	dst[i*4+2] = (GLubyte) rgba[i][BCOMP];
		1441	dst[i*4+3] = (GLubyte) rgba[i][ACOMP];
		1442	}
		1443	break;
		1444	case GL_BGR_INTEGER_EXT:
		1445	for (i=0;i
		1446	dst[i*3+0] = (GLubyte) rgba[i][BCOMP];
		1447	dst[i*3+1] = (GLubyte) rgba[i][GCOMP];
		1448	dst[i*3+2] = (GLubyte) rgba[i][RCOMP];
		1449	}
		1450	break;
		1451	case GL_BGRA_INTEGER_EXT:
		1452	for (i=0;i
		1453	dst[i*4+0] = (GLubyte) rgba[i][BCOMP];
		1454	dst[i*4+1] = (GLubyte) rgba[i][GCOMP];
		1455	dst[i*4+2] = (GLubyte) rgba[i][RCOMP];
		1456	dst[i*4+3] = (GLubyte) rgba[i][ACOMP];
		1457	}
		1458	break;
		1459	case GL_LUMINANCE_INTEGER_EXT:
		1460	for (i=0;i
		1461	dst[i*2+0] = (GLubyte) (rgba[i][RCOMP] +
		1462	rgba[i][GCOMP] +
		1463	rgba[i][BCOMP]);
		1464	dst[i*2+1] = (GLubyte) rgba[i][ACOMP];
		1465	}
		1466	break;
		1467	case GL_LUMINANCE_ALPHA_INTEGER_EXT:
		1468	for (i=0;i
		1469	dst[i] = (GLubyte) (rgba[i][RCOMP] +
		1470	rgba[i][GCOMP] +
		1471	rgba[i][BCOMP]);
		1472	}
		1473	break;
		1474	case GL_DUDV_ATI:
		1475	case GL_DU8DV8_ATI:
		1476	for (i=0;i
		1477	dst[i*2+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
		1478	dst[i*2+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
		1479	}
		1480	break;
		1481	default:
		1482	_mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
		1483	}
		1484	}
		1485	break;
		1486	case GL_BYTE:
		1487	{
		1488	GLbyte dst = (GLbyte ) dstAddr;
		1489	switch (dstFormat) {
		1490	case GL_RED:
		1491	for (i=0;i
		1492	dst[i] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
		1493	break;
		1494	case GL_GREEN:
		1495	for (i=0;i
		1496	dst[i] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
		1497	break;
		1498	case GL_BLUE:
		1499	for (i=0;i
		1500	dst[i] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
		1501	break;
		1502	case GL_ALPHA:
		1503	for (i=0;i
		1504	dst[i] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
		1505	break;
		1506	case GL_LUMINANCE:
		1507	for (i=0;i
		1508	dst[i] = FLOAT_TO_BYTE(luminance[i]);
		1509	break;
		1510	case GL_LUMINANCE_ALPHA:
		1511	for (i=0;i
		1512	dst[i*2+0] = FLOAT_TO_BYTE(luminance[i]);
		1513	dst[i*2+1] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
		1514	}
		1515	break;
		1516	case GL_RG:
		1517	for (i=0;i
		1518	dst[i*2+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
		1519	dst[i*2+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
		1520	}
		1521	break;
		1522	case GL_RGB:
		1523	for (i=0;i
		1524	dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
		1525	dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
		1526	dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
		1527	}
		1528	break;
		1529	case GL_RGBA:
		1530	for (i=0;i
		1531	dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
		1532	dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
		1533	dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
		1534	dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
		1535	}
		1536	break;
		1537	case GL_BGR:
		1538	for (i=0;i
		1539	dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
		1540	dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
		1541	dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
		1542	}
		1543	break;
		1544	case GL_BGRA:
		1545	for (i=0;i
		1546	dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
		1547	dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
		1548	dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
		1549	dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
		1550	}
		1551	break;
		1552	case GL_ABGR_EXT:
		1553	for (i=0;i
		1554	dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
		1555	dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
		1556	dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
		1557	dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
		1558	}
		1559	break;
		1560	case GL_RED_INTEGER_EXT:
		1561	for (i=0;i
		1562	dst[i] = (GLbyte) rgba[i][RCOMP];
		1563	}
		1564	break;
		1565	case GL_GREEN_INTEGER_EXT:
		1566	for (i=0;i
		1567	dst[i] = (GLbyte) rgba[i][GCOMP];
		1568	}
		1569	break;
		1570	case GL_BLUE_INTEGER_EXT:
		1571	for (i=0;i
		1572	dst[i] = (GLbyte) rgba[i][BCOMP];
		1573	}
		1574	break;
		1575	case GL_ALPHA_INTEGER_EXT:
		1576	for (i=0;i
		1577	dst[i] = (GLbyte) rgba[i][ACOMP];
		1578	}
		1579	break;
		1580	case GL_RG_INTEGER:
		1581	for (i=0;i
		1582	dst[i*2+0] = (GLbyte) rgba[i][RCOMP];
		1583	dst[i*2+1] = (GLbyte) rgba[i][GCOMP];
		1584	}
		1585	break;
		1586	case GL_RGB_INTEGER_EXT:
		1587	for (i=0;i
		1588	dst[i*3+0] = (GLbyte) rgba[i][RCOMP];
		1589	dst[i*3+1] = (GLbyte) rgba[i][GCOMP];
		1590	dst[i*3+2] = (GLbyte) rgba[i][BCOMP];
		1591	}
		1592	break;
		1593	case GL_RGBA_INTEGER_EXT:
		1594	for (i=0;i
		1595	dst[i*4+0] = (GLbyte) rgba[i][RCOMP];
		1596	dst[i*4+1] = (GLbyte) rgba[i][GCOMP];
		1597	dst[i*4+2] = (GLbyte) rgba[i][BCOMP];
		1598	dst[i*4+3] = (GLbyte) rgba[i][ACOMP];
		1599	}
		1600	break;
		1601	case GL_BGR_INTEGER_EXT:
		1602	for (i=0;i
		1603	dst[i*3+0] = (GLbyte) rgba[i][BCOMP];
		1604	dst[i*3+1] = (GLbyte) rgba[i][GCOMP];
		1605	dst[i*3+2] = (GLbyte) rgba[i][RCOMP];
		1606	}
		1607	break;
		1608	case GL_BGRA_INTEGER_EXT:
		1609	for (i=0;i
		1610	dst[i*4+0] = (GLbyte) rgba[i][BCOMP];
		1611	dst[i*4+1] = (GLbyte) rgba[i][GCOMP];
		1612	dst[i*4+2] = (GLbyte) rgba[i][RCOMP];
		1613	dst[i*4+3] = (GLbyte) rgba[i][ACOMP];
		1614	}
		1615	break;
		1616	case GL_LUMINANCE_INTEGER_EXT:
		1617	for (i=0;i
		1618	dst[i*2+0] = (GLbyte) (rgba[i][RCOMP] +
		1619	rgba[i][GCOMP] +
		1620	rgba[i][BCOMP]);
		1621	dst[i*2+1] = (GLbyte) rgba[i][ACOMP];
		1622	}
		1623	break;
		1624	case GL_LUMINANCE_ALPHA_INTEGER_EXT:
		1625	for (i=0;i
		1626	dst[i] = (GLbyte) (rgba[i][RCOMP] +
		1627	rgba[i][GCOMP] +
		1628	rgba[i][BCOMP]);
		1629	}
		1630	break;
		1631	case GL_DUDV_ATI:
		1632	case GL_DU8DV8_ATI:
		1633	for (i=0;i
		1634	dst[i*2+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
		1635	dst[i*2+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
		1636	}
		1637	break;
		1638	default:
		1639	_mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
		1640	}
		1641	}
		1642	break;
		1643	case GL_UNSIGNED_SHORT:
		1644	{
		1645	GLushort dst = (GLushort ) dstAddr;
		1646	switch (dstFormat) {
		1647	case GL_RED:
		1648	for (i=0;i
		1649	CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][RCOMP]);
		1650	break;
		1651	case GL_GREEN:
		1652	for (i=0;i
		1653	CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][GCOMP]);
		1654	break;
		1655	case GL_BLUE:
		1656	for (i=0;i
		1657	CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][BCOMP]);
		1658	break;
		1659	case GL_ALPHA:
		1660	for (i=0;i
		1661	CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][ACOMP]);
		1662	break;
		1663	case GL_LUMINANCE:
		1664	for (i=0;i
		1665	UNCLAMPED_FLOAT_TO_USHORT(dst[i], luminance[i]);
		1666	break;
		1667	case GL_LUMINANCE_ALPHA:
		1668	for (i=0;i
		1669	UNCLAMPED_FLOAT_TO_USHORT(dst[i*2+0], luminance[i]);
		1670	CLAMPED_FLOAT_TO_USHORT(dst[i*2+1], rgba[i][ACOMP]);
		1671	}
		1672	break;
		1673	case GL_RG:
		1674	for (i=0;i
		1675	CLAMPED_FLOAT_TO_USHORT(dst[i*2+0], rgba[i][RCOMP]);
		1676	CLAMPED_FLOAT_TO_USHORT(dst[i*2+1], rgba[i][GCOMP]);
		1677	}
		1678	break;
		1679	case GL_RGB:
		1680	for (i=0;i
		1681	CLAMPED_FLOAT_TO_USHORT(dst[i*3+0], rgba[i][RCOMP]);
		1682	CLAMPED_FLOAT_TO_USHORT(dst[i*3+1], rgba[i][GCOMP]);
		1683	CLAMPED_FLOAT_TO_USHORT(dst[i*3+2], rgba[i][BCOMP]);
		1684	}
		1685	break;
		1686	case GL_RGBA:
		1687	for (i=0;i
		1688	CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][RCOMP]);
		1689	CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][GCOMP]);
		1690	CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][BCOMP]);
		1691	CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][ACOMP]);
		1692	}
		1693	break;
		1694	case GL_BGR:
		1695	for (i=0;i
		1696	CLAMPED_FLOAT_TO_USHORT(dst[i*3+0], rgba[i][BCOMP]);
		1697	CLAMPED_FLOAT_TO_USHORT(dst[i*3+1], rgba[i][GCOMP]);
		1698	CLAMPED_FLOAT_TO_USHORT(dst[i*3+2], rgba[i][RCOMP]);
		1699	}
		1700	break;
		1701	case GL_BGRA:
		1702	for (i=0;i
		1703	CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][BCOMP]);
		1704	CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][GCOMP]);
		1705	CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][RCOMP]);
		1706	CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][ACOMP]);
		1707	}
		1708	break;
		1709	case GL_ABGR_EXT:
		1710	for (i=0;i
		1711	CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][ACOMP]);
		1712	CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][BCOMP]);
		1713	CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][GCOMP]);
		1714	CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][RCOMP]);
		1715	}
		1716	break;
		1717	case GL_RED_INTEGER_EXT:
		1718	for (i=0;i
		1719	dst[i] = (GLushort) rgba[i][RCOMP];
		1720	}
		1721	break;
		1722	case GL_GREEN_INTEGER_EXT:
		1723	for (i=0;i
		1724	dst[i] = (GLushort) rgba[i][GCOMP];
		1725	}
		1726	break;
		1727	case GL_BLUE_INTEGER_EXT:
		1728	for (i=0;i
		1729	dst[i] = (GLushort) rgba[i][BCOMP];
		1730	}
		1731	break;
		1732	case GL_ALPHA_INTEGER_EXT:
		1733	for (i=0;i
		1734	dst[i] = (GLushort) rgba[i][ACOMP];
		1735	}
		1736	break;
		1737	case GL_RG_INTEGER:
		1738	for (i=0;i
		1739	dst[i*2+0] = (GLushort) rgba[i][RCOMP];
		1740	dst[i*2+1] = (GLushort) rgba[i][GCOMP];
		1741	}
		1742	break;
		1743	case GL_RGB_INTEGER_EXT:
		1744	for (i=0;i
		1745	dst[i*3+0] = (GLushort) rgba[i][RCOMP];
		1746	dst[i*3+1] = (GLushort) rgba[i][GCOMP];
		1747	dst[i*3+2] = (GLushort) rgba[i][BCOMP];
		1748	}
		1749	break;
		1750	case GL_RGBA_INTEGER_EXT:
		1751	for (i=0;i
		1752	dst[i*4+0] = (GLushort) rgba[i][RCOMP];
		1753	dst[i*4+1] = (GLushort) rgba[i][GCOMP];
		1754	dst[i*4+2] = (GLushort) rgba[i][BCOMP];
		1755	dst[i*4+3] = (GLushort) rgba[i][ACOMP];
		1756	}
		1757	break;
		1758	case GL_BGR_INTEGER_EXT:
		1759	for (i=0;i
		1760	dst[i*3+0] = (GLushort) rgba[i][BCOMP];
		1761	dst[i*3+1] = (GLushort) rgba[i][GCOMP];
		1762	dst[i*3+2] = (GLushort) rgba[i][RCOMP];
		1763	}
		1764	break;
		1765	case GL_BGRA_INTEGER_EXT:
		1766	for (i=0;i
		1767	dst[i*4+0] = (GLushort) rgba[i][BCOMP];
		1768	dst[i*4+1] = (GLushort) rgba[i][GCOMP];
		1769	dst[i*4+2] = (GLushort) rgba[i][RCOMP];
		1770	dst[i*4+3] = (GLushort) rgba[i][ACOMP];
		1771	}
		1772	break;
		1773	case GL_LUMINANCE_INTEGER_EXT:
		1774	for (i=0;i
		1775	dst[i*2+0] = (GLushort) (rgba[i][RCOMP] +
		1776	rgba[i][GCOMP] +
		1777	rgba[i][BCOMP]);
		1778	dst[i*2+1] = (GLushort) rgba[i][ACOMP];
		1779	}
		1780	break;
		1781	case GL_LUMINANCE_ALPHA_INTEGER_EXT:
		1782	for (i=0;i
		1783	dst[i] = (GLushort) (rgba[i][RCOMP] +
		1784	rgba[i][GCOMP] +
		1785	rgba[i][BCOMP]);
		1786	}
		1787	break;
		1788	case GL_DUDV_ATI:
		1789	case GL_DU8DV8_ATI:
		1790	for (i=0;i
		1791	dst[i*2+0] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
		1792	dst[i*2+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
		1793	}
		1794	break;
		1795	default:
		1796	_mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
		1797	}
		1798	}
		1799	break;
		1800	case GL_SHORT:
		1801	{
		1802	GLshort dst = (GLshort ) dstAddr;
		1803	switch (dstFormat) {
		1804	case GL_RED:
		1805	for (i=0;i
		1806	dst[i] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
		1807	break;
		1808	case GL_GREEN:
		1809	for (i=0;i
		1810	dst[i] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
		1811	break;
		1812	case GL_BLUE:
		1813	for (i=0;i
		1814	dst[i] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
		1815	break;
		1816	case GL_ALPHA:
		1817	for (i=0;i
		1818	dst[i] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
		1819	break;
		1820	case GL_LUMINANCE:
		1821	for (i=0;i
		1822	dst[i] = FLOAT_TO_SHORT(luminance[i]);
		1823	break;
		1824	case GL_LUMINANCE_ALPHA:
		1825	for (i=0;i
		1826	dst[i*2+0] = FLOAT_TO_SHORT(luminance[i]);
		1827	dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
		1828	}
		1829	break;
		1830	case GL_RG:
		1831	for (i=0;i
		1832	dst[i*2+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
		1833	dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
		1834	}
		1835	break;
		1836	case GL_RGB:
		1837	for (i=0;i
		1838	dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
		1839	dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
		1840	dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
		1841	}
		1842	break;
		1843	case GL_RGBA:
		1844	for (i=0;i
		1845	dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
		1846	dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
		1847	dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
		1848	dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
		1849	}
		1850	break;
		1851	case GL_BGR:
		1852	for (i=0;i
		1853	dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
		1854	dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
		1855	dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
		1856	}
		1857	break;
		1858	case GL_BGRA:
		1859	for (i=0;i
		1860	dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
		1861	dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
		1862	dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
		1863	dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
		1864	}
		1865	break;
		1866	case GL_ABGR_EXT:
		1867	for (i=0;i
		1868	dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
		1869	dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
		1870	dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
		1871	dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
		1872	}
		1873	break;
		1874	case GL_RED_INTEGER_EXT:
		1875	for (i=0;i
		1876	dst[i] = (GLshort) rgba[i][RCOMP];
		1877	}
		1878	break;
		1879	case GL_GREEN_INTEGER_EXT:
		1880	for (i=0;i
		1881	dst[i] = (GLshort) rgba[i][GCOMP];
		1882	}
		1883	break;
		1884	case GL_BLUE_INTEGER_EXT:
		1885	for (i=0;i
		1886	dst[i] = (GLshort) rgba[i][BCOMP];
		1887	}
		1888	break;
		1889	case GL_ALPHA_INTEGER_EXT:
		1890	for (i=0;i
		1891	dst[i] = (GLshort) rgba[i][ACOMP];
		1892	}
		1893	break;
		1894	case GL_RG_INTEGER:
		1895	for (i=0;i
		1896	dst[i*2+0] = (GLshort) rgba[i][RCOMP];
		1897	dst[i*2+1] = (GLshort) rgba[i][GCOMP];
		1898	}
		1899	break;
		1900	case GL_RGB_INTEGER_EXT:
		1901	for (i=0;i
		1902	dst[i*3+0] = (GLshort) rgba[i][RCOMP];
		1903	dst[i*3+1] = (GLshort) rgba[i][GCOMP];
		1904	dst[i*3+2] = (GLshort) rgba[i][BCOMP];
		1905	}
		1906	break;
		1907	case GL_RGBA_INTEGER_EXT:
		1908	for (i=0;i
		1909	dst[i*4+0] = (GLshort) rgba[i][RCOMP];
		1910	dst[i*4+1] = (GLshort) rgba[i][GCOMP];
		1911	dst[i*4+2] = (GLshort) rgba[i][BCOMP];
		1912	dst[i*4+3] = (GLshort) rgba[i][ACOMP];
		1913	}
		1914	break;
		1915	case GL_BGR_INTEGER_EXT:
		1916	for (i=0;i
		1917	dst[i*3+0] = (GLshort) rgba[i][BCOMP];
		1918	dst[i*3+1] = (GLshort) rgba[i][GCOMP];
		1919	dst[i*3+2] = (GLshort) rgba[i][RCOMP];
		1920	}
		1921	break;
		1922	case GL_BGRA_INTEGER_EXT:
		1923	for (i=0;i
		1924	dst[i*4+0] = (GLshort) rgba[i][BCOMP];
		1925	dst[i*4+1] = (GLshort) rgba[i][GCOMP];
		1926	dst[i*4+2] = (GLshort) rgba[i][RCOMP];
		1927	dst[i*4+3] = (GLshort) rgba[i][ACOMP];
		1928	}
		1929	break;
		1930	case GL_LUMINANCE_INTEGER_EXT:
		1931	for (i=0;i
		1932	dst[i*2+0] = (GLshort) (rgba[i][RCOMP] +
		1933	rgba[i][GCOMP] +
		1934	rgba[i][BCOMP]);
		1935	dst[i*2+1] = (GLshort) rgba[i][ACOMP];
		1936	}
		1937	break;
		1938	case GL_LUMINANCE_ALPHA_INTEGER_EXT:
		1939	for (i=0;i
		1940	dst[i] = (GLshort) (rgba[i][RCOMP] +
		1941	rgba[i][GCOMP] +
		1942	rgba[i][BCOMP]);
		1943	}
		1944	break;
		1945	case GL_DUDV_ATI:
		1946	case GL_DU8DV8_ATI:
		1947	for (i=0;i
		1948	dst[i*2+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
		1949	dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
		1950	}
		1951	break;
		1952	default:
		1953	_mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
		1954	}
		1955	}
		1956	break;
		1957	case GL_UNSIGNED_INT:
		1958	{
		1959	GLuint dst = (GLuint ) dstAddr;
		1960	switch (dstFormat) {
		1961	case GL_RED:
		1962	for (i=0;i
		1963	dst[i] = FLOAT_TO_UINT(rgba[i][RCOMP]);
		1964	break;
		1965	case GL_GREEN:
		1966	for (i=0;i
		1967	dst[i] = FLOAT_TO_UINT(rgba[i][GCOMP]);
		1968	break;
		1969	case GL_BLUE:
		1970	for (i=0;i
		1971	dst[i] = FLOAT_TO_UINT(rgba[i][BCOMP]);
		1972	break;
		1973	case GL_ALPHA:
		1974	for (i=0;i
		1975	dst[i] = FLOAT_TO_UINT(rgba[i][ACOMP]);
		1976	break;
		1977	case GL_LUMINANCE:
		1978	for (i=0;i
		1979	dst[i] = FLOAT_TO_UINT(luminance[i]);
		1980	break;
		1981	case GL_LUMINANCE_ALPHA:
		1982	for (i=0;i
		1983	dst[i*2+0] = FLOAT_TO_UINT(luminance[i]);
		1984	dst[i*2+1] = FLOAT_TO_UINT(rgba[i][ACOMP]);
		1985	}
		1986	break;
		1987	case GL_RG:
		1988	for (i=0;i
		1989	dst[i*2+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
		1990	dst[i*2+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
		1991	}
		1992	break;
		1993	case GL_RGB:
		1994	for (i=0;i
		1995	dst[i*3+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
		1996	dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
		1997	dst[i*3+2] = FLOAT_TO_UINT(rgba[i][BCOMP]);
		1998	}
		1999	break;
		2000	case GL_RGBA:
		2001	for (i=0;i
		2002	dst[i*4+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
		2003	dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
		2004	dst[i*4+2] = FLOAT_TO_UINT(rgba[i][BCOMP]);
		2005	dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]);
		2006	}
		2007	break;
		2008	case GL_BGR:
		2009	for (i=0;i
		2010	dst[i*3+0] = FLOAT_TO_UINT(rgba[i][BCOMP]);
		2011	dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
		2012	dst[i*3+2] = FLOAT_TO_UINT(rgba[i][RCOMP]);
		2013	}
		2014	break;
		2015	case GL_BGRA:
		2016	for (i=0;i
		2017	dst[i*4+0] = FLOAT_TO_UINT(rgba[i][BCOMP]);
		2018	dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
		2019	dst[i*4+2] = FLOAT_TO_UINT(rgba[i][RCOMP]);
		2020	dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]);
		2021	}
		2022	break;
		2023	case GL_ABGR_EXT:
		2024	for (i=0;i
		2025	dst[i*4+0] = FLOAT_TO_UINT(rgba[i][ACOMP]);
		2026	dst[i*4+1] = FLOAT_TO_UINT(rgba[i][BCOMP]);
		2027	dst[i*4+2] = FLOAT_TO_UINT(rgba[i][GCOMP]);
		2028	dst[i*4+3] = FLOAT_TO_UINT(rgba[i][RCOMP]);
		2029	}
		2030	break;
		2031	case GL_RED_INTEGER_EXT:
		2032	for (i=0;i
		2033	dst[i] = (GLuint) rgba[i][RCOMP];
		2034	}
		2035	break;
		2036	case GL_GREEN_INTEGER_EXT:
		2037	for (i=0;i
		2038	dst[i] = (GLuint) rgba[i][GCOMP];
		2039	}
		2040	break;
		2041	case GL_BLUE_INTEGER_EXT:
		2042	for (i=0;i
		2043	dst[i] = (GLuint) rgba[i][BCOMP];
		2044	}
		2045	break;
		2046	case GL_ALPHA_INTEGER_EXT:
		2047	for (i=0;i
		2048	dst[i] = (GLuint) rgba[i][ACOMP];
		2049	}
		2050	break;
		2051	case GL_RG_INTEGER:
		2052	for (i=0;i
		2053	dst[i*2+0] = (GLuint) rgba[i][RCOMP];
		2054	dst[i*2+1] = (GLuint) rgba[i][GCOMP];
		2055	}
		2056	break;
		2057	case GL_RGB_INTEGER_EXT:
		2058	for (i=0;i
		2059	dst[i*3+0] = (GLuint) rgba[i][RCOMP];
		2060	dst[i*3+1] = (GLuint) rgba[i][GCOMP];
		2061	dst[i*3+2] = (GLuint) rgba[i][BCOMP];
		2062	}
		2063	break;
		2064	case GL_RGBA_INTEGER_EXT:
		2065	for (i=0;i
		2066	dst[i*4+0] = (GLuint) rgba[i][RCOMP];
		2067	dst[i*4+1] = (GLuint) rgba[i][GCOMP];
		2068	dst[i*4+2] = (GLuint) rgba[i][BCOMP];
		2069	dst[i*4+3] = (GLuint) rgba[i][ACOMP];
		2070	}
		2071	break;
		2072	case GL_BGR_INTEGER_EXT:
		2073	for (i=0;i
		2074	dst[i*3+0] = (GLuint) rgba[i][BCOMP];
		2075	dst[i*3+1] = (GLuint) rgba[i][GCOMP];
		2076	dst[i*3+2] = (GLuint) rgba[i][RCOMP];
		2077	}
		2078	break;
		2079	case GL_BGRA_INTEGER_EXT:
		2080	for (i=0;i
		2081	dst[i*4+0] = (GLuint) rgba[i][BCOMP];
		2082	dst[i*4+1] = (GLuint) rgba[i][GCOMP];
		2083	dst[i*4+2] = (GLuint) rgba[i][RCOMP];
		2084	dst[i*4+3] = (GLuint) rgba[i][ACOMP];
		2085	}
		2086	break;
		2087	case GL_LUMINANCE_INTEGER_EXT:
		2088	for (i=0;i
		2089	dst[i*2+0] = (GLuint) (rgba[i][RCOMP] +
		2090	rgba[i][GCOMP] +
		2091	rgba[i][BCOMP]);
		2092	dst[i*2+1] = (GLuint) rgba[i][ACOMP];
		2093	}
		2094	break;
		2095	case GL_LUMINANCE_ALPHA_INTEGER_EXT:
		2096	for (i=0;i
		2097	dst[i] = (GLuint) (rgba[i][RCOMP] +
		2098	rgba[i][GCOMP] +
		2099	rgba[i][BCOMP]);
		2100	}
		2101	break;
		2102	case GL_DUDV_ATI:
		2103	case GL_DU8DV8_ATI:
		2104	for (i=0;i
		2105	dst[i*2+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
		2106	dst[i*2+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
		2107	}
		2108	break;
		2109	default:
		2110	_mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
		2111	}
		2112	}
		2113	break;
		2114	case GL_INT:
		2115	{
		2116	GLint dst = (GLint ) dstAddr;
		2117	switch (dstFormat) {
		2118	case GL_RED:
		2119	for (i=0;i
		2120	dst[i] = FLOAT_TO_INT(rgba[i][RCOMP]);
		2121	break;
		2122	case GL_GREEN:
		2123	for (i=0;i
		2124	dst[i] = FLOAT_TO_INT(rgba[i][GCOMP]);
		2125	break;
		2126	case GL_BLUE:
		2127	for (i=0;i
		2128	dst[i] = FLOAT_TO_INT(rgba[i][BCOMP]);
		2129	break;
		2130	case GL_ALPHA:
		2131	for (i=0;i
		2132	dst[i] = FLOAT_TO_INT(rgba[i][ACOMP]);
		2133	break;
		2134	case GL_LUMINANCE:
		2135	for (i=0;i
		2136	dst[i] = FLOAT_TO_INT(luminance[i]);
		2137	break;
		2138	case GL_LUMINANCE_ALPHA:
		2139	for (i=0;i
		2140	dst[i*2+0] = FLOAT_TO_INT(luminance[i]);
		2141	dst[i*2+1] = FLOAT_TO_INT(rgba[i][ACOMP]);
		2142	}
		2143	break;
		2144	case GL_RG:
		2145	for (i=0;i
		2146	dst[i*2+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
		2147	dst[i*2+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
		2148	}
		2149	break;
		2150	case GL_RGB:
		2151	for (i=0;i
		2152	dst[i*3+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
		2153	dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
		2154	dst[i*3+2] = FLOAT_TO_INT(rgba[i][BCOMP]);
		2155	}
		2156	break;
		2157	case GL_RGBA:
		2158	for (i=0;i
		2159	dst[i*4+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
		2160	dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
		2161	dst[i*4+2] = FLOAT_TO_INT(rgba[i][BCOMP]);
		2162	dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]);
		2163	}
		2164	break;
		2165	case GL_BGR:
		2166	for (i=0;i
		2167	dst[i*3+0] = FLOAT_TO_INT(rgba[i][BCOMP]);
		2168	dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
		2169	dst[i*3+2] = FLOAT_TO_INT(rgba[i][RCOMP]);
		2170	}
		2171	break;
		2172	case GL_BGRA:
		2173	for (i=0;i
		2174	dst[i*4+0] = FLOAT_TO_INT(rgba[i][BCOMP]);
		2175	dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
		2176	dst[i*4+2] = FLOAT_TO_INT(rgba[i][RCOMP]);
		2177	dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]);
		2178	}
		2179	break;
		2180	case GL_ABGR_EXT:
		2181	for (i=0;i
		2182	dst[i*4+0] = FLOAT_TO_INT(rgba[i][ACOMP]);
		2183	dst[i*4+1] = FLOAT_TO_INT(rgba[i][BCOMP]);
		2184	dst[i*4+2] = FLOAT_TO_INT(rgba[i][GCOMP]);
		2185	dst[i*4+3] = FLOAT_TO_INT(rgba[i][RCOMP]);
		2186	}
		2187	break;
		2188	case GL_DUDV_ATI:
		2189	case GL_DU8DV8_ATI:
		2190	for (i=0;i
		2191	dst[i*2+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
		2192	dst[i*2+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
		2193	}
		2194	break;
		2195	case GL_RED_INTEGER_EXT:
		2196	for (i=0;i
		2197	dst[i] = (GLint) rgba[i][RCOMP];
		2198	}
		2199	break;
		2200	case GL_GREEN_INTEGER_EXT:
		2201	for (i=0;i
		2202	dst[i] = (GLint) rgba[i][GCOMP];
		2203	}
		2204	break;
		2205	case GL_BLUE_INTEGER_EXT:
		2206	for (i=0;i
		2207	dst[i] = (GLint) rgba[i][BCOMP];
		2208	}
		2209	break;
		2210	case GL_ALPHA_INTEGER_EXT:
		2211	for (i=0;i
		2212	dst[i] = (GLint) rgba[i][ACOMP];
		2213	}
		2214	break;
		2215	case GL_RG_INTEGER:
		2216	for (i=0;i
		2217	dst[i*2+0] = (GLint) rgba[i][RCOMP];
		2218	dst[i*2+1] = (GLint) rgba[i][GCOMP];
		2219	}
		2220	break;
		2221	case GL_RGB_INTEGER_EXT:
		2222	for (i=0;i
		2223	dst[i*3+0] = (GLint) rgba[i][RCOMP];
		2224	dst[i*3+1] = (GLint) rgba[i][GCOMP];
		2225	dst[i*3+2] = (GLint) rgba[i][BCOMP];
		2226	}
		2227	break;
		2228	case GL_RGBA_INTEGER_EXT:
		2229	for (i=0;i
		2230	dst[i*4+0] = (GLint) rgba[i][RCOMP];
		2231	dst[i*4+1] = (GLint) rgba[i][GCOMP];
		2232	dst[i*4+2] = (GLint) rgba[i][BCOMP];
		2233	dst[i*4+3] = (GLint) rgba[i][ACOMP];
		2234	}
		2235	break;
		2236	case GL_BGR_INTEGER_EXT:
		2237	for (i=0;i
		2238	dst[i*3+0] = (GLint) rgba[i][BCOMP];
		2239	dst[i*3+1] = (GLint) rgba[i][GCOMP];
		2240	dst[i*3+2] = (GLint) rgba[i][RCOMP];
		2241	}
		2242	break;
		2243	case GL_BGRA_INTEGER_EXT:
		2244	for (i=0;i
		2245	dst[i*4+0] = (GLint) rgba[i][BCOMP];
		2246	dst[i*4+1] = (GLint) rgba[i][GCOMP];
		2247	dst[i*4+2] = (GLint) rgba[i][RCOMP];
		2248	dst[i*4+3] = (GLint) rgba[i][ACOMP];
		2249	}
		2250	break;
		2251	case GL_LUMINANCE_INTEGER_EXT:
		2252	for (i=0;i
		2253	dst[i*2+0] = (GLint) (rgba[i][RCOMP] +
		2254	rgba[i][GCOMP] +
		2255	rgba[i][BCOMP]);
		2256	dst[i*2+1] = (GLint) rgba[i][ACOMP];
		2257	}
		2258	break;
		2259	case GL_LUMINANCE_ALPHA_INTEGER_EXT:
		2260	for (i=0;i
		2261	dst[i] = (GLint) (rgba[i][RCOMP] +
		2262	rgba[i][GCOMP] +
		2263	rgba[i][BCOMP]);
		2264	}
		2265	break;
		2266	default:
		2267	_mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
		2268	}
		2269	}
		2270	break;
		2271	case GL_FLOAT:
		2272	{
		2273	GLfloat dst = (GLfloat ) dstAddr;
		2274	switch (dstFormat) {
		2275	case GL_RED:
		2276	for (i=0;i
		2277	dst[i] = rgba[i][RCOMP];
		2278	break;
		2279	case GL_GREEN:
		2280	for (i=0;i
		2281	dst[i] = rgba[i][GCOMP];
		2282	break;
		2283	case GL_BLUE:
		2284	for (i=0;i
		2285	dst[i] = rgba[i][BCOMP];
		2286	break;
		2287	case GL_ALPHA:
		2288	for (i=0;i
		2289	dst[i] = rgba[i][ACOMP];
		2290	break;
		2291	case GL_LUMINANCE:
		2292	for (i=0;i
		2293	dst[i] = luminance[i];
		2294	break;
		2295	case GL_LUMINANCE_ALPHA:
		2296	for (i=0;i
		2297	dst[i*2+0] = luminance[i];
		2298	dst[i*2+1] = rgba[i][ACOMP];
		2299	}
		2300	break;
		2301	case GL_RG:
		2302	for (i=0;i
		2303	dst[i*2+0] = rgba[i][RCOMP];
		2304	dst[i*2+1] = rgba[i][GCOMP];
		2305	}
		2306	break;
		2307	case GL_RGB:
		2308	for (i=0;i
		2309	dst[i*3+0] = rgba[i][RCOMP];
		2310	dst[i*3+1] = rgba[i][GCOMP];
		2311	dst[i*3+2] = rgba[i][BCOMP];
		2312	}
		2313	break;
		2314	case GL_RGBA:
		2315	for (i=0;i
		2316	dst[i*4+0] = rgba[i][RCOMP];
		2317	dst[i*4+1] = rgba[i][GCOMP];
		2318	dst[i*4+2] = rgba[i][BCOMP];
		2319	dst[i*4+3] = rgba[i][ACOMP];
		2320	}
		2321	break;
		2322	case GL_BGR:
		2323	for (i=0;i
		2324	dst[i*3+0] = rgba[i][BCOMP];
		2325	dst[i*3+1] = rgba[i][GCOMP];
		2326	dst[i*3+2] = rgba[i][RCOMP];
		2327	}
		2328	break;
		2329	case GL_BGRA:
		2330	for (i=0;i
		2331	dst[i*4+0] = rgba[i][BCOMP];
		2332	dst[i*4+1] = rgba[i][GCOMP];
		2333	dst[i*4+2] = rgba[i][RCOMP];
		2334	dst[i*4+3] = rgba[i][ACOMP];
		2335	}
		2336	break;
		2337	case GL_ABGR_EXT:
		2338	for (i=0;i
		2339	dst[i*4+0] = rgba[i][ACOMP];
		2340	dst[i*4+1] = rgba[i][BCOMP];
		2341	dst[i*4+2] = rgba[i][GCOMP];
		2342	dst[i*4+3] = rgba[i][RCOMP];
		2343	}
		2344	break;
		2345	case GL_DUDV_ATI:
		2346	case GL_DU8DV8_ATI:
		2347	for (i=0;i
		2348	dst[i*2+0] = rgba[i][RCOMP];
		2349	dst[i*2+1] = rgba[i][GCOMP];
		2350	}
		2351	break;
		2352	default:
		2353	_mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
		2354	}
		2355	}
		2356	break;
		2357	case GL_HALF_FLOAT_ARB:
		2358	{
		2359	GLhalfARB dst = (GLhalfARB ) dstAddr;
		2360	switch (dstFormat) {
		2361	case GL_RED:
		2362	for (i=0;i
		2363	dst[i] = _mesa_float_to_half(rgba[i][RCOMP]);
		2364	break;
		2365	case GL_GREEN:
		2366	for (i=0;i
		2367	dst[i] = _mesa_float_to_half(rgba[i][GCOMP]);
		2368	break;
		2369	case GL_BLUE:
		2370	for (i=0;i
		2371	dst[i] = _mesa_float_to_half(rgba[i][BCOMP]);
		2372	break;
		2373	case GL_ALPHA:
		2374	for (i=0;i
		2375	dst[i] = _mesa_float_to_half(rgba[i][ACOMP]);
		2376	break;
		2377	case GL_LUMINANCE:
		2378	for (i=0;i
		2379	dst[i] = _mesa_float_to_half(luminance[i]);
		2380	break;
		2381	case GL_LUMINANCE_ALPHA:
		2382	for (i=0;i
		2383	dst[i*2+0] = _mesa_float_to_half(luminance[i]);
		2384	dst[i*2+1] = _mesa_float_to_half(rgba[i][ACOMP]);
		2385	}
		2386	break;
		2387	case GL_RG:
		2388	for (i=0;i
		2389	dst[i*2+0] = _mesa_float_to_half(rgba[i][RCOMP]);
		2390	dst[i*2+1] = _mesa_float_to_half(rgba[i][GCOMP]);
		2391	}
		2392	break;
		2393	case GL_RGB:
		2394	for (i=0;i
		2395	dst[i*3+0] = _mesa_float_to_half(rgba[i][RCOMP]);
		2396	dst[i*3+1] = _mesa_float_to_half(rgba[i][GCOMP]);
		2397	dst[i*3+2] = _mesa_float_to_half(rgba[i][BCOMP]);
		2398	}
		2399	break;
		2400	case GL_RGBA:
		2401	for (i=0;i
		2402	dst[i*4+0] = _mesa_float_to_half(rgba[i][RCOMP]);
		2403	dst[i*4+1] = _mesa_float_to_half(rgba[i][GCOMP]);
		2404	dst[i*4+2] = _mesa_float_to_half(rgba[i][BCOMP]);
		2405	dst[i*4+3] = _mesa_float_to_half(rgba[i][ACOMP]);
		2406	}
		2407	break;
		2408	case GL_BGR:
		2409	for (i=0;i
		2410	dst[i*3+0] = _mesa_float_to_half(rgba[i][BCOMP]);
		2411	dst[i*3+1] = _mesa_float_to_half(rgba[i][GCOMP]);
		2412	dst[i*3+2] = _mesa_float_to_half(rgba[i][RCOMP]);
		2413	}
		2414	break;
		2415	case GL_BGRA:
		2416	for (i=0;i
		2417	dst[i*4+0] = _mesa_float_to_half(rgba[i][BCOMP]);
		2418	dst[i*4+1] = _mesa_float_to_half(rgba[i][GCOMP]);
		2419	dst[i*4+2] = _mesa_float_to_half(rgba[i][RCOMP]);
		2420	dst[i*4+3] = _mesa_float_to_half(rgba[i][ACOMP]);
		2421	}
		2422	break;
		2423	case GL_ABGR_EXT:
		2424	for (i=0;i
		2425	dst[i*4+0] = _mesa_float_to_half(rgba[i][ACOMP]);
		2426	dst[i*4+1] = _mesa_float_to_half(rgba[i][BCOMP]);
		2427	dst[i*4+2] = _mesa_float_to_half(rgba[i][GCOMP]);
		2428	dst[i*4+3] = _mesa_float_to_half(rgba[i][RCOMP]);
		2429	}
		2430	break;
		2431	case GL_DUDV_ATI:
		2432	case GL_DU8DV8_ATI:
		2433	for (i=0;i
		2434	dst[i*2+0] = _mesa_float_to_half(rgba[i][RCOMP]);
		2435	dst[i*2+1] = _mesa_float_to_half(rgba[i][GCOMP]);
		2436	}
		2437	break;
		2438	default:
		2439	_mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
		2440	}
		2441	}
		2442	break;
		2443	case GL_UNSIGNED_BYTE_3_3_2:
		2444	if (dstFormat == GL_RGB) {
		2445	GLubyte dst = (GLubyte ) dstAddr;
		2446	for (i=0;i
		2447	dst[i] = (F_TO_I(rgba[i][RCOMP] * 7.0F) << 5)
		2448	\| (F_TO_I(rgba[i][GCOMP] * 7.0F) << 2)
		2449	\| (F_TO_I(rgba[i][BCOMP] * 3.0F) );
		2450	}
		2451	}
		2452	break;
		2453	case GL_UNSIGNED_BYTE_2_3_3_REV:
		2454	if (dstFormat == GL_RGB) {
		2455	GLubyte dst = (GLubyte ) dstAddr;
		2456	for (i=0;i
		2457	dst[i] = (F_TO_I(rgba[i][RCOMP] * 7.0F) )
		2458	\| (F_TO_I(rgba[i][GCOMP] * 7.0F) << 3)
		2459	\| (F_TO_I(rgba[i][BCOMP] * 3.0F) << 6);
		2460	}
		2461	}
		2462	break;
		2463	case GL_UNSIGNED_SHORT_5_6_5:
		2464	if (dstFormat == GL_RGB) {
		2465	GLushort dst = (GLushort ) dstAddr;
		2466	for (i=0;i
		2467	dst[i] = (F_TO_I(rgba[i][RCOMP] * 31.0F) << 11)
		2468	\| (F_TO_I(rgba[i][GCOMP] * 63.0F) << 5)
		2469	\| (F_TO_I(rgba[i][BCOMP] * 31.0F) );
		2470	}
		2471	}
		2472	break;
		2473	case GL_UNSIGNED_SHORT_5_6_5_REV:
		2474	if (dstFormat == GL_RGB) {
		2475	GLushort dst = (GLushort ) dstAddr;
		2476	for (i=0;i
		2477	dst[i] = (F_TO_I(rgba[i][RCOMP] * 31.0F) )
		2478	\| (F_TO_I(rgba[i][GCOMP] * 63.0F) << 5)
		2479	\| (F_TO_I(rgba[i][BCOMP] * 31.0F) << 11);
		2480	}
		2481	}
		2482	break;
		2483	case GL_UNSIGNED_SHORT_4_4_4_4:
		2484	if (dstFormat == GL_RGBA) {
		2485	GLushort dst = (GLushort ) dstAddr;
		2486	for (i=0;i
		2487	dst[i] = (F_TO_I(rgba[i][RCOMP] * 15.0F) << 12)
		2488	\| (F_TO_I(rgba[i][GCOMP] * 15.0F) << 8)
		2489	\| (F_TO_I(rgba[i][BCOMP] * 15.0F) << 4)
		2490	\| (F_TO_I(rgba[i][ACOMP] * 15.0F) );
		2491	}
		2492	}
		2493	else if (dstFormat == GL_BGRA) {
		2494	GLushort dst = (GLushort ) dstAddr;
		2495	for (i=0;i
		2496	dst[i] = (F_TO_I(rgba[i][BCOMP] * 15.0F) << 12)
		2497	\| (F_TO_I(rgba[i][GCOMP] * 15.0F) << 8)
		2498	\| (F_TO_I(rgba[i][RCOMP] * 15.0F) << 4)
		2499	\| (F_TO_I(rgba[i][ACOMP] * 15.0F) );
		2500	}
		2501	}
		2502	else if (dstFormat == GL_ABGR_EXT) {
		2503	GLushort dst = (GLushort ) dstAddr;
		2504	for (i=0;i
		2505	dst[i] = (F_TO_I(rgba[i][ACOMP] * 15.0F) << 12)
		2506	\| (F_TO_I(rgba[i][BCOMP] * 15.0F) << 8)
		2507	\| (F_TO_I(rgba[i][GCOMP] * 15.0F) << 4)
		2508	\| (F_TO_I(rgba[i][RCOMP] * 15.0F) );
		2509	}
		2510	}
		2511	break;
		2512	case GL_UNSIGNED_SHORT_4_4_4_4_REV:
		2513	if (dstFormat == GL_RGBA) {
		2514	GLushort dst = (GLushort ) dstAddr;
		2515	for (i=0;i
		2516	dst[i] = (F_TO_I(rgba[i][RCOMP] * 15.0F) )
		2517	\| (F_TO_I(rgba[i][GCOMP] * 15.0F) << 4)
		2518	\| (F_TO_I(rgba[i][BCOMP] * 15.0F) << 8)
		2519	\| (F_TO_I(rgba[i][ACOMP] * 15.0F) << 12);
		2520	}
		2521	}
		2522	else if (dstFormat == GL_BGRA) {
		2523	GLushort dst = (GLushort ) dstAddr;
		2524	for (i=0;i
		2525	dst[i] = (F_TO_I(rgba[i][BCOMP] * 15.0F) )
		2526	\| (F_TO_I(rgba[i][GCOMP] * 15.0F) << 4)
		2527	\| (F_TO_I(rgba[i][RCOMP] * 15.0F) << 8)
		2528	\| (F_TO_I(rgba[i][ACOMP] * 15.0F) << 12);
		2529	}
		2530	}
		2531	else if (dstFormat == GL_ABGR_EXT) {
		2532	GLushort dst = (GLushort ) dstAddr;
		2533	for (i=0;i
		2534	dst[i] = (F_TO_I(rgba[i][ACOMP] * 15.0F) )
		2535	\| (F_TO_I(rgba[i][BCOMP] * 15.0F) << 4)
		2536	\| (F_TO_I(rgba[i][GCOMP] * 15.0F) << 8)
		2537	\| (F_TO_I(rgba[i][RCOMP] * 15.0F) << 12);
		2538	}
		2539	}
		2540	break;
		2541	case GL_UNSIGNED_SHORT_5_5_5_1:
		2542	if (dstFormat == GL_RGBA) {
		2543	GLushort dst = (GLushort ) dstAddr;
		2544	for (i=0;i
		2545	dst[i] = (F_TO_I(rgba[i][RCOMP] * 31.0F) << 11)
		2546	\| (F_TO_I(rgba[i][GCOMP] * 31.0F) << 6)
		2547	\| (F_TO_I(rgba[i][BCOMP] * 31.0F) << 1)
		2548	\| (F_TO_I(rgba[i][ACOMP] * 1.0F) );
		2549	}
		2550	}
		2551	else if (dstFormat == GL_BGRA) {
		2552	GLushort dst = (GLushort ) dstAddr;
		2553	for (i=0;i
		2554	dst[i] = (F_TO_I(rgba[i][BCOMP] * 31.0F) << 11)
		2555	\| (F_TO_I(rgba[i][GCOMP] * 31.0F) << 6)
		2556	\| (F_TO_I(rgba[i][RCOMP] * 31.0F) << 1)
		2557	\| (F_TO_I(rgba[i][ACOMP] * 1.0F) );
		2558	}
		2559	}
		2560	else if (dstFormat == GL_ABGR_EXT) {
		2561	GLushort dst = (GLushort ) dstAddr;
		2562	for (i=0;i
		2563	dst[i] = (F_TO_I(rgba[i][ACOMP] * 31.0F) << 11)
		2564	\| (F_TO_I(rgba[i][BCOMP] * 31.0F) << 6)
		2565	\| (F_TO_I(rgba[i][GCOMP] * 31.0F) << 1)
		2566	\| (F_TO_I(rgba[i][RCOMP] * 1.0F) );
		2567	}
		2568	}
		2569	break;
		2570	case GL_UNSIGNED_SHORT_1_5_5_5_REV:
		2571	if (dstFormat == GL_RGBA) {
		2572	GLushort dst = (GLushort ) dstAddr;
		2573	for (i=0;i
		2574	dst[i] = (F_TO_I(rgba[i][RCOMP] * 31.0F) )
		2575	\| (F_TO_I(rgba[i][GCOMP] * 31.0F) << 5)
		2576	\| (F_TO_I(rgba[i][BCOMP] * 31.0F) << 10)
		2577	\| (F_TO_I(rgba[i][ACOMP] * 1.0F) << 15);
		2578	}
		2579	}
		2580	else if (dstFormat == GL_BGRA) {
		2581	GLushort dst = (GLushort ) dstAddr;
		2582	for (i=0;i
		2583	dst[i] = (F_TO_I(rgba[i][BCOMP] * 31.0F) )
		2584	\| (F_TO_I(rgba[i][GCOMP] * 31.0F) << 5)
		2585	\| (F_TO_I(rgba[i][RCOMP] * 31.0F) << 10)
		2586	\| (F_TO_I(rgba[i][ACOMP] * 1.0F) << 15);
		2587	}
		2588	}
		2589	else if (dstFormat == GL_ABGR_EXT) {
		2590	GLushort dst = (GLushort ) dstAddr;
		2591	for (i=0;i
		2592	dst[i] = (F_TO_I(rgba[i][ACOMP] * 31.0F) )
		2593	\| (F_TO_I(rgba[i][BCOMP] * 31.0F) << 5)
		2594	\| (F_TO_I(rgba[i][GCOMP] * 31.0F) << 10)
		2595	\| (F_TO_I(rgba[i][RCOMP] * 1.0F) << 15);
		2596	}
		2597	}
		2598	break;
		2599	case GL_UNSIGNED_INT_8_8_8_8:
		2600	if (dstFormat == GL_RGBA) {
		2601	GLuint dst = (GLuint ) dstAddr;
		2602	for (i=0;i
		2603	dst[i] = (F_TO_I(rgba[i][RCOMP] * 255.F) << 24)
		2604	\| (F_TO_I(rgba[i][GCOMP] * 255.F) << 16)
		2605	\| (F_TO_I(rgba[i][BCOMP] * 255.F) << 8)
		2606	\| (F_TO_I(rgba[i][ACOMP] * 255.F) );
		2607	}
		2608	}
		2609	else if (dstFormat == GL_BGRA) {
		2610	GLuint dst = (GLuint ) dstAddr;
		2611	for (i=0;i
		2612	dst[i] = (F_TO_I(rgba[i][BCOMP] * 255.F) << 24)
		2613	\| (F_TO_I(rgba[i][GCOMP] * 255.F) << 16)
		2614	\| (F_TO_I(rgba[i][RCOMP] * 255.F) << 8)
		2615	\| (F_TO_I(rgba[i][ACOMP] * 255.F) );
		2616	}
		2617	}
		2618	else if (dstFormat == GL_ABGR_EXT) {
		2619	GLuint dst = (GLuint ) dstAddr;
		2620	for (i=0;i
		2621	dst[i] = (F_TO_I(rgba[i][ACOMP] * 255.F) << 24)
		2622	\| (F_TO_I(rgba[i][BCOMP] * 255.F) << 16)
		2623	\| (F_TO_I(rgba[i][GCOMP] * 255.F) << 8)
		2624	\| (F_TO_I(rgba[i][RCOMP] * 255.F) );
		2625	}
		2626	}
		2627	break;
		2628	case GL_UNSIGNED_INT_8_8_8_8_REV:
		2629	if (dstFormat == GL_RGBA) {
		2630	GLuint dst = (GLuint ) dstAddr;
		2631	for (i=0;i
		2632	dst[i] = (F_TO_I(rgba[i][RCOMP] * 255.0F) )
		2633	\| (F_TO_I(rgba[i][GCOMP] * 255.0F) << 8)
		2634	\| (F_TO_I(rgba[i][BCOMP] * 255.0F) << 16)
		2635	\| (F_TO_I(rgba[i][ACOMP] * 255.0F) << 24);
		2636	}
		2637	}
		2638	else if (dstFormat == GL_BGRA) {
		2639	GLuint dst = (GLuint ) dstAddr;
		2640	for (i=0;i
		2641	dst[i] = (F_TO_I(rgba[i][BCOMP] * 255.0F) )
		2642	\| (F_TO_I(rgba[i][GCOMP] * 255.0F) << 8)
		2643	\| (F_TO_I(rgba[i][RCOMP] * 255.0F) << 16)
		2644	\| (F_TO_I(rgba[i][ACOMP] * 255.0F) << 24);
		2645	}
		2646	}
		2647	else if (dstFormat == GL_ABGR_EXT) {
		2648	GLuint dst = (GLuint ) dstAddr;
		2649	for (i=0;i
		2650	dst[i] = (F_TO_I(rgba[i][ACOMP] * 255.0F) )
		2651	\| (F_TO_I(rgba[i][BCOMP] * 255.0F) << 8)
		2652	\| (F_TO_I(rgba[i][GCOMP] * 255.0F) << 16)
		2653	\| (F_TO_I(rgba[i][RCOMP] * 255.0F) << 24);
		2654	}
		2655	}
		2656	break;
		2657	case GL_UNSIGNED_INT_10_10_10_2:
		2658	if (dstFormat == GL_RGBA) {
		2659	GLuint dst = (GLuint ) dstAddr;
		2660	for (i=0;i
		2661	dst[i] = (F_TO_I(rgba[i][RCOMP] * 1023.0F) << 22)
		2662	\| (F_TO_I(rgba[i][GCOMP] * 1023.0F) << 12)
		2663	\| (F_TO_I(rgba[i][BCOMP] * 1023.0F) << 2)
		2664	\| (F_TO_I(rgba[i][ACOMP] * 3.0F) );
		2665	}
		2666	}
		2667	else if (dstFormat == GL_BGRA) {
		2668	GLuint dst = (GLuint ) dstAddr;
		2669	for (i=0;i
		2670	dst[i] = (F_TO_I(rgba[i][BCOMP] * 1023.0F) << 22)
		2671	\| (F_TO_I(rgba[i][GCOMP] * 1023.0F) << 12)
		2672	\| (F_TO_I(rgba[i][RCOMP] * 1023.0F) << 2)
		2673	\| (F_TO_I(rgba[i][ACOMP] * 3.0F) );
		2674	}
		2675	}
		2676	else if (dstFormat == GL_ABGR_EXT) {
		2677	GLuint dst = (GLuint ) dstAddr;
		2678	for (i=0;i
		2679	dst[i] = (F_TO_I(rgba[i][ACOMP] * 1023.0F) << 22)
		2680	\| (F_TO_I(rgba[i][BCOMP] * 1023.0F) << 12)
		2681	\| (F_TO_I(rgba[i][GCOMP] * 1023.0F) << 2)
		2682	\| (F_TO_I(rgba[i][RCOMP] * 3.0F) );
		2683	}
		2684	}
		2685	break;
		2686	case GL_UNSIGNED_INT_2_10_10_10_REV:
		2687	if (dstFormat == GL_RGBA) {
		2688	GLuint dst = (GLuint ) dstAddr;
		2689	for (i=0;i
		2690	dst[i] = (F_TO_I(rgba[i][RCOMP] * 1023.0F) )
		2691	\| (F_TO_I(rgba[i][GCOMP] * 1023.0F) << 10)
		2692	\| (F_TO_I(rgba[i][BCOMP] * 1023.0F) << 20)
		2693	\| (F_TO_I(rgba[i][ACOMP] * 3.0F) << 30);
		2694	}
		2695	}
		2696	else if (dstFormat == GL_BGRA) {
		2697	GLuint dst = (GLuint ) dstAddr;
		2698	for (i=0;i
		2699	dst[i] = (F_TO_I(rgba[i][BCOMP] * 1023.0F) )
		2700	\| (F_TO_I(rgba[i][GCOMP] * 1023.0F) << 10)
		2701	\| (F_TO_I(rgba[i][RCOMP] * 1023.0F) << 20)
		2702	\| (F_TO_I(rgba[i][ACOMP] * 3.0F) << 30);
		2703	}
		2704	}
		2705	else if (dstFormat == GL_ABGR_EXT) {
		2706	GLuint dst = (GLuint ) dstAddr;
		2707	for (i=0;i
		2708	dst[i] = (F_TO_I(rgba[i][ACOMP] * 1023.0F) )
		2709	\| (F_TO_I(rgba[i][BCOMP] * 1023.0F) << 10)
		2710	\| (F_TO_I(rgba[i][GCOMP] * 1023.0F) << 20)
		2711	\| (F_TO_I(rgba[i][RCOMP] * 3.0F) << 30);
		2712	}
		2713	}
		2714	break;
		2715	case GL_UNSIGNED_INT_5_9_9_9_REV:
		2716	{
		2717	GLuint dst = (GLuint ) dstAddr;
		2718	for (i = 0; i < n; i++) {
		2719	dst[i] = float3_to_rgb9e5(rgba[i]);
		2720	}
		2721	}
		2722	break;
		2723	case GL_UNSIGNED_INT_10F_11F_11F_REV:
		2724	{
		2725	GLuint dst = (GLuint ) dstAddr;
		2726	for (i = 0; i < n; i++) {
		2727	dst[i] = float3_to_r11g11b10f(rgba[i]);
		2728	}
		2729	}
		2730	break;
		2731	default:
		2732	_mesa_problem(ctx, "bad type in _mesa_pack_rgba_span_float");
		2733	free(luminance);
		2734	return;
		2735	}
		2736
		2737	if (dstPacking->SwapBytes) {
		2738	GLint swapSize = _mesa_sizeof_packed_type(dstType);
		2739	if (swapSize == 2) {
		2740	_mesa_swap2((GLushort ) dstAddr, n comps);
		2741	}
		2742	else if (swapSize == 4) {
		2743	_mesa_swap4((GLuint ) dstAddr, n comps);
		2744	}
		2745	}
		2746
		2747	free(luminance);
		2748	}
		2749
		2750
		2751
		2752	#define SWAP2BYTE(VALUE) \
		2753	{ \
		2754	GLubyte bytes = (GLubyte ) &(VALUE); \
		2755	GLubyte tmp = bytes[0]; \
		2756	bytes[0] = bytes[1]; \
		2757	bytes[1] = tmp; \
		2758	}
		2759
		2760	#define SWAP4BYTE(VALUE) \
		2761	{ \
		2762	GLubyte bytes = (GLubyte ) &(VALUE); \
		2763	GLubyte tmp = bytes[0]; \
		2764	bytes[0] = bytes[3]; \
		2765	bytes[3] = tmp; \
		2766	tmp = bytes[1]; \
		2767	bytes[1] = bytes[2]; \
		2768	bytes[2] = tmp; \
		2769	}
		2770
		2771
		2772	static void
		2773	extract_uint_indexes(GLuint n, GLuint indexes[],
		2774	GLenum srcFormat, GLenum srcType, const GLvoid *src,
		2775	const struct gl_pixelstore_attrib *unpack )
		2776	{
		2777	ASSERT(srcFormat == GL_COLOR_INDEX \|\| srcFormat == GL_STENCIL_INDEX);
		2778
		2779	ASSERT(srcType == GL_BITMAP \|\|
		2780	srcType == GL_UNSIGNED_BYTE \|\|
		2781	srcType == GL_BYTE \|\|
		2782	srcType == GL_UNSIGNED_SHORT \|\|
		2783	srcType == GL_SHORT \|\|
		2784	srcType == GL_UNSIGNED_INT \|\|
		2785	srcType == GL_INT \|\|
		2786	srcType == GL_UNSIGNED_INT_24_8_EXT \|\|
		2787	srcType == GL_HALF_FLOAT_ARB \|\|
		2788	srcType == GL_FLOAT \|\|
		2789	srcType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
		2790
		2791	switch (srcType) {
		2792	case GL_BITMAP:
		2793	{
		2794	GLubyte ubsrc = (GLubyte ) src;
		2795	if (unpack->LsbFirst) {
		2796	GLubyte mask = 1 << (unpack->SkipPixels & 0x7);
		2797	GLuint i;
		2798	for (i = 0; i < n; i++) {
		2799	indexes[i] = (*ubsrc & mask) ? 1 : 0;
		2800	if (mask == 128) {
		2801	mask = 1;
		2802	ubsrc++;
		2803	}
		2804	else {
		2805	mask = mask << 1;
		2806	}
		2807	}
		2808	}
		2809	else {
		2810	GLubyte mask = 128 >> (unpack->SkipPixels & 0x7);
		2811	GLuint i;
		2812	for (i = 0; i < n; i++) {
		2813	indexes[i] = (*ubsrc & mask) ? 1 : 0;
		2814	if (mask == 1) {
		2815	mask = 128;
		2816	ubsrc++;
		2817	}
		2818	else {
		2819	mask = mask >> 1;
		2820	}
		2821	}
		2822	}
		2823	}
		2824	break;
		2825	case GL_UNSIGNED_BYTE:
		2826	{
		2827	GLuint i;
		2828	const GLubyte s = (const GLubyte ) src;
		2829	for (i = 0; i < n; i++)
		2830	indexes[i] = s[i];
		2831	}
		2832	break;
		2833	case GL_BYTE:
		2834	{
		2835	GLuint i;
		2836	const GLbyte s = (const GLbyte ) src;
		2837	for (i = 0; i < n; i++)
		2838	indexes[i] = s[i];
		2839	}
		2840	break;
		2841	case GL_UNSIGNED_SHORT:
		2842	{
		2843	GLuint i;
		2844	const GLushort s = (const GLushort ) src;
		2845	if (unpack->SwapBytes) {
		2846	for (i = 0; i < n; i++) {
		2847	GLushort value = s[i];
		2848	SWAP2BYTE(value);
		2849	indexes[i] = value;
		2850	}
		2851	}
		2852	else {
		2853	for (i = 0; i < n; i++)
		2854	indexes[i] = s[i];
		2855	}
		2856	}
		2857	break;
		2858	case GL_SHORT:
		2859	{
		2860	GLuint i;
		2861	const GLshort s = (const GLshort ) src;
		2862	if (unpack->SwapBytes) {
		2863	for (i = 0; i < n; i++) {
		2864	GLshort value = s[i];
		2865	SWAP2BYTE(value);
		2866	indexes[i] = value;
		2867	}
		2868	}
		2869	else {
		2870	for (i = 0; i < n; i++)
		2871	indexes[i] = s[i];
		2872	}
		2873	}
		2874	break;
		2875	case GL_UNSIGNED_INT:
		2876	{
		2877	GLuint i;
		2878	const GLuint s = (const GLuint ) src;
		2879	if (unpack->SwapBytes) {
		2880	for (i = 0; i < n; i++) {
		2881	GLuint value = s[i];
		2882	SWAP4BYTE(value);
		2883	indexes[i] = value;
		2884	}
		2885	}
		2886	else {
		2887	for (i = 0; i < n; i++)
		2888	indexes[i] = s[i];
		2889	}
		2890	}
		2891	break;
		2892	case GL_INT:
		2893	{
		2894	GLuint i;
		2895	const GLint s = (const GLint ) src;
		2896	if (unpack->SwapBytes) {
		2897	for (i = 0; i < n; i++) {
		2898	GLint value = s[i];
		2899	SWAP4BYTE(value);
		2900	indexes[i] = value;
		2901	}
		2902	}
		2903	else {
		2904	for (i = 0; i < n; i++)
		2905	indexes[i] = s[i];
		2906	}
		2907	}
		2908	break;
		2909	case GL_FLOAT:
		2910	{
		2911	GLuint i;
		2912	const GLfloat s = (const GLfloat ) src;
		2913	if (unpack->SwapBytes) {
		2914	for (i = 0; i < n; i++) {
		2915	GLfloat value = s[i];
		2916	SWAP4BYTE(value);
		2917	indexes[i] = (GLuint) value;
		2918	}
		2919	}
		2920	else {
		2921	for (i = 0; i < n; i++)
		2922	indexes[i] = (GLuint) s[i];
		2923	}
		2924	}
		2925	break;
		2926	case GL_HALF_FLOAT_ARB:
		2927	{
		2928	GLuint i;
		2929	const GLhalfARB s = (const GLhalfARB ) src;
		2930	if (unpack->SwapBytes) {
		2931	for (i = 0; i < n; i++) {
		2932	GLhalfARB value = s[i];
		2933	SWAP2BYTE(value);
		2934	indexes[i] = (GLuint) _mesa_half_to_float(value);
		2935	}
		2936	}
		2937	else {
		2938	for (i = 0; i < n; i++)
		2939	indexes[i] = (GLuint) _mesa_half_to_float(s[i]);
		2940	}
		2941	}
		2942	break;
		2943	case GL_UNSIGNED_INT_24_8_EXT:
		2944	{
		2945	GLuint i;
		2946	const GLuint s = (const GLuint ) src;
		2947	if (unpack->SwapBytes) {
		2948	for (i = 0; i < n; i++) {
		2949	GLuint value = s[i];
		2950	SWAP4BYTE(value);
		2951	indexes[i] = value & 0xff; /* lower 8 bits */
		2952	}
		2953	}
		2954	else {
		2955	for (i = 0; i < n; i++)
		2956	indexes[i] = s[i] & 0xff; /* lower 8 bits */
		2957	}
		2958	}
		2959	break;
		2960	case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
		2961	{
		2962	GLuint i;
		2963	const GLuint s = (const GLuint ) src;
		2964	if (unpack->SwapBytes) {
		2965	for (i = 0; i < n; i++) {
		2966	GLuint value = s[i*2+1];
		2967	SWAP4BYTE(value);
		2968	indexes[i] = value & 0xff; /* lower 8 bits */
		2969	}
		2970	}
		2971	else {
		2972	for (i = 0; i < n; i++)
		2973	indexes[i] = s[i2+1] & 0xff; / lower 8 bits */
		2974	}
		2975	}
		2976	break;
		2977
		2978	default:
		2979	_mesa_problem(NULL, "bad srcType in extract_uint_indexes");
		2980	return;
		2981	}
		2982	}
		2983
		2984
		2985	/**
		2986	* Return source/dest RGBA indexes for unpacking pixels.
		2987	*/
		2988	static void
		2989	get_component_mapping(GLenum format,
		2990	GLint *rSrc,
		2991	GLint *gSrc,
		2992	GLint *bSrc,
		2993	GLint *aSrc,
		2994	GLint *rDst,
		2995	GLint *gDst,
		2996	GLint *bDst,
		2997	GLint *aDst)
		2998	{
		2999	switch (format) {
		3000	case GL_RED:
		3001	case GL_RED_INTEGER_EXT:
		3002	*rSrc = 0;
		3003	gSrc = bSrc = *aSrc = -1;
		3004	break;
		3005	case GL_GREEN:
		3006	case GL_GREEN_INTEGER_EXT:
		3007	*gSrc = 0;
		3008	rSrc = bSrc = *aSrc = -1;
		3009	break;
		3010	case GL_BLUE:
		3011	case GL_BLUE_INTEGER_EXT:
		3012	*bSrc = 0;
		3013	rSrc = gSrc = *aSrc = -1;
		3014	break;
		3015	case GL_ALPHA:
		3016	case GL_ALPHA_INTEGER_EXT:
		3017	rSrc = gSrc = *bSrc = -1;
		3018	*aSrc = 0;
		3019	break;
		3020	case GL_LUMINANCE:
		3021	case GL_LUMINANCE_INTEGER_EXT:
		3022	rSrc = gSrc = *bSrc = 0;
		3023	*aSrc = -1;
		3024	break;
		3025	case GL_LUMINANCE_ALPHA:
		3026	case GL_LUMINANCE_ALPHA_INTEGER_EXT:
		3027	rSrc = gSrc = *bSrc = 0;
		3028	*aSrc = 1;
		3029	break;
		3030	case GL_INTENSITY:
		3031	rSrc = gSrc = bSrc = aSrc = 0;
		3032	break;
		3033	case GL_RG:
		3034	case GL_RG_INTEGER:
		3035	*rSrc = 0;
		3036	*gSrc = 1;
		3037	*bSrc = -1;
		3038	*aSrc = -1;
		3039	*rDst = 0;
		3040	*gDst = 1;
		3041	*bDst = 2;
		3042	*aDst = 3;
		3043	break;
		3044	case GL_RGB:
		3045	case GL_RGB_INTEGER:
		3046	*rSrc = 0;
		3047	*gSrc = 1;
		3048	*bSrc = 2;
		3049	*aSrc = -1;
		3050	*rDst = 0;
		3051	*gDst = 1;
		3052	*bDst = 2;
		3053	*aDst = 3;
		3054	break;
		3055	case GL_BGR:
		3056	case GL_BGR_INTEGER:
		3057	*rSrc = 2;
		3058	*gSrc = 1;
		3059	*bSrc = 0;
		3060	*aSrc = -1;
		3061	*rDst = 2;
		3062	*gDst = 1;
		3063	*bDst = 0;
		3064	*aDst = 3;
		3065	break;
		3066	case GL_RGBA:
		3067	case GL_RGBA_INTEGER:
		3068	*rSrc = 0;
		3069	*gSrc = 1;
		3070	*bSrc = 2;
		3071	*aSrc = 3;
		3072	*rDst = 0;
		3073	*gDst = 1;
		3074	*bDst = 2;
		3075	*aDst = 3;
		3076	break;
		3077	case GL_BGRA:
		3078	case GL_BGRA_INTEGER:
		3079	*rSrc = 2;
		3080	*gSrc = 1;
		3081	*bSrc = 0;
		3082	*aSrc = 3;
		3083	*rDst = 2;
		3084	*gDst = 1;
		3085	*bDst = 0;
		3086	*aDst = 3;
		3087	break;
		3088	case GL_ABGR_EXT:
		3089	*rSrc = 3;
		3090	*gSrc = 2;
		3091	*bSrc = 1;
		3092	*aSrc = 0;
		3093	*rDst = 3;
		3094	*gDst = 2;
		3095	*bDst = 1;
		3096	*aDst = 0;
		3097	break;
		3098	case GL_DU8DV8_ATI:
		3099	case GL_DUDV_ATI:
		3100	*rSrc = 0;
		3101	*gSrc = 1;
		3102	*bSrc = -1;
		3103	*aSrc = -1;
		3104	break;
		3105	default:
		3106	_mesa_problem(NULL, "bad srcFormat %s in get_component_mapping",
		3107	_mesa_lookup_enum_by_nr(format));
		3108	return;
		3109	}
		3110	}
		3111
		3112
		3113
		3114	/*
		3115	* This function extracts floating point RGBA values from arbitrary
		3116	* image data. srcFormat and srcType are the format and type parameters
		3117	* passed to glDrawPixels, glTexImage[123]D, glTexSubImage[123]D, etc.
		3118	*
		3119	* Refering to section 3.6.4 of the OpenGL 1.2 spec, this function
		3120	* implements the "Conversion to floating point", "Conversion to RGB",
		3121	* and "Final Expansion to RGBA" operations.
		3122	*
		3123	* Args: n - number of pixels
		3124	* rgba - output colors
		3125	* srcFormat - format of incoming data
		3126	* srcType - data type of incoming data
		3127	* src - source data pointer
		3128	* swapBytes - perform byteswapping of incoming data?
		3129	*/
		3130	static void
		3131	extract_float_rgba(GLuint n, GLfloat rgba[][4],
		3132	GLenum srcFormat, GLenum srcType, const GLvoid *src,
		3133	GLboolean swapBytes)
		3134	{
		3135	GLint rSrc, gSrc, bSrc, aSrc;
		3136	GLint stride;
		3137	GLint rDst, bDst, gDst, aDst;
		3138	GLboolean intFormat;
		3139	GLfloat rs = 1.0f, gs = 1.0f, bs = 1.0f, as = 1.0f; /* scale factors */
		3140
		3141	ASSERT(srcFormat == GL_RED \|\|
		3142	srcFormat == GL_GREEN \|\|
		3143	srcFormat == GL_BLUE \|\|
		3144	srcFormat == GL_ALPHA \|\|
		3145	srcFormat == GL_LUMINANCE \|\|
		3146	srcFormat == GL_LUMINANCE_ALPHA \|\|
		3147	srcFormat == GL_INTENSITY \|\|
		3148	srcFormat == GL_RG \|\|
		3149	srcFormat == GL_RGB \|\|
		3150	srcFormat == GL_BGR \|\|
		3151	srcFormat == GL_RGBA \|\|
		3152	srcFormat == GL_BGRA \|\|
		3153	srcFormat == GL_ABGR_EXT \|\|
		3154	srcFormat == GL_DU8DV8_ATI \|\|
		3155	srcFormat == GL_DUDV_ATI \|\|
		3156	srcFormat == GL_RED_INTEGER_EXT \|\|
		3157	srcFormat == GL_GREEN_INTEGER_EXT \|\|
		3158	srcFormat == GL_BLUE_INTEGER_EXT \|\|
		3159	srcFormat == GL_ALPHA_INTEGER_EXT \|\|
		3160	srcFormat == GL_RG_INTEGER \|\|
		3161	srcFormat == GL_RGB_INTEGER_EXT \|\|
		3162	srcFormat == GL_RGBA_INTEGER_EXT \|\|
		3163	srcFormat == GL_BGR_INTEGER_EXT \|\|
		3164	srcFormat == GL_BGRA_INTEGER_EXT \|\|
		3165	srcFormat == GL_LUMINANCE_INTEGER_EXT \|\|
		3166	srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT);
		3167
		3168	ASSERT(srcType == GL_UNSIGNED_BYTE \|\|
		3169	srcType == GL_BYTE \|\|
		3170	srcType == GL_UNSIGNED_SHORT \|\|
		3171	srcType == GL_SHORT \|\|
		3172	srcType == GL_UNSIGNED_INT \|\|
		3173	srcType == GL_INT \|\|
		3174	srcType == GL_HALF_FLOAT_ARB \|\|
		3175	srcType == GL_FLOAT \|\|
		3176	srcType == GL_UNSIGNED_BYTE_3_3_2 \|\|
		3177	srcType == GL_UNSIGNED_BYTE_2_3_3_REV \|\|
		3178	srcType == GL_UNSIGNED_SHORT_5_6_5 \|\|
		3179	srcType == GL_UNSIGNED_SHORT_5_6_5_REV \|\|
		3180	srcType == GL_UNSIGNED_SHORT_4_4_4_4 \|\|
		3181	srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV \|\|
		3182	srcType == GL_UNSIGNED_SHORT_5_5_5_1 \|\|
		3183	srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV \|\|
		3184	srcType == GL_UNSIGNED_INT_8_8_8_8 \|\|
		3185	srcType == GL_UNSIGNED_INT_8_8_8_8_REV \|\|
		3186	srcType == GL_UNSIGNED_INT_10_10_10_2 \|\|
		3187	srcType == GL_UNSIGNED_INT_2_10_10_10_REV \|\|
		3188	srcType == GL_UNSIGNED_INT_5_9_9_9_REV \|\|
		3189	srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
		3190
		3191	get_component_mapping(srcFormat,
		3192	&rSrc, &gSrc, &bSrc, &aSrc,
		3193	&rDst, &gDst, &bDst, &aDst);
		3194
		3195	stride = _mesa_components_in_format(srcFormat);
		3196
		3197	intFormat = _mesa_is_enum_format_integer(srcFormat);
		3198
		3199	#define PROCESS(SRC_INDEX, DST_INDEX, DEFAULT_FLT, DEFAULT_INT, TYPE, CONVERSION) \
		3200	if ((SRC_INDEX) < 0) { \
		3201	GLuint i; \
		3202	if (intFormat) { \
		3203	for (i = 0; i < n; i++) { \
		3204	rgba[i][DST_INDEX] = DEFAULT_INT; \
		3205	} \
		3206	} \
		3207	else { \
		3208	for (i = 0; i < n; i++) { \
		3209	rgba[i][DST_INDEX] = DEFAULT_FLT; \
		3210	} \
		3211	} \
		3212	} \
		3213	else if (swapBytes) { \
		3214	const TYPE s = (const TYPE ) src; \
		3215	GLuint i; \
		3216	for (i = 0; i < n; i++) { \
		3217	TYPE value = s[SRC_INDEX]; \
		3218	if (sizeof(TYPE) == 2) { \
		3219	SWAP2BYTE(value); \
		3220	} \
		3221	else if (sizeof(TYPE) == 4) { \
		3222	SWAP4BYTE(value); \
		3223	} \
		3224	if (intFormat) \
		3225	rgba[i][DST_INDEX] = (GLfloat) value; \
		3226	else \
		3227	rgba[i][DST_INDEX] = (GLfloat) CONVERSION(value); \
		3228	s += stride; \
		3229	} \
		3230	} \
		3231	else { \
		3232	const TYPE s = (const TYPE ) src; \
		3233	GLuint i; \
		3234	if (intFormat) { \
		3235	for (i = 0; i < n; i++) { \
		3236	rgba[i][DST_INDEX] = (GLfloat) s[SRC_INDEX]; \
		3237	s += stride; \
		3238	} \
		3239	} \
		3240	else { \
		3241	for (i = 0; i < n; i++) { \
		3242	rgba[i][DST_INDEX] = (GLfloat) CONVERSION(s[SRC_INDEX]); \
		3243	s += stride; \
		3244	} \
		3245	} \
		3246	}
		3247
		3248	switch (srcType) {
		3249	case GL_UNSIGNED_BYTE:
		3250	PROCESS(rSrc, RCOMP, 0.0F, 0, GLubyte, UBYTE_TO_FLOAT);
		3251	PROCESS(gSrc, GCOMP, 0.0F, 0, GLubyte, UBYTE_TO_FLOAT);
		3252	PROCESS(bSrc, BCOMP, 0.0F, 0, GLubyte, UBYTE_TO_FLOAT);
		3253	PROCESS(aSrc, ACOMP, 1.0F, 255, GLubyte, UBYTE_TO_FLOAT);
		3254	break;
		3255	case GL_BYTE:
		3256	PROCESS(rSrc, RCOMP, 0.0F, 0, GLbyte, BYTE_TO_FLOATZ);
		3257	PROCESS(gSrc, GCOMP, 0.0F, 0, GLbyte, BYTE_TO_FLOATZ);
		3258	PROCESS(bSrc, BCOMP, 0.0F, 0, GLbyte, BYTE_TO_FLOATZ);
		3259	PROCESS(aSrc, ACOMP, 1.0F, 127, GLbyte, BYTE_TO_FLOATZ);
		3260	break;
		3261	case GL_UNSIGNED_SHORT:
		3262	PROCESS(rSrc, RCOMP, 0.0F, 0, GLushort, USHORT_TO_FLOAT);
		3263	PROCESS(gSrc, GCOMP, 0.0F, 0, GLushort, USHORT_TO_FLOAT);
		3264	PROCESS(bSrc, BCOMP, 0.0F, 0, GLushort, USHORT_TO_FLOAT);
		3265	PROCESS(aSrc, ACOMP, 1.0F, 0xffff, GLushort, USHORT_TO_FLOAT);
		3266	break;
		3267	case GL_SHORT:
		3268	PROCESS(rSrc, RCOMP, 0.0F, 0, GLshort, SHORT_TO_FLOATZ);
		3269	PROCESS(gSrc, GCOMP, 0.0F, 0, GLshort, SHORT_TO_FLOATZ);
		3270	PROCESS(bSrc, BCOMP, 0.0F, 0, GLshort, SHORT_TO_FLOATZ);
		3271	PROCESS(aSrc, ACOMP, 1.0F, 32767, GLshort, SHORT_TO_FLOATZ);
		3272	break;
		3273	case GL_UNSIGNED_INT:
		3274	PROCESS(rSrc, RCOMP, 0.0F, 0, GLuint, UINT_TO_FLOAT);
		3275	PROCESS(gSrc, GCOMP, 0.0F, 0, GLuint, UINT_TO_FLOAT);
		3276	PROCESS(bSrc, BCOMP, 0.0F, 0, GLuint, UINT_TO_FLOAT);
		3277	PROCESS(aSrc, ACOMP, 1.0F, 0xffffffff, GLuint, UINT_TO_FLOAT);
		3278	break;
		3279	case GL_INT:
		3280	PROCESS(rSrc, RCOMP, 0.0F, 0, GLint, INT_TO_FLOAT);
		3281	PROCESS(gSrc, GCOMP, 0.0F, 0, GLint, INT_TO_FLOAT);
		3282	PROCESS(bSrc, BCOMP, 0.0F, 0, GLint, INT_TO_FLOAT);
		3283	PROCESS(aSrc, ACOMP, 1.0F, 2147483647, GLint, INT_TO_FLOAT);
		3284	break;
		3285	case GL_FLOAT:
		3286	PROCESS(rSrc, RCOMP, 0.0F, 0.0F, GLfloat, (GLfloat));
		3287	PROCESS(gSrc, GCOMP, 0.0F, 0.0F, GLfloat, (GLfloat));
		3288	PROCESS(bSrc, BCOMP, 0.0F, 0.0F, GLfloat, (GLfloat));
		3289	PROCESS(aSrc, ACOMP, 1.0F, 1.0F, GLfloat, (GLfloat));
		3290	break;
		3291	case GL_HALF_FLOAT_ARB:
		3292	PROCESS(rSrc, RCOMP, 0.0F, 0.0F, GLhalfARB, _mesa_half_to_float);
		3293	PROCESS(gSrc, GCOMP, 0.0F, 0.0F, GLhalfARB, _mesa_half_to_float);
		3294	PROCESS(bSrc, BCOMP, 0.0F, 0.0F, GLhalfARB, _mesa_half_to_float);
		3295	PROCESS(aSrc, ACOMP, 1.0F, 1.0F, GLhalfARB, _mesa_half_to_float);
		3296	break;
		3297	case GL_UNSIGNED_BYTE_3_3_2:
		3298	{
		3299	const GLubyte ubsrc = (const GLubyte ) src;
		3300	GLuint i;
		3301	if (!intFormat) {
		3302	rs = 1.0F / 7.0F;
		3303	gs = 1.0F / 7.0F;
		3304	bs = 1.0F / 3.0F;
		3305	}
		3306	for (i = 0; i < n; i ++) {
		3307	GLubyte p = ubsrc[i];
		3308	rgba[i][rDst] = ((p >> 5) ) * rs;
		3309	rgba[i][gDst] = ((p >> 2) & 0x7) * gs;
		3310	rgba[i][bDst] = ((p ) & 0x3) * bs;
		3311	rgba[i][aDst] = 1.0F;
		3312	}
		3313	}
		3314	break;
		3315	case GL_UNSIGNED_BYTE_2_3_3_REV:
		3316	{
		3317	const GLubyte ubsrc = (const GLubyte ) src;
		3318	GLuint i;
		3319	if (!intFormat) {
		3320	rs = 1.0F / 7.0F;
		3321	gs = 1.0F / 7.0F;
		3322	bs = 1.0F / 3.0F;
		3323	}
		3324	for (i = 0; i < n; i ++) {
		3325	GLubyte p = ubsrc[i];
		3326	rgba[i][rDst] = ((p ) & 0x7) * rs;
		3327	rgba[i][gDst] = ((p >> 3) & 0x7) * gs;
		3328	rgba[i][bDst] = ((p >> 6) ) * bs;
		3329	rgba[i][aDst] = 1.0F;
		3330	}
		3331	}
		3332	break;
		3333	case GL_UNSIGNED_SHORT_5_6_5:
		3334	if (!intFormat) {
		3335	rs = 1.0F / 31.0F;
		3336	gs = 1.0F / 63.0F;
		3337	bs = 1.0F / 31.0F;
		3338	}
		3339	if (swapBytes) {
		3340	const GLushort ussrc = (const GLushort ) src;
		3341	GLuint i;
		3342	for (i = 0; i < n; i ++) {
		3343	GLushort p = ussrc[i];
		3344	SWAP2BYTE(p);
		3345	rgba[i][rDst] = ((p >> 11) ) * rs;
		3346	rgba[i][gDst] = ((p >> 5) & 0x3f) * gs;
		3347	rgba[i][bDst] = ((p ) & 0x1f) * bs;
		3348	rgba[i][aDst] = 1.0F;
		3349	}
		3350	}
		3351	else {
		3352	const GLushort ussrc = (const GLushort ) src;
		3353	GLuint i;
		3354	for (i = 0; i < n; i ++) {
		3355	GLushort p = ussrc[i];
		3356	rgba[i][rDst] = ((p >> 11) ) * rs;
		3357	rgba[i][gDst] = ((p >> 5) & 0x3f) * gs;
		3358	rgba[i][bDst] = ((p ) & 0x1f) * bs;
		3359	rgba[i][aDst] = 1.0F;
		3360	}
		3361	}
		3362	break;
		3363	case GL_UNSIGNED_SHORT_5_6_5_REV:
		3364	if (!intFormat) {
		3365	rs = 1.0F / 31.0F;
		3366	gs = 1.0F / 63.0F;
		3367	bs = 1.0F / 31.0F;
		3368	}
		3369	if (swapBytes) {
		3370	const GLushort ussrc = (const GLushort ) src;
		3371	GLuint i;
		3372	for (i = 0; i < n; i ++) {
		3373	GLushort p = ussrc[i];
		3374	SWAP2BYTE(p);
		3375	rgba[i][rDst] = ((p ) & 0x1f) * rs;
		3376	rgba[i][gDst] = ((p >> 5) & 0x3f) * gs;
		3377	rgba[i][bDst] = ((p >> 11) ) * bs;
		3378	rgba[i][aDst] = 1.0F;
		3379	}
		3380	}
		3381	else {
		3382	const GLushort ussrc = (const GLushort ) src;
		3383	GLuint i;
		3384	for (i = 0; i < n; i ++) {
		3385	GLushort p = ussrc[i];
		3386	rgba[i][rDst] = ((p ) & 0x1f) * rs;
		3387	rgba[i][gDst] = ((p >> 5) & 0x3f) * gs;
		3388	rgba[i][bDst] = ((p >> 11) ) * bs;
		3389	rgba[i][aDst] = 1.0F;
		3390	}
		3391	}
		3392	break;
		3393	case GL_UNSIGNED_SHORT_4_4_4_4:
		3394	if (!intFormat) {
		3395	rs = gs = bs = as = 1.0F / 15.0F;
		3396	}
		3397	if (swapBytes) {
		3398	const GLushort ussrc = (const GLushort ) src;
		3399	GLuint i;
		3400	for (i = 0; i < n; i ++) {
		3401	GLushort p = ussrc[i];
		3402	SWAP2BYTE(p);
		3403	rgba[i][rDst] = ((p >> 12) ) * rs;
		3404	rgba[i][gDst] = ((p >> 8) & 0xf) * gs;
		3405	rgba[i][bDst] = ((p >> 4) & 0xf) * bs;
		3406	rgba[i][aDst] = ((p ) & 0xf) * as;
		3407	}
		3408	}
		3409	else {
		3410	const GLushort ussrc = (const GLushort ) src;
		3411	GLuint i;
		3412	for (i = 0; i < n; i ++) {
		3413	GLushort p = ussrc[i];
		3414	rgba[i][rDst] = ((p >> 12) ) * rs;
		3415	rgba[i][gDst] = ((p >> 8) & 0xf) * gs;
		3416	rgba[i][bDst] = ((p >> 4) & 0xf) * bs;
		3417	rgba[i][aDst] = ((p ) & 0xf) * as;
		3418	}
		3419	}
		3420	break;
		3421	case GL_UNSIGNED_SHORT_4_4_4_4_REV:
		3422	if (!intFormat) {
		3423	rs = gs = bs = as = 1.0F / 15.0F;
		3424	}
		3425	if (swapBytes) {
		3426	const GLushort ussrc = (const GLushort ) src;
		3427	GLuint i;
		3428	for (i = 0; i < n; i ++) {
		3429	GLushort p = ussrc[i];
		3430	SWAP2BYTE(p);
		3431	rgba[i][rDst] = ((p ) & 0xf) * rs;
		3432	rgba[i][gDst] = ((p >> 4) & 0xf) * gs;
		3433	rgba[i][bDst] = ((p >> 8) & 0xf) * bs;
		3434	rgba[i][aDst] = ((p >> 12) ) * as;
		3435	}
		3436	}
		3437	else {
		3438	const GLushort ussrc = (const GLushort ) src;
		3439	GLuint i;
		3440	for (i = 0; i < n; i ++) {
		3441	GLushort p = ussrc[i];
		3442	rgba[i][rDst] = ((p ) & 0xf) * rs;
		3443	rgba[i][gDst] = ((p >> 4) & 0xf) * gs;
		3444	rgba[i][bDst] = ((p >> 8) & 0xf) * bs;
		3445	rgba[i][aDst] = ((p >> 12) ) * as;
		3446	}
		3447	}
		3448	break;
		3449	case GL_UNSIGNED_SHORT_5_5_5_1:
		3450	if (!intFormat) {
		3451	rs = gs = bs = 1.0F / 31.0F;
		3452	}
		3453	if (swapBytes) {
		3454	const GLushort ussrc = (const GLushort ) src;
		3455	GLuint i;
		3456	for (i = 0; i < n; i ++) {
		3457	GLushort p = ussrc[i];
		3458	SWAP2BYTE(p);
		3459	rgba[i][rDst] = ((p >> 11) ) * rs;
		3460	rgba[i][gDst] = ((p >> 6) & 0x1f) * gs;
		3461	rgba[i][bDst] = ((p >> 1) & 0x1f) * bs;
		3462	rgba[i][aDst] = ((p ) & 0x1) * as;
		3463	}
		3464	}
		3465	else {
		3466	const GLushort ussrc = (const GLushort ) src;
		3467	GLuint i;
		3468	for (i = 0; i < n; i ++) {
		3469	GLushort p = ussrc[i];
		3470	rgba[i][rDst] = ((p >> 11) ) * rs;
		3471	rgba[i][gDst] = ((p >> 6) & 0x1f) * gs;
		3472	rgba[i][bDst] = ((p >> 1) & 0x1f) * bs;
		3473	rgba[i][aDst] = ((p ) & 0x1) * as;
		3474	}
		3475	}
		3476	break;
		3477	case GL_UNSIGNED_SHORT_1_5_5_5_REV:
		3478	if (!intFormat) {
		3479	rs = gs = bs = 1.0F / 31.0F;
		3480	}
		3481	if (swapBytes) {
		3482	const GLushort ussrc = (const GLushort ) src;
		3483	GLuint i;
		3484	for (i = 0; i < n; i ++) {
		3485	GLushort p = ussrc[i];
		3486	SWAP2BYTE(p);
		3487	rgba[i][rDst] = ((p ) & 0x1f) * rs;
		3488	rgba[i][gDst] = ((p >> 5) & 0x1f) * gs;
		3489	rgba[i][bDst] = ((p >> 10) & 0x1f) * bs;
		3490	rgba[i][aDst] = ((p >> 15) ) * as;
		3491	}
		3492	}
		3493	else {
		3494	const GLushort ussrc = (const GLushort ) src;
		3495	GLuint i;
		3496	for (i = 0; i < n; i ++) {
		3497	GLushort p = ussrc[i];
		3498	rgba[i][rDst] = ((p ) & 0x1f) * rs;
		3499	rgba[i][gDst] = ((p >> 5) & 0x1f) * gs;
		3500	rgba[i][bDst] = ((p >> 10) & 0x1f) * bs;
		3501	rgba[i][aDst] = ((p >> 15) ) * as;
		3502	}
		3503	}
		3504	break;
		3505	case GL_UNSIGNED_INT_8_8_8_8:
		3506	if (swapBytes) {
		3507	const GLuint uisrc = (const GLuint ) src;
		3508	GLuint i;
		3509	if (intFormat) {
		3510	for (i = 0; i < n; i ++) {
		3511	GLuint p = uisrc[i];
		3512	rgba[i][rDst] = (GLfloat) ((p ) & 0xff);
		3513	rgba[i][gDst] = (GLfloat) ((p >> 8) & 0xff);
		3514	rgba[i][bDst] = (GLfloat) ((p >> 16) & 0xff);
		3515	rgba[i][aDst] = (GLfloat) ((p >> 24) );
		3516	}
		3517	}
		3518	else {
		3519	for (i = 0; i < n; i ++) {
		3520	GLuint p = uisrc[i];
		3521	rgba[i][rDst] = UBYTE_TO_FLOAT((p ) & 0xff);
		3522	rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
		3523	rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
		3524	rgba[i][aDst] = UBYTE_TO_FLOAT((p >> 24) );
		3525	}
		3526	}
		3527	}
		3528	else {
		3529	const GLuint uisrc = (const GLuint ) src;
		3530	GLuint i;
		3531	if (intFormat) {
		3532	for (i = 0; i < n; i ++) {
		3533	GLuint p = uisrc[i];
		3534	rgba[i][rDst] = (GLfloat) ((p >> 24) );
		3535	rgba[i][gDst] = (GLfloat) ((p >> 16) & 0xff);
		3536	rgba[i][bDst] = (GLfloat) ((p >> 8) & 0xff);
		3537	rgba[i][aDst] = (GLfloat) ((p ) & 0xff);
		3538	}
		3539	}
		3540	else {
		3541	for (i = 0; i < n; i ++) {
		3542	GLuint p = uisrc[i];
		3543	rgba[i][rDst] = UBYTE_TO_FLOAT((p >> 24) );
		3544	rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
		3545	rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
		3546	rgba[i][aDst] = UBYTE_TO_FLOAT((p ) & 0xff);
		3547	}
		3548	}
		3549	}
		3550	break;
		3551	case GL_UNSIGNED_INT_8_8_8_8_REV:
		3552	if (swapBytes) {
		3553	const GLuint uisrc = (const GLuint ) src;
		3554	GLuint i;
		3555	if (intFormat) {
		3556	for (i = 0; i < n; i ++) {
		3557	GLuint p = uisrc[i];
		3558	rgba[i][rDst] = (GLfloat) ((p >> 24) );
		3559	rgba[i][gDst] = (GLfloat) ((p >> 16) & 0xff);
		3560	rgba[i][bDst] = (GLfloat) ((p >> 8) & 0xff);
		3561	rgba[i][aDst] = (GLfloat) ((p ) & 0xff);
		3562	}
		3563	}
		3564	else {
		3565	for (i = 0; i < n; i ++) {
		3566	GLuint p = uisrc[i];
		3567	rgba[i][rDst] = UBYTE_TO_FLOAT((p >> 24) );
		3568	rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
		3569	rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
		3570	rgba[i][aDst] = UBYTE_TO_FLOAT((p ) & 0xff);
		3571	}
		3572	}
		3573	}
		3574	else {
		3575	const GLuint uisrc = (const GLuint ) src;
		3576	GLuint i;
		3577	if (intFormat) {
		3578	for (i = 0; i < n; i ++) {
		3579	GLuint p = uisrc[i];
		3580	rgba[i][rDst] = (GLfloat) ((p ) & 0xff);
		3581	rgba[i][gDst] = (GLfloat) ((p >> 8) & 0xff);
		3582	rgba[i][bDst] = (GLfloat) ((p >> 16) & 0xff);
		3583	rgba[i][aDst] = (GLfloat) ((p >> 24) );
		3584	}
		3585	}
		3586	else {
		3587	for (i = 0; i < n; i ++) {
		3588	GLuint p = uisrc[i];
		3589	rgba[i][rDst] = UBYTE_TO_FLOAT((p ) & 0xff);
		3590	rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 8) & 0xff);
		3591	rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
		3592	rgba[i][aDst] = UBYTE_TO_FLOAT((p >> 24) );
		3593	}
		3594	}
		3595	}
		3596	break;
		3597	case GL_UNSIGNED_INT_10_10_10_2:
		3598	if (!intFormat) {
		3599	rs = 1.0F / 1023.0F;
		3600	gs = 1.0F / 1023.0F;
		3601	bs = 1.0F / 1023.0F;
		3602	as = 1.0F / 3.0F;
		3603	}
		3604	if (swapBytes) {
		3605	const GLuint uisrc = (const GLuint ) src;
		3606	GLuint i;
		3607	for (i = 0; i < n; i ++) {
		3608	GLuint p = uisrc[i];
		3609	SWAP4BYTE(p);
		3610	rgba[i][rDst] = ((p >> 22) ) * rs;
		3611	rgba[i][gDst] = ((p >> 12) & 0x3ff) * gs;
		3612	rgba[i][bDst] = ((p >> 2) & 0x3ff) * bs;
		3613	rgba[i][aDst] = ((p ) & 0x3 ) * as;
		3614	}
		3615	}
		3616	else {
		3617	const GLuint uisrc = (const GLuint ) src;
		3618	GLuint i;
		3619	for (i = 0; i < n; i ++) {
		3620	GLuint p = uisrc[i];
		3621	rgba[i][rDst] = ((p >> 22) ) * rs;
		3622	rgba[i][gDst] = ((p >> 12) & 0x3ff) * gs;
		3623	rgba[i][bDst] = ((p >> 2) & 0x3ff) * bs;
		3624	rgba[i][aDst] = ((p ) & 0x3 ) * as;
		3625	}
		3626	}
		3627	break;
		3628	case GL_UNSIGNED_INT_2_10_10_10_REV:
		3629	if (!intFormat) {
		3630	rs = 1.0F / 1023.0F;
		3631	gs = 1.0F / 1023.0F;
		3632	bs = 1.0F / 1023.0F;
		3633	as = 1.0F / 3.0F;
		3634	}
		3635	if (swapBytes) {
		3636	const GLuint uisrc = (const GLuint ) src;
		3637	GLuint i;
		3638	for (i = 0; i < n; i ++) {
		3639	GLuint p = uisrc[i];
		3640	SWAP4BYTE(p);
		3641	rgba[i][rDst] = ((p ) & 0x3ff) * rs;
		3642	rgba[i][gDst] = ((p >> 10) & 0x3ff) * gs;
		3643	rgba[i][bDst] = ((p >> 20) & 0x3ff) * bs;
		3644	if (aSrc < 0) {
		3645	rgba[i][aDst] = 1.0F;
		3646	} else {
		3647	rgba[i][aDst] = (p >> 30) * as;
		3648	}
		3649	}
		3650	}
		3651	else {
		3652	const GLuint uisrc = (const GLuint ) src;
		3653	GLuint i;
		3654	for (i = 0; i < n; i ++) {
		3655	GLuint p = uisrc[i];
		3656	rgba[i][rDst] = ((p ) & 0x3ff) * rs;
		3657	rgba[i][gDst] = ((p >> 10) & 0x3ff) * gs;
		3658	rgba[i][bDst] = ((p >> 20) & 0x3ff) * bs;
		3659	if (aSrc < 0) {
		3660	rgba[i][aDst] = 1.0F;
		3661	} else {
		3662	rgba[i][aDst] = (p >> 30) * as;
		3663	}
		3664	}
		3665	}
		3666	break;
		3667	case GL_UNSIGNED_INT_5_9_9_9_REV:
		3668	if (swapBytes) {
		3669	const GLuint uisrc = (const GLuint ) src;
		3670	GLuint i;
		3671	GLfloat f[3];
		3672	for (i = 0; i < n; i ++) {
		3673	GLuint p = uisrc[i];
		3674	SWAP4BYTE(p);
		3675	rgb9e5_to_float3(p, f);
		3676	rgba[i][rDst] = f[0];
		3677	rgba[i][gDst] = f[1];
		3678	rgba[i][bDst] = f[2];
		3679	rgba[i][aDst] = 1.0F;
		3680	}
		3681	}
		3682	else {
		3683	const GLuint uisrc = (const GLuint ) src;
		3684	GLuint i;
		3685	GLfloat f[3];
		3686	for (i = 0; i < n; i ++) {
		3687	rgb9e5_to_float3(uisrc[i], f);
		3688	rgba[i][rDst] = f[0];
		3689	rgba[i][gDst] = f[1];
		3690	rgba[i][bDst] = f[2];
		3691	rgba[i][aDst] = 1.0F;
		3692	}
		3693	}
		3694	break;
		3695	case GL_UNSIGNED_INT_10F_11F_11F_REV:
		3696	if (swapBytes) {
		3697	const GLuint uisrc = (const GLuint ) src;
		3698	GLuint i;
		3699	GLfloat f[3];
		3700	for (i = 0; i < n; i ++) {
		3701	GLuint p = uisrc[i];
		3702	SWAP4BYTE(p);
		3703	r11g11b10f_to_float3(p, f);
		3704	rgba[i][rDst] = f[0];
		3705	rgba[i][gDst] = f[1];
		3706	rgba[i][bDst] = f[2];
		3707	rgba[i][aDst] = 1.0F;
		3708	}
		3709	}
		3710	else {
		3711	const GLuint uisrc = (const GLuint ) src;
		3712	GLuint i;
		3713	GLfloat f[3];
		3714	for (i = 0; i < n; i ++) {
		3715	r11g11b10f_to_float3(uisrc[i], f);
		3716	rgba[i][rDst] = f[0];
		3717	rgba[i][gDst] = f[1];
		3718	rgba[i][bDst] = f[2];
		3719	rgba[i][aDst] = 1.0F;
		3720	}
		3721	}
		3722	break;
		3723	default:
		3724	_mesa_problem(NULL, "bad srcType in extract float data");
		3725	break;
		3726	}
		3727	#undef PROCESS
		3728	}
		3729
		3730
		3731	static inline GLuint
		3732	clamp_float_to_uint(GLfloat f)
		3733	{
		3734	return f < 0.0F ? 0 : F_TO_I(f);
		3735	}
		3736
		3737
		3738	static inline GLuint
		3739	clamp_half_to_uint(GLhalfARB h)
		3740	{
		3741	GLfloat f = _mesa_half_to_float(h);
		3742	return f < 0.0F ? 0 : F_TO_I(f);
		3743	}
		3744
		3745
		3746	/**
		3747	* \sa extract_float_rgba()
		3748	*/
		3749	static void
		3750	extract_uint_rgba(GLuint n, GLuint rgba[][4],
		3751	GLenum srcFormat, GLenum srcType, const GLvoid *src,
		3752	GLboolean swapBytes)
		3753	{
		3754	GLint rSrc, gSrc, bSrc, aSrc;
		3755	GLint stride;
		3756	GLint rDst, bDst, gDst, aDst;
		3757
		3758	ASSERT(srcFormat == GL_RED \|\|
		3759	srcFormat == GL_GREEN \|\|
		3760	srcFormat == GL_BLUE \|\|
		3761	srcFormat == GL_ALPHA \|\|
		3762	srcFormat == GL_LUMINANCE \|\|
		3763	srcFormat == GL_LUMINANCE_ALPHA \|\|
		3764	srcFormat == GL_INTENSITY \|\|
		3765	srcFormat == GL_RG \|\|
		3766	srcFormat == GL_RGB \|\|
		3767	srcFormat == GL_BGR \|\|
		3768	srcFormat == GL_RGBA \|\|
		3769	srcFormat == GL_BGRA \|\|
		3770	srcFormat == GL_ABGR_EXT \|\|
		3771	srcFormat == GL_DU8DV8_ATI \|\|
		3772	srcFormat == GL_DUDV_ATI \|\|
		3773	srcFormat == GL_RED_INTEGER_EXT \|\|
		3774	srcFormat == GL_RG_INTEGER \|\|
		3775	srcFormat == GL_GREEN_INTEGER_EXT \|\|
		3776	srcFormat == GL_BLUE_INTEGER_EXT \|\|
		3777	srcFormat == GL_ALPHA_INTEGER_EXT \|\|
		3778	srcFormat == GL_RGB_INTEGER_EXT \|\|
		3779	srcFormat == GL_RGBA_INTEGER_EXT \|\|
		3780	srcFormat == GL_BGR_INTEGER_EXT \|\|
		3781	srcFormat == GL_BGRA_INTEGER_EXT \|\|
		3782	srcFormat == GL_LUMINANCE_INTEGER_EXT \|\|
		3783	srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT);
		3784
		3785	ASSERT(srcType == GL_UNSIGNED_BYTE \|\|
		3786	srcType == GL_BYTE \|\|
		3787	srcType == GL_UNSIGNED_SHORT \|\|
		3788	srcType == GL_SHORT \|\|
		3789	srcType == GL_UNSIGNED_INT \|\|
		3790	srcType == GL_INT \|\|
		3791	srcType == GL_HALF_FLOAT_ARB \|\|
		3792	srcType == GL_FLOAT \|\|
		3793	srcType == GL_UNSIGNED_BYTE_3_3_2 \|\|
		3794	srcType == GL_UNSIGNED_BYTE_2_3_3_REV \|\|
		3795	srcType == GL_UNSIGNED_SHORT_5_6_5 \|\|
		3796	srcType == GL_UNSIGNED_SHORT_5_6_5_REV \|\|
		3797	srcType == GL_UNSIGNED_SHORT_4_4_4_4 \|\|
		3798	srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV \|\|
		3799	srcType == GL_UNSIGNED_SHORT_5_5_5_1 \|\|
		3800	srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV \|\|
		3801	srcType == GL_UNSIGNED_INT_8_8_8_8 \|\|
		3802	srcType == GL_UNSIGNED_INT_8_8_8_8_REV \|\|
		3803	srcType == GL_UNSIGNED_INT_10_10_10_2 \|\|
		3804	srcType == GL_UNSIGNED_INT_2_10_10_10_REV \|\|
		3805	srcType == GL_UNSIGNED_INT_5_9_9_9_REV \|\|
		3806	srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
		3807
		3808	get_component_mapping(srcFormat,
		3809	&rSrc, &gSrc, &bSrc, &aSrc,
		3810	&rDst, &gDst, &bDst, &aDst);
		3811
		3812	stride = _mesa_components_in_format(srcFormat);
		3813
		3814	#define PROCESS(SRC_INDEX, DST_INDEX, DEFAULT, TYPE, CONVERSION) \
		3815	if ((SRC_INDEX) < 0) { \
		3816	GLuint i; \
		3817	for (i = 0; i < n; i++) { \
		3818	rgba[i][DST_INDEX] = DEFAULT; \
		3819	} \
		3820	} \
		3821	else if (swapBytes) { \
		3822	const TYPE s = (const TYPE ) src; \
		3823	GLuint i; \
		3824	for (i = 0; i < n; i++) { \
		3825	TYPE value = s[SRC_INDEX]; \
		3826	if (sizeof(TYPE) == 2) { \
		3827	SWAP2BYTE(value); \
		3828	} \
		3829	else if (sizeof(TYPE) == 4) { \
		3830	SWAP4BYTE(value); \
		3831	} \
		3832	rgba[i][DST_INDEX] = CONVERSION(value); \
		3833	s += stride; \
		3834	} \
		3835	} \
		3836	else { \
		3837	const TYPE s = (const TYPE ) src; \
		3838	GLuint i; \
		3839	for (i = 0; i < n; i++) { \
		3840	rgba[i][DST_INDEX] = CONVERSION(s[SRC_INDEX]); \
		3841	s += stride; \
		3842	} \
		3843	}
		3844
		3845	switch (srcType) {
		3846	case GL_UNSIGNED_BYTE:
		3847	PROCESS(rSrc, RCOMP, 0, GLubyte, (GLuint));
		3848	PROCESS(gSrc, GCOMP, 0, GLubyte, (GLuint));
		3849	PROCESS(bSrc, BCOMP, 0, GLubyte, (GLuint));
		3850	PROCESS(aSrc, ACOMP, 1, GLubyte, (GLuint));
		3851	break;
		3852	case GL_BYTE:
		3853	PROCESS(rSrc, RCOMP, 0, GLbyte, (GLuint));
		3854	PROCESS(gSrc, GCOMP, 0, GLbyte, (GLuint));
		3855	PROCESS(bSrc, BCOMP, 0, GLbyte, (GLuint));
		3856	PROCESS(aSrc, ACOMP, 1, GLbyte, (GLuint));
		3857	break;
		3858	case GL_UNSIGNED_SHORT:
		3859	PROCESS(rSrc, RCOMP, 0, GLushort, (GLuint));
		3860	PROCESS(gSrc, GCOMP, 0, GLushort, (GLuint));
		3861	PROCESS(bSrc, BCOMP, 0, GLushort, (GLuint));
		3862	PROCESS(aSrc, ACOMP, 1, GLushort, (GLuint));
		3863	break;
		3864	case GL_SHORT:
		3865	PROCESS(rSrc, RCOMP, 0, GLshort, (GLuint));
		3866	PROCESS(gSrc, GCOMP, 0, GLshort, (GLuint));
		3867	PROCESS(bSrc, BCOMP, 0, GLshort, (GLuint));
		3868	PROCESS(aSrc, ACOMP, 1, GLshort, (GLuint));
		3869	break;
		3870	case GL_UNSIGNED_INT:
		3871	PROCESS(rSrc, RCOMP, 0, GLuint, (GLuint));
		3872	PROCESS(gSrc, GCOMP, 0, GLuint, (GLuint));
		3873	PROCESS(bSrc, BCOMP, 0, GLuint, (GLuint));
		3874	PROCESS(aSrc, ACOMP, 1, GLuint, (GLuint));
		3875	break;
		3876	case GL_INT:
		3877	PROCESS(rSrc, RCOMP, 0, GLint, (GLuint));
		3878	PROCESS(gSrc, GCOMP, 0, GLint, (GLuint));
		3879	PROCESS(bSrc, BCOMP, 0, GLint, (GLuint));
		3880	PROCESS(aSrc, ACOMP, 1, GLint, (GLuint));
		3881	break;
		3882	case GL_FLOAT:
		3883	PROCESS(rSrc, RCOMP, 0, GLfloat, clamp_float_to_uint);
		3884	PROCESS(gSrc, GCOMP, 0, GLfloat, clamp_float_to_uint);
		3885	PROCESS(bSrc, BCOMP, 0, GLfloat, clamp_float_to_uint);
		3886	PROCESS(aSrc, ACOMP, 1, GLfloat, clamp_float_to_uint);
		3887	break;
		3888	case GL_HALF_FLOAT_ARB:
		3889	PROCESS(rSrc, RCOMP, 0, GLhalfARB, clamp_half_to_uint);
		3890	PROCESS(gSrc, GCOMP, 0, GLhalfARB, clamp_half_to_uint);
		3891	PROCESS(bSrc, BCOMP, 0, GLhalfARB, clamp_half_to_uint);
		3892	PROCESS(aSrc, ACOMP, 1, GLhalfARB, clamp_half_to_uint);
		3893	break;
		3894	case GL_UNSIGNED_BYTE_3_3_2:
		3895	{
		3896	const GLubyte ubsrc = (const GLubyte ) src;
		3897	GLuint i;
		3898	for (i = 0; i < n; i ++) {
		3899	GLubyte p = ubsrc[i];
		3900	rgba[i][rDst] = ((p >> 5) );
		3901	rgba[i][gDst] = ((p >> 2) & 0x7);
		3902	rgba[i][bDst] = ((p ) & 0x3);
		3903	rgba[i][aDst] = 1;
		3904	}
		3905	}
		3906	break;
		3907	case GL_UNSIGNED_BYTE_2_3_3_REV:
		3908	{
		3909	const GLubyte ubsrc = (const GLubyte ) src;
		3910	GLuint i;
		3911	for (i = 0; i < n; i ++) {
		3912	GLubyte p = ubsrc[i];
		3913	rgba[i][rDst] = ((p ) & 0x7);
		3914	rgba[i][gDst] = ((p >> 3) & 0x7);
		3915	rgba[i][bDst] = ((p >> 6) );
		3916	rgba[i][aDst] = 1;
		3917	}
		3918	}
		3919	break;
		3920	case GL_UNSIGNED_SHORT_5_6_5:
		3921	if (swapBytes) {
		3922	const GLushort ussrc = (const GLushort ) src;
		3923	GLuint i;
		3924	for (i = 0; i < n; i ++) {
		3925	GLushort p = ussrc[i];
		3926	SWAP2BYTE(p);
		3927	rgba[i][rDst] = ((p >> 11) );
		3928	rgba[i][gDst] = ((p >> 5) & 0x3f);
		3929	rgba[i][bDst] = ((p ) & 0x1f);
		3930	rgba[i][aDst] = 1;
		3931	}
		3932	}
		3933	else {
		3934	const GLushort ussrc = (const GLushort ) src;
		3935	GLuint i;
		3936	for (i = 0; i < n; i ++) {
		3937	GLushort p = ussrc[i];
		3938	rgba[i][rDst] = ((p >> 11) );
		3939	rgba[i][gDst] = ((p >> 5) & 0x3f);
		3940	rgba[i][bDst] = ((p ) & 0x1f);
		3941	rgba[i][aDst] = 1;
		3942	}
		3943	}
		3944	break;
		3945	case GL_UNSIGNED_SHORT_5_6_5_REV:
		3946	if (swapBytes) {
		3947	const GLushort ussrc = (const GLushort ) src;
		3948	GLuint i;
		3949	for (i = 0; i < n; i ++) {
		3950	GLushort p = ussrc[i];
		3951	SWAP2BYTE(p);
		3952	rgba[i][rDst] = ((p ) & 0x1f);
		3953	rgba[i][gDst] = ((p >> 5) & 0x3f);
		3954	rgba[i][bDst] = ((p >> 11) );
		3955	rgba[i][aDst] = 1;
		3956	}
		3957	}
		3958	else {
		3959	const GLushort ussrc = (const GLushort ) src;
		3960	GLuint i;
		3961	for (i = 0; i < n; i ++) {
		3962	GLushort p = ussrc[i];
		3963	rgba[i][rDst] = ((p ) & 0x1f);
		3964	rgba[i][gDst] = ((p >> 5) & 0x3f);
		3965	rgba[i][bDst] = ((p >> 11) );
		3966	rgba[i][aDst] = 1;
		3967	}
		3968	}
		3969	break;
		3970	case GL_UNSIGNED_SHORT_4_4_4_4:
		3971	if (swapBytes) {
		3972	const GLushort ussrc = (const GLushort ) src;
		3973	GLuint i;
		3974	for (i = 0; i < n; i ++) {
		3975	GLushort p = ussrc[i];
		3976	SWAP2BYTE(p);
		3977	rgba[i][rDst] = ((p >> 12) );
		3978	rgba[i][gDst] = ((p >> 8) & 0xf);
		3979	rgba[i][bDst] = ((p >> 4) & 0xf);
		3980	rgba[i][aDst] = ((p ) & 0xf);
		3981	}
		3982	}
		3983	else {
		3984	const GLushort ussrc = (const GLushort ) src;
		3985	GLuint i;
		3986	for (i = 0; i < n; i ++) {
		3987	GLushort p = ussrc[i];
		3988	rgba[i][rDst] = ((p >> 12) );
		3989	rgba[i][gDst] = ((p >> 8) & 0xf);
		3990	rgba[i][bDst] = ((p >> 4) & 0xf);
		3991	rgba[i][aDst] = ((p ) & 0xf);
		3992	}
		3993	}
		3994	break;
		3995	case GL_UNSIGNED_SHORT_4_4_4_4_REV:
		3996	if (swapBytes) {
		3997	const GLushort ussrc = (const GLushort ) src;
		3998	GLuint i;
		3999	for (i = 0; i < n; i ++) {
		4000	GLushort p = ussrc[i];
		4001	SWAP2BYTE(p);
		4002	rgba[i][rDst] = ((p ) & 0xf);
		4003	rgba[i][gDst] = ((p >> 4) & 0xf);
		4004	rgba[i][bDst] = ((p >> 8) & 0xf);
		4005	rgba[i][aDst] = ((p >> 12) );
		4006	}
		4007	}
		4008	else {
		4009	const GLushort ussrc = (const GLushort ) src;
		4010	GLuint i;
		4011	for (i = 0; i < n; i ++) {
		4012	GLushort p = ussrc[i];
		4013	rgba[i][rDst] = ((p ) & 0xf);
		4014	rgba[i][gDst] = ((p >> 4) & 0xf);
		4015	rgba[i][bDst] = ((p >> 8) & 0xf);
		4016	rgba[i][aDst] = ((p >> 12) );
		4017	}
		4018	}
		4019	break;
		4020	case GL_UNSIGNED_SHORT_5_5_5_1:
		4021	if (swapBytes) {
		4022	const GLushort ussrc = (const GLushort ) src;
		4023	GLuint i;
		4024	for (i = 0; i < n; i ++) {
		4025	GLushort p = ussrc[i];
		4026	SWAP2BYTE(p);
		4027	rgba[i][rDst] = ((p >> 11) );
		4028	rgba[i][gDst] = ((p >> 6) & 0x1f);
		4029	rgba[i][bDst] = ((p >> 1) & 0x1f);
		4030	rgba[i][aDst] = ((p ) & 0x1 );
		4031	}
		4032	}
		4033	else {
		4034	const GLushort ussrc = (const GLushort ) src;
		4035	GLuint i;
		4036	for (i = 0; i < n; i ++) {
		4037	GLushort p = ussrc[i];
		4038	rgba[i][rDst] = ((p >> 11) );
		4039	rgba[i][gDst] = ((p >> 6) & 0x1f);
		4040	rgba[i][bDst] = ((p >> 1) & 0x1f);
		4041	rgba[i][aDst] = ((p ) & 0x1 );
		4042	}
		4043	}
		4044	break;
		4045	case GL_UNSIGNED_SHORT_1_5_5_5_REV:
		4046	if (swapBytes) {
		4047	const GLushort ussrc = (const GLushort ) src;
		4048	GLuint i;
		4049	for (i = 0; i < n; i ++) {
		4050	GLushort p = ussrc[i];
		4051	SWAP2BYTE(p);
		4052	rgba[i][rDst] = ((p ) & 0x1f);
		4053	rgba[i][gDst] = ((p >> 5) & 0x1f);
		4054	rgba[i][bDst] = ((p >> 10) & 0x1f);
		4055	rgba[i][aDst] = ((p >> 15) );
		4056	}
		4057	}
		4058	else {
		4059	const GLushort ussrc = (const GLushort ) src;
		4060	GLuint i;
		4061	for (i = 0; i < n; i ++) {
		4062	GLushort p = ussrc[i];
		4063	rgba[i][rDst] = ((p ) & 0x1f);
		4064	rgba[i][gDst] = ((p >> 5) & 0x1f);
		4065	rgba[i][bDst] = ((p >> 10) & 0x1f);
		4066	rgba[i][aDst] = ((p >> 15) );
		4067	}
		4068	}
		4069	break;
		4070	case GL_UNSIGNED_INT_8_8_8_8:
		4071	if (swapBytes) {
		4072	const GLuint uisrc = (const GLuint ) src;
		4073	GLuint i;
		4074	for (i = 0; i < n; i ++) {
		4075	GLuint p = uisrc[i];
		4076	rgba[i][rDst] = ((p ) & 0xff);
		4077	rgba[i][gDst] = ((p >> 8) & 0xff);
		4078	rgba[i][bDst] = ((p >> 16) & 0xff);
		4079	rgba[i][aDst] = ((p >> 24) );
		4080	}
		4081	}
		4082	else {
		4083	const GLuint uisrc = (const GLuint ) src;
		4084	GLuint i;
		4085	for (i = 0; i < n; i ++) {
		4086	GLuint p = uisrc[i];
		4087	rgba[i][rDst] = ((p >> 24) );
		4088	rgba[i][gDst] = ((p >> 16) & 0xff);
		4089	rgba[i][bDst] = ((p >> 8) & 0xff);
		4090	rgba[i][aDst] = ((p ) & 0xff);
		4091	}
		4092	}
		4093	break;
		4094	case GL_UNSIGNED_INT_8_8_8_8_REV:
		4095	if (swapBytes) {
		4096	const GLuint uisrc = (const GLuint ) src;
		4097	GLuint i;
		4098	for (i = 0; i < n; i ++) {
		4099	GLuint p = uisrc[i];
		4100	rgba[i][rDst] = ((p >> 24) );
		4101	rgba[i][gDst] = ((p >> 16) & 0xff);
		4102	rgba[i][bDst] = ((p >> 8) & 0xff);
		4103	rgba[i][aDst] = ((p ) & 0xff);
		4104	}
		4105	}
		4106	else {
		4107	const GLuint uisrc = (const GLuint ) src;
		4108	GLuint i;
		4109	for (i = 0; i < n; i ++) {
		4110	GLuint p = uisrc[i];
		4111	rgba[i][rDst] = ((p ) & 0xff);
		4112	rgba[i][gDst] = ((p >> 8) & 0xff);
		4113	rgba[i][bDst] = ((p >> 16) & 0xff);
		4114	rgba[i][aDst] = ((p >> 24) );
		4115	}
		4116	}
		4117	break;
		4118	case GL_UNSIGNED_INT_10_10_10_2:
		4119	if (swapBytes) {
		4120	const GLuint uisrc = (const GLuint ) src;
		4121	GLuint i;
		4122	for (i = 0; i < n; i ++) {
		4123	GLuint p = uisrc[i];
		4124	SWAP4BYTE(p);
		4125	rgba[i][rDst] = ((p >> 22) );
		4126	rgba[i][gDst] = ((p >> 12) & 0x3ff);
		4127	rgba[i][bDst] = ((p >> 2) & 0x3ff);
		4128	rgba[i][aDst] = ((p ) & 0x3 );
		4129	}
		4130	}
		4131	else {
		4132	const GLuint uisrc = (const GLuint ) src;
		4133	GLuint i;
		4134	for (i = 0; i < n; i ++) {
		4135	GLuint p = uisrc[i];
		4136	rgba[i][rDst] = ((p >> 22) );
		4137	rgba[i][gDst] = ((p >> 12) & 0x3ff);
		4138	rgba[i][bDst] = ((p >> 2) & 0x3ff);
		4139	rgba[i][aDst] = ((p ) & 0x3 );
		4140	}
		4141	}
		4142	break;
		4143	case GL_UNSIGNED_INT_2_10_10_10_REV:
		4144	if (swapBytes) {
		4145	const GLuint uisrc = (const GLuint ) src;
		4146	GLuint i;
		4147	for (i = 0; i < n; i ++) {
		4148	GLuint p = uisrc[i];
		4149	SWAP4BYTE(p);
		4150	rgba[i][rDst] = ((p ) & 0x3ff);
		4151	rgba[i][gDst] = ((p >> 10) & 0x3ff);
		4152	rgba[i][bDst] = ((p >> 20) & 0x3ff);
		4153	rgba[i][aDst] = ((p >> 30) );
		4154	}
		4155	}
		4156	else {
		4157	const GLuint uisrc = (const GLuint ) src;
		4158	GLuint i;
		4159	for (i = 0; i < n; i ++) {
		4160	GLuint p = uisrc[i];
		4161	rgba[i][rDst] = ((p ) & 0x3ff);
		4162	rgba[i][gDst] = ((p >> 10) & 0x3ff);
		4163	rgba[i][bDst] = ((p >> 20) & 0x3ff);
		4164	rgba[i][aDst] = ((p >> 30) );
		4165	}
		4166	}
		4167	break;
		4168	case GL_UNSIGNED_INT_5_9_9_9_REV:
		4169	if (swapBytes) {
		4170	const GLuint uisrc = (const GLuint ) src;
		4171	GLuint i;
		4172	float f[3];
		4173	for (i = 0; i < n; i ++) {
		4174	GLuint p = uisrc[i];
		4175	SWAP4BYTE(p);
		4176	rgb9e5_to_float3(p, f);
		4177	rgba[i][rDst] = clamp_float_to_uint(f[0]);
		4178	rgba[i][gDst] = clamp_float_to_uint(f[1]);
		4179	rgba[i][bDst] = clamp_float_to_uint(f[2]);
		4180	rgba[i][aDst] = 1;
		4181	}
		4182	}
		4183	else {
		4184	const GLuint uisrc = (const GLuint ) src;
		4185	GLuint i;
		4186	float f[3];
		4187	for (i = 0; i < n; i ++) {
		4188	GLuint p = uisrc[i];
		4189	rgb9e5_to_float3(p, f);
		4190	rgba[i][rDst] = clamp_float_to_uint(f[0]);
		4191	rgba[i][gDst] = clamp_float_to_uint(f[1]);
		4192	rgba[i][bDst] = clamp_float_to_uint(f[2]);
		4193	rgba[i][aDst] = 1;
		4194	}
		4195	}
		4196	break;
		4197	case GL_UNSIGNED_INT_10F_11F_11F_REV:
		4198	if (swapBytes) {
		4199	const GLuint uisrc = (const GLuint ) src;
		4200	GLuint i;
		4201	float f[3];
		4202	for (i = 0; i < n; i ++) {
		4203	GLuint p = uisrc[i];
		4204	SWAP4BYTE(p);
		4205	r11g11b10f_to_float3(p, f);
		4206	rgba[i][rDst] = clamp_float_to_uint(f[0]);
		4207	rgba[i][gDst] = clamp_float_to_uint(f[1]);
		4208	rgba[i][bDst] = clamp_float_to_uint(f[2]);
		4209	rgba[i][aDst] = 1;
		4210	}
		4211	}
		4212	else {
		4213	const GLuint uisrc = (const GLuint ) src;
		4214	GLuint i;
		4215	float f[3];
		4216	for (i = 0; i < n; i ++) {
		4217	GLuint p = uisrc[i];
		4218	r11g11b10f_to_float3(p, f);
		4219	rgba[i][rDst] = clamp_float_to_uint(f[0]);
		4220	rgba[i][gDst] = clamp_float_to_uint(f[1]);
		4221	rgba[i][bDst] = clamp_float_to_uint(f[2]);
		4222	rgba[i][aDst] = 1;
		4223	}
		4224	}
		4225	break;
		4226	default:
		4227	_mesa_problem(NULL, "bad srcType in extract uint data");
		4228	break;
		4229	}
		4230	#undef PROCESS
		4231	}
		4232
		4233
		4234
		4235	/*
		4236	* Unpack a row of color image data from a client buffer according to
		4237	* the pixel unpacking parameters.
		4238	* Return GLubyte values in the specified dest image format.
		4239	* This is used by glDrawPixels and glTexImage?D().
		4240	* \param ctx - the context
		4241	* n - number of pixels in the span
		4242	* dstFormat - format of destination color array
		4243	* dest - the destination color array
		4244	* srcFormat - source image format
		4245	* srcType - source image data type
		4246	* source - source image pointer
		4247	* srcPacking - pixel unpacking parameters
		4248	* transferOps - bitmask of IMAGE_*_BIT values of operations to apply
		4249	*
		4250	* XXX perhaps expand this to process whole images someday.
		4251	*/
		4252	void
		4253	_mesa_unpack_color_span_ubyte(struct gl_context *ctx,
		4254	GLuint n, GLenum dstFormat, GLubyte dest[],
		4255	GLenum srcFormat, GLenum srcType,
		4256	const GLvoid *source,
		4257	const struct gl_pixelstore_attrib *srcPacking,
		4258	GLbitfield transferOps )
		4259	{
		4260	GLboolean intFormat = _mesa_is_enum_format_integer(srcFormat);
		4261	ASSERT(dstFormat == GL_ALPHA \|\|
		4262	dstFormat == GL_LUMINANCE \|\|
		4263	dstFormat == GL_LUMINANCE_ALPHA \|\|
		4264	dstFormat == GL_INTENSITY \|\|
		4265	dstFormat == GL_RED \|\|
		4266	dstFormat == GL_RG \|\|
		4267	dstFormat == GL_RGB \|\|
		4268	dstFormat == GL_RGBA);
		4269
		4270	ASSERT(srcFormat == GL_RED \|\|
		4271	srcFormat == GL_GREEN \|\|
		4272	srcFormat == GL_BLUE \|\|
		4273	srcFormat == GL_ALPHA \|\|
		4274	srcFormat == GL_LUMINANCE \|\|
		4275	srcFormat == GL_LUMINANCE_ALPHA \|\|
		4276	srcFormat == GL_INTENSITY \|\|
		4277	srcFormat == GL_RG \|\|
		4278	srcFormat == GL_RGB \|\|
		4279	srcFormat == GL_BGR \|\|
		4280	srcFormat == GL_RGBA \|\|
		4281	srcFormat == GL_BGRA \|\|
		4282	srcFormat == GL_ABGR_EXT \|\|
		4283	srcFormat == GL_COLOR_INDEX);
		4284
		4285	ASSERT(srcType == GL_BITMAP \|\|
		4286	srcType == GL_UNSIGNED_BYTE \|\|
		4287	srcType == GL_BYTE \|\|
		4288	srcType == GL_UNSIGNED_SHORT \|\|
		4289	srcType == GL_SHORT \|\|
		4290	srcType == GL_UNSIGNED_INT \|\|
		4291	srcType == GL_INT \|\|
		4292	srcType == GL_HALF_FLOAT_ARB \|\|
		4293	srcType == GL_FLOAT \|\|
		4294	srcType == GL_UNSIGNED_BYTE_3_3_2 \|\|
		4295	srcType == GL_UNSIGNED_BYTE_2_3_3_REV \|\|
		4296	srcType == GL_UNSIGNED_SHORT_5_6_5 \|\|
		4297	srcType == GL_UNSIGNED_SHORT_5_6_5_REV \|\|
		4298	srcType == GL_UNSIGNED_SHORT_4_4_4_4 \|\|
		4299	srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV \|\|
		4300	srcType == GL_UNSIGNED_SHORT_5_5_5_1 \|\|
		4301	srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV \|\|
		4302	srcType == GL_UNSIGNED_INT_8_8_8_8 \|\|
		4303	srcType == GL_UNSIGNED_INT_8_8_8_8_REV \|\|
		4304	srcType == GL_UNSIGNED_INT_10_10_10_2 \|\|
		4305	srcType == GL_UNSIGNED_INT_2_10_10_10_REV \|\|
		4306	srcType == GL_UNSIGNED_INT_5_9_9_9_REV \|\|
		4307	srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
		4308
		4309	/* EXT_texture_integer specifies no transfer ops on integer
		4310	* types in the resolved issues section. Just set them to 0
		4311	* for integer surfaces.
		4312	*/
		4313	if (intFormat)
		4314	transferOps = 0;
		4315
		4316	/* Try simple cases first */
		4317	if (transferOps == 0) {
		4318	if (srcType == GL_UNSIGNED_BYTE) {
		4319	if (dstFormat == GL_RGBA) {
		4320	if (srcFormat == GL_RGBA) {
		4321	memcpy( dest, source, n * 4 * sizeof(GLubyte) );
		4322	return;
		4323	}
		4324	else if (srcFormat == GL_RGB) {
		4325	GLuint i;
		4326	const GLubyte src = (const GLubyte ) source;
		4327	GLubyte *dst = dest;
		4328	for (i = 0; i < n; i++) {
		4329	dst[0] = src[0];
		4330	dst[1] = src[1];
		4331	dst[2] = src[2];
		4332	dst[3] = 255;
		4333	src += 3;
		4334	dst += 4;
		4335	}
		4336	return;
		4337	}
		4338	}
		4339	else if (dstFormat == GL_RGB) {
		4340	if (srcFormat == GL_RGB) {
		4341	memcpy( dest, source, n * 3 * sizeof(GLubyte) );
		4342	return;
		4343	}
		4344	else if (srcFormat == GL_RGBA) {
		4345	GLuint i;
		4346	const GLubyte src = (const GLubyte ) source;
		4347	GLubyte *dst = dest;
		4348	for (i = 0; i < n; i++) {
		4349	dst[0] = src[0];
		4350	dst[1] = src[1];
		4351	dst[2] = src[2];
		4352	src += 4;
		4353	dst += 3;
		4354	}
		4355	return;
		4356	}
		4357	}
		4358	else if (dstFormat == srcFormat) {
		4359	GLint comps = _mesa_components_in_format(srcFormat);
		4360	assert(comps > 0);
		4361	memcpy( dest, source, n * comps * sizeof(GLubyte) );
		4362	return;
		4363	}
		4364	}
		4365	}
		4366
		4367
		4368	/* general solution begins here */
		4369	{
		4370	GLint dstComponents;
		4371	GLint rDst, gDst, bDst, aDst, lDst, iDst;
		4372	GLfloat (rgba)[4] = malloc(4 n * sizeof(GLfloat));
		4373
		4374	if (!rgba) {
		4375	_mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
		4376	return;
		4377	}
		4378
		4379	dstComponents = _mesa_components_in_format( dstFormat );
		4380	/* source & dest image formats should have been error checked by now */
		4381	assert(dstComponents > 0);
		4382
		4383	/*
		4384	* Extract image data and convert to RGBA floats
		4385	*/
		4386	if (srcFormat == GL_COLOR_INDEX) {
		4387	GLuint indexes = malloc(n sizeof(GLuint));
		4388
		4389	if (!indexes) {
		4390	_mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
		4391	free(rgba);
		4392	return;
		4393	}
		4394
		4395	extract_uint_indexes(n, indexes, srcFormat, srcType, source,
		4396	srcPacking);
		4397
		4398	/* Convert indexes to RGBA */
		4399	if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
		4400	_mesa_shift_and_offset_ci(ctx, n, indexes);
		4401	}
		4402	_mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
		4403
		4404	/* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
		4405	* with color indexes.
		4406	*/
		4407	transferOps &= ~(IMAGE_SCALE_BIAS_BIT \| IMAGE_MAP_COLOR_BIT);
		4408
		4409	free(indexes);
		4410	}
		4411	else {
		4412	/* non-color index data */
		4413	extract_float_rgba(n, rgba, srcFormat, srcType, source,
		4414	srcPacking->SwapBytes);
		4415	}
		4416
		4417	/* Need to clamp if returning GLubytes */
		4418	transferOps \|= IMAGE_CLAMP_BIT;
		4419
		4420	if (transferOps) {
		4421	_mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
		4422	}
		4423
		4424	get_component_indexes(dstFormat,
		4425	&rDst, &gDst, &bDst, &aDst, &lDst, &iDst);
		4426
		4427	/* Now return the GLubyte data in the requested dstFormat */
		4428	if (rDst >= 0) {
		4429	GLubyte *dst = dest;
		4430	GLuint i;
		4431	for (i = 0; i < n; i++) {
		4432	CLAMPED_FLOAT_TO_UBYTE(dst[rDst], rgba[i][RCOMP]);
		4433	dst += dstComponents;
		4434	}
		4435	}
		4436
		4437	if (gDst >= 0) {
		4438	GLubyte *dst = dest;
		4439	GLuint i;
		4440	for (i = 0; i < n; i++) {
		4441	CLAMPED_FLOAT_TO_UBYTE(dst[gDst], rgba[i][GCOMP]);
		4442	dst += dstComponents;
		4443	}
		4444	}
		4445
		4446	if (bDst >= 0) {
		4447	GLubyte *dst = dest;
		4448	GLuint i;
		4449	for (i = 0; i < n; i++) {
		4450	CLAMPED_FLOAT_TO_UBYTE(dst[bDst], rgba[i][BCOMP]);
		4451	dst += dstComponents;
		4452	}
		4453	}
		4454
		4455	if (aDst >= 0) {
		4456	GLubyte *dst = dest;
		4457	GLuint i;
		4458	for (i = 0; i < n; i++) {
		4459	CLAMPED_FLOAT_TO_UBYTE(dst[aDst], rgba[i][ACOMP]);
		4460	dst += dstComponents;
		4461	}
		4462	}
		4463
		4464	if (iDst >= 0) {
		4465	GLubyte *dst = dest;
		4466	GLuint i;
		4467	assert(iDst == 0);
		4468	assert(dstComponents == 1);
		4469	for (i = 0; i < n; i++) {
		4470	/* Intensity comes from red channel */
		4471	CLAMPED_FLOAT_TO_UBYTE(dst[i], rgba[i][RCOMP]);
		4472	}
		4473	}
		4474
		4475	if (lDst >= 0) {
		4476	GLubyte *dst = dest;
		4477	GLuint i;
		4478	assert(lDst == 0);
		4479	for (i = 0; i < n; i++) {
		4480	/* Luminance comes from red channel */
		4481	CLAMPED_FLOAT_TO_UBYTE(dst[0], rgba[i][RCOMP]);
		4482	dst += dstComponents;
		4483	}
		4484	}
		4485
		4486	free(rgba);
		4487	}
		4488	}
		4489
		4490
		4491	/**
		4492	* Same as _mesa_unpack_color_span_ubyte(), but return GLfloat data
		4493	* instead of GLubyte.
		4494	*/
		4495	void
		4496	_mesa_unpack_color_span_float( struct gl_context *ctx,
		4497	GLuint n, GLenum dstFormat, GLfloat dest[],
		4498	GLenum srcFormat, GLenum srcType,
		4499	const GLvoid *source,
		4500	const struct gl_pixelstore_attrib *srcPacking,
		4501	GLbitfield transferOps )
		4502	{
		4503	ASSERT(dstFormat == GL_ALPHA \|\|
		4504	dstFormat == GL_LUMINANCE \|\|
		4505	dstFormat == GL_LUMINANCE_ALPHA \|\|
		4506	dstFormat == GL_INTENSITY \|\|
		4507	dstFormat == GL_RED \|\|
		4508	dstFormat == GL_RG \|\|
		4509	dstFormat == GL_RGB \|\|
		4510	dstFormat == GL_RGBA);
		4511
		4512	ASSERT(srcFormat == GL_RED \|\|
		4513	srcFormat == GL_GREEN \|\|
		4514	srcFormat == GL_BLUE \|\|
		4515	srcFormat == GL_ALPHA \|\|
		4516	srcFormat == GL_LUMINANCE \|\|
		4517	srcFormat == GL_LUMINANCE_ALPHA \|\|
		4518	srcFormat == GL_INTENSITY \|\|
		4519	srcFormat == GL_RG \|\|
		4520	srcFormat == GL_RGB \|\|
		4521	srcFormat == GL_BGR \|\|
		4522	srcFormat == GL_RGBA \|\|
		4523	srcFormat == GL_BGRA \|\|
		4524	srcFormat == GL_ABGR_EXT \|\|
		4525	srcFormat == GL_RED_INTEGER_EXT \|\|
		4526	srcFormat == GL_GREEN_INTEGER_EXT \|\|
		4527	srcFormat == GL_BLUE_INTEGER_EXT \|\|
		4528	srcFormat == GL_ALPHA_INTEGER_EXT \|\|
		4529	srcFormat == GL_RG_INTEGER \|\|
		4530	srcFormat == GL_RGB_INTEGER_EXT \|\|
		4531	srcFormat == GL_RGBA_INTEGER_EXT \|\|
		4532	srcFormat == GL_BGR_INTEGER_EXT \|\|
		4533	srcFormat == GL_BGRA_INTEGER_EXT \|\|
		4534	srcFormat == GL_LUMINANCE_INTEGER_EXT \|\|
		4535	srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT \|\|
		4536	srcFormat == GL_COLOR_INDEX);
		4537
		4538	ASSERT(srcType == GL_BITMAP \|\|
		4539	srcType == GL_UNSIGNED_BYTE \|\|
		4540	srcType == GL_BYTE \|\|
		4541	srcType == GL_UNSIGNED_SHORT \|\|
		4542	srcType == GL_SHORT \|\|
		4543	srcType == GL_UNSIGNED_INT \|\|
		4544	srcType == GL_INT \|\|
		4545	srcType == GL_HALF_FLOAT_ARB \|\|
		4546	srcType == GL_FLOAT \|\|
		4547	srcType == GL_UNSIGNED_BYTE_3_3_2 \|\|
		4548	srcType == GL_UNSIGNED_BYTE_2_3_3_REV \|\|
		4549	srcType == GL_UNSIGNED_SHORT_5_6_5 \|\|
		4550	srcType == GL_UNSIGNED_SHORT_5_6_5_REV \|\|
		4551	srcType == GL_UNSIGNED_SHORT_4_4_4_4 \|\|
		4552	srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV \|\|
		4553	srcType == GL_UNSIGNED_SHORT_5_5_5_1 \|\|
		4554	srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV \|\|
		4555	srcType == GL_UNSIGNED_INT_8_8_8_8 \|\|
		4556	srcType == GL_UNSIGNED_INT_8_8_8_8_REV \|\|
		4557	srcType == GL_UNSIGNED_INT_10_10_10_2 \|\|
		4558	srcType == GL_UNSIGNED_INT_2_10_10_10_REV \|\|
		4559	srcType == GL_UNSIGNED_INT_5_9_9_9_REV \|\|
		4560	srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
		4561
		4562	/* general solution, no special cases, yet */
		4563	{
		4564	GLint dstComponents;
		4565	GLint rDst, gDst, bDst, aDst, lDst, iDst;
		4566	GLfloat (rgba)[4] = malloc(4 n * sizeof(GLfloat));
		4567	GLboolean intFormat = _mesa_is_enum_format_integer(srcFormat);
		4568
		4569	if (!rgba) {
		4570	_mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
		4571	return;
		4572	}
		4573
		4574	dstComponents = _mesa_components_in_format( dstFormat );
		4575	/* source & dest image formats should have been error checked by now */
		4576	assert(dstComponents > 0);
		4577
		4578	/* EXT_texture_integer specifies no transfer ops on integer
		4579	* types in the resolved issues section. Just set them to 0
		4580	* for integer surfaces.
		4581	*/
		4582	if (intFormat)
		4583	transferOps = 0;
		4584
		4585	/*
		4586	* Extract image data and convert to RGBA floats
		4587	*/
		4588	if (srcFormat == GL_COLOR_INDEX) {
		4589	GLuint indexes = malloc(n sizeof(GLuint));
		4590
		4591	if (!indexes) {
		4592	_mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
		4593	free(rgba);
		4594	return;
		4595	}
		4596
		4597	extract_uint_indexes(n, indexes, srcFormat, srcType, source,
		4598	srcPacking);
		4599
		4600	/* Convert indexes to RGBA */
		4601	if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
		4602	_mesa_shift_and_offset_ci(ctx, n, indexes);
		4603	}
		4604	_mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
		4605
		4606	/* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
		4607	* with color indexes.
		4608	*/
		4609	transferOps &= ~(IMAGE_SCALE_BIAS_BIT \| IMAGE_MAP_COLOR_BIT);
		4610
		4611	free(indexes);
		4612	}
		4613	else {
		4614	/* non-color index data */
		4615	extract_float_rgba(n, rgba, srcFormat, srcType, source,
		4616	srcPacking->SwapBytes);
		4617	}
		4618
		4619	if (transferOps) {
		4620	_mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
		4621	}
		4622
		4623	get_component_indexes(dstFormat,
		4624	&rDst, &gDst, &bDst, &aDst, &lDst, &iDst);
		4625
		4626	/* Now pack results in the requested dstFormat */
		4627	if (rDst >= 0) {
		4628	GLfloat *dst = dest;
		4629	GLuint i;
		4630	for (i = 0; i < n; i++) {
		4631	dst[rDst] = rgba[i][RCOMP];
		4632	dst += dstComponents;
		4633	}
		4634	}
		4635
		4636	if (gDst >= 0) {
		4637	GLfloat *dst = dest;
		4638	GLuint i;
		4639	for (i = 0; i < n; i++) {
		4640	dst[gDst] = rgba[i][GCOMP];
		4641	dst += dstComponents;
		4642	}
		4643	}
		4644
		4645	if (bDst >= 0) {
		4646	GLfloat *dst = dest;
		4647	GLuint i;
		4648	for (i = 0; i < n; i++) {
		4649	dst[bDst] = rgba[i][BCOMP];
		4650	dst += dstComponents;
		4651	}
		4652	}
		4653
		4654	if (aDst >= 0) {
		4655	GLfloat *dst = dest;
		4656	GLuint i;
		4657	for (i = 0; i < n; i++) {
		4658	dst[aDst] = rgba[i][ACOMP];
		4659	dst += dstComponents;
		4660	}
		4661	}
		4662
		4663	if (iDst >= 0) {
		4664	GLfloat *dst = dest;
		4665	GLuint i;
		4666	assert(iDst == 0);
		4667	assert(dstComponents == 1);
		4668	for (i = 0; i < n; i++) {
		4669	/* Intensity comes from red channel */
		4670	dst[i] = rgba[i][RCOMP];
		4671	}
		4672	}
		4673
		4674	if (lDst >= 0) {
		4675	GLfloat *dst = dest;
		4676	GLuint i;
		4677	assert(lDst == 0);
		4678	for (i = 0; i < n; i++) {
		4679	/* Luminance comes from red channel */
		4680	dst[0] = rgba[i][RCOMP];
		4681	dst += dstComponents;
		4682	}
		4683	}
		4684
		4685	free(rgba);
		4686	}
		4687	}
		4688
		4689
		4690	/**
		4691	* Same as _mesa_unpack_color_span_ubyte(), but return GLuint data
		4692	* instead of GLubyte.
		4693	* No pixel transfer ops are applied.
		4694	*/
		4695	void
		4696	_mesa_unpack_color_span_uint(struct gl_context *ctx,
		4697	GLuint n, GLenum dstFormat, GLuint *dest,
		4698	GLenum srcFormat, GLenum srcType,
		4699	const GLvoid *source,
		4700	const struct gl_pixelstore_attrib *srcPacking)
		4701	{
		4702	GLuint (rgba)[4] = malloc(n 4 * sizeof(GLfloat));
		4703
		4704	if (!rgba) {
		4705	_mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
		4706	return;
		4707	}
		4708
		4709	ASSERT(dstFormat == GL_ALPHA \|\|
		4710	dstFormat == GL_LUMINANCE \|\|
		4711	dstFormat == GL_LUMINANCE_ALPHA \|\|
		4712	dstFormat == GL_INTENSITY \|\|
		4713	dstFormat == GL_RED \|\|
		4714	dstFormat == GL_RG \|\|
		4715	dstFormat == GL_RGB \|\|
		4716	dstFormat == GL_RGBA);
		4717
		4718	ASSERT(srcFormat == GL_RED \|\|
		4719	srcFormat == GL_GREEN \|\|
		4720	srcFormat == GL_BLUE \|\|
		4721	srcFormat == GL_ALPHA \|\|
		4722	srcFormat == GL_LUMINANCE \|\|
		4723	srcFormat == GL_LUMINANCE_ALPHA \|\|
		4724	srcFormat == GL_INTENSITY \|\|
		4725	srcFormat == GL_RG \|\|
		4726	srcFormat == GL_RGB \|\|
		4727	srcFormat == GL_BGR \|\|
		4728	srcFormat == GL_RGBA \|\|
		4729	srcFormat == GL_BGRA \|\|
		4730	srcFormat == GL_ABGR_EXT \|\|
		4731	srcFormat == GL_RED_INTEGER_EXT \|\|
		4732	srcFormat == GL_GREEN_INTEGER_EXT \|\|
		4733	srcFormat == GL_BLUE_INTEGER_EXT \|\|
		4734	srcFormat == GL_ALPHA_INTEGER_EXT \|\|
		4735	srcFormat == GL_RG_INTEGER \|\|
		4736	srcFormat == GL_RGB_INTEGER_EXT \|\|
		4737	srcFormat == GL_RGBA_INTEGER_EXT \|\|
		4738	srcFormat == GL_BGR_INTEGER_EXT \|\|
		4739	srcFormat == GL_BGRA_INTEGER_EXT \|\|
		4740	srcFormat == GL_LUMINANCE_INTEGER_EXT \|\|
		4741	srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT);
		4742
		4743	ASSERT(srcType == GL_UNSIGNED_BYTE \|\|
		4744	srcType == GL_BYTE \|\|
		4745	srcType == GL_UNSIGNED_SHORT \|\|
		4746	srcType == GL_SHORT \|\|
		4747	srcType == GL_UNSIGNED_INT \|\|
		4748	srcType == GL_INT \|\|
		4749	srcType == GL_HALF_FLOAT_ARB \|\|
		4750	srcType == GL_FLOAT \|\|
		4751	srcType == GL_UNSIGNED_BYTE_3_3_2 \|\|
		4752	srcType == GL_UNSIGNED_BYTE_2_3_3_REV \|\|
		4753	srcType == GL_UNSIGNED_SHORT_5_6_5 \|\|
		4754	srcType == GL_UNSIGNED_SHORT_5_6_5_REV \|\|
		4755	srcType == GL_UNSIGNED_SHORT_4_4_4_4 \|\|
		4756	srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV \|\|
		4757	srcType == GL_UNSIGNED_SHORT_5_5_5_1 \|\|
		4758	srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV \|\|
		4759	srcType == GL_UNSIGNED_INT_8_8_8_8 \|\|
		4760	srcType == GL_UNSIGNED_INT_8_8_8_8_REV \|\|
		4761	srcType == GL_UNSIGNED_INT_10_10_10_2 \|\|
		4762	srcType == GL_UNSIGNED_INT_2_10_10_10_REV \|\|
		4763	srcType == GL_UNSIGNED_INT_5_9_9_9_REV \|\|
		4764	srcType == GL_UNSIGNED_INT_10F_11F_11F_REV);
		4765
		4766
		4767	/* Extract image data as uint[4] pixels */
		4768	extract_uint_rgba(n, rgba, srcFormat, srcType, source,
		4769	srcPacking->SwapBytes);
		4770
		4771	if (dstFormat == GL_RGBA) {
		4772	/* simple case */
		4773	memcpy(dest, rgba, 4 * sizeof(GLuint) * n);
		4774	}
		4775	else {
		4776	/* general case */
		4777	GLint rDst, gDst, bDst, aDst, lDst, iDst;
		4778	GLint dstComponents = _mesa_components_in_format( dstFormat );
		4779
		4780	assert(dstComponents > 0);
		4781
		4782	get_component_indexes(dstFormat,
		4783	&rDst, &gDst, &bDst, &aDst, &lDst, &iDst);
		4784
		4785	/* Now pack values in the requested dest format */
		4786	if (rDst >= 0) {
		4787	GLuint *dst = dest;
		4788	GLuint i;
		4789	for (i = 0; i < n; i++) {
		4790	dst[rDst] = rgba[i][RCOMP];
		4791	dst += dstComponents;
		4792	}
		4793	}
		4794
		4795	if (gDst >= 0) {
		4796	GLuint *dst = dest;
		4797	GLuint i;
		4798	for (i = 0; i < n; i++) {
		4799	dst[gDst] = rgba[i][GCOMP];
		4800	dst += dstComponents;
		4801	}
		4802	}
		4803
		4804	if (bDst >= 0) {
		4805	GLuint *dst = dest;
		4806	GLuint i;
		4807	for (i = 0; i < n; i++) {
		4808	dst[bDst] = rgba[i][BCOMP];
		4809	dst += dstComponents;
		4810	}
		4811	}
		4812
		4813	if (aDst >= 0) {
		4814	GLuint *dst = dest;
		4815	GLuint i;
		4816	for (i = 0; i < n; i++) {
		4817	dst[aDst] = rgba[i][ACOMP];
		4818	dst += dstComponents;
		4819	}
		4820	}
		4821
		4822	if (iDst >= 0) {
		4823	GLuint *dst = dest;
		4824	GLuint i;
		4825	assert(iDst == 0);
		4826	assert(dstComponents == 1);
		4827	for (i = 0; i < n; i++) {
		4828	/* Intensity comes from red channel */
		4829	dst[i] = rgba[i][RCOMP];
		4830	}
		4831	}
		4832
		4833	if (lDst >= 0) {
		4834	GLuint *dst = dest;
		4835	GLuint i;
		4836	assert(lDst == 0);
		4837	for (i = 0; i < n; i++) {
		4838	/* Luminance comes from red channel */
		4839	dst[0] = rgba[i][RCOMP];
		4840	dst += dstComponents;
		4841	}
		4842	}
		4843	}
		4844
		4845	free(rgba);
		4846	}
		4847
		4848
		4849
		4850	/**
		4851	* Similar to _mesa_unpack_color_span_float(), but for dudv data instead of rgba,
		4852	* directly return GLbyte data, no transfer ops apply.
		4853	*/
		4854	void
		4855	_mesa_unpack_dudv_span_byte( struct gl_context *ctx,
		4856	GLuint n, GLenum dstFormat, GLbyte dest[],
		4857	GLenum srcFormat, GLenum srcType,
		4858	const GLvoid *source,
		4859	const struct gl_pixelstore_attrib *srcPacking,
		4860	GLbitfield transferOps )
		4861	{
		4862	ASSERT(dstFormat == GL_DUDV_ATI);
		4863	ASSERT(srcFormat == GL_DUDV_ATI \|\|
		4864	srcFormat == GL_DU8DV8_ATI);
		4865
		4866	ASSERT(srcType == GL_UNSIGNED_BYTE \|\|
		4867	srcType == GL_BYTE \|\|
		4868	srcType == GL_UNSIGNED_SHORT \|\|
		4869	srcType == GL_SHORT \|\|
		4870	srcType == GL_UNSIGNED_INT \|\|
		4871	srcType == GL_INT \|\|
		4872	srcType == GL_HALF_FLOAT_ARB \|\|
		4873	srcType == GL_FLOAT);
		4874
		4875	/* general solution */
		4876	{
		4877	GLint dstComponents;
		4878	GLbyte *dst = dest;
		4879	GLuint i;
		4880	GLfloat (rgba)[4] = malloc(4 n * sizeof(GLfloat));
		4881
		4882	if (!rgba) {
		4883	_mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
		4884	return;
		4885	}
		4886
		4887	dstComponents = _mesa_components_in_format( dstFormat );
		4888	/* source & dest image formats should have been error checked by now */
		4889	assert(dstComponents > 0);
		4890
		4891	/*
		4892	* Extract image data and convert to RGBA floats
		4893	*/
		4894	extract_float_rgba(n, rgba, srcFormat, srcType, source,
		4895	srcPacking->SwapBytes);
		4896
		4897
		4898	/* Now determine which color channels we need to produce.
		4899	* And determine the dest index (offset) within each color tuple.
		4900	*/
		4901
		4902	/* Now pack results in the requested dstFormat */
		4903	for (i = 0; i < n; i++) {
		4904	/* not sure - need clamp[-1,1] here? */
		4905	dst[0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
		4906	dst[1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
		4907	dst += dstComponents;
		4908	}
		4909
		4910	free(rgba);
		4911	}
		4912	}
		4913
		4914	/*
		4915	* Unpack a row of color index data from a client buffer according to
		4916	* the pixel unpacking parameters.
		4917	* This is (or will be) used by glDrawPixels, glTexImage[123]D, etc.
		4918	*
		4919	* Args: ctx - the context
		4920	* n - number of pixels
		4921	* dstType - destination data type
		4922	* dest - destination array
		4923	* srcType - source pixel type
		4924	* source - source data pointer
		4925	* srcPacking - pixel unpacking parameters
		4926	* transferOps - the pixel transfer operations to apply
		4927	*/
		4928	void
		4929	_mesa_unpack_index_span( struct gl_context *ctx, GLuint n,
		4930	GLenum dstType, GLvoid *dest,
		4931	GLenum srcType, const GLvoid *source,
		4932	const struct gl_pixelstore_attrib *srcPacking,
		4933	GLbitfield transferOps )
		4934	{
		4935	ASSERT(srcType == GL_BITMAP \|\|
		4936	srcType == GL_UNSIGNED_BYTE \|\|
		4937	srcType == GL_BYTE \|\|
		4938	srcType == GL_UNSIGNED_SHORT \|\|
		4939	srcType == GL_SHORT \|\|
		4940	srcType == GL_UNSIGNED_INT \|\|
		4941	srcType == GL_INT \|\|
		4942	srcType == GL_HALF_FLOAT_ARB \|\|
		4943	srcType == GL_FLOAT);
		4944
		4945	ASSERT(dstType == GL_UNSIGNED_BYTE \|\|
		4946	dstType == GL_UNSIGNED_SHORT \|\|
		4947	dstType == GL_UNSIGNED_INT);
		4948
		4949
		4950	transferOps &= (IMAGE_MAP_COLOR_BIT \| IMAGE_SHIFT_OFFSET_BIT);
		4951
		4952	/*
		4953	* Try simple cases first
		4954	*/
		4955	if (transferOps == 0 && srcType == GL_UNSIGNED_BYTE
		4956	&& dstType == GL_UNSIGNED_BYTE) {
		4957	memcpy(dest, source, n * sizeof(GLubyte));
		4958	}
		4959	else if (transferOps == 0 && srcType == GL_UNSIGNED_INT
		4960	&& dstType == GL_UNSIGNED_INT && !srcPacking->SwapBytes) {
		4961	memcpy(dest, source, n * sizeof(GLuint));
		4962	}
		4963	else {
		4964	/*
		4965	* general solution
		4966	*/
		4967	GLuint indexes = malloc(n sizeof(GLuint));
		4968
		4969	if (!indexes) {
		4970	_mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
		4971	return;
		4972	}
		4973
		4974	extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source,
		4975	srcPacking);
		4976
		4977	if (transferOps)
		4978	_mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
		4979
		4980	/* convert to dest type */
		4981	switch (dstType) {
		4982	case GL_UNSIGNED_BYTE:
		4983	{
		4984	GLubyte dst = (GLubyte ) dest;
		4985	GLuint i;
		4986	for (i = 0; i < n; i++) {
		4987	dst[i] = (GLubyte) (indexes[i] & 0xff);
		4988	}
		4989	}
		4990	break;
		4991	case GL_UNSIGNED_SHORT:
		4992	{
		4993	GLuint dst = (GLuint ) dest;
		4994	GLuint i;
		4995	for (i = 0; i < n; i++) {
		4996	dst[i] = (GLushort) (indexes[i] & 0xffff);
		4997	}
		4998	}
		4999	break;
		5000	case GL_UNSIGNED_INT:
		5001	memcpy(dest, indexes, n * sizeof(GLuint));
		5002	break;
		5003	default:
		5004	_mesa_problem(ctx, "bad dstType in _mesa_unpack_index_span");
		5005	}
		5006
		5007	free(indexes);
		5008	}
		5009	}
		5010
		5011
		5012	void
		5013	_mesa_pack_index_span( struct gl_context *ctx, GLuint n,
		5014	GLenum dstType, GLvoid dest, const GLuint source,
		5015	const struct gl_pixelstore_attrib *dstPacking,
		5016	GLbitfield transferOps )
		5017	{
		5018	GLuint indexes = malloc(n sizeof(GLuint));
		5019
		5020	if (!indexes) {
		5021	_mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
		5022	return;
		5023	}
		5024
		5025	transferOps &= (IMAGE_MAP_COLOR_BIT \| IMAGE_SHIFT_OFFSET_BIT);
		5026
		5027	if (transferOps & (IMAGE_MAP_COLOR_BIT \| IMAGE_SHIFT_OFFSET_BIT)) {
		5028	/* make a copy of input */
		5029	memcpy(indexes, source, n * sizeof(GLuint));
		5030	_mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
		5031	source = indexes;
		5032	}
		5033
		5034	switch (dstType) {
		5035	case GL_UNSIGNED_BYTE:
		5036	{
		5037	GLubyte dst = (GLubyte ) dest;
		5038	GLuint i;
		5039	for (i = 0; i < n; i++) {
		5040	*dst++ = (GLubyte) source[i];
		5041	}
		5042	}
		5043	break;
		5044	case GL_BYTE:
		5045	{
		5046	GLbyte dst = (GLbyte ) dest;
		5047	GLuint i;
		5048	for (i = 0; i < n; i++) {
		5049	dst[i] = (GLbyte) source[i];
		5050	}
		5051	}
		5052	break;
		5053	case GL_UNSIGNED_SHORT:
		5054	{
		5055	GLushort dst = (GLushort ) dest;
		5056	GLuint i;
		5057	for (i = 0; i < n; i++) {
		5058	dst[i] = (GLushort) source[i];
		5059	}
		5060	if (dstPacking->SwapBytes) {
		5061	_mesa_swap2( (GLushort *) dst, n );
		5062	}
		5063	}
		5064	break;
		5065	case GL_SHORT:
		5066	{
		5067	GLshort dst = (GLshort ) dest;
		5068	GLuint i;
		5069	for (i = 0; i < n; i++) {
		5070	dst[i] = (GLshort) source[i];
		5071	}
		5072	if (dstPacking->SwapBytes) {
		5073	_mesa_swap2( (GLushort *) dst, n );
		5074	}
		5075	}
		5076	break;
		5077	case GL_UNSIGNED_INT:
		5078	{
		5079	GLuint dst = (GLuint ) dest;
		5080	GLuint i;
		5081	for (i = 0; i < n; i++) {
		5082	dst[i] = (GLuint) source[i];
		5083	}
		5084	if (dstPacking->SwapBytes) {
		5085	_mesa_swap4( (GLuint *) dst, n );
		5086	}
		5087	}
		5088	break;
		5089	case GL_INT:
		5090	{
		5091	GLint dst = (GLint ) dest;
		5092	GLuint i;
		5093	for (i = 0; i < n; i++) {
		5094	dst[i] = (GLint) source[i];
		5095	}
		5096	if (dstPacking->SwapBytes) {
		5097	_mesa_swap4( (GLuint *) dst, n );
		5098	}
		5099	}
		5100	break;
		5101	case GL_FLOAT:
		5102	{
		5103	GLfloat dst = (GLfloat ) dest;
		5104	GLuint i;
		5105	for (i = 0; i < n; i++) {
		5106	dst[i] = (GLfloat) source[i];
		5107	}
		5108	if (dstPacking->SwapBytes) {
		5109	_mesa_swap4( (GLuint *) dst, n );
		5110	}
		5111	}
		5112	break;
		5113	case GL_HALF_FLOAT_ARB:
		5114	{
		5115	GLhalfARB dst = (GLhalfARB ) dest;
		5116	GLuint i;
		5117	for (i = 0; i < n; i++) {
		5118	dst[i] = _mesa_float_to_half((GLfloat) source[i]);
		5119	}
		5120	if (dstPacking->SwapBytes) {
		5121	_mesa_swap2( (GLushort *) dst, n );
		5122	}
		5123	}
		5124	break;
		5125	default:
		5126	_mesa_problem(ctx, "bad type in _mesa_pack_index_span");
		5127	}
		5128
		5129	free(indexes);
		5130	}
		5131
		5132
		5133	/*
		5134	* Unpack a row of stencil data from a client buffer according to
		5135	* the pixel unpacking parameters.
		5136	* This is (or will be) used by glDrawPixels
		5137	*
		5138	* Args: ctx - the context
		5139	* n - number of pixels
		5140	* dstType - destination data type
		5141	* dest - destination array
		5142	* srcType - source pixel type
		5143	* source - source data pointer
		5144	* srcPacking - pixel unpacking parameters
		5145	* transferOps - apply offset/bias/lookup ops?
		5146	*/
		5147	void
		5148	_mesa_unpack_stencil_span( struct gl_context *ctx, GLuint n,
		5149	GLenum dstType, GLvoid *dest,
		5150	GLenum srcType, const GLvoid *source,
		5151	const struct gl_pixelstore_attrib *srcPacking,
		5152	GLbitfield transferOps )
		5153	{
		5154	ASSERT(srcType == GL_BITMAP \|\|
		5155	srcType == GL_UNSIGNED_BYTE \|\|
		5156	srcType == GL_BYTE \|\|
		5157	srcType == GL_UNSIGNED_SHORT \|\|
		5158	srcType == GL_SHORT \|\|
		5159	srcType == GL_UNSIGNED_INT \|\|
		5160	srcType == GL_INT \|\|
		5161	srcType == GL_UNSIGNED_INT_24_8_EXT \|\|
		5162	srcType == GL_HALF_FLOAT_ARB \|\|
		5163	srcType == GL_FLOAT \|\|
		5164	srcType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
		5165
		5166	ASSERT(dstType == GL_UNSIGNED_BYTE \|\|
		5167	dstType == GL_UNSIGNED_SHORT \|\|
		5168	dstType == GL_UNSIGNED_INT \|\|
		5169	dstType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
		5170
		5171	/* only shift and offset apply to stencil */
		5172	transferOps &= IMAGE_SHIFT_OFFSET_BIT;
		5173
		5174	/*
		5175	* Try simple cases first
		5176	*/
		5177	if (transferOps == 0 &&
		5178	!ctx->Pixel.MapStencilFlag &&
		5179	srcType == GL_UNSIGNED_BYTE &&
		5180	dstType == GL_UNSIGNED_BYTE) {
		5181	memcpy(dest, source, n * sizeof(GLubyte));
		5182	}
		5183	else if (transferOps == 0 &&
		5184	!ctx->Pixel.MapStencilFlag &&
		5185	srcType == GL_UNSIGNED_INT &&
		5186	dstType == GL_UNSIGNED_INT &&
		5187	!srcPacking->SwapBytes) {
		5188	memcpy(dest, source, n * sizeof(GLuint));
		5189	}
		5190	else {
		5191	/*
		5192	* general solution
		5193	*/
		5194	GLuint indexes = malloc(n sizeof(GLuint));
		5195
		5196	if (!indexes) {
		5197	_mesa_error(ctx, GL_OUT_OF_MEMORY, "stencil unpacking");
		5198	return;
		5199	}
		5200
		5201	extract_uint_indexes(n, indexes, GL_STENCIL_INDEX, srcType, source,
		5202	srcPacking);
		5203
		5204	if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
		5205	/* shift and offset indexes */
		5206	_mesa_shift_and_offset_ci(ctx, n, indexes);
		5207	}
		5208
		5209	if (ctx->Pixel.MapStencilFlag) {
		5210	/* Apply stencil lookup table */
		5211	const GLuint mask = ctx->PixelMaps.StoS.Size - 1;
		5212	GLuint i;
		5213	for (i = 0; i < n; i++) {
		5214	indexes[i] = (GLuint)ctx->PixelMaps.StoS.Map[ indexes[i] & mask ];
		5215	}
		5216	}
		5217
		5218	/* convert to dest type */
		5219	switch (dstType) {
		5220	case GL_UNSIGNED_BYTE:
		5221	{
		5222	GLubyte dst = (GLubyte ) dest;
		5223	GLuint i;
		5224	for (i = 0; i < n; i++) {
		5225	dst[i] = (GLubyte) (indexes[i] & 0xff);
		5226	}
		5227	}
		5228	break;
		5229	case GL_UNSIGNED_SHORT:
		5230	{
		5231	GLuint dst = (GLuint ) dest;
		5232	GLuint i;
		5233	for (i = 0; i < n; i++) {
		5234	dst[i] = (GLushort) (indexes[i] & 0xffff);
		5235	}
		5236	}
		5237	break;
		5238	case GL_UNSIGNED_INT:
		5239	memcpy(dest, indexes, n * sizeof(GLuint));
		5240	break;
		5241	case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
		5242	{
		5243	GLuint dst = (GLuint ) dest;
		5244	GLuint i;
		5245	for (i = 0; i < n; i++) {
		5246	dst[i2+1] = indexes[i] & 0xff; / lower 8 bits */
		5247	}
		5248	}
		5249	break;
		5250	default:
		5251	_mesa_problem(ctx, "bad dstType in _mesa_unpack_stencil_span");
		5252	}
		5253
		5254	free(indexes);
		5255	}
		5256	}
		5257
		5258
		5259	void
		5260	_mesa_pack_stencil_span( struct gl_context *ctx, GLuint n,
		5261	GLenum dstType, GLvoid dest, const GLubyte source,
		5262	const struct gl_pixelstore_attrib *dstPacking )
		5263	{
		5264	GLubyte stencil = malloc(n sizeof(GLubyte));
		5265
		5266	if (!stencil) {
		5267	_mesa_error(ctx, GL_OUT_OF_MEMORY, "stencil packing");
		5268	return;
		5269	}
		5270
		5271	if (ctx->Pixel.IndexShift \|\| ctx->Pixel.IndexOffset \|\|
		5272	ctx->Pixel.MapStencilFlag) {
		5273	/* make a copy of input */
		5274	memcpy(stencil, source, n * sizeof(GLubyte));
		5275	_mesa_apply_stencil_transfer_ops(ctx, n, stencil);
		5276	source = stencil;
		5277	}
		5278
		5279	switch (dstType) {
		5280	case GL_UNSIGNED_BYTE:
		5281	memcpy(dest, source, n);
		5282	break;
		5283	case GL_BYTE:
		5284	{
		5285	GLbyte dst = (GLbyte ) dest;
		5286	GLuint i;
		5287	for (i=0;i
		5288	dst[i] = (GLbyte) (source[i] & 0x7f);
		5289	}
		5290	}
		5291	break;
		5292	case GL_UNSIGNED_SHORT:
		5293	{
		5294	GLushort dst = (GLushort ) dest;
		5295	GLuint i;
		5296	for (i=0;i
		5297	dst[i] = (GLushort) source[i];
		5298	}
		5299	if (dstPacking->SwapBytes) {
		5300	_mesa_swap2( (GLushort *) dst, n );
		5301	}
		5302	}
		5303	break;
		5304	case GL_SHORT:
		5305	{
		5306	GLshort dst = (GLshort ) dest;
		5307	GLuint i;
		5308	for (i=0;i
		5309	dst[i] = (GLshort) source[i];
		5310	}
		5311	if (dstPacking->SwapBytes) {
		5312	_mesa_swap2( (GLushort *) dst, n );
		5313	}
		5314	}
		5315	break;
		5316	case GL_UNSIGNED_INT:
		5317	{
		5318	GLuint dst = (GLuint ) dest;
		5319	GLuint i;
		5320	for (i=0;i
		5321	dst[i] = (GLuint) source[i];
		5322	}
		5323	if (dstPacking->SwapBytes) {
		5324	_mesa_swap4( (GLuint *) dst, n );
		5325	}
		5326	}
		5327	break;
		5328	case GL_INT:
		5329	{
		5330	GLint dst = (GLint ) dest;
		5331	GLuint i;
		5332	for (i=0;i
		5333	dst[i] = (GLint) source[i];
		5334	}
		5335	if (dstPacking->SwapBytes) {
		5336	_mesa_swap4( (GLuint *) dst, n );
		5337	}
		5338	}
		5339	break;
		5340	case GL_FLOAT:
		5341	{
		5342	GLfloat dst = (GLfloat ) dest;
		5343	GLuint i;
		5344	for (i=0;i
		5345	dst[i] = (GLfloat) source[i];
		5346	}
		5347	if (dstPacking->SwapBytes) {
		5348	_mesa_swap4( (GLuint *) dst, n );
		5349	}
		5350	}
		5351	break;
		5352	case GL_HALF_FLOAT_ARB:
		5353	{
		5354	GLhalfARB dst = (GLhalfARB ) dest;
		5355	GLuint i;
		5356	for (i=0;i
		5357	dst[i] = _mesa_float_to_half( (float) source[i] );
		5358	}
		5359	if (dstPacking->SwapBytes) {
		5360	_mesa_swap2( (GLushort *) dst, n );
		5361	}
		5362	}
		5363	break;
		5364	case GL_BITMAP:
		5365	if (dstPacking->LsbFirst) {
		5366	GLubyte dst = (GLubyte ) dest;
		5367	GLint shift = 0;
		5368	GLuint i;
		5369	for (i = 0; i < n; i++) {
		5370	if (shift == 0)
		5371	*dst = 0;
		5372	*dst \|= ((source[i] != 0) << shift);
		5373	shift++;
		5374	if (shift == 8) {
		5375	shift = 0;
		5376	dst++;
		5377	}
		5378	}
		5379	}
		5380	else {
		5381	GLubyte dst = (GLubyte ) dest;
		5382	GLint shift = 7;
		5383	GLuint i;
		5384	for (i = 0; i < n; i++) {
		5385	if (shift == 7)
		5386	*dst = 0;
		5387	*dst \|= ((source[i] != 0) << shift);
		5388	shift--;
		5389	if (shift < 0) {
		5390	shift = 7;
		5391	dst++;
		5392	}
		5393	}
		5394	}
		5395	break;
		5396	default:
		5397	_mesa_problem(ctx, "bad type in _mesa_pack_index_span");
		5398	}
		5399
		5400	free(stencil);
		5401	}
		5402
		5403	#define DEPTH_VALUES(GLTYPE, GLTYPE2FLOAT) \
		5404	do { \
		5405	GLuint i; \
		5406	const GLTYPE src = (const GLTYPE )source; \
		5407	for (i = 0; i < n; i++) { \
		5408	GLTYPE value = src[i]; \
		5409	if (srcPacking->SwapBytes) { \
		5410	if (sizeof(GLTYPE) == 2) { \
		5411	SWAP2BYTE(value); \
		5412	} else if (sizeof(GLTYPE) == 4) { \
		5413	SWAP4BYTE(value); \
		5414	} \
		5415	} \
		5416	depthValues[i] = GLTYPE2FLOAT(value); \
		5417	} \
		5418	} while (0)
		5419
		5420
		5421	/**
		5422	* Unpack a row of depth/z values from memory, returning GLushort, GLuint
		5423	* or GLfloat values.
		5424	* The glPixelTransfer (scale/bias) params will be applied.
		5425	*
		5426	* \param dstType one of GL_UNSIGNED_SHORT, GL_UNSIGNED_INT, GL_FLOAT
		5427	* \param depthMax max value for returned GLushort or GLuint values
		5428	* (ignored for GLfloat).
		5429	*/
		5430	void
		5431	_mesa_unpack_depth_span( struct gl_context *ctx, GLuint n,
		5432	GLenum dstType, GLvoid *dest, GLuint depthMax,
		5433	GLenum srcType, const GLvoid *source,
		5434	const struct gl_pixelstore_attrib *srcPacking )
		5435	{
		5436	GLfloat depthTemp = NULL, depthValues;
		5437	GLboolean needClamp = GL_FALSE;
		5438
		5439	/* Look for special cases first.
		5440	* Not only are these faster, they're less prone to numeric conversion
		5441	* problems. Otherwise, converting from an int type to a float then
		5442	* back to an int type can introduce errors that will show up as
		5443	* artifacts in things like depth peeling which uses glCopyTexImage.
		5444	*/
		5445	if (ctx->Pixel.DepthScale == 1.0 && ctx->Pixel.DepthBias == 0.0) {
		5446	if (srcType == GL_UNSIGNED_INT && dstType == GL_UNSIGNED_SHORT) {
		5447	const GLuint src = (const GLuint ) source;
		5448	GLushort dst = (GLushort ) dest;
		5449	GLuint i;
		5450	for (i = 0; i < n; i++) {
		5451	dst[i] = src[i] >> 16;
		5452	}
		5453	return;
		5454	}
		5455	if (srcType == GL_UNSIGNED_SHORT
		5456	&& dstType == GL_UNSIGNED_INT
		5457	&& depthMax == 0xffffffff) {
		5458	const GLushort src = (const GLushort ) source;
		5459	GLuint dst = (GLuint ) dest;
		5460	GLuint i;
		5461	for (i = 0; i < n; i++) {
		5462	dst[i] = src[i] \| (src[i] << 16);
		5463	}
		5464	return;
		5465	}
		5466	if (srcType == GL_UNSIGNED_INT_24_8
		5467	&& dstType == GL_UNSIGNED_INT
		5468	&& depthMax == 0xffffff) {
		5469	const GLuint src = (const GLuint ) source;
		5470	GLuint dst = (GLuint ) dest;
		5471	GLuint i;
		5472	for (i = 0; i < n; i++) {
		5473	dst[i] = src[i] >> 8;
		5474	}
		5475	return;
		5476	}
		5477	/* XXX may want to add additional cases here someday */
		5478	}
		5479
		5480	/* general case path follows */
		5481
		5482	if (dstType == GL_FLOAT) {
		5483	depthValues = (GLfloat *) dest;
		5484	}
		5485	else {
		5486	depthTemp = malloc(n * sizeof(GLfloat));
		5487	if (!depthTemp) {
		5488	_mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
		5489	return;
		5490	}
		5491
		5492	depthValues = depthTemp;
		5493	}
		5494
		5495	/* Convert incoming values to GLfloat. Some conversions will require
		5496	* clamping, below.
		5497	*/
		5498	switch (srcType) {
		5499	case GL_BYTE:
		5500	DEPTH_VALUES(GLbyte, BYTE_TO_FLOATZ);
		5501	needClamp = GL_TRUE;
		5502	break;
		5503	case GL_UNSIGNED_BYTE:
		5504	DEPTH_VALUES(GLubyte, UBYTE_TO_FLOAT);
		5505	break;
		5506	case GL_SHORT:
		5507	DEPTH_VALUES(GLshort, SHORT_TO_FLOATZ);
		5508	needClamp = GL_TRUE;
		5509	break;
		5510	case GL_UNSIGNED_SHORT:
		5511	DEPTH_VALUES(GLushort, USHORT_TO_FLOAT);
		5512	break;
		5513	case GL_INT:
		5514	DEPTH_VALUES(GLint, INT_TO_FLOAT);
		5515	needClamp = GL_TRUE;
		5516	break;
		5517	case GL_UNSIGNED_INT:
		5518	DEPTH_VALUES(GLuint, UINT_TO_FLOAT);
		5519	break;
		5520	case GL_UNSIGNED_INT_24_8_EXT: /* GL_EXT_packed_depth_stencil */
		5521	if (dstType == GL_UNSIGNED_INT_24_8_EXT &&
		5522	depthMax == 0xffffff &&
		5523	ctx->Pixel.DepthScale == 1.0 &&
		5524	ctx->Pixel.DepthBias == 0.0) {
		5525	const GLuint src = (const GLuint ) source;
		5526	GLuint zValues = (GLuint ) dest;
		5527	GLuint i;
		5528	for (i = 0; i < n; i++) {
		5529	GLuint value = src[i];
		5530	if (srcPacking->SwapBytes) {
		5531	SWAP4BYTE(value);
		5532	}
		5533	zValues[i] = value & 0xffffff00;
		5534	}
		5535	free(depthTemp);
		5536	return;
		5537	}
		5538	else {
		5539	const GLuint src = (const GLuint ) source;
		5540	const GLfloat scale = 1.0f / 0xffffff;
		5541	GLuint i;
		5542	for (i = 0; i < n; i++) {
		5543	GLuint value = src[i];
		5544	if (srcPacking->SwapBytes) {
		5545	SWAP4BYTE(value);
		5546	}
		5547	depthValues[i] = (value >> 8) * scale;
		5548	}
		5549	}
		5550	break;
		5551	case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
		5552	{
		5553	GLuint i;
		5554	const GLfloat src = (const GLfloat )source;
		5555	for (i = 0; i < n; i++) {
		5556	GLfloat value = src[i * 2];
		5557	if (srcPacking->SwapBytes) {
		5558	SWAP4BYTE(value);
		5559	}
		5560	depthValues[i] = value;
		5561	}
		5562	needClamp = GL_TRUE;
		5563	}
		5564	break;
		5565	case GL_FLOAT:
		5566	DEPTH_VALUES(GLfloat, 1*);
		5567	needClamp = GL_TRUE;
		5568	break;
		5569	case GL_HALF_FLOAT_ARB:
		5570	{
		5571	GLuint i;
		5572	const GLhalfARB src = (const GLhalfARB ) source;
		5573	for (i = 0; i < n; i++) {
		5574	GLhalfARB value = src[i];
		5575	if (srcPacking->SwapBytes) {
		5576	SWAP2BYTE(value);
		5577	}
		5578	depthValues[i] = _mesa_half_to_float(value);
		5579	}
		5580	needClamp = GL_TRUE;
		5581	}
		5582	break;
		5583	default:
		5584	_mesa_problem(NULL, "bad type in _mesa_unpack_depth_span()");
		5585	free(depthTemp);
		5586	return;
		5587	}
		5588
		5589	/* apply depth scale and bias */
		5590	{
		5591	const GLfloat scale = ctx->Pixel.DepthScale;
		5592	const GLfloat bias = ctx->Pixel.DepthBias;
		5593	if (scale != 1.0 \|\| bias != 0.0) {
		5594	GLuint i;
		5595	for (i = 0; i < n; i++) {
		5596	depthValues[i] = depthValues[i] * scale + bias;
		5597	}
		5598	needClamp = GL_TRUE;
		5599	}
		5600	}
		5601
		5602	/* clamp to [0, 1] */
		5603	if (needClamp) {
		5604	GLuint i;
		5605	for (i = 0; i < n; i++) {
		5606	depthValues[i] = (GLfloat)CLAMP(depthValues[i], 0.0, 1.0);
		5607	}
		5608	}
		5609
		5610	/*
		5611	* Convert values to dstType
		5612	*/
		5613	if (dstType == GL_UNSIGNED_INT) {
		5614	GLuint zValues = (GLuint ) dest;
		5615	GLuint i;
		5616	if (depthMax <= 0xffffff) {
		5617	/* no overflow worries */
		5618	for (i = 0; i < n; i++) {
		5619	zValues[i] = (GLuint) (depthValues[i] * (GLfloat) depthMax);
		5620	}
		5621	}
		5622	else {
		5623	/* need to use double precision to prevent overflow problems */
		5624	for (i = 0; i < n; i++) {
		5625	GLdouble z = depthValues[i] * (GLdouble) depthMax;
		5626	if (z >= (GLdouble) 0xffffffff)
		5627	zValues[i] = 0xffffffff;
		5628	else
		5629	zValues[i] = (GLuint) z;
		5630	}
		5631	}
		5632	}
		5633	else if (dstType == GL_UNSIGNED_SHORT) {
		5634	GLushort zValues = (GLushort ) dest;
		5635	GLuint i;
		5636	ASSERT(depthMax <= 0xffff);
		5637	for (i = 0; i < n; i++) {
		5638	zValues[i] = (GLushort) (depthValues[i] * (GLfloat) depthMax);
		5639	}
		5640	}
		5641	else if (dstType == GL_FLOAT) {
		5642	/* Nothing to do. depthValues is pointing to dest. */
		5643	}
		5644	else if (dstType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV) {
		5645	GLfloat zValues = (GLfloat) dest;
		5646	GLuint i;
		5647	for (i = 0; i < n; i++) {
		5648	zValues[i*2] = depthValues[i];
		5649	}
		5650	}
		5651	else {
		5652	ASSERT(0);
		5653	}
		5654
		5655	free(depthTemp);
		5656	}
		5657
		5658
		5659	/*
		5660	* Pack an array of depth values. The values are floats in [0,1].
		5661	*/
		5662	void
		5663	_mesa_pack_depth_span( struct gl_context ctx, GLuint n, GLvoid dest,
		5664	GLenum dstType, const GLfloat *depthSpan,
		5665	const struct gl_pixelstore_attrib *dstPacking )
		5666	{
		5667	GLfloat depthCopy = malloc(n sizeof(GLfloat));
		5668	if (!depthCopy) {
		5669	_mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
		5670	return;
		5671	}
		5672
		5673	if (ctx->Pixel.DepthScale != 1.0 \|\| ctx->Pixel.DepthBias != 0.0) {
		5674	memcpy(depthCopy, depthSpan, n * sizeof(GLfloat));
		5675	_mesa_scale_and_bias_depth(ctx, n, depthCopy);
		5676	depthSpan = depthCopy;
		5677	}
		5678
		5679	switch (dstType) {
		5680	case GL_UNSIGNED_BYTE:
		5681	{
		5682	GLubyte dst = (GLubyte ) dest;
		5683	GLuint i;
		5684	for (i = 0; i < n; i++) {
		5685	dst[i] = FLOAT_TO_UBYTE( depthSpan[i] );
		5686	}
		5687	}
		5688	break;
		5689	case GL_BYTE:
		5690	{
		5691	GLbyte dst = (GLbyte ) dest;
		5692	GLuint i;
		5693	for (i = 0; i < n; i++) {
		5694	dst[i] = FLOAT_TO_BYTE( depthSpan[i] );
		5695	}
		5696	}
		5697	break;
		5698	case GL_UNSIGNED_SHORT:
		5699	{
		5700	GLushort dst = (GLushort ) dest;
		5701	GLuint i;
		5702	for (i = 0; i < n; i++) {
		5703	CLAMPED_FLOAT_TO_USHORT(dst[i], depthSpan[i]);
		5704	}
		5705	if (dstPacking->SwapBytes) {
		5706	_mesa_swap2( (GLushort *) dst, n );
		5707	}
		5708	}
		5709	break;
		5710	case GL_SHORT:
		5711	{
		5712	GLshort dst = (GLshort ) dest;
		5713	GLuint i;
		5714	for (i = 0; i < n; i++) {
		5715	dst[i] = FLOAT_TO_SHORT( depthSpan[i] );
		5716	}
		5717	if (dstPacking->SwapBytes) {
		5718	_mesa_swap2( (GLushort *) dst, n );
		5719	}
		5720	}
		5721	break;
		5722	case GL_UNSIGNED_INT:
		5723	{
		5724	GLuint dst = (GLuint ) dest;
		5725	GLuint i;
		5726	for (i = 0; i < n; i++) {
		5727	dst[i] = FLOAT_TO_UINT( depthSpan[i] );
		5728	}
		5729	if (dstPacking->SwapBytes) {
		5730	_mesa_swap4( (GLuint *) dst, n );
		5731	}
		5732	}
		5733	break;
		5734	case GL_INT:
		5735	{
		5736	GLint dst = (GLint ) dest;
		5737	GLuint i;
		5738	for (i = 0; i < n; i++) {
		5739	dst[i] = FLOAT_TO_INT( depthSpan[i] );
		5740	}
		5741	if (dstPacking->SwapBytes) {
		5742	_mesa_swap4( (GLuint *) dst, n );
		5743	}
		5744	}
		5745	break;
		5746	case GL_FLOAT:
		5747	{
		5748	GLfloat dst = (GLfloat ) dest;
		5749	GLuint i;
		5750	for (i = 0; i < n; i++) {
		5751	dst[i] = depthSpan[i];
		5752	}
		5753	if (dstPacking->SwapBytes) {
		5754	_mesa_swap4( (GLuint *) dst, n );
		5755	}
		5756	}
		5757	break;
		5758	case GL_HALF_FLOAT_ARB:
		5759	{
		5760	GLhalfARB dst = (GLhalfARB ) dest;
		5761	GLuint i;
		5762	for (i = 0; i < n; i++) {
		5763	dst[i] = _mesa_float_to_half(depthSpan[i]);
		5764	}
		5765	if (dstPacking->SwapBytes) {
		5766	_mesa_swap2( (GLushort *) dst, n );
		5767	}
		5768	}
		5769	break;
		5770	default:
		5771	_mesa_problem(ctx, "bad type in _mesa_pack_depth_span");
		5772	}
		5773
		5774	free(depthCopy);
		5775	}
		5776
		5777
		5778
		5779	/**
		5780	* Pack depth and stencil values as GL_DEPTH_STENCIL (GL_UNSIGNED_INT_24_8 etc)
		5781	*/
		5782	void
		5783	_mesa_pack_depth_stencil_span(struct gl_context *ctx,GLuint n,
		5784	GLenum dstType, GLuint *dest,
		5785	const GLfloat *depthVals,
		5786	const GLubyte *stencilVals,
		5787	const struct gl_pixelstore_attrib *dstPacking)
		5788	{
		5789	GLfloat depthCopy = malloc(n sizeof(GLfloat));
		5790	GLubyte stencilCopy = malloc(n sizeof(GLubyte));
		5791	GLuint i;
		5792
		5793	if (!depthCopy \|\| !stencilCopy) {
		5794	_mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
		5795	free(depthCopy);
		5796	free(stencilCopy);
		5797	return;
		5798	}
		5799
		5800	if (ctx->Pixel.DepthScale != 1.0 \|\| ctx->Pixel.DepthBias != 0.0) {
		5801	memcpy(depthCopy, depthVals, n * sizeof(GLfloat));
		5802	_mesa_scale_and_bias_depth(ctx, n, depthCopy);
		5803	depthVals = depthCopy;
		5804	}
		5805
		5806	if (ctx->Pixel.IndexShift \|\|
		5807	ctx->Pixel.IndexOffset \|\|
		5808	ctx->Pixel.MapStencilFlag) {
		5809	memcpy(stencilCopy, stencilVals, n * sizeof(GLubyte));
		5810	_mesa_apply_stencil_transfer_ops(ctx, n, stencilCopy);
		5811	stencilVals = stencilCopy;
		5812	}
		5813
		5814	switch (dstType) {
		5815	case GL_UNSIGNED_INT_24_8:
		5816	for (i = 0; i < n; i++) {
		5817	GLuint z = (GLuint) (depthVals[i] * 0xffffff);
		5818	dest[i] = (z << 8) \| (stencilVals[i] & 0xff);
		5819	}
		5820	break;
		5821	case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
		5822	for (i = 0; i < n; i++) {
		5823	((GLfloat)dest)[i2] = depthVals[i];
		5824	dest[i*2+1] = stencilVals[i] & 0xff;
		5825	}
		5826	break;
		5827	}
		5828
		5829	if (dstPacking->SwapBytes) {
		5830	_mesa_swap4(dest, n);
		5831	}
		5832
		5833	free(depthCopy);
		5834	free(stencilCopy);
		5835	}
		5836
		5837
		5838
		5839
		5840	/**
		5841	* Unpack image data. Apply byte swapping, byte flipping (bitmap).
		5842	* Return all image data in a contiguous block. This is used when we
		5843	* compile glDrawPixels, glTexImage, etc into a display list. We
		5844	* need a copy of the data in a standard format.
		5845	*/
		5846	void *
		5847	_mesa_unpack_image( GLuint dimensions,
		5848	GLsizei width, GLsizei height, GLsizei depth,
		5849	GLenum format, GLenum type, const GLvoid *pixels,
		5850	const struct gl_pixelstore_attrib *unpack )
		5851	{
		5852	GLint bytesPerRow, compsPerRow;
		5853	GLboolean flipBytes, swap2, swap4;
		5854
		5855	if (!pixels)
		5856	return NULL; /* not necessarily an error */
		5857
		5858	if (width <= 0 \|\| height <= 0 \|\| depth <= 0)
		5859	return NULL; /* generate error later */
		5860
		5861	if (type == GL_BITMAP) {
		5862	bytesPerRow = (width + 7) >> 3;
		5863	flipBytes = unpack->LsbFirst;
		5864	swap2 = swap4 = GL_FALSE;
		5865	compsPerRow = 0;
		5866	}
		5867	else {
		5868	const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
		5869	GLint components = _mesa_components_in_format(format);
		5870	GLint bytesPerComp;
		5871
		5872	if (_mesa_type_is_packed(type))
		5873	components = 1;
		5874
		5875	if (bytesPerPixel <= 0 \|\| components <= 0)
		5876	return NULL; /* bad format or type. generate error later */
		5877	bytesPerRow = bytesPerPixel * width;
		5878	bytesPerComp = bytesPerPixel / components;
		5879	flipBytes = GL_FALSE;
		5880	swap2 = (bytesPerComp == 2) && unpack->SwapBytes;
		5881	swap4 = (bytesPerComp == 4) && unpack->SwapBytes;
		5882	compsPerRow = components * width;
		5883	assert(compsPerRow >= width);
		5884	}
		5885
		5886	{
		5887	GLubyte *destBuffer
		5888	= malloc(bytesPerRow * height * depth);
		5889	GLubyte *dst;
		5890	GLint img, row;
		5891	if (!destBuffer)
		5892	return NULL; /* generate GL_OUT_OF_MEMORY later */
		5893
		5894	dst = destBuffer;
		5895	for (img = 0; img < depth; img++) {
		5896	for (row = 0; row < height; row++) {
		5897	const GLvoid *src = _mesa_image_address(dimensions, unpack, pixels,
		5898	width, height, format, type, img, row, 0);
		5899
		5900	if ((type == GL_BITMAP) && (unpack->SkipPixels & 0x7)) {
		5901	GLint i;
		5902	flipBytes = GL_FALSE;
		5903	if (unpack->LsbFirst) {
		5904	GLubyte srcMask = 1 << (unpack->SkipPixels & 0x7);
		5905	GLubyte dstMask = 128;
		5906	const GLubyte *s = src;
		5907	GLubyte *d = dst;
		5908	*d = 0;
		5909	for (i = 0; i < width; i++) {
		5910	if (*s & srcMask) {
		5911	*d \|= dstMask;
		5912	}
		5913	if (srcMask == 128) {
		5914	srcMask = 1;
		5915	s++;
		5916	}
		5917	else {
		5918	srcMask = srcMask << 1;
		5919	}
		5920	if (dstMask == 1) {
		5921	dstMask = 128;
		5922	d++;
		5923	*d = 0;
		5924	}
		5925	else {
		5926	dstMask = dstMask >> 1;
		5927	}
		5928	}
		5929	}
		5930	else {
		5931	GLubyte srcMask = 128 >> (unpack->SkipPixels & 0x7);
		5932	GLubyte dstMask = 128;
		5933	const GLubyte *s = src;
		5934	GLubyte *d = dst;
		5935	*d = 0;
		5936	for (i = 0; i < width; i++) {
		5937	if (*s & srcMask) {
		5938	*d \|= dstMask;
		5939	}
		5940	if (srcMask == 1) {
		5941	srcMask = 128;
		5942	s++;
		5943	}
		5944	else {
		5945	srcMask = srcMask >> 1;
		5946	}
		5947	if (dstMask == 1) {
		5948	dstMask = 128;
		5949	d++;
		5950	*d = 0;
		5951	}
		5952	else {
		5953	dstMask = dstMask >> 1;
		5954	}
		5955	}
		5956	}
		5957	}
		5958	else {
		5959	memcpy(dst, src, bytesPerRow);
		5960	}
		5961
		5962	/* byte flipping/swapping */
		5963	if (flipBytes) {
		5964	flip_bytes((GLubyte *) dst, bytesPerRow);
		5965	}
		5966	else if (swap2) {
		5967	_mesa_swap2((GLushort*) dst, compsPerRow);
		5968	}
		5969	else if (swap4) {
		5970	_mesa_swap4((GLuint*) dst, compsPerRow);
		5971	}
		5972	dst += bytesPerRow;
		5973	}
		5974	}
		5975	return destBuffer;
		5976	}
		5977	}
		5978
		5979
		5980
		5981	/**
		5982	* If we unpack colors from a luminance surface, we'll get pixel colors
		5983	* such as (l, l, l, a).
		5984	* When we call _mesa_pack_rgba_span_float(format=GL_LUMINANCE), that
		5985	* function will compute L=R+G+B before packing. The net effect is we'll
		5986	* accidentally store luminance values = 3*l.
		5987	* This function compensates for that by converting (aka rebasing) (l,l,l,a)
		5988	* to be (l,0,0,a).
		5989	* It's a similar story for other formats such as LUMINANCE_ALPHA, ALPHA
		5990	* and INTENSITY.
		5991	*
		5992	* Finally, we also need to do this when the actual surface format does
		5993	* not match the logical surface format. For example, suppose the user
		5994	* requests a GL_LUMINANCE texture but the driver stores it as RGBA.
		5995	* Again, we'll get pixel values like (l,l,l,a).
		5996	*/
		5997	void
		5998	_mesa_rebase_rgba_float(GLuint n, GLfloat rgba[][4], GLenum baseFormat)
		5999	{
		6000	GLuint i;
		6001
		6002	switch (baseFormat) {
		6003	case GL_ALPHA:
		6004	for (i = 0; i < n; i++) {
		6005	rgba[i][RCOMP] = 0.0F;
		6006	rgba[i][GCOMP] = 0.0F;
		6007	rgba[i][BCOMP] = 0.0F;
		6008	}
		6009	break;
		6010	case GL_INTENSITY:
		6011	/* fall-through */
		6012	case GL_LUMINANCE:
		6013	for (i = 0; i < n; i++) {
		6014	rgba[i][GCOMP] = 0.0F;
		6015	rgba[i][BCOMP] = 0.0F;
		6016	rgba[i][ACOMP] = 1.0F;
		6017	}
		6018	break;
		6019	case GL_LUMINANCE_ALPHA:
		6020	for (i = 0; i < n; i++) {
		6021	rgba[i][GCOMP] = 0.0F;
		6022	rgba[i][BCOMP] = 0.0F;
		6023	}
		6024	break;
		6025	case GL_RGB:
		6026	for (i = 0; i < n; i++) {
		6027	rgba[i][ACOMP] = 1.0F;
		6028	}
		6029	break;
		6030	case GL_RG:
		6031	for (i = 0; i < n; i++) {
		6032	rgba[i][BCOMP] = 0.0F;
		6033	rgba[i][ACOMP] = 1.0F;
		6034	}
		6035	break;
		6036	case GL_RED:
		6037	for (i = 0; i < n; i++) {
		6038	rgba[i][GCOMP] = 0.0F;
		6039	rgba[i][BCOMP] = 0.0F;
		6040	rgba[i][ACOMP] = 1.0F;
		6041	}
		6042	break;
		6043
		6044	default:
		6045	/* no-op */
		6046	;
		6047	}
		6048	}
		6049
		6050
		6051	/**
		6052	* As above, but GLuint components.
		6053	*/
		6054	void
		6055	_mesa_rebase_rgba_uint(GLuint n, GLuint rgba[][4], GLenum baseFormat)
		6056	{
		6057	GLuint i;
		6058
		6059	switch (baseFormat) {
		6060	case GL_ALPHA:
		6061	for (i = 0; i < n; i++) {
		6062	rgba[i][RCOMP] = 0;
		6063	rgba[i][GCOMP] = 0;
		6064	rgba[i][BCOMP] = 0;
		6065	}
		6066	break;
		6067	case GL_INTENSITY:
		6068	/* fall-through */
		6069	case GL_LUMINANCE:
		6070	for (i = 0; i < n; i++) {
		6071	rgba[i][GCOMP] = 0;
		6072	rgba[i][BCOMP] = 0;
		6073	rgba[i][ACOMP] = 1;
		6074	}
		6075	break;
		6076	case GL_LUMINANCE_ALPHA:
		6077	for (i = 0; i < n; i++) {
		6078	rgba[i][GCOMP] = 0;
		6079	rgba[i][BCOMP] = 0;
		6080	}
		6081	break;
		6082	case GL_RGB:
		6083	for (i = 0; i < n; i++) {
		6084	rgba[i][ACOMP] = 1;
		6085	}
		6086	break;
		6087	case GL_RG:
		6088	for (i = 0; i < n; i++) {
		6089	rgba[i][BCOMP] = 0;
		6090	rgba[i][ACOMP] = 1;
		6091	}
		6092	break;
		6093	case GL_RED:
		6094	for (i = 0; i < n; i++) {
		6095	rgba[i][GCOMP] = 0;
		6096	rgba[i][BCOMP] = 0;
		6097	rgba[i][ACOMP] = 1;
		6098	}
		6099	default:
		6100	/* no-op */
		6101	;
		6102	}
		6103	}
		6104
		6105

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/Mesa/src/mesa/main/pack.c – Rev 4826