huffman - lab

#include <stdlib.h>
#include <stdio.h>

#define BUFSIZE 1000
#define SIZECRC 4
#define kropka 46
#define degreegen 32

int LICZBA_ZNAKOW;

struct galaz
{
       int ojciec;
       int potomek1;
       int potomek2;
};
struct galaz drzewo_kodowania[255];

struct element_kodu
{
       int symbol;
       unsigned char slowo[4];
       int liczba_bitow;
};

struct element_kodu tablica_kodowania[512];
struct element_kodu tablica_kodu[256];

struct symbol_zrodla
{
       int symbol;
       int czestosc;
};
struct symbol_zrodla model_zrodla[256];


int porownaj(const void *operand1,const void *operand2)
{
    const struct symbol_zrodla *pointer1 = (const struct symbol_zrodla*) operand1;
    const struct symbol_zrodla *pointer2 = (const struct symbol_zrodla*) operand2;
    if((pointer1->czestosc)==(pointer2->czestosc)) return 0;
    else if((pointer1->czestosc)<(pointer2->czestosc))return 1;
    else return -1;
}

int nazwa_pliku(char *nazwa_pliku, char *rozszerzenie, char *nazwa_pliku_nowa)
{
    int i,n;
    char *w_nazwy;

    for (n=0; n<24; n++)
       nazwa_pliku_nowa[n]=0;

    n=0;
    w_nazwy=nazwa_pliku;
    nazwa_pliku_nowa[n]=*w_nazwy;
    while ((nazwa_pliku_nowa[n]!=kropka)&&(nazwa_pliku_nowa[n]!='\0'))
    {
        n++;
        w_nazwy++;
        nazwa_pliku_nowa[n]=*w_nazwy;
    }
    n++;
    i=0;
    nazwa_pliku_nowa[n]=rozszerzenie[i];
    while (rozszerzenie[i]!='\0')
    {
        n++;
        i++;
        nazwa_pliku_nowa[n]=rozszerzenie[i];
    }
    return 0;
}


int wyznacz_model(char *nazwa_plik_dany, struct symbol_zrodla model_zrodla[])
{
    int n;
    int indeks = 0;
    int lwz = 0;
    int licznik_symboli_zrodla=0;
    struct symbol_zrodla model_pelny[256];

    unsigned char bufor_wejscia[BUFSIZE];

    for(int k=0; k<256; k++)
    {
     model_pelny[k].symbol=k;
     model_pelny[k].czestosc=0;
    }


    FILE *wskaznik_pliku=NULL;
    wskaznik_pliku=fopen(nazwa_plik_dany,"rb");

    if (wskaznik_pliku == NULL)
    {
        printf("Nie mozna otworzyc pliku: %s  \n", nazwa_plik_dany);
        exit(EXIT_FAILURE);
    }
    else
    //wczytuje dane z pliku blokami i wyznacza czêstoœci wystêpowania znaków
    {
    printf( "Czytanie pliku %s do wyznaczenia modelu. \n", nazwa_plik_dany);
    while(n=fread(bufor_wejscia,sizeof(unsigned char),BUFSIZE,wskaznik_pliku))
    {
          for(int i=0; i<n; i++)
          {
            indeks = bufor_wejscia[i];
            model_pelny[indeks].czestosc++;
          }
            lwz+=n;
    }
    printf("liczba wszystkich znakow w pliku: %d\n", lwz);
    }

    LICZBA_ZNAKOW = lwz;

    for(int i=0; i<256; i++)
      {
            if (model_pelny[i].czestosc!=0)
            {
               model_zrodla[licznik_symboli_zrodla].symbol=model_pelny[i].symbol;
               model_zrodla[licznik_symboli_zrodla].czestosc=model_pelny[i].czestosc;
               licznik_symboli_zrodla++;
             }
       }
    return (licznik_symboli_zrodla);
}

int sortuj_model(struct symbol_zrodla model_zrodla[],int liczba_symboli_modelu,char *nazwapliku_msort)
{
    return 0;
}

