#include "stdio.h"
#include "rle_put.h"
#include "rle.h"

Include dependency graph for rle_putrow.c:

Macros
#define	FASTRUNS /* Faster run finding */

#define	FALSE 0

#define	TRUE 1

#define	PBRUN the_hdr->priv.put.brun

Functions
static int	findruns ()

void	rle_putrow (rows, int rowlen, rle_hdr *the_hdr)

void	rle_skiprow (rle_hdr *the_hdr, int nrow)

void	rle_put_init (rle_hdr *the_hdr)

void	rle_put_setup (rle_hdr *the_hdr)

void	DefaultBlockHook (rle_hdr *the_hdr)

void	rle_puteof (rle_hdr *the_hdr)

static int	findruns (rle_pixel row, int rowlen, int color, int nrun, short brun)

void	rgb_to_bw (rle_pixel red_row, rle_pixel green_row, rle_pixel blue_row, rle_pixel bw_row, int rowlen)

Macro Definition Documentation

#define FALSE 0

Definition at line 44 of file rle_putrow.c.

#define FASTRUNS /* Faster run finding */

Definition at line 39 of file rle_putrow.c.

#define PBRUN the_hdr->priv.put.brun

Definition at line 48 of file rle_putrow.c.

#define TRUE 1

Definition at line 45 of file rle_putrow.c.

Function Documentation

void DefaultBlockHook ( rle_hdr * the_hdr )

Definition at line 463 of file rle_putrow.c.

 {
                         /* Do nothing */
 }

static int findruns ( )

static

static int findruns	(	rle_pixel *	row,
		int	rowlen,
		int	color,
		int	nrun,
		short *	brun
	)

static

Definition at line 548 of file rle_putrow.c.

 {
     int i = 0, lower, upper;
     register int s, j;
 
 #ifdef DEBUG
     fprintf( stderr, "findruns( " );
     for ( s = 0; s < rowlen; s++ )
     fprintf( stderr, "%2x.%s", row[s], (s % 20 == 19) ? "\n\t" : "" );
     if ( s % 20 != 0 )
     fprintf( stderr, "\n\t" );
     fprintf( stderr, "%d, %d, %d, \n\t", rowlen, color, nrun );
     for ( j = 0; j < nrun; j++ )
     fprintf( stderr, "(%3d,%3d) %s", brun[j][0], brun[j][1],
         (j % 6 == 5) ? "\n\t" : "" );
     fprintf( stderr, ")\n" );
 #endif
 
     while ( i <= nrun )
     {
     /* Assert: 0 <= i <= rowlen
      * brun[i] is the run following the "blank" space being
      * searched.  If i == rowlen, search after brun[i-1].
      */
 
     /* get lower and upper bounds of search */
 
     if ( i == 0 )
         lower = 0;
     else
         lower = brun[i-1][1] + 1;
 
     if ( i == nrun )
         upper = rowlen - 1;
     else
         upper = brun[i][0] - 1;
 
 #ifdef DEBUG
     fprintf( stderr, "Searching before run %d from %d to %d\n",
         i, lower, upper );
 #endif
     /* Search for beginning of run != color */
 #if  defined(LOCC)&defined(vax)
     s = upper - skpc( (char *)row + lower, upper - lower + 1, color ) + 1;
 #else
     for ( s = lower; s <= upper; s++ )
         if ( row[s] != color )
         break;
 #endif
 
     if ( s <= upper )   /* found a new run? */
     {
         if ( s > lower + 1 || i == 0 ) /* disjoint from preceding run? */
         {
 #ifdef DEBUG
         fprintf( stderr, "Found new run starting at %d\n", s );
 #endif
         /* Shift following runs up */
         for ( j = nrun; j > i; j-- )
         {
             brun[j][0] = brun[j-1][0];
             brun[j][1] = brun[j-1][1];
         }
         brun[i][0] = s;
         nrun++;
         }
         else
         {
         i--;        /* just add to preceding run */
 #ifdef DEBUG
         fprintf( stderr, "Adding to previous run\n" );
 #endif
         }
 
 #if defined(LOCC)&defined(vax)
         s = upper - locc( (char *)row + s, upper - s + 1, color ) + 1;
 #else
         for ( ; s <= upper; s++ )
         if ( row[s] == color )
             break;
 #endif
         brun[i][1] = s - 1;
 
 #ifdef DEBUG
         fprintf( stderr, "Ends at %d", s - 1 );
 #endif
         if ( s >= upper && i < nrun - 1 ) /* merge with following run */
         {
         brun[i][1] = brun[i+1][1];
         /* move following runs back down */
         for ( j = i + 2; j < nrun; j++ )
         {
             brun[j-1][0] = brun[j][0];
             brun[j-1][1] = brun[j][1];
         }
         nrun--;
 #ifdef DEBUG
         fprintf( stderr, ", add to next run" );
 #endif
         }
 #ifdef DEBUG
         putc( '\n', stderr );
 #endif
     }
     
     /* Search in next space */
     i++;
     }
 
     return nrun;
 }

