kitty.c File Reference

#include "internal.h"
#include "base64.h"
#include <zlib.h>

Include dependency graph for kitty.c:

Go to the source code of this file.

Macros
#define	RGBA_MAXLEN   768
#define	TRINULLALPHA   "AAAAAAAAAAAAAAAA"
#define	UNUMNULLALPHA   "AAAAAA=="
#define	DUONULLALPHA   "AAAAAAAAAAA="

Functions
int	kitty_rebuild (sprixel *s, int ycell, int xcell, uint8_t *auxvec)
uint8_t *	kitty_trans_auxvec (const ncpile *p)
int	kitty_wipe_animation (sprixel *s, int ycell, int xcell)
int	kitty_wipe_selfref (sprixel *s, int ycell, int xcell)
sprixel *	kitty_recycle (ncplane *n)
int	kitty_wipe (sprixel *s, int ycell, int xcell)
int	kitty_commit (fbuf *f, sprixel *s, unsigned noscroll)
int	kitty_rebuild_selfref (sprixel *s, int ycell, int xcell, uint8_t *auxvec)
int	kitty_rebuild_animation (sprixel *s, int ycell, int xcell, uint8_t *auxvec)
int	kitty_blit (ncplane *n, int linesize, const void *data, int leny, int lenx, const blitterargs *bargs)
int	kitty_blit_animated (ncplane *n, int linesize, const void *data, int leny, int lenx, const blitterargs *bargs)
int	kitty_blit_selfref (ncplane *n, int linesize, const void *data, int leny, int lenx, const blitterargs *bargs)
int	kitty_remove (int id, fbuf *f)
int	kitty_scrub (const ncpile *p, sprixel *s)
int	kitty_draw (const tinfo *ti, const ncpile *p, sprixel *s, fbuf *f, int yoff, int xoff)
int	kitty_move (sprixel *s, fbuf *f, unsigned noscroll, int yoff, int xoff)
int	kitty_clear_all (fbuf *f)

Macro Definition Documentation

DUONULLALPHA

#define DUONULLALPHA   "AAAAAAAAAAA="

RGBA_MAXLEN

#define RGBA_MAXLEN   768

Definition at line 216 of file kitty.c.

TRINULLALPHA

#define TRINULLALPHA   "AAAAAAAAAAAAAAAA"

UNUMNULLALPHA

#define UNUMNULLALPHA   "AAAAAA=="

Function Documentation

kitty_blit()

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

Definition at line 1112 of file kitty.c.

                                        {
  return kitty_blit_core(n, linesize, data, leny, lenx, bargs,
                         NCPIXEL_KITTY_STATIC);
}

kitty_blit_animated()

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

Definition at line 1118 of file kitty.c.

                                                                     {
  return kitty_blit_core(n, linesize, data, leny, lenx, bargs,
                         NCPIXEL_KITTY_ANIMATED);
}

kitty_blit_selfref()

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

Definition at line 1124 of file kitty.c.

                                                                    {
  return kitty_blit_core(n, linesize, data, leny, lenx, bargs,
                         NCPIXEL_KITTY_SELFREF);
}

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 tinfo *	ti,
		const ncpile *	p,
		sprixel *	s,
		fbuf *	f,
		int	yoff,
		int	xoff
	)

Definition at line 1170 of file kitty.c.

                                  {
  (void)ti;
  (void)p;
  bool animated = false;
  if(s->animating){ // active animation
    s->animating = false;
    animated = true;
  }
  int ret = s->glyph.used;
  logdebug("dumping %" PRIu64 "b for %u at %d %d", s->glyph.used, s->id, yoff, xoff);
  if(ret){
    if(fbuf_putn(f, s->glyph.buf, s->glyph.used) < 0){
      ret = -1;
    }
  }
  if(animated){
    fbuf_free(&s->glyph);
  }
  s->invalidated = SPRIXEL_LOADED;
  return ret;
}

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_recycle()

sprixel * kitty_recycle

(

ncplane *

n

)

Definition at line 427 of file kitty.c.

                                  {
  assert(n->sprite);
  sprixel* hides = n->sprite;
  int dimy = hides->dimy;
  int dimx = hides->dimx;
  sprixel_hide(hides);
  return sprixel_alloc(n, dimy, dimx);
}

Here is the call graph for this function:

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 ncpile *	p,
		sprixel *	s
	)

Definition at line 1139 of file kitty.c.

                                            {
//fprintf(stderr, "FROM: %d/%d state: %d s->n: %p\n", s->movedfromy, s->movedfromx, s->invalidated, s->n);
  for(unsigned yy = s->movedfromy ; yy < s->movedfromy + s->dimy && yy < p->dimy ; ++yy){
    for(unsigned xx = s->movedfromx ; xx < s->movedfromx + s->dimx && xx < p->dimx ; ++xx){
      const int ridx = yy * p->dimx + xx;
      assert(0 <= ridx);
      struct crender *r = &p->crender[ridx];
      if(!r->sprixel){
        if(s->n){
//fprintf(stderr, "CHECKING %d/%d\n", yy - s->movedfromy, xx - s->movedfromx);
          sprixcell_e state = sprixel_state(s, yy - s->movedfromy + s->n->absy,
                                              xx - s->movedfromx + s->n->absx);
          if(state == SPRIXCELL_OPAQUE_KITTY){
            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;
          }
        }else{
          // need this to damage cells underneath a sprixel we're removing
          r->s.damaged = 1;
        }
      }
    }
  }
  return 0;
}

Here is the call graph for this function:

kitty_trans_auxvec()

uint8_t * kitty_trans_auxvec

(

const ncpile *

p

)

Definition at line 342 of file kitty.c.

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

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