dc1394_vendor_avt.c

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

  
  /* polarity : Bit 7 */
  curval = (curval & 0xFEFFFFFFUL) | ((polarity ) << 24); 
  
  /* mode : Bits 11..15 */
  curval = (curval & 0xFFE0FFFFUL) | ((mode << 16) & 0x1F0000UL );   
  
  /* Set  new IO parameters */            
  err=SetCameraAdvControlRegister(camera,IO, curval);
  DC1394_ERR_RTN(err,"Could not set AVT IO register");
  
  return DC1394_SUCCESS;
}

/************************************************************************/
/* BusReset IEEE1394							*/
/************************************************************************/
dc1394error_t
dc1394_avt_reset(dc1394camera_t *camera)
{
  dc1394error_t err;
  quadlet_t value;
  /* ON / OFF : Bit 6 */
  value= (1<<25) + 200; /*2sec*/
  /* Reset */                    
  err=SetCameraAdvControlRegister(camera,REG_CAMERA_AVT_SOFT_RESET,value); 
  DC1394_ERR_RTN(err,"Could not set AVT soft reset");

  return DC1394_SUCCESS;
}


/************************************************************************/
/* Get Lookup Tables (LUT)						*/
/************************************************************************/
dc1394error_t
dc1394_avt_get_lut(dc1394camera_t *camera, dc1394bool_t *on_off, uint_t *lutnb)
{
  dc1394error_t err;
  quadlet_t value;
  
  /* Retrieve current luts parameters */            
  err=GetCameraAdvControlRegister(camera,REG_CAMERA_AVT_LUT_CTRL, &value);
  DC1394_ERR_RTN(err,"Could not get AVT LUT control");
  
  /* Shading ON / OFF : Bit 6 */
  *on_off = (uint_t)((value & 0x2000000UL) >> 25); 
  
  /* Number of lut : Bits 26..31 */
  *lutnb =(uint_t)((value & 0x3FUL));
       
  return DC1394_SUCCESS;
}


/************************************************************************/
/* Set Lookup Tables (LUT)						*/
/************************************************************************/
dc1394error_t
dc1394_avt_set_lut(dc1394camera_t *camera, dc1394bool_t on_off, uint_t lutnb)
{
  dc1394error_t err;
  quadlet_t curval;
  
  /* Retrieve current luts parameters */                
  err=GetCameraAdvControlRegister(camera,REG_CAMERA_AVT_LUT_CTRL, &curval);
  DC1394_ERR_RTN(err,"Could not get AVT LUT control");
  
  /* Shading ON / OFF : Bit 6 */
  curval = (curval & 0xFDFFFFFFUL) | ((on_off ) << 25); 
  
  /* Number of lut : Bits 26..31 */
  curval = (curval & 0xFFFFFFB0UL) | ((lutnb & 0x3FUL ));   
  
  /* Set new luts parameters */            
  err=SetCameraAdvControlRegister(camera,REG_CAMERA_AVT_LUT_CTRL, curval);
  DC1394_ERR_RTN(err,"Could not set AVT LUT control");

  return DC1394_SUCCESS;
}


/************************************************************************/
/* Get LUT ctrl								*/
/************************************************************************/
dc1394error_t
dc1394_avt_get_lut_mem_ctrl(dc1394camera_t *camera, dc1394bool_t *en_write, 
			    uint_t * AccessLutNo,uint_t *addroffset)
{
  dc1394error_t err;
  quadlet_t value;
  
  /* Retrieve current memory luts parameters */                
  err=GetCameraAdvControlRegister(camera,REG_CAMERA_AVT_LUT_MEM_CTRL, &value);
  DC1394_ERR_RTN(err,"Could not get AVT LUT memory control");
 
  /* Enable write access : Bit 5 */
  *en_write = (uint_t)((value & 0x4000000UL) >> 26); 
  
  /* AccessLutNo : Bits 8..15 */
  *AccessLutNo=(uint_t)((value >> 16) & 0xFFUL);
  
  /* addroffset in byte : Bits 16..31 */
  *addroffset =(uint_t)((value & 0xFFFFUL));

  return DC1394_SUCCESS;
}


