can't write .bmp header or image data to output file

**MWJack** · 12-12-2015

I have been working on this program. I believe that I have correctly opened and read my file into the structures. When I try to access the structure value using the pointer to the structure, it won't build. However, when I access the structure value using the array, then it works. I believe that it is because my array is a 2D array, whereas the pointer to structure is 1D.

So,I have written the information to an output file, however, no content is displayed. I have used the fwrite for each value to an output file. I am using a nested for-loop to write the image data to the output file. I have been unable to write the headers.
***************************************
I want to successfully write (copy) the image because I plan to manipulate it.

Could anyone point me in the right direction concerning writing the output?

Here is my code:

Code:


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
//----------------------------------------------------------------------------------
typedef unsigned short int WORD;
typedef unsigned long int DWORD;


typedef struct tagBITMAPFILEHEADER {
  short bfType;
  long  bfSize;                                
  short bfReserved1;
  short bfReserved2;
  long  bfOffBits;
} BITMAPFILEHEADER;
//typedef PBITMAPFILEHEADER pbfh;
//-----------------------------------------
//Struct for DIB BMP file info
typedef struct tagBITMAPCOREHEADER {                                
  long  bcWidth;//---------Image width
  long  bcHeight;//--------Image height
  short bcPlanes;//-------Planes
  short bcBitCount;//-----Bitcount
  long  bcCompression;//---Compression
  long  bcSizeImage;//-----Image size
  long  bcXPelsPerMeter;//-
  long  bcYPelsPerMeter;//-
  long  bcClrUsed;//-------Number of colors used
  long  bcClrImportant;//--Important colors
} BITMAPCOREHEADER;


//-------------Pixels for editing-------------//
typedef struct tagRGBTRIPLE {  //from WinGDI.h
        unsigned char   b; //rgbtBlue;
        unsigned char   g; //rgbtGreen;
        unsigned char   r; //rgbtRed;
} pix;


#define BYTES_PER_PIX sizeof(pix)            //Header Pixels


const pix RED = {0,0,255};
const pix GREEN = {0,255,0};
const pix BLUE = {255,0,0};
//--------------------------------------------
void bitmapfileheader(BITMAPFILEHEADER *PBITMAPFILEHEADER, char name1[]);//FILE HEADER
void bitmapcoreheader(BITMAPCOREHEADER *PBITMAPCOREHEADER, char name1[]);//CORE HEADER
int pixeldata(pix *ppix,BITMAPCOREHEADER *PBITMAPCOREHEADER, BITMAPFILEHEADER *PBITMAPFILEHEADER,char name1[],char name2[]);




int main(void)
{
    FILE *fp1, *fp2, *BMPFile, *BMPCFile, *buffer, *pxr, *pxr1;
    tagBITMAPFILEHEADER BMF;
    tagBITMAPCOREHEADER BMC;
    BITMAPFILEHEADER *PBITMAPFILEHEADER=&BMF;
    BITMAPCOREHEADER *PBITMAPCOREHEADER=&BMC;
    tagRGBTRIPLE RGBP;
    pix *ppix=&RGBP, *p;
    pix** img1;
    char *pixels, name1[40], name2[40], name3[40],temp[4];
    unsigned long fileLen;
    int i, j, red, green, blue, count=0, padding=0, numPixels;


    //Open file
    printf("Enter filename (full path if not in current directory): ");
     scanf("%s", name1);


    fp1 = fopen(name1, "rb");
    if (fp1==NULL)
    {
        fprintf(stderr, "Unable to open file %s", name1);
        exit (1);
    }
    //-------------Write output Image-----------//
    printf("\nName of output file: ");
    scanf("%s", name2);


    fp2 = fopen(name2, "wb");
    if(fp2==NULL)
    {
        printf("Could not open %s.\n", name2);
        //free(ppix);
        exit(1);
    }
    //Get file length
    fseek(fp1, 0, SEEK_END);
    fileLen=ftell(fp1);
    fseek(fp1, 0, SEEK_SET);
    printf("\nLoaded %ld bytes\n", (long)fileLen);
    fclose(fp1);
    bitmapfileheader(PBITMAPFILEHEADER,name1);
    bitmapcoreheader(PBITMAPCOREHEADER,name1);
    pixeldata(ppix,PBITMAPCOREHEADER, PBITMAPFILEHEADER,name1, name2);


    printf("File copied Successfully!");
    fclose(fp1);
    fclose(fp2);
    //free(theArray);
    getchar ();
    getchar ();
    
    return 0;
}




