commit 986eac0a988e29c075ca875e8a45234cd1a38d7a · pci.express/flanterm.zig

+32 -49

backends/fb.c

···

       444
        
               return;

     

       445
        
           }

     

       446
        
       

     

       447
       -
       #ifdef FLANTERM_FB_DISABLE_CANVAS

     

       448
        
           uint32_t default_bg = ctx->default_bg;

     

       449
       -
       #endif

     

       450
        
       

     

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

     

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

     
···

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

     

       457
        
               uint8_t fy = gy / ctx->font_scale_y;

     

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

     

       459
       -
       

     

       460
       -
       #ifndef FLANTERM_FB_DISABLE_CANVAS

     

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

     

       462
       -
       #endif

     

       463
       -
       

     

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

     

       465
        
                   bool draw = glyph[fy * ctx->font_width + fx];

     

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

     

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

     

       468
       -
       #ifndef FLANTERM_FB_DISABLE_CANVAS

     

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

     

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

     

       471
       -
       #else

     

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

     

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

     

       474
       -
       #endif

     

       0
        
       
     

       475
        
                       fb_line[gx] = draw ? fg : bg;

     

       476
        
                   }

     

       477
        
               }

     
···

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

     

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

     

       491
        
       

     

       492
       -
       #ifdef FLANTERM_FB_DISABLE_CANVAS

     

       493
        
           uint32_t default_bg = ctx->default_bg;

     

       494
       -
       #endif

     

       495
        
       

     

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

     

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

     

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

     

       499
        
               uint8_t fy = gy / ctx->font_scale_y;

     

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

     

       501
       -
       #ifndef FLANTERM_FB_DISABLE_CANVAS

     

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

     

       503
       -
       #endif

     

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

     

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

     

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

     
···

       508
        
                       continue;

     

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

     

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

     

       511
       -
       #ifndef FLANTERM_FB_DISABLE_CANVAS

     

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

     

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

     

       514
       -
       #else

     

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

     

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

     

       517
       -
       #endif

     

       0
        
       
     

       518
        
                       fb_line[gx] = new_draw ? fg : bg;

     

       519
        
                   }

     

       520
        
               }

     
···

       819
        
       static void flanterm_fb_full_refresh(struct flanterm_context *_ctx) {

     

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

     

       821
        
       

     

       822
       -
       #ifdef FLANTERM_FB_DISABLE_CANVAS

     

       823
        
           uint32_t default_bg = ctx->default_bg;

     

       824
       -
       #endif

     

       825
        
       

     

       826
        
           for (size_t y = 0; y < ctx->height; y++) {

     

       827
        
               for (size_t x = 0; x < ctx->width; x++) {

     

       828
       -
       #ifndef FLANTERM_FB_DISABLE_CANVAS

     

       829
       -
                   ctx->framebuffer[y * (ctx->pitch / sizeof(uint32_t)) + x] = ctx->canvas[y * ctx->width + x];

     

       830
       -
       #else

     

       831
       -
                   ctx->framebuffer[y * (ctx->pitch / sizeof(uint32_t)) + x] = default_bg;

     

       832
       -
       #endif

     

       833
        
               }

     

       834
        
           }

     

       835
        
       

     
···

       864
        
           _free(ctx->queue, ctx->queue_size);

     

       865
        
           _free(ctx->map, ctx->map_size);

     

       866
        
       

     

       867
       -
       #ifndef FLANTERM_FB_DISABLE_CANVAS

     

       868
       -
           _free(ctx->canvas, ctx->canvas_size);

     

       869
       -
       #endif

     

       870
        
       

     

       871
        
           _free(ctx, sizeof(struct flanterm_fb_context));

     

       872
        
       }

     
···

       878
        
           uint8_t red_mask_size, uint8_t red_mask_shift,

     

       879
        
           uint8_t green_mask_size, uint8_t green_mask_shift,

     

       880
        
           uint8_t blue_mask_size, uint8_t blue_mask_shift,

     

       881
       -
       #ifndef FLANTERM_FB_DISABLE_CANVAS

     

       882
        
           uint32_t *canvas,

     

       883
       -
       #endif

     

       884
        
           uint32_t *ansi_colours, uint32_t *ansi_bright_colours,

     

       885
        
           uint32_t *default_bg, uint32_t *default_fg,

     

       886
        
           uint32_t *default_bg_bright, uint32_t *default_fg_bright,

     
···

       921
        
                   width = width_limit;

     

       922
        
                   height = height_limit;

     

       923
        
               }

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       924
        
       #else

     

       925
        
               return NULL;

     

       926
        
       #endif

     
