Написать программу кодировки файла методом LZ77

#include "???????"
#define DICBITS   12             // Log(DICSIZE)
#define DICSIZE   (1<<DICBITS)   // 4-32kB Размер словаря
#define THRESHOLD 2              // Порог
#define STRBITS   6              // Log(STRMAX-THRESHOLD)
#define STRMAX    ((1<<STRBITS)+THRESHOLD) // Мах. длина строки
#define BUFSIZE   0xff00U        // Полный размер буфера
#define TEXTSIZE  (BUFSIZE-DICSIZE-STRMAX) // Размер буфера текста
#define YES       1
#define NO        0
 
FILE *first_file, *second_file;
long srcleng=0, fileleng;
unsigned char *srcbuf, *srcstart;
/*==============================
========Функция записи=========
==============================*/
int putbits(int data, int nbits)
{
    static int bitcounter=0;
    static int outdata=0;
    int bit, error;
    data<<=(16-nbits);
    for( ; nbits > 0 ; nbits-- )
    {
        if( bitcounter == 8 )
        {
            bitcounter=0;
            error=putc(outdata,second_file);
            if( error == EOF )
            { 
                printf("Error writing to Second file."); 
                return -5; 
            }
        }
    outdata<<=1;
    bit=( data & 0x8000 ) ? 1:0;
    outdata+=bit;
    bitcounter++;
    data<<=1;
    }
}
 
/*==============================
======Функция Архивирования=====
==============================*/
void compress_stud()
{
//  struct stat buf;
    unsigned char  *position, *pointer; //байт в файле , байт в буфере
    int i, dist, offset=0, last=NO, cnt, maxleng;
 
    printf("Compress started.");
 
    // Записываем размер исходного файла
 
    fstat(fileno(first_file),&buf);
    fileleng=buf.st_size;
    write(fileno(second_file), &fileleng, sizeof(long));
 
    // Читаем файл в буфер по частям размера TEXTSIZE 
    while((srcleng=fread(srcstart+offset, 1, TEXTSIZE, first_file))>0)
    {
        if(srcleng < TEXTSIZE ) // Последняя часть текста 
        {
            last=YES; 
        }
        position=srcstart;
        pointer=srcbuf;
        srcleng+=offset;
        while(srcleng>0)
        {
            printf("\n\nStep - %d\n",srcleng);
            maxleng=0;
 
            if((last == NO) && (srcleng < STRMAX)) // Если в буфере текста осталось мало символов, сдвигаем словарь и оставшийся текст в начало буфера и дочитываем следующую часть из файла 
            {
                memcpy(srcbuf,pointer,DICSIZE+(int)srcleng);
                offset=(int)srcleng; 
                break;
            }
 
            for( i=DICSIZE-1; i >= 0; i-- )// Ищем самую длинную совпадающую строку в словаре
            {
                for( cnt=0; cnt < STRMAX; cnt++ )
                if( *(position+cnt) != *(pointer+i+cnt) ) 
                break;
 
                if( cnt <= THRESHOLD )// Если длина меньше порога, отбрасываем 
                continue;
 
                if( cnt == STRMAX )// Если максимальная строка, дальше не ищем 
                {
                    dist=DICSIZE-1-i; //позиция
                    maxleng=STRMAX; //длина
                    break; 
                }
 
                if( cnt > maxleng ) // Если очередная строка длиннее уже найденных, сохраняеМ ее длину и позицию
                {
                    dist=DICSIZE-1-i; // позиция
                    maxleng=cnt; //длина
                }
            }
 
            if( (last == YES) && (maxleng > srcleng) ) // Проверяем, чтобы не было выхода за границы файла
            {
                maxleng=(int)srcleng; //обрезаем длину по границу буфера
            }
 
            if( maxleng > THRESHOLD )//Если строка достаточно длинная, формируем pointer-код
            {
                printf("link!\n");
                putbits(1,1); //помечаем как ссылку
                putbits(dist,DICBITS); //записываем позицию
                putbits(maxleng-THRESHOLD-1,STRBITS); //записываем длину
                position+=maxleng;
                srcleng-=maxleng;
                pointer+=maxleng;
            }
            else // Иначе - chr-код
            {   
                printf("Char!\n");
                putbits(0,1);  //помечаем как chr-код
                putbits(*position,8); //записываем чар код
                position++; 
                srcleng--; 
                pointer++;
            }
        }
    }
 
    // Записываем оставшиеся биты 
    putbits(0,8);
 
    printf("\nCompress compleated!\n",fileleng);
}
 
