path: root/converter/other/rasttopnm.c

/* rasttopnm.c - read a Sun rasterfile and produce a portable anymap
**
** Copyright (C) 1989, 1991 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 "mallocvar.h"
#include "shhopt.h"
#include "pnm.h"
#include "rast.h"



struct cmdlineInfo {
    /* All the information the user supplied in the command line,
       in a form easy for the program to use.
    */
    const char * inputFileName;
    unsigned int index;
    unsigned int dumpheader;
    unsigned int dumpcolormap;
};



static void
parseCommandLine(int argc, const char ** argv,
                 struct cmdlineInfo * const cmdlineP) {
/*----------------------------------------------------------------------------
   Note that the file spec array we return is stored in the storage that
   was passed to us as the argv array.
-----------------------------------------------------------------------------*/
    optEntry * option_def;
        /* Instructions to OptParseOptions2 on how to parse our options.
         */
    optStruct3 opt;

    unsigned int option_def_index;

    MALLOCARRAY_NOFAIL(option_def, 100);

    option_def_index = 0;   /* incremented by OPTENT3 */

    opt.opt_table = option_def;
    opt.short_allowed = false;  /* We have no short (old-fashioned) options */
    opt.allowNegNum = false;  /* We have no parms that are negative numbers */

    OPTENT3(0,   "index",        OPT_FLAG,   NULL,
            &cmdlineP->index,          0);
    OPTENT3(0,   "dumpheader",   OPT_FLAG,   NULL,
            &cmdlineP->dumpheader,     0);
    OPTENT3(0,   "dumpcolormap", OPT_FLAG,   NULL,
            &cmdlineP->dumpcolormap,   0);

    pm_optParseOptions3(&argc, (char **)argv, opt, sizeof(opt), 0);
        /* Uses and sets argc, argv, and some of *cmdlineP and others. */

    if (argc-1 == 0)
        cmdlineP->inputFileName = "-";
    else if (argc-1 != 1)
        pm_error("Program takes zero or one argument (filename).  You "
                 "specified %d", argc-1);
    else
        cmdlineP->inputFileName = argv[1];
}



static bool
colorMapIsGrayscale(colormap_t const colorMap) {
/*----------------------------------------------------------------------------
   The color map contains only gray.
-----------------------------------------------------------------------------*/
    unsigned int i;
    bool grayscale;

    for (i = 0, grayscale = true; i < colorMap.length; ++i) {
        if (colorMap.map[0][i] != colorMap.map[1][i] ||
            colorMap.map[1][i] != colorMap.map[2][i]) {
            grayscale = false;
        }
    }
    return grayscale;
}



static void
analyzeImage(struct rasterfile const header,
             colormap_t        const colorMap,
             int *             const formatP,
             xelval *          const maxvalP,
             bool *            const grayscaleP,
             xel *             const zeroP,
             xel *             const oneP) {

    bool const grayscale =
        header.ras_maplength == 0 || colorMapIsGrayscale(colorMap);

    *grayscaleP = grayscale;

    switch (header.ras_depth) {
    case 1:
        if (header.ras_maptype == RMT_NONE && header.ras_maplength == 0) {
            *maxvalP = 1;
            *formatP = PBM_TYPE;
            PNM_ASSIGN1(*zeroP, 1);
            PNM_ASSIGN1(*oneP, 0);
        } else if (header.ras_maptype == RMT_EQUAL_RGB &&
                   header.ras_maplength == 6) {
            if (grayscale) {
                *maxvalP = 255;
                *formatP = PGM_TYPE;
                PNM_ASSIGN1(*zeroP, colorMap.map[0][0]);
                PNM_ASSIGN1(*oneP, colorMap.map[0][1]);
            } else {
                *maxvalP = 255;
                *formatP = PPM_TYPE;
                PPM_ASSIGN(
                    *zeroP, colorMap.map[0][0], colorMap.map[1][0],
                    colorMap.map[2][0]);
                PPM_ASSIGN(
                    *oneP, colorMap.map[0][1], colorMap.map[1][1],
                    colorMap.map[2][1]);
            }
        } else
            pm_error(
                "this depth-1 rasterfile has a non-standard colormap - "
                "type %ld length %ld",
                header.ras_maptype, header.ras_maplength);
        break;

    case 8:
        if (grayscale) {
            *maxvalP = 255;
            *formatP = PGM_TYPE;
        } else if (header.ras_maptype == RMT_EQUAL_RGB) {
            *maxvalP = 255;
            *formatP = PPM_TYPE;
        } else
            pm_error(
                "this depth-8 rasterfile has a non-standard colormap - "
                "type %ld length %ld",
                header.ras_maptype, header.ras_maplength);
        break;

    case 24:
    case 32:
        if (header.ras_maptype == RMT_NONE && header.ras_maplength == 0);
        else if (header.ras_maptype == RMT_RAW || header.ras_maplength == 768);
        else
            pm_error(
                "this depth-%ld rasterfile has a non-standard colormap - "
                "type %ld length %ld",
                header.ras_depth, header.ras_maptype, header.ras_maplength);
        *maxvalP = 255;
        *formatP = PPM_TYPE;
        break;

    default:
        pm_error("invalid depth: %ld.  Can handle only depth 1, 8, 24, or 32.",
                 header.ras_depth);
    }
}



