Skip to content

GitLab

Closed
Created by Nikita Shkurenko@NkSk
Report abuse

Шкуренко Никита R3237 (Image Rotation)

All threads resolved
Compare
and
6 files
+ 177
- 145
Show latest version
solu‎tion‎
inc‎lude‎
bm‎p.h‎ +10 -10
ima‎ge.h‎ +8 -4
s‎rc‎
bm‎p.c‎ +88 -96
ima‎ge.c‎ +35 -11
mai‎n.c‎ +35 -23
clang-tidy‎-checks.txt‎ +1 -1
solution/include/bmp.h
+ 10
- 10
#ifndef IMAGE_ROTATION_2_BMP_H
#define IMAGE_ROTATION_2_BMP_H
#ifndef BMP_H
#define BMP_H
#include "image.h"
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include "../include/image.h"
#pragma pack(push, 1)
Show 20 lines Show all unchanged lines Show 20 lines
enum write_status to_bmp( FILE* out, struct image const* img );
static uint32_t width_with_padding(struct image const* image);
static size_t size_of_padding(uint32_t width);
static bool read_header(FILE* file, struct bmp_header* header );
static enum read_status validate_header(struct bmp_header* header);
static struct bmp_header* create_header(struct image const* img);
static void free_image(struct image* image);
#endif //IMAGE_ROTATION_2_BMP_H
bool read_header(FILE* file, struct bmp_header* header );
enum read_status validate_header(struct bmp_header* header);
struct bmp_header* create_header(struct image const* img);
uint8_t size_of_padding_v2(uint32_t width);
#endif //BMP_H
solution/include/image.h
+ 8
- 4
#ifndef IMAGE_ROTATION_2_IMAGE_H
#define IMAGE_ROTATION_2_IMAGE_H
#ifndef IMAGE_H
#define IMAGE_H
#include <inttypes.h>
#include <stdint.h>
struct pixel { uint8_t b, g, r; };
Show 20 lines Show all unchanged lines Show 20 lines
struct image* rotate( struct image* source );
static struct image* create_image(struct image* source);
struct image* create_image(struct image* source);
void free_image(struct image* image);
#endif //IMAGE_ROTATION_2_IMAGE_H
#endif //IMAGE_H
solution/src/bmp.c
+ 88
- 96
Show all unchanged lines Show 20 lines
#include "string.h"
#include <stdio.h>
#define BF_TYPE 0x4D42
#define BF_TYPE 19778
#define BIT_DEPTH 24
#define NO_COMPRESSION 0
/*
* Main reading from bmp function.
* Returns result of reading in enum.
*/
enum read_status from_bmp( FILE* in, struct image* img ) {
struct bmp_header *bmp_header = (struct bmp_header *) malloc(sizeof(struct bmp_header));
if(bmp_header == NULL){
fclose(in);
return READ_MEMORY_ERROR;
}
if (!(read_header(in, bmp_header))) {
fclose(in);
return READ_ERROR;
Show 20 lines Show all unchanged lines Show 20 lines
fclose(in);
return READ_INVALID_HEADER;
}
if (fseek(in, (long) bmp_header->bOffBits, SEEK_SET) != 0) {
fclose(in);
return READ_ERROR;
}
// assigning values from the header and allocating memory for image data in bytes.
img->width = bmp_header->biWidth;
img->height = bmp_header->biHeight;
img->data = (struct pixel *) malloc(3 * bmp_header->biWidth * bmp_header->biHeight);
//creating padded width to use in reading
uint8_t padding = size_of_padding_v2(img->width);
uint32_t padded_width = sizeof(struct pixel) * img->width + padding;
//creating offset for header (and rows that were handled)
// and going throw the bytes after it in amount of default width (reading every 3 bytes = pixel).
// *not swapping pixels (like BGR -> RGB) because also we'll need to do this operation later.
// in that case we won't need to swap pixels later.
for(uint32_t i = 0; i < bmp_header->biHeight; i++){
if(fseek(in, (int32_t) (sizeof(struct bmp_header) + padded_width * i), SEEK_SET) != 0){
free(bmp_header);
fclose(in);
return READ_ERROR;
}
size_t padding = 4 - ((3*bmp_header->biWidth) % 4);
if(padding == 4)
padding = 0;
uint8_t *data = malloc((3*bmp_header->biWidth + padding) * bmp_header->biHeight);
fread(data, 1, (3*bmp_header->biWidth + padding) * bmp_header->biHeight, in);
size_t pad_ptr = 0;
size_t pixel_counter = 0;
for(uint32_t i = 0; i < (3*bmp_header->biWidth + padding) * bmp_header->biHeight; i+=3){
if(pad_ptr == bmp_header->biWidth * 3 && padding != 0){
pad_ptr = 0;
i+=padding;
img->data[pixel_counter] = (struct pixel){
.r = data[i+2],
.g = data[i+1],
.b = data[i]
};
pixel_counter++;
pad_ptr += 3;
continue;
if(fread(img->data + i * img->width, 3, img->width, in) != img->width){
free(bmp_header);
fclose(in);
return READ_ERROR;
}
img->data[pixel_counter] = (struct pixel){
.r = data[i+2],
.g = data[i+1],
.b = data[i]
};
pad_ptr += 3;
pixel_counter++;
}
//freeing the allocated memory
free(bmp_header);
free(data);
fclose(in);
return READ_OK;
}
static bool read_header(FILE *file, struct bmp_header *header) {
return fread(header, sizeof(struct bmp_header), 1, file);
/*
* Reader for header of image
* Returns bool result of work
*/
bool read_header(FILE *file, struct bmp_header *header) {
if(fread(header, sizeof(struct bmp_header), 1, file) == 1)
return true;
else
return false;
}
static enum read_status validate_header(struct bmp_header* header){
if (header->bfType != 0x4D42)
/*
* Header validator function. Checks the most necessary parts of the header.
* Return enum result of work.
*/
enum read_status validate_header(struct bmp_header* header){
if (header->bfType != BF_TYPE)
{
return READ_INVALID_SIGNATURE ;
}
Show 20 lines Show all unchanged lines Show 20 lines
return READ_OK;
}
static struct bmp_header* create_header(struct image const* img){
/*
* Header creator function. Creates a header from template using image params.
* Returns new header.
*/
struct bmp_header* create_header(struct image const* img){
struct bmp_header* header = (struct bmp_header*) malloc(sizeof (struct bmp_header));
header->bfType = 0x4D42;
header->bfType = BF_TYPE;
header->biBitCount = BIT_DEPTH;
header->bOffBits = (uint32_t) sizeof (struct bmp_header);
header->biCompression = NO_COMPRESSION;
Show 20 lines Show all unchanged lines Show 20 lines
header->biHeight = img->height;
header->biSize = 40;
header->biPlanes = 1;
header->biSizeImage = width_with_padding(img) * img->height;
header->bfileSize = header->bOffBits + header->biSizeImage;
header->biSizeImage = 3*img->width * img->height;
header->bfileSize = sizeof(struct bmp_header) + (3*img->width + size_of_padding_v2(img->width))*img->height;
header->bfReserved = 0;
header->biXPelsPerMeter = 0;
header->biYPelsPerMeter = 0;
header->biXPelsPerMeter = 2834;
header->biYPelsPerMeter = 2834;
header->biClrUsed = 0;
header->biClrImportant = 0;
return header;
}
static uint32_t width_with_padding(struct image const* image){
uint32_t width = image->width * 3;
if(width % 4 == 0)
return width;
else
return width + (4 - width % 4);
}
static size_t size_of_padding(uint32_t width){
if(width % 4 == 0){
return 0;
}
else
return 4 - width % 4;
}
/*
* Main writing to bmp file function.
* Return result of work in enum
*/
enum write_status to_bmp(FILE *out, const struct image *img) {
//creating header from template and setting the padding size
struct bmp_header* header = create_header(img);
size_t padding = 4 - size_of_padding(img->width);
uint8_t padding_size = size_of_padding_v2(img->width);
uint32_t pad_byte = 0;
//writing whole header to the file
fwrite(header, sizeof (struct bmp_header),1, out);
//after the header we write every row into the file (copying pixels from the source and setting padding-bytes as 0)
for(uint32_t i = 0; i < img->height; i++){
if(fwrite(img->data + i * img->width, 3*img->width, 1, out) != 1){
free(header);
fclose(out);
return WRITE_ERROR;
}
uint8_t* data = malloc((img->width*3 + padding)*img->height);
size_t pad_ptr = 0;
size_t pixel_counter = 0;
for(uint32_t i = 0; i < (3*img->width + padding) * img->height; i+=3){
if(pad_ptr == img->width * 3 && padding != 0){
pad_ptr = 0;
i+=padding;
data[i] = img->data[pixel_counter].b;
data[i+1] = img->data[pixel_counter].g;
data[i+2] = img->data[pixel_counter].r;
pixel_counter++;
pad_ptr += 3;
continue;
if(fwrite(&pad_byte, padding_size, 1, out) != 1){
free(header);
fclose(out);
return WRITE_ERROR;
}
data[i] = img->data[pixel_counter].b;
data[i+1] = img->data[pixel_counter].g;
data[i+2] = img->data[pixel_counter].r;
pad_ptr += 3;
pixel_counter++;
}
fwrite(data, 1, (img->width*3 + padding)*img->height, out);
free(data);
free(header);
fclose(out);
return WRITE_OK;
}
static void free_image(struct image* image){
image->width = 0;
image->height = 0;
free(image->data);
/*
* Simple function to get padding bytes.
* Returns amount of bytes.
*/
uint8_t size_of_padding_v2(uint32_t width){
uint64_t default_row = sizeof(struct pixel) * width;
if(default_row % 4 == 0){
return (uint64_t) 0;
}
else{
return 4 - default_row % 4;
}
}
solution/src/image.c
+ 35
- 11
solution/src/main.c
+ 35
- 23
clang-tidy-checks.txt
+ 1
- 1

Menu

Help