Bytes og char*

Din bfType er af typen WORD, som ikke kan skrives ud med %s. %s forventer en pointer til en null termineret streng.

Derudover kan du ikke stole på, at elementerne i din struct er pakket, som du har defineret. Hvis compileren mener, at et andet layout er mere optimalt, så optimerer den.

Der er bedre at læse filen således:

fread(&aBMPfileHeader.bfType, sizeof(WORD), 1, pBMPfile);
fread(&aBMPfileHeader.bfSize., sizeof(DWORD), 1, pBMPfile);

...osv. og også hele tiden tjekke, om du har læst det forventede antal bytes.

Det er et velkendt problem, det kaldes alignment:
http://en.wikipedia.org/wiki/Packed

I korte træk er problemet at compileren gerne vil have word og dword til at ligge på pæne adresser. Normalt forsøger den finde en adresse/offset der overholder kravet:
offset%sizeof(member) == 0
Du har en DWORD bfSize som du gerne ville have til at ligge 2 bytes inde, men som kommer til at ligge 4 bytes inde i strukturen.

Du kan prøve at tilføje disse:
printf("The size of the structure is %d\n", sizeof(BMPfileHeader));
printf("The offset of bfSize is %d\n", offsetof(BMPfileHeader, bfSize));

Den sidste kræver at du inkluderer stddef.h

Hvis alt var som du gerne ville, skulle den skrive 14 og 2, men den skriver (sandsynligvis) 16 og 4.

I artiklen jeg linker til er der nogle anvisninger på hvordan du undgår problemet.

Mange tak for jeres hjælp.

Bertel dine tal på strukturen er korrekt. Den var faktisk 16 bytes stor selvom jeg kun har fyldt den med 14 byte af datatyper.

Hvordan udskriver jeg så bfType, hvis ikke med cast til char*?

Den udskriver som sagt stadig de to korrekte tegn efterfulgt af skrot. Er dette fordi når jeg tar adressen på bfType og caster den til char* så læser den bare videre med resten af dataene?

Ja, den læser videre, indtil den møder et 0/´\0' eller programmet "dør"

Du kan udskrive bfType med:
printf("Type: %c%c\n", ((char *)(&aBMPfileHeader.bfType))[0], ((char *)(&aBMPfileHeader.bfType))[1]);

Ja %c virker, tak.

Har nu arbejdet lidt videre og er i gang med lidt test af læsning af pixelsene:

{
				BYTE r, g, b;
				int row = 1;
				int column = 1;
				bool reading = true;

				while(!feof(pBMPfile))
				{
					//Run trough row
					for(int i=0; i < bmp_file.infoHeader.biWidth; i++)
					{
						printf("RGB %d,%d:\t", column, row);
						//Read bgr
						fread(&b, sizeof(BYTE), 1, pBMPfile);
						fread(&g, sizeof(BYTE), 1, pBMPfile);
						fread(&r, sizeof(BYTE), 1, pBMPfile);
						//Print rgb
						printf("%d\t%d\t%d\n", r,g,b);
						//Next pixel horisontally.
						++column;
					}
					//Move beyond padding
					fseek(pBMPfile, sizeof(BYTE)*bmp_file.padding, SEEK_CUR);
					//Start next 'line'.
					column = 1;
					++row;

					//Use key interrupt to see data
					getchar();
				}
			}

Problemet er at den aldrig bliver færdig med at læse?

Hvis jeg erstatter fseek med fread stopper den, men først efter den har taget en ekstra runde; hvordan den får læst ekstra fra filen ved jeg ikke?

Det skal siges at padding = 2 i dette tilfælde, men selv om den var 0 ville den 'file pointeren' vel alligevel komme videre pga. fread.

Du skal undlade at bruge feof. Problemet er at den først returnerer true når du har forsøgt at læse ud over enden på filen, ikke når du er ved enden på filen.
Der er heller ikke nogen grund til at bruge den, du ved hvor mange bytes du skal læse.

