mirror of
https://gitlab.freedesktop.org/mesa/mesa.git
synced 2026-01-26 01:20:22 +01:00
rewrite/simplify the fast_draw_pixels() function
This commit is contained in:
Brian Paul
parent
f971e24cf0
commit
55fa6a2fdb
1 changed files with 226 additions and 354 deletions
|
|
@ -40,7 +40,7 @@
|
|||
#include "s_zoom.h"
|
||||
|
||||
|
||||
/*
|
||||
/**
|
||||
* Try to do a fast and simple RGB(a) glDrawPixels.
|
||||
* Return: GL_TRUE if success, GL_FALSE if slow path must be used instead
|
||||
*/
|
||||
|
|
@ -48,24 +48,29 @@ static GLboolean
|
|||
fast_draw_pixels(GLcontext *ctx, GLint x, GLint y,
|
||||
GLsizei width, GLsizei height,
|
||||
GLenum format, GLenum type,
|
||||
const struct gl_pixelstore_attrib *unpack,
|
||||
const struct gl_pixelstore_attrib *userUnpack,
|
||||
const GLvoid *pixels)
|
||||
{
|
||||
const GLint imgX = x, imgY = y;
|
||||
struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[0][0];
|
||||
const GLenum rbType = rb->DataType;
|
||||
SWcontext *swrast = SWRAST_CONTEXT(ctx);
|
||||
SWspan span;
|
||||
GLboolean simpleZoom;
|
||||
GLint yStep; /* +1 or -1 */
|
||||
struct gl_pixelstore_attrib unpack;
|
||||
GLint destX, destY, drawWidth, drawHeight; /* post clipping */
|
||||
|
||||
INIT_SPAN(span, GL_BITMAP, 0, 0, SPAN_RGBA);
|
||||
|
||||
if (swrast->_RasterMask & MULTI_DRAW_BIT)
|
||||
return GL_FALSE;
|
||||
|
||||
if (ctx->_ImageTransferState) {
|
||||
/* don't handle any pixel transfer options here */
|
||||
if ((swrast->_RasterMask & ~CLIP_BIT) ||
|
||||
ctx->Texture._EnabledCoordUnits ||
|
||||
userUnpack->Alignment != 1 ||
|
||||
userUnpack->SwapBytes ||
|
||||
ctx->_ImageTransferState) {
|
||||
/* can't handle any of those conditions */
|
||||
return GL_FALSE;
|
||||
}
|
||||
|
||||
INIT_SPAN(span, GL_BITMAP, 0, 0, SPAN_RGBA);
|
||||
if (ctx->Depth.Test)
|
||||
_swrast_span_default_z(ctx, &span);
|
||||
if (swrast->_FogEnabled)
|
||||
|
|
@ -73,373 +78,235 @@ fast_draw_pixels(GLcontext *ctx, GLint x, GLint y,
|
|||
if (ctx->Texture._EnabledCoordUnits)
|
||||
_swrast_span_default_texcoords(ctx, &span);
|
||||
|
||||
if ((swrast->_RasterMask & ~CLIP_BIT) == 0
|
||||
&& ctx->Texture._EnabledCoordUnits == 0
|
||||
&& unpack->Alignment == 1 /* XXX may not really need this */
|
||||
&& !unpack->SwapBytes
|
||||
&& !unpack->LsbFirst) {
|
||||
/* copy input params since clipping may change them */
|
||||
unpack = *userUnpack;
|
||||
destX = x;
|
||||
destY = y;
|
||||
drawWidth = width;
|
||||
drawHeight = height;
|
||||
|
||||
/* XXX there's a lot of clipping code here that should be replaced
|
||||
* by a call to _mesa_clip_drawpixels().
|
||||
*/
|
||||
GLint destX = x;
|
||||
GLint destY = y;
|
||||
GLint drawWidth = width; /* actual width drawn */
|
||||
GLint drawHeight = height; /* actual height drawn */
|
||||
GLint skipPixels = unpack->SkipPixels;
|
||||
GLint skipRows = unpack->SkipRows;
|
||||
GLint rowLength;
|
||||
|
||||
if (unpack->RowLength > 0)
|
||||
rowLength = unpack->RowLength;
|
||||
else
|
||||
rowLength = width;
|
||||
|
||||
/* If we're not using pixel zoom then do all clipping calculations
|
||||
* now. Otherwise, we'll let the _swrast_write_zoomed_*_span() functions
|
||||
* handle the clipping.
|
||||
*/
|
||||
if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) {
|
||||
/* horizontal clipping */
|
||||
if (destX < ctx->DrawBuffer->_Xmin) {
|
||||
skipPixels += (ctx->DrawBuffer->_Xmin - destX);
|
||||
drawWidth -= (ctx->DrawBuffer->_Xmin - destX);
|
||||
destX = ctx->DrawBuffer->_Xmin;
|
||||
}
|
||||
if (destX + drawWidth > ctx->DrawBuffer->_Xmax)
|
||||
drawWidth -= (destX + drawWidth - ctx->DrawBuffer->_Xmax);
|
||||
if (drawWidth <= 0)
|
||||
return GL_TRUE;
|
||||
|
||||
/* vertical clipping */
|
||||
if (destY < ctx->DrawBuffer->_Ymin) {
|
||||
skipRows += (ctx->DrawBuffer->_Ymin - destY);
|
||||
drawHeight -= (ctx->DrawBuffer->_Ymin - destY);
|
||||
destY = ctx->DrawBuffer->_Ymin;
|
||||
}
|
||||
if (destY + drawHeight > ctx->DrawBuffer->_Ymax)
|
||||
drawHeight -= (destY + drawHeight - ctx->DrawBuffer->_Ymax);
|
||||
if (drawHeight <= 0)
|
||||
return GL_TRUE;
|
||||
/* check for simple zooming and clipping */
|
||||
if (ctx->Pixel.ZoomX == 1.0F &&
|
||||
(ctx->Pixel.ZoomY == 1.0F || ctx->Pixel.ZoomY == -1.0F)) {
|
||||
if (!_mesa_clip_drawpixels(ctx, &destX, &destY,
|
||||
&drawWidth, &drawHeight, &unpack)) {
|
||||
/* image was completely clipped: no-op, all done */
|
||||
return GL_TRUE;
|
||||
}
|
||||
else if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==-1.0F) {
|
||||
/* upside-down image */
|
||||
/* horizontal clipping */
|
||||
if (destX < ctx->DrawBuffer->_Xmin) {
|
||||
skipPixels += (ctx->DrawBuffer->_Xmin - destX);
|
||||
drawWidth -= (ctx->DrawBuffer->_Xmin - destX);
|
||||
destX = ctx->DrawBuffer->_Xmin;
|
||||
}
|
||||
if (destX + drawWidth > ctx->DrawBuffer->_Xmax)
|
||||
drawWidth -= (destX + drawWidth - ctx->DrawBuffer->_Xmax);
|
||||
if (drawWidth <= 0)
|
||||
return GL_TRUE;
|
||||
simpleZoom = GL_TRUE;
|
||||
yStep = (GLint) ctx->Pixel.ZoomY;
|
||||
ASSERT(yStep == 1 || yStep == -1);
|
||||
}
|
||||
else {
|
||||
/* non-simple zooming */
|
||||
simpleZoom = GL_FALSE;
|
||||
if (unpack.RowLength == 0)
|
||||
unpack.RowLength = width;
|
||||
}
|
||||
|
||||
/* vertical clipping */
|
||||
if (destY > ctx->DrawBuffer->_Ymax) {
|
||||
skipRows += (destY - ctx->DrawBuffer->_Ymax);
|
||||
drawHeight -= (destY - ctx->DrawBuffer->_Ymax);
|
||||
destY = ctx->DrawBuffer->_Ymax;
|
||||
/*
|
||||
* Ready to draw!
|
||||
* The window region at (destX, destY) of size (drawWidth, drawHeight)
|
||||
* will be written to.
|
||||
* We'll take pixel data from buffer pointed to by "pixels" but we'll
|
||||
* skip "unpack.SkipRows" rows and skip "unpack.SkipPixels" pixels/row.
|
||||
*/
|
||||
|
||||
if (format == GL_RGBA && type == CHAN_TYPE && rbType == CHAN_TYPE) {
|
||||
const GLchan *src = (const GLchan *) pixels
|
||||
+ (unpack.SkipRows * unpack.RowLength + unpack.SkipPixels) * 4;
|
||||
if (simpleZoom) {
|
||||
GLint row;
|
||||
for (row = 0; row < drawHeight; row++) {
|
||||
rb->PutRow(ctx, rb, drawWidth, destX, destY, src, NULL);
|
||||
src += unpack.RowLength * 4;
|
||||
destY += yStep;
|
||||
}
|
||||
if (destY - drawHeight < ctx->DrawBuffer->_Ymin)
|
||||
drawHeight -= (ctx->DrawBuffer->_Ymin - (destY - drawHeight));
|
||||
if (drawHeight <= 0)
|
||||
return GL_TRUE;
|
||||
}
|
||||
else {
|
||||
if (drawWidth > MAX_WIDTH)
|
||||
return GL_FALSE; /* fall back to general case path */
|
||||
/* with zooming */
|
||||
GLint row;
|
||||
for (row = 0; row < drawHeight; row++) {
|
||||
span.x = destX;
|
||||
span.y = destY + row;
|
||||
span.end = drawWidth;
|
||||
_swrast_write_zoomed_rgba_span(ctx, imgX, imgY, &span,
|
||||
(CONST GLchan (*)[4]) src);
|
||||
src += unpack.RowLength * 4;
|
||||
}
|
||||
}
|
||||
return GL_TRUE;
|
||||
}
|
||||
|
||||
if (format == GL_RGB && type == CHAN_TYPE && rbType == CHAN_TYPE) {
|
||||
const GLchan *src = (const GLchan *) pixels
|
||||
+ (unpack.SkipRows * unpack.RowLength + unpack.SkipPixels) * 3;
|
||||
if (simpleZoom) {
|
||||
GLint row;
|
||||
for (row = 0; row < drawHeight; row++) {
|
||||
rb->PutRowRGB(ctx, rb, drawWidth, destX, destY, src, NULL);
|
||||
src += unpack.RowLength * 3;
|
||||
destY += yStep;
|
||||
}
|
||||
}
|
||||
else {
|
||||
/* with zooming */
|
||||
GLint row;
|
||||
for (row = 0; row < drawHeight; row++) {
|
||||
span.x = destX;
|
||||
span.y = destY;
|
||||
span.end = drawWidth;
|
||||
_swrast_write_zoomed_rgb_span(ctx, imgX, imgY, &span,
|
||||
(CONST GLchan (*)[3]) src);
|
||||
src += unpack.RowLength * 3;
|
||||
destY++;
|
||||
}
|
||||
}
|
||||
return GL_TRUE;
|
||||
}
|
||||
|
||||
/*
|
||||
* Ready to draw!
|
||||
* The window region at (destX, destY) of size (drawWidth, drawHeight)
|
||||
* will be written to.
|
||||
* We'll take pixel data from buffer pointed to by "pixels" but we'll
|
||||
* skip "skipRows" rows and skip "skipPixels" pixels/row.
|
||||
*/
|
||||
if (format == GL_LUMINANCE && type == CHAN_TYPE && rbType == CHAN_TYPE) {
|
||||
const GLchan *src = (const GLchan *) pixels
|
||||
+ (unpack.SkipRows * unpack.RowLength + unpack.SkipPixels);
|
||||
if (simpleZoom) {
|
||||
/* no zooming */
|
||||
GLint row;
|
||||
ASSERT(drawWidth <= MAX_WIDTH);
|
||||
for (row = 0; row < drawHeight; row++) {
|
||||
GLchan rgb[MAX_WIDTH][3];
|
||||
GLint i;
|
||||
for (i = 0;i<drawWidth;i++) {
|
||||
rgb[i][0] = src[i];
|
||||
rgb[i][1] = src[i];
|
||||
rgb[i][2] = src[i];
|
||||
}
|
||||
rb->PutRowRGB(ctx, rb, drawWidth, destX, destY, rgb, NULL);
|
||||
src += unpack.RowLength;
|
||||
destY += yStep;
|
||||
}
|
||||
}
|
||||
else {
|
||||
/* with zooming */
|
||||
GLint row;
|
||||
ASSERT(drawWidth <= MAX_WIDTH);
|
||||
for (row = 0; row < drawHeight; row++) {
|
||||
GLchan rgb[MAX_WIDTH][3];
|
||||
GLint i;
|
||||
for (i = 0;i<drawWidth;i++) {
|
||||
rgb[i][0] = src[i];
|
||||
rgb[i][1] = src[i];
|
||||
rgb[i][2] = src[i];
|
||||
}
|
||||
span.x = destX;
|
||||
span.y = destY;
|
||||
span.end = drawWidth;
|
||||
_swrast_write_zoomed_rgb_span(ctx, imgX, imgY, &span,
|
||||
(CONST GLchan (*)[3]) rgb);
|
||||
src += unpack.RowLength;
|
||||
destY++;
|
||||
}
|
||||
}
|
||||
return GL_TRUE;
|
||||
}
|
||||
|
||||
if (format == GL_RGBA && type == CHAN_TYPE) {
|
||||
if (ctx->Visual.rgbMode) {
|
||||
const GLchan *src = (const GLchan *) pixels
|
||||
+ (skipRows * rowLength + skipPixels) * 4;
|
||||
if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) {
|
||||
/* no zooming */
|
||||
GLint row;
|
||||
for (row=0; row<drawHeight; row++) {
|
||||
rb->PutRow(ctx, rb, drawWidth, destX, destY, src, NULL);
|
||||
src += rowLength * 4;
|
||||
destY++;
|
||||
}
|
||||
}
|
||||
else if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==-1.0F) {
|
||||
/* upside-down */
|
||||
GLint row;
|
||||
for (row=0; row<drawHeight; row++) {
|
||||
destY--;
|
||||
rb->PutRow(ctx, rb, drawWidth, destX, destY, src, NULL);
|
||||
src += rowLength * 4;
|
||||
}
|
||||
}
|
||||
else {
|
||||
/* with zooming */
|
||||
GLint row;
|
||||
for (row=0; row<drawHeight; row++) {
|
||||
span.x = destX;
|
||||
span.y = destY + row;
|
||||
span.end = drawWidth;
|
||||
_swrast_write_zoomed_rgba_span(ctx, imgX, imgY, &span,
|
||||
(CONST GLchan (*)[4]) src);
|
||||
src += rowLength * 4;
|
||||
}
|
||||
if (format == GL_LUMINANCE_ALPHA && type == CHAN_TYPE && rbType == CHAN_TYPE) {
|
||||
const GLchan *src = (const GLchan *) pixels
|
||||
+ (unpack.SkipRows * unpack.RowLength + unpack.SkipPixels)*2;
|
||||
if (simpleZoom) {
|
||||
GLint row;
|
||||
ASSERT(drawWidth <= MAX_WIDTH);
|
||||
for (row = 0; row < drawHeight; row++) {
|
||||
GLint i;
|
||||
const GLchan *ptr = src;
|
||||
for (i = 0;i<drawWidth;i++) {
|
||||
span.array->rgba[i][0] = *ptr;
|
||||
span.array->rgba[i][1] = *ptr;
|
||||
span.array->rgba[i][2] = *ptr++;
|
||||
span.array->rgba[i][3] = *ptr++;
|
||||
}
|
||||
rb->PutRow(ctx, rb, drawWidth, destX, destY,
|
||||
span.array->rgba, NULL);
|
||||
src += unpack.RowLength*2;
|
||||
destY += yStep;
|
||||
}
|
||||
return GL_TRUE;
|
||||
}
|
||||
else if (format == GL_RGB && type == CHAN_TYPE) {
|
||||
if (ctx->Visual.rgbMode) {
|
||||
const GLchan *src = (const GLchan *) pixels
|
||||
+ (skipRows * rowLength + skipPixels) * 3;
|
||||
if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) {
|
||||
GLint row;
|
||||
for (row=0; row<drawHeight; row++) {
|
||||
rb->PutRowRGB(ctx, rb, drawWidth, destX, destY, src, NULL);
|
||||
src += rowLength * 3;
|
||||
destY++;
|
||||
}
|
||||
}
|
||||
else if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==-1.0F) {
|
||||
/* upside-down */
|
||||
GLint row;
|
||||
for (row=0; row<drawHeight; row++) {
|
||||
destY--;
|
||||
rb->PutRowRGB(ctx, rb, drawWidth, destX, destY, src, NULL);
|
||||
src += rowLength * 3;
|
||||
}
|
||||
}
|
||||
else {
|
||||
/* with zooming */
|
||||
GLint row;
|
||||
for (row=0; row<drawHeight; row++) {
|
||||
span.x = destX;
|
||||
span.y = destY;
|
||||
span.end = drawWidth;
|
||||
_swrast_write_zoomed_rgb_span(ctx, imgX, imgY, &span,
|
||||
(CONST GLchan (*)[3]) src);
|
||||
src += rowLength * 3;
|
||||
destY++;
|
||||
}
|
||||
else {
|
||||
/* with zooming */
|
||||
GLint row;
|
||||
ASSERT(drawWidth <= MAX_WIDTH);
|
||||
for (row = 0; row < drawHeight; row++) {
|
||||
const GLchan *ptr = src;
|
||||
GLint i;
|
||||
for (i = 0;i<drawWidth;i++) {
|
||||
span.array->rgba[i][0] = *ptr;
|
||||
span.array->rgba[i][1] = *ptr;
|
||||
span.array->rgba[i][2] = *ptr++;
|
||||
span.array->rgba[i][3] = *ptr++;
|
||||
}
|
||||
span.x = destX;
|
||||
span.y = destY;
|
||||
span.end = drawWidth;
|
||||
_swrast_write_zoomed_rgba_span(ctx, imgX, imgY, &span,
|
||||
(CONST GLchan (*)[4]) span.array->rgba);
|
||||
src += unpack.RowLength*2;
|
||||
destY++;
|
||||
}
|
||||
return GL_TRUE;
|
||||
}
|
||||
else if (format == GL_LUMINANCE && type == CHAN_TYPE) {
|
||||
if (ctx->Visual.rgbMode) {
|
||||
const GLchan *src = (const GLchan *) pixels
|
||||
+ (skipRows * rowLength + skipPixels);
|
||||
if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) {
|
||||
/* no zooming */
|
||||
GLint row;
|
||||
return GL_TRUE;
|
||||
}
|
||||
|
||||
if (format==GL_COLOR_INDEX && type==GL_UNSIGNED_BYTE) {
|
||||
const GLubyte *src = (const GLubyte *) pixels
|
||||
+ unpack.SkipRows * unpack.RowLength + unpack.SkipPixels;
|
||||
if (ctx->Visual.rgbMode && rbType == CHAN_TYPE) {
|
||||
/* convert CI data to RGBA */
|
||||
if (simpleZoom) {
|
||||
GLint row;
|
||||
for (row = 0; row < drawHeight; row++) {
|
||||
ASSERT(drawWidth <= MAX_WIDTH);
|
||||
for (row=0; row<drawHeight; row++) {
|
||||
GLchan rgb[MAX_WIDTH][3];
|
||||
GLint i;
|
||||
for (i=0;i<drawWidth;i++) {
|
||||
rgb[i][0] = src[i];
|
||||
rgb[i][1] = src[i];
|
||||
rgb[i][2] = src[i];
|
||||
}
|
||||
rb->PutRowRGB(ctx, rb, drawWidth, destX, destY, rgb, NULL);
|
||||
src += rowLength;
|
||||
destY++;
|
||||
}
|
||||
}
|
||||
else if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==-1.0F) {
|
||||
/* upside-down */
|
||||
GLint row;
|
||||
ASSERT(drawWidth <= MAX_WIDTH);
|
||||
for (row=0; row<drawHeight; row++) {
|
||||
GLchan rgb[MAX_WIDTH][3];
|
||||
GLint i;
|
||||
for (i=0;i<drawWidth;i++) {
|
||||
rgb[i][0] = src[i];
|
||||
rgb[i][1] = src[i];
|
||||
rgb[i][2] = src[i];
|
||||
}
|
||||
destY--;
|
||||
rb->PutRow(ctx, rb, drawWidth, destX, destY, rgb, NULL);
|
||||
src += rowLength;
|
||||
}
|
||||
}
|
||||
else {
|
||||
/* with zooming */
|
||||
GLint row;
|
||||
ASSERT(drawWidth <= MAX_WIDTH);
|
||||
for (row=0; row<drawHeight; row++) {
|
||||
GLchan rgb[MAX_WIDTH][3];
|
||||
GLint i;
|
||||
for (i=0;i<drawWidth;i++) {
|
||||
rgb[i][0] = src[i];
|
||||
rgb[i][1] = src[i];
|
||||
rgb[i][2] = src[i];
|
||||
}
|
||||
span.x = destX;
|
||||
span.y = destY;
|
||||
span.end = drawWidth;
|
||||
_swrast_write_zoomed_rgb_span(ctx, imgX, imgY, &span,
|
||||
(CONST GLchan (*)[3]) rgb);
|
||||
src += rowLength;
|
||||
destY++;
|
||||
}
|
||||
}
|
||||
}
|
||||
return GL_TRUE;
|
||||
}
|
||||
else if (format == GL_LUMINANCE_ALPHA && type == CHAN_TYPE) {
|
||||
if (ctx->Visual.rgbMode) {
|
||||
const GLchan *src = (const GLchan *) pixels
|
||||
+ (skipRows * rowLength + skipPixels)*2;
|
||||
if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) {
|
||||
/* no zooming */
|
||||
GLint row;
|
||||
ASSERT(drawWidth <= MAX_WIDTH);
|
||||
for (row=0; row<drawHeight; row++) {
|
||||
GLint i;
|
||||
const GLchan *ptr = src;
|
||||
for (i=0;i<drawWidth;i++) {
|
||||
span.array->rgba[i][0] = *ptr;
|
||||
span.array->rgba[i][1] = *ptr;
|
||||
span.array->rgba[i][2] = *ptr++;
|
||||
span.array->rgba[i][3] = *ptr++;
|
||||
}
|
||||
rb->PutRow(ctx, rb, drawWidth, destX, destY,
|
||||
span.array->rgba, NULL);
|
||||
src += rowLength*2;
|
||||
destY++;
|
||||
}
|
||||
}
|
||||
else if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==-1.0F) {
|
||||
/* upside-down */
|
||||
GLint row;
|
||||
ASSERT(drawWidth <= MAX_WIDTH);
|
||||
for (row=0; row<drawHeight; row++) {
|
||||
GLint i;
|
||||
const GLchan *ptr = src;
|
||||
for (i=0;i<drawWidth;i++) {
|
||||
span.array->rgba[i][0] = *ptr;
|
||||
span.array->rgba[i][1] = *ptr;
|
||||
span.array->rgba[i][2] = *ptr++;
|
||||
span.array->rgba[i][3] = *ptr++;
|
||||
}
|
||||
destY--;
|
||||
rb->PutRow(ctx, rb, drawWidth, destX, destY,
|
||||
span.array->rgba, NULL);
|
||||
src += rowLength*2;
|
||||
}
|
||||
}
|
||||
else {
|
||||
/* with zooming */
|
||||
GLint row;
|
||||
ASSERT(drawWidth <= MAX_WIDTH);
|
||||
for (row=0; row<drawHeight; row++) {
|
||||
const GLchan *ptr = src;
|
||||
GLint i;
|
||||
for (i=0;i<drawWidth;i++) {
|
||||
span.array->rgba[i][0] = *ptr;
|
||||
span.array->rgba[i][1] = *ptr;
|
||||
span.array->rgba[i][2] = *ptr++;
|
||||
span.array->rgba[i][3] = *ptr++;
|
||||
}
|
||||
span.x = destX;
|
||||
span.y = destY;
|
||||
span.end = drawWidth;
|
||||
_swrast_write_zoomed_rgba_span(ctx, imgX, imgY, &span,
|
||||
(CONST GLchan (*)[4]) span.array->rgba);
|
||||
src += rowLength*2;
|
||||
destY++;
|
||||
}
|
||||
}
|
||||
}
|
||||
return GL_TRUE;
|
||||
}
|
||||
else if (format==GL_COLOR_INDEX && type==GL_UNSIGNED_BYTE) {
|
||||
const GLubyte *src =
|
||||
(const GLubyte *) pixels + skipRows * rowLength + skipPixels;
|
||||
if (ctx->Visual.rgbMode) {
|
||||
/* convert CI data to RGBA */
|
||||
if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) {
|
||||
/* no zooming */
|
||||
GLint row;
|
||||
for (row=0; row<drawHeight; row++) {
|
||||
ASSERT(drawWidth <= MAX_WIDTH);
|
||||
_mesa_map_ci8_to_rgba(ctx, drawWidth, src, span.array->rgba);
|
||||
rb->PutRow(ctx, rb, drawWidth, destX, destY,
|
||||
span.array->rgba, NULL);
|
||||
src += rowLength;
|
||||
destY++;
|
||||
}
|
||||
return GL_TRUE;
|
||||
}
|
||||
else if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==-1.0F) {
|
||||
/* upside-down */
|
||||
GLint row;
|
||||
for (row=0; row<drawHeight; row++) {
|
||||
ASSERT(drawWidth <= MAX_WIDTH);
|
||||
_mesa_map_ci8_to_rgba(ctx, drawWidth, src, span.array->rgba);
|
||||
destY--;
|
||||
rb->PutRow(ctx, rb, drawWidth, destX, destY,
|
||||
span.array->rgba, NULL);
|
||||
src += rowLength;
|
||||
}
|
||||
return GL_TRUE;
|
||||
}
|
||||
else {
|
||||
/* with zooming */
|
||||
GLint row;
|
||||
for (row=0; row<drawHeight; row++) {
|
||||
ASSERT(drawWidth <= MAX_WIDTH);
|
||||
_mesa_map_ci8_to_rgba(ctx, drawWidth, src, span.array->rgba);
|
||||
span.x = destX;
|
||||
span.y = destY;
|
||||
span.end = drawWidth;
|
||||
_swrast_write_zoomed_rgba_span(ctx, imgX, imgY, &span,
|
||||
(CONST GLchan (*)[4]) span.array->rgba);
|
||||
src += rowLength;
|
||||
destY++;
|
||||
}
|
||||
return GL_TRUE;
|
||||
_mesa_map_ci8_to_rgba(ctx, drawWidth, src, span.array->rgba);
|
||||
rb->PutRow(ctx, rb, drawWidth, destX, destY,
|
||||
span.array->rgba, NULL);
|
||||
src += unpack.RowLength;
|
||||
destY += yStep;
|
||||
}
|
||||
}
|
||||
else {
|
||||
/* write CI data to CI frame buffer */
|
||||
/* with zooming */
|
||||
GLint row;
|
||||
if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) {
|
||||
/* no zooming */
|
||||
for (row=0; row<drawHeight; row++) {
|
||||
GLuint index32[MAX_WIDTH];
|
||||
GLint col;
|
||||
for (col = 0; col < drawWidth; col++)
|
||||
index32[col] = src[col];
|
||||
rb->PutRow(ctx, rb, drawWidth, destX, destY, index32, NULL);
|
||||
src += rowLength;
|
||||
destY++;
|
||||
}
|
||||
return GL_TRUE;
|
||||
}
|
||||
else {
|
||||
/* with zooming */
|
||||
return GL_FALSE;
|
||||
for (row = 0; row < drawHeight; row++) {
|
||||
ASSERT(drawWidth <= MAX_WIDTH);
|
||||
_mesa_map_ci8_to_rgba(ctx, drawWidth, src, span.array->rgba);
|
||||
span.x = destX;
|
||||
span.y = destY;
|
||||
span.end = drawWidth;
|
||||
_swrast_write_zoomed_rgba_span(ctx, imgX, imgY, &span,
|
||||
(CONST GLchan (*)[4]) span.array->rgba);
|
||||
src += unpack.RowLength;
|
||||
destY++;
|
||||
}
|
||||
}
|
||||
return GL_TRUE;
|
||||
}
|
||||
else {
|
||||
/* can't handle this pixel format and/or data type here */
|
||||
return GL_FALSE;
|
||||
else if (!ctx->Visual.rgbMode && rbType == GL_UNSIGNED_INT) {
|
||||
/* write CI data to CI frame buffer */
|
||||
GLint row;
|
||||
if (simpleZoom) {
|
||||
for (row = 0; row < drawHeight; row++) {
|
||||
GLuint index32[MAX_WIDTH];
|
||||
GLint col;
|
||||
for (col = 0; col < drawWidth; col++)
|
||||
index32[col] = src[col];
|
||||
rb->PutRow(ctx, rb, drawWidth, destX, destY, index32, NULL);
|
||||
src += unpack.RowLength;
|
||||
destY += yStep;
|
||||
}
|
||||
return GL_TRUE;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* can't do a simple draw, have to use slow path */
|
||||
/* can't handle this pixel format and/or data type */
|
||||
return GL_FALSE;
|
||||
}
|
||||
|
||||
|
|
@ -685,12 +552,12 @@ draw_rgba_pixels( GLcontext *ctx, GLint x, GLint y,
|
|||
GLuint transferOps = ctx->_ImageTransferState;
|
||||
SWspan span;
|
||||
|
||||
INIT_SPAN(span, GL_BITMAP, 0, 0, SPAN_RGBA);
|
||||
|
||||
/* Try an optimized glDrawPixels first */
|
||||
if (fast_draw_pixels(ctx, x, y, width, height, format, type, unpack, pixels))
|
||||
return;
|
||||
|
||||
INIT_SPAN(span, GL_BITMAP, 0, 0, SPAN_RGBA);
|
||||
|
||||
if (ctx->Depth.Test)
|
||||
_swrast_span_default_z(ctx, &span);
|
||||
if (swrast->_FogEnabled)
|
||||
|
|
@ -702,8 +569,11 @@ draw_rgba_pixels( GLcontext *ctx, GLint x, GLint y,
|
|||
&& x + width <= (GLint) ctx->DrawBuffer->Width
|
||||
&& y + height <= (GLint) ctx->DrawBuffer->Height
|
||||
&& ctx->DrawBuffer->_NumColorDrawBuffers[0] == 1) {
|
||||
quickDraw = GL_TRUE;
|
||||
rb = ctx->DrawBuffer->_ColorDrawBuffers[0][0];
|
||||
if (rb->DataType == format)
|
||||
quickDraw = GL_TRUE;
|
||||
else
|
||||
quickDraw = GL_FALSE;
|
||||
}
|
||||
else {
|
||||
quickDraw = GL_FALSE;
|
||||
|
|
@ -765,6 +635,8 @@ draw_rgba_pixels( GLcontext *ctx, GLint x, GLint y,
|
|||
* General solution
|
||||
*/
|
||||
{
|
||||
const GLboolean sink = (ctx->Pixel.MinMaxEnabled && ctx->MinMax.Sink)
|
||||
|| (ctx->Pixel.HistogramEnabled && ctx->Histogram.Sink);
|
||||
const GLbitfield interpMask = span.interpMask;
|
||||
const GLbitfield arrayMask = span.arrayMask;
|
||||
GLint skipPixels = 0;
|
||||
|
|
@ -783,6 +655,7 @@ draw_rgba_pixels( GLcontext *ctx, GLint x, GLint y,
|
|||
/* Set these for each row since the _swrast_write_* function may
|
||||
* change them while clipping.
|
||||
*/
|
||||
span.array->ChanType = CHAN_TYPE;
|
||||
span.x = x + skipPixels;
|
||||
span.y = y + row;
|
||||
span.end = spanWidth;
|
||||
|
|
@ -794,8 +667,7 @@ draw_rgba_pixels( GLcontext *ctx, GLint x, GLint y,
|
|||
format, type, source, unpack,
|
||||
transferOps);
|
||||
|
||||
if ((ctx->Pixel.MinMaxEnabled && ctx->MinMax.Sink) ||
|
||||
(ctx->Pixel.HistogramEnabled && ctx->Histogram.Sink))
|
||||
if (sink)
|
||||
continue;
|
||||
|
||||
/* draw the span */
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue