begin process at 2012 02 11 19:33:55
  Trouver un code source :
 
dans
 
Accueil > 

Code

 > 

API

 > COMPRESSION BZ2 (MIEUX QUE ZLIB) EN C.

COMPRESSION BZ2 (MIEUX QUE ZLIB) EN C.


 Information sur la source

Note :
9,5 / 10 - par 2 personnes
9,50 / 10

  • 1

  • 2

  • 3

  • 4

  • 5

  • 6

  • 7

  • 8

  • 9

  • 10
Catégorie :API Niveau :Débutant Date de création :27/02/2004 Vu / téléchargé :9 282 / 458

Auteur : MetalDwarf

Ecrire un message privé
Commentaire sur cette source (16)
Ajouter un commentaire et/ou une note

 Description

Un simple petit code qui sert d'interface avec la libbz2, qui comme chacun sait compresse un peu mieux que la zlib.
C est une sorte de front-end, qui permet de compresser d'un fichier a la memoire ou d'un fichier a un fichier et pareil pour la decompression.
Les tests d'erreurs sont en principe tous fait, et le code est commente donc en principe pas de soucis.
C'est du C compile avec gcc sous Linux, mais il n'y a aucune raison que ca ne marche pas sous windows.

Source

  • /* bzcompress.c : compression/decompression bz2 (mieux que zlib)
  • * compile sous Linux, necessite la libbz2. Ce programme n'utilise pas de fonctions
  • * specifiques Linux, il devrait donc marcher sous windows.
  • * gcc -lbz2 bzcompress.c -o bzcompress
  • *
  • * (C) Metaldwarf 2004
  • */
  • #include <stdio.h>
  • #include <bzlib.h>
  • #define DEFAULT_BLOCK_SIZE 100 // taille des blocs par defaut en octets
  • /* file : fichier de destination
  • data : donnees a compresser
  • len : taille des donnes
  • retourne 0->succes
  • -1->echec
  • */
  • int compress_to_file(char *file, char *data, int len)
  • {
  • FILE *fd;
  • BZFILE *bh;
  • int bzerr;
  • int in, out;
  • int i;
  • if(!(fd = fopen(file,"w"))) return -1; // probleme IO
  • bh = BZ2_bzWriteOpen(&bzerr, fd, 9, 0, 30); // dans l'ordre : code d'erreur, fichier de sortie, parametre memoire,
  • // verbosite (0-4), facteur pour le compression (1-250)
  • if(bzerr != BZ_OK) // onquitte sur une erreur
  • {
  • fclose(fd);
  • BZ2_bzWriteClose(&bzerr,bh,1,&in,&out); // dans l'ordre : code d'erreur, flux BZ2, action a effectuer avant de quitter (1->rien 0->ecrire les buf internes
  • // avant de quitter), taille des donnees avant compression, taille apres compression
  • return -1;
  • }
  • for(i=0;i<len;i++) // boucle d ecriture dans le flux
  • {
  • bzerr=BZ_OK;
  • BZ2_bzWrite(&bzerr,bh,&(data[i]),1); // dans l'ordre : code d'erreur, flux BZ2, pointeur sur les donnees, taille des donnees
  • if(bzerr=BZ_IO_ERROR)
  • {
  • BZ2_bzWriteClose(&bzerr,bh,1,&in,&out);
  • fclose(fd);
  • return -1;
  • }
  • }
  • BZ2_bzWriteClose(&bzerr,bh,0,&in,&out); // on a fini donc on ferme!!
  • fclose(fd);
  • if(out >= in) printf("\nAttention : Compression inutile (taille en sortie >= taille en entree)\n");
  • return 0;
  • }
  • /* fin : fichier a compresser
  • fout: fichier de sortie
  • retourne 0->succes
  • -1->erreur
  • */
  • int compress_file_to_file(char *fin, char *fout)
  • {
  • FILE *fdin, *fdout;
  • BZFILE *bh;
  • int bzerr;
  • int in, out;
  • char c;
  • if(!((fdin = fopen(fin,"r")) && (fdout = fopen(fout,"w"))))
  • {
  • printf("\nErreur IO!");
  • return -1; // probleme IO
  • }
  • bh = BZ2_bzWriteOpen(&bzerr, fdout, 9, 0, 30); // dans l'ordre : code d'erreur, fichier de sortie, parametre memoire,
  • // verbosite (0-4), facteur pour le compression (1-250)
  • if(bzerr != BZ_OK) // onquitte sur une erreur
  • {
  • fclose(fdin);
  • fclose(fdout);
  • BZ2_bzWriteClose(&bzerr,bh,1,&in,&out); // dans l'ordre : code d'erreur, flux BZ2, action a effectuer avant de quitter (1->rien 0->ecrire les buf internes
  • // avant de quitter), taille des donnees avant compression, taille apres compression
  • printf("\nErreur d'ouverture du flux!");
  • return -1;
  • }
  • while(fread(&c,1,1,fdin) == 1) // boucle d ecriture dans le flux
  • {
  • bzerr=BZ_OK;
  • BZ2_bzWrite(&bzerr,bh,&c,1); // dans l'ordre : code d'erreur, flux BZ2, pointeur sur les donnees, taille des donnees
  • if(bzerr==BZ_IO_ERROR)
  • {
  • BZ2_bzWriteClose(&bzerr,bh,1,&in,&out);
  • fclose(fdin);
  • fclose(fdout);
  • printf("\nErreur de compression");
  • return -1;
  • }
  • }
  • BZ2_bzWriteClose(&bzerr,bh,0,&in,&out); // on a fini donc on ferme!!
  • fclose(fdin);
  • fclose(fdout);
  • if(out >= in) printf("\nAttention : Compression inutile (taille en sortie >= taille en entree)\n");
  • return 0;
  • }
  • /* filename : fichier a decompresser
  • block_size : taille des blocs a utiliser (pour aider la fonction). Par defaut 100 octets, donc 0->100
  • size : pointeur sur un int (et pas un tableau), renvoit la taille des donnees lues
  • cette fonction retourne un pointeur sur les donnees lues, NULL en cas d echec
  • */
  • void * uncompress_from_file(char *filename, int block_size, int *size)
  • {
  • FILE *fd;
  • BZFILE *bh;
  • int bzerr;
  • int size_read;
  • int i=0;
  • char *data = NULL;
  • /* allocation initiale de la memoire */
  • if(block_size == 0) block_size = DEFAULT_BLOCK_SIZE;
  • if((data = (char *) malloc(block_size)) == NULL)
  • {
  • printf("\nAllocation memoire impossible!\n");
  • return NULL;
  • }
  • if(!(fd = fopen(filename,"r")))
  • {
  • printf("\nImpossible de lire le fichier d'nentree!\n");
  • return NULL;
  • }
  • bh = BZ2_bzReadOpen(&bzerr, fd, 0, 0, NULL, 0); // dans l'ordre : code d'erreur, FILE *, verbosite (0-4)
  • // type d algorithme a utiliser (0->+ de memeoire,- de CPU 1->- de memoire, + de CPU)
  • // les autres e servent a rien quand on commence a lire du debut...
  • if(bzerr != BZ_OK)
  • {
  • BZ2_bzReadClose(&bzerr,bh);
  • fclose(fd);
  • printf("\nOuverture du flux impossible!!");
  • return NULL;
  • }
  • bzerr = BZ_OK;
  • *size = 0;
  • while(bzerr == BZ_OK)
  • {
  • size_read = BZ2_bzRead(&bzerr, bh, data + (i * block_size),block_size);
  • if(bzerr == BZ_OK)
  • {
  • i++;
  • *size += size_read;
  • if((data = (char *) realloc(data,block_size * (i+1))) == NULL)
  • {
  • BZ2_bzReadClose(&bzerr,bh);
  • fclose(fd);
  • printf("\nRealloc impossible!!");
  • return NULL;
  • }
  • }
  • *size += size_read;
  • if(bzerr != BZ_STREAM_END) printf("\nProbleme de lecture!\n");
  • }
  • /*On a fini donc on ferme tout et on redimensionne la zone memoire */
  • BZ2_bzReadClose(&bzerr,bh);
  • fclose(fd);
  • data = (char *) realloc(data,*size);
  • return (void *) data;
  • }
  • /* fin : fichier a decompresser
  • fout: fichier reslutat
  • block_size : taille des blocs a utiliser
  • retourne 0->succes
  • -1->echec
  • */
  • int uncompress_from_file_to_file(char *fin, char *fout, int block_size)
  • {
  • FILE *fdin;
  • FILE *fdout;
  • BZFILE *bh;
  • int bzerr;
  • int size_read;
  • char *data = NULL;
  • /* allocation initiale de la memoire */
  • if(block_size == 0) block_size = DEFAULT_BLOCK_SIZE;
  • if((data = (char *) malloc(block_size)) == NULL)
  • {
  • printf("\nAllocation memoire impossible!\n");
  • return -1;
  • }
  • if(!((fdin = fopen(fin,"r")) && (fdout = fopen(fout,"w"))))
  • {
  • printf("\nImpossible de lire le fichier d'nentree!\n");
  • return -1;
  • }
  • bh = BZ2_bzReadOpen(&bzerr, fdin, 0, 0, NULL, 0); // dans l'ordre : code d'erreur, FILE *, verbosite (0-4)
  • // type d algorithme a utiliser (0->+ de memeoire,- de CPU 1->- de memoire, + de CPU)
  • // les autres e servent a rien quand on commence a lire du debut...
  • if(bzerr != BZ_OK)
  • {
  • BZ2_bzReadClose(&bzerr,bh);
  • fclose(fdin);
  • fclose(fdout);
  • printf("\nOuverture du flux impossible!!");
  • return -1;
  • }
  • bzerr = BZ_OK;
  • while(bzerr == BZ_OK)
  • {
  • size_read = BZ2_bzRead(&bzerr, bh, data,block_size);
  • if((bzerr == BZ_OK) || (bzerr == BZ_STREAM_END))
  • {
  • fwrite(data,size_read,1,fdout);
  • }
  • else printf("\nProbleme de lecture!\n");
  • }
  • /* On a fini donc on ferme tout */
  • BZ2_bzReadClose(&bzerr,bh);
  • fclose(fdin);
  • fclose(fdout);
  • free(data);
  • return 0;
  • }
  • /*exemple tres simple d'utilisation */
  • int main(int argc, char **argv)
  • {
  • int size;
  • char * data;
  • compress_file_to_file(argv[1],argv[2]);
  • data = (char *) uncompress_from_file_to_file(argv[2],"resultat.c",0);
  • printf("%d",size);
  • data[size -1] = '\0';
  • printf("%s",data);
  • return 0;
  • }
