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

Rev	Author	Line No.	Line
5564	serge	1	/*
		2	* Mesa 3-D graphics library
		3	*
		4	* Copyright (C) 1999-2008 Brian Paul All Rights Reserved.
		5	* Copyright (c) 2008-2009 VMware, Inc.
		6	*
		7	* Permission is hereby granted, free of charge, to any person obtaining a
		8	* copy of this software and associated documentation files (the "Software"),
		9	* to deal in the Software without restriction, including without limitation
		10	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
		11	* and/or sell copies of the Software, and to permit persons to whom the
		12	* Software is furnished to do so, subject to the following conditions:
		13	*
		14	* The above copyright notice and this permission notice shall be included
		15	* in all copies or substantial portions of the Software.
		16	*
		17	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
		18	* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		19	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
		20	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
		21	* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
		22	* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
		23	* OTHER DEALINGS IN THE SOFTWARE.
		24	*/
		25
		26	/*
		27	* Authors:
		28	* Brian Paul
		29	*/
		30
		31	/**
		32	* The GL texture image functions in teximage.c basically just do
		33	* error checking and data structure allocation. They in turn call
		34	* device driver functions which actually copy/convert/store the user's
		35	* texture image data.
		36	*
		37	* However, most device drivers will be able to use the fallback functions
		38	* in this file. That is, most drivers will have the following bit of
		39	* code:
		40	* ctx->Driver.TexImage = _mesa_store_teximage;
		41	* ctx->Driver.TexSubImage = _mesa_store_texsubimage;
		42	* etc...
		43	*
		44	* Texture image processing is actually kind of complicated. We have to do:
		45	* Format/type conversions
		46	* pixel unpacking
		47	* pixel transfer (scale, bais, lookup, etc)
		48	*
		49	* These functions can handle most everything, including processing full
		50	* images and sub-images.
		51	*/
		52
		53
		54	#include "glheader.h"
		55	#include "bufferobj.h"
		56	#include "format_pack.h"
		57	#include "format_utils.h"
		58	#include "image.h"
		59	#include "macros.h"
		60	#include "mipmap.h"
		61	#include "mtypes.h"
		62	#include "pack.h"
		63	#include "pbo.h"
		64	#include "imports.h"
		65	#include "texcompress.h"
		66	#include "texcompress_fxt1.h"
		67	#include "texcompress_rgtc.h"
		68	#include "texcompress_s3tc.h"
		69	#include "texcompress_etc.h"
		70	#include "texcompress_bptc.h"
		71	#include "teximage.h"
		72	#include "texstore.h"
		73	#include "enums.h"
		74	#include "glformats.h"
		75	#include "pixeltransfer.h"
		76	#include "../../gallium/auxiliary/util/u_format_rgb9e5.h"
		77	#include "../../gallium/auxiliary/util/u_format_r11g11b10f.h"
		78
		79
		80	enum {
		81	ZERO = 4,
		82	ONE = 5
		83	};
		84
		85
		86	/**
		87	* Texture image storage function.
		88	*/
		89	typedef GLboolean (*StoreTexImageFunc)(TEXSTORE_PARAMS);
		90	static const GLubyte map_identity[6] = { 0, 1, 2, 3, ZERO, ONE };
		91	static const GLubyte map_3210[6] = { 3, 2, 1, 0, ZERO, ONE };
		92	static const GLubyte map_1032[6] = { 1, 0, 3, 2, ZERO, ONE };
		93
		94
		95	/**
		96	* Teximage storage routine for when a simple memcpy will do.
		97	* No pixel transfer operations or special texel encodings allowed.
		98	* 1D, 2D and 3D images supported.
		99	*/
		100	static void
		101	memcpy_texture(struct gl_context *ctx,
		102	GLuint dimensions,
		103	mesa_format dstFormat,
		104	GLint dstRowStride,
		105	GLubyte **dstSlices,
		106	GLint srcWidth, GLint srcHeight, GLint srcDepth,
		107	GLenum srcFormat, GLenum srcType,
		108	const GLvoid *srcAddr,
		109	const struct gl_pixelstore_attrib *srcPacking)
		110	{
		111	const GLint srcRowStride = _mesa_image_row_stride(srcPacking, srcWidth,
		112	srcFormat, srcType);
		113	const GLint srcImageStride = _mesa_image_image_stride(srcPacking,
		114	srcWidth, srcHeight, srcFormat, srcType);
		115	const GLubyte srcImage = (const GLubyte ) _mesa_image_address(dimensions,
		116	srcPacking, srcAddr, srcWidth, srcHeight, srcFormat, srcType, 0, 0, 0);
		117	const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
		118	const GLint bytesPerRow = srcWidth * texelBytes;
		119
		120	if (dstRowStride == srcRowStride &&
		121	dstRowStride == bytesPerRow) {
		122	/* memcpy image by image */
		123	GLint img;
		124	for (img = 0; img < srcDepth; img++) {
		125	GLubyte *dstImage = dstSlices[img];
		126	memcpy(dstImage, srcImage, bytesPerRow * srcHeight);
		127	srcImage += srcImageStride;
		128	}
		129	}
		130	else {
		131	/* memcpy row by row */
		132	GLint img, row;
		133	for (img = 0; img < srcDepth; img++) {
		134	const GLubyte *srcRow = srcImage;
		135	GLubyte *dstRow = dstSlices[img];
		136	for (row = 0; row < srcHeight; row++) {
		137	memcpy(dstRow, srcRow, bytesPerRow);
		138	dstRow += dstRowStride;
		139	srcRow += srcRowStride;
		140	}
		141	srcImage += srcImageStride;
		142	}
		143	}
		144	}
		145
		146
		147	/**
		148	* Store a 32-bit integer or float depth component texture image.
		149	*/
		150	static GLboolean
		151	_mesa_texstore_z32(TEXSTORE_PARAMS)
		152	{
		153	const GLuint depthScale = 0xffffffff;
		154	GLenum dstType;
		155	(void) dims;
		156	assert(dstFormat == MESA_FORMAT_Z_UNORM32 \|\|
		157	dstFormat == MESA_FORMAT_Z_FLOAT32);
		158	assert(_mesa_get_format_bytes(dstFormat) == sizeof(GLuint));
		159
		160	if (dstFormat == MESA_FORMAT_Z_UNORM32)
		161	dstType = GL_UNSIGNED_INT;
		162	else
		163	dstType = GL_FLOAT;
		164
		165	{
		166	/* general path */
		167	GLint img, row;
		168	for (img = 0; img < srcDepth; img++) {
		169	GLubyte *dstRow = dstSlices[img];
		170	for (row = 0; row < srcHeight; row++) {
		171	const GLvoid *src = _mesa_image_address(dims, srcPacking,
		172	srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);
		173	_mesa_unpack_depth_span(ctx, srcWidth,
		174	dstType, dstRow,
		175	depthScale, srcType, src, srcPacking);
		176	dstRow += dstRowStride;
		177	}
		178	}
		179	}
		180	return GL_TRUE;
		181	}
		182
		183
		184	/**
		185	* Store a 24-bit integer depth component texture image.
		186	*/
		187	static GLboolean
		188	_mesa_texstore_x8_z24(TEXSTORE_PARAMS)
		189	{
		190	const GLuint depthScale = 0xffffff;
		191
		192	(void) dims;
		193	assert(dstFormat == MESA_FORMAT_Z24_UNORM_X8_UINT);
		194
		195	{
		196	/* general path */
		197	GLint img, row;
		198	for (img = 0; img < srcDepth; img++) {
		199	GLubyte *dstRow = dstSlices[img];
		200	for (row = 0; row < srcHeight; row++) {
		201	const GLvoid *src = _mesa_image_address(dims, srcPacking,
		202	srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);
		203	_mesa_unpack_depth_span(ctx, srcWidth,
		204	GL_UNSIGNED_INT, (GLuint *) dstRow,
		205	depthScale, srcType, src, srcPacking);
		206	dstRow += dstRowStride;
		207	}
		208	}
		209	}
		210	return GL_TRUE;
		211	}
		212
		213
		214	/**
		215	* Store a 24-bit integer depth component texture image.
		216	*/
		217	static GLboolean
		218	_mesa_texstore_z24_x8(TEXSTORE_PARAMS)
		219	{
		220	const GLuint depthScale = 0xffffff;
		221
		222	(void) dims;
		223	assert(dstFormat == MESA_FORMAT_X8_UINT_Z24_UNORM);
		224
		225	{
		226	/* general path */
		227	GLint img, row;
		228	for (img = 0; img < srcDepth; img++) {
		229	GLubyte *dstRow = dstSlices[img];
		230	for (row = 0; row < srcHeight; row++) {
		231	const GLvoid *src = _mesa_image_address(dims, srcPacking,
		232	srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);
		233	GLuint dst = (GLuint ) dstRow;
		234	GLint i;
		235	_mesa_unpack_depth_span(ctx, srcWidth,
		236	GL_UNSIGNED_INT, dst,
		237	depthScale, srcType, src, srcPacking);
		238	for (i = 0; i < srcWidth; i++)
		239	dst[i] <<= 8;
		240	dstRow += dstRowStride;
		241	}
		242	}
		243	}
		244	return GL_TRUE;
		245	}
		246
		247
		248	/**
		249	* Store a 16-bit integer depth component texture image.
		250	*/
		251	static GLboolean
		252	_mesa_texstore_z16(TEXSTORE_PARAMS)
		253	{
		254	const GLuint depthScale = 0xffff;
		255	(void) dims;
		256	assert(dstFormat == MESA_FORMAT_Z_UNORM16);
		257	assert(_mesa_get_format_bytes(dstFormat) == sizeof(GLushort));
		258
		259	{
		260	/* general path */
		261	GLint img, row;
		262	for (img = 0; img < srcDepth; img++) {
		263	GLubyte *dstRow = dstSlices[img];
		264	for (row = 0; row < srcHeight; row++) {
		265	const GLvoid *src = _mesa_image_address(dims, srcPacking,
		266	srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);
		267	GLushort dst16 = (GLushort ) dstRow;
		268	_mesa_unpack_depth_span(ctx, srcWidth,
		269	GL_UNSIGNED_SHORT, dst16, depthScale,
		270	srcType, src, srcPacking);
		271	dstRow += dstRowStride;
		272	}
		273	}
		274	}
		275	return GL_TRUE;
		276	}
		277
		278
		279	/**
		280	* Texstore for _mesa_texformat_ycbcr or _mesa_texformat_ycbcr_REV.
		281	*/
		282	static GLboolean
		283	_mesa_texstore_ycbcr(TEXSTORE_PARAMS)
		284	{
		285	const GLboolean littleEndian = _mesa_little_endian();
		286
		287	(void) ctx; (void) dims; (void) baseInternalFormat;
		288
		289	assert((dstFormat == MESA_FORMAT_YCBCR) \|\|
		290	(dstFormat == MESA_FORMAT_YCBCR_REV));
		291	assert(_mesa_get_format_bytes(dstFormat) == 2);
		292	assert(ctx->Extensions.MESA_ycbcr_texture);
		293	assert(srcFormat == GL_YCBCR_MESA);
		294	assert((srcType == GL_UNSIGNED_SHORT_8_8_MESA) \|\|
		295	(srcType == GL_UNSIGNED_SHORT_8_8_REV_MESA));
		296	assert(baseInternalFormat == GL_YCBCR_MESA);
		297
		298	/* always just memcpy since no pixel transfer ops apply */
		299	memcpy_texture(ctx, dims,
		300	dstFormat,
		301	dstRowStride, dstSlices,
		302	srcWidth, srcHeight, srcDepth, srcFormat, srcType,
		303	srcAddr, srcPacking);
		304
		305	/* Check if we need byte swapping */
		306	/* XXX the logic here _might_ be wrong */
		307	if (srcPacking->SwapBytes ^
		308	(srcType == GL_UNSIGNED_SHORT_8_8_REV_MESA) ^
		309	(dstFormat == MESA_FORMAT_YCBCR_REV) ^
		310	!littleEndian) {
		311	GLint img, row;
		312	for (img = 0; img < srcDepth; img++) {
		313	GLubyte *dstRow = dstSlices[img];
		314	for (row = 0; row < srcHeight; row++) {
		315	_mesa_swap2((GLushort *) dstRow, srcWidth);
		316	dstRow += dstRowStride;
		317	}
		318	}
		319	}
		320	return GL_TRUE;
		321	}
		322
		323
		324	/**
		325	* Store a combined depth/stencil texture image.
		326	*/
		327	static GLboolean
		328	_mesa_texstore_z24_s8(TEXSTORE_PARAMS)
		329	{
		330	const GLuint depthScale = 0xffffff;
		331	const GLint srcRowStride
		332	= _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
		333	GLint img, row;
		334	GLuint depth = malloc(srcWidth sizeof(GLuint));
		335	GLubyte stencil = malloc(srcWidth sizeof(GLubyte));
		336
		337	assert(dstFormat == MESA_FORMAT_S8_UINT_Z24_UNORM);
		338	assert(srcFormat == GL_DEPTH_STENCIL_EXT \|\|
		339	srcFormat == GL_DEPTH_COMPONENT \|\|
		340	srcFormat == GL_STENCIL_INDEX);
		341	assert(srcFormat != GL_DEPTH_STENCIL_EXT \|\|
		342	srcType == GL_UNSIGNED_INT_24_8_EXT \|\|
		343	srcType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
		344
		345	if (!depth \|\| !stencil) {
		346	free(depth);
		347	free(stencil);
		348	return GL_FALSE;
		349	}
		350
		351	/* In case we only upload depth we need to preserve the stencil */
		352	for (img = 0; img < srcDepth; img++) {
		353	GLuint dstRow = (GLuint ) dstSlices[img];
		354	const GLubyte *src
		355	= (const GLubyte *) _mesa_image_address(dims, srcPacking, srcAddr,
		356	srcWidth, srcHeight,
		357	srcFormat, srcType,
		358	img, 0, 0);
		359	for (row = 0; row < srcHeight; row++) {
		360	GLint i;
		361	GLboolean keepdepth = GL_FALSE, keepstencil = GL_FALSE;
		362
		363	if (srcFormat == GL_DEPTH_COMPONENT) { /* preserve stencil */
		364	keepstencil = GL_TRUE;
		365	}
		366	else if (srcFormat == GL_STENCIL_INDEX) { /* preserve depth */
		367	keepdepth = GL_TRUE;
		368	}
		369
		370	if (keepdepth == GL_FALSE)
		371	/* the 24 depth bits will be in the low position: */
		372	_mesa_unpack_depth_span(ctx, srcWidth,
		373	GL_UNSIGNED_INT, /* dst type */
		374	keepstencil ? depth : dstRow, /* dst addr */
		375	depthScale,
		376	srcType, src, srcPacking);
		377
		378	if (keepstencil == GL_FALSE)
		379	/* get the 8-bit stencil values */
		380	_mesa_unpack_stencil_span(ctx, srcWidth,
		381	GL_UNSIGNED_BYTE, /* dst type */
		382	stencil, /* dst addr */
		383	srcType, src, srcPacking,
		384	ctx->_ImageTransferState);
		385
		386	for (i = 0; i < srcWidth; i++) {
		387	if (keepstencil)
		388	dstRow[i] = depth[i] << 8 \| (dstRow[i] & 0x000000FF);
		389	else
		390	dstRow[i] = (dstRow[i] & 0xFFFFFF00) \| (stencil[i] & 0xFF);
		391	}
		392	src += srcRowStride;
		393	dstRow += dstRowStride / sizeof(GLuint);
		394	}
		395	}
		396
		397	free(depth);
		398	free(stencil);
		399	return GL_TRUE;
		400	}
		401
		402
		403	/**
		404	* Store a combined depth/stencil texture image.
		405	*/
		406	static GLboolean
		407	_mesa_texstore_s8_z24(TEXSTORE_PARAMS)
		408	{
		409	const GLuint depthScale = 0xffffff;
		410	const GLint srcRowStride
		411	= _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
		412	GLint img, row;
		413	GLuint *depth;
		414	GLubyte *stencil;
		415
		416	assert(dstFormat == MESA_FORMAT_Z24_UNORM_S8_UINT);
		417	assert(srcFormat == GL_DEPTH_STENCIL_EXT \|\|
		418	srcFormat == GL_DEPTH_COMPONENT \|\|
		419	srcFormat == GL_STENCIL_INDEX);
		420	assert(srcFormat != GL_DEPTH_STENCIL_EXT \|\|
		421	srcType == GL_UNSIGNED_INT_24_8_EXT \|\|
		422	srcType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
		423
		424	depth = malloc(srcWidth * sizeof(GLuint));
		425	stencil = malloc(srcWidth * sizeof(GLubyte));
		426
		427	if (!depth \|\| !stencil) {
		428	free(depth);
		429	free(stencil);
		430	return GL_FALSE;
		431	}
		432
		433	for (img = 0; img < srcDepth; img++) {
		434	GLuint dstRow = (GLuint ) dstSlices[img];
		435	const GLubyte *src
		436	= (const GLubyte *) _mesa_image_address(dims, srcPacking, srcAddr,
		437	srcWidth, srcHeight,
		438	srcFormat, srcType,
		439	img, 0, 0);
		440	for (row = 0; row < srcHeight; row++) {
		441	GLint i;
		442	GLboolean keepdepth = GL_FALSE, keepstencil = GL_FALSE;
		443
		444	if (srcFormat == GL_DEPTH_COMPONENT) { /* preserve stencil */
		445	keepstencil = GL_TRUE;
		446	}
		447	else if (srcFormat == GL_STENCIL_INDEX) { /* preserve depth */
		448	keepdepth = GL_TRUE;
		449	}
		450
		451	if (keepdepth == GL_FALSE)
		452	/* the 24 depth bits will be in the low position: */
		453	_mesa_unpack_depth_span(ctx, srcWidth,
		454	GL_UNSIGNED_INT, /* dst type */
		455	keepstencil ? depth : dstRow, /* dst addr */
		456	depthScale,
		457	srcType, src, srcPacking);
		458
		459	if (keepstencil == GL_FALSE)
		460	/* get the 8-bit stencil values */
		461	_mesa_unpack_stencil_span(ctx, srcWidth,
		462	GL_UNSIGNED_BYTE, /* dst type */
		463	stencil, /* dst addr */
		464	srcType, src, srcPacking,
		465	ctx->_ImageTransferState);
		466
		467	/* merge stencil values into depth values */
		468	for (i = 0; i < srcWidth; i++) {
		469	if (keepstencil)
		470	dstRow[i] = depth[i] \| (dstRow[i] & 0xFF000000);
		471	else
		472	dstRow[i] = (dstRow[i] & 0xFFFFFF) \| (stencil[i] << 24);
		473
		474	}
		475	src += srcRowStride;
		476	dstRow += dstRowStride / sizeof(GLuint);
		477	}
		478	}
		479
		480	free(depth);
		481	free(stencil);
		482
		483	return GL_TRUE;
		484	}
		485
		486
		487	/**
		488	* Store simple 8-bit/value stencil texture data.
		489	*/
		490	static GLboolean
		491	_mesa_texstore_s8(TEXSTORE_PARAMS)
		492	{
		493	assert(dstFormat == MESA_FORMAT_S_UINT8);
		494	assert(srcFormat == GL_STENCIL_INDEX);
		495
		496	{
		497	const GLint srcRowStride
		498	= _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
		499	GLint img, row;
		500	GLubyte stencil = malloc(srcWidth sizeof(GLubyte));
		501
		502	if (!stencil)
		503	return GL_FALSE;
		504
		505	for (img = 0; img < srcDepth; img++) {
		506	GLubyte *dstRow = dstSlices[img];
		507	const GLubyte *src
		508	= (const GLubyte *) _mesa_image_address(dims, srcPacking, srcAddr,
		509	srcWidth, srcHeight,
		510	srcFormat, srcType,
		511	img, 0, 0);
		512	for (row = 0; row < srcHeight; row++) {
		513	GLint i;
		514
		515	/* get the 8-bit stencil values */
		516	_mesa_unpack_stencil_span(ctx, srcWidth,
		517	GL_UNSIGNED_BYTE, /* dst type */
		518	stencil, /* dst addr */
		519	srcType, src, srcPacking,
		520	ctx->_ImageTransferState);
		521	/* merge stencil values into depth values */
		522	for (i = 0; i < srcWidth; i++)
		523	dstRow[i] = stencil[i];
		524
		525	src += srcRowStride;
		526	dstRow += dstRowStride / sizeof(GLubyte);
		527	}
		528	}
		529
		530	free(stencil);
		531	}
		532
		533	return GL_TRUE;
		534	}
		535
		536
		537	static GLboolean
		538	_mesa_texstore_z32f_x24s8(TEXSTORE_PARAMS)
		539	{
		540	GLint img, row;
		541	const GLint srcRowStride
		542	= _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType)
		543	/ sizeof(uint64_t);
		544
		545	assert(dstFormat == MESA_FORMAT_Z32_FLOAT_S8X24_UINT);
		546	assert(srcFormat == GL_DEPTH_STENCIL \|\|
		547	srcFormat == GL_DEPTH_COMPONENT \|\|
		548	srcFormat == GL_STENCIL_INDEX);
		549	assert(srcFormat != GL_DEPTH_STENCIL \|\|
		550	srcType == GL_UNSIGNED_INT_24_8 \|\|
		551	srcType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
		552
		553	/* In case we only upload depth we need to preserve the stencil */
		554	for (img = 0; img < srcDepth; img++) {
		555	uint64_t dstRow = (uint64_t ) dstSlices[img];
		556	const uint64_t *src
		557	= (const uint64_t *) _mesa_image_address(dims, srcPacking, srcAddr,
		558	srcWidth, srcHeight,
		559	srcFormat, srcType,
		560	img, 0, 0);
		561	for (row = 0; row < srcHeight; row++) {
		562	/* The unpack functions with:
		563	* dstType = GL_FLOAT_32_UNSIGNED_INT_24_8_REV
		564	* only write their own dword, so the other dword (stencil
		565	* or depth) is preserved. */
		566	if (srcFormat != GL_STENCIL_INDEX)
		567	_mesa_unpack_depth_span(ctx, srcWidth,
		568	GL_FLOAT_32_UNSIGNED_INT_24_8_REV, /* dst type */
		569	dstRow, /* dst addr */
		570	~0U, srcType, src, srcPacking);
		571
		572	if (srcFormat != GL_DEPTH_COMPONENT)
		573	_mesa_unpack_stencil_span(ctx, srcWidth,
		574	GL_FLOAT_32_UNSIGNED_INT_24_8_REV, /* dst type */
		575	dstRow, /* dst addr */
		576	srcType, src, srcPacking,
		577	ctx->_ImageTransferState);
		578
		579	src += srcRowStride;
		580	dstRow += dstRowStride / sizeof(uint64_t);
		581	}
		582	}
		583	return GL_TRUE;
		584	}
		585
		586	static GLboolean
		587	texstore_depth_stencil(TEXSTORE_PARAMS)
		588	{
		589	static StoreTexImageFunc table[MESA_FORMAT_COUNT];
		590	static GLboolean initialized = GL_FALSE;
		591
		592	if (!initialized) {
		593	memset(table, 0, sizeof table);
		594
		595	table[MESA_FORMAT_S8_UINT_Z24_UNORM] = _mesa_texstore_z24_s8;
		596	table[MESA_FORMAT_Z24_UNORM_S8_UINT] = _mesa_texstore_s8_z24;
		597	table[MESA_FORMAT_Z_UNORM16] = _mesa_texstore_z16;
		598	table[MESA_FORMAT_Z24_UNORM_X8_UINT] = _mesa_texstore_x8_z24;
		599	table[MESA_FORMAT_X8_UINT_Z24_UNORM] = _mesa_texstore_z24_x8;
		600	table[MESA_FORMAT_Z_UNORM32] = _mesa_texstore_z32;
		601	table[MESA_FORMAT_S_UINT8] = _mesa_texstore_s8;
		602	table[MESA_FORMAT_Z_FLOAT32] = _mesa_texstore_z32;
		603	table[MESA_FORMAT_Z32_FLOAT_S8X24_UINT] = _mesa_texstore_z32f_x24s8;
		604
		605	initialized = GL_TRUE;
		606	}
		607
		608	assert(table[dstFormat]);
		609	return table[dstFormat](ctx, dims, baseInternalFormat,
		610	dstFormat, dstRowStride, dstSlices,
		611	srcWidth, srcHeight, srcDepth,
		612	srcFormat, srcType, srcAddr, srcPacking);
		613	}
		614
		615	static GLboolean
		616	texstore_compressed(TEXSTORE_PARAMS)
		617	{
		618	static StoreTexImageFunc table[MESA_FORMAT_COUNT];
		619	static GLboolean initialized = GL_FALSE;
		620
		621	if (!initialized) {
		622	memset(table, 0, sizeof table);
		623
		624	table[MESA_FORMAT_SRGB_DXT1] = _mesa_texstore_rgb_dxt1;
		625	table[MESA_FORMAT_SRGBA_DXT1] = _mesa_texstore_rgba_dxt1;
		626	table[MESA_FORMAT_SRGBA_DXT3] = _mesa_texstore_rgba_dxt3;
		627	table[MESA_FORMAT_SRGBA_DXT5] = _mesa_texstore_rgba_dxt5;
		628	table[MESA_FORMAT_RGB_FXT1] = _mesa_texstore_rgb_fxt1;
		629	table[MESA_FORMAT_RGBA_FXT1] = _mesa_texstore_rgba_fxt1;
		630	table[MESA_FORMAT_RGB_DXT1] = _mesa_texstore_rgb_dxt1;
		631	table[MESA_FORMAT_RGBA_DXT1] = _mesa_texstore_rgba_dxt1;
		632	table[MESA_FORMAT_RGBA_DXT3] = _mesa_texstore_rgba_dxt3;
		633	table[MESA_FORMAT_RGBA_DXT5] = _mesa_texstore_rgba_dxt5;
		634	table[MESA_FORMAT_R_RGTC1_UNORM] = _mesa_texstore_red_rgtc1;
		635	table[MESA_FORMAT_R_RGTC1_SNORM] = _mesa_texstore_signed_red_rgtc1;
		636	table[MESA_FORMAT_RG_RGTC2_UNORM] = _mesa_texstore_rg_rgtc2;
		637	table[MESA_FORMAT_RG_RGTC2_SNORM] = _mesa_texstore_signed_rg_rgtc2;
		638	table[MESA_FORMAT_L_LATC1_UNORM] = _mesa_texstore_red_rgtc1;
		639	table[MESA_FORMAT_L_LATC1_SNORM] = _mesa_texstore_signed_red_rgtc1;
		640	table[MESA_FORMAT_LA_LATC2_UNORM] = _mesa_texstore_rg_rgtc2;
		641	table[MESA_FORMAT_LA_LATC2_SNORM] = _mesa_texstore_signed_rg_rgtc2;
		642	table[MESA_FORMAT_ETC1_RGB8] = _mesa_texstore_etc1_rgb8;
		643	table[MESA_FORMAT_ETC2_RGB8] = _mesa_texstore_etc2_rgb8;
		644	table[MESA_FORMAT_ETC2_SRGB8] = _mesa_texstore_etc2_srgb8;
		645	table[MESA_FORMAT_ETC2_RGBA8_EAC] = _mesa_texstore_etc2_rgba8_eac;
		646	table[MESA_FORMAT_ETC2_SRGB8_ALPHA8_EAC] = _mesa_texstore_etc2_srgb8_alpha8_eac;
		647	table[MESA_FORMAT_ETC2_R11_EAC] = _mesa_texstore_etc2_r11_eac;
		648	table[MESA_FORMAT_ETC2_RG11_EAC] = _mesa_texstore_etc2_rg11_eac;
		649	table[MESA_FORMAT_ETC2_SIGNED_R11_EAC] = _mesa_texstore_etc2_signed_r11_eac;
		650	table[MESA_FORMAT_ETC2_SIGNED_RG11_EAC] = _mesa_texstore_etc2_signed_rg11_eac;
		651	table[MESA_FORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1] =
		652	_mesa_texstore_etc2_rgb8_punchthrough_alpha1;
		653	table[MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1] =
		654	_mesa_texstore_etc2_srgb8_punchthrough_alpha1;
		655
		656	table[MESA_FORMAT_BPTC_RGBA_UNORM] =
		657	_mesa_texstore_bptc_rgba_unorm;
		658	table[MESA_FORMAT_BPTC_SRGB_ALPHA_UNORM] =
		659	_mesa_texstore_bptc_rgba_unorm;
		660	table[MESA_FORMAT_BPTC_RGB_SIGNED_FLOAT] =
		661	_mesa_texstore_bptc_rgb_signed_float;
		662	table[MESA_FORMAT_BPTC_RGB_UNSIGNED_FLOAT] =
		663	_mesa_texstore_bptc_rgb_unsigned_float;
		664
		665	initialized = GL_TRUE;
		666	}
		667
		668	assert(table[dstFormat]);
		669	return table[dstFormat](ctx, dims, baseInternalFormat,
		670	dstFormat, dstRowStride, dstSlices,
		671	srcWidth, srcHeight, srcDepth,
		672	srcFormat, srcType, srcAddr, srcPacking);
		673	}
		674
		675	static GLboolean
		676	texstore_rgba(TEXSTORE_PARAMS)
		677	{
		678	void tempImage = NULL, tempRGBA = NULL;
		679	int srcRowStride, img;
		680	GLubyte src, dst;
		681	uint32_t srcMesaFormat;
		682	uint8_t rebaseSwizzle[4];
		683	bool needRebase;
		684	bool transferOpsDone = false;
		685
		686	/* We have to handle MESA_FORMAT_YCBCR manually because it is a special case
		687	* and _mesa_format_convert does not support it. In this case the we only
		688	* allow conversions between YCBCR formats and it is mostly a memcpy.
		689	*/
		690	if (dstFormat == MESA_FORMAT_YCBCR \|\| dstFormat == MESA_FORMAT_YCBCR_REV) {
		691	return _mesa_texstore_ycbcr(ctx, dims, baseInternalFormat,
		692	dstFormat, dstRowStride, dstSlices,
		693	srcWidth, srcHeight, srcDepth,
		694	srcFormat, srcType, srcAddr,
		695	srcPacking);
		696	}
		697
		698	/* We have to deal with GL_COLOR_INDEX manually because
		699	* _mesa_format_convert does not handle this format. So what we do here is
		700	* convert it to RGBA ubyte first and then convert from that to dst as usual.
		701	*/
		702	if (srcFormat == GL_COLOR_INDEX) {
		703	/* Notice that this will already handle byte swapping if necessary */
		704	tempImage =
		705	_mesa_unpack_color_index_to_rgba_ubyte(ctx, dims,
		706	srcAddr, srcFormat, srcType,
		707	srcWidth, srcHeight, srcDepth,
		708	srcPacking,
		709	ctx->_ImageTransferState);
		710	if (!tempImage)
		711	return GL_FALSE;
		712
		713	/* _mesa_unpack_color_index_to_rgba_ubyte has handled transferops
		714	* if needed.
		715	*/
		716	transferOpsDone = true;
		717
		718	/* Now we only have to adjust our src info for a conversion from
		719	* the RGBA ubyte and then we continue as usual.
		720	*/
		721	srcAddr = tempImage;
		722	srcFormat = GL_RGBA;
		723	srcType = GL_UNSIGNED_BYTE;
		724	} else if (srcPacking->SwapBytes) {
		725	/* We have to handle byte-swapping scenarios before calling
		726	* _mesa_format_convert
		727	*/
		728	GLint swapSize = _mesa_sizeof_packed_type(srcType);
		729	if (swapSize == 2 \|\| swapSize == 4) {
		730	int bytesPerPixel = _mesa_bytes_per_pixel(srcFormat, srcType);
		731	int swapsPerPixel = bytesPerPixel / swapSize;
		732	int elementCount = srcWidth * srcHeight * srcDepth;
		733	assert(bytesPerPixel % swapSize == 0);
		734	tempImage = malloc(elementCount * bytesPerPixel);
		735	if (!tempImage)
		736	return GL_FALSE;
		737	if (swapSize == 2)
		738	_mesa_swap2_copy(tempImage, (GLushort *) srcAddr,
		739	elementCount * swapsPerPixel);
		740	else
		741	_mesa_swap4_copy(tempImage, (GLuint *) srcAddr,
		742	elementCount * swapsPerPixel);
		743	srcAddr = tempImage;
		744	}
		745	}
		746
		747	srcRowStride =
		748	_mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
		749
		750	srcMesaFormat = _mesa_format_from_format_and_type(srcFormat, srcType);
		751	dstFormat = _mesa_get_srgb_format_linear(dstFormat);
		752
		753	/* If we have transferOps then we need to convert to RGBA float first,
		754	then apply transferOps, then do the conversion to dst
		755	*/
		756	if (!transferOpsDone &&
		757	_mesa_texstore_needs_transfer_ops(ctx, baseInternalFormat, dstFormat)) {
		758	/* Allocate RGBA float image */
		759	int elementCount = srcWidth * srcHeight * srcDepth;
		760	tempRGBA = malloc(4 * elementCount * sizeof(float));
		761	if (!tempRGBA) {
		762	free(tempImage);
		763	free(tempRGBA);
		764	return GL_FALSE;
		765	}
		766
		767	/* Convert from src to RGBA float */
		768	src = (GLubyte *) srcAddr;
		769	dst = (GLubyte *) tempRGBA;
		770	for (img = 0; img < srcDepth; img++) {
		771	_mesa_format_convert(dst, RGBA32_FLOAT, 4 * srcWidth * sizeof(float),
		772	src, srcMesaFormat, srcRowStride,
		773	srcWidth, srcHeight, NULL);
		774	src += srcHeight * srcRowStride;
		775	dst += srcHeight * 4 * srcWidth * sizeof(float);
		776	}
		777
		778	/* Apply transferOps */
		779	_mesa_apply_rgba_transfer_ops(ctx, ctx->_ImageTransferState, elementCount,
		780	(float(*)[4]) tempRGBA);
		781
		782	/* Now we have to adjust our src info for a conversion from
		783	* the RGBA float image and then we continue as usual.
		784	*/
		785	srcAddr = tempRGBA;
		786	srcFormat = GL_RGBA;
		787	srcType = GL_FLOAT;
		788	srcRowStride = srcWidth * 4 * sizeof(float);
		789	srcMesaFormat = RGBA32_FLOAT;
		790	}
		791
		792	src = (GLubyte *)
		793	_mesa_image_address(dims, srcPacking, srcAddr, srcWidth, srcHeight,
		794	srcFormat, srcType, 0, 0, 0);
		795
		796	if (_mesa_get_format_base_format(dstFormat) != baseInternalFormat) {
		797	needRebase =
		798	_mesa_compute_rgba2base2rgba_component_mapping(baseInternalFormat,
		799	rebaseSwizzle);
		800	} else {
		801	needRebase = false;
		802	}
		803
		804	for (img = 0; img < srcDepth; img++) {
		805	_mesa_format_convert(dstSlices[img], dstFormat, dstRowStride,
		806	src, srcMesaFormat, srcRowStride,
		807	srcWidth, srcHeight,
		808	needRebase ? rebaseSwizzle : NULL);
		809	src += srcHeight * srcRowStride;
		810	}
		811
		812	free(tempImage);
		813	free(tempRGBA);
		814
		815	return GL_TRUE;
		816	}
		817
		818	GLboolean
		819	_mesa_texstore_needs_transfer_ops(struct gl_context *ctx,
		820	GLenum baseInternalFormat,
		821	mesa_format dstFormat)
		822	{
		823	GLenum dstType;
		824
		825	/* There are different rules depending on the base format. */
		826	switch (baseInternalFormat) {
		827	case GL_DEPTH_COMPONENT:
		828	case GL_DEPTH_STENCIL:
		829	return ctx->Pixel.DepthScale != 1.0f \|\|
		830	ctx->Pixel.DepthBias != 0.0f;
		831
		832	case GL_STENCIL_INDEX:
		833	return GL_FALSE;
		834
		835	default:
		836	/* Color formats.
		837	* Pixel transfer ops (scale, bias, table lookup) do not apply
		838	* to integer formats.
		839	*/
		840	dstType = _mesa_get_format_datatype(dstFormat);
		841
		842	return dstType != GL_INT && dstType != GL_UNSIGNED_INT &&
		843	ctx->_ImageTransferState;
		844	}
		845	}
		846
		847
		848	GLboolean
		849	_mesa_texstore_can_use_memcpy(struct gl_context *ctx,
		850	GLenum baseInternalFormat, mesa_format dstFormat,
		851	GLenum srcFormat, GLenum srcType,
		852	const struct gl_pixelstore_attrib *srcPacking)
		853	{
		854	if (_mesa_texstore_needs_transfer_ops(ctx, baseInternalFormat, dstFormat)) {
		855	return GL_FALSE;
		856	}
		857
		858	/* The base internal format and the base Mesa format must match. */
		859	if (baseInternalFormat != _mesa_get_format_base_format(dstFormat)) {
		860	return GL_FALSE;
		861	}
		862
		863	/* The Mesa format must match the input format and type. */
		864	if (!_mesa_format_matches_format_and_type(dstFormat, srcFormat, srcType,
		865	srcPacking->SwapBytes)) {
		866	return GL_FALSE;
		867	}
		868
		869	/* Depth texture data needs clamping in following cases:
		870	* - Floating point dstFormat with signed srcType: clamp to [0.0, 1.0].
		871	* - Fixed point dstFormat with signed srcType: clamp to [0, 2^n -1].
		872	*
		873	* All the cases except one (float dstFormat with float srcType) are ruled
		874	* out by _mesa_format_matches_format_and_type() check above. Handle the
		875	* remaining case here.
		876	*/
		877	if ((baseInternalFormat == GL_DEPTH_COMPONENT \|\|
		878	baseInternalFormat == GL_DEPTH_STENCIL) &&
		879	(srcType == GL_FLOAT \|\|
		880	srcType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV)) {
		881	return GL_FALSE;
		882	}
		883
		884	return GL_TRUE;
		885	}
		886
		887	static GLboolean
		888	_mesa_texstore_memcpy(TEXSTORE_PARAMS)
		889	{
		890	if (!_mesa_texstore_can_use_memcpy(ctx, baseInternalFormat, dstFormat,
		891	srcFormat, srcType, srcPacking)) {
		892	return GL_FALSE;
		893	}
		894
		895	memcpy_texture(ctx, dims,
		896	dstFormat,
		897	dstRowStride, dstSlices,
		898	srcWidth, srcHeight, srcDepth, srcFormat, srcType,
		899	srcAddr, srcPacking);
		900	return GL_TRUE;
		901	}
		902	/**
		903	* Store user data into texture memory.
		904	* Called via glTex[Sub]Image1/2/3D()
		905	* \return GL_TRUE for success, GL_FALSE for failure (out of memory).
		906	*/
		907	GLboolean
		908	_mesa_texstore(TEXSTORE_PARAMS)
		909	{
		910	if (_mesa_texstore_memcpy(ctx, dims, baseInternalFormat,
		911	dstFormat,
		912	dstRowStride, dstSlices,
		913	srcWidth, srcHeight, srcDepth,
		914	srcFormat, srcType, srcAddr, srcPacking)) {
		915	return GL_TRUE;
		916	}
		917
		918	if (_mesa_is_depth_or_stencil_format(baseInternalFormat)) {
		919	return texstore_depth_stencil(ctx, dims, baseInternalFormat,
		920	dstFormat, dstRowStride, dstSlices,
		921	srcWidth, srcHeight, srcDepth,
		922	srcFormat, srcType, srcAddr, srcPacking);
		923	} else if (_mesa_is_format_compressed(dstFormat)) {
		924	return texstore_compressed(ctx, dims, baseInternalFormat,
		925	dstFormat, dstRowStride, dstSlices,
		926	srcWidth, srcHeight, srcDepth,
		927	srcFormat, srcType, srcAddr, srcPacking);
		928	} else {
		929	return texstore_rgba(ctx, dims, baseInternalFormat,
		930	dstFormat, dstRowStride, dstSlices,
		931	srcWidth, srcHeight, srcDepth,
		932	srcFormat, srcType, srcAddr, srcPacking);
		933	}
		934	}
		935
		936
		937	/**
		938	* Normally, we'll only _write_ texel data to a texture when we map it.
		939	* But if the user is providing depth or stencil values and the texture
		940	* image is a combined depth/stencil format, we'll actually read from
		941	* the texture buffer too (in order to insert the depth or stencil values.
		942	* \param userFormat the user-provided image format
		943	* \param texFormat the destination texture format
		944	*/
		945	static GLbitfield
		946	get_read_write_mode(GLenum userFormat, mesa_format texFormat)
		947	{
		948	if ((userFormat == GL_STENCIL_INDEX \|\| userFormat == GL_DEPTH_COMPONENT)
		949	&& _mesa_get_format_base_format(texFormat) == GL_DEPTH_STENCIL)
		950	return GL_MAP_READ_BIT \| GL_MAP_WRITE_BIT;
		951	else
		952	return GL_MAP_WRITE_BIT \| GL_MAP_INVALIDATE_RANGE_BIT;
		953	}
		954
		955
		956	/**
		957	* Helper function for storing 1D, 2D, 3D whole and subimages into texture
		958	* memory.
		959	* The source of the image data may be user memory or a PBO. In the later
		960	* case, we'll map the PBO, copy from it, then unmap it.
		961	*/
		962	static void
		963	store_texsubimage(struct gl_context *ctx,
		964	struct gl_texture_image *texImage,
		965	GLint xoffset, GLint yoffset, GLint zoffset,
		966	GLint width, GLint height, GLint depth,
		967	GLenum format, GLenum type, const GLvoid *pixels,
		968	const struct gl_pixelstore_attrib *packing,
		969	const char *caller)
		970
		971	{
		972	const GLbitfield mapMode = get_read_write_mode(format, texImage->TexFormat);
		973	const GLenum target = texImage->TexObject->Target;
		974	GLboolean success = GL_FALSE;
		975	GLuint dims, slice, numSlices = 1, sliceOffset = 0;
		976	GLint srcImageStride = 0;
		977	const GLubyte *src;
		978
		979	assert(xoffset + width <= texImage->Width);
		980	assert(yoffset + height <= texImage->Height);
		981	assert(zoffset + depth <= texImage->Depth);
		982
		983	switch (target) {
		984	case GL_TEXTURE_1D:
		985	dims = 1;
		986	break;
		987	case GL_TEXTURE_2D_ARRAY:
		988	case GL_TEXTURE_CUBE_MAP_ARRAY:
		989	case GL_TEXTURE_3D:
		990	dims = 3;
		991	break;
		992	default:
		993	dims = 2;
		994	}
		995
		996	/* get pointer to src pixels (may be in a pbo which we'll map here) */
		997	src = (const GLubyte *)
		998	_mesa_validate_pbo_teximage(ctx, dims, width, height, depth,
		999	format, type, pixels, packing, caller);
		1000	if (!src)
		1001	return;
		1002
		1003	/* compute slice info (and do some sanity checks) */
		1004	switch (target) {
		1005	case GL_TEXTURE_2D:
		1006	case GL_TEXTURE_RECTANGLE:
		1007	case GL_TEXTURE_CUBE_MAP:
		1008	case GL_TEXTURE_EXTERNAL_OES:
		1009	/* one image slice, nothing special needs to be done */
		1010	break;
		1011	case GL_TEXTURE_1D:
		1012	assert(height == 1);
		1013	assert(depth == 1);
		1014	assert(yoffset == 0);
		1015	assert(zoffset == 0);
		1016	break;
		1017	case GL_TEXTURE_1D_ARRAY:
		1018	assert(depth == 1);
		1019	assert(zoffset == 0);
		1020	numSlices = height;
		1021	sliceOffset = yoffset;
		1022	height = 1;
		1023	yoffset = 0;
		1024	srcImageStride = _mesa_image_row_stride(packing, width, format, type);
		1025	break;
		1026	case GL_TEXTURE_2D_ARRAY:
		1027	numSlices = depth;
		1028	sliceOffset = zoffset;
		1029	depth = 1;
		1030	zoffset = 0;
		1031	srcImageStride = _mesa_image_image_stride(packing, width, height,
		1032	format, type);
		1033	break;
		1034	case GL_TEXTURE_3D:
		1035	/* we'll store 3D images as a series of slices */
		1036	numSlices = depth;
		1037	sliceOffset = zoffset;
		1038	srcImageStride = _mesa_image_image_stride(packing, width, height,
		1039	format, type);
		1040	break;
		1041	case GL_TEXTURE_CUBE_MAP_ARRAY:
		1042	numSlices = depth;
		1043	sliceOffset = zoffset;
		1044	srcImageStride = _mesa_image_image_stride(packing, width, height,
		1045	format, type);
		1046	break;
		1047	default:
		1048	_mesa_warning(ctx, "Unexpected target 0x%x in store_texsubimage()", target);
		1049	return;
		1050	}
		1051
		1052	assert(numSlices == 1 \|\| srcImageStride != 0);
		1053
		1054	for (slice = 0; slice < numSlices; slice++) {
		1055	GLubyte *dstMap;
		1056	GLint dstRowStride;
		1057
		1058	ctx->Driver.MapTextureImage(ctx, texImage,
		1059	slice + sliceOffset,
		1060	xoffset, yoffset, width, height,
		1061	mapMode, &dstMap, &dstRowStride);
		1062	if (dstMap) {
		1063	/* Note: we're only storing a 2D (or 1D) slice at a time but we need
		1064	* to pass the right 'dims' value so that GL_UNPACK_SKIP_IMAGES is
		1065	* used for 3D images.
		1066	*/
		1067	success = _mesa_texstore(ctx, dims, texImage->_BaseFormat,
		1068	texImage->TexFormat,
		1069	dstRowStride,
		1070	&dstMap,
		1071	width, height, 1, /* w, h, d */
		1072	format, type, src, packing);
		1073
		1074	ctx->Driver.UnmapTextureImage(ctx, texImage, slice + sliceOffset);
		1075	}
		1076
		1077	src += srcImageStride;
		1078
		1079	if (!success)
		1080	break;
		1081	}
		1082
		1083	if (!success)
		1084	_mesa_error(ctx, GL_OUT_OF_MEMORY, "%s", caller);
		1085
		1086	_mesa_unmap_teximage_pbo(ctx, packing);
		1087	}
		1088
		1089
		1090
		1091	/**
		1092	* Fallback code for ctx->Driver.TexImage().
		1093	* Basically, allocate storage for the texture image, then copy the
		1094	* user's image into it.
		1095	*/
		1096	void
		1097	_mesa_store_teximage(struct gl_context *ctx,
		1098	GLuint dims,
		1099	struct gl_texture_image *texImage,
		1100	GLenum format, GLenum type, const GLvoid *pixels,
		1101	const struct gl_pixelstore_attrib *packing)
		1102	{
		1103	assert(dims == 1 \|\| dims == 2 \|\| dims == 3);
		1104
		1105	if (texImage->Width == 0 \|\| texImage->Height == 0 \|\| texImage->Depth == 0)
		1106	return;
		1107
		1108	/* allocate storage for texture data */
		1109	if (!ctx->Driver.AllocTextureImageBuffer(ctx, texImage)) {
		1110	_mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage%uD", dims);
		1111	return;
		1112	}
		1113
		1114	store_texsubimage(ctx, texImage,
		1115	0, 0, 0, texImage->Width, texImage->Height, texImage->Depth,
		1116	format, type, pixels, packing, "glTexImage");
		1117	}
		1118
		1119
		1120	/*
		1121	* Fallback for Driver.TexSubImage().
		1122	*/
		1123	void
		1124	_mesa_store_texsubimage(struct gl_context *ctx, GLuint dims,
		1125	struct gl_texture_image *texImage,
		1126	GLint xoffset, GLint yoffset, GLint zoffset,
		1127	GLint width, GLint height, GLint depth,
		1128	GLenum format, GLenum type, const void *pixels,
		1129	const struct gl_pixelstore_attrib *packing)
		1130	{
		1131	store_texsubimage(ctx, texImage,
		1132	xoffset, yoffset, zoffset, width, height, depth,
		1133	format, type, pixels, packing, "glTexSubImage");
		1134	}
		1135
		1136	static void
		1137	clear_image_to_zero(GLubyte *dstMap, GLint dstRowStride,
		1138	GLsizei width, GLsizei height,
		1139	GLsizei clearValueSize)
		1140	{
		1141	GLsizei y;
		1142
		1143	for (y = 0; y < height; y++) {
		1144	memset(dstMap, 0, clearValueSize * width);
		1145	dstMap += dstRowStride;
		1146	}
		1147	}
		1148
		1149	static void
		1150	clear_image_to_value(GLubyte *dstMap, GLint dstRowStride,
		1151	GLsizei width, GLsizei height,
		1152	const GLvoid *clearValue,
		1153	GLsizei clearValueSize)
		1154	{
		1155	GLsizei y, x;
		1156
		1157	for (y = 0; y < height; y++) {
		1158	for (x = 0; x < width; x++) {
		1159	memcpy(dstMap, clearValue, clearValueSize);
		1160	dstMap += clearValueSize;
		1161	}
		1162	dstMap += dstRowStride - clearValueSize * width;
		1163	}
		1164	}
		1165
		1166	/*
		1167	* Fallback for Driver.ClearTexSubImage().
		1168	*/
		1169	void
		1170	_mesa_store_cleartexsubimage(struct gl_context *ctx,
		1171	struct gl_texture_image *texImage,
		1172	GLint xoffset, GLint yoffset, GLint zoffset,
		1173	GLsizei width, GLsizei height, GLsizei depth,
		1174	const GLvoid *clearValue)
		1175	{
		1176	GLubyte *dstMap;
		1177	GLint dstRowStride;
		1178	GLsizeiptr clearValueSize;
		1179	GLsizei z;
		1180
		1181	clearValueSize = _mesa_get_format_bytes(texImage->TexFormat);
		1182
		1183	for (z = 0; z < depth; z++) {
		1184	ctx->Driver.MapTextureImage(ctx, texImage,
		1185	z + zoffset, xoffset, yoffset,
		1186	width, height,
		1187	GL_MAP_WRITE_BIT,
		1188	&dstMap, &dstRowStride);
		1189	if (dstMap == NULL) {
		1190	_mesa_error(ctx, GL_OUT_OF_MEMORY, "glClearTex*Image");
		1191	return;
		1192	}
		1193
		1194	if (clearValue) {
		1195	clear_image_to_value(dstMap, dstRowStride,
		1196	width, height,
		1197	clearValue,
		1198	clearValueSize);
		1199	} else {
		1200	clear_image_to_zero(dstMap, dstRowStride,
		1201	width, height,
		1202	clearValueSize);
		1203	}
		1204
		1205	ctx->Driver.UnmapTextureImage(ctx, texImage, z + zoffset);
		1206	}
		1207	}
		1208
		1209	/**
		1210	* Fallback for Driver.CompressedTexImage()
		1211	*/
		1212	void
		1213	_mesa_store_compressed_teximage(struct gl_context *ctx, GLuint dims,
		1214	struct gl_texture_image *texImage,
		1215	GLsizei imageSize, const GLvoid *data)
		1216	{
		1217	/* only 2D and 3D compressed images are supported at this time */
		1218	if (dims == 1) {
		1219	_mesa_problem(ctx, "Unexpected glCompressedTexImage1D call");
		1220	return;
		1221	}
		1222
		1223	/* This is pretty simple, because unlike the general texstore path we don't
		1224	* have to worry about the usual image unpacking or image transfer
		1225	* operations.
		1226	*/
		1227	assert(texImage);
		1228	assert(texImage->Width > 0);
		1229	assert(texImage->Height > 0);
		1230	assert(texImage->Depth > 0);
		1231
		1232	/* allocate storage for texture data */
		1233	if (!ctx->Driver.AllocTextureImageBuffer(ctx, texImage)) {
		1234	_mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage%uD", dims);
		1235	return;
		1236	}
		1237
		1238	_mesa_store_compressed_texsubimage(ctx, dims, texImage,
		1239	0, 0, 0,
		1240	texImage->Width, texImage->Height, texImage->Depth,
		1241	texImage->TexFormat,
		1242	imageSize, data);
		1243	}
		1244
		1245
		1246	/**
		1247	* Compute compressed_pixelstore parameters for copying compressed
		1248	* texture data.
		1249	* \param dims number of texture image dimensions: 1, 2 or 3
		1250	* \param texFormat the compressed texture format
		1251	* \param width, height, depth size of image to copy
		1252	* \param packing pixelstore parameters describing user-space image packing
		1253	* \param store returns the compressed_pixelstore parameters
		1254	*/
		1255	void
		1256	_mesa_compute_compressed_pixelstore(GLuint dims, mesa_format texFormat,
		1257	GLsizei width, GLsizei height,
		1258	GLsizei depth,
		1259	const struct gl_pixelstore_attrib *packing,
		1260	struct compressed_pixelstore *store)
		1261	{
		1262	GLuint bw, bh;
		1263
		1264	_mesa_get_format_block_size(texFormat, &bw, &bh);
		1265
		1266	store->SkipBytes = 0;
		1267	store->TotalBytesPerRow = store->CopyBytesPerRow =
		1268	_mesa_format_row_stride(texFormat, width);
		1269	store->TotalRowsPerSlice = store->CopyRowsPerSlice =
		1270	(height + bh - 1) / bh;
		1271	store->CopySlices = depth;
		1272
		1273	if (packing->CompressedBlockWidth &&
		1274	packing->CompressedBlockSize) {
		1275
		1276	bw = packing->CompressedBlockWidth;
		1277
		1278	if (packing->RowLength) {
		1279	store->TotalBytesPerRow = packing->CompressedBlockSize *
		1280	((packing->RowLength + bw - 1) / bw);
		1281	}
		1282
		1283	store->SkipBytes += packing->SkipPixels * packing->CompressedBlockSize / bw;
		1284	}
		1285
		1286	if (dims > 1 && packing->CompressedBlockHeight &&
		1287	packing->CompressedBlockSize) {
		1288
		1289	bh = packing->CompressedBlockHeight;
		1290
		1291	store->SkipBytes += packing->SkipRows * store->TotalBytesPerRow / bh;
		1292	store->CopyRowsPerSlice = (height + bh - 1) / bh; /* rows in blocks */
		1293
		1294	if (packing->ImageHeight) {
		1295	store->TotalRowsPerSlice = (packing->ImageHeight + bh - 1) / bh;
		1296	}
		1297	}
		1298
		1299	if (dims > 2 && packing->CompressedBlockDepth &&
		1300	packing->CompressedBlockSize) {
		1301
		1302	int bd = packing->CompressedBlockDepth;
		1303
		1304	store->SkipBytes += packing->SkipImages * store->TotalBytesPerRow *
		1305	store->TotalRowsPerSlice / bd;
		1306	}
		1307	}
		1308
		1309
		1310	/**
		1311	* Fallback for Driver.CompressedTexSubImage()
		1312	*/
		1313	void
		1314	_mesa_store_compressed_texsubimage(struct gl_context *ctx, GLuint dims,
		1315	struct gl_texture_image *texImage,
		1316	GLint xoffset, GLint yoffset, GLint zoffset,
		1317	GLsizei width, GLsizei height, GLsizei depth,
		1318	GLenum format,
		1319	GLsizei imageSize, const GLvoid *data)
		1320	{
		1321	struct compressed_pixelstore store;
		1322	GLint dstRowStride;
		1323	GLint i, slice;
		1324	GLubyte *dstMap;
		1325	const GLubyte *src;
		1326
		1327	if (dims == 1) {
		1328	_mesa_problem(ctx, "Unexpected 1D compressed texsubimage call");
		1329	return;
		1330	}
		1331
		1332	_mesa_compute_compressed_pixelstore(dims, texImage->TexFormat,
		1333	width, height, depth,
		1334	&ctx->Unpack, &store);
		1335
		1336	/* get pointer to src pixels (may be in a pbo which we'll map here) */
		1337	data = _mesa_validate_pbo_compressed_teximage(ctx, dims, imageSize, data,
		1338	&ctx->Unpack,
		1339	"glCompressedTexSubImage");
		1340	if (!data)
		1341	return;
		1342
		1343	src = (const GLubyte *) data + store.SkipBytes;
		1344
		1345	for (slice = 0; slice < store.CopySlices; slice++) {
		1346	/* Map dest texture buffer */
		1347	ctx->Driver.MapTextureImage(ctx, texImage, slice + zoffset,
		1348	xoffset, yoffset, width, height,
		1349	GL_MAP_WRITE_BIT \| GL_MAP_INVALIDATE_RANGE_BIT,
		1350	&dstMap, &dstRowStride);
		1351
		1352	if (dstMap) {
		1353
		1354	/* copy rows of blocks */
		1355	for (i = 0; i < store.CopyRowsPerSlice; i++) {
		1356	memcpy(dstMap, src, store.CopyBytesPerRow);
		1357	dstMap += dstRowStride;
		1358	src += store.TotalBytesPerRow;
		1359	}
		1360
		1361	ctx->Driver.UnmapTextureImage(ctx, texImage, slice + zoffset);
		1362
		1363	/* advance to next slice */
		1364	src += store.TotalBytesPerRow * (store.TotalRowsPerSlice - store.CopyRowsPerSlice);
		1365	}
		1366	else {
		1367	_mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexSubImage%uD",
		1368	dims);
		1369	}
		1370	}
		1371
		1372	_mesa_unmap_teximage_pbo(ctx, &ctx->Unpack);
		1373	}

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/Mesa/mesa-10.6.0/src/mesa/main/texstore.c – Rev 5564