sixel.c File Reference

#include <math.h>
#include <stdatomic.h>
#include "internal.h"
#include "fbuf.h"

Include dependency graph for sixel.c:

Go to the source code of this file.

Data Structures
struct	qsample
struct	qnode
struct	onode
struct	sixelband
struct	sixelmap
struct	qstate
struct	work_queue
struct	sixel_engine
struct	band_extender

Macros
#define	RGBSIZE   3
#define	POPULATION   3
#define	WORKERDEPTH   3
#define	TRANS_PALETTE_ENTRY   65535
#define	AUXVECELEMSIZE   2
#define	QNODECOUNT   1000

Typedefs
typedef struct qsample	qsample
typedef struct qnode	qnode
typedef struct onode	onode
typedef struct sixelband	sixelband
typedef struct sixelmap	sixelmap
typedef struct qstate	qstate
typedef struct work_queue	work_queue
typedef struct sixel_engine	sixel_engine

Enumerations
enum	sixel_p2_e { SIXEL_P2_ALLOPAQUE = 0 , SIXEL_P2_TRANS = 1 }

Functions
void	sixelmap_free (sixelmap *s)
int	sixel_wipe (sprixel *s, int ycell, int xcell)
void	sixel_refresh (const ncpile *p, sprixel *s)
int	sixel_blit (ncplane *n, int linesize, const void *data, int leny, int lenx, const blitterargs *bargs)
int	sixel_scrub (const ncpile *p, sprixel *s)
int	sixel_draw (const tinfo *ti, const ncpile *p, sprixel *s, fbuf *f, int yoff, int xoff)
int	sixel_init_forcesdm (tinfo *ti, int fd)
int	sixel_init_inverted (tinfo *ti, int fd)
int	sixel_init (tinfo *ti, int fd)
int	sixel_rebuild (sprixel *s, int ycell, int xcell, uint8_t *auxvec)
void	sixel_cleanup (tinfo *ti)
uint8_t *	sixel_trans_auxvec (const ncpile *p)

Macro Definition Documentation

AUXVECELEMSIZE

#define AUXVECELEMSIZE   2

Definition at line 20 of file sixel.c.

POPULATION

#define POPULATION   3

Definition at line 10 of file sixel.c.

QNODECOUNT

#define QNODECOUNT   1000

Definition at line 266 of file sixel.c.

RGBSIZE

#define RGBSIZE   3

Definition at line 6 of file sixel.c.

TRANS_PALETTE_ENTRY

#define TRANS_PALETTE_ENTRY   65535

Definition at line 17 of file sixel.c.

WORKERDEPTH

#define WORKERDEPTH   3

Definition at line 13 of file sixel.c.

Typedef Documentation

onode

typedef struct onode onode

qnode

typedef struct qnode qnode

qsample

typedef struct qsample qsample

qstate

typedef struct qstate qstate

sixel_engine

typedef struct sixel_engine sixel_engine

sixelband

typedef struct sixelband sixelband

sixelmap

typedef struct sixelmap sixelmap

work_queue

typedef struct work_queue work_queue

Enumeration Type Documentation

sixel_p2_e

enum sixel_p2_e

Enumerator
SIXEL_P2_ALLOPAQUE
SIXEL_P2_TRANS

Definition at line 55 of file sixel.c.

             {
  SIXEL_P2_ALLOPAQUE = 0,
  SIXEL_P2_TRANS = 1,
} sixel_p2_e;

Function Documentation

sixel_blit()

int sixel_blit	(	ncplane *	n,
		int	linesize,
		const void *	data,
		int	leny,
		int	lenx,
		const blitterargs *	bargs
	)