/* bzcompress.c : compression/decompression bz2 (mieux que zlib)
 * compile sous Linux, necessite la libbz2. Ce programme n'utilise pas de fonctions
 * specifiques Linux, il devrait donc marcher sous windows.
 * gcc -lbz2 bzcompress.c -o bzcompress
 *
 * (C) Metaldwarf 2004
 */


#include <stdio.h>
#include <bzlib.h>

#define DEFAULT_BLOCK_SIZE 100                // taille des blocs par defaut en octets


/* file : fichier de destination
   data : donnees a compresser
   len  : taille des donnes
   retourne 0->succes
           -1->echec
*/
int compress_to_file(char *file, char *data, int len)
{
  FILE *fd;
  BZFILE *bh;
  int bzerr;
  int in, out;
  int i;

  if(!(fd = fopen(file,"w"))) return -1;       // probleme IO

  bh = BZ2_bzWriteOpen(&bzerr, fd, 9, 0, 30);  // dans l'ordre : code d'erreur, fichier de sortie, parametre memoire, 
                                               // verbosite (0-4), facteur pour le compression (1-250)
  if(bzerr != BZ_OK)                           // onquitte sur une erreur
    {
      fclose(fd);
      BZ2_bzWriteClose(&bzerr,bh,1,&in,&out);  // dans l'ordre : code d'erreur, flux BZ2, action a effectuer avant de quitter (1->rien 0->ecrire les buf internes
                                               // avant de quitter), taille des donnees avant compression, taille apres compression
      return -1;
    }

  for(i=0;i<len;i++)                           // boucle d ecriture dans le flux
    {
      bzerr=BZ_OK;
      BZ2_bzWrite(&bzerr,bh,&(data[i]),1);     // dans l'ordre : code d'erreur, flux BZ2, pointeur sur les donnees, taille des donnees
      if(bzerr=BZ_IO_ERROR)
	{
	  BZ2_bzWriteClose(&bzerr,bh,1,&in,&out);
	  fclose(fd);
	  return -1;
	}
    }

  BZ2_bzWriteClose(&bzerr,bh,0,&in,&out);      // on a fini donc on ferme!!
  fclose(fd);

  if(out >= in) printf("\nAttention : Compression inutile (taille en sortie >= taille en entree)\n");

  return 0;
}

