/* infotopam: A program to convert Amiga Info icon files to PAM files
* Copyright (C) 2004 Richard Griswold - griswold@acm.org
*
* Thanks to the following people on comp.sys.amiga.programmer for tips
* and pointers on decoding the info file format:
*
* Ben Hutchings
* Thomas Richter
* Kjetil Svalastog Matheussen
* Anders Melchiorsen
* Dirk Stoecker
* Ronald V.D.
*
* The format of the Amiga info file is as follows:
*
* DiskObject header (78 bytes)
* Optional DrawerData header (56 bytes)
* First icon header (20 bytes)
* First icon data
* Second icon header (20 bytes)
* Second icon data
*
* The DiskObject header contains, among other things, the magic number
* (0xE310), the object width and height (inside the embedded Gadget header),
* and the version.
*
* Each icon header contains the icon width and height, which can be smaller
* than the object width and height, and the number of bit-planes.
*
* The icon data has the following format:
*
* BIT-PLANE planes, each with HEIGHT rows of (WIDTH +15) / 16 * 2 bytes
* length.
*
* So if you have a 9x3x2 icon, the icon data will look like this:
*
* aaaa aaaa a000 0000
* aaaa aaaa a000 0000
* aaaa aaaa a000 0000
* bbbb bbbb b000 0000
* bbbb bbbb b000 0000
* bbbb bbbb b000 0000
*
* Where 'a' is a bit for the first bit-plane, 'b' is a bit for the second
* bit-plane, and '0' is padding. Thanks again to Ben Hutchings for his
* very helpful post!
*
* This program uses code from "sidplay" and an older "infotoxpm" program I
* wrote, both of which are released under GPL.
*
*-------------------------------------------------------------------------
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "pm_c_util.h"
#include "pam.h"
#include "shhopt.h"
#include "mallocvar.h"
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* Struct to hold miscellaneous icon information */
typedef struct IconInfo_ {
const char *name; /* Icon file name */
FILE *fp; /* Input file pointer */
bool forceColor; /* Convert 1 bitplane icon to color icon */
unsigned int numColors; /* Number of colors to override */
bool selected; /* Converting selected (second) icon */
bool drawerData; /* Icon has drawer data */
unsigned int version; /* Icon version */
unsigned int width; /* Width in pixels */
unsigned int height; /* Height in pixels */
unsigned int depth; /* Bits of color per pixel */
pixel colors[4]; /* Colors to use for converted icons */
unsigned char *icon; /* Completed icon */
} IconInfo;
/* Header for each icon image */
typedef struct IconHeader_ { /* 20 bytes */
unsigned char pad0[4]; /* Padding (always seems to be zero) */
unsigned char iconWidth[2]; /* Width (usually equal to Gadget width) */
unsigned char iconHeight[2];
/* Height (usually equal to Gadget height -1) */
unsigned char bpp[2]; /* Bits per pixel */
unsigned char pad1[10]; /* ??? */
} IconHeader;
/*
* Gadget and DiskObject structs come from the libsidplay 1.36.57 info_.h file
* http://www.geocities.com/SiliconValley/Lakes/5147/sidplay/linux.html
*/
typedef struct DiskObject_ { /* 78 bytes (including Gadget struct) */
unsigned char magic[2]; /* Magic number at the start of the file */
unsigned char version[2]; /* Object version number */
unsigned char gadget[44]; /* Copy of in memory gadget (44 by */
unsigned char type; /* ??? */
unsigned char pad; /* Pad it out to the next word boundary */
unsigned char pDefaultTool[4]; /* Pointer to default tool */
unsigned char ppToolTypes[4]; /* Pointer pointer to tool types */
unsigned char currentX[4]; /* Current X position (?) */
unsigned char currentY[4]; /* Current Y position (?) */
unsigned char pDrawerData[4]; /* Pointer to drawer data */
unsigned char pToolWindow[4]; /* Ptr to tool window - only for tools */
unsigned char stackSize[4]; /* Stack size - only for tools */
} DiskObject;
static void
parseCommandLine( int argc,
char * argv[],
IconInfo * const infoP ) {
unsigned int numColorArgs, /* Number of arguments for overriding colors */
colorIdx, /* Color index */
i; /* Argument index */
const char * const colors[4] = {
/* Pixel colors based on original Amiga colors */
"#0055AA", /* Blue 0, 85, 170 */
"#FFFFFF", /* White 255, 255, 255 */
"#000020", /* Black 0, 0, 32 */
"#FF8A00" /* Orange 255, 138, 0 */
};
/* Option entry variables */
optEntry *option_def;
optStruct3 opt;
unsigned int option_def_index;
unsigned int numColorsSpec, forceColorSpec, selectedSpec;
MALLOCARRAY_NOFAIL(option_def, 100);
/* Set command line options */
option_def_index = 0; /* Incremented by OPTENT3 */
OPTENT3(0, "forcecolor", OPT_FLAG, NULL, &forceColorSpec, 0);
OPTENT3(0, "numcolors", OPT_UINT, &infoP->numColors, &numColorsSpec, 0);
OPTENT3(0, "selected", OPT_FLAG, NULL, &selectedSpec, 0);
/* Initialize the iconInfo struct */
infoP->name = NULL;
infoP->fp = NULL;
infoP->drawerData = FALSE;
infoP->version = 0;
infoP->width = 0;
infoP->height = 0;
infoP->depth = 0;
infoP->icon = NULL;
for ( colorIdx = 0; colorIdx < 4; colorIdx++ )
infoP->colors[colorIdx] =
ppm_parsecolor( (char*) colors[colorIdx], 0xFF );
/* Initialize option structure */
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* No short (old-fashioned) options */
opt.allowNegNum = FALSE; /* No negative number parameters */
/* Parse the command line */
pm_optParseOptions3( &argc, argv, opt, sizeof( opt ), 0 );
infoP->forceColor = forceColorSpec;
infoP->selected = selectedSpec;
if (!numColorsSpec)
infoP->numColors = 0;
/* Get colors and file name */
numColorArgs = infoP->numColors * 2;
if ( ( argc - 1 != numColorArgs ) && ( argc - 1 != numColorArgs + 1 ) ) {
pm_error( "Wrong number of arguments for number of colors. "
"For %u colors, you need %u color arguments, "
"with possibly one more argument for the input file name.",
infoP->numColors, numColorArgs );
}
/* Convert color arguments */
for ( i = 1; i < numColorArgs; i += 2 ) {
char * endptr; /* End pointer for strtol() */
unsigned int colorIdx;
/* Get color index from argument */
colorIdx = strtoul( argv[i], &endptr, 0 );
if ( *endptr != '\0' ) {
pm_error( "'%s' is not a valid color index", argv[i] );
}
/* Check color index range (current 0 to 3) */
if ( ( colorIdx < 0 ) || ( colorIdx > 3 ) ) {
pm_error( "%u is not a valid color index (minimum 0, maximum 3)",
colorIdx );
}
/* Convert the color for this color index */
infoP->colors[colorIdx] = ppm_parsecolor( argv[i+1], 0xFF );
}
/* Set file name */
if ( i > argc-1 )
infoP->name = "-"; /* Read from standard input */
else
infoP->name = argv[i];
}
static void
getDiskObject( IconInfo * const infoP ) {
/*-------------------------------------------------------------------------
* Get fields from disk object portion of info file
*-------------------------------------------------------------------------*/
DiskObject dobj; /* Disk object structure */
size_t bytesRead;
/* Read the disk object header */
bytesRead = fread( &dobj, 1, sizeof(dobj), infoP->fp );
if (ferror(infoP->fp))
pm_error("Cannot read disk object header for file '%s'. "
"fread() errno = %d (%s)",
infoP->name, errno, strerror(errno));
else if (bytesRead != sizeof(dobj))
pm_error("Cannot read entire disk object header for file '%s'. "
"Only read 0x%X of 0x%X bytes",
infoP->name, (unsigned)bytesRead, (unsigned)sizeof(dobj));
/* Check magic number */
if ((dobj.magic[0] != 0xE3) && (dobj.magic[1] != 0x10))
pm_error("Wrong magic number for file '%s'. "
"Expected 0xE310, but got 0x%X%X",
infoP->name, dobj.magic[0], dobj.magic[1]);
/* Set version info and have drawer data flag */
infoP->version = (dobj.version[0] << 8) +
(dobj.version[1] );
infoP->drawerData = (dobj.pDrawerData[0] << 24) +
(dobj.pDrawerData[1] << 16) +
(dobj.pDrawerData[2] << 8) +
(dobj.pDrawerData[3] ) ? TRUE : FALSE;
}
static void
getIconHeader(IconInfo * const infoP) {
/*-------------------------------------------------------------------------
* Get fields from icon header portion of info file
*-------------------------------------------------------------------------*/
IconHeader ihead; /* Icon header structure */
size_t bytesRead;
/* Read icon header */
bytesRead = fread(&ihead, 1, sizeof(ihead), infoP->fp);
if (ferror(infoP->fp))
pm_error("Cannot read icon header for file '%s'. "
"fread() errno = %d (%s)",
infoP->name, errno, strerror(errno));
else if (bytesRead != sizeof(ihead))
pm_error("Cannot read the entire icon header for file '%s'. "
"Only read 0x%X of 0x%X bytes",
infoP->name, (unsigned)bytesRead, (unsigned)sizeof(ihead));
/* Get icon width, heigh, and bitplanes */
infoP->width = (ihead.iconWidth[0] << 8) + ihead.iconWidth[1];
infoP->height = (ihead.iconHeight[0] << 8) + ihead.iconHeight[1];
infoP->depth = (ihead.bpp[0] << 8) + ihead.bpp[1];
/* Check number of bit planes */
if ((infoP->depth > 2) || (infoP->depth < 1))
pm_error("We don't know how to interpret %u bitplanes file '%s'. ",
infoP->depth, infoP->name);
}
static void
addBitplane(unsigned char * const icon,
unsigned int const bpsize,
unsigned char * const buff) {
/*----------------------------------------------------------------------------
Add bitplane to existing icon image
-----------------------------------------------------------------------------*/
unsigned int i;
unsigned int j;
for (i = j = 0; i < bpsize; ++i, j += 8) {
icon[j+0] = (icon[j+0] << 1) | ((buff[i] >> 0) & 0x01);
icon[j+1] = (icon[j+1] << 1) | ((buff[i] >> 1) & 0x01);
icon[j+2] = (icon[j+2] << 1) | ((buff[i] >> 2) & 0x01);
icon[j+3] = (icon[j+3] << 1) | ((buff[i] >> 3) & 0x01);
icon[j+4] = (icon[j+4] << 1) | ((buff[i] >> 4) & 0x01);
icon[j+5] = (icon[j+5] << 1) | ((buff[i] >> 5) & 0x01);
icon[j+6] = (icon[j+6] << 1) | ((buff[i] >> 6) & 0x01);
icon[j+7] = (icon[j+7] << 1) | ((buff[i] >> 7) & 0x01);
}
}
static void
readIconData(FILE * const fileP,
unsigned int const width,
unsigned int const height,
unsigned int const depth,
unsigned char ** const iconP) {
/*-------------------------------------------------------------------------
* Read icon data from file
*-------------------------------------------------------------------------*/
int bitplane; /* Bitplane index */
unsigned char * buff; /* Buffer to hold bits for 1 bitplane */
unsigned char * icon;
unsigned int const bpsize = height * (((width + 15) / 16) * 2);
/* Bitplane size in bytes, with padding */
MALLOCARRAY(buff, bpsize);
if ( buff == NULL )
pm_error( "Cannot allocate memory to hold icon pixels" );
MALLOCARRAY(icon, bpsize * 8);
if (icon == NULL)
pm_error( "Cannot allocate memory to hold icon" );
/* Initialize to zero */
memset(buff, 0, bpsize);
memset(icon, 0, bpsize * 8);
/* Each bitplane is stored independently in the icon file. This
* loop reads one bitplane at a time into buff. Since fread() may
* not read all of the bitplane on the first call, the inner loop
* continues until all bytes are read. The buffer pointer, bp,
* points to the next byte in buff to fill in. When the inner
* loop is done, bp points to the end of buff.
*
* After reading in the entire bitplane, the second inner loop splits the
* eight pixels in each byte of the bitplane into eight separate bytes in
* the icon buffer. The existing contents of each byte in icon are left
* shifted by one to make room for the next bit.
*
* Each byte in the completed icon contains a value from 0 to
* 2^depth (0 to 1 for depth of 1 and 0 to 3 for a depth of 3).
* This is an index into the colors array in the info struct. */
for (bitplane = 0; bitplane < depth; ++bitplane) {
/* Read bitplane into buffer */
int toread; /* Number of bytes left to read */
unsigned char * buffp; /* Buffer point for reading data */
toread = bpsize; buffp = &buff[0];
while (toread > 0) {
size_t bytesRead;
bytesRead = fread(buffp, 1, toread, fileP);
if (ferror(fileP))
pm_error("Cannot read from file info file. "
"fread() errno = %d (%s)",
errno, strerror(errno));
else if (bytesRead == 0)
pm_error("Premature end-of-file. "
"Still have 0x%X bytes to read",
toread );
toread -= bytesRead;
buffp += bytesRead;
}
addBitplane(icon, bpsize, buff);
}
*iconP = icon;
free(buff);
}
static void
writeIconData( IconInfo * const infoP,
struct pam * const pamP ) {
/*-------------------------------------------------------------------------
* Write icon data to file
*-------------------------------------------------------------------------*/
unsigned int const bpwidth = ( ( infoP->width + 15 ) / 16 ) * 16;
/* Bitplane width; Width of each row in icon, including padding */
tuple * row; /* Output row */
/* Allocate row */
row = pnm_allocpamrow( pamP );
/* Write icon image to output file */
/* Put if check outside for loop to reduce number of times check is made */
if ( infoP->depth == 1 ) {
if ( infoP->forceColor ) {
/* Convert 1 bitplane icon into color PAM */
unsigned int i;
for ( i = 0; i < infoP->height; ++i ) {
unsigned int j;
for ( j = 0; j < infoP->width; ++j ) {
/* 1 is black and 0 is white */
unsigned int colorIdx =
infoP->icon[ i * bpwidth + j ] ? 2 : 1;
row[j][PAM_RED_PLANE] =
PPM_GETR( infoP->colors[colorIdx] );
row[j][PAM_GRN_PLANE] =
PPM_GETG( infoP->colors[colorIdx] );
row[j][PAM_BLU_PLANE] =
PPM_GETB( infoP->colors[colorIdx] );
}
pnm_writepamrow( pamP, row );
}
} else {
/* Convert 1 bitplane icon into bitmap PAM */
unsigned int i;
for ( i = 0; i < infoP->height; ++i ) {
unsigned int j;
for ( j = 0; j < infoP->width; j++ ) {
/* 1 is black and 0 is white */
row[j][0] = infoP->icon[ i * bpwidth + j ] ? 0 : 1;
}
pnm_writepamrow( pamP, row );
}
}
} else {
/* Convert color icon into color PAM */
unsigned int i;
for ( i = 0; i < infoP->height; ++i ) {
unsigned int j;
for ( j = 0; j < infoP->width; ++j ) {
unsigned int const colorIdx = infoP->icon[ i * bpwidth + j ];
row[j][PAM_RED_PLANE] = PPM_GETR( infoP->colors[colorIdx] );
row[j][PAM_GRN_PLANE] = PPM_GETG( infoP->colors[colorIdx] );
row[j][PAM_BLU_PLANE] = PPM_GETB( infoP->colors[colorIdx] );
}
pnm_writepamrow( pamP, row );
}
}
/* Clean up allocated memory */
pnm_freepamrow( row );
}
int
main( int argc,
char *argv[] ) {
IconInfo info; /* Miscellaneous icon information */
struct pam pam; /* PAM header */
int skip; /* Bytes to skip to read next icon header */
/* Init PNM library */
pnm_init( &argc, argv );
/* Parse command line arguments */
parseCommandLine( argc, argv, &info );
/* Open input file */
info.fp = pm_openr( info.name );
/* Read disk object header */
getDiskObject( &info );
/* Skip drawer data, if any */
if ( info.drawerData ) {
skip = 56; /* Draw data size */
if ( fseek( info.fp, skip, SEEK_CUR ) < 0 )
pm_error( "Cannot skip header information in file '%s'. "
"fseek() errno = %d (%s)",
info.name, errno, strerror( errno ) );
}
/* Get dimensions for first icon */
getIconHeader( &info );
/* Skip ahead to next header if converting second icon */
if ( info.selected ) {
skip = info.height * ( ( ( info.width + 15 ) / 16 ) * 2 ) * info.depth;
if ( fseek( info.fp, skip, SEEK_CUR ) < 0 )
pm_error( "Cannot skip to next icon in file '%s'. "
"fseek() errno = %d (%s)",
info.name, errno, strerror( errno ) );
/* Get dimensions for second icon */
getIconHeader( &info );
}
/* Read icon data */
readIconData( info.fp, info.width, info.height, info.depth, &info.icon );
/* Print icon info */
pm_message( "converting %s, version %d, %s icon: %d X %d X %d",
info.name, info.version, info.selected ? "second" : "first",
info.width, info.height, info.depth );
/* Write PAM header */
pam.size = sizeof( pam );
pam.len = PAM_STRUCT_SIZE( tuple_type );
pam.file = stdout;
pam.height = info.height;
pam.width = info.width;
pam.format = PAM_FORMAT;
if ( ( info.depth == 1 ) && ( info.forceColor == FALSE ) ) {
pam.depth = 1;
pam.maxval = 1;
strcpy( pam.tuple_type, "BLACKANDWHITE" );
} else {
pam.depth = 3;
pam.maxval = 0xFF;
strcpy( pam.tuple_type, "RGB" );
}
pnm_writepaminit( &pam );
/* Write icon data */
writeIconData( &info, &pam );
free( info.icon );
/* Close input file and return */
pm_close( pam.file );
pm_close( info.fp );
return 0;
}