SimpleCompressor/compress.c at master · ggolish/SimpleCompressor · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
#include "compress.h"

// #define DEBUG_HEADER

static char *split_suffix(char *s);
static HEADER *make_header();
static void read_header(HEADER *hdr, char *f1, char *f2);

void compress_456(char *file_name)
{
    HEADER *hdr;
    byte_t buffer[BUFFSIZE];
    char target[BUFFSIZE];
    char temp2[BUFFSIZE];
    char temp[BUFFSIZE];
    int fd, td, num_bytes;

    hdr = make_header();

    sprintf(target, "%s.%s", file_name, "456");
    sprintf(temp, "%s.%s", file_name, "mtf");
    sprintf(temp2, "%s.%s", temp, "huff");

    mtf_encode(file_name, temp);
    hdr->lastbits = huffmanEncode(temp, temp2, hdr->lengths);

    fd = open(target, O_WRONLY | O_CREAT, 0644);
    write(fd, hdr, sizeof(HEADER));

    td = open(temp2, O_RDONLY);
    for(;;) {
        if((num_bytes = read(td, buffer, BUFFSIZE)) <= 0)
            break;
        write(fd, buffer, num_bytes);
    }

    close(fd);
    close(td);

    unlink(temp);
    unlink(temp2);
    unlink(file_name);

    free(hdr);
}

void decompress_456(char *file_name)
{
    HEADER *hdr;
    char *target;
    char temp[BUFFSIZE];
    char temp2[BUFFSIZE];
    byte_t magic[] = {4, 5, 6};

    target = split_suffix(file_name);
    sprintf(temp, "%s.%s", target, "huff");
    sprintf(temp2, "%s.%s", target, "mtf");

    hdr = (HEADER *)malloc(sizeof(HEADER));
    read_header(hdr, file_name, temp);

    if(memcmp(magic, hdr->magic, MAGICNUM) != 0) {
       fprintf(stderr, "%s: file not compress456 encoded!\n", file_name);
       free(hdr);
       free(target);
       unlink(temp);
       exit(0);
    }

    #ifdef DEBUG_HEADER
        int i;

        printf("Magic number: ");
        for(i = 0; i < MAGICNUM; i++)
            printf("%d ", hdr->magic[i]);
        printf("\n");
        printf("Last bits: %d\n", hdr->lastbits);
        printf("Lengths:\n");
        for(i = 0; i < ASCIIMAX; i++)
            printf("%3d: %d\n", i, hdr->lengths[i]);
    #endif

    huffmanDecode(temp, temp2, hdr->lengths, hdr->lastbits);
    free(hdr);
    mtf_decode(temp2, target);
    free(target);

    unlink(temp);
    unlink(temp2);
    unlink(file_name);
}

static void read_header(HEADER *hdr, char *f1, char *f2)
{
    byte_t buffer[BUFFSIZE];
    int fd_read, fd_write, n;

    fd_read = open(f1, O_RDONLY);
    fd_write = open(f2, O_WRONLY | O_CREAT, 0644);

    read(fd_read, hdr, sizeof(HEADER));
    for(;;) {
        n = read(fd_read, buffer, BUFFSIZE);
        if(n <= 0)
            break;
        write(fd_write, buffer, n);
    }

    close(fd_read);
    close(fd_write);

}

static char *split_suffix(char *s)
{
    char *t, *r;

    r = strdup(s);
    if((t = strrchr(r, '.')) != NULL)
        *t = 0;
    return r;
}

static HEADER *make_header()
{
    HEADER *tmp;
    int i;

    tmp = (HEADER *)malloc(sizeof(HEADER));
    tmp->magic[0] = 0x4;
    tmp->magic[1] = 0x5;
    tmp->magic[2] = 0x6;
    tmp->lastbits = 0;
    for(i = 0; i < ASCIIMAX; i++)
        tmp->lengths[i] = 0;

    return tmp;
}