handvufilter.cpp

tracciatore di mani con webcam

    return E_UNEXPECTED;
  }

  ASSERT(pAlloc);
  ASSERT(pProperties);
  HRESULT hr = NOERROR;

  pProperties->cBuffers = 1;
  pProperties->cbBuffer = m_pInput->CurrentMediaType().GetSampleSize();
  ASSERT(pProperties->cbBuffer);

  // Ask the allocator to reserve us some sample memory, NOTE the function
  // can succeed (that is return NOERROR) but still not have allocated the
  // memory that we requested, so we must check we got whatever we wanted

  ALLOCATOR_PROPERTIES Actual;
  hr = pAlloc->SetProperties(pProperties,&Actual);
  if (FAILED(hr)) {
    return hr;
  }

  ASSERT( Actual.cBuffers == 1 );

  if (pProperties->cBuffers > Actual.cBuffers ||
      pProperties->cbBuffer > Actual.cbBuffer) {
    return E_FAIL;
  }
  return NOERROR;

} // DecideBufferSize


//
// GetMediaType
//
// I support one type, namely the type of the input pin
// This type is only available if my input is connected
//
HRESULT CHandVuFilter::GetMediaType(int iPosition, CMediaType *pMediaType)
{
  // Is the input pin connected

  if (m_pInput->IsConnected() == FALSE) {
    return E_UNEXPECTED;
  }

  // This should never happen

  if (iPosition < 0) {
    return E_INVALIDARG;
  }

  // Do we have more items to offer

  if (iPosition > 0) {
    return VFW_S_NO_MORE_ITEMS;
  }

  *pMediaType = m_pInput->CurrentMediaType();
  return NOERROR;

} // GetMediaType


//
// CanPerformHandVuFilter
//
// Check if this is a RGB24 true colour format
//
BOOL CHandVuFilter::CanPerformHandVuFilter(const CMediaType *pMediaType) const
{
  if (IsEqualGUID(*pMediaType->Type(), MEDIATYPE_Video)) {
    if (IsEqualGUID(*pMediaType->Subtype(), MEDIASUBTYPE_RGB24)) {
      VIDEOINFOHEADER *pvi = (VIDEOINFOHEADER *) pMediaType->Format();
      return (pvi->bmiHeader.biBitCount == 24);
    }
  }
  return FALSE;

} // CanPerformHandVuFilter


#define WRITEOUT(var)  hr = pStream->Write(&var, sizeof(var), NULL); \
		       if (FAILED(hr)) return hr;

#define READIN(var)    hr = pStream->Read(&var, sizeof(var), NULL); \
		       if (FAILED(hr)) return hr;


//
// GetClassID
//
// This is the only method of IPersist
//
STDMETHODIMP CHandVuFilter::GetClassID(CLSID *pClsid)
{
  return CBaseFilter::GetClassID(pClsid);
} // GetClassID


//
// ScribbleToStream
//
// Overriden to write our state into a stream
//
HRESULT CHandVuFilter::ScribbleToStream(IStream *pStream)
{
  return NOERROR;

} // ScribbleToStream


//
// ReadFromStream
//
// Likewise overriden to restore our state from a stream
//
HRESULT CHandVuFilter::ReadFromStream(IStream *pStream)
{
  return NOERROR;

} // ReadFromStream


//
// GetPages
//
// Returns the clsid's of the property pages we support
//
STDMETHODIMP CHandVuFilter::GetPages(CAUUID *pPages)
{
  pPages->cElems = 1;
  pPages->pElems = (GUID *) CoTaskMemAlloc(sizeof(GUID));
  if (pPages->pElems == NULL) {
    return E_OUTOFMEMORY;
  }
  *(pPages->pElems) = CLSID_HandVuFilterPropertyPage;
  return NOERROR;

} // GetPages


//
// GetHandVuFilterParams
//
STDMETHODIMP
CHandVuFilter::GetHandVuFilterParams(HandVuFilterParams& params) const
{
  CAutoLock cAutolock(&m_HandVuFilterLock);

  params = m_params;

  return NOERROR;
} // GetHandVuFilterParams


//
// SetHandVuFilterParams
//
STDMETHODIMP
CHandVuFilter::SetHandVuFilterParams(const HandVuFilterParams& params)
{
  CAutoLock cAutolock(&m_HandVuFilterLock);

  m_params = params;

  SetDirty(TRUE);
  return NOERROR;
} // SetHandVuFilterParams


