Lame encoded mp3 audio slowed down - Android

Question

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

Off the top of my head that sounds like a sampling rate issue between what you're recording it with, and what you're using to play the audio back — Matt Taylor, Apr 18 '13 at 14:25
When you record you're trying lots of different configurations until you find one that works, but when you initialize LAME you're assuming 44.1 kHz stereo. Have you verified that the recording actually is 44.1 kHz stereo (even if it is, you should probably fix your `initEncoder` call so that is uses the actual config). — Michael, Apr 18 '13 at 14:29
Thats true @Michael though I know from log that the recorder is 44.1khz I do need to fix that though. But not sure that will help my current problem — Henry Ing-Simmons, Apr 18 '13 at 14:43
@Michael I have altered my code so the encoded is initialised with the same settings as the recorder still have the same problem. I don't suppose you have any other ideas? — Henry Ing-Simmons, Apr 28 '13 at 17:04
Did you do this when compiling the library?: from the Samsung webpage- "Some preparations are to be made yet. Since the standard compilation method with autoconf will not be used, some changes in header files need to be performed. First of all edit util.h and replace line: extern ieee754_float32_t fast_log2(ieee754_float32_t x); with used architecture 32-bit float implementation, which is simply float: extern float fast_log2(float x);." Because I'm having the same issue on BlackBerry 10 and wondering if it could be the library's compilation as the problem. — Dave, May 02 '13 at 20:29
@Dave yes I did make that change. As far as I know I followed the tutorial to the letter so either I've made a mistake somewhere or the tutorial is flawed — Henry Ing-Simmons, May 06 '13 at 08:31

score 3 · Answer 1 · edited Oct 12 '14 at 00:24

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);
}

score 3 · Answer 2 · answered May 21 '14 at 02:22

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                        */

Thanks. I need to get round to trying a few of these things out. — Henry Ing-Simmons, May 21 '14 at 09:14

score 1 · Answer 3 · answered May 06 '13 at 13:55

1

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?

answered May 06 '13 at 13:55

Dave

477
2
5
18

This fixed my problem with lame.all.js when converting from mic input, had to set sample rate to 48000 irrespective of mic sample rate. – timmacp Apr 17 '16 at 15:14

score 0 · Answer 4 · answered May 06 '16 at 16:58

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.

Lame encoded mp3 audio slowed down - Android

4 Answers4

Linked