Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /**************************************************************************
  2.  *
  3.  * Copyright 2009 Younes Manton.
  4.  * All Rights Reserved.
  5.  *
  6.  * Permission is hereby granted, free of charge, to any person obtaining a
  7.  * copy of this software and associated documentation files (the
  8.  * "Software"), to deal in the Software without restriction, including
  9.  * without limitation the rights to use, copy, modify, merge, publish,
  10.  * distribute, sub license, and/or sell copies of the Software, and to
  11.  * permit persons to whom the Software is furnished to do so, subject to
  12.  * the following conditions:
  13.  *
  14.  * The above copyright notice and this permission notice (including the
  15.  * next paragraph) shall be included in all copies or substantial portions
  16.  * of the Software.
  17.  *
  18.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19.  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20.  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21.  * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
  22.  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23.  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24.  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25.  *
  26.  **************************************************************************/
  27.  
  28. /* directly referenced from target Makefile, because of X dependencies */
  29.  
  30. #include <sys/types.h>
  31. #include <sys/stat.h>
  32. #include <fcntl.h>
  33.  
  34. #include <X11/Xlib-xcb.h>
  35. #include <X11/extensions/dri2tokens.h>
  36. #include <xcb/dri2.h>
  37. #include <xf86drm.h>
  38. #include <errno.h>
  39.  
  40. #include "pipe/p_screen.h"
  41. #include "pipe/p_context.h"
  42. #include "pipe/p_state.h"
  43. #include "pipe-loader/pipe_loader.h"
  44. #include "state_tracker/drm_driver.h"
  45.  
  46. #include "util/u_memory.h"
  47. #include "util/u_hash.h"
  48. #include "util/u_hash_table.h"
  49. #include "util/u_inlines.h"
  50.  
  51. #include "vl/vl_compositor.h"
  52. #include "vl/vl_winsys.h"
  53.  
  54. struct vl_dri_screen
  55. {
  56.    struct vl_screen base;
  57.    xcb_connection_t *conn;
  58.    xcb_drawable_t drawable;
  59.  
  60.    unsigned width, height;
  61.  
  62.    bool current_buffer;
  63.    uint32_t buffer_names[2];
  64.    struct u_rect dirty_areas[2];
  65.  
  66.    bool flushed;
  67.    xcb_dri2_swap_buffers_cookie_t swap_cookie;
  68.    xcb_dri2_wait_sbc_cookie_t wait_cookie;
  69.    xcb_dri2_get_buffers_cookie_t buffers_cookie;
  70.  
  71.    int64_t last_ust, ns_frame, last_msc, next_msc;
  72. };
  73.  
  74. static const unsigned int attachments[1] = { XCB_DRI2_ATTACHMENT_BUFFER_BACK_LEFT };
  75.  
  76. static void
  77. vl_dri2_handle_stamps(struct vl_dri_screen* scrn,
  78.                       uint32_t ust_hi, uint32_t ust_lo,
  79.                       uint32_t msc_hi, uint32_t msc_lo)
  80. {
  81.    int64_t ust = ((((uint64_t)ust_hi) << 32) | ust_lo) * 1000;
  82.    int64_t msc = (((uint64_t)msc_hi) << 32) | msc_lo;
  83.  
  84.    if (scrn->last_ust && scrn->last_msc && (ust > scrn->last_ust) && (msc > scrn->last_msc))
  85.       scrn->ns_frame = (ust - scrn->last_ust) / (msc - scrn->last_msc);
  86.  
  87.    scrn->last_ust = ust;
  88.    scrn->last_msc = msc;
  89. }
  90.  
  91. static xcb_dri2_get_buffers_reply_t*
  92. vl_dri2_get_flush_reply(struct vl_dri_screen *scrn)
  93. {
  94.    xcb_dri2_wait_sbc_reply_t *wait_sbc_reply;
  95.  
  96.    assert(scrn);
  97.  
  98.    if (!scrn->flushed)
  99.       return NULL;
  100.  
  101.    scrn->flushed = false;
  102.  
  103.    free(xcb_dri2_swap_buffers_reply(scrn->conn, scrn->swap_cookie, NULL));
  104.  
  105.    wait_sbc_reply = xcb_dri2_wait_sbc_reply(scrn->conn, scrn->wait_cookie, NULL);
  106.    if (!wait_sbc_reply)
  107.       return NULL;
  108.    vl_dri2_handle_stamps(scrn, wait_sbc_reply->ust_hi, wait_sbc_reply->ust_lo,
  109.                          wait_sbc_reply->msc_hi, wait_sbc_reply->msc_lo);
  110.    free(wait_sbc_reply);
  111.  
  112.    return xcb_dri2_get_buffers_reply(scrn->conn, scrn->buffers_cookie, NULL);
  113. }
  114.  
  115. static void
  116. vl_dri2_flush_frontbuffer(struct pipe_screen *screen,
  117.                           struct pipe_resource *resource,
  118.                           unsigned level, unsigned layer,
  119.                           void *context_private, struct pipe_box *sub_box)
  120. {
  121.    struct vl_dri_screen *scrn = (struct vl_dri_screen*)context_private;
  122.    uint32_t msc_hi, msc_lo;
  123.  
  124.    assert(screen);
  125.    assert(resource);
  126.    assert(context_private);
  127.  
  128.    free(vl_dri2_get_flush_reply(scrn));
  129.  
  130.    msc_hi = scrn->next_msc >> 32;
  131.    msc_lo = scrn->next_msc & 0xFFFFFFFF;
  132.  
  133.    scrn->swap_cookie = xcb_dri2_swap_buffers_unchecked(scrn->conn, scrn->drawable, msc_hi, msc_lo, 0, 0, 0, 0);
  134.    scrn->wait_cookie = xcb_dri2_wait_sbc_unchecked(scrn->conn, scrn->drawable, 0, 0);
  135.    scrn->buffers_cookie = xcb_dri2_get_buffers_unchecked(scrn->conn, scrn->drawable, 1, 1, attachments);
  136.  
  137.    scrn->flushed = true;
  138.    scrn->current_buffer = !scrn->current_buffer;
  139. }
  140.  
  141. static void
  142. vl_dri2_destroy_drawable(struct vl_dri_screen *scrn)
  143. {
  144.    xcb_void_cookie_t destroy_cookie;
  145.    if (scrn->drawable) {
  146.       free(vl_dri2_get_flush_reply(scrn));
  147.       destroy_cookie = xcb_dri2_destroy_drawable_checked(scrn->conn, scrn->drawable);
  148.       /* ignore any error here, since the drawable can be destroyed long ago */
  149.       free(xcb_request_check(scrn->conn, destroy_cookie));
  150.    }
  151. }
  152.  
  153. static void
  154. vl_dri2_set_drawable(struct vl_dri_screen *scrn, Drawable drawable)
  155. {
  156.    assert(scrn);
  157.    assert(drawable);
  158.  
  159.    if (scrn->drawable == drawable)
  160.       return;
  161.  
  162.    vl_dri2_destroy_drawable(scrn);
  163.  
  164.    xcb_dri2_create_drawable(scrn->conn, drawable);
  165.    scrn->current_buffer = false;
  166.    vl_compositor_reset_dirty_area(&scrn->dirty_areas[0]);
  167.    vl_compositor_reset_dirty_area(&scrn->dirty_areas[1]);
  168.    scrn->drawable = drawable;
  169. }
  170.  
  171. struct pipe_resource*
  172. vl_screen_texture_from_drawable(struct vl_screen *vscreen, Drawable drawable)
  173. {
  174.    struct vl_dri_screen *scrn = (struct vl_dri_screen*)vscreen;
  175.  
  176.    struct winsys_handle dri2_handle;
  177.    struct pipe_resource template, *tex;
  178.  
  179.    xcb_dri2_get_buffers_reply_t *reply;
  180.    xcb_dri2_dri2_buffer_t *buffers, *back_left;
  181.  
  182.    unsigned i;
  183.  
  184.    assert(scrn);
  185.  
  186.    vl_dri2_set_drawable(scrn, drawable);
  187.    reply = vl_dri2_get_flush_reply(scrn);
  188.    if (!reply) {
  189.       xcb_dri2_get_buffers_cookie_t cookie;
  190.       cookie = xcb_dri2_get_buffers_unchecked(scrn->conn, drawable, 1, 1, attachments);
  191.       reply = xcb_dri2_get_buffers_reply(scrn->conn, cookie, NULL);
  192.    }
  193.    if (!reply)
  194.       return NULL;
  195.  
  196.    buffers = xcb_dri2_get_buffers_buffers(reply);
  197.    if (!buffers)  {
  198.       free(reply);
  199.       return NULL;
  200.    }
  201.  
  202.    for (i = 0; i < reply->count; ++i) {
  203.       if (buffers[i].attachment == XCB_DRI2_ATTACHMENT_BUFFER_BACK_LEFT) {
  204.          back_left = &buffers[i];
  205.          break;
  206.       }
  207.    }
  208.  
  209.    if (i == reply->count) {
  210.       free(reply);
  211.       return NULL;
  212.    }
  213.  
  214.    if (reply->width != scrn->width || reply->height != scrn->height) {
  215.       vl_compositor_reset_dirty_area(&scrn->dirty_areas[0]);
  216.       vl_compositor_reset_dirty_area(&scrn->dirty_areas[1]);
  217.       scrn->width = reply->width;
  218.       scrn->height = reply->height;
  219.  
  220.    } else if (back_left->name != scrn->buffer_names[scrn->current_buffer]) {
  221.       vl_compositor_reset_dirty_area(&scrn->dirty_areas[scrn->current_buffer]);
  222.       scrn->buffer_names[scrn->current_buffer] = back_left->name;
  223.    }
  224.  
  225.    memset(&dri2_handle, 0, sizeof(dri2_handle));
  226.    dri2_handle.type = DRM_API_HANDLE_TYPE_SHARED;
  227.    dri2_handle.handle = back_left->name;
  228.    dri2_handle.stride = back_left->pitch;
  229.  
  230.    memset(&template, 0, sizeof(template));
  231.    template.target = PIPE_TEXTURE_2D;
  232.    template.format = PIPE_FORMAT_B8G8R8X8_UNORM;
  233.    template.last_level = 0;
  234.    template.width0 = reply->width;
  235.    template.height0 = reply->height;
  236.    template.depth0 = 1;
  237.    template.array_size = 1;
  238.    template.usage = PIPE_USAGE_DEFAULT;
  239.    template.bind = PIPE_BIND_RENDER_TARGET;
  240.    template.flags = 0;
  241.  
  242.    tex = scrn->base.pscreen->resource_from_handle(scrn->base.pscreen, &template, &dri2_handle);
  243.    free(reply);
  244.  
  245.    return tex;
  246. }
  247.  
  248. struct u_rect *
  249. vl_screen_get_dirty_area(struct vl_screen *vscreen)
  250. {
  251.    struct vl_dri_screen *scrn = (struct vl_dri_screen*)vscreen;
  252.    assert(scrn);
  253.    return &scrn->dirty_areas[scrn->current_buffer];
  254. }
  255.  
  256. uint64_t
  257. vl_screen_get_timestamp(struct vl_screen *vscreen, Drawable drawable)
  258. {
  259.    struct vl_dri_screen *scrn = (struct vl_dri_screen*)vscreen;
  260.    xcb_dri2_get_msc_cookie_t cookie;
  261.    xcb_dri2_get_msc_reply_t *reply;
  262.  
  263.    assert(scrn);
  264.  
  265.    vl_dri2_set_drawable(scrn, drawable);
  266.    if (!scrn->last_ust) {
  267.       cookie = xcb_dri2_get_msc_unchecked(scrn->conn, drawable);
  268.       reply = xcb_dri2_get_msc_reply(scrn->conn, cookie, NULL);
  269.  
  270.       if (reply) {
  271.          vl_dri2_handle_stamps(scrn, reply->ust_hi, reply->ust_lo,
  272.                                reply->msc_hi, reply->msc_lo);
  273.          free(reply);
  274.       }
  275.    }
  276.    return scrn->last_ust;
  277. }
  278.  
  279. void
  280. vl_screen_set_next_timestamp(struct vl_screen *vscreen, uint64_t stamp)
  281. {
  282.    struct vl_dri_screen *scrn = (struct vl_dri_screen*)vscreen;
  283.    assert(scrn);
  284.    if (stamp && scrn->last_ust && scrn->ns_frame && scrn->last_msc)
  285.       scrn->next_msc = ((int64_t)stamp - scrn->last_ust + scrn->ns_frame/2) / scrn->ns_frame + scrn->last_msc;
  286.    else
  287.       scrn->next_msc = 0;
  288. }
  289.  
  290. void*
  291. vl_screen_get_private(struct vl_screen *vscreen)
  292. {
  293.    return vscreen;
  294. }
  295.  
  296. struct vl_screen*
  297. vl_screen_create(Display *display, int screen)
  298. {
  299.    struct vl_dri_screen *scrn;
  300.    const xcb_query_extension_reply_t *extension;
  301.    xcb_dri2_query_version_cookie_t dri2_query_cookie;
  302.    xcb_dri2_query_version_reply_t *dri2_query = NULL;
  303.    xcb_dri2_connect_cookie_t connect_cookie;
  304.    xcb_dri2_connect_reply_t *connect = NULL;
  305.    xcb_dri2_authenticate_cookie_t authenticate_cookie;
  306.    xcb_dri2_authenticate_reply_t *authenticate = NULL;
  307.    xcb_screen_iterator_t s;
  308.    xcb_generic_error_t *error = NULL;
  309.    char *device_name;
  310.    int fd, device_name_length;
  311.    unsigned int driverType;
  312.  
  313.    drm_magic_t magic;
  314.  
  315.    assert(display);
  316.  
  317.    scrn = CALLOC_STRUCT(vl_dri_screen);
  318.    if (!scrn)
  319.       return NULL;
  320.  
  321.    scrn->conn = XGetXCBConnection(display);
  322.    if (!scrn->conn)
  323.       goto free_screen;
  324.  
  325.    xcb_prefetch_extension_data(scrn->conn, &xcb_dri2_id);
  326.  
  327.    extension = xcb_get_extension_data(scrn->conn, &xcb_dri2_id);
  328.    if (!(extension && extension->present))
  329.       goto free_screen;
  330.  
  331.    dri2_query_cookie = xcb_dri2_query_version (scrn->conn, XCB_DRI2_MAJOR_VERSION, XCB_DRI2_MINOR_VERSION);
  332.    dri2_query = xcb_dri2_query_version_reply (scrn->conn, dri2_query_cookie, &error);
  333.    if (dri2_query == NULL || error != NULL || dri2_query->minor_version < 2)
  334.       goto free_query;
  335.  
  336.    s = xcb_setup_roots_iterator(xcb_get_setup(scrn->conn));
  337.    while (screen--)
  338.         xcb_screen_next(&s);
  339.    driverType = XCB_DRI2_DRIVER_TYPE_DRI;
  340. #ifdef DRI2DriverPrimeShift
  341.    {
  342.       char *prime = getenv("DRI_PRIME");
  343.       if (prime) {
  344.          unsigned int primeid;
  345.          errno = 0;
  346.          primeid = strtoul(prime, NULL, 0);
  347.          if (errno == 0)
  348.             driverType |=
  349.                ((primeid & DRI2DriverPrimeMask) << DRI2DriverPrimeShift);
  350.       }
  351.    }
  352. #endif
  353.  
  354.    connect_cookie = xcb_dri2_connect_unchecked(scrn->conn, s.data->root, driverType);
  355.    connect = xcb_dri2_connect_reply(scrn->conn, connect_cookie, NULL);
  356.    if (connect == NULL || connect->driver_name_length + connect->device_name_length == 0)
  357.       goto free_connect;
  358.  
  359.    device_name_length = xcb_dri2_connect_device_name_length(connect);
  360.    device_name = CALLOC(1, device_name_length + 1);
  361.    if (!device_name)
  362.       goto free_connect;
  363.    memcpy(device_name, xcb_dri2_connect_device_name(connect), device_name_length);
  364.    fd = open(device_name, O_RDWR);
  365.    free(device_name);
  366.  
  367.    if (fd < 0)
  368.       goto free_connect;
  369.  
  370.    if (drmGetMagic(fd, &magic))
  371.       goto free_connect;
  372.  
  373.    authenticate_cookie = xcb_dri2_authenticate_unchecked(scrn->conn, s.data->root, magic);
  374.    authenticate = xcb_dri2_authenticate_reply(scrn->conn, authenticate_cookie, NULL);
  375.  
  376.    if (authenticate == NULL || !authenticate->authenticated)
  377.       goto free_authenticate;
  378.  
  379. #if GALLIUM_STATIC_TARGETS
  380.    scrn->base.pscreen = dd_create_screen(fd);
  381. #else
  382.    if (pipe_loader_drm_probe_fd(&scrn->base.dev, fd, false))
  383.       scrn->base.pscreen = pipe_loader_create_screen(scrn->base.dev, PIPE_SEARCH_DIR);
  384. #endif // GALLIUM_STATIC_TARGETS
  385.  
  386.    if (!scrn->base.pscreen)
  387.       goto release_pipe;
  388.  
  389.    scrn->base.pscreen->flush_frontbuffer = vl_dri2_flush_frontbuffer;
  390.    vl_compositor_reset_dirty_area(&scrn->dirty_areas[0]);
  391.    vl_compositor_reset_dirty_area(&scrn->dirty_areas[1]);
  392.  
  393.    free(authenticate);
  394.    free(connect);
  395.    free(dri2_query);
  396.    free(error);
  397.  
  398.    return &scrn->base;
  399.  
  400. release_pipe:
  401. #if !GALLIUM_STATIC_TARGETS
  402.    if (scrn->base.dev)
  403.       pipe_loader_release(&scrn->base.dev, 1);
  404. #endif // !GALLIUM_STATIC_TARGETS
  405. free_authenticate:
  406.    free(authenticate);
  407. free_connect:
  408.    free(connect);
  409. free_query:
  410.    free(dri2_query);
  411.    free(error);
  412.  
  413. free_screen:
  414.    FREE(scrn);
  415.    return NULL;
  416. }
  417.  
  418. void vl_screen_destroy(struct vl_screen *vscreen)
  419. {
  420.    struct vl_dri_screen *scrn = (struct vl_dri_screen*)vscreen;
  421.  
  422.    assert(vscreen);
  423.  
  424.    if (scrn->flushed) {
  425.       free(xcb_dri2_swap_buffers_reply(scrn->conn, scrn->swap_cookie, NULL));
  426.       free(xcb_dri2_wait_sbc_reply(scrn->conn, scrn->wait_cookie, NULL));
  427.       free(xcb_dri2_get_buffers_reply(scrn->conn, scrn->buffers_cookie, NULL));
  428.    }
  429.  
  430.    vl_dri2_destroy_drawable(scrn);
  431.    scrn->base.pscreen->destroy(scrn->base.pscreen);
  432. #if !GALLIUM_STATIC_TARGETS
  433.    pipe_loader_release(&scrn->base.dev, 1);
  434. #endif // !GALLIUM_STATIC_TARGETS
  435.    FREE(scrn);
  436. }
  437.