使用AudioTrack和AudioRecord录制和播放PCM wave文件

最新推荐文章于 2023-02-06 22:17:11 发布
最新推荐文章于 2023-02-06 22:17:11 发布
阅读量996 收藏 1
点赞数


  http://blog.csdn.net/brooknew/article/details/8274594

 Android.media package里包含声音录放的两个类AudioRecord和AudioTrack。前者用来录制，后者用来播放。录制的流程基本上如第一个图，播放基本上如第二个图。

      

首先来看看 AudioRecord 的构造函数：public AudioRecord(int audioSource, int sampleRateInHz, int channelConfig, int audioFormat, int bufferSizeInBytes)

第一个参数是音源，可以是从MicroPhone( MediaRecorder.AudioSource.MIC),也可以是通话的话音( MediaRecorder.AudioSource.VOICE_CALL,MediaRecorder.AudioSource.VOICE_DOWNLINK即对方声音，MediaRecorder.AudioSource.VOICE_UPLINK即本方声音 )

第二个参数是期望录音的采样频率，比如8000，16000，44100等

第三个参数是期望录音的声道数，可以是AudioFormat.CHANNEL_IN_MONO 和 AudioFormat.CHANNEL_STEREO.

第四个参数是期望录音的比特数，可以是AudioFormat.ENCODING_PCM_16BIT和AudioFormat.ENCODING_PCM_8BIT.

第五个参数是期望录音时系统为其提供的缓冲区大小，必须大于使用AudioRecord.getMinBufferSize() 得出的大小，这个参数指定的数值愈大，可以有更长的缓冲时间，也就是可以间隔较长的时间调用AudioRecord.read 函数从底层取得数据也不会溢出。

关于第一参数指定录制电话通话时，有的手机可以，有的手机不行。不行的原因是因为平台没有实现这个功能。我试过 Nexus-s不行，HTC Desire HD 可以，和“通话录音CallRecorder_1.29.apk”这个程序的测试结果一致。

startRecording()之后就可以不断调用 read函数取得声音数据。这个函数是阻塞试的，下层没有足够的数据会停在它里面。

一般来说，在一个独立线程里处理录音的数据采集比较好。

 

然后来看看AudioTrack的构造函数

AudioTrack(int streamType, int sampleRateInHz, int channelConfig, int audioFormat, int bufferSizeInBytes, int mode)

第一个参数 是选择流的种类，一般来说从喇叭放音选择 STREAM_MUSIC

最后一个参数是表示一次性把数据传给 AudioTrack还是连续不断地使用  write 函数传数据。我这里选择 MODE_STREAM

还有几个函数要在这里说一下。

write也是阻塞式的，下面的数据满了的话，会在它里面等待。

getHeadPosition()返回值表示当前已经播放了多少帧(1帧就是采样一次的意思，比如采样率是8000的话，那么1秒钟就是8000帧)

AudioTrack.OnPlaybackPositionUpdateListener 声明两个方法：

onMarkerReached(AudioTrack track )

onPeriodicNotification(AudioTrack track )

这两个方法由客户实现，通过 setPlaybackPositionUpdateListener 把该接口的实现类设进去。

通过 setNotificationMarkerPosition 设定一个marker位置，当声音播放到这个位置时，就启动onMarkerReached 方法。

通过 setPositionNotificationPeriod 设定一个周期，然后每播放了这个周期的声音时，就会启动 onPeriodicNotification 的周期。

getHeadPosition  ， onMarkerReached ， onPeriodicNotification 可以方便的取得声音播放的时间，了解声音的节奏，可以用来和视频和字幕同步。 

 下面上代码：

/avccodecDemo/src/yzriver/avc/avccodec/AudioRecThread.Java

 

package yzriver.avc.avccodec;


import java.lang.Thread;

 

import java.lang.Runnable;
import android.os.Handler;
import android.os.Message;
import android.os.PowerManager ;
import android.util.Log;
import android.content.Context ;
import java.io.FileInputStream ;
import java.io.FileOutputStream ;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.io.FileNotFoundException;

import android.os.Handler;
import java.lang.System;
import android.widget.TextView;
import android.media.AudioRecord ;
import android.media.AudioFormat ;
import android.media.MediaRecorder.AudioSource;
import android.media.AudioManager;
import android.media.AudioTrack ;
import android.media.AudioTrack.OnPlaybackPositionUpdateListener ;
import java.util.Arrays;
 
