wavspa 0.1.0

data/ext/wavspa/wavelet/walet.h

@@ -0,0 +1,59 @@
+/*
+ * Wavelet transform library
+ *
+ *  Copyright (C) 2016 Hiroshi Kuwagata <kgt9221@gmail.com>
+ */
+
+/*
+ * $Id: walet.h 91 2016-07-04 03:05:03Z kgt $
+ */
+
+#ifndef __WALET_H__
+#define __WALET_H__
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+#define WALET_LINEARSCALE_MODE    1
+#define WALET_LOGSCALE_MODE       2
+
+typedef struct __walet__ {
+  int flags;
+
+  double fq_s;  // as "sampleing frequency"
+  double fq_l;  // as "low side frequency"
+  double fq_h;  // as "high side fequency"
+
+  double sigma;
+  double wk0;
+  double wk1;
+  double wk2;
+  int* ws;   // as window size list
+  double** exp;
+
+  int width;
+  int mode;
+  double step;
+
+  double* smpl; // as "sample data"
+  int n;        // as "number of sample size"
+
+  double* wt;
+} walet_t;
+
+int walet_new(walet_t** ptr);
+int walet_destroy(walet_t* ptr);
+
+int walet_set_sigma(walet_t* ptr, double sigma);
+int walet_set_frequency(walet_t* ptr, double freq);
+int walet_set_range(walet_t* ptr, double low, double high);
+int walet_set_scale_mode(walet_t* ptr, int mode);
+int walet_set_output_width(walet_t* ptr, int width);
+
+int walet_put_in(walet_t* ptr, char* fmt, void* data, size_t size);
+int walet_transform(walet_t* ptr, int pos);
+int walet_calc_power(walet_t* ptr, double* dst);
+int walet_calc_amplitude(walet_t* ptr, double* dst);
+
+#endif /* !defined(__WALET_H__) */

data/lib/wav.rb

@@ -0,0 +1,87 @@
+#!/usr/bin/env ruby
+#coding utf-8
+
+#
+# WAV file parser
+#
+#   Copyright (C) 2014 Hiroshi Kuwagata <kgt9221@gmail.com>
+#
+
+class WavFile
+  class << self
+    alias :open :new
+  end
+
+  def initialize(file)
+    @io = File.open(file, "rb")
+    
+    tmp = @io.read(12).unpack('a4Va4')
+
+    @magic         = tmp[0]
+    @data_size     = tmp[1]
+    @type          = tmp[2]
+
+    if not (@magic == "RIFF" and @type == "WAVE")
+      raise('Illeagal magic number.')
+    end
+
+    if @data_size != (File.size(file) - 8)
+      raise('Data size is not match.')
+    end
+
+    tmp = @io.read(8).unpack('a4V')
+
+    @id            = tmp[0]
+
+    if @id != 'fmt '
+      raise('ID "%s" is not supported.' % @id)
+    end
+
+    tmp = @io.read(tmp[1]).unpack('vvVVvv')
+
+    @format_id     = tmp[0]
+    @channel_num   = tmp[1]
+    @sample_rate   = tmp[2]
+    @bytes_per_sec = tmp[3]
+    @block_size    = tmp[4]
+    @sample_size   = tmp[5]
+
+    loop {
+      tmp = @io.read(8).unpack('a4V')
+      break if tmp[0] == "data"
+
+      @io.seek(tmp[1], IO::SEEK_CUR)
+    }
+
+    @data_offset   = @io.pos
+    @data_size     = tmp[1]
+  end
+
+  attr_reader :data_size, :channel_num, :sample_rate, :sample_size,
+              :bytes_per_sec, :block_size
+
+  def read(n = nil)
+    if not n.nil?
+      @io.read(@block_size * n)
+    else
+      @io.read
+    end
+  end
+
+  def seek(pos)
+    @io.seek(@block_size * pos, IO::SEEK_SET)
+  end
+
+  def eof?
+    @io.eof?
+  end
+
+  def close
+    @io.close
+  end
+end
+
+if $0 == __FILE__
+  require 'pp'
+  pp WavFile.open(ARGV[0])
+end

data/lib/wavspa/common.rb

