Coverage Report

Created: 2025-06-10 06:56

/src/ghostpdl/base/srld.c
Line
Count
Source
1
/* Copyright (C) 2001-2023 Artifex Software, Inc.
2
   All Rights Reserved.
3
4
   This software is provided AS-IS with no warranty, either express or
5
   implied.
6
7
   This software is distributed under license and may not be copied,
8
   modified or distributed except as expressly authorized under the terms
9
   of the license contained in the file LICENSE in this distribution.
10
11
   Refer to licensing information at http://www.artifex.com or contact
12
   Artifex Software, Inc.,  39 Mesa Street, Suite 108A, San Francisco,
13
   CA 94129, USA, for further information.
14
*/
15
16
17
/* RunLengthDecode filter */
18
#include "stdio_.h"   /* includes std.h */
19
#include "memory_.h"
20
#include "strimpl.h"
21
#include "srlx.h"
22
23
/* ------ RunLengthDecode ------ */
24
25
private_st_RLD_state();
26
27
/* Set defaults */
28
static void
29
s_RLD_set_defaults(stream_state * st)
30
7
{
31
7
    stream_RLD_state *const ss = (stream_RLD_state *) st;
32
33
7
    s_RLD_set_defaults_inline(ss);
34
7
}
35
36
/* Initialize */
37
static int
38
s_RLD_init(stream_state * st)
39
7
{
40
7
    stream_RLD_state *const ss = (stream_RLD_state *) st;
41
42
7
    return s_RLD_init_inline(ss);
43
7
}
44
45
/* Refill the buffer */
46
static int
47
s_RLD_process(stream_state * st, stream_cursor_read * pr,
48
              stream_cursor_write * pw, bool last)
49
44
{
50
44
    stream_RLD_state *const ss = (stream_RLD_state *) st;
51
44
    register const byte *p = pr->ptr;
52
44
    register byte *q = pw->ptr;
53
44
    const byte *rlimit = pr->limit;
54
44
    byte *wlimit = pw->limit;
55
44
    int left;
56
44
    int status = 0;
57
58
66
top:
59
66
    if ((left = ss->copy_left) > 0) {
60
        /*
61
         * We suspended because the output buffer was full:;
62
         * try again now.
63
         */
64
45
        uint avail = wlimit - q;
65
45
        int copy_status = 1;
66
67
45
        if (left > avail)
68
13
            left = avail;
69
45
        if (ss->copy_data >= 0)
70
8
            memset(q + 1, ss->copy_data, left);
71
37
        else {
72
37
            avail = rlimit - p;
73
37
            if (left >= avail) {
74
14
                copy_status = 0;
75
14
                left = avail;
76
14
            }
77
37
            memcpy(q + 1, p + 1, left);
78
37
            p += left;
79
37
        }
80
45
        q += left;
81
45
        if ((ss->copy_left -= left) > 0) {
82
27
            status = copy_status;
83
27
            goto x;
84
27
        }
85
45
    }
86
6.93k
    while (p < rlimit) {
87
6.91k
        int b = *++p;
88
89
6.91k
        if (b < 128) {
90
3.58k
            if (++b > rlimit - p || b > wlimit - q) {
91
18
                ss->copy_left = b;
92
18
                ss->copy_data = -1;
93
18
                goto top;
94
18
            }
95
3.56k
            memcpy(q + 1, p + 1, b);
96
3.56k
            p += b;
97
3.56k
            q += b;
98
3.56k
        } else if (b == 128) { /* end of data */
99
2
            if (ss->EndOfData) {
100
2
                status = EOFC;
101
2
                break;
102
2
            }
103
3.33k
        } else if (p == rlimit) {
104
3
            p--;
105
3
            break;
106
3.32k
        } else if ((b = 257 - b) > wlimit - q) {
107
4
            ss->copy_left = b;
108
4
            ss->copy_data = *++p;
109
4
            goto top;
110
3.32k
        } else {
111
3.32k
            memset(q + 1, *++p, b);
112
3.32k
            q += b;
113
3.32k
        }
114
6.91k
    }
115
44
x:  pr->ptr = p;
116
44
    pw->ptr = q;
117
44
    return status;
118
39
}
119
120
/* Stream template */
121
const stream_template s_RLD_template = {
122
    &st_RLD_state, s_RLD_init, s_RLD_process, 1, 1, NULL,
123
    s_RLD_set_defaults
124
};