dc1394_control.c

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

  printf("Node                              :     0x%x\n", camera->node);
  printf("Port                              :     %d\n", camera->port);
  printf("Specifications ID                 :     0x%x\n", camera->ud_reg_tag_12);
  printf("Software revision                 :     0x%x\n", camera->ud_reg_tag_13);
  printf("IIDC version code                 :     %d\n", camera->iidc_version);
  printf("Unit directory offset             :     0x%llx\n", (uint64_t)camera->unit_directory);
  printf("Unit dependent directory offset   :     0x%llx\n", (uint64_t)camera->unit_dependent_directory);
  printf("Commands registers base           :     0x%llx\n", (uint64_t)camera->command_registers_base);
  printf("Unique ID                         :     0x%08x%08x\n", value[1], value[0]);
  if (camera->adv_features_capable)
    printf("Advanced features found at offset :     0x%llx\n", (uint64_t)camera->advanced_features_csr);
  printf("1394b mode capable (>=800Mbit/s)  :     ");
  if (camera->bmode_capable==DC1394_TRUE)
    printf("Yes\n");
  else
    printf("No\n");

  dc1394_print_camera_info_platform (camera);

  return DC1394_SUCCESS;
}

/*****************************************************
 dc1394_get_camera_feature_set

 Collects the available features for the camera
 described by node and stores them in features.
*****************************************************/
dc1394error_t
dc1394_get_camera_feature_set(dc1394camera_t *camera, dc1394featureset_t *features) 
{
  uint_t i, j;
  dc1394error_t err=DC1394_SUCCESS;
  
  for (i= DC1394_FEATURE_MIN, j= 0; i <= DC1394_FEATURE_MAX; i++, j++)  {
    features->feature[j].id= i;
    err=dc1394_get_camera_feature(camera, &features->feature[j]);
    DC1394_ERR_RTN(err, "Could not get camera feature %d",i);
  }

  return err;
}

