sprite.h File Reference

#include <stdint.h>
#include <stdbool.h>
#include "fbuf.h"

Include dependency graph for sprite.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	tament
struct	sprixel

Macros
#define	SIXEL_MAX_REGISTERS   65534

Typedefs
typedef struct tament	tament
typedef struct sprixel	sprixel

Enumerations
enum	sprixel_e {   SPRIXEL_QUIESCENT , SPRIXEL_UNSEEN , SPRIXEL_LOADED , SPRIXEL_INVALIDATED ,   SPRIXEL_HIDE , SPRIXEL_MOVED }
enum	sprixcell_e {   SPRIXCELL_TRANSPARENT , SPRIXCELL_OPAQUE_SIXEL , SPRIXCELL_OPAQUE_KITTY , SPRIXCELL_MIXED_SIXEL ,   SPRIXCELL_MIXED_KITTY , SPRIXCELL_ANNIHILATED , SPRIXCELL_ANNIHILATED_TRANS }

Functions
int	sprite_init (struct tinfo *t, int fd)
int	sixel_wipe (sprixel *s, int ycell, int xcell)
int	kitty_wipe (sprixel *s, int ycell, int xcell)
int	kitty_wipe_animation (sprixel *s, int ycell, int xcell)
int	kitty_wipe_selfref (sprixel *s, int ycell, int xcell)
int	fbcon_wipe (sprixel *s, int ycell, int xcell)
int	sixel_rebuild (sprixel *s, int ycell, int xcell, uint8_t *auxvec)
int	kitty_rebuild (sprixel *s, int ycell, int xcell, uint8_t *auxvec)
int	fbcon_rebuild (sprixel *s, int ycell, int xcell, uint8_t *auxvec)
int	kitty_rebuild_animation (sprixel *s, int ycell, int xcell, uint8_t *auxvec)
int	kitty_rebuild_selfref (sprixel *s, int ycell, int xcell, uint8_t *auxvec)
int	sixel_draw (const struct tinfo *ti, const struct ncpile *p, sprixel *s, fbuf *f, int yoff, int xoff)
int	kitty_draw (const struct tinfo *ti, const struct ncpile *p, sprixel *s, fbuf *f, int yoff, int xoff)
int	kitty_move (sprixel *s, fbuf *f, unsigned noscroll, int yoff, int xoff)
int	sixel_scrub (const struct ncpile *p, sprixel *s)
int	kitty_scrub (const struct ncpile *p, sprixel *s)
int	fbcon_scrub (const struct ncpile *p, sprixel *s)
int	kitty_remove (int id, fbuf *f)
int	kitty_clear_all (fbuf *f)
int	sixel_init_forcesdm (struct tinfo *ti, int fd)
int	sixel_init_inverted (struct tinfo *ti, int fd)
int	sixel_init (struct tinfo *ti, int fd)
uint8_t *	sixel_trans_auxvec (const struct ncpile *p)
uint8_t *	kitty_trans_auxvec (const struct ncpile *p)
int	kitty_commit (fbuf *f, sprixel *s, unsigned noscroll)
int	sixel_blit (struct ncplane *nc, int linesize, const void *data, int leny, int lenx, const struct blitterargs *bargs)
int	kitty_blit (struct ncplane *nc, int linesize, const void *data, int leny, int lenx, const struct blitterargs *bargs)
int	kitty_blit_animated (struct ncplane *n, int linesize, const void *data, int leny, int lenx, const struct blitterargs *bargs)
int	kitty_blit_selfref (struct ncplane *nc, int linesize, const void *data, int leny, int lenx, const struct blitterargs *bargs)
int	fbcon_blit (struct ncplane *nc, int linesize, const void *data, int leny, int lenx, const struct blitterargs *bargs)
int	fbcon_draw (const struct tinfo *ti, sprixel *s, int yoff, int xoff)
void	fbcon_scroll (const struct ncpile *p, struct tinfo *ti, int rows)
void	sixel_refresh (const struct ncpile *p, sprixel *s)
int	sprixel_load (sprixel *spx, fbuf *f, unsigned pixy, unsigned pixx, int parse_start, sprixel_e state)
int	sprixel_rescale (sprixel *spx, unsigned ncellpixy, unsigned ncellpixx)
void	sixel_cleanup (struct tinfo *ti)

