commit a6f6edd6631c01caab932a59dce97bbd5f0c72c8 · pci.express/flanterm.zig

+68 -63

backends/fb.c

···

       437
        
           ctx->text_fg = tmp;

     

       438
        
       }

     

       439
        
       

     

       440
       -
       /* Unscaled code path if font_scale_{x,y} == 1 */

     

       441
       -
       static void plot_char_unscaled(struct flanterm_fb_context *ctx, struct flanterm_fb_char *c, size_t x, size_t y) {

     

       442
       -
           uint32_t default_bg = ctx->default_bg;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       443
        
       

     

       444
        
           x = ctx->offset_x + x * ctx->glyph_width;

     

       445
        
           y = ctx->offset_y + y * ctx->glyph_height;

     
···

       447
        
           bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width];

     

       448
        
           // naming: fx,fy for font coordinates, gx,gy for glyph coordinates

     

       449
        
           for (size_t gy = 0; gy < ctx->glyph_height; gy++) {

     

       0
        
       
     

       450
        
               volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4);

     

       451
        
               uint32_t *canvas_line = ctx->canvas + x + (y + gy) * ctx->width;

     

       452
       -
               bool *glyph_pointer = glyph + (gy * ctx->font_width);

     

       453
        
               for (size_t fx = 0; fx < ctx->font_width; fx++) {

     

       454
       -
                   uint32_t bg, fg;

     

       455
       -
                   if (ctx->canvas != NULL) {

     

       456
       -
                       bg = c->bg == 0xffffffff ? canvas_line[fx] : c->bg;

     

       457
       -
                       fg = c->fg == 0xffffffff ? canvas_line[fx] : c->fg;

     

       458
       -
                   } else {

     

       459
       -
                       bg = c->bg == 0xffffffff ? default_bg : c->bg;

     

       460
       -
                       fg = c->fg == 0xffffffff ? default_bg : c->fg;

     

       461
        
                   }

     

       462
       -
                   fb_line[fx] = *(glyph_pointer++) ? fg : bg;

     

       463
        
               }

     

       464
        
           }

     

       465
        
       }

     

       466
        
       

     

       467
       -
       static void plot_char(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) {

     

       468
        
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       469
        
       

     

       470
        
           if (x >= _ctx->cols || y >= _ctx->rows) {

     

       471
       -
               return;

     

       472
       -
           }

     

       473
       -
       

     

       474
       -
           if(ctx->font_scale_x == 1 && ctx->font_scale_y == 1) {

     

       475
       -
               plot_char_unscaled(ctx, c, x, y);

     

       476
        
               return;

     

       477
        
           }

     

       478
        
       

     

       479
        
           uint32_t default_bg = ctx->default_bg;

     

       480
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       481
        
           x = ctx->offset_x + x * ctx->glyph_width;

     

       482
        
           y = ctx->offset_y + y * ctx->glyph_height;

     

       483
        
       

     
···

       486
        
           for (size_t gy = 0; gy < ctx->glyph_height; gy++) {

     

       487
        
               uint8_t fy = gy / ctx->font_scale_y;

     

       488
        
               volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4);

     

       489
       -
               uint32_t *canvas_line = ctx->canvas + x + (y + gy) * ctx->width;

     

       490
        
               bool *glyph_pointer = glyph + (fy * ctx->font_width);

     

       491
        
               for (size_t fx = 0; fx < ctx->font_width; fx++) {

     

       492
        
                   for (size_t i = 0; i < ctx->font_scale_x; i++) {

     

       493
        
                       size_t gx = ctx->font_scale_x * fx + i;

     

       494
       -
                       uint32_t bg, fg;

     

       495
       -
                       if (ctx->canvas != NULL) {

     

       496
       -
                           bg = c->bg == 0xffffffff ? canvas_line[gx] : c->bg;

     

       497
       -
                           fg = c->fg == 0xffffffff ? canvas_line[gx] : c->fg;

     

       498
       -
                       } else {

     

       499
       -
                           bg = c->bg == 0xffffffff ? default_bg : c->bg;

     

       500
       -
                           fg = c->fg == 0xffffffff ? default_bg : c->fg;

     

       501
       -
                       }

     

       502
        
                       fb_line[gx] = *glyph_pointer ? fg : bg;

     

       503
        
                   }

     

       504
        
                   glyph_pointer++;

     
···

       506
        
           }

     

       507
        
       }

     

       508
        
       

     

       509
       -
       #ifdef FLANTERM_FB_ENABLE_MASKING

     

       510
       -
       static void plot_char_masked(struct flanterm_context *_ctx, struct flanterm_fb_char *old, struct flanterm_fb_char *c, size_t x, size_t y) {

     

       511
        
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       512
        
       

     

       513
        
           if (x >= _ctx->cols || y >= _ctx->rows) {

     
···

       517
        
           x = ctx->offset_x + x * ctx->glyph_width;

     

       518
        
           y = ctx->offset_y + y * ctx->glyph_height;

     

       519
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       520
        
           uint32_t default_bg = ctx->default_bg;

     

       521
        
       

     

       522
       -
           bool *new_glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width];

     

       523
       -
           bool *old_glyph = &ctx->font_bool[old->c * ctx->font_height * ctx->font_width];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       524
        
           for (size_t gy = 0; gy < ctx->glyph_height; gy++) {

     

       525
       -
               uint8_t fy = gy / ctx->font_scale_y;

     

       526
        
               volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4);

     

       527
       -
               uint32_t *canvas_line = ctx->canvas + x + (y + gy) * ctx->width;

     

       528
        
               for (size_t fx = 0; fx < ctx->font_width; fx++) {

     

       529
       -
                   bool old_draw = old_glyph[fy * ctx->font_width + fx];

     

       530
       -
                   bool new_draw = new_glyph[fy * ctx->font_width + fx];

     

       531
       -
                   if (old_draw == new_draw)

     

       532
       -
                       continue;

     

       533
       -
                   for (size_t i = 0; i < ctx->font_scale_x; i++) {

     

       534
       -
                       size_t gx = ctx->font_scale_x * fx + i;

     

       535
       -
                       uint32_t bg, fg;

     

       536
       -
                       if (ctx->canvas != NULL) {

     

       537
       -
                           bg = c->bg == 0xffffffff ? canvas_line[gx] : c->bg;

     

       538
       -
                           fg = c->fg == 0xffffffff ? canvas_line[gx] : c->fg;

     

       539
       -
                       } else {

     

       540
       -
                           bg = c->bg == 0xffffffff ? default_bg : c->bg;

     

       541
       -
                           fg = c->fg == 0xffffffff ? default_bg : c->fg;

     

       542
       -
                       }

     

       543
       -
                       fb_line[gx] = new_draw ? fg : bg;

     

       544
       -
                   }

     

       545
        
               }

     

       546
        
           }

     

       547
        
       }

     

       548
       -
       #endif

     

       549
        
       

     

       550
        
       static inline bool compare_char(struct flanterm_fb_char *a, struct flanterm_fb_char *b) {

     

       551
        
           return !(a->c != b->c || a->bg != b->bg || a->fg != b->fg);

     
···

       773
        
           uint32_t tmp = c.fg;

     

       774
        
           c.fg = c.bg;

     

       775
        
           c.bg = tmp;

     

       776
       -
           plot_char(_ctx, &c, ctx->cursor_x, ctx->cursor_y);

     

       777
        
           if (q != NULL) {

     

       778
        
               ctx->grid[i] = q->c;

     

       779
        
               ctx->map[i] = NULL;

     
···

       793
        
               if (ctx->map[offset] == NULL) {

     

       794
        
                   continue;

     

       795
        
               }

     

       796
       -
               #ifdef FLANTERM_FB_ENABLE_MASKING

     

       797
       -
                   struct flanterm_fb_char *old = &ctx->grid[offset];

     

       798
       -
                   if (q->c.bg == old->bg && q->c.fg == old->fg) {

     

       799
       -
                       plot_char_masked(_ctx, old, &q->c, q->x, q->y);

     

       800
       -
                   } else {

     

       801
       -
                       plot_char(_ctx, &q->c, q->x, q->y);

     

       802
       -
                   }

     

       803
       -
               #else

     

       804
       -
                   plot_char(_ctx, &q->c, q->x, q->y);

     

       805
       -
               #endif

     

       806
        
               ctx->grid[offset] = q->c;

     

       807
        
               ctx->map[offset] = NULL;

     

       808
        
           }

     

       809
        
       

     

       810
        
           if ((ctx->old_cursor_x != ctx->cursor_x || ctx->old_cursor_y != ctx->cursor_y) || _ctx->cursor_enabled == false) {

     

       811
        
               if (ctx->old_cursor_x < _ctx->cols && ctx->old_cursor_y < _ctx->rows) {

     

       812
       -
                   plot_char(_ctx, &ctx->grid[ctx->old_cursor_x + ctx->old_cursor_y * _ctx->cols], ctx->old_cursor_x, ctx->old_cursor_y);

     

       813
        
               }

     

       814
        
           }

     

       815
        
       

     
···

       860
        
               size_t x = i % _ctx->cols;

     

       861
        
               size_t y = i / _ctx->cols;

     

       862
        
       

     

       863
       -
               plot_char(_ctx, &ctx->grid[i], x, y);

     

       864
        
           }

     

       865
        
       

     

       866
        
           if (_ctx->cursor_enabled) {

     
···

       1136
        
               }

     

       1137
        
               for (size_t i = 0; i < ctx->width * ctx->height; i++) {

     

       1138
        
                   ctx->canvas[i] = convert_colour(_ctx, canvas[i]);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1139
        
               }

     

       1140
        
           }

     

       1141

