Coverage Report

Created: 2023-09-25 06:16

/src/lzo-2.10/src/lzo1b_r.ch
Line
Count
Source
1
/* lzo1b_r.ch -- literal run handling for the the LZO1B/LZO1C algorithm
2
3
   This file is part of the LZO real-time data compression library.
4
5
   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
6
   All Rights Reserved.
7
8
   The LZO library is free software; you can redistribute it and/or
9
   modify it under the terms of the GNU General Public License as
10
   published by the Free Software Foundation; either version 2 of
11
   the License, or (at your option) any later version.
12
13
   The LZO library is distributed in the hope that it will be useful,
14
   but WITHOUT ANY WARRANTY; without even the implied warranty of
15
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
   GNU General Public License for more details.
17
18
   You should have received a copy of the GNU General Public License
19
   along with the LZO library; see the file COPYING.
20
   If not, write to the Free Software Foundation, Inc.,
21
   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
22
23
   Markus F.X.J. Oberhumer
24
   <markus@oberhumer.com>
25
   http://www.oberhumer.com/opensource/lzo/
26
 */
27
28
29
/***********************************************************************
30
// store a literal run (internal)
31
************************************************************************/
32
33
LZO_LOCAL_IMPL(lzo_bytep )
34
STORE_RUN ( lzo_bytep const oo, const lzo_bytep const ii, lzo_uint r_len)
35
165k
{
36
165k
    lzo_bytep op;
37
165k
    const lzo_bytep ip;
38
165k
    lzo_uint t;
39
40
165k
    LZO_STATS(lzo_stats->literals += r_len);
41
42
165k
    op = oo;
43
165k
    ip = ii;
44
165k
    assert(r_len > 0);
45
46
    /* code a long R0 run */
47
165k
    if (r_len >= 512)
48
10.3k
    {
49
10.3k
        unsigned r_bits = 6;        /* 256 << 6 == 16384 */
50
10.3k
        lzo_uint tt = 32768u;
51
52
11.1k
        while (r_len >= (t = tt))
53
803
        {
54
803
            r_len -= t;
55
803
            *op++ = 0; *op++ = (R0FAST - R0MIN) + 7;
56
803
            MEMCPY8_DS(op, ip, t);
57
803
            LZO_STATS(lzo_stats->r0long_runs++);
58
803
        }
59
10.3k
        tt >>= 1;
60
62.0k
        do {
61
62.0k
            if (r_len >= (t = tt))
62
13.8k
            {
63
13.8k
                r_len -= t;
64
13.8k
                *op++ = 0; *op++ = LZO_BYTE((R0FAST - R0MIN) + r_bits);
65
13.8k
                MEMCPY8_DS(op, ip, t);
66
13.8k
                LZO_STATS(lzo_stats->r0long_runs++);
67
13.8k
            }
68
62.0k
            tt >>= 1;
69
62.0k
        } while (--r_bits > 0);
70
10.3k
    }
71
165k
    assert(r_len < 512);
72
73
177k
    while (r_len >= (t = R0FAST))
74
12.5k
    {
75
12.5k
        r_len -= t;
76
12.5k
        *op++ = 0; *op++ = (R0FAST - R0MIN);
77
12.5k
        MEMCPY8_DS(op, ip, t);
78
12.5k
        LZO_STATS(lzo_stats->r0fast_runs++);
79
12.5k
    }
80
81
165k
    t = r_len;
82
165k
    if (t >= R0MIN)
83
35.3k
    {
84
        /* code a short R0 run */
85
35.3k
        *op++ = 0; *op++ = LZO_BYTE(t - R0MIN);
86
35.3k
        MEMCPY_DS(op, ip, t);
87
35.3k
        LZO_STATS(lzo_stats->r0short_runs++);
88
35.3k
    }
89
130k
    else if (t > 0)
90
128k
    {
91
        /* code a short literal run */
92
128k
        LZO_STATS(lzo_stats->lit_runs++);
93
128k
        LZO_STATS(lzo_stats->lit_run[t]++);
94
128k
        *op++ = LZO_BYTE(t);
95
128k
        MEMCPY_DS(op, ip, t);
96
128k
    }
97
98
165k
    return op;
99
165k
}
_lzo1b_store_run
Line
Count
Source
35
93.0k
{
36
93.0k
    lzo_bytep op;
37
93.0k
    const lzo_bytep ip;
38
93.0k
    lzo_uint t;
39
40
93.0k
    LZO_STATS(lzo_stats->literals += r_len);
41
42
93.0k
    op = oo;
43
93.0k
    ip = ii;
44
93.0k
    assert(r_len > 0);
45
46
    /* code a long R0 run */
47
93.0k
    if (r_len >= 512)
48
6.82k
    {
49
6.82k
        unsigned r_bits = 6;        /* 256 << 6 == 16384 */
50
6.82k
        lzo_uint tt = 32768u;
51
52
7.09k
        while (r_len >= (t = tt))
53
267
        {
54
267
            r_len -= t;
55
267
            *op++ = 0; *op++ = (R0FAST - R0MIN) + 7;
56
267
            MEMCPY8_DS(op, ip, t);
57
267
            LZO_STATS(lzo_stats->r0long_runs++);
58
267
        }
59
6.82k
        tt >>= 1;
60
40.9k
        do {
61
40.9k
            if (r_len >= (t = tt))
62
9.00k
            {
63
9.00k
                r_len -= t;
64
9.00k
                *op++ = 0; *op++ = LZO_BYTE((R0FAST - R0MIN) + r_bits);
65
9.00k
                MEMCPY8_DS(op, ip, t);
66
9.00k
                LZO_STATS(lzo_stats->r0long_runs++);
67
9.00k
            }
68
40.9k
            tt >>= 1;
69
40.9k
        } while (--r_bits > 0);
70
6.82k
    }
71
93.0k
    assert(r_len < 512);
72
73
101k
    while (r_len >= (t = R0FAST))
74
8.31k
    {
75
8.31k
        r_len -= t;
76
8.31k
        *op++ = 0; *op++ = (R0FAST - R0MIN);
77
8.31k
        MEMCPY8_DS(op, ip, t);
78
8.31k
        LZO_STATS(lzo_stats->r0fast_runs++);
79
8.31k
    }
80
81
93.0k
    t = r_len;
82
93.0k
    if (t >= R0MIN)
83
25.2k
    {
84
        /* code a short R0 run */
85
25.2k
        *op++ = 0; *op++ = LZO_BYTE(t - R0MIN);
86
25.2k
        MEMCPY_DS(op, ip, t);
87
25.2k
        LZO_STATS(lzo_stats->r0short_runs++);
88
25.2k
    }
89
67.8k
    else if (t > 0)
90
67.0k
    {
91
        /* code a short literal run */
92
67.0k
        LZO_STATS(lzo_stats->lit_runs++);
93
67.0k
        LZO_STATS(lzo_stats->lit_run[t]++);
94
67.0k
        *op++ = LZO_BYTE(t);
95
67.0k
        MEMCPY_DS(op, ip, t);
96
67.0k
    }
97
98
93.0k
    return op;
99
93.0k
}
_lzo1c_store_run
Line
Count
Source
35
72.3k
{
36
72.3k
    lzo_bytep op;
37
72.3k
    const lzo_bytep ip;
38
72.3k
    lzo_uint t;
39
40
72.3k
    LZO_STATS(lzo_stats->literals += r_len);
41
42
72.3k
    op = oo;
43
72.3k
    ip = ii;
44
72.3k
    assert(r_len > 0);
45
46
    /* code a long R0 run */
47
72.3k
    if (r_len >= 512)
48
3.52k
    {
49
3.52k
        unsigned r_bits = 6;        /* 256 << 6 == 16384 */
50
3.52k
        lzo_uint tt = 32768u;
51
52
4.05k
        while (r_len >= (t = tt))
53
536
        {
54
536
            r_len -= t;
55
536
            *op++ = 0; *op++ = (R0FAST - R0MIN) + 7;
56
536
            MEMCPY8_DS(op, ip, t);
57
536
            LZO_STATS(lzo_stats->r0long_runs++);
58
536
        }
59
3.52k
        tt >>= 1;
60
21.1k
        do {
61
21.1k
            if (r_len >= (t = tt))
62
4.85k
            {
63
4.85k
                r_len -= t;
64
4.85k
                *op++ = 0; *op++ = LZO_BYTE((R0FAST - R0MIN) + r_bits);
65
4.85k
                MEMCPY8_DS(op, ip, t);
66
4.85k
                LZO_STATS(lzo_stats->r0long_runs++);
67
4.85k
            }
68
21.1k
            tt >>= 1;
69
21.1k
        } while (--r_bits > 0);
70
3.52k
    }
71
72.3k
    assert(r_len < 512);
72
73
76.5k
    while (r_len >= (t = R0FAST))
74
4.20k
    {
75
4.20k
        r_len -= t;
76
4.20k
        *op++ = 0; *op++ = (R0FAST - R0MIN);
77
4.20k
        MEMCPY8_DS(op, ip, t);
78
4.20k
        LZO_STATS(lzo_stats->r0fast_runs++);
79
4.20k
    }
80
81
72.3k
    t = r_len;
82
72.3k
    if (t >= R0MIN)
83
10.0k
    {
84
        /* code a short R0 run */
85
10.0k
        *op++ = 0; *op++ = LZO_BYTE(t - R0MIN);
86
10.0k
        MEMCPY_DS(op, ip, t);
87
10.0k
        LZO_STATS(lzo_stats->r0short_runs++);
88
10.0k
    }
89
62.2k
    else if (t > 0)
90
61.7k
    {
91
        /* code a short literal run */
92
61.7k
        LZO_STATS(lzo_stats->lit_runs++);
93
61.7k
        LZO_STATS(lzo_stats->lit_run[t]++);
94
61.7k
        *op++ = LZO_BYTE(t);
95
61.7k
        MEMCPY_DS(op, ip, t);
96
61.7k
    }
97
98
72.3k
    return op;
99
72.3k
}
100
101
102
/* vim:set ts=4 sw=4 et: */