/* fin : fichier a compresser
   fout: fichier de sortie
   retourne 0->succes
           -1->erreur
*/
int compress_file_to_file(char *fin, char *fout)
{
  FILE *fdin, *fdout;
  BZFILE *bh;
  int bzerr;  
  int in, out;
  char c;

  if(!((fdin = fopen(fin,"r")) && (fdout = fopen(fout,"w"))))
    {
      printf("\nErreur IO!");
      return -1;       // probleme IO
    }
  
bh = BZ2_bzWriteOpen(&bzerr, fdout, 9, 0, 30);  // dans l'ordre : code d'erreur, fichier de sortie, parametre memoire,
// verbosite (0-4), facteur pour le compression (1-250)
if(bzerr != BZ_OK)                           // onquitte sur une erreur
{
  fclose(fdin);
  fclose(fdout);
  BZ2_bzWriteClose(&bzerr,bh,1,&in,&out);  // dans l'ordre : code d'erreur, flux BZ2, action a effectuer avant de quitter (1->rien 0->ecrire les buf internes
  // avant de quitter), taille des donnees avant compression, taille apres compression
  printf("\nErreur d'ouverture du flux!");
  return -1;
}

  while(fread(&c,1,1,fdin) == 1)                // boucle d ecriture dans le flux
      {
	bzerr=BZ_OK;
	BZ2_bzWrite(&bzerr,bh,&c,1);     // dans l'ordre : code d'erreur, flux BZ2, pointeur sur les donnees, taille des donnees
	if(bzerr==BZ_IO_ERROR)
	{
	  BZ2_bzWriteClose(&bzerr,bh,1,&in,&out);
	  fclose(fdin);
	  fclose(fdout);
	  printf("\nErreur de compression");
	  return -1;
	}
    }

	BZ2_bzWriteClose(&bzerr,bh,0,&in,&out);      // on a fini donc on ferme!!
	fclose(fdin);
	fclose(fdout);
	if(out >= in) printf("\nAttention : Compression inutile (taille en sortie >= taille en entree)\n");
	
	return 0;
	}

