← Back to branch summary

~mmach/netext73/mesa-haswell

« back to all changes in this revision

Viewing changes to src/glx/pixelstore.c

  • Committer: mmach
  • Date: 2022-09-22 19:56:13 UTC
  • Revision ID: netbit73@gmail.com-20220922195613-wtik9mmy20tmor0i
2022-09-22 21:17:09

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/glx/pixelstore.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
 
#include "glxclient.h"
32
 
#include "indirect.h"
33
 
#include "util/rounding.h"
34
 
 
35
 
#if !defined(__GNUC__)
36
 
#  define __builtin_expect(x, y) x
37
 
#endif
38
 
 
39
 
/**
40
 
 * Send glPixelStore command to the server
41
 
 * 
42
 
 * \param gc     Current GLX context
43
 
 * \param sop    Either \c X_GLsop_PixelStoref or \c X_GLsop_PixelStorei
44
 
 * \param pname  Selector of which pixel parameter is to be set.
45
 
 * \param param  Value that \c pname is set to.
46
 
 *
47
 
 * \sa __indirect_glPixelStorei,  __indirect_glPixelStoref
48
 
 */
49
 
static void
50
 
send_PixelStore(struct glx_context * gc, unsigned sop, GLenum pname,
51
 
                const void *param)
52
 
{
53
 
   Display *const dpy = gc->currentDpy;
54
 
   const GLuint cmdlen = 8;
55
 
   if (__builtin_expect(dpy != NULL, 1)) {
56
 
      GLubyte const *pc = __glXSetupSingleRequest(gc, sop, cmdlen);
57
 
      (void) memcpy((void *) (pc + 0), (void *) (&pname), 4);
58
 
      (void) memcpy((void *) (pc + 4), param, 4);
59
 
      UnlockDisplay(dpy);
60
 
      SyncHandle();
61
 
   }
62
 
   return;
63
 
}
64
 
 
65
 
/*
66
 
** Specify parameters that control the storage format of pixel arrays.
67
 
*/
68
 
void
69
 
__indirect_glPixelStoref(GLenum pname, GLfloat param)
70
 
