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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > DSP编程 > 查看源码
volume.c
资源名称：DSP-C6000-DM642DEMO.rar　[点击查看]
上传用户：dahaojd
上传日期：2008-01-29
资源大小：14357k
文件大小：4k
源码类别：

DSP编程

开发平台：

C/C++

volume.c：源码内容
  1. /*
  2.  *  Copyright 2001 by Texas Instruments Incorporated.
  3.  *  All rights reserved. Property of Texas Instruments Incorporated.
  4.  *  Restricted rights to use, duplicate or disclose this code are
  5.  *  granted through contract.
  6.  *  U.S. Patent Nos. 5,283,900  5,392,448
  7.  */
  8. /* "@(#) DSP/BIOS 4.51.0 05-23-01 (barracuda-i10)" */
  9. /***************************************************************************/
  10. /*                                                                         */
  11. /*     V O L U M E . C                                                     */
  12. /*                                                                         */
  13. /*     Audio gain processing in a main loop                                */
  14. /*                                                                         */
  15. /***************************************************************************/
  17. #include "stdio.h"
  19. #include "volume.h"
  20. /* Global declarations */
  21. int inp1_buffer[BUFSIZE];
  22. int inp2_buffer[BUFSIZE];       /* processing data buffers */
  23. int out1_buffer[BUFSIZE];
  24. int out2_buffer[BUFSIZE];
  25. int out3_buffer[BUFSIZE];
  26. int out4_buffer[BUFSIZE*2];
  27. int size = BUFSIZE;
  28. int ain = MINGAIN;
  29. int zhy=0;
  30. int sk=64;        /*sk代表所开的bufsize的大小,需修改它.输入文件sine.dat为32点,sine11.dat,
  31.                     sin22.dat,sin33.dat,sin44.dat为64点的输入波形.*/
  32.                   /* volume control variable */
  33. unsigned int processingLoad = 1;  /* processing routine load value */
  36. /* Functions */
  37. extern void load(unsigned int loadValue);
  39. static int processing1(int *output1, int *output2);
  40. static int processing2(int *output2, int *output3); 
  41. static int processing3(int *input1,int *output2,int *output4);
  42. static int processing4(int *input2, int *output1);
  43. static void dataIO1(void);
  44. static void dataIO2(void);
  46. /*
  47.  * ======== main ========
  48.  */
  49. void main()
  50. {
  51.     int *input1 = &inp1_buffer[0];
  52.     int *input2 = &inp2_buffer[0];
  53.     int *output1 = &out1_buffer[0];
  54.     int *output2 = &out2_buffer[0];
  55.     int *output3 = &out3_buffer[0];
  56.     int *output4 = &out4_buffer[0];
  57.     puts("volume example startedn");
  59.     /* loop forever */
  60.     while(TRUE)
  61.     {       
  62.         /* 
  63.          *  Read input data using a probe-point connected to a host file. 
  64.          *  Write output data to a graph connected through a probe-point.
  65.          */
  67.         dataIO1();
  68.         dataIO2();
  69.         /* apply gain */ 
  70.         processing4(input2,output1);
  71.         processing1(output1, output2); 
  72.         processing2(output2, output3);
  73.         processing3(input1,output2,output4) ;
  74.     }
  75. }
  77. /*
  78.  *  ======== processing ========
  79.  *
  80.  * FUNCTION: apply signal processing transform to input signal.
  81.  *
  82.  * PARAMETERS: address of input and output buffers.
  83.  *
  84.  * RETURN VALUE: TRUE.
  85.  */
  86. static int processing4(int *input2,int *output1)
  87. {   int m=sk;
  88.     for(;m>=0;m--)
  89.    {
  90.         *output1++ = *input2++ * ain;
  91.     }
  92.    for(;(size-m)>0;m++)
  93.    {output1[m]=0;
  94.    }
  95.     load(processingLoad); 
  96.     return(TRUE);
  97.     
  98.     }
  99.  
  100. static int processing1(int *output1,int *output2)
  101. {  
  102.     int m=sk-1;  
  103.    for(;m>0;m--)
  104.    {
  105.         *output2++ = *output1++ * ain;
  106.     }
  107.    
  108.     /* additional processing load */
  109.     load(processingLoad); 
  110.     return(TRUE);
  111. }
  112. static int processing2(int *output2, int *output3)
  113. {   int n=zhy;
  114.    
  115.     size=BUFSIZE; 
  116.     for(;(size-n)>0;n++)
  117.     { *output3++ = output2[n];
  118.     }
  119.     /* for (;n>0;n--)
  120.     { *output3++ = 0;
  121.     }  */
  122.     load(processingLoad);
  123.     return(TRUE);
  124.     }
  125. static int processing3(int *input1,int *output2,int *output4)
  126. {   int m=sk;
  127.     int y=zhy;
  128.     int z,x,w,i,f,g;
  129.     for(;(m-y)>0;)
  130.     {i=y;
  131.      x=0;
  132.      z=0;
  133.      f=y;
  134.      for(;i>=0;i--)
  135.      {g=input1[z]*output2[f];
  136.       x=x+g;
  137.      z++;
  138.      f--;
  139.      }
  140.      *output4++ = x;
  141.      y++;
  142.      }
  143.      m=sk;
  144.      y=sk-1;
  145.      w=m-zhy-1;
  146.     for(;m>0;m--)
  147.     {
  148.      y--;
  149.      i=y;
  150.      z=sk-1;
  151.      x=0;
  152.      f=sk-y;
  153.      for(;i>0;i--,z--,f++)
  154.      {g=input1[z]*output2[f];
  155.      x=x+g;
  156.      
  157.      }
  158.      out4_buffer[w]=x;
  159.      w++;
  160.      }
  161.      load(processingLoad);
  162.      return(TRUE);
  163.      }  
  164. /*
  165.  *  ======== dataIO ========
  166.  *
  167.  * FUNCTION: read input signal and write processed output signal.
  168.  *
  169.  * PARAMETERS: none.
  170.  *
  171.  * RETURN VALUE: none.
  172.  */
  173. static void dataIO1()
  174. {
  175.     /* do data I/O */
  177.     return;
  178. }
  179. static void dataIO2()
  180. {
  181.     /* do data I/O */
  183.     return;
  184. }