···

       1104
        
           }

     

       1105
        
           memset(ctx->map, 0, ctx->map_size);

     

       1106
        
       

     

       1107
       -
       #ifndef FLANTERM_FB_DISABLE_CANVAS

     

       1108
       -
           ctx->canvas_size = ctx->width * ctx->height * sizeof(uint32_t);

     

       1109
       -
           ctx->canvas = _malloc(ctx->canvas_size);

     

       1110
       -
           if (ctx->canvas == NULL) {

     

       1111
       -
               goto fail;

     

       1112
       -
           }

     

       1113
        
           if (canvas != NULL) {

     

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

     

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

     

       0
        
       
     

       0
        
       
     

       1116
        
               }

     

       1117
       -
           } else {

     

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

     

       1119
       -
                   ctx->canvas[i] = ctx->default_bg;

     

       1120
        
               }

     

       1121
        
           }

     

       1122
       -
       #endif

     

       1123
        
       

     

       1124
        
           _ctx->raw_putchar = flanterm_fb_raw_putchar;

     

       1125
        
           _ctx->clear = flanterm_fb_clear;

     
···

       1168
        
               return NULL;

     

       1169
        
           }

     

       1170
        
       

     

       1171
       -
       #ifndef FLANTERM_FB_DISABLE_CANVAS

     

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

     

       1173
        
               _free(ctx->canvas, ctx->canvas_size);

     

       1174
        
           }

     

       1175
       -
       #endif

     

       1176
        
           if (ctx->map != NULL) {

     

       1177
        
               _free(ctx->map, ctx->map_size);

     

       1178
        
           }

···

       444
        
               return;

     

       445
        
           }

     

       446
        
       

     

       0
        
       
     

       447
        
           uint32_t default_bg = ctx->default_bg;

     

       0
        
       
     

       448
        
       

     

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

     

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

     
···

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

     

       455
        
               uint8_t fy = gy / ctx->font_scale_y;

     

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

     

       0
        
       
     

       0
        
       
     

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

     

       0
        
       
     

       0
        
       
     

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

     

       459
        
                   bool draw = glyph[fy * ctx->font_width + fx];

     

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

     

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

     

       462
       +
                       uint32_t bg, fg;

     

       463
       +
                       if (ctx->canvas != NULL) {

     

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

     

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

     

       466
       +
                       } else {

     

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

     

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

     

       469
       +
                       }

     

       470
        
                       fb_line[gx] = draw ? fg : bg;

     

       471
        
                   }

     

       472
        
               }

     
···

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

     

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

     

       486
        
       

     

       0
        
       
     

       487
        
           uint32_t default_bg = ctx->default_bg;

     

       0
        
       
     

       488
        
       

     

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

     

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

     

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

     

       492
        
               uint8_t fy = gy / ctx->font_scale_y;

     

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

     

       0
        
       
     

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

     

       0
        
       
     

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

     

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

     

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

     
···

       499
        
                       continue;

     

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

     

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

     

       502
       +
                       uint32_t bg, fg;

     

       503
       +
                       if (ctx->canvas != NULL) {

     

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

     

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

     

       506
       +
                       } else {

     

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

     

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

     

       509
       +
                       }

     

       510
        
                       fb_line[gx] = new_draw ? fg : bg;

     

       511
        
                   }

     

       512
        
               }

     
···

       811
        
       static void flanterm_fb_full_refresh(struct flanterm_context *_ctx) {

     

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

     

       813
        
       

     

       0
        
       
     

       814
        
           uint32_t default_bg = ctx->default_bg;

     

       0
        
       
     

       815
        
       

     

       816
        
           for (size_t y = 0; y < ctx->height; y++) {

     

       817
        
               for (size_t x = 0; x < ctx->width; x++) {

     

       818
       +
                   if (ctx->canvas != NULL) {

     

       819
       +
                       ctx->framebuffer[y * (ctx->pitch / sizeof(uint32_t)) + x] = ctx->canvas[y * ctx->width + x];

     

       820
       +
                   } else {

     

       821
       +
                       ctx->framebuffer[y * (ctx->pitch / sizeof(uint32_t)) + x] = default_bg;

     

       822
       +
                   }

     

       823
        
               }

     

       824
        
           }

     

       825
        
       

     
···

       854
        
           _free(ctx->queue, ctx->queue_size);

     

       855
        
           _free(ctx->map, ctx->map_size);

     

       856
        
       

     

       857
       +
           if (ctx->canvas != NULL) {

     

       858
       +
               _free(ctx->canvas, ctx->canvas_size);

     

       859
       +
           }

     

       860
        
       

     

       861
        
           _free(ctx, sizeof(struct flanterm_fb_context));

     

       862
        
       }

     
···

       868
        
           uint8_t red_mask_size, uint8_t red_mask_shift,

     

       869
        
           uint8_t green_mask_size, uint8_t green_mask_shift,

     

       870
        
           uint8_t blue_mask_size, uint8_t blue_mask_shift,

     

       0
        
       
     

       871
        
           uint32_t *canvas,

     

       0
        
       
     

       872
        
           uint32_t *ansi_colours, uint32_t *ansi_bright_colours,

     

       873
        
           uint32_t *default_bg, uint32_t *default_fg,

     

       874
        
           uint32_t *default_bg_bright, uint32_t *default_fg_bright,

     
