FFmpeg coverage

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