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