···

       909
        
                   width = width_limit;

     

       910
        
                   height = height_limit;

     

       911
        
               }

     

       912
       +
       

     

       913
       +
               // Force disable canvas

     

       914
       +
               canvas = NULL;

     

       915
        
       #else

     

       916
        
               return NULL;

     

       917
        
       #endif

     
···

       1095
        
           }

     

       1096
        
           memset(ctx->map, 0, ctx->map_size);

     

       1097
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1098
        
           if (canvas != NULL) {

     

       1099
       +
               ctx->canvas_size = ctx->width * ctx->height * sizeof(uint32_t);

     

       1100
       +
               ctx->canvas = _malloc(ctx->canvas_size);

     

       1101
       +
               if (ctx->canvas == NULL) {

     

       1102
       +
                   goto fail;

     

       1103
        
               }

     

       0
        
       
     

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

     

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

     

       1106
        
               }

     

       1107
        
           }

     

       0
        
       
     

       1108
        
       

     

       1109
        
           _ctx->raw_putchar = flanterm_fb_raw_putchar;

     

       1110
        
           _ctx->clear = flanterm_fb_clear;

     
···

       1153
        
               return NULL;

     

       1154
        
           }

     

       1155
        
       

     

       0
        
       
     

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

     

       1157
        
               _free(ctx->canvas, ctx->canvas_size);

     

       1158
        
           }

     

       0
        
       
     

       1159
        
           if (ctx->map != NULL) {

     

       1160
        
               _free(ctx->map, ctx->map_size);

     

       1161
        
           }

+1 -9

backends/fb.h

···

       36
        
       

     

       37
        
       #include "../flanterm.h"

     

       38
        
       

     

       39
       -
       #ifndef FLANTERM_FB_DISABLE_BUMP_ALLOC

     

       40
       -
       #  define FLANTERM_FB_DISABLE_CANVAS 1

     

       41
       -
       #endif

     

       42
       -
       

     

       43
        
       #define FLANTERM_FB_FONT_GLYPHS 256

     

       44
        
       

     

       45
        
       struct flanterm_fb_char {

     
···

       86
        
           uint32_t default_fg, default_bg;

     

       87
        
           uint32_t default_fg_bright, default_bg_bright;

     

       88
        
       

     

       89
       -
       #ifndef FLANTERM_FB_DISABLE_CANVAS

     

       90
        
           size_t canvas_size;

     

       91
        
           uint32_t *canvas;

     

       92
       -
       #endif

     

       93
        
       

     

       94
        
           size_t grid_size;

     

       95
        
           size_t queue_size;

     
···

       124
        
           uint8_t red_mask_size, uint8_t red_mask_shift,

     

       125
        
           uint8_t green_mask_size, uint8_t green_mask_shift,

     

       126
        
           uint8_t blue_mask_size, uint8_t blue_mask_shift,

     

       127
       -
       #ifndef FLANTERM_FB_DISABLE_CANVAS

     

       128
       -
           uint32_t *canvas,

     

       129
       -
       #endif

     

       130
        
           uint32_t *ansi_colours, uint32_t *ansi_bright_colours, // If nulled, default.

     

       131
        
           uint32_t *default_bg, uint32_t *default_fg, // If nulled, default.

     

       132
        
           uint32_t *default_bg_bright, uint32_t *default_fg_bright, // If nulled, default.

···

       36
        
       

     

       37
        
       #include "../flanterm.h"

     

       38
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       39
        
       #define FLANTERM_FB_FONT_GLYPHS 256

     

       40
        
       

     

       41
        
       struct flanterm_fb_char {

     
···

       82
        
           uint32_t default_fg, default_bg;

     

       83
        
           uint32_t default_fg_bright, default_bg_bright;

     

       84
        
       

     

       0
        
       
     

       85
        
           size_t canvas_size;

     

       86
        
           uint32_t *canvas;

     

       0
        
       
     

       87
        
       

     

       88
        
           size_t grid_size;

     

       89
        
           size_t queue_size;

     
···

       118
        
           uint8_t red_mask_size, uint8_t red_mask_shift,

     

       119
        
           uint8_t green_mask_size, uint8_t green_mask_shift,

     

       120
        
           uint8_t blue_mask_size, uint8_t blue_mask_shift,

     

       121
       +
           uint32_t *canvas, // If nulled, no canvas.

     

       0
        
       
     

       0
        
       
     

       122
        
           uint32_t *ansi_colours, uint32_t *ansi_bright_colours, // If nulled, default.

     

       123
        
           uint32_t *default_bg, uint32_t *default_fg, // If nulled, default.

     

       124
        
           uint32_t *default_bg_bright, uint32_t *default_fg_bright, // If nulled, default.