---

libinfo.c

Go to the documentation of this file.

#include "libinfo.h"


/* XPM Transparency */
# ifdef LI_OUTPUT_XPM

int transparent = -1;

#endif

u8 mwb_palette[] = {
    149, 149, 149,
    0, 0, 0,
    255, 255, 255,
    59, 103, 162,
    123, 123, 123,
    175, 175, 175,
    170, 144, 124,
    255, 169, 151
};

/*************************************************************************
**                              USER INTERFACE                          **
*************************************************************************/


/*************************************************
**              LIReadDefIcon                 
*************************************************/
int LIReadDefIcon(char *filename)
{
    if((fileIcon = fopen(filename, "rb")) == NULL){
        LIErrorString = "Error opening input file";
        return -1;
    }

    if(ReadHeader() == -1)
        return -1;
    if(ReadIcon(LI_UNSELECTED) == -1)
        return -1;
    if(image2)
        if(ReadIcon(LI_SELECTED) == -1)
            return -1;

    fclose(fileIcon);
    return 0;
}

/*************************************************
**              LIReadNewIcon                 
*************************************************/
int LIReadNewIcon(char *filename)
{
    if((fileIcon = fopen(filename, "rb")) == NULL){
        LIErrorString = "Error opening input file";
        return -1;
    }

    if(ReadHeader() == -1)
        return -1;
    if(ReadIcon(LI_UNSELECTED) == -1)
        return -1;
    if(image2)
        if(ReadIcon(LI_SELECTED) == -1)
            return -1;
    if(tool)
        free(ReadString());
    if(StartTooltypes() == -1)
        return -1;
    if(ReadNewicon(LI_UNSELECTED, "IM1=") == -1)
        return -1;
    if(ReadNewicon(LI_SELECTED, "IM2=") == -1)
        return -1;

    fclose(fileIcon);
    return 0;
}


#ifdef LI_OUTPUT_XPM
/*************************************************
**              LISetXPMTransparency              
*************************************************/
int LISetXPMTransparency(int colour)
{
    if(colour >= LINumColours){
        LIErrorString = "Can't set colour transparency.";
        return -1;
    }
    transparent = colour;

    return 0;
}


/*************************************************
**                  LIWriteXPM              
*************************************************/
int LIWriteXPM(char *filename, int image)
{
    return WriteXPM(filename, LIWidth, LIHeight, LINumColours, LIPalette, image);
}

#endif
#ifdef LI_OUTPUT_PPM

/*************************************************
**                  LIWritePPM              
*************************************************/
int LIWritePPM(char *filename, int image)
{
    return WritePPM(filename, LIWidth, LIHeight, LINumColours, LIPalette, image);
}

#endif

/**************************************************
**                   LICleanUp                   
**************************************************/
void LICleanUp(void)
{
    free(LIPalette);
    free(LIBitmapSelected);
    free(LIBitmapUnselected);
}


/**************************************************
**                 LIGetVersion                 
**************************************************/
char *LIGetVersion(void)
{
    return LIBINFO_VERSION;
}



/**************************************************
**                    LIGetDate                   
**************************************************/
char *LIGetDate(void)
{
    return LIBINFO_DATE;
}


/**************************************************
**                 LIGetCopyright                 
**************************************************/
char *LIGetCopyright(void)
{
    return LIBINFO_COPYRIGHT;
}

/*************************************************************************
**                              INTERNAL STUFF                          **
*************************************************************************/

u16 Get16(u8 *p)
{
    return(*p * 256) + *(p+1);
}

u32 Get32(u8 *p)
{
    return((*p * 256 + *(p+1)) * 256 + *(p+2)) * 256 + *(p+3);
}

int Read8(u8 *buf, int len)
{
    len = fread(buf, 1, len, fileIcon);
    return len;
}