/*****************************************************
 dc1394_get_camera_feature

 Stores the bounds and options associated with the
 feature described by feature->id
*****************************************************/
dc1394error_t
dc1394_get_camera_feature(dc1394camera_t *camera, dc1394feature_info_t *feature) 
{
  octlet_t offset;
  quadlet_t value;
  dc1394error_t err;

  // check presence
  err=dc1394_feature_is_present(camera, feature->id, &(feature->available));
  DC1394_ERR_RTN(err, "Could not check feature %d presence",feature->id);
  
  if (feature->available == DC1394_FALSE) {
    return DC1394_SUCCESS;
  }

  // get capabilities
  FEATURE_TO_INQUIRY_OFFSET(feature->id, offset);
  err=GetCameraControlRegister(camera, offset, &value);
  DC1394_ERR_RTN(err, "Could not check feature %d characteristics",feature->id);

  switch (feature->id) {
  case DC1394_FEATURE_TRIGGER:
    feature->one_push= DC1394_FALSE;
    feature->polarity_capable= (value & 0x02000000UL) ? DC1394_TRUE : DC1394_FALSE;
    int i;
    quadlet_t value_tmp;
    
    feature->trigger_modes.num=0;
    value_tmp= (value & (0xFF));
    //fprintf(stderr,"value: %x\n",value_tmp);
    
    for (i=DC1394_TRIGGER_MODE_MIN;i<=DC1394_TRIGGER_MODE_MAX;i++) {
      if (value_tmp & (0x1 << (15-(i-DC1394_TRIGGER_MODE_MIN)-(i>5)*8))) { // (i>5)*8 to take the mode gap into account
	feature->trigger_modes.modes[feature->trigger_modes.num]=i;
	feature->trigger_modes.num++;
      }
    }

    err=dc1394_external_trigger_get_supported_sources(camera,&feature->trigger_sources);
    DC1394_ERR_RTN(err, "Could not get supported trigger sources");

    feature->auto_capable= DC1394_FALSE;
    feature->manual_capable= DC1394_FALSE;
    break;
  default:
    feature->polarity_capable = 0;
    feature->trigger_mode     = 0;
    feature->one_push         = (value & 0x10000000UL) ? DC1394_TRUE : DC1394_FALSE;
    feature->auto_capable     = (value & 0x02000000UL) ? DC1394_TRUE : DC1394_FALSE;
    feature->manual_capable   = (value & 0x01000000UL) ? DC1394_TRUE : DC1394_FALSE;
    
    feature->min= (value & 0xFFF000UL) >> 12;
    feature->max= (value & 0xFFFUL);
    break;
  }
  
  feature->absolute_capable = (value & 0x40000000UL) ? DC1394_TRUE : DC1394_FALSE;
  feature->readout_capable  = (value & 0x08000000UL) ? DC1394_TRUE : DC1394_FALSE;
  feature->on_off_capable   = (value & 0x04000000UL) ? DC1394_TRUE : DC1394_FALSE;
  
  // get current values
  FEATURE_TO_VALUE_OFFSET(feature->id, offset);
  
  err=GetCameraControlRegister(camera, offset, &value);
  DC1394_ERR_RTN(err, "Could not get feature register");
  
  switch (feature->id) {
  case DC1394_FEATURE_TRIGGER:
    feature->one_push_active= DC1394_FALSE;
    feature->trigger_polarity=
      (value & 0x01000000UL) ? DC1394_TRUE : DC1394_FALSE;
    feature->trigger_mode= (uint_t)((value >> 14) & 0xF);
    feature->auto_active= DC1394_FALSE;
    break;
  case DC1394_FEATURE_TRIGGER_DELAY:
    feature->one_push_active= DC1394_FALSE;
    feature->auto_active=DC1394_FALSE;
  default:
    feature->one_push_active=
      (value & 0x04000000UL) ? DC1394_TRUE : DC1394_FALSE;
    feature->auto_active=
      (value & 0x01000000UL) ? DC1394_TRUE : DC1394_FALSE;
    feature->trigger_polarity= DC1394_FALSE;
    break;
  }
  
  feature->is_on= (value & 0x02000000UL) ? DC1394_TRUE : DC1394_FALSE;
  
  switch (feature->id) {
  case DC1394_FEATURE_WHITE_BALANCE:
    feature->RV_value= value & 0xFFFUL;
    feature->BU_value= (value & 0xFFF000UL) >> 12;
    break;
  case DC1394_FEATURE_WHITE_SHADING:
    feature->R_value=value & 0xFFUL;
    feature->G_value=(value & 0xFF00UL)>>8;
    feature->B_value=(value & 0xFF0000UL)>>16;
    break;
  case DC1394_FEATURE_TEMPERATURE:
    feature->value= value & 0xFFFUL;
    feature->target_value= value & 0xFFF000UL;
    break;
  default:
    feature->value= value & 0xFFFUL;
    break;
  }
  
  if (feature->absolute_capable>0) {
    err=dc1394_feature_get_absolute_boundaries(camera, feature->id, &feature->abs_min, &feature->abs_max);
    DC1394_ERR_RTN(err, "Could not get feature %d absolute min/max",feature->id);
    err=dc1394_feature_get_absolute_value(camera, feature->id, &feature->abs_value);
    DC1394_ERR_RTN(err, "Could not get feature %d absolute value",feature->id);
    err=dc1394_feature_get_absolute_control(camera, feature->id, &feature->abs_control);
    DC1394_ERR_RTN(err, "Could not get feature %d absolute control",feature->id);
  }
  
  return err;
}

