Home Forums C Programming Errors in my program Reply To: Errors in my program

#3329
suryana
Participant

ok now my program is giving no errors and it is showing out put as follow

sizeof Bitmap File Header=14
size of Bitmap Image=2410
sizeof Bitmap Info Header=40
Height of this Bitmap Image=37
Width of this Bitmap Image=34

Now I want to modify such that it should dispaly size of compressed Bitmap
Now I want to show size of image after compressing on the screen but I don’t know how to do it
Out put should be as Follow

Before Compressing

sizeof Bitmap File Header=14
size of Bitmap Image=2410
sizeof Bitmap Info Header=40
Height of this Bitmap Image=37
Width of this Bitmap Image=34

After Compressing

sizeof Bitmap File Header=14
size of Bitmap Image=2410
sizeof Bitmap Info Header=40
Height of this Bitmap Image=37
Width of this Bitmap Image=34

Code of full program is as follow
I m using Dev C++ Compiler and this project is a basically Console program.

#include<conio.h>
#include <iostream>
#include <fstream>
#include <windows.h>

using namespace std;
int CompressInRLE8(BYTE* pSrcBits, BYTE * pRLE_Bits, int& RLE_size);
BOOL EndOfLine(int pos);
int main(int argc, char *argv[])
{

BITMAPFILEHEADER bitmapFileHeader;
BITMAPINFOHEADER bitmapInfoHeader;

ifstream file("test.bmp", ios::in);

if(!file){

cerr<<"File can not be opened"<<endl;
exit(1);

}

file.read(reinterpret_cast<char *> (&bitmapFileHeader),sizeof(BITMAPFILEHEADER));

if(bitmapFileHeader.bfType != 19778 )
cout <<" This is not a bitmap (.bmp) file ....";
else
{
cout << "sizeof Bitmap File Header =" << sizeof(bitmapFileHeader) << endl;
cout << "size of Bitmap Image =" << bitmapFileHeader.bfSize << endl;

}

file.read(reinterpret_cast<char *> (&bitmapInfoHeader),sizeof(BITMAPINFOHEADER));
if( bitmapInfoHeader.biBitCount != 8)
{
cout <<" This is not a 8 bit bitmap (.bmp) file ....";

}

else
{

cout << "sizeof Bitmap Info Header =" << sizeof(bitmapInfoHeader) << endl;
cout << "Height of this Bitmap Image =" << bitmapInfoHeader.biHeight << endl;
cout << "Widht of this Bitmap Image =" << bitmapInfoHeader.biWidth << endl;

int numColors = 1<<bitmapInfoHeader.biBitCount;
RGBQUAD rgbQuad[numColors];
file.read(reinterpret_cast<char *> (&rgbQuad),sizeof(rgbQuad));
}

getche();
}

BOOL EndOfLine(int pos)

{
DIBSECTION  m_dib;
if ( 0 != m_dib.dsBmih.biWidth % 4 )
{
int scanline_width = m_dib.dsBmih.biWidth;
scanline_width = scanline_width + ( 4 - (scanline_width%4));
pos %= scanline_width;
}

return 0 == ((pos+1)% m_dib.dsBmih.biWidth);
}