public class AudioRecThread implements android.media.AudioTrack.OnPlaybackPositionUpdateListener {
 final static String TAG = "AudioRecThread" ;
 static public  final int MSG_AUDIO_REC_FINISH = 1;
 static public  final int MSG_AUDIO_PLAY_FINISH = 2;
 private boolean audioRecContinue = false ;
 private boolean audioPlayContinue = false ;
 private PowerManager.WakeLock  wl ;
 private Thread thread;
 private long startPlayMilli = 0 ;
 private long playUpdatePeriodAmass = 0 ;
 private long timeMarkAttendModified = 0 ;
 private int  markPos = 0 ;
 private int markMill = 200 ;
 
 private final Handler myHandler = new MainHandler() ;

 private int updateTimes = 0 ;
 private class MainHandler extends Handler{
  @Override
     public void handleMessage(Message msg) {
        /* switch (msg.what) {
             case AvcThread.MSG_UPDATE_YUVVIEW: {
              updateTimes ++ ; 
              Log.v("GraphicsDraw", "AvcThread.MSG_UPDATE_YUVVIEW") ;
              graphicsView.update( argbArray ,yuv_width , yuv_height  );
                 break;
             }
             case AvcThread.MSG_UPDATE_FRAMERATE: {
   String str ;
   if( frameRatePreText == null )
    str = "Enc/Dec frame rate is " ;
   else
    str = frameRatePreText ;
              str +=  mFrameRate ;
              frameRateTextView.setText( str  ) ;
              frameRateTextView.bringToFront();  
              break ;
             }
         }*/
     }
    }
  public void onPeriodicNotification(AudioTrack track){
   playUpdatePeriodAmass += 25 ;
   long c = System.currentTimeMillis() ;
   c -= startPlayMilli ;
   c = track.getPlaybackHeadPosition() ;
   c /= 8;
   Log.v(TAG+" onPeriodicNotification", "real ms " + c + " period total " +  playUpdatePeriodAmass ) ;
 }
 public void onMarkerReached(AudioTrack track) {
  timeMarkAttendModified = System.currentTimeMillis() ;
  timeMarkAttendModified -= markMill ;
  Log.v(TAG+" period currpos", "mark:"+markMill ) ;
 }
 
 AudioRecThread( PowerManager.WakeLock wl1){
  Log.v(TAG, "AvcThread created constructor1");
  wl = wl1 ;  
 }
 
 void writeShort( RandomAccessFile fo , short in ) throws IOException {
  byte tmp[] = {0,0} ;
  tmp[0] =(byte) (in&0xff) ;
  tmp[1] =(byte) ((in >> 8) & 0xff) ;
  try {
   fo.write(tmp);
  }catch( IOException e ){
   throw e ;
  } 
 }
 
 void writeInt( RandomAccessFile fo , int in ) throws IOException {
  byte tmp[] = {0,0,0,0} ;
  tmp[0] =(byte) (in&0xff) ;
  tmp[1] =(byte) ((in >> 8) & 0xff) ;
  tmp[2] =(byte) ((in >> 16) & 0xff) ;
  tmp[3] =(byte) ((in >> 24) & 0xff) ;  
  try {
   fo.write(tmp);
  }catch( IOException e ){
   throw e ;
  } 
 } 
 
 void startAudioRec(final String audioFname, final int  audioSource, final Handler handler )
 {
 
  final Runnable audioRecRun = new Runnable() {       
       public void run() {

       int channel =AudioFormat.CHANNEL_IN_MONO ;
       short  channels = 1 ;
       int format = AudioFormat.ENCODING_PCM_16BIT ;
   int bitsPerSample = 16 ;
       int sampleRate = 8000 ;
       int bufferSizeInBytes = AudioRecord.getMinBufferSize ( sampleRate, channel , format  ) *4 ;

       AudioRecord audioRecord = new AudioRecord( audioSource,sampleRate, channel,format,  bufferSizeInBytes);
       if( audioRecord == null )
     return ;
       int bufReadLenInByte = bufferSizeInBytes/2 ;
       byte[] bufRead = new byte[bufReadLenInByte] ;
        
    RandomAccessFile  fo ;
    wl.acquire() ;
        try {
         fo = new RandomAccessFile  ( audioFname , "rw" ) ;
        }catch ( FileNotFoundException e){
         return ;
        }catch ( IllegalArgumentException e ) {
     return ;
    }catch( SecurityException e ) {
     return ;
    }
        
/*
typedef struct tWAVEFORMATEX
{
    WORD        wFormatTag;       
    WORD        nChannels;        
    DWORD       nSamplesPerSec;
    DWORD       nAvgBytesPerSec; 
    WORD        nBlockAlign;       
    WORD        wBitsPerSample; 
    WORD        cbSize;            
} WAVEFORMATEX
*/    
       int datalength = 0 ;
       
       try {
        byte[]  tmp = {0,0,0,0} ;
        fo.writeBytes( "RIFF" ) ;
     fo.writeInt(0) ; // Riff file length
     fo.writeBytes("WAVE"); // 4
     fo.writeBytes("fmt ") ; // 4     
     writeInt(fo , 16 ) ; //4 , followed by 16 bytes     
     writeShort(fo, (short)1 ) ;//pcm wave tag
     writeShort(fo, (short) channels ) ;
     writeInt(fo, sampleRate ) ;     
     writeInt(fo, bitsPerSample*sampleRate*channels/8) ;
     writeShort(fo, (short)(channels*bitsPerSample/8) ) ;
     writeShort(fo,(short)bitsPerSample) ;
     fo.writeBytes("data"); // 4
     fo.writeInt( 0 ) ; // 4 ,data length
       }catch( IOException  e) {
        
       }
    

    audioRecContinue = true ;
    try {
     audioRecord.startRecording()  ;
    } catch( IllegalStateException  e ) {

    }

        while( audioRecContinue )
        {
         //Log.v(TAG+"-ENC","In run AudioRecThread.encodeContinue="+audioRecContinue ) ;
         try
         {
           int read = audioRecord.read ( bufRead, 0 , bufReadLenInByte)  ;
           if( read > 0  ) {
           fo.write((byte[]) bufRead , 0, read ) ;
           datalength += read ;
          }
         }
         catch (IOException e)
         {
          
         }        
        }
        try {
         fo.seek( 4 ) ;
         writeInt(fo, 36 +datalength ) ;
         fo.seek( 40 ) ;
         writeInt(fo, datalength ) ;        
         fo.close() ;
        }
        catch (IOException e)
        {
          
        }
    try {
     audioRecord.stop()  ;
    } catch( IllegalStateException  e ) {

    }
    audioRecord.release() ;

        wl.release() ;
        handler.sendEmptyMessage( MSG_AUDIO_REC_FINISH ) ;
        Log.v(TAG,"AvcThread Finish encoding " ) ;
   }
  } ;  
  startLowPriorityNewThread(audioRecRun);  
 }
 public void stopAudioRec() {
  audioRecContinue = false ;
  if( thread != null  ) {
   try {
      thread.join() ;
   }catch( InterruptedException e  ) {
    
   }  
  }

  thread = null; 
  //Log.v(TAG,"in stopAvcEnc AvcThread.encodeContinue="+encodeContinue ) ;
 }
 
 
 private short readShort( FileInputStream fi ) throws IOException {
  byte tmp[] = {0,0} ;
  try {
   fi.read(tmp);
  }catch( IOException e ){
   throw e ;
  }
  short r = tmp[1] ;
  r <<= 8 ;
  r += tmp[0] ;
  return r  ;
 }
 
 private int readInt( FileInputStream fi ) throws IOException {
  byte tmp[] = {0,0,0,0} ;

  try {
   fi.read(tmp);
  }catch( IOException e ){
   throw e ;
  } 
  int r = tmp[3] ;
  r <<= 8 ;
  r += tmp[2] ;
  r <<= 8 ;
  r += tmp[1] ;
  r <<= 8 ;
  r += tmp[0] ;
  
  return r ;  
 } 


