File: compress.c

package info (click to toggle)
libpuzzle 0.11-3
  • links: PTS, VCS
  • area: main
  • in suites: bullseye, sid
  • size: 2,092 kB
  • sloc: sh: 9,723; ansic: 1,811; makefile: 977; php: 269; sql: 148
file content (125 lines) | stat: -rw-r--r-- 3,926 bytes parent folder | download | duplicates (7)
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
#include "puzzle_common.h"
#include "puzzle_p.h"
#include "puzzle.h"
#include "globals.h"

void puzzle_init_compressed_cvec(PuzzleContext * const context,
                                 PuzzleCompressedCvec * const compressed_cvec)
{
    (void) context;
    compressed_cvec->sizeof_compressed_vec = (size_t) 0U;
    compressed_cvec->vec = NULL;
}

void puzzle_free_compressed_cvec(PuzzleContext * const context,
                                 PuzzleCompressedCvec * const compressed_cvec)
{
    (void) context;    
    free(compressed_cvec->vec);
    compressed_cvec->vec = NULL;    
}

int puzzle_compress_cvec(PuzzleContext * const context,
                         PuzzleCompressedCvec * const compressed_cvec,
                         const PuzzleCvec * const cvec)
{
#define PC_NM(X) ((unsigned char) ((X) + 2))
    size_t remaining = cvec->sizeof_vec;
    const signed char *ptr;    
    unsigned char *cptr;

    (void) context;
    compressed_cvec->sizeof_compressed_vec =
        (cvec->sizeof_vec + (size_t) 2U) / (size_t) 3U;
    if ((compressed_cvec->vec =
         calloc(compressed_cvec->sizeof_compressed_vec,
                sizeof *compressed_cvec->vec)) == NULL) {
        return -1;
    }
    ptr = cvec->vec;
    cptr = compressed_cvec->vec;
    while (remaining > (size_t) 3U) {
        *cptr++ = PC_NM(ptr[0]) + PC_NM(ptr[1]) * 5U +
            PC_NM(ptr[2]) * (5U * 5U);
        ptr += 3U;
        remaining -= 3U;
    }
    if (remaining == (size_t) 1U) {
        *cptr++ = PC_NM(ptr[0]);
        compressed_cvec->vec[0] |= 128U;
    } else if (remaining == (size_t) 2U) {
        *cptr++ = PC_NM(ptr[0]) + PC_NM(ptr[1]) * 5U;
        if (compressed_cvec->sizeof_compressed_vec < (size_t) 2U) {
            puzzle_err_bug(__FILE__, __LINE__);
        }
        compressed_cvec->vec[1] |= 128U;
    }
    if ((size_t) (cptr - compressed_cvec->vec) !=
        compressed_cvec->sizeof_compressed_vec) {
        puzzle_err_bug(__FILE__, __LINE__);
    }
    return 0;
}

int puzzle_uncompress_cvec(PuzzleContext * const context,
                           const PuzzleCompressedCvec * const compressed_cvec,
                           PuzzleCvec * const cvec)
{
#define PC_FL(X) ((X) & 127U)
#define PC_NP(X) ((signed char) (X) - 2)
    
    size_t remaining;    
    unsigned char trailing_bits;
    const unsigned char *cptr = compressed_cvec->vec;
    signed char *ptr;
    unsigned char c;

    (void) context;
    if (cvec->vec != NULL) {
        puzzle_err_bug(__FILE__, __LINE__);
    }
    if ((remaining = compressed_cvec->sizeof_compressed_vec) < (size_t) 2U) {
        puzzle_err_bug(__FILE__, __LINE__);
    }
    trailing_bits = ((cptr[0] & 128U) >> 7) | ((cptr[1] & 128U) >> 6);
    if (trailing_bits > 2U) {
        puzzle_err_bug(__FILE__, __LINE__);
    }
    cvec->sizeof_vec = (size_t) 3U *
        (compressed_cvec->sizeof_compressed_vec - trailing_bits) +
        trailing_bits;
    if (compressed_cvec->sizeof_compressed_vec >
        SIZE_MAX / (size_t) 3U - (size_t) 2U) {
        puzzle_err_bug(__FILE__, __LINE__);
    }
    if ((cvec->vec = calloc(cvec->sizeof_vec, sizeof *cvec->vec)) == NULL) {
        return -1;
    }
    if (trailing_bits != 0U) {
        if (remaining <= (size_t) 0U) {
            puzzle_err_bug(__FILE__, __LINE__);
        }
        remaining--;
    }
    ptr = cvec->vec;
    while (remaining > (size_t) 0U) {
        c = PC_FL(*cptr++);
        *ptr++ = PC_NP(c % 5U);
        c /= 5U;
        *ptr++ = PC_NP(c % 5U);
        c /= 5U;
        *ptr++ = PC_NP(c % 5U);
        remaining--;
    }
    if (trailing_bits == 1U) {
        *ptr++ = PC_NP(PC_FL(*cptr) % 5U);        
    } else if (trailing_bits == 2U) {
        c = PC_FL(*cptr);
        *ptr++ = PC_NP(c % 5U);
        *ptr++ = PC_NP(c / 5U % 5U);        
    }
    if ((size_t) (ptr - cvec->vec) != cvec->sizeof_vec) {
        puzzle_err_bug(__FILE__, __LINE__);
    }
    return 0;
}