class HSpeaker
{
public:
     HSpeaker();
     HSpeaker(SV_Model_DTW* pModel);
     ~HSpeaker();
     BOOL LoadFrom(CFile* pFile);
     BOOL SaveTo(CFile* pFile);
     void SetUserName(CString strName);
     CString GetUserName(); 
     void SetPassphrase(int nSamples, short* pSamples);
     double Verify(int nSamples, short* pSamples);
     double Verify(HSpeaker* pSpeaker);
     void PrepareFeature(SV_Feature_MFCC &Feature);
     void PrepareFeature(SV_Feature_Pitch &Feature);
     void PrepareFeature(SV_Feature_LPCC &Feature);
private:
     CString m_strName;
     SV_Data* m_pPassphrase;
     SV_Model_DTW* m_pModel;
};

void HSpeaker::SetUserName(CString strName)
{
     m_strName=strName;
}
CString HSpeaker::GetUserName()
{
     return m_strName;
}
کلاس سازنده دارای دوشکل متفاوت است. علت آن است که در عمل مقایسه لازم نیست هر دو کلاس دارای عضو m_pModel باشند و تخصیص حافظه به هر دو نوعی هدر دادن حافظه است لذا اگر برای یک شیء برای این عضو داده حافظه اختصاص داده شود دیگری می‌تواند از حافظه‌ی تخصیص داده شده‌ی دیگری استفده نماید:
HSpeaker::HSpeaker()
{
     m_pModel=new SV_Model_DTW;
     m_pPassphrase=NULL;
     m_strName=“”;
}
HSpeaker::HSpeaker(SV_Model_DTW* pModel)
{
     m_pModel=pModel;
     m_pPassphrase=NULL;
     m_strName=“”;
}
در کلاس ویرانگر اگر حافظه‌ای به m_pPassphrase اختصاص داده شده باشد آزاد می‌گردد:
HSpeaker::~HSpeaker()
{
     if(m_pPassphrase)
              delete m_pPassphrase;
}

void HSpeaker::SetPassphrase(int nSamples, short* pSamples)
{
     SV_Feature_MFCC Feature;
     PrepareFeature(Feature);
     Feature.CopySignal(pSamples, nSamples);
     m_pPassphrase=Feature.ExtractFeature();
}

void HSpeaker::PrepareFeature(SV_Feature_MFCC &Feature)
{
     Feature.Para.MFCC_Order = 12;
     Feature.Para.NFilter    = 60;
     Feature.Para.FFTSz      = 512;
     Feature.Para.DEnergy    = 1;
     Feature.Para.WinSz = 512;
     Feature.Para.StpSz = 256;
     Feature.Para.Alpha = 0.97;
     Feature.Para.HammingWin = 1;
     Feature.Para.RmvSilence = 1;
}

double HSpeaker::Verify(HSpeaker* pSpeaker)
{
     return m_pModel->DTW_Comp(*m_pPassphrase, *pSpeaker->m_pPassphrase);
}
شکل دیگر این متد برای انعطاف‌پذیری بیشتر نوشته شده است:
double HSpeaker::Verify(int nSamples, short* pSamples)
{
     HSpeaker Temp(m_pModel);
     Temp.SetPassphrase(nSamples, pSamples);
     return Verify(&Temp);
}
برای ذخیره‌ی شیء از نوع HSpeaker ابتدا نام کاربر ذخیره می‌گردد و سپس از یک کلاس دیگر به نام SV_DataIO از کتابخانه‌ی SVLib برای ذخیره‌ی موقت الگو در یک فایل و به دست آوردن اندازه‌ی آن بر حسب بایت و سپس ذخیره‌ی این اندازه و الگوی به دست آمده در فایل مقصد استفاده می‌گردد و در نهایت این فایل موقتی نیز حذف می‌گردد:
BOOL HSpeaker::SaveTo(CFile* pFile)
{   
     BYTE bNameLength=(BYTE)m_strName.GetLength();
     pFile->Write(&bNameLength,sizeof(BYTE));
     for(int bc=0;bc<bNameLength;bc++)
     {
              char c=m_strName[bc];
              pFile->Write(&c,sizeof(char));
     }
     SV_DataIO Temp;
     Temp.OpenFile(“temp.sv”,WRITE_REC);
     Temp.PutDataRec(*m_pPassphrase);
     Temp.CloseFile();
     CFile TempFile(“temp.sv”, CFile::modeRead);
     BYTE byte;
     int iSize=0;
     while(TempFile.Read(&byte, sizeof(byte))==sizeof(byte))
                       iSize++;
     TempFile.Close();
     pFile->Write(&iSize, sizeof(int));
     TempFile.Open(“temp.sv”, CFile::modeRead);
     int i=0;
     while(i<iSize) 
     {
              TempFile.Read(&byte, sizeof(byte));
              pFile->Write(&byte, sizeof(byte));
              i++;
     }
     TempFile.Close();
     DeleteFile(“temp.sv”);
     return TRUE;
}

