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
decode_block(CLVContext * ctx,int16_t * blk,int has_ac,int ac_quant)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
clv_dct(int16_t * block)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
decode_mb(CLVContext * c,int x,int y)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
copy_block(AVCodecContext * avctx,AVFrame * dst,AVFrame * src,int plane,int x,int y,int dx,int dy,int size)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
copyadd_block(AVCodecContext * avctx,AVFrame * dst,AVFrame * src,int plane,int x,int y,int dx,int dy,int size,int bias)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
mvi_predict(MVInfo * mvi,int mb_x,int mb_y,MV diff)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
mvi_reset(MVInfo * mvi,int mb_w,int mb_h,int mb_size)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
mvi_update_row(MVInfo * mvi)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
decode_tile_info(GetBitContext * gb,LevelCodes * lc,int level)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
tile_do_block(AVCodecContext * avctx,AVFrame * dst,AVFrame * src,int plane,int x,int y,int dx,int dy,int size,int bias)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
restore_tree(AVCodecContext * avctx,AVFrame * dst,AVFrame * src,int plane,int x,int y,int size,TileInfo * tile,MV root_mv)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
extend_edges(AVFrame * buf,int tile_size)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
clv_decode_frame(AVCodecContext * avctx,void * data,int * got_frame,AVPacket * avpkt)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)) < 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 (c->pmb_width * c->pmb_height > 8LL*(buf_size - bytestream2_tell(&gb)))
559 return AVERROR_INVALIDDATA;
560
561 if ((ret = ff_reget_buffer(avctx, c->pic, 0)) < 0)
562 return ret;
563
564 ret = av_frame_copy(c->pic, c->prev);
565 if (ret < 0)
566 return ret;
567
568 if ((ret = init_get_bits8(&c->gb, buf + bytestream2_tell(&gb),
569 buf_size - bytestream2_tell(&gb))) < 0)
570 return ret;
571
572 mvi_reset(&c->mvi, c->pmb_width, c->pmb_height, 1 << c->tile_shift);
573
574 for (j = 0; j < c->pmb_height; j++) {
575 for (i = 0; i < c->pmb_width; i++) {
576 if (get_bits_left(&c->gb) <= 0)
577 return AVERROR_INVALIDDATA;
578 if (get_bits1(&c->gb)) {
579 MV mv = mvi_predict(&c->mvi, i, j, zero_mv);
580
581 for (plane = 0; plane < 3; plane++) {
582 int16_t x = plane == 0 ? i << c->tile_shift : i << (c->tile_shift - 1);
583 int16_t y = plane == 0 ? j << c->tile_shift : j << (c->tile_shift - 1);
584 int16_t size = plane == 0 ? 1 << c->tile_shift : 1 << (c->tile_shift - 1);
585 int16_t mx = plane == 0 ? mv.x : mv.x / 2;
586 int16_t my = plane == 0 ? mv.y : mv.y / 2;
587
588 ret = copy_block(avctx, c->pic, c->prev, plane, x, y, mx, my, size);
589 if (ret < 0)
590 mb_ret = ret;
591 }
592 } else {
593 int x = i << c->tile_shift;
594 int y = j << c->tile_shift;
595 int size = 1 << c->tile_shift;
596 TileInfo *tile;
597 MV mv, cmv;
598
599 tile = decode_tile_info(&c->gb, c->ylev, 0);
600 if (!tile)
601 return AVERROR(ENOMEM);
602 mv = mvi_predict(&c->mvi, i, j, tile->mv);
603 ret = restore_tree(avctx, c->pic, c->prev, 0, x, y, size, tile, mv);
604 if (ret < 0)
605 mb_ret = ret;
606 x = i << (c->tile_shift - 1);
607 y = j << (c->tile_shift - 1);
608 size = 1 << (c->tile_shift - 1);
609 cmv.x = mv.x + tile->mv.x;
610 cmv.y = mv.y + tile->mv.y;
611 cmv.x /= 2;
612 cmv.y /= 2;
613 av_freep(&tile);
614 tile = decode_tile_info(&c->gb, c->ulev, 0);
615 if (!tile)
616 return AVERROR(ENOMEM);
617 ret = restore_tree(avctx, c->pic, c->prev, 1, x, y, size, tile, cmv);
618 if (ret < 0)
619 mb_ret = ret;
620 av_freep(&tile);
621 tile = decode_tile_info(&c->gb, c->vlev, 0);
622 if (!tile)
623 return AVERROR(ENOMEM);
624 ret = restore_tree(avctx, c->pic, c->prev, 2, x, y, size, tile, cmv);
625 if (ret < 0)
626 mb_ret = ret;
627 av_freep(&tile);
628 }
629 }
630 mvi_update_row(&c->mvi);
631 }
632 extend_edges(c->pic, c->tile_size);
633
634 c->pic->key_frame = 0;
635 c->pic->pict_type = AV_PICTURE_TYPE_P;
636 }
637
638 if ((ret = av_frame_ref(data, c->pic)) < 0)
639 return ret;
640
641 FFSWAP(AVFrame *, c->pic, c->prev);
642
643 *got_frame = 1;
644
645 if (get_bits_left(&c->gb) < 0)
646 av_log(c->avctx, AV_LOG_WARNING, "overread %d\n", -get_bits_left(&c->gb));
647
648 return mb_ret < 0 ? mb_ret : buf_size;
649 }
650
clv_decode_init(AVCodecContext * avctx)651 static av_cold int clv_decode_init(AVCodecContext *avctx)
652 {
653 CLVContext *const c = avctx->priv_data;
654 int ret, w, h;
655
656 if (avctx->extradata_size == 110) {
657 c->tile_size = AV_RL32(&avctx->extradata[94]);
658 } else if (avctx->extradata_size == 150) {
659 c->tile_size = AV_RB32(&avctx->extradata[134]);
660 } else if (!avctx->extradata_size) {
661 c->tile_size = 16;
662 } else {
663 av_log(avctx, AV_LOG_ERROR, "Unsupported extradata size: %d\n", avctx->extradata_size);
664 return AVERROR_INVALIDDATA;
665 }
666
667 c->tile_shift = av_log2(c->tile_size);
668 if (1U << c->tile_shift != c->tile_size) {
669 av_log(avctx, AV_LOG_ERROR, "Tile size: %d, is not power of 2.\n", c->tile_size);
670 return AVERROR_INVALIDDATA;
671 }
672
673 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
674 w = avctx->width;
675 h = avctx->height;
676 ret = ff_set_dimensions(avctx, FFALIGN(w, 1 << c->tile_shift), FFALIGN(h, 1 << c->tile_shift));
677 if (ret < 0)
678 return ret;
679 avctx->width = w;
680 avctx->height = h;
681
682 c->avctx = avctx;
683 c->mb_width = FFALIGN(avctx->width, 16) >> 4;
684 c->mb_height = FFALIGN(avctx->height, 16) >> 4;
685 c->pmb_width = (w + c->tile_size - 1) >> c->tile_shift;
686 c->pmb_height = (h + c->tile_size - 1) >> c->tile_shift;
687 c->pic = av_frame_alloc();
688 c->prev = av_frame_alloc();
689 c->mvi.mv = av_calloc(c->pmb_width * 2, sizeof(*c->mvi.mv));
690 if (!c->pic || !c->prev || !c->mvi.mv)
691 return AVERROR(ENOMEM);
692
693 ff_idctdsp_init(&c->idsp, avctx);
694 ret = init_vlc(&c->dc_vlc, 9, NUM_DC_CODES,
695 clv_dc_bits, 1, 1,
696 clv_dc_codes, 1, 1, 0);
697 if (ret) {
698 av_log(avctx, AV_LOG_ERROR, "Error initialising DC VLC\n");
699 return ret;
700 }
701 ret = ff_init_vlc_sparse(&c->ac_vlc, 9, NUM_AC_CODES,
702 clv_ac_bits, 1, 1,
703 clv_ac_codes, 1, 1,
704 clv_ac_syms, 2, 2, 0);
705 if (ret) {
706 av_log(avctx, AV_LOG_ERROR, "Error initialising AC VLC\n");
707 return ret;
708 }
709
710 ret = init_vlc(&c->ylev[0].flags_cb, 9, FF_ARRAY_ELEMS(clv_flagsy_0_bits),
711 clv_flagsy_0_bits, 1, 1,
712 clv_flagsy_0_codes, 2, 2, 0);
713 if (ret)
714 return ret;
715
716 ret = init_vlc(&c->ylev[1].flags_cb, 9, FF_ARRAY_ELEMS(clv_flagsy_1_bits),
717 clv_flagsy_1_bits, 1, 1,
718 clv_flagsy_1_codes, 2, 2, 0);
719 if (ret)
720 return ret;
721
722 ret = init_vlc(&c->ylev[2].flags_cb, 9, FF_ARRAY_ELEMS(clv_flagsy_2_bits),
723 clv_flagsy_2_bits, 1, 1,
724 clv_flagsy_2_codes, 2, 2, 0);
725 if (ret)
726 return ret;
727
728 ret = init_vlc(&c->ulev[0].flags_cb, 9, FF_ARRAY_ELEMS(clv_flagsu_0_bits),
729 clv_flagsu_0_bits, 1, 1,
730 clv_flagsu_0_codes, 2, 2, 0);
731 if (ret)
732 return ret;
733
734 ret = init_vlc(&c->ulev[1].flags_cb, 9, FF_ARRAY_ELEMS(clv_flagsu_1_bits),
735 clv_flagsu_1_bits, 1, 1,
736 clv_flagsu_1_codes, 2, 2, 0);
737 if (ret)
738 return ret;
739
740 ret = init_vlc(&c->vlev[0].flags_cb, 9, FF_ARRAY_ELEMS(clv_flagsv_0_bits),
741 clv_flagsv_0_bits, 1, 1,
742 clv_flagsv_0_codes, 2, 2, 0);
743 if (ret)
744 return ret;
745
746 ret = init_vlc(&c->vlev[1].flags_cb, 9, FF_ARRAY_ELEMS(clv_flagsv_1_bits),
747 clv_flagsv_1_bits, 1, 1,
748 clv_flagsv_1_codes, 2, 2, 0);
749 if (ret)
750 return ret;
751
752 ret = ff_init_vlc_sparse(&c->ylev[0].mv_cb, 9, FF_ARRAY_ELEMS(clv_mvy_0_bits),
753 clv_mvy_0_bits, 1, 1,
754 clv_mvy_0_codes, 2, 2,
755 clv_mvy_0_syms, 2, 2, 0);
756 if (ret)
757 return ret;
758
759 ret = ff_init_vlc_sparse(&c->ylev[1].mv_cb, 9, FF_ARRAY_ELEMS(clv_mvy_1_bits),
760 clv_mvy_1_bits, 1, 1,
761 clv_mvy_1_codes, 2, 2,
762 clv_mvy_1_syms, 2, 2, 0);
763 if (ret)
764 return ret;
765
766 ret = ff_init_vlc_sparse(&c->ylev[2].mv_cb, 9, FF_ARRAY_ELEMS(clv_mvy_2_bits),
767 clv_mvy_2_bits, 1, 1,
768 clv_mvy_2_codes, 2, 2,
769 clv_mvy_2_syms, 2, 2, 0);
770 if (ret)
771 return ret;
772
773 ret = ff_init_vlc_sparse(&c->ylev[3].mv_cb, 9, FF_ARRAY_ELEMS(clv_mvy_3_bits),
774 clv_mvy_3_bits, 1, 1,
775 clv_mvy_3_codes, 2, 2,
776 clv_mvy_3_syms, 2, 2, 0);
777 if (ret)
778 return ret;
779
780 ret = ff_init_vlc_sparse(&c->ulev[1].mv_cb, 9, FF_ARRAY_ELEMS(clv_mvu_1_bits),
781 clv_mvu_1_bits, 1, 1,
782 clv_mvu_1_codes, 2, 2,
783 clv_mvu_1_syms, 2, 2, 0);
784 if (ret)
785 return ret;
786
787 ret = ff_init_vlc_sparse(&c->ulev[2].mv_cb, 9, FF_ARRAY_ELEMS(clv_mvu_2_bits),
788 clv_mvu_2_bits, 1, 1,
789 clv_mvu_2_codes, 2, 2,
790 clv_mvu_2_syms, 2, 2, 0);
791 if (ret)
792 return ret;
793
794 ret = ff_init_vlc_sparse(&c->vlev[1].mv_cb, 9, FF_ARRAY_ELEMS(clv_mvv_1_bits),
795 clv_mvv_1_bits, 1, 1,
796 clv_mvv_1_codes, 2, 2,
797 clv_mvv_1_syms, 2, 2, 0);
798 if (ret)
799 return ret;
800
801 ret = ff_init_vlc_sparse(&c->vlev[2].mv_cb, 9, FF_ARRAY_ELEMS(clv_mvv_2_bits),
802 clv_mvv_2_bits, 1, 1,
803 clv_mvv_2_codes, 2, 2,
804 clv_mvv_2_syms, 2, 2, 0);
805 if (ret)
806 return ret;
807
808 ret = ff_init_vlc_sparse(&c->ylev[1].bias_cb, 9, FF_ARRAY_ELEMS(clv_biasy_1_bits),
809 clv_biasy_1_bits, 1, 1,
810 clv_biasy_1_codes, 2, 2,
811 clv_biasy_1_syms, 2, 2, 0);
812 if (ret)
813 return ret;
814
815 ret = ff_init_vlc_sparse(&c->ylev[2].bias_cb, 9, FF_ARRAY_ELEMS(clv_biasy_2_bits),
816 clv_biasy_2_bits, 1, 1,
817 clv_biasy_2_codes, 2, 2,
818 clv_biasy_2_syms, 2, 2, 0);
819 if (ret)
820 return ret;
821
822 ret = ff_init_vlc_sparse(&c->ylev[3].bias_cb, 9, FF_ARRAY_ELEMS(clv_biasy_3_bits),
823 clv_biasy_3_bits, 1, 1,
824 clv_biasy_3_codes, 2, 2,
825 clv_biasy_3_syms, 2, 2, 0);
826 if (ret)
827 return ret;
828
829 ret = ff_init_vlc_sparse(&c->ulev[1].bias_cb, 9, FF_ARRAY_ELEMS(clv_biasu_1_bits),
830 clv_biasu_1_bits, 1, 1,
831 clv_biasu_1_codes, 2, 2,
832 clv_biasu_1_syms, 2, 2, 0);
833 if (ret)
834 return ret;
835
836 ret = ff_init_vlc_sparse(&c->ulev[2].bias_cb, 9, FF_ARRAY_ELEMS(clv_biasu_2_bits),
837 clv_biasu_2_bits, 1, 1,
838 clv_biasu_2_codes, 2, 2,
839 clv_biasu_2_syms, 2, 2, 0);
840 if (ret)
841 return ret;
842
843 ret = ff_init_vlc_sparse(&c->vlev[1].bias_cb, 9, FF_ARRAY_ELEMS(clv_biasv_1_bits),
844 clv_biasv_1_bits, 1, 1,
845 clv_biasv_1_codes, 2, 2,
846 clv_biasv_1_syms, 2, 2, 0);
847 if (ret)
848 return ret;
849
850 ret = ff_init_vlc_sparse(&c->vlev[2].bias_cb, 9, FF_ARRAY_ELEMS(clv_biasv_2_bits),
851 clv_biasv_2_bits, 1, 1,
852 clv_biasv_2_codes, 2, 2,
853 clv_biasv_2_syms, 2, 2, 0);
854 if (ret)
855 return ret;
856
857 c->ylev[0].mv_esc = 0x0909;
858 c->ylev[1].mv_esc = 0x0A0A;
859 c->ylev[2].mv_esc = 0x1010;
860 c->ylev[3].mv_esc = 0x1313;
861 c->ulev[1].mv_esc = 0x0808;
862 c->ulev[2].mv_esc = 0x0B0B;
863 c->vlev[1].mv_esc = 0x0808;
864 c->vlev[2].mv_esc = 0x0B0B;
865
866 c->ylev[1].bias_esc = 0x100;
867 c->ylev[2].bias_esc = 0x100;
868 c->ylev[3].bias_esc = 0x100;
869 c->ulev[1].bias_esc = 0x100;
870 c->ulev[2].bias_esc = 0x100;
871 c->vlev[1].bias_esc = 0x100;
872 c->vlev[2].bias_esc = 0x100;
873
874 return 0;
875 }
876
clv_decode_end(AVCodecContext * avctx)877 static av_cold int clv_decode_end(AVCodecContext *avctx)
878 {
879 CLVContext *const c = avctx->priv_data;
880 int i;
881
882 av_frame_free(&c->prev);
883 av_frame_free(&c->pic);
884
885 av_freep(&c->mvi.mv);
886
887 ff_free_vlc(&c->dc_vlc);
888 ff_free_vlc(&c->ac_vlc);
889 for (i = 0; i < 4; i++) {
890 ff_free_vlc(&c->ylev[i].mv_cb);
891 ff_free_vlc(&c->ylev[i].flags_cb);
892 ff_free_vlc(&c->ylev[i].bias_cb);
893 }
894 for (i = 0; i < 3; i++) {
895 ff_free_vlc(&c->ulev[i].mv_cb);
896 ff_free_vlc(&c->ulev[i].flags_cb);
897 ff_free_vlc(&c->ulev[i].bias_cb);
898 ff_free_vlc(&c->vlev[i].mv_cb);
899 ff_free_vlc(&c->vlev[i].flags_cb);
900 ff_free_vlc(&c->vlev[i].bias_cb);
901 }
902
903 return 0;
904 }
905
906 AVCodec ff_clearvideo_decoder = {
907 .name = "clearvideo",
908 .long_name = NULL_IF_CONFIG_SMALL("Iterated Systems ClearVideo"),
909 .type = AVMEDIA_TYPE_VIDEO,
910 .id = AV_CODEC_ID_CLEARVIDEO,
911 .priv_data_size = sizeof(CLVContext),
912 .init = clv_decode_init,
913 .close = clv_decode_end,
914 .decode = clv_decode_frame,
915 .capabilities = AV_CODEC_CAP_DR1,
916 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
917 };
918