 void startAudioPlay(final String audioFname,  final Handler handler )
 {
 
  final Runnable audioRecRun = new Runnable() {       
       public void run() {
       FileInputStream fi ;
       try {
        fi = new FileInputStream( audioFname );
       }catch (FileNotFoundException e ) {
        return ;
       }
       
       short  channels = 1 ;
       int blockAlign ;
       int bitsPerSample ;
       int sampleRate  ;
        
    wl.acquire() ;
  
       int datalength = 0 ;
       
       try {
        byte[]  tmp = {0,0,0,0} ;
        fi.read(tmp) ;
        boolean check = Arrays.equals( tmp, "RIFF".getBytes() ) ;
        if( check!= true )
         return ;
     fi.read(tmp) ; // Riff file length
     fi.read( tmp ) ;
     check = Arrays.equals( tmp, "WAVE".getBytes()); // 4
     if( check!= true )
         return ;
     fi.read( tmp ) ;
     check = Arrays.equals( tmp ,  "fmt ".getBytes()) ; // 4
     if( check!= true )
         return ;
     int headlen = readInt(fi ) ;
     if( headlen != 16 )
      return ; //4 , followed by 16 bytes     
     short s = readShort(fi ) ;
     if( s != 1 )
      return ;//pcm wave tag
     channels = readShort(fi ) ;
     sampleRate = readInt(fi )  ;     
     readInt(fi) ; // bitsPerSample*sampleRate*channels/8) ;
     blockAlign = readShort(fi ) ;//, (short)(channels*bitsPerSample/8) ) ;
     bitsPerSample = readShort(fi ) ;//,(short)bitsPerSample) ;
     fi.read( tmp ) ; //"data"); // 4
     fi.read( tmp ) ; // 4 ,data length
       }catch( IOException  e) {
        return ;
       }
    
       
       int format  ;//= AudioFormat.ENCODING_PCM_16BIT ;
       int channel  ;//=AudioFormat.CHANNEL_CONFIGURATION_MONO ;
       
       if( channels == 2 )
        channel = AudioFormat.CHANNEL_OUT_STEREO ;
       else if( channels == 1 )
        channel = AudioFormat.CHANNEL_OUT_MONO ;
       else
        channel = -1 ;
       
       if( bitsPerSample == 16 )
        format = AudioFormat.ENCODING_PCM_16BIT ;
       else if( bitsPerSample == 8 )
        format = AudioFormat.ENCODING_PCM_8BIT ;
       else
        format = -1 ;
       
       int bufferSizeInBytes = AudioTrack.getMinBufferSize(sampleRate,channel,format) *4 ;
       if( bufferSizeInBytes < channels*bitsPerSample*2/8*sampleRate  ) ;
        bufferSizeInBytes = channels*bitsPerSample*2/8*sampleRate ;
       Log.v(TAG+" write", "bufferSizeInBytes="+bufferSizeInBytes ) ;
       
       AudioTrack audioTrack = new AudioTrack(AudioManager.STREAM_MUSIC, sampleRate,channel, format, bufferSizeInBytes, AudioTrack.MODE_STREAM ) ; 
       if( audioTrack == null )
     return ;
       int bufReadLenInByte = bufferSizeInBytes ;
       byte[] bufRead = new byte[bufReadLenInByte] ;
    audioPlayContinue = true ;
    
    audioTrack.setPositionNotificationPeriod(200) ;
    
    markPos = sampleRate*markMill/1000 ;
    int rr = audioTrack.setNotificationMarkerPosition(markPos) ;
    Log.v(TAG+" Period currpos", "setNotificationMarkerPosition return "+rr) ;
    audioTrack.setPlaybackPositionUpdateListener( AudioRecThread.this ) ;
    //int rr = audioTrack.setPlaybackHeadPosition(8000*5);
    //Log.v(TAG+" Period", "setPlaybackHeadPosition return "+rr) ;
    startPlayMilli = System.currentTimeMillis() ;
    Log.v(TAG+" Period currpos", "startPlayMilli= "+startPlayMilli) ;
    playUpdatePeriodAmass = 0 ;
    rr = audioTrack.getPlaybackHeadPosition();
    Log.v(TAG+" Period", "getPlaybackHeadPosition return "+rr) ;
    
       while( audioPlayContinue )
        {
         //Log.v(TAG+"-ENC","In run AudioRecThread.encodeContinue="+audioRecContinue ) ;
         try
         {
           int read = fi.read ( bufRead, 0 , bufReadLenInByte)  ;
           if( read > 0  ) {
           Log.v(TAG+" write", "before write to AudioTrack" )  ;
           read = audioTrack.write((byte[]) bufRead , 0, read ) ;
           Log.v(TAG+" write","after write to AudioTrack, write " + read + " bytes" )  ;
           if( datalength == 0 ) {
            try {
             Log.v(TAG+" Period currpos", "startPlay : "+System.currentTimeMillis()) ;
             audioTrack.play()  ;
             bufReadLenInByte /= 10 ;
            } catch( IllegalStateException  e ) {

            }     
           }
           datalength += read ;
          }else {
           break;
          }          
         }
         catch (IOException e)
         {
          
         }
     
         long cu = System.currentTimeMillis() ;
         long cu1 = cu-startPlayMilli ;
         long cu2 = cu - timeMarkAttendModified ;
      rr = audioTrack.getPlaybackHeadPosition();
      Log.v(TAG+" Period currpos", "curr: "+cu1+ " modified mill:"+ cu2 + " pos:" + rr*1000/8000 ) ;
         

        }
        try {
         fi.close() ;
        }
        catch (IOException e)
        {
          
        };
    try {
     Log.v (TAG+" Period" , "dataLength="+datalength );
     audioTrack.flush();
     for( int i = 50 ; i >0 ; i -- ) {
         long cu = System.currentTimeMillis() ;
         long cu1 = cu-startPlayMilli ;
         long cu2 = cu - timeMarkAttendModified ;
      rr = audioTrack.getPlaybackHeadPosition();
      Log.v(TAG+" Period currpos", "curr: "+cu1+ " modified mill:"+ cu2 + " pos:" + rr*1000/8000 ) ;
      
      Thread.sleep(100) ;
     }
     audioTrack.stop()  ;
    } catch( IllegalStateException  e ) {

    }catch ( InterruptedException e) {
     
    }
    audioTrack.release() ;

        wl.release() ;
        handler.sendEmptyMessage( MSG_AUDIO_PLAY_FINISH ) ;
        Log.v(TAG,"AvcThread Finish encoding " ) ;
   }
  } ;  
  startLowPriorityNewThread(audioRecRun);  
 }