Macro Definition Documentation

SIXEL_MAX_REGISTERS

#define SIXEL_MAX_REGISTERS   65534

Definition at line 12 of file sprite.h.

Typedef Documentation

sprixel

typedef struct sprixel sprixel

tament

typedef struct tament tament

Enumeration Type Documentation

sprixcell_e

enum sprixcell_e

Enumerator
SPRIXCELL_TRANSPARENT
SPRIXCELL_OPAQUE_SIXEL
SPRIXCELL_OPAQUE_KITTY
SPRIXCELL_MIXED_SIXEL
SPRIXCELL_MIXED_KITTY
SPRIXCELL_ANNIHILATED
SPRIXCELL_ANNIHILATED_TRANS

Definition at line 114 of file sprite.h.

             {
  SPRIXCELL_TRANSPARENT,       // all pixels are naturally transparent
  SPRIXCELL_OPAQUE_SIXEL,      // no transparent pixels in this cell
  SPRIXCELL_OPAQUE_KITTY,
  SPRIXCELL_MIXED_SIXEL,       // this cell has both opaque and transparent pixels
  SPRIXCELL_MIXED_KITTY,
  SPRIXCELL_ANNIHILATED,       // this cell has been wiped (all trans)
  SPRIXCELL_ANNIHILATED_TRANS, // this transparent cell is covered
} sprixcell_e;

sprixel_e

enum sprixel_e

Enumerator
SPRIXEL_QUIESCENT
SPRIXEL_UNSEEN
SPRIXEL_LOADED
SPRIXEL_INVALIDATED
SPRIXEL_HIDE
SPRIXEL_MOVED

Definition at line 20 of file sprite.h.

             {
  SPRIXEL_QUIESCENT,   // up-to-date and visible at the proper place
  SPRIXEL_UNSEEN,      // not yet loaded, invisible, but wants loading
  SPRIXEL_LOADED,      // loaded, but not yet made visible (kitty-only)
  SPRIXEL_INVALIDATED, // not up-to-date, need reload
  SPRIXEL_HIDE,        // queued for destruction
  SPRIXEL_MOVED,       // visible, up-to-date, but in the wrong place
} sprixel_e;

Function Documentation

fbcon_blit()

int fbcon_blit	(	struct ncplane *	nc,
		int	linesize,
		const void *	data,
		int	leny,
		int	lenx,
		const struct blitterargs *	bargs
	)

Definition at line 44 of file linux.c.

                                                                   {
  uint32_t transcolor = bargs->transcolor;
  sprixel* s = bargs->u.pixel.spx;
  int cdimx = bargs->u.pixel.cellpxx;
  int cdimy = bargs->u.pixel.cellpxy;
  // FIXME this will need be a copy of the tinfo's fbuf map
  size_t flen = leny * lenx * 4;
  if(fbuf_reserve(&s->glyph, flen)){
    return -1;
  }
  for(int l = 0 ; l < leny ; ++l){
    int ycell = l / cdimy;
    size_t soffset = l * linesize;
    const uint8_t* src = (const unsigned char*)data + soffset;
    size_t toffset = l * lenx * 4;
    char* dst = (char *)s->glyph.buf + toffset;
    for(int c = 0 ; c < lenx ; ++c){
      int xcell = c / cdimx;
      int tyx = xcell + ycell * bargs->u.pixel.spx->dimx;
      if(n->tam[tyx].state >= SPRIXCELL_ANNIHILATED){
        if(rgba_trans_p(*(uint32_t*)src, transcolor)){
          ncpixel_set_a((uint32_t*)src, 0); // in case it was transcolor
          if(c % cdimx == 0 && l % cdimy == 0){
            n->tam[tyx].state = SPRIXCELL_ANNIHILATED_TRANS;
          }
        }else{
          n->tam[tyx].state = SPRIXCELL_ANNIHILATED;
        }
        dst[3] = 0;
        const int vyx = (l % cdimy) * cdimx + (c % cdimx);
        ((uint8_t*)n->tam[tyx].auxvector)[vyx] = src[3];
      }else{
        if(rgba_trans_p(*(uint32_t*)src, transcolor)){
          ncpixel_set_a((uint32_t*)src, 0); // in case it was transcolor
          if(c % cdimx == 0 && l % cdimy == 0){
            n->tam[tyx].state = SPRIXCELL_TRANSPARENT;
          }else if(n->tam[tyx].state == SPRIXCELL_OPAQUE_SIXEL){
            n->tam[tyx].state = SPRIXCELL_MIXED_SIXEL;
          }
          dst[3] = 0;
        }else{
          if(c % cdimx == 0 && l % cdimy == 0){
            n->tam[tyx].state = SPRIXCELL_OPAQUE_SIXEL;
          }else if(n->tam[tyx].state == SPRIXCELL_TRANSPARENT){
            n->tam[tyx].state = SPRIXCELL_MIXED_SIXEL;
          }
          memcpy(dst + 3, src + 3, 1);
        }
      }
      memcpy(dst, src + 2, 1);
      memcpy(dst + 1, src + 1, 1);
      memcpy(dst + 2, src, 1);
      dst += 4;
      src += 4;
    }
  }
  scrub_tam_boundaries(n->tam, leny, lenx, cdimy, cdimx);
  if(plane_blit_sixel(s, &s->glyph, leny, lenx, 0, n->tam, SPRIXEL_INVALIDATED) < 0){
    goto error;
  }
  return 1;
 
error:
  fbuf_free(&s->glyph);
  s->glyph.size = 0;
  return -1;
}