BOOL HSpeaker::LoadFrom(CFile* pFile)
{
     BYTE bNameLength;
     if(pFile->Read(&bNameLength, sizeof(BYTE)) != sizeof(BYTE))
              return FALSE;
     char* name=new char[bNameLength+1];
     pFile->Read(name,bNameLength*sizeof(char));
     name[bNameLength]=‘\0‘;
     m_strName=name;
     delete []name;
     int iSize;
     pFile->Read(&iSize, sizeof(int));
     Cfile TempFile(“temp.sv”, CFile::modeWrite|CFile::modeCreate);
     BYTE byte;
     for(int i=0; i<iSize; i++)
     {
              pFile->Read(&byte,sizeof(byte));
              TempFile.Write(&byte, sizeof(byte));
     }
     TempFile.Close();
     SV_DataIO Temp;
     Temp.OpenFile(“temp.sv”, READ_REC);
     m_pPassphrase=Temp.GetDataRec();
     Temp.CloseFile();
     DeleteFile(“temp.sv”);
     return TRUE;
}

struct SpeakerPasses
{
          SpeakerPasses(){pNext=NULL;}
          HSpeaker* pSpeaker;
          SpeakerPasses* pNext;
          double Verify(HSpeaker* pSpeaker);
};

struct SpeakersPasses
{
          CString strName;
          SpeakersPasses(){pNext=NULL;}
          SpeakerPasses* pFirst;
          SpeakersPasses* pNext;
          double Identify(HSpeaker* pSpeaker);
          double Find(HSpeaker* pSpeaker,int &Index);
};

double SpeakersPasses::Identify(HSpeaker* pSpeaker)
{
          double fMin=10;
          double d;
          int i=0;
          for(SpeakerPasses* p=pFirst; p!=NULL; p=p->pNext,i++)
          if((d=p->Verify(pSpeaker))<fMin)
                             fMin=d;
          return fMin;
}

double SpeakersPasses::Find(HSpeaker* pSpeaker, int &Index)
{
          double fMin=10;
          double d;
          int i=0;
          for(SpeakerPasses* p=pFirst; p!=NULL; p=p->pNext,i++)
                   if((d=p->Verify(pSpeaker))<fMin)
                   {
                             Index=i;
                             fMin=d;
                   }
          return fMin;
}

class HSpeakersTable
{
public:
          HSpeakersTable(){m_pFirst=NULL;}
          void Insert(HSpeaker* pSpeaker);
          HSpeaker* Get(int iMain, int iSub=0);
          int GetSubsNum(int iMain);
          int GetIndex(CString str);
          int GetNum();
          void RemoveUser(int nIndex);
          BOOL RemPass(int nIndex, HSpeaker* pSpeaker, double fThreshold);
          int Identify(HSpeaker* pSpeaker, double fThreshold);
private:
          SpeakersPasses* m_pFirst;
};

void HSpeakersTable::Insert(HSpeaker* pSpeaker)
{
if(m_pFirst==NULL)
{
     m_pFirst=new SpeakersPasses;
     m_pFirst->strName=pSpeaker->GetUserName();
     m_pFirst->pFirst=new SpeakerPasses;
     m_pFirst->pFirst->pSpeaker=pSpeaker;
     return;
}
else
{
     int index;
          if( (index=GetIndex(pSpeaker->GetUserName())) !=  -1)
      {
          int i=0;
          for(SpeakersPasses* p=m_pFirst;  i<index; p=p->pNext,i++);
          for(SpeakerPasses* q=p->pFirst; q->pNext!=NULL; q=q->pNext);
          q->pNext=new SpeakerPasses;
          q->pNext->pSpeaker=pSpeaker;
     }
     else
          {
          for(SpeakersPasses* p=m_pFirst; p->pNext!=NULL; p=p->pNext);
          p->pNext=new SpeakersPasses;
          p->pNext->strName=pSpeaker->GetUserName();
          p->pNext->pFirst=new SpeakerPasses;
          p->pNext->pFirst->pSpeaker=pSpeaker;
    }
}
}

