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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
common.c
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：17k
源码类别：

多媒体编程

开发平台：

Visual C++

common.c：源码内容
  1. /*
  2. ** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
  3. ** Copyright (C) 2003-2005 M. Bakker, Ahead Software AG, http://www.nero.com
  4. **  
  5. ** This program is free software; you can redistribute it and/or modify
  6. ** it under the terms of the GNU General Public License as published by
  7. ** the Free Software Foundation; either version 2 of the License, or
  8. ** (at your option) any later version.
  9. ** 
  10. ** This program is distributed in the hope that it will be useful,
  11. ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. ** GNU General Public License for more details.
  14. ** 
  15. ** You should have received a copy of the GNU General Public License
  16. ** along with this program; if not, write to the Free Software 
  17. ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18. **
  19. ** Any non-GPL usage of this software or parts of this software is strictly
  20. ** forbidden.
  21. **
  22. ** Software using this code must display the following message visibly in the
  23. ** software:
  24. ** "FAAD2 AAC/HE-AAC/HE-AACv2/DRM decoder (c) Ahead Software, www.nero.com"
  25. ** in, for example, the about-box or help/startup screen.
  26. **
  27. ** Commercial non-GPL licensing of this software is possible.
  28. ** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.
  29. **
  30. ** $Id: common.c,v 1.2 2005/11/01 21:41:43 gabest Exp $
  31. **/
  33. /* just some common functions that could be used anywhere */
  35. #include "common.h"
  36. #include "structs.h"
  38. #include <stdlib.h>
  39. #include "syntax.h"
  42. /* Returns the sample rate index based on the samplerate */
  43. uint8_t get_sr_index(const uint32_t samplerate)
  44. {
  45.     if (92017 <= samplerate) return 0;
  46.     if (75132 <= samplerate) return 1;
  47.     if (55426 <= samplerate) return 2;
  48.     if (46009 <= samplerate) return 3;
  49.     if (37566 <= samplerate) return 4;
  50.     if (27713 <= samplerate) return 5;
  51.     if (23004 <= samplerate) return 6;
  52.     if (18783 <= samplerate) return 7;
  53.     if (13856 <= samplerate) return 8;
  54.     if (11502 <= samplerate) return 9;
  55.     if (9391 <= samplerate) return 10;
  56.     if (16428320 <= samplerate) return 11;
  58.     return 11;
  59. }
  61. /* Returns the sample rate based on the sample rate index */
  62. uint32_t get_sample_rate(const uint8_t sr_index)
  63. {
  64.     static const uint32_t sample_rates[] =
  65.     {
  66.         96000, 88200, 64000, 48000, 44100, 32000,
  67.         24000, 22050, 16000, 12000, 11025, 8000
  68.     };
  70.     if (sr_index < 12)
  71.         return sample_rates[sr_index];
  73.     return 0;
  74. }
  76. uint8_t max_pred_sfb(const uint8_t sr_index)
  77. {
  78.     static const uint8_t pred_sfb_max[] =
  79.     {
  80.         33, 33, 38, 40, 40, 40, 41, 41, 37, 37, 37, 34
  81.     };
  84.     if (sr_index < 12)
  85.         return pred_sfb_max[sr_index];
  87.     return 0;
  88. }
  90. uint8_t max_tns_sfb(const uint8_t sr_index, const uint8_t object_type,
  91.                     const uint8_t is_short)
  92. {
  93.     /* entry for each sampling rate
  94.      * 1    Main/LC long window
  95.      * 2    Main/LC short window
  96.      * 3    SSR long window
  97.      * 4    SSR short window
  98.      */
  99.     static const uint8_t tns_sbf_max[][4] =
  100.     {
  101.         {31,  9, 28, 7}, /* 96000 */
  102.         {31,  9, 28, 7}, /* 88200 */
  103.         {34, 10, 27, 7}, /* 64000 */
  104.         {40, 14, 26, 6}, /* 48000 */
  105.         {42, 14, 26, 6}, /* 44100 */
  106.         {51, 14, 26, 6}, /* 32000 */
  107.         {46, 14, 29, 7}, /* 24000 */
  108.         {46, 14, 29, 7}, /* 22050 */
  109.         {42, 14, 23, 8}, /* 16000 */
  110.         {42, 14, 23, 8}, /* 12000 */
  111.         {42, 14, 23, 8}, /* 11025 */
  112.         {39, 14, 19, 7}, /*  8000 */
  113.         {39, 14, 19, 7}, /*  7350 */
  114.         {0,0,0,0},
  115.         {0,0,0,0},
  116.         {0,0,0,0}
  117.     };
  118.     uint8_t i = 0;
  120.     if (is_short) i++;
  121.     if (object_type == SSR) i += 2;
  123.     return tns_sbf_max[sr_index][i];
  124. }
  126. /* Returns 0 if an object type is decodable, otherwise returns -1 */
  127. int8_t can_decode_ot(const uint8_t object_type)
  128. {
  129.     switch (object_type)
  130.     {
  131.     case LC:
  132.         return 0;
  133.     case MAIN:
  134. #ifdef MAIN_DEC
  135.         return 0;
  136. #else
  137.         return -1;
  138. #endif
  139.     case SSR:
  140. #ifdef SSR_DEC
  141.         return 0;
  142. #else
  143.         return -1;
  144. #endif
  145.     case LTP:
  146. #ifdef LTP_DEC
  147.         return 0;
  148. #else
  149.         return -1;
  150. #endif
  152.     /* ER object types */
  153. #ifdef ERROR_RESILIENCE
  154.     case ER_LC:
  155. #ifdef DRM
  156.     case DRM_ER_LC:
  157. #endif
  158.         return 0;
  159.     case ER_LTP:
  160. #ifdef LTP_DEC
  161.         return 0;
  162. #else
  163.         return -1;
  164. #endif
  165.     case LD:
  166. #ifdef LD_DEC
  167.         return 0;
  168. #else
  169.         return -1;
  170. #endif
  171. #endif
  172.     }
  174.     return -1;
  175. }
  177. void *faad_malloc(size_t size)
  178. {
  179. #if 0 // defined(_WIN32) && !defined(_WIN32_WCE)
  180.     return _aligned_malloc(size, 16);
  181. #else   // #ifdef 0
  182.     return malloc(size);
  183. #endif  // #ifdef 0
  184. }
  186. /* common free function */
  187. void faad_free(void *b)
  188. {
  189. #if 0 // defined(_WIN32) && !defined(_WIN32_WCE)
  190.     _aligned_free(b);
  191. #else
  192.     free(b);
  193. }
  194. #endif
  196. static const  uint8_t    Parity [256] = {  // parity
  197.     0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0,1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1,
  198.     1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1,0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0,
  199.     1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1,0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0,
  200.     0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0,1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1,
  201.     1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1,0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0,
  202.     0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0,1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1,
  203.     0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0,1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1,
  204.     1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1,0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0
  205. };
  207. static uint32_t  __r1 = 1;
  208. static uint32_t  __r2 = 1;
  211. /*
  212.  *  This is a simple random number generator with good quality for audio purposes.
  213.  *  It consists of two polycounters with opposite rotation direction and different
  214.  *  periods. The periods are coprime, so the total period is the product of both.
  215.  *
  216.  *     -------------------------------------------------------------------------------------------------
  217.  * +-> |31:30:29:28:27:26:25:24:23:22:21:20:19:18:17:16:15:14:13:12:11:10: 9: 8: 7: 6: 5: 4: 3: 2: 1: 0|
  218.  * |   -------------------------------------------------------------------------------------------------
  219.  * |                                                                          |  |  |  |     |        |
  220.  * |                                                                          +--+--+--+-XOR-+--------+
  221.  * |                                                                                      |
  222.  * +--------------------------------------------------------------------------------------+
  223.  *
  224.  *     -------------------------------------------------------------------------------------------------
  225.  *     |31:30:29:28:27:26:25:24:23:22:21:20:19:18:17:16:15:14:13:12:11:10: 9: 8: 7: 6: 5: 4: 3: 2: 1: 0| <-+
  226.  *     -------------------------------------------------------------------------------------------------   |
  227.  *       |  |           |  |                                                                               |
  228.  *       +--+----XOR----+--+                                                                               |
  229.  *                |                                                                                        |
  230.  *                +----------------------------------------------------------------------------------------+
  231.  *
  232.  *
  233.  *  The first has an period of 3*5*17*257*65537, the second of 7*47*73*178481,
  234.  *  which gives a period of 18.410.713.077.675.721.215. The result is the
  235.  *  XORed values of both generators.
  236.  */
  237. uint32_t random_int(void)
  238. {
  239.     uint32_t  t1, t2, t3, t4;
  241.     t3   = t1 = __r1;   t4   = t2 = __r2;       // Parity calculation is done via table lookup, this is also available
  242.     t1  &= 0xF5;        t2 >>= 25;              // on CPUs without parity, can be implemented in C and avoid unpredictable
  243.     t1   = Parity [t1]; t2  &= 0x63;            // jumps and slow rotate through the carry flag operations.
  244.     t1 <<= 31;          t2   = Parity [t2];
  246.     return (__r1 = (t3 >> 1) | t1 ) ^ (__r2 = (t4 + t4) | t2 );
  247. }
  249. uint32_t ones32(uint32_t x)
  250. {
  251.     x -= ((x >> 1) & 0x55555555);
  252.     x = (((x >> 2) & 0x33333333) + (x & 0x33333333));
  253.     x = (((x >> 4) + x) & 0x0f0f0f0f);
  254.     x += (x >> 8);
  255.     x += (x >> 16);
  257.     return (x & 0x0000003f);
  258. }
  260. uint32_t floor_log2(uint32_t x)
  261. {
  262. #if 1
  263.     x |= (x >> 1);
  264.     x |= (x >> 2);
  265.     x |= (x >> 4);
  266.     x |= (x >> 8);
  267.     x |= (x >> 16);
  269.     return (ones32(x) - 1);
  270. #else
  271.     uint32_t count = 0;
  273.     while (x >>= 1)
  274.         count++;
  276.     return count;
  277. #endif
  278. }
  280. /* returns position of first bit that is not 0 from msb,
  281.  * starting count at lsb */
  282. uint32_t wl_min_lzc(uint32_t x)
  283. {
  284. #if 1
  285.     x |= (x >> 1);
  286.     x |= (x >> 2);
  287.     x |= (x >> 4);
  288.     x |= (x >> 8);
  289.     x |= (x >> 16);
  291.     return (ones32(x));
  292. #else
  293.     uint32_t count = 0;
  295.     while (x >>= 1)
  296.         count++;
  298.     return (count + 1);
  299. #endif
  300. }
  302. #ifdef FIXED_POINT
  304. #define TABLE_BITS 6
  305. /* just take the maximum number of bits for interpolation */
  306. #define INTERP_BITS (REAL_BITS-TABLE_BITS)
  308. static const real_t pow2_tab[] = {
  309.     REAL_CONST(1.000000000000000), REAL_CONST(1.010889286051701), REAL_CONST(1.021897148654117),
  310.     REAL_CONST(1.033024879021228), REAL_CONST(1.044273782427414), REAL_CONST(1.055645178360557),
  311.     REAL_CONST(1.067140400676824), REAL_CONST(1.078760797757120), REAL_CONST(1.090507732665258),
  312.     REAL_CONST(1.102382583307841), REAL_CONST(1.114386742595892), REAL_CONST(1.126521618608242),
  313.     REAL_CONST(1.138788634756692), REAL_CONST(1.151189229952983), REAL_CONST(1.163724858777578),
  314.     REAL_CONST(1.176396991650281), REAL_CONST(1.189207115002721), REAL_CONST(1.202156731452703),
  315.     REAL_CONST(1.215247359980469), REAL_CONST(1.228480536106870), REAL_CONST(1.241857812073484),
  316.     REAL_CONST(1.255380757024691), REAL_CONST(1.269050957191733), REAL_CONST(1.282870016078778),
  317.     REAL_CONST(1.296839554651010), REAL_CONST(1.310961211524764), REAL_CONST(1.325236643159741),
  318.     REAL_CONST(1.339667524053303), REAL_CONST(1.354255546936893), REAL_CONST(1.369002422974591),
  319.     REAL_CONST(1.383909881963832), REAL_CONST(1.398979672538311), REAL_CONST(1.414213562373095),
  320.     REAL_CONST(1.429613338391970), REAL_CONST(1.445180806977047), REAL_CONST(1.460917794180647),
  321.     REAL_CONST(1.476826145939499), REAL_CONST(1.492907728291265), REAL_CONST(1.509164427593423),
  322.     REAL_CONST(1.525598150744538), REAL_CONST(1.542210825407941), REAL_CONST(1.559004400237837),
  323.     REAL_CONST(1.575980845107887), REAL_CONST(1.593142151342267), REAL_CONST(1.610490331949254),
  324.     REAL_CONST(1.628027421857348), REAL_CONST(1.645755478153965), REAL_CONST(1.663676580326736),
  325.     REAL_CONST(1.681792830507429), REAL_CONST(1.700106353718524), REAL_CONST(1.718619298122478),
  326.     REAL_CONST(1.737333835273706), REAL_CONST(1.756252160373300), REAL_CONST(1.775376492526521),
  327.     REAL_CONST(1.794709075003107), REAL_CONST(1.814252175500399), REAL_CONST(1.834008086409342),
  328.     REAL_CONST(1.853979125083386), REAL_CONST(1.874167634110300), REAL_CONST(1.894575981586966),
  329.     REAL_CONST(1.915206561397147), REAL_CONST(1.936061793492294), REAL_CONST(1.957144124175400),
  330.     REAL_CONST(1.978456026387951), REAL_CONST(2.000000000000000)
  331. };
  333. static const real_t log2_tab[] = {
  334.     REAL_CONST(0.000000000000000), REAL_CONST(0.022367813028455), REAL_CONST(0.044394119358453),
  335.     REAL_CONST(0.066089190457772), REAL_CONST(0.087462841250339), REAL_CONST(0.108524456778169),
  336.     REAL_CONST(0.129283016944966), REAL_CONST(0.149747119504682), REAL_CONST(0.169925001442312),
  337.     REAL_CONST(0.189824558880017), REAL_CONST(0.209453365628950), REAL_CONST(0.228818690495881),
  338.     REAL_CONST(0.247927513443585), REAL_CONST(0.266786540694901), REAL_CONST(0.285402218862248),
  339.     REAL_CONST(0.303780748177103), REAL_CONST(0.321928094887362), REAL_CONST(0.339850002884625),
  340.     REAL_CONST(0.357552004618084), REAL_CONST(0.375039431346925), REAL_CONST(0.392317422778760),
  341.     REAL_CONST(0.409390936137702), REAL_CONST(0.426264754702098), REAL_CONST(0.442943495848728),
  342.     REAL_CONST(0.459431618637297), REAL_CONST(0.475733430966398), REAL_CONST(0.491853096329675),
  343.     REAL_CONST(0.507794640198696), REAL_CONST(0.523561956057013), REAL_CONST(0.539158811108031),
  344.     REAL_CONST(0.554588851677637), REAL_CONST(0.569855608330948), REAL_CONST(0.584962500721156),
  345.     REAL_CONST(0.599912842187128), REAL_CONST(0.614709844115208), REAL_CONST(0.629356620079610),
  346.     REAL_CONST(0.643856189774725), REAL_CONST(0.658211482751795), REAL_CONST(0.672425341971496),
  347.     REAL_CONST(0.686500527183218), REAL_CONST(0.700439718141092), REAL_CONST(0.714245517666123),
  348.     REAL_CONST(0.727920454563199), REAL_CONST(0.741466986401147), REAL_CONST(0.754887502163469),
  349.     REAL_CONST(0.768184324776926), REAL_CONST(0.781359713524660), REAL_CONST(0.794415866350106),
  350.     REAL_CONST(0.807354922057604), REAL_CONST(0.820178962415188), REAL_CONST(0.832890014164742),
  351.     REAL_CONST(0.845490050944375), REAL_CONST(0.857980995127572), REAL_CONST(0.870364719583405),
  352.     REAL_CONST(0.882643049361841), REAL_CONST(0.894817763307943), REAL_CONST(0.906890595608519),
  353.     REAL_CONST(0.918863237274595), REAL_CONST(0.930737337562886), REAL_CONST(0.942514505339240),
  354.     REAL_CONST(0.954196310386875), REAL_CONST(0.965784284662087), REAL_CONST(0.977279923499917),
  355.     REAL_CONST(0.988684686772166), REAL_CONST(1.000000000000000)
  356. };
  358. real_t pow2_fix(real_t val)
  359. {
  360.     uint32_t x1, x2;
  361.     uint32_t errcorr;
  362.     uint32_t index_frac;
  363.     real_t retval;
  364.     int32_t whole = (val >> REAL_BITS);
  366.     /* rest = [0..1] */
  367.     int32_t rest = val - (whole << REAL_BITS);
  369.     /* index into pow2_tab */
  370.     int32_t index = rest >> (REAL_BITS-TABLE_BITS);
  373.     if (val == 0)
  374.         return (1<<REAL_BITS);
  376.     /* leave INTERP_BITS bits */
  377.     index_frac = rest >> (REAL_BITS-TABLE_BITS-INTERP_BITS);
  378.     index_frac = index_frac & ((1<<INTERP_BITS)-1);
  380.     if (whole > 0)
  381.     {
  382.         retval = 1 << whole;
  383.     } else {
  384.         retval = REAL_CONST(1) >> -whole;
  385.     }
  387.     x1 = pow2_tab[index & ((1<<TABLE_BITS)-1)];
  388.     x2 = pow2_tab[(index & ((1<<TABLE_BITS)-1)) + 1];
  389.     errcorr = ( (index_frac*(x2-x1))) >> INTERP_BITS;
  391.     if (whole > 0)
  392.     {
  393.         retval = retval * (errcorr + x1);
  394.     } else {
  395.         retval = MUL_R(retval, (errcorr + x1));
  396.     }
  398.     return retval;
  399. }
  401. int32_t pow2_int(real_t val)
  402. {
  403.     uint32_t x1, x2;
  404.     uint32_t errcorr;
  405.     uint32_t index_frac;
  406.     real_t retval;
  407.     int32_t whole = (val >> REAL_BITS);
  409.     /* rest = [0..1] */
  410.     int32_t rest = val - (whole << REAL_BITS);
  412.     /* index into pow2_tab */
  413.     int32_t index = rest >> (REAL_BITS-TABLE_BITS);
  416.     if (val == 0)
  417.         return 1;
  419.     /* leave INTERP_BITS bits */
  420.     index_frac = rest >> (REAL_BITS-TABLE_BITS-INTERP_BITS);
  421.     index_frac = index_frac & ((1<<INTERP_BITS)-1);
  423.     if (whole > 0)
  424.         retval = 1 << whole;
  425.     else
  426.         retval = 0;
  428.     x1 = pow2_tab[index & ((1<<TABLE_BITS)-1)];
  429.     x2 = pow2_tab[(index & ((1<<TABLE_BITS)-1)) + 1];
  430.     errcorr = ( (index_frac*(x2-x1))) >> INTERP_BITS;
  432.     retval = MUL_R(retval, (errcorr + x1));
  434.     return retval;
  435. }
  437. /* ld(x) = ld(x*y/y) = ld(x/y) + ld(y), with y=2^N and [1 <= (x/y) < 2] */
  438. int32_t log2_int(uint32_t val)
  439. {
  440.     uint32_t frac;
  441.     uint32_t whole = (val);
  442.     int32_t exp = 0;
  443.     uint32_t index;
  444.     uint32_t index_frac;
  445.     uint32_t x1, x2;
  446.     uint32_t errcorr;
  448.     /* error */
  449.     if (val == 0)
  450.         return -10000;
  452.     exp = floor_log2(val);
  453.     exp -= REAL_BITS;
  455.     /* frac = [1..2] */
  456.     if (exp >= 0)
  457.         frac = val >> exp;
  458.     else
  459.         frac = val << -exp;
  461.     /* index in the log2 table */
  462.     index = frac >> (REAL_BITS-TABLE_BITS);
  464.     /* leftover part for linear interpolation */
  465.     index_frac = frac & ((1<<(REAL_BITS-TABLE_BITS))-1);
  467.     /* leave INTERP_BITS bits */
  468.     index_frac = index_frac >> (REAL_BITS-TABLE_BITS-INTERP_BITS);
  470.     x1 = log2_tab[index & ((1<<TABLE_BITS)-1)];
  471.     x2 = log2_tab[(index & ((1<<TABLE_BITS)-1)) + 1];
  473.     /* linear interpolation */
  474.     /* retval = exp + ((index_frac)*x2 + (1-index_frac)*x1) */
  476.     errcorr = (index_frac * (x2-x1)) >> INTERP_BITS;
  478.     return ((exp+REAL_BITS) << REAL_BITS) + errcorr + x1;
  479. }
  481. /* ld(x) = ld(x*y/y) = ld(x/y) + ld(y), with y=2^N and [1 <= (x/y) < 2] */
  482. real_t log2_fix(uint32_t val)
  483. {
  484.     uint32_t frac;
  485.     uint32_t whole = (val >> REAL_BITS);
  486.     int8_t exp = 0;
  487.     uint32_t index;
  488.     uint32_t index_frac;
  489.     uint32_t x1, x2;
  490.     uint32_t errcorr;
  492.     /* error */
  493.     if (val == 0)
  494.         return -100000;
  496.     exp = floor_log2(val);
  497.     exp -= REAL_BITS;
  499.     /* frac = [1..2] */
  500.     if (exp >= 0)
  501.         frac = val >> exp;
  502.     else
  503.         frac = val << -exp;
  505.     /* index in the log2 table */
  506.     index = frac >> (REAL_BITS-TABLE_BITS);
  508.     /* leftover part for linear interpolation */
  509.     index_frac = frac & ((1<<(REAL_BITS-TABLE_BITS))-1);
  511.     /* leave INTERP_BITS bits */
  512.     index_frac = index_frac >> (REAL_BITS-TABLE_BITS-INTERP_BITS);
  514.     x1 = log2_tab[index & ((1<<TABLE_BITS)-1)];
  515.     x2 = log2_tab[(index & ((1<<TABLE_BITS)-1)) + 1];
  517.     /* linear interpolation */
  518.     /* retval = exp + ((index_frac)*x2 + (1-index_frac)*x1) */
  520.     errcorr = (index_frac * (x2-x1)) >> INTERP_BITS;
  522.     return (exp << REAL_BITS) + errcorr + x1;
  523. }
  524. #endif