pixels.c File Reference

#include "xcftools.h"
#include "pixels.h"
#include <assert.h>
#include <string.h>

Go to the source code of this file.

Classes
struct	_convertParams

Macros
#define	DEBUG
#define	DEF(X)   case GIMP_##X##_IMAGE: layer->pixels.params = &convert##X; break
#define	OPAQUE   (255 << ALPHA_SHIFT)
#define	REUSE_RAW_DATA   tiles->tileptrs = (uint32_t*)(xcf_file + ptr)
#define	RGB_SHIFT   RED_SHIFT, GREEN_SHIFT, BLUE_SHIFT

Typedefs
typedef const struct _convertParams	convertParams

Functions
void	applyMask (struct Tile *tile, struct Tile *mask)
static int	copyRLEpixels (rgba *dest, unsigned npixels, uint32_t ptr, convertParams *params)
static int	copyStraightPixels (rgba *dest, unsigned npixels, uint32_t ptr, convertParams *params)
static int	copyTilePixels (struct Tile *dest, uint32_t ptr, convertParams *params)
int	degrayPixel (rgba pixel)
void	fillTile (struct Tile *tile, rgba data)
struct Tile *	forkTile (struct Tile *tile)
void	freeTile (struct Tile *tile)
struct Tile *	getLayerTile (struct xcfLayer *layer, const struct rect *where)
struct Tile *	getMaskOrLayerTile (struct tileDimensions *dim, struct xcfTiles *tiles, struct rect want)
int	initColormap (void)
int	initLayer (struct xcfLayer *layer)
static int	initTileDirectory (struct tileDimensions *dim, struct xcfTiles *tiles, const char *type)
struct Tile *	newTile (struct rect r)
static int	tileDirectoryOneLevel (struct tileDimensions *dim, uint32_t ptr, int *ptrOut)
summary_t	tileSummary (struct Tile *tile)

Variables
rgba	colormap [256]
unsigned	colormapLength =0
static convertParams	convertChannel = { 1, {ALPHA_SHIFT}, 0, 0 }
static convertParams	convertColormap = { 3, {RGB_SHIFT}, 0, 0 }
static convertParams	convertGRAY = { 1, {-1}, OPAQUE, graytable }
static convertParams	convertGRAYA = { 2, {-1,ALPHA_SHIFT}, 0, graytable }
static convertParams	convertINDEXED = { 1, {-1}, OPAQUE, colormap }
static convertParams	convertINDEXEDA = { 2, {-1,ALPHA_SHIFT}, 0, colormap }
static convertParams	convertRGB = { 3, {RGB_SHIFT}, OPAQUE, 0 }
static convertParams	convertRGBA = { 4, {RGB_SHIFT, ALPHA_SHIFT}, 0,0 }

Macro Definition Documentation

DEBUG

#define DEBUG

Definition at line 19 of file pixels.c.

DEF

#define DEF

(

X

)

case GIMP_##X##_IMAGE: layer->pixels.params = &convert##X; break

OPAQUE

#define OPAQUE   (255 << ALPHA_SHIFT)

Definition at line 49 of file pixels.c.

REUSE_RAW_DATA

#define REUSE_RAW_DATA   tiles->tileptrs = (uint32_t*)(xcf_file + ptr)

RGB_SHIFT

#define RGB_SHIFT   RED_SHIFT, GREEN_SHIFT, BLUE_SHIFT

Definition at line 45 of file pixels.c.

Typedef Documentation

convertParams

typedef const struct _convertParams convertParams

Function Documentation

applyMask()

void applyMask	(	struct Tile *	tile,
		struct Tile *	mask )

Definition at line 531 of file pixels.c.

{
  unsigned i ;
  assertTileCompatibility(tile,mask);
  assert( tile->count == mask->count );
  INIT_SCALETABLE_IF(1);
  invalidateSummary(tile,0);
  for( i=0; i < tile->count ;i++ )
    tile->pixels[i] = NEWALPHA(tile->pixels[i],
                               scaletable[mask->pixels[i]>>ALPHA_SHIFT]
                                         [ALPHA(tile->pixels[i])]);
  freeTile(mask);
}

References ALPHA, ALPHA_SHIFT, assertTileCompatibility, Tile::count, freeTile(), INIT_SCALETABLE_IF, invalidateSummary, NEWALPHA, Tile::pixels, and scaletable.

copyRLEpixels()

