Pset3 Resize Array not storing data properly

Question

I'm not sure where the issue is here, but from the looks of debug I only store anything in my horizontal array (line) once despite seeing the debugger hitting that section of code properly. I assume I misunderstand how pointers work and i'm assigning incorrectly but I don't know how. My instincts tell me that my treating it like an array with [count] is not properly moving positions down the line but I don't know how to properly do this.

    // Copies a BMP file

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

#include "bmp.h"

int main(int argc, char *argv[])
{
    // ensure proper usage
    if (argc != 4)
    {
        fprintf(stderr, "Usage: ./resize n infile outfile.\n");
        return 1;
    }

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

    //checks the factor size is within 0 - 100
    if (n < 0 || n > 100)
    {
        printf("Please enter a factor size between 0 and 100.\n");
        return 1;
    }

    // open input file
    FILE *inptr = fopen(infile, "r");
    if (inptr == NULL)
    {
        fprintf(stderr, "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;
    fread(&bf, sizeof(BITMAPFILEHEADER), 1, inptr);

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

    // 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;
    }

    //create new info and file header for outfile
    BITMAPINFOHEADER bi2;
    BITMAPFILEHEADER bf2;
    bi2 = bi;
    bf2 = bf;

    //assign new Height and Width to new header files
    bi2.biWidth = bi.biWidth * n;
    bi2.biHeight = bi.biHeight * n;

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


    // determine padding for outfile scanlines
    int paddingOut = (4 - (bi2.biWidth * sizeof(RGBTRIPLE)) % 4) % 4;

    //edit SizeImage and size in outfile headerfile
    bi2.biSizeImage = ((sizeof(RGBTRIPLE) * bi2.biWidth) + paddingOut) * abs(bi2.biHeight);
    bf2.bfSize = bi2.biSizeImage + sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);

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

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


    //create array to store scanlines in
    RGBTRIPLE *line = malloc(sizeof(RGBTRIPLE) * bi2.biWidth);

    // iterate over infile's scanlines
    for (int i = 0, biHeight = abs(bi.biHeight); i < biHeight; i++)
    {
        int count = 0;

        // iterate over pixels in scanline
        for (int j = 0; j < abs(bi.biWidth); j++)
        {
            // temporary storage
            RGBTRIPLE triple;


            // read RGB triple from infile
            fread(&triple, sizeof(RGBTRIPLE), 1, inptr);

            //write pixel to array n times
            for (int k = 0; k < n; k++)
            {
                line[count] = triple;
                count++;
            }

        }

        // skip over padding, if any
        fseek(inptr, paddingIn, SEEK_CUR);

        // write array to outfile n times
        for (int l = 0; l < n; l++)
        {
            fwrite(line, sizeof(sizeof(RGBTRIPLE) * bi2.biWidth ) + 1, n, outptr);
        }

        //add padding
        for (int p = 0; p < paddingOut; p++)
        {
            fputc(0x00, outptr);
        }

    }
    free(line);

    // close infile
    fclose(inptr);

    // close outfile
    fclose(outptr);

    // success
    return 0;
}

Answer 1

In the posted code, the code skips over the padding after each RGBTRIPLE! It should only do this after each row is processed. The code to skip the input padding shouldn't be inside the loop that processes each pixel.

There may be other issues. Without seeing the other header calculations, or the padding calculations, or sample output, there's no way to know.

Programming note: The code copies each individual element in the RGBTRIPLE struct triple. Instead of 3 separate lines of code to copy each element, you could just copy the entire struct at once.

            line[count]=triple;

It's a lot quicker, simpler and more efficient to do the latter.

[EDIT: after new code added.] Still has a few issues.

First, look at the following:

        // write array to outfile n times
        for (int l = 0; l < n; l++)
        {
            fwrite(line, sizeof(line), 1, outptr);
        }

line is a pointer. How large is a pointer? Here's an analogy. My finger is a pointer. It can point at a golf ball, a car, or the moon. In each case, how big is my finger? Does it ever change size? (well, only if I eat too much!) ;-)

Next, when is the padding being added to the output file?

Are you looking at the actual digital data being generated in the output file? It would make it a lot easier to spot patterns!

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

Answer 2

For future readers, unfortunately I was unable to rectify this code and ended up going with moving the file pointer back to the start of the line which is FAR less complicated.