• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Mesa 3-D graphics library
3  *
4  * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a
7  * copy of this software and associated documentation files (the "Software"),
8  * to deal in the Software without restriction, including without limitation
9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10  * and/or sell copies of the Software, and to permit persons to whom the
11  * Software is furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included
14  * in all copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
20  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22  * OTHER DEALINGS IN THE SOFTWARE.
23  */
24 
25 
26 #include "main/glheader.h"
27 #include "main/context.h"
28 #include "main/condrender.h"
29 #include "main/macros.h"
30 #include "main/blit.h"
31 #include "main/pixeltransfer.h"
32 #include "main/imports.h"
33 
34 #include "s_context.h"
35 #include "s_depth.h"
36 #include "s_span.h"
37 #include "s_stencil.h"
38 #include "s_zoom.h"
39 
40 
41 
42 /**
43  * Determine if there's overlap in an image copy.
44  * This test also compensates for the fact that copies are done from
45  * bottom to top and overlaps can sometimes be handled correctly
46  * without making a temporary image copy.
47  * \return GL_TRUE if the regions overlap, GL_FALSE otherwise.
48  */
49 static GLboolean
regions_overlap(GLint srcx,GLint srcy,GLint dstx,GLint dsty,GLint width,GLint height,GLfloat zoomX,GLfloat zoomY)50 regions_overlap(GLint srcx, GLint srcy,
51                 GLint dstx, GLint dsty,
52                 GLint width, GLint height,
53                 GLfloat zoomX, GLfloat zoomY)
54 {
55    if (zoomX == 1.0F && zoomY == 1.0F) {
56       return _mesa_regions_overlap(srcx, srcy, srcx + width, srcy + height,
57                                    dstx, dsty, dstx + width, dsty + height);
58    }
59    else {
60       /* add one pixel of slop when zooming, just to be safe */
61       if (srcx > (dstx + ((zoomX > 0.0F) ? (width * zoomX + 1.0F) : 0.0F))) {
62          /* src is completely right of dest */
63          return GL_FALSE;
64       }
65       else if (srcx + width + 1.0F < dstx + ((zoomX > 0.0F) ? 0.0F : (width * zoomX))) {
66          /* src is completely left of dest */
67          return GL_FALSE;
68       }
69       else if ((srcy < dsty) && (srcy + height < dsty + (height * zoomY))) {
70          /* src is completely below dest */
71          return GL_FALSE;
72       }
73       else if ((srcy > dsty) && (srcy + height > dsty + (height * zoomY))) {
74          /* src is completely above dest */
75          return GL_FALSE;
76       }
77       else {
78          return GL_TRUE;
79       }
80    }
81 }
82 
83 
84 /**
85  * RGBA copypixels
86  */
87 static void
copy_rgba_pixels(struct gl_context * ctx,GLint srcx,GLint srcy,GLint width,GLint height,GLint destx,GLint desty)88 copy_rgba_pixels(struct gl_context *ctx, GLint srcx, GLint srcy,
89                  GLint width, GLint height, GLint destx, GLint desty)
90 {
91    GLfloat *tmpImage, *p;
92    GLint sy, dy, stepy, row;
93    const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;
94    GLint overlapping;
95    GLuint transferOps = ctx->_ImageTransferState;
96    SWspan span;
97 
98    if (!ctx->ReadBuffer->_ColorReadBuffer) {
99       /* no readbuffer - OK */
100       return;
101    }
102 
103    if (ctx->DrawBuffer == ctx->ReadBuffer) {
104       overlapping = regions_overlap(srcx, srcy, destx, desty, width, height,
105                                     ctx->Pixel.ZoomX, ctx->Pixel.ZoomY);
106    }
107    else {
108       overlapping = GL_FALSE;
109    }
110 
111    /* Determine if copy should be done bottom-to-top or top-to-bottom */
112    if (!overlapping && srcy < desty) {
113       /* top-down  max-to-min */
114       sy = srcy + height - 1;
115       dy = desty + height - 1;
116       stepy = -1;
117    }
118    else {
119       /* bottom-up  min-to-max */
120       sy = srcy;
121       dy = desty;
122       stepy = 1;
123    }
124 
125    INIT_SPAN(span, GL_BITMAP);
126    _swrast_span_default_attribs(ctx, &span);
127    span.arrayMask = SPAN_RGBA;
128    span.arrayAttribs = VARYING_BIT_COL0; /* we'll fill in COL0 attrib values */
129 
130    if (overlapping) {
131       tmpImage = malloc(width * height * sizeof(GLfloat) * 4);
132       if (!tmpImage) {
133          _mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" );
134          return;
135       }
136       /* read the source image as RGBA/float */
137       p = tmpImage;
138       for (row = 0; row < height; row++) {
139          _swrast_read_rgba_span( ctx, ctx->ReadBuffer->_ColorReadBuffer,
140                                  width, srcx, sy + row, p );
141          p += width * 4;
142       }
143       p = tmpImage;
144    }
145    else {
146       tmpImage = NULL;  /* silence compiler warnings */
147       p = NULL;
148    }
149 
150    assert(width < SWRAST_MAX_WIDTH);
151 
152    for (row = 0; row < height; row++, sy += stepy, dy += stepy) {
153       GLvoid *rgba = span.array->attribs[VARYING_SLOT_COL0];
154 
155       /* Get row/span of source pixels */
156       if (overlapping) {
157          /* get from buffered image */
158          memcpy(rgba, p, width * sizeof(GLfloat) * 4);
159          p += width * 4;
160       }
161       else {
162          /* get from framebuffer */
163          _swrast_read_rgba_span( ctx, ctx->ReadBuffer->_ColorReadBuffer,
164                                  width, srcx, sy, rgba );
165       }
166 
167       if (transferOps) {
168          _mesa_apply_rgba_transfer_ops(ctx, transferOps, width,
169                                        (GLfloat (*)[4]) rgba);
170       }
171 
172       /* Write color span */
173       span.x = destx;
174       span.y = dy;
175       span.end = width;
176       span.array->ChanType = GL_FLOAT;
177       if (zoom) {
178          _swrast_write_zoomed_rgba_span(ctx, destx, desty, &span, rgba);
179       }
180       else {
181          _swrast_write_rgba_span(ctx, &span);
182       }
183    }
184 
185    span.array->ChanType = CHAN_TYPE; /* restore */
186 
187    if (overlapping)
188       free(tmpImage);
189 }
190 
191 
192 /**
193  * Convert floating point Z values to integer Z values with pixel transfer's
194  * Z scale and bias.
195  */
196 static void
scale_and_bias_z(struct gl_context * ctx,GLuint width,const GLfloat depth[],GLuint z[])197 scale_and_bias_z(struct gl_context *ctx, GLuint width,
198                  const GLfloat depth[], GLuint z[])
199 {
200    const GLuint depthMax = ctx->DrawBuffer->_DepthMax;
201    GLuint i;
202 
203    if (depthMax <= 0xffffff &&
204        ctx->Pixel.DepthScale == 1.0F &&
205        ctx->Pixel.DepthBias == 0.0F) {
206       /* no scale or bias and no clamping and no worry of overflow */
207       const GLfloat depthMaxF = ctx->DrawBuffer->_DepthMaxF;
208       for (i = 0; i < width; i++) {
209          z[i] = (GLuint) (depth[i] * depthMaxF);
210       }
211    }
212    else {
213       /* need to be careful with overflow */
214       const GLdouble depthMaxF = ctx->DrawBuffer->_DepthMaxF;
215       for (i = 0; i < width; i++) {
216          GLdouble d = depth[i] * ctx->Pixel.DepthScale + ctx->Pixel.DepthBias;
217          d = CLAMP(d, 0.0, 1.0) * depthMaxF;
218          if (d >= depthMaxF)
219             z[i] = depthMax;
220          else
221             z[i] = (GLuint) d;
222       }
223    }
224 }
225 
226 
227 
228 /*
229  * TODO: Optimize!!!!
230  */
231 static void
copy_depth_pixels(struct gl_context * ctx,GLint srcx,GLint srcy,GLint width,GLint height,GLint destx,GLint desty)232 copy_depth_pixels( struct gl_context *ctx, GLint srcx, GLint srcy,
233                    GLint width, GLint height,
234                    GLint destx, GLint desty )
235 {
236    struct gl_framebuffer *fb = ctx->ReadBuffer;
237    struct gl_renderbuffer *readRb = fb->Attachment[BUFFER_DEPTH].Renderbuffer;
238    GLfloat *p, *tmpImage, *depth;
239    GLint sy, dy, stepy;
240    GLint j;
241    const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;
242    GLint overlapping;
243    SWspan span;
244 
245    if (!readRb) {
246       /* no readbuffer - OK */
247       return;
248    }
249 
250    INIT_SPAN(span, GL_BITMAP);
251    _swrast_span_default_attribs(ctx, &span);
252    span.arrayMask = SPAN_Z;
253 
254    if (ctx->DrawBuffer == ctx->ReadBuffer) {
255       overlapping = regions_overlap(srcx, srcy, destx, desty, width, height,
256                                     ctx->Pixel.ZoomX, ctx->Pixel.ZoomY);
257    }
258    else {
259       overlapping = GL_FALSE;
260    }
261 
262    /* Determine if copy should be bottom-to-top or top-to-bottom */
263    if (!overlapping && srcy < desty) {
264       /* top-down  max-to-min */
265       sy = srcy + height - 1;
266       dy = desty + height - 1;
267       stepy = -1;
268    }
269    else {
270       /* bottom-up  min-to-max */
271       sy = srcy;
272       dy = desty;
273       stepy = 1;
274    }
275 
276    if (overlapping) {
277       GLint ssy = sy;
278       tmpImage = malloc(width * height * sizeof(GLfloat));
279       if (!tmpImage) {
280          _mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" );
281          return;
282       }
283       p = tmpImage;
284       for (j = 0; j < height; j++, ssy += stepy) {
285          _swrast_read_depth_span_float(ctx, readRb, width, srcx, ssy, p);
286          p += width;
287       }
288       p = tmpImage;
289    }
290    else {
291       tmpImage = NULL;  /* silence compiler warning */
292       p = NULL;
293    }
294 
295    depth = malloc(width * sizeof(GLfloat));
296    if (!depth) {
297       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyPixels()");
298       goto end;
299    }
300 
301    for (j = 0; j < height; j++, sy += stepy, dy += stepy) {
302       /* get depth values */
303       if (overlapping) {
304          memcpy(depth, p, width * sizeof(GLfloat));
305          p += width;
306       }
307       else {
308          _swrast_read_depth_span_float(ctx, readRb, width, srcx, sy, depth);
309       }
310 
311       /* apply scale and bias */
312       scale_and_bias_z(ctx, width, depth, span.array->z);
313 
314       /* write depth values */
315       span.x = destx;
316       span.y = dy;
317       span.end = width;
318       if (zoom)
319          _swrast_write_zoomed_depth_span(ctx, destx, desty, &span);
320       else
321          _swrast_write_rgba_span(ctx, &span);
322    }
323 
324    free(depth);
325 
326 end:
327    if (overlapping)
328       free(tmpImage);
329 }
330 
331 
332 
333 static void
copy_stencil_pixels(struct gl_context * ctx,GLint srcx,GLint srcy,GLint width,GLint height,GLint destx,GLint desty)334 copy_stencil_pixels( struct gl_context *ctx, GLint srcx, GLint srcy,
335                      GLint width, GLint height,
336                      GLint destx, GLint desty )
337 {
338    struct gl_framebuffer *fb = ctx->ReadBuffer;
339    struct gl_renderbuffer *rb = fb->Attachment[BUFFER_STENCIL].Renderbuffer;
340    GLint sy, dy, stepy;
341    GLint j;
342    GLubyte *p, *tmpImage, *stencil;
343    const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;
344    GLint overlapping;
345 
346    if (!rb) {
347       /* no readbuffer - OK */
348       return;
349    }
350 
351    if (ctx->DrawBuffer == ctx->ReadBuffer) {
352       overlapping = regions_overlap(srcx, srcy, destx, desty, width, height,
353                                     ctx->Pixel.ZoomX, ctx->Pixel.ZoomY);
354    }
355    else {
356       overlapping = GL_FALSE;
357    }
358 
359    /* Determine if copy should be bottom-to-top or top-to-bottom */
360    if (!overlapping && srcy < desty) {
361       /* top-down  max-to-min */
362       sy = srcy + height - 1;
363       dy = desty + height - 1;
364       stepy = -1;
365    }
366    else {
367       /* bottom-up  min-to-max */
368       sy = srcy;
369       dy = desty;
370       stepy = 1;
371    }
372 
373    if (overlapping) {
374       GLint ssy = sy;
375       tmpImage = malloc(width * height * sizeof(GLubyte));
376       if (!tmpImage) {
377          _mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" );
378          return;
379       }
380       p = tmpImage;
381       for (j = 0; j < height; j++, ssy += stepy) {
382          _swrast_read_stencil_span( ctx, rb, width, srcx, ssy, p );
383          p += width;
384       }
385       p = tmpImage;
386    }
387    else {
388       tmpImage = NULL;  /* silence compiler warning */
389       p = NULL;
390    }
391 
392    stencil = malloc(width * sizeof(GLubyte));
393    if (!stencil) {
394       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyPixels()");
395       goto end;
396    }
397 
398    for (j = 0; j < height; j++, sy += stepy, dy += stepy) {
399       /* Get stencil values */
400       if (overlapping) {
401          memcpy(stencil, p, width * sizeof(GLubyte));
402          p += width;
403       }
404       else {
405          _swrast_read_stencil_span( ctx, rb, width, srcx, sy, stencil );
406       }
407 
408       _mesa_apply_stencil_transfer_ops(ctx, width, stencil);
409 
410       /* Write stencil values */
411       if (zoom) {
412          _swrast_write_zoomed_stencil_span(ctx, destx, desty, width,
413                                            destx, dy, stencil);
414       }
415       else {
416          _swrast_write_stencil_span( ctx, width, destx, dy, stencil );
417       }
418    }
419 
420    free(stencil);
421 
422 end:
423    if (overlapping)
424       free(tmpImage);
425 }
426 
427 
428 /**
429  * Try to do a fast 1:1 blit with memcpy.
430  * \return GL_TRUE if successful, GL_FALSE otherwise.
431  */
432 GLboolean
swrast_fast_copy_pixels(struct gl_context * ctx,struct gl_framebuffer * srcFb,struct gl_framebuffer * dstFb,GLint srcX,GLint srcY,GLsizei width,GLsizei height,GLint dstX,GLint dstY,GLenum type)433 swrast_fast_copy_pixels(struct gl_context *ctx,
434                         struct gl_framebuffer *srcFb,
435                         struct gl_framebuffer *dstFb,
436                         GLint srcX, GLint srcY, GLsizei width, GLsizei height,
437                         GLint dstX, GLint dstY, GLenum type)
438 {
439    struct gl_renderbuffer *srcRb, *dstRb;
440    GLint row;
441    GLuint pixelBytes, widthInBytes;
442    GLubyte *srcMap, *dstMap;
443    GLint srcRowStride, dstRowStride;
444 
445    if (type == GL_COLOR) {
446       if (dstFb->_NumColorDrawBuffers != 1)
447          return GL_FALSE;
448       srcRb = srcFb->_ColorReadBuffer;
449       dstRb = dstFb->_ColorDrawBuffers[0];
450    }
451    else if (type == GL_STENCIL) {
452       srcRb = srcFb->Attachment[BUFFER_STENCIL].Renderbuffer;
453       dstRb = dstFb->Attachment[BUFFER_STENCIL].Renderbuffer;
454    }
455    else if (type == GL_DEPTH) {
456       srcRb = srcFb->Attachment[BUFFER_DEPTH].Renderbuffer;
457       dstRb = dstFb->Attachment[BUFFER_DEPTH].Renderbuffer;
458    }
459    else {
460       assert(type == GL_DEPTH_STENCIL_EXT);
461       /* XXX correct? */
462       srcRb = srcFb->Attachment[BUFFER_DEPTH].Renderbuffer;
463       dstRb = dstFb->Attachment[BUFFER_DEPTH].Renderbuffer;
464    }
465 
466    /* src and dst renderbuffers must be same format */
467    if (!srcRb || !dstRb || srcRb->Format != dstRb->Format) {
468       return GL_FALSE;
469    }
470 
471    if (type == GL_STENCIL || type == GL_DEPTH_COMPONENT) {
472       /* can't handle packed depth+stencil here */
473       if (_mesa_is_format_packed_depth_stencil(srcRb->Format) ||
474           _mesa_is_format_packed_depth_stencil(dstRb->Format))
475          return GL_FALSE;
476    }
477    else if (type == GL_DEPTH_STENCIL) {
478       /* can't handle separate depth/stencil buffers */
479       if (srcRb != srcFb->Attachment[BUFFER_STENCIL].Renderbuffer ||
480           dstRb != dstFb->Attachment[BUFFER_STENCIL].Renderbuffer)
481          return GL_FALSE;
482    }
483 
484    /* clipping not supported */
485    if (srcX < 0 || srcX + width > (GLint) srcFb->Width ||
486        srcY < 0 || srcY + height > (GLint) srcFb->Height ||
487        dstX < dstFb->_Xmin || dstX + width > dstFb->_Xmax ||
488        dstY < dstFb->_Ymin || dstY + height > dstFb->_Ymax) {
489       return GL_FALSE;
490    }
491 
492    pixelBytes = _mesa_get_format_bytes(srcRb->Format);
493    widthInBytes = width * pixelBytes;
494 
495    if (srcRb == dstRb) {
496       /* map whole buffer for read/write */
497       /* XXX we could be clever and just map the union region of the
498        * source and dest rects.
499        */
500       GLubyte *map;
501       GLint rowStride;
502 
503       ctx->Driver.MapRenderbuffer(ctx, srcRb, 0, 0,
504                                   srcRb->Width, srcRb->Height,
505                                   GL_MAP_READ_BIT | GL_MAP_WRITE_BIT,
506                                   &map, &rowStride);
507       if (!map) {
508          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyPixels");
509          return GL_TRUE; /* don't retry with slow path */
510       }
511 
512       srcMap = map + srcY * rowStride + srcX * pixelBytes;
513       dstMap = map + dstY * rowStride + dstX * pixelBytes;
514 
515       /* this handles overlapping copies */
516       if (srcY < dstY) {
517          /* copy in reverse (top->down) order */
518          srcMap += rowStride * (height - 1);
519          dstMap += rowStride * (height - 1);
520          srcRowStride = -rowStride;
521          dstRowStride = -rowStride;
522       }
523       else {
524          /* copy in normal (bottom->up) order */
525          srcRowStride = rowStride;
526          dstRowStride = rowStride;
527       }
528    }
529    else {
530       /* different src/dst buffers */
531       ctx->Driver.MapRenderbuffer(ctx, srcRb, srcX, srcY,
532                                   width, height,
533                                   GL_MAP_READ_BIT, &srcMap, &srcRowStride);
534       if (!srcMap) {
535          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyPixels");
536          return GL_TRUE; /* don't retry with slow path */
537       }
538       ctx->Driver.MapRenderbuffer(ctx, dstRb, dstX, dstY,
539                                   width, height,
540                                   GL_MAP_WRITE_BIT, &dstMap, &dstRowStride);
541       if (!dstMap) {
542          ctx->Driver.UnmapRenderbuffer(ctx, srcRb);
543          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyPixels");
544          return GL_TRUE; /* don't retry with slow path */
545       }
546    }
547 
548    for (row = 0; row < height; row++) {
549       /* memmove() in case of overlap */
550       memmove(dstMap, srcMap, widthInBytes);
551       dstMap += dstRowStride;
552       srcMap += srcRowStride;
553    }
554 
555    ctx->Driver.UnmapRenderbuffer(ctx, srcRb);
556    if (dstRb != srcRb) {
557       ctx->Driver.UnmapRenderbuffer(ctx, dstRb);
558    }
559 
560    return GL_TRUE;
561 }
562 
563 
564 /**
565  * Find/map the renderbuffer that we'll be reading from.
566  * The swrast_render_start() function only maps the drawing buffers,
567  * not the read buffer.
568  */
569 static struct gl_renderbuffer *
map_readbuffer(struct gl_context * ctx,GLenum type)570 map_readbuffer(struct gl_context *ctx, GLenum type)
571 {
572    struct gl_framebuffer *fb = ctx->ReadBuffer;
573    struct gl_renderbuffer *rb;
574    struct swrast_renderbuffer *srb;
575 
576    switch (type) {
577    case GL_COLOR:
578       rb = fb->Attachment[fb->_ColorReadBufferIndex].Renderbuffer;
579       break;
580    case GL_DEPTH:
581    case GL_DEPTH_STENCIL:
582       rb = fb->Attachment[BUFFER_DEPTH].Renderbuffer;
583       break;
584    case GL_STENCIL:
585       rb = fb->Attachment[BUFFER_STENCIL].Renderbuffer;
586       break;
587    default:
588       return NULL;
589    }
590 
591    srb = swrast_renderbuffer(rb);
592 
593    if (!srb || srb->Map) {
594       /* no buffer, or buffer is mapped already, we're done */
595       return NULL;
596    }
597 
598    ctx->Driver.MapRenderbuffer(ctx, rb,
599                                0, 0, rb->Width, rb->Height,
600                                GL_MAP_READ_BIT,
601                                &srb->Map, &srb->RowStride);
602 
603    return rb;
604 }
605 
606 
607 /**
608  * Do software-based glCopyPixels.
609  * By time we get here, all parameters will have been error-checked.
610  */
611 void
_swrast_CopyPixels(struct gl_context * ctx,GLint srcx,GLint srcy,GLsizei width,GLsizei height,GLint destx,GLint desty,GLenum type)612 _swrast_CopyPixels(struct gl_context *ctx,
613                    GLint srcx, GLint srcy, GLsizei width, GLsizei height,
614                    GLint destx, GLint desty, GLenum type)
615 {
616    SWcontext *swrast = SWRAST_CONTEXT(ctx);
617    struct gl_renderbuffer *rb;
618 
619    if (!_mesa_check_conditional_render(ctx))
620       return; /* don't copy */
621 
622    if (swrast->NewState)
623       _swrast_validate_derived( ctx );
624 
625    if (!(SWRAST_CONTEXT(ctx)->_RasterMask != 0x0 ||
626        ctx->Pixel.ZoomX != 1.0F ||
627        ctx->Pixel.ZoomY != 1.0F ||
628        ctx->_ImageTransferState) &&
629       swrast_fast_copy_pixels(ctx, ctx->ReadBuffer, ctx->DrawBuffer,
630                               srcx, srcy, width, height, destx, desty,
631                               type)) {
632       /* all done */
633       return;
634    }
635 
636    swrast_render_start(ctx);
637    rb = map_readbuffer(ctx, type);
638 
639    switch (type) {
640    case GL_COLOR:
641       copy_rgba_pixels( ctx, srcx, srcy, width, height, destx, desty );
642       break;
643    case GL_DEPTH:
644       copy_depth_pixels( ctx, srcx, srcy, width, height, destx, desty );
645       break;
646    case GL_STENCIL:
647       copy_stencil_pixels( ctx, srcx, srcy, width, height, destx, desty );
648       break;
649    case GL_DEPTH_STENCIL_EXT:
650       /* Copy buffers separately (if the fast copy path wasn't taken) */
651       copy_depth_pixels(ctx, srcx, srcy, width, height, destx, desty);
652       copy_stencil_pixels(ctx, srcx, srcy, width, height, destx, desty);
653       break;
654    default:
655       _mesa_problem(ctx, "unexpected type in _swrast_CopyPixels");
656    }
657 
658    swrast_render_finish(ctx);
659 
660    if (rb) {
661       struct swrast_renderbuffer *srb = swrast_renderbuffer(rb);
662       ctx->Driver.UnmapRenderbuffer(ctx, rb);
663       srb->Map = NULL;
664    }
665 }
666