+static GLint
+bytes_per_pixel(GLenum datatype, GLuint comps)
+{
+ GLint b = _mesa_sizeof_packed_type(datatype);
+ assert(b >= 0);
+ return b * comps;
+}
+
+
+static void
+mesa_format_to_type_and_comps(const struct gl_texture_format *format,
+ GLenum *datatype, GLuint *comps)
+{
+ switch (format->MesaFormat) {
+ case MESA_FORMAT_RGBA8888:
+ case MESA_FORMAT_RGBA8888_REV:
+ case MESA_FORMAT_ARGB8888:
+ case MESA_FORMAT_ARGB8888_REV:
+ *datatype = CHAN_TYPE;
+ *comps = 4;
+ return;
+ case MESA_FORMAT_RGB888:
+ case MESA_FORMAT_BGR888:
+ *datatype = GL_UNSIGNED_BYTE;
+ *comps = 3;
+ return;
+ case MESA_FORMAT_RGB565:
+ case MESA_FORMAT_RGB565_REV:
+ *datatype = GL_UNSIGNED_SHORT_5_6_5;
+ *comps = 3;
+ return;
+
+ case MESA_FORMAT_ARGB4444:
+ case MESA_FORMAT_ARGB4444_REV:
+ *datatype = GL_UNSIGNED_SHORT_4_4_4_4;
+ *comps = 4;
+ return;
+
+ case MESA_FORMAT_ARGB1555:
+ case MESA_FORMAT_ARGB1555_REV:
+ *datatype = GL_UNSIGNED_SHORT_1_5_5_5_REV;
+ *comps = 3;
+ return;
+
+ case MESA_FORMAT_AL88:
+ case MESA_FORMAT_AL88_REV:
+ *datatype = GL_UNSIGNED_BYTE;
+ *comps = 2;
+ return;
+ case MESA_FORMAT_RGB332:
+ *datatype = GL_UNSIGNED_BYTE_3_3_2;
+ *comps = 3;
+ return;
+
+ case MESA_FORMAT_A8:
+ case MESA_FORMAT_L8:
+ case MESA_FORMAT_I8:
+ case MESA_FORMAT_CI8:
+ *datatype = GL_UNSIGNED_BYTE;
+ *comps = 1;
+ return;
+
+ case MESA_FORMAT_YCBCR:
+ case MESA_FORMAT_YCBCR_REV:
+ *datatype = GL_UNSIGNED_SHORT;
+ *comps = 2;
+ return;
+
+ case MESA_FORMAT_Z24_S8:
+ *datatype = GL_UNSIGNED_INT;
+ *comps = 1; /* XXX OK? */
+ return;
+
+ case MESA_FORMAT_Z16:
+ *datatype = GL_UNSIGNED_SHORT;
+ *comps = 1;
+ return;
+
+ case MESA_FORMAT_Z32:
+ *datatype = GL_UNSIGNED_INT;
+ *comps = 1;
+ return;
+
+ case MESA_FORMAT_SRGB8:
+ *datatype = GL_UNSIGNED_BYTE;
+ *comps = 3;
+ return;
+ case MESA_FORMAT_SRGBA8:
+ *datatype = GL_UNSIGNED_BYTE;
+ *comps = 4;
+ return;
+ case MESA_FORMAT_SL8:
+ *datatype = GL_UNSIGNED_BYTE;
+ *comps = 1;
+ return;
+ case MESA_FORMAT_SLA8:
+ *datatype = GL_UNSIGNED_BYTE;
+ *comps = 2;
+ return;
+
+ case MESA_FORMAT_RGB_FXT1:
+ case MESA_FORMAT_RGBA_FXT1:
+ case MESA_FORMAT_RGB_DXT1:
+ case MESA_FORMAT_RGBA_DXT1:
+ case MESA_FORMAT_RGBA_DXT3:
+ case MESA_FORMAT_RGBA_DXT5:
+ /* XXX generate error instead? */
+ *datatype = GL_UNSIGNED_BYTE;
+ *comps = 0;
+ return;
+
+ case MESA_FORMAT_RGBA:
+ *datatype = CHAN_TYPE;
+ *comps = 4;
+ return;
+ case MESA_FORMAT_RGB:
+ *datatype = CHAN_TYPE;
+ *comps = 3;
+ return;
+ case MESA_FORMAT_LUMINANCE_ALPHA:
+ *datatype = CHAN_TYPE;
+ *comps = 2;
+ return;
+ case MESA_FORMAT_ALPHA:
+ case MESA_FORMAT_LUMINANCE:
+ case MESA_FORMAT_INTENSITY:
+ *datatype = CHAN_TYPE;
+ *comps = 1;
+ return;
+
+ case MESA_FORMAT_RGBA_FLOAT32:
+ *datatype = GL_FLOAT;
+ *comps = 4;
+ return;
+ case MESA_FORMAT_RGBA_FLOAT16:
+ *datatype = GL_HALF_FLOAT_ARB;
+ *comps = 4;
+ return;
+ case MESA_FORMAT_RGB_FLOAT32:
+ *datatype = GL_FLOAT;
+ *comps = 3;
+ return;
+ case MESA_FORMAT_RGB_FLOAT16:
+ *datatype = GL_HALF_FLOAT_ARB;
+ *comps = 3;
+ return;
+ case MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32:
+ *datatype = GL_FLOAT;
+ *comps = 2;
+ return;
+ case MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16:
+ *datatype = GL_HALF_FLOAT_ARB;
+ *comps = 2;
+ return;
+ case MESA_FORMAT_ALPHA_FLOAT32:
+ case MESA_FORMAT_LUMINANCE_FLOAT32:
+ case MESA_FORMAT_INTENSITY_FLOAT32:
+ *datatype = GL_FLOAT;
+ *comps = 1;
+ return;
+ case MESA_FORMAT_ALPHA_FLOAT16:
+ case MESA_FORMAT_LUMINANCE_FLOAT16:
+ case MESA_FORMAT_INTENSITY_FLOAT16:
+ *datatype = GL_HALF_FLOAT_ARB;
+ *comps = 1;
+ return;
+
+ default:
+ _mesa_problem(NULL, "bad texture format in mesa_format_to_type_and_comps");
+ *datatype = 0;
+ *comps = 1;
+ }
+}
+
+
/**
* Average together two rows of a source image to produce a single new
* row in the dest image. It's legal for the two source rows to point
* to the same data. The source width must be equal to either the
* dest width or two times the dest width.
+ * \param datatype GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, GL_FLOAT, etc.
+ * \param comps number of components per pixel (1..4)
*/
static void
-do_row(const struct gl_texture_format *format, GLint srcWidth,
+do_row(GLenum datatype, GLuint comps, GLint srcWidth,
const GLvoid *srcRowA, const GLvoid *srcRowB,
GLint dstWidth, GLvoid *dstRow)
{
const GLuint k0 = (srcWidth == dstWidth) ? 0 : 1;
const GLuint colStride = (srcWidth == dstWidth) ? 1 : 2;
+ ASSERT(comps >= 1);
+ ASSERT(comps <= 4);
+
/* This assertion is no longer valid with non-power-of-2 textures
assert(srcWidth == dstWidth || srcWidth == 2 * dstWidth);
*/
- switch (format->MesaFormat) {
- case MESA_FORMAT_RGBA:
- {
+ if (datatype == CHAN_TYPE && comps == 4) {
GLuint i, j, k;
const GLchan (*rowA)[4] = (const GLchan (*)[4]) srcRowA;
const GLchan (*rowB)[4] = (const GLchan (*)[4]) srcRowB;
dst[i][3] = (rowA[j][3] + rowA[k][3] +
rowB[j][3] + rowB[k][3]) / 4;
}
- }
- return;
- case MESA_FORMAT_RGB:
- {
+ }
+ else if (datatype == CHAN_TYPE && comps == 3) {
GLuint i, j, k;
const GLchan (*rowA)[3] = (const GLchan (*)[3]) srcRowA;
const GLchan (*rowB)[3] = (const GLchan (*)[3]) srcRowB;
dst[i][2] = (rowA[j][2] + rowA[k][2] +
rowB[j][2] + rowB[k][2]) / 4;
}
- }
- return;
- case MESA_FORMAT_ALPHA:
- case MESA_FORMAT_LUMINANCE:
- case MESA_FORMAT_INTENSITY:
- {
+ }
+ else if (datatype == CHAN_TYPE && comps == 1) {
GLuint i, j, k;
const GLchan *rowA = (const GLchan *) srcRowA;
const GLchan *rowB = (const GLchan *) srcRowB;
i++, j += colStride, k += colStride) {
dst[i] = (rowA[j] + rowA[k] + rowB[j] + rowB[k]) / 4;
}
- }
- return;
- case MESA_FORMAT_LUMINANCE_ALPHA:
- {
+ }
+ else if (datatype == CHAN_TYPE && comps == 2) {
GLuint i, j, k;
const GLchan (*rowA)[2] = (const GLchan (*)[2]) srcRowA;
const GLchan (*rowB)[2] = (const GLchan (*)[2]) srcRowB;
dst[i][1] = (rowA[j][1] + rowA[k][1] +
rowB[j][1] + rowB[k][1]) / 4;
}
- }
- return;
- case MESA_FORMAT_Z32:
- {
+ }
+ else if (datatype == GL_UNSIGNED_INT && comps == 1) {
GLuint i, j, k;
const GLuint *rowA = (const GLuint *) srcRowA;
const GLuint *rowB = (const GLuint *) srcRowB;
i++, j += colStride, k += colStride) {
dst[i] = rowA[j] / 4 + rowA[k] / 4 + rowB[j] / 4 + rowB[k] / 4;
}
- }
- return;
- case MESA_FORMAT_Z16:
- {
+ }
+ else if (datatype == GL_UNSIGNED_SHORT && comps == 1) {
GLuint i, j, k;
const GLushort *rowA = (const GLushort *) srcRowA;
const GLushort *rowB = (const GLushort *) srcRowB;
i++, j += colStride, k += colStride) {
dst[i] = (rowA[j] + rowA[k] + rowB[j] + rowB[k]) / 4;
}
- }
- return;
- /* Begin hardware formats */
- case MESA_FORMAT_RGBA8888:
- case MESA_FORMAT_RGBA8888_REV:
- case MESA_FORMAT_ARGB8888:
- case MESA_FORMAT_ARGB8888_REV:
-#if FEATURE_EXT_texture_sRGB
- case MESA_FORMAT_SRGBA8:
-#endif
- {
+ }
+ else if (datatype == GL_UNSIGNED_BYTE && comps == 4) {
GLuint i, j, k;
const GLubyte (*rowA)[4] = (const GLubyte (*)[4]) srcRowA;
const GLubyte (*rowB)[4] = (const GLubyte (*)[4]) srcRowB;
dst[i][3] = (rowA[j][3] + rowA[k][3] +
rowB[j][3] + rowB[k][3]) / 4;
}
- }
- return;
- case MESA_FORMAT_RGB888:
- case MESA_FORMAT_BGR888:
-#if FEATURE_EXT_texture_sRGB
- case MESA_FORMAT_SRGB8:
-#endif
- {
+ }
+ else if (datatype == GL_UNSIGNED_BYTE && comps == 3) {
GLuint i, j, k;
const GLubyte (*rowA)[3] = (const GLubyte (*)[3]) srcRowA;
const GLubyte (*rowB)[3] = (const GLubyte (*)[3]) srcRowB;
dst[i][2] = (rowA[j][2] + rowA[k][2] +
rowB[j][2] + rowB[k][2]) / 4;
}
- }
- return;
- case MESA_FORMAT_RGB565:
- case MESA_FORMAT_RGB565_REV:
- {
+ }
+ else if (datatype == GL_UNSIGNED_SHORT_5_6_5 && comps == 3) {
GLuint i, j, k;
const GLushort *rowA = (const GLushort *) srcRowA;
const GLushort *rowB = (const GLushort *) srcRowB;
const GLint blue = (rowAb0 + rowAb1 + rowBb0 + rowBb1) >> 2;
dst[i] = (blue << 11) | (green << 5) | red;
}
- }
- return;
- case MESA_FORMAT_ARGB4444:
- case MESA_FORMAT_ARGB4444_REV:
- {
+ }
+ else if (datatype == GL_UNSIGNED_SHORT_4_4_4_4 && comps == 4) {
GLuint i, j, k;
const GLushort *rowA = (const GLushort *) srcRowA;
const GLushort *rowB = (const GLushort *) srcRowB;
const GLint alpha = (rowAa0 + rowAa1 + rowBa0 + rowBa1) >> 2;
dst[i] = (alpha << 12) | (blue << 8) | (green << 4) | red;
}
- }
- return;
- case MESA_FORMAT_ARGB1555:
- case MESA_FORMAT_ARGB1555_REV: /* XXX broken? */
- {
+ }
+ else if (datatype == GL_UNSIGNED_SHORT_1_5_5_5_REV && comps == 4) {
GLuint i, j, k;
const GLushort *rowA = (const GLushort *) srcRowA;
const GLushort *rowB = (const GLushort *) srcRowB;
const GLint alpha = (rowAa0 + rowAa1 + rowBa0 + rowBa1) >> 2;
dst[i] = (alpha << 15) | (blue << 10) | (green << 5) | red;
}
- }
- return;
- case MESA_FORMAT_AL88:
- case MESA_FORMAT_AL88_REV:
-#if FEATURE_EXT_texture_sRGB
- case MESA_FORMAT_SLA8:
-#endif
- {
+ }
+ else if (datatype == GL_UNSIGNED_BYTE && comps == 2) {
GLuint i, j, k;
const GLubyte (*rowA)[2] = (const GLubyte (*)[2]) srcRowA;
const GLubyte (*rowB)[2] = (const GLubyte (*)[2]) srcRowB;
dst[i][1] = (rowA[j][1] + rowA[k][1] +
rowB[j][1] + rowB[k][1]) >> 2;
}
- }
- return;
- case MESA_FORMAT_RGB332:
- {
+ }
+ else if (datatype == GL_UNSIGNED_BYTE_3_3_2 && comps == 3) {
GLuint i, j, k;
const GLubyte *rowA = (const GLubyte *) srcRowA;
const GLubyte *rowB = (const GLubyte *) srcRowB;
const GLint blue = (rowAb0 + rowAb1 + rowBb0 + rowBb1) >> 2;
dst[i] = (blue << 5) | (green << 2) | red;
}
- }
- return;
- case MESA_FORMAT_A8:
- case MESA_FORMAT_L8:
- case MESA_FORMAT_I8:
- case MESA_FORMAT_CI8:
-#if FEATURE_EXT_texture_sRGB
- case MESA_FORMAT_SL8:
-#endif
- {
+ }
+ else if (datatype == GL_UNSIGNED_BYTE && comps == 1) {
GLuint i, j, k;
const GLubyte *rowA = (const GLubyte *) srcRowA;
const GLubyte *rowB = (const GLubyte *) srcRowB;
i++, j += colStride, k += colStride) {
dst[i] = (rowA[j] + rowA[k] + rowB[j] + rowB[k]) >> 2;
}
- }
- return;
- case MESA_FORMAT_RGBA_FLOAT32:
- {
+ }
+ else if (datatype == GL_FLOAT && comps == 4) {
GLuint i, j, k;
const GLfloat (*rowA)[4] = (const GLfloat (*)[4]) srcRowA;
const GLfloat (*rowB)[4] = (const GLfloat (*)[4]) srcRowB;
dst[i][3] = (rowA[j][3] + rowA[k][3] +
rowB[j][3] + rowB[k][3]) * 0.25F;
}
- }
- return;
- case MESA_FORMAT_RGBA_FLOAT16:
- {
+ }
+ else if (datatype == GL_HALF_FLOAT_ARB && comps == 4) {
GLuint i, j, k, comp;
const GLhalfARB (*rowA)[4] = (const GLhalfARB (*)[4]) srcRowA;
const GLhalfARB (*rowB)[4] = (const GLhalfARB (*)[4]) srcRowB;
dst[i][comp] = _mesa_float_to_half((aj + ak + bj + bk) * 0.25F);
}
}
- }
- return;
- case MESA_FORMAT_RGB_FLOAT32:
- {
+ }
+ else if (datatype == GL_FLOAT && comps == 3) {
GLuint i, j, k;
const GLfloat (*rowA)[3] = (const GLfloat (*)[3]) srcRowA;
const GLfloat (*rowB)[3] = (const GLfloat (*)[3]) srcRowB;
dst[i][2] = (rowA[j][2] + rowA[k][2] +
rowB[j][2] + rowB[k][2]) * 0.25F;
}
- }
- return;
- case MESA_FORMAT_RGB_FLOAT16:
- {
+ }
+ else if (datatype == GL_HALF_FLOAT_ARB && comps == 3) {
GLuint i, j, k, comp;
const GLhalfARB (*rowA)[3] = (const GLhalfARB (*)[3]) srcRowA;
const GLhalfARB (*rowB)[3] = (const GLhalfARB (*)[3]) srcRowB;
dst[i][comp] = _mesa_float_to_half((aj + ak + bj + bk) * 0.25F);
}
}
- }
- return;
- case MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32:
- {
+ }
+ else if (datatype == GL_FLOAT && comps == 2) {
GLuint i, j, k;
const GLfloat (*rowA)[2] = (const GLfloat (*)[2]) srcRowA;
const GLfloat (*rowB)[2] = (const GLfloat (*)[2]) srcRowB;
dst[i][1] = (rowA[j][1] + rowA[k][1] +
rowB[j][1] + rowB[k][1]) * 0.25F;
}
- }
- return;
- case MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16:
- {
+ }
+ else if (datatype == GL_HALF_FLOAT_ARB && comps == 2) {
GLuint i, j, k, comp;
const GLhalfARB (*rowA)[2] = (const GLhalfARB (*)[2]) srcRowA;
const GLhalfARB (*rowB)[2] = (const GLhalfARB (*)[2]) srcRowB;
dst[i][comp] = _mesa_float_to_half((aj + ak + bj + bk) * 0.25F);
}
}
- }
- return;
- case MESA_FORMAT_ALPHA_FLOAT32:
- case MESA_FORMAT_LUMINANCE_FLOAT32:
- case MESA_FORMAT_INTENSITY_FLOAT32:
- {
+ }
+ else if (datatype == GL_FLOAT && comps == 1) {
GLuint i, j, k;
const GLfloat *rowA = (const GLfloat *) srcRowA;
const GLfloat *rowB = (const GLfloat *) srcRowB;
i++, j += colStride, k += colStride) {
dst[i] = (rowA[j] + rowA[k] + rowB[j] + rowB[k]) * 0.25F;
}
- }
- return;
- case MESA_FORMAT_ALPHA_FLOAT16:
- case MESA_FORMAT_LUMINANCE_FLOAT16:
- case MESA_FORMAT_INTENSITY_FLOAT16:
- {
+ }
+ else if (datatype == GL_HALF_FLOAT_ARB && comps == 1) {
GLuint i, j, k;
const GLhalfARB *rowA = (const GLhalfARB *) srcRowA;
const GLhalfARB *rowB = (const GLhalfARB *) srcRowB;
bk = _mesa_half_to_float(rowB[k]);
dst[i] = _mesa_float_to_half((aj + ak + bj + bk) * 0.25F);
}
- }
- return;
-
- default:
+ }
+ else {
_mesa_problem(NULL, "bad format in do_row()");
}
}
*/
static void
-make_1d_mipmap(const struct gl_texture_format *format, GLint border,
+make_1d_mipmap(GLenum datatype, GLuint comps, GLint border,
GLint srcWidth, const GLubyte *srcPtr,
GLint dstWidth, GLubyte *dstPtr)
{
- const GLint bpt = format->TexelBytes;
+ const GLint bpt = bytes_per_pixel(datatype, comps);
const GLubyte *src;
GLubyte *dst;
dst = dstPtr + border * bpt;
/* we just duplicate the input row, kind of hack, saves code */
- do_row(format, srcWidth - 2 * border, src, src,
+ do_row(datatype, comps, srcWidth - 2 * border, src, src,
dstWidth - 2 * border, dst);
if (border) {
* XXX need to use the tex image's row stride!
*/
static void
-make_2d_mipmap(const struct gl_texture_format *format, GLint border,
+make_2d_mipmap(GLenum datatype, GLuint comps, GLint border,
GLint srcWidth, GLint srcHeight, const GLubyte *srcPtr,
GLint dstWidth, GLint dstHeight, GLubyte *dstPtr)
{
- const GLint bpt = format->TexelBytes;
+ const GLint bpt = bytes_per_pixel(datatype, comps);
const GLint srcWidthNB = srcWidth - 2 * border; /* sizes w/out border */
const GLint dstWidthNB = dstWidth - 2 * border;
const GLint dstHeightNB = dstHeight - 2 * border;
dst = dstPtr + border * ((dstWidth + 1) * bpt);
for (row = 0; row < dstHeightNB; row++) {
- do_row(format, srcWidthNB, srcA, srcB,
+ do_row(datatype, comps, srcWidthNB, srcA, srcB,
dstWidthNB, dst);
srcA += 2 * srcRowStride;
srcB += 2 * srcRowStride;
MEMCPY(dstPtr + (dstWidth * dstHeight - 1) * bpt,
srcPtr + (srcWidth * srcHeight - 1) * bpt, bpt);
/* lower border */
- do_row(format, srcWidthNB,
+ do_row(datatype, comps, srcWidthNB,
srcPtr + bpt,
srcPtr + bpt,
dstWidthNB, dstPtr + bpt);
/* upper border */
- do_row(format, srcWidthNB,
+ do_row(datatype, comps, srcWidthNB,
srcPtr + (srcWidth * (srcHeight - 1) + 1) * bpt,
srcPtr + (srcWidth * (srcHeight - 1) + 1) * bpt,
dstWidthNB,
else {
/* average two src pixels each dest pixel */
for (row = 0; row < dstHeightNB; row += 2) {
- do_row(format, 1,
+ do_row(datatype, comps, 1,
srcPtr + (srcWidth * (row * 2 + 1)) * bpt,
srcPtr + (srcWidth * (row * 2 + 2)) * bpt,
1, dstPtr + (dstWidth * row + 1) * bpt);
- do_row(format, 1,
+ do_row(datatype, comps, 1,
srcPtr + (srcWidth * (row * 2 + 1) + srcWidth - 1) * bpt,
srcPtr + (srcWidth * (row * 2 + 2) + srcWidth - 1) * bpt,
1, dstPtr + (dstWidth * row + 1 + dstWidth - 1) * bpt);
static void
-make_3d_mipmap(const struct gl_texture_format *format, GLint border,
+make_3d_mipmap(GLenum datatype, GLuint comps, GLint border,
GLint srcWidth, GLint srcHeight, GLint srcDepth,
const GLubyte *srcPtr,
GLint dstWidth, GLint dstHeight, GLint dstDepth,
GLubyte *dstPtr)
{
- const GLint bpt = format->TexelBytes;
+ const GLint bpt = bytes_per_pixel(datatype, comps);
const GLint srcWidthNB = srcWidth - 2 * border; /* sizes w/out border */
const GLint srcDepthNB = srcDepth - 2 * border;
const GLint dstWidthNB = dstWidth - 2 * border;
for (row = 0; row < dstHeightNB; row++) {
/* Average together two rows from first src image */
- do_row(format, srcWidthNB, srcImgARowA, srcImgARowB,
+ do_row(datatype, comps, srcWidthNB, srcImgARowA, srcImgARowB,
srcWidthNB, tmpRowA);
/* Average together two rows from second src image */
- do_row(format, srcWidthNB, srcImgBRowA, srcImgBRowB,
+ do_row(datatype, comps, srcWidthNB, srcImgBRowA, srcImgBRowB,
srcWidthNB, tmpRowB);
/* Average together the temp rows to make the final row */
- do_row(format, srcWidthNB, tmpRowA, tmpRowB,
+ do_row(datatype, comps, srcWidthNB, tmpRowA, tmpRowB,
dstWidthNB, dstImgRow);
/* advance to next rows */
srcImgARowA += bytesPerSrcRow + srcRowOffset;
/* Luckily we can leverage the make_2d_mipmap() function here! */
if (border > 0) {
/* do front border image */
- make_2d_mipmap(format, 1, srcWidth, srcHeight, srcPtr,
+ make_2d_mipmap(datatype, comps, 1, srcWidth, srcHeight, srcPtr,
dstWidth, dstHeight, dstPtr);
/* do back border image */
- make_2d_mipmap(format, 1, srcWidth, srcHeight,
+ make_2d_mipmap(datatype, comps, 1, srcWidth, srcHeight,
srcPtr + bytesPerSrcImage * (srcDepth - 1),
dstWidth, dstHeight,
dstPtr + bytesPerDstImage * (dstDepth - 1));
/* do border along [img][row=0][col=0] */
src = srcPtr + (img * 2 + 1) * bytesPerSrcImage;
dst = dstPtr + (img + 1) * bytesPerDstImage;
- do_row(format, 1, src, src + srcImageOffset, 1, dst);
+ do_row(datatype, comps, 1, src, src + srcImageOffset, 1, dst);
/* do border along [img][row=dstHeight-1][col=0] */
src = srcPtr + (img * 2 + 1) * bytesPerSrcImage
+ (srcHeight - 1) * bytesPerSrcRow;
dst = dstPtr + (img + 1) * bytesPerDstImage
+ (dstHeight - 1) * bytesPerDstRow;
- do_row(format, 1, src, src + srcImageOffset, 1, dst);
+ do_row(datatype, comps, 1, src, src + srcImageOffset, 1, dst);
/* do border along [img][row=0][col=dstWidth-1] */
src = srcPtr + (img * 2 + 1) * bytesPerSrcImage
+ (srcWidth - 1) * bpt;
dst = dstPtr + (img + 1) * bytesPerDstImage
+ (dstWidth - 1) * bpt;
- do_row(format, 1, src, src + srcImageOffset, 1, dst);
+ do_row(datatype, comps, 1, src, src + srcImageOffset, 1, dst);
/* do border along [img][row=dstHeight-1][col=dstWidth-1] */
src = srcPtr + (img * 2 + 1) * bytesPerSrcImage
+ (bytesPerSrcImage - bpt);
dst = dstPtr + (img + 1) * bytesPerDstImage
+ (bytesPerDstImage - bpt);
- do_row(format, 1, src, src + srcImageOffset, 1, dst);
+ do_row(datatype, comps, 1, src, src + srcImageOffset, 1, dst);
}
}
}
static void
-make_1d_stack_mipmap(const struct gl_texture_format *format, GLint border,
+make_1d_stack_mipmap(GLenum datatype, GLuint comps, GLint border,
GLint srcWidth, const GLubyte *srcPtr,
GLint dstWidth, GLint dstHeight, GLubyte *dstPtr)
{
- const GLint bpt = format->TexelBytes;
+ const GLint bpt = bytes_per_pixel(datatype, comps);
const GLint srcWidthNB = srcWidth - 2 * border; /* sizes w/out border */
const GLint dstWidthNB = dstWidth - 2 * border;
const GLint dstHeightNB = dstHeight - 2 * border;
dst = dstPtr + border * ((dstWidth + 1) * bpt);
for (row = 0; row < dstHeightNB; row++) {
- do_row(format, srcWidthNB, src, src,
+ do_row(datatype, comps, srcWidthNB, src, src,
dstWidthNB, dst);
src += srcRowStride;
dst += dstRowStride;
* and \c make_2d_mipmap.
*/
static void
-make_2d_stack_mipmap(const struct gl_texture_format *format, GLint border,
+make_2d_stack_mipmap(GLenum datatype, GLuint comps, GLint border,
GLint srcWidth, GLint srcHeight, const GLubyte *srcPtr,
GLint dstWidth, GLint dstHeight, GLint dstDepth,
GLubyte *dstPtr)
{
- const GLint bpt = format->TexelBytes;
+ const GLint bpt = bytes_per_pixel(datatype, comps);
const GLint srcWidthNB = srcWidth - 2 * border; /* sizes w/out border */
const GLint dstWidthNB = dstWidth - 2 * border;
const GLint dstHeightNB = dstHeight - 2 * border;
for (layer = 0; layer < dstDepthNB; layer++) {
for (row = 0; row < dstHeightNB; row++) {
- do_row(format, srcWidthNB, srcA, srcB,
+ do_row(datatype, comps, srcWidthNB, srcA, srcB,
dstWidthNB, dst);
srcA += 2 * srcRowStride;
srcB += 2 * srcRowStride;
MEMCPY(dstPtr + (dstWidth * dstHeight - 1) * bpt,
srcPtr + (srcWidth * srcHeight - 1) * bpt, bpt);
/* lower border */
- do_row(format, srcWidthNB,
+ do_row(datatype, comps, srcWidthNB,
srcPtr + bpt,
srcPtr + bpt,
dstWidthNB, dstPtr + bpt);
/* upper border */
- do_row(format, srcWidthNB,
+ do_row(datatype, comps, srcWidthNB,
srcPtr + (srcWidth * (srcHeight - 1) + 1) * bpt,
srcPtr + (srcWidth * (srcHeight - 1) + 1) * bpt,
dstWidthNB,
else {
/* average two src pixels each dest pixel */
for (row = 0; row < dstHeightNB; row += 2) {
- do_row(format, 1,
+ do_row(datatype, comps, 1,
srcPtr + (srcWidth * (row * 2 + 1)) * bpt,
srcPtr + (srcWidth * (row * 2 + 2)) * bpt,
1, dstPtr + (dstWidth * row + 1) * bpt);
- do_row(format, 1,
+ do_row(datatype, comps, 1,
srcPtr + (srcWidth * (row * 2 + 1) + srcWidth - 1) * bpt,
srcPtr + (srcWidth * (row * 2 + 2) + srcWidth - 1) * bpt,
1, dstPtr + (dstWidth * row + 1 + dstWidth - 1) * bpt);
const GLubyte *srcData = NULL;
GLubyte *dstData = NULL;
GLint level, maxLevels;
+ GLenum datatype;
+ GLuint comps;
ASSERT(texObj);
/* XXX choose cube map face here??? */
convertFormat = srcImage->TexFormat;
}
+ mesa_format_to_type_and_comps(convertFormat, &datatype, &comps);
+
for (level = texObj->BaseLevel; level < texObj->MaxLevel
&& level < maxLevels - 1; level++) {
/* generate image[level+1] from image[level] */
*/
switch (target) {
case GL_TEXTURE_1D:
- make_1d_mipmap(convertFormat, border,
+ make_1d_mipmap(datatype, comps, border,
srcWidth, srcData,
dstWidth, dstData);
break;
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
- make_2d_mipmap(convertFormat, border,
+ make_2d_mipmap(datatype, comps, border,
srcWidth, srcHeight, srcData,
dstWidth, dstHeight, dstData);
break;
case GL_TEXTURE_3D:
- make_3d_mipmap(convertFormat, border,
+ make_3d_mipmap(datatype, comps, border,
srcWidth, srcHeight, srcDepth, srcData,
dstWidth, dstHeight, dstDepth, dstData);
break;
case GL_TEXTURE_1D_ARRAY_EXT:
- make_1d_stack_mipmap(convertFormat, border,
+ make_1d_stack_mipmap(datatype, comps, border,
srcWidth, srcData,
dstWidth, dstHeight, dstData);
break;
case GL_TEXTURE_2D_ARRAY_EXT:
- make_2d_stack_mipmap(convertFormat, border,
+ make_2d_stack_mipmap(datatype, comps, border,
srcWidth, srcHeight, srcData,
dstWidth, dstHeight, dstDepth, dstData);
break;
projects / mesa.git / commitdiff