Commit | Line | Data |
---|---|---|
2ba45a60 DM |
1 | /* |
2 | * KMVC decoder | |
3 | * Copyright (c) 2006 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 | * Karl Morton's Video Codec decoder | |
25 | */ | |
26 | ||
27 | #include <stdio.h> | |
28 | #include <stdlib.h> | |
29 | ||
30 | #include "avcodec.h" | |
31 | #include "bytestream.h" | |
32 | #include "internal.h" | |
33 | #include "libavutil/common.h" | |
34 | ||
35 | #define KMVC_KEYFRAME 0x80 | |
36 | #define KMVC_PALETTE 0x40 | |
37 | #define KMVC_METHOD 0x0F | |
38 | #define MAX_PALSIZE 256 | |
39 | ||
40 | /* | |
41 | * Decoder context | |
42 | */ | |
43 | typedef struct KmvcContext { | |
44 | AVCodecContext *avctx; | |
45 | ||
46 | int setpal; | |
47 | int palsize; | |
48 | uint32_t pal[MAX_PALSIZE]; | |
49 | uint8_t *cur, *prev; | |
50 | uint8_t frm0[320 * 200], frm1[320 * 200]; | |
51 | GetByteContext g; | |
52 | } KmvcContext; | |
53 | ||
54 | typedef struct BitBuf { | |
55 | int bits; | |
56 | int bitbuf; | |
57 | } BitBuf; | |
58 | ||
59 | #define BLK(data, x, y) data[av_clip((x) + (y) * 320, 0, 320 * 200 -1)] | |
60 | ||
61 | #define kmvc_init_getbits(bb, g) bb.bits = 7; bb.bitbuf = bytestream2_get_byte(g); | |
62 | ||
63 | #define kmvc_getbit(bb, g, res) {\ | |
64 | res = 0; \ | |
65 | if (bb.bitbuf & (1 << bb.bits)) res = 1; \ | |
66 | bb.bits--; \ | |
67 | if(bb.bits == -1) { \ | |
68 | bb.bitbuf = bytestream2_get_byte(g); \ | |
69 | bb.bits = 7; \ | |
70 | } \ | |
71 | } | |
72 | ||
73 | static int kmvc_decode_intra_8x8(KmvcContext * ctx, int w, int h) | |
74 | { | |
75 | BitBuf bb; | |
76 | int res, val; | |
77 | int i, j; | |
78 | int bx, by; | |
79 | int l0x, l1x, l0y, l1y; | |
80 | int mx, my; | |
81 | ||
82 | kmvc_init_getbits(bb, &ctx->g); | |
83 | ||
84 | for (by = 0; by < h; by += 8) | |
85 | for (bx = 0; bx < w; bx += 8) { | |
86 | if (!bytestream2_get_bytes_left(&ctx->g)) { | |
87 | av_log(ctx->avctx, AV_LOG_ERROR, "Data overrun\n"); | |
88 | return AVERROR_INVALIDDATA; | |
89 | } | |
90 | kmvc_getbit(bb, &ctx->g, res); | |
91 | if (!res) { // fill whole 8x8 block | |
92 | val = bytestream2_get_byte(&ctx->g); | |
93 | for (i = 0; i < 64; i++) | |
94 | BLK(ctx->cur, bx + (i & 0x7), by + (i >> 3)) = val; | |
95 | } else { // handle four 4x4 subblocks | |
96 | for (i = 0; i < 4; i++) { | |
97 | l0x = bx + (i & 1) * 4; | |
98 | l0y = by + (i & 2) * 2; | |
99 | kmvc_getbit(bb, &ctx->g, res); | |
100 | if (!res) { | |
101 | kmvc_getbit(bb, &ctx->g, res); | |
102 | if (!res) { // fill whole 4x4 block | |
103 | val = bytestream2_get_byte(&ctx->g); | |
104 | for (j = 0; j < 16; j++) | |
105 | BLK(ctx->cur, l0x + (j & 3), l0y + (j >> 2)) = val; | |
106 | } else { // copy block from already decoded place | |
107 | val = bytestream2_get_byte(&ctx->g); | |
108 | mx = val & 0xF; | |
109 | my = val >> 4; | |
110 | if ((l0x-mx) + 320*(l0y-my) < 0 || (l0x-mx) + 320*(l0y-my) > 320*197 - 4) { | |
111 | av_log(ctx->avctx, AV_LOG_ERROR, "Invalid MV\n"); | |
112 | return AVERROR_INVALIDDATA; | |
113 | } | |
114 | for (j = 0; j < 16; j++) | |
115 | BLK(ctx->cur, l0x + (j & 3), l0y + (j >> 2)) = | |
116 | BLK(ctx->cur, l0x + (j & 3) - mx, l0y + (j >> 2) - my); | |
117 | } | |
118 | } else { // descend to 2x2 sub-sub-blocks | |
119 | for (j = 0; j < 4; j++) { | |
120 | l1x = l0x + (j & 1) * 2; | |
121 | l1y = l0y + (j & 2); | |
122 | kmvc_getbit(bb, &ctx->g, res); | |
123 | if (!res) { | |
124 | kmvc_getbit(bb, &ctx->g, res); | |
125 | if (!res) { // fill whole 2x2 block | |
126 | val = bytestream2_get_byte(&ctx->g); | |
127 | BLK(ctx->cur, l1x, l1y) = val; | |
128 | BLK(ctx->cur, l1x + 1, l1y) = val; | |
129 | BLK(ctx->cur, l1x, l1y + 1) = val; | |
130 | BLK(ctx->cur, l1x + 1, l1y + 1) = val; | |
131 | } else { // copy block from already decoded place | |
132 | val = bytestream2_get_byte(&ctx->g); | |
133 | mx = val & 0xF; | |
134 | my = val >> 4; | |
135 | if ((l1x-mx) + 320*(l1y-my) < 0 || (l1x-mx) + 320*(l1y-my) > 320*199 - 2) { | |
136 | av_log(ctx->avctx, AV_LOG_ERROR, "Invalid MV\n"); | |
137 | return AVERROR_INVALIDDATA; | |
138 | } | |
139 | BLK(ctx->cur, l1x, l1y) = BLK(ctx->cur, l1x - mx, l1y - my); | |
140 | BLK(ctx->cur, l1x + 1, l1y) = | |
141 | BLK(ctx->cur, l1x + 1 - mx, l1y - my); | |
142 | BLK(ctx->cur, l1x, l1y + 1) = | |
143 | BLK(ctx->cur, l1x - mx, l1y + 1 - my); | |
144 | BLK(ctx->cur, l1x + 1, l1y + 1) = | |
145 | BLK(ctx->cur, l1x + 1 - mx, l1y + 1 - my); | |
146 | } | |
147 | } else { // read values for block | |
148 | BLK(ctx->cur, l1x, l1y) = bytestream2_get_byte(&ctx->g); | |
149 | BLK(ctx->cur, l1x + 1, l1y) = bytestream2_get_byte(&ctx->g); | |
150 | BLK(ctx->cur, l1x, l1y + 1) = bytestream2_get_byte(&ctx->g); | |
151 | BLK(ctx->cur, l1x + 1, l1y + 1) = bytestream2_get_byte(&ctx->g); | |
152 | } | |
153 | } | |
154 | } | |
155 | } | |
156 | } | |
157 | } | |
158 | ||
159 | return 0; | |
160 | } | |
161 | ||
162 | static int kmvc_decode_inter_8x8(KmvcContext * ctx, int w, int h) | |
163 | { | |
164 | BitBuf bb; | |
165 | int res, val; | |
166 | int i, j; | |
167 | int bx, by; | |
168 | int l0x, l1x, l0y, l1y; | |
169 | int mx, my; | |
170 | ||
171 | kmvc_init_getbits(bb, &ctx->g); | |
172 | ||
173 | for (by = 0; by < h; by += 8) | |
174 | for (bx = 0; bx < w; bx += 8) { | |
175 | kmvc_getbit(bb, &ctx->g, res); | |
176 | if (!res) { | |
177 | kmvc_getbit(bb, &ctx->g, res); | |
178 | if (!res) { // fill whole 8x8 block | |
179 | if (!bytestream2_get_bytes_left(&ctx->g)) { | |
180 | av_log(ctx->avctx, AV_LOG_ERROR, "Data overrun\n"); | |
181 | return AVERROR_INVALIDDATA; | |
182 | } | |
183 | val = bytestream2_get_byte(&ctx->g); | |
184 | for (i = 0; i < 64; i++) | |
185 | BLK(ctx->cur, bx + (i & 0x7), by + (i >> 3)) = val; | |
186 | } else { // copy block from previous frame | |
187 | for (i = 0; i < 64; i++) | |
188 | BLK(ctx->cur, bx + (i & 0x7), by + (i >> 3)) = | |
189 | BLK(ctx->prev, bx + (i & 0x7), by + (i >> 3)); | |
190 | } | |
191 | } else { // handle four 4x4 subblocks | |
192 | if (!bytestream2_get_bytes_left(&ctx->g)) { | |
193 | av_log(ctx->avctx, AV_LOG_ERROR, "Data overrun\n"); | |
194 | return AVERROR_INVALIDDATA; | |
195 | } | |
196 | for (i = 0; i < 4; i++) { | |
197 | l0x = bx + (i & 1) * 4; | |
198 | l0y = by + (i & 2) * 2; | |
199 | kmvc_getbit(bb, &ctx->g, res); | |
200 | if (!res) { | |
201 | kmvc_getbit(bb, &ctx->g, res); | |
202 | if (!res) { // fill whole 4x4 block | |
203 | val = bytestream2_get_byte(&ctx->g); | |
204 | for (j = 0; j < 16; j++) | |
205 | BLK(ctx->cur, l0x + (j & 3), l0y + (j >> 2)) = val; | |
206 | } else { // copy block | |
207 | val = bytestream2_get_byte(&ctx->g); | |
208 | mx = (val & 0xF) - 8; | |
209 | my = (val >> 4) - 8; | |
210 | if ((l0x+mx) + 320*(l0y+my) < 0 || (l0x+mx) + 320*(l0y+my) > 320*197 - 4) { | |
211 | av_log(ctx->avctx, AV_LOG_ERROR, "Invalid MV\n"); | |
212 | return AVERROR_INVALIDDATA; | |
213 | } | |
214 | for (j = 0; j < 16; j++) | |
215 | BLK(ctx->cur, l0x + (j & 3), l0y + (j >> 2)) = | |
216 | BLK(ctx->prev, l0x + (j & 3) + mx, l0y + (j >> 2) + my); | |
217 | } | |
218 | } else { // descend to 2x2 sub-sub-blocks | |
219 | for (j = 0; j < 4; j++) { | |
220 | l1x = l0x + (j & 1) * 2; | |
221 | l1y = l0y + (j & 2); | |
222 | kmvc_getbit(bb, &ctx->g, res); | |
223 | if (!res) { | |
224 | kmvc_getbit(bb, &ctx->g, res); | |
225 | if (!res) { // fill whole 2x2 block | |
226 | val = bytestream2_get_byte(&ctx->g); | |
227 | BLK(ctx->cur, l1x, l1y) = val; | |
228 | BLK(ctx->cur, l1x + 1, l1y) = val; | |
229 | BLK(ctx->cur, l1x, l1y + 1) = val; | |
230 | BLK(ctx->cur, l1x + 1, l1y + 1) = val; | |
231 | } else { // copy block | |
232 | val = bytestream2_get_byte(&ctx->g); | |
233 | mx = (val & 0xF) - 8; | |
234 | my = (val >> 4) - 8; | |
235 | if ((l1x+mx) + 320*(l1y+my) < 0 || (l1x+mx) + 320*(l1y+my) > 320*199 - 2) { | |
236 | av_log(ctx->avctx, AV_LOG_ERROR, "Invalid MV\n"); | |
237 | return AVERROR_INVALIDDATA; | |
238 | } | |
239 | BLK(ctx->cur, l1x, l1y) = BLK(ctx->prev, l1x + mx, l1y + my); | |
240 | BLK(ctx->cur, l1x + 1, l1y) = | |
241 | BLK(ctx->prev, l1x + 1 + mx, l1y + my); | |
242 | BLK(ctx->cur, l1x, l1y + 1) = | |
243 | BLK(ctx->prev, l1x + mx, l1y + 1 + my); | |
244 | BLK(ctx->cur, l1x + 1, l1y + 1) = | |
245 | BLK(ctx->prev, l1x + 1 + mx, l1y + 1 + my); | |
246 | } | |
247 | } else { // read values for block | |
248 | BLK(ctx->cur, l1x, l1y) = bytestream2_get_byte(&ctx->g); | |
249 | BLK(ctx->cur, l1x + 1, l1y) = bytestream2_get_byte(&ctx->g); | |
250 | BLK(ctx->cur, l1x, l1y + 1) = bytestream2_get_byte(&ctx->g); | |
251 | BLK(ctx->cur, l1x + 1, l1y + 1) = bytestream2_get_byte(&ctx->g); | |
252 | } | |
253 | } | |
254 | } | |
255 | } | |
256 | } | |
257 | } | |
258 | ||
259 | return 0; | |
260 | } | |
261 | ||
262 | static int decode_frame(AVCodecContext * avctx, void *data, int *got_frame, | |
263 | AVPacket *avpkt) | |
264 | { | |
265 | KmvcContext *const ctx = avctx->priv_data; | |
266 | AVFrame *frame = data; | |
267 | uint8_t *out, *src; | |
268 | int i, ret; | |
269 | int header; | |
270 | int blocksize; | |
271 | const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL); | |
272 | ||
273 | bytestream2_init(&ctx->g, avpkt->data, avpkt->size); | |
274 | ||
275 | if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) | |
276 | return ret; | |
277 | ||
278 | header = bytestream2_get_byte(&ctx->g); | |
279 | ||
280 | /* blocksize 127 is really palette change event */ | |
281 | if (bytestream2_peek_byte(&ctx->g) == 127) { | |
282 | bytestream2_skip(&ctx->g, 3); | |
283 | for (i = 0; i < 127; i++) { | |
284 | ctx->pal[i + (header & 0x81)] = 0xFFU << 24 | bytestream2_get_be24(&ctx->g); | |
285 | bytestream2_skip(&ctx->g, 1); | |
286 | } | |
287 | bytestream2_seek(&ctx->g, -127 * 4 - 3, SEEK_CUR); | |
288 | } | |
289 | ||
290 | if (header & KMVC_KEYFRAME) { | |
291 | frame->key_frame = 1; | |
292 | frame->pict_type = AV_PICTURE_TYPE_I; | |
293 | } else { | |
294 | frame->key_frame = 0; | |
295 | frame->pict_type = AV_PICTURE_TYPE_P; | |
296 | } | |
297 | ||
298 | if (header & KMVC_PALETTE) { | |
299 | frame->palette_has_changed = 1; | |
300 | // palette starts from index 1 and has 127 entries | |
301 | for (i = 1; i <= ctx->palsize; i++) { | |
302 | ctx->pal[i] = 0xFFU << 24 | bytestream2_get_be24(&ctx->g); | |
303 | } | |
304 | } | |
305 | ||
306 | if (pal) { | |
307 | frame->palette_has_changed = 1; | |
308 | memcpy(ctx->pal, pal, AVPALETTE_SIZE); | |
309 | } | |
310 | ||
311 | if (ctx->setpal) { | |
312 | ctx->setpal = 0; | |
313 | frame->palette_has_changed = 1; | |
314 | } | |
315 | ||
316 | /* make the palette available on the way out */ | |
317 | memcpy(frame->data[1], ctx->pal, 1024); | |
318 | ||
319 | blocksize = bytestream2_get_byte(&ctx->g); | |
320 | ||
321 | if (blocksize != 8 && blocksize != 127) { | |
322 | av_log(avctx, AV_LOG_ERROR, "Block size = %i\n", blocksize); | |
323 | return AVERROR_INVALIDDATA; | |
324 | } | |
325 | memset(ctx->cur, 0, 320 * 200); | |
326 | switch (header & KMVC_METHOD) { | |
327 | case 0: | |
328 | case 1: // used in palette changed event | |
329 | memcpy(ctx->cur, ctx->prev, 320 * 200); | |
330 | break; | |
331 | case 3: | |
332 | kmvc_decode_intra_8x8(ctx, avctx->width, avctx->height); | |
333 | break; | |
334 | case 4: | |
335 | kmvc_decode_inter_8x8(ctx, avctx->width, avctx->height); | |
336 | break; | |
337 | default: | |
338 | av_log(avctx, AV_LOG_ERROR, "Unknown compression method %i\n", header & KMVC_METHOD); | |
339 | return AVERROR_INVALIDDATA; | |
340 | } | |
341 | ||
342 | out = frame->data[0]; | |
343 | src = ctx->cur; | |
344 | for (i = 0; i < avctx->height; i++) { | |
345 | memcpy(out, src, avctx->width); | |
346 | src += 320; | |
347 | out += frame->linesize[0]; | |
348 | } | |
349 | ||
350 | /* flip buffers */ | |
351 | if (ctx->cur == ctx->frm0) { | |
352 | ctx->cur = ctx->frm1; | |
353 | ctx->prev = ctx->frm0; | |
354 | } else { | |
355 | ctx->cur = ctx->frm0; | |
356 | ctx->prev = ctx->frm1; | |
357 | } | |
358 | ||
359 | *got_frame = 1; | |
360 | ||
361 | /* always report that the buffer was completely consumed */ | |
362 | return avpkt->size; | |
363 | } | |
364 | ||
365 | ||
366 | ||
367 | /* | |
368 | * Init kmvc decoder | |
369 | */ | |
370 | static av_cold int decode_init(AVCodecContext * avctx) | |
371 | { | |
372 | KmvcContext *const c = avctx->priv_data; | |
373 | int i; | |
374 | ||
375 | c->avctx = avctx; | |
376 | ||
377 | if (avctx->width > 320 || avctx->height > 200) { | |
378 | av_log(avctx, AV_LOG_ERROR, "KMVC supports frames <= 320x200\n"); | |
379 | return AVERROR(EINVAL); | |
380 | } | |
381 | ||
382 | c->cur = c->frm0; | |
383 | c->prev = c->frm1; | |
384 | ||
385 | for (i = 0; i < 256; i++) { | |
386 | c->pal[i] = 0xFFU << 24 | i * 0x10101; | |
387 | } | |
388 | ||
389 | if (avctx->extradata_size < 12) { | |
390 | av_log(avctx, AV_LOG_WARNING, | |
391 | "Extradata missing, decoding may not work properly...\n"); | |
392 | c->palsize = 127; | |
393 | } else { | |
394 | c->palsize = AV_RL16(avctx->extradata + 10); | |
395 | if (c->palsize >= (unsigned)MAX_PALSIZE) { | |
396 | c->palsize = 127; | |
397 | av_log(avctx, AV_LOG_ERROR, "KMVC palette too large\n"); | |
398 | return AVERROR_INVALIDDATA; | |
399 | } | |
400 | } | |
401 | ||
402 | if (avctx->extradata_size == 1036) { // palette in extradata | |
403 | uint8_t *src = avctx->extradata + 12; | |
404 | for (i = 0; i < 256; i++) { | |
405 | c->pal[i] = AV_RL32(src); | |
406 | src += 4; | |
407 | } | |
408 | c->setpal = 1; | |
409 | } | |
410 | ||
411 | avctx->pix_fmt = AV_PIX_FMT_PAL8; | |
412 | ||
413 | return 0; | |
414 | } | |
415 | ||
416 | AVCodec ff_kmvc_decoder = { | |
417 | .name = "kmvc", | |
418 | .long_name = NULL_IF_CONFIG_SMALL("Karl Morton's video codec"), | |
419 | .type = AVMEDIA_TYPE_VIDEO, | |
420 | .id = AV_CODEC_ID_KMVC, | |
421 | .priv_data_size = sizeof(KmvcContext), | |
422 | .init = decode_init, | |
423 | .decode = decode_frame, | |
424 | .capabilities = CODEC_CAP_DR1, | |
425 | }; |