int zrob_drzewo(struct symbol_zrodla model_zrodla[], struct galaz drzewo_kodowania[],int liczba_symboli_modelu)
{
    int liczba_symboli = liczba_symboli_modelu;
    int licznik_symboli;
    int licznik_symboli_dodanych = 0;
    int n;


    licznik_symboli=liczba_symboli;
    for(int k=0; k<liczba_symboli-1; k++)
    {
        drzewo_kodowania[k].ojciec = 256+k;
        drzewo_kodowania[k].potomek1 = model_zrodla[liczba_symboli_modelu-1-k].symbol;
        drzewo_kodowania[k].potomek2 = model_zrodla[liczba_symboli_modelu-2-k].symbol;
        model_zrodla[liczba_symboli_modelu-2-k].symbol = 256+k;
        model_zrodla[liczba_symboli_modelu-2-k].czestosc = model_zrodla[liczba_symboli_modelu-1-k].czestosc + model_zrodla[liczba_symboli_modelu-2-k].czestosc;
        licznik_symboli--;
        qsort(model_zrodla,licznik_symboli,sizeof(struct symbol_zrodla), porownaj);
        licznik_symboli_dodanych++;
    }
    return (licznik_symboli_dodanych);
}

int daj_tablice_kodowania(struct galaz drzewo_kodowania[], struct element_kodu tablica_kodowania[],int liczba_symboli_modelu)
{
    int symbol1,symbol2;
    int n, indeks_ojca, symbol_ojca;
    int licznik_drzewa=liczba_symboli_modelu-2;
    int licznik_kodu=0;
    int dlugosc_ciagu=0;
    int pozycja, ktory_bajt, ktory_bit;
    unsigned char bajt, bajtek[4], jedynka=1;

    for(int k=0; k<2*liczba_symboli_modelu; k++)
    {
      for(int i=0; i<4; i++)
          tablica_kodowania[k].slowo[i]=0;
      tablica_kodowania[k].symbol=0;
      tablica_kodowania[k].liczba_bitow=0;
    }

     tablica_kodowania[licznik_kodu].symbol=drzewo_kodowania[licznik_drzewa].ojciec;
     while(licznik_drzewa+1)
     {
          symbol_ojca=drzewo_kodowania[licznik_drzewa].ojciec;
          tablica_kodowania[licznik_kodu+1].symbol=drzewo_kodowania[licznik_drzewa].potomek1;
          tablica_kodowania[licznik_kodu+2].symbol=drzewo_kodowania[licznik_drzewa].potomek2;

          indeks_ojca=-1;
          for (int i=0; i<licznik_kodu+1; i++)
             {
               //printf("%d  %d  %d\n", licznik_drzewa, symbol_ojca, tablica_kodowania[i].symbol);
               if ((tablica_kodowania[i].symbol)==(symbol_ojca))
                {
                 indeks_ojca=i;
                 break;
                }
             }
             if (indeks_ojca==-1)
             {
                 printf("Blad tworzenie tablicy kodowania\n");
                 exit(EXIT_FAILURE);
             }

          dlugosc_ciagu=tablica_kodowania[indeks_ojca].liczba_bitow;
          //Przepisanie ciagu ojca do potomkow
          for (int i=0; i<4; i++)
                {
                tablica_kodowania[licznik_kodu+1].slowo[i]=tablica_kodowania[indeks_ojca].slowo[i];
                tablica_kodowania[licznik_kodu+2].slowo[i]=tablica_kodowania[indeks_ojca].slowo[i];

                }

          pozycja=dlugosc_ciagu;
          ktory_bajt=pozycja/8;
          ktory_bit=pozycja%8;
          jedynka=1;
          jedynka=jedynka<<7-ktory_bit;

          bajt=tablica_kodowania[indeks_ojca].slowo[ktory_bajt];
          bajt=bajt|jedynka;//dopisanie jedynki

          tablica_kodowania[licznik_kodu+1].slowo[ktory_bajt]=bajt;
          tablica_kodowania[licznik_kodu+1].liczba_bitow=dlugosc_ciagu+1;
          tablica_kodowania[licznik_kodu+2].liczba_bitow=dlugosc_ciagu+1;
          licznik_kodu+=2;
          licznik_drzewa--;
     }
    return 0;
}

