Mercurial > libavcodec.hg
annotate smc.c @ 6317:2f44646383c8 libavcodec
100l, since we already check for buf_size == 769 we should also
handle buf_size < 769 instead of just crashing in smacker decoder.
author | reimar |
---|---|
date | Sat, 02 Feb 2008 22:34:44 +0000 |
parents | 8f8017bdf4c8 |
children | 814c8bd77d91 |
rev | line source |
---|---|
1610 | 1 /* |
2 * Quicktime Graphics (SMC) Video Decoder | |
3 * Copyright (C) 2003 the ffmpeg project | |
4 * | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3036
diff
changeset
|
5 * This file is part of FFmpeg. |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3036
diff
changeset
|
6 * |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3036
diff
changeset
|
7 * FFmpeg is free software; you can redistribute it and/or |
1610 | 8 * modify it under the terms of the GNU Lesser General Public |
9 * License as published by the Free Software Foundation; either | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3036
diff
changeset
|
10 * version 2.1 of the License, or (at your option) any later version. |
1610 | 11 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3036
diff
changeset
|
12 * FFmpeg is distributed in the hope that it will be useful, |
1610 | 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 | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3036
diff
changeset
|
18 * License along with FFmpeg; if not, write to the Free Software |
3036
0b546eab515d
Update licensing information: The FSF changed postal address.
diego
parents:
2979
diff
changeset
|
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
1610 | 20 */ |
21 | |
22 /** | |
23 * @file smc.c | |
24 * QT SMC Video Decoder by Mike Melanson (melanson@pcisys.net) | |
25 * For more information about the SMC format, visit: | |
26 * http://www.pcisys.net/~melanson/codecs/ | |
27 * | |
28 * The SMC decoder outputs PAL8 colorspace data. | |
29 */ | |
30 | |
31 #include <stdio.h> | |
32 #include <stdlib.h> | |
33 #include <string.h> | |
34 #include <unistd.h> | |
35 | |
36 #include "avcodec.h" | |
37 #include "dsputil.h" | |
38 | |
39 #define CPAIR 2 | |
40 #define CQUAD 4 | |
41 #define COCTET 8 | |
42 | |
43 #define COLORS_PER_TABLE 256 | |
44 | |
45 typedef struct SmcContext { | |
46 | |
47 AVCodecContext *avctx; | |
48 DSPContext dsp; | |
49 AVFrame frame; | |
50 | |
6252 | 51 const unsigned char *buf; |
1610 | 52 int size; |
53 | |
54 /* SMC color tables */ | |
55 unsigned char color_pairs[COLORS_PER_TABLE * CPAIR]; | |
56 unsigned char color_quads[COLORS_PER_TABLE * CQUAD]; | |
57 unsigned char color_octets[COLORS_PER_TABLE * COCTET]; | |
58 | |
59 } SmcContext; | |
60 | |
61 #define GET_BLOCK_COUNT() \ | |
62 (opcode & 0x10) ? (1 + s->buf[stream_ptr++]) : 1 + (opcode & 0x0F); | |
63 | |
64 #define ADVANCE_BLOCK() \ | |
65 { \ | |
66 pixel_ptr += 4; \ | |
67 if (pixel_ptr >= width) \ | |
68 { \ | |
69 pixel_ptr = 0; \ | |
70 row_ptr += stride * 4; \ | |
71 } \ | |
72 total_blocks--; \ | |
73 if (total_blocks < 0) \ | |
74 { \ | |
1927 | 75 av_log(s->avctx, AV_LOG_INFO, "warning: block counter just went negative (this should not happen)\n"); \ |
1610 | 76 return; \ |
77 } \ | |
78 } | |
79 | |
80 static void smc_decode_stream(SmcContext *s) | |
81 { | |
82 int width = s->avctx->width; | |
83 int height = s->avctx->height; | |
84 int stride = s->frame.linesize[0]; | |
85 int i; | |
86 int stream_ptr = 0; | |
87 int chunk_size; | |
88 unsigned char opcode; | |
89 int n_blocks; | |
90 unsigned int color_flags; | |
91 unsigned int color_flags_a; | |
92 unsigned int color_flags_b; | |
93 unsigned int flag_mask; | |
94 | |
95 unsigned char *pixels = s->frame.data[0]; | |
96 | |
97 int image_size = height * s->frame.linesize[0]; | |
98 int row_ptr = 0; | |
99 int pixel_ptr = 0; | |
100 int pixel_x, pixel_y; | |
101 int row_inc = stride - 4; | |
102 int block_ptr; | |
103 int prev_block_ptr; | |
104 int prev_block_ptr1, prev_block_ptr2; | |
105 int prev_block_flag; | |
106 int total_blocks; | |
107 int color_table_index; /* indexes to color pair, quad, or octet tables */ | |
108 int pixel; | |
109 | |
110 int color_pair_index = 0; | |
111 int color_quad_index = 0; | |
112 int color_octet_index = 0; | |
113 | |
114 /* make the palette available */ | |
115 memcpy(s->frame.data[1], s->avctx->palctrl->palette, AVPALETTE_SIZE); | |
116 if (s->avctx->palctrl->palette_changed) { | |
117 s->frame.palette_has_changed = 1; | |
118 s->avctx->palctrl->palette_changed = 0; | |
119 } | |
120 | |
4364 | 121 chunk_size = AV_RB32(&s->buf[stream_ptr]) & 0x00FFFFFF; |
1610 | 122 stream_ptr += 4; |
123 if (chunk_size != s->size) | |
1927 | 124 av_log(s->avctx, AV_LOG_INFO, "warning: MOV chunk size != encoded chunk size (%d != %d); using MOV chunk size\n", |
1610 | 125 chunk_size, s->size); |
126 | |
127 chunk_size = s->size; | |
2103 | 128 total_blocks = ((s->avctx->width + 3) / 4) * ((s->avctx->height + 3) / 4); |
1610 | 129 |
130 /* traverse through the blocks */ | |
131 while (total_blocks) { | |
132 /* sanity checks */ | |
133 /* make sure stream ptr hasn't gone out of bounds */ | |
134 if (stream_ptr > chunk_size) { | |
1927 | 135 av_log(s->avctx, AV_LOG_INFO, "SMC decoder just went out of bounds (stream ptr = %d, chunk size = %d)\n", |
1610 | 136 stream_ptr, chunk_size); |
137 return; | |
138 } | |
139 /* make sure the row pointer hasn't gone wild */ | |
140 if (row_ptr >= image_size) { | |
1927 | 141 av_log(s->avctx, AV_LOG_INFO, "SMC decoder just went out of bounds (row ptr = %d, height = %d)\n", |
1610 | 142 row_ptr, image_size); |
143 return; | |
144 } | |
145 | |
146 opcode = s->buf[stream_ptr++]; | |
147 switch (opcode & 0xF0) { | |
148 /* skip n blocks */ | |
149 case 0x00: | |
150 case 0x10: | |
151 n_blocks = GET_BLOCK_COUNT(); | |
152 while (n_blocks--) { | |
153 ADVANCE_BLOCK(); | |
154 } | |
155 break; | |
156 | |
157 /* repeat last block n times */ | |
158 case 0x20: | |
159 case 0x30: | |
160 n_blocks = GET_BLOCK_COUNT(); | |
161 | |
162 /* sanity check */ | |
163 if ((row_ptr == 0) && (pixel_ptr == 0)) { | |
1927 | 164 av_log(s->avctx, AV_LOG_INFO, "encountered repeat block opcode (%02X) but no blocks rendered yet\n", |
1610 | 165 opcode & 0xF0); |
166 break; | |
167 } | |
168 | |
169 /* figure out where the previous block started */ | |
170 if (pixel_ptr == 0) | |
2967 | 171 prev_block_ptr1 = |
1610 | 172 (row_ptr - s->avctx->width * 4) + s->avctx->width - 4; |
173 else | |
174 prev_block_ptr1 = row_ptr + pixel_ptr - 4; | |
175 | |
176 while (n_blocks--) { | |
177 block_ptr = row_ptr + pixel_ptr; | |
178 prev_block_ptr = prev_block_ptr1; | |
179 for (pixel_y = 0; pixel_y < 4; pixel_y++) { | |
180 for (pixel_x = 0; pixel_x < 4; pixel_x++) { | |
181 pixels[block_ptr++] = pixels[prev_block_ptr++]; | |
182 } | |
183 block_ptr += row_inc; | |
184 prev_block_ptr += row_inc; | |
185 } | |
186 ADVANCE_BLOCK(); | |
187 } | |
188 break; | |
189 | |
190 /* repeat previous pair of blocks n times */ | |
191 case 0x40: | |
192 case 0x50: | |
193 n_blocks = GET_BLOCK_COUNT(); | |
194 n_blocks *= 2; | |
195 | |
196 /* sanity check */ | |
197 if ((row_ptr == 0) && (pixel_ptr < 2 * 4)) { | |
2979 | 198 av_log(s->avctx, AV_LOG_INFO, "encountered repeat block opcode (%02X) but not enough blocks rendered yet\n", |
1610 | 199 opcode & 0xF0); |
200 break; | |
201 } | |
202 | |
203 /* figure out where the previous 2 blocks started */ | |
204 if (pixel_ptr == 0) | |
2967 | 205 prev_block_ptr1 = (row_ptr - s->avctx->width * 4) + |
1610 | 206 s->avctx->width - 4 * 2; |
207 else if (pixel_ptr == 4) | |
208 prev_block_ptr1 = (row_ptr - s->avctx->width * 4) + row_inc; | |
209 else | |
210 prev_block_ptr1 = row_ptr + pixel_ptr - 4 * 2; | |
211 | |
212 if (pixel_ptr == 0) | |
213 prev_block_ptr2 = (row_ptr - s->avctx->width * 4) + row_inc; | |
214 else | |
215 prev_block_ptr2 = row_ptr + pixel_ptr - 4; | |
216 | |
217 prev_block_flag = 0; | |
218 while (n_blocks--) { | |
219 block_ptr = row_ptr + pixel_ptr; | |
220 if (prev_block_flag) | |
221 prev_block_ptr = prev_block_ptr2; | |
222 else | |
223 prev_block_ptr = prev_block_ptr1; | |
224 prev_block_flag = !prev_block_flag; | |
225 | |
226 for (pixel_y = 0; pixel_y < 4; pixel_y++) { | |
227 for (pixel_x = 0; pixel_x < 4; pixel_x++) { | |
228 pixels[block_ptr++] = pixels[prev_block_ptr++]; | |
229 } | |
230 block_ptr += row_inc; | |
231 prev_block_ptr += row_inc; | |
232 } | |
233 ADVANCE_BLOCK(); | |
234 } | |
235 break; | |
236 | |
237 /* 1-color block encoding */ | |
238 case 0x60: | |
239 case 0x70: | |
240 n_blocks = GET_BLOCK_COUNT(); | |
241 pixel = s->buf[stream_ptr++]; | |
242 | |
243 while (n_blocks--) { | |
244 block_ptr = row_ptr + pixel_ptr; | |
245 for (pixel_y = 0; pixel_y < 4; pixel_y++) { | |
246 for (pixel_x = 0; pixel_x < 4; pixel_x++) { | |
247 pixels[block_ptr++] = pixel; | |
248 } | |
249 block_ptr += row_inc; | |
250 } | |
251 ADVANCE_BLOCK(); | |
252 } | |
253 break; | |
254 | |
255 /* 2-color block encoding */ | |
256 case 0x80: | |
257 case 0x90: | |
258 n_blocks = (opcode & 0x0F) + 1; | |
259 | |
260 /* figure out which color pair to use to paint the 2-color block */ | |
261 if ((opcode & 0xF0) == 0x80) { | |
262 /* fetch the next 2 colors from bytestream and store in next | |
263 * available entry in the color pair table */ | |
264 for (i = 0; i < CPAIR; i++) { | |
265 pixel = s->buf[stream_ptr++]; | |
266 color_table_index = CPAIR * color_pair_index + i; | |
267 s->color_pairs[color_table_index] = pixel; | |
268 } | |
269 /* this is the base index to use for this block */ | |
270 color_table_index = CPAIR * color_pair_index; | |
271 color_pair_index++; | |
272 /* wraparound */ | |
273 if (color_pair_index == COLORS_PER_TABLE) | |
274 color_pair_index = 0; | |
275 } else | |
276 color_table_index = CPAIR * s->buf[stream_ptr++]; | |
277 | |
278 while (n_blocks--) { | |
4364 | 279 color_flags = AV_RB16(&s->buf[stream_ptr]); |
1610 | 280 stream_ptr += 2; |
281 flag_mask = 0x8000; | |
282 block_ptr = row_ptr + pixel_ptr; | |
283 for (pixel_y = 0; pixel_y < 4; pixel_y++) { | |
284 for (pixel_x = 0; pixel_x < 4; pixel_x++) { | |
285 if (color_flags & flag_mask) | |
286 pixel = color_table_index + 1; | |
287 else | |
288 pixel = color_table_index; | |
289 flag_mask >>= 1; | |
290 pixels[block_ptr++] = s->color_pairs[pixel]; | |
291 } | |
292 block_ptr += row_inc; | |
293 } | |
294 ADVANCE_BLOCK(); | |
295 } | |
296 break; | |
297 | |
298 /* 4-color block encoding */ | |
299 case 0xA0: | |
300 case 0xB0: | |
301 n_blocks = (opcode & 0x0F) + 1; | |
302 | |
303 /* figure out which color quad to use to paint the 4-color block */ | |
304 if ((opcode & 0xF0) == 0xA0) { | |
305 /* fetch the next 4 colors from bytestream and store in next | |
306 * available entry in the color quad table */ | |
307 for (i = 0; i < CQUAD; i++) { | |
308 pixel = s->buf[stream_ptr++]; | |
309 color_table_index = CQUAD * color_quad_index + i; | |
310 s->color_quads[color_table_index] = pixel; | |
311 } | |
312 /* this is the base index to use for this block */ | |
313 color_table_index = CQUAD * color_quad_index; | |
314 color_quad_index++; | |
315 /* wraparound */ | |
316 if (color_quad_index == COLORS_PER_TABLE) | |
317 color_quad_index = 0; | |
318 } else | |
319 color_table_index = CQUAD * s->buf[stream_ptr++]; | |
320 | |
321 while (n_blocks--) { | |
4364 | 322 color_flags = AV_RB32(&s->buf[stream_ptr]); |
1610 | 323 stream_ptr += 4; |
324 /* flag mask actually acts as a bit shift count here */ | |
325 flag_mask = 30; | |
326 block_ptr = row_ptr + pixel_ptr; | |
327 for (pixel_y = 0; pixel_y < 4; pixel_y++) { | |
328 for (pixel_x = 0; pixel_x < 4; pixel_x++) { | |
2967 | 329 pixel = color_table_index + |
1610 | 330 ((color_flags >> flag_mask) & 0x03); |
331 flag_mask -= 2; | |
332 pixels[block_ptr++] = s->color_quads[pixel]; | |
333 } | |
334 block_ptr += row_inc; | |
335 } | |
336 ADVANCE_BLOCK(); | |
337 } | |
338 break; | |
339 | |
340 /* 8-color block encoding */ | |
341 case 0xC0: | |
342 case 0xD0: | |
343 n_blocks = (opcode & 0x0F) + 1; | |
344 | |
345 /* figure out which color octet to use to paint the 8-color block */ | |
346 if ((opcode & 0xF0) == 0xC0) { | |
347 /* fetch the next 8 colors from bytestream and store in next | |
348 * available entry in the color octet table */ | |
349 for (i = 0; i < COCTET; i++) { | |
350 pixel = s->buf[stream_ptr++]; | |
351 color_table_index = COCTET * color_octet_index + i; | |
352 s->color_octets[color_table_index] = pixel; | |
353 } | |
354 /* this is the base index to use for this block */ | |
355 color_table_index = COCTET * color_octet_index; | |
356 color_octet_index++; | |
357 /* wraparound */ | |
358 if (color_octet_index == COLORS_PER_TABLE) | |
359 color_octet_index = 0; | |
360 } else | |
361 color_table_index = COCTET * s->buf[stream_ptr++]; | |
362 | |
363 while (n_blocks--) { | |
364 /* | |
365 For this input of 6 hex bytes: | |
366 01 23 45 67 89 AB | |
367 Mangle it to this output: | |
368 flags_a = xx012456, flags_b = xx89A37B | |
369 */ | |
370 /* build the color flags */ | |
371 color_flags_a = color_flags_b = 0; | |
372 color_flags_a = | |
373 (s->buf[stream_ptr + 0] << 16) | | |
374 ((s->buf[stream_ptr + 1] & 0xF0) << 8) | | |
375 ((s->buf[stream_ptr + 2] & 0xF0) << 4) | | |
376 ((s->buf[stream_ptr + 2] & 0x0F) << 4) | | |
377 ((s->buf[stream_ptr + 3] & 0xF0) >> 4); | |
378 color_flags_b = | |
379 (s->buf[stream_ptr + 4] << 16) | | |
380 ((s->buf[stream_ptr + 5] & 0xF0) << 8) | | |
381 ((s->buf[stream_ptr + 1] & 0x0F) << 8) | | |
382 ((s->buf[stream_ptr + 3] & 0x0F) << 4) | | |
383 (s->buf[stream_ptr + 5] & 0x0F); | |
384 stream_ptr += 6; | |
385 | |
386 color_flags = color_flags_a; | |
387 /* flag mask actually acts as a bit shift count here */ | |
388 flag_mask = 21; | |
389 block_ptr = row_ptr + pixel_ptr; | |
390 for (pixel_y = 0; pixel_y < 4; pixel_y++) { | |
391 /* reload flags at third row (iteration pixel_y == 2) */ | |
392 if (pixel_y == 2) { | |
393 color_flags = color_flags_b; | |
394 flag_mask = 21; | |
395 } | |
396 for (pixel_x = 0; pixel_x < 4; pixel_x++) { | |
2967 | 397 pixel = color_table_index + |
1610 | 398 ((color_flags >> flag_mask) & 0x07); |
399 flag_mask -= 3; | |
400 pixels[block_ptr++] = s->color_octets[pixel]; | |
401 } | |
402 block_ptr += row_inc; | |
403 } | |
404 ADVANCE_BLOCK(); | |
405 } | |
406 break; | |
407 | |
408 /* 16-color block encoding (every pixel is a different color) */ | |
409 case 0xE0: | |
410 n_blocks = (opcode & 0x0F) + 1; | |
411 | |
412 while (n_blocks--) { | |
413 block_ptr = row_ptr + pixel_ptr; | |
414 for (pixel_y = 0; pixel_y < 4; pixel_y++) { | |
415 for (pixel_x = 0; pixel_x < 4; pixel_x++) { | |
416 pixels[block_ptr++] = s->buf[stream_ptr++]; | |
417 } | |
418 block_ptr += row_inc; | |
419 } | |
420 ADVANCE_BLOCK(); | |
421 } | |
422 break; | |
423 | |
424 case 0xF0: | |
1927 | 425 av_log(s->avctx, AV_LOG_INFO, "0xF0 opcode seen in SMC chunk (contact the developers)\n"); |
1610 | 426 break; |
427 } | |
428 } | |
429 } | |
430 | |
431 static int smc_decode_init(AVCodecContext *avctx) | |
432 { | |
4827 | 433 SmcContext *s = avctx->priv_data; |
1610 | 434 |
435 s->avctx = avctx; | |
436 avctx->pix_fmt = PIX_FMT_PAL8; | |
437 dsputil_init(&s->dsp, avctx); | |
438 | |
1630 | 439 s->frame.data[0] = NULL; |
1610 | 440 |
441 return 0; | |
442 } | |
443 | |
444 static int smc_decode_frame(AVCodecContext *avctx, | |
445 void *data, int *data_size, | |
6252 | 446 const uint8_t *buf, int buf_size) |
1610 | 447 { |
4827 | 448 SmcContext *s = avctx->priv_data; |
1610 | 449 |
450 s->buf = buf; | |
451 s->size = buf_size; | |
452 | |
453 s->frame.reference = 1; | |
2967 | 454 s->frame.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_PRESERVE | |
1769 | 455 FF_BUFFER_HINTS_REUSABLE | FF_BUFFER_HINTS_READABLE; |
1630 | 456 if (avctx->reget_buffer(avctx, &s->frame)) { |
1927 | 457 av_log(s->avctx, AV_LOG_ERROR, "reget_buffer() failed\n"); |
1610 | 458 return -1; |
459 } | |
460 | |
461 smc_decode_stream(s); | |
462 | |
463 *data_size = sizeof(AVFrame); | |
464 *(AVFrame*)data = s->frame; | |
465 | |
466 /* always report that the buffer was completely consumed */ | |
467 return buf_size; | |
468 } | |
469 | |
470 static int smc_decode_end(AVCodecContext *avctx) | |
471 { | |
4827 | 472 SmcContext *s = avctx->priv_data; |
1610 | 473 |
1630 | 474 if (s->frame.data[0]) |
475 avctx->release_buffer(avctx, &s->frame); | |
1610 | 476 |
477 return 0; | |
478 } | |
479 | |
480 AVCodec smc_decoder = { | |
481 "smc", | |
482 CODEC_TYPE_VIDEO, | |
483 CODEC_ID_SMC, | |
484 sizeof(SmcContext), | |
485 smc_decode_init, | |
486 NULL, | |
487 smc_decode_end, | |
488 smc_decode_frame, | |
489 CODEC_CAP_DR1, | |
490 }; |