ebur128_stream 0.1.0

data/ext/ebur128_stream/src/lib.rs

@@ -0,0 +1,123 @@
+mod analyzer;
+mod error;
+mod normalize;
+mod report;
+mod samples;
+mod snapshot;
+
+use crate::{
+    error::Error,
+    report::Report,
+    samples::{InterleavedSamples, PlanarSamples},
+    snapshot::Snapshot,
+};
+use ebur128_stream_rs as engine;
+use magnus::{RArray, Ruby, Symbol, TryConvert, Value};
+use std::ops::Deref;
+
+struct Channel(engine::Channel);
+
+impl From<Channel> for engine::Channel {
+    fn from(value: Channel) -> Self {
+        value.0
+    }
+}
+
+impl TryConvert for Channel {
+    fn try_convert(val: Value) -> Result<Self, magnus::Error> {
+        let channel = Symbol::try_convert(val)?;
+        Ok(match channel.name()?.as_ref() {
+            "left" => Self(engine::Channel::Left),
+            "right" => Self(engine::Channel::Right),
+            "center" => Self(engine::Channel::Center),
+            "left_surround" => Self(engine::Channel::LeftSurround),
+            "right_surround" => Self(engine::Channel::RightSurround),
+            "lfe" => Self(engine::Channel::Lfe),
+            "other" => Self(engine::Channel::Other),
+            _ => {
+                let ruby = Ruby::get_with(val);
+                return Err(magnus::Error::new(
+                    ruby.exception_arg_error(),
+                    format!("unknown channel: {val}"),
+                ));
+            }
+        })
+    }
+}
+
+pub(crate) struct Channels {
+    inner: Vec<engine::Channel>,
+}
+
+impl Deref for Channels {
+    type Target = Vec<engine::Channel>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
+impl<'a> From<&'a [engine::Channel]> for Channels {
+    fn from(value: &'a [engine::Channel]) -> Self {
+        Self {
+            inner: value.to_vec(),
+        }
+    }
+}
+
+impl TryConvert for Channels {
+    fn try_convert(val: Value) -> Result<Self, magnus::Error> {
+        Ok(Self {
+            inner: RArray::try_convert(val)?
+                .into_iter()
+                .map(|value| Ok(Channel::try_convert(value)?.into()))
+                .collect::<Result<Vec<engine::Channel>, magnus::Error>>()?,
+        })
+    }
+}
+
+impl Channels {
+    fn try_into_rarray(&self, ruby: &Ruby) -> Result<RArray, magnus::Error> {
+        let syms = self
+            .inner
+            .iter()
+            .map(|channel| {
+                use engine::Channel::*;
+
+                let str = match channel {
+                    Left => "left",
+                    Right => "right",
+                    Center => "center",
+                    LeftSurround => "left_surround",
+                    RightSurround => "right_surround",
+                    Lfe => "lfe",
+                    Other => "other",
+                    _ => {
+                        return Err(magnus::Error::new(
+                            ruby.exception_runtime_error(),
+                            "couldn't convert to Symbol: {channel}",
+                        ));
+                    }
+                };
+                Ok(ruby.to_symbol(str))
+            })
+            .collect::<Result<Vec<Symbol>, magnus::Error>>()?;
+        Ok(ruby.ary_new_from_values(&syms))
+    }
+
+    fn into_boxed_slice(self) -> Box<[engine::Channel]> {
+        self.inner.into_boxed_slice()
+    }
+}
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let ebur128_stream = ruby.define_module("EBUR128Stream")?;
+
+    analyzer::init(ruby, &ebur128_stream)?;
+    snapshot::init(ruby, &ebur128_stream)?;
+    report::init(ruby, &ebur128_stream)?;
+    normalize::init(ruby, &ebur128_stream)?;
+
+    Ok(())
+}

data/ext/ebur128_stream/src/normalize.rs

