radio 0.0.2 → 0.0.3

data/lib/radio/{inputs → signals}/wav.rb

@@ -15,31 +15,33 @@
 
 
 class Radio
-  module Input
+  module Signal
     class File
       class WAV
         
         attr_reader :rate
         
-        def initialize id, rate, channel_i, channel_q
-          @file = ::File.new id
+        def initialize options
+          @file = ::File.new options[:id]
           #TODO validate header instead?
           @file.read 12 # discard header
-          @rate = rate
-          @channel_i = channel_i
-          @channel_q = channel_q
+          @rate = options[:rate].to_i
+          if input = options[:input]
+            @channel_i = input[0]
+            @channel_q = input[1]
+          end
           @data = [next_data]
           @time = Time.now
         end
         
-        def call samples
+        def in samples
           sample_size = @channels * (@bit_sample/8)
-          @time += 1.0/(rate/samples)
+          @time += 1.0/(rate.to_f/samples)
           sleep [0,@time-Time.now].max
           while @data.reduce(0){|a,b|a+b.size} < samples * sample_size
             @data.push next_data
           end
-          if channels > 1
+          if input_channels > 1
             out = NArray.scomplex samples
           else
             out = NArray.sfloat samples
@@ -59,11 +61,15 @@ class Radio
           out
         end
         
-        def channels
+        def input_channels
           return 2 if @channel_q and @channels > 1
           1
         end
         
+        def output_channels
+          0
+        end
+        
         def stop
           @file.close
         end
@@ -78,9 +84,10 @@ class Radio
           else
             raise "Unsupported sample size: #{@bit_sample}" 
           end
-          return out if channels == 1 and @channels == 1
+          return out if input_channels == 1 and @channels == 1
+          #TODO buggy wav files with bad endings raise the next line
           out.reshape! @channels, out.size/@channels
-          if channels == 1
+          if input_channels == 1
             out[@channel_i,true]
           else
             c_out = NArray.scomplex out[0,true].size
@@ -90,26 +97,32 @@ class Radio
           end
         end
         
-        #TODO read data in chunks smaller than size (which is often the whole file)
         def next_data
           loop do
             until @file.eof?
-              type = @file.read(4)
-              size = @file.read(4).unpack("V")[0].to_i
-              case type
-              when 'fmt '
-                fmt = @file.read(size)
-                @id = fmt.slice(0,2).unpack('c')[0]
-                @channels = fmt.slice(2,2).unpack('c')[0]
-                @rate = fmt.slice(4,4).unpack('V').join.to_i
-                @byte_sec = fmt.slice(8,4).unpack('V').join.to_i
-                @block_size = fmt.slice(12,2).unpack('c')[0]
-                @bit_sample = fmt.slice(14,2).unpack('c')[0]
-                next
-              when 'data'
-                return @file.read size
+              if @data_size
+                actual = [@data_size, 4096].min
+                return @file.read actual
+                @data_size -= actual
+                @data_size = nil if @data_size == 0
               else
-                raise "Unknown GIF type: #{type}"
+                type = @file.read(4)
+                size = @file.read(4).unpack("V")[0].to_i
+                case type
+                when 'fmt '
+                  fmt = @file.read(size)
+                  @id = fmt.slice(0,2).unpack('c')[0]
+                  @channels = fmt.slice(2,2).unpack('c')[0]
+                  @rate = fmt.slice(4,4).unpack('V').join.to_i
+                  @byte_sec = fmt.slice(8,4).unpack('V').join.to_i
+                  @block_size = fmt.slice(12,2).unpack('c')[0]
+                  @bit_sample = fmt.slice(14,2).unpack('c')[0]
+                  next
+                when 'data'
+                  @data_size = size
+                else
+                  raise "Unknown type: #{type}"
+                end
               end
             end
             @file.rewind

data/lib/radio/utils/firpm.rb

