Inside

/****************************************************************/
/*                                                              */
/* Title: How JPEG format works                                 */
/*                                                              */
/****************************************************************/
 
/************************** Start *******************************/
#include <windows.h>
#include <stdio.h>
 
/****************************************************************/
/*                                                              */
/* FeedBack Data                                                */
/*                                                              */
/****************************************************************/
void abc(char* s)
{
     FILE *fp;
     fp = fopen("t.txt", "a+");
     fprintf(fp, "%s\n",s);
     fclose(fp);
}
 
void readjpeg();
 
/****************************************************************/
/*                                                              */
/* Entry Point                                                  */
/*                                                              */
/****************************************************************/
int __stdcall WinMain (HINSTANCE hInst, HINSTANCE hPrev, LPSTR lpCmd, int nShow)
{
  readjpeg();
  return 0;
}
 
/****************************************************************/
/*                                                              */
/* jpeg functions                                               */
/*                                                              */
/****************************************************************/
 
 
/* Okay before we start getting overwelmed by bits and bytes and
bit shifting and all sorts of special tricks.. we should first
read in the header...which is the first part of the file, and
can tell us a lot about the jpeg file. */
 
// First lets define some things
#define             SOI                  /*Start of Image*/  0xffd8
#define             EOI                  /*End of Image  */  0xffd9
 
void readjpeg()
{
             byte chunk[2];
             WORD sizechunk;
 
     FILE *f;
     f = fopen("balloon.jpg", "rb");
             // Lets read in the first word (e.g. a word is 2 bytes).
     fread(chunk, 1, 2, f);
 
     // really big buffer for text
     char buff[200];
             // Output what we have read in.. see what it is?
     sprintf(buff, "First 2 bytes are: 0x%x, 0x%x", chunk[0], chunk[1] );
     abc(buff);
 
             fclose(f);
}
 
// okay if you run the program you'll get as an output:
/*
            First 2 bytes are: 0xff, 0xd8
*/
// This tells us that the file we are dealing with is a jpeg,
// as it starts with 0xffd8 which means SOI (Start Of Image).

#include <windows.h>
#include <stdio.h>
 
/****************************************************************/
/*                                                              */
/* FeedBack Data                                                */
/*                                                              */
/****************************************************************/
void abc(char* s)
{
     FILE *fp;
     fp = fopen("t.txt", "a+");
     fprintf(fp, "%s\n",s);
     fclose(fp);
}
 
void readjpeg();
 
/****************************************************************/
/*                                                              */
/* Entry Point                                                  */
/*                                                              */
/****************************************************************/
int __stdcall WinMain (HINSTANCE hInst, HINSTANCE hPrev, LPSTR lpCmd, int nShow)
{
  readjpeg();
  return 0;
}
 
/****************************************************************/
/*                                                              */
/* jpeg functions                                               */
/*                                                              */
/****************************************************************/
 
 
/* Okay before we start getting overwelmed by bits and bytes and
bit shifting and all sorts of special tricks.. we should first
read in the header...which is the first part of the file, and
can tell us a lot about the jpeg file. */
 
// First lets define some things
#define             SOI                  /*Start of Image*/  0xffd8
#define             EOI                  /*End of Image  */  0xffd9
 
#define             APP0   /**/          0xffe0 /*to 0xffef APP15*/
 
// Really big buffer for text output
char buff[200];
 
void readjpeg()
{
     byte chunk[2];
     byte sizeofchunk[2];
 
     FILE *f;
     f = fopen("balloon.jpg", "rb");
             // Lets read in the first 8 bytes
     fread(chunk, 1, 2, f);
 
 
             // Output what we have read in.. see what it is?
     sprintf(buff, "First 2 bytes are: 0x%x, 0x%x", chunk[0], chunk[1] );
     abc(buff);
 
     fread(chunk, 1, 2, f);
     fread(sizeofchunk, 1, 2, f);
     short unsigned int size = ((sizeofchunk[0] << 8) | sizeofchunk[1]);

sprintf(buff, "Second 2 bytes are: 0x%x, 0x%x", chunk[0], chunk[1] );
     abc(buff);
     sprintf(buff, "Size of our piece of data:%u", size);
     // Remeber the size includes the 2 bytes for the size.
     abc(buff);

// Now we now how big the next chunk is, we can read it in.
     // I know its an app0 chunk because the chunk was 0xffe0

char temp[100];
     fread(&temp, size - 2, 1, f);
     temp[size - 2 + 1] = '\0'; // Null terminate the string :)

sprintf(buff, "The APP0 value: %s", temp);
     abc(buff);

// A stage further, opening up the various sections.

//  Lets try and read in all the data...see what we get...
     //  Remeber now, its a 2 byte value which tells us what it is,
     //  then a 2 byte value of how bit it is :)
   
     while(true)
     {
                fread(chunk, 1, 2, f);
               
                // If the chunk we read in doesn't begin with 0xff then
                // then its not a valid chunk and so exit.
                if( chunk[0] != 0xff )
                {
                            sprintf(buff, "Error chunk[0] was: 0x%x, chunk[1]: 0x%x", chunk[0], chunk[1]);
                            abc(buff);
                            break;
                }

// If we get 0xffd9 then its the EOF (End Of File)
                if( chunk[1] == 0xd9 )
                {
                            abc("End Of File");
                            break;
                }

fread(sizeofchunk, 2, 1, f);
                short unsigned int size = ((sizeofchunk[0] << 8) | sizeofchunk[1]);

if( chunk[1] == 0xda )
                {
                // Okay this means we have started to scan the encoded data.
                            byte count;
                            fread(&count, 1, 1, f);
                            sprintf(buff, "Start of scan count: %u", count);
                            abc(buff);
                            //fseek(f, -1, SEEK_CUR);

while(count != 0xff)
                            {
                                        fread(&count, 1, 1, f);
                                        if(count == 0xff)
                                        {
                                                    fread(&count, 1, 1, f);
                                                    if(count != 0x00)
                                                                break;
                                        }

}
                            sprintf(buff, "\nEnd of scan value: 0xff%x", count);
                            abc(buff);

break;
                           
                           
                }

sprintf(buff, "Chunk ID: 0x%x%x,   Size:%u",
                                        chunk[0], chunk[1], size);
                abc(buff);

fseek(f, size-2, SEEK_CUR);

}

fclose(f);
}

JPEG

The mysterious world of the jpeg file format explained