WebSVN – Kolibri OS – Blame – /contrib/sdk/sources/Mesa/mesa-10.6.0/src/gallium/auxiliary/translate/translate_generic.c

Rev	Author	Line No.	Line
5564	serge	1	/**************************************************************************
		2	*
		3	* Copyright 2007 VMware, Inc.
		4	* All Rights Reserved.
		5	*
		6	* Permission is hereby granted, free of charge, to any person obtaining a
		7	* copy of this software and associated documentation files (the
		8	* "Software"), to deal in the Software without restriction, including
		9	* without limitation the rights to use, copy, modify, merge, publish,
		10	* distribute, sub license, and/or sell copies of the Software, and to
		11	* permit persons to whom the Software is furnished to do so, subject to
		12	* the following conditions:
		13	*
		14	* The above copyright notice and this permission notice (including the
		15	* next paragraph) shall be included in all copies or substantial portions
		16	* of the Software.
		17	*
		18	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
		19	* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
		20	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
		21	* IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
		22	* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
		23	* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
		24	* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
		25	*
		26	**************************************************************************/
		27
		28	/*
		29	* Authors:
		30	* Keith Whitwell
		31	*/
		32
		33	#include "util/u_memory.h"
		34	#include "util/u_format.h"
		35	#include "util/u_half.h"
		36	#include "util/u_math.h"
		37	#include "pipe/p_state.h"
		38	#include "translate.h"
		39
		40
		41	#define DRAW_DBG 0
		42
		43	typedef void (fetch_func)(void dst,
		44	const uint8_t *src,
		45	unsigned i, unsigned j);
		46	typedef void (emit_func)(const void attrib, void *ptr);
		47
		48
		49
		50	struct translate_generic {
		51	struct translate translate;
		52
		53	struct {
		54	enum translate_element_type type;
		55
		56	fetch_func fetch;
		57	unsigned buffer;
		58	unsigned input_offset;
		59	unsigned instance_divisor;
		60
		61	emit_func emit;
		62	unsigned output_offset;
		63
		64	const uint8_t *input_ptr;
		65	unsigned input_stride;
		66	unsigned max_index;
		67
		68	/* this value is set to -1 if this is a normal element with output_format != input_format:
		69	* in this case, u_format is used to do a full conversion
		70	*
		71	* this value is set to the format size in bytes if output_format == input_format or for 32-bit instance ids:
		72	* in this case, memcpy is used to copy this amount of bytes
		73	*/
		74	int copy_size;
		75
		76	} attrib[TRANSLATE_MAX_ATTRIBS];
		77
		78	unsigned nr_attrib;
		79	};
		80
		81
		82	static struct translate_generic translate_generic( struct translate translate )
		83	{
		84	return (struct translate_generic *)translate;
		85	}
		86
		87	/**
		88	* Fetch a dword[4] vertex attribute from memory, doing format/type
		89	* conversion as needed.
		90	*
		91	* This is probably needed/dupliocated elsewhere, eg format
		92	* conversion, texture sampling etc.
		93	*/
		94	#define ATTRIB( NAME, SZ, SRCTYPE, DSTTYPE, TO ) \
		95	static void \
		96	emit_##NAME(const void attrib, void ptr) \
		97	{ \
		98	unsigned i; \
		99	SRCTYPE in = (SRCTYPE )attrib; \
		100	DSTTYPE out = (DSTTYPE )ptr; \
		101	\
		102	for (i = 0; i < SZ; i++) { \
		103	out[i] = TO(in[i]); \
		104	} \
		105	}
		106
		107
		108	#define TO_64_FLOAT(x) ((double) x)
		109	#define TO_32_FLOAT(x) (x)
		110	#define TO_16_FLOAT(x) util_float_to_half(x)
		111
		112	#define TO_8_USCALED(x) ((unsigned char) x)
		113	#define TO_16_USCALED(x) ((unsigned short) x)
		114	#define TO_32_USCALED(x) ((unsigned int) x)
		115
		116	#define TO_8_SSCALED(x) ((char) x)
		117	#define TO_16_SSCALED(x) ((short) x)
		118	#define TO_32_SSCALED(x) ((int) x)
		119
		120	#define TO_8_UNORM(x) ((unsigned char) (x * 255.0f))
		121	#define TO_16_UNORM(x) ((unsigned short) (x * 65535.0f))
		122	#define TO_32_UNORM(x) ((unsigned int) (x * 4294967295.0f))
		123
		124	#define TO_8_SNORM(x) ((char) (x * 127.0f))
		125	#define TO_16_SNORM(x) ((short) (x * 32767.0f))
		126	#define TO_32_SNORM(x) ((int) (x * 2147483647.0f))
		127
		128	#define TO_32_FIXED(x) ((int) (x * 65536.0f))
		129
		130	#define TO_INT(x) (x)
		131
		132
		133	ATTRIB( R64G64B64A64_FLOAT, 4, float, double, TO_64_FLOAT )
		134	ATTRIB( R64G64B64_FLOAT, 3, float, double, TO_64_FLOAT )
		135	ATTRIB( R64G64_FLOAT, 2, float, double, TO_64_FLOAT )
		136	ATTRIB( R64_FLOAT, 1, float, double, TO_64_FLOAT )
		137
		138	ATTRIB( R32G32B32A32_FLOAT, 4, float, float, TO_32_FLOAT )
		139	ATTRIB( R32G32B32_FLOAT, 3, float, float, TO_32_FLOAT )
		140	ATTRIB( R32G32_FLOAT, 2, float, float, TO_32_FLOAT )
		141	ATTRIB( R32_FLOAT, 1, float, float, TO_32_FLOAT )
		142
		143	ATTRIB( R16G16B16A16_FLOAT, 4, float, ushort, TO_16_FLOAT )
		144	ATTRIB( R16G16B16_FLOAT, 3, float, ushort, TO_16_FLOAT )
		145	ATTRIB( R16G16_FLOAT, 2, float, ushort, TO_16_FLOAT )
		146	ATTRIB( R16_FLOAT, 1, float, ushort, TO_16_FLOAT )
		147
		148	ATTRIB( R32G32B32A32_USCALED, 4, float, unsigned, TO_32_USCALED )
		149	ATTRIB( R32G32B32_USCALED, 3, float, unsigned, TO_32_USCALED )
		150	ATTRIB( R32G32_USCALED, 2, float, unsigned, TO_32_USCALED )
		151	ATTRIB( R32_USCALED, 1, float, unsigned, TO_32_USCALED )
		152
		153	ATTRIB( R32G32B32A32_SSCALED, 4, float, int, TO_32_SSCALED )
		154	ATTRIB( R32G32B32_SSCALED, 3, float, int, TO_32_SSCALED )
		155	ATTRIB( R32G32_SSCALED, 2, float, int, TO_32_SSCALED )
		156	ATTRIB( R32_SSCALED, 1, float, int, TO_32_SSCALED )
		157
		158	ATTRIB( R32G32B32A32_UNORM, 4, float, unsigned, TO_32_UNORM )
		159	ATTRIB( R32G32B32_UNORM, 3, float, unsigned, TO_32_UNORM )
		160	ATTRIB( R32G32_UNORM, 2, float, unsigned, TO_32_UNORM )
		161	ATTRIB( R32_UNORM, 1, float, unsigned, TO_32_UNORM )
		162
		163	ATTRIB( R32G32B32A32_SNORM, 4, float, int, TO_32_SNORM )
		164	ATTRIB( R32G32B32_SNORM, 3, float, int, TO_32_SNORM )
		165	ATTRIB( R32G32_SNORM, 2, float, int, TO_32_SNORM )
		166	ATTRIB( R32_SNORM, 1, float, int, TO_32_SNORM )
		167
		168	ATTRIB( R16G16B16A16_USCALED, 4, float, ushort, TO_16_USCALED )
		169	ATTRIB( R16G16B16_USCALED, 3, float, ushort, TO_16_USCALED )
		170	ATTRIB( R16G16_USCALED, 2, float, ushort, TO_16_USCALED )
		171	ATTRIB( R16_USCALED, 1, float, ushort, TO_16_USCALED )
		172
		173	ATTRIB( R16G16B16A16_SSCALED, 4, float, short, TO_16_SSCALED )
		174	ATTRIB( R16G16B16_SSCALED, 3, float, short, TO_16_SSCALED )
		175	ATTRIB( R16G16_SSCALED, 2, float, short, TO_16_SSCALED )
		176	ATTRIB( R16_SSCALED, 1, float, short, TO_16_SSCALED )
		177
		178	ATTRIB( R16G16B16A16_UNORM, 4, float, ushort, TO_16_UNORM )
		179	ATTRIB( R16G16B16_UNORM, 3, float, ushort, TO_16_UNORM )
		180	ATTRIB( R16G16_UNORM, 2, float, ushort, TO_16_UNORM )
		181	ATTRIB( R16_UNORM, 1, float, ushort, TO_16_UNORM )
		182
		183	ATTRIB( R16G16B16A16_SNORM, 4, float, short, TO_16_SNORM )
		184	ATTRIB( R16G16B16_SNORM, 3, float, short, TO_16_SNORM )
		185	ATTRIB( R16G16_SNORM, 2, float, short, TO_16_SNORM )
		186	ATTRIB( R16_SNORM, 1, float, short, TO_16_SNORM )
		187
		188	ATTRIB( R8G8B8A8_USCALED, 4, float, ubyte, TO_8_USCALED )
		189	ATTRIB( R8G8B8_USCALED, 3, float, ubyte, TO_8_USCALED )
		190	ATTRIB( R8G8_USCALED, 2, float, ubyte, TO_8_USCALED )
		191	ATTRIB( R8_USCALED, 1, float, ubyte, TO_8_USCALED )
		192
		193	ATTRIB( R8G8B8A8_SSCALED, 4, float, char, TO_8_SSCALED )
		194	ATTRIB( R8G8B8_SSCALED, 3, float, char, TO_8_SSCALED )
		195	ATTRIB( R8G8_SSCALED, 2, float, char, TO_8_SSCALED )
		196	ATTRIB( R8_SSCALED, 1, float, char, TO_8_SSCALED )
		197
		198	ATTRIB( R8G8B8A8_UNORM, 4, float, ubyte, TO_8_UNORM )
		199	ATTRIB( R8G8B8_UNORM, 3, float, ubyte, TO_8_UNORM )
		200	ATTRIB( R8G8_UNORM, 2, float, ubyte, TO_8_UNORM )
		201	ATTRIB( R8_UNORM, 1, float, ubyte, TO_8_UNORM )
		202
		203	ATTRIB( R8G8B8A8_SNORM, 4, float, char, TO_8_SNORM )
		204	ATTRIB( R8G8B8_SNORM, 3, float, char, TO_8_SNORM )
		205	ATTRIB( R8G8_SNORM, 2, float, char, TO_8_SNORM )
		206	ATTRIB( R8_SNORM, 1, float, char, TO_8_SNORM )
		207
		208	ATTRIB( R32G32B32A32_UINT, 4, uint32_t, unsigned, TO_INT )
		209	ATTRIB( R32G32B32_UINT, 3, uint32_t, unsigned, TO_INT )
		210	ATTRIB( R32G32_UINT, 2, uint32_t, unsigned, TO_INT )
		211	ATTRIB( R32_UINT, 1, uint32_t, unsigned, TO_INT )
		212
		213	ATTRIB( R16G16B16A16_UINT, 4, uint32_t, ushort, TO_INT )
		214	ATTRIB( R16G16B16_UINT, 3, uint32_t, ushort, TO_INT )
		215	ATTRIB( R16G16_UINT, 2, uint32_t, ushort, TO_INT )
		216	ATTRIB( R16_UINT, 1, uint32_t, ushort, TO_INT )
		217
		218	ATTRIB( R8G8B8A8_UINT, 4, uint32_t, ubyte, TO_INT )
		219	ATTRIB( R8G8B8_UINT, 3, uint32_t, ubyte, TO_INT )
		220	ATTRIB( R8G8_UINT, 2, uint32_t, ubyte, TO_INT )
		221	ATTRIB( R8_UINT, 1, uint32_t, ubyte, TO_INT )
		222
		223	ATTRIB( R32G32B32A32_SINT, 4, int32_t, int, TO_INT )
		224	ATTRIB( R32G32B32_SINT, 3, int32_t, int, TO_INT )
		225	ATTRIB( R32G32_SINT, 2, int32_t, int, TO_INT )
		226	ATTRIB( R32_SINT, 1, int32_t, int, TO_INT )
		227
		228	ATTRIB( R16G16B16A16_SINT, 4, int32_t, short, TO_INT )
		229	ATTRIB( R16G16B16_SINT, 3, int32_t, short, TO_INT )
		230	ATTRIB( R16G16_SINT, 2, int32_t, short, TO_INT )
		231	ATTRIB( R16_SINT, 1, int32_t, short, TO_INT )
		232
		233	ATTRIB( R8G8B8A8_SINT, 4, int32_t, char, TO_INT )
		234	ATTRIB( R8G8B8_SINT, 3, int32_t, char, TO_INT )
		235	ATTRIB( R8G8_SINT, 2, int32_t, char, TO_INT )
		236	ATTRIB( R8_SINT, 1, int32_t, char, TO_INT )
		237
		238	static void
		239	emit_A8R8G8B8_UNORM( const void attrib, void ptr)
		240	{
		241	float in = (float )attrib;
		242	ubyte out = (ubyte )ptr;
		243	out[0] = TO_8_UNORM(in[3]);
		244	out[1] = TO_8_UNORM(in[0]);
		245	out[2] = TO_8_UNORM(in[1]);
		246	out[3] = TO_8_UNORM(in[2]);
		247	}
		248
		249	static void
		250	emit_B8G8R8A8_UNORM( const void attrib, void ptr)
		251	{
		252	float in = (float )attrib;
		253	ubyte out = (ubyte )ptr;
		254	out[2] = TO_8_UNORM(in[0]);
		255	out[1] = TO_8_UNORM(in[1]);
		256	out[0] = TO_8_UNORM(in[2]);
		257	out[3] = TO_8_UNORM(in[3]);
		258	}
		259
		260	static void
		261	emit_B10G10R10A2_UNORM( const void attrib, void ptr )
		262	{
		263	float src = (float )ptr;
		264	uint32_t value = 0;
		265	value \|= ((uint32_t)(CLAMP(src[2], 0, 1) * 0x3ff)) & 0x3ff;
		266	value \|= (((uint32_t)(CLAMP(src[1], 0, 1) * 0x3ff)) & 0x3ff) << 10;
		267	value \|= (((uint32_t)(CLAMP(src[0], 0, 1) * 0x3ff)) & 0x3ff) << 20;
		268	value \|= ((uint32_t)(CLAMP(src[3], 0, 1) * 0x3)) << 30;
		269	(uint32_t )attrib = util_le32_to_cpu(value);
		270	}
		271
		272	static void
		273	emit_B10G10R10A2_USCALED( const void attrib, void ptr )
		274	{
		275	float src = (float )ptr;
		276	uint32_t value = 0;
		277	value \|= ((uint32_t)CLAMP(src[2], 0, 1023)) & 0x3ff;
		278	value \|= (((uint32_t)CLAMP(src[1], 0, 1023)) & 0x3ff) << 10;
		279	value \|= (((uint32_t)CLAMP(src[0], 0, 1023)) & 0x3ff) << 20;
		280	value \|= ((uint32_t)CLAMP(src[3], 0, 3)) << 30;
		281	(uint32_t )attrib = util_le32_to_cpu(value);
		282	}
		283
		284	static void
		285	emit_B10G10R10A2_SNORM( const void attrib, void ptr )
		286	{
		287	float src = (float )ptr;
		288	uint32_t value = 0;
		289	value \|= (uint32_t)(((uint32_t)(CLAMP(src[2], -1, 1) * 0x1ff)) & 0x3ff) ;
		290	value \|= (uint32_t)((((uint32_t)(CLAMP(src[1], -1, 1) * 0x1ff)) & 0x3ff) << 10) ;
		291	value \|= (uint32_t)((((uint32_t)(CLAMP(src[0], -1, 1) * 0x1ff)) & 0x3ff) << 20) ;
		292	value \|= (uint32_t)(((uint32_t)(CLAMP(src[3], -1, 1) * 0x1)) << 30) ;
		293	(uint32_t )attrib = util_le32_to_cpu(value);
		294	}
		295
		296	static void
		297	emit_B10G10R10A2_SSCALED( const void attrib, void ptr )
		298	{
		299	float src = (float )ptr;
		300	uint32_t value = 0;
		301	value \|= (uint32_t)(((uint32_t)CLAMP(src[2], -512, 511)) & 0x3ff) ;
		302	value \|= (uint32_t)((((uint32_t)CLAMP(src[1], -512, 511)) & 0x3ff) << 10) ;
		303	value \|= (uint32_t)((((uint32_t)CLAMP(src[0], -512, 511)) & 0x3ff) << 20) ;
		304	value \|= (uint32_t)(((uint32_t)CLAMP(src[3], -2, 1)) << 30) ;
		305	(uint32_t )attrib = util_le32_to_cpu(value);
		306	}
		307
		308	static void
		309	emit_R10G10B10A2_UNORM( const void attrib, void ptr )
		310	{
		311	float src = (float )ptr;
		312	uint32_t value = 0;
		313	value \|= ((uint32_t)(CLAMP(src[0], 0, 1) * 0x3ff)) & 0x3ff;
		314	value \|= (((uint32_t)(CLAMP(src[1], 0, 1) * 0x3ff)) & 0x3ff) << 10;
		315	value \|= (((uint32_t)(CLAMP(src[2], 0, 1) * 0x3ff)) & 0x3ff) << 20;
		316	value \|= ((uint32_t)(CLAMP(src[3], 0, 1) * 0x3)) << 30;
		317	(uint32_t )attrib = util_le32_to_cpu(value);
		318	}
		319
		320	static void
		321	emit_R10G10B10A2_USCALED( const void attrib, void ptr )
		322	{
		323	float src = (float )ptr;
		324	uint32_t value = 0;
		325	value \|= ((uint32_t)CLAMP(src[0], 0, 1023)) & 0x3ff;
		326	value \|= (((uint32_t)CLAMP(src[1], 0, 1023)) & 0x3ff) << 10;
		327	value \|= (((uint32_t)CLAMP(src[2], 0, 1023)) & 0x3ff) << 20;
		328	value \|= ((uint32_t)CLAMP(src[3], 0, 3)) << 30;
		329	(uint32_t )attrib = util_le32_to_cpu(value);
		330	}
		331
		332	static void
		333	emit_R10G10B10A2_SNORM( const void attrib, void ptr )
		334	{
		335	float src = (float )ptr;
		336	uint32_t value = 0;
		337	value \|= (uint32_t)(((uint32_t)(CLAMP(src[0], -1, 1) * 0x1ff)) & 0x3ff) ;
		338	value \|= (uint32_t)((((uint32_t)(CLAMP(src[1], -1, 1) * 0x1ff)) & 0x3ff) << 10) ;
		339	value \|= (uint32_t)((((uint32_t)(CLAMP(src[2], -1, 1) * 0x1ff)) & 0x3ff) << 20) ;
		340	value \|= (uint32_t)(((uint32_t)(CLAMP(src[3], -1, 1) * 0x1)) << 30) ;
		341	(uint32_t )attrib = util_le32_to_cpu(value);
		342	}
		343
		344	static void
		345	emit_R10G10B10A2_SSCALED( const void attrib, void ptr)
		346	{
		347	float src = (float )ptr;
		348	uint32_t value = 0;
		349	value \|= (uint32_t)(((uint32_t)CLAMP(src[0], -512, 511)) & 0x3ff) ;
		350	value \|= (uint32_t)((((uint32_t)CLAMP(src[1], -512, 511)) & 0x3ff) << 10) ;
		351	value \|= (uint32_t)((((uint32_t)CLAMP(src[2], -512, 511)) & 0x3ff) << 20) ;
		352	value \|= (uint32_t)(((uint32_t)CLAMP(src[3], -2, 1)) << 30) ;
		353	(uint32_t )attrib = util_le32_to_cpu(value);
		354	}
		355
		356	static void
		357	emit_NULL( const void attrib, void ptr )
		358	{
		359	/* do nothing is the only sensible option */
		360	}
		361
		362	static emit_func get_emit_func( enum pipe_format format )
		363	{
		364	switch (format) {
		365	case PIPE_FORMAT_R64_FLOAT:
		366	return &emit_R64_FLOAT;
		367	case PIPE_FORMAT_R64G64_FLOAT:
		368	return &emit_R64G64_FLOAT;
		369	case PIPE_FORMAT_R64G64B64_FLOAT:
		370	return &emit_R64G64B64_FLOAT;
		371	case PIPE_FORMAT_R64G64B64A64_FLOAT:
		372	return &emit_R64G64B64A64_FLOAT;
		373
		374	case PIPE_FORMAT_R32_FLOAT:
		375	return &emit_R32_FLOAT;
		376	case PIPE_FORMAT_R32G32_FLOAT:
		377	return &emit_R32G32_FLOAT;
		378	case PIPE_FORMAT_R32G32B32_FLOAT:
		379	return &emit_R32G32B32_FLOAT;
		380	case PIPE_FORMAT_R32G32B32A32_FLOAT:
		381	return &emit_R32G32B32A32_FLOAT;
		382
		383	case PIPE_FORMAT_R16_FLOAT:
		384	return &emit_R16_FLOAT;
		385	case PIPE_FORMAT_R16G16_FLOAT:
		386	return &emit_R16G16_FLOAT;
		387	case PIPE_FORMAT_R16G16B16_FLOAT:
		388	return &emit_R16G16B16_FLOAT;
		389	case PIPE_FORMAT_R16G16B16A16_FLOAT:
		390	return &emit_R16G16B16A16_FLOAT;
		391
		392	case PIPE_FORMAT_R32_UNORM:
		393	return &emit_R32_UNORM;
		394	case PIPE_FORMAT_R32G32_UNORM:
		395	return &emit_R32G32_UNORM;
		396	case PIPE_FORMAT_R32G32B32_UNORM:
		397	return &emit_R32G32B32_UNORM;
		398	case PIPE_FORMAT_R32G32B32A32_UNORM:
		399	return &emit_R32G32B32A32_UNORM;
		400
		401	case PIPE_FORMAT_R32_USCALED:
		402	return &emit_R32_USCALED;
		403	case PIPE_FORMAT_R32G32_USCALED:
		404	return &emit_R32G32_USCALED;
		405	case PIPE_FORMAT_R32G32B32_USCALED:
		406	return &emit_R32G32B32_USCALED;
		407	case PIPE_FORMAT_R32G32B32A32_USCALED:
		408	return &emit_R32G32B32A32_USCALED;
		409
		410	case PIPE_FORMAT_R32_SNORM:
		411	return &emit_R32_SNORM;
		412	case PIPE_FORMAT_R32G32_SNORM:
		413	return &emit_R32G32_SNORM;
		414	case PIPE_FORMAT_R32G32B32_SNORM:
		415	return &emit_R32G32B32_SNORM;
		416	case PIPE_FORMAT_R32G32B32A32_SNORM:
		417	return &emit_R32G32B32A32_SNORM;
		418
		419	case PIPE_FORMAT_R32_SSCALED:
		420	return &emit_R32_SSCALED;
		421	case PIPE_FORMAT_R32G32_SSCALED:
		422	return &emit_R32G32_SSCALED;
		423	case PIPE_FORMAT_R32G32B32_SSCALED:
		424	return &emit_R32G32B32_SSCALED;
		425	case PIPE_FORMAT_R32G32B32A32_SSCALED:
		426	return &emit_R32G32B32A32_SSCALED;
		427
		428	case PIPE_FORMAT_R16_UNORM:
		429	return &emit_R16_UNORM;
		430	case PIPE_FORMAT_R16G16_UNORM:
		431	return &emit_R16G16_UNORM;
		432	case PIPE_FORMAT_R16G16B16_UNORM:
		433	return &emit_R16G16B16_UNORM;
		434	case PIPE_FORMAT_R16G16B16A16_UNORM:
		435	return &emit_R16G16B16A16_UNORM;
		436
		437	case PIPE_FORMAT_R16_USCALED:
		438	return &emit_R16_USCALED;
		439	case PIPE_FORMAT_R16G16_USCALED:
		440	return &emit_R16G16_USCALED;
		441	case PIPE_FORMAT_R16G16B16_USCALED:
		442	return &emit_R16G16B16_USCALED;
		443	case PIPE_FORMAT_R16G16B16A16_USCALED:
		444	return &emit_R16G16B16A16_USCALED;
		445
		446	case PIPE_FORMAT_R16_SNORM:
		447	return &emit_R16_SNORM;
		448	case PIPE_FORMAT_R16G16_SNORM:
		449	return &emit_R16G16_SNORM;
		450	case PIPE_FORMAT_R16G16B16_SNORM:
		451	return &emit_R16G16B16_SNORM;
		452	case PIPE_FORMAT_R16G16B16A16_SNORM:
		453	return &emit_R16G16B16A16_SNORM;
		454
		455	case PIPE_FORMAT_R16_SSCALED:
		456	return &emit_R16_SSCALED;
		457	case PIPE_FORMAT_R16G16_SSCALED:
		458	return &emit_R16G16_SSCALED;
		459	case PIPE_FORMAT_R16G16B16_SSCALED:
		460	return &emit_R16G16B16_SSCALED;
		461	case PIPE_FORMAT_R16G16B16A16_SSCALED:
		462	return &emit_R16G16B16A16_SSCALED;
		463
		464	case PIPE_FORMAT_R8_UNORM:
		465	return &emit_R8_UNORM;
		466	case PIPE_FORMAT_R8G8_UNORM:
		467	return &emit_R8G8_UNORM;
		468	case PIPE_FORMAT_R8G8B8_UNORM:
		469	return &emit_R8G8B8_UNORM;
		470	case PIPE_FORMAT_R8G8B8A8_UNORM:
		471	return &emit_R8G8B8A8_UNORM;
		472
		473	case PIPE_FORMAT_R8_USCALED:
		474	return &emit_R8_USCALED;
		475	case PIPE_FORMAT_R8G8_USCALED:
		476	return &emit_R8G8_USCALED;
		477	case PIPE_FORMAT_R8G8B8_USCALED:
		478	return &emit_R8G8B8_USCALED;
		479	case PIPE_FORMAT_R8G8B8A8_USCALED:
		480	return &emit_R8G8B8A8_USCALED;
		481
		482	case PIPE_FORMAT_R8_SNORM:
		483	return &emit_R8_SNORM;
		484	case PIPE_FORMAT_R8G8_SNORM:
		485	return &emit_R8G8_SNORM;
		486	case PIPE_FORMAT_R8G8B8_SNORM:
		487	return &emit_R8G8B8_SNORM;
		488	case PIPE_FORMAT_R8G8B8A8_SNORM:
		489	return &emit_R8G8B8A8_SNORM;
		490
		491	case PIPE_FORMAT_R8_SSCALED:
		492	return &emit_R8_SSCALED;
		493	case PIPE_FORMAT_R8G8_SSCALED:
		494	return &emit_R8G8_SSCALED;
		495	case PIPE_FORMAT_R8G8B8_SSCALED:
		496	return &emit_R8G8B8_SSCALED;
		497	case PIPE_FORMAT_R8G8B8A8_SSCALED:
		498	return &emit_R8G8B8A8_SSCALED;
		499
		500	case PIPE_FORMAT_B8G8R8A8_UNORM:
		501	return &emit_B8G8R8A8_UNORM;
		502
		503	case PIPE_FORMAT_A8R8G8B8_UNORM:
		504	return &emit_A8R8G8B8_UNORM;
		505
		506	case PIPE_FORMAT_R32_UINT:
		507	return &emit_R32_UINT;
		508	case PIPE_FORMAT_R32G32_UINT:
		509	return &emit_R32G32_UINT;
		510	case PIPE_FORMAT_R32G32B32_UINT:
		511	return &emit_R32G32B32_UINT;
		512	case PIPE_FORMAT_R32G32B32A32_UINT:
		513	return &emit_R32G32B32A32_UINT;
		514
		515	case PIPE_FORMAT_R16_UINT:
		516	return &emit_R16_UINT;
		517	case PIPE_FORMAT_R16G16_UINT:
		518	return &emit_R16G16_UINT;
		519	case PIPE_FORMAT_R16G16B16_UINT:
		520	return &emit_R16G16B16_UINT;
		521	case PIPE_FORMAT_R16G16B16A16_UINT:
		522	return &emit_R16G16B16A16_UINT;
		523
		524	case PIPE_FORMAT_R8_UINT:
		525	return &emit_R8_UINT;
		526	case PIPE_FORMAT_R8G8_UINT:
		527	return &emit_R8G8_UINT;
		528	case PIPE_FORMAT_R8G8B8_UINT:
		529	return &emit_R8G8B8_UINT;
		530	case PIPE_FORMAT_R8G8B8A8_UINT:
		531	return &emit_R8G8B8A8_UINT;
		532
		533	case PIPE_FORMAT_R32_SINT:
		534	return &emit_R32_SINT;
		535	case PIPE_FORMAT_R32G32_SINT:
		536	return &emit_R32G32_SINT;
		537	case PIPE_FORMAT_R32G32B32_SINT:
		538	return &emit_R32G32B32_SINT;
		539	case PIPE_FORMAT_R32G32B32A32_SINT:
		540	return &emit_R32G32B32A32_SINT;
		541
		542	case PIPE_FORMAT_R16_SINT:
		543	return &emit_R16_SINT;
		544	case PIPE_FORMAT_R16G16_SINT:
		545	return &emit_R16G16_SINT;
		546	case PIPE_FORMAT_R16G16B16_SINT:
		547	return &emit_R16G16B16_SINT;
		548	case PIPE_FORMAT_R16G16B16A16_SINT:
		549	return &emit_R16G16B16A16_SINT;
		550
		551	case PIPE_FORMAT_R8_SINT:
		552	return &emit_R8_SINT;
		553	case PIPE_FORMAT_R8G8_SINT:
		554	return &emit_R8G8_SINT;
		555	case PIPE_FORMAT_R8G8B8_SINT:
		556	return &emit_R8G8B8_SINT;
		557	case PIPE_FORMAT_R8G8B8A8_SINT:
		558	return &emit_R8G8B8A8_SINT;
		559
		560	case PIPE_FORMAT_B10G10R10A2_UNORM:
		561	return &emit_B10G10R10A2_UNORM;
		562	case PIPE_FORMAT_B10G10R10A2_USCALED:
		563	return &emit_B10G10R10A2_USCALED;
		564	case PIPE_FORMAT_B10G10R10A2_SNORM:
		565	return &emit_B10G10R10A2_SNORM;
		566	case PIPE_FORMAT_B10G10R10A2_SSCALED:
		567	return &emit_B10G10R10A2_SSCALED;
		568
		569	case PIPE_FORMAT_R10G10B10A2_UNORM:
		570	return &emit_R10G10B10A2_UNORM;
		571	case PIPE_FORMAT_R10G10B10A2_USCALED:
		572	return &emit_R10G10B10A2_USCALED;
		573	case PIPE_FORMAT_R10G10B10A2_SNORM:
		574	return &emit_R10G10B10A2_SNORM;
		575	case PIPE_FORMAT_R10G10B10A2_SSCALED:
		576	return &emit_R10G10B10A2_SSCALED;
		577
		578	default:
		579	assert(0);
		580	return &emit_NULL;
		581	}
		582	}
		583
		584	static ALWAYS_INLINE void PIPE_CDECL generic_run_one( struct translate_generic *tg,
		585	unsigned elt,
		586	unsigned start_instance,
		587	unsigned instance_id,
		588	void *vert )
		589	{
		590	unsigned nr_attrs = tg->nr_attrib;
		591	unsigned attr;
		592
		593	for (attr = 0; attr < nr_attrs; attr++) {
		594	float data[4];
		595	uint8_t dst = (uint8_t )vert + tg->attrib[attr].output_offset;
		596
		597	if (tg->attrib[attr].type == TRANSLATE_ELEMENT_NORMAL) {
		598	const uint8_t *src;
		599	unsigned index;
		600	int copy_size;
		601
		602	if (tg->attrib[attr].instance_divisor) {
		603	index = start_instance;
		604	index += (instance_id / tg->attrib[attr].instance_divisor);
		605	/* XXX we need to clamp the index here too, but to a
		606	* per-array max value, not the draw->pt.max_index value
		607	* that's being given to us via translate->set_buffer().
		608	*/
		609	}
		610	else {
		611	index = elt;
		612	/* clamp to avoid going out of bounds */
		613	index = MIN2(index, tg->attrib[attr].max_index);
		614	}
		615
		616	src = tg->attrib[attr].input_ptr +
		617	(ptrdiff_t)tg->attrib[attr].input_stride * index;
		618
		619	copy_size = tg->attrib[attr].copy_size;
		620	if(likely(copy_size >= 0))
		621	memcpy(dst, src, copy_size);
		622	else
		623	{
		624	tg->attrib[attr].fetch( data, src, 0, 0 );
		625
		626	if (0)
		627	debug_printf("Fetch linear attr %d from %p stride %d index %d: "
		628	" %f, %f, %f, %f \n",
		629	attr,
		630	tg->attrib[attr].input_ptr,
		631	tg->attrib[attr].input_stride,
		632	index,
		633	data[0], data[1],data[2], data[3]);
		634
		635	tg->attrib[attr].emit( data, dst );
		636	}
		637	} else {
		638	if(likely(tg->attrib[attr].copy_size >= 0))
		639	memcpy(data, &instance_id, 4);
		640	else
		641	{
		642	data[0] = (float)instance_id;
		643	tg->attrib[attr].emit( data, dst );
		644	}
		645	}
		646	}
		647	}
		648
		649	/**
		650	* Fetch vertex attributes for 'count' vertices.
		651	*/
		652	static void PIPE_CDECL generic_run_elts( struct translate *translate,
		653	const unsigned *elts,
		654	unsigned count,
		655	unsigned start_instance,
		656	unsigned instance_id,
		657	void *output_buffer )
		658	{
		659	struct translate_generic *tg = translate_generic(translate);
		660	char *vert = output_buffer;
		661	unsigned i;
		662
		663	for (i = 0; i < count; i++) {
		664	generic_run_one(tg, *elts++, start_instance, instance_id, vert);
		665	vert += tg->translate.key.output_stride;
		666	}
		667	}
		668
		669	static void PIPE_CDECL generic_run_elts16( struct translate *translate,
		670	const uint16_t *elts,
		671	unsigned count,
		672	unsigned start_instance,
		673	unsigned instance_id,
		674	void *output_buffer )
		675	{
		676	struct translate_generic *tg = translate_generic(translate);
		677	char *vert = output_buffer;
		678	unsigned i;
		679
		680	for (i = 0; i < count; i++) {
		681	generic_run_one(tg, *elts++, start_instance, instance_id, vert);
		682	vert += tg->translate.key.output_stride;
		683	}
		684	}
		685
		686	static void PIPE_CDECL generic_run_elts8( struct translate *translate,
		687	const uint8_t *elts,
		688	unsigned count,
		689	unsigned start_instance,
		690	unsigned instance_id,
		691	void *output_buffer )
		692	{
		693	struct translate_generic *tg = translate_generic(translate);
		694	char *vert = output_buffer;
		695	unsigned i;
		696
		697	for (i = 0; i < count; i++) {
		698	generic_run_one(tg, *elts++, start_instance, instance_id, vert);
		699	vert += tg->translate.key.output_stride;
		700	}
		701	}
		702
		703	static void PIPE_CDECL generic_run( struct translate *translate,
		704	unsigned start,
		705	unsigned count,
		706	unsigned start_instance,
		707	unsigned instance_id,
		708	void *output_buffer )
		709	{
		710	struct translate_generic *tg = translate_generic(translate);
		711	char *vert = output_buffer;
		712	unsigned i;
		713
		714	for (i = 0; i < count; i++) {
		715	generic_run_one(tg, start + i, start_instance, instance_id, vert);
		716	vert += tg->translate.key.output_stride;
		717	}
		718	}
		719
		720
		721
		722	static void generic_set_buffer( struct translate *translate,
		723	unsigned buf,
		724	const void *ptr,
		725	unsigned stride,
		726	unsigned max_index )
		727	{
		728	struct translate_generic *tg = translate_generic(translate);
		729	unsigned i;
		730
		731	for (i = 0; i < tg->nr_attrib; i++) {
		732	if (tg->attrib[i].buffer == buf) {
		733	tg->attrib[i].input_ptr = ((const uint8_t *)ptr +
		734	tg->attrib[i].input_offset);
		735	tg->attrib[i].input_stride = stride;
		736	tg->attrib[i].max_index = max_index;
		737	}
		738	}
		739	}
		740
		741
		742	static void generic_release( struct translate *translate )
		743	{
		744	/* Refcount?
		745	*/
		746	FREE(translate);
		747	}
		748
		749	static boolean
		750	is_legal_int_format_combo( const struct util_format_description *src,
		751	const struct util_format_description *dst )
		752	{
		753	unsigned i;
		754	unsigned nr = MIN2(src->nr_channels, dst->nr_channels);
		755
		756	for (i = 0; i < nr; i++) {
		757	/* The signs must match. */
		758	if (src->channel[i].type != dst->channel[i].type) {
		759	return FALSE;
		760	}
		761
		762	/* Integers must not lose precision at any point in the pipeline. */
		763	if (src->channel[i].size > dst->channel[i].size) {
		764	return FALSE;
		765	}
		766	}
		767	return TRUE;
		768	}
		769
		770	struct translate translate_generic_create( const struct translate_key key )
		771	{
		772	struct translate_generic *tg = CALLOC_STRUCT(translate_generic);
		773	unsigned i;
		774
		775	if (tg == NULL)
		776	return NULL;
		777
		778	assert(key->nr_elements <= TRANSLATE_MAX_ATTRIBS);
		779
		780	tg->translate.key = *key;
		781	tg->translate.release = generic_release;
		782	tg->translate.set_buffer = generic_set_buffer;
		783	tg->translate.run_elts = generic_run_elts;
		784	tg->translate.run_elts16 = generic_run_elts16;
		785	tg->translate.run_elts8 = generic_run_elts8;
		786	tg->translate.run = generic_run;
		787
		788	for (i = 0; i < key->nr_elements; i++) {
		789	const struct util_format_description *format_desc =
		790	util_format_description(key->element[i].input_format);
		791
		792	assert(format_desc);
		793
		794	tg->attrib[i].type = key->element[i].type;
		795
		796	if (format_desc->channel[0].pure_integer) {
		797	const struct util_format_description *out_format_desc =
		798	util_format_description(key->element[i].output_format);
		799
		800	if (!is_legal_int_format_combo(format_desc, out_format_desc)) {
		801	FREE(tg);
		802	return NULL;
		803	}
		804
		805	if (format_desc->channel[0].type == UTIL_FORMAT_TYPE_SIGNED) {
		806	assert(format_desc->fetch_rgba_sint);
		807	tg->attrib[i].fetch = (fetch_func)format_desc->fetch_rgba_sint;
		808	} else {
		809	assert(format_desc->fetch_rgba_uint);
		810	tg->attrib[i].fetch = (fetch_func)format_desc->fetch_rgba_uint;
		811	}
		812	} else {
		813	assert(format_desc->fetch_rgba_float);
		814	tg->attrib[i].fetch = (fetch_func)format_desc->fetch_rgba_float;
		815	}
		816
		817	tg->attrib[i].buffer = key->element[i].input_buffer;
		818	tg->attrib[i].input_offset = key->element[i].input_offset;
		819	tg->attrib[i].instance_divisor = key->element[i].instance_divisor;
		820
		821	tg->attrib[i].output_offset = key->element[i].output_offset;
		822
		823	tg->attrib[i].copy_size = -1;
		824	if (tg->attrib[i].type == TRANSLATE_ELEMENT_INSTANCE_ID)
		825	{
		826	if(key->element[i].output_format == PIPE_FORMAT_R32_USCALED
		827	\|\| key->element[i].output_format == PIPE_FORMAT_R32_SSCALED)
		828	tg->attrib[i].copy_size = 4;
		829	}
		830	else
		831	{
		832	if(key->element[i].input_format == key->element[i].output_format
		833	&& format_desc->block.width == 1
		834	&& format_desc->block.height == 1
		835	&& !(format_desc->block.bits & 7))
		836	tg->attrib[i].copy_size = format_desc->block.bits >> 3;
		837	}
		838
		839	if(tg->attrib[i].copy_size < 0)
		840	tg->attrib[i].emit = get_emit_func(key->element[i].output_format);
		841	else
		842	tg->attrib[i].emit = NULL;
		843	}
		844
		845	tg->nr_attrib = key->nr_elements;
		846
		847
		848	return &tg->translate;
		849	}
		850
		851	boolean translate_generic_is_output_format_supported(enum pipe_format format)
		852	{
		853	switch(format)
		854	{
		855	case PIPE_FORMAT_R64G64B64A64_FLOAT: return TRUE;
		856	case PIPE_FORMAT_R64G64B64_FLOAT: return TRUE;
		857	case PIPE_FORMAT_R64G64_FLOAT: return TRUE;
		858	case PIPE_FORMAT_R64_FLOAT: return TRUE;
		859
		860	case PIPE_FORMAT_R32G32B32A32_FLOAT: return TRUE;
		861	case PIPE_FORMAT_R32G32B32_FLOAT: return TRUE;
		862	case PIPE_FORMAT_R32G32_FLOAT: return TRUE;
		863	case PIPE_FORMAT_R32_FLOAT: return TRUE;
		864
		865	case PIPE_FORMAT_R16G16B16A16_FLOAT: return TRUE;
		866	case PIPE_FORMAT_R16G16B16_FLOAT: return TRUE;
		867	case PIPE_FORMAT_R16G16_FLOAT: return TRUE;
		868	case PIPE_FORMAT_R16_FLOAT: return TRUE;
		869
		870	case PIPE_FORMAT_R32G32B32A32_USCALED: return TRUE;
		871	case PIPE_FORMAT_R32G32B32_USCALED: return TRUE;
		872	case PIPE_FORMAT_R32G32_USCALED: return TRUE;
		873	case PIPE_FORMAT_R32_USCALED: return TRUE;
		874
		875	case PIPE_FORMAT_R32G32B32A32_SSCALED: return TRUE;
		876	case PIPE_FORMAT_R32G32B32_SSCALED: return TRUE;
		877	case PIPE_FORMAT_R32G32_SSCALED: return TRUE;
		878	case PIPE_FORMAT_R32_SSCALED: return TRUE;
		879
		880	case PIPE_FORMAT_R32G32B32A32_UNORM: return TRUE;
		881	case PIPE_FORMAT_R32G32B32_UNORM: return TRUE;
		882	case PIPE_FORMAT_R32G32_UNORM: return TRUE;
		883	case PIPE_FORMAT_R32_UNORM: return TRUE;
		884
		885	case PIPE_FORMAT_R32G32B32A32_SNORM: return TRUE;
		886	case PIPE_FORMAT_R32G32B32_SNORM: return TRUE;
		887	case PIPE_FORMAT_R32G32_SNORM: return TRUE;
		888	case PIPE_FORMAT_R32_SNORM: return TRUE;
		889
		890	case PIPE_FORMAT_R16G16B16A16_USCALED: return TRUE;
		891	case PIPE_FORMAT_R16G16B16_USCALED: return TRUE;
		892	case PIPE_FORMAT_R16G16_USCALED: return TRUE;
		893	case PIPE_FORMAT_R16_USCALED: return TRUE;
		894
		895	case PIPE_FORMAT_R16G16B16A16_SSCALED: return TRUE;
		896	case PIPE_FORMAT_R16G16B16_SSCALED: return TRUE;
		897	case PIPE_FORMAT_R16G16_SSCALED: return TRUE;
		898	case PIPE_FORMAT_R16_SSCALED: return TRUE;
		899
		900	case PIPE_FORMAT_R16G16B16A16_UNORM: return TRUE;
		901	case PIPE_FORMAT_R16G16B16_UNORM: return TRUE;
		902	case PIPE_FORMAT_R16G16_UNORM: return TRUE;
		903	case PIPE_FORMAT_R16_UNORM: return TRUE;
		904
		905	case PIPE_FORMAT_R16G16B16A16_SNORM: return TRUE;
		906	case PIPE_FORMAT_R16G16B16_SNORM: return TRUE;
		907	case PIPE_FORMAT_R16G16_SNORM: return TRUE;
		908	case PIPE_FORMAT_R16_SNORM: return TRUE;
		909
		910	case PIPE_FORMAT_R8G8B8A8_USCALED: return TRUE;
		911	case PIPE_FORMAT_R8G8B8_USCALED: return TRUE;
		912	case PIPE_FORMAT_R8G8_USCALED: return TRUE;
		913	case PIPE_FORMAT_R8_USCALED: return TRUE;
		914
		915	case PIPE_FORMAT_R8G8B8A8_SSCALED: return TRUE;
		916	case PIPE_FORMAT_R8G8B8_SSCALED: return TRUE;
		917	case PIPE_FORMAT_R8G8_SSCALED: return TRUE;
		918	case PIPE_FORMAT_R8_SSCALED: return TRUE;
		919
		920	case PIPE_FORMAT_R8G8B8A8_UNORM: return TRUE;
		921	case PIPE_FORMAT_R8G8B8_UNORM: return TRUE;
		922	case PIPE_FORMAT_R8G8_UNORM: return TRUE;
		923	case PIPE_FORMAT_R8_UNORM: return TRUE;
		924
		925	case PIPE_FORMAT_R8G8B8A8_SNORM: return TRUE;
		926	case PIPE_FORMAT_R8G8B8_SNORM: return TRUE;
		927	case PIPE_FORMAT_R8G8_SNORM: return TRUE;
		928	case PIPE_FORMAT_R8_SNORM: return TRUE;
		929
		930	case PIPE_FORMAT_A8R8G8B8_UNORM: return TRUE;
		931	case PIPE_FORMAT_B8G8R8A8_UNORM: return TRUE;
		932
		933	case PIPE_FORMAT_R32G32B32A32_UINT: return TRUE;
		934	case PIPE_FORMAT_R32G32B32_UINT: return TRUE;
		935	case PIPE_FORMAT_R32G32_UINT: return TRUE;
		936	case PIPE_FORMAT_R32_UINT: return TRUE;
		937
		938	case PIPE_FORMAT_R16G16B16A16_UINT: return TRUE;
		939	case PIPE_FORMAT_R16G16B16_UINT: return TRUE;
		940	case PIPE_FORMAT_R16G16_UINT: return TRUE;
		941	case PIPE_FORMAT_R16_UINT: return TRUE;
		942
		943	case PIPE_FORMAT_R8G8B8A8_UINT: return TRUE;
		944	case PIPE_FORMAT_R8G8B8_UINT: return TRUE;
		945	case PIPE_FORMAT_R8G8_UINT: return TRUE;
		946	case PIPE_FORMAT_R8_UINT: return TRUE;
		947
		948	case PIPE_FORMAT_R32G32B32A32_SINT: return TRUE;
		949	case PIPE_FORMAT_R32G32B32_SINT: return TRUE;
		950	case PIPE_FORMAT_R32G32_SINT: return TRUE;
		951	case PIPE_FORMAT_R32_SINT: return TRUE;
		952
		953	case PIPE_FORMAT_R16G16B16A16_SINT: return TRUE;
		954	case PIPE_FORMAT_R16G16B16_SINT: return TRUE;
		955	case PIPE_FORMAT_R16G16_SINT: return TRUE;
		956	case PIPE_FORMAT_R16_SINT: return TRUE;
		957
		958	case PIPE_FORMAT_R8G8B8A8_SINT: return TRUE;
		959	case PIPE_FORMAT_R8G8B8_SINT: return TRUE;
		960	case PIPE_FORMAT_R8G8_SINT: return TRUE;
		961	case PIPE_FORMAT_R8_SINT: return TRUE;
		962
		963	case PIPE_FORMAT_B10G10R10A2_UNORM: return TRUE;
		964	case PIPE_FORMAT_B10G10R10A2_USCALED: return TRUE;
		965	case PIPE_FORMAT_B10G10R10A2_SNORM: return TRUE;
		966	case PIPE_FORMAT_B10G10R10A2_SSCALED: return TRUE;
		967
		968	case PIPE_FORMAT_R10G10B10A2_UNORM: return TRUE;
		969	case PIPE_FORMAT_R10G10B10A2_USCALED: return TRUE;
		970	case PIPE_FORMAT_R10G10B10A2_SNORM: return TRUE;
		971	case PIPE_FORMAT_R10G10B10A2_SSCALED: return TRUE;
		972
		973	default: return FALSE;
		974	}
		975	}

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/Mesa/mesa-10.6.0/src/gallium/auxiliary/translate/translate_generic.c – Rev 5564