lib

#ifndef LIB

#define LIB
#include <stdlib.h>
#include <string.h>

#define max(a,b) (a < b ? b : a)
typedef struct picture
{
    short** A;
    short** B;
    short** C;
    int     rows;
    int     cols;
    int     rowsA;
    int     colsA;
    int     rowsB;
    int     colsB;
    int     rowsC;
    int     colsC;
} picture;

void pictureInit(picture* matrix, int n, int m);
void picturePurge(picture* matrix, int n);

void rotate(picture* matrix, char code, int k);
short** rotateArrayByNinety(short** a, int n, int m);

void flip(picture* matrix, char code, char dir);
void flipArray(short** a, int n, int m, char dir);

void upscale(picture* matrix, char code, int n, int m);
short** upscaleArray(short** a, int rows, int cols, int n, int m);

void downscale(picture* matrix, char code, int n, int m);
short** downscaleArray(short** a, int rows, int cols, int n, int m);

void pictureInit(picture* matrix, int n, int m)
{
    matrix->rows = n;
    matrix->cols = m;
    matrix->rowsA = n;
    matrix->colsA = m;
    matrix->rowsB = n;
    matrix->colsB = m;
    matrix->rowsC = n;
    matrix->colsC = m;
    matrix->A = (short**)(calloc(n, sizeof(short*)));
    matrix->B = (short**)(calloc(n, sizeof(short*)));
    matrix->C = (short**)(calloc(n, sizeof(short*)));
    for (int i = 0; i < n; ++i)
    {
        matrix->A[i] = (short*)(calloc(m, sizeof(short)));
        matrix->B[i] = (short*)(calloc(m, sizeof(short)));
        matrix->C[i] = (short*)(calloc(m, sizeof(short)));
    }
    return;
}

void picturePurge(picture* matrix, int n)
{
    for (int i = 0; i < n; ++i)
    {
        if (matrix->rowsA > i) free(matrix->A[i]);
        if (matrix->rowsB > i) free(matrix->B[i]);
        if (matrix->rowsC > i) free(matrix->C[i]);
    }

    free(matrix->A);
    free(matrix->B);
    free(matrix->C);
    return;
}

short** rotateArrayByNinety(short** a, int n, int m)
{
    short** b = (short**)(calloc(m, sizeof(short*)));
    for (int i = 0; i < m; ++i)
    {
        b[i] = (short*)(calloc(n, sizeof(short)));
    }
    for (int j = 0; j < n; ++j)
    {
        for (int i = 0; i < m; ++i)
        {
            b[i][j] = a[j][i];
        }
    }
    for (int j = 0; j < n; ++j)
    {
        for (int i = 0; i < m / 2; ++i)
        {
            short tmp = b[i][j];
            b[i][j] = b[m - 1 - i][j];
            b[m - 1 - i][j] = tmp;
        }
    }
    for (int i = 0; i < n; ++i)
    {
        free(a[i]);
    }
    free(a);
    a = (short**)(calloc(m, sizeof(short*)));
    for (int i = 0; i < m; ++i)
    {
        a[i] = (short*)(calloc(n, sizeof(short)));
    }
    for (int i = 0; i < m; ++i)
    {
        for (int j = 0; j < n; ++j)
        {
            a[i][j] = b[i][j];
        }
    }
    return a;
}
void rotate(picture* matrix, char code, int k)
{
    if (code == 'A')
    {
        for (int j = 0; j < k; ++j)
        {
            matrix->A = rotateArrayByNinety(matrix->A, matrix->rowsA, matrix->colsA);
            short tmp = matrix->rowsA;
            matrix->rowsA = matrix->colsA;
            matrix->colsA = tmp;
        }
    }
    else if (code == 'B')
    {
        for (int j = 0; j < k; ++j)
        {
            matrix->B = rotateArrayByNinety(matrix->B, matrix->rowsB, matrix->colsB);
            short tmp = matrix->rowsB;
            matrix->rowsB = matrix->colsB;
            matrix->colsB = tmp;
        }
    }
    else if (code == 'C')
    {
        for (int j = 0; j < k; ++j)
        {
            matrix->C = rotateArrayByNinety(matrix->C, matrix->rowsC, matrix->colsC);
            short tmp = matrix->rowsC;
            matrix->rowsC = matrix->colsC;
            matrix->colsC = tmp;
        }
    }
    return;
}

void flipArray(short** a, int n, int m, char dir)
{
    if (dir == 'H')
    {
        for (int j = 0; j < m; ++j)
        {
            for (int i = 0; i < n / 2; ++i)
            {
                short tmp = a[i][j];
                a[i][j] = a[n - 1 - i][j];
                a[n - 1 - i][j] = tmp;
            }
        }
    }
    else if (dir == 'V')
    {
        for (int i = 0; i < n; ++i)
        {
            for (int j = 0; j < m / 2; ++j)
            {
                short tmp = a[i][j];
                a[i][j] = a[i][m - 1 - j];
                a[i][m - 1 - j] = tmp;
            }
        }
    }
}
void flip(picture* matrix, char code, char dir)
{
    if (code == 'A')
    {
        flipArray(matrix->A, matrix->rowsA, matrix->colsA, dir);
    }
    else if (code == 'B')
    {
        flipArray(matrix->B, matrix->rowsB, matrix->colsB, dir);
    }
    else if (code == 'C')
    {
        flipArray(matrix->C, matrix->rowsC, matrix->colsC, dir);
    }
    return;
}

short** upscaleArray(short** a, int rows, int cols, int n, int m)
{
    short** b = (short**)(calloc(rows * n, sizeof(short*)));
    for (int i = 0; i < n * rows; ++i)
    {
        b[i] = (short*)(calloc(cols * m, sizeof(short)));
    }
    for (int i = 0; i < n * rows; i++)
    {
        for (int j = 0; j < cols * m; j++)
        {
            b[i][j] = a[i / n][j / m];
        }
    }
    for (int i = 0; i < rows; ++i)
    {
        free(a[i]);
    }
    free(a);
    a = b;
    return a;
}
void upscale(picture* matrix, char code, int n, int m)
{
    if (code == 'A')
    {
        matrix->A = upscaleArray(matrix->A, matrix->rowsA, matrix->colsA, n, m);
        matrix->rowsA *= n;
        matrix->colsA *= m;
    }
    else if (code == 'B')
    {
        matrix->B = upscaleArray(matrix->B, matrix->rowsB, matrix->colsB, n, m);
        matrix->rowsB *= n;
        matrix->colsB *= m;
    }
    else if (code == 'C')
    {
        matrix->C = upscaleArray(matrix->C, matrix->rowsC, matrix->colsC, n, m);
        matrix->rowsC *= n;
        matrix->colsC *= m;
    }

    return;
}

short** downscaleArray(short** a, int rows, int cols, int n, int m)
{
    short** b = (short**)(calloc(rows / n, sizeof(short*)));
    for (int i = 0; i < rows / n; ++i)
    {
        b[i] = (short*)(calloc(cols / m, sizeof(short)));
    }
    for (int i = 0; i < rows; i += n)
    {
        for (int j = 0; j < cols; j += m)
        {
            b[i / n][j / m] = a[i][j];
        }
    }
    for (int i = 0; i < rows; ++i)
    {
        free(a[i]);
    }
    free(a);
    a = b;
    return a;
}
void downscale(picture* matrix, char code, int n, int m)
{
    if (code == 'A')
    {
        matrix->A = downscaleArray(matrix->A, matrix->rowsA, matrix->colsA, n, m);
        matrix->rowsA /= n;
        matrix->colsA /= m;
    }
    else if (code == 'B')
    {
        matrix->B = downscaleArray(matrix->B, matrix->rowsB, matrix->colsB, n, m);
        matrix->rowsB /= n;
        matrix->colsB /= m;
    }
    else if (code == 'C')
    {
        matrix->C = downscaleArray(matrix->C, matrix->rowsC, matrix->colsC, n, m);
        matrix->rowsC /= n;
        matrix->colsC /= m;
    }
    return;
}
#endif