git.sesse.net Git - ffmpeg/blob - libavcodec/clearvideo.c

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