Context Navigation

source: trunk/src/opengl/mesa/image.c

Visit:

Last change on this file was 3598, checked in by jeroen, 25 years ago
* empty log message *
File size: 99.3 KB

Rev	Line
[3598]	1	/* $Id: image.c,v 1.3 2000-05-23 20:40:37 jeroen Exp $ */
[2938]	2
	3	/*
	4	* Mesa 3-D graphics library
[3598]	5	* Version: 3.3
[2938]	6	*
	7	* Copyright (C) 1999 Brian Paul All Rights Reserved.
	8	*
	9	* Permission is hereby granted, free of charge, to any person obtaining a
	10	* copy of this software and associated documentation files (the "Software"),
	11	* to deal in the Software without restriction, including without limitation
	12	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	13	* and/or sell copies of the Software, and to permit persons to whom the
	14	* Software is furnished to do so, subject to the following conditions:
	15	*
	16	* The above copyright notice and this permission notice shall be included
	17	* in all copies or substantial portions of the Software.
	18	*
	19	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
	20	* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	21	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	22	* BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
	23	* AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
	24	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
	25	*/
	26
	27
	28	#ifdef PC_HEADER
	29	#include "all.h"
	30	#else
[3598]	31	#include "glheader.h"
[2962]	32	#include "types.h"
[2938]	33	#include "context.h"
[3598]	34	#include "mem.h"
[2938]	35	#include "image.h"
	36	#include "macros.h"
	37	#include "mmath.h"
	38	#include "pixel.h"
	39	#endif
	40
	41
	42
	43	/*
[3598]	44	* These are the image packing parameters for Mesa's internal images.
	45	* That is, _mesa_unpack_image() returns image data in this format.
	46	* When we execute image commands (glDrawPixels, glTexImage, etc)
	47	* from within display lists we have to be sure to set the current
	48	* unpacking params to these values!
	49	*/
	50	const struct gl_pixelstore_attrib _mesa_native_packing = {
	51	1, /* Alignment */
	52	0, /* RowLength */
	53	0, /* SkipPixels */
	54	0, /* SkipRows */
	55	0, /* ImageHeight */
	56	0, /* SkipImages */
	57	GL_FALSE, /* SwapBytes */
	58	GL_FALSE /* LsbFirst */
	59	};
	60
	61
	62
	63	/*
[2938]	64	* Flip the 8 bits in each byte of the given array.
	65	*/
[3598]	66	static void
	67	flip_bytes( GLubyte *p, GLuint n )
[2938]	68	{
	69	register GLuint i, a, b;
	70
	71	for (i=0;i<n;i++) {
	72	b = (GLuint) p[i];
	73	a = ((b & 0x01) << 7) \|
[3598]	74	((b & 0x02) << 5) \|
	75	((b & 0x04) << 3) \|
	76	((b & 0x08) << 1) \|
	77	((b & 0x10) >> 1) \|
	78	((b & 0x20) >> 3) \|
	79	((b & 0x40) >> 5) \|
	80	((b & 0x80) >> 7);
[2938]	81	p[i] = (GLubyte) a;
	82	}
	83	}
	84
	85
	86	/*
	87	* Flip the order of the 2 bytes in each word in the given array.
	88	*/
[3598]	89	void
	90	_mesa_swap2( GLushort *p, GLuint n )
[2938]	91	{
	92	register GLuint i;
	93
	94	for (i=0;i<n;i++) {
	95	p[i] = (p[i] >> 8) \| ((p[i] << 8) & 0xff00);
	96	}
	97	}
	98
	99
	100
	101	/*
	102	* Flip the order of the 4 bytes in each word in the given array.
	103	*/
[3598]	104	void
	105	_mesa_swap4( GLuint *p, GLuint n )
[2938]	106	{
	107	register GLuint i, a, b;
	108
	109	for (i=0;i<n;i++) {
	110	b = p[i];
	111	a = (b >> 24)
[3598]	112	\| ((b >> 8) & 0xff00)
	113	\| ((b << 8) & 0xff0000)
	114	\| ((b << 24) & 0xff000000);
[2938]	115	p[i] = a;
	116	}
	117	}
	118
	119
	120
	121
	122	/*
	123	* Return the size, in bytes, of the given GL datatype.
	124	* Return 0 if GL_BITMAP.
	125	* Return -1 if invalid type enum.
	126	*/
[3598]	127	GLint _mesa_sizeof_type( GLenum type )
[2938]	128	{
	129	switch (type) {
	130	case GL_BITMAP:
[3598]	131	return 0;
[2938]	132	case GL_UNSIGNED_BYTE:
	133	return sizeof(GLubyte);
	134	case GL_BYTE:
[3598]	135	return sizeof(GLbyte);
[2938]	136	case GL_UNSIGNED_SHORT:
[3598]	137	return sizeof(GLushort);
[2938]	138	case GL_SHORT:
[3598]	139	return sizeof(GLshort);
[2938]	140	case GL_UNSIGNED_INT:
[3598]	141	return sizeof(GLuint);
[2938]	142	case GL_INT:
[3598]	143	return sizeof(GLint);
[2938]	144	case GL_FLOAT:
[3598]	145	return sizeof(GLfloat);
[2938]	146	default:
	147	return -1;
	148	}
	149	}
	150
	151
	152	/*
[3598]	153	* Same as _mesa_sizeof_packed_type() but we also accept the
[2938]	154	* packed pixel format datatypes.
	155	*/
[3598]	156	GLint _mesa_sizeof_packed_type( GLenum type )
[2938]	157	{
	158	switch (type) {
	159	case GL_BITMAP:
[3598]	160	return 0;
[2938]	161	case GL_UNSIGNED_BYTE:
	162	return sizeof(GLubyte);
	163	case GL_BYTE:
[3598]	164	return sizeof(GLbyte);
[2938]	165	case GL_UNSIGNED_SHORT:
[3598]	166	return sizeof(GLushort);
[2938]	167	case GL_SHORT:
[3598]	168	return sizeof(GLshort);
[2938]	169	case GL_UNSIGNED_INT:
[3598]	170	return sizeof(GLuint);
[2938]	171	case GL_INT:
[3598]	172	return sizeof(GLint);
[2938]	173	case GL_FLOAT:
[3598]	174	return sizeof(GLfloat);
[2938]	175	case GL_UNSIGNED_BYTE_3_3_2:
	176	return sizeof(GLubyte);
	177	case GL_UNSIGNED_BYTE_2_3_3_REV:
	178	return sizeof(GLubyte);
	179	case GL_UNSIGNED_SHORT_5_6_5:
	180	return sizeof(GLshort);
	181	case GL_UNSIGNED_SHORT_5_6_5_REV:
	182	return sizeof(GLshort);
	183	case GL_UNSIGNED_SHORT_4_4_4_4:
	184	return sizeof(GLshort);
	185	case GL_UNSIGNED_SHORT_4_4_4_4_REV:
	186	return sizeof(GLshort);
	187	case GL_UNSIGNED_SHORT_5_5_5_1:
	188	return sizeof(GLshort);
	189	case GL_UNSIGNED_SHORT_1_5_5_5_REV:
	190	return sizeof(GLshort);
	191	case GL_UNSIGNED_INT_8_8_8_8:
	192	return sizeof(GLuint);
	193	case GL_UNSIGNED_INT_8_8_8_8_REV:
	194	return sizeof(GLuint);
	195	case GL_UNSIGNED_INT_10_10_10_2:
	196	return sizeof(GLuint);
	197	case GL_UNSIGNED_INT_2_10_10_10_REV:
	198	return sizeof(GLuint);
	199	default:
	200	return -1;
	201	}
	202	}
	203
	204
	205
	206	/*
	207	* Return the number of components in a GL enum pixel type.
	208	* Return -1 if bad format.
	209	*/
[3598]	210	GLint _mesa_components_in_format( GLenum format )
[2938]	211	{
	212	switch (format) {
	213	case GL_COLOR_INDEX:
	214	case GL_COLOR_INDEX1_EXT:
	215	case GL_COLOR_INDEX2_EXT:
	216	case GL_COLOR_INDEX4_EXT:
	217	case GL_COLOR_INDEX8_EXT:
	218	case GL_COLOR_INDEX12_EXT:
	219	case GL_COLOR_INDEX16_EXT:
	220	case GL_STENCIL_INDEX:
	221	case GL_DEPTH_COMPONENT:
	222	case GL_RED:
	223	case GL_GREEN:
	224	case GL_BLUE:
	225	case GL_ALPHA:
	226	case GL_LUMINANCE:
	227	return 1;
	228	case GL_LUMINANCE_ALPHA:
[3598]	229	return 2;
[2938]	230	case GL_RGB:
[3598]	231	return 3;
[2938]	232	case GL_RGBA:
[3598]	233	return 4;
[2938]	234	case GL_BGR:
[3598]	235	return 3;
[2938]	236	case GL_BGRA:
[3598]	237	return 4;
[2938]	238	case GL_ABGR_EXT:
	239	return 4;
	240	default:
	241	return -1;
	242	}
	243	}
	244
	245
	246	/*
	247	* Return bytes per pixel for given format and type
	248	* Return -1 if bad format or type.
	249	*/
[3598]	250	GLint _mesa_bytes_per_pixel( GLenum format, GLenum type )
[2938]	251	{
[3598]	252	GLint comps = _mesa_components_in_format( format );
[2938]	253	if (comps < 0)
	254	return -1;
	255
	256	switch (type) {
	257	case GL_BITMAP:
	258	return 0; /* special case */
	259	case GL_BYTE:
	260	case GL_UNSIGNED_BYTE:
	261	return comps * sizeof(GLubyte);
	262	case GL_SHORT:
	263	case GL_UNSIGNED_SHORT:
	264	return comps * sizeof(GLshort);
	265	case GL_INT:
	266	case GL_UNSIGNED_INT:
	267	return comps * sizeof(GLint);
	268	case GL_FLOAT:
	269	return comps * sizeof(GLfloat);
	270	case GL_UNSIGNED_BYTE_3_3_2:
	271	case GL_UNSIGNED_BYTE_2_3_3_REV:
	272	if (format == GL_RGB \|\| format == GL_BGR)
	273	return sizeof(GLubyte);
	274	else
	275	return -1; /* error */
	276	case GL_UNSIGNED_SHORT_5_6_5:
	277	case GL_UNSIGNED_SHORT_5_6_5_REV:
	278	if (format == GL_RGB \|\| format == GL_BGR)
	279	return sizeof(GLshort);
	280	else
	281	return -1; /* error */
	282	case GL_UNSIGNED_SHORT_4_4_4_4:
	283	case GL_UNSIGNED_SHORT_4_4_4_4_REV:
	284	case GL_UNSIGNED_SHORT_5_5_5_1:
	285	case GL_UNSIGNED_SHORT_1_5_5_5_REV:
	286	if (format == GL_RGBA \|\| format == GL_BGRA \|\| format == GL_ABGR_EXT)
	287	return sizeof(GLushort);
	288	else
	289	return -1;
	290	case GL_UNSIGNED_INT_8_8_8_8:
	291	case GL_UNSIGNED_INT_8_8_8_8_REV:
	292	case GL_UNSIGNED_INT_10_10_10_2:
	293	case GL_UNSIGNED_INT_2_10_10_10_REV:
	294	if (format == GL_RGBA \|\| format == GL_BGRA \|\| format == GL_ABGR_EXT)
	295	return sizeof(GLuint);
	296	else
	297	return -1;
	298	default:
	299	return -1;
	300	}
	301	}
	302
	303
	304	/*
	305	* Test if the given pixel format and type are legal.
	306	* Return GL_TRUE for legal, GL_FALSE for illegal.
	307	*/
[3598]	308	GLboolean
	309	_mesa_is_legal_format_and_type( GLenum format, GLenum type )
[2938]	310	{
	311	switch (format) {
	312	case GL_COLOR_INDEX:
	313	case GL_STENCIL_INDEX:
	314	switch (type) {
	315	case GL_BITMAP:
	316	case GL_BYTE:
	317	case GL_UNSIGNED_BYTE:
	318	case GL_SHORT:
	319	case GL_UNSIGNED_SHORT:
	320	case GL_INT:
	321	case GL_UNSIGNED_INT:
	322	case GL_FLOAT:
	323	return GL_TRUE;
	324	default:
	325	return GL_FALSE;
	326	}
	327	case GL_RED:
	328	case GL_GREEN:
	329	case GL_BLUE:
	330	case GL_ALPHA:
	331	case GL_LUMINANCE:
	332	case GL_LUMINANCE_ALPHA:
	333	case GL_DEPTH_COMPONENT:
	334	case GL_BGR:
	335	switch (type) {
	336	case GL_BYTE:
	337	case GL_UNSIGNED_BYTE:
	338	case GL_SHORT:
	339	case GL_UNSIGNED_SHORT:
	340	case GL_INT:
	341	case GL_UNSIGNED_INT:
	342	case GL_FLOAT:
	343	return GL_TRUE;
	344	default:
	345	return GL_FALSE;
	346	}
	347	case GL_RGB:
	348	switch (type) {
	349	case GL_BYTE:
	350	case GL_UNSIGNED_BYTE:
	351	case GL_SHORT:
	352	case GL_UNSIGNED_SHORT:
	353	case GL_INT:
	354	case GL_UNSIGNED_INT:
	355	case GL_FLOAT:
	356	case GL_UNSIGNED_BYTE_3_3_2:
	357	case GL_UNSIGNED_BYTE_2_3_3_REV:
	358	case GL_UNSIGNED_SHORT_5_6_5:
	359	case GL_UNSIGNED_SHORT_5_6_5_REV:
	360	return GL_TRUE;
	361	default:
	362	return GL_FALSE;
	363	}
	364	case GL_RGBA:
	365	case GL_BGRA:
	366	case GL_ABGR_EXT:
	367	switch (type) {
	368	case GL_BYTE:
	369	case GL_UNSIGNED_BYTE:
	370	case GL_SHORT:
	371	case GL_UNSIGNED_SHORT:
	372	case GL_INT:
	373	case GL_UNSIGNED_INT:
	374	case GL_FLOAT:
	375	case GL_UNSIGNED_SHORT_4_4_4_4:
	376	case GL_UNSIGNED_SHORT_4_4_4_4_REV:
	377	case GL_UNSIGNED_SHORT_5_5_5_1:
	378	case GL_UNSIGNED_SHORT_1_5_5_5_REV:
	379	case GL_UNSIGNED_INT_8_8_8_8:
	380	case GL_UNSIGNED_INT_8_8_8_8_REV:
	381	case GL_UNSIGNED_INT_10_10_10_2:
	382	case GL_UNSIGNED_INT_2_10_10_10_REV:
	383	return GL_TRUE;
	384	default:
	385	return GL_FALSE;
	386	}
	387	default:
	388	; /* fall-through */
	389	}
	390	return GL_FALSE;
	391	}
	392
	393
	394
	395	/*
	396	* Return the address of a pixel in an image (actually a volume).
	397	* Pixel unpacking/packing parameters are observed according to 'packing'.
	398	* Input: image - start of image data
	399	* width, height - size of image
	400	* format - image format
	401	* type - pixel component type
	402	* packing - the pixelstore attributes
	403	* img - which image in the volume (0 for 1D or 2D images)
	404	* row, column - location of pixel in the image
	405	* Return: address of pixel at (image,row,column) in image or NULL if error.
	406	*/
[3598]	407	GLvoid *
	408	_mesa_image_address( const struct gl_pixelstore_attrib *packing,
	409	const GLvoid *image, GLsizei width,
	410	GLsizei height, GLenum format, GLenum type,
	411	GLint img, GLint row, GLint column )
