Android平台Alize说话人识别：gmm文件生成及3GP格式适配咨询

Hey there! I know you've already dug through all the Alize docs and scoured forums, so let's cut to the chase with practical steps and code for your two main questions.

Generating gmm/world.gmm with Alize on Android #

First off, the world.gmm is a Universal Background Model (UBM)—a generic GMM trained on a large dataset of diverse speakers. Here's how to build it in your Android Studio project:

Core Steps #

1. Prepare Training Data: Gather dozens of diverse speaker audio samples (the more, the better—aim for 50+). Start with WAV files first (we’ll cover 3GP later), as they’re uncompressed and easier to process.
2. Extract MFCC Features: Use Alize’s FeatureExtractor to convert raw audio into Mel-Frequency Cepstral Coefficients (MFCCs)—the standard feature set for speaker recognition.
3. Train the UBM: Feed the extracted features into Alize’s UBMTrainer to build the GMM, then save it as world.gmm.

Code Snippets #

JNI Layer (C++ for Alize Processing)

Assuming you’ve wrapped Alize in a JNI library, here’s how to handle training:

#include "Alize.h"
using namespace alize;

extern "C" JNIEXPORT jstring JNICALL
Java_com_yourpackage_AlizeHelper_trainWorldGMM(JNIEnv* env, jobject thiz, jstring trainingAudioDir) {
    try {
        const char* dirPath = env->GetStringUTFChars(trainingAudioDir, nullptr);
        Config config;
        
        // Configure MFCC parameters (adjust based on your needs)
        config.setParam("featureServer.mfcc.cepstralCoefficientsCount", 12);
        config.setParam("featureServer.mfcc.energy", true);
        config.setParam("featureServer.mfcc.frameLength", 256);
        config.setParam("featureServer.mfcc.frameShift", 100);
        config.setParam("featureServer.mfcc.sampleRate", 16000);

        FeatureExtractor fe(config);
        std::vector<Feature> allFeatures;

        // Traverse training directory and load WAV files
        DIR* dir = opendir(dirPath);
        struct dirent* entry;
        while ((entry = readdir(dir)) != nullptr) {
            std::string fileName = entry->d_name;
            if (fileName.substr(fileName.find_last_of(".") + 1) == "wav") {
                std::string filePath = std::string(dirPath) + "/" + fileName;
                Feature speakerFeatures = fe.loadFeature(filePath);
                allFeatures.push_back(speakerFeatures);
            }
        }
        closedir(dir);

        // Train UBM (32 Gaussian components—adjust based on compute power)
        UBMTrainer trainer(config);
        GMM worldGMM;
        trainer.trainUBM(worldGMM, allFeatures, 32);

        // Save to app's private directory (avoid external storage permission issues)
        std::string savePath = std::string(dirPath) + "/gmm/world.gmm";
        worldGMM.save(savePath);

        env->ReleaseStringUTFChars(trainingAudioDir, dirPath);
        return env->NewStringUTF("World GMM trained and saved successfully!");
    } catch (const Exception& e) {
        return env->NewStringUTF(e.getMessage().c_str());
    }
}

Android Java Layer (Call JNI and Manage Files)

public class AlizeHelper {
    static {
        System.loadLibrary("alize-jni"); // Load your compiled Alize JNI library
    }

    // Native method to trigger UBM training
    public native String trainWorldGMM(String trainingAudioDir);

    // Example usage in your activity/fragment
    public void startUbmtraining() {
        // Use app's private directory to avoid permission issues
        File trainingDir = new File(getFilesDir(), "training_audio");
        File gmmDir = new File(trainingDir, "gmm");
        if (!gmmDir.exists()) gmmDir.mkdirs();

        String result = trainWorldGMM(trainingDir.getAbsolutePath());
        Log.d("AlizeTraining", result);
    }
}

Key Notes #

• Dataset Size: A small dataset will result in a poor-performing UBM—aim for at least 50 hours of diverse speech if possible.
• File Permissions: On Android, use the app’s private directory (getFilesDir()) instead of external storage to skip runtime permission requests.
• GMM Components: The number of Gaussian components (32 in the example) balances accuracy and compute load—start with 32 or 64 for mobile.

Using .3GP Audio Files with Alize #

Alize doesn’t natively support .3GP because it’s a compressed container (usually with AMR encoding). You’ll need to first decode .3GP files into raw PCM audio, then feed that PCM data into Alize’s feature extractor.

