swcsa/intIndex/psiDeltaCode.h

   1 #include <stdlib.h>
   2 #include <stdio.h>
   3 //#include <malloc.h>
   4 #include <unistd.h>
   5 #include <fcntl.h>
   6
   7
   8
   9
  10 typedef struct {
  11         unsigned int T;
  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;
  19 } DeltaCompressedPsi;
  20
  21
  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);
  28
  29 // IMPLEMENTACI�N DAS FUNCI�NS
  30
  31 //void destroyDeltaCodesCompressedPsi(DeltaCompressedPsi *compressedPsi) {
  32 //      free(compressedPsi->deltaCodes);
  33 //      free(compressedPsi->samples);
  34 //      free(compressedPsi->pointers);
  35 //}
  36 //
  37 //
  38 //DeltaCompressedPsi deltaCompressPsi(unsigned int *Psi, unsigned int psiSize, unsigned int T) {
  39 //
  40 //      DeltaCompressedPsi cPsi;
  41 //
  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;
  49 //
  50 //      // Auxiliar para deltaCodes (estimamos como espacio maximo o do array de sufixos)
  51 //      unsigned int *deltaCodesAux;
  52 //
  53 //      // Calculamos o mellor valor para negativeGap <= 64
  54 //      unsigned int negativeGap;
  55 //      register unsigned int maxNegativeBits = 0;
  56 //      k = psiSize;
  57 //      while(k) {
  58 //              k >>= 1;
  59 //              maxNegativeBits++;
  60 //      }
  61 //      if(maxNegativeBits<=26) negativeGap = 64;
  62 //      else negativeGap = 1<<(32-maxNegativeBits);
  63 //
  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);
  68 //
  69 //      deltaCodesAux = (unsigned int *)malloc(sizeof(int)*psiSize);
  70 //      for(index=0; index<psiSize; index++) deltaCodesAux[index] = 0;
  71 //
  72 //      samplesIndex = 0;
  73 //      deltaCodesPos = 0;
  74 //      for(index=0; index<psiSize; index++) {
  75 //
  76 //              if(index % T) {
  77 //
  78 //                      diff = Psi[index] - currentInput;
  79 //                      currentInput = Psi[index];
  80 //
  81 //                      // Calculamos o codigo correspondente
  82 //                      if(diff>0) diffpositive = (negativeGap*diff-1)/(negativeGap-1);
  83 //                      else diffpositive = -negativeGap*diff;
  84 //
  85 //                      k = 0;
  86 //                      aux = diffpositive;
  87 //                      while(aux) {
  88 //                              aux >>= 1;
  89 //                              k++;
  90 //                      }
  91 //                      aux = k;
  92 //                      p = 0;
  93 //                      while(aux) {
  94 //                              aux >>= 1;
  95 //                              p++;
  96 //                      }
  97 //
  98 //                      code = diffpositive & ((1<<(k-1))-1);
  99 //                      codeLenght = 2*p+k-2;
 100 //
 101 //                      // Primeiro metemos os p-1 0's iniciais
 102 //                      deltaCodesPos += p-1;
 103 //
 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));
 108 //                      } else {
 109 //                              deltaCodesAux[deltaCodesPos/32] |= (k<<(32-p-(deltaCodesPos%32)));
 110 //                      }
 111 //                      deltaCodesPos += p;
 112 //
 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)));
 117 //                      } else {
 118 //                              deltaCodesAux[deltaCodesPos/32] |= (code<<(32-(k-1)-(deltaCodesPos%32)));
 119 //                      }
 120 //                      deltaCodesPos += k-1;
 121 //
 122 //              } else {
 123 //                      samples[samplesIndex] = Psi[index];
 124 //                      pointers[samplesIndex++] = deltaCodesPos;
 125 //                      currentInput = Psi[index];
 126 //              }
 127 //
 128 //      }
 129 //
 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);
 135 //
 136 //      totalSize = sizeof(int)*wordsDeltaCodes + 2*sizeof(int)*numberOfSamples + 4*sizeof(int);
 137 //      printf("Compressed Psi size = %d bytes\n", totalSize);
 138 //
 139 //      // Asignamos os valores a cPsi e devolvemolo
 140 //      cPsi.T = T;
 141 //      cPsi.negativeGap = negativeGap;
 142 //      cPsi.deltaCodesSize = wordsDeltaCodes;
 143 //      cPsi.deltaCodes = deltaCodes;
 144 //      cPsi.numberOfSamples = numberOfSamples;
 145 //      cPsi.samples = samples;
 146 //      cPsi.pointers = pointers;
 147 //      return cPsi;
 148 //
 149 //}
 150 //
 151 //
 152 //int getDeltaPsiValue(DeltaCompressedPsi *cPsi, unsigned int position) {
 153 //
 154 //      int result;
 155 //      register unsigned int code, aux, pointerAux, mask, pointer, toDecode, p, k;
 156 //
 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];
 161 //
 162 //      // Calculamos o numero de codigos a decodificar a partir da mostra
 163 //      toDecode = position % cPsi->T;
 164 //
 165 //      while(toDecode--) {
 166 //
 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))));
 173 //
 174 //              //Ahora contamos o n�mero de ceros (p) que hai nas posicions da esquerda de code
 175 //              p = 1;
 176 //              while(!(code & 0x80000000)) {
 177 //                      code <<= 1;
 178 //                      p++;
 179 //              }
 180 //
 181 //              // Ahora calculamos o numero de digitos da representacion binaria do codigo (k)
 182 //              k = code >> (32-p);
 183 //
 184 //              // Actualizamos o punteiro global sobre deltaCodes
 185 //              pointer += 2*p-1;
 186 //
 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);
 191 //              pointer += k-1;
 192 //
 193 //              // Bixecci�n
 194 //              if(code % cPsi->negativeGap) result += (code - (code/cPsi->negativeGap));
 195 //              else result -= code/cPsi->negativeGap;
 196 //
 197 //      }
 198 //
 199 //      return result;
 200 //
 201 //}
 202 //
 203 //
 204 //void storeDeltaCompressedPsi(DeltaCompressedPsi *compressedPsi, char *filename) {
 205 //
 206 //      int file;
 207 //
 208 //      if( (file = open(filename, O_WRONLY|O_CREAT, 0700)) < 0) {
 209 //              printf("Cannot open file %s\n", filename);
 210 //              exit(0);
 211 //      }
 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));
 219 //      close(file);
 220 //
 221 //}
 222 //
 223 //
 224 //DeltaCompressedPsi loadDeltaCompressedPsi(char *filename) {
 225 //
 226 //      DeltaCompressedPsi compressedPsi;
 227 //
 228 //      int file;
 229 //
 230 //      if( (file = open(filename, O_RDONLY)) < 0) {
 231 //              printf("Cannot read file %s\n", filename);
 232 //              exit(0);
 233 //      }
 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));
 244 //      close(file);
 245 //
 246 //      return compressedPsi;
 247 //
 248 //}