blit.c File Reference

#include <stddef.h>
#include <inttypes.h>
#include "internal.h"

Include dependency graph for blit.c:

Go to the source code of this file.

Data Structures
struct	qdriver

Macros
#define	E(bits)   (1u << (bits))

Functions
void	set_pixel_blitter (ncblitter blitfxn)
const struct blitset *	lookup_blitset (const tinfo *tcache, ncblitter_e setid, bool may_degrade)
int	notcurses_lex_blitter (const char *op, ncblitter_e *blitfxn)
const char *	notcurses_str_blitter (ncblitter_e blitfxn)
int	ncblit_bgrx (const void *data, int linesize, const struct ncvisual_options *vopts)
int	ncblit_rgb_loose (const void *data, int linesize, const struct ncvisual_options *vopts, int alpha)
int	ncblit_rgb_packed (const void *data, int linesize, const struct ncvisual_options *vopts, int alpha)
int	ncblit_rgba (const void *data, int linesize, const struct ncvisual_options *vopts)
ncblitter_e	ncvisual_media_defblitter (const notcurses *nc, ncscale_e scale)

Macro Definition Documentation

E

#define E

(

bits

)

(1u << (bits))

Function Documentation

lookup_blitset()

const struct blitset * lookup_blitset	(	const tinfo *	tcache,
		ncblitter_e	setid,
		bool	may_degrade
	)

Definition at line 1297 of file blit.c.

                                                      {
  if(setid == NCBLIT_DEFAULT){ // ought have resolved NCBLIT_DEFAULT before now
    return NULL;
  }
  // without braille support, NCBLIT_BRAILLE decays to NCBLIT_4x2
  if(setid == NCBLIT_BRAILLE){
    if(tcache->caps.braille){
      return &notcurses_blitters[setid - 1];
    }else if(!may_degrade){
      return NULL;
    }
    setid = NCBLIT_4x2;
  }
  // without octant support, NCBLIT_4x2 decays to NCBLIT_3x2
  if(setid == NCBLIT_4x2){
    if(tcache->caps.octants){
       return &notcurses_blitters[setid - 1];
    }else if(!may_degrade){
      return NULL;
    }
    setid = NCBLIT_3x2;
  }
  // without bitmap support, NCBLIT_PIXEL decays to NCBLIT_3x2
  if(setid == NCBLIT_PIXEL){
    if(tcache->pixel_draw || tcache->pixel_draw_late){
      return &notcurses_blitters[setid - 1];
    }else if(!may_degrade){
      return NULL;
    }
    setid = NCBLIT_3x2;
  }
  // without eighths support, NCBLIT_8x1 decays to NCBLIT_4x1
  if(setid == NCBLIT_8x1){ // plotter only
    if(tcache->caps.quadrants){
       return &notcurses_blitters[setid - 1];
    }else if(!may_degrade){
      return NULL;
    }
    setid = NCBLIT_4x1;
  }
  // without quarters support, NCBLIT_4x1 decays to NCBLIT_2x1
  if(setid == NCBLIT_4x1){ // plotter only
    if(tcache->caps.quadrants){
       return &notcurses_blitters[setid - 1];
    }else if(!may_degrade){
      return NULL;
    }
    setid = NCBLIT_2x1;
  }
  // without sextant support, NCBLIT_3x2 decays to NCBLIT_2x2
  if(setid == NCBLIT_3x2){
    if(tcache->caps.sextants){
       return &notcurses_blitters[setid - 1];
    }else if(!may_degrade){
      return NULL;
    }
    setid = NCBLIT_2x2;
  }
  // without quadrant support, NCBLIT_2x2 decays to NCBLIT_2x1
  if(setid == NCBLIT_2x2){
    if(tcache->caps.quadrants){
       return &notcurses_blitters[setid - 1];
    }else if(!may_degrade){
      return NULL;
    }
    setid = NCBLIT_2x1;
  }
  // without halfblock support, NCBLIT_2x1 decays to NCBLIT_1x1
  if(setid == NCBLIT_2x1){
    if(tcache->caps.halfblocks){
       return &notcurses_blitters[setid - 1];
    }else if(!may_degrade){
      return NULL;
    }
    setid = NCBLIT_1x1;
  }
  assert(NCBLIT_1x1 == setid);
  return &notcurses_blitters[setid - 1];
}

Here is the call graph for this function:

ncblit_bgrx()

int ncblit_bgrx	(	const void *	data,
		int	linesize,
		const struct ncvisual_options *	vopts
	)

