Liren Large Software Subsidy 7/07.iso/c/c185/2.ddi/OWLSRC.EXE/CSCAPE/SOURCE/PCSPLASH.C

C/C++ Source or Header | 1989-09-10 | 5.2 KB | 212 lines

/*
    pmsplash.c

    % Load a splash image file into a pixel map structure.
    NOTE !! : MUST BE COMPILED IN A LARGE DATA MODEL.

    3/11/88 By Ted.

    OWL 1.1
    Copyright (c) 1988, 1989 by Oakland Group, Inc.
    ALL RIGHTS RESERVED.

    Revision History:
    -----------------
*/

#include "pcpriv.h"
#include "splash.h"

/* bunrun.asm */
extern unsigned DIGPRIV bunrun(_arg3(byte *pixbuf, unsigned size, long runcode));

OSTATIC S_LoadMask DIGPRIV oloadfile(_arg4(FILE *fd, S_LoadMask loadwhat, pmap_type *pmapp, ocolmap_type *cmapp));
OSTATIC ocolmap_type DIGPRIV loadcolmap(_arg1(FILE *fd));
OSTATIC pmap_type DIGPRIV loadpmap(_arg1(FILE *fd));
OSTATIC boolean DIGPRIV pmap_unsqueeze(_arg1(pmap_type pm));
/* -------------------------------------------------------------------------- */

pmap_type pmap_LoadSplash(fd, crange)
    FILE *fd;                /* file descriptor of the splash image file */
    ocolmap_type crange;    /* color range to use for the loaded image */
/*
    Allocates a pixel image map and fills it with the named splash image;

    The image map is an array of pixels organized
    in the same fashion as the current display.

    Returns NULL if out of memory.
*/
{
    pmap_type pmap;
    ocolmap_type cmap;

    pmap = NULL;
    cmap = NULL;
    oloadfile(fd, B_PIXMAP | B_COLMAP, &pmap, &cmap);

    /* Compress colors of pmap into given color range */
    pc_squeezecmap(pmap, cmap, crange);
    ocolmap_Close(cmap);

    return(pmap);
}
/* -------------------------------------------------------------------------- */
#define S_MAXTAGS 20
/* -------------------------------------------------------------------------- */

static S_LoadMask DIGPRIV oloadfile(fd, loadwhat, pmapp, cmapp)
    FILE *fd;
    S_LoadMask loadwhat;
    pmap_type *pmapp;
    ocolmap_type *cmapp;
{
    int n;
    S_FileHdr(S_MAXTAGS) hbuf;
    S_FileHdr(S_MAXTAGS) *hdr;
    S_TifPtr *iptr;
    S_LoadMask loaded;

    if (fd == NULL) {
        return(FALSE);
    }
    n = fread((VOID *)&hbuf, 1, sizeof(S_FileHdr(S_MAXTAGS)), fd);
    if (n < sizeof(S_FileHdr(1))) {
        return(FALSE);
    }
    hdr = (VOID *)&hbuf;

    if (hdr->ident != ID_SPLASH)

    if (hdr->nentries > S_MAXTAGS) hdr->nentries = S_MAXTAGS;

    loaded = 0;
    for (iptr = &hdr->tags[0]; iptr < &hdr->tags [hdr->nentries]; iptr++) {
        switch (iptr->tag) {
         case T_PIXMAP:
            if (!(loadwhat & B_PIXMAP)) break;
            if (pmapp == NULL) break;
            fseek(fd, iptr->foffset, SEEK_SET);
            if ((*pmapp = loadpmap(fd)) != NULL) loaded |= B_PIXMAP;
            else return(loaded);
            break;
         case T_COLMAP:
            if (!(loadwhat & B_COLMAP)) break;
            if (cmapp == NULL) break;
            fseek(fd, iptr->foffset, SEEK_SET);
            if ((*cmapp = loadcolmap(fd)) != NULL) loaded |= B_COLMAP;
            else return(loaded);
            break;
        }
        if (loaded == loadwhat) break;
    }
    return(loaded);
}
/* -------------------------------------------------------------------------- */

static ocolmap_type DIGPRIV loadcolmap(fd)
    FILE *fd;
{
    S_Colmap(S_MaxColors) fcm;
    S_Colmap(S_MaxColors) *cm;
    ocolmap_type cmap;
    int i;

    cm = (VOID *) &fcm;

    if (fread((VOID *)cm, 1, sizeof(S_Colmap(S_MaxColors)), fd) < 0)
        return(FALSE);

    cmap = ocolmap_Open((opixval)cm->firstpix, (unsigned)cm->nentries);
    if (cmap == NULL) {
        return(NULL);
    }
/* copy colors into cmap */
    for (i = 0; i < cm->nentries; i++) {
        memmove(ocolmap_entry(cmap, cmap->firstpix + i),
                cm->rgblevs[cm->firstpix + i],
                sizeof(orgb_struct));
    }
    dig_shiftcmap(cmap, -2);
    return(cmap);
}
/* -------------------------------------------------------------------------- */

static pmap_type DIGPRIV loadpmap(fd)
    FILE *fd;
{
    S_Pixmap pmbuf;
    S_Pixmap *pm;
    pmap_type pmap;
    unsigned n, rsize;

/* Read S_Pixmap structure */
    pm = &pmbuf;
    if (fread((VOID *)pm, 1, sizeof(S_Pixmap), fd) < 0) {
        return(NULL);
    }
/* Allocate blank pmap */
    pmap = pmap_Open(S_pmwidth(pm), S_pmheight(pm));
    if (pmap == NULL) {
        return(NULL);
    }
/* Fill the pmap */
    switch (S_pmcomptype(pm)) {
    case PMC_None:        /* Uncompressed pixmap */
        if (fread((VOID *)pcpmap_pixbuf(pmap), 1,
                        (unsigned)pcpmap_GetPlaneSize(pmap), fd) < 0) {
            goto PMABORT;
        }
        break;
    case PMC_Brun:        /* Compressed pixmap */
        if ((n = fread((VOID *)pcpmap_pixbuf(pmap), 1,
                            (unsigned)pcpmap_GetPlaneSize(pmap), fd)) < 0) {
            goto PMABORT;
        }
        rsize = *((unsigned *) pcpmap_pixbuf(pmap));
        if (n < rsize) {
            goto PMABORT1;
            }
        if (!pmap_unsqueeze(pmap)) {
            goto PMABORT1;
            }
        break;
    default:
        goto PMABORT1;
    }
    return(pmap);

PMABORT1:
PMABORT:
    pmap_Close(pmap);
    return(NULL);
}
/* -------------------------------------------------------------------------- */

static boolean DIGPRIV pmap_unsqueeze(pmap)
    pmap_type pmap;
{
    union {
        struct runhdr {
            unsigned rsize;
            unsigned rcode;
        } hs;
        long runcode;
    } rh;
    unsigned bsize;
    byte *pixbuf;

    pixbuf = pcpmap_pixbuf(pmap);

    memmove(&rh, pixbuf, 4);    /* extract header */

    memmove(pixbuf, pixbuf + 4, rh.hs.rsize);    /* slide down by 4 */

    bsize = bunrun(pixbuf, (unsigned)pcpmap_GetPlaneSize(pmap), rh.runcode);
    if (bsize != (unsigned) pcpmap_GetPlaneSize(pmap)) ;    /* what can you do? */

    return(TRUE);
}
/* -------------------------------------------------------------------------- */