1
2 /*!
3 ************************************************************************
4 * \file memalloc.c
5 *
6 * \brief
7 * Memory allocation and free helper functions
8 *
9 * \author
10 * Main contributors (see contributors.h for copyright, address and affiliation details)
11 * - Alexis Michael Tourapis <alexismt@ieee.org>
12 * - Karsten Suehring
13 * - Yuwen He <yhe@dolby.com>
14 *
15 ************************************************************************
16 */
17
18 #include "global.h"
19 #include "memalloc.h"
20
21 /*!
22 ************************************************************************
23 * \brief
24 * Initialize 2-dimensional top and bottom field to point to the proper
25 * lines in frame
26 *
27 * \par Output:
28 * memory size in bytes
29 ************************************************************************/
init_top_bot_planes(imgpel ** imgFrame,int dim0,imgpel *** imgTopField,imgpel *** imgBotField)30 int init_top_bot_planes(imgpel **imgFrame, int dim0, imgpel ***imgTopField, imgpel ***imgBotField)
31 {
32 int i;
33
34 if((*imgTopField = (imgpel**)mem_malloc((dim0>>1) * sizeof(imgpel*))) == NULL)
35 no_mem_exit("init_top_bot_planes: imgTopField");
36
37 if((*imgBotField = (imgpel**)mem_malloc((dim0>>1) * sizeof(imgpel*))) == NULL)
38 no_mem_exit("init_top_bot_planes: imgBotField");
39
40 for(i = 0; i < (dim0>>1); i++)
41 {
42 (*imgTopField)[i] = imgFrame[2 * i ];
43 (*imgBotField)[i] = imgFrame[2 * i + 1];
44 }
45
46 return dim0 * sizeof(imgpel*);
47 }
48
49 /*!
50 ************************************************************************
51 * \brief
52 * free 2-dimensional top and bottom fields without freeing target memory
53 *
54 * \par Output:
55 * memory size in bytes
56 ************************************************************************/
free_top_bot_planes(imgpel ** imgTopField,imgpel ** imgBotField)57 void free_top_bot_planes(imgpel **imgTopField, imgpel **imgBotField)
58 {
59 mem_free (imgTopField);
60 mem_free (imgBotField);
61 }
62
63
64 /*!
65 ************************************************************************
66 * \brief
67 * Allocate 2D memory array -> DistortionData array2D[dim0][dim1]
68 *
69 * \par Output:
70 * memory size in bytes
71 ************************************************************************/
get_mem2Ddist(DistortionData *** array2D,int dim0,int dim1)72 int get_mem2Ddist(DistortionData ***array2D, int dim0, int dim1)
73 {
74 int i;
75
76 if((*array2D = (DistortionData**)mem_malloc(dim0 * sizeof(DistortionData*))) == NULL)
77 no_mem_exit("get_mem2Ddist: array2D");
78 if((*(*array2D) = (DistortionData* )mem_calloc(dim0 * dim1,sizeof(DistortionData ))) == NULL)
79 no_mem_exit("get_mem2Ddist: array2D");
80
81 for(i = 1 ; i < dim0; i++)
82 (*array2D)[i] = (*array2D)[i-1] + dim1;
83
84 return dim0 * (sizeof(DistortionData*) + dim1 * sizeof(DistortionData));
85 }
86
87 /*!
88 ************************************************************************
89 * \brief
90 * Allocate 2D memory array -> LambdaParams array2D[dim0][dim1]
91 *
92 * \par Output:
93 * memory size in bytes
94 ************************************************************************/
get_mem2Dlm(LambdaParams *** array2D,int dim0,int dim1)95 int get_mem2Dlm(LambdaParams ***array2D, int dim0, int dim1)
96 {
97 int i;
98
99 if((*array2D = (LambdaParams**)mem_malloc(dim0 * sizeof(LambdaParams*))) == NULL)
100 no_mem_exit("get_mem2Dlm: array2D");
101 if((*(*array2D) = (LambdaParams* )mem_calloc(dim0 * dim1,sizeof(LambdaParams ))) == NULL)
102 no_mem_exit("get_mem2Dlm: array2D");
103
104 for(i = 1 ; i < dim0; i++)
105 (*array2D)[i] = (*array2D)[i-1] + dim1;
106
107 return dim0 * (sizeof(LambdaParams*) + dim1 * sizeof(LambdaParams));
108 }
109
110 /*!
111 ************************************************************************
112 * \brief
113 * free 2D memory array
114 * which was allocated with get_mem2Ddist()
115 ************************************************************************
116 */
free_mem2Ddist(DistortionData ** array2D)117 void free_mem2Ddist(DistortionData **array2D)
118 {
119 if (array2D)
120 {
121 if (*array2D)
122 mem_free (*array2D);
123 else
124 error ("free_mem2Ddist: trying to free unused memory",100);
125
126 mem_free (array2D);
127 }
128 else
129 {
130 error ("free_mem2Ddist: trying to free unused memory",100);
131 }
132 }
133
134 /*!
135 ************************************************************************
136 * \brief
137 * free 2D memory array
138 * which was allocated with get_mem2Dlm()
139 ************************************************************************
140 */
free_mem2Dlm(LambdaParams ** array2D)141 void free_mem2Dlm(LambdaParams **array2D)
142 {
143 if (array2D)
144 {
145 if (*array2D)
146 mem_free (*array2D);
147 else
148 error ("free_mem2Dlm: trying to free unused memory",100);
149
150 mem_free (array2D);
151 }
152 else
153 {
154 error ("free_mem2Dlm: trying to free unused memory",100);
155 }
156 }
157
158 /*!
159 ************************************************************************
160 * \brief
161 * Allocate 2D memory array -> PicMotionParams array2D[dim0][dim1]
162 *
163 * \par Output:
164 * memory size in bytes
165 ************************************************************************/
get_mem2Dmp(PicMotionParams *** array2D,int dim0,int dim1)166 int get_mem2Dmp(PicMotionParams ***array2D, int dim0, int dim1)
167 {
168 int i;
169
170 if((*array2D = (PicMotionParams**)mem_malloc(dim0 * sizeof(PicMotionParams*))) == NULL)
171 no_mem_exit("get_mem2Dmp: array2D");
172 if((*(*array2D) = (PicMotionParams* )mem_calloc(dim0 * dim1, sizeof(PicMotionParams ))) == NULL)
173 no_mem_exit("get_mem2Dmp: array2D");
174
175 for(i = 1 ; i < dim0; i++)
176 (*array2D)[i] = (*array2D)[i-1] + dim1;
177
178 return dim0 * (sizeof(PicMotionParams*) + dim1 * sizeof(PicMotionParams));
179 }
180
181 /*!
182 ************************************************************************
183 * \brief
184 * Allocate 3D memory array -> PicMotionParams array3D[frames][dim0][dim1]
185 *
186 * \par Output:
187 * memory size in bytes
188 ************************************************************************
189 */
get_mem3Dmp(PicMotionParams **** array3D,int dim0,int dim1,int dim2)190 int get_mem3Dmp(PicMotionParams ****array3D, int dim0, int dim1, int dim2)
191 {
192 int i, mem_size = dim0 * sizeof(PicMotionParams**);
193
194 if(((*array3D) = (PicMotionParams***)mem_malloc(dim0 * sizeof(PicMotionParams**))) == NULL)
195 no_mem_exit("get_mem3Dmp: array3D");
196
197 mem_size += get_mem2Dmp(*array3D, dim0 * dim1, dim2);
198
199 for(i = 1; i < dim0; i++)
200 (*array3D)[i] = (*array3D)[i - 1] + dim1;
201
202 return mem_size;
203 }
204
205 /*!
206 ************************************************************************
207 * \brief
208 * free 2D memory array
209 * which was allocated with get_mem2Dmp()
210 ************************************************************************
211 */
free_mem2Dmp(PicMotionParams ** array2D)212 void free_mem2Dmp(PicMotionParams **array2D)
213 {
214 if (array2D)
215 {
216 if (*array2D)
217 mem_free (*array2D);
218 else
219 error ("free_mem2Dmp: trying to free unused memory",100);
220
221 mem_free (array2D);
222 }
223 else
224 {
225 error ("free_mem2Dmp: trying to free unused memory",100);
226 }
227 }
228
229 /*!
230 ************************************************************************
231 * \brief
232 * free 3D memory array
233 * which was allocated with get_mem3Dmp()
234 ************************************************************************
235 */
free_mem3Dmp(PicMotionParams *** array3D)236 void free_mem3Dmp(PicMotionParams ***array3D)
237 {
238 if (array3D)
239 {
240 free_mem2Dmp(*array3D);
241 mem_free (array3D);
242 }
243 else
244 {
245 error ("free_mem3Dmp: trying to free unused memory",100);
246 }
247 }
248
249 /*!
250 ************************************************************************
251 * \brief
252 * Allocate 2D memory array -> LevelQuantParams array2D[dim0][dim1]
253 *
254 * \par Output:
255 * memory size in bytes
256 ************************************************************************/
get_mem2Dquant(LevelQuantParams *** array2D,int dim0,int dim1)257 int get_mem2Dquant(LevelQuantParams ***array2D, int dim0, int dim1)
258 {
259 int i;
260
261 if((*array2D = (LevelQuantParams**) mem_malloc(dim0 * sizeof(LevelQuantParams*))) == NULL)
262 no_mem_exit("get_mem2Dquant: array2D");
263 if((*(*array2D) = (LevelQuantParams* ) mem_calloc(dim0 * dim1,sizeof(LevelQuantParams ))) == NULL)
264 no_mem_exit("get_mem2Dquant: array2D");
265
266 for(i = 1 ; i < dim0; i++)
267 (*array2D)[i] = (*array2D)[i-1] + dim1;
268
269 return dim0 * (sizeof(LevelQuantParams*) + dim1 * sizeof(LevelQuantParams));
270 }
271
272 /*!
273 ************************************************************************
274 * \brief
275 * Allocate 3D memory array -> LevelQuantParams array3D[dim0][dim1][dim2]
276 *
277 * \par Output:
278 * memory size in bytes
279 ************************************************************************
280 */
get_mem3Dquant(LevelQuantParams **** array3D,int dim0,int dim1,int dim2)281 int get_mem3Dquant(LevelQuantParams ****array3D, int dim0, int dim1, int dim2)
282 {
283 int i, mem_size = dim0 * sizeof(LevelQuantParams**);
284
285 if(((*array3D) = (LevelQuantParams***)mem_malloc(dim0 * sizeof(LevelQuantParams**))) == NULL)
286 no_mem_exit("get_mem3Dquant: array3D");
287
288 mem_size += get_mem2Dquant(*array3D, dim0 * dim1, dim2);
289
290 for(i = 1; i < dim0; i++)
291 (*array3D)[i] = (*array3D)[i - 1] + dim1;
292
293 return mem_size;
294 }
295
296 /*!
297 ************************************************************************
298 * \brief
299 * Allocate 4D memory array -> LevelQuantParams array3D[dim0][dim1][dim2][dim3]
300 *
301 * \par Output:
302 * memory size in bytes
303 ************************************************************************
304 */
get_mem4Dquant(LevelQuantParams ***** array4D,int dim0,int dim1,int dim2,int dim3)305 int get_mem4Dquant(LevelQuantParams *****array4D, int dim0, int dim1, int dim2, int dim3)
306 {
307 int i, mem_size = dim0 * sizeof(LevelQuantParams***);
308
309 if(((*array4D) = (LevelQuantParams****)mem_malloc(dim0 * sizeof(LevelQuantParams***))) == NULL)
310 no_mem_exit("get_mem4Dquant: array4D");
311
312 mem_size += get_mem3Dquant(*array4D, dim0 * dim1, dim2, dim3);
313
314 for(i = 1; i < dim0; i++)
315 (*array4D)[i] = (*array4D)[i - 1] + dim1;
316
317 return mem_size;
318 }
319
320 /*!
321 ************************************************************************
322 * \brief
323 * Allocate 5D memory array -> LevelQuantParams array3D[dim0][dim1][dim2][dim3][dim4]
324 *
325 * \par Output:
326 * memory size in bytes
327 ************************************************************************
328 */
get_mem5Dquant(LevelQuantParams ****** array5D,int dim0,int dim1,int dim2,int dim3,int dim4)329 int get_mem5Dquant(LevelQuantParams ******array5D, int dim0, int dim1, int dim2, int dim3, int dim4)
330 {
331 int i, mem_size = dim0 * sizeof(LevelQuantParams***);
332
333 if(((*array5D) = (LevelQuantParams*****)mem_malloc(dim0 * sizeof(LevelQuantParams****))) == NULL)
334 no_mem_exit("get_mem5Dquant: array5D");
335
336 mem_size += get_mem4Dquant(*array5D, dim0 * dim1, dim2, dim3, dim4);
337
338 for(i = 1; i < dim0; i++)
339 (*array5D)[i] = (*array5D)[i - 1] + dim1;
340
341 return mem_size;
342 }
343
344
345 /*!
346 ************************************************************************
347 * \brief
348 * Allocate 2D memory array -> WPParams array2D[dim0][dim1]
349 *
350 * \par Output:
351 * memory size in bytes
352 ************************************************************************/
get_mem2Dwp(WPParams *** array2D,int dim0,int dim1)353 int get_mem2Dwp(WPParams ***array2D, int dim0, int dim1)
354 {
355 int i;
356
357 if((*array2D = (WPParams**)mem_malloc(dim0 * sizeof(WPParams*))) == NULL)
358 no_mem_exit("get_mem2Dwp: array2D");
359 if((*(*array2D) = (WPParams* )mem_calloc(dim0 * dim1,sizeof(WPParams ))) == NULL)
360 no_mem_exit("get_mem2Dwp: array2D");
361
362 for(i = 1 ; i < dim0; i++)
363 (*array2D)[i] = (*array2D)[i-1] + dim1;
364
365 return dim0 * (sizeof(WPParams*) + dim1 * sizeof(WPParams));
366 }
367
368 /*!
369 ************************************************************************
370 * \brief
371 * free 2D memory array
372 * which was allocated with get_mem2Dwp()
373 ************************************************************************
374 */
free_mem2Dwp(WPParams ** array2D)375 void free_mem2Dwp(WPParams **array2D)
376 {
377 if (array2D)
378 {
379 if (*array2D)
380 mem_free (*array2D);
381 else
382 error ("free_mem2Dwp: trying to free unused memory",100);
383
384 mem_free (array2D);
385 }
386 else
387 {
388 error ("free_mem2Dwp: trying to free unused memory",100);
389 }
390 }
391
392 /*!
393 ************************************************************************
394 * \brief
395 * free 2D memory array
396 * which was allocated with get_mem2Dquant()
397 ************************************************************************
398 */
free_mem2Dquant(LevelQuantParams ** array2D)399 void free_mem2Dquant(LevelQuantParams **array2D)
400 {
401 if (array2D)
402 {
403 if (*array2D)
404 mem_free (*array2D);
405 else
406 error ("free_mem2Dquant: trying to free unused memory",100);
407
408 mem_free (array2D);
409 }
410 else
411 {
412 error ("free_mem2Dquant: trying to free unused memory",100);
413 }
414 }
415
416
417 /*!
418 ************************************************************************
419 * \brief
420 * free 3D memory array
421 * which was allocated with get_mem3Dquant()
422 ************************************************************************
423 */
free_mem3Dquant(LevelQuantParams *** array3D)424 void free_mem3Dquant(LevelQuantParams ***array3D)
425 {
426 if (array3D)
427 {
428 free_mem2Dquant(*array3D);
429 mem_free (array3D);
430 }
431 else
432 {
433 error ("free_mem3Dquant: trying to free unused memory",100);
434 }
435 }
436
437 /*!
438 ************************************************************************
439 * \brief
440 * free 4D memory array
441 * which was allocated with get_mem4Dquant()
442 ************************************************************************
443 */
free_mem4Dquant(LevelQuantParams **** array4D)444 void free_mem4Dquant(LevelQuantParams ****array4D)
445 {
446 if (array4D)
447 {
448 free_mem3Dquant(*array4D);
449 mem_free (array4D);
450 }
451 else
452 {
453 error ("free_mem4Dquant: trying to free unused memory",100);
454 }
455 }
456
457 /*!
458 ************************************************************************
459 * \brief
460 * free 5D memory array
461 * which was allocated with get_mem5Dquant()
462 ************************************************************************
463 */
free_mem5Dquant(LevelQuantParams ***** array5D)464 void free_mem5Dquant(LevelQuantParams *****array5D)
465 {
466 if (array5D)
467 {
468 free_mem4Dquant(*array5D);
469 mem_free (array5D);
470 }
471 else
472 {
473 error ("free_mem5Dquant: trying to free unused memory",100);
474 }
475 }
476
477
478 /*!
479 ************************************************************************
480 * \brief
481 * Allocate 2D memory array -> StorablePicturePtr array2D[dim0][dim1]
482 *
483 * \par Output:
484 * memory size in bytes
485 ************************************************************************/
get_mem2D_spp(StorablePicturePtr *** array2D,int dim0,int dim1)486 int get_mem2D_spp(StorablePicturePtr ***array2D, int dim0, int dim1)
487 {
488 int i;
489
490 if((*array2D = (StorablePicturePtr**)mem_malloc(dim0 * sizeof(StorablePicturePtr*))) == NULL)
491 no_mem_exit("get_mem2D_spp: array2D");
492 if((*(*array2D) = (StorablePicturePtr* )mem_calloc(dim0 * dim1,sizeof(StorablePicturePtr ))) == NULL)
493 no_mem_exit("get_mem2D_spp: array2D");
494
495 for(i = 1 ; i < dim0; i++)
496 (*array2D)[i] = (*array2D)[i-1] + dim1;
497
498 return dim0 * (sizeof(StorablePicturePtr*) + dim1 * sizeof(StorablePicturePtr));
499 }
500
501 /*!
502 ************************************************************************
503 * \brief
504 * Allocate 3D memory array -> StorablePicturePtr array3D[dim0][dim1][dim2]
505 *
506 * \par Output:
507 * memory size in bytes
508 ************************************************************************
509 */
get_mem3D_spp(StorablePicturePtr **** array3D,int dim0,int dim1,int dim2)510 int get_mem3D_spp(StorablePicturePtr ****array3D, int dim0, int dim1, int dim2)
511 {
512 int i, mem_size = dim0 * sizeof(StorablePicturePtr**);
513
514 if(((*array3D) = (StorablePicturePtr***)mem_malloc(dim0 * sizeof(StorablePicturePtr**))) == NULL)
515 no_mem_exit("get_mem3D_spp: array3D");
516
517 mem_size += get_mem2D_spp(*array3D, dim0 * dim1, dim2);
518
519 for(i = 1; i < dim0; i++)
520 (*array3D)[i] = (*array3D)[i - 1] + dim1;
521
522 return mem_size;
523 }
524
525 /*!
526 ************************************************************************
527 * \brief
528 * Allocate 2D memory array -> MotionVector array2D[dim0][dim1]
529 *
530 * \par Output:
531 * memory size in bytes
532 ************************************************************************/
get_mem2Dmv(MotionVector *** array2D,int dim0,int dim1)533 int get_mem2Dmv(MotionVector ***array2D, int dim0, int dim1)
534 {
535 int i;
536
537 if((*array2D = (MotionVector**)mem_malloc(dim0 * sizeof(MotionVector*))) == NULL)
538 no_mem_exit("get_mem2Dmv: array2D");
539 if((*(*array2D) = (MotionVector* )mem_calloc(dim0 * dim1,sizeof(MotionVector ))) == NULL)
540 no_mem_exit("get_mem2Dmv: array2D");
541
542 for(i = 1 ; i < dim0; i++)
543 (*array2D)[i] = (*array2D)[i-1] + dim1;
544
545 return dim0 * (sizeof(MotionVector*) + dim1 * sizeof(MotionVector));
546 }
547
548 /*!
549 ************************************************************************
550 * \brief
551 * Allocate 3D memory array -> MotionVector array3D[dim0][dim1][dim2]
552 *
553 * \par Output:
554 * memory size in bytes
555 ************************************************************************
556 */
get_mem3Dmv(MotionVector **** array3D,int dim0,int dim1,int dim2)557 int get_mem3Dmv(MotionVector ****array3D, int dim0, int dim1, int dim2)
558 {
559 int i, mem_size = dim0 * sizeof(MotionVector**);
560
561 if(((*array3D) = (MotionVector***)mem_malloc(dim0 * sizeof(MotionVector**))) == NULL)
562 no_mem_exit("get_mem3Dmv: array3D");
563
564 mem_size += get_mem2Dmv(*array3D, dim0 * dim1, dim2);
565
566 for(i = 1; i < dim0; i++)
567 (*array3D)[i] = (*array3D)[i - 1] + dim1;
568
569 return mem_size;
570 }
571
572 /*!
573 ************************************************************************
574 * \brief
575 * Allocate 4D memory array -> MotionVector array3D[dim0][dim1][dim2][dim3]
576 *
577 * \par Output:
578 * memory size in bytes
579 ************************************************************************
580 */
get_mem4Dmv(MotionVector ***** array4D,int dim0,int dim1,int dim2,int dim3)581 int get_mem4Dmv(MotionVector *****array4D, int dim0, int dim1, int dim2, int dim3)
582 {
583 int i, mem_size = dim0 * sizeof(MotionVector***);
584
585 if(((*array4D) = (MotionVector****)mem_malloc(dim0 * sizeof(MotionVector***))) == NULL)
586 no_mem_exit("get_mem4Dpel: array4D");
587
588 mem_size += get_mem3Dmv(*array4D, dim0 * dim1, dim2, dim3);
589
590 for(i = 1; i < dim0; i++)
591 (*array4D)[i] = (*array4D)[i - 1] + dim1;
592
593 return mem_size;
594 }
595
596 /*!
597 ************************************************************************
598 * \brief
599 * Allocate 5D memory array -> MotionVector array3D[dim0][dim1][dim2][dim3][dim4]
600 *
601 * \par Output:
602 * memory size in bytes
603 ************************************************************************
604 */
get_mem5Dmv(MotionVector ****** array5D,int dim0,int dim1,int dim2,int dim3,int dim4)605 int get_mem5Dmv(MotionVector ******array5D, int dim0, int dim1, int dim2, int dim3, int dim4)
606 {
607 int i, mem_size = dim0 * sizeof(MotionVector***);
608
609 if(((*array5D) = (MotionVector*****)mem_malloc(dim0 * sizeof(MotionVector****))) == NULL)
610 no_mem_exit("get_mem5Dmv: array5D");
611
612 mem_size += get_mem4Dmv(*array5D, dim0 * dim1, dim2, dim3, dim4);
613
614 for(i = 1; i < dim0; i++)
615 (*array5D)[i] = (*array5D)[i - 1] + dim1;
616
617 return mem_size;
618 }
619
620 /*!
621 ************************************************************************
622 * \brief
623 * Allocate 6D memory array -> MotionVector array6D[dim0][dim1][dim2][dim3][dim4][dim5]
624 *
625 * \par Output:
626 * memory size in bytes
627 ************************************************************************
628 */
get_mem6Dmv(MotionVector ******* array6D,int dim0,int dim1,int dim2,int dim3,int dim4,int dim5)629 int get_mem6Dmv(MotionVector *******array6D, int dim0, int dim1, int dim2, int dim3, int dim4, int dim5)
630 {
631 int i, mem_size = dim0 * sizeof(MotionVector*****);
632
633 if(((*array6D) = (MotionVector******)mem_malloc(dim0 * sizeof(MotionVector*****))) == NULL)
634 no_mem_exit("get_mem6Dmv: array6D");
635
636 mem_size += get_mem5Dmv(*array6D, dim0 * dim1, dim2, dim3, dim4, dim5);
637
638 for(i = 1; i < dim0; i++)
639 (*array6D)[i] = (*array6D)[i - 1] + dim1;
640
641 return mem_size;
642 }
643
644 /*!
645 ************************************************************************
646 * \brief
647 * Allocate 7D memory array -> MotionVector array6D[dim0][dim1][dim2][dim3][dim4][dim5][dim6]
648 *
649 * \par Output:
650 * memory size in bytes
651 ************************************************************************
652 */
get_mem7Dmv(MotionVector ******** array7D,int dim0,int dim1,int dim2,int dim3,int dim4,int dim5,int dim6)653 int get_mem7Dmv(MotionVector ********array7D, int dim0, int dim1, int dim2, int dim3, int dim4, int dim5, int dim6)
654 {
655 int i, mem_size = dim0 * sizeof(MotionVector*****);
656
657 if(((*array7D) = (MotionVector*******)mem_malloc(dim0 * sizeof(MotionVector******))) == NULL)
658 no_mem_exit("get_mem7Dmv: array7D");
659
660 mem_size += get_mem6Dmv(*array7D, dim0 * dim1, dim2, dim3, dim4, dim5, dim6);
661
662 for(i = 1; i < dim0; i++)
663 (*array7D)[i] = (*array7D)[i - 1] + dim1;
664
665 return mem_size;
666 }
667
668
669 /*!
670 ************************************************************************
671 * \brief
672 * free 2D memory array
673 * which was allocated with get_mem2D_spp()
674 ************************************************************************
675 */
free_mem2D_spp(StorablePicturePtr ** array2D)676 void free_mem2D_spp(StorablePicturePtr **array2D)
677 {
678 if (array2D)
679 {
680 if (*array2D)
681 mem_free (*array2D);
682 else
683 error ("free_mem2D_spp: trying to free unused memory",100);
684
685 mem_free (array2D);
686 }
687 else
688 {
689 error ("free_mem2D_spp: trying to free unused memory",100);
690 }
691 }
692
693
694 /*!
695 ************************************************************************
696 * \brief
697 * free 3D memory array
698 * which was allocated with get_mem3D_spp()
699 ************************************************************************
700 */
free_mem3D_spp(StorablePicturePtr *** array3D)701 void free_mem3D_spp(StorablePicturePtr ***array3D)
702 {
703 if (array3D)
704 {
705 free_mem2D_spp(*array3D);
706 mem_free (array3D);
707 }
708 else
709 {
710 error ("free_mem3D_spp: trying to free unused memory",100);
711 }
712 }
713
714
715 /*!
716 ************************************************************************
717 * \brief
718 * free 2D memory array
719 * which was allocated with get_mem2Dmv()
720 ************************************************************************
721 */
free_mem2Dmv(MotionVector ** array2D)722 void free_mem2Dmv(MotionVector **array2D)
723 {
724 if (array2D)
725 {
726 if (*array2D)
727 mem_free (*array2D);
728 else
729 error ("free_mem2Dmv: trying to free unused memory",100);
730
731 mem_free (array2D);
732 }
733 else
734 {
735 error ("free_mem2Dmv: trying to free unused memory",100);
736 }
737 }
738
739
740 /*!
741 ************************************************************************
742 * \brief
743 * free 3D memory array
744 * which was allocated with get_mem3Dmv()
745 ************************************************************************
746 */
free_mem3Dmv(MotionVector *** array3D)747 void free_mem3Dmv(MotionVector ***array3D)
748 {
749 if (array3D)
750 {
751 free_mem2Dmv(*array3D);
752 mem_free (array3D);
753 }
754 else
755 {
756 error ("free_mem3Dmv: trying to free unused memory",100);
757 }
758 }
759
760 /*!
761 ************************************************************************
762 * \brief
763 * free 4D memory array
764 * which was allocated with get_mem4Dmv()
765 ************************************************************************
766 */
free_mem4Dmv(MotionVector **** array4D)767 void free_mem4Dmv(MotionVector ****array4D)
768 {
769 if (array4D)
770 {
771 free_mem3Dmv(*array4D);
772 mem_free (array4D);
773 }
774 else
775 {
776 error ("free_mem4Dmv: trying to free unused memory",100);
777 }
778 }
779
780 /*!
781 ************************************************************************
782 * \brief
783 * free 5D memory array
784 * which was allocated with get_mem5Dmv()
785 ************************************************************************
786 */
free_mem5Dmv(MotionVector ***** array5D)787 void free_mem5Dmv(MotionVector *****array5D)
788 {
789 if (array5D)
790 {
791 free_mem4Dmv(*array5D);
792 mem_free (array5D);
793 }
794 else
795 {
796 error ("free_mem5Dmv: trying to free unused memory",100);
797 }
798 }
799
800 /*!
801 ************************************************************************
802 * \brief
803 * free 6D memory array
804 * which was allocated with get_mem6Dmv()
805 ************************************************************************
806 */
free_mem6Dmv(MotionVector ****** array6D)807 void free_mem6Dmv(MotionVector ******array6D)
808 {
809 if (array6D)
810 {
811 free_mem5Dmv(*array6D);
812 mem_free (array6D);
813 }
814 else
815 {
816 error ("free_mem6Dmv: trying to free unused memory",100);
817 }
818 }
819
820 /*!
821 ************************************************************************
822 * \brief
823 * free 7D memory array
824 * which was allocated with get_mem7Dmv()
825 ************************************************************************
826 */
free_mem7Dmv(MotionVector ******* array7D)827 void free_mem7Dmv(MotionVector *******array7D)
828 {
829 if (array7D)
830 {
831 free_mem6Dmv(*array7D);
832 mem_free (array7D);
833 }
834 else
835 {
836 error ("free_mem7Dmv: trying to free unused memory",100);
837 }
838 }
839
840 /*!
841 ************************************************************************
842 * \brief
843 * Allocate 1D memory array -> imgpel array1D[dim0
844 *
845 * \par Output:
846 * memory size in bytes
847 ************************************************************************/
get_mem1Dpel(imgpel ** array1D,int dim0)848 int get_mem1Dpel(imgpel **array1D, int dim0)
849 {
850 if((*array1D = (imgpel*)mem_calloc(dim0, sizeof(imgpel))) == NULL)
851 no_mem_exit("get_mem1Dpel: array1D");
852
853 return (sizeof(imgpel*) + dim0 * sizeof(imgpel));
854 }
855
856 /*!
857 ************************************************************************
858 * \brief
859 * Allocate 2D memory array -> imgpel array2D[dim0][dim1]
860 *
861 * \par Output:
862 * memory size in bytes
863 ************************************************************************/
get_mem2Dpel(imgpel *** array2D,int dim0,int dim1)864 int get_mem2Dpel(imgpel ***array2D, int dim0, int dim1)
865 {
866 int i;
867
868 if((*array2D = (imgpel**)mem_malloc(dim0 * sizeof(imgpel*))) == NULL)
869 no_mem_exit("get_mem2Dpel: array2D");
870 if((*(*array2D) = (imgpel* )mem_malloc(dim0 * dim1 * sizeof(imgpel ))) == NULL)
871 no_mem_exit("get_mem2Dpel: array2D");
872
873 for(i = 1 ; i < dim0; i++)
874 {
875 (*array2D)[i] = (*array2D)[i-1] + dim1;
876 }
877
878 return dim0 * (sizeof(imgpel*) + dim1 * sizeof(imgpel));
879 }
880
get_mem2Dpel_pad(imgpel *** array2D,int dim0,int dim1,int iPadY,int iPadX)881 int get_mem2Dpel_pad(imgpel ***array2D, int dim0, int dim1, int iPadY, int iPadX)
882 {
883 int i;
884 imgpel *curr = NULL;
885 int iHeight, iWidth;
886
887 iHeight = dim0+2*iPadY;
888 iWidth = dim1+2*iPadX;
889 if((*array2D = (imgpel**)mem_malloc(iHeight*sizeof(imgpel*))) == NULL)
890 no_mem_exit("get_mem2Dpel_pad: array2D");
891 if((*(*array2D) = (imgpel* )mem_calloc(iHeight * iWidth, sizeof(imgpel ))) == NULL)
892 no_mem_exit("get_mem2Dpel_pad: array2D");
893
894 (*array2D)[0] += iPadX;
895 curr = (*array2D)[0];
896 for(i = 1 ; i < iHeight; i++)
897 {
898 curr += iWidth;
899 (*array2D)[i] = curr;
900 }
901 (*array2D) = &((*array2D)[iPadY]);
902
903 return iHeight * (sizeof(imgpel*) + iWidth * sizeof(imgpel));
904 }
905
906
907 /*!
908 ************************************************************************
909 * \brief
910 * Allocate 3D memory array -> imgpel array3D[dim0][dim1][dim2]
911 *
912 * \par Output:
913 * memory size in bytes
914 ************************************************************************
915 */
get_mem3Dpel(imgpel **** array3D,int dim0,int dim1,int dim2)916 int get_mem3Dpel(imgpel ****array3D, int dim0, int dim1, int dim2)
917 {
918 int i, mem_size = dim0 * sizeof(imgpel**);
919
920 if(((*array3D) = (imgpel***)malloc(dim0 * sizeof(imgpel**))) == NULL)
921 no_mem_exit("get_mem3Dpel: array3D");
922
923 mem_size += get_mem2Dpel(*array3D, dim0 * dim1, dim2);
924
925 for(i = 1; i < dim0; i++)
926 (*array3D)[i] = (*array3D)[i - 1] + dim1;
927
928 return mem_size;
929 }
930
get_mem3Dpel_pad(imgpel **** array3D,int dim0,int dim1,int dim2,int iPadY,int iPadX)931 int get_mem3Dpel_pad(imgpel ****array3D, int dim0, int dim1, int dim2, int iPadY, int iPadX)
932 {
933 int i, mem_size = dim0 * sizeof(imgpel**);
934
935 if(((*array3D) = (imgpel***)mem_malloc(dim0*sizeof(imgpel**))) == NULL)
936 no_mem_exit("get_mem3Dpel_pad: array3D");
937
938 for(i = 0; i < dim0; i++)
939 mem_size += get_mem2Dpel_pad((*array3D)+i, dim1, dim2, iPadY, iPadX);
940
941 return mem_size;
942 }
943
944
945 /*!
946 ************************************************************************
947 * \brief
948 * Allocate 4D memory array -> imgpel array4D[dim0][dim1][dim2][dim3]
949 *
950 * \par Output:
951 * memory size in bytes
952 ************************************************************************
953 */
get_mem4Dpel(imgpel ***** array4D,int dim0,int dim1,int dim2,int dim3)954 int get_mem4Dpel(imgpel *****array4D, int dim0, int dim1, int dim2, int dim3)
955 {
956 int i, mem_size = dim0 * sizeof(imgpel***);
957
958 if(((*array4D) = (imgpel****)mem_malloc(dim0 * sizeof(imgpel***))) == NULL)
959 no_mem_exit("get_mem4Dpel: array4D");
960
961 mem_size += get_mem3Dpel(*array4D, dim0 * dim1, dim2, dim3);
962
963 for(i = 1; i < dim0; i++)
964 (*array4D)[i] = (*array4D)[i - 1] + dim1;
965
966 return mem_size;
967 }
968
969
get_mem4Dpel_pad(imgpel ***** array4D,int dim0,int dim1,int dim2,int dim3,int iPadY,int iPadX)970 int get_mem4Dpel_pad(imgpel *****array4D, int dim0, int dim1, int dim2, int dim3, int iPadY, int iPadX)
971 {
972 int i, mem_size = dim0 * sizeof(imgpel***);
973
974 if(((*array4D) = (imgpel****)mem_malloc(dim0 * sizeof(imgpel***))) == NULL)
975 no_mem_exit("get_mem4Dpel_pad: array4D");
976
977 mem_size += get_mem3Dpel_pad(*array4D, dim0 * dim1, dim2, dim3, iPadY, iPadX);
978
979 for(i = 1; i < dim0; i++)
980 (*array4D)[i] = (*array4D)[i - 1] + dim1;
981
982 return mem_size;
983 }
984
985 /*!
986 ************************************************************************
987 * \brief
988 * Allocate 5D memory array -> imgpel array5D[dim0][dim1][dim2][dim3][dim4]
989 *
990 * \par Output:
991 * memory size in bytes
992 ************************************************************************
993 */
get_mem5Dpel(imgpel ****** array5D,int dim0,int dim1,int dim2,int dim3,int dim4)994 int get_mem5Dpel(imgpel ******array5D, int dim0, int dim1, int dim2, int dim3, int dim4)
995 {
996 int i, mem_size = dim0 * sizeof(imgpel****);
997
998 if(((*array5D) = (imgpel*****)mem_malloc(dim0 * sizeof(imgpel****))) == NULL)
999 no_mem_exit("get_mem5Dpel: array5D");
1000
1001 mem_size += get_mem4Dpel(*array5D, dim0 * dim1, dim2, dim3, dim4);
1002
1003 for(i = 1; i < dim0; i++)
1004 (*array5D)[i] = (*array5D)[i - 1] + dim1;
1005
1006 return mem_size;
1007 }
1008
get_mem5Dpel_pad(imgpel ****** array5D,int dim0,int dim1,int dim2,int dim3,int dim4,int iPadY,int iPadX)1009 int get_mem5Dpel_pad(imgpel ******array5D, int dim0, int dim1, int dim2, int dim3, int dim4, int iPadY, int iPadX)
1010 {
1011 int i, mem_size = dim0 * sizeof(imgpel****);
1012
1013 if(((*array5D) = (imgpel*****)mem_malloc(dim0 * sizeof(imgpel****))) == NULL)
1014 no_mem_exit("get_mem5Dpel_pad: array5D");
1015
1016 mem_size += get_mem4Dpel_pad(*array5D, dim0 * dim1, dim2, dim3, dim4, iPadY, iPadX);
1017
1018 for(i = 1; i < dim0; i++)
1019 (*array5D)[i] = (*array5D)[i - 1] + dim1;
1020
1021 return mem_size;
1022 }
1023
1024 /*!
1025 ************************************************************************
1026 * \brief
1027 * free 1D memory array
1028 * which was allocated with get_mem1Dpel()
1029 ************************************************************************
1030 */
free_mem1Dpel(imgpel * array1D)1031 void free_mem1Dpel(imgpel *array1D)
1032 {
1033 if (array1D)
1034 {
1035 mem_free (array1D);
1036 }
1037 else
1038 {
1039 error ("free_mem1Dpel: trying to free unused memory",100);
1040 }
1041 }
1042
1043 /*!
1044 ************************************************************************
1045 * \brief
1046 * free 2D memory array
1047 * which was allocated with get_mem2Dpel()
1048 ************************************************************************
1049 */
free_mem2Dpel(imgpel ** array2D)1050 void free_mem2Dpel(imgpel **array2D)
1051 {
1052 if (array2D)
1053 {
1054 if (*array2D)
1055 mem_free (*array2D);
1056 else
1057 error ("free_mem2Dpel: trying to free unused memory",100);
1058
1059 mem_free (array2D);
1060 }
1061 else
1062 {
1063 error ("free_mem2Dpel: trying to free unused memory",100);
1064 }
1065 }
1066
free_mem2Dpel_pad(imgpel ** array2D,int iPadY,int iPadX)1067 void free_mem2Dpel_pad(imgpel **array2D, int iPadY, int iPadX)
1068 {
1069 if (array2D)
1070 {
1071 if (*array2D)
1072 {
1073 mem_free (array2D[-iPadY]-iPadX);
1074 }
1075 else
1076 error ("free_mem2Dpel_pad: trying to free unused memory",100);
1077
1078 mem_free (&array2D[-iPadY]);
1079 }
1080 else
1081 {
1082 error ("free_mem2Dpel_pad: trying to free unused memory",100);
1083 }
1084 }
1085
1086 /*!
1087 ************************************************************************
1088 * \brief
1089 * free 3D memory array
1090 * which was allocated with get_mem3Dpel()
1091 ************************************************************************
1092 */
free_mem3Dpel(imgpel *** array3D)1093 void free_mem3Dpel(imgpel ***array3D)
1094 {
1095 if (array3D)
1096 {
1097 free_mem2Dpel(*array3D);
1098 mem_free (array3D);
1099 }
1100 else
1101 {
1102 error ("free_mem3Dpel: trying to free unused memory",100);
1103 }
1104 }
1105
free_mem3Dpel_pad(imgpel *** array3D,int iDim12,int iPadY,int iPadX)1106 void free_mem3Dpel_pad(imgpel ***array3D, int iDim12, int iPadY, int iPadX)
1107 {
1108 if (array3D)
1109 {
1110 int i;
1111 for(i=0; i<iDim12; i++)
1112 if(array3D[i])
1113 {
1114 free_mem2Dpel_pad(array3D[i], iPadY, iPadX);
1115 array3D[i] = NULL;
1116 }
1117 mem_free (array3D);
1118 }
1119 else
1120 {
1121 error ("free_mem3Dpel_pad: trying to free unused memory",100);
1122 }
1123
1124 }
1125
1126 /*!
1127 ************************************************************************
1128 * \brief
1129 * free 4D memory array
1130 * which was allocated with get_mem4Dpel()
1131 ************************************************************************
1132 */
free_mem4Dpel(imgpel **** array4D)1133 void free_mem4Dpel(imgpel ****array4D)
1134 {
1135 if (array4D)
1136 {
1137 free_mem3Dpel(*array4D);
1138 mem_free (array4D);
1139 }
1140 else
1141 {
1142 error ("free_mem4Dpel: trying to free unused memory",100);
1143 }
1144 }
1145
free_mem4Dpel_pad(imgpel **** array4D,int iFrames,int iPadY,int iPadX)1146 void free_mem4Dpel_pad(imgpel ****array4D, int iFrames, int iPadY, int iPadX)
1147 {
1148 if (array4D)
1149 {
1150 free_mem3Dpel_pad(*array4D, iFrames, iPadY, iPadX);
1151 mem_free (array4D);
1152 }
1153 else
1154 {
1155 error ("free_mem4Dpel_pad: trying to free unused memory",100);
1156 }
1157 }
1158
1159 /*!
1160 ************************************************************************
1161 * \brief
1162 * free 5D memory array
1163 * which was allocated with get_mem5Dpel()
1164 ************************************************************************
1165 */
free_mem5Dpel(imgpel ***** array5D)1166 void free_mem5Dpel(imgpel *****array5D)
1167 {
1168 if (array5D)
1169 {
1170 free_mem4Dpel(*array5D);
1171 mem_free (array5D);
1172 }
1173 else
1174 {
1175 error ("free_mem5Dpel: trying to free unused memory",100);
1176 }
1177 }
1178
free_mem5Dpel_pad(imgpel ***** array5D,int iFrames,int iPadY,int iPadX)1179 void free_mem5Dpel_pad(imgpel *****array5D, int iFrames, int iPadY, int iPadX)
1180 {
1181 if (array5D)
1182 {
1183 free_mem4Dpel_pad(*array5D, iFrames, iPadY, iPadX);
1184 mem_free(array5D);
1185 }
1186 else
1187 {
1188 error ("free_mem5Dpel_pad: trying to free unused memory",100);
1189 }
1190 }
1191
1192 /*!
1193 ************************************************************************
1194 * \brief
1195 * Create 2D memory array -> byte array2D[dim0][dim1]
1196 *
1197 * \par Output:
1198 * byte type array of size dim0 * dim1
1199 ************************************************************************
1200 */
new_mem2D(int dim0,int dim1)1201 byte** new_mem2D(int dim0, int dim1)
1202 {
1203 int i;
1204 byte **array2D;
1205
1206 if(( array2D = (byte**)mem_malloc(dim0 * sizeof(byte*))) == NULL)
1207 no_mem_exit("get_mem2D: array2D");
1208 if((*(array2D) = (byte* )mem_calloc(dim0 * dim1,sizeof(byte ))) == NULL)
1209 no_mem_exit("get_mem2D: array2D");
1210
1211 for(i = 1; i < dim0; i++)
1212 array2D[i] = array2D[i-1] + dim1;
1213
1214 return (array2D);
1215 }
1216
1217 /*!
1218 ************************************************************************
1219 * \brief
1220 * Allocate 2D memory array -> unsigned char array2D[dim0][dim1]
1221 *
1222 * \par Output:
1223 * memory size in bytes
1224 ************************************************************************/
get_mem2D(byte *** array2D,int dim0,int dim1)1225 int get_mem2D(byte ***array2D, int dim0, int dim1)
1226 {
1227 int i;
1228
1229 if(( *array2D = (byte**)mem_malloc(dim0 * sizeof(byte*))) == NULL)
1230 no_mem_exit("get_mem2D: array2D");
1231 if((*(*array2D) = (byte* )mem_calloc(dim0 * dim1,sizeof(byte ))) == NULL)
1232 no_mem_exit("get_mem2D: array2D");
1233
1234 for(i = 1; i < dim0; i++)
1235 (*array2D)[i] = (*array2D)[i-1] + dim1;
1236
1237 return dim0 * (sizeof(byte*) + dim1 * sizeof(byte));
1238 }
1239
1240
1241 /*!
1242 ************************************************************************
1243 * \brief
1244 * Create 2D memory array -> int array2D[dim0][dim1]
1245 *
1246 * \par Output:
1247 * int type array of size dim0 * dim1
1248 ************************************************************************
1249 */
new_mem2Dint(int dim0,int dim1)1250 int** new_mem2Dint(int dim0, int dim1)
1251 {
1252 int i;
1253 int **array2D;
1254
1255 if((array2D = (int**)mem_malloc(dim0 * sizeof(int*))) == NULL)
1256 no_mem_exit("get_mem2Dint: array2D");
1257 if((*(array2D) = (int* )mem_calloc(dim0 * dim1, sizeof(int ))) == NULL)
1258 no_mem_exit("get_mem2Dint: array2D");
1259
1260 for(i = 1 ; i < dim0; i++)
1261 (array2D)[i] = (array2D)[i-1] + dim1;
1262
1263 return (array2D);
1264 }
1265
1266 /*!
1267 ************************************************************************
1268 * \brief
1269 * Allocate 2D memory array -> int array2D[dim0][dim1]
1270 *
1271 * \par Output:
1272 * memory size in bytes
1273 ************************************************************************
1274 */
get_mem2Dint(int *** array2D,int dim0,int dim1)1275 int get_mem2Dint(int ***array2D, int dim0, int dim1)
1276 {
1277 int i;
1278
1279 if((*array2D = (int**)mem_malloc(dim0 * sizeof(int*))) == NULL)
1280 no_mem_exit("get_mem2Dint: array2D");
1281 if((*(*array2D) = (int* )mem_calloc(dim0 * dim1, sizeof(int ))) == NULL)
1282 no_mem_exit("get_mem2Dint: array2D");
1283
1284 for(i = 1 ; i < dim0; i++)
1285 (*array2D)[i] = (*array2D)[i-1] + dim1;
1286
1287 return dim0 * (sizeof(int*) + dim1 * sizeof(int));
1288 }
1289
get_mem2Dint_pad(int *** array2D,int dim0,int dim1,int iPadY,int iPadX)1290 int get_mem2Dint_pad(int ***array2D, int dim0, int dim1, int iPadY, int iPadX)
1291 {
1292 int i;
1293 int *curr = NULL;
1294 int iHeight, iWidth;
1295
1296 iHeight = dim0+2*iPadY;
1297 iWidth = dim1+2*iPadX;
1298 if((*array2D = (int**)mem_malloc(iHeight*sizeof(int*))) == NULL)
1299 no_mem_exit("get_mem2Dint_pad: array2D");
1300 if((*(*array2D) = (int* )mem_calloc(iHeight * iWidth, sizeof(int ))) == NULL)
1301 no_mem_exit("get_mem2Dint_pad: array2D");
1302
1303 (*array2D)[0] += iPadX;
1304 curr = (*array2D)[0];
1305 for(i = 1 ; i < iHeight; i++)
1306 {
1307 curr += iWidth;
1308 (*array2D)[i] = curr;
1309 }
1310 (*array2D) = &((*array2D)[iPadY]);
1311
1312 return iHeight * (sizeof(int*) + iWidth * sizeof(int));
1313 }
1314
1315 /*!
1316 ************************************************************************
1317 * \brief
1318 * Allocate 2D memory array -> int64 array2D[dim0][dim1]
1319 *
1320 * \par Output:
1321 * memory size in bytes
1322 ************************************************************************
1323 */
get_mem2Dint64(int64 *** array2D,int dim0,int dim1)1324 int get_mem2Dint64(int64 ***array2D, int dim0, int dim1)
1325 {
1326 int i;
1327
1328 if((*array2D = (int64**)mem_malloc(dim0 * sizeof(int64*))) == NULL)
1329 no_mem_exit("get_mem2Dint64: array2D");
1330 if((*(*array2D) = (int64* )mem_calloc(dim0 * dim1,sizeof(int64 ))) == NULL)
1331 no_mem_exit("get_mem2Dint64: array2D");
1332
1333 for(i = 1; i < dim0; i++)
1334 (*array2D)[i] = (*array2D)[i-1] + dim1;
1335
1336 return dim0 * (sizeof(int64*) + dim1 * sizeof(int64));
1337 }
1338
1339 /*!
1340 ************************************************************************
1341 * \brief
1342 * Allocate 3D memory array -> unsigned char array3D[dim0][dim1][dim2]
1343 *
1344 * \par Output:
1345 * memory size in bytes
1346 ************************************************************************
1347 */
get_mem3D(byte **** array3D,int dim0,int dim1,int dim2)1348 int get_mem3D(byte ****array3D, int dim0, int dim1, int dim2)
1349 {
1350 int i, mem_size = dim0 * sizeof(byte**);
1351
1352 if(((*array3D) = (byte***)mem_malloc(dim0 * sizeof(byte**))) == NULL)
1353 no_mem_exit("get_mem3D: array3D");
1354
1355 mem_size += get_mem2D(*array3D, dim0 * dim1, dim2);
1356
1357 for(i = 1; i < dim0; i++)
1358 (*array3D)[i] = (*array3D)[i-1] + dim1;
1359
1360 return mem_size;
1361 }
1362
1363 /*!
1364 ************************************************************************
1365 * \brief
1366 * Allocate 4D memory array -> unsigned char array4D[dim0][dim1][dim2][dim3]
1367 *
1368 * \par Output:
1369 * memory size in bytes
1370 ************************************************************************
1371 */
get_mem4D(byte ***** array4D,int dim0,int dim1,int dim2,int dim3)1372 int get_mem4D(byte *****array4D, int dim0, int dim1, int dim2, int dim3)
1373 {
1374 int i, mem_size = dim0 * sizeof(byte***);
1375
1376 if(((*array4D) = (byte****)mem_malloc(dim0 * sizeof(byte***))) == NULL)
1377 no_mem_exit("get_mem4D: array4D");
1378
1379 mem_size += get_mem3D(*array4D, dim0 * dim1, dim2, dim3);
1380
1381 for(i = 1; i < dim0; i++)
1382 (*array4D)[i] = (*array4D)[i-1] + dim1;
1383
1384 return mem_size;
1385 }
1386
1387 /*!
1388 ************************************************************************
1389 * \brief
1390 * Allocate 3D memory array -> int array3D[dim0][dim1][dim2]
1391 *
1392 * \par Output:
1393 * memory size in bytes
1394 ************************************************************************
1395 */
get_mem3Dint(int **** array3D,int dim0,int dim1,int dim2)1396 int get_mem3Dint(int ****array3D, int dim0, int dim1, int dim2)
1397 {
1398 int i, mem_size = dim0 * sizeof(int**);
1399
1400 if(((*array3D) = (int***)mem_malloc(dim0 * sizeof(int**))) == NULL)
1401 no_mem_exit("get_mem3Dint: array3D");
1402
1403 mem_size += get_mem2Dint(*array3D, dim0 * dim1, dim2);
1404
1405 for(i = 1; i < dim0; i++)
1406 (*array3D)[i] = (*array3D)[i-1] + dim1;
1407
1408 return mem_size;
1409 }
1410
1411 /*!
1412 ************************************************************************
1413 * \brief
1414 * Allocate 3D memory array -> int64 array3D[dim0][dim1][dim2]
1415 *
1416 * \par Output:
1417 * memory size in bytes
1418 ************************************************************************
1419 */
get_mem3Dint64(int64 **** array3D,int dim0,int dim1,int dim2)1420 int get_mem3Dint64(int64 ****array3D, int dim0, int dim1, int dim2)
1421 {
1422 int i, mem_size = dim0 * sizeof(int64**);
1423
1424 if(((*array3D) = (int64***)mem_malloc(dim0 * sizeof(int64**))) == NULL)
1425 no_mem_exit("get_mem3Dint64: array3D");
1426
1427 mem_size += get_mem2Dint64(*array3D, dim0 * dim1, dim2);
1428
1429 for(i = 1; i < dim0; i++)
1430 (*array3D)[i] = (*array3D)[i-1] + dim1;
1431
1432 return mem_size;
1433 }
1434
get_mem2Ddistblk(distblk *** array2D,int dim0,int dim1)1435 int get_mem2Ddistblk(distblk ***array2D, int dim0, int dim1)
1436 {
1437 int i;
1438
1439 if((*array2D = (distblk**)mem_malloc(dim0 * sizeof(distblk*))) == NULL)
1440 no_mem_exit("get_mem2Ddistblk: array2D");
1441 if((*(*array2D) = (distblk* )mem_calloc(dim0 * dim1,sizeof(distblk ))) == NULL)
1442 no_mem_exit("get_mem2Ddistblk: array2D");
1443
1444 for(i = 1; i < dim0; i++)
1445 (*array2D)[i] = (*array2D)[i-1] + dim1;
1446
1447 return dim0 * (sizeof(distblk*) + dim1 * sizeof(distblk));
1448 }
1449
get_mem3Ddistblk(distblk **** array3D,int dim0,int dim1,int dim2)1450 int get_mem3Ddistblk(distblk ****array3D, int dim0, int dim1, int dim2)
1451 {
1452 int i, mem_size = dim0 * sizeof(distblk**);
1453
1454 if(((*array3D) = (distblk***)mem_malloc(dim0 * sizeof(distblk**))) == NULL)
1455 no_mem_exit("get_mem3Ddistblk: array3D");
1456
1457 mem_size += get_mem2Ddistblk(*array3D, dim0 * dim1, dim2);
1458
1459 for(i = 1; i < dim0; i++)
1460 (*array3D)[i] = (*array3D)[i-1] + dim1;
1461
1462 return mem_size;
1463 }
1464
get_mem4Ddistblk(distblk ***** array4D,int dim0,int dim1,int dim2,int dim3)1465 int get_mem4Ddistblk(distblk *****array4D, int dim0, int dim1, int dim2, int dim3)
1466 {
1467 int i, mem_size = dim0 * sizeof(distblk***);
1468
1469 if(((*array4D) = (distblk****)mem_malloc(dim0 * sizeof(distblk***))) == NULL)
1470 no_mem_exit("get_mem4Ddistblk: array4D");
1471
1472 mem_size += get_mem3Ddistblk(*array4D, dim0 * dim1, dim2, dim3);
1473
1474 for(i = 1; i < dim0; i++)
1475 (*array4D)[i] = (*array4D)[i-1] + dim1;
1476
1477 return mem_size;
1478 }
1479 /*!
1480 ************************************************************************
1481 * \brief
1482 * Allocate 4D memory array -> int array4D[dim0][dim1][dim2][dim3]
1483 *
1484 * \par Output:
1485 * memory size in bytes
1486 ************************************************************************
1487 */
get_mem4Dint(int ***** array4D,int dim0,int dim1,int dim2,int dim3)1488 int get_mem4Dint(int *****array4D, int dim0, int dim1, int dim2, int dim3)
1489 {
1490 int i, mem_size = dim0 * sizeof(int***);
1491
1492 if(((*array4D) = (int****)mem_malloc(dim0 * sizeof(int***))) == NULL)
1493 no_mem_exit("get_mem4Dint: array4D");
1494
1495 mem_size += get_mem3Dint(*array4D, dim0 * dim1, dim2, dim3);
1496
1497 for(i = 1; i < dim0; i++)
1498 (*array4D)[i] = (*array4D)[i-1] + dim1;
1499
1500 return mem_size;
1501 }
1502
get_mem4Dint64(int64 ***** array4D,int dim0,int dim1,int dim2,int dim3)1503 int get_mem4Dint64(int64 *****array4D, int dim0, int dim1, int dim2, int dim3)
1504 {
1505 int i, mem_size = dim0 * sizeof(int64***);
1506
1507 if(((*array4D) = (int64****)mem_malloc(dim0 * sizeof(int64***))) == NULL)
1508 no_mem_exit("get_mem4Dint64: array4D");
1509
1510 mem_size += get_mem3Dint64(*array4D, dim0 * dim1, dim2, dim3);
1511
1512 for(i = 1; i < dim0; i++)
1513 (*array4D)[i] = (*array4D)[i-1] + dim1;
1514
1515 return mem_size;
1516 }
1517
1518 /*!
1519 ************************************************************************
1520 * \brief
1521 * Allocate 5D memory array -> int array5D[dim0][dim1][dim2][dim3][dim4]
1522 *
1523 * \par Output:
1524 * memory size in bytes
1525 ************************************************************************
1526 */
get_mem5Dint(int ****** array5D,int dim0,int dim1,int dim2,int dim3,int dim4)1527 int get_mem5Dint(int ******array5D, int dim0, int dim1, int dim2, int dim3, int dim4)
1528 {
1529 int i, mem_size = dim0 * sizeof(int****);
1530
1531 if(((*array5D) = (int*****)mem_malloc(dim0 * sizeof(int****))) == NULL)
1532 no_mem_exit("get_mem5Dint: array5D");
1533
1534 mem_size += get_mem4Dint(*array5D, dim0 * dim1, dim2, dim3, dim4);
1535
1536 for(i = 1; i < dim0; i++)
1537 (*array5D)[i] = (*array5D)[i-1] + dim1;
1538
1539 return mem_size;
1540 }
1541
1542
1543 /*!
1544 ************************************************************************
1545 * \brief
1546 * free 2D memory array
1547 * which was allocated with get_mem2D()
1548 ************************************************************************
1549 */
free_mem2D(byte ** array2D)1550 void free_mem2D(byte **array2D)
1551 {
1552 if (array2D)
1553 {
1554 if (*array2D)
1555 mem_free (*array2D);
1556 else
1557 error ("free_mem2D: trying to free unused memory",100);
1558
1559 mem_free (array2D);
1560 }
1561 else
1562 {
1563 error ("free_mem2D: trying to free unused memory",100);
1564 }
1565 }
1566
1567 /*!
1568 ************************************************************************
1569 * \brief
1570 * free 2D memory array
1571 * which was allocated with get_mem2Dint()
1572 ************************************************************************
1573 */
free_mem2Dint(int ** array2D)1574 void free_mem2Dint(int **array2D)
1575 {
1576 if (array2D)
1577 {
1578 if (*array2D)
1579 mem_free (*array2D);
1580 else
1581 error ("free_mem2Dint: trying to free unused memory",100);
1582
1583 mem_free (array2D);
1584 }
1585 else
1586 {
1587 error ("free_mem2Dint: trying to free unused memory",100);
1588 }
1589 }
1590
free_mem2Dint_pad(int ** array2D,int iPadY,int iPadX)1591 void free_mem2Dint_pad(int **array2D, int iPadY, int iPadX)
1592 {
1593 if (array2D)
1594 {
1595 if (*array2D)
1596 mem_free (array2D[-iPadY]-iPadX);
1597 else
1598 error ("free_mem2Dint_pad: trying to free unused memory",100);
1599
1600 mem_free (&array2D[-iPadY]);
1601 }
1602 else
1603 {
1604 error ("free_mem2Dint_pad: trying to free unused memory",100);
1605 }
1606 }
1607
1608 /*!
1609 ************************************************************************
1610 * \brief
1611 * free 2D memory array
1612 * which was allocated with get_mem2Dint64()
1613 ************************************************************************
1614 */
free_mem2Dint64(int64 ** array2D)1615 void free_mem2Dint64(int64 **array2D)
1616 {
1617 if (array2D)
1618 {
1619 if (*array2D)
1620 mem_free (*array2D);
1621 else
1622 error ("free_mem2Dint64: trying to free unused memory",100);
1623 mem_free (array2D);
1624 }
1625 else
1626 {
1627 error ("free_mem2Dint64: trying to free unused memory",100);
1628 }
1629 }
1630
1631
1632 /*!
1633 ************************************************************************
1634 * \brief
1635 * free 3D memory array
1636 * which was allocated with get_mem3D()
1637 ************************************************************************
1638 */
free_mem3D(byte *** array3D)1639 void free_mem3D(byte ***array3D)
1640 {
1641 if (array3D)
1642 {
1643 free_mem2D(*array3D);
1644 mem_free (array3D);
1645 }
1646 else
1647 {
1648 error ("free_mem3D: trying to free unused memory",100);
1649 }
1650 }
1651
1652 /*!
1653 ************************************************************************
1654 * \brief
1655 * free 4D memory array
1656 * which was allocated with get_mem3D()
1657 ************************************************************************
1658 */
free_mem4D(byte **** array4D)1659 void free_mem4D(byte ****array4D)
1660 {
1661 if (array4D)
1662 {
1663 free_mem3D(*array4D);
1664 mem_free (array4D);
1665 }
1666 else
1667 {
1668 error ("free_mem4D: trying to free unused memory",100);
1669 }
1670 }
1671
1672 /*!
1673 ************************************************************************
1674 * \brief
1675 * free 3D memory array
1676 * which was allocated with get_mem3Dint()
1677 ************************************************************************
1678 */
free_mem3Dint(int *** array3D)1679 void free_mem3Dint(int ***array3D)
1680 {
1681 if (array3D)
1682 {
1683 free_mem2Dint(*array3D);
1684 mem_free (array3D);
1685 }
1686 else
1687 {
1688 error ("free_mem3Dint: trying to free unused memory",100);
1689 }
1690 }
1691
1692
1693 /*!
1694 ************************************************************************
1695 * \brief
1696 * free 3D memory array
1697 * which was allocated with get_mem3Dint64()
1698 ************************************************************************
1699 */
free_mem3Dint64(int64 *** array3D)1700 void free_mem3Dint64(int64 ***array3D)
1701 {
1702 if (array3D)
1703 {
1704 free_mem2Dint64(*array3D);
1705 mem_free (array3D);
1706 }
1707 else
1708 {
1709 error ("free_mem3Dint64: trying to free unused memory",100);
1710 }
1711 }
1712
free_mem3Ddistblk(distblk *** array3D)1713 void free_mem3Ddistblk(distblk ***array3D)
1714 {
1715 if (array3D)
1716 {
1717 free_mem2Ddistblk(*array3D);
1718 mem_free (array3D);
1719 }
1720 else
1721 {
1722 error ("free_mem3Ddistblk: trying to free unused memory",100);
1723 }
1724 }
1725
1726 /*!
1727 ************************************************************************
1728 * \brief
1729 * free 4D memory array
1730 * which was allocated with get_mem4Dint()
1731 ************************************************************************
1732 */
free_mem4Dint(int **** array4D)1733 void free_mem4Dint(int ****array4D)
1734 {
1735 if (array4D)
1736 {
1737 free_mem3Dint( *array4D);
1738 mem_free (array4D);
1739 } else
1740 {
1741 error ("free_mem4Dint: trying to free unused memory",100);
1742 }
1743 }
1744
free_mem4Dint64(int64 **** array4D)1745 void free_mem4Dint64(int64 ****array4D)
1746 {
1747 if (array4D)
1748 {
1749 free_mem3Dint64( *array4D);
1750 mem_free (array4D);
1751 } else
1752 {
1753 error ("free_mem4Dint64: trying to free unused memory",100);
1754 }
1755 }
1756
free_mem4Ddistblk(distblk **** array4D)1757 void free_mem4Ddistblk(distblk ****array4D)
1758 {
1759 if (array4D)
1760 {
1761 free_mem3Ddistblk( *array4D);
1762 mem_free (array4D);
1763 } else
1764 {
1765 error ("free_mem4Ddistblk: trying to free unused memory",100);
1766 }
1767 }
1768
1769 /*!
1770 ************************************************************************
1771 * \brief
1772 * free 5D int memory array
1773 * which was allocated with get_mem5Dint()
1774 ************************************************************************
1775 */
free_mem5Dint(int ***** array5D)1776 void free_mem5Dint(int *****array5D)
1777 {
1778 if (array5D)
1779 {
1780 free_mem4Dint( *array5D);
1781 mem_free (array5D);
1782 } else
1783 {
1784 error ("free_mem5Dint: trying to free unused memory",100);
1785 }
1786 }
1787
1788 /*!
1789 ************************************************************************
1790 * \brief
1791 * Exit program if memory allocation failed (using error())
1792 * \param where
1793 * string indicating which memory allocation failed
1794 ************************************************************************
1795 */
no_mem_exit(char * where)1796 void no_mem_exit(char *where)
1797 {
1798 snprintf(errortext, ET_SIZE, "Could not allocate memory: %s",where);
1799 error (errortext, 100);
1800 }
1801
1802
1803 /*!
1804 ************************************************************************
1805 * \brief
1806 * Create 2D memory array -> uint16 array2D[dim0][dim1]
1807 *
1808 * \par Output:
1809 * uint16 type array of size dim0 * dim1
1810 ************************************************************************
1811 */
new_mem2Duint16(int dim0,int dim1)1812 uint16** new_mem2Duint16(int dim0, int dim1)
1813 {
1814 int i;
1815 uint16 **array2D;
1816
1817 if(( array2D = (uint16**)mem_malloc(dim0 * sizeof(uint16*))) == NULL)
1818 no_mem_exit("get_mem2Duint16: array2D");
1819 if((*array2D = (uint16* )mem_calloc(dim0 * dim1,sizeof(uint16 ))) == NULL)
1820 no_mem_exit("get_mem2Duint16: array2D");
1821
1822 for(i = 1; i < dim0; i++)
1823 array2D[i] = array2D[i-1] + dim1;
1824
1825 return (array2D);
1826 }
1827
1828 /*!
1829 ************************************************************************
1830 * \brief
1831 * Allocate 2D uint16 memory array -> uint16 array2D[dim0][dim1]
1832 *
1833 * \par Output:
1834 * memory size in bytes
1835 ************************************************************************
1836 */
get_mem2Duint16(uint16 *** array2D,int dim0,int dim1)1837 int get_mem2Duint16(uint16 ***array2D, int dim0, int dim1)
1838 {
1839 int i;
1840
1841 if(( *array2D = (uint16**)mem_malloc(dim0 * sizeof(uint16*))) == NULL)
1842 no_mem_exit("get_mem2Duint16: array2D");
1843
1844 if((*(*array2D) = (uint16* )mem_calloc(dim0 * dim1,sizeof(uint16 ))) == NULL)
1845 no_mem_exit("get_mem2Duint16: array2D");
1846
1847 for(i = 1; i < dim0; i++)
1848 (*array2D)[i] = (*array2D)[i-1] + dim1;
1849
1850 return dim0 * (sizeof(uint16*) + dim1 * sizeof(uint16));
1851 }
1852
1853 /*!
1854 ************************************************************************
1855 * \brief
1856 * Allocate 3D memory uint16 array -> uint16 array3D[dim0][dim1][dim2]
1857 *
1858 * \par Output:
1859 * memory size in bytes
1860 ************************************************************************
1861 */
get_mem3Duint16(uint16 **** array3D,int dim0,int dim1,int dim2)1862 int get_mem3Duint16(uint16 ****array3D,int dim0, int dim1, int dim2)
1863 {
1864 int i, mem_size = dim0 * sizeof(uint16**);
1865
1866 if(((*array3D) = (uint16***)mem_malloc(dim0 * sizeof(uint16**))) == NULL)
1867 no_mem_exit("get_mem3Duint16: array3D");
1868
1869 mem_size += get_mem2Duint16(*array3D, dim0 * dim1, dim2);
1870
1871 for(i = 1; i < dim0; i++)
1872 (*array3D)[i] = (*array3D)[i-1] + dim1;
1873
1874 return mem_size;
1875 }
1876
1877
1878 /*!
1879 ************************************************************************
1880 * \brief
1881 * Allocate 4D memory uint16 array -> uint16 array3D[dim0][dim1][dim2][dim3]
1882 *
1883 * \par Output:
1884 * memory size in bytes
1885 ************************************************************************
1886 */
get_mem4Duint16(uint16 ***** array4D,int dim0,int dim1,int dim2,int dim3)1887 int get_mem4Duint16(uint16 *****array4D, int dim0, int dim1, int dim2, int dim3)
1888 {
1889 int i, mem_size = dim0 * sizeof(uint16***);
1890
1891 if(((*array4D) = (uint16****)mem_malloc(dim0 * sizeof(uint16***))) == NULL)
1892 no_mem_exit("get_mem4Duint16: array4D");
1893
1894 mem_size += get_mem3Duint16(*array4D, dim0 * dim1, dim2, dim3);
1895
1896 for(i = 1; i < dim0; i++)
1897 (*array4D)[i] = (*array4D)[i-1] + dim1;
1898
1899 return mem_size;
1900 }
1901
1902 /*!
1903 ************************************************************************
1904 * \brief
1905 * Allocate 2D short memory array -> short array2D[dim0][dim1]
1906 *
1907 * \par Output:
1908 * memory size in bytes
1909 ************************************************************************
1910 */
get_mem2Dshort(short *** array2D,int dim0,int dim1)1911 int get_mem2Dshort(short ***array2D, int dim0, int dim1)
1912 {
1913 int i;
1914 short *curr = NULL;
1915
1916 if(( *array2D = (short**)mem_malloc(dim0 * sizeof(short*))) == NULL)
1917 no_mem_exit("get_mem2Dshort: array2D");
1918 if((*(*array2D) = (short* )mem_calloc(dim0 * dim1,sizeof(short ))) == NULL)
1919 no_mem_exit("get_mem2Dshort: array2D");
1920
1921 curr = (*array2D)[0];
1922 for(i = 1; i < dim0; i++)
1923 {
1924 curr += dim1;
1925 (*array2D)[i] = curr;
1926 }
1927
1928 return dim0 * (sizeof(short*) + dim1 * sizeof(short));
1929 }
1930
1931 /*!
1932 ************************************************************************
1933 * \brief
1934 * Allocate 3D memory short array -> short array3D[dim0][dim1][dim2]
1935 *
1936 * \par Output:
1937 * memory size in bytes
1938 ************************************************************************
1939 */
get_mem3Dshort(short **** array3D,int dim0,int dim1,int dim2)1940 int get_mem3Dshort(short ****array3D,int dim0, int dim1, int dim2)
1941 {
1942 int i, mem_size = dim0 * sizeof(short**);
1943 short **curr = NULL;
1944
1945 if(((*array3D) = (short***)mem_malloc(dim0 * sizeof(short**))) == NULL)
1946 no_mem_exit("get_mem3Dshort: array3D");
1947
1948 mem_size += get_mem2Dshort(*array3D, dim0 * dim1, dim2);
1949
1950 curr = (*array3D)[0];
1951 for(i = 1; i < dim0; i++)
1952 {
1953 curr += dim1;
1954 (*array3D)[i] = curr;
1955 }
1956
1957 return mem_size;
1958 }
1959
1960
1961 /*!
1962 ************************************************************************
1963 * \brief
1964 * Allocate 4D memory short array -> short array3D[dim0][dim1][dim2][dim3]
1965 *
1966 * \par Output:
1967 * memory size in bytes
1968 ************************************************************************
1969 */
get_mem4Dshort(short ***** array4D,int dim0,int dim1,int dim2,int dim3)1970 int get_mem4Dshort(short *****array4D, int dim0, int dim1, int dim2, int dim3)
1971 {
1972 int i, mem_size = dim0 * sizeof(short***);
1973
1974 if(((*array4D) = (short****)mem_malloc(dim0 * sizeof(short***))) == NULL)
1975 no_mem_exit("get_mem4Dshort: array4D");
1976
1977 mem_size += get_mem3Dshort(*array4D, dim0 * dim1, dim2, dim3);
1978
1979 for(i = 1; i < dim0; i++)
1980 (*array4D)[i] = (*array4D)[i-1] + dim1;
1981
1982 return mem_size;
1983 }
1984
1985 /*!
1986 ************************************************************************
1987 * \brief
1988 * Allocate 5D memory array -> short array5D[dim0][dim1][dim2][dim3][dim4]
1989 *
1990 * \par Output:
1991 * memory size in bytes
1992 ************************************************************************
1993 */
get_mem5Dshort(short ****** array5D,int dim0,int dim1,int dim2,int dim3,int dim4)1994 int get_mem5Dshort(short ******array5D, int dim0, int dim1, int dim2, int dim3, int dim4)
1995 {
1996 int i, mem_size = dim0 * sizeof(short****);
1997
1998 if(((*array5D) = (short*****)mem_malloc(dim0 * sizeof(short****))) == NULL)
1999 no_mem_exit("get_mem5Dshort: array5D");
2000
2001 mem_size += get_mem4Dshort(*array5D, dim0 * dim1, dim2, dim3, dim4);
2002
2003 for(i = 1; i < dim0; i++)
2004 (*array5D)[i] = (*array5D)[i-1] + dim1;
2005
2006 return mem_size;
2007 }
2008
2009 /*!
2010 ************************************************************************
2011 * \brief
2012 * Allocate 6D memory array -> short array6D[dim0][dim1][dim2][dim3][dim4][dim5]
2013 *
2014 * \par Output:
2015 * memory size in bytes
2016 ************************************************************************
2017 */
get_mem6Dshort(short ******* array6D,int dim0,int dim1,int dim2,int dim3,int dim4,int dim5)2018 int get_mem6Dshort(short *******array6D, int dim0, int dim1, int dim2, int dim3, int dim4, int dim5)
2019 {
2020 int i, mem_size = dim0 * sizeof(short*****);
2021
2022 if(((*array6D) = (short******)mem_malloc(dim0 * sizeof(short*****))) == NULL)
2023 no_mem_exit("get_mem6Dshort: array6D");
2024
2025 mem_size += get_mem5Dshort(*array6D, dim0 * dim1, dim2, dim3, dim4, dim5);
2026
2027 for(i = 1; i < dim0; i++)
2028 (*array6D)[i] = (*array6D)[i-1] + dim1;
2029
2030 return mem_size;
2031 }
2032
2033 /*!
2034 ************************************************************************
2035 * \brief
2036 * Allocate 7D memory array -> short array7D[dim0][dim1][dim2][dim3][dim4][dim5][dim6]
2037 *
2038 * \par Output:
2039 * memory size in bytes
2040 ************************************************************************
2041 */
get_mem7Dshort(short ******** array7D,int dim0,int dim1,int dim2,int dim3,int dim4,int dim5,int dim6)2042 int get_mem7Dshort(short ********array7D, int dim0, int dim1, int dim2, int dim3, int dim4, int dim5, int dim6)
2043 {
2044 int i, mem_size = dim0 * sizeof(short******);
2045
2046 if(((*array7D) = (short*******)mem_malloc(dim0 * sizeof(short******))) == NULL)
2047 no_mem_exit("get_mem7Dshort: array7D");
2048
2049 mem_size += get_mem6Dshort(*array7D, dim0 * dim1, dim2, dim3, dim4, dim5, dim6);
2050
2051 for(i = 1; i < dim0; i++)
2052 (*array7D)[i] = (*array7D)[i-1] + dim1;
2053
2054 return mem_size;
2055 }
2056
2057 /*!
2058 ************************************************************************
2059 * \brief
2060 * free 2D uint16 memory array
2061 * which was allocated with get_mem2Duint16()
2062 ************************************************************************
2063 */
free_mem2Duint16(uint16 ** array2D)2064 void free_mem2Duint16(uint16 **array2D)
2065 {
2066 if (array2D)
2067 {
2068 if (*array2D)
2069 mem_free (*array2D);
2070 else error ("free_mem2Duint16: trying to free unused memory",100);
2071
2072 mem_free (array2D);
2073 }
2074 else
2075 {
2076 error ("free_mem2Duint16: trying to free unused memory",100);
2077 }
2078 }
2079
2080 /*!
2081 ************************************************************************
2082 * \brief
2083 * free 3D uint16 memory array
2084 * which was allocated with get_mem3Duint16()
2085 ************************************************************************
2086 */
free_mem3Duint16(uint16 *** array3D)2087 void free_mem3Duint16(uint16 ***array3D)
2088 {
2089 if (array3D)
2090 {
2091 free_mem2Duint16(*array3D);
2092 mem_free (array3D);
2093 }
2094 else
2095 {
2096 error ("free_mem3Duint16: trying to free unused memory",100);
2097 }
2098 }
2099
2100 /*!
2101 ************************************************************************
2102 * \brief
2103 * free 4D uint16 memory array
2104 * which was allocated with get_mem4Duint16()
2105 ************************************************************************
2106 */
free_mem4Duint16(uint16 **** array4D)2107 void free_mem4Duint16(uint16 ****array4D)
2108 {
2109 if (array4D)
2110 {
2111 free_mem3Duint16( *array4D);
2112 mem_free (array4D);
2113 }
2114 else
2115 {
2116 error ("free_mem4Duint16: trying to free unused memory",100);
2117 }
2118 }
2119
2120 /*!
2121 ************************************************************************
2122 * \brief
2123 * free 2D short memory array
2124 * which was allocated with get_mem2Dshort()
2125 ************************************************************************
2126 */
free_mem2Dshort(short ** array2D)2127 void free_mem2Dshort(short **array2D)
2128 {
2129 if (array2D)
2130 {
2131 if (*array2D)
2132 mem_free (*array2D);
2133 else error ("free_mem2Dshort: trying to free unused memory",100);
2134
2135 mem_free (array2D);
2136 }
2137 else
2138 {
2139 error ("free_mem2Dshort: trying to free unused memory",100);
2140 }
2141 }
2142
2143 /*!
2144 ************************************************************************
2145 * \brief
2146 * free 3D short memory array
2147 * which was allocated with get_mem3Dshort()
2148 ************************************************************************
2149 */
free_mem3Dshort(short *** array3D)2150 void free_mem3Dshort(short ***array3D)
2151 {
2152 if (array3D)
2153 {
2154 free_mem2Dshort(*array3D);
2155 mem_free (array3D);
2156 }
2157 else
2158 {
2159 error ("free_mem3Dshort: trying to free unused memory",100);
2160 }
2161 }
2162
2163 /*!
2164 ************************************************************************
2165 * \brief
2166 * free 4D short memory array
2167 * which was allocated with get_mem4Dshort()
2168 ************************************************************************
2169 */
free_mem4Dshort(short **** array4D)2170 void free_mem4Dshort(short ****array4D)
2171 {
2172 if (array4D)
2173 {
2174 free_mem3Dshort( *array4D);
2175 mem_free (array4D);
2176 }
2177 else
2178 {
2179 error ("free_mem4Dshort: trying to free unused memory",100);
2180 }
2181 }
2182
2183 /*!
2184 ************************************************************************
2185 * \brief
2186 * free 5D short memory array
2187 * which was allocated with get_mem5Dshort()
2188 ************************************************************************
2189 */
free_mem5Dshort(short ***** array5D)2190 void free_mem5Dshort(short *****array5D)
2191 {
2192 if (array5D)
2193 {
2194 free_mem4Dshort( *array5D) ;
2195 mem_free (array5D);
2196 }
2197 else
2198 {
2199 error ("free_mem5Dshort: trying to free unused memory",100);
2200 }
2201 }
2202
2203 /*!
2204 ************************************************************************
2205 * \brief
2206 * free 6D short memory array
2207 * which was allocated with get_mem6Dshort()
2208 ************************************************************************
2209 */
free_mem6Dshort(short ****** array6D)2210 void free_mem6Dshort(short ******array6D)
2211 {
2212 if (array6D)
2213 {
2214 free_mem5Dshort( *array6D);
2215 mem_free (array6D);
2216 }
2217 else
2218 {
2219 error ("free_mem6Dshort: trying to free unused memory",100);
2220 }
2221 }
2222
2223 /*!
2224 ************************************************************************
2225 * \brief
2226 * free 7D short memory array
2227 * which was allocated with get_mem7Dshort()
2228 ************************************************************************
2229 */
free_mem7Dshort(short ******* array7D)2230 void free_mem7Dshort(short *******array7D)
2231 {
2232 if (array7D)
2233 {
2234 free_mem6Dshort( *array7D);
2235 mem_free (array7D);
2236 }
2237 else
2238 {
2239 error ("free_mem7Dshort: trying to free unused memory",100);
2240 }
2241 }
2242
2243 /*!
2244 ************************************************************************
2245 * \brief
2246 * Allocate 2D memory array -> double array2D[dim0][dim1]
2247 *
2248 * \par Output:
2249 * memory size in bytes
2250 ************************************************************************
2251 */
get_mem2Ddouble(double *** array2D,int dim0,int dim1)2252 int get_mem2Ddouble(double ***array2D, int dim0, int dim1)
2253 {
2254 int i;
2255
2256 if((*array2D = (double**)mem_malloc(dim0 * sizeof(double*))) == NULL)
2257 no_mem_exit("get_mem2Ddouble: array2D");
2258
2259 if(((*array2D)[0] = (double* )mem_calloc(dim0 * dim1, sizeof(double ))) == NULL)
2260 no_mem_exit("get_mem2Ddouble: array2D");
2261
2262 for(i=1 ; i<dim0 ; i++)
2263 (*array2D)[i] = (*array2D)[i-1] + dim1 ;
2264
2265 return dim0 * (sizeof(double*) + dim1 * sizeof(double));
2266 }
2267
2268 /*!
2269 ************************************************************************
2270 * \brief
2271 * Allocate 1D memory array -> double array1D[dim0]
2272 * Note that array is shifted towards offset allowing negative values
2273 *
2274 * \par Output:
2275 * memory size in bytes
2276 ************************************************************************
2277 */
get_mem1Dodouble(double ** array1D,int dim0,int offset)2278 int get_mem1Dodouble(double **array1D, int dim0, int offset)
2279 {
2280 if((*array1D = (double*)mem_calloc(dim0, sizeof(double))) == NULL)
2281 no_mem_exit("get_mem1Dodouble: array2D");
2282
2283 *array1D += offset;
2284
2285 return dim0 * sizeof(double);
2286 }
2287
2288 /*!
2289 ************************************************************************
2290 * \brief
2291 * Allocate 2D memory array -> double array2D[dim0][dim1]
2292 * Note that array is shifted towards offset allowing negative values
2293 *
2294 * \par Output:
2295 * memory size in bytes
2296 ************************************************************************
2297 */
get_mem2Dodouble(double *** array2D,int dim0,int dim1,int offset)2298 int get_mem2Dodouble(double ***array2D, int dim0, int dim1, int offset)
2299 {
2300 int i;
2301
2302 if((*array2D = (double**)mem_malloc(dim0 * sizeof(double*))) == NULL)
2303 no_mem_exit("get_mem2Dodouble: array2D");
2304 if(((*array2D)[0] = (double* )mem_calloc(dim0 * dim1,sizeof(double ))) == NULL)
2305 no_mem_exit("get_mem2Dodouble: array2D");
2306
2307 (*array2D)[0] += offset;
2308
2309 for(i=1 ; i<dim0 ; i++)
2310 (*array2D)[i] = (*array2D)[i-1] + dim1 ;
2311
2312 return dim0 * (sizeof(double*) + dim1 * sizeof(double));
2313 }
2314
2315 /*!
2316 ************************************************************************
2317 * \brief
2318 * Allocate 3D memory double array -> double array3D[dim0][dim1][dim2]
2319 *
2320 * \par Output:
2321 * memory size in bytes
2322 ************************************************************************
2323 */
get_mem3Dodouble(double **** array3D,int dim0,int dim1,int dim2,int offset)2324 int get_mem3Dodouble(double ****array3D, int dim0, int dim1, int dim2, int offset)
2325 {
2326 int i,j;
2327
2328 if(((*array3D) = (double***)mem_malloc(dim0 * sizeof(double**))) == NULL)
2329 no_mem_exit("get_mem3Dodouble: array3D");
2330
2331 if(((*array3D)[0] = (double** )mem_calloc(dim0 * dim1,sizeof(double*))) == NULL)
2332 no_mem_exit("get_mem3Dodouble: array3D");
2333
2334 (*array3D) [0] += offset;
2335
2336 for(i=1 ; i<dim0 ; i++)
2337 (*array3D)[i] = (*array3D)[i-1] + dim1 ;
2338
2339 for (i = 0; i < dim0; i++)
2340 for (j = -offset; j < dim1 - offset; j++)
2341 if(((*array3D)[i][j] = (double* )mem_calloc(dim2, sizeof(double))) == NULL)
2342 no_mem_exit("get_mem3Dodouble: array3D");
2343
2344 return dim0*( sizeof(double**) + dim1 * ( sizeof(double*) + dim2 * sizeof(double)));
2345 }
2346
2347
2348 /*!
2349 ************************************************************************
2350 * \brief
2351 * Allocate 2D memory array -> int array2D[dim0][dim1]
2352 * Note that array is shifted towards offset allowing negative values
2353 *
2354 * \par Output:
2355 * memory size in bytes
2356 ************************************************************************
2357 */
get_offset_mem2Dshort(short *** array2D,int dim0,int dim1,int offset_y,int offset_x)2358 int get_offset_mem2Dshort(short ***array2D, int dim0, int dim1, int offset_y, int offset_x)
2359 {
2360 int i;
2361
2362 if((*array2D = (short**)mem_malloc(dim0 * sizeof(short*))) == NULL)
2363 no_mem_exit("get_offset_mem2Dshort: array2D");
2364
2365 if(((*array2D)[0] = (short* )mem_calloc(dim0 * dim1,sizeof(short))) == NULL)
2366 no_mem_exit("get_offset_mem2Dshort: array2D");
2367 (*array2D)[0] += offset_x + offset_y * dim1;
2368
2369 for(i=-1 ; i > -offset_y - 1; i--)
2370 {
2371 (*array2D)[i] = (*array2D)[i+1] - dim1;
2372 }
2373
2374 for(i=1 ; i < dim1 - offset_y; i++)
2375 (*array2D)[i] = (*array2D)[i-1] + dim1;
2376
2377 return dim0 * (sizeof(short*) + dim1 * sizeof(short));
2378 }
2379
2380 /*!
2381 ************************************************************************
2382 * \brief
2383 * Allocate 3D memory int array -> int array3D[dim0][dim1][dim2]
2384 *
2385 * \par Output:
2386 * memory size in bytes
2387 ************************************************************************
2388 */
get_mem3Doint(int **** array3D,int dim0,int dim1,int dim2,int offset)2389 int get_mem3Doint(int ****array3D, int dim0, int dim1, int dim2, int offset)
2390 {
2391 int i,j;
2392
2393 if(((*array3D) = (int***)mem_malloc(dim0 * sizeof(int**))) == NULL)
2394 no_mem_exit("get_mem3Doint: array3D");
2395
2396 if(((*array3D)[0] = (int** )mem_calloc(dim0 * dim1,sizeof(int*))) == NULL)
2397 no_mem_exit("get_mem3Doint: array3D");
2398
2399 (*array3D) [0] += offset;
2400
2401 for(i=1 ; i<dim0 ; i++)
2402 (*array3D)[i] = (*array3D)[i-1] + dim1 ;
2403
2404 for (i = 0; i < dim0; i++)
2405 for (j = -offset; j < dim1 - offset; j++)
2406 if(((*array3D)[i][j] = (int* )mem_calloc(dim2,sizeof(int))) == NULL)
2407 no_mem_exit("get_mem3Doint: array3D");
2408
2409 return dim0 * (sizeof(int**) + dim1 * (sizeof(int*) + dim2 * sizeof(int)));
2410 }
2411
2412 /*!
2413 ************************************************************************
2414 * \brief
2415 * Allocate 2D memory array -> int array2D[dim0][dim1]
2416 * Note that array is shifted towards offset allowing negative values
2417 *
2418 * \par Output:
2419 * memory size in bytes
2420 ************************************************************************
2421 */
get_mem2Doint(int *** array2D,int dim0,int dim1,int offset)2422 int get_mem2Doint(int ***array2D, int dim0, int dim1, int offset)
2423 {
2424 int i;
2425
2426 if((*array2D = (int**)mem_malloc(dim0 * sizeof(int*))) == NULL)
2427 no_mem_exit("get_mem2Dint: array2D");
2428 if(((*array2D)[0] = (int* )mem_calloc(dim0 * dim1,sizeof(int))) == NULL)
2429 no_mem_exit("get_mem2Dint: array2D");
2430
2431 (*array2D)[0] += offset;
2432
2433 for(i=1 ; i<dim0 ; i++)
2434 (*array2D)[i] = (*array2D)[i-1] + dim1 ;
2435
2436 return dim0 * (sizeof(int*) + dim1 * sizeof(int));
2437 }
2438
2439
2440 /*!
2441 ************************************************************************
2442 * \brief
2443 * free 2D double memory array
2444 * which was allocated with get_mem2Ddouble()
2445 ************************************************************************
2446 */
free_mem2Ddouble(double ** array2D)2447 void free_mem2Ddouble(double **array2D)
2448 {
2449 if (array2D)
2450 {
2451 if (*array2D)
2452 mem_free (*array2D);
2453 else
2454 error ("free_mem2Ddouble: trying to free unused memory",100);
2455
2456 mem_free (array2D);
2457
2458 }
2459 else
2460 {
2461 error ("free_mem2Ddouble: trying to free unused memory",100);
2462 }
2463 }
2464
2465 /*!
2466 ************************************************************************
2467 * \brief
2468 * free 1D double memory array (with offset)
2469 * which was allocated with get_mem1Ddouble()
2470 ************************************************************************
2471 */
free_mem1Dodouble(double * array1D,int offset)2472 void free_mem1Dodouble(double *array1D, int offset)
2473 {
2474 if (array1D)
2475 {
2476 array1D -= offset;
2477 mem_free (array1D);
2478 }
2479 else
2480 {
2481 error ("free_mem1Dodouble: trying to free unused memory",100);
2482 }
2483 }
2484
2485
2486 /*!
2487 ************************************************************************
2488 * \brief
2489 * free 2D double memory array (with offset)
2490 * which was allocated with get_mem2Ddouble()
2491 ************************************************************************
2492 */
free_mem2Dodouble(double ** array2D,int offset)2493 void free_mem2Dodouble(double **array2D, int offset)
2494 {
2495 if (array2D)
2496 {
2497 array2D[0] -= offset;
2498 if (array2D[0])
2499 mem_free (array2D[0]);
2500 else error ("free_mem2Dodouble: trying to free unused memory",100);
2501
2502 mem_free (array2D);
2503
2504 } else
2505 {
2506 error ("free_mem2Dodouble: trying to free unused memory",100);
2507 }
2508 }
2509
2510 /*!
2511 ************************************************************************
2512 * \brief
2513 * free 3D memory array with offset
2514 ************************************************************************
2515 */
free_mem3Dodouble(double *** array3D,int dim0,int dim1,int offset)2516 void free_mem3Dodouble(double ***array3D, int dim0, int dim1, int offset)
2517 {
2518 int i, j;
2519
2520 if (array3D)
2521 {
2522 for (i = 0; i < dim0; i++)
2523 {
2524 for (j = -offset; j < dim1 - offset; j++)
2525 {
2526 if (array3D[i][j])
2527 mem_free (array3D[i][j]);
2528 else
2529 error ("free_mem3Dodouble: trying to free unused memory",100);
2530 }
2531 }
2532 array3D[0] -= offset;
2533 if (array3D[0])
2534 mem_free (array3D[0]);
2535 else
2536 error ("free_mem3Dodouble: trying to free unused memory",100);
2537 mem_free (array3D);
2538 }
2539 else
2540 {
2541 error ("free_mem3Dodouble: trying to free unused memory",100);
2542 }
2543 }
2544
2545 /*!
2546 ************************************************************************
2547 * \brief
2548 * free 3D memory array with offset
2549 ************************************************************************
2550 */
free_mem3Doint(int *** array3D,int dim0,int dim1,int offset)2551 void free_mem3Doint(int ***array3D, int dim0, int dim1, int offset)
2552 {
2553 int i, j;
2554
2555 if (array3D)
2556 {
2557 for (i = 0; i < dim0; i++)
2558 {
2559 for (j = -offset; j < dim1 - offset; j++)
2560 {
2561 if (array3D[i][j])
2562 mem_free (array3D[i][j]);
2563 else
2564 error ("free_mem3Doint: trying to free unused memory",100);
2565 }
2566 }
2567 array3D[0] -= offset;
2568 if (array3D[0])
2569 mem_free (array3D[0]);
2570 else
2571 error ("free_mem3Doint: trying to free unused memory",100);
2572 mem_free (array3D);
2573 }
2574 else
2575 {
2576 error ("free_mem3Doint: trying to free unused memory",100);
2577 }
2578 }
2579
2580
2581 /*!
2582 ************************************************************************
2583 * \brief
2584 * free 2D double memory array (with offset)
2585 * which was allocated with get_mem2Ddouble()
2586 ************************************************************************
2587 */
free_mem2Doint(int ** array2D,int offset)2588 void free_mem2Doint(int **array2D, int offset)
2589 {
2590 if (array2D)
2591 {
2592 array2D[0] -= offset;
2593 if (array2D[0])
2594 mem_free (array2D[0]);
2595 else
2596 error ("free_mem2Doint: trying to free unused memory",100);
2597
2598 mem_free (array2D);
2599
2600 }
2601 else
2602 {
2603 error ("free_mem2Doint: trying to free unused memory",100);
2604 }
2605 }
2606
2607 /*!
2608 ************************************************************************
2609 * \brief
2610 * free 2D double memory array (with offset)
2611 * which was allocated with get_mem2Ddouble()
2612 ************************************************************************
2613 */
free_offset_mem2Dshort(short ** array2D,int dim1,int offset_y,int offset_x)2614 void free_offset_mem2Dshort(short **array2D, int dim1, int offset_y, int offset_x)
2615 {
2616 if (array2D)
2617 {
2618 array2D[0] -= offset_x + offset_y * dim1;
2619 if (array2D[0])
2620 mem_free (array2D[0]);
2621 else
2622 error ("free_offset_mem2Dshort: trying to free unused memory",100);
2623
2624 mem_free (array2D);
2625
2626 }
2627 else
2628 {
2629 error ("free_offset_mem2Dshort: trying to free unused memory",100);
2630 }
2631 }
2632
2633 /*!
2634 ************************************************************************
2635 * \brief
2636 * free 3D memory array
2637 * which was alocated with get_mem3Dint()
2638 ************************************************************************
2639 */
free_mem3Ddouble(double *** array3D)2640 void free_mem3Ddouble(double ***array3D)
2641 {
2642 if (array3D)
2643 {
2644 free_mem2Ddouble(*array3D);
2645 mem_free (array3D);
2646 }
2647 else
2648 {
2649 error ("free_mem3D: trying to free unused memory",100);
2650 }
2651 }
2652
2653
2654 /*!
2655 ************************************************************************
2656 * \brief
2657 * Allocate 2D memory array -> LambdaParams array2D[dim0][dim1]
2658 * Note that array is shifted towards offset allowing negative values
2659 *
2660 * \par Output:
2661 * memory size in bytes
2662 ************************************************************************
2663 */
get_mem2Dolm(LambdaParams *** array2D,int dim0,int dim1,int offset)2664 int get_mem2Dolm(LambdaParams ***array2D, int dim0, int dim1, int offset)
2665 {
2666 int i;
2667
2668 if((*array2D = (LambdaParams**)mem_malloc(dim0 * sizeof(LambdaParams*))) == NULL)
2669 no_mem_exit("get_mem2Dolm: array2D");
2670 if(((*array2D)[0] = (LambdaParams* )mem_calloc(dim0 * dim1, sizeof(LambdaParams))) == NULL)
2671 no_mem_exit("get_mem2Dolm: array2D");
2672
2673 (*array2D)[0] += offset;
2674
2675 for(i=1 ; i<dim0 ; i++)
2676 (*array2D)[i] = (*array2D)[i-1] + dim1 ;
2677
2678 return dim0 * (sizeof(LambdaParams*) + dim1 * sizeof(LambdaParams));
2679 }
2680
2681
2682 /*!
2683 ************************************************************************
2684 * \brief
2685 * free 2D LambdaParams memory array (with offset)
2686 * which was allocated with get_mem2Dlm()
2687 ************************************************************************
2688 */
free_mem2Dolm(LambdaParams ** array2D,int offset)2689 void free_mem2Dolm(LambdaParams **array2D, int offset)
2690 {
2691 if (array2D)
2692 {
2693 array2D[0] -= offset;
2694 if (array2D[0])
2695 mem_free (array2D[0]);
2696 else
2697 error ("free_mem2Dolm: trying to free unused memory",100);
2698
2699 mem_free (array2D);
2700
2701 }
2702 else
2703 {
2704 error ("free_mem2Dolm: trying to free unused memory",100);
2705 }
2706 }
2707
free_mem2Ddistblk(distblk ** array2D)2708 void free_mem2Ddistblk(distblk **array2D)
2709 {
2710 if (array2D)
2711 {
2712 if (*array2D)
2713 mem_free (*array2D);
2714 else
2715 error ("free_mem2Ddistblk: trying to free unused memory",100);
2716 free (array2D);
2717 }
2718 else
2719 {
2720 error ("free_mem2Ddistblk: trying to free unused memory",100);
2721 }
2722 }
2723