LCOV - code coverage report
Current view: top level - libavcodec - indeo2.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 104 127 81.9 %
Date: 2017-12-16 13:57:32 Functions: 6 6 100.0 %

          Line data    Source code
       1             : /*
       2             :  * Intel Indeo 2 codec
       3             :  * Copyright (c) 2005 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             :  * Intel Indeo 2 decoder.
      25             :  */
      26             : 
      27             : #include "libavutil/attributes.h"
      28             : 
      29             : #define BITSTREAM_READER_LE
      30             : #include "avcodec.h"
      31             : #include "get_bits.h"
      32             : #include "indeo2data.h"
      33             : #include "internal.h"
      34             : #include "mathops.h"
      35             : 
      36             : typedef struct Ir2Context{
      37             :     AVCodecContext *avctx;
      38             :     AVFrame *picture;
      39             :     GetBitContext gb;
      40             :     int decode_delta;
      41             : } Ir2Context;
      42             : 
      43             : #define CODE_VLC_BITS 14
      44             : static VLC ir2_vlc;
      45             : 
      46             : /* Indeo 2 codes are in range 0x01..0x7F and 0x81..0x90 */
      47     2449607 : static inline int ir2_get_code(GetBitContext *gb)
      48             : {
      49     2449607 :     return get_vlc2(gb, ir2_vlc.table, CODE_VLC_BITS, 1) + 1;
      50             : }
      51             : 
      52         633 : static int ir2_decode_plane(Ir2Context *ctx, int width, int height, uint8_t *dst,
      53             :                             int pitch, const uint8_t *table)
      54             : {
      55             :     int i;
      56             :     int j;
      57         633 :     int out = 0;
      58             : 
      59         633 :     if (width & 1)
      60           0 :         return AVERROR_INVALIDDATA;
      61             : 
      62             :     /* first line contain absolute values, other lines contain deltas */
      63       26497 :     while (out < width) {
      64       25231 :         int c = ir2_get_code(&ctx->gb);
      65       25231 :         if (c >= 0x80) { /* we have a run */
      66         338 :             c -= 0x7F;
      67         338 :             if (out + c*2 > width)
      68           0 :                 return AVERROR_INVALIDDATA;
      69        1192 :             for (i = 0; i < c * 2; i++)
      70         854 :                 dst[out++] = 0x80;
      71             :         } else { /* copy two values from table */
      72       24893 :             if (c <= 0)
      73           0 :                 return AVERROR_INVALIDDATA;
      74       24893 :             dst[out++] = table[c * 2];
      75       24893 :             dst[out++] = table[(c * 2) + 1];
      76             :         }
      77             :     }
      78         633 :     dst += pitch;
      79             : 
      80       37980 :     for (j = 1; j < height; j++) {
      81       37347 :         out = 0;
      82       37347 :         if (get_bits_left(&ctx->gb) <= 0)
      83           0 :             return AVERROR_INVALIDDATA;
      84     2189775 :         while (out < width) {
      85     2115081 :             int c = ir2_get_code(&ctx->gb);
      86     2115081 :             if (c >= 0x80) { /* we have a skip */
      87      228280 :                 c -= 0x7F;
      88      228280 :                 if (out + c*2 > width)
      89           0 :                     return AVERROR_INVALIDDATA;
      90      961638 :                 for (i = 0; i < c * 2; i++) {
      91      733358 :                     dst[out] = dst[out - pitch];
      92      733358 :                     out++;
      93             :                 }
      94             :             } else { /* add two deltas from table */
      95             :                 int t;
      96     1886801 :                 if (c <= 0)
      97           0 :                     return AVERROR_INVALIDDATA;
      98     1886801 :                 t        = dst[out - pitch] + (table[c * 2] - 128);
      99     1886801 :                 t        = av_clip_uint8(t);
     100     1886801 :                 dst[out] = t;
     101     1886801 :                 out++;
     102     1886801 :                 t        = dst[out - pitch] + (table[(c * 2) + 1] - 128);
     103     1886801 :                 t        = av_clip_uint8(t);
     104     1886801 :                 dst[out] = t;
     105     1886801 :                 out++;
     106             :             }
     107             :         }
     108       37347 :         dst += pitch;
     109             :     }
     110         633 :     return 0;
     111             : }
     112             : 
     113          99 : static int ir2_decode_plane_inter(Ir2Context *ctx, int width, int height, uint8_t *dst,
     114             :                                   int pitch, const uint8_t *table)
     115             : {
     116             :     int j;
     117          99 :     int out = 0;
     118             :     int c;
     119             :     int t;
     120             : 
     121          99 :     if (width & 1)
     122           0 :         return AVERROR_INVALIDDATA;
     123             : 
     124        6039 :     for (j = 0; j < height; j++) {
     125        5940 :         out = 0;
     126        5940 :         if (get_bits_left(&ctx->gb) <= 0)
     127           0 :             return AVERROR_INVALIDDATA;
     128      321175 :         while (out < width) {
     129      309295 :             c = ir2_get_code(&ctx->gb);
     130      309295 :             if (c >= 0x80) { /* we have a skip */
     131       56657 :                 c   -= 0x7F;
     132       56657 :                 out += c * 2;
     133             :             } else { /* add two deltas from table */
     134      252638 :                 if (c <= 0)
     135           0 :                     return AVERROR_INVALIDDATA;
     136      252638 :                 t        = dst[out] + (((table[c * 2] - 128)*3) >> 2);
     137      252638 :                 t        = av_clip_uint8(t);
     138      252638 :                 dst[out] = t;
     139      252638 :                 out++;
     140      252638 :                 t        = dst[out] + (((table[(c * 2) + 1] - 128)*3) >> 2);
     141      252638 :                 t        = av_clip_uint8(t);
     142      252638 :                 dst[out] = t;
     143      252638 :                 out++;
     144             :             }
     145             :         }
     146        5940 :         dst += pitch;
     147             :     }
     148          99 :     return 0;
     149             : }
     150             : 
     151         244 : static int ir2_decode_frame(AVCodecContext *avctx,
     152             :                         void *data, int *got_frame,
     153             :                         AVPacket *avpkt)
     154             : {
     155         244 :     Ir2Context * const s = avctx->priv_data;
     156         244 :     const uint8_t *buf   = avpkt->data;
     157         244 :     int buf_size         = avpkt->size;
     158         244 :     AVFrame *picture     = data;
     159         244 :     AVFrame * const p    = s->picture;
     160             :     int start, ret;
     161             :     int ltab, ctab;
     162             : 
     163         244 :     if ((ret = ff_reget_buffer(avctx, p)) < 0)
     164           0 :         return ret;
     165             : 
     166         244 :     start = 48; /* hardcoded for now */
     167             : 
     168         244 :     if (start >= buf_size) {
     169           0 :         av_log(s->avctx, AV_LOG_ERROR, "input buffer size too small (%d)\n", buf_size);
     170           0 :         return AVERROR_INVALIDDATA;
     171             :     }
     172             : 
     173         244 :     s->decode_delta = buf[18];
     174             : 
     175             :     /* decide whether frame uses deltas or not */
     176             : #ifndef BITSTREAM_READER_LE
     177             :     for (i = 0; i < buf_size; i++)
     178             :         buf[i] = ff_reverse[buf[i]];
     179             : #endif
     180             : 
     181         244 :     if ((ret = init_get_bits8(&s->gb, buf + start, buf_size - start)) < 0)
     182           0 :         return ret;
     183             : 
     184         244 :     ltab = buf[0x22] & 3;
     185         244 :     ctab = buf[0x22] >> 2;
     186             : 
     187         244 :     if (ctab > 3) {
     188           0 :         av_log(avctx, AV_LOG_ERROR, "ctab %d is invalid\n", ctab);
     189           0 :         return AVERROR_INVALIDDATA;
     190             :     }
     191             : 
     192         244 :     if (s->decode_delta) { /* intraframe */
     193         211 :         if ((ret = ir2_decode_plane(s, avctx->width, avctx->height,
     194             :                                     p->data[0], p->linesize[0],
     195         211 :                                     ir2_delta_table[ltab])) < 0)
     196           0 :             return ret;
     197             : 
     198             :         /* swapped U and V */
     199         211 :         if ((ret = ir2_decode_plane(s, avctx->width >> 2, avctx->height >> 2,
     200             :                                     p->data[2], p->linesize[2],
     201         211 :                                     ir2_delta_table[ctab])) < 0)
     202           0 :             return ret;
     203         211 :         if ((ret = ir2_decode_plane(s, avctx->width >> 2, avctx->height >> 2,
     204             :                                     p->data[1], p->linesize[1],
     205         211 :                                     ir2_delta_table[ctab])) < 0)
     206           0 :             return ret;
     207             :     } else { /* interframe */
     208          33 :         if ((ret = ir2_decode_plane_inter(s, avctx->width, avctx->height,
     209             :                                           p->data[0], p->linesize[0],
     210          33 :                                           ir2_delta_table[ltab])) < 0)
     211           0 :             return ret;
     212             :         /* swapped U and V */
     213          33 :         if ((ret = ir2_decode_plane_inter(s, avctx->width >> 2, avctx->height >> 2,
     214             :                                           p->data[2], p->linesize[2],
     215          33 :                                           ir2_delta_table[ctab])) < 0)
     216           0 :             return ret;
     217          33 :         if ((ret = ir2_decode_plane_inter(s, avctx->width >> 2, avctx->height >> 2,
     218             :                                           p->data[1], p->linesize[1],
     219          33 :                                           ir2_delta_table[ctab])) < 0)
     220           0 :             return ret;
     221             :     }
     222             : 
     223         244 :     if ((ret = av_frame_ref(picture, p)) < 0)
     224           0 :         return ret;
     225             : 
     226         244 :     *got_frame = 1;
     227             : 
     228         244 :     return buf_size;
     229             : }
     230             : 
     231           4 : static av_cold int ir2_decode_init(AVCodecContext *avctx)
     232             : {
     233           4 :     Ir2Context * const ic = avctx->priv_data;
     234             :     static VLC_TYPE vlc_tables[1 << CODE_VLC_BITS][2];
     235             : 
     236           4 :     ic->avctx = avctx;
     237             : 
     238           4 :     avctx->pix_fmt= AV_PIX_FMT_YUV410P;
     239             : 
     240           4 :     ic->picture = av_frame_alloc();
     241           4 :     if (!ic->picture)
     242           0 :         return AVERROR(ENOMEM);
     243             : 
     244           4 :     ir2_vlc.table = vlc_tables;
     245           4 :     ir2_vlc.table_allocated = 1 << CODE_VLC_BITS;
     246             : #ifdef BITSTREAM_READER_LE
     247           4 :         init_vlc(&ir2_vlc, CODE_VLC_BITS, IR2_CODES,
     248             :                  &ir2_codes[0][1], 4, 2,
     249             :                  &ir2_codes[0][0], 4, 2, INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);
     250             : #else
     251             :         init_vlc(&ir2_vlc, CODE_VLC_BITS, IR2_CODES,
     252             :                  &ir2_codes[0][1], 4, 2,
     253             :                  &ir2_codes[0][0], 4, 2, INIT_VLC_USE_NEW_STATIC);
     254             : #endif
     255             : 
     256           4 :     return 0;
     257             : }
     258             : 
     259           4 : static av_cold int ir2_decode_end(AVCodecContext *avctx)
     260             : {
     261           4 :     Ir2Context * const ic = avctx->priv_data;
     262             : 
     263           4 :     av_frame_free(&ic->picture);
     264             : 
     265           4 :     return 0;
     266             : }
     267             : 
     268             : AVCodec ff_indeo2_decoder = {
     269             :     .name           = "indeo2",
     270             :     .long_name      = NULL_IF_CONFIG_SMALL("Intel Indeo 2"),
     271             :     .type           = AVMEDIA_TYPE_VIDEO,
     272             :     .id             = AV_CODEC_ID_INDEO2,
     273             :     .priv_data_size = sizeof(Ir2Context),
     274             :     .init           = ir2_decode_init,
     275             :     .close          = ir2_decode_end,
     276             :     .decode         = ir2_decode_frame,
     277             :     .capabilities   = AV_CODEC_CAP_DR1,
     278             : };

Generated by: LCOV version 1.13