1 |
|
|
/* |
2 |
|
|
* Interplay C93 video decoder |
3 |
|
|
* Copyright (c) 2007 Anssi Hannula <anssi.hannula@gmail.com> |
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 |
|
|
#include "avcodec.h" |
23 |
|
|
#include "bytestream.h" |
24 |
|
|
#include "internal.h" |
25 |
|
|
|
26 |
|
|
typedef struct C93DecoderContext { |
27 |
|
|
AVFrame *pictures[2]; |
28 |
|
|
int currentpic; |
29 |
|
|
} C93DecoderContext; |
30 |
|
|
|
31 |
|
|
typedef enum { |
32 |
|
|
C93_8X8_FROM_PREV = 0x02, |
33 |
|
|
C93_4X4_FROM_PREV = 0x06, |
34 |
|
|
C93_4X4_FROM_CURR = 0x07, |
35 |
|
|
C93_8X8_2COLOR = 0x08, |
36 |
|
|
C93_4X4_2COLOR = 0x0A, |
37 |
|
|
C93_4X4_4COLOR_GRP = 0x0B, |
38 |
|
|
C93_4X4_4COLOR = 0x0D, |
39 |
|
|
C93_NOOP = 0x0E, |
40 |
|
|
C93_8X8_INTRA = 0x0F, |
41 |
|
|
} C93BlockType; |
42 |
|
|
|
43 |
|
|
#define WIDTH 320 |
44 |
|
|
#define HEIGHT 192 |
45 |
|
|
|
46 |
|
|
#define C93_HAS_PALETTE 0x01 |
47 |
|
|
#define C93_FIRST_FRAME 0x02 |
48 |
|
|
|
49 |
|
2 |
static av_cold int decode_end(AVCodecContext *avctx) |
50 |
|
|
{ |
51 |
|
2 |
C93DecoderContext * const c93 = avctx->priv_data; |
52 |
|
|
|
53 |
|
2 |
av_frame_free(&c93->pictures[0]); |
54 |
|
2 |
av_frame_free(&c93->pictures[1]); |
55 |
|
|
|
56 |
|
2 |
return 0; |
57 |
|
|
} |
58 |
|
|
|
59 |
|
2 |
static av_cold int decode_init(AVCodecContext *avctx) |
60 |
|
|
{ |
61 |
|
2 |
C93DecoderContext *s = avctx->priv_data; |
62 |
|
2 |
avctx->pix_fmt = AV_PIX_FMT_PAL8; |
63 |
|
|
|
64 |
|
2 |
s->pictures[0] = av_frame_alloc(); |
65 |
|
2 |
s->pictures[1] = av_frame_alloc(); |
66 |
✓✗✗✓
|
2 |
if (!s->pictures[0] || !s->pictures[1]) |
67 |
|
|
return AVERROR(ENOMEM); |
68 |
|
|
|
69 |
|
2 |
return 0; |
70 |
|
|
} |
71 |
|
|
|
72 |
|
98205 |
static inline int copy_block(AVCodecContext *avctx, uint8_t *to, |
73 |
|
|
uint8_t *from, int offset, int height, int stride) |
74 |
|
|
{ |
75 |
|
|
int i; |
76 |
|
98205 |
int width = height; |
77 |
|
98205 |
int from_x = offset % WIDTH; |
78 |
|
98205 |
int from_y = offset / WIDTH; |
79 |
|
98205 |
int overflow = from_x + width - WIDTH; |
80 |
|
|
|
81 |
✗✓ |
98205 |
if (!from) { |
82 |
|
|
/* silently ignoring predictive blocks in first frame */ |
83 |
|
|
return 0; |
84 |
|
|
} |
85 |
|
|
|
86 |
✗✓ |
98205 |
if (from_y + height > HEIGHT) { |
87 |
|
|
av_log(avctx, AV_LOG_ERROR, "invalid offset %d during C93 decoding\n", |
88 |
|
|
offset); |
89 |
|
|
return AVERROR_INVALIDDATA; |
90 |
|
|
} |
91 |
|
|
|
92 |
✗✓ |
98205 |
if (overflow > 0) { |
93 |
|
|
width -= overflow; |
94 |
|
|
for (i = 0; i < height; i++) { |
95 |
|
|
memcpy(&to[i*stride+width], &from[(from_y+i)*stride], overflow); |
96 |
|
|
} |
97 |
|
|
} |
98 |
|
|
|
99 |
✓✓ |
573461 |
for (i = 0; i < height; i++) { |
100 |
|
475256 |
memcpy(&to[i*stride], &from[(from_y+i)*stride+from_x], width); |
101 |
|
|
} |
102 |
|
|
|
103 |
|
98205 |
return 0; |
104 |
|
|
} |
105 |
|
|
|
106 |
|
2576 |
static inline void draw_n_color(uint8_t *out, int stride, int width, |
107 |
|
|
int height, int bpp, uint8_t cols[4], uint8_t grps[4], uint32_t col) |
108 |
|
|
{ |
109 |
|
|
int x, y; |
110 |
✓✓ |
11584 |
for (y = 0; y < height; y++) { |
111 |
✓✓ |
9008 |
if (grps) |
112 |
|
480 |
cols[0] = grps[3 * (y >> 1)]; |
113 |
✓✓ |
46768 |
for (x = 0; x < width; x++) { |
114 |
✓✓ |
37760 |
if (grps) |
115 |
|
1920 |
cols[1]= grps[(x >> 1) + 1]; |
116 |
|
37760 |
out[x + y*stride] = cols[col & ((1 << bpp) - 1)]; |
117 |
|
37760 |
col >>= bpp; |
118 |
|
|
} |
119 |
|
|
} |
120 |
|
2576 |
} |
121 |
|
|
|
122 |
|
45 |
static int decode_frame(AVCodecContext *avctx, void *data, |
123 |
|
|
int *got_frame, AVPacket *avpkt) |
124 |
|
|
{ |
125 |
|
45 |
const uint8_t *buf = avpkt->data; |
126 |
|
45 |
int buf_size = avpkt->size; |
127 |
|
45 |
C93DecoderContext * const c93 = avctx->priv_data; |
128 |
|
45 |
AVFrame * const newpic = c93->pictures[c93->currentpic]; |
129 |
|
45 |
AVFrame * const oldpic = c93->pictures[c93->currentpic^1]; |
130 |
|
|
GetByteContext gb; |
131 |
|
|
uint8_t *out; |
132 |
|
45 |
int stride, ret, i, x, y, b, bt = 0; |
133 |
|
|
|
134 |
✗✓ |
45 |
if ((ret = ff_set_dimensions(avctx, WIDTH, HEIGHT)) < 0) |
135 |
|
|
return ret; |
136 |
|
|
|
137 |
|
45 |
c93->currentpic ^= 1; |
138 |
|
|
|
139 |
✗✓ |
45 |
if ((ret = ff_reget_buffer(avctx, newpic, 0)) < 0) |
140 |
|
|
return ret; |
141 |
|
|
|
142 |
|
45 |
stride = newpic->linesize[0]; |
143 |
|
|
|
144 |
|
45 |
bytestream2_init(&gb, buf, buf_size); |
145 |
|
45 |
b = bytestream2_get_byte(&gb); |
146 |
✓✓ |
45 |
if (b & C93_FIRST_FRAME) { |
147 |
|
1 |
newpic->pict_type = AV_PICTURE_TYPE_I; |
148 |
|
1 |
newpic->key_frame = 1; |
149 |
|
|
} else { |
150 |
|
44 |
newpic->pict_type = AV_PICTURE_TYPE_P; |
151 |
|
44 |
newpic->key_frame = 0; |
152 |
|
|
} |
153 |
|
|
|
154 |
✓✓ |
1125 |
for (y = 0; y < HEIGHT; y += 8) { |
155 |
|
1080 |
out = newpic->data[0] + y * stride; |
156 |
✓✓ |
44280 |
for (x = 0; x < WIDTH; x += 8) { |
157 |
|
43200 |
uint8_t *copy_from = oldpic->data[0]; |
158 |
|
|
unsigned int offset, j; |
159 |
|
|
uint8_t cols[4], grps[4]; |
160 |
|
|
C93BlockType block_type; |
161 |
|
|
|
162 |
✓✓ |
43200 |
if (!bt) |
163 |
|
21600 |
bt = bytestream2_get_byte(&gb); |
164 |
|
|
|
165 |
|
43200 |
block_type= bt & 0x0F; |
166 |
✓✓✓✓ ✓✗✓✗
|
43200 |
switch (block_type) { |
167 |
|
20609 |
case C93_8X8_FROM_PREV: |
168 |
|
20609 |
offset = bytestream2_get_le16(&gb); |
169 |
✗✓ |
20609 |
if ((ret = copy_block(avctx, out, copy_from, offset, 8, stride)) < 0) |
170 |
|
|
return ret; |
171 |
|
20609 |
break; |
172 |
|
|
|
173 |
|
621 |
case C93_4X4_FROM_CURR: |
174 |
|
621 |
copy_from = newpic->data[0]; |
175 |
|
19399 |
case C93_4X4_FROM_PREV: |
176 |
✓✓ |
58197 |
for (j = 0; j < 8; j += 4) { |
177 |
✓✓ |
116394 |
for (i = 0; i < 8; i += 4) { |
178 |
|
77596 |
int offset = bytestream2_get_le16(&gb); |
179 |
|
77596 |
int from_x = offset % WIDTH; |
180 |
|
77596 |
int from_y = offset / WIDTH; |
181 |
✓✓✗✓
|
77596 |
if (block_type == C93_4X4_FROM_CURR && from_y == y+j && |
182 |
|
|
(FFABS(from_x - x-i) < 4 || FFABS(from_x - x-i) > WIDTH-4)) { |
183 |
|
|
avpriv_request_sample(avctx, "block overlap %d %d %d %d", from_x, x+i, from_y, y+j); |
184 |
|
|
return AVERROR_INVALIDDATA; |
185 |
|
|
} |
186 |
✗✓ |
77596 |
if ((ret = copy_block(avctx, &out[j*stride+i], |
187 |
|
|
copy_from, offset, 4, stride)) < 0) |
188 |
|
|
return ret; |
189 |
|
|
} |
190 |
|
|
} |
191 |
|
19399 |
break; |
192 |
|
|
|
193 |
|
54 |
case C93_8X8_2COLOR: |
194 |
|
54 |
bytestream2_get_buffer(&gb, cols, 2); |
195 |
✓✓ |
486 |
for (i = 0; i < 8; i++) { |
196 |
|
432 |
draw_n_color(out + i*stride, stride, 8, 1, 1, cols, |
197 |
|
|
NULL, bytestream2_get_byte(&gb)); |
198 |
|
|
} |
199 |
|
|
|
200 |
|
54 |
break; |
201 |
|
|
|
202 |
|
536 |
case C93_4X4_2COLOR: |
203 |
|
|
case C93_4X4_4COLOR: |
204 |
|
|
case C93_4X4_4COLOR_GRP: |
205 |
✓✓ |
1608 |
for (j = 0; j < 8; j += 4) { |
206 |
✓✓ |
3216 |
for (i = 0; i < 8; i += 4) { |
207 |
✓✓ |
2144 |
if (block_type == C93_4X4_2COLOR) { |
208 |
|
108 |
bytestream2_get_buffer(&gb, cols, 2); |
209 |
|
108 |
draw_n_color(out + i + j*stride, stride, 4, 4, |
210 |
|
|
1, cols, NULL, bytestream2_get_le16(&gb)); |
211 |
✓✓ |
2036 |
} else if (block_type == C93_4X4_4COLOR) { |
212 |
|
1916 |
bytestream2_get_buffer(&gb, cols, 4); |
213 |
|
1916 |
draw_n_color(out + i + j*stride, stride, 4, 4, |
214 |
|
|
2, cols, NULL, bytestream2_get_le32(&gb)); |
215 |
|
|
} else { |
216 |
|
120 |
bytestream2_get_buffer(&gb, grps, 4); |
217 |
|
120 |
draw_n_color(out + i + j*stride, stride, 4, 4, |
218 |
|
|
1, cols, grps, bytestream2_get_le16(&gb)); |
219 |
|
|
} |
220 |
|
|
} |
221 |
|
|
} |
222 |
|
536 |
break; |
223 |
|
|
|
224 |
|
|
case C93_NOOP: |
225 |
|
|
break; |
226 |
|
|
|
227 |
|
2602 |
case C93_8X8_INTRA: |
228 |
✓✓ |
23418 |
for (j = 0; j < 8; j++) |
229 |
|
20816 |
bytestream2_get_buffer(&gb, out + j*stride, 8); |
230 |
|
2602 |
break; |
231 |
|
|
|
232 |
|
|
default: |
233 |
|
|
av_log(avctx, AV_LOG_ERROR, "unexpected type %x at %dx%d\n", |
234 |
|
|
block_type, x, y); |
235 |
|
|
return AVERROR_INVALIDDATA; |
236 |
|
|
} |
237 |
|
43200 |
bt >>= 4; |
238 |
|
43200 |
out += 8; |
239 |
|
|
} |
240 |
|
|
} |
241 |
|
|
|
242 |
✓✓ |
45 |
if (b & C93_HAS_PALETTE) { |
243 |
|
1 |
uint32_t *palette = (uint32_t *) newpic->data[1]; |
244 |
✓✓ |
257 |
for (i = 0; i < 256; i++) { |
245 |
|
256 |
palette[i] = 0xFFU << 24 | bytestream2_get_be24(&gb); |
246 |
|
|
} |
247 |
|
1 |
newpic->palette_has_changed = 1; |
248 |
|
|
} else { |
249 |
✓✗ |
44 |
if (oldpic->data[1]) |
250 |
|
44 |
memcpy(newpic->data[1], oldpic->data[1], 256 * 4); |
251 |
|
|
} |
252 |
|
|
|
253 |
✗✓ |
45 |
if ((ret = av_frame_ref(data, newpic)) < 0) |
254 |
|
|
return ret; |
255 |
|
45 |
*got_frame = 1; |
256 |
|
|
|
257 |
|
45 |
return buf_size; |
258 |
|
|
} |
259 |
|
|
|
260 |
|
|
AVCodec ff_c93_decoder = { |
261 |
|
|
.name = "c93", |
262 |
|
|
.long_name = NULL_IF_CONFIG_SMALL("Interplay C93"), |
263 |
|
|
.type = AVMEDIA_TYPE_VIDEO, |
264 |
|
|
.id = AV_CODEC_ID_C93, |
265 |
|
|
.priv_data_size = sizeof(C93DecoderContext), |
266 |
|
|
.init = decode_init, |
267 |
|
|
.close = decode_end, |
268 |
|
|
.decode = decode_frame, |
269 |
|
|
.capabilities = AV_CODEC_CAP_DR1, |
270 |
|
|
.caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP, |
271 |
|
|
}; |