src/glx/renderpix.c

   1 /*
   2  * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
   3  * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice including the dates of first publication and
  13  * either this permission notice or a reference to
  14  * http://oss.sgi.com/projects/FreeB/
  15  * shall be included 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  * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  21  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
  22  * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  23  * SOFTWARE.
  24  *
  25  * Except as contained in this notice, the name of Silicon Graphics, Inc.
  26  * shall not be used in advertising or otherwise to promote the sale, use or
  27  * other dealings in this Software without prior written authorization from
  28  * Silicon Graphics, Inc.
  29  */
  30
  31 /*
  32  * (C) Copyright IBM Corporation 2005
  33  * All Rights Reserved.
  34  *
  35  * Permission is hereby granted, free of charge, to any person obtaining a
  36  * copy of this software and associated documentation files (the "Software"),
  37  * to deal in the Software without restriction, including without limitation
  38  * the rights to use, copy, modify, merge, publish, distribute, sub license,
  39  * and/or sell copies of the Software, and to permit persons to whom the
  40  * Software is furnished to do so, subject to the following conditions:
  41  *
  42  * The above copyright notice and this permission notice (including the next
  43  * paragraph) shall be included in all copies or substantial portions of the
  44  * Software.
  45  *
  46  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  47  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  48  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
  49  * IBM,
  50  * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  51  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
  52  * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  53  * SOFTWARE.
  54  */
  55
  56 #include "packrender.h"
  57 #include "indirect.h"
  58
  59 /**
  60  * Send a large image to the server.  If necessary, a buffer is allocated
  61  * to hold the unpacked data that is copied from the clients memory.
  62  *
  63  * \param gc        Current GLX context
  64  * \param compsize  Size, in bytes, of the image portion
  65  * \param dim       Number of dimensions of the image
  66  * \param width     Width of the image
  67  * \param height    Height of the image, must be 1 for 1D images
  68  * \param depth     Depth of the image, must be 1 for 1D or 2D images
  69  * \param format    Format of the image
  70  * \param type      Data type of the image
  71  * \param src       Pointer to the image data
  72  * \param pc        Pointer to end of the command header
  73  * \param modes     Pointer to the pixel unpack data
  74  *
  75  * \todo
  76  * Modify this function so that \c NULL images are sent using
  77  * \c __glXSendLargeChunk instead of __glXSendLargeCommand.  Doing this
  78  * will eliminate the need to allocate a buffer for that case.
  79  *
  80  * \bugs
  81  * The \c fastImageUnpack path, which is thankfully never used, is completely
  82  * broken.
  83  */
  84 void
  85 __glXSendLargeImage(struct glx_context * gc, GLint compsize, GLint dim,
  86                     GLint width, GLint height, GLint depth,
  87                     GLenum format, GLenum type, const GLvoid * src,
  88                     GLubyte * pc, GLubyte * modes)
  89 {
  90    if (!gc->fastImageUnpack || (src == NULL)) {
  91       /* Allocate a temporary holding buffer */
  92       GLubyte *buf = (GLubyte *) Xmalloc(compsize);
  93       if (!buf) {
  94          __glXSetError(gc, GL_OUT_OF_MEMORY);
  95          return;
  96       }
  97
  98       /* Apply pixel store unpack modes to copy data into buf */
  99       if (src != NULL) {
 100          (*gc->fillImage) (gc, dim, width, height, depth, format, type,
 101                            src, buf, modes);
 102       }
 103       else {
 104          if (dim < 3) {
 105             (void) memcpy(modes, __glXDefaultPixelStore + 4, 20);
 106          }
 107          else {
 108             (void) memcpy(modes, __glXDefaultPixelStore + 0, 36);
 109          }
 110       }
 111
 112       /* Send large command */
 113       __glXSendLargeCommand(gc, gc->pc, pc - gc->pc, buf, compsize);
 114
 115       /* Free buffer */
 116       Xfree((char *) buf);
 117    }
 118    else {
 119       /* Just send the data straight as is */
 120       __glXSendLargeCommand(gc, gc->pc, pc - gc->pc, pc, compsize);
 121    }
 122 }
 123
 124 /************************************************************************/
 125
 126 /**
 127  * Implement GLX protocol for \c glSeparableFilter2D.
 128  *
 129  * \bugs
 130  * The \c fastImageUnpack path, which is thankfully never used, is completely
 131  * broken.
 132  */
 133 void
 134 __indirect_glSeparableFilter2D(GLenum target, GLenum internalformat,
 135                                GLsizei width, GLsizei height, GLenum format,
 136                                GLenum type, const GLvoid * row,
 137                                const GLvoid * column)
 138 {
 139    __GLX_DECLARE_VARIABLES();
 140    GLuint compsize2, hdrlen, totalhdrlen, image1len, image2len;
 141
 142    __GLX_LOAD_VARIABLES();
 143    compsize = __glImageSize(width, 1, 1, format, type, 0);
 144    compsize2 = __glImageSize(height, 1, 1, format, type, 0);
 145    totalhdrlen = __GLX_PAD(__GLX_CONV_FILT_CMD_HDR_SIZE);
 146    hdrlen = __GLX_PAD(__GLX_CONV_FILT_HDR_SIZE);
 147    image1len = __GLX_PAD(compsize);
 148    image2len = __GLX_PAD(compsize2);
 149    cmdlen = totalhdrlen + image1len + image2len;
 150    if (!gc->currentDpy)
 151       return;
 152
 153    if (cmdlen <= gc->maxSmallRenderCommandSize) {
 154       /* Use GLXRender protocol to send small command */
 155       __GLX_BEGIN_VARIABLE_WITH_PIXEL(X_GLrop_SeparableFilter2D, cmdlen);
 156       __GLX_PUT_LONG(0, target);
 157       __GLX_PUT_LONG(4, internalformat);
 158       __GLX_PUT_LONG(8, width);
 159       __GLX_PUT_LONG(12, height);
 160       __GLX_PUT_LONG(16, format);
 161       __GLX_PUT_LONG(20, type);
 162       pc += hdrlen;
 163       if (compsize > 0) {
 164          (*gc->fillImage) (gc, 1, width, 1, 1, format, type,
 165                            row, pc, pixelHeaderPC);
 166          pc += image1len;
 167       }
 168       if (compsize2 > 0) {
 169          (*gc->fillImage) (gc, 1, height, 1, 1, format, type,
 170                            column, pc, NULL);
 171          pc += image2len;
 172       }
 173       if ((compsize == 0) && (compsize2 == 0)) {
 174          /* Setup default store modes */
 175          (void) memcpy(pixelHeaderPC, __glXDefaultPixelStore + 4, 20);
 176       }
 177       __GLX_END(0);
 178    }
 179    else {
 180       const GLint bufsize = image1len + image2len;
 181
 182       /* Use GLXRenderLarge protocol to send command */
 183       __GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL(X_GLrop_SeparableFilter2D,
 184                                             cmdlen + 4);
 185       __GLX_PUT_LONG(0, target);
 186       __GLX_PUT_LONG(4, internalformat);
 187       __GLX_PUT_LONG(8, width);
 188       __GLX_PUT_LONG(12, height);
 189       __GLX_PUT_LONG(16, format);
 190       __GLX_PUT_LONG(20, type);
 191       pc += hdrlen;
 192
 193       if (!gc->fastImageUnpack) {
 194          /* Allocate a temporary holding buffer */
 195          GLubyte *buf = (GLubyte *) Xmalloc(bufsize);
 196          if (!buf) {
 197             __glXSetError(gc, GL_OUT_OF_MEMORY);
 198             return;
 199          }
 200          (*gc->fillImage) (gc, 1, width, 1, 1, format, type, row, buf,
 201                            pixelHeaderPC);
 202
 203          (*gc->fillImage) (gc, 1, height, 1, 1, format, type, column,
 204                            buf + image1len, pixelHeaderPC);
 205
 206          /* Send large command */
 207          __glXSendLargeCommand(gc, gc->pc, (GLint) (pc - gc->pc), buf,
 208                                bufsize);
 209          /* Free buffer */
 210          Xfree((char *) buf);
 211       }
 212       else {
 213          /* Just send the data straight as is */
 214          __glXSendLargeCommand(gc, gc->pc, (GLint) (pc - gc->pc), pc,
 215                                bufsize);
 216       }
 217    }
 218 }