Statistics
| Branch: | Revision:

ffmpeg / libavcodec / tiff.c @ 72415b2a

History | View | Annotate | Download (17.6 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
#include "libavutil/common.h"
35
#include "libavutil/intreadwrite.h"
36

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

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

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

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

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

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

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

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

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

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

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

    
212

    
213
static int tiff_decode_tag(TiffContext *s, const uint8_t *start, const uint8_t *buf, const uint8_t *end_buf)
214
{
215
    int tag, type, count, off, value = 0;
216
    int i, j;
217
    uint32_t *pal;
218
    const uint8_t *rp, *gp, *bp;
219

    
220
    tag = tget_short(&buf, s->le);
221
    type = tget_short(&buf, s->le);
222
    count = tget_long(&buf, s->le);
223
    off = tget_long(&buf, s->le);
224

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

    
252
    if(buf && (buf < start || buf > end_buf)){
253
        av_log(s->avctx, AV_LOG_ERROR, "Tag referencing position outside the image\n");
254
        return -1;
255
    }
256

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

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

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

    
533
        if(s->stripdata){
534
            soff = tget(&s->stripdata, s->sot, s->le);
535
        }else
536
            soff = s->stripoff;
537
        if(tiff_unpack_strip(s, dst, stride, orig_buf + soff, ssize, FFMIN(s->rps, s->height - i)) < 0)
538
            break;
539
        dst += s->rps * stride;
540
    }
541
    if(s->predictor == 2){
542
        dst = p->data[0];
543
        soff = s->bpp >> 3;
544
        ssize = s->width * soff;
545
        for(i = 0; i < s->height; i++) {
546
            for(j = soff; j < ssize; j++)
547
                dst[j] += dst[j - soff];
548
            dst += stride;
549
        }
550
    }
551

    
552
    if(s->invert){
553
        uint8_t *src;
554
        int j;
555

    
556
        src = s->picture.data[0];
557
        for(j = 0; j < s->height; j++){
558
            for(i = 0; i < s->picture.linesize[0]; i++)
559
                src[i] = 255 - src[i];
560
            src += s->picture.linesize[0];
561
        }
562
    }
563
    *picture= *(AVFrame*)&s->picture;
564
    *data_size = sizeof(AVPicture);
565

    
566
    return buf_size;
567
}
568

    
569
static av_cold int tiff_init(AVCodecContext *avctx){
570
    TiffContext *s = avctx->priv_data;
571

    
572
    s->width = 0;
573
    s->height = 0;
574
    s->avctx = avctx;
575
    avcodec_get_frame_defaults((AVFrame*)&s->picture);
576
    avctx->coded_frame= (AVFrame*)&s->picture;
577
    ff_lzw_decode_open(&s->lzw);
578
    ff_ccitt_unpack_init();
579

    
580
    return 0;
581
}
582

    
583
static av_cold int tiff_end(AVCodecContext *avctx)
584
{
585
    TiffContext * const s = avctx->priv_data;
586

    
587
    ff_lzw_decode_close(&s->lzw);
588
    if(s->picture.data[0])
589
        avctx->release_buffer(avctx, &s->picture);
590
    return 0;
591
}
592

    
593
AVCodec tiff_decoder = {
594
    "tiff",
595
    AVMEDIA_TYPE_VIDEO,
596
    CODEC_ID_TIFF,
597
    sizeof(TiffContext),
598
    tiff_init,
599
    NULL,
600
    tiff_end,
601
    decode_frame,
602
    CODEC_CAP_DR1,
603
    NULL,
604
    .long_name = NULL_IF_CONFIG_SMALL("TIFF image"),
605
};