summaryrefslogtreecommitdiff
path: root/libavcodec/clearvideo.c (plain)
blob: 437c459aa55b1dd397fe461236a67e9472c60711
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
36static 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
55static 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
74static 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
90static 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
106static 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
122typedef 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
134static 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
208static 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
226static 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
274static 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
332static 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
368static 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
380AVCodec 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};
391
generated by cgit at 2024-05-17 04:14:10 (GMT)