← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/wayland/oneiric

« back to all changes in this revision

Viewing changes to compositor/drm.c

  • Committer: Bazaar Package Importer
  • Author(s): Bryce Harrington
  • Date: 2011-02-23 18:13:23 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20110223181323-xm62w5zi2adkscxq
Tags: 0.1~git20110214.e4762a6a-0ubuntu1
https://launchpad.net/bugs/700986
* Update to new git snapshot from 2011-02-14 up to commit e4762a6a. (This
  is the most recent upstream commit that doesn't require moving to a
  newer version of mesa.)
  (LP: #700986)
* copyright: Update to match current codebase, and reformat to follow
  dep5 style.

Show diffs side-by-side

added added

removed removed

Lines of Context:
compositor/drm.c
35
35
                                     (struct wl_object *) compositor->wl_display,
36
36
                                     WL_DISPLAY_INVALID_OBJECT, 0);
37
37
        else
38
 
                wl_client_post_event(client, &drm->base, WL_DRM_AUTHENTICATED);
 
38
                wl_client_post_event(client, &drm->object,
 
39
                                     WL_DRM_AUTHENTICATED);
39
40
}
40
41
 
41
42
static void
42
43
destroy_buffer(struct wl_resource *resource, struct wl_client *client)
43
44
{
44
45
        struct wlsc_drm_buffer *buffer =
45
 
                container_of(resource, struct wlsc_drm_buffer, base.base);
 
46
                container_of(resource, struct wlsc_drm_buffer, buffer.resource);
46
47
        struct wlsc_compositor *compositor =
47
 
                (struct wlsc_compositor *) buffer->base.compositor;
 
48
                (struct wlsc_compositor *) buffer->buffer.compositor;
48
49
 
49
50
        eglDestroyImageKHR(compositor->display, buffer->image);
50
51
        free(buffer);
53
54
static void
54
55
buffer_destroy(struct wl_client *client, struct wl_buffer *buffer)
55
56
{
56
 
        wl_resource_destroy(&buffer->base, client);
 
57
        wl_resource_destroy(&buffer->resource, client);
57
58
}
58
59
 
59
60
const static struct wl_buffer_interface buffer_interface = {
69
70
 
70
71
        glBindTexture(GL_TEXTURE_2D, es->texture);
71
72
        glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, buffer->image);
72
 
        es->visual = buffer->base.visual;
 
73
        es->visual = buffer->buffer.visual;
73
74
}
74
75
 
75
76
static void
79
80
{
80
81
}
81
82
 
 
83
static struct wlsc_drm_buffer *
 
84
wlsc_drm_buffer_create_for_image(struct wlsc_compositor *compositor,
 
85
                                 EGLImageKHR *image,
 
86
                                 int32_t width, int32_t height,
 
87
                                 struct wl_visual *visual)
 
88
{
 
89
        struct wlsc_drm_buffer *buffer;
 
90
 
 
91
        buffer = malloc(sizeof *buffer);
 
92
        if (buffer == NULL)
 
93
                return NULL;
 
94
 
 
95
        buffer->buffer.compositor = &compositor->compositor;
 
96
        buffer->buffer.width = width;
 
97
        buffer->buffer.height = height;
 
98
        buffer->buffer.visual = visual;
 
99
        buffer->buffer.attach = drm_buffer_attach;
 
100
        buffer->buffer.damage = drm_buffer_damage;
 
101
        buffer->image = image;
 
102
 
 
103
        return buffer;
 
104
}
 
105
 
