问题
I have been following this tutorial on using LAME mp3 on Android with jni. Recording seems to be working and I am getting an output as mp3 but upon playback the audio has been slowed down and pitched down.
I've tried to put all pertinent code below. Any guidance on why this is happening? Thanks in advance for your help.
Edit: OK so just to check I imported the raw data into Audacity and that plays back fine so this must be an issue at the encoding stage.
Java class:
public class Record extends Activity implements OnClickListener {
static {
System.loadLibrary("mp3lame");
}
private native void initEncoder(int numChannels, int sampleRate, int bitRate, int mode, int quality);
private native void destroyEncoder();
private native int encodeFile(String sourcePath, String targetPath);
private static final int RECORDER_BPP = 16;
private static final String AUDIO_RECORDER_FILE_EXT_WAV = ".wav";
private static final String AUDIO_RECORDER_FOLDER = "AberdeenSoundsites";
private static final String AUDIO_RECORDER_TEMP_FILE = "record_temp.raw";
private static final int[] RECORDER_SAMPLERATES = {44100, 22050, 11025, 8000};
private static final int RECORDER_CHANNELS = AudioFormat.CHANNEL_IN_STEREO;
private static final int RECORDER_AUDIO_ENCODING = AudioFormat.ENCODING_PCM_16BIT;
public static final int NUM_CHANNELS = 2;
public static final int SAMPLE_RATE = 44100;
public static final int BITRATE = 320;
public static final int MODE = 1;
public static final int QUALITY = 2;
private short[] mBuffer;
private File rawFile;
private File encodedFile;
private int sampleRate;
private String filename;
private AudioRecord recorder = null;
private int bufferSize = 0;
private Thread recordingThread = null;
private boolean isRecording = false;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.record);
initEncoder(NUM_CHANNELS, SAMPLE_RATE, BITRATE, MODE, QUALITY);
stopButton = (Button) findViewById(R.id.stop_button);
stopButton.setOnClickListener(this);
timer = (TextView) findViewById(R.id.recording_time);
bufferSize = AudioRecord.getMinBufferSize(44100, RECORDER_CHANNELS, RECORDER_AUDIO_ENCODING);
}
private void startRecording() {
stopped = false;
stopButton.setText(R.string.stop_button_label);
// Set up and start audio recording
recorder = findAudioRecord();
recorder.startRecording();
isRecording = true;
rawFile = getFile("raw");
mBuffer = new short[bufferSize];
startBufferedWrite(rawFile);
}
private void stopRecording() {
mHandler.removeCallbacks(startTimer);
stopped = true;
if(recorder != null){
isRecording = false;
recorder.stop();
recorder.release();
recorder = null;
recordingThread = null;
}
encodedFile = getFile("mp3");
int result = encodeFile(rawFile.getAbsolutePath(), encodedFile.getAbsolutePath());
if (result == 0) {
Toast.makeText(Record.this, "Encoded to " + encodedFile.getName(), Toast.LENGTH_SHORT)
.show();
}
}
private void startBufferedWrite(final File file) {
new Thread(new Runnable() {
@Override
public void run() {
Looper.prepare();
DataOutputStream output = null;
try {
output = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(file)));
while (isRecording) {
int readSize = recorder.read(mBuffer, 0, mBuffer.length);
for (int i = 0; i < readSize; i++) {
output.writeShort(mBuffer[i]);
}
}
} catch (IOException e) {
Toast.makeText(Record.this, e.getMessage(), Toast.LENGTH_SHORT).show();
} finally {
if (output != null) {
try {
output.flush();
} catch (IOException e) {
Toast.makeText(Record.this, e.getMessage(), Toast.LENGTH_SHORT).show();
} finally {
try {
output.close();
} catch (IOException e) {
Toast.makeText(Record.this, e.getMessage(), Toast.LENGTH_SHORT).show();
}
}
}
}
}
}).start();
}
private File getFile(final String suffix) {
Time time = new Time();
time.setToNow();
return new File(Environment.getExternalStorageDirectory()+"/MyAppFolder", time.format("%Y%m%d%H%M%S") + "." + suffix);
}
public AudioRecord findAudioRecord() {
for (int rate : RECORDER_SAMPLERATES) {
for (short audioFormat : new short[] { AudioFormat.ENCODING_PCM_16BIT, AudioFormat.ENCODING_PCM_8BIT }) {
for (short channelConfig : new short[] { AudioFormat.CHANNEL_IN_STEREO, AudioFormat.CHANNEL_IN_MONO }) {
try {
Log.d("AberdeenSoundsites", "Attempting rate " + rate + "Hz, bits: " + audioFormat + ", channel: "
+ channelConfig);
int bufferSize = AudioRecord.getMinBufferSize(rate, channelConfig, audioFormat);
if (bufferSize != AudioRecord.ERROR_BAD_VALUE) {
// check if we can instantiate and have a success
AudioRecord recorder = new AudioRecord(MediaRecorder.AudioSource.MIC, rate, channelConfig, audioFormat, bufferSize);
sampleRate = rate;
if (recorder.getState() == AudioRecord.STATE_INITIALIZED)
return recorder;
}
} catch (Exception e) {
Log.e("MyApp", rate + "Exception, keep trying.",e);
}
}
}
}
Log.e("MyApp", "No settings worked :(");
return null;
}
C wrapper:
#include <stdio.h>
#include <stdlib.h>
#include <jni.h>
#include <android/log.h>
#include "libmp3lame/lame.h"
#define LOG_TAG "LAME ENCODER"
#define LOGD(format, args...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, format, ##args);
#define BUFFER_SIZE 8192
#define be_short(s) ((short) ((unsigned short) (s) << 8) | ((unsigned short) (s) >> 8))
lame_t lame;
int read_samples(FILE *input_file, short *input) {
int nb_read;
nb_read = fread(input, 1, sizeof(short), input_file) / sizeof(short);
int i = 0;
while (i < nb_read) {
input[i] = be_short(input[i]);
i++;
}
return nb_read;
}
void Java_myPacakage_myApp_Record_initEncoder(JNIEnv *env,
jobject jobj, jint in_num_channels, jint in_samplerate, jint in_brate,
jint in_mode, jint in_quality) {
lame = lame_init();
LOGD("Init parameters:");
lame_set_num_channels(lame, in_num_channels);
LOGD("Number of channels: %d", in_num_channels);
lame_set_in_samplerate(lame, in_samplerate);
LOGD("Sample rate: %d", in_samplerate);
lame_set_brate(lame, in_brate);
LOGD("Bitrate: %d", in_brate);
lame_set_mode(lame, in_mode);
LOGD("Mode: %d", in_mode);
lame_set_quality(lame, in_quality);
LOGD("Quality: %d", in_quality);
int res = lame_init_params(lame);
LOGD("Init returned: %d", res);
}
void Java_myPacakage_myApp_Record_destroyEncoder(
JNIEnv *env, jobject jobj) {
int res = lame_close(lame);
LOGD("Deinit returned: %d", res);
}
void Java_myPacakage_myApp_Record_encodeFile(JNIEnv *env,
jobject jobj, jstring in_source_path, jstring in_target_path) {
const char *source_path, *target_path;
source_path = (*env)->GetStringUTFChars(env, in_source_path, NULL);
target_path = (*env)->GetStringUTFChars(env, in_target_path, NULL);
FILE *input_file, *output_file;
input_file = fopen(source_path, "rb");
output_file = fopen(target_path, "wb");
short input[BUFFER_SIZE];
char output[BUFFER_SIZE];
int nb_read = 0;
int nb_write = 0;
int nb_total = 0;
LOGD("Encoding started");
while (nb_read = read_samples(input_file, input)) {
nb_write = lame_encode_buffer(lame, input, input, nb_read, output,
BUFFER_SIZE);
fwrite(output, nb_write, 1, output_file);
nb_total += nb_write;
}
LOGD("Encoded %d bytes", nb_total);
nb_write = lame_encode_flush(lame, output, BUFFER_SIZE);
fwrite(output, nb_write, 1, output_file);
LOGD("Flushed %d bytes", nb_write);
fclose(input_file);
fclose(output_file);
}
Edit - ok so out of interest I downloaded the apk the tutorial provides to my phone and ran it. That works fine. So this would suggest the problem is less with the tutorial and more something I've done. I will re-look over this when I have some time available and see if I can determine where I went wrong
回答1:
You call initEncoder with 2 channels, and initialize AudioRecord with STEREO and MONO, but wrapper.c can only deal with 1 channel:
nb_write = lame_encode_buffer(lame, input, input, nb_read, output, BUFFER_SIZE);
The above codes require that the source audio is mono with 1 channel. If you want to support STEREO, pay attention to lame_encode_buffer method
int CDECL lame_encode_buffer (
lame_global_flags* gfp, /* global context handle */
const short int buffer_l [], /* PCM data for left channel */
const short int buffer_r [], /* PCM data for right channel */
const int nsamples, /* number of samples per channel */
unsigned char* mp3buf, /* pointer to encoded MP3 stream */
const int mp3buf_size ); /* number of valid octets in this
stream */
回答2:
To give you a pointer, you need to invoke lame_encode_buffer_interleaved() if you use 2 channels (.stereo) to record.
It took me a few days to figure it out, this is the code you can use:
if (lame_get_num_channels(glf) == 2)
{
result = lame_encode_buffer_interleaved(glf, j_buffer_l, samples/2, j_mp3buf, mp3buf_size);
}
else
{
result = lame_encode_buffer(glf, j_buffer_l, j_buffer_r, samples, j_mp3buf, mp3buf_size);
}
回答3:
You stimulated me to look at my problem again and I found the problem for me. Maybe it is what is happening for you. Check the sample rate of the wav file you were using. I assumed or looked at mine too quickly and thought it said 44100; but it was 48000! I fixed my problem with:
lame_set_in_samplerate(lame, 48000);
lame_set_out_samplerate(lame, 44100);
Perhaps your code isn't reading the correct in sample rate for some odd reason?
回答4:
You can rewrite
nb_write = lame_encode_buffer(lame, input, input, nb_read, output, BUFFER_SIZE);
to
nb_write = lame_encode_buffer(lame, input1, input2, nb_read, output, BUFFER_SIZE);
and use 2 mono raw files as an input. Of course you will have to adapt your encodeFile - function so that it takes two strings as source and handles everything twice.
来源：https://stackoverflow.com/questions/16084882/lame-encoded-mp3-audio-slowed-down-android