opencv

1
/*
2
 * Copyright (c) 2017, Planet Labs
3
 * Author: <even.rouault at spatialys.com>
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 ZSTD_SUPPORT
27
/*
28
 * TIFF Library.
29
 *
30
 * ZSTD Compression Support
31
 *
32
 */
33

34
#include "tif_predict.h"
35
#include "zstd.h"
36

37
#include <stdio.h>
38

39
/*
40
 * State block for each open TIFF file using ZSTD compression/decompression.
41
 */
42
typedef struct
43
{
44
    TIFFPredictorState predict;
45
    ZSTD_DStream *dstream;
46
    ZSTD_CStream *cstream;
47
    int compression_level; /* compression level */
48
    ZSTD_outBuffer out_buffer;
49
    int state; /* state flags */
50
#define LSTATE_INIT_DECODE 0x01
51
#define LSTATE_INIT_ENCODE 0x02
52

53
    TIFFVGetMethod vgetparent; /* super-class method */
54
    TIFFVSetMethod vsetparent; /* super-class method */
55
} ZSTDState;
56

57
#define LState(tif) ((ZSTDState *)(tif)->tif_data)
58
#define DecoderState(tif) LState(tif)
59
#define EncoderState(tif) LState(tif)
60

61
static int ZSTDEncode(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s);
62
static int ZSTDDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s);
63

64
static int ZSTDFixupTags(TIFF *tif)
65
{
66
    (void)tif;
67
    return 1;
68
}
69

70
static int ZSTDSetupDecode(TIFF *tif)
71
{
72
    ZSTDState *sp = DecoderState(tif);
73

74
    assert(sp != NULL);
75

76
    /* if we were last encoding, terminate this mode */
77
    if (sp->state & LSTATE_INIT_ENCODE)
78
    {
79
        ZSTD_freeCStream(sp->cstream);
80
        sp->cstream = NULL;
81
        sp->state = 0;
82
    }
83

84
    sp->state |= LSTATE_INIT_DECODE;
85
    return 1;
86
}
87

88
/*
89
 * Setup state for decoding a strip.
90
 */
91
static int ZSTDPreDecode(TIFF *tif, uint16_t s)
92
{
93
    static const char module[] = "ZSTDPreDecode";
94
    ZSTDState *sp = DecoderState(tif);
95
    size_t zstd_ret;
96

97
    (void)s;
98
    assert(sp != NULL);
99

100
    if ((sp->state & LSTATE_INIT_DECODE) == 0)
101
        tif->tif_setupdecode(tif);
102

103
    if (sp->dstream == NULL)
104
    {
105
        sp->dstream = ZSTD_createDStream();
106
        if (sp->dstream == NULL)
107
        {
108
            TIFFErrorExtR(tif, module, "Cannot allocate decompression stream");
109
            return 0;
110
        }
111
    }
112

113
    zstd_ret = ZSTD_initDStream(sp->dstream);
114
    if (ZSTD_isError(zstd_ret))
115
    {
116
        TIFFErrorExtR(tif, module, "Error in ZSTD_initDStream(): %s",
117
                      ZSTD_getErrorName(zstd_ret));
118
        return 0;
119
    }
120

121
    return 1;
122
}
123

124
static int ZSTDDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
125
{
126
    static const char module[] = "ZSTDDecode";
127
    ZSTDState *sp = DecoderState(tif);
128
    ZSTD_inBuffer in_buffer;
129
    ZSTD_outBuffer out_buffer;
130
    size_t zstd_ret;
131

132
    (void)s;
133
    assert(sp != NULL);
134
    assert(sp->state == LSTATE_INIT_DECODE);
135

136
    in_buffer.src = tif->tif_rawcp;
137
    in_buffer.size = (size_t)tif->tif_rawcc;
138
    in_buffer.pos = 0;
139

140
    out_buffer.dst = op;
141
    out_buffer.size = (size_t)occ;
142
    out_buffer.pos = 0;
143

144
    do
145
    {
146
        zstd_ret = ZSTD_decompressStream(sp->dstream, &out_buffer, &in_buffer);
147
        if (ZSTD_isError(zstd_ret))
148
        {
149
            TIFFErrorExtR(tif, module, "Error in ZSTD_decompressStream(): %s",
150
                          ZSTD_getErrorName(zstd_ret));
151
            return 0;
152
        }
153
    } while (zstd_ret != 0 && in_buffer.pos < in_buffer.size &&
154
             out_buffer.pos < out_buffer.size);
155

156
    if (out_buffer.pos < (size_t)occ)
157
    {
158
        TIFFErrorExtR(tif, module,
159
                      "Not enough data at scanline %lu (short %lu bytes)",
160
                      (unsigned long)tif->tif_row,
161
                      (unsigned long)((size_t)occ - out_buffer.pos));
162
        return 0;
163
    }
164

165
    tif->tif_rawcp += in_buffer.pos;
166
    tif->tif_rawcc -= in_buffer.pos;
167

168
    return 1;
169
}
170

