Esempio n. 1
0
   virtual std::vector<unsigned int> EnumDeviceProperties() const override
   {
      // start enumerating
      cdHEnum hEnum = 0;

      // may return cdINVALID_PARAMETER, cdINVALID_HANDLE
      cdError err = CDEnumDevicePropertyReset(m_hSource, 0, &hEnum);
      if (err != cdOK) LOG_TRACE(_T("CDEnumDevicePropertyReset(%08x) returned %08x\n"), m_hSource, err);
      CheckError(_T("CDEnumDeviceReset"), err, __FILE__, __LINE__);

      // get count of properties
      cdUInt32 count = 0;

      // returns cdINVALID_HANDLE, cdINVALID_PARAMETER
      err = CDGetDevicePropertyCount(hEnum, &count);
      if (err != cdOK) LOG_TRACE(_T("CDGetDevicePropertyCount(%08x, &count = %u) returned %08x\n"), hEnum, count, err);
      CheckError(_T("CDGetDevicePropertyCount"), err, __FILE__, __LINE__);

      std::vector<unsigned int> vecData;
      for (cdUInt32 i=0; i<count+1; i++)
      {
         cdDevicePropertyStruct deviceProperty;

         // may return cdINVALID_PARAMETER, cdINVALID_HANDLE, cdENUM_NA
         err = CDEnumDevicePropertyNext(hEnum, &deviceProperty);
         if ((err & cdERROR_ERRORID_MASK) == cdENUM_NA)
            break;

         if (err != cdOK) LOG_TRACE(_T("CDEnumDevicePropertyNext(%08x, &propId = %08x \"%s\") returned %08x\n"),
            hEnum, deviceProperty.DevPropID,
            DevicePropertyAccess::NameFromId(deviceProperty.DevPropID),
            err);

         CheckError(_T("CDEnumDevicePropertyNext"), err, __FILE__, __LINE__);

         LOG_TRACE(_T("Available device property: \"%s\" (%08x)\n"),
            DevicePropertyAccess::NameFromId(deviceProperty.DevPropID),
            deviceProperty.DevPropID);

         vecData.push_back(deviceProperty.DevPropID);
      }

      // end enumerating
      // may return cdINVALID_HANDLE, cdINVALID_FN_CALL
      err = CDEnumDevicePropertyRelease(hEnum);
      if (err != cdOK) LOG_TRACE(_T("CDEnumDevicePropertyRelease(%08x) returned %08x\n"), hEnum, err);
      CheckError(_T("CDEnumDevicePropertyRelease"), err, __FILE__, __LINE__);

      return vecData;
   }
