rund2l.cpp

Intel开发的IPP库的应用例程

/*
//
//               INTEL CORPORATION PROPRIETARY INFORMATION
//  This software is supplied under the terms of a license agreement or
//  nondisclosure agreement with Intel Corporation and may not be copied
//  or disclosed except in accordance with the terms of that agreement.
//        Copyright(c) 1999-2006 Intel Corporation. All Rights Reserved.
//
*/

// RunD2L.cpp : implementation of the CRunD2L class.
// CRunD2L class processes vectors by ippSP functions listed in
// CallIppFunction member function.
// See CRun & CippsRun classes for more information.
//
/////////////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "ippsdemo.h"
#include "ippsdemodoc.h"
#include "RunD2L.h"
#include "ParmIntDlg.h"
#include "Histo.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CRunD2L::CRunD2L()
{
   m_bToD2L = FALSE;
   m_iDoc = 0;
   m_numDoc = 3;
   m_chanLen = 0;
   m_ppVec = NULL;
   m_ppDoc = NULL;
   m_pNewDst = NULL;
}

CRunD2L::~CRunD2L()
{
   DeleteD2L(); 
}

BOOL CRunD2L::Open(CFunc funcName)
{
   if (!CippsRun::Open(funcName))
      return FALSE;
   m_bToD2L = funcName.Found("Split");
   if (m_bToD2L) m_UsedVectors = VEC_SRC;

   if (!CippsRun::GetParms()) return FALSE;
   if (m_numDoc <= 0) {
      return FALSE;
   }
   CreateD2L(m_numDoc);
   return TRUE;
}

void CRunD2L::CreateD2L(int num)
{
   DeleteD2L();
   m_ppDoc = new CippsDemoDoc*[num];
   m_ppVec = new void*[num];
   m_pNewDst = new BOOL[num];
   for (int i=0; i<num; i++) {
      m_ppDoc  [i] = NULL;
      m_ppVec  [i] = NULL;
      m_pNewDst[i] = FALSE;
   }
}

void CRunD2L::DeleteD2L()
{
   if (m_ppDoc) delete[] m_ppDoc;  m_ppDoc = NULL;
   if (m_ppVec) delete[] m_ppDoc;  m_ppVec = NULL;
   if (m_pNewDst) delete[] m_pNewDst;  m_pNewDst = NULL;
}

void CRunD2L::Close()
{
   CippsRun::Close();
}

BOOL CRunD2L::PickStart()
{
   if (m_bToD2L)
      return TRUE;
   CippsRun::PickStart();
   m_ppDoc[0] = (CippsDemoDoc*)m_pDocSrc;
   m_iDoc = 1;
   return TRUE;
}

BOOL CRunD2L::PickNextPos()
{
   if (m_bToD2L)
      return FALSE;
   if (m_iDoc < m_numDoc) return TRUE;
   m_PickVecPos = -1;
   return FALSE;
}

BOOL CRunD2L::PickSetID(CMyString& vectorName, UINT& pickID, UINT& grabID)
{
   vectorName.Format("Src%d", m_iDoc + 1);
   pickID = IDC_CURSOR_PSI;
   grabID = IDC_CURSOR_SI;
   return TRUE;
}

void CRunD2L::GrabDoc(CDemoDoc* pDoc)
{
   m_ppDoc[m_iDoc] = (CippsDemoDoc*)pDoc;
   m_iDoc++;
   pDoc->IsPicked(TRUE);
}

BOOL CRunD2L::PrepareDst()
{
   if (!m_bToD2L)
      return CippsRun::PrepareDst();
   for (int i=0; i<m_numDoc; i++) {
      if (!CreateNewDst(TRUE, GetDstLength(), m_pNewDst[i], (CDemoDoc*&)(m_ppDoc[i])))
         return FALSE;
   }
   return TRUE;
}

void CRunD2L::DeleteNewDst()
{
   if (!m_bToD2L) {
      CippsRun::DeleteNewDst();
      return;
   }
   for (int i=0; i<m_numDoc; i++) {
      if (m_pNewDst[i])
         m_ppDoc[i]->OnCloseDocument();
   }
}