Code for .3GP to PCM Decoding (Android Java) #

public byte[] decode3gpToPcm(String filePath) throws IOException {
    MediaExtractor extractor = new MediaExtractor();
    extractor.setDataSource(filePath);

    // Find the audio track in the 3GP file
    int audioTrackIdx = -1;
    for (int i = 0; i < extractor.getTrackCount(); i++) {
        MediaFormat format = extractor.getTrackFormat(i);
        if (format.getString(MediaFormat.KEY_MIME).startsWith("audio/")) {
            audioTrackIdx = i;
            break;
        }
    }
    if (audioTrackIdx == -1) throw new IOException("No audio track found in 3GP file");

    extractor.selectTrack(audioTrackIdx);
    MediaFormat audioFormat = extractor.getTrackFormat(audioTrackIdx);
    MediaCodec codec = MediaCodec.createDecoderByType(audioFormat.getString(MediaFormat.KEY_MIME));
    codec.configure(audioFormat, null, null, 0);
    codec.start();

    ByteBuffer[] inputBuffers = codec.getInputBuffers();
    ByteBuffer[] outputBuffers = codec.getOutputBuffers();
    MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
    ByteArrayOutputStream pcmStream = new ByteArrayOutputStream();
    boolean isDecodingDone = false;

    while (!isDecodingDone) {
        // Feed encoded data to codec
        int inputBufferIdx = codec.dequeueInputBuffer(10000);
        if (inputBufferIdx >= 0) {
            ByteBuffer inputBuffer = inputBuffers[inputBufferIdx];
            int sampleSize = extractor.readSampleData(inputBuffer, 0);
            if (sampleSize < 0) {
                codec.queueInputBuffer(inputBufferIdx, 0, 0, 0, MediaCodec.BUFFER_FLAG_END_OF_STREAM);
                isDecodingDone = true;
            } else {
                codec.queueInputBuffer(inputBufferIdx, 0, sampleSize, extractor.getSampleTime(), 0);
                extractor.advance();
            }
        }

        // Extract decoded PCM data
        int outputBufferIdx = codec.dequeueOutputBuffer(bufferInfo, 10000);
        if (outputBufferIdx >= 0) {
            ByteBuffer outputBuffer = outputBuffers[outputBufferIdx];
            byte[] pcmChunk = new byte[bufferInfo.size];
            outputBuffer.get(pcmChunk);
            pcmStream.write(pcmChunk);
            codec.releaseOutputBuffer(outputBufferIdx, false);

            if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
                isDecodingDone = true;
            }
        } else if (outputBufferIdx == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED) {
            outputBuffers = codec.getOutputBuffers();
        }
    }

    // Cleanup
    codec.stop();
    codec.release();
    extractor.release();

    return pcmStream.toByteArray();
}

Pass PCM to Alize (JNI Layer) #

Add this native method to your JNI code to convert PCM to MFCC features:

extern "C" JNIEXPORT jboolean JNICALL
Java_com_yourpackage_AlizeHelper_extractFeaturesFromPcm(JNIEnv* env, jobject thiz, jbyteArray pcmData, jint sampleRate) {
    try {
        jbyte* pcmBytes = env->GetByteArrayElements(pcmData, nullptr);
        size_t pcmLength = env->GetArrayLength(pcmData);

        Config config;
        config.setParam("featureServer.mfcc.sampleRate", sampleRate);
        // Match other MFCC parameters to your training config
        config.setParam("featureServer.mfcc.cepstralCoefficientsCount", 12);

        FeatureExtractor fe(config);
        // PCM is typically 16-bit, so cast to int16_t and divide length by 2
        Feature pcmFeatures = fe.extractPCMFeature((const int16_t*)pcmBytes, pcmLength / 2);
        
        // Save features for training or verification
        pcmFeatures.save(getFilesDir() + "/temp_features.feature");

        env->ReleaseByteArrayElements(pcmData, pcmBytes, 0);
        return true;
    } catch (const Exception& e) {
        return false;
    }
}

Key Notes #

• PCM Format: Ensure the decoded PCM matches Alize’s expectations (16-bit depth, single-channel recommended, sample rate matching your training config—16kHz is standard for speech).
• Stereo to Mono: If your .3GP file is stereo, extract one channel (left or right) before passing to Alize, as speaker recognition works best with mono audio.

内容的提问来源于stack exchange，提问作者SATYAM P TODKAR