OpenCores
URL https://opencores.org/ocsvn/bluespec-h264/bluespec-h264/trunk

Subversion Repositories bluespec-h264

[/] [bluespec-h264/] [trunk/] [test/] [decoder/] [ldecod/] [src/] [memalloc.c] - Blame information for rev 14

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 14 jamey.hick 
 
2 
/*!
3 
************************************************************************
4 
* \file  memalloc.c
5 
*
6 
* \brief
7 
*    Memory allocation and free helper funtions
8 
*
9 
* \author
10 
*    Main contributors (see contributors.h for copyright, address and affiliation details)
11 
************************************************************************
12 
*/
13 
 
14 
#include <stdlib.h>
15 
#include "memalloc.h"
16 
 
17 
 
18 
/*!
19 
 ************************************************************************
20 
 * \brief
21 
 *    Allocate 2D memory array -> imgpel array2D[rows][columns]
22 
 *
23 
 * \par Output:
24 
 *    memory size in bytes
25 
 ************************************************************************/
26 
int get_mem2Dpel(imgpel ***array2D, int rows, int columns)
27 
{
28 
  int i;
29 
 
30 
  if((*array2D      = (imgpel**)calloc(rows,        sizeof(imgpel*))) == NULL)
31 
    no_mem_exit("get_mem2Dpel: array2D");
32 
  if(((*array2D)[0] = (imgpel* )calloc(rows*columns,sizeof(imgpel ))) == NULL)
33 
    no_mem_exit("get_mem2Dpel: array2D");
34 
 
35 
  for(i=1 ; i<rows ; i++)
36 
    (*array2D)[i] =  (*array2D)[i-1] + columns  ;
37 
 
38 
  return rows*columns*sizeof(imgpel);
39 
}
40 
 
41 
/*!
42 
 ************************************************************************
43 
 * \brief
44 
 *    Allocate 3D memory array -> imgpel array3D[frames][rows][columns]
45 
 *
46 
 * \par Output:
47 
 *    memory size in bytes
48 
 ************************************************************************
49 
 */
50 
int get_mem3Dpel(imgpel ****array3D, int frames, int rows, int columns)
51 
{
52 
  int  j;
53 
 
54 
  if(((*array3D) = (imgpel***)calloc(frames,sizeof(imgpel**))) == NULL)
55 
    no_mem_exit("get_mem3Dpel: array3D");
56 
 
57 
  for(j=0;j<frames;j++)
58 
    get_mem2Dpel( (*array3D)+j, rows, columns ) ;
59 
 
60 
  return frames*rows*columns*sizeof(imgpel);
61 
}
62 
 
63 
/*!
64 
 ************************************************************************
65 
 * \brief
66 
 *    free 2D memory array
67 
 *    which was alocated with get_mem2Dpel()
68 
 ************************************************************************
69 
 */
70 
void free_mem2Dpel(imgpel **array2D)
71 
{
72 
  if (array2D)
73 
  {
74 
    if (array2D[0])
75 
      free (array2D[0]);
76 
    else error ("free_mem2Dpel: trying to free unused memory",100);
77 
 
78 
    free (array2D);
79 
  } else
80 
  {
81 
    error ("free_mem2Dpel: trying to free unused memory",100);
82 
  }
83 
}
84 
 
85 
/*!
86 
 ************************************************************************
87 
 * \brief
88 
 *    free 3D memory array
89 
 *    which was alocated with get_mem3Dpel()
90 
 ************************************************************************
91 
 */
92 
void free_mem3Dpel(imgpel ***array3D, int frames)
93 
{
94 
  int i;
95 
 
96 
  if (array3D)
97 
  {
98 
    for (i=0;i<frames;i++)
99 
    {
100 
      free_mem2Dpel(array3D[i]);
101 
    }
102 
   free (array3D);
103 
  } else
104 
  {
105 
    error ("free_mem3Dpel: trying to free unused memory",100);
106 
  }
107 
}
108 
 