[2938]	412	{
	413	GLint alignment; /* 1, 2 or 4 */
	414	GLint pixels_per_row;
	415	GLint rows_per_image;
	416	GLint skiprows;
	417	GLint skippixels;
	418	GLint skipimages; /* for 3-D volume images */
	419	GLubyte *pixel_addr;
	420
	421	alignment = packing->Alignment;
	422	if (packing->RowLength > 0) {
	423	pixels_per_row = packing->RowLength;
	424	}
	425	else {
	426	pixels_per_row = width;
	427	}
	428	if (packing->ImageHeight > 0) {
	429	rows_per_image = packing->ImageHeight;
	430	}
	431	else {
	432	rows_per_image = height;
	433	}
	434	skiprows = packing->SkipRows;
	435	skippixels = packing->SkipPixels;
	436	skipimages = packing->SkipImages;
	437
	438	if (type==GL_BITMAP) {
	439	/* BITMAP data */
	440	GLint comp_per_pixel; /* components per pixel */
	441	GLint bytes_per_comp; /* bytes per component */
	442	GLint bytes_per_row;
	443	GLint bytes_per_image;
	444
	445	/* Compute bytes per component */
[3598]	446	bytes_per_comp = _mesa_sizeof_packed_type( type );
[2938]	447	if (bytes_per_comp<0) {
	448	return NULL;
	449	}
	450
	451	/* Compute number of components per pixel */
[3598]	452	comp_per_pixel = _mesa_components_in_format( format );
[2938]	453	if (comp_per_pixel<0 && type != GL_BITMAP) {
	454	return NULL;
	455	}
	456
	457	bytes_per_row = alignment
	458	* CEILING( comp_per_pixelpixels_per_row, 8alignment );
	459
	460	bytes_per_image = bytes_per_row * rows_per_image;
	461
	462	pixel_addr = (GLubyte *) image
	463	+ (skipimages + img) * bytes_per_image
	464	+ (skiprows + row) * bytes_per_row
	465	+ (skippixels + column) / 8;
	466	}
	467	else {
	468	/* Non-BITMAP data */
	469	GLint bytes_per_pixel, bytes_per_row, remainder, bytes_per_image;
	470
[3598]	471	bytes_per_pixel = _mesa_bytes_per_pixel( format, type );
[2938]	472
	473	/* The pixel type and format should have been error checked earlier */
[3598]	474	ASSERT(bytes_per_pixel > 0);
[2938]	475
	476	bytes_per_row = pixels_per_row * bytes_per_pixel;
	477	remainder = bytes_per_row % alignment;
	478	if (remainder > 0)
	479	bytes_per_row += (alignment - remainder);
	480
	481	ASSERT(bytes_per_row % alignment == 0);
	482
	483	bytes_per_image = bytes_per_row * rows_per_image;
	484
	485	/* compute final pixel address */
	486	pixel_addr = (GLubyte *) image
	487	+ (skipimages + img) * bytes_per_image
	488	+ (skiprows + row) * bytes_per_row
	489	+ (skippixels + column) * bytes_per_pixel;
	490	}
	491
	492	return (GLvoid *) pixel_addr;
	493	}
	494
	495
	496
	497	/*
[3598]	498	* Compute the stride between image rows (in bytes) for the given
	499	* pixel packing parameters and image width, format and type.
[2938]	500	*/
[3598]	501	GLint
	502	_mesa_image_row_stride( const struct gl_pixelstore_attrib *packing,
	503	GLint width, GLenum format, GLenum type )
[2938]	504	{
[3598]	505	ASSERT(packing);
	506	if (type == GL_BITMAP) {
	507	/* BITMAP data */
	508	if (packing->RowLength == 0) {
	509	GLint bytes = (width + 7) / 8;
	510	return bytes;
[2938]	511	}
	512	else {
[3598]	513	GLint bytes = (packing->RowLength + 7) / 8;
	514	return bytes;
[2938]	515	}
	516	}
	517	else {
[3598]	518	/* Non-BITMAP data */
	519	const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
	520	if (bytesPerPixel <= 0)
	521	return -1; /* error */
	522	if (packing->RowLength == 0) {
	523	GLint bytes = bytesPerPixel * width;
	524	return bytes;
[2938]	525	}
	526	else {
[3598]	527	GLint bytes = bytesPerPixel * packing->RowLength;
	528	return bytes;
[2938]	529	}
	530	}
	531	}
	532
	533
	534
	535	/*
	536	* Unpack a 32x32 pixel polygon stipple from user memory using the
	537	* current pixel unpack settings.
	538	*/
[3598]	539	void
	540	_mesa_unpack_polygon_stipple( const GLubyte *pattern, GLuint dest[32],
	541	const struct gl_pixelstore_attrib *unpacking )
[2938]	542	{
[3598]	543	GLubyte ptrn = (GLubyte ) _mesa_unpack_bitmap( 32, 32, pattern, unpacking );
	544	if (ptrn) {
	545	/* Convert pattern from GLubytes to GLuints and handle big/little
	546	* endian differences
	547	*/
	548	GLubyte *p = ptrn;
	549	GLint i;
	550	for (i = 0; i < 32; i++) {
	551	dest[i] = (p[0] << 24)
	552	\| (p[1] << 16)
	553	\| (p[2] << 8)
	554	\| (p[3] );
	555	p += 4;
	556	}
	557	FREE(ptrn);
[2938]	558	}
	559	}
	560
	561
	562
	563	/*
	564	* Pack polygon stipple into user memory given current pixel packing
	565	* settings.
	566	*/
[3598]	567	void
	568	_mesa_pack_polygon_stipple( const GLuint pattern[32], GLubyte *dest,
	569	const struct gl_pixelstore_attrib *packing )
[2938]	570	{
[3598]	571	/* Convert pattern from GLuints to GLubytes to handle big/little
	572	* endian differences.
	573	*/
	574	GLubyte ptrn[32*4];
[2938]	575	GLint i;
	576	for (i = 0; i < 32; i++) {
[3598]	577	ptrn[i * 4 + 0] = (GLubyte) ((pattern[i] >> 24) & 0xff);
	578	ptrn[i * 4 + 1] = (GLubyte) ((pattern[i] >> 16) & 0xff);
	579	ptrn[i * 4 + 2] = (GLubyte) ((pattern[i] >> 8 ) & 0xff);
	580	ptrn[i * 4 + 3] = (GLubyte) ((pattern[i] ) & 0xff);
[2938]	581	}
	582
[3598]	583	_mesa_pack_bitmap(32, 32, ptrn, dest, packing);
[2938]	584	}
	585
	586
	587
	588	/*
	589	* Pack the given RGBA span into client memory at 'dest' address
	590	* in the given pixel format and type.
	591	* Optionally apply the enabled pixel transfer ops.
	592	* Pack into memory using the given packing params struct.
	593	* This is used by glReadPixels and glGetTexImage?D()
	594	* Input: ctx - the context
	595	* n - number of pixels in the span
	596	* rgba - the pixels
	597	* format - dest packing format
	598	* type - dest packing datatype
	599	* destination - destination packing address
	600	* packing - pixel packing parameters
	601	* applyTransferOps - apply scale/bias/lookup-table ops?
	602	*/
[3598]	603	void
	604	_mesa_pack_rgba_span( const GLcontext *ctx,
	605	GLuint n, CONST GLubyte rgba[][4],
	606	GLenum format, GLenum type, GLvoid *destination,
	607	const struct gl_pixelstore_attrib *packing,
	608	GLboolean applyTransferOps )
