Mercurial > libavcodec.hg
annotate vb.c @ 9830:bd0879f752e6 libavcodec
Express the H.264 parser dependency on the golomb code in configure instead of
in the Makefile as it is done for all other parts that depend on golomb.
author | diego |
---|---|
date | Tue, 09 Jun 2009 20:29:52 +0000 |
parents | 0813b30e7db9 |
children | d7ed9dcc78e3 |
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 | |
9355
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
8718
diff
changeset
|
176 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt) |
5847 | 177 { |
9355
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
8718
diff
changeset
|
178 const uint8_t *buf = avpkt->data; |
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
8718
diff
changeset
|
179 int buf_size = avpkt->size; |
5847 | 180 VBDecContext * const c = avctx->priv_data; |
181 uint8_t *outptr, *srcptr; | |
182 int i, j; | |
183 int flags; | |
184 uint32_t size; | |
185 int rest = buf_size; | |
186 int offset = 0; | |
187 | |
9821
0813b30e7db9
Get new buffer during frame decoding in VB video decoder, not only once
kostya
parents:
9355
diff
changeset
|
188 if(c->pic.data[0]) |
0813b30e7db9
Get new buffer during frame decoding in VB video decoder, not only once
kostya
parents:
9355
diff
changeset
|
189 avctx->release_buffer(avctx, &c->pic); |
0813b30e7db9
Get new buffer during frame decoding in VB video decoder, not only once
kostya
parents:
9355
diff
changeset
|
190 c->pic.reference = 1; |
0813b30e7db9
Get new buffer during frame decoding in VB video decoder, not only once
kostya
parents:
9355
diff
changeset
|
191 if(avctx->get_buffer(avctx, &c->pic) < 0){ |
0813b30e7db9
Get new buffer during frame decoding in VB video decoder, not only once
kostya
parents:
9355
diff
changeset
|
192 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); |
0813b30e7db9
Get new buffer during frame decoding in VB video decoder, not only once
kostya
parents:
9355
diff
changeset
|
193 return -1; |
0813b30e7db9
Get new buffer during frame decoding in VB video decoder, not only once
kostya
parents:
9355
diff
changeset
|
194 } |
0813b30e7db9
Get new buffer during frame decoding in VB video decoder, not only once
kostya
parents:
9355
diff
changeset
|
195 |
5847 | 196 c->stream = buf; |
197 flags = bytestream_get_le16(&c->stream); | |
198 rest -= 2; | |
199 | |
200 if(flags & VB_HAS_GMC){ | |
201 i = (int16_t)bytestream_get_le16(&c->stream); | |
202 j = (int16_t)bytestream_get_le16(&c->stream); | |
203 offset = i + j * avctx->width; | |
204 rest -= 4; | |
205 } | |
206 if(flags & VB_HAS_VIDEO){ | |
207 size = bytestream_get_le32(&c->stream); | |
208 if(size > rest){ | |
209 av_log(avctx, AV_LOG_ERROR, "Frame size is too big\n"); | |
210 return -1; | |
211 } | |
212 vb_decode_framedata(c, c->stream, offset); | |
213 c->stream += size - 4; | |
214 rest -= size; | |
215 } | |
216 if(flags & VB_HAS_PALETTE){ | |
217 size = bytestream_get_le32(&c->stream); | |
218 if(size > rest){ | |
219 av_log(avctx, AV_LOG_ERROR, "Palette size is too big\n"); | |
220 return -1; | |
221 } | |
222 vb_decode_palette(c); | |
223 rest -= size; | |
224 } | |
225 | |
226 memcpy(c->pic.data[1], c->pal, AVPALETTE_SIZE); | |
227 c->pic.palette_has_changed = flags & VB_HAS_PALETTE; | |
228 | |
229 outptr = c->pic.data[0]; | |
230 srcptr = c->frame; | |
231 | |
232 for(i = 0; i < avctx->height; i++){ | |
233 memcpy(outptr, srcptr, avctx->width); | |
234 srcptr += avctx->width; | |
235 outptr += c->pic.linesize[0]; | |
236 } | |
237 | |
238 FFSWAP(uint8_t*, c->frame, c->prev_frame); | |
239 | |
240 *data_size = sizeof(AVFrame); | |
241 *(AVFrame*)data = c->pic; | |
242 | |
243 /* always report that the buffer was completely consumed */ | |
244 return buf_size; | |
245 } | |
246 | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6218
diff
changeset
|
247 static av_cold int decode_init(AVCodecContext *avctx) |
5847 | 248 { |
249 VBDecContext * const c = avctx->priv_data; | |
250 | |
251 c->avctx = avctx; | |
252 avctx->pix_fmt = PIX_FMT_PAL8; | |
253 | |
254 if (avcodec_check_dimensions(avctx, avctx->width, avctx->height) < 0) { | |
255 return -1; | |
256 } | |
257 | |
258 c->frame = av_malloc( avctx->width * avctx->height); | |
259 c->prev_frame = av_malloc( avctx->width * avctx->height); | |
260 | |
261 return 0; | |
262 } | |
263 | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6218
diff
changeset
|
264 static av_cold int decode_end(AVCodecContext *avctx) |
5847 | 265 { |
266 VBDecContext *c = avctx->priv_data; | |
267 | |
268 av_freep(&c->frame); | |
269 av_freep(&c->prev_frame); | |
270 if(c->pic.data[0]) | |
271 avctx->release_buffer(avctx, &c->pic); | |
272 | |
273 return 0; | |
274 } | |
275 | |
276 AVCodec vb_decoder = { | |
277 "vb", | |
278 CODEC_TYPE_VIDEO, | |
279 CODEC_ID_VB, | |
280 sizeof(VBDecContext), | |
281 decode_init, | |
282 NULL, | |
283 decode_end, | |
6710 | 284 decode_frame, |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
6710
diff
changeset
|
285 .long_name = NULL_IF_CONFIG_SMALL("Beam Software VB"), |
5847 | 286 }; |
287 |