radio 0.0.2 → 0.0.3

data/lib/radio/rig/ssb.rb_

@@ -0,0 +1,150 @@
+# 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.
+
+
+class Radio
+  
+  class Rig
+
+    module SSB
+      
+      def initialize
+        @ssb_semaphore = Mutex.new
+        super
+      end
+      
+      def af= output
+        if output and !iq?
+          raise 'requires i/q signal'
+        end
+        old_af_thread = false
+        @ssb_semaphore.synchronize do
+          deregister @af_queue if @af_queue
+          @af_queue = nil
+          old_rate = 0
+          if @af
+            @af.stop
+            old_af_thread = @af_thread
+            old_af_thread.kill if old_af_thread
+          end
+          if @af = output
+            @bfo_filter = bfo_mixer
+            @af_filter = af_generate_filter
+            @agc = Filter.new :agc => true
+            @iq = Filter.new :iq => true
+          
+            #TODO need a nicer pattern to force JIT compile
+            @bfo_filter.call(NArray.scomplex(1)) {}
+            @af_filter.call(NArray.sfloat(1)) {}
+            @agc.call(NArray.sfloat(1)) {}
+            @iq.call(NArray.scomplex(1)) {}
+          
+            register @af_queue = Queue.new
+            @af_thread = Thread.new &method(:af_thread)
+          end
+        end
+        old_af_thread.join if old_af_thread
+      end
+      
+      def tune= freq
+        @ssb_semaphore.synchronize do
+          return unless @af
+          @bfo_filter.decimation_mix = freq / rate
+        end
+      end
+      
+      def set_lsb
+        @ssb_semaphore.synchronize do
+          @bfo_filter.decimation_fir = @lsb_coef if @bfo_filter
+        end
+      end
+
+      def set_usb
+        @ssb_semaphore.synchronize do
+          @bfo_filter.decimation_fir = @usb_coef if @bfo_filter
+        end
+      end
+      
+      private
+      
+      def af_thread
+        begin
+          loop do
+            in_data = @af_queue.pop
+            @ssb_semaphore.synchronize do
+              if @af_filter and @af
+                @bfo_filter.call(in_data) do |iq|
+                  @iq.call!(iq) do |iq|
+                    @agc.call(iq.real + iq.imag) do |pcm|
+                      @af_filter.call(pcm) do |data| 
+                        @af.out data
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        rescue Exception => e
+          p "ERROR #{e.message}: #{e.backtrace.first}" #TODO logger
+          raise e
+        end
+      end
+
+      def bfo_mixer
+        rate = self.rate.to_f
+        decimate = rate / 6000
+        unless decimate == decimate.floor
+          raise "unable to filter #{rate} to 6000"
+        end
+        bands = []
+        bands[0] = 0.0 / rate
+        bands[1] = 2400.0 / rate
+        bands[2] = 2800.0 / rate
+        bands[3] = 0.5
+        taps = kaiser_estimate passband:0.01, stopband:0.01, transition:bands[2]-bands[1]
+        p taps
+        fir1 = firpm numtaps: taps, type: :bandpass,
+          bands: bands, desired: [1,1,0,0], weights: [1,2000]
+        fir2 = firpm numtaps: taps, type: :hilbert,
+          bands: bands, desired: [1,1,0,0], weights: [1,2000]
+        @usb_coef = NArray.scomplex fir1.size
+        @usb_coef[true] = fir1.to_a
+        @usb_coef.imag = fir2.to_a
+        @lsb_coef = @usb_coef.conj
+        Filter.new fir:@usb_coef, decimate:decimate, mix:0
+      end
+      
+      def af_generate_filter
+        return nil unless @af
+        bands = [0,nil,nil,0.5]
+        bands[1] = 2400.0 / @af.rate
+        bands[2] = 2800.0 / @af.rate
+        taps = kaiser_estimate passband:0.01, stopband:0.01, transition:bands[2]-bands[1]
+        p taps
+        fir = firpm numtaps: taps, type: :bandpass,
+          bands: bands, desired: [1,1,0,0], weights: [1,1000]
+        interpolate = @af.rate.to_f / 6000
+        unless interpolate == interpolate.floor
+          raise "unable to filter 6000 to #{@af.rate}"
+        end
+        Filter.new fir:fir, interpolate:interpolate
+      end
+      
+      
+    end
+
+  end
+end
+  

data/lib/radio/{input.rb → signal.rb}

@@ -14,7 +14,7 @@
 
 
 class Radio
-  module Input
+  module Signal
     
     # Keep this namespace clean because we search inputs by
     # finding the classes from Radio::Inputs.constants.
@@ -23,17 +23,17 @@ class Radio
     # dependencies. This allows us to present a basic debug screen.
     def self.status
       s = {}
