dc1394_control.c

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

  
  err=GetCameraControlRegister(camera, offset, &quadval);
  DC1394_ERR_RTN(err, "Could not get feature %d auto status",feature);
  
  if (quadval & 0x04000000UL) {
    *mode= DC1394_FEATURE_MODE_ONE_PUSH_AUTO;
  }
  else if (quadval & 0x01000000UL) {
    *mode= DC1394_FEATURE_MODE_AUTO;
  }
  else {
    *mode= DC1394_FEATURE_MODE_MANUAL;
  }
  
  return err;
}

dc1394error_t
dc1394_feature_set_mode(dc1394camera_t *camera, dc1394feature_t feature, dc1394feature_mode_t mode)
{
  dc1394error_t err;
  octlet_t offset;
  quadlet_t curval;

  if (feature == DC1394_FEATURE_TRIGGER) {
    return DC1394_INVALID_FEATURE;
  }
  
  FEATURE_TO_VALUE_OFFSET(feature, offset);
  
  err=GetCameraControlRegister(camera, offset, &curval);
  DC1394_ERR_RTN(err, "Could not get feature %d register",feature);
  
  if ((mode==DC1394_FEATURE_MODE_AUTO) && !(curval & 0x01000000UL)) {
    curval|= 0x01000000UL;
    err=SetCameraControlRegister(camera, offset, curval);
    DC1394_ERR_RTN(err, "Could not set auto mode for feature %d",feature);
  }
  else if ((mode==DC1394_FEATURE_MODE_MANUAL) && (curval & 0x01000000UL)) {
    curval&= 0xFEFFFFFFUL;
    err=SetCameraControlRegister(camera, offset, curval);
    DC1394_ERR_RTN(err, "Could not set auto mode for feature %d",feature);
  }
  else if ((mode==DC1394_FEATURE_MODE_ONE_PUSH_AUTO)&& !(curval & 0x04000000UL)) {
    curval|= 0x04000000UL;
    err=SetCameraControlRegister(camera, offset, curval);
    DC1394_ERR_RTN(err, "Could not sart one-push capability for feature %d",feature);
  }
  
  return err;
}

dc1394error_t
dc1394_feature_get_boundaries(dc1394camera_t *camera, dc1394feature_t feature, uint_t *min, uint_t *max)
{
  dc1394error_t err;
  octlet_t offset;
  quadlet_t quadval;
  
  if (feature == DC1394_FEATURE_TRIGGER) {
    return DC1394_INVALID_FEATURE;
  }
  
  FEATURE_TO_INQUIRY_OFFSET(feature, offset);
  
  err=GetCameraControlRegister(camera, offset, &quadval);
  DC1394_ERR_RTN(err, "Could not get feature %d min value",feature);
  
  *min= (uint_t)((quadval & 0xFFF000UL) >> 12);
  *max= (uint_t)(quadval & 0xFFFUL);
  return err;
}

/*
 * Memory load/save functions
 */
dc1394error_t
dc1394_memory_get_save_ch(dc1394camera_t *camera, uint_t *channel)
{
  quadlet_t value;
  dc1394error_t err= GetCameraControlRegister(camera, REG_CAMERA_MEM_SAVE_CH, &value);
  DC1394_ERR_RTN(err, "Could not get memory save channel");
  *channel= (uint_t)((value >> 28) & 0xFUL);
  return err;
}


dc1394error_t
dc1394_memory_get_load_ch(dc1394camera_t *camera, uint_t *channel)
{
  quadlet_t value;
  dc1394error_t err= GetCameraControlRegister(camera, REG_CAMERA_CUR_MEM_CH, &value);
  DC1394_ERR_RTN(err, "Could not get memory load channel");
  *channel= (uint_t)((value >> 28) & 0xFUL);
  return err;
}


