/* ilbmtoppm.c - read an IFF ILBM file and produce a PPM

**

** Copyright (C) 1989 by Jef Poskanzer.

**

** 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.

**

** Modified by Mark Thompson on 10/4/90 to accommodate 24-bit IFF files

** as used by ASDG, NewTek, etc.

**

** Modified by Ingo Wilken (Ingo.Wilken@informatik.uni-oldenburg.de)

**  20/Jun/93:

**  - row-by-row operation

**  - better de-interleave algorithm

**  - colormap files

**  - direct color

**  04/Oct/93:

**  - multipalette capability (PCHG chunk)

**  - options -ignore, -isham, -isehb and -adjustcolors

**  22/May/94:

**  - minor change: check first for 24 planes, then for HAM

**  21/Sep/94:

**  - write mask plane to a file if -maskfile option used

**  - write colormap file

**  - added sliced HAM/dynamic HAM/dynamic Hires multipalette formats (SHAM, CTBL chunk)

**  - added color lookup tables (CLUT chunk)

**  - major rework of colormap/multipalette handling

**  - now uses numeric IFF IDs

**  24/Oct/94:

**  - transparentColor capability

**  - added RGBN/RGB8 image types

**  - 24-bit & direct color modified to n-bit deep ILBM

**  22/Feb/95:

**  - direct color (DCOL) reimplemented

**  29/Mar/95

**  - added IFF-PBM format

*/

#include <string.h>

#include "pm_c_util.h"

#include "mallocvar.h"

#include "intcode.h"

#include "ilbm.h"

#include "ppm.h"

typedef struct {

    int reg;            /* color register to change */

    pixval r, g, b;     /* new colors for register */

} PaletteChange;

typedef struct {

    pixel *color;

    int    ncolors;

    /* lookup tables */

    unsigned char *redlut;

    unsigned char *greenlut;

    unsigned char *bluelut;

    unsigned char *monolut;

    /* multipalette stuff */

    PaletteChange *mp_init;

    PaletteChange **mp_change;

    int mp_rows;                /* # of rows in change array */

    int mp_type;                /* see below, higher types preferred */

    int mp_flags;

    IFF_ID  mp_id;

} ColorMap;

#define HAS_COLORMAP(cmap)      ((cmap) && (cmap)->color)

#define HAS_COLORLUT(cmap)      ((cmap) && ((cmap)->redlut || (cmap)->greenlut || (cmap)->bluelut))

#define HAS_MONOLUT(cmap)       ((cmap) && (cmap)->monolut)

#define HAS_MULTIPALETTE(cmap)  (HAS_COLORMAP(cmap) && (cmap)->mp_type)

#define MP_TYPE_SHAM        1

#define MP_TYPE_CTBL        2

#define MP_TYPE_PCHG        3

#define MP_REG_IGNORE       -1

#define MP_REG_END          -2

#define MP_FLAGS_SKIPLACED   (1<<0)

#define FACTOR_4BIT     17      /* scale factor maxval 15 -> maxval 255 */

static short verbose = 0;

static short adjustcolors = 0;

static unsigned char *ilbmrow;

static pixel *pixelrow;

static FILE *maskfile = NULL;

static bit *maskrow = NULL;

static bool wrotemask;

static IFF_ID typeid;       /* ID_ILBM, ID_RGBN, ID_RGB8 */

static char *transpName = NULL;  /* -transparent option value */

static bool debug = FALSE;

static char *

ID2string(id)

    IFF_ID id;

{

    static char str[] = "abcd";

    str[0] = (char)(id >> 24 & 0xff);

    str[1] = (char)(id >> 16 & 0xff);

    str[2] = (char)(id >>  8 & 0xff);

    str[3] = (char)(id >>  0 & 0xff);

    return str;

}

/****************************************************************************

 Memory allocation

 ****************************************************************************/

static ColorMap *

alloc_cmap(void) {

    ColorMap * cmap;

    MALLOCVAR_NOFAIL(cmap);

    cmap->color     = NULL;

    cmap->ncolors   = 0;

    cmap->monolut   = NULL;

    cmap->redlut    = NULL;

    cmap->greenlut  = NULL;

    cmap->bluelut   = NULL;

    cmap->mp_init   = NULL;

    cmap->mp_change = NULL;

    cmap->mp_rows   = 0;

    cmap->mp_type   = 0;

    cmap->mp_flags  = 0;

    return cmap;

}

static rawtype *

alloc_rawrow(cols)

    int cols;

{

    rawtype *r;

    int i;

    MALLOCARRAY_NOFAIL(r, cols);

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

        r[i] = 0;

    return r;

}

/****************************************************************************

 Basic I/O functions

 ****************************************************************************/

static void

readerr(f, iffid)

    FILE *f;

    IFF_ID iffid;

{

    if( ferror(f) )

        pm_error("read error");

    else

        pm_error("premature EOF in %s chunk", ID2string(iffid));

}

static void

read_bytes(FILE *          const ifP,

           int             const bytes,

           unsigned char * const buffer,

           IFF_ID          const iffid,

           unsigned long * const counterP) {

    if (counterP) {

        if (*counterP < bytes)

            pm_error("insufficient data in %s chunk", ID2string(iffid));

        *counterP -= bytes;

    }

    if (fread(buffer, 1, bytes, ifP) != bytes)

        readerr(ifP, iffid);

}

static unsigned char

get_byte(ifP, iffid, counter)

    FILE* ifP;

    IFF_ID iffid;

    long *counter;

{

    int i;

    if( counter ) {

        if( *counter == 0 )

            pm_error("insufficient data in %s chunk", ID2string(iffid));

        --(*counter);

    }

    i = getc(ifP);

    if( i == EOF )

        readerr(ifP, iffid);

    return (unsigned char) i;

}

static long

get_big_long(FILE *          const ifP,

             IFF_ID          const iffid,

             unsigned long * const counterP) {

    long l;

    if (counterP) {

        if (*counterP < 4)

            pm_error("insufficient data in %s chunk", ID2string(iffid));

        *counterP -= 4;

    }

    if (pm_readbiglong(ifP, &l) == -1)

        readerr(ifP, iffid);

    return l;

}

static short

get_big_short(FILE *          const ifP,

              IFF_ID          const iffid,

              unsigned long * const counterP) {

    short s;

    if (counterP) {

        if (*counterP < 2)

            pm_error("insufficient data in %s chunk", ID2string(iffid));

        *counterP -= 2;

    }

    if (pm_readbigshort(ifP, &s) == -1)

        readerr(ifP, iffid);

    return s;

}

/****************************************************************************

 Chunk reader

 ****************************************************************************/

static void

chunk_end(FILE *        const ifP,

          IFF_ID        const iffid,

          unsigned long const chunksize) {

    if (chunksize > 0) {

        unsigned long remainingChunksize;

        pm_message("warning - %ld extraneous byte%s in %s chunk",

                    chunksize, (chunksize == 1 ? "" : "s"), ID2string(iffid));

        remainingChunksize = chunksize;  /* initial value */

        while (remainingChunksize > 0)

            get_byte(ifP, iffid, &remainingChunksize);

    }

}

static void

skip_chunk(FILE *        const ifP,

           IFF_ID        const iffid,

           unsigned long const chunksize) {

    unsigned long remainingChunksize;

    remainingChunksize = chunksize;  /* initial value */

    while (remainingChunksize > 0)

        get_byte(ifP, iffid, &remainingChunksize);

}

static void

display_chunk(FILE *        const ifP,

              IFF_ID        const iffid,

              unsigned long const chunksize) {

    int byte;

    unsigned long remainingChunksize;

    pm_message("contents of %s chunk:", ID2string(iffid));

    remainingChunksize = chunksize;  /* initial value */

    byte = '\0';

    while (remainingChunksize > 0) {

        byte = get_byte(ifP, iffid, &remainingChunksize);

        if (fputc(byte, stderr) == EOF)

            pm_error("write error");

    }

    if (byte != '\n')

        if (fputc('\n', stderr) == EOF)

            pm_error("write error");

}

static void