171
static int ZSTDSetupEncode(TIFF *tif)
172
{
173
    ZSTDState *sp = EncoderState(tif);
174

175
    assert(sp != NULL);
176
    if (sp->state & LSTATE_INIT_DECODE)
177
    {
178
        ZSTD_freeDStream(sp->dstream);
179
        sp->dstream = NULL;
180
        sp->state = 0;
181
    }
182

183
    sp->state |= LSTATE_INIT_ENCODE;
184
    return 1;
185
}
186

187
/*
188
 * Reset encoding state at the start of a strip.
189
 */
190
static int ZSTDPreEncode(TIFF *tif, uint16_t s)
191
{
192
    static const char module[] = "ZSTDPreEncode";
193
    ZSTDState *sp = EncoderState(tif);
194
    size_t zstd_ret;
195

196
    (void)s;
197
    assert(sp != NULL);
198
    if (sp->state != LSTATE_INIT_ENCODE)
199
        tif->tif_setupencode(tif);
200

201
    if (sp->cstream == NULL)
202
    {
203
        sp->cstream = ZSTD_createCStream();
204
        if (sp->cstream == NULL)
205
        {
206
            TIFFErrorExtR(tif, module, "Cannot allocate compression stream");
207
            return 0;
208
        }
209
    }
210

211
    zstd_ret = ZSTD_initCStream(sp->cstream, sp->compression_level);
212
    if (ZSTD_isError(zstd_ret))
213
    {
214
        TIFFErrorExtR(tif, module, "Error in ZSTD_initCStream(): %s",
215
                      ZSTD_getErrorName(zstd_ret));
216
        return 0;
217
    }
218

219
    sp->out_buffer.dst = tif->tif_rawdata;
220
    sp->out_buffer.size = (size_t)tif->tif_rawdatasize;
221
    sp->out_buffer.pos = 0;
222

223
    return 1;
224
}
225

226
/*
227
 * Encode a chunk of pixels.
228
 */
