QBasic & Borland Pascal & C/Delphi5.iso/C/Samples/CSAPE32.ARJ/SOURCE/OWLSCR/PCSPLASH.C

C/C++ Source or Header | 1990-11-01 | 5.3 KB | 214 lines

/*
    pcsplash.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-PC 1.2
    Copyright (c) 1988, 1989 by Oakland Group, Inc.
    ALL RIGHTS RESERVED.

    Revision History:
    -----------------
     2/15/90 ted    Called dig_squeezecmap instead of pc_squeezecmap.
     2/29/90 ted    Added OCDECL for assembly function.
     3/28/90 jmd    ansi-fied
    10/10/90 ted    Replaced OCDECL with oasm_func for assembly functions.
    10/31/90 ted    Added ferror() calls; fread ret val never has error code.
*/

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

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

OSTATIC S_LoadMask DIGPRIV oloadfile(FILE *fd, S_LoadMask loadwhat, pmap_type *pmapp, ocolmap_type *cmapp);
OSTATIC ocolmap_type DIGPRIV loadcolmap(FILE *fd);
OSTATIC pmap_type DIGPRIV loadpmap(FILE *fd);
OSTATIC boolean DIGPRIV pmap_unsqueeze(pmap_type pmap);

/* -------------------------------------------------------------------------- */

pmap_type pmap_LoadSplash(FILE *fd, ocolmap_type crange)
/*
    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.

    'fd'        file descriptor of the splash image file
    'crange'    color range to use for the loaded image
*/
{
    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 */
    dig_squeezecmap(pmap, cmap, crange, pc_pmhist, pc_pmcswap, pc_pmnearcol);
    ocolmap_Close(cmap);

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

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

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

    if (hdr->ident != ID_SPLASH) {
        return(FALSE);
    }

    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(FILE *fd)
{
    S_Colmap fcm;
    S_Colmap *cm;
    ocolmap_type cmap;
    unsigned short i;

    cm = &fcm;

    fread((VOID *) cm, 1, sizeof(S_Colmap), fd);
    if (ferror(fd)) {
        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(FILE *fd)
{
    S_Pixmap pmbuf;
    S_Pixmap *pm;
    pmap_type pmap;
    SIZE_T n;
    unsigned rsize;

/* Read S_Pixmap structure */
    pm = &pmbuf;
    fread((VOID *) pm, 1, sizeof(S_Pixmap), fd);
    if (ferror(fd)) {
        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 */
        fread((VOID *) pcpmap_pixbuf(pmap), 1,
                    (unsigned) pcpmap_GetPlaneSize(pmap), fd);
        if (ferror(fd)) {
            goto PMABORT;
        }
        break;
    case PMC_Brun:        /* Compressed pixmap */
        n = fread((VOID *) pcpmap_pixbuf(pmap), 1,
                        (unsigned) pcpmap_GetPlaneSize(pmap), fd);
        if (ferror(fd)) {
            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_type pmap)
{
    union {
        struct runhdr {
            unsigned rsize;
            unsigned rcode;
        } hs;
        long runcode;
    } rh;
    byte *pixbuf;

    pixbuf = pcpmap_pixbuf(pmap);

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

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

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

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