This is rle_raw_alc.c in view mode; [Download] [Up]
/*
* This software is copyrighted as noted below. It may be freely copied,
* modified, and redistributed, provided that the copyright notice is
* preserved on all copies.
*
* There is no warranty or other guarantee of fitness for this software,
* it is provided solely "as is". Bug reports or fixes may be sent
* to the author, who may or may not act on them as he desires.
*
* You may not include this software in a program or other software product
* without supplying the source, or without informing the end-user that the
* source is available for no extra charge.
*
* If you modify this software, you should include a notice giving the
* name of the person performing the modification, the date of modification,
* and the reason for such modification.
*
* Modified at BRL 16-May-88 by Mike Muuss to avoid Alliant STDC desire
* to have all "void" functions so declared.
*/
/*
* rle_raw_alc.c - Allocate buffers for rle_getraw/rle_putraw.
*
* Author: Spencer W. Thomas
* Computer Science Dept.
* University of Utah
* Date: Fri Nov 14 1986
* Copyright (c) 1986, Spencer W. Thomas
*/
#include <stdio.h>
#include <rle.h>
#include <rle_raw.h>
#ifndef VOID_STAR
extern char * malloc();
#else
extern void *malloc();
#endif
extern void free();
/*****************************************************************
* TAG( rle_raw_alloc )
*
* Allocate buffer space for use by rle_getraw and rle_putraw.
* Inputs:
* the_hdr: Header structure for RLE file to be read or
* written.
* Outputs:
* scanp: Pointer to pointer to created opcode buffer.
* nrawp: Pointer to pointer to created length buffer.
* These pointers are adjusted for the alpha channel,
* if present.
* Returns 0 for success, -1 if malloc failed.
* Assumptions:
* Since buffers are built to have as many slots as there are pixels
* in the input scanline, it is assumed that no input scanline will
* have more data elements than this.
* Algorithm:
* Count number of channels actually used (check bitmap).
* Allocate nchan*rowlength elements, allocate a buffer
* to hold (ncolors+alpha) pointers.
* Also allocate a buffer of ncolors+alpha
* integers for the length buffer.
*/
int
rle_raw_alloc( the_hdr, scanp, nrawp )
rle_hdr *the_hdr;
rle_op ***scanp;
int **nrawp;
{
rle_op ** scanbuf, * opbuf;
int rowlen, nchan = 0, i, ncol;
rowlen = the_hdr->xmax - the_hdr->xmin + 1;
if ( the_hdr->alpha && RLE_BIT( *the_hdr, RLE_ALPHA ) )
nchan++;
for ( i = 0; i < the_hdr->ncolors; i++ )
if ( RLE_BIT( *the_hdr, i ) )
nchan++;
ncol = the_hdr->ncolors + the_hdr->alpha;
if ( (scanbuf = (rle_op **) malloc( ncol * sizeof(rle_op *) )) == 0 )
return -1;
if ( (opbuf = (rle_op *)malloc( nchan * rowlen * sizeof(rle_op) )) == 0 )
{
free( scanbuf );
return -1;
}
if ( (*nrawp = (int *)malloc( ncol * sizeof(int) )) == 0 )
{
free( scanbuf );
free( opbuf );
return -1;
}
if ( the_hdr->alpha )
{
scanbuf++;
(*nrawp)++;
}
for ( i = -the_hdr->alpha; i < the_hdr->ncolors; i++ )
if ( RLE_BIT( *the_hdr, i ) )
{
scanbuf[i] = opbuf;
opbuf += rowlen;
}
else
scanbuf[i] = 0;
*scanp = scanbuf;
return 0;
}
/*****************************************************************
* TAG( rle_raw_free )
*
* Free storage allocated by rle_raw_alloc().
* Inputs:
* the_hdr: Header structure as above.
* scanp: Pointer to scanbuf above.
* nrawp: Pointer to length buffer.
* Outputs:
* Frees storage referenced by scanp and nrawp.
* Assumptions:
* Storage was allocated by rle_raw_alloc, or by use of same
* algorithm, at least.
* Algorithm:
* free scanp[0], scanp, and nrawp.
*/
void
rle_raw_free( the_hdr, scanp, nrawp )
rle_hdr *the_hdr;
rle_op **scanp;
int *nrawp ;
{
int i;
if ( the_hdr->alpha )
{
scanp--;
nrawp--;
}
for ( i = 0; i < the_hdr->ncolors + the_hdr->alpha; i++ )
if ( scanp[i] != 0 )
{
free( (char *)scanp[i] );
break;
}
free( (char *)scanp );
free( (char *)nrawp );
}
These are the contents of the former NiCE NeXT User Group NeXTSTEP/OpenStep software archive, currently hosted by Netfuture.ch.