path: root/converter/ppm/ppmtoarbtxt.c

/* ppmtoarbtxt.c - convert portable pixmap to cleartext
**
** Renamed from ppmtotxt.c by Bryan Henderson in January 2003.
**
** Copyright (C) 1995 by Peter Kirchgessner
**
** 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 <string.h>

#include "ppm.h"
#include "mallocvar.h"
#include "nstring.h"

typedef enum {
/* The types of object we handle */
    BDATA, IRED, IGREEN, IBLUE, ILUM, FRED, FGREEN, FBLUE, FLUM,
    WIDTH, HEIGHT, POSX, POSY
} SKL_OBJ_TYP;

typedef enum {
    OBJTYP_ICOLOR, OBJTYP_FCOLOR, OBJTYP_INT, OBJTYP_BDATA
} SKL_OBJ_CLASS;

/* Maximum size for a format string ("%d" etc.) */
#define MAXFORMAT 16

/* The data we keep for each object */
typedef union
 {
  struct BNDAT { char *bdat;   /* Binary data (text with newlines etc.) */
                 int ndat;
               } bin_data;

  struct ICDAT { char icformat[MAXFORMAT];  /* Integer colors */
                 int icolmin, icolmax;
               } icol_data;

  struct FCDAT { char fcformat[MAXFORMAT];  /* Float colors */
                 double fcolmin, fcolmax;
               } fcol_data;

  struct IDAT  { char iformat[MAXFORMAT];   /* Integer data */
               } i_data;
 } SKL_OBJ_DATA;


/* Each object has a type and some data */
typedef struct
 { 
   SKL_OBJ_TYP otyp;
   SKL_OBJ_DATA odata;
 } SKL_OBJ;


#define MAX_SKL_HEAD_OBJ 64
#define MAX_SKL_BODY_OBJ 256
#define MAX_SKL_TAIL_OBJ 64
#define MAX_LINE_BUF 1024
#define MAX_OBJ_BUF 80


static void write_txt (fout, nobj, obj, width, height, x, y, red, green, blue)
FILE *fout;
int nobj;
SKL_OBJ *obj[];
int width, height, x, y;
double red, green, blue;

{register int count;

#define WRITE_BNDAT(fd,theobj) \
 {struct BNDAT *bdata = &((theobj)->odata.bin_data); \
       fwrite (bdata->bdat,bdata->ndat,1,fd); }

#define WRITE_ICOL(fd,theobj,thecol) \
 {struct ICDAT *icdata = &((theobj)->odata.icol_data); \
  fprintf (fd,icdata->icformat,(int)(icdata->icolmin \
                + (icdata->icolmax - icdata->icolmin)*(thecol))); }

#define WRITE_FCOL(fd,theobj,thecol) \
 {struct FCDAT *fcdata = &((theobj)->odata.fcol_data); \
  fprintf (fd,fcdata->fcformat,(double)(fcdata->fcolmin \
                + (fcdata->fcolmax - fcdata->fcolmin)*(thecol))); }

#define WRITE_IDAT(fd,theobj,thedat) \
 {struct IDAT *idata = &((theobj)->odata.i_data); \
  fprintf (fd,idata->iformat,thedat); }

 for (count = 0; count < nobj; count++)
 {
   switch (obj[count]->otyp)
   {
     case BDATA:
       WRITE_BNDAT (fout,obj[count]);
       break;
     case IRED:
       WRITE_ICOL (fout,obj[count],red);
       break;
     case IGREEN:
       WRITE_ICOL (fout,obj[count],green);
       break;
     case IBLUE:
       WRITE_ICOL (fout,obj[count],blue);
       break;
     case ILUM:
       WRITE_ICOL (fout,obj[count],0.299*red+0.587*green+0.114*blue);
       break;
     case FRED:
       WRITE_FCOL (fout,obj[count],red);
       break;
     case FGREEN:
       WRITE_FCOL (fout,obj[count],green);
       break;
     case FBLUE:
       WRITE_FCOL (fout,obj[count],blue);
       break;
     case FLUM:
       WRITE_FCOL (fout,obj[count],0.299*red+0.587*green+0.114*blue);
       break;
     case WIDTH:
       WRITE_IDAT (fout,obj[count],width);
       break;
     case HEIGHT:
       WRITE_IDAT (fout,obj[count],height);
       break;
     case POSX:
       WRITE_IDAT (fout,obj[count],x);
       break;
     case POSY:
       WRITE_IDAT (fout,obj[count],y);
       break;
   }
 }
}


