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