Add CELT compatibility, functionality to bridge server's

README.rdoc

@@ -1,5 +1,10 @@
 mumble-ruby
-    http://www.github.com/perrym5/mumble-ruby
+    forked from: http://www.github.com/perrym5/mumble-ruby
+	    and: https://github.com/qwertos/mumble-ruby
+
+== ADDED Dependencies (06.01.2016):
+ruby-portaudio
+		 https://github.com/dafoxia/ruby-portaudio
 
 == DESCRIPTION:
 

lib/mumble-ruby.rb

@@ -1,4 +1,5 @@
 require 'opus-ruby'
+require 'celt-ruby'
 require 'active_support/inflector'
 require 'mumble-ruby/version'
 require 'mumble-ruby/thread_tools'
@@ -13,6 +14,7 @@
 require 'mumble-ruby/img_reader'
 require 'mumble-ruby/cert_manager'
 require 'mumble-ruby/audio_recorder'
+require 'mumble-ruby/mumble2mumble.rb'
 require 'hashie'
 
 module Mumble

lib/mumble-ruby/audio_player.rb

@@ -3,18 +3,31 @@
 module Mumble
   class AudioPlayer
     include ThreadTools
-    COMPRESSED_SIZE = 960
+    COMPRESSED_SIZE = 48
 
     def initialize(type, connection, sample_rate, bitrate)
       @packet_header = (type << 5).chr
       @conn = connection
       @pds = PacketDataStream.new
-      @queue = Queue.new
-      @wav_format = WaveFile::Format.new :mono, :pcm_16, sample_rate
-
+      @queue = SizedQueue.new 500
+      @wav_format = WaveFile::Format.new :stereo, :pcm_16, sample_rate
+      @type = type
+      @bitrate = bitrate
+      @sample_rate = sample_rate
+      @framesize = COMPRESSED_SIZE * 10    
       create_encoder sample_rate, bitrate
     end
 
+    def set_codec(type)
+      @type = type
+      @packet_header = (type << 5).chr
+      create_encoder @sample_rate, @bitrate
+    end
+
+    def destroy
+      kill_threads
+    end
+
     def volume
       @volume ||= 100
     end
@@ -38,65 +51,175 @@ def play_file(file)
     def stream_named_pipe(pipe)
       unless playing?
         @file = File.open(pipe, 'rb')
-        spawn_threads :produce, :consume
+        spawn_threads :produce
         @playing = true
       end
     end
 
+    def stream_portaudio
+      begin
+        require 'ruby-portaudio'
+        PortAudio.init
+        unless playing?
+          @portaudio = PortAudio::Stream.open( :sample_rate => sample_rate, :frames => 8192, :input => { :device => PortAudio::Device.default_input, :channels => 1, :sample_format => :int16, :suggested_latency => 0.05 })
+          @audiobuffer = PortAudio::SampleBuffer.new( :format => :float32, :channels => 1, :frames => @framesize)
+          @portaudio.start
+          spawn_threads :portaudio
+          @playing = true
+        end
+        true
+      rescue
+        # no portaudio installed - no streaming possible
+        false
+      end
+    end
+
     def stop
       if playing?
         kill_threads
         @encoder.reset
         @file.close unless @file.closed?
+        #@portaudio.stop unless @portaudio.stopped?
         @playing = false
       end
     end
 
+    def set_bitrate bitrate
+      if !(@type == CODEC_ALPHA || @type == CODEC_BETA)
+        begin
+          @encoder.bitrate = bitrate
+          @bitrate = bitrate
+        rescue
+        end
+      end
+    end
+
+    def get_bitrate
+      @bitrate
+    end
+
+    def set_framelength miliseconds
+      case miliseconds
+      when 1..4
+        framelength = 2.5
+      when 5..14
+        framelength = 10
+      when 15..30
+        framelength = 20
+      when 31..45
+        framelength = 40
+      else
+        framelength = 60
+      end
+      @framesize= COMPRESSED_SIZE * framelength
+      begin
+        @encoder.set_frame_size @framesize
+        @audiobuffer = PortAudio::SampleBuffer.new( :format => :float32, :channels => 1, :frames => @framesize) if !@portaudio.stopped?
+      rescue
+      end
+    end
+
+    def get_frame_length
+      begin
+        (@encoder.frame_size / COMPRESSED_SIZE).to_i
+      rescue
+        puts $1
+      end
+    end
+
+    def get_framelength
+      @framesize / COMPRESSED_SIZE
+    end
     private
     def create_encoder(sample_rate, bitrate)
