/* ppmtopgm.c - convert a portable pixmap to a portable graymap
**
** Copyright (C) 1989 by Jef Poskanzer.
**
** Permission to use, copy, modify, and distribute this software and its
** documentation for any purpose and without fee is hereby granted, provided
** that the above copyright notice appear in all copies and that both that
** copyright notice and this permission notice appear in supporting
** documentation.  This software is provided "as is" without express or
** implied warranty.
*/

#include "pm_c_util.h"
#include "ppm.h"
#include "pgm.h"
#include "lum.h"

static void
convertRaster(FILE *       const ifP,
              unsigned int const cols,
              unsigned int const rows,
              pixval       const maxval,
              int          const format, 
              pixel *      const inputRow,
              gray *       const outputRow, 
              FILE *       const ofP) {

    unsigned int row;

    for (row = 0; row < rows; ++row) {
        ppm_readppmrow( ifP, inputRow, cols, maxval, format );
        if (maxval <= 255) {
            /* Use fast approximation to 0.299 r + 0.587 g + 0.114 b */
            unsigned int col;
            for (col = 0; col < cols; ++col)
                outputRow[col] = (gray) ppm_fastlumin(inputRow[col]);
        } else {
            /* Can't use fast approximation, so fall back on floats. */
            unsigned int col;
            for (col = 0; col < cols; ++col) 
                outputRow[col] = ppm_luminosity(inputRow[col]);
        }
        pgm_writepgmrow(ofP, outputRow, cols, maxval, 0);
    }
}



int
main(int argc, char *argv[]) {

    FILE* ifP;
    const char * inputFilespec;
    int eof;
    
    ppm_init( &argc, argv );

    if (argc-1 > 1)
        pm_error("The only argument is the (optional) input filename");

    if (argc == 2)
        inputFilespec = argv[1];
    else
        inputFilespec = "-";
    
    ifP = pm_openr(inputFilespec);

    eof = FALSE;  /* initial assumption */

    while (!eof) {
        ppm_nextimage(ifP, &eof);
        if (!eof) {
            int rows, cols, format;
            pixval maxval;
            pixel* inputRow;
            gray* outputRow;

            ppm_readppminit(ifP, &cols, &rows, &maxval, &format);
            pgm_writepgminit(stdout, cols, rows, maxval, 0);

            inputRow = ppm_allocrow(cols);
            outputRow = pgm_allocrow(cols);

            convertRaster(ifP, cols, rows, maxval, format, 
                          inputRow, outputRow, stdout);

            ppm_freerow(inputRow);
            pgm_freerow(outputRow);
        }
    }
    pm_close(ifP);
    pm_close(stdout);

    return 0;
}
