dc1394_vendor_avt.c

This library provides functionality to control any camera that conforms to the 1394-Based Digital C

{
  dc1394error_t err;
  quadlet_t curval;
  
  /* Retrieve current timebase */        
  err=GetCameraAdvControlRegister(camera,REG_CAMERA_AVT_TIMEBASE, &curval);
  DC1394_ERR_RTN(err,"Could not get AVT timebase");
  
  curval = (curval & 0xFFFFFFF0UL) | ((timebase_id & 0xFUL ));   
  
  /* Set new timebase */     
  err=SetCameraAdvControlRegister(camera,REG_CAMERA_AVT_TIMEBASE, curval);
  DC1394_ERR_RTN(err,"Could not set AVT timebase");
  
  return DC1394_SUCCESS;
}


/************************************************************************/
/* Get Extented Shutter  						*/
/************************************************************************/
dc1394error_t
dc1394_avt_get_extented_shutter(dc1394camera_t *camera, uint_t *timebase_id)
{
  dc1394error_t err;
  quadlet_t value;
    
  /* Retrieve current extented shutter value */    
  err=GetCameraAdvControlRegister(camera,REG_CAMERA_AVT_EXTD_SHUTTER, &value);
  DC1394_ERR_RTN(err,"Could not get AVT extended shutter reg");
  
  /* Exposure Time in us: Bits 6..31 */
  *timebase_id =(uint_t)((value & 0xFFFFFFFUL));
        
  return DC1394_SUCCESS;
  
}


/************************************************************************/
/* Set Extented shutter							*/
/************************************************************************/
dc1394error_t
dc1394_avt_set_extented_shutter(dc1394camera_t *camera, uint_t timebase_id)
{
  dc1394error_t err;
  quadlet_t curval;
  
  /* Retrieve current extented shutter value */        
  err=GetCameraAdvControlRegister(camera,REG_CAMERA_AVT_EXTD_SHUTTER, &curval);
  DC1394_ERR_RTN(err,"Could not get AVT extended shutter reg");
  
  /* Time base ID : Bits 6..31 */
  curval = (curval & 0xF0000000UL) | ((timebase_id & 0x0FFFFFFFUL ));   
  
  /* Set new extented shutter value */    
  err=SetCameraAdvControlRegister(camera,REG_CAMERA_AVT_EXTD_SHUTTER, curval);
  DC1394_ERR_RTN(err,"Could not set AVT extended shutter reg");
  
  return DC1394_SUCCESS;
}


/************************************************************************/
/* Get MaxResolution  	(Read Only)					*/
/************************************************************************/
dc1394error_t
dc1394_avt_get_MaxResolution(dc1394camera_t *camera, uint_t *MaxHeight, uint_t *MaxWidth)
{
  dc1394error_t err;
  quadlet_t value;
  
  /* Retrieve the maximum resolution */    
  err=GetCameraAdvControlRegister(camera,REG_CAMERA_AVT_MAX_RESOLUTION, &value);
  DC1394_ERR_RTN(err,"Could not get AVT max resolution");
  
  /* MaxHeight : Bits 0..15 */
  *MaxHeight =(uint_t)(value >> 16);
  /* MaxWidth : Bits 16..31 */
  *MaxWidth =(uint_t)(value & 0xFFFFUL );      
       
  return DC1394_SUCCESS;
}


/************************************************************************/
/* Get Auto Shutter  							*/
/************************************************************************/
dc1394error_t
dc1394_avt_get_auto_shutter(dc1394camera_t *camera, uint_t *MinValue, uint_t *MaxValue)
{
  dc1394error_t err;
  quadlet_t value;
  
  /* Retrieve current min auto shutter value */    
  err=GetCameraAdvControlRegister(camera,REG_CAMERA_AVT_AUTOSHUTTER_LO, &value);
  DC1394_ERR_RTN(err,"Could not get AVT autoshutter LSB");
  
  *MinValue =(uint_t)value;
  
  /* Retrieve current max auto shutter value */    
  err=GetCameraAdvControlRegister(camera,REG_CAMERA_AVT_AUTOSHUTTER_HI, &value); 
  DC1394_ERR_RTN(err,"Could not get AVT autoshutter MSB");
  
  *MaxValue =(uint_t)value;
  
  return DC1394_SUCCESS;
}