-      @encoder = Opus::Encoder.new sample_rate, sample_rate / 100, 1
-      @encoder.vbr_rate = 0 # CBR
-      @encoder.bitrate = bitrate
+      kill_threads
+      @encoder.destroy if @encoder != nil 
+
+      if @type == CODEC_ALPHA || @type == CODEC_BETA
+        @encoder = Celt::Encoder.new sample_rate, sample_rate / 100, 1, [bitrate / 800, 127].min
+        @encoder.vbr_rate = bitrate
+        @encoder.prediction_request = 0
+      else
+        @encoder = Opus::Encoder.new sample_rate, @framesize, 2, 7200
+        @encoder.bitrate = bitrate
+        @encoder.opus_set_signal Opus::Constants::OPUS_SIGNAL_MUSIC # alternative OPUS_SIGNAL_VOICE  but then constrainded vbr not work.
+        begin
+          @encoder.opus_set_vbr 1
+          @encoder.opus_set_vbr_constraint 1        # 1 constrainted VBR , 0 unconstrainded VBR
+          @encoder.opus_set_packet_loss_perc 10     # calculate with 10 percent packet loss 
+          @encoder.opus_set_dtx 1
+        rescue
+          puts "[Warning] Some OPUS functions not aviable, use dafoxia's opus-ruby!"
+          puts $!
+        end
+        begin
+          @encoder.packet_loss_perc= 10
+        rescue
+          puts "[Warning] Packet Loss Resistance could not setted"
+        end
+      end
     end
 
+    # TODO: call native functions
     def change_volume(pcm_data)
       pcm_data.unpack('s*').map { |s| s * (volume / 100.0) }.pack('s*')
     end
 
     def bounded_produce
+      frametime = (@encoder.frame_size / COMPRESSED_SIZE).to_f / 1000  #milliseconds
+      frame_counter = 0
+      timestart = Time.now.to_f
       @file.each_buffer(@encoder.frame_size) do |buffer|
-        encode_sample buffer.samples.pack('s*')
+        encode_sample buffer.samples.flatten.pack('s*')
         consume
+        frame_counter +=1
+        wait = timestart - Time.now.to_f + frame_counter * frametime
+        sleep(wait) if wait > 0
       end
 
       stop
     end
 
     def produce
-      encode_sample @file.read(@encoder.frame_size * 2)
+      encode_sample @file.read(@encoder.frame_size*4)
+      consume
+    end
+
+    def portaudio
+      begin
+        @portaudio.read(@audiobuffer)
+        @queue << @encoder.encode_ptr(@audiobuffer.to_ptr)
+        consume
+      rescue
+        sleep 0.2
+      end
     end
 
     def encode_sample(sample)
-      pcm_data = change_volume sample
-      @queue << @encoder.encode(pcm_data, COMPRESSED_SIZE)
+      if volume < 100
+        @queue << @encoder.encode(change_volume(sample))
+      else
+        @queue << @encoder.encode(sample)
+      end
     end
 
     def consume
-      @seq ||= 0
-      @seq %= 1000000 # Keep sequence number reasonable for long runs
-
-      @pds.rewind
-      @seq += 1
-      @pds.put_int @seq
-
-      frame = @queue.pop
-      @pds.put_int frame.size
-      @pds.append_block frame
-
-      size = @pds.size
-      @pds.rewind
-      data = [@packet_header, @pds.get_block(size)].flatten.join
-      @conn.send_udp_packet data
+      frame = @queue.pop  
+      if frame != nil   # prevent reading accidently from an empty queue
+        @seq ||= 0
+        @seq %= 1000000 # Keep sequence number reasonable for long runs
+        @pds.rewind
+        @seq += 1
+        @pds.put_int @seq
+        #frame = @queue.pop         
+        @pds.put_int frame.size
+        @pds.append_block frame
+
+        size = @pds.size
+        @pds.rewind
+        data = [@packet_header, @pds.get_block(size)].flatten.join
+        @conn.send_udp_packet data
+      end
     end
   end
 end

lib/mumble-ruby/audio_recorder.rb

@@ -4,17 +4,24 @@
 module Mumble
   class AudioRecorder
     include ThreadTools
+    CODEC_ALPHA = 0
+    CODEC_BETA = 3
+    CODEC_OPUS = 4
 
     def initialize(client, sample_rate)
       @client = client
       @wav_format = WaveFile::Format.new(:mono, :pcm_16, sample_rate)
       @pds = PacketDataStream.new
       @pds_lock = Mutex.new
 