/* filename   : fichier a decompresser
   block_size : taille des blocs a utiliser (pour aider la fonction). Par defaut 100 octets, donc 0->100
   size       : pointeur sur un int (et pas un tableau), renvoit la taille des donnees lues
   cette fonction retourne un pointeur sur les donnees lues, NULL en cas d echec
*/
void * uncompress_from_file(char *filename, int block_size, int *size)
{
  FILE *fd;
  BZFILE *bh;
  int bzerr;
  int size_read;
  int i=0;
  char *data = NULL;

  
  /* allocation initiale de la memoire */
  if(block_size == 0) block_size = DEFAULT_BLOCK_SIZE;
  if((data = (char *) malloc(block_size)) == NULL)
    {
      printf("\nAllocation memoire impossible!\n");
      return NULL;
    }

  if(!(fd = fopen(filename,"r")))
    {
      printf("\nImpossible de lire le fichier d'nentree!\n");
      return NULL;
    }  
  bh = BZ2_bzReadOpen(&bzerr, fd, 0, 0, NULL, 0); // dans l'ordre : code d'erreur, FILE *, verbosite (0-4)
                                                  // type d algorithme a utiliser (0->+ de memeoire,- de CPU 1->- de memoire, + de CPU)
                                                  // les autres e servent a rien quand on commence a lire du debut...
  if(bzerr != BZ_OK)
    {
      BZ2_bzReadClose(&bzerr,bh);
      fclose(fd);
      printf("\nOuverture du flux impossible!!");
      return NULL;
    }

  bzerr = BZ_OK;
  *size = 0;
  while(bzerr == BZ_OK)
    {
      size_read = BZ2_bzRead(&bzerr, bh, data + (i * block_size),block_size);
      if(bzerr == BZ_OK)
	{
	  i++;
	  *size += size_read;
	  if((data = (char *) realloc(data,block_size * (i+1))) == NULL)
	    {
	      BZ2_bzReadClose(&bzerr,bh);
	      fclose(fd);
	      printf("\nRealloc impossible!!");
	      return NULL;
	    }
	}
      *size += size_read;
      if(bzerr != BZ_STREAM_END) printf("\nProbleme de lecture!\n");
    }
  /*On a fini donc on ferme tout et on redimensionne la zone memoire */
  BZ2_bzReadClose(&bzerr,bh);
  fclose(fd);

  data = (char *) realloc(data,*size);

  return (void *) data;
}

/* fin : fichier a decompresser
   fout: fichier reslutat
   block_size : taille des blocs a utiliser
   retourne 0->succes
           -1->echec
*/
int uncompress_from_file_to_file(char *fin, char *fout, int block_size)
{
  FILE *fdin;
  FILE *fdout;
  BZFILE *bh;
  int bzerr;
  int size_read;
  char *data = NULL;


  /* allocation initiale de la memoire */
  if(block_size == 0) block_size = DEFAULT_BLOCK_SIZE;
  if((data = (char *) malloc(block_size)) == NULL)
    {
      printf("\nAllocation memoire impossible!\n");
      return -1;
    }

  if(!((fdin = fopen(fin,"r")) && (fdout = fopen(fout,"w"))))
  {
    printf("\nImpossible de lire le fichier d'nentree!\n");
    return -1;
  }
     bh = BZ2_bzReadOpen(&bzerr, fdin, 0, 0, NULL, 0); // dans l'ordre : code d'erreur, FILE *, verbosite (0-4)
                                                  // type d algorithme a utiliser (0->+ de memeoire,- de CPU 1->- de memoire, + de CPU)
                                                  // les autres e servent a rien quand on commence a lire du debut...
  if(bzerr != BZ_OK)
    {
      BZ2_bzReadClose(&bzerr,bh);
      fclose(fdin);
      fclose(fdout);
      printf("\nOuverture du flux impossible!!");
      return -1;
    }

  bzerr = BZ_OK;
  while(bzerr == BZ_OK)
    {
      size_read = BZ2_bzRead(&bzerr, bh, data,block_size);
      if((bzerr == BZ_OK) || (bzerr == BZ_STREAM_END))
	{
	  fwrite(data,size_read,1,fdout);
	}
      else  printf("\nProbleme de lecture!\n");
    }
  /* On a fini donc on ferme tout */
  BZ2_bzReadClose(&bzerr,bh);
  fclose(fdin);
  fclose(fdout);
  free(data);

  return 0;
}