static int copyRLEpixels ( rgba * dest, unsigned npixels, uint32_t ptr, convertParams * params )

inlinestatic

Definition at line 327 of file pixels.c.

{
  unsigned i,j ;
  rgba base_pixel = params->base_pixel ;
 
#ifdef xDEBUG
  fprintf(stderr,"RLE stream at %x, want %u x %u pixels, base %x\n",
          ptr,params->bpp,npixels,base_pixel);
#endif
 
  /* This algorithm depends on the indexed byte always being the first one */
  if( params->shift[0] < -1 )
    base_pixel = 0 ;
  for( j = npixels ; j-- ; )
    dest[j] = base_pixel ;
 
  for( i = 0 ; i < params->bpp ; i++ ) {
    int shift = params->shift[i] ;
    if( shift < 0 )
      shift = 0 ;
    for( j = 0 ; j < npixels ; ) {
      int countspec ;
      unsigned count ;
      if (xcfCheckspace(ptr,2,"RLE data stream") != XCF_OK) {
          return XCF_ERROR;
      }
      countspec = (int8_t) xcf_file[ptr++] ;
      count = countspec >= 0 ? countspec+1 : -countspec ;
      if( count == 128 ) {
          if (xcfCheckspace(ptr,3,"RLE long count") != XCF_OK) {
              return XCF_ERROR;
          }
        count = xcf_file[ptr++] << 8 ;
        count += xcf_file[ptr++] ;
      }
      if( j + count > npixels ) {
        FatalBadXCF("Overlong RLE run at %"PRIX32" (plane %u, %u left)",
                    ptr,i,npixels-j);
        return XCF_ERROR;
      }
      if( countspec >= 0 ) {
        rgba data = (uint32_t) xcf_file[ptr++] << shift ;
        while( count-- )
          dest[j++] += data ;
      } else {
        while( count-- )
          dest[j++] += (uint32_t) xcf_file[ptr++] << shift ;
      }
    }
    if( i == 0 && params->shift[0] < 0 ) {
      const rgba *lookup = params->lookup ;
      base_pixel = params->base_pixel ;
      for( j = npixels ; j-- ; ) {
        dest[j] = lookup[dest[j]-base_pixel] + base_pixel ;
      }
    }
  }
#ifdef xDEBUG
  fprintf(stderr,"RLE decoding OK at %"PRIX32"\n",ptr);
  /*
  for( j = 0 ; j < npixels ; j++ ) {
    if( j % 8 == 0 ) fprintf(stderr,"\n");
    fprintf(stderr," %8x",dest[j]);
  }
  fprintf(stderr,"\n");
  */
#endif
    return XCF_OK;
}

References _convertParams::base_pixel, _convertParams::bpp, Tile::count, FatalBadXCF(), _convertParams::lookup, _convertParams::shift, XCF_ERROR, xcf_file, XCF_OK, and xcfCheckspace().

copyStraightPixels()

static int copyStraightPixels ( rgba * dest, unsigned npixels, uint32_t ptr, convertParams * params )

static

Definition at line 299 of file pixels.c.

{
  unsigned bpp = params->bpp;
  const rgba *lookup = params->lookup;
  rgba base_pixel = params->base_pixel ;
  uint8_t *bp = xcf_file + ptr ;
  int response;
  if ((response = xcfCheckspace(ptr,bpp*npixels,
                                "pixel array (%u x %d bpp) at %"PRIX32,npixels,bpp,ptr)) != XCF_OK) {
      return XCF_ERROR;
  }
  while( npixels-- ) {
    rgba pixel = base_pixel ;
    unsigned i ;
    for( i = 0 ; i < bpp ; i++ ) {
      if( params->shift[i] < 0 ) {
        pixel += lookup[*bp++] ;
      } else {
        pixel += *bp++ << params->shift[i] ;
      }
    }
    *dest++ = pixel ;
  }
  return XCF_OK;
}

References _convertParams::base_pixel, _convertParams::bpp, _convertParams::lookup, _convertParams::shift, XCF_ERROR, xcf_file, XCF_OK, and xcfCheckspace().

copyTilePixels()

static int copyTilePixels ( struct Tile * dest, uint32_t ptr, convertParams * params )

inlinestatic

Definition at line 398 of file pixels.c.

