opencv

1
/*
2
 * Copyright (c) 1988-1997 Sam Leffler
3
 * Copyright (c) 1991-1997 Silicon Graphics, Inc.
4
 *
5
 * Permission to use, copy, modify, distribute, and sell this software and
6
 * its documentation for any purpose is hereby granted without fee, provided
7
 * that (i) the above copyright notices and this permission notice appear in
8
 * all copies of the software and related documentation, and (ii) the names of
9
 * Sam Leffler and Silicon Graphics may not be used in any advertising or
10
 * publicity relating to the software without the specific, prior written
11
 * permission of Sam Leffler and Silicon Graphics.
12
 *
13
 * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
14
 * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
15
 * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
16
 *
17
 * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
18
 * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
19
 * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
20
 * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
21
 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
22
 * OF THIS SOFTWARE.
23
 */
24

25
#include "tiffiop.h"
26
#ifdef PACKBITS_SUPPORT
27
/*
28
 * TIFF Library.
29
 *
30
 * PackBits Compression Algorithm Support
31
 */
32
#include <stdio.h>
33

34
static int PackBitsPreEncode(TIFF *tif, uint16_t s)
35
{
36
    (void)s;
37

38
    tif->tif_data = (uint8_t *)_TIFFmallocExt(tif, sizeof(tmsize_t));
39
    if (tif->tif_data == NULL)
40
        return (0);
41
    /*
42
     * Calculate the scanline/tile-width size in bytes.
43
     */
44
    if (isTiled(tif))
45
        *(tmsize_t *)tif->tif_data = TIFFTileRowSize(tif);
46
    else
47
        *(tmsize_t *)tif->tif_data = TIFFScanlineSize(tif);
48
    return (1);
49
}
50

51
static int PackBitsPostEncode(TIFF *tif)
52
{
53
    if (tif->tif_data)
54
        _TIFFfreeExt(tif, tif->tif_data);
55
    return (1);
56
}
57

58
/*
59
 * Encode a run of pixels.
60
 */
61
static int PackBitsEncode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s)
62
{
63
    unsigned char *bp = (unsigned char *)buf;
64
    uint8_t *op;
65
    uint8_t *ep;
66
    uint8_t *lastliteral;
67
    long n, slop;
68
    int b;
69
    enum
70
    {
71
        BASE,
72
        LITERAL,
73
        RUN,
74
        LITERAL_RUN
75
    } state;
76

77
    (void)s;
78
    op = tif->tif_rawcp;
79
    ep = tif->tif_rawdata + tif->tif_rawdatasize;
80
    state = BASE;
81
    lastliteral = 0;
82
    while (cc > 0)
83
    {
84
        /*
85
         * Find the longest string of identical bytes.
86
         */
87
        b = *bp++;
88
        cc--;
89
        n = 1;
90
        for (; cc > 0 && b == *bp; cc--, bp++)
91
            n++;
92
    again:
93
        if (op + 2 >= ep)
94
        { /* insure space for new data */
95
            /*
96
             * Be careful about writing the last
97
             * literal.  Must write up to that point
98
             * and then copy the remainder to the
99
             * front of the buffer.
100
             */
101
            if (state == LITERAL || state == LITERAL_RUN)
102
            {
103
                slop = (long)(op - lastliteral);
104
                tif->tif_rawcc += (tmsize_t)(lastliteral - tif->tif_rawcp);
105
                if (!TIFFFlushData1(tif))
106
                    return (0);
107
                op = tif->tif_rawcp;
108
                while (slop-- > 0)
109
                    *op++ = *lastliteral++;
110
                lastliteral = tif->tif_rawcp;
111
            }
112
            else
113
            {
114
                tif->tif_rawcc += (tmsize_t)(op - tif->tif_rawcp);
115
                if (!TIFFFlushData1(tif))
116
                    return (0);
117
                op = tif->tif_rawcp;
118
            }
119
        }
120
        switch (state)
121
        {
122
            case BASE: /* initial state, set run/literal */
123
                if (n > 1)
124
                {
125
                    state = RUN;
126
                    if (n > 128)
127
                    {
128
                        *op++ = (uint8_t)-127;
129
                        *op++ = (uint8_t)b;
130
                        n -= 128;
131
                        goto again;
132
                    }
133
                    *op++ = (uint8_t)(-(n - 1));
134
                    *op++ = (uint8_t)b;
135
                }
136
                else
137
                {
138
                    lastliteral = op;
139
                    *op++ = 0;
140
                    *op++ = (uint8_t)b;
141
                    state = LITERAL;
142
                }
143
                break;
144
            case LITERAL: /* last object was literal string */
145
                if (n > 1)
146
                {
147
                    state = LITERAL_RUN;
148
                    if (n > 128)
149
                    {
150
                        *op++ = (uint8_t)-127;
151
                        *op++ = (uint8_t)b;
152
                        n -= 128;
153
                        goto again;
154
                    }
155
                    *op++ = (uint8_t)(-(n - 1)); /* encode run */
156
                    *op++ = (uint8_t)b;
157
                }
158
                else
159
                { /* extend literal */
160
                    if (++(*lastliteral) == 127)
161
                        state = BASE;
162
                    *op++ = (uint8_t)b;
163
                }
164
                break;
165
            case RUN: /* last object was run */
166
                if (n > 1)
167
                {
168
                    if (n > 128)
169
                    {
170
                        *op++ = (uint8_t)-127;
171
                        *op++ = (uint8_t)b;
172
                        n -= 128;
173
                        goto again;
174
                    }
175
                    *op++ = (uint8_t)(-(n - 1));
176
                    *op++ = (uint8_t)b;
177
                }
178
                else
179
                {
180
                    lastliteral = op;
181
                    *op++ = 0;
182
                    *op++ = (uint8_t)b;
183
                    state = LITERAL;
184
                }
185
                break;
186
            case LITERAL_RUN: /* literal followed by a run */
187
                /*
188
                 * Check to see if previous run should
189
                 * be converted to a literal, in which
190
                 * case we convert literal-run-literal
191
                 * to a single literal.
192
                 */
193
                if (n == 1 && op[-2] == (uint8_t)-1 && *lastliteral < 126)
194
                {
195
                    state = (((*lastliteral) += 2) == 127 ? BASE : LITERAL);
196
                    op[-2] = op[-1]; /* replicate */
197
                }
198
                else
199
                    state = RUN;
200
                goto again;
201
        }
202
    }
203
    tif->tif_rawcc += (tmsize_t)(op - tif->tif_rawcp);
204
    tif->tif_rawcp = op;
205
    return (1);
206
}
207