Definition at line 1389 of file sixel.c.

                                        {
  if(bargs->u.pixel.colorregs >= TRANS_PALETTE_ENTRY){
    logerror("palette too large %d", bargs->u.pixel.colorregs);
    return -1;
  }
  sixelmap* smap = sixelmap_create(leny - bargs->begy);
  if(smap == NULL){
    return -1;
  }
  assert(n->tam);
  qstate* qs;
  if((qs = alloc_qstate(bargs->u.pixel.colorregs)) == NULL){
    logerror("couldn't allocate qstate");
    sixelmap_free(smap);
    return -1;
  }
  qs->bargs = bargs;
  qs->data = data;
  qs->linesize = linesize;
  qs->smap = smap;
  qs->leny = leny;
  qs->lenx = lenx;
  sixel_engine* sengine = ncplane_pile(n) ? ncplane_notcurses(n)->tcache.sixelengine : NULL;
  if(extract_color_table(sengine, qs)){
    free(bargs->u.pixel.spx->needs_refresh);
    bargs->u.pixel.spx->needs_refresh = NULL;
    sixelmap_free(smap);
    free_qstate(qs);
    return -1;
  }
  // takes ownership of sixelmap on success
  int r = sixel_blit_inner(qs, smap, bargs, n->tam);
  free_qstate(qs);
  if(r < 0){
    sixelmap_free(smap);
    // FIXME free refresh table?
  }
  scrub_color_table(bargs->u.pixel.spx);
  // we haven't actually emitted the body of the sixel yet. instead, we'll emit
  // it at sixel_redraw(), thus avoiding a double emission in the case of wipes
  // taking place before it's visible.
  bargs->u.pixel.spx->wipes_outstanding = 1;
  return r;
}

Here is the call graph for this function:

sixel_cleanup()

void sixel_cleanup

(

tinfo *

ti

)

Definition at line 1764 of file sixel.c.

                             {
  sixel_engine* sengine = ti->sixelengine;
  const unsigned tids = POPULATION;
  pthread_mutex_lock(&sengine->lock);
  sengine->done = 1;
  pthread_mutex_unlock(&sengine->lock);
  pthread_cond_broadcast(&sengine->cond);
  loginfo("joining %u sixel thread%s", tids, tids == 1 ? "" : "s");
  for(unsigned t = 0 ; t < tids ; ++t){
    pthread_join(sengine->tids[t], NULL);
  }
  pthread_mutex_destroy(&sengine->lock);
  pthread_cond_destroy(&sengine->cond);
  free(sengine);
  loginfo("reaped sixel engine");
  ti->sixelengine = NULL;
  // no way to know what the state was before; we ought use XTSAVE/XTRESTORE
}

Here is the call graph for this function:

sixel_draw()

int sixel_draw	(	const tinfo *	ti,
		const ncpile *	p,
		sprixel *	s,
		fbuf *	f,
		int	yoff,
		int	xoff
	)

Definition at line 1477 of file sixel.c.

                                  {
  (void)ti;
  // if we've wiped or rebuilt any cells, effect those changes now, or else
  // we'll get flicker when we move to the new location.
  if(s->wipes_outstanding){
    if(sixel_reblit(s)){
      return -1;
    }
    s->wipes_outstanding = false;
  }
  if(p){
    const int targy = s->n->absy + yoff;
    const int targx = s->n->absx + xoff;
    if(goto_location(p->nc, f, targy, targx, NULL)){
      return -1;
    }
    if(s->invalidated == SPRIXEL_MOVED){
      for(int yy = s->movedfromy ; yy < s->movedfromy + (int)s->dimy && yy < (int)p->dimy ; ++yy){
        if(yy < 0){
          continue;
        }
        for(int xx = s->movedfromx ; xx < s->movedfromx + (int)s->dimx && xx < (int)p->dimx ; ++xx){
          if(xx < 0){
            continue;
          }
          struct crender *r = &p->crender[yy * p->dimx + xx];
          if(!r->sprixel || sprixel_state(r->sprixel, yy, xx) != SPRIXCELL_OPAQUE_SIXEL){
            r->s.damaged = 1;
          }
        }
      }
    }
  }
  if(fbuf_putn(f, s->glyph.buf, s->glyph.used) < 0){
    return -1;
  }
  s->invalidated = SPRIXEL_QUIESCENT;
  return s->glyph.used;
}

sixel_init()

int sixel_init	(	tinfo *	ti,
		int	fd
	)

Definition at line 1602 of file sixel.c.

                                 {
  return sixel_init_core(ti, "\e[?8452h", fd);
}

sixel_init_forcesdm()

int sixel_init_forcesdm	(	tinfo *	ti,
		int	fd
	)

