5 respuestas en este tema

[pcicom]

Saludos desde mi desmadrado Monterrey..

sabran de alguna rutina para comprimit strings, lo que quiero realizar es grabar algunos strings que en promedio miden de 5 a 10k comprimido, de tal forma que ocupen menos espacio y que evite mandar lo mas posible datos..


Y como dijo copernico....  y sin embargo se mueve..

[escafandra]

Puedes echar un vistazo a este código de seoane.

Tambien puedes usar la utilidad Compress.exe de windows, que alguna vez he utilizado

Comprimir:

cpp

void
ComprimeArchivo(char* Origen)
{
  char Command[MAXPATH];
  strcpy(Command, "Compress -r ");
  strcat(Command, Origen);
  WinExec(Command, SW_HIDE);
  for(; FindWindow(0, "COMPRESS"); kbhit());
}

Descomprimir:

cpp

void
DesComprimeArchivo(const char* SrcFile, const char* dstPath = 0)
{
  char DstFile[255];
  char DstPath[255];
  OFSTRUCT ofStrSrc;
  OFSTRUCT ofStrDest;
  HFILE hfSrcFile, hfDstFile;
 
  int error = GetExpandedName((char*)SrcFile, DstFile);
  if(error==0) return;
  if(dstPath){
	  strcpy(DstPath, dstPath);
	  MkDir(DstPath);
	  if(DstPath[strlen(DstPath)-1] != '\\') strcat(DstPath, "\\");
	  strcat(DstPath, DstFile);
	  strcpy(DstFile, DstPath);
  }
  LZStart();
  hfSrcFile = LZOpenFile((char*)SrcFile, &ofStrSrc, OF_READ);
  hfDstFile = LZOpenFile(DstFile, &ofStrDest, OF_CREATE);
  CopyLZFile(hfSrcFile, hfDstFile);   // Copia y descomprime;
  LZClose(hfSrcFile);
  LZClose(hfDstFile);
  LZDone(); 
}

Saludos.

[seoane]

Yo te recomiendo usar la librería zlib, que ya viene incluida con delphi.

delphi

uses ZLib;
 
procedure GuardarString(Archivo, Str: String);
var
  Src: TStringStream;
  Dst: TFileStream;
begin
  Src:= TStringStream.Create(Str);
  try
    Dst:= TFileStream.Create(Archivo,fmCreate);
    try
      with TCompressionStream.Create(clMax,Dst) do
      try
        CopyFrom(Src,0);
      finally
        Free;
      end;
    finally
      Dst.Free;
    end;
  finally
    Src.Free;
  end;
end;
 
const
  BUFFERSIZE = 1024*1024;
 
function LeerString(Archivo: String): String;
var
  Src: TFileStream;
  Dst: TStringStream;
  Buffer: PByte;
  i: Integer;
begin
  Result:= EmptyStr;
  Src:= TFileStream.Create(Archivo,fmOpenRead);
  try
    Dst:= TStringStream.Create(EmptyStr);;
    try
      // Comprimimos el fichero
      with TDeCompressionStream.Create(Src) do
      try
        GetMem(Buffer,BUFFERSIZE);
        try
          i:= Read(Buffer^,BUFFERSIZE);
          while i > 0  do
          begin
            Dst.Write(Buffer^,i);
            i:= Read(Buffer^,BUFFERSIZE);
          end;
          Result:= Dst.DataString;
        finally
          FreeMem(Buffer);
        end;
      finally
        Free;
      end;
    finally
      Dst.Free;
    end;
  finally
    Src.Free;
  end;
end;
 
// Por ejemplo
  GuardarString('e:\1.bin','Hola mundo');
  ShowMessage(LeerString('e:\1.bin'));

[pcicom]

Gracias Escafandra y SEOANE..

Encontre en este lnik  http://hh.pastebin.com/f76921bb7

un codigo muy parecido al de la PAGINA de SEOANE..

En el se incluyen rutinas para comprimir un STRING...  pero la verdad no disminuye mucho el contenido..

[seoane]

...  pero la verdad no disminuye mucho el contenido..

La verdad es que RtlCompressBuffer no comprime demasiado bien.

Pero ¿probaste el código que pongo aquí? uso zlib que si que tiene un ratio de compresión bastante bueno.

[pcicom]

Gracias SEOANE, si si lo PROBE y esta mejor que el OTRO...
Y en unas pruebas he comprobado que incluso el hacer un ENCODE64 tambien lo comprime los strings bien..

Mi idea es grabar el STRING en un campo tipo VARCHAR, pero como al comprimirlo mete codigo binario lo tendria que grabar con un formato tipo ANSI .. para que no tenga problemas por lo que lo estoy convirtiendo a  base 64..

Algo ASI estoy haciendo..

sql

   INSERT INTO (campo1,campo2......  campoBase64_1,campoBase64_2) 
          VALUES (dato1.......,'IiBkZXNjcmlwY2lvbj0iRkxFVEUgNDA5NiBERSBGRUNIQSAwMy8xMS8wO
SIgdW5pZGFkPSJTRVIiIHZhbG9yVW5pdGFyaW89IjQzODkuNCIgaW1wb3J0ZT0iNDM4OS40IiAvPg0KI=',  ...)

Una pequeña modificacion al codigo que pusiste lo realiza, la compresion esta muy bien, pero al convertirla a base 64 lo hace mas GRANDE..

delphi

Function ComprimeString64(Str: String):String;
var
   Src,Dst: TStringStream;
   cResult: String;
//   Dst: TFileStream;
begin
   cResult := '';
   Src:= TStringStream.Create(Str);
   try
//      Dst:= TFileStream.Create(Archivo,fmCreate);
      Dst := TStringStream.Create('');
      try
         with TCompressionStream.Create(clMax,Dst) do
         try
            CopyFrom(Src,0);
         finally
            Free;
         end;
      finally
         cResult := Base64Encode(dst.DataString);
         Dst.Free;
      end;
   finally
      Src.Free;
   end;
   Result := cResult;
end;

Aun asi estoy tratando de definir el mejor metodo...