{
  if( FULLALPHA(params->base_pixel) )
    dest->summary = TILESUMMARY_UPTODATE+TILESUMMARY_ALLFULL+TILESUMMARY_CRISP;
  else
    dest->summary = 0 ;
  switch( XCF.compression ) {
  case COMPRESS_NONE:
      if (copyStraightPixels(dest->pixels,dest->count,ptr,params) != XCF_OK) {
          return XCF_ERROR;
      }
    break ;
  case COMPRESS_RLE:
      if (copyRLEpixels(dest->pixels,dest->count,ptr,params) != XCF_OK) {
          return XCF_ERROR;
      }
    break ;
  default:
    {
        FatalUnsupportedXCF(_("%s compression"),
                        _(showXcfCompressionType(XCF.compression)));
        return XCF_ERROR;
    }
  }
  return XCF_OK;
}

References _, _convertParams::base_pixel, COMPRESS_NONE, COMPRESS_RLE, xcfImage::compression, copyRLEpixels(), copyStraightPixels(), Tile::count, FatalUnsupportedXCF(), FULLALPHA, Tile::pixels, showXcfCompressionType(), Tile::summary, TILESUMMARY_ALLFULL, TILESUMMARY_CRISP, TILESUMMARY_UPTODATE, XCF, XCF_ERROR, and XCF_OK.

degrayPixel()

int degrayPixel

(

rgba

pixel

)

Definition at line 29 of file pixels.c.

{
  if( ((pixel >> RED_SHIFT) & 255) == ((pixel >> GREEN_SHIFT) & 255) &&
      ((pixel >> RED_SHIFT) & 255) == ((pixel >> BLUE_SHIFT) & 255) )
    return (pixel >> RED_SHIFT) & 255 ;
  return -1 ;
}

References BLUE_SHIFT, GREEN_SHIFT, and RED_SHIFT.

fillTile()

void fillTile	(	struct Tile *	tile,
		rgba	data )

Definition at line 283 of file pixels.c.

{
  unsigned i ;
  for( i = 0 ; i < tile->count ; i++ )
    tile->pixels[i] = data ;
  if( FULLALPHA(data) )
    tile->summary = TILESUMMARY_UPTODATE+TILESUMMARY_ALLFULL+TILESUMMARY_CRISP;
  else if (NULLALPHA(data) )
    tile->summary = TILESUMMARY_UPTODATE+TILESUMMARY_ALLNULL+TILESUMMARY_CRISP;
  else
    tile->summary = TILESUMMARY_UPTODATE ;
}

References Tile::count, FULLALPHA, NULLALPHA, Tile::pixels, Tile::summary, TILESUMMARY_ALLFULL, TILESUMMARY_ALLNULL, TILESUMMARY_CRISP, and TILESUMMARY_UPTODATE.

forkTile()

struct Tile * forkTile

(

struct Tile *

tile

)

Definition at line 244 of file pixels.c.

{
  if( ++tile->refcount <= 0 ) {
    FatalUnsupportedXCF(_("Unbelievably many layers?\n"
                          "More likely to be a bug in %s"),progname);
    return XCF_PTR_EMPTY;
  }
  return tile ;
}

References _, FatalUnsupportedXCF(), progname, Tile::refcount, and XCF_PTR_EMPTY.

freeTile()

void freeTile

(

struct Tile *

tile

)

Definition at line 255 of file pixels.c.

{
  if( --tile->refcount == 0 )
    xcffree(tile) ;
}

References Tile::refcount, and xcffree().

getLayerTile()

struct Tile * getLayerTile	(	struct xcfLayer *	layer,
		const struct rect *	where )

Definition at line 546 of file pixels.c.

{
  struct Tile *data ;
 
#ifdef xDEBUG
  fprintf(stderr,"getLayerTile(%s): (%d-%d),(%d-%d)\n",
          layer->name,where->l,where->r,where->t,where->b);
#endif
 
  if( disjointRects(*where,layer->dim.c) ||
      layer->opacity == 0 ) {
    data = newTile(*where);
    fillTile(data,0);
    return data ;
  }
 
  data = getMaskOrLayerTile(&layer->dim,&layer->pixels,*where);
  if (data == XCF_PTR_EMPTY) {
      return XCF_PTR_EMPTY;
  }
  if( (data->summary & TILESUMMARY_ALLNULL) != 0 )
    return data ;
  if( layer->hasMask ) {
    struct Tile *mask = getMaskOrLayerTile(&layer->dim,&layer->mask,*where);
    if (mask == XCF_PTR_EMPTY) { /* error */
        freeTile(data);
        return XCF_PTR_EMPTY;
    }
    applyMask(data,mask);
  }
  if( layer->opacity < 255 ) {
    const uint8_t *ourtable ;
    int i ;
    invalidateSummary(data,~(TILESUMMARY_CRISP | TILESUMMARY_ALLFULL));
    INIT_SCALETABLE_IF(1);
    ourtable = scaletable[layer->opacity] ;
    for( i=0; i < data->count; i++ )
      data->pixels[i]
        = NEWALPHA(data->pixels[i],ourtable[ALPHA(data->pixels[i])]) ;
  }
  return data ;
}

