src/hd/sm_samp.c

#ifndef lint
static const char       RCSid[] = "$Id: sm_samp.c,v 3.8 2003/06/20 00:25:49 greg Exp $";
#endif
/*
 * sm_samp.c
 */

#include <string.h>

#include "standard.h"
#include "sm_flag.h"
#include "rhd_sample.h"

SAMP rsL;
int32 *samp_flag=NULL;

/* Each sample has a world coord point, and direction, brightness,chrominance,
   and RGB triples
 */

#define TMSIZE sizeof(TMbright)
#define SAMPSIZ (3*sizeof(SFLOAT)+sizeof(int32)+ 6*sizeof(BYTE) + TMSIZE + 2*sizeof(int))

 /* Extra points world space point, vert flag and qt flag */
#define POINTSIZ (3*sizeof(SFLOAT) + 2*sizeof(int))

/* Clear the flags for all samples */ 
sClear_all_flags(s)
SAMP *s;
{
  if(samp_flag)
    memset((char *)samp_flag, '\0', FLAG_BYTES(S_MAX_BASE_PT(s)));
}

sInit(s)
   SAMP *s;
{
  S_REPLACE_SAMP(s) = 0;
  S_NUM_SAMP(s) = 0;
  S_TONE_MAP(s) = 0;
  S_FREE_SAMP(s) = -1;
  sClear_base_points(s);

}

sFree(s)
SAMP *s;
{
    if(S_BASE(s))
    {
        free(S_BASE(s));
        S_BASE(s)=NULL;
    }
    if(samp_flag)
    {
        free(samp_flag);
        samp_flag = NULL;
    }
}
        /* Initialize/clear global smL sample list for at least n samples */
SAMP
*sAlloc(nptr,extra_points)
int *nptr,extra_points;
{
  unsigned nbytes;
  register unsigned     i;
  SAMP *s;
  int n;
  
  s = &rsL;
  /* round space up to nearest power of 2 */
  nbytes = (*nptr)*SAMPSIZ + extra_points*POINTSIZ + 8;
  for (i = 1024; nbytes > i; i <<= 1)
                ;
  /* get number of samples that fit in block */
  n = (i - 8 - extra_points*POINTSIZ) / SAMPSIZ;        

  /* Must make sure n + extra_points can fit in a S_ID identifier */
  if ( n > (S_ID_MAX - extra_points))
    n = (S_ID_MAX - extra_points);

  S_BASE(s) = (char *)malloc(n*SAMPSIZ + extra_points*POINTSIZ);
  if (!S_BASE(s))
    error(SYSTEM,"sAlloc(): Unable to allocate memory");

  /* assign larger alignment types earlier */
  S_W_PT(s) = (SFLOAT(*)[3])S_BASE(s);
  S_W_DIR(s) = (int32 *)(S_W_PT(s) + n + extra_points);
  S_BRT(s) = (TMbright *)(S_W_DIR(s) + n);
  S_CHR(s) = (BYTE (*)[3])(S_BRT(s) + n);
  S_RGB(s) = (BYTE (*)[3])(S_CHR(s) + n);
  S_INFO(s) = (int *)(S_RGB(s)+n);
  S_INFO1(s) = (int *)(S_INFO(s)+n+extra_points);
  S_MAX_SAMP(s) = n;
  S_MAX_BASE_PT(s) = n + extra_points;

  /* Allocate memory for a per/sample bit flag */
  if(!(samp_flag = (int32 *)malloc(FLAG_BYTES(n+extra_points))))
    error(SYSTEM,"sAlloc(): Unable to allocate flag memory");
  sInit(s);
  sClear_all_flags(s);

  *nptr = n;
  
  return(s);
}


/* Add a base point to the sample structure: only the world point
   is added: These points are not displayed-they are used to form the
   initial mesh
 */
S_ID
sAdd_base_point(s,v)
     SAMP *s;
     FVECT v;
{
    S_ID id;

    /* Get pointer to next available point */
    id = S_NEXT_BASE_PT(s);
    if(id >= S_MAX_BASE_PT(s))
       return(-1);

    /* Update free aux pointer */
    S_NEXT_BASE_PT(s)++;

    /* Copy vector into point */
    VCOPY(S_NTH_W_PT(s,id),v);
    return(id);
}

