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