References ALPHA, applyMask(), rect::b, tileDimensions::c, Tile::count, xcfLayer::dim, disjointRects, fillTile(), freeTile(), getMaskOrLayerTile(), xcfLayer::hasMask, INIT_SCALETABLE_IF, invalidateSummary, rect::l, xcfLayer::mask, xcfLayer::name, NEWALPHA, newTile(), xcfLayer::opacity, Tile::pixels, xcfLayer::pixels, rect::r, scaletable, Tile::summary, rect::t, TILESUMMARY_ALLFULL, TILESUMMARY_ALLNULL, TILESUMMARY_CRISP, and XCF_PTR_EMPTY.

getMaskOrLayerTile()

struct Tile * getMaskOrLayerTile	(	struct tileDimensions *	dim,
		struct xcfTiles *	tiles,
		struct rect	want )

Definition at line 427 of file pixels.c.

{
  struct Tile *tile = newTile(want);
 
  if (want.l >= want.r || want.t >= want.b ) {
      freeTile(tile);
      return XCF_PTR_EMPTY;
  }
 
  if( tiles->tileptrs == 0 ) {
    fillTile(tile,0);
    return tile ;
  }
 
#ifdef xDEBUG
  fprintf(stderr,"getMaskOrLayer: (%d-%d),(%d-%d)\n",left,right,top,bottom);
#endif
 
  if( isSubrect(want,dim->c) &&
      (want.l - dim->c.l) % TILE_WIDTH == 0 &&
      (want.t - dim->c.t) % TILE_HEIGHT == 0 ) {
    int tx = TILE_NUM(want.l - dim->c.l);
    int ty = TILE_NUM(want.t - dim->c.t);
    if( want.r == TILEXn(*dim,tx+1) && want.b == TILEYn(*dim,ty+1) ) {
      /* The common case? An entire single tile from the layer */
        if (copyTilePixels(tile,tiles->tileptrs[tx + ty*dim->tilesx],tiles->params) != XCF_OK) {
            freeTile(tile);
            return XCF_PTR_EMPTY;
        }
      return tile ;
    }
  }
 
  /* OK, we must construct the wanted tile as a jigsaw */
  {
    unsigned width = want.r-want.l ;
    rgba *pixvert = tile->pixels ;
    rgba *pixhoriz ;
    int y, ty, l0, l1 ;
    int x, tx, c0, c1 ;
    unsigned lstart, lnum ;
    unsigned cstart, cnum ;
 
    if( !isSubrect(want,dim->c) ) {
      if( want.l < dim->c.l ) pixvert += (dim->c.l - want.l),
                                want.l = dim->c.l ;
      if( want.r > dim->c.r ) want.r = dim->c.r ;
      if( want.t < dim->c.t ) pixvert += (dim->c.t - want.t) * width,
                                want.t = dim->c.t ;
      if( want.b > dim->c.b ) want.b = dim->c.b ;
      fillTile(tile,0);
    } else {
      tile->summary = -1 ; /* I.e. whatever the jigsaw pieces say */
    }
 
#ifdef xDEBUG
    fprintf(stderr,"jig0 (%d-%d),(%d-%d)\n",left,right,top,bottom);
#endif
 
    for( y=want.t, ty=TILE_NUM(want.t-dim->c.t), l0=TILEYn(*dim,ty);
         y<want.b;
         pixvert += lnum*width, ty++, y=l0=l1 ) {
      l1 = TILEYn(*dim,ty+1) ;
      lstart = y - l0 ;
      lnum = (l1 > want.b ? want.b : l1) - y ;
 
      pixhoriz = pixvert ;
      for( x=want.l, tx=TILE_NUM(want.l-dim->c.l), c0=TILEXn(*dim,tx);
           x<want.r;
           pixhoriz += cnum, tx++, x=c0=c1 ) {
        c1 = TILEXn(*dim,tx+1);
        cstart = x - c0 ;
        cnum = (c1 > want.r ? want.r : c1) - x ;
 
        {
          static struct Tile tmptile ;
          unsigned dwidth = c1-c0 ;
          unsigned i, j ;
          tmptile.count = (c1-c0)*(l1-l0) ;
#ifdef xDEBUG
          fprintf(stderr,"jig ty=%u(%u-%u-%u)(%u+%u) tx=%u(%u-%u-%u)(%u+%u)\n",
                  ty,l0,y,l1,lstart,lnum,
                  tx,c0,x,c1,cstart,cnum);
#endif
          if (copyTilePixels(&tmptile,
                             tiles->tileptrs[tx+ty*dim->tilesx],tiles->params) != XCF_OK) {
              freeTile(tile);
              return XCF_PTR_EMPTY;
          }
 
          for(i=0; i<lnum; i++)
            for(j=0; j<cnum; j++)
              pixhoriz[i*width+j]
                = tmptile.pixels[(i+lstart)*dwidth+(j+cstart)];
          tile->summary &= tmptile.summary ;
        }
      }
    }
  }
  return tile ;
}