static void
reportOutputType(int const format) {

    switch (PNM_FORMAT_TYPE(format)) {
    case PBM_TYPE:
        pm_message("writing PBM file");
        break;
    case PGM_TYPE:
        pm_message("writing PGM file");
        break;
    case PPM_TYPE:
        pm_message("writing PPM file");
        break;
    default:
        abort();
    }
}



static void
convertRowDepth1(const unsigned char * const rastLine,
                 unsigned int          const cols,
                 xel                   const zeroXel,
                 xel                   const oneXel,
                 xel *                 const xelrow) {

    const unsigned char * byteP;
     unsigned int col;
    unsigned char mask;

    byteP = rastLine;  /* initial value */

    for (col = 0, mask = 0x80; col < cols; ++col) {
        if (mask == 0x00) {
            ++byteP;
            mask = 0x80;
        }
        xelrow[col] = (*byteP & mask) ? oneXel : zeroXel;
        mask = mask >> 1;
    }
}



static void
convertRowDepth8(const unsigned char * const lineStart,
                 unsigned int          const cols,
                 bool                  const colorMapped,
                 bool                  const useIndexForColor,
                 bool                  const grayscale,
                 colormap_t            const colorMap,
                 xel *                 const xelrow) {
/*----------------------------------------------------------------------------
   Convert a line of raster data from the RAST input to a row of raster
   data for the PNM output.

   'lineStart' is where the RAST row starts.   'xelrow' is where to put the
   PNM row.  'cols' is the number of pixels in the row.

   'colorMapped' means the RAST image is colormapped.  If so, 'colorMap'
   is the color map from the RAST file and 'useIndexForColor' means not
   to use that map but instead to create a PGM row of the colormap
   _indices_.

   'grayscale' means it is a grayscale image; the output is PGM.
-----------------------------------------------------------------------------*/
    const unsigned char * byteP;
    unsigned int col;

    byteP = lineStart; /* initial value */

    for (col = 0; col < cols; ++col) {
        if (colorMapped && !useIndexForColor) {
            if (grayscale)
                PNM_ASSIGN1(xelrow[col], colorMap.map[0][*byteP]);
            else
                PPM_ASSIGN(xelrow[col],
                           colorMap.map[0][*byteP],
                           colorMap.map[1][*byteP],
                           colorMap.map[2][*byteP]);
        } else
            PNM_ASSIGN1(xelrow[col], *byteP);

        ++byteP;
    }
}



static void
convertRowRgb(const unsigned char * const lineStart,
              unsigned int          const cols,
              unsigned int          const depth,
              long                  const rastType,
              bool                  const colorMapped,
              bool                  const useIndexForColor,
              colormap_t            const colorMap,
              xel *                 const xelrow) {

    const unsigned char * byteP;
    unsigned int col;

    byteP = lineStart; /* initial value */

    for (col = 0; col < cols; ++col) {
        xelval r, g, b;

        if (depth == 32)
            ++byteP;
        if (rastType == RT_FORMAT_RGB) {
            r = *byteP++;
            g = *byteP++;
            b = *byteP++;
        } else {
            b = *byteP++;
            g = *byteP++;
            r = *byteP++;
        }
        if (colorMapped && !useIndexForColor)
            PPM_ASSIGN(xelrow[col],
                       colorMap.map[0][r],
                       colorMap.map[1][g],
                       colorMap.map[2][b]);
        else
            PPM_ASSIGN(xelrow[col], r, g, b);
    }
}



static void
writePnm(FILE *                 const ofP,
         const struct pixrect * const pixRectP,
         unsigned int           const cols,
         unsigned int           const rows,
         xelval                 const maxval,
         int                    const format,
         unsigned int           const depth,
         long                   const rastType,
         bool                   const grayscale,
         bool                   const colorMapped,
         colormap_t             const colorMap,
         xel                    const zeroXel,
         xel                    const oneXel,
         bool                   const useIndexForColor) {

    struct mpr_data const mprData = *pixRectP->pr_data;

    xel * xelrow;
    unsigned int row;
    unsigned char * lineStart;

    pnm_writepnminit(ofP, cols, rows, maxval, format, 0);

    xelrow = pnm_allocrow(cols);

    reportOutputType(format);

    for (row = 0, lineStart = mprData.md_image;
         row < rows;
         ++row, lineStart += mprData.md_linebytes) {

        switch (depth) {
        case 1:
            convertRowDepth1(lineStart, cols, zeroXel, oneXel, xelrow);
            break;
        case 8:
            convertRowDepth8(lineStart, cols, colorMapped, useIndexForColor,
                             grayscale, colorMap, xelrow);
            break;
        case 24:
        case 32:
            convertRowRgb(lineStart, cols, depth, rastType, colorMapped,
                          useIndexForColor, colorMap, xelrow);
            break;
        default:
            pm_error("Invalid depth value: %u", depth);
        }
        pnm_writepnmrow(ofP, xelrow, cols, maxval, format, 0);
    }
}