109 
/*!
110 
 ************************************************************************
111 
 * \brief
112 
 *    Allocate 2D memory array -> unsigned char array2D[rows][columns]
113 
 *
114 
 * \par Output:
115 
 *    memory size in bytes
116 
 ************************************************************************/
117 
// Change 9-Aug-2001 P. List: dont allocate independant row arrays anymore
118 
// but one complete array and move row-pointers to array. Now you can step
119 
// to the next line with an offset of img->width
120 
int get_mem2D(byte ***array2D, int rows, int columns)
121 
{
122 
  int i;
123 
 
124 
  if((*array2D      = (byte**)calloc(rows,        sizeof(byte*))) == NULL)
125 
    no_mem_exit("get_mem2D: array2D");
126 
  if(((*array2D)[0] = (byte* )calloc(columns*rows,sizeof(byte ))) == NULL)
127 
    no_mem_exit("get_mem2D: array2D");
128 
 
129 
  for(i=1;i<rows;i++)
130 
    (*array2D)[i] = (*array2D)[i-1] + columns ;
131 
 
132 
  return rows*columns;
133 
}
134 
 
135 
/*!
136 
 ************************************************************************
137 
 * \brief
138 
 *    Allocate 2D memory array -> int array2D[rows][columns]
139 
 *
140 
 * \par Output:
141 
 *    memory size in bytes
142 
 ************************************************************************
143 
 */
144 
// same change as in get_mem2Dint
145 
int get_mem2Dint(int ***array2D, int rows, int columns)
146 
{
147 
  int i;
148 
 
149 
  if((*array2D      = (int**)calloc(rows,        sizeof(int*))) == NULL)
150 
    no_mem_exit("get_mem2Dint: array2D");
151 
  if(((*array2D)[0] = (int* )calloc(rows*columns,sizeof(int ))) == NULL)
152 
    no_mem_exit("get_mem2Dint: array2D");
153 
 
154 
  for(i=1 ; i<rows ; i++)
155 
    (*array2D)[i] =  (*array2D)[i-1] + columns  ;
156 
 
157 
  return rows*columns*sizeof(int);
158 
}
159 
 
160 
/*!
161 
 ************************************************************************
162 
 * \brief
163 
 *    Allocate 2D memory array -> int64 array2D[rows][columns]
164 
 *
165 
 * \par Output:
166 
 *    memory size in bytes
167 
 ************************************************************************
168 
 */
169 
// same change as in get_mem2Dint
170 
int get_mem2Dint64(int64 ***array2D, int rows, int columns)
171 
{
172 
  int i;
173 
 
174 
  if((*array2D      = (int64**)calloc(rows,        sizeof(int64*))) == NULL)
175 
    no_mem_exit("get_mem2Dint64: array2D");
176 
  if(((*array2D)[0] = (int64* )calloc(rows*columns,sizeof(int64 ))) == NULL)
177 
    no_mem_exit("get_mem2Dint64: array2D");
178 
 
179 
  for(i=1 ; i<rows ; i++)
180 
    (*array2D)[i] =  (*array2D)[i-1] + columns  ;
181 
 
182 
  return rows*columns*sizeof(int64);
183 
}
184 
 
185 
/*!
186 
 ************************************************************************
187 
 * \brief
188 
 *    Allocate 3D memory array -> unsigned char array3D[frames][rows][columns]
189 
 *
190 
 * \par Output:
191 
 *    memory size in bytes
192 
 ************************************************************************
193 
 */
194 
// same change as in get_mem2Dint
195 
int get_mem3D(byte ****array3D, int frames, int rows, int columns)
196 
{
197 
  int  j;
198 
 
199 
  if(((*array3D) = (byte***)calloc(frames,sizeof(byte**))) == NULL)
200 
    no_mem_exit("get_mem3D: array3D");
201 
 
202 
  for(j=0;j<frames;j++)
203 
    get_mem2D( (*array3D)+j, rows, columns ) ;
204 
 
205 
  return frames*rows*columns;
206 
}
207 
 