static SKL_OBJ *
save_bin_data(int    const ndat, 
              char * const bdat) {

    /* Save binary data in Object */

    SKL_OBJ *obj;

    obj = (SKL_OBJ *)malloc (sizeof (SKL_OBJ) + ndat);
    if (obj != NULL)
    {
        obj->otyp = BDATA;
        obj->odata.bin_data.ndat = ndat;
        obj->odata.bin_data.bdat = ((char *)(obj))+sizeof (SKL_OBJ);
        memcpy (obj->odata.bin_data.bdat,bdat,ndat);
    }
    return (obj);
}



static SKL_OBJ *
save_icol_data(SKL_OBJ_TYP  const ctyp,
               const char * const format,
               int          const icolmin,
               int          const icolmax) {
/* Save integer color data in Object */

    SKL_OBJ * objP;

    MALLOCVAR(objP);

    if (objP) {
        objP->otyp = ctyp;
        strcpy(objP->odata.icol_data.icformat, format);
        objP->odata.icol_data.icolmin = icolmin;
        objP->odata.icol_data.icolmax = icolmax;
    }
    return objP;
}



static SKL_OBJ *
save_fcol_data(SKL_OBJ_TYP  const ctyp,
               const char * const format,
               double       const fcolmin,
               double       const fcolmax) {
/* Save float color data in Object */

    SKL_OBJ * objP;

    MALLOCVAR(objP);

    if (objP) {
        objP->otyp = ctyp;
        strcpy(objP->odata.fcol_data.fcformat, format);
        objP->odata.fcol_data.fcolmin = fcolmin;
        objP->odata.fcol_data.fcolmax = fcolmax;
    }
    return objP;
}



static SKL_OBJ *
save_i_data(SKL_OBJ_TYP  const ctyp,
            const char * const format) {

/* Save universal data in Object */

    SKL_OBJ * objP;

    MALLOCVAR(objP);
    if (objP) {
        objP->otyp = ctyp;
        strcpy(objP->odata.i_data.iformat, format);
    }
    return objP;
}



static char const escape = '#';



static SKL_OBJ_TYP
interpretObjType(const char * const typstr) {

    SKL_OBJ_TYP otyp;

    /* Check for integer colors */
    if      (streq(typstr, "ired")  ) otyp = IRED;
    else if (streq(typstr, "igreen")) otyp = IGREEN;
    else if (streq(typstr, "iblue") ) otyp = IBLUE;
    else if (streq(typstr, "ilum")  ) otyp = ILUM;
    /* Check for real colors */
    else if (streq(typstr, "fred")  ) otyp = FRED;
    else if (streq(typstr, "fgreen")) otyp = FGREEN;
    else if (streq(typstr, "fblue") ) otyp = FBLUE;
    else if (streq(typstr, "flum")  ) otyp = FLUM;
    /* Check for integer data */
    else if (streq(typstr, "width") ) otyp = WIDTH;
    else if (streq(typstr, "height")) otyp = HEIGHT;
    else if (streq(typstr, "posx")  ) otyp = POSX;
    else if (streq(typstr, "posy")  ) otyp = POSY;
    else                              otyp = BDATA;

    return otyp;
}



static SKL_OBJ_CLASS
objClass(SKL_OBJ_TYP const otyp) {

    switch (otyp) {
    case IRED:
    case IGREEN:
    case IBLUE:
    case ILUM:
        return OBJTYP_ICOLOR;

    case FRED:
    case FGREEN:
    case FBLUE:
    case FLUM:
        return OBJTYP_FCOLOR;

    case WIDTH:
    case HEIGHT:
    case POSX:
    case POSY:
        return OBJTYP_INT;
    case BDATA:
        return OBJTYP_BDATA;
    }
    return 999; /* quiet compiler warning */
}



static void
addImpostorReplacementSeq(char *         const line,
                          unsigned int   const startCursor,
                          const char *   const seqContents,
                          unsigned int   const seqContentsLen,
                          unsigned int * const newCursorP) {
/*----------------------------------------------------------------------------
   Add to line line[], at position 'startCursor', text that looks like a
   replacement sequence but doesn't have the proper contents (the
   stuff between the parentheses) to be one.  For example,

     "#(fread x)"

   seqContents[] is the contents; 'seqContentsLen' its length.

   Return as *newCursorP where the line[] cursor ends up after adding
   the sequence.
-----------------------------------------------------------------------------*/
    unsigned int cursor;
    unsigned int i;

    cursor = startCursor;

    line[cursor++] = escape;
    line[cursor++] = '(';

    for (i = 0; i < seqContentsLen; ++i)
        line[cursor++] = seqContents[i];

    line[cursor++] = ')';

    *newCursorP = cursor;
}



