dc1394_control.c

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

  }

  switch (format) {
  case DC1394_FORMAT0:
    video_mode-=DC1394_VIDEO_MODE_FORMAT0_MIN;
    break;
  case DC1394_FORMAT1:
    video_mode-=DC1394_VIDEO_MODE_FORMAT1_MIN;
    break;
  case DC1394_FORMAT2:
    video_mode-=DC1394_VIDEO_MODE_FORMAT2_MIN;
    break;
  }
  format-=DC1394_FORMAT_MIN;
  

  err=GetCameraControlRegister(camera,REG_CAMERA_V_RATE_INQ_BASE + (format * 0x20U) + (video_mode * 0x04U), &value);
  DC1394_ERR_RTN(err, "Could not get supported framerates");

  framerates->num=0;
  for (framerate=DC1394_FRAMERATE_MIN;framerate<=DC1394_FRAMERATE_MAX;framerate++) {
    if ((value & (0x1<<(31-(framerate-DC1394_FRAMERATE_MIN))))>0) {
      framerates->framerates[framerates->num]=framerate;
      framerates->num++;
    }
  }

  return err;
}


dc1394error_t
dc1394_video_get_framerate(dc1394camera_t *camera, dc1394framerate_t *framerate)
{
  quadlet_t value;
  dc1394error_t err;

  err=GetCameraControlRegister(camera, REG_CAMERA_FRAME_RATE, &value);
  DC1394_ERR_RTN(err, "Could not get video framerate");
  
  *framerate= (uint_t)((value >> 29) & 0x7UL) + DC1394_FRAMERATE_MIN;
  
  return err;
}

dc1394error_t
dc1394_video_set_framerate(dc1394camera_t *camera, dc1394framerate_t framerate)
{ 
  dc1394error_t err;
  if ( (framerate < DC1394_FRAMERATE_MIN) || (framerate > DC1394_FRAMERATE_MAX) ) {
    return DC1394_INVALID_FRAMERATE;
  }

  if (camera->capture_is_set>0)
    return DC1394_CAPTURE_IS_RUNNING;
  
  err=SetCameraControlRegister(camera, REG_CAMERA_FRAME_RATE,
			       (quadlet_t)(((framerate - DC1394_FRAMERATE_MIN) & 0x7UL) << 29));
  DC1394_ERR_RTN(err, "Could not set video framerate");

  return err;
}

dc1394error_t
dc1394_video_get_mode(dc1394camera_t *camera, dc1394video_mode_t *mode)
{
  dc1394error_t err;
  quadlet_t value;
  uint_t format;
  
  err= GetCameraControlRegister(camera, REG_CAMERA_VIDEO_FORMAT, &value);
  DC1394_ERR_RTN(err, "Could not get video format");

  format= (uint_t)((value >> 29) & 0x7UL) + DC1394_FORMAT_MIN;
  
  //if (format>FORMAT2)
  //format-=3;

  //fprintf(stderr,"format: %d\n",format);

  err= GetCameraControlRegister(camera, REG_CAMERA_VIDEO_MODE, &value);
  DC1394_ERR_RTN(err, "Could not get video mode");
  
  switch(format) {
  case DC1394_FORMAT0:
    *mode= (uint_t)((value >> 29) & 0x7UL) + DC1394_VIDEO_MODE_FORMAT0_MIN;
    break;
  case DC1394_FORMAT1:
    *mode= (uint_t)((value >> 29) & 0x7UL) + DC1394_VIDEO_MODE_FORMAT1_MIN;
    break;
  case DC1394_FORMAT2:
    *mode= (uint_t)((value >> 29) & 0x7UL) + DC1394_VIDEO_MODE_FORMAT2_MIN;
    break;
  case DC1394_FORMAT6:
    *mode= (uint_t)((value >> 29) & 0x7UL) + DC1394_VIDEO_MODE_FORMAT6_MIN;
    break;
  case DC1394_FORMAT7:
    *mode= (uint_t)((value >> 29) & 0x7UL) + DC1394_VIDEO_MODE_FORMAT7_MIN;
    break;
  default:
    return DC1394_INVALID_VIDEO_FORMAT;
    break;
  }
  
  return err;
}

