rletoabA60.c File Reference

#include <stdio.h>
#include <math.h>
#include "rle.h"

Include dependency graph for rletoabA60.c:

Go to the source code of this file.

Macros
#define	LINE_LENGTH   720
#define	FRAME_LENGTH   486
#define	shifty(val)   y4=y3;y3=y2;y2=y1;y1=y0;y0=(val)
#define	shiftu(val)   u4=u3;u3=u2;u2=u1;u1=u0;u0=(val)
#define	shiftv(val)   v4=v3;v3=v2;v2=v1;v1=v0;v0=(val)

Functions
void	read_image ()
void	send_image ()
void	main (int argc, char **argv)
void	read_image (int yrun, scanbuf, int minx, int maxy, int xrun)
void	send_image (FILE *outfile)

Variables
rle_hdr	hdr
rle_pixel	scanred [486][720]
rle_pixel	scanblu [486][720]
rle_pixel	scangrn [486][720]

Macro Definition Documentation

#define FRAME_LENGTH   486

Definition at line 38 of file rletoabA60.c.

#define LINE_LENGTH   720

Definition at line 37 of file rletoabA60.c.

#define shiftu

(

val

)

u4=u3;u3=u2;u2=u1;u1=u0;u0=(val)

Definition at line 45 of file rletoabA60.c.

#define shiftv

(

val

)

v4=v3;v3=v2;v2=v1;v1=v0;v0=(val)

Definition at line 46 of file rletoabA60.c.

#define shifty

(

val

)

y4=y3;y3=y2;y2=y1;y1=y0;y0=(val)

Definition at line 44 of file rletoabA60.c.

Function Documentation

void main	(	int	argc,
		char **	argv
	)

Definition at line 56 of file rletoabA60.c.

{
    char       *infname = NULL,
               *out_fname = NULL;
    int     cflag = 0,
            Pflag = 0,
            pflag = 0,
            oflag = 0;
    register int i, xrun, maxy;
    int minx, maxx, miny, yrun, px, py;
    int ix, iy;
    rle_pixel *scanbuf[3];
    FILE *outfile;

    if ( scanargs( argc, argv,
    "% c%- P%-incx!dincy!d p%-posx!dposy!d o%-outfile!s infile%s\n(\
\t-c\tCenter image in Abekas frame.\n\
\t-p\tPosition image at given position.\n\
\t-P\tIncrementally position image by given offset.)",
          &cflag,
          &Pflag, &ix, &iy,
          &pflag, &px, &py, &oflag, &out_fname, &infname ) == 0 )
    exit(3);

    /* Initialize header. */
    hdr = *rle_hdr_init( (rle_hdr *)NULL );
    rle_names( &hdr, cmd_name( argv ), infname, 0 );

    if ( cflag + pflag +  Pflag > 1 )  {
    fprintf( stderr, "%s: specify exactly one of -c -p -P\n", hdr.cmd );
    exit(3);
    }
    hdr.rle_file = rle_open_f(hdr.cmd, infname, "r");
    outfile = rle_open_f(hdr.cmd, out_fname, "w");
    /*
     * Do the rle initialization stuff
     */
    rle_get_setup_ok( &hdr, NULL, NULL );

    if ( hdr.xmax > LINE_LENGTH || hdr.ymax > FRAME_LENGTH )  {     
    fprintf( stderr,"%s: rle image too big for Abekas\n", hdr.cmd);
    exit(3);
    }
    RLE_CLR_BIT( hdr, RLE_ALPHA );
    for (i = 3 ; i < hdr.ncolors ; i++) 
    RLE_CLR_BIT( hdr, i );
    
    /*
     * Initialize some variables.
     */
    bzero( scanred, LINE_LENGTH * FRAME_LENGTH );
    bzero( scangrn, LINE_LENGTH * FRAME_LENGTH );
    bzero( scanblu, LINE_LENGTH * FRAME_LENGTH );

    for (i=0; i<3; i++) 
    scanbuf[i] = (rle_pixel *) malloc ( LINE_LENGTH * sizeof(rle_pixel));

    /* 
     * Put the entire rle image into a buffer upside down and centered. 
     */
    xrun = hdr.xmax - hdr.xmin + 1;
    yrun = hdr.ymax - hdr.ymin + 1;
    if ( cflag )  {
    minx = (LINE_LENGTH - xrun) / 2;
    miny = (FRAME_LENGTH - yrun) / 2;
    }
    else if ( pflag )  {
    minx = px;
    miny = FRAME_LENGTH - (yrun + py);
    }
    else if ( Pflag )  {
    minx = hdr.xmin + ix;
    miny = FRAME_LENGTH - (yrun + hdr.ymin + iy);
    }
    else {
    minx = hdr.xmin;
    miny = FRAME_LENGTH - (yrun + hdr.ymin);
    }

    maxx = minx + xrun - 1;
    maxy = miny + yrun - 1;

    if ( maxx > LINE_LENGTH-1 )
    xrun = LINE_LENGTH - minx;

    read_image( yrun, scanbuf, minx, maxy, xrun );
    send_image( outfile );

    exit(0);
}

void read_image

(

)

void read_image	(	int	yrun,
		scanbuf	,
		int	minx,
		int	maxy,
		int	xrun
	)

