WebSVN – Kolibri OS – Blame – /programs/develop/libraries/Mesa/src/mesa/main/pack.c

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

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/Mesa/src/mesa/main/pack.c – Rev 1901