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

Rev	Author	Line No.	Line
4358	Serge	1	/*
		2	* Mesa 3-D graphics library
		3	*
		4	* Copyright (c) 2011 VMware, Inc.
		5	*
		6	* Permission is hereby granted, free of charge, to any person obtaining a
		7	* copy of this software and associated documentation files (the "Software"),
		8	* to deal in the Software without restriction, including without limitation
		9	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
		10	* and/or sell copies of the Software, and to permit persons to whom the
		11	* Software is furnished to do so, subject to the following conditions:
		12	*
		13	* The above copyright notice and this permission notice shall be included
		14	* in all copies or substantial portions of the Software.
		15	*
		16	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
		17	* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		18	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
		19	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
		20	* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
		21	* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
		22	* OTHER DEALINGS IN THE SOFTWARE.
		23	*/
		24
		25
		26	/**
		27	* Color, depth, stencil packing functions.
		28	* Used to pack basic color, depth and stencil formats to specific
		29	* hardware formats.
		30	*
		31	* There are both per-pixel and per-row packing functions:
		32	* - The former will be used by swrast to write values to the color, depth,
		33	* stencil buffers when drawing points, lines and masked spans.
		34	* - The later will be used for image-oriented functions like glDrawPixels,
		35	* glAccum, and glTexImage.
		36	*/
		37
		38
		39	#include "colormac.h"
		40	#include "format_pack.h"
		41	#include "macros.h"
		42	#include "../../gallium/auxiliary/util/u_format_rgb9e5.h"
		43	#include "../../gallium/auxiliary/util/u_format_r11g11b10f.h"
		44
		45
		46	/** Helper struct for MESA_FORMAT_Z32_FLOAT_X24S8 */
		47	struct z32f_x24s8
		48	{
		49	float z;
		50	uint32_t x24s8;
		51	};
		52
		53
		54	typedef void (*pack_ubyte_rgba_row_func)(GLuint n,
		55	const GLubyte src[][4], void *dst);
		56
		57	typedef void (*pack_float_rgba_row_func)(GLuint n,
		58	const GLfloat src[][4], void *dst);
		59
		60
		61
		62	static inline GLfloat
		63	linear_to_srgb(GLfloat cl)
		64	{
		65	if (cl < 0.0f)
		66	return 0.0f;
		67	else if (cl < 0.0031308f)
		68	return 12.92f * cl;
		69	else if (cl < 1.0f)
		70	return 1.055f * powf(cl, 0.41666f) - 0.055f;
		71	else
		72	return 1.0f;
		73	}
		74
		75
		76	static inline GLubyte
		77	linear_float_to_srgb_ubyte(GLfloat cl)
		78	{
		79	GLubyte res = FLOAT_TO_UBYTE(linear_to_srgb(cl));
		80	return res;
		81	}
		82
		83
		84	static inline GLubyte
		85	linear_ubyte_to_srgb_ubyte(GLubyte cl)
		86	{
		87	GLubyte res = FLOAT_TO_UBYTE(linear_to_srgb(cl / 255.0f));
		88	return res;
		89	}
		90
		91
		92
		93
		94	/*
		95	* MESA_FORMAT_RGBA8888
		96	*/
		97
		98	static void
		99	pack_ubyte_RGBA8888(const GLubyte src[4], void *dst)
		100	{
		101	GLuint d = ((GLuint ) dst);
		102	*d = PACK_COLOR_8888(src[RCOMP], src[GCOMP], src[BCOMP], src[ACOMP]);
		103	}
		104
		105	static void
		106	pack_float_RGBA8888(const GLfloat src[4], void *dst)
		107	{
		108	GLubyte v[4];
		109	_mesa_unclamped_float_rgba_to_ubyte(v, src);
		110	pack_ubyte_RGBA8888(v, dst);
		111	}
		112
		113	static void
		114	pack_row_ubyte_RGBA8888(GLuint n, const GLubyte src[][4], void *dst)
		115	{
		116	GLuint d = ((GLuint ) dst);
		117	GLuint i;
		118	for (i = 0; i < n; i++) {
		119	d[i] = PACK_COLOR_8888(src[i][RCOMP], src[i][GCOMP],
		120	src[i][BCOMP], src[i][ACOMP]);
		121	}
		122	}
		123
		124	static void
		125	pack_row_float_RGBA8888(GLuint n, const GLfloat src[][4], void *dst)
		126	{
		127	GLuint d = ((GLuint ) dst);
		128	GLuint i;
		129	for (i = 0; i < n; i++) {
		130	GLubyte v[4];
		131	_mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
		132	pack_ubyte_RGBA8888(v, d + i);
		133	}
		134	}
		135
		136
		137
		138	/*
		139	* MESA_FORMAT_RGBA8888_REV
		140	*/
		141
		142	static void
		143	pack_ubyte_RGBA8888_REV(const GLubyte src[4], void *dst)
		144	{
		145	GLuint d = ((GLuint ) dst);
		146	*d = PACK_COLOR_8888(src[ACOMP], src[BCOMP], src[GCOMP], src[RCOMP]);
		147	}
		148
		149	static void
		150	pack_float_RGBA8888_REV(const GLfloat src[4], void *dst)
		151	{
		152	GLubyte v[4];
		153	_mesa_unclamped_float_rgba_to_ubyte(v, src);
		154	pack_ubyte_RGBA8888_REV(v, dst);
		155	}
		156
		157	static void
		158	pack_row_ubyte_RGBA8888_REV(GLuint n, const GLubyte src[][4], void *dst)
		159	{
		160	GLuint d = ((GLuint ) dst);
		161	GLuint i;
		162	for (i = 0; i < n; i++) {
		163	d[i] = PACK_COLOR_8888(src[i][ACOMP], src[i][BCOMP],
		164	src[i][GCOMP], src[i][RCOMP]);
		165	}
		166	}
		167
		168	static void
		169	pack_row_float_RGBA8888_REV(GLuint n, const GLfloat src[][4], void *dst)
		170	{
		171	GLuint d = ((GLuint ) dst);
		172	GLuint i;
		173	for (i = 0; i < n; i++) {
		174	GLubyte v[4];
		175	_mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
		176	pack_ubyte_RGBA8888_REV(v, d + i);
		177	}
		178	}
		179
		180
		181	/*
		182	* MESA_FORMAT_ARGB8888
		183	*/
		184
		185	static void
		186	pack_ubyte_ARGB8888(const GLubyte src[4], void *dst)
		187	{
		188	GLuint d = ((GLuint ) dst);
		189	*d = PACK_COLOR_8888(src[ACOMP], src[RCOMP], src[GCOMP], src[BCOMP]);
		190	}
		191
		192	static void
		193	pack_float_ARGB8888(const GLfloat src[4], void *dst)
		194	{
		195	GLubyte v[4];
		196	_mesa_unclamped_float_rgba_to_ubyte(v, src);
		197	pack_ubyte_ARGB8888(v, dst);
		198	}
		199
		200	static void
		201	pack_row_ubyte_ARGB8888(GLuint n, const GLubyte src[][4], void *dst)
		202	{
		203	GLuint d = ((GLuint ) dst);
		204	GLuint i;
		205	for (i = 0; i < n; i++) {
		206	d[i] = PACK_COLOR_8888(src[i][ACOMP], src[i][RCOMP],
		207	src[i][GCOMP], src[i][BCOMP]);
		208	}
		209	}
		210
		211	static void
		212	pack_row_float_ARGB8888(GLuint n, const GLfloat src[][4], void *dst)
		213	{
		214	GLuint d = ((GLuint ) dst);
		215	GLuint i;
		216	for (i = 0; i < n; i++) {
		217	GLubyte v[4];
		218	_mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
		219	pack_ubyte_ARGB8888(v, d + i);
		220	}
		221	}
		222
		223
		224	/*
		225	* MESA_FORMAT_ARGB8888_REV
		226	*/
		227
		228	static void
		229	pack_ubyte_ARGB8888_REV(const GLubyte src[4], void *dst)
		230	{
		231	GLuint d = ((GLuint ) dst);
		232	*d = PACK_COLOR_8888(src[BCOMP], src[GCOMP], src[RCOMP], src[ACOMP]);
		233	}
		234
		235	static void
		236	pack_float_ARGB8888_REV(const GLfloat src[4], void *dst)
		237	{
		238	GLubyte v[4];
		239	_mesa_unclamped_float_rgba_to_ubyte(v, src);
		240	pack_ubyte_ARGB8888_REV(v, dst);
		241	}
		242
		243	static void
		244	pack_row_ubyte_ARGB8888_REV(GLuint n, const GLubyte src[][4], void *dst)
		245	{
		246	GLuint d = ((GLuint ) dst);
		247	GLuint i;
		248	for (i = 0; i < n; i++) {
		249	d[i] = PACK_COLOR_8888(src[i][BCOMP], src[i][GCOMP],
		250	src[i][RCOMP], src[i][ACOMP]);
		251	}
		252	}
		253
		254	static void
		255	pack_row_float_ARGB8888_REV(GLuint n, const GLfloat src[][4], void *dst)
		256	{
		257	GLuint d = ((GLuint ) dst);
		258	GLuint i;
		259	for (i = 0; i < n; i++) {
		260	GLubyte v[4];
		261	_mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
		262	pack_ubyte_ARGB8888_REV(v, d + i);
		263	}
		264	}
		265
		266
		267	/*
		268	* MESA_FORMAT_XRGB8888
		269	*/
		270
		271	static void
		272	pack_ubyte_XRGB8888(const GLubyte src[4], void *dst)
		273	{
		274	GLuint d = ((GLuint ) dst);
		275	*d = PACK_COLOR_8888(0x0, src[RCOMP], src[GCOMP], src[BCOMP]);
		276	}
		277
		278	static void
		279	pack_float_XRGB8888(const GLfloat src[4], void *dst)
		280	{
		281	GLubyte v[4];
		282	_mesa_unclamped_float_rgba_to_ubyte(v, src);
		283	pack_ubyte_XRGB8888(v, dst);
		284	}
		285
		286	static void
		287	pack_row_ubyte_XRGB8888(GLuint n, const GLubyte src[][4], void *dst)
		288	{
		289	GLuint d = ((GLuint ) dst);
		290	GLuint i;
		291	for (i = 0; i < n; i++) {
		292	d[i] = PACK_COLOR_8888(0, src[i][RCOMP], src[i][GCOMP], src[i][BCOMP]);
		293	}
		294	}
		295
		296	static void
		297	pack_row_float_XRGB8888(GLuint n, const GLfloat src[][4], void *dst)
		298	{
		299	GLuint d = ((GLuint ) dst);
		300	GLuint i;
		301	for (i = 0; i < n; i++) {
		302	GLubyte v[4];
		303	_mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
		304	pack_ubyte_XRGB8888(v, d + i);
		305	}
		306	}
		307
		308
		309	/*
		310	* MESA_FORMAT_XRGB8888_REV
		311	*/
		312
		313	static void
		314	pack_ubyte_XRGB8888_REV(const GLubyte src[4], void *dst)
		315	{
		316	GLuint d = ((GLuint ) dst);
		317	*d = PACK_COLOR_8888(src[BCOMP], src[GCOMP], src[RCOMP], 0);
		318	}
		319
		320	static void
		321	pack_float_XRGB8888_REV(const GLfloat src[4], void *dst)
		322	{
		323	GLubyte v[4];
		324	_mesa_unclamped_float_rgba_to_ubyte(v, src);
		325	pack_ubyte_XRGB8888_REV(v, dst);
		326	}
		327
		328	static void
		329	pack_row_ubyte_XRGB8888_REV(GLuint n, const GLubyte src[][4], void *dst)
		330	{
		331	GLuint d = ((GLuint ) dst);
		332	GLuint i;
		333	for (i = 0; i < n; i++) {
		334	d[i] = PACK_COLOR_8888(src[i][BCOMP], src[i][GCOMP], src[i][RCOMP], 0);
		335	}
		336	}
		337
		338	static void
		339	pack_row_float_XRGB8888_REV(GLuint n, const GLfloat src[][4], void *dst)
		340	{
		341	GLuint d = ((GLuint ) dst);
		342	GLuint i;
		343	for (i = 0; i < n; i++) {
		344	GLubyte v[4];
		345	_mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
		346	pack_ubyte_XRGB8888_REV(v, d + i);
		347	}
		348	}
		349
		350
		351	/*
		352	* MESA_FORMAT_RGB888
		353	*/
		354
		355	static void
		356	pack_ubyte_RGB888(const GLubyte src[4], void *dst)
		357	{
		358	GLubyte d = ((GLubyte ) dst);
		359	d[2] = src[RCOMP];
		360	d[1] = src[GCOMP];
		361	d[0] = src[BCOMP];
		362	}
		363
		364	static void
		365	pack_float_RGB888(const GLfloat src[4], void *dst)
		366	{
		367	GLubyte d = ((GLubyte ) dst);
		368	UNCLAMPED_FLOAT_TO_UBYTE(d[2], src[RCOMP]);
		369	UNCLAMPED_FLOAT_TO_UBYTE(d[1], src[GCOMP]);
		370	UNCLAMPED_FLOAT_TO_UBYTE(d[0], src[BCOMP]);
		371	}
		372
		373	static void
		374	pack_row_ubyte_RGB888(GLuint n, const GLubyte src[][4], void *dst)
		375	{
		376	GLubyte d = ((GLubyte ) dst);
		377	GLuint i;
		378	for (i = 0; i < n; i++) {
		379	d[i*3+2] = src[i][RCOMP];
		380	d[i*3+1] = src[i][GCOMP];
		381	d[i*3+0] = src[i][BCOMP];
		382	}
		383	}
		384
		385	static void
		386	pack_row_float_RGB888(GLuint n, const GLfloat src[][4], void *dst)
		387	{
		388	GLubyte d = ((GLubyte ) dst);
		389	GLuint i;
		390	for (i = 0; i < n; i++) {
		391	GLubyte v[4];
		392	_mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
		393	d[i*3+2] = v[RCOMP];
		394	d[i*3+1] = v[GCOMP];
		395	d[i*3+0] = v[BCOMP];
		396	}
		397	}
		398
		399
		400	/*
		401	* MESA_FORMAT_BGR888
		402	*/
		403
		404	static void
		405	pack_ubyte_BGR888(const GLubyte src[4], void *dst)
		406	{
		407	GLubyte d = ((GLubyte ) dst);
		408	d[2] = src[BCOMP];
		409	d[1] = src[GCOMP];
		410	d[0] = src[RCOMP];
		411	}
		412
		413	static void
		414	pack_float_BGR888(const GLfloat src[4], void *dst)
		415	{
		416	GLubyte d = ((GLubyte ) dst);
		417	UNCLAMPED_FLOAT_TO_UBYTE(d[2], src[BCOMP]);
		418	UNCLAMPED_FLOAT_TO_UBYTE(d[1], src[GCOMP]);
		419	UNCLAMPED_FLOAT_TO_UBYTE(d[0], src[RCOMP]);
		420	}
		421
		422	static void
		423	pack_row_ubyte_BGR888(GLuint n, const GLubyte src[][4], void *dst)
		424	{
		425	GLubyte d = ((GLubyte ) dst);
		426	GLuint i;
		427	for (i = 0; i < n; i++) {
		428	d[i*3+2] = src[i][BCOMP];
		429	d[i*3+1] = src[i][GCOMP];
		430	d[i*3+0] = src[i][RCOMP];
		431	}
		432	}
		433
		434	static void
		435	pack_row_float_BGR888(GLuint n, const GLfloat src[][4], void *dst)
		436	{
		437	GLubyte d = ((GLubyte ) dst);
		438	GLuint i;
		439	for (i = 0; i < n; i++) {
		440	GLubyte v[4];
		441	_mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
		442	d[i*3+2] = v[BCOMP];
		443	d[i*3+1] = v[GCOMP];
		444	d[i*3+0] = v[RCOMP];
		445	}
		446	}
		447
		448
		449	/*
		450	* MESA_FORMAT_RGB565
		451	*/
		452
		453	static void
		454	pack_ubyte_RGB565(const GLubyte src[4], void *dst)
		455	{
		456	GLushort d = ((GLushort ) dst);
		457	*d = PACK_COLOR_565(src[RCOMP], src[GCOMP], src[BCOMP]);
		458	}
		459
		460	static void
		461	pack_float_RGB565(const GLfloat src[4], void *dst)
		462	{
		463	GLubyte v[3];
		464	UNCLAMPED_FLOAT_TO_UBYTE(v[0], src[RCOMP]);
		465	UNCLAMPED_FLOAT_TO_UBYTE(v[1], src[GCOMP]);
		466	UNCLAMPED_FLOAT_TO_UBYTE(v[2], src[BCOMP]);
		467	pack_ubyte_RGB565(v, dst);
		468	}
		469
		470	static void
		471	pack_row_ubyte_RGB565(GLuint n, const GLubyte src[][4], void *dst)
		472	{
		473	GLushort d = ((GLushort ) dst);
		474	GLuint i;
		475	for (i = 0; i < n; i++) {
		476	pack_ubyte_RGB565(src[i], d + i);
		477	}
		478	}
		479
		480	static void
		481	pack_row_float_RGB565(GLuint n, const GLfloat src[][4], void *dst)
		482	{
		483	GLushort d = ((GLushort ) dst);
		484	GLuint i;
		485	for (i = 0; i < n; i++) {
		486	GLubyte v[4];
		487	_mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
		488	pack_ubyte_RGB565(v, d + i);
		489	}
		490	}
		491
		492
		493	/*
		494	* MESA_FORMAT_RGB565_REV
		495	*/
		496
		497	static void
		498	pack_ubyte_RGB565_REV(const GLubyte src[4], void *dst)
		499	{
		500	GLushort d = ((GLushort ) dst);
		501	*d = PACK_COLOR_565_REV(src[RCOMP], src[GCOMP], src[BCOMP]);
		502	}
		503
		504	static void
		505	pack_float_RGB565_REV(const GLfloat src[4], void *dst)
		506	{
		507	GLushort d = ((GLushort ) dst);
		508	GLubyte r, g, b;
		509	UNCLAMPED_FLOAT_TO_UBYTE(r, src[RCOMP]);
		510	UNCLAMPED_FLOAT_TO_UBYTE(g, src[GCOMP]);
		511	UNCLAMPED_FLOAT_TO_UBYTE(b, src[BCOMP]);
		512	*d = PACK_COLOR_565_REV(r, g, b);
		513	}
		514
		515	static void
		516	pack_row_ubyte_RGB565_REV(GLuint n, const GLubyte src[][4], void *dst)
		517	{
		518	GLushort d = ((GLushort ) dst);
		519	GLuint i;
		520	for (i = 0; i < n; i++) {
		521	pack_ubyte_RGB565_REV(src[i], d + i);
		522	}
		523	}
		524
		525	static void
		526	pack_row_float_RGB565_REV(GLuint n, const GLfloat src[][4], void *dst)
		527	{
		528	GLushort d = ((GLushort ) dst);
		529	GLuint i;
		530	for (i = 0; i < n; i++) {
		531	GLubyte v[4];
		532	_mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
		533	pack_ubyte_RGB565_REV(v, d + i);
		534	}
		535	}
		536
		537
		538	/*
		539	* MESA_FORMAT_ARGB4444
		540	*/
		541
		542	static void
		543	pack_ubyte_ARGB4444(const GLubyte src[4], void *dst)
		544	{
		545	GLushort d = ((GLushort ) dst);
		546	*d = PACK_COLOR_4444(src[ACOMP], src[RCOMP], src[GCOMP], src[BCOMP]);
		547	}
		548
		549	static void
		550	pack_float_ARGB4444(const GLfloat src[4], void *dst)
		551	{
		552	GLubyte v[4];
		553	_mesa_unclamped_float_rgba_to_ubyte(v, src);
		554	pack_ubyte_ARGB4444(v, dst);
		555	}
		556
		557	/* use fallback row packing functions */
		558
		559
		560	/*
		561	* MESA_FORMAT_ARGB4444_REV
		562	*/
		563
		564	static void
		565	pack_ubyte_ARGB4444_REV(const GLubyte src[4], void *dst)
		566	{
		567	GLushort d = ((GLushort ) dst);
		568	*d = PACK_COLOR_4444(src[GCOMP], src[BCOMP], src[ACOMP], src[RCOMP]);
		569	}
		570
		571	static void
		572	pack_float_ARGB4444_REV(const GLfloat src[4], void *dst)
		573	{
		574	GLubyte v[4];
		575	_mesa_unclamped_float_rgba_to_ubyte(v, src);
		576	pack_ubyte_ARGB4444_REV(v, dst);
		577	}
		578
		579	/* use fallback row packing functions */
		580
		581
		582	/*
		583	* MESA_FORMAT_RGBA5551
		584	*/
		585
		586	static void
		587	pack_ubyte_RGBA5551(const GLubyte src[4], void *dst)
		588	{
		589	GLushort d = ((GLushort ) dst);
		590	*d = PACK_COLOR_5551(src[RCOMP], src[GCOMP], src[BCOMP], src[ACOMP]);
		591	}
		592
		593	static void
		594	pack_float_RGBA5551(const GLfloat src[4], void *dst)
		595	{
		596	GLubyte v[4];
		597	_mesa_unclamped_float_rgba_to_ubyte(v, src);
		598	pack_ubyte_RGBA5551(v, dst);
		599	}
		600
		601	/* use fallback row packing functions */
		602
		603
		604	/*
		605	* MESA_FORMAT_ARGB1555
		606	*/
		607
		608	static void
		609	pack_ubyte_ARGB1555(const GLubyte src[4], void *dst)
		610	{
		611	GLushort d = ((GLushort ) dst);
		612	*d = PACK_COLOR_1555(src[ACOMP], src[RCOMP], src[GCOMP], src[BCOMP]);
		613	}
		614
		615	static void
		616	pack_float_ARGB1555(const GLfloat src[4], void *dst)
		617	{
		618	GLubyte v[4];
		619	_mesa_unclamped_float_rgba_to_ubyte(v, src);
		620	pack_ubyte_ARGB1555(v, dst);
		621	}
		622
		623
		624	/* MESA_FORMAT_ARGB1555_REV */
		625
		626	static void
		627	pack_ubyte_ARGB1555_REV(const GLubyte src[4], void *dst)
		628	{
		629	GLushort d = ((GLushort ) dst), tmp;
		630	tmp = PACK_COLOR_1555(src[ACOMP], src[RCOMP], src[GCOMP], src[BCOMP]);
		631	*d = (tmp >> 8) \| (tmp << 8);
		632	}
		633
		634	static void
		635	pack_float_ARGB1555_REV(const GLfloat src[4], void *dst)
		636	{
		637	GLubyte v[4];
		638	_mesa_unclamped_float_rgba_to_ubyte(v, src);
		639	pack_ubyte_ARGB1555_REV(v, dst);
		640	}
		641
		642
		643	/* MESA_FORMAT_AL44 */
		644
		645	static void
		646	pack_ubyte_AL44(const GLubyte src[4], void *dst)
		647	{
		648	GLubyte d = ((GLubyte ) dst);
		649	*d = PACK_COLOR_44(src[ACOMP], src[RCOMP]);
		650	}
		651
		652	static void
		653	pack_float_AL44(const GLfloat src[4], void *dst)
		654	{
		655	GLubyte v[4];
		656	UNCLAMPED_FLOAT_TO_UBYTE(v[0], src[RCOMP]);
		657	UNCLAMPED_FLOAT_TO_UBYTE(v[3], src[ACOMP]);
		658	pack_ubyte_AL44(v, dst);
		659	}
		660
		661
		662	/* MESA_FORMAT_AL88 */
		663
		664	static void
		665	pack_ubyte_AL88(const GLubyte src[4], void *dst)
		666	{
		667	GLushort d = ((GLushort ) dst);
		668	*d = PACK_COLOR_88(src[ACOMP], src[RCOMP]);
		669	}
		670
		671	static void
		672	pack_float_AL88(const GLfloat src[4], void *dst)
		673	{
		674	GLubyte v[4];
		675	UNCLAMPED_FLOAT_TO_UBYTE(v[0], src[RCOMP]);
		676	UNCLAMPED_FLOAT_TO_UBYTE(v[3], src[ACOMP]);
		677	pack_ubyte_AL88(v, dst);
		678	}
		679
		680
		681	/* MESA_FORMAT_AL88_REV */
		682
		683	static void
		684	pack_ubyte_AL88_REV(const GLubyte src[4], void *dst)
		685	{
		686	GLushort d = ((GLushort ) dst);
		687	*d = PACK_COLOR_88(src[RCOMP], src[ACOMP]);
		688	}
		689
		690	static void
		691	pack_float_AL88_REV(const GLfloat src[4], void *dst)
		692	{
		693	GLubyte v[4];
		694	UNCLAMPED_FLOAT_TO_UBYTE(v[0], src[RCOMP]);
		695	UNCLAMPED_FLOAT_TO_UBYTE(v[3], src[ACOMP]);
		696	pack_ubyte_AL88_REV(v, dst);
		697	}
		698
		699
		700	/* MESA_FORMAT_AL1616 */
		701
		702	static void
		703	pack_ubyte_AL1616(const GLubyte src[4], void *dst)
		704	{
		705	GLuint d = ((GLuint ) dst);
		706	GLushort l = UBYTE_TO_USHORT(src[RCOMP]);
		707	GLushort a = UBYTE_TO_USHORT(src[ACOMP]);
		708	*d = PACK_COLOR_1616(a, l);
		709	}
		710
		711	static void
		712	pack_float_AL1616(const GLfloat src[4], void *dst)
		713	{
		714	GLuint d = ((GLuint ) dst);
		715	GLushort l, a;
		716	UNCLAMPED_FLOAT_TO_USHORT(l, src[RCOMP]);
		717	UNCLAMPED_FLOAT_TO_USHORT(a, src[ACOMP]);
		718	*d = PACK_COLOR_1616(a, l);
		719	}
		720
		721
		722	/* MESA_FORMAT_AL1616_REV */
		723
		724	static void
		725	pack_ubyte_AL1616_REV(const GLubyte src[4], void *dst)
		726	{
		727	GLuint d = ((GLuint ) dst);
		728	GLushort l = UBYTE_TO_USHORT(src[RCOMP]);
		729	GLushort a = UBYTE_TO_USHORT(src[ACOMP]);
		730	*d = PACK_COLOR_1616(l, a);
		731	}
		732
		733	static void
		734	pack_float_AL1616_REV(const GLfloat src[4], void *dst)
		735	{
		736	GLuint d = ((GLuint ) dst);
		737	GLushort l, a;
		738	UNCLAMPED_FLOAT_TO_USHORT(l, src[RCOMP]);
		739	UNCLAMPED_FLOAT_TO_USHORT(a, src[ACOMP]);
		740	*d = PACK_COLOR_1616(l, a);
		741	}
		742
		743
		744	/* MESA_FORMAT_RGB332 */
		745
		746	static void
		747	pack_ubyte_RGB332(const GLubyte src[4], void *dst)
		748	{
		749	GLubyte d = ((GLubyte ) dst);
		750	*d = PACK_COLOR_332(src[RCOMP], src[GCOMP], src[BCOMP]);
		751	}
		752
		753	static void
		754	pack_float_RGB332(const GLfloat src[4], void *dst)
		755	{
		756	GLubyte v[4];
		757	UNCLAMPED_FLOAT_TO_UBYTE(v[0], src[RCOMP]);
		758	UNCLAMPED_FLOAT_TO_UBYTE(v[1], src[GCOMP]);
		759	UNCLAMPED_FLOAT_TO_UBYTE(v[2], src[BCOMP]);
		760	pack_ubyte_RGB332(v, dst);
		761	}
		762
		763
		764	/* MESA_FORMAT_A8 */
		765
		766	static void
		767	pack_ubyte_A8(const GLubyte src[4], void *dst)
		768	{
		769	GLubyte d = ((GLubyte ) dst);
		770	*d = src[ACOMP];
		771	}
		772
		773	static void
		774	pack_float_A8(const GLfloat src[4], void *dst)
		775	{
		776	GLubyte d = ((GLubyte ) dst);
		777	UNCLAMPED_FLOAT_TO_UBYTE(d[0], src[ACOMP]);
		778	}
		779
		780
		781	/* MESA_FORMAT_A16 */
		782
		783	static void
		784	pack_ubyte_A16(const GLubyte src[4], void *dst)
		785	{
		786	GLushort d = ((GLushort ) dst);
		787	*d = UBYTE_TO_USHORT(src[ACOMP]);
		788	}
		789
		790	static void
		791	pack_float_A16(const GLfloat src[4], void *dst)
		792	{
		793	GLushort d = ((GLushort ) dst);
		794	UNCLAMPED_FLOAT_TO_USHORT(d[0], src[ACOMP]);
		795	}
		796
		797
		798	/* MESA_FORMAT_L8 */
		799
		800	static void
		801	pack_ubyte_L8(const GLubyte src[4], void *dst)
		802	{
		803	GLubyte d = ((GLubyte ) dst);
		804	*d = src[RCOMP];
		805	}
		806
		807	static void
		808	pack_float_L8(const GLfloat src[4], void *dst)
		809	{
		810	GLubyte d = ((GLubyte ) dst);
		811	UNCLAMPED_FLOAT_TO_UBYTE(d[0], src[RCOMP]);
		812	}
		813
		814
		815	/* MESA_FORMAT_L16 */
		816
		817	static void
		818	pack_ubyte_L16(const GLubyte src[4], void *dst)
		819	{
		820	GLushort d = ((GLushort ) dst);
		821	*d = UBYTE_TO_USHORT(src[RCOMP]);
		822	}
		823
		824	static void
		825	pack_float_L16(const GLfloat src[4], void *dst)
		826	{
		827	GLushort d = ((GLushort ) dst);
		828	UNCLAMPED_FLOAT_TO_USHORT(d[0], src[RCOMP]);
		829	}
		830
		831
		832	/* MESA_FORMAT_YCBCR */
		833
		834	static void
		835	pack_ubyte_YCBCR(const GLubyte src[4], void *dst)
		836	{
		837	/* todo */
		838	}
		839
		840	static void
		841	pack_float_YCBCR(const GLfloat src[4], void *dst)
		842	{
		843	/* todo */
		844	}
		845
		846
		847	/* MESA_FORMAT_YCBCR_REV */
		848
		849	static void
		850	pack_ubyte_YCBCR_REV(const GLubyte src[4], void *dst)
		851	{
		852	/* todo */
		853	}
		854
		855	static void
		856	pack_float_YCBCR_REV(const GLfloat src[4], void *dst)
		857	{
		858	/* todo */
		859	}
		860
		861
		862	/* MESA_FORMAT_R8 */
		863
		864	static void
		865	pack_ubyte_R8(const GLubyte src[4], void *dst)
		866	{
		867	GLubyte d = ((GLubyte ) dst);
		868	*d = src[RCOMP];
		869	}
		870
		871	static void
		872	pack_float_R8(const GLfloat src[4], void *dst)
		873	{
		874	GLubyte d = ((GLubyte ) dst);
		875	GLubyte r;
		876	UNCLAMPED_FLOAT_TO_UBYTE(r, src[RCOMP]);
		877	d[0] = r;
		878	}
		879
		880
		881	/* MESA_FORMAT_GR88 */
		882
		883	static void
		884	pack_ubyte_GR88(const GLubyte src[4], void *dst)
		885	{
		886	GLubyte d = ((GLubyte ) dst);
		887	*d = PACK_COLOR_88(src[GCOMP], src[RCOMP]);
		888	}
		889
		890	static void
		891	pack_float_GR88(const GLfloat src[4], void *dst)
		892	{
		893	GLushort d = ((GLushort ) dst);
		894	GLubyte r, g;
		895	UNCLAMPED_FLOAT_TO_UBYTE(r, src[RCOMP]);
		896	UNCLAMPED_FLOAT_TO_UBYTE(g, src[GCOMP]);
		897	*d = PACK_COLOR_88(g, r);
		898	}
		899
		900
		901	/* MESA_FORMAT_RG88 */
		902
		903	static void
		904	pack_ubyte_RG88(const GLubyte src[4], void *dst)
		905	{
		906	GLubyte d = ((GLubyte ) dst);
		907	*d = PACK_COLOR_88(src[RCOMP], src[GCOMP]);
		908	}
		909
		910	static void
		911	pack_float_RG88(const GLfloat src[4], void *dst)
		912	{
		913	GLushort d = ((GLushort ) dst);
		914	GLubyte r, g;
		915	UNCLAMPED_FLOAT_TO_UBYTE(r, src[RCOMP]);
		916	UNCLAMPED_FLOAT_TO_UBYTE(g, src[GCOMP]);
		917	*d = PACK_COLOR_88(r, g);
		918	}
		919
		920
		921	/* MESA_FORMAT_R16 */
		922
		923	static void
		924	pack_ubyte_R16(const GLubyte src[4], void *dst)
		925	{
		926	GLushort d = ((GLushort ) dst);
		927	*d = UBYTE_TO_USHORT(src[RCOMP]);
		928	}
		929
		930	static void
		931	pack_float_R16(const GLfloat src[4], void *dst)
		932	{
		933	GLushort d = ((GLushort ) dst);
		934	UNCLAMPED_FLOAT_TO_USHORT(d[0], src[RCOMP]);
		935	}
		936
		937
		938	/* MESA_FORMAT_GR1616 */
		939
		940	static void
		941	pack_ubyte_GR1616(const GLubyte src[4], void *dst)
		942	{
		943	GLuint d = ((GLuint ) dst);
		944	GLushort r = UBYTE_TO_USHORT(src[RCOMP]);
		945	GLushort g = UBYTE_TO_USHORT(src[GCOMP]);
		946	*d = PACK_COLOR_1616(g, r);
		947	}
		948
		949	static void
		950	pack_float_GR1616(const GLfloat src[4], void *dst)
		951	{
		952	GLuint d = ((GLuint ) dst);
		953	GLushort r, g;
		954	UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
		955	UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
		956	*d = PACK_COLOR_1616(g, r);
		957	}
		958
		959
		960	/* MESA_FORMAT_RG1616 */
		961
		962	static void
		963	pack_ubyte_RG1616(const GLubyte src[4], void *dst)
		964	{
		965	GLuint d = ((GLuint ) dst);
		966	GLushort r = UBYTE_TO_USHORT(src[RCOMP]);
		967	GLushort g = UBYTE_TO_USHORT(src[GCOMP]);
		968	*d = PACK_COLOR_1616(r, g);
		969	}
		970
		971
		972	static void
		973	pack_float_RG1616(const GLfloat src[4], void *dst)
		974	{
		975	GLuint d = ((GLuint ) dst);
		976	GLushort r, g;
		977	UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
		978	UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
		979	*d = PACK_COLOR_1616(r, g);
		980	}
		981
		982
		983	/* MESA_FORMAT_ARGB2101010 */
		984
		985	static void
		986	pack_ubyte_ARGB2101010(const GLubyte src[4], void *dst)
		987	{
		988	GLuint d = ((GLuint ) dst);
		989	GLushort r = UBYTE_TO_USHORT(src[RCOMP]);
		990	GLushort g = UBYTE_TO_USHORT(src[GCOMP]);
		991	GLushort b = UBYTE_TO_USHORT(src[BCOMP]);
		992	GLushort a = UBYTE_TO_USHORT(src[ACOMP]);
		993	*d = PACK_COLOR_2101010_US(a, r, g, b);
		994	}
		995
		996	static void
		997	pack_float_ARGB2101010(const GLfloat src[4], void *dst)
		998	{
		999	GLuint d = ((GLuint ) dst);
		1000	GLushort r, g, b, a;
		1001	UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
		1002	UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
		1003	UNCLAMPED_FLOAT_TO_USHORT(b, src[BCOMP]);
		1004	UNCLAMPED_FLOAT_TO_USHORT(a, src[ACOMP]);
		1005	*d = PACK_COLOR_2101010_US(a, r, g, b);
		1006	}
		1007
		1008
		1009	/* MESA_FORMAT_ABGR2101010_UINT */
		1010
		1011	static void
		1012	pack_ubyte_ABGR2101010_UINT(const GLubyte src[4], void *dst)
		1013	{
		1014	GLuint d = ((GLuint ) dst);
		1015	GLushort r = UBYTE_TO_USHORT(src[RCOMP]);
		1016	GLushort g = UBYTE_TO_USHORT(src[GCOMP]);
		1017	GLushort b = UBYTE_TO_USHORT(src[BCOMP]);
		1018	GLushort a = UBYTE_TO_USHORT(src[ACOMP]);
		1019	*d = PACK_COLOR_2101010_US(a, b, g, r);
		1020	}
		1021
		1022	static void
		1023	pack_float_ABGR2101010_UINT(const GLfloat src[4], void *dst)
		1024	{
		1025	GLuint d = ((GLuint ) dst);
		1026	GLushort r, g, b, a;
		1027	UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
		1028	UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
		1029	UNCLAMPED_FLOAT_TO_USHORT(b, src[BCOMP]);
		1030	UNCLAMPED_FLOAT_TO_USHORT(a, src[ACOMP]);
		1031	*d = PACK_COLOR_2101010_US(a, b, g, r);
		1032	}
		1033
		1034
		1035	/* MESA_FORMAT_SRGB8 */
		1036
		1037	static void
		1038	pack_ubyte_SRGB8(const GLubyte src[4], void *dst)
		1039	{
		1040	GLubyte d = ((GLubyte ) dst);
		1041	d[2] = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
		1042	d[1] = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
		1043	d[0] = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
		1044	}
		1045
		1046	static void
		1047	pack_float_SRGB8(const GLfloat src[4], void *dst)
		1048	{
		1049	GLubyte d = ((GLubyte ) dst);
		1050	d[2] = linear_float_to_srgb_ubyte(src[RCOMP]);
		1051	d[1] = linear_float_to_srgb_ubyte(src[GCOMP]);
		1052	d[0] = linear_float_to_srgb_ubyte(src[BCOMP]);
		1053	}
		1054
		1055
		1056	/* MESA_FORMAT_SRGBA8 */
		1057
		1058	static void
		1059	pack_ubyte_SRGBA8(const GLubyte src[4], void *dst)
		1060	{
		1061	GLuint d = ((GLuint ) dst);
		1062	GLubyte r = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
		1063	GLubyte g = linear_ubyte_to_srgb_ubyte(src[GCOMP]);
		1064	GLubyte b = linear_ubyte_to_srgb_ubyte(src[BCOMP]);
		1065	*d = PACK_COLOR_8888(r, g, b, src[ACOMP]);
		1066	}
		1067
		1068	static void
		1069	pack_float_SRGBA8(const GLfloat src[4], void *dst)
		1070	{
		1071	GLuint d = ((GLuint ) dst);
		1072	GLubyte r, g, b, a;
		1073	r = linear_float_to_srgb_ubyte(src[RCOMP]);
		1074	g = linear_float_to_srgb_ubyte(src[GCOMP]);
		1075	b = linear_float_to_srgb_ubyte(src[BCOMP]);
		1076	UNCLAMPED_FLOAT_TO_UBYTE(a, src[ACOMP]);
		1077	*d = PACK_COLOR_8888(r, g, b, a);
		1078	}
		1079
		1080
		1081	/* MESA_FORMAT_SARGB8 */
		1082
		1083	static void
		1084	pack_ubyte_SARGB8(const GLubyte src[4], void *dst)
		1085	{
		1086	GLuint d = ((GLuint ) dst);
		1087	GLubyte r = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
		1088	GLubyte g = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
		1089	GLubyte b = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
		1090	*d = PACK_COLOR_8888(src[ACOMP], r, g, b);
		1091	}
		1092
		1093	static void
		1094	pack_float_SARGB8(const GLfloat src[4], void *dst)
		1095	{
		1096	GLuint d = ((GLuint ) dst);
		1097	GLubyte r, g, b, a;
		1098	r = linear_float_to_srgb_ubyte(src[RCOMP]);
		1099	g = linear_float_to_srgb_ubyte(src[GCOMP]);
		1100	b = linear_float_to_srgb_ubyte(src[BCOMP]);
		1101	UNCLAMPED_FLOAT_TO_UBYTE(a, src[ACOMP]);
		1102	*d = PACK_COLOR_8888(a, r, g, b);
		1103	}
		1104
		1105
		1106	/* MESA_FORMAT_SL8 */
		1107
		1108	static void
		1109	pack_ubyte_SL8(const GLubyte src[4], void *dst)
		1110	{
		1111	GLubyte d = ((GLubyte ) dst);
		1112	*d = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
		1113	}
		1114
		1115	static void
		1116	pack_float_SL8(const GLfloat src[4], void *dst)
		1117	{
		1118	GLubyte d = ((GLubyte ) dst);
		1119	GLubyte l = linear_float_to_srgb_ubyte(src[RCOMP]);
		1120	*d = l;
		1121	}
		1122
		1123
		1124	/* MESA_FORMAT_SLA8 */
		1125
		1126	static void
		1127	pack_ubyte_SLA8(const GLubyte src[4], void *dst)
		1128	{
		1129	GLushort d = ((GLushort ) dst);
		1130	GLubyte l = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
		1131	*d = PACK_COLOR_88(src[ACOMP], l);
		1132	}
		1133
		1134	static void
		1135	pack_float_SLA8(const GLfloat src[4], void *dst)
		1136	{
		1137	GLushort d = ((GLushort ) dst);
		1138	GLubyte a, l = linear_float_to_srgb_ubyte(src[RCOMP]);
		1139	CLAMPED_FLOAT_TO_UBYTE(a, src[ACOMP]);
		1140	*d = PACK_COLOR_88(a, l);
		1141	}
		1142
		1143
		1144	/* MESA_FORMAT_RGBA_FLOAT32 */
		1145
		1146	static void
		1147	pack_ubyte_RGBA_FLOAT32(const GLubyte src[4], void *dst)
		1148	{
		1149	GLfloat d = ((GLfloat ) dst);
		1150	d[0] = UBYTE_TO_FLOAT(src[0]);
		1151	d[1] = UBYTE_TO_FLOAT(src[1]);
		1152	d[2] = UBYTE_TO_FLOAT(src[2]);
		1153	d[3] = UBYTE_TO_FLOAT(src[3]);
		1154	}
		1155
		1156	static void
		1157	pack_float_RGBA_FLOAT32(const GLfloat src[4], void *dst)
		1158	{
		1159	GLfloat d = ((GLfloat ) dst);
		1160	d[0] = src[0];
		1161	d[1] = src[1];
		1162	d[2] = src[2];
		1163	d[3] = src[3];
		1164	}
		1165
		1166
		1167	/* MESA_FORMAT_RGBA_FLOAT16 */
		1168
		1169	static void
		1170	pack_ubyte_RGBA_FLOAT16(const GLubyte src[4], void *dst)
		1171	{
		1172	GLhalfARB d = ((GLhalfARB ) dst);
		1173	d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[0]));
		1174	d[1] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[1]));
		1175	d[2] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[2]));
		1176	d[3] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[3]));
		1177	}
		1178
		1179	static void
		1180	pack_float_RGBA_FLOAT16(const GLfloat src[4], void *dst)
		1181	{
		1182	GLhalfARB d = ((GLhalfARB ) dst);
		1183	d[0] = _mesa_float_to_half(src[0]);
		1184	d[1] = _mesa_float_to_half(src[1]);
		1185	d[2] = _mesa_float_to_half(src[2]);
		1186	d[3] = _mesa_float_to_half(src[3]);
		1187	}
		1188
		1189
		1190	/* MESA_FORMAT_RGB_FLOAT32 */
		1191
		1192	static void
		1193	pack_ubyte_RGB_FLOAT32(const GLubyte src[4], void *dst)
		1194	{
		1195	GLfloat d = ((GLfloat ) dst);
		1196	d[0] = UBYTE_TO_FLOAT(src[0]);
		1197	d[1] = UBYTE_TO_FLOAT(src[1]);
		1198	d[2] = UBYTE_TO_FLOAT(src[2]);
		1199	}
		1200
		1201	static void
		1202	pack_float_RGB_FLOAT32(const GLfloat src[4], void *dst)
		1203	{
		1204	GLfloat d = ((GLfloat ) dst);
		1205	d[0] = src[0];
		1206	d[1] = src[1];
		1207	d[2] = src[2];
		1208	}
		1209
		1210
		1211	/* MESA_FORMAT_RGB_FLOAT16 */
		1212
		1213	static void
		1214	pack_ubyte_RGB_FLOAT16(const GLubyte src[4], void *dst)
		1215	{
		1216	GLhalfARB d = ((GLhalfARB ) dst);
		1217	d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[0]));
		1218	d[1] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[1]));
		1219	d[2] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[2]));
		1220	}
		1221
		1222	static void
		1223	pack_float_RGB_FLOAT16(const GLfloat src[4], void *dst)
		1224	{
		1225	GLhalfARB d = ((GLhalfARB ) dst);
		1226	d[0] = _mesa_float_to_half(src[0]);
		1227	d[1] = _mesa_float_to_half(src[1]);
		1228	d[2] = _mesa_float_to_half(src[2]);
		1229	}
		1230
		1231
		1232	/* MESA_FORMAT_ALPHA_FLOAT32 */
		1233
		1234	static void
		1235	pack_ubyte_ALPHA_FLOAT32(const GLubyte src[4], void *dst)
		1236	{
		1237	GLfloat d = ((GLfloat ) dst);
		1238	d[0] = UBYTE_TO_FLOAT(src[ACOMP]);
		1239	}
		1240
		1241	static void
		1242	pack_float_ALPHA_FLOAT32(const GLfloat src[4], void *dst)
		1243	{
		1244	GLfloat d = ((GLfloat ) dst);
		1245	d[0] = src[ACOMP];
		1246	}
		1247
		1248
		1249	/* MESA_FORMAT_ALPHA_FLOAT16 */
		1250
		1251	static void
		1252	pack_ubyte_ALPHA_FLOAT16(const GLubyte src[4], void *dst)
		1253	{
		1254	GLhalfARB d = ((GLhalfARB ) dst);
		1255	d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[ACOMP]));
		1256	}
		1257
		1258	static void
		1259	pack_float_ALPHA_FLOAT16(const GLfloat src[4], void *dst)
		1260	{
		1261	GLhalfARB d = ((GLhalfARB ) dst);
		1262	d[0] = _mesa_float_to_half(src[ACOMP]);
		1263	}
		1264
		1265
		1266	/* MESA_FORMAT_LUMINANCE_FLOAT32 (and INTENSITY_FLOAT32, R_FLOAT32) */
		1267
		1268	static void
		1269	pack_ubyte_LUMINANCE_FLOAT32(const GLubyte src[4], void *dst)
		1270	{
		1271	GLfloat d = ((GLfloat ) dst);
		1272	d[0] = UBYTE_TO_FLOAT(src[RCOMP]);
		1273	}
		1274
		1275	static void
		1276	pack_float_LUMINANCE_FLOAT32(const GLfloat src[4], void *dst)
		1277	{
		1278	GLfloat d = ((GLfloat ) dst);
		1279	d[0] = src[RCOMP];
		1280	}
		1281
		1282
		1283	/* MESA_FORMAT_LUMINANCE_FLOAT16 (and INTENSITY_FLOAT16, R_FLOAT32) */
		1284
		1285	static void
		1286	pack_ubyte_LUMINANCE_FLOAT16(const GLubyte src[4], void *dst)
		1287	{
		1288	GLhalfARB d = ((GLhalfARB ) dst);
		1289	d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[RCOMP]));
		1290	}
		1291
		1292	static void
		1293	pack_float_LUMINANCE_FLOAT16(const GLfloat src[4], void *dst)
		1294	{
		1295	GLhalfARB d = ((GLhalfARB ) dst);
		1296	d[0] = _mesa_float_to_half(src[RCOMP]);
		1297	}
		1298
		1299
		1300	/* MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32 */
		1301
		1302	static void
		1303	pack_ubyte_LUMINANCE_ALPHA_FLOAT32(const GLubyte src[4], void *dst)
		1304	{
		1305	GLfloat d = ((GLfloat ) dst);
		1306	d[0] = UBYTE_TO_FLOAT(src[RCOMP]);
		1307	d[1] = UBYTE_TO_FLOAT(src[ACOMP]);
		1308	}
		1309
		1310	static void
		1311	pack_float_LUMINANCE_ALPHA_FLOAT32(const GLfloat src[4], void *dst)
		1312	{
		1313	GLfloat d = ((GLfloat ) dst);
		1314	d[0] = src[RCOMP];
		1315	d[1] = src[ACOMP];
		1316	}
		1317
		1318
		1319	/* MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16 */
		1320
		1321	static void
		1322	pack_ubyte_LUMINANCE_ALPHA_FLOAT16(const GLubyte src[4], void *dst)
		1323	{
		1324	GLhalfARB d = ((GLhalfARB ) dst);
		1325	d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[RCOMP]));
		1326	d[1] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[ACOMP]));
		1327	}
		1328
		1329	static void
		1330	pack_float_LUMINANCE_ALPHA_FLOAT16(const GLfloat src[4], void *dst)
		1331	{
		1332	GLhalfARB d = ((GLhalfARB ) dst);
		1333	d[0] = _mesa_float_to_half(src[RCOMP]);
		1334	d[1] = _mesa_float_to_half(src[ACOMP]);
		1335	}
		1336
		1337
		1338	/* MESA_FORMAT_RG_FLOAT32 */
		1339
		1340	static void
		1341	pack_ubyte_RG_FLOAT32(const GLubyte src[4], void *dst)
		1342	{
		1343	GLfloat d = ((GLfloat ) dst);
		1344	d[0] = UBYTE_TO_FLOAT(src[RCOMP]);
		1345	d[1] = UBYTE_TO_FLOAT(src[GCOMP]);
		1346	}
		1347
		1348	static void
		1349	pack_float_RG_FLOAT32(const GLfloat src[4], void *dst)
		1350	{
		1351	GLfloat d = ((GLfloat ) dst);
		1352	d[0] = src[RCOMP];
		1353	d[1] = src[GCOMP];
		1354	}
		1355
		1356
		1357	/* MESA_FORMAT_RG_FLOAT16 */
		1358
		1359	static void
		1360	pack_ubyte_RG_FLOAT16(const GLubyte src[4], void *dst)
		1361	{
		1362	GLhalfARB d = ((GLhalfARB ) dst);
		1363	d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[RCOMP]));
		1364	d[1] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[GCOMP]));
		1365	}
		1366
		1367	static void
		1368	pack_float_RG_FLOAT16(const GLfloat src[4], void *dst)
		1369	{
		1370	GLhalfARB d = ((GLhalfARB ) dst);
		1371	d[0] = _mesa_float_to_half(src[RCOMP]);
		1372	d[1] = _mesa_float_to_half(src[GCOMP]);
		1373	}
		1374
		1375
		1376	/* MESA_FORMAT_DUDV8 */
		1377
		1378	static void
		1379	pack_ubyte_DUDV8(const GLubyte src[4], void *dst)
		1380	{
		1381	/* XXX is this ever used? */
		1382	GLushort d = ((GLushort ) dst);
		1383	*d = PACK_COLOR_88(src[0], src[1]);
		1384	}
		1385
		1386	static void
		1387	pack_float_DUDV8(const GLfloat src[4], void *dst)
		1388	{
		1389	GLushort d = ((GLushort ) dst);
		1390	GLbyte du, dv;
		1391	du = FLOAT_TO_BYTE(CLAMP(src[0], 0.0F, 1.0F));
		1392	dv = FLOAT_TO_BYTE(CLAMP(src[1], 0.0F, 1.0F));
		1393	*d = PACK_COLOR_88(du, dv);
		1394	}
		1395
		1396
		1397	/* MESA_FORMAT_RGBA_16 */
		1398
		1399	static void
		1400	pack_ubyte_RGBA_16(const GLubyte src[4], void *dst)
		1401	{
		1402	GLushort d = ((GLushort ) dst);
		1403	d[0] = UBYTE_TO_USHORT(src[RCOMP]);
		1404	d[1] = UBYTE_TO_USHORT(src[GCOMP]);
		1405	d[2] = UBYTE_TO_USHORT(src[BCOMP]);
		1406	d[3] = UBYTE_TO_USHORT(src[ACOMP]);
		1407	}
		1408
		1409	static void
		1410	pack_float_RGBA_16(const GLfloat src[4], void *dst)
		1411	{
		1412	GLushort d = ((GLushort ) dst);
		1413	UNCLAMPED_FLOAT_TO_USHORT(d[0], src[RCOMP]);
		1414	UNCLAMPED_FLOAT_TO_USHORT(d[1], src[GCOMP]);
		1415	UNCLAMPED_FLOAT_TO_USHORT(d[2], src[BCOMP]);
		1416	UNCLAMPED_FLOAT_TO_USHORT(d[3], src[ACOMP]);
		1417	}
		1418
		1419
		1420
		1421	/*
		1422	* MESA_FORMAT_SIGNED_R8
		1423	*/
		1424
		1425	static void
		1426	pack_float_SIGNED_R8(const GLfloat src[4], void *dst)
		1427	{
		1428	GLbyte d = (GLbyte ) dst;
		1429	*d = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
		1430	}
		1431
		1432
		1433	/*
		1434	* MESA_FORMAT_SIGNED_RG88_REV
		1435	*/
		1436
		1437	static void
		1438	pack_float_SIGNED_RG88_REV(const GLfloat src[4], void *dst)
		1439	{
		1440	GLushort d = (GLushort ) dst;
		1441	GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
		1442	GLbyte g = FLOAT_TO_BYTE(CLAMP(src[GCOMP], -1.0f, 1.0f));
		1443	*d = (g << 8) \| r;
		1444	}
		1445
		1446
		1447	/*
		1448	* MESA_FORMAT_SIGNED_RGBX8888
		1449	*/
		1450
		1451	static void
		1452	pack_float_SIGNED_RGBX8888(const GLfloat src[4], void *dst)
		1453	{
		1454	GLuint d = (GLuint ) dst;
		1455	GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
		1456	GLbyte g = FLOAT_TO_BYTE(CLAMP(src[GCOMP], -1.0f, 1.0f));
		1457	GLbyte b = FLOAT_TO_BYTE(CLAMP(src[BCOMP], -1.0f, 1.0f));
		1458	GLbyte a = 127;
		1459	*d = PACK_COLOR_8888(r, g, b, a);
		1460	}
		1461
		1462
		1463	/*
		1464	* MESA_FORMAT_SIGNED_RGBA8888
		1465	*/
		1466
		1467	static void
		1468	pack_float_SIGNED_RGBA8888(const GLfloat src[4], void *dst)
		1469	{
		1470	GLuint d = (GLuint ) dst;
		1471	GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
		1472	GLbyte g = FLOAT_TO_BYTE(CLAMP(src[GCOMP], -1.0f, 1.0f));
		1473	GLbyte b = FLOAT_TO_BYTE(CLAMP(src[BCOMP], -1.0f, 1.0f));
		1474	GLbyte a = FLOAT_TO_BYTE(CLAMP(src[ACOMP], -1.0f, 1.0f));
		1475	*d = PACK_COLOR_8888(r, g, b, a);
		1476	}
		1477
		1478
		1479	/*
		1480	* MESA_FORMAT_SIGNED_RGBA8888_REV
		1481	*/
		1482
		1483	static void
		1484	pack_float_SIGNED_RGBA8888_REV(const GLfloat src[4], void *dst)
		1485	{
		1486	GLuint d = (GLuint ) dst;
		1487	GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
		1488	GLbyte g = FLOAT_TO_BYTE(CLAMP(src[GCOMP], -1.0f, 1.0f));
		1489	GLbyte b = FLOAT_TO_BYTE(CLAMP(src[BCOMP], -1.0f, 1.0f));
		1490	GLbyte a = FLOAT_TO_BYTE(CLAMP(src[ACOMP], -1.0f, 1.0f));
		1491	*d = PACK_COLOR_8888(a, b, g, r);
		1492	}
		1493
		1494
		1495	/*
		1496	* MESA_FORMAT_SIGNED_R16
		1497	*/
		1498
		1499	static void
		1500	pack_float_SIGNED_R16(const GLfloat src[4], void *dst)
		1501	{
		1502	GLshort d = (GLshort ) dst;
		1503	*d = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
		1504	}
		1505
		1506
		1507	/*
		1508	* MESA_FORMAT_SIGNED_GR1616
		1509	*/
		1510
		1511	static void
		1512	pack_float_SIGNED_GR1616(const GLfloat src[4], void *dst)
		1513	{
		1514	GLuint d = (GLuint ) dst;
		1515	GLshort r = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
		1516	GLshort g = FLOAT_TO_SHORT(CLAMP(src[GCOMP], -1.0f, 1.0f));
		1517	*d = (g << 16) \| (r & 0xffff);
		1518	}
		1519
		1520
		1521	/*
		1522	* MESA_FORMAT_SIGNED_RGB_16
		1523	*/
		1524
		1525	static void
		1526	pack_float_SIGNED_RGB_16(const GLfloat src[4], void *dst)
		1527	{
		1528	GLshort d = (GLshort ) dst;
		1529	d[0] = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
		1530	d[1] = FLOAT_TO_SHORT(CLAMP(src[GCOMP], -1.0f, 1.0f));
		1531	d[2] = FLOAT_TO_SHORT(CLAMP(src[BCOMP], -1.0f, 1.0f));
		1532	}
		1533
		1534
		1535	/*
		1536	* MESA_FORMAT_SIGNED_RGBA_16
		1537	*/
		1538
		1539	static void
		1540	pack_float_SIGNED_RGBA_16(const GLfloat src[4], void *dst)
		1541	{
		1542	GLshort d = (GLshort ) dst;
		1543	d[0] = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
		1544	d[1] = FLOAT_TO_SHORT(CLAMP(src[GCOMP], -1.0f, 1.0f));
		1545	d[2] = FLOAT_TO_SHORT(CLAMP(src[BCOMP], -1.0f, 1.0f));
		1546	d[3] = FLOAT_TO_SHORT(CLAMP(src[ACOMP], -1.0f, 1.0f));
		1547	}
		1548
		1549
		1550	/*
		1551	* MESA_FORMAT_SIGNED_A8
		1552	*/
		1553
		1554	static void
		1555	pack_float_SIGNED_A8(const GLfloat src[4], void *dst)
		1556	{
		1557	GLbyte d = (GLbyte ) dst;
		1558	*d = FLOAT_TO_BYTE(CLAMP(src[ACOMP], -1.0f, 1.0f));
		1559	}
		1560
		1561
		1562	/*
		1563	* MESA_FORMAT_SIGNED_L8
		1564	*/
		1565
		1566	static void
		1567	pack_float_SIGNED_L8(const GLfloat src[4], void *dst)
		1568	{
		1569	GLbyte d = (GLbyte ) dst;
		1570	*d = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
		1571	}
		1572
		1573
		1574	/*
		1575	* MESA_FORMAT_SIGNED_AL88
		1576	*/
		1577
		1578	static void
		1579	pack_float_SIGNED_AL88(const GLfloat src[4], void *dst)
		1580	{
		1581	GLushort d = (GLushort ) dst;
		1582	GLbyte l = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
		1583	GLbyte a = FLOAT_TO_BYTE(CLAMP(src[ACOMP], -1.0f, 1.0f));
		1584	*d = (a << 8) \| l;
		1585	}
		1586
		1587
		1588	/*
		1589	* MESA_FORMAT_SIGNED_A16
		1590	*/
		1591
		1592	static void
		1593	pack_float_SIGNED_A16(const GLfloat src[4], void *dst)
		1594	{
		1595	GLshort d = (GLshort ) dst;
		1596	*d = FLOAT_TO_SHORT(CLAMP(src[ACOMP], -1.0f, 1.0f));
		1597	}
		1598
		1599
		1600	/*
		1601	* MESA_FORMAT_SIGNED_L16
		1602	*/
		1603
		1604	static void
		1605	pack_float_SIGNED_L16(const GLfloat src[4], void *dst)
		1606	{
		1607	GLshort d = (GLshort ) dst;
		1608	*d = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
		1609	}
		1610
		1611
		1612	/*
		1613	* MESA_FORMAT_SIGNED_AL1616
		1614	*/
		1615
		1616	static void
		1617	pack_float_SIGNED_AL1616(const GLfloat src[4], void *dst)
		1618	{
		1619	GLuint d = (GLuint ) dst;
		1620	GLshort l = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
		1621	GLshort a = FLOAT_TO_SHORT(CLAMP(src[ACOMP], -1.0f, 1.0f));
		1622	*d = PACK_COLOR_1616(a, l);
		1623	}
		1624
		1625
		1626	/*
		1627	* MESA_FORMAT_RGB9_E5_FLOAT;
		1628	*/
		1629
		1630	static void
		1631	pack_float_RGB9_E5_FLOAT(const GLfloat src[4], void *dst)
		1632	{
		1633	GLuint d = (GLuint ) dst;
		1634	*d = float3_to_rgb9e5(src);
		1635	}
		1636
		1637	static void
		1638	pack_ubyte_RGB9_E5_FLOAT(const GLubyte src[4], void *dst)
		1639	{
		1640	GLuint d = (GLuint ) dst;
		1641	GLfloat rgb[3];
		1642	rgb[0] = UBYTE_TO_FLOAT(src[RCOMP]);
		1643	rgb[1] = UBYTE_TO_FLOAT(src[GCOMP]);
		1644	rgb[2] = UBYTE_TO_FLOAT(src[BCOMP]);
		1645	*d = float3_to_rgb9e5(rgb);
		1646	}
		1647
		1648
		1649
		1650	/*
		1651	* MESA_FORMAT_R11_G11_B10_FLOAT;
		1652	*/
		1653
		1654	static void
		1655	pack_ubyte_R11_G11_B10_FLOAT(const GLubyte src[4], void *dst)
		1656	{
		1657	GLuint d = (GLuint ) dst;
		1658	GLfloat rgb[3];
		1659	rgb[0] = UBYTE_TO_FLOAT(src[RCOMP]);
		1660	rgb[1] = UBYTE_TO_FLOAT(src[GCOMP]);
		1661	rgb[2] = UBYTE_TO_FLOAT(src[BCOMP]);
		1662	*d = float3_to_r11g11b10f(rgb);
		1663	}
		1664
		1665	static void
		1666	pack_float_R11_G11_B10_FLOAT(const GLfloat src[4], void *dst)
		1667	{
		1668	GLuint d = (GLuint ) dst;
		1669	*d = float3_to_r11g11b10f(src);
		1670	}
		1671
		1672
		1673	/*
		1674	* MESA_FORMAT_XRGB4444_UNORM
		1675	*/
		1676
		1677	static void
		1678	pack_ubyte_XRGB4444_UNORM(const GLubyte src[4], void *dst)
		1679	{
		1680	GLushort d = ((GLushort ) dst);
		1681	*d = PACK_COLOR_4444(255, src[RCOMP], src[GCOMP], src[BCOMP]);
		1682	}
		1683
		1684	static void
		1685	pack_float_XRGB4444_UNORM(const GLfloat src[4], void *dst)
		1686	{
		1687	GLubyte v[4];
		1688	_mesa_unclamped_float_rgba_to_ubyte(v, src);
		1689	pack_ubyte_XRGB4444_UNORM(v, dst);
		1690	}
		1691
		1692
		1693	/*
		1694	* MESA_FORMAT_XRGB1555_UNORM
		1695	*/
		1696
		1697	static void
		1698	pack_ubyte_XRGB1555_UNORM(const GLubyte src[4], void *dst)
		1699	{
		1700	GLushort d = ((GLushort ) dst);
		1701	*d = PACK_COLOR_1555(255, src[RCOMP], src[GCOMP], src[BCOMP]);
		1702	}
		1703
		1704	static void
		1705	pack_float_XRGB1555_UNORM(const GLfloat src[4], void *dst)
		1706	{
		1707	GLubyte v[4];
		1708	_mesa_unclamped_float_rgba_to_ubyte(v, src);
		1709	pack_ubyte_XRGB1555_UNORM(v, dst);
		1710	}
		1711
		1712
		1713	/*
		1714	* MESA_FORMAT_XBGR8888_SNORM
		1715	*/
		1716
		1717	static void
		1718	pack_float_XBGR8888_SNORM(const GLfloat src[4], void *dst)
		1719	{
		1720	GLuint d = (GLuint ) dst;
		1721	GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
		1722	GLbyte g = FLOAT_TO_BYTE(CLAMP(src[GCOMP], -1.0f, 1.0f));
		1723	GLbyte b = FLOAT_TO_BYTE(CLAMP(src[BCOMP], -1.0f, 1.0f));
		1724	*d = PACK_COLOR_8888(127, b, g, r);
		1725	}
		1726
		1727
		1728	/*
		1729	* MESA_FORMAT_XBGR8888_SRGB
		1730	*/
		1731
		1732	static void
		1733	pack_float_XBGR8888_SRGB(const GLfloat src[4], void *dst)
		1734	{
		1735	GLuint d = (GLuint ) dst;
		1736	GLubyte r = linear_float_to_srgb_ubyte(src[RCOMP]);
		1737	GLubyte g = linear_float_to_srgb_ubyte(src[GCOMP]);
		1738	GLubyte b = linear_float_to_srgb_ubyte(src[BCOMP]);
		1739	*d = PACK_COLOR_8888(127, b, g, r);
		1740	}
		1741
		1742
		1743	/* MESA_FORMAT_XRGB2101010_UNORM */
		1744
		1745	static void
		1746	pack_ubyte_XRGB2101010_UNORM(const GLubyte src[4], void *dst)
		1747	{
		1748	GLuint d = ((GLuint ) dst);
		1749	GLushort r = UBYTE_TO_USHORT(src[RCOMP]);
		1750	GLushort g = UBYTE_TO_USHORT(src[GCOMP]);
		1751	GLushort b = UBYTE_TO_USHORT(src[BCOMP]);
		1752	*d = PACK_COLOR_2101010_US(3, r, g, b);
		1753	}
		1754
		1755	static void
		1756	pack_float_XRGB2101010_UNORM(const GLfloat src[4], void *dst)
		1757	{
		1758	GLuint d = ((GLuint ) dst);
		1759	GLushort r, g, b;
		1760	UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
		1761	UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
		1762	UNCLAMPED_FLOAT_TO_USHORT(b, src[BCOMP]);
		1763	*d = PACK_COLOR_2101010_US(3, r, g, b);
		1764	}
		1765
		1766
		1767	/* MESA_FORMAT_XBGR16161616_UNORM */
		1768
		1769	static void
		1770	pack_ubyte_XBGR16161616_UNORM(const GLubyte src[4], void *dst)
		1771	{
		1772	GLushort d = ((GLushort ) dst);
		1773	d[0] = UBYTE_TO_USHORT(src[RCOMP]);
		1774	d[1] = UBYTE_TO_USHORT(src[GCOMP]);
		1775	d[2] = UBYTE_TO_USHORT(src[BCOMP]);
		1776	d[3] = 65535;
		1777	}
		1778
		1779	static void
		1780	pack_float_XBGR16161616_UNORM(const GLfloat src[4], void *dst)
		1781	{
		1782	GLushort d = ((GLushort ) dst);
		1783	UNCLAMPED_FLOAT_TO_USHORT(d[0], src[RCOMP]);
		1784	UNCLAMPED_FLOAT_TO_USHORT(d[1], src[GCOMP]);
		1785	UNCLAMPED_FLOAT_TO_USHORT(d[2], src[BCOMP]);
		1786	d[3] = 65535;
		1787	}
		1788
		1789
		1790	/* MESA_FORMAT_XBGR16161616_SNORM */
		1791
		1792	static void
		1793	pack_float_XBGR16161616_SNORM(const GLfloat src[4], void *dst)
		1794	{
		1795	GLushort d = ((GLushort ) dst);
		1796	UNCLAMPED_FLOAT_TO_SHORT(d[0], src[RCOMP]);
		1797	UNCLAMPED_FLOAT_TO_SHORT(d[1], src[GCOMP]);
		1798	UNCLAMPED_FLOAT_TO_SHORT(d[2], src[BCOMP]);
		1799	d[3] = 32767;
		1800	}
		1801
		1802
		1803	/* MESA_FORMAT_XBGR16161616_FLOAT */
		1804
		1805	static void
		1806	pack_float_XBGR16161616_FLOAT(const GLfloat src[4], void *dst)
		1807	{
		1808	GLushort d = ((GLushort ) dst);
		1809	d[0] = _mesa_float_to_half(src[RCOMP]);
		1810	d[1] = _mesa_float_to_half(src[GCOMP]);
		1811	d[2] = _mesa_float_to_half(src[BCOMP]);
		1812	d[3] = _mesa_float_to_half(1.0);
		1813	}
		1814
		1815	/* MESA_FORMAT_XBGR32323232_FLOAT */
		1816
		1817	static void
		1818	pack_float_XBGR32323232_FLOAT(const GLfloat src[4], void *dst)
		1819	{
		1820	GLfloat d = ((GLfloat ) dst);
		1821	d[0] = src[RCOMP];
		1822	d[1] = src[GCOMP];
		1823	d[2] = src[BCOMP];
		1824	d[3] = 1.0;
		1825	}
		1826
		1827
		1828	/**
		1829	* Return a function that can pack a GLubyte rgba[4] color.
		1830	*/
		1831	gl_pack_ubyte_rgba_func
		1832	_mesa_get_pack_ubyte_rgba_function(gl_format format)
		1833	{
		1834	static gl_pack_ubyte_rgba_func table[MESA_FORMAT_COUNT];
		1835	static GLboolean initialized = GL_FALSE;
		1836
		1837	if (!initialized) {
		1838	memset(table, 0, sizeof(table));
		1839
		1840	table[MESA_FORMAT_NONE] = NULL;
		1841
		1842	table[MESA_FORMAT_RGBA8888] = pack_ubyte_RGBA8888;
		1843	table[MESA_FORMAT_RGBA8888_REV] = pack_ubyte_RGBA8888_REV;
		1844	table[MESA_FORMAT_ARGB8888] = pack_ubyte_ARGB8888;
		1845	table[MESA_FORMAT_ARGB8888_REV] = pack_ubyte_ARGB8888_REV;
		1846	table[MESA_FORMAT_RGBX8888] = pack_ubyte_RGBA8888; /* reused */
		1847	table[MESA_FORMAT_RGBX8888_REV] = pack_ubyte_RGBA8888_REV; /* reused */
		1848	table[MESA_FORMAT_XRGB8888] = pack_ubyte_XRGB8888;
		1849	table[MESA_FORMAT_XRGB8888_REV] = pack_ubyte_XRGB8888_REV;
		1850	table[MESA_FORMAT_RGB888] = pack_ubyte_RGB888;
		1851	table[MESA_FORMAT_BGR888] = pack_ubyte_BGR888;
		1852	table[MESA_FORMAT_RGB565] = pack_ubyte_RGB565;
		1853	table[MESA_FORMAT_RGB565_REV] = pack_ubyte_RGB565_REV;
		1854	table[MESA_FORMAT_ARGB4444] = pack_ubyte_ARGB4444;
		1855	table[MESA_FORMAT_ARGB4444_REV] = pack_ubyte_ARGB4444_REV;
		1856	table[MESA_FORMAT_RGBA5551] = pack_ubyte_RGBA5551;
		1857	table[MESA_FORMAT_ARGB1555] = pack_ubyte_ARGB1555;
		1858	table[MESA_FORMAT_ARGB1555_REV] = pack_ubyte_ARGB1555_REV;
		1859	table[MESA_FORMAT_AL44] = pack_ubyte_AL44;
		1860	table[MESA_FORMAT_AL88] = pack_ubyte_AL88;
		1861	table[MESA_FORMAT_AL88_REV] = pack_ubyte_AL88_REV;
		1862	table[MESA_FORMAT_AL1616] = pack_ubyte_AL1616;
		1863	table[MESA_FORMAT_AL1616_REV] = pack_ubyte_AL1616_REV;
		1864	table[MESA_FORMAT_RGB332] = pack_ubyte_RGB332;
		1865	table[MESA_FORMAT_A8] = pack_ubyte_A8;
		1866	table[MESA_FORMAT_A16] = pack_ubyte_A16;
		1867	table[MESA_FORMAT_L8] = pack_ubyte_L8;
		1868	table[MESA_FORMAT_L16] = pack_ubyte_L16;
		1869	table[MESA_FORMAT_I8] = pack_ubyte_L8; /* reuse pack_ubyte_L8 */
		1870	table[MESA_FORMAT_I16] = pack_ubyte_L16; /* reuse pack_ubyte_L16 */
		1871	table[MESA_FORMAT_YCBCR] = pack_ubyte_YCBCR;
		1872	table[MESA_FORMAT_YCBCR_REV] = pack_ubyte_YCBCR_REV;
		1873	table[MESA_FORMAT_R8] = pack_ubyte_R8;
		1874	table[MESA_FORMAT_GR88] = pack_ubyte_GR88;
		1875	table[MESA_FORMAT_RG88] = pack_ubyte_RG88;
		1876	table[MESA_FORMAT_R16] = pack_ubyte_R16;
		1877	table[MESA_FORMAT_GR1616] = pack_ubyte_GR1616;
		1878	table[MESA_FORMAT_RG1616] = pack_ubyte_RG1616;
		1879	table[MESA_FORMAT_ARGB2101010] = pack_ubyte_ARGB2101010;
		1880	table[MESA_FORMAT_ABGR2101010_UINT] = pack_ubyte_ABGR2101010_UINT;
		1881
		1882	/* should never convert RGBA to these formats */
		1883	table[MESA_FORMAT_Z24_S8] = NULL;
		1884	table[MESA_FORMAT_S8_Z24] = NULL;
		1885	table[MESA_FORMAT_Z16] = NULL;
		1886	table[MESA_FORMAT_X8_Z24] = NULL;
		1887	table[MESA_FORMAT_Z24_X8] = NULL;
		1888	table[MESA_FORMAT_Z32] = NULL;
		1889	table[MESA_FORMAT_S8] = NULL;
		1890
		1891	/* sRGB */
		1892	table[MESA_FORMAT_SRGB8] = pack_ubyte_SRGB8;
		1893	table[MESA_FORMAT_SRGBA8] = pack_ubyte_SRGBA8;
		1894	table[MESA_FORMAT_SARGB8] = pack_ubyte_SARGB8;
		1895	table[MESA_FORMAT_SL8] = pack_ubyte_SL8;
		1896	table[MESA_FORMAT_SLA8] = pack_ubyte_SLA8;
		1897
		1898	/* n/a */
		1899	table[MESA_FORMAT_SRGB_DXT1] = NULL; /* pack_ubyte_SRGB_DXT1; */
		1900	table[MESA_FORMAT_SRGBA_DXT1] = NULL; /* pack_ubyte_SRGBA_DXT1; */
		1901	table[MESA_FORMAT_SRGBA_DXT3] = NULL; /* pack_ubyte_SRGBA_DXT3; */
		1902	table[MESA_FORMAT_SRGBA_DXT5] = NULL; /* pack_ubyte_SRGBA_DXT5; */
		1903
		1904	table[MESA_FORMAT_RGB_FXT1] = NULL; /* pack_ubyte_RGB_FXT1; */
		1905	table[MESA_FORMAT_RGBA_FXT1] = NULL; /* pack_ubyte_RGBA_FXT1; */
		1906	table[MESA_FORMAT_RGB_DXT1] = NULL; /* pack_ubyte_RGB_DXT1; */
		1907	table[MESA_FORMAT_RGBA_DXT1] = NULL; /* pack_ubyte_RGBA_DXT1; */
		1908	table[MESA_FORMAT_RGBA_DXT3] = NULL; /* pack_ubyte_RGBA_DXT3; */
		1909	table[MESA_FORMAT_RGBA_DXT5] = NULL; /* pack_ubyte_RGBA_DXT5; */
		1910
		1911	table[MESA_FORMAT_RGBA_FLOAT32] = pack_ubyte_RGBA_FLOAT32;
		1912	table[MESA_FORMAT_RGBA_FLOAT16] = pack_ubyte_RGBA_FLOAT16;
		1913	table[MESA_FORMAT_RGB_FLOAT32] = pack_ubyte_RGB_FLOAT32;
		1914	table[MESA_FORMAT_RGB_FLOAT16] = pack_ubyte_RGB_FLOAT16;
		1915	table[MESA_FORMAT_ALPHA_FLOAT32] = pack_ubyte_ALPHA_FLOAT32;
		1916	table[MESA_FORMAT_ALPHA_FLOAT16] = pack_ubyte_ALPHA_FLOAT16;
		1917	table[MESA_FORMAT_LUMINANCE_FLOAT32] = pack_ubyte_LUMINANCE_FLOAT32;
		1918	table[MESA_FORMAT_LUMINANCE_FLOAT16] = pack_ubyte_LUMINANCE_FLOAT16;
		1919	table[MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32] = pack_ubyte_LUMINANCE_ALPHA_FLOAT32;
		1920	table[MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16] = pack_ubyte_LUMINANCE_ALPHA_FLOAT16;
		1921	table[MESA_FORMAT_INTENSITY_FLOAT32] = pack_ubyte_LUMINANCE_FLOAT32;
		1922	table[MESA_FORMAT_INTENSITY_FLOAT16] = pack_ubyte_LUMINANCE_FLOAT16;
		1923	table[MESA_FORMAT_R_FLOAT32] = pack_ubyte_LUMINANCE_FLOAT32;
		1924	table[MESA_FORMAT_R_FLOAT16] = pack_ubyte_LUMINANCE_FLOAT16;
		1925	table[MESA_FORMAT_RG_FLOAT32] = pack_ubyte_RG_FLOAT32;
		1926	table[MESA_FORMAT_RG_FLOAT16] = pack_ubyte_RG_FLOAT16;
		1927
		1928	/* n/a */
		1929	table[MESA_FORMAT_RGBA_INT8] = NULL; /* pack_ubyte_RGBA_INT8 */
		1930	table[MESA_FORMAT_RGBA_INT16] = NULL; /* pack_ubyte_RGBA_INT16 */
		1931	table[MESA_FORMAT_RGBA_INT32] = NULL; /* pack_ubyte_RGBA_INT32 */
		1932	table[MESA_FORMAT_RGBA_UINT8] = NULL; /* pack_ubyte_RGBA_UINT8 */
		1933	table[MESA_FORMAT_RGBA_UINT16] = NULL; /* pack_ubyte_RGBA_UINT16 */
		1934	table[MESA_FORMAT_RGBA_UINT32] = NULL; /* pack_ubyte_RGBA_UINT32 */
		1935
		1936	table[MESA_FORMAT_DUDV8] = pack_ubyte_DUDV8;
		1937
		1938	table[MESA_FORMAT_RGBA_16] = pack_ubyte_RGBA_16;
		1939
		1940	/* n/a */
		1941	table[MESA_FORMAT_SIGNED_R8] = NULL;
		1942	table[MESA_FORMAT_SIGNED_RG88_REV] = NULL;
		1943	table[MESA_FORMAT_SIGNED_RGBX8888] = NULL;
		1944	table[MESA_FORMAT_SIGNED_RGBA8888] = NULL;
		1945	table[MESA_FORMAT_SIGNED_RGBA8888_REV] = NULL;
		1946	table[MESA_FORMAT_SIGNED_R16] = NULL;
		1947	table[MESA_FORMAT_SIGNED_GR1616] = NULL;
		1948	table[MESA_FORMAT_SIGNED_RGB_16] = NULL;
		1949	table[MESA_FORMAT_SIGNED_RGBA_16] = NULL;
		1950	table[MESA_FORMAT_SIGNED_A8] = NULL;
		1951	table[MESA_FORMAT_SIGNED_L8] = NULL;
		1952	table[MESA_FORMAT_SIGNED_AL88] = NULL;
		1953	table[MESA_FORMAT_SIGNED_I8] = NULL;
		1954	table[MESA_FORMAT_SIGNED_A16] = NULL;
		1955	table[MESA_FORMAT_SIGNED_L16] = NULL;
		1956	table[MESA_FORMAT_SIGNED_AL1616] = NULL;
		1957	table[MESA_FORMAT_SIGNED_I16] = NULL;
		1958
		1959
		1960	table[MESA_FORMAT_RGBA_16] = pack_ubyte_RGBA_16;
		1961
		1962	table[MESA_FORMAT_RGB9_E5_FLOAT] = pack_ubyte_RGB9_E5_FLOAT;
		1963	table[MESA_FORMAT_R11_G11_B10_FLOAT] = pack_ubyte_R11_G11_B10_FLOAT;
		1964
		1965	table[MESA_FORMAT_XRGB4444_UNORM] = pack_ubyte_XRGB4444_UNORM;
		1966	table[MESA_FORMAT_XRGB1555_UNORM] = pack_ubyte_XRGB1555_UNORM;
		1967	table[MESA_FORMAT_XBGR8888_SNORM] = NULL;
		1968	table[MESA_FORMAT_XBGR8888_SRGB] = NULL;
		1969	table[MESA_FORMAT_XBGR8888_UINT] = NULL;
		1970	table[MESA_FORMAT_XBGR8888_SINT] = NULL;
		1971	table[MESA_FORMAT_XRGB2101010_UNORM] = pack_ubyte_XRGB2101010_UNORM;
		1972	table[MESA_FORMAT_XBGR16161616_UNORM] = pack_ubyte_XBGR16161616_UNORM;
		1973	table[MESA_FORMAT_XBGR16161616_SNORM] = NULL;
		1974	table[MESA_FORMAT_XBGR16161616_FLOAT] = NULL;
		1975	table[MESA_FORMAT_XBGR16161616_UINT] = NULL;
		1976	table[MESA_FORMAT_XBGR16161616_SINT] = NULL;
		1977	table[MESA_FORMAT_XBGR32323232_FLOAT] = NULL;
		1978	table[MESA_FORMAT_XBGR32323232_UINT] = NULL;
		1979	table[MESA_FORMAT_XBGR32323232_SINT] = NULL;
		1980
		1981	initialized = GL_TRUE;
		1982	}
		1983
		1984	return table[format];
		1985	}
		1986
		1987
		1988
		1989	/**
		1990	* Return a function that can pack a GLfloat rgba[4] color.
		1991	*/
		1992	gl_pack_float_rgba_func
		1993	_mesa_get_pack_float_rgba_function(gl_format format)
		1994	{
		1995	static gl_pack_float_rgba_func table[MESA_FORMAT_COUNT];
		1996	static GLboolean initialized = GL_FALSE;
		1997
		1998	if (!initialized) {
		1999	memset(table, 0, sizeof(table));
		2000
		2001	table[MESA_FORMAT_NONE] = NULL;
		2002
		2003	table[MESA_FORMAT_RGBA8888] = pack_float_RGBA8888;
		2004	table[MESA_FORMAT_RGBA8888_REV] = pack_float_RGBA8888_REV;
		2005	table[MESA_FORMAT_ARGB8888] = pack_float_ARGB8888;
		2006	table[MESA_FORMAT_ARGB8888_REV] = pack_float_ARGB8888_REV;
		2007	table[MESA_FORMAT_RGBX8888] = pack_float_RGBA8888; /* reused */
		2008	table[MESA_FORMAT_RGBX8888_REV] = pack_float_RGBA8888_REV; /* reused */
		2009	table[MESA_FORMAT_XRGB8888] = pack_float_XRGB8888;
		2010	table[MESA_FORMAT_XRGB8888_REV] = pack_float_XRGB8888_REV;
		2011	table[MESA_FORMAT_RGB888] = pack_float_RGB888;
		2012	table[MESA_FORMAT_BGR888] = pack_float_BGR888;
		2013	table[MESA_FORMAT_RGB565] = pack_float_RGB565;
		2014	table[MESA_FORMAT_RGB565_REV] = pack_float_RGB565_REV;
		2015	table[MESA_FORMAT_ARGB4444] = pack_float_ARGB4444;
		2016	table[MESA_FORMAT_ARGB4444_REV] = pack_float_ARGB4444_REV;
		2017	table[MESA_FORMAT_RGBA5551] = pack_float_RGBA5551;
		2018	table[MESA_FORMAT_ARGB1555] = pack_float_ARGB1555;
		2019	table[MESA_FORMAT_ARGB1555_REV] = pack_float_ARGB1555_REV;
		2020
		2021	table[MESA_FORMAT_AL44] = pack_float_AL44;
		2022	table[MESA_FORMAT_AL88] = pack_float_AL88;
		2023	table[MESA_FORMAT_AL88_REV] = pack_float_AL88_REV;
		2024	table[MESA_FORMAT_AL1616] = pack_float_AL1616;
		2025	table[MESA_FORMAT_AL1616_REV] = pack_float_AL1616_REV;
		2026	table[MESA_FORMAT_RGB332] = pack_float_RGB332;
		2027	table[MESA_FORMAT_A8] = pack_float_A8;
		2028	table[MESA_FORMAT_A16] = pack_float_A16;
		2029	table[MESA_FORMAT_L8] = pack_float_L8;
		2030	table[MESA_FORMAT_L16] = pack_float_L16;
		2031	table[MESA_FORMAT_I8] = pack_float_L8; /* reuse pack_float_L8 */
		2032	table[MESA_FORMAT_I16] = pack_float_L16; /* reuse pack_float_L16 */
		2033	table[MESA_FORMAT_YCBCR] = pack_float_YCBCR;
		2034	table[MESA_FORMAT_YCBCR_REV] = pack_float_YCBCR_REV;
		2035	table[MESA_FORMAT_R8] = pack_float_R8;
		2036	table[MESA_FORMAT_GR88] = pack_float_GR88;
		2037	table[MESA_FORMAT_RG88] = pack_float_RG88;
		2038	table[MESA_FORMAT_R16] = pack_float_R16;
		2039	table[MESA_FORMAT_GR1616] = pack_float_GR1616;
		2040	table[MESA_FORMAT_RG1616] = pack_float_RG1616;
		2041	table[MESA_FORMAT_ARGB2101010] = pack_float_ARGB2101010;
		2042	table[MESA_FORMAT_ABGR2101010_UINT] = pack_float_ABGR2101010_UINT;
		2043
		2044	/* should never convert RGBA to these formats */
		2045	table[MESA_FORMAT_Z24_S8] = NULL;
		2046	table[MESA_FORMAT_S8_Z24] = NULL;
		2047	table[MESA_FORMAT_Z16] = NULL;
		2048	table[MESA_FORMAT_X8_Z24] = NULL;
		2049	table[MESA_FORMAT_Z24_X8] = NULL;
		2050	table[MESA_FORMAT_Z32] = NULL;
		2051	table[MESA_FORMAT_S8] = NULL;
		2052
		2053	table[MESA_FORMAT_SRGB8] = pack_float_SRGB8;
		2054	table[MESA_FORMAT_SRGBA8] = pack_float_SRGBA8;
		2055	table[MESA_FORMAT_SARGB8] = pack_float_SARGB8;
		2056	table[MESA_FORMAT_SL8] = pack_float_SL8;
		2057	table[MESA_FORMAT_SLA8] = pack_float_SLA8;
		2058
		2059	/* n/a */
		2060	table[MESA_FORMAT_SRGB_DXT1] = NULL;
		2061	table[MESA_FORMAT_SRGBA_DXT1] = NULL;
		2062	table[MESA_FORMAT_SRGBA_DXT3] = NULL;
		2063	table[MESA_FORMAT_SRGBA_DXT5] = NULL;
		2064
		2065	table[MESA_FORMAT_RGB_FXT1] = NULL;
		2066	table[MESA_FORMAT_RGBA_FXT1] = NULL;
		2067	table[MESA_FORMAT_RGB_DXT1] = NULL;
		2068	table[MESA_FORMAT_RGBA_DXT1] = NULL;
		2069	table[MESA_FORMAT_RGBA_DXT3] = NULL;
		2070	table[MESA_FORMAT_RGBA_DXT5] = NULL;
		2071
		2072	table[MESA_FORMAT_RGBA_FLOAT32] = pack_float_RGBA_FLOAT32;
		2073	table[MESA_FORMAT_RGBA_FLOAT16] = pack_float_RGBA_FLOAT16;
		2074	table[MESA_FORMAT_RGB_FLOAT32] = pack_float_RGB_FLOAT32;
		2075	table[MESA_FORMAT_RGB_FLOAT16] = pack_float_RGB_FLOAT16;
		2076	table[MESA_FORMAT_ALPHA_FLOAT32] = pack_float_ALPHA_FLOAT32;
		2077	table[MESA_FORMAT_ALPHA_FLOAT16] = pack_float_ALPHA_FLOAT16;
		2078	table[MESA_FORMAT_LUMINANCE_FLOAT32] = pack_float_LUMINANCE_FLOAT32;
		2079	table[MESA_FORMAT_LUMINANCE_FLOAT16] = pack_float_LUMINANCE_FLOAT16;
		2080	table[MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32] = pack_float_LUMINANCE_ALPHA_FLOAT32;
		2081	table[MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16] = pack_float_LUMINANCE_ALPHA_FLOAT16;
		2082
		2083	table[MESA_FORMAT_INTENSITY_FLOAT32] = pack_float_LUMINANCE_FLOAT32;
		2084	table[MESA_FORMAT_INTENSITY_FLOAT16] = pack_float_LUMINANCE_FLOAT16;
		2085	table[MESA_FORMAT_R_FLOAT32] = pack_float_LUMINANCE_FLOAT32;
		2086	table[MESA_FORMAT_R_FLOAT16] = pack_float_LUMINANCE_FLOAT16;
		2087	table[MESA_FORMAT_RG_FLOAT32] = pack_float_RG_FLOAT32;
		2088	table[MESA_FORMAT_RG_FLOAT16] = pack_float_RG_FLOAT16;
		2089
		2090	/* n/a */
		2091	table[MESA_FORMAT_RGBA_INT8] = NULL;
		2092	table[MESA_FORMAT_RGBA_INT16] = NULL;
		2093	table[MESA_FORMAT_RGBA_INT32] = NULL;
		2094	table[MESA_FORMAT_RGBA_UINT8] = NULL;
		2095	table[MESA_FORMAT_RGBA_UINT16] = NULL;
		2096	table[MESA_FORMAT_RGBA_UINT32] = NULL;
		2097
		2098	table[MESA_FORMAT_DUDV8] = pack_float_DUDV8;
		2099
		2100	table[MESA_FORMAT_RGBA_16] = pack_float_RGBA_16;
		2101
		2102	table[MESA_FORMAT_SIGNED_R8] = pack_float_SIGNED_R8;
		2103	table[MESA_FORMAT_SIGNED_RG88_REV] = pack_float_SIGNED_RG88_REV;
		2104	table[MESA_FORMAT_SIGNED_RGBX8888] = pack_float_SIGNED_RGBX8888;
		2105	table[MESA_FORMAT_SIGNED_RGBA8888] = pack_float_SIGNED_RGBA8888;
		2106	table[MESA_FORMAT_SIGNED_RGBA8888_REV] = pack_float_SIGNED_RGBA8888_REV;
		2107	table[MESA_FORMAT_SIGNED_R16] = pack_float_SIGNED_R16;
		2108	table[MESA_FORMAT_SIGNED_GR1616] = pack_float_SIGNED_GR1616;
		2109	table[MESA_FORMAT_SIGNED_RGB_16] = pack_float_SIGNED_RGB_16;
		2110	table[MESA_FORMAT_SIGNED_RGBA_16] = pack_float_SIGNED_RGBA_16;
		2111	table[MESA_FORMAT_SIGNED_A8] = pack_float_SIGNED_A8;
		2112	table[MESA_FORMAT_SIGNED_L8] = pack_float_SIGNED_L8;
		2113	table[MESA_FORMAT_SIGNED_AL88] = pack_float_SIGNED_AL88;
		2114	table[MESA_FORMAT_SIGNED_I8] = pack_float_SIGNED_L8; /* reused */
		2115	table[MESA_FORMAT_SIGNED_A16] = pack_float_SIGNED_A16;
		2116	table[MESA_FORMAT_SIGNED_L16] = pack_float_SIGNED_L16;
		2117	table[MESA_FORMAT_SIGNED_AL1616] = pack_float_SIGNED_AL1616;
		2118	table[MESA_FORMAT_SIGNED_I16] = pack_float_SIGNED_L16; /* reused */
		2119
		2120	table[MESA_FORMAT_RGB9_E5_FLOAT] = pack_float_RGB9_E5_FLOAT;
		2121	table[MESA_FORMAT_R11_G11_B10_FLOAT] = pack_float_R11_G11_B10_FLOAT;
		2122
		2123	table[MESA_FORMAT_XRGB4444_UNORM] = pack_float_XRGB4444_UNORM;
		2124	table[MESA_FORMAT_XRGB1555_UNORM] = pack_float_XRGB1555_UNORM;
		2125	table[MESA_FORMAT_XBGR8888_SNORM] = pack_float_XBGR8888_SNORM;
		2126	table[MESA_FORMAT_XBGR8888_SRGB] = pack_float_XBGR8888_SRGB;
		2127	table[MESA_FORMAT_XBGR8888_UINT] = NULL;
		2128	table[MESA_FORMAT_XBGR8888_SINT] = NULL;
		2129	table[MESA_FORMAT_XRGB2101010_UNORM] = pack_float_XRGB2101010_UNORM;
		2130	table[MESA_FORMAT_XBGR16161616_UNORM] = pack_float_XBGR16161616_UNORM;
		2131	table[MESA_FORMAT_XBGR16161616_SNORM] = pack_float_XBGR16161616_SNORM;
		2132	table[MESA_FORMAT_XBGR16161616_FLOAT] = pack_float_XBGR16161616_FLOAT;
		2133	table[MESA_FORMAT_XBGR16161616_UINT] = NULL;
		2134	table[MESA_FORMAT_XBGR16161616_SINT] = NULL;
		2135	table[MESA_FORMAT_XBGR32323232_FLOAT] = pack_float_XBGR32323232_FLOAT;
		2136	table[MESA_FORMAT_XBGR32323232_UINT] = NULL;
		2137	table[MESA_FORMAT_XBGR32323232_SINT] = NULL;
		2138
		2139	initialized = GL_TRUE;
		2140	}
		2141
		2142	return table[format];
		2143	}
		2144
		2145
		2146
		2147	static pack_float_rgba_row_func
		2148	get_pack_float_rgba_row_function(gl_format format)
		2149	{
		2150	static pack_float_rgba_row_func table[MESA_FORMAT_COUNT];
		2151	static GLboolean initialized = GL_FALSE;
		2152
		2153	if (!initialized) {
		2154	/* We don't need a special row packing function for each format.
		2155	* There's a generic fallback which uses a per-pixel packing function.
		2156	*/
		2157	memset(table, 0, sizeof(table));
		2158
		2159	table[MESA_FORMAT_RGBA8888] = pack_row_float_RGBA8888;
		2160	table[MESA_FORMAT_RGBA8888_REV] = pack_row_float_RGBA8888_REV;
		2161	table[MESA_FORMAT_ARGB8888] = pack_row_float_ARGB8888;
		2162	table[MESA_FORMAT_ARGB8888_REV] = pack_row_float_ARGB8888_REV;
		2163	table[MESA_FORMAT_RGBX8888] = pack_row_float_RGBA8888; /* reused */
		2164	table[MESA_FORMAT_RGBX8888_REV] = pack_row_float_RGBA8888_REV; /* reused */
		2165	table[MESA_FORMAT_XRGB8888] = pack_row_float_XRGB8888;
		2166	table[MESA_FORMAT_XRGB8888_REV] = pack_row_float_XRGB8888_REV;
		2167	table[MESA_FORMAT_RGB888] = pack_row_float_RGB888;
		2168	table[MESA_FORMAT_BGR888] = pack_row_float_BGR888;
		2169	table[MESA_FORMAT_RGB565] = pack_row_float_RGB565;
		2170	table[MESA_FORMAT_RGB565_REV] = pack_row_float_RGB565_REV;
		2171
		2172	initialized = GL_TRUE;
		2173	}
		2174
		2175	return table[format];
		2176	}
		2177
		2178
		2179
		2180	static pack_ubyte_rgba_row_func
		2181	get_pack_ubyte_rgba_row_function(gl_format format)
		2182	{
		2183	static pack_ubyte_rgba_row_func table[MESA_FORMAT_COUNT];
		2184	static GLboolean initialized = GL_FALSE;
		2185
		2186	if (!initialized) {
		2187	/* We don't need a special row packing function for each format.
		2188	* There's a generic fallback which uses a per-pixel packing function.
		2189	*/
		2190	memset(table, 0, sizeof(table));
		2191
		2192	table[MESA_FORMAT_RGBA8888] = pack_row_ubyte_RGBA8888;
		2193	table[MESA_FORMAT_RGBA8888_REV] = pack_row_ubyte_RGBA8888_REV;
		2194	table[MESA_FORMAT_ARGB8888] = pack_row_ubyte_ARGB8888;
		2195	table[MESA_FORMAT_ARGB8888_REV] = pack_row_ubyte_ARGB8888_REV;
		2196	table[MESA_FORMAT_RGBX8888] = pack_row_ubyte_RGBA8888; /* reused */
		2197	table[MESA_FORMAT_RGBX8888_REV] = pack_row_ubyte_RGBA8888_REV; /* reused */
		2198	table[MESA_FORMAT_XRGB8888] = pack_row_ubyte_XRGB8888;
		2199	table[MESA_FORMAT_XRGB8888_REV] = pack_row_ubyte_XRGB8888_REV;
		2200	table[MESA_FORMAT_RGB888] = pack_row_ubyte_RGB888;
		2201	table[MESA_FORMAT_BGR888] = pack_row_ubyte_BGR888;
		2202	table[MESA_FORMAT_RGB565] = pack_row_ubyte_RGB565;
		2203	table[MESA_FORMAT_RGB565_REV] = pack_row_ubyte_RGB565_REV;
		2204
		2205	initialized = GL_TRUE;
		2206	}
		2207
		2208	return table[format];
		2209	}
		2210
		2211
		2212
		2213	/**
		2214	* Pack a row of GLfloat rgba[4] values to the destination.
		2215	*/
		2216	void
		2217	_mesa_pack_float_rgba_row(gl_format format, GLuint n,
		2218	const GLfloat src[][4], void *dst)
		2219	{
		2220	pack_float_rgba_row_func packrow = get_pack_float_rgba_row_function(format);
		2221	if (packrow) {
		2222	/* use "fast" function */
		2223	packrow(n, src, dst);
		2224	}
		2225	else {
		2226	/* slower fallback */
		2227	gl_pack_float_rgba_func pack = _mesa_get_pack_float_rgba_function(format);
		2228	GLuint dstStride = _mesa_get_format_bytes(format);
		2229	GLubyte dstPtr = (GLubyte ) dst;
		2230	GLuint i;
		2231
		2232	assert(pack);
		2233	if (!pack)
		2234	return;
		2235
		2236	for (i = 0; i < n; i++) {
		2237	pack(src[i], dstPtr);
		2238	dstPtr += dstStride;
		2239	}
		2240	}
		2241	}
		2242
		2243
		2244	/**
		2245	* Pack a row of GLubyte rgba[4] values to the destination.
		2246	*/
		2247	void
		2248	_mesa_pack_ubyte_rgba_row(gl_format format, GLuint n,
		2249	const GLubyte src[][4], void *dst)
		2250	{
		2251	pack_ubyte_rgba_row_func packrow = get_pack_ubyte_rgba_row_function(format);
		2252	if (packrow) {
		2253	/* use "fast" function */
		2254	packrow(n, src, dst);
		2255	}
		2256	else {
		2257	/* slower fallback */
		2258	gl_pack_ubyte_rgba_func pack = _mesa_get_pack_ubyte_rgba_function(format);
		2259	const GLuint stride = _mesa_get_format_bytes(format);
		2260	GLubyte d = ((GLubyte ) dst);
		2261	GLuint i;
		2262
		2263	assert(pack);
		2264	if (!pack)
		2265	return;
		2266
		2267	for (i = 0; i < n; i++) {
		2268	pack(src[i], d);
		2269	d += stride;
		2270	}
		2271	}
		2272	}
		2273
		2274
		2275	/**
		2276	* Pack a 2D image of ubyte RGBA pixels in the given format.
		2277	* \param srcRowStride source image row stride in bytes
		2278	* \param dstRowStride destination image row stride in bytes
		2279	*/
		2280	void
		2281	_mesa_pack_ubyte_rgba_rect(gl_format format, GLuint width, GLuint height,
		2282	const GLubyte *src, GLint srcRowStride,
		2283	void *dst, GLint dstRowStride)
		2284	{
		2285	pack_ubyte_rgba_row_func packrow = get_pack_ubyte_rgba_row_function(format);
		2286	GLubyte dstUB = (GLubyte ) dst;
		2287	GLuint i;
		2288
		2289	if (packrow) {
		2290	if (srcRowStride == width * 4 * sizeof(GLubyte) &&
		2291	dstRowStride == _mesa_format_row_stride(format, width)) {
		2292	/* do whole image at once */
		2293	packrow(width * height, (const GLubyte (*)[4]) src, dst);
		2294	}
		2295	else {
		2296	/* row by row */
		2297	for (i = 0; i < height; i++) {
		2298	packrow(width, (const GLubyte (*)[4]) src, dstUB);
		2299	src += srcRowStride;
		2300	dstUB += dstRowStride;
		2301	}
		2302	}
		2303	}
		2304	else {
		2305	/* slower fallback */
		2306	for (i = 0; i < height; i++) {
		2307	_mesa_pack_ubyte_rgba_row(format, width,
		2308	(const GLubyte (*)[4]) src, dstUB);
		2309	src += srcRowStride;
		2310	dstUB += dstRowStride;
		2311	}
		2312	}
		2313	}
		2314
		2315
		2316
		2317	/**
		2318	** Pack float Z pixels
		2319	**/
		2320
		2321	static void
		2322	pack_float_z_Z24_S8(const GLfloat src, void dst)
		2323	{
		2324	/* don't disturb the stencil values */
		2325	GLuint d = ((GLuint ) dst);
		2326	const GLdouble scale = (GLdouble) 0xffffff;
		2327	GLuint s = *d & 0xff;
		2328	GLuint z = (GLuint) (src scale);
		2329	assert(z <= 0xffffff);
		2330	*d = (z << 8) \| s;
		2331	}
		2332
		2333	static void
		2334	pack_float_z_S8_Z24(const GLfloat src, void dst)
		2335	{
		2336	/* don't disturb the stencil values */
		2337	GLuint d = ((GLuint ) dst);
		2338	const GLdouble scale = (GLdouble) 0xffffff;
		2339	GLuint s = *d & 0xff000000;
		2340	GLuint z = (GLuint) (src scale);
		2341	assert(z <= 0xffffff);
		2342	*d = s \| z;
		2343	}
		2344
		2345	static void
		2346	pack_float_z_Z16(const GLfloat src, void dst)
		2347	{
		2348	GLushort d = ((GLushort ) dst);
		2349	const GLfloat scale = (GLfloat) 0xffff;
		2350	d = (GLushort) (src * scale);
		2351	}
		2352
		2353	static void
		2354	pack_float_z_Z32(const GLfloat src, void dst)
		2355	{
		2356	GLuint d = ((GLuint ) dst);
		2357	const GLdouble scale = (GLdouble) 0xffffffff;
		2358	d = (GLuint) (src * scale);
		2359	}
		2360
		2361	static void
		2362	pack_float_z_Z32_FLOAT(const GLfloat src, void dst)
		2363	{
		2364	GLfloat d = (GLfloat ) dst;
		2365	d = src;
		2366	}
		2367
		2368	gl_pack_float_z_func
		2369	_mesa_get_pack_float_z_func(gl_format format)
		2370	{
		2371	switch (format) {
		2372	case MESA_FORMAT_Z24_S8:
		2373	case MESA_FORMAT_Z24_X8:
		2374	return pack_float_z_Z24_S8;
		2375	case MESA_FORMAT_S8_Z24:
		2376	case MESA_FORMAT_X8_Z24:
		2377	return pack_float_z_S8_Z24;
		2378	case MESA_FORMAT_Z16:
		2379	return pack_float_z_Z16;
		2380	case MESA_FORMAT_Z32:
		2381	return pack_float_z_Z32;
		2382	case MESA_FORMAT_Z32_FLOAT:
		2383	case MESA_FORMAT_Z32_FLOAT_X24S8:
		2384	return pack_float_z_Z32_FLOAT;
		2385	default:
		2386	_mesa_problem(NULL,
		2387	"unexpected format in _mesa_get_pack_float_z_func()");
		2388	return NULL;
		2389	}
		2390	}
		2391
		2392
		2393
		2394	/**
		2395	** Pack uint Z pixels. The incoming src value is always in
		2396	** the range [0, 2^32-1].
		2397	**/
		2398
		2399	static void
		2400	pack_uint_z_Z24_S8(const GLuint src, void dst)
		2401	{
		2402	/* don't disturb the stencil values */
		2403	GLuint d = ((GLuint ) dst);
		2404	GLuint s = *d & 0xff;
		2405	GLuint z = *src & 0xffffff00;
		2406	*d = z \| s;
		2407	}
		2408
		2409	static void
		2410	pack_uint_z_S8_Z24(const GLuint src, void dst)
		2411	{
		2412	/* don't disturb the stencil values */
		2413	GLuint d = ((GLuint ) dst);
		2414	GLuint s = *d & 0xff000000;
		2415	GLuint z = *src >> 8;
		2416	*d = s \| z;
		2417	}
		2418
		2419	static void
		2420	pack_uint_z_Z16(const GLuint src, void dst)
		2421	{
		2422	GLushort d = ((GLushort ) dst);
		2423	d = src >> 16;
		2424	}
		2425
		2426	static void
		2427	pack_uint_z_Z32(const GLuint src, void dst)
		2428	{
		2429	GLuint d = ((GLuint ) dst);
		2430	d = src;
		2431	}
		2432
		2433	static void
		2434	pack_uint_z_Z32_FLOAT(const GLuint src, void dst)
		2435	{
		2436	GLuint d = ((GLuint ) dst);
		2437	const GLdouble scale = 1.0 / (GLdouble) 0xffffffff;
		2438	d = (GLuint) (src * scale);
		2439	assert(*d >= 0.0f);
		2440	assert(*d <= 1.0f);
		2441	}
		2442
		2443	static void
		2444	pack_uint_z_Z32_FLOAT_X24S8(const GLuint src, void dst)
		2445	{
		2446	GLfloat d = ((GLfloat ) dst);
		2447	const GLdouble scale = 1.0 / (GLdouble) 0xffffffff;
		2448	d = (GLfloat) (src * scale);
		2449	assert(*d >= 0.0f);
		2450	assert(*d <= 1.0f);
		2451	}
		2452
		2453	gl_pack_uint_z_func
		2454	_mesa_get_pack_uint_z_func(gl_format format)
		2455	{
		2456	switch (format) {
		2457	case MESA_FORMAT_Z24_S8:
		2458	case MESA_FORMAT_Z24_X8:
		2459	return pack_uint_z_Z24_S8;
		2460	case MESA_FORMAT_S8_Z24:
		2461	case MESA_FORMAT_X8_Z24:
		2462	return pack_uint_z_S8_Z24;
		2463	case MESA_FORMAT_Z16:
		2464	return pack_uint_z_Z16;
		2465	case MESA_FORMAT_Z32:
		2466	return pack_uint_z_Z32;
		2467	case MESA_FORMAT_Z32_FLOAT:
		2468	return pack_uint_z_Z32_FLOAT;
		2469	case MESA_FORMAT_Z32_FLOAT_X24S8:
		2470	return pack_uint_z_Z32_FLOAT_X24S8;
		2471	default:
		2472	_mesa_problem(NULL, "unexpected format in _mesa_get_pack_uint_z_func()");
		2473	return NULL;
		2474	}
		2475	}
		2476
		2477
		2478	/**
		2479	** Pack ubyte stencil pixels
		2480	**/
		2481
		2482	static void
		2483	pack_ubyte_stencil_Z24_S8(const GLubyte src, void dst)
		2484	{
		2485	/* don't disturb the Z values */
		2486	GLuint d = ((GLuint ) dst);
		2487	GLuint s = *src;
		2488	GLuint z = *d & 0xffffff00;
		2489	*d = z \| s;
		2490	}
		2491
		2492	static void
		2493	pack_ubyte_stencil_S8_Z24(const GLubyte src, void dst)
		2494	{
		2495	/* don't disturb the Z values */
		2496	GLuint d = ((GLuint ) dst);
		2497	GLuint s = *src << 24;
		2498	GLuint z = *d & 0xffffff;
		2499	*d = s \| z;
		2500	}
		2501
		2502	static void
		2503	pack_ubyte_stencil_S8(const GLubyte src, void dst)
		2504	{
		2505	GLubyte d = (GLubyte ) dst;
		2506	d = src;
		2507	}
		2508
		2509	static void
		2510	pack_ubyte_stencil_Z32_FLOAT_X24S8(const GLubyte src, void dst)
		2511	{
		2512	GLfloat d = ((GLfloat ) dst);
		2513	d[1] = *src;
		2514	}
		2515
		2516
		2517	gl_pack_ubyte_stencil_func
		2518	_mesa_get_pack_ubyte_stencil_func(gl_format format)
		2519	{
		2520	switch (format) {
		2521	case MESA_FORMAT_Z24_S8:
		2522	return pack_ubyte_stencil_Z24_S8;
		2523	case MESA_FORMAT_S8_Z24:
		2524	return pack_ubyte_stencil_S8_Z24;
		2525	case MESA_FORMAT_S8:
		2526	return pack_ubyte_stencil_S8;
		2527	case MESA_FORMAT_Z32_FLOAT_X24S8:
		2528	return pack_ubyte_stencil_Z32_FLOAT_X24S8;
		2529	default:
		2530	_mesa_problem(NULL,
		2531	"unexpected format in _mesa_pack_ubyte_stencil_func()");
		2532	return NULL;
		2533	}
		2534	}
		2535
		2536
		2537
		2538	void
		2539	_mesa_pack_float_z_row(gl_format format, GLuint n,
		2540	const GLfloat src, void dst)
		2541	{
		2542	switch (format) {
		2543	case MESA_FORMAT_Z24_S8:
		2544	case MESA_FORMAT_Z24_X8:
		2545	{
		2546	/* don't disturb the stencil values */
		2547	GLuint d = ((GLuint ) dst);
		2548	const GLdouble scale = (GLdouble) 0xffffff;
		2549	GLuint i;
		2550	for (i = 0; i < n; i++) {
		2551	GLuint s = d[i] & 0xff;
		2552	GLuint z = (GLuint) (src[i] * scale);
		2553	assert(z <= 0xffffff);
		2554	d[i] = (z << 8) \| s;
		2555	}
		2556	}
		2557	break;
		2558	case MESA_FORMAT_S8_Z24:
		2559	case MESA_FORMAT_X8_Z24:
		2560	{
		2561	/* don't disturb the stencil values */
		2562	GLuint d = ((GLuint ) dst);
		2563	const GLdouble scale = (GLdouble) 0xffffff;
		2564	GLuint i;
		2565	for (i = 0; i < n; i++) {
		2566	GLuint s = d[i] & 0xff000000;
		2567	GLuint z = (GLuint) (src[i] * scale);
		2568	assert(z <= 0xffffff);
		2569	d[i] = s \| z;
		2570	}
		2571	}
		2572	break;
		2573	case MESA_FORMAT_Z16:
		2574	{
		2575	GLushort d = ((GLushort ) dst);
		2576	const GLfloat scale = (GLfloat) 0xffff;
		2577	GLuint i;
		2578	for (i = 0; i < n; i++) {
		2579	d[i] = (GLushort) (src[i] * scale);
		2580	}
		2581	}
		2582	break;
		2583	case MESA_FORMAT_Z32:
		2584	{
		2585	GLuint d = ((GLuint ) dst);
		2586	const GLdouble scale = (GLdouble) 0xffffffff;
		2587	GLuint i;
		2588	for (i = 0; i < n; i++) {
		2589	d[i] = (GLuint) (src[i] * scale);
		2590	}
		2591	}
		2592	break;
		2593	case MESA_FORMAT_Z32_FLOAT:
		2594	memcpy(dst, src, n * sizeof(GLfloat));
		2595	break;
		2596	case MESA_FORMAT_Z32_FLOAT_X24S8:
		2597	{
		2598	struct z32f_x24s8 d = (struct z32f_x24s8 ) dst;
		2599	GLuint i;
		2600	for (i = 0; i < n; i++) {
		2601	d[i].z = src[i];
		2602	}
		2603	}
		2604	break;
		2605	default:
		2606	_mesa_problem(NULL, "unexpected format in _mesa_pack_float_z_row()");
		2607	}
		2608	}
		2609
		2610
		2611	/**
		2612	* The incoming Z values are always in the range [0, 0xffffffff].
		2613	*/
		2614	void
		2615	_mesa_pack_uint_z_row(gl_format format, GLuint n,
		2616	const GLuint src, void dst)
		2617	{
		2618	switch (format) {
		2619	case MESA_FORMAT_Z24_S8:
		2620	case MESA_FORMAT_Z24_X8:
		2621	{
		2622	/* don't disturb the stencil values */
		2623	GLuint d = ((GLuint ) dst);
		2624	GLuint i;
		2625	for (i = 0; i < n; i++) {
		2626	GLuint s = d[i] & 0xff;
		2627	GLuint z = src[i] & 0xffffff00;
		2628	d[i] = z \| s;
		2629	}
		2630	}
		2631	break;
		2632	case MESA_FORMAT_S8_Z24:
		2633	case MESA_FORMAT_X8_Z24:
		2634	{
		2635	/* don't disturb the stencil values */
		2636	GLuint d = ((GLuint ) dst);
		2637	GLuint i;
		2638	for (i = 0; i < n; i++) {
		2639	GLuint s = d[i] & 0xff000000;
		2640	GLuint z = src[i] >> 8;
		2641	d[i] = s \| z;
		2642	}
		2643	}
		2644	break;
		2645	case MESA_FORMAT_Z16:
		2646	{
		2647	GLushort d = ((GLushort ) dst);
		2648	GLuint i;
		2649	for (i = 0; i < n; i++) {
		2650	d[i] = src[i] >> 16;
		2651	}
		2652	}
		2653	break;
		2654	case MESA_FORMAT_Z32:
		2655	memcpy(dst, src, n * sizeof(GLfloat));
		2656	break;
		2657	case MESA_FORMAT_Z32_FLOAT:
		2658	{
		2659	GLuint d = ((GLuint ) dst);
		2660	const GLdouble scale = 1.0 / (GLdouble) 0xffffffff;
		2661	GLuint i;
		2662	for (i = 0; i < n; i++) {
		2663	d[i] = (GLuint) (src[i] * scale);
		2664	assert(d[i] >= 0.0f);
		2665	assert(d[i] <= 1.0f);
		2666	}
		2667	}
		2668	break;
		2669	case MESA_FORMAT_Z32_FLOAT_X24S8:
		2670	{
		2671	struct z32f_x24s8 d = (struct z32f_x24s8 ) dst;
		2672	const GLdouble scale = 1.0 / (GLdouble) 0xffffffff;
		2673	GLuint i;
		2674	for (i = 0; i < n; i++) {
		2675	d[i].z = (GLfloat) (src[i] * scale);
		2676	assert(d[i].z >= 0.0f);
		2677	assert(d[i].z <= 1.0f);
		2678	}
		2679	}
		2680	break;
		2681	default:
		2682	_mesa_problem(NULL, "unexpected format in _mesa_pack_uint_z_row()");
		2683	}
		2684	}
		2685
		2686
		2687	void
		2688	_mesa_pack_ubyte_stencil_row(gl_format format, GLuint n,
		2689	const GLubyte src, void dst)
		2690	{
		2691	switch (format) {
		2692	case MESA_FORMAT_Z24_S8:
		2693	{
		2694	/* don't disturb the Z values */
		2695	GLuint d = ((GLuint ) dst);
		2696	GLuint i;
		2697	for (i = 0; i < n; i++) {
		2698	GLuint s = src[i];
		2699	GLuint z = d[i] & 0xffffff00;
		2700	d[i] = z \| s;
		2701	}
		2702	}
		2703	break;
		2704	case MESA_FORMAT_S8_Z24:
		2705	{
		2706	/* don't disturb the Z values */
		2707	GLuint d = ((GLuint ) dst);
		2708	GLuint i;
		2709	for (i = 0; i < n; i++) {
		2710	GLuint s = src[i] << 24;
		2711	GLuint z = d[i] & 0xffffff;
		2712	d[i] = s \| z;
		2713	}
		2714	}
		2715	break;
		2716	case MESA_FORMAT_S8:
		2717	memcpy(dst, src, n * sizeof(GLubyte));
		2718	break;
		2719	case MESA_FORMAT_Z32_FLOAT_X24S8:
		2720	{
		2721	struct z32f_x24s8 d = (struct z32f_x24s8 ) dst;
		2722	GLuint i;
		2723	for (i = 0; i < n; i++) {
		2724	d[i].x24s8 = src[i];
		2725	}
		2726	}
		2727	break;
		2728	default:
		2729	_mesa_problem(NULL, "unexpected format in _mesa_pack_ubyte_stencil_row()");
		2730	}
		2731	}
		2732
		2733
		2734	/**
		2735	* Incoming Z/stencil values are always in uint_24_8 format.
		2736	*/
		2737	void
		2738	_mesa_pack_uint_24_8_depth_stencil_row(gl_format format, GLuint n,
		2739	const GLuint src, void dst)
		2740	{
		2741	switch (format) {
		2742	case MESA_FORMAT_Z24_S8:
		2743	memcpy(dst, src, n * sizeof(GLuint));
		2744	break;
		2745	case MESA_FORMAT_S8_Z24:
		2746	{
		2747	GLuint d = ((GLuint ) dst);
		2748	GLuint i;
		2749	for (i = 0; i < n; i++) {
		2750	GLuint s = src[i] << 24;
		2751	GLuint z = src[i] >> 8;
		2752	d[i] = s \| z;
		2753	}
		2754	}
		2755	break;
		2756	case MESA_FORMAT_Z32_FLOAT_X24S8:
		2757	{
		2758	const GLdouble scale = 1.0 / (GLdouble) 0xffffff;
		2759	struct z32f_x24s8 d = (struct z32f_x24s8 ) dst;
		2760	GLuint i;
		2761	for (i = 0; i < n; i++) {
		2762	GLfloat z = (GLfloat) ((src[i] >> 8) * scale);
		2763	d[i].z = z;
		2764	d[i].x24s8 = src[i];
		2765	}
		2766	}
		2767	break;
		2768	default:
		2769	_mesa_problem(NULL, "bad format %s in _mesa_pack_ubyte_s_row",
		2770	_mesa_get_format_name(format));
		2771	return;
		2772	}
		2773	}
		2774
		2775
		2776
		2777	/**
		2778	* Convert a boolean color mask to a packed color where each channel of
		2779	* the packed value at dst will be 0 or ~0 depending on the colorMask.
		2780	*/
		2781	void
		2782	_mesa_pack_colormask(gl_format format, const GLubyte colorMask[4], void *dst)
		2783	{
		2784	GLfloat maskColor[4];
		2785
		2786	switch (_mesa_get_format_datatype(format)) {
		2787	case GL_UNSIGNED_NORMALIZED:
		2788	/* simple: 1.0 will convert to ~0 in the right bit positions */
		2789	maskColor[0] = colorMask[0] ? 1.0f : 0.0f;
		2790	maskColor[1] = colorMask[1] ? 1.0f : 0.0f;
		2791	maskColor[2] = colorMask[2] ? 1.0f : 0.0f;
		2792	maskColor[3] = colorMask[3] ? 1.0f : 0.0f;
		2793	_mesa_pack_float_rgba_row(format, 1,
		2794	(const GLfloat (*)[4]) maskColor, dst);
		2795	break;
		2796	case GL_SIGNED_NORMALIZED:
		2797	case GL_FLOAT:
		2798	/* These formats are harder because it's hard to know the floating
		2799	* point values that will convert to ~0 for each color channel's bits.
		2800	* This solution just generates a non-zero value for each color channel
		2801	* then fixes up the non-zero values to be ~0.
		2802	* Note: we'll need to add special case code if we ever have to deal
		2803	* with formats with unequal color channel sizes, like R11_G11_B10.
		2804	* We issue a warning below for channel sizes other than 8,16,32.
		2805	*/
		2806	{
		2807	GLuint bits = _mesa_get_format_max_bits(format); /* bits per chan */
		2808	GLuint bytes = _mesa_get_format_bytes(format);
		2809	GLuint i;
		2810
		2811	/* this should put non-zero values into the channels of dst */
		2812	maskColor[0] = colorMask[0] ? -1.0f : 0.0f;
		2813	maskColor[1] = colorMask[1] ? -1.0f : 0.0f;
		2814	maskColor[2] = colorMask[2] ? -1.0f : 0.0f;
		2815	maskColor[3] = colorMask[3] ? -1.0f : 0.0f;
		2816	_mesa_pack_float_rgba_row(format, 1,
		2817	(const GLfloat (*)[4]) maskColor, dst);
		2818
		2819	/* fix-up the dst channels by converting non-zero values to ~0 */
		2820	if (bits == 8) {
		2821	GLubyte d = (GLubyte ) dst;
		2822	for (i = 0; i < bytes; i++) {
		2823	d[i] = d[i] ? 0xff : 0x0;
		2824	}
		2825	}
		2826	else if (bits == 16) {
		2827	GLushort d = (GLushort ) dst;
		2828	for (i = 0; i < bytes / 2; i++) {
		2829	d[i] = d[i] ? 0xffff : 0x0;
		2830	}
		2831	}
		2832	else if (bits == 32) {
		2833	GLuint d = (GLuint ) dst;
		2834	for (i = 0; i < bytes / 4; i++) {
		2835	d[i] = d[i] ? 0xffffffffU : 0x0;
		2836	}
		2837	}
		2838	else {
		2839	_mesa_problem(NULL, "unexpected size in _mesa_pack_colormask()");
		2840	return;
		2841	}
		2842	}
		2843	break;
		2844	default:
		2845	_mesa_problem(NULL, "unexpected format data type in gen_color_mask()");
		2846	return;
		2847	}
		2848	}

Subversion Repositories Kolibri OS

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