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


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.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • 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.