int CRunD2L::GetChanLen()
{
   int length = m_pDocSrc->GetVector()->Length();
   if (m_bToD2L)
      return length/m_numDoc;
   for (int i=1; i<m_numDoc; i++) {
      if (length > m_ppDoc[i]->Length())
         length = m_ppDoc[i]->Length();   
   }
   return length;
}

int CRunD2L::GetDstLength()
{
   if (m_bToD2L) 
      return GetChanLen();
   else
      return GetChanLen()*m_numDoc;
}

void CRunD2L::PrepareParameters()
{
   m_chanLen = GetChanLen();
   int dummyLen;
   if (m_bToD2L)
      SetParams((CippsDemoDoc*)m_pDocSrc, pSrc, m_lenSrc);
   for (int i=0; i<m_numDoc; i++) 
      SetParams(m_ppDoc[i] , m_ppVec[i] , dummyLen);
   if (!m_bToD2L)
      SetParams((CippsDemoDoc*)m_pDocDst ,pDst , m_lenDst);
}

void CRunD2L::ActivateDst()
{ 
   int maxNum = m_numDoc + 2;
   CippsDemoDoc** ppDoc = new CippsDemoDoc*[maxNum];
   int num = 0;
   AddToDocs((CippsDemoDoc*)m_pDocSrc , ppDoc, num);
   for (int i=0; i<m_numDoc; i++) 
      AddToDocs(m_ppDoc[i], ppDoc, num);
   AddToDocs((CippsDemoDoc*)m_pDocDst , ppDoc, num);
   ActivateDocs(ppDoc, num);
   delete[] ppDoc;
}

void CRunD2L::SetHistory()
{
   if (m_bToD2L) {
      for (m_iDoc=0; m_iDoc<m_numDoc; m_iDoc++)
         SetToHisto(m_ppDoc[m_iDoc], VEC_DST );
   } else {
      m_iDoc = -1;
      SetToHisto(m_pDocDst, VEC_DST );
   }
}

void CRunD2L::SetToHistoSrc(CDemoDoc* pDoc, int vecPos)
{
   CHisto* pHisto = pDoc->GetVector()->GetHisto();
   CMyString title = pDoc->GetTitle();
   pHisto->RemoveAll();
   pHisto->AddTail(m_pDocSrc->GetVector()->GetHisto());
   if (!m_bToD2L) {
      for (int i=1; i<m_numDoc; i++) 
         pHisto->AddTail(m_ppDoc[i]->GetTitle());
   }
}

CString CRunD2L::GetVecName(int vecPos)
{
   if (!m_bToD2L) return "";
   CMyString vecName;
   return vecName << "Dst[" << m_iDoc << "]";
}

CParamDlg* CRunD2L::CreateDlg() { 
   return new CParmIntDlg;
   return NULL;
}

void CRunD2L::UpdateData(CParamDlg* parmDlg, BOOL save)
{
   CippsRun::UpdateData(parmDlg,save);
   CParmIntDlg *pDlg = (CParmIntDlg*)parmDlg;
   if (save) {
      m_numDoc = pDlg->m_Val;
   } else {
      pDlg->m_Val = m_numDoc;
      pDlg->m_ValName = "nChannels";
      pDlg->m_MinVal = 1;
      pDlg->m_MaxVal = 1000;
   }
}

IppStatus CRunD2L::CallIppFunction()
{
   FUNC_CALL(ippsJoin_32f16s_D2L,((const Ipp32f**)m_ppVec, m_numDoc, m_chanLen, (Ipp16s*)pDst ) )
   FUNC_CALL(ippsJoinScaled_32f16s_D2L,((const Ipp32f**)m_ppVec, m_numDoc, m_chanLen, (Ipp16s*)pDst))
   FUNC_CALL(ippsJoinScaled_32f24s_D2L,((const Ipp32f**)m_ppVec, m_numDoc, m_chanLen, (Ipp8u*)pDst))
   FUNC_CALL(ippsSplitScaled_16s32f_D2L,((Ipp16s*)pSrc, (Ipp32f**)m_ppVec, m_numDoc, m_chanLen))
   FUNC_CALL(ippsSplitScaled_24s32f_D2L,((Ipp8u*)pSrc, (Ipp32f**)m_ppVec, m_numDoc, m_chanLen))

   return stsNoFunction;
}

CString CRunD2L::GetHistoryParms()
{
   CMyString parm;
   parm << m_numDoc;
   return parm;
}