← Back to branch summary

~ubuntu-branches/ubuntu/quantal/mesa/quantal

« back to all changes in this revision

Viewing changes to src/glut/os2/glut_vidresize.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2007-02-21 12:44:07 UTC
  • mfrom: (1.2.1 upstream)
  • mto: This revision was merged to the branch mainline in revision 22.
  • Revision ID: james.westby@ubuntu.com-20070221124407-rgcacs32mycrtadl
Import upstream version 6.5.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/glut/os2/glut_vidresize.cpp
1
 
 
2
 
/* Copyright (c) Mark J. Kilgard, 1996. */
3
 
 
4
 
/* This program is freely distributable without licensing fees
5
 
   and is provided without guarantee or warrantee expressed or
6
 
   implied. This program is -not- in the public domain. */
7
 
 
8
 
#include <stdlib.h>
9
 
 
10
 
#ifdef __sgi
11
 
#include <dlfcn.h>
12
 
#endif
13
 
 
14
 
#include "glutint.h"
15
 
 
16
 
/* Grumble.  The IRIX 6.3 and early IRIX 6.4 OpenGL headers
17
 
   support the video resize extension, but failed to define
18
 
   GLX_SGIX_video_resize. */
19
 
#if 0
20
 
#ifdef GLX_SYNC_FRAME_SGIX
21
 
#define GLX_SGIX_video_resize 1
22
 
#endif
23
 
#endif
24
 
 
25
 
#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize)
26
 
static int canVideoResize = -1;
27
 
static int videoResizeChannel;
28
 
#else
29
 
static int canVideoResize = 0;
30
 
#endif
31
 
static int videoResizeInUse = 0;
32
 
static int dx = -1, dy = -1, dw = -1, dh = -1;
33
 
 
34
 
/* XXX Note that IRIX 6.2, 6.3, and some 6.4 versions have a
35
 
   bug where programs seg-fault when they attempt video
36
 
   resizing from an indirect OpenGL context (either local or
37
 
   over a network). */
38
 
 
39
 
#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize)
40
 
 
41
 
static volatile int errorCaught;
42
 
 
43
 
/* ARGSUSED */
44
 
static int
45
 
catchXSGIvcErrors(Display * dpy, XErrorEvent * event)
46
 
{
47
 
  errorCaught = 1;
48
 
  return 0;
49
 
}
50
 
#endif
51
 
 
52
 
/* CENTRY */
53
 
 
54
 
int GLUTAPIENTRY
55
 
glutVideoResizeGet(GLenum param)
56
 
{
57
 
#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize)
58
 
  if (canVideoResize < 0) {
59
 
    canVideoResize = __glutIsSupportedByGLX("GLX_SGIX_video_resize");
60
 
    if (canVideoResize) {
61
 
#if defined(__sgi) && __sgi
62
 
      /* This is a hack because IRIX 6.2, 6.3, and some 6.4
63
 
         versions were released with GLX_SGIX_video_resize
64
 
         being advertised by the X server though the video
65
 
         resize extension is not actually supported.  We try to
66
 
         determine if the libGL.so we are using actually has a
67
 
         video resize entrypoint before we try to use the
68
 
         feature. */
69
 
      void (*func) (void);
70
 
      void *glxDso = dlopen("libGL.so", RTLD_LAZY);
71
 
 
72
 
      func = (void (*)(void)) dlsym(glxDso, "glXQueryChannelDeltasSGIX");
73
 
      if (!func) {
74
 
        canVideoResize = 0;
75
 
      } else
76
 
#endif
77
 
      {
78
 
        char *channelString;
79
 
        int (*handler) (Display *, XErrorEvent *);
80
 
 
81
 
        channelString = getenv("GLUT_VIDEO_RESIZE_CHANNEL");
82
 
        videoResizeChannel = channelString ? atoi(channelString) : 0;
83
 
 
84
 
        /* Work around another annoying problem with SGI's
85
 
           GLX_SGIX_video_resize implementation.  Early IRIX
86
 
           6.4 OpenGL's advertise the extension and have the
87
 
           video resize API, but an XSGIvc X protocol errors
88
 
           result trying to use the API.  Set up an error
89
 
           handler to intercept what would otherwise be a fatal
90
 
           error.  If an error was recieved, do not report that
91
 
           video resize is possible. */
92
 
        handler = XSetErrorHandler(catchXSGIvcErrors);
93
 
 
94
 
        errorCaught = 0;
95
 
 
96
 
#if defined(GLX_GLXEXT_PROTOTYPES)
97
 
#endif
98
 
 
99
 
        __glut_glXQueryChannelDeltasSGIX(__glutDisplay, __glutScreen,
100
 
          videoResizeChannel, &dx, &dy, &dw, &dh);
101
 
 
102
 
        /* glXQueryChannelDeltasSGIX is an inherent X server
103
 
           round-trip so we know we will have gotten either the
104
 
           correct reply or and error by this time. */
105
 
        XSetErrorHandler(handler);
106
 
 
107
 
        /* Still yet another work around.  In IRIX 6.4 betas,
108
 
           glXQueryChannelDeltasSGIX will return as if it
109
 
           succeeded, but the values are filled with junk.
110
 
           Watch to make sure the delta variables really make
111
 
           sense. */
112
 
        if (errorCaught ||
113
 
          dx < 0 || dy < 0 || dw < 0 || dh < 0 ||
114
 
          dx > 2048 || dy > 2048 || dw > 2048 || dh > 2048) {
115
 
          canVideoResize = 0;
116
 
        }
117
 
      }
118
 
    }
119
 
  }
120
 
#endif /* GLX_SGIX_video_resize */
121
 
 
122
 
  switch (param) {
123
 
  case GLUT_VIDEO_RESIZE_POSSIBLE:
124
 
    return canVideoResize;
125
 
  case GLUT_VIDEO_RESIZE_IN_USE:
126
 
    return videoResizeInUse;
127
 
  case GLUT_VIDEO_RESIZE_X_DELTA:
128
 
    return dx;
129
 
  case GLUT_VIDEO_RESIZE_Y_DELTA:
130
 
    return dy;
131
 
  case GLUT_VIDEO_RESIZE_WIDTH_DELTA:
132
 
    return dw;
133
 
  case GLUT_VIDEO_RESIZE_HEIGHT_DELTA:
134
 
    return dh;
135
 
  case GLUT_VIDEO_RESIZE_X:
136
 
  case GLUT_VIDEO_RESIZE_Y:
137
 
  case GLUT_VIDEO_RESIZE_WIDTH:
138
 
  case GLUT_VIDEO_RESIZE_HEIGHT:
139
 
#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize)
140
 
    if (videoResizeInUse) {
141
 
      int x, y, width, height;
142
 
 
143
 
      __glut_glXQueryChannelRectSGIX(__glutDisplay, __glutScreen,
144
 
        videoResizeChannel, &x, &y, &width, &height);
145
 
      switch (param) {
146
 
      case GLUT_VIDEO_RESIZE_X:
147
 
        return x;
148
 
      case GLUT_VIDEO_RESIZE_Y:
149
 
        return y;
150
 
      case GLUT_VIDEO_RESIZE_WIDTH:
151
 
        return width;
152
 
      case GLUT_VIDEO_RESIZE_HEIGHT:
153
 
        return height;
154
 
      }
155
 
    }
156
 
#endif
157
 
    return -1;
158
 
  default:
159
 
    __glutWarning("invalid glutVideoResizeGet parameter: %d", param);
160
 
    return -1;
161
 
  }
162
 
}
163
 
 
164
 
