0x00 ist bei Textdateien anders als bei Bitmaps...komisch!!!

Guenter Mies

******************************************
* Beitrag in C++ Forum verschoben!!! *
* Sorry! *
* *
* *
* Gruss *
* Guenni *
******************************************

Hi Maedels,

momentan arbeite ich am Zippen von Bilddateien anhand der ZLIB Bibliothek.

Ich bin soweit, dass ich Textdateien jeglicher Form einlesen, zippen und auch entzippen kann.
Dabei ist es egal ob es sich um Text mit Steuerzeichen oder auch ohne handelt.

Eigentlich moechte ich aber Bitmaps zippen. Diese enthalten extrem viele Steuerzeichen.
Und genau da liegt das Problem. Leider wird das 0x00 nicht richtig erkannt, solange es sich um Bitmaps handelt.
Bei der Textdatei wird das 0x00 komischerweise richtig erkannt und auch gezippt/entzippt.
Das weiss ich wirklich genau, da ich mir die Dateien immer mit einem Hexviewer anschaue.

Bei der Bitmapdatei werden die ganzen 0x00 ausgelassen wodurch das Datenvolumen sich stark verringert, welches der Zipper
dann jedoch am Ende der Datei durch Auffuellen mit 0x00 ausgleicht um die Dateigroesse richtig herzustellen.

Eigenartig!!!!!!

Nun habe ich einfach die "schwarzweiss.bmp" in "schwarzweiss.txt" umgewandelt und sie wieder durch den Algorithmus gejagt.
Man sollte davon ausgehen, dass nun die 0x00 richtig erkannt werden. Leider Fehlanzeige.
Nein, auch hier laesst der Algorithmus die 0x00 geschmeidig weg.

Muss ich das verstehen?!?!?!

Leider kann ich "fstream"-Objekte nicht verwenden, da ich fuer PocketPc progge.
Ich verwende fopen, fread, fwrite, etc.

Hat wer 'ne blasse Ahnung woran das mit den 0x00 liegen koennte??
Zusammengefasst: Bei Textdateien erstellt mit irgendeinem Texteditor liesst er 0x00 einwandfrei und bei Bitmapdateien nicht.

Gruss
Guenni

Mit welchem Programm hast du denn die Bitmpas erstellt?
Afaik sieht das Dateiformat von Bitmaps vor, dass diese RLE-Komprimiert werden können. dass zb 20 0x00's in 0x14 0x00 oder so umgewandelt werden können. Vllt is das ja der Grund?

Guenter Mies

hmmmm, was heisst denn AFAIK??

Die Bitmaps erstelle ich selber mit einer gemopsten Routine
Habe was Bitmaps angeht auch nicht so den riesen Plan...bin froh, dass es laeuft.

Ich denke, dass es etwas mit dem Unicode zu tun hat, da Unicode aufm PocketPC nur 1Byte gross ist und nicht wie normal 2.

Ich habe zwischenzeitlich den Text einmal in einen Unicode Text umgewandelt und diesen ohne Dateiendung auf den PocketPC transferiert, sodass keine Formatumwandlung waerend des Transports stattfinden konnte.
Diese Datei hab ich dann wiederrum durch den Algorithmus gejagt und siehe da: Auch hier kommt Schrott raus...aufgefuellt mit 0x00.

Hmmmmmm.......

Gruss
Guenni

Guenter Mies

hmmmmm....
ich bin verwirrt!!

ich kriege es nicht mehr hin, dass meine textdateien ein 0x00 enthalten

vergessen wir mal die 0x00 in den textdateien!

weiss wer wo mein code fehlerhaft sein koennte, da er bei 0x00 falsch einliest?

