Statistics
| Branch: | Revision:

ffmpeg / libavcodec / tiff.c @ 8da5d3dc

History | View | Annotate | Download (16.9 KB)

1
/*
2
 * TIFF image decoder
3
 * Copyright (c) 2006 Konstantin Shishkov
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

    
22
/**
23
 * TIFF image decoder
24
 * @file libavcodec/tiff.c
25
 * @author Konstantin Shishkov
26
 */
27
#include "avcodec.h"
28
#if CONFIG_ZLIB
29
#include <zlib.h>
30
#endif
31
#include "lzw.h"
32
#include "tiff.h"
33
#include "faxcompr.h"
34

    
35

    
36
typedef struct TiffContext {
37
    AVCodecContext *avctx;
38
    AVFrame picture;
39

    
40
    int width, height;
41
    unsigned int bpp;
42
    int le;
43
    int compr;
44
    int invert;
45
    int fax_opts;
46
    int predictor;
47
    int fill_order;
48

    
49
    int strips, rps, sstype;
50
    int sot;
51
    const uint8_t* stripdata;
52
    const uint8_t* stripsizes;
53
    int stripsize, stripoff;
54
    LZWState *lzw;
55
} TiffContext;
56

    
57
static int tget_short(const uint8_t **p, int le){
58
    int v = le ? AV_RL16(*p) : AV_RB16(*p);
59
    *p += 2;
60
    return v;
61
}
62

    
63
static int tget_long(const uint8_t **p, int le){
64
    int v = le ? AV_RL32(*p) : AV_RB32(*p);
65
    *p += 4;
66
    return v;
67
}
68

    
69
static int tget(const uint8_t **p, int type, int le){
70
    switch(type){
71
    case TIFF_BYTE : return *(*p)++;
72
    case TIFF_SHORT: return tget_short(p, le);
73
    case TIFF_LONG : return tget_long (p, le);
74
    default        : return -1;
75
    }
76
}
77

    
78
#if CONFIG_ZLIB
79
static int tiff_uncompress(uint8_t *dst, unsigned long *len, const uint8_t *src, int size)
80
{
81
    z_stream zstream;
82
    int zret;
83

    
84
    memset(&zstream, 0, sizeof(zstream));
85
    zstream.next_in = src;
86
    zstream.avail_in = size;
87
    zstream.next_out = dst;
88
    zstream.avail_out = *len;
89
    zret = inflateInit(&zstream);
90
    if (zret != Z_OK) {
91
        av_log(NULL, AV_LOG_ERROR, "Inflate init error: %d\n", zret);
92
        return zret;
93
    }
94
    zret = inflate(&zstream, Z_SYNC_FLUSH);
95
    inflateEnd(&zstream);
96
    *len = zstream.total_out;
97
    return zret == Z_STREAM_END ? Z_OK : zret;
98
}
99
#endif
100

    
101
static int tiff_unpack_strip(TiffContext *s, uint8_t* dst, int stride, const uint8_t *src, int size, int lines){
102
    int c, line, pixels, code;
103
    const uint8_t *ssrc = src;
104
    int width = s->width * s->bpp >> 3;
105
#if CONFIG_ZLIB
106
    uint8_t *zbuf; unsigned long outlen;
107

    
108
    if(s->compr == TIFF_DEFLATE || s->compr == TIFF_ADOBE_DEFLATE){
109
        int ret;
110
        outlen = width * lines;
111
        zbuf = av_malloc(outlen);
112
        ret = tiff_uncompress(zbuf, &outlen, src, size);
113
        if(ret != Z_OK){
114
            av_log(s->avctx, AV_LOG_ERROR, "Uncompressing failed (%lu of %lu) with error %d\n", outlen, (unsigned long)width * lines, ret);
115
            av_free(zbuf);
116
            return -1;
117
        }
118
        src = zbuf;
119
        for(line = 0; line < lines; line++){
120
            memcpy(dst, src, width);
121
            dst += stride;
122
            src += width;
123
        }
124
        av_free(zbuf);
125
        return 0;
126
    }
127
#endif
128
    if(s->compr == TIFF_LZW){
129
        if(ff_lzw_decode_init(s->lzw, 8, src, size, FF_LZW_TIFF) < 0){
130
            av_log(s->avctx, AV_LOG_ERROR, "Error initializing LZW decoder\n");
131
            return -1;
132
        }
133
    }
134
    if(s->compr == TIFF_CCITT_RLE || s->compr == TIFF_G3 || s->compr == TIFF_G4){
135
        int i, ret = 0;
136
        uint8_t *src2 = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
137

    
138
        if(!src2 || (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE < (unsigned)size){
139
            av_log(s->avctx, AV_LOG_ERROR, "Error allocating temporary buffer\n");
140
            return -1;
141
        }
142
        if(!s->fill_order){
143
            memcpy(src2, src, size);
144
        }else{
145
            for(i = 0; i < size; i++)
146
                src2[i] = ff_reverse[src[i]];
147
        }
148
        memset(src2+size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
149
        switch(s->compr){
150
        case TIFF_CCITT_RLE:
151
        case TIFF_G3:
152
        case TIFF_G4:
153
            ret = ff_ccitt_unpack(s->avctx, src2, size, dst, lines, stride, s->compr, s->fax_opts);
154
            break;
155
        }
156
        av_free(src2);
157
        return ret;
158
    }
159
    for(line = 0; line < lines; line++){
160
        if(src - ssrc > size){
161
            av_log(s->avctx, AV_LOG_ERROR, "Source data overread\n");
162
            return -1;
163
        }
164
        switch(s->compr){
165
        case TIFF_RAW:
166
            memcpy(dst, src, width);
167
            src += width;
168
            break;
169
        case TIFF_PACKBITS:
170
            for(pixels = 0; pixels < width;){
171
                code = (int8_t)*src++;
172
                if(code >= 0){
173
                    code++;
174
                    if(pixels + code > width){
175
                        av_log(s->avctx, AV_LOG_ERROR, "Copy went out of bounds\n");
176
                        return -1;
177
                    }
178
                    memcpy(dst + pixels, src, code);
179
                    src += code;
180
                    pixels += code;
181
                }else if(code != -128){ // -127..-1
182
                    code = (-code) + 1;
183
                    if(pixels + code > width){
184
                        av_log(s->avctx, AV_LOG_ERROR, "Run went out of bounds\n");
185
                        return -1;
186
                    }
187
                    c = *src++;
188
                    memset(dst + pixels, c, code);
189
                    pixels += code;
190
                }
191
            }
192
            break;
193
        case TIFF_LZW:
194
            pixels = ff_lzw_decode(s->lzw, dst, width);
195
            if(pixels < width){
196
                av_log(s->avctx, AV_LOG_ERROR, "Decoded only %i bytes of %i\n", pixels, width);
197
                return -1;
198
            }
199
            break;
200
        }
201
        dst += stride;
202
    }
203
    return 0;
204
}
205

    
206

    
207
static int tiff_decode_tag(TiffContext *s, const uint8_t *start, const uint8_t *buf, const uint8_t *end_buf)
208
{
209
    int tag, type, count, off, value = 0;
210
    int i, j;
211
    uint32_t *pal;
212
    const uint8_t *rp, *gp, *bp;
213

    
214
    tag = tget_short(&buf, s->le);
215
    type = tget_short(&buf, s->le);
216
    count = tget_long(&buf, s->le);
217
    off = tget_long(&buf, s->le);
218

    
219
    if(count == 1){
220
        switch(type){
221
        case TIFF_BYTE:
222
        case TIFF_SHORT:
223
            buf -= 4;
224
            value = tget(&buf, type, s->le);
225
            buf = NULL;
226
            break;
227
        case TIFF_LONG:
228
            value = off;
229
            buf = NULL;
230
            break;
231
        case TIFF_STRING:
232
            if(count <= 4){
233
                buf -= 4;
234
                break;
235
            }
236
        default:
237
            value = -1;
238
            buf = start + off;
239
        }
240
    }else if(type_sizes[type] * count <= 4){
241
        buf -= 4;
242
    }else{
243
        buf = start + off;
244
    }
245

    
246
    if(buf && (buf < start || buf > end_buf)){
247
        av_log(s->avctx, AV_LOG_ERROR, "Tag referencing position outside the image\n");
248
        return -1;
249
    }
250

    
251
    switch(tag){
252
    case TIFF_WIDTH:
253
        s->width = value;
254
        break;
255
    case TIFF_HEIGHT:
256
        s->height = value;
257
        break;
258
    case TIFF_BPP:
259
        if(count == 1) s->bpp = value;
260
        else{
261
            switch(type){
262
            case TIFF_BYTE:
263
                s->bpp = (off & 0xFF) + ((off >> 8) & 0xFF) + ((off >> 16) & 0xFF) + ((off >> 24) & 0xFF);
264
                break;
265
            case TIFF_SHORT:
266
            case TIFF_LONG:
267
                s->bpp = 0;
268
                for(i = 0; i < count; i++) s->bpp += tget(&buf, type, s->le);
269
                break;
270
            default:
271
                s->bpp = -1;
272
            }
273
        }
274
        if(count > 4){
275
            av_log(s->avctx, AV_LOG_ERROR, "This format is not supported (bpp=%d, %d components)\n", s->bpp, count);
276
            return -1;
277
        }
278
        switch(s->bpp*10 + count){
279
        case 11:
280
            s->avctx->pix_fmt = PIX_FMT_MONOBLACK;
281
            break;
282
        case 81:
283
            s->avctx->pix_fmt = PIX_FMT_PAL8;
284
            break;
285
        case 243:
286
            s->avctx->pix_fmt = PIX_FMT_RGB24;
287
            break;
288
        case 161:
289
            s->avctx->pix_fmt = PIX_FMT_GRAY16BE;
290
            break;
291
        case 324:
292
            s->avctx->pix_fmt = PIX_FMT_RGBA;
293
            break;
294
        case 483:
295
            s->avctx->pix_fmt = s->le ? PIX_FMT_RGB48LE : PIX_FMT_RGB48BE;
296
            break;
297
        default:
298
            av_log(s->avctx, AV_LOG_ERROR, "This format is not supported (bpp=%d, %d components)\n", s->bpp, count);
299
            return -1;
300
        }
301
        if(s->width != s->avctx->width || s->height != s->avctx->height){
302
            if(avcodec_check_dimensions(s->avctx, s->width, s->height))
303
                return -1;
304
            avcodec_set_dimensions(s->avctx, s->width, s->height);
305
        }
306
        if(s->picture.data[0])
307
            s->avctx->release_buffer(s->avctx, &s->picture);
308
        if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){
309
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
310
            return -1;
311
        }
312
        if(s->bpp == 8){
313
            /* make default grayscale pal */
314
            pal = (uint32_t *) s->picture.data[1];
315
            for(i = 0; i < 256; i++)
316
                pal[i] = i * 0x010101;
317
        }
318
        break;
319
    case TIFF_COMPR:
320
        s->compr = value;
321
        s->predictor = 0;
322
        switch(s->compr){
323
        case TIFF_RAW:
324
        case TIFF_PACKBITS:
325
        case TIFF_LZW:
326
        case TIFF_CCITT_RLE:
327
            break;
328
        case TIFF_G3:
329
        case TIFF_G4:
330
            s->fax_opts = 0;
331
            break;
332
        case TIFF_DEFLATE:
333
        case TIFF_ADOBE_DEFLATE:
334
#if CONFIG_ZLIB
335
            break;
336
#else
337
            av_log(s->avctx, AV_LOG_ERROR, "Deflate: ZLib not compiled in\n");
338
            return -1;
339
#endif
340
        case TIFF_JPEG:
341
        case TIFF_NEWJPEG:
342
            av_log(s->avctx, AV_LOG_ERROR, "JPEG compression is not supported\n");
343
            return -1;
344
        default:
345
            av_log(s->avctx, AV_LOG_ERROR, "Unknown compression method %i\n", s->compr);
346
            return -1;
347
        }
348
        break;
349
    case TIFF_ROWSPERSTRIP:
350
        if(type == TIFF_LONG && value == -1)
351
            value = s->avctx->height;
352
        if(value < 1){
353
            av_log(s->avctx, AV_LOG_ERROR, "Incorrect value of rows per strip\n");
354
            return -1;
355
        }
356
        s->rps = value;
357
        break;
358
    case TIFF_STRIP_OFFS:
359
        if(count == 1){
360
            s->stripdata = NULL;
361
            s->stripoff = value;
362
        }else
363
            s->stripdata = start + off;
364
        s->strips = count;
365
        if(s->strips == 1) s->rps = s->height;
366
        s->sot = type;
367
        if(s->stripdata > end_buf){
368
            av_log(s->avctx, AV_LOG_ERROR, "Tag referencing position outside the image\n");
369
            return -1;
370
        }
371
        break;
372
    case TIFF_STRIP_SIZE:
373
        if(count == 1){
374
            s->stripsizes = NULL;
375
            s->stripsize = value;
376
            s->strips = 1;
377
        }else{
378
            s->stripsizes = start + off;
379
        }
380
        s->strips = count;
381
        s->sstype = type;
382
        if(s->stripsizes > end_buf){
383
            av_log(s->avctx, AV_LOG_ERROR, "Tag referencing position outside the image\n");
384
            return -1;
385
        }
386
        break;
387
    case TIFF_PREDICTOR:
388
        s->predictor = value;
389
        break;
390
    case TIFF_INVERT:
391
        switch(value){
392
        case 0:
393
            s->invert = 1;
394
            break;
395
        case 1:
396
            s->invert = 0;
397
            break;
398
        case 2:
399
        case 3:
400
            break;
401
        default:
402
            av_log(s->avctx, AV_LOG_ERROR, "Color mode %d is not supported\n", value);
403
            return -1;
404
        }
405
        break;
406
    case TIFF_FILL_ORDER:
407
        if(value < 1 || value > 2){
408
            av_log(s->avctx, AV_LOG_ERROR, "Unknown FillOrder value %d, trying default one\n", value);
409
            value = 1;
410
        }
411
        s->fill_order = value - 1;
412
        break;
413
    case TIFF_PAL:
414
        if(s->avctx->pix_fmt != PIX_FMT_PAL8){
415
            av_log(s->avctx, AV_LOG_ERROR, "Palette met but this is not palettized format\n");
416
            return -1;
417
        }
418
        pal = (uint32_t *) s->picture.data[1];
419
        off = type_sizes[type];
420
        rp = buf;
421
        gp = buf + count / 3 * off;
422
        bp = buf + count / 3 * off * 2;
423
        off = (type_sizes[type] - 1) << 3;
424
        for(i = 0; i < count / 3; i++){
425
            j = (tget(&rp, type, s->le) >> off) << 16;
426
            j |= (tget(&gp, type, s->le) >> off) << 8;
427
            j |= tget(&bp, type, s->le) >> off;
428
            pal[i] = j;
429
        }
430
        break;
431
    case TIFF_PLANAR:
432
        if(value == 2){
433
            av_log(s->avctx, AV_LOG_ERROR, "Planar format is not supported\n");
434
            return -1;
435
        }
436
        break;
437
    case TIFF_T4OPTIONS:
438
        if(s->compr == TIFF_G3)
439
            s->fax_opts = value;
440
        break;
441
    case TIFF_T6OPTIONS:
442
        if(s->compr == TIFF_G4)
443
            s->fax_opts = value;
444
        break;
445
    }
446
    return 0;
447
}
448

    
449
static int decode_frame(AVCodecContext *avctx,
450
                        void *data, int *data_size,
451
                        AVPacket *avpkt)
452
{
453
    const uint8_t *buf = avpkt->data;
454
    int buf_size = avpkt->size;
455
    TiffContext * const s = avctx->priv_data;
456
    AVFrame *picture = data;
457
    AVFrame * const p= (AVFrame*)&s->picture;
458
    const uint8_t *orig_buf = buf, *end_buf = buf + buf_size;
459
    int id, le, off;
460
    int i, j, entries;
461
    int stride, soff, ssize;
462
    uint8_t *dst;
463

    
464
    //parse image header
465
    id = AV_RL16(buf); buf += 2;
466
    if(id == 0x4949) le = 1;
467
    else if(id == 0x4D4D) le = 0;
468
    else{
469
        av_log(avctx, AV_LOG_ERROR, "TIFF header not found\n");
470
        return -1;
471
    }
472
    s->le = le;
473
    s->invert = 0;
474
    s->compr = TIFF_RAW;
475
    s->fill_order = 0;
476
    // As TIFF 6.0 specification puts it "An arbitrary but carefully chosen number
477
    // that further identifies the file as a TIFF file"
478
    if(tget_short(&buf, le) != 42){
479
        av_log(avctx, AV_LOG_ERROR, "The answer to life, universe and everything is not correct!\n");
480
        return -1;
481
    }
482
    /* parse image file directory */
483
    off = tget_long(&buf, le);
484
    if(orig_buf + off + 14 >= end_buf){
485
        av_log(avctx, AV_LOG_ERROR, "IFD offset is greater than image size\n");
486
        return -1;
487
    }
488
    buf = orig_buf + off;
489
    entries = tget_short(&buf, le);
490
    for(i = 0; i < entries; i++){
491
        if(tiff_decode_tag(s, orig_buf, buf, end_buf) < 0)
492
            return -1;
493
        buf += 12;
494
    }
495
    if(!s->stripdata && !s->stripoff){
496
        av_log(avctx, AV_LOG_ERROR, "Image data is missing\n");
497
        return -1;
498
    }
499
    /* now we have the data and may start decoding */
500
    if(!p->data[0]){
501
        av_log(s->avctx, AV_LOG_ERROR, "Picture initialization missing\n");
502
        return -1;
503
    }
504
    if(s->strips == 1 && !s->stripsize){
505
        av_log(avctx, AV_LOG_WARNING, "Image data size missing\n");
506
        s->stripsize = buf_size - s->stripoff;
507
    }
508
    stride = p->linesize[0];
509
    dst = p->data[0];
510
    for(i = 0; i < s->height; i += s->rps){
511
        if(s->stripsizes)
512
            ssize = tget(&s->stripsizes, s->sstype, s->le);
513
        else
514
            ssize = s->stripsize;
515

    
516
        if(s->stripdata){
517
            soff = tget(&s->stripdata, s->sot, s->le);
518
        }else
519
            soff = s->stripoff;
520
        if(tiff_unpack_strip(s, dst, stride, orig_buf + soff, ssize, FFMIN(s->rps, s->height - i)) < 0)
521
            break;
522
        dst += s->rps * stride;
523
    }
524
    if(s->predictor == 2){
525
        dst = p->data[0];
526
        soff = s->bpp >> 3;
527
        ssize = s->width * soff;
528
        for(i = 0; i < s->height; i++) {
529
            for(j = soff; j < ssize; j++)
530
                dst[j] += dst[j - soff];
531
            dst += stride;
532
        }
533
    }
534

    
535
    if(s->invert){
536
        uint8_t *src;
537
        int j;
538

    
539
        src = s->picture.data[0];
540
        for(j = 0; j < s->height; j++){
541
            for(i = 0; i < s->picture.linesize[0]; i++)
542
                src[i] = 255 - src[i];
543
            src += s->picture.linesize[0];
544
        }
545
    }
546
    *picture= *(AVFrame*)&s->picture;
547
    *data_size = sizeof(AVPicture);
548

    
549
    return buf_size;
550
}
551

    
552
static av_cold int tiff_init(AVCodecContext *avctx){
553
    TiffContext *s = avctx->priv_data;
554

    
555
    s->width = 0;
556
    s->height = 0;
557
    s->avctx = avctx;
558
    avcodec_get_frame_defaults((AVFrame*)&s->picture);
559
    avctx->coded_frame= (AVFrame*)&s->picture;
560
    ff_lzw_decode_open(&s->lzw);
561
    ff_ccitt_unpack_init();
562

    
563
    return 0;
564
}
565

    
566
static av_cold int tiff_end(AVCodecContext *avctx)
567
{
568
    TiffContext * const s = avctx->priv_data;
569

    
570
    ff_lzw_decode_close(&s->lzw);
571
    if(s->picture.data[0])
572
        avctx->release_buffer(avctx, &s->picture);
573
    return 0;
574
}
575

    
576
AVCodec tiff_decoder = {
577
    "tiff",
578
    CODEC_TYPE_VIDEO,
579
    CODEC_ID_TIFF,
580
    sizeof(TiffContext),
581
    tiff_init,
582
    NULL,
583
    tiff_end,
584
    decode_frame,
585
    CODEC_CAP_DR1,
586
    NULL,
587
    .long_name = NULL_IF_CONFIG_SMALL("TIFF image"),
588
};