avcodec: add ClearVideo decoder
[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]) << dshift) + bias;  \
189     const int t7 = ((blk[0 * step] - blk[4 * step]) << 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
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     if ((ret = ff_reget_buffer(avctx, c->pic)) < 0)
293         return ret;
294
295     c->pic->key_frame = frame_type & 0x20 ? 1 : 0;
296     c->pic->pict_type = frame_type & 0x20 ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
297
298     if (frame_type & 0x2) {
299         bytestream2_get_be32(&gb); // frame size;
300         c->ac_quant        = bytestream2_get_byte(&gb);
301         c->luma_dc_quant   = 32;
302         c->chroma_dc_quant = 32;
303
304         if ((ret = init_get_bits8(&c->gb, buf + bytestream2_tell(&gb),
305                                   (buf_size - bytestream2_tell(&gb)))) < 0)
306             return ret;
307
308         for (i = 0; i < 3; i++)
309             c->top_dc[i] = 32;
310         for (i = 0; i < 4; i++)
311             c->left_dc[i] = 32;
312
313         for (j = 0; j < c->mb_height; j++) {
314             for (i = 0; i < c->mb_width; i++) {
315                 ret |= decode_mb(c, i, j);
316             }
317         }
318     } else {
319     }
320
321     if ((ret = av_frame_ref(data, c->pic)) < 0)
322         return ret;
323
324     *got_frame = 1;
325
326     return ret < 0 ? ret : buf_size;
327 }
328
329 static av_cold int clv_decode_init(AVCodecContext *avctx)
330 {
331     CLVContext * const c = avctx->priv_data;
332     int ret;
333
334     c->avctx = avctx;
335
336     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
337
338     c->pic = av_frame_alloc();
339     if (!c->pic)
340         return AVERROR(ENOMEM);
341
342     c->mb_width  = FFALIGN(avctx->width,  16) >> 4;
343     c->mb_height = FFALIGN(avctx->height, 16) >> 4;
344
345     ff_idctdsp_init(&c->idsp, avctx);
346     ret = init_vlc(&c->dc_vlc, 9, NUM_DC_CODES,
347                    clv_dc_bits,  1, 1,
348                    clv_dc_codes, 1, 1, 0);
349     if (ret) {
350         av_log(avctx, AV_LOG_ERROR, "Error initialising DC VLC\n");
351         return ret;
352     }
353     ret = ff_init_vlc_sparse(&c->ac_vlc, 9, NUM_AC_CODES,
354                              clv_ac_bits,  1, 1,
355                              clv_ac_codes, 1, 1,
356                              clv_ac_syms,  2, 2, 0);
357     if (ret) {
358         av_log(avctx, AV_LOG_ERROR, "Error initialising AC VLC\n");
359         return ret;
360     }
361
362     return 0;
363 }
364
365 static av_cold int clv_decode_end(AVCodecContext *avctx)
366 {
367     CLVContext * const c = avctx->priv_data;
368
369     av_frame_free(&c->pic);
370
371     ff_free_vlc(&c->dc_vlc);
372     ff_free_vlc(&c->ac_vlc);
373
374     return 0;
375 }
376
377 AVCodec ff_clearvideo_decoder = {
378     .name           = "clearvideo",
379     .type           = AVMEDIA_TYPE_VIDEO,
380     .id             = AV_CODEC_ID_CLEARVIDEO,
381     .priv_data_size = sizeof(CLVContext),
382     .init           = clv_decode_init,
383     .close          = clv_decode_end,
384     .decode         = clv_decode_frame,
385     .capabilities   = CODEC_CAP_DR1,
386     .long_name      = NULL_IF_CONFIG_SMALL("Iterated Systems ClearVideo"),
387 };