1/*
2 Copyright (c) 2009 Apple Inc.
3
4 Permission is hereby granted, free of charge, to any person
5 obtaining a copy of this software and associated documentation files
6 (the "Software"), to deal in the Software without restriction,
7 including without limitation the rights to use, copy, modify, merge,
8 publish, distribute, sublicense, and/or sell copies of the Software,
9 and to permit persons to whom the Software is furnished to do so,
10 subject to the following conditions:
11
12 The above copyright notice and this permission notice shall be
13 included in all copies or substantial portions of the Software.
14
15 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
18 NONINFRINGEMENT.  IN NO EVENT SHALL THE ABOVE LISTED COPYRIGHT
19 HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
20 WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 DEALINGS IN THE SOFTWARE.
23
24 Except as contained in this notice, the name(s) of the above
25 copyright holders shall not be used in advertising or otherwise to
26 promote the sale, use or other dealings in this Software without
27 prior written authorization.
28*/
29
30#include <stdio.h>
31#include <stdlib.h>
32#include <pthread.h>
33#include <fcntl.h>
34#include <sys/types.h>
35#include <sys/mman.h>
36#include <unistd.h>
37#include <assert.h>
38#include "apple_glx.h"
39#include "apple_cgl.h"
40#include "apple_visual.h"
41#include "apple_glx_drawable.h"
42#include "appledri.h"
43#include "glxconfig.h"
44
45static bool pixmap_make_current(struct apple_glx_context *ac,
46                                struct apple_glx_drawable *d);
47
48static void pixmap_destroy(Display * dpy, struct apple_glx_drawable *d);
49
50static struct apple_glx_drawable_callbacks callbacks = {
51   .type = APPLE_GLX_DRAWABLE_PIXMAP,
52   .make_current = pixmap_make_current,
53   .destroy = pixmap_destroy
54};
55
56static bool
57pixmap_make_current(struct apple_glx_context *ac,
58                    struct apple_glx_drawable *d)
59{
60   CGLError cglerr;
61   struct apple_glx_pixmap *p = &d->types.pixmap;
62
63   assert(APPLE_GLX_DRAWABLE_PIXMAP == d->type);
64
65   cglerr = apple_cgl.set_current_context(p->context_obj);
66
67   if (kCGLNoError != cglerr) {
68      fprintf(stderr, "set current context: %s\n",
69              apple_cgl.error_string(cglerr));
70      return true;
71   }
72
73   cglerr = apple_cgl.set_off_screen(p->context_obj, p->width, p->height,
74                                     p->pitch, p->buffer);
75
76   if (kCGLNoError != cglerr) {
77      fprintf(stderr, "set off screen: %s\n", apple_cgl.error_string(cglerr));
78
79      return true;
80   }
81
82   if (!ac->made_current) {
83      apple_glapi_oglfw_viewport_scissor(0, 0, p->width, p->height);
84      ac->made_current = true;
85   }
86
87   return false;
88}
89
90static void
91pixmap_destroy(Display * dpy, struct apple_glx_drawable *d)
92{
93   struct apple_glx_pixmap *p = &d->types.pixmap;
94
95   if (p->pixel_format_obj)
96      (void) apple_cgl.destroy_pixel_format(p->pixel_format_obj);
97
98   if (p->context_obj)
99      (void) apple_cgl.destroy_context(p->context_obj);
100
101   XAppleDRIDestroyPixmap(dpy, p->xpixmap);
102
103   if (p->buffer) {
104      if (munmap(p->buffer, p->size))
105         perror("munmap");
106
107      if (-1 == close(p->fd))
108         perror("close");
109
110      if (shm_unlink(p->path))
111         perror("shm_unlink");
112   }
113
114   apple_glx_diagnostic("destroyed pixmap buffer for: 0x%lx\n", d->drawable);
115}
116
117/* Return true if an error occurred. */
118bool
119apple_glx_pixmap_create(Display * dpy, int screen, Pixmap pixmap,
120                        const void *mode)
121{
122   struct apple_glx_drawable *d;
123   struct apple_glx_pixmap *p;
124   bool double_buffered;
125   bool uses_stereo;
126   CGLError error;
127   const struct glx_config *cmodes = mode;
128
129   if (apple_glx_drawable_create(dpy, screen, pixmap, &d, &callbacks))
130      return true;
131
132   /* d is locked and referenced at this point. */
133
134   p = &d->types.pixmap;
135
136   p->xpixmap = pixmap;
137   p->buffer = NULL;
138
139   if (!XAppleDRICreatePixmap(dpy, screen, pixmap,
140                              &p->width, &p->height, &p->pitch, &p->bpp,
141                              &p->size, p->path, PATH_MAX)) {
142      d->unlock(d);
143      d->destroy(d);
144      return true;
145   }
146
147   p->fd = shm_open(p->path, O_RDWR, 0);
148
149   if (p->fd < 0) {
150      perror("shm_open");
151      d->unlock(d);
152      d->destroy(d);
153      return true;
154   }
155
156   p->buffer = mmap(NULL, p->size, PROT_READ | PROT_WRITE,
157                    MAP_FILE | MAP_SHARED, p->fd, 0);
158
159   if (MAP_FAILED == p->buffer) {
160      perror("mmap");
161      d->unlock(d);
162      d->destroy(d);
163      return true;
164   }
165
166   apple_visual_create_pfobj(&p->pixel_format_obj, mode, &double_buffered,
167                             &uses_stereo, /*offscreen */ true);
168
169   error = apple_cgl.create_context(p->pixel_format_obj, NULL,
170                                    &p->context_obj);
171
172   if (kCGLNoError != error) {
173      d->unlock(d);
174      d->destroy(d);
175      return true;
176   }
177
178   p->fbconfigID = cmodes->fbconfigID;
179
180   d->unlock(d);
181
182   apple_glx_diagnostic("created: pixmap buffer for 0x%lx\n", d->drawable);
183
184   return false;
185}
186
187bool
188apple_glx_pixmap_query(GLXPixmap pixmap, int attr, unsigned int *value)
189{
190   struct apple_glx_drawable *d;
191   struct apple_glx_pixmap *p;
192   bool result = false;
193
194   d = apple_glx_drawable_find_by_type(pixmap, APPLE_GLX_DRAWABLE_PIXMAP,
195                                       APPLE_GLX_DRAWABLE_LOCK);
196
197   if (d) {
198      p = &d->types.pixmap;
199
200      switch (attr) {
201      case GLX_WIDTH:
202         *value = p->width;
203         result = true;
204         break;
205
206      case GLX_HEIGHT:
207         *value = p->height;
208         result = true;
209         break;
210
211      case GLX_FBCONFIG_ID:
212         *value = p->fbconfigID;
213         result = true;
214         break;
215      }
216
217      d->unlock(d);
218   }
219
220   return result;
221}
222
223/* Return true if the type is valid for pixmap. */
224bool
225apple_glx_pixmap_destroy(Display * dpy, GLXPixmap pixmap)
226{
227   return !apple_glx_drawable_destroy_by_type(dpy, pixmap,
228                                              APPLE_GLX_DRAWABLE_PIXMAP);
229}
230