void CTeilerDlg::OnButton4() 
{
	FILE *inDatei;
	inDatei = fopen("\\text.txt", "rb");

	int Dateigroesse = 0, wert = 0;
	fseek (inDatei,0,SEEK_END);
	Dateigroesse = ftell (inDatei);
	fseek (inDatei,0,SEEK_SET);
	char *Puffer = new char[Dateigroesse];

	///////////////////////////////ersetzt durch zeichenweises lesen//////////////////////
/*	if(inDatei != NULL)
	{
		wert = fread(Puffer, 1,Dateigroesse,inDatei);
	}
	fclose (inDatei);
*/

	char *Puffer2 = new char[2];
	*(Puffer2+1) = '\0';

	int j=1;

	do
	{
		wert = fread(Puffer2,sizeof(char),1, inDatei);

		strcat(Puffer, Puffer2);
		j++;
	}
	while(j<=Dateigroesse);
	fclose (inDatei);
	/////////////////////////////////////////////////////////////////////////////////////

	Byte *original= (unsigned char*)Puffer;
	Byte *zip = new Byte[100000]; 
	uLong zipLen= 100000, origLen= Dateigroesse;

	zipLen= test_large_deflate( zip, zipLen, original, origLen);
	delete Puffer;
	delete original;
////////////////
	FILE *ZipDatei;
	ZipDatei = fopen("gezippte.txt", "wb");
	fwrite(zip, 1, zipLen, ZipDatei);
	fclose (ZipDatei);
////////////////////

//////////////////////
	FILE *gezippteDateiLesen;
	gezippteDateiLesen = fopen("\\gezippte.txt", "rb");

	int neueDateigroesse = 0, neuwert = 0;
	fseek (gezippteDateiLesen,0,SEEK_END);
	neueDateigroesse = ftell (gezippteDateiLesen);
	fseek (gezippteDateiLesen,0,SEEK_SET);
	char *Buffer = new char[neueDateigroesse];

	///////////////////////////////ersetzt durch zeichenweises lesen//////////////////////
	if(gezippteDateiLesen != NULL)
	{
		neuwert = fread(Buffer, 1,neueDateigroesse,gezippteDateiLesen);
	}
	fclose (gezippteDateiLesen);

/*	char *Puffer3 = new char[2];
	*(Puffer3+1) = '\0';

	int m=1;

	do
	{
		neuwert = fread(Puffer3,sizeof(char),1, gezippteDateiLesen);

		strcat(Buffer, Puffer3);
		m++;
	}
	while(m<=neueDateigroesse);
	fclose (gezippteDateiLesen);
*/	//////////////////////////////////////////////////////////////////////////////////////

	Byte *irgendwas= (unsigned char*)Buffer;
	Byte *neu = new Byte[100000];
	uLong neuLen= 100000, irgendwasLen= neueDateigroesse;
///////////////////////

	neuLen= test_large_inflate(irgendwas, irgendwasLen, neu, neuLen);

	FILE *EntzipDatei;
	EntzipDatei = fopen("entzippte.txt", "wb");
	fwrite(neu, 1, neuLen, EntzipDatei);
	fclose (EntzipDatei);

	m_neu = neu;
	m_string = zip;
	UpdateData(false);
}

gruss
Guenni

Guenter Mies

abschliessend (fuer leute dies mal brauchen)

FERTIG!!!

ich kann zwar immer noch nicht richtig bitmapdateien zippen und entzippen aber ich kann MEINE BITMAPS zippen und entzippen

ich weiss dass in meinen bitmaps nie die 0x55 als grafikinfo vorkommt und somit hab ich die 0x00 einfach vor dem zippen in 0x55 umgewandelt und nach dem enzippen wieder zurueckgewandelt

wenn jemand eine bessere loesung weiss die auf alle bitmaps anzuwenden ist wuerde mich das sehr freuen...

gruss
Guenni

das solltest du auf keinen Fall als Lösung aktzeptieren.

junix

Also entweder hier oder hier zu. Ich würde eher sagen hier zu, da das ja nix mit MFC zu tun hat.

Hab übrigens nen Lösungsvorschlag im anderen Thread gepostet.

-junix

MFK

Das Problem liegt vermutlich in der Verwendung von strcat.

Specialguest

dann helf uns du SCHISSA ohne Namen!

Für unsere Zwecke erstmal völlig ausreichend, aber wir suchen natürlich händeringend nach einer Lösung für alle bmp´s

Fur Alle mal unsren Code!
(wer was gebrauchen kann, kann es sich gerne ausleihen! , aber wiederbringen )

