pset4 - resize fails check50

Question

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
    // TODO: a paren is missing from this line!
    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;
}

Answer 1

Have you looked carefully at the output files? Did you use the xxd tool to look at the image data? Maybe compare it to the output of the staff version of the executable? The output image has n times as many rows as it should, even though the image is created correctly at the beginning of the image space.

That should be enough of a push in the right direction, as requested. ;-)

If this answers your question, please click on the check mark to accept. Let's keep up on forum maintenance. ;-)