void GLUTAPIENTRY
165
 
glutSetupVideoResizing(void)
166
 
{
167
 
#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize)
168
 
  if (glutVideoResizeGet(GLUT_VIDEO_RESIZE_POSSIBLE)) {
169
 
    __glut_glXBindChannelToWindowSGIX(__glutDisplay, __glutScreen,
170
 
      videoResizeChannel, __glutCurrentWindow->win);
171
 
    videoResizeInUse = 1;
172
 
  } else
173
 
#endif
174
 
    __glutFatalError("glutEstablishVideoResizing: video resizing not possible.\n");
175
 
}
176
 
 
177
 
void GLUTAPIENTRY
178
 
glutStopVideoResizing(void)
179
 
{
180
 
#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize)
181
 
  if (glutVideoResizeGet(GLUT_VIDEO_RESIZE_POSSIBLE)) {
182
 
    if (videoResizeInUse) {
183
 
      __glut_glXBindChannelToWindowSGIX(__glutDisplay, __glutScreen,
184
 
        videoResizeChannel, None);
185
 
      videoResizeInUse = 0;
186
 
    }
187
 
  }
188
 
#endif
189
 
}
190
 
 
191
 
/* ARGSUSED */
192
 
void GLUTAPIENTRY
193
 
glutVideoResize(int x, int y, int width, int height)
194
 
{
195
 
#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize)
196
 
  if (videoResizeInUse) {
197
 
#ifdef GLX_SYNC_SWAP_SGIX
198
 
    /* glXChannelRectSyncSGIX introduced in a patch to IRIX
199
 
       6.2; the original unpatched IRIX 6.2 behavior is always
200
 
       GLX_SYNC_SWAP_SGIX. */
201
 
    __glut_glXChannelRectSyncSGIX(__glutDisplay, __glutScreen,
202
 
      videoResizeChannel, GLX_SYNC_SWAP_SGIX);
203
 
#endif
204
 
    __glut_glXChannelRectSGIX(__glutDisplay, __glutScreen,
205
 
      videoResizeChannel, x, y, width, height);
206
 
  }
207
 
#endif
208
 
}
209
 
 
210
 
/* ARGSUSED */
211
 
void GLUTAPIENTRY
212
 
glutVideoPan(int x, int y, int width, int height)
213
 
{
214
 
#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize)
215
 
  if (videoResizeInUse) {
216
 
#ifdef GLX_SYNC_FRAME_SGIX
217
 
    /* glXChannelRectSyncSGIX introduced in a patch to IRIX
218
 
       6.2; the original unpatched IRIX 6.2 behavior is always
219
 
       GLX_SYNC_SWAP_SGIX.  We just ignore that we cannot
220
 
       accomplish GLX_SYNC_FRAME_SGIX on IRIX unpatched 6.2;
221
 
       this means you'd need a glutSwapBuffers to actually
222
 
       realize the video resize. */
223
 
    __glut_glXChannelRectSyncSGIX(__glutDisplay, __glutScreen,
224
 
      videoResizeChannel, GLX_SYNC_FRAME_SGIX);
225
 
#endif
226
 
    __glut_glXChannelRectSGIX(__glutDisplay, __glutScreen,
227
 
      videoResizeChannel, x, y, width, height);
228
 
  }
229
 
#endif
230
 
}
231
 
 
232
 
/* ENDCENTRY */