-      Radio::Input.constants.collect do |input_name|
+      constants.collect do |input_name|
         s[input_name] = eval(input_name.to_s).status
       end
       s
     end
     
     # Consolidate all sources from all inputs and add the class name to the keys.
-    def self.sources
+    def self.devices
       s = {}
-      Radio::Input.constants.each do |type|
-        eval(type.to_s).sources.each do |id, source|
+      constants.each do |type|
+        eval(type.to_s).devices.each do |id, source|
           s[[type, id]] = source
         end
       end
@@ -41,20 +41,24 @@ class Radio
     end
     
     # You can't new a module so this switches into the specific class.
-    def self.new type, id, rate, channel_i, channel_q=nil
-      # defend the eval
-      unless Radio::Input.constants.include? type.to_sym
+    def self.new options
+      type = options.delete :type
+      options[:output] = [options[:output]].flatten if options[:output]
+      options[:input] = [options[:input]].flatten if options[:input]
+      unless constants.include? type.to_sym
         raise NameError, "uninitialized constant Radio::Input::#{type}"
       end
-      input = eval(type.to_s).new id, rate, channel_i, channel_q
+      device = eval(type.to_s).new options
       # Ask for and discard the first sample to report errors here
       begin
-        input.call 1
+        device.out NArray.scomplex(1) if device.output_channels == 2
+        device.out NArray.sfloat(1) if device.output_channels == 1
+        device.in 1 if device.input_channels > 0
       rescue Exception => e
-        input.stop
+        device.stop
         raise e
       end
-      input
+      device
     end
     
   end

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

@@ -20,13 +20,13 @@ end
 
 
 class Radio
-  module Input
+  module Signal
 
     class ALSA
       
       def self.status
         if defined? ::ALSA::PCM
-          return "Loaded: %d input devices" % sources.count
+          return "Loaded: %d devices" % devices.count
         end
         unless defined? @is_linux
           @is_linux = (`uname`.strip == 'Linux') rescue false
@@ -42,7 +42,7 @@ class Radio
       CP_REGEX = /:\s*(capture|playback)\s*(\d+)\s*$/
       CD_REGEX = /^(\d+)-(\d+):\s*/
       
-      def self.sources
+      def self.devices
         return {} unless defined? ::ALSA::PCM
         # Funky read to get around old Linux bug
         # http://kerneltrap.org/mailarchive/git-commits-head/2009/4/17/5510664
@@ -63,31 +63,37 @@ class Radio
             result[device] = {
               name: line,
               rates: [params.sample_rate],
-              channels: params.channels
+              input: params.channels,
+              output: 0
             }
           end rescue nil
         end
         result
       end
       
-      def initialize id, rate, channel_i, channel_q
+      def initialize options
         @stream = ::ALSA::PCM::Capture.new
-        @stream.open id
-        @channel_i = channel_i
-        @channel_q = channel_q
+        @stream.open options[:id]
+        if input = options[:input]
+          @channel_i = input[0]
+          @channel_q = input[1]
+        end
       end
       
       def rate
         @stream.hardware_parameters.sample_rate
       end
       
-      def channels
+      def input_channels
         return 2 if @channel_q and @stream.hardware_parameters.channels > 1
         1
       end
       
-      def call samples
-        
+      def output_channels
+        0
+      end
+      
+      def in samples
         out=nil
         buf_size = @stream.hw_params.buffer_size_for(samples)
         FFI::MemoryPointer.new(:char, buf_size) do |buffer|
@@ -96,12 +102,13 @@ class Radio
           NArray.to_na(out, NArray::SINT).to_f.div! 32767
         end
         stream_channels = @stream.hardware_parameters.channels
-        out = case buf_size / samples / stream_channels
+        sample_size = buf_size / samples / stream_channels
+        out = case sample_size
         when 1 then NArray.to_na(out,NArray::BYTE).to_f.collect!{|v|(v-128)/127}
         when 2 then NArray.to_na(out,NArray::SINT).to_f.div! 32767
         # when 3 then NArray.to_na(d,NArray::???).to_f.collect!{|v|(v-8388608)/8388607}
         else
-          raise "Unsupported sample size: #{@bit_sample}" 
+          raise "Unsupported sample size: #{@sample_size}" 
         end
         return out if channels == 1 and stream_channels == 1
         out.reshape! stream_channels, out.size/stream_channels
@@ -123,13 +130,3 @@ class Radio
     
   end
 end
-
-
-if $0 == __FILE__
-  
-  require 'narray'
-  a = Radio::Input::ALSA
-  i = a.new 'default', 44100, 0, nil
-  p i.call 8
-  
-end

data/lib/radio/signals/coreaudio.rb