References rect::b, tileDimensions::c, copyTilePixels(), Tile::count, fillTile(), freeTile(), isSubrect, rect::l, newTile(), xcfTiles::params, Tile::pixels, rect::r, Tile::summary, rect::t, TILE_HEIGHT, TILE_NUM, TILE_WIDTH, xcfTiles::tileptrs, tileDimensions::tilesx, TILEXn, TILEYn, XCF_OK, and XCF_PTR_EMPTY.

initColormap()

int initColormap

(

void

)

Definition at line 199 of file pixels.c.

                   {
  uint32_t ncolors ;
  if( XCF.colormapptr == 0 ) {
    colormapLength = 0 ;
    return XCF_OK;
  }
  ncolors = xcfL(XCF.colormapptr) ;
  if( ncolors > 256 ) {
    FatalUnsupportedXCF(_("Color map has more than 256 entries"));
    return XCF_ERROR;
  }
  if(copyStraightPixels(colormap,ncolors,XCF.colormapptr+4,&convertColormap) != XCF_OK) {
      return XCF_ERROR;
  }
  colormapLength = ncolors ;
#ifdef xDEBUG
  {
    unsigned j ;
    fprintf(stderr,"Colormap decoding OK\n");
    for( j = 0 ; j < ncolors ; j++ ) {
      if( j % 8 == 0 ) fprintf(stderr,"\n");
      fprintf(stderr," %08x",colormap[j]);
    }
    fprintf(stderr,"\n");
  }
#endif
    return XCF_OK;
}

References _, colormap, colormapLength, xcfImage::colormapptr, convertColormap, copyStraightPixels(), FatalUnsupportedXCF(), XCF, XCF_ERROR, XCF_OK, and xcfL.

initLayer()

int initLayer

(

struct xcfLayer *

layer

)

Definition at line 167 of file pixels.c.

                                  {
  if( layer->dim.ntiles == 0 ||
      (layer->pixels.hierarchy == 0 && layer->mask.hierarchy == 0) )
    return XCF_OK;
  switch(layer->type) {
#define DEF(X) case GIMP_##X##_IMAGE: layer->pixels.params = &convert##X; break
    DEF(RGB);
    DEF(RGBA);
    DEF(GRAY);
    DEF(GRAYA);
    DEF(INDEXED);
    DEF(INDEXEDA);
  default:
    {
        FatalUnsupportedXCF(_("Layer type %s"),_(showGimpImageType(layer->type)));
        return XCF_ERROR;
    }
 
  }
  if (initTileDirectory(&layer->dim,&layer->pixels,
                                    _(showGimpImageType(layer->type)))  != XCF_OK) {
      return XCF_ERROR;
  }
  layer->mask.params = &convertChannel ;
  if (initTileDirectory(&layer->dim,&layer->mask,"layer mask") != XCF_OK) {
          return XCF_ERROR;
   }
  return XCF_OK;
}

References _, convertChannel, DEF, xcfLayer::dim, FatalUnsupportedXCF(), xcfTiles::hierarchy, initTileDirectory(), xcfLayer::mask, tileDimensions::ntiles, xcfTiles::params, xcfLayer::pixels, RGB, RGBA, showGimpImageType(), xcfLayer::type, XCF_ERROR, and XCF_OK.