dc1394error_t
dc1394_memory_is_save_in_operation(dc1394camera_t *camera, dc1394bool_t *value)
{
  quadlet_t quadlet;
  dc1394error_t err= GetCameraControlRegister(camera, REG_CAMERA_MEMORY_SAVE, &quadlet);
  DC1394_ERR_RTN(err, "Could not get memory busy status");
  *value = (quadlet & DC1394_FEATURE_ON) >> 31;
  return err;
}

dc1394error_t
dc1394_memory_save(dc1394camera_t *camera, uint_t channel)
{
  dc1394error_t err=SetCameraControlRegister(camera, REG_CAMERA_MEM_SAVE_CH,
				  (quadlet_t)((channel & 0xFUL) << 28));
  DC1394_ERR_RTN(err, "Could not save memory channel");

  err=SetCameraControlRegister(camera, REG_CAMERA_MEMORY_SAVE, DC1394_FEATURE_ON);
  DC1394_ERR_RTN(err, "Could not save to memory");
  return err;
}

dc1394error_t
dc1394_memory_load(dc1394camera_t *camera, uint_t channel)
{
  dc1394error_t err=SetCameraControlRegister(camera, REG_CAMERA_CUR_MEM_CH,
				  (quadlet_t)((channel & 0xFUL) << 28));
  DC1394_ERR_RTN(err, "Could not load from memory");
  return err;
}

/*
 * Trigger functions
 */

dc1394error_t
dc1394_external_trigger_set_polarity(dc1394camera_t *camera, dc1394trigger_polarity_t polarity)
{
  dc1394error_t err;
  quadlet_t curval;
  
  err=GetCameraControlRegister(camera, REG_CAMERA_TRIGGER_MODE, &curval);
  DC1394_ERR_RTN(err, "Could not get trigger register");
  
  curval= (curval & 0xFEFFFFFFUL) | ((polarity & 0x1UL) << 24);
  err=SetCameraControlRegister(camera, REG_CAMERA_TRIGGER_MODE, curval);
  DC1394_ERR_RTN(err, "Could not set set trigger polarity");
  return err;
}

dc1394error_t
dc1394_external_trigger_get_polarity(dc1394camera_t *camera, dc1394trigger_polarity_t *polarity)
{
  quadlet_t value;
  dc1394error_t err= GetCameraControlRegister(camera, REG_CAMERA_TRIGGER_MODE, &value);
  DC1394_ERR_RTN(err, "Could not get trigger polarity");
  
  *polarity= (uint_t)( ((value >> 24) & 0x1UL) );
  return err;
}

dc1394error_t
dc1394_external_trigger_has_polarity(dc1394camera_t *camera, dc1394bool_t *polarity)
{
  dc1394error_t err;
  octlet_t offset;
  quadlet_t quadval;
  
  offset= REG_CAMERA_FEATURE_HI_BASE_INQ;
  
  err=GetCameraControlRegister(camera, offset + ((DC1394_FEATURE_TRIGGER - DC1394_FEATURE_MIN) * 0x04U), &quadval);
  DC1394_ERR_RTN(err, "Could not get trigger polarity capability");
  
  if (quadval & 0x02000000UL) {
    *polarity= DC1394_TRUE;
  }
  else {
    *polarity= DC1394_FALSE;
  }
  
  return err;
}

dc1394error_t
dc1394_external_trigger_set_power(dc1394camera_t *camera, dc1394switch_t pwr)
{
  dc1394error_t err=dc1394_feature_set_power(camera, DC1394_FEATURE_TRIGGER, pwr);
  DC1394_ERR_RTN(err, "Could not set external trigger");
  return err;
}

dc1394error_t
dc1394_external_trigger_get_power(dc1394camera_t *camera, dc1394switch_t *pwr)
{
  dc1394error_t err=dc1394_feature_get_power(camera, DC1394_FEATURE_TRIGGER, pwr);
  DC1394_ERR_RTN(err, "Could not set external trigger");
  return err;
}

