notedeck

blur.rs (4705B)

---

 use std::collections::HashMap;
 
 use nostrdb::Note;
 
 use crate::jobs::{Job, JobError, JobParamsOwned};
 
 #[derive(Clone)]
 pub struct Blur<'a> {
     pub blurhash: &'a str,
     pub dimensions: Option<PixelDimensions>, // width and height in pixels
 }
 
 #[derive(Clone, Debug)]
 pub struct PixelDimensions {
     pub x: u32,
     pub y: u32,
 }
 
 impl PixelDimensions {
     pub fn to_points(&self, ppp: f32) -> PointDimensions {
         PointDimensions {
             x: (self.x as f32) / ppp,
             y: (self.y as f32) / ppp,
         }
     }
 }
 
 #[derive(Clone, Debug)]
 pub struct PointDimensions {
     pub x: f32,
     pub y: f32,
 }
 
 impl PointDimensions {
     pub fn to_pixels(self, ui: &egui::Ui) -> PixelDimensions {
         PixelDimensions {
             x: (self.x * ui.pixels_per_point()).round() as u32,
             y: (self.y * ui.pixels_per_point()).round() as u32,
         }
     }
 
     pub fn to_vec(self) -> egui::Vec2 {
         egui::Vec2::new(self.x, self.y)
     }
 }
 
 impl Blur<'_> {
     pub fn scaled_pixel_dimensions(
         &self,
         ui: &egui::Ui,
         available_points: PointDimensions,
     ) -> PixelDimensions {
         let max_pixels = available_points.to_pixels(ui);
 
         let Some(defined_dimensions) = &self.dimensions else {
             return max_pixels;
         };
 
         if defined_dimensions.x == 0 || defined_dimensions.y == 0 {
             tracing::error!("The blur dimensions should not be zero");
             return max_pixels;
         }
 
         if defined_dimensions.y <= max_pixels.y {
             return defined_dimensions.clone();
         }
 
         let scale_factor = (max_pixels.y as f32) / (defined_dimensions.y as f32);
         let max_width_scaled = scale_factor * (defined_dimensions.x as f32);
 
         PixelDimensions {
             x: (max_width_scaled.round() as u32),
             y: max_pixels.y,
         }
     }
 }
 
 pub fn imeta_blurhashes<'a>(note: &'a Note) -> HashMap<&'a str, Blur<'a>> {
     let mut blurs = HashMap::new();
 
     for tag in note.tags() {
         let mut tag_iter = tag.into_iter();
         if tag_iter
             .next()
             .and_then(|s| s.str())
             .filter(|s| *s == "imeta")
             .is_none()
         {
             continue;
         }
 
         let Some((url, blur)) = find_blur(tag_iter) else {
             continue;
         };
 
         blurs.insert(url, blur);
     }
 
     blurs
 }
 
 fn find_blur(tag_iter: nostrdb::TagIter) -> Option<(&str, Blur)> {
     let mut url = None;
     let mut blurhash = None;
     let mut dims = None;
 
     for tag_elem in tag_iter {
         let Some(s) = tag_elem.str() else { continue };
         let mut split = s.split_whitespace();
 
         let Some(first) = split.next() else { continue };
         let Some(second) = split.next() else { continue };
 
         match first {
             "url" => url = Some(second),
             "blurhash" => blurhash = Some(second),
             "dim" => dims = Some(second),
             _ => {}
         }
 
         if url.is_some() && blurhash.is_some() && dims.is_some() {
             break;
         }
     }
 
     let url = url?;
     let blurhash = blurhash?;
 
     let dimensions = dims.and_then(|d| {
         let mut split = d.split('x');
         let width = split.next()?.parse::<u32>().ok()?;
         let height = split.next()?.parse::<u32>().ok()?;
 
         Some(PixelDimensions {
             x: width,
             y: height,
         })
     });
 
     Some((
         url,
         Blur {
             blurhash,
             dimensions,
         },
     ))
 }
 
 #[derive(Clone)]
 pub enum ObfuscationType<'a> {
     Blurhash(Blur<'a>),
     Default,
 }
 
 pub(crate) fn compute_blurhash(
     params: Option<JobParamsOwned>,
     dims: PixelDimensions,
 ) -> Result<Job, JobError> {
     #[allow(irrefutable_let_patterns)]
     let Some(JobParamsOwned::Blurhash(params)) = params
     else {
         return Err(JobError::InvalidParameters);
     };
 
     let maybe_handle = match generate_blurhash_texturehandle(
         &params.ctx,
         &params.blurhash,
         &params.url,
         dims.x,
         dims.y,
     ) {
         Ok(tex) => Some(tex),
         Err(e) => {
             tracing::error!("failed to render blurhash: {e}");
             None
         }
     };
 
     Ok(Job::Blurhash(maybe_handle))
 }
 
 fn generate_blurhash_texturehandle(
     ctx: &egui::Context,
     blurhash: &str,
     url: &str,
     width: u32,
     height: u32,
 ) -> notedeck::Result<egui::TextureHandle> {
     let bytes = blurhash::decode(blurhash, width, height, 1.0)
         .map_err(|e| notedeck::Error::Generic(e.to_string()))?;
 
     let img = egui::ColorImage::from_rgba_unmultiplied([width as usize, height as usize], &bytes);
     Ok(ctx.load_texture(url, img, Default::default()))
 }