Bit Operation (Message Compression/Decompression)

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

#define UNPACKED_SIZE 160
#define PACKED_SIZE 120

void menu();
void pack();
void unpack();

int main()
{
    
    menu();
    return 0;
}

void unpack()
{
    char UnpackedArray[UNPACKED_SIZE];
    char PackedArray[PACKED_SIZE];
    FILE *packed_file = NULL;
    char Buffer[100];
    char file_name[100];
    int i; int pos; int count = 0;
    int bit[8]; int bit2[8]; int bit3[8];

    printf("Enter the file name:");
    fgets(Buffer,100,stdin);
    sscanf(Buffer,"%s",file_name);
        

    packed_file = fopen(file_name,"rb");
    if(packed_file == NULL)
    {
        printf("packed_file is NULL!\n");
        menu();
        exit(1);
    }

    fread(PackedArray,sizeof(char),PACKED_SIZE,packed_file);
    
    /* bit operation */
    for(i=0;i<UNPACKED_SIZE;i = i+4)
    {
        /* bit represents the bits of the first byte in a 4-bytes unit */    
        bit[0] = (PackedArray[i-count] & 0x01) == 0x01 ? 1:0;
        bit[1] = (PackedArray[i-count] & 0x02) == 0x02 ? 1:0;
        bit[2] = (PackedArray[i-count] & 0x04) == 0x04 ? 1:0;
        bit[3] = (PackedArray[i-count] & 0x08) == 0x08 ? 1:0;
        bit[4] = (PackedArray[i-count] & 0x10) == 0x10 ? 1:0;
        bit[5] = (PackedArray[i-count] & 0x20) == 0x20 ? 1:0;
        bit[6] = (PackedArray[i-count] & 0x40) == 0x40 ? 1:0;
        bit[7] = (PackedArray[i-count] & 0x80) == 0x80 ? 1:0;
        
        /* bit2 represents the bits of the next byte */
        bit2[0] = (PackedArray[i+1-count] & 0x01) == 0x01 ? 1:0;
        bit2[1] = (PackedArray[i+1-count] & 0x02) == 0x02 ? 1:0;
        bit2[2] = (PackedArray[i+1-count] & 0x04) == 0x04 ? 1:0;
        bit2[3] = (PackedArray[i+1-count] & 0x08) == 0x08 ? 1:0;
        bit2[4] = (PackedArray[i+1-count] & 0x10) == 0x10 ? 1:0;
        bit2[5] = (PackedArray[i+1-count] & 0x20) == 0x20 ? 1:0;
        bit2[6] = (PackedArray[i+1-count] & 0x40) == 0x40 ? 1:0;
        bit2[7] = (PackedArray[i+1-count] & 0x80) == 0x80 ? 1:0;

        /* bit3 works the same way as bit2*/
        bit3[0] = (PackedArray[i+2-count] & 0x01) == 0x01 ? 1:0;
        bit3[1] = (PackedArray[i+2-count] & 0x02) == 0x02 ? 1:0;
        bit3[2] = (PackedArray[i+2-count] & 0x04) == 0x04 ? 1:0;
        bit3[3] = (PackedArray[i+2-count] & 0x08) == 0x08 ? 1:0;
        bit3[4] = (PackedArray[i+2-count] & 0x10) == 0x10 ? 1:0;
        bit3[5] = (PackedArray[i+2-count] & 0x20) == 0x20 ? 1:0;
        bit3[6] = (PackedArray[i+2-count] & 0x40) == 0x40 ? 1:0;
        bit3[7] = (PackedArray[i+2-count] & 0x80) == 0x80 ? 1:0;

        UnpackedArray[ i ] = PackedArray[i-count];
        for(pos=7; pos>=6; pos--)
        {
            UnpackedArray[i] &= ~(1<<pos); 
        }


        UnpackedArray[ i+1 ] = ( PackedArray[i+1-count] << 2 );
        for(pos=1; pos>=0; pos--)
        {
            if( bit[ pos+6 ] )
            {
                UnpackedArray[ i+1 ] |= 1<<pos;
            }
            else
            {
                UnpackedArray[ i+1 ] &= ~(1<<pos); 
            }
        }
        for(pos=7; pos>=6; pos--)
        {
            UnpackedArray[ i+1 ] &= ~(1<<pos); 
        }


        UnpackedArray[ i+2 ] = ( PackedArray[i+2-count] << 4 );
        for(pos=3; pos>=0; pos--)
        {
            if(bit2[ pos+4 ])
            {
                UnpackedArray[ i+2 ] |= 1<<pos;
            }
            else
            {
                UnpackedArray[ i+2 ] &= ~(1<<pos); 
            }
        }
        for(pos=7; pos>=6; pos--)
        {
            UnpackedArray[ i+2 ] &= ~(1<<pos); 
        }

        
    
        for(pos=5; pos>=0; pos--)
        {
            if(bit3[ pos+2 ])
            {
                UnpackedArray[ i+3 ] |= 1<<pos;
            }
            else
            {
                UnpackedArray[ i+3 ] &= ~(1<<pos); 
            }
        }
        for(pos=7; pos>=6; pos--)
        {
            UnpackedArray[ i+3 ] &= ~(1<<pos); 
        }

        /* Every time 3 bytes are unpacked to 4 bytes, count will increase 1 */ 
        count++;

    }

    for( i=0; i<strlen(UnpackedArray); i++ )
    {
        UnpackedArray[i] = SMSToChar(UnpackedArray[i]);
    }
    
    printf("The unpacked cstring is:%s \n",UnpackedArray);
    fclose(packed_file);
    menu();
    
}

