feat: png,jpeg file support

Author: indrasuthar07

Makefile

@@ -1,19 +1,24 @@
 # Compiler and compiler flags
 CC = gcc
-CFLAGS = -g -std=c11 -Wall -Wextra -Werror -Wshadow
-LDFLAGS = -lm
+CFLAGS = -g -std=c11 -Wall -Wextra -Wshadow
+LDFLAGS = -lm -lpng -ljpeg
+
+# Include paths (adjust for your system)
+INCLUDES = -I/ucrt64/include
+# For Linux/macOS with standard paths, comment out INCLUDES or set to empty:
+# INCLUDES =
 
 # Source files and executable name
-SRCS = filter.c helpers.c
-TARGET = filter
+SRCS = filter.c helpers.c image_io.c bmp_io.c png_io.c jpeg_io.c
+TARGET = filter.exe
 
 # Default target
 all: $(TARGET)
 
 # Rule to link the object files into the final executable
 $(TARGET): $(SRCS)
-	$(CC) $(CFLAGS) $^ -o $@ $(LDFLAGS)
+	$(CC) $(CFLAGS) $(INCLUDES) $^ -o $@ $(LDFLAGS)
 
 # Rule to clean up generated files
 clean:
-	rm -f $(TARGET)
+	rm -f $(TARGET) *.o

bmp.h

@@ -14,7 +14,7 @@
 #endif
 
 // --- Bitmap File Header (14 bytes) ---
-typedef struct
+typedef struct bmp_file_header_struct
 {
     uint16_t bfType;         // File type ("BM")
     uint32_t bfSize;         // Size of the file in bytes
@@ -24,7 +24,7 @@ typedef struct
 } BITMAPFILEHEADER;
 
 // --- Bitmap Info Header (40 bytes for BITMAPINFOHEADER) ---
-typedef struct
+typedef struct bmp_info_header_struct
 {
     uint32_t biSize;            // Header size (40 bytes)
     int32_t  biWidth;           // Image width in pixels
@@ -40,7 +40,7 @@ typedef struct
 } BITMAPINFOHEADER;
 
 // --- RGB Triple (3 bytes per pixel) ---
-typedef struct
+typedef struct bmp_rgb_triple_struct
 {
     uint8_t rgbtBlue;
     uint8_t rgbtGreen;

bmp_io.c

@@ -0,0 +1,107 @@
+#include "image_io.h"
+#include "bmp.h"
+#include <stdlib.h>
+#include <string.h>
+
+// Read BMP file
+int read_bmp(const char *filename, ImageData *img) {
+    FILE *inptr = fopen(filename, "rb");
+    if (inptr == NULL) {
+        return 1;
+    }
+    BITMAPFILEHEADER bf;
+    if (fread(&bf, sizeof(BITMAPFILEHEADER), 1, inptr) != 1) {
+        fclose(inptr);
+        return 1;
+    }
+    BITMAPINFOHEADER bi;
+    if (fread(&bi, sizeof(BITMAPINFOHEADER), 1, inptr) != 1) {
+        fclose(inptr);
+        return 1;
+    }
+    if (bf.bfType != 0x4d42 || bf.bfOffBits != 54 || bi.biSize != 40 ||  bi.biBitCount != 24 || bi.biCompression != 0) {
+        fclose(inptr);
+        return 1;
+    }
+    img->height = abs(bi.biHeight);
+    img->width = bi.biWidth;
+    img->format = IMAGE_FORMAT_BMP;
+
+    img->pixels = (RGBTRIPLE **)malloc(img->height * sizeof(RGBTRIPLE *));
+    if (img->pixels == NULL) {
+        fclose(inptr);
+        return 1;
+    }
+    RGBTRIPLE *pixel_data = (RGBTRIPLE *)calloc(img->height * img->width, sizeof(RGBTRIPLE));
+    if (pixel_data == NULL) {
+        free(img->pixels);
+        fclose(inptr);
+        return 1;
+    }
+    for (int i = 0; i < img->height; i++) {
+        img->pixels[i] = pixel_data + i * img->width;
+    }
+    int padding = (4 - (img->width * sizeof(RGBTRIPLE)) % 4) % 4;
+
+    // Read pixels
+    for (int i = 0; i < img->height; i++) {
+        if (fread(img->pixels[i], sizeof(RGBTRIPLE), img->width, inptr) != (size_t)img->width) {
+            free_image(img);
+            fclose(inptr);
+            return 1;
+        }
+        fseek(inptr, padding, SEEK_CUR);
+    }
+
+    fclose(inptr);
+    return 0;
+}
+
+// Write BMP file
+int write_bmp(const char *filename, ImageData *img) {
+    FILE *outptr = fopen(filename, "wb");
+    if (outptr == NULL) {
+        return 1;
+    }
+    int padding = (4 - (img->width * sizeof(RGBTRIPLE)) % 4) % 4;
+    int row_size = img->width * sizeof(RGBTRIPLE) + padding;
+    int image_size = row_size * img->height;
+
+    BITMAPFILEHEADER bf;
+    bf.bfType = 0x4d42; 
+    bf.bfSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + image_size;
+    bf.bfReserved1 = 0;
+    bf.bfReserved2 = 0;
+    bf.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
+
+    BITMAPINFOHEADER bi;
+    bi.biSize = sizeof(BITMAPINFOHEADER);
+    bi.biWidth = img->width;
+    bi.biHeight = img->height;
+    bi.biPlanes = 1;
+    bi.biBitCount = 24;
+    bi.biCompression = 0;
+    bi.biSizeImage = image_size;
+    bi.biXPelsPerMeter = 0;
+    bi.biYPelsPerMeter = 0;
+    bi.biClrUsed = 0;
+    bi.biClrImportant = 0;
+
+    if (fwrite(&bf, sizeof(BITMAPFILEHEADER), 1, outptr) != 1 || fwrite(&bi, sizeof(BITMAPINFOHEADER), 1, outptr) != 1) {
+        fclose(outptr);
+        return 1;
+    }
+
+    for (int i = 0; i < img->height; i++) {
+        if (fwrite(img->pixels[i], sizeof(RGBTRIPLE), img->width, outptr) != (size_t)img->width) {
+            fclose(outptr);
+            return 1;
+        }
+        for (int k = 0; k < padding; k++) {
+            fputc(0x00, outptr);
+        }
+    }
+    fclose(outptr);
+    return 0;
+}
+

ex2.png

@@ -3,99 +3,84 @@
 #include <stdlib.h>
 
 #include "helpers.h"
+#include "image_io.h"
 
 int main(int argc, char *argv[])
 {
     // Define allowable filters
     char *filters = "bgrsivtdGoB:";
 
-    
-    char filterArr[argc-3];
+    // Allocate filter array
+    char *filterArr = (char *)malloc((argc - 2) * sizeof(char));
+    if (!filterArr) {
+        printf("Memory allocation error.\n");
+        return 1;
+    }
     int filterCount = 0;
+    int brightness_value = 0;
 
     // gets all filter flags and checks validity
     int opt;
     while ((opt = getopt(argc, argv, filters)) != -1) {
         if (opt == '?') {
             printf("Invalid filter option\n");
+            free(filterArr);
             return 1;
         }
-        filterArr[filterCount++] = opt;
+        if (opt == 'B') {
+            if (optarg) {
+                brightness_value = atoi(optarg);
+            } else {
+                printf("Brightness filter requires a value. Usage: -B <value>\n");
+                free(filterArr);
+                return 1;
+            }
+            filterArr[filterCount++] = opt;
+        } else {
+            filterArr[filterCount++] = opt;
+        }
     }
 
 
     // Ensure proper usage
     if (argc < optind + 2)
     {
         printf("Usage: ./filter [flag] infile outfile\n");
+        printf("Filters: -g (grayscale), -s (sepia), -r (reflect), -b (blur), -i (invert), -v (vignette), -G (glow), -t (threshold), -d (edge detection), -o (oil paint), -B <value> (brightness)\n");
+        free(filterArr);
         return 3;
     }
 
     // Remember filenames
     char *infile = argv[optind];
     char *outfile = argv[optind + 1];
 
-    // Open input file
-    FILE *inptr = fopen(infile, "rb");
-    if (inptr == NULL)
-    {
-        printf("Could not open %s.\n", infile);
+    // Read image using new I/O system
+    ImageData img;
+    img.pixels = NULL;
+    img.width = 0;
+    img.height = 0;
+    img.format = IMAGE_FORMAT_UNKNOWN;
+    
+    if (read_image(infile, &img) != 0) {
+        printf("Could not read %s. Unsupported file format or file not found.\n", infile);
+        printf("Supported formats: BMP, PNG, JPEG\n");
         return 4;
     }
 
-    // Open output file
-    FILE *outptr = fopen(outfile, "wb");
-    if (outptr == NULL)
-    {
-        fclose(inptr);
-        printf("Could not create %s.\n", outfile);
-        return 5;
-    }
-
-    // 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);
-        printf("Unsupported file format.\n");
-        return 6;
-    }
-
-    // Get image's dimensions
-    int height = abs(bi.biHeight);
-    int width = bi.biWidth;
-
-    // Allocate memory for image
-    RGBTRIPLE(*image)[width] = calloc(height, width * sizeof(RGBTRIPLE));
-    if (image == NULL)
-    {
-        printf("Not enough memory to store image.\n");
-        fclose(outptr);
-        fclose(inptr);
-        return 7;
+    // Validate image was read correctly
+    if (img.pixels == NULL || img.width <= 0 || img.height <= 0 || img.pixels[0] == NULL) {
+        printf("Error: Invalid image data after reading.\n");
+        free_image(&img);
+        return 4;
     }
 
-    // Determine padding for scanlines
-    int padding = (4 - (width * sizeof(RGBTRIPLE)) % 4) % 4;
-
-    // Iterate over infile's scanlines
-    for (int i = 0; i < height; i++)
-    {
-        // Read row into pixel array
-        fread(image[i], sizeof(RGBTRIPLE), width, inptr);
+    int height = img.height;
+    int width = img.width;
+    
+    // Cast pixels to match filter function
 
-        // Skip over padding
-        fseek(inptr, padding, SEEK_CUR);
-    }
+    RGBTRIPLE(*image)[width] = (RGBTRIPLE(*)[width])img.pixels[0];
 
     // Filter image
     for(int i=0; i<filterCount; i++){
@@ -152,37 +137,29 @@ int main(int argc, char *argv[])
 
         default:
             printf("Unknown filter: %c\n", filterArr[i]);
-            free(image);
-            fclose(inptr);
-            fclose(outptr);
+            free_image(&img);
+            free(filterArr);
             return 7;
 
     }
     }
-    // Write outfile's BITMAPFILEHEADER
-    fwrite(&bf, sizeof(BITMAPFILEHEADER), 1, outptr);
-
-    // Write outfile's BITMAPINFOHEADER
-    fwrite(&bi, sizeof(BITMAPINFOHEADER), 1, outptr);
-
-    // Write new pixels to outfile
-    for (int i = 0; i < height; i++)
-    {
-        // Write row to outfile
-        fwrite(image[i], sizeof(RGBTRIPLE), width, outptr);
-
-        // Write padding at end of row
-        for (int k = 0; k < padding; k++)
-        {
-            fputc(0x00, outptr);
-        }
+    
+    // Free filter array
+    free(filterArr);
+    
+    // Write image using I/O system
+    ImageFormat output_format = get_format_from_extension(outfile);
+    if (output_format == IMAGE_FORMAT_UNKNOWN) {
+        output_format = img.format;  
+    }
+    
+    if (write_image(outfile, &img, output_format) != 0) {
+        printf("Could not write %s.\n", outfile);
+        free_image(&img);
+        return 5;
     }
 
     // Free memory for image
-    free(image);
-
-    // Close files
-    fclose(inptr);
-    fclose(outptr);
+    free_image(&img);
     return 0;
 }