/*********************************************************************/

/* ppmflash -  brighten a picture up to total whiteout               */

/* Frank Neumann, August 1993                                        */

/* V1.4 16.11.1993                                                   */

/*                                                                   */

/* version history:                                                  */

/* V1.0 ~ 15.August 1993    first version                            */

/* V1.1 03.09.1993          uses ppm libs & header files             */

/* V1.2 03.09.1993          integer arithmetics instead of float     */

/*                          (gains about 50 % speed up)              */

/* V1.3 11.10.1993          reads only one line at a time - this     */

/*                          saves LOTS of memory on big picturs      */

/* V1.4 16.11.1993          Rewritten to be NetPBM.programming con-  */

/*                          forming                                  */

/*********************************************************************/

#include "ppm.h"

/* global variables */

#ifdef AMIGA

static char *version = "$VER: ppmflash 1.4 (16.11.93)";

#endif

/**************************/

/* start of main function */

/**************************/

int main(argc, argv)

    int argc;

    char *argv[];

{

    FILE* ifp;

    int argn, rows, cols, i, j, format;

    pixel *srcrow, *destrow;

    pixel *pP, *pP2;

    pixval maxval;

    double flashfactor;

    long longfactor;

    const char* const usage = "flashfactor [ppmfile]\n        flashfactor: 0.0 = original picture, 1.0 = total whiteout\n";

    /* parse in 'default' parameters */

    ppm_init( &argc, argv );

    argn = 1;

    /* parse in flash factor */

    if (argn == argc)

        pm_usage(usage);

    if (sscanf(argv[argn], "%lf", &flashfactor) != 1)

        pm_usage(usage);

    if (flashfactor < 0.0 || flashfactor > 1.0)

        pm_error("flash factor must be in the range from 0.0 to 1.0 ");

    ++argn;

    /* parse in filename (if present, stdin otherwise) */

    if (argn != argc)

    {

        ifp = pm_openr(argv[argn]);

        ++argn;

    }

    else

        ifp = stdin;

    if (argn != argc)

        pm_usage(usage);

    /* read first data from file */

    ppm_readppminit(ifp, &cols, &rows, &maxval, &format);

    /* no error checking required here, ppmlib does it all for us */

    srcrow = ppm_allocrow(cols);

    longfactor = (long)(flashfactor * 65536);

    /* allocate a row of pixel data for the new pixels */

    destrow = ppm_allocrow(cols);

    ppm_writeppminit(stdout, cols, rows, maxval, 0);

    /** now do the flashing **/

    /* the 'float' parameter for flashing is sort of faked - in fact, we */

    /* convert it to a range from 0 to 65536 for integer math. Shouldn't */

    /* be something you'll have to worry about, though. */

    for (i = 0; i < rows; i++) {

        ppm_readppmrow(ifp, srcrow, cols, maxval, format);

        pP = srcrow;

        pP2 = destrow;

        for (j = 0; j < cols; j++) {

            PPM_ASSIGN(*pP2, 

                       PPM_GETR(*pP) + 

                       (((maxval - PPM_GETR(*pP)) * longfactor) >> 16),

                       PPM_GETG(*pP) + 

                       (((maxval - PPM_GETG(*pP)) * longfactor) >> 16),

                       PPM_GETB(*pP) + 

                       (((maxval - PPM_GETB(*pP)) * longfactor) >> 16));

            pP++;

            pP2++;

        }

        /* write out one line of graphic data */

        ppm_writeppmrow(stdout, destrow, cols, maxval, 0);

    }

    pm_close(ifp);

    ppm_freerow(srcrow);

    ppm_freerow(destrow);

    exit(0);

}