Definition at line 1588 of file sixel.c.

                                          {
  return sixel_init_core(ti, "\e[?80l\e[?8452h", fd);
}

sixel_init_inverted()

int sixel_init_inverted	(	tinfo *	ti,
		int	fd
	)

Definition at line 1592 of file sixel.c.

                                          {
  // some terminals, at some versions, invert the sense of DECSDM. for those,
  // we must use 80h rather than the correct 80l. this grows out of a
  // misunderstanding in XTerm through patchlevel 368, which was widely
  // copied into other terminals.
  return sixel_init_core(ti, "\e[?80h\e[?8452h", fd);
}

sixel_rebuild()

int sixel_rebuild	(	sprixel *	s,
		int	ycell,
		int	xcell,
		uint8_t *	auxvec
	)

Definition at line 1724 of file sixel.c.

                                                                    {
//fprintf(stderr, "REBUILDING %d/%d\n", ycell, xcell);
  if(auxvec == NULL){
    return -1;
  }
  const int cellpxy = ncplane_pile(s->n)->cellpxy;
  const int cellpxx = ncplane_pile(s->n)->cellpxx;
  sixelmap* smap = s->smap;
  const int startx = xcell * cellpxx;
  const int starty = ycell * cellpxy;
  int endx = ((xcell + 1) * cellpxx);
  if(endx >= s->pixx){
    endx = s->pixx;
  }
  int endy = ((ycell + 1) * cellpxy);
  if(endy >= s->pixy){
    endy = s->pixy;
  }
  const int startband = starty / 6;
  const int endband = (endy - 1) / 6;
//fprintf(stderr, "%d/%d start: %d/%d end: %d/%d bands: %d-%d\n", ycell, xcell, starty, startx, endy, endx, starty / 6, endy / 6);
  // walk through each color, and wipe the necessary sixels from each band
  int w = 0;
  for(int b = startband ; b <= endband ; ++b){
    w += restore_band(smap, b, startx, endx, starty, endy, s->pixx,
                      cellpxy, cellpxx, auxvec);
  }
  s->wipes_outstanding = true;
  sprixcell_e newstate;
  if(w == cellpxx * cellpxy){
    newstate = SPRIXCELL_TRANSPARENT;
  }else if(w){
    newstate = SPRIXCELL_MIXED_SIXEL;
  }else{
    newstate = SPRIXCELL_OPAQUE_SIXEL;
  }
  s->n->tam[s->dimx * ycell + xcell].state = newstate;
  return 1;
}

sixel_refresh()

void sixel_refresh	(	const ncpile *	p,
		sprixel *	s
	)

Definition at line 725 of file sixel.c.

                                               {
  if(s->needs_refresh == NULL){
    return;
  }
  int absy, absx;
  ncplane_abs_yx(s->n, &absy, &absx);
  for(unsigned y = 0 ; y < s->dimy ; ++y){
    const unsigned yy = absy + y;
    for(unsigned x = 0 ; x < s->dimx ; ++x){
      unsigned idx = y * s->dimx + x;
      if(s->needs_refresh[idx]){
        const unsigned xx = absx + x;
        if(xx < p->dimx && yy < p->dimy){
          unsigned ridx = yy * p->dimx + xx;
          struct crender *r = &p->crender[ridx];
          r->s.damaged = 1;
        }
      }
    }
  }
  free(s->needs_refresh);
  s->needs_refresh = NULL;
}

Here is the call graph for this function:

sixel_scrub()

int sixel_scrub	(	const ncpile *	p,
		sprixel *	s
	)