/*****************************************************
 dc1394_print_feature

 Displays the bounds and options of the given feature
*****************************************************/
dc1394error_t
dc1394_print_feature(dc1394feature_info_t *f) 
{
  int fid= f->id;
  
  if ( (fid < DC1394_FEATURE_MIN) || (fid > DC1394_FEATURE_MAX) ) {
    printf("Invalid feature code\n");
    return DC1394_INVALID_FEATURE;
  }
  
  printf("%s:\n\t", dc1394_feature_desc[fid - DC1394_FEATURE_MIN]);
  
  if (!f->available) {
    printf("NOT AVAILABLE\n");
    return DC1394_SUCCESS;
  }
  
  if (f->one_push) 
    printf("OP  ");
  if (f->readout_capable)
    printf("RC  ");
  if (f->on_off_capable)
    printf("O/OC  ");
  if (f->auto_capable)
    printf("AC  ");
  if (f->manual_capable)
    printf("MC  ");
  if (f->absolute_capable)
    printf("ABS  ");
  printf("\n");
  
  if (f->on_off_capable) {
    if (f->is_on) 
      printf("\tFeature: ON  ");
    else
      printf("\tFeature: OFF  ");
  }
  else
    printf("\t");

  if (f->one_push)  {
    if (f->one_push_active)
      printf("One push: ACTIVE  ");
    else
      printf("One push: INACTIVE  ");
  }
  
  if (f->auto_active) 
    printf("AUTO  ");
  else
    printf("MANUAL ");

  if (fid != DC1394_FEATURE_TRIGGER) 
    printf("min: %d max %d\n", f->min, f->max);

  switch(fid) {
  case DC1394_FEATURE_TRIGGER:
    printf("\n\tAvailableTriggerModes: ");
    if (f->trigger_modes.num==0) {
      printf("none");
    }
    else {
      int i;
      for (i=0;i<f->trigger_modes.num;i++) {
	printf("%d ",f->trigger_modes.modes[i]);
      }
    }
    printf("\n\tAvailableTriggerSources: ");
    if (f->trigger_sources.num==0) {
      printf("none");
    }
    else {
      int i;
      for (i=0;i<f->trigger_sources.num;i++) {
	printf("%d ",f->trigger_sources.sources[i]);
      }
    }
    printf("\n\tPolarity Change Capable: ");
    
    if (f->polarity_capable) 
      printf("True");
    else 
      printf("False");
    
    printf("\n\tCurrent Polarity: ");
    
    if (f->trigger_polarity) 
      printf("POS");
    else 
      printf("NEG");
    
    printf("\n\tcurrent mode: %d\n", f->trigger_mode);
    if (f->trigger_sources.num>0) {
      printf("\n\tcurrent source: %d\n", f->trigger_source);
    }
    break;
  case DC1394_FEATURE_WHITE_BALANCE: 
    printf("\tB/U value: %d R/V value: %d\n", f->BU_value, f->RV_value);
    break;
  case DC1394_FEATURE_TEMPERATURE:
    printf("\tTarget temp: %d Current Temp: %d\n", f->target_value, f->value);
    break;
  case DC1394_FEATURE_WHITE_SHADING: 
    printf("\tR value: %d G value: %d B value: %d\n", f->R_value,
	   f->G_value, f->B_value);
    break;
  default:
    printf("\tcurrent value is: %d\n",f->value);
    break;
  }
  if (f->absolute_capable)
    printf("\tabsolute settings:\n\t value: %f\n\t min: %f\n\t max: %f\n",
	   f->abs_value,f->abs_min,f->abs_max);

  return DC1394_SUCCESS;
}

/*****************************************************
 dc1394_print_feature_set

 Displays the entire feature set stored in features
*****************************************************/
dc1394error_t
dc1394_print_feature_set(dc1394featureset_t *features) 
{
  uint_t i, j;
  dc1394error_t err=DC1394_SUCCESS;
  
  printf("------ Features report ------\n");
  printf("OP   - one push capable\n");
  printf("RC   - readout capable\n");
  printf("O/OC - on/off capable\n");
  printf("AC   - auto capable\n");
  printf("MC   - manual capable\n");
  printf("ABS  - absolute capable\n");
  printf("-----------------------------\n");
  
  for (i= DC1394_FEATURE_MIN, j= 0; i <= DC1394_FEATURE_MAX; i++, j++)  {
    err=dc1394_print_feature(&features->feature[j]);
    DC1394_ERR_RTN(err, "Could not print feature %d",i);
  }
  
  return err;
}

dc1394error_t
dc1394_reset_camera(dc1394camera_t *camera)
{
  dc1394error_t err;
  err=SetCameraControlRegister(camera, REG_CAMERA_INITIALIZE, DC1394_FEATURE_ON);
  DC1394_ERR_RTN(err, "Could not reset the camera");
  return err;
}

