swcsa/intIndex/psiGonzalo.h

   1 #include <stdlib.h>
   2 #include <stdio.h>
   3 #include <malloc.h>
   4 #include "../utils/huff.h"
   5
   6 // ESTRUCTURA QUE REPRESENTA A FUNCION PSI COMPRIMIDA
   7 typedef struct {
   8         uint links;
   9         uint totexc;
  10         uint samplen;
  11         uint bplen;
  12         uint pslen;
  13         uint *cPsi;
  14         uint *bposS;
  15         THuff Hacc;
  16         THuff Hlen;
  17         unsigned int totalMem;                  // the size in bytes used;
  18 } GonzaloCompressedPsi;
  19
  20
  21 // PROTOTIPOS DE FUNCIONS
  22 GonzaloCompressedPsi gonzaloCompressPsi(uint *Psi, uint psiSize, uint T, uint HUFF);
  23 int getGonzaloPsiValue(GonzaloCompressedPsi *compressedPsi, unsigned int position);
  24 void storeGonzaloCompressedPsi(GonzaloCompressedPsi *compressedPsi, char *filename);
  25 GonzaloCompressedPsi loadGonzaloCompressedPsi(char *filename);
  26 //frees the memory used.
  27 void destroyGonzaloCompressedPsi(GonzaloCompressedPsi *compressedPsi);
  28
  29
  30 //// IMPLEMENTACI�N DAS FUNCI�NS
  31 //
  32 //void destroyGonzaloCompressedPsi(GonzaloCompressedPsi *compressedPsi) {
  33 //
  34 //      //free(compressedPsi->Hlen.s.spos);
  35 //      //free(compressedPsi->Hacc.s.spos);
  36 //      freeHuff(compressedPsi->Hlen);
  37 //      freeHuff(compressedPsi->Hacc);
  38 //      free(compressedPsi->cPsi);
  39 //      free(compressedPsi->bposS);
  40 //}
  41 //
  42 //
  43 //GonzaloCompressedPsi gonzaloCompressPsi(uint *Psi, uint psiSize, uint T, uint HUFF) {
  44 //
  45 //      GonzaloCompressedPsi compressedPsi;
  46 //
  47 //      register uint i;
  48 //      uint oi,j;
  49 //      int ok,k;
  50 //      register uint _cptr;
  51 //
  52 //      uint *_cPsi;
  53 //      uint *_bposS;
  54 //
  55 //      uint links = psiSize;
  56 //      uint samplen = T;
  57 //      uint _bplen;
  58 //      uint pslen;
  59 //      uint totexc;
  60 //
  61 //      uint *acc,*lacc;
  62 //      THuff Hacc, Hlen;
  63 //
  64 //      uint totalSize;
  65 //
  66 //      // Construe os arboles de huffman, o dos valores directos
  67 //      // e o das lonxitudes dos runs. Usa como vectores auxiliares de frecuencias
  68 //      // a acc e lacc, que finalmente libera.
  69 //      acc = (uint *)malloc (HUFF*sizeof(uint));
  70 //      lacc = (uint *)malloc ((samplen-1)*sizeof(uint));
  71 //      for (k=0;k<HUFF;k++) acc[k]=0;
  72 //      for (k=0;k<samplen-1;k++) lacc[k]=0;
  73 //
  74 //      ok = 0;
  75 //      k = Psi[0];
  76 //      for (i=0;i<=links;i++) {
  77 //              if ((k == 1) && (i % samplen)) { if (ok != 1) oi = i; }
  78 //              else {
  79 //                      if (ok == 1) {
  80 //                              acc[1]++;
  81 //                          lacc[i-oi-1]++;
  82 //                      }
  83 //                  if (i % samplen)
  84 //                              if ((k < 1) || (k >= HUFF)) acc[0]++;
  85 //                      else acc[k]++;
  86 //              }
  87 //          ok = (i % samplen) ? k : 0;
  88 //              k = Psi[i+1]-Psi[i];
  89 //      }
  90 //
  91 //      if (ok == 1) {
  92 //              acc[1]++;
  93 //              lacc[i-oi-1]++;
  94 //      }
  95 //
  96 //      Hacc = createHuff (acc,HUFF-1, UNSORTED);
  97 //      Hlen = createHuff (lacc,samplen-2, UNSORTED);
  98 //      totexc = acc[0];
  99 //      pslen = bits(psiSize+1);
 100 //      _bplen = bits(Hacc.total+Hlen.total+(1+links/samplen+totexc)*pslen);
 101 //      _bposS = (uint *)malloc ((((1+links/samplen)*_bplen+W-1)/W)*sizeof(uint));
 102 //      _cPsi  = (uint *)malloc (((Hacc.total+Hlen.total+(1+links/samplen+totexc)*pslen+W-1)/W)*sizeof(uint));
 103 //
 104 //      _cptr = 0;
 105 //      ok = 0;
 106 //      k = Psi[0];
 107 //
 108 //      for (i=0;i<=links;i++) {
 109 //
 110 //              if ((k == 1) && (i % samplen)) { if (ok != 1) oi = i; }
 111 //              else {
 112 //                      if (ok == 1) {
 113 //                              _cptr = encodeHuff (Hacc,1,_cPsi,_cptr);
 114 //                          _cptr = encodeHuff(Hlen,i-oi-1,_cPsi,_cptr);
 115 //                      }
 116 //                      if (i % samplen) {
 117 //                              if ((k > 1) && (k < HUFF)) _cptr = encodeHuff (Hacc,k,_cPsi,_cptr);
 118 //                      else {
 119 //                                      _cptr = encodeHuff (Hacc,0,_cPsi,_cptr);
 120 //                              bitwrite (_cPsi,_cptr,pslen,Psi[i]);
 121 //                                      _cptr += pslen;
 122 //                              }
 123 //                      }
 124 //                      else {
 125 //                              bitwrite (_bposS,(i/samplen)*_bplen,_bplen,_cptr);
 126 //                          bitwrite (_cPsi,_cptr,pslen,Psi[i]);
 127 //                          _cptr += pslen;
 128 //                      }
 129 //              }
 130 //              ok = (i % samplen) ? k : 0;
 131 //              k = Psi[i+1]-Psi[i];
 132 //      }
 133 //
 134 //      if (ok == 1) {
 135 //              _cptr = encodeHuff (Hacc,1,_cPsi,_cptr);
 136 //              _cptr = encodeHuff(Hlen,i-oi-1,_cPsi,_cptr);
 137 //      }
 138 //
 139 //      // Calculamos o espacio total
 140 //      totalSize = (((1+links/samplen)*_bplen+W-1)/W)*sizeof(uint) +
 141 //              ((Hacc.total+Hlen.total+(1+links/samplen+totexc)*pslen+W-1)/W)*sizeof(uint) +
 142 //              5*sizeof(int) + sizeHuff(Hacc) + sizeHuff(Hlen);
 143 //      printf("Compressed Psi size = %d bytes\n", totalSize);
 144 //
 145 //      // Necesario antes de decodificar
 146 //      prepareToDecode(&Hacc);
 147 //      prepareToDecode(&Hlen);
 148 //
 149 //      // Asignamos os valores e devolvemos psi comprimido
 150 //      compressedPsi.links = psiSize;
 151 //      compressedPsi.totexc = totexc;
 152 //      compressedPsi.cPsi = _cPsi;
 153 //      compressedPsi.samplen = samplen;
 154 //      compressedPsi.bposS = _bposS;
 155 //      compressedPsi.bplen = _bplen;
 156 //      compressedPsi.pslen = pslen;
 157 //      compressedPsi.Hacc = Hacc;
 158 //      compressedPsi.Hlen = Hlen;
 159 //
 160 //      free(acc);
 161 //      free(lacc);
 162 //
 163 //      return compressedPsi;
 164 //}
 165 //
 166 //
 167 //
 168 //int getGonzaloPsiValue(GonzaloCompressedPsi *compressedPsi, unsigned int position) {
 169 //
 170 //      uint *cPsi = compressedPsi->cPsi;
 171 //      uint samplen = compressedPsi->samplen;
 172 //      uint *bposS = compressedPsi->bposS;
 173 //      uint bplen = compressedPsi->bplen;
 174 //      uint pslen = compressedPsi->pslen;
 175 //      THuff *Hacc = &compressedPsi->Hacc;
 176 //      THuff *Hlen = &compressedPsi->Hlen;
 177 //
 178 //      uint sampj,cptr,val,dval,rlen,head,hlen;
 179 //
 180 //      sampj = (position/samplen)*samplen;
 181 //      cptr = bitread(bposS,(sampj/samplen)*bplen,bplen);
 182 //      head = cptr;
 183 //      val = bitread(cPsi,head,pslen);
 184 //      head += pslen;
 185 //
 186 //      while (sampj < position) {
 187 //
 188 //              head = decodeHuff(Hacc,&dval,cPsi,head);
 189 //
 190 //              if (dval == 0) {
 191 //
 192 //                      val = bitread(cPsi,head,pslen);
 193 //                      head += pslen;
 194 //                      sampj++;
 195 //              }
 196 //              else
 197 //                      if (dval == 1) {
 198 //                              head = decodeHuff(Hlen,&rlen,cPsi,head);
 199 //                              rlen++;
 200 //                      if (sampj + rlen >= position) return val + (position-sampj);
 201 //                      val += rlen;
 202 //                      sampj += rlen;
 203 //                      }
 204 //                      else {
 205 //                              val += dval;
 206 //                      sampj++;
 207 //                      }
 208 //
 209 //      }
 210 //
 211 //      return val;
 212 //
 213 //}
 214 //
 215 //
 216 //void storeGonzaloCompressedPsi(GonzaloCompressedPsi *compressedPsi, char *filename) {
 217 //
 218 //      int file;
 219 //      THuff Hacc;
 220 //      THuff Hlen;
 221 //
 222 //      if( (file = open(filename, O_WRONLY|O_CREAT, 0700)) < 0) {
 223 //              printf("Cannot open file %s\n", filename);
 224 //              exit(0);
 225 //      }
 226 //
 227 //      // Copias locales dos arboles de HUFFMAN
 228 //      Hacc = compressedPsi->Hacc;
 229 //      Hlen = compressedPsi->Hlen;
 230 //
 231 //      write(file, &(compressedPsi->links), sizeof(int));
 232 //      write(file, &(compressedPsi->totexc), sizeof(int));
 233 //      write(file, &(compressedPsi->samplen), sizeof(int));
 234 //      write(file, &(compressedPsi->bplen), sizeof(int));
 235 //      write(file, &(compressedPsi->pslen), sizeof(int));
 236 //      // Almacenar o arbol de huffman principal
 237 //      write(file, &Hacc.max, sizeof(int));
 238 //      write(file, &Hacc.lim, sizeof(int));
 239 //      write(file, &Hacc.depth, sizeof(int));
 240 ////    write(file, Hacc.s.spos, (Hacc.lim+1)*sizeof(int));
 241 //      write(file, Hacc.s.symb, (Hacc.lim+1)*sizeof(int));
 242 //      write(file, Hacc.num, (Hacc.depth+1)*sizeof(int));
 243 //      write(file, Hacc.fst, (Hacc.depth+1)*sizeof(int));
 244 //      // Fin de almacenar o arbol de huffman principal
 245 //      // Almacenar o arbol de huffman das lonxitudes dos runs
 246 //      write(file, &Hlen.max, sizeof(int));
 247 //      write(file, &Hlen.lim, sizeof(int));
 248 //      write(file, &Hlen.depth, sizeof(int));
 249 ////    write(file, Hlen.s.spos, (Hlen.lim+1)*sizeof(int));
 250 //      write(file, Hlen.s.symb, (Hlen.lim+1)*sizeof(int));
 251 //      write(file, Hlen.num, (Hlen.depth+1)*sizeof(int));
 252 //      write(file, Hlen.fst, (Hlen.depth+1)*sizeof(int));
 253 //      // Fin de almacenar o arbol de huffman das lonxitudes dos runs
 254 //      write(file,     compressedPsi->bposS, ((compressedPsi->bplen*(1+compressedPsi->links/compressedPsi->samplen)+W-1)/W)*sizeof(uint));
 255 //      write(file,     compressedPsi->cPsi, ((Hacc.total+Hlen.total+(1+compressedPsi->links/compressedPsi->samplen+compressedPsi->totexc)*compressedPsi->pslen+W-1)/W)*sizeof(int));
 256 //
 257 //      close(file);
 258 //
 259 //}
 260 //
 261 //
 262 //GonzaloCompressedPsi loadGonzaloCompressedPsi(char *filename) {
 263 //
 264 //      GonzaloCompressedPsi compressedPsi;
 265 //
 266 //      THuff Hacc;
 267 //      THuff Hlen;
 268 //
 269 //      int file;
 270 //
 271 //      if( (file = open(filename, O_RDONLY)) < 0) {
 272 //              printf("Cannot read file %s\n", filename);
 273 //              exit(0);
 274 //      }
 275 //      read(file, &(compressedPsi.links), sizeof(int));
 276 //      read(file, &(compressedPsi.totexc), sizeof(int));
 277 //      read(file, &(compressedPsi.samplen), sizeof(int));
 278 //      read(file, &(compressedPsi.bplen), sizeof(int));
 279 //      read(file, &(compressedPsi.pslen), sizeof(int));
 280 //      // Cargamos o arbol de Huffman principal
 281 //      read(file, &Hacc.max, sizeof(int));
 282 //      read(file, &Hacc.lim, sizeof(int));
 283 //      read(file, &Hacc.depth, sizeof(int));
 284 //      //Hacc.s.spos = (unsigned int *) malloc((Hacc.lim+1)*sizeof(int));
 285 //      Hacc.s.symb = (unsigned int *) malloc((Hacc.lim+1)*sizeof(int));
 286 //      Hacc.num = (unsigned int *) malloc((Hacc.depth+1)*sizeof(int));
 287 //      Hacc.fst = (unsigned int *) malloc((Hacc.depth+1)*sizeof(int));
 288 //      //read(file, Hacc.s.spos, (Hacc.lim+1)*sizeof(int));
 289 //      read(file, Hacc.s.symb, (Hacc.lim+1)*sizeof(int));
 290 //      read(file, Hacc.num, (Hacc.depth+1)*sizeof(int));
 291 //      read(file, Hacc.fst, (Hacc.depth+1)*sizeof(int));
 292 //      compressedPsi.Hacc = Hacc;
 293 //      // Fin da carga do arbol de Huffman     principal
 294 //      // Cargamos o arbol de Huffman coas lonxitudes dos runs
 295 //      read(file, &Hlen.max, sizeof(int));
 296 //      read(file, &Hlen.lim, sizeof(int));
 297 //      read(file, &Hlen.depth, sizeof(int));
 298 //      //Hlen.s.spos = (unsigned int *) malloc((Hlen.lim+1)*sizeof(int));
 299 //      Hlen.s.symb = (unsigned int *) malloc((Hlen.lim+1)*sizeof(int));
 300 //      Hlen.num = (unsigned int *) malloc((Hlen.depth+1)*sizeof(int));
 301 //      Hlen.fst = (unsigned int *) malloc((Hlen.depth+1)*sizeof(int));
 302 //      //read(file, Hlen.s.spos, (Hlen.lim+1)*sizeof(int));
 303 //      read(file, Hlen.s.symb, (Hlen.lim+1)*sizeof(int));
 304 //      read(file, Hlen.num, (Hlen.depth+1)*sizeof(int));
 305 //      read(file, Hlen.fst, (Hlen.depth+1)*sizeof(int));
 306 //      compressedPsi.Hlen = Hlen;
 307 //      // Fin da carga do arbol de Huffman     coas lonxitudes dos runs
 308 //      compressedPsi.bposS = (uint *) malloc (((compressedPsi.bplen*(1+compressedPsi.links/compressedPsi.samplen)+W-1)/W)*sizeof(uint));
 309 //      read(file, compressedPsi.bposS, ((compressedPsi.bplen*(1+compressedPsi.links/compressedPsi.samplen)+W-1)/W)*sizeof(uint));
 310 //      compressedPsi.cPsi = (uint *) malloc (((Hacc.total+Hlen.total+(1+compressedPsi.links/compressedPsi.samplen+compressedPsi.totexc)*compressedPsi.pslen+W-1)/W)*sizeof(uint));
 311 //      read(file, compressedPsi.cPsi, ((Hacc.total+Hlen.total+(1+compressedPsi.links/compressedPsi.samplen+compressedPsi.totexc)*compressedPsi.pslen+W-1)/W)*sizeof(uint));
 312 //
 313 //      close(file);
 314 //
 315 //      return compressedPsi;
 316 //
 317 //}