vizcore 0.1.0 → 1.1.0

data/lib/vizcore/renderer/scene_frame_source.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require_relative "../analysis"
+require_relative "../audio"
+require_relative "../dsl"
+
+module Vizcore
+  module Renderer
+    # Produces analyzed scene frames for offline renderers.
+    class SceneFrameSource
+      def initialize(config:, frame_rate: nil)
+        @config = config
+        @frame_rate = frame_rate
+        @shader_source_resolver = Vizcore::DSL::ShaderSourceResolver.new
+      end
+
+      # @return [Vizcore::Renderer::SceneFrameSource]
+      def start
+        @definition = resolve_shader_sources(Vizcore::DSL::Engine.load_file(@config.scene_file.to_s))
+        @scene = first_scene(@definition)
+        @input_manager = build_input_manager
+        @input_manager.start
+        @capture_size = capture_size
+        @pipeline = build_pipeline
+        @frame_count = 0
+        self
+      end
+
+      # @return [Hash] frame data consumed by offline renderers
+      def capture
+        ensure_started!
+
+        audio = @pipeline.call(@input_manager.capture_frame(@capture_size))
+        @frame_count += 1
+        layers = Vizcore::DSL::MappingResolver.new.resolve_layers(
+          scene_layers: @scene[:layers],
+          audio: audio,
+          time: frame_time,
+          frame: @frame_count
+        )
+
+        {
+          scene: { name: @scene[:name], layers: layers },
+          audio: audio,
+          scene_name: @scene[:name].to_s
+        }
+      end
+
+      # @return [void]
+      def stop
+        @input_manager&.stop
+      end
+
+      private
+
+      def resolve_shader_sources(definition)
+        @shader_source_resolver.resolve(definition: definition, scene_file: @config.scene_file.to_s)
+      end
+
+      def first_scene(definition)
+        scene = Array(definition[:scenes]).first
+        return scene if scene
+
+        { name: @config.scene_file.basename(".rb").to_sym, layers: [] }
+      end
+
+      def build_input_manager
+        Vizcore::Audio::InputManager.new(
+          source: @config.audio_source,
+          file_path: @config.audio_file&.to_s,
+          audio_device: @config.audio_device
+        )
+      end
+
+      def capture_size
+        return @input_manager.frame_size unless @frame_rate
+
+        @input_manager.realtime_capture_size(@frame_rate)
+      end
+
+      def build_pipeline
+        Vizcore::Analysis::Pipeline.new(
+          sample_rate: @input_manager.sample_rate,
+          fft_size: supported_fft_size(@input_manager.frame_size),
+          noise_gate: @config.noise_gate,
+          audio_normalize: audio_normalize_settings,
+          bpm: bpm_setting,
+          bpm_lock: bpm_lock_setting
+        )
+      end
+
+      def frame_time
+        return 0.0 unless @frame_rate
+
+        (@frame_count - 1).fdiv(@frame_rate)
+      end
+
+      def audio_normalize_settings
+        Hash(@definition[:analysis] || {})[:audio_normalize]
+      rescue StandardError
+        nil
+      end
+
+      def bpm_setting
+        @config.bpm || Hash(@definition[:analysis] || {})[:bpm]
+      rescue StandardError
+        @config.bpm
+      end
+
+      def bpm_lock_setting
+        @config.bpm_lock? || !!Hash(@definition[:analysis] || {})[:bpm_lock]
+      rescue StandardError
+        @config.bpm_lock?
+      end
+
+      def supported_fft_size(size)
+        value = Integer(size)
+        return value if value.positive? && (value & (value - 1)).zero?
+
+        1024
+      rescue StandardError
+        1024
+      end
+
+      def ensure_started!
+        return if @input_manager && @pipeline && @scene
+
+        raise RuntimeError, "scene frame source has not been started"
+      end
+    end
+  end
+end

data/lib/vizcore/renderer/scene_serializer.rb

@@ -9,28 +9,39 @@ module Vizcore
       # @param scene_name [String, Symbol]
       # @param scene_layers [Array<Hash>]
       # @param transition [Hash, nil]