//Разархивирование Алгоритм  LZ77
 
/*==============================
======Функция считывания========
==============================*/
int getbits(int nbits)
{
    static int bitcounter=8;
    static int indata=0;
    int bit, data=0;
 
    for( ; nbits > 0 ; nbits-- )
    {
        if( bitcounter == 8 )
        { 
            bitcounter=0; 
            indata=getc(first_file); 
        }
 
        if( indata == EOF )
        { 
            printf("Error writing to First file."); 
            return -6; 
        }
 
        bit=( indata & 0x80 ) ? 1:0;
        data<<=1; 
        data+=bit; 
        bitcounter++; 
        indata<<=1;
    }
    return data;
}
 
/*==============================
=======Функция Извлечения=======
==============================*/
 
void decompress_stud()
{
    struct stat buf;
    unsigned char  *pos;
    int   i, dist, ch, maxleng;
 
    printf("Decompress started.\n");
 
    // Получаем длину исходного файла
    read(fileno(first_file),&fileleng,sizeof(long));
    pos=srcstart;
 
    while( fileleng > 0 )
        {
        if( (ch=getbits(1)) == 0 ) // Если chr-код, копируем в буфер текста символ 
        {
            ch=getbits(8); 
            putc(ch,second_file); 
            *pos=ch; 
            pos++; 
            fileleng--; 
        }
        else // Иначе - копируем maxleng символов из словаря, начиная с позиции dist
        {
            dist=getbits(DICBITS)+1; 
            maxleng=getbits(STRBITS)+THRESHOLD+1;
            for( i=0; i < maxleng; i++ )
            {
                *(pos+i)=*(pos+i-dist); 
                putc(*(pos+i-dist),second_file); 
            }
            pos+=maxleng; 
            fileleng-=maxleng;
        }
 
        if( pos > srcstart+TEXTSIZE ) // Если буфер заполнен, записываем его на диск и сдвигаем словарь в начало буфера
        {
            memcpy(srcbuf,pos-DICSIZE,DICSIZE);
            pos=srcstart;
        }
    }
    printf("\nDecompress compleated.");
}

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <string.h>
#include <fstream>
#include <fcntl.h>
#include <io.h>
 
 
#define DICBITS   12             // Log(DICSIZE)
#define DICSIZE   (1<<DICBITS)   // Rozmiar slownika
#define THRESHOLD 2              // Prog
#define STRBITS   6              // Log(STRMAX-THRESHOLD)
#define STRMAX    ((1<<STRBITS)+THRESHOLD) // Maksymalny rozmiar wierszu
#define BUFSIZE   0xff00U        // Pelny rozmiar bufora
#define TEXTSIZE  (BUFSIZE-DICSIZE-STRMAX) // Rozmiar bufora teksta
#define YES       1
#define NO        0
 
 
long fileleng;
int srcleng=0;
unsigned char *srcbuf, *srcstart;
 
 
 