dc1394error_t
dc1394_software_trigger_set_power(dc1394camera_t *camera, dc1394switch_t pwr)
{
  dc1394error_t err;

  if (pwr==DC1394_ON) {
    err=SetCameraControlRegister(camera, REG_CAMERA_SOFT_TRIGGER, DC1394_FEATURE_ON);
  }
  else {
    err=SetCameraControlRegister(camera, REG_CAMERA_SOFT_TRIGGER, DC1394_FEATURE_OFF);
  }
  DC1394_ERR_RTN(err, "Could not set software trigger");
  return err;
}

dc1394error_t
dc1394_software_trigger_get_power(dc1394camera_t *camera, dc1394switch_t *pwr)
{
  quadlet_t value;
  dc1394error_t err = GetCameraControlRegister(camera, REG_CAMERA_SOFT_TRIGGER, &value);
  DC1394_ERR_RTN(err, "Could not get software trigger status");
  
  *pwr = (value & DC1394_FEATURE_ON)? DC1394_ON : DC1394_OFF;

  return err;
}

dc1394error_t
dc1394_video_get_data_depth(dc1394camera_t *camera, unsigned int *depth)
{
  quadlet_t value;
  dc1394error_t err = GetCameraControlRegister(camera, REG_CAMERA_DATA_DEPTH, &value);
  DC1394_ERR_RTN(err, "Could not get video data depth");
  
  *depth = value & 0xFFUL;

  return err;
}

dc1394error_t
dc1394_feature_get_absolute_control(dc1394camera_t *camera, dc1394feature_t feature, dc1394switch_t *pwr)
{
  dc1394error_t err;
  octlet_t offset;
  quadlet_t quadval;
  
  FEATURE_TO_VALUE_OFFSET(feature, offset);
  
  err=GetCameraControlRegister(camera, offset, &quadval);
  DC1394_ERR_RTN(err, "Could not get get abs control for feature %d",feature);
  
  if (quadval & 0x40000000UL) {
    *pwr= DC1394_ON;
  }
  else {
    *pwr= DC1394_OFF;
  }
  
  return err;
}

dc1394error_t
dc1394_feature_set_absolute_control(dc1394camera_t *camera, dc1394feature_t feature, uint_t value)
{
  dc1394error_t err;
  octlet_t offset;
  quadlet_t curval;
  
  FEATURE_TO_VALUE_OFFSET(feature, offset);
  
  err=GetCameraControlRegister(camera, offset, &curval);
  DC1394_ERR_RTN(err, "Could not get abs setting status for feature %d",feature);
  
  if (value && !(curval & 0x40000000UL)) {
    curval|= 0x40000000UL;
    err=SetCameraControlRegister(camera, offset, curval);
    DC1394_ERR_RTN(err, "Could not set absolute control for feature %d",feature);
  }
  else if (!value && (curval & 0x40000000UL)) {
    curval&= 0xBFFFFFFFUL;
    err=SetCameraControlRegister(camera, offset, curval);
    DC1394_ERR_RTN(err, "Could not set absolute control for feature %d",feature);
  }
  
  return err;
}


dc1394error_t
dc1394_feature_has_absolute_control(dc1394camera_t *camera, dc1394feature_t feature, dc1394bool_t *value)
{
  dc1394error_t err;
  octlet_t offset;
  quadlet_t quadval;
  
  FEATURE_TO_INQUIRY_OFFSET(feature, offset);
  
  err=GetCameraControlRegister(camera, offset, &quadval);
  DC1394_ERR_RTN(err, "Could not get absolute control register for feature %d",feature);
  
  if (quadval & 0x40000000UL) {
    *value= DC1394_TRUE;
  }
  else {
    *value= DC1394_FALSE;
  }
  
  return err;
}


/* This function returns the bandwidth that is used by the camera *IF* ISO was ON.
   The returned value is in bandwidth units. The 1394 bus has 4915 bandwidth units
   available per cycle. Each unit corresponds to the time it takes to send one
   quadlet at ISO speed S1600. The bandwidth usage at S400 is thus four times the
   number of quadlets per packet. Thanks to Krisitian Hogsberg for clarifying this.
*/