Esempio n. 2
0
//////////////////////////////////////////////////////////////////////////
// 
//  Function Name:  ConnectCamera 
//  Description:    Function that connects to camera 
//  Parameters:     CPictureWizardDlg * pCPictureWizardDlg - the dialog that calls this
//                  functions
//                  CStatic *m_cViewImage - picture box where viewfinder will be displayed                
//  Returns:        BOOL - true if successful, otherwise false
//  Summary:        Initially, GetCameraSource is called to get the camera information so we
//                  can connect to the camera called various cdSDK functions. One of the 
//                  obvious things that happens in this function is the camera turning on  
//  Author:         Adam Levy ([email protected])
//                           
///////////////////////////////////////////////////////////////////////////
BOOL CCameraConnect::ConnectCamera(CPictureWizardDlg* pCPictureWizardDlg, CStatic *m_cViewImage)
{
	cdError			err;
	cdSourceInfo	SSrcInfo;
	cdRelDataKind	Kind;
	
	m_CpViewFinder = m_cViewImage;
	this->pCPictureWizardDlg = pCPictureWizardDlg;
	
	err = GetCameraSource(&SSrcInfo);

	if( GETERRORID(err) != cdOK )
	{
		CameraError(err);
		return false;
	}
    
	if(SSrcInfo.SurceType == cdSRC_TYPE_INVALID)
	{	
		return false;
	}
	
	/* A device is opened. */
	err = CDOpenSource( &SSrcInfo, &m_hSource );
	
	
	
	if( GETERRORID(err) != cdOK )
	{
		CameraError(err);
		return false;
	}

	/* UI is locked so that information may not be changed. */
	//err = CDLockUI( m_hSource );
	//if( GETERRORID(err) != cdOK )
	//{
	//	goto	camerr;
	//}

	/* The function which receives the event from a camera is set up. */
	//err = CDRegisterEventCallbackFunction( m_hSource, CamCallBackFunc, (cdContext)this, &m_hCallbackFunction );
	//if( GETERRORID(err) != cdOK )
	//{
	//	goto	camerr;
	//}

	/* The existence of memory card is checked. */
	cdHEnum			hEnumVol;
	cdHVolume		hVolume;
	cdVolumeInfo	SVolInfo;
	
	m_fMCard = FALSE;
	/*Volumes are enumerated.*/
	err = CDEnumVolumeReset( m_hSource, &hEnumVol );
	if( GETERRORID(err) != cdOK )
	{
		CameraError(err);
		return FALSE;
	}
	
	/* It repeats until it enumerates all volumes. */
	while( (err = CDEnumVolumeNext( hEnumVol, &hVolume )) == cdOK )
	{
		/* The information on volume is acquired. */
		err = CDGetVolumeInfo( hVolume, &SVolInfo );
		if( GETERRORID(err) != cdOK )
		{
			CDEnumVolumeRelease( hEnumVol );
			CameraError(err);
			return false;
		}
		
		if( SVolInfo.TotalSpace )
		{
			m_fMCard = TRUE;
			break;
		}
	}
	
	//if( GETERRORID(err) != cdOK && GETERRORID(err) != cdENUM_NA)
	//{
	//	CDEnumVolumeRelease( hEnumVol );
	//	goto	camerr;
	//}
	
	/* Listing of volume is ended. */
	err = CDEnumVolumeRelease( hEnumVol );
	if( GETERRORID(err) != cdOK )
	{
		CameraError(err);
		return false;
	}

	cdHEnum		hEnum;
	cdUInt32	bufsize;
	cdChar		ModelName[32];
	err = CDEnumDevicePropertyReset(m_hSource, 0, &hEnum);
	if( GETERRORID(err) != cdOK )
	{
		CameraError(err);
		return false;
	}

	bufsize = sizeof(m_RelControlCap);
	//err = CDGetDevicePropertyData(m_hSource, cdDEVICE_PROP_RELEASE_CONTROL_CAP, &bufsize, &m_RelControlCap, 0);
	//if( GETERRORID(err) != cdOK )
	//{
	//	CDEnumDevicePropertyRelease(hEnum);
	//	goto	camerr;
	//}
	//if( m_RelControlCap&cdRELEASE_CONTROL_CAP_SUPPORT==0 ){
	//	err = cdNOT_SUPPORTED;
	//	goto camerr;
	//}

	bufsize = sizeof(ModelName);
	memset(ModelName, 0, bufsize);
	err = CDGetDevicePropertyData(m_hSource, cdDEVICE_PROP_MODEL_NAME, &bufsize, ModelName, 0);
	if( GETERRORID(err) != cdOK )
	{
		CDEnumDevicePropertyRelease(hEnum);
		CameraError(err);
		return false;
	}
	if( strstr(ModelName, "EOS") )
	{
		m_fCamTypeEOS = TRUE;
	}
	else
	{
		m_fCamTypeEOS = FALSE;
	}

	err = CDEnumDevicePropertyRelease(hEnum);
	hEnum = NULL;
	if( GETERRORID(err) != cdOK )
	{
		CameraError(err);
		return false;
	}

	/* A camera is set as remote release control mode. */
	//err = CDEnterReleaseControl( m_hSource, RelCallBackFunc, (cdContext)this );
	err = CDEnterReleaseControl( m_hSource, RelCallBackFunc, (cdContext)pCPictureWizardDlg );
	
	if( GETERRORID(err) != cdOK )
	{
		CameraError(err);
		return false;
	}
	
	// window commands
	//m_CConnect.EnableWindow( FALSE );
	//m_CDisconnect.EnableWindow( TRUE );
	//m_CRelChk1.EnableWindow( TRUE );
	//m_CRelChk2.EnableWindow( TRUE );

	if( m_RelControlCap&cdRELEASE_CONTROL_CAP_VIEWFINDER )
	{	
		// window commands
		//m_CViewFinder.EnableWindow( TRUE );
		//m_CAEAF.EnableWindow( TRUE );
	}

	//err = SetReleaseState();
	Kind =  cdREL_KIND_PICT_TO_PC;
	if( Kind )
		{
			// The Kind of Release is set up. 
			err = CDSelectReleaseDataKind( m_hSource, Kind );
			if( GETERRORID(err) != cdOK )
			{
				CameraError(err);
				return false;
			}
		}
	if( GETERRORID(err) != cdOK )
	{
		CDExitReleaseControl( m_hSource );
		CameraError(err);
		return false;
	}
	
	// change image size
	cdImageSizeSpec pSpec;
	cdUInt32 Option = 0;
	cdHEnum phEnum;
	cdUInt32 pCount;
	cdCompQuality pQuality;
	cdImageSize pSize;
	size_t index;
	
	// Prepare enumeration of image sizes
	err = CDEnumSupportedImageSizeReset(m_hSource, Option, &phEnum);
	if( GETERRORID(err) != cdOK )
	{
		CameraError(err);
		return false;
	}
	// Get count of image sizes 
	err = CDGetSupportedImageSizeCount(phEnum, &pCount);
	if( GETERRORID(err) != cdOK )
	{
		CameraError(err);
		return false;
	}
	
	for (index = 0; index<pCount; index++)
	{
		err = CDEnumSupportedImageSizeNext(phEnum, &pSpec);
		if( GETERRORID(err) != cdOK )
		{
			CameraError(err);
			return false;
		}
		// Found ideal image size
		if (pSpec.Size.Width == 640 && pSpec.Size.Height == 480)
		{
			break;
		}

	}
	// Release enumeration of image sizes
	CDEnumSupportedImageSizeRelease(phEnum);

	// Prepare enumeration of image quality
	CDEnumImageFormatAttributeReset(m_hSource, &phEnum);
	// Get count of image qualities 
	CDGetImageFormatAttributeCount(phEnum, &pCount);
	
	for(index = 0; index<pCount; index++)
	{
		err = CDEnumImageFormatAttributeNext(phEnum, &pQuality, &pSize); 
		if( GETERRORID(err) != cdOK )
		{
			CameraError(err);
			return false;
		}
		// We found the ideal size so exit
		if (pSize == pSpec.ImageSize)
			break;
	}

	//set resolution of saved image (1600x1200)
	pSize = cdIMAGE_SIZE_MEDIUM2;
	CDSetImageFormatAttribute(m_hSource, pQuality, pSize);
	
	err = CDEnumImageFormatAttributeRelease(phEnum);
	if( GETERRORID(err) != cdOK )
	{
		CameraError(err);
		return false;
	}
	CDSelectViewFinderCameraOutput(m_hSource, cdREL_FINDER_TO_LCD);
	return true;
}