mode12gray.c

/**
 * Copyright (c) 2005 Hin-Tak Leung. All rights reserved.
 *
 **/
/*
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/
/**
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 **/

#include <stdio.h>
#include <string.h>
#include "mode12.h"


#define min(a, b) (a>b? b:a)

int mode12gray_compress(int bytecount, unsigned char *current_start,
			unsigned char *previous_start, unsigned char *compressed)
{
  unsigned char *ptr_current = current_start;
  unsigned char *ptr_previous = previous_start;
  unsigned char *comp_ptr = compressed;
  unsigned char *current_end = current_start + bytecount;
  unsigned char cached_color = 0xff; /* MORE: what if this is the first literal? */
  
  while (ptr_current < current_end) { /* Detect a run of unchanged bytes. */
    unsigned char *run = ptr_current;
    unsigned char *diff_start;
    int offset;
    
    while ((ptr_current < current_end) && ((*ptr_current) == (*ptr_previous))) {
      ptr_current++, ptr_previous++;
    }
    
    /* Detect a run of changed bytes. */
    /* We know that *ptr_current != *ptr_previous. */
    diff_start = ptr_current;
    while (ptr_current < current_end && ((*ptr_current) != (*ptr_previous))) {
      ptr_current++, ptr_previous++;
    }
    /* Now [run..diff_start) are unchanged, and */
    /* [diff_start..ptr_current) are changed. */
    offset = diff_start - run;
    if (diff_start == current_end)
      {
	/* coding the last offset as RLE of count 2 without the byte following */
	if (offset >= 3)
	  {
	    *comp_ptr++ = eRLE | eeNewPixel | (3 << 3);
	    offset -=3;
	    while (offset >= 255)
	      {
		*comp_ptr++ = 255;
		offset -= 255;
	      }
	    *comp_ptr++ = offset;	    
	  }
	else
	  {
	    *comp_ptr++ = eRLE | eeNewPixel | (offset << 3);
	  }
      }
    else
      {
	/* go back and see if it is rle or literal */
	unsigned char rle = diff_start[0];
	unsigned char pixel_src = eeNewPixel;
	unsigned char cmd;
	int count;
	
	ptr_current = diff_start;

	/* MORE: This is the windows driver order - the compression
	   efficiency is all the time, so it is really up to
	   choice */
	if (0)
	  {
	  }
	/*
	else if ((ptr_current > current_start) && (rle == *(ptr_current -1)))
	  {
	    pixel_src = eeWPixel;
	  }
	else if ((ptr_current - 1 < current_end) &&  
		 (rle == *(previous_start + (ptr_current - current_start) + 1)))
	  {
	    pixel_src = eeNEPixel;
	  }
	else if (rle == cached_color)
	  {
	    pixel_src = eeCachedColor;
	  }
	*/
	else
	  {
	    pixel_src = eeNewPixel;
	    cached_color = rle;
	  }
	
	while (rle == *ptr_current)
	  {
	    ptr_current++;
	  }
	
	if (ptr_current - diff_start > 1)
	  {
	    /* rle */
	    ptr_previous = previous_start + (ptr_current - current_start); 
	    count = (ptr_current - diff_start) - 2;
	    cmd = eRLE;
	  }
	else
	  {
	    /* MORE: literal can't go beyond 8 */
	    count = min((ptr_current - diff_start),8);
	    ptr_previous = previous_start + (count + diff_start - current_start); 
	    ptr_current = diff_start + count;
	    count -=1;
	    cmd = eLiteral;
	  }
	
	*comp_ptr++ = cmd | pixel_src | (min(offset, 3) <<3) | min(count,7);

	if (offset >= 3)
	  {
	    offset -=3;
	    while (offset >= 255)
	      {
		*comp_ptr++ = 255;
		offset -= 255;
	      }
	    *comp_ptr++ = offset;
	  }
	
	if(pixel_src == eeNewPixel)
	  {
	    unsigned char temp = 0xff ^ *diff_start;
	    *comp_ptr++ = temp;
	    *comp_ptr++ = temp;
	    *comp_ptr++ = temp;
	  }
	
	if((cmd == eLiteral) && (count > 0))
	  {
	    unsigned char *temp_ptr = diff_start;
	    /* we are not reusing count in this case */
	      while (count > 0)
		{
		  unsigned char temp = 0xff ^ (*(++temp_ptr)); 
		  *comp_ptr++ = temp;
		  *comp_ptr++ = temp;
		  *comp_ptr++ = temp;
		  count--;
		}
	  }
	if (count >= 7)
	  {
	    count -=7;
	    while (count >= 255)
	      {
		*comp_ptr++ = 255;
		count -= 255;
	      }
	    *comp_ptr++ = count;
	  }
      } /* not the last one */
  } /* while not end */
  return comp_ptr - compressed;
}