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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
idct.c
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：44k
源码类别：

Symbian

开发平台：

Visual C++

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