[经验分享] AudioRecord和AudioTrack类的使用
（1）创建AudioRecord和AudioTrack类对象：创建这两个类的对象比较复杂，通过对文档的反复和仔细理解，并通过多次失败的尝试，并在北理工的某个Android大牛的网上的文章启发下，我们也最终成功地创建了这两个类的对象。创建AudioRecord和AudioTrack类对象的代码如下：AudioRecord类：
1.
2. m_in_buf_size =MinBufferSize(8000,   
3.                         AudioFormat.CHANNEL_CONFIGURATION_MONO,   
4.                         AudioFormat.ENCODING_PCM_16BIT);   
5.      
6.          m_in_rec = new AudioRecord(MediaRecorder.AudioSource.MIC,   
7.          8000,   
8.          AudioFormat.CHANNEL_CONFIGURATION_MONO,   
9.          AudioFormat.ENCODING_PCM_16BIT,   
10.          m_in_buf_size) ;   
11.
1 AudioTrack类：
1. m_out_buf_size = MinBufferSize(8000,
2. AudioFormat.CHANNEL_CONFIGURATION_MONO,
3. AudioFormat.ENCODING_PCM_16BIT);
4.
5. m_out_trk = new AudioTrack(AudioManager.STREAM_MUSIC, 8000,
6. AudioFormat.CHANNEL_CONFIGURATION_MONO,
7. AudioFormat.ENCODING_PCM_16BIT,
8. m_out_buf_size,
9. AudioTrack.MODE_STREAM);
2 （java模拟器怎么用2）关于AudioRecord和AudioTrack类的监听函数，不用也行。
    （3）调试方面，包括初始化后看logcat信息，以确定类的工作状态，初始化是否成功等。
     编写好代码，没有语法错误，调用模拟器运行、调试代码时，logcat发挥了很好的功用。刚调试时，经常会出现模拟器显示出现异常，这时我们可以在代码的一些关键语句后添加如Log.d("test1","OK")；这样的语句进行标识，出现异常时我们就可以在logcat窗口观察代码执行到哪里出现异常，然后进行相应的修改、调试。模拟器不会出现异常时，又遇到了录放音的问题。录音方面，刚开始选择将语音编码数据存放在多个固定大小的文件中进行传送，但是这种情况下会出现声音断续的现象，而且要反复的建立文件，比较麻烦，后来想到要进行网上传输，直接将语音编码数据以数据流的形式传送，经过验证，这种方法可行并且使代码更加简洁。放音方面，将接收到的数据流存放在一个数组中，然后将数组中数据写到AudioTrack中。刚开始只是“嘟”几声，经过检查发现只是把数据写一次，加入循环，让数据反复写到AudioTrack中，就可以听到正常的语音了。接下来的工作主要是改善话音质量与话音延迟，在进行通话的过程中，观察logcat窗口，发现向数组中写数据时会出现Bufferflow的情况，于是把重心转移到数组大小的影响上，经过试验，发现 AudioRecord一次会读640个数据，然后就对录音和放音中有数组的地方进行实验修改。AudioRecord和AudioTrack进行实例化时，参数中各有一个数组大小，经过试验这个数组大小和AudioRecord和AudioTrack能正常实例化所需的最小Buffer大小（即上面实例化时的m_in_buf_size和m_out_buf_size参数）相等且服务器方进行缓存数据的数组尺寸是上述数值的2倍时，语音质量最好。由于录音和放音的速度不一致，受到北理工大牛的启发，在录音方面，将存放录音数据的数组放到LinkedList中,当LinkedList中数组个数达到2（这个也是经过试验验证话音质量最好时的数据）时，将先录好的数组中数据传送出去。经过上述反复试验和修改，最终使双方通话质量较好，且延时较短（大概有2秒钟）。
    （4）通过套接字传输和接收数据
     数据传送部分，使用的是套接字。通信双方，通过不同的端口向服务器发送请求，与服务器连接上后，开始通话向服务器发送数据，服务器通过一个套接字接收到一方的数据后，先存在一个数组中，然后将该数组中数据以数据流的形式再通过另一个套接字传送到另一方。这样就实现了双方数据的传送。
     （5）代码架构
      为避免反复录入和读取数据占用较多资源，使程序在进行录放音时不能执行其他命令，故将录音和放音各写成一个线程类，然后在主程序中，通过MENU控制通话的开始、停止、结束。
      最后说明，AudioRecord和AudioTrack类可以用，只是稍微复杂些。以下贴出双方通信的源码，希望对大家有所帮助：
