buildmap.c File Reference

#include <stdio.h>
#include "rle.h"
#include <math.h>

Include dependency graph for buildmap.c:

Go to the source code of this file.

Functions
rle_pixel **	buildmap (rle_hdr *the_hdr, int minmap, double orig_gamma, double new_gamma)

Function Documentation

rle_pixel** buildmap	(	rle_hdr *	the_hdr,
		int	minmap,
		double	orig_gamma,
		double	new_gamma
	)

Definition at line 56 of file buildmap.c.

Referenced by find_most_used().

{
    rle_pixel ** cmap, * gammap;
    double gamma;
    register int i, j;
    int maplen, cmaplen, nmap;

    if ( the_hdr->ncmap == 0 )  /* make identity map */
    {
    nmap = (minmap < the_hdr->ncolors) ? the_hdr->ncolors : minmap;
    cmap = (rle_pixel **)malloc( nmap * sizeof(rle_pixel *) );
    cmap[0] = (rle_pixel *)malloc( nmap * 256 * sizeof(rle_pixel) );
    for ( j = 1; j < nmap; j++ )
        cmap[j] = cmap[j-1] + 256;
    for ( i = 0; i < 256; i++ )
        for ( j = 0; j < nmap; j++ )
        cmap[j][i] = i;
    maplen = 256;
    }
    else            /* make map from the_hdr */
    {
    /* Map is at least 256 long */
    cmaplen = (1 << the_hdr->cmaplen);
    if ( cmaplen < 256 )
        maplen = 256;
    else
        maplen = cmaplen;

    /* Nmap is max( minmap, the_hdr->ncmap, the_hdr->ncolors ). */
    nmap = minmap;
    if ( nmap < the_hdr->ncmap )
        nmap = the_hdr->ncmap;
    if ( nmap < the_hdr->ncolors )
        nmap = the_hdr->ncolors;
    
    /* Allocate memory for the map and secondary pointers. */
    cmap = (rle_pixel **)malloc( nmap * sizeof(rle_pixel *) );
    cmap[0] = (rle_pixel *)malloc( nmap * maplen * sizeof(rle_pixel) );
    for ( i = 1; i < nmap; i++ )
        cmap[i] = cmap[0] + i * maplen;
    
    /* Fill it in. */
    for ( i = 0; i < maplen; i++ )
    {
        for ( j = 0; j < the_hdr->ncmap; j++ )
        if ( i < cmaplen )
            cmap[j][i] = the_hdr->cmap[j*cmaplen + i] >> 8;
        else
            cmap[j][i] = i;
        for ( ; j < nmap; j++ )
        cmap[j][i] = cmap[j-1][i];
    }
    }
    
    /* Gamma compensate if requested */
    if ( orig_gamma == 0 )
    {
    char *v;
    if ( (v = rle_getcom( "image_gamma", the_hdr )) != NULL )
    {
        orig_gamma = atof( v );
        /* Protect against bogus information */
        if ( orig_gamma == 0.0 )
        orig_gamma = 1.0;
        else
        orig_gamma = 1.0 / orig_gamma;
    }
    else if ( (v = rle_getcom( "display_gamma", the_hdr )) != NULL)
    {
        orig_gamma = atof( v );
        /* Protect */
        if ( orig_gamma == 0.0 )
        orig_gamma = 1.0;
    }
    else
        orig_gamma = 1.0;
    }

    /* Now, compensate for the gamma of the new display, too. */
    if ( new_gamma != 0.0 )
    gamma = orig_gamma / new_gamma;
    else
    gamma = orig_gamma;

    if ( gamma != 1.0 )
    {
    gammap = (rle_pixel *)malloc( 256 * sizeof(rle_pixel) );
    for ( i = 0; i < 256; i++ )
        gammap[i] = (int)(0.5 + 255.0 * pow( i / 255.0, gamma ));
    for ( i = 0; i < nmap; i++ )
        for ( j = 0; j < maplen; j++ )
        cmap[i][j] = gammap[cmap[i][j]];
    free( gammap );
    }

    return cmap;
}

Here is the caller graph for this function: