Ich habe eine Anwendung geschrieben in der ich einen Screenshot vom BS mache! Dieses BMP will ich nun komprimieren! Ich habe gelesen das es da eine universellen und freien Code gibt unter [ http://www.gzip.org/zlib/ ] der in Form einer dll in das Projekt eingebunden werden muss!
Soweit so gut! Einbinden der dll habe ich geschafft!
Ich weiß das ich diese dll richtig eingebunden haben, weil ich beireits eine Methode davon nutzen konnte, zwar nur die Methode zum Anzeigen der VErsionsnummer aber das ist ja schon mal ein gutes Zeichen!
Nun versteh ich leider nicht wie ich die Methoden zum komprimieren und dekomprimieren richtig nutzen kann und welche Parameter diese brauchen!
Hat schon mal jemand damit gearbeitet und kann mir gute Tips dazu geben oder weiß wer wo ich gute Beispiele dazu herbekomme? Hab schon bei Codeprojekt und codeguru einige Sachen gefunden, nur leider sind diese keinen "leichte Kost" !
Danke Sven

aber wie du das gemacht hast war glaub ich svens frage!!!

also wir sitzen nebeneinander und raffen einfach nicht wie wir unser bitmap an die richtige(n) (welche???) methode uebergeben koennen um es dann gezippt auf der platte abholen zu koennen.

wir kommen einfach nicht mit dem code klar...

es gibt auch ein beispiel dazu namens EXAMPLE aber da werden einfach in einer methode einzelne buchstaben eines Strings an unterschiedliche funktionen uebergeben.

das ist voll das schlechte example!!

waere nett wenn ihr uns helfen koennt...wir stehen voll aufm schlauch!

hier noch kurz der code welcher uns in seiner urspruenglichen form eine datei ausgibt in der "hello, hello!" steht
anstatt "hello, hello!" sollen da die binaerdaten unseres bitmap rein!

test_compress(compr, comprLen, uncompr, uncomprLen);

////////////////////von uns auskommentiert und ersetzt//////////////////
///////////////////////////////////////////////////////////////////////
    /*test_gzio((argc > 1 ? argv[1] : TESTFILE),
                (argc > 2 ? argv[2] : TESTFILE),
	            uncompr, (int)uncomprLen);*/

    const char in1[] = "Bilddatei.rar";
    const char in2[] = "";
    test_gzio(in1, in2, uncompr, (int)uncomprLen);

////////////eigenartigerweise nicht benoetigt!!!!!!//////////////////////
////////////////////////////////////////////////////////////////////////
   /*test_deflate(compr, comprLen);
    test_inflate(compr, comprLen, uncompr, uncomprLen);

    test_large_deflate(compr, comprLen, uncompr, uncomprLen);
    test_large_inflate(compr, comprLen, uncompr, uncomprLen);

    test_flush(compr, &comprLen);
    test_sync(compr, comprLen, uncompr, uncomprLen);
    comprLen = uncomprLen;

    test_dict_deflate(compr, comprLen);
    test_dict_inflate(compr, comprLen, uncompr, uncomprLen);

    exit(0);*/

void CTeilerDlg::test_compress(Byte *compr, uLong comprLen, Byte *uncompr, uLong uncomprLen) 
{
    int err;
    uLong len = strlen(hello)+1;

    err = compress(compr, &comprLen, (const Bytef*)hello, len);
    CHECK_ERR(err, "compress");

    strcpy((char*)uncompr, "garbage");

    err = uncompress(uncompr, &uncomprLen, compr, comprLen);
    CHECK_ERR(err, "uncompress");

    if (strcmp((char*)uncompr, hello)) {
        fprintf(stderr, "bad uncompress\n");
	exit(1);
    } else {
        printf("uncompress(): %s\n", (char *)uncompr);
    }
}

void CTeilerDlg::test_gzio(const char *out, const char *in, Byte *uncompr, int uncomprLen)
{
    int err;
    int len = strlen(hello)+1;
    gzFile file;
    z_off_t pos;

    file = gzopen(out, "wb");
    if (file == F_NULL) {
        fprintf(stderr, "gzopen error\n");
        exit(1);
    }
    gzputc(file, 'h');
    if (gzputs(file, "ello") != 4) {
        fprintf(stderr, "gzputs err: %s\n", gzerror(file, &err));
	exit(1);
    }
    if (gzprintf(file, ", %s!", "hello") != 8) {
        fprintf(stderr, "gzprintf err: %s\n", gzerror(file, &err));
	exit(1);
    }
    gzseek(file, 1L, SEEK_CUR); /* add one zero byte */
    gzclose(file);

    file = gzopen(in, "rb");
    if (file == F_NULL) {
        fprintf(stderr, "gzopen error\n");
    }
    strcpy((char*)uncompr, "garbage");

    uncomprLen = gzread(file, uncompr, (unsigned)uncomprLen);
    if (uncomprLen != len) {
        fprintf(stderr, "gzread err: %s\n", gzerror(file, &err));
	exit(1);
    }
    if (strcmp((char*)uncompr, hello)) {
        fprintf(stderr, "bad gzread: %s\n", (char*)uncompr);
	exit(1);
    } else {
        printf("gzread(): %s\n", (char *)uncompr);
    }

    pos = gzseek(file, -8L, SEEK_CUR);
    if (pos != 6 || gztell(file) != pos) {
	fprintf(stderr, "gzseek error, pos=%ld, gztell=%ld\n",
		(long)pos, (long)gztell(file));
	exit(1);
    }

    if (gzgetc(file) != ' ') {
	fprintf(stderr, "gzgetc error\n");
	exit(1);
    }

    gzgets(file, (char*)uncompr, uncomprLen);
    uncomprLen = strlen((char*)uncompr);
    if (uncomprLen != 6) { /* "hello!" */
        fprintf(stderr, "gzgets err after gzseek: %s\n", gzerror(file, &err));
	exit(1);
    }
    if (strcmp((char*)uncompr, hello+7)) {
        fprintf(stderr, "bad gzgets after gzseek\n");
	exit(1);
    } else {
        printf("gzgets() after gzseek: %s\n", (char *)uncompr);
    }

    gzclose(file);
}

gruss
Günni

hier n beispiel:

#include <windows.h>
#include <assert.h>

typedef int (__stdcall *TAR)(HWND hwnd,char *cmd,char *buff,int buflen);

int main()
{
	HINSTANCE hLib=0;
	TAR pTarFunc=0;

#ifdef _DEBUG
	hLib=LoadLibrary("tar/tar32d.dll");
#else
         hLib=LoadLibrary("tar/tar32.dll");
#endif
	pTarFunc=(TAR)GetProcAddress(hLib,"Tar");

	//komprimierung aller .h .cpp ohne kompression
	pTarFunc(0,"-cvf foo.tar *.cpp *.h",0,0);
	//komprimierung aller .h .cpp mit kompression
//	pTarFunc(0,"-cvfz9 foo.tar *.cpp *.h",0,0);
	//entpacken in fooextract
//	pTarFunc(0,"-xvf foo.tar -o fooextrac/",0,0);
return 0;
}

das ding heisst tar32.dll
Copyright (C) 1999 Yoshioka Tsuneo URL: http://openlab.ring.gr.jp/tsuneo/tar32/

soweit ich weiss isses freeware und open source und öffnet standardmäßig irgendein statusfenster beim komprimieren, das sich aber leicht ausschalten lässt weil ja der code beiliegt

nur leider hab ich keine japanische tastatur um angemessen antworten zu koennen....

aber ich find schon das deutsche gegenstueck...danke!!

Günni

aber kann mir wer diese Zeile mal genauer erklären!

$B$O$8$aK(B TAR32.DLLBO(BWindowsBMQN(BTAR/GZ/BZ2/ZBEyN05=L(B/BE83+MQ%i%%V%i%j%W%m%0%i%`G9!#(B BE}9g%"!<%+%%P%W%m%8%'%/%HN(BAPI$B;EMM$K=`5r$7$F$$$^9!#(B BBP1~7A<0$O0J2<$NDL$j$G$9!#(B

lol
Wir werden mal schauen was wir damit anfangen können! Leider soll unsere gegenstelle Betriebssystemunabhängig dekomprimieren können.

wenn ihrs einfacher und winabhängig haben wollt benutzt lieber tar32

Das mit dem winabhängig ist dann so ne frage! Mal schauen was unsere dekomprimierer dazu sagen :p

trotzdem danke für den tip!
sven

http://www.openlab.jp/tsuneo/tar32/index-e.html

netter link!!

nur leider hab ich keine japanische tastatur um angemessen antworten zu koennen....

aber ich find schon das deutsche gegenstueck...danke!!

Günni

jep sorry war gestern schon spät

ich kann euch auch noch meinen zlib code raussuchen... mal schaun

thx a lot

sven

an den code komm ich erst heut abend wenn ich wieder zuhause bin

///// NEUES PROBLEM MIT ZLIB ////////////////
unsere einelese buffer ist 9000 zeichen groß, damit liest er 3332 Zeichen ein bei 3333 zeichen bricht er ab! Und die Ausgabedatei ist dann leer!
Vergrößern wir unseren Buffer auf 10000 dann ist kann er die 3333 Zeichen lesen! Nun haben wir uns gedacht den Buffer in Schritten auf 50000 zu erhöhen.
Und 6000 Zeichen einzuladen aber es funzt nicht!!!
Und es wäre müsig die maximale Lesbaren Zeichen dafür heraus zu finden.
Wir sind der Meinung dass es daran liegt dass die fread methode nur bis zu einem eof liest. Wir haben uns die Datei in einem Hexeditor angeschaut und erkannt, dass es immer bei HEX 00 endet egal ob noch zeichen folgen sollten! Dies ist laut ASCII tabelle == NULL
ist in diesem Fall ein \0 gemeint oder ...

int wert =0;
File inFile;
inFile = fopen("Dateiname","rb");
char *puffer = new char [Dateigroesse +1];
if (inFile != NULL )
{
  wert = fread(puffer,1,Dateigroesse,inFile);
}

.. das NULL der If Abfrage?
p.s. wir arbeiten auf pocketpc daher fread / fopen usw. (geht nicht anders )

Sven

char *Puffer = new char[Dateigroesse];
Puffer = "";
char *Puffer2 = new char[2];
*(Puffer2+1) = '\0';
do{
	wert = fread(Puffer2,sizeof(char),1, inZip);
         strcat(Puffer, Puffer2);
         j++;
	} while(j<Dateigroesse);
fclose (inZip);

Wäre cool wenn du heut abend einfach mal deinen code postest dann können wir vielleicht sehen wo s bei uns scheitert!

thx a lot

char *Puffer = new char[Dateigroesse];
Puffer = "";
char *Puffer2 = new char[2];
*(Puffer2+1) = '\0';
do{
	wert = fread(Puffer2,sizeof(char),1, inZip);
         strcat(Puffer, Puffer2);
         j++;
	} while(j<Dateigroesse);
fclose (inZip);

Wäre cool wenn du heut abend einfach mal deinen code postest dann können wir vielleicht sehen wo s bei uns scheitert!

thx a lot

int eCompress_CompressFile(CString FileName,CString Extension)
{
	LastError="";
	CFile TheFile;
	if(!TheFile.Open(FileName,CFile::modeRead|CFile::typeBinary))
		return PutError("Datei konnte nicht geöffnet werden!"); 
	char Buf[1000000];
	int read=0;
	gzFile zFile=gzopen(FileName+Extension,"wb9");

	if(!zFile)
		return PutError("Ausgabedatei konnte nicht erstellt werden!");

	do
	{
		read=TheFile.Read(Buf,1000000);
		if(!gzwrite(zFile,Buf,read))
			PutError("Fehler beim Schreiben der komprimierten Daten!");

	}while(read);

	TheFile.Close();
	gzclose(zFile);

return eCompressionFINE;
}
int eCompress_DecompressFile(CString FileName,CString Extension)
{
	LastError="";
	gzFile zFile=gzopen(FileName+Extension,"rb9");
	if(!zFile)
		return PutError("Eingabedatei konnte nicht geöffnet werden!");
	char Buf[1000000];
	int write=0;

	CFile TheFile;
	if(!TheFile.Open(FileName,CFile::modeWrite|CFile::typeBinary|CFile::modeCreate))
		return PutError("Ausgabedatei konnte nicht erstellt werden!"); 

	do
	{
		write=gzread(zFile,Buf,1000000);
		TheFile.Write(Buf,write);
	}while(write);

	gzclose(zFile);
	TheFile.Close();

return eCompressionFINE;
}

sven