/************************************************************************/
/* Set LUT ctrl					         		*/
/************************************************************************/
dc1394error_t
dc1394_avt_set_lut_mem_ctrl(dc1394camera_t *camera,
			    dc1394bool_t en_write, uint_t AccessLutNo, uint_t addroffset)
{
  dc1394error_t err;
  quadlet_t curval;
  
  /* Retrieve current memory luts parameters */                    
  err=GetCameraAdvControlRegister(camera,REG_CAMERA_AVT_LUT_MEM_CTRL, &curval);
  DC1394_ERR_RTN(err,"Could not get AVT LUT memory control");
  
  /* write access enable : Bit 5 */
  curval = (curval & 0xFBFFFFFFUL) | ((en_write ) << 26); 
  
  /* AccessLutNo : Bits 8..15 */
  curval = (curval & 0xFF00FFFFUL) | ((AccessLutNo << 16) & 0xFF0000UL );   
  
  /* Number of images : Bits 16..31 */
  curval = (curval & 0xFFFF0000UL) | ((addroffset & 0xFFFFUL ));   
  
  /* Set new parameters */     
  err=SetCameraAdvControlRegister(camera,REG_CAMERA_AVT_LUT_MEM_CTRL, curval);
  DC1394_ERR_RTN(err,"Could not set AVT LUT memory control");
  
  return DC1394_SUCCESS;
}


/************************************************************************/
/* Get LUT  info							*/
/************************************************************************/
dc1394error_t
dc1394_avt_get_lut_info(dc1394camera_t *camera, uint_t *NumOfLuts, uint_t *MaxLutSize)
{
  dc1394error_t err;
  quadlet_t value;
  /* Retrieve luts info */                
  err=GetCameraAdvControlRegister(camera,REG_CAMERA_AVT_LUT_INFO, &value);
  DC1394_ERR_RTN(err,"Could not get AVT LUT info");

  /* NumOfLuts : Bits 8..15 */
  *NumOfLuts=(uint_t)((value >> 16) & 0xFFUL);
  
  /* MaxLutSize : Bits 16..31 */
  *MaxLutSize =(uint_t)((value & 0xFFFFUL));

  return DC1394_SUCCESS;
}



/************************************************************************/
/* Get Automatic white balance	with Area Of Interest AOI		*/
/************************************************************************/
dc1394error_t
dc1394_avt_get_aoi(dc1394camera_t *camera, 
		   dc1394bool_t *on_off, int *left, int *top, int *width, int *height)
{
  dc1394error_t err;
  quadlet_t value;
  
  /* Retrieve current mode*/                
  err=GetCameraAdvControlRegister(camera,REG_CAMERA_AVT_AUTOFNC_AOI, &value);
  DC1394_ERR_RTN(err,"Could not get AVT autofocus AOI");
  
  /*  ON / OFF : Bit 6 */
  *on_off = (uint_t)((value & 0x2000000UL) >> 25); 
  
  /* Retrieve current size of area*/                      
  err=GetCameraAdvControlRegister(camera,REG_CAMERA_AVT_AF_AREA_SIZE, &value);
  DC1394_ERR_RTN(err,"Could not get AVT AF area size");
    
  /* width : Bits 0..15 */
  *width =(uint_t)(value >> 16);
  /* height : Bits 16..31 */
  *height =(uint_t)(value & 0xFFFFUL );
  
  /* Retrieve current position of area*/                      	
  err=GetCameraAdvControlRegister(camera,REG_CAMERA_AVT_AF_AREA_POSITION, &value);
  DC1394_ERR_RTN(err,"Could not get AVT AF area position");

  /* left : Bits 0..15 */
  *left =(uint_t)(value >> 16);
  /* top : Bits 16..31 */
  *top =(uint_t)(value & 0xFFFFUL );

  return DC1394_SUCCESS;
}