/*exemple tres simple d'utilisation */
int main(int argc, char **argv)
{
  int size;
  char * data;
  compress_file_to_file(argv[1],argv[2]);
  data = (char *) uncompress_from_file_to_file(argv[2],"resultat.c",0);
  printf("%d",size);
  data[size -1] = '\0';
  printf("%s",data);
  return 0;
}


 Fichier Zip

Les Membres Club peuvent télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

Télécharger le zip


 Sources du même auteur

Source avec Zip LECTURE/ECRITURE DES MSR (MODEL SPECIFIC REGISTER) EN C SOUS...
Source avec Zip Source avec une capture SOLUTION GRAPHIQUE APPROCHÉE AU PROBLÈME DES N CORPS
Source avec Zip Source avec une capture SERVEUR DE CHAT MULTITHREADE EN C SOUS LINUX
Source avec Zip TESTE SI UN TRES GRAND NOMBRE (PLUSIEURS MILLIERS DE CHIFFRE...
COMMENT UN PC FAIT DES MULTIPLICATIONS...

 Sources de la même categorie

Source avec Zip WIN32 TLS LENT par dguilmain
Source avec Zip VIDER ELEMENTS DE CORBEILLE WINDOWS7 (WIN64) par BruNews
Source avec Zip Source avec une capture FIND TEXT (WIN64) par BruNews
Source avec Zip DELETE DIRECTORY (WIN64) par BruNews
Source avec Zip ENUM DIRECTORY (WIN64) par BruNews

Commentaires et avis

Commentaire de victorcoasne le 24/08/2004 21:07:37

Nickel et pour Windows sous Dev-C++ ça fonctionne en modifiant 2~3 p'tit choses !!

Un exemple de compression sur une image bitmap de 2.25 Mo j'obtient 327ko pas mal non ?


10/10 !!

Commentaire de victorcoasne le 24/08/2004 22:18:52

Plus inprésionant un fichier de vide créé par Windows de taille 100Mo en 23 secondes devient du 113octets et en 6 Sec le 113octes redevient du 100Mo !!!!

Allucinant non ?

Si vous me croyez pas je vous envoi la preuve (en .bz evidement!!)

Et d'après mes test sur tout les compressions celle là est un bon compromis entre vitesse et compression (je ne dirait pas que la compression est sans aucune perte).

Même les format .rar et .zip compresse moins bien (testé seulement avec une bitmap)

Voilà c'était mon petit rapport

Commentaire de MetalDwarf le 25/08/2004 15:01:58

Et oui c est bien les logiciels libres!
Ce format est en effet tres performant, et il tend a remplacer le format .gz sous Unix (.gz --> Zlib).

Commentaire de victorcoasne le 25/08/2004 17:26:21

Il me semble que ce format est .bz.

Commentaire de MetalDwarf le 25/08/2004 17:28:53

oui...et meme .bz2 pour etre precis!!
en general il est associe a tar, qui permetr de faire une archive (la bzlib ne fait que compresser), ce qui donne des archives .tar.bz2 qui tendent a remplacer les archives .tar.gz ;-)

Commentaire de progrima le 10/10/2005 23:05:10

j'ai essayé de compiler ca avec visual C++ 6.0, mais j'ai eu l'erreur : Cannot open include file: 'bzlib.h': No such file or directory.

que dois je faire??

Commentaire de progrima le 11/10/2005 02:33:01

j'ai pris tes deux fonctions de compressions file to file et décompression file to file, et je les ai intégré dans mon prog.
Le prob c'est que la fonction de compression me donne tjrs une taille supperieur pour le fichier compressé.
stp, est ce que tu peux m'aider?

Commentaire de rascas le 04/05/2006 17:29:41

j ai essayé d utiliser le code avec kdevelop mais ca donne des erreur de type
/home/tannicha/appessai/src/appessai.cpp:334: undefined reference to `BZ2_bzWriteOpen'
/home/tannicha/appessai/src/appessai.cpp:340: undefined reference to `BZ2_bzWriteClose'
que dois je faire??merci

Commentaire de victorcoasne le 04/05/2006 17:33:53

Il faut télécharger et installer la librairie bz2 !