Definition at line 1408 of file blit.c.

                                                                                     {
  if(vopts->leny <= 0 || vopts->lenx <= 0){
    logerror("invalid lengths %u %u", vopts->leny, vopts->lenx);
    return -1;
  }
  if(vopts->n == NULL){
    logerror("prohibited null plane");
    return -1;
  }
  void* rdata = bgra_to_rgba(data, vopts->leny, &linesize, vopts->lenx, 0xff);
  if(rdata == NULL){
    return -1;
  }
  int r = ncblit_rgba(rdata, linesize, vopts);
  free(rdata);
  return r;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncblit_rgb_loose()

int ncblit_rgb_loose	(	const void *	data,
		int	linesize,
		const struct ncvisual_options *	vopts,
		int	alpha
	)

Definition at line 1426 of file blit.c.

                                                                     {
  if(vopts->leny <= 0 || vopts->lenx <= 0){
    return -1;
  }
  void* rdata = rgb_loose_to_rgba(data, vopts->leny, &linesize, vopts->lenx, alpha);
  if(rdata == NULL){
    return -1;
  }
  int r = ncblit_rgba(rdata, linesize, vopts);
  free(rdata);
  return r;
}

Here is the call graph for this function:

ncblit_rgb_packed()

int ncblit_rgb_packed	(	const void *	data,
		int	linesize,
		const struct ncvisual_options *	vopts,
		int	alpha
	)

Definition at line 1440 of file blit.c.

                                                                      {
  if(vopts->leny <= 0 || vopts->lenx <= 0){
    return -1;
  }
  void* rdata = rgb_packed_to_rgba(data, vopts->leny, &linesize, vopts->lenx, alpha);
  if(rdata == NULL){
    return -1;
  }
  int r = ncblit_rgba(rdata, linesize, vopts);
  free(rdata);
  return r;
}

Here is the call graph for this function:

ncblit_rgba()

int ncblit_rgba	(	const void *	data,
		int	linesize,
		const struct ncvisual_options *	vopts
	)

Definition at line 1454 of file blit.c.

                                                                                     {
  if(vopts->leny <= 0 || vopts->lenx <= 0){
    logerror("invalid lengths %u %u", vopts->leny, vopts->lenx);
    return -1;
  }
  if(vopts->n == NULL){
    logerror("prohibited null plane");
    return -1;
  }
  struct ncvisual* ncv = ncvisual_from_rgba(data, vopts->leny, linesize, vopts->lenx);
  if(ncv == NULL){
    return -1;
  }
  if(ncvisual_blit(ncplane_notcurses(vopts->n), ncv, vopts) == NULL){
    ncvisual_destroy(ncv);
    return -1;
  }
  ncvisual_destroy(ncv);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ncvisual_media_defblitter()

ncblitter_e ncvisual_media_defblitter	(	const notcurses *	nc,
		ncscale_e	scale
	)

Definition at line 1475 of file blit.c.

                                                                           {
  return rgba_blitter_default(&nc->tcache, scale);
}

Here is the caller graph for this function:

notcurses_lex_blitter()

int notcurses_lex_blitter	(	const char *	op,
		ncblitter_e *	blitfxn
	)

Definition at line 1378 of file blit.c.

                                                               {
  const struct blitset* bset = notcurses_blitters;
  while(bset->name){
    if(strcasecmp(bset->name, op) == 0){
      *blitfxn = bset->geom;
      return 0;
    }
    ++bset;
  }
  if(strcasecmp("default", op) == 0){
    *blitfxn = NCBLIT_DEFAULT;
    return 0;
  }
  return -1;
}

Here is the caller graph for this function:

notcurses_str_blitter()

const char * notcurses_str_blitter

(

ncblitter_e

blitfxn

)

Definition at line 1394 of file blit.c.

                                                      {
  if(blitfxn == NCBLIT_DEFAULT){
    return "default";
  }
  const struct blitset* bset = notcurses_blitters;
  while(bset->name){
    if(bset->geom == blitfxn){
      return bset->name;
    }
    ++bset;
  }
  return NULL;
}

Here is the caller graph for this function:

set_pixel_blitter()

void set_pixel_blitter

(

ncblitter

blitfxn

)

Definition at line 1289 of file blit.c.

                                         {
  struct blitset* b = notcurses_blitters;
  while(b->geom != NCBLIT_PIXEL){
    ++b;
  }
  b->blit = blitfxn;
}