主程序Daudioclient：
1. view plaincopy to clipboardprint?
2. package cn.Daudioclient;
3.
4. import android.app.Activity;
5. import android.os.Bundle;
6. import android.view.Menu;
7. import android.view.MenuItem;
8.
9. public class Daudioclient extends Activity {
10.
11. public static final int MENU_START_ID = Menu.FIRST ;
12. public static final int MENU_STOP_ID = Menu.FIRST + 1 ;
13. public static final int MENU_EXIT_ID = Menu.FIRST + 2 ;
14.
15. protected Saudioserver m_player ;
16. protected Saudioclient m_recorder ;
17.
18.
19. @Override
20. public void onCreate(Bundle savedInstanceState) {
21. Create(savedInstanceState);
22. setContentView(R.layout.main);
23. }
24.
25. public boolean onCreateOptionsMenu(Menu aMenu)
26. {
27. boolean res = CreateOptionsMenu(aMenu) ;
28.
29. aMenu.add(0, MENU_START_ID, 0, "START") ;
30. aMenu.add(0, MENU_STOP_ID, 0, "STOP") ;
31. aMenu.add(0, MENU_EXIT_ID, 0, "EXIT") ;
32.
33. return res ;
34. }
35.
36.
37. public boolean onOptionsItemSelected(MenuItem aMenuItem)
38. {
39. switch (ItemId()) {
40. case MENU_START_ID:
41. {
42. m_player = new Saudioserver() ;
43. m_recorder = new Saudioclient() ;
44.
45. m_player.init() ;
46. m_recorder.init() ;
47.
48. m_recorder.start() ;
49. m_player.start() ;
50.
51. }
52. break ;
53. case MENU_STOP_ID:
54. {
55. m_recorder.free() ;
56. m_player.free() ;
57.
58. m_player = null ;
59. m_recorder = null ;
60. }
61. break ;
62. case MENU_EXIT_ID:
63. {
64. int pid = android.Pid() ;
65. android.os.Process.killProcess(pid) ;
66. }
67. break ;
68. default:
69. break ;
70. }
71.
72. OptionsItemSelected(aMenuItem);
73. }
74. }
75. package cn.Daudioclient;
76.
77. import android.app.Activity;
78. import android.os.Bundle;
79. import android.view.Menu;
80. import android.view.MenuItem;
81.
82. public class Daudioclient extends Activity {
83.
84. public static final int MENU_START_ID = Menu.FIRST ;
85. public static final int MENU_STOP_ID = Menu.FIRST + 1 ;
86. public static final int MENU_EXIT_ID = Menu.FIRST + 2 ;
87.
88. protected Saudioserver m_player ;
89. protected Saudioclient m_recorder ;
90.
91.
92. @Override
93. public void onCreate(Bundle savedInstanceState) {
94. Create(savedInstanceState);
95. setContentView(R.layout.main);
96. }
97.
98. public boolean onCreateOptionsMenu(Menu aMenu)
99. {
100. boolean res = CreateOptionsMenu(aMenu) ;
101.
102. aMenu.add(0, MENU_START_ID, 0, "START") ;
103. aMenu.add(0, MENU_STOP_ID, 0, "STOP") ;
104. aMenu.add(0, MENU_EXIT_ID, 0, "EXIT") ;
105.
106. return res ;
107. }
108.
109.
110. public boolean onOptionsItemSelected(MenuItem aMenuItem)
111. {
112. switch (ItemId()) {
113. case MENU_START_ID:
114. {
115. m_player = new Saudioserver() ;
116. m_recorder = new Saudioclient() ;
117.
118. m_player.init() ;
119. m_recorder.init() ;
120.
121. m_recorder.start() ;
122. m_player.start() ;
123.
124. }
125. break ;
126. case MENU_STOP_ID:
127. {
128. m_recorder.free() ;
129. m_player.free() ;
130.
131. m_player = null ;
132. m_recorder = null ;
133. }
134. break ;
135. case MENU_EXIT_ID:
136. {
137. int pid = android.Pid() ;
138. android.os.Process.killProcess(pid) ;
139. }
140. break ;
141. default:
142. break ;
143. }
144.
145. OptionsItemSelected(aMenuItem);
146. }
147. }
3 录音程序Saudioclient：
1.
2. package cn.Daudioclient;   
3.  
4. import java.io.DataOutputStream;   
5. import java.io.IOException;   
6. import java.Socket;   
7. import java.UnknownHostException;   
8. import java.util.LinkedList;   
9.  
10. dia.AudioFormat;   
11. dia.AudioRecord;   
12. dia.MediaRecorder;   
13. import android.util.Log;   
14.  
15. public class Saudioclient extends Thread   
16. {   
17.    
18.     protected AudioRecord m_in_rec ;   
19.     protected int         m_in_buf_size ;   
20.     protected byte []     m_in_bytes ;   
21.     protected boolean     m_keep_running ;   
22.     protected Socket      s;   
23.     protected DataOutputStream dout;   
24.     protected LinkedList<byte[]>  m_in_q ;   
25.      
26.     public void run()   
27. {   
28.       try 
29.       {   
30.           byte [] bytes_pkg ;   
31.             m_in_rec.startRecording() ;   
32.             while(m_keep_running)   
33.             {   
34.                  m_ad(m_in_bytes, 0, m_in_buf_size) ;   
35.                  bytes_pkg = m_in_bytes.clone() ;   
36.                  if(m_in_q.size() >= 2)   
37.                  {   
38.                         dout.write(m_veFirst() , 0, m_veFirst() .length);   
39.                     }   
40.                     m_in_q.add(bytes_pkg) ;   
41.             }   
42.        
43.             m_in_rec.stop() ;   
44.             m_in_rec = null ;   
45.             m_in_bytes = null ;   
46.       dout.close();   
47.            
48.       }   
49.       catch(Exception e)   
50.       {   
51.       e.printStackTrace();   
52.       }   
53.     }   
54.      
55.     public void init()   
56.     {   
57.      m_in_buf_size =  MinBufferSize(8000,   
58.                         AudioFormat.CHANNEL_CONFIGURATION_MONO,   
59.                         AudioFormat.ENCODING_PCM_16BIT);   
60.      
61.   m_in_rec = new AudioRecord(MediaRecorder.AudioSource.MIC,   
62.   8000,   
63.   AudioFormat.CHANNEL_CONFIGURATION_MONO,   
64.   AudioFormat.ENCODING_PCM_16BIT,   
65.   m_in_buf_size) ;   
66.      
67.   m_in_bytes = new byte [m_in_buf_size] ;   
68.      
69.   m_keep_running = true ;   
70.   m_in_q=new LinkedList<byte[]>();   
71.      
72.      try 
73.      {   
74.    s=new Socket("192.168.1.100",4332);   
75.    dout=new OutputStream());   
76.    //new Thread(R1).start();   
77.   }   
78.      catch (UnknownHostException e)   
79.      {   
80.    // TODO Auto-generated catch block   
81.    e.printStackTrace();   
82.   }   
83.      catch (IOException e)   
84.      {   
85.    // TODO Auto-generated catch block   
86.    e.printStackTrace();   
87.   }   
88.  
89.     }   
90.      
91.     public void free()   
92. {   
93.   m_keep_running = false ;   
94.         try {   
95.             Thread.sleep(1000) ;   
96.         } catch(Exception e) {   
97.             Log.d("\n","") ;   
98.         }   
99. }   
100. } 
101.
102.
4 AudioRecord和AudioTrack类的使用 收藏
    （1）创建AudioRecord和AudioTrack类对象：创建这两个类的对象比较复杂，通过对文档的反复和仔细理解，并通过多次失败的尝试，并在北理工的某个Android大牛的网上的文章启发下，我们也最终成功地创建了这两个类的对象。创建AudioRecord和AudioTrack类对象的代码如下：
AudioRecord类：
view plaincopy to clipboardprint?
         m_in_buf_size =MinBufferSize(8000,   
                        AudioFormat.CHANNEL_CONFIGURATION_MONO,   
                        AudioFormat.ENCODING_PCM_16BIT);   
     
         m_in_rec = new AudioRecord(MediaRecorder.AudioSource.MIC,   
         8000,   
         AudioFormat.CHANNEL_CONFIGURATION_MONO,   
         AudioFormat.ENCODING_PCM_16BIT,   
         m_in_buf_size) ;   
 
AudioTrack类：   
 
         m_out_buf_size = MinBufferSize(8000,   
                          AudioFormat.CHANNEL_CONFIGURATION_MONO,   
                          AudioFormat.ENCODING_PCM_16BIT);   
 
         m_out_trk = new AudioTrack(AudioManager.STREAM_MUSIC, 8000,   
                                       AudioFormat.CHANNEL_CONFIGURATION_MONO,   
                                       AudioFormat.ENCODING_PCM_16BIT,   
                                       m_out_buf_size,   
                                       AudioTrack.MODE_STREAM); 
         m_in_buf_size =MinBufferSize(8000,
                        AudioFormat.CHANNEL_CONFIGURATION_MONO,
                        AudioFormat.ENCODING_PCM_16BIT);
   
         m_in_rec = new AudioRecord(MediaRecorder.AudioSource.MIC,
         8000,
         AudioFormat.CHANNEL_CONFIGURATION_MONO,
         AudioFormat.ENCODING_PCM_16BIT,
         m_in_buf_size) ;