229
static int ZSTDEncode(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
230
{
231
    static const char module[] = "ZSTDEncode";
232
    ZSTDState *sp = EncoderState(tif);
233
    ZSTD_inBuffer in_buffer;
234
    size_t zstd_ret;
235

236
    assert(sp != NULL);
237
    assert(sp->state == LSTATE_INIT_ENCODE);
238

239
    (void)s;
240

241
    in_buffer.src = bp;
242
    in_buffer.size = (size_t)cc;
243
    in_buffer.pos = 0;
244

245
    do
246
    {
247
        zstd_ret =
248
            ZSTD_compressStream(sp->cstream, &sp->out_buffer, &in_buffer);
249
        if (ZSTD_isError(zstd_ret))
250
        {
251
            TIFFErrorExtR(tif, module, "Error in ZSTD_compressStream(): %s",
252
                          ZSTD_getErrorName(zstd_ret));
253
            return 0;
254
        }
255
        if (sp->out_buffer.pos == sp->out_buffer.size)
256
        {
257
            tif->tif_rawcc = tif->tif_rawdatasize;
258
            if (!TIFFFlushData1(tif))
259
                return 0;
260
            sp->out_buffer.dst = tif->tif_rawcp;
261
            sp->out_buffer.pos = 0;
262
        }
263
    } while (in_buffer.pos < in_buffer.size);
264

265
    return 1;
266
}
267

268
/*
269
 * Finish off an encoded strip by flushing it.
270
 */
271
static int ZSTDPostEncode(TIFF *tif)
272
{
273
    static const char module[] = "ZSTDPostEncode";
274
    ZSTDState *sp = EncoderState(tif);
275
    size_t zstd_ret;
276

277
    do
278
    {
279
        zstd_ret = ZSTD_endStream(sp->cstream, &sp->out_buffer);
280
        if (ZSTD_isError(zstd_ret))
281
        {
282
            TIFFErrorExtR(tif, module, "Error in ZSTD_endStream(): %s",
283
                          ZSTD_getErrorName(zstd_ret));
284
            return 0;
285
        }
286
        if (sp->out_buffer.pos > 0)
287
        {
288
            tif->tif_rawcc = sp->out_buffer.pos;
289
            if (!TIFFFlushData1(tif))
290
                return 0;
291
            sp->out_buffer.dst = tif->tif_rawcp;
292
            sp->out_buffer.pos = 0;
293
        }
294
    } while (zstd_ret != 0);
295
    return 1;
296
}
297

298
static void ZSTDCleanup(TIFF *tif)
299
{
300
    ZSTDState *sp = LState(tif);
301

302
    assert(sp != 0);
303

304
    (void)TIFFPredictorCleanup(tif);
305

306
    tif->tif_tagmethods.vgetfield = sp->vgetparent;
307
    tif->tif_tagmethods.vsetfield = sp->vsetparent;
308

309
    if (sp->dstream)
310
    {
311
        ZSTD_freeDStream(sp->dstream);
312
        sp->dstream = NULL;
313
    }
314
    if (sp->cstream)
315
    {
316
        ZSTD_freeCStream(sp->cstream);
317
        sp->cstream = NULL;
318
    }
319
    _TIFFfreeExt(tif, sp);
320
    tif->tif_data = NULL;
321

322
    _TIFFSetDefaultCompressionState(tif);
323
}
324

325
static int ZSTDVSetField(TIFF *tif, uint32_t tag, va_list ap)
326
{
327
    static const char module[] = "ZSTDVSetField";
328
    ZSTDState *sp = LState(tif);
329

330
    switch (tag)
331
    {
332
        case TIFFTAG_ZSTD_LEVEL:
333
            sp->compression_level = (int)va_arg(ap, int);
334
            if (sp->compression_level <= 0 ||
335
                sp->compression_level > ZSTD_maxCLevel())
336
            {
337
                TIFFWarningExtR(tif, module,
338
                                "ZSTD_LEVEL should be between 1 and %d",
339
                                ZSTD_maxCLevel());
340
            }
341
            return 1;
342
        default:
343
            return (*sp->vsetparent)(tif, tag, ap);
344
    }
345
    /*NOTREACHED*/
346
}
347

348
static int ZSTDVGetField(TIFF *tif, uint32_t tag, va_list ap)
349
{
350
    ZSTDState *sp = LState(tif);
351

352
    switch (tag)
353
    {
354
        case TIFFTAG_ZSTD_LEVEL:
355
            *va_arg(ap, int *) = sp->compression_level;
356
            break;
357
        default:
358
            return (*sp->vgetparent)(tif, tag, ap);
359
    }
360
    return 1;
361
}
362

363
static const TIFFField ZSTDFields[] = {
364
    {TIFFTAG_ZSTD_LEVEL, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT,
365
     TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, TRUE, FALSE, "ZSTD compression_level",
366
     NULL},
367
};
368

369
int TIFFInitZSTD(TIFF *tif, int scheme)
370
{
371
    static const char module[] = "TIFFInitZSTD";
372
    ZSTDState *sp;
373

374
    (void)scheme;
375
    assert(scheme == COMPRESSION_ZSTD);
376

377
    /*
378
     * Merge codec-specific tag information.
379
     */
380
    if (!_TIFFMergeFields(tif, ZSTDFields, TIFFArrayCount(ZSTDFields)))
381
    {
382
        TIFFErrorExtR(tif, module, "Merging ZSTD codec-specific tags failed");
383
        return 0;
384
    }
385

386
    /*
387
     * Allocate state block so tag methods have storage to record values.
388
     */
389
    tif->tif_data = (uint8_t *)_TIFFmallocExt(tif, sizeof(ZSTDState));
390
    if (tif->tif_data == NULL)
391
        goto bad;
392
    sp = LState(tif);
393

394
    /*
395
     * Override parent get/set field methods.
396
     */
397
    sp->vgetparent = tif->tif_tagmethods.vgetfield;
398
    tif->tif_tagmethods.vgetfield = ZSTDVGetField; /* hook for codec tags */
399
    sp->vsetparent = tif->tif_tagmethods.vsetfield;
400
    tif->tif_tagmethods.vsetfield = ZSTDVSetField; /* hook for codec tags */
401

402
    /* Default values for codec-specific fields */
403
    sp->compression_level = 9; /* default comp. level */
404
    sp->state = 0;
405
    sp->dstream = 0;
406
    sp->cstream = 0;
407
    sp->out_buffer.dst = NULL;
408
    sp->out_buffer.size = 0;
409
    sp->out_buffer.pos = 0;
410

411
    /*
412
     * Install codec methods.
413
     */
414
    tif->tif_fixuptags = ZSTDFixupTags;
415
    tif->tif_setupdecode = ZSTDSetupDecode;
416
    tif->tif_predecode = ZSTDPreDecode;
417
    tif->tif_decoderow = ZSTDDecode;
418
    tif->tif_decodestrip = ZSTDDecode;
419
    tif->tif_decodetile = ZSTDDecode;
420
    tif->tif_setupencode = ZSTDSetupEncode;
421
    tif->tif_preencode = ZSTDPreEncode;
422
    tif->tif_postencode = ZSTDPostEncode;
423
    tif->tif_encoderow = ZSTDEncode;
424
    tif->tif_encodestrip = ZSTDEncode;
425
    tif->tif_encodetile = ZSTDEncode;
426
    tif->tif_cleanup = ZSTDCleanup;
427
    /*
428
     * Setup predictor setup.
429
     */
430
    (void)TIFFPredictorInit(tif);
431
    return 1;
432
bad:
433
    TIFFErrorExtR(tif, module, "No space for ZSTD state block");
434
    return 0;
435
}
436
#endif /* ZSTD_SUPPORT */
437