Question

 for(unsigned int  h=0; h<ImageBits.iHeight; h++)
  {
        for(unsigned int  w=0; w<ImageBits.iWidth; w++)
        {
              // So in this loop - if our data isn't aligned to 4 bytes, then its been padded
              // in the file so it aligns...so we check for this and skip over the padded 0's
              // Note here, that the data is read in as b,g,r and not rgb as you'd think!
              unsigned char r,g,b;
              fread(&b, 1, 1, fp);
              fread(&g, 1, 1, fp);
              fread(&r, 1, 1, fp);

              ImageBits.pARGB[ w + h*ImageBits.iWidth ] = (r<<16 | g<<8 | b);

        }// End of for loop w

        //If there are any padded bytes - we skip over them here
        if( iNumPaddedBytes != 0 )
        {
              unsigned char skip[4];
              fread(skip, 1, 4 - iNumPaddedBytes, fp);
        }// End of if reading padded bytes

  }// End of for loop h

I do not understand this statement and how does it store the rgb value of the pixel

ImageBits.pARGB[ w + h*ImageBits.iWidth ] = (r<<16 | g<<8 | b);

i did a read up on the << bitwise shift operator but i still do not understand how it works.Can someone help me out here.

Answer 1

Bit shifting moves the bits that make up the value along by the number you specify.

In this case it’s done with colour values so that you can store multiple 1 byte components (such as RGBA which are in the range 0-255) in a single 4 byte structure such as an int

Take this byte:

00000011

which is equal to 3 in decimal. If we wanted to store the value 3 for the RGB and A channel, we would need to store this value in the int (the int being 32 bits)

R        G        B        A
00000011 00000011 00000011 00000011 

As you can see the bits are set in 4 groups of 8, and all equal the value 3, but how do you tell what the R value is when it’s stored this way?

If you got rid of the G/B/A values, you’d be left with

00000011 00000000 00000000 00000000

Which still doesn’t equal 3 – (in fact it’s some massive number – 12884901888 I think)

In order to get this value into the last byte of the int, you need to shift the bits 24 places to the right. e.g.

12884901888 >> 24

Then the bits would look like this:

00000000 00000000 00000000 00000011

And you would have your value ‘3’

Basically it’s just a way of moving bits around in a storage structure so that you can better manipulate the values. Putting the RGBA values into a single value is usually called stuffing the bits