/* Copy the values of sample n_id into sample id: Note must not call with
   Base point n_id
*/
int
sCopy_samp(s,n_id,id)
   SAMP *s;
   S_ID n_id,id;
{

#ifdef DEBUG
   if(id <0||id >= S_MAX_SAMP(s)||n_id <0||n_id >= S_MAX_SAMP(s))
   {
     eputs("smReset_sample():invalid sample id\n");
     return(0);
   }
#endif
   if(n_id == id)
     return(1);
 /* Copy vector into point */
   VCOPY(S_NTH_W_PT(s,n_id),S_NTH_W_PT(s,id));
   S_NTH_W_DIR(s,n_id) = S_NTH_W_DIR(s,id);

   S_NTH_BRT(s,n_id) = S_NTH_BRT(s,id);
   S_NTH_CHR(s,n_id)[0] = S_NTH_CHR(s,id)[0];
   S_NTH_CHR(s,n_id)[1] = S_NTH_CHR(s,id)[1];
   S_NTH_CHR(s,n_id)[2] = S_NTH_CHR(s,id)[2];

   return(1);
}


/* Initialize the sample 'id' to contain world point 'p', direction 'd' and
   color 'c'. If 'p' is NULL, a direction only is represented in 'd'. In
   this case, the world point is set to the projection of the direction on
   the view sphere, and the direction value is set to -1
 */
void
sInit_samp(s,id,c,d,p,o_id)
   SAMP *s;
   S_ID id;
   COLR c;
   FVECT d,p;
   S_ID o_id;
{

  if(o_id != INVALID)
    sCopy_samp(s,id,o_id);
  else
  {
    /* Copy vector into point */
    VCOPY(S_NTH_W_PT(s,id),p);
    if(d)
      S_NTH_W_DIR(s,id) = encodedir(d);
    else
      S_NTH_W_DIR(s,id) = -1;

    /* calculate the brightness and chrominance,RGB will be set by
       tonemapping
       */
    tmCvColrs(&S_NTH_BRT(s,id),S_NTH_CHR(s,id),c,1);
  }
    /* Set ACTIVE bit upon creation */
  S_SET_FLAG(id);
  if(id < S_TONE_MAP(s))
    tmMapPixels(S_NTH_RGB(s,id),&S_NTH_BRT(s,id),S_NTH_CHR(s,id),1);
}


/* Allocate a new sample. If an existing sample was replaced: set flag */
S_ID
sAlloc_samp(s,replaced)
   SAMP *s;
   int *replaced;
   
{
    S_ID id;

    /* First check if there are any freed sample available */
    if((id = S_FREE_SAMP(s)) != INVALID)
    {
      *replaced = 0;
#if 0
      fprintf(stderr,"allocating previously freed sample %d\n",id);
#endif
      S_FREE_SAMP(s) = S_NTH_NEXT(s,id);
      return(id);
    }
    /* If havn't reached end of sample array:return next sample */
    if(S_NUM_SAMP(s) < S_MAX_SAMP(s))
    {
      id = S_NUM_SAMP(s)++;
#if 0
      fprintf(stderr,"allocating sample %d\n",id);
#endif
      *replaced = 0;
      return(id);
    }

#ifdef DEBUG 
{
  static int replace = 0;
  if(replace == 0)
  {
    eputs("Out of samples: using replacement strategy\n");
    replace =1 ;
  }
}
#endif
    
    /* CLOCKED LRU replacement policy: Search through samples starting 
       with S_REPLACE_SAMP for a sample that does not have its active 
       bit set. Clear bit along the way 
     */
    id = S_REPLACE_SAMP(s);
    while(S_IS_FLAG(id))
    {
      S_CLR_FLAG(id);
      id = (id +1)% S_MAX_SAMP(s);
    }
    S_REPLACE_SAMP(s) = (id +1)% S_MAX_SAMP(s);
    *replaced = 1;
    return(id);
}


