Subversion Repositories shark

/*

 * fs2.c --

 *

 *      Procedures dealing with Floyd-Steinberg dithering with 2 error

 *      values propagated.

 *

 */

/*

 * Copyright (c) 1995 The Regents of the University of California.

 * All rights reserved.

 *

 * Permission to use, copy, modify, and distribute this software and its

 * documentation for any purpose, without fee, and without written agreement is

 * hereby granted, provided that the above copyright notice and the following

 * two paragraphs appear in all copies of this software.

 *

 * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR

 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT

 * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF

 * CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 *

 * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,

 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY

 * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS

 * ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO

 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.

 */

#include "video.h"

#include "dither.h"

#include "fs2.h"

#include "proto.h"

#ifdef __STDC__

#include <stdlib.h>

#else

#include <malloc.h>     /* member of stdlib.h included in header.h */

#endif

/* Structures for precomputed error propogation values. */

static FS2DithVal lum_index[256];

static FS2DithVal cr_index[256];

static FS2DithVal cb_index[256];

/*

 *--------------------------------------------------------------

 *

 * InitFS2Dither --

 *

 *      Initializes structures for precomputed 2 error f-s dithering.

 *      The value field of the structure contains the pixel component

 *      of the particular channel in question. Thus the addition of

 *      the value field of a structure in the luminance index, a

 *      structure in the Cr index, and a structure in the Cb index will

 *      yeild a color number. This color number can then be transformed

 *      into a pixel value to be displayed. Each channel can then be

 *      processed (i.e. dithered) separately, with the results being

 *      added up and remapped to yield a final pixel value.

 *

 * Results:

 *      None.

 *

 * Side effects:

 *      None.

 *

 *--------------------------------------------------------------

 */

void InitFS2Dither()

{

  int i;

  /* For each possible pixel value, precompute propogated error and

     store in array.

  */

  for (i=0; i<256; i++) {

    lum_index[i].value = (i * LUM_RANGE) / 256;

    lum_index[i].e1 = (i-lum_values[lum_index[i].value]) / 2;

    lum_index[i].e3 = (i - lum_values[lum_index[i].value]) - lum_index[i].e1;

    lum_index[i].value *= LUM_BASE;

    cr_index[i].value = (i * CR_RANGE) / 256;

    cr_index[i].e1 = (i - cr_values[cr_index[i].value]) / 2;

    cr_index[i].e3 = (i - cr_values[cr_index[i].value]) - cr_index[i].e1 ;

    cr_index[i].value *= CR_BASE;

    cb_index[i].value = (i * CB_RANGE) / 256;

    cb_index[i].e1 = (i - cb_values[cb_index[i].value]) / 2;

    cb_index[i].e3 = (i - cb_values[cb_index[i].value]) - cb_index[i].e1;

    cb_index[i].value *= CB_BASE;

  }

}

/*

 *--------------------------------------------------------------

 *

 * DitherImage --

 *

 *      Converts lum, cr, cb image planes into fixed colormap

 *      space.

 *

 * Results:

 *      the display plane is replaced by 8-bit colormap space

 *      image.

 *

 * Side effects:

 *      Hopefully, none.

 *

 *--------------------------------------------------------------

 */

void FS2DitherImage(lum, cr, cb, disp, rows, cols)

     unsigned char *lum, *cr, *cb, *disp;

     int rows, cols;

