2c06b79fd5673b2533148251419c3007787139d2
[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 "bytestream.h"
29 #include "get_bits.h"
30 #include "idctdsp.h"
31 #include "internal.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     int            iframes_warning;
133 } CLVContext;
134
135 static inline int decode_block(CLVContext *ctx, int16_t *blk, int has_ac,
136                                int ac_quant)
137 {
138     GetBitContext *gb = &ctx->gb;
139     int idx = 1, last = 0, val, skip;
140
141     memset(blk, 0, sizeof(*blk) * 64);
142     blk[0] = get_vlc2(gb, ctx->dc_vlc.table, 9, 3);
143     if (blk[0] < 0)
144         return AVERROR_INVALIDDATA;
145     blk[0] -= 63;
146
147     if (!has_ac)
148         return 0;
149
150     while (idx < 64 && !last) {
151         val = get_vlc2(gb, ctx->ac_vlc.table, 9, 2);
152         if (val < 0)
153             return AVERROR_INVALIDDATA;
154         if (val != 0x1BFF) {
155             last =  val >> 12;
156             skip = (val >> 4) & 0xFF;
157             val &= 0xF;
158             if (get_bits1(gb))
159                 val = -val;
160         } else {
161             last = get_bits1(gb);
162             skip = get_bits(gb, 6);
163             val  = get_sbits(gb, 8);
164         }
165         if (val) {
166             int aval = FFABS(val), sign = val < 0;
167             val = ac_quant * (2 * aval + 1);
168             if (!(ac_quant & 1))
169                 val--;
170             if (sign)
171                 val = -val;
172         }
173         idx += skip;
174         if (idx >= 64)
175             return AVERROR_INVALIDDATA;
176         blk[ff_zigzag_direct[idx++]] = val;
177     }
178
179     return (idx <= 64 && last) ? 0 : -1;
180 }
181
182 #define DCT_TEMPLATE(blk, step, bias, shift, dshift, OP)                \
183     const int t0 = OP(2841 * blk[1 * step] +  565 * blk[7 * step]);     \
184     const int t1 = OP( 565 * blk[1 * step] - 2841 * blk[7 * step]);     \
185     const int t2 = OP(1609 * blk[5 * step] + 2408 * blk[3 * step]);     \
186     const int t3 = OP(2408 * blk[5 * step] - 1609 * blk[3 * step]);     \
187     const int t4 = OP(1108 * blk[2 * step] - 2676 * blk[6 * step]);     \
188     const int t5 = OP(2676 * blk[2 * step] + 1108 * blk[6 * step]);     \
189     const int t6 = ((blk[0 * step] + blk[4 * step]) * (1 << dshift)) + bias;  \
190     const int t7 = ((blk[0 * step] - blk[4 * step]) * (1 << dshift)) + bias;  \
191     const int t8 = t0 + t2;                                             \
192     const int t9 = t0 - t2;                                             \
193     const int tA = (int)(181U * (t9 + (t1 - t3)) + 0x80) >> 8;          \
194     const int tB = (int)(181U * (t9 - (t1 - t3)) + 0x80) >> 8;          \
195     const int tC = t1 + t3;                                             \
196                                                                         \
197     blk[0 * step] = (t6 + t5 + t8) >> shift;                            \
198     blk[1 * step] = (t7 + t4 + tA) >> shift;                            \
199     blk[2 * step] = (t7 - t4 + tB) >> shift;                            \
200     blk[3 * step] = (t6 - t5 + tC) >> shift;                            \
201     blk[4 * step] = (t6 - t5 - tC) >> shift;                            \
202     blk[5 * step] = (t7 - t4 - tB) >> shift;                            \
203     blk[6 * step] = (t7 + t4 - tA) >> shift;                            \
204     blk[7 * step] = (t6 + t5 - t8) >> shift;                            \
205
206 #define ROP(x) x
207 #define COP(x) (((x) + 4) >> 3)
208
209 static void clv_dct(int16_t *block)
210 {
211     int i;
212     int16_t *ptr;
213
214     ptr = block;
215     for (i = 0; i < 8; i++) {
216         DCT_TEMPLATE(ptr, 1, 0x80, 8, 11, ROP);
217         ptr += 8;
218     }
219
220     ptr = block;
221     for (i = 0; i < 8; i++) {
222         DCT_TEMPLATE(ptr, 8, 0x2000, 14, 8, COP);
223         ptr++;
224     }
225 }
226
227 static int decode_mb(CLVContext *c, int x, int y)
228 {
229     int i, has_ac[6], off;
230
231     for (i = 0; i < 6; i++)
232         has_ac[i] = get_bits1(&c->gb);
233
234     off = x * 16 + y * 16 * c->pic->linesize[0];
235     for (i = 0; i < 4; i++) {
236         if (decode_block(c, c->block, has_ac[i], c->ac_quant) < 0)
237             return AVERROR_INVALIDDATA;
238         if (!x && !(i & 1)) {
239             c->block[0] += c->top_dc[0];
240             c->top_dc[0] = c->block[0];
241         } else {
242             c->block[0] += c->left_dc[(i & 2) >> 1];
243         }
244         c->left_dc[(i & 2) >> 1] = c->block[0];
245         c->block[0]             *= c->luma_dc_quant;
246         clv_dct(c->block);
247         if (i == 2)
248             off += c->pic->linesize[0] * 8;
249         c->idsp.put_pixels_clamped(c->block,
250                                    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, ret;
283     int mb_ret = 0;
284
285     bytestream2_init(&gb, buf, buf_size);
286     if (avctx->codec_tag == MKTAG('C', 'L', 'V', '1')) {
287         int skip = bytestream2_get_byte(&gb);
288         bytestream2_skip(&gb, (skip + 1) * 8);
289     }
290
291     frame_type = bytestream2_get_byte(&gb);
292
293     if (frame_type & 0x2) {
294         if (buf_size < c->mb_width * c->mb_height) {
295             av_log(avctx, AV_LOG_ERROR, "Packet too small\n");
296             return AVERROR_INVALIDDATA;
297         }
298
299         if ((ret = ff_reget_buffer(avctx, c->pic)) < 0)
300             return ret;
301
302         c->pic->key_frame = frame_type & 0x20 ? 1 : 0;
303         c->pic->pict_type = frame_type & 0x20 ? AV_PICTURE_TYPE_I
304                                               : AV_PICTURE_TYPE_P;
305
306         bytestream2_get_be32(&gb); // frame size;
307         c->ac_quant        = bytestream2_get_byte(&gb);
308         c->luma_dc_quant   = 32;
309         c->chroma_dc_quant = 32;
310
311         if ((ret = init_get_bits8(&c->gb, buf + bytestream2_tell(&gb),
312                                   buf_size - bytestream2_tell(&gb))) < 0)
313             return ret;
314
315         for (i = 0; i < 3; i++)
316             c->top_dc[i] = 32;
317         for (i = 0; i < 4; i++)
318             c->left_dc[i] = 32;
319
320         for (j = 0; j < c->mb_height; j++) {
321             for (i = 0; i < c->mb_width; i++) {
322                 ret = decode_mb(c, i, j);
323                 if (ret < 0)
324                     mb_ret = ret;
325             }
326         }
327
328         if ((ret = av_frame_ref(data, c->pic)) < 0)
329             return ret;
330
331         *got_frame = 1;
332     } else {
333         if (!c->iframes_warning)
334             avpriv_report_missing_feature(avctx, "Non-I-frames in Clearvideo");
335         c->iframes_warning = 1;
336         return AVERROR_PATCHWELCOME;
337     }
338
339     return mb_ret < 0 ? mb_ret : buf_size;
340 }
341
342 static av_cold int clv_decode_init(AVCodecContext *avctx)
343 {
344     CLVContext *const c = avctx->priv_data;
345     int ret;
346
347     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
348
349     c->avctx           = avctx;
350     c->mb_width        = FFALIGN(avctx->width,  16) >> 4;
351     c->mb_height       = FFALIGN(avctx->height, 16) >> 4;
352     c->iframes_warning = 0;
353     c->pic             = av_frame_alloc();
354     if (!c->pic)
355         return AVERROR(ENOMEM);
356
357     ff_idctdsp_init(&c->idsp, avctx);
358     ret = init_vlc(&c->dc_vlc, 9, NUM_DC_CODES,
359                    clv_dc_bits,  1, 1,
360                    clv_dc_codes, 1, 1, 0);
361     if (ret) {
362         av_log(avctx, AV_LOG_ERROR, "Error initialising DC VLC\n");
363         return ret;
364     }
365     ret = ff_init_vlc_sparse(&c->ac_vlc, 9, NUM_AC_CODES,
366                              clv_ac_bits,  1, 1,
367                              clv_ac_codes, 1, 1,
368                              clv_ac_syms,  2, 2, 0);
369     if (ret) {
370         av_log(avctx, AV_LOG_ERROR, "Error initialising AC VLC\n");
371         return ret;
372     }
373
374     return 0;
375 }
376
377 static av_cold int clv_decode_end(AVCodecContext *avctx)
378 {
379     CLVContext *const c = avctx->priv_data;
380
381     av_frame_free(&c->pic);
382
383     ff_free_vlc(&c->dc_vlc);
384     ff_free_vlc(&c->ac_vlc);
385
386     return 0;
387 }
388
389 AVCodec ff_clearvideo_decoder = {
390     .name           = "clearvideo",
391     .long_name      = NULL_IF_CONFIG_SMALL("Iterated Systems ClearVideo"),
392     .type           = AVMEDIA_TYPE_VIDEO,
393     .id             = AV_CODEC_ID_CLEARVIDEO,
394     .priv_data_size = sizeof(CLVContext),
395     .init           = clv_decode_init,
396     .close          = clv_decode_end,
397     .decode         = clv_decode_frame,
398     .capabilities   = AV_CODEC_CAP_DR1,
399     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
400 };