Unable to play recorded raw PCM from file - android

I have saved recorded audio raw PCM into a file rxrawpcm.pcm, after that i tried to play the pcm file but unable to play recorded PCM? I didn't hear recorded voice hearing only a buzzy sound
Configuration
AudioRecorder and AudioTrack configuration
Stream Type :STREAM_VOICE_CALL
Sample Rate : 8000
Audio Format :PCM_16BIT
MODE :MODE_STREAM
Channel Config :CHANNEL_CONFIGURATION_MONO
Recording
byte[] buffer=new byte[1600];
int read = audioRecord.read(buffer, 0,buffer.length);
if(recordAudio){
if(out!=null){
out.write(buffer);
}
Player Side
FileInputStream fis=new FileInputStream(rxFile);
byte[] buffer=new byte[1600];
while(fis.read(buffer)!=-1){
audioPlayer.write(buffer, 0, buffer.length);
}


Your buffer size may be too small. You are supposed to use the getMinBufferSize method to determine the smallest buffer size that doesn't result in buffer overflows. The top voted answer in this question Android AudioRecord class - process live mic audio quickly, set up callback function demonstrates how to properly setup audio recording with an appropriate buffer size.

Related

Using AudioTrack to play base64 encoded audio String (converted to byte array) just produces white noise

I am trying to playback base64 encoded .wav audio data on Android, via AudioTrack, and all I'm getting is a very short burst of white noise.
I presume it's in .wav format anyway - it was recorded via JavaScript using my Mac's built-in microphone and converted to base64.
I've possibly set the variables wrong when creating the AudioTrack (bit of guesswork involved there) - I've guessed at the sample rate and encoding, and put the buffer size as that of the entire chunk of data. Very grateful for any assistance.
playChannelAudio("data:application/octet-stream;base64,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");
private void playChannelAudio(String base64FormattedString) {
String strippedAudioData = base64FormattedString.substring(base64FormattedString.indexOf(',') + 1);
byte[] data = Base64.decode(strippedAudioData, Base64.DEFAULT);
AudioTrack audioTrack = new AudioTrack(
AudioManager.STREAM_MUSIC, 44100,
AudioFormat.CHANNEL_CONFIGURATION_MONO,
AudioFormat.ENCODING_PCM_16BIT,
data.length,
AudioTrack.MODE_STATIC);
audioTrack.write(data, 0, data.length);
audioTrack.play();
audioTrack.release();
}

Your audio data is encoded with Opus codec with a sample rate of 48000 Hz (detected by FFmpeg). You have given wrong sample rate as a parameter to the AudioTrack constructor (given 44100 but it's 48000) and also it's encoded with a codec, and AudioTrack expects raw/decoded PCM audio so it could be the reason for the white noise you are hearing. In order to play the audio correctly, first convert it to raw PCM audio data then encode it with Base64.

How do I playback an audio stream (not by URL)?

Say, I have an InputStream, providing audio/mpeg (or audio/aacp) - a Shoutcast radio.
Could somebody please show me a code example to playback such a stream?
I searched all over the internet, and it looks like the android.media.MediaPlayer can't playback a buffered stream. It can playback streams only via HTTP URL as DataSource.
Yes, there is a possibility to implement your own android.media.MediaDataSource and feed it to MediaPlayer.setDataSource(), but in case of audio/aacp the codec could not initialize.
Guess this could be done with OpenSL ES, but still I haven't found any example which would perform decoding from InputStream (not from URL), and then play back the output..
Come on guys! Any sample snippet in OpenSL ES decoding an input byte array and sending it to the audio output. Please!
Only one condition - input audio format should be obtained from the input stream.
The only one manual I found on OpenSL ES is Khronos OpenSL ES™ Registry, but that is not a reading for beginners at all. I'd rather die there searching for a proper "how-to" example... :(
Why is it so weird - it's very simple /though inconvenient/ (java), or it's very hard (NDK)? Why is there nothing in the middle?

your solution is something like this:
public void run() {
int buffersize = AudioRecord.getMinBufferSize(11025, AudioFormat.CHANNEL_CONFIGURATION_MONO, AudioFormat.ENCODING_PCM_16BIT);
AudioTrack atrack = new AudioTrack(AudioManager.STREAM_MUSIC, 11025, AudioFormat.CHANNEL_CONFIGURATION_MONO, AudioFormat.ENCODING_PCM_16BIT, buffersize, AudioTrack.MODE_STREAM);
atrack.setPlaybackRate(11025);
byte[] buffer = new byte[buffersize];
atrack.play();
while (isPlaying) {
yourStream.read(buffer, 0, buffersize);
atrack.write(buffer, 0, buffer.length);
}
}

Decoding audio with Jspeex in android produces choppy/clipped sound

i am developing an android app, which plays live speex audio stream. So i used jspeex library .
The audio stream is 11khz,16 bit.
At android side i have done as follows:
SpeexDecoder decoder = new SpeexDecoder();
decoder.init(1, 11025,1, true);
decoder.processData(subdata, 0, subdata.length);
byte[] decoded_data = new byte[decoder.getProcessedDataByteSize()];
int result= decoder.getProcessedData(decoded_data, 0);
When this decoded data is played by Audiotrack , some part of audio is clipped.
Also when decoder is set to nb-mode( first parameter set to 0) the sound quality is worse.
I wonder there is any parameter configuration mistake in my code.
Any help, advice appreciated.
Thanks in advance.

Sampling rate and buffer size should be set in an optimized way for the specific device. For example you can use AudioRecord.getMinBufferSize() to obtain the best size for your buffer:
int sampleRate = 11025; //try also different standard sampleRate
int bufferSize = AudioRecord.getMinBufferSize(sampleRate,
AudioFormat.CHANNEL_CONFIGURATION_MONO,
AudioFormat.ENCODING_PCM_16BIT);
If your Audiotrack has a buffer which is too small or too large you will experience audio glitch. I suggest you to take a look here and play around with these values (sampleRate and bufferSize).

Playing mp3 data compressed by lame mp3 with JLayer and Audiotrack in android

I have followed this example to convert raw audio data coming from AudioRecord to mp3, and it happened successfully, if I store this data in a file the mp3 file and play with music player then it is audible.
Now my question is instead of storing mp3 data to a file i need to play it with AudioTrack, the data is coming from the Red5 media server as live stream, but the problem is AudioTrack can only play PCM data, so i can only hear noise from my data.
Now i am using JLayer to my require task.
My code is as follows.
int readresult = recorder.read(audioData, 0, recorderBufSize);
int encResult = SimpleLame.encode(audioData,audioData, readresult, mp3buffer);
and this mp3buffer data is sent to other user by Red5 stream.
data received at other user is in form of stream, so for playing it the code is
Bitstream bitstream = new Bitstream(data.read());
Decoder decoder = new Decoder();
Header frameHeader = bitstream.readFrame();
SampleBuffer output = (SampleBuffer) decoder.decodeFrame(frameHeader, bitstream);
short[] pcm = output.getBuffer();
player.write(pcm, 0, pcm.length);
But my code freezes at bitstream.readFrame after 2-3 seconds, also no sound is produced before that.
Any guess what will be the problem? Any suggestion is appreciated.
Note: I don't need to store the mp3 data, so i cant use MediaPlayer, as it requires a file or filedescriptor.

just a tip, but try to
output.close();
bitstream.closeFrame();
after yours write code. I'm processing MP3 same as you do, but I'm closing buffers after usage and I have no problem.
Second tip - do it in Thread or any other Background process. As you mentioned these deaf 2 seconds, media player may wait until you process whole stream because you are loading it in same thread.
Try both tips (and you should anyway). In first, problem could be in internal buffers; In second you probably fulfill Media's input buffer and you locked app (same thread, full buffer cannot receive your input and code to play it and release same buffer is not invoked because writing locks it...)
Also, if you don't doing it now, check for 'frameHeader == null' due to file end.
Good luck.

You need to loop through the frames like this:
While (frameHeader = bitstream.readFrame()){
SampleBuffer output = (SampleBuffer) decoder.decodeFrame(frameHeader, bitstream);
short[] pcm = output.getBuffer();
player.write(pcm, 0, pcm.length);
bitstream.close();
}
And make sure you are not running them on main thread.(This is probably the reason of freezing.)

Android, maximum buffer size

I capture sound in real time to buffer and then I process these data. But sometimes I get warning: buffer overflow what cause of problem in the processing.
I created AudioRecord:
bufferSize = ???;
recorder = new AudioRecord(MediaRecorder.AudioSource.MIC,
RECORDER_SAMPLERATE, RECORDER_CHANNELS,
RECORDER_AUDIO_ENCODING, **bufferSize**);
but there are not method for getMaximumBufferSize or semthing like that (only getMinBufferSize - but here is buffer owerflow). And I think that setting own buffer size is not good solution.

According to the API:
Upon creation, an AudioRecord object initializes its associated audio buffer that it will fill with the new audio data. The size of this buffer, specified during the construction, determines how long an AudioRecord can record before "over-running" data that has not been read yet. Data should be read from the audio hardware in chunks of sizes inferior to the total recording buffer size.
Your buffer should be large enough for the amount of buffered data you want to support, ie bitrate*time, and you need to make sure that you are reading from the AudioRecord consistently so that it does not fill the buffer, and that the size of the chunks that you read are smaller than the buffer size in the AudioRecorder. I like to read/write in 8k chunks but have seen other values too.

Categories

Resources