@@ -0,0 +1,136 @@
+# 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.
+
+
+class Radio
+  module Signal
+
+    class CoreAudio
+      
+      VERSION = '>= 0.0.9'
+      BUFFER = 0.3 #seconds of buffer
+      JITTER = 0.6 #percent of buffer for output adjust
+
+      begin
+        gem 'coreaudio', VERSION
+        require 'coreaudio'
+      rescue LoadError => e
+        @bad_coreaudio = gem 'coreaudio'
+      end
+      
+      def self.status
+        if defined? ::CoreAudio
+          return "Loaded: %d devices" % devices.count
+        end
+        unless defined? @is_darwin
+          @is_darwin = (`uname`.strip == 'Darwin') rescue false
+        end
+        return 'Unsupported: requires Apple OS' unless @is_darwin
+        return 'Unavailable: gem update coreaudio '+ VERSION.dump if @bad_coreaudio
+        return 'Unavailable: gem install coreaudio'
+      end
+  
+      # I don't see a way to automatically set the CoreAudio CODEC rate.
+      # We'll present the nominal_rate as the only option.
+      def self.devices
+        return {} unless defined? ::CoreAudio
+        result = {}
+        ::CoreAudio.devices.each do |dev|
+          result[dev.devid] = {
+            name: dev.name,
+            rates: [dev.nominal_rate.to_i],
+            input: dev.input_stream.channels,
+            output: dev.output_stream.channels,
+          }
+        end
+        result
+      end
+      
+      attr_reader :input_channels, :output_channels
+
+      def initialize options 
+        @device = ::CoreAudio::AudioDevice.new options[:id].to_i
+        @input_channels = @output_channels = 0
+        if @input = options[:input]
+          @input_channels = @input.size
+          buffer_size = @input_channels * rate * BUFFER
+          @input_buf = @device.input_buffer buffer_size
+          @input_buf.start
+        end
+        if @output = options[:output]
+          @output_channels = @output.size
+          buffer_size = @output_channels * rate * BUFFER
+          @output_buf = @device.output_buffer buffer_size
+          @output_buf.start
+        end
+      end
+
+      # This is called on its own thread in Rig and is expected to block.
+      def in samples
+        # CoreAudio range of -32767..32767 makes easy conversion to -1.0..1.0
+        if @input_channels == 1
+          @input_buf.read(samples)[@input[0],true].to_f.div!(32767)
+        else
+          b = @input_buf.read samples
+          c_out = NArray.scomplex samples
+          c_out[0..-1] = b[@input[0],true].to_f.div!(32767)
+          c_out.imag = b[@input[1],true].to_f.div!(32767)
+          c_out
+        end
+      end
+      
+      def out data
+        resetting = false
+        if @output_buf.dropped_frame > 0
+          p 'filling because frame dropped' #TODO logger
+          resetting = true
+          filler = rate * BUFFER * JITTER - data.size
+          @output_buf << NArray.sfloat(filler) if filler > 0
+        end
+        output_buf_space = @output_buf.space
+        if output_buf_space < data.size
+          p 'dropping some data' #TODO logger
+          # we'll drop all the data that won't fit
+          @drop_data = data.size - output_buf_space
+          # plus enough data to swing back
+          @drop_data += rate * BUFFER * JITTER
+        end
+        out = nil
+        if @drop_data
+          if @drop_data < data.size
+            out = data[@drop_data..-1] * 32767
+          end
+          @drop_data -= data.size
+          @drop_data = nil if @drop_data <= 0
+        else
+          out = data * 32767
+        end
+        @output_buf << out if out
+        @output_buf.reset_dropped_frame if resetting
+      end
+  
+      # Once stopped, rig won't attempt starting again on this object.
+      def stop
+        @input_buf.stop if @input_buf
+        @output_buf.stop if @output_buf
+      end
+      
+      def rate
+        @device.nominal_rate
+      end
+      
+    end
+
+  end
+end

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

@@ -15,36 +15,37 @@
 
 
 class Radio
-  module Input
+  module Signal
     class File
       
       def self.status
-        "Loaded: %d files found" % sources.size
+        "Loaded: %d files found" % devices.size
       end
       
-      def self.sources
+      def self.devices
         result = {}
         files = Dir.glob ::File.expand_path '../../../../test/wav/**/*.wav', __FILE__
         files.each do |file|
           begin
-            f = new file, 0, 0, 1
+            f = new id:file, input:[0,1]
           rescue Exception => e
             next
           end
           result[file] = {
             name: file,
             rates: [f.rate],
-            channels: f.channels
+            input: f.input_channels,
+            output: 0
           }
         end
         result
       end
       
       # You can load any file, not just the ones in sources.
-      def initialize id, rate, channel_i, channel_q
+      def initialize options
         self.class.constants.each do |x|
           klass = eval x.to_s
-          @reader = klass.new id, rate, channel_i, channel_q rescue nil
+          @reader = klass.new options
           break if @reader
         end
         raise 'Unknown format' unless @reader
@@ -57,4 +58,3 @@ class Radio
     end
   end
 end
-