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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
block.c
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：12k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

block.c：源码内容
  1. /************************* MPEG-2 NBC Audio Decoder **************************
  2.  *                                                                           *
  3. "This software module was originally developed by
  4. AT&T, Dolby Laboratories, Fraunhofer Gesellschaft IIS in the course of
  5. development of the MPEG-2 NBC/MPEG-4 Audio standard ISO/IEC 13818-7,
  6. 14496-1,2 and 3. This software module is an implementation of a part of one or more
  7. MPEG-2 NBC/MPEG-4 Audio tools as specified by the MPEG-2 NBC/MPEG-4
  8. Audio standard. ISO/IEC  gives users of the MPEG-2 NBC/MPEG-4 Audio
  9. standards free license to this software module or modifications thereof for use in
  10. hardware or software products claiming conformance to the MPEG-2 NBC/MPEG-4
  11. Audio  standards. Those intending to use this software module in hardware or
  12. software products are advised that this use may infringe existing patents.
  13. The original developer of this software module and his/her company, the subsequent
  14. editors and their companies, and ISO/IEC have no liability for use of this software
  15. module or modifications thereof in an implementation. Copyright is not released for
  16. non MPEG-2 NBC/MPEG-4 Audio conforming products.The original developer
  17. retains full right to use the code for his/her  own purpose, assign or donate the
  18. code to a third party and to inhibit third party from using the code for non
  19. MPEG-2 NBC/MPEG-4 Audio conforming products. This copyright notice must
  20. be included in all copies or derivative works."
  21. Copyright(c)1996.
  22.  *                                                                           *
  23.  ****************************************************************************/
  24. /*
  25.  * $Id: block.c,v 1.5 2002/01/09 22:25:41 wmay Exp $
  26.  */
  28. #ifdef WIN32
  29. #define WIN32_MEAN_AND_LEAN
  30. #include <windows.h>
  31. #endif
  32. #include <math.h>
  33. #include "all.h"
  34. #include "block.h"
  35. #include "kbd_win.h"
  36. #include "transfo.h"
  37. #include "util.h"
  39. #ifndef PI
  40. #define PI 3.14159265359f
  41. #endif
  43. Float *sin_long;
  44. Float *sin_short;
  45. #ifndef WIN_TABLE
  46. Float *kbd_long;
  47. Float *kbd_short;
  48. #endif
  49. Float *sin_edler;
  50. Float *kbd_edler;
  51. Float *sin_adv;
  52. Float *kbd_adv;
  54. Float *windowPtr[N_WINDOW_TYPES][N_WINDOW_SHAPES];
  57. const int windowLeng[N_WINDOW_TYPES] = {
  58.     1024,
  59.     128,
  60.     1024,
  61.     1024
  62. };
  65. #ifndef WIN_TABLE
  66. static float Izero(float x)
  67. {
  68.     float IzeroEPSILON = 1E-37f;  /* Max error acceptable in Izero */
  69.     float sum, u, halfx, temp;
  70.     int n;
  72.     sum = u = 1.f;
  73.     n = 1;
  74.     halfx = x/2.0f;
  75.     do {
  76.         temp = halfx/(float)n;
  77.         n += 1;
  78.         temp *= temp;
  79.         u *= temp;
  80.         sum += u;
  81.     } while (u >= IzeroEPSILON*sum);
  83.     return(sum);
  84. }
  86. static void CalculateKBDWindow(float* win, float alpha, int length)
  87. {
  88.     int i;
  89.     float IBeta;
  90.     float tmp;
  91.     float sum = 0.0;
  93.     alpha *= PI;
  94.     IBeta = 1.0f/Izero(alpha);
  96.     /* calculate lower half of Kaiser Bessel window */
  97.     for(i=0; i<(length>>1); i++) {
  98.         tmp = 4.0f*(float)i/(float)length - 1.0f;
  99.         win[i] = Izero(alpha*(float)sqrt(1.0f-tmp*tmp))*IBeta;
  100.         sum += win[i];
  101.     }
  103.     sum = 1.0f/sum;
  104.     tmp = 0.0f;
  106.     /* calculate lower half of window */
  107.     for(i=0; i<(length>>1); i++) {
  108.         tmp += win[i];
  109.         win[i] = (float)sqrt(tmp*sum);
  110.     }
  111. }
  112. #endif
  115. /*****************************************************************************
  116. *
  117. *   InitBlock
  118. *   calculate windows for use by Window()
  119. *   input: none
  120. *   output: none
  121. *   local static: none
  122. *   globals: shortWindow[], longWindow[]
  123. *
  124. *****************************************************************************/
  125. void InitBlock (void)
  126. {
  128.     /* calc half-window data */
  129.     int     i, j;
  130.     float   phaseInc;
  132.     sin_long = AllocMemory(NWINLONG*sizeof(Float));
  133.     sin_short = AllocMemory(NWINSHORT*sizeof(Float));
  134. #ifndef WIN_TABLE
  135.     kbd_long = AllocMemory(NWINLONG*sizeof(Float));
  136.     kbd_short = AllocMemory(NWINSHORT*sizeof(Float));
  137. #endif
  138.     sin_edler = AllocMemory(NWINLONG*sizeof(Float));
  139.     kbd_edler = AllocMemory(NWINLONG*sizeof(Float));
  140.     sin_adv = AllocMemory(NWINADV*sizeof(Float));
  141.     kbd_adv = AllocMemory(NWINADV*sizeof(Float));
  143. /*
  144. Float *windowPtr[N_WINDOW_TYPES][N_WINDOW_SHAPES] = {
  145.     {sin_long,  kbd_long},
  146.     {sin_short, kbd_short},
  147.     {sin_edler, kbd_edler},
  148.     {sin_adv,   kbd_adv}
  149. };
  150. */
  151.     windowPtr[0][0] = sin_long;
  152.     windowPtr[0][1] = kbd_long;
  153.     windowPtr[1][0] = sin_short;
  154.     windowPtr[1][1] = kbd_short;
  155.     windowPtr[2][0] = sin_edler;
  156.     windowPtr[2][1] = kbd_edler;
  157.     windowPtr[3][0] = sin_adv;
  158.     windowPtr[3][1] = kbd_adv;
  160.     /* init half-windows */
  162.     /* sin long window */
  163.     phaseInc = PI / (2.0f * NWINLONG);
  164.     for (i = 0; i < NWINLONG; i++) {
  165.         sin_long [i]  = (float)sin(phaseInc * (i + 0.5));
  166.     }
  168.     /* sin short window */
  169.     phaseInc = PI / (2.0f * NWINSHORT);
  170.     for (i = 0; i < NWINSHORT; i++) {
  171.         sin_short [i] = (float)sin(phaseInc * (i + 0.5));
  172.     }
  174. #ifndef WIN_TABLE
  175.     CalculateKBDWindow(kbd_long, 4.f, NWINLONG*2);
  176.     CalculateKBDWindow(kbd_short, 6.f, NWINSHORT*2);
  177. #endif
  179.     /* Edler windows */
  180.     for (i = 0, j = 0; i < NFLAT; i++, j++) {
  181.         sin_edler[j] = 0.0;
  182.         kbd_edler[j] = 0.0;
  183.     }
  184.     for (i = 0; i < NWINSHORT; i++, j++) {
  185.         sin_edler [j] = sin_short [i];
  186.         kbd_edler [j] = kbd_short [i];
  187.     }
  188.     for ( ; j < NWINFLAT; j++) {
  189.         sin_edler [j] = 1.0;
  190.         kbd_edler [j] = 1.0;
  191.     }
  193.     /* Advanced Edler windows */
  194.     for (i = 0, j = 0; i < NADV0; i++, j++) {
  195.         sin_adv [j] = 0.0;
  196.         kbd_adv [j] = 0.0;
  197.     }
  198.     for (i = 0; i < NWINSHORT; i++, j++) {
  199.         sin_adv[j] = sin_short[i];
  200.         kbd_adv[j] = kbd_short[i];
  201.     }
  202.     for ( ; j < NWINADV; j++) {
  203.         sin_adv[j] = 1.0;
  204.         kbd_adv[j] = 1.0;
  205.     }
  206. }
  208. void EndBlock(void)
  209. {
  210.     FreeMemory(sin_long);
  211.     FreeMemory(sin_short);
  212. #ifndef WIN_TABLE
  213.     FreeMemory(kbd_long);
  214.     FreeMemory(kbd_short);
  215. #endif
  216.     FreeMemory(sin_edler);
  217.     FreeMemory(kbd_edler);
  218.     FreeMemory(sin_adv);
  219.     FreeMemory(kbd_adv);
  220. }
  222. /*****************************************************************************
  223. *
  224. *   Window
  225. *   window input sequence based on window type
  226. *   input: see below
  227. *   output: see below
  228. *   local static:
  229. *     firstTime             flag = need to initialize data structures
  230. *   globals: shortWindow[], longWindow[]
  231. *
  232. *****************************************************************************/
  234. void ITransformBlock (faacDecHandle hDecoder,
  235.     Float* dataPtr,             /* vector to be windowed in place   */
  236.     BLOCK_TYPE bT,              /* input: window type               */
  237.     Wnd_Shape *wnd_shape,
  238.     Float *state                /* input/output                     */
  239.     )
  240. {
  241.     int leng0, leng1;
  242.     int         i,leng;
  243.     Float       *windPtr;
  244.     WINDOW_TYPE beginWT, endWT;
  246.     if((bT==LONG_BLOCK) || (bT==START_FLAT_BLOCK)) {
  247.         beginWT = WT_LONG;
  248.     } else if(bT==STOP_FLAT_BLOCK) {
  249.         beginWT = WT_FLAT;
  250.     } else
  251.         beginWT = WT_SHORT;
  253.     if ((bT == LONG_BLOCK) || (bT == STOP_FLAT_BLOCK)) {
  254.         endWT = WT_LONG;
  255.     } else if (bT == START_FLAT_BLOCK)  {
  256.         endWT = WT_FLAT;
  257.     } else
  258.         endWT = WT_SHORT;
  260.     leng0 = windowLeng [beginWT];
  261.     leng1 = windowLeng [endWT];
  263.     switch(leng0 + leng1) {
  264.     case 2048: IMDCT_Long(hDecoder, dataPtr); break;
  265.     case 256: IMDCT_Short(hDecoder, dataPtr);
  266.     }
  268.     /*  first half of window */
  269.     /*     windPtr = windowPtr [0] [0];  */
  270.     windPtr = windowPtr [beginWT] [wnd_shape->prev_bk];
  272.   /* idimkovic: should be optimized with SSE memcpy() */
  273.     for (i = windowLeng [beginWT]/16 - 1; i>=0; --i)  {
  274.     *dataPtr++ *= *windPtr++;  *dataPtr++ *= *windPtr++;
  275.     *dataPtr++ *= *windPtr++;  *dataPtr++ *= *windPtr++;
  276.     *dataPtr++ *= *windPtr++;  *dataPtr++ *= *windPtr++;
  277.     *dataPtr++ *= *windPtr++;  *dataPtr++ *= *windPtr++;
  278.     *dataPtr++ *= *windPtr++;  *dataPtr++ *= *windPtr++;
  279.     *dataPtr++ *= *windPtr++;  *dataPtr++ *= *windPtr++;
  280.     *dataPtr++ *= *windPtr++;  *dataPtr++ *= *windPtr++;
  281.     *dataPtr++ *= *windPtr++;  *dataPtr++ *= *windPtr++;
  282.     }
  284.     /*  second half of window */
  285.     leng = windowLeng [endWT];
  286.     windPtr = windowPtr [endWT] [wnd_shape->this_bk] + leng - 1;
  287.   for (i = leng/16-1; i>=0; --i) {
  288.     *dataPtr++ *= *windPtr--; *dataPtr++ *= *windPtr--;
  289.     *dataPtr++ *= *windPtr--; *dataPtr++ *= *windPtr--;
  290.     *dataPtr++ *= *windPtr--; *dataPtr++ *= *windPtr--;
  291.     *dataPtr++ *= *windPtr--; *dataPtr++ *= *windPtr--;
  292.     *dataPtr++ *= *windPtr--; *dataPtr++ *= *windPtr--;
  293.     *dataPtr++ *= *windPtr--; *dataPtr++ *= *windPtr--;
  294.     *dataPtr++ *= *windPtr--; *dataPtr++ *= *windPtr--;
  295.     *dataPtr++ *= *windPtr--; *dataPtr++ *= *windPtr--;
  296.     }
  298.     wnd_shape->prev_bk = wnd_shape->this_bk;
  299. }
  301. /*****************************************************************************
  302. *
  303. *   MDCT
  304. *   window input sequence based on window type and perform MDCT
  305. *   This is adapted from ITransformBlock().
  306. *   (long term prediction needs this routine)
  307. *   input: see below
  308. *   output: see below
  309. *   local static:
  310. *     firstTime             flag = need to initialize data structures
  311. *   globals: -
  312. *
  313. *****************************************************************************/
  314. void TransformBlock(faacDecHandle hDecoder,
  315.     Float* dataPtr,             /* time domain signal   */
  316.     BLOCK_TYPE bT,              /* input: window type               */
  317.     Wnd_Shape *wnd_shape
  318.     )
  319. {
  320.     int leng0, leng1;
  321.     int i,leng;
  322.     Float *windPtr;
  323.     WINDOW_TYPE beginWT, endWT;
  325.     if((bT==LONG_BLOCK) || (bT==START_BLOCK) || (bT==START_FLAT_BLOCK)
  326.         || (bT==START_ADV_BLOCK))  {
  327.         beginWT = WT_LONG;
  328.         }
  329.     else if(bT==STOP_FLAT_BLOCK) {
  330.         beginWT = WT_FLAT;
  331.         }
  332.     else if(bT==STOP_ADV_BLOCK) {
  333.         beginWT = WT_ADV;
  334.         }
  335.     else
  336.         beginWT = WT_SHORT;
  338.     if ((bT == LONG_BLOCK) || (bT == STOP_BLOCK) || (bT == STOP_FLAT_BLOCK)
  339.         || (bT == STOP_ADV_BLOCK)) {
  340.         endWT = WT_LONG;
  341.         }
  342.     else if (bT == START_FLAT_BLOCK)  {
  343.         endWT = WT_FLAT;
  344.         }
  345.     else if (bT == START_ADV_BLOCK)  {
  346.         endWT = WT_ADV;
  347.         }
  348.     else
  349.         endWT = WT_SHORT;
  351.     leng0 = windowLeng[beginWT];
  352.     leng1 = windowLeng[endWT];
  354. /*  first half of window */
  355. /*     windPtr = windowPtr [0] [0];  */
  356.      windPtr = windowPtr [beginWT] [wnd_shape->prev_bk];
  358.     for (i = windowLeng [beginWT]/16 - 1; i>=0; --i)  {
  359.     *dataPtr++ *= *windPtr++;  *dataPtr++ *= *windPtr++;
  360.     *dataPtr++ *= *windPtr++;  *dataPtr++ *= *windPtr++;
  361.     *dataPtr++ *= *windPtr++;  *dataPtr++ *= *windPtr++;
  362.     *dataPtr++ *= *windPtr++;  *dataPtr++ *= *windPtr++;
  363.     *dataPtr++ *= *windPtr++;  *dataPtr++ *= *windPtr++;
  364.     *dataPtr++ *= *windPtr++;  *dataPtr++ *= *windPtr++;
  365.     *dataPtr++ *= *windPtr++;  *dataPtr++ *= *windPtr++;
  366.     *dataPtr++ *= *windPtr++;  *dataPtr++ *= *windPtr++;
  367.     }
  370. /*  second half of window */
  371.     leng = windowLeng[endWT];
  372.     windPtr = windowPtr[endWT][wnd_shape->this_bk] + leng - 1;
  374.     for (i = leng/16-1; i>=0; --i) {
  375.       *dataPtr++ *= *windPtr--; *dataPtr++ *= *windPtr--;
  376.       *dataPtr++ *= *windPtr--; *dataPtr++ *= *windPtr--;
  377.       *dataPtr++ *= *windPtr--; *dataPtr++ *= *windPtr--;
  378.       *dataPtr++ *= *windPtr--; *dataPtr++ *= *windPtr--;
  379.       *dataPtr++ *= *windPtr--; *dataPtr++ *= *windPtr--;
  380.       *dataPtr++ *= *windPtr--; *dataPtr++ *= *windPtr--;
  381.       *dataPtr++ *= *windPtr--; *dataPtr++ *= *windPtr--;
  382.       *dataPtr++ *= *windPtr--; *dataPtr++ *= *windPtr--;
  383.     }
  385.     dataPtr -= (windowLeng [beginWT] + leng);
  387.     switch(leng0 + leng1) {
  388.     case 2048: MDCT_Long(hDecoder, dataPtr); break;
  389.     case 256: MDCT_Short(hDecoder, dataPtr);
  390.     }
  391.     wnd_shape->prev_bk = wnd_shape->this_bk;
  392. }