 public void stopAudioPlay() {
  audioPlayContinue = false ;
  if( thread != null  ) {
   try {
      thread.join() ;
   }catch( InterruptedException e  ) {
    
   }  
  }

  thread = null; 
  //Log.v(TAG,"in stopAvcEnc AvcThread.encodeContinue="+encodeContinue ) ;
 }

 
 private void startLowPriorityNewThread(Runnable run) {
  thread = new Thread( run ) ;
  int pr = thread.getPriority() ;
  Log.v( TAG, "Original Thread priority is " + pr ) ;
  thread.setPriority( pr - 1 ) ;
  pr = thread.getPriority() ;
  Log.v( TAG, "new Thread priority is " + pr ) ;
  thread.start();  
 }
 
 
 
}

yuanyuan_186
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
使用 AudioRecord 录制 PCM、WAV 文件，AudioTrack 播放 PCM 文件
我的学习笔记
07-15 2104
音频采集： private class AudioRecorder { private ExecutorService mExecutor = Executors.newCachedThreadPool(); private AudioRecord mAudioRecord; private int mBufferSize; ...
Android java层的AudioTrack使用总结
最新发布
u011613654的博客
06-10 645
如采样率为 44100 hz，2声道、采样位宽是16位{2字节}，则有一秒钟播放了：44100 * 2 * 2 = 176400 字节。总时长其实很简单：如果你播放的就是.pcm文件，则直接计算文件的总byte大小，然后除以 1秒的播放量就行。按照上面说的，可以使用： 总的播放字节数 / 一秒钟播放的字节数 = 播放了多少秒。奔驰S的大柏林了解一下。如果你播放的不是.pcm文件，而是封装过的音频文件，那么在解封装时，有api获取。总的播放数据量 作为右边值，其声道数 和 采样位宽与左边公式的其实是一致的。
android AudioRecord 与 AudioTrack的录音加回放的使用
dielucui7698的博客
12-04 112
http://stackoverflow.com/questions/32682952/audiotrack-audiotack-not-playing-fully-recorded-audio 转载于:https://www.cnblogs.com/welhzh/p/5019870.html
使用AudioRecord和AudioTrack来录制和播放音频
ShaderJoy 的兴趣技术杂货铺
04-08 4754
1.使用AudioRecord录制原始音频 除了通过意图启动录音机和使用MediaRecorder之外，Android还提供了第三种方法来捕获音频：使用成为AudioRecord的类。AudioRecord是三种方法里最灵活的（因为允许访问原始音频流），但是它拥有的内置功能也是最少的，如不会自动压缩音频。 使用AudioRecord的基础知识非常简单。我们只需要构造一个AudioRecord类
Android Native C++ 层中使用AudioRecord录制PCM音频
Romantic_Energy的专栏
01-15 8058
Android应用程序很少会用到Android Native C++ 层中AudioRecord来录制PCM，但也不是完全没有需求，至少这么做可以在不懂C++的程序员面前装装逼！ 直接在Native C++层录制和处理PCM数据可以避免数据拷贝到虚拟机，再由虚拟机拷回到Native C++层；虽然这个消耗笔者认为应该不大，但是没有具体分析过虚拟机，不清楚，有知道的朋友请告诉一下。     本文
Android 使用 AudioRecord 和 AudioTrack 完成音频PCM数据的采集和播放，并读写音频wav文件。
07-28
Android 使用 AudioRecord 和 AudioTrack 完成音频PCM数据的采集和播放，并读写音频wav文件。 封装好的Java代码，可同时录制PCM和WAV文件。自己定义存储位置。 Android提供了AudioRecord和MediaRecord。MediaRecord...
android使用audioRecord和audioTrack实现语音录音播放与即时播放
01-19
接下来，我们将深入探讨如何使用`AudioRecord`和`AudioTrack`来实现语音录音和即时播放。 **一、AudioRecord：录音** `AudioRecord`类用于从设备的麦克风捕捉音频数据。首先，我们需要初始化一个`AudioRecord`实例...
android 使用 audiotrack和audiorecord c++代码
12-23
它们分别用于播放和录制音频数据，是Android系统原生提供的Java接口。当需要在C++层处理音频时，可以借助JNI（Java Native Interface）进行底层操作。本篇文章将深入探讨`AudioTrack`、`AudioRecord`以及如何在JNI中...
Android AudioRecord 和 AudioTrack 使用例程
09-26
通过分析`MyRecorder`的代码，你可以更深入地了解如何将AudioRecord和AudioTrack结合使用，以实现完整的音频录制和回放功能。 为了进一步增强音频处理能力，开发者还可以探索其他API，如AudioEffect（用于音频特效...
AudioRecord和AudioTrack
01-27
在Android平台上，AudioRecord和AudioTrack是两个非常重要的音频处理类，它们分别用于音频的录制和播放。在本文中，我们将深入探讨这两个类的工作原理、使用方法以及如何结合它们实现一个简单的音频处理流程。 首先...
Android C++ 录制 Audio PCM 文件
素炒瓢儿白的CSDN博客
02-17 571
一般的录制 PCM 文件，可以简单的修改 tinycap 的代码，将 tinycap 打包 wav 的地方去掉，直接就可以录制 PCM 文件了（原理是 WAV = 头部+PCM 数据）。也可以使用 Android C++ 的 AudioSource 类来进行录制。代码非常简单，如下： #include <binder/ProcessState.h> #include <media...
java audiotrack_java – 如何告诉AudioTrack对象何时完成播放？
weixin_35327612的博客
02-13 428
我发现使用audioTrack.setNotificationMarkerPosition(audioLength)和audioTrack.setPlaybackPositionUpdateListener对我有用.请参阅以下代码：// Get the length of the audio stored in the file (16 bit so 2 bytes per short)// an...
Android多媒体开发（5）————利用Android AudioTrack播放mp3文件
yuanyuan_186的专栏
04-25 649
 http://blog.csdn.net/conowen/article/details/7799155/ /********************************************************************************************  * author：conowen@大钟                          
AudioRecord 录音和播放的Demo
wenzhi的博客
03-24 3467
#AudioRecord 录音和播放的Demo 本文介绍一个AudioRecord的简单录音和播放的示例程序。 录音是需要动态获取权限的！ ##主要代码 ###1.AudioRecord录音代码 //开通输出流到指定的文件,audioFile是保存的音频文件File对象 DataOutputStream dos = new DataOutputStream(new BufferedOutputSt...
Android音视频开发入门（三）
Lewis的专栏
01-25 1741
任务目标 用AudioRecord采集PCM数据到SDCard,并用AudioTrack播放采集的PCM数据，最后实现读写wav文件。 AudioRecord采集PCM数据 AudioRecord可以记录从硬件设备输入的音频，生成PCM格式的音频数据。有三个读取数据的方法可以选择read(byte[], int, int)， read(short[], int, int) 或 read(ByteB...
FFmpeg_Android音频播放demo--audioTrack方式
分享音视频技术
06-10 945
在之前的文章中，我们有讲解了FFmpeg的音频的解码流程，本文于此基础上，讲解在Android平台上对mp3文件进行解码并播放。本文例子使用AudioTrack来对音频解码后的数据进行播放。
android11 stagefright AudioPlayer 播放音频流程解析
我的博客
02-06 396
android11 stagefright AudioPlayer 解析
Android AudioTrack实时播放
xdy1120的博客
08-08 1205
选择AudioRecord进行录后，实时播放也只能采用AudioTrack进行播放。 public class AudioTrackManager { public static final String TAG = "AudioTrackManager"; private AudioTrack audioTrack; private DataInputStream dis...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值