+      # @param metrics [Hash, nil]
       # @return [Hash]
-      def audio_frame(timestamp:, audio:, scene_name:, scene_layers:, transition: nil)
-        {
+      def audio_frame(timestamp:, audio:, scene_name:, scene_layers:, transition: nil, metrics: nil)
+        frame = {
           timestamp: Float(timestamp),
           audio: serialize_audio(audio),
           scene: serialize_scene(scene_name, scene_layers),
           transition: transition
         }
+        frame[:metrics] = serialize_metrics(metrics) if metrics
+        frame
       end
 
       private
 
       def serialize_audio(audio)
         bands = symbolize_hash(audio[:bands])
+        onsets = { sub: 0.0, low: 0.0, mid: 0.0, high: 0.0 }.merge(symbolize_hash(audio[:onsets]))
+        drums = { kick: 0.0, snare: 0.0, hihat: 0.0 }.merge(symbolize_hash(audio[:drums]))
 
         {
           amplitude: round_float(audio[:amplitude]),
           bands: bands.transform_values { |value| round_float(value) },
           fft: Array(audio[:fft]).map { |value| round_float(value) },
+          onset: round_float(audio[:onset]),
+          onsets: onsets.transform_values { |value| round_float(value) },
+          drums: drums.transform_values { |value| round_float(value) },
           beat: !!audio[:beat],
+          beat_confidence: round_float(audio[:beat_confidence]),
+          beat_pulse: round_float(audio[:beat_pulse]),
           beat_count: Integer(audio[:beat_count] || 0),
-          bpm: audio[:bpm]
+          bpm: audio[:bpm],
+          peak_frequency: round_float(audio[:peak_frequency])
         }
       end
 
@@ -52,9 +63,31 @@ module Vizcore
         output[:shader] = values[:shader].to_s if values[:shader]
         output[:glsl] = values[:glsl].to_s if values[:glsl]
         output[:glsl_source] = values[:glsl_source].to_s if values[:glsl_source]
+        output[:param_schema] = serialize_param_schema(values[:param_schema]) if values[:param_schema]
         output
       end
 
+      def serialize_param_schema(schema)
+        Array(schema).map do |entry|
+          values = symbolize_hash(entry)
+          {
+            name: values.fetch(:name).to_s,
+            default: round_float(values[:default]),
+            min: round_float(values[:min]),
+            max: round_float(values[:max]),
+            step: round_float(values[:step])
+          }.compact
+        end
+      end
+
+      def serialize_metrics(metrics)
+        symbolize_hash(metrics).each_with_object({}) do |(key, value), output|
+          output[key] = key == :frame_id ? Integer(value) : round_float(value)
+        rescue StandardError
+          output[key] = 0
+        end
+      end
+
       def symbolize_hash(value)
         Hash(value).each_with_object({}) do |(key, entry), output|
           output[key.to_sym] = entry

data/lib/vizcore/renderer/snapshot.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "pathname"
+require_relative "scene_frame_source"
+require_relative "snapshot_renderer"
+
+module Vizcore
+  module Renderer
+    # Builds one analyzed scene frame and writes a PNG preview.
+    class Snapshot
+      def initialize(config:, width: SnapshotRenderer::DEFAULT_WIDTH, height: SnapshotRenderer::DEFAULT_HEIGHT)
+        @config = config
+        @width = width
+        @height = height
+      end
+
+      # @param out [String, Pathname]
+      # @return [Hash] snapshot metadata
+      def write(out:)
+        output_path = Pathname.new(out.to_s).expand_path
+        frame_source = SceneFrameSource.new(config: @config)
+        frame_source.start
+        frame = frame_source.capture
+        png = SnapshotRenderer.new(width: @width, height: @height).render(
+          scene: frame.fetch(:scene),
+          audio: frame.fetch(:audio)
+        )
+
+        FileUtils.mkdir_p(output_path.dirname)
+        File.binwrite(output_path, png)
+        { path: output_path, scene: frame.fetch(:scene_name), width: @width, height: @height }
+      ensure
+        frame_source&.stop
+      end
+    end
+  end
+end