Category

Development Platform
Home > SourceCode/Document > Multimedia program > VOIP program > View Code
ezplay.c
Package: vcShiPinHuiYiKaiFaJiShuYuShiLi04.rar　[view]
Upload User: hbbaokai
Upload Date: 2009-07-13
Package Size: 328k
Code Size: 5k
Category:

VOIP program

Development Platform:

Visual C++

ezplay.c：Code Content
  1. /*************************************************************************/
  2. /*                                                                       */
  3. /*                            LD-CELP  G.728                             */
  4. /*                                                                       */
  5. /*    Low-Delay Code Excitation Linear Prediction speech compression.    */
  6. /*                                                                       */
  7. /*                 Copyright: Analog Devices, Inc., 1993                 */
  8. /*                                                                       */
  9. /*                         Author: Alex Zatsman.                         */
  10. /*                                                                       */
  11. /*  This program was written mostly for testing  Analog Devices' g21k C  */
  12. /*  compiler for the  ADSP21000 architecture  family. While the program  */
  13. /*  works  on  Sparc and ADSP21020, it  has  NOT  been  tested with the  */
  14. /*  official test data from CCITT/ITU.                                   */
  15. /*                                                                       */
  16. /*  The program  is   distributed as  is,  WITHOUT ANY WARRANTY, EITHER  */
  17. /*  EXPLICIT OR IMPLIED.                                                 */
  18. /*                                                                       */
  19. /*************************************************************************/
  21. /* Play back for ez-lab */
  22. #include <signal.h>
  23. #include <macros.h>
  24. #include <def21020.h>
  25. #include "21kflags.h"
  26. #include "common.h"
  27. #include "parm.h"
  29. volatile int button_pushed;
  31. extern void initx_in();
  32. extern void initx_out();
  34. void irq2_handler(int);
  35. void record();
  36. void wait_for_button();
  37. void light_on(int);
  38. void light_off(int);
  40. extern void encoder();
  41. extern void init_encoder();
  42. extern void decoder();
  43. extern void init_decoder();
  45. void main ()
  46. {
  47.     interrupt(SIG_IRQ2, irq2_handler);
  48.     mode2.b.irq2_edge   = 1;
  49.     mode2.b.flg1_output = 1;
  50.     mode2.b.flg2_output = 1;
  51.     mode2.b.flg3_output = 1;
  52.     light_on(1);
  53.     light_off(2);
  54.     light_off(3);
  56.     wait_for_button();
  57.     light_off(1);
  58.     light_on(3);
  59.     initx_in();
  60.     encoder();
  61.     light_off(3);
  63.     while(1) {
  64. light_on(2);
  65. wait_for_button();
  66. light_off(2);
  67. initx_out();
  68. decoder();
  69.     }
  70. }
  72. void wait_for_button()
  73. {
  74.     button_pushed = 0;
  75.     imask.b.irq3i = 0;
  76.     imask.b.sft0i = 0;
  77.     while(!button_pushed);
  78. }
  80. void irq2_handler(int x)
  81. {
  82.     extern int volatile encoder_done;
  83.     extern int volatile decoder_done;
  84.     encoder_done  = 1;
  85.     decoder_done  = 1;
  86.     button_pushed = 1;
  87. }
  89. void light_on(int n)
  90. {
  91.     switch(n) {
  92.       case 1: astat.b.flg1_value = 1; break;
  93.       case 2: astat.b.flg2_value = 1; break;
  94.       case 3: astat.b.flg3_value = 1; break;
  95.       default:
  96. astat.b.flg1_value = 1;
  97. astat.b.flg2_value = 1;
  98. astat.b.flg3_value = 1;
  99.     }
  100. }
  102. void light_off(int n)
  103. {
  104.     switch(n) {
  105.       case 1: astat.b.flg1_value = 0; break;
  106.       case 2: astat.b.flg2_value = 0; break;
  107.       case 3: astat.b.flg3_value = 0; break;
  108.       default:
  109. astat.b.flg1_value = 0;
  110. astat.b.flg2_value = 0;
  111. astat.b.flg3_value = 0;
  112.     }
  113. }
  115. /******************************** Storing and Retrieving Indices. *******/
  117. #define NUMX 25000
  118. int ix_in  = 0;
  119. int ix_out = 0;
  120. int index_data[NUMX];
  121.    /* scratch volatile to make sure that asm's are not moved */
  122. volatile int pm scratch;
  125. void initx_out() 
  126. {
  127.     ix_out = 0;
  128. }
  130. void initx_in() 
  131. {
  132.     ix_in  = 0;
  133. }
  135. void
  136. put_index(int x)
  137. {
  138.     int wnum,fnum;
  139.     wnum = ix_in>>2;
  140.     if (wnum<NUMX) {
  141. fnum = ix_in&3;
  142. if (fnum) {
  143.     int new, old = index_data[wnum];
  144.     scratch=old;
  145.     asm volatile ("px=pm(_scratch);");
  146.     new = old | x<<(fnum*10-8);
  147.     asm volatile ("px2=%0;" : : "d" (new));
  148. }
  149. else {
  150.     /* this clobbers the rest 30 bits, but since the index is */
  151.     /* always written sequentially, this should not matter much */
  152.     int 
  153. x1 = x<<8 & 0xff00,
  154. x2 = (x>>8)&3;
  155.     asm volatile ("px1=%0;" : : "d" (x1));
  156.     asm volatile ("px2=%0;" : : "d" (x2));
  157. }
  158. asm volatile ("pm(_scratch)=px;");
  159. index_data[wnum] = scratch;
  160. ix_in++;
  161.     }
  162.     else {
  163. extern int volatile encoder_done;
  164. encoder_done=1;
  165.     }
  166. }
  168. int get_index()
  169. {
  170.     int wnum, fnum, result;
  171.     wnum = ix_out>>2;
  172.     if (ix_out < ix_in && wnum < NUMX) {
  173. fnum = ix_out&3;
  174. if (fnum) {
  175.     result  = (index_data[wnum]>>(fnum*10-8))& 0x3ff;
  176. } else {
  177.     int x1,x2;
  178.     scratch=index_data[wnum];
  179.     asm volatile ("px=pm(_scratch);");
  180.     asm volatile ("%0=px1;" : "=d" (x1));
  181.     asm volatile ("%0=px2;" : "=d" (x2));
  182.     result = ((x2&3)<<8) | (x1>>8);
  183. }
  184. ix_out++;
  185. return result;
  186.     }
  187.     else {
  188. extern int decoder_done;
  189. decoder_done=1;
  190. return 0;
  191.     }
  192. }