Tricks of the DOOM Programming Gurus/Tricks_of_the_Doom_Programming_Gurus.iso/bonus/linux/dm2ppm/raw2ppm.c

C/C++ Source or Header | 1994-06-24 | 5.1 KB | 190 lines

/* This module converts the DOOM raw image format to PPM image format

    (PPM, mainly because I know its format)

*/

#include    <stdio.h>
#include    <assert.h>
#include    "doomdefs.h"
#include    "directory.h"


struct raw_header {
    two_byte width;            /* Picture width */
    two_byte height;        /* Picture height */
    two_byte l_offset;        /* Left offset from center (unused?) */
    two_byte t_offset;        /* Top offset from center (unused?) */
    };

struct color {
    unsigned char red;
    unsigned char green;
    unsigned char blue;
    } colormap[256];

/* The background color for the pictures */
struct color cyan = { 0, 255, 255 };

int load_colormap(int fd) {
    struct dir_entry entry;

    /* Set the fd to the start of the directory entries */
    if ( set_directory(fd) < 0 )
        return(-1);

    /* Now cycle through the entries, looking for PLAYMAP */
    if ( get_entry(fd, "PLAYPAL", &entry) < 0 )
        return(-1);

    /* Go to the entry and retrieve the first colormap (colormap 0) */
    if ( lseek(fd, entry.res_start, SEEK_SET) < 0 )
        return(-1);
    if (read(fd, (char *)&colormap, sizeof(colormap)) != sizeof(colormap))
        return(-1);

    return(0);
}

int convert_rawpic(int fd, char *name)
{
    struct dir_entry entry;
    struct raw_header header;
    struct color *matrix;
    four_byte *columns;
    unsigned char post_row, num_pixels, pixel;
    char outfile[BUFSIZ];
    FILE *output;
    int i, j, l, index;

    /* Load the default colormap first */
    if ( load_colormap(fd) < 0 ) {
        fprintf(stderr, "Couldn't load color map from doom.wad\n");
        return(-1);
    }

    /* Set the fd to the start of the directory entries */
    if ( set_directory(fd) < 0 ) {
        fprintf(stderr, "Can't find start of directories.\n");
        return(-1);
    }

    /* Now cycle through the entries, looking for the picture  */
    if ( get_entry(fd, name, &entry) < 0 ) {
        fprintf(stderr, "Couldn't find directory entry for %s\n", name);
        return(-1);
    }

    /* Go to the entry and retrieve the picture */
    if ( lseek(fd, entry.res_start, SEEK_SET) < 0 ) {
        perror("lseek()");
        return(-1);
    }
    if (read(fd, (char *)&header, sizeof(header)) != sizeof(header)) {
        perror("header read error");
        return(-1);
    }
    /* Print out the header for now */
    printf("Picture size: %dx%d  (left offset=%d, top offset=%d)\n",
        header.width, header.height, header.l_offset, header.t_offset);

    /* Allocate memory for the picture */
    if ( (matrix=(struct color *)malloc(
        sizeof(struct color)*(header.width*header.height))) == NULL ) {
        perror("malloc(matrix)");
        return(-1);
    }
    if ( (columns=(four_byte *)malloc(header.width*4)) == NULL ) {
        perror("malloc(columns)");
        return(-1);
    }

    /* Set the default color to cyan */
    for ( i=0; i<header.height; ++i )
        for ( j=0; j<header.width; ++j )
            matrix[(i*header.width)+j] = cyan;

    /* Convert the raw picture format into the pixel matrix */
    /* Get all the columns pointers */
    if ( read(fd, (char *)columns, header.width*4) != (header.width*4) ) {
        perror("read(columns");
        return(-1);
    }
    /* I tried using the offsets in the header, but they didn't seem
       to be relevant.  Thus, I ignore them.
     */
    for ( i=0; i<header.width; ++i ) {
        /* Each column is stored as a series of posts */
        if ( lseek(fd, entry.res_start+columns[i], SEEK_SET) < 0 ) {
            perror("lseek(columns)");
            return(-1);
        }
        for ( ; ; ) {
            /* The first byte is the starting row of the post */
            if ( read(fd, &post_row, 1) != 1 ) {
                perror("read()");
                return(-1);
            }
            if ( post_row == 255 )  /* End of column marker */
                break;
            /* The second byte is the number of pixels in the post */
            if ( read(fd, &num_pixels, 1) != 1 ) {
                perror("read()");
                return(-1);
            }
            /* Skip first and last pixel bytes */
            (void) read(fd, &pixel, 1);
            for ( j=0; j<num_pixels; ++j ) {
                if ( read(fd, &pixel, 1) != 1 ) {
                    perror("read()");
                    return(-1);
                }
                index=((post_row*header.width)+i);
                assert(index > 0);
                matrix[index] = colormap[pixel];
                ++post_row;
            }
            (void) read(fd, &pixel, 1);
        }
    }

    /* Make sure we can write the output file */
    sprintf(outfile, "%s.ppm", name);
    if ( (output=fopen(outfile, "w")) == NULL ) {
        fprintf(stderr, "Can't open %s for writing.\n", outfile);
        return(-1);
    }
    /* Write the output file */
    fprintf(output, "P3\n");    /* PPM Magic cookie */
    fprintf(output, "# %s\n", outfile);
    fprintf(output, "%d %d\n", header.width, header.height);
    fprintf(output, "255\n");    /* The maximum color value */
    /* Now the matrix itself */
    for ( i=0; i<header.height; ++i ) {
        fprintf(output, "# row %d\n", i);
        for ( j=0, l=0; j<header.width; ++j ) {
            index = ((i*header.width)+j);
            sprintf(outfile, "%d %d %d  ", matrix[index].red,
                matrix[index].green, matrix[index].blue);

            /* The line can be no longer than 70 chars */
            l += strlen(outfile);
            if ( l > 70 ) {
                fprintf(output, "\n");
                l = strlen(outfile);
            }
            fprintf(output, "%s", outfile);
        }
        fprintf(output, "\n");
    }
    fclose(output);

    /* Free malloc()'d data here.  It is not freed on errors */
    (void) free(matrix);
    (void) free(columns);

    /* Done! */
    return(0);
}