Definition at line 1439 of file sixel.c.

                                            {
  loginfo("%d state %d at %d/%d (%d/%d)", s->id, s->invalidated, s->movedfromy, s->movedfromx, s->dimy, s->dimx);
  int starty = s->movedfromy;
  int startx = s->movedfromx;
  for(int yy = starty ; yy < starty + (int)s->dimy && yy < (int)p->dimy ; ++yy){
    for(int xx = startx ; xx < startx + (int)s->dimx && xx < (int)p->dimx ; ++xx){
      int ridx = yy * p->dimx + xx;
      struct crender *r = &p->crender[ridx];
      if(!s->n){
        // need this to damage cells underneath a sprixel we're removing
        r->s.damaged = 1;
        continue;
      }
      sprixel* trues = r->sprixel ? r->sprixel : s;
      if(yy >= (int)trues->n->leny || yy - trues->n->absy < 0){
        r->s.damaged = 1;
        continue;
      }
      if(xx >= (int)trues->n->lenx || xx - trues->n->absx < 0){
        r->s.damaged = 1;
        continue;
      }
      sprixcell_e state = sprixel_state(trues, yy, xx);
//fprintf(stderr, "CHECKING %d/%d state: %d %d/%d\n", yy - s->movedfromy - s->n->absy, xx - s->movedfromx - s->n->absx, state, yy, xx);
      if(state == SPRIXCELL_TRANSPARENT || state == SPRIXCELL_MIXED_SIXEL){
        r->s.damaged = 1;
      }else if(s->invalidated == SPRIXEL_MOVED){
        // ideally, we wouldn't damage our annihilated sprixcells, but if
        // we're being annihilated only during this cycle, we need to go
        // ahead and damage it.
        r->s.damaged = 1;
      }
    }
  }
  return 1;
}

Here is the caller graph for this function:

sixel_trans_auxvec()

uint8_t * sixel_trans_auxvec

(

const ncpile *

p

)

Definition at line 1786 of file sixel.c.

                                            {
  const size_t slen = AUXVECELEMSIZE * p->cellpxy * p->cellpxx;
  uint8_t* a = malloc(slen);
  if(a){
    memset(a, 0xff, slen);
  }
  return a;
}

Here is the caller graph for this function:

sixel_wipe()

int sixel_wipe	(	sprixel *	s,
		int	ycell,
		int	xcell
	)

Definition at line 655 of file sixel.c.

                                                {
//fprintf(stderr, "WIPING %d/%d\n", ycell, xcell);
  uint8_t* auxvec = sixel_trans_auxvec(ncplane_pile(s->n));
  if(auxvec == NULL){
    return -1;
  }
  const int cellpxy = ncplane_pile(s->n)->cellpxy;
  const int cellpxx = ncplane_pile(s->n)->cellpxx;
  sixelmap* smap = s->smap;
  const int startx = xcell * cellpxx;
  const int starty = ycell * cellpxy;
  int endx = ((xcell + 1) * cellpxx);
  if(endx >= s->pixx){
    endx = s->pixx;
  }
  int endy = ((ycell + 1) * cellpxy);
  if(endy >= s->pixy){
    endy = s->pixy;
  }
  const int startband = starty / 6;
  const int endband = (endy - 1) / 6;
//fprintf(stderr, "y/x: %d/%d bands: %d-%d start: %d/%d end: %d/%d\n", ycell, xcell, startband, endband - 1, starty, startx, endy, endx);
  // walk through each color, and wipe the necessary sixels from each band
  int w = 0;
  for(int b = startband ; b <= endband ; ++b){
    w += wipe_band(smap, b, startx, endx, starty, endy, s->pixx,
                   cellpxy, cellpxx, auxvec);
  }
  if(w){
    s->wipes_outstanding = true;
  }
  change_p2(s->glyph.buf, SIXEL_P2_TRANS);
  assert(NULL == s->n->tam[s->dimx * ycell + xcell].auxvector);
  s->n->tam[s->dimx * ycell + xcell].auxvector = auxvec;
  // FIXME this invalidation ought not be necessary, since we're simply
  // wiping, and thus a glyph is going to be printed over whatever we've
  // just destroyed. in alacritty, however, this isn't sufficient to knock
  // out a graphic; we need repaint with the transparency.
  // see https://github.com/dankamongmen/notcurses/issues/2142
  int absx, absy;
  ncplane_abs_yx(s->n, &absy, &absx);
  sprixel_invalidate(s, absy, absx);
  return 0;
}

Here is the call graph for this function:

sixelmap_free()

void sixelmap_free

(

sixelmap *

s

)

Definition at line 216 of file sixel.c.

                               {
  if(s){
    for(int i = 0 ; i < s->sixelbands ; ++i){
      sixelband_free(&s->bands[i]);
    }
    free(s->bands);
    free(s);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function: