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

blur.c

#include <config.h>
#ifndef _plan9_
#ifndef NO_MALLOC_H
#include <malloc.h>
#endif
#include <string.h>
#include <math.h>
#include <stdio.h>
#ifdef HAVE_ALLOCA_H
#include <alloca.h>
#endif
#include <stdlib.h>
#else
#include <u.h>
#include <libc.h>
#include <stdio.h>
#endif
#include <filter.h>
#include <fractal.h>
#include <xthread.h>
#include <xerror.h>
#include <archaccel.h>
#define SIZE 64
#define SIZE2 8
#define AMOUNT 0.005
#define DIV 1000.0
#define MAXFRAMES 800*1000    /*after 800 frames should be OK */
struct blurdata
{
  int bckuptime;
  int counter;
  struct palette *savedpalette, *palette;
  unsigned char (*table)[256];      /*Used by blur routines */
  int n;
};
static int
requirement (struct filter *f, struct requirements *r)
{
  f->req = *r;
  r->nimages = 1;
  r->flags |= IMAGEDATA;
  r->supportedmask = C256 | TRUECOLOR24 | TRUECOLOR | TRUECOLOR16 | GRAYSCALE;
  return (f->next->action->requirement (f->next, r));
}
static void
blur8 (struct filter *f)
{
  struct image *desti = f->image;
  struct blurdata *s = (struct blurdata *) f->data;
  unsigned char (*table)[256] = s->table;
  unsigned int i, i1, im, im1, ipl, ii;
  if (f->image->palette->type == C256)
    for (i = im = 0; i < SIZE; i++, im += 256 - s->n)
      {
      for (i1 = im1 = 0; i1 < SIZE2; i1++, im1 += s->n * (SIZE / SIZE2))
        {
          ipl = (im + im1 + 128) >> 8;
          ii = i1 * (SIZE / SIZE2);
          if (ipl == i && i != ii)
            {
            if (i < ii)
              ipl++;
            else
              ipl--;
            }
          ii = desti->palette->pixels[i];
          table[i1][ii] = (unsigned char) desti->palette->pixels[ipl];
        }
      }
  else
    for (i = im = desti->palette->start, im *= 256 - s->n;
       i < (unsigned int) desti->palette->end; i++, im += 256 - s->n)
      {
      for (i1 = im1 = desti->palette->start, im1 *= s->n;
           i1 < (unsigned int) desti->palette->end; i1++, im1 += s->n)
        {
          ipl = (im + im1 + 128) >> 8;
          if (ipl == i && i != i1)
            {
            if (i < i1)
              ipl++;
            else
              ipl--;
            }
          table[i1][i] = (unsigned char) ipl;
        }
      }
}
static void
blurtruecolor (struct filter *f)
{
  struct blurdata *s = (struct blurdata *) f->data;
  unsigned int i, i1, im, im1;
  unsigned char (*table)[256] = s->table;
  for (i = im = 0; i < 256; i++, im += 256 - s->n)
    {
      for (i1 = im1 = 0; i1 < 256; i1++, im1 += s->n)
      table[i1][i] = (unsigned char) ((im + im1) >> 8);
    }
}
static void
clear_image2 (struct image *img)
{
  int i;
  int color = img->palette->pixels[0];
  int width = img->width * img->bytesperpixel;
  if (!width)
    width = (img->width + 7) / 8;
  for (i = 0; i < img->height; i++)
    memset_long (img->currlines[i], color, (size_t) width);
}


static int
initialize (struct filter *f, struct initdata *i)
{
  struct blurdata *s = (struct blurdata *) f->data;
  unsigned int x;
  inhermisc (f, i);
  s->counter = 0;
  s->palette->size = SIZE2;
  for (x = 0; x < SIZE2; x++)
    s->palette->pixels[x] = x;
  if (datalost (f, i) || i->image->version != f->imageversion)
    {
      s->bckuptime = MAXFRAMES;
      s->counter = MAXFRAMES;
      if (i->image->palette->type == C256)
      {
        if (s->savedpalette == NULL)
          s->savedpalette = clonepalette (i->image->palette);
        mkblurpalette (i->image->palette);
      }
      else
      {
        if (s->savedpalette != NULL)
          {
            restorepalette (i->image->palette, s->savedpalette);
            destroypalette (s->savedpalette);
            s->savedpalette = NULL;
          }
      }
      clear_image2 (i->image);
    }
  if (!inherimage
      (f, i, TOUCHIMAGE | IMAGEDATA, 0, 0,
       i->image->palette->type == C256 ? s->palette : NULL, 0, 0))
    return 0;
  if (f->image->palette->type == C256)
    {
      setfractalpalette (f, s->savedpalette);
    }
  if (i->image == NULL)
    {
      return 0;
    }
  return (f->previous->action->initialize (f->previous, i));
}
static struct filter *
getinstance (CONST struct filteraction *a)
{
  struct filter *f = createfilter (a);
  struct blurdata *i = (struct blurdata *) calloc (1, sizeof (*i));
  i->savedpalette = NULL;
  i->palette =
    createpalette (0, 256, SMALLITER, 0, 256, NULL, NULL, NULL, NULL, NULL);
  i->palette->size = SIZE2;
  i->palette->end = SIZE2;
  i->table = NULL;
  f->childimage = NULL;
  f->data = i;
  f->name = "Motionblur";
  return (f);
}
static void
destroyinstance (struct filter *f)
{
  struct blurdata *i = (struct blurdata *) f->data;
  if (i->table != NULL)
    free (i->table);
  if (i->savedpalette != NULL)
    destroypalette (i->savedpalette);
  destroypalette (i->palette);
  destroyinheredimage (f);
  free (f->data);
  free (f);
}

/* An part of blur function that should be done paraely */
static void
blur82 (void *data, struct taskinfo *task, int r1, int r2)
{
  struct filter *f = (struct filter *) data;
  struct image *srci = f->childimage, *desti = f->image;
  struct blurdata *s = (struct blurdata *) f->data;
  unsigned char (*table)[256];
  int i, im;
  unsigned char *src, *dest, *srcend;

  im = srci->width;
  table = s->table;
  for (i = r1; i < r2; i++)
    {
      src = srci->currlines[i];
      srcend = src + im;
      dest = desti->currlines[i];
      for (; src < srcend; src++, dest++)
      {
        dest[0] = table[src[0]][dest[0]];
      }
    }
}