//----------------------------------BITMAPFILEHEADER Display-------------------------------
void bitmapfileheader(BITMAPFILEHEADER *PBITMAPFILEHEADER, char name1[]) 
{
    //BITMAPFILEHEADER *PBITMAPFILEHEADER;
    FILE *BMPFile = fopen(name1, "rb");
    fread(&PBITMAPFILEHEADER->bfType, sizeof (short), 1, BMPFile);
    fread(&PBITMAPFILEHEADER->bfSize, sizeof (long), 1, BMPFile);
    fread(&PBITMAPFILEHEADER->bfReserved1, sizeof (short), 1, BMPFile);
    fread(&PBITMAPFILEHEADER->bfReserved2, sizeof (short), 1, BMPFile);
    fread(&PBITMAPFILEHEADER->bfOffBits, sizeof (long), 1, BMPFile);
    printf("BITMAP FILE HEADER INFO: \n");
    printf(" Header memory address is : 0x%x \n", BMPFile);
    printf(" File type (BM=0x424d=19778):%d \n",PBITMAPFILEHEADER->bfType);
    printf(" File size in bytes is : %d \n",PBITMAPFILEHEADER->bfSize);
    printf(" Reserve1:%hd\n", PBITMAPFILEHEADER->bfReserved1);  
    printf(" Reserve2:%hd\n", PBITMAPFILEHEADER->bfReserved2);
    printf(" Offset to pixel start (hex) is: %d\n", PBITMAPFILEHEADER->bfOffBits);
    fclose(BMPFile);
}
//------------------------------BITMAPINFOHEADER Display------------------------------------//
void bitmapcoreheader(BITMAPCOREHEADER *PBITMAPCOREHEADER, char name1[] )
{
    //BMP DIB HEADER /coreheader
    //BITMAPCOREHEADER *PBITMAPCOREHEADER;
    FILE *BMPCFile = fopen(name1, "rb");
    fseek(BMPCFile, 18, SEEK_SET);
    
    //-------------------Read file contents into struct BCH--------------------------------------------
    //This fread stuff is so the compiler doesnt padd from largest to smaller in an unorganized fashion. 
    fread(&PBITMAPCOREHEADER->bcWidth, sizeof (long), 1, BMPCFile);
    fread(&PBITMAPCOREHEADER->bcHeight, sizeof (long), 1, BMPCFile);
    fread(&PBITMAPCOREHEADER->bcPlanes, sizeof (short), 1, BMPCFile);
    fread(&PBITMAPCOREHEADER->bcBitCount, sizeof (short), 1, BMPCFile);
    fread(&PBITMAPCOREHEADER->bcCompression, sizeof (long), 1, BMPCFile);
    fread(&PBITMAPCOREHEADER->bcSizeImage, sizeof (long), 1, BMPCFile);
    fread(&PBITMAPCOREHEADER->bcXPelsPerMeter, sizeof (long), 1, BMPCFile);
    fread(&PBITMAPCOREHEADER->bcYPelsPerMeter, sizeof (long), 1, BMPCFile);
    fread(&PBITMAPCOREHEADER->bcClrUsed, sizeof (long), 1, BMPCFile);
    fread(&PBITMAPCOREHEADER->bcClrImportant, sizeof (long), 1, BMPCFile);
    //-----------------------------Print struct data------------------------------------
    printf("\nBMP DIB INFO: \n");                  
    printf(" Image Width:%ld\n", PBITMAPCOREHEADER->bcWidth);    
    printf(" Image Height:%ld\n", PBITMAPCOREHEADER->bcHeight);  
    printf(" biPlanes:%hd\n", PBITMAPCOREHEADER->bcPlanes);  
    printf(" biBitCount:%hd\n", PBITMAPCOREHEADER->bcBitCount);
    printf(" biCompression:%ld\n", PBITMAPCOREHEADER->bcCompression);  
    printf(" biSizeofImage(Height*Width):%ld\n", PBITMAPCOREHEADER->bcSizeImage);  
    printf(" biXPelsPerMeter:%ld\n", PBITMAPCOREHEADER->bcXPelsPerMeter);  
    printf(" biYPelsPerMeter:%ld\n", PBITMAPCOREHEADER->bcYPelsPerMeter);  
    printf(" biClrUsed:%ld\n", PBITMAPCOREHEADER->bcClrUsed);  
    printf(" biClrImportant:%ld\n\n", PBITMAPCOREHEADER->bcClrImportant);  
       
    fclose(BMPCFile);
    //-----------------------------------------------------------------------------------
    
}