static int
read_skeleton(const char *   const filename,
              unsigned int   const maxskl,
              unsigned int * const nsklP,
              SKL_OBJ **     const skl) {
/*----------------------------------------------------------------------------
  Read skeleton file
-----------------------------------------------------------------------------*/
    FILE * sklfile;
    unsigned int slen;
    unsigned int objlen;
    int chr;
    SKL_OBJ_TYP otyp;
    char line[MAX_LINE_BUF+MAX_OBJ_BUF+16];
    char objstr[MAX_OBJ_BUF],typstr[MAX_OBJ_BUF];
    unsigned int nskl;

#define SAVE_BIN(slen,line) \
    { if (slen > 0 && (skl[nskl] = save_bin_data(slen,line)) != NULL) ++nskl; \
      slen = 0; }

    sklfile = pm_openr(filename);

    /* Parse skeleton file */
    nskl = 0;  /* initial value */

    slen = 0;
    while ((chr = getc (sklfile)) != EOF) {  /* Up to end of skeleton file */
        if (nskl >= maxskl)
            return -1;

        if (slen+1 >= MAX_LINE_BUF) {
            /* Buffer finished.  Save as binary object */
            SAVE_BIN(slen,line);
        }

        if (chr != escape) {
            /* Not a replacement sequence; just a literal character */
            line[slen++] = chr;
            continue;
        }

        chr = getc(sklfile);
        if (chr == EOF) {
            /* Not a valid replacement sequence */
            line[slen++] = escape;
            break;
        }
        if (chr != '(') {
            /* Not a valid replacement sequence */
            line[slen++] = escape;
            line[slen++] = chr;
            continue;
        }
        /* Read replacement string up through ')'.  Put contents of
           parentheses in objstr[].
        */
        for (objlen = 0; objlen < sizeof(objstr)-1; ++objlen) {
            chr = getc(sklfile);
            if (chr == EOF) break;
            if (chr == ')') break;
            objstr[objlen] = chr;
        }
        objstr[objlen] = '\0';

        if (chr != ')') {
            /* Not valid replacement sequence */
            unsigned int i;
            line[slen++] = escape;
            line[slen++] = chr;
            for (i = 0; i < objlen; ++i)
                line[slen++] = objstr[i];
            if (chr == EOF)
                break;
            continue;
        }

        typstr[0] = '\0';           /* Get typ of data */
        sscanf(objstr, "%s", typstr);

        otyp = interpretObjType(typstr);

        switch (objClass(otyp)) {
        case OBJTYP_ICOLOR: {
            int icolmin, icolmax;
            char formstr[MAX_OBJ_BUF];
            int n_odata;

            n_odata = sscanf(objstr, "%*s%s%d%d", formstr, &icolmin, &icolmax);

            if (n_odata == 3) {
                SAVE_BIN(slen, line);
                skl[nskl] = save_icol_data(otyp, formstr, icolmin, icolmax);
                if (skl[nskl] != NULL)
                    ++nskl;
            } else if (n_odata == EOF) {
                /* No arguments specified.  Use defaults */
                SAVE_BIN(slen, line);
                skl[nskl] = save_icol_data(otyp, "%d", 0, 255);
                if (skl[nskl] != NULL)
                    ++nskl;
            } else
                addImpostorReplacementSeq(line, slen, objstr, objlen, &slen);
        } break;
        case OBJTYP_FCOLOR: {
            double fcolmin, fcolmax;
            char formstr[MAX_OBJ_BUF];
            int n_odata;

            n_odata = sscanf(objstr, "%*s%s%lf%lf", formstr,
                             &fcolmin, &fcolmax);

            if (n_odata == 3) {
                SAVE_BIN(slen, line);
                skl[nskl] = save_fcol_data(otyp, formstr, fcolmin, fcolmax);
                if (skl[nskl] != NULL)
                    ++nskl;
            } else if (n_odata == EOF) {
                /* No arguments specified.  Use defaults */
                SAVE_BIN(slen, line);
                skl[nskl] = save_fcol_data(otyp, "%f", 0.0, 1.0);
                if (skl[nskl] != NULL)
                    ++nskl;
            } else
                addImpostorReplacementSeq(line, slen, objstr, objlen, &slen);
        } break;

        case OBJTYP_INT: {
            char formstr[MAX_OBJ_BUF];
            int const n_odata = sscanf(objstr, "%*s%s", formstr);

            if (n_odata == 1) {
                SAVE_BIN(slen, line);
                skl[nskl] = save_i_data(otyp, formstr);
                if (skl[nskl] != NULL)
                    ++nskl;
            } else if (n_odata == EOF) {
                /* No arguments specified.  Use defaults */
                SAVE_BIN(slen, line);
                skl[nskl] = save_i_data(otyp, "%d");
                if (skl[nskl] != NULL)
                    ++nskl;
            } else
                addImpostorReplacementSeq(line, slen, objstr, objlen, &slen);
        } break;
        case OBJTYP_BDATA:
            addImpostorReplacementSeq(line, slen, objstr, objlen, &slen);
        }
    } /* EOF of skeleton file */

    if (slen >= 1 && line[slen-1] == '\n')
        /* Drop finishing newline character */
        --slen;

    SAVE_BIN(slen, line);  /* Save whatever is left */

    *nsklP = nskl;

    fclose(sklfile);
    return 0;
}



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

