X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Ftiff.c;h=8818a665307e34b5ccd1528781ce2965a1fd11a3;hb=4b5fee0205a825e5f0c7b414af6776803e55a78e;hp=a172b625393e1a0529d7f007ef548c11cd3d5ff5;hpb=08e505293041e6bbe1c9f6c4db73f6045c778d32;p=ffmpeg

diff --git a/libavcodec/tiff.c b/libavcodec/tiff.c
index a172b625393..8818a665307 100644
--- a/libavcodec/tiff.c
+++ b/libavcodec/tiff.c
@@ -21,15 +21,16 @@
 
 /**
  * TIFF image decoder
- * @file tiff.c
+ * @file libavcodec/tiff.c
  * @author Konstantin Shishkov
  */
 #include "avcodec.h"
-#ifdef CONFIG_ZLIB
+#if CONFIG_ZLIB
 #include <zlib.h>
 #endif
 #include "lzw.h"
 #include "tiff.h"
+#include "faxcompr.h"
 
 
 typedef struct TiffContext {
@@ -41,8 +42,11 @@ typedef struct TiffContext {
     int le;
     int compr;
     int invert;
+    int fax_opts;
+    int predictor;
+    int fill_order;
 
-    int strips, rps;
+    int strips, rps, sstype;
     int sot;
     const uint8_t* stripdata;
     const uint8_t* stripsizes;
@@ -71,18 +75,43 @@ static int tget(const uint8_t **p, int type, int le){
     }
 }
 
+#if CONFIG_ZLIB
+static int tiff_uncompress(uint8_t *dst, unsigned long *len, const uint8_t *src, int size)
+{
+    z_stream zstream;
+    int zret;
+
+    memset(&zstream, 0, sizeof(zstream));
+    zstream.next_in = src;
+    zstream.avail_in = size;
+    zstream.next_out = dst;
+    zstream.avail_out = *len;
+    zret = inflateInit(&zstream);
+    if (zret != Z_OK) {
+        av_log(NULL, AV_LOG_ERROR, "Inflate init error: %d\n", zret);
+        return zret;
+    }
+    zret = inflate(&zstream, Z_SYNC_FLUSH);
+    inflateEnd(&zstream);
+    *len = zstream.total_out;
+    return zret == Z_STREAM_END ? Z_OK : zret;
+}
+#endif
+
 static int tiff_unpack_strip(TiffContext *s, uint8_t* dst, int stride, const uint8_t *src, int size, int lines){
     int c, line, pixels, code;
     const uint8_t *ssrc = src;
-    int width = s->width * (s->bpp / 8);
-#ifdef CONFIG_ZLIB
+    int width = s->width * s->bpp >> 3;
+#if CONFIG_ZLIB
     uint8_t *zbuf; unsigned long outlen;
 
     if(s->compr == TIFF_DEFLATE || s->compr == TIFF_ADOBE_DEFLATE){
+        int ret;
         outlen = width * lines;
         zbuf = av_malloc(outlen);
-        if(uncompress(zbuf, &outlen, src, size) != Z_OK){
-            av_log(s->avctx, AV_LOG_ERROR, "Uncompressing failed (%lu of %lu)\n", outlen, (unsigned long)width * lines);
+        ret = tiff_uncompress(zbuf, &outlen, src, size);
+        if(ret != Z_OK){
+            av_log(s->avctx, AV_LOG_ERROR, "Uncompressing failed (%lu of %lu) with error %d\n", outlen, (unsigned long)width * lines, ret);
             av_free(zbuf);
             return -1;
         }
@@ -102,6 +131,36 @@ static int tiff_unpack_strip(TiffContext *s, uint8_t* dst, int stride, const uin
             return -1;
         }
     }
+    if(s->compr == TIFF_CCITT_RLE || s->compr == TIFF_G3 || s->compr == TIFF_G4){
+        int i, ret = 0;
+        uint8_t *src2 = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
+
+        if(!src2 || (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE < (unsigned)size){
+            av_log(s->avctx, AV_LOG_ERROR, "Error allocating temporary buffer\n");
+            return -1;
+        }
+        if(s->fax_opts & 2){
+            av_log(s->avctx, AV_LOG_ERROR, "Uncompressed fax mode is not supported (yet)\n");
+            av_free(src2);
+            return -1;
+        }
+        if(!s->fill_order){
+            memcpy(src2, src, size);
+        }else{
+            for(i = 0; i < size; i++)
+                src2[i] = ff_reverse[src[i]];
+        }
+        memset(src2+size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
+        switch(s->compr){
+        case TIFF_CCITT_RLE:
+        case TIFF_G3:
+        case TIFF_G4:
+            ret = ff_ccitt_unpack(s->avctx, src2, size, dst, lines, stride, s->compr, s->fax_opts);
+            break;
+        }
+        av_free(src2);
+        return ret;
+    }
     for(line = 0; line < lines; line++){
         if(src - ssrc > size){
             av_log(s->avctx, AV_LOG_ERROR, "Source data overread\n");
@@ -109,8 +168,8 @@ static int tiff_unpack_strip(TiffContext *s, uint8_t* dst, int stride, const uin
         }
         switch(s->compr){
         case TIFF_RAW:
-            memcpy(dst, src, s->width * (s->bpp / 8));
-            src += s->width * (s->bpp / 8);
+            memcpy(dst, src, width);
+            src += width;
             break;
         case TIFF_PACKBITS:
             for(pixels = 0; pixels < width;){
@@ -150,12 +209,10 @@ static int tiff_unpack_strip(TiffContext *s, uint8_t* dst, int stride, const uin
 }
 
 
-static int tiff_decode_tag(TiffContext *s, const uint8_t *start, const uint8_t *buf, const uint8_t *end_buf, AVFrame *pic)
+static int tiff_decode_tag(TiffContext *s, const uint8_t *start, const uint8_t *buf, const uint8_t *end_buf)
 {
     int tag, type, count, off, value = 0;
-    const uint8_t *src;
-    uint8_t *dst;
-    int i, j, ssize, soff, stride;
+    int i, j;
     uint32_t *pal;
     const uint8_t *rp, *gp, *bp;
 
@@ -176,6 +233,11 @@ static int tiff_decode_tag(TiffContext *s, const uint8_t *start, const uint8_t *
             value = off;
             buf = NULL;
             break;
+        case TIFF_STRING:
+            if(count <= 4){
+                buf -= 4;
+                break;
+            }
         default:
             value = -1;
             buf = start + off;
@@ -214,23 +276,31 @@ static int tiff_decode_tag(TiffContext *s, const uint8_t *start, const uint8_t *
                 s->bpp = -1;
             }
         }
-        switch(s->bpp){
-        case 8:
+        if(count > 4){
+            av_log(s->avctx, AV_LOG_ERROR, "This format is not supported (bpp=%d, %d components)\n", s->bpp, count);
+            return -1;
+        }
+        switch(s->bpp*10 + count){
+        case 11:
+            s->avctx->pix_fmt = PIX_FMT_MONOBLACK;
+            break;
+        case 81:
             s->avctx->pix_fmt = PIX_FMT_PAL8;
             break;
-        case 24:
+        case 243:
             s->avctx->pix_fmt = PIX_FMT_RGB24;
             break;
-        case 16:
-            if(count == 1){
-                s->avctx->pix_fmt = PIX_FMT_GRAY16BE;
-            }else{
-                av_log(s->avctx, AV_LOG_ERROR, "This format is not supported (bpp=%i)\n", s->bpp);
-                return -1;
-            }
+        case 161:
+            s->avctx->pix_fmt = PIX_FMT_GRAY16BE;
+            break;
+        case 324:
+            s->avctx->pix_fmt = PIX_FMT_RGBA;
+            break;
+        case 483:
+            s->avctx->pix_fmt = s->le ? PIX_FMT_RGB48LE : PIX_FMT_RGB48BE;
             break;
         default:
-            av_log(s->avctx, AV_LOG_ERROR, "This format is not supported (bpp=%i)\n", s->bpp);
+            av_log(s->avctx, AV_LOG_ERROR, "This format is not supported (bpp=%d, %d components)\n", s->bpp, count);
             return -1;
         }
         if(s->width != s->avctx->width || s->height != s->avctx->height){
@@ -253,28 +323,25 @@ static int tiff_decode_tag(TiffContext *s, const uint8_t *start, const uint8_t *
         break;
     case TIFF_COMPR:
         s->compr = value;
+        s->predictor = 0;
         switch(s->compr){
         case TIFF_RAW:
         case TIFF_PACKBITS:
         case TIFF_LZW:
+        case TIFF_CCITT_RLE:
+            break;
+        case TIFF_G3:
+        case TIFF_G4:
+            s->fax_opts = 0;
             break;
         case TIFF_DEFLATE:
         case TIFF_ADOBE_DEFLATE:
-#ifdef CONFIG_ZLIB
+#if CONFIG_ZLIB
             break;
 #else
             av_log(s->avctx, AV_LOG_ERROR, "Deflate: ZLib not compiled in\n");
             return -1;
 #endif
-        case TIFF_G3:
-            av_log(s->avctx, AV_LOG_ERROR, "CCITT G3 compression is not supported\n");
-            return -1;
-        case TIFF_G4:
-            av_log(s->avctx, AV_LOG_ERROR, "CCITT G4 compression is not supported\n");
-            return -1;
-        case TIFF_CCITT_RLE:
-            av_log(s->avctx, AV_LOG_ERROR, "CCITT RLE compression is not supported\n");
-            return -1;
         case TIFF_JPEG:
         case TIFF_NEWJPEG:
             av_log(s->avctx, AV_LOG_ERROR, "JPEG compression is not supported\n");
@@ -285,6 +352,8 @@ static int tiff_decode_tag(TiffContext *s, const uint8_t *start, const uint8_t *
         }
         break;
     case TIFF_ROWSPERSTRIP:
+        if(type == TIFF_LONG && value == -1)
+            value = s->avctx->height;
         if(value < 1){
             av_log(s->avctx, AV_LOG_ERROR, "Incorrect value of rows per strip\n");
             return -1;
@@ -314,49 +383,14 @@ static int tiff_decode_tag(TiffContext *s, const uint8_t *start, const uint8_t *
             s->stripsizes = start + off;
         }
         s->strips = count;
+        s->sstype = type;
         if(s->stripsizes > end_buf){
             av_log(s->avctx, AV_LOG_ERROR, "Tag referencing position outside the image\n");
             return -1;
         }
-        if(!pic->data[0]){
-            av_log(s->avctx, AV_LOG_ERROR, "Picture initialization missing\n");
-            return -1;
-        }
-        /* now we have the data and may start decoding */
-        stride = pic->linesize[0];
-        dst = pic->data[0];
-        for(i = 0; i < s->height; i += s->rps){
-            if(s->stripsizes)
-                ssize = tget(&s->stripsizes, type, s->le);
-            else
-                ssize = s->stripsize;
-
-            if(s->stripdata){
-                soff = tget(&s->stripdata, s->sot, s->le);
-            }else
-                soff = s->stripoff;
-            src = start + soff;
-            if(tiff_unpack_strip(s, dst, stride, src, ssize, FFMIN(s->rps, s->height - i)) < 0)
-                break;
-            dst += s->rps * stride;
-        }
         break;
     case TIFF_PREDICTOR:
-        if(!pic->data[0]){
-            av_log(s->avctx, AV_LOG_ERROR, "Picture initialization missing\n");
-            return -1;
-        }
-        if(value == 2){
-            dst = pic->data[0];
-            stride = pic->linesize[0];
-            soff = s->bpp >> 3;
-            ssize = s->width * soff;
-            for(i = 0; i < s->height; i++) {
-                for(j = soff; j < ssize; j++)
-                    dst[j] += dst[j - soff];
-                dst += stride;
-            }
-        }
+        s->predictor = value;
         break;
     case TIFF_INVERT:
         switch(value){
@@ -374,6 +408,13 @@ static int tiff_decode_tag(TiffContext *s, const uint8_t *start, const uint8_t *
             return -1;
         }
         break;
+    case TIFF_FILL_ORDER:
+        if(value < 1 || value > 2){
+            av_log(s->avctx, AV_LOG_ERROR, "Unknown FillOrder value %d, trying default one\n", value);
+            value = 1;
+        }
+        s->fill_order = value - 1;
+        break;
     case TIFF_PAL:
         if(s->avctx->pix_fmt != PIX_FMT_PAL8){
             av_log(s->avctx, AV_LOG_ERROR, "Palette met but this is not palettized format\n");
@@ -398,20 +439,32 @@ static int tiff_decode_tag(TiffContext *s, const uint8_t *start, const uint8_t *
             return -1;
         }
         break;
+    case TIFF_T4OPTIONS:
+        if(s->compr == TIFF_G3)
+            s->fax_opts = value;
+        break;
+    case TIFF_T6OPTIONS:
+        if(s->compr == TIFF_G4)
+            s->fax_opts = value;
+        break;
     }
     return 0;
 }
 
 static int decode_frame(AVCodecContext *avctx,
                         void *data, int *data_size,
-                        const uint8_t *buf, int buf_size)
+                        AVPacket *avpkt)
 {
+    const uint8_t *buf = avpkt->data;
+    int buf_size = avpkt->size;
     TiffContext * const s = avctx->priv_data;
     AVFrame *picture = data;
     AVFrame * const p= (AVFrame*)&s->picture;
     const uint8_t *orig_buf = buf, *end_buf = buf + buf_size;
     int id, le, off;
-    int i, entries;
+    int i, j, entries;
+    int stride, soff, ssize;
+    uint8_t *dst;
 
     //parse image header
     id = AV_RL16(buf); buf += 2;
@@ -424,6 +477,7 @@ static int decode_frame(AVCodecContext *avctx,
     s->le = le;
     s->invert = 0;
     s->compr = TIFF_RAW;
+    s->fill_order = 0;
     // As TIFF 6.0 specification puts it "An arbitrary but carefully chosen number
     // that further identifies the file as a TIFF file"
     if(tget_short(&buf, le) != 42){
@@ -439,10 +493,60 @@ static int decode_frame(AVCodecContext *avctx,
     buf = orig_buf + off;
     entries = tget_short(&buf, le);
     for(i = 0; i < entries; i++){
-        if(tiff_decode_tag(s, orig_buf, buf, end_buf, p) < 0)
+        if(tiff_decode_tag(s, orig_buf, buf, end_buf) < 0)
             return -1;
         buf += 12;
     }
+    if(!s->stripdata && !s->stripoff){
+        av_log(avctx, AV_LOG_ERROR, "Image data is missing\n");
+        return -1;
+    }
+    /* now we have the data and may start decoding */
+    if(!p->data[0]){
+        s->bpp = 1;
+        avctx->pix_fmt = PIX_FMT_MONOBLACK;
+        if(s->width != s->avctx->width || s->height != s->avctx->height){
+            if(avcodec_check_dimensions(s->avctx, s->width, s->height))
+                return -1;
+            avcodec_set_dimensions(s->avctx, s->width, s->height);
+        }
+        if(s->picture.data[0])
+            s->avctx->release_buffer(s->avctx, &s->picture);
+        if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){
+            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
+            return -1;
+        }
+    }
+    if(s->strips == 1 && !s->stripsize){
+        av_log(avctx, AV_LOG_WARNING, "Image data size missing\n");
+        s->stripsize = buf_size - s->stripoff;
+    }
+    stride = p->linesize[0];
+    dst = p->data[0];
+    for(i = 0; i < s->height; i += s->rps){
+        if(s->stripsizes)
+            ssize = tget(&s->stripsizes, s->sstype, s->le);
+        else
+            ssize = s->stripsize;
+
+        if(s->stripdata){
+            soff = tget(&s->stripdata, s->sot, s->le);
+        }else
+            soff = s->stripoff;
+        if(tiff_unpack_strip(s, dst, stride, orig_buf + soff, ssize, FFMIN(s->rps, s->height - i)) < 0)
+            break;
+        dst += s->rps * stride;
+    }
+    if(s->predictor == 2){
+        dst = p->data[0];
+        soff = s->bpp >> 3;
+        ssize = s->width * soff;
+        for(i = 0; i < s->height; i++) {
+            for(j = soff; j < ssize; j++)
+                dst[j] += dst[j - soff];
+            dst += stride;
+        }
+    }
 
     if(s->invert){
         uint8_t *src;
@@ -461,7 +565,7 @@ static int decode_frame(AVCodecContext *avctx,
     return buf_size;
 }
 
-static int tiff_init(AVCodecContext *avctx){
+static av_cold int tiff_init(AVCodecContext *avctx){
     TiffContext *s = avctx->priv_data;
 
     s->width = 0;
@@ -469,13 +573,13 @@ static int tiff_init(AVCodecContext *avctx){
     s->avctx = avctx;
     avcodec_get_frame_defaults((AVFrame*)&s->picture);
     avctx->coded_frame= (AVFrame*)&s->picture;
-    s->picture.data[0] = NULL;
     ff_lzw_decode_open(&s->lzw);
+    ff_ccitt_unpack_init();
 
     return 0;
 }
 
-static int tiff_end(AVCodecContext *avctx)
+static av_cold int tiff_end(AVCodecContext *avctx)
 {
     TiffContext * const s = avctx->priv_data;
 
@@ -494,6 +598,7 @@ AVCodec tiff_decoder = {
     NULL,
     tiff_end,
     decode_frame,
-    0,
-    NULL
+    CODEC_CAP_DR1,
+    NULL,
+    .long_name = NULL_IF_CONFIG_SMALL("TIFF image"),
 };