{
71
 
   struct glx_context *gc = __glXGetCurrentContext();
72
 
   __GLXattribute *state = gc->client_state_private;
73
 
   Display *dpy = gc->currentDpy;
74
 
   GLuint a;
75
 
 
76
 
   if (!dpy)
77
 
      return;
78
 
 
79
 
   switch (pname) {
80
 
   case GL_PACK_ROW_LENGTH:
81
 
      a = _mesa_lroundevenf(param);
82
 
      if (((GLint) a) < 0) {
83
 
         __glXSetError(gc, GL_INVALID_VALUE);
84
 
         return;
85
 
      }
86
 
      state->storePack.rowLength = a;
87
 
      break;
88
 
   case GL_PACK_IMAGE_HEIGHT:
89
 
      a = _mesa_lroundevenf(param);
90
 
      if (((GLint) a) < 0) {
91
 
         __glXSetError(gc, GL_INVALID_VALUE);
92
 
         return;
93
 
      }
94
 
      state->storePack.imageHeight = a;
95
 
      break;
96
 
   case GL_PACK_SKIP_ROWS:
97
 
      a = _mesa_lroundevenf(param);
98
 
      if (((GLint) a) < 0) {
99
 
         __glXSetError(gc, GL_INVALID_VALUE);
100
 
         return;
101
 
      }
102
 
      state->storePack.skipRows = a;
103
 
      break;
104
 
   case GL_PACK_SKIP_PIXELS:
105
 
      a = _mesa_lroundevenf(param);
106
 
      if (((GLint) a) < 0) {
107
 
         __glXSetError(gc, GL_INVALID_VALUE);
108
 
         return;
109
 
      }
110
 
      state->storePack.skipPixels = a;
111
 
      break;
112
 
   case GL_PACK_SKIP_IMAGES:
113
 
      a = _mesa_lroundevenf(param);
114
 
      if (((GLint) a) < 0) {
115
 
         __glXSetError(gc, GL_INVALID_VALUE);
116
 
         return;
117
 
      }
118
 
      state->storePack.skipImages = a;
119
 
      break;
120
 
   case GL_PACK_ALIGNMENT:
121
 
      a = _mesa_lroundevenf(param);
122
 
      switch (a) {
123
 
      case 1:
124
 
      case 2:
125
 
      case 4:
126
 
      case 8:
127
 
         state->storePack.alignment = a;
128
 
         break;
129
 
      default:
130
 
         __glXSetError(gc, GL_INVALID_VALUE);
131
 
         return;
132
 
      }
133
 
      break;
134
 
   case GL_PACK_SWAP_BYTES:
135
 
      state->storePack.swapEndian = (param != 0);
136
 
      break;
137
 
   case GL_PACK_LSB_FIRST:
138
 
      state->storePack.lsbFirst = (param != 0);
139
 
      break;
140
 
 
141
 
   case GL_UNPACK_ROW_LENGTH:
142
 
      a = _mesa_lroundevenf(param);
143
 
      if (((GLint) a) < 0) {
144
 
         __glXSetError(gc, GL_INVALID_VALUE);
145
 
         return;
146
 
      }
147
 
      state->storeUnpack.rowLength = a;
148
 
      break;
149
 
   case GL_UNPACK_IMAGE_HEIGHT:
150
 
      a = _mesa_lroundevenf(param);
151
 
      if (((GLint) a) < 0) {
152
 
         __glXSetError(gc, GL_INVALID_VALUE);
153
 
         return;
154
 
      }
155
 
      state->storeUnpack.imageHeight = a;
156
 
      break;
157
 
   case GL_UNPACK_SKIP_ROWS:
158
 
      a = _mesa_lroundevenf(param);
159
 
      if (((GLint) a) < 0) {
160
 
         __glXSetError(gc, GL_INVALID_VALUE);
161
 
         return;
162
 
      }
163
 
      state->storeUnpack.skipRows = a;
164
 
      break;
165
 
   case GL_UNPACK_SKIP_PIXELS:
166
 
      a = _mesa_lroundevenf(param);
167
 
      if (((GLint) a) < 0) {
168
 
         __glXSetError(gc, GL_INVALID_VALUE);
169
 
         return;
170
 
      }
171
 
      state->storeUnpack.skipPixels = a;
172
 
      break;
173
 
   case GL_UNPACK_SKIP_IMAGES:
174
 
      a = _mesa_lroundevenf(param);
175
 
      if (((GLint) a) < 0) {
176
 
         __glXSetError(gc, GL_INVALID_VALUE);
177
 
         return;
178
 
      }
179
 
      state->storeUnpack.skipImages = a;
180
 
      break;
181
 
   case GL_UNPACK_ALIGNMENT:
182
 
      a = _mesa_lroundevenf(param);
183
 
      switch (a) {
184
 
      case 1:
185
 
      case 2:
186
 
      case 4:
187
 
      case 8:
188
 
         state->storeUnpack.alignment = a;
189
 
         break;
190
 
      default:
191
 
         __glXSetError(gc, GL_INVALID_VALUE);
192
 
         return;
193
 
      }
194
 
      break;
195
 
   case GL_UNPACK_SWAP_BYTES:
196
 
      state->storeUnpack.swapEndian = (param != 0);
197
 
      break;
198
 
   case GL_UNPACK_LSB_FIRST:
199
 
      state->storeUnpack.lsbFirst = (param != 0);
200
 
      break;
201
 
 
202
 
      /* Group all of the pixel store modes that need to be sent to the
203
 
       * server here.  Care must be used to only send modes to the server that
204
 
       * won't affect the size of the data sent to or received from the
205
 
       * server.  GL_PACK_INVERT_MESA is safe in this respect, but other,
206
 
       * future modes may not be.
207
 
       */
208
 
   case GL_PACK_INVERT_MESA:
209
 
      send_PixelStore(gc, X_GLsop_PixelStoref, pname, &param);
210
 
      break;
211
 
 
212
 
   default:
213
 
      __glXSetError(gc, GL_INVALID_ENUM);
214
 
      break;
215
 
   }
216
 
}
217
 
 
218
 
void
219
 
__indirect_glPixelStorei(GLenum pname, GLint param)
220
 