int daj_tablice_kodu(struct element_kodu tablica_kodowania[], struct element_kodu tablica_kodu[],int liczba_symboli_modelu)
{
    int symbol, licznik_kodu=0;
    unsigned char bajtek[4];

     for (int k=0; k<2*liczba_symboli_modelu-1; k++)
     {
         symbol=tablica_kodowania[k].symbol;
         if (symbol<256)
         {
             tablica_kodu[licznik_kodu].symbol=symbol;
             tablica_kodu[licznik_kodu].liczba_bitow=tablica_kodowania[k].liczba_bitow;
             for (int i=0; i<4; i++)
                tablica_kodu[licznik_kodu].slowo[i]=tablica_kodowania[k].slowo[i];
             licznik_kodu++;
         }
     }
    return 0;
}

int kompresja(char *nazwa_pliku_in, char *nazwa_pliku_out, struct element_kodu tablica_kodu[],int liczba_symboli_modelu)
{

    unsigned char bufor_wejscia[BUFSIZE];
    unsigned char bufor_wyjscia[BUFSIZE];
    unsigned char symbol, dopisek, bajt_out;
    int n,suma=0;
    int licznik_symboli_kodowanych;
    int kursor_slowka, kursor_out;//pozycja bitu w slowie kodowym, pozycja bitu w bajcie out
    int liczba_bit_skod, liczba_wolne_bity, liczba_pozostale_w_slowku, numer_bajtu, numer_slowka;
    unsigned char maska1, maska2, maska, slowko[4];

    FILE *wskaznik_pliku_out=NULL;
    wskaznik_pliku_out=fopen(nazwa_pliku_out,"wb");

    if (wskaznik_pliku_out == NULL)
    {
        printf("Nie mozna otworzyc pliku: %s  \n", nazwa_pliku_in);
        exit(EXIT_FAILURE);
    }


    FILE *wskaznik_pliku_in=NULL;
    wskaznik_pliku_in=fopen(nazwa_pliku_in,"rb");

    if (wskaznik_pliku_in == NULL)
    {
        printf("Nie mozna otworzyc pliku: %s  \n", nazwa_pliku_in);
        exit(EXIT_FAILURE);
    }
    numer_slowka=0;
    numer_bajtu=0;
    kursor_out=0;
    bajt_out=0;
    licznik_symboli_kodowanych=0;

    while(n=fread(bufor_wejscia,sizeof(unsigned char),BUFSIZE,wskaznik_pliku_in))
    {
    for(int i=0; i<n; i++)
      {
        symbol = bufor_wejscia[i];
        for (int m=0; m<liczba_symboli_modelu; m++)
        {
          if (symbol==tablica_kodu[m].symbol)
           {
           for (int k=0; k<4; k++)
             slowko[k]=tablica_kodu[m].slowo[k];
           liczba_bit_skod=tablica_kodu[m].liczba_bitow;
           suma=suma+liczba_bit_skod;
           kursor_slowka=0;
           numer_slowka=0;
           break;
           }
        }
        while (liczba_bit_skod>0)
        {
           liczba_pozostale_w_slowku=8-kursor_slowka;
           if (liczba_pozostale_w_slowku>liczba_bit_skod)
              liczba_pozostale_w_slowku=liczba_bit_skod;
           liczba_wolne_bity=8-kursor_out;
           if (liczba_pozostale_w_slowku<liczba_wolne_bity)
               liczba_wolne_bity=liczba_pozostale_w_slowku;
           maska1=255>>kursor_slowka;
           maska2=255<<(8-(kursor_slowka+liczba_wolne_bity));
           maska=maska1&maska2;
           dopisek=slowko[numer_slowka]&maska;
           dopisek=dopisek<<kursor_slowka;
           dopisek=dopisek>>kursor_out;
           bajt_out=bajt_out|dopisek;
           kursor_out+=liczba_wolne_bity;
           liczba_bit_skod-=liczba_wolne_bity;
           kursor_slowka+=liczba_wolne_bity;
           liczba_pozostale_w_slowku-=liczba_wolne_bity;
           if (liczba_pozostale_w_slowku==0)
           {
             numer_slowka++;
             kursor_slowka=0;
             if (liczba_bit_skod>=8)
             liczba_pozostale_w_slowku=8;
             else
             liczba_pozostale_w_slowku=liczba_bit_skod;
           }
           if (kursor_out==8)
           {
           fwrite(&bajt_out,sizeof(unsigned char),1,wskaznik_pliku_out);
           numer_bajtu++;
           kursor_out=0;
           bajt_out=0;
           }
         }
         licznik_symboli_kodowanych+=1;
       }
    }

    printf("Bajt wyjsciowy numer %d  kod hdec  %x  \n", numer_bajtu, bajt_out);
    fwrite(&bajt_out,sizeof(unsigned char),1,wskaznik_pliku_out);

    printf("Liczba zakodowanych znakow pliku kompresowanego: %d\n", licznik_symboli_kodowanych);
    printf("Liczba bajtow w pliku skompresowanym: %d\n", numer_bajtu+1);
    printf("Wskaznik upakowania: %5.1f  procent\n", 100*(float)(numer_bajtu+1)/(float)licznik_symboli_kodowanych);
    fclose(wskaznik_pliku_in);
    fclose(wskaznik_pliku_out);

    return (suma);
}