@@ -0,0 +1,395 @@
+# Copyright 2012 The ham21/radio Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+# This uses similar variable names and similar logic as a
+# popular C implementation of the Parks McClellan algorithm
+# which is based on an old FORTRAN implementation.
+# I did this Ruby version in a hurry so for comments, see the C:
+# http://www.janovetz.com/  Jake Janovetz (janovetz@uiuc.edu) 
+
+
+class Radio
+  module Utils
+
+    FIRPM_CACHE_VERSION = 1
+    FIRPM_CACHE_FILENAME = File.expand_path '~/.radio_firpm_cache'
+    @@firpm_cache = {}
+    @@firpm_mtime = nil
+    
+    def firpm options
+      out = nil
+      File.open(FIRPM_CACHE_FILENAME, File::CREAT|File::RDWR) do |f|
+        f.flock(File::LOCK_EX)
+        if f.mtime != @@firpm_mtime
+          @@firpm_cache = YAML::load(f)
+          unless @@firpm_cache and @@firpm_cache[:version] == FIRPM_CACHE_VERSION
+            @@firpm_cache = {version:FIRPM_CACHE_VERSION}
+          end
+          f.seek 0
+          @@firpm_mtime = f.mtime
+        end
+        firpm = FirPM.new(options)
+        out = @@firpm_cache[firpm.options]
+        unless out
+          out = firpm.to_a
+          @@firpm_cache[firpm.options] = out
+          f.truncate 0
+          YAML::dump @@firpm_cache, f
+        end
+      end
+      out
+    end
+    module_function :firpm
+
+    # Instances of FirPM will act as the result array.  The result
+    # is lazily generated just-in-time for the first use.  This
+    # allows for CONSTANT=FirPM.new assignments without the huge
+    # penalty to application startup.  It also let's us normalize
+    # the options at initialization for use as a cache key.
+    # It is strongly recommended to use the caching mixin.
+    class FirPM
+    
+      # :type may be in [:bandpass, :differentiator, :hilbert]
+      # :maxiterations won't raise error when negative
+      def initialize options
+        # normalized and frozen to be suitable for a hash key
+        @options = {
+          type: options[:type].to_sym,
+          numtaps: options[:numtaps].to_i,
+          bands: options[:bands].flatten.collect(&:to_f).freeze,
+          desired: options[:desired].collect(&:to_f).freeze,
+          weights: options[:weights].collect(&:to_f).freeze,
+          griddensity: options[:griddensity] || 16,
+          maxiterations: options[:maxiterations] || 40
+        }.freeze
+      end
+      attr_reader :options
+
+      def method_missing name, *opts, &block
+        firpm unless @h
+        @h.send name, *opts, &block
+      end
+    
+      private
+    
+      def firpm
+        numtaps = @options[:numtaps]
+        bands = @options[:bands]
+        des = @options[:desired]
+        weight = @options[:weights]
+        type = @options[:type]
+        griddensity = @options[:griddensity]
+        maxiterations = @options[:maxiterations]
+
+        numband = weight.size
+        unless bands.size == numband * 2 and des.size == numband * 2
+          raise 'size mismatch in bands, desired, or weights'
+        end
+
+        symmetry = (type == :bandpass) ? :positive : :negative
+      
+        @r = numtaps / 2
+        @r += 1 if numtaps.odd? and symmetry == :positive
+      
+        @gridsize = 0
+        numband.times do |i|
+          increment = 2.0 * @r * griddensity * (bands[2*i+1] - bands[2*i])
+          @gridsize += increment.round
+        end
+        @gridsize -= 1 if symmetry == :negative
+
+        taps = Array.new @r+1, 0.0
+        @h = Array.new numtaps, 0.0
+        @grid = Array.new @gridsize, 0.0
+        @d = Array.new @gridsize, 0.0
+        @w = Array.new @gridsize, 0.0
+        @e = Array.new @gridsize, 0.0
+        @ext = Array.new @r+1, 0
+        @x = Array.new @r+1, 0.0
+        @y = Array.new @r+1, 0.0
+        @ad = Array.new @r+1, 0.0
+        @foundExt = Array.new @r*2, 0
+      
+        lowf = delf = 0.5/(griddensity*@r)
+        lowf = bands[0] unless symmetry == :negative and delf > bands[0]
+        j=0
+        numband.times do |band|
+          @grid[j] = bands[2*band]
+          lowf = bands[2*band] unless band == 0
+          highf = bands[2*band + 1]
+          k = ((highf - lowf)/delf).round
+          k.times do |i|
+            @d[j] = des[2*band] + i*(des[2*band+1]-des[2*band])/(k-1)
+            @w[j] = weight[band]
+            @grid[j] = lowf
+            lowf += delf
+            j += 1
+          end
+          @grid[j-1] = highf
+        end
+        @grid[@gridsize-1] = 0.5-delf if (
+          (symmetry == :negative) &&
+          (@grid[@gridsize-1] > (0.5 - delf)) &&
+          numtaps.odd?
+        )
+
+        (0..@r).each do |i|
+          @ext[i] = i * (@gridsize-1) / @r
+        end
+      
+        if type == :differentiator
+          @gridsize.times do |i|
+            @w[i] = @w[i]/@grid[i] if @d[i] > 0.0001
+          end
+        end
+      
+        if symmetry == :positive
+          if numtaps.even?
+            @gridsize.times do |i|
+              c = Math.cos(PI * @grid[i])
+              @d[i] /= c
+              @w[i] *= c
+            end
+          end
+        else
+          if numtaps.odd?
+            @gridsize.times do |i|
+              c = Math.sin(PI2 * @grid[i])
+              @d[i] /= c
+              @w[i] *= c
+            end
+          else
+            @gridsize.times do |i|
+              c = Math.sin(PI * @grid[i])
+              @d[i] /= c
+              @w[i] *= c
+            end
+          end
+        end
+
+        if maxiterations > 0
+          maxiter_error = true
+        else
+          maxiterations = -maxiterations
+          maxiter_error = false
+        end
+        iter = 0
+        while iter < maxiterations
+          calc_params
+          @gridsize.times do |i|
+            @e[i] = @w[i] * (@d[i] - compute_a(@grid[i]))
+          end
+          search
+          break if done?
+          iter += 1
+        end
+        raise "Maximum iterations exceeded" if maxiter_error && iter == maxiterations
+        calc_params
+      
+        (0..numtaps/2).each do |i|
+          if symmetry == :positive
+            if numtaps.odd?
+              c = 1
+            else
+              c = Math.cos(PI * i / numtaps)
+            end
+          else
+            if numtaps.odd?
+              c = Math.sin(PI2 * i / numtaps)
+            else
+              c = Math.sin(PI * i / numtaps)
+            end
+          end
+          taps[i] = compute_a(i.to_f / numtaps) * c
+        end
+    
+        m = (numtaps.to_f-1)/2
+        if symmetry == :positive
+          if numtaps.odd?
+            (0...numtaps).each do |n|
+              val = taps[0]
+              x = PI2 * (n - m)/numtaps
+              (1..m).each do |k|
+                val += 2.0 * taps[k] * Math.cos(x*k)
+              end
+              @h[n] = val/numtaps
+            end
+          else
+            (0...numtaps).each do |n|
+              val = taps[0]
+              x = PI2 * (n - m)/numtaps
+              (1..numtaps/2-1).each do |k|
+                val += 2.0 * taps[k] * Math.cos(x*k)
+              end
+              @h[n] = val/numtaps
+            end
+          end
+        else
+          if numtaps.odd?
+            (0...numtaps).each do |n|
+              val = 0
+              x = PI2 * (n - m)/numtaps
+              (1..m).each do |k|
+                val += 2.0 * taps[k] * Math.sin(x*k)
+              end
+              @h[n] = val/numtaps
+            end
+          else
+            (0...numtaps).each do |n|
+              val = taps[numtaps/2] * Math.sin(PI * (n - m))
+              x = PI2 * (n - m) / numtaps
+              (1..numtaps/2-1).each do |k|
+                val += 2.0 * taps[k] * Math.sin(x*k)
+              end
+              @h[n] = val/numtaps
+            end
+          end
+        end
+      
+        @gridsize = nil
+        @r = nil
+        @grid = nil
+        @d = nil
+        @w = nil
+        @e = nil
+        @ext = nil
+        @x = nil
+        @y = nil
+        @ad = nil
+        @foundExt = nil
+        @h.freeze
+      end
+    
+    
+      def calc_params
+        (0..@r).each do |i|
+          @x[i] = Math.cos(PI2 * @grid[@ext[i]])
+        end
+        ld = (@r-1)/15 + 1
+        (0..@r).each do |i|
+          denom = 1.0
+          xi = @x[i]
+          (0...ld).each do |j|
+            k=j
+            while k <= @r
+              denom *= 2.0*(xi - @x[k]) if k != i
+              k += ld
+            end
+          end
+          denom = 0.00001 if denom.abs < 0.00001
+          @ad[i] = 1.0/denom
+        end
+        numer = denom = 0
+        sign = 1
+        (0..@r).each do |i|
+          numer += @ad[i] * @d[@ext[i]]
+          denom += sign * @ad[i]/@w[@ext[i]]
+          sign = -sign
+        end
+        delta = numer/denom
+        sign = 1
+        (0..@r).each do |i|
+          @y[i] = @d[@ext[i]] - sign * delta / @w[@ext[i]]
+          sign = -sign
+        end
+      end
+
+
+      def compute_a freq
+        denom = numer = 0
+        xc = Math.cos(PI2 * freq)
+        (0..@r).each do |i|
+          c = xc - @x[i]
+          if c.abs < 1.0e-7
+            numer = @y[i]
+            denom = 1
+            break
+          end
+          c = @ad[i]/c
+          denom += c
+          numer += c*@y[i]
+        end
+        numer/denom
+      end
+    
+    
+      def search
+        @foundExt.fill 0
+        k = 0
+        if ((@e[0]>0.0) && (@e[0]>@e[1])) || ((@e[0]<0.0) && (@e[0]<@e[1]))
+          @foundExt[k] = 0
+          k += 1
+        end
+        (1...@gridsize-1).each do |i|
+          if (((@e[i]>=@e[i-1]) && (@e[i]>@e[i+1]) && (@e[i]>0.0)) ||
+               ((@e[i]<=@e[i-1]) && (@e[i]<@e[i+1]) && (@e[i]<0.0)))
+            @foundExt[k] = i
+            k += 1
+          end
+        end
+        j = @gridsize-1
+        if (((@e[j]>0.0) && (@e[j]>@e[j-1])) ||
+            ((@e[j]<0.0) && (@e[j]<@e[j-1])))
+          @foundExt[k] = j
+          k += 1
+        end
+        extra = k - (@r+1)
+        while (extra > 0)
+          up = @e[@foundExt[0]] > 0.0
+          l = 0
+          alt = true
+          (1...k).each do |j|
+            l = j if (@e[@foundExt[j]].abs < @e[@foundExt[l]].abs)
+            if up && (@e[@foundExt[j]] < 0.0)
+              up = false
+            elsif !up && (@e[@foundExt[j]] > 0.0)
+              up = true
+            else
+              alt = false
+              break
+            end
+          end
+          if alt && (extra == 1)
+            if (@e[@foundExt[k-1]].abs < @e[@foundExt[0]].abs)
+              l = @foundExt[k-1]
+            else
+              l = @foundExt[0]
+            end
+          end
+          (l...k).each do |j|
+            @foundExt[j] = @foundExt[j+1]
+          end
+          k -= 1
+          extra -= 1
+        end
+        (0..@r).each do |i|
+          @ext[i] = @foundExt[i]
+        end
+      end
+    
+    
+      def done?
+        min = max = @e[@ext[0]].abs
+        (1..@r).each do |i|
+          current = @e[@ext[i]].abs
+          min = current if current < min
+          max = current if current > max
+        end
+        ((max-min)/max) < 0.0001
+      end
+   
+    end
+  end
+end