{

  static char *cur_row_error, *next_row_error;

  static int first = 1;

  char  *cur_row_err_mark, *next_row_err_mark;

  char *temp;

  int i, j, pixsum, c_cols;

  unsigned char *cur_row, *channel, *dest_row;

  FS2DithVal *chan_index;

  /* Allocate error arrays. */

  if (first) {

    cur_row_error = (char *) malloc((unsigned int) cols+2);

    next_row_error = (char *) malloc((unsigned int) cols+2);

    first = 0;

  }

  /* Initialize error arrays. */

  memset(cur_row_error, 0, cols+2);

  memset(next_row_error, 0, cols+2);

  /* Use luminance values first. */

  /* For each two rows, do... */

  for(i=0; i<rows; i+=2) {

    /* Establish pointer to current source and destination rows. */

    cur_row = lum + (i*cols);

    dest_row = disp + (i*cols);

    /* Establish pointers to error arrays. */

    cur_row_err_mark = cur_row_error + 1;

    next_row_err_mark = next_row_error + 1;

    /* For each column within first row do... */

    for (j=0; j<cols; j++) {

      /* Calculate pixel value with error. */

      pixsum = *cur_row + *cur_row_err_mark;

      /* Bounds check. */

      if (pixsum < 0) pixsum = 0;

      else if (pixsum > 255) pixsum = 255;

      /* Establish dest value, propogate errors. */

      *dest_row = lum_index[pixsum].value;

      *(cur_row_err_mark+1) += lum_index[pixsum].e1;

      *next_row_err_mark += lum_index[pixsum].e3;

      /* Advance pointers. */

      cur_row++;

      dest_row++;

      cur_row_err_mark++;

      next_row_err_mark++;

    }

    /* Switch error arrays, so next row errors are now current row errors, and

       vice versa.

    */

    temp = cur_row_error;

    cur_row_error = next_row_error;

    next_row_error = temp;

    /* Reset next row errors. */

    memset(next_row_error, 0, cols+2);

    /* Establish pointers for second row. This one will be processed right to

       left to establish serpantine motion.

    */

    cur_row += cols-1;

    dest_row += cols-1;

    cur_row_err_mark = cur_row_error + cols;

    next_row_err_mark = next_row_error + cols;

    /* Process each column... */

    for (j=0; j<cols; j++) {

      pixsum = *cur_row + *cur_row_err_mark;

      if (pixsum < 0) pixsum = 0;

      else if (pixsum > 255) pixsum = 255;

      *dest_row = lum_index[pixsum].value;

      *(cur_row_err_mark-1) += lum_index[pixsum].e1;

      *next_row_err_mark += lum_index[pixsum].e3;

      cur_row--;

      dest_row--;

      cur_row_err_mark--;

      next_row_err_mark--;

    }

    /* Switch error arrays. */

    temp = cur_row_error;

    cur_row_error = next_row_error;

    next_row_error = temp;

    /* Reset next row errors. */

    memset(next_row_error, 0, cols+2);

  }

  /* Reset error arrays. */

  memset(cur_row_error, 0, cols+2);

  /* Establish column length divided by two. */

  c_cols = cols >> 1;

  /* Set channel to Cr. Use Cr index. */

  channel = cr;

  chan_index = cr_index;

 repeat:

  /* Process each row of chrominance data... */

  for (i=0; i < rows; i+=2) {

    /* Establish pointers. */

    cur_row = channel + ((i>>1)*c_cols);

    dest_row = disp + (i*cols);

    cur_row_err_mark = cur_row_error+1;

    next_row_err_mark = next_row_error+1;

    /* For each column in row... */

    for (j=0; j<cols; j++) {

      int p_val;

      /* Get pixel value as twos bit complement. */

      p_val = *cur_row;

      /* Add error term. */

      pixsum = *cur_row_err_mark + p_val;

      /* Bounds check. */

      if (pixsum < 0) pixsum = 0;

      else if (pixsum > 255) pixsum = 255;

      /* Increment dest value. */

      *dest_row += chan_index[pixsum].value;

      /* Propogate error values. */

      *(cur_row_err_mark+1) += chan_index[pixsum].e1;

      *next_row_err_mark += chan_index[pixsum].e3;

      /* If count is odd, advance source pointer (Cr and Cb channels are 2:1

         subsampled.

      */

      if (j&1) cur_row++;

      /* Advance destination and error pointers. */

      dest_row++;

      cur_row_err_mark++;

      next_row_err_mark++;

    }

    /* Switch error arrays. */

    temp = cur_row_error;

    cur_row_error = next_row_error;

    next_row_error = temp;

    /* Reset next row errors. */

    memset(next_row_error, 0, cols+2);

    /* Re-establish pointers. */

    cur_row += c_cols-1;

    dest_row += cols-1;

    cur_row_err_mark = cur_row_error+cols;

    next_row_err_mark = next_row_error+cols;

    /* Process second row right to left. */

    for (j=0; j<cols; j++) {

      int p_val;

      /* Get source value as twos bit complement. */

      p_val = *cur_row;

      /* Add error. */

      pixsum = *cur_row_err_mark + p_val;

      /* Bounds check. */

      if (pixsum < 0) pixsum = 0;

      else if (pixsum > 255) pixsum = 255;

      /* Increment dest value. */

      *dest_row += chan_index[pixsum].value;

      /* Propogate errors. */

      *(cur_row_err_mark-1) += chan_index[pixsum].e1;

      *next_row_err_mark += chan_index[pixsum].e3;

      /* If column counters is odd, decrement source pointer. */

      if (j&1) cur_row--;

      /* Decrement dest and error pointers. */

      dest_row--;

      cur_row_err_mark--;

      next_row_err_mark--;

    }

    /* Switch error arrays. */

    temp = cur_row_error;

    cur_row_error = next_row_error;

    next_row_error = temp;

    /* Reinitialize next row errors. */

    memset(next_row_error, 0, cols+2);

  }

  /* If Cr channel completed, set channel to Cb and Cb index and repeat. */

  if (channel == cr) {

    channel = cb;

    chan_index = cb_index;

    memset(cur_row_error, 0, cols+2);

    goto repeat;

  }

  /* Establish pointer to start of display frame. */

  dest_row = disp;

  /* Transform all display values to pixel values. */

  for (i=0; i<rows; i++) {

    for (j=0; j<cols; j++) {

      *dest_row =  pixel[*dest_row];

      dest_row++;

    }

  }

}