/*
 * 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_row_alc.c - Allocate buffers for rle_getrow/rle_putrow.
 *
 * Author:      Spencer W. Thomas
 *              Computer Science Dept.
 *              University of Utah
 * Date:        Fri Nov 14 1986
 * Copyright (c) 1986, Spencer W. Thomas
 */

#include <stdlib.h>
#include <stdio.h>

#include "rle.h"

/*****************************************************************
 * TAG( rle_row_alloc )
 *
 * Allocate buffer space for use by rle_getrow and rle_putrow.
 * Inputs:
 *      the_hdr:        Header structure for RLE file to be read or
 *                      written.
 * Outputs:
 *      scanp:          Pointer to pointer to created scanline buffer.
 *                      This pointer is adjusted for the alpha channel,
 *                      if present.
 *      Returns 0 for success, -1 if malloc failed.
 * Assumptions:
 *      No input scanline will extend beyond the declared xmax endpoint.
 * Algorithm:
 *      Count number of channels actually used (check bitmap).
 *      Allocate nchan*rowlength pixels, allocate a buffer
 *      to hold ncolors+alpha pointers, and give each channel
 *      rowlength pixels.  Rowlength is xmax + 1, to allow for rle_getrow
 *      usage.
 */
int
rle_row_alloc( the_hdr, scanp )
rle_hdr *the_hdr;
rle_pixel ***scanp;
{
    rle_pixel ** scanbuf, * pixbuf;
    int rowlen, nchan = 0, i, ncol;

    rowlen = the_hdr->xmax + 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_pixel **)malloc( ncol * sizeof(rle_pixel *) )) == 0 )
        return -1;
    if ( (pixbuf = (rle_pixel *)malloc( nchan * rowlen *
                                       sizeof(rle_pixel) )) == 0 )
    {
        free( scanbuf );
        return -1;
    }

    if ( the_hdr->alpha )
        scanbuf++;

    for ( i = -the_hdr->alpha; i < the_hdr->ncolors; i++ )
        if ( RLE_BIT( *the_hdr, i ) )
        {
            scanbuf[i] = pixbuf;
            pixbuf += rowlen;
        }
        else
            scanbuf[i] = 0;
    *scanp = scanbuf;

    return 0;
}



/*****************************************************************
 * TAG( rle_row_free )
 *
 * Free storage allocated by rle_row_alloc().
 * Inputs:
 *      the_hdr:        Header structure as above.
 *      scanp:          Pointer to scanbuf above.
 * Outputs:
 *      Frees storage referenced by scanp and nrawp.
 * Assumptions:
 *      Storage was allocated by rle_row_alloc, or by use of same
 *      algorithm, at least.
 * Algorithm:
 *      free scanp[0] and scanp.
 */
void
rle_row_free( the_hdr, scanp )
rle_hdr *the_hdr;
rle_pixel **scanp;
{
    int i;

    if ( the_hdr->alpha )
        scanp--;
    for ( i = 0; i < the_hdr->ncolors + the_hdr->alpha; i++ )
        if ( scanp[i] != 0 )
        {
            free( (char *)scanp[i] );
            break;
        }
    free( (char *)scanp );
}