Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 87a7cdb in mainline


Ignore:
Timestamp:
2019-12-05T19:35:12Z (12 months ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
master
Children:
71cbe5c
Parents:
973efd36
Message:

Enumerate display devices for output, RFB conversion (WIP)

Currently we can only have one active output device. Bitmaps
do not work as ipcgfx does not accept alloc != NULL.
Need to fill in tests.

Location:
uspace
Files:
4 added
12 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/ddev/test/ddev.c

    r973efd36 r87a7cdb  
    210210                }
    211211
    212                 /* Window GC connection */
     212                /* GC connection */
    213213                gc_conn(icall, gc);
    214214        }
  • uspace/srv/hid/display/display.c

    r973efd36 r87a7cdb  
    5858
    5959        list_initialize(&disp->clients);
    60         disp->gc = gc;
    6160        disp->next_wnd_id = 1;
     61        list_initialize(&disp->ddevs);
    6262        list_initialize(&disp->seats);
    6363        list_initialize(&disp->windows);
     
    347347}
    348348
     349/** Add display device to display.
     350 *
     351 * @param disp Display
     352 * @param ddev Display device
     353 */
     354void ds_display_add_ddev(ds_display_t *disp, ds_ddev_t *ddev)
     355{
     356        assert(ddev->display == NULL);
     357        assert(!link_used(&ddev->lddevs));
     358
     359        ddev->display = disp;
     360        list_append(&ddev->lddevs, &disp->ddevs);
     361}
     362
     363/** Remove display device from display.
     364 *
     365 * @param ddev Display device
     366 */
     367void ds_display_remove_ddev(ds_ddev_t *ddev)
     368{
     369        list_remove(&ddev->lddevs);
     370        ddev->display = NULL;
     371}
     372
     373/** Get first display device in display.
     374 *
     375 * @param disp Display
     376 * @return First display device or @c NULL if there is none
     377 */
     378ds_ddev_t *ds_display_first_ddev(ds_display_t *disp)
     379{
     380        link_t *link = list_first(&disp->ddevs);
     381
     382        if (link == NULL)
     383                return NULL;
     384
     385        return list_get_instance(link, ds_ddev_t, lddevs);
     386}
     387
     388/** Get next display device in display.
     389 *
     390 * @param ddev Current display device
     391 * @return Next display device or @c NULL if there is none
     392 */
     393ds_ddev_t *ds_display_next_ddev(ds_ddev_t *ddev)
     394{
     395        link_t *link = list_next(&ddev->lddevs, &ddev->display->ddevs);
     396
     397        if (link == NULL)
     398                return NULL;
     399
     400        return list_get_instance(link, ds_ddev_t, lddevs);
     401}
     402
     403// XXX
     404gfx_context_t *ds_display_get_gc(ds_display_t *display)
     405{
     406        ds_ddev_t *ddev;
     407
     408        ddev = ds_display_first_ddev(display);
     409        if (ddev == NULL)
     410                abort();
     411
     412        return ddev->gc;
     413}
     414
    349415/** @}
    350416 */
  • uspace/srv/hid/display/display.h

    r973efd36 r87a7cdb  
    4242#include <io/pos_event.h>
    4343#include "types/display/client.h"
     44#include "types/display/ddev.h"
    4445#include "types/display/display.h"
    4546#include "types/display/seat.h"
     
    6364extern ds_seat_t *ds_display_first_seat(ds_display_t *);
    6465extern ds_seat_t *ds_display_next_seat(ds_seat_t *);
     66extern void ds_display_add_ddev(ds_display_t *, ds_ddev_t *);
     67extern void ds_display_remove_ddev(ds_ddev_t *);
     68extern ds_ddev_t *ds_display_first_ddev(ds_display_t *);
     69extern ds_ddev_t *ds_display_next_ddev(ds_ddev_t *);
     70extern gfx_context_t *ds_display_get_gc(ds_display_t *);
    6571
    6672#endif
  • uspace/srv/hid/display/main.c

    r973efd36 r87a7cdb  
    8484
    8585/** Initialize display server */
    86 static errno_t display_srv_init(void)
     86static errno_t display_srv_init(ds_output_t **routput)
    8787{
    8888        ds_display_t *disp = NULL;
    8989        ds_seat_t *seat = NULL;
     90        ds_output_t *output = NULL;
    9091        gfx_context_t *gc = NULL;
    9192        errno_t rc;
     
    101102                goto error;
    102103
    103         rc = output_init(display_kbd_event, (void *) disp,
    104             display_pos_event, (void *) disp, &gc);
    105         if (rc != EOK)
    106                 goto error;
    107 
    108         disp->gc = gc;
    109104#if 0
    110105        rc = ds_input_open(disp);
     
    112107                goto error;
    113108#endif
     109        rc = ds_output_create(display_kbd_event, (void *) disp,
     110            display_pos_event, (void *) disp, &output);
     111        if (rc != EOK)
     112                goto error;
     113
     114        output->def_display = disp;
     115        rc = ds_output_start_discovery(output);
     116        if (rc != EOK)
     117                goto error;
     118
    114119        async_set_fallback_port_handler(display_client_conn, disp);
    115120
     
    128133        }
    129134
     135        *routput = output;
    130136        return EOK;
    131137error:
     
    134140                ds_input_close(disp);
    135141#endif
     142        if (output != NULL)
     143                ds_output_destroy(output);
    136144        if (gc != NULL)
    137145                gfx_context_delete(gc);
     
    199207{
    200208        errno_t rc;
     209        ds_output_t *output;
    201210
    202211        printf("%s: Display server\n", NAME);
     
    207216        }
    208217
    209         rc = display_srv_init();
     218        rc = display_srv_init(&output);
    210219        if (rc != EOK)
    211220                return 1;
  • uspace/srv/hid/display/meson.build

    r973efd36 r87a7cdb  
    2727#
    2828
    29 deps = [ 'ipcgfx', 'display', 'guigfx' ]
     29deps = [ 'ipcgfx', 'display', 'ddev' ]
    3030
    3131src = files(
    3232        'client.c',
     33        'ddev.c',
    3334        'display.c',
    3435        'dsops.c',
  • uspace/srv/hid/display/output.c

    r973efd36 r87a7cdb  
    3434 */
    3535
     36#include <assert.h>
    3637#include <errno.h>
    37 #include <gfx/context.h>
    38 #include <guigfx/canvas.h>
     38#include <fibril_synch.h>
    3939#include <io/kbd_event.h>
    4040#include <io/pos_event.h>
     41#include <loc.h>
    4142#include <stdio.h>
    4243#include <stdlib.h>
    43 #include <window.h>
     44#include "ddev.h"
    4445#include "output.h"
    4546
     47#if 0
    4648static void (*kbd_ev_handler)(void *, kbd_event_t *);
    4749static void *kbd_ev_arg;
     
    5961        pos_ev_handler(pos_ev_arg, (pos_event_t *) data);
    6062}
     63#endif
    6164
    62 errno_t output_init(void (*kbd_event_handler)(void *, kbd_event_t *),
    63     void *karg, void (*pos_event_handler)(void *, pos_event_t *),
    64     void *parg, gfx_context_t **rgc)
     65/** Check for new display devices.
     66 *
     67 * @param output Display server output
     68 */
     69static errno_t ds_output_check_new_devs(ds_output_t *output)
    6570{
    66         canvas_gc_t *cgc = NULL;
    67         window_t *window = NULL;
    68         pixel_t *pixbuf = NULL;
    69         surface_t *surface = NULL;
    70         canvas_t *canvas = NULL;
    71         gfx_coord_t vw, vh;
     71        category_id_t ddev_cid;
     72        service_id_t *svcs;
     73        size_t count, i;
     74        bool already_known;
     75        ds_ddev_t *nddev;
    7276        errno_t rc;
    7377
    74         printf("Init canvas..\n");
    75         kbd_ev_handler = kbd_event_handler;
    76         kbd_ev_arg = karg;
     78        assert(fibril_mutex_is_locked(&output->lock));
    7779
    78         pos_ev_handler = pos_event_handler;
    79         pos_ev_arg = parg;
    80 
    81         window = window_open("comp:0/winreg", NULL,
    82             WINDOW_MAIN | WINDOW_DECORATED, "Display Server");
    83         if (window == NULL) {
    84                 printf("Error creating window.\n");
    85                 return -1;
    86         }
    87 
    88         vw = 800;
    89         vh = 600;
    90 
    91         pixbuf = calloc(vw * vh, sizeof(pixel_t));
    92         if (pixbuf == NULL) {
    93                 printf("Error allocating memory for pixel buffer.\n");
    94                 return ENOMEM;
    95         }
    96 
    97         surface = surface_create(vw, vh, pixbuf, 0);
    98         if (surface == NULL) {
    99                 printf("Error creating surface.\n");
     80        rc = loc_category_get_id("display-device", &ddev_cid,
     81            IPC_FLAG_BLOCKING);
     82        if (rc != EOK) {
     83                printf("Error looking up category 'display-device'.\n");
    10084                return EIO;
    10185        }
    10286
    103         canvas = create_canvas(window_root(window), NULL, vw, vh,
    104             surface);
    105         if (canvas == NULL) {
    106                 printf("Error creating canvas.\n");
     87        /*
     88         * Check for new dispay devices
     89         */
     90        rc = loc_category_get_svcs(ddev_cid, &svcs, &count);
     91        if (rc != EOK) {
     92                printf("Error getting list of display devices.\n");
    10793                return EIO;
    10894        }
    10995
    110         sig_connect(&canvas->keyboard_event, NULL, on_keyboard_event);
    111         sig_connect(&canvas->position_event, NULL, on_position_event);
     96        for (i = 0; i < count; i++) {
     97                already_known = false;
    11298
    113         window_resize(window, 0, 0, vw + 10, vh + 30, WINDOW_PLACEMENT_ANY);
    114         window_exec(window);
     99                /* Determine whether we already know this device. */
     100                list_foreach(output->ddevs, loutdevs, ds_ddev_t, ddev) {
     101                        if (ddev->svc_id == svcs[i]) {
     102                                already_known = true;
     103                                break;
     104                        }
     105                }
    115106
    116         printf("Create canvas GC\n");
    117         rc = canvas_gc_create(canvas, surface, &cgc);
    118         if (rc != EOK)
     107                if (!already_known) {
     108                        rc = ds_ddev_open(output->def_display, svcs[i], &nddev);
     109                        if (rc != EOK) {
     110                                printf("Error adding display device.\n");
     111                                continue;
     112                        }
     113
     114                        list_append(&nddev->loutdevs, &output->ddevs);
     115
     116                        printf("Added display device '%lu'\n",
     117                            (unsigned long) svcs[i]);
     118                }
     119        }
     120
     121        free(svcs);
     122
     123        return EOK;
     124}
     125
     126/** Display device category change callback.
     127 *
     128 * @param arg Display server output (cast to void *)
     129 */
     130static void ds_ddev_change_cb(void *arg)
     131{
     132        ds_output_t *output = (ds_output_t *) arg;
     133
     134        printf("ds_ddev_change_cb\n");
     135        fibril_mutex_lock(&output->lock);
     136        (void) ds_output_check_new_devs(output);
     137        fibril_mutex_unlock(&output->lock);
     138}
     139
     140/** Create display server output.
     141 *
     142 * @param kbd_event_handler
     143 * @param karg
     144 * @param pos_event_handler
     145 * @param parg
     146 * @param routput Place to store pointer to display server output object.
     147 * @return EOK on success or an error code
     148 */
     149errno_t ds_output_create(void (*kbd_event_handler)(void *, kbd_event_t *),
     150    void *karg, void (*pos_event_handler)(void *, pos_event_t *),
     151    void *parg, ds_output_t **routput)
     152{
     153        ds_output_t *output;
     154
     155        output = calloc(1, sizeof(ds_output_t));
     156        if (output == NULL)
     157                return ENOMEM;
     158
     159        fibril_mutex_initialize(&output->lock);
     160        list_initialize(&output->ddevs);
     161
     162        *routput = output;
     163        return EOK;
     164}
     165
     166/** Start display device discovery.
     167 *
     168 * @param output Display server output
     169 * @return EOK on success or an error code
     170 */
     171errno_t ds_output_start_discovery(ds_output_t *output)
     172{
     173        errno_t rc;
     174
     175        rc = loc_register_cat_change_cb(ds_ddev_change_cb, output);
     176        if (rc != EOK) {
     177                printf("Failed registering callback for device discovery.\n");
    119178                return rc;
     179        }
    120180
    121         *rgc = canvas_gc_get_ctx(cgc);
    122         return EOK;
     181        fibril_mutex_lock(&output->lock);
     182        rc = ds_output_check_new_devs(output);
     183        fibril_mutex_unlock(&output->lock);
     184
     185        return rc;
     186}
     187
     188/** Destroy display server output.
     189 *
     190 * @param output Display server output
     191 */
     192void ds_output_destroy(ds_output_t *output)
     193{
     194        free(output);
    123195}
    124196
  • uspace/srv/hid/display/output.h

    r973efd36 r87a7cdb  
    4040#include <io/kbd_event.h>
    4141#include <io/pos_event.h>
     42#include "types/display/output.h"
    4243
    43 extern errno_t output_init(void (*)(void *, kbd_event_t *), void *,
    44     void (*)(void *, pos_event_t *), void *,
    45     gfx_context_t **);
     44extern errno_t ds_output_create(void (*)(void *, kbd_event_t *),
     45    void *, void (*)(void *, pos_event_t *), void *, ds_output_t **);
     46extern errno_t ds_output_start_discovery(ds_output_t *);
     47extern void ds_output_destroy(ds_output_t *);
    4648
    4749#endif
  • uspace/srv/hid/display/types/display/display.h

    r973efd36 r87a7cdb  
    3838
    3939#include <adt/list.h>
    40 #include <gfx/context.h>
    4140#include <io/input.h>
    4241#include "window.h"
     
    4645        /** Clients (of ds_client_t) */
    4746        list_t clients;
    48         /** Output GC */
    49         gfx_context_t *gc;
    5047
    5148        /** Next ID to assign to a window.
     
    6562        /** Windows (of ds_window_t) in stacking order */
    6663        list_t windows;
     64
     65        /** Display devices (of ds_ddev_t) */
     66        list_t ddevs;
    6767} ds_display_t;
    6868
  • uspace/srv/hid/display/window.c

    r973efd36 r87a7cdb  
    7777        ds_window_t *wnd = (ds_window_t *) arg;
    7878
    79         log_msg(LOG_DEFAULT, LVL_NOTE, "gc_set_color gc=%p", wnd->display->gc);
    80         return gfx_set_color(wnd->display->gc, color);
     79        log_msg(LOG_DEFAULT, LVL_NOTE, "gc_set_color gc=%p",
     80            ds_display_get_gc(wnd->display));
     81        return gfx_set_color(ds_display_get_gc(wnd->display), color);
    8182}
    8283
     
    9596        log_msg(LOG_DEFAULT, LVL_NOTE, "gc_fill_rect");
    9697        gfx_rect_translate(&wnd->dpos, rect, &drect);
    97         return gfx_fill_rect(wnd->display->gc, &drect);
     98        return gfx_fill_rect(ds_display_get_gc(wnd->display), &drect);
    9899}
    99100
     
    117118                return ENOMEM;
    118119
    119         rc = gfx_bitmap_create(wnd->display->gc, params, alloc,
     120        rc = gfx_bitmap_create(ds_display_get_gc(wnd->display), params, alloc,
    120121            &cbm->bitmap);
    121122        if (rc != EOK)
  • uspace/srv/hid/rfb/main.c

    r973efd36 r87a7cdb  
    2727 */
    2828
    29 #include <stdlib.h>
     29#include <ddev_srv.h>
    3030#include <errno.h>
     31#include <fibril_synch.h>
     32#include <gfx/color.h>
     33#include <gfx/context.h>
     34#include <gfx/coord.h>
     35#include <inttypes.h>
     36#include <io/log.h>
     37#include <io/pixelmap.h>
     38#include <ipcgfx/server.h>
    3139#include <loc.h>
    3240#include <stdio.h>
    33 #include <fibril_synch.h>
    34 #include <abi/ipc/methods.h>
    35 #include <inttypes.h>
    36 #include <io/log.h>
    37 #include <str.h>
     41#include <stdlib.h>
    3842#include <task.h>
    3943
    40 #include <abi/fb/visuals.h>
    41 #include <adt/list.h>
    42 #include <io/mode.h>
    43 #include <io/pixelmap.h>
    44 #include <io/chargrid.h>
    45 #include <graph.h>
    46 
    4744#include "rfb.h"
    4845
    4946#define NAME "rfb"
    5047
    51 static vslmode_list_element_t pixel_mode;
    52 static visualizer_t *vis;
    53 static rfb_t rfb;
    54 
    55 static errno_t rfb_claim(visualizer_t *vs)
    56 {
    57         return EOK;
    58 }
    59 
    60 static errno_t rfb_yield(visualizer_t *vs)
    61 {
    62         return EOK;
    63 }
    64 
    65 static errno_t rfb_suspend(visualizer_t *vs)
    66 {
    67         return EOK;
    68 }
    69 
    70 static errno_t rfb_wakeup(visualizer_t *vs)
    71 {
    72         return EOK;
    73 }
    74 
     48static errno_t rfb_gc_set_color(void *, gfx_color_t *);
     49static errno_t rfb_gc_fill_rect(void *, gfx_rect_t *);
     50static errno_t rfb_gc_bitmap_create(void *, gfx_bitmap_params_t *,
     51    gfx_bitmap_alloc_t *, void **);
     52static errno_t rfb_gc_bitmap_destroy(void *);
     53static errno_t rfb_gc_bitmap_render(void *, gfx_rect_t *, gfx_coord2_t *);
     54static errno_t rfb_gc_bitmap_get_alloc(void *, gfx_bitmap_alloc_t *);
     55
     56static ddev_ops_t rfb_ddev_ops = {
     57};
     58
     59typedef struct {
     60        rfb_t rfb;
     61        pixel_t color;
     62} rfb_gc_t;
     63
     64typedef struct {
     65        rfb_gc_t *rfb;
     66        gfx_bitmap_alloc_t alloc;
     67        gfx_rect_t rect;
     68        bool myalloc;
     69} rfb_bitmap_t;
     70
     71gfx_context_ops_t rfb_gc_ops = {
     72        .set_color = rfb_gc_set_color,
     73        .fill_rect = rfb_gc_fill_rect,
     74        .bitmap_create = rfb_gc_bitmap_create,
     75        .bitmap_destroy = rfb_gc_bitmap_destroy,
     76        .bitmap_render = rfb_gc_bitmap_render,
     77        .bitmap_get_alloc = rfb_gc_bitmap_get_alloc
     78};
     79
     80static void rfb_gc_invalidate_rect(rfb_gc_t *rfbgc, gfx_rect_t *rect)
     81{
     82        rfb_t *rfb = &rfbgc->rfb;
     83        gfx_rect_t old_rect;
     84        gfx_rect_t new_rect;
     85
     86        if (gfx_rect_is_empty(rect))
     87                return;
     88
     89        if (!rfb->damage_valid) {
     90                old_rect.p0.x = old_rect.p0.y = 0;
     91                old_rect.p1.x = old_rect.p1.y = 0;
     92        } else {
     93                old_rect.p0.x = rfb->damage_rect.x;
     94                old_rect.p0.y = rfb->damage_rect.y;
     95                old_rect.p1.x = rfb->damage_rect.x + rfb->damage_rect.width;
     96                old_rect.p1.y = rfb->damage_rect.y + rfb->damage_rect.height;
     97        }
     98
     99        gfx_rect_envelope(&old_rect, rect, &new_rect);
     100
     101        rfb->damage_rect.x = new_rect.p0.x;
     102        rfb->damage_rect.y = new_rect.p0.y;
     103        rfb->damage_rect.width = new_rect.p1.x - new_rect.p0.x;
     104        rfb->damage_rect.height = new_rect.p1.y - new_rect.p1.y;
     105}
     106
     107/** Set color on RFB.
     108 *
     109 * Set drawing color on RFB GC.
     110 *
     111 * @param arg RFB
     112 * @param color Color
     113 *
     114 * @return EOK on success or an error code
     115 */
     116static errno_t rfb_gc_set_color(void *arg, gfx_color_t *color)
     117{
     118        rfb_gc_t *rfb = (rfb_gc_t *) arg;
     119        uint16_t r, g, b;
     120
     121        gfx_color_get_rgb_i16(color, &r, &g, &b);
     122        rfb->color = PIXEL(0, r >> 8, g >> 8, b >> 8);
     123        return EOK;
     124}
     125
     126/** Fill rectangle on RFB.
     127 *
     128 * @param arg RFB
     129 * @param rect Rectangle
     130 *
     131 * @return EOK on success or an error code
     132 */
     133static errno_t rfb_gc_fill_rect(void *arg, gfx_rect_t *rect)
     134{
     135        rfb_gc_t *rfb = (rfb_gc_t *) arg;
     136        gfx_coord_t x, y;
     137
     138        // XXX We should handle p0.x > p1.x and p0.y > p1.y
     139
     140        for (y = rect->p0.y; y < rect->p1.y; y++) {
     141                for (x = rect->p0.x; x < rect->p1.x; x++) {
     142                        pixelmap_put_pixel(&rfb->rfb.framebuffer, x, y,
     143                            rfb->color);
     144                }
     145        }
     146
     147        rfb_gc_invalidate_rect(rfb, rect);
     148
     149        return EOK;
     150}
     151
     152/** Create bitmap in RFB GC.
     153 *
     154 * @param arg RFB
     155 * @param params Bitmap params
     156 * @param alloc Bitmap allocation info or @c NULL
     157 * @param rbm Place to store pointer to new bitmap
     158 * @return EOK on success or an error code
     159 */
     160errno_t rfb_gc_bitmap_create(void *arg, gfx_bitmap_params_t *params,
     161    gfx_bitmap_alloc_t *alloc, void **rbm)
     162{
     163        rfb_gc_t *rfb = (rfb_gc_t *) arg;
     164        rfb_bitmap_t *rfbbm = NULL;
     165        gfx_coord2_t dim;
     166        errno_t rc;
     167
     168        rfbbm = calloc(1, sizeof(rfb_bitmap_t));
     169        if (rfbbm == NULL)
     170                return ENOMEM;
     171
     172        gfx_coord2_subtract(&params->rect.p1, &params->rect.p0, &dim);
     173        rfbbm->rect = params->rect;
     174
     175        if (alloc == NULL) {
     176                rfbbm->alloc.pitch = dim.x * sizeof(uint32_t);
     177                rfbbm->alloc.off0 = 0;
     178                rfbbm->alloc.pixels = malloc(rfbbm->alloc.pitch * dim.y);
     179                rfbbm->myalloc = true;
     180
     181                if (rfbbm->alloc.pixels == NULL) {
     182                        rc = ENOMEM;
     183                        goto error;
     184                }
     185        } else {
     186                rfbbm->alloc = *alloc;
     187        }
     188
     189        rfbbm->rfb = rfb;
     190        *rbm = (void *)rfbbm;
     191        return EOK;
     192error:
     193        if (rbm != NULL)
     194                free(rfbbm);
     195        return rc;
     196}
     197
     198/** Destroy bitmap in RFB GC.
     199 *
     200 * @param bm Bitmap
     201 * @return EOK on success or an error code
     202 */
     203static errno_t rfb_gc_bitmap_destroy(void *bm)
     204{
     205        rfb_bitmap_t *rfbbm = (rfb_bitmap_t *)bm;
     206        if (rfbbm->myalloc)
     207                free(rfbbm->alloc.pixels);
     208        free(rfbbm);
     209        return EOK;
     210}
     211
     212/** Render bitmap in RFB GC.
     213 *
     214 * @param bm Bitmap
     215 * @param srect0 Source rectangle or @c NULL
     216 * @param offs0 Offset or @c NULL
     217 * @return EOK on success or an error code
     218 */
     219static errno_t rfb_gc_bitmap_render(void *bm, gfx_rect_t *srect0,
     220    gfx_coord2_t *offs0)
     221{
     222        rfb_bitmap_t *rfbbm = (rfb_bitmap_t *)bm;
     223        gfx_rect_t srect;
     224        gfx_rect_t drect;
     225        gfx_coord2_t offs;
     226        gfx_coord2_t dim;
     227
     228        if (srect0 != NULL)
     229                srect = *srect0;
     230        else
     231                srect = rfbbm->rect;
     232
     233        if (offs0 != NULL) {
     234                offs = *offs0;
     235        } else {
     236                offs.x = 0;
     237                offs.y = 0;
     238        }
     239
     240        /* Destination rectangle */
     241        gfx_rect_translate(&offs, &srect, &drect);
     242
     243        gfx_coord2_subtract(&drect.p1, &drect.p0, &dim);
     244
     245        return EOK;
     246}
     247
     248/** Get allocation info for bitmap in RFB GC.
     249 *
     250 * @param bm Bitmap
     251 * @param alloc Place to store allocation info
     252 * @return EOK on success or an error code
     253 */
     254static errno_t rfb_gc_bitmap_get_alloc(void *bm, gfx_bitmap_alloc_t *alloc)
     255{
     256        rfb_bitmap_t *rfbbm = (rfb_bitmap_t *)bm;
     257        *alloc = rfbbm->alloc;
     258        return EOK;
     259}
     260
     261#if 0
    75262static errno_t rfb_handle_damage_pixels(visualizer_t *vs,
    76263    sysarg_t x0, sysarg_t y0, sysarg_t width, sysarg_t height,
     
    125312        return EOK;
    126313}
    127 
    128 static errno_t rfb_change_mode(visualizer_t *vs, vslmode_t new_mode)
    129 {
    130         return EOK;
    131 }
    132 
    133 static visualizer_ops_t rfb_ops = {
    134         .claim = rfb_claim,
    135         .yield = rfb_yield,
    136         .change_mode = rfb_change_mode,
    137         .handle_damage = rfb_handle_damage_pixels,
    138         .suspend = rfb_suspend,
    139         .wakeup = rfb_wakeup
    140 };
     314#endif
    141315
    142316static void syntax_print(void)
     
    145319}
    146320
    147 static void client_connection(ipc_call_t *call, void *data)
    148 {
    149         graph_visualizer_connection(vis, call, data);
     321static void client_connection(ipc_call_t *icall, void *arg)
     322{
     323        ddev_srv_t srv;
     324        sysarg_t svc_id;
     325        gfx_context_t *gc;
     326        errno_t rc;
     327
     328        svc_id = ipc_get_arg2(icall);
     329
     330        if (svc_id != 0) {
     331                /* Set up protocol structure */
     332                ddev_srv_initialize(&srv);
     333                srv.ops = &rfb_ddev_ops;
     334                srv.arg = arg;
     335
     336                /* Handle connection */
     337                ddev_conn(icall, &srv);
     338        } else {
     339                rc = gfx_context_new(&rfb_gc_ops, arg, &gc);
     340                if (rc != EOK) {
     341                        async_answer_0(icall, ENOMEM);
     342                        return;
     343                }
     344
     345                /* GC connection */
     346                gc_conn(icall, gc);
     347        }
    150348}
    151349
    152350int main(int argc, char **argv)
    153351{
     352        rfb_t rfb;
     353
    154354        log_init(NAME);
    155355
     
    188388        rfb_init(&rfb, width, height, rfb_name);
    189389
    190         vis = malloc(sizeof(visualizer_t));
    191         if (vis == NULL) {
    192                 fprintf(stderr, "Failed allocating visualizer struct\n");
    193                 return 3;
    194         }
    195 
    196         graph_init_visualizer(vis);
    197 
    198         pixel_mode.mode.index = 0;
    199         pixel_mode.mode.version = 0;
    200         pixel_mode.mode.refresh_rate = 0;
    201         pixel_mode.mode.screen_aspect.width = rfb.width;
    202         pixel_mode.mode.screen_aspect.height = rfb.height;
    203         pixel_mode.mode.screen_width = rfb.width;
    204         pixel_mode.mode.screen_height = rfb.height;
    205         pixel_mode.mode.cell_aspect.width = 1;
    206         pixel_mode.mode.cell_aspect.height = 1;
    207         pixel_mode.mode.cell_visual.pixel_visual = VISUAL_RGB_8_8_8;
    208 
    209         link_initialize(&pixel_mode.link);
    210         list_append(&pixel_mode.link, &vis->modes);
    211 
    212         vis->def_mode_idx = 0;
    213 
    214         vis->ops = rfb_ops;
    215         vis->dev_ctx = NULL;
    216 
    217         async_set_fallback_port_handler(client_connection, NULL);
     390        async_set_fallback_port_handler(client_connection, &rfb);
    218391
    219392        errno_t rc = loc_server_register(NAME);
     
    240413        free(service_name);
    241414
    242         category_id_t visualizer_category;
    243         rc = loc_category_get_id("visualizer", &visualizer_category, IPC_FLAG_BLOCKING);
     415        category_id_t ddev_cid;
     416        rc = loc_category_get_id("display-device", &ddev_cid, IPC_FLAG_BLOCKING);
    244417        if (rc != EOK) {
    245418                fprintf(stderr, NAME ": Unable to get visualizer category id.\n");
     
    247420        }
    248421
    249         rc = loc_service_add_to_cat(service_id, visualizer_category);
     422        rc = loc_service_add_to_cat(service_id, ddev_cid);
    250423        if (rc != EOK) {
    251424                fprintf(stderr, NAME ": Unable to add service to visualizer category.\n");
  • uspace/srv/hid/rfb/meson.build

    r973efd36 r87a7cdb  
    2727#
    2828
    29 deps = [ 'graph' ]
     29deps = [ 'ipcgfx', 'ddev' ]
    3030src = files('main.c', 'rfb.c')
  • uspace/srv/locsrv/locsrv.c

    r973efd36 r87a7cdb  
    13841384        categ_dir_add_cat(&cdir, cat);
    13851385
     1386        cat = category_new("display-device");
     1387        categ_dir_add_cat(&cdir, cat);
     1388
    13861389        cat = category_new("audio-pcm");
    13871390        categ_dir_add_cat(&cdir, cat);
Note: See TracChangeset for help on using the changeset viewer.