YUV2BMP

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include "bmp.h"
typedef unsigned char uchar;


typedef struct {
    int y, u, v;
} YUV;

int ch_round(int v) {
    if (v < 0) return 0;
    if (v > 255) return 255;
    return v;
}


BGR yuv2rgb(YUV yuv) {
    BGR rgb;
    rgb.r = ch_round(yuv.y + 1.402 * (yuv.v - 128));
    rgb.g = ch_round(yuv.y - 0.344136 * (yuv.u - 128) - 0.714136 * (yuv.v - 128));
    rgb.b = ch_round(yuv.y + 1.772 * (yuv.u - 128));
    return rgb;
}


uchar *read_bytes(FILE *in, int count) {
    uchar *input = malloc(count * sizeof(uchar));
    if (input == NULL) {
        printf("Memory allocation failed\n");
        return NULL;
    }
    size_t read_count = fread(input, sizeof(uchar), count, in);
    if (read_count != count) {
        printf("Read %zu elements, expected %d\n", read_count, count);
        return NULL;
    }
    return input;
}

uchar **read_yuv_image(FILE *in, int count, int stride) {
    uchar *luminance = read_bytes(in, count);
    uchar *blue = read_bytes(in, count / (stride * stride));
    uchar *red = read_bytes(in, count / (stride * stride));

    if (luminance && blue && red) {
        printf("Data read successfully\n");
    } else {
        free(luminance);
        free(blue);
        free(red);
        return NULL;
    }
    uchar **data = malloc(3 * sizeof(uchar *));
    data[0] = luminance;
    data[1] = blue;
    data[2] = red;
    return data;
}

// covert
BGR **transform(uchar *luminance, uchar *blue, uchar *red, int height, int width, int stride,
                int gray_scale, int up_size, int down_size) {
    int new_height = height * up_size / down_size;
    int new_width = width * up_size / down_size;
    printf("new_height = %d, new_width = %d\n", new_height, new_width);

    BGR **data = malloc(height * sizeof(BGR *));
    for (int i = 0; i < height; i++) {
        data[i] = (BGR *) malloc(width * sizeof(BGR));
    }

    if (!data) {
        fprintf(stderr, "Memory allocation failed!\n");
        exit(1);
    }


    for (int i = 0; i < height; i++) {
        for (int j = 0; j < width; j++) {
            if (gray_scale) {
                BGR rgb = {luminance[i * width + j], luminance[i * width + j], luminance[i * width + j]};
                data[i][j] = rgb;
            } else {
                int group_id = (i / stride) * (width / stride) + j / stride;
                YUV yuv = {luminance[i * width + j], blue[group_id], red[group_id]};
                BGR rgb = yuv2rgb(yuv);
                data[i][j] = rgb;
            }
        }
    }
    printf("from yuv to rgb\n");
    // rescale
    BGR **scaled_data = malloc(new_height * sizeof(BGR *));
    for (int i = 0; i < new_height; i++) {
        scaled_data[i] = (BGR *) malloc(new_width * sizeof(BGR));
    }

    if (!scaled_data) {
        free(data);
        fprintf(stderr, "Memory allocation failed!\n");
        exit(1);
    }


    for (int i = 0; i < new_height; i++) {
        for (int j = 0; j < new_width; j++) {
            int old_i = i * down_size / up_size;
            int old_j = j * down_size / up_size;
            if (old_i >= height) {
                old_i = height - 1;
            }
            if (old_j >= width) {
                old_j = width - 1;
            }
            scaled_data[i][j] = data[old_i][old_j];
        }
    }
    printf("scaled data\n");
    return scaled_data;
}


void YUV2BMP(FILE *in, FILE *out, int height, int width, int stride, int gray_scale, int up_size, int down_size) {
    printf("up_size = %d, down_size = %d\n", up_size, down_size);
    int count = height * width;
    uchar **data = read_yuv_image(in, count, stride);
    if (data == NULL) {
        printf("Data read failed\n");
        return;
    }

    uchar *luminance = data[0];
    uchar *blue = data[1];
    uchar *red = data[2];

    int new_height = height * up_size / down_size;
    int new_width = width * up_size / down_size;
    BMP_Header *bmp_header = malloc(sizeof(BMP_Header));
    fill_bmp_header(bmp_header, new_height, new_width, 24);
    fwrite(bmp_header, sizeof(BMP_Header), 1, out);

    BGR **scaled_data = transform(luminance, blue, red, height, width, stride, gray_scale, up_size, down_size);
    printf("data transformed\n");
    for (int i = 0; i < new_height; i++) {
        fwrite(scaled_data[i], sizeof(BGR), new_width, out); // error
        int row_size = (3 * new_width + 3) & ~3;
        fwrite("\0", 1, row_size - 3 * new_width, out); // error
    }

    free(data);
    free(scaled_data);
}


char *is_argkey(char *arg) {
    if (strlen(arg) <= 2) {
        return NULL;
    }
    if (arg[0] == '-' && arg[1] == '-') {
        return arg + 2;
    }
    return NULL;
}

int main(int argc, char *argv[]) {
    // printf("amount of arguments %d \n", argc);
    char *input_file_name;
    char *output_file_name;
    int width;
    int height;
    int is_gray_scale = 0; // 1 - if grayscale, 0 - if not
    int up_size = 1, down_size = 1;
    for (int i = 1; i < argc; i++) {
        char *key = is_argkey(argv[i]);
        if (key == NULL) {
            printf("No valid argument for command line %s \n", argv[i]);
            return 1;
        }
        if (strcmp(key, "input") == 0) {
            input_file_name = argv[++i];
        } else if (strcmp(key, "output") == 0) { // ++i есть?
            output_file_name = argv[++i];
        } else if (strcmp(key, "width") == 0) {
            width = atoi(argv[++i]);
        } else if (strcmp(key, "height") == 0) {
            height = atoi(argv[++i]);
        } else if (strcmp(key, "to–gray–scale") == 0) {
            is_gray_scale = 1;
        } else if (strcmp(key, "up-size") == 0) {
            up_size = atoi(argv[++i]);
        } else if (strcmp(key, "down-size") == 0) {
            down_size = atoi(argv[++i]);
        } else {
            printf("key is not find %s \n", key);
            return 1;
        }
    }

    if (width <= 0 || height <= 0 || up_size <= 0 || down_size <= 0) {
        perror("Can't get minus arguments.\n");
        return 1;
    }

    FILE *in = fopen(input_file_name, "rb");
    if (!in) {
        perror("Error opening input file");
        return 1;
    }

    FILE *out = fopen(output_file_name, "wb");
    if (!out) {
        perror("Error opening output file");
        fclose(in);
        return 1;
    }


    YUV2BMP(in, out, height, width, 2, is_gray_scale, up_size, down_size);

    fclose(in);
    fclose(out);
}