itak 3 → 4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a7ab66466c640ba4b91cfdf41de938434bdf3decd225c606213ff0aa91a9cff2
-  data.tar.gz: 8eabbd49439e13cd6d1831a7fc5fd83a391538f89a06e9c69640ba3ec5006ace
+  metadata.gz: 3f5c18bc3e593097a8a4efac8f78432ccf2db6b7771ba740dae975f12b0f12f3
+  data.tar.gz: b8e1a1c9e26a8427116515243703e889171b6a5f49d4c42285a89b19b63749e9
 SHA512:
-  metadata.gz: 0f7278553178a3d2fa2de089f14a71f5079814528772adccd5fd1897056b31fb5a624efe5b73c2a8779f6d3bb7e8ee213cea8aea8fc26a1f9984967b9b6a75c7
-  data.tar.gz: ed4f9e3765197050aa8061e52cad8cfcbed747f00c2433e59f80fa7ce1a715255be4ec0e36ecc7d78cae85dc7fc8463d4aa2fc7154eee3e12eda0b882b7d069c
+  metadata.gz: d8fc23e257aa870f7337ef05e6f930f96713402881c2f3290dececdbf2792522a1d8f9f4394e1e00f43108bd13c5498ee4e141409cee65f470dfcd28d9c01f03
+  data.tar.gz: 45e7516e05441624c7871c900097f12472e450bf0d557e9a81e7ef0c0f8512f9cc5d59dad0a88d4090db3f31f36b3ba5fef1d32c53e8fffce4cb2cdd35b0c9ce

data/README.md

@@ -3,21 +3,239 @@ Itak
 
 Audio editing tool for podcasters.
 
