libavcodec/tiff.c
Go to the documentation of this file.
00001 /*
00002  * TIFF image decoder
00003  * Copyright (c) 2006 Konstantin Shishkov
00004  *
00005  * This file is part of Libav.
00006  *
00007  * Libav is free software; you can redistribute it and/or
00008  * modify it under the terms of the GNU Lesser General Public
00009  * License as published by the Free Software Foundation; either
00010  * version 2.1 of the License, or (at your option) any later version.
00011  *
00012  * Libav is distributed in the hope that it will be useful,
00013  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00015  * Lesser General Public License for more details.
00016  *
00017  * You should have received a copy of the GNU Lesser General Public
00018  * License along with Libav; if not, write to the Free Software
00019  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00020  */
00021 
00028 #include "avcodec.h"
00029 #if CONFIG_ZLIB
00030 #include <zlib.h>
00031 #endif
00032 #include "lzw.h"
00033 #include "tiff.h"
00034 #include "faxcompr.h"
00035 #include "libavutil/common.h"
00036 #include "libavutil/intreadwrite.h"
00037 #include "libavutil/imgutils.h"
00038 
00039 typedef struct TiffContext {
00040     AVCodecContext *avctx;
00041     AVFrame picture;
00042 
00043     int width, height;
00044     unsigned int bpp, bppcount;
00045     uint32_t palette[256];
00046     int palette_is_set;
00047     int le;
00048     enum TiffCompr compr;
00049     int invert;
00050     int fax_opts;
00051     int predictor;
00052     int fill_order;
00053 
00054     int strips, rps, sstype;
00055     int sot;
00056     const uint8_t* stripdata;
00057     const uint8_t* stripsizes;
00058     int stripsize, stripoff;
00059     LZWState *lzw;
00060 } TiffContext;
00061 
00062 static unsigned tget_short(const uint8_t **p, int le) {
00063     unsigned v = le ? AV_RL16(*p) : AV_RB16(*p);
00064     *p += 2;
00065     return v;
00066 }
00067 
00068 static unsigned tget_long(const uint8_t **p, int le) {
00069     unsigned v = le ? AV_RL32(*p) : AV_RB32(*p);
00070     *p += 4;
00071     return v;
00072 }
00073 
00074 static unsigned tget(const uint8_t **p, int type, int le) {
00075     switch(type){
00076     case TIFF_BYTE : return *(*p)++;
00077     case TIFF_SHORT: return tget_short(p, le);
00078     case TIFF_LONG : return tget_long (p, le);
00079     default        : return UINT_MAX;
00080     }
00081 }
00082 
00083 #if CONFIG_ZLIB
00084 static int tiff_uncompress(uint8_t *dst, unsigned long *len, const uint8_t *src, int size)
00085 {
00086     z_stream zstream;
00087     int zret;
00088 
00089     memset(&zstream, 0, sizeof(zstream));
00090     zstream.next_in = src;
00091     zstream.avail_in = size;
00092     zstream.next_out = dst;
00093     zstream.avail_out = *len;
00094     zret = inflateInit(&zstream);
00095     if (zret != Z_OK) {
00096         av_log(NULL, AV_LOG_ERROR, "Inflate init error: %d\n", zret);
00097         return zret;
00098     }
00099     zret = inflate(&zstream, Z_SYNC_FLUSH);
00100     inflateEnd(&zstream);
00101     *len = zstream.total_out;
00102     return zret == Z_STREAM_END ? Z_OK : zret;
00103 }
00104 #endif
00105 
00106 static int tiff_unpack_strip(TiffContext *s, uint8_t* dst, int stride, const uint8_t *src, int size, int lines){
00107     int c, line, pixels, code;
00108     const uint8_t *ssrc = src;
00109     int width = ((s->width * s->bpp) + 7) >> 3;
00110 #if CONFIG_ZLIB
00111     uint8_t *zbuf; unsigned long outlen;
00112 
00113     if(s->compr == TIFF_DEFLATE || s->compr == TIFF_ADOBE_DEFLATE){
00114         int ret;
00115         outlen = width * lines;
00116         zbuf = av_malloc(outlen);
00117         ret = tiff_uncompress(zbuf, &outlen, src, size);
00118         if(ret != Z_OK){
00119             av_log(s->avctx, AV_LOG_ERROR, "Uncompressing failed (%lu of %lu) with error %d\n", outlen, (unsigned long)width * lines, ret);
00120             av_free(zbuf);
00121             return -1;
00122         }
00123         src = zbuf;
00124         for(line = 0; line < lines; line++){
00125             memcpy(dst, src, width);
00126             dst += stride;
00127             src += width;
00128         }
00129         av_free(zbuf);
00130         return 0;
00131     }
00132 #endif
00133     if(s->compr == TIFF_LZW){
00134         if(ff_lzw_decode_init(s->lzw, 8, src, size, FF_LZW_TIFF) < 0){
00135             av_log(s->avctx, AV_LOG_ERROR, "Error initializing LZW decoder\n");
00136             return -1;
00137         }
00138     }
00139     if(s->compr == TIFF_CCITT_RLE || s->compr == TIFF_G3 || s->compr == TIFF_G4){
00140         int i, ret = 0;
00141         uint8_t *src2 = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
00142 
00143         if(!src2 || (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE < (unsigned)size){
00144             av_log(s->avctx, AV_LOG_ERROR, "Error allocating temporary buffer\n");
00145             return -1;
00146         }
00147         if(s->fax_opts & 2){
00148             av_log(s->avctx, AV_LOG_ERROR, "Uncompressed fax mode is not supported (yet)\n");
00149             av_free(src2);
00150             return -1;
00151         }
00152         if(!s->fill_order){
00153             memcpy(src2, src, size);
00154         }else{
00155             for(i = 0; i < size; i++)
00156                 src2[i] = av_reverse[src[i]];
00157         }
00158         memset(src2+size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
00159         switch(s->compr){
00160         case TIFF_CCITT_RLE:
00161         case TIFF_G3:
00162         case TIFF_G4:
00163             ret = ff_ccitt_unpack(s->avctx, src2, size, dst, lines, stride, s->compr, s->fax_opts);
00164             break;
00165         }
00166         av_free(src2);
00167         return ret;
00168     }
00169     for(line = 0; line < lines; line++){
00170         if(src - ssrc > size){
00171             av_log(s->avctx, AV_LOG_ERROR, "Source data overread\n");
00172             return -1;
00173         }
00174         switch(s->compr){
00175         case TIFF_RAW:
00176             if (ssrc + size - src < width)
00177                 return AVERROR_INVALIDDATA;
00178             if (!s->fill_order) {
00179                 memcpy(dst, src, width);
00180             } else {
00181                 int i;
00182                 for (i = 0; i < width; i++)
00183                     dst[i] = av_reverse[src[i]];
00184             }
00185             src += width;
00186             break;
00187         case TIFF_PACKBITS:
00188             for(pixels = 0; pixels < width;){
00189                 if (ssrc + size - src < 2)
00190                     return AVERROR_INVALIDDATA;
00191                 code = (int8_t)*src++;
00192                 if(code >= 0){
00193                     code++;
00194                     if (pixels + code > width ||
00195                         ssrc + size - src < code) {
00196                         av_log(s->avctx, AV_LOG_ERROR, "Copy went out of bounds\n");
00197                         return -1;
00198                     }
00199                     memcpy(dst + pixels, src, code);
00200                     src += code;
00201                     pixels += code;
00202                 }else if(code != -128){ // -127..-1
00203                     code = (-code) + 1;
00204                     if(pixels + code > width){
00205                         av_log(s->avctx, AV_LOG_ERROR, "Run went out of bounds\n");
00206                         return -1;
00207                     }
00208                     c = *src++;
00209                     memset(dst + pixels, c, code);
00210                     pixels += code;
00211                 }
00212             }
00213             break;
00214         case TIFF_LZW:
00215             pixels = ff_lzw_decode(s->lzw, dst, width);
00216             if(pixels < width){
00217                 av_log(s->avctx, AV_LOG_ERROR, "Decoded only %i bytes of %i\n", pixels, width);
00218                 return -1;
00219             }
00220             break;
00221         }
00222         dst += stride;
00223     }
00224     return 0;
00225 }
00226 
00227 static int init_image(TiffContext *s)
00228 {
00229     int i, ret;
00230     uint32_t *pal;
00231 
00232     switch (s->bpp * 10 + s->bppcount) {
00233     case 11:
00234         s->avctx->pix_fmt = PIX_FMT_MONOBLACK;
00235         break;
00236     case 81:
00237         s->avctx->pix_fmt = PIX_FMT_PAL8;
00238         break;
00239     case 243:
00240         s->avctx->pix_fmt = PIX_FMT_RGB24;
00241         break;
00242     case 161:
00243         s->avctx->pix_fmt = PIX_FMT_GRAY16BE;
00244         break;
00245     case 324:
00246         s->avctx->pix_fmt = PIX_FMT_RGBA;
00247         break;
00248     case 483:
00249         s->avctx->pix_fmt = s->le ? PIX_FMT_RGB48LE : PIX_FMT_RGB48BE;
00250         break;
00251     default:
00252         av_log(s->avctx, AV_LOG_ERROR,
00253                "This format is not supported (bpp=%d, bppcount=%d)\n",
00254                s->bpp, s->bppcount);
00255         return AVERROR_INVALIDDATA;
00256     }
00257     if (s->width != s->avctx->width || s->height != s->avctx->height) {
00258         if ((ret = av_image_check_size(s->width, s->height, 0, s->avctx)) < 0)
00259             return ret;
00260         avcodec_set_dimensions(s->avctx, s->width, s->height);
00261     }
00262     if (s->picture.data[0])
00263         s->avctx->release_buffer(s->avctx, &s->picture);
00264     if ((ret = s->avctx->get_buffer(s->avctx, &s->picture)) < 0) {
00265         av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
00266         return ret;
00267     }
00268     if (s->avctx->pix_fmt == PIX_FMT_PAL8) {
00269         if (s->palette_is_set) {
00270             memcpy(s->picture.data[1], s->palette, sizeof(s->palette));
00271         } else {
00272             /* make default grayscale pal */
00273             pal = (uint32_t *) s->picture.data[1];
00274             for (i = 0; i < 256; i++)
00275                 pal[i] = i * 0x010101;
00276         }
00277     }
00278     return 0;
00279 }
00280 
00281 static int tiff_decode_tag(TiffContext *s, const uint8_t *start, const uint8_t *buf, const uint8_t *end_buf)
00282 {
00283     unsigned tag, type, count, off, value = 0;
00284     int i, j;
00285     uint32_t *pal;
00286     const uint8_t *rp, *gp, *bp;
00287 
00288     if (end_buf - buf < 12)
00289         return -1;
00290     tag = tget_short(&buf, s->le);
00291     type = tget_short(&buf, s->le);
00292     count = tget_long(&buf, s->le);
00293     off = tget_long(&buf, s->le);
00294 
00295     if (type == 0 || type >= FF_ARRAY_ELEMS(type_sizes)) {
00296         av_log(s->avctx, AV_LOG_DEBUG, "Unknown tiff type (%u) encountered\n", type);
00297         return 0;
00298     }
00299 
00300     if(count == 1){
00301         switch(type){
00302         case TIFF_BYTE:
00303         case TIFF_SHORT:
00304             buf -= 4;
00305             value = tget(&buf, type, s->le);
00306             buf = NULL;
00307             break;
00308         case TIFF_LONG:
00309             value = off;
00310             buf = NULL;
00311             break;
00312         case TIFF_STRING:
00313             if(count <= 4){
00314                 buf -= 4;
00315                 break;
00316             }
00317         default:
00318             value = UINT_MAX;
00319             buf = start + off;
00320         }
00321     } else {
00322         if (count <= 4 && type_sizes[type] * count <= 4) {
00323             buf -= 4;
00324         } else {
00325             buf = start + off;
00326         }
00327     }
00328 
00329     if(buf && (buf < start || buf > end_buf)){
00330         av_log(s->avctx, AV_LOG_ERROR, "Tag referencing position outside the image\n");
00331         return -1;
00332     }
00333 
00334     switch(tag){
00335     case TIFF_WIDTH:
00336         s->width = value;
00337         break;
00338     case TIFF_HEIGHT:
00339         s->height = value;
00340         break;
00341     case TIFF_BPP:
00342         s->bppcount = count;
00343         if(count > 4){
00344             av_log(s->avctx, AV_LOG_ERROR, "This format is not supported (bpp=%d, %d components)\n", s->bpp, count);
00345             return -1;
00346         }
00347         if(count == 1) s->bpp = value;
00348         else{
00349             switch(type){
00350             case TIFF_BYTE:
00351                 s->bpp = (off & 0xFF) + ((off >> 8) & 0xFF) + ((off >> 16) & 0xFF) + ((off >> 24) & 0xFF);
00352                 break;
00353             case TIFF_SHORT:
00354             case TIFF_LONG:
00355                 s->bpp = 0;
00356                 for(i = 0; i < count && buf < end_buf; i++) s->bpp += tget(&buf, type, s->le);
00357                 break;
00358             default:
00359                 s->bpp = -1;
00360             }
00361         }
00362         break;
00363     case TIFF_SAMPLES_PER_PIXEL:
00364         if (count != 1) {
00365             av_log(s->avctx, AV_LOG_ERROR,
00366                    "Samples per pixel requires a single value, many provided\n");
00367             return AVERROR_INVALIDDATA;
00368         }
00369         if (s->bppcount == 1)
00370             s->bpp *= value;
00371         s->bppcount = value;
00372         break;
00373     case TIFF_COMPR:
00374         s->compr = value;
00375         s->predictor = 0;
00376         switch(s->compr){
00377         case TIFF_RAW:
00378         case TIFF_PACKBITS:
00379         case TIFF_LZW:
00380         case TIFF_CCITT_RLE:
00381             break;
00382         case TIFF_G3:
00383         case TIFF_G4:
00384             s->fax_opts = 0;
00385             break;
00386         case TIFF_DEFLATE:
00387         case TIFF_ADOBE_DEFLATE:
00388 #if CONFIG_ZLIB
00389             break;
00390 #else
00391             av_log(s->avctx, AV_LOG_ERROR, "Deflate: ZLib not compiled in\n");
00392             return -1;
00393 #endif
00394         case TIFF_JPEG:
00395         case TIFF_NEWJPEG:
00396             av_log(s->avctx, AV_LOG_ERROR, "JPEG compression is not supported\n");
00397             return -1;
00398         default:
00399             av_log(s->avctx, AV_LOG_ERROR, "Unknown compression method %i\n", s->compr);
00400             return -1;
00401         }
00402         break;
00403     case TIFF_ROWSPERSTRIP:
00404         if (type == TIFF_LONG && value == UINT_MAX)
00405             value = s->avctx->height;
00406         if(value < 1){
00407             av_log(s->avctx, AV_LOG_ERROR, "Incorrect value of rows per strip\n");
00408             return -1;
00409         }
00410         s->rps = value;
00411         break;
00412     case TIFF_STRIP_OFFS:
00413         if(count == 1){
00414             s->stripdata = NULL;
00415             s->stripoff = value;
00416         }else
00417             s->stripdata = start + off;
00418         s->strips = count;
00419         if(s->strips == 1) s->rps = s->height;
00420         s->sot = type;
00421         if(s->stripdata > end_buf){
00422             av_log(s->avctx, AV_LOG_ERROR, "Tag referencing position outside the image\n");
00423             return -1;
00424         }
00425         break;
00426     case TIFF_STRIP_SIZE:
00427         if(count == 1){
00428             s->stripsizes = NULL;
00429             s->stripsize = value;
00430             s->strips = 1;
00431         }else{
00432             s->stripsizes = start + off;
00433         }
00434         s->strips = count;
00435         s->sstype = type;
00436         if(s->stripsizes > end_buf){
00437             av_log(s->avctx, AV_LOG_ERROR, "Tag referencing position outside the image\n");
00438             return -1;
00439         }
00440         break;
00441     case TIFF_PREDICTOR:
00442         s->predictor = value;
00443         break;
00444     case TIFF_INVERT:
00445         switch(value){
00446         case 0:
00447             s->invert = 1;
00448             break;
00449         case 1:
00450             s->invert = 0;
00451             break;
00452         case 2:
00453         case 3:
00454             break;
00455         default:
00456             av_log(s->avctx, AV_LOG_ERROR, "Color mode %d is not supported\n", value);
00457             return -1;
00458         }
00459         break;
00460     case TIFF_FILL_ORDER:
00461         if(value < 1 || value > 2){
00462             av_log(s->avctx, AV_LOG_ERROR, "Unknown FillOrder value %d, trying default one\n", value);
00463             value = 1;
00464         }
00465         s->fill_order = value - 1;
00466         break;
00467     case TIFF_PAL:
00468         pal = (uint32_t *) s->palette;
00469         off = type_sizes[type];
00470         if (count / 3 > 256 || end_buf - buf < count / 3 * off * 3)
00471             return -1;
00472         rp = buf;
00473         gp = buf + count / 3 * off;
00474         bp = buf + count / 3 * off * 2;
00475         off = (type_sizes[type] - 1) << 3;
00476         for(i = 0; i < count / 3; i++){
00477             j = (tget(&rp, type, s->le) >> off) << 16;
00478             j |= (tget(&gp, type, s->le) >> off) << 8;
00479             j |= tget(&bp, type, s->le) >> off;
00480             pal[i] = j;
00481         }
00482         s->palette_is_set = 1;
00483         break;
00484     case TIFF_PLANAR:
00485         if(value == 2){
00486             av_log(s->avctx, AV_LOG_ERROR, "Planar format is not supported\n");
00487             return -1;
00488         }
00489         break;
00490     case TIFF_T4OPTIONS:
00491         if(s->compr == TIFF_G3)
00492             s->fax_opts = value;
00493         break;
00494     case TIFF_T6OPTIONS:
00495         if(s->compr == TIFF_G4)
00496             s->fax_opts = value;
00497         break;
00498     default:
00499         av_log(s->avctx, AV_LOG_DEBUG, "Unknown or unsupported tag %d/0X%0X\n", tag, tag);
00500     }
00501     return 0;
00502 }
00503 
00504 static int decode_frame(AVCodecContext *avctx,
00505                         void *data, int *data_size,
00506                         AVPacket *avpkt)
00507 {
00508     const uint8_t *buf = avpkt->data;
00509     int buf_size = avpkt->size;
00510     TiffContext * const s = avctx->priv_data;
00511     AVFrame *picture = data;
00512     AVFrame * const p= (AVFrame*)&s->picture;
00513     const uint8_t *orig_buf = buf, *end_buf = buf + buf_size;
00514     unsigned off;
00515     int id, le, ret;
00516     int i, j, entries;
00517     int stride;
00518     unsigned soff, ssize;
00519     uint8_t *dst;
00520 
00521     //parse image header
00522     if (end_buf - buf < 8)
00523         return AVERROR_INVALIDDATA;
00524     id = AV_RL16(buf); buf += 2;
00525     if(id == 0x4949) le = 1;
00526     else if(id == 0x4D4D) le = 0;
00527     else{
00528         av_log(avctx, AV_LOG_ERROR, "TIFF header not found\n");
00529         return -1;
00530     }
00531     s->le = le;
00532     s->invert = 0;
00533     s->compr = TIFF_RAW;
00534     s->fill_order = 0;
00535     // As TIFF 6.0 specification puts it "An arbitrary but carefully chosen number
00536     // that further identifies the file as a TIFF file"
00537     if(tget_short(&buf, le) != 42){
00538         av_log(avctx, AV_LOG_ERROR, "The answer to life, universe and everything is not correct!\n");
00539         return -1;
00540     }
00541     // Reset these pointers so we can tell if they were set this frame
00542     s->stripsizes = s->stripdata = NULL;
00543     /* parse image file directory */
00544     off = tget_long(&buf, le);
00545     if (off >= UINT_MAX - 14 || end_buf - orig_buf < off + 14) {
00546         av_log(avctx, AV_LOG_ERROR, "IFD offset is greater than image size\n");
00547         return AVERROR_INVALIDDATA;
00548     }
00549     buf = orig_buf + off;
00550     entries = tget_short(&buf, le);
00551     for(i = 0; i < entries; i++){
00552         if(tiff_decode_tag(s, orig_buf, buf, end_buf) < 0)
00553             return -1;
00554         buf += 12;
00555     }
00556     if(!s->stripdata && !s->stripoff){
00557         av_log(avctx, AV_LOG_ERROR, "Image data is missing\n");
00558         return -1;
00559     }
00560     /* now we have the data and may start decoding */
00561     if ((ret = init_image(s)) < 0)
00562         return ret;
00563 
00564     if(s->strips == 1 && !s->stripsize){
00565         av_log(avctx, AV_LOG_WARNING, "Image data size missing\n");
00566         s->stripsize = buf_size - s->stripoff;
00567     }
00568     stride = p->linesize[0];
00569     dst = p->data[0];
00570     for(i = 0; i < s->height; i += s->rps){
00571         if(s->stripsizes) {
00572             if (s->stripsizes >= end_buf)
00573                 return AVERROR_INVALIDDATA;
00574             ssize = tget(&s->stripsizes, s->sstype, s->le);
00575         } else
00576             ssize = s->stripsize;
00577 
00578         if(s->stripdata){
00579             if (s->stripdata >= end_buf)
00580                 return AVERROR_INVALIDDATA;
00581             soff = tget(&s->stripdata, s->sot, s->le);
00582         }else
00583             soff = s->stripoff;
00584 
00585         if (soff > buf_size || ssize > buf_size - soff) {
00586             av_log(avctx, AV_LOG_ERROR, "Invalid strip size/offset\n");
00587             return -1;
00588         }
00589         if(tiff_unpack_strip(s, dst, stride, orig_buf + soff, ssize, FFMIN(s->rps, s->height - i)) < 0)
00590             break;
00591         dst += s->rps * stride;
00592     }
00593     if(s->predictor == 2){
00594         dst = p->data[0];
00595         soff = s->bpp >> 3;
00596         ssize = s->width * soff;
00597         for(i = 0; i < s->height; i++) {
00598             for(j = soff; j < ssize; j++)
00599                 dst[j] += dst[j - soff];
00600             dst += stride;
00601         }
00602     }
00603 
00604     if(s->invert){
00605         uint8_t *src;
00606         int j;
00607 
00608         src = s->picture.data[0];
00609         for(j = 0; j < s->height; j++){
00610             for(i = 0; i < s->picture.linesize[0]; i++)
00611                 src[i] = 255 - src[i];
00612             src += s->picture.linesize[0];
00613         }
00614     }
00615     *picture= *(AVFrame*)&s->picture;
00616     *data_size = sizeof(AVPicture);
00617 
00618     return buf_size;
00619 }
00620 
00621 static av_cold int tiff_init(AVCodecContext *avctx){
00622     TiffContext *s = avctx->priv_data;
00623 
00624     s->width = 0;
00625     s->height = 0;
00626     s->avctx = avctx;
00627     avcodec_get_frame_defaults((AVFrame*)&s->picture);
00628     avctx->coded_frame= (AVFrame*)&s->picture;
00629     ff_lzw_decode_open(&s->lzw);
00630     ff_ccitt_unpack_init();
00631 
00632     return 0;
00633 }
00634 
00635 static av_cold int tiff_end(AVCodecContext *avctx)
00636 {
00637     TiffContext * const s = avctx->priv_data;
00638 
00639     ff_lzw_decode_close(&s->lzw);
00640     if(s->picture.data[0])
00641         avctx->release_buffer(avctx, &s->picture);
00642     return 0;
00643 }
00644 
00645 AVCodec ff_tiff_decoder = {
00646     .name           = "tiff",
00647     .type           = AVMEDIA_TYPE_VIDEO,
00648     .id             = CODEC_ID_TIFF,
00649     .priv_data_size = sizeof(TiffContext),
00650     .init           = tiff_init,
00651     .close          = tiff_end,
00652     .decode         = decode_frame,
00653     .capabilities   = CODEC_CAP_DR1,
00654     .long_name = NULL_IF_CONFIG_SMALL("TIFF image"),
00655 };