void pack()
{
    char UnpackedArray[UNPACKED_SIZE];
    char PackedArray[PACKED_SIZE];
    FILE *packed_file = NULL;
    char Buffer[UNPACKED_SIZE+100];
    char file_name[100];
    int i; int pos; int count = 0;
    int bit2[8]; int bit3[8]; int bit4[8];

    printf("Enter the file name to save the packed array:");
    fgets(Buffer,100,stdin);
    sscanf(Buffer,"%s",file_name);
        
    printf("Enter the text to pack:");
    fgets(Buffer,UNPACKED_SIZE+100,stdin);
    if(Buffer[0] == '\n')
    {
        printf("Invalid input: 0 character was entered! \n");
        menu();
        exit(1);
    }
    /* Remove newline character from the input string */
    if(strlen(Buffer) > UNPACKED_SIZE)
    {
        /*It will be truncated to 159 chars and NULL will be placed in the last element */
        Buffer[UNPACKED_SIZE-1] = '\0';
    }
    else
    {
        Buffer[strlen(Buffer)-1] = '\0';
    }

    sscanf(Buffer,"%[^\n]",UnpackedArray);
    /* clean the garbage characters in UnpackedArray */
    for(i=strlen(UnpackedArray);i<UNPACKED_SIZE;i++)
    {
        UnpackedArray[i] = 0;
    }
    
    packed_file = fopen(file_name,"wb");
    if(packed_file == NULL)
    {
        printf("packed_file is NULL!\n");
        menu();
        exit(1);
    }
    
    for(i=0;i<strlen(UnpackedArray);i++)
    {
        UnpackedArray[i] = CharToSMS(UnpackedArray[i]);
    }
    
    /* bit operation */
    for(i=0;i<UNPACKED_SIZE;i = i+4)
    {    
        /* bit2 represents the bits of the second byte in every 4 bytes in the text*/
        bit2[0] = (UnpackedArray[i+1] & 0x01) == 0x01 ? 1:0;
        bit2[1] = (UnpackedArray[i+1] & 0x02) == 0x02 ? 1:0;
        bit2[2] = (UnpackedArray[i+1] & 0x04) == 0x04 ? 1:0;
        bit2[3] = (UnpackedArray[i+1] & 0x08) == 0x08 ? 1:0;
        bit2[4] = (UnpackedArray[i+1] & 0x10) == 0x10 ? 1:0;
        bit2[5] = (UnpackedArray[i+1] & 0x20) == 0x20 ? 1:0;
        bit2[6] = (UnpackedArray[i+1] & 0x40) == 0x40 ? 1:0;
        bit2[7] = (UnpackedArray[i+1] & 0x80) == 0x80 ? 1:0;

        /* bit3 works the same way as bit2*/
        bit3[0] = (UnpackedArray[i+2] & 0x01) == 0x01 ? 1:0;
        bit3[1] = (UnpackedArray[i+2] & 0x02) == 0x02 ? 1:0;
        bit3[2] = (UnpackedArray[i+2] & 0x04) == 0x04 ? 1:0;
        bit3[3] = (UnpackedArray[i+2] & 0x08) == 0x08 ? 1:0;
        bit3[4] = (UnpackedArray[i+2] & 0x10) == 0x10 ? 1:0;
        bit3[5] = (UnpackedArray[i+2] & 0x20) == 0x20 ? 1:0;
        bit3[6] = (UnpackedArray[i+2] & 0x40) == 0x40 ? 1:0;
        bit3[7] = (UnpackedArray[i+2] & 0x80) == 0x80 ? 1:0;

        /* bit4 works the same way as bit3 & bit2*/
        bit4[0] = (UnpackedArray[i+3] & 0x01) == 0x01 ? 1:0;
        bit4[1] = (UnpackedArray[i+3] & 0x02) == 0x02 ? 1:0;
        bit4[2] = (UnpackedArray[i+3] & 0x04) == 0x04 ? 1:0;
        bit4[3] = (UnpackedArray[i+3] & 0x08) == 0x08 ? 1:0;
        bit4[4] = (UnpackedArray[i+3] & 0x10) == 0x10 ? 1:0;
        bit4[5] = (UnpackedArray[i+3] & 0x20) == 0x20 ? 1:0;
        bit4[6] = (UnpackedArray[i+3] & 0x40) == 0x40 ? 1:0;
        bit4[7] = (UnpackedArray[i+3] & 0x80) == 0x80 ? 1:0;

        PackedArray[ i-count ] = UnpackedArray[i];
        for(pos=7; pos>=6; pos--)
        {             
            if( bit2[ pos-6 ] )
            {
                PackedArray[ i-count ] |= 1<<pos;
            }
            else
            {
                PackedArray[ i-count ] &= ~(1<<pos); 
            }
        }

        PackedArray[ i+1-count ] = ( UnpackedArray[i+1] >> 2 );
        for(pos=7; pos>=4; pos--)
        {             
            if( bit3[ pos-4 ] )
            {
                PackedArray[ i+1-count ] |= 1<<pos;
            }
            else
            {
                PackedArray[ i+1-count ] &= ~(1<<pos); 
            }
        }

        PackedArray[ i+2-count ] = ( UnpackedArray[i+2] >> 4 );
        for(pos=7; pos>=2; pos--)
        {             
            if( bit4[ pos-2 ] )
            {
                PackedArray[ i+2-count ] |= 1<<pos;
            }
            else
            {
                PackedArray[ i+2-count ] &= ~(1<<pos); 
            }
        }

        /* Every time 4 bytes are packed to 3 bytes, count will increase 1 */ 
        count++;

    }

    for(i=strlen(PackedArray);i<PACKED_SIZE;i++)
    {
        PackedArray[i] = 0;    
    }


    for(i=0;i<PACKED_SIZE;i++)
    {
        fwrite(&PackedArray[i],sizeof(char),1,packed_file);
    }
    fclose(packed_file);

    menu();    
}

void menu()
{
    char Buffer[1024];
    char choice ;

    printf("Enter P or p: Pack and save a line of text \n");
    printf("Enter U or u: Unpack and print a line of text  \n");
    printf("Enter Q or q: Quit \n");
    printf("Enter your choice: ");
    
    fgets(Buffer,1024,stdin);
    sscanf(Buffer,"%c",&choice);

    if(choice == 'P' || choice == 'p')
    {
        pack();        
    }
    else if(choice == 'U' || choice == 'u')
    {
        unpack();
    }
    else if(choice == 'Q' || choice == 'q')
    {
        printf("Program Exited. \n");        
    }
    else
    {
        menu();
    }
    

}