Pokaż wyniki 1 do 2 z 2

Temat: kodowanie slownikowe implementacja w C

  1. #1
    Zarejestrowany
    Dec 2006
    Postów
    726

    Domyślnie kodowanie slownikowe implementacja w C

    próbował moze ktoś kiedys zaimplementować metode slownikowa w C? bo potrzebował bym troche pomocy.
    "dobrzy hakerzy są sławni na cały świat, ale o hakerach geniuszach nikt nic nie wie."

  2. #2
    Zarejestrowany
    Dec 2006
    Postów
    726

    Domyślnie

    Moze komuś sie przyda, metoda lz77:

    Kod php:
    #include<stdlib.h>
    #include<conio.h>
    #include<stdio.h>
    #include<string.h>


    #ifndef BIT_H
    #define BIT_H
    #define            LZ77_TYPE_BITS        1
    #define            LZ77_WINOFF_BITS     12
    #define            LZ77_BUFLEN_BITS      5
    #define            LZ77_NEXT_BITS        8
    #define            LZ77_WINDOW_SIZE   4096
    #define            LZ77_BUFFER_SIZE     32
    #define            LZ77_PHRASE_BITS      (LZ77_TYPE_BITS+LZ77_WINOFF_BITS+LZ77_NEXT_BITS+LZ77_BUFLEN_BITS)
    #define            LZ77_SYMBOL_BITS      (LZ77_TYPE_BITS+LZ77_NEXT_BITS)

    int bit_get(const unsigned char *bitsint pos);

    void bit_set(unsigned char *bitsint posint state);




    int lz77_compress(const unsigned char *originalunsigned char **compressed,int size);

    int lz77_uncompress(const unsigned char *compressedunsigned char**original);

    inline unsigned long htonl(unsigned long n)
    {
      return ((
    0xFF) << 24) | ((0xFF00) << 8) | ((0xFF0000) >> 8) | ((0xFF000000) >> 24);
    }

    inline unsigned long ntohl(unsigned long n)
    {
      return ((
    0xFF) << 24) | ((0xFF00) << 8) | ((0xFF0000) >> 8) | ((0xFF000000) >> 24);
    }

    #endif










    int bit_get(const unsigned char *bitsint pos
    {

    unsigned char      mask;

    int                i;



    mask 0x80;

    for (
    0< (pos 8); i++)
       
    mask mask >> 1;



    return (((
    mask bits[(int)(pos 8)]) == mask) ? 0);

    }



    void bit_set(unsigned char *bitsint posint state
    {

    unsigned char      mask;

    int                i;



    mask 0x80;

    for (
    0< (pos 8); i++)
       
    mask mask >> 1;



    if (
    state)
       
    bits[pos 8] = bits[pos 8] | mask;
    else
       
    bits[pos 8] = bits[pos 8] & (~mask);

    return;

    }



     



    static 
    int compare_win(const unsigned char *window, const unsigned char
       

    *bufferint *offsetunsigned char *next
    {

    int                match,
                       
    longest,
                       
    i,
                       
    j,
                       
    k;

    *
    offset 0;
    longest 0;
    *
    next buffer[0];

        for (
    0LZ77_WINDOW_SIZEk++) {

       
    k;
       
    0;
       
    match 0;

       while (
    LZ77_WINDOW_SIZE && LZ77_BUFFER_SIZE 1
       {
          if (
    window[i] != buffer[j])
             {
              break;
             }
          
    match++;
          
    i++;
          
    j++;

       }

       if (
    match longest
       {

          *
    offset k;
          
    longest match;
          *
    next buffer[j];
       }

    }

    return 
    longest;

    }


    int lz77_compress(const unsigned char *originalunsigned char **compressed,
       
    int size
       {

    unsigned long      token;

    unsigned char      window[LZ77_WINDOW_SIZE],
                       
    buffer[LZ77_BUFFER_SIZE],
                       *
    comp,
                       *
    temp,
                       
    next;

    int                offset,
                       
    length,
                       
    remaining,
                       
    tbits,
                       
    hsize,
                       
    ipos,
                       
    opos,
                       
    tpos,
                       
    i;


    *
    compressed NULL;

    hsize sizeof(int);

    if ((
    comp = (unsigned char *)malloc(hsize)) == NULL)
       return -
    1;

    memcpy(comp, &sizesizeof(int));


    memset(window0LZ77_WINDOW_SIZE);
    memset(buffer0LZ77_BUFFER_SIZE);


    ipos 0;

    for (
    0LZ77_BUFFER_SIZE && ipos sizei++) 
    {

       
    buffer[i] = original[ipos];
       
    ipos++;

    }


    opos hsize 8;
    remaining size;

    while (
    remaining 0
    {

       if ((
    length compare_win(windowbuffer, &offset, &next)) != 0
       {

          
    token 0x00000001 << (LZ77_PHRASE_BITS 1);

          
    token token | (offset << (LZ77_PHRASE_BITS LZ77_TYPE_BITS -
             
    LZ77_WINOFF_BITS));

          
    token token | (length << (LZ77_PHRASE_BITS LZ77_TYPE_BITS -
             
    LZ77_WINOFF_BITS LZ77_BUFLEN_BITS));

          
    token token next;

          
    tbits LZ77_PHRASE_BITS;
          
          }

       else 
       {

          
    token 0x00000000;


          
    token token next;


          
    tbits LZ77_SYMBOL_BITS;

       }


       
    token htonl(token);


       for (
    0tbitsi++) 
       {

          if (
    opos == 0
          {


             if ((
    temp = (unsigned char *)realloc(comp,(opos 8) + 1)) == NULL) {

                
    free(comp);
                return -
    1;

             }

             
    comp temp;

          }

          
    tpos = (sizeof(unsigned long) * 8) - tbits i;
          
    bit_set(compoposbit_get((unsigned char *)&tokentpos));
          
    opos++;

       }


       
    length++;
          

       
    memmove(&window[0], &window[length], LZ77_WINDOW_SIZE length);
       
    memmove(&window[LZ77_WINDOW_SIZE length], &buffer[0], length);


       
    memmove(&buffer[0], &buffer[length], LZ77_BUFFER_SIZE length);

       for (
    LZ77_BUFFER_SIZE lengthi<LZ77_BUFFER_SIZE && ipos<sizei++) 
       {

          
    buffer[i] = original[ipos];
          
    ipos++;

       }


       
    remaining remaining length;

    }


    *
    compressed comp;

    return ((
    opos 1) / 8) + 1;

    }


    int lz77_uncompress(const unsigned char *compressedunsigned char
       
    **original) {

    unsigned char    window[LZ77_WINDOW_SIZE];
    unsigned char    buffer[LZ77_BUFFER_SIZE];
    unsigned char    *orig;
    unsigned char    *temp;
    unsigned char    next;



    int       offset;
    int       length;
    int       remaining;
    int       hsize;
    int       size;
    int       ipos;
    int       opos;
    int       tpos;
    int       state;
    int       i;


    *
    original orig NULL;


    hsize sizeof(int);
    memcpy(&sizecompressedsizeof(int));


    memset(window0LZ77_WINDOW_SIZE);
    memset(buffer0LZ77_BUFFER_SIZE);

    ipos hsize 8;
    opos 0;
    remaining size;

    while (
    remaining 0
    {


       
    state bit_get(compressedipos);
       
    ipos++;

       if (
    state == 1
       {


          
    memset(&offset0sizeof(int));

          for (
    0LZ77_WINOFF_BITSi++) 
          {

             
    tpos = (sizeof(int) * 8) - LZ77_WINOFF_BITS i;
             
    bit_set((unsigned char *)&offsettposbit_get(compressedipos));
             
    ipos++;

          }

          
    memset(&length0sizeof(int));

          for (
    0LZ77_BUFLEN_BITSi++) 
          {

             
    tpos = (sizeof(int) * 8) - LZ77_BUFLEN_BITS i;
             
    bit_set((unsigned char *)&lengthtposbit_get(compressedipos));
             
    ipos++;

          }

          
    next 0x00;

          for (
    0LZ77_NEXT_BITSi++) 
          {

             
    tpos = (sizeof(unsigned char) * 8) - LZ77_NEXT_BITS i;
             
    bit_set((unsigned char *)&nexttposbit_get(compressedipos));
             
    ipos++;

          }


          
    offset ntohl(offset);
          
    length ntohl(length);


          
    0;

          if (
    opos 0
          {

             if ((
    temp = (unsigned char *)realloc(origopos+length+1)) == NULL
             {

                
    free(orig);
                return -
    1;

             }

             
    orig temp;

           }

          else 
          {

             if ((
    orig = (unsigned char *)malloc(length 1)) == NULL)
                return -
    1;

          }

          while (
    length && remaining 0
          {

             
    orig[opos] = window[offset i];
             
    opos++;


             
    buffer[i] = window[offset i];
             
    i++;


             
    remaining--;

          }


          if (
    remaining 0
          {

             
    orig[opos] = next;
             
    opos++;


             
    buffer[i] = next;


             
    remaining--;

          }


          
    length++;

          }

       else 
       {


          
    next 0x00;

          for (
    0LZ77_NEXT_BITSi++) 
          {

             
    tpos = (sizeof(unsigned char) * 8) - LZ77_NEXT_BITS i;
             
    bit_set((unsigned char *)&nexttposbit_get(compressedipos));
             
    ipos++;

          }


          if (
    opos 0
          {

             if ((
    temp = (unsigned char *)realloc(origopos 1)) == NULL
             {

                
    free(orig);
                return -
    1;

             }

             
    orig temp;

             }

          else 
          {

             if ((
    orig = (unsigned char *)malloc(1)) == NULL)
                return -
    1;

          }

          
    orig[opos] = next;
          
    opos++;


          if (
    remaining 0)
             
    buffer[0] = next;


          
    remaining--;


          
    length 1;

       }


       
    memmove(&window[0], &window[length], LZ77_WINDOW_SIZE length);
       
    memmove(&window[LZ77_WINDOW_SIZE length], &buffer[0], length);

    }


    *
    original orig;


    return 
    opos;

    }

    FILE *plik1,
         *
    plik2;

    int main(int argcchar *argv[])
    {
        
    int i=0;
        
    int destlen;
        
    unsigned char *compressed;
        
    unsigned char *original;
        
    char *z;
        
    fpos_t dlugosc;
        
     
        if (
    argc != 4)
        {
            
    printf("program kompresja/dekompresja metoda slownikowa:");
            
    getch();
            return 
    1;
        }
        if ((
    argv[1], z[1] || strpbrk(z"DKdk") == NULL)
         || (
    argv[2], (plik1  fopen(z"rb")) == NULL)
         || (
    argv[3], (plik2 fopen(z"wb")) == NULL)) {
            
    printf("Blad");  return -1;
        }

    fseek (plik10SEEK_END); 
    fgetpos (plik1, &dlugosc);

    unsigned char window2[dlugosc];

    fseek(plik10SEEK_SET); 
    fread(window2sizeof(char), dlugoscplik1);

        
        if (
    toupper(*argv[1]) == 'K')
        {
            
    printf("trwa kompresja....");
            
            
    destlen lz77_compress((char*)window2,&compresseddlugosc);
            
            
    fwrite(compressedsizeof(char), destlenplik2);    
                
    }
        else
        {
            
    printf("trwa dekompresja....");
            
    destlen=lz77_uncompress((char*)window2, &original);
            
    fwrite(originalsizeof(char), destlenplik2);
        }
        
        
        
    fclose(plik1);
        
    fclose(plik2);
        
        return 
    0;

    Ostatnio edytowane przez kosiarz : 06-24-2009 - 23:11
    "dobrzy hakerzy są sławni na cały świat, ale o hakerach geniuszach nikt nic nie wie."

Podobne wątki

  1. Kodowanie pakietów
    By sebeq8912 in forum Hacking
    Odpowiedzi: 10
    Autor: 04-29-2009, 18:35
  2. Kodowanie hoffmana
    By ogre in forum Matematyka/Liczby/Kody/Teoria Chaosu
    Odpowiedzi: 4
    Autor: 11-12-2008, 02:15
  3. Odpowiedzi: 12
    Autor: 08-01-2007, 22:28
  4. kodowanie.. pomocy!!!
    By Agusia in forum C/C++
    Odpowiedzi: 0
    Autor: 10-25-2006, 12:18

Zasady Postowania

  • Nie możesz zakładać nowych tematów
  • Nie możesz pisać wiadomości
  • Nie możesz dodawać załączników
  • Nie możesz edytować swoich postów
  •  
Subskrybuj