dc1394error_t
dc1394_video_get_supported_modes(dc1394camera_t *camera, dc1394video_modes_t *modes)
{
  dc1394error_t err;
  quadlet_t value, sup_formats;
  dc1394video_mode_t mode;

  // get supported formats
  err=GetCameraControlRegister(camera, REG_CAMERA_V_FORMAT_INQ, &sup_formats);
  DC1394_ERR_RTN(err, "Could not get supported formats");

  //fprintf(stderr,"supoerted formats: 0x%x\n",sup_formats);

  // for each format check supported modes and add them as we find them.

  modes->num=0;
  // Format_0
  //fprintf(stderr,"shiftval=%d, mask=0x%x\n",31-(FORMAT0-FORMAT_MIN),0x1 << (31-(FORMAT0-FORMAT_MIN)));
  if ((sup_formats & (0x1 << (31-(DC1394_FORMAT0-DC1394_FORMAT_MIN)))) > 0) {
    //fprintf(stderr,"F0 available\n");
    err=GetCameraControlRegister(camera, REG_CAMERA_V_MODE_INQ_BASE + ((DC1394_FORMAT0-DC1394_FORMAT_MIN) * 0x04U), &value);
    DC1394_ERR_RTN(err, "Could not get supported modes for Format_0");
    
    //fprintf(stderr,"modes 0: 0x%x\n",value);
    for (mode=DC1394_VIDEO_MODE_FORMAT0_MIN;mode<=DC1394_VIDEO_MODE_FORMAT0_MAX;mode++) {
      //fprintf(stderr,"mask=0x%x, cond=0x%x\n", 0x1 << (31-(mode-MODE_FORMAT0_MIN)),(value && (0x1<<(31-(mode-MODE_FORMAT0_MIN)))));
      if ((value & (0x1<<(31-(mode-DC1394_VIDEO_MODE_FORMAT0_MIN)))) > 0) {
	modes->modes[modes->num]=mode;
	modes->num++;
      }
    }
  }
  // Format_1
  if ((sup_formats & (0x1 << (31-(DC1394_FORMAT1-DC1394_FORMAT_MIN)))) > 0) {
    err=GetCameraControlRegister(camera, REG_CAMERA_V_MODE_INQ_BASE + ((DC1394_FORMAT1-DC1394_FORMAT_MIN) * 0x04U), &value);
    DC1394_ERR_RTN(err, "Could not get supported modes for Format_1");
    
    for (mode=DC1394_VIDEO_MODE_FORMAT1_MIN;mode<=DC1394_VIDEO_MODE_FORMAT1_MAX;mode++) {
      if ((value & (0x1<<(31-(mode-DC1394_VIDEO_MODE_FORMAT1_MIN)))) > 0) {
	modes->modes[modes->num]=mode;
	modes->num++;
      }
    }
  }
  // Format_2
  if ((sup_formats & (0x1 << (31-(DC1394_FORMAT2-DC1394_FORMAT_MIN)))) > 0) {
    err=GetCameraControlRegister(camera, REG_CAMERA_V_MODE_INQ_BASE + ((DC1394_FORMAT2-DC1394_FORMAT_MIN) * 0x04U), &value);
    DC1394_ERR_RTN(err, "Could not get supported modes for Format_2");
    
    for (mode=DC1394_VIDEO_MODE_FORMAT2_MIN;mode<=DC1394_VIDEO_MODE_FORMAT2_MAX;mode++) {
      if ((value & (0x1<<(31-(mode-DC1394_VIDEO_MODE_FORMAT2_MIN)))) > 0) {
	modes->modes[modes->num]=mode;
	modes->num++;
      }
    }
  }
  // Format_6
  if ((sup_formats & (0x1 << (31-(DC1394_FORMAT6-DC1394_FORMAT_MIN)))) > 0) {
    err=GetCameraControlRegister(camera, REG_CAMERA_V_MODE_INQ_BASE + ((DC1394_FORMAT6-DC1394_FORMAT_MIN) * 0x04U), &value);
    DC1394_ERR_RTN(err, "Could not get supported modes for Format_3");
    
    for (mode=DC1394_VIDEO_MODE_FORMAT6_MIN;mode<=DC1394_VIDEO_MODE_FORMAT6_MAX;mode++) {
      if ((value & (0x1<<(31-(mode-DC1394_VIDEO_MODE_FORMAT6_MIN))))>0) {
	modes->modes[modes->num]=mode;
	modes->num++;
      }
    }
  }
  // Format_7
  if ((sup_formats & (0x1 << (31-(DC1394_FORMAT7-DC1394_FORMAT_MIN)))) > 0) {
    err=GetCameraControlRegister(camera, REG_CAMERA_V_MODE_INQ_BASE + ((DC1394_FORMAT7-DC1394_FORMAT_MIN) * 0x04U), &value);
    DC1394_ERR_RTN(err, "Could not get supported modes for Format_4");
    
    for (mode=DC1394_VIDEO_MODE_FORMAT7_MIN;mode<=DC1394_VIDEO_MODE_FORMAT7_MAX;mode++) {
      if ((value & (0x1<<(31-(mode-DC1394_VIDEO_MODE_FORMAT7_MIN))))>0) {
	modes->modes[modes->num]=mode;
	modes->num++;
      }
    }
  }

  return err;
}

dc1394error_t
dc1394_video_get_supported_framerates(dc1394camera_t *camera, dc1394video_mode_t video_mode, dc1394framerates_t *framerates)
{
  dc1394framerate_t framerate;
  dc1394error_t err;
  uint_t format;
  quadlet_t value;

  err=_dc1394_get_format_from_mode(video_mode, &format);
  DC1394_ERR_RTN(err, "Invalid mode code");

  if ((format==DC1394_FORMAT6)||(format==DC1394_FORMAT7)) {
    err=DC1394_INVALID_VIDEO_FORMAT;
    DC1394_ERR_RTN(err, "Modes corresponding for format6 and format7 do not have framerates!");