Revision:	3.9
Committed:	Mon Jun 30 14:59:12 2003 UTC (20 years, 10 months ago) by schorsch
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rad3R6P1, rad3R6
Changes since 3.8:	+5 -2 lines
Log Message:	Replaced most outdated BSD function calls with their posix equivalents, and cleaned up a few other platform dependencies.
#	User	Rev	Content
1	gwlarson	3.1	#ifndef lint
2	schorsch	3.9	static const char RCSid[] = "$Id: sm_samp.c,v 3.8 2003/06/20 00:25:49 greg Exp $";
3	gwlarson	3.1	#endif
4			/*
5			* sm_samp.c
6			*/
7	schorsch	3.9
8			#include <string.h>
9
10	gwlarson	3.1	#include "standard.h"
11	gwlarson	3.3	#include "sm_flag.h"
12			#include "rhd_sample.h"
13	gwlarson	3.1
14	gwlarson	3.3	SAMP rsL;
15	greg	3.8	int32 *samp_flag=NULL;
16	gwlarson	3.1
17	gwlarson	3.3	/* Each sample has a world coord point, and direction, brightness,chrominance,
18			and RGB triples
19			*/
20	gwlarson	3.6
21	gwlarson	3.3	#define TMSIZE sizeof(TMbright)
22	greg	3.8	#define SAMPSIZ (3sizeof(SFLOAT)+sizeof(int32)+ 6sizeof(BYTE) + TMSIZE + 2*sizeof(int))
23	gwlarson	3.1
24	gwlarson	3.6	/* Extra points world space point, vert flag and qt flag */
25			#define POINTSIZ (3sizeof(SFLOAT) + 2sizeof(int))
26	gwlarson	3.3
27			/* Clear the flags for all samples */
28			sClear_all_flags(s)
29			SAMP *s;
30	gwlarson	3.1	{
31	gwlarson	3.3	if(samp_flag)
32	schorsch	3.9	memset((char *)samp_flag, '\0', FLAG_BYTES(S_MAX_BASE_PT(s)));
33	gwlarson	3.3	}
34	gwlarson	3.1
35	gwlarson	3.3	sInit(s)
36			SAMP *s;
37			{
38			S_REPLACE_SAMP(s) = 0;
39			S_NUM_SAMP(s) = 0;
40			S_TONE_MAP(s) = 0;
41			S_FREE_SAMP(s) = -1;
42			sClear_base_points(s);
43	gwlarson	3.1
44	gwlarson	3.3	}
45	gwlarson	3.1
46	gwlarson	3.3	sFree(s)
47			SAMP *s;
48			{
49			if(S_BASE(s))
50			{
51			free(S_BASE(s));
52			S_BASE(s)=NULL;
53			}
54			if(samp_flag)
55			{
56			free(samp_flag);
57			samp_flag = NULL;
58			}
59			}
60			/* Initialize/clear global smL sample list for at least n samples */
61			SAMP
62			*sAlloc(nptr,extra_points)
63			int *nptr,extra_points;
64			{
65			unsigned nbytes;
66			register unsigned i;
67			SAMP *s;
68			int n;
69
70			s = &rsL;
71	gwlarson	3.1	/* round space up to nearest power of 2 */
72	gwlarson	3.3	nbytes = (nptr)SAMPSIZ + extra_points*POINTSIZ + 8;
73	gwlarson	3.1	for (i = 1024; nbytes > i; i <<= 1)
74			;
75	gwlarson	3.3	/* get number of samples that fit in block */
76			n = (i - 8 - extra_points*POINTSIZ) / SAMPSIZ;
77	gwlarson	3.1
78	greg	3.7	/* Must make sure n + extra_points can fit in a S_ID identifier */
79			if ( n > (S_ID_MAX - extra_points))
80			n = (S_ID_MAX - extra_points);
81
82	gwlarson	3.3	S_BASE(s) = (char )malloc(nSAMPSIZ + extra_points*POINTSIZ);
83			if (!S_BASE(s))
84	gwlarson	3.4	error(SYSTEM,"sAlloc(): Unable to allocate memory");
85	gwlarson	3.1
86			/* assign larger alignment types earlier */
87	gwlarson	3.6	S_W_PT(s) = (SFLOAT(*)[3])S_BASE(s);
88	greg	3.8	S_W_DIR(s) = (int32 *)(S_W_PT(s) + n + extra_points);
89	gwlarson	3.4	S_BRT(s) = (TMbright *)(S_W_DIR(s) + n);
90	gwlarson	3.3	S_CHR(s) = (BYTE (*)[3])(S_BRT(s) + n);
91			S_RGB(s) = (BYTE (*)[3])(S_CHR(s) + n);
92	gwlarson	3.6	S_INFO(s) = (int *)(S_RGB(s)+n);
93			S_INFO1(s) = (int *)(S_INFO(s)+n+extra_points);
94	gwlarson	3.3	S_MAX_SAMP(s) = n;
95			S_MAX_BASE_PT(s) = n + extra_points;
96	gwlarson	3.1
97	gwlarson	3.3	/* Allocate memory for a per/sample bit flag */
98	greg	3.8	if(!(samp_flag = (int32 *)malloc(FLAG_BYTES(n+extra_points))))
99	gwlarson	3.4	error(SYSTEM,"sAlloc(): Unable to allocate flag memory");
100	gwlarson	3.3	sInit(s);
101	gwlarson	3.4	sClear_all_flags(s);
102
103	gwlarson	3.3	*nptr = n;
104
105			return(s);
106	gwlarson	3.1	}
107
108
109	gwlarson	3.3	/* Add a base point to the sample structure: only the world point
110			is added: These points are not displayed-they are used to form the
111			initial mesh
112			*/
113	greg	3.7	S_ID
114	gwlarson	3.3	sAdd_base_point(s,v)
115			SAMP *s;
116			FVECT v;
117	gwlarson	3.1	{
118	greg	3.7	S_ID id;
119	gwlarson	3.1
120			/* Get pointer to next available point */
121	gwlarson	3.3	id = S_NEXT_BASE_PT(s);
122			if(id >= S_MAX_BASE_PT(s))
123	gwlarson	3.1	return(-1);
124
125			/* Update free aux pointer */
126	gwlarson	3.3	S_NEXT_BASE_PT(s)++;
127	gwlarson	3.1
128			/* Copy vector into point */
129	gwlarson	3.3	VCOPY(S_NTH_W_PT(s,id),v);
130	gwlarson	3.1	return(id);
131			}
132
133	gwlarson	3.4	/* Copy the values of sample n_id into sample id: Note must not call with
134			Base point n_id
135			*/
136			int
137			sCopy_samp(s,n_id,id)
138			SAMP *s;
139	greg	3.7	S_ID n_id,id;
140	gwlarson	3.4	{
141
142			#ifdef DEBUG
143			if(id <0\|\|id >= S_MAX_SAMP(s)\|\|n_id <0\|\|n_id >= S_MAX_SAMP(s))
144			{
145			eputs("smReset_sample():invalid sample id\n");
146			return(0);
147			}
148			#endif
149			if(n_id == id)
150			return(1);
151			/* Copy vector into point */
152			VCOPY(S_NTH_W_PT(s,n_id),S_NTH_W_PT(s,id));
153			S_NTH_W_DIR(s,n_id) = S_NTH_W_DIR(s,id);
154
155			S_NTH_BRT(s,n_id) = S_NTH_BRT(s,id);
156			S_NTH_CHR(s,n_id)[0] = S_NTH_CHR(s,id)[0];
157			S_NTH_CHR(s,n_id)[1] = S_NTH_CHR(s,id)[1];
158			S_NTH_CHR(s,n_id)[2] = S_NTH_CHR(s,id)[2];
159
160			return(1);
161			}
162
163
164	gwlarson	3.3	/* Initialize the sample 'id' to contain world point 'p', direction 'd' and
165			color 'c'. If 'p' is NULL, a direction only is represented in 'd'. In
166			this case, the world point is set to the projection of the direction on
167			the view sphere, and the direction value is set to -1
168			*/
169	gwlarson	3.1	void
170	gwlarson	3.5	sInit_samp(s,id,c,d,p,o_id)
171	gwlarson	3.3	SAMP *s;
172	greg	3.7	S_ID id;
173	gwlarson	3.1	COLR c;
174			FVECT d,p;
175	greg	3.7	S_ID o_id;
176	gwlarson	3.1	{
177	gwlarson	3.4
178			if(o_id != INVALID)
179			sCopy_samp(s,id,o_id);
180			else
181			{
182	gwlarson	3.3	/* Copy vector into point */
183			VCOPY(S_NTH_W_PT(s,id),p);
184			if(d)
185			S_NTH_W_DIR(s,id) = encodedir(d);
186			else
187			S_NTH_W_DIR(s,id) = -1;
188	gwlarson	3.1
189	gwlarson	3.4	/* calculate the brightness and chrominance,RGB will be set by
190			tonemapping
191			*/
192	gwlarson	3.3	tmCvColrs(&S_NTH_BRT(s,id),S_NTH_CHR(s,id),c,1);
193	gwlarson	3.4	}
194	gwlarson	3.3	/* Set ACTIVE bit upon creation */
195	gwlarson	3.6	S_SET_FLAG(id);
196	gwlarson	3.5	if(id < S_TONE_MAP(s))
197	gwlarson	3.4	tmMapPixels(S_NTH_RGB(s,id),&S_NTH_BRT(s,id),S_NTH_CHR(s,id),1);
198	gwlarson	3.1	}
199
200
201	gwlarson	3.3	/* Allocate a new sample. If an existing sample was replaced: set flag */
202	greg	3.7	S_ID
203	gwlarson	3.3	sAlloc_samp(s,replaced)
204			SAMP *s;
205	gwlarson	3.2	int *replaced;
206	gwlarson	3.1
207			{
208	greg	3.7	S_ID id;
209	gwlarson	3.1
210	gwlarson	3.4	/* First check if there are any freed sample available */
211	gwlarson	3.3	if((id = S_FREE_SAMP(s)) != INVALID)
212	gwlarson	3.1	{
213	gwlarson	3.6	*replaced = 0;
214			#if 0
215			fprintf(stderr,"allocating previously freed sample %d\n",id);
216			#endif
217	gwlarson	3.4	S_FREE_SAMP(s) = S_NTH_NEXT(s,id);
218	gwlarson	3.3	return(id);
219	gwlarson	3.1	}
220	gwlarson	3.3	/* If havn't reached end of sample array:return next sample */
221			if(S_NUM_SAMP(s) < S_MAX_SAMP(s))
222			{
223	gwlarson	3.6	id = S_NUM_SAMP(s)++;
224			#if 0
225			fprintf(stderr,"allocating sample %d\n",id);
226			#endif
227			*replaced = 0;
228			return(id);
229	gwlarson	3.3	}
230	gwlarson	3.1
231	gwlarson	3.6	#ifdef DEBUG
232	gwlarson	3.1	{
233	gwlarson	3.6	static int replace = 0;
234			if(replace == 0)
235			{
236			eputs("Out of samples: using replacement strategy\n");
237			replace =1 ;
238			}
239			}
240	gwlarson	3.3	#endif
241	gwlarson	3.6
242			/* CLOCKED LRU replacement policy: Search through samples starting
243			with S_REPLACE_SAMP for a sample that does not have its active
244			bit set. Clear bit along the way
245			*/
246			id = S_REPLACE_SAMP(s);
247			while(S_IS_FLAG(id))
248			{
249			S_CLR_FLAG(id);
250			id = (id +1)% S_MAX_SAMP(s);
251			}
252			S_REPLACE_SAMP(s) = (id +1)% S_MAX_SAMP(s);
253			*replaced = 1;
254			return(id);
255	gwlarson	3.1	}
256	greg	3.7
257
258
259
260
261
262	gwlarson	3.4
263
264
265
266
267
268	gwlarson	3.1
269
270
271
272