Commentaire de rascas le 09/05/2006 10:49:46

je croi qu elle est deja instaler car quand je compile le source seul avec un editeur de texte ca marche bien, mais toujour sur kwrite ca marche pas!!

Commentaire de rascas le 09/05/2006 10:51:34

non je veux dire sur kdevelop desolé pas kwrite (la honte)

Commentaire de rwick le 27/10/2006 17:35:28

Pour ceux qui comme moi on des problèmes de vue sur ce source,
je veux signaler qu'il y a petit problème dans la fonction compress_to_file.
Il ne faut pas lire :
  if(bzerr=BZ_IO_ERROR)
  {
    BZ2_bzWriteClose(&bzerr,bh,1,&in,&out);
    fclose(fd);
    return -1;
  }
mais
  if(bzerr==BZ_IO_ERROR)
  {
     BZ2_bzWriteClose(&bzerr,bh,1,&in,&out);
     fclose(fd);
     return -1;
   }

Commentaire de victorcoasne le 17/04/2007 00:40:25

Comment on récupère la taille du fichier non compressé dans une archive compressée ?

Commentaire de rosemarie302 le 02/05/2007 22:28:21

bonjour,

Alors voici les corrections a apporter pour que le code soit correcte :
il faut remplacer tous les "int in, out;" par "unsigned int in, out;" .
et changer les options d'ouverture de fichier "r" et "w" en mode binaire par "rb" et "wb"  dans toutes les fonctions.
Dans la fonction compress_to_file, remplacer  "if(bzerr=BZ_IO_ERROR)" par "  if(bzerr==BZ_IO_ERROR)" .

et voilla le code est parfait, je rapel que pour l'utiliser sous DEV-C++ il suffi d'installer le DEV-PACK "bzip2" et de linker l'option -lbz2 dans le projet et de trouver sur son ordi la DLL "bzip2.dll" pour accompagner le programme, voillou !!

Pour une utilisation en annex il faut cree le fichier "bzcompress.h" a inclure dans votre programme main.

/* bzcompress.h par 302 ~ joie ludovic ~ 2007 */
int compress_file_to_file(char *fin, char *fout);
int compress_to_file(char *file, char *data, int len);
void * uncompress_from_file(char *filename, int block_size, int *size);
int uncompress_from_file_to_file(char *fin, char *fout, int block_size);
/*  */

et pour les rapides voici une fonction test :

#include "bzcompress.h"
et
char source[512];
char compresser[512];
char decompresser[512];

sprintf(source,"image.bmp");
sprintf(compresser,"image compresser.bmp.bz");  
sprintf(decompresser,"image decompresser.bmp");    

compress_file_to_file(source,compresser);  
uncompress_from_file_to_file(compresser,decompresser,0);
/**/

Oki j'espere faciliter la tache a pas mal de monde.
Bonne compression a tous.


/* 302 ~ joie ludovic ~ 2007 */
/* slyders302@hotmail.com */

Commentaire de SuperMonkey le 10/03/2008 17:05:50 9/10

Pas mal du tout !
Cependant j'ai une question :

Est il possible de compresser plusieurs fichiers en un
en améliorant ton code ?

Commentaire de victorcoasne le 10/03/2008 19:14:50

Il faut que tu créé un format d'assemblage de fichier et qu'au lieu de l'écrire avec la fonction write que tu utilise celle du BZ2.
Ca revient à créer un assembleur de fichier avec juste la fonction de lecture et d'écriture qui diffère.

 Ajouter un commentaire




Nos sponsors


Sondage...

Comparez les prix

CalendriCode

Février 2012
LMMJVSD
  12345
6789101112
13141516171819
20212223242526
272829    

Consulter la suite du CalendriCode

Photothèque

 
Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils.
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés

Google Coop CodeS-SourceS Google Coop CodeS-SourceS
Temps d'éxécution de la page : 0,905 sec (3)

Nous contacter | Annoncer sur CodeS-SourceS | Mentions légales