]> git.sesse.net Git - ffmpeg/blobdiff - libavcodec/tiff.c
Add some explanatory comments to #endif directives.
[ffmpeg] / libavcodec / tiff.c
index 4fa54bb7b1a0e9166c3dcdbcee531fce5dc4bcea..f614b32a6ac0f50ca353be8e907f9d738906e89c 100644 (file)
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  *
  */
+
+/**
+ * TIFF image decoder
+ * @file tiff.c
+ * @author Konstantin Shishkov
+ */
 #include "avcodec.h"
 #ifdef CONFIG_ZLIB
 #include <zlib.h>
 #endif
+#include "lzw.h"
+#include "tiff.h"
 
-/* abridged list of TIFF tags */
-enum TiffTags{
-    TIFF_WIDTH = 0x100,
-    TIFF_HEIGHT,
-    TIFF_BPP,
-    TIFF_COMPR,
-    TIFF_INVERT = 0x106,
-    TIFF_STRIP_OFFS = 0x111,
-    TIFF_ROWSPERSTRIP = 0x116,
-    TIFF_STRIP_SIZE,
-    TIFF_XPOS = 0x11E,
-    TIFF_YPOS = 0x11F,
-    TIFF_PREDICTOR = 0x13D
-};
-
-enum TiffCompr{
-    TIFF_RAW = 1,
-    TIFF_CCITT_RLE,
-    TIFF_G3,
-    TIFF_G4,
-    TIFF_LZW,
-    TIFF_JPEG,
-    TIFF_NEWJPEG,
-    TIFF_ADOBE_DEFLATE,
-    TIFF_PACKBITS = 0x8005,
-    TIFF_DEFLATE = 0x80B2
-};
-
-enum TiffTypes{
-    TIFF_BYTE = 1,
-    TIFF_STRING,
-    TIFF_SHORT,
-    TIFF_LONG,
-    TIFF_LONGLONG
-};
 
 typedef struct TiffContext {
     AVCodecContext *avctx;
@@ -68,22 +41,24 @@ typedef struct TiffContext {
     unsigned int bpp;
     int le;
     int compr;
+    int invert;
 
     int strips, rps;
     int sot;
     uint8_t* stripdata;
     uint8_t* stripsizes;
     int stripsize, stripoff;
+    LZWState *lzw;
 } TiffContext;
 
 static int tget_short(uint8_t **p, int le){
-    int v = le ? LE_16(*p) : BE_16(*p);
+    int v = le ? AV_RL16(*p) : AV_RB16(*p);
     *p += 2;
     return v;
 }
 
 static int tget_long(uint8_t **p, int le){
-    int v = le ? LE_32(*p) : BE_32(*p);
+    int v = le ? AV_RL32(*p) : AV_RB32(*p);
     *p += 4;
     return v;
 }
@@ -106,10 +81,6 @@ static int tiff_unpack_strip(TiffContext *s, uint8_t* dst, int stride, uint8_t *
 
     if(s->compr == TIFF_DEFLATE || s->compr == TIFF_ADOBE_DEFLATE){
         outlen = width * lines;
-        if(lines != s->height){
-            av_log(s->avctx, AV_LOG_ERROR, "This decoder won't decode ZLib-packed TIFF with %i lines per strip\n", lines);
-            return -1;
-        }
         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);
@@ -126,6 +97,12 @@ static int tiff_unpack_strip(TiffContext *s, uint8_t* dst, int stride, uint8_t *
         return 0;
     }
 #endif
+    if(s->compr == TIFF_LZW){
+        if(ff_lzw_decode_init(s->lzw, 8, src, size, FF_LZW_TIFF) < 0){
+            av_log(s->avctx, AV_LOG_ERROR, "Error initializing LZW decoder\n");
+            return -1;
+        }
+    }
     for(line = 0; line < lines; line++){
         if(src - ssrc > size){
             av_log(s->avctx, AV_LOG_ERROR, "Source data overread\n");
@@ -160,6 +137,13 @@ static int tiff_unpack_strip(TiffContext *s, uint8_t* dst, int stride, uint8_t *
                 }
             }
             break;
+        case TIFF_LZW:
+            pixels = ff_lzw_decode(s->lzw, dst, width);
+            if(pixels < width){
+                av_log(s->avctx, AV_LOG_ERROR, "Decoded only %i bytes of %i\n", pixels, width);
+                return -1;
+            }
+            break;
         }
         dst += stride;
     }
@@ -172,6 +156,7 @@ static int tiff_decode_tag(TiffContext *s, uint8_t *start, uint8_t *buf, uint8_t
     int tag, type, count, off, value = 0;
     uint8_t *src, *dst;
     int i, j, ssize, soff, stride;
+    int *pal, *rp, *gp, *bp;
 
     tag = tget_short(&buf, s->le);
     type = tget_short(&buf, s->le);
@@ -194,6 +179,8 @@ static int tiff_decode_tag(TiffContext *s, uint8_t *start, uint8_t *buf, uint8_t
             value = -1;
             buf = start + off;
         }
+    }else if(type_sizes[type] * count <= 4){
+        buf -= 4;
     }else{
         buf = start + off;
     }
@@ -209,44 +196,66 @@ static int tiff_decode_tag(TiffContext *s, uint8_t *start, uint8_t *buf, uint8_t
         break;
     case TIFF_HEIGHT:
         s->height = value;
-        s->avctx->pix_fmt = PIX_FMT_RGB24;
-        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;
-        }
         break;
     case TIFF_BPP:
         if(count == 1) s->bpp = value;
         else{
             switch(type){
             case TIFF_BYTE:
-                s->bpp = (off & 0xFF) + ((off >> 8) & 0xFF) + ((off >> 16) & 0xFF);
+                s->bpp = (off & 0xFF) + ((off >> 8) & 0xFF) + ((off >> 16) & 0xFF) + ((off >> 24) & 0xFF);
                 break;
             case TIFF_SHORT:
             case TIFF_LONG:
-                s->bpp = tget(&buf, type, s->le) + tget(&buf, type, s->le) + tget(&buf, type, s->le);
+                s->bpp = 0;
+                for(i = 0; i < count; i++) s->bpp += tget(&buf, type, s->le);
                 break;
             default:
                 s->bpp = -1;
             }
         }
-        if(s->bpp != 24){
-            av_log(s->avctx, AV_LOG_ERROR, "Only RGB24 is supported\n");
+        switch(s->bpp){
+        case 8:
+            s->avctx->pix_fmt = PIX_FMT_PAL8;
+            break;
+        case 24:
+            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;
+            }
+            break;
+        default:
+            av_log(s->avctx, AV_LOG_ERROR, "This format is not supported (bpp=%i)\n", s->bpp);
+            return -1;
+        }
+        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->bpp == 8){
+            /* make default grayscale pal */
+            pal = s->picture.data[1];
+            for(i = 0; i < 256; i++)
+                pal[i] = i * 0x010101;
+        }
         break;
     case TIFF_COMPR:
         s->compr = value;
         switch(s->compr){
         case TIFF_RAW:
         case TIFF_PACKBITS:
+        case TIFF_LZW:
             break;
         case TIFF_DEFLATE:
         case TIFF_ADOBE_DEFLATE:
@@ -256,9 +265,6 @@ static int tiff_decode_tag(TiffContext *s, uint8_t *start, uint8_t *buf, uint8_t
             av_log(s->avctx, AV_LOG_ERROR, "Deflate: ZLib not compiled in\n");
             return -1;
 #endif
-        case TIFF_LZW:
-            av_log(s->avctx, AV_LOG_ERROR, "LZW: not implemented yet\n");
-            return -1;
         case TIFF_G3:
             av_log(s->avctx, AV_LOG_ERROR, "CCITT G3 compression is not supported\n");
             return -1;
@@ -268,13 +274,17 @@ static int tiff_decode_tag(TiffContext *s, uint8_t *start, uint8_t *buf, uint8_t
         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");
+            return -1;
         default:
             av_log(s->avctx, AV_LOG_ERROR, "Unknown compression method %i\n", s->compr);
             return -1;
         }
         break;
     case TIFF_ROWSPERSTRIP:
-        if(value < 1 || value > s->height){
+        if(value < 1){
             av_log(s->avctx, AV_LOG_ERROR, "Incorrect value of rows per strip\n");
             return -1;
         }
@@ -287,6 +297,7 @@ static int tiff_decode_tag(TiffContext *s, uint8_t *start, uint8_t *buf, uint8_t
         }else
             s->stripdata = start + off;
         s->strips = count;
+        if(s->strips == 1) s->rps = s->height;
         s->sot = type;
         if(s->stripdata > end_buf){
             av_log(s->avctx, AV_LOG_ERROR, "Tag referencing position outside the image\n");
@@ -335,7 +346,7 @@ static int tiff_decode_tag(TiffContext *s, uint8_t *start, uint8_t *buf, uint8_t
             return -1;
         }
         if(value == 2){
-            src = pic->data[0] + pic->linesize[0];
+            src = pic->data[0];
             stride = pic->linesize[0];
             soff = s->bpp >> 3;
             ssize = s->width * soff;
@@ -346,6 +357,46 @@ static int tiff_decode_tag(TiffContext *s, uint8_t *start, uint8_t *buf, uint8_t
             }
         }
         break;
+    case TIFF_INVERT:
+        switch(value){
+        case 0:
+            s->invert = 1;
+            break;
+        case 1:
+            s->invert = 0;
+            break;
+        case 2:
+        case 3:
+            break;
+        default:
+            av_log(s->avctx, AV_LOG_ERROR, "Color mode %d is not supported\n", value);
+            return -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");
+            return -1;
+        }
+        pal = s->picture.data[1];
+        off = type_sizes[type];
+        rp = buf;
+        gp = buf + count / 3 * off;
+        bp = buf + count / 3 * off * 2;
+        off = (type_sizes[type] - 1) << 3;
+        for(i = 0; i < count / 3; i++){
+            j = (tget(&rp, type, s->le) >> off) << 16;
+            j |= (tget(&gp, type, s->le) >> off) << 8;
+            j |= tget(&bp, type, s->le) >> off;
+            pal[i] = j;
+        }
+        break;
+    case TIFF_PLANAR:
+        if(value == 2){
+            av_log(s->avctx, AV_LOG_ERROR, "Planar format is not supported\n");
+            return -1;
+        }
+        break;
     }
     return 0;
 }
@@ -362,7 +413,7 @@ static int decode_frame(AVCodecContext *avctx,
     int i, entries;
 
     //parse image header
-    id = LE_16(buf); buf += 2;
+    id = AV_RL16(buf); buf += 2;
     if(id == 0x4949) le = 1;
     else if(id == 0x4D4D) le = 0;
     else{
@@ -370,6 +421,7 @@ static int decode_frame(AVCodecContext *avctx,
         return -1;
     }
     s->le = le;
+    s->invert = 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){
@@ -390,6 +442,17 @@ static int decode_frame(AVCodecContext *avctx,
         buf += 12;
     }
 
+    if(s->invert){
+        uint8_t *src;
+        int j;
+
+        src = s->picture.data[0];
+        for(j = 0; j < s->height; j++){
+            for(i = 0; i < s->picture.linesize[0]; i++)
+                src[i] = 255 - src[i];
+            src += s->picture.linesize[0];
+        }
+    }
     *picture= *(AVFrame*)&s->picture;
     *data_size = sizeof(AVPicture);
 
@@ -405,6 +468,7 @@ static int tiff_init(AVCodecContext *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);
 
     return 0;
 }
@@ -413,6 +477,7 @@ static int tiff_end(AVCodecContext *avctx)
 {
     TiffContext * const s = avctx->priv_data;
 
+    ff_lzw_decode_close(&s->lzw);
     if(s->picture.data[0])
         avctx->release_buffer(avctx, &s->picture);
     return 0;