[2938]	609	{
[3598]	610	applyTransferOps &= (ctx->Pixel.ScaleOrBiasRGBA \|\| ctx->Pixel.MapColorFlag);
	611
[2938]	612	/* Test for optimized case first */
[3598]	613	if (!applyTransferOps && format == GL_RGBA && type == GL_UNSIGNED_BYTE) {
[2938]	614	/* common simple case */
	615	MEMCPY( destination, rgba, n * 4 * sizeof(GLubyte) );
	616	}
[3598]	617	else if (!applyTransferOps && format == GL_RGB && type == GL_UNSIGNED_BYTE) {
[2938]	618	/* common simple case */
	619	GLint i;
	620	GLubyte dest = (GLubyte ) destination;
	621	for (i = 0; i < n; i++) {
	622	dest[0] = rgba[i][RCOMP];
	623	dest[1] = rgba[i][GCOMP];
	624	dest[2] = rgba[i][BCOMP];
	625	dest += 3;
	626	}
	627	}
	628	else {
[3598]	629	/* general solution */
[2938]	630	GLfloat red[MAX_WIDTH], green[MAX_WIDTH], blue[MAX_WIDTH];
	631	GLfloat alpha[MAX_WIDTH], luminance[MAX_WIDTH];
	632	const GLfloat rscale = 1.0F / 255.0F;
	633	const GLfloat gscale = 1.0F / 255.0F;
	634	const GLfloat bscale = 1.0F / 255.0F;
	635	const GLfloat ascale = 1.0F / 255.0F;
[3598]	636	const GLint comps = _mesa_components_in_format(format);
[2938]	637	GLuint i;
	638
[3598]	639	ASSERT(n <= MAX_WIDTH);
[2938]	640
	641	/* convert color components to floating point */
	642	for (i=0;i<n;i++) {
	643	red[i] = rgba[i][RCOMP] * rscale;
	644	green[i] = rgba[i][GCOMP] * gscale;
	645	blue[i] = rgba[i][BCOMP] * bscale;
	646	alpha[i] = rgba[i][ACOMP] * ascale;
	647	}
	648
	649	/*
	650	* Apply scale, bias and lookup-tables if enabled.
	651	*/
	652	if (applyTransferOps) {
	653	if (ctx->Pixel.ScaleOrBiasRGBA) {
	654	gl_scale_and_bias_color( ctx, n, red, green, blue, alpha );
	655	}
	656	if (ctx->Pixel.MapColorFlag) {
	657	gl_map_color( ctx, n, red, green, blue, alpha );
	658	}
	659	}
	660
	661	if (format==GL_LUMINANCE \|\| format==GL_LUMINANCE_ALPHA) {
	662	for (i=0;i<n;i++) {
	663	GLfloat sum = red[i] + green[i] + blue[i];
	664	luminance[i] = CLAMP( sum, 0.0F, 1.0F );
	665	}
	666	}
	667
	668	/*
	669	* Pack/store the pixels. Ugh! Lots of cases!!!
	670	*/
	671	switch (type) {
	672	case GL_UNSIGNED_BYTE:
	673	{
	674	GLubyte dst = (GLubyte ) destination;
	675	switch (format) {
	676	case GL_RED:
	677	for (i=0;i<n;i++)
	678	dst[i] = FLOAT_TO_UBYTE(red[i]);
	679	break;
	680	case GL_GREEN:
	681	for (i=0;i<n;i++)
	682	dst[i] = FLOAT_TO_UBYTE(green[i]);
	683	break;
	684	case GL_BLUE:
	685	for (i=0;i<n;i++)
	686	dst[i] = FLOAT_TO_UBYTE(blue[i]);
	687	break;
	688	case GL_ALPHA:
	689	for (i=0;i<n;i++)
	690	dst[i] = FLOAT_TO_UBYTE(alpha[i]);
	691	break;
	692	case GL_LUMINANCE:
	693	for (i=0;i<n;i++)
	694	dst[i] = FLOAT_TO_UBYTE(luminance[i]);
	695	break;
	696	case GL_LUMINANCE_ALPHA:
	697	for (i=0;i<n;i++) {
	698	dst[i*2+0] = FLOAT_TO_UBYTE(luminance[i]);
	699	dst[i*2+1] = FLOAT_TO_UBYTE(alpha[i]);
	700	}
	701	break;
	702	case GL_RGB:
	703	for (i=0;i<n;i++) {
	704	dst[i*3+0] = FLOAT_TO_UBYTE(red[i]);
	705	dst[i*3+1] = FLOAT_TO_UBYTE(green[i]);
	706	dst[i*3+2] = FLOAT_TO_UBYTE(blue[i]);
	707	}
	708	break;
	709	case GL_RGBA:
	710	for (i=0;i<n;i++) {
	711	dst[i*4+0] = FLOAT_TO_UBYTE(red[i]);
	712	dst[i*4+1] = FLOAT_TO_UBYTE(green[i]);
	713	dst[i*4+2] = FLOAT_TO_UBYTE(blue[i]);
	714	dst[i*4+3] = FLOAT_TO_UBYTE(alpha[i]);
	715	}
	716	break;
	717	case GL_BGR:
	718	for (i=0;i<n;i++) {
	719	dst[i*3+0] = FLOAT_TO_UBYTE(blue[i]);
	720	dst[i*3+1] = FLOAT_TO_UBYTE(green[i]);
	721	dst[i*3+2] = FLOAT_TO_UBYTE(red[i]);
	722	}
	723	break;
	724	case GL_BGRA:
	725	for (i=0;i<n;i++) {
	726	dst[i*4+0] = FLOAT_TO_UBYTE(blue[i]);
	727	dst[i*4+1] = FLOAT_TO_UBYTE(green[i]);
	728	dst[i*4+2] = FLOAT_TO_UBYTE(red[i]);
	729	dst[i*4+3] = FLOAT_TO_UBYTE(alpha[i]);
	730	}
	731	break;
	732	case GL_ABGR_EXT:
	733	for (i=0;i<n;i++) {
	734	dst[i*4+0] = FLOAT_TO_UBYTE(alpha[i]);
	735	dst[i*4+1] = FLOAT_TO_UBYTE(blue[i]);
	736	dst[i*4+2] = FLOAT_TO_UBYTE(green[i]);
	737	dst[i*4+3] = FLOAT_TO_UBYTE(red[i]);
	738	}
	739	break;
	740	default:
[3598]	741	gl_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
[2938]	742	}
[3598]	743	}
	744	break;
	745	case GL_BYTE:
[2938]	746	{
	747	GLbyte dst = (GLbyte ) destination;
	748	switch (format) {
	749	case GL_RED:
	750	for (i=0;i<n;i++)
	751	dst[i] = FLOAT_TO_BYTE(red[i]);
	752	break;
	753	case GL_GREEN:
	754	for (i=0;i<n;i++)
	755	dst[i] = FLOAT_TO_BYTE(green[i]);
	756	break;
	757	case GL_BLUE:
	758	for (i=0;i<n;i++)
	759	dst[i] = FLOAT_TO_BYTE(blue[i]);
	760	break;
	761	case GL_ALPHA:
	762	for (i=0;i<n;i++)
	763	dst[i] = FLOAT_TO_BYTE(alpha[i]);
	764	break;
	765	case GL_LUMINANCE:
	766	for (i=0;i<n;i++)
	767	dst[i] = FLOAT_TO_BYTE(luminance[i]);
	768	break;
	769	case GL_LUMINANCE_ALPHA:
	770	for (i=0;i<n;i++) {
	771	dst[i*2+0] = FLOAT_TO_BYTE(luminance[i]);
	772	dst[i*2+1] = FLOAT_TO_BYTE(alpha[i]);
	773	}
	774	break;
	775	case GL_RGB:
	776	for (i=0;i<n;i++) {
	777	dst[i*3+0] = FLOAT_TO_BYTE(red[i]);
	778	dst[i*3+1] = FLOAT_TO_BYTE(green[i]);
	779	dst[i*3+2] = FLOAT_TO_BYTE(blue[i]);
	780	}
	781	break;
	782	case GL_RGBA:
	783	for (i=0;i<n;i++) {
	784	dst[i*4+0] = FLOAT_TO_BYTE(red[i]);
	785	dst[i*4+1] = FLOAT_TO_BYTE(green[i]);
	786	dst[i*4+2] = FLOAT_TO_BYTE(blue[i]);
	787	dst[i*4+3] = FLOAT_TO_BYTE(alpha[i]);
	788	}
	789	break;
	790	case GL_BGR:
	791	for (i=0;i<n;i++) {
	792	dst[i*3+0] = FLOAT_TO_BYTE(blue[i]);
	793	dst[i*3+1] = FLOAT_TO_BYTE(green[i]);
	794	dst[i*3+2] = FLOAT_TO_BYTE(red[i]);
	795	}
	796	break;
	797	case GL_BGRA:
	798	for (i=0;i<n;i++) {
	799	dst[i*4+0] = FLOAT_TO_BYTE(blue[i]);
	800	dst[i*4+1] = FLOAT_TO_BYTE(green[i]);
	801	dst[i*4+2] = FLOAT_TO_BYTE(red[i]);
	802	dst[i*4+3] = FLOAT_TO_BYTE(alpha[i]);
	803	}
	804	case GL_ABGR_EXT:
	805	for (i=0;i<n;i++) {
	806	dst[i*4+0] = FLOAT_TO_BYTE(alpha[i]);
	807	dst[i*4+1] = FLOAT_TO_BYTE(blue[i]);
	808	dst[i*4+2] = FLOAT_TO_BYTE(green[i]);
	809	dst[i*4+3] = FLOAT_TO_BYTE(red[i]);
	810	}
	811	break;
	812	default:
[3598]	813	gl_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
[2938]	814	}
	815	}
[3598]	816	break;
	817	case GL_UNSIGNED_SHORT:
[2938]	818	{
	819	GLushort dst = (GLushort ) destination;
	820	switch (format) {
	821	case GL_RED:
	822	for (i=0;i<n;i++)
	823	dst[i] = FLOAT_TO_USHORT(red[i]);
	824	break;
	825	case GL_GREEN:
	826	for (i=0;i<n;i++)
	827	dst[i] = FLOAT_TO_USHORT(green[i]);
	828	break;
	829	case GL_BLUE:
	830	for (i=0;i<n;i++)
	831	dst[i] = FLOAT_TO_USHORT(blue[i]);
	832	break;
	833	case GL_ALPHA:
	834	for (i=0;i<n;i++)
	835	dst[i] = FLOAT_TO_USHORT(alpha[i]);
	836	break;
	837	case GL_LUMINANCE:
	838	for (i=0;i<n;i++)
	839	dst[i] = FLOAT_TO_USHORT(luminance[i]);
	840	break;
	841	case GL_LUMINANCE_ALPHA:
	842	for (i=0;i<n;i++) {
	843	dst[i*2+0] = FLOAT_TO_USHORT(luminance[i]);
	844	dst[i*2+1] = FLOAT_TO_USHORT(alpha[i]);
	845	}
	846	break;
	847	case GL_RGB:
	848	for (i=0;i<n;i++) {
	849	dst[i*3+0] = FLOAT_TO_USHORT(red[i]);
	850	dst[i*3+1] = FLOAT_TO_USHORT(green[i]);
	851	dst[i*3+2] = FLOAT_TO_USHORT(blue[i]);
	852	}
	853	break;
	854	case GL_RGBA:
	855	for (i=0;i<n;i++) {
	856	dst[i*4+0] = FLOAT_TO_USHORT(red[i]);
	857	dst[i*4+1] = FLOAT_TO_USHORT(green[i]);
	858	dst[i*4+2] = FLOAT_TO_USHORT(blue[i]);
	859	dst[i*4+3] = FLOAT_TO_USHORT(alpha[i]);
	860	}
	861	break;
	862	case GL_BGR:
	863	for (i=0;i<n;i++) {
	864	dst[i*3+0] = FLOAT_TO_USHORT(blue[i]);
	865	dst[i*3+1] = FLOAT_TO_USHORT(green[i]);
	866	dst[i*3+2] = FLOAT_TO_USHORT(red[i]);
	867	}
	868	break;
	869	case GL_BGRA:
	870	for (i=0;i<n;i++) {
	871	dst[i*4+0] = FLOAT_TO_USHORT(blue[i]);
	872	dst[i*4+1] = FLOAT_TO_USHORT(green[i]);
	873	dst[i*4+2] = FLOAT_TO_USHORT(red[i]);
	874	dst[i*4+3] = FLOAT_TO_USHORT(alpha[i]);
	875	}
	876	break;
	877	case GL_ABGR_EXT:
	878	for (i=0;i<n;i++) {
	879	dst[i*4+0] = FLOAT_TO_USHORT(alpha[i]);
	880	dst[i*4+1] = FLOAT_TO_USHORT(blue[i]);
	881	dst[i*4+2] = FLOAT_TO_USHORT(green[i]);
	882	dst[i*4+3] = FLOAT_TO_USHORT(red[i]);
	883	}
	884	break;
	885	default:
[3598]	886	gl_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
[2938]	887	}
	888	if (packing->SwapBytes) {
[3598]	889	_mesa_swap2( (GLushort ) dst, n comps);
[2938]	890	}
	891	}
[3598]	892	break;
	893	case GL_SHORT:
[2938]	894	{
	895	GLshort dst = (GLshort ) destination;
	896	switch (format) {
	897	case GL_RED:
	898	for (i=0;i<n;i++)
	899	dst[i] = FLOAT_TO_SHORT(red[i]);
	900	break;
	901	case GL_GREEN:
	902	for (i=0;i<n;i++)
	903	dst[i] = FLOAT_TO_SHORT(green[i]);
	904	break;
	905	case GL_BLUE:
	906	for (i=0;i<n;i++)
	907	dst[i] = FLOAT_TO_SHORT(blue[i]);
	908	break;
	909	case GL_ALPHA:
	910	for (i=0;i<n;i++)
	911	dst[i] = FLOAT_TO_SHORT(alpha[i]);
	912	break;
	913	case GL_LUMINANCE:
	914	for (i=0;i<n;i++)
	915	dst[i] = FLOAT_TO_SHORT(luminance[i]);
	916	break;
	917	case GL_LUMINANCE_ALPHA:
	918	for (i=0;i<n;i++) {
	919	dst[i*2+0] = FLOAT_TO_SHORT(luminance[i]);
	920	dst[i*2+1] = FLOAT_TO_SHORT(alpha[i]);
	921	}
	922	break;
	923	case GL_RGB:
	924	for (i=0;i<n;i++) {
	925	dst[i*3+0] = FLOAT_TO_SHORT(red[i]);
	926	dst[i*3+1] = FLOAT_TO_SHORT(green[i]);
	927	dst[i*3+2] = FLOAT_TO_SHORT(blue[i]);
	928	}
	929	break;
	930	case GL_RGBA:
	931	for (i=0;i<n;i++) {
	932	dst[i*4+0] = FLOAT_TO_SHORT(red[i]);
	933	dst[i*4+1] = FLOAT_TO_SHORT(green[i]);
	934	dst[i*4+2] = FLOAT_TO_SHORT(blue[i]);
	935	dst[i*4+3] = FLOAT_TO_SHORT(alpha[i]);
	936	}
	937	break;
	938	case GL_BGR:
	939	for (i=0;i<n;i++) {
	940	dst[i*3+0] = FLOAT_TO_SHORT(blue[i]);
	941	dst[i*3+1] = FLOAT_TO_SHORT(green[i]);
	942	dst[i*3+2] = FLOAT_TO_SHORT(red[i]);
	943	}
	944	break;
	945	case GL_BGRA:
	946	for (i=0;i<n;i++) {
	947	dst[i*4+0] = FLOAT_TO_SHORT(blue[i]);
	948	dst[i*4+1] = FLOAT_TO_SHORT(green[i]);
	949	dst[i*4+2] = FLOAT_TO_SHORT(red[i]);
	950	dst[i*4+3] = FLOAT_TO_SHORT(alpha[i]);
	951	}
	952	case GL_ABGR_EXT:
	953	for (i=0;i<n;i++) {
	954	dst[i*4+0] = FLOAT_TO_SHORT(alpha[i]);
	955	dst[i*4+1] = FLOAT_TO_SHORT(blue[i]);
	956	dst[i*4+2] = FLOAT_TO_SHORT(green[i]);
	957	dst[i*4+3] = FLOAT_TO_SHORT(red[i]);
	958	}
	959	break;
	960	default:
[3598]	961	gl_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
[2938]	962	}
	963	if (packing->SwapBytes) {
[3598]	964	_mesa_swap2( (GLushort ) dst, n comps );
[2938]	965	}
	966	}
[3598]	967	break;
	968	case GL_UNSIGNED_INT:
[2938]	969	{
	970	GLuint dst = (GLuint ) destination;
	971	switch (format) {
	972	case GL_RED:
	973	for (i=0;i<n;i++)
	974	dst[i] = FLOAT_TO_UINT(red[i]);
	975	break;
	976	case GL_GREEN:
	977	for (i=0;i<n;i++)
	978	dst[i] = FLOAT_TO_UINT(green[i]);
	979	break;
	980	case GL_BLUE:
	981	for (i=0;i<n;i++)
	982	dst[i] = FLOAT_TO_UINT(blue[i]);
	983	break;
	984	case GL_ALPHA:
	985	for (i=0;i<n;i++)
	986	dst[i] = FLOAT_TO_UINT(alpha[i]);
	987	break;
	988	case GL_LUMINANCE:
	989	for (i=0;i<n;i++)
	990	dst[i] = FLOAT_TO_UINT(luminance[i]);
	991	break;
	992	case GL_LUMINANCE_ALPHA:
	993	for (i=0;i<n;i++) {
	994	dst[i*2+0] = FLOAT_TO_UINT(luminance[i]);
	995	dst[i*2+1] = FLOAT_TO_UINT(alpha[i]);
	996	}
	997	break;
	998	case GL_RGB:
	999	for (i=0;i<n;i++) {
	1000	dst[i*3+0] = FLOAT_TO_UINT(red[i]);
	1001	dst[i*3+1] = FLOAT_TO_UINT(green[i]);
	1002	dst[i*3+2] = FLOAT_TO_UINT(blue[i]);
	1003	}
	1004	break;
	1005	case GL_RGBA:
	1006	for (i=0;i<n;i++) {
	1007	dst[i*4+0] = FLOAT_TO_UINT(red[i]);
	1008	dst[i*4+1] = FLOAT_TO_UINT(green[i]);
	1009	dst[i*4+2] = FLOAT_TO_UINT(blue[i]);
	1010	dst[i*4+3] = FLOAT_TO_UINT(alpha[i]);
	1011	}
	1012	break;
	1013	case GL_BGR:
	1014	for (i=0;i<n;i++) {
	1015	dst[i*3+0] = FLOAT_TO_UINT(blue[i]);
	1016	dst[i*3+1] = FLOAT_TO_UINT(green[i]);
	1017	dst[i*3+2] = FLOAT_TO_UINT(red[i]);
	1018	}
	1019	break;
	1020	case GL_BGRA:
	1021	for (i=0;i<n;i++) {
	1022	dst[i*4+0] = FLOAT_TO_UINT(blue[i]);
	1023	dst[i*4+1] = FLOAT_TO_UINT(green[i]);
	1024	dst[i*4+2] = FLOAT_TO_UINT(red[i]);
	1025	dst[i*4+3] = FLOAT_TO_UINT(alpha[i]);
	1026	}
	1027	break;
	1028	case GL_ABGR_EXT:
	1029	for (i=0;i<n;i++) {
	1030	dst[i*4+0] = FLOAT_TO_UINT(alpha[i]);
	1031	dst[i*4+1] = FLOAT_TO_UINT(blue[i]);
	1032	dst[i*4+2] = FLOAT_TO_UINT(green[i]);
	1033	dst[i*4+3] = FLOAT_TO_UINT(red[i]);
	1034	}
	1035	break;
	1036	default:
[3598]	1037	gl_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
[2938]	1038	}
	1039	if (packing->SwapBytes) {
[3598]	1040	_mesa_swap4( (GLuint ) dst, n comps );
[2938]	1041	}
	1042	}
[3598]	1043	break;
	1044	case GL_INT:
	1045	{
[2938]	1046	GLint dst = (GLint ) destination;
	1047	switch (format) {
	1048	case GL_RED:
	1049	for (i=0;i<n;i++)
	1050	dst[i] = FLOAT_TO_INT(red[i]);
	1051	break;
	1052	case GL_GREEN:
	1053	for (i=0;i<n;i++)
	1054	dst[i] = FLOAT_TO_INT(green[i]);
	1055	break;
	1056	case GL_BLUE:
	1057	for (i=0;i<n;i++)
	1058	dst[i] = FLOAT_TO_INT(blue[i]);
	1059	break;
	1060	case GL_ALPHA:
	1061	for (i=0;i<n;i++)
	1062	dst[i] = FLOAT_TO_INT(alpha[i]);
	1063	break;
	1064	case GL_LUMINANCE:
	1065	for (i=0;i<n;i++)
	1066	dst[i] = FLOAT_TO_INT(luminance[i]);
	1067	break;
	1068	case GL_LUMINANCE_ALPHA:
	1069	for (i=0;i<n;i++) {
	1070	dst[i*2+0] = FLOAT_TO_INT(luminance[i]);
	1071	dst[i*2+1] = FLOAT_TO_INT(alpha[i]);
	1072	}
	1073	break;
	1074	case GL_RGB:
	1075	for (i=0;i<n;i++) {
	1076	dst[i*3+0] = FLOAT_TO_INT(red[i]);
	1077	dst[i*3+1] = FLOAT_TO_INT(green[i]);
	1078	dst[i*3+2] = FLOAT_TO_INT(blue[i]);
	1079	}
	1080	break;
	1081	case GL_RGBA:
	1082	for (i=0;i<n;i++) {
	1083	dst[i*4+0] = FLOAT_TO_INT(red[i]);
	1084	dst[i*4+1] = FLOAT_TO_INT(green[i]);
	1085	dst[i*4+2] = FLOAT_TO_INT(blue[i]);
	1086	dst[i*4+3] = FLOAT_TO_INT(alpha[i]);
	1087	}
	1088	break;
	1089	case GL_BGR:
	1090	for (i=0;i<n;i++) {
	1091	dst[i*3+0] = FLOAT_TO_INT(blue[i]);
	1092	dst[i*3+1] = FLOAT_TO_INT(green[i]);
	1093	dst[i*3+2] = FLOAT_TO_INT(red[i]);
	1094	}
	1095	break;
	1096	case GL_BGRA:
	1097	for (i=0;i<n;i++) {
	1098	dst[i*4+0] = FLOAT_TO_INT(blue[i]);
	1099	dst[i*4+1] = FLOAT_TO_INT(green[i]);
	1100	dst[i*4+2] = FLOAT_TO_INT(red[i]);
	1101	dst[i*4+3] = FLOAT_TO_INT(alpha[i]);
	1102	}
	1103	break;
	1104	case GL_ABGR_EXT:
	1105	for (i=0;i<n;i++) {
	1106	dst[i*4+0] = FLOAT_TO_INT(alpha[i]);
	1107	dst[i*4+1] = FLOAT_TO_INT(blue[i]);
	1108	dst[i*4+2] = FLOAT_TO_INT(green[i]);
	1109	dst[i*4+3] = FLOAT_TO_INT(red[i]);
	1110	}
	1111	break;
	1112	default:
[3598]	1113	gl_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
[2938]	1114	}
[3598]	1115	if (packing->SwapBytes) {
	1116	_mesa_swap4( (GLuint ) dst, n comps );
	1117	}
	1118	}
	1119	break;
	1120	case GL_FLOAT:
	1121	{
[2938]	1122	GLfloat dst = (GLfloat ) destination;
	1123	switch (format) {
	1124	case GL_RED:
	1125	for (i=0;i<n;i++)
	1126	dst[i] = red[i];
	1127	break;
	1128	case GL_GREEN:
	1129	for (i=0;i<n;i++)
	1130	dst[i] = green[i];
	1131	break;
	1132	case GL_BLUE:
	1133	for (i=0;i<n;i++)
	1134	dst[i] = blue[i];
	1135	break;
	1136	case GL_ALPHA:
	1137	for (i=0;i<n;i++)
	1138	dst[i] = alpha[i];
	1139	break;
	1140	case GL_LUMINANCE:
	1141	for (i=0;i<n;i++)
	1142	dst[i] = luminance[i];
	1143	break;
	1144	case GL_LUMINANCE_ALPHA:
	1145	for (i=0;i<n;i++) {
	1146	dst[i*2+0] = luminance[i];
	1147	dst[i*2+1] = alpha[i];
	1148	}
	1149	break;
	1150	case GL_RGB:
	1151	for (i=0;i<n;i++) {
	1152	dst[i*3+0] = red[i];
	1153	dst[i*3+1] = green[i];
	1154	dst[i*3+2] = blue[i];
	1155	}
	1156	break;
	1157	case GL_RGBA:
	1158	for (i=0;i<n;i++) {
	1159	dst[i*4+0] = red[i];
	1160	dst[i*4+1] = green[i];
	1161	dst[i*4+2] = blue[i];
	1162	dst[i*4+3] = alpha[i];
	1163	}
	1164	break;
	1165	case GL_BGR:
	1166	for (i=0;i<n;i++) {
	1167	dst[i*3+0] = blue[i];
	1168	dst[i*3+1] = green[i];
	1169	dst[i*3+2] = red[i];
	1170	}
	1171	break;
	1172	case GL_BGRA:
	1173	for (i=0;i<n;i++) {
	1174	dst[i*4+0] = blue[i];
	1175	dst[i*4+1] = green[i];
	1176	dst[i*4+2] = red[i];
	1177	dst[i*4+3] = alpha[i];
	1178	}
	1179	break;
	1180	case GL_ABGR_EXT:
	1181	for (i=0;i<n;i++) {
	1182	dst[i*4+0] = alpha[i];
	1183	dst[i*4+1] = blue[i];
	1184	dst[i*4+2] = green[i];
	1185	dst[i*4+3] = red[i];
	1186	}
	1187	break;
	1188	default:
[3598]	1189	gl_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
[2938]	1190	}
[3598]	1191	if (packing->SwapBytes) {
	1192	_mesa_swap4( (GLuint ) dst, n comps );
	1193	}
	1194	}
	1195	break;
[2938]	1196	case GL_UNSIGNED_BYTE_3_3_2:
	1197	if (format == GL_RGB) {
	1198	GLubyte dst = (GLubyte ) destination;
	1199	for (i=0;i<n;i++) {
	1200	dst[i] = (((GLint) (red[i] * 7.0F)) << 5)
	1201	\| (((GLint) (green[i] * 7.0F)) << 2)
	1202	\| (((GLint) (blue[i] * 3.0F)) );
	1203	}
	1204	}
	1205	break;
	1206	case GL_UNSIGNED_BYTE_2_3_3_REV:
	1207	if (format == GL_RGB) {
	1208	GLubyte dst = (GLubyte ) destination;
	1209	for (i=0;i<n;i++) {
	1210	dst[i] = (((GLint) (red[i] * 7.0F)) )
	1211	\| (((GLint) (green[i] * 7.0F)) << 3)
	1212	\| (((GLint) (blue[i] * 3.0F)) << 5);
	1213	}
	1214	}
	1215	break;
	1216	case GL_UNSIGNED_SHORT_5_6_5:
	1217	if (format == GL_RGB) {
	1218	GLushort dst = (GLushort ) destination;
	1219	for (i=0;i<n;i++) {
	1220	dst[i] = (((GLint) (red[i] * 31.0F)) << 11)
	1221	\| (((GLint) (green[i] * 63.0F)) << 5)
	1222	\| (((GLint) (blue[i] * 31.0F)) );
	1223	}
	1224	}
	1225	break;
	1226	case GL_UNSIGNED_SHORT_5_6_5_REV:
	1227	if (format == GL_RGB) {
	1228	GLushort dst = (GLushort ) destination;
	1229	for (i=0;i<n;i++) {
	1230	dst[i] = (((GLint) (red[i] * 31.0F)) )
	1231	\| (((GLint) (green[i] * 63.0F)) << 5)
	1232	\| (((GLint) (blue[i] * 31.0F)) << 11);
	1233	}
	1234	}
	1235	break;
	1236	case GL_UNSIGNED_SHORT_4_4_4_4:
	1237	if (format == GL_RGB) {
	1238	GLushort dst = (GLushort ) destination;
	1239	for (i=0;i<n;i++) {
	1240	dst[i] = (((GLint) (red[i] * 15.0F)) << 12)
	1241	\| (((GLint) (green[i] * 15.0F)) << 8)
	1242	\| (((GLint) (blue[i] * 15.0F)) << 4)
	1243	\| (((GLint) (alpha[i] * 15.0F)) );
	1244	}
	1245	}
	1246	break;
	1247	case GL_UNSIGNED_SHORT_4_4_4_4_REV:
	1248	if (format == GL_RGB) {
	1249	GLushort dst = (GLushort ) destination;
	1250	for (i=0;i<n;i++) {
	1251	dst[i] = (((GLint) (red[i] * 15.0F)) )
	1252	\| (((GLint) (green[i] * 15.0F)) << 4)
	1253	\| (((GLint) (blue[i] * 15.0F)) << 8)
	1254	\| (((GLint) (alpha[i] * 15.0F)) << 12);
	1255	}
	1256	}
	1257	break;
	1258	case GL_UNSIGNED_SHORT_5_5_5_1:
	1259	if (format == GL_RGB) {
	1260	GLushort dst = (GLushort ) destination;
	1261	for (i=0;i<n;i++) {
	1262	dst[i] = (((GLint) (red[i] * 31.0F)) << 11)
	1263	\| (((GLint) (green[i] * 31.0F)) << 6)
	1264	\| (((GLint) (blue[i] * 31.0F)) << 1)
	1265	\| (((GLint) (alpha[i] * 1.0F)) );
	1266	}
	1267	}
	1268	break;
	1269	case GL_UNSIGNED_SHORT_1_5_5_5_REV:
	1270	if (format == GL_RGB) {
	1271	GLushort dst = (GLushort ) destination;
	1272	for (i=0;i<n;i++) {
	1273	dst[i] = (((GLint) (red[i] * 31.0F)) )
	1274	\| (((GLint) (green[i] * 31.0F)) << 5)
	1275	\| (((GLint) (blue[i] * 31.0F)) << 10)
	1276	\| (((GLint) (alpha[i] * 1.0F)) << 15);
	1277	}
	1278	}
	1279	break;
	1280	case GL_UNSIGNED_INT_8_8_8_8:
	1281	if (format == GL_RGBA) {
	1282	GLuint dst = (GLuint ) destination;
	1283	for (i=0;i<n;i++) {
	1284	dst[i] = (((GLuint) (red[i] * 255.0F)) << 24)
	1285	\| (((GLuint) (green[i] * 255.0F)) << 16)
	1286	\| (((GLuint) (blue[i] * 255.0F)) << 8)
	1287	\| (((GLuint) (alpha[i] * 255.0F)) );
	1288	}
	1289	}
	1290	else if (format == GL_BGRA) {
	1291	GLuint dst = (GLuint ) destination;
	1292	for (i=0;i<n;i++) {
	1293	dst[i] = (((GLuint) (blue[i] * 255.0F)) << 24)
	1294	\| (((GLuint) (green[i] * 255.0F)) << 16)
	1295	\| (((GLuint) (red[i] * 255.0F)) << 8)
	1296	\| (((GLuint) (alpha[i] * 255.0F)) );
	1297	}
	1298	}
	1299	else if (format == GL_ABGR_EXT) {
	1300	GLuint dst = (GLuint ) destination;
	1301	for (i=0;i<n;i++) {
	1302	dst[i] = (((GLuint) (alpha[i] * 255.0F)) << 24)
	1303	\| (((GLuint) (blue[i] * 255.0F)) << 16)
	1304	\| (((GLuint) (green[i] * 255.0F)) << 8)
	1305	\| (((GLuint) (red[i] * 255.0F)) );
	1306	}
	1307	}
	1308	break;
	1309	case GL_UNSIGNED_INT_8_8_8_8_REV:
	1310	if (format == GL_RGBA) {
	1311	GLuint dst = (GLuint ) destination;
	1312	for (i=0;i<n;i++) {
	1313	dst[i] = (((GLuint) (red[i] * 255.0F)) )
	1314	\| (((GLuint) (green[i] * 255.0F)) << 8)
	1315	\| (((GLuint) (blue[i] * 255.0F)) << 16)
	1316	\| (((GLuint) (alpha[i] * 255.0F)) << 24);
	1317	}
	1318	}
	1319	else if (format == GL_BGRA) {
	1320	GLuint dst = (GLuint ) destination;
	1321	for (i=0;i<n;i++) {
	1322	dst[i] = (((GLuint) (blue[i] * 255.0F)) )
	1323	\| (((GLuint) (green[i] * 255.0F)) << 8)
	1324	\| (((GLuint) (red[i] * 255.0F)) << 16)
	1325	\| (((GLuint) (alpha[i] * 255.0F)) << 24);
	1326	}
	1327	}
	1328	else if (format == GL_ABGR_EXT) {
	1329	GLuint dst = (GLuint ) destination;
	1330	for (i=0;i<n;i++) {
	1331	dst[i] = (((GLuint) (alpha[i] * 255.0F)) )
	1332	\| (((GLuint) (blue[i] * 255.0F)) << 8)
	1333	\| (((GLuint) (green[i] * 255.0F)) << 16)
	1334	\| (((GLuint) (red[i] * 255.0F)) << 24);
	1335	}
	1336	}
	1337	break;
	1338	case GL_UNSIGNED_INT_10_10_10_2:
	1339	if (format == GL_RGBA) {
	1340	GLuint dst = (GLuint ) destination;
	1341	for (i=0;i<n;i++) {
	1342	dst[i] = (((GLuint) (red[i] * 1023.0F)) << 22)
	1343	\| (((GLuint) (green[i] * 1023.0F)) << 12)
	1344	\| (((GLuint) (blue[i] * 1023.0F)) << 2)
	1345	\| (((GLuint) (alpha[i] * 3.0F)) );
	1346	}
	1347	}
	1348	else if (format == GL_BGRA) {
	1349	GLuint dst = (GLuint ) destination;
	1350	for (i=0;i<n;i++) {
	1351	dst[i] = (((GLuint) (blue[i] * 1023.0F)) << 22)
	1352	\| (((GLuint) (green[i] * 1023.0F)) << 12)
	1353	\| (((GLuint) (red[i] * 1023.0F)) << 2)
	1354	\| (((GLuint) (alpha[i] * 3.0F)) );
	1355	}
	1356	}
	1357	else if (format == GL_ABGR_EXT) {
	1358	GLuint dst = (GLuint ) destination;
	1359	for (i=0;i<n;i++) {
	1360	dst[i] = (((GLuint) (alpha[i] * 1023.0F)) << 22)
	1361	\| (((GLuint) (blue[i] * 1023.0F)) << 12)
	1362	\| (((GLuint) (green[i] * 1023.0F)) << 2)
	1363	\| (((GLuint) (red[i] * 3.0F)) );
	1364	}
	1365	}
	1366	break;
	1367	case GL_UNSIGNED_INT_2_10_10_10_REV:
	1368	if (format == GL_RGBA) {
	1369	GLuint dst = (GLuint ) destination;
	1370	for (i=0;i<n;i++) {
	1371	dst[i] = (((GLuint) (red[i] * 1023.0F)) )
	1372	\| (((GLuint) (green[i] * 1023.0F)) << 10)
	1373	\| (((GLuint) (blue[i] * 1023.0F)) << 20)
	1374	\| (((GLuint) (alpha[i] * 3.0F)) << 30);
	1375	}
	1376	}
	1377	else if (format == GL_BGRA) {
	1378	GLuint dst = (GLuint ) destination;
	1379	for (i=0;i<n;i++) {
	1380	dst[i] = (((GLuint) (blue[i] * 1023.0F)) )
	1381	\| (((GLuint) (green[i] * 1023.0F)) << 10)
	1382	\| (((GLuint) (red[i] * 1023.0F)) << 20)
	1383	\| (((GLuint) (alpha[i] * 3.0F)) << 30);
	1384	}
	1385	}
	1386	else if (format == GL_ABGR_EXT) {
	1387	GLuint dst = (GLuint ) destination;
	1388	for (i=0;i<n;i++) {
	1389	dst[i] = (((GLuint) (alpha[i] * 1023.0F)) )
	1390	\| (((GLuint) (blue[i] * 1023.0F)) << 10)
	1391	\| (((GLuint) (green[i] * 1023.0F)) << 20)
	1392	\| (((GLuint) (red[i] * 3.0F)) << 30);
	1393	}
	1394	}
	1395	break;
	1396	default:
[3598]	1397	gl_problem( ctx, "bad type in _mesa_pack_rgba_span" );
[2938]	1398	}
	1399	}
	1400	}
	1401
	1402
