add Fp32ToUInt16 node

README.md

@@ -206,6 +206,16 @@ Some Nodes e.g. `RawBlobReader` or `RawDirectoryReader` need to know how to inte
 
 These parameters only specify the interpretation but no conversions. So if you want to get an RGB image from a Bayer source you still need to take care of conversion with a `Debayer` node in between.
 
+### DNG output
+In the pipeline of the AXIOM raw recorder, sometimes images in floating point format can occur
+(for example when averaging multiple frames). Although the DNG specification specifies floating 
+point DNG files, not a lot of software actually supports it. To avoid issues with downstream
+processing software you can convert your data to uint16 before writing DNG files. Example:
+
+```shell
+$ target/release/cli from-cli RawBlobReader --fp32 --width 3840 --height 2160 --bayer GBRG --file Halogen_Xrite_0_8ms.raw32 ! Fp32ToUInt16 --multiplier 16 ! CinemaDngWriter --path out
+```
+
 ## Examples
 
 Convert a directory of raw12 files from the Beta to mp4 (h264) using FFmpeg:

src/nodes.rs

@@ -9,6 +9,7 @@ use crate::{
         //average::Average,
         benchmark_sink::BenchmarkSink,
         dual_frame_raw_decoder::{DualFrameRawDecoder, ReverseDualFrameRawDecoder},
+        fp_to_uint::Fp32ToUInt16,
         //sz3::SZ3Compress,
         zstd::ZstdBlobReader,
     },
@@ -98,4 +99,5 @@ generate_dynamic_node_creation_functions![
     FfmpegWriter,
     CinemaDngFrameserver,
     NullFrameSource,
+    Fp32ToUInt16,
 ];

src/nodes_cpu/fp_to_uint.rs

@@ -0,0 +1,78 @@
+use crate::pipeline_processing::{
+    node::InputProcessingNode,
+    parametrizable::{Parameterizable, Parameters, ParametersDescriptor},
+    payload::Payload,
+};
+use anyhow::{bail, Context, Result};
+
+
+use crate::pipeline_processing::{
+    frame::{Frame, FrameInterpretation, SampleInterpretation},
+    node::{Caps, NodeID, ProcessingNode, Request},
+    parametrizable::prelude::*,
+    processing_context::ProcessingContext,
+};
+use async_trait::async_trait;
+
+pub struct Fp32ToUInt16 {
+    input: InputProcessingNode,
+    context: ProcessingContext,
+    multiplier: f32,
+}
+impl Parameterizable for Fp32ToUInt16 {
+    fn describe_parameters() -> ParametersDescriptor {
+        ParametersDescriptor::new()
+            .with("input", Mandatory(NodeInputParameter))
+            .with("multiplier", WithDefault(PositiveReal(), FloatRangeValue(1.0)))
+    }
+
+    fn from_parameters(
+        mut parameters: Parameters,
+        _is_input_to: &[NodeID],
+        context: &ProcessingContext,
+    ) -> Result<Self> {
+        Ok(Self {
+            input: parameters.take("input")?,
+            multiplier: parameters.take("multiplier")?,
+            context: context.clone(),
+        })
+    }
+}
+
+#[async_trait]
+impl ProcessingNode for Fp32ToUInt16 {
+    async fn pull(&self, request: Request) -> Result<Payload> {
+        let input = self.input.pull(request).await?;
+        let frame = self
+            .context
+            .ensure_cpu_buffer_frame(&input)
+            .context("Wrong input format for FPotUint16")?;
+        let interpretation = FrameInterpretation {
+            sample_interpretation: SampleInterpretation::UInt(16),
+            ..frame.interpretation.clone()
+        };
+        let mut new_buffer =
+            unsafe { self.context.get_uninit_cpu_buffer(interpretation.required_bytes()) };
+
+        if let SampleInterpretation::FP32 = frame.interpretation.sample_interpretation {
+            new_buffer.as_mut_slice(|new_buffer| {
+                frame.storage.as_slice(|frame_storage| {
+                    let fp_storage: &[f32] = bytemuck::cast_slice(frame_storage);
+                    let uint_storage: &mut [u16] = bytemuck::cast_slice_mut(new_buffer);
+
+                    for (input, output) in fp_storage.iter().zip(uint_storage.iter_mut()) {
+                        *output = (*input * self.multiplier).round() as u16;
+                    }
+                })
+            });
+        } else {
+            bail!("only fp32 is a legal input to the Fp32ToUInt16 Node!")
+        }
+
+        let new_frame = Frame { storage: new_buffer, interpretation };
+
+        Ok(Payload::from(new_frame))
+    }
+
+    fn get_caps(&self) -> Caps { self.input.get_caps() }
+}

src/nodes_cpu/mod.rs

@@ -3,4 +3,5 @@ pub mod benchmark_sink;
 pub mod bitdepth_convert;
 pub mod dual_frame_raw_decoder;
 //pub mod sz3;
+pub mod fp_to_uint;
 pub mod zstd;