fbcon_draw()

int fbcon_draw	(	const struct tinfo *	ti,
		sprixel *	s,
		int	yoff,
		int	xoff
	)

fbcon_rebuild()

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

Definition at line 791 of file linux.c.

                                                                    {
  (void)s;
  (void)ycell;
  (void)xcell;
  (void)auxvec;
  return 0;
}

fbcon_scroll()

void fbcon_scroll	(	const struct ncpile *	p,
		struct tinfo *	ti,
		int	rows
	)

Definition at line 807 of file linux.c.

                                                              {
  (void)p;
  (void)ti;
  (void)rows;
}

fbcon_scrub()

int fbcon_scrub	(	const struct ncpile *	p,
		sprixel *	s
	)

Definition at line 113 of file linux.c.

                                                   {
  return sixel_scrub(p, s);
}

Here is the call graph for this function:

fbcon_wipe()

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

Definition at line 16 of file linux.c.

                                                {
  uint8_t* auxvec = fbcon_auxiliary_vector(s);
  if(auxvec == NULL){
    return -1;
  }
  const int cellpxy = ncplane_pile(s->n)->cellpxy;
  const int cellpxx = ncplane_pile(s->n)->cellpxx;
  char* glyph = s->glyph.buf;
  for(int y = 0 ; y < cellpxy ; ++y){
    if(ycell * cellpxy + y >= s->pixy){
      break;
    }
    // number of pixels total above our pixel row
    const size_t yoff = s->pixx * (ycell * cellpxy + y);
    for(int x = 0 ; x < cellpxx ; ++x){
      if(xcell * cellpxx + x >= s->pixx){
        break;
      }
      size_t offset = (yoff + xcell * cellpxx + x) * 4;
      const int vyx = (y % cellpxy) * cellpxx + x;
      auxvec[vyx] = glyph[offset + 3];
      glyph[offset + 3] = 0;
    }
  }
  s->n->tam[s->dimx * ycell + xcell].auxvector = auxvec;
  return 0;
}

kitty_blit()

int kitty_blit	(	struct ncplane *	nc,
		int	linesize,
		const void *	data,
		int	leny,
		int	lenx,
		const struct blitterargs *	bargs
	)

kitty_blit_animated()

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

kitty_blit_selfref()

int kitty_blit_selfref	(	struct ncplane *	nc,
		int	linesize,
		const void *	data,
		int	leny,
		int	lenx,
		const struct blitterargs *	bargs
	)

kitty_clear_all()

int kitty_clear_all

(

fbuf *

f

)

Definition at line 1210 of file kitty.c.

                            {
//fprintf(stderr, "KITTY UNIVERSAL ERASE\n");
  if(fbuf_putn(f, "\x1b_Ga=d,q=2\x1b\\", 12) < 0){
    return -1;
  }
  return 0;
}

kitty_commit()

int kitty_commit	(	fbuf *	f,
		sprixel *	s,
		unsigned	noscroll
	)