int dekompresja(char *nazwa_pliku_skom, char *nazwa_pliku_dekom, struct galaz drzewo_kodowania[], int liczba_galezi_drzewa, int ile_symboli)
{
    unsigned char bajt_out, bit1, bajt_in;
    int m,n,suma_symboli=0,suma_bitow=0;
    int indeks_drzewa;
    int kursor_in;//pozycja bitu w bajcie wejsciowym
    int pater, syn1, syn0;;
    unsigned char maska=128;

    FILE *wskaznik_pliku_skom=NULL;
    wskaznik_pliku_skom=fopen(nazwa_pliku_skom,"rb");

    if (wskaznik_pliku_skom == NULL)
    {
        printf("Nie mozna otworzyc pliku: %s  \n", nazwa_pliku_skom);
        exit(EXIT_FAILURE);
    }


    FILE *wskaznik_pliku_dekom=NULL;
    wskaznik_pliku_dekom=fopen(nazwa_pliku_dekom,"wb");

    if (wskaznik_pliku_dekom == NULL)
    {
        printf("Nie mozna otworzyc pliku: %s  \n", nazwa_pliku_dekom);
        exit(EXIT_FAILURE);
    }

    printf( "Czytanie pliku skompresowanego %s po jednym bajcie. \n", nazwa_pliku_skom);
    printf( "Po zdekodowaniu pisanie bajtu do pliku %s. \n", nazwa_pliku_dekom);

    suma_symboli=0;
    indeks_drzewa=liczba_galezi_drzewa-1;
    pater=drzewo_kodowania[indeks_drzewa].ojciec;
    syn1=drzewo_kodowania[indeks_drzewa].potomek1;
    syn0=drzewo_kodowania[indeks_drzewa].potomek2;

    //printf("Tyle ma byc bajtow po zdekodowaniu:  %d a tyle zdekodowano: %d\n", ile_bajtow, suma_symboli);

    while(suma_symboli<ile_symboli)
    {
    //printf("Tyle ma byc bajtow:  %d a tyle juz zdekodowano: %d\n", ile_bajtow, suma_symboli);
    n=fread(&bajt_in,sizeof(unsigned char),1,wskaznik_pliku_skom);
    if (n==1)
      {
        for (int k=0;k<8; k++)
        {
            bit1=bajt_in&maska;
            //printf("Galaz %d %d %d  bajt_in %x bit1 %x\n",pater, syn1, syn0, bajt_in, bit1);
            bajt_in=bajt_in<<1;
            suma_bitow++;
            if (bit1)
              pater=syn1;
            else
              pater=syn0;

            if (pater<256)
            {
               bajt_out=pater;
               //printf("Galaz %d %d %d symbol %d\n",pater, syn1, syn0, bajt_out);
               fwrite(&bajt_out,sizeof(unsigned char),1,wskaznik_pliku_dekom);
               suma_symboli++;
               indeks_drzewa=liczba_galezi_drzewa-1;
               pater=drzewo_kodowania[indeks_drzewa].ojciec;
               syn1=drzewo_kodowania[indeks_drzewa].potomek1;
               syn0=drzewo_kodowania[indeks_drzewa].potomek2;
               if (suma_symboli == ile_symboli)
               break;//wyjscie z for
            }
            else
            {
            m=liczba_galezi_drzewa-1;
            while (m>=0)
            {
               if  (drzewo_kodowania[m].ojciec==pater)
               {
                 indeks_drzewa=m;
                 m=-1;
               }
               m=m-1;
            }
            //pater=drzewo_kodowania[indeks_drzewa].ojciec;
            syn1=drzewo_kodowania[indeks_drzewa].potomek1;
            syn0=drzewo_kodowania[indeks_drzewa].potomek2;
            }//end else
          }//end for
        } //end if
      }//end while

      printf("Liczba odczytanych bitow: %d, liczba zdekodowanych symboli %d.\n", suma_bitow, suma_symboli);
      fclose(wskaznik_pliku_skom);
      fclose(wskaznik_pliku_dekom);

      return (suma_symboli);
}