//кодировка сдвигом
void coding(char fnamein[],char fnameout[],char code[],int p=1){
    FILE *in = fopen(fnamein,"rb");
    FILE *out = fopen(fnameout,"wb");
    if (in==NULL || out==NULL) return;
    int len=strlen(code);
    int i=0;
    int ch;
    while ((ch=getc(in))!=EOF)
    {
        int c=(ch+p*code[i%len])%256;
        putc(c,out);
        i++;
    }
    fclose(in);
    fclose(out);
}
 
 
//crc-16
unsigned int crc16(char fname[])
{
    FILE *in = fopen(fname,"r");
    if (in==NULL) return 0;
    unsigned int crc = 0xFFFF;
    unsigned char i;
    unsigned char ch;
    while (fscanf(in,"%c",&ch)!=EOF)
    {
        crc ^= ch << 8;
 
        for (i = 0; i < 8; i++) 
        {
            if (crc & 0x8000) 
                crc=(crc << 1) ^ 0x1021;
            else 
                crc = crc << 1;
        }
    }
    fclose(in);
    return crc;
}
 
 
/*==============================
========Функция записи=========
==============================*/
int putbits(int data, int nbits, char fileout [])
{       FILE *out = fopen( fileout, "w");
        static int bitcounter=0;
        static int outdata=0;
        int bit, error;
        data<<=(16-nbits);
        for( ; nbits > 0 ; nbits-- )
        {
                if( bitcounter == 8 )
                {
                        bitcounter=0;
                        error=putc(outdata,out);
                        if( error == EOF )
                        { 
                                printf("Error writing to Second file."); 
                                return -5; 
                        }
                }
        outdata<<=1;
        bit=( data & 0x8000 ) ? 1:0;
        outdata+=bit;
        bitcounter++;
        data<<=1;
        }
}
 
 
/*==============================
======Функция Архивирования=====
==============================*/
void compress_stud(char *filein,char *fileout)
{
       
        unsigned char  *position, *pointer; //байт в файле , байт в буфере
        int i, dist, offset=0, last=NO, cnt, maxleng;
 
        printf("Compressing...");
 
 
       FILE *in = fopen(filein, "r");
        // Читаем файл в буфер по частям размера TEXTSIZE 
        while((srcleng=fread(srcstart+offset, 1, TEXTSIZE, in))>0)
        {
                if(srcleng < TEXTSIZE ) // Последняя часть текста 
                {
                        last=YES; 
                }
                position=srcstart;
                pointer=srcbuf;
                srcleng+=offset;
 
                printf("\n\nStep - %d\n",srcleng);
                maxleng=0;
                
                if((last == NO) && (srcleng < STRMAX)) // Если в буфере текста осталось мало символов, сдвигаем словарь и оставшийся текст в начало буфера и дочитываем следующую часть из файла 
                {
                        memcpy(srcbuf,pointer,DICSIZE+(int)srcleng);
                        offset=(int)srcleng; 
                        break;
                }
 
                for(i=DICSIZE-1; i >= 0; i--) // Ищем самую длинную совпадающую строку в словаре
                {
                        for( cnt=0; cnt < STRMAX; cnt++ )
                        if( *(position+cnt) != *(pointer+i+cnt) ) 
                        break;
 
                        if( cnt <= THRESHOLD )// Если длина меньше порога, отбрасываем  
                        continue;
 
                        if( cnt == STRMAX )// Если максимальная строка, дальше не ищем 
                        {
                                dist=DICSIZE-1-i; //позиция
                                maxleng=STRMAX; 
                                break; 
                        }
 
                       if( cnt > maxleng ) // Если очередная строка длиннее уже найденных, сохраняеМ ее длину и позицию
                                {
                                        dist=DICSIZE-1-i; // позиция
                                        maxleng=cnt; //длина
                                }
                        }
 
                        if( (last == YES) && (maxleng > srcleng) ) // Проверяем, чтобы не было выхода за границы файла
                        {
                                maxleng=(int)srcleng; //обрезаем длину по границу буфера
                        }
 
                        if( maxleng > THRESHOLD )//Если строка достаточно длинная, формируем pointer-код
                        {
                                printf("link!\n");
                                putbits(1,1, fileout); //помечаем как ссылку
                                putbits(dist,DICBITS, fileout); //записываем позицию
                                putbits(maxleng-THRESHOLD-1,STRBITS, fileout); //записываем длину
                                position+=maxleng;
                                srcleng-=maxleng;
                                pointer+=maxleng;
                        }
                        else // Иначе - chr-код
                        {       
                                printf("Char!\n");
                                putbits(0,1,fileout);  //помечаем как chr-код
                                putbits(*position,8,fileout); //записываем чар код
                                position++; 
                                srcleng--; 
                                pointer++;
                        }
                }
        putbits(0,8,fileout);
 
        printf("\nCompress compleated!\n",fileleng);
        }
 
        
 
 //Разархивирование Алгоритм  LZ77
 