Ændrede programmet til ikke at bruge feof, og nu virker det perfekt.

Du skal undlade at bruge feof. Problemet er at den først returnerer true når du har forsøgt at læse ud over enden på filen, ikke når du er ved enden på filen.
Der er heller ikke nogen grund til at bruge den, du ved hvor mange bytes du skal læse.

Ville også være mit gæt. Men det forklarer vel ikke at den aldrig bliver færdig??

Jeg ved ikke præcist hvorfor den ikke bliver færdig, måske fordi din fseek flyter fil-pointeren tilbage, så du kan læse i for-loopen for evigt?

Jeg er kommet ud for et mystisk problem med mit program. Så hvis nogen har lidt ting til at kigge på det ville jeg være taknemmelig.

Problemet er at jeg læser en fil ind, jeg synes ikke jeg kan finde nogle problemer med det. Jeg læser tre forskellige dele ind:

Filheaderen:

bool BMP_readFileHeader(FILE* file, BMPfileHeader& header)
	{
		//Read
		printf("\nReading BMP file header from file:\n\n");

		//Side effects: advances file pointer. Modifies header.
		printf("Reading bfType. Read %d bytes.\n", fread(&header.bfType, sizeof(WORD), 1, file)*sizeof(WORD));
		printf("Reading bfSize. Read %d bytes.\n", fread(&header.bfSize, sizeof(DWORD), 1, file)*sizeof(DWORD));
		printf("Reading bfReserved1. Read %d bytes.\n", fread(&header.bfReserved1, sizeof(WORD), 1, file)*sizeof(WORD));
		printf("Reading bfReserved2. Read %d bytes.\n", fread(&header.bfReserved2, sizeof(WORD), 1, file)*sizeof(WORD));
		printf("Reading bfOffBits. Read %d bytes.\n", fread(&header.bfOffBits, sizeof(DWORD), 1, file)*sizeof(DWORD));

		//If not magic number
		if (header.bfType != 19778)
		{
			return false;
		}
		return true;
	}

Informationsheaderen:

bool BMP_readInfoHeader(FILE* file, BMPinfoHeader& header)
	{
		//Read
		printf("\nReading BMP info header from file:\n\n");

		//Side effects: advances file pointer. Modifies header.
		printf("Reading biSize. Read %d bytes.\n", fread(&header.biSize, sizeof(DWORD), 1, file)*sizeof(DWORD));
		printf("Reading biWidth. Read %d bytes.\n", fread(&header.biWidth, sizeof(DWORD), 1, file)*sizeof(DWORD));
		printf("Reading biHeight. Read %d bytes.\n", fread(&header.biHeight, sizeof(DWORD), 1, file)*sizeof(DWORD));
		printf("Reading biPlanes. Read %d bytes.\n", fread(&header.biPlanes, sizeof(DWORD), 1, file)*sizeof(DWORD));
		printf("Reading biBitCount. Read %d bytes.\n", fread(&header.biBitCount, sizeof(DWORD), 1, file)*sizeof(DWORD));
		printf("Reading biCompression. Read %d bytes.\n", fread(&header.biCompression, sizeof(DWORD), 1, file)*sizeof(DWORD));
		printf("Reading biSizeImage. Read %d bytes.\n", fread(&header.biSizeImage, sizeof(DWORD), 1, file)*sizeof(DWORD));
		printf("Reading biXPelsPerMeter. Read %d bytes.\n", fread(&header.biXPelsPerMeter, sizeof(DWORD), 1, file)*sizeof(DWORD));
		printf("Reading biYPelsPerMeter. Read %d bytes.\n", fread(&header.biYPelsPerMeter, sizeof(DWORD), 1, file)*sizeof(DWORD));
		printf("Reading biClrUsed. Read %d bytes.\n", fread(&header.biClrUsed, sizeof(DWORD), 1, file)*sizeof(DWORD));
		printf("Reading biClrImportant. Read %d bytes.\n", fread(&header.biClrImportant, sizeof(DWORD), 1, file)*sizeof(DWORD));

		return true;
	}

