LCOV - code coverage report
Current view: top level - libavcodec - lzw.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 86 96 89.6 %
Date: 2017-12-14 01:15:32 Functions: 6 6 100.0 %

          Line data    Source code
       1             : /*
       2             :  * LZW decoder
       3             :  * Copyright (c) 2003 Fabrice Bellard
       4             :  * Copyright (c) 2006 Konstantin Shishkov
       5             :  *
       6             :  * This file is part of FFmpeg.
       7             :  *
       8             :  * FFmpeg is free software; you can redistribute it and/or
       9             :  * modify it under the terms of the GNU Lesser General Public
      10             :  * License as published by the Free Software Foundation; either
      11             :  * version 2.1 of the License, or (at your option) any later version.
      12             :  *
      13             :  * FFmpeg is distributed in the hope that it will be useful,
      14             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      15             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      16             :  * Lesser General Public License for more details.
      17             :  *
      18             :  * You should have received a copy of the GNU Lesser General Public
      19             :  * License along with FFmpeg; if not, write to the Free Software
      20             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      21             :  */
      22             : 
      23             : /**
      24             :  * @file
      25             :  * @brief LZW decoding routines
      26             :  * @author Fabrice Bellard
      27             :  * @author modified for use in TIFF by Konstantin Shishkov
      28             :  */
      29             : 
      30             : #include "avcodec.h"
      31             : #include "bytestream.h"
      32             : #include "lzw.h"
      33             : #include "libavutil/mem.h"
      34             : 
      35             : #define LZW_MAXBITS                 12
      36             : #define LZW_SIZTABLE                (1<<LZW_MAXBITS)
      37             : 
      38             : static const uint16_t mask[17] =
      39             : {
      40             :     0x0000, 0x0001, 0x0003, 0x0007,
      41             :     0x000F, 0x001F, 0x003F, 0x007F,
      42             :     0x00FF, 0x01FF, 0x03FF, 0x07FF,
      43             :     0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF
      44             : };
      45             : 
      46             : struct LZWState {
      47             :     GetByteContext gb;
      48             :     int bbits;
      49             :     unsigned int bbuf;
      50             : 
      51             :     int mode;                   ///< Decoder mode
      52             :     int cursize;                ///< The current code size
      53             :     int curmask;
      54             :     int codesize;
      55             :     int clear_code;
      56             :     int end_code;
      57             :     int newcodes;               ///< First available code
      58             :     int top_slot;               ///< Highest code for current size
      59             :     int extra_slot;
      60             :     int slot;                   ///< Last read code
      61             :     int fc, oc;
      62             :     uint8_t *sp;
      63             :     uint8_t stack[LZW_SIZTABLE];
      64             :     uint8_t suffix[LZW_SIZTABLE];
      65             :     uint16_t prefix[LZW_SIZTABLE];
      66             :     int bs;                     ///< current buffer size for GIF
      67             : };
      68             : 
      69             : /* get one code from stream */
      70     2165543 : static int lzw_get_code(struct LZWState * s)
      71             : {
      72             :     int c;
      73             : 
      74     2165543 :     if(s->mode == FF_LZW_GIF) {
      75     7274136 :         while (s->bbits < s->cursize) {
      76     2943050 :             if (!s->bs) {
      77       12583 :                 s->bs = bytestream2_get_byte(&s->gb);
      78             :             }
      79     2943050 :             s->bbuf |= bytestream2_get_byte(&s->gb) << s->bbits;
      80     2943050 :             s->bbits += 8;
      81     2943050 :             s->bs--;
      82             :         }
      83     2165543 :         c = s->bbuf;
      84     2165543 :         s->bbuf >>= s->cursize;
      85             :     } else { // TIFF
      86           0 :         while (s->bbits < s->cursize) {
      87           0 :             s->bbuf = (s->bbuf << 8) | bytestream2_get_byte(&s->gb);
      88           0 :             s->bbits += 8;
      89             :         }
      90           0 :         c = s->bbuf >> (s->bbits - s->cursize);
      91             :     }
      92     2165543 :     s->bbits -= s->cursize;
      93     2165543 :     return c & s->curmask;
      94             : }
      95             : 
      96        1294 : int ff_lzw_decode_tail(LZWState *p)
      97             : {
      98        1294 :     struct LZWState *s = (struct LZWState *)p;
      99             : 
     100        1294 :     if(s->mode == FF_LZW_GIF) {
     101        3882 :         while (s->bs > 0 && bytestream2_get_bytes_left(&s->gb)) {
     102        1294 :             bytestream2_skip(&s->gb, s->bs);
     103        1294 :             s->bs = bytestream2_get_byte(&s->gb);
     104             :         }
     105             :     }else
     106           0 :         bytestream2_skip(&s->gb, bytestream2_get_bytes_left(&s->gb));
     107        1294 :     return bytestream2_tell(&s->gb);
     108             : }
     109             : 
     110          37 : av_cold void ff_lzw_decode_open(LZWState **p)
     111             : {
     112          37 :     *p = av_mallocz(sizeof(struct LZWState));
     113          37 : }
     114             : 
     115          37 : av_cold void ff_lzw_decode_close(LZWState **p)
     116             : {
     117          37 :     av_freep(p);
     118          37 : }
     119             : 
     120             : /**
     121             :  * Initialize LZW decoder
     122             :  * @param p LZW context
     123             :  * @param csize initial code size in bits
     124             :  * @param buf input data
     125             :  * @param buf_size input data size
     126             :  * @param mode decoder working mode - either GIF or TIFF
     127             :  */
     128        1294 : int ff_lzw_decode_init(LZWState *p, int csize, const uint8_t *buf, int buf_size, int mode)
     129             : {
     130        1294 :     struct LZWState *s = (struct LZWState *)p;
     131             : 
     132        1294 :     if(csize < 1 || csize >= LZW_MAXBITS)
     133           0 :         return -1;
     134             :     /* read buffer */
     135        1294 :     bytestream2_init(&s->gb, buf, buf_size);
     136        1294 :     s->bbuf = 0;
     137        1294 :     s->bbits = 0;
     138        1294 :     s->bs = 0;
     139             : 
     140             :     /* decoder */
     141        1294 :     s->codesize = csize;
     142        1294 :     s->cursize = s->codesize + 1;
     143        1294 :     s->curmask = mask[s->cursize];
     144        1294 :     s->top_slot = 1 << s->cursize;
     145        1294 :     s->clear_code = 1 << s->codesize;
     146        1294 :     s->end_code = s->clear_code + 1;
     147        1294 :     s->slot = s->newcodes = s->clear_code + 2;
     148        1294 :     s->oc = s->fc = -1;
     149        1294 :     s->sp = s->stack;
     150             : 
     151        1294 :     s->mode = mode;
     152        1294 :     s->extra_slot = s->mode == FF_LZW_TIFF;
     153        1294 :     return 0;
     154             : }
     155             : 
     156             : /**
     157             :  * Decode given number of bytes
     158             :  * NOTE: the algorithm here is inspired from the LZW GIF decoder
     159             :  *  written by Steven A. Bennett in 1987.
     160             :  *
     161             :  * @param p LZW context
     162             :  * @param buf output buffer
     163             :  * @param len number of bytes to decode
     164             :  * @return number of bytes decoded
     165             :  */
     166       37973 : int ff_lzw_decode(LZWState *p, uint8_t *buf, int len){
     167             :     int l, c, code, oc, fc;
     168             :     uint8_t *sp;
     169       37973 :     struct LZWState *s = (struct LZWState *)p;
     170             : 
     171       37973 :     if (s->end_code < 0)
     172           0 :         return 0;
     173             : 
     174       37973 :     l = len;
     175       37973 :     sp = s->sp;
     176       37973 :     oc = s->oc;
     177       37973 :     fc = s->fc;
     178             : 
     179             :     for (;;) {
     180    11863201 :         while (sp > s->stack) {
     181     5328599 :             *buf++ = *(--sp);
     182     5328599 :             if ((--l) == 0)
     183       37973 :                 goto the_end;
     184             :         }
     185     2165543 :         c = lzw_get_code(s);
     186     2165543 :         if (c == s->end_code) {
     187           0 :             break;
     188     2165543 :         } else if (c == s->clear_code) {
     189        3060 :             s->cursize = s->codesize + 1;
     190        3060 :             s->curmask = mask[s->cursize];
     191        3060 :             s->slot = s->newcodes;
     192        3060 :             s->top_slot = 1 << s->cursize;
     193        3060 :             fc= oc= -1;
     194             :         } else {
     195     2162483 :             code = c;
     196     2162483 :             if (code == s->slot && fc>=0) {
     197       30208 :                 *sp++ = fc;
     198       30208 :                 code = oc;
     199     2132275 :             }else if(code >= s->slot)
     200           0 :                 break;
     201     7460874 :             while (code >= s->newcodes) {
     202     3135908 :                 *sp++ = s->suffix[code];
     203     3135908 :                 code = s->prefix[code];
     204             :             }
     205     2162483 :             *sp++ = code;
     206     2162483 :             if (s->slot < s->top_slot && oc>=0) {
     207     2159423 :                 s->suffix[s->slot] = code;
     208     2159423 :                 s->prefix[s->slot++] = oc;
     209             :             }
     210     2162483 :             fc = code;
     211     2162483 :             oc = c;
     212     2162483 :             if (s->slot >= s->top_slot - s->extra_slot) {
     213        1563 :                 if (s->cursize < LZW_MAXBITS) {
     214        1563 :                     s->top_slot <<= 1;
     215        1563 :                     s->curmask = mask[++s->cursize];
     216             :                 }
     217             :             }
     218             :         }
     219             :     }
     220           0 :     s->end_code = -1;
     221       37973 :   the_end:
     222       37973 :     s->sp = sp;
     223       37973 :     s->oc = oc;
     224       37973 :     s->fc = fc;
     225       37973 :     return len - l;
     226             : }

Generated by: LCOV version 1.13