dc1394error_t
dc1394_video_get_bandwidth_usage(dc1394camera_t *camera, uint_t *bandwidth)
{
  uint_t format, qpp;
  dc1394video_mode_t video_mode;
  dc1394speed_t speed;
  dc1394framerate_t framerate=0;
  dc1394error_t err;

  // get format and mode
  err=dc1394_video_get_mode(camera, &video_mode);
  DC1394_ERR_RTN(err, "Could not get video mode");
  
  err=_dc1394_get_format_from_mode(video_mode, &format);
  DC1394_ERR_RTN(err, "Invalid mode ID");
  
  if (format==DC1394_FORMAT7) {
    // use the bytes per packet value:
    err=dc1394_format7_get_byte_per_packet(camera, video_mode, &qpp);
    DC1394_ERR_RTN(err, "Could not get BPP");
    qpp=qpp/4;
  }
  else {
    // get the framerate:
    err=dc1394_video_get_framerate(camera, &framerate);
    DC1394_ERR_RTN(err, "Could not get framerate");
    err=_dc1394_get_quadlets_per_packet(video_mode, framerate, &qpp); 
  }
  // add the ISO header and footer:
  qpp+=3;
  
  // get camera ISO speed:
  err=dc1394_video_get_iso_speed(camera, &speed);
  DC1394_ERR_RTN(err, "Could not get ISO speed");
  
  // mutiply by 4 anyway because the best speed is SPEED_400 only
  if (speed>=DC1394_ISO_SPEED_1600)
    *bandwidth = qpp >> (speed-DC1394_ISO_SPEED_1600);
  else
    *bandwidth = qpp << (DC1394_ISO_SPEED_1600-speed);

  return err;
}

dc1394error_t
dc1394_video_specify_iso_channel(dc1394camera_t *camera, int iso_channel)
{
  if (camera->capture_is_set>0)
    return DC1394_CAPTURE_IS_RUNNING;
  
  camera->iso_channel=iso_channel;

  return DC1394_SUCCESS;
}

dc1394error_t
dc1394_feature_get_absolute_boundaries(dc1394camera_t *camera, dc1394feature_t feature, float *min, float *max)
{
  dc1394error_t err=DC1394_SUCCESS;
  
  if ( (feature > DC1394_FEATURE_MAX) || (feature < DC1394_FEATURE_MIN) ) {
    return DC1394_INVALID_FEATURE;
  }

  err=GetCameraAbsoluteRegister(camera, feature, REG_CAMERA_ABS_MAX, (quadlet_t*)max);
  DC1394_ERR_RTN(err,"Could not get maximal absolute value");
  err=GetCameraAbsoluteRegister(camera, feature, REG_CAMERA_ABS_MIN, (quadlet_t*)min);
  DC1394_ERR_RTN(err,"Could not get minimal absolute value");

  return err;
}


dc1394error_t
dc1394_feature_get_absolute_value(dc1394camera_t *camera, dc1394feature_t feature, float *value)
{
  dc1394error_t err=DC1394_SUCCESS;

  if ( (feature > DC1394_FEATURE_MAX) || (feature < DC1394_FEATURE_MIN) ) {
    return DC1394_INVALID_FEATURE;
  }
  err=GetCameraAbsoluteRegister(camera, feature, REG_CAMERA_ABS_VALUE, (quadlet_t*)value);
  DC1394_ERR_RTN(err,"Could not get current absolute value");

  return err;
}


dc1394error_t
dc1394_feature_set_absolute_value(dc1394camera_t *camera, dc1394feature_t feature, float value)
{
  dc1394error_t err=DC1394_SUCCESS;
  
  quadlet_t tempq;
  memcpy(&tempq,&value,4);

  if ( (feature > DC1394_FEATURE_MAX) || (feature < DC1394_FEATURE_MIN) ) {
    return DC1394_INVALID_FEATURE;
  }

  SetCameraAbsoluteRegister(camera, feature, REG_CAMERA_ABS_VALUE, tempq);
  DC1394_ERR_RTN(err,"Could not get current absolute value");

  return err;
}