og pixel dataene:

void BMP_readPixels(FILE* file, BMPfile& bmp_file)
	{
		int pixels = bmp_file.infoHeader.biHeight*bmp_file.infoHeader.biWidth;
		bmp_file.pixels = pixels;
		bmp_file.bytesOfPixel = pixels * sizeof(BYTE) * 3;
		bmp_file.pixelData.pixels = new Pixel24Bit[pixels];

		//Read colors
		{
			BYTE r, g, b;
			int index = 0;

			//Run trough row
			for (int row=bmp_file.infoHeader.biHeight; row > 0; row--)
			{
				for(int column=1; column <= (int)bmp_file.infoHeader.biWidth; column++)
				{
					printf("RGB %d,%d:\t", column, row);
					//Read bgr
					fread(&b, sizeof(BYTE), 1, file);
					fread(&g, sizeof(BYTE), 1, file);
					fread(&r, sizeof(BYTE), 1, file);
					//Print rgb
					printf("%d\t%d\t%d\n", r,g,b);

					//Save in array
					bmp_file.pixelData.pixels[index].r = r;
					bmp_file.pixelData.pixels[index].g = g;
					bmp_file.pixelData.pixels[index].b = b;
					++index;
				}
				//Move beyond padding
				fseek(file, sizeof(BYTE)*bmp_file.padding, SEEK_CUR);
			}
		}
	}

Sådan som jeg kan se det bliver alle disse indlæst korrekt. Problemet opstår når jeg bruger lignende skrive operationer. Filheaderen og pixeldataene virker korrekt ved små eksempler. F.eks. have jeg et 2x2 billede hvor farverne blev lidt anderledes når jeg skrev billedet ud igen (kopierede). Jeg prøvede at skrive dele, filheader, infoheader og pixeldata ud og det viste sig at infoheaderen skrev 4 bytes mere ud end den burde, og disse 4 bytes lignede de første af pixeldataene (men det er jeg ingengang sikker på for farverne var blevet anderledes).

Jeg prøvede at udkommentere et af de DWORDs som infoheaderen udskrev og filen med de 70 bytes kom nu ud som 70 bytes og var en præcis kopi. Her er det store problem så:

Der går et eller andet grueligt galt med større filer. Når jeg prøver med en fil på 75294 bytes får jeg en med 75104 bytes som er ugyldig. Jeg har også prøvet at få en ud som var større-

Mine skriveoperationer er som følgende:

filheader skriv:

void BMP_writeFileHeader(FILE* file, BMPfileHeader& header)
	{
		printf("\nWriting BMP header to file:\n\n");

		printf("Writing bfType. Wrote %d bytes.\n", fwrite(&header.bfType, sizeof(WORD), 1, file)*sizeof(WORD));
		printf("Writing bfSize. Wrote %d bytes.\n", fwrite(&header.bfSize, sizeof(DWORD), 1, file)*sizeof(DWORD));
		printf("Writing bfReserved1. Wrote %d bytes.\n", fwrite(&header.bfReserved1, sizeof(WORD), 1, file)*sizeof(WORD));
		printf("Writing bfReserved2. Wrote %d bytes.\n", fwrite(&header.bfReserved2, sizeof(WORD), 1, file)*sizeof(WORD));
		printf("Writing bfOffBits. Wrote %d bytes.\n", fwrite(&header.bfOffBits, sizeof(DWORD), 1, file)*sizeof(DWORD));
	}