dc1394error_t
dc1394_video_set_mode(dc1394camera_t *camera, dc1394video_mode_t  mode)
{
  uint_t format, min;
  dc1394error_t err;
  
  if (camera->capture_is_set>0)
    return DC1394_CAPTURE_IS_RUNNING;

  if ((mode<DC1394_VIDEO_MODE_MIN)||(mode>DC1394_VIDEO_MODE_MAX))
    return DC1394_INVALID_VIDEO_MODE;

  err=_dc1394_get_format_from_mode(mode, &format);
  DC1394_ERR_RTN(err, "Invalid video mode code");
  
  switch(format) {
  case DC1394_FORMAT0:
    min= DC1394_VIDEO_MODE_FORMAT0_MIN;
    break;
  case DC1394_FORMAT1:
    min= DC1394_VIDEO_MODE_FORMAT1_MIN;
    break;
  case DC1394_FORMAT2:
    min= DC1394_VIDEO_MODE_FORMAT2_MIN;
    break;
  case DC1394_FORMAT6:
    min= DC1394_VIDEO_MODE_FORMAT6_MIN;
    break;
  case DC1394_FORMAT7:
    min= DC1394_VIDEO_MODE_FORMAT7_MIN;
    break;
  default:
    return DC1394_INVALID_VIDEO_MODE;
    break;
  }

  //if (format>FORMAT2)
  //  format+=DC1394_FORMAT_GAP;
  
  err=SetCameraControlRegister(camera, REG_CAMERA_VIDEO_FORMAT, (quadlet_t)(((format - DC1394_FORMAT_MIN) & 0x7UL) << 29));
  DC1394_ERR_RTN(err, "Could not set video format");

  err=SetCameraControlRegister(camera, REG_CAMERA_VIDEO_MODE, (quadlet_t)(((mode - min) & 0x7UL) << 29));
  DC1394_ERR_RTN(err, "Could not set video mode");

  return err;
  
}

dc1394error_t
dc1394_video_get_iso_speed(dc1394camera_t *camera, dc1394speed_t *speed)
{
  dc1394error_t err;
  quadlet_t value;
  
  err=GetCameraControlRegister(camera, REG_CAMERA_ISO_DATA, &value);
  DC1394_ERR_RTN(err, "Could not get ISO data");

  if (camera->bmode_capable) { // check if 1394b is available
    if (value & 0x00008000) { //check if we are now using 1394b
      *speed= (uint_t)(value& 0x7UL);
    }
    else { // fallback to legacy
      *speed= (uint_t)((value >> 24) & 0x3UL);
    }
  }
  else { // legacy
    *speed= (uint_t)((value >> 24) & 0x3UL);
  }
  
  return err;
}

dc1394error_t
dc1394_video_set_iso_speed(dc1394camera_t *camera, dc1394speed_t speed)
{
  dc1394error_t err;
  quadlet_t value;
  int channel;

  if (camera->capture_is_set>0)
    return DC1394_CAPTURE_IS_RUNNING;
  
  err=GetCameraControlRegister(camera, REG_CAMERA_ISO_DATA, &value);
  DC1394_ERR_RTN(err, "Could not get ISO data");

  // check if 1394b is available and if we are now using 1394b
  if ((camera->bmode_capable)&&(value & 0x00008000)) {
    err=GetCameraControlRegister(camera, REG_CAMERA_ISO_DATA, &value);
    DC1394_ERR_RTN(err, "oops");
    channel=(value >> 8) & 0x3FUL;
    err=SetCameraControlRegister(camera, REG_CAMERA_ISO_DATA,
				 (quadlet_t) ( ((channel & 0x3FUL) << 8) |
					       (speed & 0x7UL) |
					       (0x1 << 15) ));
    DC1394_ERR_RTN(err, "oops");
  }
  else { // fallback to legacy
    if (speed>DC1394_ISO_SPEED_400-DC1394_ISO_SPEED_MIN) {
      fprintf(stderr,"(%s) line %d: an ISO speed >400Mbps was requested while the camera is in LEGACY mode\n",__FILE__,__LINE__);
      fprintf(stderr,"              Please set the operation mode to OPERATION_MODE_1394B before asking for\n");
      fprintf(stderr,"              1394b ISO speeds\n");
      return DC1394_INVALID_ISO_SPEED;
    }
    err=GetCameraControlRegister(camera, REG_CAMERA_ISO_DATA, &value);
    DC1394_ERR_RTN(err, "oops");
    channel=(value >> 28) & 0xFUL;
    err=SetCameraControlRegister(camera, REG_CAMERA_ISO_DATA,
				 (quadlet_t) (((channel & 0xFUL) << 28) |
					      ((speed & 0x3UL) << 24) ));
    DC1394_ERR_RTN(err, "Could not set ISO data register");
  }
  
  return err;;
}

