avcodec/pnm: Avoid structure pointer dereferences in inner loop in pnm_get()
[ffmpeg.git] / 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 };