fs2.c

MPEG2 PLAYER in linux

/*
 * 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++;
    }
  }
}