void rgb_to_bw	(	rle_pixel *	red_row,
		rle_pixel *	green_row,
		rle_pixel *	blue_row,
		rle_pixel *	bw_row,
		int	rowlen
	)

Definition at line 680 of file rle_putrow.c.

 {
     register int x, bw;
 
     for (x=0; x<rowlen; x++)
     {
     /* 68000 won't store float > 127 into byte? */
     /* HP compiler blows it */
     bw = 0.5 + .30*red_row[x] + .59*green_row[x] + .11*blue_row[x];
     bw_row[x] = bw;
     }
 }

void rle_put_init ( rle_hdr * the_hdr )

Definition at line 415 of file rle_putrow.c.

 {
     the_hdr->dispatch = RUN_DISPATCH;
 
     if ( the_hdr->is_init != RLE_INIT_MAGIC )
     {
     the_hdr->cmd = "Urt";
     the_hdr->file_name = "some file";
     }
     the_hdr->priv.put.nblank = 0;   /* Reinit static vars */
     /* Would like to be able to free previously allocated storage,
      * but can't count on a non-NULL value being a valid pointer.
      */
     PBRUN = NULL;
     the_hdr->priv.put.fileptr = 0;
 
     /* Only save alpha if alpha AND alpha channel bit are set. */
     if ( the_hdr->alpha )
     the_hdr->alpha = (RLE_BIT( *the_hdr, -1 ) != 0);
     else
     RLE_CLR_BIT( *the_hdr, -1 );
 }

void rle_put_setup ( rle_hdr * the_hdr )

Definition at line 453 of file rle_putrow.c.

Referenced by find_most_used(), and write_rle_header().

 {
     rle_put_init( the_hdr );
     the_hdr->img_num++;     /* Count output images. */
     Setup();
 }

Here is the caller graph for this function:

void rle_puteof ( rle_hdr * the_hdr )

Definition at line 474 of file rle_putrow.c.

Referenced by FormFeed(), rasterDone(), and write_rle_data().

 {
     /* Don't puteof twice. */
     if ( the_hdr->dispatch == NO_DISPATCH )
     return;
     PutEof();
     fflush( the_hdr->rle_file );
     /* Free storage allocated by rle_put_init. */
     if ( PBRUN != NULL )
     {
     free( PBRUN );
     PBRUN = NULL;
     }
     /* Signal that puteof has been called. */
     the_hdr->dispatch = NO_DISPATCH;
 }

Here is the caller graph for this function:

void rle_putrow	(	rows	,
		int	rowlen,
		rle_hdr *	the_hdr
	)

Definition at line 96 of file rle_putrow.c.