#ifdef SUPPORT16
static void
blur16 (void *data, struct taskinfo *task, int r1, int r2)
{
  struct filter *f = (struct filter *) data;
  struct image *srci = f->childimage, *desti = f->image;
  struct blurdata *s = (struct blurdata *) f->data;
  struct truec *info = &srci->palette->info.truec;
  unsigned int rmask = info->rmask;
  unsigned int gmask = info->gmask;
  unsigned int bmask = info->bmask;
  unsigned int n = (unsigned int) s->n;
  int i;
  pixel16_t *src, *dest, *srcend;
  for (i = r1; i < r2; i++)
    {
      src = (pixel16_t *) srci->currlines[i];
      srcend = src + srci->width;
      dest = (pixel16_t *) desti->currlines[i];
      for (; src < srcend; src++, dest++)
      {
        *dest = interpol (*src, *dest, n, rmask, gmask, bmask);
      }
    }
}
#endif
#ifdef STRUECOLOR24
static void
blur24 (void *data, struct taskinfo *task, int r1, int r2)
{
  struct filter *f = (struct filter *) data;
  struct image *srci = f->childimage, *desti = f->image;
  struct blurdata *s = (struct blurdata *) f->data;
  unsigned char (*table)[256] = s->table;
  unsigned char *src, *dest, *srcend;
  int i, im;
  im = srci->width * 3;
  if (!srci->palette->info.truec.byteexact)
    {
      x_fatalerror
      ("Blur filter:unsupported color configuration! Please contact authors.");
    }
  for (i = r1; i < r2; i++)
    {
      src = srci->currlines[i];
      srcend = src + im;
      dest = desti->currlines[i];
      for (; src < srcend; src += 3, dest += 3)
      {
        dest[0] = table[src[0]][dest[0]];
        dest[1] = table[src[1]][dest[1]];
        dest[2] = table[src[2]][dest[2]];
      }
    }
}
#endif
static void
blur32 (void *data, struct taskinfo *task, int r1, int r2)
{
  struct filter *f = (struct filter *) data;
  struct image *srci = f->childimage, *desti = f->image;
  struct blurdata *s = (struct blurdata *) f->data;
  unsigned char (*table)[256] = s->table;
  unsigned char *src, *dest, *srcend;
  int i, im;
  im = srci->width * 4;
  if (!srci->palette->info.truec.byteexact)
    {
      x_fatalerror
      ("Blur filter:unsupported color configuration! Please contact authors.");
    }
  for (i = r1; i < r2; i++)
    {
      src = srci->currlines[i];
      srcend = src + im;
      dest = desti->currlines[i];
      switch (f->image->palette->info.truec.missingbyte)
      {
      case 3:
        for (; src < srcend; src += 4, dest += 4)
          {
            dest[0] = table[src[0]][dest[0]];
            dest[1] = table[src[1]][dest[1]];
            dest[2] = table[src[2]][dest[2]];
          }
        break;
      case 2:
        for (; src < srcend; src += 4, dest += 4)
          {
            dest[0] = table[src[0]][dest[0]];
            dest[1] = table[src[1]][dest[1]];
            dest[3] = table[src[2]][dest[2]];
          }
        break;
      case 1:
        for (; src < srcend; src += 4, dest += 4)
          {
            dest[0] = table[src[0]][dest[0]];
            dest[2] = table[src[1]][dest[1]];
            dest[3] = table[src[2]][dest[2]];
          }
        break;
      case 0:
        for (; src < srcend; src += 4, dest += 4)
          {
            dest[1] = table[src[1]][dest[1]];
            dest[2] = table[src[2]][dest[2]];
            dest[3] = table[src[3]][dest[3]];
          }
        break;
      default:
        for (; src < srcend; src += 4, dest += 4)
          {
            dest[1] = table[src[1]][dest[1]];
            dest[2] = table[src[2]][dest[2]];
            dest[3] = table[src[3]][dest[3]];
            dest[4] = table[src[4]][dest[4]];
          }
      }
    }
}
static int
doit (struct filter *f, int flags, int time1)
{
  int val, n;
  int time = time1;
  struct blurdata *s = (struct blurdata *) f->data;
  updateinheredimage (f);
  val = f->previous->action->doit (f->previous, flags, time);
  s->counter += time;
  if (val & CHANGED)
    s->counter = 0;
  n = (int) ((1 - pow (1.0 - AMOUNT, (time + s->bckuptime) / DIV)) * 256);
  if (s->counter >= 2 * MAXFRAMES)
    {
      return val;
    }
  if (n < 10)
    {
      s->bckuptime += time;
      return val | ANIMATION;
    }
  s->bckuptime = 0;
  if (s->counter >= MAXFRAMES)
    n = 256, s->counter = 2 * MAXFRAMES;
  if (s->n != n)
    {
      s->n = n;
      switch (f->image->bytesperpixel)
      {
      case 1:
        if (s->table == NULL)
          s->table = (unsigned char (*)[256]) malloc (256 * 256);
        blur8 (f);
        break;
      case 3:
      case 4:
        if (s->table == NULL)
          s->table = (unsigned char (*)[256]) malloc (256 * 256);
        blurtruecolor (f);
        break;
      default:
        if (s->table != NULL)
          free (s->table), s->table = NULL;
      }
    }
  switch (f->image->palette->type)
    {
    case C256:
    case GRAYSCALE:
      xth_function (blur82, f, f->image->height);
      break;
#ifdef SUPPORT16
    case TRUECOLOR16:
      xth_function (blur16, f, f->image->height);
      break;
#endif
    case TRUECOLOR:
      xth_function (blur32, f, f->image->height);
      break;
#ifdef STRUECOLOR24
    case TRUECOLOR24:
      xth_function (blur24, f, f->image->height);
      break;
#endif
    }
  xth_sync ();
  if (s->counter == 2 * MAXFRAMES)
    {
      return val | CHANGED;
    }
  return val | CHANGED | ANIMATION;
}
static void
myremovefilter (struct filter *f)
{
  struct blurdata *s = (struct blurdata *) f->data;
  if (s->savedpalette != NULL)
    {
      restorepalette (f->image->palette, s->savedpalette);
      destroypalette (s->savedpalette);
      s->savedpalette = NULL;
    }
}

CONST struct filteraction blur_filter = {
  "Motionblur",
  "blur",
  0,
  getinstance,
  destroyinstance,
  doit,
  requirement,
  initialize,
  convertupgeneric,
  convertdowngeneric,
  myremovefilter
};

Generated by  Doxygen 1.6.0   Back to index