···

       437
        
           ctx->text_fg = tmp;

     

       438
        
       }

     

       439
        
       

     

       440
       +
       static void plot_char_scaled_canvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) {

     

       441
       +
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       442
       +
       

     

       443
       +
           if (x >= _ctx->cols || y >= _ctx->rows) {

     

       444
       +
               return;

     

       445
       +
           }

     

       446
        
       

     

       447
        
           x = ctx->offset_x + x * ctx->glyph_width;

     

       448
        
           y = ctx->offset_y + y * ctx->glyph_height;

     
···

       450
        
           bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width];

     

       451
        
           // naming: fx,fy for font coordinates, gx,gy for glyph coordinates

     

       452
        
           for (size_t gy = 0; gy < ctx->glyph_height; gy++) {

     

       453
       +
               uint8_t fy = gy / ctx->font_scale_y;

     

       454
        
               volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4);

     

       455
        
               uint32_t *canvas_line = ctx->canvas + x + (y + gy) * ctx->width;

     

       456
       +
               bool *glyph_pointer = glyph + (fy * ctx->font_width);

     

       457
        
               for (size_t fx = 0; fx < ctx->font_width; fx++) {

     

       458
       +
                   for (size_t i = 0; i < ctx->font_scale_x; i++) {

     

       459
       +
                       size_t gx = ctx->font_scale_x * fx + i;

     

       460
       +
                       uint32_t bg = c->bg == 0xffffffff ? canvas_line[gx] : c->bg;

     

       461
       +
                       uint32_t fg = c->fg == 0xffffffff ? canvas_line[gx] : c->fg;

     

       462
       +
                       fb_line[gx] = *glyph_pointer ? fg : bg;

     

       0
        
       
     

       0
        
       
     

       463
        
                   }

     

       464
       +
                   glyph_pointer++;

     

       465
        
               }

     

       466
        
           }

     

       467
        
       }

     

       468
        
       

     

       469
       +
       static void plot_char_scaled_uncanvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) {

     

       470
        
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       471
        
       

     

       472
        
           if (x >= _ctx->cols || y >= _ctx->rows) {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       473
        
               return;

     

       474
        
           }

     

       475
        
       

     

       476
        
           uint32_t default_bg = ctx->default_bg;

     

       477
        
       

     

       478
       +
           uint32_t bg = c->bg == 0xffffffff ? default_bg : c->bg;

     

       479
       +
           uint32_t fg = c->fg == 0xffffffff ? default_bg : c->fg;

     

       480
       +
       

     

       481
        
           x = ctx->offset_x + x * ctx->glyph_width;

     

       482
        
           y = ctx->offset_y + y * ctx->glyph_height;

     

       483
        
       

     
···

       486
        
           for (size_t gy = 0; gy < ctx->glyph_height; gy++) {

     

       487
        
               uint8_t fy = gy / ctx->font_scale_y;

     

       488
        
               volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4);

     

       0
        
       
     

       489
        
               bool *glyph_pointer = glyph + (fy * ctx->font_width);

     

       490
        
               for (size_t fx = 0; fx < ctx->font_width; fx++) {

     

       491
        
                   for (size_t i = 0; i < ctx->font_scale_x; i++) {

     

       492
        
                       size_t gx = ctx->font_scale_x * fx + i;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       493
        
                       fb_line[gx] = *glyph_pointer ? fg : bg;

     

       494
        
                   }

     

       495
        
                   glyph_pointer++;

     
···

       497
        
           }

     

       498
        
       }

     

       499
        
       

     

       500
       +
       static void plot_char_unscaled_canvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) {

     

       0
        
       
     

       501
        
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       502
        
       

     

       503
        
           if (x >= _ctx->cols || y >= _ctx->rows) {

     
···

       507
        
           x = ctx->offset_x + x * ctx->glyph_width;

     

       508
        
           y = ctx->offset_y + y * ctx->glyph_height;

     

       509
        
       

     

       510
       +
           bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width];

     

       511
       +
           // naming: fx,fy for font coordinates, gx,gy for glyph coordinates

     

       512
       +
           for (size_t gy = 0; gy < ctx->glyph_height; gy++) {

     

       513
       +
               volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4);

     

       514
       +
               uint32_t *canvas_line = ctx->canvas + x + (y + gy) * ctx->width;

     

       515
       +
               bool *glyph_pointer = glyph + (gy * ctx->font_width);

     

       516
       +
               for (size_t fx = 0; fx < ctx->font_width; fx++) {

     

       517
       +
                   uint32_t bg = c->bg == 0xffffffff ? canvas_line[fx] : c->bg;

     

       518
       +
                   uint32_t fg = c->fg == 0xffffffff ? canvas_line[fx] : c->fg;

     

       519
       +
                   fb_line[fx] = *(glyph_pointer++) ? fg : bg;

     

       520
       +
               }

     

       521
       +
           }

     

       522
       +
       }

     

       523
       +
       

     

       524
       +
       static void plot_char_unscaled_uncanvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) {

     

       525
       +
           struct flanterm_fb_context *ctx = (void *)_ctx;

     

       526
       +
       

     

       527
       +
           if (x >= _ctx->cols || y >= _ctx->rows) {

     

       528
       +
               return;

     

       529
       +
           }

     

       530
       +
       

     

       531
        
           uint32_t default_bg = ctx->default_bg;

     

       532
        
       

     

       533
       +
           uint32_t bg = c->bg == 0xffffffff ? default_bg : c->bg;

     

       534
       +
           uint32_t fg = c->fg == 0xffffffff ? default_bg : c->fg;

     

       535
       +
       

     

       536
       +
           x = ctx->offset_x + x * ctx->glyph_width;

     

       537
       +
           y = ctx->offset_y + y * ctx->glyph_height;

     

       538
       +
       

     

       539
       +
           bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width];

     

       540
       +
           // naming: fx,fy for font coordinates, gx,gy for glyph coordinates

     

       541
        
           for (size_t gy = 0; gy < ctx->glyph_height; gy++) {

     

       0
        
       
     

       542
        
               volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4);

     

       543
       +
               bool *glyph_pointer = glyph + (gy * ctx->font_width);

     

       544
        
               for (size_t fx = 0; fx < ctx->font_width; fx++) {

     

       545
       +
                   fb_line[fx] = *(glyph_pointer++) ? fg : bg;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       546
        
               }

     

       547
        
           }

     

       548
        
       }

     

       0
        
       
     

       549
        
       

     

       550
        
       static inline bool compare_char(struct flanterm_fb_char *a, struct flanterm_fb_char *b) {

     

       551
        
           return !(a->c != b->c || a->bg != b->bg || a->fg != b->fg);

     
···

       773
        
           uint32_t tmp = c.fg;

     

       774
        
           c.fg = c.bg;

     

       775
        
           c.bg = tmp;

     

       776
       +
           ctx->plot_char(_ctx, &c, ctx->cursor_x, ctx->cursor_y);

     

       777
        
           if (q != NULL) {

     

       778
        
               ctx->grid[i] = q->c;

     

       779
        
               ctx->map[i] = NULL;

     
···

       793
        
               if (ctx->map[offset] == NULL) {

     

       794
        
                   continue;

     

       795
        
               }

     

       796
       +
               ctx->plot_char(_ctx, &q->c, q->x, q->y);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       797
        
               ctx->grid[offset] = q->c;

     

       798
        
               ctx->map[offset] = NULL;

     

       799
        
           }

     

       800
        
       

     

       801
        
           if ((ctx->old_cursor_x != ctx->cursor_x || ctx->old_cursor_y != ctx->cursor_y) || _ctx->cursor_enabled == false) {

     

       802
        
               if (ctx->old_cursor_x < _ctx->cols && ctx->old_cursor_y < _ctx->rows) {

     

       803
       +
                   ctx->plot_char(_ctx, &ctx->grid[ctx->old_cursor_x + ctx->old_cursor_y * _ctx->cols], ctx->old_cursor_x, ctx->old_cursor_y);

     

       804
        
               }

     

       805
        
           }

     

       806
        
       

     
···

       851
        
               size_t x = i % _ctx->cols;

     

       852
        
               size_t y = i / _ctx->cols;

     

       853
        
       

     

       854
       +
               ctx->plot_char(_ctx, &ctx->grid[i], x, y);

     

       855
        
           }

     

       856
        
       

     

       857
        
           if (_ctx->cursor_enabled) {

     
···

       1127
        
               }

     

       1128
        
               for (size_t i = 0; i < ctx->width * ctx->height; i++) {

     

       1129
        
                   ctx->canvas[i] = convert_colour(_ctx, canvas[i]);

     

       1130
       +
               }

     

       1131
       +
           }

     

       1132
       +
       

     

       1133
       +
           if (font_scale_x == 1 && font_scale_y == 1) {

     

       1134
       +
               if (canvas == NULL) {

     

       1135
       +
                   ctx->plot_char = plot_char_unscaled_uncanvas;

     

       1136
       +
               } else {

     

       1137
       +
                   ctx->plot_char = plot_char_unscaled_canvas;

     

       1138
       +
               }

     

       1139
       +
           } else {

     

       1140
       +
               if (canvas == NULL) {

     

       1141
       +
                   ctx->plot_char = plot_char_scaled_uncanvas;

     

       1142
       +
               } else {

     

       1143
       +
                   ctx->plot_char = plot_char_scaled_canvas;

     

       1144
        
               }

     

       1145
        
           }

     

       1146

backends/fb.h

···

       52
        
       struct flanterm_fb_context {

     

       53
        
           struct flanterm_context term;

     

       54
        
       

     

       0
        
       
     

       0
        
       
     

       55
        
           size_t font_width;

     

       56
        
           size_t font_height;

     

       57
        
           size_t glyph_width;

···

       52
        
       struct flanterm_fb_context {

     

       53
        
           struct flanterm_context term;

     

       54
        
       

     

       55
       +
           void (*plot_char)(struct flanterm_context *ctx, struct flanterm_fb_char *c, size_t x, size_t y);

     

       56
       +
       

     

       57
        
           size_t font_width;

     

       58
        
           size_t font_height;

     

       59
        
           size_t glyph_width;