int ReadHeader()
{
    u8 header[0x4e];

    if(!Read8(header, sizeof header)){
        LIErrorString = "Unable to read header.";
        return -1;
    }
    magic = Get16(header);
    if(magic != 0xE310){
        LIErrorString = "Wrong magic number.";
        return -1;
    }
    version = Get16(header + 0x02);
    if(version != 1){
        LIErrorString = "Wrong version.";
        return -1;
    }
    type = Get16(header + 0x30);
    image1 = Get32(header + 0x16);
    if(!image1){
        LIErrorString = "Could not find image.";
        return -1;
    }
    image2 = Get32(header + 0x1A);
    tool = Get32(header + 0x32);
    if(Get32(header + 0x42)) {
        u8 drawer[0x38];
        if(!Read8(drawer, sizeof drawer)){
            LIErrorString = "Unable to read drawer.";
            return -1;
        }
    }
    return 0;
}

#ifdef LI_OUTPUT_PPM

int WritePPM(char *filename, int width, int height, int ncols, u8 *palette, int image)
{
    int     x, y;
    u8      *bitmap;
    FILE    *file;

    if(image == LI_UNSELECTED)
        bitmap = LIBitmapUnselected;
    else
        bitmap = LIBitmapSelected;

    if((file = fopen(filename, "w")) == NULL){
        LIErrorString = "Unable to create PPM file.";
        return -1;
    }
    fprintf(file, "P6 %d %d 255\n", width, height);
    for(y = 0; y < height; y++) {
        for(x = 0; x < width; x++) {
            u8 c = 3 * bitmap[x + y*width];
            putc(palette[c], file);
            putc(palette[c+1], file);
            putc(palette[c+2], file);
        }
    }
    if(fclose(file) != 0){
        LIErrorString = "Error closing PPM file.";
        return -1;
    }
    return 0;
}

#endif
#ifdef LI_OUTPUT_XPM

int WriteXPM(char *filename, int width, int height, int ncols, u8 *palette, int image)
{
    int     x, y;
    u8      *bitmap;
    FILE    *file;

    if(image == LI_UNSELECTED)
        bitmap = LIBitmapUnselected;
    else
        bitmap = LIBitmapSelected;

    if((file = fopen(filename, "w")) == NULL){
        LIErrorString = "Unable to create XPM file.";
        return -1;
    }
    fprintf(file, "/* XPM */\nstatic char * amigaicon_xpm[] = {\n"
        "\"%d %d %d 1\",\n", width, height, ncols);
    for(x = 0; x < ncols; x++)
        if (x == transparent)
            fprintf(file, "\"%c\tc None\",\n", 'A' + x);
        else
            fprintf(file, "\"%c\tc #%02x%02x%02x\",\n",
                'A' + x,
                palette[x * 3], palette[x * 3 + 1], palette[x * 3 + 2]);
    for(y = 0; y < height; y++) {
        fprintf(file, "%c", '"');
        for(x = 0; x < width; x++){
            putc('A' + bitmap[x + y*width], file);
        }
        if(y == height - 1)
            fprintf(file, "%s", "\"};");
        else
            fprintf(file, "%s", "\",\n");
    }
    if(fclose(file) != 0){
        LIErrorString = "Error closing XPM file.";
        return -1;
    }
    return 0;
}

#endif

int ReadIcon(int image)
{
    u8 header[0x14];
    u16 width, height, depth;
    u8 plane_pick, plane_onoff;
    u8 *row, *bitmap;
    int rwidth;
    int ib;

    if (!Read8(header, sizeof header)){
        LIErrorString = "Unable to read icon header.";
        return -1;
    }
    width = Get16(header + 0x04);
    height = Get16(header + 0x06);
    depth = Get16(header + 0x08);
    plane_pick = *(header + 0x0e);
    if(!plane_pick){
        LIErrorString = "Icon does not have any bitplanes.";
        return -1;
    }
    plane_onoff = *(header + 0x0f);
    rwidth = ((width + 15) / 16) * 2;
    row = malloc(rwidth);
    bitmap = malloc(width * height);
    memset(bitmap, 0, width * height);
    for(ib = 0; ib < depth; ib++) {
        int ix, iy;
        int oslib = 1 << ib;
        if(plane_pick & oslib) {
            for(iy = 0; iy < height; iy++) {
                if(!Read8(row, rwidth)){
                    LIErrorString = "Unable to read row.";
                    return -1;
                }
                for(ix = 0; ix < width; ix++)
                    if(row[ix/8] & (0x80 >> (ix & 0x7)))
                        bitmap[ix + iy * width] |= oslib;
            }
        }else if (plane_onoff & oslib){
            for(iy = 0; iy < height; iy++)
                for(ix = 0; ix < width; ix++)
                    bitmap[ix + iy * width] |= oslib;
        }
    }
    LIWidth = width;
    LIHeight = height;
    LINumColours = 8;
    LIPalette = mwb_palette;
    if(image == LI_UNSELECTED)
        LIBitmapUnselected = bitmap;
    else
        LIBitmapSelected = bitmap;

    free(row);
    return 0;
}