int dzielenie(char *nazwa_pliku_in, unsigned char reszta[], unsigned char wielomian[])
{
 unsigned char bufor_wejscia[BUFSIZE], kolejka[SIZECRC+BUFSIZE];
 unsigned char start=0, koniec=0, maska=128, ostatni_bit, pierwszy_bit;
 int n,m;
 int licznik_bitow=0;
 int licznik_bajtow_in=0, licznik_buforu=0;

    for (int i=0; i<SIZECRC; i++)
       reszta[i]=0;

    for (int i=0; i<SIZECRC+BUFSIZE; i++)
       kolejka[i]=0;

    FILE *wskaznik_pliku_in=NULL;
    wskaznik_pliku_in=fopen(nazwa_pliku_in,"rb");

    if (wskaznik_pliku_in == NULL)
    {
      printf("Nie mozna otworzyc pliku: %s  \n", nazwa_pliku_in);
      exit(EXIT_FAILURE);
    }

    while(n=fread(bufor_wejscia,sizeof(unsigned char),BUFSIZE,wskaznik_pliku_in))
    {
        //printf("Return fread %d\n",n);
        for (int i=0; i<n; i++)
                  kolejka[SIZECRC+i]=bufor_wejscia[i];
        licznik_bitow=8*n;
        licznik_bajtow_in+=n;

        while (licznik_bitow)
        {
          licznik_buforu=1+(licznik_bitow-1)/8;
          //printf("Liczba bitow %d. Licznik buforu %d. \n", licznik_bitow, licznik_buforu);
          pierwszy_bit=maska&kolejka[0];

          for (int i=0; i<SIZECRC+licznik_buforu; i++)
               {
                 kolejka[i]=(kolejka[i]<<1);
                 ostatni_bit=kolejka[i+1]>>7;
                 kolejka[i]=kolejka[i]|ostatni_bit;
                 //printf("Bajt %d kolejki po przesunieciu: %#x\n", i, kolejka[i]);
               }
          if (pierwszy_bit!=0)  //jesli pierwszy bit jest jedynka
               for(int i=0; i<SIZECRC; i++)
                  {
                    kolejka[i]=kolejka[i]^wielomian[i];
                    //printf("Bajt %d kolejki po xorowaniu: %#x\n", i, kolejka[i]);
                  }
          licznik_bitow--;

        } // end while
    } // end while

    //printf("Sukcesywne dopisywanie degreegen zer na koncu kolejki.\n");
    licznik_bitow=degreegen;

        while (licznik_bitow>0)
        {
          //printf("Liczba bitow %d\n", licznik_bitow);

          pierwszy_bit=maska&kolejka[0];
          //printf("Pierwszy bit %#x\n", pierwszy_bit);
          for (int i=0; i<SIZECRC; i++)
               {
                 kolejka[i]=(kolejka[i]<<1);
                 ostatni_bit=kolejka[i+1]>>7;
                 kolejka[i]=kolejka[i]|ostatni_bit;
               }
              //for(int i=0; i<SIZECRC+n; i++)
              //   printf("Po przesunieciu bajt %d kolejki: %#x\n", i, kolejka[i]);
          //Zero na koncu jest dopisywane z definicji przesuniecia
          if (pierwszy_bit!=0)  //jesli pierwszy bit jest jedynka
                 for(int i=0; i<SIZECRC; i++)
                 {
                    kolejka[i]=kolejka[i]^wielomian[i];
                    //printf("Bajt %d kolejki po xorowaniu: %#x\n", i, kolejka[i]);
                 }
          licznik_bitow--;

        }// end while

 for(int i=0; i<SIZECRC; i++)
      reszta[i]=kolejka[i];

 return licznik_bajtow_in;

}
void copyFile(char *from, char *to)
{
    FILE * input;
    FILE * output;

    if((input = fopen(from, "rb")) == NULL)
    {
        perror("Nie mozna otworzyc pliku");
        exit(EXIT_FAILURE);
    }

    if((output = fopen(to, "wb")) == NULL)
    {
        perror("Nie mozna otworzyc pliku");
        exit(EXIT_FAILURE);
    }

    int c;
    do
    {
        c = fgetc(input);
        if( feof(input) )
        {
            break ;
        }
        fputc(c, output);
    }while(1);

    if(fclose(input) != 0)
    {
        perror("fclose");
        exit(EXIT_FAILURE);
    }

    if(fclose(output) != 0)
    {
        perror("fclose");
        exit(EXIT_FAILURE);
    }
}

void appendCrcToFile(char * outputWithCrc, int crcSizeInBytes, unsigned char crc[])
{

    FILE * output;

    if((output = fopen(outputWithCrc, "a")) == NULL)
    {
        perror("Nie mozna otworzyc pliku");
        exit(EXIT_FAILURE);
    }

    int c;
    int i;

    for(i=0; i<SIZECRC; i++)
    {
        c = crc[i];
        fputc(c, output);
    }

    if(fclose(output) != 0)
    {
        perror("fclose");
        exit(EXIT_FAILURE);
    }
}

void createCrcFile(char * fileName, int crcSizeInBytes, unsigned char crc[])
{

    FILE * fp;

    if((fp = fopen(fileName, "wb")) == NULL)
    {
        perror("Nie mozna otworzyc pliku");
        exit(EXIT_FAILURE);
    }

    int c;
    int i;
    for(i=0; i<SIZECRC; i++)
    {
        c = crc[i];
        fputc(c, fp);
    }
    if(fclose(fp) != 0)
    {
        perror("fclose");
        exit(EXIT_FAILURE);
    }
}

int isIntegral(unsigned char rest[], int restSize){

    int i=0;
    for(i=0; i<restSize; i++){
        if(rest[i] != 0){
//            printf("Integrity check failed");
            return 0;
        }
    }
    return 1;
}

