source: mainline/uspace/srv/hid/rfb/main.c@ 3083c74

/*
 * Copyright (c) 2013 Martin Sucha
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <stdlib.h>
#include <errno.h>
#include <loc.h>
#include <stdio.h>
#include <fibril_synch.h>
#include <abi/ipc/methods.h>
#include <inttypes.h>
#include <io/log.h>
#include <str.h>
#include <task.h>

#include <abi/fb/visuals.h>
#include <adt/list.h>
#include <io/mode.h>
#include <io/pixelmap.h>
#include <io/chargrid.h>
#include <graph.h>

#include "rfb.h"

#define NAME "rfb"

static vslmode_list_element_t pixel_mode;
static visualizer_t *vis;
static rfb_t rfb;

static errno_t rfb_claim(visualizer_t *vs)
{
        return EOK;
}

static errno_t rfb_yield(visualizer_t *vs)
{
        return EOK;
}

static errno_t rfb_suspend(visualizer_t *vs)
{
        return EOK;
}

static errno_t rfb_wakeup(visualizer_t *vs)
{
        return EOK;
}

static errno_t rfb_handle_damage_pixels(visualizer_t *vs,
    sysarg_t x0, sysarg_t y0, sysarg_t width, sysarg_t height,
    sysarg_t x_offset, sysarg_t y_offset)
{
        fibril_mutex_lock(&rfb.lock);

        if (x0 + width > rfb.width || y0 + height > rfb.height) {
                fibril_mutex_unlock(&rfb.lock);
                return EINVAL;
        }

        /* TODO update surface_t and use it */
        if (!rfb.damage_valid) {
                rfb.damage_rect.x = x0;
                rfb.damage_rect.y = y0;
                rfb.damage_rect.width = width;
                rfb.damage_rect.height = height;
                rfb.damage_valid = true;
        } else {
                if (x0 < rfb.damage_rect.x) {
                        rfb.damage_rect.width += rfb.damage_rect.x - x0;
                        rfb.damage_rect.x = x0;
                }
                if (y0 < rfb.damage_rect.y) {
                        rfb.damage_rect.height += rfb.damage_rect.y - y0;
                        rfb.damage_rect.y = y0;
                }
                sysarg_t x1 = x0 + width;
                sysarg_t dx1 = rfb.damage_rect.x + rfb.damage_rect.width;
                if (x1 > dx1) {
                        rfb.damage_rect.width += x1 - dx1;
                }
                sysarg_t y1 = y0 + height;
                sysarg_t dy1 = rfb.damage_rect.y + rfb.damage_rect.height;
                if (y1 > dy1) {
                        rfb.damage_rect.height += y1 - dy1;
                }
        }

        pixelmap_t *map = &vs->cells;

        for (sysarg_t y = y0; y < height + y0; ++y) {
                for (sysarg_t x = x0; x < width + x0; ++x) {
                        pixel_t pix = pixelmap_get_pixel(map, (x + x_offset) % map->width,
                            (y + y_offset) % map->height);
                        pixelmap_put_pixel(&rfb.framebuffer, x, y, pix);
                }
        }

        fibril_mutex_unlock(&rfb.lock);
        return EOK;
}

static errno_t rfb_change_mode(visualizer_t *vs, vslmode_t new_mode)
{
        return EOK;
}

static visualizer_ops_t rfb_ops = {
        .claim = rfb_claim,
        .yield = rfb_yield,
        .change_mode = rfb_change_mode,
        .handle_damage = rfb_handle_damage_pixels,
        .suspend = rfb_suspend,
        .wakeup = rfb_wakeup
};

static void syntax_print(void)
{
        fprintf(stderr, "Usage: %s <name> <width> <height> [port]\n", NAME);
}

static void client_connection(ipc_call_t *call, void *data)
{
        graph_visualizer_connection(vis, call, data);
}

int main(int argc, char **argv)
{
        log_init(NAME);

        if (argc <= 3) {
                syntax_print();
                return 1;
        }

        const char *rfb_name = argv[1];

        char *endptr;
        unsigned long width = strtoul(argv[2], &endptr, 0);
        if (*endptr != 0) {
                fprintf(stderr, "Invalid width\n");
                syntax_print();
                return 1;
        }

        unsigned long height = strtoul(argv[3], &endptr, 0);
        if (*endptr != 0) {
                fprintf(stderr, "Invalid height\n");
                syntax_print();
                return 1;
        }

        unsigned long port = 5900;
        if (argc > 4) {
                port = strtoul(argv[4], &endptr, 0);
                if (*endptr != 0) {
                        fprintf(stderr, "Invalid port number\n");
                        syntax_print();
                        return 1;
                }
        }

        rfb_init(&rfb, width, height, rfb_name);

        vis = malloc(sizeof(visualizer_t));
        if (vis == NULL) {
                fprintf(stderr, "Failed allocating visualizer struct\n");
                return 3;
        }

        graph_init_visualizer(vis);

        pixel_mode.mode.index = 0;
        pixel_mode.mode.version = 0;
        pixel_mode.mode.refresh_rate = 0;
        pixel_mode.mode.screen_aspect.width = rfb.width;
        pixel_mode.mode.screen_aspect.height = rfb.height;
        pixel_mode.mode.screen_width = rfb.width;
        pixel_mode.mode.screen_height = rfb.height;
        pixel_mode.mode.cell_aspect.width = 1;
        pixel_mode.mode.cell_aspect.height = 1;
        pixel_mode.mode.cell_visual.pixel_visual = VISUAL_RGB_8_8_8;

        link_initialize(&pixel_mode.link);
        list_append(&pixel_mode.link, &vis->modes);

        vis->def_mode_idx = 0;

        vis->ops = rfb_ops;
        vis->dev_ctx = NULL;

        async_set_fallback_port_handler(client_connection, NULL);

        errno_t rc = loc_server_register(NAME);
        if (rc != EOK) {
                printf("%s: Unable to register server.\n", NAME);
                return rc;
        }

        char *service_name;
        rc = asprintf(&service_name, "rfb/%s", rfb_name);
        if (rc < 0) {
                printf(NAME ": Unable to create service name\n");
                return rc;
        }

        service_id_t service_id;

        rc = loc_service_register(service_name, &service_id);
        if (rc != EOK) {
                printf(NAME ": Unable to register service %s.\n", service_name);
                return rc;
        }

        free(service_name);

        category_id_t visualizer_category;
        rc = loc_category_get_id("visualizer", &visualizer_category, IPC_FLAG_BLOCKING);
        if (rc != EOK) {
                fprintf(stderr, NAME ": Unable to get visualizer category id.\n");
                return 1;
        }

        rc = loc_service_add_to_cat(service_id, visualizer_category);
        if (rc != EOK) {
                fprintf(stderr, NAME ": Unable to add service to visualizer category.\n");
                return 1;
        }

        rc = rfb_listen(&rfb, port);
        if (rc != EOK) {
                fprintf(stderr, NAME ": Unable to listen at rfb port\n");
                return 2;
        }

        printf("%s: Accepting connections\n", NAME);
        task_retval(0);
        async_manager();

        /* Not reached */
        return 0;
}