void CTeilerDlg::OnButton4() 
{
	FILE *inDatei;
	inDatei = fopen("\\schwarzweiss.bmp", "rb");

	int Dateigroesse = 0, wert = 0;
	fseek (inDatei,0,SEEK_END);
	Dateigroesse = ftell (inDatei);
	fseek (inDatei,0,SEEK_SET);
	char *Puffer = new char[Dateigroesse];

	///////////////////////////////ersetzt durch zeichenweises lesen//////////////////////
/*	if(inDatei != NULL)
	{
		wert = fread(Puffer, 1,Dateigroesse,inDatei);
	}
	fclose (inDatei);
*/

	char *Puffer2 = new char[2];
	*(Puffer2+1) = '\0';

	int j=1;

	do
	{
		wert = fread(Puffer2,sizeof(char),1, inDatei);

				if (*Puffer2 == 00)
				{
					*Puffer2 = 55;
				}

		strcat(Puffer, Puffer2);
		j++;
	}
	while(j<=Dateigroesse);
	fclose (inDatei);

	/////////////////////////////////////////////////////////////////////////////////////

	Byte *original= (unsigned char*)Puffer;
	Byte *zip = new Byte[100000]; 
	uLong zipLen= 100000, origLen= Dateigroesse;

	zipLen= test_large_deflate( zip, zipLen, original, origLen);
	delete Puffer;
	delete original;
////////////////
	FILE *ZipDatei;
	ZipDatei = fopen("gezippte.txt", "wb");
	fwrite(zip, 1, zipLen, ZipDatei);
	fclose (ZipDatei);

	m_string = zip;
	UpdateData(false);
////////////////////

//////////////////////
	FILE *gezippteDateiLesen;
	gezippteDateiLesen = fopen("\\gezippte.txt", "rb");

	int neueDateigroesse = 0, neuwert = 0;
	fseek (gezippteDateiLesen,0,SEEK_END);
	neueDateigroesse = ftell (gezippteDateiLesen);
	fseek (gezippteDateiLesen,0,SEEK_SET);
	char *Buffer = new char[neueDateigroesse];

	///////////////////////////////ersetzt durch zeichenweises lesen//////////////////////
	if(gezippteDateiLesen != NULL)
	{
		neuwert = fread(Buffer, 1,neueDateigroesse,gezippteDateiLesen);
	}
	fclose (gezippteDateiLesen);

/*	char *Puffer3 = new char[2];
	*(Puffer3+1) = '\0';

	int m=1;

	do
	{
		neuwert = fread(Puffer3,sizeof(char),1, gezippteDateiLesen);

		strcat(Buffer, Puffer3);
		m++;
	}
	while(m<=neueDateigroesse);
	fclose (gezippteDateiLesen);
*/	//////////////////////////////////////////////////////////////////////////////////////

	Byte *irgendwas= (unsigned char*)Buffer;
	Byte *neu = new Byte[100000];
	uLong neuLen= 100000, irgendwasLen= neueDateigroesse;
///////////////////////

	neuLen= test_large_inflate(irgendwas, irgendwasLen, neu, neuLen);

	for (int z=0; z<(int)neuLen; z++)
	{
		if(neu[z] == 55)
		{
			neu[z] = 00;
		}
	}

	FILE *EntzipDatei;
	EntzipDatei = fopen("BertDaten\\schwarzweiss.bmp", "wb");
	fwrite(neu, 1, neuLen, EntzipDatei);
	fclose (EntzipDatei);

	m_neu = neu;
	//m_string = zip;
	UpdateData(false);
}

Für Verbessserungen sind wir immer offen!

sven & günni

Specialguest

gibt es den eine alternative zu strcat die mir den selben effekt mit binar streams liefert?

Leider kommen wir frisch vond er Schule und stehen des öfteren vor steilen Bergwänden wo wir nicht wissen wie wir sie bezwingen sollen!
Und sind auf jede Hilfe angewiesen!

THX a lot

sven

Bashar

Warum macht ihr das Einlesen so Hölle kompliziert?

spricht irgendwas gegen

fread(Puffer, 1, Dateigroesse, inDatei);

Specialguest

Warum macht ihr das Einlesen so Hölle kompliziert?