@@ -0,0 +1,74 @@
+require "wavspa/version"
+
+module WavSpectrumAnalyzer
+  module Common
+    def log_scaler(r)
+      return 1.0 - ((Math.log(r / @lo_freq) / @log_base) / @output_width)
+    end
+
+    def linear_scaler(r)
+      return 1.0 - ((r - @lo_freq) / @freq_width)
+    end
+
+    def fpos(r)
+      scale = (@logscale)? log_scaler(r): linear_scaler(r)
+      return (scale * @output_width).round
+    end
+
+    def draw_freq_line(fb)
+      #
+      # 低周波方向
+      #
+      frq = @basis_freq / 2
+      loop {
+        pos  = fpos(frq)
+        break if pos > @output_width
+
+        fb.hline(pos, "#{frq.to_i}Hz")
+        frq /= 2
+      }
+     
+      #
+      # 高周波方向
+      #
+      frq = @basis_freq;
+      loop {
+        pos = fpos(frq)
+        break if pos <= 0 
+
+        fb.hline(pos, "#{frq.to_i}Hz")
+        frq *= 2
+      }
+    end
+
+    def time_str(tm)
+      m = tm / 60
+      s = tm % 60
+
+      if m.zero?
+        ret = %q{%d"} % s
+      else
+        ret = %q{%d'%02d"} % [m, s]
+      end
+
+      return ret
+    end
+
+    def draw_time_line(fb, wav, usize)
+      tc = 0
+      tm = 0
+      n  = (wav.data_size / (wav.sample_size / 8)) / usize
+
+      fb.vline(0, time_str(tm))
+
+      n.times { |col|
+        tc += usize;
+        if tc >= wav.sample_rate
+          tm += 1
+          tc %= wav.sample_rate
+          fb.vline(col, time_str(tm)) if (tm % 10).zero?
+        end
+      }
+    end
+  end
+end

data/lib/wavspa/version.rb

@@ -0,0 +1,3 @@
+module WavSpectrumAnalyzer
+  VERSION = "0.1.0"
+end

data/lib/wavspa/wavfft/main.rb

@@ -0,0 +1,130 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+#
+# Spectrum analyzer for WAV file
+#
+#   Copyright (C) 2019 Hiroshi Kuwagata <kgt9221@gmail.com>
+#
+
+require 'wav'
+require 'png'
+
+require 'wavspa/fft'
+require 'wavspa/fb'
+
+module WavSpectrumAnalyzer
+  module FFTApp
+    extend WavSpectrumAnalyzer::Common
+
+    class << self
+      def load_param(param)
+        @unit_time    = param[:unit_time]
+        @fft_size     = param[:fft_size]
+        @output_width = param[:output_width]
+        @logscale     = (param[:scale_mode] == :LOGSCALE)
+        @win_func     = param[:window_function]
+        @scale_mode   = param[:scale_mode]
+        @col_step     = param[:col_step]
+
+        @freq_range   = param[:range]
+        @lo_freq      = @freq_range[0]
+        @hi_freq      = @freq_range[1]
+        @freq_width   = (@hi_freq - @lo_freq)
+
+        @log_step     = (@hi_freq / @lo_freq) ** (1.0 / @output_width)
+        @log_base     = Math.log(@log_step)
+        @basis_freq   = 440.0
+      end
+      private :load_param
+
+      def main(input, param, output)
+        load_param(param)
+
+        wav = WavFile.open(input)
+        fft = FFT.new("s%dle" % wav.sample_size, @fft_size)
+
+        fft.window     = @win_func
+        fft.width      = @output_width
+        fft.scale_mode = @scale_mode
+        fft.frequency  = @freq_range.clone.unshift(wav.sample_rate)
+
+        line  = []
+        rows  = 0
+        usize = (wav.sample_rate / 100) * @unit_time
+        nblk  = (wav.data_size / (wav.sample_size / 8)) / usize
+
+        fb    = FrameBuffer.new(nblk,
+                                @output_width,
+                                :column_step => @col_step,
+                                :margin_x => ($draw_freq_line)? 50:0,
+                                :margin_y => ($draw_time_line)? 30:0)
+
+        if $verbose
+          STDERR.print <<~EOT
+            - input data
+              #{input}
+                data size:   #{wav.data_size}
+                channel num: #{wav.channel_num}
+                sample rate: #{wav.sample_rate} Hz
+                sample size: #{wav.sample_size} bits
+                data rate:   #{wav.bytes_per_sec} bytes/sec
+
+            - FFT parameter
+                FFT size:    #{@fft_size} samples
+                unit time:   #{@unit_time} cs
+                window func: #{@win_func}
+
+            - OUTPUT
+                width:       #{fb.width}px
+                height:      #{fb.height}px
+                freq range:  #{@lo_freq} - #{@hi_freq}Hz
+                scale mode:  #{@scale_mode}
+
+          EOT
+        end
+
+        if wav.channel_num >= 2
+          STDERR.print("error: multi chanel data is not supported " \
+                       "(support only monoral data).\n")
+          exit(1)
+        end
+       
+        until rows >= nblk
+          STDERR.printf("\rtransform #{rows + 1}/#{nblk}", rows) if $verbose
+
+          fft << wav.read(usize)
+
+          fft.spectrum.unpack("d*").each {|x|
+            begin
+              x = (x * 3.5).round 
+              x = 0 if x < 0 
+              x = 255 if x > 255
+            rescue
+              x = 0
+            end
+
+            line.unshift(x / 3, x, x / 2)
+          }
+
+          fb.put_column(rows, line)
+          line.clear
+
+          rows += 1
+        end
+
+        STDERR.printf(" ... done\n") if $verbose
+
+        STDERR.printf("write to #{output} ... ") if $verbose
+
+        draw_freq_line(fb) if $draw_freq_line
+        draw_time_line(fb, wav, usize) if $draw_time_line
+
+        png = PNG.encode(fb.width, fb.height, fb.to_s, :pixel_format => :RGB)
+        IO.binwrite(output, png)
+
+        STDERR.printf("done\n") if $verbose
+      end
+    end
+  end
+end

data/lib/wavspa/wavfft/preset.rb

@@ -0,0 +1,54 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+#
+# Spectrum analyzer for WAV file
+#
+#   Copyright (C) 2019 Hiroshi Kuwagata <kgt9221@gmail.com>
+#
+
+module WavSpectrumAnalyzer
+  module FFTApp
+    PRESET_TABLE = {
+      "default" => {
+        :unit_time       => 10,
+        :fft_size        => 16384,
+        :output_width    => 240,
+        :window_function => :FLAT_TOP,
+        :scale_mode      => :LOGSCALE,
+        :range            => [200, 8000],
+        :col_step        => 1,
+      },
+
+      "32k" => {
+        :unit_time       => 5,
+        :fft_size        => 32768,
+        :output_width    => 360,
+        :window_function => :FLAT_TOP,
+        :scale_mode      => :LOGSCALE,
+        :range            => [200, 16000],
+        :col_step        => 1,
+      },
+
+      "cd" => {
+        :unit_time       => 5,
+        :fft_size        => 32768,
+        :output_width    => 480,
+        :window_function => :FLAT_TOP,
+        :scale_mode      => :LOGSCALE,
+        :range            => [50, 22000],
+        :col_step        => 1,
+      },
+
+      "highreso" => {
+        :unit_time       => 5,
+        :fft_size        => 131072,
+        :window_function => :FLAT_TOP,
+        :output_width    => 640,
+        :scale_mode      => :LOGSCALE,
+        :range           => [200, 32000],
+        :col_step        => 1,
+      },
+    }
+  end
+end

data/lib/wavspa/wavlet/main.rb

@@ -0,0 +1,139 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+#
+# Spectrum analyzer for WAV file
+#
+#   Copyright (C) 2019 Hiroshi Kuwagata <kgt9221@gmail.com>
+#
+
+require 'wav'
+require 'png'
+
+require 'wavspa/wavelet'
+require 'wavspa/fb'
+
+module WavSpectrumAnalyzer
+  module WaveLetApp
+    extend WavSpectrumAnalyzer::Common
+
+    class << self
+      def load_param(param)
+        @unit_time    = param[:unit_time]
+        @sigma        = param[:sigma]
+        @ceil         = param[:ceil]
+        @floor        = param[:floor]
+        @tran_mode    = param[:transform_mode]
+        @output_width = param[:output_width]
+        @logscale     = (param[:scale_mode] == :LOGSCALE)
+        @scale_mode   = param[:scale_mode]
+        @col_step     = param[:col_step]
+
+        @freq_range   = param[:range]
+        @lo_freq      = @freq_range[0]
+        @hi_freq      = @freq_range[1]
+        @freq_width   = (@hi_freq - @lo_freq)
+
+        @log_step     = (@hi_freq / @lo_freq) ** (1.0 / @output_width)
+        @log_base     = Math.log(@log_step)
+        @basis_freq   = 440.0
+      end
+      private :load_param
+
+      def main(input, param, output)
+        load_param(param)
+
+        wav = WavFile.open(input)
+        wl  = Wavelet.new
+
+        wl.frequency  = wav.sample_rate
+        wl.sigma      = @sigma
+        wl.range      = (@lo_freq .. @hi_freq)
+        wl.scale_mode = @scale_mode
+        wl.width      = @output_width
+
+        wl.put_in("s%dle" % wav.sample_size, wav.read)
+
+        line  = []
+        rows  = 0
+
+        usize = (wav.sample_rate * @unit_time) / 1000
+        nblk  = (wav.data_size / wav.block_size) / usize
+
+        fb    = FrameBuffer.new(nblk,
+                                @output_width,
+                                :column_step => @col_step,
+                                :margin_x => ($draw_freq_line)? 50:0,
+                                :margin_y => ($draw_time_line)? 30:0)
+
+        if $verbose
+          STDERR.print <<~EOT
+            - input data
+              #{input}
+                data size:   #{wav.data_size}
+                channel num: #{wav.channel_num}
+                sample rate: #{wav.sample_rate} Hz
+                sample size: #{wav.sample_size} bits
+                data rate:   #{wav.bytes_per_sec} bytes/sec
+
+            - FFT parameter
+                sigma:       #{@sigma}
+                unit time:   #{@unit_time} ms
+                ceil:        #{@ceil}
+                floor:       #{@floor}
+                mode :       #{@tran_mode}
+
+            - OUTPUT
+                width:       #{fb.width}px
+                height:      #{fb.height}px
+                freq range:  #{@lo_freq} - #{@hi_freq}Hz
+                scale mode:  #{@scale_mode}
+
+          EOT
+        end
+
+        if wav.channel_num >= 2
+          STDERR.print("error: multi chanel data is not supported " \
+                       "(support only monoral data).\n")
+          exit(1)
+        end
+       
+        until rows >= nblk
+          STDERR.printf("\rtransform #{rows + 1}/#{nblk}", rows) if $verbose
+          wl.transform(rows * usize)
+
+          result = (@transform_mode == :POWER)? wl.power: wl.amplitude
+
+          result.unpack("d*").each {|x|
+            if x > @ceil
+              x = 255
+            elsif x < @floor
+              x = 0
+            else
+              x = ((255 * (x - @floor)) / (@ceil - @floor)).floor
+            end
+
+            line.unshift(x / 3, x, x / 2)
+          }
+
+          fb.put_column(rows, line)
+          line.clear
+
+          rows += 1
+        end
+
+        STDERR.printf(" ... done\n") if $verbose
+
+        STDERR.printf("write to #{output} ... ") if $verbose
+
+        draw_freq_line(fb) if $draw_freq_line
+        draw_time_line(fb, wav, usize) if $draw_time_line
+
+        png = PNG.encode(fb.width, fb.height, fb.to_s, :pixel_format => :RGB)
+        IO.binwrite(output, png)
+
+        STDERR.printf("done\n") if $verbose
+      end
+    end
+  end
+end

data/lib/wavspa/wavlet/preset.rb

@@ -0,0 +1,38 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+#
+# Spectrum analyzer for WAV file
+#
+#   Copyright (C) 2019 Hiroshi Kuwagata <kgt9221@gmail.com>
+#
+
+module WavSpectrumAnalyzer
+  module WaveLetApp
+    PRESET_TABLE = {
+      "default" => {
+        :sigma           => 24.0,
+        :unit_time       => 10 * 10,
+        :scale_mode      => :LOGSCALE,
+        :transform_mode  => :POWER,
+        :output_width    => 240,
+        :range           => [200.0, 8000.0],
+        :ceil            => -10,
+        :floor           => -90,
+        :col_step        => 1,
+      },
+
+      "cd" => {
+        :sigma           => 24.0,
+        :unit_time       => 5 * 10,
+        :scale_mode      => :LOGSCALE,
+        :transform_mode  => :POWER,
+        :output_width    => 480,
+        :range           => [50.0, 22050.0],
+        :ceil            => -10,
+        :floor           => -90,
+        :col_step        => 1,
+      },
+    }
+  end
+end

data/wavspa.gemspec

@@ -0,0 +1,47 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "wavspa/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "wavspa"
+  spec.version       = WavSpectrumAnalyzer::VERSION
+  spec.authors       = ["Hirosho Kuwagata"]
+  spec.email         = ["kgt9221@gmail.com"]
+
+  spec.summary       = %q{spectrum analyzer for wav file.}
+  spec.description   = %q{spectrum analyzer for wav file.}
+  spec.homepage      = "https://github.com/kwgt/wavspa"
+  spec.license       = "MIT"
+
+  if spec.respond_to?(:metadata)
+    spec.metadata["homepage_uri"] = spec.homepage
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been
+  # added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f|
+      f.match(%r{^(test|spec|features)/})
+    }
+  end
+
+  spec.bindir        = "bin"
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ["none"]
+  spec.extensions    = %w[
+    ext/wavspa/fft/extconf.rb
+    ext/wavspa/wavelet/extconf.rb
+    ext/wavspa/fb/extconf.rb
+  ]
+
+  spec.required_ruby_version = ">= 2.4.0"
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_dependency "libpng-ruby", "~> 0.5.2"
+end