12 unsigned int negativeGap;
13 unsigned int deltaCodesSize; // En palabras
14 unsigned int *deltaCodes;
15 unsigned int numberOfSamples;
16 unsigned int *samples;
17 unsigned int *pointers;
18 unsigned int totalMem; // the size in bytes used;
22 // PROTOTIPOS DE FUNCI�NS
23 DeltaCompressedPsi deltaCompressPsi(unsigned int *Psi, unsigned int psiSize, unsigned int T);
24 int getDeltaPsiValue(DeltaCompressedPsi *cPsi, unsigned int position);
25 void storeDeltaCompressedPsi(DeltaCompressedPsi *compressedPsi, char *filename);
26 DeltaCompressedPsi loadDeltaCompressedPsi(char *filename);
27 void destroyDeltaCodesCompressedPsi(DeltaCompressedPsi *compressedPsi);
29 // IMPLEMENTACI�N DAS FUNCI�NS
31 //void destroyDeltaCodesCompressedPsi(DeltaCompressedPsi *compressedPsi) {
32 // free(compressedPsi->deltaCodes);
33 // free(compressedPsi->samples);
34 // free(compressedPsi->pointers);
38 //DeltaCompressedPsi deltaCompressPsi(unsigned int *Psi, unsigned int psiSize, unsigned int T) {
40 // DeltaCompressedPsi cPsi;
42 // int numberOfSamples;
43 // register int diff, deltaCodesPos;
44 // register unsigned int k, p, aux, diffpositive, code, index;
45 // unsigned int samplesIndex, codeLenght, currentInput, wordsDeltaCodes, totalSize;
46 // unsigned int *deltaCodes;
47 // unsigned int *samples;
48 // unsigned int *pointers;
50 // // Auxiliar para deltaCodes (estimamos como espacio maximo o do array de sufixos)
51 // unsigned int *deltaCodesAux;
53 // // Calculamos o mellor valor para negativeGap <= 64
54 // unsigned int negativeGap;
55 // register unsigned int maxNegativeBits = 0;
61 // if(maxNegativeBits<=26) negativeGap = 64;
62 // else negativeGap = 1<<(32-maxNegativeBits);
64 // // Reservamos espacio para as estructuras
65 // numberOfSamples = (psiSize + T - 1) / T;
66 // samples = (unsigned int *)malloc(sizeof(int)*numberOfSamples);
67 // pointers = (unsigned int *)malloc(sizeof(int)*numberOfSamples);
69 // deltaCodesAux = (unsigned int *)malloc(sizeof(int)*psiSize);
70 // for(index=0; index<psiSize; index++) deltaCodesAux[index] = 0;
74 // for(index=0; index<psiSize; index++) {
78 // diff = Psi[index] - currentInput;
79 // currentInput = Psi[index];
81 // // Calculamos o codigo correspondente
82 // if(diff>0) diffpositive = (negativeGap*diff-1)/(negativeGap-1);
83 // else diffpositive = -negativeGap*diff;
86 // aux = diffpositive;
98 // code = diffpositive & ((1<<(k-1))-1);
99 // codeLenght = 2*p+k-2;
101 // // Primeiro metemos os p-1 0's iniciais
102 // deltaCodesPos += p-1;
104 // // Agora metemos os p bits de k
105 // if( ((deltaCodesPos%32) + p) > 32 ) {
106 // deltaCodesAux[deltaCodesPos/32] |= (k>>((deltaCodesPos%32)+p-32));
107 // deltaCodesAux[deltaCodesPos/32+1] = (k<<(64-(deltaCodesPos%32)-p));
109 // deltaCodesAux[deltaCodesPos/32] |= (k<<(32-p-(deltaCodesPos%32)));
111 // deltaCodesPos += p;
113 // // Por �ltimo metemos os k-1 bits de code (sen o 1 inicial)
114 // if( ((deltaCodesPos%32) + (k-1)) > 32 ) {
115 // deltaCodesAux[deltaCodesPos/32] |= (code>>((deltaCodesPos%32)+(k-1)-32));
116 // deltaCodesAux[deltaCodesPos/32+1] = (code<<(64-(deltaCodesPos%32)-(k-1)));
118 // deltaCodesAux[deltaCodesPos/32] |= (code<<(32-(k-1)-(deltaCodesPos%32)));
120 // deltaCodesPos += k-1;
123 // samples[samplesIndex] = Psi[index];
124 // pointers[samplesIndex++] = deltaCodesPos;
125 // currentInput = Psi[index];
130 // // Ahora que xa sabemos o espacio necesario para os deltaCodes, reservamolo e liberamos a estructura auxiliar
131 // wordsDeltaCodes = (deltaCodesPos+31)/32;
132 // deltaCodes = (unsigned int *)malloc(sizeof(int)*wordsDeltaCodes);
133 // for(index=0;index<wordsDeltaCodes;index++) deltaCodes[index] = deltaCodesAux[index];
134 // free(deltaCodesAux);
136 // totalSize = sizeof(int)*wordsDeltaCodes + 2*sizeof(int)*numberOfSamples + 4*sizeof(int);
137 // printf("Compressed Psi size = %d bytes\n", totalSize);
139 // // Asignamos os valores a cPsi e devolvemolo
141 // cPsi.negativeGap = negativeGap;
142 // cPsi.deltaCodesSize = wordsDeltaCodes;
143 // cPsi.deltaCodes = deltaCodes;
144 // cPsi.numberOfSamples = numberOfSamples;
145 // cPsi.samples = samples;
146 // cPsi.pointers = pointers;
152 //int getDeltaPsiValue(DeltaCompressedPsi *cPsi, unsigned int position) {
155 // register unsigned int code, aux, pointerAux, mask, pointer, toDecode, p, k;
157 // // Collemos a mostra inmediatamente inferior, e o punteiro o array de codigos
158 // // pointer = punteiro absoluto sobre deltaCodes
159 // result = cPsi->samples[position/cPsi->T];
160 // pointer = cPsi->pointers[position/cPsi->T];
162 // // Calculamos o numero de codigos a decodificar a partir da mostra
163 // toDecode = position % cPsi->T;
165 // while(toDecode--) {
167 // // Collemos o n�mero ceros iniciais
168 // // Po�emos o inicio do c�digo nun enteiro (code) alineado a esquerda
169 // // Non importa que non colla todo o c�digo, pero si temos asegurado que
170 // // colle p e k (k<=32 (6bits), p<=5bits)
171 // code = (cPsi->deltaCodes[pointer/32] << (pointer%32)) |
172 // ((pointer%32 != 0) * (cPsi->deltaCodes[pointer/32+1] >> (32-(pointer%32))));
174 // //Ahora contamos o n�mero de ceros (p) que hai nas posicions da esquerda de code
176 // while(!(code & 0x80000000)) {
181 // // Ahora calculamos o numero de digitos da representacion binaria do codigo (k)
182 // k = code >> (32-p);
184 // // Actualizamos o punteiro global sobre deltaCodes
187 // // Po�emos a representacion binaria do codigo nun enteiro (code) alineado a esquerda
188 // code = (cPsi->deltaCodes[pointer/32] << (pointer%32)) |
189 // ((pointer%32 != 0) * (cPsi->deltaCodes[pointer/32+1] >> (32-(pointer%32))));
190 // code = ((code >> 1) | 0x80000000) >> (32-k);
194 // if(code % cPsi->negativeGap) result += (code - (code/cPsi->negativeGap));
195 // else result -= code/cPsi->negativeGap;
204 //void storeDeltaCompressedPsi(DeltaCompressedPsi *compressedPsi, char *filename) {
208 // if( (file = open(filename, O_WRONLY|O_CREAT, 0700)) < 0) {
209 // printf("Cannot open file %s\n", filename);
212 // write(file, &(compressedPsi->T), sizeof(int));
213 // write(file, &(compressedPsi->negativeGap), sizeof(int));
214 // write(file, &(compressedPsi->deltaCodesSize), sizeof(int));
215 // write(file, compressedPsi->deltaCodes, compressedPsi->deltaCodesSize*sizeof(int));
216 // write(file, &(compressedPsi->numberOfSamples), sizeof(int));
217 // write(file, compressedPsi->samples, compressedPsi->numberOfSamples*sizeof(int));
218 // write(file, compressedPsi->pointers, compressedPsi->numberOfSamples*sizeof(int));
224 //DeltaCompressedPsi loadDeltaCompressedPsi(char *filename) {
226 // DeltaCompressedPsi compressedPsi;
230 // if( (file = open(filename, O_RDONLY)) < 0) {
231 // printf("Cannot read file %s\n", filename);
234 // read(file, &(compressedPsi.T), sizeof(int));
235 // read(file, &(compressedPsi.negativeGap), sizeof(int));
236 // read(file, &(compressedPsi.deltaCodesSize), sizeof(int));
237 // compressedPsi.deltaCodes = (unsigned int *)malloc(compressedPsi.deltaCodesSize*sizeof(int));
238 // read(file, compressedPsi.deltaCodes, compressedPsi.deltaCodesSize*sizeof(int));
239 // read(file, &(compressedPsi.numberOfSamples), sizeof(int));
240 // compressedPsi.samples = (unsigned int *)malloc(compressedPsi.numberOfSamples*sizeof(int));
241 // compressedPsi.pointers = (unsigned int *)malloc(compressedPsi.numberOfSamples*sizeof(int));
242 // read(file, compressedPsi.samples, compressedPsi.numberOfSamples*sizeof(int));
243 // read(file, compressedPsi.pointers, compressedPsi.numberOfSamples*sizeof(int));
246 // return compressedPsi;