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"
34 #include "main/pixeltransfer.h"
35 #include "main/state.h"
37 #include "s_context.h"
39 #include "s_stencil.h"
45 * Try to do a fast and simple RGB(a) glDrawPixels.
46 * Return: GL_TRUE if success, GL_FALSE if slow path must be used instead
49 fast_draw_rgba_pixels(struct gl_context *ctx, GLint x, GLint y,
50 GLsizei width, GLsizei height,
51 GLenum format, GLenum type,
52 const struct gl_pixelstore_attrib *userUnpack,
55 const GLint imgX = x, imgY = y;
56 struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[0];
58 SWcontext *swrast = SWRAST_CONTEXT(ctx);
61 GLint yStep; /* +1 or -1 */
62 struct gl_pixelstore_attrib unpack;
63 GLint destX, destY, drawWidth, drawHeight; /* post clipping */
66 return GL_TRUE; /* no-op */
68 rbType = rb->DataType;
70 if ((swrast->_RasterMask & ~CLIP_BIT) ||
71 ctx->Texture._EnabledCoordUnits ||
72 userUnpack->SwapBytes ||
73 ctx->_ImageTransferState) {
74 /* can't handle any of those conditions */
78 INIT_SPAN(span, GL_BITMAP);
79 span.arrayMask = SPAN_RGBA;
80 span.arrayAttribs = FRAG_BIT_COL0;
81 _swrast_span_default_attribs(ctx, &span);
83 /* copy input params since clipping may change them */
90 /* check for simple zooming and clipping */
91 if (ctx->Pixel.ZoomX == 1.0F &&
92 (ctx->Pixel.ZoomY == 1.0F || ctx->Pixel.ZoomY == -1.0F)) {
93 if (!_mesa_clip_drawpixels(ctx, &destX, &destY,
94 &drawWidth, &drawHeight, &unpack)) {
95 /* image was completely clipped: no-op, all done */
99 yStep = (GLint) ctx->Pixel.ZoomY;
100 ASSERT(yStep == 1 || yStep == -1);
103 /* non-simple zooming */
104 simpleZoom = GL_FALSE;
106 if (unpack.RowLength == 0)
107 unpack.RowLength = width;
114 if (format == GL_RGBA && type == rbType) {
116 = (const GLubyte *) _mesa_image_address2d(&unpack, pixels, width,
117 height, format, type, 0, 0);
118 const GLint srcStride = _mesa_image_row_stride(&unpack, width,
122 for (row = 0; row < drawHeight; row++) {
123 rb->PutRow(ctx, rb, drawWidth, destX, destY, src, NULL);
131 for (row = 0; row < drawHeight; row++) {
133 span.y = destY + row;
134 span.end = drawWidth;
135 span.array->ChanType = rbType;
136 _swrast_write_zoomed_rgba_span(ctx, imgX, imgY, &span, src);
139 span.array->ChanType = CHAN_TYPE;
144 if (format == GL_RGB && type == rbType) {
146 = (const GLubyte *) _mesa_image_address2d(&unpack, pixels, width,
147 height, format, type, 0, 0);
148 const GLint srcStride = _mesa_image_row_stride(&unpack, width,
152 for (row = 0; row < drawHeight; row++) {
153 rb->PutRowRGB(ctx, rb, drawWidth, destX, destY, src, NULL);
161 for (row = 0; row < drawHeight; row++) {
164 span.end = drawWidth;
165 span.array->ChanType = rbType;
166 _swrast_write_zoomed_rgb_span(ctx, imgX, imgY, &span, src);
170 span.array->ChanType = CHAN_TYPE;
175 /* Remaining cases haven't been tested with alignment != 1 */
176 if (userUnpack->Alignment != 1)
179 if (format == GL_LUMINANCE && type == CHAN_TYPE && rbType == CHAN_TYPE) {
180 const GLchan *src = (const GLchan *) pixels
181 + (unpack.SkipRows * unpack.RowLength + unpack.SkipPixels);
185 ASSERT(drawWidth <= MAX_WIDTH);
186 for (row = 0; row < drawHeight; row++) {
187 GLchan rgb[MAX_WIDTH][3];
189 for (i = 0;i<drawWidth;i++) {
194 rb->PutRowRGB(ctx, rb, drawWidth, destX, destY, rgb, NULL);
195 src += unpack.RowLength;
202 ASSERT(drawWidth <= MAX_WIDTH);
203 for (row = 0; row < drawHeight; row++) {
204 GLchan rgb[MAX_WIDTH][3];
206 for (i = 0;i<drawWidth;i++) {
213 span.end = drawWidth;
214 _swrast_write_zoomed_rgb_span(ctx, imgX, imgY, &span, rgb);
215 src += unpack.RowLength;
222 if (format == GL_LUMINANCE_ALPHA && type == CHAN_TYPE && rbType == CHAN_TYPE) {
223 const GLchan *src = (const GLchan *) pixels
224 + (unpack.SkipRows * unpack.RowLength + unpack.SkipPixels)*2;
227 ASSERT(drawWidth <= MAX_WIDTH);
228 for (row = 0; row < drawHeight; row++) {
230 const GLchan *ptr = src;
231 for (i = 0;i<drawWidth;i++) {
232 span.array->rgba[i][0] = *ptr;
233 span.array->rgba[i][1] = *ptr;
234 span.array->rgba[i][2] = *ptr++;
235 span.array->rgba[i][3] = *ptr++;
237 rb->PutRow(ctx, rb, drawWidth, destX, destY,
238 span.array->rgba, NULL);
239 src += unpack.RowLength*2;
246 ASSERT(drawWidth <= MAX_WIDTH);
247 for (row = 0; row < drawHeight; row++) {
248 const GLchan *ptr = src;
250 for (i = 0;i<drawWidth;i++) {
251 span.array->rgba[i][0] = *ptr;
252 span.array->rgba[i][1] = *ptr;
253 span.array->rgba[i][2] = *ptr++;
254 span.array->rgba[i][3] = *ptr++;
258 span.end = drawWidth;
259 _swrast_write_zoomed_rgba_span(ctx, imgX, imgY, &span,
261 src += unpack.RowLength*2;
268 if (format == GL_COLOR_INDEX && type == GL_UNSIGNED_BYTE) {
269 const GLubyte *src = (const GLubyte *) pixels
270 + unpack.SkipRows * unpack.RowLength + unpack.SkipPixels;
271 if (rbType == GL_UNSIGNED_BYTE) {
272 /* convert ubyte/CI data to ubyte/RGBA */
275 for (row = 0; row < drawHeight; row++) {
276 ASSERT(drawWidth <= MAX_WIDTH);
277 _mesa_map_ci8_to_rgba8(ctx, drawWidth, src,
279 rb->PutRow(ctx, rb, drawWidth, destX, destY,
280 span.array->rgba8, NULL);
281 src += unpack.RowLength;
286 /* ubyte/CI to ubyte/RGBA with zooming */
288 for (row = 0; row < drawHeight; row++) {
289 ASSERT(drawWidth <= MAX_WIDTH);
290 _mesa_map_ci8_to_rgba8(ctx, drawWidth, src,
294 span.end = drawWidth;
295 _swrast_write_zoomed_rgba_span(ctx, imgX, imgY, &span,
297 src += unpack.RowLength;
305 /* can't handle this pixel format and/or data type */
312 * Draw stencil image.
315 draw_stencil_pixels( struct gl_context *ctx, GLint x, GLint y,
316 GLsizei width, GLsizei height,
318 const struct gl_pixelstore_attrib *unpack,
319 const GLvoid *pixels )
321 const GLboolean zoom = ctx->Pixel.ZoomX != 1.0 || ctx->Pixel.ZoomY != 1.0;
324 /* if width > MAX_WIDTH, have to process image in chunks */
326 while (skipPixels < width) {
327 const GLint spanX = x + skipPixels;
328 const GLint spanWidth = MIN2(width - skipPixels, MAX_WIDTH);
330 for (row = 0; row < height; row++) {
331 const GLint spanY = y + row;
332 GLstencil values[MAX_WIDTH];
333 GLenum destType = (sizeof(GLstencil) == sizeof(GLubyte))
334 ? GL_UNSIGNED_BYTE : GL_UNSIGNED_SHORT;
335 const GLvoid *source = _mesa_image_address2d(unpack, pixels,
337 GL_COLOR_INDEX, type,
339 _mesa_unpack_stencil_span(ctx, spanWidth, destType, values,
340 type, source, unpack,
341 ctx->_ImageTransferState);
343 _swrast_write_zoomed_stencil_span(ctx, x, y, spanWidth,
344 spanX, spanY, values);
347 _swrast_write_stencil_span(ctx, spanWidth, spanX, spanY, values);
350 skipPixels += spanWidth;
359 draw_depth_pixels( struct gl_context *ctx, GLint x, GLint y,
360 GLsizei width, GLsizei height,
362 const struct gl_pixelstore_attrib *unpack,
363 const GLvoid *pixels )
365 const GLboolean scaleOrBias
366 = ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0;
367 const GLboolean zoom = ctx->Pixel.ZoomX != 1.0 || ctx->Pixel.ZoomY != 1.0;
370 INIT_SPAN(span, GL_BITMAP);
371 span.arrayMask = SPAN_Z;
372 _swrast_span_default_attribs(ctx, &span);
374 if (type == GL_UNSIGNED_SHORT
375 && ctx->DrawBuffer->Visual.depthBits == 16
378 && width <= MAX_WIDTH
379 && !unpack->SwapBytes) {
380 /* Special case: directly write 16-bit depth values */
382 for (row = 0; row < height; row++) {
383 const GLushort *zSrc = (const GLushort *)
384 _mesa_image_address2d(unpack, pixels, width, height,
385 GL_DEPTH_COMPONENT, type, row, 0);
387 for (i = 0; i < width; i++)
388 span.array->z[i] = zSrc[i];
392 _swrast_write_rgba_span(ctx, &span);
395 else if (type == GL_UNSIGNED_INT
398 && width <= MAX_WIDTH
399 && !unpack->SwapBytes) {
400 /* Special case: shift 32-bit values down to Visual.depthBits */
401 const GLint shift = 32 - ctx->DrawBuffer->Visual.depthBits;
403 for (row = 0; row < height; row++) {
404 const GLuint *zSrc = (const GLuint *)
405 _mesa_image_address2d(unpack, pixels, width, height,
406 GL_DEPTH_COMPONENT, type, row, 0);
408 memcpy(span.array->z, zSrc, width * sizeof(GLuint));
412 for (col = 0; col < width; col++)
413 span.array->z[col] = zSrc[col] >> shift;
418 _swrast_write_rgba_span(ctx, &span);
423 const GLuint depthMax = ctx->DrawBuffer->_DepthMax;
424 GLint skipPixels = 0;
426 /* in case width > MAX_WIDTH do the copy in chunks */
427 while (skipPixels < width) {
428 const GLint spanWidth = MIN2(width - skipPixels, MAX_WIDTH);
430 ASSERT(span.end <= MAX_WIDTH);
431 for (row = 0; row < height; row++) {
432 const GLvoid *zSrc = _mesa_image_address2d(unpack,
433 pixels, width, height,
434 GL_DEPTH_COMPONENT, type,
437 /* Set these for each row since the _swrast_write_* function may
438 * change them while clipping.
440 span.x = x + skipPixels;
442 span.end = spanWidth;
444 _mesa_unpack_depth_span(ctx, spanWidth,
445 GL_UNSIGNED_INT, span.array->z, depthMax,
448 _swrast_write_zoomed_depth_span(ctx, x, y, &span);
451 _swrast_write_rgba_span(ctx, &span);
454 skipPixels += spanWidth;
465 draw_rgba_pixels( struct gl_context *ctx, GLint x, GLint y,
466 GLsizei width, GLsizei height,
467 GLenum format, GLenum type,
468 const struct gl_pixelstore_attrib *unpack,
469 const GLvoid *pixels )
471 const GLint imgX = x, imgY = y;
472 const GLboolean zoom = ctx->Pixel.ZoomX!=1.0 || ctx->Pixel.ZoomY!=1.0;
473 GLfloat *convImage = NULL;
474 GLbitfield transferOps = ctx->_ImageTransferState;
477 /* Try an optimized glDrawPixels first */
478 if (fast_draw_rgba_pixels(ctx, x, y, width, height, format, type,
483 INIT_SPAN(span, GL_BITMAP);
484 _swrast_span_default_attribs(ctx, &span);
485 span.arrayMask = SPAN_RGBA;
486 span.arrayAttribs = FRAG_BIT_COL0; /* we're fill in COL0 attrib values */
488 if (ctx->DrawBuffer->_NumColorDrawBuffers > 0 &&
489 ctx->DrawBuffer->_ColorDrawBuffers[0]->DataType != GL_FLOAT &&
490 ctx->Color.ClampFragmentColor != GL_FALSE) {
491 /* need to clamp colors before applying fragment ops */
492 transferOps |= IMAGE_CLAMP_BIT;
499 const GLbitfield interpMask = span.interpMask;
500 const GLbitfield arrayMask = span.arrayMask;
501 const GLint srcStride
502 = _mesa_image_row_stride(unpack, width, format, type);
503 GLint skipPixels = 0;
504 /* use span array for temp color storage */
505 GLfloat *rgba = (GLfloat *) span.array->attribs[FRAG_ATTRIB_COL0];
507 /* if the span is wider than MAX_WIDTH we have to do it in chunks */
508 while (skipPixels < width) {
509 const GLint spanWidth = MIN2(width - skipPixels, MAX_WIDTH);
510 const GLubyte *source
511 = (const GLubyte *) _mesa_image_address2d(unpack, pixels,
512 width, height, format,
513 type, 0, skipPixels);
516 for (row = 0; row < height; row++) {
517 /* get image row as float/RGBA */
518 _mesa_unpack_color_span_float(ctx, spanWidth, GL_RGBA, rgba,
519 format, type, source, unpack,
521 /* Set these for each row since the _swrast_write_* functions
522 * may change them while clipping/rendering.
524 span.array->ChanType = GL_FLOAT;
525 span.x = x + skipPixels;
527 span.end = spanWidth;
528 span.arrayMask = arrayMask;
529 span.interpMask = interpMask;
531 _swrast_write_zoomed_rgba_span(ctx, imgX, imgY, &span, rgba);
534 _swrast_write_rgba_span(ctx, &span);
540 skipPixels += spanWidth;
541 } /* while skipPixels < width */
543 /* XXX this is ugly/temporary, to undo above change */
544 span.array->ChanType = CHAN_TYPE;
554 * This is a bit different from drawing GL_DEPTH_COMPONENT pixels.
555 * The only per-pixel operations that apply are depth scale/bias,
556 * stencil offset/shift, GL_DEPTH_WRITEMASK and GL_STENCIL_WRITEMASK,
558 * Also, only the depth buffer and stencil buffers are touched, not the
562 draw_depth_stencil_pixels(struct gl_context *ctx, GLint x, GLint y,
563 GLsizei width, GLsizei height, GLenum type,
564 const struct gl_pixelstore_attrib *unpack,
565 const GLvoid *pixels)
567 const GLint imgX = x, imgY = y;
568 const GLboolean scaleOrBias
569 = ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0;
570 const GLuint depthMax = ctx->DrawBuffer->_DepthMax;
571 const GLuint stencilMask = ctx->Stencil.WriteMask[0];
572 const GLuint stencilType = (STENCIL_BITS == 8) ?
573 GL_UNSIGNED_BYTE : GL_UNSIGNED_SHORT;
574 const GLboolean zoom = ctx->Pixel.ZoomX != 1.0 || ctx->Pixel.ZoomY != 1.0;
575 struct gl_renderbuffer *depthRb, *stencilRb;
576 struct gl_pixelstore_attrib clippedUnpack = *unpack;
579 if (!_mesa_clip_drawpixels(ctx, &x, &y, &width, &height,
581 /* totally clipped */
586 depthRb = ctx->ReadBuffer->Attachment[BUFFER_DEPTH].Renderbuffer;
587 stencilRb = ctx->ReadBuffer->Attachment[BUFFER_STENCIL].Renderbuffer;
591 if (depthRb->_BaseFormat == GL_DEPTH_STENCIL_EXT &&
592 stencilRb->_BaseFormat == GL_DEPTH_STENCIL_EXT &&
593 depthRb == stencilRb &&
597 (stencilMask & 0xff) == 0xff) {
598 /* This is the ideal case.
599 * Drawing GL_DEPTH_STENCIL pixels into a combined depth/stencil buffer.
600 * Plus, no pixel transfer ops, zooming, or masking needed.
603 for (i = 0; i < height; i++) {
604 const GLuint *src = (const GLuint *)
605 _mesa_image_address2d(&clippedUnpack, pixels, width, height,
606 GL_DEPTH_STENCIL_EXT, type, i, 0);
607 depthRb->PutRow(ctx, depthRb, width, x, y + i, src, NULL);
611 /* sub-optimal cases:
612 * Separate depth/stencil buffers, or pixel transfer ops required.
614 /* XXX need to handle very wide images (skippixels) */
617 depthRb = ctx->DrawBuffer->_DepthBuffer;
618 stencilRb = ctx->DrawBuffer->_StencilBuffer;
620 for (i = 0; i < height; i++) {
621 const GLuint *depthStencilSrc = (const GLuint *)
622 _mesa_image_address2d(&clippedUnpack, pixels, width, height,
623 GL_DEPTH_STENCIL_EXT, type, i, 0);
625 if (ctx->Depth.Mask) {
626 if (!scaleOrBias && ctx->DrawBuffer->Visual.depthBits == 24) {
627 /* fast path 24-bit zbuffer */
628 GLuint zValues[MAX_WIDTH];
630 ASSERT(depthRb->DataType == GL_UNSIGNED_INT);
631 for (j = 0; j < width; j++) {
632 zValues[j] = depthStencilSrc[j] >> 8;
635 _swrast_write_zoomed_z_span(ctx, imgX, imgY, width,
638 depthRb->PutRow(ctx, depthRb, width, x, y + i, zValues,NULL);
640 else if (!scaleOrBias && ctx->DrawBuffer->Visual.depthBits == 16) {
641 /* fast path 16-bit zbuffer */
642 GLushort zValues[MAX_WIDTH];
644 ASSERT(depthRb->DataType == GL_UNSIGNED_SHORT);
645 for (j = 0; j < width; j++) {
646 zValues[j] = depthStencilSrc[j] >> 16;
649 _swrast_write_zoomed_z_span(ctx, imgX, imgY, width,
652 depthRb->PutRow(ctx, depthRb, width, x, y + i, zValues,NULL);
656 GLuint zValues[MAX_WIDTH]; /* 16 or 32-bit Z value storage */
657 _mesa_unpack_depth_span(ctx, width,
658 depthRb->DataType, zValues, depthMax,
659 type, depthStencilSrc, &clippedUnpack);
661 _swrast_write_zoomed_z_span(ctx, imgX, imgY, width, x,
665 depthRb->PutRow(ctx, depthRb, width, x, y + i, zValues,NULL);
670 if (stencilMask != 0x0) {
671 GLstencil stencilValues[MAX_WIDTH];
672 /* get stencil values, with shift/offset/mapping */
673 _mesa_unpack_stencil_span(ctx, width, stencilType, stencilValues,
674 type, depthStencilSrc, &clippedUnpack,
675 ctx->_ImageTransferState);
677 _swrast_write_zoomed_stencil_span(ctx, imgX, imgY, width,
678 x, y + i, stencilValues);
680 _swrast_write_stencil_span(ctx, width, x, y + i, stencilValues);
688 * Execute software-based glDrawPixels.
689 * By time we get here, all error checking will have been done.
692 _swrast_DrawPixels( struct gl_context *ctx,
694 GLsizei width, GLsizei height,
695 GLenum format, GLenum type,
696 const struct gl_pixelstore_attrib *unpack,
697 const GLvoid *pixels )
699 SWcontext *swrast = SWRAST_CONTEXT(ctx);
700 GLboolean save_vp_override = ctx->VertexProgram._Overriden;
702 if (!_mesa_check_conditional_render(ctx))
703 return; /* don't draw */
705 /* We are creating fragments directly, without going through vertex
708 * This override flag tells the fragment processing code that its input
709 * comes from a non-standard source, and it may therefore not rely on
710 * optimizations that assume e.g. constant color if there is no color
713 _mesa_set_vp_override(ctx, GL_TRUE);
715 swrast_render_start(ctx);
718 _mesa_update_state(ctx);
720 if (swrast->NewState)
721 _swrast_validate_derived( ctx );
723 pixels = _mesa_map_pbo_source(ctx, unpack, pixels);
725 swrast_render_finish(ctx);
726 _mesa_set_vp_override(ctx, save_vp_override);
731 * By time we get here, all error checking should have been done.
734 case GL_STENCIL_INDEX:
735 draw_stencil_pixels( ctx, x, y, width, height, type, unpack, pixels );
737 case GL_DEPTH_COMPONENT:
738 draw_depth_pixels( ctx, x, y, width, height, type, unpack, pixels );
740 case GL_DEPTH_STENCIL_EXT:
741 draw_depth_stencil_pixels(ctx, x, y, width, height, type, unpack, pixels);
744 /* all other formats should be color formats */
745 draw_rgba_pixels(ctx, x, y, width, height, format, type, unpack, pixels);
748 swrast_render_finish(ctx);
749 _mesa_set_vp_override(ctx, save_vp_override);
751 _mesa_unmap_pbo_source(ctx, unpack);