/************************************************************************/
/* Set Auto shutter							*/
/************************************************************************/
dc1394error_t
dc1394_avt_set_auto_shutter(dc1394camera_t *camera, uint_t MinValue, uint_t MaxValue)
{
  dc1394error_t err;
  /* Set min auto shutter value */    
  err=SetCameraAdvControlRegister(camera,REG_CAMERA_AVT_AUTOSHUTTER_LO, MinValue);
  DC1394_ERR_RTN(err,"Could not set AVT autoshutter LSB");

  /* Set max auto shutter value */  
  err=SetCameraAdvControlRegister(camera,REG_CAMERA_AVT_AUTOSHUTTER_HI, MaxValue); 
  DC1394_ERR_RTN(err,"Could not set AVT autoshutter MSB");
  
  return DC1394_SUCCESS;
}


/************************************************************************/
/* Get Auto Gain  							*/
/************************************************************************/
dc1394error_t
dc1394_avt_get_auto_gain(dc1394camera_t *camera, uint_t *MinValue, uint_t *MaxValue)
{
  dc1394error_t err;
  quadlet_t value;
    
  /* Retrieve auto gain values */    
  err=GetCameraAdvControlRegister(camera,REG_CAMERA_AVT_AUTOGAIN_CTRL, &value);
  DC1394_ERR_RTN(err,"Could not get AVT autogain");
  
  /* Min : bits 20..31 */
  *MinValue =(uint_t)(value & 0xFFFUL);
  /* Max : bits 4..15 */
  *MaxValue =(uint_t)((value >> 16) & 0xFFFUL);
  
  return DC1394_SUCCESS;
}


/************************************************************************/
/* Set Auto gain							*/
/************************************************************************/
dc1394error_t
dc1394_avt_set_auto_gain(dc1394camera_t *camera, uint_t MinValue, uint_t MaxValue)
{
  dc1394error_t err;
  quadlet_t value;    
  
  /* Max : bits 4..15, Min : bits 20..31  */
  value = ( MaxValue <<16 ) | ( MinValue );
  
  /* Set new parameters */    
  err=SetCameraAdvControlRegister(camera,REG_CAMERA_AVT_AUTOGAIN_CTRL,value);
  DC1394_ERR_RTN(err,"Could not set AVT autogain");

  return DC1394_SUCCESS;
}


/************************************************************************/
/* Get Trigger delay							*/
/************************************************************************/
dc1394error_t
dc1394_avt_get_trigger_delay(dc1394camera_t *camera, dc1394bool_t *on_off, uint_t *DelayTime)
{
  dc1394error_t err;
  quadlet_t value;
  
  /* Retrieve trigger delay */    
  err=GetCameraAdvControlRegister(camera,REG_CAMERA_AVT_TRIGGER_DELAY, &value);
  DC1394_ERR_RTN(err,"Could not get AVT trigger delay");
  
  /* trigger_delay ON / OFF : Bit 6 */
  *on_off = (uint_t)((value & 0x2000000UL) >> 25); 
  
  /* Delai time in us : Bits 11..31 */
  *DelayTime =(uint_t)((value & 0xFFFFFUL));

  return DC1394_SUCCESS;
}


/************************************************************************/
/* Set Trigger delay							*/
/************************************************************************/
dc1394error_t
dc1394_avt_set_trigger_delay(dc1394camera_t *camera, dc1394bool_t on_off, uint_t DelayTime)
{
  dc1394error_t err;
  quadlet_t curval;
  
  /* Retrieve trigger delay */       
  err=GetCameraAdvControlRegister(camera,REG_CAMERA_AVT_TRIGGER_DELAY, &curval);
  DC1394_ERR_RTN(err,"Could not get AVT trigger delay");
  
  /* trigger_delay ON / OFF : Bit 6 */
  curval = (curval & 0xFDFFFFFFUL) | ((on_off ) << 25); 
  
  /* Delay time in us : Bits 11..31 */
  curval = (curval & 0xFFF00000UL) | DelayTime;   
  
  /* Set new parameters */     
  err=SetCameraAdvControlRegister(camera,REG_CAMERA_AVT_TRIGGER_DELAY, curval);
  DC1394_ERR_RTN(err,"Could not set AVT trigger delay");
  
  return DC1394_SUCCESS;
}


