WebSVN - shark - Blame - Rev 55 - /shark/trunk/ports/mesa/src/teximage.c

Rev	Author	Line No.	Line
55	pj	1	/* $Id: teximage.c,v 1.1 2003-02-28 11:42:05 pj Exp $ */
		2
		3	/*
		4	* Mesa 3-D graphics library
		5	* Version: 4.1
		6	*
		7	* Copyright (C) 1999-2002 Brian Paul All Rights Reserved.
		8	*
		9	* Permission is hereby granted, free of charge, to any person obtaining a
		10	* copy of this software and associated documentation files (the "Software"),
		11	* to deal in the Software without restriction, including without limitation
		12	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
		13	* and/or sell copies of the Software, and to permit persons to whom the
		14	* Software is furnished to do so, subject to the following conditions:
		15	*
		16	* The above copyright notice and this permission notice shall be included
		17	* in all copies or substantial portions of the Software.
		18	*
		19	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
		20	* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		21	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
		22	* BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
		23	* AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
		24	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
		25	*/
		26
		27	#include "glheader.h"
		28	#include "context.h"
		29	#include "convolve.h"
		30	#include "image.h"
		31	#include "imports.h"
		32	#include "macros.h"
		33	#include "mmath.h"
		34	#include "state.h"
		35	#include "texcompress.h"
		36	#include "texformat.h"
		37	#include "teximage.h"
		38	#include "texstate.h"
		39	#include "texstore.h"
		40	#include "mtypes.h"
		41
		42
		43	/*
		44	* NOTES:
		45	*
		46	* Mesa's native texture datatype is GLchan. Native formats are
		47	* GL_ALPHA, GL_LUMINANCE, GL_LUMANCE_ALPHA, GL_INTENSITY, GL_RGB, GL_RGBA,
		48	* and GL_COLOR_INDEX.
		49	* Device drivers are free to implement any internal format they want.
		50	*/
		51
		52
		53	#if 0
		54	static void PrintTexture(GLcontext ctx, const struct gl_texture_image img)
		55	{
		56	#if CHAN_TYPE == GL_FLOAT
		57	_mesa_problem(NULL, "PrintTexture doesn't support float channels");
		58	#else
		59	GLuint i, j, c;
		60	const GLchan data = (const GLchan ) img->Data;
		61
		62	if (!data) {
		63	_mesa_printf("No texture data\n");
		64	return;
		65	}
		66
		67	switch (img->Format) {
		68	case GL_ALPHA:
		69	case GL_LUMINANCE:
		70	case GL_INTENSITY:
		71	case GL_COLOR_INDEX:
		72	c = 1;
		73	break;
		74	case GL_LUMINANCE_ALPHA:
		75	c = 2;
		76	break;
		77	case GL_RGB:
		78	c = 3;
		79	break;
		80	case GL_RGBA:
		81	c = 4;
		82	break;
		83	default:
		84	_mesa_problem(NULL, "error in PrintTexture\n");
		85	return;
		86	}
		87
		88	for (i = 0; i < img->Height; i++) {
		89	for (j = 0; j < img->Width; j++) {
		90	if (c==1)
		91	_mesa_printf("%02x ", data[0]);
		92	else if (c==2)
		93	_mesa_printf("%02x%02x ", data[0], data[1]);
		94	else if (c==3)
		95	_mesa_printf("%02x%02x%02x ", data[0], data[1], data[2]);
		96	else if (c==4)
		97	_mesa_printf("%02x%02x%02x%02x ", data[0], data[1], data[2], data[3]);
		98	data += (img->RowStride - img->Width) * c;
		99	}
		100	_mesa_printf("\n");
		101	}
		102	#endif
		103	}
		104	#endif
		105
		106
		107
		108	/*
		109	* Compute log base 2 of n.
		110	* If n isn't an exact power of two return -1.
		111	* If n < 0 return -1.
		112	*/
		113	static int
		114	logbase2( int n )
		115	{
		116	GLint i = 1;
		117	GLint log2 = 0;
		118
		119	if (n < 0) {
		120	return -1;
		121	}
		122
		123	while ( n > i ) {
		124	i *= 2;
		125	log2++;
		126	}
		127	if (i != n) {
		128	return -1;
		129	}
		130	else {
		131	return log2;
		132	}
		133	}
		134
		135
		136
		137	/*
		138	* Given an internal texture format enum or 1, 2, 3, 4 return the
		139	* corresponding _base_ internal format: GL_ALPHA, GL_LUMINANCE,
		140	* GL_LUMANCE_ALPHA, GL_INTENSITY, GL_RGB, or GL_RGBA.
		141	*
		142	* This is the format which is used during texture application (i.e. the
		143	* texture format and env mode determine the arithmetic used.
		144	*
		145	* Return -1 if invalid enum.
		146	*/
		147	GLint
		148	_mesa_base_tex_format( GLcontext *ctx, GLint format )
		149	{
		150	/*
		151	* Ask the driver for the base format, if it doesn't
		152	* know, it will return -1;
		153	*/
		154	switch (format) {
		155	case GL_ALPHA:
		156	case GL_ALPHA4:
		157	case GL_ALPHA8:
		158	case GL_ALPHA12:
		159	case GL_ALPHA16:
		160	return GL_ALPHA;
		161	case 1:
		162	case GL_LUMINANCE:
		163	case GL_LUMINANCE4:
		164	case GL_LUMINANCE8:
		165	case GL_LUMINANCE12:
		166	case GL_LUMINANCE16:
		167	return GL_LUMINANCE;
		168	case 2:
		169	case GL_LUMINANCE_ALPHA:
		170	case GL_LUMINANCE4_ALPHA4:
		171	case GL_LUMINANCE6_ALPHA2:
		172	case GL_LUMINANCE8_ALPHA8:
		173	case GL_LUMINANCE12_ALPHA4:
		174	case GL_LUMINANCE12_ALPHA12:
		175	case GL_LUMINANCE16_ALPHA16:
		176	return GL_LUMINANCE_ALPHA;
		177	case GL_INTENSITY:
		178	case GL_INTENSITY4:
		179	case GL_INTENSITY8:
		180	case GL_INTENSITY12:
		181	case GL_INTENSITY16:
		182	return GL_INTENSITY;
		183	case 3:
		184	case GL_RGB:
		185	case GL_R3_G3_B2:
		186	case GL_RGB4:
		187	case GL_RGB5:
		188	case GL_RGB8:
		189	case GL_RGB10:
		190	case GL_RGB12:
		191	case GL_RGB16:
		192	return GL_RGB;
		193	case 4:
		194	case GL_RGBA:
		195	case GL_RGBA2:
		196	case GL_RGBA4:
		197	case GL_RGB5_A1:
		198	case GL_RGBA8:
		199	case GL_RGB10_A2:
		200	case GL_RGBA12:
		201	case GL_RGBA16:
		202	return GL_RGBA;
		203	case GL_COLOR_INDEX:
		204	case GL_COLOR_INDEX1_EXT:
		205	case GL_COLOR_INDEX2_EXT:
		206	case GL_COLOR_INDEX4_EXT:
		207	case GL_COLOR_INDEX8_EXT:
		208	case GL_COLOR_INDEX12_EXT:
		209	case GL_COLOR_INDEX16_EXT:
		210	if (ctx->Extensions.EXT_paletted_texture)
		211	return GL_COLOR_INDEX;
		212	else
		213	return -1;
		214	case GL_DEPTH_COMPONENT:
		215	case GL_DEPTH_COMPONENT16_SGIX:
		216	case GL_DEPTH_COMPONENT24_SGIX:
		217	case GL_DEPTH_COMPONENT32_SGIX:
		218	if (ctx->Extensions.SGIX_depth_texture)
		219	return GL_DEPTH_COMPONENT;
		220	else
		221	return -1;
		222
		223	/* GL_ARB_texture_compression */
		224	case GL_COMPRESSED_ALPHA:
		225	if (ctx->Extensions.ARB_texture_compression)
		226	return GL_ALPHA;
		227	else
		228	return -1;
		229	case GL_COMPRESSED_LUMINANCE:
		230	if (ctx->Extensions.ARB_texture_compression)
		231	return GL_LUMINANCE;
		232	else
		233	return -1;
		234	case GL_COMPRESSED_LUMINANCE_ALPHA:
		235	if (ctx->Extensions.ARB_texture_compression)
		236	return GL_LUMINANCE_ALPHA;
		237	else
		238	return -1;
		239	case GL_COMPRESSED_INTENSITY:
		240	if (ctx->Extensions.ARB_texture_compression)
		241	return GL_INTENSITY;
		242	else
		243	return -1;
		244	case GL_COMPRESSED_RGB:
		245	if (ctx->Extensions.ARB_texture_compression)
		246	return GL_RGB;
		247	else
		248	return -1;
		249	case GL_COMPRESSED_RGBA:
		250	if (ctx->Extensions.ARB_texture_compression)
		251	return GL_RGBA;
		252	else
		253	return -1;
		254	case GL_COMPRESSED_RGB_FXT1_3DFX:
		255	if (ctx->Extensions.TDFX_texture_compression_FXT1)
		256	return GL_RGB;
		257	else
		258	return -1;
		259	case GL_COMPRESSED_RGBA_FXT1_3DFX:
		260	if (ctx->Extensions.TDFX_texture_compression_FXT1)
		261	return GL_RGBA;
		262	else
		263	return -1;
		264
		265	case GL_YCBCR_MESA:
		266	if (ctx->Extensions.MESA_ycbcr_texture)
		267	return GL_YCBCR_MESA;
		268	else
		269	return -1;
		270
		271	default:
		272	return -1; /* error */
		273	}
		274	}
		275
		276
		277	/*
		278	* Test if the given image format is a color/rgba format. That is,
		279	* not color index, depth, stencil, etc.
		280	*/
		281	static GLboolean
		282	is_color_format(GLenum format)
		283	{
		284	switch (format) {
		285	case GL_ALPHA:
		286	case GL_ALPHA4:
		287	case GL_ALPHA8:
		288	case GL_ALPHA12:
		289	case GL_ALPHA16:
		290	case 1:
		291	case GL_LUMINANCE:
		292	case GL_LUMINANCE4:
		293	case GL_LUMINANCE8:
		294	case GL_LUMINANCE12:
		295	case GL_LUMINANCE16:
		296	case 2:
		297	case GL_LUMINANCE_ALPHA:
		298	case GL_LUMINANCE4_ALPHA4:
		299	case GL_LUMINANCE6_ALPHA2:
		300	case GL_LUMINANCE8_ALPHA8:
		301	case GL_LUMINANCE12_ALPHA4:
		302	case GL_LUMINANCE12_ALPHA12:
		303	case GL_LUMINANCE16_ALPHA16:
		304	case GL_INTENSITY:
		305	case GL_INTENSITY4:
		306	case GL_INTENSITY8:
		307	case GL_INTENSITY12:
		308	case GL_INTENSITY16:
		309	case 3:
		310	case GL_RGB:
		311	case GL_R3_G3_B2:
		312	case GL_RGB4:
		313	case GL_RGB5:
		314	case GL_RGB8:
		315	case GL_RGB10:
		316	case GL_RGB12:
		317	case GL_RGB16:
		318	case 4:
		319	case GL_RGBA:
		320	case GL_RGBA2:
		321	case GL_RGBA4:
		322	case GL_RGB5_A1:
		323	case GL_RGBA8:
		324	case GL_RGB10_A2:
		325	case GL_RGBA12:
		326	case GL_RGBA16:
		327	return GL_TRUE;
		328	case GL_YCBCR_MESA: /* not considered to be RGB */
		329	default:
		330	return GL_FALSE;
		331	}
		332	}
		333
		334
		335	static GLboolean
		336	is_index_format(GLenum format)
		337	{
		338	switch (format) {
		339	case GL_COLOR_INDEX:
		340	case GL_COLOR_INDEX1_EXT:
		341	case GL_COLOR_INDEX2_EXT:
		342	case GL_COLOR_INDEX4_EXT:
		343	case GL_COLOR_INDEX8_EXT:
		344	case GL_COLOR_INDEX12_EXT:
		345	case GL_COLOR_INDEX16_EXT:
		346	return GL_TRUE;
		347	default:
		348	return GL_FALSE;
		349	}
		350	}
		351
		352
		353	/**
		354	* Return GL_TRUE if internalFormat is a supported compressed format,
		355	* return GL_FALSE otherwise.
		356	* \param - internalFormat - the internal format token provided by the user
		357	*/
		358	static GLboolean
		359	is_compressed_format(GLenum internalFormat)
		360	{
		361	switch (internalFormat) {
		362	case GL_COMPRESSED_RGB_FXT1_3DFX:
		363	case GL_COMPRESSED_RGBA_FXT1_3DFX:
		364	return GL_TRUE;
		365	default:
		366	return GL_FALSE;
		367	}
		368	}
		369
		370
		371	/*
		372	* Store a gl_texture_image pointer in a gl_texture_object structure
		373	* according to the target and level parameters.
		374	* This was basically prompted by the introduction of cube maps.
		375	*/
		376	void
		377	_mesa_set_tex_image(struct gl_texture_object *tObj,
		378	GLenum target, GLint level,
		379	struct gl_texture_image *texImage)
		380	{
		381	ASSERT(tObj);
		382	ASSERT(texImage);
		383	switch (target) {
		384	case GL_TEXTURE_1D:
		385	case GL_TEXTURE_2D:
		386	case GL_TEXTURE_3D:
		387	tObj->Image[level] = texImage;
		388	return;
		389	case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
		390	tObj->Image[level] = texImage;
		391	return;
		392	case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
		393	tObj->NegX[level] = texImage;
		394	return;
		395	case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
		396	tObj->PosY[level] = texImage;
		397	return;
		398	case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
		399	tObj->NegY[level] = texImage;
		400	return;
		401	case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
		402	tObj->PosZ[level] = texImage;
		403	return;
		404	case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
		405	tObj->NegZ[level] = texImage;
		406	return;
		407	case GL_TEXTURE_RECTANGLE_NV:
		408	ASSERT(level == 0);
		409	tObj->Image[level] = texImage;
		410	return;
		411	default:
		412	_mesa_problem(NULL, "bad target in _mesa_set_tex_image()");
		413	return;
		414	}
		415	}
		416
		417
		418
		419	/*
		420	* Return new gl_texture_image struct with all fields initialized to zero.
		421	*/
		422	struct gl_texture_image *
		423	_mesa_alloc_texture_image( void )
		424	{
		425	return CALLOC_STRUCT(gl_texture_image);
		426	}
		427
		428
		429
		430	void
		431	_mesa_free_texture_image( struct gl_texture_image *teximage )
		432	{
		433	if (teximage->Data && !teximage->IsClientData) {
		434	MESA_PBUFFER_FREE( teximage->Data );
		435	teximage->Data = NULL;
		436	}
		437	FREE( teximage );
		438	}
		439
		440
		441	/*
		442	* Return GL_TRUE if the target is a proxy target.
		443	*/
		444	static GLboolean
		445	is_proxy_target(GLenum target)
		446	{
		447	return (target == GL_PROXY_TEXTURE_1D \|\|
		448	target == GL_PROXY_TEXTURE_2D \|\|
		449	target == GL_PROXY_TEXTURE_3D \|\|
		450	target == GL_PROXY_TEXTURE_CUBE_MAP_ARB);
		451	}
		452
		453
		454	/*
		455	* Given a texture unit and a texture target, return the corresponding
		456	* texture object.
		457	*/
		458	struct gl_texture_object *
		459	_mesa_select_tex_object(GLcontext ctx, const struct gl_texture_unit texUnit,
		460	GLenum target)
		461	{
		462	switch (target) {
		463	case GL_TEXTURE_1D:
		464	return texUnit->Current1D;
		465	case GL_PROXY_TEXTURE_1D:
		466	return ctx->Texture.Proxy1D;
		467	case GL_TEXTURE_2D:
		468	return texUnit->Current2D;
		469	case GL_PROXY_TEXTURE_2D:
		470	return ctx->Texture.Proxy2D;
		471	case GL_TEXTURE_3D:
		472	return texUnit->Current3D;
		473	case GL_PROXY_TEXTURE_3D:
		474	return ctx->Texture.Proxy3D;
		475	case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
		476	case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
		477	case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
		478	case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
		479	case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
		480	case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
		481	case GL_TEXTURE_CUBE_MAP_ARB:
		482	return ctx->Extensions.ARB_texture_cube_map
		483	? texUnit->CurrentCubeMap : NULL;
		484	case GL_PROXY_TEXTURE_CUBE_MAP_ARB:
		485	return ctx->Extensions.ARB_texture_cube_map
		486	? ctx->Texture.ProxyCubeMap : NULL;
		487	case GL_TEXTURE_RECTANGLE_NV:
		488	return ctx->Extensions.NV_texture_rectangle
		489	? texUnit->CurrentRect : NULL;
		490	case GL_PROXY_TEXTURE_RECTANGLE_NV:
		491	return ctx->Extensions.NV_texture_rectangle
		492	? ctx->Texture.ProxyRect : NULL;
		493	default:
		494	_mesa_problem(NULL, "bad target in _mesa_select_tex_object()");
		495	return NULL;
		496	}
		497	}
		498
		499
		500	/*
		501	* Return the texture image struct which corresponds to target and level
		502	* for the given texture unit.
		503	*/
		504	struct gl_texture_image *
		505	_mesa_select_tex_image(GLcontext ctx, const struct gl_texture_unit texUnit,
		506	GLenum target, GLint level)
		507	{
		508	ASSERT(texUnit);
		509	ASSERT(level < MAX_TEXTURE_LEVELS);
		510	switch (target) {
		511	case GL_TEXTURE_1D:
		512	return texUnit->Current1D->Image[level];
		513	case GL_PROXY_TEXTURE_1D:
		514	return ctx->Texture.Proxy1D->Image[level];
		515	case GL_TEXTURE_2D:
		516	return texUnit->Current2D->Image[level];
		517	case GL_PROXY_TEXTURE_2D:
		518	return ctx->Texture.Proxy2D->Image[level];
		519	case GL_TEXTURE_3D:
		520	return texUnit->Current3D->Image[level];
		521	case GL_PROXY_TEXTURE_3D:
		522	return ctx->Texture.Proxy3D->Image[level];
		523	case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
		524	if (ctx->Extensions.ARB_texture_cube_map)
		525	return texUnit->CurrentCubeMap->Image[level];
		526	else
		527	return NULL;
		528	case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
		529	if (ctx->Extensions.ARB_texture_cube_map)
		530	return texUnit->CurrentCubeMap->NegX[level];
		531	else
		532	return NULL;
		533	case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
		534	if (ctx->Extensions.ARB_texture_cube_map)
		535	return texUnit->CurrentCubeMap->PosY[level];
		536	else
		537	return NULL;
		538	case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
		539	if (ctx->Extensions.ARB_texture_cube_map)
		540	return texUnit->CurrentCubeMap->NegY[level];
		541	else
		542	return NULL;
		543	case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
		544	if (ctx->Extensions.ARB_texture_cube_map)
		545	return texUnit->CurrentCubeMap->PosZ[level];
		546	else
		547	return NULL;
		548	case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
		549	if (ctx->Extensions.ARB_texture_cube_map)
		550	return texUnit->CurrentCubeMap->NegZ[level];
		551	else
		552	return NULL;
		553	case GL_PROXY_TEXTURE_CUBE_MAP_ARB:
		554	if (ctx->Extensions.ARB_texture_cube_map)
		555	return ctx->Texture.ProxyCubeMap->Image[level];
		556	else
		557	return NULL;
		558	case GL_TEXTURE_RECTANGLE_NV:
		559	if (ctx->Extensions.NV_texture_rectangle) {
		560	ASSERT(level == 0);
		561	return texUnit->CurrentRect->Image[level];
		562	}
		563	else {
		564	return NULL;
		565	}
		566	case GL_PROXY_TEXTURE_RECTANGLE_NV:
		567	if (ctx->Extensions.NV_texture_rectangle) {
		568	ASSERT(level == 0);
		569	return ctx->Texture.ProxyRect->Image[level];
		570	}
		571	else {
		572	return NULL;
		573	}
		574	default:
		575	_mesa_problem(ctx, "bad target in _mesa_select_tex_image()");
		576	return NULL;
		577	}
		578	}
		579
		580
		581	/*
		582	* Return the maximum number of allows mipmap levels for the given
		583	* texture target.
		584	*/
		585	GLint
		586	_mesa_max_texture_levels(GLcontext *ctx, GLenum target)
		587	{
		588	switch (target) {
		589	case GL_TEXTURE_1D:
		590	case GL_PROXY_TEXTURE_1D:
		591	case GL_TEXTURE_2D:
		592	case GL_PROXY_TEXTURE_2D:
		593	return ctx->Const.MaxTextureLevels;
		594	case GL_TEXTURE_3D:
		595	case GL_PROXY_TEXTURE_3D:
		596	return ctx->Const.Max3DTextureLevels;
		597	case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
		598	case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
		599	case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
		600	case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
		601	case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
		602	case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
		603	case GL_PROXY_TEXTURE_CUBE_MAP_ARB:
		604	return ctx->Const.MaxCubeTextureLevels;
		605	break;
		606	case GL_TEXTURE_RECTANGLE_NV:
		607	case GL_PROXY_TEXTURE_RECTANGLE_NV:
		608	return 1;
		609	break;
		610	default:
		611	return 0; /* bad target */
		612	}
		613	}
		614
		615
		616
		617	#if 000 /* not used anymore */
		618	/*
		619	* glTexImage[123]D can accept a NULL image pointer. In this case we
		620	* create a texture image with unspecified image contents per the OpenGL
		621	* spec.
		622	*/
		623	static GLubyte *
		624	make_null_texture(GLint width, GLint height, GLint depth, GLenum format)
		625	{
		626	const GLint components = _mesa_components_in_format(format);
		627	const GLint numPixels = width * height * depth;
		628	GLubyte data = (GLubyte ) MALLOC(numPixels * components * sizeof(GLubyte));
		629
		630	#ifdef DEBUG
		631	/*
		632	* Let's see if anyone finds this. If glTexImage2D() is called with
		633	* a NULL image pointer then load the texture image with something
		634	* interesting instead of leaving it indeterminate.
		635	*/
		636	if (data) {
		637	static const char message[8][32] = {
		638	" X X XXXXX XXX X ",
		639	" XX XX X X X X X ",
		640	" X X X X X X X ",
		641	" X X XXXX XXX XXXXX ",
		642	" X X X X X X ",
		643	" X X X X X X X ",
		644	" X X XXXXX XXX X X ",
		645	" "
		646	};
		647
		648	GLubyte *imgPtr = data;
		649	GLint h, i, j, k;
		650	for (h = 0; h < depth; h++) {
		651	for (i = 0; i < height; i++) {
		652	GLint srcRow = 7 - (i % 8);
		653	for (j = 0; j < width; j++) {
		654	GLint srcCol = j % 32;
		655	GLubyte texel = (message[srcRow][srcCol]=='X') ? 255 : 70;
		656	for (k = 0; k < components; k++) {
		657	*imgPtr++ = texel;
		658	}
		659	}
		660	}
		661	}
		662	}
		663	#endif
		664
		665	return data;
		666	}
		667	#endif
		668
		669
		670
		671	/*
		672	* Reset the fields of a gl_texture_image struct to zero.
		673	* This is called when a proxy texture test fails, we set all the
		674	* image members (except DriverData) to zero.
		675	* It's also used in glTexImage[123]D as a safeguard to be sure all
		676	* required fields get initialized properly by the Driver.TexImage[123]D
		677	* functions.
		678	*/
		679	static void
		680	clear_teximage_fields(struct gl_texture_image *img)
		681	{
		682	ASSERT(img);
		683	img->Format = 0;
		684	img->IntFormat = 0;
		685	img->Border = 0;
		686	img->Width = 0;
		687	img->Height = 0;
		688	img->Depth = 0;
		689	img->RowStride = 0;
		690	img->Width2 = 0;
		691	img->Height2 = 0;
		692	img->Depth2 = 0;
		693	img->WidthLog2 = 0;
		694	img->HeightLog2 = 0;
		695	img->DepthLog2 = 0;
		696	img->Data = NULL;
		697	img->TexFormat = &_mesa_null_texformat;
		698	img->FetchTexel = NULL;
		699	img->IsCompressed = 0;
		700	img->CompressedSize = 0;
		701	}
		702
		703
		704	/*
		705	* Initialize basic fields of the gl_texture_image struct.
		706	*/
		707	void
		708	_mesa_init_teximage_fields(GLcontext *ctx, GLenum target,
		709	struct gl_texture_image *img,
		710	GLsizei width, GLsizei height, GLsizei depth,
		711	GLint border, GLenum internalFormat)
		712	{
		713	ASSERT(img);
		714	img->Format = _mesa_base_tex_format( ctx, internalFormat );
		715	ASSERT(img->Format > 0);
		716	img->IntFormat = internalFormat;
		717	img->Border = border;
		718	img->Width = width;
		719	img->Height = height;
		720	img->Depth = depth;
		721	img->RowStride = width;
		722	img->WidthLog2 = logbase2(width - 2 * border);
		723	if (height == 1) /* 1-D texture */
		724	img->HeightLog2 = 0;
		725	else
		726	img->HeightLog2 = logbase2(height - 2 * border);
		727	if (depth == 1) /* 2-D texture */
		728	img->DepthLog2 = 0;
		729	else
		730	img->DepthLog2 = logbase2(depth - 2 * border);
		731	img->Width2 = 1 << img->WidthLog2;
		732	img->Height2 = 1 << img->HeightLog2;
		733	img->Depth2 = 1 << img->DepthLog2;
		734	img->MaxLog2 = MAX2(img->WidthLog2, img->HeightLog2);
		735	img->IsCompressed = is_compressed_format(internalFormat);
		736	if (img->IsCompressed)
		737	img->CompressedSize = _mesa_compressed_texture_size(ctx, width, height,
		738	depth, internalFormat);
		739	else
		740	img->CompressedSize = 0;
		741
		742	/* Compute Width/Height/DepthScale for mipmap lod computation */
		743	if (target == GL_TEXTURE_RECTANGLE_NV) {
		744	/* scale = 1.0 since texture coords directly map to texels */
		745	img->WidthScale = 1.0;
		746	img->HeightScale = 1.0;
		747	img->DepthScale = 1.0;
		748	}
		749	else {
		750	img->WidthScale = (GLfloat) img->Width;
		751	img->HeightScale = (GLfloat) img->Height;
		752	img->DepthScale = (GLfloat) img->Depth;
		753	}
		754	}
		755
		756
		757
		758	/*
		759	* Test glTexImage[123]D() parameters for errors.
		760	* Input:
		761	* dimensions - must be 1 or 2 or 3
		762	* Return: GL_TRUE = an error was detected, GL_FALSE = no errors
		763	*/
		764	static GLboolean
		765	texture_error_check( GLcontext *ctx, GLenum target,
		766	GLint level, GLint internalFormat,
		767	GLenum format, GLenum type,
		768	GLuint dimensions,
		769	GLint width, GLint height,
		770	GLint depth, GLint border )
		771	{
		772	GLboolean isProxy;
		773	GLint maxLevels = 0, maxTextureSize;
		774
		775	if (dimensions == 1) {
		776	if (target == GL_PROXY_TEXTURE_1D) {
		777	isProxy = GL_TRUE;
		778	}
		779	else if (target == GL_TEXTURE_1D) {
		780	isProxy = GL_FALSE;
		781	}
		782	else {
		783	_mesa_error( ctx, GL_INVALID_ENUM, "glTexImage1D(target)" );
		784	return GL_TRUE;
		785	}
		786	maxLevels = ctx->Const.MaxTextureLevels;
		787	}
		788	else if (dimensions == 2) {
		789	if (target == GL_PROXY_TEXTURE_2D) {
		790	isProxy = GL_TRUE;
		791	maxLevels = ctx->Const.MaxTextureLevels;
		792	}
		793	else if (target == GL_TEXTURE_2D) {
		794	isProxy = GL_FALSE;
		795	maxLevels = ctx->Const.MaxTextureLevels;
		796	}
		797	else if (target == GL_PROXY_TEXTURE_CUBE_MAP_ARB) {
		798	if (!ctx->Extensions.ARB_texture_cube_map) {
		799	_mesa_error(ctx, GL_INVALID_ENUM, "glTexImage2D(target)");
		800	return GL_TRUE;
		801	}
		802	isProxy = GL_TRUE;
		803	maxLevels = ctx->Const.MaxCubeTextureLevels;
		804	}
		805	else if (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&
		806	target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB) {
		807	if (!ctx->Extensions.ARB_texture_cube_map) {
		808	_mesa_error(ctx, GL_INVALID_ENUM, "glTexImage2D(target)");
		809	return GL_TRUE;
		810	}
		811	isProxy = GL_FALSE;
		812	maxLevels = ctx->Const.MaxCubeTextureLevels;
		813	}
		814	else if (target == GL_PROXY_TEXTURE_RECTANGLE_NV) {
		815	if (!ctx->Extensions.NV_texture_rectangle) {
		816	_mesa_error(ctx, GL_INVALID_ENUM, "glTexImage2D(target)");
		817	return GL_TRUE;
		818	}
		819	isProxy = GL_TRUE;
		820	maxLevels = 1;
		821	}
		822	else if (target == GL_TEXTURE_RECTANGLE_NV) {
		823	if (!ctx->Extensions.NV_texture_rectangle) {
		824	_mesa_error(ctx, GL_INVALID_ENUM, "glTexImage2D(target)");
		825	return GL_TRUE;
		826	}
		827	isProxy = GL_FALSE;
		828	maxLevels = 1;
		829	}
		830	else {
		831	_mesa_error(ctx, GL_INVALID_ENUM, "glTexImage2D(target)");
		832	return GL_TRUE;
		833	}
		834	}
		835	else if (dimensions == 3) {
		836	if (target == GL_PROXY_TEXTURE_3D) {
		837	isProxy = GL_TRUE;
		838	}
		839	else if (target == GL_TEXTURE_3D) {
		840	isProxy = GL_FALSE;
		841	}
		842	else {
		843	_mesa_error( ctx, GL_INVALID_ENUM, "glTexImage3D(target)" );
		844	return GL_TRUE;
		845	}
		846	maxLevels = ctx->Const.Max3DTextureLevels;
		847	}
		848	else {
		849	_mesa_problem( ctx, "bad dims in texture_error_check" );
		850	return GL_TRUE;
		851	}
		852
		853	ASSERT(maxLevels > 0);
		854	maxTextureSize = 1 << (maxLevels - 1);
		855
		856	/* Border */
		857	if (border != 0 && border != 1) {
		858	if (!isProxy) {
		859	_mesa_error(ctx, GL_INVALID_VALUE,
		860	"glTexImage%dD(border=%d)", dimensions, border);
		861	}
		862	return GL_TRUE;
		863	}
		864	if ((target == GL_TEXTURE_RECTANGLE_NV \|\|
		865	target == GL_PROXY_TEXTURE_RECTANGLE_NV) && border != 0) {
		866	return GL_TRUE;
		867	}
		868
		869	/* Width */
		870	if (target == GL_TEXTURE_RECTANGLE_NV \|\|
		871	target == GL_PROXY_TEXTURE_RECTANGLE_NV) {
		872	if (width < 1 \|\| width > ctx->Const.MaxTextureRectSize) {
		873	if (!isProxy) {
		874	_mesa_error(ctx, GL_INVALID_VALUE,
		875	"glTexImage%dD(width=%d)", dimensions, width);
		876	}
		877	return GL_TRUE;
		878	}
		879	}
		880	else if (width < 2 * border \|\| width > 2 + maxTextureSize
		881	\|\| logbase2( width - 2 * border ) < 0) {
		882	if (!isProxy) {
		883	_mesa_error(ctx, GL_INVALID_VALUE,
		884	"glTexImage%dD(width=%d)", dimensions, width);
		885	}
		886	return GL_TRUE;
		887	}
		888
		889	/* Height */
		890	if (target == GL_TEXTURE_RECTANGLE_NV \|\|
		891	target == GL_PROXY_TEXTURE_RECTANGLE_NV) {
		892	if (height < 1 \|\| height > ctx->Const.MaxTextureRectSize) {
		893	if (!isProxy) {
		894	_mesa_error(ctx, GL_INVALID_VALUE,
		895	"glTexImage%dD(height=%d)", dimensions, height);
		896	}
		897	return GL_TRUE;
		898	}
		899	}
		900	else if (dimensions >= 2) {
		901	if (height < 2 * border \|\| height > 2 + maxTextureSize
		902	\|\| logbase2( height - 2 * border ) < 0) {
		903	if (!isProxy) {
		904	_mesa_error(ctx, GL_INVALID_VALUE,
		905	"glTexImage%dD(height=%d)", dimensions, height);
		906	}
		907	return GL_TRUE;
		908	}
		909	}
		910
		911	/* For cube map, width must equal height */
		912	if (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&
		913	target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB) {
		914	if (width != height) {
		915	if (!isProxy) {
		916	_mesa_error(ctx, GL_INVALID_VALUE, "glTexImage2D(width != height)");
		917	}
		918	return GL_TRUE;
		919	}
		920	}
		921
		922	/* Depth */
		923	if (dimensions >= 3) {
		924	if (depth < 2 * border \|\| depth > 2 + maxTextureSize
		925	\|\| logbase2( depth - 2 * border ) < 0) {
		926	if (!isProxy) {
		927	_mesa_error( ctx, GL_INVALID_VALUE,
		928	"glTexImage3D(depth=%d)", depth );
		929	}
		930	return GL_TRUE;
		931	}
		932	}
		933
		934	/* Level */
		935	if (target == GL_TEXTURE_RECTANGLE_NV \|\|
		936	target == GL_PROXY_TEXTURE_RECTANGLE_NV) {
		937	if (level != 0) {
		938	if (!isProxy) {
		939	_mesa_error(ctx, GL_INVALID_VALUE,
		940	"glTexImage2D(level=%d)", level);
		941	}
		942	return GL_TRUE;
		943	}
		944	}
		945	else if (level < 0 \|\| level >= maxLevels) {
		946	if (!isProxy) {
		947	_mesa_error(ctx, GL_INVALID_VALUE,
		948	"glTexImage%dD(level=%d)", dimensions, level);
		949	}
		950	return GL_TRUE;
		951	}
		952
		953	/* For cube map, width must equal height */
		954	if (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&
		955	target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB) {
		956	if (width != height) {
		957	_mesa_error(ctx, GL_INVALID_VALUE, "glTexImage2D(width != height)");
		958	return GL_TRUE;
		959	}
		960	}
		961
		962	if (_mesa_base_tex_format(ctx, internalFormat) < 0) {
		963	if (!isProxy) {
		964	_mesa_error(ctx, GL_INVALID_VALUE,
		965	"glTexImage%dD(internalFormat=0x%x)",
		966	dimensions, internalFormat);
		967	}
		968	return GL_TRUE;
		969	}
		970
		971	if (!_mesa_is_legal_format_and_type(format, type)) {
		972	/* Yes, generate GL_INVALID_OPERATION, not GL_INVALID_ENUM, if there
		973	* is a type/format mismatch. See 1.2 spec page 94, sec 3.6.4.
		974	*/
		975	if (!isProxy) {
		976	_mesa_error(ctx, GL_INVALID_OPERATION,
		977	"glTexImage%dD(format or type)", dimensions);
		978	}
		979	return GL_TRUE;
		980	}
		981
		982	if (format == GL_YCBCR_MESA \|\| internalFormat == GL_YCBCR_MESA) {
		983	ASSERT(ctx->Extensions.MESA_ycbcr_texture);
		984	if (format != GL_YCBCR_MESA \|\|
		985	internalFormat != GL_YCBCR_MESA \|\|
		986	(type != GL_UNSIGNED_SHORT_8_8_MESA &&
		987	type != GL_UNSIGNED_SHORT_8_8_REV_MESA)) {
		988	char message[100];
		989	_mesa_sprintf(message,
		990	"glTexImage%d(format/type/internalFormat YCBCR mismatch",
		991	dimensions);
		992	_mesa_error(ctx, GL_INVALID_ENUM, message);
		993	return GL_TRUE; /* error */
		994	}
		995	if (target != GL_TEXTURE_2D &&
		996	target != GL_PROXY_TEXTURE_2D &&
		997	target != GL_TEXTURE_RECTANGLE_NV &&
		998	target != GL_PROXY_TEXTURE_RECTANGLE_NV) {
		999	if (!isProxy)
		1000	_mesa_error(ctx, GL_INVALID_ENUM, "glTexImage(target)");
		1001	return GL_TRUE;
		1002	}
		1003	if (border != 0) {
		1004	if (!isProxy) {
		1005	char message[100];
		1006	_mesa_sprintf(message,
		1007	"glTexImage%d(format=GL_YCBCR_MESA and border=%d)",
		1008	dimensions, border);
		1009	_mesa_error(ctx, GL_INVALID_VALUE, message);
		1010	}
		1011	return GL_TRUE;
		1012	}
		1013	}
		1014
		1015	if (is_compressed_format(internalFormat)) {
		1016	if (target == GL_TEXTURE_2D \|\| target == GL_PROXY_TEXTURE_2D) {
		1017	/* OK */
		1018	}
		1019	else if (ctx->Extensions.ARB_texture_cube_map &&
		1020	(target == GL_PROXY_TEXTURE_CUBE_MAP \|\|
		1021	(target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X &&
		1022	target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z))) {
		1023	/* OK */
		1024	}
		1025	else {
		1026	if (!isProxy) {
		1027	_mesa_error(ctx, GL_INVALID_ENUM,
		1028	"glTexImage%d(target)", dimensions);
		1029	return GL_TRUE;
		1030	}
		1031	}
		1032	if (border != 0) {
		1033	if (!isProxy) {
		1034	_mesa_error(ctx, GL_INVALID_OPERATION,
		1035	"glTexImage%D(border!=0)", dimensions);
		1036	}
		1037	return GL_TRUE;
		1038	}
		1039	}
		1040
		1041	/* if we get here, the parameters are OK */
		1042	return GL_FALSE;
		1043	}
		1044
		1045
		1046
		1047	/*
		1048	* Test glTexSubImage[123]D() parameters for errors.
		1049	* Input:
		1050	* dimensions - must be 1 or 2 or 3
		1051	* Return: GL_TRUE = an error was detected, GL_FALSE = no errors
		1052	*/
		1053	static GLboolean
		1054	subtexture_error_check( GLcontext *ctx, GLuint dimensions,
		1055	GLenum target, GLint level,
		1056	GLint xoffset, GLint yoffset, GLint zoffset,
		1057	GLint width, GLint height, GLint depth,
		1058	GLenum format, GLenum type )
		1059	{
		1060	struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
		1061	struct gl_texture_image *destTex;
		1062	GLint maxLevels = 0;
		1063
		1064	if (dimensions == 1) {
		1065	if (target == GL_TEXTURE_1D) {
		1066	maxLevels = ctx->Const.MaxTextureLevels;
		1067	}
		1068	else {
		1069	_mesa_error( ctx, GL_INVALID_ENUM, "glTexSubImage1D(target)" );
		1070	return GL_TRUE;
		1071	}
		1072	}
		1073	else if (dimensions == 2) {
		1074	if (ctx->Extensions.ARB_texture_cube_map &&
		1075	target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&
		1076	target <=GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB) {
		1077	maxLevels = ctx->Const.MaxCubeTextureLevels;
		1078	}
		1079	else if (ctx->Extensions.NV_texture_rectangle &&
		1080	target == GL_TEXTURE_RECTANGLE_NV) {
		1081	maxLevels = 1;
		1082	}
		1083	else if (target == GL_TEXTURE_2D) {
		1084	maxLevels = ctx->Const.MaxTextureLevels;
		1085	}
		1086	else {
		1087	_mesa_error( ctx, GL_INVALID_ENUM, "glTexSubImage2D(target)" );
		1088	return GL_TRUE;
		1089	}
		1090	}
		1091	else if (dimensions == 3) {
		1092	if (target == GL_TEXTURE_3D) {
		1093	maxLevels = ctx->Const.Max3DTextureLevels;
		1094	}
		1095	else {
		1096	_mesa_error( ctx, GL_INVALID_ENUM, "glTexSubImage3D(target)" );
		1097	return GL_TRUE;
		1098	}
		1099	}
		1100	else {
		1101	_mesa_problem( ctx, "bad dims in texture_error_check" );
		1102	return GL_TRUE;
		1103	}
		1104
		1105	ASSERT(maxLevels > 0);
		1106
		1107	if (level < 0 \|\| level >= maxLevels) {
		1108	_mesa_error(ctx, GL_INVALID_ENUM, "glTexSubImage2D(level=%d)", level);
		1109	return GL_TRUE;
		1110	}
		1111
		1112	if (width < 0) {
		1113	_mesa_error(ctx, GL_INVALID_VALUE,
		1114	"glTexSubImage%dD(width=%d)", dimensions, width);
		1115	return GL_TRUE;
		1116	}
		1117	if (height < 0 && dimensions > 1) {
		1118	_mesa_error(ctx, GL_INVALID_VALUE,
		1119	"glTexSubImage%dD(height=%d)", dimensions, height);
		1120	return GL_TRUE;
		1121	}
		1122	if (depth < 0 && dimensions > 2) {
		1123	_mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage%dD(depth=%d)", dimensions, depth);
		1124	return GL_TRUE;
		1125	}
		1126
		1127	destTex = _mesa_select_tex_image(ctx, texUnit, target, level);
		1128
		1129	if (!destTex) {
		1130	_mesa_error(ctx, GL_INVALID_OPERATION, "glTexSubImage2D");
		1131	return GL_TRUE;
		1132	}
		1133
		1134	if (xoffset < -((GLint)destTex->Border)) {
		1135	_mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage1/2/3D(xoffset)");
		1136	return GL_TRUE;
		1137	}
		1138	if (xoffset + width > (GLint) (destTex->Width + destTex->Border)) {
		1139	_mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage1/2/3D(xoffset+width)");
		1140	return GL_TRUE;
		1141	}
		1142	if (dimensions > 1) {
		1143	if (yoffset < -((GLint)destTex->Border)) {
		1144	_mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage2/3D(yoffset)");
		1145	return GL_TRUE;
		1146	}
		1147	if (yoffset + height > (GLint) (destTex->Height + destTex->Border)) {
		1148	_mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage2/3D(yoffset+height)");
		1149	return GL_TRUE;
		1150	}
		1151	}
		1152	if (dimensions > 2) {
		1153	if (zoffset < -((GLint)destTex->Border)) {
		1154	_mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage3D(zoffset)");
		1155	return GL_TRUE;
		1156	}
		1157	if (zoffset + depth > (GLint) (destTex->Depth + destTex->Border)) {
		1158	_mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage3D(zoffset+depth)");
		1159	return GL_TRUE;
		1160	}
		1161	}
		1162
		1163	if (!_mesa_is_legal_format_and_type(format, type)) {
		1164	_mesa_error(ctx, GL_INVALID_ENUM,
		1165	"glTexSubImage%dD(format or type)", dimensions);
		1166	return GL_TRUE;
		1167	}
		1168
		1169	if (destTex->IsCompressed) {
		1170	const struct gl_texture_unit *texUnit;
		1171	const struct gl_texture_object *texObj;
		1172	const struct gl_texture_image *texImage;
		1173	texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
		1174	texObj = _mesa_select_tex_object(ctx, texUnit, target);
		1175	texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
		1176
		1177	if (target == GL_TEXTURE_2D \|\| target == GL_PROXY_TEXTURE_2D) {
		1178	/* OK */
		1179	}
		1180	else if (ctx->Extensions.ARB_texture_cube_map &&
		1181	(target == GL_PROXY_TEXTURE_CUBE_MAP \|\|
		1182	(target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X &&
		1183	target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z))) {
		1184	/* OK */
		1185	}
		1186	else {
		1187	_mesa_error(ctx, GL_INVALID_ENUM,
		1188	"glTexSubImage%D(target)", dimensions);
		1189	return GL_TRUE;
		1190	}
		1191	/* offset must be multiple of 4 */
		1192	if ((xoffset & 3) \|\| (yoffset & 3)) {
		1193	_mesa_error(ctx, GL_INVALID_OPERATION,
		1194	"glTexSubImage%D(xoffset or yoffset)", dimensions);
		1195	return GL_TRUE;
		1196	}
		1197	/* size must be multiple of 4 or equal to whole texture size */
		1198	if ((width & 3) && (GLuint) width != texImage->Width) {
		1199	_mesa_error(ctx, GL_INVALID_OPERATION,
		1200	"glTexSubImage%D(width)", dimensions);
		1201	return GL_TRUE;
		1202	}
		1203	if ((height & 3) && (GLuint) height != texImage->Height) {
		1204	_mesa_error(ctx, GL_INVALID_OPERATION,
		1205	"glTexSubImage%D(width)", dimensions);
		1206	return GL_TRUE;
		1207	}
		1208	}
		1209
		1210	return GL_FALSE;
		1211	}
		1212
		1213
		1214	/*
		1215	* Test glCopyTexImage[12]D() parameters for errors.
		1216	* Input: dimensions - must be 1 or 2 or 3
		1217	* Return: GL_TRUE = an error was detected, GL_FALSE = no errors
		1218	*/
		1219	static GLboolean
		1220	copytexture_error_check( GLcontext *ctx, GLuint dimensions,
		1221	GLenum target, GLint level, GLint internalFormat,
		1222	GLint width, GLint height, GLint border )
		1223	{
		1224	GLint maxLevels = 0, maxTextureSize;
		1225
		1226	if (dimensions == 1) {
		1227	if (target != GL_TEXTURE_1D) {
		1228	_mesa_error( ctx, GL_INVALID_ENUM, "glCopyTexImage1D(target)" );
		1229	return GL_TRUE;
		1230	}
		1231	maxLevels = ctx->Const.MaxTextureLevels;
		1232	}
		1233	else if (dimensions == 2) {
		1234	if (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&
		1235	target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB) {
		1236	if (!ctx->Extensions.ARB_texture_cube_map) {
		1237	_mesa_error( ctx, GL_INVALID_ENUM, "glCopyTexImage2D(target)" );
		1238	return GL_TRUE;
		1239	}
		1240	}
		1241	else if (target == GL_TEXTURE_RECTANGLE_NV) {
		1242	if (!ctx->Extensions.NV_texture_rectangle) {
		1243	_mesa_error( ctx, GL_INVALID_ENUM, "glCopyTexImage2D(target)" );
		1244	return GL_TRUE;
		1245	}
		1246	}
		1247	else if (target != GL_TEXTURE_2D) {
		1248	_mesa_error( ctx, GL_INVALID_ENUM, "glCopyTexImage2D(target)" );
		1249	return GL_TRUE;
		1250	}
		1251	if (target == GL_TEXTURE_2D)
		1252	maxLevels = ctx->Const.MaxTextureLevels;
		1253	else if (target == GL_TEXTURE_RECTANGLE_NV)
		1254	maxLevels = 1;
		1255	else
		1256	maxLevels = ctx->Const.MaxCubeTextureLevels;
		1257	}
		1258
		1259	ASSERT(maxLevels > 0);
		1260	maxTextureSize = 1 << (maxLevels - 1);
		1261
		1262	/* Border */
		1263	if (border != 0 && border != 1) {
		1264	_mesa_error(ctx, GL_INVALID_VALUE,
		1265	"glCopyTexImage%dD(border)", dimensions);
		1266	return GL_TRUE;
		1267	}
		1268
		1269	/* Width */
		1270	if (width < 2 * border \|\| width > 2 + maxTextureSize
		1271	\|\| logbase2( width - 2 * border ) < 0) {
		1272	_mesa_error(ctx, GL_INVALID_VALUE,
		1273	"glCopyTexImage%dD(width=%d)", dimensions, width);
		1274	return GL_TRUE;
		1275	}
		1276
		1277	/* Height */
		1278	if (dimensions >= 2) {
		1279	if (height < 2 * border \|\| height > 2 + maxTextureSize
		1280	\|\| logbase2( height - 2 * border ) < 0) {
		1281	_mesa_error(ctx, GL_INVALID_VALUE,
		1282	"glCopyTexImage%dD(height=%d)", dimensions, height);
		1283	return GL_TRUE;
		1284	}
		1285	}
		1286
		1287	/* For cube map, width must equal height */
		1288	if (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&
		1289	target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB) {
		1290	if (width != height) {
		1291	_mesa_error(ctx, GL_INVALID_VALUE, "glCopyTexImage2D(width != height)");
		1292	return GL_TRUE;
		1293	}
		1294	}
		1295
		1296	/* Level */
		1297	if (level < 0 \|\| level >= maxLevels) {
		1298	_mesa_error(ctx, GL_INVALID_VALUE,
		1299	"glCopyTexImage%dD(level=%d)", dimensions, level);
		1300	return GL_TRUE;
		1301	}
		1302
		1303	if (_mesa_base_tex_format(ctx, internalFormat) < 0) {
		1304	_mesa_error(ctx, GL_INVALID_VALUE,
		1305	"glCopyTexImage%dD(internalFormat)", dimensions);
		1306	return GL_TRUE;
		1307	}
		1308
		1309	if (is_compressed_format(internalFormat)) {
		1310	if (target != GL_TEXTURE_2D) {
		1311	_mesa_error(ctx, GL_INVALID_ENUM,
		1312	"glCopyTexImage%d(target)", dimensions);
		1313	return GL_TRUE;
		1314	}
		1315	if (border != 0) {
		1316	_mesa_error(ctx, GL_INVALID_OPERATION,
		1317	"glCopyTexImage%D(border!=0)", dimensions);
		1318	return GL_TRUE;
		1319	}
		1320	}
		1321
		1322	/* if we get here, the parameters are OK */
		1323	return GL_FALSE;
		1324	}
		1325
		1326
		1327	static GLboolean
		1328	copytexsubimage_error_check( GLcontext *ctx, GLuint dimensions,
		1329	GLenum target, GLint level,
		1330	GLint xoffset, GLint yoffset, GLint zoffset,
		1331	GLsizei width, GLsizei height )
		1332	{
		1333	struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
		1334	struct gl_texture_image *teximage;
		1335	GLint maxLevels = 0;
		1336
		1337	if (dimensions == 1) {
		1338	if (target != GL_TEXTURE_1D) {
		1339	_mesa_error( ctx, GL_INVALID_ENUM, "glCopyTexSubImage1D(target)" );
		1340	return GL_TRUE;
		1341	}
		1342	maxLevels = ctx->Const.MaxTextureLevels;
		1343	}
		1344	else if (dimensions == 2) {
		1345	if (ctx->Extensions.ARB_texture_cube_map) {
		1346	if ((target < GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB \|\|
		1347	target > GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB) &&
		1348	target != GL_TEXTURE_2D) {
		1349	_mesa_error( ctx, GL_INVALID_ENUM, "glCopyTexSubImage2D(target)" );
		1350	return GL_TRUE;
		1351	}
		1352	}
		1353	else if (target != GL_TEXTURE_2D) {
		1354	_mesa_error( ctx, GL_INVALID_ENUM, "glCopyTexSubImage2D(target)" );
		1355	return GL_TRUE;
		1356	}
		1357	if (target == GL_PROXY_TEXTURE_2D && target == GL_TEXTURE_2D)
		1358	maxLevels = ctx->Const.MaxTextureLevels;
		1359	else
		1360	maxLevels = ctx->Const.MaxCubeTextureLevels;
		1361	}
		1362	else if (dimensions == 3) {
		1363	if (target != GL_TEXTURE_3D) {
		1364	_mesa_error( ctx, GL_INVALID_ENUM, "glCopyTexSubImage3D(target)" );
		1365	return GL_TRUE;
		1366	}
		1367	maxLevels = ctx->Const.Max3DTextureLevels;
		1368	}
		1369
		1370	ASSERT(maxLevels > 0);
		1371
		1372	if (level < 0 \|\| level >= maxLevels) {
		1373	_mesa_error(ctx, GL_INVALID_VALUE,
		1374	"glCopyTexSubImage%dD(level=%d)", dimensions, level);
		1375	return GL_TRUE;
		1376	}
		1377
		1378	if (width < 0) {
		1379	_mesa_error(ctx, GL_INVALID_VALUE,
		1380	"glCopyTexSubImage%dD(width=%d)", dimensions, width);
		1381	return GL_TRUE;
		1382	}
		1383	if (dimensions > 1 && height < 0) {
		1384	_mesa_error(ctx, GL_INVALID_VALUE,
		1385	"glCopyTexSubImage%dD(height=%d)", dimensions, height);
		1386	return GL_TRUE;
		1387	}
		1388
		1389	teximage = _mesa_select_tex_image(ctx, texUnit, target, level);
		1390	if (!teximage) {
		1391	_mesa_error(ctx, GL_INVALID_OPERATION,
		1392	"glCopyTexSubImage%dD(undefined texture level: %d)",
		1393	dimensions, level);
		1394	return GL_TRUE;
		1395	}
		1396
		1397	if (xoffset < -((GLint)teximage->Border)) {
		1398	_mesa_error(ctx, GL_INVALID_VALUE,
		1399	"glCopyTexSubImage%dD(xoffset=%d)", dimensions, xoffset);
		1400	return GL_TRUE;
		1401	}
		1402	if (xoffset + width > (GLint) (teximage->Width + teximage->Border)) {
		1403	_mesa_error(ctx, GL_INVALID_VALUE,
		1404	"glCopyTexSubImage%dD(xoffset+width)", dimensions);
		1405	return GL_TRUE;
		1406	}
		1407	if (dimensions > 1) {
		1408	if (yoffset < -((GLint)teximage->Border)) {
		1409	_mesa_error(ctx, GL_INVALID_VALUE,
		1410	"glCopyTexSubImage%dD(yoffset=%d)", dimensions, yoffset);
		1411	return GL_TRUE;
		1412	}
		1413	/* NOTE: we're adding the border here, not subtracting! */
		1414	if (yoffset + height > (GLint) (teximage->Height + teximage->Border)) {
		1415	_mesa_error(ctx, GL_INVALID_VALUE,
		1416	"glCopyTexSubImage%dD(yoffset+height)", dimensions);
		1417	return GL_TRUE;
		1418	}
		1419	}
		1420
		1421	if (dimensions > 2) {
		1422	if (zoffset < -((GLint)teximage->Border)) {
		1423	_mesa_error(ctx, GL_INVALID_VALUE,
		1424	"glCopyTexSubImage%dD(zoffset)", dimensions);
		1425	return GL_TRUE;
		1426	}
		1427	if (zoffset > (GLint) (teximage->Depth + teximage->Border)) {
		1428	_mesa_error(ctx, GL_INVALID_VALUE,
		1429	"glCopyTexSubImage%dD(zoffset+depth)", dimensions);
		1430	return GL_TRUE;
		1431	}
		1432	}
		1433
		1434	if (teximage->IsCompressed) {
		1435	if (target != GL_TEXTURE_2D) {
		1436	_mesa_error(ctx, GL_INVALID_ENUM,
		1437	"glCopyTexSubImage%d(target)", dimensions);
		1438	return GL_TRUE;
		1439	}
		1440	/* offset must be multiple of 4 */
		1441	if ((xoffset & 3) \|\| (yoffset & 3)) {
		1442	_mesa_error(ctx, GL_INVALID_VALUE,
		1443	"glCopyTexSubImage%D(xoffset or yoffset)", dimensions);
		1444	return GL_TRUE;
		1445	}
		1446	/* size must be multiple of 4 */
		1447	if ((width & 3) != 0 && (GLuint) width != teximage->Width) {
		1448	_mesa_error(ctx, GL_INVALID_VALUE,
		1449	"glCopyTexSubImage%D(width)", dimensions);
		1450	return GL_TRUE;
		1451	}
		1452	if ((height & 3) != 0 && (GLuint) height != teximage->Height) {
		1453	_mesa_error(ctx, GL_INVALID_VALUE,
		1454	"glCopyTexSubImage%D(height)", dimensions);
		1455	return GL_TRUE;
		1456	}
		1457	}
		1458
		1459	if (teximage->IntFormat == GL_YCBCR_MESA) {
		1460	_mesa_error(ctx, GL_INVALID_OPERATION, "glCopyTexSubImage2D");
		1461	return GL_TRUE;
		1462	}
		1463
		1464	/* if we get here, the parameters are OK */
		1465	return GL_FALSE;
		1466	}
		1467
		1468
		1469
		1470	void
		1471	_mesa_GetTexImage( GLenum target, GLint level, GLenum format,
		1472	GLenum type, GLvoid *pixels )
		1473	{
		1474	const struct gl_texture_unit *texUnit;
		1475	const struct gl_texture_object *texObj;
		1476	const struct gl_texture_image *texImage;
		1477	GLint maxLevels = 0;
		1478	GET_CURRENT_CONTEXT(ctx);
		1479	ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
		1480
		1481	texUnit = &(ctx->Texture.Unit[ctx->Texture.CurrentUnit]);
		1482	texObj = _mesa_select_tex_object(ctx, texUnit, target);
		1483	if (!texObj \|\| is_proxy_target(target)) {
		1484	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(target)");
		1485	return;
		1486	}
		1487
		1488	maxLevels = _mesa_max_texture_levels(ctx, target);
		1489	ASSERT(maxLevels > 0); /* 0 indicates bad target, caught above */
		1490
		1491	if (level < 0 \|\| level >= maxLevels) {
		1492	_mesa_error( ctx, GL_INVALID_VALUE, "glGetTexImage(level)" );
		1493	return;
		1494	}
		1495
		1496	if (_mesa_sizeof_packed_type(type) <= 0) {
		1497	_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexImage(type)" );
		1498	return;
		1499	}
		1500
		1501	if (_mesa_components_in_format(format) <= 0 \|\|
		1502	format == GL_STENCIL_INDEX) {
		1503	_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexImage(format)" );
		1504	return;
		1505	}
		1506
		1507	if (!ctx->Extensions.EXT_paletted_texture && is_index_format(format)) {
		1508	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)");
		1509	}
		1510
		1511	if (!ctx->Extensions.SGIX_depth_texture && format == GL_DEPTH_COMPONENT) {
		1512	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)");
		1513	}
		1514
		1515	if (!ctx->Extensions.MESA_ycbcr_texture && format == GL_YCBCR_MESA) {
		1516	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)");
		1517	}
		1518
		1519	/* XXX what if format/type doesn't match texture format/type? */
		1520
		1521	if (!pixels)
		1522	return;
		1523
		1524	texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
		1525	if (!texImage) {
		1526	/* invalid mipmap level, not an error */
		1527	return;
		1528	}
		1529
		1530	if (!texImage->Data) {
		1531	/* no image data, not an error */
		1532	return;
		1533	}
		1534
		1535	{
		1536	const GLint width = texImage->Width;
		1537	const GLint height = texImage->Height;
		1538	const GLint depth = texImage->Depth;
		1539	GLint img, row;
		1540	for (img = 0; img < depth; img++) {
		1541	for (row = 0; row < height; row++) {
		1542	/* compute destination address in client memory */
		1543	GLvoid *dest = _mesa_image_address( &ctx->Pack, pixels,
		1544	width, height, format, type,
		1545	img, row, 0);
		1546	assert(dest);
		1547
		1548	if (format == GL_COLOR_INDEX) {
		1549	GLuint indexRow[MAX_WIDTH];
		1550	GLint col;
		1551	for (col = 0; col < width; col++) {
		1552	(*texImage->FetchTexel)(texImage, col, row, img,
		1553	(GLvoid *) &indexRow[col]);
		1554	}
		1555	_mesa_pack_index_span(ctx, width, type, dest,
		1556	indexRow, &ctx->Pack,
		1557
		1558	}
		1559	else if (format == GL_DEPTH_COMPONENT) {
		1560	GLfloat depthRow[MAX_WIDTH];
		1561	GLint col;
		1562	for (col = 0; col < width; col++) {
		1563	(*texImage->FetchTexel)(texImage, col, row, img,
		1564	(GLvoid *) &depthRow[col]);
		1565	}
		1566	_mesa_pack_depth_span(ctx, width, dest, type,
		1567	depthRow, &ctx->Pack);
		1568	}
		1569	else if (format == GL_YCBCR_MESA) {
		1570	/* No pixel transfer */
		1571	const GLint rowstride = texImage->RowStride;
		1572	MEMCPY(dest,
		1573	(const GLushort ) texImage->Data + row rowstride,
		1574	width * sizeof(GLushort));
		1575	/* check for byte swapping */
		1576	if ((texImage->TexFormat->MesaFormat == MESA_FORMAT_YCBCR
		1577	&& type == GL_UNSIGNED_SHORT_8_8_REV_MESA) \|\|
		1578	(texImage->TexFormat->MesaFormat == MESA_FORMAT_YCBCR_REV
		1579	&& type == GL_UNSIGNED_SHORT_8_8_MESA)) {
		1580	if (!ctx->Pack.SwapBytes)
		1581	_mesa_swap2((GLushort *) dest, width);
		1582	}
		1583	else if (ctx->Pack.SwapBytes) {
		1584	_mesa_swap2((GLushort *) dest, width);
		1585	}
		1586	}
		1587	else {
		1588	/* general case: convert row to RGBA format */
		1589	GLchan rgba[MAX_WIDTH][4];
		1590	GLint col;
		1591	for (col = 0; col < width; col++) {
		1592	(*texImage->FetchTexel)(texImage, col, row, img,
		1593	(GLvoid *) rgba[col]);
		1594	}
		1595	_mesa_pack_rgba_span(ctx, width, (const GLchan (*)[4])rgba,
		1596	format, type, dest, &ctx->Pack,
		1597
		1598	} /* format */
		1599	} /* row */
		1600	} /* img */
		1601	}
		1602	}
		1603
		1604
		1605
		1606	/*
		1607	* Called from the API. Note that width includes the border.
		1608	*/
		1609	void
		1610	_mesa_TexImage1D( GLenum target, GLint level, GLint internalFormat,
		1611	GLsizei width, GLint border, GLenum format,
		1612	GLenum type, const GLvoid *pixels )
		1613	{
		1614	GLsizei postConvWidth = width;
		1615	GET_CURRENT_CONTEXT(ctx);
		1616	ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
		1617
		1618	if (is_color_format(internalFormat)) {
		1619	_mesa_adjust_image_for_convolution(ctx, 1, &postConvWidth, NULL);
		1620	}
		1621
		1622	if (target == GL_TEXTURE_1D) {
		1623	struct gl_texture_unit *texUnit;
		1624	struct gl_texture_object *texObj;
		1625	struct gl_texture_image *texImage;
		1626
		1627	if (texture_error_check(ctx, target, level, internalFormat,
		1628	format, type, 1, postConvWidth, 1, 1, border)) {
		1629	return; /* error was recorded */
		1630	}
		1631
		1632	texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
		1633	texObj = _mesa_select_tex_object(ctx, texUnit, target);
		1634	texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
		1635
		1636	if (!texImage) {
		1637	texImage = _mesa_alloc_texture_image();
		1638	texObj->Image[level] = texImage;
		1639	if (!texImage) {
		1640	_mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage1D");
		1641	return;
		1642	}
		1643	}
		1644	else if (texImage->Data && !texImage->IsClientData) {
		1645	/* free the old texture data */
		1646	MESA_PBUFFER_FREE(texImage->Data);
		1647	}
		1648	texImage->Data = NULL;
		1649	clear_teximage_fields(texImage); /* not really needed, but helpful */
		1650	_mesa_init_teximage_fields(ctx, target, texImage,
		1651	postConvWidth, 1, 1,
		1652	border, internalFormat);
		1653
		1654	if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
		1655	_mesa_update_state(ctx);
		1656
		1657	ASSERT(ctx->Driver.TexImage1D);
		1658
		1659	/* Give the texture to the driver! <pixels> may be null! */
		1660	(*ctx->Driver.TexImage1D)(ctx, target, level, internalFormat,
		1661	width, border, format, type, pixels,
		1662	&ctx->Unpack, texObj, texImage);
		1663
		1664	ASSERT(texImage->TexFormat);
		1665	if (!texImage->FetchTexel) {
		1666	/* If driver didn't explicitly set this, use the default */
		1667	texImage->FetchTexel = texImage->TexFormat->FetchTexel1D;
		1668	}
		1669	ASSERT(texImage->FetchTexel);
		1670
		1671	/* state update */
		1672	texObj->Complete = GL_FALSE;
		1673	ctx->NewState \|= _NEW_TEXTURE;
		1674	}
		1675	else if (target == GL_PROXY_TEXTURE_1D) {
		1676	/* Proxy texture: check for errors and update proxy state */
		1677	GLboolean error = texture_error_check(ctx, target, level, internalFormat,
		1678	format, type, 1, postConvWidth, 1, 1, border);
		1679	if (!error) {
		1680	ASSERT(ctx->Driver.TestProxyTexImage);
		1681	error = !(*ctx->Driver.TestProxyTexImage)(ctx, target, level,
		1682	internalFormat, format, type,
		1683	postConvWidth, 1, 1, border);
		1684	}
		1685	if (error) {
		1686	/* if error, clear all proxy texture image parameters */
		1687	if (level >= 0 && level < ctx->Const.MaxTextureLevels) {
		1688	clear_teximage_fields(ctx->Texture.Proxy1D->Image[level]);
		1689	}
		1690	}
		1691	else {
		1692	/* no error, set the tex image parameters */
		1693	struct gl_texture_unit *texUnit;
		1694	struct gl_texture_image *texImage;
		1695	texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
		1696	texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
		1697	_mesa_init_teximage_fields(ctx, target, texImage,
		1698	postConvWidth, 1, 1,
		1699	border, internalFormat);
		1700	}
		1701	}
		1702	else {
		1703	_mesa_error( ctx, GL_INVALID_ENUM, "glTexImage1D(target)" );
		1704	return;
		1705	}
		1706	}
		1707
		1708
		1709	void
		1710	_mesa_TexImage2D( GLenum target, GLint level, GLint internalFormat,
		1711	GLsizei width, GLsizei height, GLint border,
		1712	GLenum format, GLenum type,
		1713	const GLvoid *pixels )
		1714	{
		1715	GLsizei postConvWidth = width, postConvHeight = height;
		1716	GET_CURRENT_CONTEXT(ctx);
		1717	ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
		1718
		1719	if (is_color_format(internalFormat)) {
		1720	_mesa_adjust_image_for_convolution(ctx, 2, &postConvWidth,
		1721	&postConvHeight);
		1722	}
		1723
		1724	if (target == GL_TEXTURE_2D \|\|
		1725	(ctx->Extensions.ARB_texture_cube_map &&
		1726	target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&
		1727	target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB) \|\|
		1728	(ctx->Extensions.NV_texture_rectangle &&
		1729	target == GL_TEXTURE_RECTANGLE_NV)) {
		1730	/* non-proxy target */
		1731	struct gl_texture_unit *texUnit;
		1732	struct gl_texture_object *texObj;
		1733	struct gl_texture_image *texImage;
		1734
		1735	if (texture_error_check(ctx, target, level, internalFormat,
		1736	format, type, 2, postConvWidth, postConvHeight,
		1737	1, border)) {
		1738	return; /* error was recorded */
		1739	}
		1740
		1741	texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
		1742	texObj = _mesa_select_tex_object(ctx, texUnit, target);
		1743	texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
		1744
		1745	if (!texImage) {
		1746	texImage = _mesa_alloc_texture_image();
		1747	_mesa_set_tex_image(texObj, target, level, texImage);
		1748	if (!texImage) {
		1749	_mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage2D");
		1750	return;
		1751	}
		1752	}
		1753	else if (texImage->Data && !texImage->IsClientData) {
		1754	/* free the old texture data */
		1755	MESA_PBUFFER_FREE(texImage->Data);
		1756	}
		1757	texImage->Data = NULL;
		1758	clear_teximage_fields(texImage); /* not really needed, but helpful */
		1759	_mesa_init_teximage_fields(ctx, target, texImage,
		1760	postConvWidth, postConvHeight, 1,
		1761	border, internalFormat);
		1762
		1763	if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
		1764	_mesa_update_state(ctx);
		1765
		1766	ASSERT(ctx->Driver.TexImage2D);
		1767
		1768	/* Give the texture to the driver! <pixels> may be null! */
		1769	(*ctx->Driver.TexImage2D)(ctx, target, level, internalFormat,
		1770	width, height, border, format, type, pixels,
		1771	&ctx->Unpack, texObj, texImage);
		1772
		1773	ASSERT(texImage->TexFormat);
		1774	if (!texImage->FetchTexel) {
		1775	/* If driver didn't explicitly set this, use the default */
		1776	texImage->FetchTexel = texImage->TexFormat->FetchTexel2D;
		1777	}
		1778	ASSERT(texImage->FetchTexel);
		1779
		1780	/* state update */
		1781	texObj->Complete = GL_FALSE;
		1782	ctx->NewState \|= _NEW_TEXTURE;
		1783	}
		1784	else if (target == GL_PROXY_TEXTURE_2D \|\|
		1785	(target == GL_PROXY_TEXTURE_CUBE_MAP_ARB &&
		1786	ctx->Extensions.ARB_texture_cube_map) \|\|
		1787	(target == GL_PROXY_TEXTURE_RECTANGLE_NV &&
		1788	ctx->Extensions.NV_texture_rectangle)) {
		1789	/* Proxy texture: check for errors and update proxy state */
		1790	GLboolean error = texture_error_check(ctx, target, level, internalFormat,
		1791	format, type, 2, postConvWidth, postConvHeight, 1, border);
		1792	if (!error) {
		1793	ASSERT(ctx->Driver.TestProxyTexImage);
		1794	error = !(*ctx->Driver.TestProxyTexImage)(ctx, target, level,
		1795	internalFormat, format, type,
		1796	postConvWidth, postConvHeight, 1, border);
		1797	}
		1798	if (error) {
		1799	/* if error, clear all proxy texture image parameters */
		1800	const GLint maxLevels = (target == GL_PROXY_TEXTURE_2D) ?
		1801	ctx->Const.MaxTextureLevels : ctx->Const.MaxCubeTextureLevels;
		1802	if (level >= 0 && level < maxLevels) {
		1803	clear_teximage_fields(ctx->Texture.Proxy2D->Image[level]);
		1804	}
		1805	}
		1806	else {
		1807	/* no error, set the tex image parameters */
		1808	struct gl_texture_unit *texUnit;
		1809	struct gl_texture_image *texImage;
		1810	texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
		1811	texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
		1812	_mesa_init_teximage_fields(ctx, target, texImage,
		1813	postConvWidth, postConvHeight, 1,
		1814	border, internalFormat);
		1815	}
		1816	}
		1817	else {
		1818	_mesa_error( ctx, GL_INVALID_ENUM, "glTexImage2D(target)" );
		1819	return;
		1820	}
		1821	}
		1822
		1823
		1824	/*
		1825	* Called by the API or display list executor.
		1826	* Note that width and height include the border.
		1827	*/
		1828	void
		1829	_mesa_TexImage3D( GLenum target, GLint level, GLint internalFormat,
		1830	GLsizei width, GLsizei height, GLsizei depth,
		1831	GLint border, GLenum format, GLenum type,
		1832	const GLvoid *pixels )
		1833	{
		1834	GET_CURRENT_CONTEXT(ctx);
		1835	ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
		1836
		1837	if (target == GL_TEXTURE_3D) {
		1838	struct gl_texture_unit *texUnit;
		1839	struct gl_texture_object *texObj;
		1840	struct gl_texture_image *texImage;
		1841
		1842	if (texture_error_check(ctx, target, level, (GLint) internalFormat,
		1843	format, type, 3, width, height, depth, border)) {
		1844	return; /* error was recorded */
		1845	}
		1846
		1847	texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
		1848	texObj = _mesa_select_tex_object(ctx, texUnit, target);
		1849	texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
		1850
		1851	if (!texImage) {
		1852	texImage = _mesa_alloc_texture_image();
		1853	texObj->Image[level] = texImage;
		1854	if (!texImage) {
		1855	_mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage3D");
		1856	return;
		1857	}
		1858	}
		1859	else if (texImage->Data && !texImage->IsClientData) {
		1860	MESA_PBUFFER_FREE(texImage->Data);
		1861	}
		1862	texImage->Data = NULL;
		1863	clear_teximage_fields(texImage); /* not really needed, but helpful */
		1864	_mesa_init_teximage_fields(ctx, target, texImage,
		1865	width, height, depth,
		1866	border, internalFormat);
		1867
		1868	if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
		1869	_mesa_update_state(ctx);
		1870
		1871	ASSERT(ctx->Driver.TexImage3D);
		1872
		1873	/* Give the texture to the driver! <pixels> may be null! */
		1874	(*ctx->Driver.TexImage3D)(ctx, target, level, internalFormat,
		1875	width, height, depth, border, format, type,
		1876	pixels, &ctx->Unpack, texObj, texImage);
		1877
		1878	ASSERT(texImage->TexFormat);
		1879	if (!texImage->FetchTexel) {
		1880	/* If driver didn't explicitly set this, use the default */
		1881	texImage->FetchTexel = texImage->TexFormat->FetchTexel3D;
		1882	}
		1883	ASSERT(texImage->FetchTexel);
		1884
		1885	/* state update */
		1886	texObj->Complete = GL_FALSE;
		1887	ctx->NewState \|= _NEW_TEXTURE;
		1888	}
		1889	else if (target == GL_PROXY_TEXTURE_3D) {
		1890	/* Proxy texture: check for errors and update proxy state */
		1891	GLboolean error = texture_error_check(ctx, target, level, internalFormat,
		1892	format, type, 3, width, height, depth, border);
		1893	if (!error) {
		1894	ASSERT(ctx->Driver.TestProxyTexImage);
		1895	error = !(*ctx->Driver.TestProxyTexImage)(ctx, target, level,
		1896	internalFormat, format, type,
		1897	width, height, depth, border);
		1898	}
		1899	if (error) {
		1900	/* if error, clear all proxy texture image parameters */
		1901	if (level >= 0 && level < ctx->Const.Max3DTextureLevels) {
		1902	clear_teximage_fields(ctx->Texture.Proxy3D->Image[level]);
		1903	}
		1904	}
		1905	else {
		1906	/* no error, set the tex image parameters */
		1907	struct gl_texture_unit *texUnit;
		1908	struct gl_texture_image *texImage;
		1909	texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
		1910	texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
		1911	_mesa_init_teximage_fields(ctx, target, texImage, width, height, 1,
		1912	border, internalFormat);
		1913	}
		1914	}
		1915	else {
		1916	_mesa_error( ctx, GL_INVALID_ENUM, "glTexImage3D(target)" );
		1917	return;
		1918	}
		1919	}
		1920
		1921
		1922	void
		1923	_mesa_TexImage3DEXT( GLenum target, GLint level, GLenum internalFormat,
		1924	GLsizei width, GLsizei height, GLsizei depth,
		1925	GLint border, GLenum format, GLenum type,
		1926	const GLvoid *pixels )
		1927	{
		1928	_mesa_TexImage3D(target, level, (GLint) internalFormat, width, height,
		1929	depth, border, format, type, pixels);
		1930	}
		1931
		1932
		1933
		1934	void
		1935	_mesa_TexSubImage1D( GLenum target, GLint level,
		1936	GLint xoffset, GLsizei width,
		1937	GLenum format, GLenum type,
		1938	const GLvoid *pixels )
		1939	{
		1940	GLsizei postConvWidth = width;
		1941	struct gl_texture_unit *texUnit;
		1942	struct gl_texture_object *texObj;
		1943	struct gl_texture_image *texImage;
		1944	GET_CURRENT_CONTEXT(ctx);
		1945	ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
		1946
		1947	if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
		1948	_mesa_update_state(ctx);
		1949
		1950	/* XXX should test internal format */
		1951	if (is_color_format(format)) {
		1952	_mesa_adjust_image_for_convolution(ctx, 1, &postConvWidth, NULL);
		1953	}
		1954
		1955	if (subtexture_error_check(ctx, 1, target, level, xoffset, 0, 0,
		1956	postConvWidth, 1, 1, format, type)) {
		1957	return; /* error was detected */
		1958	}
		1959
		1960	texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
		1961	texObj = _mesa_select_tex_object(ctx, texUnit, target);
		1962	texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
		1963	assert(texImage);
		1964
		1965	if (width == 0 \|\| !pixels)
		1966	return; /* no-op, not an error */
		1967
		1968	/* If we have a border, xoffset=-1 is legal. Bias by border width */
		1969	xoffset += texImage->Border;
		1970
		1971	ASSERT(ctx->Driver.TexSubImage1D);
		1972	(*ctx->Driver.TexSubImage1D)(ctx, target, level, xoffset, width,
		1973	format, type, pixels, &ctx->Unpack,
		1974	texObj, texImage);
		1975	ctx->NewState \|= _NEW_TEXTURE;
		1976	}
		1977
		1978
		1979	void
		1980	_mesa_TexSubImage2D( GLenum target, GLint level,
		1981	GLint xoffset, GLint yoffset,
		1982	GLsizei width, GLsizei height,
		1983	GLenum format, GLenum type,
		1984	const GLvoid *pixels )
		1985	{
		1986	GLsizei postConvWidth = width, postConvHeight = height;
		1987	struct gl_texture_unit *texUnit;
		1988	struct gl_texture_object *texObj;
		1989	struct gl_texture_image *texImage;
		1990	GET_CURRENT_CONTEXT(ctx);
		1991	ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
		1992
		1993	if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
		1994	_mesa_update_state(ctx);
		1995
		1996	/* XXX should test internal format */
		1997	if (is_color_format(format)) {
		1998	_mesa_adjust_image_for_convolution(ctx, 2, &postConvWidth,
		1999	&postConvHeight);
		2000	}
		2001
		2002	if (subtexture_error_check(ctx, 2, target, level, xoffset, yoffset, 0,
		2003	postConvWidth, postConvHeight, 1, format, type)) {
		2004	return; /* error was detected */
		2005	}
		2006
		2007	texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
		2008	texObj = _mesa_select_tex_object(ctx, texUnit, target);
		2009	texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
		2010	assert(texImage);
		2011
		2012	if (width == 0 \|\| height == 0 \|\| !pixels)
		2013	return; /* no-op, not an error */
		2014
		2015	/* If we have a border, xoffset=-1 is legal. Bias by border width */
		2016	xoffset += texImage->Border;
		2017	yoffset += texImage->Border;
		2018
		2019	ASSERT(ctx->Driver.TexSubImage2D);
		2020	(*ctx->Driver.TexSubImage2D)(ctx, target, level, xoffset, yoffset,
		2021	width, height, format, type, pixels,
		2022	&ctx->Unpack, texObj, texImage);
		2023	ctx->NewState \|= _NEW_TEXTURE;
		2024	}
		2025
		2026
		2027
		2028	void
		2029	_mesa_TexSubImage3D( GLenum target, GLint level,
		2030	GLint xoffset, GLint yoffset, GLint zoffset,
		2031	GLsizei width, GLsizei height, GLsizei depth,
		2032	GLenum format, GLenum type,
		2033	const GLvoid *pixels )
		2034	{
		2035	struct gl_texture_unit *texUnit;
		2036	struct gl_texture_object *texObj;
		2037	struct gl_texture_image *texImage;
		2038	GET_CURRENT_CONTEXT(ctx);
		2039	ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
		2040
		2041	if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
		2042	_mesa_update_state(ctx);
		2043
		2044	if (subtexture_error_check(ctx, 3, target, level, xoffset, yoffset, zoffset,
		2045	width, height, depth, format, type)) {
		2046	return; /* error was detected */
		2047	}
		2048
		2049	texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
		2050	texObj = _mesa_select_tex_object(ctx, texUnit, target);
		2051	texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
		2052	assert(texImage);
		2053
		2054	if (width == 0 \|\| height == 0 \|\| height == 0 \|\| !pixels)
		2055	return; /* no-op, not an error */
		2056
		2057	/* If we have a border, xoffset=-1 is legal. Bias by border width */
		2058	xoffset += texImage->Border;
		2059	yoffset += texImage->Border;
		2060	zoffset += texImage->Border;
		2061
		2062	ASSERT(ctx->Driver.TexSubImage3D);
		2063	(*ctx->Driver.TexSubImage3D)(ctx, target, level,
		2064	xoffset, yoffset, zoffset,
		2065	width, height, depth,
		2066	format, type, pixels,
		2067	&ctx->Unpack, texObj, texImage );
		2068	ctx->NewState \|= _NEW_TEXTURE;
		2069	}
		2070
		2071
		2072
		2073	void
		2074	_mesa_CopyTexImage1D( GLenum target, GLint level,
		2075	GLenum internalFormat,
		2076	GLint x, GLint y,
		2077	GLsizei width, GLint border )
		2078	{
		2079	struct gl_texture_unit *texUnit;
		2080	struct gl_texture_object *texObj;
		2081	struct gl_texture_image *texImage;
		2082	GLsizei postConvWidth = width;
		2083	GET_CURRENT_CONTEXT(ctx);
		2084	ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
		2085
		2086	if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
		2087	_mesa_update_state(ctx);
		2088
		2089	if (is_color_format(internalFormat)) {
		2090	_mesa_adjust_image_for_convolution(ctx, 1, &postConvWidth, NULL);
		2091	}
		2092
		2093	if (copytexture_error_check(ctx, 1, target, level, internalFormat,
		2094	postConvWidth, 1, border))
		2095	return;
		2096
		2097	texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
		2098	texObj = _mesa_select_tex_object(ctx, texUnit, target);
		2099	texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
		2100	if (!texImage) {
		2101	texImage = _mesa_alloc_texture_image();
		2102	_mesa_set_tex_image(texObj, target, level, texImage);
		2103	if (!texImage) {
		2104	_mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexImage1D");
		2105	return;
		2106	}
		2107	}
		2108	else if (texImage->Data && !texImage->IsClientData) {
		2109	/* free the old texture data */
		2110	MESA_PBUFFER_FREE(texImage->Data);
		2111	}
		2112	texImage->Data = NULL;
		2113
		2114	clear_teximage_fields(texImage); /* not really needed, but helpful */
		2115	_mesa_init_teximage_fields(ctx, target, texImage, postConvWidth, 1, 1,
		2116	border, internalFormat);
		2117
		2118
		2119	ASSERT(ctx->Driver.CopyTexImage1D);
		2120	(*ctx->Driver.CopyTexImage1D)(ctx, target, level, internalFormat,
		2121	x, y, width, border);
		2122
		2123	ASSERT(texImage->TexFormat);
		2124	if (!texImage->FetchTexel) {
		2125	/* If driver didn't explicitly set this, use the default */
		2126	texImage->FetchTexel = texImage->TexFormat->FetchTexel1D;
		2127	}
		2128	ASSERT(texImage->FetchTexel);
		2129
		2130	/* state update */
		2131	texObj->Complete = GL_FALSE;
		2132	ctx->NewState \|= _NEW_TEXTURE;
		2133	}
		2134
		2135
		2136
		2137	void
		2138	_mesa_CopyTexImage2D( GLenum target, GLint level, GLenum internalFormat,
		2139	GLint x, GLint y, GLsizei width, GLsizei height,
		2140	GLint border )
		2141	{
		2142	struct gl_texture_unit *texUnit;
		2143	struct gl_texture_object *texObj;
		2144	struct gl_texture_image *texImage;
		2145	GLsizei postConvWidth = width, postConvHeight = height;
		2146	GET_CURRENT_CONTEXT(ctx);
		2147	ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
		2148
		2149	if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
		2150	_mesa_update_state(ctx);
		2151
		2152	if (is_color_format(internalFormat)) {
		2153	_mesa_adjust_image_for_convolution(ctx, 2, &postConvWidth,
		2154	&postConvHeight);
		2155	}
		2156
		2157	if (copytexture_error_check(ctx, 2, target, level, internalFormat,
		2158	postConvWidth, postConvHeight, border))
		2159	return;
		2160
		2161	texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
		2162	texObj = _mesa_select_tex_object(ctx, texUnit, target);
		2163	texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
		2164	if (!texImage) {
		2165	texImage = _mesa_alloc_texture_image();
		2166	_mesa_set_tex_image(texObj, target, level, texImage);
		2167	if (!texImage) {
		2168	_mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexImage2D");
		2169	return;
		2170	}
		2171	}
		2172	else if (texImage->Data && !texImage->IsClientData) {
		2173	/* free the old texture data */
		2174	MESA_PBUFFER_FREE(texImage->Data);
		2175	}
		2176	texImage->Data = NULL;
		2177
		2178	clear_teximage_fields(texImage); /* not really needed, but helpful */
		2179	_mesa_init_teximage_fields(ctx, target, texImage,
		2180	postConvWidth, postConvHeight, 1,
		2181	border, internalFormat);
		2182
		2183	ASSERT(ctx->Driver.CopyTexImage2D);
		2184	(*ctx->Driver.CopyTexImage2D)(ctx, target, level, internalFormat,
		2185	x, y, width, height, border);
		2186
		2187	ASSERT(texImage->TexFormat);
		2188	if (!texImage->FetchTexel) {
		2189	/* If driver didn't explicitly set this, use the default */
		2190	texImage->FetchTexel = texImage->TexFormat->FetchTexel2D;
		2191	}
		2192	ASSERT(texImage->FetchTexel);
		2193
		2194	/* state update */
		2195	texObj->Complete = GL_FALSE;
		2196	ctx->NewState \|= _NEW_TEXTURE;
		2197	}
		2198
		2199
		2200
		2201	void
		2202	_mesa_CopyTexSubImage1D( GLenum target, GLint level,
		2203	GLint xoffset, GLint x, GLint y, GLsizei width )
		2204	{
		2205	struct gl_texture_unit *texUnit;
		2206	struct gl_texture_object *texObj;
		2207	struct gl_texture_image *texImage;
		2208	GLsizei postConvWidth = width;
		2209	GET_CURRENT_CONTEXT(ctx);
		2210	ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
		2211
		2212	if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
		2213	_mesa_update_state(ctx);
		2214
		2215	/* XXX should test internal format */
		2216	_mesa_adjust_image_for_convolution(ctx, 1, &postConvWidth, NULL);
		2217
		2218	if (copytexsubimage_error_check(ctx, 1, target, level,
		2219	xoffset, 0, 0, postConvWidth, 1))
		2220	return;
		2221
		2222	texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
		2223	texObj = _mesa_select_tex_object(ctx, texUnit, target);
		2224	texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
		2225
		2226	/* If we have a border, xoffset=-1 is legal. Bias by border width */
		2227	xoffset += texImage->Border;
		2228
		2229	ASSERT(ctx->Driver.CopyTexSubImage1D);
		2230	(*ctx->Driver.CopyTexSubImage1D)(ctx, target, level, xoffset, x, y, width);
		2231	ctx->NewState \|= _NEW_TEXTURE;
		2232	}
		2233
		2234
		2235
		2236	void
		2237	_mesa_CopyTexSubImage2D( GLenum target, GLint level,
		2238	GLint xoffset, GLint yoffset,
		2239	GLint x, GLint y, GLsizei width, GLsizei height )
		2240	{
		2241	struct gl_texture_unit *texUnit;
		2242	struct gl_texture_object *texObj;
		2243	struct gl_texture_image *texImage;
		2244	GLsizei postConvWidth = width, postConvHeight = height;
		2245	GET_CURRENT_CONTEXT(ctx);
		2246	ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
		2247
		2248	if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
		2249	_mesa_update_state(ctx);
		2250
		2251	/* XXX should test internal format */
		2252	_mesa_adjust_image_for_convolution(ctx, 2, &postConvWidth, &postConvHeight);
		2253
		2254	if (copytexsubimage_error_check(ctx, 2, target, level, xoffset, yoffset, 0,
		2255	postConvWidth, postConvHeight))
		2256	return;
		2257
		2258	texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
		2259	texObj = _mesa_select_tex_object(ctx, texUnit, target);
		2260	texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
		2261
		2262	/* If we have a border, xoffset=-1 is legal. Bias by border width */
		2263	xoffset += texImage->Border;
		2264	yoffset += texImage->Border;
		2265
		2266	ASSERT(ctx->Driver.CopyTexSubImage2D);
		2267	(*ctx->Driver.CopyTexSubImage2D)(ctx, target, level,
		2268	xoffset, yoffset, x, y, width, height);
		2269	ctx->NewState \|= _NEW_TEXTURE;
		2270	}
		2271
		2272
		2273
		2274	void
		2275	_mesa_CopyTexSubImage3D( GLenum target, GLint level,
		2276	GLint xoffset, GLint yoffset, GLint zoffset,
		2277	GLint x, GLint y, GLsizei width, GLsizei height )
		2278	{
		2279	struct gl_texture_unit *texUnit;
		2280	struct gl_texture_object *texObj;
		2281	struct gl_texture_image *texImage;
		2282	GLsizei postConvWidth = width, postConvHeight = height;
		2283	GET_CURRENT_CONTEXT(ctx);
		2284	ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
		2285
		2286	if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
		2287	_mesa_update_state(ctx);
		2288
		2289	/* XXX should test internal format */
		2290	_mesa_adjust_image_for_convolution(ctx, 2, &postConvWidth, &postConvHeight);
		2291
		2292	if (copytexsubimage_error_check(ctx, 3, target, level, xoffset, yoffset,
		2293	zoffset, postConvWidth, postConvHeight))
		2294	return;
		2295
		2296	texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
		2297	texObj = _mesa_select_tex_object(ctx, texUnit, target);
		2298	texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
		2299
		2300	/* If we have a border, xoffset=-1 is legal. Bias by border width */
		2301	xoffset += texImage->Border;
		2302	yoffset += texImage->Border;
		2303	zoffset += texImage->Border;
		2304
		2305	ASSERT(ctx->Driver.CopyTexSubImage3D);
		2306	(*ctx->Driver.CopyTexSubImage3D)(ctx, target, level,
		2307	xoffset, yoffset, zoffset,
		2308	x, y, width, height);
		2309	ctx->NewState \|= _NEW_TEXTURE;
		2310	}
		2311
		2312
		2313
		2314
		2315	/**********************************************************************/
		2316	/**** Compressed Textures ****/
		2317	/**********************************************************************/
		2318
		2319
		2320	/**
		2321	* Error checking for glCompressedTexImage[123]D().
		2322	* \return error code or GL_NO_ERROR.
		2323	*/
		2324	static GLenum
		2325	compressed_texture_error_check(GLcontext *ctx, GLint dimensions,
		2326	GLenum target, GLint level,
		2327	GLenum internalFormat, GLsizei width,
		2328	GLsizei height, GLsizei depth, GLint border,
		2329	GLsizei imageSize)
		2330	{
		2331	GLboolean isProxy = GL_FALSE;
		2332	GLint expectedSize, maxLevels = 0, maxTextureSize;
		2333
		2334	if (dimensions == 1) {
		2335	/* 1D compressed textures not allowed */
		2336	return GL_INVALID_ENUM;
		2337	}
		2338	else if (dimensions == 2) {
		2339	if (target == GL_PROXY_TEXTURE_2D) {
		2340	maxLevels = ctx->Const.MaxTextureLevels;
		2341	isProxy = GL_TRUE;
		2342	}
		2343	else if (target == GL_TEXTURE_2D) {
		2344	maxLevels = ctx->Const.MaxTextureLevels;
		2345	}
		2346	else if (target == GL_PROXY_TEXTURE_CUBE_MAP_ARB) {
		2347	if (!ctx->Extensions.ARB_texture_cube_map)
		2348	return GL_INVALID_ENUM; /target/
		2349	maxLevels = ctx->Const.MaxCubeTextureLevels;
		2350	isProxy = GL_TRUE;
		2351	}
		2352	else if (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&
		2353	target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB) {
		2354	if (!ctx->Extensions.ARB_texture_cube_map)
		2355	return GL_INVALID_ENUM; /target/
		2356	maxLevels = ctx->Const.MaxCubeTextureLevels;
		2357	}
		2358	else {
		2359	return GL_INVALID_ENUM; /target/
		2360	}
		2361	}
		2362	else if (dimensions == 3) {
		2363	/* 3D compressed textures not allowed */
		2364	return GL_INVALID_ENUM;
		2365	}
		2366
		2367	maxTextureSize = 1 << (maxLevels - 1);
		2368
		2369	if (!is_compressed_format(internalFormat))
		2370	return GL_INVALID_ENUM;
		2371
		2372	if (border != 0)
		2373	return GL_INVALID_VALUE;
		2374
		2375	if (width < 1 \|\| width > maxTextureSize \|\| logbase2(width) < 0)
		2376	return GL_INVALID_VALUE;
		2377
		2378	if ((height < 1 \|\| height > maxTextureSize \|\| logbase2(height) < 0)
		2379	&& dimensions > 1)
		2380	return GL_INVALID_VALUE;
		2381
		2382	if ((depth < 1 \|\| depth > maxTextureSize \|\| logbase2(depth) < 0)
		2383	&& dimensions > 2)
		2384	return GL_INVALID_VALUE;
		2385
		2386	/* For cube map, width must equal height */
		2387	if (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&
		2388	target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB && width != height)
		2389	return GL_INVALID_VALUE;
		2390
		2391	if (level < 0 \|\| level >= maxLevels)
		2392	return GL_INVALID_VALUE;
		2393
		2394	expectedSize = _mesa_compressed_texture_size(ctx, width, height, depth,
		2395	internalFormat);
		2396	if (expectedSize != imageSize)
		2397	return GL_INVALID_VALUE;
		2398
		2399	return GL_NO_ERROR;
		2400	}
		2401
		2402
		2403	/**
		2404	* Error checking for glCompressedTexSubImage[123]D().
		2405	* \return error code or GL_NO_ERROR.
		2406	*/
		2407	static GLenum
		2408	compressed_subtexture_error_check(GLcontext *ctx, GLint dimensions,
		2409	GLenum target, GLint level,
		2410	GLint xoffset, GLint yoffset, GLint zoffset,
		2411	GLsizei width, GLsizei height, GLsizei depth,
		2412	GLenum format, GLsizei imageSize)
		2413	{
		2414	GLboolean isProxy = GL_FALSE;
		2415	GLint expectedSize, maxLevels = 0, maxTextureSize;
		2416
		2417	if (dimensions == 1) {
		2418	/* 1D compressed textures not allowed */
		2419	return GL_INVALID_ENUM;
		2420	}
		2421	else if (dimensions == 2) {
		2422	if (target == GL_PROXY_TEXTURE_2D) {
		2423	maxLevels = ctx->Const.MaxTextureLevels;
		2424	isProxy = GL_TRUE;
		2425	}
		2426	else if (target == GL_TEXTURE_2D) {
		2427	maxLevels = ctx->Const.MaxTextureLevels;
		2428	}
		2429	else if (target == GL_PROXY_TEXTURE_CUBE_MAP_ARB) {
		2430	if (!ctx->Extensions.ARB_texture_cube_map)
		2431	return GL_INVALID_ENUM; /target/
		2432	maxLevels = ctx->Const.MaxCubeTextureLevels;
		2433	isProxy = GL_TRUE;
		2434	}
		2435	else if (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&
		2436	target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB) {
		2437	if (!ctx->Extensions.ARB_texture_cube_map)
		2438	return GL_INVALID_ENUM; /target/
		2439	maxLevels = ctx->Const.MaxCubeTextureLevels;
		2440	}
		2441	else {
		2442	return GL_INVALID_ENUM; /target/
		2443	}
		2444	}
		2445	else if (dimensions == 3) {
		2446	/* 3D compressed textures not allowed */
		2447	return GL_INVALID_ENUM;
		2448	}
		2449
		2450	maxTextureSize = 1 << (maxLevels - 1);
		2451
		2452	if (!is_compressed_format(format))
		2453	return GL_INVALID_ENUM;
		2454
		2455	if (width < 1 \|\| width > maxTextureSize \|\| logbase2(width) < 0)
		2456	return GL_INVALID_VALUE;
		2457
		2458	if ((height < 1 \|\| height > maxTextureSize \|\| logbase2(height) < 0)
		2459	&& dimensions > 1)
		2460	return GL_INVALID_VALUE;
		2461
		2462	if (level < 0 \|\| level >= maxLevels)
		2463	return GL_INVALID_VALUE;
		2464
		2465	if ((xoffset & 3) != 0 \|\| (yoffset & 3) != 0)
		2466	return GL_INVALID_VALUE;
		2467
		2468	if ((width & 3) != 0 && width != 2 && width != 1)
		2469	return GL_INVALID_VALUE;
		2470
		2471	if ((height & 3) != 0 && height != 2 && height != 1)
		2472	return GL_INVALID_VALUE;
		2473
		2474	expectedSize = _mesa_compressed_texture_size(ctx, width, height, depth,
		2475	format);
		2476	if (expectedSize != imageSize)
		2477	return GL_INVALID_VALUE;
		2478
		2479	return GL_NO_ERROR;
		2480	}
		2481
		2482
		2483
		2484	void
		2485	_mesa_CompressedTexImage1DARB(GLenum target, GLint level,
		2486	GLenum internalFormat, GLsizei width,
		2487	GLint border, GLsizei imageSize,
		2488	const GLvoid *data)
		2489	{
		2490	GET_CURRENT_CONTEXT(ctx);
		2491	ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
		2492
		2493	if (target == GL_TEXTURE_1D) {
		2494	struct gl_texture_unit *texUnit;
		2495	struct gl_texture_object *texObj;
		2496	struct gl_texture_image *texImage;
		2497	GLenum error = compressed_texture_error_check(ctx, 1, target, level,
		2498	internalFormat, width, 1, 1, border, imageSize);
		2499	if (error) {
		2500	_mesa_error(ctx, error, "glCompressedTexImage1D");
		2501	return;
		2502	}
		2503
		2504	texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
		2505	texObj = _mesa_select_tex_object(ctx, texUnit, target);
		2506	texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
		2507
		2508	if (!texImage) {
		2509	texImage = _mesa_alloc_texture_image();
		2510	texObj->Image[level] = texImage;
		2511	if (!texImage) {
		2512	_mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage1D");
		2513	return;
		2514	}
		2515	}
		2516	else if (texImage->Data && !texImage->IsClientData) {
		2517	MESA_PBUFFER_FREE(texImage->Data);
		2518	}
		2519	texImage->Data = NULL;
		2520
		2521	_mesa_init_teximage_fields(ctx, target, texImage, width, 1, 1,
		2522	border, internalFormat);
		2523
		2524	ASSERT(ctx->Driver.CompressedTexImage1D);
		2525	(*ctx->Driver.CompressedTexImage1D)(ctx, target, level,
		2526	internalFormat, width, border,
		2527	imageSize, data,
		2528	texObj, texImage);
		2529
		2530	/* state update */
		2531	texObj->Complete = GL_FALSE;
		2532	ctx->NewState \|= _NEW_TEXTURE;
		2533	}
		2534	else if (target == GL_PROXY_TEXTURE_1D) {
		2535	/* Proxy texture: check for errors and update proxy state */
		2536	GLenum error = compressed_texture_error_check(ctx, 1, target, level,
		2537	internalFormat, width, 1, 1, border, imageSize);
		2538	if (!error) {
		2539	ASSERT(ctx->Driver.TestProxyTexImage);
		2540	error = !(*ctx->Driver.TestProxyTexImage)(ctx, target, level,
		2541	internalFormat, GL_NONE, GL_NONE,
		2542	width, 1, 1, border);
		2543	}
		2544	if (error) {
		2545	/* if error, clear all proxy texture image parameters */
		2546	if (level >= 0 && level < ctx->Const.MaxTextureLevels) {
		2547	clear_teximage_fields(ctx->Texture.Proxy1D->Image[level]);
		2548	}
		2549	}
		2550	else {
		2551	/* store the teximage parameters */
		2552	struct gl_texture_unit *texUnit;
		2553	struct gl_texture_image *texImage;
		2554	texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
		2555	texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
		2556	_mesa_init_teximage_fields(ctx, target, texImage, width, 1, 1,
		2557	border, internalFormat);
		2558	}
		2559	}
		2560	else {
		2561	_mesa_error(ctx, GL_INVALID_ENUM, "glCompressedTexImage1D(target)");
		2562	return;
		2563	}
		2564	}
		2565
		2566
		2567	void
		2568	_mesa_CompressedTexImage2DARB(GLenum target, GLint level,
		2569	GLenum internalFormat, GLsizei width,
		2570	GLsizei height, GLint border, GLsizei imageSize,
		2571	const GLvoid *data)
		2572	{
		2573	GET_CURRENT_CONTEXT(ctx);
		2574	ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
		2575
		2576	if (target == GL_TEXTURE_2D \|\|
		2577	(ctx->Extensions.ARB_texture_cube_map &&
		2578	target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&
		2579	target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB)) {
		2580	struct gl_texture_unit *texUnit;
		2581	struct gl_texture_object *texObj;
		2582	struct gl_texture_image *texImage;
		2583	GLenum error = compressed_texture_error_check(ctx, 2, target, level,
		2584	internalFormat, width, height, 1, border, imageSize);
		2585	if (error) {
		2586	_mesa_error(ctx, error, "glCompressedTexImage2D");
		2587	return;
		2588	}
		2589
		2590	texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
		2591	texObj = _mesa_select_tex_object(ctx, texUnit, target);
		2592	texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
		2593
		2594	if (!texImage) {
		2595	texImage = _mesa_alloc_texture_image();
		2596	texObj->Image[level] = texImage;
		2597	if (!texImage) {
		2598	_mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage2D");
		2599	return;
		2600	}
		2601	}
		2602	else if (texImage->Data && !texImage->IsClientData) {
		2603	MESA_PBUFFER_FREE(texImage->Data);
		2604	}
		2605	texImage->Data = NULL;
		2606
		2607	_mesa_init_teximage_fields(ctx, target, texImage, width, height, 1,
		2608	border, internalFormat);
		2609
		2610	ASSERT(ctx->Driver.CompressedTexImage2D);
		2611	(*ctx->Driver.CompressedTexImage2D)(ctx, target, level,
		2612	internalFormat, width, height,
		2613	border, imageSize, data,
		2614	texObj, texImage);
		2615
		2616	/* state update */
		2617	texObj->Complete = GL_FALSE;
		2618	ctx->NewState \|= _NEW_TEXTURE;
		2619	}
		2620	else if (target == GL_PROXY_TEXTURE_2D \|\|
		2621	(target == GL_PROXY_TEXTURE_CUBE_MAP_ARB &&
		2622	ctx->Extensions.ARB_texture_cube_map)) {
		2623	/* Proxy texture: check for errors and update proxy state */
		2624	GLenum error = compressed_texture_error_check(ctx, 2, target, level,
		2625	internalFormat, width, height, 1, border, imageSize);
		2626	if (!error) {
		2627	ASSERT(ctx->Driver.TestProxyTexImage);
		2628	error = !(*ctx->Driver.TestProxyTexImage)(ctx, target, level,
		2629	internalFormat, GL_NONE, GL_NONE,
		2630	width, height, 1, border);
		2631	}
		2632	if (error) {
		2633	/* if error, clear all proxy texture image parameters */
		2634	const GLint maxLevels = (target == GL_PROXY_TEXTURE_2D) ?
		2635	ctx->Const.MaxTextureLevels : ctx->Const.MaxCubeTextureLevels;
		2636	if (level >= 0 && level < maxLevels) {
		2637	clear_teximage_fields(ctx->Texture.Proxy2D->Image[level]);
		2638	}
		2639	}
		2640	else {
		2641	/* store the teximage parameters */
		2642	struct gl_texture_unit *texUnit;
		2643	struct gl_texture_image *texImage;
		2644	texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
		2645	texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
		2646	_mesa_init_teximage_fields(ctx, target, texImage, width, height, 1,
		2647	border, internalFormat);
		2648	}
		2649	}
		2650	else {
		2651	_mesa_error(ctx, GL_INVALID_ENUM, "glCompressedTexImage2D(target)");
		2652	return;
		2653	}
		2654	}
		2655
		2656
		2657	void
		2658	_mesa_CompressedTexImage3DARB(GLenum target, GLint level,
		2659	GLenum internalFormat, GLsizei width,
		2660	GLsizei height, GLsizei depth, GLint border,
		2661	GLsizei imageSize, const GLvoid *data)
		2662	{
		2663	GET_CURRENT_CONTEXT(ctx);
		2664	ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
		2665
		2666	if (target == GL_TEXTURE_3D) {
		2667	struct gl_texture_unit *texUnit;
		2668	struct gl_texture_object *texObj;
		2669	struct gl_texture_image *texImage;
		2670	GLenum error = compressed_texture_error_check(ctx, 3, target, level,
		2671	internalFormat, width, height, depth, border, imageSize);
		2672	if (error) {
		2673	_mesa_error(ctx, error, "glCompressedTexImage3D");
		2674	return;
		2675	}
		2676
		2677	texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
		2678	texObj = _mesa_select_tex_object(ctx, texUnit, target);
		2679	texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
		2680
		2681	if (!texImage) {
		2682	texImage = _mesa_alloc_texture_image();
		2683	texObj->Image[level] = texImage;
		2684	if (!texImage) {
		2685	_mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage3D");
		2686	return;
		2687	}
		2688	}
		2689	else if (texImage->Data && !texImage->IsClientData) {
		2690	MESA_PBUFFER_FREE(texImage->Data);
		2691	}
		2692	texImage->Data = NULL;
		2693
		2694	_mesa_init_teximage_fields(ctx, target, texImage, width, height, depth,
		2695	border, internalFormat);
		2696
		2697	ASSERT(ctx->Driver.CompressedTexImage3D);
		2698	(*ctx->Driver.CompressedTexImage3D)(ctx, target, level,
		2699	internalFormat,
		2700	width, height, depth,
		2701	border, imageSize, data,
		2702	texObj, texImage);
		2703
		2704	/* state update */
		2705	texObj->Complete = GL_FALSE;
		2706	ctx->NewState \|= _NEW_TEXTURE;
		2707	}
		2708	else if (target == GL_PROXY_TEXTURE_3D) {
		2709	/* Proxy texture: check for errors and update proxy state */
		2710	GLenum error = compressed_texture_error_check(ctx, 3, target, level,
		2711	internalFormat, width, height, depth, border, imageSize);
		2712	if (!error) {
		2713	ASSERT(ctx->Driver.TestProxyTexImage);
		2714	error = !(*ctx->Driver.TestProxyTexImage)(ctx, target, level,
		2715	internalFormat, GL_NONE, GL_NONE,
		2716	width, height, depth, border);
		2717	}
		2718	if (error) {
		2719	/* if error, clear all proxy texture image parameters */
		2720	if (level >= 0 && level < ctx->Const.Max3DTextureLevels) {
		2721	clear_teximage_fields(ctx->Texture.Proxy3D->Image[level]);
		2722	}
		2723	}
		2724	else {
		2725	/* store the teximage parameters */
		2726	struct gl_texture_unit *texUnit;
		2727	struct gl_texture_image *texImage;
		2728	texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
		2729	texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
		2730	_mesa_init_teximage_fields(ctx, target, texImage, width, height,
		2731	depth, border, internalFormat);
		2732	}
		2733	}
		2734	else {
		2735	_mesa_error(ctx, GL_INVALID_ENUM, "glCompressedTexImage3D(target)");
		2736	return;
		2737	}
		2738	}
		2739
		2740
		2741	void
		2742	_mesa_CompressedTexSubImage1DARB(GLenum target, GLint level, GLint xoffset,
		2743	GLsizei width, GLenum format,
		2744	GLsizei imageSize, const GLvoid *data)
		2745	{
		2746	struct gl_texture_unit *texUnit;
		2747	struct gl_texture_object *texObj;
		2748	struct gl_texture_image *texImage;
		2749	GLenum error;
		2750	GET_CURRENT_CONTEXT(ctx);
		2751	ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
		2752
		2753	error = compressed_subtexture_error_check(ctx, 1, target, level,
		2754	xoffset, 0, 0, width, 1, 1, format, imageSize);
		2755	if (error) {
		2756	_mesa_error(ctx, error, "glCompressedTexSubImage1D");
		2757	return;
		2758	}
		2759
		2760	texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
		2761	texObj = _mesa_select_tex_object(ctx, texUnit, target);
		2762	texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
		2763	assert(texImage);
		2764
		2765	if ((GLint) format != texImage->IntFormat) {
		2766	_mesa_error(ctx, GL_INVALID_OPERATION,
		2767	"glCompressedTexSubImage1D(format)");
		2768	return;
		2769	}
		2770
		2771	if ((width == 1 \|\| width == 2) && (GLuint) width != texImage->Width) {
		2772	_mesa_error(ctx, GL_INVALID_VALUE, "glCompressedTexSubImage1D(width)");
		2773	return;
		2774	}
		2775
		2776	if (width == 0 \|\| !data)
		2777	return; /* no-op, not an error */
		2778
		2779	if (ctx->Driver.CompressedTexSubImage1D) {
		2780	(*ctx->Driver.CompressedTexSubImage1D)(ctx, target, level,
		2781	xoffset, width,
		2782	format, imageSize, data,
		2783	texObj, texImage);
		2784	}
		2785	ctx->NewState \|= _NEW_TEXTURE;
		2786	}
		2787
		2788
		2789	void
		2790	_mesa_CompressedTexSubImage2DARB(GLenum target, GLint level, GLint xoffset,
		2791	GLint yoffset, GLsizei width, GLsizei height,
		2792	GLenum format, GLsizei imageSize,
		2793	const GLvoid *data)
		2794	{
		2795	struct gl_texture_unit *texUnit;
		2796	struct gl_texture_object *texObj;
		2797	struct gl_texture_image *texImage;
		2798	GLenum error;
		2799	GET_CURRENT_CONTEXT(ctx);
		2800	ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
		2801
		2802	error = compressed_subtexture_error_check(ctx, 2, target, level,
		2803	xoffset, yoffset, 0, width, height, 1, format, imageSize);
		2804	if (error) {
		2805	_mesa_error(ctx, error, "glCompressedTexSubImage2D");
		2806	return;
		2807	}
		2808
		2809	texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
		2810	texObj = _mesa_select_tex_object(ctx, texUnit, target);
		2811	texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
		2812	assert(texImage);
		2813
		2814	if ((GLint) format != texImage->IntFormat) {
		2815	_mesa_error(ctx, GL_INVALID_OPERATION,
		2816	"glCompressedTexSubImage2D(format)");
		2817	return;
		2818	}
		2819
		2820	if (((width == 1 \|\| width == 2) && (GLuint) width != texImage->Width) \|\|
		2821	((height == 1 \|\| height == 2) && (GLuint) height != texImage->Height)) {
		2822	_mesa_error(ctx, GL_INVALID_VALUE, "glCompressedTexSubImage2D(size)");
		2823	return;
		2824	}
		2825
		2826	if (width == 0 \|\| height == 0 \|\| !data)
		2827	return; /* no-op, not an error */
		2828
		2829	if (ctx->Driver.CompressedTexSubImage2D) {
		2830	(*ctx->Driver.CompressedTexSubImage2D)(ctx, target, level,
		2831	xoffset, yoffset, width, height,
		2832	format, imageSize, data,
		2833	texObj, texImage);
		2834	}
		2835	ctx->NewState \|= _NEW_TEXTURE;
		2836	}
		2837
		2838
		2839	void
		2840	_mesa_CompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset,
		2841	GLint yoffset, GLint zoffset, GLsizei width,
		2842	GLsizei height, GLsizei depth, GLenum format,
		2843	GLsizei imageSize, const GLvoid *data)
		2844	{
		2845	struct gl_texture_unit *texUnit;
		2846	struct gl_texture_object *texObj;
		2847	struct gl_texture_image *texImage;
		2848	GLenum error;
		2849	GET_CURRENT_CONTEXT(ctx);
		2850	ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
		2851
		2852	error = compressed_subtexture_error_check(ctx, 3, target, level,
		2853	xoffset, yoffset, zoffset, width, height, depth, format, imageSize);
		2854	if (error) {
		2855	_mesa_error(ctx, error, "glCompressedTexSubImage2D");
		2856	return;
		2857	}
		2858
		2859	texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
		2860	texObj = _mesa_select_tex_object(ctx, texUnit, target);
		2861	texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
		2862	assert(texImage);
		2863
		2864	if ((GLint) format != texImage->IntFormat) {
		2865	_mesa_error(ctx, GL_INVALID_OPERATION,
		2866	"glCompressedTexSubImage3D(format)");
		2867	return;
		2868	}
		2869
		2870	if (((width == 1 \|\| width == 2) && (GLuint) width != texImage->Width) \|\|
		2871	((height == 1 \|\| height == 2) && (GLuint) height != texImage->Height) \|\|
		2872	((depth == 1 \|\| depth == 2) && (GLuint) depth != texImage->Depth)) {
		2873	_mesa_error(ctx, GL_INVALID_VALUE, "glCompressedTexSubImage3D(size)");
		2874	return;
		2875	}
		2876
		2877	if (width == 0 \|\| height == 0 \|\| depth == 0 \|\| !data)
		2878	return; /* no-op, not an error */
		2879
		2880	if (ctx->Driver.CompressedTexSubImage3D) {
		2881	(*ctx->Driver.CompressedTexSubImage3D)(ctx, target, level,
		2882	xoffset, yoffset, zoffset,
		2883	width, height, depth,
		2884	format, imageSize, data,
		2885	texObj, texImage);
		2886	}
		2887	ctx->NewState \|= _NEW_TEXTURE;
		2888	}
		2889
		2890
		2891	void
		2892	_mesa_GetCompressedTexImageARB(GLenum target, GLint level, GLvoid *img)
		2893	{
		2894	const struct gl_texture_unit *texUnit;
		2895	const struct gl_texture_object *texObj;
		2896	struct gl_texture_image *texImage;
		2897	GLint maxLevels;
		2898	GET_CURRENT_CONTEXT(ctx);
		2899	ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
		2900
		2901	texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
		2902	texObj = _mesa_select_tex_object(ctx, texUnit, target);
		2903	if (!texObj) {
		2904	_mesa_error(ctx, GL_INVALID_ENUM, "glGetCompressedTexImageARB");
		2905	return;
		2906	}
		2907
		2908	maxLevels = _mesa_max_texture_levels(ctx, target);
		2909	ASSERT(maxLevels > 0); /* 0 indicates bad target, caught above */
		2910
		2911	if (level < 0 \|\| level >= maxLevels) {
		2912	_mesa_error(ctx, GL_INVALID_VALUE, "glGetCompressedTexImageARB(level)");
		2913	return;
		2914	}
		2915
		2916	if (is_proxy_target(target)) {
		2917	_mesa_error(ctx, GL_INVALID_ENUM, "glGetCompressedTexImageARB(target)");
		2918	return;
		2919	}
		2920
		2921	texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
		2922	if (!texImage) {
		2923	/* probably invalid mipmap level */
		2924	_mesa_error(ctx, GL_INVALID_VALUE, "glGetCompressedTexImageARB(level)");
		2925	return;
		2926	}
		2927
		2928	if (!texImage->IsCompressed) {
		2929	_mesa_error(ctx, GL_INVALID_OPERATION, "glGetCompressedTexImageARB");
		2930	return;
		2931	}
		2932
		2933	if (!img)
		2934	return;
		2935
		2936	/* just memcpy, no pixelstore or pixel transfer */
		2937	MEMCPY(img, texImage->Data, texImage->CompressedSize);
		2938	}

Subversion Repositories shark

(root)/shark/trunk/ports/mesa/src/teximage.c @ 75 - Rev 55