@@ -0,0 +1,121 @@
+use crate::{Channels, error::Error, samples::WritableInterleavedSamples};
+use ebur128_stream_rs as engine;
+use magnus::{
+    RModule, Ruby, Value, function, method,
+    prelude::*,
+    scan_args::{get_kwargs, scan_args},
+};
+
+// Members are the same to engine::normalize::Normalizer
+#[magnus::wrap(class = "EBUR128Stream::Normalizer")]
+struct Normalizer {
+    sample_rate: u32,
+    channels: Box<[engine::Channel]>,
+    target_lufs: Option<f64>,
+    true_peak_ceiling_dbtp: Option<f64>,
+}
+
+impl Normalizer {
+    fn new(args: &[Value]) -> Result<Self, Error> {
+        let args = scan_args::<(), (), (), (), _, ()>(args)?;
+        let kws = get_kwargs::<_, (u32, Channels), (Option<f64>, Option<f64>), ()>(
+            args.keywords,
+            &["sample_rate", "channels"],
+            &["target_lufs", "true_peak_ceiling_dbtp"],
+        )?;
+        let (sample_rate, channels) = kws.required;
+        let (target_lufs, true_peak_ceiling_dbtp) = kws.optional;
+
+        Ok(Self {
+            sample_rate,
+            channels: channels.into_boxed_slice(),
+            target_lufs,
+            true_peak_ceiling_dbtp,
+        })
+    }
+
+    fn normalize_in_place(
+        &self,
+        mut samples: WritableInterleavedSamples,
+    ) -> Result<NormalizeReport, Error> {
+        let mut normalizer = engine::normalize::Normalizer::new(self.sample_rate, &self.channels);
+        if let Some(target_lufs) = self.target_lufs {
+            normalizer = normalizer.target_lufs(target_lufs);
+        }
+        if let Some(true_peak_ceiling_dbtp) = self.true_peak_ceiling_dbtp {
+            normalizer = normalizer.true_peak_ceiling_dbtp(true_peak_ceiling_dbtp);
+        }
+
+        let report = normalizer
+            .normalize_in_place(samples.as_mut_slice())
+            .map_err(Error::runtime)?;
+        samples.write_back_in_place()?;
+
+        Ok(NormalizeReport { report })
+    }
+}
+
+#[magnus::wrap(class = "EBUR128Stream::NormalizeReport")]
+struct NormalizeReport {
+    report: engine::normalize::NormalizeReport,
+}
+
+impl NormalizeReport {
+    fn measured_integrated_lufs(&self) -> Option<f64> {
+        self.report.measured_integrated_lufs
+    }
+
+    fn measured_true_peak_dbtp(&self) -> Option<f64> {
+        self.report.measured_true_peak_dbtp
+    }
+
+    fn target_lufs(&self) -> f64 {
+        self.report.target_lufs
+    }
+
+    fn true_peak_ceiling_dbtp(&self) -> Option<f64> {
+        self.report.true_peak_ceiling_dbtp
+    }
+
+    fn applied_gain_db(&self) -> f64 {
+        self.report.applied_gain_db
+    }
+
+    fn limited_by_true_peak(&self) -> bool {
+        self.report.limited_by_true_peak
+    }
+}
+
+pub(crate) fn init(ruby: &Ruby, module: &RModule) -> Result<(), Error> {
+    let normalizer = module.define_class("Normalizer", ruby.class_object())?;
+    normalizer.define_singleton_method("new", function!(Normalizer::new, -1))?;
+    normalizer.define_method(
+        "normalize_in_place",
+        method!(Normalizer::normalize_in_place, 1),
+    )?;
+
+    let normalize_report = module.define_class("NormalizeReport", ruby.class_object())?;
+    normalize_report.define_method(
+        "measured_integrated_lufs",
+        method!(NormalizeReport::measured_integrated_lufs, 0),
+    )?;
+    normalize_report.define_method(
+        "measured_true_peak_dbtp",
+        method!(NormalizeReport::measured_true_peak_dbtp, 0),
+    )?;
+    normalize_report.define_method("target_lufs", method!(NormalizeReport::target_lufs, 0))?;
+    normalize_report.define_method(
+        "true_peak_ceiling_dbtp",
+        method!(NormalizeReport::true_peak_ceiling_dbtp, 0),
+    )?;
+    normalize_report.define_method(
+        "applied_gain_db",
+        method!(NormalizeReport::applied_gain_db, 0),
+    )?;
+    normalize_report.define_method(
+        "limited_by_true_peak",
+        method!(NormalizeReport::limited_by_true_peak, 0),
+    )?;
+
+    Ok(())
+}

data/ext/ebur128_stream/src/report.rs

