Mikhail Kadilov P3231

solution/include/bmp.h

+#pragma once
+
+#include "image.h"
+#include <stdint.h>
+#include <stdio.h>
+
+#pragma pack(push, 1)
+struct bmp_header 
+{
+  uint16_t bfType;
+  uint32_t  bfileSize;
+  uint32_t bfReserved;
+  uint32_t bOffBits;
+  uint32_t biSize;
+  uint32_t biWidth;
+  uint32_t  biHeight;
+  uint16_t  biPlanes;
+  uint16_t biBitCount;
+  uint32_t biCompression;
+  uint32_t biSizeImage;
+  uint32_t biXPelsPerMeter;
+  uint32_t biYPelsPerMeter;
+  uint32_t biClrUsed;
+  uint32_t  biClrImportant;
+};
+#pragma pack(pop)
+
+
+/*  deserializer   */
+enum read_status  {
+  READ_OK = 0,
+  READ_INVALID_SIGNATURE,
+  READ_INVALID_BITS,
+  READ_INVALID_HEADER
+  };
+
+/*  serializer   */
+enum  write_status  {
+  WRITE_OK = 0,
+  WRITE_ERROR
+};
+
+enum write_status to_bmp( FILE* out, struct image const* img );
+enum read_status from_bmp(FILE* in, struct image* img);

solution/include/image.h

+#pragma once
+
+#include <stdint.h>
+
+#pragma pack(push, 1)
+struct pixel {
+  uint8_t r;
+  uint8_t g;
+  uint8_t b;
+};
+#pragma pack(pop)
+
+struct image {
+  uint64_t width, height;
+  struct pixel* data;
+};
+
+struct image create_image(const uint64_t width, const uint64_t height);
+
+void delete_image(struct image* current_image);

solution/include/rotate.h

+#pragma once
+
+#include "image.h"
+
+struct image rotate_image(struct image const source, int angle);

solution/include/util.h

+#pragma once
+
+#include "bmp.h"
+#include "image.h"
+#include <stdint.h>
+#include <stdio.h>
+
+int check_angle(int angle);
+
+FILE* open_file(const char* filename, const char* mode);
+
+void close_file(FILE* file);
+
+struct image read_image_from_file(const char* filename);
+
+enum write_status write_image_to_file(const char* filename, struct image* img);
+
+void set_padding(uint8_t* start, size_t count);

solution/src/bmp.c

+#include "../include/util.h"
+#include "../include/bmp.h"
+#include <inttypes.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define PIXEL_SIZE sizeof(struct pixel)
+
+static const uint16_t BMP_TYPE = 0x4D42; // 'BM' (little endian)
+
+static void copy_pixels(struct pixel* destination, const struct pixel* source, size_t count) {
+    for (size_t i = 0; i < count; ++i) {
+        destination[i] = source[i];
+    }
+}
+
+enum read_status from_bmp(FILE* in, struct image* img) {
+    struct bmp_header header = { 0 };
+
+    if (fread(&header, sizeof(struct bmp_header), 1, in) != 1) {
+        return READ_INVALID_HEADER;
+    }
+
+    if (header.bfType != BMP_TYPE) {
+        return READ_INVALID_SIGNATURE;
+    }
+
+    if (header.biBitCount != 24 || header.biCompression != 0) {
+        return READ_INVALID_BITS;
+    }
+
+    *img = create_image(header.biWidth, header.biHeight);
+    size_t padding = (4 - (header.biWidth * PIXEL_SIZE) % 4) % 4;
+    
+    void* row = malloc(header.biWidth * PIXEL_SIZE + padding);
+    if (!row) {
+        delete_image(img);  
+        return READ_INVALID_HEADER;
+    }
+
+    for (size_t i = 0; i < header.biHeight; i++) {
+        if (fread(row, header.biWidth * PIXEL_SIZE + padding, 1, in) != 1) {
+            free(row);
+            delete_image(img);
+            return READ_INVALID_BITS;
+        }
+        copy_pixels(img->data + i * header.biWidth, row, header.biWidth);
+    }
+
+    free(row);
+    
+    return READ_OK;
+}
+
+enum write_status to_bmp(FILE* out, const struct image* img) {
+    size_t padding = (4 - ((uint32_t)img->width * PIXEL_SIZE) % 4) % 4;
+
+    size_t rowSize = img->width * PIXEL_SIZE + padding;
+    uint64_t imageSize = rowSize * img->height;
+    uint64_t fileSize = sizeof(struct bmp_header) + imageSize;
+
+    if (fileSize > UINT32_MAX || imageSize > UINT32_MAX) {
+        fprintf(stderr, "ERROR: Image size more then UINT32_MAX.\n");
+        return WRITE_ERROR;
+    }
+
+    struct bmp_header header = {
+        .bfType = BMP_TYPE,                                 // 'BM' for Bitmap
+        .bfileSize = (uint32_t)fileSize,                    // File size (bytes)
+        .bfReserved = 0,                                    // Reserved, must be set to 0
+        .bOffBits = sizeof(struct bmp_header),              // Offset to start of image data
+        .biSize = 40,                                       // BITMAPINFOHEADER size (bytes)
+        .biWidth = (uint32_t)img->width,          // Image width in pixels
+        .biHeight = (uint32_t)img->height,        // Image height in pixels
+        .biPlanes = 1,                                      // Number of color planes
+        .biBitCount = 24,                                   // Bits per pixel
+        .biCompression = 0,                                 // Compression type
+        .biSizeImage = (uint32_t)imageSize,                 // Image size (bytes)
+        .biXPelsPerMeter = 0,                               // Horizontal resolution
+        .biYPelsPerMeter = 0,                               // Vertical resolution
+        .biClrUsed = 0,                                     // Colors in the color palette
+        .biClrImportant = 0                                 // Important colors
+    };
+
+
+    if (fwrite(&header, sizeof(header), 1, out) != 1) {
+        return WRITE_ERROR;
+    }
+
+    void* row = malloc(rowSize);
+    if (!row) {
+        return WRITE_ERROR;
+    }
+
+    for (size_t i = 0; i < img->height; i++) {
+        copy_pixels(row, img->data + i * img->width, img->width);
+        set_padding((uint8_t*)row + img->width * PIXEL_SIZE, padding);
+
+        if (fwrite(row, rowSize, 1, out) != 1) {
+            free(row);
+            return WRITE_ERROR;
+        }
+    }
+
+    free(row);
+
+    return WRITE_OK;
+}

[Elizabeth]

Ревью принято

[Kirill Krakov]

@RayRelax изменения приняты

[Mikhail Kadilov]

@RayRelax, все исправлено, прошу проверить

[Andrey Andropov (Busy)]

Принято