2 * Mesa 3-D graphics library
5 * Copyright (C) 1999-2006 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.
30 #include "histogram.h"
36 #include "s_context.h"
39 #include "s_stencil.h"
45 * Determine if there's overlap in an image copy.
46 * This test also compensates for the fact that copies are done from
47 * bottom to top and overlaps can sometimes be handled correctly
48 * without making a temporary image copy.
51 regions_overlap(GLint srcx
, GLint srcy
,
52 GLint dstx
, GLint dsty
,
53 GLint width
, GLint height
,
54 GLfloat zoomX
, GLfloat zoomY
)
56 if (zoomX
== 1.0 && zoomY
== 1.0) {
58 if (srcx
>= dstx
+ width
|| (srcx
+ width
<= dstx
)) {
61 else if (srcy
< dsty
) { /* this is OK */
64 else if (srcy
> dsty
+ height
) {
72 /* add one pixel of slop when zooming, just to be safe */
73 if ((srcx
> dstx
+ (width
* zoomX
) + 1) || (srcx
+ width
+ 1 < dstx
)) {
76 else if ((srcy
< dsty
) && (srcy
+ height
< dsty
+ (height
* zoomY
))) {
79 else if ((srcy
> dsty
) && (srcy
+ height
> dsty
+ (height
* zoomY
))) {
90 * Convert GLfloat[n][4] colors to GLchan[n][4].
91 * XXX maybe move into image.c
94 float_span_to_chan(GLuint n
, CONST GLfloat in
[][4], GLchan out
[][4])
97 for (i
= 0; i
< n
; i
++) {
98 UNCLAMPED_FLOAT_TO_CHAN(out
[i
][RCOMP
], in
[i
][RCOMP
]);
99 UNCLAMPED_FLOAT_TO_CHAN(out
[i
][GCOMP
], in
[i
][GCOMP
]);
100 UNCLAMPED_FLOAT_TO_CHAN(out
[i
][BCOMP
], in
[i
][BCOMP
]);
101 UNCLAMPED_FLOAT_TO_CHAN(out
[i
][ACOMP
], in
[i
][ACOMP
]);
107 * Convert GLchan[n][4] colors to GLfloat[n][4].
108 * XXX maybe move into image.c
111 chan_span_to_float(GLuint n
, CONST GLchan in
[][4], GLfloat out
[][4])
114 for (i
= 0; i
< n
; i
++) {
115 out
[i
][RCOMP
] = CHAN_TO_FLOAT(in
[i
][RCOMP
]);
116 out
[i
][GCOMP
] = CHAN_TO_FLOAT(in
[i
][GCOMP
]);
117 out
[i
][BCOMP
] = CHAN_TO_FLOAT(in
[i
][BCOMP
]);
118 out
[i
][ACOMP
] = CHAN_TO_FLOAT(in
[i
][ACOMP
]);
125 * RGBA copypixels with convolution.
128 copy_conv_rgba_pixels(GLcontext
*ctx
, GLint srcx
, GLint srcy
,
129 GLint width
, GLint height
, GLint destx
, GLint desty
)
131 SWcontext
*swrast
= SWRAST_CONTEXT(ctx
);
132 struct gl_renderbuffer
*drawRb
= NULL
;
133 GLboolean quick_draw
;
135 const GLboolean zoom
= ctx
->Pixel
.ZoomX
!= 1.0F
|| ctx
->Pixel
.ZoomY
!= 1.0F
;
136 const GLuint transferOps
= ctx
->_ImageTransferState
;
137 GLfloat
*dest
, *tmpImage
, *convImage
;
140 INIT_SPAN(span
, GL_BITMAP
, 0, 0, SPAN_RGBA
);
143 _swrast_span_default_z(ctx
, &span
);
144 if (swrast
->_FogEnabled
)
145 _swrast_span_default_fog(ctx
, &span
);
148 if (SWRAST_CONTEXT(ctx
)->_RasterMask
== 0
151 && destx
+ width
<= (GLint
) ctx
->DrawBuffer
->Width
) {
152 quick_draw
= GL_TRUE
;
153 drawRb
= ctx
->DrawBuffer
->_ColorDrawBuffers
[0][0];
156 quick_draw
= GL_FALSE
;
159 /* allocate space for GLfloat image */
160 tmpImage
= (GLfloat
*) _mesa_malloc(width
* height
* 4 * sizeof(GLfloat
));
162 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glCopyPixels");
165 convImage
= (GLfloat
*) _mesa_malloc(width
* height
* 4 * sizeof(GLfloat
));
167 _mesa_free(tmpImage
);
168 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glCopyPixels");
172 /* read source image */
174 for (row
= 0; row
< height
; row
++) {
175 GLchan rgba
[MAX_WIDTH
][4];
176 /* Read GLchan and convert to GLfloat */
177 _swrast_read_rgba_span(ctx
, ctx
->ReadBuffer
->_ColorReadBuffer
,
178 width
, srcx
, srcy
+ row
, rgba
);
179 chan_span_to_float(width
, (CONST
GLchan (*)[4]) rgba
,
180 (GLfloat (*)[4]) dest
);
184 /* do the image transfer ops which preceed convolution */
185 for (row
= 0; row
< height
; row
++) {
186 GLfloat (*rgba
)[4] = (GLfloat (*)[4]) (tmpImage
+ row
* width
* 4);
187 _mesa_apply_rgba_transfer_ops(ctx
,
188 transferOps
& IMAGE_PRE_CONVOLUTION_BITS
,
193 if (ctx
->Pixel
.Convolution2DEnabled
) {
194 _mesa_convolve_2d_image(ctx
, &width
, &height
, tmpImage
, convImage
);
197 ASSERT(ctx
->Pixel
.Separable2DEnabled
);
198 _mesa_convolve_sep_image(ctx
, &width
, &height
, tmpImage
, convImage
);
200 _mesa_free(tmpImage
);
202 /* do remaining post-convolution image transfer ops */
203 for (row
= 0; row
< height
; row
++) {
204 GLfloat (*rgba
)[4] = (GLfloat (*)[4]) (convImage
+ row
* width
* 4);
205 _mesa_apply_rgba_transfer_ops(ctx
,
206 transferOps
& IMAGE_POST_CONVOLUTION_BITS
,
210 /* write the new image */
211 for (row
= 0; row
< height
; row
++) {
212 const GLfloat
*src
= convImage
+ row
* width
* 4;
215 /* convert floats back to chan */
216 float_span_to_chan(width
, (const GLfloat (*)[4]) src
, span
.array
->rgba
);
218 /* write row to framebuffer */
220 if (quick_draw
&& dy
>= 0 && dy
< (GLint
) ctx
->DrawBuffer
->Height
) {
221 drawRb
->PutRow(ctx
, drawRb
, width
, destx
, dy
, span
.array
->rgba
, NULL
);
228 _swrast_write_zoomed_rgba_span(ctx
, destx
, desty
, &span
,
229 (CONST
GLchan (*)[4])span
.array
->rgba
);
232 _swrast_write_rgba_span(ctx
, &span
);
237 _mesa_free(convImage
);
245 copy_rgba_pixels(GLcontext
*ctx
, GLint srcx
, GLint srcy
,
246 GLint width
, GLint height
, GLint destx
, GLint desty
)
248 SWcontext
*swrast
= SWRAST_CONTEXT(ctx
);
249 struct gl_renderbuffer
*drawRb
;
251 GLboolean quick_draw
;
252 GLint sy
, dy
, stepy
, j
;
253 const GLboolean zoom
= ctx
->Pixel
.ZoomX
!= 1.0F
|| ctx
->Pixel
.ZoomY
!= 1.0F
;
255 const GLuint transferOps
= ctx
->_ImageTransferState
;
258 if (!ctx
->ReadBuffer
->_ColorReadBuffer
) {
259 /* no readbuffer - OK */
263 INIT_SPAN(span
, GL_BITMAP
, 0, 0, SPAN_RGBA
);
265 if (ctx
->Pixel
.Convolution2DEnabled
|| ctx
->Pixel
.Separable2DEnabled
) {
266 copy_conv_rgba_pixels(ctx
, srcx
, srcy
, width
, height
, destx
, desty
);
270 /* Determine if copy should be done bottom-to-top or top-to-bottom */
272 /* top-down max-to-min */
273 sy
= srcy
+ height
- 1;
274 dy
= desty
+ height
- 1;
278 /* bottom-up min-to-max */
284 if (ctx
->DrawBuffer
== ctx
->ReadBuffer
) {
285 overlapping
= regions_overlap(srcx
, srcy
, destx
, desty
, width
, height
,
286 ctx
->Pixel
.ZoomX
, ctx
->Pixel
.ZoomY
);
289 overlapping
= GL_FALSE
;
293 _swrast_span_default_z(ctx
, &span
);
294 if (swrast
->_FogEnabled
)
295 _swrast_span_default_fog(ctx
, &span
);
297 if (SWRAST_CONTEXT(ctx
)->_RasterMask
== 0
300 && destx
+ width
<= (GLint
) ctx
->DrawBuffer
->Width
) {
301 quick_draw
= GL_TRUE
;
302 drawRb
= ctx
->DrawBuffer
->_ColorDrawBuffers
[0][0];
305 quick_draw
= GL_FALSE
;
311 tmpImage
= (GLchan
*) _mesa_malloc(width
* height
* sizeof(GLchan
) * 4);
313 _mesa_error( ctx
, GL_OUT_OF_MEMORY
, "glCopyPixels" );
316 /* read the source image */
318 for (j
= 0; j
< height
; j
++, ssy
+= stepy
) {
319 _swrast_read_rgba_span( ctx
, ctx
->ReadBuffer
->_ColorReadBuffer
,
320 width
, srcx
, ssy
, (GLchan (*)[4]) p
);
326 tmpImage
= NULL
; /* silence compiler warnings */
330 for (j
= 0; j
< height
; j
++, sy
+= stepy
, dy
+= stepy
) {
331 /* Get source pixels */
333 /* get from buffered image */
334 ASSERT(width
< MAX_WIDTH
);
335 _mesa_memcpy(span
.array
->rgba
, p
, width
* sizeof(GLchan
) * 4);
339 /* get from framebuffer */
340 ASSERT(width
< MAX_WIDTH
);
341 _swrast_read_rgba_span( ctx
, ctx
->ReadBuffer
->_ColorReadBuffer
,
342 width
, srcx
, sy
, span
.array
->rgba
);
346 GLfloat rgbaFloat
[MAX_WIDTH
][4];
347 /* convert to float, transfer, convert back to chan */
348 chan_span_to_float(width
, (CONST
GLchan (*)[4]) span
.array
->rgba
,
350 _mesa_apply_rgba_transfer_ops(ctx
, transferOps
, width
, rgbaFloat
);
351 float_span_to_chan(width
, (CONST
GLfloat (*)[4]) rgbaFloat
,
355 /* Write color span */
356 if (quick_draw
&& dy
>= 0 && dy
< (GLint
) ctx
->DrawBuffer
->Height
) {
357 drawRb
->PutRow(ctx
, drawRb
, width
, destx
, dy
, span
.array
->rgba
, NULL
);
364 _swrast_write_zoomed_rgba_span(ctx
, destx
, desty
, &span
,
365 (CONST
GLchan (*)[4]) span
.array
->rgba
);
368 _swrast_write_rgba_span(ctx
, &span
);
374 _mesa_free(tmpImage
);
379 copy_ci_pixels( GLcontext
*ctx
, GLint srcx
, GLint srcy
,
380 GLint width
, GLint height
,
381 GLint destx
, GLint desty
)
383 SWcontext
*swrast
= SWRAST_CONTEXT(ctx
);
387 const GLboolean zoom
= ctx
->Pixel
.ZoomX
!= 1.0F
|| ctx
->Pixel
.ZoomY
!= 1.0F
;
388 const GLboolean shift_or_offset
= ctx
->Pixel
.IndexShift
|| ctx
->Pixel
.IndexOffset
;
392 if (!ctx
->ReadBuffer
->_ColorReadBuffer
) {
393 /* no readbuffer - OK */
397 INIT_SPAN(span
, GL_BITMAP
, 0, 0, SPAN_INDEX
);
399 /* Determine if copy should be bottom-to-top or top-to-bottom */
401 /* top-down max-to-min */
402 sy
= srcy
+ height
- 1;
403 dy
= desty
+ height
- 1;
407 /* bottom-up min-to-max */
413 if (ctx
->DrawBuffer
== ctx
->ReadBuffer
) {
414 overlapping
= regions_overlap(srcx
, srcy
, destx
, desty
, width
, height
,
415 ctx
->Pixel
.ZoomX
, ctx
->Pixel
.ZoomY
);
418 overlapping
= GL_FALSE
;
422 _swrast_span_default_z(ctx
, &span
);
423 if (swrast
->_FogEnabled
)
424 _swrast_span_default_fog(ctx
, &span
);
428 tmpImage
= (GLuint
*) _mesa_malloc(width
* height
* sizeof(GLuint
));
430 _mesa_error( ctx
, GL_OUT_OF_MEMORY
, "glCopyPixels" );
435 for (j
= 0; j
< height
; j
++, ssy
+= stepy
) {
436 _swrast_read_index_span( ctx
, ctx
->ReadBuffer
->_ColorReadBuffer
,
437 width
, srcx
, ssy
, p
);
443 tmpImage
= NULL
; /* silence compiler warning */
447 for (j
= 0; j
< height
; j
++, sy
+= stepy
, dy
+= stepy
) {
448 /* Get color indexes */
450 _mesa_memcpy(span
.array
->index
, p
, width
* sizeof(GLuint
));
454 _swrast_read_index_span( ctx
, ctx
->ReadBuffer
->_ColorReadBuffer
,
455 width
, srcx
, sy
, span
.array
->index
);
458 /* Apply shift, offset, look-up table */
459 if (shift_or_offset
) {
460 _mesa_shift_and_offset_ci( ctx
, width
, span
.array
->index
);
462 if (ctx
->Pixel
.MapColorFlag
) {
463 _mesa_map_ci( ctx
, width
, span
.array
->index
);
466 /* write color indexes */
471 _swrast_write_zoomed_index_span(ctx
, destx
, desty
, &span
);
473 _swrast_write_index_span(ctx
, &span
);
477 _mesa_free(tmpImage
);
482 * Convert floating point Z values to integer Z values with pixel transfer's
486 scale_and_bias_z(GLcontext
*ctx
, GLuint width
,
487 const GLfloat depth
[], GLuint z
[])
489 const GLuint depthMax
= ctx
->DrawBuffer
->_DepthMax
;
492 if (depthMax
<= 0xffffff &&
493 ctx
->Pixel
.DepthScale
== 1.0 &&
494 ctx
->Pixel
.DepthBias
== 0.0) {
495 /* no scale or bias and no clamping and no worry of overflow */
496 const GLfloat depthMaxF
= ctx
->DrawBuffer
->_DepthMaxF
;
497 for (i
= 0; i
< width
; i
++) {
498 z
[i
] = (GLuint
) (depth
[i
] * depthMaxF
);
502 /* need to be careful with overflow */
503 const GLdouble depthMaxF
= ctx
->DrawBuffer
->_DepthMaxF
;
504 for (i
= 0; i
< width
; i
++) {
505 GLdouble d
= depth
[i
] * ctx
->Pixel
.DepthScale
+ ctx
->Pixel
.DepthBias
;
506 d
= CLAMP(d
, 0.0, 1.0) * depthMaxF
;
521 copy_depth_pixels( GLcontext
*ctx
, GLint srcx
, GLint srcy
,
522 GLint width
, GLint height
,
523 GLint destx
, GLint desty
)
525 SWcontext
*swrast
= SWRAST_CONTEXT(ctx
);
526 struct gl_framebuffer
*fb
= ctx
->ReadBuffer
;
527 struct gl_renderbuffer
*readRb
= fb
->_DepthBuffer
;
528 GLfloat
*p
, *tmpImage
;
531 const GLboolean zoom
= ctx
->Pixel
.ZoomX
!= 1.0F
|| ctx
->Pixel
.ZoomY
!= 1.0F
;
536 /* no readbuffer - OK */
540 INIT_SPAN(span
, GL_BITMAP
, 0, 0, SPAN_Z
);
542 /* Determine if copy should be bottom-to-top or top-to-bottom */
544 /* top-down max-to-min */
545 sy
= srcy
+ height
- 1;
546 dy
= desty
+ height
- 1;
550 /* bottom-up min-to-max */
556 if (ctx
->DrawBuffer
== ctx
->ReadBuffer
) {
557 overlapping
= regions_overlap(srcx
, srcy
, destx
, desty
, width
, height
,
558 ctx
->Pixel
.ZoomX
, ctx
->Pixel
.ZoomY
);
561 overlapping
= GL_FALSE
;
564 _swrast_span_default_color(ctx
, &span
);
565 if (swrast
->_FogEnabled
)
566 _swrast_span_default_fog(ctx
, &span
);
570 tmpImage
= (GLfloat
*) _mesa_malloc(width
* height
* sizeof(GLfloat
));
572 _mesa_error( ctx
, GL_OUT_OF_MEMORY
, "glCopyPixels" );
576 for (j
= 0; j
< height
; j
++, ssy
+= stepy
) {
577 _swrast_read_depth_span_float(ctx
, readRb
, width
, srcx
, ssy
, p
);
583 tmpImage
= NULL
; /* silence compiler warning */
587 for (j
= 0; j
< height
; j
++, sy
+= stepy
, dy
+= stepy
) {
588 GLfloat depth
[MAX_WIDTH
];
589 /* get depth values */
591 _mesa_memcpy(depth
, p
, width
* sizeof(GLfloat
));
595 _swrast_read_depth_span_float(ctx
, readRb
, width
, srcx
, sy
, depth
);
598 /* apply scale and bias */
599 scale_and_bias_z(ctx
, width
, depth
, span
.array
->z
);
601 /* write depth values */
605 if (fb
->Visual
.rgbMode
) {
607 _swrast_write_zoomed_rgba_span(ctx
, destx
, desty
, &span
,
608 (const GLchan (*)[4]) span
.array
->rgba
);
610 _swrast_write_rgba_span(ctx
, &span
);
614 _swrast_write_zoomed_index_span(ctx
, destx
, desty
, &span
);
616 _swrast_write_index_span(ctx
, &span
);
621 _mesa_free(tmpImage
);
627 copy_stencil_pixels( GLcontext
*ctx
, GLint srcx
, GLint srcy
,
628 GLint width
, GLint height
,
629 GLint destx
, GLint desty
)
631 struct gl_framebuffer
*fb
= ctx
->ReadBuffer
;
632 struct gl_renderbuffer
*rb
= fb
->_StencilBuffer
;
635 GLstencil
*p
, *tmpImage
;
636 const GLboolean zoom
= ctx
->Pixel
.ZoomX
!= 1.0F
|| ctx
->Pixel
.ZoomY
!= 1.0F
;
637 const GLboolean shift_or_offset
= ctx
->Pixel
.IndexShift
|| ctx
->Pixel
.IndexOffset
;
641 /* no readbuffer - OK */
645 /* Determine if copy should be bottom-to-top or top-to-bottom */
647 /* top-down max-to-min */
648 sy
= srcy
+ height
- 1;
649 dy
= desty
+ height
- 1;
653 /* bottom-up min-to-max */
659 if (ctx
->DrawBuffer
== ctx
->ReadBuffer
) {
660 overlapping
= regions_overlap(srcx
, srcy
, destx
, desty
, width
, height
,
661 ctx
->Pixel
.ZoomX
, ctx
->Pixel
.ZoomY
);
664 overlapping
= GL_FALSE
;
669 tmpImage
= (GLstencil
*) _mesa_malloc(width
* height
* sizeof(GLstencil
));
671 _mesa_error( ctx
, GL_OUT_OF_MEMORY
, "glCopyPixels" );
675 for (j
= 0; j
< height
; j
++, ssy
+= stepy
) {
676 _swrast_read_stencil_span( ctx
, rb
, width
, srcx
, ssy
, p
);
682 tmpImage
= NULL
; /* silence compiler warning */
686 for (j
= 0; j
< height
; j
++, sy
+= stepy
, dy
+= stepy
) {
687 GLstencil stencil
[MAX_WIDTH
];
689 /* Get stencil values */
691 _mesa_memcpy(stencil
, p
, width
* sizeof(GLstencil
));
695 _swrast_read_stencil_span( ctx
, rb
, width
, srcx
, sy
, stencil
);
698 /* Apply shift, offset, look-up table */
699 if (shift_or_offset
) {
700 _mesa_shift_and_offset_stencil( ctx
, width
, stencil
);
702 if (ctx
->Pixel
.MapStencilFlag
) {
703 _mesa_map_stencil( ctx
, width
, stencil
);
706 /* Write stencil values */
708 _swrast_write_zoomed_stencil_span(ctx
, destx
, desty
, width
,
712 _swrast_write_stencil_span( ctx
, width
, destx
, dy
, stencil
);
717 _mesa_free(tmpImage
);
722 * This isn't terribly efficient. If a driver really has combined
723 * depth/stencil buffers the driver should implement an optimized
724 * CopyPixels function.
727 copy_depth_stencil_pixels(GLcontext
*ctx
,
728 const GLint srcX
, const GLint srcY
,
729 const GLint width
, const GLint height
,
730 const GLint destX
, const GLint destY
)
732 struct gl_renderbuffer
*stencilReadRb
, *depthReadRb
, *depthDrawRb
;
735 GLstencil
*tempStencilImage
= NULL
, *stencilPtr
= NULL
;
736 GLfloat
*tempDepthImage
= NULL
, *depthPtr
= NULL
;
737 const GLfloat depthScale
= ctx
->DrawBuffer
->_DepthMaxF
;
738 const GLuint stencilMask
= ctx
->Stencil
.WriteMask
[0];
739 const GLboolean zoom
= ctx
->Pixel
.ZoomX
!= 1.0F
|| ctx
->Pixel
.ZoomY
!= 1.0F
;
740 const GLboolean shiftOrOffset
741 = ctx
->Pixel
.IndexShift
|| ctx
->Pixel
.IndexOffset
;
742 const GLboolean scaleOrBias
743 = ctx
->Pixel
.DepthScale
!= 1.0 || ctx
->Pixel
.DepthBias
!= 0.0;
746 depthDrawRb
= ctx
->DrawBuffer
->_DepthBuffer
;
747 depthReadRb
= ctx
->ReadBuffer
->_DepthBuffer
;
748 stencilReadRb
= ctx
->ReadBuffer
->_StencilBuffer
;
752 ASSERT(stencilReadRb
);
754 /* Determine if copy should be bottom-to-top or top-to-bottom */
756 /* top-down max-to-min */
757 sy
= srcY
+ height
- 1;
758 dy
= destY
+ height
- 1;
762 /* bottom-up min-to-max */
768 if (ctx
->DrawBuffer
== ctx
->ReadBuffer
) {
769 overlapping
= regions_overlap(srcX
, srcY
, destX
, destY
, width
, height
,
770 ctx
->Pixel
.ZoomX
, ctx
->Pixel
.ZoomY
);
773 overlapping
= GL_FALSE
;
779 if (stencilMask
!= 0x0) {
781 = (GLstencil
*) _mesa_malloc(width
* height
* sizeof(GLstencil
));
782 if (!tempStencilImage
) {
783 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glCopyPixels");
787 /* get copy of stencil pixels */
788 stencilPtr
= tempStencilImage
;
789 for (j
= 0; j
< height
; j
++, ssy
+= stepy
) {
790 _swrast_read_stencil_span(ctx
, stencilReadRb
,
791 width
, srcX
, ssy
, stencilPtr
);
794 stencilPtr
= tempStencilImage
;
797 if (ctx
->Depth
.Mask
) {
799 = (GLfloat
*) _mesa_malloc(width
* height
* sizeof(GLfloat
));
800 if (!tempDepthImage
) {
801 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glCopyPixels");
802 _mesa_free(tempStencilImage
);
806 /* get copy of depth pixels */
807 depthPtr
= tempDepthImage
;
808 for (j
= 0; j
< height
; j
++, ssy
+= stepy
) {
809 _swrast_read_depth_span_float(ctx
, depthReadRb
,
810 width
, srcX
, ssy
, depthPtr
);
813 depthPtr
= tempDepthImage
;
817 for (j
= 0; j
< height
; j
++, sy
+= stepy
, dy
+= stepy
) {
818 if (stencilMask
!= 0x0) {
819 GLstencil stencil
[MAX_WIDTH
];
821 /* Get stencil values */
823 _mesa_memcpy(stencil
, stencilPtr
, width
* sizeof(GLstencil
));
827 _swrast_read_stencil_span(ctx
, stencilReadRb
,
828 width
, srcX
, sy
, stencil
);
831 /* Apply shift, offset, look-up table */
833 _mesa_shift_and_offset_stencil(ctx
, width
, stencil
);
835 if (ctx
->Pixel
.MapStencilFlag
) {
836 _mesa_map_stencil(ctx
, width
, stencil
);
841 _swrast_write_zoomed_stencil_span(ctx
, destX
, destY
, width
,
845 _swrast_write_stencil_span( ctx
, width
, destX
, dy
, stencil
);
849 if (ctx
->Depth
.Mask
) {
850 GLfloat depth
[MAX_WIDTH
];
851 GLuint zVals32
[MAX_WIDTH
];
852 GLushort zVals16
[MAX_WIDTH
];
856 /* get depth values */
858 _mesa_memcpy(depth
, depthPtr
, width
* sizeof(GLfloat
));
862 _swrast_read_depth_span_float(ctx
, depthReadRb
,
863 width
, srcX
, sy
, depth
);
868 _mesa_scale_and_bias_depth(ctx
, width
, depth
);
870 /* convert to integer Z values */
871 if (depthDrawRb
->DataType
== GL_UNSIGNED_SHORT
) {
873 for (k
= 0; k
< width
; k
++)
874 zVals16
[k
] = (GLushort
) (depth
[k
] * depthScale
);
880 for (k
= 0; k
< width
; k
++)
881 zVals32
[k
] = (GLuint
) (depth
[k
] * depthScale
);
888 _swrast_write_zoomed_z_span(ctx
, destX
, destY
, width
,
892 _swrast_put_row(ctx
, depthDrawRb
, width
, destX
, dy
, zVals
, zBytes
);
897 if (tempStencilImage
)
898 _mesa_free(tempStencilImage
);
901 _mesa_free(tempDepthImage
);
906 * Do software-based glCopyPixels.
907 * By time we get here, all parameters will have been error-checked.
910 _swrast_CopyPixels( GLcontext
*ctx
,
911 GLint srcx
, GLint srcy
, GLsizei width
, GLsizei height
,
912 GLint destx
, GLint desty
, GLenum type
)
914 SWcontext
*swrast
= SWRAST_CONTEXT(ctx
);
915 RENDER_START(swrast
,ctx
);
917 if (swrast
->NewState
)
918 _swrast_validate_derived( ctx
);
922 if (ctx
->Visual
.rgbMode
) {
923 copy_rgba_pixels( ctx
, srcx
, srcy
, width
, height
, destx
, desty
);
926 copy_ci_pixels( ctx
, srcx
, srcy
, width
, height
, destx
, desty
);
930 copy_depth_pixels( ctx
, srcx
, srcy
, width
, height
, destx
, desty
);
933 copy_stencil_pixels( ctx
, srcx
, srcy
, width
, height
, destx
, desty
);
935 case GL_DEPTH_STENCIL_EXT
:
936 copy_depth_stencil_pixels(ctx
, srcx
, srcy
, width
, height
, destx
, desty
);
939 _mesa_problem(ctx
, "unexpected type in _swrast_CopyPixels");
942 RENDER_FINISH(swrast
,ctx
);