int HSpeakersTable::GetIndex(CString str)
{
   int index=0;
   for(SpeakersPasses* p=m_pFirst; p!=NULL; p=p->pNext,index++)
        {
          if(str==p->strName)
                   return index;
        }
          return -1;
}

int HSpeakersTable::GetNum()
{
          if(m_pFirst==NULL)
                   return 0;
          int Num=1;
          for(SpeakersPasses* p=m_pFirst; p->pNext!=NULL; p=p->pNext,Num++);
          return Num;
}
int HSpeakersTable::GetSubsNum(int iMain)
{
          if(m_pFirst==NULL)
                   return 0;
          int index=0;
          for(SpeakersPasses* p=m_pFirst; index<iMain; p=p->pNext,index++);
          index=1;
          for(SpeakerPasses* q=p->pFirst; q->pNext!=NULL; q=q->pNext,index++);
          return index;
}
HSpeaker* HSpeakersTable::Get(int iMain, int iSub)
{
          int index=0;
          for(SpeakersPasses* p=m_pFirst; index<iMain; p=p->pNext,index++);
          index=0;
          for(SpeakerPasses* q=p->pFirst; index<iSub; q=q->pNext,index++);
          return q->pSpeaker;
}

void HSpeakersTable::RemoveUser(int nIndex)
{
          if(nIndex==0)
          {
                   SpeakersPasses *p=m_pFirst;
                   m_pFirst=m_pFirst->pNext;
                   SpeakerPasses* q=p->pFirst;
                   for(SpeakerPasses* r=q->pNext; r!=NULL; r=r->pNext)
                   {
                             delete q;
                             q=r;
                   }
                   delete p;
                   return;
          }
          int i=1;
          for(SpeakersPasses* p=m_pFirst; i<nIndex; p=p->pNext,i++);
          SpeakersPasses *pp=p->pNext;
          p->pNext=pp->pNext;
          SpeakerPasses* q=pp->pFirst;
          for(SpeakerPasses* r=q->pNext; r!=NULL; r=r->pNext)
          {
                   delete q;
                   q=r;
          }
          delete pp;
}

int HSpeakersTable::Identify(HSpeaker* pSpeaker, double fThreshold)
{
          double fMin=10,d;
          int index;
          int i=0;
          for(SpeakersPasses* p=m_pFirst; p!=NULL; p=p->pNext,i++)
          {
                   if((d=p->Identify(pSpeaker))<fMin)
                   {
                             fMin=d;
                             index=i;
                   }
          }
          if(fMin<=fThreshold)
                   return index;
          return -1;
}

BOOL HSpeakersTable::RemPass(int nIndex, HSpeaker* pSpeaker, double fThreshold)
{
          int i=0;
          for(SpeakersPasses* p=m_pFirst; i<nIndex; p=p->pNext,i++);
          int Index=-1;
          if(p->Find(pSpeaker,Index)<=fThreshold)
          {
                   if(Index==0)
                   {
                             SpeakerPasses *t=p->pFirst;
                             p->pFirst=t->pNext;
                             delete t;
                   }
                   else
                   {
                             int i=0;
                             for(SpeakerPasses *q=p->pFirst; i<Index-1; q=q->pNext,i++);
                             SpeakerPasses *t=q->pNext;
                             q->pNext=t->pNext;
                             delete t;
                   }
                   return TRUE;
          }
          return FALSE;
}

