ReactOS Development > Doxygen

00001 /*
00002     tabinit.c: initialize tables...
00003 
00004     copyright ?-2008 by the mpg123 project - free software under the terms of the LGPL 2.1
00005     see COPYING and AUTHORS files in distribution or http://mpg123.org
00006     initially written by Michael Hipp
00007 */
00008 
00009 #include "mpg123lib_intern.h"
00010 #include "debug.h"
00011 
00012 /* That altivec alignment part here should not hurt generic code, I hope */
00013 #ifdef OPT_ALTIVEC
00014 static ALIGNED(16) real cos64[16];
00015 static ALIGNED(16) real cos32[8];
00016 static ALIGNED(16) real cos16[4];
00017 static ALIGNED(16) real cos8[2];
00018 static ALIGNED(16) real cos4[1];
00019 #elif defined(REAL_IS_FIXED) && defined(PRECALC_TABLES)
00020 static real cos64[16] = 
00021 {
00022     8398725,8480395,8647771,8909416,9279544,9780026,10443886,11321405,
00023     12491246,14081950,16316987,19619946,24900150,34523836,57170182,170959967
00024 };
00025 static real cos32[8] =
00026 {
00027     8429197,8766072,9511743,10851869,13223040,17795219,28897867,85583072
00028 };
00029 static real cos16[4] =
00030 {
00031     8552951,10088893,15099095,42998586
00032 };
00033 static real cos8[2] =
00034 {
00035     9079764,21920489
00036 };
00037 static real cos4[1] =
00038 {
00039     11863283
00040 };
00041 #else
00042 static real cos64[16],cos32[8],cos16[4],cos8[2],cos4[1];
00043 #endif
00044 
00045 real *pnts[] = { cos64,cos32,cos16,cos8,cos4 };
00046 
00047 
00048 static long intwinbase[] = {
00049      0,    -1,    -1,    -1,    -1,    -1,    -1,    -2,    -2,    -2,
00050     -2,    -3,    -3,    -4,    -4,    -5,    -5,    -6,    -7,    -7,
00051     -8,    -9,   -10,   -11,   -13,   -14,   -16,   -17,   -19,   -21,
00052    -24,   -26,   -29,   -31,   -35,   -38,   -41,   -45,   -49,   -53,
00053    -58,   -63,   -68,   -73,   -79,   -85,   -91,   -97,  -104,  -111,
00054   -117,  -125,  -132,  -139,  -147,  -154,  -161,  -169,  -176,  -183,
00055   -190,  -196,  -202,  -208,  -213,  -218,  -222,  -225,  -227,  -228,
00056   -228,  -227,  -224,  -221,  -215,  -208,  -200,  -189,  -177,  -163,
00057   -146,  -127,  -106,   -83,   -57,   -29,     2,    36,    72,   111,
00058    153,   197,   244,   294,   347,   401,   459,   519,   581,   645,
00059    711,   779,   848,   919,   991,  1064,  1137,  1210,  1283,  1356,
00060   1428,  1498,  1567,  1634,  1698,  1759,  1817,  1870,  1919,  1962,
00061   2001,  2032,  2057,  2075,  2085,  2087,  2080,  2063,  2037,  2000,
00062   1952,  1893,  1822,  1739,  1644,  1535,  1414,  1280,  1131,   970,
00063    794,   605,   402,   185,   -45,  -288,  -545,  -814, -1095, -1388,
00064  -1692, -2006, -2330, -2663, -3004, -3351, -3705, -4063, -4425, -4788,
00065  -5153, -5517, -5879, -6237, -6589, -6935, -7271, -7597, -7910, -8209,
00066  -8491, -8755, -8998, -9219, -9416, -9585, -9727, -9838, -9916, -9959,
00067  -9966, -9935, -9863, -9750, -9592, -9389, -9139, -8840, -8492, -8092,
00068  -7640, -7134, -6574, -5959, -5288, -4561, -3776, -2935, -2037, -1082,
00069    -70,   998,  2122,  3300,  4533,  5818,  7154,  8540,  9975, 11455,
00070  12980, 14548, 16155, 17799, 19478, 21189, 22929, 24694, 26482, 28289,
00071  30112, 31947, 33791, 35640, 37489, 39336, 41176, 43006, 44821, 46617,
00072  48390, 50137, 51853, 53534, 55178, 56778, 58333, 59838, 61289, 62684,
00073  64019, 65290, 66494, 67629, 68692, 69679, 70590, 71420, 72169, 72835,
00074  73415, 73908, 74313, 74630, 74856, 74992, 75038 };
00075 
00076 void prepare_decode_tables()
00077 {
00078 #if !defined(REAL_IS_FIXED) || !defined(PRECALC_TABLES)
00079   int i,k,kr,divv;
00080   real *costab;
00081 
00082   for(i=0;i<5;i++)
00083   {
00084     kr=0x10>>i; divv=0x40>>i;
00085     costab = pnts[i];
00086     for(k=0;k<kr;k++)
00087       costab[k] = DOUBLE_TO_REAL(1.0 / (2.0 * cos(M_PI * ((double) k * 2.0 + 1.0) / (double) divv)));
00088   }
00089 #endif
00090 }
00091 
00092 #ifdef OPT_MMXORSSE
00093 #ifndef OPT_X86_64
00094 void make_decode_tables_mmx_asm(long scaleval, float* decwin_mmx, float *decwins);
00095 void make_decode_tables_mmx(mpg123_handle *fr)
00096 {
00097     debug("MMX decode tables");
00098     /* Take care: The scale should be like before, when we didn't have float output all around. */
00099     make_decode_tables_mmx_asm((long)((fr->lastscale < 0 ? fr->p.outscale : fr->lastscale)*SHORT_SCALE), fr->decwin_mmx, fr->decwins);
00100     debug("MMX decode tables done");
00101 }
00102 #else
00103 
00104 /* This mimics round() as defined in C99. We stay C89. */
00105 static int rounded(double f)
00106 {
00107     return (int)(f>0 ? floor(f+0.5) : ceil(f-0.5));
00108 }
00109 
00110 /* x86-64 doesn't use asm version */
00111 void make_decode_tables_mmx(mpg123_handle *fr)
00112 {
00113     int i,j,val;
00114     int idx = 0;
00115     short *ptr = (short *)fr->decwins;
00116     /* Scale is always based on 1.0 . */
00117     double scaleval = -0.5*(fr->lastscale < 0 ? fr->p.outscale : fr->lastscale);
00118     debug1("MMX decode tables with scaleval %g", scaleval);
00119     for(i=0,j=0;i<256;i++,j++,idx+=32)
00120     {
00121         if(idx < 512+16)
00122         fr->decwin_mmx[idx+16] = fr->decwin_mmx[idx] = DOUBLE_TO_REAL((double) intwinbase[j] * scaleval);
00123         
00124         if(i % 32 == 31)
00125         idx -= 1023;
00126         if(i % 64 == 63)
00127         scaleval = - scaleval;
00128     }
00129     
00130     for( /* i=256 */ ;i<512;i++,j--,idx+=32)
00131     {
00132         if(idx < 512+16)
00133         fr->decwin_mmx[idx+16] = fr->decwin_mmx[idx] = DOUBLE_TO_REAL((double) intwinbase[j] * scaleval);
00134         
00135         if(i % 32 == 31)
00136         idx -= 1023;
00137         if(i % 64 == 63)
00138         scaleval = - scaleval;
00139     }
00140     
00141     for(i=0; i<512; i++) {
00142         if(i&1) val = rounded(fr->decwin_mmx[i]*0.5);
00143         else val = rounded(fr->decwin_mmx[i]*-0.5);
00144         if(val > 32767) val = 32767;
00145         else if(val < -32768) val = -32768;
00146         ptr[i] = val;
00147     }
00148     for(i=512; i<512+32; i++) {
00149         if(i&1) val = rounded(fr->decwin_mmx[i]*0.5);
00150         else val = 0;
00151         if(val > 32767) val = 32767;
00152         else if(val < -32768) val = -32768;
00153         ptr[i] = val;
00154     }
00155     for(i=0; i<512; i++) {
00156         val = rounded(fr->decwin_mmx[511-i]*-0.5);
00157         if(val > 32767) val = 32767;
00158         else if(val < -32768) val = -32768;
00159         ptr[512+32+i] = val;
00160     }
00161     debug("decode tables done");
00162 }
00163 #endif
00164 #endif
00165 
00166 void make_decode_tables(mpg123_handle *fr)
00167 {
00168     int i,j;
00169     int idx = 0;
00170     /* Scale is always based on 1.0 . */
00171     double scaleval = -0.5*(fr->lastscale < 0 ? fr->p.outscale : fr->lastscale);
00172     debug1("decode tables with scaleval %g", scaleval);
00173 #ifdef REAL_IS_FIXED
00174     long scaleval_long = DOUBLE_TO_REAL_15(scaleval);
00175 #endif
00176     for(i=0,j=0;i<256;i++,j++,idx+=32)
00177     {
00178         if(idx < 512+16)
00179 #ifdef REAL_IS_FIXED
00180         fr->decwin[idx+16] = fr->decwin[idx] = REAL_SCALE_WINDOW(intwinbase[j] * scaleval_long);
00181 #else
00182         fr->decwin[idx+16] = fr->decwin[idx] = DOUBLE_TO_REAL((double) intwinbase[j] * scaleval);
00183 #endif
00184 
00185         if(i % 32 == 31)
00186         idx -= 1023;
00187         if(i % 64 == 63)
00188 #ifdef REAL_IS_FIXED
00189         scaleval_long = - scaleval_long;
00190 #else
00191         scaleval = - scaleval;
00192 #endif
00193     }
00194 
00195     for( /* i=256 */ ;i<512;i++,j--,idx+=32)
00196     {
00197         if(idx < 512+16)
00198 #ifdef REAL_IS_FIXED
00199         fr->decwin[idx+16] = fr->decwin[idx] = REAL_SCALE_WINDOW(intwinbase[j] * scaleval_long);
00200 #else
00201         fr->decwin[idx+16] = fr->decwin[idx] = DOUBLE_TO_REAL((double) intwinbase[j] * scaleval);
00202 #endif
00203 
00204         if(i % 32 == 31)
00205         idx -= 1023;
00206         if(i % 64 == 63)
00207 #ifdef REAL_IS_FIXED
00208         scaleval_long = - scaleval_long;
00209 #else
00210         scaleval = - scaleval;
00211 #endif
00212     }
00213 #if defined(OPT_X86_64) || defined(OPT_ALTIVEC) || defined(OPT_SSE) || defined(OPT_ARM)
00214     if(fr->cpu_opts.type == x86_64 || fr->cpu_opts.type == altivec || fr->cpu_opts.type == sse || fr->cpu_opts.type == arm)
00215     { /* for float SSE / AltiVec / ARM decoder */
00216         for(i=512; i<512+32; i++)
00217         {
00218             fr->decwin[i] = (i&1) ? fr->decwin[i] : 0;
00219         }
00220         for(i=0; i<512; i++)
00221         {
00222             fr->decwin[512+32+i] = -fr->decwin[511-i];
00223         }
00224     }
00225 #endif
00226     debug("decode tables done");
00227 }
00228 
00229 #ifndef NO_8BIT
00230 int make_conv16to8_table(mpg123_handle *fr)
00231 {
00232   int i;
00233     int mode = fr->af.encoding;
00234 
00235   /*
00236    * ????: 8.0 is right but on SB cards '2.0' is a better value ???
00237    */
00238   const double mul = 8.0;
00239 
00240   if(!fr->conv16to8_buf){
00241     fr->conv16to8_buf = (unsigned char *) malloc(8192);
00242     if(!fr->conv16to8_buf) {
00243       fr->err = MPG123_ERR_16TO8TABLE;
00244       if(NOQUIET) error("Can't allocate 16 to 8 converter table!");
00245       return -1;
00246     }
00247     fr->conv16to8 = fr->conv16to8_buf + 4096;
00248   }
00249 
00250   if(fr->af.encoding == MPG123_ENC_ULAW_8){
00251     double m=127.0 / log(256.0);
00252     int c1;
00253 
00254     for(i=-4096;i<4096;i++) {
00255 /* dunno whether this is a valid transformation rule ?!?!? */
00256       if(i < 0)
00257         c1 = 127 - (int) (log( 1.0 - 255.0 * (double) i*mul / 32768.0 ) * m);
00258       else
00259         c1 = 255 - (int) (log( 1.0 + 255.0 * (double) i*mul / 32768.0 ) * m);
00260       if((c1 < 0 || c1 > 255) && NOQUIET) error2("Converror %d %d",i,c1);
00261 
00262       if(c1 == 0)
00263         c1 = 2;
00264       fr->conv16to8[i] = (unsigned char) c1;
00265     }
00266   }
00267   else if(mode == MPG123_ENC_SIGNED_8) {
00268     for(i=-4096;i<4096;i++) {
00269       fr->conv16to8[i] = i>>5;
00270     }
00271   }
00272   else if(mode == MPG123_ENC_UNSIGNED_8) {
00273     for(i=-4096;i<4096;i++) {
00274       fr->conv16to8[i] = (i>>5)+128;
00275     }
00276   }
00277   else {
00278     for(i=-4096;i<4096;i++) {
00279       fr->conv16to8[i] = 0;
00280     }
00281   }
00282     return 0;
00283 }
00284 #endif
00285
Generated on Sat May 26 2012 04:33:02 for ReactOS by
1.7.6.1