[3598]	1403	#define SWAP2BYTE(VALUE) \
	1404	{ \
	1405	GLubyte bytes = (GLubyte ) &(VALUE); \
	1406	GLubyte tmp = bytes[0]; \
	1407	bytes[0] = bytes[1]; \
	1408	bytes[1] = tmp; \
[2938]	1409	}
	1410
[3598]	1411	#define SWAP4BYTE(VALUE) \
	1412	{ \
	1413	GLubyte bytes = (GLubyte ) &(VALUE); \
	1414	GLubyte tmp = bytes[0]; \
	1415	bytes[0] = bytes[3]; \
	1416	bytes[3] = tmp; \
	1417	tmp = bytes[1]; \
	1418	bytes[1] = bytes[2]; \
	1419	bytes[2] = tmp; \
[2938]	1420	}
	1421
	1422
	1423	static void
	1424	extract_uint_indexes(GLuint n, GLuint indexes[],
	1425	GLenum srcFormat, GLenum srcType, const GLvoid *src,
	1426	const struct gl_pixelstore_attrib *unpack )
	1427	{
[3598]	1428	ASSERT(srcFormat == GL_COLOR_INDEX);
[2938]	1429
	1430	ASSERT(srcType == GL_BITMAP \|\|
	1431	srcType == GL_UNSIGNED_BYTE \|\|
	1432	srcType == GL_BYTE \|\|
	1433	srcType == GL_UNSIGNED_SHORT \|\|
	1434	srcType == GL_SHORT \|\|
	1435	srcType == GL_UNSIGNED_INT \|\|
	1436	srcType == GL_INT \|\|
	1437	srcType == GL_FLOAT);
	1438
	1439	switch (srcType) {
	1440	case GL_BITMAP:
	1441	{
	1442	GLubyte ubsrc = (GLubyte ) src;
	1443	if (unpack->LsbFirst) {
	1444	GLubyte mask = 1 << (unpack->SkipPixels & 0x7);
	1445	GLuint i;
	1446	for (i = 0; i < n; i++) {
	1447	indexes[i] = (*ubsrc & mask) ? 1 : 0;
	1448	if (mask == 128) {
	1449	mask = 1;
	1450	ubsrc++;
	1451	}
	1452	else {
	1453	mask = mask << 1;
	1454	}
	1455	}
	1456	}
	1457	else {
	1458	GLubyte mask = 128 >> (unpack->SkipPixels & 0x7);
	1459	GLuint i;
	1460	for (i = 0; i < n; i++) {
	1461	indexes[i] = (*ubsrc & mask) ? 1 : 0;
	1462	if (mask == 1) {
	1463	mask = 128;
	1464	ubsrc++;
	1465	}
	1466	else {
	1467	mask = mask >> 1;
	1468	}
	1469	}
	1470	}
	1471	}
	1472	break;
	1473	case GL_UNSIGNED_BYTE:
	1474	{
	1475	GLuint i;
	1476	const GLubyte s = (const GLubyte ) src;
	1477	for (i = 0; i < n; i++)
	1478	indexes[i] = s[i];
	1479	}
	1480	break;
	1481	case GL_BYTE:
	1482	{
	1483	GLuint i;
	1484	const GLbyte s = (const GLbyte ) src;
	1485	for (i = 0; i < n; i++)
	1486	indexes[i] = s[i];
	1487	}
	1488	break;
	1489	case GL_UNSIGNED_SHORT:
	1490	{
	1491	GLuint i;
	1492	const GLushort s = (const GLushort ) src;
	1493	if (unpack->SwapBytes) {
	1494	for (i = 0; i < n; i++) {
	1495	GLushort value = s[i];
	1496	SWAP2BYTE(value);
	1497	indexes[i] = value;
	1498	}
	1499	}
	1500	else {
	1501	for (i = 0; i < n; i++)
	1502	indexes[i] = s[i];
	1503	}
	1504	}
	1505	break;
	1506	case GL_SHORT:
	1507	{
	1508	GLuint i;
	1509	const GLshort s = (const GLshort ) src;
	1510	if (unpack->SwapBytes) {
	1511	for (i = 0; i < n; i++) {
	1512	GLshort value = s[i];
	1513	SWAP2BYTE(value);
	1514	indexes[i] = value;
	1515	}
	1516	}
	1517	else {
	1518	for (i = 0; i < n; i++)
	1519	indexes[i] = s[i];
	1520	}
	1521	}
	1522	break;
	1523	case GL_UNSIGNED_INT:
	1524	{
	1525	GLuint i;
	1526	const GLuint s = (const GLuint ) src;
	1527	if (unpack->SwapBytes) {
	1528	for (i = 0; i < n; i++) {
	1529	GLuint value = s[i];
	1530	SWAP4BYTE(value);
	1531	indexes[i] = value;
	1532	}
	1533	}
	1534	else {
	1535	for (i = 0; i < n; i++)
	1536	indexes[i] = s[i];
	1537	}
	1538	}
	1539	break;
	1540	case GL_INT:
	1541	{
	1542	GLuint i;
	1543	const GLint s = (const GLint ) src;
	1544	if (unpack->SwapBytes) {
	1545	for (i = 0; i < n; i++) {
	1546	GLint value = s[i];
	1547	SWAP4BYTE(value);
	1548	indexes[i] = value;
	1549	}
	1550	}
	1551	else {
	1552	for (i = 0; i < n; i++)
	1553	indexes[i] = s[i];
	1554	}
	1555	}
	1556	break;
	1557	case GL_FLOAT:
	1558	{
	1559	GLuint i;
	1560	const GLfloat s = (const GLfloat ) src;
	1561	if (unpack->SwapBytes) {
	1562	for (i = 0; i < n; i++) {
	1563	GLfloat value = s[i];
	1564	SWAP4BYTE(value);
[3598]	1565	indexes[i] = (GLuint) value;
[2938]	1566	}
	1567	}
	1568	else {
	1569	for (i = 0; i < n; i++)
[3598]	1570	indexes[i] = (GLuint) s[i];
[2938]	1571	}
	1572	}
	1573	break;
	1574	default:
	1575	gl_problem(NULL, "bad srcType in extract_uint_indexes");
	1576	return;
	1577	}
	1578	}
	1579
	1580
	1581
	1582	/*
	1583	* This function extracts floating point RGBA values from arbitrary
	1584	* image data. srcFormat and srcType are the format and type parameters
	1585	* passed to glDrawPixels, glTexImage[123]D, glTexSubImage[123]D, etc.
	1586	*
	1587	* Refering to section 3.6.4 of the OpenGL 1.2 spec, this function
	1588	* implements the "Conversion to floating point", "Conversion to RGB",
	1589	* and "Final Expansion to RGBA" operations.
	1590	*
	1591	* Args: n - number of pixels
	1592	* rgba - output colors
	1593	* srcFormat - format of incoming data
	1594	* srcType - datatype of incoming data
	1595	* src - source data pointer
	1596	* swapBytes - perform byteswapping of incoming data?
	1597	*/
	1598	static void
	1599	extract_float_rgba(GLuint n, GLfloat rgba[][4],
	1600	GLenum srcFormat, GLenum srcType, const GLvoid *src,
	1601	GLboolean swapBytes)
	1602	{
	1603	GLint redIndex, greenIndex, blueIndex, alphaIndex;
	1604	GLint stride;
	1605	GLint rComp, bComp, gComp, aComp;
	1606
	1607	ASSERT(srcFormat == GL_RED \|\|
	1608	srcFormat == GL_GREEN \|\|
	1609	srcFormat == GL_BLUE \|\|
	1610	srcFormat == GL_ALPHA \|\|
	1611	srcFormat == GL_LUMINANCE \|\|
	1612	srcFormat == GL_LUMINANCE_ALPHA \|\|
	1613	srcFormat == GL_INTENSITY \|\|
	1614	srcFormat == GL_RGB \|\|
	1615	srcFormat == GL_BGR \|\|
	1616	srcFormat == GL_RGBA \|\|
	1617	srcFormat == GL_BGRA \|\|
	1618	srcFormat == GL_ABGR_EXT);
	1619
	1620	ASSERT(srcType == GL_UNSIGNED_BYTE \|\|
	1621	srcType == GL_BYTE \|\|
	1622	srcType == GL_UNSIGNED_SHORT \|\|
	1623	srcType == GL_SHORT \|\|
	1624	srcType == GL_UNSIGNED_INT \|\|
	1625	srcType == GL_INT \|\|
	1626	srcType == GL_FLOAT \|\|
	1627	srcType == GL_UNSIGNED_BYTE_3_3_2 \|\|
	1628	srcType == GL_UNSIGNED_BYTE_2_3_3_REV \|\|
	1629	srcType == GL_UNSIGNED_SHORT_5_6_5 \|\|
	1630	srcType == GL_UNSIGNED_SHORT_5_6_5_REV \|\|
	1631	srcType == GL_UNSIGNED_SHORT_4_4_4_4 \|\|
	1632	srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV \|\|
	1633	srcType == GL_UNSIGNED_SHORT_5_5_5_1 \|\|
	1634	srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV \|\|
	1635	srcType == GL_UNSIGNED_INT_8_8_8_8 \|\|
	1636	srcType == GL_UNSIGNED_INT_8_8_8_8_REV \|\|
	1637	srcType == GL_UNSIGNED_INT_10_10_10_2 \|\|
	1638	srcType == GL_UNSIGNED_INT_2_10_10_10_REV);
	1639
[3598]	1640	rComp = gComp = bComp = aComp = -1;
	1641
[2938]	1642	switch (srcFormat) {
	1643	case GL_RED:
	1644	redIndex = 0;
	1645	greenIndex = blueIndex = alphaIndex = -1;
	1646	stride = 1;
	1647	break;
	1648	case GL_GREEN:
	1649	greenIndex = 0;
	1650	redIndex = blueIndex = alphaIndex = -1;
	1651	stride = 1;
	1652	break;
	1653	case GL_BLUE:
	1654	blueIndex = 0;
	1655	redIndex = greenIndex = alphaIndex = -1;
	1656	stride = 1;
	1657	break;
	1658	case GL_ALPHA:
	1659	redIndex = greenIndex = blueIndex = -1;
	1660	alphaIndex = 0;
	1661	stride = 1;
	1662	break;
	1663	case GL_LUMINANCE:
	1664	redIndex = greenIndex = blueIndex = 0;
	1665	alphaIndex = -1;
	1666	stride = 1;
	1667	break;
	1668	case GL_LUMINANCE_ALPHA:
	1669	redIndex = greenIndex = blueIndex = 0;
	1670	alphaIndex = 1;
	1671	stride = 2;
	1672	break;
	1673	case GL_INTENSITY:
	1674	redIndex = 0;
	1675	greenIndex = blueIndex = alphaIndex = -1;
	1676	stride = 1;
	1677	break;
	1678	case GL_RGB:
	1679	redIndex = 0;
	1680	greenIndex = 1;
	1681	blueIndex = 2;
	1682	alphaIndex = -1;
	1683	stride = 3;
	1684	break;
	1685	case GL_BGR:
	1686	redIndex = 2;
	1687	greenIndex = 1;
	1688	blueIndex = 0;
	1689	alphaIndex = -1;
	1690	stride = 3;
	1691	break;
	1692	case GL_RGBA:
	1693	redIndex = 0;
	1694	greenIndex = 1;
	1695	blueIndex = 2;
	1696	alphaIndex = 3;
	1697	rComp = 0;
	1698	gComp = 1;
	1699	bComp = 2;
	1700	aComp = 3;
	1701	stride = 4;
	1702	break;
	1703	case GL_BGRA:
	1704	redIndex = 2;
	1705	greenIndex = 1;
	1706	blueIndex = 0;
	1707	alphaIndex = 3;
	1708	rComp = 2;
	1709	gComp = 1;
	1710	bComp = 0;
	1711	aComp = 3;
	1712	stride = 4;
	1713	break;
	1714	case GL_ABGR_EXT:
	1715	redIndex = 3;
	1716	greenIndex = 2;
	1717	blueIndex = 1;
	1718	alphaIndex = 0;
	1719	rComp = 3;
	1720	gComp = 2;
	1721	bComp = 1;
	1722	aComp = 0;
	1723	stride = 4;
	1724	break;
	1725	default:
	1726	gl_problem(NULL, "bad srcFormat in extract float data");
	1727	return;
	1728	}
	1729
	1730
[3598]	1731	#define PROCESS(INDEX, CHANNEL, DEFAULT, TYPE, CONVERSION) \
	1732	if ((INDEX) < 0) { \
	1733	GLuint i; \
	1734	for (i = 0; i < n; i++) { \
	1735	rgba[i][CHANNEL] = DEFAULT; \
	1736	} \
	1737	} \
	1738	else if (swapBytes) { \
	1739	const TYPE s = (const TYPE ) src; \
	1740	GLuint i; \
	1741	for (i = 0; i < n; i++) { \
	1742	TYPE value = s[INDEX]; \
	1743	if (sizeof(TYPE) == 2) { \
	1744	SWAP2BYTE(value); \
	1745	} \
	1746	else if (sizeof(TYPE) == 4) { \
	1747	SWAP4BYTE(value); \
	1748	} \
	1749	rgba[i][CHANNEL] = (GLfloat) CONVERSION(value); \
	1750	s += stride; \
	1751	} \
	1752	} \
	1753	else { \
	1754	const TYPE s = (const TYPE ) src; \
	1755	GLuint i; \
	1756	for (i = 0; i < n; i++) { \
	1757	rgba[i][CHANNEL] = (GLfloat) CONVERSION(s[INDEX]); \
	1758	s += stride; \
	1759	} \
[2938]	1760	}
	1761
	1762	switch (srcType) {
	1763	case GL_UNSIGNED_BYTE:
	1764	PROCESS(redIndex, RCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT);
	1765	PROCESS(greenIndex, GCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT);
	1766	PROCESS(blueIndex, BCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT);
	1767	PROCESS(alphaIndex, ACOMP, 1.0F, GLubyte, UBYTE_TO_FLOAT);
	1768	break;
	1769	case GL_BYTE:
	1770	PROCESS(redIndex, RCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT);
	1771	PROCESS(greenIndex, GCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT);
	1772	PROCESS(blueIndex, BCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT);
	1773	PROCESS(alphaIndex, ACOMP, 1.0F, GLbyte, BYTE_TO_FLOAT);
	1774	break;
	1775	case GL_UNSIGNED_SHORT:
	1776	PROCESS(redIndex, RCOMP, 0.0F, GLushort, USHORT_TO_FLOAT);
	1777	PROCESS(greenIndex, GCOMP, 0.0F, GLushort, USHORT_TO_FLOAT);
	1778	PROCESS(blueIndex, BCOMP, 0.0F, GLushort, USHORT_TO_FLOAT);
	1779	PROCESS(alphaIndex, ACOMP, 1.0F, GLushort, USHORT_TO_FLOAT);
	1780	break;
	1781	case GL_SHORT:
	1782	PROCESS(redIndex, RCOMP, 0.0F, GLshort, SHORT_TO_FLOAT);
	1783	PROCESS(greenIndex, GCOMP, 0.0F, GLshort, SHORT_TO_FLOAT);
	1784	PROCESS(blueIndex, BCOMP, 0.0F, GLshort, SHORT_TO_FLOAT);
	1785	PROCESS(alphaIndex, ACOMP, 1.0F, GLshort, SHORT_TO_FLOAT);
	1786	break;
	1787	case GL_UNSIGNED_INT:
	1788	PROCESS(redIndex, RCOMP, 0.0F, GLuint, UINT_TO_FLOAT);
	1789	PROCESS(greenIndex, GCOMP, 0.0F, GLuint, UINT_TO_FLOAT);
	1790	PROCESS(blueIndex, BCOMP, 0.0F, GLuint, UINT_TO_FLOAT);
	1791	PROCESS(alphaIndex, ACOMP, 1.0F, GLuint, UINT_TO_FLOAT);
	1792	break;
	1793	case GL_INT:
	1794	PROCESS(redIndex, RCOMP, 0.0F, GLint, INT_TO_FLOAT);
	1795	PROCESS(greenIndex, GCOMP, 0.0F, GLint, INT_TO_FLOAT);
	1796	PROCESS(blueIndex, BCOMP, 0.0F, GLint, INT_TO_FLOAT);
	1797	PROCESS(alphaIndex, ACOMP, 1.0F, GLint, INT_TO_FLOAT);
	1798	break;
	1799	case GL_FLOAT:
	1800	PROCESS(redIndex, RCOMP, 0.0F, GLfloat, (GLfloat));
	1801	PROCESS(greenIndex, GCOMP, 0.0F, GLfloat, (GLfloat));
	1802	PROCESS(blueIndex, BCOMP, 0.0F, GLfloat, (GLfloat));
	1803	PROCESS(alphaIndex, ACOMP, 1.0F, GLfloat, (GLfloat));
	1804	break;
	1805	case GL_UNSIGNED_BYTE_3_3_2:
	1806	{
	1807	const GLubyte ubsrc = (const GLubyte ) src;
	1808	GLuint i;
	1809	for (i = 0; i < n; i ++) {
	1810	GLubyte p = ubsrc[i];
	1811	rgba[i][RCOMP] = ((p >> 5) ) * (1.0F / 7.0F);
	1812	rgba[i][GCOMP] = ((p >> 2) & 0x7) * (1.0F / 7.0F);
	1813	rgba[i][BCOMP] = ((p ) & 0x3) * (1.0F / 3.0F);
	1814	rgba[i][ACOMP] = 1.0F;
	1815	}
	1816	}
	1817	break;
	1818	case GL_UNSIGNED_BYTE_2_3_3_REV:
	1819	{
	1820	const GLubyte ubsrc = (const GLubyte ) src;
	1821	GLuint i;
	1822	for (i = 0; i < n; i ++) {
	1823	GLubyte p = ubsrc[i];
	1824	rgba[i][RCOMP] = ((p ) & 0x7) * (1.0F / 7.0F);
	1825	rgba[i][GCOMP] = ((p >> 3) & 0x7) * (1.0F / 7.0F);
	1826	rgba[i][BCOMP] = ((p >> 6) ) * (1.0F / 3.0F);
	1827	rgba[i][ACOMP] = 1.0F;
	1828	}
	1829	}
	1830	break;
	1831	case GL_UNSIGNED_SHORT_5_6_5:
	1832	if (swapBytes) {
	1833	const GLushort ussrc = (const GLushort ) src;
	1834	GLuint i;
	1835	for (i = 0; i < n; i ++) {
	1836	GLushort p = ussrc[i];
	1837	SWAP2BYTE(p);
	1838	rgba[i][RCOMP] = ((p >> 11) ) * (1.0F / 31.0F);
	1839	rgba[i][GCOMP] = ((p >> 5) & 0x3f) * (1.0F / 63.0F);
	1840	rgba[i][BCOMP] = ((p ) & 0x1f) * (1.0F / 31.0F);
	1841	rgba[i][ACOMP] = 1.0F;
	1842	}
	1843	}
	1844	else {
	1845	const GLushort ussrc = (const GLushort ) src;
	1846	GLuint i;
	1847	for (i = 0; i < n; i ++) {
	1848	GLushort p = ussrc[i];
	1849	rgba[i][RCOMP] = ((p >> 11) ) * (1.0F / 31.0F);
	1850	rgba[i][GCOMP] = ((p >> 5) & 0x3f) * (1.0F / 63.0F);
	1851	rgba[i][BCOMP] = ((p ) & 0x1f) * (1.0F / 31.0F);
	1852	rgba[i][ACOMP] = 1.0F;
	1853	}
	1854	}
	1855	break;
	1856	case GL_UNSIGNED_SHORT_5_6_5_REV:
	1857	if (swapBytes) {
	1858	const GLushort ussrc = (const GLushort ) src;
	1859	GLuint i;
	1860	for (i = 0; i < n; i ++) {
	1861	GLushort p = ussrc[i];
	1862	SWAP2BYTE(p);
	1863	rgba[i][RCOMP] = ((p ) & 0x1f) * (1.0F / 31.0F);
	1864	rgba[i][GCOMP] = ((p >> 5) & 0x3f) * (1.0F / 63.0F);
	1865	rgba[i][BCOMP] = ((p >> 11) ) * (1.0F / 31.0F);
	1866	rgba[i][ACOMP] = 1.0F;
	1867	}
	1868	}
	1869	else {
	1870	const GLushort ussrc = (const GLushort ) src;
	1871	GLuint i;
	1872	for (i = 0; i < n; i ++) {
	1873	GLushort p = ussrc[i];
	1874	rgba[i][RCOMP] = ((p ) & 0x1f) * (1.0F / 31.0F);
	1875	rgba[i][GCOMP] = ((p >> 5) & 0x3f) * (1.0F / 63.0F);
	1876	rgba[i][BCOMP] = ((p >> 11) ) * (1.0F / 31.0F);
	1877	rgba[i][ACOMP] = 1.0F;
	1878	}
	1879	}
	1880	break;
	1881	case GL_UNSIGNED_SHORT_4_4_4_4:
	1882	if (swapBytes) {
	1883	const GLushort ussrc = (const GLushort ) src;
	1884	GLuint i;
	1885	for (i = 0; i < n; i ++) {
	1886	GLushort p = ussrc[i];
	1887	SWAP2BYTE(p);
	1888	rgba[i][rComp] = ((p >> 12) ) * (1.0F / 15.0F);
	1889	rgba[i][gComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F);
	1890	rgba[i][bComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F);
	1891	rgba[i][aComp] = ((p ) & 0xf) * (1.0F / 15.0F);
	1892	}
	1893	}
	1894	else {
	1895	const GLushort ussrc = (const GLushort ) src;
	1896	GLuint i;
	1897	for (i = 0; i < n; i ++) {
	1898	GLushort p = ussrc[i];
	1899	rgba[i][rComp] = ((p >> 12) ) * (1.0F / 15.0F);
	1900	rgba[i][gComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F);
	1901	rgba[i][bComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F);
	1902	rgba[i][aComp] = ((p ) & 0xf) * (1.0F / 15.0F);
	1903	}
	1904	}
	1905	break;
	1906	case GL_UNSIGNED_SHORT_4_4_4_4_REV:
	1907	if (swapBytes) {
	1908	const GLushort ussrc = (const GLushort ) src;
	1909	GLuint i;
	1910	for (i = 0; i < n; i ++) {
	1911	GLushort p = ussrc[i];
	1912	SWAP2BYTE(p);
	1913	rgba[i][rComp] = ((p ) & 0xf) * (1.0F / 15.0F);
	1914	rgba[i][gComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F);
	1915	rgba[i][bComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F);
	1916	rgba[i][aComp] = ((p >> 12) ) * (1.0F / 15.0F);
	1917	}
	1918	}
	1919	else {
	1920	const GLushort ussrc = (const GLushort ) src;
	1921	GLuint i;
	1922	for (i = 0; i < n; i ++) {
	1923	GLushort p = ussrc[i];
	1924	rgba[i][rComp] = ((p ) & 0xf) * (1.0F / 15.0F);
	1925	rgba[i][gComp] = ((p >> 4) & 0xf) * (1.0F / 15.0F);
	1926	rgba[i][bComp] = ((p >> 8) & 0xf) * (1.0F / 15.0F);
	1927	rgba[i][aComp] = ((p >> 12) ) * (1.0F / 15.0F);
	1928	}
	1929	}
	1930	break;
	1931	case GL_UNSIGNED_SHORT_5_5_5_1:
	1932	if (swapBytes) {
	1933	const GLushort ussrc = (const GLushort ) src;
	1934	GLuint i;
	1935	for (i = 0; i < n; i ++) {
	1936	GLushort p = ussrc[i];
	1937	SWAP2BYTE(p);
	1938	rgba[i][rComp] = ((p >> 11) ) * (1.0F / 31.0F);
	1939	rgba[i][gComp] = ((p >> 6) & 0x1f) * (1.0F / 31.0F);
	1940	rgba[i][bComp] = ((p >> 1) & 0x1f) * (1.0F / 31.0F);
	1941	rgba[i][aComp] = ((p ) & 0x1) * (1.0F / 1.0F);
	1942	}
	1943	}
	1944	else {
	1945	const GLushort ussrc = (const GLushort ) src;
	1946	GLuint i;
	1947	for (i = 0; i < n; i ++) {
	1948	GLushort p = ussrc[i];
	1949	rgba[i][rComp] = ((p >> 11) ) * (1.0F / 31.0F);
	1950	rgba[i][gComp] = ((p >> 6) & 0x1f) * (1.0F / 31.0F);
	1951	rgba[i][bComp] = ((p >> 1) & 0x1f) * (1.0F / 31.0F);
	1952	rgba[i][aComp] = ((p ) & 0x1) * (1.0F / 1.0F);
	1953	}
	1954	}
	1955	break;
	1956	case GL_UNSIGNED_SHORT_1_5_5_5_REV:
	1957	if (swapBytes) {
	1958	const GLushort ussrc = (const GLushort ) src;
	1959	GLuint i;
	1960	for (i = 0; i < n; i ++) {
	1961	GLushort p = ussrc[i];
	1962	SWAP2BYTE(p);
	1963	rgba[i][rComp] = ((p ) & 0x1f) * (1.0F / 31.0F);
	1964	rgba[i][gComp] = ((p >> 5) & 0x1f) * (1.0F / 31.0F);
	1965	rgba[i][bComp] = ((p >> 10) & 0x1f) * (1.0F / 31.0F);
	1966	rgba[i][aComp] = ((p >> 15) ) * (1.0F / 1.0F);
	1967	}
	1968	}
	1969	else {
	1970	const GLushort ussrc = (const GLushort ) src;
	1971	GLuint i;
	1972	for (i = 0; i < n; i ++) {
	1973	GLushort p = ussrc[i];
	1974	rgba[i][rComp] = ((p ) & 0x1f) * (1.0F / 31.0F);
	1975	rgba[i][gComp] = ((p >> 5) & 0x1f) * (1.0F / 31.0F);
	1976	rgba[i][bComp] = ((p >> 10) & 0x1f) * (1.0F / 31.0F);
	1977	rgba[i][aComp] = ((p >> 15) ) * (1.0F / 1.0F);
	1978	}
	1979	}
	1980	break;
	1981	case GL_UNSIGNED_INT_8_8_8_8:
	1982	if (swapBytes) {
	1983	const GLuint uisrc = (const GLuint ) src;
	1984	GLuint i;
	1985	for (i = 0; i < n; i ++) {
	1986	GLuint p = uisrc[i];
	1987	rgba[i][rComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p ) & 0xff);
	1988	rgba[i][gComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 8) & 0xff);
	1989	rgba[i][bComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 16) & 0xff);
	1990	rgba[i][aComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 24) );
	1991	}
	1992	}
	1993	else {
	1994	const GLuint uisrc = (const GLuint ) src;
	1995	GLuint i;
	1996	for (i = 0; i < n; i ++) {
	1997	GLuint p = uisrc[i];
	1998	rgba[i][rComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 24) );
	1999	rgba[i][gComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 16) & 0xff);
	2000	rgba[i][bComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 8) & 0xff);
	2001	rgba[i][aComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p ) & 0xff);
	2002	}
	2003	}
	2004	break;
	2005	case GL_UNSIGNED_INT_8_8_8_8_REV:
	2006	if (swapBytes) {
	2007	const GLuint uisrc = (const GLuint ) src;
	2008	GLuint i;
	2009	for (i = 0; i < n; i ++) {
	2010	GLuint p = uisrc[i];
	2011	rgba[i][rComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 24) );
	2012	rgba[i][gComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 16) & 0xff);
	2013	rgba[i][bComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 8) & 0xff);
	2014	rgba[i][aComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p ) & 0xff);
	2015	}
	2016	}
	2017	else {
	2018	const GLuint uisrc = (const GLuint ) src;
	2019	GLuint i;
	2020	for (i = 0; i < n; i ++) {
	2021	GLuint p = uisrc[i];
	2022	rgba[i][rComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p ) & 0xff);
	2023	rgba[i][gComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 8) & 0xff);
	2024	rgba[i][bComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 16) & 0xff);
	2025	rgba[i][aComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 24) );
	2026	}
	2027	}
	2028	break;
	2029	case GL_UNSIGNED_INT_10_10_10_2:
	2030	if (swapBytes) {
	2031	const GLuint uisrc = (const GLuint ) src;
	2032	GLuint i;
	2033	for (i = 0; i < n; i ++) {
	2034	GLuint p = uisrc[i];
	2035	SWAP4BYTE(p);
[3598]	2036	rgba[i][rComp] = ((p >> 22) ) * (1.0F / 1023.0F);
	2037	rgba[i][gComp] = ((p >> 12) & 0x3ff) * (1.0F / 1023.0F);
	2038	rgba[i][bComp] = ((p >> 2) & 0x3ff) * (1.0F / 1023.0F);
	2039	rgba[i][aComp] = ((p ) & 0x3 ) * (1.0F / 3.0F);
[2938]	2040	}
	2041	}
	2042	else {
	2043	const GLuint uisrc = (const GLuint ) src;
	2044	GLuint i;
	2045	for (i = 0; i < n; i ++) {
	2046	GLuint p = uisrc[i];
[3598]	2047	rgba[i][rComp] = ((p >> 22) ) * (1.0F / 1023.0F);
	2048	rgba[i][gComp] = ((p >> 12) & 0x3ff) * (1.0F / 1023.0F);
	2049	rgba[i][bComp] = ((p >> 2) & 0x3ff) * (1.0F / 1023.0F);
	2050	rgba[i][aComp] = ((p ) & 0x3 ) * (1.0F / 3.0F);
[2938]	2051	}
	2052	}
	2053	break;
	2054	case GL_UNSIGNED_INT_2_10_10_10_REV:
	2055	if (swapBytes) {
	2056	const GLuint uisrc = (const GLuint ) src;
	2057	GLuint i;
	2058	for (i = 0; i < n; i ++) {
	2059	GLuint p = uisrc[i];
	2060	SWAP4BYTE(p);
	2061	rgba[i][rComp] = ((p ) & 0x3ff) * (1.0F / 1023.0F);
	2062	rgba[i][gComp] = ((p >> 10) & 0x3ff) * (1.0F / 1023.0F);
	2063	rgba[i][bComp] = ((p >> 20) & 0x3ff) * (1.0F / 1023.0F);
	2064	rgba[i][aComp] = ((p >> 30) ) * (1.0F / 3.0F);
	2065	}
	2066	}
	2067	else {
	2068	const GLuint uisrc = (const GLuint ) src;
	2069	GLuint i;
	2070	for (i = 0; i < n; i ++) {
	2071	GLuint p = uisrc[i];
	2072	rgba[i][rComp] = ((p ) & 0x3ff) * (1.0F / 1023.0F);
	2073	rgba[i][gComp] = ((p >> 10) & 0x3ff) * (1.0F / 1023.0F);
	2074	rgba[i][bComp] = ((p >> 20) & 0x3ff) * (1.0F / 1023.0F);
	2075	rgba[i][aComp] = ((p >> 30) ) * (1.0F / 3.0F);
	2076	}
	2077	}
	2078	break;
	2079	default:
	2080	gl_problem(NULL, "bad srcType in extract float data");
	2081	break;
	2082	}
	2083	}
	2084
	2085
	2086
	2087	/*
	2088	* Unpack a row of color image data from a client buffer according to
	2089	* the pixel unpacking parameters. Apply any enabled pixel transfer
	2090	* ops (PixelMap, scale/bias) if the applyTransferOps flag is enabled.
	2091	* Return GLubyte values in the specified dest image format.
	2092	* This is (or will be) used by glDrawPixels and glTexImage?D().
	2093	* Input: ctx - the context
	2094	* n - number of pixels in the span
	2095	* dstFormat - format of destination color array
	2096	* dest - the destination color array
	2097	* srcFormat - source image format
	2098	* srcType - source image datatype
	2099	* source - source image pointer
	2100	* unpacking - pixel unpacking parameters
	2101	* applyTransferOps - apply scale/bias/lookup-table ops?
	2102	*
	2103	* XXX perhaps expand this to process whole images someday.
	2104	*/
	2105	void
	2106	_mesa_unpack_ubyte_color_span( const GLcontext *ctx,
	2107	GLuint n, GLenum dstFormat, GLubyte dest[],
	2108	GLenum srcFormat, GLenum srcType,
	2109	const GLvoid *source,
	2110	const struct gl_pixelstore_attrib *unpacking,
	2111	GLboolean applyTransferOps )
	2112	{
	2113	ASSERT(dstFormat == GL_ALPHA \|\|
	2114	dstFormat == GL_LUMINANCE \|\|
	2115	dstFormat == GL_LUMINANCE_ALPHA \|\|
	2116	dstFormat == GL_INTENSITY \|\|
	2117	dstFormat == GL_RGB \|\|
	2118	dstFormat == GL_RGBA \|\|
	2119	dstFormat == GL_COLOR_INDEX);
	2120
	2121	ASSERT(srcFormat == GL_RED \|\|
	2122	srcFormat == GL_GREEN \|\|
	2123	srcFormat == GL_BLUE \|\|
	2124	srcFormat == GL_ALPHA \|\|
	2125	srcFormat == GL_LUMINANCE \|\|
	2126	srcFormat == GL_LUMINANCE_ALPHA \|\|
	2127	srcFormat == GL_INTENSITY \|\|
	2128	srcFormat == GL_RGB \|\|
	2129	srcFormat == GL_BGR \|\|
	2130	srcFormat == GL_RGBA \|\|
	2131	srcFormat == GL_BGRA \|\|
	2132	srcFormat == GL_ABGR_EXT \|\|
	2133	srcFormat == GL_COLOR_INDEX);
	2134
	2135	ASSERT(srcType == GL_BITMAP \|\|
	2136	srcType == GL_UNSIGNED_BYTE \|\|
	2137	srcType == GL_BYTE \|\|
	2138	srcType == GL_UNSIGNED_SHORT \|\|
	2139	srcType == GL_SHORT \|\|
	2140	srcType == GL_UNSIGNED_INT \|\|
	2141	srcType == GL_INT \|\|
	2142	srcType == GL_FLOAT \|\|
	2143	srcType == GL_UNSIGNED_BYTE_3_3_2 \|\|
	2144	srcType == GL_UNSIGNED_BYTE_2_3_3_REV \|\|
	2145	srcType == GL_UNSIGNED_SHORT_5_6_5 \|\|
	2146	srcType == GL_UNSIGNED_SHORT_5_6_5_REV \|\|
	2147	srcType == GL_UNSIGNED_SHORT_4_4_4_4 \|\|
	2148	srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV \|\|
	2149	srcType == GL_UNSIGNED_SHORT_5_5_5_1 \|\|
	2150	srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV \|\|
	2151	srcType == GL_UNSIGNED_INT_8_8_8_8 \|\|
	2152	srcType == GL_UNSIGNED_INT_8_8_8_8_REV \|\|
	2153	srcType == GL_UNSIGNED_INT_10_10_10_2 \|\|
	2154	srcType == GL_UNSIGNED_INT_2_10_10_10_REV);
	2155
	2156	/* this is intended for RGBA mode */
	2157	ASSERT(ctx->Visual->RGBAflag);
	2158
	2159	applyTransferOps &= (ctx->Pixel.ScaleOrBiasRGBA \|\|
[3598]	2160	ctx->Pixel.MapColorFlag \|\|
[2938]	2161	ctx->Pixel.MapColorFlag);
	2162
	2163	/* Try simple cases first */
	2164	if (!applyTransferOps && srcType == GL_UNSIGNED_BYTE) {
	2165	if (dstFormat == GL_RGBA) {
	2166	if (srcFormat == GL_RGBA) {
	2167	MEMCPY( dest, source, n * 4 * sizeof(GLubyte) );
	2168	return;
	2169	}
	2170	else if (srcFormat == GL_RGB) {
	2171	GLuint i;
	2172	const GLubyte src = (const GLubyte ) source;
	2173	GLubyte *dst = dest;
	2174	for (i = 0; i < n; i++) {
	2175	dst[0] = src[0];
	2176	dst[1] = src[1];
	2177	dst[2] = src[2];
	2178	dst[3] = 255;
	2179	src += 3;
	2180	dst += 4;
	2181	}
	2182	return;
	2183	}
	2184	}
	2185	else if (dstFormat == GL_RGB) {
	2186	if (srcFormat == GL_RGB) {
	2187	MEMCPY( dest, source, n * 3 * sizeof(GLubyte) );
	2188	return;
	2189	}
	2190	else if (srcFormat == GL_RGBA) {
	2191	GLuint i;
	2192	const GLubyte src = (const GLubyte ) source;
	2193	GLubyte *dst = dest;
	2194	for (i = 0; i < n; i++) {
	2195	dst[0] = src[0];
	2196	dst[1] = src[1];
	2197	dst[2] = src[2];
	2198	src += 4;
	2199	dst += 3;
	2200	}
	2201	return;
	2202	}
	2203	}
	2204	else if (dstFormat == srcFormat) {
[3598]	2205	GLint comps = _mesa_components_in_format(srcFormat);
	2206	ASSERT(comps > 0);
[2938]	2207	MEMCPY( dest, source, n * comps * sizeof(GLubyte) );
	2208	return;
	2209	}
	2210	}
	2211
	2212
	2213	{
	2214	/* general solution */
	2215	GLfloat rgba[MAX_WIDTH][4];
	2216	GLint dstComponents;
	2217	GLint dstRedIndex, dstGreenIndex, dstBlueIndex, dstAlphaIndex;
	2218	GLint dstLuminanceIndex, dstIntensityIndex;
	2219
[3598]	2220	dstComponents = _mesa_components_in_format( dstFormat );
[2938]	2221	/* source & dest image formats should have been error checked by now */
[3598]	2222	ASSERT(dstComponents > 0);
[2938]	2223
	2224	/*
	2225	* Extract image data and convert to RGBA floats
	2226	*/
[3598]	2227	ASSERT(n <= MAX_WIDTH);
[2938]	2228	if (srcFormat == GL_COLOR_INDEX) {
	2229	GLuint indexes[MAX_WIDTH];
	2230	extract_uint_indexes(n, indexes, srcFormat, srcType, source,
	2231	unpacking);
	2232
	2233	/* shift and offset indexes */
	2234	gl_shift_and_offset_ci(ctx, n, indexes);
	2235
	2236	if (dstFormat == GL_COLOR_INDEX) {
	2237	if (applyTransferOps) {
	2238	if (ctx->Pixel.MapColorFlag) {
	2239	/* Apply lookup table */
	2240	gl_map_ci(ctx, n, indexes);
	2241	}
	2242
	2243	if (ctx->Pixel.IndexShift \|\| ctx->Pixel.IndexOffset) {
	2244
	2245	}
	2246	}
	2247
	2248	/* convert to GLubyte and return */
	2249	{
	2250	GLuint i;
	2251	for (i = 0; i < n; i++) {
	2252	dest[i] = (GLubyte) (indexes[i] & 0xff);
	2253	}
	2254	}
	2255	}
	2256	else {
	2257	/* Convert indexes to RGBA */
	2258	gl_map_ci_to_rgba_float(ctx, n, indexes, rgba);
	2259	}
	2260	}
	2261	else {
	2262	extract_float_rgba(n, rgba, srcFormat, srcType, source,
	2263	unpacking->SwapBytes);
	2264
	2265	if (applyTransferOps) {
	2266	/* scale and bias colors */
	2267	gl_scale_and_bias_rgba_float(ctx, n, rgba);
	2268
	2269	/* color table lookup */
	2270	if (ctx->Pixel.MapColorFlag) {
	2271	gl_map_rgba_float(ctx, n, rgba);
	2272	}
	2273	}
	2274	}
	2275
	2276
	2277	/*
	2278	* XXX This is where more color table lookups, convolution,
	2279	* histograms, minmax, color matrix, etc would take place if
	2280	* implemented.
	2281	* See figure 3.7 in the OpenGL 1.2 specification for more info.
	2282	*/
	2283
	2284
	2285	/* clamp to [0,1] */
	2286	{
	2287	GLuint i;
	2288	for (i = 0; i < n; i++) {
	2289	rgba[i][RCOMP] = CLAMP(rgba[i][RCOMP], 0.0F, 1.0F);
	2290	rgba[i][GCOMP] = CLAMP(rgba[i][GCOMP], 0.0F, 1.0F);
	2291	rgba[i][BCOMP] = CLAMP(rgba[i][BCOMP], 0.0F, 1.0F);
	2292	rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F);
	2293	}
	2294	}
	2295
	2296	/* Now determine which color channels we need to produce.
	2297	* And determine the dest index (offset) within each color tuple.
	2298	*/
	2299	switch (dstFormat) {
	2300	case GL_ALPHA:
	2301	dstAlphaIndex = 0;
	2302	dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
	2303	dstLuminanceIndex = dstIntensityIndex = -1;
	2304	break;
	2305	case GL_LUMINANCE:
	2306	dstLuminanceIndex = 0;
	2307	dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
	2308	dstIntensityIndex = -1;
	2309	break;
	2310	case GL_LUMINANCE_ALPHA:
	2311	dstLuminanceIndex = 0;
	2312	dstAlphaIndex = 1;
	2313	dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
	2314	dstIntensityIndex = -1;
	2315	break;
	2316	case GL_INTENSITY:
	2317	dstIntensityIndex = 0;
	2318	dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
	2319	dstLuminanceIndex = -1;
	2320	break;
	2321	case GL_RGB:
	2322	dstRedIndex = 0;
	2323	dstGreenIndex = 1;
	2324	dstBlueIndex = 2;
	2325	dstAlphaIndex = dstLuminanceIndex = dstIntensityIndex = -1;
	2326	break;
	2327	case GL_RGBA:
	2328	dstRedIndex = 0;
	2329	dstGreenIndex = 1;
	2330	dstBlueIndex = 2;
	2331	dstAlphaIndex = 3;
	2332	dstLuminanceIndex = dstIntensityIndex = -1;
	2333	break;
	2334	default:
	2335	gl_problem(ctx, "bad dstFormat in _mesa_unpack_ubyte_span()");
[3598]	2336	return;
[2938]	2337	}
	2338
	2339
	2340	/* Now return the GLubyte data in the requested dstFormat */
[3598]	2341
[2938]	2342	if (dstRedIndex >= 0) {
	2343	GLubyte *dst = dest;
	2344	GLuint i;
	2345	for (i = 0; i < n; i++) {
	2346	dst[dstRedIndex] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
	2347	dst += dstComponents;
	2348	}
	2349	}
	2350
	2351	if (dstGreenIndex >= 0) {
	2352	GLubyte *dst = dest;
	2353	GLuint i;
	2354	for (i = 0; i < n; i++) {
	2355	dst[dstGreenIndex] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
	2356	dst += dstComponents;
	2357	}
	2358	}
	2359
	2360	if (dstBlueIndex >= 0) {
	2361	GLubyte *dst = dest;
	2362	GLuint i;
	2363	for (i = 0; i < n; i++) {
	2364	dst[dstBlueIndex] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
	2365	dst += dstComponents;
	2366	}
	2367	}
	2368
	2369	if (dstAlphaIndex >= 0) {
	2370	GLubyte *dst = dest;
	2371	GLuint i;
	2372	for (i = 0; i < n; i++) {
	2373	dst[dstAlphaIndex] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
	2374	dst += dstComponents;
	2375	}
	2376	}
	2377
	2378	if (dstIntensityIndex >= 0) {
	2379	GLubyte *dst = dest;
	2380	GLuint i;
[3598]	2381	ASSERT(dstIntensityIndex == 0);
	2382	ASSERT(dstComponents == 1);
[2938]	2383	for (i = 0; i < n; i++) {
	2384	/* Intensity comes from red channel */
	2385	dst[i] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
	2386	}
	2387	}
	2388
	2389	if (dstLuminanceIndex >= 0) {
	2390	GLubyte *dst = dest;
	2391	GLuint i;
[3598]	2392	ASSERT(dstLuminanceIndex == 0);
[2938]	2393	for (i = 0; i < n; i++) {
	2394	/* Luminance comes from red channel */
	2395	dst[0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
	2396	dst += dstComponents;
	2397	}
	2398	}
	2399	}
	2400	}
	2401
	2402
	2403
	2404	/*
	2405	* Unpack a row of color index data from a client buffer according to
	2406	* the pixel unpacking parameters. Apply pixel transfer ops if enabled
	2407	* and applyTransferOps is true.
	2408	* This is (or will be) used by glDrawPixels, glTexImage[123]D, etc.
	2409	*
	2410	* Args: ctx - the context
	2411	* n - number of pixels
	2412	* dstType - destination datatype
	2413	* dest - destination array
	2414	* srcType - source pixel type
	2415	* source - source data pointer
	2416	* unpacking - pixel unpacking parameters
	2417	* applyTransferOps - apply offset/bias/lookup ops?
	2418	*/
	2419	void
	2420	_mesa_unpack_index_span( const GLcontext *ctx, GLuint n,
	2421	GLenum dstType, GLvoid *dest,
	2422	GLenum srcType, const GLvoid *source,
	2423	const struct gl_pixelstore_attrib *unpacking,
	2424	GLboolean applyTransferOps )
	2425	{
	2426	ASSERT(srcType == GL_BITMAP \|\|
	2427	srcType == GL_UNSIGNED_BYTE \|\|
	2428	srcType == GL_BYTE \|\|
	2429	srcType == GL_UNSIGNED_SHORT \|\|
	2430	srcType == GL_SHORT \|\|
	2431	srcType == GL_UNSIGNED_INT \|\|
	2432	srcType == GL_INT \|\|
	2433	srcType == GL_FLOAT);
	2434
	2435	ASSERT(dstType == GL_UNSIGNED_BYTE \|\|
	2436	dstType == GL_UNSIGNED_SHORT \|\|
	2437	dstType == GL_UNSIGNED_INT);
	2438
	2439	applyTransferOps &= (ctx->Pixel.IndexShift \|\| ctx->Pixel.IndexOffset \|\| ctx->Pixel.MapColorFlag);
	2440
	2441	/*
	2442	* Try simple cases first
	2443	*/
	2444	if (!applyTransferOps && srcType == GL_UNSIGNED_BYTE
	2445	&& dstType == GL_UNSIGNED_BYTE) {
	2446	MEMCPY(dest, source, n * sizeof(GLubyte));
	2447	}
	2448	else if (!applyTransferOps && srcType == GL_UNSIGNED_INT
	2449	&& dstType == GL_UNSIGNED_INT && !unpacking->SwapBytes) {
	2450	MEMCPY(dest, source, n * sizeof(GLuint));
	2451	}
	2452	else {
	2453	/*
	2454	* general solution
	2455	*/
	2456	GLuint indexes[MAX_WIDTH];
[3598]	2457	ASSERT(n <= MAX_WIDTH);
[2938]	2458
	2459	extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source,
	2460	unpacking);
	2461
	2462	if (applyTransferOps) {
	2463	if (ctx->Pixel.IndexShift \|\| ctx->Pixel.IndexOffset) {
	2464	/* shift and offset indexes */
	2465	gl_shift_and_offset_ci(ctx, n, indexes);
	2466	}
	2467
	2468	if (ctx->Pixel.MapColorFlag) {
	2469	/* Apply lookup table */
	2470	gl_map_ci(ctx, n, indexes);
	2471	}
	2472	}
	2473
	2474	/* convert to dest type */
	2475	switch (dstType) {
	2476	case GL_UNSIGNED_BYTE:
	2477	{
	2478	GLubyte dst = (GLubyte ) dest;
	2479	GLuint i;
	2480	for (i = 0; i < n; i++) {
	2481	dst[i] = (GLubyte) (indexes[i] & 0xff);
	2482	}
	2483	}
	2484	break;
	2485	case GL_UNSIGNED_SHORT:
	2486	{
	2487	GLuint dst = (GLuint ) dest;
	2488	GLuint i;
	2489	for (i = 0; i < n; i++) {
	2490	dst[i] = (GLushort) (indexes[i] & 0xffff);
	2491	}
	2492	}
	2493	break;
	2494	case GL_UNSIGNED_INT:
	2495	MEMCPY(dest, indexes, n * sizeof(GLuint));
	2496	break;
	2497	default:
	2498	gl_problem(ctx, "bad dstType in _mesa_unpack_index_span");
	2499	}
	2500	}
	2501	}
	2502
	2503
	2504	/*
[3598]	2505	* Unpack a row of stencil data from a client buffer according to
	2506	* the pixel unpacking parameters. Apply pixel transfer ops if enabled
	2507	* and applyTransferOps is true.
	2508	* This is (or will be) used by glDrawPixels
	2509	*
	2510	* Args: ctx - the context
	2511	* n - number of pixels
	2512	* dstType - destination datatype
	2513	* dest - destination array
	2514	* srcType - source pixel type
	2515	* source - source data pointer
	2516	* unpacking - pixel unpacking parameters
	2517	* applyTransferOps - apply offset/bias/lookup ops?
	2518	*/
	2519	void
	2520	_mesa_unpack_stencil_span( const GLcontext *ctx, GLuint n,
	2521	GLenum dstType, GLvoid *dest,
	2522	GLenum srcType, const GLvoid *source,
	2523	const struct gl_pixelstore_attrib *unpacking,
	2524	GLboolean applyTransferOps )
	2525	{
	2526	ASSERT(srcType == GL_BITMAP \|\|
	2527	srcType == GL_UNSIGNED_BYTE \|\|
	2528	srcType == GL_BYTE \|\|
	2529	srcType == GL_UNSIGNED_SHORT \|\|
	2530	srcType == GL_SHORT \|\|
	2531	srcType == GL_UNSIGNED_INT \|\|
	2532	srcType == GL_INT \|\|
	2533	srcType == GL_FLOAT);
	2534
	2535	ASSERT(dstType == GL_UNSIGNED_BYTE \|\|
	2536	dstType == GL_UNSIGNED_SHORT \|\|
	2537	dstType == GL_UNSIGNED_INT);
	2538
	2539	applyTransferOps &= (ctx->Pixel.IndexShift \|\| ctx->Pixel.IndexOffset \|\| ctx->Pixel.MapColorFlag);
	2540
	2541	/*
	2542	* Try simple cases first
	2543	*/
	2544	if (!applyTransferOps && srcType == GL_UNSIGNED_BYTE
	2545	&& dstType == GL_UNSIGNED_BYTE) {
	2546	MEMCPY(dest, source, n * sizeof(GLubyte));
	2547	}
	2548	else if (!applyTransferOps && srcType == GL_UNSIGNED_INT
	2549	&& dstType == GL_UNSIGNED_INT && !unpacking->SwapBytes) {
	2550	MEMCPY(dest, source, n * sizeof(GLuint));
	2551	}
	2552	else {
	2553	/*
	2554	* general solution
	2555	*/
	2556	GLuint indexes[MAX_WIDTH];
	2557	ASSERT(n <= MAX_WIDTH);
	2558
	2559	extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source,
	2560	unpacking);
	2561
	2562	if (applyTransferOps) {
	2563	if (ctx->Pixel.IndexShift \|\| ctx->Pixel.IndexOffset) {
	2564	/* shift and offset indexes */
	2565	gl_shift_and_offset_ci(ctx, n, indexes);
	2566	}
	2567
	2568	if (ctx->Pixel.MapStencilFlag) {
	2569	/* Apply stencil lookup table */
	2570	GLuint mask = ctx->Pixel.MapStoSsize - 1;
	2571	GLuint i;
	2572	for (i=0;i<n;i++) {
	2573	indexes[i] = ctx->Pixel.MapStoS[ indexes[i] & mask ];
	2574	}
	2575	}
	2576	}
	2577
	2578	/* convert to dest type */
	2579	switch (dstType) {
	2580	case GL_UNSIGNED_BYTE:
	2581	{
	2582	GLubyte dst = (GLubyte ) dest;
	2583	GLuint i;
	2584	for (i = 0; i < n; i++) {
	2585	dst[i] = (GLubyte) (indexes[i] & 0xff);
	2586	}
	2587	}
	2588	break;
	2589	case GL_UNSIGNED_SHORT:
	2590	{
	2591	GLuint dst = (GLuint ) dest;
	2592	GLuint i;
	2593	for (i = 0; i < n; i++) {
	2594	dst[i] = (GLushort) (indexes[i] & 0xffff);
	2595	}
	2596	}
	2597	break;
	2598	case GL_UNSIGNED_INT:
	2599	MEMCPY(dest, indexes, n * sizeof(GLuint));
	2600	break;
	2601	default:
	2602	gl_problem(ctx, "bad dstType in _mesa_unpack_stencil_span");
	2603	}
	2604	}
	2605	}
	2606
	2607
	2608
	2609	void
	2610	_mesa_unpack_depth_span( const GLcontext ctx, GLuint n, GLdepth dest,
	2611	GLenum srcType, const GLvoid *source,
	2612	const struct gl_pixelstore_attrib *unpacking,
	2613	GLboolean applyTransferOps )
	2614	{
	2615	GLfloat depth = (GLfloat )MALLOC(n * sizeof(GLfloat));
	2616	if (!depth)
	2617	return;
	2618
	2619	switch (srcType) {
	2620	case GL_BYTE:
	2621	{
	2622	GLuint i;
	2623	const GLubyte src = (const GLubyte ) source;
	2624	for (i = 0; i < n; i++) {
	2625	depth[i] = BYTE_TO_FLOAT(src[i]);
	2626	}
	2627	}
	2628	break;
	2629	case GL_UNSIGNED_BYTE:
	2630	{
	2631	GLuint i;
	2632	const GLubyte src = (const GLubyte ) source;
	2633	for (i = 0; i < n; i++) {
	2634	depth[i] = UBYTE_TO_FLOAT(src[i]);
	2635	}
	2636	}
	2637	break;
	2638	case GL_SHORT:
	2639	{
	2640	GLuint i;
	2641	const GLshort src = (const GLshort ) source;
	2642	for (i = 0; i < n; i++) {
	2643	depth[i] = SHORT_TO_FLOAT(src[i]);
	2644	}
	2645	}
	2646	break;
	2647	case GL_UNSIGNED_SHORT:
	2648	{
	2649	GLuint i;
	2650	const GLushort src = (const GLushort ) source;
	2651	for (i = 0; i < n; i++) {
	2652	depth[i] = USHORT_TO_FLOAT(src[i]);
	2653	}
	2654	}
	2655	break;
	2656	case GL_INT:
	2657	{
	2658	GLuint i;
	2659	const GLint src = (const GLint ) source;
	2660	for (i = 0; i < n; i++) {
	2661	depth[i] = INT_TO_FLOAT(src[i]);
	2662	}
	2663	}
	2664	break;
	2665	case GL_UNSIGNED_INT:
	2666	{
	2667	GLuint i;
	2668	const GLuint src = (const GLuint ) source;
	2669	for (i = 0; i < n; i++) {
	2670	depth[i] = UINT_TO_FLOAT(src[i]);
	2671	}
	2672	}
	2673	break;
	2674	case GL_FLOAT:
	2675	MEMCPY(depth, source, n * sizeof(GLfloat));
	2676	break;
	2677	default:
	2678	gl_problem(NULL, "bad type in _mesa_unpack_depth_span()");
	2679	return;
	2680	}
	2681
	2682
	2683	/* apply depth scale and bias */
	2684	if (ctx->Pixel.DepthScale != 1.0 \|\| ctx->Pixel.DepthBias != 0.0) {
	2685	GLuint i;
	2686	for (i = 0; i < n; i++) {
	2687	depth[i] = depth[i] * ctx->Pixel.DepthScale + ctx->Pixel.DepthBias;
	2688	}
	2689	}
	2690
	2691	/* clamp depth values to [0,1] and convert from floats to integers */
	2692	{
	2693	const GLfloat zs = ctx->Visual->DepthMaxF;
	2694	GLuint i;
	2695	for (i = 0; i < n; i++) {
	2696	dest[i] = (GLdepth) (CLAMP(depth[i], 0.0F, 1.0F) * zs);
	2697	}
	2698	}
	2699
	2700	FREE(depth);
	2701	}
	2702
	2703
	2704
	2705	/*
[2938]	2706	* Unpack image data. Apply byteswapping, byte flipping (bitmap).
	2707	* Return all image data in a contiguous block.
	2708	*/
	2709	void *
	2710	_mesa_unpack_image( GLsizei width, GLsizei height, GLsizei depth,
	2711	GLenum format, GLenum type, const GLvoid *pixels,
	2712	const struct gl_pixelstore_attrib *unpack )
	2713	{
	2714	GLint bytesPerRow, compsPerRow;
	2715	GLboolean flipBytes, swap2, swap4;
	2716
	2717	if (!pixels)
	2718	return NULL; /* not necessarily an error */
	2719
	2720	if (width <= 0 \|\| height <= 0 \|\| depth <= 0)
	2721	return NULL; /* generate error later */
	2722
	2723	if (format == GL_BITMAP) {
	2724	bytesPerRow = (width + 7) >> 3;
	2725	flipBytes = !unpack->LsbFirst;
	2726	swap2 = swap4 = GL_FALSE;
	2727	compsPerRow = 0;
	2728	}
	2729	else {
[3598]	2730	const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
	2731	const GLint components = _mesa_components_in_format(format);
[2938]	2732	GLint bytesPerComp;
	2733	if (bytesPerPixel <= 0 \|\| components <= 0)
	2734	return NULL; /* bad format or type. generate error later */
	2735	bytesPerRow = bytesPerPixel * width;
	2736	bytesPerComp = bytesPerPixel / components;
	2737	flipBytes = GL_FALSE;
	2738	swap2 = (bytesPerComp == 2) && unpack->SwapBytes;
	2739	swap4 = (bytesPerComp == 4) && unpack->SwapBytes;
	2740	compsPerRow = components * width;
[3598]	2741	ASSERT(compsPerRow >= width);
[2938]	2742	}
	2743
	2744	{
	2745	GLubyte destBuffer = (GLubyte )MALLOC(bytesPerRow * height * depth);
	2746	GLubyte *dst;
	2747	GLint img, row;
	2748	if (!destBuffer)
	2749	return NULL; /* generate GL_OUT_OF_MEMORY later */
	2750
	2751	dst = destBuffer;
	2752	for (img = 0; img < depth; img++) {
	2753	for (row = 0; row < height; row++) {
[3598]	2754	const GLvoid *src = _mesa_image_address(unpack, pixels,
[2938]	2755	width, height, format, type, img, row, 0);
	2756	MEMCPY(dst, src, bytesPerRow);
	2757	/* byte flipping/swapping */
	2758	if (flipBytes) {
[3598]	2759	flip_bytes((GLubyte *) dst, bytesPerRow);
[2938]	2760	}
	2761	else if (swap2) {
[3598]	2762	_mesa_swap2((GLushort*) dst, compsPerRow);
[2938]	2763	}
	2764	else if (swap4) {
[3598]	2765	_mesa_swap4((GLuint*) dst, compsPerRow);
[2938]	2766	}
	2767	dst += bytesPerRow;
	2768	}
	2769	}
	2770	return destBuffer;
	2771	}
	2772	}
