commit 1e42a24

buffer: Move internal state to struct buffer

  1@@ -23,20 +23,20 @@
  2 
  3 #include "wld-private.h"
  4 
  5-void buffer_initialize(struct wld_buffer * buffer,
  6+void buffer_initialize(struct buffer * buffer,
  7                        const struct wld_buffer_impl * impl,
  8                        uint32_t width, uint32_t height,
  9                        uint32_t format, uint32_t pitch)
 10 {
 11-    *((const struct wld_buffer_impl **) &buffer->impl) = impl;
 12-    buffer->width = width;
 13-    buffer->height = height;
 14-    buffer->format = format;
 15-    buffer->pitch = pitch;
 16-    buffer->map.data = NULL;
 17-    buffer->map.count = 0;
 18+    *((const struct wld_buffer_impl **) &buffer->base.impl) = impl;
 19+    buffer->base.width = width;
 20+    buffer->base.height = height;
 21+    buffer->base.format = format;
 22+    buffer->base.pitch = pitch;
 23+    buffer->base.map = NULL;
 24+    buffer->map_references = 0;
 25     buffer->exporters = NULL;
 26-    pixman_region32_init_rect(&buffer->damage, 0, 0, width, height);
 27+    pixman_region32_init_rect(&buffer->base.damage, 0, 0, width, height);
 28 }
 29 
 30 EXPORT
 31@@ -48,37 +48,42 @@ void wld_exporter_initialize(struct wld_exporter * exporter,
 32 }
 33 
 34 EXPORT
 35-bool wld_map(struct wld_buffer * buffer)
 36+bool wld_map(struct wld_buffer * base)
 37 {
 38-    if (buffer->map.count == 0 && !buffer->impl->map(buffer))
 39+    struct buffer * buffer = (void *) base;
 40+
 41+    if (buffer->map_references == 0 && !buffer->base.impl->map(buffer))
 42         return false;
 43 
 44-    ++buffer->map.count;
 45+    ++buffer->map_references;
 46     return true;
 47 }
 48 
 49 EXPORT
 50-bool wld_unmap(struct wld_buffer * buffer)
 51+bool wld_unmap(struct wld_buffer * base)
 52 {
 53-    if (buffer->map.count == 0
 54-        || (buffer->map.count == 1 && !buffer->impl->unmap(buffer)))
 55+    struct buffer * buffer = (void *) base;
 56+
 57+    if (buffer->map_references == 0
 58+        || (buffer->map_references == 1 && !buffer->base.impl->unmap(buffer)))
 59     {
 60         return false;
 61     }
 62 
 63-    --buffer->map.count;
 64+    --buffer->map_references;
 65     return true;
 66 }
 67 
 68 EXPORT
 69-bool wld_export(struct wld_buffer * buffer,
 70+bool wld_export(struct wld_buffer * base,
 71                 uint32_t type, union wld_object * object)
 72 {
 73+    struct buffer * buffer = (void *) base;
 74     struct wld_exporter * exporter;
 75 
 76     for (exporter = buffer->exporters; exporter; exporter = exporter->next)
 77     {
 78-        if (exporter->impl->export(exporter, buffer, type, object))
 79+        if (exporter->impl->export(exporter, &buffer->base, type, object))
 80             return true;
 81     }
 82 
 83@@ -86,22 +91,25 @@ bool wld_export(struct wld_buffer * buffer,
 84 }
 85 
 86 EXPORT
 87-void wld_buffer_add_exporter(struct wld_buffer * buffer,
 88+void wld_buffer_add_exporter(struct wld_buffer * base,
 89                              struct wld_exporter * exporter)
 90 {
 91+    struct buffer * buffer = (void *) base;
 92+
 93     exporter->next = buffer->exporters;
 94     buffer->exporters = exporter;
 95 }
 96 
 97 EXPORT
 98-void wld_destroy_buffer(struct wld_buffer * buffer)
 99+void wld_destroy_buffer(struct wld_buffer * base)
100 {
101+    struct buffer * buffer = (void *) base;
102     struct wld_exporter * exporter, * next;
103 
104-    if (buffer->map.count > 0)
105-        wld_unmap(buffer);
106+    if (buffer->map_references > 0)
107+        buffer->base.impl->unmap(buffer);
108 
109-    pixman_region32_fini(&buffer->damage);
110+    pixman_region32_fini(&buffer->base.damage);
111 
112     for (exporter = buffer->exporters, next = exporter ? exporter->next : NULL;
113          exporter; exporter = next, next = exporter ? exporter->next : NULL)
114@@ -109,6 +117,6 @@ void wld_destroy_buffer(struct wld_buffer * buffer)
115         exporter->impl->destroy(exporter);
116     }
117 
118-    buffer->impl->destroy(buffer);
119+    buffer->base.impl->destroy(buffer);
120 }
121 

  1@@ -28,7 +28,7 @@ IMPL(buffered_surface, wld_surface)
  2 
  3 struct buffer_entry
  4 {
  5-    struct wld_buffer * buffer;
  6+    struct buffer * buffer;
  7     bool busy;
  8 };
  9 
 10@@ -75,15 +75,15 @@ pixman_region32_t * surface_damage(struct wld_surface * base,
 11                                    pixman_region32_t * new_damage)
 12 {
 13     struct buffered_surface * surface = buffered_surface(base);
 14-    struct wld_buffer * back_buffer;
 15+    struct buffer * back_buffer;
 16     unsigned index;
 17 
 18     if (pixman_region32_not_empty(new_damage))
 19     {
 20         for (index = 0; index < surface->entries_size; ++index)
 21         {
 22-            pixman_region32_union(&surface->entries[index].buffer->damage,
 23-                                  &surface->entries[index].buffer->damage,
 24+            pixman_region32_union(&surface->entries[index].buffer->base.damage,
 25+                                  &surface->entries[index].buffer->base.damage,
 26                                   new_damage);
 27         }
 28     }
 29@@ -91,10 +91,10 @@ pixman_region32_t * surface_damage(struct wld_surface * base,
 30     if (!(back_buffer = surface_back(base)))
 31         return NULL;
 32 
 33-    return &back_buffer->damage;
 34+    return &back_buffer->base.damage;
 35 }
 36 
 37-struct wld_buffer * surface_back(struct wld_surface * base)
 38+struct buffer * surface_back(struct wld_surface * base)
 39 {
 40     struct buffered_surface * surface = buffered_surface(base);
 41     unsigned index;
 42@@ -116,11 +116,11 @@ struct wld_buffer * surface_back(struct wld_surface * base)
 43     }
 44 
 45     /* If there are no free buffers, we need to allocate another one. */
 46-    struct wld_buffer * buffer;
 47+    struct buffer * buffer;
 48 
 49-    buffer = wld_create_buffer(surface->context,
 50-                               surface->width, surface->height,
 51-                               surface->format, surface->flags);
 52+    buffer = surface->context->impl->create_buffer
 53+        (surface->context, surface->width, surface->height,
 54+         surface->format, surface->flags);
 55 
 56     if (!buffer)
 57         goto error0;
 58@@ -149,27 +149,27 @@ struct wld_buffer * surface_back(struct wld_surface * base)
 59     return buffer;
 60 
 61   error1:
 62-    wld_destroy_buffer(buffer);
 63+    wld_destroy_buffer(&buffer->base);
 64   error0:
 65     return NULL;
 66 }
 67 
 68-struct wld_buffer * surface_take(struct wld_surface * base)
 69+struct buffer * surface_take(struct wld_surface * base)
 70 {
 71     struct buffered_surface * surface = buffered_surface(base);
 72-    struct wld_buffer * buffer;
 73+    struct buffer * buffer;
 74 
 75     if (!(buffer = surface_back(base)))
 76         return NULL;
 77 
 78     surface->back->busy = true;
 79     surface->back = NULL;
 80-    pixman_region32_clear(&buffer->damage);
 81+    pixman_region32_clear(&buffer->base.damage);
 82 
 83     return buffer;
 84 }
 85 
 86-bool surface_release(struct wld_surface * base, struct wld_buffer * buffer)
 87+bool surface_release(struct wld_surface * base, struct buffer * buffer)
 88 {
 89     struct buffered_surface * surface = buffered_surface(base);
 90     unsigned index;
 91@@ -189,7 +189,7 @@ bool surface_release(struct wld_surface * base, struct wld_buffer * buffer)
 92 bool surface_swap(struct wld_surface * base)
 93 {
 94     struct buffered_surface * surface = buffered_surface(base);
 95-    struct wld_buffer * buffer;
 96+    struct buffer * buffer;
 97 
 98     if (!surface->buffer_socket)
 99         return false;
100@@ -202,7 +202,7 @@ bool surface_swap(struct wld_surface * base)
101 
102     surface->back->busy = true;
103     surface->back = NULL;
104-    pixman_region32_clear(&buffer->damage);
105+    pixman_region32_clear(&buffer->base.damage);
106 
107     return true;
108 }
109@@ -216,7 +216,7 @@ void surface_destroy(struct wld_surface * base)
110         surface->buffer_socket->impl->destroy(surface->buffer_socket);
111 
112     for (index = 0; index < surface->entries_size; ++index)
113-        wld_destroy_buffer(surface->entries[index].buffer);
114+        wld_destroy_buffer(&surface->entries[index].buffer->base);
115 
116     free(surface->entries);
117     free(surface);

 1@@ -40,7 +40,8 @@ struct wld_buffer * wld_create_buffer(struct wld_context * context,
 2                                       uint32_t width, uint32_t height,
 3                                       uint32_t format, uint32_t flags)
 4 {
 5-    return context->impl->create_buffer(context, width, height, format, flags);
 6+    return &context->impl->create_buffer(context, width, height,
 7+                                         format, flags)->base;
 8 }
 9 
10 EXPORT
11@@ -49,8 +50,8 @@ struct wld_buffer * wld_import_buffer(struct wld_context * context,
12                                       uint32_t width, uint32_t height,
13                                       uint32_t format, uint32_t pitch)
14 {
15-    return context->impl->import_buffer(context, type, object,
16-                                        width, height, format, pitch);
17+    return &context->impl->import_buffer(context, type, object,
18+                                         width, height, format, pitch)->base;
19 }
20 
21 EXPORT

  1@@ -40,7 +40,7 @@ struct dumb_context
  2 
  3 struct dumb_buffer
  4 {
  5-    struct wld_buffer base;
  6+    struct buffer base;
  7     struct wld_exporter exporter;
  8     struct dumb_context * context;
  9     uint32_t handle;
 10@@ -79,10 +79,10 @@ struct wld_renderer * context_create_renderer(struct wld_context * context)
 11     return wld_create_renderer(wld_pixman_context);
 12 }
 13 
 14-static struct wld_buffer * new_buffer(struct dumb_context * context,
 15-                                      uint32_t width, uint32_t height,
 16-                                      uint32_t format, uint32_t handle,
 17-                                      unsigned long pitch)
 18+static struct buffer * new_buffer(struct dumb_context * context,
 19+                                  uint32_t width, uint32_t height,
 20+                                  uint32_t format, uint32_t handle,
 21+                                  unsigned long pitch)
 22 {
 23     struct dumb_buffer * buffer;
 24 
 25@@ -94,17 +94,17 @@ static struct wld_buffer * new_buffer(struct dumb_context * context,
 26     buffer->context = context;
 27     buffer->handle = handle;
 28     wld_exporter_initialize(&buffer->exporter, &wld_exporter_impl);
 29-    wld_buffer_add_exporter(&buffer->base, &buffer->exporter);
 30+    wld_buffer_add_exporter(&buffer->base.base, &buffer->exporter);
 31 
 32     return &buffer->base;
 33 }
 34 
 35-struct wld_buffer * context_create_buffer(struct wld_context * base,
 36-                                          uint32_t width, uint32_t height,
 37-                                          uint32_t format, uint32_t flags)
 38+struct buffer * context_create_buffer(struct wld_context * base,
 39+                                      uint32_t width, uint32_t height,
 40+                                      uint32_t format, uint32_t flags)
 41 {
 42     struct dumb_context * context = dumb_context(base);
 43-    struct wld_buffer * buffer;
 44+    struct buffer * buffer;
 45     struct drm_mode_create_dumb create_dumb = {
 46         .height = height, .width = width,
 47         .bpp = format_bytes_per_pixel(format) * 8,
 48@@ -133,11 +133,10 @@ struct wld_buffer * context_create_buffer(struct wld_context * base,
 49     return NULL;
 50 }
 51 
 52-struct wld_buffer * context_import_buffer(struct wld_context * base,
 53-                                          uint32_t type,
 54-                                          union wld_object object,
 55-                                          uint32_t width, uint32_t height,
 56-                                          uint32_t format, uint32_t pitch)
 57+struct buffer * context_import_buffer(struct wld_context * base,
 58+                                      uint32_t type, union wld_object object,
 59+                                      uint32_t width, uint32_t height,
 60+                                      uint32_t format, uint32_t pitch)
 61 {
 62     struct dumb_context * context = dumb_context(base);
 63     uint32_t handle;
 64@@ -174,9 +173,9 @@ void context_destroy(struct wld_context * base)
 65 
 66 /**** Buffer ****/
 67 
 68-bool buffer_map(struct wld_buffer * base)
 69+bool buffer_map(struct buffer * base)
 70 {
 71-    struct dumb_buffer * buffer = dumb_buffer(base);
 72+    struct dumb_buffer * buffer = dumb_buffer(&base->base);
 73     struct drm_mode_map_dumb map_dumb = { .handle = buffer->handle };
 74     void * data;
 75 
 76@@ -186,30 +185,34 @@ bool buffer_map(struct wld_buffer * base)
 77         return false;
 78     }
 79 
 80-    data = mmap(NULL, base->pitch * base->height, PROT_READ | PROT_WRITE,
 81-                MAP_SHARED, buffer->context->fd, map_dumb.offset);
 82+    data = mmap(NULL, buffer->base.base.pitch * buffer->base.base.height,
 83+                PROT_READ | PROT_WRITE, MAP_SHARED,
 84+                buffer->context->fd, map_dumb.offset);
 85 
 86     if (data == MAP_FAILED)
 87         return false;
 88 
 89-    buffer->base.map.data = data;
 90+    buffer->base.base.map = data;
 91 
 92     return true;
 93 }
 94 
 95-bool buffer_unmap(struct wld_buffer * buffer)
 96+bool buffer_unmap(struct buffer * buffer)
 97 {
 98-    if (munmap(buffer->map.data, buffer->pitch * buffer->height) == -1)
 99+    if (munmap(buffer->base.map,
100+               buffer->base.pitch * buffer->base.height) == -1)
101+    {
102         return false;
103+    }
104 
105-    buffer->map.data = NULL;
106+    buffer->base.map = NULL;
107 
108     return true;
109 }
110 
111-void buffer_destroy(struct wld_buffer * base)
112+void buffer_destroy(struct buffer * base)
113 {
114-    struct dumb_buffer * buffer = dumb_buffer(base);
115+    struct dumb_buffer * buffer = dumb_buffer(&base->base);
116     struct drm_mode_destroy_dumb destroy_dumb = {
117         .handle = buffer->handle
118     };

  1@@ -46,7 +46,7 @@ struct intel_renderer
  2 
  3 struct intel_buffer
  4 {
  5-    struct wld_buffer base;
  6+    struct buffer base;
  7     struct wld_exporter exporter;
  8     drm_intel_bo * bo;
  9 };
 10@@ -112,9 +112,9 @@ struct wld_renderer * context_create_renderer(struct wld_context * base)
 11     return NULL;
 12 }
 13 
 14-static struct wld_buffer * new_buffer(uint32_t width, uint32_t height,
 15-                                      uint32_t format, uint32_t pitch,
 16-                                      drm_intel_bo * bo)
 17+static struct buffer * new_buffer(uint32_t width, uint32_t height,
 18+                                  uint32_t format, uint32_t pitch,
 19+                                  drm_intel_bo * bo)
 20 {
 21     struct intel_buffer * buffer;
 22 
 23@@ -125,17 +125,17 @@ static struct wld_buffer * new_buffer(uint32_t width, uint32_t height,
 24                       width, height, format, pitch);
 25     buffer->bo = bo;
 26     wld_exporter_initialize(&buffer->exporter, &wld_exporter_impl);
 27-    wld_buffer_add_exporter(&buffer->base, &buffer->exporter);
 28+    wld_buffer_add_exporter(&buffer->base.base, &buffer->exporter);
 29 
 30     return &buffer->base;
 31 }
 32 
 33-struct wld_buffer * context_create_buffer(struct wld_context * base,
 34-                                          uint32_t width, uint32_t height,
 35-                                          uint32_t format, uint32_t flags)
 36+struct buffer * context_create_buffer(struct wld_context * base,
 37+                                      uint32_t width, uint32_t height,
 38+                                      uint32_t format, uint32_t flags)
 39 {
 40     struct intel_context * context = intel_context(base);
 41-    struct wld_buffer * buffer;
 42+    struct buffer * buffer;
 43     drm_intel_bo * bo;
 44     uint32_t tiling_mode = width >= 128 ? I915_TILING_X : I915_TILING_NONE;
 45     unsigned long pitch;
 46@@ -157,14 +157,13 @@ struct wld_buffer * context_create_buffer(struct wld_context * base,
 47     return NULL;
 48 }
 49 
 50-struct wld_buffer * context_import_buffer(struct wld_context * base,
 51-                                          uint32_t type,
 52-                                          union wld_object object,
 53-                                          uint32_t width, uint32_t height,
 54-                                          uint32_t format, uint32_t pitch)
 55+struct buffer * context_import_buffer(struct wld_context * base,
 56+                                      uint32_t type, union wld_object object,
 57+                                      uint32_t width, uint32_t height,
 58+                                      uint32_t format, uint32_t pitch)
 59 {
 60     struct intel_context * context = intel_context(base);
 61-    struct wld_buffer * buffer;
 62+    struct buffer * buffer;
 63     drm_intel_bo * bo;
 64 
 65     switch (type)
 66@@ -207,23 +206,22 @@ void context_destroy(struct wld_context * base)
 67 
 68 /**** Renderer ****/
 69 uint32_t renderer_capabilities(struct wld_renderer * renderer,
 70-                               struct wld_buffer * buffer)
 71+                               struct buffer * buffer)
 72 {
 73-    if (buffer->impl == &wld_buffer_impl)
 74+    if (buffer->base.impl == &wld_buffer_impl)
 75         return WLD_CAPABILITY_READ | WLD_CAPABILITY_WRITE;
 76 
 77     return 0;
 78 }
 79 
 80-bool renderer_set_target(struct wld_renderer * base,
 81-                         struct wld_buffer * buffer)
 82+bool renderer_set_target(struct wld_renderer * base, struct buffer * buffer)
 83 {
 84     struct intel_renderer * renderer = intel_renderer(base);
 85 
 86-    if (buffer && buffer->impl != &wld_buffer_impl)
 87+    if (buffer && buffer->base.impl != &wld_buffer_impl)
 88         return false;
 89 
 90-    renderer->target = buffer ? intel_buffer(buffer) : NULL;
 91+    renderer->target = buffer ? intel_buffer(&buffer->base) : NULL;
 92 
 93     return true;
 94 }
 95@@ -235,27 +233,27 @@ void renderer_fill_rectangle(struct wld_renderer * base, uint32_t color,
 96     struct intel_renderer * renderer = intel_renderer(base);
 97     struct intel_buffer * dst = renderer->target;
 98 
 99-    xy_color_blt(&renderer->batch, dst->bo, dst->base.pitch,
100+    xy_color_blt(&renderer->batch, dst->bo, dst->base.base.pitch,
101                  x, y, x + width, y + height, color);
102 }
103 
104 void renderer_copy_rectangle(struct wld_renderer * base,
105-                             struct wld_buffer * buffer_base,
106+                             struct buffer * buffer_base,
107                              int32_t dst_x, int32_t dst_y,
108                              int32_t src_x, int32_t src_y,
109                              uint32_t width, uint32_t height)
110 {
111     struct intel_renderer * renderer = intel_renderer(base);
112 
113-    if (buffer_base->impl != &wld_buffer_impl)
114+    if (buffer_base->base.impl != &wld_buffer_impl)
115         return;
116 
117-    struct intel_buffer * src = intel_buffer(buffer_base),
118+    struct intel_buffer * src = intel_buffer(&buffer_base->base),
119                         * dst = renderer->target;
120 
121     xy_src_copy_blt(&renderer->batch,
122-                    src->bo, src->base.pitch, src_x, src_y,
123-                    dst->bo, dst->base.pitch, dst_x, dst_y, width, height);
124+                    src->bo, src->base.base.pitch, src_x, src_y,
125+                    dst->bo, dst->base.base.pitch, dst_x, dst_y, width, height);
126 }
127 
128 void renderer_draw_text(struct wld_renderer * base,
129@@ -275,7 +273,7 @@ void renderer_draw_text(struct wld_renderer * base,
130     int32_t origin_x = x;
131 
132     xy_setup_blt(&renderer->batch, true, BLT_RASTER_OPERATION_SRC,
133-                 0, color, dst->bo, dst->base.pitch);
134+                 0, color, dst->bo, dst->base.base.pitch);
135 
136     while ((ret = FcUtf8ToUcs4((FcChar8 *) text, &c, length)) > 0 && c != '\0')
137     {
138@@ -313,7 +311,7 @@ void renderer_draw_text(struct wld_renderer * base,
139         {
140             intel_batch_flush(&renderer->batch);
141             xy_setup_blt(&renderer->batch, true, BLT_RASTER_OPERATION_SRC,
142-                         0, color, dst->bo, dst->base.pitch);
143+                         0, color, dst->bo, dst->base.base.pitch);
144             goto retry;
145         }
146 
147@@ -341,33 +339,33 @@ void renderer_destroy(struct wld_renderer * base)
148 }
149 
150 /**** Buffer ****/
151-bool buffer_map(struct wld_buffer * base)
152+bool buffer_map(struct buffer * base)
153 {
154-    struct intel_buffer * buffer = intel_buffer(base);
155+    struct intel_buffer * buffer = intel_buffer(&base->base);
156 
157     if (drm_intel_gem_bo_map_gtt(buffer->bo) != 0)
158         return false;
159 
160-    buffer->base.map.data = buffer->bo->virtual;
161+    buffer->base.base.map = buffer->bo->virtual;
162 
163     return true;
164 }
165 
166-bool buffer_unmap(struct wld_buffer * base)
167+bool buffer_unmap(struct buffer * base)
168 {
169-    struct intel_buffer * buffer = intel_buffer(base);
170+    struct intel_buffer * buffer = intel_buffer(&base->base);
171 
172     if (drm_intel_gem_bo_unmap_gtt(buffer->bo) != 0)
173         return false;
174 
175-    buffer->base.map.data = NULL;
176+    buffer->base.base.map = NULL;
177 
178     return true;
179 }
180 
181-void buffer_destroy(struct wld_buffer * base)
182+void buffer_destroy(struct buffer * base)
183 {
184-    struct intel_buffer * buffer = intel_buffer(base);
185+    struct intel_buffer * buffer = intel_buffer(&base->base);
186 
187     drm_intel_bo_unreference(buffer->bo);
188     free(buffer);

 1@@ -21,9 +21,9 @@
 2  * SOFTWARE.
 3  */
 4 
 5-static bool buffer_map(struct wld_buffer * drawable);
 6-static bool buffer_unmap(struct wld_buffer * drawable);
 7-static void buffer_destroy(struct wld_buffer * drawable);
 8+static bool buffer_map(struct buffer * drawable);
 9+static bool buffer_unmap(struct buffer * drawable);
10+static void buffer_destroy(struct buffer * drawable);
11 
12 static const struct wld_buffer_impl wld_buffer_impl = {
13     .map = &buffer_map,

 1@@ -23,10 +23,10 @@
 2 
 3 static struct wld_renderer * context_create_renderer
 4     (struct wld_context * context);
 5-static struct wld_buffer * context_create_buffer
 6+static struct buffer * context_create_buffer
 7     (struct wld_context * context,
 8      uint32_t width, uint32_t height, uint32_t format, uint32_t flags);
 9-static struct wld_buffer * context_import_buffer
10+static struct buffer * context_import_buffer
11     (struct wld_context * context, uint32_t type, union wld_object object,
12      uint32_t width, uint32_t height, uint32_t format, uint32_t pitch);
13 #ifdef CONTEXT_IMPLEMENTS_CREATE_SURFACE

 1@@ -22,14 +22,14 @@
 2  */
 3 
 4 static uint32_t renderer_capabilities(struct wld_renderer * renderer,
 5-                                      struct wld_buffer * buffer);
 6+                                      struct buffer * buffer);
 7 static bool renderer_set_target(struct wld_renderer * renderer,
 8-                                struct wld_buffer * buffer);
 9+                                struct buffer * buffer);
10 static void renderer_fill_rectangle(struct wld_renderer * renderer,
11                                     uint32_t color, int32_t x, int32_t y,
12                                     uint32_t width, uint32_t height);
13 static void renderer_copy_rectangle(struct wld_renderer * renderer,
14-                                    struct wld_buffer * buffer,
15+                                    struct buffer * buffer,
16                                     int32_t dst_x, int32_t dst_y,
17                                     int32_t src_x, int32_t src_y,
18                                     uint32_t width, uint32_t height);
19@@ -37,7 +37,7 @@ static void renderer_copy_rectangle(struct wld_renderer * renderer,
20 static void renderer_fill_region(struct wld_renderer * base, uint32_t color,
21                                  pixman_region32_t * region);
22 static void renderer_copy_region(struct wld_renderer * base,
23-                                 struct wld_buffer * buffer,
24+                                 struct buffer * buffer,
25                                  int32_t dst_x, int32_t dst_y,
26                                  pixman_region32_t * region);
27 #endif

 1@@ -23,10 +23,10 @@
 2 
 3 static pixman_region32_t * surface_damage(struct wld_surface * surface,
 4                                           pixman_region32_t * new_damage);
 5-static struct wld_buffer * surface_back(struct wld_surface * surface);
 6-static struct wld_buffer * surface_take(struct wld_surface * surface);
 7+static struct buffer * surface_back(struct wld_surface * surface);
 8+static struct buffer * surface_take(struct wld_surface * surface);
 9 static bool surface_release(struct wld_surface * surface,
10-                            struct wld_buffer * buffer);
11+                            struct buffer * buffer);
12 static bool surface_swap(struct wld_surface * surface);
13 static void surface_destroy(struct wld_surface * surface);
14 

  1@@ -64,7 +64,7 @@ struct nouveau_renderer
  2 
  3 struct nouveau_buffer
  4 {
  5-    struct wld_buffer base;
  6+    struct buffer base;
  7     struct wld_exporter exporter;
  8     struct nouveau_context * context;
  9     struct nouveau_bo * bo;
 10@@ -311,7 +311,7 @@ static struct nouveau_buffer * new_buffer(struct nouveau_context * context,
 11                         width, height, format, pitch);
 12     buffer->context = context;
 13     wld_exporter_initialize(&buffer->exporter, &wld_exporter_impl);
 14-    wld_buffer_add_exporter(&buffer->base, &buffer->exporter);
 15+    wld_buffer_add_exporter(&buffer->base.base, &buffer->exporter);
 16 
 17     return buffer;
 18 }
 19@@ -321,9 +321,9 @@ static inline uint32_t roundup(uint32_t value, uint32_t alignment)
 20     return (value + alignment - 1) & ~(alignment - 1);
 21 }
 22 
 23-struct wld_buffer * context_create_buffer(struct wld_context * base,
 24-                                          uint32_t width, uint32_t height,
 25-                                          uint32_t format, uint32_t flags)
 26+struct buffer * context_create_buffer(struct wld_context * base,
 27+                                      uint32_t width, uint32_t height,
 28+                                      uint32_t format, uint32_t flags)
 29 {
 30     struct nouveau_context * context = nouveau_context(base);
 31     struct nouveau_buffer * buffer;
 32@@ -362,9 +362,10 @@ struct wld_buffer * context_create_buffer(struct wld_context * base,
 33     return NULL;
 34 }
 35 
 36-struct wld_buffer * context_import_buffer
 37-    (struct wld_context * base, uint32_t type, union wld_object object,
 38-     uint32_t width, uint32_t height, uint32_t format, uint32_t pitch)
 39+struct buffer * context_import_buffer(struct wld_context * base,
 40+                                      uint32_t type, union wld_object object,
 41+                                      uint32_t width, uint32_t height,
 42+                                      uint32_t format, uint32_t pitch)
 43 {
 44     struct nouveau_context * context = (void *) base;
 45     struct nouveau_buffer * buffer;
 46@@ -410,23 +411,22 @@ void context_destroy(struct wld_context * base)
 47 
 48 /**** Renderer ****/
 49 uint32_t renderer_capabilities(struct wld_renderer * renderer,
 50-                               struct wld_buffer * buffer)
 51+                               struct buffer * buffer)
 52 {
 53-    if (buffer->impl == &wld_buffer_impl)
 54+    if (buffer->base.impl == &wld_buffer_impl)
 55         return WLD_CAPABILITY_READ | WLD_CAPABILITY_WRITE;
 56 
 57     return 0;
 58 }
 59 
 60-bool renderer_set_target(struct wld_renderer * base,
 61-                         struct wld_buffer * buffer)
 62+bool renderer_set_target(struct wld_renderer * base, struct buffer * buffer)
 63 {
 64     struct nouveau_renderer * renderer = nouveau_renderer(base);
 65 
 66-    if (buffer && buffer->impl != &wld_buffer_impl)
 67+    if (buffer && buffer->base.impl != &wld_buffer_impl)
 68         return false;
 69 
 70-    renderer->target = buffer ? nouveau_buffer(buffer) : NULL;
 71+    renderer->target = buffer ? nouveau_buffer(&buffer->base) : NULL;
 72 
 73     return true;
 74 }
 75@@ -448,11 +448,12 @@ static inline void nvc0_2d_use_buffer(struct nouveau_renderer * renderer,
 76     else
 77     {
 78         nvc0_2d_inline(renderer->pushbuf, format_method + 0x04, 1);
 79-        nvc0_2d(renderer->pushbuf, format_method + 0x14, 1, buffer->base.pitch);
 80+        nvc0_2d(renderer->pushbuf, format_method + 0x14, 1,
 81+                buffer->base.base.pitch);
 82     }
 83 
 84     nvc0_2d(renderer->pushbuf, format_method + 0x18, 4,
 85-            buffer->base.width, buffer->base.height,
 86+            buffer->base.base.width, buffer->base.base.height,
 87             buffer->bo->offset >> 32, buffer->bo->offset);
 88     nouveau_bufctx_refn(renderer->bufctx, 0, buffer->bo,
 89                         NOUVEAU_BO_VRAM | access);
 90@@ -469,7 +470,7 @@ void renderer_fill_rectangle(struct wld_renderer * base, uint32_t color,
 91     if (!ensure_space(renderer->pushbuf, 18))
 92         return;
 93 
 94-    format = nvc0_format(dst->base.format);
 95+    format = nvc0_format(dst->base.base.format);
 96 
 97     nouveau_bufctx_reset(renderer->bufctx, 0);
 98     nvc0_2d_use_buffer(renderer, dst, NV50_2D_DST_FORMAT, format);
 99@@ -485,25 +486,25 @@ void renderer_fill_rectangle(struct wld_renderer * base, uint32_t color,
100 }
101 
102 void renderer_copy_rectangle(struct wld_renderer * base,
103-                             struct wld_buffer * buffer_base,
104+                             struct buffer * buffer_base,
105                              int32_t dst_x, int32_t dst_y,
106                              int32_t src_x, int32_t src_y,
107                              uint32_t width, uint32_t height)
108 {
109     struct nouveau_renderer * renderer = nouveau_renderer(base);
110 
111-    if (buffer_base->impl != &wld_buffer_impl)
112+    if (buffer_base->base.impl != &wld_buffer_impl)
113         return;
114 
115-    struct nouveau_buffer * src = nouveau_buffer(buffer_base),
116+    struct nouveau_buffer * src = nouveau_buffer(&buffer_base->base),
117                           * dst = renderer->target;
118     uint32_t src_format, dst_format;
119 
120     if (!ensure_space(renderer->pushbuf, 33))
121         return;
122 
123-    src_format = nvc0_format(src->base.format);
124-    dst_format = nvc0_format(dst->base.format);
125+    src_format = nvc0_format(src->base.base.format);
126+    dst_format = nvc0_format(dst->base.base.format);
127 
128     nouveau_bufctx_reset(renderer->bufctx, 0);
129     nvc0_2d_use_buffer(renderer, src, NV50_2D_SRC_FORMAT, src_format);
130@@ -540,7 +541,7 @@ void renderer_draw_text(struct wld_renderer * base,
131     if (!ensure_space(renderer->pushbuf, 17))
132         return;
133 
134-    format = nvc0_format(dst->base.format);
135+    format = nvc0_format(dst->base.base.format);
136 
137     nouveau_bufctx_reset(renderer->bufctx, 0);
138     nvc0_2d_use_buffer(renderer, dst, NV50_2D_DST_FORMAT, format);
139@@ -616,9 +617,9 @@ void renderer_destroy(struct wld_renderer * base)
140 }
141 
142 /**** Buffer ****/
143-bool buffer_map(struct wld_buffer * base)
144+bool buffer_map(struct buffer * base)
145 {
146-    struct nouveau_buffer * buffer = nouveau_buffer(base);
147+    struct nouveau_buffer * buffer = nouveau_buffer(&base->base);
148 
149     /* If the buffer is tiled, it cannot be mapped into virtual memory in order
150      * to appear linear like intel can do with map_gtt. */
151@@ -631,27 +632,27 @@ bool buffer_map(struct wld_buffer * base)
152         return false;
153     }
154 
155-    base->map.data = buffer->bo->map;
156+    buffer->base.base.map = buffer->bo->map;
157 
158     return true;
159 }
160 
161-bool buffer_unmap(struct wld_buffer * base)
162+bool buffer_unmap(struct buffer * base)
163 {
164-    struct nouveau_buffer * buffer = nouveau_buffer(base);
165+    struct nouveau_buffer * buffer = nouveau_buffer(&base->base);
166 
167     if (munmap(buffer->bo->map, buffer->bo->size) == -1)
168         return false;
169 
170     buffer->bo->map = NULL;
171-    base->map.data = NULL;
172+    base->base.map = NULL;
173 
174     return true;
175 }
176 
177-void buffer_destroy(struct wld_buffer * base)
178+void buffer_destroy(struct buffer * base)
179 {
180-    struct nouveau_buffer * buffer = (void *) base;
181+    struct nouveau_buffer * buffer = nouveau_buffer(&base->base);
182 
183     nouveau_bo_ref(NULL, &buffer->bo);
184     free(buffer);

  1@@ -40,7 +40,7 @@ struct pixman_renderer
  2 
  3 struct pixman_buffer
  4 {
  5-    struct wld_buffer base;
  6+    struct buffer base;
  7     pixman_image_t * image;
  8 };
  9 
 10@@ -85,7 +85,7 @@ struct wld_renderer * context_create_renderer(struct wld_context * context)
 11     return NULL;
 12 }
 13 
 14-static struct wld_buffer * new_buffer(pixman_image_t * image)
 15+static struct buffer * new_buffer(pixman_image_t * image)
 16 {
 17     struct pixman_buffer * buffer;
 18 
 19@@ -97,17 +97,17 @@ static struct wld_buffer * new_buffer(pixman_image_t * image)
 20                       pixman_image_get_height(image),
 21                       format_pixman_to_wld(pixman_image_get_format(image)),
 22                       pixman_image_get_stride(image));
 23-    buffer->base.map.data = pixman_image_get_data(image);
 24+    buffer->base.base.map = pixman_image_get_data(image);
 25     buffer->image = image;
 26 
 27     return &buffer->base;
 28 }
 29 
 30-struct wld_buffer * context_create_buffer(struct wld_context * context,
 31-                                          uint32_t width, uint32_t height,
 32-                                          uint32_t format, uint32_t flags)
 33+struct buffer * context_create_buffer(struct wld_context * context,
 34+                                      uint32_t width, uint32_t height,
 35+                                      uint32_t format, uint32_t flags)
 36 {
 37-    struct wld_buffer * buffer;
 38+    struct buffer * buffer;
 39     pixman_image_t * image;
 40 
 41     image = pixman_image_create_bits(format_wld_to_pixman(format),
 42@@ -127,13 +127,12 @@ struct wld_buffer * context_create_buffer(struct wld_context * context,
 43     return NULL;
 44 }
 45 
 46-struct wld_buffer * context_import_buffer(struct wld_context * context,
 47-                                          uint32_t type,
 48-                                          union wld_object object,
 49-                                          uint32_t width, uint32_t height,
 50-                                          uint32_t format, uint32_t pitch)
 51+struct buffer * context_import_buffer(struct wld_context * context,
 52+                                      uint32_t type, union wld_object object,
 53+                                      uint32_t width, uint32_t height,
 54+                                      uint32_t format, uint32_t pitch)
 55 {
 56-    struct wld_buffer * buffer;
 57+    struct buffer * buffer;
 58     pixman_image_t * image;
 59 
 60     switch (type)
 61@@ -165,7 +164,7 @@ void context_destroy(struct wld_context * context)
 62 }
 63 
 64 uint32_t renderer_capabilities(struct wld_renderer * renderer,
 65-                               struct wld_buffer * buffer)
 66+                               struct buffer * buffer)
 67 {
 68     /* The pixman renderer can read and write to any buffer using it's map
 69      * implementation. */
 70@@ -174,30 +173,30 @@ uint32_t renderer_capabilities(struct wld_renderer * renderer,
 71 
 72 static void destroy_image(pixman_image_t * image, void * data)
 73 {
 74-    struct wld_buffer * buffer = data;
 75+    struct buffer * buffer = data;
 76 
 77-    wld_unmap(buffer);
 78+    wld_unmap(&buffer->base);
 79 }
 80 
 81-static pixman_image_t * pixman_image(struct wld_buffer * buffer)
 82+static pixman_image_t * pixman_image(struct buffer * buffer)
 83 {
 84-    if (buffer->impl == &wld_buffer_impl)
 85-        return pixman_image_ref(pixman_buffer(buffer)->image);
 86+    if (buffer->base.impl == &wld_buffer_impl)
 87+        return pixman_image_ref(pixman_buffer(&buffer->base)->image);
 88 
 89     union wld_object object;
 90 
 91-    if (wld_export(buffer, WLD_PIXMAN_OBJECT_IMAGE, &object))
 92+    if (wld_export(&buffer->base, WLD_PIXMAN_OBJECT_IMAGE, &object))
 93         return object.ptr;
 94 
 95     struct pixman_exporter * exporter;
 96     pixman_image_t * image;
 97 
 98-    if (!wld_map(buffer))
 99+    if (!wld_map(&buffer->base))
100         goto error0;
101 
102-    image = pixman_image_create_bits(format_wld_to_pixman(buffer->format),
103-                                     buffer->width, buffer->height,
104-                                     buffer->map.data, buffer->pitch);
105+    image = pixman_image_create_bits(format_wld_to_pixman(buffer->base.format),
106+                                     buffer->base.width, buffer->base.height,
107+                                     buffer->base.map, buffer->base.pitch);
108 
109     if (!image)
110         goto error1;
111@@ -207,7 +206,7 @@ static pixman_image_t * pixman_image(struct wld_buffer * buffer)
112 
113     wld_exporter_initialize(&exporter->base, &wld_exporter_impl);
114     exporter->image = image;
115-    wld_buffer_add_exporter(buffer, &exporter->base);
116+    wld_buffer_add_exporter(&buffer->base, &exporter->base);
117     pixman_image_set_destroy_function(image, &destroy_image, buffer);
118 
119     return pixman_image_ref(image);
120@@ -215,13 +214,12 @@ static pixman_image_t * pixman_image(struct wld_buffer * buffer)
121   error2:
122     pixman_image_unref(image);
123   error1:
124-    wld_unmap(buffer);
125+    wld_unmap(&buffer->base);
126   error0:
127     return NULL;
128 }
129 
130-bool renderer_set_target(struct wld_renderer * base,
131-                         struct wld_buffer * buffer)
132+bool renderer_set_target(struct wld_renderer * base, struct buffer * buffer)
133 {
134     struct pixman_renderer * renderer = pixman_renderer(base);
135 
136@@ -260,8 +258,7 @@ void renderer_fill_region(struct wld_renderer * base, uint32_t color,
137                             &pixman_color, num_boxes, boxes);
138 }
139 
140-void renderer_copy_rectangle(struct wld_renderer * base,
141-                             struct wld_buffer * buffer,
142+void renderer_copy_rectangle(struct wld_renderer * base, struct buffer * buffer,
143                              int32_t dst_x, int32_t dst_y,
144                              int32_t src_x, int32_t src_y,
145                              uint32_t width, uint32_t height)
146@@ -275,8 +272,7 @@ void renderer_copy_rectangle(struct wld_renderer * base,
147                              src_x, src_y, 0, 0, dst_x, dst_y, width, height);
148 }
149 
150-void renderer_copy_region(struct wld_renderer * base,
151-                          struct wld_buffer * buffer,
152+void renderer_copy_region(struct wld_renderer * base, struct buffer * buffer,
153                           int32_t dst_x, int32_t dst_y,
154                           pixman_region32_t * region)
155 {
156@@ -408,19 +404,19 @@ void renderer_destroy(struct wld_renderer * base)
157     free(renderer);
158 }
159 
160-bool buffer_map(struct wld_buffer * buffer)
161+bool buffer_map(struct buffer * buffer)
162 {
163     return true;
164 }
165 
166-bool buffer_unmap(struct wld_buffer * buffer)
167+bool buffer_unmap(struct buffer * buffer)
168 {
169     return true;
170 }
171 
172-void buffer_destroy(struct wld_buffer * base)
173+void buffer_destroy(struct buffer * base)
174 {
175-    struct pixman_buffer * buffer = pixman_buffer(base);
176+    struct pixman_buffer * buffer = pixman_buffer(&base->base);
177 
178     pixman_image_unref(buffer->image);
179     free(buffer);

 1@@ -39,8 +39,7 @@ void default_fill_region(struct wld_renderer * renderer, uint32_t color,
 2     }
 3 }
 4 
 5-void default_copy_region(struct wld_renderer * renderer,
 6-                         struct wld_buffer * buffer,
 7+void default_copy_region(struct wld_renderer * renderer, struct buffer * buffer,
 8                          int32_t dst_x, int32_t dst_y,
 9                          pixman_region32_t * region)
10 {
11@@ -76,14 +75,14 @@ EXPORT
12 uint32_t wld_capabilities(struct wld_renderer * renderer,
13                           struct wld_buffer * buffer)
14 {
15-    return renderer->impl->capabilities(renderer, buffer);
16+    return renderer->impl->capabilities(renderer, (struct buffer *) buffer);
17 }
18 
19 EXPORT
20 bool wld_set_target_buffer(struct wld_renderer * renderer,
21                            struct wld_buffer * buffer)
22 {
23-    if (!renderer->impl->set_target(renderer, buffer))
24+    if (!renderer->impl->set_target(renderer, (struct buffer *) buffer))
25         return false;
26 
27     renderer->target = buffer;
28@@ -95,12 +94,12 @@ EXPORT
29 bool wld_set_target_surface(struct wld_renderer * renderer,
30                             struct wld_surface * surface)
31 {
32-    struct wld_buffer * back_buffer;
33+    struct buffer * back_buffer;
34 
35     if (!(back_buffer = surface->impl->back(surface)))
36         return false;
37 
38-    return wld_set_target_buffer(renderer, back_buffer);
39+    return renderer->impl->set_target(renderer, back_buffer);
40 }
41 
42 EXPORT
43@@ -124,8 +123,8 @@ void wld_copy_rectangle(struct wld_renderer * renderer,
44                         int32_t src_x, int32_t src_y,
45                         uint32_t width, uint32_t height)
46 {
47-    renderer->impl->copy_rectangle(renderer, buffer, dst_x, dst_y, src_x, src_y,
48-                                   width, height);
49+    renderer->impl->copy_rectangle(renderer, (struct buffer *) buffer,
50+                                   dst_x, dst_y, src_x, src_y, width, height);
51 }
52 
53 EXPORT
54@@ -133,7 +132,8 @@ void wld_copy_region(struct wld_renderer * renderer,
55                      struct wld_buffer * buffer,
56                      int32_t dst_x, int32_t dst_y, pixman_region32_t * region)
57 {
58-    renderer->impl->copy_region(renderer, buffer, dst_x, dst_y, region);
59+    renderer->impl->copy_region(renderer, (struct buffer *) buffer,
60+                                dst_x, dst_y, region);
61 }
62 
63 EXPORT

 1@@ -46,14 +46,14 @@ pixman_region32_t * wld_surface_damage(struct wld_surface * surface,
 2 EXPORT
 3 struct wld_buffer * wld_surface_take(struct wld_surface * surface)
 4 {
 5-    return surface->impl->take(surface);
 6+    return &surface->impl->take(surface)->base;
 7 }
 8 
 9 EXPORT
10 void wld_surface_release(struct wld_surface * surface,
11                          struct wld_buffer * buffer)
12 {
13-    surface->impl->release(surface, buffer);
14+    surface->impl->release(surface, (struct buffer *) buffer);
15 }
16 
17 EXPORT

 1@@ -189,12 +189,12 @@ struct wld_renderer * context_create_renderer(struct wld_context * base)
 2     return wld_create_renderer(context->driver_context);
 3 }
 4 
 5-struct wld_buffer * context_create_buffer(struct wld_context * base,
 6-                                          uint32_t width, uint32_t height,
 7-                                          uint32_t format, uint32_t flags)
 8+struct buffer * context_create_buffer(struct wld_context * base,
 9+                                      uint32_t width, uint32_t height,
10+                                      uint32_t format, uint32_t flags)
11 {
12     struct drm_context * context = drm_context(base);
13-    struct wld_buffer * buffer;
14+    struct buffer * buffer;
15     struct wld_exporter * exporter;
16     union wld_object object;
17     struct wl_buffer * wl;
18@@ -202,17 +202,17 @@ struct wld_buffer * context_create_buffer(struct wld_context * base,
19     if (!wld_wayland_drm_has_format(base, format))
20         goto error0;
21 
22-    buffer = wld_create_buffer(context->driver_context, width, height,
23-                               format, flags);
24+    buffer = context->driver_context->impl->create_buffer
25+        (context->driver_context, width, height, format, flags);
26 
27     if (!buffer)
28         goto error0;
29 
30-    if (!wld_export(buffer, WLD_DRM_OBJECT_PRIME_FD, &object))
31+    if (!wld_export(&buffer->base, WLD_DRM_OBJECT_PRIME_FD, &object))
32         goto error1;
33 
34     wl = wl_drm_create_prime_buffer(context->wl, object.i, width, height,
35-                                    format, 0, buffer->pitch, 0, 0, 0, 0);
36+                                    format, 0, buffer->base.pitch, 0, 0, 0, 0);
37     close(object.i);
38 
39     if (!wl)
40@@ -221,23 +221,22 @@ struct wld_buffer * context_create_buffer(struct wld_context * base,
41     if (!(exporter = wayland_create_exporter(wl)))
42         goto error2;
43 
44-    wld_buffer_add_exporter(buffer, exporter);
45+    wld_buffer_add_exporter(&buffer->base, exporter);
46 
47     return buffer;
48 
49   error2:
50     wl_buffer_destroy(wl);
51   error1:
52-    wld_destroy_buffer(buffer);
53+    wld_destroy_buffer(&buffer->base);
54   error0:
55     return NULL;
56 }
57 
58-struct wld_buffer * context_import_buffer(struct wld_context * context,
59-                                          uint32_t type,
60-                                          union wld_object object,
61-                                          uint32_t width, uint32_t height,
62-                                          uint32_t format, uint32_t pitch)
63+struct buffer * context_import_buffer(struct wld_context * context,
64+                                      uint32_t type, union wld_object object,
65+                                      uint32_t width, uint32_t height,
66+                                      uint32_t format, uint32_t pitch)
67 {
68     return NULL;
69 }

 1@@ -46,7 +46,7 @@ struct shm_context
 2 
 3 struct shm_buffer
 4 {
 5-    struct wld_buffer base;
 6+    struct buffer base;
 7     int fd;
 8 };
 9 
10@@ -158,9 +158,9 @@ struct wld_renderer * context_create_renderer(struct wld_context * context)
11     return wld_create_renderer(wld_pixman_context);
12 }
13 
14-struct wld_buffer * context_create_buffer(struct wld_context * base,
15-                                          uint32_t width, uint32_t height,
16-                                          uint32_t format, uint32_t flags)
17+struct buffer * context_create_buffer(struct wld_context * base,
18+                                      uint32_t width, uint32_t height,
19+                                      uint32_t format, uint32_t flags)
20 {
21     struct shm_context * context = shm_context(base);
22     struct shm_buffer * buffer;
23@@ -201,7 +201,7 @@ struct wld_buffer * context_create_buffer(struct wld_context * base,
24     buffer_initialize(&buffer->base, &wld_buffer_impl,
25                       width, height, format, pitch);
26     buffer->fd = fd;
27-    wld_buffer_add_exporter(&buffer->base, exporter);
28+    wld_buffer_add_exporter(&buffer->base.base, exporter);
29 
30     return &buffer->base;
31 
32@@ -215,11 +215,10 @@ struct wld_buffer * context_create_buffer(struct wld_context * base,
33     return NULL;
34 }
35 
36-struct wld_buffer * context_import_buffer(struct wld_context * context,
37-                                          uint32_t type,
38-                                          union wld_object object,
39-                                          uint32_t width, uint32_t height,
40-                                          uint32_t format, uint32_t pitch)
41+struct buffer * context_import_buffer(struct wld_context * context,
42+                                      uint32_t type, union wld_object object,
43+                                      uint32_t width, uint32_t height,
44+                                      uint32_t format, uint32_t pitch)
45 {
46     return NULL;
47 }
48@@ -237,35 +236,38 @@ void context_destroy(struct wld_context * base)
49 
50 /**** Buffer ****/
51 
52-bool buffer_map(struct wld_buffer * base)
53+bool buffer_map(struct buffer * base)
54 {
55-    struct shm_buffer * buffer = shm_buffer(base);
56+    struct shm_buffer * buffer = shm_buffer(&base->base);
57     void * data;
58 
59-    data = mmap(NULL, base->pitch * base->height, PROT_READ | PROT_WRITE,
60-                MAP_SHARED, buffer->fd, 0);
61+    data = mmap(NULL, buffer->base.base.pitch * buffer->base.base.height,
62+                PROT_READ | PROT_WRITE, MAP_SHARED, buffer->fd, 0);
63 
64     if (data == MAP_FAILED)
65         return false;
66 
67-    buffer->base.map.data = data;
68+    buffer->base.base.map = data;
69 
70     return true;
71 }
72 
73-bool buffer_unmap(struct wld_buffer * buffer)
74+bool buffer_unmap(struct buffer * buffer)
75 {
76-    if (munmap(buffer->map.data, buffer->pitch * buffer->height) == -1)
77+    if (munmap(buffer->base.map,
78+               buffer->base.pitch * buffer->base.height) == -1)
79+    {
80         return false;
81+    }
82 
83-    buffer->map.data = NULL;
84+    buffer->base.map = NULL;
85 
86     return true;
87 }
88 
89-void buffer_destroy(struct wld_buffer * base)
90+void buffer_destroy(struct buffer * base)
91 {
92-    struct shm_buffer * buffer = shm_buffer(base);
93+    struct shm_buffer * buffer = shm_buffer(&base->base);
94 
95     close(buffer->fd);
96     free(buffer);

 1@@ -48,7 +48,7 @@ struct wayland_buffer_socket
 2 IMPL(wayland_exporter, wld_exporter)
 3 
 4 static bool buffer_socket_attach(struct wld_buffer_socket * socket,
 5-                                 struct wld_buffer * buffer);
 6+                                 struct buffer * buffer);
 7 static void buffer_socket_process(struct wld_buffer_socket * socket);
 8 static void buffer_socket_destroy(struct wld_buffer_socket * socket);
 9 
10@@ -241,13 +241,13 @@ void exporter_destroy(struct wld_exporter * base)
11 }
12 
13 bool buffer_socket_attach(struct wld_buffer_socket * base,
14-                          struct wld_buffer * buffer)
15+                          struct buffer * buffer)
16 {
17     struct wayland_buffer_socket * socket = wayland_buffer_socket(base);
18     struct wl_buffer * wl;
19     union wld_object object;
20 
21-    if (!wld_export(buffer, WLD_WAYLAND_OBJECT_BUFFER, &object))
22+    if (!wld_export(&buffer->base, WLD_WAYLAND_OBJECT_BUFFER, &object))
23         return false;
24 
25     wl = object.ptr;
26@@ -257,12 +257,12 @@ bool buffer_socket_attach(struct wld_buffer_socket * base,
27 
28     wl_surface_attach(socket->wl, wl, 0, 0);
29 
30-    if (pixman_region32_not_empty(&buffer->damage))
31+    if (pixman_region32_not_empty(&buffer->base.damage))
32     {
33         pixman_box32_t * box;
34         int num_boxes;
35 
36-        box = pixman_region32_rectangles(&buffer->damage, &num_boxes);
37+        box = pixman_region32_rectangles(&buffer->base.damage, &num_boxes);
38 
39         while (num_boxes--)
40         {

  1@@ -83,14 +83,13 @@ struct font
  2 struct wld_context_impl
  3 {
  4     struct wld_renderer * (* create_renderer)(struct wld_context * context);
  5-    struct wld_buffer * (* create_buffer)(struct wld_context * context,
  6-                                          uint32_t width, uint32_t height,
  7-                                          uint32_t format, uint32_t flags);
  8-    struct wld_buffer * (* import_buffer)(struct wld_context * context,
  9-                                          uint32_t type,
 10-                                          union wld_object object,
 11-                                          uint32_t width, uint32_t height,
 12-                                          uint32_t format, uint32_t pitch);
 13+    struct buffer * (* create_buffer)(struct wld_context * context,
 14+                                      uint32_t width, uint32_t height,
 15+                                      uint32_t format, uint32_t flags);
 16+    struct buffer * (* import_buffer)(struct wld_context * context,
 17+                                      uint32_t type, union wld_object object,
 18+                                      uint32_t width, uint32_t height,
 19+                                      uint32_t format, uint32_t pitch);
 20     struct wld_surface * (* create_surface)(struct wld_context * context,
 21                                             uint32_t width, uint32_t height,
 22                                             uint32_t format, uint32_t flags);
 23@@ -100,21 +99,18 @@ struct wld_context_impl
 24 struct wld_renderer_impl
 25 {
 26     uint32_t (* capabilities)(struct wld_renderer * renderer,
 27-                              struct wld_buffer * buffer);
 28-    bool (* set_target)(struct wld_renderer * renderer,
 29-                        struct wld_buffer * buffer);
 30+                              struct buffer * buffer);
 31+    bool (* set_target)(struct wld_renderer * renderer, struct buffer * buffer);
 32     void (* fill_rectangle)(struct wld_renderer * renderer,
 33                             uint32_t color, int32_t x, int32_t y,
 34                             uint32_t width, uint32_t height);
 35     void (* fill_region)(struct wld_renderer * renderer,
 36                          uint32_t color, pixman_region32_t * region);
 37-    void (* copy_rectangle)(struct wld_renderer * renderer,
 38-                            struct wld_buffer * src,
 39+    void (* copy_rectangle)(struct wld_renderer * renderer, struct buffer * src,
 40                             int32_t dst_x, int32_t dst_y,
 41                             int32_t src_x, int32_t src_y,
 42                             uint32_t width, uint32_t height);
 43-    void (* copy_region)(struct wld_renderer * renderer,
 44-                         struct wld_buffer * src,
 45+    void (* copy_region)(struct wld_renderer * renderer, struct buffer * src,
 46                          int32_t dst_x, int32_t dst_y,
 47                          pixman_region32_t * region);
 48     void (* draw_text)(struct wld_renderer * renderer,
 49@@ -125,20 +121,28 @@ struct wld_renderer_impl
 50     void (* destroy)(struct wld_renderer * renderer);
 51 };
 52 
 53+struct buffer
 54+{
 55+    struct wld_buffer base;
 56+
 57+    unsigned map_references;
 58+    struct wld_exporter * exporters;
 59+};
 60+
 61 struct wld_buffer_impl
 62 {
 63-    bool (* map)(struct wld_buffer * buffer);
 64-    bool (* unmap)(struct wld_buffer * buffer);
 65-    void (* destroy)(struct wld_buffer * buffer);
 66+    bool (* map)(struct buffer * buffer);
 67+    bool (* unmap)(struct buffer * buffer);
 68+    void (* destroy)(struct buffer * buffer);
 69 };
 70 
 71 struct wld_surface_impl
 72 {
 73     pixman_region32_t * (* damage)(struct wld_surface * surface,
 74                                    pixman_region32_t * damage);
 75-    struct wld_buffer * (* back)(struct wld_surface * surface);
 76-    struct wld_buffer * (* take)(struct wld_surface * surface);
 77-    bool (* release)(struct wld_surface * surface, struct wld_buffer * buffer);
 78+    struct buffer * (* back)(struct wld_surface * surface);
 79+    struct buffer * (* take)(struct wld_surface * surface);
 80+    bool (* release)(struct wld_surface * surface, struct buffer * buffer);
 81     bool (* swap)(struct wld_surface * surface);
 82     void (* destroy)(struct wld_surface * surface);
 83 };
 84@@ -150,8 +154,7 @@ struct wld_buffer_socket
 85 
 86 struct wld_buffer_socket_impl
 87 {
 88-    bool (* attach)(struct wld_buffer_socket * socket,
 89-                    struct wld_buffer * buffer);
 90+    bool (* attach)(struct wld_buffer_socket * socket, struct buffer * buffer);
 91     void (* process)(struct wld_buffer_socket * socket);
 92     void (* destroy)(struct wld_buffer_socket * socket);
 93 };
 94@@ -208,8 +211,7 @@ void default_fill_region(struct wld_renderer * renderer, uint32_t color,
 95 /**
 96  * This default copy_region method is implemented in terms of copy_rectangle.
 97  */
 98-void default_copy_region(struct wld_renderer * renderer,
 99-                         struct wld_buffer * buffer,
100+void default_copy_region(struct wld_renderer * renderer, struct buffer * buffer,
101                          int32_t dst_x, int32_t dst_y,
102                          pixman_region32_t * region);
103 
104@@ -228,7 +230,7 @@ void context_initialize(struct wld_context * context,
105 void renderer_initialize(struct wld_renderer * renderer,
106                          const struct wld_renderer_impl * impl);
107 
108-void buffer_initialize(struct wld_buffer * buffer,
109+void buffer_initialize(struct buffer * buffer,
110                        const struct wld_buffer_impl * impl,
111                        uint32_t width, uint32_t height,
112                        uint32_t format, uint32_t pitch);

 1@@ -178,14 +178,7 @@ struct wld_buffer
 2     uint32_t width, height, pitch;
 3     enum wld_format format;
 4     pixman_region32_t damage;
 5-
 6-    struct
 7-    {
 8-        void * data;
 9-        unsigned count;
10-    } map;
11-
12-    struct wld_exporter * exporters;
13+    void * map;
14 };
15 
16 bool wld_map(struct wld_buffer * buffer);