infoheader skriv:

    void BMP_writeInfoHeader(FILE* file, BMPinfoHeader& header)
	{
		printf("\nWriting BMP info header to file:\n\n");

		printf("Writing biSize. Wrote %d bytes.\n", fwrite(&header.biSize, sizeof(DWORD), 1, file)*sizeof(DWORD));
		printf("Writing biWidth. Wrote %d bytes.\n", fwrite(&header.biWidth, sizeof(DWORD), 1, file)*sizeof(DWORD));
		printf("Writing biHeight. Wrote %d bytes.\n", fwrite(&header.biHeight, sizeof(DWORD), 1, file)*sizeof(DWORD));
		printf("Writing biPlanes. Wrote %d bytes.\n", fwrite(&header.biPlanes, sizeof(DWORD), 1, file)*sizeof(DWORD));
		printf("Writing biBitCount. Wrote %d bytes.\n", fwrite(&header.biBitCount, sizeof(DWORD), 1, file)*sizeof(DWORD));
		printf("Writing biCompression. Wrote %d bytes.\n", fwrite(&header.biCompression, sizeof(DWORD), 1, file)*sizeof(DWORD));
		printf("Writing biSizeImage. Wrote %d bytes.\n", fwrite(&header.biSizeImage, sizeof(DWORD), 1, file)*sizeof(DWORD));
		printf("Writing biXPelsPerMeter. Wrote %d bytes.\n", fwrite(&header.biXPelsPerMeter, sizeof(DWORD), 1, file)*sizeof(DWORD));
		printf("Writing biYPelsPerMeter. Wrote %d bytes.\n", fwrite(&header.biYPelsPerMeter, sizeof(DWORD), 1, file)*sizeof(DWORD));
		printf("Writing biClrUsed. Wrote %d bytes.\n", fwrite(&header.biClrUsed, sizeof(DWORD), 1, file)*sizeof(DWORD));
		//Denne udkommenteres f.eks. og så virker det fint ved 70bytes.
		printf("Writing biClrImportant. Wrote %d bytes.\n", fwrite(&header.biClrImportant, sizeof(DWORD), 1, file)*sizeof(DWORD));
	}

pixel data skriv:

void BMP_writePixels(FILE* file, BMPfile& bmp_file)
	{
		//Read colors
		{
			BYTE r, g, b;
			int index = 0;
			BYTE padd_fill = 0x00;
			int paddings = 0;

			//Run trough row
			for (int row=bmp_file.infoHeader.biHeight; row > 0; row--)
			{
				for(int column=1; column <= (int)bmp_file.infoHeader.biWidth; column++)
				{
					//Load pixel value
					r = bmp_file.pixelData.pixels[index].r;
					g = bmp_file.pixelData.pixels[index].g;
					b = bmp_file.pixelData.pixels[index].b;

					printf("RGB %d,%d:\t", column, row);
					//Print rgb
					printf("%d\t%d\t%d", r,g,b);
					//write bgr
					fwrite(&b, sizeof(BYTE), 1, file);
					fwrite(&g, sizeof(BYTE), 1, file);
					fwrite(&r, sizeof(BYTE), 1, file);
					printf("\tat index %d\n", index);
					++index;
				}
				//Write padding
				paddings = 0;
				for (int i=0; i<bmp_file.padding; i++)
				{ fwrite(&padd_fill, sizeof(BYTE), 1, file); paddings++; }
				printf("Wrote padding; %d bytes\n", paddings);
			}
		}
	}

Som sagt tror jeg ikke det har noget med packing at gøre fordi den læser filen korrekt.

Hvis nogen gerne vil have hele 'projektet' for at gøre det mere overskuelig så skriv lige (der er 340 linier med det meste er bare ligesom de ovenstående skriv og read rutiner).

På forhånd tak.

Okay har fået løst det.. Det var 2 fejl jeg selv har lavet. Den ene var let da jeg så.

biPlanes og biBitCount fylder ikke hver 4 byte men 2 bytes.

Den anden bar meget mere grum og tog timer at finde..

For at finde den nødvendige padding have jeg sagt at der sådan at den skulle være sådan at antallet af bytes i en række i billedet skulle være en faktor af 4. Men jeg kom til at bruge pixels i stedet for bytes hvilket er 1/3 af antallet af bytes.
Mange tak for hjælpen med alt det andet Bertel og Robert.