Definition at line 150 of file rletoabA60.c.

{
    register int line, upsidedowny;

    for( line = 0; line < yrun; line++ )  {
    rle_getrow( &hdr, scanbuf );
    upsidedowny = maxy - line;

    if ( ( upsidedowny > FRAME_LENGTH-1 ) || ( upsidedowny < 0 ) )
        continue;

    bcopy( scanbuf[RLE_RED],   &scanred[upsidedowny][minx], xrun );
    bcopy( scanbuf[RLE_GREEN], &scangrn[upsidedowny][minx], xrun );
    bcopy( scanbuf[RLE_BLUE],  &scanblu[upsidedowny][minx], xrun );
    }

}

void send_image

(

)

void send_image

(

FILE *

outfile

)

Definition at line 172 of file rletoabA60.c.

{
    unsigned char buf[LINE_LENGTH*5];
    register unsigned char *bp;
    int line, col;
    register rle_pixel *sr, *sg, *sb;
    register int r, g, b;
    int y, u, v;
    int y0=0, y1=0, y2=0, y3=0, y4=0;
    int u0=0, u1=0, u2=0, u3=0, u4=0;
    int v0=0, v1=0, v2=0, v3=0, v4=0;
    
    /*
     * Convert the 720x486 rle image to yuv one byte at a time.
     *
     * All arithmetic is performed in "fixed point" integer for speed.
     * The original equations are shown in comments.
     */
    for( line=0; line < FRAME_LENGTH; line++ )  { 
    sr = scanred[line];  
    sg = scangrn[line]; 
    sb = scanblu[line];
    bp = buf;

    for( col=0; col < LINE_LENGTH; col+=2 )  {
        if ( *sr || *sg || *sb )
        {
        /*
         * r = *sr++ / 255.0;
         * g = *sg++ / 255.0;
         * b = *sb++ / 255.0;
         */
        r = (*sr++ * 8000000) / 255;
        g = (*sg++ * 8000000) / 255;
        b = (*sb++ * 8000000) / 255;

        /*
         * shifty( ( 0.2990 * r + 0.5870 * g + 0.1140 * b));
         * shiftu( (-0.1686 * r - 0.3311 * g + 0.4997 * b));
         * shiftv( ( 0.4998 * r - 0.4185 * g - 0.0813 * b));
         */
        shifty( ( r / 33445 + g / 17036 + b / 87719) * 1000000 );
        shiftu( (-r / 59312 - g / 30202 + b / 20012) * 1000000 );
        shiftv( ( r / 20012 - g / 23895 - b / 123001) * 1000000 );
        }
        else
        {
        sr++; sg++; sb++;
        shifty( 0 ); shiftu( 0 ); shiftv( 0 );
        }

        /*
         * u = ( (0.14963 * u0) + (0.22010 * u1)  
         *      +(0.26054 * u2) + (0.22010 * u3) 
         *      +(0.14963 * u4)) * 224;
         */
        u = ( (u0 / 66832) + (u1 / 45434)  
         +(u2 / 38382) + (u3 / 45434) 
         +(u4 / 66832)) * 224 / 80000;
        *bp++ = u + 128;

        /* 
         * y = (-(0.05674 * y0) + (0.01883 * y1)  
         *      +(1.07582 * y2) + (0.01883 * y3) 
         *      -(0.05674 * y4)) * 219.0;
         */
        y = (-(y0 / 176243) + (y1 / 531067)  
         +(y1 / 9295) + (y3 / 531067) 
         -(y4 / 176243)) * 219 / 80000;
        *bp++ = y + 16;
 
        /*
         * v =  ((0.14963 * v0) + (0.22010 * v1)  
         *      +(0.26054 * v2) + (0.22010 * v3) 
         *      +(0.14963 * v4)) * 224.0;
         */
        v = ( (v0 / 66832) + (v1 / 45434)  
         +(v2 / 38382) + (v3 / 45434) 
         +(v4 / 66832)) * 224 / 80000;
        *bp++ = v + 128;

        if ( *sr || *sg || *sb )
        {
        r = (*sr++ * 8000000) / 255;
        g = (*sg++ * 8000000) / 255;
        b = (*sb++ * 8000000) / 255;

        shifty( ( r / 33445 + g / 17036 + b / 87719) * 1000000 );
        shiftu( (-r / 59312 - g / 30202 + b / 20012) * 1000000 );
        shiftv( ( r / 20012 - g / 23895 - b / 123001) * 1000000 );
        }
        else
        {
        sr++; sg++; sb++;
        shifty( 0 ); shiftu( 0 ); shiftv( 0 );
        }

        y = (-(y0 / 176243) + (y1 / 531067)  
         +(y1 / 9295) + (y3 / 531067) 
         -(y4 / 176243)) * 219 / 80000;
        *bp++ = y + 16;
    }

    fwrite( buf, 1, bp - buf, outfile );
    }
}

Variable Documentation

rle_hdr hdr

Definition at line 50 of file rletoabA60.c.

rle_pixel scanblu[486][720]

Definition at line 52 of file rletoabA60.c.

rle_pixel scangrn[486][720]

Definition at line 53 of file rletoabA60.c.

rle_pixel scanred[486][720]

Definition at line 51 of file rletoabA60.c.