initTileDirectory()

static int initTileDirectory ( struct tileDimensions * dim, struct xcfTiles * tiles, const char * type )

static

Definition at line 80 of file pixels.c.

{
  uint32_t ptr ;
  uint32_t data ;
 
  ptr = tiles->hierarchy ;
  tiles->hierarchy = 0 ;
  int ptrOut;
  if (tileDirectoryOneLevel(dim,ptr, &ptrOut) != XCF_OK) {
      return XCF_ERROR;
  }
  if (ptrOut == XCF_PTR_EMPTY) {
      return XCF_OK;
  }
  ptr = ptrOut;
  if( tiles->params == &convertChannel ) {
    /* A layer mask is a channel.
     * Skip a name and a property list.
     */
     xcfString(ptr,&ptr);
    PropType type;
    int response;
    while( (response = xcfNextprop(&ptr,&data, &type)) != XCF_ERROR && type != PROP_END ) {
 
    }
    if (response != XCF_OK) {
        return XCF_ERROR;
    }
    uint32_t ptrout;
    if(xcfOffset(ptr,4*4, &ptrout) != XCF_OK) return XCF_ERROR;
    ptr = ptrout;
    if (tileDirectoryOneLevel(dim,ptr, &ptrOut) != XCF_OK) {
        return XCF_ERROR;
    }
    if (ptrOut == XCF_PTR_EMPTY) {
        return XCF_OK;
    }
    ptr = ptrOut;
  }
  /* The XCF format has a dummy "hierarchy" level which was
   * once meant to mean something, but never happened. It contains
   * the bpp value and a list of "level" pointers; but only the
   * first level actually contains data.
   */
  data = xcfL(ptr) ;
  if( xcfL(ptr) != tiles->params->bpp ) {
      FatalBadXCF("%" PRIuPTR " bytes per pixel for %s drawable",
                  xcfL(ptr),
                  type);
      return XCF_ERROR;
  }
  uint32_t ptrout;
  if(xcfOffset(ptr+4,3*4, &ptrout) != XCF_OK) return XCF_ERROR;
  ptr = ptrout;
  if (tileDirectoryOneLevel(dim,ptr, &ptrOut) != XCF_OK) {
      return XCF_ERROR;
  }
  if (ptrOut == XCF_PTR_EMPTY) {
      return XCF_OK;
  }
  ptr = ptrOut;
 
  if (xcfCheckspace(ptr,dim->ntiles*4+4,"Tile directory at %" PRIX32,ptr) != XCF_OK) {
      return XCF_ERROR;
  }
/*  if( xcfL(ptr + dim->ntiles*4) != 0 )
    FatalBadXCF("Wrong sized tile directory at %" PRIX32,ptr);*/
 
#define REUSE_RAW_DATA tiles->tileptrs = (uint32_t*)(xcf_file + ptr)
#if defined(WORDS_BIGENDIAN) && defined(CAN_DO_UNALIGNED_WORDS)
  REUSE_RAW_DATA;
#else
# if defined(WORDS_BIGENDIAN)
  if( (ptr&3) == 0 ) REUSE_RAW_DATA; else
# endif
    {
      unsigned i ;
      tiles->tileptrs = xcfmalloc(dim->ntiles * sizeof(uint32_t)) ;
      for( i = 0 ; i < dim->ntiles ; i++ )
        tiles->tileptrs[i] = xcfL(ptr+i*4);
    }
#endif
  return XCF_OK;
}

References _convertParams::bpp, convertChannel, FatalBadXCF(), xcfTiles::hierarchy, tileDimensions::ntiles, xcfTiles::params, PROP_END, REUSE_RAW_DATA, tileDirectoryOneLevel(), xcfTiles::tileptrs, XCF_ERROR, XCF_OK, XCF_PTR_EMPTY, xcfCheckspace(), xcfL, xcfmalloc(), xcfNextprop(), xcfOffset(), and xcfString().

newTile()

struct Tile * newTile

(

struct rect

r

)

Definition at line 231 of file pixels.c.

{
  unsigned npixels = (unsigned)(r.b-r.t) * (unsigned)(r.r-r.l) ;
  struct Tile *data
    = xcfmalloc(sizeof(struct Tile) -
                sizeof(rgba)*(TILE_HEIGHT*TILE_WIDTH - npixels)) ;
  data->count = npixels ;
  data->refcount = 1 ;
  data->summary = 0 ;
  return data ;
}