+[![Gem Version](https://badge.fury.io/rb/itak.svg)](https://badge.fury.io/rb/itak)
+
 It does:
 
+* normalize loudness,
 * remove noise, and
-* remove non-active period
+* remove non-speech period
 
 from the audio file.
 
 SYNOPSIS
 --------
 
-    % itak path/to/audio.wav --output=path/to/output.wav
+    % itak path/to/audio.wav --output=path/to/dir
+    Output written to
+    * path/to/dir/audio.denoised-vad.wav
+    * path/to/dir/audio.denoised-vad.txt
+
+INSTALLATION
+------------
+
+    % gem install itak
+
+Or,
+
+    % bundle add itak
+
+CLI
+---
+
+The `itak` command accepts an audio path and create an edited audio file.
+
+By default, output path is created by inserting `.vad-denoised` before the file extension: `path/to/audio.mp3` -> `path/to/audio.vad-denoised.mp3`. You can specify the output path by `--output` (`-o` shortly) option:
+
+    # Specifies directory
+    itak path/to/audio --output=./
+    # Specifies file
+    itak path/to/audio.wav --output=./output.wav
+
+LIBRARY
+-------
+
+Though Itak is intended to be used as CLI, it provides some useful classes for editing podcast audio.
+
+*Note* that these classes and APIs might change frequently.
+
+### `Audio` ###
+
+`Itak::Audio` is a model of audio data. Attributes are:
+
+* `waveform`: Multi-dimensional array containing the waveform. Currently, it is a `Torch::Tensor`
+* `sample_rate`: Sample rate
+* `layout`: Audio layout. `:interleaved` or `:planar`
+* `channels`: The number of channels
+
+*Note* that attributes are *not* kept consistent automatically. You are responsible for updating them when modifying the audio data:
+
+```ruby
+audio.waveform = ...
+audio.sample_rate = ...
+```
+
+Also, it has methods to load and save audio:
+
+* `Audio.load(path)` loads audio from `path` and returns `Itak::Audio` instance.
+* `Audio#save(path)` saves audio to `path`.
+
+It uses [TorchAudio Ruby][] internally, so supports formats which TorchAudio supports.
+
+`Itak::Audio` is a base of processing audio. It chains processes like this:
+
+```ruby
+include Itak::Process
+
+Itak::Audio.load("path/to/audio")
+  .(&NormalizeLoudness)
+  .(&DownMix)
+  .(&Resample[to: 16_000])
+  .(&Denoise)
+  .(&VAD)
+  .>>(&Save[to: "path/to/output"])
+  .>>(&Transcribe[dest: "path/to/transcription.txt"])
+  .<<
+```
+
+*Note* that process classes below mutate `Itak::Audio` object.
+
+Processes below are under the `Itak::Process` namespace. So, `include`ing it before use is useful.
+
+### `NormalizeLoudness` ###
+
+`Itak::Process::NormalizeLoudness` normalizes audio loudness using EBU R128.
+
+```ruby
+include Itak::Process
+
+audio = Itak::Audio.load("path/to/audio")
+audio.(&NormalizeLoudness) # => Normalized audio
+# Or
+NormalizeLoudness.new
+                 .run(audio)
+audio # => Normalized audio
+```
+
+You can configure target loudness (in LUFS) and the true peak ceiling (in dBTP):
 
-Audio file must be mono WAV with 16kHz sampling rate and 16-bit per sample.
+```ruby
+audio.(&NormalizeLoudness[target: -16.0, true_peak_ceiling: -1.0])
+# Or
+NormalizeLoudness.new(target: -16.0, true_peak_ceiling: -1.0)
+                 .run(audio)
+```
+
+### `DownMix` ###
+
+`Itak::Process::DownMix` down-mixes audio to mono.
+
+```ruby
+audio.(&DownMix) # => Mono audio
+# Or
+DownMix.new
+       .run(audio)
+audio # => Mono audio
+```
+
+### `Resample` ###
+
+`Itak::Process::Resample` resamples audio.
+
+```ruby
+audio.(&Resample[to: 16_000]) # => Audio with 16,000Hz sample rate
+# Or
+Resample.new(to: 16_000)
+        .run(audio)
+audio # => Resampled audio
+```
+
+### `Denoise` ###
+
+`Itak::Process::Denoise` denoises from audio.
+
+```ruby
+audio.(&Denoise) # => Denoised audio
+# Or
+Denoise.new
+       .run(audio)
+audio # => Denoised audio
+```
+
+### `VAD` ###
+
+`Itak::Process::VAD` detects voice activity and removes non-speech periods from the audio.
+
+```ruby
+audio.(&VAD) # => Audio without silent periods
+# Or
+VAD.new
+   .run(audio)
+audio # => Audio without silent periods
+```
+
+`Itak::Process::VAD` uses [Silero VAD][] via [whispercpp][] internally. You can specify the model and configure params:
+
+```ruby
+
+params = Whisper::VAD::Params.new(
+  threshold: 0.1,               # Threshold to consider a frame as speech
+  min_silence_duration_ms: 3000 # Considers a segment is silent when silence continues 3 seconds.
+)
+
+audio.(&VAD[model: "silero-v5.1.2", params: params])
+# Or
+VAD.new(model: "silero-v5.1.2", params: params)
+   .run(audio)
+```
+
+See `Whisper::VAD::Params` in the [signature file][whisper-sig] for available params.
+
+### `Save` ###
+
+`Itak::Process::Save` saves audio to a file.
+
+```ruby
+audio.(&Save[to: "path/to/output"])
+# Or
+Save.new(to: "path/to/output")
+    .run(audio)
+```
+
+This is equivalent to:
+
+```ruby
+audio.save "path/to/output"
+```
+
+### `Transcribe` ###
+
+`Itak::Process::Transcribe` transcribes from audio and output to a file if needed.
+
+```ruby
+audio.(&Transcribe[dest: "path/to/output.txt"]) # => Audio, not transcription
+# Or
+transcription = Transcribe.new(dest: "path/to/output.txt")
+                          .run(audio)
+puts transcription
+# [00:00:00 --> 00:00:30] Transcription text here
+# 
+# [00:00:30 --> 00:00:60] Transcription text here
+```
+
+Blank lines are inserted between transcription segments to make the output file easier to import into Notion.
+
+`Itak::Process::Transcribe` uses [whispercpp][] internally. You can specify the model and configure params:
+
+```ruby
+params = {
+  language: "de",
+  temperature: 0.5
+}
+audio.(&Transcribe[model: "tiny", params: params, dest: "path/to/output.txt"])
+# Or
+Transcribe.new(model: "tiny", params: params, dest: "path/to/output.txt")
+          .run(audio)
+```
+
+See `Whisper::Params` in the [signature file][whisper-sig] for available params.
 
 LICENSE
 -------
 
 AGPL 3.0 or later. See the file agpl-3.0.txt.
+
+[TorchAudio Ruby]: https://github.com/ankane/torchaudio-ruby
+[Silero VAD]: https://github.com/snakers4/silero-vad
+[whispercpp]: https://github.com/ggml-org/whisper.cpp/tree/master/bindings/ruby
+[whisper-sig]: https://github.com/ggml-org/whisper.cpp/blob/master/bindings/ruby/sig/whisper.rbs

data/bin/itak

@@ -2,15 +2,23 @@ require "optparse"
 require "optparse/pathname"
 require "itak"
 
+Version = Gem::Specification.find_by_name("itak").version
+
 def main(argv)
   options = parse_options(argv)
   src = argv.shift
   abort "Specify input file" unless src
-  output = Itak.new.run(src, options[:output])
+  outputs = Itak.new(src, options[:output]).run
   $stderr.puts "Output written to"
-  $stderr.puts output
+  outputs.each do |output|
+    $stderr.puts "* #{output}"
+  end
 rescue => err
-  abort err.message
+  if $DEBUG
+    raise
+  else
+    abort err.message
+  end
 end
 
 def parse_options(argv)
@@ -21,6 +29,13 @@ def parse_options(argv)
 
       Usage: itak [options] INPUT
     EOB
+    opt.on "-d", "--debug", "Set debugging flag" do
+      $DEBUG = true
+      $VERBOSE = true
+    end
+    opt.on "--verbose", "Set verbose flag" do
+      $VERBOSE = true
+    end
     opt.on "-o", "--output=PATH", "Specify output file or directory", Pathname do |path|
       options[:output] = path
     end

data/itak.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "itak"
-  s.version = "3"
+  s.version = "4"
   s.authors = ["Kitaiti Makoto"]
   s.email = ["KitaitiMaokto@gmail.com"]
   s.summary = "Audio editing tool for podcasters"
@@ -18,6 +18,9 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency "torch-rb"
   s.add_runtime_dependency "optparse-pathname"
   s.add_runtime_dependency "ndav-torch-tensor"
+  s.add_runtime_dependency "ebur128_stream"
+  s.add_runtime_dependency "awaaz"
+  s.add_runtime_dependency "ndav-numo-narray"
 
   s.add_development_dependency "rake"
   s.add_development_dependency "rubygems-tasks"

data/lib/itak/audio.rb

@@ -0,0 +1,36 @@
+require "itak/callable"
+
+class Itak
+  class Audio
+    prepend Callable
+
+    class << self
+      def load(path, **)
+        waveform, sample_rate = TorchAudio.load(path.to_path)
+        new(waveform, sample_rate:, layout: :planar, **)
+      end
+    end
+
+    attr_accessor :waveform, :sample_rate, :layout
+    attr_reader :debug_info
+
+    def initialize(waveform, sample_rate:, layout:, debug_info: nil)
+      @waveform = waveform
+      @sample_rate = sample_rate
+      @layout = layout
+      @debug_info = debug_info
+    end
+
+    def channels
+      shape = @waveform.shape
+      return 1 if shape.length == 1
+
+      layout == :interleaved ? shape[-1] : shape[0]
+    end
+
+    def save(path)
+      TorchAudio.save path.to_path, waveform, sample_rate
+      self
+    end
+  end
+end

data/lib/itak/awaaz_patch.rb

@@ -0,0 +1,8 @@
+module AwaazResampeFix
+  def read_and_resample(input_samples, input_rate, output_rate, channels, sampling_option: :sinc_fastest)
+    samples = super
+    samples.reshape!(channels, samples.shape[0] / channels)
+  end
+
+  Awaaz::Utils::Resample.singleton_class.prepend self
+end

data/lib/itak/callable.rb

@@ -0,0 +1,22 @@
+class Itak
+  module Callable
+    def initialize(*, **, &)
+      super
+      @threads = []
+    end
+
+    alias call tap
+
+    def >>(&blk)
+      @threads << Thread.new(blk) {call(&blk)}
+      self
+    end
+
+    def <<
+      while thread = @threads.shift
+        thread.join
+      end
+      self
+    end
+  end
+end

data/lib/itak/debuggable.rb

@@ -0,0 +1,32 @@
+require "pp"
+
+class Itak
+  module Debuggable
+    def debug_log_start
+      return unless $VERBOSE
+
+      $stderr.puts "[#{self.class}] Started..."
+    end
+
+    def debug_inspect(obj)
+      return unless $VERBOSE
+
+      $stderr.puts "[#{self.class}]"
+      PP.pp obj, $stderr
+    end
+
+    def debug_save(audio)
+      return unless $DEBUG
+      return unless audio.debug_info
+      src = audio.debug_info[:src]
+      dest = audio.debug_info[:dest]
+      return if src.nil? || dest.nil?
+
+      id = self.class.to_s.split("::").last.downcase
+
+      path = dest.dirname/src.basename.sub_ext(".#{id}" + src.extname)
+      audio.save path
+      $stderr.puts "[#{self.class}] Saved to #{path}"
+    end
+  end
+end

data/lib/itak/process/denoise.rb

@@ -0,0 +1,17 @@
+require "gtcrn"
+
+class Itak
+  module Process
+    class Denoise
+      prepend Processible
+
+      def initialize
+        @gtcrn = GTCRN.new
+      end
+
+      def run(audio)
+        audio.waveform = @gtcrn.enhance_speech_waveform(audio.waveform)
+      end
+    end
+  end
+end

data/lib/itak/process/down_mix.rb

@@ -0,0 +1,13 @@
+class Itak
+  module Process
+    class DownMix
+      prepend Processible
+
+      def run(audio)
+        return if audio.waveform.length == 1
+
+        audio.waveform = audio.waveform.mean(0)
+      end
+    end
+  end
+end

data/lib/itak/process/normalize_loudness.rb

@@ -0,0 +1,40 @@
+require "ebur128_stream"
+
+class Itak
+  module Process
+    class NormalizeLoudness
+      prepend Processible
+
+      def initialize(target: -14.0, true_peak_ceiling: -0.1)
+        @target = target
+        @true_peak_ceiling= true_peak_ceiling
+      end
+
+      def run(audio)
+        channels = case audio.channels
+                  in 1
+                    [:center]
+                  in 2
+                    [:left, :right]
+                  end
+        normalizer = EBUR128Stream::Normalizer.new(
+          sample_rate: audio.sample_rate,
+          channels:,
+          target_lufs: @target,
+          true_peak_ceiling_dbtp: @true_peak_ceiling
+        )
+
+        samples = audio.waveform.transpose(1, 0)
+        shape = samples.shape
+        samples = samples.reshape([shape.reduce(:*)])
+        report = normalizer.normalize_in_place(samples)
+        samples = samples.reshape(shape).transpose(0, 1)
+        audio.waveform = samples
+
+        debug_inspect report
+
+        report
+      end
+    end
+  end
+end

data/lib/itak/process/resample.rb

@@ -0,0 +1,18 @@
+class Itak
+  module Process
+    class Resample
+      include NDAV::Converter
+      prepend Processible
+
+      def initialize(to:)
+        @to = to
+      end
+
+      def run(audio)
+        samples = NumoNArray(audio.waveform)
+        audio.waveform = Awaaz::Utils::Resample.read_and_resample(samples, audio.sample_rate, @to, audio.channels).to_ndav.to_torch_tensor
+        audio.sample_rate = @to
+      end
+    end
+  end
+end

data/lib/itak/process/save.rb

@@ -0,0 +1,15 @@
+class Itak
+  module Process
+    class Save
+      prepend Processible
+
+      def initialize(to:)
+        @to = to
+      end
+
+      def run(audio)
+        audio.save @to
+      end
+    end
+  end
+end

data/lib/itak/process/transcribe.rb

@@ -0,0 +1,47 @@
+require "whisper"
+
+class Itak
+  module Process
+    class Transcribe
+      prepend Processible
+
+      PARAMS = {
+        language: "ja",
+        temperature: 1.0
+      }
+
+      def initialize(model: "large-v3-turbo-q8_0", dest:, params: {})
+        Whisper.log_set proc {}, nil
+        @whisper = Whisper::Context.new(model)
+        @params = Whisper::Params.new(**PARAMS.merge(params))
+        @dest = dest
+      end
+
+      def run(audio)
+        src = audio.waveform
+        src = src[0] if src.ndim == 2 && src.shape[0] == 1
+        transcription = @whisper
+                          .full(@params, src.to_ndav)
+                          .each_segment
+                          .collect {|segment|
+                            "[%<start_time>s --> %<end_time>s]%<text>s" % {
+                              start_time: format_time(segment.start_time),
+                              end_time: format_time(segment.end_time),
+                              text: segment.text
+                            }
+                          }.join("\n\n")
+        @dest.write transcription
+        transcription
+      end
+
+      private
+
+      def format_time(time_ms)
+        sec, decimal_part = time_ms.divmod(1000)
+        min, sec = sec.divmod(60)
+        hour, min = min.divmod(60)
+        "%02d:%02d:%02d" % [hour, min, sec]
+      end
+    end
+  end
+end

data/lib/itak/process/vad.rb

@@ -0,0 +1,33 @@
+require "whisper"
+
+class Itak
+  module Process
+    class VAD
+      prepend Processible
+
+      PARAMS = Whisper::VAD::Params.new(
+        threshold: 0.7,
+        min_silence_duration_ms: 1500
+      )
+
+      def initialize(model: "silero-v6.2.0", params: PARAMS)
+        Whisper.log_set proc {}, nil
+        @vad = Whisper::VAD::Context.new(model)
+        @params = params
+      end
+
+      def run(audio)
+        src = audio.waveform
+        src = src[0] if src.ndim == 2 && src.shape[0] == 1
+        chunks = []
+        @vad.segments_from_samples(@params, src).each do |segment|
+          segment => {start_time:, end_time:}
+          st = start_time * SAMPLE_RATE / 1000
+          en = end_time * SAMPLE_RATE / 1000
+          chunks << src[st..en]
+        end
+        chunks.empty? ? src : Torch.cat(chunks)
+      end
+    end
+  end
+end

data/lib/itak/process.rb

@@ -0,0 +1,8 @@
+require "itak/processible"
+require "itak/process/normalize_loudness"
+require "itak/process/down_mix"
+require "itak/process/resample"
+require "itak/process/denoise"
+require "itak/process/vad"
+require "itak/process/transcribe"
+require "itak/process/save"

data/lib/itak/processible.rb

@@ -0,0 +1,34 @@
+require "itak/debuggable"
+
+class Itak
+  module Processible
+    include Debuggable
+
+    class << self
+      def prepended(mod)
+        mod.extend ClassMethods
+      end
+    end
+
+    def run(audio, *, **, &)
+      debug_log_start
+      rv = super
+      debug_save audio
+      rv
+    end
+
+    def to_proc
+      ->(audio) {run audio}
+    end
+
+    module ClassMethods
+      def to_proc
+        new.to_proc
+      end
+
+      def [](*, **, &)
+        new(*, **, &)
+      end
+    end
+  end
+end

data/lib/itak.rb

@@ -1,47 +1,45 @@
 require "pathname"
 require "torchaudio"
+require "ndav/numo/narray"
+require "ndav/torch/tensor"
+require "awaaz"
+require "itak/awaaz_patch"
 
-require "itak/denoiser"
-require "itak/vad"
-require "itak/transcriber"
+require "itak/audio"
+require "itak/process"
 
 class Itak
+  include NDAV::Converter
+  include Process
+
   SAMPLE_RATE = 16_000
 
-  def run(src, dest=nil)
-    src = Pathname(src)
+  def initialize(src, dest=nil)
+    @src = Pathname(src)
     if dest
-      dest = Pathname(dest)
-      if dest.directory?
-        dest = dest/src.basename.sub_ext(".denoised-vad" + src.extname)
+      @dest = Pathname(dest)
+      if @dest.directory?
+        @dest = @dest/@src.basename.sub_ext(".denoised-vad" + @src.extname)
       end
     else
-      dest = src.sub_ext(".denoised-vad" + src.extname)
+      @dest = src.sub_ext(".denoised-vad" + src.extname)
     end
-    dest.dirname.mkpath
-
-    waveform, sample_rate = TorchAudio.load(src.to_path)
-    raise "Currently only #{SAMPLE_RATE}Hz audio is supported" unless sample_rate == SAMPLE_RATE
+    @transcription_dest = @dest.sub_ext(".txt")
+  end
 
-    $stderr.puts "Denoising..."
-    denoised = Denoiser.new.denoise(waveform)
+  def run
+    @dest.dirname.mkpath
 
-    $stderr.puts "VAD..."
-    vadded = VAD.new.run(denoised)
+    Audio.load(@src, debug_info: {src: @src, dest: @dest})
+      .(&NormalizeLoudness)
+      .(&DownMix)
+      .(&Resample[to: SAMPLE_RATE])
+      .(&Denoise)
+      .(&VAD)
+      .>>(&Save[to: @dest])
+      .>>(&Transcribe[dest: @transcription_dest])
+      .<<
 
-    saving = Thread.new {
-      TorchAudio.save(dest.to_path, vadded.unsqueeze(0), SAMPLE_RATE)
-      $stderr.puts "Saved to #{dest}"
-    }
-    transcribing = Thread.new {
-      $stderr.puts "Transcribing..."
-      transcription = Transcriber.new.run(vadded)
-      transcription_path = dest.sub_ext(".txt")
-      transcription_path.write transcription
-      $stderr.puts "Transcription saved to #{transcription_path}"
-    }
-    saving.join
-    transcribing.join
-    dest
+    [@dest, @transcription_dest]
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: itak
 version: !ruby/object:Gem::Version
-  version: '3'
+  version: '4'
 platform: ruby
 authors:
 - Kitaiti Makoto
@@ -107,6 +107,48 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: ebur128_stream
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: awaaz
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ndav-numo-narray
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -222,9 +264,19 @@ files:
 - bin/itak
 - itak.gemspec
 - lib/itak.rb
-- lib/itak/denoiser.rb
-- lib/itak/transcriber.rb
-- lib/itak/vad.rb
+- lib/itak/audio.rb
+- lib/itak/awaaz_patch.rb
+- lib/itak/callable.rb
+- lib/itak/debuggable.rb
+- lib/itak/process.rb
+- lib/itak/process/denoise.rb
+- lib/itak/process/down_mix.rb
+- lib/itak/process/normalize_loudness.rb
+- lib/itak/process/resample.rb
+- lib/itak/process/save.rb
+- lib/itak/process/transcribe.rb
+- lib/itak/process/vad.rb
+- lib/itak/processible.rb
 - test/fixtures/.gitkeep
 - test/helper.rb
 - test/test_itak.rb
@@ -246,7 +298,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Audio editing tool for podcasters
 test_files: []

data/lib/itak/denoiser.rb

@@ -1,13 +0,0 @@
-require "gtcrn"
-
-class Itak
-  class Denoiser
-    def initialize
-      @gtcrn = GTCRN.new
-    end
-
-    def denoise(src)
-      @gtcrn.enhance_speech_waveform(src)
-    end
-  end
-end

data/lib/itak/transcriber.rb

@@ -1,39 +0,0 @@
-require "whisper"
-
-class Itak
-  class Transcriber
-    PARAMS = {
-      language: "ja",
-      temperature: 1.0
-    }
-
-    def initialize(model: "large-v3-turbo-q8_0")
-      Whisper.log_set proc {}, nil
-      @whisper = Whisper::Context.new(model)
-    end
-
-    def run(src, params: {})
-      params = Whisper::Params.new(**PARAMS.merge(params))
-      src = src[0] if src.ndim == 2 && src.shape[0] == 1
-      @whisper
-        .full(params, src.to_ndav)
-        .each_segment
-        .collect {|segment|
-          "[%<start_time>s --> %<end_time>s]%<text>s" % {
-            start_time: format_time(segment.start_time),
-            end_time: format_time(segment.end_time),
-            text: segment.text
-          }
-        }.join("\n\n")
-    end
-
-    private
-
-    def format_time(time_ms)
-      sec, decimal_part = time_ms.divmod(1000)
-      min, sec = sec.divmod(60)
-      hour, min = min.divmod(60)
-      "%02d:%02d:%02d" % [hour, min, sec]
-    end
-  end
-end

data/lib/itak/vad.rb

@@ -1,28 +0,0 @@
-require "whisper"
-require "ndav/torch/tensor"
-
-class Itak
-  class VAD
-    PARAMS = Whisper::VAD::Params.new(
-      threshold: 0.7,
-      min_silence_duration_ms: 1500
-    )
-
-    def initialize(model: "silero-v6.2.0")
-      Whisper.log_set proc {}, nil
-      @vad = Whisper::VAD::Context.new(model)
-    end
-
-    def run(src, params: PARAMS)
-      src = src[0] if src.ndim == 2 && src.shape[0] == 1
-      chunks = []
-      @vad.segments_from_samples(params, src.to_ndav).each do |segment|
-        segment => {start_time:, end_time:}
-        st = start_time * SAMPLE_RATE / 1000
-        en = end_time * SAMPLE_RATE / 1000
-        chunks << src[st..en]
-      end
-      Torch.cat(chunks)
-    end
-  end
-end