linux.c File Reference

#include "linux.h"
#include "internal.h"

Include dependency graph for linux.c:

Go to the source code of this file.

Functions
int	fbcon_wipe (sprixel *s, int ycell, int xcell)
int	fbcon_blit (struct ncplane *n, int linesize, const void *data, int leny, int lenx, const struct blitterargs *bargs)
int	fbcon_scrub (const struct ncpile *p, sprixel *s)
int	fbcon_rebuild (sprixel *s, int ycell, int xcell, uint8_t *auxvec)
int	fbcon_draw (const tinfo *ti, sprixel *s, int y, int x)
void	fbcon_scroll (const struct ncpile *p, tinfo *ti, int rows)
int	get_linux_fb_pixelgeom (tinfo *ti, unsigned *ypix, unsigned *xpix)

Function Documentation

fbcon_blit()

int fbcon_blit	(	struct ncplane *	n,
		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 tinfo *	ti,
		sprixel *	s,
		int	y,
		int	x
	)

Definition at line 799 of file linux.c.

                                                         {
  (void)ti;
  (void)s;
  (void)y;
  (void)x;
  return 0;
}

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

get_linux_fb_pixelgeom()

int get_linux_fb_pixelgeom	(	tinfo *	ti,
		unsigned *	ypix,
		unsigned *	xpix
	)

Definition at line 813 of file linux.c.

                                                                     {
  (void)ti;
  (void)ypix;
  (void)xpix;
  return -1;
}

Here is the caller graph for this function: