00001
00017 #include "global.h"
00018 #include "memalloc.h"
00019
00020
00029 int get_mem2Dpel(imgpel ***array2D, int dim0, int dim1)
00030 {
00031 int i;
00032
00033 if((*array2D = (imgpel**)malloc(dim0 * sizeof(imgpel*))) == NULL)
00034 no_mem_exit("get_mem2Dpel: array2D");
00035 if((*(*array2D) = (imgpel* )calloc(dim0 * dim1,sizeof(imgpel ))) == NULL)
00036 no_mem_exit("get_mem2Dpel: array2D");
00037
00038 for(i = 1 ; i < dim0; i++)
00039 (*array2D)[i] = (*array2D)[i-1] + dim1;
00040
00041 return dim0 * (sizeof(imgpel*) + dim1 * sizeof(imgpel));
00042 }
00043
00044
00054 int get_mem3Dpel(imgpel ****array3D, int dim0, int dim1, int dim2)
00055 {
00056 int i, mem_size = dim0 * sizeof(imgpel**);
00057
00058 if(((*array3D) = (imgpel***)malloc(dim0 * sizeof(imgpel**))) == NULL)
00059 no_mem_exit("get_mem3Dpel: array3D");
00060
00061 mem_size += get_mem2Dpel(*array3D, dim0 * dim1, dim2);
00062
00063 for(i = 1; i < dim0; i++)
00064 (*array3D)[i] = (*array3D)[i - 1] + dim1;
00065
00066 return mem_size;
00067 }
00077 int get_mem4Dpel(imgpel *****array4D, int dim0, int dim1, int dim2, int dim3)
00078 {
00079 int i, mem_size = dim0 * sizeof(imgpel***);
00080
00081 if(((*array4D) = (imgpel****)malloc(dim0 * sizeof(imgpel***))) == NULL)
00082 no_mem_exit("get_mem4Dpel: array4D");
00083
00084 mem_size += get_mem3Dpel(*array4D, dim0 * dim1, dim2, dim3);
00085
00086 for(i = 1; i < dim0; i++)
00087 (*array4D)[i] = (*array4D)[i - 1] + dim1;
00088
00089 return mem_size;
00090 }
00091
00101 int get_mem5Dpel(imgpel ******array5D, int dim0, int dim1, int dim2, int dim3, int dim4)
00102 {
00103 int i, mem_size = dim0 * sizeof(imgpel****);
00104
00105 if(((*array5D) = (imgpel*****)malloc(dim0 * sizeof(imgpel****))) == NULL)
00106 no_mem_exit("get_mem5Dpel: array5D");
00107
00108 mem_size += get_mem4Dpel(*array5D, dim0 * dim1, dim2, dim3, dim4);
00109
00110 for(i = 1; i < dim0; i++)
00111 (*array5D)[i] = (*array5D)[i - 1] + dim1;
00112
00113 return mem_size;
00114 }
00115
00123 void free_mem2Dpel(imgpel **array2D)
00124 {
00125 if (array2D)
00126 {
00127 if (*array2D)
00128 free (*array2D);
00129 else
00130 error ("free_mem2Dpel: trying to free unused memory",100);
00131
00132 free (array2D);
00133 }
00134 else
00135 {
00136 error ("free_mem2Dpel: trying to free unused memory",100);
00137 }
00138 }
00139
00140
00148 void free_mem3Dpel(imgpel ***array3D)
00149 {
00150 if (array3D)
00151 {
00152 free_mem2Dpel(*array3D);
00153 free (array3D);
00154 }
00155 else
00156 {
00157 error ("free_mem3Dpel: trying to free unused memory",100);
00158 }
00159 }
00167 void free_mem4Dpel(imgpel ****array4D)
00168 {
00169 if (array4D)
00170 {
00171 free_mem3Dpel(*array4D);
00172 free (array4D);
00173 }
00174 else
00175 {
00176 error ("free_mem4Dpel: trying to free unused memory",100);
00177 }
00178 }
00186 void free_mem5Dpel(imgpel *****array5D)
00187 {
00188 if (array5D)
00189 {
00190 free_mem4Dpel(*array5D);
00191 free (array5D);
00192 }
00193 else
00194 {
00195 error ("free_mem5Dpel: trying to free unused memory",100);
00196 }
00197 }
00198
00207 int get_mem2D(byte ***array2D, int dim0, int dim1)
00208 {
00209 int i;
00210
00211 if(( *array2D = (byte**)malloc(dim0 * sizeof(byte*))) == NULL)
00212 no_mem_exit("get_mem2D: array2D");
00213 if((*(*array2D) = (byte* )calloc(dim0 * dim1,sizeof(byte ))) == NULL)
00214 no_mem_exit("get_mem2D: array2D");
00215
00216 for(i = 1; i < dim0; i++)
00217 (*array2D)[i] = (*array2D)[i-1] + dim1;
00218
00219 return dim0 * (sizeof(byte*) + dim1 * sizeof(byte));
00220 }
00221
00231 int get_mem2Dint(int ***array2D, int dim0, int dim1)
00232 {
00233 int i;
00234
00235 if((*array2D = (int**)malloc(dim0 * sizeof(int*))) == NULL)
00236 no_mem_exit("get_mem2Dint: array2D");
00237 if((*(*array2D) = (int* )calloc(dim0 * dim1, sizeof(int ))) == NULL)
00238 no_mem_exit("get_mem2Dint: array2D");
00239
00240 for(i = 1 ; i < dim0; i++)
00241 (*array2D)[i] = (*array2D)[i-1] + dim1;
00242
00243 return dim0 * (sizeof(int*) + dim1 * sizeof(int));
00244 }
00245
00255 int get_mem2Dint64(int64 ***array2D, int dim0, int dim1)
00256 {
00257 int i;
00258
00259 if((*array2D = (int64**)malloc(dim0 * sizeof(int64*))) == NULL)
00260 no_mem_exit("get_mem2Dint64: array2D");
00261 if((*(*array2D) = (int64* )calloc(dim0 * dim1,sizeof(int64 ))) == NULL)
00262 no_mem_exit("get_mem2Dint64: array2D");
00263
00264 for(i = 1; i < dim0; i++)
00265 (*array2D)[i] = (*array2D)[i-1] + dim1;
00266
00267 return dim0 * (sizeof(int64*) + dim1 * sizeof(int64));
00268 }
00269
00279 int get_mem3D(byte ****array3D, int dim0, int dim1, int dim2)
00280 {
00281 int i, mem_size = dim0 * sizeof(byte**);
00282
00283 if(((*array3D) = (byte***)malloc(dim0 * sizeof(byte**))) == NULL)
00284 no_mem_exit("get_mem3D: array3D");
00285
00286 mem_size += get_mem2D(*array3D, dim0 * dim1, dim2);
00287
00288 for(i = 1; i < dim0; i++)
00289 (*array3D)[i] = (*array3D)[i-1] + dim1;
00290
00291 return mem_size;
00292 }
00293
00303 int get_mem4D(byte *****array4D, int dim0, int dim1, int dim2, int dim3)
00304 {
00305 int i, mem_size = dim0 * sizeof(byte***);
00306
00307 if(((*array4D) = (byte****)malloc(dim0 * sizeof(byte***))) == NULL)
00308 no_mem_exit("get_mem4D: array4D");
00309
00310 mem_size += get_mem3D(*array4D, dim0 * dim1, dim2, dim3);
00311
00312 for(i = 1; i < dim0; i++)
00313 (*array4D)[i] = (*array4D)[i-1] + dim1;
00314
00315 return mem_size;
00316 }
00317
00327 int get_mem3Dint(int ****array3D, int dim0, int dim1, int dim2)
00328 {
00329 int i, mem_size = dim0 * sizeof(int**);
00330
00331 if(((*array3D) = (int***)malloc(dim0 * sizeof(int**))) == NULL)
00332 no_mem_exit("get_mem3Dint: array3D");
00333
00334 mem_size += get_mem2Dint(*array3D, dim0 * dim1, dim2);
00335
00336 for(i = 1; i < dim0; i++)
00337 (*array3D)[i] = (*array3D)[i-1] + dim1;
00338
00339 return mem_size;
00340 }
00341
00351 int get_mem3Dint64(int64 ****array3D, int dim0, int dim1, int dim2)
00352 {
00353 int i, mem_size = dim0 * sizeof(int64**);
00354
00355 if(((*array3D) = (int64***)malloc(dim0 * sizeof(int64**))) == NULL)
00356 no_mem_exit("get_mem3Dint64: array3D");
00357
00358 mem_size += get_mem2Dint64(*array3D, dim0 * dim1, dim2);
00359
00360 for(i = 1; i < dim0; i++)
00361 (*array3D)[i] = (*array3D)[i-1] + dim1;
00362
00363 return mem_size;
00364 }
00365
00375 int get_mem4Dint(int *****array4D, int dim0, int dim1, int dim2, int dim3)
00376 {
00377 int i, mem_size = dim0 * sizeof(int***);
00378
00379 if(((*array4D) = (int****)malloc(dim0 * sizeof(int***))) == NULL)
00380 no_mem_exit("get_mem4Dint: array4D");
00381
00382 mem_size += get_mem3Dint(*array4D, dim0 * dim1, dim2, dim3);
00383
00384 for(i = 1; i < dim0; i++)
00385 (*array4D)[i] = (*array4D)[i-1] + dim1;
00386
00387 return mem_size;
00388 }
00389
00399 int get_mem5Dint(int ******array5D, int dim0, int dim1, int dim2, int dim3, int dim4)
00400 {
00401 int i, mem_size = dim0 * sizeof(int****);
00402
00403 if(((*array5D) = (int*****)malloc(dim0 * sizeof(int****))) == NULL)
00404 no_mem_exit("get_mem5Dint: array5D");
00405
00406 mem_size += get_mem4Dint(*array5D, dim0 * dim1, dim2, dim3, dim4);
00407
00408 for(i = 1; i < dim0; i++)
00409 (*array5D)[i] = (*array5D)[i-1] + dim1;
00410
00411 return mem_size;
00412 }
00413
00414
00422 void free_mem2D(byte **array2D)
00423 {
00424 if (array2D)
00425 {
00426 if (*array2D)
00427 free (*array2D);
00428 else
00429 error ("free_mem2D: trying to free unused memory",100);
00430
00431 free (array2D);
00432 }
00433 else
00434 {
00435 error ("free_mem2D: trying to free unused memory",100);
00436 }
00437 }
00438
00446 void free_mem2Dint(int **array2D)
00447 {
00448 if (array2D)
00449 {
00450 if (*array2D)
00451 free (*array2D);
00452 else
00453 error ("free_mem2Dint: trying to free unused memory",100);
00454
00455 free (array2D);
00456 }
00457 else
00458 {
00459 error ("free_mem2Dint: trying to free unused memory",100);
00460 }
00461 }
00462
00470 void free_mem2Dint64(int64 **array2D)
00471 {
00472 if (array2D)
00473 {
00474 if (*array2D)
00475 free (*array2D);
00476 else
00477 error ("free_mem2Dint64: trying to free unused memory",100);
00478 free (array2D);
00479 }
00480 else
00481 {
00482 error ("free_mem2Dint64: trying to free unused memory",100);
00483 }
00484 }
00485
00486
00494 void free_mem3D(byte ***array3D)
00495 {
00496 if (array3D)
00497 {
00498 free_mem2D(*array3D);
00499 free (array3D);
00500 }
00501 else
00502 {
00503 error ("free_mem3D: trying to free unused memory",100);
00504 }
00505 }
00506
00514 void free_mem4D(byte ****array4D)
00515 {
00516 if (array4D)
00517 {
00518 free_mem3D(*array4D);
00519 free (array4D);
00520 }
00521 else
00522 {
00523 error ("free_mem4D: trying to free unused memory",100);
00524 }
00525 }
00526
00534 void free_mem3Dint(int ***array3D)
00535 {
00536 if (array3D)
00537 {
00538 free_mem2Dint(*array3D);
00539 free (array3D);
00540 }
00541 else
00542 {
00543 error ("free_mem3Dint: trying to free unused memory",100);
00544 }
00545 }
00546
00547
00555 void free_mem3Dint64(int64 ***array3D)
00556 {
00557 if (array3D)
00558 {
00559 free_mem2Dint64(*array3D);
00560 free (array3D);
00561 }
00562 else
00563 {
00564 error ("free_mem3Dint64: trying to free unused memory",100);
00565 }
00566 }
00567
00575 void free_mem4Dint(int ****array4D)
00576 {
00577 if (array4D)
00578 {
00579 free_mem3Dint( *array4D);
00580 free (array4D);
00581 } else
00582 {
00583 error ("free_mem4Dint: trying to free unused memory",100);
00584 }
00585 }
00586
00594 void free_mem5Dint(int *****array5D)
00595 {
00596 if (array5D)
00597 {
00598 free_mem4Dint( *array5D);
00599 free (array5D);
00600 } else
00601 {
00602 error ("free_mem5Dint: trying to free unused memory",100);
00603 }
00604 }
00605
00614 void no_mem_exit(char *where)
00615 {
00616 snprintf(errortext, ET_SIZE, "Could not allocate memory: %s",where);
00617 error (errortext, 100);
00618 }
00619
00620
00630 int get_mem2Dshort(short ***array2D, int dim0, int dim1)
00631 {
00632 int i;
00633
00634 if(( *array2D = (short**)malloc(dim0 * sizeof(short*))) == NULL)
00635 no_mem_exit("get_mem2Dshort: array2D");
00636 if((*(*array2D) = (short* )calloc(dim0 * dim1,sizeof(short ))) == NULL)
00637 no_mem_exit("get_mem2Dshort: array2D");
00638
00639 for(i = 1; i < dim0; i++)
00640 (*array2D)[i] = (*array2D)[i-1] + dim1;
00641
00642 return dim0 * (sizeof(short*) + dim1 * sizeof(short));
00643 }
00644
00654 int get_mem3Dshort(short ****array3D,int dim0, int dim1, int dim2)
00655 {
00656 int i, mem_size = dim0 * sizeof(short**);
00657
00658 if(((*array3D) = (short***)malloc(dim0 * sizeof(short**))) == NULL)
00659 no_mem_exit("get_mem3Dshort: array3D");
00660
00661 mem_size += get_mem2Dshort(*array3D, dim0 * dim1, dim2);
00662
00663 for(i = 1; i < dim0; i++)
00664 (*array3D)[i] = (*array3D)[i-1] + dim1;
00665
00666 return mem_size;
00667 }
00668
00669
00679 int get_mem4Dshort(short *****array4D, int dim0, int dim1, int dim2, int dim3)
00680 {
00681 int i, mem_size = dim0 * sizeof(short***);
00682
00683 if(((*array4D) = (short****)malloc(dim0 * sizeof(short***))) == NULL)
00684 no_mem_exit("get_mem4Dshort: array4D");
00685
00686 mem_size += get_mem3Dshort(*array4D, dim0 * dim1, dim2, dim3);
00687
00688 for(i = 1; i < dim0; i++)
00689 (*array4D)[i] = (*array4D)[i-1] + dim1;
00690
00691 return mem_size;
00692 }
00693
00703 int get_mem5Dshort(short ******array5D, int dim0, int dim1, int dim2, int dim3, int dim4)
00704 {
00705 int i, mem_size = dim0 * sizeof(short****);
00706
00707 if(((*array5D) = (short*****)malloc(dim0 * sizeof(short****))) == NULL)
00708 no_mem_exit("get_mem5Dshort: array5D");
00709
00710 mem_size += get_mem4Dshort(*array5D, dim0 * dim1, dim2, dim3, dim4);
00711
00712 for(i = 1; i < dim0; i++)
00713 (*array5D)[i] = (*array5D)[i-1] + dim1;
00714
00715 return mem_size;
00716 }
00717
00727 int get_mem6Dshort(short *******array6D, int dim0, int dim1, int dim2, int dim3, int dim4, int dim5)
00728 {
00729 int i, mem_size = dim0 * sizeof(short*****);
00730
00731 if(((*array6D) = (short******)malloc(dim0 * sizeof(short*****))) == NULL)
00732 no_mem_exit("get_mem6Dshort: array6D");
00733
00734 mem_size += get_mem5Dshort(*array6D, dim0 * dim1, dim2, dim3, dim4, dim5);
00735
00736 for(i = 1; i < dim0; i++)
00737 (*array6D)[i] = (*array6D)[i-1] + dim1;
00738
00739 return mem_size;
00740 }
00741
00751 int get_mem7Dshort(short ********array7D, int dim0, int dim1, int dim2, int dim3, int dim4, int dim5, int dim6)
00752 {
00753 int i, mem_size = dim0 * sizeof(short******);
00754
00755 if(((*array7D) = (short*******)malloc(dim0 * sizeof(short******))) == NULL)
00756 no_mem_exit("get_mem7Dshort: array7D");
00757
00758 mem_size += get_mem6Dshort(*array7D, dim0 * dim1, dim2, dim3, dim4, dim5, dim6);
00759
00760 for(i = 1; i < dim0; i++)
00761 (*array7D)[i] = (*array7D)[i-1] + dim1;
00762
00763 return mem_size;
00764 }
00765
00773 void free_mem2Dshort(short **array2D)
00774 {
00775 if (array2D)
00776 {
00777 if (*array2D)
00778 free (*array2D);
00779 else error ("free_mem2Dshort: trying to free unused memory",100);
00780
00781 free (array2D);
00782 }
00783 else
00784 {
00785 error ("free_mem2Dshort: trying to free unused memory",100);
00786 }
00787 }
00788
00796 void free_mem3Dshort(short ***array3D)
00797 {
00798 if (array3D)
00799 {
00800 free_mem2Dshort(*array3D);
00801 free (array3D);
00802 }
00803 else
00804 {
00805 error ("free_mem3Dshort: trying to free unused memory",100);
00806 }
00807 }
00808
00816 void free_mem4Dshort(short ****array4D)
00817 {
00818 if (array4D)
00819 {
00820 free_mem3Dshort( *array4D);
00821 free (array4D);
00822 }
00823 else
00824 {
00825 error ("free_mem4Dshort: trying to free unused memory",100);
00826 }
00827 }
00828
00836 void free_mem5Dshort(short *****array5D)
00837 {
00838 if (array5D)
00839 {
00840 free_mem4Dshort( *array5D) ;
00841 free (array5D);
00842 }
00843 else
00844 {
00845 error ("free_mem5Dshort: trying to free unused memory",100);
00846 }
00847 }
00848
00856 void free_mem6Dshort(short ******array6D)
00857 {
00858 if (array6D)
00859 {
00860 free_mem5Dshort( *array6D);
00861 free (array6D);
00862 }
00863 else
00864 {
00865 error ("free_mem6Dshort: trying to free unused memory",100);
00866 }
00867 }
00868
00876 void free_mem7Dshort(short *******array7D)
00877 {
00878 if (array7D)
00879 {
00880 free_mem6Dshort( *array7D);
00881 free (array7D);
00882 }
00883 else
00884 {
00885 error ("free_mem7Dshort: trying to free unused memory",100);
00886 }
00887 }
00888
00898 int get_mem2Ddouble(double ***array2D, int dim0, int dim1)
00899 {
00900 int i;
00901
00902 if((*array2D = (double**)malloc(dim0 * sizeof(double*))) == NULL)
00903 no_mem_exit("get_mem2Ddouble: array2D");
00904
00905 if(((*array2D)[0] = (double* )calloc(dim0 * dim1,sizeof(double ))) == NULL)
00906 no_mem_exit("get_mem2Ddouble: array2D");
00907
00908 for(i=1 ; i<dim0 ; i++)
00909 (*array2D)[i] = (*array2D)[i-1] + dim1 ;
00910
00911 return dim0 * (sizeof(double*) + dim1 * sizeof(double));
00912 }
00913
00924 int get_mem2Dodouble(double ***array2D, int dim0, int dim1, int offset)
00925 {
00926 int i;
00927
00928 if((*array2D = (double**)malloc(dim0 * sizeof(double*))) == NULL)
00929 no_mem_exit("get_mem2Dodouble: array2D");
00930 if(((*array2D)[0] = (double* )calloc(dim0 * dim1, sizeof(double ))) == NULL)
00931 no_mem_exit("get_mem2Dodouble: array2D");
00932
00933 (*array2D)[0] += offset;
00934
00935 for(i=1 ; i<dim0 ; i++)
00936 (*array2D)[i] = (*array2D)[i-1] + dim1 ;
00937
00938 return dim0 * (sizeof(double*) + dim1 * sizeof(double));
00939 }
00940
00950 int get_mem3Dodouble(double ****array3D, int dim0, int dim1, int dim2, int offset)
00951 {
00952 int i,j;
00953
00954 if(((*array3D) = (double***)malloc(dim0 * sizeof(double**))) == NULL)
00955 no_mem_exit("get_mem3Dodouble: array3D");
00956
00957 if(((*array3D)[0] = (double** )calloc(dim0 * dim1, sizeof(double*))) == NULL)
00958 no_mem_exit("get_mem3Dodouble: array3D");
00959
00960 (*array3D) [0] += offset;
00961
00962 for(i=1 ; i<dim0 ; i++)
00963 (*array3D)[i] = (*array3D)[i-1] + dim1 ;
00964
00965 for (i = 0; i < dim0; i++)
00966 for (j = -offset; j < dim1 - offset; j++)
00967 if(((*array3D)[i][j] = (double* )calloc(dim2, sizeof(double))) == NULL)
00968 no_mem_exit("get_mem3Dodouble: array3D");
00969
00970 return dim0*( sizeof(double**) + dim1 * ( sizeof(double*) + dim2 * sizeof(double)));
00971 }
00972
00973
00984 int get_offset_mem2Dshort(short ***array2D, int dim0, int dim1, int offset_y, int offset_x)
00985 {
00986 int i;
00987
00988 if((*array2D = (short**)malloc(dim0 * sizeof(short*))) == NULL)
00989 no_mem_exit("get_offset_mem2Dshort: array2D");
00990
00991 if(((*array2D)[0] = (short* )calloc(dim0 * dim1, sizeof(short))) == NULL)
00992 no_mem_exit("get_offset_mem2Dshort: array2D");
00993 (*array2D)[0] += offset_x + offset_y * dim1;
00994
00995 for(i=-1 ; i > -offset_y - 1; i--)
00996 {
00997 (*array2D)[i] = (*array2D)[i+1] - dim1;
00998 }
00999
01000 for(i=1 ; i < dim1 - offset_y; i++)
01001 (*array2D)[i] = (*array2D)[i-1] + dim1;
01002
01003 return dim0 * (sizeof(short*) + dim1 * sizeof(short));
01004 }
01005
01015 int get_mem3Doint(int ****array3D, int dim0, int dim1, int dim2, int offset)
01016 {
01017 int i,j;
01018
01019 if(((*array3D) = (int***)malloc(dim0 * sizeof(int**))) == NULL)
01020 no_mem_exit("get_mem3Doint: array3D");
01021
01022 if(((*array3D)[0] = (int** )calloc(dim0 * dim1, sizeof(int*))) == NULL)
01023 no_mem_exit("get_mem3Doint: array3D");
01024
01025 (*array3D) [0] += offset;
01026
01027 for(i=1 ; i<dim0 ; i++)
01028 (*array3D)[i] = (*array3D)[i-1] + dim1 ;
01029
01030 for (i = 0; i < dim0; i++)
01031 for (j = -offset; j < dim1 - offset; j++)
01032 if(((*array3D)[i][j] = (int* )calloc(dim2, sizeof(int))) == NULL)
01033 no_mem_exit("get_mem3Doint: array3D");
01034
01035 return dim0 * (sizeof(int**) + dim1 * (sizeof(int*) + dim2 * sizeof(int)));
01036 }
01037
01048 int get_mem2Doint(int ***array2D, int dim0, int dim1, int offset)
01049 {
01050 int i;
01051
01052 if((*array2D = (int**)malloc(dim0 * sizeof(int*))) == NULL)
01053 no_mem_exit("get_mem2Dint: array2D");
01054 if(((*array2D)[0] = (int* )calloc(dim0 * dim1, sizeof(int))) == NULL)
01055 no_mem_exit("get_mem2Dint: array2D");
01056
01057 (*array2D)[0] += offset;
01058
01059 for(i=1 ; i<dim0 ; i++)
01060 (*array2D)[i] = (*array2D)[i-1] + dim1 ;
01061
01062 return dim0 * (sizeof(int*) + dim1 * sizeof(int));
01063 }
01064
01065
01075
01076 int get_mem3Ddouble(double ****array3D, int dim0, int dim1, int dim2)
01077 {
01078 int j, mem_size = dim0 * sizeof(double**);
01079
01080 double **array2D;
01081
01082 if(((*array3D) = (double***)malloc(dim0 * sizeof(double**))) == NULL)
01083 no_mem_exit("get_mem3Ddouble: array3D");
01084
01085 mem_size += get_mem2Ddouble(&array2D, dim0 * dim1, dim2);
01086
01087 for(j = 0; j < dim0; j++)
01088 {
01089 (*array3D)[j] = &array2D[j * dim1];
01090 }
01091
01092 return mem_size;
01093 }
01094
01102 void free_mem2Ddouble(double **array2D)
01103 {
01104 if (array2D)
01105 {
01106 if (*array2D)
01107 free (*array2D);
01108 else
01109 error ("free_mem2Ddouble: trying to free unused memory",100);
01110
01111 free (array2D);
01112
01113 }
01114 else
01115 {
01116 error ("free_mem2Ddouble: trying to free unused memory",100);
01117 }
01118 }
01119
01120
01128 void free_mem2Dodouble(double **array2D, int offset)
01129 {
01130 if (array2D)
01131 {
01132 array2D[0] -= offset;
01133 if (array2D[0])
01134 free (array2D[0]);
01135 else error ("free_mem2Dodouble: trying to free unused memory",100);
01136
01137 free (array2D);
01138
01139 } else
01140 {
01141 error ("free_mem2Dodouble: trying to free unused memory",100);
01142 }
01143 }
01144
01151 void free_mem3Dodouble(double ***array3D, int dim0, int dim1, int offset)
01152 {
01153 int i, j;
01154
01155 if (array3D)
01156 {
01157 for (i = 0; i < dim0; i++)
01158 {
01159 for (j = -offset; j < dim1 - offset; j++)
01160 {
01161 if (array3D[i][j])
01162 free(array3D[i][j]);
01163 else
01164 error ("free_mem3Dodouble: trying to free unused memory",100);
01165 }
01166 }
01167 array3D[0] -= offset;
01168 if (array3D[0])
01169 free(array3D[0]);
01170 else
01171 error ("free_mem3Dodouble: trying to free unused memory",100);
01172 free (array3D);
01173 }
01174 else
01175 {
01176 error ("free_mem3Dodouble: trying to free unused memory",100);
01177 }
01178 }
01179
01186 void free_mem3Doint(int ***array3D, int dim0, int dim1, int offset)
01187 {
01188 int i, j;
01189
01190 if (array3D)
01191 {
01192 for (i = 0; i < dim0; i++)
01193 {
01194 for (j = -offset; j < dim1 - offset; j++)
01195 {
01196 if (array3D[i][j])
01197 free(array3D[i][j]);
01198 else
01199 error ("free_mem3Doint: trying to free unused memory",100);
01200 }
01201 }
01202 array3D[0] -= offset;
01203 if (array3D[0])
01204 free(array3D[0]);
01205 else
01206 error ("free_mem3Doint: trying to free unused memory",100);
01207 free (array3D);
01208 }
01209 else
01210 {
01211 error ("free_mem3Doint: trying to free unused memory",100);
01212 }
01213 }
01214
01215
01223 void free_mem2Doint(int **array2D, int offset)
01224 {
01225 if (array2D)
01226 {
01227 array2D[0] -= offset;
01228 if (array2D[0])
01229 free (array2D[0]);
01230 else
01231 error ("free_mem2Doint: trying to free unused memory",100);
01232
01233 free (array2D);
01234
01235 }
01236 else
01237 {
01238 error ("free_mem2Doint: trying to free unused memory",100);
01239 }
01240 }
01241
01249 void free_offset_mem2Dshort(short **array2D, int dim1, int offset_y, int offset_x)
01250 {
01251 if (array2D)
01252 {
01253 array2D[0] -= offset_x + offset_y * dim1;
01254 if (array2D[0])
01255 free (array2D[0]);
01256 else
01257 error ("free_offset_mem2Dshort: trying to free unused memory",100);
01258
01259 free (array2D);
01260
01261 }
01262 else
01263 {
01264 error ("free_offset_mem2Dshort: trying to free unused memory",100);
01265 }
01266 }
01267
01275 void free_mem3Ddouble(double ***array3D)
01276 {
01277 if (array3D)
01278 {
01279 free_mem2Ddouble(*array3D);
01280 free (array3D);
01281 }
01282 else
01283 {
01284 error ("free_mem3D: trying to free unused memory",100);
01285 }
01286 }
01287
01288