Definition at line 534 of file kitty.c.

                                                        {
  loginfo("committing Kitty graphic id %u", s->id);
  int i;
  if(s->pxoffx || s->pxoffy){
    i = fbuf_printf(f, "\e_Ga=p,i=%u,p=1,X=%u,Y=%u%s,q=2\e\\", s->id,
                    s->pxoffx, s->pxoffy, noscroll ? ",C=1" : "");
  }else{
    i = fbuf_printf(f, "\e_Ga=p,i=%u,p=1,q=2%s\e\\", s->id, noscroll ? ",C=1" : "");
  }
  if(i < 0){
    return -1;
  }
  s->invalidated = SPRIXEL_QUIESCENT;
  return 0;
}

kitty_draw()

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

kitty_move()

int kitty_move	(	sprixel *	s,
		fbuf *	f,
		unsigned	noscroll,
		int	yoff,
		int	xoff
	)

Definition at line 1194 of file kitty.c.

                                                                          {
  const int targy = s->n->absy;
  const int targx = s->n->absx;
  logdebug("moving %u to %d %d", s->id, targy, targx);
  int ret = 0;
  if(goto_location(ncplane_notcurses(s->n), f, targy + yoff, targx + xoff, s->n)){
    ret = -1;
  }else if(fbuf_printf(f, "\e_Ga=p,i=%d,p=1,q=2%s\e\\", s->id,
                       noscroll ? ",C=1" : "") < 0){
    ret = -1;
  }
  s->invalidated = SPRIXEL_QUIESCENT;
  return ret;
}

Here is the call graph for this function:

kitty_rebuild()

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

Definition at line 219 of file kitty.c.

                                                                    {
  const int totalpixels = s->pixy * s->pixx;
  const int xpixels = ncplane_pile(s->n)->cellpxx;
  const int ypixels = ncplane_pile(s->n)->cellpxy;
  int targx = xpixels;
  if((xcell + 1) * xpixels > s->pixx){
    targx = s->pixx - xcell * xpixels;
  }
  int targy = ypixels;
  if((ycell + 1) * ypixels > s->pixy){
    targy = s->pixy - ycell * ypixels;
  }
  char* c = (char*)s->glyph.buf + s->parse_start;
  int nextpixel = (s->pixx * ycell * ypixels) + (xpixels * xcell);
  int thisrow = targx;
  int chunkedhandled = 0;
  sprixcell_e state = SPRIXCELL_OPAQUE_KITTY;
  const int chunks = totalpixels / RGBA_MAXLEN + !!(totalpixels % RGBA_MAXLEN);
  int auxvecidx = 0;
  while(targy && chunkedhandled < chunks){ // need to null out |targy| rows of |targx| pixels, track with |thisrow|
    int inchunk = totalpixels - chunkedhandled * RGBA_MAXLEN;
    if(inchunk > RGBA_MAXLEN){
      inchunk = RGBA_MAXLEN;
    }
    const int curpixel = chunkedhandled * RGBA_MAXLEN;
    // a full chunk is 4096 + 2 + 7 (5005)
    while(nextpixel - curpixel < RGBA_MAXLEN && thisrow){
      // our next pixel is within this chunk. find the pixel offset of the
      // first pixel (within the chunk).
      int pixoffset = nextpixel - curpixel;
      int triples = pixoffset / 3;
      int tripbytes = triples * 16;
      int tripskip = pixoffset - triples * 3;
      // we start within a 16-byte chunk |tripbytes| into the chunk. determine
      // the number of bits.
//fprintf(stderr, "pixoffset: %d next: %d tripbytes: %d tripskip: %d thisrow: %d\n", pixoffset, nextpixel, tripbytes, tripskip, thisrow);
      // the maximum number of pixels we can convert is the minimum of the
      // pixels remaining in the target row, and the pixels left in the chunk.
//fprintf(stderr, "inchunk: %d total: %d triples: %d\n", inchunk, totalpixels, triples);
      int chomped = kitty_restore(c + tripbytes, tripskip, thisrow,
                                  inchunk - triples * 3, auxvec + auxvecidx,
                                  &state);
      assert(chomped >= 0);
      auxvecidx += chomped;
      thisrow -= chomped;
//fprintf(stderr, "POSTCHIMP CHOMP: %d pixoffset: %d next: %d tripbytes: %d tripskip: %d thisrow: %d\n", chomped, pixoffset, nextpixel, tripbytes, tripskip, thisrow);
      if(thisrow == 0){
//fprintf(stderr, "CLEARED ROW, TARGY: %d\n", targy - 1);
        if(--targy == 0){
          s->n->tam[s->dimx * ycell + xcell].state = state;
          s->invalidated = SPRIXEL_INVALIDATED;
          return 1;
        }
        thisrow = targx;
//fprintf(stderr, "BUMP IT: %d %d %d %d\n", nextpixel, s->pixx, targx, chomped);
        nextpixel += s->pixx - targx + chomped;
      }else{
        nextpixel += chomped;
      }
    }
    c += RGBA_MAXLEN * 4 * 4 / 3; // 4bpp * 4/3 for base64, 4096b per chunk
    c += 8; // new chunk header
    ++chunkedhandled;
//fprintf(stderr, "LOOKING NOW AT %u [%s]\n", c - s->glyph, c);
    while(*c != ';'){
      ++c;
    }
    ++c;
  }
  return -1;
}

