home *** CD-ROM | disk | FTP | other *** search
/ Dream 44 / Amiga_Dream_44.iso / Linux / Apps / xanim.tgz / xanim / xanim27064 / xa_mpg.c < prev    next >
C/C++ Source or Header  |  1997-01-26  |  88KB  |  3,079 lines
  1.  
  2. /*
  3.  * xa_mpg.c
  4.  *
  5.  * Copyright (C) 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. /* The following copyright notice applies to some portions of the
  20.  * following code.
  21.  */
  22. /*
  23.  * Copyright (c) 1992 The Regents of the University of California.
  24.  * All rights reserved.
  25.  *
  26.  * Permission to use, copy, modify, and distribute this software and its
  27.  * documentation for any purpose, without fee, and without written agreement is
  28.  * hereby granted, provided that the above copyright notice and the following
  29.  * two paragraphs appear in all copies of this software.
  30.  *
  31.  * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
  32.  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
  33.  * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF
  34.  * CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  35.  *
  36.  * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
  37.  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  38.  * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  39.  * ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO
  40.  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  41.  */
  42.  
  43. /* Revision History
  44.  *
  45.  * 03apr95 - fixed bug with New quant scale. Wasn't flushing bits.
  46.  *        (typically caused HUFF ERRs)
  47.  * 03apr95 - fixed bug with height > width.(was showing bottom part of screen)
  48.  * 03apr95 - fixed incorrect warning message(DCT-A and DCT-B errs).
  49.  * 29jun95 - modified timing to account for skipped P and B frames.
  50.  * 22Aug95 - +F dithering to MPEG.
  51.  *
  52.  */
  53.  
  54. #include "xa_mpg.h"
  55. #include "xa_xmpg.h"
  56. #include "xa_color.h"
  57.  
  58. extern YUVBufs jpg_YUVBufs;
  59. extern YUVTabs def_yuv_tabs;
  60.  
  61. /* internal FUNCTIONS */
  62. xaULONG MPG_Read_File();
  63. xaULONG mpg_get_start_code();
  64. xaULONG mpg_read_SEQ_HDR();
  65. xaULONG mpg_read_GOP_HDR();
  66. xaULONG mpg_read_PIC_HDR();
  67. xaULONG MPG_Setup_Delta();
  68. xaULONG MPG_Decode_I();
  69. #ifdef NOTYET
  70. xaULONG MPG_Decode_P();
  71. xaULONG MPG_Decode_B();
  72. #endif
  73. void MPG_Init_Stuff();
  74. void mpg_init_motion_vectors();
  75. void mpg_init_mb_type_B();
  76. void mpg_init_mb_type_P();
  77. void mpg_init_mb_addr_inc();
  78. void MPG_Free_Stuff();
  79. void  decodeDCTDCSizeLum();
  80. void  decodeDCTDCSizeChrom();
  81. static void decodeDCTCoeff();
  82. void  decodeDCTCoeffFirst();
  83. void  decodeDCTCoeffNext();
  84. void mpg_huffparseI();
  85. void mpg_skip_extra_bitsB();
  86. void j_orig_rev_dct();
  87. void j_rev_dct();
  88.  
  89. extern xaLONG xa_dither_flag;
  90.  
  91. /* external FUNCTIONS */
  92. extern void XA_Gen_YUV_Tabs();
  93. extern void XA_MCU221111_To_RGB();
  94. extern void XA_MCU221111_To_CLR8();
  95. extern void XA_MCU221111_To_CLR16();
  96. extern void XA_MCU221111_To_CLR32();
  97. extern void XA_MCU221111_To_CF4();
  98. extern void XA_MCU221111_To_332_Dither();
  99. extern void XA_MCU221111_To_332();
  100.  
  101. XA_ACTION *ACT_Get_Action();
  102. extern XA_ANIM_SETUP *XA_Get_Anim_Setup();
  103. extern void XA_Add_Func_To_Free_Chain();
  104. void XA_Free_Anim_Setup();
  105. XA_CHDR   *ACT_Get_CMAP();
  106. XA_CHDR *CMAP_Create_332();
  107. XA_CHDR *CMAP_Create_Gray();
  108. XA_CHDR *CMAP_Create_CHDR_From_True();
  109. xaUBYTE *UTIL_RGB_To_Map();
  110. xaUBYTE *UTIL_RGB_To_FS_Map();
  111. void UTIL_FPS_2_Time();
  112. void ACT_Setup_Mapped();
  113. void ACT_Add_CHDR_To_Action();
  114. extern void JPG_Alloc_MCU_Bufs();
  115. extern void JPG_Setup_Samp_Limit_Table();
  116. extern xaULONG UTIL_Get_MSB_Long();
  117. extern void ACT_Setup_Delta();
  118. extern void CMAP_Cache_Init();
  119. extern void CMAP_Cache_Clear();
  120.  
  121. /* external Buffers */
  122. extern xaUBYTE *xa_byte_limit;
  123. extern int xa_vid_fd;
  124.  
  125. #define MPG_RDCT  j_rev_dct
  126. /* DON'T USE - NO xaLONGER THE SAME AS j_rev_dct
  127. #define MPG_RDCT j_orig_rev_dct
  128. */
  129.  
  130. xaSHORT mpg_dct_buf[64];
  131.  
  132. xaUBYTE  *mpg_buff = 0;
  133. xaLONG   mpg_bsize = 0;
  134.  
  135. /* BUFFER reading global vars */
  136. xaLONG   mpg_b_bnum;
  137. xaULONG  mpg_b_bbuf;
  138. XA_INPUT *mpg_f_file;
  139.  
  140. /* FILE reading global vars */
  141. xaLONG   mpg_f_bnum;  /* this must be signed */
  142. xaULONG  mpg_f_bbuf;
  143.  
  144. xaULONG mpg_init_flag = xaFALSE;
  145.  
  146. xaULONG mpg_start_code,mpg_count;
  147.  
  148. /*
  149. static xaUBYTE mpg_def_intra_qtab[64] = {
  150.     8,  16, 19, 22, 26, 27, 29, 34,
  151.     16, 16, 22, 24, 27, 29, 34, 37,
  152.     19, 22, 26, 27, 29, 34, 34, 38,
  153.     22, 22, 26, 27, 29, 34, 37, 40,
  154.     22, 26, 27, 29, 32, 35, 40, 48,
  155.     26, 27, 29, 32, 35, 40, 48, 58,
  156.     26, 27, 29, 34, 38, 46, 56, 69,
  157.     27, 29, 35, 38, 46, 56, 69, 83};
  158. */
  159.  
  160. /* my shifted version */
  161. static xaUBYTE mpg_def_intra_qtab[64] = {
  162.      8,16,19,22,22,26,26,27,
  163.     16,16,22,22,26,27,27,29,
  164.     19,22,26,26,27,29,29,35,
  165.     22,24,27,27,29,32,34,38,
  166.     26,27,29,29,32,35,38,46,
  167.     27,29,34,34,35,40,46,56,
  168.     29,34,34,37,40,48,56,69,
  169.     34,37,38,40,48,58,69,83 };
  170.  
  171.  
  172.  
  173. MPG_SEQ_HDR *mpg_seq_hdr;
  174.  
  175. MPG_PIC_HDR *mpg_pic_hdr,*mpg_Gpic_hdr;
  176. MPG_PIC_HDR *mpg_pic_start,*mpg_pic_cur;
  177.  
  178. /* used in xa_avi.c */
  179. xaUBYTE *mpg_dlta_buf = 0;
  180. xaULONG mpg_dlta_size = 0;
  181.  
  182.  
  183. typedef struct MPG_FRAME_STRUCT
  184. { xaULONG time;
  185.   xaULONG timelo;
  186.   XA_ACTION *act;
  187.   struct MPG_FRAME_STRUCT *next;
  188. } MPG_FRAME;
  189.  
  190. MPG_FRAME *MPG_Add_Frame();
  191. void MPG_Free_Frame_List();
  192. MPG_FRAME *mpg_frame_start,*mpg_frame_cur;
  193. xaULONG mpg_frame_cnt;
  194. xaULONG mpg_Icnt,mpg_Pcnt,mpg_Bcnt;
  195.  
  196. /*******
  197.  *
  198.  */
  199. #define MPG_INIT_FBUF(xin) \
  200.   { mpg_f_file = xin; mpg_f_bnum = 0; mpg_f_bbuf = 0; }
  201.  
  202. /*******
  203.  *
  204.  */
  205. #define MPG_INIT_BBUF(buff,bsize) \
  206. { mpg_buff = buff; mpg_bsize = bsize; \
  207.   mpg_b_bnum = 0; mpg_b_bbuf = 0; \
  208. }
  209.  
  210. /*******
  211.  *
  212.  */
  213. #define MPG_BIT_MASK(s) ((1 << (s)) - 1)
  214.  
  215. /*******
  216.  *
  217.  */
  218. #define MPG_GET_BBITS(num,result) \
  219. { while(mpg_b_bnum < (num)) { mpg_b_bnum += 8; mpg_bsize--; \
  220.         mpg_b_bbuf = (*mpg_buff++) | (mpg_b_bbuf << 8); } \
  221.   mpg_b_bnum -= (num); \
  222.   (result) = ((mpg_b_bbuf >> mpg_b_bnum) & MPG_BIT_MASK(num)); \
  223. }
  224.  
  225. /* ROUGH CHECK */
  226. #define MPG_CHECK_BBITS(num,result) \
  227. { result = (mpg_bsize > (num))?(xaTRUE):(xaFALSE); }
  228.  
  229. #define MPG_NXT_BBITS(num,result) \
  230. { while(mpg_b_bnum < (num)) { mpg_b_bnum += 8; mpg_bsize--; \
  231.         mpg_b_bbuf = (*mpg_buff++) | (mpg_b_bbuf << 8); } \
  232.   result = (mpg_b_bbuf >> (mpg_b_bnum - num)) & MPG_BIT_MASK(num); \
  233. }
  234.  
  235. #define MPG_FLUSH_BBITS(num) \
  236. { while(mpg_b_bnum < (num)) { mpg_b_bnum += 8; mpg_bsize--; \
  237.         mpg_b_bbuf = (*mpg_buff++) | (mpg_b_bbuf << 8); } \
  238.   mpg_b_bnum -= (num); \
  239. }
  240.  
  241.  
  242. /*******
  243.  *
  244.  */
  245. #define MPG_GET_FBITS(num,result) \
  246. { while(mpg_f_bnum < (num)) { mpg_f_bnum += 8; mpg_count++; \
  247.     mpg_f_bbuf = (mpg_f_file->Read_U8(mpg_f_file)) | (mpg_f_bbuf << 8); } \
  248.   mpg_f_bnum -= (num); \
  249.   result = (mpg_f_bbuf >> mpg_f_bnum) & MPG_BIT_MASK(num); \
  250. }
  251.  
  252. #define MPG_ALIGN_FBUF() { mpg_f_bnum -= (mpg_f_bnum % 8); }
  253.  
  254. void MPG_Time_Adjust(mpg,ret_time,ret_timelo,skipped_frames)
  255. XA_ANIM_SETUP *mpg;
  256. xaULONG *ret_time;
  257. xaULONG *ret_timelo;
  258. xaULONG skipped_frames;
  259. { xaULONG t_time   = mpg->vid_time;
  260.   xaULONG t_timelo = mpg->vid_timelo;
  261.   if (skipped_frames)
  262.   {
  263.     while(skipped_frames--)
  264.     {
  265.       t_time   += mpg->vid_time;
  266.       t_timelo += mpg->vid_timelo;
  267.       while(t_timelo > (1<<24)) {t_time++; t_timelo -= (1<<24);}
  268.     }
  269.   }
  270.   *ret_time   = t_time;
  271.   *ret_timelo = t_timelo;
  272. }
  273.  
  274. /*******
  275.  *
  276.  */
  277. MPG_FRAME *MPG_Add_Frame(time,timelo,act)
  278. xaULONG time,timelo;
  279. XA_ACTION *act;
  280. { MPG_FRAME *fframe;
  281.  
  282.   fframe = (MPG_FRAME *) malloc(sizeof(MPG_FRAME));
  283.   if (fframe == 0) TheEnd1("MPG_Add_Frame: malloc err");
  284.   fframe->time   = time;
  285.   fframe->timelo = timelo;
  286.   fframe->act = act;
  287.   fframe->next = 0;
  288.  
  289.   if (mpg_frame_start == 0) mpg_frame_start = fframe;
  290.   else mpg_frame_cur->next = fframe;
  291.  
  292.   mpg_frame_cur = fframe;
  293.   mpg_frame_cnt++;
  294.   return(fframe);
  295. }
  296.  
  297. /*******
  298.  *
  299.  */
  300. void MPG_Free_Frame_List(fframes)
  301. MPG_FRAME *fframes;
  302. { MPG_FRAME *ftmp;
  303.   while(fframes != 0)
  304.   { ftmp = fframes;
  305.     fframes = fframes->next;
  306.     FREE(ftmp,0xA000);
  307.   }
  308. }
  309.  
  310.  
  311. xaULONG MPG_Read_File(fname,anim_hdr)
  312. char *fname;
  313. XA_ANIM_HDR *anim_hdr;
  314. { XA_INPUT *xin = anim_hdr->xin;
  315.   xaULONG i,t_timelo;
  316.   xaULONG t_time;
  317.   xaULONG skipped_frames = 0;
  318.   XA_ANIM_SETUP *mpg;
  319.  
  320.   mpg = XA_Get_Anim_Setup();
  321.   mpg->vid_time = XA_GET_TIME( 200 ); /* default */
  322.   mpg->cmap_frame_num = 20;  /* ?? how many frames in file?? */
  323.  
  324.   mpg_frame_cnt = 0;
  325.   mpg_frame_cur = mpg_frame_start = 0;
  326.   mpg_Icnt = mpg_Pcnt = mpg_Bcnt = 0;
  327.   mpg_Gpic_hdr = mpg_pic_hdr = 0;
  328.   mpg_pic_start = mpg_pic_cur = 0;
  329.  
  330.   mpg_seq_hdr = 0;
  331.  
  332.   /* Initialize tables and setup for Dying Time */
  333.   MPG_Init_Stuff(anim_hdr);
  334.  
  335.    /* find file size */
  336.   MPG_INIT_FBUF(xin); /* init file bit buffer */
  337.   if (mpg_get_start_code() == xaFALSE) return(xaFALSE);
  338.   while( !mpg_f_file->At_EOF(mpg_f_file,-1) )
  339.   { xaULONG ret,need_nxt_flag = xaTRUE;
  340.  
  341.     DEBUG_LEVEL1 fprintf(stderr,"MPG CODE %x cnt %x\n",
  342.                         mpg_start_code,mpg_count);
  343.     if (mpg_start_code == MPG_SEQ_START)
  344.     { XA_ACTION *act = 0;
  345.       act = ACT_Get_Action(anim_hdr,ACT_NOP);
  346.       mpg_seq_hdr = (MPG_SEQ_HDR *)malloc(sizeof(MPG_SEQ_HDR));
  347.       act->data = (xaUBYTE *)mpg_seq_hdr;
  348.       mpg_read_SEQ_HDR(anim_hdr,mpg,mpg_seq_hdr);
  349.     }
  350.     else if (mpg_start_code == MPG_PIC_START)
  351.     {
  352.       if (mpg_Gpic_hdr==0)
  353.       { XA_ACTION *act = 0;
  354.         act = ACT_Get_Action(anim_hdr,ACT_NOP);
  355.         mpg_Gpic_hdr = (MPG_PIC_HDR *)malloc(sizeof(MPG_PIC_HDR));
  356.         act->data = (xaUBYTE *)mpg_Gpic_hdr;
  357.         mpg_Gpic_hdr->slice_1st = mpg_Gpic_hdr->slice_last = 0;
  358.     mpg_Gpic_hdr->slice_cnt = 0;
  359.     mpg_Gpic_hdr->slices[0].fsize = 0;
  360.     mpg_Gpic_hdr->slices[0].act   = 0;
  361.       }
  362.       mpg_read_PIC_HDR(mpg_Gpic_hdr);
  363.       mpg_Gpic_hdr->seq_hdr = mpg_seq_hdr;
  364.  
  365.       mpg->compression = mpg_Gpic_hdr->type;
  366.       mpg_pic_hdr = 0;
  367.       switch(mpg->compression)
  368.       {
  369.     case MPG_TYPE_I: 
  370.       { XA_ACTION *act = 0;
  371.         act = ACT_Get_Action(anim_hdr,ACT_NOP);
  372.         mpg_pic_hdr = (MPG_PIC_HDR *)malloc(sizeof(MPG_PIC_HDR));
  373.         if (mpg_pic_hdr==0) TheEnd1("MPG: pic_hdr malloc err");
  374.         memcpy((char *)mpg_pic_hdr,(char *)mpg_Gpic_hdr,
  375.                         sizeof(MPG_PIC_HDR));
  376.         act->data = (xaUBYTE *)mpg_pic_hdr;
  377.         mpg_pic_hdr->slice_1st = mpg_pic_hdr->slice_last = 0;
  378.         mpg_pic_hdr->slice_cnt = 0;
  379.         mpg_pic_hdr->slices[0].fsize = 0;
  380.         mpg_pic_hdr->slices[0].act   = 0;
  381.         MPG_Time_Adjust(mpg,&t_time,&t_timelo,skipped_frames);
  382.         skipped_frames = 0;
  383.             MPG_Add_Frame(t_time,t_timelo, act);
  384.  
  385.       }
  386.       mpg_Icnt++; 
  387.       break;
  388.     case MPG_TYPE_P: mpg_Pcnt++; skipped_frames++; break;
  389.     case MPG_TYPE_B: mpg_Bcnt++; skipped_frames++; break;
  390.     default: 
  391.       fprintf(stderr,"MPG Unk type %x\n",mpg->compression);
  392.       break;
  393.       }
  394.     }
  395.     else if (mpg_start_code == MPG_UNK_BE)
  396.         { DEBUG_LEVEL1 fprintf(stderr,"MPG: BE code  - ignored\n"); }
  397.     else if (mpg_start_code == MPG_PACK_START)
  398.         { DEBUG_LEVEL1 fprintf(stderr,"MPG: BA code  - ignored\n"); }
  399.     else if (mpg_start_code == MPG_SYS_START)
  400.         { DEBUG_LEVEL1 fprintf(stderr,"MPG: BB code  - ignored\n"); }
  401.     else if (mpg_start_code == MPG_UNK_BC)
  402.         { DEBUG_LEVEL1 fprintf(stderr,"MPG: BC code  - ignored\n"); }
  403.     else if (mpg_start_code == MPG_UNK_C0)
  404.         { DEBUG_LEVEL1 fprintf(stderr,"MPG: C0 code  - ignored\n"); }
  405.     else if (mpg_start_code == MPG_GOP_START)    mpg_read_GOP_HDR();
  406.     else if (mpg_start_code == MPG_SEQ_END)    break; /* END??? */
  407.     else if (mpg_start_code == MPG_USR_START)    
  408.     { DEBUG_LEVEL1 fprintf(stderr,"USR START:\n"); }
  409.     else if (mpg_start_code == MPG_EXT_START)    
  410.     { DEBUG_LEVEL1 fprintf(stderr,"EXT START:\n"); }
  411.     else if (   (mpg_start_code >= MPG_MIN_SLICE)
  412.          && (mpg_start_code <= MPG_MAX_SLICE) )
  413.     { xaULONG except_flag = 0;
  414.       DEBUG_LEVEL1 fprintf(stderr,"SLICE %x\n",mpg_start_code);
  415.       if (mpg_seq_hdr == 0)
  416.        { fprintf(stderr,"Slice without Sequence Header Err\n"); break; }
  417.       if (   (mpg->compression == MPG_TYPE_I)
  418.       && (mpg_pic_hdr == 0) )  /* assume old Xing and create one */
  419.       { XA_ACTION *tmp_act;
  420.     fprintf(stderr,"slice without pic hdr err\n");
  421.         except_flag = 1;
  422.     tmp_act = ACT_Get_Action(anim_hdr,ACT_NOP);
  423.     mpg_pic_hdr = (MPG_PIC_HDR *)malloc(sizeof(MPG_PIC_HDR));
  424.     if (mpg_pic_hdr==0) TheEnd1("MPG: pic_hdr malloc err");
  425.     mpg_pic_hdr->seq_hdr = mpg_seq_hdr;
  426.     mpg->compression = mpg_pic_hdr->type = MPG_TYPE_I;
  427.     tmp_act->data = (xaUBYTE *)mpg_pic_hdr;
  428.     mpg_pic_hdr->slice_1st = mpg_pic_hdr->slice_last = 0;
  429.     mpg_pic_hdr->slice_cnt = 0;
  430.     mpg_pic_hdr->slices[0].fsize = 0;
  431.     mpg_pic_hdr->slices[0].act   = 0;
  432.     MPG_Time_Adjust(mpg,&t_time,&t_timelo,skipped_frames);
  433.     skipped_frames = 0;
  434.     MPG_Add_Frame(t_time,t_timelo, tmp_act);
  435.       }
  436.       if ( (mpg->compression == MPG_TYPE_I) && (mpg_pic_hdr))
  437.       { MPG_SLICE_HDR *slice_hdr;
  438.         XA_ACTION *act = 0;
  439.  
  440.     /* alloc SLICE_HDR and ADD to current PIC_HDR */
  441.     act = ACT_Get_Action(anim_hdr,ACT_NOP);
  442.     slice_hdr = (MPG_SLICE_HDR *)malloc(sizeof(MPG_SLICE_HDR));
  443.     act->data = (xaUBYTE *)slice_hdr;
  444.     slice_hdr->next = 0;
  445.     slice_hdr->act  = act;
  446.     if (mpg_pic_hdr->slice_1st) mpg_pic_hdr->slice_last->next = slice_hdr;
  447.     else                mpg_pic_hdr->slice_1st = slice_hdr;
  448.         mpg_pic_hdr->slice_last = slice_hdr;
  449.     mpg_pic_hdr->slice_cnt++;
  450.  
  451.     slice_hdr->vert_pos = mpg_start_code & 0xff;
  452.     slice_hdr->fpos = mpg_f_file->Get_FPos(mpg_f_file);
  453.     mpg_count = 0;
  454.     ret = mpg_get_start_code(); need_nxt_flag = xaFALSE;
  455.     slice_hdr->fsize = mpg_count; /* get slice size */
  456.     if (mpg_count > mpg->max_fvid_size) mpg->max_fvid_size = mpg_count;
  457.       }
  458.       if (except_flag) mpg_pic_hdr = 0; /* one slice only per pic_hdr*/
  459.     }
  460. #ifdef NOTHING
  461.     else if (mpg_start_code == MPG_UNK_E0)  /* Slice Continuation */
  462.     { xaULONG sys_clk_ref, mux_rate;
  463.       { MPG_SLICE_HDR *slice_hdr;
  464.         XA_ACTION *act = 0;
  465.  
  466.         /* alloc SLICE_HDR and ADD to current PIC_HDR */
  467.         act = ACT_Get_Action(anim_hdr,ACT_NOP);
  468.         slice_hdr = (MPG_SLICE_HDR *)malloc(sizeof(MPG_SLICE_HDR));
  469.         act->data = (xaUBYTE *)slice_hdr;
  470.         slice_hdr->next = 0;
  471.         slice_hdr->act  = act;
  472.         if (mpg_pic_hdr->slice_1st) mpg_pic_hdr->slice_last->next = slice_hdr;
  473.         else                        mpg_pic_hdr->slice_1st = slice_hdr;
  474.         mpg_pic_hdr->slice_last = slice_hdr;
  475.         mpg_pic_hdr->slice_cnt++;
  476.  
  477.         slice_hdr->vert_pos = mpg_start_code & 0xff;
  478.         slice_hdr->fpos = mpg_f_file->Get_FPos(mpg_f_file);
  479.         mpg_count = 0;
  480.         ret = mpg_get_start_code(); need_nxt_flag = xaFALSE;
  481.         slice_hdr->fsize = mpg_count; /* get slice size */
  482.         if (mpg_count > mpg->max_fvid_size) mpg->max_fvid_size = mpg_count;
  483.       }
  484.     }
  485. #endif
  486.     else
  487.     {
  488.       fprintf(stderr,"MPG_UNK CODE: %02x\n",mpg_start_code);
  489.     }
  490.  
  491.     /* get next if necessary */
  492.     if (need_nxt_flag == xaTRUE) ret = mpg_get_start_code(); 
  493.     if (ret == xaFALSE) break;
  494.   } /* end of while forever */
  495.  
  496.   if (mpg_frame_cnt == 0)
  497.   { fprintf(stderr,"MPG: No supported video frames exist in this file.\n");
  498.     return(xaFALSE);
  499.   }
  500.   if (xa_verbose)
  501.     fprintf(stdout,"MPG %dx%d frames %d  I's %d  P's %d  B's %d\n",
  502.       mpg->imagex,mpg->imagey,mpg_frame_cnt,mpg_Icnt,mpg_Pcnt,mpg_Bcnt);
  503.  
  504.   mpg_pic_hdr = 0; /* force err if used */
  505.  
  506.   /* Adjust Temporary Data Structures into Final Organization */
  507.   mpg_frame_cur = mpg_frame_start;
  508.   while(mpg_frame_cur != 0)
  509.   { XA_ACTION *phdr_act = mpg_frame_cur->act;
  510.     MPG_PIC_HDR *phdr = (MPG_PIC_HDR *)(phdr_act->data);
  511.     xaULONG slice_cnt = phdr->slice_cnt;
  512.  
  513.     if (slice_cnt == 0) 
  514.     {
  515.       fprintf(stderr,"MPG scnt 0 err - deal mit later\n");
  516.     }
  517.     else
  518.     { MPG_PIC_HDR  *new_phdr;
  519.       ACT_DLTA_HDR *dlta_hdr;
  520.       MPG_SLICE_HDR *shdr;
  521.       xaULONG s_cnt;
  522.  
  523.       DEBUG_LEVEL1 fprintf(stderr,"MPG: Rearranging Structures\n");
  524.  
  525.        /* alloc new pic_hdr with slice array at end */
  526.       s_cnt = (sizeof(ACT_DLTA_HDR)) + (sizeof(MPG_PIC_HDR));
  527.       s_cnt += ( (slice_cnt + 1) * (sizeof(MPG_SLICE_HDR)) );
  528.       dlta_hdr = (ACT_DLTA_HDR *)malloc( s_cnt );
  529.  
  530.       if (dlta_hdr == 0) TheEnd1("MPG dlta malloc err");
  531.       phdr_act->data = (xaUBYTE *)dlta_hdr; /* old saved in phdr */
  532.  
  533.       dlta_hdr->flags = DLTA_DATA;
  534.       dlta_hdr->fpos = dlta_hdr->fsize = 0;
  535.  
  536.       new_phdr = (MPG_PIC_HDR *)(dlta_hdr->data);
  537.         /* copy old phdr to new phdr */
  538.       memcpy((char *)new_phdr,(char *)phdr,sizeof(MPG_PIC_HDR));
  539.  
  540.       s_cnt = 0;
  541.       shdr = phdr->slice_1st;
  542.       while(shdr)
  543.       { XA_ACTION *s_act = shdr->act;
  544.     xaULONG fpos,fsize;
  545.         new_phdr->slices[s_cnt].vert_pos    = shdr->vert_pos;
  546.         new_phdr->slices[s_cnt].fpos =   fpos      = shdr->fpos;
  547.         new_phdr->slices[s_cnt].fsize =  fsize    = shdr->fsize;
  548.         new_phdr->slices[s_cnt].act        = shdr->act;
  549.         shdr = shdr->next; /* move on */
  550.     s_cnt++;
  551.  
  552.         free(s_act->data); s_act->data = 0;
  553.         if ( (xa_buffer_flag == xaFALSE) && (xa_file_flag == xaFALSE) )
  554.         {  /* need to read in the data */
  555.           xaUBYTE *tmp = 0;
  556.           mpg_f_file->Seek_FPos(mpg_f_file,fpos,0);
  557.           tmp = (xaUBYTE *)malloc( fsize );
  558.           if (tmp==0) TheEnd1("MPG: alloc err 3");
  559.           mpg_f_file->Read_Block(mpg_f_file,(char *)tmp,fsize);
  560.           s_act->data = tmp;
  561.         }
  562.       }
  563.       new_phdr->slices[s_cnt].fpos  = 0;
  564.       new_phdr->slices[s_cnt].fsize = 0;
  565.       new_phdr->slices[s_cnt].act   = 0;
  566.       free(phdr); phdr = 0; /* not phdr_act->data already reassigned */
  567.       phdr_act->type = ACT_DELTA;
  568.       MPG_Setup_Delta(mpg,fname,phdr_act);
  569.     }
  570.     mpg_frame_cur = mpg_frame_cur->next; /* move on */
  571.   }
  572.   xin->Close_File(xin);
  573.   if (mpg->pic) { free(mpg->pic); mpg->pic = 0; }
  574.  
  575.   anim_hdr->frame_lst = (XA_FRAME *)
  576.                                 malloc( sizeof(XA_FRAME) * (mpg_frame_cnt+1));
  577.   if (anim_hdr->frame_lst == NULL) TheEnd1("MPG_Read_File: frame malloc err");
  578.  
  579.  
  580.   mpg_frame_cur = mpg_frame_start;
  581.   i = 0;
  582.   t_time = 0;
  583.   t_timelo = 0;
  584.   while(mpg_frame_cur != 0)
  585.   { if (i > mpg_frame_cnt)
  586.     { fprintf(stderr,"MPG_Read_Anim: frame inconsistency %d %d\n",
  587.                 i,mpg_frame_cnt);
  588.       break;
  589.     }
  590.     anim_hdr->frame_lst[i].time_dur = mpg_frame_cur->time;
  591.     anim_hdr->frame_lst[i].zztime = t_time;
  592.     t_time += mpg_frame_cur->time;
  593.     t_timelo += mpg_frame_cur->timelo;
  594.     while(t_timelo > (1<<24)) {t_time++; t_timelo -= (1<<24);}
  595.     anim_hdr->frame_lst[i].act = mpg_frame_cur->act;
  596.     mpg_frame_cur = mpg_frame_cur->next;
  597.     i++;
  598.   }
  599.   anim_hdr->imagex = mpg->imagex;
  600.   anim_hdr->imagey = mpg->imagey;
  601.   anim_hdr->imagec = mpg->imagec;
  602.   anim_hdr->imaged = 8; /* nop */
  603.   anim_hdr->frame_lst[i].time_dur = 0;
  604.   anim_hdr->frame_lst[i].zztime = -1;
  605.   anim_hdr->frame_lst[i].act  = 0;
  606.   anim_hdr->loop_frame = 0;
  607.   if (xa_buffer_flag == xaFALSE) anim_hdr->anim_flags |= ANIM_SNG_BUF;
  608.   if (xa_file_flag == xaTRUE) anim_hdr->anim_flags |= ANIM_USE_FILE;
  609.   anim_hdr->anim_flags |= ANIM_FULL_IM;
  610.   anim_hdr->max_fvid_size = 0; /* all buffering internal */
  611.   anim_hdr->max_faud_size = 0; /* mpg_max_faud_size; */
  612.   anim_hdr->fname = anim_hdr->name;
  613.   if (i > 0)
  614.   {
  615.     anim_hdr->last_frame = i - 1;
  616.     anim_hdr->total_time = anim_hdr->frame_lst[i-1].zztime
  617.                                 + anim_hdr->frame_lst[i-1].time_dur;
  618.   }
  619.   else
  620.   {
  621.     anim_hdr->last_frame = 0;
  622.     anim_hdr->total_time = 0;
  623.   }
  624.   MPG_Free_Frame_List(mpg_frame_start);
  625.   XA_Free_Anim_Setup(mpg);
  626.   return(xaTRUE);
  627. }
  628.  
  629. /******************
  630.  *  Look for 0x00 0x00 0x01 MPEG Start Code
  631.  *****/
  632. xaULONG mpg_get_start_code()
  633. { xaLONG d; xaULONG state = 0;
  634.   MPG_ALIGN_FBUF(); /* make mpg_f_bnum multiple of 8 */
  635.   while( !mpg_f_file->At_EOF(mpg_f_file) )
  636.   { 
  637.  
  638. /*
  639.     MPG_GET_FBITS(8,d);
  640. */
  641.     if (mpg_f_bnum > 0)
  642.     { 
  643. fprintf(stderr,"FBITS: %d %x\n",mpg_f_bnum,mpg_f_bbuf);
  644.  
  645.        mpg_f_bnum -= 8; d = (mpg_f_bbuf >> mpg_f_bnum) & 0xff;
  646.     }
  647.     else d =  mpg_f_file->Read_U8(mpg_f_file);
  648.     if (d >= 0) mpg_count++;
  649.  
  650. /* DEBUG_LEVEL1 fprintf(stderr,"GET_CODE: st(%d) d=%x\n",state,d); */
  651.     if (state == 3) 
  652.     { 
  653.       mpg_start_code = d;
  654.       mpg_f_bnum = 0; mpg_f_bbuf = 0;
  655.       return(xaTRUE);
  656.     }
  657.     else if (state == 2)
  658.     { if (d==0x01) state = 3;
  659.       else if (d==0x00) state = 2; 
  660.       else state = 0;
  661.     }
  662.     else
  663.     { if (d==0x00) state++; 
  664.       else state = 0; 
  665.     }
  666.   }
  667.   return(xaFALSE);
  668. }
  669.  
  670. /*****
  671.  *
  672.  */
  673. void mpg_skip_extra_bitsB()
  674. { xaULONG i,f;
  675.   DEBUG_LEVEL1 fprintf(stderr,"MPG Extra:\n");
  676.   i = 0;
  677.   f = 1; 
  678.   while(f)
  679.   { xaULONG d;
  680.     MPG_GET_BBITS(1,f);
  681.     if (f) 
  682.     { MPG_GET_BBITS(8,d);
  683.       DEBUG_LEVEL1
  684.       { fprintf(stderr,"%02x ",d);
  685.     i++; if (i >=8) {i=0; fprintf(stderr,"\n"); }
  686.       }
  687.     }
  688.   }
  689.   DEBUG_LEVEL1 if (i) fprintf(stderr,"\n");
  690. }
  691.  
  692.  
  693. /*******
  694.  *  12 bits width
  695.  *  12 bits height
  696.  *   4 bits aspect ratio
  697.  *   4 bits picture rate
  698.  *
  699.  *  18 bits bit rate
  700.  *   1 bit  marker bit
  701.  *  10 bits vbv buffer size
  702.  *   1 bit  constrained param flag(1 = xaTRUE, 0 = xaFALSE)
  703.  *   1 bit  intra quant flag(1 = xaTRUE, 0 = xaFALSE)
  704.  *      if (1) get 64 * 8 bits for intra quant table
  705.  *   1 bit  non-intra quant flag(1 = xaTRUE, 0 = xaFALSE)
  706.  *      if (1) get 64 * 8 bits for non-intra quant table
  707.  */
  708.  
  709. /*Xing Added 9; */
  710. /* Is 9 12 fps or 15 fps ?? */
  711. xaULONG mpg_pic_rate_idx[] = {30,24,24,25,30,30,50,60,60,12,30,30,30,30,30,30};
  712.  
  713. xaULONG mpg_const_param,mpg_intra_q_flag,mpg_nonintra_q_flag;
  714.  
  715. xaULONG mpg_read_SEQ_HDR(anim_hdr,mpg,shdr)
  716. XA_ANIM_HDR *anim_hdr;
  717. XA_ANIM_SETUP *mpg;
  718. MPG_SEQ_HDR *shdr;
  719. { xaULONG i,d,marker;
  720.   d = 0;
  721. DEBUG_LEVEL1 fprintf(stderr,"MPG_SEQ_START: \n");
  722.   MPG_GET_FBITS(12,shdr->width);
  723.   MPG_GET_FBITS(12,shdr->height);
  724.   MPG_GET_FBITS(4,shdr->aspect);
  725.   MPG_GET_FBITS(4,shdr->pic_rate);
  726.   MPG_GET_FBITS(18,shdr->bit_rate);
  727.   MPG_GET_FBITS(1,marker);
  728.   MPG_GET_FBITS(10,shdr->vbv_buff_size);
  729.   MPG_GET_FBITS(1,shdr->constrained);
  730.   MPG_GET_FBITS(1,shdr->intra_flag);
  731.  
  732. /*POD TEMP */
  733. if (xa_verbose) fprintf(stderr,"MPEG Pic rate: %x\n",shdr->pic_rate);
  734.  
  735.   UTIL_FPS_2_Time(mpg, ((double)(mpg_pic_rate_idx[shdr->pic_rate])) );
  736.  
  737.   if (shdr->intra_flag)
  738.   { for(i=0; i < 64; i++)  
  739.     { MPG_GET_FBITS(8,d); shdr->intra_qtab[i] = d;  /* ZIG */
  740.     }
  741.   }
  742.   else
  743.   { for(i=0; i < 64;i++)  
  744.     { shdr->intra_qtab[i] = mpg_def_intra_qtab[i];  /* NO-ZIG */
  745.     }
  746.   }
  747.   MPG_GET_FBITS(1,shdr->non_intra_flag);
  748.   if (mpg_nonintra_q_flag)
  749.   { for(i=0; i < 64; i++)  
  750.     { MPG_GET_FBITS(8,d); shdr->non_intra_qtab[i] = d; 
  751.     } 
  752.   }
  753. /*POD TEMP until real fix */
  754.   mpg->imagex = shdr->width;
  755.   if (mpg->imagex & 1) { mpg->imagex++; shdr->width++; }
  756.   mpg->imagey = shdr->height;
  757.   if (mpg->imagey & 1) { mpg->imagey++; shdr->height++; }
  758.  
  759.   JPG_Alloc_MCU_Bufs(anim_hdr,mpg->imagex,mpg->imagey,xaTRUE);
  760.   mpg->depth = 24; 
  761.   XA_Gen_YUV_Tabs(anim_hdr);
  762.   JPG_Setup_Samp_Limit_Table(anim_hdr);
  763.  
  764.   if (   (cmap_true_map_flag == xaFALSE) /* depth 16 and not true_map */
  765.       || (xa_buffer_flag == xaFALSE) )
  766.   {
  767.      if (cmap_true_to_332 == xaTRUE)
  768.              mpg->chdr = CMAP_Create_332(mpg->cmap,&mpg->imagec);
  769.      else    mpg->chdr = CMAP_Create_Gray(mpg->cmap,&mpg->imagec);
  770.   }
  771.   if ( (mpg->pic==0) && (xa_buffer_flag == xaTRUE))
  772.   {
  773.     mpg->pic_size = mpg->imagex * mpg->imagey;
  774.     if ( (cmap_true_map_flag == xaTRUE) && (mpg->depth > 8) )
  775.                 mpg->pic = (xaUBYTE *) malloc( 3 * mpg->pic_size );
  776.     else mpg->pic = (xaUBYTE *) malloc( XA_PIC_SIZE(mpg->pic_size) );
  777.     if (mpg->pic == 0) TheEnd1("MPG_Buffer_Action: malloc failed");
  778.   }
  779.   return(xaTRUE);
  780. }
  781.  
  782.  
  783. xaULONG mpg_num_pics;
  784.  
  785. /*******
  786.  * 1 drop_frame_flag
  787.  * 5 hour
  788.  * 6 minutes
  789.  * 1 marker
  790.  * 6 seconds
  791.  * 6 num_pics
  792.  * 1 closed gop flag
  793.  * 1 broken link flag
  794.  *
  795.  */
  796. xaULONG mpg_read_GOP_HDR()
  797. { xaULONG drop_flag,hours,minutes,marker,seconds;
  798.   xaULONG mpg_num_pics,closed_gop,broken_link;
  799. DEBUG_LEVEL1 fprintf(stderr,"MPG_GOP_START: \n");
  800.   MPG_GET_FBITS(1,drop_flag);
  801.   MPG_GET_FBITS(5,hours);
  802.   MPG_GET_FBITS(6,minutes);
  803.   MPG_GET_FBITS(1,marker);
  804.   MPG_GET_FBITS(6,seconds);
  805.   MPG_GET_FBITS(6,mpg_num_pics);
  806.   MPG_GET_FBITS(1,closed_gop);
  807.   MPG_GET_FBITS(1,broken_link);
  808.   DEBUG_LEVEL1 fprintf(stderr,"  dflag %d time %02d:%02d:%02d mrkr %d\n",
  809.     drop_flag,hours,minutes,seconds,marker);
  810.   DEBUG_LEVEL1 fprintf(stderr,"   numpics %d %d %d\n",
  811.     mpg_num_pics,closed_gop,broken_link);
  812.  /* USR EXT data?? */
  813.   return(xaTRUE);
  814. }
  815.  
  816. /*
  817. 00000000: 000001B3 0A007819 FFFFE084 000001B2   ......x.........
  818. 00000010: 000000E8 000001B8 00000000 00000100   ................
  819. 00000020: 004FFFFF FFFC0000 01B2FFFF 00000101   .O..............
  820. 00000030: 43FBA498 FCE3E785 73BF8D80 3C48D0CC   C.......s...<H..
  821. 00000040: 33E6E2FB FC440FBC 280E80BA 502CFFDC   3....D..(...P,..
  822. 00000050: 9FEFBA00 3A02A929 3D1BA47E 6E177C58   ....:..)=...n..X
  823. ...
  824. */
  825.  
  826. /*******
  827.  *
  828.  * 10 timestamp
  829.  *  3 frame type (I=1   P=2   B=3 )
  830.  * 16 vbv buffer delay
  831.  * if P or B frame
  832.  *   1 full_pel_forw_vect flag
  833.  *   3 forw_r_code  forw_r_size = code-1; forw_f = (1 << forw_r_size);
  834.  * if P or B frame
  835.  *   1 full_pel_back_vect flag (back vector full pixel flag)
  836.  *   3 back_r_code  back_r_size = code-1; back_f = (1 << back_r_size);
  837.  *
  838.  */
  839.  
  840.  
  841. xaULONG mpg_read_PIC_HDR(phdr)
  842. MPG_PIC_HDR *phdr;
  843. { xaULONG d;
  844.   MPG_GET_FBITS(10,phdr->time);
  845.   MPG_GET_FBITS(3,phdr->type);
  846.   MPG_GET_FBITS(16,phdr->vbv_delay);
  847. DEBUG_LEVEL1 fprintf(stderr,"MPG_PIC_START: TYPE %d\n",phdr->type);
  848.   phdr->full_forw_flag = 0;
  849.   phdr->forw_r_size = phdr->forw_f = 0;
  850.   phdr->full_back_flag = 0;
  851.   phdr->back_r_size = phdr->back_f = 0;
  852.  
  853.   if ( (phdr->type == MPG_TYPE_P) || (phdr->type == MPG_TYPE_B))
  854.   {
  855.     MPG_GET_FBITS(1,phdr->full_forw_flag);
  856.     MPG_GET_FBITS(3,d);
  857.     phdr->forw_r_size = d - 1;    phdr->forw_f = (1 << phdr->forw_r_size);
  858.   }
  859.   else if (phdr->type == MPG_TYPE_B)
  860.   {
  861.     MPG_GET_FBITS(1,phdr->full_back_flag);
  862.     MPG_GET_FBITS(3,d);
  863.     phdr->back_r_size = d - 1;    phdr->back_f = (1 << phdr->back_r_size);
  864.   }
  865.   return(xaTRUE);
  866. }
  867.  
  868.  
  869. /*******
  870.  * assume mpg_pic_hdr is valid
  871.  *
  872.  * USES global variable xa_vid_fd
  873.  */
  874. xaULONG MPG_Setup_Delta(mpg,fname,act)
  875. XA_ANIM_SETUP *mpg;
  876. char *fname;
  877. XA_ACTION *act;            /* action to use  */
  878. {
  879.   ACT_DLTA_HDR *dlta_hdr = (ACT_DLTA_HDR *)act->data;
  880.   MPG_PIC_HDR *the_pic_hdr = (MPG_PIC_HDR *)dlta_hdr->data;
  881.   MPG_SEQ_HDR *the_seq_hdr = the_pic_hdr->seq_hdr;
  882.  
  883.   if ( (xa_buffer_flag==xaTRUE) || (xa_file_flag==xaTRUE) )
  884.   { /* POD CAUTION   xa_vid_fd is global variable */
  885.     if ( (xa_vid_fd=open(fname,O_RDONLY,NULL)) == 0)
  886.     { fprintf(stderr,"MPG: Open file %s for video err\n",fname);
  887.       return(xaFALSE);
  888.     }
  889.     if (mpg_dlta_buf==0)
  890.     { mpg_dlta_size = mpg->max_fvid_size;
  891.       mpg_dlta_buf = (xaUBYTE *)malloc(mpg_dlta_size);
  892.       if (mpg_dlta_buf == 0) TheEnd1("MPG: dlta_buf alloc err");
  893.     }
  894.     else if (mpg->max_fvid_size > mpg_dlta_size)
  895.     { xaUBYTE *tmp;
  896.       mpg_dlta_size = mpg->max_fvid_size;
  897.       tmp = (xaUBYTE *)realloc(mpg_dlta_buf,mpg_dlta_size);
  898.       if (tmp) mpg_dlta_buf = tmp;
  899.       else TheEnd1("MPG: dlta_buf realloc err");
  900.     }
  901.   }
  902.  
  903.   dlta_hdr->xpos = dlta_hdr->ypos = 0;
  904.   dlta_hdr->xsize = the_seq_hdr->width;
  905.   dlta_hdr->ysize = the_seq_hdr->height;
  906.   dlta_hdr->special = 0;
  907.   dlta_hdr->extra = (void *)(&mpg_dlta_buf); /* scratch buffer */
  908.   dlta_hdr->xapi_rev = 0x0001;
  909.   switch(the_pic_hdr->type)
  910.   {
  911.     case MPG_TYPE_I:
  912.     dlta_hdr->delta = MPG_Decode_I;
  913.     break;
  914.     case MPG_TYPE_B:
  915.     dlta_hdr->delta = MPG_Decode_I; /* MPG_Decode_B; */
  916.     act->type = ACT_NOP; /* POD TEMP */
  917.     return(xaTRUE);
  918.     break;
  919.     case MPG_TYPE_P:
  920.     dlta_hdr->delta = MPG_Decode_I; /* MPG_Decode_P; */
  921.     act->type = ACT_NOP; /* POD TEMP */
  922.     return(xaTRUE);
  923.     break;
  924.     default:
  925.     fprintf(stderr,"MPG frame type %d unknown\n",the_pic_hdr->type);
  926.     act->type = ACT_NOP;
  927.     return(xaFALSE);
  928.     break;
  929.   }
  930.  
  931.   ACT_Setup_Delta(mpg,act,dlta_hdr,0);
  932.  
  933.   if (xa_vid_fd >= 0) { close(xa_vid_fd); xa_vid_fd = -1; }
  934.   return(xaTRUE);
  935. }
  936.  
  937.  
  938.  
  939. /*******
  940.  *
  941.  */
  942. xaULONG
  943. MPG_Decode_B(image,delta,dsize,tchdr,map,map_flag,imagex,imagey,imaged,
  944.                                                 xs,ys,xe,ye,special,extra)
  945. xaUBYTE *image;           /* Image Buffer. */
  946. xaUBYTE *delta;           /* delta data. */
  947. xaULONG dsize;            /* delta size */
  948. XA_CHDR *tchdr;         /* color map info */
  949. xaULONG *map;             /* used if it's going to be remapped. */
  950. xaULONG map_flag;         /* whether or not to use remap_map info. */
  951. xaULONG imagex,imagey;    /* Size of image buffer. */
  952. xaULONG imaged;           /* Depth of Image. (IFF specific) */
  953. xaULONG *xs,*ys;          /* pos of changed area. */
  954. xaULONG *xe,*ye;          /* size of changed area. */
  955. xaULONG special;          /* Special Info. */
  956. void *extra;            /* extra info needed to decode delta */
  957. {
  958.   XA_CHDR *chdr;
  959.   if (tchdr) {chdr=(tchdr->new_chdr)?(tchdr->new_chdr):(tchdr);} else chdr=0;
  960.   *xs = *ys = *xe = *ye = 0; return(ACT_DLTA_NOP);
  961.  
  962.  
  963. /*
  964.   if (map_flag) return(ACT_DLTA_MAPD);
  965.   else return(ACT_DLTA_NORM);
  966. */
  967. }
  968.  
  969.  
  970.  
  971. /**************** HUFFMAN TABLES AND INIT ******************************/
  972.  
  973. #define MB_ESCAPE 35
  974. #define MB_STUFFING 34
  975.  
  976. /* Structure for an entry in the decoding table of
  977.  * macroblock_address_increment */
  978.  
  979. mb_addr_inc_entry    *mb_addr_inc = 0;        /* MacroBlk Addr Inc huff tab */
  980. mb_type_entry        *mb_type_P = 0;        /* MacroType P huff table */
  981. mb_type_entry        *mb_type_B = 0;        /* MacroType B huff table */
  982. motion_vectors_entry *motion_vectors = 0;    /* Motion Vectors huff table */
  983.  
  984.  
  985.  
  986. /* Code for unbound values in decoding tables */
  987. #define ERROR -1
  988. #define DCT_ERROR 63
  989.  
  990. #define MACRO_BLOCK_STUFFING 34
  991. #define MACRO_BLOCK_ESCAPE 35
  992.  
  993. /*******
  994.  * Macro for filling up the decoding table for mb_addr_inc
  995.  */
  996. #define ASSIGN1(start, end, step, val, num)    \
  997.   for (i = start; i < end; i+= step)    \
  998.   { for (j = 0; j < step; j++)        \
  999.     { mb_addr_inc[i+j].value = val;    \
  1000.       mb_addr_inc[i+j].num_bits = num;    \
  1001.     }        \
  1002.     val--;    \
  1003.   }
  1004.  
  1005. /*******
  1006.  * Init mb_addr_inc huffman table 
  1007.  */
  1008. void mpg_init_mb_addr_inc()
  1009. { int i, j, val;
  1010.  
  1011.   for (i = 0; i < 8; i++) 
  1012.   { mb_addr_inc[i].value = ERROR;
  1013.     mb_addr_inc[i].num_bits = 0;
  1014.   }
  1015.  
  1016.   mb_addr_inc[8].value = MACRO_BLOCK_ESCAPE;
  1017.   mb_addr_inc[8].num_bits = 11;
  1018.  
  1019.   for (i = 9; i < 15; i++) 
  1020.   { mb_addr_inc[i].value = ERROR;
  1021.     mb_addr_inc[i].num_bits = 0;
  1022.   }
  1023.  
  1024.   mb_addr_inc[15].value = MACRO_BLOCK_STUFFING;
  1025.   mb_addr_inc[15].num_bits = 11;
  1026.  
  1027.   for (i = 16; i < 24; i++) 
  1028.   { mb_addr_inc[i].value = ERROR;
  1029.     mb_addr_inc[i].num_bits = 0;
  1030.   }
  1031.  
  1032.   val = 33;
  1033.  
  1034.   ASSIGN1(24, 36, 1, val, 11);
  1035.   ASSIGN1(36, 48, 2, val, 10);
  1036.   ASSIGN1(48, 96, 8, val, 8);
  1037.   ASSIGN1(96, 128, 16, val, 7);
  1038.   ASSIGN1(128, 256, 64, val, 5);
  1039.   ASSIGN1(256, 512, 128, val, 4);
  1040.   ASSIGN1(512, 1024, 256, val, 3);
  1041.   ASSIGN1(1024, 2048, 1024, val, 1);
  1042. }
  1043.  
  1044. /* Macro for filling up the decoding table for mb_type */
  1045. #define ASSIGN2(start, end, quant, motion_forward, motion_backward, pattern, intra, num, mb_type) \
  1046.   for (i = start; i < end; i ++)            \
  1047.   { mb_type[i].mb_quant = quant;            \
  1048.     mb_type[i].mb_motion_forward = motion_forward;    \
  1049.     mb_type[i].mb_motion_backward = motion_backward;    \
  1050.     mb_type[i].mb_pattern = pattern;            \
  1051.     mb_type[i].mb_intra = intra;            \
  1052.     mb_type[i].num_bits = num;                \
  1053.   }
  1054.  
  1055.  
  1056. /*******
  1057.  *      Initialize the VLC decoding table for macro_block_type in
  1058.  *      predictive-coded pictures.
  1059.  */
  1060. void mpg_init_mb_type_P()
  1061. { int i;
  1062.  
  1063.   mb_type_P[0].mb_quant = mb_type_P[0].mb_motion_forward
  1064.     = mb_type_P[0].mb_motion_backward = mb_type_P[0].mb_pattern
  1065.     = mb_type_P[0].mb_intra = ERROR;
  1066.   mb_type_P[0].num_bits = 0;
  1067.  
  1068.   ASSIGN2( 1,  2, 1, 0, 0, 0, 1, 6, mb_type_P)
  1069.   ASSIGN2( 2,  4, 1, 0, 0, 1, 0, 5, mb_type_P)
  1070.   ASSIGN2( 4,  6, 1, 1, 0, 1, 0, 5, mb_type_P);
  1071.   ASSIGN2( 6,  8, 0, 0, 0, 0, 1, 5, mb_type_P);
  1072.   ASSIGN2( 8, 16, 0, 1, 0, 0, 0, 3, mb_type_P);
  1073.   ASSIGN2(16, 32, 0, 0, 0, 1, 0, 2, mb_type_P);
  1074.   ASSIGN2(32, 64, 0, 1, 0, 1, 0, 1, mb_type_P);
  1075. }
  1076.  
  1077. /******
  1078.  *      Initialize the VLC decoding table for macro_block_type in
  1079.  *      bidirectionally-coded pictures.
  1080.  */
  1081. void mpg_init_mb_type_B()
  1082. { int i;
  1083.  
  1084.   mb_type_B[0].mb_quant = mb_type_B[0].mb_motion_forward
  1085.     = mb_type_B[0].mb_motion_backward = mb_type_B[0].mb_pattern
  1086.     = mb_type_B[0].mb_intra = ERROR;
  1087.   mb_type_B[0].num_bits = 0;
  1088.  
  1089.   ASSIGN2( 1,  2, 1, 0, 0, 0, 1, 6, mb_type_B);
  1090.   ASSIGN2( 2,  3, 1, 0, 1, 1, 0, 6, mb_type_B);
  1091.   ASSIGN2( 3,  4, 1, 1, 0, 1, 0, 6, mb_type_B);
  1092.   ASSIGN2( 4,  6, 1, 1, 1, 1, 0, 5, mb_type_B);
  1093.   ASSIGN2( 6,  8, 0, 0, 0, 0, 1, 5, mb_type_B);
  1094.   ASSIGN2( 8, 12, 0, 1, 0, 0, 0, 4, mb_type_B);
  1095.   ASSIGN2(12, 16, 0, 1, 0, 1, 0, 4, mb_type_B);
  1096.   ASSIGN2(16, 24, 0, 0, 1, 0, 0, 3, mb_type_B);
  1097.   ASSIGN2(24, 32, 0, 0, 1, 1, 0, 3, mb_type_B);
  1098.   ASSIGN2(32, 48, 0, 1, 1, 0, 0, 2, mb_type_B);
  1099.   ASSIGN2(48, 64, 0, 1, 1, 1, 0, 2, mb_type_B);
  1100. }
  1101.  
  1102. /* Macro for filling up the decoding tables for motion_vectors */
  1103. #define ASSIGN3(start, end, step, val, num)    \
  1104.   for (i = start; i < end; i+= step)         \
  1105.   { for (j = 0; j < step / 2; j++)        \
  1106.     { motion_vectors[i+j].code = val;        \
  1107.       motion_vectors[i+j].num_bits = num;    \
  1108.     }                        \
  1109.     for (j = step / 2; j < step; j++)         \
  1110.     { motion_vectors[i+j].code = -val;        \
  1111.       motion_vectors[i+j].num_bits = num;    \
  1112.     }        \
  1113.     val--;    \
  1114.   }
  1115.  
  1116. /*******
  1117.  *      Initialize the VLC decoding table for the various motion
  1118.  *      vectors, including motion_horizontal_forward_code,
  1119.  *      motion_vertical_forward_code, motion_horizontal_backward_code,
  1120.  *      and motion_vertical_backward_code.
  1121.  */
  1122. void mpg_init_motion_vectors()
  1123. { int i, j, val = 16;
  1124.  
  1125.   for (i = 0; i < 24; i++) 
  1126.   { motion_vectors[i].code = ERROR;
  1127.     motion_vectors[i].num_bits = 0;
  1128.   }
  1129.  
  1130.   ASSIGN3(24, 36, 2, val, 11);
  1131.   ASSIGN3(36, 48, 4, val, 10);
  1132.   ASSIGN3(48, 96, 16, val, 8);
  1133.   ASSIGN3(96, 128, 32, val, 7);
  1134.   ASSIGN3(128, 256, 128, val, 5);
  1135.   ASSIGN3(256, 512, 256, val, 4);
  1136.   ASSIGN3(512, 1024, 512, val, 3);
  1137.   ASSIGN3(1024, 2048, 1024, val, 1);
  1138. }
  1139.  
  1140. /*
  1141.  *--------------------------------------------------------------
  1142.  *
  1143.  * DecodeDCTDCSizeLum --
  1144.  *
  1145.  *    Huffman Decoder for dct_dc_size_luminance; location where
  1146.  *      the result of decoding will be placed is passed as argument.
  1147.  *      The decoded values are obtained by doing a table lookup on
  1148.  *      dct_dc_size_luminance.
  1149.  *
  1150.  * Results:
  1151.  *    The decoded value for dct_dc_size_luminance or ERROR for 
  1152.  *      unbound values will be placed in the location specified.
  1153.  *
  1154.  * Side effects:
  1155.  *    Bit stream is irreversibly parsed.
  1156.  *
  1157.  *--------------------------------------------------------------
  1158.  */        
  1159. void decodeDCTDCSizeLum(value)
  1160. unsigned int *value;
  1161. { xaULONG idx,f;
  1162.   MPG_NXT_BBITS(7,idx);
  1163.   *value = dct_dc_size_luminance[idx].value;
  1164.   f = dct_dc_size_luminance[idx].num_bits;
  1165.   MPG_FLUSH_BBITS(f);
  1166. }
  1167.  
  1168.  
  1169. /*
  1170.  *--------------------------------------------------------------
  1171.  *
  1172.  * DecodeDCTDCSizeChrom --
  1173.  *
  1174.  *    Huffman Decoder for dct_dc_size_chrominance; location where
  1175.  *      the result of decoding will be placed is passed as argument.
  1176.  *      The decoded values are obtained by doing a table lookup on
  1177.  *      dct_dc_size_chrominance.
  1178.  *
  1179.  * Results:
  1180.  *    The decoded value for dct_dc_size_chrominance or ERROR for
  1181.  *      unbound values will be placed in the location specified.
  1182.  *
  1183.  * Side effects:
  1184.  *    Bit stream is irreversibly parsed.
  1185.  *
  1186.  *--------------------------------------------------------------
  1187.  */    
  1188. void    decodeDCTDCSizeChrom(value)
  1189. unsigned int *value;
  1190. { xaULONG idx,f;
  1191.   MPG_NXT_BBITS(8,idx);
  1192.   *value = dct_dc_size_chrominance[idx].value;
  1193.   f = dct_dc_size_chrominance[idx].num_bits; 
  1194.   MPG_FLUSH_BBITS(f);
  1195. }
  1196.  
  1197. #define RUN_MASK    0xfc00
  1198. #define LEVEL_MASK    0x03f0
  1199. #define NUM_MASK    0x000f
  1200. #define RUN_SHIFT      10
  1201. #define LEVEL_SHIFT       4
  1202. #define END_OF_BLOCK    0x3e
  1203. #define ESCAPE        0x3d
  1204.  
  1205.  
  1206. /*
  1207.  *--------------------------------------------------------------
  1208.  *
  1209.  * decodeDCTCoeff --
  1210.  *
  1211.  *    Huffman Decoder for dct_coeff_first and dct_coeff_next;
  1212.  *      locations where the results of decoding: run and level, are to
  1213.  *      be placed and also the type of DCT coefficients, either
  1214.  *      dct_coeff_first or dct_coeff_next, are being passed as argument.
  1215.  *      
  1216.  *      The decoder first examines the next 8 bits in the input stream,
  1217.  *      and perform according to the following cases:
  1218.  *      
  1219.  *      '0000 0000' - examine 8 more bits (i.e. 16 bits total) and
  1220.  *                    perform a table lookup on dct_coeff_tbl_0.
  1221.  *                    One more bit is then examined to determine the sign
  1222.  *                    of level.
  1223.  *
  1224.  *      '0000 0001' - examine 4 more bits (i.e. 12 bits total) and 
  1225.  *                    perform a table lookup on dct_coeff_tbl_1.
  1226.  *                    One more bit is then examined to determine the sign
  1227.  *                    of level.
  1228.  *      
  1229.  *      '0000 0010' - examine 2 more bits (i.e. 10 bits total) and
  1230.  *                    perform a table lookup on dct_coeff_tbl_2.
  1231.  *                    One more bit is then examined to determine the sign
  1232.  *                    of level.
  1233.  *
  1234.  *      '0000 0011' - examine 2 more bits (i.e. 10 bits total) and 
  1235.  *                    perform a table lookup on dct_coeff_tbl_3.
  1236.  *                    One more bit is then examined to determine the sign
  1237.  *                    of level.
  1238.  *
  1239.  *      otherwise   - perform a table lookup on dct_coeff_tbl. If the
  1240.  *                    value of run is not ESCAPE, extract one more bit
  1241.  *                    to determine the sign of level; otherwise 6 more
  1242.  *                    bits will be extracted to obtain the actual value 
  1243.  *                    of run , and then 8 or 16 bits to get the value of level.
  1244.  *                    
  1245.  *      
  1246.  *
  1247.  * Results:
  1248.  *    The decoded values of run and level or ERROR for unbound values
  1249.  *      are placed in the locations specified.
  1250.  *
  1251.  * Side effects:
  1252.  *    Bit stream is irreversibly parsed.
  1253.  *
  1254.  *--------------------------------------------------------------
  1255.  */
  1256. static void decodeDCTCoeff(dct_coeff_tbl, run, level)
  1257. xaUSHORT *dct_coeff_tbl;                                       
  1258. xaULONG *run;
  1259. xaLONG *level;
  1260. { xaULONG temp, idx, value, f;
  1261.  
  1262.   MPG_NXT_BBITS(8,idx);
  1263.  
  1264.   if (idx > 3) 
  1265.   {
  1266.     value = dct_coeff_tbl[idx];
  1267.     *run = (value & RUN_MASK) >> RUN_SHIFT;
  1268.     if (*run == END_OF_BLOCK) { *level = END_OF_BLOCK; }
  1269.     else 
  1270.     { f = (value & NUM_MASK) + 1;
  1271.       MPG_FLUSH_BBITS(f);
  1272.  
  1273.       if (*run != ESCAPE) 
  1274.       { xaULONG t;
  1275.          *level = (value & LEVEL_MASK) >> LEVEL_SHIFT;
  1276.      MPG_GET_BBITS(1,t); 
  1277.      if (t) *level = - *level;
  1278.       }
  1279.       else    /* *run == ESCAPE */
  1280.       { /* get_bits14(temp); */
  1281.     MPG_GET_BBITS(14,temp);  /* 6 are run, 8 are part of level */
  1282.     *run = temp >> 8;  /*  1st 6 bits are run */
  1283.  
  1284.     temp &= 0xff;  /* next 8 are for value */
  1285.     if (temp == 0) 
  1286.     { MPG_GET_BBITS(8,*level);
  1287.     /* POD Is Ness?? */
  1288. /*
  1289.       if ( (*level) < 128 ) fprintf(stderr,"DCT err A-%d\n",*level);
  1290. */
  1291.     } else if (temp != 128) 
  1292.     { 
  1293.       if (temp & 0x80) *level = temp - 256;
  1294.           else *level = temp;
  1295. /* was
  1296.       *level = ((xaLONG) (temp << 24)) >> 24; 
  1297. */
  1298.     }
  1299.     else
  1300.     { MPG_GET_BBITS(8,*level);
  1301.       *level = *level - 256;
  1302.     /* POD Is Ness?? */
  1303. /*
  1304.       if ( ((*level) > -128) || ((*level) < -255) )
  1305.             fprintf(stderr,"DCT err B-%d\n",*level);
  1306. */
  1307.     }
  1308.       }
  1309.     }
  1310.   }
  1311.   else 
  1312.   { xaULONG t;
  1313.     if (idx == 2) 
  1314.     { MPG_NXT_BBITS(10,idx); 
  1315.       value = dct_coeff_tbl_2[idx & 3];
  1316.     }
  1317.     else if (idx == 3) 
  1318.     { MPG_NXT_BBITS(10,idx); 
  1319.       value = dct_coeff_tbl_3[idx & 3];
  1320.     }
  1321.     else if (idx)    /* idx == 1 */
  1322.     { MPG_NXT_BBITS(12,idx); 
  1323.       value = dct_coeff_tbl_1[idx & 15];
  1324.     }
  1325.     else /* idx == 0 */
  1326.     { MPG_NXT_BBITS(16,idx); 
  1327.       value = dct_coeff_tbl_0[idx & 255];
  1328.     }
  1329.     *run = (value & RUN_MASK) >> RUN_SHIFT;
  1330.     *level = (value & LEVEL_MASK) >> LEVEL_SHIFT;
  1331.  
  1332.     f = (value & NUM_MASK) + 1;
  1333.     MPG_FLUSH_BBITS(f);
  1334.     MPG_GET_BBITS(1,t);
  1335.     if (t) *level = -*level;
  1336.   }
  1337. }
  1338.  
  1339. /*
  1340.  *--------------------------------------------------------------
  1341.  *
  1342.  * decodeDCTCoeffFirst --
  1343.  *
  1344.  *    Huffman Decoder for dct_coeff_first. Locations for the
  1345.  *      decoded results: run and level, are being passed as
  1346.  *      arguments. Actual work is being done by calling DecodeDCTCoeff,
  1347.  *      with the table dct_coeff_first.
  1348.  *
  1349.  * Results:
  1350.  *    The decoded values of run and level for dct_coeff_first or
  1351.  *      ERROR for unbound values are placed in the locations given.
  1352.  *
  1353.  * Side effects:
  1354.  *    Bit stream is irreversibly parsed.
  1355.  *
  1356.  *--------------------------------------------------------------
  1357.  */        
  1358. void decodeDCTCoeffFirst(run, level)
  1359. xaULONG *run;
  1360. xaLONG *level;
  1361. {
  1362.   decodeDCTCoeff(dct_coeff_first, run, level);
  1363. }
  1364.  
  1365.  
  1366.  
  1367. /*
  1368.  *--------------------------------------------------------------
  1369.  *
  1370.  * decodeDCTCoeffNext --
  1371.  *
  1372.  *    Huffman Decoder for dct_coeff_first. Locations for the
  1373.  *      decoded results: run and level, are being passed as
  1374.  *      arguments. Actual work is being done by calling DecodeDCTCoeff,
  1375.  *      with the table dct_coeff_next.
  1376.  *
  1377.  * Results:
  1378.  *    The decoded values of run and level for dct_coeff_next or
  1379.  *      ERROR for unbound values are placed in the locations given.
  1380.  *
  1381.  * Side effects:
  1382.  *    Bit stream is irreversibly parsed.
  1383.  *
  1384.  *--------------------------------------------------------------
  1385.  */ 
  1386. void       decodeDCTCoeffNext(run, level)
  1387. xaULONG *run;
  1388. xaLONG *level;
  1389. {
  1390.   decodeDCTCoeff(dct_coeff_next, run, level);
  1391. }
  1392.  
  1393. /********************END HUFFMAN*******************************************/
  1394.  
  1395. /***********************************************
  1396.  * Function to
  1397.  *      Initialize all the tables for VLC decoding; this must be
  1398.  *      called when the system is set up before any decoding can
  1399.  *      take place.
  1400.  *
  1401.  *********************/
  1402.  
  1403. void MPG_Init_Stuff(anim_hdr)
  1404. XA_ANIM_HDR *anim_hdr;
  1405. {
  1406.   XA_Add_Func_To_Free_Chain(anim_hdr,MPG_Free_Stuff);
  1407.   if (mb_addr_inc == 0)  
  1408.   { mb_addr_inc 
  1409.     = (mb_addr_inc_entry *)malloc(2048 * sizeof(mb_addr_inc_entry));
  1410.     mpg_init_mb_addr_inc();
  1411.   }
  1412.   if (mb_type_P == 0)
  1413.   { mb_type_P = (mb_type_entry *)malloc(64 * sizeof(mb_type_entry));
  1414.     mpg_init_mb_type_P();
  1415.   }
  1416.   if (mb_type_B == 0)
  1417.   { mb_type_B = (mb_type_entry *)malloc(64 * sizeof(mb_type_entry));
  1418.     mpg_init_mb_type_B();
  1419.   }
  1420.   if (motion_vectors==0)
  1421.   { motion_vectors 
  1422.     = (motion_vectors_entry *)malloc(2048 * sizeof(motion_vectors_entry));
  1423.     mpg_init_motion_vectors();
  1424.   }
  1425. }
  1426.  
  1427.  
  1428. /***********************************************
  1429.  * Function to Free MPG tables and buffers, etc.
  1430.  *
  1431.  *********************/
  1432. void MPG_Free_Stuff()
  1433. {
  1434.   if (mb_addr_inc) { free(mb_addr_inc); mb_addr_inc = 0; }
  1435.   if (mb_type_P) { free(mb_type_P); mb_type_P = 0; }
  1436.   if (mb_type_B) { free(mb_type_B); mb_type_B = 0; }
  1437.   if (motion_vectors) { free(motion_vectors); motion_vectors = 0; }
  1438.   if (mpg_dlta_buf) { free(mpg_dlta_buf); mpg_dlta_buf = 0; }
  1439. }
  1440.  
  1441. #define MPG_GET_MBAddrInc(ainc) \
  1442. { register xaULONG i,j;        \
  1443.   MPG_NXT_BBITS(11,i);        \
  1444.   ainc = mb_addr_inc[i].value;    \
  1445.   j = mb_addr_inc[i].num_bits;    \
  1446.   MPG_FLUSH_BBITS(j);        \
  1447. }
  1448.  
  1449. #define DCTSIZE   8
  1450. #define DCTSIZE2 64
  1451.  
  1452. /*
  1453. MBACoeff
  1454. MVDCoeff
  1455. CBPCoeff
  1456. TCoeff1
  1457. TCoeff2
  1458. TCoeff3
  1459. TCoeff4
  1460. IntraTypeCoeff
  1461. PredictedTypeCoeff
  1462. InterpolatedTypeCoeff
  1463. DCLumCoeff
  1464. DCChromCoeff
  1465. */
  1466.  
  1467. /**** HUFFMAN TABLES ****************
  1468.  *Bits Vals 
  1469.  * 11   36   MBA Coeff    
  1470.  * 11   33   MVD Coeff
  1471.  *  9   63   CBP Coef
  1472.  *           T Coeff 1
  1473.  *           T Coeff 2
  1474.  *           T Coeff 3
  1475.  *           T Coeff 4
  1476.  *  2    2   Intra Type Coeff
  1477.  *  6    7   Predicted Type Coeff
  1478.  *  6   11   Interpolated Type Coeff
  1479.  *  7    9   DC Lum Coeff
  1480.  *  8    9   DC Chrom Coeff
  1481.  *  1    1   DC Type Coeff ???
  1482.  *******************************/
  1483.  
  1484. /*****
  1485.  *
  1486.  */
  1487. #define MPG_CMAP_CACHE_CHECK(chdr); { if (cmap_cache == 0) CMAP_Cache_Init(0); \
  1488.   if (chdr != cmap_cache_chdr) { CMAP_Cache_Clear(); cmap_cache_chdr = chdr; \
  1489. } } \
  1490.  
  1491.  
  1492. xaLONG mpg_dc_y, mpg_dc_cr, mpg_dc_cb;
  1493.  
  1494. /*******
  1495.  *
  1496.  */
  1497. xaULONG
  1498. MPG_Decode_I(image,delta,dsize,dec_info)
  1499. xaUBYTE *image;         /* Image Buffer. */
  1500. xaUBYTE *delta;         /* delta data. */
  1501. xaULONG dsize;          /* delta size */
  1502. XA_DEC_INFO *dec_info;  /* Decoder Info Header */
  1503. { xaULONG imagex = dec_info->imagex;    xaULONG imagey = dec_info->imagey;
  1504.   xaULONG map_flag = dec_info->map_flag;        xaULONG *map = dec_info->map;
  1505.   xaULONG special = dec_info->special;        void *extra = dec_info->extra;
  1506.   XA_CHDR *chdr = dec_info->chdr;
  1507.   xaULONG mb_addr,vert_pos,q_scale;
  1508.   xaLONG mcu_cols,mcu_rows;
  1509.   xaUBYTE *qtab;
  1510.   xaUBYTE *Ybuf,*Ubuf,*Vbuf;
  1511.   xaULONG orow_size;
  1512.   MPG_PIC_HDR *phdr = (MPG_PIC_HDR *)(delta);
  1513.   MPG_SEQ_HDR *shdr =  phdr->seq_hdr;
  1514.   MPG_SLICE_HDR *slice;
  1515.   xaUBYTE *data_buf;
  1516.   xaULONG special_flag;
  1517.   xaUBYTE *iptr = image;
  1518.   void (*color_func)();
  1519.   xaULONG mb_size;
  1520.   xaLONG sidx;
  1521.  
  1522.    /* always full image for now */
  1523.   dec_info->xs = dec_info->ys = 0;
  1524.   dec_info->xe = imagex; dec_info->ye = imagey; 
  1525.  
  1526.    /* Indicate we can drop these frames */
  1527.   if (dec_info->skip_flag > 0) return(ACT_DLTA_DROP);
  1528.    
  1529.   if (chdr) { if (chdr->new_chdr) chdr = chdr->new_chdr; }
  1530.  
  1531.   special_flag = special & 0x0001;
  1532.   if (cmap_color_func == 4) { MPG_CMAP_CACHE_CHECK(chdr); }
  1533.  
  1534.   orow_size = imagex;
  1535.     /*** Setup Color Decode Functions */
  1536.   if (special_flag) { orow_size *= 3;    color_func = XA_MCU221111_To_RGB; }
  1537.   else
  1538.   { orow_size *= x11_bytes_pixel;
  1539.     if (x11_bytes_pixel==1)        
  1540.     { 
  1541.       color_func = XA_MCU221111_To_CLR8;
  1542.       if ( (chdr) && (x11_display_type == XA_PSEUDOCOLOR))
  1543.       {
  1544.     if (cmap_color_func == 4)        color_func = XA_MCU221111_To_CF4;
  1545.     else if ( (cmap_true_to_332 == xaTRUE) && (x11_cmap_size == 256) )
  1546.         if (xa_dither_flag==xaTRUE)    color_func = XA_MCU221111_To_332_Dither;
  1547.         else                           color_func = XA_MCU221111_To_332;
  1548.       }
  1549.     }
  1550.     else if (x11_bytes_pixel==2)    color_func = XA_MCU221111_To_CLR16;
  1551.     else                color_func = XA_MCU221111_To_CLR32;
  1552.   }
  1553.   imagex++; imagex >>= 1;
  1554.     
  1555.   mcu_cols = ((shdr->width  + 15) / 16);
  1556.   mcu_rows = ((shdr->height + 15) / 16);
  1557.   mb_size = mcu_cols * mcu_rows;
  1558.  
  1559. DEBUG_LEVEL1 fprintf(stderr,"mcu xy %d %d  size %d\n",
  1560.                     mcu_cols,mcu_rows,mb_size);
  1561.  
  1562.   qtab = shdr->intra_qtab;
  1563.  
  1564.   /* get current slice */
  1565.   sidx = 0;
  1566.   slice = &(phdr->slices[sidx]);
  1567.  
  1568.     /*** Loop through slices in order to construct each Image */
  1569.   while(slice->fsize)
  1570.   { 
  1571.     if (slice->act) data_buf = (xaUBYTE *)(slice->act->data);
  1572.     else data_buf = 0;
  1573.  
  1574.     if (data_buf == 0)
  1575.     { xaLONG ret;
  1576.       xaUBYTE **t = (xaUBYTE **)(extra);
  1577.       data_buf = *t;
  1578.       ret = lseek(xa_vid_fd,slice->fpos,SEEK_SET);
  1579.       ret = read(xa_vid_fd,data_buf,slice->fsize);
  1580.       /* read data into slice */
  1581.     }
  1582.  
  1583.     MPG_INIT_BBUF(data_buf,slice->fsize);
  1584.     vert_pos = slice->vert_pos - 1;
  1585.     MPG_GET_BBITS(5,q_scale);  /* quant scale */
  1586.     mpg_skip_extra_bitsB();
  1587.  
  1588.     /* move on */
  1589.     sidx++; 
  1590.     slice = &(phdr->slices[sidx]);
  1591.  
  1592. DEBUG_LEVEL1 { if (vert_pos != 0) fprintf(stderr,"VERT_POS = %d mcu rows = %d cols = %d\n",vert_pos,mcu_rows,mcu_cols); }
  1593.  
  1594.     /* adjust pointers for slice */
  1595.  
  1596.     mb_addr = (vert_pos * mcu_cols) - 1;
  1597.  
  1598.     mpg_dc_y = mpg_dc_cr = mpg_dc_cb = 1024;
  1599.  
  1600.     do  /* while(mb_addr < mb_size) */
  1601.     { xaULONG tmp,i;
  1602.  
  1603.     /* parse MB addr increment and update MB address */
  1604. DEBUG_LEVEL1 fprintf(stderr,"PARSE MB ADDR(%d): ",mb_addr);
  1605.  
  1606.     do
  1607.     { MPG_GET_MBAddrInc(tmp);  /* huff decode MB addr inc */
  1608.  
  1609. DEBUG_LEVEL1 fprintf(stderr," %d",tmp);
  1610.  
  1611.       if (tmp == MB_ESCAPE) 
  1612.       { mb_addr += 33; tmp = MB_STUFFING;
  1613.       }
  1614.     } while(tmp == MB_STUFFING);
  1615.  
  1616.  
  1617.     if (tmp > 1) mpg_dc_y = mpg_dc_cr = mpg_dc_cb = 1024;
  1618.     mb_addr += tmp;
  1619. DEBUG_LEVEL1 fprintf(stderr,"  :mb_addr %d\n",mb_addr);
  1620.  
  1621.     if (mb_addr >= mb_size) break;
  1622.  
  1623.     /* check for end of slice */
  1624.     MPG_CHECK_BBITS(4,tmp); 
  1625.         if (tmp == xaFALSE) 
  1626.         { DEBUG_LEVEL1 fprintf(stderr,"end of slice\n");
  1627.           break;
  1628.         }
  1629.  
  1630. /* Calculate Y,U,V buffers */
  1631. { xaULONG offset;
  1632.   Ybuf = jpg_YUVBufs.Ybuf; Ubuf = jpg_YUVBufs.Ubuf; Vbuf = jpg_YUVBufs.Vbuf;
  1633.  
  1634.   offset = DCTSIZE2 * mb_addr;
  1635.   Ubuf += offset;
  1636.   Vbuf += offset;
  1637.   Ybuf += offset << 2;
  1638. }
  1639.  
  1640.     /* Decode I Type MacroBlock Type  1 or 01 */
  1641.     MPG_NXT_BBITS(2,i);
  1642.  
  1643. DEBUG_LEVEL1 fprintf(stderr,"MB type %x\n",i);
  1644.  
  1645.     if (i & 0x02) { MPG_FLUSH_BBITS(1); }
  1646.     /* else if (i == 0x00) ERROR */
  1647.     else /* new quant scale */
  1648.     { MPG_FLUSH_BBITS(2);
  1649.       MPG_GET_BBITS(5,q_scale);  /* quant scale */
  1650.       DEBUG_LEVEL1 fprintf(stderr,"New Quant Scale %x\n",q_scale);
  1651.     }
  1652.     mpg_huffparseI(dct_dc_size_luminance, 7, &mpg_dc_y,
  1653.             q_scale, qtab, mpg_dct_buf, Ybuf); Ybuf += DCTSIZE2;
  1654.     mpg_huffparseI(dct_dc_size_luminance, 7, &mpg_dc_y,
  1655.             q_scale, qtab, mpg_dct_buf, Ybuf); Ybuf += DCTSIZE2;
  1656.     mpg_huffparseI(dct_dc_size_luminance, 7, &mpg_dc_y,
  1657.             q_scale, qtab, mpg_dct_buf, Ybuf); Ybuf += DCTSIZE2;
  1658.     mpg_huffparseI(dct_dc_size_luminance, 7, &mpg_dc_y,
  1659.             q_scale, qtab, mpg_dct_buf, Ybuf); Ybuf += DCTSIZE2;
  1660.     mpg_huffparseI(dct_dc_size_chrominance, 8, &mpg_dc_cr,
  1661.             q_scale, qtab, mpg_dct_buf, Ubuf); Ubuf += DCTSIZE2;
  1662.     mpg_huffparseI(dct_dc_size_chrominance, 8, &mpg_dc_cb,
  1663.             q_scale, qtab, mpg_dct_buf, Vbuf); Vbuf += DCTSIZE2;
  1664.     } while(mb_addr < (mb_size - 1) );
  1665.   } /* end of while slices */
  1666.  
  1667.   (void)(color_func)(iptr,imagex,imagey,(mcu_cols * DCTSIZE2),orow_size,
  1668.             &jpg_YUVBufs,&def_yuv_tabs,map_flag,map,chdr);
  1669.  
  1670.   if (map_flag) return(ACT_DLTA_MAPD); else return(ACT_DLTA_NORM);
  1671. }
  1672.  
  1673.  
  1674. xaULONG MPG_Decode_B();
  1675. #ifdef NOTYET_FINISHED
  1676. /*******
  1677.  *
  1678.  */
  1679. xaULONG
  1680. MPG_Decode_P(image,delta,dsize,dec_info)
  1681. xaUBYTE *image;         /* Image Buffer. */
  1682. xaUBYTE *delta;         /* delta data. */
  1683. xaULONG dsize;          /* delta size */
  1684. XA_DEC_INFO *dec_info;  /* Decoder Info Header */
  1685. { xaULONG imagex = dec_info->imagex;    xaULONG imagey = dec_info->imagey;
  1686.   xaULONG map_flag = dec_info->map_flag;        xaULONG *map = dec_info->map;
  1687.   xaULONG special = dec_info->special;          void *extra = dec_info->extra;
  1688.   XA_CHDR *chdr = dec_info->chdr;
  1689.  
  1690.   dec_info->xs = dec_info->ys = 0;
  1691.   dec_info->xe = imagex; dec_info->ye = imagey; 
  1692.   if (chdr) { if (chdr->new_chdr) chdr = chdr->new_chdr; }
  1693.  
  1694.   if (map_flag) return(ACT_DLTA_MAPD); else return(ACT_DLTA_NORM);
  1695. }
  1696.  
  1697.   xaULONG mb_addr,vert_pos,q_scale;
  1698.   xaLONG x,y,mcu_cols,mcu_rows,mcu_row_size;
  1699.   xaUBYTE *qtab;
  1700.   xaUBYTE *Ybuf0,*Ybuf1,*Ubuf,*Vbuf;
  1701.   xaULONG orow_size;
  1702.   MPG_PIC_HDR *phdr = (MPG_PIC_HDR *)(delta);
  1703.   MPG_SEQ_HDR *shdr =  phdr->seq_hdr;
  1704.   MPG_SLICE_HDR *slice;
  1705.   xaUBYTE *data_buf;
  1706.   XA_CHDR *chdr;
  1707.   xaULONG special_flag;
  1708.   xaUBYTE *iptr = image;
  1709.   void (*color_func)();
  1710.   xaULONG mb_size,mb_cnt;
  1711.   xaLONG sidx,y_count;
  1712.  
  1713. xaULONG Pquant,Pmotion_fwd,Ppat,Pintra;
  1714. xaULONG P_cbp;
  1715. xaLONG mot_h_forw_code,mot_v_forw_code;
  1716. xaULONG mot_h_forw_r,mot_v_forw_r;
  1717. xaLONG recon_right_for,recon_down_for;
  1718. xaLONG recon_right_for_prev,recon_down_for_prev;
  1719.  
  1720.  
  1721.  
  1722.   *xs = *ys = 0; *xe = imagex; *ye = imagey; 
  1723.   if (tchdr) {chdr=(tchdr->new_chdr)?(tchdr->new_chdr):(tchdr);} else chdr=0;
  1724.  
  1725.   special_flag = special & 0x0001;
  1726.   if (cmap_color_func == 4) { MPG_CMAP_CACHE_CHECK(chdr); }
  1727.  
  1728.   orow_size = imagex;
  1729.   if (special_flag) { orow_size *= 3;    color_func = XA_MCU221111_To_RGB; }
  1730.   else { orow_size *= x11_bytes_pixel;
  1731.     if (x11_bytes_pixel==1)        
  1732.     { 
  1733.       if ((cmap_color_func == 4) && (chdr)
  1734.           && !(x11_display_type & XA_X11_TRUE) ) color_func = XA_MCU221111_To_CF4;
  1735.       else color_func = XA_MCU221111_To_CLR8;
  1736.     }
  1737.     else if (x11_bytes_pixel==2)    color_func = XA_MCU221111_To_CLR16;
  1738.     else                color_func = XA_MCU221111_To_CLR32;
  1739.   }
  1740.   imagex++; imagex >>= 1;
  1741.  
  1742.   mcu_cols  = ((shdr->width  + 15) / 16);
  1743.   mcu_rows = ((shdr->height + 15) / 16);
  1744.   mcu_row_size = mcu_cols * DCTSIZE2;
  1745.   mb_size = mcu_cols * mcu_rows;
  1746.  
  1747.   qtab = shdr->intra_qtab;
  1748.  
  1749.   /* get current slice */
  1750.   sidx = 0;
  1751.   slice = &(phdr->slices[sidx]);
  1752.  
  1753.   while(slice->fsize)
  1754.   { 
  1755.     data_buf = (xaUBYTE *)(slice->act->data);
  1756.     if (data_buf == 0)
  1757.     { xaLONG ret;
  1758.       xaUBYTE **t = (xaUBYTE **)(extra);
  1759.       data_buf = *t;
  1760.       ret = lseek(xa_vid_fd,slice->fpos,SEEK_SET);
  1761.       ret = read(xa_vid_fd,data_buf,slice->fsize);
  1762.       /* read data into slice */
  1763.     }
  1764.  
  1765.     MPG_INIT_BBUF(data_buf,slice->fsize);
  1766.     vert_pos = slice->vert_pos - 1;
  1767.     MPG_GET_BBITS(5,q_scale);  /* quant scale */
  1768.     mpg_skip_extra_bitsB();
  1769.  
  1770.     /* move on */
  1771.     sidx++; 
  1772.     slice = &(phdr->slices[sidx]);
  1773.  
  1774. DEBUG_LEVEL1 { if (vert_pos != 0) fprintf(stderr,"VERT_POS = %d\n",vert_pos); }
  1775.  
  1776.     /* adjust pointers for slice */
  1777.     y = mcu_rows - vert_pos;
  1778.     mb_addr = (vert_pos * mcu_rows) - 1;
  1779.     y_count = imagey - (vert_pos << 4);
  1780.     iptr   = image;
  1781.     iptr  += (orow_size * (vert_pos << 4));
  1782.  
  1783.     mpg_dc_y = mpg_dc_cr = mpg_dc_cb = 1024;
  1784.     mb_cnt = 0;
  1785.  
  1786.     x = 0;
  1787.     Ybuf0 = jpg_YUVBufs.Ybuf;        Ybuf1 = Ybuf0 + (mcu_row_size << 1);
  1788.     Ubuf  = jpg_YUVBufs.Ubuf;        Vbuf = jpg_YUVBufs.Vbuf;
  1789.     while(mb_cnt < mb_size)
  1790.     { xaULONG tmp,i;
  1791.  
  1792.     /* parse MB addr increment and update MB address */
  1793.     do
  1794.     { MPG_GET_MBAddrInc(tmp);  /* huff decode MB addr inc */
  1795.       if (tmp == MB_ESCAPE) { mb_addr += 33; tmp = MB_STUFFING; }
  1796.     } while(tmp == MB_STUFFING);
  1797.  
  1798.     mb_addr += tmp;
  1799.     if (tmp > 1) mpg_dc_y = mpg_dc_cr = mpg_dc_cb = 1024;
  1800.  
  1801.     if (mb_addr >= mb_size) {  break; }
  1802.     MPG_CHECK_BBITS(4,tmp); if (tmp == xaFALSE) { y = 0; break; }
  1803.  
  1804.     /* Decode P Type MacroBlock Type */
  1805.  
  1806.         MPG_NXT_BBITS(6,i);
  1807.         Pquant = mb_type_P[index].mb_quant;
  1808.         Pmotion_fwd = mb_type_P[index].mb_motion_forward;
  1809.     Ppat = mb_type_P[index].mb_pattern;
  1810.     Pintra = mb_type_P[index].mb_intra;
  1811.     MPG_FLUSH_BBITS(mb_type_P[index].num_bits);
  1812.         /* new quant scale */
  1813.         if (Pquant) 
  1814.     {
  1815.       MPG_GET_BBITS(5,q_scale);
  1816.       DEBUG_LEVEL1 fprintf(stderr,"New Quant Scale %x\n",q_scale);
  1817.     }
  1818.         /* forward motion vectors exist */
  1819.     if (mb_motion_forw)
  1820.     { xaULONG i;
  1821.  
  1822.         /* decode horiz forward motion vector */
  1823.       MPG_NXT_BBITS(11,i);
  1824.       mot_h_forw_code = motion_vectors[i].code;
  1825. /* POD NOTE: signed?? dcval = mpg_huff_EXTEND(tmp,size); */
  1826.       MPG_FLUSH_BBITS(motion_vectors[i].num_bits);
  1827.         /* if horiz forward r data exists, parse off */
  1828.       if (mot_h_forw_code != 0) /* && (pic.forw_f != 1) */
  1829.       {
  1830.         MPG_GET_BBITS(forw_r_size,i);
  1831.         mot_h_forw_r = i;  /* xaULONG */
  1832.       }
  1833.         /* decode vert forward motion vector */
  1834.       MPG_NXT_BBITS(11,i);
  1835.       mot_v_forw_code = motion_vectors[i].code;
  1836. /* POD NOTE: signed?? dcval = mpg_huff_EXTEND(tmp,size); */
  1837.       MPG_FLUSH_BBITS(motion_vectors[i].num_bits);
  1838.         /* if horiz forward r data exists, parse off */
  1839.       if (mot_v_forw_code != 0) /* && (pic.forw_f != 1) */
  1840.       {
  1841.         MPG_GET_BBITS(forw_r_size,i);
  1842.         mot_v_forw_r = i;  /* xaULONG */
  1843.       }
  1844.     }
  1845.         /* Code Block Pattern exists */
  1846.     if (Ppat)
  1847.     { xaULONG index,f;
  1848.       MPG_NXT_BBITS(9,index);
  1849.       P_cbp = coded_block_pattern[index].cbp;
  1850.       f = coded_block_pattern[index].num_bits;
  1851.       MPG_FLUSH_BBITS(f);
  1852.     } else P_cbp = 0;
  1853.  
  1854.     if (!mb_motion_forw)
  1855.     {
  1856.       recon_right_for = recon_down_for = 0;
  1857.       recon_right_for_prev = recon_down_for_prev = 0;
  1858.     }
  1859.     else
  1860.     {
  1861. /*
  1862. ComputeForwVector(recon_right_for_ptr, recon_down_for_ptr)
  1863.      int *recon_right_for_ptr;
  1864.      int *recon_down_for_ptr;
  1865. { Pict *picture; Macroblock *mblock;
  1866.   picture = &(curVidStream->picture);
  1867.   mblock = &(curVidStream->mblock);
  1868.   ComputeVector(recon_right_for_ptr, recon_down_for_ptr,
  1869.                 mblock->recon_right_for_prev,
  1870.                 mblock->recon_down_for_prev,
  1871.                 picture->forw_f, picture->full_pel_forw_vector,
  1872.                 mblock->motion_h_forw_code, mblock->motion_v_forw_code,
  1873.                 mblock->motion_h_forw_r, mblock->motion_v_forw_r);
  1874. */
  1875.  
  1876.     }
  1877.  
  1878.     if ( (Pintra) || (P_cpb & 0x20) )
  1879.     {
  1880.     }
  1881.     if ( (Pintra) || (P_cpb & 0x10) )
  1882.     {
  1883.     }
  1884.     if ( (Pintra) || (P_cpb & 0x08) )
  1885.     {
  1886.     }
  1887.     if ( (Pintra) || (P_cpb & 0x04) )
  1888.     {
  1889.     }
  1890.     if ( (Pintra) || (P_cpb & 0x02) )
  1891.     {
  1892.     }
  1893.     if ( (Pintra) || (P_cpb & 0x01) )
  1894.     {
  1895.     }
  1896.     mpg_huffparseI(dct_dc_size_luminance, 7, &mpg_dc_y,
  1897.             q_scale, qtab, mpg_dct_buf, Ybuf0 ); Ybuf0 += DCTSIZE2;
  1898.     mpg_huffparseI(dct_dc_size_luminance, 7, &mpg_dc_y,
  1899.             q_scale, qtab, mpg_dct_buf, Ybuf0 ); Ybuf0 += DCTSIZE2;
  1900.     mpg_huffparseI(dct_dc_size_luminance, 7, &mpg_dc_y,
  1901.             q_scale, qtab, mpg_dct_buf, Ybuf1);  Ybuf1 += DCTSIZE2;
  1902.     mpg_huffparseI(dct_dc_size_luminance, 7, &mpg_dc_y,
  1903.             q_scale, qtab, mpg_dct_buf, Ybuf1);  Ybuf1 += DCTSIZE2;
  1904.  
  1905.     mpg_huffparseI(dct_dc_size_chrominance, 8, &mpg_dc_cr,
  1906.             q_scale, qtab, mpg_dct_buf, Ubuf);   Ubuf += DCTSIZE2;
  1907.     mpg_huffparseI(dct_dc_size_chrominance, 8, &mpg_dc_cb,
  1908.             q_scale, qtab, mpg_dct_buf, Vbuf);   Vbuf += DCTSIZE2;
  1909.       } /* end of mcu_cols */
  1910.       if (y) 
  1911.       { (void)(color_func)(iptr,imagex,y_count,mcu_row_size,orow_size,
  1912.             &jpg_YUVBufs, &def_yuv_tabs, map_flag,map,chdr);
  1913.     y_count -= 16;  iptr += (orow_size << 4);
  1914.     y--;
  1915.       }
  1916.     } /* end of y */
  1917.   } /* end of while slices */
  1918.   if (map_flag) return(ACT_DLTA_MAPD); else return(ACT_DLTA_NORM);
  1919. }
  1920. #endif
  1921.  
  1922.  
  1923. /******
  1924.  *
  1925.  */
  1926. #define mpg_huff_EXTEND(val,sz) \
  1927.  ((val) < (1<<((sz)-1)) ? (val) + (((-1)<<(sz)) + 1) : (val))
  1928.  
  1929. int zigzag_direct[64] = {
  1930.    0,  1,  8, 16,  9,  2,  3, 10, 17, 24, 32, 25, 18, 11, 4, 5, 12,
  1931.   19, 26, 33, 40, 48, 41, 34, 27, 20, 13,  6,  7, 14, 21, 28, 35,
  1932.   42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51,
  1933.   58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63};
  1934.  
  1935.  
  1936. /*
  1937. #define DECODE_DCT_COEFF_FIRST DecodeDCTCoeffFirst
  1938. #define DECODE_DCT_COEFF_NEXT DecodeDCTCoeffNext
  1939. */
  1940.  
  1941. #define DECODE_DCT_COEFF_FIRST decodeDCTCoeffFirst
  1942. #define DECODE_DCT_COEFF_NEXT  decodeDCTCoeffNext
  1943.  
  1944.  
  1945. /*
  1946. #define DecodeDCTCoeffFirst(runval, levelval) \
  1947.   { DecodeDCTCoeff(dct_coeff_first, runval, levelval); }
  1948.  
  1949. #define DecodeDCTCoeffNext(runval, levelval) \
  1950.   { DecodeDCTCoeff(dct_coeff_next, runval, levelval); }
  1951. */
  1952.  
  1953.  
  1954. #define CENTERJSAMPLE 128
  1955. #define MAXJSAMPLE 255
  1956. #define RANGE_MASK  (MAXJSAMPLE * 4 + 3)
  1957.  
  1958.  
  1959. /**********
  1960.  *  dct_dc_htab is either dct_dc_size_luminance or dct_dc_size_chrominance
  1961.  *  dc_val_in is either mpg_dc_y, mpg_dc_cr or mpg_dc_cb
  1962.  *  qscale
  1963.  *  qtab is usually intra_quant table 
  1964.  *  hsz is 7 for luminance and 8 for chroma
  1965.  */
  1966. void mpg_huffparseI(dct_dc_htab,hsz,dc_val_in,qscale,qtab,dct_buf,OBuf)
  1967. dct_dc_size_entry *dct_dc_htab;
  1968. xaULONG hsz;
  1969. xaLONG *dc_val_in;
  1970. xaLONG qscale;
  1971. xaUBYTE *qtab;
  1972. xaSHORT *dct_buf;
  1973. xaUBYTE *OBuf;
  1974. { xaULONG size,idx,flush;
  1975.   xaLONG tmp;
  1976.   xaLONG i,dcval,c_cnt;
  1977.   xaUBYTE *rnglimit = xa_byte_limit;
  1978.  
  1979.   MPG_NXT_BBITS(hsz,idx); /* look at next hsz bits */
  1980.   size =  dct_dc_htab[idx].value;
  1981.   flush = dct_dc_htab[idx].num_bits;
  1982.   MPG_FLUSH_BBITS(flush); /* flush used bits */
  1983.  
  1984. if (size > 10) { fprintf(stderr,"HUFF ERR \n"); return; }
  1985.  
  1986.   if (size)
  1987.   {
  1988.     MPG_GET_BBITS(size,tmp);  /* get bits */
  1989.     dcval = mpg_huff_EXTEND(tmp,size); /* sign extend them */
  1990.     dcval = (*dc_val_in) + (dcval << 3);
  1991.     *dc_val_in = dcval;
  1992.   } else dcval = *dc_val_in;
  1993.  
  1994.  memset( (char *)(dct_buf), 0, (DCTSIZE2 * sizeof(xaSHORT)) );
  1995.  dct_buf[0] = dcval;
  1996.  c_cnt = 0;
  1997.  
  1998.  i = 0;
  1999.  while( i < DCTSIZE2 )
  2000.  { xaLONG run,level;
  2001.    DECODE_DCT_COEFF_NEXT(&run,&level);
  2002.    if (run == END_OF_BLOCK) break;
  2003.    i += (run + 1);
  2004.    if (i < 64)
  2005.    { register xaULONG pos = zigzag_direct[ i ];
  2006.      register xaLONG coeff = (level * qscale * (xaLONG)(qtab[pos]) ) >> 3;
  2007.      if (level < 0) coeff += (coeff & 1);
  2008.      else coeff -= (coeff & 1);
  2009.      if (coeff) { dct_buf[pos] = coeff; c_cnt++; }
  2010.    }
  2011.  }
  2012.  MPG_FLUSH_BBITS(2); /* marker bits ?? */
  2013.  
  2014.  
  2015. /*
  2016.  DEBUG_LEVEL1
  2017.  { int ii;
  2018.    fprintf(stderr,"BLOCK \n");
  2019.    for(ii = 0; ii < 64; ii += 8)
  2020.    {
  2021.     fprintf(stderr,"  %08x %08x %08x %08x %08x %08x %08x %08x\n",
  2022.     dct_buf[ii], dct_buf[ii+1], dct_buf[ii+2], dct_buf[ii+3],
  2023.     dct_buf[ii+4], dct_buf[ii+5], dct_buf[ii+6], dct_buf[ii+7] );
  2024.    }
  2025.  }
  2026. */
  2027.  
  2028.  
  2029.   if (c_cnt) j_rev_dct(dct_buf,OBuf,rnglimit);
  2030.   else
  2031.   { register xaUBYTE *op = OBuf;
  2032.     xaSHORT v = dcval;
  2033.     register xaUBYTE dc;
  2034.     v = (v < 0)?( (v-3)>>3 ):( (v+4)>>3 );
  2035.     dc = rnglimit[ (int) (v & RANGE_MASK) ];
  2036.     op[0]  = op[1]  = op[2]  = op[3]  = op[4]  = op[5]  = op[6]  =op[7] =dc;
  2037.     op[8]  = op[9]  = op[10] = op[11] = op[12] = op[13] = op[14] =op[15] =dc;
  2038.     op[16] = op[17] = op[18] = op[19] = op[20] = op[21] = op[22] =op[23] =dc;
  2039.     op[24] = op[25] = op[26] = op[27] = op[28] = op[29] = op[30] =op[31] =dc;
  2040.     op[32] = op[33] = op[34] = op[35] = op[36] = op[37] = op[38] =op[39] =dc;
  2041.     op[40] = op[41] = op[42] = op[43] = op[44] = op[45] = op[46] =op[47] =dc;
  2042.     op[48] = op[49] = op[50] = op[51] = op[52] = op[53] = op[54] =op[55] =dc;
  2043.     op[56] = op[57] = op[58] = op[59] = op[60] = op[61] = op[62] =op[63] =dc;
  2044.   }
  2045.   return;
  2046. }
  2047.  
  2048.  
  2049.  
  2050. #ifdef RIGHT_SHIFT_IS_UNSIGNED
  2051. #define SHIFT_TEMPS    xaLONG shift_temp;
  2052. #define RIGHT_SHIFT(x,shft)  \
  2053.     ((shift_temp = (x)) < 0 ? \
  2054.      (shift_temp >> (shft)) | ((~((xaLONG) 0)) << (32-(shft))) : \
  2055.      (shift_temp >> (shft)))
  2056. #else
  2057. #define SHIFT_TEMPS
  2058. #define RIGHT_SHIFT(x,shft)    ((x) >> (shft))
  2059. #endif
  2060.  
  2061. #define PASS1_BITS  2
  2062.  
  2063. #define ONE    ((xaLONG) 1)
  2064.  
  2065. #define CONST_BITS 13
  2066.  
  2067. #define CONST_SCALE (ONE << CONST_BITS)
  2068.  
  2069. #define FIX(x)    ((xaLONG) ((x) * CONST_SCALE + 0.5))
  2070.  
  2071. #define DESCALE(x,n)  RIGHT_SHIFT((x) + (ONE << ((n)-1)), n)
  2072.  
  2073. #define MULTIPLY(var,const)  ((var) * (const))
  2074.  
  2075. void j_rev_dct (data,outptr,rnglimit)
  2076. xaSHORT *data;
  2077. xaUBYTE *outptr;
  2078. xaUBYTE *rnglimit;
  2079. {
  2080.   xaLONG tmp0, tmp1, tmp2, tmp3;
  2081.   xaLONG tmp10, tmp11, tmp12, tmp13;
  2082.   xaLONG z1, z2, z3, z4, z5;
  2083.   xaLONG d0, d1, d2, d3, d4, d5, d6, d7;
  2084.   register xaSHORT *dataptr;
  2085.   int rowctr;
  2086.   SHIFT_TEMPS
  2087.    
  2088.   /* Pass 1: process rows. */
  2089.   /* Note results are scaled up by sqrt(8) compared to a true IDCT; */
  2090.   /* furthermore, we scale the results by 2**PASS1_BITS. */
  2091.  
  2092.   dataptr = data;
  2093.  
  2094.   for (rowctr = DCTSIZE-1; rowctr >= 0; rowctr--) 
  2095.   {
  2096.     /* Due to quantization, we will usually find that many of the input
  2097.      * coefficients are zero, especially the AC terms.  We can exploit this
  2098.      * by short-circuiting the IDCT calculation for any row in which all
  2099.      * the AC terms are zero.  In that case each output is equal to the
  2100.      * DC coefficient (with scale factor as needed).
  2101.      * With typical images and quantization tables, half or more of the
  2102.      * row DCT calculations can be simplified this way.
  2103.      */
  2104.  
  2105.     register int *idataptr = (int*)dataptr;
  2106.     d0 = dataptr[0];
  2107.     d1 = dataptr[1];
  2108.     if ((d1 == 0) && (idataptr[1] | idataptr[2] | idataptr[3]) == 0) {
  2109.       /* AC terms all zero */
  2110.       if (d0) {
  2111.       /* Compute a 32 bit value to assign. */
  2112.       xaSHORT dcval = (xaSHORT) (d0 << PASS1_BITS);
  2113.       register int v = (dcval & 0xffff) | ((dcval << 16) & 0xffff0000);
  2114.       
  2115.       idataptr[0] = v;
  2116.       idataptr[1] = v;
  2117.       idataptr[2] = v;
  2118.       idataptr[3] = v;
  2119.       }
  2120.       
  2121.       dataptr += DCTSIZE;    /* advance pointer to next row */
  2122.       continue;
  2123.     }
  2124.     d2 = dataptr[2];
  2125.     d3 = dataptr[3];
  2126.     d4 = dataptr[4];
  2127.     d5 = dataptr[5];
  2128.     d6 = dataptr[6];
  2129.     d7 = dataptr[7];
  2130.  
  2131.     /* Even part: reverse the even part of the forward DCT. */
  2132.     /* The rotator is sqrt(2)*c(-6). */
  2133.     if (d6) {
  2134.     if (d4) {
  2135.         if (d2) {
  2136.         if (d0) {
  2137.             /* d0 != 0, d2 != 0, d4 != 0, d6 != 0 */
  2138.             z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
  2139.             tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
  2140.             tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
  2141.  
  2142.             tmp0 = (d0 + d4) << CONST_BITS;
  2143.             tmp1 = (d0 - d4) << CONST_BITS;
  2144.  
  2145.             tmp10 = tmp0 + tmp3;
  2146.             tmp13 = tmp0 - tmp3;
  2147.             tmp11 = tmp1 + tmp2;
  2148.             tmp12 = tmp1 - tmp2;
  2149.         } else {
  2150.             /* d0 == 0, d2 != 0, d4 != 0, d6 != 0 */
  2151.             z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
  2152.             tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
  2153.             tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
  2154.  
  2155.             tmp0 = d4 << CONST_BITS;
  2156.  
  2157.             tmp10 = tmp0 + tmp3;
  2158.             tmp13 = tmp0 - tmp3;
  2159.             tmp11 = tmp2 - tmp0;
  2160.             tmp12 = -(tmp0 + tmp2);
  2161.         }
  2162.         } else {
  2163.         if (d0) {
  2164.             /* d0 != 0, d2 == 0, d4 != 0, d6 != 0 */
  2165.             tmp2 = MULTIPLY(d6, - FIX(1.306562965));
  2166.             tmp3 = MULTIPLY(d6, FIX(0.541196100));
  2167.  
  2168.             tmp0 = (d0 + d4) << CONST_BITS;
  2169.             tmp1 = (d0 - d4) << CONST_BITS;
  2170.  
  2171.             tmp10 = tmp0 + tmp3;
  2172.             tmp13 = tmp0 - tmp3;
  2173.             tmp11 = tmp1 + tmp2;
  2174.             tmp12 = tmp1 - tmp2;
  2175.         } else {
  2176.             /* d0 == 0, d2 == 0, d4 != 0, d6 != 0 */
  2177.             tmp2 = MULTIPLY(d6, -FIX(1.306562965));
  2178.             tmp3 = MULTIPLY(d6, FIX(0.541196100));
  2179.  
  2180.             tmp0 = d4 << CONST_BITS;
  2181.  
  2182.             tmp10 = tmp0 + tmp3;
  2183.             tmp13 = tmp0 - tmp3;
  2184.             tmp11 = tmp2 - tmp0;
  2185.             tmp12 = -(tmp0 + tmp2);
  2186.         }
  2187.         }
  2188.     } else {
  2189.         if (d2) {
  2190.         if (d0) {
  2191.             /* d0 != 0, d2 != 0, d4 == 0, d6 != 0 */
  2192.             z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
  2193.             tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
  2194.             tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
  2195.  
  2196.             tmp0 = d0 << CONST_BITS;
  2197.  
  2198.             tmp10 = tmp0 + tmp3;
  2199.             tmp13 = tmp0 - tmp3;
  2200.             tmp11 = tmp0 + tmp2;
  2201.             tmp12 = tmp0 - tmp2;
  2202.         } else {
  2203.             /* d0 == 0, d2 != 0, d4 == 0, d6 != 0 */
  2204.             z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
  2205.             tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
  2206.             tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
  2207.  
  2208.             tmp10 = tmp3;
  2209.             tmp13 = -tmp3;
  2210.             tmp11 = tmp2;
  2211.             tmp12 = -tmp2;
  2212.         }
  2213.         } else {
  2214.         if (d0) {
  2215.             /* d0 != 0, d2 == 0, d4 == 0, d6 != 0 */
  2216.             tmp2 = MULTIPLY(d6, - FIX(1.306562965));
  2217.             tmp3 = MULTIPLY(d6, FIX(0.541196100));
  2218.  
  2219.             tmp0 = d0 << CONST_BITS;
  2220.  
  2221.             tmp10 = tmp0 + tmp3;
  2222.             tmp13 = tmp0 - tmp3;
  2223.             tmp11 = tmp0 + tmp2;
  2224.             tmp12 = tmp0 - tmp2;
  2225.         } else {
  2226.             /* d0 == 0, d2 == 0, d4 == 0, d6 != 0 */
  2227.             tmp2 = MULTIPLY(d6, - FIX(1.306562965));
  2228.             tmp3 = MULTIPLY(d6, FIX(0.541196100));
  2229.  
  2230.             tmp10 = tmp3;
  2231.             tmp13 = -tmp3;
  2232.             tmp11 = tmp2;
  2233.             tmp12 = -tmp2;
  2234.         }
  2235.         }
  2236.     }
  2237.     } else {
  2238.     if (d4) {
  2239.         if (d2) {
  2240.         if (d0) {
  2241.             /* d0 != 0, d2 != 0, d4 != 0, d6 == 0 */
  2242.             tmp2 = MULTIPLY(d2, FIX(0.541196100));
  2243.             tmp3 = MULTIPLY(d2, FIX(1.306562965));
  2244.  
  2245.             tmp0 = (d0 + d4) << CONST_BITS;
  2246.             tmp1 = (d0 - d4) << CONST_BITS;
  2247.  
  2248.             tmp10 = tmp0 + tmp3;
  2249.             tmp13 = tmp0 - tmp3;
  2250.             tmp11 = tmp1 + tmp2;
  2251.             tmp12 = tmp1 - tmp2;
  2252.         } else {
  2253.             /* d0 == 0, d2 != 0, d4 != 0, d6 == 0 */
  2254.             tmp2 = MULTIPLY(d2, FIX(0.541196100));
  2255.             tmp3 = MULTIPLY(d2, FIX(1.306562965));
  2256.  
  2257.             tmp0 = d4 << CONST_BITS;
  2258.  
  2259.             tmp10 = tmp0 + tmp3;
  2260.             tmp13 = tmp0 - tmp3;
  2261.             tmp11 = tmp2 - tmp0;
  2262.             tmp12 = -(tmp0 + tmp2);
  2263.         }
  2264.         } else {
  2265.         if (d0) {
  2266.             /* d0 != 0, d2 == 0, d4 != 0, d6 == 0 */
  2267.             tmp10 = tmp13 = (d0 + d4) << CONST_BITS;
  2268.             tmp11 = tmp12 = (d0 - d4) << CONST_BITS;
  2269.         } else {
  2270.             /* d0 == 0, d2 == 0, d4 != 0, d6 == 0 */
  2271.             tmp10 = tmp13 = d4 << CONST_BITS;
  2272.             tmp11 = tmp12 = -tmp10;
  2273.         }
  2274.         }
  2275.     } else {
  2276.         if (d2) {
  2277.         if (d0) {
  2278.             /* d0 != 0, d2 != 0, d4 == 0, d6 == 0 */
  2279.             tmp2 = MULTIPLY(d2, FIX(0.541196100));
  2280.             tmp3 = MULTIPLY(d2, FIX(1.306562965));
  2281.  
  2282.             tmp0 = d0 << CONST_BITS;
  2283.  
  2284.             tmp10 = tmp0 + tmp3;
  2285.             tmp13 = tmp0 - tmp3;
  2286.             tmp11 = tmp0 + tmp2;
  2287.             tmp12 = tmp0 - tmp2;
  2288.         } else {
  2289.             /* d0 == 0, d2 != 0, d4 == 0, d6 == 0 */
  2290.             tmp2 = MULTIPLY(d2, FIX(0.541196100));
  2291.             tmp3 = MULTIPLY(d2, FIX(1.306562965));
  2292.  
  2293.             tmp10 = tmp3;
  2294.             tmp13 = -tmp3;
  2295.             tmp11 = tmp2;
  2296.             tmp12 = -tmp2;
  2297.         }
  2298.         } else {
  2299.         if (d0) {
  2300.             /* d0 != 0, d2 == 0, d4 == 0, d6 == 0 */
  2301.             tmp10 = tmp13 = tmp11 = tmp12 = d0 << CONST_BITS;
  2302.         } else {
  2303.             /* d0 == 0, d2 == 0, d4 == 0, d6 == 0 */
  2304.             tmp10 = tmp13 = tmp11 = tmp12 = 0;
  2305.         }
  2306.         }
  2307.     }
  2308.     }
  2309.  
  2310.  
  2311.     /* Odd part per figure 8; the matrix is unitary and hence its
  2312.      * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
  2313.      */
  2314.  
  2315.     if (d7) {
  2316.     if (d5) {
  2317.         if (d3) {
  2318.         if (d1) {
  2319.             /* d1 != 0, d3 != 0, d5 != 0, d7 != 0 */
  2320.             z1 = d7 + d1;
  2321.             z2 = d5 + d3;
  2322.             z3 = d7 + d3;
  2323.             z4 = d5 + d1;
  2324.             z5 = MULTIPLY(z3 + z4, FIX(1.175875602));
  2325.             
  2326.             tmp0 = MULTIPLY(d7, FIX(0.298631336)); 
  2327.             tmp1 = MULTIPLY(d5, FIX(2.053119869));
  2328.             tmp2 = MULTIPLY(d3, FIX(3.072711026));
  2329.             tmp3 = MULTIPLY(d1, FIX(1.501321110));
  2330.             z1 = MULTIPLY(z1, - FIX(0.899976223));
  2331.             z2 = MULTIPLY(z2, - FIX(2.562915447));
  2332.             z3 = MULTIPLY(z3, - FIX(1.961570560));
  2333.             z4 = MULTIPLY(z4, - FIX(0.390180644));
  2334.             
  2335.             z3 += z5;
  2336.             z4 += z5;
  2337.             
  2338.             tmp0 += z1 + z3;
  2339.             tmp1 += z2 + z4;
  2340.             tmp2 += z2 + z3;
  2341.             tmp3 += z1 + z4;
  2342.         } else {
  2343.             /* d1 == 0, d3 != 0, d5 != 0, d7 != 0 */
  2344.             z1 = d7;
  2345.             z2 = d5 + d3;
  2346.             z3 = d7 + d3;
  2347.             z5 = MULTIPLY(z3 + d5, FIX(1.175875602));
  2348.             
  2349.             tmp0 = MULTIPLY(d7, FIX(0.298631336)); 
  2350.             tmp1 = MULTIPLY(d5, FIX(2.053119869));
  2351.             tmp2 = MULTIPLY(d3, FIX(3.072711026));
  2352.             z1 = MULTIPLY(d7, - FIX(0.899976223));
  2353.             z2 = MULTIPLY(z2, - FIX(2.562915447));
  2354.             z3 = MULTIPLY(z3, - FIX(1.961570560));
  2355.             z4 = MULTIPLY(d5, - FIX(0.390180644));
  2356.             
  2357.             z3 += z5;
  2358.             z4 += z5;
  2359.             
  2360.             tmp0 += z1 + z3;
  2361.             tmp1 += z2 + z4;
  2362.             tmp2 += z2 + z3;
  2363.             tmp3 = z1 + z4;
  2364.         }
  2365.         } else {
  2366.         if (d1) {
  2367.             /* d1 != 0, d3 == 0, d5 != 0, d7 != 0 */
  2368.             z1 = d7 + d1;
  2369.             z2 = d5;
  2370.             z3 = d7;
  2371.             z4 = d5 + d1;
  2372.             z5 = MULTIPLY(z3 + z4, FIX(1.175875602));
  2373.             
  2374.             tmp0 = MULTIPLY(d7, FIX(0.298631336)); 
  2375.             tmp1 = MULTIPLY(d5, FIX(2.053119869));
  2376.             tmp3 = MULTIPLY(d1, FIX(1.501321110));
  2377.             z1 = MULTIPLY(z1, - FIX(0.899976223));
  2378.             z2 = MULTIPLY(d5, - FIX(2.562915447));
  2379.             z3 = MULTIPLY(d7, - FIX(1.961570560));
  2380.             z4 = MULTIPLY(z4, - FIX(0.390180644));
  2381.             
  2382.             z3 += z5;
  2383.             z4 += z5;
  2384.             
  2385.             tmp0 += z1 + z3;
  2386.             tmp1 += z2 + z4;
  2387.             tmp2 = z2 + z3;
  2388.             tmp3 += z1 + z4;
  2389.         } else {
  2390.             /* d1 == 0, d3 == 0, d5 != 0, d7 != 0 */
  2391.             tmp0 = MULTIPLY(d7, - FIX(0.601344887)); 
  2392.             z1 = MULTIPLY(d7, - FIX(0.899976223));
  2393.             z3 = MULTIPLY(d7, - FIX(1.961570560));
  2394.             tmp1 = MULTIPLY(d5, - FIX(0.509795578));
  2395.             z2 = MULTIPLY(d5, - FIX(2.562915447));
  2396.             z4 = MULTIPLY(d5, - FIX(0.390180644));
  2397.             z5 = MULTIPLY(d5 + d7, FIX(1.175875602));
  2398.             
  2399.             z3 += z5;
  2400.             z4 += z5;
  2401.             
  2402.             tmp0 += z3;
  2403.             tmp1 += z4;
  2404.             tmp2 = z2 + z3;
  2405.             tmp3 = z1 + z4;
  2406.         }
  2407.         }
  2408.     } else {
  2409.         if (d3) {
  2410.         if (d1) {
  2411.             /* d1 != 0, d3 != 0, d5 == 0, d7 != 0 */
  2412.             z1 = d7 + d1;
  2413.             z3 = d7 + d3;
  2414.             z5 = MULTIPLY(z3 + d1, FIX(1.175875602));
  2415.             
  2416.             tmp0 = MULTIPLY(d7, FIX(0.298631336)); 
  2417.             tmp2 = MULTIPLY(d3, FIX(3.072711026));
  2418.             tmp3 = MULTIPLY(d1, FIX(1.501321110));
  2419.             z1 = MULTIPLY(z1, - FIX(0.899976223));
  2420.             z2 = MULTIPLY(d3, - FIX(2.562915447));
  2421.             z3 = MULTIPLY(z3, - FIX(1.961570560));
  2422.             z4 = MULTIPLY(d1, - FIX(0.390180644));
  2423.             
  2424.             z3 += z5;
  2425.             z4 += z5;
  2426.             
  2427.             tmp0 += z1 + z3;
  2428.             tmp1 = z2 + z4;
  2429.             tmp2 += z2 + z3;
  2430.             tmp3 += z1 + z4;
  2431.         } else {
  2432.             /* d1 == 0, d3 != 0, d5 == 0, d7 != 0 */
  2433.             z3 = d7 + d3;
  2434.             
  2435.             tmp0 = MULTIPLY(d7, - FIX(0.601344887)); 
  2436.             z1 = MULTIPLY(d7, - FIX(0.899976223));
  2437.             tmp2 = MULTIPLY(d3, FIX(0.509795579));
  2438.             z2 = MULTIPLY(d3, - FIX(2.562915447));
  2439.             z5 = MULTIPLY(z3, FIX(1.175875602));
  2440.             z3 = MULTIPLY(z3, - FIX(0.785694958));
  2441.             
  2442.             tmp0 += z3;
  2443.             tmp1 = z2 + z5;
  2444.             tmp2 += z3;
  2445.             tmp3 = z1 + z5;
  2446.         }
  2447.         } else {
  2448.         if (d1) {
  2449.             /* d1 != 0, d3 == 0, d5 == 0, d7 != 0 */
  2450.             z1 = d7 + d1;
  2451.             z5 = MULTIPLY(z1, FIX(1.175875602));
  2452.  
  2453.             z1 = MULTIPLY(z1, FIX(0.275899379));
  2454.             z3 = MULTIPLY(d7, - FIX(1.961570560));
  2455.             tmp0 = MULTIPLY(d7, - FIX(1.662939224)); 
  2456.             z4 = MULTIPLY(d1, - FIX(0.390180644));
  2457.             tmp3 = MULTIPLY(d1, FIX(1.111140466));
  2458.  
  2459.             tmp0 += z1;
  2460.             tmp1 = z4 + z5;
  2461.             tmp2 = z3 + z5;
  2462.             tmp3 += z1;
  2463.         } else {
  2464.             /* d1 == 0, d3 == 0, d5 == 0, d7 != 0 */
  2465.             tmp0 = MULTIPLY(d7, - FIX(1.387039845));
  2466.             tmp1 = MULTIPLY(d7, FIX(1.175875602));
  2467.             tmp2 = MULTIPLY(d7, - FIX(0.785694958));
  2468.             tmp3 = MULTIPLY(d7, FIX(0.275899379));
  2469.         }
  2470.         }
  2471.     }
  2472.     } else {
  2473.     if (d5) {
  2474.         if (d3) {
  2475.         if (d1) {
  2476.             /* d1 != 0, d3 != 0, d5 != 0, d7 == 0 */
  2477.             z2 = d5 + d3;
  2478.             z4 = d5 + d1;
  2479.             z5 = MULTIPLY(d3 + z4, FIX(1.175875602));
  2480.             
  2481.             tmp1 = MULTIPLY(d5, FIX(2.053119869));
  2482.             tmp2 = MULTIPLY(d3, FIX(3.072711026));
  2483.             tmp3 = MULTIPLY(d1, FIX(1.501321110));
  2484.             z1 = MULTIPLY(d1, - FIX(0.899976223));
  2485.             z2 = MULTIPLY(z2, - FIX(2.562915447));
  2486.             z3 = MULTIPLY(d3, - FIX(1.961570560));
  2487.             z4 = MULTIPLY(z4, - FIX(0.390180644));
  2488.             
  2489.             z3 += z5;
  2490.             z4 += z5;
  2491.             
  2492.             tmp0 = z1 + z3;
  2493.             tmp1 += z2 + z4;
  2494.             tmp2 += z2 + z3;
  2495.             tmp3 += z1 + z4;
  2496.         } else {
  2497.             /* d1 == 0, d3 != 0, d5 != 0, d7 == 0 */
  2498.             z2 = d5 + d3;
  2499.             
  2500.             z5 = MULTIPLY(z2, FIX(1.175875602));
  2501.             tmp1 = MULTIPLY(d5, FIX(1.662939225));
  2502.             z4 = MULTIPLY(d5, - FIX(0.390180644));
  2503.             z2 = MULTIPLY(z2, - FIX(1.387039845));
  2504.             tmp2 = MULTIPLY(d3, FIX(1.111140466));
  2505.             z3 = MULTIPLY(d3, - FIX(1.961570560));
  2506.             
  2507.             tmp0 = z3 + z5;
  2508.             tmp1 += z2;
  2509.             tmp2 += z2;
  2510.             tmp3 = z4 + z5;
  2511.         }
  2512.         } else {
  2513.         if (d1) {
  2514.             /* d1 != 0, d3 == 0, d5 != 0, d7 == 0 */
  2515.             z4 = d5 + d1;
  2516.             
  2517.             z5 = MULTIPLY(z4, FIX(1.175875602));
  2518.             z1 = MULTIPLY(d1, - FIX(0.899976223));
  2519.             tmp3 = MULTIPLY(d1, FIX(0.601344887));
  2520.             tmp1 = MULTIPLY(d5, - FIX(0.509795578));
  2521.             z2 = MULTIPLY(d5, - FIX(2.562915447));
  2522.             z4 = MULTIPLY(z4, FIX(0.785694958));
  2523.             
  2524.             tmp0 = z1 + z5;
  2525.             tmp1 += z4;
  2526.             tmp2 = z2 + z5;
  2527.             tmp3 += z4;
  2528.         } else {
  2529.             /* d1 == 0, d3 == 0, d5 != 0, d7 == 0 */
  2530.             tmp0 = MULTIPLY(d5, FIX(1.175875602));
  2531.             tmp1 = MULTIPLY(d5, FIX(0.275899380));
  2532.             tmp2 = MULTIPLY(d5, - FIX(1.387039845));
  2533.             tmp3 = MULTIPLY(d5, FIX(0.785694958));
  2534.         }
  2535.         }
  2536.     } else {
  2537.         if (d3) {
  2538.         if (d1) {
  2539.             /* d1 != 0, d3 != 0, d5 == 0, d7 == 0 */
  2540.             z5 = d1 + d3;
  2541.             tmp3 = MULTIPLY(d1, FIX(0.211164243));
  2542.             tmp2 = MULTIPLY(d3, - FIX(1.451774981));
  2543.             z1 = MULTIPLY(d1, FIX(1.061594337));
  2544.             z2 = MULTIPLY(d3, - FIX(2.172734803));
  2545.             z4 = MULTIPLY(z5, FIX(0.785694958));
  2546.             z5 = MULTIPLY(z5, FIX(1.175875602));
  2547.             
  2548.             tmp0 = z1 - z4;
  2549.             tmp1 = z2 + z4;
  2550.             tmp2 += z5;
  2551.             tmp3 += z5;
  2552.         } else {
  2553.             /* d1 == 0, d3 != 0, d5 == 0, d7 == 0 */
  2554.             tmp0 = MULTIPLY(d3, - FIX(0.785694958));
  2555.             tmp1 = MULTIPLY(d3, - FIX(1.387039845));
  2556.             tmp2 = MULTIPLY(d3, - FIX(0.275899379));
  2557.             tmp3 = MULTIPLY(d3, FIX(1.175875602));
  2558.         }
  2559.         } else {
  2560.         if (d1) {
  2561.             /* d1 != 0, d3 == 0, d5 == 0, d7 == 0 */
  2562.             tmp0 = MULTIPLY(d1, FIX(0.275899379));
  2563.             tmp1 = MULTIPLY(d1, FIX(0.785694958));
  2564.             tmp2 = MULTIPLY(d1, FIX(1.175875602));
  2565.             tmp3 = MULTIPLY(d1, FIX(1.387039845));
  2566.         } else {
  2567.             /* d1 == 0, d3 == 0, d5 == 0, d7 == 0 */
  2568.             tmp0 = tmp1 = tmp2 = tmp3 = 0;
  2569.         }
  2570.         }
  2571.     }
  2572.     }
  2573.  
  2574.     /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
  2575.  
  2576.     dataptr[0] = (xaSHORT) DESCALE(tmp10 + tmp3, CONST_BITS-PASS1_BITS);
  2577.     dataptr[7] = (xaSHORT) DESCALE(tmp10 - tmp3, CONST_BITS-PASS1_BITS);
  2578.     dataptr[1] = (xaSHORT) DESCALE(tmp11 + tmp2, CONST_BITS-PASS1_BITS);
  2579.     dataptr[6] = (xaSHORT) DESCALE(tmp11 - tmp2, CONST_BITS-PASS1_BITS);
  2580.     dataptr[2] = (xaSHORT) DESCALE(tmp12 + tmp1, CONST_BITS-PASS1_BITS);
  2581.     dataptr[5] = (xaSHORT) DESCALE(tmp12 - tmp1, CONST_BITS-PASS1_BITS);
  2582.     dataptr[3] = (xaSHORT) DESCALE(tmp13 + tmp0, CONST_BITS-PASS1_BITS);
  2583.     dataptr[4] = (xaSHORT) DESCALE(tmp13 - tmp0, CONST_BITS-PASS1_BITS);
  2584.  
  2585.     dataptr += DCTSIZE;        /* advance pointer to next row */
  2586.   }
  2587.  
  2588.   /* Pass 2: process columns. */
  2589.   /* Note that we must descale the results by a factor of 8 == 2**3, */
  2590.   /* and also undo the PASS1_BITS scaling. */
  2591.  
  2592.   dataptr = data;
  2593.   for (rowctr = DCTSIZE-1; rowctr >= 0; rowctr--) 
  2594.   {
  2595.     /* Columns of zeroes can be exploited in the same way as we did with rows.
  2596.      * However, the row calculation has created many nonzero AC terms, so the
  2597.      * simplification applies less often (typically 5% to 10% of the time).
  2598.      * On machines with very fast multiplication, it's possible that the
  2599.      * test takes more time than it's worth.  In that case this section
  2600.      * may be commented out.
  2601.      */
  2602.  
  2603.     d0 = dataptr[DCTSIZE*0];
  2604.     d1 = dataptr[DCTSIZE*1];
  2605.     d2 = dataptr[DCTSIZE*2];
  2606.     d3 = dataptr[DCTSIZE*3];
  2607.     d4 = dataptr[DCTSIZE*4];
  2608.     d5 = dataptr[DCTSIZE*5];
  2609.     d6 = dataptr[DCTSIZE*6];
  2610.     d7 = dataptr[DCTSIZE*7];
  2611.  
  2612.     /* Even part: reverse the even part of the forward DCT. */
  2613.     /* The rotator is sqrt(2)*c(-6). */
  2614.     if (d6) {
  2615.     if (d4) {
  2616.         if (d2) {
  2617.         if (d0) {
  2618.             /* d0 != 0, d2 != 0, d4 != 0, d6 != 0 */
  2619.             z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
  2620.             tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
  2621.             tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
  2622.  
  2623.             tmp0 = (d0 + d4) << CONST_BITS;
  2624.             tmp1 = (d0 - d4) << CONST_BITS;
  2625.  
  2626.             tmp10 = tmp0 + tmp3;
  2627.             tmp13 = tmp0 - tmp3;
  2628.             tmp11 = tmp1 + tmp2;
  2629.             tmp12 = tmp1 - tmp2;
  2630.         } else {
  2631.             /* d0 == 0, d2 != 0, d4 != 0, d6 != 0 */
  2632.             z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
  2633.             tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
  2634.             tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
  2635.  
  2636.             tmp0 = d4 << CONST_BITS;
  2637.  
  2638.             tmp10 = tmp0 + tmp3;
  2639.             tmp13 = tmp0 - tmp3;
  2640.             tmp11 = tmp2 - tmp0;
  2641.             tmp12 = -(tmp0 + tmp2);
  2642.         }
  2643.         } else {
  2644.         if (d0) {
  2645.             /* d0 != 0, d2 == 0, d4 != 0, d6 != 0 */
  2646.             tmp2 = MULTIPLY(d6, - FIX(1.306562965));
  2647.             tmp3 = MULTIPLY(d6, FIX(0.541196100));
  2648.  
  2649.             tmp0 = (d0 + d4) << CONST_BITS;
  2650.             tmp1 = (d0 - d4) << CONST_BITS;
  2651.  
  2652.             tmp10 = tmp0 + tmp3;
  2653.             tmp13 = tmp0 - tmp3;
  2654.             tmp11 = tmp1 + tmp2;
  2655.             tmp12 = tmp1 - tmp2;
  2656.         } else {
  2657.             /* d0 == 0, d2 == 0, d4 != 0, d6 != 0 */
  2658.             tmp2 = MULTIPLY(d6, -FIX(1.306562965));
  2659.             tmp3 = MULTIPLY(d6, FIX(0.541196100));
  2660.  
  2661.             tmp0 = d4 << CONST_BITS;
  2662.  
  2663.             tmp10 = tmp0 + tmp3;
  2664.             tmp13 = tmp0 - tmp3;
  2665.             tmp11 = tmp2 - tmp0;
  2666.             tmp12 = -(tmp0 + tmp2);
  2667.         }
  2668.         }
  2669.     } else {
  2670.         if (d2) {
  2671.         if (d0) {
  2672.             /* d0 != 0, d2 != 0, d4 == 0, d6 != 0 */
  2673.             z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
  2674.             tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
  2675.             tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
  2676.  
  2677.             tmp0 = d0 << CONST_BITS;
  2678.  
  2679.             tmp10 = tmp0 + tmp3;
  2680.             tmp13 = tmp0 - tmp3;
  2681.             tmp11 = tmp0 + tmp2;
  2682.             tmp12 = tmp0 - tmp2;
  2683.         } else {
  2684.             /* d0 == 0, d2 != 0, d4 == 0, d6 != 0 */
  2685.             z1 = MULTIPLY(d2 + d6, FIX(0.541196100));
  2686.             tmp2 = z1 + MULTIPLY(d6, - FIX(1.847759065));
  2687.             tmp3 = z1 + MULTIPLY(d2, FIX(0.765366865));
  2688.  
  2689.             tmp10 = tmp3;
  2690.             tmp13 = -tmp3;
  2691.             tmp11 = tmp2;
  2692.             tmp12 = -tmp2;
  2693.         }
  2694.         } else {
  2695.         if (d0) {
  2696.             /* d0 != 0, d2 == 0, d4 == 0, d6 != 0 */
  2697.             tmp2 = MULTIPLY(d6, - FIX(1.306562965));
  2698.             tmp3 = MULTIPLY(d6, FIX(0.541196100));
  2699.  
  2700.             tmp0 = d0 << CONST_BITS;
  2701.  
  2702.             tmp10 = tmp0 + tmp3;
  2703.             tmp13 = tmp0 - tmp3;
  2704.             tmp11 = tmp0 + tmp2;
  2705.             tmp12 = tmp0 - tmp2;
  2706.         } else {
  2707.             /* d0 == 0, d2 == 0, d4 == 0, d6 != 0 */
  2708.             tmp2 = MULTIPLY(d6, - FIX(1.306562965));
  2709.             tmp3 = MULTIPLY(d6, FIX(0.541196100));
  2710.  
  2711.             tmp10 = tmp3;
  2712.             tmp13 = -tmp3;
  2713.             tmp11 = tmp2;
  2714.             tmp12 = -tmp2;
  2715.         }
  2716.         }
  2717.     }
  2718.     } else {
  2719.     if (d4) {
  2720.         if (d2) {
  2721.         if (d0) {
  2722.             /* d0 != 0, d2 != 0, d4 != 0, d6 == 0 */
  2723.             tmp2 = MULTIPLY(d2, FIX(0.541196100));
  2724.             tmp3 = MULTIPLY(d2, FIX(1.306562965));
  2725.  
  2726.             tmp0 = (d0 + d4) << CONST_BITS;
  2727.             tmp1 = (d0 - d4) << CONST_BITS;
  2728.  
  2729.             tmp10 = tmp0 + tmp3;
  2730.             tmp13 = tmp0 - tmp3;
  2731.             tmp11 = tmp1 + tmp2;
  2732.             tmp12 = tmp1 - tmp2;
  2733.         } else {
  2734.             /* d0 == 0, d2 != 0, d4 != 0, d6 == 0 */
  2735.             tmp2 = MULTIPLY(d2, FIX(0.541196100));
  2736.             tmp3 = MULTIPLY(d2, FIX(1.306562965));
  2737.  
  2738.             tmp0 = d4 << CONST_BITS;
  2739.  
  2740.             tmp10 = tmp0 + tmp3;
  2741.             tmp13 = tmp0 - tmp3;
  2742.             tmp11 = tmp2 - tmp0;
  2743.             tmp12 = -(tmp0 + tmp2);
  2744.         }
  2745.         } else {
  2746.         if (d0) {
  2747.             /* d0 != 0, d2 == 0, d4 != 0, d6 == 0 */
  2748.             tmp10 = tmp13 = (d0 + d4) << CONST_BITS;
  2749.             tmp11 = tmp12 = (d0 - d4) << CONST_BITS;
  2750.         } else {
  2751.             /* d0 == 0, d2 == 0, d4 != 0, d6 == 0 */
  2752.             tmp10 = tmp13 = d4 << CONST_BITS;
  2753.             tmp11 = tmp12 = -tmp10;
  2754.         }
  2755.         }
  2756.     } else {
  2757.         if (d2) {
  2758.         if (d0) {
  2759.             /* d0 != 0, d2 != 0, d4 == 0, d6 == 0 */
  2760.             tmp2 = MULTIPLY(d2, FIX(0.541196100));
  2761.             tmp3 = MULTIPLY(d2, FIX(1.306562965));
  2762.  
  2763.             tmp0 = d0 << CONST_BITS;
  2764.  
  2765.             tmp10 = tmp0 + tmp3;
  2766.             tmp13 = tmp0 - tmp3;
  2767.             tmp11 = tmp0 + tmp2;
  2768.             tmp12 = tmp0 - tmp2;
  2769.         } else {
  2770.             /* d0 == 0, d2 != 0, d4 == 0, d6 == 0 */
  2771.             tmp2 = MULTIPLY(d2, FIX(0.541196100));
  2772.             tmp3 = MULTIPLY(d2, FIX(1.306562965));
  2773.  
  2774.             tmp10 = tmp3;
  2775.             tmp13 = -tmp3;
  2776.             tmp11 = tmp2;
  2777.             tmp12 = -tmp2;
  2778.         }
  2779.         } else {
  2780.         if (d0) {
  2781.             /* d0 != 0, d2 == 0, d4 == 0, d6 == 0 */
  2782.             tmp10 = tmp13 = tmp11 = tmp12 = d0 << CONST_BITS;
  2783.         } else {
  2784.             /* d0 == 0, d2 == 0, d4 == 0, d6 == 0 */
  2785.             tmp10 = tmp13 = tmp11 = tmp12 = 0;
  2786.         }
  2787.         }
  2788.     }
  2789.     }
  2790.  
  2791.     /* Odd part per figure 8; the matrix is unitary and hence its
  2792.      * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
  2793.      */
  2794.     if (d7) {
  2795.     if (d5) {
  2796.         if (d3) {
  2797.         if (d1) {
  2798.             /* d1 != 0, d3 != 0, d5 != 0, d7 != 0 */
  2799.             z1 = d7 + d1;
  2800.             z2 = d5 + d3;
  2801.             z3 = d7 + d3;
  2802.             z4 = d5 + d1;
  2803.             z5 = MULTIPLY(z3 + z4, FIX(1.175875602));
  2804.             
  2805.             tmp0 = MULTIPLY(d7, FIX(0.298631336)); 
  2806.             tmp1 = MULTIPLY(d5, FIX(2.053119869));
  2807.             tmp2 = MULTIPLY(d3, FIX(3.072711026));
  2808.             tmp3 = MULTIPLY(d1, FIX(1.501321110));
  2809.             z1 = MULTIPLY(z1, - FIX(0.899976223));
  2810.             z2 = MULTIPLY(z2, - FIX(2.562915447));
  2811.             z3 = MULTIPLY(z3, - FIX(1.961570560));
  2812.             z4 = MULTIPLY(z4, - FIX(0.390180644));
  2813.             
  2814.             z3 += z5;
  2815.             z4 += z5;
  2816.             
  2817.             tmp0 += z1 + z3;
  2818.             tmp1 += z2 + z4;
  2819.             tmp2 += z2 + z3;
  2820.             tmp3 += z1 + z4;
  2821.         } else {
  2822.             /* d1 == 0, d3 != 0, d5 != 0, d7 != 0 */
  2823.             z1 = d7;
  2824.             z2 = d5 + d3;
  2825.             z3 = d7 + d3;
  2826.             z5 = MULTIPLY(z3 + d5, FIX(1.175875602));
  2827.             
  2828.             tmp0 = MULTIPLY(d7, FIX(0.298631336)); 
  2829.             tmp1 = MULTIPLY(d5, FIX(2.053119869));
  2830.             tmp2 = MULTIPLY(d3, FIX(3.072711026));
  2831.             z1 = MULTIPLY(d7, - FIX(0.899976223));
  2832.             z2 = MULTIPLY(z2, - FIX(2.562915447));
  2833.             z3 = MULTIPLY(z3, - FIX(1.961570560));
  2834.             z4 = MULTIPLY(d5, - FIX(0.390180644));
  2835.             
  2836.             z3 += z5;
  2837.             z4 += z5;
  2838.             
  2839.             tmp0 += z1 + z3;
  2840.             tmp1 += z2 + z4;
  2841.             tmp2 += z2 + z3;
  2842.             tmp3 = z1 + z4;
  2843.         }
  2844.         } else {
  2845.         if (d1) {
  2846.             /* d1 != 0, d3 == 0, d5 != 0, d7 != 0 */
  2847.             z1 = d7 + d1;
  2848.             z2 = d5;
  2849.             z3 = d7;
  2850.             z4 = d5 + d1;
  2851.             z5 = MULTIPLY(z3 + z4, FIX(1.175875602));
  2852.             
  2853.             tmp0 = MULTIPLY(d7, FIX(0.298631336)); 
  2854.             tmp1 = MULTIPLY(d5, FIX(2.053119869));
  2855.             tmp3 = MULTIPLY(d1, FIX(1.501321110));
  2856.             z1 = MULTIPLY(z1, - FIX(0.899976223));
  2857.             z2 = MULTIPLY(d5, - FIX(2.562915447));
  2858.             z3 = MULTIPLY(d7, - FIX(1.961570560));
  2859.             z4 = MULTIPLY(z4, - FIX(0.390180644));
  2860.             
  2861.             z3 += z5;
  2862.             z4 += z5;
  2863.             
  2864.             tmp0 += z1 + z3;
  2865.             tmp1 += z2 + z4;
  2866.             tmp2 = z2 + z3;
  2867.             tmp3 += z1 + z4;
  2868.         } else {
  2869.             /* d1 == 0, d3 == 0, d5 != 0, d7 != 0 */
  2870.             tmp0 = MULTIPLY(d7, - FIX(0.601344887)); 
  2871.             z1 = MULTIPLY(d7, - FIX(0.899976223));
  2872.             z3 = MULTIPLY(d7, - FIX(1.961570560));
  2873.             tmp1 = MULTIPLY(d5, - FIX(0.509795578));
  2874.             z2 = MULTIPLY(d5, - FIX(2.562915447));
  2875.             z4 = MULTIPLY(d5, - FIX(0.390180644));
  2876.             z5 = MULTIPLY(d5 + d7, FIX(1.175875602));
  2877.             
  2878.             z3 += z5;
  2879.             z4 += z5;
  2880.             
  2881.             tmp0 += z3;
  2882.             tmp1 += z4;
  2883.             tmp2 = z2 + z3;
  2884.             tmp3 = z1 + z4;
  2885.         }
  2886.         }
  2887.     } else {
  2888.         if (d3) {
  2889.         if (d1) {
  2890.             /* d1 != 0, d3 != 0, d5 == 0, d7 != 0 */
  2891.             z1 = d7 + d1;
  2892.             z3 = d7 + d3;
  2893.             z5 = MULTIPLY(z3 + d1, FIX(1.175875602));
  2894.             
  2895.             tmp0 = MULTIPLY(d7, FIX(0.298631336)); 
  2896.             tmp2 = MULTIPLY(d3, FIX(3.072711026));
  2897.             tmp3 = MULTIPLY(d1, FIX(1.501321110));
  2898.             z1 = MULTIPLY(z1, - FIX(0.899976223));
  2899.             z2 = MULTIPLY(d3, - FIX(2.562915447));
  2900.             z3 = MULTIPLY(z3, - FIX(1.961570560));
  2901.             z4 = MULTIPLY(d1, - FIX(0.390180644));
  2902.             
  2903.             z3 += z5;
  2904.             z4 += z5;
  2905.             
  2906.             tmp0 += z1 + z3;
  2907.             tmp1 = z2 + z4;
  2908.             tmp2 += z2 + z3;
  2909.             tmp3 += z1 + z4;
  2910.         } else {
  2911.             /* d1 == 0, d3 != 0, d5 == 0, d7 != 0 */
  2912.             z3 = d7 + d3;
  2913.             
  2914.             tmp0 = MULTIPLY(d7, - FIX(0.601344887)); 
  2915.             z1 = MULTIPLY(d7, - FIX(0.899976223));
  2916.             tmp2 = MULTIPLY(d3, FIX(0.509795579));
  2917.             z2 = MULTIPLY(d3, - FIX(2.562915447));
  2918.             z5 = MULTIPLY(z3, FIX(1.175875602));
  2919.             z3 = MULTIPLY(z3, - FIX(0.785694958));
  2920.             
  2921.             tmp0 += z3;
  2922.             tmp1 = z2 + z5;
  2923.             tmp2 += z3;
  2924.             tmp3 = z1 + z5;
  2925.         }
  2926.         } else {
  2927.         if (d1) {
  2928.             /* d1 != 0, d3 == 0, d5 == 0, d7 != 0 */
  2929.             z1 = d7 + d1;
  2930.             z5 = MULTIPLY(z1, FIX(1.175875602));
  2931.  
  2932.             z1 = MULTIPLY(z1, FIX(0.275899379));
  2933.             z3 = MULTIPLY(d7, - FIX(1.961570560));
  2934.             tmp0 = MULTIPLY(d7, - FIX(1.662939224)); 
  2935.             z4 = MULTIPLY(d1, - FIX(0.390180644));
  2936.             tmp3 = MULTIPLY(d1, FIX(1.111140466));
  2937.  
  2938.             tmp0 += z1;
  2939.             tmp1 = z4 + z5;
  2940.             tmp2 = z3 + z5;
  2941.             tmp3 += z1;
  2942.         } else {
  2943.             /* d1 == 0, d3 == 0, d5 == 0, d7 != 0 */
  2944.             tmp0 = MULTIPLY(d7, - FIX(1.387039845));
  2945.             tmp1 = MULTIPLY(d7, FIX(1.175875602));
  2946.             tmp2 = MULTIPLY(d7, - FIX(0.785694958));
  2947.             tmp3 = MULTIPLY(d7, FIX(0.275899379));
  2948.         }
  2949.         }
  2950.     }
  2951.     } else {
  2952.     if (d5) {
  2953.         if (d3) {
  2954.         if (d1) {
  2955.             /* d1 != 0, d3 != 0, d5 != 0, d7 == 0 */
  2956.             z2 = d5 + d3;
  2957.             z4 = d5 + d1;
  2958.             z5 = MULTIPLY(d3 + z4, FIX(1.175875602));
  2959.             
  2960.             tmp1 = MULTIPLY(d5, FIX(2.053119869));
  2961.             tmp2 = MULTIPLY(d3, FIX(3.072711026));
  2962.             tmp3 = MULTIPLY(d1, FIX(1.501321110));
  2963.             z1 = MULTIPLY(d1, - FIX(0.899976223));
  2964.             z2 = MULTIPLY(z2, - FIX(2.562915447));
  2965.             z3 = MULTIPLY(d3, - FIX(1.961570560));
  2966.             z4 = MULTIPLY(z4, - FIX(0.390180644));
  2967.             
  2968.             z3 += z5;
  2969.             z4 += z5;
  2970.             
  2971.             tmp0 = z1 + z3;
  2972.             tmp1 += z2 + z4;
  2973.             tmp2 += z2 + z3;
  2974.             tmp3 += z1 + z4;
  2975.         } else {
  2976.             /* d1 == 0, d3 != 0, d5 != 0, d7 == 0 */
  2977.             z2 = d5 + d3;
  2978.             
  2979.             z5 = MULTIPLY(z2, FIX(1.175875602));
  2980.             tmp1 = MULTIPLY(d5, FIX(1.662939225));
  2981.             z4 = MULTIPLY(d5, - FIX(0.390180644));
  2982.             z2 = MULTIPLY(z2, - FIX(1.387039845));
  2983.             tmp2 = MULTIPLY(d3, FIX(1.111140466));
  2984.             z3 = MULTIPLY(d3, - FIX(1.961570560));
  2985.             
  2986.             tmp0 = z3 + z5;
  2987.             tmp1 += z2;
  2988.             tmp2 += z2;
  2989.             tmp3 = z4 + z5;
  2990.         }
  2991.         } else {
  2992.         if (d1) {
  2993.             /* d1 != 0, d3 == 0, d5 != 0, d7 == 0 */
  2994.             z4 = d5 + d1;
  2995.             
  2996.             z5 = MULTIPLY(z4, FIX(1.175875602));
  2997.             z1 = MULTIPLY(d1, - FIX(0.899976223));
  2998.             tmp3 = MULTIPLY(d1, FIX(0.601344887));
  2999.             tmp1 = MULTIPLY(d5, - FIX(0.509795578));
  3000.             z2 = MULTIPLY(d5, - FIX(2.562915447));
  3001.             z4 = MULTIPLY(z4, FIX(0.785694958));
  3002.             
  3003.             tmp0 = z1 + z5;
  3004.             tmp1 += z4;
  3005.             tmp2 = z2 + z5;
  3006.             tmp3 += z4;
  3007.         } else {
  3008.             /* d1 == 0, d3 == 0, d5 != 0, d7 == 0 */
  3009.             tmp0 = MULTIPLY(d5, FIX(1.175875602));
  3010.             tmp1 = MULTIPLY(d5, FIX(0.275899380));
  3011.             tmp2 = MULTIPLY(d5, - FIX(1.387039845));
  3012.             tmp3 = MULTIPLY(d5, FIX(0.785694958));
  3013.         }
  3014.         }
  3015.     } else {
  3016.         if (d3) {
  3017.         if (d1) {
  3018.             /* d1 != 0, d3 != 0, d5 == 0, d7 == 0 */
  3019.             z5 = d1 + d3;
  3020.             tmp3 = MULTIPLY(d1, FIX(0.211164243));
  3021.             tmp2 = MULTIPLY(d3, - FIX(1.451774981));
  3022.             z1 = MULTIPLY(d1, FIX(1.061594337));
  3023.             z2 = MULTIPLY(d3, - FIX(2.172734803));
  3024.             z4 = MULTIPLY(z5, FIX(0.785694958));
  3025.             z5 = MULTIPLY(z5, FIX(1.175875602));
  3026.             
  3027.             tmp0 = z1 - z4;
  3028.             tmp1 = z2 + z4;
  3029.             tmp2 += z5;
  3030.             tmp3 += z5;
  3031.         } else {
  3032.             /* d1 == 0, d3 != 0, d5 == 0, d7 == 0 */
  3033.             tmp0 = MULTIPLY(d3, - FIX(0.785694958));
  3034.             tmp1 = MULTIPLY(d3, - FIX(1.387039845));
  3035.             tmp2 = MULTIPLY(d3, - FIX(0.275899379));
  3036.             tmp3 = MULTIPLY(d3, FIX(1.175875602));
  3037.         }
  3038.         } else {
  3039.         if (d1) {
  3040.             /* d1 != 0, d3 == 0, d5 == 0, d7 == 0 */
  3041.             tmp0 = MULTIPLY(d1, FIX(0.275899379));
  3042.             tmp1 = MULTIPLY(d1, FIX(0.785694958));
  3043.             tmp2 = MULTIPLY(d1, FIX(1.175875602));
  3044.             tmp3 = MULTIPLY(d1, FIX(1.387039845));
  3045.         } else {
  3046.             /* d1 == 0, d3 == 0, d5 == 0, d7 == 0 */
  3047.             tmp0 = tmp1 = tmp2 = tmp3 = 0;
  3048.         }
  3049.         }
  3050.     }
  3051.     }
  3052.  
  3053.     /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
  3054.  
  3055.  
  3056.     outptr[DCTSIZE*0] = rnglimit[ (int) DESCALE(tmp10 + tmp3,
  3057.                    CONST_BITS+PASS1_BITS+3) & RANGE_MASK];
  3058.     outptr[DCTSIZE*7] = rnglimit[ (int) DESCALE(tmp10 - tmp3,
  3059.                    CONST_BITS+PASS1_BITS+3) & RANGE_MASK];
  3060.     outptr[DCTSIZE*1] = rnglimit[ (int) DESCALE(tmp11 + tmp2,
  3061.                    CONST_BITS+PASS1_BITS+3) & RANGE_MASK];
  3062.     outptr[DCTSIZE*6] = rnglimit[ (int) DESCALE(tmp11 - tmp2,
  3063.                    CONST_BITS+PASS1_BITS+3) & RANGE_MASK];
  3064.     outptr[DCTSIZE*2] = rnglimit[ (int) DESCALE(tmp12 + tmp1,
  3065.                    CONST_BITS+PASS1_BITS+3) & RANGE_MASK];
  3066.     outptr[DCTSIZE*5] = rnglimit[ (int) DESCALE(tmp12 - tmp1,
  3067.                    CONST_BITS+PASS1_BITS+3) & RANGE_MASK];
  3068.     outptr[DCTSIZE*3] = rnglimit[ (int) DESCALE(tmp13 + tmp0,
  3069.                    CONST_BITS+PASS1_BITS+3) & RANGE_MASK];
  3070.     outptr[DCTSIZE*4] = rnglimit[ (int) DESCALE(tmp13 - tmp0,
  3071.                    CONST_BITS+PASS1_BITS+3) & RANGE_MASK];
  3072.     
  3073.     dataptr++;            /* advance pointer to next column */
  3074.     outptr++;
  3075.   }
  3076. }
  3077.  
  3078.  
  3079.