Mercurial > libavcodec.hg
annotate vb.c @ 9077:ad7fd7a40717 libavcodec
Do not read uninitialized buffer, no matter if it will be multiplied by
zero later. This should fix some valgrind warnings and hopefully FATE
ra144 test on ARM.
author | vitor |
---|---|
date | Sun, 01 Mar 2009 11:14:21 +0000 |
parents | e9d9d946f213 |
children | 54bc8a2727b0 |
rev | line source |
---|---|
5847 | 1 /* |
2 * Beam Software VB decoder | |
3 * Copyright (c) 2007 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 /** | |
8718
e9d9d946f213
Use full internal pathname in doxygen @file directives.
diego
parents:
7040
diff
changeset
|
23 * @file libavcodec/vb.c |
5847 | 24 * VB Video decoder |
25 */ | |
26 | |
27 #include <stdio.h> | |
28 #include <stdlib.h> | |
29 | |
30 #include "avcodec.h" | |
31 #include "bytestream.h" | |
32 | |
33 enum VBFlags{ | |
34 VB_HAS_GMC = 0x01, | |
35 VB_HAS_AUDIO = 0x04, | |
36 VB_HAS_VIDEO = 0x08, | |
37 VB_HAS_PALETTE = 0x10, | |
38 VB_HAS_LENGTH = 0x20 | |
39 }; | |
40 | |
41 typedef struct VBDecContext { | |
42 AVCodecContext *avctx; | |
43 AVFrame pic; | |
44 | |
45 uint8_t *frame, *prev_frame; | |
46 uint32_t pal[256]; | |
6218 | 47 const uint8_t *stream; |
5847 | 48 } VBDecContext; |
49 | |
50 static const uint16_t vb_patterns[64] = { | |
51 0x0660, 0xFF00, 0xCCCC, 0xF000, 0x8888, 0x000F, 0x1111, 0xFEC8, | |
52 0x8CEF, 0x137F, 0xF731, 0xC800, 0x008C, 0x0013, 0x3100, 0xCC00, | |
53 0x00CC, 0x0033, 0x3300, 0x0FF0, 0x6666, 0x00F0, 0x0F00, 0x2222, | |
54 0x4444, 0xF600, 0x8CC8, 0x006F, 0x1331, 0x318C, 0xC813, 0x33CC, | |
55 0x6600, 0x0CC0, 0x0066, 0x0330, 0xF900, 0xC88C, 0x009F, 0x3113, | |
56 0x6000, 0x0880, 0x0006, 0x0110, 0xCC88, 0xFC00, 0x00CF, 0x88CC, | |
57 0x003F, 0x1133, 0x3311, 0xF300, 0x6FF6, 0x0603, 0x08C6, 0x8C63, | |
58 0xC631, 0x6310, 0xC060, 0x0136, 0x136C, 0x36C8, 0x6C80, 0x324C | |
59 }; | |
60 | |
61 static void vb_decode_palette(VBDecContext *c) | |
62 { | |
63 int start, size, i; | |
64 | |
65 start = bytestream_get_byte(&c->stream); | |
66 size = (bytestream_get_byte(&c->stream) - 1) & 0xFF; | |
67 if(start + size > 255){ | |
68 av_log(c->avctx, AV_LOG_ERROR, "Palette change runs beyond entry 256\n"); | |
69 return; | |
70 } | |
71 for(i = start; i <= start + size; i++) | |
72 c->pal[i] = bytestream_get_be24(&c->stream); | |
73 } | |
74 | |
75 static inline int check_pixel(uint8_t *buf, uint8_t *start, uint8_t *end) | |
76 { | |
77 return buf >= start && buf < end; | |
78 } | |
79 | |
80 static inline int check_line(uint8_t *buf, uint8_t *start, uint8_t *end) | |
81 { | |
82 return buf >= start && (buf + 4) <= end; | |
83 } | |
84 | |
6218 | 85 static int vb_decode_framedata(VBDecContext *c, const uint8_t *buf, int offset) |
5847 | 86 { |
87 uint8_t *prev, *cur; | |
88 int blk, blocks, t, blk2; | |
89 int blocktypes = 0; | |
90 int x, y, a, b; | |
91 int pattype, pattern; | |
92 const int width = c->avctx->width; | |
93 uint8_t *pstart = c->prev_frame; | |
94 uint8_t *pend = c->prev_frame + width*c->avctx->height; | |
95 | |
96 prev = c->prev_frame + offset; | |
97 cur = c->frame; | |
98 | |
99 blocks = (c->avctx->width >> 2) * (c->avctx->height >> 2); | |
100 blk2 = 0; | |
101 for(blk = 0; blk < blocks; blk++){ | |
102 if(!(blk & 3)) | |
103 blocktypes = bytestream_get_byte(&buf); | |
104 switch(blocktypes & 0xC0){ | |
105 case 0x00: //skip | |
106 for(y = 0; y < 4; y++) | |
107 if(check_line(prev + y*width, pstart, pend)) | |
108 memcpy(cur + y*width, prev + y*width, 4); | |
109 else | |
110 memset(cur + y*width, 0, 4); | |
111 break; | |
112 case 0x40: | |
113 t = bytestream_get_byte(&buf); | |
114 if(!t){ //raw block | |
115 for(y = 0; y < 4; y++) | |
116 memcpy(cur + y*width, buf + y*4, 4); | |
117 buf += 16; | |
118 }else{ // motion compensation | |
119 x = ((t & 0xF)^8) - 8; | |
120 y = ((t >> 4) ^8) - 8; | |
121 t = x + y*width; | |
122 for(y = 0; y < 4; y++) | |
123 if(check_line(prev + t + y*width, pstart, pend)) | |
124 memcpy(cur + y*width, prev + t + y*width, 4); | |
125 else | |
126 memset(cur + y*width, 0, 4); | |
127 } | |
128 break; | |
129 case 0x80: // fill | |
130 t = bytestream_get_byte(&buf); | |
131 for(y = 0; y < 4; y++) | |
132 memset(cur + y*width, t, 4); | |
133 break; | |
134 case 0xC0: // pattern fill | |
135 t = bytestream_get_byte(&buf); | |
136 pattype = t >> 6; | |
137 pattern = vb_patterns[t & 0x3F]; | |
138 switch(pattype){ | |
139 case 0: | |
140 a = bytestream_get_byte(&buf); | |
141 b = bytestream_get_byte(&buf); | |
142 for(y = 0; y < 4; y++) | |
143 for(x = 0; x < 4; x++, pattern >>= 1) | |
144 cur[x + y*width] = (pattern & 1) ? b : a; | |
145 break; | |
146 case 1: | |
147 pattern = ~pattern; | |
148 case 2: | |
149 a = bytestream_get_byte(&buf); | |
150 for(y = 0; y < 4; y++) | |
151 for(x = 0; x < 4; x++, pattern >>= 1) | |
152 if(pattern & 1 && check_pixel(prev + x + y*width, pstart, pend)) | |
153 cur[x + y*width] = prev[x + y*width]; | |
154 else | |
155 cur[x + y*width] = a; | |
156 break; | |
157 case 3: | |
158 av_log(c->avctx, AV_LOG_ERROR, "Invalid opcode seen @%d\n",blk); | |
159 return -1; | |
160 } | |
161 break; | |
162 } | |
163 blocktypes <<= 2; | |
164 cur += 4; | |
165 prev += 4; | |
166 blk2++; | |
167 if(blk2 == (width >> 2)){ | |
168 blk2 = 0; | |
169 cur += width * 3; | |
170 prev += width * 3; | |
171 } | |
172 } | |
173 return 0; | |
174 } | |
175 | |
6218 | 176 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, const uint8_t *buf, int buf_size) |
5847 | 177 { |
178 VBDecContext * const c = avctx->priv_data; | |
179 uint8_t *outptr, *srcptr; | |
180 int i, j; | |
181 int flags; | |
182 uint32_t size; | |
183 int rest = buf_size; | |
184 int offset = 0; | |
185 | |
186 c->stream = buf; | |
187 flags = bytestream_get_le16(&c->stream); | |
188 rest -= 2; | |
189 | |
190 if(flags & VB_HAS_GMC){ | |
191 i = (int16_t)bytestream_get_le16(&c->stream); | |
192 j = (int16_t)bytestream_get_le16(&c->stream); | |
193 offset = i + j * avctx->width; | |
194 rest -= 4; | |
195 } | |
196 if(flags & VB_HAS_VIDEO){ | |
197 size = bytestream_get_le32(&c->stream); | |
198 if(size > rest){ | |
199 av_log(avctx, AV_LOG_ERROR, "Frame size is too big\n"); | |
200 return -1; | |
201 } | |
202 vb_decode_framedata(c, c->stream, offset); | |
203 c->stream += size - 4; | |
204 rest -= size; | |
205 } | |
206 if(flags & VB_HAS_PALETTE){ | |
207 size = bytestream_get_le32(&c->stream); | |
208 if(size > rest){ | |
209 av_log(avctx, AV_LOG_ERROR, "Palette size is too big\n"); | |
210 return -1; | |
211 } | |
212 vb_decode_palette(c); | |
213 rest -= size; | |
214 } | |
215 | |
216 memcpy(c->pic.data[1], c->pal, AVPALETTE_SIZE); | |
217 c->pic.palette_has_changed = flags & VB_HAS_PALETTE; | |
218 | |
219 outptr = c->pic.data[0]; | |
220 srcptr = c->frame; | |
221 | |
222 for(i = 0; i < avctx->height; i++){ | |
223 memcpy(outptr, srcptr, avctx->width); | |
224 srcptr += avctx->width; | |
225 outptr += c->pic.linesize[0]; | |
226 } | |
227 | |
228 FFSWAP(uint8_t*, c->frame, c->prev_frame); | |
229 | |
230 *data_size = sizeof(AVFrame); | |
231 *(AVFrame*)data = c->pic; | |
232 | |
233 /* always report that the buffer was completely consumed */ | |
234 return buf_size; | |
235 } | |
236 | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6218
diff
changeset
|
237 static av_cold int decode_init(AVCodecContext *avctx) |
5847 | 238 { |
239 VBDecContext * const c = avctx->priv_data; | |
240 | |
241 c->avctx = avctx; | |
242 avctx->pix_fmt = PIX_FMT_PAL8; | |
243 | |
244 if (avcodec_check_dimensions(avctx, avctx->width, avctx->height) < 0) { | |
245 return -1; | |
246 } | |
247 | |
248 c->pic.reference = 1; | |
249 if(avctx->get_buffer(avctx, &c->pic) < 0){ | |
250 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); | |
251 return -1; | |
252 } | |
253 | |
254 c->frame = av_malloc( avctx->width * avctx->height); | |
255 c->prev_frame = av_malloc( avctx->width * avctx->height); | |
256 | |
257 return 0; | |
258 } | |
259 | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6218
diff
changeset
|
260 static av_cold int decode_end(AVCodecContext *avctx) |
5847 | 261 { |
262 VBDecContext *c = avctx->priv_data; | |
263 | |
264 av_freep(&c->frame); | |
265 av_freep(&c->prev_frame); | |
266 if(c->pic.data[0]) | |
267 avctx->release_buffer(avctx, &c->pic); | |
268 | |
269 return 0; | |
270 } | |
271 | |
272 AVCodec vb_decoder = { | |
273 "vb", | |
274 CODEC_TYPE_VIDEO, | |
275 CODEC_ID_VB, | |
276 sizeof(VBDecContext), | |
277 decode_init, | |
278 NULL, | |
279 decode_end, | |
6710 | 280 decode_frame, |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
6710
diff
changeset
|
281 .long_name = NULL_IF_CONFIG_SMALL("Beam Software VB"), |
5847 | 282 }; |
283 |