AudioTrack类：
         m_out_buf_size = MinBufferSize(8000,
                          AudioFormat.CHANNEL_CONFIGURATION_MONO,
                          AudioFormat.ENCODING_PCM_16BIT);
         m_out_trk = new AudioTrack(AudioManager.STREAM_MUSIC, 8000,
                                       AudioFormat.CHANNEL_CONFIGURATION_MONO,
                                       AudioFormat.ENCODING_PCM_16BIT,
                                       m_out_buf_size,
                                       AudioTrack.MODE_STREAM);

    （2）关于AudioRecord和AudioTrack类的监听函数，不用也行。
    （3）调试方面，包括初始化后看logcat信息，以确定类的工作状态，初始化是否成功等。
     编写好代码，没有语法错误，调用模拟器运行、调试代码时，logcat发挥了很好的功用。刚调试时，经常会出现模拟器显示出现异常，这时我们可以在代码的一些关键语句后添加如Log.d("test1","OK")；这样的语句进行标识，出现异常时我们就可以在logcat窗口观察代码执行到哪里出现异常，然后进行相应的修改、调试。模拟器不会出现异常时，又遇到了录放音的问题。录音方面，刚开始选择将语音编码数据存放在多个固定大小的文件中进行传送，但是这种情况下会出现声音断续的现象，而且要反复的建立文件，比较麻烦，后来想到要进行网上传输，直接将语音编码数据以数据流的形式传送，经过验证，这种方法可行并且使代码更加简洁。放音方面，将接收到的数据流存放在一个数组中，然后将数组中数据写到AudioTrack中。刚开始只是“嘟”几声，经过检查发现只是把数据写一次，加入循环，让数据反复写到AudioTrack中，就可以听到正常的语音了。接下来的工作主要是改善话音质量与话音延迟，在进行通话的过程中，观察logcat窗口，发现向数组中写数据时会出现Bufferflow的情况，于是把重心转移到数组大小的影响上，经过试验，发现 AudioRecord一次会读640个数据，然后就对录音和放音中有数组的地方进行实验修改。AudioRecord和AudioTrack进行实例化时，参数中各有一个数组大小，经过试验这个数组大小和AudioRecord和AudioTrack能正常实例化所需的最小Buffer大小（即上面实例化时的m_in_buf_size和m_out_buf_size参数）相等且服务器方进行缓存数据的数组尺寸是上述数值的2倍时，语音质量最好。由于录音和放音的速度不一致，受到北理工大牛的启发，在录音方面，将存放录音数据的数组放到LinkedList中,当LinkedList中数组个数达到2（这个也是经过试验验证话音质量最好时的数据）时，将先录好的数组中数据传送出去。经过上述反复试验和修改，最终使双方通话质量较好，且延时较短（大概有2秒钟）。
    （4）通过套接字传输和接收数据
     数据传送部分，使用的是套接字。通信双方，通过不同的端口向服务器发送请求，与服务器连接上后，开始通话向服务器发送数据，服务器通过一个套接字接收到一方的数据后，先存在一个数组中，然后将该数组中数据以数据流的形式再通过另一个套接字传送到另一方。这样就实现了双方数据的传送。
     （5）代码架构
      为避免反复录入和读取数据占用较多资源，使程序在进行录放音时不能执行其他命令，故将录音和放音各写成一个线程类，然后在主程序中，通过MENU控制通话的开始、停止、结束。
      最后说明，AudioRecord和AudioTrack类可以用，只是稍微复杂些。以下贴出双方通信的源码，希望对大家有所帮助：
