dc1394_control.c

DCAM1394相机Linux下的驱动源码

      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;
    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_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);
    }

    if (fid == 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);
    }
    else if (fid == FEATURE_WHITE_BALANCE) 
    {
        printf("\tB/U value: %d R/V value: %d\n", f->BU_value, f->RV_value);
    }
    else if (fid == FEATURE_TEMPERATURE) 
    {
        printf("\tTarget temp: %d Current Temp: %d\n", f->target_value,
               f->value);
    }
    else 
    {
        printf("\tcurrent value is: %d\n",f->value);
    }
    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);
}

int
dc1394_query_feature_characteristics(raw1394handle_t handle, nodeid_t node,
                                     unsigned int feature, quadlet_t *value)
{
    octlet_t offset;
    int retval;

    FEATURE_TO_INQUIRY_OFFSET(feature, offset);
    retval= GetCameraControlRegister(handle, node, offset, value);
    return (retval ? DC1394_FAILURE : DC1394_SUCCESS);
}

int
dc1394_get_video_framerate(raw1394handle_t handle, nodeid_t node,
                           unsigned int *framerate)
{
    quadlet_t value;
    int retval= GetCameraControlRegister(handle, node, REG_CAMERA_FRAME_RATE,
                                         &value);

    if (!retval) {
        *framerate= (unsigned int)((value >> 29) & 0x7UL) + FRAMERATE_MIN;
    }

    return (retval ? DC1394_FAILURE : DC1394_SUCCESS);
}

int
dc1394_set_video_framerate(raw1394handle_t handle, nodeid_t node,
                           unsigned int framerate)
{
    int retval;

    if ( (framerate < FRAMERATE_MIN) || (framerate > FRAMERATE_MAX) ) {
        return DC1394_FAILURE;
    }

    retval= SetCameraControlRegister(handle, node, REG_CAMERA_FRAME_RATE,
                     (quadlet_t)(((framerate - FRAMERATE_MIN) & 0x7UL) << 29));
    return (retval ? DC1394_FAILURE : DC1394_SUCCESS);
}

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

    if (dc1394_get_video_format(handle, node, &format) != DC1394_SUCCESS) {
        return DC1394_FAILURE;
    }

    retval= GetCameraControlRegister(handle, node, REG_CAMERA_VIDEO_MODE,
                                     &value);

    if (!retval) {

        switch(format) {
        case FORMAT_VGA_NONCOMPRESSED:
            *mode= (unsigned int)((value >> 29) & 0x7UL) + MODE_FORMAT0_MIN;
            break;
        case FORMAT_SVGA_NONCOMPRESSED_1:
            *mode= (unsigned int)((value >> 29) & 0x7UL) + MODE_FORMAT1_MIN;
            break;
        case FORMAT_SVGA_NONCOMPRESSED_2:
            *mode= (unsigned int)((value >> 29) & 0x7UL) + MODE_FORMAT2_MIN;
            break;
        case FORMAT_STILL_IMAGE:
            *mode= (unsigned int)((value >> 29) & 0x7UL) + MODE_FORMAT6_MIN;
            break;
        case FORMAT_SCALABLE_IMAGE_SIZE:
            *mode= (unsigned int)((value >> 29) & 0x7UL) + MODE_FORMAT7_MIN;
            break;
        default:
            return DC1394_FAILURE;
            break;
        }

    }

    return (retval ? DC1394_FAILURE : DC1394_SUCCESS);
}

int
dc1394_set_video_mode(raw1394handle_t handle, nodeid_t node, unsigned int mode)
{
    int retval;
    unsigned int format, min, max;

    if (dc1394_get_video_format(handle, node, &format) != DC1394_SUCCESS) {
        return DC1394_FAILURE;
    }

    switch(format) {
        case FORMAT_VGA_NONCOMPRESSED:
            min= MODE_FORMAT0_MIN;
            max= MODE_FORMAT0_MAX;
            break;
        case FORMAT_SVGA_NONCOMPRESSED_1:
            min= MODE_FORMAT1_MIN;
            max= MODE_FORMAT1_MAX;
            break;
        case FORMAT_SVGA_NONCOMPRESSED_2:
            min= MODE_FORMAT2_MIN;
            max= MODE_FORMAT2_MAX;
            break;
        case FORMAT_STILL_IMAGE:
            min= MODE_FORMAT6_MIN;
            max= MODE_FORMAT6_MAX;
            break;
        case FORMAT_SCALABLE_IMAGE_SIZE:
            min= MODE_FORMAT7_MIN;
            max= MODE_FORMAT7_MAX;
            break;
        default:
            return DC1394_FAILURE;
            break;
    }

    if ( (mode < min) || (mode > max) ) {
        return DC1394_FAILURE;
    }

    retval= SetCameraControlRegister(handle, node, REG_CAMERA_VIDEO_MODE,
                                    (quadlet_t)(((mode - min) & 0x7UL) << 29));