开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
idct.c
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：43k
源码类别：

Symbian

开发平台：

C/C++

idct.c：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  36. #include <math.h>
  37. #include "dllindex.h"
  38. #include "h261defs.h"
  39. #include "h261func.h"
  40. #include "clip.h"
  41. #include "h263plus.h"
  43. #ifdef _MACINTOSH
  44. #include <string.h> // for memset
  45. #endif
  47. #ifndef UNREFERENCED_PARAMETER
  48. #define UNREFERENCED_PARAMETER(x) (x) = (x)
  49. #endif
  51. extern S16 Recon [QUANT_MAX - QUANT_MIN + 1] [N_SYM_INDICES];
  53. //  Function prototypes
  54. static void init_inv_dct (void);
  55. static void Fix_PTel_S4000_mismatch( void );
  56. static void truncate_more( S32 * idct_tab_entry );
  57. static void idct2_goertzel( SYMBOL sym[], int nsym, S32 x[8][4],
  58.                             S16 recon[], int intra, int clean, int idct_class );
  59. static int idct2_energy_test( SYMBOL sym[], int nsym,
  60.                             S16 recon[] );                            
  61. static void recon_intra_dc( U8 index, S32 vec[8]);
  62. static void recon_dc( S32 y, S32 vec[8]);
  63. static void recon_hor_ac( S32 y, S32 vec[8]);
  64. static void recon_vert_ac( S32 y, S32 vec[8]);
  65. static void update( S32 x[8], S32 index, S32 table[][8*8*8]);
  66. static double dctfunc (int freq, int index);
  67. static S32 dct_tab_entry (double x, double y);
  68. static S32 combine (S32 iy, S32 ix);
  70. extern void idct2_advanced_intra( SYMBOL sym[], int nsym, S32 x[8][4], S16 recon[],
  71.                             U8 rDCpred, S8 rACpred[8], U8 rDCstore[1], S8 rACstore[8], 
  72.                             U8 cDCpred, S8 cACpred[8], U8 cDCstore[1], S8 cACstore[8],
  73.                             int predtype, int fixedDC, int leftBoundary, int upperBoundary);
  75. #define PI              3.141592654
  76. #define FRACBITS        6   /* Fractional bits in IDCT computation */
  77. #define SCALE_FACTOR    64. /* 2**FRACBITS */
  78. #define MAX_DCT_INDEX   1024
  79. #define IDCT_NTAB1_BITS 5
  80. #define IDCT_NTAB1_SIZE 32  /* 2**NTAB1_BITS entries in table for small values */
  81. #define IDCT_NTAB2_SIZE ((MAX_DCT_INDEX - 1) / IDCT_NTAB1_SIZE)
  82.                             /* Entries to handle values > NTAB1_SIZE */
  83. #define PIXEL_MIN       0
  84. #define PIXEL_MAX       255
  85. #define CLIPMARGIN      300
  86. #define CLIPMIN         (PIXEL_MIN - CLIPMARGIN)
  87. #define CLIPMAX         (PIXEL_MAX + CLIPMARGIN)
  88. #define N_DCT_INDEX     1024
  91. //  Reconstruction levels for QUANT = 1,2,..,31
  92. S16 Recon [QUANT_MAX - QUANT_MIN + 1] [N_SYM_INDICES];
  94. //  Define zigzag scanning pattern
  95. static int ZigZag[64] = {  0,  1,  5,  6,  14, 15, 27, 28,
  96.                             2,  4,  7,  13, 16, 26, 29, 42,
  97.                             3,  8,  12, 17, 25, 30, 41, 43,
  98.                             9,  11, 18, 24, 31, 40, 44, 53,
  99.                             10, 19, 23, 32, 39, 45, 52, 54,
  100.                             20, 22, 33, 38, 46, 51, 55, 60,
  101.                             21, 34, 37, 47, 50, 56, 59, 61,
  102.                             35, 36, 48, 49, 57, 58, 62, 63
  103. };
  104. static  int InvZZ[64];
  106. static  S32    idct_tab [(IDCT_NTAB1_SIZE + IDCT_NTAB2_SIZE)][8*8][8];
  107.                     /* LUT for all coeffs; [amplitude][zigzag position][] */
  108. static  S32    dc_tab [MAX_DCT_INDEX];         /* LUT for DC coeff */
  109. static  S32    hor_ac_tab [MAX_DCT_INDEX][2];  /* LUT for 1st hor AC coeff */
  110. static  S32    vert_ac_tab [MAX_DCT_INDEX][4]; /* LUT for 1st vert AC coeff */
  111. static  S32    intra_dc_tab[N_SYM_INDICES];    /* LUT for INTRA DC coeff */
  112. PIXEL   clip[(CLIPMAX-CLIPMIN+1)];      /* LUT to limit to 0-255 */
  113. static  int     even_odd_index[8*8];    /* Classify zigzag pos. as even or odd */
  116. extern void InitReconTables( void )
  117. {
  118.     int level, index, quant;
  120. //  QUANT=1 => 3,5,7,...
  121. //  QUANT=2 => 5,9,13,...
  122. //  QUANT=3 => 9,15,21,...
  123. //  QUANT=4 => 11,19,27,...
  125.     for (quant = QUANT_MIN; quant <= QUANT_MAX; quant++) {
  126.         index = (quant + 1) / 2;
  127.         for (level = 1; level < N_SYM_INDICES/2; level++) {
  128.             index += quant;
  129.             index = min( index, N_DCT_INDEX);
  130.             Recon [quant - QUANT_MIN] [level] = index;
  131.             Recon [quant - QUANT_MIN] [N_SYM_INDICES-level] = -index;
  132.         }
  133.         Recon [quant - QUANT_MIN] [0] = 0;
  134.     }
  135.     /* Generate zigzag table */
  136.     for (index = 0; index < 64; index++) {
  137.         InvZZ[ ZigZag[index] ] = index;
  138.     }
  139.     init_inv_dct();
  140.     return;
  141. }
  144. //  Idct2 - Reconstruct DCT coeffs, perform IDCT, and clip to allowed pixel range */
  145. //  Requires nsym > 0
  146. extern void Idct2( SYMBOL sym[], int nsym, PIXEL x[], int xdim, S16 recon[], int clean)
  147. {
  148.     union {
  149.         S16   bshort[8][8];
  150.         S32    blong[8][4];
  151.     } block;    /* Output from IDCT */
  152.     int     intra;
  153.     int     idct_class;
  155.     idct_class = GENERAL;   /* assume the general case */
  157.     /* look for situations involving specific involving 1,2,3 symbols */
  158.     if (sym[0].type==0) 
  159.         {
  160.             switch (nsym) 
  161.             {
  162.                 case 1:
  163.                     idct_class = DC_ONLY;
  164.                 break;
  165.                 case 2:
  166.                     if (sym[1].type == 0)  
  167.                         idct_class = DC_AC_H;
  168.                     if (sym[1].type == 1)  
  169.                         idct_class = DC_AC_V;
  170.                 break;
  171.                 case 3:
  172.                     if ( (sym[1].type | sym[2].type) == 0) 
  173.                         idct_class = DC_3;
  174.                 break;
  175.             } 
  176.         }
  178.     intra = YES;
  180.     switch (idct_class)
  181.             {
  182.                 case DC_ONLY:
  183.                 {   
  184.                     idct2_goertzel( sym, nsym, block.blong, recon, intra, clean, DC_ONLY);
  185.                     idct2_clip(x, xdim, block.blong, DC_ONLY);
  186.                     break;
  187.                 }               
  188.                 case DC_AC_H:
  189.                 {   
  190.                     idct2_goertzel( sym, nsym, block.blong, recon, intra, clean, DC_AC_H);
  191.                     idct2_clip(x, xdim, block.blong, DC_AC_H);
  192.                     break;
  193.                 }               
  194.                 case DC_AC_V:
  195.                 {   
  196.                     idct2_goertzel( sym, nsym, block.blong, recon, intra, clean, DC_AC_V);
  197.                     idct2_clip(x, xdim, block.blong, GENERAL);
  198.                     break;
  199.                 }               
  200.                 case DC_3:
  201.                 {   
  202.                     idct2_goertzel( sym, nsym, block.blong, recon, intra, clean, DC_3);
  203.                     idct2_clip(x, xdim, block.blong, GENERAL);
  204.                     break;
  205.                 }               
  206.                 default:                
  207.                 {   
  208.                     idct2_goertzel( sym, nsym, block.blong, recon, intra, clean, GENERAL);
  209.                     idct2_clip(x, xdim, block.blong, GENERAL);
  210.                 }               
  211.             }               
  213.     return;
  214. }
  216. //  Idct2Sum - Reconstruct DCT coeffs, perform IDCT, add to predition,
  217. //  and clip to allowed pixel range.  Requires nsym > 0
  218. extern void Idct2Sum( SYMBOL sym[], int nsym, PIXEL x[], int xdim, S16 recon[],int clean)
  219. {
  220.     union {
  221.         S16   bshort[8][8];
  222.         S32    blong[8][4];
  223.     } block;    /* Output from IDCT */
  224.     int     intra;
  225.     int     idct_class;
  226.     
  227.     idct_class = GENERAL;   /* assume the general case */
  229.     /* look for situations involving specific involving 1,2,3 symbols */
  230.     if (sym[0].type==0) 
  231.         {
  232.             switch (nsym) 
  233.             {
  234.                 case 1:
  235.                     idct_class = DC_ONLY;
  236.                 break;
  237.                 case 2:
  238.                     if (sym[1].type == 0)  
  239.                         idct_class = DC_AC_H;
  240.                     if (sym[1].type == 1)  
  241.                         idct_class = DC_AC_V;
  242.                 break;
  243.                 case 3:
  244.                     if ( (sym[1].type | sym[2].type) == 0) 
  245.                         idct_class = DC_3;
  246.                 break;
  247.             } 
  248.         }
  250.     intra = NO;
  251. //    if (clean == YES || (idct2_energy_test( sym, nsym, recon) > 20)){ 
  252. // activate this for sleazy IDCT in decoder
  253. //    
  254.     switch (idct_class)
  255.             {
  256.                 case DC_ONLY:
  257.                 {   
  258.                     idct2_goertzel( sym, nsym, block.blong, recon, intra, clean, DC_ONLY);
  259.                     idct2sum_clip(x, xdim, block.blong, DC_ONLY);
  260.                     break;
  261.                 }               
  262.                 case DC_AC_H:
  263.                 {   
  264.                     idct2_goertzel( sym, nsym, block.blong, recon, intra, clean, DC_AC_H);
  265.                     idct2sum_clip(x, xdim, block.blong, DC_AC_H);
  266.                     break;
  267.                 }               
  268.                 case DC_AC_V:
  269.                 {   
  270.                     idct2_goertzel( sym, nsym, block.blong, recon, intra, clean, DC_AC_V);
  271.                     idct2sum_clip(x, xdim, block.blong, GENERAL);
  272.                     break;
  273.                 }               
  274.                 case DC_3:
  275.                 {   
  276.                     idct2_goertzel( sym, nsym, block.blong, recon, intra, clean, DC_3);
  277.                     idct2sum_clip(x, xdim, block.blong, GENERAL);
  278.                     break;
  279.                 }               
  280.                 default:                
  281.                 {   
  282.                     idct2_goertzel( sym, nsym, block.blong, recon, intra, clean, GENERAL);
  283.                     idct2sum_clip(x, xdim, block.blong, GENERAL);
  284.                 }               
  285.             }
  286.  //   }         // activate this for sleazy IDCT in decoder
  287.     return;
  288. }
  290. //  Idct2_s16 - Reconstruct DCT coeffs, perform IDCT, and write as signed 16-bit values
  291. //  Set output block to zero if nsym=0
  292. extern void Idct2_s16( int intra, SYMBOL sym[], int nsym, S16 x[], int xdim, S16 recon[] )
  293. {
  294.     int i, clean = YES;
  295.     union {
  296.         S16   bshort[8][8];
  297.         S32    blong[8][4];
  298.     } block;    /* Output from IDCT */
  300.     if (nsym == 0) {
  301.         for (i = 0; i < 8; i++) {
  302.             S32 * px = (S32 *)x;
  303.             px[0] = px[1] = px[2] = px[3] = 0;
  304.             x += xdim;
  305.         }
  306.         return;
  307.     }
  309.     idct2_goertzel( sym, nsym, block.blong, recon, intra, clean, GENERAL);
  311.     // Shift out fractional bits
  312.     for (i = 0; i < 8; i++) {
  313.         x[i*xdim + 0] = block.bshort[i][0] >> FRACBITS;
  314.         x[i*xdim + 1] = block.bshort[i][1] >> FRACBITS;
  315.         x[i*xdim + 2] = block.bshort[i][2] >> FRACBITS;
  316.         x[i*xdim + 3] = block.bshort[i][3] >> FRACBITS;
  317.         x[i*xdim + 4] = block.bshort[i][7] >> FRACBITS;
  318.         x[i*xdim + 5] = block.bshort[i][6] >> FRACBITS;
  319.         x[i*xdim + 6] = block.bshort[i][5] >> FRACBITS;
  320.         x[i*xdim + 7] = block.bshort[i][4] >> FRACBITS;
  321.     }
  322. }
  325. //  Initialize tables for inverse DCT
  326. //  Note: This routine has not been optimized for speed
  327. static void init_inv_dct (void)
  328. {
  329.     int             i,j,m,n, index, zzpos;
  330.     double          magn;               /* amplitude of DCT coefficient */
  331.     static  double  bfunc[8][8][4][4];  /* DCT basis functions [vert freq][hor freq][][] */
  333.     for (n=0; n < 8; n++) {     /* Construct 2-D basis functions */
  334.       for (m=0; m < 8; m++) {
  335.         for (j=0; j < 4; j++) {
  336.           for (i=0; i < 4; i++) {
  337.               bfunc[n][m][j][i] = SCALE_FACTOR * dctfunc(n,j) * dctfunc(m,i);
  338.           }
  339.         }
  340.       }
  341.     }
  342.     //  Initialize table for INTRA DC coeff reconstruction */
  343.     for (index = 0; index < N_SYM_INDICES; index++) {
  344.         magn = 8 * index;
  345.         //printf( "Init index = %d   magn = %f n", index, magn);
  346.         intra_dc_tab [index] = dct_tab_entry (magn * bfunc[0][0][0][0],
  347.                                               magn * bfunc[0][0][0][1]);
  348.     }
  349.     //  128 is represented by index=255
  350.     index = 255;
  351.     magn = 8 * 128;
  352.     //printf( "Init index = %d   magn = %f n", index, magn);
  353.     intra_dc_tab [index] = dct_tab_entry (magn * bfunc[0][0][0][0],
  354.                                               magn * bfunc[0][0][0][1]);
  355.     
  356.     //  Initialize tables for DC and first two AC coeffs
  357.     for (index = 0; index < MAX_DCT_INDEX; index++) {
  358.         magn = 2*index + 1;
  359.         //printf( "Init index = %d   magn = %f n", index, magn);
  360.         dc_tab [index] = dct_tab_entry (magn * bfunc[0][0][0][0],
  361.                                         magn * bfunc[0][0][0][1]);
  362.         for (i = 0; i < 2; i++) {
  363.             hor_ac_tab [index][i]
  364.                         = dct_tab_entry (magn * bfunc[0][1][0][2*i],
  365.                                          magn * bfunc[0][1][0][2*i+1]);
  366.         }
  367.         for (j = 0; j < 4; j++) {
  368.             vert_ac_tab [index][j]
  369.                         = dct_tab_entry (magn * bfunc[1][0][j][0],
  370.                                          magn * bfunc[1][0][j][1]);
  371.         }
  372.     }
  373.     //  Initialize table for all coeffs
  374.     for (index = 0; index < IDCT_NTAB1_SIZE; index++) {
  375.         magn = 2*index + 1;
  376.         //printf( "Init index = %d   magn = %f n", index, magn);
  377.         for (zzpos = 0; zzpos < 8*8; zzpos++) {
  378.             n = InvZZ[zzpos] / 8;
  379.             m = InvZZ[zzpos] % 8;
  380.             for (j=0; j < 4; j++) {
  381.               for (i=0; i < 2; i++) {
  382.                   idct_tab [index][zzpos][2*j+i]
  383.                     = dct_tab_entry (magn * bfunc[n][m][j][2*i],
  384.                                     magn * bfunc[n][m][j][2*i+1]);
  385.               }
  386.             }
  387.         }
  388.     }
  389.     for (index = 0; index < IDCT_NTAB2_SIZE; index++) {
  390.         magn = 2 * IDCT_NTAB1_SIZE * (index + 1);
  391.         //printf( "Init index = %d   magn = %f n", index+IDCT_NTAB1_SIZE, magn);
  392.         for (zzpos = 0; zzpos < 8*8; zzpos++) {
  393.             n = InvZZ[zzpos] / 8;
  394.             m = InvZZ[zzpos] % 8;
  395.             for (j=0; j < 4; j++) {
  396.               for (i=0; i < 2; i++) {
  397.                   idct_tab [index + IDCT_NTAB1_SIZE][zzpos][2*j+i]
  398.                     = dct_tab_entry (magn * bfunc[n][m][j][2*i],
  399.                                     magn * bfunc[n][m][j][2*i+1]);
  400.               }
  401.             }
  402.         }
  403.     }
  404.     // Modify tables for index=1 to truncate more values to zero
  405.     Fix_PTel_S4000_mismatch();
  406.     //  LUT to clip to allowed range for PIXEL
  407.     for (i = CLIPMIN; i <= CLIPMAX; i++) {
  408.         clip[i-CLIPMIN] = max( PIXEL_MIN, min( PIXEL_MAX, i));
  409.     }
  410.     //  Classify zigzag position as even or odd, horizontally and vertically
  411.     for (zzpos = 0; zzpos < 8*8; zzpos++) {
  412.         n = InvZZ[zzpos] / 8;
  413.         m = InvZZ[zzpos] % 8;
  414.         even_odd_index[zzpos] = 2 * (n % 2) + m % 2;
  415.     }
  417. #ifdef DO_H263_PLUS
  418.     InitAdvancedIntraTables();
  419. #endif
  421.     return;
  422. }
  425. // Fix_PTel_S4000_mismatch - Modify tables for index=1 to truncate more 
  426. // values to zero.  This improves the quality when communicating with a 
  427. // system that has an IDCT mismatch problem (PTel S-4000, bug #250)
  428. static void Fix_PTel_S4000_mismatch( void )
  429. {
  430.     int index, i, j, zzpos;
  431.     
  432.     index = 1;
  433.     for (i = 0; i < 2; i++) {
  434.         truncate_more( &hor_ac_tab [index][i] );
  435.     }
  436.     for (j = 0; j < 4; j++) {
  437.         truncate_more( &vert_ac_tab [index][j] );
  438.     }
  439.     for (zzpos = 0; zzpos < 8*8; zzpos++) {
  440.         for (j=0; j < 4; j++) {
  441.             for (i=0; i < 2; i++) {
  442.                 truncate_more( &idct_tab [index][zzpos][2*j+i] );
  443.             }
  444.         }
  445.     }
  446.     return;
  447. }
  449. // truncate_more
  450. static void truncate_more( S32 * idct_tab_entry )
  451. {
  452. #define ONE_HALF            (1 << (FRACBITS - 1))
  453. #define PTEL_FIX_INTERVAL   (3)     // Set to 0 if no fix needed
  454.     S32 halfword[2];
  455.     int i;
  456.     
  457.     halfword[0] = *idct_tab_entry >> 16;            // Upper part of word
  458.     halfword[1] = (*idct_tab_entry << 16) >> 16;    // Lower part of word
  459.     for (i = 0; i < 2; ++i) {
  460.         if (halfword[i] >= ONE_HALF  &&  halfword[i] < ONE_HALF + PTEL_FIX_INTERVAL) {
  461.             halfword[i] = ONE_HALF - 1;
  462.         } else if (halfword[i] <= -ONE_HALF  &&  halfword[i] > -(ONE_HALF + PTEL_FIX_INTERVAL)) {
  463.             halfword[i] = -(ONE_HALF - 1);
  464.         }
  465.     }
  466.     *idct_tab_entry = (halfword[0] << 16) | (halfword[1] & 0xffff);
  467.     return;
  468. }
  470.  
  471. #ifdef WHY_IS_THIS_HERE
  472. static int idct2_energy_test( SYMBOL sym[], int nsym,
  473.                             S16 recon[] )
  474. {
  475.     int isym, zzpos;
  476.     int temp;
  478.     isym = 0;
  479.     temp = 0; 
  480.     zzpos = sym[0].type;
  481.     while (isym < nsym && zzpos < 10) {
  482.         temp += abs((int) recon[(U8)sym[isym].value]);
  483.         isym++;
  484.         zzpos += 1 + sym[isym].type; 
  485.     }
  486.     return(temp);
  487. }
  488. #endif
  490. static void idct2_goertzel( SYMBOL sym[], int nsym, S32 x[8][4],
  491.                             S16 recon[], int intra, int clean, int idct_class)
  492. {
  493.     int     i, zzpos, isym;
  494.     S32     even_odd[4][8]; /* Accumulate even/even, even/odd, odd/even, odd/odd */
  495.     S32     temp[4];        /* Used in final butterfly computations */
  496. #ifdef LITTLE_ENDIAN                    
  497.     char    msg[120]; /* Flawfinder: ignore */
  498.     int LUT_index;
  499. #endif
  501.     UNREFERENCED_PARAMETER(clean);
  503. //  The four special class implementations are specific to LITTLE_ENDIAN.
  504. #ifdef LITTLE_ENDIAN                    
  506.     switch (idct_class)
  507.     {
  508.         case GENERAL:
  509.             {
  510.                 memset(even_odd, 0, 128);
  512.                 isym = 0;
  513.                 zzpos = sym[0].type;
  514.                 //  Reconstruct DC coeff
  515.                 if (intra == YES) {
  516.                 recon_intra_dc( (U8) sym[0].value, even_odd[0]);
  517.                 isym++;
  518.                 zzpos += 1 + sym[isym].type;
  519.                 } 
  520.                 else if (zzpos == 0) {
  521.                 recon_dc( (S32) recon[(U8)sym[0].value], even_odd[0]);
  522.                 isym++;
  523.                 zzpos += 1 + sym[isym].type;
  524.                 }
  525.                 //  Init even/odd: reconstruct first hor. AC coeff
  526.                 if (isym < nsym  &&  zzpos == 1) {
  527.                 recon_hor_ac( (S32) recon[(U8)sym[isym].value], even_odd[1]);
  528.                 isym++;
  529.                 zzpos += 1 + sym[isym].type;
  530.                 }
  531.                 //  Init odd/even: reconstruct first vert. AC coeff
  532.                 if (isym < nsym  &&  zzpos == 2) {
  533.                 recon_vert_ac( (S32) recon[(U8)sym[isym].value], even_odd[2]); 
  534.                 isym++;
  535.                 zzpos += 1 + sym[isym].type;
  536.                 }
  537.                 //  Reconstruct remaining coeffs
  538. //  if (clean == YES) {      // activate this for sleazy IDCT decoder
  539.                 while (isym < nsym) {
  540.                 //printf(" Calling update with  zzpos = %dn", zzpos);
  541.                 update( &even_odd[ even_odd_index[zzpos]] [0],
  542.                     (S32) recon[(U8)sym[isym].value],
  543.                     (long (*)[512]) &idct_tab[0][zzpos][0]);
  544.                 isym++;
  545.                 zzpos += 1 + sym[isym].type;
  546.                 }
  547. //    }     // activate this for sleazy IDCT decoder
  548.  //   else {
  549.  //
  550.  // Sleazy reconstruction
  551.  //
  552.  //      while (isym < nsym && zzpos < 10) {
  553.  //       //printf(" Calling update with  zzpos = %dn", zzpos);
  554.  //       update( &even_odd[ even_odd_index[zzpos]] [0],
  555.  //               (S32) recon[(U8)sym[isym].value],  
  556.  //               (U32 (*)[8*8*8])&idct_tab[0][zzpos][0]);
  557.  //       isym++;
  558.  //       zzpos += 1 + sym[isym].type;
  559.  //         }
  560.  //   }             
  561.             }
  562.         break;
  564.         case DC_ONLY:
  565.         case DC_AC_H:
  566.         case DC_AC_V:
  567.         case DC_3:
  568.             {
  569.                 isym = 0;
  570.                 zzpos = sym[0].type;
  571.                 //  Reconstruct DC coeff
  572.                 if (intra == YES) 
  573.                     {
  574.                         LUT_index = (U8)sym[0].value;
  575.                         even_odd[0][0] = intra_dc_tab[LUT_index];
  576.                         isym++;
  577.                         zzpos += 1 + sym[isym].type;
  578.                     } 
  579.                 else if (zzpos == 0) 
  580.                         {
  581.                             LUT_index = (S32)recon[(U8)sym[0].value];
  582.                             if (LUT_index>0)
  583.                                 even_odd[0][0] = dc_tab[LUT_index-1];
  584.                             else if (LUT_index<0)
  585.                                     even_odd[0][0] = -dc_tab[-LUT_index-1];
  586.                             else
  587.                             {
  588.                                 //sprintf(msg, "ERROR:recon_dc called with arg=0");
  589.                                 //H261ErrMsg(msg);
  590.                             }
  591.                             isym++;
  592.                             zzpos += 1 + sym[isym].type;
  593.                         }
  594.                 //  Init even/odd: reconstruct first hor. AC coeff
  595.                 if (isym < nsym  &&  zzpos == 1) {
  596.                 recon_hor_ac( (S32) recon[(U8)sym[isym].value], even_odd[1]);
  597.                 isym++;
  598.                 zzpos += 1 + sym[isym].type;
  599.                 }
  600.                 //  Init odd/even: reconstruct first vert. AC coeff
  601.                 if (isym < nsym  &&  zzpos == 2) {
  602.                 recon_vert_ac( (S32) recon[(U8)sym[isym].value], even_odd[2]); 
  603.                 isym++;
  604.                 zzpos += 1 + sym[isym].type;
  605.                 }   
  606.             }
  607.         break;
  608.                     
  609.         default:
  610.             break;
  611.     }       
  613. #else
  614.                 memset(even_odd, 0, 128);
  616.                 isym = 0;
  617.                 zzpos = sym[0].type;
  618.                 //  Reconstruct DC coeff
  619.                 if (intra == YES) {
  620.                 recon_intra_dc( (U8) sym[0].value, even_odd[0]);
  621.                 isym++;
  622.                 zzpos += 1 + sym[isym].type;
  623.                 } 
  624.                 else if (zzpos == 0) {
  625.                 recon_dc( (S32) recon[(U8)sym[0].value], even_odd[0]);
  626.                 isym++;
  627.                 zzpos += 1 + sym[isym].type;
  628.                 }
  629.                 //  Init even/odd: reconstruct first hor. AC coeff
  630.                 if (isym < nsym  &&  zzpos == 1) {
  631.                 recon_hor_ac( (S32) recon[(U8)sym[isym].value], even_odd[1]);
  632.                 isym++;
  633.                 zzpos += 1 + sym[isym].type;
  634.                 }
  635.                 //  Init odd/even: reconstruct first vert. AC coeff
  636.                 if (isym < nsym  &&  zzpos == 2) {
  637.                 recon_vert_ac( (S32) recon[(U8)sym[isym].value], even_odd[2]); 
  638.                 isym++;
  639.                 zzpos += 1 + sym[isym].type;
  640.                 }
  641.                 //  Reconstruct remaining coeffs
  642. //  if (clean == YES) {      // activate this for sleazy IDCT decoder
  643.                 while (isym < nsym) {
  644.                 //printf(" Calling update with  zzpos = %dn", zzpos);
  645.                 update( &even_odd[ even_odd_index[zzpos]] [0],
  646.                     (S32) recon[(U8)sym[isym].value],  
  647.                     (S32 (*)[8*8*8]) &idct_tab[0][zzpos][0]);
  648.                 isym++;
  649.                 zzpos += 1 + sym[isym].type;
  650.                 }
  651. //    }     // activate this for sleazy IDCT decoder
  652.  //   else {
  653.  //
  654.  // Sleazy reconstruction
  655.  //
  656.  //      while (isym < nsym && zzpos < 10) {
  657.  //       //printf(" Calling update with  zzpos = %dn", zzpos);
  658.  //       update( &even_odd[ even_odd_index[zzpos]] [0],
  659.  //               (S32) recon[(U8)sym[isym].value],  
  660.  //               (U32 (*)[8*8*8]) &idct_tab[0][zzpos][0]);
  661.  //       isym++;
  662.  //       zzpos += 1 + sym[isym].type;
  663.  //         }
  664.  //   }             
  665. #endif
  667. #ifdef LITTLE_ENDIAN
  669.     //  Final butterflies
  670.     switch (idct_class)
  671.     {
  672.     //  DC only case
  673.         case DC_ONLY:
  674.             {
  675.                 temp[0] = even_odd[0][0];                   
  676.                 temp[0] += (0x10001L << (FRACBITS-1));      
  678.                 x[0][0] = temp[0];
  679.             }
  680.         break;
  681.         
  682.     //  DC + 1 horizontal AC case   
  683.         case DC_AC_H:
  684.              {
  685.                 temp[0] = even_odd[0][0];
  686.                 
  687.                 temp[0] += (0x10001L << (FRACBITS-1));
  688.                 
  689.                 x[0][0] = temp[0] + even_odd[1][0];
  690.                 x[0][2] = temp[0] - even_odd[1][0];
  691.                 x[0][1] = temp[0] + even_odd[1][1];
  692.                 x[0][3] = temp[0] - even_odd[1][1];
  693.              }
  694.         break;   
  695.     // DC + 1 vertical AC case
  696.         case DC_AC_V:
  697.              {
  698.                 for (i = 0; i < 4; i++)
  699.                     {
  700.                         temp[0] = even_odd[0][0] + even_odd[2][2*i];
  701.                         temp[1] = even_odd[0][0] - even_odd[2][2*i];
  703.                         temp[0] += (0x10001L << (FRACBITS-1));    
  704.                         temp[1] += (0x10001L << (FRACBITS-1));    
  706.                         x[i][0]     = temp[0];
  707.                         x[i][1]     = temp[0];
  708.                         x[i][2]     = temp[0];
  709.                         x[i][3]     = temp[0];                                              
  710.                         x[7-i][0]   = temp[1];
  711.                         x[7-i][1]   = temp[1];
  712.                         x[7-i][2]   = temp[1];
  713.                         x[7-i][3]   = temp[1];                                                                      
  714.                     }
  715.              }      
  716.         break;                              
  717.     // DC + 1 vertical AC + 1 horizontal AC case                                    
  718.         case DC_3:
  719.              {
  720.                 for (i = 0; i < 4; i++)
  721.                     {
  722.                         temp[0] = even_odd[0][0] + even_odd[2][2*i];
  723.                         temp[2] = even_odd[0][0] - even_odd[2][2*i];
  725.                         temp[0] += (0x10001L << (FRACBITS-1));    
  726.                         temp[2] += (0x10001L << (FRACBITS-1));    
  728.                         x[i][0]     = temp[0] + even_odd[1][2*i];
  729.                         x[i][2]     = temp[0] - even_odd[1][2*i];                                               
  730.                         x[7-i][0]   = temp[2] + even_odd[1][2*i];
  731.                         x[7-i][2]   = temp[2] - even_odd[1][2*i];
  732.                         x[i][1]     = temp[0] + even_odd[1][2*i+1];
  733.                         x[i][3]     = temp[0] - even_odd[1][2*i+1];                                             
  734.                         x[7-i][1]   = temp[2] + even_odd[1][2*i+1];
  735.                         x[7-i][3]   = temp[2] - even_odd[1][2*i+1];
  736.                     }
  737.              }
  738.         break;   
  739.         case GENERAL:
  740.             {
  741.                 for (i = 0; i < 4; i++) 
  742.                     {
  743.                     // j=0
  744.                         temp[0] = even_odd[0][2*i] + even_odd[2][2*i];
  745.                         temp[2] = even_odd[0][2*i] - even_odd[2][2*i];
  746.                         temp[1] = even_odd[1][2*i] + even_odd[3][2*i];
  747.                         temp[3] = even_odd[1][2*i] - even_odd[3][2*i];
  748.                         temp[0] += (0x10001L << (FRACBITS-1));    /* Round */
  749.                         x[i][0] = temp[0] + temp[1];
  750.                         x[i][2] = temp[0] - temp[1];
  751.                         temp[2] += (0x10001L << (FRACBITS-1));    /* Round */
  752.                         x[7-i][0] = temp[2] + temp[3];
  753.                         x[7-i][2] = temp[2] - temp[3];
  754.                     // j=1
  755.                         temp[0] = even_odd[0][2*i+1] + even_odd[2][2*i+1];
  756.                         temp[2] = even_odd[0][2*i+1] - even_odd[2][2*i+1];
  757.                         temp[1] = even_odd[1][2*i+1] + even_odd[3][2*i+1];
  758.                         temp[3] = even_odd[1][2*i+1] - even_odd[3][2*i+1];
  759.                         temp[0] += (0x10001L << (FRACBITS-1));    /* Round */
  760.                         x[i][1] = temp[0] + temp[1];
  761.                         x[i][3] = temp[0] - temp[1];
  762.                         temp[2] += (0x10001L << (FRACBITS-1));    /* Round */
  763.                         x[7-i][1] = temp[2] + temp[3];
  764.                         x[7-i][3] = temp[2] - temp[3];
  765.                 }
  766.             }
  767.         break;
  768.     
  769.         default:
  770.             break;
  771.     }
  772. #else
  773.             {
  774.                 for (i = 0; i < 4; i++) 
  775.                     {
  776.                     // j=0
  777.                         temp[0] = even_odd[0][2*i] + even_odd[2][2*i];
  778.                         temp[2] = even_odd[0][2*i] - even_odd[2][2*i];
  779.                         temp[1] = even_odd[1][2*i] + even_odd[3][2*i];
  780.                         temp[3] = even_odd[1][2*i] - even_odd[3][2*i];
  781.                         temp[0] += (0x10001L << (FRACBITS-1));    /* Round */
  782.                         x[i][0] = temp[0] + temp[1];
  783.                         x[i][2] = temp[0] - temp[1];
  784.                         temp[2] += (0x10001L << (FRACBITS-1));    /* Round */
  785.                         x[7-i][0] = temp[2] + temp[3];
  786.                         x[7-i][2] = temp[2] - temp[3];
  787.                     // j=1
  788.                         temp[0] = even_odd[0][2*i+1] + even_odd[2][2*i+1];
  789.                         temp[2] = even_odd[0][2*i+1] - even_odd[2][2*i+1];
  790.                         temp[1] = even_odd[1][2*i+1] + even_odd[3][2*i+1];
  791.                         temp[3] = even_odd[1][2*i+1] - even_odd[3][2*i+1];
  792.                         temp[0] += (0x10001L << (FRACBITS-1));    /* Round */
  793.                         x[i][1] = temp[0] + temp[1];
  794.                         x[i][3] = temp[0] - temp[1];
  795.                         temp[2] += (0x10001L << (FRACBITS-1));    /* Round */
  796.                         x[7-i][1] = temp[2] + temp[3];
  797.                         x[7-i][3] = temp[2] - temp[3];
  798.                 }
  799.             }
  800. #endif                          
  801.     return;
  802. }
  805. #ifdef DO_H263_PLUS
  806. //  recon_advanced_intra_dc - Reconstruct DC coeff in INTRA block
  807. static void recon_advanced_intra_dc( U8 index, S32 vec[8])
  808. {
  809.     int j, temp;
  810.     double bfunc;
  811.     bfunc = SCALE_FACTOR * dctfunc(0,0) * dctfunc(0,0);
  812.     temp = 8 * index;
  813.     temp = dct_tab_entry( temp * bfunc, temp * bfunc);
  814.     for (j = 0; j < 8; j++) {
  815.         vec[j] = temp;
  816.     }
  817.     return;
  818. }
  820. //
  821. // Quick implementation of intra prediction
  822. //
  823. extern void idct2_advanced_intra( SYMBOL sym[], int nsym, S32 x[8][4], S16 recon[],
  824.                             U8 rDCpred, S8 rACpred[8], U8 rDCstore[1], S8 rACstore[8], 
  825.                             U8 cDCpred, S8 cACpred[8], U8 cDCstore[1], S8 cACstore[8],
  826.                             int predtype, int fixedDC, int leftBoundary, int upperBoundary)
  827. {
  828.     int     i, pos, isym;
  829.     S32     even_odd[4][8]; /* Accumulate even/even, even/odd, odd/even, odd/odd */
  830.     S32     temp[4];        /* Used in final butterfly computations */
  831.     int     skip;
  832.     S8      value;
  833.     int    *scan_to_zz;
  834.     int    *inv_scan_order;
  836.     memset(even_odd, 0, 128);
  837.     
  838.     // in advanced intra mode, the AC and DC are coded in the same way, so it
  839.     // is possible for the DC residual to be zero and the first symbol to 
  840.     // have a non-trivial zero run
  841.     if(nsym) {
  842.         if(sym[0].type) {
  843.             value = 0;
  844.             isym = 0;
  845.             skip = sym[0].type - 1; // we'll take care of DC outside the loop
  846.         } else {
  847.             value = sym[0].value;
  848.             isym = 1;
  849.             skip = sym[isym].type;
  850.         }
  851.     } else {
  852.         value = 0;
  853.         isym = 0;
  854.         skip = 0;
  855.     }
  857.     //  Reconstruct DC coeff
  858.     switch(predtype) {
  859.     case ADV_INTRA_PRED_DC_ONLY:
  860.         scan_to_zz = &zigzag_to_zigzag[0];
  861.         inv_scan_order = &InvZZ[0];
  862.         rDCstore[0] = cDCstore[0] = (U8)(value + (( 
  863.             (upperBoundary ? cDCpred : rDCpred) + // use row predictor unless on upper boundary
  864.             (leftBoundary ? rDCpred : cDCpred) + // use column predictor unless on left boundary
  865.             1)>>1) );
  866.         break;
  867.     case ADV_INTRA_PRED_COLUMN:
  868.         scan_to_zz = &alt_ver_to_zigzag[0];
  869.         inv_scan_order = &inv_alt_ver_scan_no_reorder[0];
  870.         rDCstore[0] = cDCstore[0] = (U8)(value + cDCpred);
  871.         break;
  872.     case ADV_INTRA_PRED_ROW:
  873.         scan_to_zz = &alt_hor_to_zigzag[0];
  874.         inv_scan_order = &inv_alt_hor_scan_no_reorder[0];
  875.         rDCstore[0] = cDCstore[0] = (U8)(value + rDCpred);
  876.         break;
  877.     case ADV_INTRA_PRED_NONE:
  878.         scan_to_zz = &zigzag_to_zigzag[0];
  879.         inv_scan_order = &InvZZ[0];
  880.         rDCstore[0] = cDCstore[0] = (U8)(value);
  881.         break;
  882.     }
  884.     // We deviate from the H.263+ spec and the standard H.263 8-bit INTRA_DC quantizer
  885.     // for small quantizer values so that we avoid problems with the dynamic range
  886.     // getting too small
  887.     if(fixedDC) {
  888.         recon_advanced_intra_dc( rDCstore[0], even_odd[0]);
  889.     } else {
  890.         if(rDCstore[0]) update( &even_odd[even_odd_index[0]][0],
  891.                         (S32) recon[rDCstore[0]],  
  892.                         (S32 (*)[8*8*8]) &idct_tab[0][0][0]);
  893.     }
  896.     for(pos=1; pos<64; pos++)
  897.     {
  898.        // compute the quantized AC coefficient
  899.         if(skip || isym>=nsym) {
  900.             value = 0;
  901.             skip--;
  902.         } else {
  903.             value = sym[isym++].value;
  904.             skip = sym[isym].type;
  905.         }
  906.          // row predict and store reconstructed
  907.         if(inv_scan_order[pos] < 8) {
  908.             if(predtype == ADV_INTRA_PRED_ROW)
  909.                 value += rACpred[inv_scan_order[pos]];
  910.             rACstore[inv_scan_order[pos]] = value;
  911.         }
  912.          // col predict and store reconstructed
  913.         if((inv_scan_order[pos] & 7) == 0) {
  914.             if(predtype == ADV_INTRA_PRED_COLUMN)
  915.                 value += cACpred[inv_scan_order[pos]>>3];
  916.             cACstore[inv_scan_order[pos]>>3] = value;
  917.         }
  918.     
  919.         // note that both even_odd_index and idct_tab assume that we are indexing
  920.         // by zigzag order; hence the conversion of the variable pos
  921.         if(value) update( &even_odd[ even_odd_index[scan_to_zz[pos]]] [0],
  922.                     (S32) recon[ (U8)value],  
  923.                     (S32 (*)[8*8*8]) &idct_tab[0][scan_to_zz[pos]][0]);
  924.     }
  927.     // Do the final butterfly
  928.     for (i = 0; i < 4; i++) 
  929.     {
  930.         // j=0
  931.         temp[0] = even_odd[0][2*i] + even_odd[2][2*i];
  932.         temp[2] = even_odd[0][2*i] - even_odd[2][2*i];
  933.         temp[1] = even_odd[1][2*i] + even_odd[3][2*i];
  934.         temp[3] = even_odd[1][2*i] - even_odd[3][2*i];
  935.         temp[0] += (0x10001L << (FRACBITS-1));    /* Round */
  936.         x[i][0] = temp[0] + temp[1];
  937.         x[i][2] = temp[0] - temp[1];
  938.         temp[2] += (0x10001L << (FRACBITS-1));    /* Round */
  939.         x[7-i][0] = temp[2] + temp[3];
  940.         x[7-i][2] = temp[2] - temp[3];
  941.         // j=1
  942.         temp[0] = even_odd[0][2*i+1] + even_odd[2][2*i+1];
  943.         temp[2] = even_odd[0][2*i+1] - even_odd[2][2*i+1];
  944.         temp[1] = even_odd[1][2*i+1] + even_odd[3][2*i+1];
  945.         temp[3] = even_odd[1][2*i+1] - even_odd[3][2*i+1];
  946.         temp[0] += (0x10001L << (FRACBITS-1));    /* Round */
  947.         x[i][1] = temp[0] + temp[1];
  948.         x[i][3] = temp[0] - temp[1];
  949.         temp[2] += (0x10001L << (FRACBITS-1));    /* Round */
  950.         x[7-i][1] = temp[2] + temp[3];
  951.         x[7-i][3] = temp[2] - temp[3];
  952.     }
  954.     return;
  955. }
  958. //  Idct2 - Reconstruct DCT coeffs, perform IDCT, and clip to allowed pixel range */
  959. //  Requires nsym > 0
  960. extern void Idct2AdvancedIntra( SYMBOL sym[], int nsym, PIXEL x[], int xdim, S16 recon[],
  961.                                U8 rDCpred, S8 rACpred[8], U8 rDCstore[1], S8 rACstore[8], 
  962.                                U8 cDCpred, S8 cACpred[8], U8 cDCstore[1], S8 cACstore[8],
  963.                                int predtype, int fixedDC, int leftBoundary, int upperBoundary)
  964. {
  965.     union {
  966.         S16   bshort[8][8];
  967.         S32    blong[8][4];
  968.     } block;    /* Output from IDCT */
  970.     idct2_advanced_intra( sym, nsym, block.blong, recon, 
  971.         rDCpred, rACpred, rDCstore, rACstore,
  972.         cDCpred, cACpred, cDCstore, cACstore,
  973.         predtype, fixedDC,leftBoundary,upperBoundary);
  974.     idct2_clip(x, xdim, block.blong, GENERAL);
  976.     return;
  977. }
  980. #endif
  983. //  recon_intra_dc - Reconstruct DC coeff in INTRA block
  984. static void recon_intra_dc( U8 index, S32 vec[8])
  985. {
  986.     int j, temp;
  987.     
  988.     temp = intra_dc_tab [index];
  989.     for (j = 0; j < 8; j++) {
  990.         vec[j] = temp;
  991.     }
  992.     return;
  993. }
  996. //  recon_dc - Reconstruct DC coeff
  997. static void recon_dc( S32 y, S32 vec[8])
  998. {
  999.     int j, temp;
  1000.     char msg[120]; /* Flawfinder: ignore */
  1001.     
  1002.     if (y > 0) {
  1003.         temp = dc_tab[ y - 1 ];
  1004.     } else if (y < 0) {
  1005.         temp = -dc_tab[ -y - 1 ];
  1006.     } else {
  1007.         //sprintf( msg, "ERROR: recon_dc called with arg=0");
  1008.         //H261ErrMsg( msg );
  1009.     }
  1010.     for (j = 0; j < 8; j++) {
  1011.         vec[j] = temp;
  1012.     }
  1013.     return;
  1014. }
  1017. //  recon_hor_ac - Reconstruct first hor. AC coeff
  1018. static void recon_hor_ac( S32 y, S32 vec[8])
  1019. {
  1020.     int j, temp0, temp1;
  1021.     char msg[120]; /* Flawfinder: ignore */
  1022.     
  1023.     if (y > 0) {
  1024.         temp0 = hor_ac_tab[ y - 1 ] [0];
  1025.         temp1 = hor_ac_tab[ y - 1 ] [1];
  1026.     } else if (y < 0) {
  1027.         temp0 = -hor_ac_tab[ -y - 1 ] [0];
  1028.         temp1 = -hor_ac_tab[ -y - 1 ] [1];
  1029.     } else {
  1030.         //sprintf( msg, "ERROR: recon_hor_ac called with arg=0");
  1031.         //H261ErrMsg( msg );
  1032.     }
  1033.     for (j = 0; j < 8; j += 2) {
  1034.         vec[j] = temp0;
  1035.         vec[j+1] = temp1;
  1036.     }
  1037.     return;
  1038. }
  1041. //  recon_vert_ac - Reconstruct first vert. AC coeff
  1042. static void recon_vert_ac( S32 y, S32 vec[8])
  1043. {
  1044.     int j, temp, index;
  1045.     char msg[120]; /* Flawfinder: ignore */
  1046.     
  1047.     if (y > 0) {
  1048.         for (j = 0; j < 4; j++) {
  1049.             vec[2*j] = vert_ac_tab[ y - 1 ] [j];
  1050.             vec[2*j+1] = vert_ac_tab[ y - 1 ] [j];
  1051.         }
  1052.     } else if (y < 0) {
  1053.         index = -y - 1;
  1054.         for (j = 0; j < 4; j++) {
  1055.             temp = -vert_ac_tab[ index ] [j];
  1056.             vec[2*j] = temp;
  1057.             vec[2*j+1] = temp;
  1058.         }
  1059.     } else {
  1060.         //sprintf( msg, "ERROR: recon_vert_ac called with arg=0");
  1061.         //H261ErrMsg( msg );
  1062.     }
  1063.     return;
  1064. }
  1067. static void update( S32 x[8], S32 index, S32 table[][8*8*8])
  1068. {
  1069.     int tab1_index, tab2_index;
  1070.     char msg[120]; /* Flawfinder: ignore */
  1071.     
  1072.     //printf( "Entered updaten" );
  1073.     if (index > 0) {
  1074.         index -= 1;
  1075.         tab1_index = index & ((0x1L << IDCT_NTAB1_BITS) - 1);  /* index % SIZE */
  1076.         tab2_index = index >> IDCT_NTAB1_BITS;
  1077.         //printf( "update plus: tab2 = %d    tab1 = %dn", tab2_index, tab1_index);
  1078.         //printf( "x0 = %d  table = %dn", x[0], table[tab1_index][0]);
  1079.         x[0] += table [tab1_index][0];
  1080.         x[1] += table [tab1_index][1];
  1081.         x[2] += table [tab1_index][2];
  1082.         x[3] += table [tab1_index][3];
  1083.         x[4] += table [tab1_index][4];
  1084.         x[5] += table [tab1_index][5];
  1085.         x[6] += table [tab1_index][6];
  1086.         x[7] += table [tab1_index][7];
  1087.         if (tab2_index != 0) {
  1088.             //printf( "x0 = %d  table = %dn", x[0],
  1089.             //            table[tab2_index - 1 + IDCT_NTAB1_SIZE][0]);
  1090.             x[0] += table [tab2_index - 1 + IDCT_NTAB1_SIZE][0];
  1091.             x[1] += table [tab2_index - 1 + IDCT_NTAB1_SIZE][1];
  1092.             x[2] += table [tab2_index - 1 + IDCT_NTAB1_SIZE][2];
  1093.             x[3] += table [tab2_index - 1 + IDCT_NTAB1_SIZE][3];
  1094.             x[4] += table [tab2_index - 1 + IDCT_NTAB1_SIZE][4];
  1095.             x[5] += table [tab2_index - 1 + IDCT_NTAB1_SIZE][5];
  1096.             x[6] += table [tab2_index - 1 + IDCT_NTAB1_SIZE][6];
  1097.             x[7] += table [tab2_index - 1 + IDCT_NTAB1_SIZE][7];
  1098.         //printf( "x0 = %dn", x[0]);
  1099.         }
  1100.     } else if (index < 0) {
  1101.         index = -index - 1;
  1102.         tab1_index = index & ((0x1L << IDCT_NTAB1_BITS) - 1);  /* index % SIZE */
  1103.         tab2_index = index >> IDCT_NTAB1_BITS;
  1104.         //printf( "update minus: tab2 = %d    tab1 = %dn", tab2_index, tab1_index);
  1105.         x[0] -= table [tab1_index][0];
  1106.         x[1] -= table [tab1_index][1];
  1107.         x[2] -= table [tab1_index][2];
  1108.         x[3] -= table [tab1_index][3];
  1109.         x[4] -= table [tab1_index][4];
  1110.         x[5] -= table [tab1_index][5];
  1111.         x[6] -= table [tab1_index][6];
  1112.         x[7] -= table [tab1_index][7];
  1113.         if (tab2_index != 0) {
  1114.             x[0] -= table [tab2_index - 1 + IDCT_NTAB1_SIZE][0];
  1115.             x[1] -= table [tab2_index - 1 + IDCT_NTAB1_SIZE][1];
  1116.             x[2] -= table [tab2_index - 1 + IDCT_NTAB1_SIZE][2];
  1117.             x[3] -= table [tab2_index - 1 + IDCT_NTAB1_SIZE][3];
  1118.             x[4] -= table [tab2_index - 1 + IDCT_NTAB1_SIZE][4];
  1119.             x[5] -= table [tab2_index - 1 + IDCT_NTAB1_SIZE][5];
  1120.             x[6] -= table [tab2_index - 1 + IDCT_NTAB1_SIZE][6];
  1121.             x[7] -= table [tab2_index - 1 + IDCT_NTAB1_SIZE][7];
  1122.         }
  1123.     } else if (index == 0) {
  1124.         //sprintf( msg, "ERROR: update called with arg=0");
  1125.         //H261ErrMsg( msg );
  1126.     }
  1127.     return;
  1128. }
  1131. static double dctfunc (int freq, int index)
  1132. {
  1133.     if (freq == 0) {
  1134.         return (1./sqrt(8.));
  1135.     }
  1136.     return ( cos(PI*freq*(index+0.5)/8.) / 2.);
  1137. }
  1140. // Turn off "warning C4244: '=' : conversion from 'double ' to 'long ', 
  1141. //     possible loss of data" for MSVC 4.0
  1142. #pragma message("Turning off ConvFromDblToLong Warning")
  1143. #pragma warning(disable:4244)
  1146. //  Round x and y; put x in lower halfword, y in upper halfword (if little-endian)
  1147. static S32 dct_tab_entry (double x, double y)
  1148. {
  1149.     S32 ix, iy;
  1151.     ix = x * 65536.;    /* Mult by 2**16 */
  1152.     iy = y * 65536.;
  1153. #ifdef LITTLE_ENDIAN    /* x in lower halfword, y in upper */
  1154.     return (combine (iy, ix));
  1155. #elif defined BIG_ENDIAN    /* x in upper halfword, y in lower */
  1156.     return (combine (ix, iy));
  1157. #else
  1158. #   error
  1159. #endif
  1160. }
  1162. // Turn back on "warning C4244: '=' : conversion from 'double ' to 'long ', 
  1163. //     possible loss of data" for MSVC 4.0
  1164. #pragma warning(default:4244)
  1167. //  iy in upper halfword, ix>>16 in lower
  1168. static S32 combine (S32 iy, S32 ix)
  1169. {
  1170.     S32 low_tab, high_tab;
  1172. // Note: this should not be a big-endian problem because calls to this function
  1173. // exchange the order of ix and iy as needed. (Though wouldn't it have been
  1174. // simpler to make the change here?) tkent
  1175.     low_tab = (ix + 0x8000L) >> 16  &  0x0000ffffL;
  1176.     high_tab = iy + 0x8000L - low_tab;
  1177.     high_tab &= 0xffff0000L;
  1178.     return (low_tab | high_tab);
  1179. }