avcodec/clearvideo: Fix multiple runtime error: left shift of negative value -1024
[ffmpeg.git] / libavcodec / clearvideo.c
1 /*
2  * ClearVideo decoder
3  * Copyright (c) 2012 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 "idctdsp.h"
29 #include "internal.h"
30 #include "get_bits.h"
31 #include "bytestream.h"
32
33 #define NUM_DC_CODES 127
34 #define NUM_AC_CODES 103
35
36 static const uint8_t clv_dc_codes[NUM_DC_CODES] = {
37     0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
38     0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
39     0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x07, 0x0B,
40     0x0C, 0x08, 0x08, 0x09, 0x04, 0x06, 0x07, 0x05,
41     0x04, 0x05, 0x04, 0x06, 0x05, 0x06, 0x07, 0x05,
42     0x06, 0x07, 0x06, 0x07, 0x08, 0x06, 0x07, 0x08,
43     0x09, 0x0A, 0x0B, 0x07, 0x08, 0x09, 0x07, 0x08,
44     0x06, 0x07, 0x08, 0x06, 0x04, 0x05, 0x02, 0x01,
45     0x03, 0x06, 0x07, 0x07, 0x09, 0x0A, 0x0B, 0x09,
46     0x0A, 0x0B, 0x0A, 0x0B, 0x0C, 0x0D, 0x0C, 0x09,
47     0x0D, 0x0A, 0x0B, 0x08, 0x09, 0x0A, 0x0B, 0x07,
48     0x08, 0x09, 0x0A, 0x0B, 0x06, 0x07, 0x06, 0x08,
49     0x07, 0x09, 0x0A, 0x0B, 0x09, 0x0A, 0x0B, 0x0C,
50     0x14, 0x0D, 0x0D, 0x0E, 0x0F, 0x15, 0x15, 0x16,
51     0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E,
52     0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25,
53 };
54
55 static const uint8_t clv_dc_bits[NUM_DC_CODES] = {
56     22, 22, 22, 22, 22, 22, 22, 22,
57     22, 22, 22, 22, 22, 22, 22, 22,
58     22, 22, 22, 21, 22, 22, 19, 20,
59     20, 19, 18, 18, 15, 17, 17, 16,
60     14, 15, 12, 13, 14, 14, 14, 12,
61     12, 12, 11, 11, 11, 10, 10, 10,
62     10, 10, 10,  9,  9,  9,  8,  8,
63      7,  7,  7,  6,  5,  5,  3,  1,
64      3,  5,  5,  6,  7,  7,  7,  8,
65      8,  8,  9,  9,  9,  9, 10, 11,
66     10, 11, 11, 12, 12, 12, 12, 13,
67     14, 14, 14, 14, 15, 15, 16, 17,
68     16, 17, 18, 18, 19, 19, 19, 19,
69     21, 19, 20, 19, 19, 21, 22, 22,
70     22, 22, 22, 22, 22, 22, 22, 22,
71     22, 22, 22, 22, 22, 22, 22,
72 };
73
74 static const uint16_t clv_ac_syms[NUM_AC_CODES] = {
75     0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008,
76     0x0009, 0x000A, 0x000B, 0x000C, 0x0011, 0x0012, 0x0013, 0x0014,
77     0x0015, 0x0016, 0x0021, 0x0022, 0x0023, 0x0024, 0x0031, 0x0032,
78     0x0033, 0x0041, 0x0042, 0x0043, 0x0051, 0x0052, 0x0053, 0x0061,
79     0x0062, 0x0063, 0x0071, 0x0072, 0x0081, 0x0082, 0x0091, 0x0092,
80     0x00A1, 0x00A2, 0x00B1, 0x00C1, 0x00D1, 0x00E1, 0x00F1, 0x0101,
81     0x0111, 0x0121, 0x0131, 0x0141, 0x0151, 0x0161, 0x0171, 0x0181,
82     0x0191, 0x01A1, 0x1001, 0x1002, 0x1003, 0x1011, 0x1012, 0x1021,
83     0x1031, 0x1041, 0x1051, 0x1061, 0x1071, 0x1081, 0x1091, 0x10A1,
84     0x10B1, 0x10C1, 0x10D1, 0x10E1, 0x10F1, 0x1101, 0x1111, 0x1121,
85     0x1131, 0x1141, 0x1151, 0x1161, 0x1171, 0x1181, 0x1191, 0x11A1,
86     0x11B1, 0x11C1, 0x11D1, 0x11E1, 0x11F1, 0x1201, 0x1211, 0x1221,
87     0x1231, 0x1241, 0x1251, 0x1261, 0x1271, 0x1281, 0x1BFF,
88 };
89
90 static const uint8_t clv_ac_codes[NUM_AC_CODES] = {
91     0x02, 0x0F, 0x15, 0x17, 0x1F, 0x25, 0x24, 0x21,
92     0x20, 0x07, 0x06, 0x20, 0x06, 0x14, 0x1E, 0x0F,
93     0x21, 0x50, 0x0E, 0x1D, 0x0E, 0x51, 0x0D, 0x23,
94     0x0D, 0x0C, 0x22, 0x52, 0x0B, 0x0C, 0x53, 0x13,
95     0x0B, 0x54, 0x12, 0x0A, 0x11, 0x09, 0x10, 0x08,
96     0x16, 0x55, 0x15, 0x14, 0x1C, 0x1B, 0x21, 0x20,
97     0x1F, 0x1E, 0x1D, 0x1C, 0x1B, 0x1A, 0x22, 0x23,
98     0x56, 0x57, 0x07, 0x19, 0x05, 0x0F, 0x04, 0x0E,
99     0x0D, 0x0C, 0x13, 0x12, 0x11, 0x10, 0x1A, 0x19,
100     0x18, 0x17, 0x16, 0x15, 0x14, 0x13, 0x18, 0x17,
101     0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x07, 0x06,
102     0x05, 0x04, 0x24, 0x25, 0x26, 0x27, 0x58, 0x59,
103     0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x03,
104 };
105
106 static const uint8_t clv_ac_bits[NUM_AC_CODES] = {
107      2,  4,  6,  7,  8,  9,  9, 10,
108     10, 11, 11, 11,  3,  6,  8, 10,
109     11, 12,  4,  8, 10, 12,  5,  9,
110     10,  5,  9, 12,  5, 10, 12,  6,
111     10, 12,  6, 10,  6, 10,  6, 10,
112      7, 12,  7,  7,  8,  8,  9,  9,
113      9,  9,  9,  9,  9,  9, 11, 11,
114     12, 12,  4,  9, 11,  6, 11,  6,
115      6,  6,  7,  7,  7,  7,  8,  8,
116      8,  8,  8,  8,  8,  8,  9,  9,
117      9,  9,  9,  9,  9,  9, 10, 10,
118     10, 10, 11, 11, 11, 11, 12, 12,
119     12, 12, 12, 12, 12, 12,  7,
120 };
121
122 typedef struct CLVContext {
123     AVCodecContext *avctx;
124     IDCTDSPContext idsp;
125     AVFrame        *pic;
126     GetBitContext  gb;
127     int            mb_width, mb_height;
128     VLC            dc_vlc, ac_vlc;
129     int            luma_dc_quant, chroma_dc_quant, ac_quant;
130     DECLARE_ALIGNED(16, int16_t, block)[64];
131     int            top_dc[3], left_dc[4];
132 } CLVContext;
133
134 static inline int decode_block(CLVContext *ctx, int16_t *blk, int has_ac,
135                                int ac_quant)
136 {
137     GetBitContext *gb = &ctx->gb;
138     int idx = 1, last = 0, val, skip;
139
140     memset(blk, 0, sizeof(*blk) * 64);
141     blk[0] = get_vlc2(gb, ctx->dc_vlc.table, 9, 3);
142     if (blk[0] < 0)
143         return AVERROR_INVALIDDATA;
144     blk[0] -= 63;
145
146     if (!has_ac)
147         return 0;
148
149     while (idx < 64 && !last) {
150         val = get_vlc2(gb, ctx->ac_vlc.table, 9, 2);
151         if (val < 0)
152             return AVERROR_INVALIDDATA;
153         if (val != 0x1BFF) {
154             last =  val >> 12;
155             skip = (val >> 4) & 0xFF;
156             val &= 0xF;
157             if (get_bits1(gb))
158                 val = -val;
159         } else {
160             last = get_bits1(gb);
161             skip = get_bits(gb, 6);
162             val  = get_sbits(gb, 8);
163         }
164         if (val) {
165             int aval = FFABS(val), sign = val < 0;
166             val = ac_quant * (2 * aval + 1);
167             if (!(ac_quant & 1))
168                 val--;
169             if (sign)
170                 val = -val;
171         }
172         idx += skip;
173         if (idx >= 64)
174             return AVERROR_INVALIDDATA;
175         blk[ff_zigzag_direct[idx++]] = val;
176     }
177
178     return (idx <= 64 && last) ? 0 : -1;
179 }
180
181 #define DCT_TEMPLATE(blk, step, bias, shift, dshift, OP)                \
182     const int t0 = OP( 2841 * blk[1 * step] +  565 * blk[7 * step]);    \
183     const int t1 = OP(  565 * blk[1 * step] - 2841 * blk[7 * step]);    \
184     const int t2 = OP( 1609 * blk[5 * step] + 2408 * blk[3 * step]);    \
185     const int t3 = OP( 2408 * blk[5 * step] - 1609 * blk[3 * step]);    \
186     const int t4 = OP( 1108 * blk[2 * step] - 2676 * blk[6 * step]);    \
187     const int t5 = OP( 2676 * blk[2 * step] + 1108 * blk[6 * step]);    \
188     const int t6 = ((blk[0 * step] + blk[4 * step]) * (1 << dshift)) + bias;  \
189     const int t7 = ((blk[0 * step] - blk[4 * step]) * (1 << dshift)) + bias;  \
190     const int t8 = t0 + t2;                                             \
191     const int t9 = t0 - t2;                                             \
192     const int tA = 181 * (t9 + (t1 - t3)) + 0x80 >> 8;                  \
193     const int tB = 181 * (t9 - (t1 - t3)) + 0x80 >> 8;                  \
194     const int tC = t1 + t3;                                             \
195                                                                         \
196     blk[0 * step] = (t6 + t5 + t8) >> shift;                            \
197     blk[1 * step] = (t7 + t4 + tA) >> shift;                            \
198     blk[2 * step] = (t7 - t4 + tB) >> shift;                            \
199     blk[3 * step] = (t6 - t5 + tC) >> shift;                            \
200     blk[4 * step] = (t6 - t5 - tC) >> shift;                            \
201     blk[5 * step] = (t7 - t4 - tB) >> shift;                            \
202     blk[6 * step] = (t7 + t4 - tA) >> shift;                            \
203     blk[7 * step] = (t6 + t5 - t8) >> shift;                            \
204
205 #define ROP(x) x
206 #define COP(x) (((x) + 4) >> 3)
207
208 static void clv_dct(int16_t *block)
209 {
210     int i;
211     int16_t *ptr;
212
213     ptr = block;
214     for (i = 0; i < 8; i++) {
215         DCT_TEMPLATE(ptr, 1, 0x80, 8, 11, ROP);
216         ptr += 8;
217     }
218
219     ptr = block;
220     for (i = 0; i < 8; i++) {
221         DCT_TEMPLATE(ptr, 8, 0x2000, 14, 8, COP);
222         ptr++;
223     }
224 }
225
226 static int decode_mb(CLVContext *c, int x, int y)
227 {
228     int i;
229     int has_ac[6];
230     int off;
231
232     for (i = 0; i < 6; i++)
233         has_ac[i] = get_bits1(&c->gb);
234
235     off = x * 16 + y * 16 * c->pic->linesize[0];
236     for (i = 0; i < 4; i++) {
237         if (decode_block(c, c->block, has_ac[i], c->ac_quant) < 0)
238             return AVERROR_INVALIDDATA;
239         if (!x && !(i & 1)) {
240             c->block[0] += c->top_dc[0];
241             c->top_dc[0] = c->block[0];
242         } else {
243             c->block[0] += c->left_dc[(i & 2) >> 1];
244         }
245         c->left_dc[(i & 2) >> 1] = c->block[0];
246         c->block[0]             *= c->luma_dc_quant;
247         clv_dct(c->block);
248         if (i == 2)
249             off += c->pic->linesize[0] * 8;
250         c->idsp.put_pixels_clamped(c->block, c->pic->data[0] + off + (i & 1) * 8,
251                                    c->pic->linesize[0]);
252     }
253
254     off = x * 8 + y * 8 * c->pic->linesize[1];
255     for (i = 1; i < 3; i++) {
256         if (decode_block(c, c->block, has_ac[i + 3], c->ac_quant) < 0)
257             return AVERROR_INVALIDDATA;
258         if (!x) {
259             c->block[0] += c->top_dc[i];
260             c->top_dc[i] = c->block[0];
261         } else {
262             c->block[0] += c->left_dc[i + 1];
263         }
264         c->left_dc[i + 1] = c->block[0];
265         c->block[0]      *= c->chroma_dc_quant;
266         clv_dct(c->block);
267         c->idsp.put_pixels_clamped(c->block, c->pic->data[i] + off,
268                                    c->pic->linesize[i]);
269     }
270
271     return 0;
272 }
273
274 static int clv_decode_frame(AVCodecContext *avctx, void *data,
275                             int *got_frame, AVPacket *avpkt)
276 {
277     const uint8_t *buf = avpkt->data;
278     int buf_size = avpkt->size;
279     CLVContext *c = avctx->priv_data;
280     GetByteContext gb;
281     uint32_t frame_type;
282     int i, j;
283     int ret;
284     int mb_ret = 0;
285
286     bytestream2_init(&gb, buf, buf_size);
287     if (avctx->codec_tag == MKTAG('C','L','V','1')) {
288         int skip = bytestream2_get_byte(&gb);
289         bytestream2_skip(&gb, (skip + 1) * 8);
290     }
291
292     frame_type = bytestream2_get_byte(&gb);
293     if ((ret = ff_reget_buffer(avctx, c->pic)) < 0)
294         return ret;
295
296     c->pic->key_frame = frame_type & 0x20 ? 1 : 0;
297     c->pic->pict_type = frame_type & 0x20 ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
298
299     if (frame_type & 0x2) {
300         bytestream2_get_be32(&gb); // frame size;
301         c->ac_quant        = bytestream2_get_byte(&gb);
302         c->luma_dc_quant   = 32;
303         c->chroma_dc_quant = 32;
304
305         if ((ret = init_get_bits8(&c->gb, buf + bytestream2_tell(&gb),
306                                   (buf_size - bytestream2_tell(&gb)))) < 0)
307             return ret;
308
309         for (i = 0; i < 3; i++)
310             c->top_dc[i] = 32;
311         for (i = 0; i < 4; i++)
312             c->left_dc[i] = 32;
313
314         for (j = 0; j < c->mb_height; j++) {
315             for (i = 0; i < c->mb_width; i++) {
316                 ret = decode_mb(c, i, j);
317                 if (ret < 0)
318                     mb_ret = ret;
319             }
320         }
321     } else {
322     }
323
324     if ((ret = av_frame_ref(data, c->pic)) < 0)
325         return ret;
326
327     *got_frame = 1;
328
329     return mb_ret < 0 ? mb_ret : buf_size;
330 }
331
332 static av_cold int clv_decode_init(AVCodecContext *avctx)
333 {
334     CLVContext * const c = avctx->priv_data;
335     int ret;
336
337     c->avctx = avctx;
338
339     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
340
341     c->pic = av_frame_alloc();
342     if (!c->pic)
343         return AVERROR(ENOMEM);
344
345     c->mb_width  = FFALIGN(avctx->width,  16) >> 4;
346     c->mb_height = FFALIGN(avctx->height, 16) >> 4;
347
348     ff_idctdsp_init(&c->idsp, avctx);
349     ret = init_vlc(&c->dc_vlc, 9, NUM_DC_CODES,
350                    clv_dc_bits,  1, 1,
351                    clv_dc_codes, 1, 1, 0);
352     if (ret) {
353         av_log(avctx, AV_LOG_ERROR, "Error initialising DC VLC\n");
354         return ret;
355     }
356     ret = ff_init_vlc_sparse(&c->ac_vlc, 9, NUM_AC_CODES,
357                              clv_ac_bits,  1, 1,
358                              clv_ac_codes, 1, 1,
359                              clv_ac_syms,  2, 2, 0);
360     if (ret) {
361         av_log(avctx, AV_LOG_ERROR, "Error initialising AC VLC\n");
362         return ret;
363     }
364
365     return 0;
366 }
367
368 static av_cold int clv_decode_end(AVCodecContext *avctx)
369 {
370     CLVContext * const c = avctx->priv_data;
371
372     av_frame_free(&c->pic);
373
374     ff_free_vlc(&c->dc_vlc);
375     ff_free_vlc(&c->ac_vlc);
376
377     return 0;
378 }
379
380 AVCodec ff_clearvideo_decoder = {
381     .name           = "clearvideo",
382     .type           = AVMEDIA_TYPE_VIDEO,
383     .id             = AV_CODEC_ID_CLEARVIDEO,
384     .priv_data_size = sizeof(CLVContext),
385     .init           = clv_decode_init,
386     .close          = clv_decode_end,
387     .decode         = clv_decode_frame,
388     .capabilities   = AV_CODEC_CAP_DR1,
389     .long_name      = NULL_IF_CONFIG_SMALL("Iterated Systems ClearVideo"),
390 };