dc1394error_t
dc1394_video_get_operation_mode(dc1394camera_t *camera, dc1394operation_mode_t  *mode)
{
  dc1394error_t err;
  quadlet_t value;

  err=GetCameraControlRegister(camera, REG_CAMERA_ISO_DATA, &value);
  DC1394_ERR_RTN(err, "Could not get ISO data");
  
  if (camera->bmode_capable==DC1394_TRUE) {
    *mode=((value & 0x00008000) >0);
  }
  else {
    *mode=DC1394_OPERATION_MODE_LEGACY;
  }
  
  return err;
}


dc1394error_t
dc1394_video_set_operation_mode(dc1394camera_t *camera, dc1394operation_mode_t  mode)
{
  dc1394error_t err;
  quadlet_t value;

  if (camera->capture_is_set>0)
    return DC1394_CAPTURE_IS_RUNNING;
  
  err=GetCameraControlRegister(camera, REG_CAMERA_ISO_DATA, &value);
  DC1394_ERR_RTN(err, "Could not get ISO data");
  
  if (mode==DC1394_OPERATION_MODE_LEGACY) {
    err=SetCameraControlRegister(camera, REG_CAMERA_ISO_DATA,
				 (quadlet_t) (value & 0xFFFF7FFF));
    DC1394_ERR_RTN(err, "Could not set ISO data");
  }
  else { // 1394b
    if (camera->bmode_capable) { // if 1394b available
      err=SetCameraControlRegister(camera, REG_CAMERA_ISO_DATA,
				   (quadlet_t) (value | 0x00008000));
      DC1394_ERR_RTN(err, "Could not set ISO data");
    }
    else { // 1394b asked, but it is not available
      return DC1394_FUNCTION_NOT_SUPPORTED;
    }
  }
  
  return DC1394_SUCCESS;
  
}

dc1394error_t
dc1394_set_camera_power(dc1394camera_t *camera, dc1394switch_t pwr)
{
  dc1394error_t err;
  switch (pwr) {
  case DC1394_ON:
    err=SetCameraControlRegister(camera, REG_CAMERA_POWER, DC1394_FEATURE_ON);
    DC1394_ERR_RTN(err, "Could not switch camera ON");
    break;
  case DC1394_OFF:
    err=SetCameraControlRegister(camera, REG_CAMERA_POWER, DC1394_FEATURE_OFF);
    DC1394_ERR_RTN(err, "Could not switch camera OFF");
    break;
  default:
    err=DC1394_INVALID_ARGUMENT_VALUE;
    DC1394_ERR_RTN(err, "Invalid switch value");
  }
  return err;
}

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

  if (pwr==DC1394_ON) {
    // first allocate iso channel and bandwidth
    // err=dc1394_allocate_iso_channel_and_bandwidth(camera);
    // DC1394_ERR_RTN(err, "Could not allocate ISO channel and bandwidth");
    // then we start ISO
    err=SetCameraControlRegister(camera, REG_CAMERA_ISO_EN, DC1394_FEATURE_ON);
    if (err==DC1394_SUCCESS)
      camera->is_iso_on=1;
    DC1394_ERR_RTN(err, "Could not start ISO transmission");
  }
  else {
    // first we stop ISO
    err=SetCameraControlRegister(camera, REG_CAMERA_ISO_EN, DC1394_FEATURE_OFF);
    if (err==DC1394_SUCCESS) {
      camera->is_iso_on=0;
      // then we free iso bandwidth and iso channels
      // err=dc1394_free_iso_channel_and_bandwidth(camera);
      // DC1394_ERR_RTN(err, "Could not free ISO channel and bandwidth");
    }
    DC1394_ERR_RTN(err, "Could not stop ISO transmission");
  }

  return err;
}