STDMETHODIMP CHandVuFilter::Initialize(int img_width, int img_height, int iPixelSize, CameraController* pCamCon)
{
  CAutoLock lock(&m_HandVuFilterLock);
  if (m_is_initialized) {
    return E_UNEXPECTED;
  }

  m_cxImage = img_width;
  if (img_height<0) {
    // norm for RGB images
    m_img_bottom_up = false;
    m_cyImage = -img_height;
  } else {
    m_img_bottom_up = true;
    m_cyImage = img_height;
  }

  ASSERT(m_pColorHeader==NULL);
  m_pColorHeader = cvCreateImageHeader(cvSize(m_cxImage, m_cyImage), IPL_DEPTH_8U, 3);

  hvInitialize(m_cxImage, m_cyImage);

  m_is_initialized = true;

  return NOERROR;
}

STDMETHODIMP CHandVuFilter::LoadConductor(const string& filename)
{
  CAutoLock lock(&m_HandVuFilterLock);
  hvLoadConductor(filename);
  return NOERROR;
}

STDMETHODIMP CHandVuFilter::ConductorLoaded(bool* pLoaded)
{
  *pLoaded = hvConductorLoaded();
  return NOERROR;
}

STDMETHODIMP CHandVuFilter::StartRecognition(int obj_id)
{
  CAutoLock lock(&m_HandVuFilterLock);
  hvStartRecognition(obj_id);
  return NOERROR;
}

STDMETHODIMP CHandVuFilter::StopRecognition(int obj_id)
{
  CAutoLock lock(&m_HandVuFilterLock);
  hvStopRecognition(obj_id);
  return NOERROR;
}

STDMETHODIMP CHandVuFilter::IsActive(bool* pActive)
{
  *pActive = hvIsActive();
  return NOERROR;
}

STDMETHODIMP CHandVuFilter::GetState(int obj_id, hvState& state)
{
  hvGetState(obj_id, state);
  return NOERROR;
}

STDMETHODIMP CHandVuFilter::SetOverlayLevel(int level)
{
  hvSetOverlayLevel(level);
  return NOERROR;
}

STDMETHODIMP CHandVuFilter::GetOverlayLevel(int* pLevel)
{
  *pLevel = hvGetOverlayLevel();
  return NOERROR;
}

STDMETHODIMP CHandVuFilter::CorrectDistortion(bool enable)
{
  hvCorrectDistortion(enable);
  return NOERROR;
}

STDMETHODIMP CHandVuFilter::CanCorrectDistortion(bool* pPossible)
{
  *pPossible = hvCanCorrectDistortion();
  return NOERROR;
}

STDMETHODIMP CHandVuFilter::IsCorrectingDistortion(bool* pOn)
{
  *pOn = hvIsCorrectingDistortion();
  return NOERROR;
}

STDMETHODIMP CHandVuFilter::SetDetectionArea(int left, int top, int right, int bottom)
{
  hvSetDetectionArea(left, top, right, bottom);
  return NOERROR;
}

STDMETHODIMP CHandVuFilter::RecomputeNormalLatency()
{
  hvRecomputeNormalLatency();
  return NOERROR;
}

STDMETHODIMP CHandVuFilter::SetAdjustExposure(bool enable)
{
  hvSetAdjustExposure(enable);
  return NOERROR;
}

STDMETHODIMP CHandVuFilter::CanAdjustExposure(bool* pPossible)
{
  *pPossible = hvCanAdjustExposure();
  return NOERROR;
}

STDMETHODIMP CHandVuFilter::IsAdjustingExposure(bool* pEnabled)
{
  *pEnabled = hvIsAdjustingExposure();
  return NOERROR;
}

STDMETHODIMP CHandVuFilter::AddListener(HVFilterEventListener* pHVFListener)
{
  CAutoLock lock(&m_HandVuFilterLock);
  m_HVFListenerPtrs.push_back(pHVFListener);
  return NOERROR;
}

STDMETHODIMP CHandVuFilter::RemoveListener(HVFilterEventListener* pHVFListener)
{
  CAutoLock lock(&m_HandVuFilterLock);
  bool found = false;
  int old_size = (int)m_HVFListenerPtrs.size();
  for (int i=0; i<old_size; i++) {
    if (m_HVFListenerPtrs[i]==pHVFListener) {
      found = true;
    }
    if (found && i+1<old_size) {
      m_HVFListenerPtrs[i] = m_HVFListenerPtrs[i+1];
    }
  }
  if (found) {
    m_HVFListenerPtrs.resize(old_size-1);
    return NOERROR;
  } else {
    return E_INVALIDARG;
  }
}