class HSpeakersDB
{
public:
          int GetUsersNum();
          void AddUser(HSpeaker* pSpeaker);
          CString GetUserName(int index);
          int GetPassesNum(int index);
          void RemoveUser(int nIndex);
          int Identify(HSpeaker* pSpeaker);
          BOOL RemPass(int index, HSpeaker* pSpeaker);
          HSpeakersDB(BOOL bAutoLoad=FALSE);
          void LoadUsers();
          void StoreUsers();
private:
          void CreateUsersDB();
private:
          HSpeakersTable* m_pTable;
          CString m_strDBFileName;
private:         //user identification options:
          int m_nRepetitions;
          float m_fMinPassLength;
          double m_fThreshold;
public:
          void SetRepsNum(int iNum);
          int GetRepsNum();
          void SetMinPassLen(float fMin);
          float GetMinPassLen();
          void SetSecurityLevel(int nLevel);
          int GetSecurityLevel();
};

int HSpeakersDB::GetUsersNum()
{
          return m_pTable->GetNum();
}
void HSpeakersDB::AddUser(HSpeaker *pSpeaker)
{
          m_pTable->Insert(pSpeaker);
}
CString HSpeakersDB::GetUserName(int index)
{
          return m_pTable->Get(index)->GetUserName();
}
int HSpeakersDB::GetPassesNum(int index)
{
          return m_pTable->GetSubsNum(index);
}
void HSpeakersDB::RemoveUser(int nIndex)
{
          m_pTable->RemoveUser(nIndex);
}
int HSpeakersDB::Identify(HSpeaker* pSpeaker)
{
          return m_pTable->Identify(pSpeaker, m_fThreshold);
}
BOOL HSpeakersDB::RemPass(int index, HSpeaker* pSpeaker)
{
          return m_pTable->RemPass(index, Speaker,m_fThreshold);
}

void HSpeakersDB::SetSecurityLevel(int nLevel)
{
          switch(nLevel)
          {
          case VERYHIGH:
                   m_fThreshold=0.3;
                   break;
          case HIGH:
                   m_fThreshold=0.5;
                   break;
          case MEDIUM:
                   m_fThreshold=0.7;
                   break;
          case LOW:
                   m_fThreshold=0.9;
                   break;
          case VERYLOW:
                   m_fThreshold=1.1;
                   break;
          }
}
int HSpeakersDB::GetSecurityLevel()
{
          int nLevel;
          switch(int(m_fThreshold*10))
          {
          case 3:
                   nLevel=VERYHIGH;
                   break;
          case 5:
                   nLevel=HIGH;
                   break;
          case 7:
                   nLevel=MEDIUM;
                   break;
          case 9:
                   nLevel=LOW;
                   break;
          case 11:
                   nLevel=VERYLOW;
                   break;
          }
          return nLevel;
}

void HSpeakersDB::StoreUsers()
{
   CFile UsersDB;
   if(UsersDB.Open(“USERS.DB”, CFile::modeWrite|CFile::modeCreate))
          {
                    UsersDB.Write(&m_nRepetitions, sizeof(m_nRepetitions));
          UsersDB.Write(&m_fMinPassLength, sizeof(m_fMinPassLength));
          UsersDB.Write(&m_fThreshold, sizeof(m_fThreshold));
                   int iNum=m_pTable->GetNum();
                   for(int i=0; i<iNum; i++)
                   {
                             int iSubs=m_pTable->GetSubsNum(i);
                             for(int j=0; j<iSubs; j++)
                                      m_pTable->Get(i,j)->SaveTo(&UsersDB);
                   }
                   UsersDB.Close();
          }
}

void HSpeakersDB::LoadUsers()
{
          CFile UsersDB;
          m_nRepetitions=2;
          m_fMinPassLength=2.0;
          m_fThreshold=0.7;
          if(UsersDB.Open(“USERS.DB”,CFile::modeRead))
          {
                   if(UsersDB.Read(&m_nRepetitions, sizeof(m_nRepetitions))==sizeof(m_nRepetitions))
          if(UsersDB.Read(&m_fMinPassLength, sizeof(m_fMinPassLength))==sizeof(m_fMinPassLength))
                   UsersDB.Read(&m_fThreshold, sizeof(m_fThreshold));
                   BOOL Finished=FALSE;
                   while(!Finished)
                   {
                             HSpeaker* pSpeaker=new HSpeaker;
                             if(pSpeaker->LoadFrom(&UsersDB))
                                      m_pTable->Insert(pSpeaker);
                             else
                             {
                                      delete pSpeaker;
                                      Finished=TRUE;
                             }
                   }
          }
          else
                   CreateUsersDB();
}