X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Ftiff.c;h=82327d0838590eb433ae612409c5ec327e0c1f81;hb=32b3ab9b60f05c1c1e82022e9f57a21a0e3e1ec4;hp=a172b625393e1a0529d7f007ef548c11cd3d5ff5;hpb=08e505293041e6bbe1c9f6c4db73f6045c778d32;p=ffmpeg

diff --git a/libavcodec/tiff.c b/libavcodec/tiff.c
index a172b625393..82327d08385 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,10 @@ typedef struct TiffContext {
     int le;
     int compr;
     int invert;
+    int fax_opts;
+    int predictor;
 
-    int strips, rps;
+    int strips, rps, sstype;
     int sot;
     const uint8_t* stripdata;
     const uint8_t* stripsizes;
@@ -74,8 +77,8 @@ static int tget(const uint8_t **p, int type, int le){
 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){
@@ -102,6 +105,29 @@ 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;
+        }
+        for(i = 0; i < size; i++)
+            src2[i] = ff_reverse[src[i]];
+        memset(src2+size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
+        if(s->compr == TIFF_G3 && !(s->fax_opts & 1))
+            s->compr = TIFF_CCITT_RLE;
+        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);
+            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 +135,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 +176,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 +200,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;
@@ -215,6 +244,9 @@ static int tiff_decode_tag(TiffContext *s, const uint8_t *start, const uint8_t *
             }
         }
         switch(s->bpp){
+        case 1:
+            s->avctx->pix_fmt = PIX_FMT_MONOBLACK;
+            break;
         case 8:
             s->avctx->pix_fmt = PIX_FMT_PAL8;
             break;
@@ -229,8 +261,16 @@ static int tiff_decode_tag(TiffContext *s, const uint8_t *start, const uint8_t *
                 return -1;
             }
             break;
+        case 32:
+            if(count == 4){
+                s->avctx->pix_fmt = PIX_FMT_RGBA;
+            }else{
+                av_log(s->avctx, AV_LOG_ERROR, "This format is not supported (bpp=%d, %d components)\n", s->bpp, count);
+                return -1;
+            }
+            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 +293,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 +322,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 +353,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){
@@ -398,20 +402,28 @@ static int tiff_decode_tag(TiffContext *s, const uint8_t *start, const uint8_t *
             return -1;
         }
         break;
+    case TIFF_T4OPTIONS:
+    case TIFF_T6OPTIONS:
+        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;
@@ -439,10 +451,49 @@ 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]){
+        av_log(s->avctx, AV_LOG_ERROR, "Picture initialization missing\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 +512,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 +520,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;
 
@@ -495,5 +546,6 @@ AVCodec tiff_decoder = {
     tiff_end,
     decode_frame,
     0,
-    NULL
+    NULL,
+    .long_name = NULL_IF_CONFIG_SMALL("TIFF image"),
 };