208
/*
209
 * Encode a rectangular chunk of pixels.  We break it up
210
 * into row-sized pieces to insure that encoded runs do
211
 * not span rows.  Otherwise, there can be problems with
212
 * the decoder if data is read, for example, by scanlines
213
 * when it was encoded by strips.
214
 */
215
static int PackBitsEncodeChunk(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
216
{
217
    tmsize_t rowsize = *(tmsize_t *)tif->tif_data;
218

219
    while (cc > 0)
220
    {
221
        tmsize_t chunk = rowsize;
222

223
        if (cc < chunk)
224
            chunk = cc;
225

226
        if (PackBitsEncode(tif, bp, chunk, s) < 0)
227
            return (-1);
228
        bp += chunk;
229
        cc -= chunk;
230
    }
231
    return (1);
232
}
233

234
static int PackBitsDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
235
{
236
    static const char module[] = "PackBitsDecode";
237
    int8_t *bp;
238
    tmsize_t cc;
239
    long n;
240
    int b;
241

242
    (void)s;
243
    bp = (int8_t *)tif->tif_rawcp;
244
    cc = tif->tif_rawcc;
245
    while (cc > 0 && occ > 0)
246
    {
247
        n = (long)*bp++;
248
        cc--;
249
        if (n < 0)
250
        {                  /* replicate next byte -n+1 times */
251
            if (n == -128) /* nop */
252
                continue;
253
            n = -n + 1;
254
            if (occ < (tmsize_t)n)
255
            {
256
                TIFFWarningExtR(tif, module,
257
                                "Discarding %" TIFF_SSIZE_FORMAT
258
                                " bytes to avoid buffer overrun",
259
                                (tmsize_t)n - occ);
260
                n = (long)occ;
261
            }
262
            if (cc == 0)
263
            {
264
                TIFFWarningExtR(
265
                    tif, module,
266
                    "Terminating PackBitsDecode due to lack of data.");
267
                break;
268
            }
269
            occ -= n;
270
            b = *bp++;
271
            cc--;
272
            while (n-- > 0)
273
                *op++ = (uint8_t)b;
274
        }
275
        else
276
        { /* copy next n+1 bytes literally */
277
            if (occ < (tmsize_t)(n + 1))
278
            {
279
                TIFFWarningExtR(tif, module,
280
                                "Discarding %" TIFF_SSIZE_FORMAT
281
                                " bytes to avoid buffer overrun",
282
                                (tmsize_t)n - occ + 1);
283
                n = (long)occ - 1;
284
            }
285
            if (cc < (tmsize_t)(n + 1))
286
            {
287
                TIFFWarningExtR(
288
                    tif, module,
289
                    "Terminating PackBitsDecode due to lack of data.");
290
                break;
291
            }
292
            _TIFFmemcpy(op, bp, ++n);
293
            op += n;
294
            occ -= n;
295
            bp += n;
296
            cc -= n;
297
        }
298
    }
299
    tif->tif_rawcp = (uint8_t *)bp;
300
    tif->tif_rawcc = cc;
301
    if (occ > 0)
302
    {
303
        TIFFErrorExtR(tif, module, "Not enough data for scanline %" PRIu32,
304
                      tif->tif_row);
305
        return (0);
306
    }
307
    return (1);
308
}
309

310
int TIFFInitPackBits(TIFF *tif, int scheme)
311
{
312
    (void)scheme;
313
    tif->tif_decoderow = PackBitsDecode;
314
    tif->tif_decodestrip = PackBitsDecode;
315
    tif->tif_decodetile = PackBitsDecode;
316
    tif->tif_preencode = PackBitsPreEncode;
317
    tif->tif_postencode = PackBitsPostEncode;
318
    tif->tif_encoderow = PackBitsEncode;
319
    tif->tif_encodestrip = PackBitsEncodeChunk;
320
    tif->tif_encodetile = PackBitsEncodeChunk;
321
    return (1);
322
}
323
#endif /* PACKBITS_SUPPORT */
324