@@ -0,0 +1,52 @@
+use crate::error::Error;
+use ebur128_stream_rs as engine;
+use magnus::{RModule, Ruby, method, prelude::*};
+
+#[magnus::wrap(class = "EBUR128Stream::Report")]
+pub(crate) struct Report {
+    pub(crate) report: engine::Report,
+}
+
+impl Report {
+    fn integrated_lufs(&self) -> Option<f64> {
+        self.report.integrated_lufs()
+    }
+
+    fn loudness_range_lu(&self) -> Option<f64> {
+        self.report.loudness_range_lu()
+    }
+
+    fn true_peak_dbtp(&self) -> Option<f64> {
+        self.report.true_peak_dbtp()
+    }
+
+    fn momentary_max_lufs(&self) -> Option<f64> {
+        self.report.momentary_max_lufs()
+    }
+
+    fn short_term_max_lufs(&self) -> Option<f64> {
+        self.report.short_term_max_lufs()
+    }
+
+    fn programme_duration_seconds(&self) -> f64 {
+        self.report.programme_duration_seconds()
+    }
+}
+
+pub(crate) fn init(ruby: &Ruby, module: &RModule) -> Result<(), Error> {
+    let report = module.define_class("Report", ruby.class_object())?;
+    report.define_method("integrated_lufs", method!(Report::integrated_lufs, 0))?;
+    report.define_method("loudness_range_lu", method!(Report::loudness_range_lu, 0))?;
+    report.define_method("true_peak_dbtp", method!(Report::true_peak_dbtp, 0))?;
+    report.define_method("momentary_max_lufs", method!(Report::momentary_max_lufs, 0))?;
+    report.define_method(
+        "short_term_max_lufs",
+        method!(Report::short_term_max_lufs, 0),
+    )?;
+    report.define_method(
+        "programme_duration_seconds",
+        method!(Report::programme_duration_seconds, 0),
+    )?;
+
+    Ok(())
+}

data/ext/ebur128_stream/src/samples.rs