208 
/*!
209 
 ************************************************************************
210 
 * \brief
211 
 *    Allocate 3D memory array -> int array3D[frames][rows][columns]
212 
 *
213 
 * \par Output:
214 
 *    memory size in bytes
215 
 ************************************************************************
216 
 */
217 
// same change as in get_mem2Dint
218 
int get_mem3Dint(int ****array3D, int frames, int rows, int columns)
219 
{
220 
  int  j;
221 
 
222 
  if(((*array3D) = (int***)calloc(frames,sizeof(int**))) == NULL)
223 
    no_mem_exit("get_mem3Dint: array3D");
224 
 
225 
  for(j=0;j<frames;j++)
226 
    get_mem2Dint( (*array3D)+j, rows, columns ) ;
227 
 
228 
  return frames*rows*columns*sizeof(int);
229 
}
230 
 
231 
/*!
232 
 ************************************************************************
233 
 * \brief
234 
 *    Allocate 3D memory array -> int64 array3D[frames][rows][columns]
235 
 *
236 
 * \par Output:
237 
 *    memory size in bytes
238 
 ************************************************************************
239 
 */
240 
// same change as in get_mem2Dint
241 
int get_mem3Dint64(int64 ****array3D, int frames, int rows, int columns)
242 
{
243 
  int  j;
244 
 
245 
  if(((*array3D) = (int64***)calloc(frames,sizeof(int64**))) == NULL)
246 
    no_mem_exit("get_mem3Dint64: array3D");
247 
 
248 
  for(j=0;j<frames;j++)
249 
    get_mem2Dint64( (*array3D)+j, rows, columns ) ;
250 
 
251 
  return frames*rows*columns*sizeof(int64);
252 
}
253 
 
254 
/*!
255 
 ************************************************************************
256 
 * \brief
257 
 *    Allocate 4D memory array -> int array3D[frames][rows][columns][component]
258 
 *
259 
 * \par Output:
260 
 *    memory size in bytes
261 
 ************************************************************************
262 
 */
263 
// same change as in get_mem2Dint
264 
int get_mem4Dint(int *****array4D, int idx, int frames, int rows, int columns )
265 
{
266 
  int  j;
267 
 
268 
  if(((*array4D) = (int****)calloc(idx,sizeof(int**))) == NULL)
269 
    no_mem_exit("get_mem4Dint: array4D");
270 
 
271 
  for(j=0;j<idx;j++)
272 
    get_mem3Dint( (*array4D)+j, frames, rows, columns ) ;
273 
 
274 
  return idx*frames*rows*columns*sizeof(int);
275 
}
276 
 
277 
/*!
278 
 ************************************************************************
279 
 * \brief
280 
 *    free 2D memory array
281 
 *    which was alocated with get_mem2D()
282 
 ************************************************************************
283 
 */
284 
void free_mem2D(byte **array2D)
285 
{
286 
  if (array2D)
287 
  {
288 
    if (array2D[0])
289 
      free (array2D[0]);
290 
    else error ("free_mem2D: trying to free unused memory",100);
291 
 
292 
    free (array2D);
293 
  } else
294 
  {
295 
    error ("free_mem2D: trying to free unused memory",100);
296 
  }
297 
}
298 
 
299 
/*!
300 
 ************************************************************************
301 
 * \brief
302 
 *    free 2D memory array
303 
 *    which was alocated with get_mem2Dint()
304 
 ************************************************************************
305 
 */
306 
void free_mem2Dint(int **array2D)
307 
{
308 
  if (array2D)
309 
  {
310 
    if (array2D[0])
311 
      free (array2D[0]);
312 
    else error ("free_mem2Dint: trying to free unused memory",100);
313 
 
314 
    free (array2D);
315 
 
316 
  } else
317 
  {
318 
    error ("free_mem2Dint: trying to free unused memory",100);
319 
  }
320 
}
321 
 
322 
/*!
323 
 ************************************************************************
324 
 * \brief
325 
 *    free 2D memory array
326 
 *    which was alocated with get_mem2Dint64()
327 
 ************************************************************************
328 
 */
329 
void free_mem2Dint64(int64 **array2D)
330 
{
331 
  if (array2D)
332 
  {
333 
    if (array2D[0])
334 
      free (array2D[0]);
335 
    else error ("free_mem2Dint64: trying to free unused memory",100);
336 
 
337 
    free (array2D);
338 
 
339 
  } else
340 
  {
341 
    error ("free_mem2Dint64: trying to free unused memory",100);
342 
  }
343 
}
344 
 
345 
 
346 
/*!
347 
 ************************************************************************
348 
 * \brief
349 
 *    free 3D memory array
350 
 *    which was alocated with get_mem3D()
351 
 ************************************************************************
352 
 */
353 
void free_mem3D(byte ***array3D, int frames)
354 
{
355 
  int i;
356 
 
357 
  if (array3D)
358 
  {
359 
    for (i=0;i<frames;i++)
360 
    {
361 
      free_mem2D(array3D[i]);
362 
    }
363 
   free (array3D);
364 
  } else
365 
  {
366 
    error ("free_mem3D: trying to free unused memory",100);
367 
  }
368 
}
369 
 
370 
/*!
371 
 ************************************************************************
372 
 * \brief
373 
 *    free 3D memory array
374 
 *    which was alocated with get_mem3Dint()
375 
 ************************************************************************
376 
 */
377 
void free_mem3Dint(int ***array3D, int frames)
378 
{
379 
  int i;
380 
 
381 
  if (array3D)
382 
  {
383 
    for (i=0;i<frames;i++)
384 
    {
385 
      free_mem2Dint(array3D[i]);
386 
    }
387 
   free (array3D);
388 
  } else
389 
  {
390 
    error ("free_mem3D: trying to free unused memory",100);
391 
  }
392 
}
393 
 
394 
 
395 
/*!
396 
 ************************************************************************
397 
 * \brief
398 
 *    free 3D memory array
399 
 *    which was alocated with get_mem3Dint64()
400 
 ************************************************************************
401 
 */
402 
void free_mem3Dint64(int64 ***array3D, int frames)
403 
{
404 
  int i;
405 
 
406 
  if (array3D)
407 
  {
408 
    for (i=0;i<frames;i++)
409 
    {
410 
      free_mem2Dint64(array3D[i]);
411 
    }
412 
   free (array3D);
413 
  } else
414 
  {
415 
    error ("free_mem3Dint64: trying to free unused memory",100);
416 
  }
417 
}
418 
 
419 
/*!
420 
 ************************************************************************
421 
 * \brief
422 
 *    free 4D memory array
423 
 *    which was alocated with get_mem4Dint()
424 
 ************************************************************************
425 
 */
426 
void free_mem4Dint(int ****array4D, int idx, int frames )
427 
{
428 
  int  j;
429 
 
430 
  if (array4D)
431 
  {
432 
    for(j=0;j<idx;j++)
433 
      free_mem3Dint( array4D[j], frames) ;
434 
    free (array4D);
435 
  } else
436 
  {
437 
    error ("free_mem4D: trying to free unused memory",100);
438 
  }
439 
}
440 
 
441 
 
442 
/*!
443 
 ************************************************************************
444 
 * \brief
445 
 *    Exit program if memory allocation failed (using error())
446 
 * \param where
447 
 *    string indicating which memory allocation failed
448 
 ************************************************************************
449 
 */
450 
void no_mem_exit(char *where)
451 
{
452 
   snprintf(errortext, ET_SIZE, "Could not allocate memory: %s",where);
453 
   error (errortext, 100);
454 
}
455 
 
456 
/*!
457 
 ************************************************************************
458 
 * \brief
459 
 *    Allocate 2D short memory array -> short array2D[rows][columns]
460 
 *
461 
 * \par Output:
462 
 *    memory size in bytes
463 
 ************************************************************************
464 
 */
