src/mesa/swrast/s_bitmap.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  6.5.2
   4  *
   5  * Copyright (C) 1999-2006  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 /**
  26  * \file swrast/s_bitmap.c
  27  * \brief glBitmap rendering.
  28  * \author Brian Paul
  29  */
  30
  31 #include "glheader.h"
  32 #include "bufferobj.h"
  33 #include "image.h"
  34 #include "macros.h"
  35 #include "pixel.h"
  36
  37 #include "s_context.h"
  38 #include "s_span.h"
  39
  40
  41
  42 /**
  43  * Render a bitmap.
  44  * Called via ctx->Driver.Bitmap()
  45  * All parameter error checking will have been done before this is called.
  46  */
  47 void
  48 _swrast_Bitmap( GLcontext *ctx, GLint px, GLint py,
  49                 GLsizei width, GLsizei height,
  50                 const struct gl_pixelstore_attrib *unpack,
  51                 const GLubyte *bitmap )
  52 {
  53    SWcontext *swrast = SWRAST_CONTEXT(ctx);
  54    GLint row, col;
  55    GLuint count = 0;
  56    SWspan span;
  57
  58    ASSERT(ctx->RenderMode == GL_RENDER);
  59
  60    if (unpack->BufferObj->Name) {
  61       /* unpack from PBO */
  62       GLubyte *buf;
  63       if (!_mesa_validate_pbo_access(2, unpack, width, height, 1,
  64                                      GL_COLOR_INDEX, GL_BITMAP,
  65                                      (GLvoid *) bitmap)) {
  66          _mesa_error(ctx, GL_INVALID_OPERATION,"glBitmap(invalid PBO access)");
  67          return;
  68       }
  69       buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
  70                                               GL_READ_ONLY_ARB,
  71                                               unpack->BufferObj);
  72       if (!buf) {
  73          /* buffer is already mapped - that's an error */
  74          _mesa_error(ctx, GL_INVALID_OPERATION, "glBitmap(PBO is mapped)");
  75          return;
  76       }
  77       bitmap = ADD_POINTERS(buf, bitmap);
  78    }
  79
  80    RENDER_START(swrast,ctx);
  81
  82    if (SWRAST_CONTEXT(ctx)->NewState)
  83       _swrast_validate_derived( ctx );
  84
  85    INIT_SPAN(span, GL_BITMAP, width, 0, SPAN_XY);
  86
  87    _swrast_span_default_color(ctx, &span);
  88    if (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)
  89       _swrast_span_default_secondary_color(ctx, &span);
  90    if (ctx->Depth.Test)
  91       _swrast_span_default_z(ctx, &span);
  92    if (swrast->_FogEnabled)
  93       _swrast_span_default_fog(ctx, &span);
  94    if (ctx->Texture._EnabledCoordUnits)
  95       _swrast_span_default_texcoords(ctx, &span);
  96
  97    for (row = 0; row < height; row++) {
  98       const GLubyte *src = (const GLubyte *) _mesa_image_address2d(unpack,
  99                  bitmap, width, height, GL_COLOR_INDEX, GL_BITMAP, row, 0);
 100
 101       if (unpack->LsbFirst) {
 102          /* Lsb first */
 103          GLubyte mask = 1U << (unpack->SkipPixels & 0x7);
 104          for (col = 0; col < width; col++) {
 105             if (*src & mask) {
 106                span.array->x[count] = px + col;
 107                span.array->y[count] = py + row;
 108                count++;
 109             }
 110             if (mask == 128U) {
 111                src++;
 112                mask = 1U;
 113             }
 114             else {
 115                mask = mask << 1;
 116             }
 117          }
 118
 119          /* get ready for next row */
 120          if (mask != 1)
 121             src++;
 122       }
 123       else {
 124          /* Msb first */
 125          GLubyte mask = 128U >> (unpack->SkipPixels & 0x7);
 126          for (col = 0; col < width; col++) {
 127             if (*src & mask) {
 128                span.array->x[count] = px + col;
 129                span.array->y[count] = py + row;
 130                count++;
 131             }
 132             if (mask == 1U) {
 133                src++;
 134                mask = 128U;
 135             }
 136             else {
 137                mask = mask >> 1;
 138             }
 139          }
 140
 141          /* get ready for next row */
 142          if (mask != 128)
 143             src++;
 144       }
 145
 146       if (count + width >= MAX_WIDTH || row + 1 == height) {
 147          /* flush the span */
 148          span.end = count;
 149          if (ctx->Visual.rgbMode)
 150             _swrast_write_rgba_span(ctx, &span);
 151          else
 152             _swrast_write_index_span(ctx, &span);
 153          span.end = 0;
 154          count = 0;
 155       }
 156    }
 157
 158    RENDER_FINISH(swrast,ctx);
 159
 160    if (unpack->BufferObj->Name) {
 161       /* done with PBO so unmap it now */
 162       ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
 163                               unpack->BufferObj);
 164    }
 165 }
 166
 167
 168 #if 0
 169 /*
 170  * XXX this is another way to implement Bitmap.  Use horizontal runs of
 171  * fragments, initializing the mask array to indicate which fragments to
 172  * draw or skip.
 173  */
 174 void
 175 _swrast_Bitmap( GLcontext *ctx, GLint px, GLint py,
 176                 GLsizei width, GLsizei height,
 177                 const struct gl_pixelstore_attrib *unpack,
 178                 const GLubyte *bitmap )
 179 {
 180    SWcontext *swrast = SWRAST_CONTEXT(ctx);
 181    GLint row, col;
 182    SWspan span;
 183
 184    ASSERT(ctx->RenderMode == GL_RENDER);
 185    ASSERT(bitmap);
 186
 187    RENDER_START(swrast,ctx);
 188
 189    if (SWRAST_CONTEXT(ctx)->NewState)
 190       _swrast_validate_derived( ctx );
 191
 192    INIT_SPAN(span, GL_BITMAP, width, 0, SPAN_MASK);
 193
 194    /*span.arrayMask |= SPAN_MASK;*/  /* we'll init span.mask[] */
 195    span.x = px;
 196    span.y = py;
 197    /*span.end = width;*/
 198
 199    _swrast_span_default_color(ctx, &span);
 200    if (ctx->Depth.Test)
 201       _swrast_span_default_z(ctx, &span);
 202    if (swrast->_FogEnabled)
 203       _swrast_span_default_fog(ctx, &span);
 204    if (ctx->Texture._EnabledCoordUnits)
 205       _swrast_span_default_texcoords(ctx, &span);
 206
 207    for (row=0; row<height; row++, span.y++) {
 208       const GLubyte *src = (const GLubyte *) _mesa_image_address2d(unpack,
 209                  bitmap, width, height, GL_COLOR_INDEX, GL_BITMAP, row, 0);
 210
 211       if (unpack->LsbFirst) {
 212          /* Lsb first */
 213          GLubyte mask = 1U << (unpack->SkipPixels & 0x7);
 214          for (col=0; col<width; col++) {
 215             span.array->mask[col] = (*src & mask) ? GL_TRUE : GL_FALSE;
 216             if (mask == 128U) {
 217                src++;
 218                mask = 1U;
 219             }
 220             else {
 221                mask = mask << 1;
 222             }
 223          }
 224
 225          if (ctx->Visual.rgbMode)
 226             _swrast_write_rgba_span(ctx, &span);
 227          else
 228             _swrast_write_index_span(ctx, &span);
 229
 230          /* get ready for next row */
 231          if (mask != 1)
 232             src++;
 233       }
 234       else {
 235          /* Msb first */
 236          GLubyte mask = 128U >> (unpack->SkipPixels & 0x7);
 237          for (col=0; col<width; col++) {
 238             span.array->mask[col] = (*src & mask) ? GL_TRUE : GL_FALSE;
 239             if (mask == 1U) {
 240                src++;
 241                mask = 128U;
 242             }
 243             else {
 244                mask = mask >> 1;
 245             }
 246          }
 247
 248          if (ctx->Visual.rgbMode)
 249             _swrast_write_rgba_span(ctx, &span);
 250          else
 251             _swrast_write_index_span(ctx, &span);
 252
 253          /* get ready for next row */
 254          if (mask != 128)
 255             src++;
 256       }
 257    }
 258
 259    RENDER_FINISH(swrast,ctx);
 260 }
 261 #endif