reco_sphinx.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2012 I-maginer
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
 
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
 
#ifndef __RECO_H__
#define __RECO_H__
 
#include "pluginSpeechPrerequisites.h"
#include <pocketsphinx.h>
#include <thread>
#include <mutex>
 
#include <cstring>
#include <iostream>
 
#include <unordered_map>
 
#define MAX_BUFFER 262144
 
class Buffer {
public:
  Buffer(size_t bufferSize) : size(bufferSize), data(new char[size]), count(0) {}
 
  ~Buffer()
  {
    delete[] data;
  }
 
  void fill(const char* newData, size_t newDataSize)
  {
    if (newDataSize > size - count)
    {
      // "Buffer overflow. Data not filled completely."
      return;
    }
 
    std::memcpy(data + count, newData, newDataSize);
    count += newDataSize;
  }
 
  void consume(size_t consumeSize)
  {
    if (consumeSize >= count)
    {
      count = 0;
    }
    else
    {
      std::memmove(data, data + consumeSize, count - consumeSize);
      count -= consumeSize;
    }
  }
 
  void getInt16(int16_t* int16Array, size_t length)
  {
    const int16_t* audioData = reinterpret_cast<const int16_t*>(data);
    for (size_t i = 0; i < length; ++i)
    {
      int16Array[i] = audioData[i];
    }
    consume(length);
  }
 
  const char* getData() const
  {
    return data;
  }
 
  size_t getCount() const
  {
    return count;
  }
 
private:
  size_t size;
  char* data;
  size_t count;
};
 
 
class Recognition 
{
public:
protected:
private:
  std::thread mThread;
  std::mutex mMutex;
  std::mutex mMutexConfig;
  bool mValid;
  ps_config_t* mConfig;
  ps_decoder_t* mDecoder;
  ps_endpointer_t* mEndPointer;
  size_t mFrameSize;
  Buffer* mBuffer;
  bool mKeySearch;
  std::vector<std::string> mKeyWords;
public:
  Recognition();
 
        Recognition(std::string pathtobin, std::string lang);
 
  ~Recognition();
 
  void cbThread();
 
  void fillAudioBuffer(const char* data, size_t lenght);
 
  bool initializeObjects();
 
  int getVolume();
        
  void setVolume(int volume);
      
  void AddWord(std::string s_Rule, std::string s_Word);
protected:
private:
};
 
#endif