-      @decoders = Hash.new do |h, k|
+      @opus_decoders = Hash.new do |h, k|
         h[k] = Opus::Decoder.new sample_rate, sample_rate / 100, 1
       end
 
+      @celt_decoders = Hash.new do |h, k|
+        h[k] = Celt::Decoder.new sample_rate, sample_rate / 100, 1
+      end
+
       @queues = Hash.new do |h, k|
         h[k] = Queue.new
       end
@@ -24,6 +31,24 @@ def recording?
       @recording ||= false
     end
 
+    def stream_portaudio
+      begin
+        PortAudio.init
+        unless !recording?
+          @portaudio = PortAudio::Stream.open( :sample_rate => 48000, :frames => 8192, :output => { :device => PortAudio::Device.default_output, :channels => 1, :sample_format => :int16, :suggested_latency => 0.25 })
+          @audiobuffer = PortAudio::SampleBuffer.new(:format   => :int16, :channels => 1, :frames => 8192)
+          @portaudio.start
+          @callback = @client.on_udp_tunnel { |msg| process_udp_tunnel msg }
+          spawn_thread :portaudio
+          @recording = true
+        end
+        true
+      rescue
+        # no portaudio gem installed - no streaming possible.
+        false
+      end
+    end
+
     def start(file)
       unless recording?
         @file = WaveFile::Writer.new(file, @wav_format)
@@ -37,8 +62,8 @@ def stop
       if recording?
         @client.remove_callback :udp_tunnel, @callback
         kill_threads
-        @decoders.values.each &:destroy
-        @decoders.clear
+        @opus_decoders.values.each &:destroy
+        @opus_decoders.clear
         @queues.clear
         @file.close
         @recording = false
@@ -49,15 +74,37 @@ def stop
     def process_udp_tunnel(message)
       @pds_lock.synchronize do
         @pds.rewind
-        @pds.append_block message.packet[1..-1]
+        @pds.append_block message.packet#[1..-1]        # we need packet type info
 
         @pds.rewind
+        packet_type = @pds.get_next
         source = @pds.get_int
         seq = @pds.get_int
-        len = @pds.get_int
-        opus = @pds.get_block len
-
-        @queues[source] << @decoders[source].decode(opus.join)
+        case ( packet_type >> 5 )
+          when CODEC_ALPHA
+            len = @pds.get_next
+            alpha = @pds.get_block ( len & 0x7f )
+            @queues[source] << @celt_decoders[source].decode(alpha.join)
+            while ( len  0x80 ) != 0
+              len = @pds.get_next
+              alpha = @pds.get_block ( len & 0x7f )
+              @queues[source] << @celt_decoders[source].decode(alpha.join)
+            end
+          when CODEC_BETA
+            len = @pds.get_next
+            beta = @pds.get_block ( len & 0x7f )
+            @queues[source] << @celt_decoders[source].decode(beta.join)
+            while ( len  0x80 ) != 0
+              len = @pds.get_next
+              beta = @pds.get_block ( len & 0x7f )
+              @queues[source] << @celt_decoders[source].decode(beta.join)
+            end
+          when CODEC_OPUS
+            len = @pds.get_int
+            opus = @pds.get_block ( len & 0x1FFF )
+            @queues[source] << @opus_decoders[source].decode(opus.join)
+            @opus_decoders[source].reset if ( len & 0x2000 ) == 0x2000
+        end
       end
     end
 
@@ -75,5 +122,23 @@ def write_audio
         @file.write WaveFile::Buffer.new(samples, @wav_format)
       end
     end
+
+    def portaudio
+      pcms = @queues.values
+        .reject { |q| q.empty? }                      # Remove empty queues
+        .map { |q| q.pop.unpack 's*' }                # Grab the top element of each queue and expand
+      head, *tail = pcms
+      if head
+        samples = head.zip(*tail)
+          .map { |pcms| pcms.reduce(:+) / pcms.size }   # Average together all the columns of the matrix (merge audio streams)
+          .flatten                                      # Flatten the resulting 1d matrix
+        @audiobuffer = PortAudio::SampleBuffer.new( :format => :int16, :channels => 1, :frames => send.size / 2 +1)
+        @audiobuffer.add(sample.pack 's*')
+        begin
+          @portaudio << @audiobuffer
+        rescue
+        end
+      end
+    end
   end
 end