@@ -0,0 +1,209 @@
+use crate::error::Error;
+use grey_knights::memory_view::{Flags, FlagsChainable, ItemComponent, ValidatedMemoryView};
+use magnus::{RArray, Ruby, TryConvert, Value, error::IntoError};
+
+fn is_acceptable_component(component: ItemComponent) -> bool {
+    component.offset == 0 && component.repeat == 1 && is_acceptable_format(component.format)
+}
+
+fn is_acceptable_format(format: char) -> bool {
+    match format {
+        'f' => true,
+
+        #[cfg(target_endian = "little")]
+        'e' => true,
+
+        #[cfg(target_endian = "big")]
+        'g' => true,
+
+        _ => false,
+    }
+}
+
+pub(crate) enum InterleavedSamples {
+    Array { samples: Vec<f32> },
+    MemoryView { view: ValidatedMemoryView<f32> },
+}
+
+impl TryConvert for InterleavedSamples {
+    fn try_convert(val: Value) -> Result<Self, magnus::Error> {
+        if let Some(view) = Self::consume_memory_view(val) {
+            Ok(Self::MemoryView { view })
+        } else if let Some(obj) = RArray::from_value(val) {
+            Ok(Self::Array {
+                samples: obj.to_vec()?,
+            })
+        } else {
+            Err(Error::argument(format!("unsupported samples type: {val}"))
+                .into_error(&Ruby::get_with(val)))
+        }
+    }
+}
+
+impl InterleavedSamples {
+    pub(crate) fn as_slice(&self) -> &[f32] {
+        match self {
+            Self::Array { samples } => samples,
+            Self::MemoryView { view } => view.data(),
+        }
+    }
+
+    fn consume_memory_view(val: Value) -> Option<ValidatedMemoryView<f32>> {
+        let view = ValidatedMemoryView::<f32>::new(val, Flags::any_contiguous());
+        if let Ok(mut view) = view {
+            if Self::is_acceptable(&mut view).unwrap_or(false) {
+                return Some(view);
+            }
+        }
+        let view = ValidatedMemoryView::<f32>::new(val, Flags::simple());
+        if let Ok(mut view) = view {
+            if Self::is_acceptable(&mut view).unwrap_or(false) {
+                return Some(view);
+            }
+        }
+        None
+    }
+
+    // TODO: Check format more strictly(size, other expression)
+    fn is_acceptable(view: &mut ValidatedMemoryView<f32>) -> Result<bool, Error> {
+        let item_desc = view.item_desc()?;
+        Ok(view.ndim() == 1
+            && item_desc.len() == 1
+            && item_desc
+                .into_iter()
+                .next()
+                .is_some_and(is_acceptable_component))
+    }
+}
+
+pub(crate) enum WritableInterleavedSamples {
+    Array { obj: RArray, samples: Vec<f32> },
+    MemoryView { view: ValidatedMemoryView<f32> },
+}
+
+impl TryConvert for WritableInterleavedSamples {
+    fn try_convert(val: Value) -> Result<Self, magnus::Error> {
+        if let Some(view) = Self::consume_memory_view(val) {
+            Ok(Self::MemoryView { view })
+        } else if let Some(obj) = RArray::from_value(val) {
+            Ok(Self::Array {
+                obj,
+                samples: obj.to_vec()?,
+            })
+        } else {
+            Err(Error::argument(format!("unsupported samples type: {val}"))
+                .into_error(&Ruby::get_with(val)))
+        }
+    }
+}
+
+impl WritableInterleavedSamples {
+    pub(crate) fn as_mut_slice(&mut self) -> &mut [f32] {
+        match self {
+            Self::Array { obj: _, samples } => samples,
+            Self::MemoryView { view } => view.data_as_mut(),
+        }
+    }
+
+    pub(crate) fn write_back_in_place(self) -> Result<(), Error> {
+        match self {
+            Self::Array { obj, samples } => {
+                let ruby = Ruby::get_with(obj);
+                obj.replace(ruby.ary_from_vec(samples))?;
+            }
+            Self::MemoryView { view: _ } => {}
+        }
+
+        Ok(())
+    }
+
+    fn consume_memory_view(val: Value) -> Option<ValidatedMemoryView<f32>> {
+        let view = ValidatedMemoryView::<f32>::new(val, Flags::writable().any_contiguous());
+        if let Ok(mut view) = view {
+            if Self::is_acceptable(&mut view).unwrap_or(false) {
+                return Some(view);
+            }
+        }
+        let view = ValidatedMemoryView::<f32>::new(val, Flags::simple());
+        if let Ok(mut view) = view {
+            if !view.is_readonly() && Self::is_acceptable(&mut view).unwrap_or(false) {
+                return Some(view);
+            }
+        }
+        None
+    }
+
+    fn is_acceptable(view: &mut ValidatedMemoryView<f32>) -> Result<bool, Error> {
+        let item_desc = view.item_desc()?;
+        Ok(view.ndim() == 1
+            && item_desc.len() == 1
+            && item_desc
+                .into_iter()
+                .next()
+                .is_some_and(is_acceptable_component))
+    }
+}
+
+pub(crate) enum PlanarSamples {
+    Array { samples: Vec<Vec<f32>> },
+    MemoryView { view: ValidatedMemoryView<f32> },
+}
+
+impl TryConvert for PlanarSamples {
+    fn try_convert(val: Value) -> Result<Self, magnus::Error> {
+        if let Some(view) = Self::consume_memory_view(val) {
+            Ok(Self::MemoryView { view })
+        } else if let Some(obj) = RArray::from_value(val) {
+            Ok(Self::Array {
+                samples: obj.to_vec()?,
+            })
+        } else {
+            Err(Error::argument(format!("unsupported samples type: {val}"))
+                .into_error(&Ruby::get_with(val)))
+        }
+    }
+}
+
+impl PlanarSamples {
+    pub fn channel_slices(&self) -> Vec<&[f32]> {
+        match self {
+            Self::Array { samples } => samples.iter().map(Vec::as_slice).collect(),
+            Self::MemoryView { view } => {
+                let shape = view.shape().expect("ndim > 1 is checked when calling ");
+                let n_channels = shape[0];
+                let channel_len = shape[1];
+                if channel_len == 0 {
+                    (0..n_channels).map(|_| &view.data()[..0]).collect()
+                } else {
+                    view.data().chunks_exact(channel_len).collect()
+                }
+            }
+        }
+    }
+
+    fn consume_memory_view(val: Value) -> Option<ValidatedMemoryView<f32>> {
+        let view = ValidatedMemoryView::<f32>::new(val, Flags::row_major());
+        if let Ok(mut view) = view {
+            if Self::is_acceptable(&mut view).unwrap_or(false) {
+                return Some(view);
+            }
+        }
+        let view = ValidatedMemoryView::<f32>::new(val, Flags::simple());
+        if let Ok(mut view) = view {
+            if Self::is_acceptable(&mut view).unwrap_or(false) {
+                return Some(view);
+            }
+        }
+        None
+    }
+
+    fn is_acceptable(view: &mut ValidatedMemoryView<f32>) -> Result<bool, Error> {
+        let item_desc = view.item_desc()?;
+        Ok(view.ndim() == 2
+            && item_desc.len() == 1
+            && item_desc
+                .into_iter()
+                .next()
+                .is_some_and(is_acceptable_component))
+    }
+}

