LCOV - code coverage report
Current view: top level - libavcodec - clearvideo.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 0 485 0.0 %
Date: 2018-05-20 11:54:08 Functions: 0 15 0.0 %

          Line data    Source code
       1             : /*
       2             :  * ClearVideo decoder
       3             :  * Copyright (c) 2012-2018 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             : #include "mathops.h"
      33             : #include "clearvideodata.h"
      34             : 
      35             : typedef struct LevelCodes {
      36             :     uint16_t    mv_esc;
      37             :     uint16_t    bias_esc;
      38             :     VLC         flags_cb;
      39             :     VLC         mv_cb;
      40             :     VLC         bias_cb;
      41             : } LevelCodes;
      42             : 
      43             : typedef struct MV {
      44             :     int16_t x, y;
      45             : } MV;
      46             : 
      47             : static const MV zero_mv = { 0 };
      48             : 
      49             : typedef struct MVInfo {
      50             :     int mb_w;
      51             :     int mb_h;
      52             :     int mb_size;
      53             :     int mb_stride;
      54             :     int top;
      55             :     MV  *mv;
      56             : } MVInfo;
      57             : 
      58             : typedef struct TileInfo {
      59             :     uint16_t        flags;
      60             :     int16_t         bias;
      61             :     MV              mv;
      62             :     struct TileInfo *child[4];
      63             : } TileInfo;
      64             : 
      65             : typedef struct CLVContext {
      66             :     AVCodecContext *avctx;
      67             :     IDCTDSPContext idsp;
      68             :     AVFrame        *pic;
      69             :     AVFrame        *prev;
      70             :     GetBitContext  gb;
      71             :     int            mb_width, mb_height;
      72             :     int            pmb_width, pmb_height;
      73             :     MVInfo         mvi;
      74             :     int            tile_size;
      75             :     int            tile_shift;
      76             :     VLC            dc_vlc, ac_vlc;
      77             :     LevelCodes     ylev[4], ulev[3], vlev[3];
      78             :     int            luma_dc_quant, chroma_dc_quant, ac_quant;
      79             :     DECLARE_ALIGNED(16, int16_t, block)[64];
      80             :     int            top_dc[3], left_dc[4];
      81             : } CLVContext;
      82             : 
      83           0 : static inline int decode_block(CLVContext *ctx, int16_t *blk, int has_ac,
      84             :                                int ac_quant)
      85             : {
      86           0 :     GetBitContext *gb = &ctx->gb;
      87           0 :     int idx = 1, last = 0, val, skip;
      88             : 
      89           0 :     memset(blk, 0, sizeof(*blk) * 64);
      90           0 :     blk[0] = get_vlc2(gb, ctx->dc_vlc.table, 9, 3);
      91           0 :     if (blk[0] < 0)
      92           0 :         return AVERROR_INVALIDDATA;
      93           0 :     blk[0] -= 63;
      94             : 
      95           0 :     if (!has_ac)
      96           0 :         return 0;
      97             : 
      98           0 :     while (idx < 64 && !last) {
      99           0 :         val = get_vlc2(gb, ctx->ac_vlc.table, 9, 2);
     100           0 :         if (val < 0)
     101           0 :             return AVERROR_INVALIDDATA;
     102           0 :         if (val != 0x1BFF) {
     103           0 :             last =  val >> 12;
     104           0 :             skip = (val >> 4) & 0xFF;
     105           0 :             val &= 0xF;
     106           0 :             if (get_bits1(gb))
     107           0 :                 val = -val;
     108             :         } else {
     109           0 :             last = get_bits1(gb);
     110           0 :             skip = get_bits(gb, 6);
     111           0 :             val  = get_sbits(gb, 8);
     112             :         }
     113           0 :         if (val) {
     114           0 :             int aval = FFABS(val), sign = val < 0;
     115           0 :             val = ac_quant * (2 * aval + 1);
     116           0 :             if (!(ac_quant & 1))
     117           0 :                 val--;
     118           0 :             if (sign)
     119           0 :                 val = -val;
     120             :         }
     121           0 :         idx += skip;
     122           0 :         if (idx >= 64)
     123           0 :             return AVERROR_INVALIDDATA;
     124           0 :         blk[ff_zigzag_direct[idx++]] = val;
     125             :     }
     126             : 
     127           0 :     return (idx <= 64 && last) ? 0 : -1;
     128             : }
     129             : 
     130             : #define DCT_TEMPLATE(blk, step, bias, shift, dshift, OP)                \
     131             :     const int t0 = OP(2841 * blk[1 * step] +  565 * blk[7 * step]);     \
     132             :     const int t1 = OP( 565 * blk[1 * step] - 2841 * blk[7 * step]);     \
     133             :     const int t2 = OP(1609 * blk[5 * step] + 2408 * blk[3 * step]);     \
     134             :     const int t3 = OP(2408 * blk[5 * step] - 1609 * blk[3 * step]);     \
     135             :     const int t4 = OP(1108 * blk[2 * step] - 2676 * blk[6 * step]);     \
     136             :     const int t5 = OP(2676 * blk[2 * step] + 1108 * blk[6 * step]);     \
     137             :     const int t6 = ((blk[0 * step] + blk[4 * step]) * (1 << dshift)) + bias;  \
     138             :     const int t7 = ((blk[0 * step] - blk[4 * step]) * (1 << dshift)) + bias;  \
     139             :     const int t8 = t0 + t2;                                             \
     140             :     const int t9 = t0 - t2;                                             \
     141             :     const int tA = (int)(181U * (t9 + (t1 - t3)) + 0x80) >> 8;          \
     142             :     const int tB = (int)(181U * (t9 - (t1 - t3)) + 0x80) >> 8;          \
     143             :     const int tC = t1 + t3;                                             \
     144             :                                                                         \
     145             :     blk[0 * step] = (t6 + t5 + t8) >> shift;                            \
     146             :     blk[1 * step] = (t7 + t4 + tA) >> shift;                            \
     147             :     blk[2 * step] = (t7 - t4 + tB) >> shift;                            \
     148             :     blk[3 * step] = (t6 - t5 + tC) >> shift;                            \
     149             :     blk[4 * step] = (t6 - t5 - tC) >> shift;                            \
     150             :     blk[5 * step] = (t7 - t4 - tB) >> shift;                            \
     151             :     blk[6 * step] = (t7 + t4 - tA) >> shift;                            \
     152             :     blk[7 * step] = (t6 + t5 - t8) >> shift;                            \
     153             : 
     154             : #define ROP(x) x
     155             : #define COP(x) (((x) + 4) >> 3)
     156             : 
     157           0 : static void clv_dct(int16_t *block)
     158             : {
     159             :     int i;
     160             :     int16_t *ptr;
     161             : 
     162           0 :     ptr = block;
     163           0 :     for (i = 0; i < 8; i++) {
     164           0 :         DCT_TEMPLATE(ptr, 1, 0x80, 8, 11, ROP);
     165           0 :         ptr += 8;
     166             :     }
     167             : 
     168           0 :     ptr = block;
     169           0 :     for (i = 0; i < 8; i++) {
     170           0 :         DCT_TEMPLATE(ptr, 8, 0x2000, 14, 8, COP);
     171           0 :         ptr++;
     172             :     }
     173           0 : }
     174             : 
     175           0 : static int decode_mb(CLVContext *c, int x, int y)
     176             : {
     177             :     int i, has_ac[6], off;
     178             : 
     179           0 :     for (i = 0; i < 6; i++)
     180           0 :         has_ac[i] = get_bits1(&c->gb);
     181             : 
     182           0 :     off = x * 16 + y * 16 * c->pic->linesize[0];
     183           0 :     for (i = 0; i < 4; i++) {
     184           0 :         if (decode_block(c, c->block, has_ac[i], c->ac_quant) < 0)
     185           0 :             return AVERROR_INVALIDDATA;
     186           0 :         if (!x && !(i & 1)) {
     187           0 :             c->block[0] += c->top_dc[0];
     188           0 :             c->top_dc[0] = c->block[0];
     189             :         } else {
     190           0 :             c->block[0] += c->left_dc[(i & 2) >> 1];
     191             :         }
     192           0 :         c->left_dc[(i & 2) >> 1] = c->block[0];
     193           0 :         c->block[0]             *= c->luma_dc_quant;
     194           0 :         clv_dct(c->block);
     195           0 :         if (i == 2)
     196           0 :             off += c->pic->linesize[0] * 8;
     197           0 :         c->idsp.put_pixels_clamped(c->block,
     198           0 :                                    c->pic->data[0] + off + (i & 1) * 8,
     199           0 :                                    c->pic->linesize[0]);
     200             :     }
     201             : 
     202           0 :     off = x * 8 + y * 8 * c->pic->linesize[1];
     203           0 :     for (i = 1; i < 3; i++) {
     204           0 :         if (decode_block(c, c->block, has_ac[i + 3], c->ac_quant) < 0)
     205           0 :             return AVERROR_INVALIDDATA;
     206           0 :         if (!x) {
     207           0 :             c->block[0] += c->top_dc[i];
     208           0 :             c->top_dc[i] = c->block[0];
     209             :         } else {
     210           0 :             c->block[0] += c->left_dc[i + 1];
     211             :         }
     212           0 :         c->left_dc[i + 1] = c->block[0];
     213           0 :         c->block[0]      *= c->chroma_dc_quant;
     214           0 :         clv_dct(c->block);
     215           0 :         c->idsp.put_pixels_clamped(c->block, c->pic->data[i] + off,
     216           0 :                                    c->pic->linesize[i]);
     217             :     }
     218             : 
     219           0 :     return 0;
     220             : }
     221             : 
     222           0 : static int copy_block(AVCodecContext *avctx, AVFrame *dst, AVFrame *src,
     223             :                       int plane, int x, int y, int dx, int dy, int size)
     224             : {
     225           0 :     int shift = plane > 0;
     226           0 :     int sx = x + dx;
     227           0 :     int sy = y + dy;
     228             :     int sstride, dstride, soff, doff;
     229             :     uint8_t *sbuf, *dbuf;
     230             :     int i;
     231             : 
     232           0 :     if (x < 0 || sx < 0 || y < 0 || sy < 0 ||
     233           0 :         x + size > avctx->coded_width >> shift ||
     234           0 :         y + size > avctx->coded_height >> shift ||
     235           0 :         sx + size > avctx->coded_width >> shift ||
     236           0 :         sy + size > avctx->coded_height >> shift)
     237           0 :         return AVERROR_INVALIDDATA;
     238             : 
     239           0 :     sstride = src->linesize[plane];
     240           0 :     dstride = dst->linesize[plane];
     241           0 :     soff    = sx + sy * sstride;
     242           0 :     sbuf    = src->data[plane];
     243           0 :     doff    = x + y * dstride;
     244           0 :     dbuf    = dst->data[plane];
     245             : 
     246           0 :     for (i = 0; i < size; i++) {
     247           0 :         uint8_t *dptr = &dbuf[doff];
     248           0 :         uint8_t *sptr = &sbuf[soff];
     249             : 
     250           0 :         memcpy(dptr, sptr, size);
     251           0 :         doff += dstride;
     252           0 :         soff += sstride;
     253             :     }
     254             : 
     255           0 :     return 0;
     256             : }
     257             : 
     258           0 : static int copyadd_block(AVCodecContext *avctx, AVFrame *dst, AVFrame *src,
     259             :                          int plane, int x, int y, int dx, int dy, int size, int bias)
     260             : {
     261           0 :     int shift = plane > 0;
     262           0 :     int sx = x + dx;
     263           0 :     int sy = y + dy;
     264           0 :     int sstride   = src->linesize[plane];
     265           0 :     int dstride   = dst->linesize[plane];
     266           0 :     int soff      = sx + sy * sstride;
     267           0 :     uint8_t *sbuf = src->data[plane];
     268           0 :     int doff      = x + y * dstride;
     269           0 :     uint8_t *dbuf = dst->data[plane];
     270             :     int i, j;
     271             : 
     272           0 :     if (x < 0 || sx < 0 || y < 0 || sy < 0 ||
     273           0 :         x + size > avctx->coded_width >> shift ||
     274           0 :         y + size > avctx->coded_height >> shift ||
     275           0 :         sx + size > avctx->coded_width >> shift ||
     276           0 :         sy + size > avctx->coded_height >> shift)
     277           0 :         return AVERROR_INVALIDDATA;
     278             : 
     279           0 :     for (j = 0; j < size; j++) {
     280           0 :         uint8_t *dptr = &dbuf[doff];
     281           0 :         uint8_t *sptr = &sbuf[soff];
     282             : 
     283           0 :         for (i = 0; i < size; i++) {
     284           0 :             int val = sptr[i] + bias;
     285             : 
     286           0 :             dptr[i] = av_clip_uint8(val);
     287             :         }
     288             : 
     289           0 :         doff += dstride;
     290           0 :         soff += sstride;
     291             :     }
     292             : 
     293           0 :     return 0;
     294             : }
     295             : 
     296           0 : static MV mvi_predict(MVInfo *mvi, int mb_x, int mb_y, MV diff)
     297             : {
     298             :     MV res, pred_mv;
     299             :     int left_mv, right_mv, top_mv, bot_mv;
     300             : 
     301           0 :     if (mvi->top) {
     302           0 :         if (mb_x > 0) {
     303           0 :             pred_mv = mvi->mv[mvi->mb_stride + mb_x - 1];
     304             :         } else {
     305           0 :             pred_mv = zero_mv;
     306             :         }
     307           0 :     } else if ((mb_x == 0) || (mb_x == mvi->mb_w - 1)) {
     308           0 :         pred_mv = mvi->mv[mb_x];
     309             :     } else {
     310           0 :         MV A = mvi->mv[mvi->mb_stride + mb_x - 1];
     311           0 :         MV B = mvi->mv[                 mb_x    ];
     312           0 :         MV C = mvi->mv[                 mb_x + 1];
     313           0 :         pred_mv.x = mid_pred(A.x, B.x, C.x);
     314           0 :         pred_mv.y = mid_pred(A.y, B.y, C.y);
     315             :     }
     316             : 
     317           0 :     res = pred_mv;
     318             : 
     319           0 :     left_mv = -((mb_x * mvi->mb_size));
     320           0 :     right_mv = ((mvi->mb_w - mb_x - 1) * mvi->mb_size);
     321           0 :     if (res.x < left_mv) {
     322           0 :         res.x = left_mv;
     323             :     }
     324           0 :     if (res.x > right_mv) {
     325           0 :         res.x = right_mv;
     326             :     }
     327           0 :     top_mv = -((mb_y * mvi->mb_size));
     328           0 :     bot_mv = ((mvi->mb_h - mb_y - 1) * mvi->mb_size);
     329           0 :     if (res.y < top_mv) {
     330           0 :         res.y = top_mv;
     331             :     }
     332           0 :     if (res.y > bot_mv) {
     333           0 :         res.y = bot_mv;
     334             :     }
     335             : 
     336           0 :     mvi->mv[mvi->mb_stride + mb_x].x = res.x + diff.x;
     337           0 :     mvi->mv[mvi->mb_stride + mb_x].y = res.y + diff.y;
     338             : 
     339           0 :     return res;
     340             : }
     341             : 
     342           0 : static void mvi_reset(MVInfo *mvi, int mb_w, int mb_h, int mb_size)
     343             : {
     344           0 :     mvi->top       = 1;
     345           0 :     mvi->mb_w      = mb_w;
     346           0 :     mvi->mb_h      = mb_h;
     347           0 :     mvi->mb_size   = mb_size;
     348           0 :     mvi->mb_stride = mb_w;
     349           0 :     memset(mvi->mv, 0, sizeof(MV) * mvi->mb_stride * 2);
     350           0 : }
     351             : 
     352           0 : static void mvi_update_row(MVInfo *mvi)
     353             : {
     354             :     int i;
     355             : 
     356           0 :     mvi->top = 0;
     357           0 :     for (i = 0 ; i < mvi->mb_stride; i++) {
     358           0 :         mvi->mv[i] = mvi->mv[mvi->mb_stride + i];
     359             :     }
     360           0 : }
     361             : 
     362           0 : static TileInfo* decode_tile_info(GetBitContext *gb, LevelCodes *lc, int level)
     363             : {
     364             :     TileInfo *ti;
     365           0 :     int i, flags = 0;
     366           0 :     int16_t bias = 0;
     367           0 :     MV mv = { 0 };
     368             : 
     369           0 :     if (lc[level].flags_cb.table) {
     370           0 :         flags = get_vlc2(gb, lc[level].flags_cb.table, lc[level].flags_cb.bits, 2);
     371             :     }
     372             : 
     373           0 :     if (lc[level].mv_cb.table) {
     374           0 :         uint16_t mv_code = get_vlc2(gb, lc[level].mv_cb.table, lc[level].mv_cb.bits, 3);
     375             : 
     376           0 :         if (mv_code != lc[level].mv_esc) {
     377           0 :             mv.x = (int8_t)(mv_code & 0xff);
     378           0 :             mv.y = (int8_t)(mv_code >> 8);
     379             :         } else {
     380           0 :             mv.x = get_sbits(gb, 8);
     381           0 :             mv.y = get_sbits(gb, 8);
     382             :         }
     383             :     }
     384             : 
     385           0 :     if (lc[level].bias_cb.table) {
     386           0 :         uint16_t bias_val = get_vlc2(gb, lc[level].bias_cb.table, lc[level].bias_cb.bits, 2);
     387             : 
     388           0 :         if (bias_val != lc[level].bias_esc) {
     389           0 :             bias = (int16_t)(bias_val);
     390             :         } else {
     391           0 :             bias = get_sbits(gb, 16);
     392             :         }
     393             :     }
     394             : 
     395           0 :     ti = av_calloc(1, sizeof(*ti));
     396           0 :     if (!ti)
     397           0 :         return NULL;
     398             : 
     399           0 :     ti->flags = flags;
     400           0 :     ti->mv = mv;
     401           0 :     ti->bias = bias;
     402             : 
     403           0 :     if (ti->flags) {
     404           0 :         for (i = 0; i < 4; i++) {
     405           0 :             if (ti->flags & (1 << i)) {
     406           0 :                 TileInfo *subti = decode_tile_info(gb, lc, level + 1);
     407           0 :                 ti->child[i] = subti;
     408             :             }
     409             :         }
     410             :     }
     411             : 
     412           0 :     return ti;
     413             : }
     414             : 
     415           0 : static int tile_do_block(AVCodecContext *avctx, AVFrame *dst, AVFrame *src,
     416             :                          int plane, int x, int y, int dx, int dy, int size, int bias)
     417             : {
     418             :     int ret;
     419             : 
     420           0 :     if (!bias) {
     421           0 :         ret = copy_block(avctx, dst, src, plane, x, y, dx, dy, size);
     422             :     } else {
     423           0 :         ret = copyadd_block(avctx, dst, src, plane, x, y, dx, dy, size, bias);
     424             :     }
     425             : 
     426           0 :     return ret;
     427             : }
     428             : 
     429           0 : static int restore_tree(AVCodecContext *avctx, AVFrame *dst, AVFrame *src,
     430             :                         int plane, int x, int y, int size,
     431             :                         TileInfo *tile, MV root_mv)
     432             : {
     433             :     int ret;
     434             :     MV mv;
     435             : 
     436           0 :     mv.x = root_mv.x + tile->mv.x;
     437           0 :     mv.y = root_mv.y + tile->mv.y;
     438             : 
     439           0 :     if (!tile->flags) {
     440           0 :         ret = tile_do_block(avctx, dst, src, plane, x, y, mv.x, mv.y, size, tile->bias);
     441             :     } else {
     442           0 :         int i, hsize = size >> 1;
     443             : 
     444           0 :         for (i = 0; i < 4; i++) {
     445           0 :             int xoff = (i & 2) == 0 ? 0 : hsize;
     446           0 :             int yoff = (i & 1) == 0 ? 0 : hsize;
     447             : 
     448           0 :             if (tile->child[i]) {
     449           0 :                 ret = restore_tree(avctx, dst, src, plane, x + xoff, y + yoff, hsize, tile->child[i], root_mv);
     450           0 :                 av_freep(&tile->child[i]);
     451             :             } else {
     452           0 :                 ret = tile_do_block(avctx, dst, src, plane, x + xoff, y + yoff, mv.x, mv.y, hsize, tile->bias);
     453             :             }
     454             :         }
     455             :     }
     456             : 
     457           0 :     return ret;
     458             : }
     459             : 
     460           0 : static void extend_edges(AVFrame *buf, int tile_size)
     461             : {
     462             :     int comp, i, j;
     463             : 
     464           0 :     for (comp = 0; comp < 3; comp++) {
     465           0 :         int shift = comp > 0;
     466           0 :         int w = buf->width  >> shift;
     467           0 :         int h = buf->height >> shift;
     468           0 :         int size = comp == 0 ? tile_size : tile_size >> 1;
     469           0 :         int stride = buf->linesize[comp];
     470           0 :         uint8_t *framebuf = buf->data[comp];
     471             : 
     472           0 :         int right  = size - (w & (size - 1));
     473           0 :         int bottom = size - (h & (size - 1));
     474             : 
     475           0 :         if ((right == size) && (bottom == size)) {
     476           0 :             return;
     477             :         }
     478           0 :         if (right != size) {
     479           0 :             int off = w;
     480           0 :             for (j = 0; j < h; j++) {
     481           0 :                 for (i = 0; i < right; i++) {
     482           0 :                     framebuf[off + i] = 0x80;
     483             :                 }
     484           0 :                 off += stride;
     485             :             }
     486             :         }
     487           0 :         if (bottom != size) {
     488           0 :             int off = h * stride;
     489           0 :             for (j = 0; j < bottom; j++) {
     490           0 :                 for (i = 0; i < stride; i++) {
     491           0 :                     framebuf[off + i] = 0x80;
     492             :                 }
     493           0 :                 off += stride;
     494             :             }
     495             :         }
     496             :     }
     497             : }
     498             : 
     499           0 : static int clv_decode_frame(AVCodecContext *avctx, void *data,
     500             :                             int *got_frame, AVPacket *avpkt)
     501             : {
     502           0 :     const uint8_t *buf = avpkt->data;
     503           0 :     int buf_size = avpkt->size;
     504           0 :     CLVContext *c = avctx->priv_data;
     505             :     GetByteContext gb;
     506             :     uint32_t frame_type;
     507             :     int i, j, ret;
     508           0 :     int mb_ret = 0;
     509             : 
     510           0 :     bytestream2_init(&gb, buf, buf_size);
     511           0 :     if (avctx->codec_tag == MKTAG('C', 'L', 'V', '1')) {
     512           0 :         int skip = bytestream2_get_byte(&gb);
     513           0 :         bytestream2_skip(&gb, (skip + 1) * 8);
     514             :     }
     515             : 
     516           0 :     frame_type = bytestream2_get_byte(&gb);
     517             : 
     518           0 :     if ((frame_type & 0x7f) == 0x30) {
     519           0 :         *got_frame = 0;
     520           0 :         return buf_size;
     521           0 :     } else if (frame_type & 0x2) {
     522           0 :         if (buf_size < c->mb_width * c->mb_height) {
     523           0 :             av_log(avctx, AV_LOG_ERROR, "Packet too small\n");
     524           0 :             return AVERROR_INVALIDDATA;
     525             :         }
     526             : 
     527           0 :         if ((ret = ff_reget_buffer(avctx, c->pic)) < 0)
     528           0 :             return ret;
     529             : 
     530           0 :         c->pic->key_frame = 1;
     531           0 :         c->pic->pict_type = AV_PICTURE_TYPE_I;
     532             : 
     533           0 :         bytestream2_get_be32(&gb); // frame size;
     534           0 :         c->ac_quant        = bytestream2_get_byte(&gb);
     535           0 :         c->luma_dc_quant   = 32;
     536           0 :         c->chroma_dc_quant = 32;
     537             : 
     538           0 :         if ((ret = init_get_bits8(&c->gb, buf + bytestream2_tell(&gb),
     539           0 :                                   buf_size - bytestream2_tell(&gb))) < 0)
     540           0 :             return ret;
     541             : 
     542           0 :         for (i = 0; i < 3; i++)
     543           0 :             c->top_dc[i] = 32;
     544           0 :         for (i = 0; i < 4; i++)
     545           0 :             c->left_dc[i] = 32;
     546             : 
     547           0 :         for (j = 0; j < c->mb_height; j++) {
     548           0 :             for (i = 0; i < c->mb_width; i++) {
     549           0 :                 ret = decode_mb(c, i, j);
     550           0 :                 if (ret < 0)
     551           0 :                     mb_ret = ret;
     552             :             }
     553             :         }
     554           0 :         extend_edges(c->pic, c->tile_size);
     555             :     } else {
     556             :         int plane;
     557             : 
     558           0 :         if ((ret = ff_reget_buffer(avctx, c->pic)) < 0)
     559           0 :             return ret;
     560             : 
     561           0 :         ret = av_frame_copy(c->pic, c->prev);
     562           0 :         if (ret < 0)
     563           0 :             return ret;
     564             : 
     565           0 :         if ((ret = init_get_bits8(&c->gb, buf + bytestream2_tell(&gb),
     566           0 :                                   buf_size - bytestream2_tell(&gb))) < 0)
     567           0 :             return ret;
     568             : 
     569           0 :         mvi_reset(&c->mvi, c->pmb_width, c->pmb_height, 1 << c->tile_shift);
     570             : 
     571           0 :         for (j = 0; j < c->pmb_height; j++) {
     572           0 :             for (i = 0; i < c->pmb_width; i++) {
     573           0 :                 if (get_bits1(&c->gb)) {
     574           0 :                     MV mv = mvi_predict(&c->mvi, i, j, zero_mv);
     575             : 
     576           0 :                     for (plane = 0; plane < 3; plane++) {
     577           0 :                         int16_t x = plane == 0 ? i << c->tile_shift : i << (c->tile_shift - 1);
     578           0 :                         int16_t y = plane == 0 ? j << c->tile_shift : j << (c->tile_shift - 1);
     579           0 :                         int16_t size = plane == 0 ? 1 << c->tile_shift : 1 << (c->tile_shift - 1);
     580           0 :                         int16_t mx = plane == 0 ? mv.x : mv.x / 2;
     581           0 :                         int16_t my = plane == 0 ? mv.y : mv.y / 2;
     582             : 
     583           0 :                         ret = copy_block(avctx, c->pic, c->prev, plane, x, y, mx, my, size);
     584           0 :                         if (ret < 0)
     585           0 :                             mb_ret = ret;
     586             :                     }
     587             :                 } else {
     588           0 :                     int x = i << c->tile_shift;
     589           0 :                     int y = j << c->tile_shift;
     590           0 :                     int size = 1 << c->tile_shift;
     591             :                     TileInfo *tile;
     592             :                     MV mv, cmv;
     593             : 
     594           0 :                     tile = decode_tile_info(&c->gb, c->ylev, 0);
     595           0 :                     if (!tile)
     596           0 :                         return AVERROR(ENOMEM);
     597           0 :                     mv = mvi_predict(&c->mvi, i, j, tile->mv);
     598           0 :                     ret = restore_tree(avctx, c->pic, c->prev, 0, x, y, size, tile, mv);
     599           0 :                     if (ret < 0)
     600           0 :                         mb_ret = ret;
     601           0 :                     x = i << (c->tile_shift - 1);
     602           0 :                     y = j << (c->tile_shift - 1);
     603           0 :                     size = 1 << (c->tile_shift - 1);
     604           0 :                     cmv.x = mv.x + tile->mv.x;
     605           0 :                     cmv.y = mv.y + tile->mv.y;
     606           0 :                     cmv.x /= 2;
     607           0 :                     cmv.y /= 2;
     608           0 :                     av_freep(&tile);
     609           0 :                     tile = decode_tile_info(&c->gb, c->ulev, 0);
     610           0 :                     if (!tile)
     611           0 :                         return AVERROR(ENOMEM);
     612           0 :                     ret = restore_tree(avctx, c->pic, c->prev, 1, x, y, size, tile, cmv);
     613           0 :                     if (ret < 0)
     614           0 :                         mb_ret = ret;
     615           0 :                     av_freep(&tile);
     616           0 :                     tile = decode_tile_info(&c->gb, c->vlev, 0);
     617           0 :                     if (!tile)
     618           0 :                         return AVERROR(ENOMEM);
     619           0 :                     ret = restore_tree(avctx, c->pic, c->prev, 2, x, y, size, tile, cmv);
     620           0 :                     if (ret < 0)
     621           0 :                         mb_ret = ret;
     622           0 :                     av_freep(&tile);
     623             :                 }
     624             :             }
     625           0 :             mvi_update_row(&c->mvi);
     626             :         }
     627           0 :         extend_edges(c->pic, c->tile_size);
     628             : 
     629           0 :         c->pic->key_frame = 0;
     630           0 :         c->pic->pict_type = AV_PICTURE_TYPE_P;
     631             :     }
     632             : 
     633           0 :     if ((ret = av_frame_ref(data, c->pic)) < 0)
     634           0 :         return ret;
     635             : 
     636           0 :     FFSWAP(AVFrame *, c->pic, c->prev);
     637             : 
     638           0 :     *got_frame = 1;
     639             : 
     640           0 :     if (get_bits_left(&c->gb) < 0)
     641           0 :         av_log(c->avctx, AV_LOG_WARNING, "overread %d\n", -get_bits_left(&c->gb));
     642             : 
     643           0 :     return mb_ret < 0 ? mb_ret : buf_size;
     644             : }
     645             : 
     646           0 : static av_cold int clv_decode_init(AVCodecContext *avctx)
     647             : {
     648           0 :     CLVContext *const c = avctx->priv_data;
     649             :     int ret, w, h;
     650             : 
     651           0 :     if (avctx->extradata_size == 110) {
     652           0 :         c->tile_size = AV_RL32(&avctx->extradata[94]);
     653           0 :     } else if (avctx->extradata_size == 150) {
     654           0 :         c->tile_size = AV_RB32(&avctx->extradata[134]);
     655           0 :     } else if (!avctx->extradata_size) {
     656           0 :         c->tile_size = 16;
     657             :     } else {
     658           0 :         av_log(avctx, AV_LOG_ERROR, "Unsupported extradata size: %d\n", avctx->extradata_size);
     659           0 :         return AVERROR_INVALIDDATA;
     660             :     }
     661             : 
     662           0 :     c->tile_shift = av_log2(c->tile_size);
     663           0 :     if (1 << c->tile_shift != c->tile_size) {
     664           0 :         av_log(avctx, AV_LOG_ERROR, "Tile size: %d, is not power of 2.\n", c->tile_size);
     665           0 :         return AVERROR_INVALIDDATA;
     666             :     }
     667             : 
     668           0 :     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
     669           0 :     w = avctx->width;
     670           0 :     h = avctx->height;
     671           0 :     ret = ff_set_dimensions(avctx, FFALIGN(w, 1 << c->tile_shift), FFALIGN(h, 1 << c->tile_shift));
     672           0 :     if (ret < 0)
     673           0 :         return ret;
     674           0 :     avctx->width  = w;
     675           0 :     avctx->height = h;
     676             : 
     677           0 :     c->avctx           = avctx;
     678           0 :     c->mb_width        = FFALIGN(avctx->width,  16) >> 4;
     679           0 :     c->mb_height       = FFALIGN(avctx->height, 16) >> 4;
     680           0 :     c->pmb_width       = (w + c->tile_size - 1) >> c->tile_shift;
     681           0 :     c->pmb_height      = (h + c->tile_size - 1) >> c->tile_shift;
     682           0 :     c->pic             = av_frame_alloc();
     683           0 :     c->prev            = av_frame_alloc();
     684           0 :     c->mvi.mv          = av_calloc(c->pmb_width * 2, sizeof(*c->mvi.mv));
     685           0 :     if (!c->pic || !c->prev || !c->mvi.mv)
     686           0 :         return AVERROR(ENOMEM);
     687             : 
     688           0 :     ff_idctdsp_init(&c->idsp, avctx);
     689           0 :     ret = init_vlc(&c->dc_vlc, 9, NUM_DC_CODES,
     690             :                    clv_dc_bits,  1, 1,
     691             :                    clv_dc_codes, 1, 1, 0);
     692           0 :     if (ret) {
     693           0 :         av_log(avctx, AV_LOG_ERROR, "Error initialising DC VLC\n");
     694           0 :         return ret;
     695             :     }
     696           0 :     ret = ff_init_vlc_sparse(&c->ac_vlc, 9, NUM_AC_CODES,
     697             :                              clv_ac_bits,  1, 1,
     698             :                              clv_ac_codes, 1, 1,
     699             :                              clv_ac_syms,  2, 2, 0);
     700           0 :     if (ret) {
     701           0 :         av_log(avctx, AV_LOG_ERROR, "Error initialising AC VLC\n");
     702           0 :         return ret;
     703             :     }
     704             : 
     705           0 :     ret = init_vlc(&c->ylev[0].flags_cb, 9, FF_ARRAY_ELEMS(clv_flagsy_0_bits),
     706             :                    clv_flagsy_0_bits,  1, 1,
     707             :                    clv_flagsy_0_codes, 2, 2, 0);
     708           0 :     if (ret)
     709           0 :         return ret;
     710             : 
     711           0 :     ret = init_vlc(&c->ylev[1].flags_cb, 9, FF_ARRAY_ELEMS(clv_flagsy_1_bits),
     712             :                    clv_flagsy_1_bits,  1, 1,
     713             :                    clv_flagsy_1_codes, 2, 2, 0);
     714           0 :     if (ret)
     715           0 :         return ret;
     716             : 
     717           0 :     ret = init_vlc(&c->ylev[2].flags_cb, 9, FF_ARRAY_ELEMS(clv_flagsy_2_bits),
     718             :                    clv_flagsy_2_bits,  1, 1,
     719             :                    clv_flagsy_2_codes, 2, 2, 0);
     720           0 :     if (ret)
     721           0 :         return ret;
     722             : 
     723           0 :     ret = init_vlc(&c->ulev[0].flags_cb, 9, FF_ARRAY_ELEMS(clv_flagsu_0_bits),
     724             :                    clv_flagsu_0_bits,  1, 1,
     725             :                    clv_flagsu_0_codes, 2, 2, 0);
     726           0 :     if (ret)
     727           0 :         return ret;
     728             : 
     729           0 :     ret = init_vlc(&c->ulev[1].flags_cb, 9, FF_ARRAY_ELEMS(clv_flagsu_1_bits),
     730             :                    clv_flagsu_1_bits,  1, 1,
     731             :                    clv_flagsu_1_codes, 2, 2, 0);
     732           0 :     if (ret)
     733           0 :         return ret;
     734             : 
     735           0 :     ret = init_vlc(&c->vlev[0].flags_cb, 9, FF_ARRAY_ELEMS(clv_flagsv_0_bits),
     736             :                    clv_flagsv_0_bits,  1, 1,
     737             :                    clv_flagsv_0_codes, 2, 2, 0);
     738           0 :     if (ret)
     739           0 :         return ret;
     740             : 
     741           0 :     ret = init_vlc(&c->vlev[1].flags_cb, 9, FF_ARRAY_ELEMS(clv_flagsv_1_bits),
     742             :                    clv_flagsv_1_bits,  1, 1,
     743             :                    clv_flagsv_1_codes, 2, 2, 0);
     744           0 :     if (ret)
     745           0 :         return ret;
     746             : 
     747           0 :     ret = ff_init_vlc_sparse(&c->ylev[0].mv_cb, 9, FF_ARRAY_ELEMS(clv_mvy_0_bits),
     748             :                              clv_mvy_0_bits,  1, 1,
     749             :                              clv_mvy_0_codes, 2, 2,
     750             :                              clv_mvy_0_syms,  2, 2, 0);
     751           0 :     if (ret)
     752           0 :         return ret;
     753             : 
     754           0 :     ret = ff_init_vlc_sparse(&c->ylev[1].mv_cb, 9, FF_ARRAY_ELEMS(clv_mvy_1_bits),
     755             :                              clv_mvy_1_bits,  1, 1,
     756             :                              clv_mvy_1_codes, 2, 2,
     757             :                              clv_mvy_1_syms,  2, 2, 0);
     758           0 :     if (ret)
     759           0 :         return ret;
     760             : 
     761           0 :     ret = ff_init_vlc_sparse(&c->ylev[2].mv_cb, 9, FF_ARRAY_ELEMS(clv_mvy_2_bits),
     762             :                              clv_mvy_2_bits,  1, 1,
     763             :                              clv_mvy_2_codes, 2, 2,
     764             :                              clv_mvy_2_syms,  2, 2, 0);
     765           0 :     if (ret)
     766           0 :         return ret;
     767             : 
     768           0 :     ret = ff_init_vlc_sparse(&c->ylev[3].mv_cb, 9, FF_ARRAY_ELEMS(clv_mvy_3_bits),
     769             :                              clv_mvy_3_bits,  1, 1,
     770             :                              clv_mvy_3_codes, 2, 2,
     771             :                              clv_mvy_3_syms,  2, 2, 0);
     772           0 :     if (ret)
     773           0 :         return ret;
     774             : 
     775           0 :     ret = ff_init_vlc_sparse(&c->ulev[1].mv_cb, 9, FF_ARRAY_ELEMS(clv_mvu_1_bits),
     776             :                              clv_mvu_1_bits,  1, 1,
     777             :                              clv_mvu_1_codes, 2, 2,
     778             :                              clv_mvu_1_syms,  2, 2, 0);
     779           0 :     if (ret)
     780           0 :         return ret;
     781             : 
     782           0 :     ret = ff_init_vlc_sparse(&c->ulev[2].mv_cb, 9, FF_ARRAY_ELEMS(clv_mvu_2_bits),
     783             :                              clv_mvu_2_bits,  1, 1,
     784             :                              clv_mvu_2_codes, 2, 2,
     785             :                              clv_mvu_2_syms,  2, 2, 0);
     786           0 :     if (ret)
     787           0 :         return ret;
     788             : 
     789           0 :     ret = ff_init_vlc_sparse(&c->vlev[1].mv_cb, 9, FF_ARRAY_ELEMS(clv_mvv_1_bits),
     790             :                              clv_mvv_1_bits,  1, 1,
     791             :                              clv_mvv_1_codes, 2, 2,
     792             :                              clv_mvv_1_syms,  2, 2, 0);
     793           0 :     if (ret)
     794           0 :         return ret;
     795             : 
     796           0 :     ret = ff_init_vlc_sparse(&c->vlev[2].mv_cb, 9, FF_ARRAY_ELEMS(clv_mvv_2_bits),
     797             :                              clv_mvv_2_bits,  1, 1,
     798             :                              clv_mvv_2_codes, 2, 2,
     799             :                              clv_mvv_2_syms,  2, 2, 0);
     800           0 :     if (ret)
     801           0 :         return ret;
     802             : 
     803           0 :     ret = ff_init_vlc_sparse(&c->ylev[1].bias_cb, 9, FF_ARRAY_ELEMS(clv_biasy_1_bits),
     804             :                              clv_biasy_1_bits,  1, 1,
     805             :                              clv_biasy_1_codes, 2, 2,
     806             :                              clv_biasy_1_syms,  2, 2, 0);
     807           0 :     if (ret)
     808           0 :         return ret;
     809             : 
     810           0 :     ret = ff_init_vlc_sparse(&c->ylev[2].bias_cb, 9, FF_ARRAY_ELEMS(clv_biasy_2_bits),
     811             :                              clv_biasy_2_bits,  1, 1,
     812             :                              clv_biasy_2_codes, 2, 2,
     813             :                              clv_biasy_2_syms,  2, 2, 0);
     814           0 :     if (ret)
     815           0 :         return ret;
     816             : 
     817           0 :     ret = ff_init_vlc_sparse(&c->ylev[3].bias_cb, 9, FF_ARRAY_ELEMS(clv_biasy_3_bits),
     818             :                              clv_biasy_3_bits,  1, 1,
     819             :                              clv_biasy_3_codes, 2, 2,
     820             :                              clv_biasy_3_syms,  2, 2, 0);
     821           0 :     if (ret)
     822           0 :         return ret;
     823             : 
     824           0 :     ret = ff_init_vlc_sparse(&c->ulev[1].bias_cb, 9, FF_ARRAY_ELEMS(clv_biasu_1_bits),
     825             :                              clv_biasu_1_bits,  1, 1,
     826             :                              clv_biasu_1_codes, 2, 2,
     827             :                              clv_biasu_1_syms,  2, 2, 0);
     828           0 :     if (ret)
     829           0 :         return ret;
     830             : 
     831           0 :     ret = ff_init_vlc_sparse(&c->ulev[2].bias_cb, 9, FF_ARRAY_ELEMS(clv_biasu_2_bits),
     832             :                              clv_biasu_2_bits,  1, 1,
     833             :                              clv_biasu_2_codes, 2, 2,
     834             :                              clv_biasu_2_syms,  2, 2, 0);
     835           0 :     if (ret)
     836           0 :         return ret;
     837             : 
     838           0 :     ret = ff_init_vlc_sparse(&c->vlev[1].bias_cb, 9, FF_ARRAY_ELEMS(clv_biasv_1_bits),
     839             :                              clv_biasv_1_bits,  1, 1,
     840             :                              clv_biasv_1_codes, 2, 2,
     841             :                              clv_biasv_1_syms,  2, 2, 0);
     842           0 :     if (ret)
     843           0 :         return ret;
     844             : 
     845           0 :     ret = ff_init_vlc_sparse(&c->vlev[2].bias_cb, 9, FF_ARRAY_ELEMS(clv_biasv_2_bits),
     846             :                              clv_biasv_2_bits,  1, 1,
     847             :                              clv_biasv_2_codes, 2, 2,
     848             :                              clv_biasv_2_syms,  2, 2, 0);
     849           0 :     if (ret)
     850           0 :         return ret;
     851             : 
     852           0 :     c->ylev[0].mv_esc = 0x0909;
     853           0 :     c->ylev[1].mv_esc = 0x0A0A;
     854           0 :     c->ylev[2].mv_esc = 0x1010;
     855           0 :     c->ylev[3].mv_esc = 0x1313;
     856           0 :     c->ulev[1].mv_esc = 0x0808;
     857           0 :     c->ulev[2].mv_esc = 0x0B0B;
     858           0 :     c->vlev[1].mv_esc = 0x0808;
     859           0 :     c->vlev[2].mv_esc = 0x0B0B;
     860             : 
     861           0 :     c->ylev[1].bias_esc = 0x100;
     862           0 :     c->ylev[2].bias_esc = 0x100;
     863           0 :     c->ylev[3].bias_esc = 0x100;
     864           0 :     c->ulev[1].bias_esc = 0x100;
     865           0 :     c->ulev[2].bias_esc = 0x100;
     866           0 :     c->vlev[1].bias_esc = 0x100;
     867           0 :     c->vlev[2].bias_esc = 0x100;
     868             : 
     869           0 :     return 0;
     870             : }
     871             : 
     872           0 : static av_cold int clv_decode_end(AVCodecContext *avctx)
     873             : {
     874           0 :     CLVContext *const c = avctx->priv_data;
     875             :     int i;
     876             : 
     877           0 :     av_frame_free(&c->prev);
     878           0 :     av_frame_free(&c->pic);
     879             : 
     880           0 :     av_freep(&c->mvi.mv);
     881             : 
     882           0 :     ff_free_vlc(&c->dc_vlc);
     883           0 :     ff_free_vlc(&c->ac_vlc);
     884           0 :     for (i = 0; i < 4; i++) {
     885           0 :         ff_free_vlc(&c->ylev[i].mv_cb);
     886           0 :         ff_free_vlc(&c->ylev[i].flags_cb);
     887           0 :         ff_free_vlc(&c->ylev[i].bias_cb);
     888             :     }
     889           0 :     for (i = 0; i < 3; i++) {
     890           0 :         ff_free_vlc(&c->ulev[i].mv_cb);
     891           0 :         ff_free_vlc(&c->ulev[i].flags_cb);
     892           0 :         ff_free_vlc(&c->ulev[i].bias_cb);
     893           0 :         ff_free_vlc(&c->vlev[i].mv_cb);
     894           0 :         ff_free_vlc(&c->vlev[i].flags_cb);
     895           0 :         ff_free_vlc(&c->vlev[i].bias_cb);
     896             :     }
     897             : 
     898           0 :     return 0;
     899             : }
     900             : 
     901             : AVCodec ff_clearvideo_decoder = {
     902             :     .name           = "clearvideo",
     903             :     .long_name      = NULL_IF_CONFIG_SMALL("Iterated Systems ClearVideo"),
     904             :     .type           = AVMEDIA_TYPE_VIDEO,
     905             :     .id             = AV_CODEC_ID_CLEARVIDEO,
     906             :     .priv_data_size = sizeof(CLVContext),
     907             :     .init           = clv_decode_init,
     908             :     .close          = clv_decode_end,
     909             :     .decode         = clv_decode_frame,
     910             :     .capabilities   = AV_CODEC_CAP_DR1,
     911             :     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
     912             : };

Generated by: LCOV version 1.13