/* * fs4.c -- * *      Procedures dealing with Floyd-Steinberg dithering with 4 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. *//* This file contains C code to do YCrCb -> colormap space. */#include "fs4.h"#include "video.h"#include "proto.h"#include "dither.h"/* Structures containing precomputed error terms. */static FS4Dither lum_index[256];static FS4Dither cr_index[256];static FS4Dither cb_index[256];/* *-------------------------------------------------------------- * * InitFS4Dither -- * *	Initializes structures used for f-s dithering. Precomputes *      error terms. * * Results: *	None. * * Side effects: *      None. * *-------------------------------------------------------------- */voidInitFS4Dither(){  int i;  for (i=0; i<256; i++) {    lum_index[i].value = (i * LUM_RANGE) / 256;    lum_index[i].e1 = (7 * (i-lum_values[lum_index[i].value])) / 16;    lum_index[i].e2 = (i-lum_values[lum_index[i].value])/16;    lum_index[i].e3 = (5 *  (i - lum_values[lum_index[i].value])) / 16;    lum_index[i].e4 = (i-lum_values[lum_index[i].value]) - lum_index[i].e1 -      lum_index[i].e2 - lum_index[i].e3;    lum_index[i].value *= LUM_BASE;    cr_index[i].value = (i * CR_RANGE) / 256;     cr_index[i].e1 = (7 * (i-cr_values[cr_index[i].value])) / 16;    cr_index[i].e2 = (i-cr_values[cr_index[i].value])/16;    cr_index[i].e3 = (5 *  (i - cr_values[cr_index[i].value])) / 16;    cr_index[i].e4 = (i-cr_values[cr_index[i].value]) - cr_index[i].e1 -      cr_index[i].e2 - cr_index[i].e3;    cr_index[i].value *= CR_BASE;    cb_index[i].value = (i * CB_RANGE) / 256;     cb_index[i].e1 = (7 * (i-cb_values[cb_index[i].value])) / 16;    cb_index[i].e2 = (i-cb_values[cb_index[i].value])/16;    cb_index[i].e3 = (5 *  (i - cb_values[cb_index[i].value])) / 16;    cb_index[i].e4 = (i-cb_values[cb_index[i].value]) - cb_index[i].e1 -      cb_index[i].e2 - cb_index[i].e3;    cb_index[i].value *= CB_BASE;  }}/* *-------------------------------------------------------------- * * DitherImage -- * *	Converts lum, cr, cb image planes into fixed colormap *      space. Uses Floyd-Steinberg dithering in serpentine *      pattern with standard 4 errors propogated. * * Results: *	The display plane is replaced by 8-bit colormap space *      image. * * Side effects: *      Hopefully, none. * *-------------------------------------------------------------- */void FS4DitherImage(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;  FS4Dither *chan_index;  if (first) {    cur_row_error = (char *) malloc(cols+2);    next_row_error = (char *) malloc(cols+2);    first = 0;  }  memset(cur_row_error, 0, cols+2);  memset(next_row_error, 0, cols+2);  for(i=0; i<rows; i+=2) {     cur_row = lum + (i*cols);     dest_row = disp + (i*cols);     cur_row_err_mark = cur_row_error + 1;     next_row_err_mark = next_row_error + 1;     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+1) += lum_index[pixsum].e2;       *next_row_err_mark += lum_index[pixsum].e3;        *(next_row_err_mark-1) += lum_index[pixsum].e4;       cur_row++;       dest_row++;       cur_row_err_mark++;       next_row_err_mark++;     }     temp = cur_row_error;     cur_row_error = next_row_error;     next_row_error = temp;     memset(next_row_error, 0, cols+2);      cur_row += cols-1;     dest_row += cols-1;     cur_row_err_mark = cur_row_error + cols;     next_row_err_mark = next_row_error + cols;     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-1) += lum_index[pixsum].e2;       *next_row_err_mark += lum_index[pixsum].e3;        *(next_row_err_mark+1) += lum_index[pixsum].e4;       cur_row--;       dest_row--;       cur_row_err_mark--;       next_row_err_mark--;     }     temp = cur_row_error;     cur_row_error = next_row_error;     next_row_error = temp;     memset(next_row_error, 0, cols+2);    }  memset(cur_row_error, 0, cols+2);   c_cols = cols >> 1;  channel = cr;  chan_index = cr_index; repeat:  for (i=0; i < rows; i+=2) {    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 (j=0; j<cols; j++) {      int p_val;      p_val = *cur_row;      pixsum = *cur_row_err_mark + p_val;      if (pixsum < 0) pixsum = 0;      else if (pixsum > 255) pixsum = 255;      *dest_row += chan_index[pixsum].value;      *(cur_row_err_mark+1) += chan_index[pixsum].e1;       *(next_row_err_mark+1) += chan_index[pixsum].e2;      *next_row_err_mark += chan_index[pixsum].e3;       *(next_row_err_mark-1) += chan_index[pixsum].e4;      if (j&1) cur_row++;      dest_row++;      cur_row_err_mark++;      next_row_err_mark++;    }          temp = cur_row_error;    cur_row_error = next_row_error;    next_row_error = temp;    memset(next_row_error, 0, cols+2);    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;    for (j=0; j<cols; j++) {      int p_val;      p_val = *cur_row;      pixsum = *cur_row_err_mark + p_val;      if (pixsum < 0) pixsum = 0;      else if (pixsum > 255) pixsum = 255;      *dest_row += chan_index[pixsum].value;      *(cur_row_err_mark-1) += chan_index[pixsum].e1;       *(next_row_err_mark-1) += chan_index[pixsum].e2;      *next_row_err_mark += chan_index[pixsum].e3;       *(next_row_err_mark+1) += chan_index[pixsum].e4;      if (j&1) cur_row--;      dest_row--;      cur_row_err_mark--;      next_row_err_mark--;    }    temp = cur_row_error;    cur_row_error = next_row_error;    next_row_error = temp;    memset(next_row_error, 0, cols+2);  }  if (channel == cr) {    channel = cb;    chan_index = cb_index;    memset(cur_row_error, 0, cols+2);    goto repeat;  }  dest_row = disp;  for (i=0; i<rows; i++) {    for (j=0; j<cols; j++) {      *dest_row =  pixel[*dest_row];      dest_row++;    }  }}