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