spricht irgendwas gegen
C/C++ Code: 
fread(Puffer, 1, Dateigroesse, inDatei);

ja dadurch ließt er wenn NULL (0x00) in der BMP findet nicht weiter ein!
das ist FATAL !
Und da wir jedes Zeichen überprüfen müssen! Kann man das doch nicht anders.

sven

Bashar

Das wär mir neu, dass fread bei 0 stoppt.

Specialguest

wir hatten auf jedenfall das Problem das wenn wir den gesamten Stream am Stück mit fread eingelesen haben das uns nicht alle zeichen eingelesen werden konnten! Uns fehlten bei der einige Zeichen, wir haben uns dies dazu im Hexeditor angeschaut und festgestellt das der Punkt wo er diese Zeichen nicht mehr einliest ein 00 ist!
Kann ja auch sein das wir irgendwo tierisch vor die Wand laufen!
Aber durch das zeichenweise einlesen und überprüfen des einlesestream gehen wir sicher das er nicht rausspringt und es funzt komischerweise!
Aber wenn du dazu ein Verbesserungsvorschlag machen kannst wäre das super!

sven

Bashar

Dann muss der Fehler da liegen, wo ihr das mit fread eingelesene wieder ausschreibt, bevor ihr es mit dem Hexeditor anguckt. Habt ihr da fwrite benutzt oder möglicherweise sowas wie fprintf??

Specialguest

Der code oben ist der den wir z.Z. dafür nutzen!
Wir schrieben unsere entzippten daten mit fwrite wieder in eine Datei!

selbst in den Methoden von zlib wird bei uns nichts mit fprintf gemacht!

sven

Bashar

Bitte erstmal in kleinen Schritten. Wenn du fread nicht vertraust, dann teste fread, und zwar ohne den zlib-Kram drumherum. Ganz simples Testprogramm, zb sowas:

#include <stdio.h>
int main() {
  FILE *file = fopen("meins.bmp", "rb");
  fseek(file, 0, SEEK_END);
  long laenge = ftell(file);
  rewind(file);

  char * buffer = new char[laenge];

  fread(buffer, 1, laenge, file);
  fclose(file);

  file = fopen("kopie.bmp", "wb");
  fwrite(buffer, 1, laenge, file);
  fclose(file);

  return 0;
}

laufenlassen und danach gucken, ob die beiden Dateien sich unterscheiden. Wenn beide gleich sind, liegt der Fehler schonmal nicht bei fread/fwrite. So als vertrauensbildende Maßnahme ...

Wenn ich ein Compiler wär, würd ich übrigens an der Stelle aussteigen:

delete Puffer;
    delete original;

Da beide Zeiger auf dieselbe Adresse zeigen ist das ein doppeltes delete. Komisch dass da nichts passiert.

bei eurem code kriegt man ja das kotzen. wie kann man noch C sachen verwenden?

Bashar

Leider kann ich "fstream"-Objekte nicht verwenden, da ich fuer PocketPc progge.
Ich verwende fopen, fread, fwrite, etc.

Specialguest

Also "STOERENFRIED" wer lesen kann ist klar im Vorteil!

Leider kann ich "fstream"-Objekte nicht verwenden, da ich fuer PocketPc progge.
Ich verwende fopen, fread, fwrite, etc.

DORT gibt es kein fstream!! Wurde unter WinCE leider nicht implementiert und da bleibt einem nicht mehr viel übrig als auf c auszuweichen!
Soviel dazu!

Wir hatten schon ein Prog erstellt welches mit fread usw.. bmp dateien zerteilt und anschließend wieder zusammen fügt! Klappte alles ohne Probleme.
Nur seit dem wir mit zlib arbeiten funzt es nicht mehr so wie wir es wollen!
Zu mal wir darauf angewiesen sind den Stream zeichenweise zu durchforsten!
Es ist komisch ich weiß, aber beim Zeichenweisen einlesen der bmp passiert genau dieser Fehler das er mir bei einem 00 nicht alle zeichen liefert die es sein sollen!

danke wegen dem delete das ist uns nicht aufgefallen!

sven

Specialguest

thx Bashar