read_cmap(FILE *     const ifP,

          IFF_ID     const iffid,

          long       const chunksize,

          ColorMap * const cmap) {

    long colors;

    colors = chunksize / 3;

    if( colors == 0 ) {

        pm_error("warning - empty %s colormap", ID2string(iffid));

        skip_chunk(ifP, iffid, chunksize);

    } else {

        unsigned int i;

        if( cmap->color )               /* prefer CMAP-chunk over CMYK-chunk */

            ppm_freerow(cmap->color);

        cmap->color = ppm_allocrow(colors);

        cmap->ncolors = colors;

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

            int r, g, b;

            r = get_byte(ifP, iffid, &chunksize);

            g = get_byte(ifP, iffid, &chunksize);

            b = get_byte(ifP, iffid, &chunksize);

            PPM_ASSIGN(cmap->color[i], r, g, b);

        }

        chunk_end(ifP, iffid, chunksize);

    }

}

static void

read_cmyk(FILE *     const ifP,

          IFF_ID     const iffid,

          long       const chunksize,

          ColorMap * const cmap) {

    if( HAS_COLORMAP(cmap) ) {      /* prefer RGB color map */

        skip_chunk(ifP, iffid, chunksize);

    } else {

        long const colors = chunksize/4;

        if( colors == 0 ) {

            pm_error("warning - empty %s colormap", ID2string(iffid));

            skip_chunk(ifP, iffid, chunksize);

        } else {

            unsigned int i;

            cmap->color = ppm_allocrow(colors);

            cmap->ncolors = colors;

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

                int c, m, y, k;

                c = get_byte(ifP, iffid, &chunksize);

                m = get_byte(ifP, iffid, &chunksize);

                y = get_byte(ifP, iffid, &chunksize);

                k = get_byte(ifP, iffid, &chunksize);

                {

                    pixval const red = 

                        MAXCOLVAL - MIN(MAXCOLVAL,

                                        c*(MAXCOLVAL-k)/MAXCOLVAL+k); 

                    pixval const green = 

                        MAXCOLVAL - MIN(MAXCOLVAL,

                                        m*(MAXCOLVAL-k)/MAXCOLVAL+k);

                    pixval const blue = 

                        MAXCOLVAL - MIN(MAXCOLVAL,

                                        y*(MAXCOLVAL-k)/MAXCOLVAL+k);

                    PPM_ASSIGN(cmap->color[i], red, green, blue);

                }

            }

            chunk_end(ifP, iffid, chunksize);

        }

    }

}

static void

read_clut(FILE *        const ifP,

          IFF_ID        const iffid,

          unsigned long const chunksize,

          ColorMap *    const cmap) {

    if (chunksize != CLUTSize) {

        pm_message("invalid size for %s chunk - skipping it", 

                   ID2string(iffid));

        skip_chunk(ifP, iffid, chunksize);

    } else {

        long type;

        unsigned char * lut;

        unsigned long remainingChunksize;

        unsigned int i;

        type = get_big_long(ifP, iffid, &remainingChunksize);

        get_big_long(ifP, iffid, &remainingChunksize); /* skip reserved fld */

        MALLOCARRAY_NOFAIL(lut, 256);

        for( i = 0; i < 256; ++i )

            lut[i] = get_byte(ifP, iffid, &remainingChunksize);

        switch( type ) {

        case CLUT_MONO:

            cmap->monolut  = lut;

            break;

        case CLUT_RED:

            cmap->redlut   = lut;

            break;

        case CLUT_GREEN:

            cmap->greenlut = lut;

            break;

        case CLUT_BLUE:

            cmap->bluelut  = lut;

            break;

        default:

            pm_message("warning - %s type %ld not recognized",

                       ID2string(iffid), type);

            free(lut);

        }

    }

}

static void

warnNonsquarePixels(uint8_t const xAspect,

                    uint8_t const yAspect) {

    if (xAspect != yAspect) {

        const char * const baseMsg = "warning - non-square pixels";

        if (pm_have_float_format())

            pm_message("%s; to fix do a 'pamscale -%cscale %g'",

                       baseMsg,

                       xAspect > yAspect ? 'x' : 'y',

                       xAspect > yAspect ? 

                       (float)xAspect/yAspect : 

                       (float)yAspect/xAspect);

        else

            pm_message("%s", baseMsg);

    }

}

static BitMapHeader *

read_bmhd(FILE *        const ifP,

          IFF_ID        const iffid,

          unsigned long const chunksize) {

    BitMapHeader * bmhdP;

    if (chunksize != BitMapHeaderSize) {

        pm_message("invalid size for %s chunk - skipping it", 

                   ID2string(iffid));

        skip_chunk(ifP, iffid, chunksize);

        bmhdP = NULL;

    } else {

        unsigned long remainingChunksize;

        MALLOCVAR_NOFAIL(bmhdP);

        remainingChunksize = chunksize;  /* initial value */

        bmhdP->w = get_big_short(ifP, iffid, &remainingChunksize);

        bmhdP->h = get_big_short(ifP, iffid, &remainingChunksize);

        bmhdP->x = get_big_short(ifP, iffid, &remainingChunksize);

        bmhdP->y = get_big_short(ifP, iffid, &remainingChunksize);

        bmhdP->nPlanes = get_byte(ifP, iffid, &remainingChunksize);

        bmhdP->masking = get_byte(ifP, iffid, &remainingChunksize);

        bmhdP->compression = get_byte(ifP, iffid, &remainingChunksize);

        bmhdP->flags = get_byte(ifP, iffid, &remainingChunksize);

        bmhdP->transparentColor =

            get_big_short(ifP, iffid, &remainingChunksize);

        bmhdP->xAspect = get_byte(ifP, iffid, &remainingChunksize);

        bmhdP->yAspect = get_byte(ifP, iffid, &remainingChunksize);

        bmhdP->pageWidth  = get_big_short(ifP, iffid, &remainingChunksize);

        bmhdP->pageHeight = get_big_short(ifP, iffid, &remainingChunksize);

        if (verbose) {

            if (typeid == ID_ILBM)

                pm_message("dimensions: %dx%d, %d planes", 

                           bmhdP->w, bmhdP->h, bmhdP->nPlanes);

            else

                pm_message("dimensions: %dx%d", bmhdP->w, bmhdP->h);

            if (typeid == ID_ILBM || typeid == ID_PBM) {

                pm_message("compression: %s",

                           bmhdP->compression <= cmpMAXKNOWN ?

                           cmpNAME[bmhdP->compression] : "unknown");

                switch(bmhdP->masking) {

                case mskNone:

                    break;

                case mskHasMask:

                case mskHasTransparentColor:

                    if (!maskfile)

                        pm_message("use '-maskfile <filename>' "

                                   "to generate a PBM mask file from %s", 

                                   mskNAME[bmhdP->masking]);

                    break;

                case mskLasso:

                    pm_message("warning - masking type '%s' not recognized", 

                               mskNAME[bmhdP->masking]);

                    break;

                default:

                    pm_error("unknown masking type %d", bmhdP->masking);

                }

            }

            else    /* RGBN/RGB8 */

                if (!maskfile)

                    pm_message("use '-maskfile <filename>' "

                               "to generate a PBM mask file "

                               "from genlock bits");

        }

        /* fix aspect ratio */

        if (bmhdP->xAspect == 0 || bmhdP->yAspect == 0) {

            pm_message("warning - illegal aspect ratio %d:%d, using 1:1", 

                       bmhdP->xAspect, bmhdP->yAspect);

            bmhdP->xAspect = bmhdP->yAspect = 1;

        }

        warnNonsquarePixels(bmhdP->xAspect, bmhdP->yAspect);

    }

    return bmhdP;

}

/****************************************************************************

 ILBM functions

 ****************************************************************************/

static void

read_ilbm_plane(FILE *          const ifP,

                unsigned long * const remainingChunksizeP,

                int             const bytes,

                int             const compression) {

    unsigned char *ubp;

    int j, byte;

    int bytesRemaining;

    bytesRemaining = bytes;  /* initial value */

    switch(compression) {

        case cmpNone:

            read_bytes(ifP, bytesRemaining, ilbmrow,

                       ID_BODY, remainingChunksizeP);

            break;

        case cmpByteRun1:

            ubp = ilbmrow;

            do {

                byte = (int)get_byte(ifP, ID_BODY, remainingChunksizeP);

                if( byte <= 127 ) {

                    j = byte;

                    bytesRemaining -= (j+1);

                    if( bytesRemaining < 0 )

                        pm_error("error doing ByteRun1 decompression");

                    for( ; j >= 0; j-- )

                        *ubp++ = get_byte(ifP, ID_BODY, remainingChunksizeP);

                }

                else

                if ( byte != 128 ) {

                    j = 256 - byte;

                    bytesRemaining -= (j+1);

                    if( bytesRemaining < 0 )

                        pm_error("error doing ByteRun1 decompression");

                    byte = (int)get_byte(ifP, ID_BODY, remainingChunksizeP);

                    for( ; j >= 0; j-- )

                        *ubp++ = (unsigned char)byte;

                }

                /* 128 is a NOP */

            }

            while( bytesRemaining > 0 );

            break;

        default:

            pm_error("unknown compression type %d", compression);

    }

}

static const unsigned char bit_mask[] = {1, 2, 4, 8, 16, 32, 64, 128};

static void

decode_row(FILE *          const ifP,

           unsigned long * const remainingChunksizeP,

           rawtype *       const chunkyrow,

           int             const nPlanes,

           BitMapHeader *  const bmhdP) {

    int plane, col, cols, cbit, bytes;

    unsigned char *ilp;

    rawtype *chp;

    cols = bmhdP->w;

    overflow_add(cols, 15);

    bytes = RowBytes(cols);

    for( plane = 0; plane < nPlanes; plane++ ) {

        int mask;

        mask = 1 << plane;

        read_ilbm_plane(ifP, remainingChunksizeP, bytes, bmhdP->compression);

        ilp = ilbmrow;

        chp = chunkyrow;

        cbit = 7;

        for( col = 0; col < cols; col++, cbit--, chp++ ) {

            if( cbit < 0 ) {

                cbit = 7;

                ilp++;

            }

            if( *ilp & bit_mask[cbit] )

                *chp |= mask;

            else

                *chp &= ~mask;

        }

    }

}

static void

decode_mask(FILE *          const ifP,

            unsigned long * const remainingChunksizeP,

            rawtype *       const chunkyrow,

            BitMapHeader *  const bmhdP) {

    int col, cols, cbit;

    unsigned char *ilp;

    cols = bmhdP->w;

    switch (bmhdP->masking) {

    case mskNone:

        break;

    case mskHasMask:        /* mask plane */

        read_ilbm_plane(ifP, remainingChunksizeP, RowBytes(cols), 

                        bmhdP->compression);

        if (maskfile) {

            ilp = ilbmrow;

            cbit = 7;

            for (col = 0; col < cols; ++col, --cbit) {

                if (cbit < 0) {

                    cbit = 7;

                    ++ilp;

                }

                if (*ilp & bit_mask[cbit])

                    maskrow[col] = PBM_BLACK;

                else

                    maskrow[col] = PBM_WHITE;

            }

            pbm_writepbmrow(maskfile, maskrow, cols, 0);

            wrotemask = true;

        }

        break;

    case mskHasTransparentColor:

        if (!chunkyrow)

            pm_error("decode_mask(): chunkyrow == NULL - can't happen");

        if (maskfile) {

            for (col = 0; col < cols; ++col) {

                if (chunkyrow[col] == bmhdP->transparentColor)

                    maskrow[col] = PBM_WHITE;

                else

                    maskrow[col] = PBM_BLACK;

            }

            pbm_writepbmrow(maskfile, maskrow, cols, 0);

                wrotemask = true;

        }

        break;

    case mskLasso:

        pm_error("This program does not know how to process Lasso masking");

        break;

    default:

        pm_error("decode_mask(): unknown masking type %d - can't happen", 

                 bmhdP->masking);

    }

}

/****************************************************************************

 Multipalette handling

 ****************************************************************************/

static void *

xmalloc2(x, y)

    int x;

    int y;

{

    void *mem;

    overflow2(x,y);

    if( x * y == 0 )

        return NULL;

    mem = malloc2(x,y);

    if( mem == NULL )

        pm_error("out of memory allocating %d bytes", x * y);

    return mem;

}

static void

multi_adjust(cmap, row, palchange)

    ColorMap *cmap;

    int row;

    PaletteChange *palchange;

{

    int i, reg;

    for( i = 0; palchange[i].reg != MP_REG_END; i++ ) {

        reg = palchange[i].reg;

        if( reg >= cmap->ncolors ) {

            pm_message("warning - palette change register out of range");

            pm_message("    row %d  change structure %d  reg=%d (max %d)", 

                       row, i, reg, cmap->ncolors-1);

            pm_message("    ignoring it...  "

                       "colors might get messed up from here");

        }

        else

        if( reg != MP_REG_IGNORE ) {

            PPM_ASSIGN(cmap->color[reg], 

                       palchange[i].r, palchange[i].g, palchange[i].b);

        }

    }

}

static void

multi_init(cmap, viewportmodes)

    ColorMap *cmap;

    long viewportmodes;

{

    if( cmap->mp_init )

        multi_adjust(cmap, -1, cmap->mp_init);

    if( !(viewportmodes & vmLACE) )

        cmap->mp_flags &= ~(MP_FLAGS_SKIPLACED);

}

static void

multi_update(cmap, row)

    ColorMap *cmap;

    int row;

{

    if( cmap->mp_flags & MP_FLAGS_SKIPLACED ) {

        if( ODD(row) )

            return;

        if( row/2 < cmap->mp_rows && cmap->mp_change[row/2] )

            multi_adjust(cmap, row, cmap->mp_change[row/2]);

    }

    else {

        if( row < cmap->mp_rows && cmap->mp_change[row] )

            multi_adjust(cmap, row, cmap->mp_change[row]);

    }

}

static void

multi_free(cmap)

    ColorMap *cmap;

{

    int i;

    if( cmap->mp_init ) {

        free(cmap->mp_init);

        cmap->mp_init = NULL;

    }

    if( cmap->mp_change ) {

        for( i = 0; i < cmap->mp_rows; i++ ) {

            if( cmap->mp_change[i] )

                free(cmap->mp_change[i]);

        }

        free(cmap->mp_change);

        cmap->mp_change = NULL;

    }

    cmap->mp_rows = 0;

    cmap->mp_type = 0;

    cmap->mp_flags = 0;

}

/****************************************************************************

 Colormap handling

 ****************************************************************************/

static void

analyzeCmapSamples(const ColorMap * const cmapP,

                   pixval *         const maxSampleP,

                   bool *           const shiftedP) {

    pixval       maxSample;

    bool         shifted;

    unsigned int i;

    for (i = 0, maxSample = 0, shifted = true; i < cmapP->ncolors; ++i) {

        pixval const r = PPM_GETR(cmapP->color[i]);

        pixval const g = PPM_GETG(cmapP->color[i]);

        pixval const b = PPM_GETB(cmapP->color[i]);

        maxSample = MAX(maxSample, MAX(r, MAX(g, b)));

        if (r & 0x0f || g & 0x0f || b & 0x0f)

            shifted = false;

    }

    *shiftedP   = shifted;

    *maxSampleP = maxSample;

}

static void

transformCmap(ColorMap * const cmapP) {

    pixval maxSample;

        /* The maximum sample value in *cmapP input */

    bool shifted;

        /* Samples in the *cmapP input appear to be 4 bit (maxval 15) original

           values shifted left 4 places to make 8 bit (maxval 255) samples.

        */

    analyzeCmapSamples(cmapP, &maxSample, &shifted);

    if (maxSample == 0)

        pm_message("warning - black colormap");

    else if (shifted || maxSample <= 15) {

        if (!adjustcolors) {

            pm_message("warning - probably %s4-bit colormap",

                       shifted ? "shifted " : "");

            pm_message("Use '-adjustcolors' to scale colormap to 8 bits");

        } else {

            unsigned int i;

            pm_message("scaling colormap to 8 bits");

            for (i = 0; i < cmapP->ncolors; ++i) {

                pixval r, g, b;

                r = PPM_GETR(cmapP->color[i]);

                g = PPM_GETG(cmapP->color[i]);

                b = PPM_GETB(cmapP->color[i]);

                if (shifted) {

                    r >>= 4;

                    g >>= 4;

                    b >>= 4;

                }

                r *= FACTOR_4BIT;

                g *= FACTOR_4BIT;

                b *= FACTOR_4BIT;

                PPM_ASSIGN(cmapP->color[i], r, g, b);

            }

        }

    }

}

static pixel *

transpColor(const BitMapHeader * const bmhdP,

            ColorMap *           const cmapP,

            const char *         const transpName,

            pixval               const maxval) {

    pixel * transpColorP;

    if (bmhdP) {

        if (bmhdP->masking == mskHasTransparentColor || 

            bmhdP->masking == mskLasso) {

            MALLOCVAR_NOFAIL(transpColorP);

            if (transpName)