/************************************************************************/
/* Set Automatic white balance with Area Of Interest AOI		*/
/************************************************************************/
dc1394error_t
dc1394_avt_set_aoi(dc1394camera_t *camera,
		   dc1394bool_t on_off,int left, int top, int width, int height)
{
  dc1394error_t err;
  quadlet_t curval;
  
  /* ON / OFF : Bit 6 */
  curval = on_off << 25; 
  
  /* Set feature on off */
  err=SetCameraAdvControlRegister(camera,REG_CAMERA_AVT_AUTOFNC_AOI, curval);
  DC1394_ERR_RTN(err,"Could not set AVT autofocus AOI");
  
  /* Set size */
  err=SetCameraAdvControlRegister(camera,REG_CAMERA_AVT_AF_AREA_SIZE, (width << 16) | height);
  DC1394_ERR_RTN(err,"Could not set AVT AF area size");
  
  /* Set position */  
  err=SetCameraAdvControlRegister(camera,REG_CAMERA_AVT_AF_AREA_POSITION,(left << 16) | top );
  DC1394_ERR_RTN(err,"Could not set AVT AF area position");
  
  return DC1394_SUCCESS;
}

/************************************************************************/
/* Get test_images							*/
/************************************************************************/
dc1394error_t
dc1394_avt_get_test_images(dc1394camera_t *camera, uint_t *image_no)
{
  dc1394error_t err;
  quadlet_t value;
  
  /* Retrieve test image number */
  err=GetCameraAdvControlRegister(camera,REG_CAMERA_AVT_TEST_IMAGE, &value);
  DC1394_ERR_RTN(err,"Could not get AVT test image");
  
  /* Numero Image : Bits 28..31 */
  *image_no =(uint_t)((value & 0xFUL));    
  
  return DC1394_SUCCESS;
}


/************************************************************************/
/* Set test_images							*/
/************************************************************************/
dc1394error_t
dc1394_avt_set_test_images(dc1394camera_t *camera, uint_t image_no)
{
  dc1394error_t err;
  quadlet_t curval;

  /* Retrieve current test image */
  err=GetCameraAdvControlRegister(camera,REG_CAMERA_AVT_TEST_IMAGE, &curval);
  DC1394_ERR_RTN(err,"Could not get AVT test image");
  
  /* Numero Image : Bits 28..31 */
  curval = (curval & 0xFFFFFFF0UL) | ((image_no & 0xFUL ));   
  
  /* Set new test image */
  err=SetCameraAdvControlRegister(camera,REG_CAMERA_AVT_TEST_IMAGE,curval);
  DC1394_ERR_RTN(err,"Could not set AVT test image");
  
  return DC1394_SUCCESS;
}


/************************************************************************/
/* Get frame info							*/
/************************************************************************/
dc1394error_t
dc1394_avt_get_frame_info(dc1394camera_t *camera, uint_t *framecounter)
{
  dc1394error_t err;
  quadlet_t value;
  
  /* Retrieve frame info */
  err=GetCameraAdvControlRegister(camera,REG_CAMERA_AVT_FRAMECOUNTER, &value);
  DC1394_ERR_RTN(err,"Could not get AVT framecounter");
  
  /* framecounter : Bits 0..31 */
  *framecounter =(uint_t)(value);    
  
  return DC1394_SUCCESS;
}


/************************************************************************/
/* Reset frame info							*/
/************************************************************************/
dc1394error_t
dc1394_avt_reset_frame_info(dc1394camera_t *camera)
{
  dc1394error_t err;
  /* Reset counter */
  err=SetCameraAdvControlRegister(camera,REG_CAMERA_AVT_FRAMEINFO,1 << 30);
  DC1394_ERR_RTN(err,"Could not get AVT frame info");

  return DC1394_SUCCESS;
}

