Mercurial > libavcodec.hg
annotate jpeglsdec.c @ 7279:00858715211e libavcodec
Remove dead code in bitstream.h
author | mru |
---|---|
date | Tue, 15 Jul 2008 18:43:26 +0000 |
parents | e943e1409077 |
children | d6bab465b82c |
rev | line source |
---|---|
5003 | 1 /* |
2 * JPEG-LS decoder | |
3 * Copyright (c) 2003 Michael Niedermayer | |
4 * Copyright (c) 2006 Konstantin Shishkov | |
5 * | |
6 * This file is part of FFmpeg. | |
7 * | |
8 * FFmpeg is free software; you can redistribute it and/or | |
9 * modify it under the terms of the GNU Lesser General Public | |
10 * License as published by the Free Software Foundation; either | |
11 * version 2.1 of the License, or (at your option) any later version. | |
12 * | |
13 * FFmpeg is distributed in the hope that it will be useful, | |
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
16 * Lesser General Public License for more details. | |
17 * | |
18 * You should have received a copy of the GNU Lesser General Public | |
19 * License along with FFmpeg; if not, write to the Free Software | |
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
21 */ | |
22 | |
23 /** | |
24 * @file jpeglsdec.c | |
25 * JPEG-LS decoder. | |
26 */ | |
27 | |
28 #include "avcodec.h" | |
29 #include "bitstream.h" | |
30 #include "golomb.h" | |
31 #include "mjpeg.h" | |
5041 | 32 #include "mjpegdec.h" |
5003 | 33 #include "jpegls.h" |
34 #include "jpeglsdec.h" | |
35 | |
36 | |
37 /* | |
38 * Uncomment this to significantly speed up decoding of broken JPEG-LS | |
39 * (or test broken JPEG-LS decoder) and slow down ordinary decoding a bit. | |
40 * | |
41 * There is no Golomb code with length >= 32 bits possible, so check and | |
42 * avoid situation of 32 zeros, FFmpeg Golomb decoder is painfully slow | |
43 * on this errors. | |
44 */ | |
45 //#define JLS_BROKEN | |
46 | |
47 | |
48 /** | |
49 * Decode LSE block with initialization parameters | |
50 */ | |
51 int ff_jpegls_decode_lse(MJpegDecodeContext *s) | |
52 { | |
53 int len, id; | |
54 | |
55 /* XXX: verify len field validity */ | |
56 len = get_bits(&s->gb, 16); | |
57 id = get_bits(&s->gb, 8); | |
58 | |
59 switch(id){ | |
60 case 1: | |
61 s->maxval= get_bits(&s->gb, 16); | |
62 s->t1= get_bits(&s->gb, 16); | |
63 s->t2= get_bits(&s->gb, 16); | |
64 s->t3= get_bits(&s->gb, 16); | |
65 s->reset= get_bits(&s->gb, 16); | |
66 | |
67 // ff_jpegls_reset_coding_parameters(s, 0); | |
68 //FIXME quant table? | |
69 break; | |
70 case 2: | |
71 case 3: | |
72 av_log(s->avctx, AV_LOG_ERROR, "palette not supported\n"); | |
73 return -1; | |
74 case 4: | |
75 av_log(s->avctx, AV_LOG_ERROR, "oversize image not supported\n"); | |
76 return -1; | |
77 default: | |
78 av_log(s->avctx, AV_LOG_ERROR, "invalid id %d\n", id); | |
79 return -1; | |
80 } | |
81 // av_log(s->avctx, AV_LOG_DEBUG, "ID=%i, T=%i,%i,%i\n", id, s->t1, s->t2, s->t3); | |
82 | |
83 return 0; | |
84 } | |
85 | |
86 /** | |
87 * Get context-dependent Golomb code, decode it and update context | |
88 */ | |
89 static inline int ls_get_code_regular(GetBitContext *gb, JLSState *state, int Q){ | |
90 int k, ret; | |
91 | |
92 for(k = 0; (state->N[Q] << k) < state->A[Q]; k++); | |
93 | |
94 #ifdef JLS_BROKEN | |
95 if(!show_bits_long(gb, 32))return -1; | |
96 #endif | |
97 ret = get_ur_golomb_jpegls(gb, k, state->limit, state->qbpp); | |
98 | |
99 /* decode mapped error */ | |
100 if(ret & 1) | |
101 ret = -((ret + 1) >> 1); | |
102 else | |
103 ret >>= 1; | |
104 | |
105 /* for NEAR=0, k=0 and 2*B[Q] <= - N[Q] mapping is reversed */ | |
106 if(!state->near && !k && (2 * state->B[Q] <= -state->N[Q])) | |
107 ret = -(ret + 1); | |
108 | |
109 ret= ff_jpegls_update_state_regular(state, Q, ret); | |
110 | |
111 return ret; | |
112 } | |
113 | |
114 /** | |
115 * Get Golomb code, decode it and update state for run termination | |
116 */ | |
117 static inline int ls_get_code_runterm(GetBitContext *gb, JLSState *state, int RItype, int limit_add){ | |
118 int k, ret, temp, map; | |
119 int Q = 365 + RItype; | |
120 | |
121 temp= state->A[Q]; | |
122 if(RItype) | |
123 temp += state->N[Q] >> 1; | |
124 | |
125 for(k = 0; (state->N[Q] << k) < temp; k++); | |
126 | |
127 #ifdef JLS_BROKEN | |
128 if(!show_bits_long(gb, 32))return -1; | |
129 #endif | |
130 ret = get_ur_golomb_jpegls(gb, k, state->limit - limit_add - 1, state->qbpp); | |
131 | |
132 /* decode mapped error */ | |
133 map = 0; | |
134 if(!k && (RItype || ret) && (2 * state->B[Q] < state->N[Q])) | |
135 map = 1; | |
136 ret += RItype + map; | |
137 | |
138 if(ret & 1){ | |
139 ret = map - ((ret + 1) >> 1); | |
140 state->B[Q]++; | |
141 } else { | |
142 ret = ret >> 1; | |
143 } | |
144 | |
145 /* update state */ | |
146 state->A[Q] += FFABS(ret) - RItype; | |
147 ret *= state->twonear; | |
148 ff_jpegls_downscale_state(state, Q); | |
149 | |
150 return ret; | |
151 } | |
152 | |
153 /** | |
154 * Decode one line of image | |
155 */ | |
156 static inline void ls_decode_line(JLSState *state, MJpegDecodeContext *s, void *last, void *dst, int last2, int w, int stride, int comp, int bits){ | |
157 int i, x = 0; | |
158 int Ra, Rb, Rc, Rd; | |
159 int D0, D1, D2; | |
160 | |
161 while(x < w) { | |
162 int err, pred; | |
163 | |
164 /* compute gradients */ | |
165 Ra = x ? R(dst, x - stride) : R(last, x); | |
166 Rb = R(last, x); | |
167 Rc = x ? R(last, x - stride) : last2; | |
168 Rd = (x >= w - stride) ? R(last, x) : R(last, x + stride); | |
169 D0 = Rd - Rb; | |
170 D1 = Rb - Rc; | |
171 D2 = Rc - Ra; | |
172 /* run mode */ | |
173 if((FFABS(D0) <= state->near) && (FFABS(D1) <= state->near) && (FFABS(D2) <= state->near)) { | |
174 int r; | |
175 int RItype; | |
176 | |
177 /* decode full runs while available */ | |
178 while(get_bits1(&s->gb)) { | |
179 int r; | |
180 r = 1 << ff_log2_run[state->run_index[comp]]; | |
181 if(x + r * stride > w) { | |
182 r = (w - x) / stride; | |
183 } | |
184 for(i = 0; i < r; i++) { | |
185 W(dst, x, Ra); | |
186 x += stride; | |
187 } | |
188 /* if EOL reached, we stop decoding */ | |
189 if(r != (1 << ff_log2_run[state->run_index[comp]])) | |
190 return; | |
191 if(state->run_index[comp] < 31) | |
192 state->run_index[comp]++; | |
193 if(x + stride > w) | |
194 return; | |
195 } | |
196 /* decode aborted run */ | |
197 r = ff_log2_run[state->run_index[comp]]; | |
198 if(r) | |
199 r = get_bits_long(&s->gb, r); | |
200 for(i = 0; i < r; i++) { | |
201 W(dst, x, Ra); | |
202 x += stride; | |
203 } | |
204 | |
205 /* decode run termination value */ | |
206 Rb = R(last, x); | |
207 RItype = (FFABS(Ra - Rb) <= state->near) ? 1 : 0; | |
208 err = ls_get_code_runterm(&s->gb, state, RItype, ff_log2_run[state->run_index[comp]]); | |
209 if(state->run_index[comp]) | |
210 state->run_index[comp]--; | |
211 | |
212 if(state->near && RItype){ | |
213 pred = Ra + err; | |
214 } else { | |
215 if(Rb < Ra) | |
216 pred = Rb - err; | |
217 else | |
218 pred = Rb + err; | |
219 } | |
220 } else { /* regular mode */ | |
221 int context, sign; | |
222 | |
223 context = ff_jpegls_quantize(state, D0) * 81 + ff_jpegls_quantize(state, D1) * 9 + ff_jpegls_quantize(state, D2); | |
224 pred = mid_pred(Ra, Ra + Rb - Rc, Rb); | |
225 | |
226 if(context < 0){ | |
227 context = -context; | |
228 sign = 1; | |
229 }else{ | |
230 sign = 0; | |
231 } | |
232 | |
233 if(sign){ | |
234 pred = av_clip(pred - state->C[context], 0, state->maxval); | |
235 err = -ls_get_code_regular(&s->gb, state, context); | |
236 } else { | |
237 pred = av_clip(pred + state->C[context], 0, state->maxval); | |
238 err = ls_get_code_regular(&s->gb, state, context); | |
239 } | |
240 | |
241 /* we have to do something more for near-lossless coding */ | |
242 pred += err; | |
243 } | |
244 if(state->near){ | |
245 if(pred < -state->near) | |
246 pred += state->range * state->twonear; | |
247 else if(pred > state->maxval + state->near) | |
248 pred -= state->range * state->twonear; | |
249 pred = av_clip(pred, 0, state->maxval); | |
250 } | |
251 | |
252 pred &= state->maxval; | |
253 W(dst, x, pred); | |
254 x += stride; | |
255 } | |
256 } | |
257 | |
258 int ff_jpegls_decode_picture(MJpegDecodeContext *s, int near, int point_transform, int ilv){ | |
259 int i, t = 0; | |
260 uint8_t *zero, *last, *cur; | |
261 JLSState *state; | |
262 int off = 0, stride = 1, width, shift; | |
263 | |
264 zero = av_mallocz(s->picture.linesize[0]); | |
265 last = zero; | |
266 cur = s->picture.data[0]; | |
267 | |
268 state = av_mallocz(sizeof(JLSState)); | |
269 /* initialize JPEG-LS state from JPEG parameters */ | |
270 state->near = near; | |
271 state->bpp = (s->bits < 2) ? 2 : s->bits; | |
272 state->maxval = s->maxval; | |
273 state->T1 = s->t1; | |
274 state->T2 = s->t2; | |
275 state->T3 = s->t3; | |
276 state->reset = s->reset; | |
277 ff_jpegls_reset_coding_parameters(state, 0); | |
278 ff_jpegls_init_state(state); | |
279 | |
280 if(s->bits <= 8) | |
281 shift = point_transform + (8 - s->bits); | |
282 else | |
283 shift = point_transform + (16 - s->bits); | |
284 | |
285 // av_log(s->avctx, AV_LOG_DEBUG, "JPEG-LS params: %ix%i NEAR=%i MV=%i T(%i,%i,%i) RESET=%i, LIMIT=%i, qbpp=%i, RANGE=%i\n",s->width,s->height,state->near,state->maxval,state->T1,state->T2,state->T3,state->reset,state->limit,state->qbpp, state->range); | |
286 // av_log(s->avctx, AV_LOG_DEBUG, "JPEG params: ILV=%i Pt=%i BPP=%i, scan = %i\n", ilv, point_transform, s->bits, s->cur_scan); | |
287 if(ilv == 0) { /* separate planes */ | |
288 off = s->cur_scan - 1; | |
289 stride = (s->nb_components > 1) ? 3 : 1; | |
290 width = s->width * stride; | |
291 cur += off; | |
292 for(i = 0; i < s->height; i++) { | |
293 if(s->bits <= 8){ | |
294 ls_decode_line(state, s, last, cur, t, width, stride, off, 8); | |
295 t = last[0]; | |
296 }else{ | |
297 ls_decode_line(state, s, last, cur, t, width, stride, off, 16); | |
298 t = *((uint16_t*)last); | |
299 } | |
300 last = cur; | |
301 cur += s->picture.linesize[0]; | |
302 | |
303 if (s->restart_interval && !--s->restart_count) { | |
304 align_get_bits(&s->gb); | |
305 skip_bits(&s->gb, 16); /* skip RSTn */ | |
306 } | |
307 } | |
308 } else if(ilv == 1) { /* line interleaving */ | |
309 int j; | |
310 int Rc[3] = {0, 0, 0}; | |
311 memset(cur, 0, s->picture.linesize[0]); | |
312 width = s->width * 3; | |
313 for(i = 0; i < s->height; i++) { | |
314 for(j = 0; j < 3; j++) { | |
315 ls_decode_line(state, s, last + j, cur + j, Rc[j], width, 3, j, 8); | |
316 Rc[j] = last[j]; | |
317 | |
318 if (s->restart_interval && !--s->restart_count) { | |
319 align_get_bits(&s->gb); | |
320 skip_bits(&s->gb, 16); /* skip RSTn */ | |
321 } | |
322 } | |
323 last = cur; | |
324 cur += s->picture.linesize[0]; | |
325 } | |
326 } else if(ilv == 2) { /* sample interleaving */ | |
327 av_log(s->avctx, AV_LOG_ERROR, "Sample interleaved images are not supported.\n"); | |
328 av_free(state); | |
329 av_free(zero); | |
330 return -1; | |
331 } | |
332 | |
333 if(shift){ /* we need to do point transform or normalize samples */ | |
334 int x, w; | |
335 | |
336 w = s->width * s->nb_components; | |
337 | |
338 if(s->bits <= 8){ | |
339 uint8_t *src = s->picture.data[0]; | |
340 | |
341 for(i = 0; i < s->height; i++){ | |
342 for(x = off; x < w; x+= stride){ | |
343 src[x] <<= shift; | |
344 } | |
345 src += s->picture.linesize[0]; | |
346 } | |
347 }else{ | |
348 uint16_t *src = (uint16_t*) s->picture.data[0]; | |
349 | |
350 for(i = 0; i < s->height; i++){ | |
351 for(x = 0; x < w; x++){ | |
352 src[x] <<= shift; | |
353 } | |
354 src += s->picture.linesize[0]/2; | |
355 } | |
356 } | |
357 } | |
358 av_free(state); | |
359 av_free(zero); | |
360 | |
361 return 0; | |
362 } | |
5041 | 363 |
364 | |
365 AVCodec jpegls_decoder = { | |
366 "jpegls", | |
367 CODEC_TYPE_VIDEO, | |
368 CODEC_ID_JPEGLS, | |
369 sizeof(MJpegDecodeContext), | |
370 ff_mjpeg_decode_init, | |
371 NULL, | |
372 ff_mjpeg_decode_end, | |
373 ff_mjpeg_decode_frame, | |
374 CODEC_CAP_DR1, | |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
6712
diff
changeset
|
375 .long_name = NULL_IF_CONFIG_SMALL("JPEG-LS"), |
5041 | 376 }; |