dc1394_control.c

较新版本的libdc1394

    if (dc1394_get_iso_channel_and_speed(handle, node,
                                         &info->iso_channel, 
                                         &info->iso_speed)!= DC1394_SUCCESS)
        return DC1394_FAILURE;

    if (dc1394_get_video_format(handle, node, &info->format) != DC1394_SUCCESS)
        return DC1394_FAILURE;

    if (dc1394_get_video_mode(handle, node, &info->mode) != DC1394_SUCCESS)
        return DC1394_FAILURE;

    if (dc1394_get_video_framerate(handle, node, &info->framerate)
        != DC1394_SUCCESS)
        return DC1394_FAILURE;

    if (dc1394_get_iso_status(handle, node, &info->is_iso_on)
        != DC1394_SUCCESS)
        return DC1394_FAILURE;

    if (dc1394_query_basic_functionality(handle,node,&value) != DC1394_SUCCESS)
        return DC1394_FAILURE;
    else {
      info->mem_channel_number = (value & 0x0000000F);
      info->bmode_capable      = (value & 0x00800000) != 0;
      info->one_shot_capable   = (value & 0x00000800) != 0;
      info->multi_shot_capable = (value & 0x00001000) != 0;
    }

    if (info->mem_channel_number>0) {
      if (dc1394_get_memory_load_ch(handle, node, &info->load_channel)
	  != DC1394_SUCCESS)
        return DC1394_FAILURE;
      
      if (dc1394_get_memory_save_ch(handle, node, &info->save_channel)
	  != DC1394_SUCCESS)
        return DC1394_FAILURE;
    }
    else {
      info->load_channel=0;
      info->save_channel=0;
    }

    return DC1394_SUCCESS;
} 

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

 Collects the available features for the camera
 described by node and stores them in features.
*****************************************************/
int
dc1394_get_camera_feature_set(raw1394handle_t handle, nodeid_t node,
                              dc1394_feature_set *features) 
{
    int i, j;

    for (i= FEATURE_MIN, j= 0; i <= FEATURE_MAX; i++, j++) 
    {
        features->feature[j].feature_id= i;
        dc1394_get_camera_feature(handle, node, &features->feature[j]);
    }

    return DC1394_SUCCESS;
}

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

 Stores the bounds and options associated with the
 feature described by feature->feature_id
*****************************************************/
int
dc1394_get_camera_feature(raw1394handle_t handle, nodeid_t node,
                          dc1394_feature_info *feature) 
{
    octlet_t offset;
    quadlet_t value;
    unsigned int orig_fid, updated_fid;

    orig_fid= feature->feature_id;
    updated_fid= feature->feature_id;
    

    // check presence
    if (dc1394_is_feature_present(handle, node, feature->feature_id, &(feature->available))!=DC1394_SUCCESS) {
      return DC1394_FAILURE;
    }

    if (feature->available == DC1394_FALSE)
    {
        return DC1394_SUCCESS;
    }

    // get capabilities
    if (dc1394_query_feature_characteristics(handle, node, feature->feature_id, &value)!=DC1394_SUCCESS) {
      return DC1394_FAILURE;
    }

    switch (feature->feature_id) {
    case FEATURE_TRIGGER:
      feature->one_push= DC1394_FALSE;
      feature->polarity_capable=
	(value & 0x02000000UL) ? DC1394_TRUE : DC1394_FALSE;
      feature->trigger_mode_capable_mask= ((value >> 12) & 0x0f);
      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
    updated_fid= orig_fid;
    FEATURE_TO_VALUE_OFFSET(updated_fid, offset);

    if (GetCameraControlRegister(handle, node, offset, &value) < 0) {
      return DC1394_FAILURE;
    }

    switch (feature->feature_id) {
    case FEATURE_TRIGGER:
        feature->one_push_active= DC1394_FALSE;
        feature->trigger_polarity=
            (value & 0x01000000UL) ? DC1394_TRUE : DC1394_FALSE;
        feature->trigger_mode= (int)((value >> 14) & 0xF);
        feature->auto_active= DC1394_FALSE;
	break;
    case 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 (orig_fid) {
    case FEATURE_WHITE_BALANCE:
      feature->RV_value= value & 0xFFFUL;
      feature->BU_value= (value & 0xFFF000UL) >> 12;
      break;
    case FEATURE_WHITE_SHADING:
      feature->R_value=value & 0xFFUL;
      feature->G_value=(value & 0xFF00UL)>>8;
      feature->B_value=(value & 0xFF0000UL)>>16;
      break;
    case FEATURE_TEMPERATURE:
      feature->value= value & 0xFFFUL;
      feature->target_value= value & 0xFFF000UL;
      break;
    default:
      feature->value= value & 0xFFFUL;
      break;
    }

    if (feature->absolute_capable>0) {
      dc1394_query_absolute_feature_min_max(handle, node, orig_fid,
					    &feature->abs_min, &feature->abs_max);
      dc1394_query_absolute_feature_value(handle, node, orig_fid,
					  &feature->abs_value);
      dc1394_query_absolute_control(handle, node, orig_fid,
				    &feature->abs_control);
    }

    return DC1394_SUCCESS;
}

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

 Displays the bounds and options of the given feature
*****************************************************/
void
dc1394_print_feature(dc1394_feature_info *f) 
{
    //char * tags[2] = {"NO","YES"};
    //char * autoMode[2] = {"Manual","Auto"};
    int fid= f->feature_id;

    if ( (fid < FEATURE_MIN) || (fid > FEATURE_MAX) )
    {
        printf("Invalid feature code\n");
        return;
    }

    printf("%s:\n\t", dc1394_feature_desc[fid - FEATURE_MIN]);

    if (!f->available) 
    {
        printf("NOT AVAILABLE\n");
        return;
    }

    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 != FEATURE_TRIGGER) 
    {
        printf("min: %d max %d\n", f->min, f->max);
    }
    switch(fid) {
    case FEATURE_TRIGGER:
      printf("\n\tAvailableTriggerModes: ");
      
      if (f->trigger_mode_capable_mask & 0x08)
	printf("0 ");
      if (f->trigger_mode_capable_mask & 0x04)
	printf("1 ");
      if (f->trigger_mode_capable_mask & 0x02)
	printf("2 ");
      if (f->trigger_mode_capable_mask & 0x02)
	printf("3 ");
      if (!(f->trigger_mode_capable_mask & 0x0f))
	printf("No modes available");
      
      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);
      break;
    case FEATURE_WHITE_BALANCE: 
      printf("\tB/U value: %d R/V value: %d\n", f->BU_value, f->RV_value);
      break;
    case FEATURE_TEMPERATURE:
      printf("\tTarget temp: %d Current Temp: %d\n", f->target_value, f->value);
      break;
    case 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);
}

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

 Displays the entire feature set stored in features