Here is the call graph for this function:

kitty_rebuild_animation()

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

Definition at line 972 of file kitty.c.

                                                                              {
  logdebug("rebuilding sprixel %u %d at %d/%d", s->id, s->invalidated, ycell, xcell);
  if(init_sprixel_animation(s)){
    return -1;
  }
  fbuf* f = &s->glyph;
  const int cellpxy = ncplane_pile(s->n)->cellpxy;
  const int cellpxx = ncplane_pile(s->n)->cellpxx;
  const int ystart = ycell * cellpxy;
  const int xstart = xcell * cellpxx;
  const int xlen = xstart + cellpxx > s->pixx ? s->pixx - xstart : cellpxx;
  const int ylen = ystart + cellpxy > s->pixy ? s->pixy - ystart : cellpxy;
  const int linesize = xlen * 4;
  const int total = xlen * ylen;
  const int tyx = xcell + ycell * s->dimx;
  int chunks = (total + (RGBA_MAXLEN - 1)) / RGBA_MAXLEN;
  int totalout = 0; // total pixels of payload out
  int y = 0; // position within source image (pixels)
  int x = 0;
  int targetout = 0; // number of pixels expected out after this chunk
//fprintf(stderr, "total: %d chunks = %d, s=%d,v=%d\n", total, chunks, lenx, leny);
  // FIXME this ought be factored out and shared with write_kitty_data()
  logdebug("placing %d/%d at %d/%d", ylen, xlen, ycell * cellpxy, xcell * cellpxx);
  while(chunks--){
    if(totalout == 0){
      const int c = kitty_anim_auxvec_blitsource_p(s, auxvec) ? 2 : 1;
      const int r = kitty_anim_auxvec_blitsource_p(s, auxvec) ? 1 : 2;
      if(fbuf_printf(f, "\e_Ga=f,x=%d,y=%d,s=%d,v=%d,i=%d,X=1,c=%d,r=%d,%s;",
                     xcell * cellpxx, ycell * cellpxy, xlen, ylen,
                     s->id, c, r, chunks ? "m=1" : "q=2") < 0){
        return -1;
      }
    }else{
      if(fbuf_putn(f, "\x1b_G", 3) < 0){
        return -1;
      }
      if(!chunks){
        if(fbuf_putn(f, "q=2,", 4) < 0){
          return -1;
        }
      }
      if(fbuf_putn(f, "m=", 2) < 0){
        return -1;
      }
      if(fbuf_putint(f, chunks ? 1 : 0) < 0){
        return -1;
      }
      if(fbuf_putc(f, ';') != 1){
        return -1;
      }
    }
    if((targetout += RGBA_MAXLEN) > total){
      targetout = total;
    }
    while(totalout < targetout){
      int encodeable = targetout - totalout;
      if(encodeable > 3){
        encodeable = 3;
      }
      uint32_t source[3]; // we encode up to 3 pixels at a time
      bool wipe[3];
      for(int e = 0 ; e < encodeable ; ++e){
        if(x == xlen){
          x = 0;
          ++y;
        }
        const uint32_t* line = (const uint32_t*)(auxvec + linesize * y);
        source[e] = line[x];
//fprintf(stderr, "%u/%u/%u -> %c%c%c%c %u %u %u %u\n", r, g, b, b64[0], b64[1], b64[2], b64[3], b64[0], b64[1], b64[2], b64[3]);
//fprintf(stderr, "Tyx: %d y: %d (%d) * %d x: %d (%d) state %d %p\n", tyx, y, y / cdimy, cols, x, x / cdimx, tam[tyx].state, tam[tyx].auxvector);
        wipe[e] = 0;
        if(rgba_trans_p(source[e], 0)){
          if(x % cellpxx == 0 && y % cellpxy == 0){
            s->n->tam[tyx].state = SPRIXCELL_TRANSPARENT;
          }else if(s->n->tam[tyx].state == SPRIXCELL_OPAQUE_KITTY){
            s->n->tam[tyx].state = SPRIXCELL_MIXED_KITTY;
          }
        }else{
          if(x % cellpxx == 0 && y % cellpxy == 0){
            s->n->tam[tyx].state = SPRIXCELL_OPAQUE_KITTY;
          }else if(s->n->tam[tyx].state == SPRIXCELL_TRANSPARENT){
            s->n->tam[tyx].state = SPRIXCELL_MIXED_KITTY;
          }
        }
        ++x;
      }
      totalout += encodeable;
      char out[17];
      base64_rgba3(source, encodeable, out, wipe, 0);
      if(fbuf_puts(f, out) < 0){
        return -1;
      }
    }
    if(fbuf_putn(f, "\x1b\\", 2) < 0){
      return -1;
    }
  }
//fprintf(stderr, "EMERGED WITH TAM STATE %d\n", s->n->tam[tyx].state);
  s->invalidated = SPRIXEL_INVALIDATED;
  return 0;
}

