Mercurial > libavcodec.hg

comparison jpeg_ls.c @ 3063:f02d0b59279c libavcodec

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Remove all stray tabs and trailing whitespace, this time for good.
author diego
date Tue, 24 Jan 2006 10:33:14 +0000
parents 0b546eab515d
children 1e63c12c2c71
comparison
equal deleted inserted replaced
3062:8d05d4036b6a 3063:f02d0b59279c
70 const int basic_t2= 7; 70 const int basic_t2= 7;
71 const int basic_t3= 21; 71 const int basic_t3= 21;
72 int factor; 72 int factor;
73 73
74 if(s->maxval==0 || reset_all) s->maxval= (1<<s->bits) - 1; 74 if(s->maxval==0 || reset_all) s->maxval= (1<<s->bits) - 1;
75 75
76 if(s->maxval >=128){ 76 if(s->maxval >=128){
77 factor= (FFMIN(s->maxval, 4096) + 128)>>8; 77 factor= (FFMIN(s->maxval, 4096) + 128)>>8;
78 78
79 if(s->t1==0 || reset_all) 79 if(s->t1==0 || reset_all)
80 s->t1= iso_clip(factor*(basic_t1-2) + 2 + 3*s->near, s->near+1, s->maxval); 80 s->t1= iso_clip(factor*(basic_t1-2) + 2 + 3*s->near, s->near+1, s->maxval);
101 int len, id; 101 int len, id;
102 102
103 /* XXX: verify len field validity */ 103 /* XXX: verify len field validity */
104 len = get_bits(&s->gb, 16); 104 len = get_bits(&s->gb, 16);
105 id = get_bits(&s->gb, 8); 105 id = get_bits(&s->gb, 8);
106 106
107 switch(id){ 107 switch(id){
108 case 1: 108 case 1:
109 s->maxval= get_bits(&s->gb, 16); 109 s->maxval= get_bits(&s->gb, 16);
110 s->t1= get_bits(&s->gb, 16); 110 s->t1= get_bits(&s->gb, 16);
111 s->t2= get_bits(&s->gb, 16); 111 s->t2= get_bits(&s->gb, 16);
112 s->t3= get_bits(&s->gb, 16); 112 s->t3= get_bits(&s->gb, 16);
113 s->reset= get_bits(&s->gb, 16); 113 s->reset= get_bits(&s->gb, 16);
114 114
115 reset_ls_coding_parameters(s, 0); 115 reset_ls_coding_parameters(s, 0);
116 //FIXME quant table? 116 //FIXME quant table?
117 break; 117 break;
118 case 2: 118 case 2:
119 case 3: 119 case 3:
143 } 143 }
144 count++; 144 count++;
145 145
146 if(drift <= -count){ 146 if(drift <= -count){
147 if(state->bias > -128) state->bias--; 147 if(state->bias > -128) state->bias--;
148 148
149 drift += count; 149 drift += count;
150 if(drift <= -count) 150 if(drift <= -count)
151 drift= -count + 1; 151 drift= -count + 1;
152 }else if(drift > 0){ 152 }else if(drift > 0){
153 if(state->bias < 127) state->bias++; 153 if(state->bias < 127) state->bias++;
154 154
155 drift -= count; 155 drift -= count;
156 if(drift > 0) 156 if(drift > 0)
157 drift= 0; 157 drift= 0;
158 } 158 }
159 159
160 state->drift= drift; 160 state->drift= drift;
161 state->count= count; 161 state->count= count;
167 int w, int point_transform, int is_uint8){ 167 int w, int point_transform, int is_uint8){
168 int i, x, y; 168 int i, x, y;
169 169
170 for(x=0; x < w; x++){ 170 for(x=0; x < w; x++){
171 int l, t, lt, rt; 171 int l, t, lt, rt;
172 172
173 t= R(last, 0); 173 t= R(last, 0);
174 if(x){ 174 if(x){
175 l = t; 175 l = t;
176 lt= last2; 176 lt= last2;
177 }else{ 177 }else{
179 lt= R(last, x-1); 179 lt= R(last, x-1);
180 } 180 }
181 181
182 if(x<w-1) rt= R(last, x+1); 182 if(x<w-1) rt= R(last, x+1);
183 else rt= t; 183 else rt= t;
184 184
185 hr_gradient= rt - t; 185 hr_gradient= rt - t;
186 hl_gradient= t - lt; 186 hl_gradient= t - lt;
187 v_gradient= lt - l; 187 v_gradient= lt - l;
188 188
189 context= quantize(s, v_gradient) + 9*(quantize(s, hl_gradient) + 9*quantize(s, hr_gradient)); 189 context= quantize(s, v_gradient) + 9*(quantize(s, hl_gradient) + 9*quantize(s, hr_gradient));
190 190
191 if(context){ 191 if(context){
192 int pred= mid_pred(l, l + t - lt, t); 192 int pred= mid_pred(l, l + t - lt, t);
193 193
204 k=0; 204 k=0;
205 while(i < state->error_sum){ //FIXME optimize 205 while(i < state->error_sum){ //FIXME optimize
206 k++; 206 k++;
207 i += i; 207 i += i;
208 } 208 }
209 209
210 v= get_ur_golomb_jpegls(gb, k, LIMIT-qbpp, qbpp); 210 v= get_ur_golomb_jpegls(gb, k, LIMIT-qbpp, qbpp);
211 #if 1 211 #if 1
212 v++; 212 v++;
213 if(v&1) v= (v>>1); 213 if(v&1) v= (v>>1);
214 else v= -(v>>1); 214 else v= -(v>>1);
220 if(v&1) v= (v>>1); 220 if(v&1) v= (v>>1);
221 else v= -(v>>1); 221 else v= -(v>>1);
222 222
223 #endif 223 #endif
224 update_vlc_state(state, v, half_count); 224 update_vlc_state(state, v, half_count);
225 225
226 if(sign) v= -v; 226 if(sign) v= -v;
227 227
228 if(is_uint8) ((uint8_t *)dst)[x]= (pred + v) & maxval; 228 if(is_uint8) ((uint8_t *)dst)[x]= (pred + v) & maxval;
229 else ((uint16_t*)dst)[x]= (pred + v) & maxval; 229 else ((uint16_t*)dst)[x]= (pred + v) & maxval;
230 }else{ 230 }else{
231 int run_count; 231 int run_count;
232 232
233 while(get_bits1(&s->gb)){ 233 while(get_bits1(&s->gb)){
234 run_count = 1<<log2_run[run_index]; 234 run_count = 1<<log2_run[run_index];
235 if(x + run_count > w) run_count= w - x; 235 if(x + run_count > w) run_count= w - x;
236 else run_index++; 236 else run_index++;
237 237
238 for(; run_count; run_count--){ 238 for(; run_count; run_count--){
239 if(is_uint8) ((uint8_t *)dst)[x++]= l; 239 if(is_uint8) ((uint8_t *)dst)[x++]= l;
240 else ((uint16_t*)dst)[x++]= l; 240 else ((uint16_t*)dst)[x++]= l;
241 } 241 }
242 242
243 if(x >= w) return 0; 243 if(x >= w) return 0;
244 } 244 }
245 245
246 run_count= get_bits(&s->gb, log2_run[run_index]); 246 run_count= get_bits(&s->gb, log2_run[run_index]);
247 247
248 for(; run_count; run_count--){ 248 for(; run_count; run_count--){
249 if(is_uint8) ((uint8_t *)dst)[x++]= l; 249 if(is_uint8) ((uint8_t *)dst)[x++]= l;
250 else ((uint16_t*)dst)[x++]= l; 250 else ((uint16_t*)dst)[x++]= l;
251 } 251 }
252 252
253 if(run_index) run_index--; 253 if(run_index) run_index--;
254 254
255 if(x >= w) return 0; 255 if(x >= w) return 0;
256 256
257 t= R(last, 0); 257 t= R(last, 0);
258 258
259 RItype= (l==t); 259 RItype= (l==t);
260 if(l==t){ 260 if(l==t){
261 state= 366; 261 state= 366;
262 temp= state->error_sum + (state->count>>1); 262 temp= state->error_sum + (state->count>>1);
263 }else{ 263 }else{
264 state= 365; 264 state= 365;
265 temp= state->error_sum; 265 temp= state->error_sum;
266 } 266 }
267 267
268 pred= t; 268 pred= t;
269 sign= l > t; 269 sign= l > t;
270 270
271 i= state->count; 271 i= state->count;
272 k=0; 272 k=0;
273 while(i < temp){ //FIXME optimize 273 while(i < temp){ //FIXME optimize
274 k++; 274 k++;
275 i += i; 275 i += i;
276 } 276 }
277 277
278 assert(Errval != 0); 278 assert(Errval != 0);
279 map = (k==0 && 2*Nn < state->count) == (Errval>0); 279 map = (k==0 && 2*Nn < state->count) == (Errval>0);
280 280
281 281
282 if(run_count==0 && run_mode==1){ 282 if(run_count==0 && run_mode==1){
283 if(get_bits1(&s->gb)){ 283 if(get_bits1(&s->gb)){
284 run_count = 1<<log2_run[run_index]; 284 run_count = 1<<log2_run[run_index];
285 if(x + run_count <= w) run_index++; 285 if(x + run_count <= w) run_index++;
286 }else{ 286 }else{
296 run_count=0; 296 run_count=0;
297 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context]); 297 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context]);
298 if(diff>=0) diff++; 298 if(diff>=0) diff++;
299 }else 299 }else
300 diff=0; 300 diff=0;
301 301
302 } 302 }
303 } 303 }
304 304
305 /* if (s->restart_interval && !s->restart_count) 305 /* if (s->restart_interval && !s->restart_count)
306 s->restart_count = s->restart_interval;*/ 306 s->restart_count = s->restart_interval;*/
314 h = s->h_scount[i]; 314 h = s->h_scount[i];
315 v = s->v_scount[i]; 315 v = s->v_scount[i];
316 x = 0; 316 x = 0;
317 y = 0; 317 y = 0;
318 linesize= s->linesize[c]; 318 linesize= s->linesize[c];
319 319
320 for(j=0; j<n; j++) { 320 for(j=0; j<n; j++) {
321 int pred; 321 int pred;
322 322
323 ptr = s->current_picture[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap 323 ptr = s->current_picture[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
324 if(y==0 && mb_y==0){ 324 if(y==0 && mb_y==0){
332 pred= ptr[-linesize]; 332 pred= ptr[-linesize];
333 }else{ 333 }else{
334 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor); 334 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
335 } 335 }
336 } 336 }
337 337
338 if (s->interlaced && s->bottom_field) 338 if (s->interlaced && s->bottom_field)
339 ptr += linesize >> 1; 339 ptr += linesize >> 1;
340 *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform); 340 *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
341 341
342 if (++x == h) { 342 if (++x == h) {
354 h = s->h_scount[i]; 354 h = s->h_scount[i];
355 v = s->v_scount[i]; 355 v = s->v_scount[i];
356 x = 0; 356 x = 0;
357 y = 0; 357 y = 0;
358 linesize= s->linesize[c]; 358 linesize= s->linesize[c];
359 359
360 for(j=0; j<n; j++) { 360 for(j=0; j<n; j++) {
361 int pred; 361 int pred;
362 362
363 ptr = s->current_picture[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap 363 ptr = s->current_picture[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
364 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor); 364 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);