Logo Search packages:      
Sourcecode: xaos version File versions  Download package

emboss.c

#include <config.h>
#ifndef _plan9_
#ifdef NO_MALLOC_H
#include <stdlib.h>
#else
#include <malloc.h>
#endif
#include <stdio.h>
#else
#include <u.h>
#include <libc.h>
#include <stdio.h>
#endif
#include <filter.h>
#include <fractal.h>
#include <xthread.h>
struct embossdata
{
  struct palette *savedpalette, *palette;
  int xdist, ydist;
  unsigned int table[512];
};
static int
requirement (struct filter *f, struct requirements *r)
{
  f->req = *r;
  r->nimages = 1;
  r->flags &= ~(IMAGEDATA);
  r->supportedmask = GRAYSCALE | C256 | TRUECOLOR24 | TRUECOLOR | TRUECOLOR16;

  return (f->next->action->requirement (f->next, r));
}
static int
initialize (struct filter *f, struct initdata *i)
{
  int x;
  struct embossdata *s = (struct embossdata *) f->data;
  inhermisc (f, i);
  s->palette->size = 256 / 32;
  for (x = 0; x < 256 / 32; x++)
    s->palette->pixels[x] = x * 32;
#define SSTEP (32*8/64)
#define SSTEP2 (32*8/256)
  if (datalost (f, i) || i->image->version != f->imageversion)
    {
      if (s->savedpalette == NULL)
      s->savedpalette = clonepalette (i->image->palette);
      mkgraypalette (i->image->palette);
      if (i->image->palette->type & (C256 | GRAYSCALE))
      {
        for (x = 0; x < 256; x++)
          {
            int dist = (x + SSTEP - 1) / SSTEP;
            dist += 32;
            if (dist > 63)
            dist = 63;
            s->table[x] = i->image->palette->pixels[dist];
          }
        for (x = 256; x < 512; x++)
          {
            int dist = -(512 - x + SSTEP - 1) / SSTEP;
            dist += 32;
            if (dist < 0)
            dist = 0;
            s->table[x] = i->image->palette->pixels[dist];
          }
      }
      else
      {
        for (x = 0; x < 256; x++)
          {
            int dist = (x + SSTEP2 - 1) / SSTEP2;
            dist += 128;
            if (dist > 255)
            dist = 255;
            s->table[x] =
            ((dist >> i->image->palette->info.truec.rprec) << i->
             image->palette->info.truec.rshift) | ((dist >> i->image->
                                          palette->info.truec.
                                          gprec) << i->image->
                                           palette->info.
                                           truec.gshift) | ((dist
                                                       >>
                                                       i->
                                                       image->
                                                       palette->
                                                       info.
                                                       truec.
                                                       bprec)
                                                      << i->
                                                      image->
                                                      palette->
                                                      info.
                                                      truec.
                                                      bshift);

          }
        for (x = 256; x < 512; x++)
          {
            int dist = -(512 - x + SSTEP2 - 1) / SSTEP2;
            dist += 128;
            if (dist < 0)
            dist = 0;
            s->table[x] =
            ((dist >> i->image->palette->info.truec.rprec) << i->
             image->palette->info.truec.rshift) | ((dist >> i->image->
                                          palette->info.truec.
                                          gprec) << i->image->
                                           palette->info.
                                           truec.gshift) | ((dist
                                                       >>
                                                       i->
                                                       image->
                                                       palette->
                                                       info.
                                                       truec.
                                                       bprec)
                                                      << i->
                                                      image->
                                                      palette->
                                                      info.
                                                      truec.
                                                      bshift);
          }
      }
    }
  s->xdist = (int) (0.1 / i->image->pixelwidth);
  s->ydist = (int) (0.1 / i->image->pixelwidth);
  if (s->xdist < 1)
    s->xdist = 1;
  if (s->ydist < 1)
    s->ydist = 1;
  if (!inherimage
      (f, i, TOUCHIMAGE, i->image->width + s->xdist,
       i->image->height + s->ydist, s->palette, 0, 0))
    return 0;
  clear_image (f->image);
  setfractalpalette (f, s->savedpalette);
  return (f->previous->action->initialize (f->previous, i));
}
static struct filter *
getinstance (CONST struct filteraction *a)
{
  struct filter *f = createfilter (a);
  struct embossdata *i = (struct embossdata *) calloc (1, sizeof (*i));
  i->savedpalette = NULL;
  i->palette =
    createpalette (0, 256, GRAYSCALE, 0, 256, NULL, NULL, NULL, NULL, NULL);
  f->childimage = NULL;
  f->data = i;
  f->name = "Emboss";
  return (f);
}
static void
emboss8 (void *data, struct taskinfo *task, int r1, int r2)
{
  pixel8_t *src, *srcend, *src2;
  pixel8_t *dest;
  struct filter *f = (struct filter *) data;
  struct embossdata *s = (struct embossdata *) f->data;
  int i;
  unsigned int *table = s->table;
  for (i = r1; i < r2; i++)
    {
      src = f->childimage->currlines[i];
      src2 = f->childimage->currlines[i + s->ydist] + s->xdist;
      srcend = src + f->image->width;
      dest = f->image->currlines[i];
      while (src < srcend)
      {
        *dest = table[((int) *src2 - (int) *src) & 511];
        src++;
        src2++;
        dest++;
      }
    }
}

