Archives
/
notcurses
mirror of https://github.com/dankamongmen/notcurses
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[visual] c++ to c #1421

Browse Source
pull/1427/head
nick black 3 years ago
parent 7d72b69f1d
commit 252826245d
No known key found for this signature in database
GPG Key ID: 5F43400C21CBFACC
2 changed files with 98 additions and 100 deletions
Show Stats Download Patch File Download Diff File

2
src/lib/internal.h
Unescape Escape View File

@ -890,7 +890,7 @@ void nclog(const char* fmt, ...);
bool is_linux_console(const notcurses* nc, unsigned no_font_changes); bool is_linux_console(const notcurses* nc, unsigned no_font_changes);
// get a file descriptor for the controlling tty device, -1 on error // get a file descriptor for the controlling tty device, -1 on error
int get_controlling_tty(void); int get_controlling_tty(FILE* fp);
// logging // logging
#define logerror(nc, fmt, ...) do{ \ #define logerror(nc, fmt, ...) do{ \

196
src/lib/visual.cpp → src/lib/visual.c
Unescape Escape View File

@ -1,21 +1,21 @@
#include <cmath> #include <math.h>
#include <cstring> #include <string.h>
#include "builddef.h" #include "builddef.h"
#include "visual-details.h" #include "visual-details.h"
#include "internal.h" #include "internal.h"
const ncvisual_implementation* visual_implementation = nullptr; const ncvisual_implementation* visual_implementation = NULL;
auto ncvisual_decode(ncvisual* nc) -> int { int ncvisual_decode(ncvisual* nc){
if(!visual_implementation){ if(!visual_implementation){
return -1; return -1;
} }
return visual_implementation->visual_decode(nc); return visual_implementation->visual_decode(nc);
} }
auto ncvisual_blit(ncvisual* ncv, int rows, int cols, ncplane* n, int ncvisual_blit(ncvisual* ncv, int rows, int cols, ncplane* n,
const struct blitset* bset, int begy, int begx, const struct blitset* bset, int begy, int begx,
int leny, int lenx, const blitterargs* barg) -> int { int leny, int lenx, const blitterargs* barg){
int ret = -1; int ret = -1;
if(visual_implementation){ if(visual_implementation){
if(visual_implementation->visual_blit(ncv, rows, cols, n, bset, if(visual_implementation->visual_blit(ncv, rows, cols, n, bset,
@ -34,42 +34,44 @@ auto ncvisual_blit(ncvisual* ncv, int rows, int cols, ncplane* n,
// ncv constructors other than ncvisual_from_file() need to set up the // ncv constructors other than ncvisual_from_file() need to set up the
// AVFrame* 'frame' according to their own data, which is assumed to // AVFrame* 'frame' according to their own data, which is assumed to
// have been prepared already in 'ncv'. // have been prepared already in 'ncv'.
auto ncvisual_details_seed(struct ncvisual* ncv) -> void { void ncvisual_details_seed(struct ncvisual* ncv){
if(visual_implementation){ if(visual_implementation){
visual_implementation->visual_details_seed(ncv); visual_implementation->visual_details_seed(ncv);
} }
} }
auto ncvisual_init(int loglevel) -> int { int ncvisual_init(int loglevel){
if(visual_implementation){ if(visual_implementation){
return visual_implementation->visual_init(loglevel); return visual_implementation->visual_init(loglevel);
} }
return 0; return 0;
} }
auto ncvisual_from_file(const char* filename) -> ncvisual* { ncvisual* ncvisual_from_file(const char* filename){
if(!visual_implementation){ if(!visual_implementation){
return nullptr; return NULL;
} }
return visual_implementation->visual_from_file(filename); return visual_implementation->visual_from_file(filename);
} }
auto ncvisual_create(void) -> ncvisual* { ncvisual* ncvisual_create(void){
if(visual_implementation){ if(visual_implementation){
return visual_implementation->visual_create(); return visual_implementation->visual_create();
} }
return new ncvisual{}; ncvisual* ret = malloc(sizeof(*ret));
memset(ret, 0, sizeof(*ret));
return ret;
} }
auto ncvisual_printbanner(const notcurses* nc) -> void { void ncvisual_printbanner(const notcurses* nc){
if(visual_implementation){ if(visual_implementation){
visual_implementation->visual_printbanner(nc); visual_implementation->visual_printbanner(nc);
} }
} }
auto ncvisual_geom(const notcurses* nc, const ncvisual* n, int ncvisual_geom(const notcurses* nc, const ncvisual* n,
const struct ncvisual_options* vopts, const struct ncvisual_options* vopts,
int* y, int* x, int* toy, int* tox) -> int { int* y, int* x, int* toy, int* tox){
const ncscale_e scale = vopts ? vopts->scaling : NCSCALE_NONE; const ncscale_e scale = vopts ? vopts->scaling : NCSCALE_NONE;
ncblitter_e blitfxn; ncblitter_e blitfxn;
if(!vopts || vopts->blitter == NCBLIT_DEFAULT){ if(!vopts || vopts->blitter == NCBLIT_DEFAULT){
@ -112,11 +114,11 @@ auto ncvisual_geom(const notcurses* nc, const ncvisual* n,
return 0; return 0;
} }
auto bgra_to_rgba(const void* data, int rows, int rowstride, int cols) -> void* { void* bgra_to_rgba(const void* data, int rows, int rowstride, int cols){
if(rowstride % 4){ // must be a multiple of 4 bytes if(rowstride % 4){ // must be a multiple of 4 bytes
return nullptr; return NULL;
} }
auto ret = static_cast<uint32_t*>(malloc(rowstride * rows)); uint32_t* ret = malloc(rowstride * rows);
if(ret){ if(ret){
for(int y = 0 ; y < rows ; ++y){ for(int y = 0 ; y < rows ; ++y){
for(int x = 0 ; x < cols ; ++x){ for(int x = 0 ; x < cols ; ++x){
@ -136,8 +138,8 @@ auto bgra_to_rgba(const void* data, int rows, int rowstride, int cols) -> void*
// "real" pixels, where "real" pixels are, by convention, all zeroes. // "real" pixels, where "real" pixels are, by convention, all zeroes.
// Placing this box at offyXoffx relative to the visual will encompass all // Placing this box at offyXoffx relative to the visual will encompass all
// pixels. Returns the area of the box (0 if there are no pixels). // pixels. Returns the area of the box (0 if there are no pixels).
auto ncvisual_bounding_box(const ncvisual* ncv, int* leny, int* lenx, int ncvisual_bounding_box(const ncvisual* ncv, int* leny, int* lenx,
int* offy, int* offx) -> int { int* offy, int* offx){
int trow, lcol = -1, rcol = INT_MAX; // FIXME shouldn't need lcol init int trow, lcol = -1, rcol = INT_MAX; // FIXME shouldn't need lcol init
// first, find the topmost row with a real pixel. if there is no such row, // first, find the topmost row with a real pixel. if there is no such row,
// there are no such pixels. if we find one, we needn't look in this region // there are no such pixels. if we find one, we needn't look in this region
@ -242,8 +244,8 @@ ncvisual_center(const ncvisual* n, int* RESTRICT y, int* RESTRICT x){
// rotate the 0-indexed (origin-indexed) ['y', 'x'] through 'ctheta' and // rotate the 0-indexed (origin-indexed) ['y', 'x'] through 'ctheta' and
// 'stheta' around the centerpoint at ['centy', 'centx']. write the results // 'stheta' around the centerpoint at ['centy', 'centx']. write the results
// back to 'y' and 'x'. // back to 'y' and 'x'.
static auto static void
rotate_point(int* y, int* x, double stheta, double ctheta, int centy, int centx) -> void { rotate_point(int* y, int* x, double stheta, double ctheta, int centy, int centx){
// convert coordinates from origin to left-handed cartesian // convert coordinates from origin to left-handed cartesian
const int convx = *x - centx; const int convx = *x - centx;
const int convy = *y - centy; const int convy = *y - centy;
@ -256,9 +258,9 @@ rotate_point(int* y, int* x, double stheta, double ctheta, int centy, int centx)
// theta radians, enlarging or shrinking it as necessary. returns the area. // theta radians, enlarging or shrinking it as necessary. returns the area.
// 'leny', 'lenx', 'offy', and 'offx' describe the bounding box to be rotated, // 'leny', 'lenx', 'offy', and 'offx' describe the bounding box to be rotated,
// and might all be updated (in either direction). // and might all be updated (in either direction).
static auto static int
rotate_bounding_box(double stheta, double ctheta, int* leny, int* lenx, rotate_bounding_box(double stheta, double ctheta, int* leny, int* lenx,
int* offy, int* offx) -> int { int* offy, int* offx){
//fprintf(stderr, "Incoming bounding box: %dx%d @ %dx%d rotate s(%f) c(%f)\n", *leny, *lenx, *offy, *offx, stheta, ctheta); //fprintf(stderr, "Incoming bounding box: %dx%d @ %dx%d rotate s(%f) c(%f)\n", *leny, *lenx, *offy, *offx, stheta, ctheta);
int xs[4], ys[4]; // x and y locations of rotated coordinates int xs[4], ys[4]; // x and y locations of rotated coordinates
int centy = *leny; int centy = *leny;
@ -306,7 +308,7 @@ rotate_bounding_box(double stheta, double ctheta, int* leny, int* lenx,
return *leny * *lenx; return *leny * *lenx;
} }
auto ncvisual_rotate(ncvisual* ncv, double rads) -> int { int ncvisual_rotate(ncvisual* ncv, double rads){
// done to force conversion into RGBA // done to force conversion into RGBA
int err = ncvisual_resize(ncv, ncv->rows, ncv->cols); int err = ncvisual_resize(ncv, ncv->rows, ncv->cols);
if(err){ if(err){
@ -314,7 +316,7 @@ auto ncvisual_rotate(ncvisual* ncv, double rads) -> int {
} }
assert(ncv->rowstride / 4 >= ncv->cols); assert(ncv->rowstride / 4 >= ncv->cols);
rads = -rads; // we're a left-handed Cartesian rads = -rads; // we're a left-handed Cartesian
if(ncv->data == nullptr){ if(ncv->data == NULL){
return -1; return -1;
} }
int centy, centx; int centy, centx;
@ -341,8 +343,8 @@ auto ncvisual_rotate(ncvisual* ncv, double rads) -> int {
center_box(&bbcenty, &bbcentx); center_box(&bbcenty, &bbcentx);
//fprintf(stderr, "stride: %d height: %d width: %d\n", ncv->rowstride, ncv->rows, ncv->cols); //fprintf(stderr, "stride: %d height: %d width: %d\n", ncv->rowstride, ncv->rows, ncv->cols);
assert(ncv->rowstride / 4 >= ncv->cols); assert(ncv->rowstride / 4 >= ncv->cols);
auto data = static_cast<uint32_t*>(malloc(bbarea * 4)); uint32_t* data = malloc(bbarea * 4);
if(data == nullptr){ if(data == NULL){
return -1; return -1;
} }
memset(data, 0, bbarea * 4); memset(data, 0, bbarea * 4);
@ -369,21 +371,20 @@ auto ncvisual_rotate(ncvisual* ncv, double rads) -> int {
return 0; return 0;
} }
auto ncvisual_from_rgba(const void* rgba, int rows, int rowstride, ncvisual* ncvisual_from_rgba(const void* rgba, int rows, int rowstride, int cols){
int cols) -> ncvisual* {
if(rowstride % 4){ if(rowstride % 4){
return nullptr; return NULL;
} }
ncvisual* ncv = ncvisual_create(); ncvisual* ncv = ncvisual_create();
if(ncv){ if(ncv){
ncv->rowstride = rowstride; ncv->rowstride = rowstride;
ncv->cols = cols; ncv->cols = cols;
ncv->rows = rows; ncv->rows = rows;
auto data = static_cast<uint32_t*>(memdup(rgba, rowstride * ncv->rows)); uint32_t* data = memdup(rgba, rowstride * ncv->rows);
//fprintf(stderr, "COPY US %zu (%d)\n", rowstride * ncv->rows, ncv->rows); //fprintf(stderr, "COPY US %zu (%d)\n", rowstride * ncv->rows, ncv->rows);
if(data == nullptr){ if(data == NULL){
ncvisual_destroy(ncv); ncvisual_destroy(ncv);
return nullptr; return NULL;
} }
//fprintf(stderr, "ROWS: %d STRIDE: %d (%d) COLS: %d\n", rows, rowstride, rowstride / 4, cols); //fprintf(stderr, "ROWS: %d STRIDE: %d (%d) COLS: %d\n", rows, rowstride, rowstride / 4, cols);
ncvisual_set_data(ncv, data, true); ncvisual_set_data(ncv, data, true);
@ -392,25 +393,24 @@ auto ncvisual_from_rgba(const void* rgba, int rows, int rowstride,
return ncv; return ncv;
} }
auto ncvisual_from_bgra(const void* bgra, int rows, int rowstride, ncvisual* ncvisual_from_bgra(const void* bgra, int rows, int rowstride, int cols){
int cols) -> ncvisual* {
if(rowstride % 4){ if(rowstride % 4){
return nullptr; return NULL;
} }
ncvisual* ncv = ncvisual_create(); ncvisual* ncv = ncvisual_create();
if(ncv){ if(ncv){
ncv->rowstride = rowstride; ncv->rowstride = rowstride;
ncv->cols = cols; ncv->cols = cols;
ncv->rows = rows; ncv->rows = rows;
auto data = static_cast<uint32_t*>(memdup(bgra, rowstride * ncv->rows)); uint32_t* data = memdup(bgra, rowstride * ncv->rows);
for(int p = 0 ; p < rowstride / 4 * ncv->rows ; ++p){ for(int p = 0 ; p < rowstride / 4 * ncv->rows ; ++p){
const unsigned r = (data[p] & 0xffllu) << 16u; const unsigned r = (data[p] & 0xffllu) << 16u;
const unsigned b = (data[p] & 0xff0000llu) >> 16u; const unsigned b = (data[p] & 0xff0000llu) >> 16u;
data[p] = (data[p] & 0xff00ff00llu) | r | b; data[p] = (data[p] & 0xff00ff00llu) | r | b;
} }
if(data == nullptr){ if(data == NULL){
ncvisual_destroy(ncv); ncvisual_destroy(ncv);
return nullptr; return NULL;
} }
ncvisual_set_data(ncv, data, true); ncvisual_set_data(ncv, data, true);
ncvisual_details_seed(ncv); ncvisual_details_seed(ncv);
@ -418,13 +418,13 @@ auto ncvisual_from_bgra(const void* bgra, int rows, int rowstride,
return ncv; return ncv;
} }
auto ncvisual_render_cells(notcurses* nc, ncvisual* ncv, const blitset* bset, ncplane* ncvisual_render_cells(notcurses* nc, ncvisual* ncv, const struct blitset* bset,
int placey, int placex, int begy, int begx, int placey, int placex, int begy, int begx,
int leny, int lenx, ncplane* n, ncscale_e scaling, int leny, int lenx, ncplane* n, ncscale_e scaling,
bool blendcolors) -> ncplane* { bool blendcolors){
int disprows, dispcols; int disprows, dispcols;
//fprintf(stderr, "INPUT N: %p\n", vopts ? vopts->n : nullptr); //fprintf(stderr, "INPUT N: %p\n", vopts ? vopts->n : NULL);
if(n == nullptr){ // create plane if(n == NULL){ // create plane
if(scaling == NCSCALE_NONE || scaling == NCSCALE_NONE_HIRES){ if(scaling == NCSCALE_NONE || scaling == NCSCALE_NONE_HIRES){
dispcols = ncv->cols; dispcols = ncv->cols;
disprows = ncv->rows; disprows = ncv->rows;
@ -442,13 +442,13 @@ auto ncvisual_render_cells(notcurses* nc, ncvisual* ncv, const blitset* bset,
.x = placex, .x = placex,
.rows = disprows / encoding_y_scale(&nc->tcache, bset), .rows = disprows / encoding_y_scale(&nc->tcache, bset),
.cols = dispcols / encoding_x_scale(&nc->tcache, bset), .cols = dispcols / encoding_x_scale(&nc->tcache, bset),
.userptr = nullptr, .userptr = NULL,
.name = "rgba", .name = "rgba",
.resizecb = nullptr, .resizecb = NULL,
.flags = 0, .flags = 0,
}; };
if((n = ncplane_create(notcurses_stdplane(nc), &nopts)) == nullptr){ if((n = ncplane_create(notcurses_stdplane(nc), &nopts)) == NULL){
return nullptr; return NULL;
} }
placey = 0; placey = 0;
placex = 0; placex = 0;
@ -476,21 +476,21 @@ auto ncvisual_render_cells(notcurses* nc, ncvisual* ncv, const blitset* bset,
bargs.cell.blendcolors = blendcolors; bargs.cell.blendcolors = blendcolors;
if(ncvisual_blit(ncv, disprows, dispcols, n, bset, begy, begx, leny, lenx, &bargs)){ if(ncvisual_blit(ncv, disprows, dispcols, n, bset, begy, begx, leny, lenx, &bargs)){
ncplane_destroy(n); ncplane_destroy(n);
return nullptr; return NULL;
} }
return n; return n;
} }
auto ncvisual_render_pixels(tinfo* tcache, ncvisual* ncv, const blitset* bset, ncplane* ncvisual_render_pixels(tinfo* tcache, ncvisual* ncv, const struct blitset* bset,
int placey, int placex, int begy, int begx, int placey, int placex, int begy, int begx,
ncplane* n, ncscale_e scaling, ncplane* stdn) -> ncplane* { ncplane* n, ncscale_e scaling, ncplane* stdn){
int disprows, dispcols; int disprows, dispcols;
if(scaling == NCSCALE_NONE || scaling == NCSCALE_NONE_HIRES){ if(scaling == NCSCALE_NONE || scaling == NCSCALE_NONE_HIRES){
dispcols = ncv->cols; dispcols = ncv->cols;
disprows = ncv->rows; disprows = ncv->rows;
} }
//fprintf(stderr, "INPUT N: %p\n", vopts ? vopts->n : nullptr); //fprintf(stderr, "INPUT N: %p\n", vopts ? vopts->n : NULL);
if(n == nullptr){ // create plane if(n == NULL){ // create plane
if(scaling != NCSCALE_NONE && scaling != NCSCALE_NONE_HIRES){ if(scaling != NCSCALE_NONE && scaling != NCSCALE_NONE_HIRES){
ncplane_dim_yx(stdn, &disprows, &dispcols); ncplane_dim_yx(stdn, &disprows, &dispcols);
dispcols *= tcache->cellpixx; dispcols *= tcache->cellpixx;
@ -502,13 +502,13 @@ auto ncvisual_render_pixels(tinfo* tcache, ncvisual* ncv, const blitset* bset,
.x = placex, .x = placex,
.rows = disprows / tcache->cellpixy + !!(disprows % tcache->cellpixy), .rows = disprows / tcache->cellpixy + !!(disprows % tcache->cellpixy),
.cols = dispcols / tcache->cellpixx + !!(dispcols % tcache->cellpixx), .cols = dispcols / tcache->cellpixx + !!(dispcols % tcache->cellpixx),
.userptr = nullptr, .userptr = NULL,
.name = "rgba", .name = "rgba",
.resizecb = nullptr, .resizecb = NULL,
.flags = 0, .flags = 0,
}; };
if((n = ncplane_create(stdn, &nopts)) == nullptr){ if((n = ncplane_create(stdn, &nopts)) == NULL){
return nullptr; return NULL;
} }
placey = 0; placey = 0;
placex = 0; placex = 0;
@ -533,13 +533,12 @@ auto ncvisual_render_pixels(tinfo* tcache, ncvisual* ncv, const blitset* bset,
if(ncvisual_blit(ncv, disprows, dispcols, n, bset, if(ncvisual_blit(ncv, disprows, dispcols, n, bset,
begy, begx, disprows, dispcols, &bargs)){ begy, begx, disprows, dispcols, &bargs)){
ncplane_destroy(n); ncplane_destroy(n);
return nullptr; return NULL;
} }
return n; return n;
} }
auto ncvisual_render(notcurses* nc, ncvisual* ncv, ncplane* ncvisual_render(notcurses* nc, ncvisual* ncv, const struct ncvisual_options* vopts){
const struct ncvisual_options* vopts) -> ncplane* {
if(vopts && vopts->flags > NCVISUAL_OPTION_BLEND){ if(vopts && vopts->flags > NCVISUAL_OPTION_BLEND){
logwarn(nc, "Warning: unknown ncvisual options %016jx\n", (uintmax_t)vopts->flags); logwarn(nc, "Warning: unknown ncvisual options %016jx\n", (uintmax_t)vopts->flags);
} }
@ -549,15 +548,15 @@ auto ncvisual_render(notcurses* nc, ncvisual* ncv,
int begx = vopts ? vopts->begx : 0; int begx = vopts ? vopts->begx : 0;
//fprintf(stderr, "blit %dx%d+%dx%d %p\n", begy, begx, leny, lenx, ncv->data); //fprintf(stderr, "blit %dx%d+%dx%d %p\n", begy, begx, leny, lenx, ncv->data);
if(begy < 0 || begx < 0 || lenx < -1 || leny < -1){ if(begy < 0 || begx < 0 || lenx < -1 || leny < -1){
return nullptr; return NULL;
} }
//fprintf(stderr, "OUR DATA: %p rows/cols: %d/%d\n", ncv->data, ncv->rows, ncv->cols); //fprintf(stderr, "OUR DATA: %p rows/cols: %d/%d\n", ncv->data, ncv->rows, ncv->cols);
if(ncv->data == nullptr){ if(ncv->data == NULL){
return nullptr; return NULL;
} }
//fprintf(stderr, "blit %d/%d to %dx%d+%dx%d scaling: %d\n", ncv->rows, ncv->cols, begy, begx, leny, lenx, vopts ? vopts->scaling : 0); //fprintf(stderr, "blit %d/%d to %dx%d+%dx%d scaling: %d\n", ncv->rows, ncv->cols, begy, begx, leny, lenx, vopts ? vopts->scaling : 0);
if(begx >= ncv->cols || begy >= ncv->rows){ if(begx >= ncv->cols || begy >= ncv->rows){
return nullptr; return NULL;
} }
if(lenx == 0){ // 0 means "to the end"; use all available source material if(lenx == 0){ // 0 means "to the end"; use all available source material
lenx = ncv->cols - begx; lenx = ncv->cols - begx;
@ -567,19 +566,19 @@ auto ncvisual_render(notcurses* nc, ncvisual* ncv,
} }
//fprintf(stderr, "blit %d/%d to %dx%d+%dx%d scaling: %d\n", ncv->rows, ncv->cols, begy, begx, leny, lenx, vopts ? vopts->scaling : 0); //fprintf(stderr, "blit %d/%d to %dx%d+%dx%d scaling: %d\n", ncv->rows, ncv->cols, begy, begx, leny, lenx, vopts ? vopts->scaling : 0);
if(lenx <= 0 || leny <= 0){ // no need to draw zero-size object, exit if(lenx <= 0 || leny <= 0){ // no need to draw zero-size object, exit
return nullptr; return NULL;
} }
if(begx + lenx > ncv->cols || begy + leny > ncv->rows){ if(begx + lenx > ncv->cols || begy + leny > ncv->rows){
return nullptr; return NULL;
} }
auto bset = rgba_blitter(nc, vopts); const struct blitset* bset = rgba_blitter(nc, vopts);
if(!bset){ if(!bset){
return nullptr; return NULL;
} }
//fprintf(stderr, "beg/len: %d %d %d %d scale: %d/%d\n", begy, leny, begx, lenx, encoding_y_scale(bset), encoding_x_scale(bset)); //fprintf(stderr, "beg/len: %d %d %d %d scale: %d/%d\n", begy, leny, begx, lenx, encoding_y_scale(bset), encoding_x_scale(bset));
int placey = vopts ? vopts->y : 0; int placey = vopts ? vopts->y : 0;
int placex = vopts ? vopts->x : 0; int placex = vopts ? vopts->x : 0;
ncplane* n = (vopts ? vopts->n : nullptr); ncplane* n = (vopts ? vopts->n : NULL);
ncscale_e scaling = vopts ? vopts->scaling : NCSCALE_NONE; ncscale_e scaling = vopts ? vopts->scaling : NCSCALE_NONE;
if(bset->geom != NCBLIT_PIXEL){ if(bset->geom != NCBLIT_PIXEL){
n = ncvisual_render_cells(nc, ncv, bset, placey, placex, begy, begx, leny, lenx, n = ncvisual_render_cells(nc, ncv, bset, placey, placex, begy, begx, leny, lenx,
@ -592,13 +591,13 @@ auto ncvisual_render(notcurses* nc, ncvisual* ncv,
return n; return n;
} }
auto ncvisual_from_plane(const ncplane* n, ncblitter_e blit, int begy, int begx, ncvisual* ncvisual_from_plane(const ncplane* n, ncblitter_e blit, int begy, int begx,
int leny, int lenx) -> ncvisual* { int leny, int lenx){
uint32_t* rgba = ncplane_rgba(n, blit, begy, begx, leny, lenx); uint32_t* rgba = ncplane_rgba(n, blit, begy, begx, leny, lenx);
//fprintf(stderr, "snarg: %d/%d @ %d/%d (%p)\n", leny, lenx, begy, begx, rgba); //fprintf(stderr, "snarg: %d/%d @ %d/%d (%p)\n", leny, lenx, begy, begx, rgba);
//fprintf(stderr, "RGBA %p\n", rgba); //fprintf(stderr, "RGBA %p\n", rgba);
if(rgba == nullptr){ if(rgba == NULL){
return nullptr; return NULL;
} }
int dimy, dimx; int dimy, dimx;
ncplane_dim_yx(n, &dimy, &dimx); ncplane_dim_yx(n, &dimy, &dimx);
@ -608,36 +607,36 @@ auto ncvisual_from_plane(const ncplane* n, ncblitter_e blit, int begy, int begx,
if(leny == -1){ if(leny == -1){
leny = (n->leny - begy); leny = (n->leny - begy);
} }
auto* ncv = ncvisual_from_rgba(rgba, leny * 2, lenx * 4, lenx); ncvisual* ncv = ncvisual_from_rgba(rgba, leny * 2, lenx * 4, lenx);
free(rgba); free(rgba);
//fprintf(stderr, "RETURNING %p\n", ncv); //fprintf(stderr, "RETURNING %p\n", ncv);
return ncv; return ncv;
} }
auto ncvisual_details_destroy(ncvisual_details* deets){ void ncvisual_details_destroy(struct ncvisual_details* deets){
if(visual_implementation){ if(visual_implementation){
visual_implementation->visual_details_destroy(deets); visual_implementation->visual_details_destroy(deets);
} }
} }
auto ncvisual_destroy(ncvisual* ncv) -> void { void ncvisual_destroy(ncvisual* ncv){
if(ncv){ if(ncv){
ncvisual_details_destroy(ncv->details); ncvisual_details_destroy(ncv->details);
if(ncv->owndata){ if(ncv->owndata){
free(ncv->data); free(ncv->data);
} }
delete ncv; free(ncv);
} }
} }
auto ncvisual_simple_streamer(ncvisual* ncv, struct ncvisual_options* vopts, int ncvisual_simple_streamer(ncvisual* ncv, struct ncvisual_options* vopts,
const timespec* tspec, void* curry) -> int { const struct timespec* tspec, void* curry){
if(notcurses_render(ncplane_notcurses(vopts->n))){ if(notcurses_render(ncplane_notcurses(vopts->n))){
return -1; return -1;
} }
int ret = 0; int ret = 0;
if(curry){ if(curry){
ncplane* subncp = static_cast<ncplane*>(curry); ncplane* subncp = curry;
char* subtitle = ncvisual_subtitle(ncv); char* subtitle = ncvisual_subtitle(ncv);
if(subtitle){ if(subtitle){
if(ncplane_putstr_yx(subncp, 0, 0, subtitle) < 0){ if(ncplane_putstr_yx(subncp, 0, 0, subtitle) < 0){
@ -650,7 +649,7 @@ auto ncvisual_simple_streamer(ncvisual* ncv, struct ncvisual_options* vopts,
return ret; return ret;
} }
auto ncvisual_set_yx(const struct ncvisual* n, int y, int x, uint32_t pixel) -> int { int ncvisual_set_yx(const struct ncvisual* n, int y, int x, uint32_t pixel){
if(y >= n->rows || y < 0){ if(y >= n->rows || y < 0){
return -1; return -1;
} }
@ -661,7 +660,7 @@ auto ncvisual_set_yx(const struct ncvisual* n, int y, int x, uint32_t pixel) ->
return 0; return 0;
} }
auto ncvisual_at_yx(const ncvisual* n, int y, int x, uint32_t* pixel) -> int { int ncvisual_at_yx(const ncvisual* n, int y, int x, uint32_t* pixel){
if(y >= n->rows || y < 0){ if(y >= n->rows || y < 0){
return -1; return -1;
} }
@ -672,8 +671,7 @@ auto ncvisual_at_yx(const ncvisual* n, int y, int x, uint32_t* pixel) -> int {
return 0; return 0;
} }
auto ncvisual_polyfill_recurse(ncvisual* n, int y, int x, int ncvisual_polyfill_recurse(ncvisual* n, int y, int x, uint32_t rgba, uint32_t match){
uint32_t rgba, uint32_t match) -> int {
if(y < 0 || y >= n->rows){ if(y < 0 || y >= n->rows){
return 0; return 0;
} }
@ -694,7 +692,7 @@ auto ncvisual_polyfill_recurse(ncvisual* n, int y, int x,
return ret; return ret;
} }
auto ncvisual_polyfill_yx(ncvisual* n, int y, int x, uint32_t rgba) -> int { int ncvisual_polyfill_yx(ncvisual* n, int y, int x, uint32_t rgba){
if(y >= n->rows || y < 0){ if(y >= n->rows || y < 0){
return -1; return -1;
} }
@ -705,44 +703,44 @@ auto ncvisual_polyfill_yx(ncvisual* n, int y, int x, uint32_t rgba) -> int {
return ncvisual_polyfill_recurse(n, y, x, rgba, *pixel); return ncvisual_polyfill_recurse(n, y, x, rgba, *pixel);
} }
auto notcurses_canopen_images(const notcurses* nc __attribute__ ((unused))) -> bool { bool notcurses_canopen_images(const notcurses* nc __attribute__ ((unused))){
if(!visual_implementation){ if(!visual_implementation){
return false; return false;
} }
return visual_implementation->canopen_images; return visual_implementation->canopen_images;
} }
auto notcurses_canopen_videos(const notcurses* nc __attribute__ ((unused))) -> bool { bool notcurses_canopen_videos(const notcurses* nc __attribute__ ((unused))){
if(!visual_implementation){ if(!visual_implementation){
return false; return false;
} }
return visual_implementation->canopen_videos; return visual_implementation->canopen_videos;
} }
auto ncvisual_decode_loop(ncvisual* nc) -> int { int ncvisual_decode_loop(ncvisual* nc){
if(!visual_implementation){ if(!visual_implementation){
return -1; return -1;
} }
return visual_implementation->visual_decode_loop(nc); return visual_implementation->visual_decode_loop(nc);
} }
auto ncvisual_stream(notcurses* nc, ncvisual* ncv, float timescale, int ncvisual_stream(notcurses* nc, ncvisual* ncv, float timescale,
streamcb streamer, const ncvisual_options* vopts, streamcb streamer, const struct ncvisual_options* vopts,
void* curry) -> int { void* curry){
if(!visual_implementation){ if(!visual_implementation){
return -1; return -1;
} }
return visual_implementation->visual_stream(nc, ncv, timescale, streamer, vopts, curry); return visual_implementation->visual_stream(nc, ncv, timescale, streamer, vopts, curry);
} }
auto ncvisual_subtitle(const ncvisual* ncv) -> char* { char* ncvisual_subtitle(const ncvisual* ncv){
if(!visual_implementation){ if(!visual_implementation){
return nullptr; return NULL;
} }
return visual_implementation->visual_subtitle(ncv); return visual_implementation->visual_subtitle(ncv);
} }
auto ncvisual_resize(ncvisual* nc, int rows, int cols) -> int { int ncvisual_resize(ncvisual* nc, int rows, int cols){
if(!visual_implementation){ if(!visual_implementation){
return -1; return -1;
} }
Write Preview
Loading…
Cancel
Save