static void
dumpHeader(struct rasterfile const header) {

    const char * typeName;

    switch (header.ras_type) {
    case RT_OLD:            typeName = "old";           break;
    case RT_STANDARD:       typeName = "standard";      break;
    case RT_BYTE_ENCODED:   typeName = "byte encoded";  break;
    case RT_FORMAT_RGB:     typeName = "format rgb";    break;
    case RT_FORMAT_TIFF:    typeName = "format_tiff";   break;
    case RT_FORMAT_IFF:     typeName = "format_iff";    break;
    case RT_EXPERIMENTAL:   typeName = "experimental";  break;
    default:                typeName = "???";
    }

    pm_message("type: %s (%lu)", typeName, (unsigned long)header.ras_type);
    pm_message("%luw x %lul x %lud",
               (unsigned long)header.ras_width,
               (unsigned long)header.ras_height,
               (unsigned long)header.ras_depth);
    pm_message("raster length: %lu", (unsigned long)header.ras_length);

    if (header.ras_maplength)
        pm_message("Has color map");
}



static void
dumpHeaderAnalysis(bool         const grayscale,
                   unsigned int const depth,
                   xel          const zero,
                   xel          const one) {

    pm_message("grayscale: %s", grayscale ? "YES" : "NO");

    if (depth == 1) {
        pm_message("Zero color: (%u,%u,%u)",
                   PNM_GETR(zero),
                   PNM_GETG(zero),
                   PNM_GETB(zero));

        pm_message("One color: (%u,%u,%u)",
                   PNM_GETR(one),
                   PNM_GETG(one),
                   PNM_GETB(one));
    }
}



static void
dumpColorMap(colormap_t const colorMap) {

    unsigned int i;
    const char * typeName;

    switch (colorMap.type) {
    case RMT_NONE:      typeName = "NONE";      break;
    case RMT_EQUAL_RGB: typeName = "EQUAL_RGB"; break;
    case RMT_RAW:       typeName = "RAW";       break;
    default:            typeName = "???";
    }

    pm_message("color map type = %s (%u)", typeName, colorMap.type);

    pm_message("color map size = %u", colorMap.length);

    for (i = 0; i < colorMap.length; ++i)
        pm_message("color %u: (%u, %u, %u)", i,
                   (unsigned char)colorMap.map[0][i],
                   (unsigned char)colorMap.map[1][i],
                   (unsigned char)colorMap.map[2][i]);
}



int
main(int argc, const char ** const argv) {

    struct cmdlineInfo cmdline;
    FILE * ifP;
    struct rasterfile header;
    colormap_t colorMap;
    bool grayscale;
    struct pixrect * pr;
    int format;
    xelval maxval;
    xel zero, one;
    int rc;

    pm_proginit(&argc, argv);

    parseCommandLine(argc, argv, &cmdline);

    ifP = pm_openr(cmdline.inputFileName);

    rc = pr_load_header(ifP, &header);
    if (rc != 0 )
        pm_error("unable to read in rasterfile header");

    if (cmdline.dumpheader)
        dumpHeader(header);

    if (header.ras_maplength != 0) {
        int rc;

        rc = pr_load_colormap(ifP, &header, &colorMap);

        if (rc != 0 )
            pm_error("unable to read colormap from RAST file");

        if (cmdline.dumpcolormap)
            dumpColorMap(colorMap);
    }

    analyzeImage(header, colorMap, &format, &maxval, &grayscale, &zero, &one);

    if (cmdline.dumpheader)
        dumpHeaderAnalysis(grayscale, header.ras_depth, zero, one);

    pr = pr_load_image(ifP, &header, NULL);
    if (pr == NULL )
        pm_error("unable to read in the image from the rasterfile" );

    if (cmdline.index && header.ras_maplength == 0)
        pm_error("You requested to use color map indices as colors (-index), "
                 "but this is not a color mapped image");

    writePnm(stdout, pr, header.ras_width, header.ras_height, maxval, format,
             header.ras_depth, header.ras_type, grayscale,
             header.ras_maplength > 0, colorMap, zero, one, cmdline.index);

    pm_close(ifP);
    pm_close(stdout);

    return 0;
}