主程序Daudioclient：
view plaincopy to clipboardprint?
package cn.Daudioclient;   
 
import android.app.Activity;   
import android.os.Bundle;   
import android.view.Menu;   
import android.view.MenuItem;   
 
public class Daudioclient extends Activity {   
   
    public static final int MENU_START_ID = Menu.FIRST ;   
    public static final int MENU_STOP_ID = Menu.FIRST + 1 ;   
    public static final int MENU_EXIT_ID = Menu.FIRST + 2 ;   
   
    protected Saudioserver     m_player ;   
    protected Saudioclient     m_recorder ;   
   
     
    @Override 
    public void onCreate(Bundle savedInstanceState) {   
        Create(savedInstanceState);   
        setContentView(R.layout.main);   
    }   
     
    public boolean onCreateOptionsMenu(Menu aMenu)   
    {   
        boolean res = CreateOptionsMenu(aMenu) ;   
 
        aMenu.add(0, MENU_START_ID, 0, "START") ;   
        aMenu.add(0, MENU_STOP_ID, 0, "STOP") ;   
        aMenu.add(0, MENU_EXIT_ID, 0, "EXIT") ;   
 
        return res ;   
    }   
 
     
    public boolean onOptionsItemSelected(MenuItem aMenuItem)   
    {   
        switch (ItemId()) {   
        case MENU_START_ID:   
            {   
            m_player = new Saudioserver() ;   
                m_recorder = new Saudioclient() ;   
 
                m_player.init() ;   
                m_recorder.init() ;   
 
                m_recorder.start() ;   
                m_player.start() ;   
                 
            }   
            break ;   
        case MENU_STOP_ID:   
            {     
            m_recorder.free() ;   
                m_player.free() ;   
 
                m_player = null ;   
                m_recorder = null ;   
            }   
            break ;   
        case MENU_EXIT_ID:   
            {   
                int pid = android.Pid() ;   
                android.os.Process.killProcess(pid) ;   
            }   
            break ;   
        default:   
            break ;   
        }   
 
        OptionsItemSelected(aMenuItem);   
    }   
} 
package cn.Daudioclient;
import android.app.Activity;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
public class Daudioclient extends Activity {

    public static final int MENU_START_ID = Menu.FIRST ;
    public static final int MENU_STOP_ID = Menu.FIRST + 1 ;
    public static final int MENU_EXIT_ID = Menu.FIRST + 2 ;

    protected Saudioserver     m_player ;
    protected Saudioclient     m_recorder ;

   
    @Override
    public void onCreate(Bundle savedInstanceState) {
        Create(savedInstanceState);
        setContentView(R.layout.main);
    }
   
    public boolean onCreateOptionsMenu(Menu aMenu)
    {
        boolean res = CreateOptionsMenu(aMenu) ;
        aMenu.add(0, MENU_START_ID, 0, "START") ;
        aMenu.add(0, MENU_STOP_ID, 0, "STOP") ;
        aMenu.add(0, MENU_EXIT_ID, 0, "EXIT") ;
        return res ;
    }
   