kitty_rebuild_selfref()

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

Definition at line 950 of file kitty.c.

                                                                            {
  if(init_sprixel_animation(s)){
    return -1;
  }
  fbuf* f = &s->glyph;
  const int cellpxy = ncplane_pile(s->n)->cellpxy;
  const int cellpxx = ncplane_pile(s->n)->cellpxx;
  const int ystart = ycell * cellpxy;
  const int xstart = xcell * cellpxx;
  const int xlen = xstart + cellpxx > s->pixx ? s->pixx - xstart : cellpxx;
  const int ylen = ystart + cellpxy > s->pixy ? s->pixy - ystart : cellpxy;
  logdebug("rematerializing %u at %d/%d (%dx%d)", s->id, ycell, xcell, ylen, xlen);
  fbuf_printf(f, "\e_Ga=c,x=%d,y=%d,X=%d,Y=%d,w=%d,h=%d,i=%d,r=1,c=2,q=2;\x1b\\",
              xcell * cellpxx, ycell * cellpxy,
              xcell * cellpxx, ycell * cellpxy,
              xlen, ylen, s->id);
  const int tyx = xcell + ycell * s->dimx;
  memcpy(&s->n->tam[tyx].state, auxvec, sizeof(s->n->tam[tyx].state));
  s->invalidated = SPRIXEL_INVALIDATED;
  return 0;
}

kitty_remove()

int kitty_remove	(	int	id,
		fbuf *	f
	)

Definition at line 1130 of file kitty.c.

                                 {
  loginfo("removing graphic %u", id);
  if(fbuf_printf(f, "\e_Ga=d,d=I,i=%d\e\\", id) < 0){
    return -1;
  }
  return 0;
}

kitty_scrub()

int kitty_scrub	(	const struct ncpile *	p,
		sprixel *	s
	)

kitty_trans_auxvec()

uint8_t * kitty_trans_auxvec

(

const struct ncpile *

p

)

kitty_wipe()

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