/*==============================
======Функция считывания========
==============================*/
int getbits(int nbits, char filein [])
{
        static int bitcounter=8;
        static int indata=0;
        int bit, data=0;
        FILE *in = fopen(filein, "r");
        for( ; nbits > 0 ; nbits-- )
        {
                if( bitcounter == 8 )
                { 
                        bitcounter=0; 
                        indata=getc(in); 
                }
 
                if( indata == EOF )
                { 
                        printf("Error writing to First file."); 
                        return -6; 
                }
 
                bit=( indata & 0x80 ) ? 1:0;
                data<<=1; 
                data+=bit; 
                bitcounter++; 
                indata<<=1;
        }
        return data;
}
 
/*==============================
=======Функция Извлечения=======
==============================*/
 
void decompress_stud(char *filein,char *fileout)
{
       
        unsigned char  *pos;
        int   i, dist, ch, maxleng;
 
        printf("Decompress started.\n");
 
        // Получаем длину исходного файла
        FILE *in = fopen(filein, "r");
        FILE *out = fopen(fileout, "w");
        read(fileno(in),&fileleng,sizeof(long));
        pos=srcstart;
 
        while( fileleng > 0 )
                {
                if( (ch=getbits(1,filein)) == 0 ) // Если chr-код, копируем в буфер текста символ 
                {
                        ch=getbits(8,filein); 
                        putc(ch,out); 
                        *pos=ch; 
                        pos++; 
                        fileleng--; 
                }
                else // Иначе - копируем maxleng символов из словаря, начиная с позиции dist
                {
                        dist=getbits(DICBITS,filein)+1; 
                        maxleng=getbits(STRBITS,filein)+THRESHOLD+1;
                        for( i=0; i < maxleng; i++ )
                        {
                                *(pos+i)=*(pos+i-dist); 
                                putc(*(pos+i-dist),out); 
                        }
                        pos+=maxleng; 
                        fileleng-=maxleng;
                }
 
                if( pos > srcstart+TEXTSIZE ) // Если буфер заполнен, записываем его на диск и сдвигаем словарь в начало буфера
                {
                        memcpy(srcbuf,pos-DICSIZE,DICSIZE);
                        pos=srcstart;
                }
        }
        printf("\nDecompress compleated.");
}
 
int main() {
    char mode;
    char fname_in[20];
    char fname_out[20];
    char cod[]="zzblabzzlabla";
    crc16("input.txt");
    puts("Enter '1' to encode or '2' to decode");
    scanf("%c",&mode);
    if (mode=='1') {
        puts("Enter file names");
        scanf("%s %s",fname_in,fname_out);
        compress_stud(fname_in,"out");
        coding("out",fname_out,cod,1);
        remove("out");
        printf("CRC-16(%s):%X CRC-16(%s):%X\n",fname_in,crc16(fname_in),fname_out,crc16(fname_out));
        puts("Encoding completed");
    }
    else {
        puts("Enter file names");
        scanf("%s %s",fname_in,fname_out);
        coding(fname_in,"out",cod,-1);
        decompress_stud("out",fname_out);
        remove("out");
        printf("CRC-16(%s):%X CRC-16(%s):%X\n",fname_in,crc16(fname_in),fname_out,crc16(fname_out));
        puts("Decoding completed");
    }
 
    return 0;
}