    public boolean onOptionsItemSelected(MenuItem aMenuItem)
    {
        switch (ItemId()) {
        case MENU_START_ID:
            {
            m_player = new Saudioserver() ;
                m_recorder = new Saudioclient() ;
                m_player.init() ;
                m_recorder.init() ;
                m_recorder.start() ;
                m_player.start() ;
               
            }
            break ;
        case MENU_STOP_ID:
            { 
            m_recorder.free() ;
                m_player.free() ;
                m_player = null ;
                m_recorder = null ;
            }
            break ;
        case MENU_EXIT_ID:
            {
                int pid = android.Pid() ;
                android.os.Process.killProcess(pid) ;
            }
            break ;
        default:
            break ;
        }
        OptionsItemSelected(aMenuItem);
    }
}

录音程序Saudioclient：
view plaincopy to clipboardprint?
package cn.Daudioclient;   
 
import java.io.DataOutputStream;   
import java.io.IOException;   
import java.Socket;   
import java.UnknownHostException;   
import java.util.LinkedList;   
 
dia.AudioFormat;   
dia.AudioRecord;   
dia.MediaRecorder;   
import android.util.Log;   
 
public class Saudioclient extends Thread   
{   
   
    protected AudioRecord m_in_rec ;   
    protected int         m_in_buf_size ;   
    protected byte []     m_in_bytes ;   
    protected boolean     m_keep_running ;   
    protected Socket      s;   
    protected DataOutputStream dout;   
    protected LinkedList<byte[]>  m_in_q ;   
     
    public void run()   
{   
      try 
      {   
          byte [] bytes_pkg ;   
            m_in_rec.startRecording() ;   
            while(m_keep_running)   
            {   
                 m_ad(m_in_bytes, 0, m_in_buf_size) ;   
                 bytes_pkg = m_in_bytes.clone() ;   
                 if(m_in_q.size() >= 2)   
                 {   
                        dout.write(m_veFirst() , 0, m_veFirst() .length);   
                    }   
                    m_in_q.add(bytes_pkg) ;   
            }   
       
            m_in_rec.stop() ;   
            m_in_rec = null ;   
            m_in_bytes = null ;   
      dout.close();   
           
      }   
      catch(Exception e)   
      {   
      e.printStackTrace();   
      }   
    }   
     
    public void init()   
    {   
     m_in_buf_size =  MinBufferSize(8000,   
                        AudioFormat.CHANNEL_CONFIGURATION_MONO,   
                        AudioFormat.ENCODING_PCM_16BIT);   
     
  m_in_rec = new AudioRecord(MediaRecorder.AudioSource.MIC,   
  8000,   
  AudioFormat.CHANNEL_CONFIGURATION_MONO,   
  AudioFormat.ENCODING_PCM_16BIT,   
  m_in_buf_size) ;   
     
  m_in_bytes = new byte [m_in_buf_size] ;   
     
  m_keep_running = true ;   
  m_in_q=new LinkedList<byte[]>();   
     
     try 
     {   
   s=new Socket("192.168.1.100",4332);   
   dout=new OutputStream());   
   //new Thread(R1).start();   
  }   
     catch (UnknownHostException e)   
     {   
   // TODO Auto-generated catch block   
   e.printStackTrace();   
  }   
     catch (IOException e)   
     {   
   // TODO Auto-generated catch block   
   e.printStackTrace();   
  }   
 
    }   
     
    public void free()   
{   
  m_keep_running = false ;   
        try {   
            Thread.sleep(1000) ;   
        } catch(Exception e) {   
            Log.d("\n","") ;   
        }   
}   
} 
package cn.Daudioclient;
import java.io.DataOutputStream;
import java.io.IOException;
import java.Socket;
import java.UnknownHostException;
import java.util.LinkedList;
dia.AudioFormat;
dia.AudioRecord;
dia.MediaRecorder;
import android.util.Log;
public class Saudioclient extends Thread
{

    protected AudioRecord m_in_rec ;
    protected int         m_in_buf_size ;
    protected byte []     m_in_bytes ;
    protected boolean     m_keep_running ;
    protected Socket      s;
    protected DataOutputStream dout;
    protected LinkedList<byte[]>  m_in_q ;
 
    public void run()
{
      try
      {
          byte [] bytes_pkg ;
            m_in_rec.startRecording() ;
            while(m_keep_running)
            {
                 m_ad(m_in_bytes, 0, m_in_buf_size) ;
                 bytes_pkg = m_in_bytes.clone() ;
                 if(m_in_q.size() >= 2)
                 {
                        dout.write(m_veFirst() , 0, m_veFirst() .length);
                    }
                    m_in_q.add(bytes_pkg) ;
            }
     
            m_in_rec.stop() ;
            m_in_rec = null ;
            m_in_bytes = null ;
      dout.close();
       
      }
      catch(Exception e)
      {
      e.printStackTrace();
      }
    }
   
    public void init()
    {
     m_in_buf_size =  MinBufferSize(8000,
                        AudioFormat.CHANNEL_CONFIGURATION_MONO,
                        AudioFormat.ENCODING_PCM_16BIT);
   
  m_in_rec = new AudioRecord(MediaRecorder.AudioSource.MIC,
  8000,
  AudioFormat.CHANNEL_CONFIGURATION_MONO,
  AudioFormat.ENCODING_PCM_16BIT,
  m_in_buf_size) ;
 
  m_in_bytes = new byte [m_in_buf_size] ;
 
  m_keep_running = true ;
  m_in_q=new LinkedList<byte[]>();
 
     try
     {
   s=new Socket("192.168.1.100",4332);
   dout=new OutputStream());
   //new Thread(R1).start();
  }
     catch (UnknownHostException e)
     {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
     catch (IOException e)
     {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
    }
   
    public void free()
{
  m_keep_running = false ;
        try {
            Thread.sleep(1000) ;
        } catch(Exception e) {
            Log.d("\n","") ;
        }
}
}

放音程序Saudioserver：
1. package cn.Daudioclient;
2.
3. import java.io.DataInputStream;
4. import java.io.IOException;
5. import java.Socket;
6.
7. dia.AudioFormat;
8. dia.AudioManager;
9. dia.AudioTrack;
10. import android.util.Log;
11.
12. public class Saudioserver extends Thread
13. {
14. protected AudioTrack m_out_trk ;
15. protected int m_out_buf_size ;
16. protected byte [] m_out_bytes ;
17. protected boolean m_keep_running ;
18. private Socket s;
19. private DataInputStream din;
20. public void init()
21. {
22. try
23. {
24. s=new Socket("192.168.1.100",4331);
25. din=new InputStream());
26.
27. m_keep_running = true ;
28.
29.
30. m_out_buf_size = MinBufferSize(8000,
31. AudioFormat.CHANNEL_CONFIGURATION_MONO,
32. AudioFormat.ENCODING_PCM_16BIT);
33.
34. m_out_trk = new AudioTrack(AudioManager.STREAM_MUSIC, 8000,
35. AudioFormat.CHANNEL_CONFIGURATION_MONO,
36. AudioFormat.ENCODING_PCM_16BIT,
37. m_out_buf_size,
38. AudioTrack.MODE_STREAM);
39.
40. m_out_bytes=new byte[m_out_buf_size];
41.
42. // new Thread(R1).start();
43.
44. }
45. catch(Exception e)
46. {
47. e.printStackTrace();
48. }
49. }
50.
51. public void free()
52. {
53. m_keep_running = false ;
54. try {
55. Thread.sleep(1000) ;
56. } catch(Exception e) {
57. Log.d("\n","") ;
58. }
59. }
60.
61. public void run()
62. {
63. byte [] bytes_pkg = null ;
64. m_out_trk.play() ;
65. while(m_keep_running) {
66. try
67. {
68. ad(m_out_bytes);
69. bytes_pkg = m_out_bytes.clone() ;
70. m_out_trk.write(bytes_pkg, 0, bytes_pkg.length) ;
71. }
72. catch(Exception e)
73. {
74. e.printStackTrace();
75. }
76.
77. }
78.
79. m_out_trk.stop() ;
80. m_out_trk = null ;
81. try {
82. din.close();
83. } catch (IOException e) {
84. // TODO Auto-generated catch block
85. e.printStackTrace();
86. }
87. }
88. }
11-19 11:53:55.897: INFO/System.out(2127):  aaa116666！startRecording() called on an uninitialized AudioRecord.

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。