gxci 0.3.9

A safe raw-and-HAL camera interface based on Daheng-Image's GxIAPI(Galaxy Camera SDK)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

//! Placeholder

use crate::error::Result;
use crate::hal::config::*;
use crate::raw::gx_enum::GX_FEATURE_ID;

#[cfg(feature = "solo")]
pub fn gxi_get_device_vendor_name() -> Result<String> {
    let vendor_name: String = gxi_get_feature_value(GX_FEATURE_ID::GX_STRING_DEVICE_VENDOR_NAME)?;
    println!("Now, vendor name is {}", vendor_name);
    Ok(vendor_name)
}

#[cfg(feature = "solo")]
pub fn gxi_get_device_model_name() -> Result<String> {
    let model_name: String = gxi_get_feature_value(GX_FEATURE_ID::GX_STRING_DEVICE_MODEL_NAME)?;
    println!("Now, model name is {}", model_name);
    Ok(model_name)
}

#[cfg(feature = "solo")]
pub fn gxi_get_device_version() -> Result<String> {
    let version: String = gxi_get_feature_value(GX_FEATURE_ID::GX_STRING_DEVICE_VERSION)?;
    println!("Now, version is {}", version);
    Ok(version)
}

#[cfg(feature = "solo")]
pub fn gxi_get_device_firmware_version() -> Result<String> {
    let firmware_version: String =
        gxi_get_feature_value(GX_FEATURE_ID::GX_STRING_DEVICE_FIRMWARE_VERSION)?;
    println!("Now, firmware version is {}", firmware_version);
    Ok(firmware_version)
}

#[cfg(feature = "solo")]
pub fn gxi_get_device_serial_number() -> Result<String> {
    let serial_number: String =
        gxi_get_feature_value(GX_FEATURE_ID::GX_STRING_DEVICE_SERIAL_NUMBER)?;
    println!("Now, serial number is {}", serial_number);
    Ok(serial_number)
}

#[cfg(feature = "solo")]
pub fn gxi_get_factory_setting_version() -> Result<String> {
    let factory_setting_version: String =
        gxi_get_feature_value(GX_FEATURE_ID::GX_STRING_FACTORY_SETTING_VERSION)?;
    println!(
        "Now, factory setting version is {}",
        factory_setting_version
    );
    Ok(factory_setting_version)
}

#[cfg(feature = "solo")]
pub fn gxi_get_device_user_id() -> Result<String> {
    let user_id: String = gxi_get_feature_value(GX_FEATURE_ID::GX_STRING_DEVICE_USERID)?;
    println!("Now, user id is {}", user_id);
    Ok(user_id)
}

#[cfg(feature = "solo")]
pub fn gxi_set_device_user_id(user_id: String) -> Result<()> {
    gxi_set_feature_value(GX_FEATURE_ID::GX_STRING_DEVICE_USERID, &user_id)?;
    println!("Now, user id is {}", user_id);
    Ok(())
}

#[cfg(feature = "solo")]
pub fn gxi_get_device_link_selector() -> Result<i64> {
    let link_selector: i64 = gxi_get_feature_value(GX_FEATURE_ID::GX_INT_DEVICE_LINK_SELECTOR)?;
    println!("Now, link selector is {}", link_selector);
    Ok(link_selector)
}

#[cfg(feature = "solo")]
pub fn gxi_set_device_link_selector(link_selector: i64) -> Result<()> {
    gxi_set_feature_value(GX_FEATURE_ID::GX_INT_DEVICE_LINK_SELECTOR, &link_selector)?;
    println!("Now, link selector is {}", link_selector);
    Ok(())
}

#[cfg(feature = "solo")]
pub fn gxi_get_device_link_throughput_limit_mode() -> Result<i64> {
    let link_selector: i64 =
        gxi_get_feature_value(GX_FEATURE_ID::GX_ENUM_DEVICE_LINK_THROUGHPUT_LIMIT_MODE)?;
    println!("Now, link selector is {}", link_selector);
    Ok(link_selector)
}

#[cfg(feature = "solo")]
pub fn gxi_set_device_link_throughput_limit_mode(link_selector: i64) -> Result<()> {
    gxi_set_feature_value(
        GX_FEATURE_ID::GX_ENUM_DEVICE_LINK_THROUGHPUT_LIMIT_MODE,
        &link_selector,
    )?;
    println!("Now, link selector is {}", link_selector);
    Ok(())
}

#[cfg(feature = "solo")]
pub fn gxi_set_device_link_throughput_limit_mode_off() -> Result<()> {
    gxi_set_feature_value(
        GX_FEATURE_ID::GX_ENUM_DEVICE_LINK_THROUGHPUT_LIMIT_MODE,
        &0i64,
    )?;
    println!("Now, link selector is off");
    Ok(())
}

#[cfg(feature = "solo")]
pub fn gxi_set_device_link_throughput_limit_mode_on() -> Result<()> {
    gxi_set_feature_value(
        GX_FEATURE_ID::GX_ENUM_DEVICE_LINK_THROUGHPUT_LIMIT_MODE,
        &1i64,
    )?;
    println!("Now, link selector is on");
    Ok(())
}

#[cfg(feature = "solo")]
pub fn gxi_get_device_link_throughput_limit() -> Result<i64> {
    let link_selector: i64 =
        gxi_get_feature_value(GX_FEATURE_ID::GX_INT_DEVICE_LINK_THROUGHPUT_LIMIT)?;
    println!("Now, link selector is {}", link_selector);
    Ok(link_selector)
}

#[cfg(feature = "solo")]
pub fn gxi_set_device_link_throughput_limit(link_selector: i64) -> Result<()> {
    gxi_set_feature_value(
        GX_FEATURE_ID::GX_INT_DEVICE_LINK_THROUGHPUT_LIMIT,
        &link_selector,
    )?;
    println!("Now, link selector is {}", link_selector);
    Ok(())
}

#[cfg(feature = "solo")]
pub fn gxi_get_device_link_current_throughput() -> Result<i64> {
    let link_selector: i64 =
        gxi_get_feature_value(GX_FEATURE_ID::GX_INT_DEVICE_LINK_CURRENT_THROUGHPUT)?;
    println!("Now, link selector is {}", link_selector);
    Ok(link_selector)
}