data/ext/ebur128_stream/src/snapshot.rs

@@ -0,0 +1,49 @@
+use crate::Error;
+use ebur128_stream_rs as engine;
+use magnus::{RModule, Ruby, method, prelude::*};
+
+#[magnus::wrap(class = "EBUR128Stream::Snapshot")]
+pub(crate) struct Snapshot {
+    pub(crate) snapshot: engine::Snapshot,
+}
+
+impl Snapshot {
+    fn momentary_lufs(&self) -> Option<f64> {
+        self.snapshot.momentary_lufs()
+    }
+
+    fn short_term_lufs(&self) -> Option<f64> {
+        self.snapshot.short_term_lufs()
+    }
+
+    fn integrated_lufs(&self) -> Option<f64> {
+        self.snapshot.integrated_lufs()
+    }
+
+    fn true_peak_dbtp(&self) -> Option<f64> {
+        self.snapshot.true_peak_dbtp()
+    }
+
+    fn loudness_range_lu(&self) -> Option<f64> {
+        self.snapshot.loudness_range_lu()
+    }
+
+    fn programme_duration_seconds(&self) -> f64 {
+        self.snapshot.programme_duration_seconds()
+    }
+}
+
+pub(crate) fn init(ruby: &Ruby, module: &RModule) -> Result<(), Error> {
+    let snapshot = module.define_class("Snapshot", ruby.class_object())?;
+    snapshot.define_method("momentary_lufs", method!(Snapshot::momentary_lufs, 0))?;
+    snapshot.define_method("short_term_lufs", method!(Snapshot::short_term_lufs, 0))?;
+    snapshot.define_method("integrated_lufs", method!(Snapshot::integrated_lufs, 0))?;
+    snapshot.define_method("loudness_range_lu", method!(Snapshot::loudness_range_lu, 0))?;
+    snapshot.define_method("true_peak_dbtp", method!(Snapshot::true_peak_dbtp, 0))?;
+    snapshot.define_method(
+        "programme_duration_seconds",
+        method!(Snapshot::programme_duration_seconds, 0),
+    )?;
+
+    Ok(())
+}

data/lib/ebur128_stream/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module EBUR128Stream
+  VERSION = "0.1.0"
+end

data/lib/ebur128_stream.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative "ebur128_stream/version"
+require "ebur128_stream/ebur128_stream"
+
+module EBUR128Stream
+  class Error < StandardError; end
+
+  module Reportable
+    def deconstruct_keys(keys = nil)
+      keys = self.class::ATTRS if keys.nil?
+      (keys & self.class::ATTRS).inject({}) {|deconstructed, attr|
+        deconstructed[attr] = send(attr)
+        deconstructed
+      }
+    end
+
+    def inspect
+      "#<%{class} %{attrs}>" % {
+        class: self.class,
+        attrs: self.class::ATTRS.collect {|attr| "#{attr}=#{send(attr).inspect}"}.join(" ")
+      }
+    end
+
+    def ==(other)
+      deconstruct_keys(nil) == other.deconstruct_keys(nil)
+    end
+  end
+
+  class Snapshot
+    include Reportable
+
+    ATTRS = [
+      :momentary_lufs,
+      :short_term_lufs,
+      :integrated_lufs,
+      :loudness_range_lu,
+      :true_peak_dbtp,
+      :programme_duration_seconds
+    ]
+  end
+
+  class Report
+    include Reportable
+
+    ATTRS = [
+      :integrated_lufs,
+      :loudness_range_lu,
+      :true_peak_dbtp,
+      :momentary_max_lufs,
+      :short_term_max_lufs,
+      :programme_duration_seconds
+    ]
+  end
+
+  class NormalizeReport
+    include Reportable
+
+    ATTRS = [
+      :measured_integrated_lufs,
+      :measured_true_peak_dbtp,
+      :target_lufs,
+      :true_peak_ceiling_dbtp,
+      :applied_gain_db,
+      :limited_by_true_peak,
+    ]
+  end
+end