*****************************************************/
void
dc1394_print_feature_set(dc1394_feature_set *features) 
{
    int i, j;

    printf("FEATURE SETTINGS\n==================================\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= FEATURE_MIN, j= 0; i <= FEATURE_MAX; i++, j++) 
    {
        dc1394_print_feature(&features->feature[j]);
    }

    printf("==================================\n");
}

int
dc1394_init_camera(raw1394handle_t handle, nodeid_t node)
{
    int retval= SetCameraControlRegister(handle, node, REG_CAMERA_INITIALIZE,
                                         ON_VALUE);
    return (retval ? DC1394_FAILURE : DC1394_SUCCESS);
}

int
dc1394_query_supported_formats(raw1394handle_t handle, nodeid_t node,
                               quadlet_t *value)
{
    int retval= GetCameraControlRegister(handle, node, REG_CAMERA_V_FORMAT_INQ,
                                         value);
    return (retval ? DC1394_FAILURE : DC1394_SUCCESS);
}

int
dc1394_query_supported_modes(raw1394handle_t handle, nodeid_t node,
                             unsigned int format, quadlet_t *value)
{
    int retval;

    if ( (format > FORMAT_MAX) || (format < FORMAT_MIN) )
    {
        return DC1394_FAILURE;
    }

    format-= FORMAT_MIN;
    retval= GetCameraControlRegister(handle, node,
                                     REG_CAMERA_V_MODE_INQ_BASE +
                                     (format * 0x04U), value);
    return (retval ? DC1394_FAILURE : DC1394_SUCCESS);
}

int
dc1394_query_supported_framerates(raw1394handle_t handle, nodeid_t node,
                                  unsigned int format, unsigned int mode,
                                  quadlet_t *value)
{
    int retval;
    int max_mode_for_format, min_mode_for_format;

    switch(format)
    {
    case FORMAT_VGA_NONCOMPRESSED:
        min_mode_for_format= MODE_FORMAT0_MIN;
        max_mode_for_format= MODE_FORMAT0_MAX;
        break;
    case FORMAT_SVGA_NONCOMPRESSED_1:
        min_mode_for_format= MODE_FORMAT1_MIN;
        max_mode_for_format= MODE_FORMAT1_MAX;
        break;
    case FORMAT_SVGA_NONCOMPRESSED_2:
        min_mode_for_format= MODE_FORMAT2_MIN;
        max_mode_for_format= MODE_FORMAT2_MAX;
        break;
    default:
        printf("Invalid format query\n");
        return DC1394_FAILURE;
    }

    if ( (format > FORMAT_MAX) || (format < FORMAT_MIN) ||
         (mode > max_mode_for_format) || (mode < min_mode_for_format) )
    {
        return DC1394_FAILURE;
    }

    format-= FORMAT_MIN;
    mode-= min_mode_for_format;
    retval= GetCameraControlRegister(handle, node,
                                     REG_CAMERA_V_RATE_INQ_BASE +
                                     (format * 0x20U) + (mode * 0x04U), value);
    return (retval ? DC1394_FAILURE : DC1394_SUCCESS);
}

int
dc1394_query_revision(raw1394handle_t handle, nodeid_t node, int mode,
                      quadlet_t *value)
{
    int retval;

    if ( (mode > MODE_FORMAT6_MAX) || (mode < MODE_FORMAT6_MIN) )
    {
        return DC1394_FAILURE;
    }

    mode-= MODE_FORMAT6_MIN;
    retval= GetCameraControlRegister(handle, node,
                                     REG_CAMERA_V_REV_INQ_BASE +
                                     (mode * 0x04U), value);
    return (retval ? DC1394_FAILURE : DC1394_SUCCESS);
}

int
dc1394_query_basic_functionality(raw1394handle_t handle, nodeid_t node,
                                 quadlet_t *value)
{
    int retval= GetCameraControlRegister(handle, node,
                                         REG_CAMERA_BASIC_FUNC_INQ, value);
    return (retval ? DC1394_FAILURE : DC1394_SUCCESS);
}

int
dc1394_query_advanced_feature_offset(raw1394handle_t handle, nodeid_t node,
                                     quadlet_t *value)
{
    int retval= GetCameraControlRegister(handle, node,
                                         REG_CAMERA_ADV_FEATURE_INQ, value);
    return (retval ? DC1394_FAILURE : DC1394_SUCCESS);
}