Changeset a35b458 in mainline for uspace/srv/hid/rfb


Ignore:
Timestamp:
2018-03-02T20:10:49Z (8 years ago)
Author:
Jiří Zárevúcky <zarevucky.jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f1380b7
Parents:
3061bc1
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-02-28 17:38:31)
git-committer:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:10:49)
Message:

style: Remove trailing whitespace on _all_ lines, including empty ones, for particular file types.

Command used: tools/srepl '\s\+$' '' -- *.c *.h *.py *.sh *.s *.S *.ag

Currently, whitespace on empty lines is very inconsistent.
There are two basic choices: Either remove the whitespace, or keep empty lines
indented to the level of surrounding code. The former is AFAICT more common,
and also much easier to do automatically.

Alternatively, we could write script for automatic indentation, and use that
instead. However, if such a script exists, it's possible to use the indented
style locally, by having the editor apply relevant conversions on load/save,
without affecting remote repository. IMO, it makes more sense to adopt
the simpler rule.

Location:
uspace/srv/hid/rfb
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/hid/rfb/main.c

    r3061bc1 ra35b458  
    7878{
    7979        fibril_mutex_lock(&rfb.lock);
    80        
     80
    8181        if (x0 + width > rfb.width || y0 + height > rfb.height) {
    8282                fibril_mutex_unlock(&rfb.lock);
    8383                return EINVAL;
    8484        }
    85        
     85
    8686        /* TODO update surface_t and use it */
    8787        if (!rfb.damage_valid) {
    … …  
    112112                }
    113113        }
    114        
     114
    115115        pixelmap_t *map = &vs->cells;
    116        
     116
    117117        for (sysarg_t y = y0; y < height + y0; ++y) {
    118118                for (sysarg_t x = x0; x < width + x0; ++x) {
    … …  
    122122                }
    123123        }
    124        
     124
    125125        fibril_mutex_unlock(&rfb.lock);
    126126        return EOK;
    … …  
    161161
    162162        const char *rfb_name = argv[1];
    163        
     163
    164164        char *endptr;
    165165        unsigned long width = strtoul(argv[2], &endptr, 0);
    … …  
    169169                return 1;
    170170        }
    171        
     171
    172172        unsigned long height = strtoul(argv[3], &endptr, 0);
    173173        if (*endptr != 0) {
    … …  
    176176                return 1;
    177177        }
    178        
     178
    179179        unsigned long port = 5900;
    180180        if (argc > 4) {
    … …  
    186186                }
    187187        }
    188        
     188
    189189        rfb_init(&rfb, width, height, rfb_name);
    190        
     190
    191191        vis = malloc(sizeof(visualizer_t));
    192192        if (vis == NULL) {
    … …  
    194194                return 3;
    195195        }
    196        
     196
    197197        graph_init_visualizer(vis);
    198        
     198
    199199        pixel_mode.mode.index = 0;
    200200        pixel_mode.mode.version = 0;
    … …  
    207207        pixel_mode.mode.cell_aspect.height = 1;
    208208        pixel_mode.mode.cell_visual.pixel_visual = VISUAL_RGB_8_8_8;
    209        
     209
    210210        link_initialize(&pixel_mode.link);
    211211        list_append(&pixel_mode.link, &vis->modes);
    212        
     212
    213213        vis->def_mode_idx = 0;
    214        
     214
    215215        vis->ops = rfb_ops;
    216216        vis->dev_ctx = NULL;
    … …  
    232232
    233233        service_id_t service_id;
    234        
     234
    235235        rc = loc_service_register(service_name, &service_id);
    236236        if (rc != EOK) {
    … …  
    238238                return rc;
    239239        }
    240        
     240
    241241        free(service_name);
    242242
    … …  
    247247                return 1;
    248248        }
    249        
     249
    250250        rc = loc_service_add_to_cat(service_id, visualizer_category);
    251251        if (rc != EOK) {
    … …  
    253253                return 1;
    254254        }
    255        
     255
    256256        rc = rfb_listen(&rfb, port);
    257257        if (rc != EOK) {
    … …  
    259259                return 2;
    260260        }
    261        
     261
    262262        printf("%s: Accepting connections\n", NAME);
    263263        task_retval(0);

  • uspace/srv/hid/rfb/rfb.c

    r3061bc1 ra35b458  
    7070                rbuf_out = 0;
    7171                rbuf_in = 0;
    72                
     72
    7373                rc = tcp_conn_recv_wait(conn, rbuf, BUFFER_SIZE, &nrecv);
    7474                if (rc != EOK)
    7575                        return rc;
    76                
     76
    7777                rbuf_in = nrecv;
    7878        }
    79        
     79
    8080        *c = rbuf[rbuf_out++];
    8181        return EOK;
    … …  
    177177        memset(rfb, 0, sizeof(rfb_t));
    178178        fibril_mutex_initialize(&rfb->lock);
    179        
     179
    180180        rfb_pixel_format_t *pf = &rfb->pixel_format;
    181181        pf->bpp = 32;
    … …  
    189189        pf->g_shift = 8;
    190190        pf->b_shift = 16;
    191        
     191
    192192        rfb->name = str_dup(name);
    193193        rfb->supports_trle = false;
    194        
     194
    195195        return rfb_set_size(rfb, width, height);
    196196}
    … …  
    209209        rfb->width = width;
    210210        rfb->height = height;
    211        
     211
    212212        /* Fill with white */
    213213        memset(rfb->framebuffer.data, 255, new_size);
    214        
     214
    215215        return EOK;
    216216}
    … …  
    242242                }
    243243        }
    244        
     244
    245245        if (first_free_index != -1) {
    246246                rfb->palette[first_free_index] = PIXEL(255, RED(pixel), GREEN(pixel),
    … …  
    250250                return;
    251251        }
    252        
     252
    253253        /* TODO find nearest color index. We are lazy so return index 0 for now */
    254254        *buf = 0;
    … …  
    262262        pix |= rfb_scale_channel(GREEN(pixel), pf->g_max) << pf->g_shift;
    263263        pix |= rfb_scale_channel(BLUE(pixel), pf->b_max) << pf->b_shift;
    264        
     264
    265265        if (pf->bpp == 8) {
    266266                uint8_t pix8 = pix;
    … …  
    317317        size_t size = sizeof(rfb_set_color_map_entries_t) +
    318318            rfb->palette_used * sizeof(rfb_color_map_entry_t);
    319        
     319
    320320        void *buf = malloc(size);
    321321        if (buf == NULL)
    322322                return NULL;
    323        
     323
    324324        void *pos = buf;
    325        
     325
    326326        rfb_set_color_map_entries_t *scme = pos;
    327327        scme->message_type = RFB_SMSG_SET_COLOR_MAP_ENTRIES;
    … …  
    330330        rfb_set_color_map_entries_to_be(scme, scme);
    331331        pos += sizeof(rfb_set_color_map_entries_t);
    332        
     332
    333333        rfb_color_map_entry_t *entries = pos;
    334334        for (unsigned i = 0; i < rfb->palette_used; i++) {
    … …  
    338338                rfb_color_map_entry_to_be(&entries[i], &entries[i]);
    339339        }
    340        
     340
    341341        *psize = size;
    342342        return buf;
    … …  
    347347        size_t pixel_size = rfb->pixel_format.bpp / 8;
    348348        size_t size = (rect->width * rect->height * pixel_size);
    349        
     349
    350350        if (buf == NULL)
    351351                return size;
    352        
     352
    353353        for (uint16_t y = 0; y < rect->height; y++) {
    354354                for (uint16_t x = 0; x < rect->width; x++) {
    … …  
    359359                }
    360360        }
    361        
     361
    362362        return size;
    363363}
    … …  
    376376        ctx->size = pixel_format->bpp / 8;
    377377        ctx->compress_type = COMP_NONE;
    378        
     378
    379379        if (pixel_format->bpp == 32 && pixel_format->depth <= 24) {
    380380                uint32_t mask = 0;
    … …  
    382382                mask |= pixel_format->g_max << pixel_format->g_shift;
    383383                mask |= pixel_format->b_max << pixel_format->b_shift;
    384                
     384
    385385                if (pixel_format->big_endian) {
    386386                        mask = host2uint32_t_be(mask);
    … …  
    389389                        mask = host2uint32_t_le(mask);
    390390                }
    391                
     391
    392392                uint8_t *mask_data = (uint8_t *) &mask;
    393393                if (mask_data[0] == 0) {
    … …  
    407407        uint8_t data[4];
    408408        rfb_encode_pixel(rfb, data, pixel);
    409        
     409
    410410        switch (cpixel->compress_type) {
    411411        case COMP_NONE:
    … …  
    424424        if (buf == NULL)
    425425                return size;
    426        
     426
    427427        for (uint16_t y = tile->y; y < tile->y + tile->height; y++) {
    428428                for (uint16_t x = tile->x; x < tile->x + tile->width; x++) {
    … …  
    431431                }
    432432        }
    433        
     433
    434434        return size;
    435435}
    … …  
    446446                }
    447447        }
    448        
     448
    449449        /* OK, encode it */
    450450        if (buf)
    … …  
    458458        cpixel_ctx_t cpixel;
    459459        cpixel_context_init(&cpixel, &rfb->pixel_format);
    460        
     460
    461461        size_t size = 0;
    462462        for (uint16_t y = 0; y < rect->height; y += 16) {
    … …  
    468468                                .height = (y + 16 <= rect->height ? 16 : rect->height - y)
    469469                        };
    470                        
     470
    471471                        size += 1;
    472472                        uint8_t *tile_enctype_ptr = buf;
    473473                        if (buf)
    474474                                buf +=  1;
    475                        
     475
    476476                        uint8_t tile_enctype = RFB_TILE_ENCODING_SOLID;
    477477                        size_t tile_size;
    … …  
    482482                                tile_enctype = RFB_TILE_ENCODING_RAW;
    483483                        }
    484                        
     484
    485485                        if (buf) {
    486486                                *tile_enctype_ptr = tile_enctype;
    … …  
    502502                rfb->damage_rect.height = rfb->height;
    503503        }
    504        
     504
    505505
    506506        /* We send only single raw rectangle right now */
    … …  
    509509            rfb_rect_encode_raw(rfb, &rfb->damage_rect, NULL)
    510510            ;
    511        
     511
    512512        void *buf = malloc(buf_size);
    513513        if (buf == NULL) {
    … …  
    516516        }
    517517        memset(buf, 0, buf_size);
    518        
     518
    519519        void *pos = buf;
    520520        rfb_framebuffer_update_t *fbu = buf;
    … …  
    523523        rfb_framebuffer_update_to_be(fbu, fbu);
    524524        pos += sizeof(rfb_framebuffer_update_t);
    525        
     525
    526526        rfb_rectangle_t *rect = pos;
    527527        pos += sizeof(rfb_rectangle_t);
    528        
     528
    529529        *rect = rfb->damage_rect;
    530        
     530
    531531        if (rfb->supports_trle) {
    532532                rect->enctype = RFB_ENCODING_TRLE;
    … …  
    538538        }
    539539        rfb_rectangle_to_be(rect, rect);
    540        
     540
    541541        rfb->damage_valid = false;
    542        
     542
    543543        size_t send_palette_size = 0;
    544544        void *send_palette = NULL;
    545        
     545
    546546        if (!rfb->pixel_format.true_color) {
    547547                send_palette = rfb_send_palette_message(rfb, &send_palette_size);
    … …  
    552552                }
    553553        }
    554        
     554
    555555        fibril_mutex_unlock(&rfb->lock);
    556        
     556
    557557        if (!rfb->pixel_format.true_color) {
    558558                errno_t rc = tcp_conn_send(conn, send_palette, send_palette_size);
    … …  
    562562                }
    563563        }
    564        
     564
    565565        errno_t rc = tcp_conn_send(conn, buf, buf_size);
    566566        free(buf);
    567        
     567
    568568        return rc;
    569569}
    … …  
    605605                return;
    606606        }
    607        
     607
    608608        char client_version[12];
    609609        rc = recv_chars(conn, client_version, 12);
    … …  
    613613                return;
    614614        }
    615        
     615
    616616        if (memcmp(client_version, "RFB 003.008\n", 12) != 0) {
    617617                log_msg(LOG_DEFAULT, LVL_WARN, "Client version is not RFB 3.8");
    618618                return;
    619619        }
    620        
     620
    621621        /* Security handshake
    622622         * 1 security type supported, which is 1 - None
    … …  
    631631                return;
    632632        }
    633        
     633
    634634        char selected_sec_type = 0;
    635635        rc = recv_char(conn, &selected_sec_type);
    … …  
    651651                return;
    652652        }
    653        
     653
    654654        /* Client init */
    655655        char shared_flag;
    … …  
    660660                return;
    661661        }
    662        
     662
    663663        /* Server init */
    664664        fibril_mutex_lock(&rfb->lock);
    … …  
    684684                return;
    685685        }
    686        
     686
    687687        while (true) {
    688688                char message_type = 0;
    … …  
    693693                        return;
    694694                }
    695                
     695
    696696                rfb_set_pixel_format_t spf;
    697697                rfb_set_encodings_t se;
    … …  
    765765        inet_ep_t ep;
    766766        errno_t rc;
    767        
     767
    768768        rc = tcp_create(&tcp);
    769769        if (rc != EOK) {
    … …  
    771771                goto error;
    772772        }
    773        
     773
    774774        inet_ep_init(&ep);
    775775        ep.port = port;
    776        
     776
    777777        rc = tcp_listener_create(tcp, &ep, &listen_cb, rfb, &conn_cb, rfb,
    778778            &lst);
    … …  
    781781                goto error;
    782782        }
    783        
     783
    784784        rfb->tcp = tcp;
    785785        rfb->lst = lst;
    786        
     786
    787787        return EOK;
    788788error:
Note: See TracChangeset for help on using the changeset viewer.