References Tile::count, Tile::refcount, Tile::summary, TILE_HEIGHT, TILE_WIDTH, and xcfmalloc().

tileDirectoryOneLevel()

static int tileDirectoryOneLevel ( struct tileDimensions * dim, uint32_t ptr, int * ptrOut )

inlinestatic

Definition at line 63 of file pixels.c.

{
  if( ptr == 0 ) {
      *ptrOut = 0;
    return XCF_OK; /* allowed by xcf, apparently */
  }
  if( xcfL(ptr  ) != dim->c.r - dim->c.l ||
          xcfL(ptr+4) != dim->c.b - dim->c.t ) {
    FatalBadXCF("Drawable size mismatch at %" PRIX32, ptr);
    *ptrOut = XCF_PTR_EMPTY;
    return XCF_ERROR;
  }
  *ptrOut = (ptr += 8) ;
  return XCF_OK;
}

References rect::b, tileDimensions::c, FatalBadXCF(), rect::l, rect::r, rect::t, XCF_ERROR, XCF_OK, XCF_PTR_EMPTY, and xcfL.

tileSummary()

summary_t tileSummary

(

struct Tile *

tile

)

Definition at line 262 of file pixels.c.

{
  unsigned i ;
  summary_t summary ;
  if( (tile->summary & TILESUMMARY_UPTODATE) != 0 )
    return tile->summary ;
  summary = TILESUMMARY_ALLNULL + TILESUMMARY_ALLFULL + TILESUMMARY_CRISP ;
  for( i=0; summary && i<tile->count; i++ ) {
    if( FULLALPHA(tile->pixels[i]) )
      summary &= ~TILESUMMARY_ALLNULL ;
    else if( NULLALPHA(tile->pixels[i]) )
      summary &= ~TILESUMMARY_ALLFULL ;
    else
      summary = 0 ;
  }
  summary += TILESUMMARY_UPTODATE ;
  tile->summary = summary ;
  return summary ;
}

References Tile::count, FULLALPHA, NULLALPHA, Tile::pixels, Tile::summary, TILESUMMARY_ALLFULL, TILESUMMARY_ALLNULL, TILESUMMARY_CRISP, and TILESUMMARY_UPTODATE.

Variable Documentation

colormap

rgba colormap[256]

Definition at line 25 of file pixels.c.

colormapLength

unsigned colormapLength =0

Definition at line 26 of file pixels.c.

convertChannel

convertParams convertChannel = { 1, {ALPHA_SHIFT}, 0, 0 }

static

Definition at line 58 of file pixels.c.

{ 1, {ALPHA_SHIFT}, 0, 0 };

convertColormap

convertParams convertColormap = { 3, {RGB_SHIFT}, 0, 0 }

static

Definition at line 57 of file pixels.c.

{ 3, {RGB_SHIFT}, 0, 0 };

convertGRAY

convertParams convertGRAY = { 1, {-1}, OPAQUE, graytable }

static

Definition at line 52 of file pixels.c.

{ 1, {-1}, OPAQUE, graytable };

convertGRAYA

convertParams convertGRAYA = { 2, {-1,ALPHA_SHIFT}, 0, graytable }

static

Definition at line 53 of file pixels.c.

{ 2, {-1,ALPHA_SHIFT}, 0, graytable };

convertINDEXED

convertParams convertINDEXED = { 1, {-1}, OPAQUE, colormap }

static

Definition at line 54 of file pixels.c.

{ 1, {-1}, OPAQUE, colormap };

convertINDEXEDA

convertParams convertINDEXEDA = { 2, {-1,ALPHA_SHIFT}, 0, colormap }

static

Definition at line 55 of file pixels.c.

{ 2, {-1,ALPHA_SHIFT}, 0, colormap };

convertRGB

convertParams convertRGB = { 3, {RGB_SHIFT}, OPAQUE, 0 }

static

Definition at line 50 of file pixels.c.

{ 3, {RGB_SHIFT}, OPAQUE, 0 };

convertRGBA

convertParams convertRGBA = { 4, {RGB_SHIFT, ALPHA_SHIFT}, 0,0 }

static

Definition at line 51 of file pixels.c.

{ 4, {RGB_SHIFT, ALPHA_SHIFT}, 0,0 };