int CompressInRLE8(BYTE* pSrcBits, BYTE * pRLEBits, int& RLE_size)
{

DIBSECTION  m_dib;
int line;
int src_index = 0, dst_index = 0, counter, i;
// in RLE8 every pixel is one byte

for ( line = 0;  line < m_dib.dsBmih.biHeight; line++)
{

state_start:  // just at the start of a block

if ( EndOfLine(src_index)) // this is the last pixel of the line
{
pRLEBits[dst_index++] = 1; // block of length 1
pRLEBits[dst_index++] = pSrcBits[src_index];

src_index++;
goto end_of_line;
}

// now the block length is at least 2, look ahead to decide next state
// next two same pixels are the same, enter compress mode
if (pSrcBits[src_index] == pSrcBits[src_index+1])
goto state_compress;

if ( EndOfLine(src_index+1)) // the last 2 pixel of the line
{  // these 2 pixel are not the same
pRLEBits[dst_index++] = 1; // block of length 1
pRLEBits[dst_index++] = pSrcBits[src_index++];
pRLEBits[dst_index++] = 1; // block of length 1
pRLEBits[dst_index++] = pSrcBits[src_index++];
goto end_of_line;
}

// now the block length is at least 3
// in next 3 pixels, the last 2 consecutive pixel are the same
if (pSrcBits[src_index+1] == pSrcBits[src_index+2])
{
pRLEBits[dst_index++] = 1; // block of length 1
pRLEBits[dst_index++] = pSrcBits[src_index++];
goto state_compress;
}
else // in these 3 pixel, no 2 consecutive pixel are the same
goto state_no_compress; // un-compressed block need at least 3 pixel

state_compress:  // compress mode

// src_index is the first pixel of a compressd block
// counter is the number of additional pixels following currrent pixel
// (src_index+counter) point to the last pixel of current block
for ( counter = 1; counter <= 254; counter++)
{
// must check this condition first, or a BUG occur!
if ( pSrcBits[src_index+counter] != pSrcBits[src_index] )
break;
if ( EndOfLine(src_index+counter) ) // reach end of line
{
pRLEBits[dst_index++] = counter+1; // block length is (counter+1)
pRLEBits[dst_index++] = pSrcBits[src_index];
src_index += counter +1;
goto end_of_line;
}

}
// now pSrcBits[src_index+counter] falls out of block
pRLEBits[dst_index++] = counter; // block length is (counter)
pRLEBits[dst_index++] = pSrcBits[src_index];
src_index += counter;
goto state_start;

state_no_compress:
// src_index is the first pixel of a un-compressd block
// un-compressed block need at least 3 pixel
// counter is the number of additional pixels following currrent pixel
for (counter = 2; counter <= 254; counter++)
{
if ( EndOfLine(src_index+counter) ) // reach end of line
{
pRLEBits[dst_index++] = 0; // escape character for un-compress block
pRLEBits[dst_index++] = counter + 1; // block length is (counter+1)
for (i = counter + 1; i > 0; i--)
pRLEBits[dst_index++] = pSrcBits[src_index++];
if ( 0 != ((counter+1) % 2) ) // block length is odd
pRLEBits[dst_index++];	// padd with a zero byte
goto end_of_line;
}

if ( EndOfLine(src_index+counter+1)  ||
pSrcBits[src_index+counter] != pSrcBits[src_index+counter+1] )
continue;   // still no 2 consecutive pixel are the same,
// therefore continue to extend the un-compress block
// we found two pixels are the same
if ( EndOfLine(src_index+counter+2) ||
pSrcBits[src_index+counter+1] != pSrcBits[src_index+counter+2] )
continue; // the third pixel is not the same, no need to exit un-compressed mode
else
{  // // now pSrcBits[src_index+counter] and following 2 pixel are the same
// now we need to exit the un-compressed mode
if ( counter > 2)
counter--; // we can shrink the block one pixel (go backward)
pRLEBits[dst_index++] = 0; // escape character for un-compress block
pRLEBits[dst_index++] = counter+1; // block length is (counter+1)
for (i = counter+1; i > 0; i--)
pRLEBits[dst_index++] = pSrcBits[src_index++];
if ( 0 != ((counter+1) % 2) ) // block length is odd
pRLEBits[dst_index++];	// padd with a zero byte
goto state_compress;
}
} // end of for (counter = 2; counter <= 254; counter++)

// now we have a full block of 255 pixels
pRLEBits[dst_index++] = 0; // escape character for un-compress block
pRLEBits[dst_index++] = counter; // block length is (counter)
for (i = counter; i > 0; i--)
pRLEBits[dst_index++] = pSrcBits[src_index++];
if ( 0 != ((counter) % 2) )   // block length is odd
pRLEBits[dst_index++];  // padd with a zero byte
goto state_start;

end_of_line:

if ( 0 != (src_index % 4 )) // each scan line is dword align
{
int pad =  4 - (src_index%4);
src_index += pad;
}

// src_index already point to the start of next line
pRLEBits[dst_index++] = 0; // mark end-of-line
pRLEBits[dst_index++] = 0;
}

pRLEBits[dst_index++] = 0; // mark end-of-bitmap
pRLEBits[dst_index++] = 1;

RLE_size = dst_index; // image size

}

so help me to do that as quick as possible so that I can do that project very quickly Waiting for ur immediate response.

  • This reply was modified 7 years, 4 months ago by M. Saqib.
  • This reply was modified 2 years, 5 months ago by M. Saqib.
  • This reply was modified 2 years, 5 months ago by M. Saqib.