display-ambient-light/desktop
1
0
Fork 0
Code Issues 1 Pull Requests Packages Projects 1 Releases Wiki Activity

feat: 灯条段排序。

Browse Source
This commit is contained in:
Ivan Li
2023-04-02 16:08:28 +08:00
parent 535f731770
commit 86e9b072bc
8 changed files with 89 additions and 186 deletions
Download Patch File Download Diff File Expand all files Collapse all files

124
src-tauri/src/ambient_light/config.rs
View File

@ -17,14 +17,6 @@ pub enum Border {
Right,
}
#[derive(Clone, Copy, Serialize, Deserialize, Debug)]
pub struct LedStripConfigOfBorders {
pub top: Option<LedStripConfig>,
pub bottom: Option<LedStripConfig>,
pub left: Option<LedStripConfig>,
pub right: Option<LedStripConfig>,
}
#[derive(Clone, Copy, Serialize, Deserialize, Debug)]
pub struct LedStripConfig {
pub index: usize,
@ -119,6 +111,7 @@ impl LedStripConfigGroup {
mappers.push(SamplePointMapper {
start: (j + i * 4) * 30,
end: (j + i * 4 + 1) * 30,
pos: (j + i * 4) * 30,
})
}
}
@ -126,124 +119,11 @@ impl LedStripConfigGroup {
}
}
#[derive(Clone, Copy, Serialize, Deserialize, Debug)]
pub struct LedStripConfigOfDisplays {
pub id: u32,
pub index_of_display: usize,
pub led_strip_of_borders: LedStripConfigOfBorders,
}
impl LedStripConfigOfBorders {
pub fn default() -> Self {
Self {
top: None,
bottom: None,
left: None,
right: None,
}
}
}
impl LedStripConfigOfDisplays {
pub fn default(id: u32, index_of_display: usize) -> Self {
Self {
id,
index_of_display,
led_strip_of_borders: LedStripConfigOfBorders::default(),
}
}
pub async fn read_from_disk() -> anyhow::Result<Self> {
let path = config_dir()
.unwrap_or(current_dir().unwrap())
.join("led_strip_config_of_displays.toml");
let exists = tokio::fs::try_exists(path.clone())
.await
.map_err(|e| anyhow::anyhow!("Failed to check config file exists: {}", e))?;
if exists {
let config = tokio::fs::read_to_string(path).await?;
let config: Self = toml::from_str(&config)
.map_err(|e| anyhow::anyhow!("Failed to parse config file: {}", e))?;
Ok(config)
} else {
info!("config file not exist, fallback to default config");
Ok(Self::get_default_config().await?)
}
}
pub async fn write_to_disk(&self) -> anyhow::Result<()> {
let path = config_dir()
.unwrap_or(current_dir().unwrap())
.join("led_strip_config_of_displays.toml");
let config = toml::to_string(self).map_err(|e| {
anyhow::anyhow!("Failed to parse config file: {}. config: {:?}", e, self)
})?;
tokio::fs::write(&path, config).await.map_err(|e| {
anyhow::anyhow!("Failed to write config file: {}. path: {:?}", e, &path)
})?;
Ok(())
}
pub async fn get_default_config() -> anyhow::Result<Self> {
let displays = display_info::DisplayInfo::all().map_err(|e| {
error!("can not list display info: {}", e);
anyhow::anyhow!("can not list display info: {}", e)
})?;
let mut configs = Vec::new();
for (i, display) in displays.iter().enumerate() {
let config = Self {
id: display.id,
index_of_display: i,
led_strip_of_borders: LedStripConfigOfBorders {
top: Some(LedStripConfig {
index: i * 4 * 30,
display_id: display.id,
border: Border::Top,
start_pos: i * 4 * 30,
len: 30,
}),
bottom: Some(LedStripConfig {
index: i * 4 * 30 + 30,
display_id: display.id,
border: Border::Bottom,
start_pos: i * 4 * 30 + 30,
len: 30,
}),
left: Some(LedStripConfig {
index: i * 4 * 30 + 60,
display_id: display.id,
border: Border::Left,
start_pos: i * 4 * 30 + 60,
len: 30,
}),
right: Some(LedStripConfig {
index: i * 4 * 30 + 90,
display_id: display.id,
border: Border::Right,
start_pos: i * 4 * 30 + 90,
len: 30,
}),
},
};
configs.push(config);
}
Ok(configs[0])
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SamplePointMapper {
pub start: usize,
pub end: usize,
pub pos: usize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]

33
src-tauri/src/ambient_light/config_manager.rs
View File

@ -122,7 +122,8 @@ impl ConfigManager {
log::info!("mapper: {:?}", mapper);
}
}
log::info!("mapper: {:?}", config.mappers[4]);
Self::rebuild_mappers(&mut config);
let cloned_config = config.clone();
@ -138,17 +139,31 @@ impl ConfigManager {
}
fn rebuild_mappers(config: &mut LedStripConfigGroup) {
let mut prev_end = 0;
let mut prev_pos_end = 0;
let mappers: Vec<SamplePointMapper> = config
.strips
.iter()
.map(|strip| {
let mapper = SamplePointMapper {
start: prev_end,
end: prev_end + strip.len,
};
prev_end = mapper.end;
mapper
.enumerate()
.map(|(index, strip)| {
let mapper = &config.mappers[index];
if mapper.start < mapper.end {
let mapper = SamplePointMapper {
start: mapper.start,
end: mapper.start + strip.len,
pos: prev_pos_end,
};
prev_pos_end = prev_pos_end + strip.len;
mapper
} else {
let mapper = SamplePointMapper {
end: mapper.end,
start: mapper.end + strip.len,
pos: prev_pos_end,
};
prev_pos_end = prev_pos_end + strip.len;
mapper
}
})
.collect();

17
src-tauri/src/screenshot_manager.rs
View File

@ -236,22 +236,33 @@ impl ScreenshotManager {
pub async fn get_sorted_colors(colors: &Vec<LedColor>, mappers: &Vec<SamplePointMapper>) -> Vec<u8> {
let total_leds = mappers
.iter()
.map(|mapper| mapper.end)
.map(|mapper| usize::max(mapper.start, mapper.end))
.max()
.unwrap_or(0) as usize;
let mut global_colors = vec![0u8; total_leds * 3];
let mut color_index = 0;
mappers.iter().for_each(|group| {
if group.end > colors.len() || group.start > colors.len() {
if group.end > global_colors.len() || group.start > global_colors.len() {
warn!(
"get_sorted_colors: group out of range. start: {}, end: {}, colors.len(): {}",
"get_sorted_colors: group out of range. start: {}, end: {}, global_colors.len(): {}",
group.start,
group.end,
global_colors.len()
);
return;
}
if color_index + group.start.abs_diff(group.end) > colors.len() {
warn!(
"get_sorted_colors: color_index out of range. color_index: {}, strip len: {}, colors.len(): {}",
color_index,
group.start.abs_diff(group.end),
colors.len()
);
return;
}
if group.end > group.start {
for i in group.start..group.end {
let rgb = colors[color_index].get_rgb();