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