{register int col;
 register pixel* xP;
 pixel* pixelrow;
 pixval maxval,red,green,blue;
 double dmaxval;
 int argn, rows, cols, format, row;
 unsigned int head_nskl,body_nskl,tail_nskl;
 SKL_OBJ *head_skl[MAX_SKL_HEAD_OBJ];
 SKL_OBJ *body_skl[MAX_SKL_BODY_OBJ];
 SKL_OBJ *tail_skl[MAX_SKL_TAIL_OBJ];
 FILE *ifp;
 const char *usage = "bodyskl [ -hd headskl ] [ -tl tailskl ] [pnmfile]";

 ppm_init( &argc, argv );

 argn = 1;
 if (argn == argc)
   pm_usage( usage );
                          /* Read body skeleton file */
 if (read_skeleton (argv[argn],sizeof (body_skl)/sizeof (SKL_OBJ *),
                    &body_nskl,body_skl) < 0)
   pm_usage ( usage );
 ++argn;

 head_nskl = tail_nskl = 0;

 while ( argn < argc && argv[argn][0] == '-' && argv[argn][1] != '\0')
 {
   if ( pm_keymatch ( argv[argn], "-hd", 1) && argn+1 < argc )
   {
     argn++;           /* Read header skeleton */
     if (read_skeleton (argv[argn],sizeof (head_skl)/sizeof (SKL_OBJ *),
                        &head_nskl,head_skl) < 0)
       pm_usage ( usage );
   }
   else if ( pm_keymatch ( argv[argn], "-tl", 1) && argn+1 < argc )
   {
     argn++;           /* Read tail skeleton */
     if (read_skeleton (argv[argn],sizeof (tail_skl)/sizeof (SKL_OBJ *),
                        &tail_nskl,tail_skl) < 0)
       pm_usage ( usage );
   }
   else
   {
     pm_usage ( usage );
   }
   argn++;
 }

 if ( argn != argc )
 {
   ifp = pm_openr( argv[argn] );
   ++argn;
 }
 else 
 {
   ifp = stdin;
 }

 if ( argn != argc )
   pm_usage( usage );

 ppm_readppminit( ifp, &cols, &rows, &maxval, &format );
 pixelrow = ppm_allocrow( cols );
 dmaxval = (double)maxval;

 if (head_nskl > 0)    /* Write header */
   write_txt (stdout,head_nskl,head_skl,cols,rows,0,0,0.0,0.0,0.0);

 for ( row = 0; row < rows; ++row )
 {
   ppm_readppmrow( ifp, pixelrow, cols, maxval, format );

   for ( col = 0, xP = pixelrow; col < cols; ++col, ++xP )
   {
     red = PPM_GETR( *xP );
     green = PPM_GETG( *xP );
     blue = PPM_GETB( *xP );
     write_txt (stdout,body_nskl,body_skl,cols,rows,col,row,
                red/dmaxval,green/dmaxval,blue/dmaxval);
   }
 }

 if (tail_nskl > 0)    /* Write trailer */
   write_txt (stdout,tail_nskl,tail_skl,cols,rows,0,0,0.0,0.0,0.0);

 pm_close( ifp );

 exit( 0 );
}