g/d/r: builds and links, now how do I get a libGL.so?

1 files changed, 171 insertions, 363 deletions

diff --git a/src/gallium/drivers/remote/tr_screen.c b/src/gallium/drivers/remote/tr_screen.c
index 4de287a55e..dfa49ba4af 100644
--- a/src/gallium/drivers/remote/tr_screen.c
+++ b/src/gallium/drivers/remote/tr_screen.c
@@ -88,7 +88,7 @@ remote_screen_get_vendor(struct pipe_screen *_screen)
 
 static int 
 remote_screen_get_param(struct pipe_screen *_screen, 
-                       int param) {
+                       enum pipe_cap param) {
 
   struct remote_screen* rscreen = (struct remote_screen*)_screen;
 
@@ -115,10 +115,17 @@ remote_screen_get_param(struct pipe_screen *_screen,
 
 }
 
+static int
+remote_screen_get_shader_param(struct pipe_screen *_screen, unsigned shader,
+                       enum pipe_shader_cap param)
+{
+   return 0;
+}
+
 
 static float 
 remote_screen_get_paramf(struct pipe_screen *_screen, 
-                        int param)
+                        enum pipe_cap param)
 {
 
   struct remote_screen* rscreen = (struct remote_screen*)_screen;
@@ -180,173 +187,6 @@ remote_screen_is_format_supported(struct pipe_screen *_screen,
 
 }
 
-#define minify(x) (((x >> 1) > 0) ? (x >> 1) : 1)
-
-static struct pipe_texture *
-remote_screen_texture_create(struct pipe_screen *_screen,
-                            const struct pipe_texture *templat)
-{
-   struct remote_screen *tr_scr = remote_screen(_screen);
-
-    ALLOC_OUT_MESSAGE(texture_create, message);
-    
-    uint32_t handle = get_fresh_texture_handle(_screen);
-    
-    DBG("Creating new texture, using handle %u\n", handle);
-    
-    message->base.opcode = REMREQ_TEXTURE_CREATE;
-    message->templat = *templat;
-    message->screen = tr_scr->remote_handle;
-    message->handle = handle;
-    
-    enqueue_message(message);
-
-    struct remote_texture* result = CALLOC_STRUCT(remote_texture);
-	
-    result->base = *templat; // Struct copy
-    result->base.screen = _screen;
-    result->base.refcount = 1;
-    result->handle = handle;
-
-    pf_get_block(result->base.format, &result->base.block);
-
-    // This bit heavily based off softpipe's texture allocation stuff
-
-    DBG("Texture create: %d levels, base dimension %dx%dx%d\n", result->base.last_level, result->base.width[0], result->base.height[0], result->base.depth[0]);
-
-    unsigned int width = result->base.width[0];
-    unsigned int height = result->base.height[0];
-    unsigned int depth = result->base.depth[0];
-
-    unsigned int buffer_size = 0;
-
-    for(unsigned int i = 0; i <= result->base.last_level; i++) {
-
-      result->base.width[i] = width;
-      result->base.height[i] = height;
-      result->base.depth[i] = depth;
-      result->base.nblocksx[i] = pf_get_nblocksx(&result->base.block, width);
-      result->base.nblocksy[i] = pf_get_nblocksy(&result->base.block, height);
-      result->level_offset[i] = buffer_size;
-      result->stride[i] = result->base.nblocksx[i] * result->base.block.size;
-
-      int plane_size = result->base.nblocksx[i] * result->base.nblocksy[i] * result->base.block.size;
-
-      buffer_size += (plane_size * ((result->base.target == PIPE_TEXTURE_CUBE) ? 6 : depth));
-
-      DBG("Level %d consists of %dx%d blocks; block size %d; %d planes\n", i, result->base.nblocksx[i], result->base.nblocksy[i],  result->base.block.size, (result->base.target == PIPE_TEXTURE_CUBE ? 6 : depth));
-
-      width = minify(width);
-      height = minify(height);
-      depth = minify(depth);
-
-    }
-
-    DBG("In total will allocate a buffer of size %d\n", buffer_size);
-
-    result->backing_buffer = create_anon_buffer(buffer_size);
-
-    if(!result->backing_buffer) {
-      free(result);
-      return 0;
-    }
-    else {
-      return &(result->base);
-    }
-
-}
-
-
-static struct pipe_texture *
-remote_screen_texture_blanket(struct pipe_screen *_screen,
-                             const struct pipe_texture *templat,
-                             const unsigned *ppitch,
-                             struct pipe_buffer *buffer)
-{
-
-  struct remote_screen *tr_scr = remote_screen(_screen);
-   
-  if(templat->target != PIPE_TEXTURE_2D ||
-     templat->last_level != 0 ||
-     templat->depth[0] != 1)
-    return NULL;
-
-  // All current Gallium drivers enforce this... and it seems as though
-  // there is no way to express how you want extra mip-levels or planes
-  // to be laid out in the buffer, so it's probably the only reasonable
-  // thing to do with this interface.
-
-    ALLOC_OUT_MESSAGE(texture_blanket, message);
-
-    uint32_t handle = get_fresh_texture_handle(_screen);
-
-    DBG("Blanket: created texture %u based on buffer %u\n", handle, BUFFER_HANDLE(buffer));
-    
-    message->base.opcode = REMREQ_TEXTURE_BLANKET;
-    message->templat = *templat;
-    message->screen = tr_scr->remote_handle;
-    message->pitch = *ppitch;
-    message->buffer = BUFFER_HANDLE(buffer);
-    message->handle = handle;
-    
-    enqueue_message(message);
-    
-    struct remote_texture* result = CALLOC_STRUCT(remote_texture);
-	
-    result->base = *templat; // Struct copy
-    result->base.screen = _screen;
-    result->base.refcount = 1;
-    result->handle = handle;
-
-    pf_get_block(result->base.format, &result->base.block);
-
-    // This bit heavily based off softpipe's texture allocation stuff
-
-    pipe_buffer_reference(_screen, &result->backing_buffer, buffer);
-    
-    return &(result->base);
-	
-}
-
-
-static void 
-remote_screen_texture_release(struct pipe_screen *_screen,
-                             struct pipe_texture **ptexture)
-{
-
-    if(*ptexture)
-	DBG("Texture release: had refcount %d\n", (*ptexture)->refcount);
-    else
-	DBG("Texture release called against null pointer\n");
-
-    if((*ptexture) && !(--((*ptexture)->refcount))) {
-    
-	DBG("Our local refcount reached zero; remote deref on texture %u\n", TEXTURE_HANDLE(*ptexture));
-    
-	ALLOC_OUT_MESSAGE(texture_release, message);
-
-	message->base.opcode = REMREQ_TEXTURE_RELEASE;
-	message->screen = SCREEN_HANDLE(_screen);
-	message->texture = TEXTURE_HANDLE(*ptexture);
-	
-	enqueue_message(message);
-
-	struct remote_texture* rtex = (struct remote_texture*)*ptexture;
-	if(rtex->backing_buffer) {
-	  pipe_buffer_reference(_screen, &rtex->backing_buffer, NULL);
-	}
-	else {
-	  debug_printf("!!! Freeing a texture with no backing buffer\n");
-	}
-
-	FREE(*ptexture);
-	
-    }
-    
-    *ptexture = NULL;
-
-}
-
 static int get_or_alloc_buffer_handle(struct remote_buffer* rbuf,
 				      struct pipe_screen* screen,
 				      uint32_t* handle) {
@@ -363,233 +203,127 @@ static int get_or_alloc_buffer_handle(struct remote_buffer* rbuf,
 
 }
 
-static struct pipe_surface *
-remote_screen_get_tex_surface(struct pipe_screen *_screen,
-                             struct pipe_texture *texture,
-                             unsigned face, unsigned level,
-                             unsigned zslice,
-                             unsigned usage)
+static void
+remote_screen_destroy(struct pipe_screen *_screen)
 {
+   struct remote_screen *tr_scr = remote_screen(_screen);
 
-    DBG("Get texture surface for texture %u\n", TEXTURE_HANDLE(texture));
-    DBG("Face %u, level %u, zslice %u, usage %x\n", face, level, zslice, usage);
-
-    struct remote_texture* rtex = (struct remote_texture*)texture;
-
-    uint32_t buffer_handle;
-    int new_name = get_or_alloc_buffer_handle((struct remote_buffer*)rtex->backing_buffer, _screen, &buffer_handle);
-    // Gives the buffer a name, if it hadn't one already
-
-    if(new_name)
-      DBG("Get tex surface: the buffer had no name\n");
-    else
-      DBG("Get tex surface: the buffer had a name already\n");
-
-    uint32_t surf_handle = get_fresh_surface_handle(_screen);
+   DBG("Destroying screen %u: closing connection\n", SCREEN_HANDLE(_screen));
 
-    DBG("Using handle %u for new surface\n", surf_handle);
-    DBG("Using handle %u for its related buffer\n", buffer_handle);
-    
-    ALLOC_OUT_MESSAGE(get_tex_surface, message);
-    
-    message->base.opcode = REMREQ_GET_TEX_SURFACE;
-    message->screen = SCREEN_HANDLE(_screen);
-    message->texture = TEXTURE_HANDLE(texture);
-    message->face = face;
-    message->level = level;
-    message->zslice = zslice;
-    message->usage = usage;
-    message->handle = surf_handle;
-    message->buffer_handle = new_name ? buffer_handle : 0;
-    // 0 here signifies that we already have a name for that buffer
-    // This is the *only* way for anonymous buffers to get a name
-
-    enqueue_message(message);
-    
-    struct remote_surface* result = CALLOC_STRUCT(remote_surface);
-
-    result->base.winsys = _screen->winsys;
-    result->base.texture = texture;
-    result->base.face = face;
-    result->base.level = level;
-    result->base.zslice = zslice;
-    result->base.format = texture->format;
-    result->base.clear_value = 0;
-    result->base.width = texture->width[level];
-    result->base.height = texture->height[level];
-    result->base.block = texture->block;
-    result->base.nblocksx = texture->nblocksx[level];
-    result->base.nblocksy = texture->nblocksy[level];
-    result->base.stride = rtex->stride[level];
-    result->base.offset = rtex->level_offset[level];
-
-    if(texture->target == PIPE_TEXTURE_CUBE || texture->target == PIPE_TEXTURE_3D) {
-      result->base.offset += ((texture->target == PIPE_TEXTURE_CUBE) ? face : zslice) * result->base.nblocksy * result->base.stride;
-    }
+   close(tr_scr->socketfd);
 
-    result->base.usage = usage;
+   FREE(tr_scr);
+}
 
-    // ...and one is used for communication between the various driver components without a callback :(
-    // In the current mesa-anything arrangment of state-tracker/pipe/winsys, the winsys calls into the Mesa ST
-    // to notify st_notify_swapbuffers_complete, which sets pipe status to UNDEFINED; it then gets set back to DEFINED
-    // by the next call to any drawing function (softpipe,) or upon a clear or get_tex_surface (i915).
-    
-    // For now I will always consider my surfaces to be defined, and since my winsys doesn't call notify_swapbuffers_complete,
-    // this won't be interfered with. Its only use seems to be deciding how to clear a surface, so this could easily be
-    // faked out at the remote side.
+static struct pipe_context *
+remote_screen_context_create(struct pipe_screen *_screen, void *priv)
+{
+   DBG("%s: unimplemented\n", __FUNCTION__);
+   return NULL;
+}
 
-    // At the remote, then, the winsys might well call notify_complete, but I don't do anything about it, meaning buffers will be
-    // DEFINED the first time the pipe chooses and stay that way. I might need to get the DEFINED/UNDEFINED cycle going on the remote,
-    // set UNDEFINED here so I get Clear() calls and not clear-with-quad, and then finally recreate the "with-quad?" logic in the remote
-    // state tracker depending on DEFINED'ness.
+static void
+remote_screen_flush_frontbuffer(struct pipe_screen *_screen,
+                               struct pipe_resource *_resource,
+                               unsigned level, unsigned layer,
+                               void *context_private)
+{
+   DBG("%s: unimplemented\n", __FUNCTION__);
+}
 
-    result->base.status = PIPE_SURFACE_STATUS_DEFINED;
 
-    // Not sure whether we or the remote are expected to fill this in: better safe than sorry.
-    result->base.refcount = 1;
+/********************************************************************
+ * texture
+ */
 
-    result->handle = surf_handle;
+static struct pipe_resource *
+remote_screen_resource_create(struct pipe_screen *_screen,
+                            const struct pipe_resource *templat)
+{
+   struct pipe_resource *result = NULL;
 
-    pipe_buffer_reference(_screen, &result->base.buffer, rtex->backing_buffer);
-    
-    return (&(result->base));
-    
+   DBG("%s: unimplemented\n", __FUNCTION__);
+   return result;
 }
 
-
-static void 
-remote_screen_tex_surface_release(struct pipe_screen *_screen,
-                                 struct pipe_surface **psurface)
+static struct pipe_resource *
+remote_screen_resource_from_handle(struct pipe_screen *_screen,
+                                 const struct pipe_resource *templ,
+                                 struct winsys_handle *handle)
 {
+   struct pipe_resource *result = NULL;
 
-    if(*psurface)
-	DBG("Texture surface release on %u: old refcount %d\n", SURFACE_HANDLE(*psurface), (*psurface)->refcount);
-    else
-	DBG("Texture surface release passed a null pointer\n");
-
-    if(*psurface && !(--((*psurface)->refcount))) {
-
-        if((*psurface)->buffer) {
-	    pipe_buffer_reference(_screen, &((*psurface)->buffer), NULL);
-	}
-	else {
-	    debug_printf("!!! tex_surface_release with no buffer\n");
-	}
-	
-	ALLOC_OUT_MESSAGE(tex_surface_release, message);
-	
-	message->base.opcode = REMREQ_TEX_SURFACE_RELEASE;
-	message->screen = SCREEN_HANDLE(_screen);
-	message->surface = SURFACE_HANDLE(*psurface);
-	
-	enqueue_message(message);
-	
-	FREE(*psurface);
-	
-    }
-    
-    *psurface = NULL;
+   DBG("%s: unimplemented\n", __FUNCTION__);
+   return result;
 }
 
-
-static void*
-remote_screen_surface_map(struct pipe_screen *_screen,
-                         struct pipe_surface *surface,
-                         unsigned flags)
+static boolean
+remote_screen_resource_get_handle(struct pipe_screen *_screen,
+                                struct pipe_resource *_resource,
+                                struct winsys_handle *handle)
 {
-
-    DBG("Map surface %u (flags: %x)\n", SURFACE_HANDLE(surface), flags);
-    DBG("(-->mapping buffer %u, with offset %u)\n", BUFFER_HANDLE(surface->buffer), surface->offset);
-
-    char* map = (char*)pipe_buffer_map(_screen, surface->buffer, flags);
-
-    return (void*)(map + surface->offset);
-	
+   DBG("%s: unimplemented\n", __FUNCTION__);
+   return false;
 }
 
-
-static void 
-remote_screen_surface_unmap(struct pipe_screen *_screen,
-                           struct pipe_surface *surface)
+static void
+remote_screen_resource_destroy(struct pipe_screen *_screen,
+			      struct pipe_resource *_resource)
 {
-
-  DBG("Unmap surface %u\n", SURFACE_HANDLE(surface));
-
-  pipe_buffer_unmap(_screen, surface->buffer);
-
+   DBG("%s: unimplemented\n", __FUNCTION__);
 }
 
+/********************************************************************
+ * buffer
+ */
 
-static void
-remote_screen_destroy(struct pipe_screen *_screen)
+static struct pipe_resource *
+remote_screen_user_buffer_create(struct pipe_screen *_screen,
+                                void *data,
+                                unsigned size,
+				unsigned usage)
 {
-   struct remote_screen *tr_scr = remote_screen(_screen);
+   DBG("%s: unimplemented\n", __FUNCTION__);
+   return NULL;
+}
 
-   DBG("Destroying screen %u: closing connection\n", SCREEN_HANDLE(_screen));
 
-   close(tr_scr->socketfd);
+/********************************************************************
+ * fence
+ */
 
-   FREE(tr_scr);
-}
 
-struct pipe_screen *
-remote_screen_create(struct pipe_winsys* winsys)
+static void
+remote_screen_fence_reference(struct pipe_screen *_screen,
+                             struct pipe_fence_handle **pdst,
+                             struct pipe_fence_handle *src)
 {
-   
-   struct remote_screen* tr_scr = CALLOC_STRUCT(remote_screen);
+   DBG("%s: unimplemented\n", __FUNCTION__);
+}
 
-   memset(tr_scr, 0, sizeof(struct remote_screen));
 
-   DBG("Creating new screen\n");
-   
-   if(!tr_scr) {
-      debug_printf("Alloc failed in remote_screen_create!\n");
-      return NULL;
-   }
-  
-   tr_scr->base.winsys = winsys;
-   tr_scr->base.destroy = remote_screen_destroy;
-   tr_scr->base.get_name = remote_screen_get_name;
-   tr_scr->base.get_vendor = remote_screen_get_vendor;
-   tr_scr->base.get_param = remote_screen_get_param;
-   tr_scr->base.get_shader_param = remote_screen_get_shader_param;
-   tr_scr->base.get_paramf = remote_screen_get_paramf;
-   tr_scr->base.is_format_supported = remote_screen_is_format_supported;
-   assert(screen->context_create);
-   tr_scr->base.context_create = remote_screen_context_create;
-   tr_scr->base.resource_create = remote_screen_resource_create;
-   tr_scr->base.resource_from_handle = remote_screen_resource_from_handle;
-   tr_scr->base.resource_get_handle = remote_screen_resource_get_handle;
-   tr_scr->base.resource_destroy = remote_screen_resource_destroy;
-   tr_scr->base.user_buffer_create = remote_screen_user_buffer_create;
-   tr_scr->base.fence_reference = remote_screen_fence_reference;
-   tr_scr->base.fence_signalled = remote_screen_fence_signalled;
-   tr_scr->base.fence_finish = remote_screen_fence_finish;
-   tr_scr->base.flush_frontbuffer = remote_screen_flush_frontbuffer;   
-   tr_scr->last_query_handle = 1;
-   tr_scr->last_blend_handle = 1;
-   tr_scr->last_dsa_handle = 1;
-   tr_scr->last_rast_handle = 1;
-   tr_scr->last_sampler_handle = 1;
-   tr_scr->last_fs_handle = 1;
-   tr_scr->last_vs_handle = 1;
-   tr_scr->last_texture_handle = 1;
-   tr_scr->last_surface_handle = 1;
-   tr_scr->last_buffer_handle = 1;
-   tr_scr->last_window_handle = 1;
+static boolean
+remote_screen_fence_signalled(struct pipe_screen *_screen,
+                             struct pipe_fence_handle *fence)
+{
+   DBG("%s: unimplemented\n", __FUNCTION__);
+   return false;
+}
 
-   // Check if the user requests wait analysis
-   
-   analyse_waits = 0;
 
-   char* analyse_waits_env = getenv("VG_ANALYSE_WAITS");
-   if(analyse_waits_env) {
-     if(analyse_waits_env[0] == '1') {
-       debug_printf("Enabled wait analysis\n");
-       analyse_waits = 1;
-     }
-   }
+static boolean
+remote_screen_fence_finish(struct pipe_screen *_screen,
+                          struct pipe_fence_handle *fence,
+                          uint64_t timeout)
+{
+   DBG("%s: unimplemented\n", __FUNCTION__);
+   return false;
+}
 
+#ifdef XEN_HOST
+// currently broken
+static void setup_xen_connection(struct remote_screen* tr_scr)
+{
    // Set up a Xen-IDC connection to describe graphics events to the host
 
    struct sockaddr_un sun;
@@ -743,9 +477,83 @@ remote_screen_create(struct pipe_winsys* winsys)
    }
 
    DBG("Successfully relayed that to the compositor\n");
+}
+#endif
+
+static void setup_virtio_connection(struct remote_screen* tr_scr)
+{
+   DBG("%s: unimplemented\n", __FUNCTION__);
+}
+
+static void setup_host_connection(struct remote_screen* tr_scr)
+{
+#ifdef XEN_HOST
+   setup_xen_connection(tr_scr);
+#else
+   setup_virtio_connection(tr_scr);
+#endif
+}
+
+struct pipe_screen *
+remote_screen_create(struct pipe_winsys* winsys)
+{
    
-   return &(tr_scr->base);
+   struct remote_screen* tr_scr = CALLOC_STRUCT(remote_screen);
+
+   memset(tr_scr, 0, sizeof(struct remote_screen));
+
+   DBG("Creating new screen\n");
+
+   if(!tr_scr) {
+      debug_printf("Alloc failed in remote_screen_create!\n");
+      return NULL;
+   }
+
+   tr_scr->base.winsys = winsys;
+   tr_scr->base.destroy = remote_screen_destroy;
+   tr_scr->base.get_name = remote_screen_get_name;
+   tr_scr->base.get_vendor = remote_screen_get_vendor;
+   tr_scr->base.get_param = remote_screen_get_param;
+   tr_scr->base.get_shader_param = remote_screen_get_shader_param;
+   tr_scr->base.get_paramf = remote_screen_get_paramf;
+   tr_scr->base.is_format_supported = remote_screen_is_format_supported;
+   tr_scr->base.context_create = remote_screen_context_create;
+   tr_scr->base.resource_create = remote_screen_resource_create;
+   tr_scr->base.resource_from_handle = remote_screen_resource_from_handle;
+   tr_scr->base.resource_get_handle = remote_screen_resource_get_handle;
+   tr_scr->base.resource_destroy = remote_screen_resource_destroy;
+   tr_scr->base.user_buffer_create = remote_screen_user_buffer_create;
+   tr_scr->base.fence_reference = remote_screen_fence_reference;
+   tr_scr->base.fence_signalled = remote_screen_fence_signalled;
+   tr_scr->base.fence_finish = remote_screen_fence_finish;
+   tr_scr->base.flush_frontbuffer = remote_screen_flush_frontbuffer;
+   tr_scr->last_query_handle = 1;
+   tr_scr->last_blend_handle = 1;
+   tr_scr->last_dsa_handle = 1;
+   tr_scr->last_rast_handle = 1;
+   tr_scr->last_sampler_handle = 1;
+   tr_scr->last_fs_handle = 1;
+   tr_scr->last_vs_handle = 1;
+   tr_scr->last_texture_handle = 1;
+   tr_scr->last_surface_handle = 1;
+   tr_scr->last_buffer_handle = 1;
+   tr_scr->last_window_handle = 1;
+
+   // Check if the user requests wait analysis
    
+   analyse_waits = 0;
+
+   char* analyse_waits_env = getenv("VG_ANALYSE_WAITS");
+   if(analyse_waits_env) {
+     if(analyse_waits_env[0] == '1') {
+       debug_printf("Enabled wait analysis\n");
+       analyse_waits = 1;
+     }
+   }
+
+   setup_host_connection(tr_scr);
+
+   return &(tr_scr->base);
 }
 
 int complete_screen_creation(struct remote_screen* screen) {