{
221
 
   struct glx_context *gc = __glXGetCurrentContext();
222
 
   __GLXattribute *state = gc->client_state_private;
223
 
   Display *dpy = gc->currentDpy;
224
 
 
225
 
   if (!dpy)
226
 
      return;
227
 
 
228
 
   switch (pname) {
229
 
   case GL_PACK_ROW_LENGTH:
230
 
      if (param < 0) {
231
 
         __glXSetError(gc, GL_INVALID_VALUE);
232
 
         return;
233
 
      }
234
 
      state->storePack.rowLength = param;
235
 
      break;
236
 
   case GL_PACK_IMAGE_HEIGHT:
237
 
      if (param < 0) {
238
 
         __glXSetError(gc, GL_INVALID_VALUE);
239
 
         return;
240
 
      }
241
 
      state->storePack.imageHeight = param;
242
 
      break;
243
 
   case GL_PACK_SKIP_ROWS:
244
 
      if (param < 0) {
245
 
         __glXSetError(gc, GL_INVALID_VALUE);
246
 
         return;
247
 
      }
248
 
      state->storePack.skipRows = param;
249
 
      break;
250
 
   case GL_PACK_SKIP_PIXELS:
251
 
      if (param < 0) {
252
 
         __glXSetError(gc, GL_INVALID_VALUE);
253
 
         return;
254
 
      }
255
 
      state->storePack.skipPixels = param;
256
 
      break;
257
 
   case GL_PACK_SKIP_IMAGES:
258
 
      if (param < 0) {
259
 
         __glXSetError(gc, GL_INVALID_VALUE);
260
 
         return;
261
 
      }
262
 
      state->storePack.skipImages = param;
263
 
      break;
264
 
   case GL_PACK_ALIGNMENT:
265
 
      switch (param) {
266
 
      case 1:
267
 
      case 2:
268
 
      case 4:
269
 
      case 8:
270
 
         state->storePack.alignment = param;
271
 
         break;
272
 
      default:
273
 
         __glXSetError(gc, GL_INVALID_VALUE);
274
 
         return;
275
 
      }
276
 
      break;
277
 
   case GL_PACK_SWAP_BYTES:
278
 
      state->storePack.swapEndian = (param != 0);
279
 
      break;
280
 
   case GL_PACK_LSB_FIRST:
281
 
      state->storePack.lsbFirst = (param != 0);
282
 
      break;
283
 
 
284
 
   case GL_UNPACK_ROW_LENGTH:
285
 
      if (param < 0) {
286
 
         __glXSetError(gc, GL_INVALID_VALUE);
287
 
         return;
288
 
      }
289
 
      state->storeUnpack.rowLength = param;
290
 
      break;
291
 
   case GL_UNPACK_IMAGE_HEIGHT:
292
 
      if (param < 0) {
293
 
         __glXSetError(gc, GL_INVALID_VALUE);
294
 
         return;
295
 
      }
296
 
      state->storeUnpack.imageHeight = param;
297
 
      break;
298
 
   case GL_UNPACK_SKIP_ROWS:
299
 
      if (param < 0) {
300
 
         __glXSetError(gc, GL_INVALID_VALUE);
301
 
         return;
302
 
      }
303
 
      state->storeUnpack.skipRows = param;
304
 
      break;
305
 
   case GL_UNPACK_SKIP_PIXELS:
306
 
      if (param < 0) {
307
 
         __glXSetError(gc, GL_INVALID_VALUE);
308
 
         return;
309
 
      }
310
 
      state->storeUnpack.skipPixels = param;
311
 
      break;
312
 
   case GL_UNPACK_SKIP_IMAGES:
313
 
      if (param < 0) {
314
 
         __glXSetError(gc, GL_INVALID_VALUE);
315
 
         return;
316
 
      }
317
 
      state->storeUnpack.skipImages = param;
318
 
      break;
319
 
   case GL_UNPACK_ALIGNMENT:
320
 
      switch (param) {
321
 
      case 1:
322
 
      case 2:
323
 
      case 4:
324
 
      case 8:
325
 
         state->storeUnpack.alignment = param;
326
 
         break;
327
 
      default:
328
 
         __glXSetError(gc, GL_INVALID_VALUE);
329
 
         return;
330
 
      }
331
 
      break;
332
 
   case GL_UNPACK_SWAP_BYTES:
333
 
      state->storeUnpack.swapEndian = (param != 0);
334
 
      break;
335
 
   case GL_UNPACK_LSB_FIRST:
336
 
      state->storeUnpack.lsbFirst = (param != 0);
337
 
      break;
338
 
 
339
 
      /* Group all of the pixel store modes that need to be sent to the
340
 
       * server here.  Care must be used to only send modes to the server that
341
 
       * won't affect the size of the data sent to or received from the
342
 
       * server.  GL_PACK_INVERT_MESA is safe in this respect, but other,
343
 
       * future modes may not be.
344
 
       */
345
 
   case GL_PACK_INVERT_MESA:
346
 
      send_PixelStore(gc, X_GLsop_PixelStorei, pname, &param);
347
 
      break;
348
 
 
349
 
   default:
350
 
      __glXSetError(gc, GL_INVALID_ENUM);
351
 
      break;
352
 
   }
353
 
}