/* pjtoppm.c - convert an HP PainJetXL image to a portable pixmap file

**

** Copyright (C) 1990 by Christos Zoulas (christos@ee.cornell.edu)

**

** 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 "ppm.h"

#include "mallocvar.h"

static char usage[] =  "[paintjetfile]";

static int egetc ARGS((FILE *fp));

static int

egetc(fp)

    FILE *fp;

{

    int c;

    if ((c = fgetc(fp)) == -1)

        pm_error("unexpected end of file");

    return(c);

}

int

main(argc, argv)

    int argc;

    char *argv[];

{

    int cmd, val;

    char buffer[BUFSIZ];

    int planes = 3, rows = -1, cols = -1;

    int r = 0, c = 0, p = 0, i;

    unsigned char **image = NULL;

    int *imlen;

    FILE *fp = stdin;

    int mode;

    int argn;

    unsigned char bf[3];

    pixel *pixrow;

    ppm_init(&argc, argv);

    argn = 1;

    if (argn != argc)

        fp = pm_openr(argv[argn++]);

    else

        fp = stdin;

    if (argn != argc)

        pm_usage(usage);

    while ((c = fgetc(fp)) != -1) {

        if (c != '\033')

            continue;

        switch (c = egetc(fp)) {

        case 'E':   /* reset */

            break;

        case '*':

            cmd = egetc(fp);

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

                if (!isdigit(c = egetc(fp)) && c != '+' && c != '-')

                    break;

                buffer[i] = c;

            }

            if (i != 0) {

                buffer[i] = '\0';

                if (sscanf(buffer, "%d", &val) != 1) 

                    pm_error("bad value `%s' at <ESC>*%c%c", buffer, cmd, c);

            }

            else

                val = -1;

            switch (cmd) {

            case 't':

                switch (c) {

                case 'J':   /* render */

                    break;

                case 'K':   /* back scale */

                    break;

                case 'I':   /* gamma */

                    break;

                case 'R':

                    break;  /* set resolution */

                default:

                    pm_message("uninmplemented <ESC>*%c%d%c", cmd, val, c);

                    break;

                }

                break;

            case 'r':

                switch (c) {

                case 'S':   /* width */

                    cols = val;

                    break;

                case 'T':   /* height */

                    rows = val;

                    break;

                case 'U':   /* planes */

                    planes = val;

                    if (planes != 3) 

                        pm_error("can handle only 3 plane files");

                    break;

                case 'A':   /* begin raster */

                    break;

                case 'B':

                case 'C':   /* end raster */

                    break;

                case 'V':

                    break;  /* set deci height */

                case 'H':

                    break;  /* set deci width */

                default:

                    pm_message("uninmplemented <ESC>*%c%d%c", cmd, val, c);

                    break;

                }

                break;

            case 'b':

                switch (c) {

                case 'M':   /* transmission mode */

                    if (val != 0 && val != 1)

                        pm_error("unimplemented trasmission mode %d", val);

                    mode = val;

                    break;

                case 'V':   /* send plane */

                case 'W':   /* send last plane */

                    if (rows == -1 || r >= rows || image == NULL) {

                        if (rows == -1 || r >= rows) {

                            overflow_add(rows, 100);

                            rows += 100;

                        }

                        if (image == NULL) {

                            image = (unsigned char **)

                                malloc3(rows , planes , sizeof(unsigned char *));

                            imlen = (int *) malloc3(rows , planes,  sizeof(int));

                        }

                        else {

                            overflow2(rows,planes);

                            image = (unsigned char **)

                                realloc2(image, rows * planes,

                                    sizeof(unsigned char *));

                            imlen = (int *) realloc2(imlen, rows * planes, sizeof(int));                        }

                    }

                    if (image == NULL || imlen == NULL)

                        pm_error("out of memory");

                    if (p == planes) 

                        pm_error("too many planes");

                    cols = cols > val ? cols : val;

                    imlen[r * planes + p] = val;

                    MALLOCARRAY(image[r * planes + p], val);

                    if (image[r * planes + p] == NULL) 

                        pm_error("out of memory");

                    if (fread(image[r * planes + p], 1, val, fp) != val) 

                        pm_error("short data");

                    if (c == 'V')

                        p++;

                    else {

                        p = 0;

                        r++;

                    }

                    break;

                default:

                    pm_message("uninmplemented <ESC>*%c%d%c", cmd, val, c);

                    break;

                }

                break;

            case 'p': /* Position */

                if (p != 0) 

                    pm_error("changed position in the middle of "

                             "transferring planes");

                switch (c) {

                case 'X':

                    pm_message("can only position in y");

                    break;

                case 'Y':

                    if (buffer[0] == '+')

                        val = r + val;

                    if (buffer[0] == '-')

                        val = r - val;

                    for (; val > r; r++) 

                        for (p = 0; p < 3; p++) {

                            imlen[r * planes + p] = 0;

                            image[r * planes + p] = NULL;

                        }

                    r = val;

                    break;

                default:

                    pm_message("uninmplemented <ESC>*%c%d%c", cmd, val, c);

                    break;

                }

            default:

                pm_message("uninmplemented <ESC>*%c%d%c", cmd, val, c);

                break;

            }

        }

    }

    pm_close(fp);

    rows = r;

    if (mode == 1) {

        unsigned char *buf;

        int newcols = 0;

        newcols = 10240; /* It could not be larger that that! */

        cols = 0;

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

            if (image[r * planes] == NULL)

                continue;

            for (p = 0; p < planes; p++) {

                MALLOCARRAY(buf, newcols);

                if (buf == NULL) 

                    pm_error("out of memory");

                for (i = 0, c = 0; c < imlen[p + r * planes]; c += 2)

                    for (cmd = image[p + r * planes][c],

                             val = image[p + r * planes][c+1]; 

                         cmd >= 0 && i < newcols; cmd--, i++) {

                        buf[i] = val;

                        overflow_add(i, 1);

                    }

                cols = cols > i ? cols : i;

                free(image[p + r * planes]);

                /* 

                 * This is less than what we have so it realloc should 

                 * not return null. Even if it does, tough! We will

                 * lose a line, and probably die on the next line anyway

                 */

                image[p + r * planes] = (unsigned char *) realloc(buf, i);

            }

        }

        overflow2(cols, 8);

        cols *= 8;

    }

    ppm_writeppminit(stdout, cols, rows, (pixval) 255, 0);

    pixrow = ppm_allocrow(cols);

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

        if (image[r * planes] == NULL) {

            for (c = 0; c < cols; c++)

                PPM_ASSIGN(pixrow[c], 0, 0, 0);

            continue;

        }

        for (cmd = 0, c = 0; c < cols; c += 8, cmd++) 

            for (i = 0; i < 8 && c + i < cols; i++) {

                for (p = 0; p < planes; p++) 

                    if (mode == 0 && cmd >= imlen[r * planes + p])

                        bf[p] = 0;

                    else

                        bf[p] = (image[r * planes + p][cmd] & 

                                 (1 << (7 - i))) ? 255 : 0;

                PPM_ASSIGN(pixrow[c + i], bf[0], bf[1], bf[2]);

            }

        ppm_writeppmrow(stdout, pixrow, cols, (pixval) 255, 0);

    }

    pm_close(stdout);

    exit(0);

}