int pixeldata(pix *ppix,BITMAPCOREHEADER *PBITMAPCOREHEADER, BITMAPFILEHEADER *PBITMAPFILEHEADER,char name1[],char name2[])
{


    int i=0, j=0;
    int size_spix; // size of struct pix
    int padding = 0;
    char temp[4];
    FILE* fp=fopen(name1, "rb");
    padding = (int)PBITMAPCOREHEADER->bcWidth % 4;
    if(padding != 0 ) {
        padding = 4 - padding;
   }
    
    size_spix = sizeof(pix);
    pix **pixel_arrayp;
 
    printf("\nSize_spix: %d\n", size_spix);


   /*allocate memory*/
    pixel_arrayp = (pix **)calloc(PBITMAPCOREHEADER->bcHeight,sizeof(pix));
 
    for(i=0;i<((int)PBITMAPCOREHEADER->bcHeight); i++) {
          pixel_arrayp[i] = (pix *)calloc(PBITMAPCOREHEADER->bcWidth,size_spix);
    }
    
    printf("\nReading Pixels Info...\n");
    for(i=0; i < ((int)PBITMAPCOREHEADER->bcHeight); i++) 
    {
        for(j=0; j < (int)PBITMAPCOREHEADER->bcWidth; j++) 
        {
            fread(&pixel_arrayp[i][j], 3,1,  fp);
            //fwrite(&pixel_arrayp[i][j], 3, 1, BMP_out);
            printf("y=%d  x=%d   ", i+1, j+1);
            printf("[%d][%d][%d]\n",pixel_arrayp[i][j].r, pixel_arrayp[i][j].g,pixel_arrayp[i][j].b);      
        }
      if(padding != 0) {
         printf("Padding: %d\n", padding);
         fread(&temp, padding, 1,  fp);            
      }
   }
    fclose(fp);
     
    FILE *BMP_out = fopen(name2, "w");
   if (BMP_out == NULL) {
      printf("\nCannot open file\n");
      exit(1);
   }
   printf("\nWriting Header...\n");
   //save to new bmp file
   //-----------------------------------------------------------------
    //fwrite(&PBITMAPFILEHEADER, 14, 1,  BMP_out);
    fwrite(&PBITMAPFILEHEADER->bfType, sizeof (PBITMAPFILEHEADER->bfType), 1, BMP_out);
    fwrite(&PBITMAPFILEHEADER->bfSize, sizeof (PBITMAPFILEHEADER->bfSize), 1, BMP_out);
    fwrite(&PBITMAPFILEHEADER->bfReserved1, sizeof (PBITMAPFILEHEADER->bfReserved1), 1, BMP_out);
    fwrite(&PBITMAPFILEHEADER->bfReserved2, sizeof (PBITMAPFILEHEADER->bfReserved2), 1, BMP_out);
    fwrite(&PBITMAPFILEHEADER->bfOffBits, sizeof (PBITMAPFILEHEADER->bfOffBits), 1, BMP_out);
 
   //-----------------------------------------------------------------


    //fwrite(&PBITMAPCOREHEADER, 40, 1, BMP_out);
    fwrite(&PBITMAPCOREHEADER->bcWidth, sizeof (PBITMAPCOREHEADER->bcWidth), 1, BMP_out);
    fwrite(&PBITMAPCOREHEADER->bcHeight, sizeof (PBITMAPCOREHEADER->bcHeight), 1, BMP_out);
    fwrite(&PBITMAPCOREHEADER->bcPlanes, sizeof (PBITMAPCOREHEADER->bcPlanes), 1, BMP_out);
    fwrite(&PBITMAPCOREHEADER->bcBitCount, sizeof (PBITMAPCOREHEADER->bcBitCount), 1, BMP_out);
    fwrite(&PBITMAPCOREHEADER->bcCompression, sizeof (PBITMAPCOREHEADER->bcCompression), 1, BMP_out);
    fwrite(&PBITMAPCOREHEADER->bcSizeImage, sizeof (PBITMAPCOREHEADER->bcSizeImage), 1, BMP_out);
    fwrite(&PBITMAPCOREHEADER->bcXPelsPerMeter, sizeof (PBITMAPCOREHEADER->bcXPelsPerMeter), 1, BMP_out);
    fwrite(&PBITMAPCOREHEADER->bcYPelsPerMeter, sizeof (PBITMAPCOREHEADER->bcYPelsPerMeter), 1, BMP_out);
    fwrite(&PBITMAPCOREHEADER->bcClrUsed, sizeof (PBITMAPCOREHEADER->bcClrUsed), 1, BMP_out);
    fwrite(&PBITMAPCOREHEADER->bcClrImportant, sizeof (PBITMAPCOREHEADER->bcClrImportant), 1, BMP_out);
 
   
   //------------------------------------------------------------------
   printf("\nWriting Pixels...\n");
   for(i=0; i < (int)PBITMAPCOREHEADER->bcHeight ; i++) {
      for(j=0; j < (int)PBITMAPCOREHEADER->bcWidth; j++) {   
         fwrite(&pixel_arrayp[i][j], 3, 1, BMP_out);
         printf("y=%d  x=%d   ", i+1, j+1);
         printf("[%d][%d][%d]\n",pixel_arrayp[i][j].r, pixel_arrayp[i][j].g,pixel_arrayp[i][j].b);
      }
      if(padding != 0) {
         //printf("Padding: %d\n", padding);
         fwrite(&temp, padding, 1,BMP_out);
      }
   }
   printf("\nDone writing...\n");




   fclose(fp);
   fclose(BMP_out);
   return 0;
}

Thread: can't write .bmp header or image data to output file

Thread Tools

Search Thread

Display

can't write .bmp header or image data to output file

Similar Threads

A program to calculate students grades from an input file and write to output file

Program in c++ to extract the header of Tiff Image File

How to write image data to binary PGM file format(P5)?

Input & output image file in C++

How to write a C code to load an image file.