1
2 /*
3 * xa_jpg.c
4 *
5 * Copyright (C) 1994-1998,1999 by Mark Podlipec.
6 * All rights reserved.
7 *
8 * This software may be freely used, copied and redistributed without
9 * fee for non-commerical purposes provided that this copyright
10 * notice is preserved intact on all copies.
11 *
12 * There is no warranty or other guarantee of fitness of this software.
13 * It is provided solely "as is". The author disclaims all
14 * responsibility and liability with respect to this software's usage
15 * or its effect upon hardware or computer systems.
16 *
17 */
18
19 /* Revision History
20 *
21 * 22Aug95 - +F dithering to MPEG.
22 * 18Nov98 - Added support for QT MJPA format
23 * 21Mar99 - Added default DQT tables for JPEGs that don't have them.
24 */
25
26 #include "xa_jpg.h"
27
28 #include "xa_color.h"
29 YUVBufs jpg_YUVBufs;
30 extern YUVTabs def_yuv_tabs;
31
32 extern xaLONG xa_dither_flag;
33
34 /* JPEG Specific Variables */
35 xaUBYTE *jpg_buff = 0;
36 xaLONG jpg_bsize = 0;
37
38 xaLONG jpg_h_bnum; /* this must be signed */
39 xaULONG jpg_h_bbuf;
40
41 xaUBYTE *jpg_samp_limit = 0;
42 xaUBYTE *xa_byte_limit = 0;
43
44 xaULONG jpg_init_flag = xaFALSE;
45 xaLONG *jpg_quant_tables[JJ_NUM_QUANT_TBLS];
46 xaULONG jpg_marker = 0;
47 xaULONG jpg_saw_SOI,jpg_saw_SOF,jpg_saw_SOS;
48 xaULONG jpg_saw_DHT,jpg_saw_DQT,jpg_saw_EOI;
49 xaULONG jpg_std_DHT_flag = 0;
50 xaLONG jpg_dprec,jpg_height,jpg_width;
51 xaLONG jpg_num_comps,jpg_comps_in_scan;
52 xaLONG jpg_nxt_rst_num;
53 xaLONG jpg_rst_interval;
54
55 xaULONG xa_mjpg_kludge;
56
57 static void JPG_Double_MCU();
58
59
60 JJ_HUFF_TBL jpg_ac_huff[JJ_NUM_HUFF_TBLS];
61 JJ_HUFF_TBL jpg_dc_huff[JJ_NUM_HUFF_TBLS];
62
63 #define JPG_MAX_COMPS 4
64 #define JPG_DUMMY_COMP (JPG_MAX_COMPS + 1)
65 COMPONENT_HDR jpg_comps[JPG_MAX_COMPS + 1];
66
67
68 #define JJ_INPUT_SKIP(len) \
69 { int _tlen = (len > jpg_bsize)?(jpg_bsize):(len); \
70 jpg_buff += _tlen; jpg_bsize -= _tlen; }
71 #define JJ_INPUT_CHECK(val) ((jpg_bsize >= (val))?(xaTRUE):(xaFALSE))
72 #define JJ_INPUT_xaBYTE(var) { var = *jpg_buff++; jpg_bsize--; }
73 #define JJ_INPUT_xaSHORT(var) \
74 { var = (*jpg_buff++) << 8; var |= (*jpg_buff++); jpg_bsize -= 2; }
75 #define JJ_INPUT_xaLONG(var) \
76 { var = (*jpg_buff++) << 24; var |= (*jpg_buff++) << 16; \
77 var |= (*jpg_buff++) << 8; var |= (*jpg_buff++); jpg_bsize -= 4; }
78
79 xaLONG JJ_ZAG[DCTSIZE2+16] = {
80 0, 1, 8, 16, 9, 2, 3, 10,
81 17, 24, 32, 25, 18, 11, 4, 5,
82 12, 19, 26, 33, 40, 48, 41, 34,
83 27, 20, 13, 6, 7, 14, 21, 28,
84 35, 42, 49, 56, 57, 50, 43, 36,
85 29, 22, 15, 23, 30, 37, 44, 51,
86 58, 59, 52, 45, 38, 31, 39, 46,
87 53, 60, 61, 54, 47, 55, 62, 63,
88 0, 0, 0, 0, 0, 0, 0, 0, /* extra entries in case k>63 below */
89 0, 0, 0, 0, 0, 0, 0, 0
90 };
91
92 xaULONG jpg_MCUbuf_size = 0;
93 xaUBYTE *jpg_Ybuf = 0;
94 xaUBYTE *jpg_Ubuf = 0;
95 xaUBYTE *jpg_Vbuf = 0;
96 xaSHORT jpg_dct_buf[DCTSIZE2];
97
98
99 /* FUNCTIONS */
100 xaULONG JFIF_Decode_JPEG();
101 xaULONG jpg_read_markers();
102 xaULONG jpg_decode_111111();
103 xaULONG jpg_decode_211111();
104 xaULONG jpg_decode_221111();
105 xaULONG jpg_decode_411111();
106 void jpg_huff_build();
107 xaULONG jpg_huffparse();
108 extern void j_rev_dct();
109 extern void j_rev_dct_sparse();
110 void JPG_Setup_Samp_Limit_Table();
111 void JPG_Free_Samp_Limit_Table();
112 xaULONG jpg_read_EOI_marker();
113 xaULONG jpg_std_DHT();
114 xaULONG jpg_std_DQT();
115 void JPG_Alloc_MCU_Bufs();
116 void JPG_Free_MCU_Bufs();
117 xaULONG jpg_search_marker();
118 xaULONG jpg_read_SOF();
119 xaULONG jpg_skip_marker();
120 xaULONG jpg_get_marker();
121 xaULONG jpg_read_appX();
122 void jpg_init_input();
123 void jpg_huff_reset();
124 void JFIF_Read_IJPG_Tables();
125 void JFIF_Init_IJPG_Tables();
126 char IJPG_Tab1[64];
127 char IJPG_Tab2[64];
128 xaULONG jpg_check_for_marker();
129 xaULONG jpg_skip_to_nxt_rst();
130
131 /* external */
132 extern void XA_Gen_YUV_Tabs();
133 extern void XA_MCU111111_To_Gray();
134 extern void *XA_MCU111111_Func();
135 extern void *XA_MCU211111_Func();
136 extern void *XA_MCU221111_Func();
137 extern void *XA_MCU411111_Func();
138 extern void XA_Add_Func_To_Free_Chain();
139
140 /******* JFIF extern stuff and variables ***************/
141 xaULONG JFIF_Read_File();
142 XA_ACTION *ACT_Get_Action();
143 XA_CHDR *ACT_Get_CMAP();
144 XA_CHDR *CMAP_Create_332();
145 XA_CHDR *CMAP_Create_Gray();
146 XA_CHDR *CMAP_Create_CHDR_From_True();
147 xaUBYTE *UTIL_RGB_To_Map();
148 xaUBYTE *UTIL_RGB_To_FS_Map();
149 xaULONG UTIL_Get_LSB_Short();
150 void ACT_Setup_Mapped();
151 void ACT_Add_CHDR_To_Action();
152 xaULONG CMAP_Find_Closest();
153 extern XA_ANIM_SETUP *XA_Get_Anim_Setup();
154 extern void XA_Free_Anim_Setup();
155 extern void ACT_Setup_Delta();
156
157
158 typedef struct
159 {
160 int valid;
161 int field_sz;
162 int pad_field_sz;
163 int next_off;
164 int quant_off;
165 int huff_off;
166 int image_off;
167 int scan_off;
168 int data_off;
169 } QT_JPEG_INFO;
170 static QT_JPEG_INFO qt_jpeg_info;
171
172 typedef struct
173 {
174 int valid;
175 int ileave;
176 } AVI_JPEG_INFO;
177 static AVI_JPEG_INFO avi_jpeg_info;
178
179 /*******
180 *
181 */
jpg_init_stuff()182 void jpg_init_stuff()
183 { xaLONG i;
184 DEBUG_LEVEL1 fprintf(stderr,"JJINIT\n");
185 if (jpg_init_flag==xaTRUE) return;
186 for(i=0; i < JJ_NUM_QUANT_TBLS; i++) jpg_quant_tables[i] = 0;
187 if (jpg_samp_limit==0) JPG_Setup_Samp_Limit_Table(0);
188 jpg_init_flag = xaTRUE;
189 jpg_std_DHT_flag = 0;
190 qt_jpeg_info.valid = xaFALSE;
191 avi_jpeg_info.valid = xaFALSE;
192 }
193
194
195 /*******
196 *
197 */
jpg_free_stuff()198 void jpg_free_stuff()
199 { xaLONG i;
200 DEBUG_LEVEL1 fprintf(stderr,"JJFREE\n");
201 if (jpg_init_flag == xaFALSE) return;
202 for(i=0; i < JJ_NUM_QUANT_TBLS; i++)
203 if (jpg_quant_tables[i]) { free(jpg_quant_tables[i]); jpg_quant_tables[i]=0; }
204 if (jpg_samp_limit) { free(jpg_samp_limit); jpg_samp_limit = 0; }
205 jpg_init_flag = xaFALSE;
206 jpg_std_DHT_flag = 0;
207 }
208
209 #define JFIF_APP0_LEN 14
210
211 /*****
212 *
213 */
JFIF_Read_File(fname,anim_hdr)214 xaULONG JFIF_Read_File(fname,anim_hdr)
215 char *fname;
216 XA_ANIM_HDR *anim_hdr;
217 { XA_INPUT *xin = anim_hdr->xin;
218 ACT_DLTA_HDR *dlta_hdr = 0;
219 XA_ACTION *act = 0;
220 xaULONG jfif_flen;
221 xaUBYTE *inbuff = 0;
222 XA_ANIM_SETUP *jfif;
223
224 jfif = XA_Get_Anim_Setup();
225 jfif->cmap_frame_num = 1; /* always 1 image per file */
226 jfif->vid_time = XA_GET_TIME( 200 );
227
228 /* find file size */
229 xin->Seek_FPos(xin,0L,2);
230 jfif_flen = xin->Get_FPos(xin); /* POD may not be portable */
231 xin->Seek_FPos(xin,0L,0);
232
233 if (xa_file_flag==xaTRUE)
234 { xaLONG ret;
235 dlta_hdr = (ACT_DLTA_HDR *) malloc(sizeof(ACT_DLTA_HDR));
236 if (dlta_hdr == 0) TheEnd1("JFIF: malloc failed");
237 dlta_hdr->flags = 0;
238 dlta_hdr->fpos = xin->Get_FPos(xin);
239 dlta_hdr->fsize = jfif_flen;
240 jfif->max_fvid_size = jfif_flen + 16;
241 inbuff = (xaUBYTE *)malloc(jfif_flen);
242 ret = xin->Read_Block(xin,inbuff,jfif_flen);
243 if (ret < jfif_flen)
244 {fprintf(stderr,"JFIF: inbuff read failed\n"); return(xaFALSE);}
245 }
246 else
247 { xaLONG ret,d;
248 d = jfif_flen + (sizeof(ACT_DLTA_HDR));
249 dlta_hdr = (ACT_DLTA_HDR *) malloc( d );
250 if (dlta_hdr == 0) TheEnd1("JFIF: malloc failed");
251 dlta_hdr->flags = DLTA_DATA;
252 dlta_hdr->fpos = 0; dlta_hdr->fsize = jfif_flen;
253 ret = xin->Read_Block(xin, dlta_hdr->data, jfif_flen);
254 if (ret < jfif_flen)
255 {fprintf(stderr,"JFIF: read failed\n"); return(xaFALSE);}
256 inbuff = dlta_hdr->data;
257 }
258
259 /******** EXTRACT IMAGE SIZE ****************/
260 jpg_init_input(inbuff,jfif_flen);
261 jpg_saw_SOF = xaFALSE;
262 while(jpg_get_marker() == xaTRUE)
263 {
264 if ( (jpg_marker == M_SOF0) /* baseline */
265 || (jpg_marker == M_SOF1) ) /* extended sequential */
266 {
267 if (jpg_read_SOF()==xaTRUE) jpg_saw_SOF = xaTRUE;
268 break;
269 }
270 else if (jpg_marker == M_SOF2)
271 {
272 fprintf(stderr,"JPEG: progessive images not yet supported\n");
273 return(xaFALSE);
274 }
275 else if ((jpg_marker == M_SOI) || (jpg_marker == M_TEM)) continue;
276 else if ((jpg_marker >= M_RST0) && (jpg_marker <= M_RST7)) continue;
277 else jpg_skip_marker();
278 }
279 if (jpg_saw_SOF == xaFALSE)
280 {
281 fprintf(stderr,"JPEG: not recognized as a JPEG file\n");
282 return(xaFALSE);
283 }
284 jfif->imagex = 4 * ((jpg_width + 3)/4);
285 jfif->imagey = 2 * ((jpg_height + 1)/2);
286 JPG_Alloc_MCU_Bufs(anim_hdr,jfif->imagex,0,xaFALSE);
287 XA_Gen_YUV_Tabs(anim_hdr);
288
289 if (xa_verbose)
290 {
291 fprintf(stderr,"JFIF: size %d by %d\n",jfif->imagex,jfif->imagey);
292 }
293
294 /* Allocate Colors */
295 if (jpg_num_comps == 1) /* assume grayscale */
296 { int i;
297 jfif->imagec = 256; jfif->depth = 8;
298 for(i=0;i<jfif->imagec;i++)
299 { jfif->cmap[i].red = jfif->cmap[i].green = jfif->cmap[i].blue = i; }
300 jfif->chdr = ACT_Get_CMAP(jfif->cmap,jfif->imagec,0,jfif->imagec,0,8,8,8);
301 }
302 else if (jpg_num_comps == 3)
303 {
304 jfif->depth = 24;
305 if ( (cmap_true_map_flag == xaFALSE) /* depth 24 and not true_map */
306 || (xa_buffer_flag == xaFALSE) )
307 {
308 if (cmap_true_to_332 == xaTRUE)
309 jfif->chdr = CMAP_Create_332(jfif->cmap,&jfif->imagec);
310 else jfif->chdr = CMAP_Create_Gray(jfif->cmap,&jfif->imagec);
311 }
312 }
313 else
314 {
315 fprintf(stderr,"JFIF: unsupported number of components %d\n",jpg_num_comps);
316 return(xaFALSE);
317 }
318
319 act = ACT_Get_Action(anim_hdr,ACT_DELTA);
320 act->data = (xaUBYTE *)dlta_hdr;
321
322 dlta_hdr->xpos = dlta_hdr->ypos = 0;
323 dlta_hdr->xsize = jfif->imagex;
324 dlta_hdr->ysize = jfif->imagey;
325 dlta_hdr->special = 0;
326 dlta_hdr->extra = (void *)(0);
327 dlta_hdr->xapi_rev = 0x0002;
328 dlta_hdr->delta = JFIF_Decode_JPEG;
329
330 jfif->pic = 0;
331 ACT_Setup_Delta(jfif,act,dlta_hdr,xin);
332
333 xin->Close_File(xin);
334 /* free up buffer in necessary */
335 if (xa_file_flag==xaTRUE) {free(inbuff); inbuff = 0; }
336
337 anim_hdr->imagex = jfif->imagex;
338 anim_hdr->imagey = jfif->imagey;
339 anim_hdr->imagec = jfif->imagec;
340 anim_hdr->imaged = 8; /* nop */
341 anim_hdr->frame_lst = (XA_FRAME *) malloc( sizeof(XA_FRAME) * 2);
342 anim_hdr->frame_lst[0].time_dur = jfif->vid_time;
343 anim_hdr->frame_lst[0].zztime = 0;
344 anim_hdr->frame_lst[0].act = act;
345 anim_hdr->frame_lst[1].time_dur = 0;
346 anim_hdr->frame_lst[1].zztime = -1;
347 anim_hdr->frame_lst[1].act = 0;
348 anim_hdr->loop_frame = 0;
349 anim_hdr->last_frame = 0;
350 anim_hdr->total_time = anim_hdr->frame_lst[0].time_dur;
351 if (xa_buffer_flag == xaFALSE) anim_hdr->anim_flags |= ANIM_SNG_BUF;
352 if (xa_file_flag == xaTRUE) anim_hdr->anim_flags |= ANIM_USE_FILE;
353 anim_hdr->anim_flags |= ANIM_FULL_IM;
354 anim_hdr->max_fvid_size = jfif->max_fvid_size;
355 anim_hdr->max_faud_size = 0;
356 anim_hdr->fname = anim_hdr->name;
357 XA_Free_Anim_Setup(jfif);
358 return(xaTRUE);
359 }
360
361 /********* END OF JFIF Code *************************************************/
362
363
364
365 /*******
366 *
367 */
jpg_read_SOI()368 xaULONG jpg_read_SOI()
369 {
370 DEBUG_LEVEL1 fprintf(stderr,"SOI: \n");
371 jpg_rst_interval = 0;
372 return(xaTRUE);
373 }
374
375
376 /*******
377 *
378 */
jpg_read_SOF()379 xaULONG jpg_read_SOF()
380 {
381 xaLONG len,ci;
382 COMPONENT_HDR *comp;
383
384 JJ_INPUT_xaSHORT(len);
385 if (xa_mjpg_kludge) len -= 6;
386 else len -= 8;
387
388 JJ_INPUT_xaBYTE(jpg_dprec);
389 JJ_INPUT_xaSHORT(jpg_height);
390 JJ_INPUT_xaSHORT(jpg_width);
391 JJ_INPUT_xaBYTE(jpg_num_comps);
392
393 DEBUG_LEVEL1 fprintf(stderr,"SOF: dprec %x res %d x %d comps %x\n",jpg_dprec,jpg_width,jpg_height,jpg_num_comps);
394
395 for(ci = 0; ci < jpg_num_comps; ci++)
396 { xaULONG c;
397 if (ci > JPG_MAX_COMPS) comp = &jpg_comps[JPG_DUMMY_COMP];
398 else comp = &jpg_comps[ci];
399 JJ_INPUT_xaBYTE(comp->id);
400 JJ_INPUT_xaBYTE(c);
401 comp->hvsample = c;
402 JJ_INPUT_xaBYTE(comp->qtbl_num);
403 DEBUG_LEVEL1 fprintf(stderr," id %x hvsamp %x qtbl %x\n",comp->id,c,comp->qtbl_num);
404 }
405 return(JJ_INPUT_CHECK(0));
406 }
407
408 /*******
409 *
410 */
jpg_read_SOS()411 xaULONG jpg_read_SOS()
412 { xaLONG len,i;
413 xaLONG jpg_Ss, jpg_Se, jpg_AhAl;
414
415 JJ_INPUT_xaSHORT(len);
416 /* if (xa_mjpg_kludge) len += 2; length ignored */
417
418 JJ_INPUT_xaBYTE(jpg_comps_in_scan);
419
420 DEBUG_LEVEL1 fprintf(stderr,"SOS: comps %d\n",jpg_comps_in_scan);
421
422 for (i = 0; i < jpg_comps_in_scan; i++)
423 { xaLONG j,comp_id,htbl_num;
424 COMPONENT_HDR *comp = 0;
425
426 JJ_INPUT_xaBYTE(comp_id);
427 j = 0;
428 while(j < jpg_num_comps)
429 { comp = &jpg_comps[j];
430 if (comp->id == comp_id) break;
431 j++;
432 }
433 if (j > jpg_num_comps)
434 { fprintf(stderr,"JJ: bad id %x",comp_id); return(xaFALSE); }
435
436 JJ_INPUT_xaBYTE(htbl_num);
437 comp->dc_htbl_num = (htbl_num >> 4) & 0x0f;
438 comp->ac_htbl_num = (htbl_num ) & 0x0f;
439 DEBUG_LEVEL1 fprintf(stderr," id %x dc/ac %x\n",comp_id,htbl_num);
440 }
441 JJ_INPUT_xaBYTE(jpg_Ss);
442 JJ_INPUT_xaBYTE(jpg_Se);
443 JJ_INPUT_xaBYTE(jpg_AhAl);
444 return(JJ_INPUT_CHECK(0));
445 }
446
447 /*******
448 *
449 */
jpg_read_DQT()450 xaULONG jpg_read_DQT()
451 { xaLONG len;
452 JJ_INPUT_xaSHORT(len);
453 if ( !xa_mjpg_kludge ) len -= 2;
454
455 DEBUG_LEVEL1 fprintf(stderr,"DQT:\n");
456
457 while(len > 0)
458 { xaLONG i,tbl_num,prec;
459 xaLONG *quant_table;
460
461 JJ_INPUT_xaBYTE(tbl_num); len -= 1;
462 DEBUG_LEVEL1 fprintf(stderr," prec/tnum %02x\n",tbl_num);
463
464 prec = (tbl_num >> 4) & 0x0f;
465 prec = (prec)?(2 * DCTSIZE2):(DCTSIZE2); /* 128 or 64 */
466 tbl_num &= 0x0f;
467 if (tbl_num > 4)
468 { fprintf(stderr,"JJ: bad DQT tnum %x\n",tbl_num); return(xaFALSE); }
469
470 if (jpg_quant_tables[tbl_num] == 0)
471 {
472 jpg_quant_tables[tbl_num] = (xaLONG *)malloc(64 * sizeof(xaLONG));
473 if (jpg_quant_tables[tbl_num] == 0)
474 { fprintf(stderr,"JJ: DQT alloc err %x \n",tbl_num); return(xaFALSE); }
475 }
476 len -= prec;
477 if (JJ_INPUT_CHECK(prec)==xaFALSE) return(xaFALSE);
478 quant_table = jpg_quant_tables[tbl_num];
479 if (prec==128)
480 { xaULONG tmp;
481 for (i = 0; i < DCTSIZE2; i++)
482 { JJ_INPUT_xaSHORT(tmp); quant_table[ JJ_ZAG[i] ] = (xaLONG) tmp; }
483 }
484 else
485 { xaULONG tmp;
486 for (i = 0; i < DCTSIZE2; i++)
487 { JJ_INPUT_xaBYTE(tmp); quant_table[ JJ_ZAG[i] ] = (xaLONG) tmp; }
488 }
489 }
490 return(xaTRUE);
491 }
492
493 /*******
494 * Handle DRI chunk
495 */
jpg_read_DRI()496 xaULONG jpg_read_DRI()
497 { xaLONG len;
498 JJ_INPUT_xaSHORT(len);
499 JJ_INPUT_xaSHORT(jpg_rst_interval);
500 DEBUG_LEVEL1 fprintf(stderr,"DRI: int %x\n",jpg_rst_interval);
501 return(xaTRUE);
502 }
503
504 /*******
505 *
506 */
jpg_skip_marker()507 xaULONG jpg_skip_marker()
508 { xaLONG len,tmp;
509 JJ_INPUT_xaSHORT(len);
510 DEBUG_LEVEL1 fprintf(stderr,"SKIP: marker %x len %x\n",jpg_marker,len);
511 len -= 2; if (len <=0) return(xaFALSE);
512 if (JJ_INPUT_CHECK(len)==xaFALSE) return(xaFALSE);
513 while(len--) JJ_INPUT_xaBYTE(tmp); /* POD improve this */
514 return(xaTRUE);
515 }
516
517 /*******
518 *
519 */
jpg_read_DHT()520 xaULONG jpg_read_DHT()
521 {
522 xaLONG len;
523 xaULONG ret = xaFALSE;
524 JJ_HUFF_TBL *htable;
525 xaUBYTE *hbits;
526 xaUBYTE *hvals;
527
528 jpg_std_DHT_flag = 0;
529 JJ_INPUT_xaSHORT(len);
530
531 DEBUG_LEVEL1 fprintf(stderr,"DHT: len %d\n",len);
532
533 if (xa_mjpg_kludge) len += 2;
534 len -= 2;
535 if (JJ_INPUT_CHECK(len)==xaFALSE) return(xaFALSE);
536
537 while(len > 0)
538 { xaLONG i,index,count;
539 JJ_INPUT_xaBYTE(index);
540 len--;
541 /* POD index check */
542 if (index & 0x10) /* AC Table */
543 {
544 index &= 0x0f;
545 if (index >= JJ_NUM_HUFF_TBLS) break; /* return(xaFALSE); */
546 htable = &(jpg_ac_huff[index]);
547 hbits = jpg_ac_huff[index].bits;
548 hvals = jpg_ac_huff[index].vals;
549 }
550 else /* DC Table */
551 {
552 index &= 0x0f;
553 if (index >= JJ_NUM_HUFF_TBLS) break; /* return(xaFALSE); */
554 htable = &(jpg_dc_huff[index]);
555 hbits = jpg_dc_huff[index].bits;
556 hvals = jpg_dc_huff[index].vals;
557 }
558 hbits[0] = 0; count = 0;
559 if (len < 16) break;
560 for (i = 1; i <= 16; i++)
561 {
562 JJ_INPUT_xaBYTE(hbits[i]);
563 count += hbits[i];
564 }
565 len -= 16;
566 if (count > 256)
567 { fprintf(stderr,"JJ: DHT bad count %d defaulting to STD.\n",count);
568 break;
569 }
570 if (len < count)
571 { fprintf(stderr,"JJ: DHT count(%d) > len(%d).\n",count,len);
572 break;
573 }
574
575 for (i = 0; i < count; i++) JJ_INPUT_xaBYTE(hvals[i]);
576 len -= count;
577
578 jpg_huff_build(htable,hbits,hvals);
579 ret = xaTRUE;
580 } /* end of len */
581
582 if (ret == xaFALSE)
583 { xaULONG garb;
584 /* Something is roached, but what the heck, try default DHT instead */
585 DEBUG_LEVEL1 fprintf(stderr,"bad DHT trying STD instead.\n");
586 while(len > 0)
587 { len--;
588 JJ_INPUT_xaBYTE(garb);
589 }
590 jpg_std_DHT();
591 return(xaTRUE);
592 }
593 return(xaTRUE);
594 }
595
596 /*******
597 *
598 */
jpg_get_marker()599 xaULONG jpg_get_marker()
600 {
601 xaLONG c;
602
603 for(;;)
604 {
605 JJ_INPUT_xaBYTE(c);
606 while(c != 0xFF) /* look for FF */
607 {
608 if (JJ_INPUT_CHECK(1)==xaFALSE) return(xaFALSE);
609 JJ_INPUT_xaBYTE(c);
610 }
611 /* now we've got 1 0xFF, keep reading until not 0xFF */
612 do
613 {
614 if (JJ_INPUT_CHECK(1)==xaFALSE) return(xaFALSE);
615 JJ_INPUT_xaBYTE(c);
616 } while (c == 0xFF);
617 if (c != 0) break; /* ignore FF/00 sequences */
618 }
619 jpg_marker = c;
620 return(xaTRUE);
621 }
622
623
624 /*******
625 *
626 */
jpg_read_markers()627 xaULONG jpg_read_markers()
628 {
629 for(;;)
630 {
631 if (jpg_get_marker() == xaFALSE) return(xaFALSE);
632 DEBUG_LEVEL1 fprintf(stderr,"JJ: marker %x\n",jpg_marker);
633 switch(jpg_marker)
634 {
635 case M_SOI:
636 if (jpg_read_SOI()==xaFALSE) return(xaFALSE);
637 jpg_saw_SOI = xaTRUE;
638 break;
639 case M_SOF0:
640 case M_SOF1:
641 case M_SOF2:
642 if (jpg_read_SOF()==xaFALSE) return(xaFALSE);
643 jpg_saw_SOF = xaTRUE;
644 break;
645 /* Not yet supported */
646 case M_SOF3:
647 case M_SOF5:
648 case M_SOF6:
649 case M_SOF7:
650 case M_SOF9:
651 case M_SOF10:
652 case M_SOF11:
653 case M_SOF13:
654 case M_SOF14:
655 case M_SOF15:
656 return(xaFALSE);
657 break;
658 case M_SOS:
659 if (jpg_read_SOS()==xaFALSE) return(xaFALSE);
660 jpg_saw_SOS = xaTRUE;
661 jpg_nxt_rst_num = 0;
662 return(xaTRUE);
663 break;
664 case M_DHT:
665 if (jpg_read_DHT()==xaFALSE) return(xaFALSE);
666 jpg_saw_DHT = xaTRUE;
667 break;
668 case M_DQT:
669 if (jpg_read_DQT()==xaFALSE) return(xaFALSE);
670 jpg_saw_DQT = xaTRUE;
671 break;
672 case M_DRI:
673 if (jpg_read_DRI()==xaFALSE) return(xaFALSE);
674 break;
675 case M_COM: /* COMMENT */
676 { int len;
677 JJ_INPUT_xaSHORT(len);
678 len -= 2;
679 /*
680 if (xa_verbose) fprintf(stdout,"JPG Comment: ");
681 */
682 while(len > 0)
683 { int d;
684 JJ_INPUT_xaBYTE(d); len--;
685 /*
686 if ((xa_verbose) && (d >= 20)) fputc(d,stdout);
687 */
688 }
689 /*
690 if (xa_verbose) fprintf(stdout,"\n");
691 */
692 }
693 break;
694 case M_APP0:
695 case M_APP1:
696 if (jpg_read_appX() == xaFALSE) return(xaFALSE);
697 break;
698 case M_EOI:
699 fprintf(stderr,"JJ: reached EOI without data\n");
700 return(xaFALSE);
701 break;
702 case M_RST0: /* these are all parameterless */
703 case M_RST1:
704 case M_RST2:
705 case M_RST3:
706 case M_RST4:
707 case M_RST5:
708 case M_RST6:
709 case M_RST7:
710 case M_TEM:
711 break;
712 default:
713 DEBUG_LEVEL1 fprintf(stderr,"JJ: unknown marker %x\n",jpg_marker);
714 if (jpg_skip_marker()==xaFALSE) return(xaFALSE);
715 break;
716 } /* end of switch */
717 } /* end of forever */
718 }
719
720 /* Good lord, is there no standard */
jpg_read_appX()721 xaULONG jpg_read_appX()
722 { xaLONG len;
723 JJ_INPUT_xaSHORT(len);
724 len -= 2;
725 if (len > 4)
726 { xaULONG first;
727 JJ_INPUT_xaLONG(first);
728 len -= 4;
729 if (first == 0x41564931) /* AVI1 */
730 { int interleave;
731 JJ_INPUT_xaBYTE(interleave);
732 len--;
733 avi_jpeg_info.valid = xaTRUE;
734 avi_jpeg_info.ileave = interleave;
735 }
736 else if (len > (0x28 - 4)) /* Maybe APPLE MJPEG A */
737 { xaULONG jid;
738 JJ_INPUT_xaLONG(jid);
739 len -= 4;
740 if (jid == 0x6D6A7067) /* TODO: define JPEG_APP1_mjpg */
741 { qt_jpeg_info.valid = xaTRUE;
742 JJ_INPUT_xaLONG(qt_jpeg_info.field_sz);
743 JJ_INPUT_xaLONG(qt_jpeg_info.pad_field_sz);
744 JJ_INPUT_xaLONG(qt_jpeg_info.next_off);
745 JJ_INPUT_xaLONG(qt_jpeg_info.quant_off);
746 JJ_INPUT_xaLONG(qt_jpeg_info.huff_off);
747 JJ_INPUT_xaLONG(qt_jpeg_info.image_off);
748 JJ_INPUT_xaLONG(qt_jpeg_info.scan_off);
749 JJ_INPUT_xaLONG(qt_jpeg_info.data_off);
750 len -= 32;
751 }
752 }
753 }
754 if (len) JJ_INPUT_SKIP(len);
755 return(xaTRUE);
756 }
757
758
759 /*****
760 *
761 */
jpg_huff_build(htbl,hbits,hvals)762 void jpg_huff_build(htbl,hbits,hvals)
763 JJ_HUFF_TBL *htbl;
764 xaUBYTE *hbits,*hvals;
765 { xaULONG clen,num_syms,p,i,si,code,lookbits;
766 xaULONG l,ctr;
767 xaUBYTE huffsize[257];
768 xaULONG huffcode[257];
769
770 /*** generate code lengths for each symbol */
771 num_syms = 0;
772 for(clen = 1; clen <= 16; clen++)
773 {
774 for(i = 1; i <= (xaULONG)(hbits[clen]); i++)
775 huffsize[num_syms++] = (xaUBYTE)(clen);
776 }
777 huffsize[num_syms] = 0;
778
779 /*** generate codes */
780 code = 0;
781 si = huffsize[0];
782 p = 0;
783 while (huffsize[p])
784 {
785 while ( ((xaULONG)huffsize[p]) == si)
786 {
787 huffcode[p++] = code;
788 code++;
789 }
790 code <<= 1;
791 si++;
792 }
793
794 /* Init mincode/maxcode/valptr arrays */
795 p = 0;
796 for (l = 1; l <= 16; l++)
797 {
798 if (htbl->bits[l])
799 {
800 htbl->valptr[l] = p; /* huffval[] index of 1st symbol of code length l */
801 htbl->mincode[l] = huffcode[p]; /* minimum code of length l */
802 p += (xaULONG)(htbl->bits[l]);
803 htbl->maxcode[l] = huffcode[p-1]; /* maximum code of length l */
804 }
805 else
806 {
807 htbl->valptr[l] = 0; /* not needed */
808 htbl->mincode[l] = 0; /* not needed */
809 htbl->maxcode[l] = 0; /* WAS -1; */ /* -1 if no codes of this length */
810 }
811 }
812 htbl->maxcode[17] = 0xFFFFFL; /* ensures huff_DECODE terminates */
813
814
815 /* Init huffman cache */
816 memset((char *)htbl->cache, 0, ((1<<HUFF_LOOKAHEAD) * sizeof(xaUSHORT)) );
817 p = 0;
818 for (l = 1; l <= HUFF_LOOKAHEAD; l++)
819 {
820 for (i = 1; i <= (xaULONG) htbl->bits[l]; i++, p++)
821 { xaSHORT the_code = (xaUSHORT)((l << 8) | htbl->vals[p]);
822
823 /* l = current code's length, p = its index in huffcode[] & huffval[]. */
824 /* Generate left-justified code followed by all possible bit sequences */
825
826 lookbits = huffcode[p] << (HUFF_LOOKAHEAD-l);
827 for (ctr = 1 << (HUFF_LOOKAHEAD-l); ctr > 0; ctr--)
828 {
829 htbl->cache[lookbits] = the_code;
830 lookbits++;
831 }
832 }
833 }
834 }
835
836
837 /*******
838 *
839 */
jpg_init_input(buff,buff_size)840 void jpg_init_input(buff,buff_size)
841 xaUBYTE *buff;
842 xaLONG buff_size;
843 {
844 jpg_buff = buff;
845 jpg_bsize = buff_size;
846 }
847
848 /*******
849 *
850 */
851 xaULONG
JFIF_Decode_JPEG(image,delta,dsize,dec_info)852 JFIF_Decode_JPEG(image,delta,dsize,dec_info)
853 xaUBYTE *image; /* Image Buffer. */
854 xaUBYTE *delta; /* delta data. */
855 xaULONG dsize; /* delta size */
856 XA_DEC2_INFO *dec_info; /* Decoder Info Header */
857 { xaULONG imagex = dec_info->imagex; xaULONG imagey = dec_info->imagey;
858 xaULONG map_flag = dec_info->map_flag;
859 void *extra = dec_info->extra;
860 xaLONG base_y;
861 xaULONG jpg_type;
862 xaULONG interleave,row_offset;
863
864 dec_info->xs = dec_info->ys = 0;
865 dec_info->xe = imagex; dec_info->ye = imagey;
866
867 /* Indicate we can drop these frames */
868 if (dec_info->skip_flag > 0) return(ACT_DLTA_DROP);
869
870 /* JPEG_TYPE passed in via extra
871 *
872 * 0x01 interleaved jpeg files
873 * 0x40 AVI MJPG kludge(they screwed up the marker lengths)
874 * 0x10 IJPG/JMOV images(no upfront markers)
875 *
876 */
877
878 jpg_type = (xaULONG)(extra);
879 xa_mjpg_kludge = (jpg_type & 0x40)?(0x40):(0x00);
880
881 if (jpg_init_flag==xaFALSE) jpg_init_stuff();
882
883 /* init buffer stuff */
884 jpg_init_input(delta,dsize);
885
886 base_y = 0;
887 while(base_y < (imagey - 4)) /* the 4 is just a fuzz factor TODO do better */
888 {
889 jpg_saw_EOI = jpg_saw_DHT = xaFALSE;
890 if (jpg_type & 0x10) /* IJPG/JMOV File */
891 { xaLONG ci,*qtbl0,*qtbl1;
892 jpg_saw_SOI = jpg_saw_SOF = jpg_saw_SOS = jpg_saw_DQT = xaTRUE;
893 jpg_saw_EOI = xaTRUE;
894
895 if (base_y == 0) /* 1st time through */
896 {
897 jpg_huff_reset(); /* only 1st time */
898 jpg_width = imagex;
899 if (jpg_type & 0x01)
900 jpg_height = (imagey + 1) >> 1;/* interleaved */
901 else jpg_height = imagey;
902 jpg_comps_in_scan = jpg_num_comps = 3;
903 jpg_rst_interval = 0;
904
905 jpg_comps[0].hvsample = 0x21;
906 jpg_comps[0].ac_htbl_num = 0;
907 jpg_comps[0].dc_htbl_num = 0;
908 jpg_comps[0].qtbl_num = 0;
909 jpg_comps[1].hvsample = jpg_comps[2].hvsample = 0x11;
910 jpg_comps[1].ac_htbl_num = jpg_comps[2].ac_htbl_num = 1;
911 jpg_comps[1].dc_htbl_num = jpg_comps[2].dc_htbl_num = 1;
912 jpg_comps[1].qtbl_num = jpg_comps[2].qtbl_num = 1;
913 jpg_comps[0].id = 0;
914 jpg_comps[1].id = 1;
915 jpg_comps[2].id = 2;
916
917 /* IJPG set up quant tables */
918 if (jpg_quant_tables[0] == 0)
919 {
920 jpg_quant_tables[0] = (xaLONG *)malloc(64 * sizeof(xaLONG));
921 if (jpg_quant_tables[0] == 0)
922 { fprintf(stderr,"JJ: IJPG DQT0 alloc err \n"); return(xaFALSE); }
923 }
924 if (jpg_quant_tables[1] == 0)
925 {
926 jpg_quant_tables[1] = (xaLONG *)malloc(64 * sizeof(xaLONG));
927 if (jpg_quant_tables[1] == 0)
928 { fprintf(stderr,"JJ: IJPG DQT1 alloc err \n"); return(xaFALSE); }
929 }
930 qtbl0 = jpg_quant_tables[0];
931 qtbl1 = jpg_quant_tables[1];
932 for(ci=0; ci < DCTSIZE2; ci++)
933 {
934 qtbl0[ JJ_ZAG[ci] ] = (xaLONG)IJPG_Tab1[ci];
935 qtbl1[ JJ_ZAG[ci] ] = (xaLONG)IJPG_Tab2[ci];
936 }
937 } else jpg_saw_DHT = xaTRUE; /* 2nd time through IJPG */
938
939 if (jpg_type & 0x01)
940 {
941 interleave = 2;
942 if (jpg_type & 0x2) /* first field is even/top field */
943 {
944 row_offset = (base_y)?(1):(0);
945 }
946 else /* first field is odd/bottom field */
947 {
948 row_offset = (base_y)?(0):(1);
949 }
950 }
951 else
952 {
953 interleave = 1;
954 row_offset = 0;
955 }
956
957 } else
958 {
959 /* read markers */
960 jpg_saw_SOI = jpg_saw_SOF = jpg_saw_SOS = jpg_saw_DHT = jpg_saw_DQT = xaFALSE;
961 if (jpg_read_markers() == xaFALSE) { jpg_free_stuff();
962 fprintf(stderr,"JPG: rd marker err\n"); return(ACT_DLTA_NOP); }
963 jpg_huff_reset();
964
965 DEBUG_LEVEL1 fprintf(stderr,"jpg_height %d imagey %d qt_jpeg.valid %d\n",
966 jpg_height, imagey, qt_jpeg_info.valid);
967 interleave = (jpg_height <= ((imagey>>1)+1) )?(2):(1);
968 if (interleave == 2)
969 {
970 if (avi_jpeg_info.valid == xaTRUE)
971 {
972 switch(avi_jpeg_info.ileave)
973 {
974 case 0:
975 case 2: row_offset = 0; break;
976 case 1: row_offset = 1; break;
977 default:
978 DEBUG_LEVEL1 fprintf(stderr,"AVIJPEG: unknown ileave %d\n",
979 avi_jpeg_info.ileave);
980 row_offset = 0;
981 break;
982 }
983 }
984 else if (jpg_type & 0x2) /* first field is even/top field */
985 {
986 row_offset = (base_y == 0)?(0):(1);
987 }
988 else /* first field is odd/bottom field */
989 {
990 row_offset = (base_y == 0)?(1):(0);
991 }
992 }
993 else row_offset = 0;
994 }
995 jpg_marker = 0x00;
996 if (jpg_width > imagex) JPG_Alloc_MCU_Bufs(0,jpg_width,0,xaFALSE);
997
998
999 if ((jpg_saw_DHT != xaTRUE) && (jpg_std_DHT_flag==0))
1000 {
1001 DEBUG_LEVEL1 fprintf(stderr,"standard DHT tables\n");
1002 (void)jpg_std_DHT();
1003 }
1004
1005 if (jpg_saw_DQT != xaTRUE)
1006 {
1007 DEBUG_LEVEL1 fprintf(stderr,"JPG: warning no DQT table - guessing\n");
1008 (void)jpg_std_DQT(100);
1009 }
1010
1011
1012 DEBUG_LEVEL1 fprintf(stderr,"JJ: imagexy %d %d jjxy %d %d basey %d\n",imagex,imagey,jpg_width,jpg_height,base_y);
1013
1014 if ( (jpg_num_comps == 3) && (jpg_comps_in_scan == 3)
1015 && (jpg_comps[1].hvsample == 0x11) && (jpg_comps[2].hvsample== 0x11) )
1016 {
1017 if (jpg_comps[0].hvsample == 0x41) /* 411 */
1018 { jpg_decode_411111(image,jpg_width,jpg_height,interleave,row_offset,
1019 imagex,imagey,dec_info); }
1020 else if (jpg_comps[0].hvsample == 0x22) /* 411 */
1021 { jpg_decode_221111(image,jpg_width,jpg_height,interleave,row_offset,
1022 imagex,imagey,dec_info); }
1023 else if (jpg_comps[0].hvsample == 0x21) /* 211 */
1024 { jpg_decode_211111(image,jpg_width,jpg_height,interleave,row_offset,
1025 imagex,imagey,dec_info); }
1026 else if (jpg_comps[0].hvsample == 0x11) /* 111 */
1027 { jpg_decode_111111(image,jpg_width,jpg_height,interleave,row_offset,
1028 imagex,imagey,dec_info,0); }
1029 else
1030 { fprintf(stderr,"JPG: cmps %d %d mcu %04x %04x %04x unsupported\n",
1031 jpg_num_comps,jpg_comps_in_scan,jpg_comps[0].hvsample,
1032 jpg_comps[1].hvsample,jpg_comps[2].hvsample);
1033 break;
1034 }
1035 }
1036 else if ( (jpg_num_comps == 1) || (jpg_comps_in_scan == 1) )
1037 {
1038 jpg_decode_111111(image,jpg_width,jpg_height,interleave,row_offset,
1039 imagex,imagey,dec_info,1);
1040 }
1041 else
1042 { fprintf(stderr,"JPG: cmps %d %d mcu %04x %04x %04x unsupported.\n",
1043 jpg_num_comps,jpg_comps_in_scan,jpg_comps[0].hvsample,
1044 jpg_comps[1].hvsample,jpg_comps[2].hvsample);
1045 break;
1046 }
1047
1048 base_y += ((interleave == 1)?(imagey):(jpg_height));
1049 if (jpg_marker == M_EOI) { jpg_saw_EOI = xaTRUE; jpg_marker = 0x00; }
1050 else if (jpg_saw_EOI==xaFALSE) if (jpg_read_EOI_marker() == xaFALSE) break;
1051 }
1052 if (map_flag==xaTRUE) return(ACT_DLTA_MAPD);
1053 else return(ACT_DLTA_NORM);
1054 }
1055
1056 /*******
1057 *
1058 */
jpg_huff_reset()1059 void jpg_huff_reset()
1060 {
1061 jpg_comps[0].dc = 0;
1062 jpg_comps[1].dc = 0;
1063 jpg_comps[2].dc = 0;
1064 jpg_h_bbuf = 0; /* clear huffman bit buffer */
1065 jpg_h_bnum = 0;
1066 }
1067
1068 /*******
1069 *
1070 */
jpg_read_EOI_marker()1071 xaULONG jpg_read_EOI_marker()
1072 {
1073 /* POD make sure previous code restores bit buffer to input stream */
1074 while( jpg_get_marker() == xaTRUE)
1075 {
1076 if (jpg_marker == M_EOI) {jpg_saw_EOI = xaTRUE; return(xaTRUE); }
1077 }
1078 return(xaFALSE);
1079 }
1080
JPG_Free_MCU_Bufs()1081 void JPG_Free_MCU_Bufs()
1082 {
1083 if (jpg_Ybuf) { free(jpg_Ybuf); jpg_Ybuf = 0; }
1084 if (jpg_Ubuf) { free(jpg_Ubuf); jpg_Ubuf = 0; }
1085 if (jpg_Vbuf) { free(jpg_Vbuf); jpg_Vbuf = 0; }
1086 jpg_YUVBufs.Ybuf = 0; jpg_YUVBufs.Ubuf = 0; jpg_YUVBufs.Vbuf = 0;
1087 }
1088
1089 /*******
1090 *
1091 */
JPG_Alloc_MCU_Bufs(anim_hdr,width,height,full_flag)1092 void JPG_Alloc_MCU_Bufs(anim_hdr,width,height,full_flag)
1093 XA_ANIM_HDR *anim_hdr;
1094 xaULONG width, height, full_flag;
1095 { xaULONG twidth = (width + 15) / 16;
1096 xaULONG theight = (height + 15) / 16; if (theight & 1) theight++;
1097
1098 if (full_flag==xaTRUE) twidth *= (theight << 2);
1099 else twidth <<= 2; /* four dct's deep */
1100
1101 DEBUG_LEVEL1 fprintf(stderr,"Alloc_MCU: wh %d %d twid %d act %d\n",
1102 width,height,twidth,(twidth * DCTSIZE2) );
1103
1104 if (anim_hdr) XA_Add_Func_To_Free_Chain(anim_hdr,JPG_Free_MCU_Bufs);
1105 if (jpg_init_flag==xaFALSE) jpg_init_stuff();
1106 if (jpg_Ybuf == 0)
1107 { jpg_MCUbuf_size = twidth;
1108 jpg_Ybuf = (xaUBYTE *)malloc(twidth * DCTSIZE2);
1109 jpg_Ubuf = (xaUBYTE *)malloc(twidth * DCTSIZE2);
1110 jpg_Vbuf = (xaUBYTE *)malloc(twidth * DCTSIZE2);
1111 }
1112 else if (twidth > jpg_MCUbuf_size)
1113 { jpg_MCUbuf_size = twidth;
1114 jpg_Ybuf = (xaUBYTE *)realloc( jpg_Ybuf,(twidth * DCTSIZE2) );
1115 jpg_Ubuf = (xaUBYTE *)realloc( jpg_Ubuf,(twidth * DCTSIZE2) );
1116 jpg_Vbuf = (xaUBYTE *)realloc( jpg_Vbuf,(twidth * DCTSIZE2) );
1117 }
1118 jpg_YUVBufs.Ybuf = jpg_Ybuf;
1119 jpg_YUVBufs.Ubuf = jpg_Ubuf;
1120 jpg_YUVBufs.Vbuf = jpg_Vbuf;
1121
1122 }
1123
1124 #define jpg_huff_EXTEND(val,sz) \
1125 ((val) < (1<<((sz)-1)) ? (val) + (((-1)<<(sz)) + 1) : (val))
1126
1127
1128 /*
1129 * IF marker is read then jpg_marker is set and nothing more is read in.
1130 */
1131
1132 #define JJ_HBBUF_FILL8(hbbuf,hbnum) \
1133 { register xaULONG _tmp; \
1134 hbbuf <<= 8; \
1135 if (jpg_marker) return(xaFALSE); \
1136 else { _tmp = *jpg_buff++; jpg_bsize--; } \
1137 while(_tmp == 0xff) \
1138 { register xaULONG _t1; _t1 = *jpg_buff++; jpg_bsize--; \
1139 if (_t1 == 0x00) break; \
1140 else if (_t1 == 0xff) continue; \
1141 else {jpg_marker = _t1; _tmp = 0x00; break;} \
1142 } \
1143 hbbuf |= _tmp; hbnum += 8; \
1144 }
1145
1146 #define JJ_HBBUF_FILL8_1(hbbuf,hbnum) \
1147 { register xaULONG __tmp; \
1148 hbbuf <<= 8; hbnum += 8; \
1149 if (jpg_marker) __tmp = 0x00; \
1150 else { __tmp = *jpg_buff++; jpg_bsize--; } \
1151 while(__tmp == 0xff) \
1152 { register xaULONG _t1; _t1 = *jpg_buff++; jpg_bsize--; \
1153 if (_t1 == 0x00) break; \
1154 else if (_t1 == 0xff) continue; \
1155 else {jpg_marker = _t1; __tmp = 0x00; break;} \
1156 } \
1157 hbbuf |= __tmp; \
1158 }
1159
1160 #define JJ_HUFF_DECODE(huff_hdr,htbl, hbnum, hbbuf, result) \
1161 { register xaULONG _tmp, _hcode; \
1162 while(hbnum < 16) JJ_HBBUF_FILL8_1(hbbuf,hbnum); \
1163 _tmp = (hbbuf >> (hbnum - 8)) & 0xff; \
1164 _hcode = (htbl)[_tmp]; \
1165 if (_hcode) { hbnum -= (_hcode >> 8); (result) = _hcode & 0xff; } \
1166 else \
1167 { register xaULONG _hcode, _shift, _minbits = 9; \
1168 _tmp = (hbbuf >> (hbnum - 16)) & 0xffff; /* get 16 bits */ \
1169 _shift = 16 - _minbits; _hcode = _tmp >> _shift; \
1170 while(_hcode > huff_hdr->maxcode[_minbits]) \
1171 { _minbits++; _shift--; _hcode = _tmp >> _shift; } \
1172 if (_minbits > 16) { fprintf(stderr,"JHDerr\n"); return(xaFALSE); } \
1173 else \
1174 { hbnum -= _minbits; _hcode -= huff_hdr->mincode[_minbits]; \
1175 result = huff_hdr->vals[ (huff_hdr->valptr[_minbits] + _hcode) ]; } \
1176 } \
1177 }
1178
1179 #define JJ_HUFF_MASK(s) ((1 << (s)) - 1)
1180
1181 #define JJ_GET_BITS(n, hbnum, hbbuf, result) \
1182 { hbnum -= n; \
1183 while(hbnum < 0) { JJ_HBBUF_FILL8_1(hbbuf,hbnum); } \
1184 (result) = ((hbbuf >> hbnum) & JJ_HUFF_MASK(n)); \
1185 }
1186
1187 /****--------------------------------------------------------------------****
1188 * Look ahead to see if marker is present. This is not 100% robust
1189 * in that it doesn't catch markers with multiple leading 0xFF's.
1190 ****--------------------------------------------------------------------****/
jpg_check_for_marker()1191 xaULONG jpg_check_for_marker()
1192 {
1193 if (jpg_marker) return(jpg_marker);
1194 if (jpg_bsize < 2) return(0);
1195 if ((jpg_buff[0] == 0xff) && (jpg_buff[1] != 0x00))
1196 {
1197 jpg_marker = jpg_buff[1];
1198 DEBUG_LEVEL1
1199 { if (jpg_h_bnum)
1200 { fprintf(stderr,"JPG: check marker positive - lost %d bits\n",
1201 jpg_h_bnum);
1202 }
1203 }
1204 jpg_h_bnum = 0;
1205 jpg_h_bbuf = 0;
1206 jpg_buff += 2;
1207 jpg_bsize -= 2;
1208 }
1209 return(jpg_marker);
1210 }
1211
1212 /****--------------------------------------------------------------------****
1213 * Skip ahead to next marker.
1214 ****--------------------------------------------------------------------****/
jpg_skip_to_nxt_rst()1215 xaULONG jpg_skip_to_nxt_rst()
1216 { xaULONG d, last_ff = 0;
1217 jpg_h_bnum = 0;
1218 jpg_h_bbuf = 0;
1219 while( jpg_bsize )
1220 {
1221 d = *jpg_buff++; jpg_bsize--;
1222 if (last_ff)
1223 {
1224 if ((d != 0) && (d != 0xff)) return(d);
1225 }
1226 last_ff = (d == 0xff)?(1):(0);
1227 }
1228 return(M_EOI);
1229 }
1230
1231
1232 /* clears dctbuf to zeroes.
1233 * fills from huffman encode stream
1234 */
jpg_huffparse(comp,dct_buf,qtab,OBuf)1235 xaULONG jpg_huffparse(comp, dct_buf, qtab, OBuf)
1236 register COMPONENT_HDR *comp;
1237 register xaSHORT *dct_buf;
1238 xaULONG *qtab;
1239 xaUBYTE *OBuf;
1240 { xaLONG i,dcval;
1241 xaULONG size;
1242 JJ_HUFF_TBL *huff_hdr = &(jpg_dc_huff[ comp->dc_htbl_num ]);
1243 xaUSHORT *huff_tbl = huff_hdr->cache;
1244 xaUBYTE *rnglimit = jpg_samp_limit + (CENTERJSAMPLE + MAXJSAMPLE + 1);
1245 xaULONG c_cnt,pos = 0;
1246
1247 JJ_HUFF_DECODE(huff_hdr,huff_tbl,jpg_h_bnum,jpg_h_bbuf,size);
1248
1249 DEBUG_LEVEL2 { fprintf(stderr," HUFF DECODE: size %d\n",size); }
1250
1251 if (size)
1252 { xaULONG bits;
1253 JJ_GET_BITS(size,jpg_h_bnum,jpg_h_bbuf,bits);
1254 dcval = jpg_huff_EXTEND(bits, size);
1255 comp->dc += dcval;
1256 DEBUG_LEVEL2 { fprintf(stderr," dcval %d -dc %d\n",dcval,comp->dc); }
1257 }
1258 dcval = comp->dc;
1259
1260 /* clear reset of dct buffer */
1261 memset((char *)(dct_buf),0,(DCTSIZE2 * sizeof(xaSHORT)));
1262 dcval *= (xaLONG)qtab[0];
1263 dct_buf[0] = (xaSHORT)dcval;
1264 c_cnt = 0;
1265
1266 huff_hdr = &(jpg_ac_huff[ comp->ac_htbl_num ]);
1267 huff_tbl = huff_hdr->cache;
1268 i = 1;
1269 while(i < 64)
1270 { xaLONG level; xaULONG run,tmp;
1271 JJ_HUFF_DECODE(huff_hdr,huff_tbl,jpg_h_bnum,jpg_h_bbuf,tmp);
1272 size = tmp & 0x0f;
1273 run = (tmp >> 4) & 0x0f; /* leading zeroes */
1274 DEBUG_LEVEL2 { fprintf(stderr," %d) tmp %x size %x run %x\n",
1275 i,tmp,size,run); }
1276 if (size)
1277 { xaLONG coeff;
1278 i += run; /* skip zeroes */
1279 JJ_GET_BITS(size, jpg_h_bnum,jpg_h_bbuf,level);
1280 coeff = (xaLONG)jpg_huff_EXTEND(level, size);
1281 DEBUG_LEVEL2 fprintf(stderr," size %d coeff %x\n",size,coeff);
1282 pos = JJ_ZAG[i];
1283 coeff *= (xaLONG)qtab[ pos ];
1284 if (coeff)
1285 { c_cnt++;
1286 dct_buf[ pos ] = (xaSHORT)(coeff);
1287 }
1288 i++;
1289 }
1290 else
1291 {
1292 if (run != 15) break; /* EOB */
1293 i += 16;
1294 }
1295 }
1296
1297 if (c_cnt) j_rev_dct(dct_buf, OBuf, rnglimit);
1298 else
1299 { register xaUBYTE *op = OBuf;
1300 register int jj = 8;
1301 xaSHORT v = *dct_buf;
1302 register xaUBYTE dc;
1303 v = (v < 0)?( (v-3)>>3 ):( (v+4)>>3 );
1304 dc = rnglimit[ (int) (v & RANGE_MASK) ];
1305 while(jj--)
1306 { op[0] = op[1] = op[2] = op[3] = op[4] = op[5] = op[6] = op[7] = dc;
1307 op += 8;
1308 }
1309 }
1310 return(xaTRUE);
1311 }
1312
1313 /* POD since these are fixed, possibly eliminate */
1314 #define FIX_0_298631336 ((xaLONG) 2446) /* FIX(0.298631336) */
1315 #define FIX_0_390180644 ((xaLONG) 3196) /* FIX(0.390180644) */
1316 #define FIX_0_541196100 ((xaLONG) 4433) /* FIX(0.541196100) */
1317 #define FIX_0_765366865 ((xaLONG) 6270) /* FIX(0.765366865) */
1318 #define FIX_0_899976223 ((xaLONG) 7373) /* FIX(0.899976223) */
1319 #define FIX_1_175875602 ((xaLONG) 9633) /* FIX(1.175875602) */
1320 #define FIX_1_501321110 ((xaLONG) 12299) /* FIX(1.501321110) */
1321 #define FIX_1_847759065 ((xaLONG) 15137) /* FIX(1.847759065) */
1322 #define FIX_1_961570560 ((xaLONG) 16069) /* FIX(1.961570560) */
1323 #define FIX_2_053119869 ((xaLONG) 16819) /* FIX(2.053119869) */
1324 #define FIX_2_562915447 ((xaLONG) 20995) /* FIX(2.562915447) */
1325 #define FIX_3_072711026 ((xaLONG) 25172) /* FIX(3.072711026) */
1326
1327 /***********************************************************************
1328 * For most steps we can mathematically guarantee that the initial value
1329 * of x is within MAXJSAMPLE+1 of the legal range, so a table running from
1330 * -(MAXJSAMPLE+1) to 2*MAXJSAMPLE+1 is sufficient. But for the initial
1331 * limiting step (just after the IDCT), a wildly out-of-range value is
1332 * possible if the input data is corrupt. To avoid any chance of indexing
1333 * off the end of memory and getting a bad-pointer trap, we perform the
1334 * post-IDCT limiting thus:
1335 * x = range_limit[x & MASK];
1336 * where MASK is 2 bits wider than legal sample data, ie 10 bits for 8-bit
1337 * samples. Under normal circumstances this is more than enough range and
1338 * a correct output will be generated; with bogus input data the mask will
1339 * cause wraparound, and we will safely generate a bogus-but-in-range output.
1340 * For the post-IDCT step, we want to convert the data from signed to unsigned
1341 * representation by adding CENTERJSAMPLE at the same time that we limit it.
1342 * So the post-IDCT limiting table ends up looking like this:
1343 * CENTERJSAMPLE,CENTERJSAMPLE+1,...,MAXJSAMPLE,
1344 * MAXJSAMPLE (repeat 2*(MAXJSAMPLE+1)-CENTERJSAMPLE times),
1345 * 0 (repeat 2*(MAXJSAMPLE+1)-CENTERJSAMPLE times),
1346 * 0,1,...,CENTERJSAMPLE-1
1347 * Negative inputs select values from the upper half of the table after
1348 * masking.
1349 *
1350 * We can save some space by overlapping the start of the post-IDCT table
1351 * with the simpler range limiting table. The post-IDCT table begins at
1352 * sample_range_limit + CENTERJSAMPLE.
1353 *
1354 * Note that the table is allocated in near data space on PCs; it's small
1355 * enough and used often enough to justify this.
1356 */
1357
JPG_Free_Samp_Limit_Table()1358 void JPG_Free_Samp_Limit_Table()
1359 {
1360 if (jpg_samp_limit) { free(jpg_samp_limit); jpg_samp_limit = 0; }
1361 }
1362
JPG_Setup_Samp_Limit_Table(anim_hdr)1363 void JPG_Setup_Samp_Limit_Table(anim_hdr)
1364 XA_ANIM_HDR *anim_hdr;
1365 {
1366 xaUBYTE *table;
1367 xaLONG i;
1368
1369 if (jpg_samp_limit==0)
1370 {
1371 jpg_samp_limit = (xaUBYTE *)malloc((5 * (MAXJSAMPLE+1) + CENTERJSAMPLE));
1372 if (jpg_samp_limit==0)
1373 { fprintf(stderr,"JJ: samp limit malloc err\n");
1374 return;
1375 } /*POD note improve this */
1376 }
1377 else return; /* already done */
1378
1379 if (anim_hdr) XA_Add_Func_To_Free_Chain(anim_hdr,JPG_Free_Samp_Limit_Table);
1380 xa_byte_limit = jpg_samp_limit + (MAXJSAMPLE + 1);
1381
1382 table = jpg_samp_limit;
1383 table += (MAXJSAMPLE+1); /* allow negative subscripts of simple table */
1384
1385 /* First segment of "simple" table: limit[x] = 0 for x < 0 */
1386 memset(table - (MAXJSAMPLE+1), 0, (MAXJSAMPLE+1));
1387
1388 /* Main part of "simple" table: limit[x] = x */
1389 for (i = 0; i <= MAXJSAMPLE; i++) table[i] = (xaUBYTE) i;
1390
1391 table += CENTERJSAMPLE; /* Point to where post-IDCT table starts */
1392 /* End of simple table, rest of first half of post-IDCT table */
1393
1394 for (i = CENTERJSAMPLE; i < 2*(MAXJSAMPLE+1); i++) table[i] = MAXJSAMPLE;
1395
1396 /* Second half of post-IDCT table */
1397 memset(table + (2 * (MAXJSAMPLE+1)), 0, (2 * (MAXJSAMPLE+1) - CENTERJSAMPLE));
1398 memcpy(table + (4 * (MAXJSAMPLE+1) - CENTERJSAMPLE),
1399 (char *)(jpg_samp_limit+(MAXJSAMPLE+1)), CENTERJSAMPLE);
1400 }
1401
1402 /*******
1403 *
1404 */
jpg_std_DHT()1405 xaULONG jpg_std_DHT()
1406 {
1407 xaLONG ttt,len;
1408 JJ_HUFF_TBL *htable;
1409 xaUBYTE *hbits,*Sbits;
1410 xaUBYTE *hvals,*Svals;
1411
1412 static xaUBYTE dc_luminance_bits[17] =
1413 { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
1414 static xaUBYTE dc_luminance_vals[] =
1415 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
1416
1417 static xaUBYTE dc_chrominance_bits[17] =
1418 { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
1419 static xaUBYTE dc_chrominance_vals[] =
1420 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
1421
1422 static xaUBYTE ac_luminance_bits[17] =
1423 { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
1424 static xaUBYTE ac_luminance_vals[] =
1425 { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
1426 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
1427 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
1428 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
1429 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
1430 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
1431 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
1432 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
1433 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
1434 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
1435 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
1436 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
1437 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
1438 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
1439 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
1440 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
1441 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
1442 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
1443 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
1444 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
1445 0xf9, 0xfa };
1446
1447 static xaUBYTE ac_chrominance_bits[17] =
1448 { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
1449 static xaUBYTE ac_chrominance_vals[] =
1450 { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
1451 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
1452 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
1453 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
1454 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
1455 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
1456 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
1457 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
1458 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
1459 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
1460 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
1461 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
1462 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
1463 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
1464 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
1465 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
1466 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
1467 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
1468 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
1469 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
1470 0xf9, 0xfa };
1471
1472 for(ttt=0;ttt<4;ttt++)
1473 { xaULONG index = ttt & 1;
1474 xaLONG i,count;
1475
1476 if (ttt <= 1) /* DC tables */
1477 {
1478 htable = &(jpg_dc_huff[index]);
1479 hbits = jpg_dc_huff[index].bits;
1480 hvals = jpg_dc_huff[index].vals;
1481 if (index==0) { Sbits = dc_luminance_bits; Svals = dc_luminance_vals; }
1482 else { Sbits = dc_chrominance_bits; Svals = dc_chrominance_vals; }
1483 }
1484 else /* AC tables */
1485 {
1486 htable = &(jpg_ac_huff[index]);
1487 hbits = jpg_ac_huff[index].bits;
1488 hvals = jpg_ac_huff[index].vals;
1489 if (index==0) { Sbits = ac_luminance_bits; Svals = ac_luminance_vals; }
1490 else { Sbits = ac_chrominance_bits; Svals = ac_chrominance_vals; }
1491 }
1492 hbits[0] = 0; count = 0;
1493 for (i = 1; i <= 16; i++)
1494 {
1495 hbits[i] = Sbits[i];
1496 count += hbits[i];
1497 }
1498 len -= 17;
1499 if (count > 256)
1500 { fprintf(stderr,"JJ: STD DHT bad count %d\n",count); return(xaFALSE); }
1501
1502 for (i = 0; i < count; i++) hvals[i] = Svals[i];
1503 len -= count;
1504
1505 jpg_huff_build(htable,hbits,hvals);
1506
1507 } /* end of i */
1508 jpg_std_DHT_flag = 1;
1509 return(xaTRUE);
1510 }
1511
jpg_std_DQT(scale)1512 xaULONG jpg_std_DQT(scale)
1513 xaLONG scale;
1514 { xaLONG i, tbl_num;
1515 xaLONG *quant_table;
1516 unsigned int *table;
1517 unsigned int std_luminance_quant_tbl[DCTSIZE2] = {
1518 16, 11, 10, 16, 24, 40, 51, 61,
1519 12, 12, 14, 19, 26, 58, 60, 55,
1520 14, 13, 16, 24, 40, 57, 69, 56,
1521 14, 17, 22, 29, 51, 87, 80, 62,
1522 18, 22, 37, 56, 68, 109, 103, 77,
1523 24, 35, 55, 64, 81, 104, 113, 92,
1524 49, 64, 78, 87, 103, 121, 120, 101,
1525 72, 92, 95, 98, 112, 100, 103, 99
1526 };
1527 unsigned int std_chrominance_quant_tbl[DCTSIZE2] = {
1528 17, 18, 24, 47, 99, 99, 99, 99,
1529 18, 21, 26, 66, 99, 99, 99, 99,
1530 24, 26, 56, 99, 99, 99, 99, 99,
1531 47, 66, 99, 99, 99, 99, 99, 99,
1532 99, 99, 99, 99, 99, 99, 99, 99,
1533 99, 99, 99, 99, 99, 99, 99, 99,
1534 99, 99, 99, 99, 99, 99, 99, 99,
1535 99, 99, 99, 99, 99, 99, 99, 99
1536 };
1537
1538 tbl_num = 0;
1539 for(tbl_num = 0; tbl_num <= 1; tbl_num++ )
1540 {
1541 if (jpg_quant_tables[tbl_num] == 0)
1542 { jpg_quant_tables[tbl_num] = (xaLONG *)malloc(64 * sizeof(xaLONG));
1543 if (jpg_quant_tables[tbl_num] == 0)
1544 { fprintf(stderr,"JJ: DQT alloc err %x \n",tbl_num);
1545 return(xaFALSE);
1546 }
1547 }
1548 if (tbl_num == 0) table = std_luminance_quant_tbl;
1549 else table = std_chrominance_quant_tbl;
1550 quant_table = jpg_quant_tables[tbl_num];
1551 for (i = 0; i < DCTSIZE2; i++)
1552 { xaLONG tmp;
1553 tmp = ((long) table[i] * scale + 50L) / 100L;
1554 if (tmp <= 0) tmp = 1;
1555 if (tmp > 255) tmp = 255;
1556 /*
1557 quant_table[ JJ_ZAG[i] ] = (xaLONG) tmp;
1558 */
1559 quant_table[ i ] = (xaLONG) tmp;
1560 }
1561 }
1562 return(xaTRUE);
1563 }
1564 /*
1565 jcparam.c: static const unsigned int std_luminance_quant_tbl[DCTSIZE2] = {
1566 jcparam.c: static const unsigned int std_chrominance_quant_tbl[DCTSIZE2] = {
1567 jcparam.c: jpeg_add_quant_table(cinfo, 0, std_luminance_quant_tbl,
1568 jcparam.c: jpeg_add_quant_table(cinfo, 1, std_chrominance_quant_tbl,
1569 */
1570
jpg_search_marker(marker,data_ptr,data_size)1571 xaULONG jpg_search_marker(marker,data_ptr,data_size)
1572 xaULONG marker;
1573 xaUBYTE **data_ptr;
1574 xaLONG *data_size;
1575 { xaULONG d = 0;
1576 xaUBYTE *dptr = *data_ptr;
1577 xaLONG dsize = *data_size;
1578
1579 while( dsize )
1580 {
1581 if (d == 0xff) /* potential marker */
1582 {
1583 d = *dptr++; dsize--;
1584 if (d == marker)
1585 {
1586 *data_size = dsize; *data_ptr = dptr;
1587 return(xaTRUE); /* found marker */
1588 }
1589 } else { d = *dptr++; dsize--; }
1590 }
1591 *data_size = dsize; *data_ptr = dptr;
1592 return(xaFALSE);
1593 }
1594
JFIF_Read_IJPG_Tables(xin)1595 void JFIF_Read_IJPG_Tables(xin)
1596 XA_INPUT *xin;
1597 { int i;
1598 for(i=0;i<64;i++) IJPG_Tab1[i] = xin->Read_U8(xin);
1599 for(i=0;i<64;i++) IJPG_Tab2[i] = xin->Read_U8(xin);
1600 }
1601
1602 static char std_luminance_quant_tbl[64] = {
1603 16, 11, 12, 14, 12, 10, 16, 14,
1604 13, 14, 18, 17, 16, 19, 24, 40,
1605 26, 24, 22, 22, 24, 49, 35, 37,
1606 29, 40, 58, 51, 61, 60, 57, 51,
1607 56, 55, 64, 72, 92, 78, 64, 68,
1608 87, 69, 55, 56, 80, 109, 81, 87,
1609 95, 98, 103, 104, 103, 62, 77, 113,
1610 121, 112, 100, 120, 92, 101, 103, 99
1611 };
1612
1613 static char std_chrominance_quant_tbl[64] = {
1614 17, 18, 18, 24, 21, 24, 47, 26,
1615 26, 47, 99, 66, 56, 66, 99, 99,
1616 99, 99, 99, 99, 99, 99, 99, 99,
1617 99, 99, 99, 99, 99, 99, 99, 99,
1618 99, 99, 99, 99, 99, 99, 99, 99,
1619 99, 99, 99, 99, 99, 99, 99, 99,
1620 99, 99, 99, 99, 99, 99, 99, 99,
1621 99, 99, 99, 99, 99, 99, 99, 99
1622 };
1623
1624
JFIF_Init_IJPG_Tables(qfactor)1625 void JFIF_Init_IJPG_Tables(qfactor)
1626 int qfactor;
1627 { int i;
1628 for(i=0;i<64;i++) IJPG_Tab1[i] = qfactor * std_luminance_quant_tbl[i];
1629 for(i=0;i<64;i++) IJPG_Tab2[i] = qfactor * std_chrominance_quant_tbl[i];
1630 }
1631
1632 #define JPG_HANDLE_RST(rst_int,rst_cnt) { \
1633 if ( ((rst_int) && (rst_cnt==0)) ) \
1634 { jpg_h_bbuf = 0; jpg_h_bnum = 0; \
1635 DEBUG_LEVEL1 fprintf(stderr," jRST_INT %d rst_cnt %d\n", rst_int,rst_cnt); \
1636 if (jpg_marker == 0) jpg_marker = jpg_check_for_marker(); \
1637 if (jpg_marker) \
1638 { \
1639 if (jpg_marker == M_EOI) { jpg_saw_EOI = xaTRUE; return(xaTRUE); } \
1640 else if (jpg_marker == M_SOS) (void)jpg_read_SOS(); \
1641 else if ( !((jpg_marker >= M_RST0) && (jpg_marker <= M_RST7))) \
1642 {fprintf(stderr,"JPEG: unexp marker(%x)\n",jpg_marker); /*return(xaFALSE);*/} \
1643 jpg_marker = 0; \
1644 } \
1645 jpg_comps[0].dc = jpg_comps[1].dc = jpg_comps[2].dc = 0; \
1646 rst_cnt = rst_int; \
1647 } else rst_cnt--; }
1648
1649 #define JPG_TST_MARKER() \
1650 while(jpg_marker) \
1651 { DEBUG_LEVEL4 fprintf(stderr," jpg_marker(%x)\n",jpg_marker); \
1652 if (jpg_marker == M_EOI) { jpg_saw_EOI = xaTRUE; jpg_marker = 0; } \
1653 else if (jpg_marker == M_SOS) { (void)jpg_read_SOS(); jpg_marker = 0; } \
1654 else if ( (jpg_marker >= M_RST0) && (jpg_marker <= M_RST7) ) \
1655 { DEBUG_LEVEL1 fprintf(stderr,"JPEG: marker %x rst_cnt %x rst_int %x\n", \
1656 jpg_marker,rst_count,jpg_rst_interval); \
1657 jpg_comps[0].dc = jpg_comps[1].dc = jpg_comps[2].dc = 0; \
1658 rst_skip = rst_count; rst_count = jpg_rst_interval; \
1659 jpg_marker = 0; jpg_h_bbuf = 0; jpg_h_bnum = 0; \
1660 } \
1661 else /* Unknown or unexpected Marker */ \
1662 { fprintf(stderr,"JPEG: unexp marker(%x)\n",jpg_marker); \
1663 jpg_marker = jpg_skip_to_nxt_rst(); /* hopefully a RST marker */ \
1664 } \
1665 }
1666
1667
1668 /*******
1669 *
1670 */
jpg_decode_111111(image,width,height,interleave,row_offset,imagex,imagey,dec_info,gray)1671 xaULONG jpg_decode_111111(image,width,height,interleave,row_offset,
1672 imagex,imagey,dec_info,gray)
1673 xaUBYTE *image;
1674 xaULONG width,height,interleave,row_offset;
1675 xaULONG imagex,imagey;
1676 XA_DEC2_INFO *dec_info;
1677 xaULONG gray;
1678 {
1679 xaUBYTE *iptr = image;
1680 xaULONG map_flag = dec_info->map_flag;
1681 xaULONG *map = dec_info->map;
1682 XA_CHDR *chdr = dec_info->chdr;
1683 xaULONG x,mcu_cols,mcu_rows;
1684 xaLONG *qtab0,*qtab1,*qtab2;
1685 xaUBYTE *Ybuf,*Ubuf,*Vbuf;
1686 xaULONG rst_count;
1687 xaULONG rst_skip = 0;
1688 xaULONG orow_size = imagex * dec_info->bytes_pixel;
1689 void (*color_func)();
1690
1691 if (chdr) { if (chdr->new_chdr) chdr = chdr->new_chdr; }
1692
1693 if (gray) color_func = XA_MCU111111_To_Gray;
1694 else color_func = (void (*)())XA_MCU111111_Func(dec_info->image_type);
1695
1696 if (row_offset) iptr += row_offset * orow_size;
1697 orow_size *= interleave;
1698 if (interleave == 2) imagey >>= 1;
1699
1700 qtab0 = jpg_quant_tables[ jpg_comps[0].qtbl_num ];
1701 qtab1 = jpg_quant_tables[ jpg_comps[1].qtbl_num ];
1702 qtab2 = jpg_quant_tables[ jpg_comps[2].qtbl_num ];
1703
1704 mcu_cols = (width + 7) / 8;
1705 mcu_rows = (height + 7) / 8;
1706 if (gray)
1707 { DEBUG_LEVEL1 fprintf(stderr,"111111 gray MCUS %d,%d\n",mcu_cols,mcu_rows); }
1708 else { DEBUG_LEVEL1 fprintf(stderr,"111111 MCUS %d,%d\n",mcu_cols,mcu_rows); }
1709 jpg_marker = 0x00;
1710
1711 rst_count = jpg_rst_interval;
1712 while(mcu_rows--)
1713 {
1714 Ybuf = jpg_YUVBufs.Ybuf; Ubuf = jpg_YUVBufs.Ubuf; Vbuf = jpg_YUVBufs.Vbuf;
1715 x = mcu_cols;
1716 while(x--)
1717 {
1718 DEBUG_LEVEL1 fprintf(stderr," MCU XY %d,%d\n",x,mcu_rows);
1719
1720 if (rst_skip)
1721 {
1722 DEBUG_LEVEL1 fprintf(stderr," RST_SKIP: rst_skip %d\n",rst_skip);
1723 rst_skip--;
1724 if (Ybuf != jpg_YUVBufs.Ybuf)
1725 { xaUBYTE *prev;
1726 prev = Ybuf - DCTSIZE2;
1727 memcpy(Ybuf,prev,DCTSIZE2);
1728 Ybuf += DCTSIZE2;
1729 if (gray==0)
1730 { prev = Ubuf - DCTSIZE2; memcpy(Ubuf,prev,DCTSIZE2);
1731 prev = Vbuf - DCTSIZE2; memcpy(Vbuf,prev,DCTSIZE2);
1732 Ubuf += DCTSIZE2;
1733 Vbuf += DCTSIZE2;
1734 }
1735 }
1736 else
1737 {
1738 memset(Ybuf,0,DCTSIZE2);
1739 Ybuf += DCTSIZE2;
1740 if (gray==0)
1741 { memset(Ubuf,0x80,DCTSIZE2);
1742 memset(Vbuf,0x80,DCTSIZE2);
1743 Ubuf += DCTSIZE2;
1744 Vbuf += DCTSIZE2;
1745 }
1746 }
1747 }
1748 else
1749 {
1750 JPG_HANDLE_RST(jpg_rst_interval,rst_count);
1751
1752 jpg_huffparse(&jpg_comps[0],jpg_dct_buf,qtab0,Ybuf); Ybuf += DCTSIZE2;
1753 if (gray==0)
1754 {
1755 jpg_huffparse(&jpg_comps[1],jpg_dct_buf,qtab1,Ubuf); Ubuf += DCTSIZE2;
1756 jpg_huffparse(&jpg_comps[2],jpg_dct_buf,qtab2,Vbuf); Vbuf += DCTSIZE2;
1757 }
1758 if (jpg_marker == 0) jpg_marker = jpg_check_for_marker();
1759 JPG_TST_MARKER();
1760
1761 } /* end of rst_skip */
1762 } /* end of mcu_cols */
1763
1764 DEBUG_LEVEL1 fprintf(stderr,"imagey %d\n",imagey);
1765
1766 (void)(color_func)(iptr,imagex,xaMIN(imagey,8),(mcu_cols * DCTSIZE2),
1767 orow_size, &jpg_YUVBufs,&def_yuv_tabs, map_flag,map,chdr);
1768
1769 imagey -= 8; iptr += (orow_size << 3);
1770
1771 } /* end of mcu_rows */
1772 if (jpg_marker) { jpg_h_bbuf = 0; jpg_h_bnum = 0; }
1773 return(xaTRUE);
1774 }
1775
1776
1777 /*******
1778 *
1779 */
jpg_decode_211111(image,width,height,interleave,row_offset,imagex,imagey,dec_info)1780 xaULONG jpg_decode_211111(image,width,height,interleave,row_offset,
1781 imagex,imagey,dec_info)
1782 xaUBYTE *image;
1783 xaULONG width,height,interleave,row_offset;
1784 xaULONG imagex,imagey;
1785 XA_DEC2_INFO *dec_info;
1786 {
1787 xaUBYTE *iptr = image;
1788 xaULONG map_flag = dec_info->map_flag;
1789 xaULONG *map = dec_info->map;
1790 XA_CHDR *chdr = dec_info->chdr;
1791 xaULONG x,mcu_cols,mcu_rows;
1792 xaLONG *qtab0,*qtab1,*qtab2;
1793 xaUBYTE *Ybuf,*Ubuf,*Vbuf;
1794 xaULONG rst_count;
1795 xaULONG rst_skip = 0;
1796 xaULONG orow_size = imagex * dec_info->bytes_pixel;
1797 void (*color_func)() = (void (*)())XA_MCU211111_Func(dec_info->image_type);
1798
1799 if (chdr) { if (chdr->new_chdr) chdr = chdr->new_chdr; }
1800
1801 if (row_offset) iptr += row_offset * orow_size;
1802 orow_size *= interleave;
1803 if (interleave == 2) imagey >>= 1;
1804 imagex++; imagex >>= 1;
1805
1806 qtab0 = jpg_quant_tables[ jpg_comps[0].qtbl_num ];
1807 qtab1 = jpg_quant_tables[ jpg_comps[1].qtbl_num ];
1808 qtab2 = jpg_quant_tables[ jpg_comps[2].qtbl_num ];
1809
1810 mcu_cols = (width + 15) / 16;
1811 mcu_rows = (height + 7) / 8;
1812 DEBUG_LEVEL1 fprintf(stderr,"211111 begin MCUS(%d,%d)\n",mcu_cols,mcu_rows);
1813 jpg_marker = 0x00;
1814
1815 rst_count = jpg_rst_interval;
1816 while(mcu_rows--)
1817 {
1818 Ybuf = jpg_YUVBufs.Ybuf; Ubuf = jpg_YUVBufs.Ubuf; Vbuf = jpg_YUVBufs.Vbuf;
1819 x = mcu_cols;
1820 while(x--)
1821 { /* DEBUG_LEVEL1 fprintf(stderr,"MCU XY(%d,%d)\n", x,mcu_rows); */
1822
1823 if (rst_skip)
1824 {
1825 DEBUG_LEVEL1 fprintf(stderr," RST_SKIP: rst_skip\n");
1826 rst_skip--;
1827 memset(Ybuf,0,(DCTSIZE2 << 1));
1828 memset(Ubuf,0x80,DCTSIZE2);
1829 memset(Vbuf,0x80,DCTSIZE2);
1830 Ybuf += (DCTSIZE2 << 1);
1831 Ubuf += DCTSIZE2;
1832 Vbuf += DCTSIZE2;
1833 }
1834 else
1835 {
1836 JPG_HANDLE_RST(jpg_rst_interval,rst_count);
1837
1838 jpg_huffparse(&jpg_comps[0],jpg_dct_buf,qtab0,Ybuf); Ybuf += DCTSIZE2;
1839 jpg_huffparse(&jpg_comps[0],jpg_dct_buf,qtab0,Ybuf); Ybuf += DCTSIZE2;
1840 jpg_huffparse(&jpg_comps[1],jpg_dct_buf,qtab1,Ubuf); Ubuf += DCTSIZE2;
1841 jpg_huffparse(&jpg_comps[2],jpg_dct_buf,qtab2,Vbuf); Vbuf += DCTSIZE2;
1842
1843 if (jpg_marker == 0) jpg_marker = jpg_check_for_marker();
1844 JPG_TST_MARKER();
1845 }
1846 } /* end of mcu_cols */
1847
1848 if (width <= imagex) /* NOTE: imagex already >> 1 above */
1849 {
1850 JPG_Double_MCU(jpg_YUVBufs.Ybuf, (mcu_cols << 1) );
1851 JPG_Double_MCU(jpg_YUVBufs.Ubuf, mcu_cols);
1852 JPG_Double_MCU(jpg_YUVBufs.Vbuf, mcu_cols);
1853 (void)(color_func)(iptr,imagex,xaMIN(imagey,8),((mcu_cols<<1) * DCTSIZE2),
1854 orow_size, &jpg_YUVBufs,&def_yuv_tabs, map_flag,map,chdr);
1855 }
1856 else
1857 {
1858 (void)(color_func)(iptr,imagex,xaMIN(imagey,8),(mcu_cols * DCTSIZE2),
1859 orow_size, &jpg_YUVBufs,&def_yuv_tabs, map_flag,map,chdr);
1860 }
1861 imagey -= 8; iptr += (orow_size << 3);
1862
1863 } /* end of mcu_rows */
1864 if (jpg_marker) { jpg_h_bbuf = 0; jpg_h_bnum = 0; }
1865 return(xaTRUE);
1866 }
1867
1868
JPG_Double_MCU(ptr,mcus)1869 static void JPG_Double_MCU(ptr,mcus)
1870 xaUBYTE *ptr;
1871 int mcus;
1872 { xaUBYTE *sblk, *dblk;
1873 int blks = mcus * 8;
1874 int flag = 0;
1875
1876 sblk = ptr + (blks * 8) - 8;
1877 dblk = ptr + (blks * 16) - 8;
1878 while(blks--)
1879 { dblk[7] = dblk[6] = sblk[7];
1880 dblk[5] = dblk[4] = sblk[6];
1881 dblk[3] = dblk[2] = sblk[5];
1882 dblk[1] = dblk[0] = sblk[4];
1883 dblk -= 64;
1884 dblk[7] = dblk[6] = sblk[3];
1885 dblk[5] = dblk[4] = sblk[2];
1886 dblk[3] = dblk[2] = sblk[1];
1887 dblk[1] = dblk[0] = sblk[0];
1888 flag++;
1889 if (flag >= 8)
1890 {
1891 flag = 0;
1892 dblk -= 8;
1893 }
1894 else
1895 {
1896 dblk += 56;
1897 }
1898 sblk -= 8;
1899 }
1900 }
1901
1902
1903 /*******
1904 *
1905 */
jpg_decode_221111(image,width,height,interleave,row_offset,imagex,imagey,dec_info)1906 xaULONG jpg_decode_221111(image,width,height,interleave,row_offset,
1907 imagex,imagey,dec_info)
1908 xaUBYTE *image;
1909 xaULONG width,height,interleave,row_offset;
1910 xaLONG imagex,imagey;
1911 XA_DEC2_INFO *dec_info;
1912 { xaUBYTE *iptr = image;
1913 xaULONG map_flag = dec_info->map_flag;
1914 xaULONG *map = dec_info->map;
1915 XA_CHDR *chdr = dec_info->chdr;
1916 xaLONG x,mcu_cols,mcu_rows;
1917 xaLONG *qtab0,*qtab1,*qtab2;
1918 xaUBYTE *Ybuf,*Ubuf,*Vbuf;
1919 xaULONG rst_count;
1920 xaULONG rst_skip = 0;
1921 void (*color_func)() = (void (*)())XA_MCU221111_Func(dec_info->image_type);
1922 xaULONG orow_size = imagex * dec_info->bytes_pixel;
1923
1924 if (chdr) { if (chdr->new_chdr) chdr = chdr->new_chdr; }
1925
1926 if (row_offset) iptr += row_offset * orow_size;
1927 orow_size *= interleave;
1928 if (interleave == 2) imagey >>= 1;
1929 imagex++; imagex >>= 1; /* 2h */
1930 qtab0 = jpg_quant_tables[ jpg_comps[0].qtbl_num ];
1931 qtab1 = jpg_quant_tables[ jpg_comps[1].qtbl_num ];
1932 qtab2 = jpg_quant_tables[ jpg_comps[2].qtbl_num ];
1933
1934 mcu_cols = (width + 15) / 16;
1935 mcu_rows = (height + 15) / 16;
1936 DEBUG_LEVEL1 fprintf(stderr,"221111 begin MCUS(%d,%d)\n",mcu_cols,mcu_rows);
1937 jpg_marker = 0x00;
1938
1939 rst_count = jpg_rst_interval;
1940 while(mcu_rows--)
1941 { Ybuf = jpg_YUVBufs.Ybuf; Ubuf = jpg_YUVBufs.Ubuf; Vbuf = jpg_YUVBufs.Vbuf;
1942 x = mcu_cols; while(x--)
1943 { DEBUG_LEVEL1 fprintf(stderr," MCU XY(%d,%d)\n",x,mcu_rows);
1944
1945 if (rst_skip)
1946 {
1947 DEBUG_LEVEL1 fprintf(stderr," RST_SKIP: rst_skip\n");
1948 rst_skip--;
1949 memset(Ybuf,0,(DCTSIZE2 << 2));
1950 memset(Ubuf,0x80,DCTSIZE2);
1951 memset(Vbuf,0x80,DCTSIZE2);
1952 Ybuf += (DCTSIZE2 << 2);
1953 Ubuf += DCTSIZE2;
1954 Vbuf += DCTSIZE2;
1955 }
1956 else
1957 {
1958 JPG_HANDLE_RST(jpg_rst_interval,rst_count);
1959
1960 /* Y0 Y1 Y2 Y3 U V */
1961 jpg_huffparse(&jpg_comps[0],jpg_dct_buf,qtab0,Ybuf); Ybuf += DCTSIZE2;
1962 jpg_huffparse(&jpg_comps[0],jpg_dct_buf,qtab0,Ybuf); Ybuf += DCTSIZE2;
1963 jpg_huffparse(&jpg_comps[0],jpg_dct_buf,qtab0,Ybuf); Ybuf += DCTSIZE2;
1964 jpg_huffparse(&jpg_comps[0],jpg_dct_buf,qtab0,Ybuf); Ybuf += DCTSIZE2;
1965 jpg_huffparse(&jpg_comps[1],jpg_dct_buf,qtab1,Ubuf); Ubuf += DCTSIZE2;
1966 jpg_huffparse(&jpg_comps[2],jpg_dct_buf,qtab2,Vbuf); Vbuf += DCTSIZE2;
1967
1968 if (jpg_marker == 0) jpg_marker = jpg_check_for_marker();
1969 JPG_TST_MARKER();
1970 }
1971 } /* end of mcu_cols */
1972
1973 (void)(color_func)(iptr,imagex,xaMIN(imagey,16),(mcu_cols * DCTSIZE2),orow_size,
1974 &jpg_YUVBufs,&def_yuv_tabs,map_flag,map,chdr);
1975 imagey -= 16; iptr += (orow_size << 4);
1976
1977 } /* end of mcu_rows */
1978 if (jpg_marker) { jpg_h_bbuf = 0; jpg_h_bnum = 0; }
1979 DEBUG_LEVEL1 fprintf(stderr,"411: done\n");
1980 return(xaTRUE);
1981 }
1982
1983
1984
1985 /*******
1986 *
1987 */
jpg_decode_411111(image,width,height,interleave,row_offset,imagex,imagey,dec_info)1988 xaULONG jpg_decode_411111(image,width,height,interleave,row_offset,
1989 imagex,imagey,dec_info)
1990 xaUBYTE *image;
1991 xaULONG width,height,interleave,row_offset;
1992 xaLONG imagex,imagey;
1993 XA_DEC2_INFO *dec_info;
1994 { xaUBYTE *iptr = image;
1995 xaULONG map_flag = dec_info->map_flag;
1996 xaULONG *map = dec_info->map;
1997 XA_CHDR *chdr = dec_info->chdr;
1998 xaLONG x,mcu_cols,mcu_rows;
1999 xaLONG *qtab0,*qtab1,*qtab2;
2000 xaUBYTE *Ybuf,*Ubuf,*Vbuf;
2001 xaULONG rst_count;
2002 xaULONG rst_skip = 0;
2003 xaULONG orow_size = imagex * dec_info->bytes_pixel;
2004 void (*color_func)() = (void (*)())XA_MCU411111_Func(dec_info->image_type);
2005
2006 if (chdr) { if (chdr->new_chdr) chdr = chdr->new_chdr; }
2007
2008 if (row_offset) iptr += row_offset * orow_size;
2009 orow_size *= interleave;
2010 if (interleave == 2) imagey >>= 1;
2011 imagex +=3; imagex >>= 2; /* 4h */
2012 qtab0 = jpg_quant_tables[ jpg_comps[0].qtbl_num ];
2013 qtab1 = jpg_quant_tables[ jpg_comps[1].qtbl_num ];
2014 qtab2 = jpg_quant_tables[ jpg_comps[2].qtbl_num ];
2015
2016 mcu_cols = (width + 31) / 32;
2017 mcu_rows = (height + 7) / 8;
2018 DEBUG_LEVEL1 fprintf(stderr,"411111 begin MCUS(%d,%d)\n",mcu_cols,mcu_rows);
2019 jpg_marker = 0x00;
2020
2021 rst_count = jpg_rst_interval;
2022 while(mcu_rows--)
2023 { Ybuf = jpg_YUVBufs.Ybuf; Ubuf = jpg_YUVBufs.Ubuf; Vbuf = jpg_YUVBufs.Vbuf;
2024 x = mcu_cols; while(x--)
2025 { DEBUG_LEVEL1 fprintf(stderr," MCU XY(%d,%d)\n",x,mcu_rows);
2026
2027
2028 if (rst_skip)
2029 {
2030 DEBUG_LEVEL1 fprintf(stderr," RST_SKIP: rst_skip\n");
2031 rst_skip--;
2032 memset(Ybuf,0,(DCTSIZE2 << 2));
2033 memset(Ubuf,0x80,DCTSIZE2);
2034 memset(Vbuf,0x80,DCTSIZE2);
2035 Ybuf += (DCTSIZE2 << 2);
2036 Ubuf += DCTSIZE2;
2037 Vbuf += DCTSIZE2;
2038 }
2039 else
2040 {
2041 JPG_HANDLE_RST(jpg_rst_interval,rst_count);
2042
2043 /* Y0 Y1 Y2 Y3 U V */
2044 jpg_huffparse(&jpg_comps[0],jpg_dct_buf,qtab0,Ybuf); Ybuf += DCTSIZE2;
2045 jpg_huffparse(&jpg_comps[0],jpg_dct_buf,qtab0,Ybuf); Ybuf += DCTSIZE2;
2046 jpg_huffparse(&jpg_comps[0],jpg_dct_buf,qtab0,Ybuf); Ybuf += DCTSIZE2;
2047 jpg_huffparse(&jpg_comps[0],jpg_dct_buf,qtab0,Ybuf); Ybuf += DCTSIZE2;
2048 jpg_huffparse(&jpg_comps[1],jpg_dct_buf,qtab1,Ubuf); Ubuf += DCTSIZE2;
2049 jpg_huffparse(&jpg_comps[2],jpg_dct_buf,qtab2,Vbuf); Vbuf += DCTSIZE2;
2050
2051 if (jpg_marker == 0) jpg_marker = jpg_check_for_marker();
2052 JPG_TST_MARKER();
2053 }
2054 } /* end of mcu_cols */
2055
2056 (void)(color_func)(iptr,imagex,xaMIN(imagey,8),(mcu_cols * DCTSIZE2),orow_size,
2057 &jpg_YUVBufs,&def_yuv_tabs,map_flag,map,chdr);
2058 imagey -= 8; iptr += (orow_size << 3);
2059
2060 } /* end of mcu_rows */
2061 if (jpg_marker) { jpg_h_bbuf = 0; jpg_h_bnum = 0; }
2062 DEBUG_LEVEL1 fprintf(stderr,"411: done\n");
2063 return(xaTRUE);
2064 }
2065
2066
2067