[3598]	2773
	2774
	2775	/*
	2776	* Unpack bitmap data. Resulting data will be in most-significant-bit-first
	2777	* order with row alignment = 1 byte.
	2778	*/
	2779	GLvoid *
	2780	_mesa_unpack_bitmap( GLint width, GLint height, const GLubyte *pixels,
	2781	const struct gl_pixelstore_attrib *packing )
	2782	{
	2783	GLint bytes, row, width_in_bytes;
	2784	GLubyte buffer, dst;
	2785
	2786	if (!pixels)
	2787	return NULL;
	2788
	2789	/* Alloc dest storage */
	2790	bytes = ((width + 7) / 8 * height);
	2791	buffer = (GLubyte *) MALLOC( bytes );
	2792	if (!buffer)
	2793	return NULL;
	2794
	2795
	2796	width_in_bytes = CEILING( width, 8 );
	2797	dst = buffer;
	2798	for (row = 0; row < height; row++) {
	2799	GLubyte src = (GLubyte )_mesa_image_address( packing, pixels, width, height,
	2800	GL_COLOR_INDEX, GL_BITMAP,
	2801	0, row, 0 );
	2802	if (!src) {
	2803	FREE(buffer);
	2804	return NULL;
	2805	}
	2806
	2807	if (packing->SkipPixels == 0) {
	2808	MEMCPY( dst, src, width_in_bytes );
	2809	if (packing->LsbFirst) {
	2810	flip_bytes( dst, width_in_bytes );
	2811	}
	2812	}
	2813	else {
	2814	/* handling SkipPixels is a bit tricky (no pun intended!) */
	2815	GLint i;
	2816	if (packing->LsbFirst) {
	2817	GLubyte srcMask = 1 << (packing->SkipPixels & 0x7);
	2818	GLubyte dstMask = 128;
	2819	GLubyte *s = src;
	2820	GLubyte *d = dst;
	2821	*d = 0;
	2822	for (i = 0; i < width; i++) {
	2823	if (*s & srcMask) {
	2824	*d \|= dstMask;
	2825	}
	2826	if (srcMask == 128) {
	2827	srcMask = 1;
	2828	s++;
	2829	}
	2830	else {
	2831	srcMask = srcMask << 1;
	2832	}
	2833	if (dstMask == 1) {
	2834	dstMask = 128;
	2835	d++;
	2836	*d = 0;
	2837	}
	2838	else {
	2839	dstMask = dstMask >> 1;
	2840	}
	2841	}
	2842	}
	2843	else {
	2844	GLubyte srcMask = 128 >> (packing->SkipPixels & 0x7);
	2845	GLubyte dstMask = 128;
	2846	GLubyte *s = src;
	2847	GLubyte *d = dst;
	2848	*d = 0;
	2849	for (i = 0; i < width; i++) {
	2850	if (*s & srcMask) {
	2851	*d \|= dstMask;
	2852	}
	2853	if (srcMask == 1) {
	2854	srcMask = 128;
	2855	s++;
	2856	}
	2857	else {
	2858	srcMask = srcMask >> 1;
	2859	}
	2860	if (dstMask == 1) {
	2861	dstMask = 128;
	2862	d++;
	2863	*d = 0;
	2864	}
	2865	else {
	2866	dstMask = dstMask >> 1;
	2867	}
	2868	}
	2869	}
	2870	}
	2871	dst += width_in_bytes;
	2872	}
	2873
	2874	return buffer;
	2875	}
	2876
	2877
	2878	/*
	2879	* Pack bitmap data.
	2880	*/
	2881	void
	2882	_mesa_pack_bitmap( GLint width, GLint height, const GLubyte *source,
	2883	GLubyte dest, const struct gl_pixelstore_attrib packing )
	2884	{
	2885	GLint row, width_in_bytes;
	2886	const GLubyte *src;
	2887
	2888	if (!source)
	2889	return;
	2890
	2891	width_in_bytes = CEILING( width, 8 );
	2892	src = source;
	2893	for (row = 0; row < height; row++) {
	2894	GLubyte dst = (GLubyte )_mesa_image_address( packing, dest, width, height,
	2895	GL_COLOR_INDEX, GL_BITMAP,
	2896	0, row, 0 );
	2897	if (!dst)
	2898	return;
	2899
	2900	if (packing->SkipPixels == 0) {
	2901	MEMCPY( dst, src, width_in_bytes );
	2902	if (packing->LsbFirst) {
	2903	flip_bytes( dst, width_in_bytes );
	2904	}
	2905	}
	2906	else {
	2907	/* handling SkipPixels is a bit tricky (no pun intended!) */
	2908	GLint i;
	2909	if (packing->LsbFirst) {
	2910	GLubyte srcMask = 1 << (packing->SkipPixels & 0x7);
	2911	GLubyte dstMask = 128;
	2912	const GLubyte *s = src;
	2913	GLubyte *d = dst;
	2914	*d = 0;
	2915	for (i = 0; i < width; i++) {
	2916	if (*s & srcMask) {
	2917	*d \|= dstMask;
	2918	}
	2919	if (srcMask == 128) {
	2920	srcMask = 1;
	2921	s++;
	2922	}
	2923	else {
	2924	srcMask = srcMask << 1;
	2925	}
	2926	if (dstMask == 1) {
	2927	dstMask = 128;
	2928	d++;
	2929	*d = 0;
	2930	}
	2931	else {
	2932	dstMask = dstMask >> 1;
	2933	}
	2934	}
	2935	}
	2936	else {
	2937	GLubyte srcMask = 128 >> (packing->SkipPixels & 0x7);
	2938	GLubyte dstMask = 128;
	2939	const GLubyte *s = src;
	2940	GLubyte *d = dst;
	2941	*d = 0;
	2942	for (i = 0; i < width; i++) {
	2943	if (*s & srcMask) {
	2944	*d \|= dstMask;
	2945	}
	2946	if (srcMask == 1) {
	2947	srcMask = 128;
	2948	s++;
	2949	}
	2950	else {
	2951	srcMask = srcMask >> 1;
	2952	}
	2953	if (dstMask == 1) {
	2954	dstMask = 128;
	2955	d++;
	2956	*d = 0;
	2957	}
	2958	else {
	2959	dstMask = dstMask >> 1;
	2960	}
	2961	}
	2962	}
	2963	}
	2964	src += width_in_bytes;
	2965	}
	2966	}

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

Download in other formats: