The Developer Connection…ice Driver Kit for OS/2 3/DEV3-D1.ISO/source/gbmsrc/gbm/gbmiax.c

C/C++ Source or Header | 1993-09-27 | 5.0 KB | 239 lines

/*

GBMIAX.C  IBM Image Access eXecutive support

Reads array as 8 bit greyscale.
Writes grey equivelent of passed in 8 bit colour data (no palette written).
Input options: width=# (default: 512)
Output options: r,g,b,k (default: k)

*/

/*...sincludes:0:*/
#include <stdio.h>
#include <ctype.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <memory.h>
#include <malloc.h>
#ifdef AIX
#include <unistd.h>
#else
#include <io.h>
#endif
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "standard.h"
#include "gbm.h"

/*...vgbm\46\h:0:*/
/*...e*/

/*...suseful:0:*/
#define    low_byte(w)    ((byte)  ((w)&0x00ff)    )
#define    high_byte(w)    ((byte) (((w)&0xff00)>>8))
#define    make_word(a,b)    (((word)a) + (((word)b) << 8))
/*...e*/
/*...ssame:0:*/
static BOOLEAN same(char *s1, char *s2, int n)
    {
    for ( ; n--; s1++, s2++ )
        if ( tolower(*s1) != tolower(*s2) )
            return ( FALSE );
    return ( TRUE );
    }
/*...e*/
/*...sfind_word:0:*/
static char *find_word(char *str, char *substr)
    {
    char    buf [100+1], *s;
    int    len = strlen(substr);

    for ( s  = strtok(strcpy(buf, str), " \t,");
          s != NULL;
          s  = strtok(NULL, " \t,") )
        if ( same(s, substr, len) && s [len] == '\0' )
            return ( str + (s - buf) );
    return ( NULL );
    }
/*...e*/
/*...sfind_word_prefix:0:*/
static char *find_word_prefix(char *str, char *substr)
    {
    char    buf [100+1], *s;
    int    len = strlen(substr);

    for ( s  = strtok(strcpy(buf, str), " \t,");
          s != NULL;
          s  = strtok(NULL, " \t,") )
        if ( same(s, substr, len) )
            return ( str + (s - buf) );
    return ( NULL );
    }
/*...e*/
/*...smake_output_palette:0:*/
#define    SW4(a,b,c,d)    ((a)*8+(b)*4+(c)*2+(d))

static BOOLEAN make_output_palette(GBMRGB gbmrgb [], byte grey [], char *opt)
    {
    BOOLEAN    k = ( find_word(opt, "k") != NULL );
    BOOLEAN    r = ( find_word(opt, "r") != NULL );
    BOOLEAN    g = ( find_word(opt, "g") != NULL );
    BOOLEAN    b = ( find_word(opt, "b") != NULL );
    int    i;

    switch ( SW4(k,r,g,b) )
        {
        case SW4(0,0,0,0):
            /* Default is the same as "k" */
        case SW4(1,0,0,0):
            for ( i = 0; i < 0x100; i++ )
                grey [i] = (byte) ( ((word) gbmrgb [i].r *  77 +
                             (word) gbmrgb [i].g * 151 +
                             (word) gbmrgb [i].b *  28) >> 8 );
            return ( TRUE );
        case SW4(0,1,0,0):
            for ( i = 0; i < 0x100; i++ )
                grey [i] = gbmrgb [i].r;
            return ( TRUE );
        case SW4(0,0,1,0):
            for ( i = 0; i < 0x100; i++ )
                grey [i] = gbmrgb [i].g;
            return ( TRUE );
        case SW4(0,0,0,1):
            for ( i = 0; i < 0x100; i++ )
                grey [i] = gbmrgb [i].b;
            return ( TRUE );
        }
    return ( FALSE );
    }
/*...e*/

static GBMFT iax_gbmft =
    {
    "IAX",
    "IBM Image Access eXecutive",
    "IAX",
    GBM_FT_R8|
    GBM_FT_W8,
    };

#define    GBM_ERR_IAX_SIZE    ((GBM_ERR) 1500)

/*...siax_qft:0:*/
GBM_ERR iax_qft(GBMFT *gbmft)
    {
    *gbmft = iax_gbmft;
    return ( GBM_ERR_OK );
    }
/*...e*/
/*...siax_rhdr:0:*/
GBM_ERR iax_rhdr(char *fn, int fd, GBM *gbm, char *opt)
    {
    long    length;
    int    w, h;
    char    *width;

    fn=fn; fd=fd; /* Suppress 'unref arg' compiler warnings */

    length = lseek(fd, 0L, SEEK_END);
    lseek(fd, 0L, SEEK_SET);

    if ( (width = find_word_prefix(opt, "width=")) != NULL )
        sscanf(width + 6, "%d", &w);
    else
        w = 512;

    h = (int) (length / w);

    if ( w <= 0 || h <= 0 )
        return ( GBM_ERR_BAD_SIZE );

    if ( w * h != length )
        return ( GBM_ERR_IAX_SIZE );

    gbm -> w   = w;
    gbm -> h   = h;
    gbm -> bpp = 8;

    return ( GBM_ERR_OK );
    }
/*...e*/
/*...siax_rpal:0:*/
GBM_ERR iax_rpal(int fd, GBM *gbm, GBMRGB *gbmrgb)
    {
    int    i;

    fd=fd; gbm=gbm; /* Suppress 'unref arg' compiler warnings */

    for ( i = 0; i < 0x100; i++ )
        gbmrgb [i].r =
        gbmrgb [i].g =
        gbmrgb [i].b = (byte) i;

    return ( GBM_ERR_OK );
    }
/*...e*/
/*...siax_rdata:0:*/
GBM_ERR iax_rdata(int fd, GBM *gbm, byte *data)
    {
    int    i, stride;
    byte    *p;

    stride = ((gbm -> w + 3) & ~3);
    p = data + ((gbm -> h - 1) * stride);
    for ( i = gbm -> h - 1; i >= 0; i-- )
        {
        read(fd, p, gbm -> w);
        p -= stride;
        }
    return ( GBM_ERR_OK );
    }
/*...e*/
/*...siax_w:0:*/
GBM_ERR iax_w(char *fn, int fd, GBM *gbm, GBMRGB *gbmrgb, byte *data, char *opt)
    {
    int    i, j, stride;
    byte    grey [0x100];
    byte    *p, *linebuf;

    fn=fn; /* Suppress 'unref arg' compiler warning */

    if ( gbm -> bpp != 8 )
        return ( GBM_ERR_NOT_SUPP );

    if ( !make_output_palette(gbmrgb, grey, opt) )
        return ( GBM_ERR_BAD_OPTION );

    if ( (linebuf = malloc(gbm -> w)) == NULL )
        return ( GBM_ERR_MEM );

    stride = ((gbm -> w + 3) & ~3);
    p = data + ((gbm -> h - 1) * stride);
    for ( i = gbm -> h - 1; i >= 0; i-- )
        {
        for ( j = 0; j < gbm -> w; j++ )
            linebuf [j] = grey [p [j]];
        write(fd, linebuf, gbm -> w);
        p -= stride;
        }

    free(linebuf);

    return ( GBM_ERR_OK );
    }
/*...e*/
/*...siax_err:0:*/
char *iax_err(GBM_ERR rc)
    {
    switch ( (int) rc )
        {
        case GBM_ERR_IAX_SIZE:
            return ( "file length is not a multiple of its width" );
        }
    return ( NULL );
    }
/*...e*/