465 
int get_mem2Dshort(short ***array2D, int rows, int columns)
466 
{
467 
  int i;
468 
 
469 
  if((*array2D      = (short**)calloc(rows,        sizeof(short*))) == NULL)
470 
    no_mem_exit("get_mem2Dshort: array2D");
471 
  if(((*array2D)[0] = (short* )calloc(rows*columns,sizeof(short ))) == NULL)
472 
    no_mem_exit("get_mem2Dshort: array2D");
473 
 
474 
  for(i=1 ; i<rows ; i++)
475 
    (*array2D)[i] =  (*array2D)[i-1] + columns  ;
476 
 
477 
  return rows*columns*sizeof(short);
478 
}
479 
 
480 
/*!
481 
 ************************************************************************
482 
 * \brief
483 
 *    Allocate 3D memory short array -> short array3D[frames][rows][columns]
484 
 *
485 
 * \par Output:
486 
 *    memory size in bytes
487 
 ************************************************************************
488 
 */
489 
int get_mem3Dshort(short ****array3D, int frames, int rows, int columns)
490 
{
491 
  int  j;
492 
 
493 
  if(((*array3D) = (short***)calloc(frames,sizeof(short**))) == NULL)
494 
    no_mem_exit("get_mem3Dshort: array3D");
495 
 
496 
  for(j=0;j<frames;j++)
497 
    get_mem2Dshort( (*array3D)+j, rows, columns ) ;
498 
 
499 
  return frames*rows*columns*sizeof(short);
500 
}
501 
 
502 
/*!
503 
 ************************************************************************
504 
 * \brief
505 
 *    Allocate 4D memory short array -> short array3D[frames][rows][columns][component]
506 
 *
507 
 * \par Output:
508 
 *    memory size in bytes
509 
 ************************************************************************
510 
 */
511 
int get_mem4Dshort(short *****array4D, int idx, int frames, int rows, int columns )
512 
{
513 
  int  j;
514 
 
515 
  if(((*array4D) = (short****)calloc(idx,sizeof(short**))) == NULL)
516 
    no_mem_exit("get_mem4Dshort: array4D");
517 
 
518 
  for(j=0;j<idx;j++)
519 
    get_mem3Dshort( (*array4D)+j, frames, rows, columns ) ;
520 
 
521 
  return idx*frames*rows*columns*sizeof(short);
522 
}
523 
 
524 
/*!
525 
 ************************************************************************
526 
 * \brief
527 
 *    free 2D short memory array
528 
 *    which was allocated with get_mem2Dshort()
529 
 ************************************************************************
530 
 */
531 
void free_mem2Dshort(short **array2D)
532 
{
533 
  if (array2D)
534 
  {
535 
    if (array2D[0])
536 
      free (array2D[0]);
537 
    else error ("free_mem2Dshort: trying to free unused memory",100);
538 
 
539 
    free (array2D);
540 
 
541 
  } else
542 
  {
543 
    error ("free_mem2Dshort: trying to free unused memory",100);
544 
  }
545 
}
546 
 
547 
/*!
548 
 ************************************************************************
549 
 * \brief
550 
 *    free 3D short memory array
551 
 *    which was allocated with get_mem3Dshort()
552 
 ************************************************************************
553 
 */
554 
void free_mem3Dshort(short ***array3D, int frames)
555 
{
556 
  int i;
557 
 
558 
  if (array3D)
559 
  {
560 
    for (i=0;i<frames;i++)
561 
    {
562 
      free_mem2Dshort(array3D[i]);
563 
    }
564 
   free (array3D);
565 
  } else
566 
  {
567 
    error ("free_mem3Dshort: trying to free unused memory",100);
568 
  }
569 
}
570 
 
571 
/*!
572 
 ************************************************************************
573 
 * \brief
574 
 *    free 4D short memory array
575 
 *    which was allocated with get_mem4Dshort()
576 
 ************************************************************************
577 
 */
578 
void free_mem4Dshort(short ****array4D, int idx, int frames )
579 
{
580 
  int  j;
581 
 
582 
  if (array4D)
583 
  {
584 
    for(j=0;j<idx;j++)
585 
      free_mem3Dshort( array4D[j], frames) ;
586 
    free (array4D);
587 
  } else
588 
  {
589 
    error ("free_mem4Dshort: trying to free unused memory",100);
590 
  }
591 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.