Lire la partie Données d'un fichier WAV pour la reconnaissance vocale avec Hopfield Neural Network

Question

Je souhaite écrire un programme de reconnaissance sonore. J'ai l'algorithme, mais je ne peux pas lire correctement la voix du microphone. J'ai un code de https://stackoverflow.com/, qui lit les données d'un fichier wav, mais je ne sais pas comment mettre les données brutes wav dans un vecteur binaire ou un tableau. Donc, fondamentalement, j'ai besoin d'un vecteur binaire ou un tableau qui contient les bits de données (1-s ou 0-s) et il doit être long de 2000-4000 bits. Comment puis je faire ça?

(je l'utilise avec un réseau de neurones Hopfield)

#include <iostream> 
#include <string> 
#include <fstream> 
#include <cstdint> 

using std::cin; 
using std::cout; 
using std::endl; 
using std::fstream; 
using std::string; 

typedef struct WAV_HEADER 
{ 
    /* RIFF Chunk Descriptor */ 
    uint8_t   RIFF[4];  // RIFF Header Magic header 
    uint32_t  ChunkSize;  // RIFF Chunk Size 
    uint8_t   WAVE[4];  // WAVE Header 
    /* "fmt" sub-chunk */ 
    uint8_t   fmt[4];   // FMT header 
    uint32_t  Subchunk1Size; // Size of the fmt chunk 
    uint16_t  AudioFormat; // Audio format 1=PCM,6=mulaw,7=alaw,  257=IBM Mu-Law, 258=IBM A-Law, 259=ADPCM 
    uint16_t  NumOfChan;  // Number of channels 1=Mono 2=Sterio 
    uint32_t  SamplesPerSec; // Sampling Frequency in Hz 
    uint32_t  bytesPerSec; // bytes per second 
    uint16_t  blockAlign;  // 2=16-bit mono, 4=16-bit stereo 
    uint16_t  bitsPerSample; // Number of bits per sample 
    /* "data" sub-chunk */ 
    uint8_t   Subchunk2ID[4]; // "data" string 
    uint32_t  Subchunk2Size; // Sampled data length 
} wav_hdr; 

// Function prototypes 
int getFileSize(FILE* inFile); 

int main(int argc, char* argv[]) 
{ 
    wav_hdr wavHeader; 
    int headerSize = sizeof(wav_hdr), filelength = 0; 

    const char* filePath; 
    string input; 
    if (argc <= 1) 
    { 
     cout << "Input wave file name: "; 
     cin >> input; 
     cin.get(); 
     filePath = input.c_str(); 
    } 
    else 
    { 
     filePath = argv[1]; 
     cout << "Input wave file name: " << filePath << endl; 
    } 

    FILE* wavFile = fopen(filePath, "r"); 
    if (wavFile == nullptr) 
    { 
     fprintf(stderr, "Unable to open wave file: %s\n", filePath); 
     return 1; 
    } 

    //Read the header 
    size_t bytesRead = fread(&wavHeader, 1, headerSize, wavFile); 
    cout << "Header Read " << bytesRead << " bytes." << endl; 
    if (bytesRead > 0) 
    { 
     //Read the data 
     uint16_t bytesPerSample = wavHeader.bitsPerSample/8;  //Number  of bytes per sample 
     uint64_t numSamples = wavHeader.ChunkSize/bytesPerSample; //How many samples are in the wav file? 
     static const uint16_t BUFFER_SIZE = 4096; 
     int8_t* buffer = new int8_t[BUFFER_SIZE]; 
     while ((bytesRead = fread(buffer, sizeof buffer[0], BUFFER_SIZE/(sizeof buffer[0]), wavFile)) > 0) 
     { 
      /** DO SOMETHING WITH THE WAVE DATA HERE **/ 
      cout << "Read " << bytesRead << " bytes." << endl; 
     } 
     delete [] buffer; 
     buffer = nullptr; 
     filelength = getFileSize(wavFile); 

     cout << "File is     :" << filelength << " bytes." << endl; 
     cout << "RIFF header    :" << wavHeader.RIFF[0] << wavHeader.RIFF[1] << wavHeader.RIFF[2] << wavHeader.RIFF[3] << endl; 
     cout << "WAVE header    :" << wavHeader.WAVE[0] << wavHeader.WAVE[1] << wavHeader.WAVE[2] << wavHeader.WAVE[3] << endl; 
     cout << "FMT      :" << wavHeader.fmt[0] << wavHeader.fmt[1] << wavHeader.fmt[2] << wavHeader.fmt[3] << endl; 
     cout << "Data size     :" << wavHeader.ChunkSize << endl; 

     // Display the sampling Rate from the header 
     cout << "Sampling Rate    :" << wavHeader.SamplesPerSec << endl; 
     cout << "Number of bits used  :" << wavHeader.bitsPerSample << endl; 
     cout << "Number of channels   :" << wavHeader.NumOfChan << endl; 
     cout << "Number of bytes per second :" << wavHeader.bytesPerSec << endl; 
     cout << "Data length    :" << wavHeader.Subchunk2Size << endl; 
     cout << "Audio Format    :" << wavHeader.AudioFormat << endl; 
     // Audio format 1=PCM,6=mulaw,7=alaw, 257=IBM Mu-Law, 258=IBM A-Law, 259=ADPCM 

     cout << "Block align    :" << wavHeader.blockAlign << endl; 
     cout << "Data string    :" << wavHeader.Subchunk2ID[0] << wavHeader.Subchunk2ID[1] << wavHeader.Subchunk2ID[2] << wavHeader.Subchunk2ID[3] << endl; 
    } 
    fclose(wavFile); 
    return 0; 
} 

// find the file size 
int getFileSize(FILE* inFile) 
{ 
    int fileSize = 0; 
    fseek(inFile, 0, SEEK_END); 

    fileSize = ftell(inFile); 

    fseek(inFile, 0, SEEK_SET); 
    return fileSize; 
} 

Answer 1

Il pourrait y avoir plusieurs façons d'utiliser un réseau de neurones pour calculer même a posteriori et l'alimentation les dents postérieures dans Hopfield comme décrit dans cet article:

http://www.assta.org/sst/SST-92/cache/SST-92-NeuralNetworks-p14.pdf

Deuxième approche serait juste pour convertir des échantillons en morceaux, ce serait plus complexe, mais aussi plus intéressant comme dans la recherche moderne suivante:

Langue multilingue traitement de Bytes Dan Gillick, Cliff Brunk, Oriol Vinyals, Amarnag Subramanya http://arxiv.org/abs/1512.00103

Vous devriez avoir l'algorithme d'étude et choisir vous-même d'abord.