src/mesa/main/readpix.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  7.1
   4  *
   5  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
   6  *
   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:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  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.
  23  */
  24
  25 #include "glheader.h"
  26 #include "imports.h"
  27 #include "bufferobj.h"
  28 #include "context.h"
  29 #include "enums.h"
  30 #include "readpix.h"
  31 #include "framebuffer.h"
  32 #include "formats.h"
  33 #include "image.h"
  34 #include "mtypes.h"
  35 #include "state.h"
  36
  37
  38 /**
  39  * Do error checking of the format/type parameters to glReadPixels and
  40  * glDrawPixels.
  41  * \param drawing if GL_TRUE do checking for DrawPixels, else do checking
  42  *                for ReadPixels.
  43  * \return GL_TRUE if error detected, GL_FALSE if no errors
  44  */
  45 GLboolean
  46 _mesa_error_check_format_type(struct gl_context *ctx, GLenum format, GLenum type,
  47                               GLboolean drawing)
  48 {
  49    const char *readDraw = drawing ? "Draw" : "Read";
  50    const GLboolean reading = !drawing;
  51
  52    /* state validation should have already been done */
  53    ASSERT(ctx->NewState == 0x0);
  54
  55    if (ctx->Extensions.EXT_packed_depth_stencil
  56        && type == GL_UNSIGNED_INT_24_8_EXT
  57        && format != GL_DEPTH_STENCIL_EXT) {
  58       _mesa_error(ctx, GL_INVALID_OPERATION,
  59                   "gl%sPixels(format is not GL_DEPTH_STENCIL_EXT)", readDraw);
  60       return GL_TRUE;
  61    }
  62
  63    /* basic combinations test */
  64    if (!_mesa_is_legal_format_and_type(ctx, format, type)) {
  65       _mesa_error(ctx, GL_INVALID_ENUM,
  66                   "gl%sPixels(format or type)", readDraw);
  67       return GL_TRUE;
  68    }
  69
  70    /* additional checks */
  71    switch (format) {
  72    case GL_RG:
  73    case GL_RED:
  74    case GL_GREEN:
  75    case GL_BLUE:
  76    case GL_ALPHA:
  77    case GL_LUMINANCE:
  78    case GL_LUMINANCE_ALPHA:
  79    case GL_RGB:
  80    case GL_BGR:
  81    case GL_RGBA:
  82    case GL_BGRA:
  83    case GL_ABGR_EXT:
  84    case GL_RED_INTEGER_EXT:
  85    case GL_GREEN_INTEGER_EXT:
  86    case GL_BLUE_INTEGER_EXT:
  87    case GL_ALPHA_INTEGER_EXT:
  88    case GL_RGB_INTEGER_EXT:
  89    case GL_RGBA_INTEGER_EXT:
  90    case GL_BGR_INTEGER_EXT:
  91    case GL_BGRA_INTEGER_EXT:
  92    case GL_LUMINANCE_INTEGER_EXT:
  93    case GL_LUMINANCE_ALPHA_INTEGER_EXT:
  94       if (!drawing) {
  95          /* reading */
  96          if (!_mesa_source_buffer_exists(ctx, GL_COLOR)) {
  97             _mesa_error(ctx, GL_INVALID_OPERATION,
  98                         "glReadPixels(no color buffer)");
  99             return GL_TRUE;
 100          }
 101       }
 102       break;
 103    case GL_COLOR_INDEX:
 104       if (drawing) {
 105          if (ctx->PixelMaps.ItoR.Size == 0 ||
 106              ctx->PixelMaps.ItoG.Size == 0 ||
 107              ctx->PixelMaps.ItoB.Size == 0) {
 108             _mesa_error(ctx, GL_INVALID_OPERATION,
 109                    "glDrawPixels(drawing color index pixels into RGB buffer)");
 110             return GL_TRUE;
 111          }
 112       }
 113       else {
 114          /* reading */
 115          if (!_mesa_source_buffer_exists(ctx, GL_COLOR)) {
 116             _mesa_error(ctx, GL_INVALID_OPERATION,
 117                         "glReadPixels(no color buffer)");
 118             return GL_TRUE;
 119          }
 120          /* We no longer support CI-mode color buffers so trying to read
 121           * GL_COLOR_INDEX pixels is always an error.
 122           */
 123          _mesa_error(ctx, GL_INVALID_OPERATION,
 124                      "glReadPixels(color buffer is RGB)");
 125          return GL_TRUE;
 126       }
 127       break;
 128    case GL_STENCIL_INDEX:
 129       if ((drawing && !_mesa_dest_buffer_exists(ctx, format)) ||
 130           (reading && !_mesa_source_buffer_exists(ctx, format))) {
 131          _mesa_error(ctx, GL_INVALID_OPERATION,
 132                      "gl%sPixels(no stencil buffer)", readDraw);
 133          return GL_TRUE;
 134       }
 135       break;
 136    case GL_DEPTH_COMPONENT:
 137       if ((drawing && !_mesa_dest_buffer_exists(ctx, format))) {
 138          _mesa_error(ctx, GL_INVALID_OPERATION,
 139                      "gl%sPixels(no depth buffer)", readDraw);
 140          return GL_TRUE;
 141       }
 142       break;
 143    case GL_DEPTH_STENCIL_EXT:
 144       if (!ctx->Extensions.EXT_packed_depth_stencil ||
 145           type != GL_UNSIGNED_INT_24_8_EXT) {
 146          _mesa_error(ctx, GL_INVALID_ENUM, "gl%sPixels(type)", readDraw);
 147          return GL_TRUE;
 148       }
 149       if ((drawing && !_mesa_dest_buffer_exists(ctx, format)) ||
 150           (reading && !_mesa_source_buffer_exists(ctx, format))) {
 151          _mesa_error(ctx, GL_INVALID_OPERATION,
 152                      "gl%sPixels(no depth or stencil buffer)", readDraw);
 153          return GL_TRUE;
 154       }
 155       break;
 156    default:
 157       /* this should have been caught in _mesa_is_legal_format_type() */
 158       _mesa_problem(ctx, "unexpected format in _mesa_%sPixels", readDraw);
 159       return GL_TRUE;
 160    }
 161
 162    /* no errors */
 163    return GL_FALSE;
 164 }
 165
 166
 167
 168 void GLAPIENTRY
 169 _mesa_ReadPixels( GLint x, GLint y, GLsizei width, GLsizei height,
 170                   GLenum format, GLenum type, GLvoid *pixels )
 171 {
 172    GET_CURRENT_CONTEXT(ctx);
 173    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 174
 175    FLUSH_CURRENT(ctx, 0);
 176
 177    if (MESA_VERBOSE & VERBOSE_API)
 178       _mesa_debug(ctx, "glReadPixels(%d, %d, %s, %s, %p)\n",
 179                   width, height,
 180                   _mesa_lookup_enum_by_nr(format),
 181                   _mesa_lookup_enum_by_nr(type),
 182                   pixels);
 183
 184    if (width < 0 || height < 0) {
 185       _mesa_error( ctx, GL_INVALID_VALUE,
 186                    "glReadPixels(width=%d height=%d)", width, height );
 187       return;
 188    }
 189
 190    if (ctx->NewState)
 191       _mesa_update_state(ctx);
 192
 193    if (_mesa_error_check_format_type(ctx, format, type, GL_FALSE)) {
 194       /* found an error */
 195       return;
 196    }
 197
 198    /* Check that the destination format and source buffer are both
 199     * integer-valued or both non-integer-valued.
 200     */
 201    if (ctx->Extensions.EXT_texture_integer && _mesa_is_color_format(format)) {
 202       const struct gl_renderbuffer *rb = ctx->ReadBuffer->_ColorReadBuffer;
 203       const GLboolean srcInteger = _mesa_is_format_integer_color(rb->Format);
 204       const GLboolean dstInteger = _mesa_is_integer_format(format);
 205       if (dstInteger != srcInteger) {
 206          _mesa_error(ctx, GL_INVALID_OPERATION,
 207                      "glReadPixels(integer / non-integer format mismatch");
 208          return;
 209       }
 210    }
 211
 212    if (ctx->ReadBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
 213       _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,
 214                   "glReadPixels(incomplete framebuffer)" );
 215       return;
 216    }
 217
 218    if (!_mesa_source_buffer_exists(ctx, format)) {
 219       _mesa_error(ctx, GL_INVALID_OPERATION, "glReadPixels(no readbuffer)");
 220       return;
 221    }
 222
 223    if (width == 0 || height == 0)
 224       return; /* nothing to do */
 225
 226    if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) {
 227       if (!_mesa_validate_pbo_access(2, &ctx->Pack, width, height, 1,
 228                                      format, type, pixels)) {
 229          _mesa_error(ctx, GL_INVALID_OPERATION,
 230                      "glReadPixels(invalid PBO access)");
 231          return;
 232       }
 233
 234       if (_mesa_bufferobj_mapped(ctx->Pack.BufferObj)) {
 235          /* buffer is mapped - that's an error */
 236          _mesa_error(ctx, GL_INVALID_OPERATION, "glReadPixels(PBO is mapped)");
 237          return;
 238       }
 239    }
 240
 241    ctx->Driver.ReadPixels(ctx, x, y, width, height,
 242                           format, type, &ctx->Pack, pixels);
 243 }