LCOV - code coverage report
Current view: top level - libavcodec - faxcompr.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 81 235 34.5 %
Date: 2017-12-14 08:27:08 Functions: 5 7 71.4 %

          Line data    Source code
       1             : /*
       2             :  * CCITT Fax Group 3 and 4 decompression
       3             :  * Copyright (c) 2008 Konstantin Shishkov
       4             :  *
       5             :  * This file is part of FFmpeg.
       6             :  *
       7             :  * FFmpeg is free software; you can redistribute it and/or
       8             :  * modify it under the terms of the GNU Lesser General Public
       9             :  * License as published by the Free Software Foundation; either
      10             :  * version 2.1 of the License, or (at your option) any later version.
      11             :  *
      12             :  * FFmpeg is distributed in the hope that it will be useful,
      13             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      15             :  * Lesser General Public License for more details.
      16             :  *
      17             :  * You should have received a copy of the GNU Lesser General Public
      18             :  * License along with FFmpeg; if not, write to the Free Software
      19             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      20             :  */
      21             : 
      22             : /**
      23             :  * @file
      24             :  * CCITT Fax Group 3 and 4 decompression
      25             :  * @author Konstantin Shishkov
      26             :  */
      27             : #include "avcodec.h"
      28             : #include "get_bits.h"
      29             : #include "put_bits.h"
      30             : #include "faxcompr.h"
      31             : 
      32             : #define CCITT_SYMS 104
      33             : 
      34             : static const uint16_t ccitt_syms[CCITT_SYMS] = {
      35             :     0,    1,    2,    3,    4,    5,    6,    7,    8,    9,   10,   11,   12,
      36             :    13,   14,   15,   16,   17,   18,   19,   20,   21,   22,   23,   24,   25,
      37             :    26,   27,   28,   29,   30,   31,   32,   33,   34,   35,   36,   37,   38,
      38             :    39,   40,   41,   42,   43,   44,   45,   46,   47,   48,   49,   50,   51,
      39             :    52,   53,   54,   55,   56,   57,   58,   59,   60,   61,   62,   63,   64,
      40             :   128,  192,  256,  320,  384,  448,  512,  576,  640,  704,  768,  832,  896,
      41             :   960, 1024, 1088, 1152, 1216, 1280, 1344, 1408, 1472, 1536, 1600, 1664, 1728,
      42             :  1792, 1856, 1920, 1984, 2048, 2112, 2176, 2240, 2304, 2368, 2432, 2496, 2560
      43             : };
      44             : 
      45             : static const uint8_t ccitt_codes_bits[2][CCITT_SYMS] =
      46             : {
      47             :   {
      48             :     0x35, 0x07, 0x07, 0x08, 0x0B, 0x0C, 0x0E, 0x0F, 0x13, 0x14, 0x07, 0x08, 0x08,
      49             :     0x03, 0x34, 0x35, 0x2A, 0x2B, 0x27, 0x0C, 0x08, 0x17, 0x03, 0x04, 0x28, 0x2B,
      50             :     0x13, 0x24, 0x18, 0x02, 0x03, 0x1A, 0x1B, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
      51             :     0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x04, 0x05, 0x0A, 0x0B, 0x52, 0x53, 0x54,
      52             :     0x55, 0x24, 0x25, 0x58, 0x59, 0x5A, 0x5B, 0x4A, 0x4B, 0x32, 0x33, 0x34, 0x1B,
      53             :     0x12, 0x17, 0x37, 0x36, 0x37, 0x64, 0x65, 0x68, 0x67, 0xCC, 0xCD, 0xD2, 0xD3,
      54             :     0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0x98, 0x99, 0x9A, 0x18, 0x9B,
      55             :     0x08, 0x0C, 0x0D, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F
      56             :   },
      57             :   {
      58             :     0x37, 0x02, 0x03, 0x02, 0x03, 0x03, 0x02, 0x03, 0x05, 0x04, 0x04, 0x05, 0x07,
      59             :     0x04, 0x07, 0x18, 0x17, 0x18, 0x08, 0x67, 0x68, 0x6C, 0x37, 0x28, 0x17, 0x18,
      60             :     0xCA, 0xCB, 0xCC, 0xCD, 0x68, 0x69, 0x6A, 0x6B, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6,
      61             :     0xD7, 0x6C, 0x6D, 0xDA, 0xDB, 0x54, 0x55, 0x56, 0x57, 0x64, 0x65, 0x52, 0x53,
      62             :     0x24, 0x37, 0x38, 0x27, 0x28, 0x58, 0x59, 0x2B, 0x2C, 0x5A, 0x66, 0x67, 0x0F,
      63             :     0xC8, 0xC9, 0x5B, 0x33, 0x34, 0x35, 0x6C, 0x6D, 0x4A, 0x4B, 0x4C, 0x4D, 0x72,
      64             :     0x73, 0x74, 0x75, 0x76, 0x77, 0x52, 0x53, 0x54, 0x55, 0x5A, 0x5B, 0x64, 0x65,
      65             :     0x08, 0x0C, 0x0D, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F
      66             :   }
      67             : };
      68             : 
      69             : static const uint8_t ccitt_codes_lens[2][CCITT_SYMS] =
      70             : {
      71             :   {
      72             :      8,  6,  4,  4,  4,  4,  4,  4,  5,  5,  5,  5,  6,  6,  6,  6,  6,  6,  7,  7,
      73             :      7,  7,  7,  7,  7,  7,  7,  7,  7,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
      74             :      8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
      75             :      8,  8,  8,  8,  5,  5,  6,  7,  8,  8,  8,  8,  8,  8,  9,  9,  9,  9,  9,  9,
      76             :      9,  9,  9,  9,  9,  9,  9,  9,  9,  6,  9, 11, 11, 11, 12, 12, 12, 12, 12, 12,
      77             :     12, 12, 12, 12
      78             :   },
      79             :   {
      80             :     10,  3,  2,  2,  3,  4,  4,  5,  6,  6,  7,  7,  7,  8,  8,  9, 10, 10, 10, 11,
      81             :     11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
      82             :     12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
      83             :     12, 12, 12, 12, 10, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, 13, 13, 13, 13, 13,
      84             :     13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 11, 11, 11, 12, 12, 12, 12, 12, 12,
      85             :     12, 12, 12, 12
      86             :   }
      87             : };
      88             : 
      89             : static const uint8_t ccitt_group3_2d_bits[11] = {
      90             :     1, 1, 2, 2, 2, 1, 3, 3, 3, 1, 1
      91             : };
      92             : 
      93             : static const uint8_t ccitt_group3_2d_lens[11] = {
      94             :     4, 3, 7, 6, 3, 1, 3, 6, 7, 7, 9
      95             : };
      96             : 
      97             : static VLC ccitt_vlc[2], ccitt_group3_2d_vlc;
      98             : 
      99           9 : av_cold void ff_ccitt_unpack_init(void)
     100             : {
     101             :     static VLC_TYPE code_table1[528][2];
     102             :     static VLC_TYPE code_table2[648][2];
     103             :     int i;
     104             :     static int initialized = 0;
     105             : 
     106           9 :     if (initialized)
     107           4 :         return;
     108           5 :     ccitt_vlc[0].table = code_table1;
     109           5 :     ccitt_vlc[0].table_allocated = 528;
     110           5 :     ccitt_vlc[1].table = code_table2;
     111           5 :     ccitt_vlc[1].table_allocated = 648;
     112          15 :     for (i = 0; i < 2; i++) {
     113          10 :         ff_init_vlc_sparse(&ccitt_vlc[i], 9, CCITT_SYMS,
     114          10 :                            ccitt_codes_lens[i], 1, 1,
     115          10 :                            ccitt_codes_bits[i], 1, 1,
     116             :                            ccitt_syms, 2, 2,
     117             :                            INIT_VLC_USE_NEW_STATIC);
     118             :     }
     119           5 :     INIT_VLC_STATIC(&ccitt_group3_2d_vlc, 9, 11,
     120             :                     ccitt_group3_2d_lens, 1, 1,
     121             :                     ccitt_group3_2d_bits, 1, 1, 512);
     122           5 :     initialized = 1;
     123             : }
     124             : 
     125           0 : static int decode_uncompressed(AVCodecContext *avctx, GetBitContext *gb,
     126             :                                unsigned int *pix_left, int **runs,
     127             :                                const int *runend, int *mode)
     128             : {
     129           0 :     int eob = 0;
     130             :     int newmode;
     131           0 :     int saved_run = 0;
     132             : 
     133             :     do {
     134             :         int cwi, k;
     135           0 :         int cw = 0;
     136             :         int codes[2];
     137             :         do {
     138           0 :             cwi = show_bits(gb, 11);
     139           0 :             if (!cwi) {
     140           0 :                 av_log(avctx, AV_LOG_ERROR, "Invalid uncompressed codeword\n");
     141           0 :                 return AVERROR_INVALIDDATA;
     142             :             }
     143           0 :             cwi = 10 - av_log2(cwi);
     144           0 :             skip_bits(gb, cwi + 1);
     145           0 :             if (cwi > 5) {
     146           0 :                 newmode = get_bits1(gb);
     147           0 :                 eob = 1;
     148           0 :                 cwi -= 6;
     149             :             }
     150           0 :             cw += cwi;
     151           0 :         } while(cwi == 5);
     152             : 
     153           0 :         codes[0] = cw;
     154           0 :         codes[1] = !eob;
     155             : 
     156           0 :         for (k = 0; k < 2; k++) {
     157           0 :             if (codes[k]) {
     158           0 :                 if (*mode == !k) {
     159           0 :                     *(*runs)++ = saved_run;
     160           0 :                     if (*runs >= runend) {
     161           0 :                         av_log(avctx, AV_LOG_ERROR, "uncompressed run overrun\n");
     162           0 :                         return AVERROR_INVALIDDATA;
     163             :                     }
     164           0 :                     if (*pix_left <= saved_run) {
     165           0 :                         av_log(avctx, AV_LOG_ERROR, "uncompressed run went out of bounds\n");
     166           0 :                         return AVERROR_INVALIDDATA;
     167             :                     }
     168           0 :                     *pix_left -= saved_run;
     169           0 :                     saved_run = 0;
     170           0 :                     *mode = !*mode;
     171             :                 }
     172           0 :                 saved_run += codes[k];
     173             :             }
     174             :         }
     175           0 :     } while (!eob);
     176           0 :     *(*runs)++ = saved_run;
     177           0 :     if (*runs >= runend) {
     178           0 :         av_log(avctx, AV_LOG_ERROR, "uncompressed run overrun\n");
     179           0 :         return AVERROR_INVALIDDATA;
     180             :     }
     181           0 :     if (*pix_left <= saved_run) {
     182           0 :         if (*pix_left == saved_run)
     183           0 :             return 1;
     184           0 :         av_log(avctx, AV_LOG_ERROR, "uncompressed run went out of boundsE\n");
     185           0 :         return AVERROR_INVALIDDATA;
     186             :     }
     187           0 :     *pix_left -= saved_run;
     188           0 :     saved_run = 0;
     189           0 :     *mode = !*mode;
     190           0 :     if (newmode != *mode) { //FIXME CHECK
     191           0 :         *(*runs)++ = 0;
     192           0 :         if (*runs >= runend) {
     193           0 :             av_log(avctx, AV_LOG_ERROR, "uncompressed run overrun\n");
     194           0 :             return AVERROR_INVALIDDATA;
     195             :         }
     196           0 :         *mode = newmode;
     197             :     }
     198           0 :     return 0;
     199             : }
     200             : 
     201       12992 : static int decode_group3_1d_line(AVCodecContext *avctx, GetBitContext *gb,
     202             :                                  unsigned int pix_left, int *runs,
     203             :                                  const int *runend)
     204             : {
     205       12992 :     int mode         = 0;
     206       12992 :     unsigned int run = 0;
     207             :     unsigned int t;
     208             :     for (;;) {
     209     1498080 :         t    = get_vlc2(gb, ccitt_vlc[mode].table, 9, 2);
     210      755536 :         run += t;
     211      755536 :         if (t < 64) {
     212      663056 :             *runs++ = run;
     213      663056 :             if (runs >= runend) {
     214           0 :                 av_log(avctx, AV_LOG_ERROR, "Run overrun\n");
     215           0 :                 return AVERROR_INVALIDDATA;
     216             :             }
     217      663056 :             if (pix_left <= run) {
     218       12992 :                 if (pix_left == run)
     219       12992 :                     break;
     220           0 :                 av_log(avctx, AV_LOG_ERROR, "Run went out of bounds\n");
     221           0 :                 return AVERROR_INVALIDDATA;
     222             :             }
     223      650064 :             pix_left -= run;
     224      650064 :             run       = 0;
     225      650064 :             mode      = !mode;
     226       92480 :         } else if ((int)t == -1) {
     227           0 :             if (show_bits(gb, 12) == 15) {
     228             :                 int ret;
     229           0 :                 skip_bits(gb, 12);
     230           0 :                 ret = decode_uncompressed(avctx, gb, &pix_left, &runs, runend, &mode);
     231           0 :                 if (ret < 0) {
     232           0 :                     return ret;
     233           0 :                 } else if (ret)
     234           0 :                     break;
     235             :             } else {
     236           0 :                 av_log(avctx, AV_LOG_ERROR, "Incorrect code\n");
     237           0 :                 return AVERROR_INVALIDDATA;
     238             :             }
     239             :         }
     240             :     }
     241       12992 :     *runs++ = 0;
     242       12992 :     return 0;
     243             : }
     244             : 
     245           0 : static int decode_group3_2d_line(AVCodecContext *avctx, GetBitContext *gb,
     246             :                                  unsigned int width, int *runs,
     247             :                                  const int *runend, const int *ref)
     248             : {
     249           0 :     int mode          = 0, saved_run = 0, t;
     250           0 :     int run_off       = *ref++;
     251           0 :     unsigned int offs = 0, run = 0;
     252             : 
     253           0 :     while (offs < width) {
     254           0 :         int cmode = get_vlc2(gb, ccitt_group3_2d_vlc.table, 9, 1);
     255           0 :         if (cmode == -1) {
     256           0 :             av_log(avctx, AV_LOG_ERROR, "Incorrect mode VLC\n");
     257           0 :             return AVERROR_INVALIDDATA;
     258             :         }
     259           0 :         if (!cmode) { //pass mode
     260           0 :             if (run_off < width)
     261           0 :                 run_off += *ref++;
     262           0 :             run      = run_off - offs;
     263           0 :             offs     = run_off;
     264           0 :             if (run_off < width)
     265           0 :                 run_off += *ref++;
     266           0 :             if (offs > width) {
     267           0 :                 av_log(avctx, AV_LOG_ERROR, "Run went out of bounds\n");
     268           0 :                 return AVERROR_INVALIDDATA;
     269             :             }
     270           0 :             saved_run += run;
     271           0 :         } else if (cmode == 1) { //horizontal mode
     272             :             int k;
     273           0 :             for (k = 0; k < 2; k++) {
     274           0 :                 run = 0;
     275             :                 for (;;) {
     276           0 :                     t = get_vlc2(gb, ccitt_vlc[mode].table, 9, 2);
     277           0 :                     if (t == -1) {
     278           0 :                         av_log(avctx, AV_LOG_ERROR, "Incorrect code\n");
     279           0 :                         return AVERROR_INVALIDDATA;
     280             :                     }
     281           0 :                     run += t;
     282           0 :                     if (t < 64)
     283           0 :                         break;
     284             :                 }
     285           0 :                 *runs++ = run + saved_run;
     286           0 :                 if (runs >= runend) {
     287           0 :                     av_log(avctx, AV_LOG_ERROR, "Run overrun\n");
     288           0 :                     return AVERROR_INVALIDDATA;
     289             :                 }
     290           0 :                 saved_run = 0;
     291           0 :                 offs     += run;
     292           0 :                 if (offs > width || run > width) {
     293           0 :                     av_log(avctx, AV_LOG_ERROR, "Run went out of bounds\n");
     294           0 :                     return AVERROR_INVALIDDATA;
     295             :                 }
     296           0 :                 mode = !mode;
     297             :             }
     298           0 :         } else if (cmode == 9 || cmode == 10) {
     299           0 :             int xxx = get_bits(gb, 3);
     300           0 :             if (cmode == 9 && xxx == 7) {
     301             :                 int ret;
     302           0 :                 int pix_left = width - offs;
     303             : 
     304           0 :                 if (saved_run) {
     305           0 :                     av_log(avctx, AV_LOG_ERROR, "saved run %d on entering uncompressed mode\n", saved_run);
     306           0 :                     return AVERROR_INVALIDDATA;
     307             :                 }
     308           0 :                 ret = decode_uncompressed(avctx, gb, &pix_left, &runs, runend, &mode);
     309           0 :                 offs = width - pix_left;
     310           0 :                 if (ret < 0) {
     311           0 :                     return ret;
     312           0 :                 } else if (ret)
     313           0 :                     break;
     314             :             } else {
     315           0 :                 avpriv_report_missing_feature(avctx, "Special mode %d xxx=%d support", cmode, xxx);
     316           0 :                 return AVERROR_PATCHWELCOME;
     317             :             }
     318             :         } else { //vertical mode
     319           0 :             run      = run_off - offs + (cmode - 5);
     320           0 :             run_off -= *--ref;
     321           0 :             offs    += run;
     322           0 :             if (offs > width || run > width) {
     323           0 :                 av_log(avctx, AV_LOG_ERROR, "Run went out of bounds\n");
     324           0 :                 return AVERROR_INVALIDDATA;
     325             :             }
     326           0 :             *runs++ = run + saved_run;
     327           0 :             if (runs >= runend) {
     328           0 :                 av_log(avctx, AV_LOG_ERROR, "Run overrun\n");
     329           0 :                 return AVERROR_INVALIDDATA;
     330             :             }
     331           0 :             saved_run = 0;
     332           0 :             mode      = !mode;
     333             :         }
     334             :         //sync line pointers
     335           0 :         while (offs < width && run_off <= offs) {
     336           0 :             run_off += *ref++;
     337           0 :             run_off += *ref++;
     338             :         }
     339             :     }
     340           0 :     *runs++ = saved_run;
     341           0 :     if (saved_run) {
     342           0 :         if (runs >= runend) {
     343           0 :             av_log(avctx, AV_LOG_ERROR, "Run overrun\n");
     344           0 :             return -1;
     345             :         }
     346           0 :         *runs++ = 0;
     347             :     }
     348           0 :     return 0;
     349             : }
     350             : 
     351       12992 : static void put_line(uint8_t *dst, int size, int width, const int *runs)
     352             : {
     353             :     PutBitContext pb;
     354       12992 :     int run, mode = ~0, pix_left = width, run_idx = 0;
     355             : 
     356       12992 :     init_put_bits(&pb, dst, size);
     357      689040 :     while (pix_left > 0) {
     358      663056 :         run       = runs[run_idx++];
     359      663056 :         mode      = ~mode;
     360      663056 :         pix_left -= run;
     361     2465368 :         for (; run > 16; run -= 16)
     362     1802312 :             put_sbits(&pb, 16, mode);
     363      663056 :         if (run)
     364      663056 :             put_sbits(&pb, run, mode);
     365             :     }
     366       12992 :     flush_put_bits(&pb);
     367       12992 : }
     368             : 
     369       12992 : static int find_group3_syncmarker(GetBitContext *gb, int srcsize)
     370             : {
     371       12992 :     unsigned int state = -1;
     372       12992 :     srcsize -= get_bits_count(gb);
     373      168896 :     while (srcsize-- > 0) {
     374      155904 :         state += state + get_bits1(gb);
     375      155904 :         if ((state & 0xFFF) == 1)
     376       12992 :             return 0;
     377             :     }
     378           0 :     return -1;
     379             : }
     380             : 
     381          36 : int ff_ccitt_unpack(AVCodecContext *avctx, const uint8_t *src, int srcsize,
     382             :                     uint8_t *dst, int height, int stride,
     383             :                     enum TiffCompr compr, int opts)
     384             : {
     385             :     int j;
     386             :     GetBitContext gb;
     387          36 :     int *runs, *ref = NULL, *runend;
     388             :     int ret;
     389          36 :     int runsize = avctx->width + 2;
     390             :     int has_eol;
     391             : 
     392          36 :     runs = av_malloc_array(runsize, sizeof(runs[0]));
     393          36 :     ref  = av_malloc_array(runsize, sizeof(ref[0]));
     394          36 :     if (!runs || !ref) {
     395           0 :         ret = AVERROR(ENOMEM);
     396           0 :         goto fail;
     397             :     }
     398          36 :     ref[0] = avctx->width;
     399          36 :     ref[1] = 0;
     400          36 :     ref[2] = 0;
     401          36 :     if ((ret = init_get_bits8(&gb, src, srcsize)) < 0)
     402           0 :         goto fail;
     403          36 :     has_eol = show_bits(&gb, 12) == 1 || show_bits(&gb, 16) == 1;
     404             : 
     405       13028 :     for (j = 0; j < height; j++) {
     406       12992 :         runend = runs + runsize;
     407       12992 :         if (compr == TIFF_G4) {
     408           0 :             ret = decode_group3_2d_line(avctx, &gb, avctx->width, runs, runend,
     409             :                                         ref);
     410           0 :             if (ret < 0)
     411           0 :                 goto fail;
     412             :         } else {
     413       12992 :             int g3d1 = (compr == TIFF_G3) && !(opts & 1);
     414       12992 :             if (compr != TIFF_CCITT_RLE &&
     415       12992 :                 has_eol &&
     416       12992 :                 find_group3_syncmarker(&gb, srcsize * 8) < 0)
     417           0 :                 break;
     418       12992 :             if (compr == TIFF_CCITT_RLE || g3d1 || get_bits1(&gb))
     419       12992 :                 ret = decode_group3_1d_line(avctx, &gb, avctx->width, runs,
     420             :                                             runend);
     421             :             else
     422           0 :                 ret = decode_group3_2d_line(avctx, &gb, avctx->width, runs,
     423             :                                             runend, ref);
     424       12992 :             if (compr == TIFF_CCITT_RLE)
     425           0 :                 align_get_bits(&gb);
     426             :         }
     427       12992 :         if (avctx->err_recognition & AV_EF_EXPLODE && ret < 0)
     428           0 :             goto fail;
     429             : 
     430       12992 :         if (ret < 0) {
     431           0 :             put_line(dst, stride, avctx->width, ref);
     432             :         } else {
     433       12992 :             put_line(dst, stride, avctx->width, runs);
     434       12992 :             FFSWAP(int *, runs, ref);
     435             :         }
     436       12992 :         dst += stride;
     437             :     }
     438          36 :     ret = 0;
     439          36 : fail:
     440          36 :     av_free(runs);
     441          36 :     av_free(ref);
     442          36 :     return ret;
     443             : }

Generated by: LCOV version 1.13