I've been reluctant to ask for help but it's got to the stage where I'm all out of ideas. I just cannot get resize to pass check50.

The code looks fine, and when I run it through debug step by step, everything appears to be doing what it should be. I ran it through valgrind, too, just to make sure that there weren't any memory leaks or errors.

I'm not asking for outright answers, but if someone could tell me which area of my code might be causing issues, it really would be much appreciated.

Thanks in advance to anyone willing to help out!

Here's my resize.c code:

#include <stdio.h> #include <stdlib.h>

#include "bmp.h"

int main(int argc, char* argv[]) { // ensure proper usage if (argc != 4) { printf("Usage: ./copy infile outfile\n"); return 1; } else if (atoi(argv[1]) < 1 || atoi(argv[1]) > 100) { printf("Your multiplier should be a number between 1 and 100\n"); return 1; }

// remember filenames
char* infile = argv[2];
char* outfile = argv[3];
int n = atoi(argv[1]); 

// open input file 
FILE* inptr = fopen(infile, "r");
if (inptr == NULL)
{
    printf("Could not open %s.\n", infile);
    return 2;
}

// open output file
FILE* outptr = fopen(outfile, "w");
if (outptr == NULL)
{
    fclose(inptr);
    fprintf(stderr, "Could not create %s.\n", outfile);
    return 3;
}

// read infile's BITMAPFILEHEADER
BITMAPFILEHEADER bf, new_bf;
fread(&bf, sizeof(BITMAPFILEHEADER), 1, inptr);
new_bf = bf;

// read infile's BITMAPINFOHEADER
BITMAPINFOHEADER bi, new_bi;
fread(&bi, sizeof(BITMAPINFOHEADER), 1, inptr);
new_bi = bi;



// ensure infile is (likely) a 24-bit uncompressed BMP 4.0
if (bf.bfType != 0x4d42 || bf.bfOffBits != 54 || bi.biSize != 40 || 
    bi.biBitCount != 24 || bi.biCompression != 0)
{
    fclose(outptr);
    fclose(inptr);
    fprintf(stderr, "Unsupported file format.\n");
    return 4;
}



// update height and width for header files
new_bi.biHeight *= n;
new_bi.biWidth *= n;

// determine padding for scanlines
int padding =  (4 - (bi.biWidth * sizeof(RGBTRIPLE)) % 4) % 4;
int new_padding = (4 - (new_bi.biWidth * sizeof(RGBTRIPLE)) % 4) % 4;

// new image and file sizes
new_bi.biSizeImage = ((new_bi.biWidth * sizeof(RGBTRIPLE) + new_padding) * abs(new_bi.biHeight);
new_bf.bfSize = new_bi.biSizeImage + sizeof(BITMAPINFOHEADER) + sizeof(BITMAPFILEHEADER);



// write outfile's BITMAPFILEHEADER
fwrite(&new_bf, sizeof(BITMAPFILEHEADER), 1, outptr);

// write outfile's BITMAPINFOHEADER
fwrite(&new_bi, sizeof(BITMAPINFOHEADER), 1, outptr);



// iterate over infile's scanlines
for (int i = 0, new_biHeight = abs(new_bi.biHeight); i < new_biHeight; i++)
{
    // loop for n number of lines
    for (int l = 0; l < n; l ++)
    {
        // iterate over pixels in scanline
        for (int j = 0; j < bi.biWidth; j++)
        {
          // temporary storage
            RGBTRIPLE triple;

            // read RGB triple from infile
            fread(&triple, sizeof(RGBTRIPLE), 1, inptr);
        
            // write RGB triple to outfile n times for horizontal

            for (int k = 0; k < n; k ++)
            {
                fwrite(&triple, sizeof(RGBTRIPLE), 1, outptr);
            }
        }
        // skip over padding, if any
        fseek(inptr, padding, SEEK_CUR);

        // then add it back (to demonstrate how)
        for (int k = 0; k < new_padding; k++)
        {
            fputc(0x00, outptr);
        }
        
        // jump back to start of line while l is less than n-1
        if (l < n-1)
        {
            fseek(inptr, -(padding + (bi.biWidth * sizeof(RGBTRIPLE) ) ), SEEK_CUR);
        }
    }
}

// close infile
fclose(inptr);

// close outfile
fclose(outptr);

// that's all folks
return 0;

}