/************************************************************************/
/* Get Deferred image transport						*/
/************************************************************************/
dc1394error_t
dc1394_avt_get_deferred_trans(dc1394camera_t *camera, 
			      dc1394bool_t *HoldImage, dc1394bool_t * FastCapture,
			      uint_t *FifoSize, uint_t *NumOfImages )
{
  dc1394error_t err;
  quadlet_t value;
  
  /* Retrieve Deferred image transport mode */
  err=GetCameraAdvControlRegister(camera,REG_CAMERA_AVT_DEFERRED_TRANS, &value);
  DC1394_ERR_RTN(err,"Could not get AVT deferred transfer info");
  
  /* enable/disable deferred transport mode : Bit 6 */
  *HoldImage = (uint_t)((value & 0x2000000UL) >> 25); 
  
  /* enable/disable fast capture mode (format 7 only) : Bit 7 */
  *FastCapture = (uint_t)((value & 0x1000000UL) >> 24); 
  
  /* Size of fifo in number of image : Bits 16..23 */
  *FifoSize =(uint_t)((value >> 8 & 0xFFUL));
  
  /* Number of images in buffer: Bits 24..31 */
  *NumOfImages =(uint_t)((value & 0xFFUL));
       
  return DC1394_SUCCESS;
}


/************************************************************************/
/* Set Deferred image transport						*/
/************************************************************************/
dc1394error_t
dc1394_avt_set_deferred_trans(dc1394camera_t *camera,
			      dc1394bool_t HoldImage, dc1394bool_t FastCapture,
			      uint_t FifoSize, uint_t NumOfImages,
			      dc1394bool_t SendImage)
{
  dc1394error_t err;
  quadlet_t curval;
  
  /* Retrieve current image transport mode */
  err=GetCameraAdvControlRegister(camera,REG_CAMERA_AVT_DEFERRED_TRANS, &curval);
  DC1394_ERR_RTN(err,"Could not get AVT deferred transfer info");
  
  /* Send NumOfImages now : Bit 5 */
  curval = (curval & 0xFBFFFFFFUL) | ((SendImage ) << 26); 
  
  /* enable/disable deferred transport mode : Bit 6 */
  curval = (curval & 0xFDFFFFFFUL) | ((HoldImage ) << 25); 
  
  /* enable/disable fast capture mode (format 7 only) : Bit 7 */       
  curval = (curval & 0xFEFFFFFFUL) | ((FastCapture ) << 24);  
  
  /* Size of fifo in number of image : Bits 16..23 */
  curval = (curval & 0xFFFF00FFUL) | (((FifoSize << 8) & 0xFF00UL ));   
  
  /* Number of images : Bits 24..31 */
  curval = (curval & 0xFFFFFF00UL) | ((NumOfImages & 0xFFUL ));   
  
  /* Set new parameters */    
  err=SetCameraAdvControlRegister(camera,REG_CAMERA_AVT_DEFERRED_TRANS, curval);
  DC1394_ERR_RTN(err,"Could not set AVT deferred transfer info");

  return DC1394_SUCCESS;
}



/************************************************************************/
/* Get GPData info							*/
/************************************************************************/
dc1394error_t
dc1394_avt_get_gpdata_info(dc1394camera_t *camera, uint_t *BufferSize)
{
  dc1394error_t err;
  quadlet_t value;
  /* Retrieve info on the general purpose buffer */
  err=GetCameraAdvControlRegister(camera,REG_CAMERA_AVT_GPDATA_INFO, &value);
  DC1394_ERR_RTN(err,"Could not get AVT GP data info");
  
  /* BufferSize : Bits 16..31 */
  *BufferSize =(uint_t)((value & 0xFFFFUL));    
  
  return DC1394_SUCCESS;
}


/************************************************************************/
/* Get pdata_buffer : experimental, does not work			*/
/************************************************************************/
dc1394error_t
dc1394_avt_get_pdata_buffer(dc1394camera_t *camera, uint_t *buff)
{
  return DC1394_FAILURE ;       
}


/************************************************************************/
/* Set pdata_buffer	experimental, does not work			*/
/************************************************************************/
dc1394error_t
dc1394_avt_set_pdata_buffer(dc1394camera_t *camera, unsigned long buff)
{
  return DC1394_FAILURE;
}