82
106
static void
83
107
drm_create_buffer(struct wl_client *client, struct wl_drm *drm_base,
84
108
                  uint32_t id, uint32_t name, int32_t width, int32_t height,
88
112
        struct wlsc_compositor *compositor =
89
113
                container_of(drm, struct wlsc_compositor, drm);
90
114
        struct wlsc_drm_buffer *buffer;
 
115
        EGLImageKHR image;
91
116
        EGLint attribs[] = {
92
117
                EGL_WIDTH,              0,
93
118
                EGL_HEIGHT,             0,
96
121
                EGL_NONE
97
122
        };
98
123
 
99
 
        if (visual != &compositor->argb_visual &&
100
 
            visual != &compositor->premultiplied_argb_visual &&
101
 
            visual != &compositor->rgb_visual) {
 
124
        if (visual->object.interface != &wl_visual_interface) {
102
125
                /* FIXME: Define a real exception event instead of
103
126
                 * abusing this one */
104
127
                wl_client_post_event(client,
108
131
                return;
109
132
        }
110
133
 
111
 
        buffer = malloc(sizeof *buffer);
112
 
        if (buffer == NULL) {
113
 
                wl_client_post_no_memory(client);
114
 
                return;
115
 
        }
116
 
 
117
134
        attribs[1] = width;
118
135
        attribs[3] = height;
119
136
        attribs[5] = stride / 4;
120
 
 
121
 
        buffer->base.compositor = &compositor->base;
122
 
        buffer->base.width = width;
123
 
        buffer->base.height = height;
124
 
        buffer->base.visual = visual;
125
 
        buffer->base.attach = drm_buffer_attach;
126
 
        buffer->base.damage = drm_buffer_damage;
127
 
        buffer->image = eglCreateImageKHR(compositor->display,
128
 
                                          compositor->context,
129
 
                                          EGL_DRM_BUFFER_MESA,
130
 
                                          (EGLClientBuffer) name, attribs);
131
 
        if (buffer->image == NULL) {
 
137
        image = eglCreateImageKHR(compositor->display,
 
138
                                  EGL_NO_CONTEXT,
 
139
                                  EGL_DRM_BUFFER_MESA,
 
140
                                  (EGLClientBuffer) name, attribs);
 
141
        if (image == NULL) {
132
142
                /* FIXME: Define a real exception event instead of
133
143
                 * abusing this one */
134
 
                free(buffer);
135
144
                wl_client_post_event(client,
136
145
                                     (struct wl_object *) compositor->wl_display,
137
146
                                     WL_DISPLAY_INVALID_OBJECT, 0);
139
148
                return;
140
149
        }
141
150
 
142
 
        buffer->base.base.base.id = id;
143
 
        buffer->base.base.base.interface = &wl_buffer_interface;
144
 
        buffer->base.base.base.implementation = (void (**)(void))
 
151
        buffer = wlsc_drm_buffer_create_for_image(compositor, image,
 
152
                                                  width, height, visual);
 
153
        if (buffer == NULL) {
 
154
                eglDestroyImageKHR(compositor->display, image);
 
155
                wl_client_post_no_memory(client);
 
156
                return;
 
157
        }
 
158
 
 
159
        buffer->buffer.resource.object.id = id;
 
160
        buffer->buffer.resource.object.interface = &wl_buffer_interface;
 
161
        buffer->buffer.resource.object.implementation = (void (**)(void))
145
162
                &buffer_interface;
146
163
 
147
 
        buffer->base.base.destroy = destroy_buffer;
 
164
        buffer->buffer.resource.destroy = destroy_buffer;
148
165
 
149
 
        wl_client_add_resource(client, &buffer->base.base);
 
166
        wl_client_add_resource(client, &buffer->buffer.resource);
150
167
}
151
168
 
152
169
const static struct wl_drm_interface drm_interface = {
157
174
static void
158
175
post_drm_device(struct wl_client *client, struct wl_object *global)
159
176
{
160
 
        struct wlsc_drm *drm = container_of(global, struct wlsc_drm, base);
 
177
        struct wlsc_drm *drm = container_of(global, struct wlsc_drm, object);
161
178
 
162
179
        wl_client_post_event(client, global, WL_DRM_DEVICE, drm->filename);
163
180
}
172
189
        if (drm->filename == NULL)
173
190
                return -1;
174
191
 
175
 
        drm->base.interface = &wl_drm_interface;
176
 
        drm->base.implementation = (void (**)(void)) &drm_interface;
177
 
        wl_display_add_object(ec->wl_display, &drm->base);
178
 
        wl_display_add_global(ec->wl_display, &drm->base, post_drm_device);
 
192
        drm->object.interface = &wl_drm_interface;
 
193
        drm->object.implementation = (void (**)(void)) &drm_interface;
 
194
        wl_display_add_object(ec->wl_display, &drm->object);
 
195
        wl_display_add_global(ec->wl_display, &drm->object, post_drm_device);
179
196
 
180
197
        return 0;
181
198
}
185
202
                       int width, int height, struct wl_visual *visual)
186
203
{
187
204
        struct wlsc_drm_buffer *buffer;
 
205
        EGLImageKHR image;
188
206
 
189
207
        EGLint image_attribs[] = {
190
208
                EGL_WIDTH,              0,
197
215
        image_attribs[1] = width;
198
216
        image_attribs[3] = height;
199
217
 
200
 
        buffer = malloc(sizeof *buffer);
201
 
        if (buffer == NULL)
202
 
                return NULL;
203
 
 
204
 
        buffer->image =
205
 
                eglCreateDRMImageMESA(ec->display, image_attribs);
206
 
        if (buffer->image == NULL) {
207
 
                free(buffer);
208
 
                return NULL;
209
 
        }
210
 
 
211
 
        buffer->base.visual = visual;
212
 
        buffer->base.width = width;
213
 
        buffer->base.height = height;
214
 
        buffer->base.attach = drm_buffer_attach;
215
 
        buffer->base.damage = drm_buffer_damage;
 
218
        image = eglCreateDRMImageMESA(ec->display, image_attribs);
 
219
        if (image == NULL)
 
220
                return NULL;
 
221
 
 
222
        buffer = wlsc_drm_buffer_create_for_image(ec, image,
 
223
                                                  width, height, visual);
216
224
 
217
225
        return buffer;
218
226
}