WebSVN – Kolibri OS – Blame – /contrib/sdk/sources/Mesa/mesa-10.6.0/src/mesa/state_tracker/st_format.c

Rev	Author	Line No.	Line
5564	serge	1	/**************************************************************************
		2	*
		3	* Copyright 2007 VMware, Inc.
		4	* Copyright (c) 2008-2010 VMware, Inc.
		5	* All Rights Reserved.
		6	*
		7	* Permission is hereby granted, free of charge, to any person obtaining a
		8	* copy of this software and associated documentation files (the
		9	* "Software"), to deal in the Software without restriction, including
		10	* without limitation the rights to use, copy, modify, merge, publish,
		11	* distribute, sub license, and/or sell copies of the Software, and to
		12	* permit persons to whom the Software is furnished to do so, subject to
		13	* the following conditions:
		14	*
		15	* The above copyright notice and this permission notice (including the
		16	* next paragraph) shall be included in all copies or substantial portions
		17	* 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
		21	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
		22	* IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
		23	* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
		24	* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
		25	* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
		26	*
		27	**************************************************************************/
		28
		29
		30	/**
		31	* Mesa / Gallium format conversion and format selection code.
		32	* \author Brian Paul
		33	*/
		34
		35	#include "main/imports.h"
		36	#include "main/context.h"
		37	#include "main/glformats.h"
		38	#include "main/texgetimage.h"
		39	#include "main/teximage.h"
		40	#include "main/texstore.h"
		41	#include "main/image.h"
		42	#include "main/macros.h"
		43
		44	#include "pipe/p_context.h"
		45	#include "pipe/p_defines.h"
		46	#include "pipe/p_screen.h"
		47	#include "util/u_format.h"
		48	#include "st_cb_texture.h"
		49	#include "st_context.h"
		50	#include "st_format.h"
		51
		52
		53	/**
		54	* Translate Mesa format to Gallium format.
		55	*/
		56	enum pipe_format
		57	st_mesa_format_to_pipe_format(struct st_context *st, mesa_format mesaFormat)
		58	{
		59	switch (mesaFormat) {
		60	case MESA_FORMAT_A8B8G8R8_UNORM:
		61	return PIPE_FORMAT_ABGR8888_UNORM;
		62	case MESA_FORMAT_R8G8B8A8_UNORM:
		63	return PIPE_FORMAT_RGBA8888_UNORM;
		64	case MESA_FORMAT_B8G8R8A8_UNORM:
		65	return PIPE_FORMAT_BGRA8888_UNORM;
		66	case MESA_FORMAT_A8R8G8B8_UNORM:
		67	return PIPE_FORMAT_ARGB8888_UNORM;
		68	case MESA_FORMAT_X8B8G8R8_UNORM:
		69	return PIPE_FORMAT_XBGR8888_UNORM;
		70	case MESA_FORMAT_R8G8B8X8_UNORM:
		71	return PIPE_FORMAT_RGBX8888_UNORM;
		72	case MESA_FORMAT_B8G8R8X8_UNORM:
		73	return PIPE_FORMAT_BGRX8888_UNORM;
		74	case MESA_FORMAT_X8R8G8B8_UNORM:
		75	return PIPE_FORMAT_XRGB8888_UNORM;
		76	case MESA_FORMAT_B5G5R5A1_UNORM:
		77	return PIPE_FORMAT_B5G5R5A1_UNORM;
		78	case MESA_FORMAT_B4G4R4A4_UNORM:
		79	return PIPE_FORMAT_B4G4R4A4_UNORM;
		80	case MESA_FORMAT_B5G6R5_UNORM:
		81	return PIPE_FORMAT_B5G6R5_UNORM;
		82	case MESA_FORMAT_B2G3R3_UNORM:
		83	return PIPE_FORMAT_B2G3R3_UNORM;
		84	case MESA_FORMAT_B10G10R10A2_UNORM:
		85	return PIPE_FORMAT_B10G10R10A2_UNORM;
		86	case MESA_FORMAT_R10G10B10A2_UNORM:
		87	return PIPE_FORMAT_R10G10B10A2_UNORM;
		88	case MESA_FORMAT_L4A4_UNORM:
		89	return PIPE_FORMAT_L4A4_UNORM;
		90	case MESA_FORMAT_L8A8_UNORM:
		91	return PIPE_FORMAT_LA88_UNORM;
		92	case MESA_FORMAT_A8L8_UNORM:
		93	return PIPE_FORMAT_AL88_UNORM;
		94	case MESA_FORMAT_L16A16_UNORM:
		95	return PIPE_FORMAT_LA1616_UNORM;
		96	case MESA_FORMAT_A16L16_UNORM:
		97	return PIPE_FORMAT_AL1616_UNORM;
		98	case MESA_FORMAT_A_UNORM8:
		99	return PIPE_FORMAT_A8_UNORM;
		100	case MESA_FORMAT_A_UNORM16:
		101	return PIPE_FORMAT_A16_UNORM;
		102	case MESA_FORMAT_L_UNORM8:
		103	return PIPE_FORMAT_L8_UNORM;
		104	case MESA_FORMAT_L_UNORM16:
		105	return PIPE_FORMAT_L16_UNORM;
		106	case MESA_FORMAT_I_UNORM8:
		107	return PIPE_FORMAT_I8_UNORM;
		108	case MESA_FORMAT_I_UNORM16:
		109	return PIPE_FORMAT_I16_UNORM;
		110	case MESA_FORMAT_Z_UNORM16:
		111	return PIPE_FORMAT_Z16_UNORM;
		112	case MESA_FORMAT_Z_UNORM32:
		113	return PIPE_FORMAT_Z32_UNORM;
		114	case MESA_FORMAT_S8_UINT_Z24_UNORM:
		115	return PIPE_FORMAT_S8_UINT_Z24_UNORM;
		116	case MESA_FORMAT_Z24_UNORM_S8_UINT:
		117	return PIPE_FORMAT_Z24_UNORM_S8_UINT;
		118	case MESA_FORMAT_X8_UINT_Z24_UNORM:
		119	return PIPE_FORMAT_X8Z24_UNORM;
		120	case MESA_FORMAT_Z24_UNORM_X8_UINT:
		121	return PIPE_FORMAT_Z24X8_UNORM;
		122	case MESA_FORMAT_S_UINT8:
		123	return PIPE_FORMAT_S8_UINT;
		124	case MESA_FORMAT_Z_FLOAT32:
		125	return PIPE_FORMAT_Z32_FLOAT;
		126	case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
		127	return PIPE_FORMAT_Z32_FLOAT_S8X24_UINT;
		128	case MESA_FORMAT_YCBCR:
		129	return PIPE_FORMAT_UYVY;
		130	case MESA_FORMAT_YCBCR_REV:
		131	return PIPE_FORMAT_YUYV;
		132	case MESA_FORMAT_RGB_DXT1:
		133	return PIPE_FORMAT_DXT1_RGB;
		134	case MESA_FORMAT_RGBA_DXT1:
		135	return PIPE_FORMAT_DXT1_RGBA;
		136	case MESA_FORMAT_RGBA_DXT3:
		137	return PIPE_FORMAT_DXT3_RGBA;
		138	case MESA_FORMAT_RGBA_DXT5:
		139	return PIPE_FORMAT_DXT5_RGBA;
		140	case MESA_FORMAT_SRGB_DXT1:
		141	return PIPE_FORMAT_DXT1_SRGB;
		142	case MESA_FORMAT_SRGBA_DXT1:
		143	return PIPE_FORMAT_DXT1_SRGBA;
		144	case MESA_FORMAT_SRGBA_DXT3:
		145	return PIPE_FORMAT_DXT3_SRGBA;
		146	case MESA_FORMAT_SRGBA_DXT5:
		147	return PIPE_FORMAT_DXT5_SRGBA;
		148	case MESA_FORMAT_L8A8_SRGB:
		149	return PIPE_FORMAT_LA88_SRGB;
		150	case MESA_FORMAT_A8L8_SRGB:
		151	return PIPE_FORMAT_AL88_SRGB;
		152	case MESA_FORMAT_L_SRGB8:
		153	return PIPE_FORMAT_L8_SRGB;
		154	case MESA_FORMAT_BGR_SRGB8:
		155	return PIPE_FORMAT_R8G8B8_SRGB;
		156	case MESA_FORMAT_A8B8G8R8_SRGB:
		157	return PIPE_FORMAT_ABGR8888_SRGB;
		158	case MESA_FORMAT_R8G8B8A8_SRGB:
		159	return PIPE_FORMAT_RGBA8888_SRGB;
		160	case MESA_FORMAT_B8G8R8A8_SRGB:
		161	return PIPE_FORMAT_BGRA8888_SRGB;
		162	case MESA_FORMAT_A8R8G8B8_SRGB:
		163	return PIPE_FORMAT_ARGB8888_SRGB;
		164	case MESA_FORMAT_RGBA_FLOAT32:
		165	return PIPE_FORMAT_R32G32B32A32_FLOAT;
		166	case MESA_FORMAT_RGBA_FLOAT16:
		167	return PIPE_FORMAT_R16G16B16A16_FLOAT;
		168	case MESA_FORMAT_RGB_FLOAT32:
		169	return PIPE_FORMAT_R32G32B32_FLOAT;
		170	case MESA_FORMAT_RGB_FLOAT16:
		171	return PIPE_FORMAT_R16G16B16_FLOAT;
		172	case MESA_FORMAT_LA_FLOAT32:
		173	return PIPE_FORMAT_L32A32_FLOAT;
		174	case MESA_FORMAT_LA_FLOAT16:
		175	return PIPE_FORMAT_L16A16_FLOAT;
		176	case MESA_FORMAT_L_FLOAT32:
		177	return PIPE_FORMAT_L32_FLOAT;
		178	case MESA_FORMAT_L_FLOAT16:
		179	return PIPE_FORMAT_L16_FLOAT;
		180	case MESA_FORMAT_A_FLOAT32:
		181	return PIPE_FORMAT_A32_FLOAT;
		182	case MESA_FORMAT_A_FLOAT16:
		183	return PIPE_FORMAT_A16_FLOAT;
		184	case MESA_FORMAT_I_FLOAT32:
		185	return PIPE_FORMAT_I32_FLOAT;
		186	case MESA_FORMAT_I_FLOAT16:
		187	return PIPE_FORMAT_I16_FLOAT;
		188	case MESA_FORMAT_R_FLOAT32:
		189	return PIPE_FORMAT_R32_FLOAT;
		190	case MESA_FORMAT_R_FLOAT16:
		191	return PIPE_FORMAT_R16_FLOAT;
		192	case MESA_FORMAT_RG_FLOAT32:
		193	return PIPE_FORMAT_R32G32_FLOAT;
		194	case MESA_FORMAT_RG_FLOAT16:
		195	return PIPE_FORMAT_R16G16_FLOAT;
		196
		197	case MESA_FORMAT_R_UNORM8:
		198	return PIPE_FORMAT_R8_UNORM;
		199	case MESA_FORMAT_R_UNORM16:
		200	return PIPE_FORMAT_R16_UNORM;
		201	case MESA_FORMAT_R8G8_UNORM:
		202	return PIPE_FORMAT_RG88_UNORM;
		203	case MESA_FORMAT_G8R8_UNORM:
		204	return PIPE_FORMAT_GR88_UNORM;
		205	case MESA_FORMAT_R16G16_UNORM:
		206	return PIPE_FORMAT_RG1616_UNORM;
		207	case MESA_FORMAT_G16R16_UNORM:
		208	return PIPE_FORMAT_GR1616_UNORM;
		209	case MESA_FORMAT_RGBA_UNORM16:
		210	return PIPE_FORMAT_R16G16B16A16_UNORM;
		211
		212	/* signed int formats */
		213	case MESA_FORMAT_A_UINT8:
		214	return PIPE_FORMAT_A8_UINT;
		215	case MESA_FORMAT_A_UINT16:
		216	return PIPE_FORMAT_A16_UINT;
		217	case MESA_FORMAT_A_UINT32:
		218	return PIPE_FORMAT_A32_UINT;
		219
		220	case MESA_FORMAT_A_SINT8:
		221	return PIPE_FORMAT_A8_SINT;
		222	case MESA_FORMAT_A_SINT16:
		223	return PIPE_FORMAT_A16_SINT;
		224	case MESA_FORMAT_A_SINT32:
		225	return PIPE_FORMAT_A32_SINT;
		226
		227	case MESA_FORMAT_I_UINT8:
		228	return PIPE_FORMAT_I8_UINT;
		229	case MESA_FORMAT_I_UINT16:
		230	return PIPE_FORMAT_I16_UINT;
		231	case MESA_FORMAT_I_UINT32:
		232	return PIPE_FORMAT_I32_UINT;
		233
		234	case MESA_FORMAT_I_SINT8:
		235	return PIPE_FORMAT_I8_SINT;
		236	case MESA_FORMAT_I_SINT16:
		237	return PIPE_FORMAT_I16_SINT;
		238	case MESA_FORMAT_I_SINT32:
		239	return PIPE_FORMAT_I32_SINT;
		240
		241	case MESA_FORMAT_L_UINT8:
		242	return PIPE_FORMAT_L8_UINT;
		243	case MESA_FORMAT_L_UINT16:
		244	return PIPE_FORMAT_L16_UINT;
		245	case MESA_FORMAT_L_UINT32:
		246	return PIPE_FORMAT_L32_UINT;
		247
		248	case MESA_FORMAT_L_SINT8:
		249	return PIPE_FORMAT_L8_SINT;
		250	case MESA_FORMAT_L_SINT16:
		251	return PIPE_FORMAT_L16_SINT;
		252	case MESA_FORMAT_L_SINT32:
		253	return PIPE_FORMAT_L32_SINT;
		254
		255	case MESA_FORMAT_LA_UINT8:
		256	return PIPE_FORMAT_L8A8_UINT;
		257	case MESA_FORMAT_LA_UINT16:
		258	return PIPE_FORMAT_L16A16_UINT;
		259	case MESA_FORMAT_LA_UINT32:
		260	return PIPE_FORMAT_L32A32_UINT;
		261
		262	case MESA_FORMAT_LA_SINT8:
		263	return PIPE_FORMAT_L8A8_SINT;
		264	case MESA_FORMAT_LA_SINT16:
		265	return PIPE_FORMAT_L16A16_SINT;
		266	case MESA_FORMAT_LA_SINT32:
		267	return PIPE_FORMAT_L32A32_SINT;
		268
		269	case MESA_FORMAT_R_SINT8:
		270	return PIPE_FORMAT_R8_SINT;
		271	case MESA_FORMAT_RG_SINT8:
		272	return PIPE_FORMAT_R8G8_SINT;
		273	case MESA_FORMAT_RGB_SINT8:
		274	return PIPE_FORMAT_R8G8B8_SINT;
		275	case MESA_FORMAT_RGBA_SINT8:
		276	return PIPE_FORMAT_R8G8B8A8_SINT;
		277	case MESA_FORMAT_R_SINT16:
		278	return PIPE_FORMAT_R16_SINT;
		279	case MESA_FORMAT_RG_SINT16:
		280	return PIPE_FORMAT_R16G16_SINT;
		281	case MESA_FORMAT_RGB_SINT16:
		282	return PIPE_FORMAT_R16G16B16_SINT;
		283	case MESA_FORMAT_RGBA_SINT16:
		284	return PIPE_FORMAT_R16G16B16A16_SINT;
		285	case MESA_FORMAT_R_SINT32:
		286	return PIPE_FORMAT_R32_SINT;
		287	case MESA_FORMAT_RG_SINT32:
		288	return PIPE_FORMAT_R32G32_SINT;
		289	case MESA_FORMAT_RGB_SINT32:
		290	return PIPE_FORMAT_R32G32B32_SINT;
		291	case MESA_FORMAT_RGBA_SINT32:
		292	return PIPE_FORMAT_R32G32B32A32_SINT;
		293
		294	/* unsigned int formats */
		295	case MESA_FORMAT_R_UINT8:
		296	return PIPE_FORMAT_R8_UINT;
		297	case MESA_FORMAT_RG_UINT8:
		298	return PIPE_FORMAT_R8G8_UINT;
		299	case MESA_FORMAT_RGB_UINT8:
		300	return PIPE_FORMAT_R8G8B8_UINT;
		301	case MESA_FORMAT_RGBA_UINT8:
		302	return PIPE_FORMAT_R8G8B8A8_UINT;
		303	case MESA_FORMAT_R_UINT16:
		304	return PIPE_FORMAT_R16_UINT;
		305	case MESA_FORMAT_RG_UINT16:
		306	return PIPE_FORMAT_R16G16_UINT;
		307	case MESA_FORMAT_RGB_UINT16:
		308	return PIPE_FORMAT_R16G16B16_UINT;
		309	case MESA_FORMAT_RGBA_UINT16:
		310	return PIPE_FORMAT_R16G16B16A16_UINT;
		311	case MESA_FORMAT_R_UINT32:
		312	return PIPE_FORMAT_R32_UINT;
		313	case MESA_FORMAT_RG_UINT32:
		314	return PIPE_FORMAT_R32G32_UINT;
		315	case MESA_FORMAT_RGB_UINT32:
		316	return PIPE_FORMAT_R32G32B32_UINT;
		317	case MESA_FORMAT_RGBA_UINT32:
		318	return PIPE_FORMAT_R32G32B32A32_UINT;
		319
		320	case MESA_FORMAT_R_RGTC1_UNORM:
		321	return PIPE_FORMAT_RGTC1_UNORM;
		322	case MESA_FORMAT_R_RGTC1_SNORM:
		323	return PIPE_FORMAT_RGTC1_SNORM;
		324	case MESA_FORMAT_RG_RGTC2_UNORM:
		325	return PIPE_FORMAT_RGTC2_UNORM;
		326	case MESA_FORMAT_RG_RGTC2_SNORM:
		327	return PIPE_FORMAT_RGTC2_SNORM;
		328
		329	case MESA_FORMAT_L_LATC1_UNORM:
		330	return PIPE_FORMAT_LATC1_UNORM;
		331	case MESA_FORMAT_L_LATC1_SNORM:
		332	return PIPE_FORMAT_LATC1_SNORM;
		333	case MESA_FORMAT_LA_LATC2_UNORM:
		334	return PIPE_FORMAT_LATC2_UNORM;
		335	case MESA_FORMAT_LA_LATC2_SNORM:
		336	return PIPE_FORMAT_LATC2_SNORM;
		337
		338	/* The destination RGBA format mustn't be changed, because it's also
		339	* a destination format of the unpack/decompression function. */
		340	case MESA_FORMAT_ETC1_RGB8:
		341	return st->has_etc1 ? PIPE_FORMAT_ETC1_RGB8 : PIPE_FORMAT_R8G8B8A8_UNORM;
		342
		343	case MESA_FORMAT_BPTC_RGBA_UNORM:
		344	return PIPE_FORMAT_BPTC_RGBA_UNORM;
		345	case MESA_FORMAT_BPTC_SRGB_ALPHA_UNORM:
		346	return PIPE_FORMAT_BPTC_SRGBA;
		347	case MESA_FORMAT_BPTC_RGB_SIGNED_FLOAT:
		348	return PIPE_FORMAT_BPTC_RGB_FLOAT;
		349	case MESA_FORMAT_BPTC_RGB_UNSIGNED_FLOAT:
		350	return PIPE_FORMAT_BPTC_RGB_UFLOAT;
		351
		352	/* signed normalized formats */
		353	case MESA_FORMAT_R_SNORM8:
		354	return PIPE_FORMAT_R8_SNORM;
		355	case MESA_FORMAT_R8G8_SNORM:
		356	return PIPE_FORMAT_RG88_SNORM;
		357	case MESA_FORMAT_G8R8_SNORM:
		358	return PIPE_FORMAT_GR88_SNORM;
		359	case MESA_FORMAT_R8G8B8A8_SNORM:
		360	return PIPE_FORMAT_RGBA8888_SNORM;
		361	case MESA_FORMAT_A8B8G8R8_SNORM:
		362	return PIPE_FORMAT_ABGR8888_SNORM;
		363
		364	case MESA_FORMAT_A_SNORM8:
		365	return PIPE_FORMAT_A8_SNORM;
		366	case MESA_FORMAT_L_SNORM8:
		367	return PIPE_FORMAT_L8_SNORM;
		368	case MESA_FORMAT_L8A8_SNORM:
		369	return PIPE_FORMAT_LA88_SNORM;
		370	case MESA_FORMAT_A8L8_SNORM:
		371	return PIPE_FORMAT_AL88_SNORM;
		372	case MESA_FORMAT_I_SNORM8:
		373	return PIPE_FORMAT_I8_SNORM;
		374
		375	case MESA_FORMAT_R_SNORM16:
		376	return PIPE_FORMAT_R16_SNORM;
		377	case MESA_FORMAT_R16G16_SNORM:
		378	return PIPE_FORMAT_RG1616_SNORM;
		379	case MESA_FORMAT_G16R16_SNORM:
		380	return PIPE_FORMAT_GR1616_SNORM;
		381	case MESA_FORMAT_RGBA_SNORM16:
		382	return PIPE_FORMAT_R16G16B16A16_SNORM;
		383
		384	case MESA_FORMAT_A_SNORM16:
		385	return PIPE_FORMAT_A16_SNORM;
		386	case MESA_FORMAT_L_SNORM16:
		387	return PIPE_FORMAT_L16_SNORM;
		388	case MESA_FORMAT_LA_SNORM16:
		389	return PIPE_FORMAT_L16A16_SNORM;
		390	case MESA_FORMAT_I_SNORM16:
		391	return PIPE_FORMAT_I16_SNORM;
		392
		393	case MESA_FORMAT_R9G9B9E5_FLOAT:
		394	return PIPE_FORMAT_R9G9B9E5_FLOAT;
		395	case MESA_FORMAT_R11G11B10_FLOAT:
		396	return PIPE_FORMAT_R11G11B10_FLOAT;
		397	case MESA_FORMAT_B10G10R10A2_UINT:
		398	return PIPE_FORMAT_B10G10R10A2_UINT;
		399	case MESA_FORMAT_R10G10B10A2_UINT:
		400	return PIPE_FORMAT_R10G10B10A2_UINT;
		401
		402	case MESA_FORMAT_B4G4R4X4_UNORM:
		403	return PIPE_FORMAT_B4G4R4X4_UNORM;
		404	case MESA_FORMAT_B5G5R5X1_UNORM:
		405	return PIPE_FORMAT_B5G5R5X1_UNORM;
		406	case MESA_FORMAT_R8G8B8X8_SNORM:
		407	return PIPE_FORMAT_RGBX8888_SNORM;
		408	case MESA_FORMAT_X8B8G8R8_SNORM:
		409	return PIPE_FORMAT_XBGR8888_SNORM;
		410	case MESA_FORMAT_R8G8B8X8_SRGB:
		411	return PIPE_FORMAT_RGBX8888_SRGB;
		412	case MESA_FORMAT_X8B8G8R8_SRGB:
		413	return PIPE_FORMAT_XBGR8888_SRGB;
		414	case MESA_FORMAT_RGBX_UINT8:
		415	return PIPE_FORMAT_R8G8B8X8_UINT;
		416	case MESA_FORMAT_RGBX_SINT8:
		417	return PIPE_FORMAT_R8G8B8X8_SINT;
		418	case MESA_FORMAT_B10G10R10X2_UNORM:
		419	return PIPE_FORMAT_B10G10R10X2_UNORM;
		420	case MESA_FORMAT_RGBX_UNORM16:
		421	return PIPE_FORMAT_R16G16B16X16_UNORM;
		422	case MESA_FORMAT_RGBX_SNORM16:
		423	return PIPE_FORMAT_R16G16B16X16_SNORM;
		424	case MESA_FORMAT_RGBX_FLOAT16:
		425	return PIPE_FORMAT_R16G16B16X16_FLOAT;
		426	case MESA_FORMAT_RGBX_UINT16:
		427	return PIPE_FORMAT_R16G16B16X16_UINT;
		428	case MESA_FORMAT_RGBX_SINT16:
		429	return PIPE_FORMAT_R16G16B16X16_SINT;
		430	case MESA_FORMAT_RGBX_FLOAT32:
		431	return PIPE_FORMAT_R32G32B32X32_FLOAT;
		432	case MESA_FORMAT_RGBX_UINT32:
		433	return PIPE_FORMAT_R32G32B32X32_UINT;
		434	case MESA_FORMAT_RGBX_SINT32:
		435	return PIPE_FORMAT_R32G32B32X32_SINT;
		436
		437	case MESA_FORMAT_B8G8R8X8_SRGB:
		438	return PIPE_FORMAT_BGRX8888_SRGB;
		439	case MESA_FORMAT_X8R8G8B8_SRGB:
		440	return PIPE_FORMAT_XRGB8888_SRGB;
		441
		442	/* ETC2 formats are emulated as uncompressed ones.
		443	* The destination formats mustn't be changed, because they are also
		444	* destination formats of the unpack/decompression function. */
		445	case MESA_FORMAT_ETC2_RGB8:
		446	return st->has_etc2 ? PIPE_FORMAT_ETC2_RGB8 : PIPE_FORMAT_R8G8B8A8_UNORM;
		447	case MESA_FORMAT_ETC2_SRGB8:
		448	return st->has_etc2 ? PIPE_FORMAT_ETC2_SRGB8 : PIPE_FORMAT_B8G8R8A8_SRGB;
		449	case MESA_FORMAT_ETC2_RGBA8_EAC:
		450	return st->has_etc2 ? PIPE_FORMAT_ETC2_RGBA8 : PIPE_FORMAT_R8G8B8A8_UNORM;
		451	case MESA_FORMAT_ETC2_SRGB8_ALPHA8_EAC:
		452	return st->has_etc2 ? PIPE_FORMAT_ETC2_SRGBA8 : PIPE_FORMAT_B8G8R8A8_SRGB;
		453	case MESA_FORMAT_ETC2_R11_EAC:
		454	return st->has_etc2 ? PIPE_FORMAT_ETC2_R11_UNORM : PIPE_FORMAT_R16_UNORM;
		455	case MESA_FORMAT_ETC2_RG11_EAC:
		456	return st->has_etc2 ? PIPE_FORMAT_ETC2_RG11_UNORM : PIPE_FORMAT_R16G16_UNORM;
		457	case MESA_FORMAT_ETC2_SIGNED_R11_EAC:
		458	return st->has_etc2 ? PIPE_FORMAT_ETC2_R11_SNORM : PIPE_FORMAT_R16_SNORM;
		459	case MESA_FORMAT_ETC2_SIGNED_RG11_EAC:
		460	return st->has_etc2 ? PIPE_FORMAT_ETC2_RG11_SNORM : PIPE_FORMAT_R16G16_SNORM;
		461	case MESA_FORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1:
		462	return st->has_etc2 ? PIPE_FORMAT_ETC2_RGB8A1 : PIPE_FORMAT_R8G8B8A8_UNORM;
		463	case MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1:
		464	return st->has_etc2 ? PIPE_FORMAT_ETC2_SRGB8A1 : PIPE_FORMAT_B8G8R8A8_SRGB;
		465
		466	default:
		467	return PIPE_FORMAT_NONE;
		468	}
		469	}
		470
		471
		472	/**
		473	* Translate Gallium format to Mesa format.
		474	*/
		475	mesa_format
		476	st_pipe_format_to_mesa_format(enum pipe_format format)
		477	{
		478	switch (format) {
		479	case PIPE_FORMAT_ABGR8888_UNORM:
		480	return MESA_FORMAT_A8B8G8R8_UNORM;
		481	case PIPE_FORMAT_RGBA8888_UNORM:
		482	return MESA_FORMAT_R8G8B8A8_UNORM;
		483	case PIPE_FORMAT_BGRA8888_UNORM:
		484	return MESA_FORMAT_B8G8R8A8_UNORM;
		485	case PIPE_FORMAT_ARGB8888_UNORM:
		486	return MESA_FORMAT_A8R8G8B8_UNORM;
		487	case PIPE_FORMAT_XBGR8888_UNORM:
		488	return MESA_FORMAT_X8B8G8R8_UNORM;
		489	case PIPE_FORMAT_RGBX8888_UNORM:
		490	return MESA_FORMAT_R8G8B8X8_UNORM;
		491	case PIPE_FORMAT_BGRX8888_UNORM:
		492	return MESA_FORMAT_B8G8R8X8_UNORM;
		493	case PIPE_FORMAT_XRGB8888_UNORM:
		494	return MESA_FORMAT_X8R8G8B8_UNORM;
		495	case PIPE_FORMAT_B5G5R5A1_UNORM:
		496	return MESA_FORMAT_B5G5R5A1_UNORM;
		497	case PIPE_FORMAT_B4G4R4A4_UNORM:
		498	return MESA_FORMAT_B4G4R4A4_UNORM;
		499	case PIPE_FORMAT_B5G6R5_UNORM:
		500	return MESA_FORMAT_B5G6R5_UNORM;
		501	case PIPE_FORMAT_B2G3R3_UNORM:
		502	return MESA_FORMAT_B2G3R3_UNORM;
		503	case PIPE_FORMAT_B10G10R10A2_UNORM:
		504	return MESA_FORMAT_B10G10R10A2_UNORM;
		505	case PIPE_FORMAT_R10G10B10A2_UNORM:
		506	return MESA_FORMAT_R10G10B10A2_UNORM;
		507	case PIPE_FORMAT_L4A4_UNORM:
		508	return MESA_FORMAT_L4A4_UNORM;
		509	case PIPE_FORMAT_LA88_UNORM:
		510	return MESA_FORMAT_L8A8_UNORM;
		511	case PIPE_FORMAT_AL88_UNORM:
		512	return MESA_FORMAT_A8L8_UNORM;
		513	case PIPE_FORMAT_LA1616_UNORM:
		514	return MESA_FORMAT_L16A16_UNORM;
		515	case PIPE_FORMAT_AL1616_UNORM:
		516	return MESA_FORMAT_A16L16_UNORM;
		517	case PIPE_FORMAT_A8_UNORM:
		518	return MESA_FORMAT_A_UNORM8;
		519	case PIPE_FORMAT_A16_UNORM:
		520	return MESA_FORMAT_A_UNORM16;
		521	case PIPE_FORMAT_L8_UNORM:
		522	return MESA_FORMAT_L_UNORM8;
		523	case PIPE_FORMAT_L16_UNORM:
		524	return MESA_FORMAT_L_UNORM16;
		525	case PIPE_FORMAT_I8_UNORM:
		526	return MESA_FORMAT_I_UNORM8;
		527	case PIPE_FORMAT_I16_UNORM:
		528	return MESA_FORMAT_I_UNORM16;
		529	case PIPE_FORMAT_S8_UINT:
		530	return MESA_FORMAT_S_UINT8;
		531
		532	case PIPE_FORMAT_R16G16B16A16_UNORM:
		533	return MESA_FORMAT_RGBA_UNORM16;
		534
		535	case PIPE_FORMAT_Z16_UNORM:
		536	return MESA_FORMAT_Z_UNORM16;
		537	case PIPE_FORMAT_Z32_UNORM:
		538	return MESA_FORMAT_Z_UNORM32;
		539	case PIPE_FORMAT_S8_UINT_Z24_UNORM:
		540	return MESA_FORMAT_S8_UINT_Z24_UNORM;
		541	case PIPE_FORMAT_X8Z24_UNORM:
		542	return MESA_FORMAT_X8_UINT_Z24_UNORM;
		543	case PIPE_FORMAT_Z24X8_UNORM:
		544	return MESA_FORMAT_Z24_UNORM_X8_UINT;
		545	case PIPE_FORMAT_Z24_UNORM_S8_UINT:
		546	return MESA_FORMAT_Z24_UNORM_S8_UINT;
		547	case PIPE_FORMAT_Z32_FLOAT:
		548	return MESA_FORMAT_Z_FLOAT32;
		549	case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT:
		550	return MESA_FORMAT_Z32_FLOAT_S8X24_UINT;
		551
		552	case PIPE_FORMAT_UYVY:
		553	return MESA_FORMAT_YCBCR;
		554	case PIPE_FORMAT_YUYV:
		555	return MESA_FORMAT_YCBCR_REV;
		556
		557	case PIPE_FORMAT_DXT1_RGB:
		558	return MESA_FORMAT_RGB_DXT1;
		559	case PIPE_FORMAT_DXT1_RGBA:
		560	return MESA_FORMAT_RGBA_DXT1;
		561	case PIPE_FORMAT_DXT3_RGBA:
		562	return MESA_FORMAT_RGBA_DXT3;
		563	case PIPE_FORMAT_DXT5_RGBA:
		564	return MESA_FORMAT_RGBA_DXT5;
		565	case PIPE_FORMAT_DXT1_SRGB:
		566	return MESA_FORMAT_SRGB_DXT1;
		567	case PIPE_FORMAT_DXT1_SRGBA:
		568	return MESA_FORMAT_SRGBA_DXT1;
		569	case PIPE_FORMAT_DXT3_SRGBA:
		570	return MESA_FORMAT_SRGBA_DXT3;
		571	case PIPE_FORMAT_DXT5_SRGBA:
		572	return MESA_FORMAT_SRGBA_DXT5;
		573	case PIPE_FORMAT_LA88_SRGB:
		574	return MESA_FORMAT_L8A8_SRGB;
		575	case PIPE_FORMAT_AL88_SRGB:
		576	return MESA_FORMAT_A8L8_SRGB;
		577	case PIPE_FORMAT_L8_SRGB:
		578	return MESA_FORMAT_L_SRGB8;
		579	case PIPE_FORMAT_R8G8B8_SRGB:
		580	return MESA_FORMAT_BGR_SRGB8;
		581	case PIPE_FORMAT_ABGR8888_SRGB:
		582	return MESA_FORMAT_A8B8G8R8_SRGB;
		583	case PIPE_FORMAT_RGBA8888_SRGB:
		584	return MESA_FORMAT_R8G8B8A8_SRGB;
		585	case PIPE_FORMAT_BGRA8888_SRGB:
		586	return MESA_FORMAT_B8G8R8A8_SRGB;
		587	case PIPE_FORMAT_ARGB8888_SRGB:
		588	return MESA_FORMAT_A8R8G8B8_SRGB;
		589	case PIPE_FORMAT_R32G32B32A32_FLOAT:
		590	return MESA_FORMAT_RGBA_FLOAT32;
		591	case PIPE_FORMAT_R16G16B16A16_FLOAT:
		592	return MESA_FORMAT_RGBA_FLOAT16;
		593	case PIPE_FORMAT_R32G32B32_FLOAT:
		594	return MESA_FORMAT_RGB_FLOAT32;
		595	case PIPE_FORMAT_R16G16B16_FLOAT:
		596	return MESA_FORMAT_RGB_FLOAT16;
		597	case PIPE_FORMAT_L32A32_FLOAT:
		598	return MESA_FORMAT_LA_FLOAT32;
		599	case PIPE_FORMAT_L16A16_FLOAT:
		600	return MESA_FORMAT_LA_FLOAT16;
		601	case PIPE_FORMAT_L32_FLOAT:
		602	return MESA_FORMAT_L_FLOAT32;
		603	case PIPE_FORMAT_L16_FLOAT:
		604	return MESA_FORMAT_L_FLOAT16;
		605	case PIPE_FORMAT_A32_FLOAT:
		606	return MESA_FORMAT_A_FLOAT32;
		607	case PIPE_FORMAT_A16_FLOAT:
		608	return MESA_FORMAT_A_FLOAT16;
		609	case PIPE_FORMAT_I32_FLOAT:
		610	return MESA_FORMAT_I_FLOAT32;
		611	case PIPE_FORMAT_I16_FLOAT:
		612	return MESA_FORMAT_I_FLOAT16;
		613	case PIPE_FORMAT_R32_FLOAT:
		614	return MESA_FORMAT_R_FLOAT32;
		615	case PIPE_FORMAT_R16_FLOAT:
		616	return MESA_FORMAT_R_FLOAT16;
		617	case PIPE_FORMAT_R32G32_FLOAT:
		618	return MESA_FORMAT_RG_FLOAT32;
		619	case PIPE_FORMAT_R16G16_FLOAT:
		620	return MESA_FORMAT_RG_FLOAT16;
		621
		622	case PIPE_FORMAT_R8_UNORM:
		623	return MESA_FORMAT_R_UNORM8;
		624	case PIPE_FORMAT_R16_UNORM:
		625	return MESA_FORMAT_R_UNORM16;
		626	case PIPE_FORMAT_RG88_UNORM:
		627	return MESA_FORMAT_R8G8_UNORM;
		628	case PIPE_FORMAT_GR88_UNORM:
		629	return MESA_FORMAT_G8R8_UNORM;
		630	case PIPE_FORMAT_RG1616_UNORM:
		631	return MESA_FORMAT_R16G16_UNORM;
		632	case PIPE_FORMAT_GR1616_UNORM:
		633	return MESA_FORMAT_G16R16_UNORM;
		634
		635	case PIPE_FORMAT_A8_UINT:
		636	return MESA_FORMAT_A_UINT8;
		637	case PIPE_FORMAT_A16_UINT:
		638	return MESA_FORMAT_A_UINT16;
		639	case PIPE_FORMAT_A32_UINT:
		640	return MESA_FORMAT_A_UINT32;
		641	case PIPE_FORMAT_A8_SINT:
		642	return MESA_FORMAT_A_SINT8;
		643	case PIPE_FORMAT_A16_SINT:
		644	return MESA_FORMAT_A_SINT16;
		645	case PIPE_FORMAT_A32_SINT:
		646	return MESA_FORMAT_A_SINT32;
		647
		648	case PIPE_FORMAT_I8_UINT:
		649	return MESA_FORMAT_I_UINT8;
		650	case PIPE_FORMAT_I16_UINT:
		651	return MESA_FORMAT_I_UINT16;
		652	case PIPE_FORMAT_I32_UINT:
		653	return MESA_FORMAT_I_UINT32;
		654	case PIPE_FORMAT_I8_SINT:
		655	return MESA_FORMAT_I_SINT8;
		656	case PIPE_FORMAT_I16_SINT:
		657	return MESA_FORMAT_I_SINT16;
		658	case PIPE_FORMAT_I32_SINT:
		659	return MESA_FORMAT_I_SINT32;
		660
		661	case PIPE_FORMAT_L8_UINT:
		662	return MESA_FORMAT_L_UINT8;
		663	case PIPE_FORMAT_L16_UINT:
		664	return MESA_FORMAT_L_UINT16;
		665	case PIPE_FORMAT_L32_UINT:
		666	return MESA_FORMAT_L_UINT32;
		667	case PIPE_FORMAT_L8_SINT:
		668	return MESA_FORMAT_L_SINT8;
		669	case PIPE_FORMAT_L16_SINT:
		670	return MESA_FORMAT_L_SINT16;
		671	case PIPE_FORMAT_L32_SINT:
		672	return MESA_FORMAT_L_SINT32;
		673
		674	case PIPE_FORMAT_L8A8_UINT:
		675	return MESA_FORMAT_LA_UINT8;
		676	case PIPE_FORMAT_L16A16_UINT:
		677	return MESA_FORMAT_LA_UINT16;
		678	case PIPE_FORMAT_L32A32_UINT:
		679	return MESA_FORMAT_LA_UINT32;
		680	case PIPE_FORMAT_L8A8_SINT:
		681	return MESA_FORMAT_LA_SINT8;
		682	case PIPE_FORMAT_L16A16_SINT:
		683	return MESA_FORMAT_LA_SINT16;
		684	case PIPE_FORMAT_L32A32_SINT:
		685	return MESA_FORMAT_LA_SINT32;
		686
		687	case PIPE_FORMAT_R8_SINT:
		688	return MESA_FORMAT_R_SINT8;
		689	case PIPE_FORMAT_R8G8_SINT:
		690	return MESA_FORMAT_RG_SINT8;
		691	case PIPE_FORMAT_R8G8B8_SINT:
		692	return MESA_FORMAT_RGB_SINT8;
		693	case PIPE_FORMAT_R8G8B8A8_SINT:
		694	return MESA_FORMAT_RGBA_SINT8;
		695
		696	case PIPE_FORMAT_R16_SINT:
		697	return MESA_FORMAT_R_SINT16;
		698	case PIPE_FORMAT_R16G16_SINT:
		699	return MESA_FORMAT_RG_SINT16;
		700	case PIPE_FORMAT_R16G16B16_SINT:
		701	return MESA_FORMAT_RGB_SINT16;
		702	case PIPE_FORMAT_R16G16B16A16_SINT:
		703	return MESA_FORMAT_RGBA_SINT16;
		704
		705	case PIPE_FORMAT_R32_SINT:
		706	return MESA_FORMAT_R_SINT32;
		707	case PIPE_FORMAT_R32G32_SINT:
		708	return MESA_FORMAT_RG_SINT32;
		709	case PIPE_FORMAT_R32G32B32_SINT:
		710	return MESA_FORMAT_RGB_SINT32;
		711	case PIPE_FORMAT_R32G32B32A32_SINT:
		712	return MESA_FORMAT_RGBA_SINT32;
		713
		714	/* unsigned int formats */
		715	case PIPE_FORMAT_R8_UINT:
		716	return MESA_FORMAT_R_UINT8;
		717	case PIPE_FORMAT_R8G8_UINT:
		718	return MESA_FORMAT_RG_UINT8;
		719	case PIPE_FORMAT_R8G8B8_UINT:
		720	return MESA_FORMAT_RGB_UINT8;
		721	case PIPE_FORMAT_R8G8B8A8_UINT:
		722	return MESA_FORMAT_RGBA_UINT8;
		723
		724	case PIPE_FORMAT_R16_UINT:
		725	return MESA_FORMAT_R_UINT16;
		726	case PIPE_FORMAT_R16G16_UINT:
		727	return MESA_FORMAT_RG_UINT16;
		728	case PIPE_FORMAT_R16G16B16_UINT:
		729	return MESA_FORMAT_RGB_UINT16;
		730	case PIPE_FORMAT_R16G16B16A16_UINT:
		731	return MESA_FORMAT_RGBA_UINT16;
		732
		733	case PIPE_FORMAT_R32_UINT:
		734	return MESA_FORMAT_R_UINT32;
		735	case PIPE_FORMAT_R32G32_UINT:
		736	return MESA_FORMAT_RG_UINT32;
		737	case PIPE_FORMAT_R32G32B32_UINT:
		738	return MESA_FORMAT_RGB_UINT32;
		739	case PIPE_FORMAT_R32G32B32A32_UINT:
		740	return MESA_FORMAT_RGBA_UINT32;
		741
		742	case PIPE_FORMAT_RGTC1_UNORM:
		743	return MESA_FORMAT_R_RGTC1_UNORM;
		744	case PIPE_FORMAT_RGTC1_SNORM:
		745	return MESA_FORMAT_R_RGTC1_SNORM;
		746	case PIPE_FORMAT_RGTC2_UNORM:
		747	return MESA_FORMAT_RG_RGTC2_UNORM;
		748	case PIPE_FORMAT_RGTC2_SNORM:
		749	return MESA_FORMAT_RG_RGTC2_SNORM;
		750
		751	case PIPE_FORMAT_LATC1_UNORM:
		752	return MESA_FORMAT_L_LATC1_UNORM;
		753	case PIPE_FORMAT_LATC1_SNORM:
		754	return MESA_FORMAT_L_LATC1_SNORM;
		755	case PIPE_FORMAT_LATC2_UNORM:
		756	return MESA_FORMAT_LA_LATC2_UNORM;
		757	case PIPE_FORMAT_LATC2_SNORM:
		758	return MESA_FORMAT_LA_LATC2_SNORM;
		759
		760	case PIPE_FORMAT_ETC1_RGB8:
		761	return MESA_FORMAT_ETC1_RGB8;
		762
		763	case PIPE_FORMAT_BPTC_RGBA_UNORM:
		764	return MESA_FORMAT_BPTC_RGBA_UNORM;
		765	case PIPE_FORMAT_BPTC_SRGBA:
		766	return MESA_FORMAT_BPTC_SRGB_ALPHA_UNORM;
		767	case PIPE_FORMAT_BPTC_RGB_FLOAT:
		768	return MESA_FORMAT_BPTC_RGB_SIGNED_FLOAT;
		769	case PIPE_FORMAT_BPTC_RGB_UFLOAT:
		770	return MESA_FORMAT_BPTC_RGB_UNSIGNED_FLOAT;
		771
		772	/* signed normalized formats */
		773	case PIPE_FORMAT_R8_SNORM:
		774	return MESA_FORMAT_R_SNORM8;
		775	case PIPE_FORMAT_RG88_SNORM:
		776	return MESA_FORMAT_R8G8_SNORM;
		777	case PIPE_FORMAT_GR88_SNORM:
		778	return MESA_FORMAT_G8R8_SNORM;
		779	case PIPE_FORMAT_RGBA8888_SNORM:
		780	return MESA_FORMAT_R8G8B8A8_SNORM;
		781	case PIPE_FORMAT_ABGR8888_SNORM:
		782	return MESA_FORMAT_A8B8G8R8_SNORM;
		783
		784	case PIPE_FORMAT_A8_SNORM:
		785	return MESA_FORMAT_A_SNORM8;
		786	case PIPE_FORMAT_L8_SNORM:
		787	return MESA_FORMAT_L_SNORM8;
		788	case PIPE_FORMAT_LA88_SNORM:
		789	return MESA_FORMAT_L8A8_SNORM;
		790	case PIPE_FORMAT_AL88_SNORM:
		791	return MESA_FORMAT_A8L8_SNORM;
		792	case PIPE_FORMAT_I8_SNORM:
		793	return MESA_FORMAT_I_SNORM8;
		794
		795	case PIPE_FORMAT_R16_SNORM:
		796	return MESA_FORMAT_R_SNORM16;
		797	case PIPE_FORMAT_RG1616_SNORM:
		798	return MESA_FORMAT_R16G16_SNORM;
		799	case PIPE_FORMAT_GR1616_SNORM:
		800	return MESA_FORMAT_G16R16_SNORM;
		801	case PIPE_FORMAT_R16G16B16A16_SNORM:
		802	return MESA_FORMAT_RGBA_SNORM16;
		803
		804	case PIPE_FORMAT_A16_SNORM:
		805	return MESA_FORMAT_A_SNORM16;
		806	case PIPE_FORMAT_L16_SNORM:
		807	return MESA_FORMAT_L_SNORM16;
		808	case PIPE_FORMAT_L16A16_SNORM:
		809	return MESA_FORMAT_LA_SNORM16;
		810	case PIPE_FORMAT_I16_SNORM:
		811	return MESA_FORMAT_I_SNORM16;
		812
		813	case PIPE_FORMAT_R9G9B9E5_FLOAT:
		814	return MESA_FORMAT_R9G9B9E5_FLOAT;
		815	case PIPE_FORMAT_R11G11B10_FLOAT:
		816	return MESA_FORMAT_R11G11B10_FLOAT;
		817
		818	case PIPE_FORMAT_B10G10R10A2_UINT:
		819	return MESA_FORMAT_B10G10R10A2_UINT;
		820	case PIPE_FORMAT_R10G10B10A2_UINT:
		821	return MESA_FORMAT_R10G10B10A2_UINT;
		822
		823	case PIPE_FORMAT_B4G4R4X4_UNORM:
		824	return MESA_FORMAT_B4G4R4X4_UNORM;
		825	case PIPE_FORMAT_B5G5R5X1_UNORM:
		826	return MESA_FORMAT_B5G5R5X1_UNORM;
		827	case PIPE_FORMAT_RGBX8888_SNORM:
		828	return MESA_FORMAT_R8G8B8X8_SNORM;
		829	case PIPE_FORMAT_XBGR8888_SNORM:
		830	return MESA_FORMAT_X8B8G8R8_SNORM;
		831	case PIPE_FORMAT_RGBX8888_SRGB:
		832	return MESA_FORMAT_R8G8B8X8_SRGB;
		833	case PIPE_FORMAT_XBGR8888_SRGB:
		834	return MESA_FORMAT_X8B8G8R8_SRGB;
		835	case PIPE_FORMAT_R8G8B8X8_UINT:
		836	return MESA_FORMAT_RGBX_UINT8;
		837	case PIPE_FORMAT_R8G8B8X8_SINT:
		838	return MESA_FORMAT_RGBX_SINT8;
		839	case PIPE_FORMAT_B10G10R10X2_UNORM:
		840	return MESA_FORMAT_B10G10R10X2_UNORM;
		841	case PIPE_FORMAT_R16G16B16X16_UNORM:
		842	return MESA_FORMAT_RGBX_UNORM16;
		843	case PIPE_FORMAT_R16G16B16X16_SNORM:
		844	return MESA_FORMAT_RGBX_SNORM16;
		845	case PIPE_FORMAT_R16G16B16X16_FLOAT:
		846	return MESA_FORMAT_RGBX_FLOAT16;
		847	case PIPE_FORMAT_R16G16B16X16_UINT:
		848	return MESA_FORMAT_RGBX_UINT16;
		849	case PIPE_FORMAT_R16G16B16X16_SINT:
		850	return MESA_FORMAT_RGBX_SINT16;
		851	case PIPE_FORMAT_R32G32B32X32_FLOAT:
		852	return MESA_FORMAT_RGBX_FLOAT32;
		853	case PIPE_FORMAT_R32G32B32X32_UINT:
		854	return MESA_FORMAT_RGBX_UINT32;
		855	case PIPE_FORMAT_R32G32B32X32_SINT:
		856	return MESA_FORMAT_RGBX_SINT32;
		857
		858	case PIPE_FORMAT_BGRX8888_SRGB:
		859	return MESA_FORMAT_B8G8R8X8_SRGB;
		860	case PIPE_FORMAT_XRGB8888_SRGB:
		861	return MESA_FORMAT_X8R8G8B8_SRGB;
		862
		863	case PIPE_FORMAT_ETC2_RGB8:
		864	return MESA_FORMAT_ETC2_RGB8;
		865	case PIPE_FORMAT_ETC2_SRGB8:
		866	return MESA_FORMAT_ETC2_SRGB8;
		867	case PIPE_FORMAT_ETC2_RGB8A1:
		868	return MESA_FORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1;
		869	case PIPE_FORMAT_ETC2_SRGB8A1:
		870	return MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1;
		871	case PIPE_FORMAT_ETC2_RGBA8:
		872	return MESA_FORMAT_ETC2_RGBA8_EAC;
		873	case PIPE_FORMAT_ETC2_SRGBA8:
		874	return MESA_FORMAT_ETC2_SRGB8_ALPHA8_EAC;
		875	case PIPE_FORMAT_ETC2_R11_UNORM:
		876	return MESA_FORMAT_ETC2_R11_EAC;
		877	case PIPE_FORMAT_ETC2_R11_SNORM:
		878	return MESA_FORMAT_ETC2_SIGNED_R11_EAC;
		879	case PIPE_FORMAT_ETC2_RG11_UNORM:
		880	return MESA_FORMAT_ETC2_RG11_EAC;
		881	case PIPE_FORMAT_ETC2_RG11_SNORM:
		882	return MESA_FORMAT_ETC2_SIGNED_RG11_EAC;
		883
		884	default:
		885	return MESA_FORMAT_NONE;
		886	}
		887	}
		888
		889
		890	/**
		891	* Debug only: check that the two functions above correctly map
		892	* Mesa formats to Gallium formats and back again.
		893	*/
		894	static void
		895	test_format_conversion(struct st_context *st)
		896	{
		897	GLuint i;
		898
		899	/* test all Mesa formats */
		900	for (i = 1; i < MESA_FORMAT_COUNT; i++) {
		901	enum pipe_format pf;
		902
		903	/* ETC formats are translated differently, skip them. */
		904	if (_mesa_is_format_etc2(i))
		905	continue;
		906	if (i == MESA_FORMAT_ETC1_RGB8 && !st->has_etc1)
		907	continue;
		908
		909	pf = st_mesa_format_to_pipe_format(st, i);
		910	if (pf != PIPE_FORMAT_NONE) {
		911	mesa_format mf = st_pipe_format_to_mesa_format(pf);
		912	assert(mf == i);
		913	}
		914	}
		915
		916	/* Test all Gallium formats */
		917	for (i = 1; i < PIPE_FORMAT_COUNT; i++) {
		918	mesa_format mf = st_pipe_format_to_mesa_format(i);
		919
		920	/* ETC formats are translated differently, skip them. */
		921	if (i == PIPE_FORMAT_ETC1_RGB8 && !st->has_etc1)
		922	continue;
		923
		924	if (_mesa_is_format_etc2(mf) && !st->has_etc2)
		925	continue;
		926
		927	if (mf != MESA_FORMAT_NONE) {
		928	enum pipe_format pf = st_mesa_format_to_pipe_format(st, mf);
		929	assert(pf == i);
		930	}
		931	}
		932	}
		933
		934
		935	/**
		936	* Map GL texture formats to Gallium pipe formats.
		937	*/
		938	struct format_mapping
		939	{
		940	GLenum glFormats[18]; /*< list of GLenum formats, 0-terminated /
		941	enum pipe_format pipeFormats[13]; /*< list of pipe formats, 0-terminated /
		942	};
		943
		944
		945	#define DEFAULT_RGBA_FORMATS \
		946	PIPE_FORMAT_B8G8R8A8_UNORM, \
		947	PIPE_FORMAT_R8G8B8A8_UNORM, \
		948	PIPE_FORMAT_A8R8G8B8_UNORM, \
		949	PIPE_FORMAT_A8B8G8R8_UNORM, \
		950
		951
		952	#define DEFAULT_RGB_FORMATS \
		953	PIPE_FORMAT_B8G8R8X8_UNORM, \
		954	PIPE_FORMAT_R8G8B8X8_UNORM, \
		955	PIPE_FORMAT_X8R8G8B8_UNORM, \
		956	PIPE_FORMAT_X8B8G8R8_UNORM, \
		957	PIPE_FORMAT_B5G6R5_UNORM, \
		958	DEFAULT_RGBA_FORMATS
		959
		960	#define DEFAULT_SRGBA_FORMATS \
		961	PIPE_FORMAT_B8G8R8A8_SRGB, \
		962	PIPE_FORMAT_R8G8B8A8_SRGB, \
		963	PIPE_FORMAT_A8R8G8B8_SRGB, \
		964	PIPE_FORMAT_A8B8G8R8_SRGB, \
		965
		966
		967	#define DEFAULT_DEPTH_FORMATS \
		968	PIPE_FORMAT_Z24X8_UNORM, \
		969	PIPE_FORMAT_X8Z24_UNORM, \
		970	PIPE_FORMAT_Z16_UNORM, \
		971	PIPE_FORMAT_Z24_UNORM_S8_UINT, \
		972	PIPE_FORMAT_S8_UINT_Z24_UNORM, \
		973
		974
		975	#define DEFAULT_SNORM8_RGBA_FORMATS \
		976	PIPE_FORMAT_R8G8B8A8_SNORM, \
		977
		978
		979	#define DEFAULT_UNORM16_RGBA_FORMATS \
		980	PIPE_FORMAT_R16G16B16A16_UNORM, \
		981	DEFAULT_RGBA_FORMATS
		982
		983
		984	/**
		985	* This table maps OpenGL texture format enums to Gallium pipe_format enums.
		986	* Multiple GL enums might map to multiple pipe_formats.
		987	* The first pipe format in the list that's supported is the one that's chosen.
		988	*/
		989	static const struct format_mapping format_map[] = {
		990	/* Basic RGB, RGBA formats */
		991	{
		992	{ GL_RGB10, 0 },
		993	{ PIPE_FORMAT_B10G10R10X2_UNORM, PIPE_FORMAT_B10G10R10A2_UNORM,
		994	PIPE_FORMAT_R10G10B10A2_UNORM, DEFAULT_RGB_FORMATS }
		995	},
		996	{
		997	{ GL_RGB10_A2, 0 },
		998	{ PIPE_FORMAT_B10G10R10A2_UNORM, PIPE_FORMAT_R10G10B10A2_UNORM,
		999	DEFAULT_RGBA_FORMATS }
		1000	},
		1001	{
		1002	{ 4, GL_RGBA, GL_RGBA8, 0 },
		1003	{ DEFAULT_RGBA_FORMATS }
		1004	},
		1005	{
		1006	{ GL_BGRA, 0 },
		1007	{ DEFAULT_RGBA_FORMATS }
		1008	},
		1009	{
		1010	{ 3, GL_RGB, GL_RGB8, 0 },
		1011	{ DEFAULT_RGB_FORMATS }
		1012	},
		1013	{
		1014	{ GL_RGB12, GL_RGB16, 0 },
		1015	{ PIPE_FORMAT_R16G16B16X16_UNORM, PIPE_FORMAT_R16G16B16A16_UNORM,
		1016	DEFAULT_RGB_FORMATS }
		1017	},
		1018	{
		1019	{ GL_RGBA12, GL_RGBA16, 0 },
		1020	{ PIPE_FORMAT_R16G16B16A16_UNORM, DEFAULT_RGBA_FORMATS }
		1021	},
		1022	{
		1023	{ GL_RGBA4, GL_RGBA2, 0 },
		1024	{ PIPE_FORMAT_B4G4R4A4_UNORM, DEFAULT_RGBA_FORMATS }
		1025	},
		1026	{
		1027	{ GL_RGB5_A1, 0 },
		1028	{ PIPE_FORMAT_B5G5R5A1_UNORM, DEFAULT_RGBA_FORMATS }
		1029	},
		1030	{
		1031	{ GL_R3_G3_B2, 0 },
		1032	{ PIPE_FORMAT_B2G3R3_UNORM, PIPE_FORMAT_B5G6R5_UNORM,
		1033	PIPE_FORMAT_B5G5R5A1_UNORM, DEFAULT_RGB_FORMATS }
		1034	},
		1035	{
		1036	{ GL_RGB4 },
		1037	{ PIPE_FORMAT_B4G4R4X4_UNORM, PIPE_FORMAT_B4G4R4A4_UNORM,
		1038	DEFAULT_RGB_FORMATS }
		1039	},
		1040	{
		1041	{ GL_RGB5 },
		1042	{ PIPE_FORMAT_B5G5R5X1_UNORM, PIPE_FORMAT_B5G5R5A1_UNORM,
		1043	DEFAULT_RGB_FORMATS }
		1044	},
		1045	{
		1046	{ GL_RGB565 },
		1047	{ PIPE_FORMAT_B5G6R5_UNORM, DEFAULT_RGB_FORMATS }
		1048	},
		1049
		1050	/* basic Alpha formats */
		1051	{
		1052	{ GL_ALPHA12, GL_ALPHA16, 0 },
		1053	{ PIPE_FORMAT_A16_UNORM, PIPE_FORMAT_A8_UNORM,
		1054	DEFAULT_RGBA_FORMATS }
		1055	},
		1056	{
		1057	{ GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_COMPRESSED_ALPHA, 0 },
		1058	{ PIPE_FORMAT_A8_UNORM, DEFAULT_RGBA_FORMATS }
		1059	},
		1060
		1061	/* basic Luminance formats */
		1062	{
		1063	{ GL_LUMINANCE12, GL_LUMINANCE16, 0 },
		1064	{ PIPE_FORMAT_L16_UNORM, PIPE_FORMAT_L8_UNORM, DEFAULT_RGB_FORMATS }
		1065	},
		1066	{
		1067	{ 1, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, 0 },
		1068	{ PIPE_FORMAT_L8_UNORM, DEFAULT_RGB_FORMATS }
		1069	},
		1070
		1071	/* basic Luminance/Alpha formats */
		1072	{
		1073	{ GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12,
		1074	GL_LUMINANCE16_ALPHA16, 0},
		1075	{ PIPE_FORMAT_L16A16_UNORM, PIPE_FORMAT_L8A8_UNORM,
		1076	DEFAULT_RGBA_FORMATS }
		1077	},
		1078	{
		1079	{ 2, GL_LUMINANCE_ALPHA, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, 0 },
		1080	{ PIPE_FORMAT_L8A8_UNORM, DEFAULT_RGBA_FORMATS }
		1081	},
		1082	{
		1083	{ GL_LUMINANCE4_ALPHA4, 0 },
		1084	{ PIPE_FORMAT_L4A4_UNORM, PIPE_FORMAT_L8A8_UNORM,
		1085	DEFAULT_RGBA_FORMATS }
		1086	},
		1087
		1088	/* basic Intensity formats */
		1089	{
		1090	{ GL_INTENSITY12, GL_INTENSITY16, 0 },
		1091	{ PIPE_FORMAT_I16_UNORM, PIPE_FORMAT_I8_UNORM, DEFAULT_RGBA_FORMATS }
		1092	},
		1093	{
		1094	{ GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8,
		1095	GL_COMPRESSED_INTENSITY, 0 },
		1096	{ PIPE_FORMAT_I8_UNORM, DEFAULT_RGBA_FORMATS }
		1097	},
		1098
		1099	/* YCbCr */
		1100	{
		1101	{ GL_YCBCR_MESA, 0 },
		1102	{ PIPE_FORMAT_UYVY, PIPE_FORMAT_YUYV, 0 }
		1103	},
		1104
		1105	/* compressed formats / / XXX PIPE_BIND_SAMPLER_VIEW only */
		1106	{
		1107	{ GL_COMPRESSED_RGB, 0 },
		1108	{ PIPE_FORMAT_DXT1_RGB, DEFAULT_RGB_FORMATS }
		1109	},
		1110	{
		1111	{ GL_COMPRESSED_RGBA, 0 },
		1112	{ PIPE_FORMAT_DXT5_RGBA, DEFAULT_RGBA_FORMATS }
		1113	},
		1114	{
		1115	{ GL_RGB_S3TC, GL_RGB4_S3TC, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, 0 },
		1116	{ PIPE_FORMAT_DXT1_RGB, 0 }
		1117	},
		1118	{
		1119	{ GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, 0 },
		1120	{ PIPE_FORMAT_DXT1_RGBA, 0 }
		1121	},
		1122	{
		1123	{ GL_RGBA_S3TC, GL_RGBA4_S3TC, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, 0 },
		1124	{ PIPE_FORMAT_DXT3_RGBA, 0 }
		1125	},
		1126	{
		1127	{ GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, 0 },
		1128	{ PIPE_FORMAT_DXT5_RGBA, 0 }
		1129	},
		1130
		1131	#if 0
		1132	{
		1133	{ GL_COMPRESSED_RGB_FXT1_3DFX, 0 },
		1134	{ PIPE_FORMAT_RGB_FXT1, 0 }
		1135	},
		1136	{
		1137	{ GL_COMPRESSED_RGBA_FXT1_3DFX, 0 },
		1138	{ PIPE_FORMAT_RGBA_FXT1, 0 }
		1139	},
		1140	#endif
		1141
		1142	/* Depth formats */
		1143	{
		1144	{ GL_DEPTH_COMPONENT16, 0 },
		1145	{ PIPE_FORMAT_Z16_UNORM, DEFAULT_DEPTH_FORMATS }
		1146	},
		1147	{
		1148	{ GL_DEPTH_COMPONENT24, 0 },
		1149	{ PIPE_FORMAT_Z24X8_UNORM, PIPE_FORMAT_X8Z24_UNORM,
		1150	DEFAULT_DEPTH_FORMATS }
		1151	},
		1152	{
		1153	{ GL_DEPTH_COMPONENT32, 0 },
		1154	{ PIPE_FORMAT_Z32_UNORM, DEFAULT_DEPTH_FORMATS }
		1155	},
		1156	{
		1157	{ GL_DEPTH_COMPONENT, 0 },
		1158	{ DEFAULT_DEPTH_FORMATS }
		1159	},
		1160	{
		1161	{ GL_DEPTH_COMPONENT32F, 0 },
		1162	{ PIPE_FORMAT_Z32_FLOAT, 0 }
		1163	},
		1164
		1165	/* stencil formats */
		1166	{
		1167	{ GL_STENCIL_INDEX, GL_STENCIL_INDEX1_EXT, GL_STENCIL_INDEX4_EXT,
		1168	GL_STENCIL_INDEX8_EXT, GL_STENCIL_INDEX16_EXT, 0 },
		1169	{
		1170	PIPE_FORMAT_S8_UINT, PIPE_FORMAT_Z24_UNORM_S8_UINT,
		1171	PIPE_FORMAT_S8_UINT_Z24_UNORM, 0
		1172	}
		1173	},
		1174
		1175	/* Depth / Stencil formats */
		1176	{
		1177	{ GL_DEPTH_STENCIL_EXT, GL_DEPTH24_STENCIL8_EXT, 0 },
		1178	{ PIPE_FORMAT_Z24_UNORM_S8_UINT, PIPE_FORMAT_S8_UINT_Z24_UNORM, 0 }
		1179	},
		1180	{
		1181	{ GL_DEPTH32F_STENCIL8, 0 },
		1182	{ PIPE_FORMAT_Z32_FLOAT_S8X24_UINT, 0 }
		1183	},
		1184
		1185	/* sRGB formats */
		1186	{
		1187	{ GL_SRGB_EXT, GL_SRGB8_EXT, 0 },
		1188	{ PIPE_FORMAT_R8G8B8X8_SRGB, PIPE_FORMAT_B8G8R8X8_SRGB,
		1189	DEFAULT_SRGBA_FORMATS }
		1190	},
		1191	{
		1192	{ GL_SRGB_ALPHA_EXT, GL_SRGB8_ALPHA8_EXT, 0 },
		1193	{ DEFAULT_SRGBA_FORMATS }
		1194	},
		1195	{
		1196	{ GL_COMPRESSED_SRGB_EXT, GL_COMPRESSED_SRGB_S3TC_DXT1_EXT, 0 },
		1197	{ PIPE_FORMAT_DXT1_SRGB, PIPE_FORMAT_R8G8B8X8_SRGB,
		1198	PIPE_FORMAT_B8G8R8X8_SRGB, DEFAULT_SRGBA_FORMATS }
		1199	},
		1200	{
		1201	{ GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, 0 },
		1202	{ PIPE_FORMAT_DXT1_SRGBA, 0 }
		1203	},
		1204	{
		1205	{ GL_COMPRESSED_SRGB_ALPHA_EXT,
		1206	GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, 0 },
		1207	{ PIPE_FORMAT_DXT3_SRGBA, DEFAULT_SRGBA_FORMATS }
		1208	},
		1209	{
		1210	{ GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, 0 },
		1211	{ PIPE_FORMAT_DXT5_SRGBA, 0 }
		1212	},
		1213	{
		1214	{ GL_SLUMINANCE_ALPHA_EXT, GL_SLUMINANCE8_ALPHA8_EXT,
		1215	GL_COMPRESSED_SLUMINANCE_ALPHA_EXT, 0 },
		1216	{ PIPE_FORMAT_L8A8_SRGB, DEFAULT_SRGBA_FORMATS }
		1217	},
		1218	{
		1219	{ GL_SLUMINANCE_EXT, GL_SLUMINANCE8_EXT, GL_COMPRESSED_SLUMINANCE_EXT,
		1220
		1221	{ PIPE_FORMAT_L8_SRGB, DEFAULT_SRGBA_FORMATS }
		1222	},
		1223
		1224	/* 16-bit float formats */
		1225	{
		1226	{ GL_RGBA16F_ARB, 0 },
		1227	{ PIPE_FORMAT_R16G16B16A16_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
		1228	},
		1229	{
		1230	{ GL_RGB16F_ARB, 0 },
		1231	{ PIPE_FORMAT_R16G16B16_FLOAT, PIPE_FORMAT_R16G16B16X16_FLOAT,
		1232	PIPE_FORMAT_R16G16B16A16_FLOAT,
		1233	PIPE_FORMAT_R32G32B32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
		1234	},
		1235	{
		1236	{ GL_LUMINANCE_ALPHA16F_ARB, 0 },
		1237	{ PIPE_FORMAT_L16A16_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT,
		1238	PIPE_FORMAT_L32A32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
		1239	},
		1240	{
		1241	{ GL_ALPHA16F_ARB, 0 },
		1242	{ PIPE_FORMAT_A16_FLOAT, PIPE_FORMAT_L16A16_FLOAT,
		1243	PIPE_FORMAT_A32_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT,
		1244	PIPE_FORMAT_L32A32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
		1245	},
		1246	{
		1247	{ GL_INTENSITY16F_ARB, 0 },
		1248	{ PIPE_FORMAT_I16_FLOAT, PIPE_FORMAT_L16A16_FLOAT,
		1249	PIPE_FORMAT_I32_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT,
		1250	PIPE_FORMAT_L32A32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
		1251	},
		1252	{
		1253	{ GL_LUMINANCE16F_ARB, 0 },
		1254	{ PIPE_FORMAT_L16_FLOAT, PIPE_FORMAT_L16A16_FLOAT,
		1255	PIPE_FORMAT_L32_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT,
		1256	PIPE_FORMAT_L32A32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
		1257	},
		1258	{
		1259	{ GL_R16F, 0 },
		1260	{ PIPE_FORMAT_R16_FLOAT, PIPE_FORMAT_R16G16_FLOAT,
		1261	PIPE_FORMAT_R32_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT,
		1262	PIPE_FORMAT_R32G32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
		1263	},
		1264	{
		1265	{ GL_RG16F, 0 },
		1266	{ PIPE_FORMAT_R16G16_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT,
		1267	PIPE_FORMAT_R32G32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
		1268	},
		1269
		1270	/* 32-bit float formats */
		1271	{
		1272	{ GL_RGBA32F_ARB, 0 },
		1273	{ PIPE_FORMAT_R32G32B32A32_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT, 0 }
		1274	},
		1275	{
		1276	{ GL_RGB32F_ARB, 0 },
		1277	{ PIPE_FORMAT_R32G32B32_FLOAT, PIPE_FORMAT_R32G32B32X32_FLOAT,
		1278	PIPE_FORMAT_R32G32B32A32_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT, 0 }
		1279	},
		1280	{
		1281	{ GL_LUMINANCE_ALPHA32F_ARB, 0 },
		1282	{ PIPE_FORMAT_L32A32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT,
		1283	PIPE_FORMAT_L16A16_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT, 0 }
		1284	},
		1285	{
		1286	{ GL_ALPHA32F_ARB, 0 },
		1287	{ PIPE_FORMAT_A32_FLOAT, PIPE_FORMAT_L32A32_FLOAT,
		1288	PIPE_FORMAT_R32G32B32A32_FLOAT, PIPE_FORMAT_A16_FLOAT,
		1289	PIPE_FORMAT_L16A16_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT, 0 }
		1290	},
		1291	{
		1292	{ GL_INTENSITY32F_ARB, 0 },
		1293	{ PIPE_FORMAT_I32_FLOAT, PIPE_FORMAT_L32A32_FLOAT,
		1294	PIPE_FORMAT_R32G32B32A32_FLOAT, PIPE_FORMAT_I16_FLOAT,
		1295	PIPE_FORMAT_L16A16_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT, 0 }
		1296	},
		1297	{
		1298	{ GL_LUMINANCE32F_ARB, 0 },
		1299	{ PIPE_FORMAT_L32_FLOAT, PIPE_FORMAT_L32A32_FLOAT,
		1300	PIPE_FORMAT_R32G32B32A32_FLOAT, PIPE_FORMAT_L16_FLOAT,
		1301	PIPE_FORMAT_L16A16_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT, 0 }
		1302	},
		1303	{
		1304	{ GL_R32F, 0 },
		1305	{ PIPE_FORMAT_R32_FLOAT, PIPE_FORMAT_R32G32_FLOAT,
		1306	PIPE_FORMAT_R32G32B32A32_FLOAT, PIPE_FORMAT_R16_FLOAT,
		1307	PIPE_FORMAT_R16G16_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT, 0 }
		1308	},
		1309	{
		1310	{ GL_RG32F, 0 },
		1311	{ PIPE_FORMAT_R32G32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT,
		1312	PIPE_FORMAT_R16G16_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT, 0 }
		1313	},
		1314
		1315	/* R, RG formats */
		1316	{
		1317	{ GL_RED, GL_R8, 0 },
		1318	{ PIPE_FORMAT_R8_UNORM, PIPE_FORMAT_R8G8_UNORM, DEFAULT_RGBA_FORMATS }
		1319	},
		1320	{
		1321	{ GL_RG, GL_RG8, 0 },
		1322	{ PIPE_FORMAT_R8G8_UNORM, DEFAULT_RGBA_FORMATS }
		1323	},
		1324	{
		1325	{ GL_R16, 0 },
		1326	{ PIPE_FORMAT_R16_UNORM, PIPE_FORMAT_R16G16_UNORM,
		1327	DEFAULT_UNORM16_RGBA_FORMATS }
		1328	},
		1329	{
		1330	{ GL_RG16, 0 },
		1331	{ PIPE_FORMAT_R16G16_UNORM, DEFAULT_UNORM16_RGBA_FORMATS }
		1332	},
		1333
		1334	/* compressed R, RG formats */
		1335	{
		1336	{ GL_COMPRESSED_RED, GL_COMPRESSED_RED_RGTC1, 0 },
		1337	{ PIPE_FORMAT_RGTC1_UNORM, PIPE_FORMAT_R8_UNORM, DEFAULT_RGBA_FORMATS }
		1338	},
		1339	{
		1340	{ GL_COMPRESSED_SIGNED_RED_RGTC1, 0 },
		1341	{ PIPE_FORMAT_RGTC1_SNORM, DEFAULT_SNORM8_RGBA_FORMATS }
		1342	},
		1343	{
		1344	{ GL_COMPRESSED_RG, GL_COMPRESSED_RG_RGTC2, 0 },
		1345	{ PIPE_FORMAT_RGTC2_UNORM, PIPE_FORMAT_R8G8_UNORM, DEFAULT_RGBA_FORMATS }
		1346	},
		1347	{
		1348	{ GL_COMPRESSED_SIGNED_RG_RGTC2, 0 },
		1349	{ PIPE_FORMAT_RGTC2_SNORM, DEFAULT_SNORM8_RGBA_FORMATS }
		1350	},
		1351	{
		1352	{ GL_COMPRESSED_LUMINANCE, GL_COMPRESSED_LUMINANCE_LATC1_EXT, 0 },
		1353	{ PIPE_FORMAT_LATC1_UNORM, PIPE_FORMAT_L8_UNORM, DEFAULT_RGBA_FORMATS }
		1354	},
		1355	{
		1356	{ GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT, 0 },
		1357	{ PIPE_FORMAT_LATC1_SNORM, DEFAULT_SNORM8_RGBA_FORMATS }
		1358	},
		1359	{
		1360	{ GL_COMPRESSED_LUMINANCE_ALPHA, GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT,
		1361	GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI, 0 },
		1362	{ PIPE_FORMAT_LATC2_UNORM, PIPE_FORMAT_L8A8_UNORM, DEFAULT_RGBA_FORMATS }
		1363	},
		1364	{
		1365	{ GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT, 0 },
		1366	{ PIPE_FORMAT_LATC2_SNORM, DEFAULT_SNORM8_RGBA_FORMATS }
		1367	},
		1368
		1369	/* ETC1 */
		1370	{
		1371	{ GL_ETC1_RGB8_OES, 0 },
		1372	{ PIPE_FORMAT_ETC1_RGB8, 0 }
		1373	},
		1374
		1375	/* BPTC */
		1376	{
		1377	{ GL_COMPRESSED_RGBA_BPTC_UNORM, 0 },
		1378	{ PIPE_FORMAT_BPTC_RGBA_UNORM, 0 },
		1379	},
		1380	{
		1381	{ GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM, 0 },
		1382	{ PIPE_FORMAT_BPTC_SRGBA, 0 },
		1383	},
		1384	{
		1385	{ GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT, 0 },
		1386	{ PIPE_FORMAT_BPTC_RGB_FLOAT, 0 },
		1387	},
		1388	{
		1389	{ GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT, 0 },
		1390	{ PIPE_FORMAT_BPTC_RGB_UFLOAT, 0 },
		1391	},
		1392
		1393	/* signed/unsigned integer formats.
		1394	*/
		1395	{
		1396	{ GL_RGBA_INTEGER_EXT,
		1397	GL_BGRA_INTEGER_EXT,
		1398	GL_RGBA8I_EXT, 0 },
		1399	{ PIPE_FORMAT_R8G8B8A8_SINT, 0 }
		1400	},
		1401	{
		1402	{ GL_RGB_INTEGER_EXT,
		1403	GL_BGR_INTEGER_EXT,
		1404	GL_RGB8I_EXT,
		1405	GL_BLUE_INTEGER_EXT, 0 },
		1406	{ PIPE_FORMAT_R8G8B8_SINT, PIPE_FORMAT_R8G8B8X8_SINT,
		1407	PIPE_FORMAT_R8G8B8A8_SINT, 0 }
		1408	},
		1409	{
		1410	{ GL_ALPHA_INTEGER_EXT,
		1411	GL_ALPHA8I_EXT, 0 },
		1412	{ PIPE_FORMAT_A8_SINT, 0 }
		1413	},
		1414	{
		1415	{ GL_ALPHA16I_EXT, 0 },
		1416	{ PIPE_FORMAT_A16_SINT, 0 }
		1417	},
		1418	{
		1419	{ GL_ALPHA32I_EXT, 0 },
		1420	{ PIPE_FORMAT_A32_SINT, 0 }
		1421	},
		1422	{
		1423	{ GL_ALPHA8UI_EXT, 0 },
		1424	{ PIPE_FORMAT_A8_UINT, 0 }
		1425	},
		1426	{
		1427	{ GL_ALPHA16UI_EXT, 0 },
		1428	{ PIPE_FORMAT_A16_UINT, 0 }
		1429	},
		1430	{
		1431	{ GL_ALPHA32UI_EXT, 0 },
		1432	{ PIPE_FORMAT_A32_UINT, 0 }
		1433	},
		1434	{
		1435	{ GL_INTENSITY8I_EXT, 0 },
		1436	{ PIPE_FORMAT_I8_SINT, 0 }
		1437	},
		1438	{
		1439	{ GL_INTENSITY16I_EXT, 0 },
		1440	{ PIPE_FORMAT_I16_SINT, 0 }
		1441	},
		1442	{
		1443	{ GL_INTENSITY32I_EXT, 0 },
		1444	{ PIPE_FORMAT_I32_SINT, 0 }
		1445	},
		1446	{
		1447	{ GL_INTENSITY8UI_EXT, 0 },
		1448	{ PIPE_FORMAT_I8_UINT, 0 }
		1449	},
		1450	{
		1451	{ GL_INTENSITY16UI_EXT, 0 },
		1452	{ PIPE_FORMAT_I16_UINT, 0 }
		1453	},
		1454	{
		1455	{ GL_INTENSITY32UI_EXT, 0 },
		1456	{ PIPE_FORMAT_I32_UINT, 0 }
		1457	},
		1458	{
		1459	{ GL_LUMINANCE8I_EXT, 0 },
		1460	{ PIPE_FORMAT_L8_SINT, 0 }
		1461	},
		1462	{
		1463	{ GL_LUMINANCE16I_EXT, 0 },
		1464	{ PIPE_FORMAT_L16_SINT, 0 }
		1465	},
		1466	{
		1467	{ GL_LUMINANCE32I_EXT, 0 },
		1468	{ PIPE_FORMAT_L32_SINT, 0 }
		1469	},
		1470	{
		1471	{ GL_LUMINANCE_INTEGER_EXT,
		1472	GL_LUMINANCE8UI_EXT, 0 },
		1473	{ PIPE_FORMAT_L8_UINT, 0 }
		1474	},
		1475	{
		1476	{ GL_LUMINANCE16UI_EXT, 0 },
		1477	{ PIPE_FORMAT_L16_UINT, 0 }
		1478	},
		1479	{
		1480	{ GL_LUMINANCE32UI_EXT, 0 },
		1481	{ PIPE_FORMAT_L32_UINT, 0 }
		1482	},
		1483	{
		1484	{ GL_LUMINANCE_ALPHA_INTEGER_EXT,
		1485	GL_LUMINANCE_ALPHA8I_EXT, 0 },
		1486	{ PIPE_FORMAT_L8A8_SINT, 0 }
		1487	},
		1488	{
		1489	{ GL_LUMINANCE_ALPHA16I_EXT, 0 },
		1490	{ PIPE_FORMAT_L16A16_SINT, 0 }
		1491	},
		1492	{
		1493	{ GL_LUMINANCE_ALPHA32I_EXT, 0 },
		1494	{ PIPE_FORMAT_L32A32_SINT, 0 }
		1495	},
		1496	{
		1497	{ GL_LUMINANCE_ALPHA8UI_EXT, 0 },
		1498	{ PIPE_FORMAT_L8A8_UINT, 0 }
		1499	},
		1500	{
		1501	{ GL_LUMINANCE_ALPHA16UI_EXT, 0 },
		1502	{ PIPE_FORMAT_L16A16_UINT, 0 }
		1503	},
		1504	{
		1505	{ GL_LUMINANCE_ALPHA32UI_EXT, 0 },
		1506	{ PIPE_FORMAT_L32A32_UINT, 0 }
		1507	},
		1508	{
		1509	{ GL_RGB16I_EXT, 0 },
		1510	{ PIPE_FORMAT_R16G16B16_SINT, PIPE_FORMAT_R16G16B16X16_SINT,
		1511	PIPE_FORMAT_R16G16B16A16_SINT, 0 },
		1512	},
		1513	{
		1514	{ GL_RGBA16I_EXT, 0 },
		1515	{ PIPE_FORMAT_R16G16B16A16_SINT, 0 },
		1516	},
		1517	{
		1518	{ GL_RGB32I_EXT, 0 },
		1519	{ PIPE_FORMAT_R32G32B32_SINT, PIPE_FORMAT_R32G32B32X32_SINT,
		1520	PIPE_FORMAT_R32G32B32A32_SINT, 0 },
		1521	},
		1522	{
		1523	{ GL_RGBA32I_EXT, 0 },
		1524	{ PIPE_FORMAT_R32G32B32A32_SINT, 0 }
		1525	},
		1526	{
		1527	{ GL_RGBA8UI_EXT, 0 },
		1528	{ PIPE_FORMAT_R8G8B8A8_UINT, 0 }
		1529	},
		1530	{
		1531	{ GL_RGB8UI_EXT, 0 },
		1532	{ PIPE_FORMAT_R8G8B8_UINT, PIPE_FORMAT_R8G8B8X8_UINT,
		1533	PIPE_FORMAT_R8G8B8A8_UINT, 0 }
		1534	},
		1535	{
		1536	{ GL_RGB16UI_EXT, 0 },
		1537	{ PIPE_FORMAT_R16G16B16_UINT, PIPE_FORMAT_R16G16B16X16_UINT,
		1538	PIPE_FORMAT_R16G16B16A16_UINT, 0 }
		1539	},
		1540	{
		1541	{ GL_RGBA16UI_EXT, 0 },
		1542	{ PIPE_FORMAT_R16G16B16A16_UINT, 0 }
		1543	},
		1544	{
		1545	{ GL_RGB32UI_EXT, 0},
		1546	{ PIPE_FORMAT_R32G32B32_UINT, PIPE_FORMAT_R32G32B32X32_UINT,
		1547	PIPE_FORMAT_R32G32B32A32_UINT, 0 }
		1548	},
		1549	{
		1550	{ GL_RGBA32UI_EXT, 0},
		1551	{ PIPE_FORMAT_R32G32B32A32_UINT, 0 }
		1552	},
		1553	{
		1554	{ GL_R8I, GL_RED_INTEGER_EXT, 0},
		1555	{ PIPE_FORMAT_R8_SINT, 0},
		1556	},
		1557	{
		1558	{ GL_R16I, 0},
		1559	{ PIPE_FORMAT_R16_SINT, 0},
		1560	},
		1561	{
		1562	{ GL_R32I, 0},
		1563	{ PIPE_FORMAT_R32_SINT, 0},
		1564	},
		1565	{
		1566	{ GL_R8UI, 0},
		1567	{ PIPE_FORMAT_R8_UINT, 0},
		1568	},
		1569	{
		1570	{ GL_R16UI, 0},
		1571	{ PIPE_FORMAT_R16_UINT, 0},
		1572	},
		1573	{
		1574	{ GL_R32UI, 0},
		1575	{ PIPE_FORMAT_R32_UINT, 0},
		1576	},
		1577	{
		1578	{ GL_RG8I, GL_GREEN_INTEGER_EXT, 0},
		1579	{ PIPE_FORMAT_R8G8_SINT, 0},
		1580	},
		1581	{
		1582	{ GL_RG16I, 0},
		1583	{ PIPE_FORMAT_R16G16_SINT, 0},
		1584	},
		1585	{
		1586	{ GL_RG32I, 0},
		1587	{ PIPE_FORMAT_R32G32_SINT, 0},
		1588	},
		1589	{
		1590	{ GL_RG8UI, 0},
		1591	{ PIPE_FORMAT_R8G8_UINT, 0},
		1592	},
		1593	{
		1594	{ GL_RG16UI, 0},
		1595	{ PIPE_FORMAT_R16G16_UINT, 0},
		1596	},
		1597	{
		1598	{ GL_RG32UI, 0},
		1599	{ PIPE_FORMAT_R32G32_UINT, 0},
		1600	},
		1601	/* signed normalized formats */
		1602	{
		1603	{ GL_RED_SNORM, GL_R8_SNORM, 0 },
		1604	{ PIPE_FORMAT_R8_SNORM, PIPE_FORMAT_R8G8_SNORM,
		1605	PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
		1606	},
		1607	{
		1608	{ GL_R16_SNORM, 0 },
		1609	{ PIPE_FORMAT_R16_SNORM,
		1610	PIPE_FORMAT_R16G16_SNORM,
		1611	PIPE_FORMAT_R16G16B16A16_SNORM,
		1612	PIPE_FORMAT_R8_SNORM,
		1613	PIPE_FORMAT_R8G8_SNORM,
		1614	PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
		1615	},
		1616	{
		1617	{ GL_RG_SNORM, GL_RG8_SNORM, 0 },
		1618	{ PIPE_FORMAT_R8G8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
		1619	},
		1620	{
		1621	{ GL_RG16_SNORM, 0 },
		1622	{ PIPE_FORMAT_R16G16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM,
		1623	PIPE_FORMAT_R8G8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
		1624	},
		1625	{
		1626	{ GL_RGB_SNORM, GL_RGB8_SNORM, 0 },
		1627	{ PIPE_FORMAT_R8G8B8X8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
		1628	},
		1629	{
		1630	{ GL_RGBA_SNORM, GL_RGBA8_SNORM, 0 },
		1631	{ PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
		1632	},
		1633	{
		1634	{ GL_RGB16_SNORM, 0 },
		1635	{ PIPE_FORMAT_R16G16B16X16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM,
		1636	PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
		1637	},
		1638	{
		1639	{ GL_RGBA16_SNORM, 0 },
		1640	{ PIPE_FORMAT_R16G16B16A16_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
		1641	},
		1642	{
		1643	{ GL_ALPHA_SNORM, GL_ALPHA8_SNORM, 0 },
		1644	{ PIPE_FORMAT_A8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
		1645	},
		1646	{
		1647	{ GL_ALPHA16_SNORM, 0 },
		1648	{ PIPE_FORMAT_A16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM,
		1649	PIPE_FORMAT_A8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
		1650	},
		1651	{
		1652	{ GL_LUMINANCE_SNORM, GL_LUMINANCE8_SNORM, 0 },
		1653	{ PIPE_FORMAT_L8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
		1654	},
		1655	{
		1656	{ GL_LUMINANCE16_SNORM, 0 },
		1657	{ PIPE_FORMAT_L16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM,
		1658	PIPE_FORMAT_L8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
		1659	},
		1660	{
		1661	{ GL_LUMINANCE_ALPHA_SNORM, GL_LUMINANCE8_ALPHA8_SNORM, 0 },
		1662	{ PIPE_FORMAT_L8A8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
		1663	},
		1664	{
		1665	{ GL_LUMINANCE16_ALPHA16_SNORM, 0 },
		1666	{ PIPE_FORMAT_L16A16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM,
		1667	PIPE_FORMAT_L8A8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
		1668	},
		1669	{
		1670	{ GL_INTENSITY_SNORM, GL_INTENSITY8_SNORM, 0 },
		1671	{ PIPE_FORMAT_I8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
		1672	},
		1673	{
		1674	{ GL_INTENSITY16_SNORM, 0 },
		1675	{ PIPE_FORMAT_I16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM,
		1676	PIPE_FORMAT_I8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
		1677	},
		1678	{
		1679	{ GL_RGB9_E5, 0 },
		1680	{ PIPE_FORMAT_R9G9B9E5_FLOAT, 0 }
		1681	},
		1682	{
		1683	{ GL_R11F_G11F_B10F, 0 },
		1684	{ PIPE_FORMAT_R11G11B10_FLOAT, 0 }
		1685	},
		1686	{
		1687	{ GL_RGB10_A2UI, 0 },
		1688	{ PIPE_FORMAT_R10G10B10A2_UINT, PIPE_FORMAT_B10G10R10A2_UINT, 0 }
		1689	},
		1690	};
		1691
		1692
		1693	/**
		1694	* Return first supported format from the given list.
		1695	* \param allow_dxt indicates whether it's OK to return a DXT format.
		1696	*/
		1697	static enum pipe_format
		1698	find_supported_format(struct pipe_screen *screen,
		1699	const enum pipe_format formats[],
		1700	enum pipe_texture_target target,
		1701	unsigned sample_count,
		1702	unsigned tex_usage,
		1703	boolean allow_dxt)
		1704	{
		1705	uint i;
		1706	for (i = 0; formats[i]; i++) {
		1707	if (screen->is_format_supported(screen, formats[i], target,
		1708	sample_count, tex_usage)) {
		1709	if (!allow_dxt && util_format_is_s3tc(formats[i])) {
		1710	/* we can't return a dxt format, continue searching */
		1711	continue;
		1712	}
		1713
		1714	return formats[i];
		1715	}
		1716	}
		1717	return PIPE_FORMAT_NONE;
		1718	}
		1719
		1720	struct exact_format_mapping
		1721	{
		1722	GLenum format;
		1723	GLenum type;
		1724	enum pipe_format pformat;
		1725	};
		1726
		1727	static const struct exact_format_mapping rgba8888_tbl[] =
		1728	{
		1729	{ GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, PIPE_FORMAT_ABGR8888_UNORM },
		1730	{ GL_ABGR_EXT, GL_UNSIGNED_INT_8_8_8_8_REV, PIPE_FORMAT_ABGR8888_UNORM },
		1731	{ GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, PIPE_FORMAT_RGBA8888_UNORM },
		1732	{ GL_ABGR_EXT, GL_UNSIGNED_INT_8_8_8_8, PIPE_FORMAT_RGBA8888_UNORM },
		1733	{ GL_BGRA, GL_UNSIGNED_INT_8_8_8_8, PIPE_FORMAT_ARGB8888_UNORM },
		1734	{ GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, PIPE_FORMAT_BGRA8888_UNORM },
		1735	{ GL_RGBA, GL_UNSIGNED_BYTE, PIPE_FORMAT_R8G8B8A8_UNORM },
		1736	{ GL_ABGR_EXT, GL_UNSIGNED_BYTE, PIPE_FORMAT_A8B8G8R8_UNORM },
		1737	{ GL_BGRA, GL_UNSIGNED_BYTE, PIPE_FORMAT_B8G8R8A8_UNORM },
		1738	{ 0, 0, 0 }
		1739	};
		1740
		1741	static const struct exact_format_mapping rgbx8888_tbl[] =
		1742	{
		1743	{ GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, PIPE_FORMAT_XBGR8888_UNORM },
		1744	{ GL_ABGR_EXT, GL_UNSIGNED_INT_8_8_8_8_REV, PIPE_FORMAT_XBGR8888_UNORM },
		1745	{ GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, PIPE_FORMAT_RGBX8888_UNORM },
		1746	{ GL_ABGR_EXT, GL_UNSIGNED_INT_8_8_8_8, PIPE_FORMAT_RGBX8888_UNORM },
		1747	{ GL_BGRA, GL_UNSIGNED_INT_8_8_8_8, PIPE_FORMAT_XRGB8888_UNORM },
		1748	{ GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, PIPE_FORMAT_BGRX8888_UNORM },
		1749	{ GL_RGBA, GL_UNSIGNED_BYTE, PIPE_FORMAT_R8G8B8X8_UNORM },
		1750	{ GL_ABGR_EXT, GL_UNSIGNED_BYTE, PIPE_FORMAT_X8B8G8R8_UNORM },
		1751	{ GL_BGRA, GL_UNSIGNED_BYTE, PIPE_FORMAT_B8G8R8X8_UNORM },
		1752	{ 0, 0, 0 }
		1753	};
		1754
		1755	static const struct exact_format_mapping rgba1010102_tbl[] =
		1756	{
		1757	{ GL_BGRA, GL_UNSIGNED_INT_2_10_10_10_REV, PIPE_FORMAT_B10G10R10A2_UNORM },
		1758	/* No Mesa formats for these Gallium formats:
		1759	{ GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV, PIPE_FORMAT_R10G10B10A2_UNORM },
		1760	{ GL_ABGR_EXT, GL_UNSIGNED_INT_10_10_10_2, PIPE_FORMAT_R10G10B10A2_UNORM },
		1761	{ GL_ABGR_EXT, GL_UNSIGNED_INT, PIPE_FORMAT_R10G10B10A2_UNORM },
		1762	*/
		1763	{ 0, 0, 0 }
		1764	};
		1765
		1766	/**
		1767	* If there is an exact pipe_format match for {internalFormat, format, type}
		1768	* return that, otherwise return PIPE_FORMAT_NONE so we can do fuzzy matching.
		1769	*/
		1770	static enum pipe_format
		1771	find_exact_format(GLint internalFormat, GLenum format, GLenum type)
		1772	{
		1773	uint i;
		1774	const struct exact_format_mapping* tbl;
		1775
		1776	if (format == GL_NONE \|\| type == GL_NONE)
		1777	return PIPE_FORMAT_NONE;
		1778
		1779	switch (internalFormat) {
		1780	case 4:
		1781	case GL_RGBA:
		1782	case GL_RGBA8:
		1783	tbl = rgba8888_tbl;
		1784	break;
		1785	case 3:
		1786	case GL_RGB:
		1787	case GL_RGB8:
		1788	tbl = rgbx8888_tbl;
		1789	break;
		1790	case GL_RGB10_A2:
		1791	tbl = rgba1010102_tbl;
		1792	break;
		1793	default:
		1794	return PIPE_FORMAT_NONE;
		1795	}
		1796
		1797	for (i = 0; tbl[i].format; i++)
		1798	if (tbl[i].format == format && tbl[i].type == type)
		1799	return tbl[i].pformat;
		1800
		1801	return PIPE_FORMAT_NONE;
		1802	}
		1803
		1804	/**
		1805	* Given an OpenGL internalFormat value for a texture or surface, return
		1806	* the best matching PIPE_FORMAT_x, or PIPE_FORMAT_NONE if there's no match.
		1807	* This is called during glTexImage2D, for example.
		1808	*
		1809	* The bindings parameter typically has PIPE_BIND_SAMPLER_VIEW set, plus
		1810	* either PIPE_BINDING_RENDER_TARGET or PIPE_BINDING_DEPTH_STENCIL if
		1811	* we want render-to-texture ability.
		1812	*
		1813	* \param internalFormat the user value passed to glTexImage2D
		1814	* \param target one of PIPE_TEXTURE_x
		1815	* \param bindings bitmask of PIPE_BIND_x flags.
		1816	* \param allow_dxt indicates whether it's OK to return a DXT format. This
		1817	* only matters when internalFormat names a generic or
		1818	* specific compressed format. And that should only happen
		1819	* when we're getting called from gl[Copy]TexImage().
		1820	*/
		1821	enum pipe_format
		1822	st_choose_format(struct st_context *st, GLenum internalFormat,
		1823	GLenum format, GLenum type,
		1824	enum pipe_texture_target target, unsigned sample_count,
		1825	unsigned bindings, boolean allow_dxt)
		1826	{
		1827	struct pipe_screen *screen = st->pipe->screen;
		1828	unsigned i;
		1829	int j;
		1830	enum pipe_format pf;
		1831
		1832	#ifdef DEBUG
		1833	{
		1834	static boolean firstCall = TRUE;
		1835	if (firstCall) {
		1836	test_format_conversion(st);
		1837	firstCall = FALSE;
		1838	}
		1839	}
		1840	#else
		1841	(void) test_format_conversion;
		1842	#endif
		1843
		1844	/* can't render to compressed formats at this time */
		1845	if (_mesa_is_compressed_format(st->ctx, internalFormat)
		1846	&& (bindings & ~PIPE_BIND_SAMPLER_VIEW)) {
		1847	return PIPE_FORMAT_NONE;
		1848	}
		1849
		1850	/* search for exact matches */
		1851	pf = find_exact_format(internalFormat, format, type);
		1852	if (pf != PIPE_FORMAT_NONE &&
		1853	screen->is_format_supported(screen, pf,
		1854	target, sample_count, bindings))
		1855	return pf;
		1856
		1857	/* search table for internalFormat */
		1858	for (i = 0; i < ARRAY_SIZE(format_map); i++) {
		1859	const struct format_mapping *mapping = &format_map[i];
		1860	for (j = 0; mapping->glFormats[j]; j++) {
		1861	if (mapping->glFormats[j] == internalFormat) {
		1862	/* Found the desired internal format. Find first pipe format
		1863	* which is supported by the driver.
		1864	*/
		1865	return find_supported_format(screen, mapping->pipeFormats,
		1866	target, sample_count, bindings,
		1867	allow_dxt);
		1868	}
		1869	}
		1870	}
		1871
		1872	_mesa_problem(NULL, "unhandled format!\n");
		1873	return PIPE_FORMAT_NONE;
		1874	}
		1875
		1876
		1877	/**
		1878	* Called by FBO code to choose a PIPE_FORMAT_ for drawing surfaces.
		1879	*/
		1880	enum pipe_format
		1881	st_choose_renderbuffer_format(struct st_context *st,
		1882	GLenum internalFormat, unsigned sample_count)
		1883	{
		1884	uint usage;
		1885	if (_mesa_is_depth_or_stencil_format(internalFormat))
		1886	usage = PIPE_BIND_DEPTH_STENCIL;
		1887	else
		1888	usage = PIPE_BIND_RENDER_TARGET;
		1889	return st_choose_format(st, internalFormat, GL_NONE, GL_NONE,
		1890	PIPE_TEXTURE_2D, sample_count, usage, FALSE);
		1891	}
		1892
		1893
		1894	/**
		1895	* Given an OpenGL user-requested format and type, and swapBytes state,
		1896	* return the format which exactly matches those parameters, so that
		1897	* a memcpy-based transfer can be done.
		1898	*
		1899	* If no format is supported, return PIPE_FORMAT_NONE.
		1900	*/
		1901	enum pipe_format
		1902	st_choose_matching_format(struct st_context *st, unsigned bind,
		1903	GLenum format, GLenum type, GLboolean swapBytes)
		1904	{
		1905	struct pipe_screen *screen = st->pipe->screen;
		1906	mesa_format mesa_format;
		1907
		1908	for (mesa_format = 1; mesa_format < MESA_FORMAT_COUNT; mesa_format++) {
		1909	if (_mesa_get_format_color_encoding(mesa_format) == GL_SRGB) {
		1910	continue;
		1911	}
		1912	if (_mesa_get_format_bits(mesa_format, GL_TEXTURE_INTENSITY_SIZE) > 0) {
		1913	/* If `format` is GL_RED/GL_RED_INTEGER, then we might match some
		1914	* intensity formats, which we don't want.
		1915	*/
		1916	continue;
		1917	}
		1918
		1919	if (_mesa_format_matches_format_and_type(mesa_format, format, type,
		1920	swapBytes)) {
		1921	enum pipe_format format =
		1922	st_mesa_format_to_pipe_format(st, mesa_format);
		1923
		1924	if (format &&
		1925	screen->is_format_supported(screen, format, PIPE_TEXTURE_2D, 0,
		1926	bind)) {
		1927	return format;
		1928	}
		1929	/* It's unlikely to find 2 matching Mesa formats. */
		1930	break;
		1931	}
		1932	}
		1933	return PIPE_FORMAT_NONE;
		1934	}
		1935
		1936
		1937	/**
		1938	* Called via ctx->Driver.ChooseTextureFormat().
		1939	*/
		1940	mesa_format
		1941	st_ChooseTextureFormat(struct gl_context *ctx, GLenum target,
		1942	GLint internalFormat,
		1943	GLenum format, GLenum type)
		1944	{
		1945	struct st_context *st = st_context(ctx);
		1946	enum pipe_format pFormat;
		1947	unsigned bindings;
		1948	enum pipe_texture_target pTarget = gl_target_to_pipe(target);
		1949
		1950	if (target == GL_TEXTURE_1D \|\| target == GL_TEXTURE_1D_ARRAY) {
		1951	/* We don't do compression for these texture targets because of
		1952	* difficulty with sub-texture updates on non-block boundaries, etc.
		1953	* So change the internal format request to an uncompressed format.
		1954	*/
		1955	internalFormat =
		1956	_mesa_generic_compressed_format_to_uncompressed_format(internalFormat);
		1957	}
		1958
		1959	/* GL textures may wind up being render targets, but we don't know
		1960	* that in advance. Specify potential render target flags now for formats
		1961	* that we know should always be renderable.
		1962	*/
		1963	bindings = PIPE_BIND_SAMPLER_VIEW;
		1964	if (_mesa_is_depth_or_stencil_format(internalFormat))
		1965	bindings \|= PIPE_BIND_DEPTH_STENCIL;
		1966	else if (internalFormat == 3 \|\| internalFormat == 4 \|\|
		1967	internalFormat == GL_RGB \|\| internalFormat == GL_RGBA \|\|
		1968	internalFormat == GL_RGB8 \|\| internalFormat == GL_RGBA8 \|\|
		1969	internalFormat == GL_BGRA)
		1970	bindings \|= PIPE_BIND_RENDER_TARGET;
		1971
		1972	/* GLES allows the driver to choose any format which matches
		1973	* the format+type combo, because GLES only supports unsized internal
		1974	* formats and expects the driver to choose whatever suits it.
		1975	*/
		1976	if (_mesa_is_gles(ctx)) {
		1977	GLenum baseFormat = _mesa_base_tex_format(ctx, internalFormat);
		1978	GLenum basePackFormat = _mesa_base_pack_format(format);
		1979	GLenum iformat = internalFormat;
		1980
		1981	/* Treat GL_BGRA as GL_RGBA. */
		1982	if (iformat == GL_BGRA)
		1983	iformat = GL_RGBA;
		1984
		1985	/* Check if the internalformat is unsized and compatible
		1986	* with the "format".
		1987	*/
		1988	if (iformat == baseFormat && iformat == basePackFormat) {
		1989	pFormat = st_choose_matching_format(st, bindings, format, type,
		1990	ctx->Unpack.SwapBytes);
		1991
		1992	if (pFormat != PIPE_FORMAT_NONE)
		1993	return st_pipe_format_to_mesa_format(pFormat);
		1994
		1995	/* try choosing format again, this time without render target bindings */
		1996	pFormat = st_choose_matching_format(st, PIPE_BIND_SAMPLER_VIEW,
		1997	format, type,
		1998	ctx->Unpack.SwapBytes);
		1999	if (pFormat != PIPE_FORMAT_NONE)
		2000	return st_pipe_format_to_mesa_format(pFormat);
		2001	}
		2002	}
		2003
		2004	pFormat = st_choose_format(st, internalFormat, format, type,
		2005	pTarget, 0, bindings, ctx->Mesa_DXTn);
		2006
		2007	if (pFormat == PIPE_FORMAT_NONE) {
		2008	/* try choosing format again, this time without render target bindings */
		2009	pFormat = st_choose_format(st, internalFormat, format, type,
		2010	pTarget, 0, PIPE_BIND_SAMPLER_VIEW,
		2011	ctx->Mesa_DXTn);
		2012	}
		2013
		2014	if (pFormat == PIPE_FORMAT_NONE) {
		2015	/* no luck at all */
		2016	return MESA_FORMAT_NONE;
		2017	}
		2018
		2019	return st_pipe_format_to_mesa_format(pFormat);
		2020	}
		2021
		2022
		2023	/**
		2024	* Called via ctx->Driver.ChooseTextureFormat().
		2025	*/
		2026	size_t
		2027	st_QuerySamplesForFormat(struct gl_context *ctx, GLenum target,
		2028	GLenum internalFormat, int samples[16])
		2029	{
		2030	struct st_context *st = st_context(ctx);
		2031	enum pipe_format format;
		2032	unsigned i, bind, num_sample_counts = 0;
		2033
		2034	(void) target;
		2035
		2036	if (_mesa_is_depth_or_stencil_format(internalFormat))
		2037	bind = PIPE_BIND_DEPTH_STENCIL;
		2038	else
		2039	bind = PIPE_BIND_RENDER_TARGET;
		2040
		2041	/* If an sRGB framebuffer is unsupported, sRGB formats behave like linear
		2042	* formats.
		2043	*/
		2044	if (!ctx->Extensions.EXT_framebuffer_sRGB) {
		2045	internalFormat = _mesa_get_linear_internalformat(internalFormat);
		2046	}
		2047
		2048	/* Set sample counts in descending order. */
		2049	for (i = 16; i > 1; i--) {
		2050	format = st_choose_format(st, internalFormat, GL_NONE, GL_NONE,
		2051	PIPE_TEXTURE_2D, i, bind, FALSE);
		2052
		2053	if (format != PIPE_FORMAT_NONE) {
		2054	samples[num_sample_counts++] = i;
		2055	}
		2056	}
		2057
		2058	if (!num_sample_counts) {
		2059	samples[num_sample_counts++] = 1;
		2060	}
		2061
		2062	return num_sample_counts;
		2063	}
		2064
		2065
		2066	/**
		2067	* This is used for translating texture border color and the clear
		2068	* color. For example, the clear color is interpreted according to
		2069	* the renderbuffer's base format. For example, if clearing a
		2070	* GL_LUMINANCE buffer, we'll return colorOut[0] = colorOut[1] =
		2071	* colorOut[2] = colorIn[0].
		2072	* Similarly for texture border colors.
		2073	*/
		2074	void
		2075	st_translate_color(const union gl_color_union *colorIn,
		2076	union pipe_color_union *colorOut,
		2077	GLenum baseFormat, GLboolean is_integer)
		2078	{
		2079	if (is_integer) {
		2080	const int *in = colorIn->i;
		2081	int *out = colorOut->i;
		2082
		2083	switch (baseFormat) {
		2084	case GL_RED:
		2085	out[0] = in[0];
		2086	out[1] = 0;
		2087	out[2] = 0;
		2088	out[3] = 1;
		2089	break;
		2090	case GL_RG:
		2091	out[0] = in[0];
		2092	out[1] = in[1];
		2093	out[2] = 0;
		2094	out[3] = 1;
		2095	break;
		2096	case GL_RGB:
		2097	out[0] = in[0];
		2098	out[1] = in[1];
		2099	out[2] = in[2];
		2100	out[3] = 1;
		2101	break;
		2102	case GL_ALPHA:
		2103	out[0] = out[1] = out[2] = 0;
		2104	out[3] = in[3];
		2105	break;
		2106	case GL_LUMINANCE:
		2107	out[0] = out[1] = out[2] = in[0];
		2108	out[3] = 1;
		2109	break;
		2110	case GL_LUMINANCE_ALPHA:
		2111	out[0] = out[1] = out[2] = in[0];
		2112	out[3] = in[3];
		2113	break;
		2114	case GL_INTENSITY:
		2115	out[0] = out[1] = out[2] = out[3] = in[0];
		2116	break;
		2117	default:
		2118	COPY_4V(out, in);
		2119	}
		2120	}
		2121	else {
		2122	const float *in = colorIn->f;
		2123	float *out = colorOut->f;
		2124
		2125	switch (baseFormat) {
		2126	case GL_RED:
		2127	out[0] = in[0];
		2128	out[1] = 0.0F;
		2129	out[2] = 0.0F;
		2130	out[3] = 1.0F;
		2131	break;
		2132	case GL_RG:
		2133	out[0] = in[0];
		2134	out[1] = in[1];
		2135	out[2] = 0.0F;
		2136	out[3] = 1.0F;
		2137	break;
		2138	case GL_RGB:
		2139	out[0] = in[0];
		2140	out[1] = in[1];
		2141	out[2] = in[2];
		2142	out[3] = 1.0F;
		2143	break;
		2144	case GL_ALPHA:
		2145	out[0] = out[1] = out[2] = 0.0F;
		2146	out[3] = in[3];
		2147	break;
		2148	case GL_LUMINANCE:
		2149	out[0] = out[1] = out[2] = in[0];
		2150	out[3] = 1.0F;
		2151	break;
		2152	case GL_LUMINANCE_ALPHA:
		2153	out[0] = out[1] = out[2] = in[0];
		2154	out[3] = in[3];
		2155	break;
		2156	case GL_INTENSITY:
		2157	out[0] = out[1] = out[2] = out[3] = in[0];
		2158	break;
		2159	default:
		2160	COPY_4V(out, in);
		2161	}
		2162	}
		2163	}

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/Mesa/mesa-10.6.0/src/mesa/state_tracker/st_format.c – Rev 5568