/************************************************************************/
/* Get Mirror 								*/
/************************************************************************/
dc1394error_t
dc1394_avt_get_mirror(dc1394camera_t *camera, dc1394bool_t *on_off)
{
  dc1394error_t err;
  quadlet_t value;

  /* Retrieve Mirror mode */
  err=GetCameraAdvControlRegister(camera,REG_CAMERA_AVT_MIRROR_IMAGE, &value);
  DC1394_ERR_RTN(err,"Could not get AVT mirror image");
  
  /* mirror ON / OFF : Bit 6 */
  *on_off = (uint_t)((value & 0x2000000UL) >> 25); 
       
  return DC1394_SUCCESS;
}

/************************************************************************/
/* Set Mirror								*/
/************************************************************************/
dc1394error_t
dc1394_avt_set_mirror(dc1394camera_t *camera, dc1394bool_t on_off)
{
  dc1394error_t err;
  quadlet_t curval;
  
  /* ON / OFF : Bit 6 */
  curval = on_off << 25; 
  
  /* Set mirror mode */     
  err=SetCameraAdvControlRegister(camera,REG_CAMERA_AVT_MIRROR_IMAGE, curval);
  DC1394_ERR_RTN(err,"Could not set AVT mirror image");
  
  return DC1394_SUCCESS;
}

/************************************************************************/
/* Get DSNU 								*/
/************************************************************************/
dc1394error_t
dc1394_avt_get_dsnu(dc1394camera_t *camera, dc1394bool_t *on_off,uint_t *frame_nb)
{
  dc1394error_t err;
  quadlet_t value;
  /* Retrieve dsnu parameters */        
  err=GetCameraAdvControlRegister(camera,REG_CAMERA_AVT_DSNU_CONTROL, &value);
  DC1394_ERR_RTN(err,"Could not get AVT DSNU control");
  
  /* ON / OFF : Bit 6 */
  *on_off = !(uint_t)((value & 0x2000000UL) >> 25); 
  
  /* Number of images : Bits 24..31 */
  *frame_nb =(uint_t)((value & 0xFFUL));
    
  return DC1394_SUCCESS;
}

/************************************************************************/
/* Set DSNU								*/
/************************************************************************/
dc1394error_t
dc1394_avt_set_dsnu(dc1394camera_t *camera,
		    dc1394bool_t on_off, dc1394bool_t compute, uint_t frame_nb)
{
  dc1394error_t err;
  quadlet_t curval;

  /* Retrieve current dsnu parameters */            
  err=GetCameraAdvControlRegister(camera,REG_CAMERA_AVT_DSNU_CONTROL, &curval);
  DC1394_ERR_RTN(err,"Could not get AVT DSNU control");
  
  /* Compute : Bit 5 */
  curval = (curval & 0xFBFFFFFFUL) | ((compute ) << 26); 
  
  /* ON / OFF : Bit 6 */
  curval = (curval & 0xFDFFFFFFUL) | ((!on_off ) << 25); 
  
  /* Number of images : Bits 24..31 */
  curval = (curval & 0xFFFFFF00UL) | ((frame_nb & 0xFFUL ));   
  
  /* Set new dsnu parameters */        
  err=SetCameraAdvControlRegister(camera,REG_CAMERA_AVT_DSNU_CONTROL, curval);
  DC1394_ERR_RTN(err,"Could not set AVT DSNU control");

  int cont=1;
  while (cont) {
    usleep(50000);
    err=GetCameraAdvControlRegister(camera,REG_CAMERA_AVT_DSNU_CONTROL, &curval);
    DC1394_ERR_RTN(err,"Could not get AVT DSNU control");
    if ((curval & 0x01000000UL)==0)
      cont=0;
  }
  return DC1394_SUCCESS;
}