Definition at line 448 of file kitty.c.

                                                {
//fprintf(stderr, "NEW WIPE %d %d/%d\n", s->id, ycell, xcell);
  uint8_t* auxvec = kitty_auxiliary_vector(s);
  if(auxvec == NULL){
    return -1;
  }
  const int totalpixels = s->pixy * s->pixx;
  const int xpixels = ncplane_pile(s->n)->cellpxx;
  const int ypixels = ncplane_pile(s->n)->cellpxy;
  // if the cell is on the right or bottom borders, it might only be partially
  // filled by actual graphic data, and we need to cap our target area.
  int targx = xpixels;
  if((xcell + 1) * xpixels > s->pixx){
    targx = s->pixx - xcell * xpixels;
  }
  int targy = ypixels;
  if((ycell + 1) * ypixels > s->pixy){
    targy = s->pixy - ycell * ypixels;
  }
  char* c = (char*)s->glyph.buf + s->parse_start;
//fprintf(stderr, "TARGET AREA: %d x %d @ %dx%d of %d/%d (%d/%d) len %zu\n", targy, targx, ycell, xcell, s->dimy, s->dimx, s->pixy, s->pixx, strlen(c));
  // every pixel was 4 source bytes, 32 bits, 6.33 base64 bytes. every 3 input pixels is
  // 12 bytes (96 bits), an even 16 base64 bytes. there is chunking to worry about. there
  // are up to 768 pixels in a chunk.
  int nextpixel = (s->pixx * ycell * ypixels) + (xpixels * xcell);
  int thisrow = targx;
  int chunkedhandled = 0;
  const int chunks = totalpixels / RGBA_MAXLEN + !!(totalpixels % RGBA_MAXLEN);
  int auxvecidx = 0;
  while(targy && chunkedhandled < chunks){ // need to null out |targy| rows of |targx| pixels, track with |thisrow|
//fprintf(stderr, "PLUCKING FROM [%s]\n", c);
    int inchunk = totalpixels - chunkedhandled * RGBA_MAXLEN;
    if(inchunk > RGBA_MAXLEN){
      inchunk = RGBA_MAXLEN;
    }
    const int curpixel = chunkedhandled * RGBA_MAXLEN;
    // a full chunk is 4096 + 2 + 7 (5005)
    while(nextpixel - curpixel < RGBA_MAXLEN && thisrow){
      // our next pixel is within this chunk. find the pixel offset of the
      // first pixel (within the chunk).
      int pixoffset = nextpixel - curpixel;
      int triples = pixoffset / 3;
      int tripbytes = triples * 16;
      // we start within a 16-byte chunk |tripbytes| into the chunk. determine
      // the number of bits.
      int tripskip = pixoffset - triples * 3;
//fprintf(stderr, "pixoffset: %d next: %d tripbytes: %d tripskip: %d thisrow: %d\n", pixoffset, nextpixel, tripbytes, tripskip, thisrow);
      // the maximum number of pixels we can convert is the minimum of the
      // pixels remaining in the target row, and the pixels left in the chunk.
//fprintf(stderr, "inchunk: %d total: %d triples: %d\n", inchunk, totalpixels, triples);
//fprintf(stderr, "PRECHOMP:  [%.16s]\n", c + tripbytes);
      int chomped = kitty_null(c + tripbytes, tripskip, thisrow,
                               inchunk - triples * 3, auxvec + auxvecidx);
//fprintf(stderr, "POSTCHOMP: [%.16s]\n", c + tripbytes);
      assert(chomped >= 0);
      auxvecidx += chomped;
      assert(auxvecidx <= ypixels * xpixels);
      thisrow -= chomped;
//fprintf(stderr, "POSTCHIMP CHOMP: %d pixoffset: %d next: %d tripbytes: %d tripskip: %d thisrow: %d\n", chomped, pixoffset, nextpixel, tripbytes, tripskip, thisrow);
      if(thisrow == 0){
//fprintf(stderr, "CLEARED ROW, TARGY: %d\n", targy - 1);
        if(--targy == 0){
          s->n->tam[s->dimx * ycell + xcell].auxvector = auxvec;
          s->invalidated = SPRIXEL_INVALIDATED;
          return 1;
        }
        thisrow = targx;
//fprintf(stderr, "BUMP IT: %d %d %d %d\n", nextpixel, s->pixx, targx, chomped);
        nextpixel += s->pixx - targx + chomped;
      }else{
        nextpixel += chomped;
      }
    }
    c += RGBA_MAXLEN * 4 * 4 / 3; // 4bpp * 4/3 for base64, 4096b per chunk
    c += 8; // new chunk header
    ++chunkedhandled;
//fprintf(stderr, "LOOKING NOW AT %u [%s]\n", c - s->glyph, c);
    while(*c != ';'){
      ++c;
    }
    ++c;
  }
  free(auxvec);
  return -1;
}

Here is the call graph for this function:

kitty_wipe_animation()

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

Definition at line 394 of file kitty.c.

                                                          {
  logdebug("wiping sprixel %u at %d/%d", s->id, ycell, xcell);
  if(init_sprixel_animation(s)){
    return -1;
  }
  fbuf* f = &s->glyph;
  if(kitty_blit_wipe_selfref(s, f, ycell, xcell) < 0){
    return -1;
  }
  int tamidx = ycell * s->dimx + xcell;
  uint8_t* auxvec = s->n->tam[tamidx].auxvector;
  auxvec[ncplane_pile(s->n)->cellpxx * ncplane_pile(s->n)->cellpxy * 4] = 0;
  s->invalidated = SPRIXEL_INVALIDATED;
  return 1;
}

kitty_wipe_selfref()

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

Definition at line 410 of file kitty.c.

                                                        {
  if(init_sprixel_animation(s)){
    return -1;
  }
  const int tyx = xcell + ycell * s->dimx;
  int state = s->n->tam[tyx].state;
  void* auxvec = s->n->tam[tyx].auxvector;
  logdebug("wiping sprixel %u at %d/%d auxvec: %p state: %d", s->id, ycell, xcell, auxvec, state);
  fbuf* f = &s->glyph;
  if(kitty_blit_wipe_selfref(s, f, ycell, xcell)){
    return -1;
  }
  s->invalidated = SPRIXEL_INVALIDATED;
  memcpy(auxvec, &state, sizeof(state));
  return 1;
}

sixel_blit()

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

sixel_cleanup()

void sixel_cleanup

(

struct 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
}

sixel_draw()

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

sixel_init()

int sixel_init	(	struct 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	(	struct 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	(	struct 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 struct ncpile *	p,
		sprixel *	s
	)

sixel_scrub()

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

sixel_trans_auxvec()

uint8_t * sixel_trans_auxvec

(

const struct ncpile *

p

)

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:

sprite_init()

int sprite_init	(	struct tinfo *	t,
		int	fd
	)

Definition at line 214 of file sprite.c.

                                 {
  struct timeval tv;
  gettimeofday(&tv, NULL);
  int stir = (tv.tv_sec >> 3) ^ tv.tv_usec;
  sprixelid_nonce = (rand() ^ stir) % 0xffffffu;
  if(t->pixel_init == NULL){
    return 0;
  }
  return t->pixel_init(t, fd);
}

sprixel_load()

int sprixel_load	(	sprixel *	spx,
		fbuf *	f,
		unsigned	pixy,
		unsigned	pixx,
		int	parse_start,
		sprixel_e	state
	)

Definition at line 154 of file sprite.c.

                                                  {
  assert(spx->n);
  if(&spx->glyph != f){
    fbuf_free(&spx->glyph);
    memcpy(&spx->glyph, f, sizeof(*f));
  }
  spx->invalidated = state;
  spx->pixx = pixx;
  spx->pixy = pixy;
  spx->parse_start = parse_start;
  return 0;
}

Here is the call graph for this function:

sprixel_rescale()

int sprixel_rescale	(	sprixel *	spx,
		unsigned	ncellpixy,
		unsigned	ncellpixx
	)

Definition at line 225 of file sprite.c.

                                                                       {
  assert(spx->n);
  loginfo("rescaling -> %ux%u", ncellpxy, ncellpxx);
  // FIXME need adjust for sixel (scale_height)
  int nrows = (spx->pixy + (ncellpxy - 1)) / ncellpxy;
  int ncols = (spx->pixx + (ncellpxx - 1)) / ncellpxx;
  tament* ntam = create_tam(nrows, ncols);
  if(ntam == NULL){
    return -1;
  }
  for(unsigned y = 0 ; y < spx->dimy ; ++y){
    for(unsigned x = 0 ; x < spx->dimx ; ++x){
      sprite_rebuild(ncplane_notcurses(spx->n), spx, y, x);
    }
  }
  ncplane* ncopy = spx->n;
  destroy_tam(spx->n);
  // spx->n->tam has been reset, so it will not be resized herein
  ncplane_resize_simple(spx->n, nrows, ncols);
  spx->n = ncopy;
  spx->n->sprite = spx;
  spx->n->tam = ntam;
  spx->dimy = nrows;
  spx->dimx = ncols;
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function: