Pliki.cpp

// funkcje związane z zapisywaniem i odczytywaniem danych z plików
#include "SM2024-Funkcje.h"
#include "SM2024-Zmienne.h"
#include "SM2024-Paleta.h"
#include "SM2024-MedianCut.h"
#include "SM2024-Pliki.h"
#include "SM2024-Kompresja.h"
#include <vector>

void zapisywanie_pliku()
{
    cout << "\nKolor:\n[1] - skala szarosci\n[2] - kolor\n\n";
    cout << "Tryb:\n[1] - 15 bitowy (RGB555)\n[2] - 24 bitowy (RGB888)\n[3] - 24 bitowy (YUV888)\n\n";
    cout << "Dithering dla RGB555:\n[0] - inny wybor niz RGB555\n[1] - nie\n[2] - tak\n\n";
    cout << "Algorytm predykcji typu 1:\n[1] - nie\n[2] - tak\n\n";
    cout << "Kompresja bezstratna ByteRun:\n[1] - nie\n[2] - tak\n\n";
    cout << "Podprobkowanie skladowych chrominacji:\n[1] - nie\n[2] - tak\n\n";
    cout << "Kompresja stratna DCT:\n[1] - nie\n[2] - tak\n";
    cout << "\nPodaj opcje: ";

    int kolor, tryb, dithering, predykcja, ByteRun, podprobkowanie, DCT;
    cin >> kolor >> tryb >> dithering >> predykcja >> ByteRun >> DCT;
    zapisz_do_pliku_uniwersalna("obraz.z13", szerokosc / 2, wysokosc / 2, kolor, tryb, dithering, predykcja, podprobkowanie, ByteRun, DCT);
}

void zapisz_do_pliku_uniwersalna(string plik, Uint16 szerokosc_obrazka, Uint16 wysokosc_obrazka, int kolor, int tryb, int dithering, int predykcja, int podprobkowanie, int ByteRun, int DCT)
{
    ofstream wyjscie(plik, ios::binary);

    Uint8* komponent1 = new Uint8[szerokosc_obrazka*wysokosc_obrazka];
    Uint8* komponent2 = new Uint8[szerokosc_obrazka*wysokosc_obrazka];
    Uint8* komponent3 = new Uint8[szerokosc_obrazka*wysokosc_obrazka];

    vector<Uint8> vec1;
    vector<Uint8> vec2;
    vector<Uint8> vec3;

    switch(kolor)
    {
    case 1:
        {
            for(int y = 0; y < wysokosc_obrazka; y++)
            {
                for(int x = 0; x < szerokosc_obrazka; x++)
                {
                    SDL_Color kolor = getPixel(x, y);
                    int szary = 0.299 * kolor.r + 0.587 * kolor.g + 0.114 * kolor.b;
                    setPixel(x, y, szary, szary, szary);
                }
            }
            break;
        }
    case 2:
        {
            // brak
            break;
        }
    default:
        {
            cout << "Kolor: zla opcja\n";
            break;
        }
    }

    switch(tryb)
    {
    case 1:
        {
            //Dopiero na etapie ditheringu zbieramy dane
            break;
        }
    case 2:
        {
            for(int y = 0; y < wysokosc_obrazka; y++)
            {
                for(int x = 0; x < szerokosc_obrazka; x++)
                {
                    SDL_Color pixel = getPixel(x, y);
                    komponent1[y * szerokosc_obrazka + x] = pixel.r;
                    komponent2[y * szerokosc_obrazka + x] = pixel.g;
                    komponent3[y * szerokosc_obrazka + x] = pixel.b;
                }
            }
            break;
        }
    case 3:
        {
            for(int y = 0; y < wysokosc_obrazka; y++)
            {
                for(int x = 0; x < szerokosc_obrazka; x++)
                {
                    SDL_Color pixel = getPixel(x, y);
                    YUV yuv = RGBtoYUV(pixel);
                    komponent1[y * szerokosc_obrazka + x] = yuv.Y;
                    komponent2[y * szerokosc_obrazka + x] = yuv.U;
                    komponent3[y * szerokosc_obrazka + x] = yuv.V;
                }
            }
            break;
        }
    default:
        {
            cout << "Tryb: zla opcja\n";
            break;
        }
    }

    switch(dithering)
    {
    case 0:
        {
            //Inna opcja kolorystyczna
            break;
        }
    case 1:
        {
            //Brak ditheringu dla RGB555
            for(int y = 0; y < wysokosc_obrazka; y++)
            {
                for(int x = 0; x < szerokosc_obrazka; x++)
                {
                    SDL_Color pixel = getRGB555(x, y);
                    komponent1[y * szerokosc_obrazka + x] = pixel.r;
                    komponent2[y * szerokosc_obrazka + x] = pixel.g;
                    komponent3[y * szerokosc_obrazka + x] = pixel.b;
                }
            }
            break;
        }
    case 2:
        {
            //Dithering dla RGB555
            for(int y = 0; y < wysokosc_obrazka; y++)
            {
                for(int x = 0; x < szerokosc_obrazka; x++)
                {
                    SDL_Color pixel = Dithering555(x, y);
                    komponent1[y * szerokosc_obrazka + x] = pixel.r;
                    komponent2[y * szerokosc_obrazka + x] = pixel.g;
                    komponent3[y * szerokosc_obrazka + x] = pixel.b;
                }
            }
            break;
        }
    default:
        {
            cout << "Dithering: zla opcja\n";
            break;
        }
    }

    switch(predykcja)
    {
    case 1:
        {
            // brak
            break;
        }
    case 2:
        {
            for(int y = 0; y < wysokosc_obrazka; y++)
            {
                TheFilterRoznicowy(komponent1+y * szerokosc_obrazka, szerokosc_obrazka);
                TheFilterRoznicowy(komponent2+y * szerokosc_obrazka, szerokosc_obrazka);
                TheFilterRoznicowy(komponent3+y * szerokosc_obrazka, szerokosc_obrazka);

            }
            break;
        }
    default:
        {
             cout << "Predykcja: zla opcja\n";
             break;
        }
    }

    switch(ByteRun)
    {
        case 1:
            {
                vector<Uint8> temp1(komponent1, komponent1 + szerokosc_obrazka * wysokosc_obrazka);
                vector<Uint8> temp2(komponent2, komponent2 + szerokosc_obrazka * wysokosc_obrazka);
                vector<Uint8> temp3(komponent3, komponent3 + szerokosc_obrazka * wysokosc_obrazka);

                vec1 = temp1;
                vec2 = temp2;
                vec3 = temp3;
                break;
            }
        case 2:
            {
                vec1 = byte_run(komponent1, szerokosc_obrazka * wysokosc_obrazka);
                vec2 = byte_run(komponent2, szerokosc_obrazka * wysokosc_obrazka);
                vec3 = byte_run(komponent3, szerokosc_obrazka * wysokosc_obrazka);
                break;
            }
        default:
            {
                cout << "ByteRun: zla opcja\n";
            }
    }

    delete[] komponent1;
    delete[] komponent2;
    delete[] komponent3;

    komponent1 = new Uint8[vec1.size()];
    komponent2 = new Uint8[vec2.size()];
    komponent3 = new Uint8[vec3.size()];

    copy(vec1.begin(), vec1.end(), komponent1);
    copy(vec2.begin(), vec2.end(), komponent2);
    copy(vec3.begin(), vec3.end(), komponent3);

    vector<komponentDCT> komp1;
    vector<komponentDCT> komp2;
    vector<komponentDCT> komp3;

    switch(DCT)
    {
    case 1:
        {
            // brak
            break;
        }
    case 2:
        {
            komp1 = wykonajDCT(komponent1, szerokosc_obrazka, wysokosc_obrazka);
            komp2 = wykonajDCT(komponent2, szerokosc_obrazka, wysokosc_obrazka);
            komp3 = wykonajDCT(komponent3, szerokosc_obrazka, wysokosc_obrazka);
            break;
        }
    default:
        {
            cout << "DCT: zla opcja\n";
        }
    }

    char identyfikator[] = "13";
    wyjscie.write((char*)&identyfikator, sizeof(char) * 2);
    wyjscie.write((char*)&szerokosc_obrazka, sizeof(Uint16));
    wyjscie.write((char*)&wysokosc_obrazka, sizeof(Uint16));
    wyjscie.write((char*)&tryb, sizeof(int));
    wyjscie.write((char*)&predykcja, sizeof(int));
    wyjscie.write((char*)&ByteRun, sizeof(int));
    wyjscie.write((char*)&DCT, sizeof(int));

    if(DCT == 1)
    {
        int sectionSize=vec1.size();
        wyjscie.write((char*)&sectionSize, sizeof(int));
        for(int i = 0; i < vec1.size(); i++)
        {
            wyjscie.write((char*)&vec1[i], sizeof(Uint8));
        }

        sectionSize=vec2.size();
        wyjscie.write((char*)&sectionSize, sizeof(int));
        for(int i = 0; i < vec2.size(); i++)
        {
            wyjscie.write((char*)&vec2[i], sizeof(Uint8));
        }

        sectionSize=vec3.size();
        wyjscie.write((char*)&sectionSize, sizeof(int));
         for(int i = 0; i < vec3.size(); i++)
        {
            wyjscie.write((char*)&vec3[i], sizeof(Uint8));
        }

        wyjscie.close();
    }
    else
    {
        int sectionSize1 = komp1.size();
        wyjscie.write((char*)&sectionSize1, sizeof(int));
        for(int i = 0; i < komp1.size(); i++)
        {
            int sectionSubSize1 = komp1.at(i).vec.size();
            wyjscie.write((char*)&sectionSubSize1, sizeof(int));
            for(int j = 0; j < komp1.at(i).vec.size(); j++)
            {
                wyjscie.write((char*)&komp1.at(i).vec.at(j), sizeof(float));
            }
        }

        int sectionSize2 = komp2.size();
        wyjscie.write((char*)&sectionSize2, sizeof(int));
        for(int i = 0; i < komp2.size(); i++)
        {
            int sectionSubSize2 = komp2.at(i).vec.size();
            wyjscie.write((char*)&sectionSubSize2, sizeof(int));
            for(int j = 0; j < komp2.at(i).vec.size(); j++)
            {
                wyjscie.write((char*)&komp2.at(i).vec.at(j), sizeof(float));
            }
        }

        int sectionSize3 = komp3.size();
        wyjscie.write((char*)&sectionSize3, sizeof(int));
        for(int i = 0; i < komp3.size(); i++)
        {
            int sectionSubSize3 = komp3.at(i).vec.size();
            wyjscie.write((char*)&sectionSubSize3, sizeof(int));
            for(int j = 0; j < komp3.at(i).vec.size(); j++)
            {
                wyjscie.write((char*)&komp3.at(i).vec.at(j), sizeof(float));
            }
        }

        wyjscie.close();
    }
}

void wczytaj_z_pliku_uniwersalna(string plik)
{
    char identyfikator[] = "";
    Uint16 szerokosc_obrazka = 0;
    Uint16 wysokosc_obrazka = 0;
    int tryb = 0;
    int predykcja = 0;
    int ByteRun = 0;
    int DCT = 0;

    cout << "Odczytujemy plik " << plik << " uzywajac dedykowanej metody" << endl;

    ifstream wejscie(plik, ios::binary);

    wejscie.read((char*)&identyfikator, sizeof(char) * 2);
    wejscie.read((char*)&szerokosc_obrazka, sizeof(szerokosc_obrazka));
    wejscie.read((char*)&wysokosc_obrazka, sizeof(wysokosc_obrazka));
    wejscie.read((char*)&tryb, sizeof(tryb));
    wejscie.read((char*)&predykcja, sizeof(predykcja));
    wejscie.read((char*)&ByteRun, sizeof(ByteRun));
    wejscie.read((char*)&DCT, sizeof(DCT));

    int sectionSize1=0;
    int sectionSize2=0;
    int sectionSize3=0;

    vector<komponentDCT> komp1;
    vector<komponentDCT> komp2;
    vector<komponentDCT> komp3;

    vector<Uint8> vec1;
    vector<Uint8> vec2;
    vector<Uint8> vec3;

    Uint8* komponent1 = nullptr;
    Uint8* komponent2 = nullptr;
    Uint8* komponent3 = nullptr;

    if(DCT == 1)
    {
        wejscie.read((char*)&sectionSize1, sizeof(int));
        komponent1 = new Uint8[sectionSize1];
        for(int i = 0; i < sectionSize1; i++)
        {
            wejscie.read((char*)&komponent1[i], sizeof(Uint8));
            vec1.push_back(komponent1[i]);
        }

        wejscie.read((char*)&sectionSize2, sizeof(int));
        komponent2 = new Uint8[sectionSize2];
        for(int i = 0; i < sectionSize2; i++)
        {
            wejscie.read((char*)&komponent2[i], sizeof(Uint8));
            vec2.push_back(komponent2[i]);
        }

        wejscie.read((char*)&sectionSize3, sizeof(int));
        komponent3 = new Uint8[sectionSize3];
        for(int i = 0; i < sectionSize3; i++)
        {
            wejscie.read((char*)&komponent3[i], sizeof(Uint8));
            vec3.push_back(komponent3[i]);
        }
    }
    else
    {
        wejscie.read((char*)&sectionSize1, sizeof(int));
        for(int i = 0; i < sectionSize1; i++)
        {
            komponentDCT temp;
            int sectionSubSize1;
            wejscie.read((char*)&sectionSubSize1, sizeof(int));
            temp.vec.resize(sectionSubSize1);
            for(int j = 0; j < sectionSubSize1; j++)
            {
                wejscie.read((char*)&temp.vec[j], sizeof(float));
            }
            komp1.push_back(temp);
        }

        wejscie.read((char*)&sectionSize2, sizeof(int));
        for(int i = 0; i < sectionSize2; i++)
        {
            komponentDCT temp;
            int sectionSubSize2;
            wejscie.read((char*)&sectionSubSize2, sizeof(int));
            temp.vec.resize(sectionSubSize2);
            for(int j = 0; j < sectionSubSize2; j++)
            {
                wejscie.read((char*)&temp.vec[j], sizeof(float));
            }
            komp2.push_back(temp);
        }

        wejscie.read((char*)&sectionSize3, sizeof(int));
        for(int i = 0; i < sectionSize3; i++)
        {
            komponentDCT temp;
            int sectionSubSize3;
            wejscie.read((char*)&sectionSubSize3, sizeof(int));
            temp.vec.resize(sectionSubSize3);
            for(int j = 0; j < sectionSubSize3; j++)
            {
                wejscie.read((char*)&temp.vec[j], sizeof(float));
            }
            komp3.push_back(temp);
        }
    }

    switch(DCT)
    {
    case 1:
        {
            // brak
            break;
        }
    case 2:
        {
            komponent1 = wykonajIDCT(komp1, szerokosc_obrazka, wysokosc_obrazka);
            komponent2 = wykonajIDCT(komp2, szerokosc_obrazka, wysokosc_obrazka);
            komponent3 = wykonajIDCT(komp3, szerokosc_obrazka, wysokosc_obrazka);
            break;
        }
    }

    switch(ByteRun)
    {
    case 1:
        {
            vector<Uint8> temp1(komponent1, komponent1 + szerokosc_obrazka * wysokosc_obrazka);
            vector<Uint8> temp2(komponent2, komponent2 + szerokosc_obrazka * wysokosc_obrazka);
            vector<Uint8> temp3(komponent3, komponent3 + szerokosc_obrazka * wysokosc_obrazka);

            vec1 = temp1;
            vec2 = temp2;
            vec3 = temp3;
            break;
        }
    case 2:
        {
            vec1 = ByteRunDekompresja(komponent1, sectionSize1);
            vec2 = ByteRunDekompresja(komponent2, sectionSize2);
            vec3 = ByteRunDekompresja(komponent3, sectionSize3);
            break;
        }
    }

    delete[] komponent1;
    delete[] komponent2;
    delete[] komponent3;

    komponent1 = new Uint8[vec1.size()];
    komponent2 = new Uint8[vec2.size()];
    komponent3 = new Uint8[vec3.size()];

    copy(vec1.begin(), vec1.end(), komponent1);
    copy(vec2.begin(), vec2.end(), komponent2);
    copy(vec3.begin(), vec3.end(), komponent3);

    switch(predykcja)
    {
    case 1:
        {
            // brak
            break;
        }
    case 2:
        {
            for(int y = 0; y < wysokosc_obrazka; y++)
            {
                DefiltratorRoznicowy(komponent1+y * szerokosc_obrazka, szerokosc_obrazka);
                DefiltratorRoznicowy(komponent2+y * szerokosc_obrazka, szerokosc_obrazka);
                DefiltratorRoznicowy(komponent3+y * szerokosc_obrazka, szerokosc_obrazka);
            }
            break;
        }
    }

    for(int y = 0; y < wysokosc_obrazka; y++)
    {
        for(int x = 0; x < szerokosc_obrazka; x++)
        {
            switch(tryb)
            {
            case 1:
                {
                    setRGB555(x + szerokosc_obrazka, y, komponent1[y * szerokosc_obrazka + x],
                                 komponent2[y * szerokosc_obrazka + x], komponent3[y * szerokosc_obrazka + x]);
                    break;
                }
            case 2:
                {
                    setPixel(x + szerokosc_obrazka, y, komponent1[y * szerokosc_obrazka + x],
                                 komponent2[y * szerokosc_obrazka + x], komponent3[y * szerokosc_obrazka + x]);
                        break;
                }
            case 3:
                {
                    YUVtoRGB(x + szerokosc_obrazka, y, komponent1[y * szerokosc_obrazka + x],
                                 komponent2[y * szerokosc_obrazka + x], komponent3[y * szerokosc_obrazka + x]);
                        break;
                }
            }
        }
    }
    wejscie.close();
    SDL_UpdateWindowSurface(window);

    delete[] komponent1;
    delete[] komponent2;
    delete[] komponent3;
}