mumble-ruby2 1.1.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b0b2f66cdde08f10db6f6af8e9fd08eedf13cf856b0674446c4ea726238c09f4
+  data.tar.gz: 2938bc5085b878c7fa0611074bd9ca3ed1d140210b0a6b95fb5a3dec23f1e272
+SHA512:
+  metadata.gz: 78bd56173cb547f21bf784bd3c16dd8851c415141f100bf4c1f4954c60eda2132fbb43839e1ac15bc199bd838f8c1dd216ef467cbd1898e9a866fc33e977dfa8
+  data.tar.gz: 87df7a958f3b142d8418e0da1d53c3c4b20c865a5d95e35588508e158c38021427d4a14589a745c6f8e1339fa87b021217d84851af47498c636816273911f429

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.ruby-gemset

@@ -0,0 +1 @@
+mumble_ruby_gem

data/.ruby-version

@@ -0,0 +1 @@
+ruby-3.0

data/Gemfile

@@ -0,0 +1,4 @@
+source 'http://rubygems.org'
+
+# Specify your gem's dependencies in mumble-ruby2.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Matthew Perry, Philip Mayer
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,119 @@
+mumble-ruby
+    https://github.com/Shadowsith/mumble-ruby2
+
+== DESCRIPTION:
+
+Mumble-Ruby is a headless client for the Mumble VOIP application.
+Mumble-Ruby provides the ability to write scripts and bots which interact with mumble servers through a simple DSL.
+Mumble-Ruby also has the ability to stream raw audio from a fifo pipe (mpd) to the mumble server.
+There is huge room for improvement in this library and I am willing to accept all sorts of pull requests so please do.
+
+== INSTALL:
+
+    [sudo] gem install mumble-ruby2
+
+== REQUIREMENTS:
+
+* Ruby >= 2.1.0
+* OPUS Audio Codec
+* Murmur server > 1.2.4 -- NOTE: mumble-ruby2 will not be able to stream audio to servers that don't support OPUS anymore. I haven't looked into backwards-compatability with CELT.
+
+== RECENT CHANGES:
+
+* Merged changes for proper user/channel objects
+* Merged changes for recording feature
+* Added half-broken support for playing files (Something is wrong, wouldn't recommend using it)
+* Bit of refactoring and renaming
+
+* Added OPUS support
+* Added more configuration options
+* Added image text messages
+* Added ssl cert auth
+* Fixed several bugs
+
+== BASIC USAGE:
+
+    # Configure all clients globally
+    Mumble.configure do |conf|
+        # sample rate of sound (48 khz recommended)
+        conf.sample_rate = 48000
+
+        # bitrate of sound (32 kbit/s recommended)
+        conf.bitrate = 32000
+
+        # directory to store user's ssl certs
+        conf.ssl_cert_opts[:cert_dir] = File.expand_path("./")
+    end
+
+    # Create client instance for your server
+    cli = Mumble::Client.new('localhost') do |conf|
+        conf.username = 'Mumble Bot'
+        conf.password = 'password123'
+
+        # Overwrite global config
+        conf.bitrate = 48000
+    end
+    # => #<Mumble::Client:0x00000003064fe8 @host="localhost", @port=64738, @username="Mumble Bot", @password="password123", @channels={}, @users={}, @callbacks={}>
+
+    # Set up some callbacks for when you recieve text messages
+    # There are callbacks for every Mumble Protocol Message that a client can recieve
+    # For a reference on those, see the linked PDF at the bottom of the README.
+    cli.on_text_message do |msg|
+        puts msg.message
+    end
+    # => [#<Proc:0x0000000346e5f8@(irb):2>]
+
+    # Initiate the connection to the client
+    cli.connect
+    # => #<Thread:0x000000033d7388 run>
+
+    # Mute and Deafen yourself after connecting
+    cli.on_connected do
+        cli.me.mute
+        cli.me.deafen
+    end
+
+    # Join the channel titled "Chillen" (this will return a channel object for that channel)
+    cli.join_channel('Chillen')
+
+    # Get a list of channels
+    cli.channels
+    # Returns a hash of channel_id: Channel objects
+
+    # Join Channel using ID
+    cli.join_channel(0)
+
+    # Join Channel using Channel object
+    cli.join_channel(cli.channels[0])
+    cli.channels[0].join
+
+    # Get a list of users
+    cli.users
+    # Returns a hash of session_id: UserState Messages
+
+    # Text user
+    cli.text_user('perrym5', "Hello there, I'm a robot!")
+
+    # Text an image to a channel
+    cli.text_channel_img('Chillen', '/path/to/image.jpg')
+
+    # Start streaming from a FIFO queue of raw PCM data
+    cli.player.stream_named_pipe('/tmp/mpd.fifo')
+
+    # EXPERIMENTAL: Recording feature
+    cli.recorder.start('/home/matt/record.wav')
+    sleep(2)
+    cli.recorder.stop
+
+    # EXPERIMENTAL: Play wav files
+    cli.player.play_file('/home/matt/record.wav')
+
+    # Safely disconnect
+    cli.disconnect
+    # => nil
+
+== MUMBLE PROTOCOL:
+
+The documentation for Mumble's control and voice protocol is a good reference for using this client as all of the callbacks
+are based on the types of messages the Mumble uses to accomplish its tasks.
+You can see it here[https://github.com/mumble-voip/mumble-protocol/blob/master/protocol_stack_tcp.rst].

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/mumble-ruby2.rb

@@ -0,0 +1,39 @@
+require 'opus-ruby'
+require 'active_support/inflector'
+require 'mumble-ruby2/version'
+require 'mumble-ruby2/thread_tools'
+require 'mumble-ruby2/messages'
+require 'mumble-ruby2/connection'
+require 'mumble-ruby2/model'
+require 'mumble-ruby2/user'
+require 'mumble-ruby2/channel'
+require 'mumble-ruby2/client'
+require 'mumble-ruby2/audio_player'
+require 'mumble-ruby2/packet_data_stream'
+require 'mumble-ruby2/img_reader'
+require 'mumble-ruby2/cert_manager'
+require 'mumble-ruby2/audio_recorder'
+require 'hashie'
+
+module Mumble
+  DEFAULTS = {
+    sample_rate: 48000,
+    bitrate: 32000,
+    ssl_cert_opts: {
+      cert_dir: File.expand_path("./"),
+      country_code: "US",
+      organization: "github.com",
+      organization_unit: "Engineering"
+    }
+  }
+
+  def self.configuration
+    @configuration ||= Hashie::Mash.new(DEFAULTS)
+  end
+
+  def self.configure
+    yield(configuration) if block_given?
+  end
+
+  Thread.abort_on_exception = true
+end

data/lib/mumble-ruby2/audio_player.rb

@@ -0,0 +1,107 @@
+require 'wavefile'
+
+module Mumble
+  class AudioPlayer
+    include ThreadTools
+    COMPRESSED_SIZE = 960
+
+    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
+
+      create_encoder sample_rate, bitrate
+    end
+
+    def volume
+      @volume ||= 100
+    end
+
+    def volume=(volume)
+      @volume = volume
+    end
+
+    def playing?
+      @playing ||= false
+    end
+
+    def play_file(file)
+      unless playing?
+        @file = WaveFile::Reader.new(file, @wav_format)
+        Thread.new { bounded_produce }
+        @playing = true
+      end
+    end
+
+    def stream_named_pipe(pipe)
+      unless playing?
+        @file = File.open(pipe, 'rb')
+        spawn_threads :produce, :consume
+        @playing = true
+      end
+    end
+
+    def stop
+      if playing?
+        kill_threads
+        @encoder.reset
+        @file.close unless @file.closed?
+        @playing = false
+      end
+    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
+    end
+
+    def change_volume(pcm_data)
+      pcm_data.unpack('s*').map { |s| s * (volume / 100.0) }.pack('s*')
+    end
+
+    def bounded_produce
+      frame_count = 0
+      start_time = Time.now.to_f
+      @file.each_buffer(@encoder.frame_size) do |buffer|
+        encode_sample buffer.samples.pack('s*')
+        consume
+        frame_count += 1
+        wait_time = start_time - Time.now.to_f + frame_count * 0.01
+        sleep(wait_time) if wait_time > 0
+      end
+
+      stop
+    end
+
+    def produce
+      encode_sample @file.read(@encoder.frame_size * 2)
+    end
+
+    def encode_sample(sample)
+      pcm_data = change_volume sample
+      @queue << @encoder.encode(pcm_data, COMPRESSED_SIZE)
+    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
+    end
+  end
+end

data/lib/mumble-ruby2/audio_recorder.rb

@@ -0,0 +1,79 @@
+require 'wavefile'
+require 'thread'
+
+module Mumble
+  class AudioRecorder
+    include ThreadTools
+
+    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|
+        h[k] = Opus::Decoder.new sample_rate, sample_rate / 100, 1
+      end
+
+      @queues = Hash.new do |h, k|
+        h[k] = Queue.new
+      end
+    end
+
+    def recording?
+      @recording ||= false
+    end
+
+    def start(file)
+      unless recording?
+        @file = WaveFile::Writer.new(file, @wav_format)
+        @callback = @client.on_udp_tunnel { |msg| process_udp_tunnel msg }
+        spawn_thread :write_audio
+        @recording = true
+      end
+    end
+
+    def stop
+      if recording?
+        @client.remove_callback :udp_tunnel, @callback
+        kill_threads
+        @decoders.values.each &:destroy
+        @decoders.clear
+        @queues.clear
+        @file.close
+        @recording = false
+      end
+    end
+
+    private
+    def process_udp_tunnel(message)
+      @pds_lock.synchronize do
+        @pds.rewind
+        @pds.append_block message.packet[1..-1]
+
+        @pds.rewind
+        source = @pds.get_int
+        seq = @pds.get_int
+        len = @pds.get_int
+        opus = @pds.get_block len
+
+        @queues[source] << @decoders[source].decode(opus.join)
+      end
+    end
+
+    # TODO: Better audio stream merge with normalization
+    def write_audio
+      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
+        @file.write WaveFile::Buffer.new(samples, @wav_format)
+      end
+    end
+  end
+end

data/lib/mumble-ruby2/cert_manager.rb

@@ -0,0 +1,67 @@
+require 'openssl'
+require 'fileutils'
+
+module Mumble
+  class CertManager
+    attr_reader :key, :cert
+
+    CERT_STRING = "/C=%s/O=%s/OU=%s/CN=%s"
+
+    def initialize(username, opts)
+      @cert_dir = File.join(opts[:cert_dir], "#{username.downcase}_cert")
+      @username = username
+      @opts = opts
+
+      FileUtils.mkdir_p @cert_dir
+      setup_key
+      setup_cert
+    end
+
+    [:private_key, :public_key, :cert].each do |sym|
+      define_method "#{sym}_path" do
+        File.join(@cert_dir, "#{sym}.pem")
+      end
+    end
+
+    private
+    def setup_key
+      if File.exists?(private_key_path)
+        @key ||= OpenSSL::PKey::RSA.new File.read(private_key_path)
+      else
+        @key ||= OpenSSL::PKey::RSA.new 2048
+        File.write private_key_path, key.to_pem
+        File.write public_key_path, key.public_key.to_pem
+      end
+    end
+
+    def setup_cert
+      if File.exists?(cert_path)
+        @cert ||= OpenSSL::X509::Certificate.new File.read(cert_path)
+      else
+        @cert ||= OpenSSL::X509::Certificate.new
+
+        subject = CERT_STRING % [@opts[:country_code], @opts[:organization], @opts[:organization_unit], @username]
+
+        cert.subject = cert.issuer = OpenSSL::X509::Name.parse(subject)
+        cert.not_before = Time.now
+        cert.not_after = Time.new + 365 * 24 * 60 * 60 * 5
+        cert.public_key = key.public_key
+        cert.serial = rand(65535) + 1
+        cert.version = 2
+
+        ef = OpenSSL::X509::ExtensionFactory.new
+        ef.subject_certificate = cert
+        ef.issuer_certificate = cert
+
+        cert.add_extension(ef.create_extension("basicConstraints", "CA:TRUE", true))
+        cert.add_extension(ef.create_extension("keyUsage", "keyCertSign, cRLSign", true))
+        cert.add_extension(ef.create_extension("subjectKeyIdentifier", "hash", false))
+        cert.add_extension(ef.create_extension("authorityKeyIdentifier", "keyid:always", false))
+
+        cert.sign key, OpenSSL::Digest::SHA256.new
+
+        File.write cert_path, cert.to_pem
+      end
+    end
+  end
+end