#include <stdio.h>                                                              
                                                                                
main()                                                                          
{                                                                               
 int   cols, rows, interlace;                                                   
 int   result;                                                                  
 char *image, *c;                                                               
 char *redrow, *greenrow, *bluerow;                                             
 int   i;                                                                       
 FILE *f;                                                                       
 FILE *g;                                                                       
 FILE *cr;                                                                      
 FILE *cg;                                                                      
 FILE *cb;                                                                      
 union {                                                                        
         short size;                                                            
         char  sizec??( 2 ??);                                                  
       } equiv;                                                                 
 void  compress( );                                                             
 char  rowpad??( 8 ??);                                                         
                                                                                
 result = DF24getdims( "dd:input", &cols, &rows, &interlace );                  
 printf( "\n return code from DF24getdims %i", result );                        
 printf( "\n cols= %i rows= %i", cols, rows );                                  
 printf( "\n interlace= %i", interlace );                                       
                                                                                
 result = DF24reqil( 1 );                                                       
 printf( "\n return code from DF24reqil= %i", result );                         
                                                                                
 image = ( char * )malloc( cols*3*rows );                                       
                                                                                
 result = DF24getimage( "dd:input", image, cols, rows );                        
 printf( "\n return code from DF24getimage %i", result );                       
                                                                                
 /****************************************************************/             
 /* mike these following 4 lines write out the entire raw raster */             
 /* comment them if you dont want it                             */             
 /* you will also have to remove type=record from all open statem*/             
 /****************************************************************/             
 /* g = fopen( "dd:raw", "wb,type=record" );     */                             
 /*  for( i = 0;  i < rows;  i++ ) */                                           
 /*    fwrite( image+i*(cols*3), cols*3, 1, g ); */                             
 /*  fclose( g ); */                                                            
                                                                                
    redrow   = image;                                                           
    greenrow = redrow   + cols;                                                 
    bluerow  = greenrow + cols;                                                 
                                                                                
    f = fopen( "dd:output", "wb" );                                             
 /* cr= fopen( "dd:red", "wb,type=record" );   */                               
 /* cg= fopen( "dd:green", "wb,type=record" );             */                   
 /* cb= fopen( "dd:blue", "wb,type=record" );              */                   
                                                                                
    c = ( char * )malloc( 2*cols+1 );                                           
                                                                                
   for( i = 0;  i < rows;  i++ )                                                
     {                                                                          
 /*      fwrite( redrow,   cols, 1, cr );             */                        
 /*      fwrite( greenrow, cols, 1, cg );                  */                   
 /*      fwrite( bluerow,  cols, 1, cb );                  */                   
         compress( redrow, cols, &equiv.size, c );                              
            fwrite( equiv.sizec, 2, 1, f );                                     
            fwrite( c, equiv.size, 1, f );                                      
         compress( greenrow, cols, &equiv.size, c );                            
            fwrite( equiv.sizec, 2, 1, f );                                     
            fwrite( c, equiv.size, 1, f );                                      
         compress( bluerow, cols, &equiv.size, c );                             
            fwrite( equiv.sizec, 2, 1, f );                                     
            fwrite( c, equiv.size, 1, f );                                      
                                                                                
         redrow   = bluerow  + cols;                                            
         greenrow = redrow   + cols;                                            
         bluerow  = greenrow + cols;                                            
     }                                                                          
                                                                                
                                                                                
 /***********************************************/                              
 /* make it fit a predefined # of rows (480)    */                              
 /* Mike - I was using this for head to make the*/                              
 /* rle version exactly 480 rows.  you dont care*/                              
 /***********************************************/                              
                                                                                
 /*rowpad??( 0 ??) = ( char )0x00;                                              
   rowpad??( 1 ??) = ( char )0x06;                                              
   rowpad??( 2 ??) = ( char )0xfe;                                              
   rowpad??( 3 ??) = ( char )0x00;                                              
   rowpad??( 4 ??) = ( char )0xfe;                                              
   rowpad??( 5 ??) = ( char )0x00;                                              
   rowpad??( 6 ??) = ( char )0x81;                                              
   rowpad??( 7 ??) = ( char )0x00;                                              
                                                                                
   for( i = 0;  i < 152;  i++ )                                                 
     {                                                                          
       fwrite( rowpad, 8, 1, f );                                               
     }                                  */                                      
                                                                                
fclose( f );                                                                    
}                                                                               
                                                                                
void compress( row, cols, size, comprow )                                       
char   *row;                                                                    
int     cols;                                                                   
short  *size;                                                                   
char   *comprow;                                                                
                                                                                
{                                                                               
                                                                                
char   *ptr;                                                                    
short   count;                                                                  
int     i;                                                                      
                                                                                
ptr   = comprow;                                                                
count = 1;                                                                      
for( i = 1;  i < cols;  i++ )                                                   
   {                                                                            
      if( *( row + i ) == *( row + (i - 1) ) && count < 255 )                   
          count++;                                                              
      else                                                                      
         {                                                                      
            *ptr         =  ( char )( count - 1 );                              
            *( ptr + 1 ) = *( row + (i - 1) );                                  
             ptr = ptr + 2;                                                     
             count = 1;                                                         
          }                                                                     
   }                                                                            
                                                                                
*ptr         =  ( char )( count - 1 );                                          
*( ptr + 1 ) = *( row + (i - 1) );                                              
  ptr = ptr + 2;                                                                
                                                                                
 /***********************************************/                              
 /* make it fit a predefined size (640)         */                              
 /***********************************************/                              
                                                                                
 /* count = 122;                                                                
    *ptr         =  ( char )( count - 1 );                                      
     count = 0;                                                                 
    *( ptr + 1 ) =  ( char )count;                                              
     ptr = ptr + 2;                                                             
                                                                                
       count = 255;                                                             
      *ptr         =  ( char )( count - 1 );                                    
       count = 0;                                                               
      *( ptr + 1 ) =  ( char )count;                                            
       ptr = ptr + 2;              */                                           
                                                                                
 /***********************************************/                              
 /* remove above when rs 6000 variable size     */                              
 /***********************************************/                              
                                                                                
*size = ptr - comprow;                                                          
                                                                                
}