#ifdef SUPPORT16
static void
emboss16 (void *data, struct taskinfo *task, int r1, int r2)
{
  pixel8_t *src, *srcend, *src2;
  pixel16_t *dest;
  struct filter *f = (struct filter *) data;
  struct embossdata *s = (struct embossdata *) f->data;
  int i;
  unsigned int *table = s->table;
  for (i = r1; i < r2; i++)
    {
      src = f->childimage->currlines[i];
      src2 = f->childimage->currlines[i + s->ydist] + s->xdist;
      srcend = src + f->image->width;
      dest = (pixel16_t *) f->image->currlines[i];
      while (src < srcend)
      {
        *dest = table[((int) *src2 - (int) *src) & 511];
        src++;
        src2++;
        dest++;
      }
    }
}
#endif
#ifdef STRUECOLOR24
static void
emboss24 (void *data, struct taskinfo *task, int r1, int r2)
{
  pixel8_t *src, *srcend, *src2;
  pixel8_t *dest;
  struct filter *f = (struct filter *) data;
  struct embossdata *s = (struct embossdata *) f->data;
  int i;
  unsigned int *table = s->table;
  for (i = r1; i < r2; i++)
    {
      src = f->childimage->currlines[i];
      src2 = f->childimage->currlines[i + s->ydist] + s->xdist;
      srcend = src + f->image->width;
      dest = (pixel8_t *) f->image->currlines[i];
      while (src < srcend)
      {
        *dest = *(dest + 1) = *(dest + 2) =
          table[((int) *src2 - (int) *src) & 511];
        src++;
        src2++;
        dest += 3;
      }
    }
}
#endif
static void
emboss32 (void *data, struct taskinfo *task, int r1, int r2)
{
  pixel8_t *src, *srcend, *src2;
  pixel32_t *dest;
  struct filter *f = (struct filter *) data;
  struct embossdata *s = (struct embossdata *) f->data;
  int i;
  unsigned int *table = s->table;
  for (i = r1; i < r2; i++)
    {
      src = f->childimage->currlines[i];
      src2 = f->childimage->currlines[i + s->ydist] + s->xdist;
      srcend = src + f->image->width;
      dest = (pixel32_t *) f->image->currlines[i];
      while (src < srcend)
      {
        *dest = table[((int) *src2 - (int) *src) & 511];
        src++;
        src2++;
        dest++;
      }
    }
}
static void
destroyinstance (struct filter *f)
{
  struct embossdata *i = (struct embossdata *) f->data;
  if (i->savedpalette != NULL)
    destroypalette (i->savedpalette);
  destroypalette (i->palette);
  destroyinheredimage (f);
  free (f->data);
  free (f);
}

static int
doit (struct filter *f, int flags, int time1)
{
  int val;
  int time = time1;
  updateinheredimage (f);
  val = f->previous->action->doit (f->previous, flags, time);
  drivercall (*f->image,
            xth_function (emboss8, f, f->image->height),
            xth_function (emboss16, f, f->image->height),
            xth_function (emboss24, f, f->image->height),
            xth_function (emboss32, f, f->image->height));
  xth_sync ();
  return val;
}
static void
myremovefilter (struct filter *f)
{
  struct embossdata *s = (struct embossdata *) f->data;
  if (s->savedpalette != NULL)
    {
      restorepalette (f->image->palette, s->savedpalette);
      destroypalette (s->savedpalette);
      s->savedpalette = NULL;
    }
}

CONST struct filteraction emboss_filter = {
  "Emboss",
  "emboss",
  0,
  getinstance,
  destroyinstance,
  doit,
  requirement,
  initialize,
  convertupgeneric,
  convertdowngeneric,
  myremovefilter
};

Generated by  Doxygen 1.6.0   Back to index