Preface- Android Audio Collection
- There are generally two ways to collect audio in Android:
- AudioRecord and MediaRecorder can both record audio. MediaRecorder has implemented a lot of encapsulation and is easier to operate, while AudioRecord is more flexible to use and can achieve more functions.
1. Android audio acquisition 1. Audio Record- Based on byte stream recording;
- It can realize real-time voice processing, record and play simultaneously, and process audio in real time;
- AudioRecord is a low-level API that can get PCM data frame by frame and then process the data.
- The output is PCM voice data. If it is saved as an audio file, it cannot be played by the player. AudioTrack is needed to process it.
2.MediaRecorder- Based on file recording;
- MediaRecorder is an API based on AudioRecorder (eventually, AudioRecord will be created to interact with AudioFlinger). It can directly convert the collected audio data into the executable encoding format and save it;
- It has integrated recording, encoding, compression, etc. and supports a small number of audio format files;
- High degree of packaging and simple operation;
2. MediaRecorder Implementation MediaRecorder (note that both recording and playback are time-consuming operations and need to be performed in a non-main thread). The main code for recording: private boolean start ( ) {
try {
// Create MediaRecorder
mMediaRecorder = new MediaRecorder ( ) ;
// Create a recording file
mRecorderFile = new File ( Environment .getExternalStorageDirectory ( ) .getAbsolutePath ( )
+ "/recorderdemo/" + System .currentTimeMillis ( ) + ".m4a" ) ;
if ( ! mRecorderFile .getParentFile ( ) .exists ( ) ) mRecorderFile .getParentFile ( ) .mkdirs ( ) ;
mRecorderFile .createNewFile ( ) ;
// Configure MediaRecorder
// Collect from microphone
mMediaRecorder .setAudioSource ( MediaRecorder .AudioSource .MIC ) ;
// Save the file in MP4 format
mMediaRecorder .setOutputFormat ( MediaRecorder .OutputFormat .MPEG_4 ) ;
// Moderate sampling frequency supported by all Android systems
mMediaRecorder .setAudioSamplingRate ( 44100 ) ;
// Universal AAC encoding format
mMediaRecorder .setAudioEncoder ( MediaRecorder .AudioEncoder .AAC ) ;
// Set the sound quality frequency
mMediaRecorder .setAudioEncodingBitRate ( 96000 ) ;
// Set the location of the file recording
mMediaRecorder .setOutputFile ( mRecorderFile .getAbsolutePath ( ) ) ;
// Start recording
mMediaRecorder .prepare ( ) ;
mMediaRecorder .start ( ) ;
startRecorderTime = System .currentTimeMillis ( ) ;
} catch ( Exception e ) {
Toast .makeText ( FileActivity .this , "Recording failed, please try again" , Toast .LENGTH_SHORT ) .show ( ) ;
return false ;
}
// Record the start time of recording, used to count the duration. If it is less than 3 seconds, the recording will not be sent
return true ;
} 2. AudioRecord Audio Collection 1. Parameter introduction- Basic parameters of AudioRecord;
- audioResource: the source of audio collection;
- audioSampleRate: audio sampling rate;
- channelConfig: channel;
- audioFormat: audio sampling accuracy, specifies the format of the sampled data and the size of each sample;
- bufferSizeInBytes: The size of the buffer where the audio data collected by AudioRecord is stored;
// Specify the audio source. This is the same as MediaRecorder.MediaRecorder.AudioSource.MIC refers to the microphone .
private static final int mAudioSource = MediaRecorder .AudioSource .MIC ;
// Specify the sampling rate (MediaRecoder's sampling rate is usually 8000Hz and AAC's is usually 44100Hz. Set the sampling rate to 44100, which is currently the commonly used sampling rate. The official documentation indicates that this value is compatible with all settings)
private static final int mSampleRateInHz = 44100 ;
// Specify the number of channels to capture audio. Specify the constants used for this in the AudioFormat class
private static final int mChannelConfig = AudioFormat .CHANNEL_CONFIGURATION_MONO ; // Mono
// Specify the number of bits for audio quantization . The following possible constants are specified in the AudioFormaat class. Usually we choose ENCODING_PCM_16BIT and ENCODING_PCM_8BIT PCM stands for Pulse Code Modulation, which is actually the raw audio sample.
// Therefore, you can set the resolution of each sample to 16 bits or 8 bits. 16 bits will take up more space and processing power , and the audio represented will be closer to reality.
private static final int mAudioFormat = AudioFormat .ENCODING_PCM_16BIT ;
// Specify the buffer size. You can get it by calling the getMinBufferSize method of the AudioRecord class.
private int mBufferSizeInBytes = AudioRecord .getMinBufferSize ( mSampleRateInHz , mChannelConfig , mAudioFormat ) ; // Calculate the minimum buffer
// Create an AudioRecord. The AudioRecord class does not actually save the captured audio, so you need to manually create the file and save it for download.
private AudioRecord mAudioRecord = new AudioRecord ( MediaRecorder .AudioSource .MIC , mSampleRateInHz , mChannelConfig ,
mAudioFormat , mBufferSizeInBytes ) ; // Create AudioRecorder object 2. Audio Collection Add permissions < uses - permission android : name = "android.permission.RECORD_AUDIO" />
< uses - permission android : name = "android.permission.WRITE_EXTERNAL_STORAGE" /> - Collection process
- Constructs an AudioRecord object.
- Start collecting;
- Read the collected data;
- Stop collecting;
The collection code is as follows: import android .media .AudioFormat ;
import android .media .AudioRecord ;
import android .media .MediaRecorder ;
import android .os .Environment ;
import android .os .Bundle ;
import android .util .Log ;
import android .view .View ;
import android .widget .Button ;
import java .io .BufferedOutputStream ;
import java .io .DataOutputStream ;
import java .io .File ;
import java .io .FileOutputStream ;
import java .io .IOException ;
public class AudioRecordTest extends AppCompatActivity implements Runnable {
private Button mBtnStartRecord , mBtnStopRecord ;
// Specify the audio source. This is the same as MediaRecorder.MediaRecorder.AudioSource.MIC refers to the microphone .
private static final int mAudioSource = MediaRecorder .AudioSource .MIC ;
// Specify the sampling rate (MediaRecoder's sampling rate is usually 8000Hz and AAC's is usually 44100Hz. Set the sampling rate to 44100, which is currently the commonly used sampling rate. The official documentation indicates that this value is compatible with all settings)
private static final int mSampleRateInHz = 44100 ;
// Specify the number of channels to capture audio. Specify the constants used for this in the AudioFormat class
private static final int mChannelConfig = AudioFormat .CHANNEL_CONFIGURATION_MONO ; // Mono
// Specify the number of bits for audio quantization . The following possible constants are specified in the AudioFormaat class. Usually we choose ENCODING_PCM_16BIT and ENCODING_PCM_8BIT PCM stands for Pulse Code Modulation, which is actually the raw audio sample.
// Therefore, you can set the resolution of each sample to 16 bits or 8 bits. 16 bits will take up more space and processing power , and the audio represented will be closer to reality.
private static final int mAudioFormat = AudioFormat .ENCODING_PCM_16BIT ;
// Specify the buffer size. You can get it by calling the getMinBufferSize method of the AudioRecord class.
private int mBufferSizeInBytes ;
private File mRecordingFile ; // Store the file recorded by AudioRecord
private boolean isRecording = false ; // true means recording is in progress
private AudioRecord mAudioRecord = null ;
private File mFileRoot = null ; // File directory
// Stored directory path name
private static final String mPathName = getFilesDir ( ) + "/audiioRecordtest" ;
// The name of the saved audio file
private static final String mFileName = "audiorecordtest.pcm" ;
// The data in the buffer is written to the data. Because IO operations are required, the process of reading data should be executed in the child thread.
private Thread mThread ;
private DataOutputStream mDataOutputStream ;
@Override
protected void onCreate ( Bundle savedInstanceState ) {
super .onCreate ( savedInstanceState ) ;
setContentView ( R .layout .activity_audio_record ) ;
initDatas ( ) ;
initUI ( ) ;
}
// Initialize data
private void initDatas ( ) {
mBufferSizeInBytes = AudioRecord.getMinBufferSize ( mSampleRateInHz , mChannelConfig , mAudioFormat ) ; // Calculate the minimum buffer
mAudioRecord = new AudioRecord ( mAudioSource , mSampleRateInHz , mChannelConfig ,
mAudioFormat , mBufferSizeInBytes ) ; // Create AudioRecorder object
mFileRoot = new File ( mPathName ) ;
if ( ! mFileRoot .exists ( ) )
mFileRoot .mkdirs ( ) ; // Create a folder
}
// Initialize UI
private void initUI ( ) {
mBtnStartRecord = findViewById ( R .id .btn_start_record ) ;
mBtnStopRecord = findViewById ( R .id .btn_stop_record ) ;
mBtnStartRecord .setOnClickListener ( new View .OnClickListener ( ) {
@Override
public void onClick ( View v ) {
startRecord ( ) ;
}
} ) ;
mBtnStopRecord .setOnClickListener ( new View .OnClickListener ( ) {
@Override
public void onClick ( View v ) {
stopRecord ( ) ;
}
} ) ;
}
// Start recording
public void startRecord ( ) {
// Whether the parameter of AudioRecord.getMinBufferSize supports the current hardware device
if ( AudioRecord .ERROR_BAD_VALUE == mBufferSizeInBytes || AudioRecord .ERROR == mBufferSizeInBytes ) {
throw new RuntimeException ( "Unable to getMinBufferSize" ) ;
} else {
destroyThread ( ) ;
isRecording = true ;
if ( mThread == null ) {
mThread = new Thread ( this ) ;
mThread .start ( ) ; // Start thread
}
}
}
private void destroyThread ( ) {
try {
isRecording = false ;
if ( null != mThread && Thread .State .RUNNABLE == mThread .getState ( ) ) {
try {
Thread .sleep ( 500 ) ;
mThread .interrupt ( ) ;
} catch ( Exception e ) {
mThread = null ;
}
}
mThread = null ;
} catch ( Exception e ) {
e .printStackTrace ( ) ;
finally
mThread = null ;
}
}
// Stop recording
public void stopRecord ( ) {
isRecording = false ;
// Stop recording, recycle the AudioRecord object, and release memory
if ( mAudioRecord != null ) {
if ( mAudioRecord .getState ( ) == AudioRecord .STATE_INITIALIZED ) { // Initialization successful
mAudioRecord .stop ( ) ;
}
if ( mAudioRecord != null ) {
mAudioRecord .release ( ) ;
}
}
}
@Override
public void run ( ) {
// Mark as start collection state
isRecording = true ;
// Create a stream to store the data read from AudioRecord
mRecordingFile = new File ( mFileRoot , mFileName ) ;
if ( mRecordingFile .exists ( ) ) { // The audio file has been saved and deleted
mRecordingFile .delete ( ) ;
}
try {
mRecordingFile .createNewFile ( ) ; // Create a new file
} catch ( IOException e ) {
e .printStackTrace ( ) ;
Log .e ( "lu" , "Error creating storage audio file" ) ;
}
try {
// Get the data stream of the file
mDataOutputStream = new DataOutputStream ( new BufferedOutputStream ( new FileOutputStream ( mRecordingFile ) ) ) ;
byte [ ] buffer = new byte [ mBufferSizeInBytes ] ;
// Judge that AudioRecord is not initialized. It is released when recording stops, and the state is STATE_UNINITIALIZED
if ( mAudioRecord .getState ( ) == mAudioRecord .STATE_UNINITIALIZED ) {
initDatas ( ) ;
}
mAudioRecord .startRecording ( ) ; // Start recording
// getRecordingState gets the status of whether the current AudioReroding is collecting data
while ( isRecording && mAudioRecord .getRecordingState ( ) == AudioRecord .RECORDSTATE_RECORDING ) {
int bufferReadResult = mAudioRecord .read ( buffer , 0 , mBufferSizeInBytes ) ;
for ( int i = 0 ; i < bufferReadResult ; i ++ )
{
mDataOutputStream .write ( buffer [ i ] ) ;
}
}
mDataOutputStream .close ( ) ;
} catch ( Throwable t ) {
Log .e ( "lu" , "Recording Failed" ) ;
stopRecord ( ) ;
}
}
@Override
protected void onDestroy ( ) {
super .onDestroy ( ) ;
destroyThread ( ) ;
stopRecord ( ) ;
}
} Summarize AudioRecord is the most flexible way to collect audio, allowing developers to process the collected audio to the maximum extent. At the same time, the audio it captures is in the original audio PCM format! If you need to do voice changing processing, you must use it to collect audio;
|