STDMETHODIMP CHandVuFilter::ToggleMaintenanceApp()
{
  CAutoLock lock(&m_HandVuFilterLock);
  if (!m_pOverlay) {
    VERBOSE0(3, "HandVuFilter: loading MaintenanceApp");
    m_pOverlay = new CMaintenanceApp();
    m_pOverlay->Initialize(m_cxImage, m_cyImage);

    // $IT_DATA environmet variable, NULL if not set
    const char *it_data = getenv("IT_DATA");

    string filename = string(it_data)+"\\config\\default.conductor";

    try {
      hvLoadConductor(filename);
      hvStartRecognition();
      hvSetOverlayLevel(0);

    } catch (HVException& hve) {
      AfxMessageBox(hve.GetMessage().c_str());
      delete m_pOverlay;
      m_pOverlay = NULL;
      return S_FALSE;
    }
  }

  m_show_maintenanceapp = !m_show_maintenanceapp;
  return NOERROR;
}

STDMETHODIMP CHandVuFilter::ToggleFDLOnly()
{
  m_FDL_only = !m_FDL_only;
  return NOERROR;
}

#if !defined(HAVE_USER_STUDY)
STDMETHODIMP CHandVuFilter::OnMouseMove(UINT nFlags, double x, double y)
{
  return NOERROR;
}

STDMETHODIMP CHandVuFilter::OnLButtonUp(UINT nFlags, double x, double y)
{
  return NOERROR;
}
#endif // ! HAVE_USER_STUDY

STDMETHODIMP CHandVuFilter::SetTimecodeReader(IUnknown* tcr)
{
  ASSERT(tcr);
  HRESULT hr;
  hr = tcr->QueryInterface(IID_IAMTimecodeReader, (void **) &m_pIAMTCReader);
  if (!SUCCEEDED(hr)) {
    VERBOSE0(1, "HVF: got corrupt DV TimecodeReader");
    m_pIAMTCReader = NULL;
    return hr;
  }

  return NOERROR;
}

string CHandVuFilter::GetTimecode()
{
  ASSERT(m_pIAMTCReader);

  TIMECODE_SAMPLE TimecodeSample;
  TimecodeSample.timecode.dwFrames = 0;
  static DWORD i1 = 0, i2 = 0, i3 = 0;

  TimecodeSample.dwFlags = ED_DEVCAP_TIMECODE_READ;

  // Query the TimeCode sample data
  HRESULT hr = m_pIAMTCReader->GetTimecode(&TimecodeSample);
  ASSERT(SUCCEEDED(hr));

  const int tcodelen = 64;
  TCHAR tcode[tcodelen];
  wsprintf(tcode, "%.2x:%.2x:%.2x:%.2x",
//  StringCbPrintf(tcode, tcodelen*sizeof(TCHAR), "%.2x:%.2x:%.2x:%.2x",
    ((TimecodeSample.timecode.dwFrames & 0xff000000) >> 24),
    ((TimecodeSample.timecode.dwFrames & 0x00ff0000) >> 16),
    ((TimecodeSample.timecode.dwFrames & 0x0000ff00) >>  8),
    (TimecodeSample.timecode.dwFrames & 0x000000ff));
  return string(tcode);
} 

STDMETHODIMP CHandVuFilter::TakeSnapshot() {
  CAutoLock lock(&m_HandVuFilterLock);
  if (m_pColorHeader==NULL) {
    return E_UNEXPECTED;
  }
  m_take_one_snapshot = true;
  return NOERROR;
}

void CHandVuFilter::SaveImageArea(IplImage* pImg)
{
  ASSERT(m_is_initialized);
  string picfile = "";
  hvSaveImageArea(pImg, 0, 0, INT_MAX, INT_MAX, picfile);
  VERBOSE1(3, "HandVuFilter: saved image in file %s", picfile.c_str());
}

STDMETHODIMP CHandVuFilter::SetVerbosity(int level, const string& logfilename)
{
  CAutoLock lock(&m_HandVuFilterLock);
  if (logfilename=="") {
    g_verbose = level;
    return NOERROR;
  }

  g_ostream = fopen(logfilename.c_str(), "a+");
  if (g_ostream==NULL) {
    return E_FAIL;
  }
  g_verbose = level;

  return NOERROR;
}

STDMETHODIMP CHandVuFilter::GetVersion(string& version)
{
  if (!m_is_initialized) {
    return E_UNEXPECTED;
  }

  version = "HandVuFilter CVS id: $Id: HandVuFilter.cpp,v 1.22 2005/10/30 23:00:43 matz Exp $";
  version = version + ", built on "__DATE__" at "__TIME__;

  string handvu_version;
  hvGetVersion(handvu_version, 3);
  version = version + "\n" + handvu_version;

  return NOERROR;
}