2 * Mesa 3-D graphics library
5 * Copyright (C) 1999-2007 Brian Paul All Rights Reserved.
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:
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
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 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26 #include "main/glheader.h"
27 #include "main/bufferobj.h"
28 #include "main/condrender.h"
29 #include "main/context.h"
30 #include "main/image.h"
31 #include "main/imports.h"
32 #include "main/macros.h"
33 #include "main/pack.h"
35 #include "main/pixeltransfer.h"
36 #include "main/state.h"
38 #include "s_context.h"
40 #include "s_stencil.h"
46 * Try to do a fast and simple RGB(a) glDrawPixels.
47 * Return: GL_TRUE if success, GL_FALSE if slow path must be used instead
50 fast_draw_rgba_pixels(struct gl_context *ctx, GLint x, GLint y,
51 GLsizei width, GLsizei height,
52 GLenum format, GLenum type,
53 const struct gl_pixelstore_attrib *userUnpack,
56 const GLint imgX = x, imgY = y;
57 struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[0];
59 SWcontext *swrast = SWRAST_CONTEXT(ctx);
62 GLint yStep; /* +1 or -1 */
63 struct gl_pixelstore_attrib unpack;
64 GLint destX, destY, drawWidth, drawHeight; /* post clipping */
67 return GL_TRUE; /* no-op */
69 rbType = rb->DataType;
71 if ((swrast->_RasterMask & ~CLIP_BIT) ||
72 ctx->Texture._EnabledCoordUnits ||
73 userUnpack->SwapBytes ||
74 ctx->_ImageTransferState) {
75 /* can't handle any of those conditions */
79 INIT_SPAN(span, GL_BITMAP);
80 span.arrayMask = SPAN_RGBA;
81 span.arrayAttribs = FRAG_BIT_COL0;
82 _swrast_span_default_attribs(ctx, &span);
84 /* copy input params since clipping may change them */
91 /* check for simple zooming and clipping */
92 if (ctx->Pixel.ZoomX == 1.0F &&
93 (ctx->Pixel.ZoomY == 1.0F || ctx->Pixel.ZoomY == -1.0F)) {
94 if (!_mesa_clip_drawpixels(ctx, &destX, &destY,
95 &drawWidth, &drawHeight, &unpack)) {
96 /* image was completely clipped: no-op, all done */
100 yStep = (GLint) ctx->Pixel.ZoomY;
101 ASSERT(yStep == 1 || yStep == -1);
104 /* non-simple zooming */
105 simpleZoom = GL_FALSE;
107 if (unpack.RowLength == 0)
108 unpack.RowLength = width;
115 if (format == GL_RGBA && type == rbType) {
117 = (const GLubyte *) _mesa_image_address2d(&unpack, pixels, width,
118 height, format, type, 0, 0);
119 const GLint srcStride = _mesa_image_row_stride(&unpack, width,
123 for (row = 0; row < drawHeight; row++) {
124 rb->PutRow(ctx, rb, drawWidth, destX, destY, src, NULL);
132 for (row = 0; row < drawHeight; row++) {
134 span.y = destY + row;
135 span.end = drawWidth;
136 span.array->ChanType = rbType;
137 _swrast_write_zoomed_rgba_span(ctx, imgX, imgY, &span, src);
140 span.array->ChanType = CHAN_TYPE;
145 if (format == GL_RGB && type == rbType) {
147 = (const GLubyte *) _mesa_image_address2d(&unpack, pixels, width,
148 height, format, type, 0, 0);
149 const GLint srcStride = _mesa_image_row_stride(&unpack, width,
153 for (row = 0; row < drawHeight; row++) {
154 rb->PutRowRGB(ctx, rb, drawWidth, destX, destY, src, NULL);
162 for (row = 0; row < drawHeight; row++) {
165 span.end = drawWidth;
166 span.array->ChanType = rbType;
167 _swrast_write_zoomed_rgb_span(ctx, imgX, imgY, &span, src);
171 span.array->ChanType = CHAN_TYPE;
176 /* Remaining cases haven't been tested with alignment != 1 */
177 if (userUnpack->Alignment != 1)
180 if (format == GL_LUMINANCE && type == CHAN_TYPE && rbType == CHAN_TYPE) {
181 const GLchan *src = (const GLchan *) pixels
182 + (unpack.SkipRows * unpack.RowLength + unpack.SkipPixels);
186 ASSERT(drawWidth <= MAX_WIDTH);
187 for (row = 0; row < drawHeight; row++) {
188 GLchan rgb[MAX_WIDTH][3];
190 for (i = 0;i<drawWidth;i++) {
195 rb->PutRowRGB(ctx, rb, drawWidth, destX, destY, rgb, NULL);
196 src += unpack.RowLength;
203 ASSERT(drawWidth <= MAX_WIDTH);
204 for (row = 0; row < drawHeight; row++) {
205 GLchan rgb[MAX_WIDTH][3];
207 for (i = 0;i<drawWidth;i++) {
214 span.end = drawWidth;
215 _swrast_write_zoomed_rgb_span(ctx, imgX, imgY, &span, rgb);
216 src += unpack.RowLength;
223 if (format == GL_LUMINANCE_ALPHA && type == CHAN_TYPE && rbType == CHAN_TYPE) {
224 const GLchan *src = (const GLchan *) pixels
225 + (unpack.SkipRows * unpack.RowLength + unpack.SkipPixels)*2;
228 ASSERT(drawWidth <= MAX_WIDTH);
229 for (row = 0; row < drawHeight; row++) {
231 const GLchan *ptr = src;
232 for (i = 0;i<drawWidth;i++) {
233 span.array->rgba[i][0] = *ptr;
234 span.array->rgba[i][1] = *ptr;
235 span.array->rgba[i][2] = *ptr++;
236 span.array->rgba[i][3] = *ptr++;
238 rb->PutRow(ctx, rb, drawWidth, destX, destY,
239 span.array->rgba, NULL);
240 src += unpack.RowLength*2;
247 ASSERT(drawWidth <= MAX_WIDTH);
248 for (row = 0; row < drawHeight; row++) {
249 const GLchan *ptr = src;
251 for (i = 0;i<drawWidth;i++) {
252 span.array->rgba[i][0] = *ptr;
253 span.array->rgba[i][1] = *ptr;
254 span.array->rgba[i][2] = *ptr++;
255 span.array->rgba[i][3] = *ptr++;
259 span.end = drawWidth;
260 _swrast_write_zoomed_rgba_span(ctx, imgX, imgY, &span,
262 src += unpack.RowLength*2;
269 if (format == GL_COLOR_INDEX && type == GL_UNSIGNED_BYTE) {
270 const GLubyte *src = (const GLubyte *) pixels
271 + unpack.SkipRows * unpack.RowLength + unpack.SkipPixels;
272 if (rbType == GL_UNSIGNED_BYTE) {
273 /* convert ubyte/CI data to ubyte/RGBA */
276 for (row = 0; row < drawHeight; row++) {
277 ASSERT(drawWidth <= MAX_WIDTH);
278 _mesa_map_ci8_to_rgba8(ctx, drawWidth, src,
280 rb->PutRow(ctx, rb, drawWidth, destX, destY,
281 span.array->rgba8, NULL);
282 src += unpack.RowLength;
287 /* ubyte/CI to ubyte/RGBA with zooming */
289 for (row = 0; row < drawHeight; row++) {
290 ASSERT(drawWidth <= MAX_WIDTH);
291 _mesa_map_ci8_to_rgba8(ctx, drawWidth, src,
295 span.end = drawWidth;
296 _swrast_write_zoomed_rgba_span(ctx, imgX, imgY, &span,
298 src += unpack.RowLength;
306 /* can't handle this pixel format and/or data type */
313 * Draw stencil image.
316 draw_stencil_pixels( struct gl_context *ctx, GLint x, GLint y,
317 GLsizei width, GLsizei height,
319 const struct gl_pixelstore_attrib *unpack,
320 const GLvoid *pixels )
322 const GLboolean zoom = ctx->Pixel.ZoomX != 1.0 || ctx->Pixel.ZoomY != 1.0;
325 /* if width > MAX_WIDTH, have to process image in chunks */
327 while (skipPixels < width) {
328 const GLint spanX = x + skipPixels;
329 const GLint spanWidth = MIN2(width - skipPixels, MAX_WIDTH);
331 for (row = 0; row < height; row++) {
332 const GLint spanY = y + row;
333 GLstencil values[MAX_WIDTH];
334 GLenum destType = (sizeof(GLstencil) == sizeof(GLubyte))
335 ? GL_UNSIGNED_BYTE : GL_UNSIGNED_SHORT;
336 const GLvoid *source = _mesa_image_address2d(unpack, pixels,
338 GL_STENCIL_INDEX, type,
340 _mesa_unpack_stencil_span(ctx, spanWidth, destType, values,
341 type, source, unpack,
342 ctx->_ImageTransferState);
344 _swrast_write_zoomed_stencil_span(ctx, x, y, spanWidth,
345 spanX, spanY, values);
348 _swrast_write_stencil_span(ctx, spanWidth, spanX, spanY, values);
351 skipPixels += spanWidth;
360 draw_depth_pixels( struct gl_context *ctx, GLint x, GLint y,
361 GLsizei width, GLsizei height,
363 const struct gl_pixelstore_attrib *unpack,
364 const GLvoid *pixels )
366 const GLboolean scaleOrBias
367 = ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0;
368 const GLboolean zoom = ctx->Pixel.ZoomX != 1.0 || ctx->Pixel.ZoomY != 1.0;
371 INIT_SPAN(span, GL_BITMAP);
372 span.arrayMask = SPAN_Z;
373 _swrast_span_default_attribs(ctx, &span);
375 if (type == GL_UNSIGNED_SHORT
376 && ctx->DrawBuffer->Visual.depthBits == 16
379 && width <= MAX_WIDTH
380 && !unpack->SwapBytes) {
381 /* Special case: directly write 16-bit depth values */
383 for (row = 0; row < height; row++) {
384 const GLushort *zSrc = (const GLushort *)
385 _mesa_image_address2d(unpack, pixels, width, height,
386 GL_DEPTH_COMPONENT, type, row, 0);
388 for (i = 0; i < width; i++)
389 span.array->z[i] = zSrc[i];
393 _swrast_write_rgba_span(ctx, &span);
396 else if (type == GL_UNSIGNED_INT
399 && width <= MAX_WIDTH
400 && !unpack->SwapBytes) {
401 /* Special case: shift 32-bit values down to Visual.depthBits */
402 const GLint shift = 32 - ctx->DrawBuffer->Visual.depthBits;
404 for (row = 0; row < height; row++) {
405 const GLuint *zSrc = (const GLuint *)
406 _mesa_image_address2d(unpack, pixels, width, height,
407 GL_DEPTH_COMPONENT, type, row, 0);
409 memcpy(span.array->z, zSrc, width * sizeof(GLuint));
413 for (col = 0; col < width; col++)
414 span.array->z[col] = zSrc[col] >> shift;
419 _swrast_write_rgba_span(ctx, &span);
424 const GLuint depthMax = ctx->DrawBuffer->_DepthMax;
425 GLint skipPixels = 0;
427 /* in case width > MAX_WIDTH do the copy in chunks */
428 while (skipPixels < width) {
429 const GLint spanWidth = MIN2(width - skipPixels, MAX_WIDTH);
431 ASSERT(span.end <= MAX_WIDTH);
432 for (row = 0; row < height; row++) {
433 const GLvoid *zSrc = _mesa_image_address2d(unpack,
434 pixels, width, height,
435 GL_DEPTH_COMPONENT, type,
438 /* Set these for each row since the _swrast_write_* function may
439 * change them while clipping.
441 span.x = x + skipPixels;
443 span.end = spanWidth;
445 _mesa_unpack_depth_span(ctx, spanWidth,
446 GL_UNSIGNED_INT, span.array->z, depthMax,
449 _swrast_write_zoomed_depth_span(ctx, x, y, &span);
452 _swrast_write_rgba_span(ctx, &span);
455 skipPixels += spanWidth;
466 draw_rgba_pixels( struct gl_context *ctx, GLint x, GLint y,
467 GLsizei width, GLsizei height,
468 GLenum format, GLenum type,
469 const struct gl_pixelstore_attrib *unpack,
470 const GLvoid *pixels )
472 const GLint imgX = x, imgY = y;
473 const GLboolean zoom = ctx->Pixel.ZoomX!=1.0 || ctx->Pixel.ZoomY!=1.0;
474 GLfloat *convImage = NULL;
475 GLbitfield transferOps = ctx->_ImageTransferState;
478 /* Try an optimized glDrawPixels first */
479 if (fast_draw_rgba_pixels(ctx, x, y, width, height, format, type,
484 INIT_SPAN(span, GL_BITMAP);
485 _swrast_span_default_attribs(ctx, &span);
486 span.arrayMask = SPAN_RGBA;
487 span.arrayAttribs = FRAG_BIT_COL0; /* we're fill in COL0 attrib values */
489 if (ctx->DrawBuffer->_NumColorDrawBuffers > 0 &&
490 ctx->DrawBuffer->_ColorDrawBuffers[0]->DataType != GL_FLOAT &&
491 ctx->Color.ClampFragmentColor != GL_FALSE) {
492 /* need to clamp colors before applying fragment ops */
493 transferOps |= IMAGE_CLAMP_BIT;
500 const GLbitfield interpMask = span.interpMask;
501 const GLbitfield arrayMask = span.arrayMask;
502 const GLint srcStride
503 = _mesa_image_row_stride(unpack, width, format, type);
504 GLint skipPixels = 0;
505 /* use span array for temp color storage */
506 GLfloat *rgba = (GLfloat *) span.array->attribs[FRAG_ATTRIB_COL0];
508 /* if the span is wider than MAX_WIDTH we have to do it in chunks */
509 while (skipPixels < width) {
510 const GLint spanWidth = MIN2(width - skipPixels, MAX_WIDTH);
511 const GLubyte *source
512 = (const GLubyte *) _mesa_image_address2d(unpack, pixels,
513 width, height, format,
514 type, 0, skipPixels);
517 for (row = 0; row < height; row++) {
518 /* get image row as float/RGBA */
519 _mesa_unpack_color_span_float(ctx, spanWidth, GL_RGBA, rgba,
520 format, type, source, unpack,
522 /* Set these for each row since the _swrast_write_* functions
523 * may change them while clipping/rendering.
525 span.array->ChanType = GL_FLOAT;
526 span.x = x + skipPixels;
528 span.end = spanWidth;
529 span.arrayMask = arrayMask;
530 span.interpMask = interpMask;
532 _swrast_write_zoomed_rgba_span(ctx, imgX, imgY, &span, rgba);
535 _swrast_write_rgba_span(ctx, &span);
541 skipPixels += spanWidth;
542 } /* while skipPixels < width */
544 /* XXX this is ugly/temporary, to undo above change */
545 span.array->ChanType = CHAN_TYPE;
555 * This is a bit different from drawing GL_DEPTH_COMPONENT pixels.
556 * The only per-pixel operations that apply are depth scale/bias,
557 * stencil offset/shift, GL_DEPTH_WRITEMASK and GL_STENCIL_WRITEMASK,
559 * Also, only the depth buffer and stencil buffers are touched, not the
563 draw_depth_stencil_pixels(struct gl_context *ctx, GLint x, GLint y,
564 GLsizei width, GLsizei height, GLenum type,
565 const struct gl_pixelstore_attrib *unpack,
566 const GLvoid *pixels)
568 const GLint imgX = x, imgY = y;
569 const GLboolean scaleOrBias
570 = ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0;
571 const GLuint depthMax = ctx->DrawBuffer->_DepthMax;
572 const GLuint stencilMask = ctx->Stencil.WriteMask[0];
573 const GLuint stencilType = (STENCIL_BITS == 8) ?
574 GL_UNSIGNED_BYTE : GL_UNSIGNED_SHORT;
575 const GLboolean zoom = ctx->Pixel.ZoomX != 1.0 || ctx->Pixel.ZoomY != 1.0;
576 struct gl_renderbuffer *depthRb, *stencilRb;
577 struct gl_pixelstore_attrib clippedUnpack = *unpack;
580 if (!_mesa_clip_drawpixels(ctx, &x, &y, &width, &height,
582 /* totally clipped */
587 depthRb = ctx->ReadBuffer->Attachment[BUFFER_DEPTH].Renderbuffer;
588 stencilRb = ctx->ReadBuffer->Attachment[BUFFER_STENCIL].Renderbuffer;
592 if (depthRb->_BaseFormat == GL_DEPTH_STENCIL_EXT &&
593 depthRb->Format == MESA_FORMAT_Z24_S8 &&
594 type == GL_UNSIGNED_INT_24_8 &&
595 depthRb == stencilRb &&
599 (stencilMask & 0xff) == 0xff) {
600 /* This is the ideal case.
601 * Drawing GL_DEPTH_STENCIL pixels into a combined depth/stencil buffer.
602 * Plus, no pixel transfer ops, zooming, or masking needed.
605 for (i = 0; i < height; i++) {
606 const GLuint *src = (const GLuint *)
607 _mesa_image_address2d(&clippedUnpack, pixels, width, height,
608 GL_DEPTH_STENCIL_EXT, type, i, 0);
609 depthRb->PutRow(ctx, depthRb, width, x, y + i, src, NULL);
613 /* sub-optimal cases:
614 * Separate depth/stencil buffers, or pixel transfer ops required.
616 /* XXX need to handle very wide images (skippixels) */
619 depthRb = ctx->DrawBuffer->_DepthBuffer;
620 stencilRb = ctx->DrawBuffer->_StencilBuffer;
622 for (i = 0; i < height; i++) {
623 const GLuint *depthStencilSrc = (const GLuint *)
624 _mesa_image_address2d(&clippedUnpack, pixels, width, height,
625 GL_DEPTH_STENCIL_EXT, type, i, 0);
627 if (ctx->Depth.Mask) {
628 if (!scaleOrBias && ctx->DrawBuffer->Visual.depthBits == 24) {
629 /* fast path 24-bit zbuffer */
630 GLuint zValues[MAX_WIDTH];
632 ASSERT(depthRb->DataType == GL_UNSIGNED_INT);
633 for (j = 0; j < width; j++) {
634 zValues[j] = depthStencilSrc[j] >> 8;
637 _swrast_write_zoomed_z_span(ctx, imgX, imgY, width,
640 depthRb->PutRow(ctx, depthRb, width, x, y + i, zValues,NULL);
642 else if (!scaleOrBias && ctx->DrawBuffer->Visual.depthBits == 16) {
643 /* fast path 16-bit zbuffer */
644 GLushort zValues[MAX_WIDTH];
646 ASSERT(depthRb->DataType == GL_UNSIGNED_SHORT);
647 for (j = 0; j < width; j++) {
648 zValues[j] = depthStencilSrc[j] >> 16;
651 _swrast_write_zoomed_z_span(ctx, imgX, imgY, width,
654 depthRb->PutRow(ctx, depthRb, width, x, y + i, zValues,NULL);
658 GLuint zValues[MAX_WIDTH]; /* 16 or 32-bit Z value storage */
659 _mesa_unpack_depth_span(ctx, width,
660 depthRb->DataType, zValues, depthMax,
661 type, depthStencilSrc, &clippedUnpack);
663 _swrast_write_zoomed_z_span(ctx, imgX, imgY, width, x,
667 depthRb->PutRow(ctx, depthRb, width, x, y + i, zValues,NULL);
672 if (stencilMask != 0x0) {
673 GLstencil stencilValues[MAX_WIDTH];
674 /* get stencil values, with shift/offset/mapping */
675 _mesa_unpack_stencil_span(ctx, width, stencilType, stencilValues,
676 type, depthStencilSrc, &clippedUnpack,
677 ctx->_ImageTransferState);
679 _swrast_write_zoomed_stencil_span(ctx, imgX, imgY, width,
680 x, y + i, stencilValues);
682 _swrast_write_stencil_span(ctx, width, x, y + i, stencilValues);
690 * Execute software-based glDrawPixels.
691 * By time we get here, all error checking will have been done.
694 _swrast_DrawPixels( struct gl_context *ctx,
696 GLsizei width, GLsizei height,
697 GLenum format, GLenum type,
698 const struct gl_pixelstore_attrib *unpack,
699 const GLvoid *pixels )
701 SWcontext *swrast = SWRAST_CONTEXT(ctx);
702 GLboolean save_vp_override = ctx->VertexProgram._Overriden;
704 if (!_mesa_check_conditional_render(ctx))
705 return; /* don't draw */
707 /* We are creating fragments directly, without going through vertex
710 * This override flag tells the fragment processing code that its input
711 * comes from a non-standard source, and it may therefore not rely on
712 * optimizations that assume e.g. constant color if there is no color
715 _mesa_set_vp_override(ctx, GL_TRUE);
717 swrast_render_start(ctx);
720 _mesa_update_state(ctx);
722 if (swrast->NewState)
723 _swrast_validate_derived( ctx );
725 pixels = _mesa_map_pbo_source(ctx, unpack, pixels);
727 swrast_render_finish(ctx);
728 _mesa_set_vp_override(ctx, save_vp_override);
733 * By time we get here, all error checking should have been done.
736 case GL_STENCIL_INDEX:
737 draw_stencil_pixels( ctx, x, y, width, height, type, unpack, pixels );
739 case GL_DEPTH_COMPONENT:
740 draw_depth_pixels( ctx, x, y, width, height, type, unpack, pixels );
742 case GL_DEPTH_STENCIL_EXT:
743 draw_depth_stencil_pixels(ctx, x, y, width, height, type, unpack, pixels);
746 /* all other formats should be color formats */
747 draw_rgba_pixels(ctx, x, y, width, height, format, type, unpack, pixels);
750 swrast_render_finish(ctx);
751 _mesa_set_vp_override(ctx, save_vp_override);
753 _mesa_unmap_pbo_source(ctx, unpack);