Referenced by find_most_used(), and write_rle_data().

 {
     register int i, j;
     int nrun;
     register rle_pixel *row;
     int mask;
     char bits[256];
     short   state,      /* State of run-finding state machine. */
         dstart,     /* Starting point for current data segment. */
             dend,       /* Ending point of current data segment. */
         rstart = 0,     /* Starting point of current run. */
         runval = 0;     /* Data value for current run. */
 
     if (rows == NULL)
     {
     the_hdr->priv.put.nblank += rowlen;
     return;
     }
     /* 
      * If not done already, allocate space to remember runs of
      * non-background color.  A run of bg color must be at least 2
      * bytes long to count, so there can be at most rowlen/3 of them.
      */
     if ( PBRUN == NULL )
     {
     PBRUN = (short (*)[2])malloc(
         (unsigned)((rowlen/3 + 1) * 2 * sizeof(short)) );
     if ( PBRUN == NULL )
     {
         fprintf( stderr, "%s: Malloc failed in rle_putrow, writing %s\n",
              the_hdr->cmd, the_hdr->file_name );
         exit(1);
     }
     }
     /* Unpack bitmask in the_hdr struct */
     for ( i=0; i < the_hdr->ncolors; i++ )
     bits[i] = RLE_BIT( *the_hdr, i );
     bits[255] = RLE_BIT( *the_hdr, -1 );
 
     /* 
      * If saving only non-background pixels, find runs of them.  Note
      * that the alpha channel is considered to be background iff it is
      * zero.
      */
 #ifdef  FASTRUNS
     if ( the_hdr->background )
     {
     /* 
      * Find runs in each color individually, merging them as we go.
      */
     nrun = 0;       /* start out with no runs */
     /* Alpha channel first */
     if ( the_hdr->alpha )
         nrun = findruns( rows[-1], rowlen, 0, nrun, PBRUN );
     /* Now the color channels */
     for ( i = 0; i < the_hdr->ncolors; i++ )
         if ( bits[i] )
         nrun = findruns( rows[i], rowlen, the_hdr->bg_color[i],
                  nrun, PBRUN );
     }
     else
     {
     PBRUN[0][0] = 0;
     PBRUN[0][1] = rowlen-1;
     nrun = 1;
     }
 #else               /* FASTRUNS */
     if (the_hdr->background)    /* find non-background runs */
     {
     j = 0;
     for (i=0; i<rowlen; i++)
         if (!same_color( i, rows, the_hdr->bg_color,
                  the_hdr->ncolors, bits ) ||
         (the_hdr->alpha && rows[-1][i] != 0))
         {
         if (j > 0 && i - PBRUN[j-1][1] <= 2)
             j--;
         else
             PBRUN[j][0] = i; /* start of run */
         for ( i++;
               i < rowlen && 
             ( !same_color( i, rows, the_hdr->bg_color,
                      the_hdr->ncolors, bits ) ||
               (the_hdr->alpha && rows[-1][i] != 0) );
               i++)
             ;           /* find the end of this run */
         PBRUN[j][1] = i-1;    /* last in run */
         j++;
         }
     nrun = j;
     }
     else
     {
     PBRUN[0][0] = 0;
     PBRUN[0][1] = rowlen-1;
     nrun = 1;
     }
 #endif              /* FASTRUNS */
     /* One final pass merges runs with fewer than 4 intervening pixels
      * if the second run is longer than 255 pixels.  This is because
      * the startup cost for such a run is 4 bytes.
      */
     if ( nrun > 1 )
     {
     for ( i = nrun - 1; i > 0; i-- )
     {
         if ( PBRUN[i][1] - PBRUN[i][0] > 255 &&
          PBRUN[i-1][1] + 4 > PBRUN[i][0] )
         {
         PBRUN[i-1][1] = PBRUN[i][1];
         for ( j = i; j < nrun - 1; j++ )
         {
             PBRUN[j][0] = PBRUN[j+1][0];
             PBRUN[j][1] = PBRUN[j+1][1];
         }
         nrun--;
         }
     }
     }
 
     if (nrun > 0)
     {
     if (the_hdr->priv.put.nblank > 0)
     {
         SkipBlankLines(the_hdr->priv.put.nblank);
         the_hdr->priv.put.nblank = 0;
     }
     for ( mask = (the_hdr->alpha ? -1 : 0);
           mask < the_hdr->ncolors;
           mask++)           /* do all colors */
     {
         if ( ! bits[mask & 0xff] )
         {
         continue;
         }
         row = rows[mask];
         SetColor(mask);
         if (PBRUN[0][0] > 0)
         {
         SkipPixels(PBRUN[0][0], FALSE, FALSE);
         }
         for (j=0; j<nrun; j++)
         {
         state = DATA;
         dstart = PBRUN[j][0];
         dend = PBRUN[j][1];
         for (i=dstart; i<=dend; i++)
         {
             switch(state)
             {
             case DATA:
             if (i > dstart && runval == row[i])
             {
                 /* 2 in a row may be a run. */
                 /* If odd data length, start with RUN1 */
                 if ( ((i - dstart) % 2) == 0)
                 state = RUN1;
                 else
                 state = RUN2;
             }
             else
             {
                 runval = row[i];    /* maybe a run starts here? */
                 rstart = i;
             }
             break;
         
             case RUN4:
             if (runval == row[i])
             {
                 /* If the following data might be longer
                  * than 255 pixels then look for 8 in a
                  * row, otherwise, 6 in a row is
                  * sufficient.  Fake this by skipping to
                  * state RUN5.
                  */
                 if ( dend - i > 255 )
                 state  = RUN5;  /* Need some more. */
                 else
                 state = RUN7;   /* Next one makes a run. */
                 
             }
             else
             {
                 state = DATA;   /* Nope, back to data */
                 runval = row[i];    /* but maybe a new run here? */
                 rstart = i;
             }
             break;
 
             case RUN1:
             case RUN2:
             case RUN3:
             case RUN5:
             case RUN6:
             if (runval == row[i])
             {
                 /* Move to the next state. */
                 state++;
             }
             else
             {
                 state = DATA;   /* Nope, back to data */
                 runval = row[i];    /* but maybe a new run here? */
                 rstart = i;
             }
             break;
 
 
             case RUN7:
             if (runval == row[i])   /* enough in a row for a run */
             {
                 state = INRUN;
                 putdata(row + dstart, rstart - dstart);
 #ifdef FASTRUNS
 #ifdef LOCC
                 /* Shortcut to find end of run! */
                 i = dend - skpc( (char *)row + i, dend + 1 - i,
                          runval );
 #else
                 while ( row[++i] == runval && i <= dend)
                 ; /* not quite so good, but not bad */
                 i--;
 #endif /* LOCC */
 #endif /* FASTRUNS */
             }
             else
             {
                 state = DATA;       /* not a run, */
                 runval = row[i];    /* but may this starts one */
                 rstart = i;
             }
             break;
         
             case INRUN:
             if (runval != row[i])   /* if run out */
             {
                 state = DATA;
                 putrun(runval, i - rstart, FALSE);
                 runval = row[i];    /* who knows, might be more */
                 rstart = i;
                 dstart = i; /* starting a new 'data' run */
             }
             break;
             }
         }
         if (state == INRUN)
             putrun(runval, i - rstart, TRUE);   /* last bit */
         else
             putdata(row + dstart, i - dstart);
 
         if (j < nrun-1)
             SkipPixels(
                 PBRUN[j+1][0] - dend - 1,
                 FALSE, state == INRUN);
         else
         {
             if (rowlen - dend > 0)
             SkipPixels(
                 rowlen - dend - 1,
                 TRUE, state == INRUN);
         }
         }
 
         if ( mask != the_hdr->ncolors - 1 )
         NewScanLine(FALSE);
     }
     }
 
     /* Increment to next scanline */
     the_hdr->priv.put.nblank++;
 
     /* flush every scanline */
     fflush( the_hdr->rle_file );
 }

Here is the caller graph for this function:

void rle_skiprow	(	rle_hdr *	the_hdr,
		int	nrow
	)

Definition at line 393 of file rle_putrow.c.

Referenced by write_rle_data().

 {
     the_hdr->priv.put.nblank += nrow;
 }

Here is the caller graph for this function:

Macros

Functions

Macro Definition Documentation

Function Documentation