/************************************************************************/
/* Get BLEMISH 								*/
/************************************************************************/
dc1394error_t
dc1394_avt_get_blemish(dc1394camera_t *camera, dc1394bool_t *on_off, uint_t *frame_nb)
{
  dc1394error_t err;
  quadlet_t value;
  
  err=GetCameraAdvControlRegister(camera,REG_CAMERA_AVT_BLEMISH_CONTROL, &value);
  DC1394_ERR_RTN(err,"Could not get AVT blemish control");
  
  /* ON / OFF : Bit 6 */
  *on_off = (uint_t)((value & 0x2000000UL) >> 25); 
  
  /* Number of images : Bits 24..31 */
  *frame_nb =(uint_t)((value & 0xFFUL));
    
  return DC1394_SUCCESS;
}

/************************************************************************/
/* Set BLEMISH								*/
/************************************************************************/
dc1394error_t
dc1394_avt_set_blemish(dc1394camera_t *camera,
		       dc1394bool_t on_off, dc1394bool_t compute, uint_t frame_nb)
{
  dc1394error_t err;
  quadlet_t curval;
  
  /* Retrieve current blemish parameters */        
  err=GetCameraAdvControlRegister(camera,REG_CAMERA_AVT_BLEMISH_CONTROL, &curval);
  DC1394_ERR_RTN(err,"Could not get AVT blemish control");
  
  /* Compute : Bit 5 */
  curval = (curval & 0xFBFFFFFFUL) | ((compute ) << 26); 
  
  /* ON / OFF : Bit 6 */
  curval = (curval & 0xFDFFFFFFUL) | ((on_off ) << 25); 
  
  /* Number of images : Bits 24..31 */
  curval = (curval & 0xFFFFFF00UL) | ((frame_nb & 0xFFUL ));   
  
  /* Set new blemish parameters */         
  err=SetCameraAdvControlRegister(camera,REG_CAMERA_AVT_BLEMISH_CONTROL, curval);
  DC1394_ERR_RTN(err,"Could not set AVT blemish control");
  
  int cont=1;
  while (cont) {
    usleep(50000);
    err=GetCameraAdvControlRegister(camera,REG_CAMERA_AVT_BLEMISH_CONTROL, &curval);
    DC1394_ERR_RTN(err,"Could not get AVT DSNU control");
    if ((curval & 0x01000000UL)==0)
      cont=0;
  }

  return DC1394_SUCCESS;
}



/************************************************************************/
/* Get IO	REG_CAMERA_AVT_IO_INP_CTRLx	or REG_CAMERA_AVT_IO_OUTP_CTRLx	*/
/************************************************************************/
dc1394error_t
dc1394_avt_get_io(dc1394camera_t *camera, uint_t IO,
		  dc1394bool_t *polarity, uint_t *mode, dc1394bool_t *pinstate)
{
  dc1394error_t err;
  quadlet_t value;
  
  /* Retrieve IO parameters */        
  err=GetCameraAdvControlRegister(camera,IO, &value);
  DC1394_ERR_RTN(err,"Could not get AVT IO register");
 
  /* polarity : Bit 7 */
  *polarity = (uint_t)((value & 0x1000000UL) >> 24); 
  
  /* pinstate : Bit 31 */
  *pinstate = (uint_t)((value & 0x1UL)); 
  
  /* mode : Bits 11..15 */
  *mode =(uint_t)((value >> 16 ) & 0x1FUL);
         
  return DC1394_SUCCESS;
}

/************************************************************************/
/* Set IO	REG_CAMERA_AVT_IO_INP_CTRLx	or REG_CAMERA_AVT_IO_OUTP_CTRLx	*/
/************************************************************************/
dc1394error_t
dc1394_avt_set_io(dc1394camera_t *camera,uint_t IO,
		  dc1394bool_t polarity, uint_t mode)
{
  dc1394error_t err;
  quadlet_t curval;
  
  /* Retrieve current IO parameters */            
  err=GetCameraAdvControlRegister(camera,IO, &curval);
  DC1394_ERR_RTN(err,"Could not get AVT IO register");