LCOV - code coverage report
Current view: top level - libavcodec - clearvideo.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 0 147 0.0 %
Date: 2017-12-15 18:13:28 Functions: 0 6 0.0 %

          Line data    Source code
       1             : /*
       2             :  * ClearVideo decoder
       3             :  * Copyright (c) 2012 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             :  * ClearVideo decoder
      25             :  */
      26             : 
      27             : #include "avcodec.h"
      28             : #include "bytestream.h"
      29             : #include "get_bits.h"
      30             : #include "idctdsp.h"
      31             : #include "internal.h"
      32             : 
      33             : #define NUM_DC_CODES 127
      34             : #define NUM_AC_CODES 103
      35             : 
      36             : static const uint8_t clv_dc_codes[NUM_DC_CODES] = {
      37             :     0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
      38             :     0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
      39             :     0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x07, 0x0B,
      40             :     0x0C, 0x08, 0x08, 0x09, 0x04, 0x06, 0x07, 0x05,
      41             :     0x04, 0x05, 0x04, 0x06, 0x05, 0x06, 0x07, 0x05,
      42             :     0x06, 0x07, 0x06, 0x07, 0x08, 0x06, 0x07, 0x08,
      43             :     0x09, 0x0A, 0x0B, 0x07, 0x08, 0x09, 0x07, 0x08,
      44             :     0x06, 0x07, 0x08, 0x06, 0x04, 0x05, 0x02, 0x01,
      45             :     0x03, 0x06, 0x07, 0x07, 0x09, 0x0A, 0x0B, 0x09,
      46             :     0x0A, 0x0B, 0x0A, 0x0B, 0x0C, 0x0D, 0x0C, 0x09,
      47             :     0x0D, 0x0A, 0x0B, 0x08, 0x09, 0x0A, 0x0B, 0x07,
      48             :     0x08, 0x09, 0x0A, 0x0B, 0x06, 0x07, 0x06, 0x08,
      49             :     0x07, 0x09, 0x0A, 0x0B, 0x09, 0x0A, 0x0B, 0x0C,
      50             :     0x14, 0x0D, 0x0D, 0x0E, 0x0F, 0x15, 0x15, 0x16,
      51             :     0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E,
      52             :     0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25,
      53             : };
      54             : 
      55             : static const uint8_t clv_dc_bits[NUM_DC_CODES] = {
      56             :     22, 22, 22, 22, 22, 22, 22, 22,
      57             :     22, 22, 22, 22, 22, 22, 22, 22,
      58             :     22, 22, 22, 21, 22, 22, 19, 20,
      59             :     20, 19, 18, 18, 15, 17, 17, 16,
      60             :     14, 15, 12, 13, 14, 14, 14, 12,
      61             :     12, 12, 11, 11, 11, 10, 10, 10,
      62             :     10, 10, 10,  9,  9,  9,  8,  8,
      63             :      7,  7,  7,  6,  5,  5,  3,  1,
      64             :      3,  5,  5,  6,  7,  7,  7,  8,
      65             :      8,  8,  9,  9,  9,  9, 10, 11,
      66             :     10, 11, 11, 12, 12, 12, 12, 13,
      67             :     14, 14, 14, 14, 15, 15, 16, 17,
      68             :     16, 17, 18, 18, 19, 19, 19, 19,
      69             :     21, 19, 20, 19, 19, 21, 22, 22,
      70             :     22, 22, 22, 22, 22, 22, 22, 22,
      71             :     22, 22, 22, 22, 22, 22, 22,
      72             : };
      73             : 
      74             : static const uint16_t clv_ac_syms[NUM_AC_CODES] = {
      75             :     0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008,
      76             :     0x0009, 0x000A, 0x000B, 0x000C, 0x0011, 0x0012, 0x0013, 0x0014,
      77             :     0x0015, 0x0016, 0x0021, 0x0022, 0x0023, 0x0024, 0x0031, 0x0032,
      78             :     0x0033, 0x0041, 0x0042, 0x0043, 0x0051, 0x0052, 0x0053, 0x0061,
      79             :     0x0062, 0x0063, 0x0071, 0x0072, 0x0081, 0x0082, 0x0091, 0x0092,
      80             :     0x00A1, 0x00A2, 0x00B1, 0x00C1, 0x00D1, 0x00E1, 0x00F1, 0x0101,
      81             :     0x0111, 0x0121, 0x0131, 0x0141, 0x0151, 0x0161, 0x0171, 0x0181,
      82             :     0x0191, 0x01A1, 0x1001, 0x1002, 0x1003, 0x1011, 0x1012, 0x1021,
      83             :     0x1031, 0x1041, 0x1051, 0x1061, 0x1071, 0x1081, 0x1091, 0x10A1,
      84             :     0x10B1, 0x10C1, 0x10D1, 0x10E1, 0x10F1, 0x1101, 0x1111, 0x1121,
      85             :     0x1131, 0x1141, 0x1151, 0x1161, 0x1171, 0x1181, 0x1191, 0x11A1,
      86             :     0x11B1, 0x11C1, 0x11D1, 0x11E1, 0x11F1, 0x1201, 0x1211, 0x1221,
      87             :     0x1231, 0x1241, 0x1251, 0x1261, 0x1271, 0x1281, 0x1BFF,
      88             : };
      89             : 
      90             : static const uint8_t clv_ac_codes[NUM_AC_CODES] = {
      91             :     0x02, 0x0F, 0x15, 0x17, 0x1F, 0x25, 0x24, 0x21,
      92             :     0x20, 0x07, 0x06, 0x20, 0x06, 0x14, 0x1E, 0x0F,
      93             :     0x21, 0x50, 0x0E, 0x1D, 0x0E, 0x51, 0x0D, 0x23,
      94             :     0x0D, 0x0C, 0x22, 0x52, 0x0B, 0x0C, 0x53, 0x13,
      95             :     0x0B, 0x54, 0x12, 0x0A, 0x11, 0x09, 0x10, 0x08,
      96             :     0x16, 0x55, 0x15, 0x14, 0x1C, 0x1B, 0x21, 0x20,
      97             :     0x1F, 0x1E, 0x1D, 0x1C, 0x1B, 0x1A, 0x22, 0x23,
      98             :     0x56, 0x57, 0x07, 0x19, 0x05, 0x0F, 0x04, 0x0E,
      99             :     0x0D, 0x0C, 0x13, 0x12, 0x11, 0x10, 0x1A, 0x19,
     100             :     0x18, 0x17, 0x16, 0x15, 0x14, 0x13, 0x18, 0x17,
     101             :     0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x07, 0x06,
     102             :     0x05, 0x04, 0x24, 0x25, 0x26, 0x27, 0x58, 0x59,
     103             :     0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x03,
     104             : };
     105             : 
     106             : static const uint8_t clv_ac_bits[NUM_AC_CODES] = {
     107             :      2,  4,  6,  7,  8,  9,  9, 10,
     108             :     10, 11, 11, 11,  3,  6,  8, 10,
     109             :     11, 12,  4,  8, 10, 12,  5,  9,
     110             :     10,  5,  9, 12,  5, 10, 12,  6,
     111             :     10, 12,  6, 10,  6, 10,  6, 10,
     112             :      7, 12,  7,  7,  8,  8,  9,  9,
     113             :      9,  9,  9,  9,  9,  9, 11, 11,
     114             :     12, 12,  4,  9, 11,  6, 11,  6,
     115             :      6,  6,  7,  7,  7,  7,  8,  8,
     116             :      8,  8,  8,  8,  8,  8,  9,  9,
     117             :      9,  9,  9,  9,  9,  9, 10, 10,
     118             :     10, 10, 11, 11, 11, 11, 12, 12,
     119             :     12, 12, 12, 12, 12, 12,  7,
     120             : };
     121             : 
     122             : typedef struct CLVContext {
     123             :     AVCodecContext *avctx;
     124             :     IDCTDSPContext idsp;
     125             :     AVFrame        *pic;
     126             :     GetBitContext  gb;
     127             :     int            mb_width, mb_height;
     128             :     VLC            dc_vlc, ac_vlc;
     129             :     int            luma_dc_quant, chroma_dc_quant, ac_quant;
     130             :     DECLARE_ALIGNED(16, int16_t, block)[64];
     131             :     int            top_dc[3], left_dc[4];
     132             :     int            iframes_warning;
     133             : } CLVContext;
     134             : 
     135           0 : static inline int decode_block(CLVContext *ctx, int16_t *blk, int has_ac,
     136             :                                int ac_quant)
     137             : {
     138           0 :     GetBitContext *gb = &ctx->gb;
     139           0 :     int idx = 1, last = 0, val, skip;
     140             : 
     141           0 :     memset(blk, 0, sizeof(*blk) * 64);
     142           0 :     blk[0] = get_vlc2(gb, ctx->dc_vlc.table, 9, 3);
     143           0 :     if (blk[0] < 0)
     144           0 :         return AVERROR_INVALIDDATA;
     145           0 :     blk[0] -= 63;
     146             : 
     147           0 :     if (!has_ac)
     148           0 :         return 0;
     149             : 
     150           0 :     while (idx < 64 && !last) {
     151           0 :         val = get_vlc2(gb, ctx->ac_vlc.table, 9, 2);
     152           0 :         if (val < 0)
     153           0 :             return AVERROR_INVALIDDATA;
     154           0 :         if (val != 0x1BFF) {
     155           0 :             last =  val >> 12;
     156           0 :             skip = (val >> 4) & 0xFF;
     157           0 :             val &= 0xF;
     158           0 :             if (get_bits1(gb))
     159           0 :                 val = -val;
     160             :         } else {
     161           0 :             last = get_bits1(gb);
     162           0 :             skip = get_bits(gb, 6);
     163           0 :             val  = get_sbits(gb, 8);
     164             :         }
     165           0 :         if (val) {
     166           0 :             int aval = FFABS(val), sign = val < 0;
     167           0 :             val = ac_quant * (2 * aval + 1);
     168           0 :             if (!(ac_quant & 1))
     169           0 :                 val--;
     170           0 :             if (sign)
     171           0 :                 val = -val;
     172             :         }
     173           0 :         idx += skip;
     174           0 :         if (idx >= 64)
     175           0 :             return AVERROR_INVALIDDATA;
     176           0 :         blk[ff_zigzag_direct[idx++]] = val;
     177             :     }
     178             : 
     179           0 :     return (idx <= 64 && last) ? 0 : -1;
     180             : }
     181             : 
     182             : #define DCT_TEMPLATE(blk, step, bias, shift, dshift, OP)                \
     183             :     const int t0 = OP(2841 * blk[1 * step] +  565 * blk[7 * step]);     \
     184             :     const int t1 = OP( 565 * blk[1 * step] - 2841 * blk[7 * step]);     \
     185             :     const int t2 = OP(1609 * blk[5 * step] + 2408 * blk[3 * step]);     \
     186             :     const int t3 = OP(2408 * blk[5 * step] - 1609 * blk[3 * step]);     \
     187             :     const int t4 = OP(1108 * blk[2 * step] - 2676 * blk[6 * step]);     \
     188             :     const int t5 = OP(2676 * blk[2 * step] + 1108 * blk[6 * step]);     \
     189             :     const int t6 = ((blk[0 * step] + blk[4 * step]) * (1 << dshift)) + bias;  \
     190             :     const int t7 = ((blk[0 * step] - blk[4 * step]) * (1 << dshift)) + bias;  \
     191             :     const int t8 = t0 + t2;                                             \
     192             :     const int t9 = t0 - t2;                                             \
     193             :     const int tA = (int)(181U * (t9 + (t1 - t3)) + 0x80) >> 8;          \
     194             :     const int tB = (int)(181U * (t9 - (t1 - t3)) + 0x80) >> 8;          \
     195             :     const int tC = t1 + t3;                                             \
     196             :                                                                         \
     197             :     blk[0 * step] = (t6 + t5 + t8) >> shift;                            \
     198             :     blk[1 * step] = (t7 + t4 + tA) >> shift;                            \
     199             :     blk[2 * step] = (t7 - t4 + tB) >> shift;                            \
     200             :     blk[3 * step] = (t6 - t5 + tC) >> shift;                            \
     201             :     blk[4 * step] = (t6 - t5 - tC) >> shift;                            \
     202             :     blk[5 * step] = (t7 - t4 - tB) >> shift;                            \
     203             :     blk[6 * step] = (t7 + t4 - tA) >> shift;                            \
     204             :     blk[7 * step] = (t6 + t5 - t8) >> shift;                            \
     205             : 
     206             : #define ROP(x) x
     207             : #define COP(x) (((x) + 4) >> 3)
     208             : 
     209           0 : static void clv_dct(int16_t *block)
     210             : {
     211             :     int i;
     212             :     int16_t *ptr;
     213             : 
     214           0 :     ptr = block;
     215           0 :     for (i = 0; i < 8; i++) {
     216           0 :         DCT_TEMPLATE(ptr, 1, 0x80, 8, 11, ROP);
     217           0 :         ptr += 8;
     218             :     }
     219             : 
     220           0 :     ptr = block;
     221           0 :     for (i = 0; i < 8; i++) {
     222           0 :         DCT_TEMPLATE(ptr, 8, 0x2000, 14, 8, COP);
     223           0 :         ptr++;
     224             :     }
     225           0 : }
     226             : 
     227           0 : static int decode_mb(CLVContext *c, int x, int y)
     228             : {
     229             :     int i, has_ac[6], off;
     230             : 
     231           0 :     for (i = 0; i < 6; i++)
     232           0 :         has_ac[i] = get_bits1(&c->gb);
     233             : 
     234           0 :     off = x * 16 + y * 16 * c->pic->linesize[0];
     235           0 :     for (i = 0; i < 4; i++) {
     236           0 :         if (decode_block(c, c->block, has_ac[i], c->ac_quant) < 0)
     237           0 :             return AVERROR_INVALIDDATA;
     238           0 :         if (!x && !(i & 1)) {
     239           0 :             c->block[0] += c->top_dc[0];
     240           0 :             c->top_dc[0] = c->block[0];
     241             :         } else {
     242           0 :             c->block[0] += c->left_dc[(i & 2) >> 1];
     243             :         }
     244           0 :         c->left_dc[(i & 2) >> 1] = c->block[0];
     245           0 :         c->block[0]             *= c->luma_dc_quant;
     246           0 :         clv_dct(c->block);
     247           0 :         if (i == 2)
     248           0 :             off += c->pic->linesize[0] * 8;
     249           0 :         c->idsp.put_pixels_clamped(c->block,
     250           0 :                                    c->pic->data[0] + off + (i & 1) * 8,
     251           0 :                                    c->pic->linesize[0]);
     252             :     }
     253             : 
     254           0 :     off = x * 8 + y * 8 * c->pic->linesize[1];
     255           0 :     for (i = 1; i < 3; i++) {
     256           0 :         if (decode_block(c, c->block, has_ac[i + 3], c->ac_quant) < 0)
     257           0 :             return AVERROR_INVALIDDATA;
     258           0 :         if (!x) {
     259           0 :             c->block[0] += c->top_dc[i];
     260           0 :             c->top_dc[i] = c->block[0];
     261             :         } else {
     262           0 :             c->block[0] += c->left_dc[i + 1];
     263             :         }
     264           0 :         c->left_dc[i + 1] = c->block[0];
     265           0 :         c->block[0]      *= c->chroma_dc_quant;
     266           0 :         clv_dct(c->block);
     267           0 :         c->idsp.put_pixels_clamped(c->block, c->pic->data[i] + off,
     268           0 :                                    c->pic->linesize[i]);
     269             :     }
     270             : 
     271           0 :     return 0;
     272             : }
     273             : 
     274           0 : static int clv_decode_frame(AVCodecContext *avctx, void *data,
     275             :                             int *got_frame, AVPacket *avpkt)
     276             : {
     277           0 :     const uint8_t *buf = avpkt->data;
     278           0 :     int buf_size = avpkt->size;
     279           0 :     CLVContext *c = avctx->priv_data;
     280             :     GetByteContext gb;
     281             :     uint32_t frame_type;
     282             :     int i, j, ret;
     283           0 :     int mb_ret = 0;
     284             : 
     285           0 :     bytestream2_init(&gb, buf, buf_size);
     286           0 :     if (avctx->codec_tag == MKTAG('C', 'L', 'V', '1')) {
     287           0 :         int skip = bytestream2_get_byte(&gb);
     288           0 :         bytestream2_skip(&gb, (skip + 1) * 8);
     289             :     }
     290             : 
     291           0 :     frame_type = bytestream2_get_byte(&gb);
     292             : 
     293           0 :     if (frame_type & 0x2) {
     294           0 :         if (buf_size < c->mb_width * c->mb_height) {
     295           0 :             av_log(avctx, AV_LOG_ERROR, "Packet too small\n");
     296           0 :             return AVERROR_INVALIDDATA;
     297             :         }
     298             : 
     299           0 :         if ((ret = ff_reget_buffer(avctx, c->pic)) < 0)
     300           0 :             return ret;
     301             : 
     302           0 :         c->pic->key_frame = frame_type & 0x20 ? 1 : 0;
     303           0 :         c->pic->pict_type = frame_type & 0x20 ? AV_PICTURE_TYPE_I
     304           0 :                                               : AV_PICTURE_TYPE_P;
     305             : 
     306           0 :         bytestream2_get_be32(&gb); // frame size;
     307           0 :         c->ac_quant        = bytestream2_get_byte(&gb);
     308           0 :         c->luma_dc_quant   = 32;
     309           0 :         c->chroma_dc_quant = 32;
     310             : 
     311           0 :         if ((ret = init_get_bits8(&c->gb, buf + bytestream2_tell(&gb),
     312           0 :                                   buf_size - bytestream2_tell(&gb))) < 0)
     313           0 :             return ret;
     314             : 
     315           0 :         for (i = 0; i < 3; i++)
     316           0 :             c->top_dc[i] = 32;
     317           0 :         for (i = 0; i < 4; i++)
     318           0 :             c->left_dc[i] = 32;
     319             : 
     320           0 :         for (j = 0; j < c->mb_height; j++) {
     321           0 :             for (i = 0; i < c->mb_width; i++) {
     322           0 :                 ret = decode_mb(c, i, j);
     323           0 :                 if (ret < 0)
     324           0 :                     mb_ret = ret;
     325             :             }
     326             :         }
     327             : 
     328           0 :         if ((ret = av_frame_ref(data, c->pic)) < 0)
     329           0 :             return ret;
     330             : 
     331           0 :         *got_frame = 1;
     332             :     } else {
     333           0 :         if (!c->iframes_warning)
     334           0 :             avpriv_report_missing_feature(avctx, "Non-I-frames in Clearvideo");
     335           0 :         c->iframes_warning = 1;
     336           0 :         return AVERROR_PATCHWELCOME;
     337             :     }
     338             : 
     339           0 :     return mb_ret < 0 ? mb_ret : buf_size;
     340             : }
     341             : 
     342           0 : static av_cold int clv_decode_init(AVCodecContext *avctx)
     343             : {
     344           0 :     CLVContext *const c = avctx->priv_data;
     345             :     int ret;
     346             : 
     347           0 :     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
     348             : 
     349           0 :     c->avctx           = avctx;
     350           0 :     c->mb_width        = FFALIGN(avctx->width,  16) >> 4;
     351           0 :     c->mb_height       = FFALIGN(avctx->height, 16) >> 4;
     352           0 :     c->iframes_warning = 0;
     353           0 :     c->pic             = av_frame_alloc();
     354           0 :     if (!c->pic)
     355           0 :         return AVERROR(ENOMEM);
     356             : 
     357           0 :     ff_idctdsp_init(&c->idsp, avctx);
     358           0 :     ret = init_vlc(&c->dc_vlc, 9, NUM_DC_CODES,
     359             :                    clv_dc_bits,  1, 1,
     360             :                    clv_dc_codes, 1, 1, 0);
     361           0 :     if (ret) {
     362           0 :         av_log(avctx, AV_LOG_ERROR, "Error initialising DC VLC\n");
     363           0 :         return ret;
     364             :     }
     365           0 :     ret = ff_init_vlc_sparse(&c->ac_vlc, 9, NUM_AC_CODES,
     366             :                              clv_ac_bits,  1, 1,
     367             :                              clv_ac_codes, 1, 1,
     368             :                              clv_ac_syms,  2, 2, 0);
     369           0 :     if (ret) {
     370           0 :         av_log(avctx, AV_LOG_ERROR, "Error initialising AC VLC\n");
     371           0 :         return ret;
     372             :     }
     373             : 
     374           0 :     return 0;
     375             : }
     376             : 
     377           0 : static av_cold int clv_decode_end(AVCodecContext *avctx)
     378             : {
     379           0 :     CLVContext *const c = avctx->priv_data;
     380             : 
     381           0 :     av_frame_free(&c->pic);
     382             : 
     383           0 :     ff_free_vlc(&c->dc_vlc);
     384           0 :     ff_free_vlc(&c->ac_vlc);
     385             : 
     386           0 :     return 0;
     387             : }
     388             : 
     389             : AVCodec ff_clearvideo_decoder = {
     390             :     .name           = "clearvideo",
     391             :     .long_name      = NULL_IF_CONFIG_SMALL("Iterated Systems ClearVideo"),
     392             :     .type           = AVMEDIA_TYPE_VIDEO,
     393             :     .id             = AV_CODEC_ID_CLEARVIDEO,
     394             :     .priv_data_size = sizeof(CLVContext),
     395             :     .init           = clv_decode_init,
     396             :     .close          = clv_decode_end,
     397             :     .decode         = clv_decode_frame,
     398             :     .capabilities   = AV_CODEC_CAP_DR1,
     399             :     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
     400             : };

Generated by: LCOV version 1.13