dc1394error_t
dc1394_video_get_transmission(dc1394camera_t *camera, dc1394switch_t *is_on)
{
  dc1394error_t err;
  quadlet_t value;
  err= GetCameraControlRegister(camera, REG_CAMERA_ISO_EN, &value);
  DC1394_ERR_RTN(err, "Could not get ISO status");
  
  *is_on= (value & DC1394_FEATURE_ON)>>31;
  return err;
}

dc1394error_t
dc1394_video_set_one_shot(dc1394camera_t *camera, dc1394switch_t pwr)
{
  dc1394error_t err;
  switch (pwr) {
  case DC1394_ON:
    err=SetCameraControlRegister(camera, REG_CAMERA_ONE_SHOT, DC1394_FEATURE_ON);
    DC1394_ERR_RTN(err, "Could not set one-shot");
    break;
  case DC1394_OFF:
    err=SetCameraControlRegister(camera, REG_CAMERA_ONE_SHOT, DC1394_FEATURE_OFF);
    DC1394_ERR_RTN(err, "Could not unset one-shot");
    break;
  default:
    err=DC1394_INVALID_ARGUMENT_VALUE;
    DC1394_ERR_RTN(err, "Invalid switch value");
  }
  return err;
}

dc1394error_t
dc1394_video_get_one_shot(dc1394camera_t *camera, dc1394bool_t *is_on)
{
  quadlet_t value;
  dc1394error_t err = GetCameraControlRegister(camera, REG_CAMERA_ONE_SHOT, &value);
  DC1394_ERR_RTN(err, "Could not get one-shot status");
  *is_on = value & DC1394_FEATURE_ON;
  return err;
}

dc1394error_t
dc1394_video_get_multi_shot(dc1394camera_t *camera, dc1394bool_t *is_on, uint_t *numFrames)
{
  quadlet_t value;
  dc1394error_t err = GetCameraControlRegister(camera, REG_CAMERA_ONE_SHOT, &value);
  DC1394_ERR_RTN(err, "Could not get multishot status");
  *is_on = (value & (DC1394_FEATURE_ON>>1)) >> 30;
  *numFrames= value & 0xFFFFUL;
  
  return err;  
}

dc1394error_t
dc1394_video_set_multi_shot(dc1394camera_t *camera, uint_t numFrames, dc1394switch_t pwr)
{
  dc1394error_t err;
  switch (pwr) {
  case DC1394_ON:
    err=SetCameraControlRegister(camera, REG_CAMERA_ONE_SHOT,
				 (0x40000000UL | (numFrames & 0xFFFFUL)));
    DC1394_ERR_RTN(err, "Could not set multishot");
    break;
  case DC1394_OFF:
    err=dc1394_video_set_one_shot(camera,pwr);
    DC1394_ERR_RTN(err, "Could not unset multishot");
    break;
  default:
    err=DC1394_INVALID_ARGUMENT_VALUE;
    DC1394_ERR_RTN(err, "Invalid switch value");
  }
  return err;
}

dc1394error_t
dc1394_feature_whitebalance_get_value(dc1394camera_t *camera, uint_t *u_b_value, uint_t *v_r_value)
{
  quadlet_t value;
  dc1394error_t err= GetCameraControlRegister(camera, REG_CAMERA_WHITE_BALANCE, &value);
  DC1394_ERR_RTN(err, "Could not get white balance");

  *u_b_value= (uint_t)((value & 0xFFF000UL) >> 12);
  *v_r_value= (uint_t)(value & 0xFFFUL);
  return err;
}

dc1394error_t
dc1394_feature_whitebalance_set_value(dc1394camera_t *camera, uint_t u_b_value, uint_t v_r_value)
{
  quadlet_t curval;
  dc1394error_t err;
  err=GetCameraControlRegister(camera, REG_CAMERA_WHITE_BALANCE, &curval);
  DC1394_ERR_RTN(err, "Could not get white balance");
  
  curval= (curval & 0xFF000000UL) | ( ((u_b_value & 0xFFFUL) << 12) |
				      (v_r_value & 0xFFFUL) );
  err=SetCameraControlRegister(camera, REG_CAMERA_WHITE_BALANCE, curval);
  DC1394_ERR_RTN(err, "Could not set white balance");
  return err;