char *ReadString()
{
    u8 *buf;
    u8 lenbuf[4];
    u32 len;

    if(!Read8(lenbuf, sizeof lenbuf)){
        LIErrorString = "Unable to read string length.";
        return "-1";
    }
    len = Get32(lenbuf);
    buf = malloc(len + 1);
    buf[len] = '\0';
    if(len > 0)
        if(!Read8(buf, len)){
            LIErrorString = "Unable to read string.";
            return "-1";
        }
    return buf;
}

int StartTooltypes()
{
    u8 countbuf[4];

    if(!Read8(countbuf, sizeof countbuf)){
        LIErrorString = "Unable to read number of tooltypes.";
        return -1;
    }
    num_tooltypes = Get32(countbuf)/4 - 1;
    return 0;
}

u8 *GetTooltype(char *name)
{
    while (num_tooltypes > 0) {
        u8 *s = ReadString();
        num_tooltypes--;
        if(strncmp(s, name, strlen(name)) == 0){
            return s;
        }
        free(s);
    }
    return NULL;
}

u8 *DecompressNewicon(u8 *src, char *name, int len, int bits)
{
    u8 *s = src;
    u8 *data = malloc(len), *p = data;
    int bitmask = (1 << bits) - 1;
    int workbits, currentworkbit;

    readblock:              /* goto */
    workbits = 0;
    currentworkbit = 7;

    while(1){
        int runlength = 0;
        s8 c = (s8) *s++;
        if(c == 0){
            free(src);
            src = GetTooltype(name);
            if(!src){
                LIErrorString = "Ran out of tooltype data.";
                return "-1";
            }
            s = src + 4;
            goto readblock;
        }
        c -= 0x20;
        if(c <= 0){
            c -= 0x31;
            if(c <= 0){
                runlength = c + 0x80;
                c = 0;
            }
        }
        workbits |= c;
        while(runlength-- >= 0){
            while(currentworkbit - bits >= 0){
                currentworkbit -= bits;
                *p = (workbits >> currentworkbit) & bitmask;
                p++;
                len--;
                if(len == 0){
                    free(src);
                    return data;
                }
            }
            workbits <<= 7;
            currentworkbit += 7;
        }
    }
}

int ReadNewicon(int image, char *name)
{
    u8 *s, *palette, *bitmap;
    u8 transparent, width, height;
    u16 colors;
    int bits;

    s = GetTooltype(name);
    if(!s){
        LIErrorString = "NewIcon not found.";
        return -1;
    }
    if(strlen(s) < 4){
        LIErrorString = "NewIcon header too short.";
        return -1;
    }
    transparent = s[4] - 0x21;
    width = s[5] - 0x21;
    height = s[6] - 0x21;
    colors = ((s[7] - 0x21) << 6) | (s[8] - 0x21);
    if(width > 95 || height > 95){
        LIErrorString = "Illegal NewIcon size.";
        return -1;
    }
    if(colors > 256){
        LIErrorString = "Illegal NewIcon palette size.";
        return -1;
    }
    palette = DecompressNewicon(strdup(s + 9), name, colors * 3, 8);
    free(s);

    bits = 1;
    while((colors - 1) >> bits)
        bits++;
    bitmap = DecompressNewicon(strdup(""), name, width * height, bits);

    LIWidth = width;
    LIHeight = height;
    LINumColours = colors;
    LIPalette =  palette;
    if(image == LI_UNSELECTED)
        LIBitmapUnselected = bitmap;
    else
        LIBitmapSelected = bitmap;

    return 0;
}

---