int main(int argc, char *argv[])
{
    int n;
    int liczba_symboli_modelu=0;
    int liczba_symboli_dodanych=0;
    char *nazwa_pliku_in;
    char rozszerzenie_out[]= "huffman";
    char rozszerzenie_decoded[]= "decoded";
    char CRC_rozszerzenie[]= "CRC";
    char nazwa_CRC[24];
    char nazwa_modelu[24];
    char nazwa_modsort[24];
    char nazwa_pliku_out[24];
    char nazwa_pliku_decoded[24];
    unsigned char wielomian[SIZECRC], reszta[SIZECRC];
    int ile_bajtow_zrobiono;

    wielomian[0]=0x00;
    wielomian[1]=0x00;
    wielomian[2]=0x00;
    wielomian[3]=0x0b;

    if(argc==2)
    {
        nazwa_pliku_in=argv[1];
        printf("Nazwa pliku do kompresji:  %s \n", nazwa_pliku_in);
    }
    else
    {
        printf("Zla liczba parametrow.  ","%d", argc);
        exit(EXIT_FAILURE);
    }
    for (int i=0; i<SIZECRC; i++)
        printf("Wartosc %d. bajtu wielomianu to: %02x\n", i+1, wielomian[i]);
    n=nazwa_pliku(nazwa_pliku_in, CRC_rozszerzenie,nazwa_CRC);
    n=dzielenie(nazwa_pliku_in, reszta, wielomian);
    createCrcFile(nazwa_CRC, SIZECRC, reszta);
    appendCrcToFile(nazwa_pliku_in, SIZECRC, reszta);

    liczba_symboli_modelu = wyznacz_model(nazwa_pliku_in, model_zrodla);

    if (liczba_symboli_modelu!=0)
        printf("Liczba symboli alfabetu wejsciowego: %d\n", liczba_symboli_modelu);
    else
    {
        printf("Wyznaczanie modelu zrodla nie powiodlo sie.\n");
        exit(EXIT_FAILURE);
    }

    n = sortuj_model(model_zrodla,liczba_symboli_modelu, nazwa_modsort);
    if (n==0)
     printf("Model zrodla zostal posortowany\n");
    else
    {
     printf("Sortowanie modelu zrodla nie powiodlo sie.\n");
     exit(EXIT_FAILURE);
    }
    liczba_symboli_dodanych=zrob_drzewo(model_zrodla,drzewo_kodowania,liczba_symboli_modelu);
    if (liczba_symboli_dodanych!=0)
     printf("Liczba symboli dodanych: %d\n", liczba_symboli_dodanych);
    else
    {
     printf("Utworzenie drzewa kodowania nie powiodlo sie.\n");
     exit(EXIT_FAILURE);
    }
    n = daj_tablice_kodowania(drzewo_kodowania, tablica_kodowania, liczba_symboli_modelu);
    if (n==0)
     printf("Tablica kodowania zostala utworzona.\n");
    else
    {
     printf("Utworzenie tablicy kodowania nie powiodlo sie.\n");
     exit(EXIT_FAILURE);
    }
    n = daj_tablice_kodu( tablica_kodowania, tablica_kodu,liczba_symboli_modelu);
    if (n==0)
     printf("Tablica kodu zostala utworzona.\n");
    else
    {
     printf("Utworzenie tablicy kodu nie powiodlo sie.\n");
     exit(EXIT_FAILURE);
    }
    n=nazwa_pliku(nazwa_pliku_in, rozszerzenie_out,nazwa_pliku_out);
    n=kompresja(nazwa_pliku_in, nazwa_pliku_out, tablica_kodu,liczba_symboli_modelu);

    if (n>0)
    {
      printf("Suma bitow kodu w pliku %s  %d  \n", nazwa_pliku_out, n);
      if (n%8!=0)
        n=n/8+1;
      printf("Liczba bajtow w pliku %s  %d  \n", nazwa_pliku_out, n);
    }
    else
    {
        printf("Kodowanie nie powiodlo sie.\n");
        exit(EXIT_FAILURE);
    }
    n=nazwa_pliku(nazwa_pliku_in, rozszerzenie_decoded,nazwa_pliku_decoded);
    printf("\nDEKODOWANIE\n\n");
    printf("Tyle bajtow nalezy odkodowac: %d\n", LICZBA_ZNAKOW);
    ile_bajtow_zrobiono=dekompresja(nazwa_pliku_out, nazwa_pliku_decoded,drzewo_kodowania,liczba_symboli_dodanych, LICZBA_ZNAKOW);
    if (ile_bajtow_zrobiono==LICZBA_ZNAKOW)
      printf("Liczba bajtow prawidlowa. Wynik dekompresji zapisany do pliku: %s. \n\n\n", nazwa_pliku_decoded);
    else
      printf("Liczba bajtow nieprawidlowa. Wynik dekompresji zapisany do pliku: %s. \n\n\n", nazwa_pliku_decoded);
    n=dzielenie(nazwa_pliku_decoded, reszta, wielomian);
    if(isIntegral(reszta, SIZECRC)) printf("Zdekodowano poprawnie. CRC prawidlowe");
    else printf("Zdekodowano niepoprawnie. CRC nieprawidlowe");
    return 0;
}