ipcam 0.1.0

data/lib/ipcam/main.rb

@@ -0,0 +1,344 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+#
+# Sample for v4l2-ruby
+#
+#   Copyright (C) 2019 Hiroshi Kuwagata <kgt9221@gmail.com>
+#
+
+require 'v4l2'
+require 'msgpack'
+
+module IPCam
+  BASIS_SIZE = 640 * 480
+  Stop       = Class.new(Exception)
+
+  class << self
+    def start
+      restore_db()
+
+      @mutex   = Mutex.new
+      @camera  = nil
+      @state   = :READY
+      @img_que = Thread::Queue.new
+      @cam_thr = Thread.new {camera_thread}
+      @snd_thr = Thread.new {sender_thread}
+      @clients = []
+
+      WebServer.start(self)
+      WebSocket.start(self)
+
+      EM.run
+    end
+
+    def stop
+      @cam_thr.join
+
+      @snd_thr.raise(Stop)
+      @snd_thr.join
+
+
+      WebServer.stop
+      EM.stop
+    end
+
+    def restart_camera
+      @cam_thr.raise(Stop)
+      @cam_thr.join
+
+      @img_que.clear
+
+      @cam_thr = Thread.new {camera_thread}
+    end
+
+    def select_capabilities(cam)
+      ret = cam.frame_capabilities(:MJPEG).instance_eval {
+        self.sort! { |a,b|
+          da = (BASIS_SIZE - (a.width * a.height)).abs
+          db = (BASIS_SIZE - (b.width * b.height)).abs
+
+          da <=> db
+        }
+
+        self.first
+      }
+
+      return ret
+    end
+    private :select_capabilities
+
+    def pack_capability(cap)
+      ret = {
+        :width  => cap.width,
+        :height => cap.height,
+        :rate   => cap.rate.inject([]) { |m, n|
+          m << [n.numerator, n.denominator]
+        }
+      }
+
+      return ret
+    end
+    private :pack_capability
+
+    def create_capability_list(cam)
+      ret = cam.frame_capabilities(:MJPEG).inject([]) { |m, n|
+        m << pack_capability(n)
+      }
+
+      return ret
+    end
+    private :create_capability_list
+
+    def pack_integer_control(c)
+      ret = {
+        :type  => :integer,
+        :id    => c.id,
+        :name  => c.name,
+        :value => c.default,
+        :min   => c.min,
+        :max   => c.max,
+        :step  => c.step
+      }
+
+      return ret
+    end
+    private :pack_integer_control
+
+    def pack_boolean_control(c)
+      ret = {
+        :type  => :boolean,
+        :id    => c.id,
+        :name  => c.name,
+        :value => c.default
+      }
+
+      return ret
+    end
+    private :pack_boolean_control
+
+    def pack_menu_control(c)
+      ret = {
+        :type  => :menu,
+        :id    => c.id,
+        :name  => c.name,
+        :value => c.default,
+        :items => c.items.inject({}) {|m, n| m[n.name] = n.index; m}
+      }
+
+      return ret
+    end
+    private :pack_menu_control
+
+    def create_control_list(cam)
+      ret = cam.controls.inject([]) { |m, n|
+        case n
+        when Video4Linux2::Camera::IntegerControl
+          m << pack_integer_control(n)
+
+        when Video4Linux2::Camera::BooleanControl
+          m << pack_boolean_control(n)
+
+        when Video4Linux2::Camera::MenuControl
+          m << pack_menu_control(n)
+
+        else
+          raise("Unknwon control found #{n.class}")
+        end
+      }
+
+      return ret
+    end
+    private :create_control_list
+
+    def create_setting_entry(cam)
+      cap  = select_capabilities(cam)
+      rate = cap.rate.sort.first
+
+      ret  = {
+        :image_width  => cap.width,
+        :image_height => cap.height,
+        :framerate    => [rate.numerator, rate.denominator],
+        :capabilities => create_capability_list(cam),
+        :controls     => create_control_list(cam)
+      }
+
+      return ret
+    end
+    private :create_setting_entry
+
+    def restore_db
+      begin
+        blob  = $db_file.binread
+        @db   = MessagePack.unpack(blob, :symbolize_keys => true)
+
+      rescue
+        begin
+          $db_file.delete
+        rescue Errno::ENOENT
+          # ignore
+        end
+          
+        @db   = {}
+      end
+    end
+    private :restore_db
+
+    def load_settings
+      ret = @db.dig(@camera.bus, @camera.name)
+
+      if not ret
+        ret = create_setting_entry(@camera)
+        (@db[@camera.bus] ||= {})[@camera.name] = ret
+
+        $db_file.binwrite(@db.to_msgpack)
+      end
+
+      @camera.image_height = ret[:image_height]
+      @camera.image_width  = ret[:image_width]
+      @camera.framerate    = Rational(*ret[:framerate])
+
+      ret[:controls].each { |ctr|
+        @camera.set_control(ctr[:id], ctr[:value]) rescue :ignore
+      }
+
+      return ret
+    end
+    private :load_settings
+
+    def broadcast(name, *args)
+      WebSocket.broadcast(name, *args)
+    end
+    private :broadcast
+
+    def camera_thread
+      $logger.info("main") {"camera thread start"}
+
+      @mutex.synchronize {
+        @camera = Video4Linux2::Camera.new($target)
+
+        if not @camera.support_formats.any? {|x| x.fcc == "MJPG"}
+          raise("#{$target} is not support Motion-JPEG")
+        end
+
+        @config = load_settings()
+
+        @camera.start
+        @state = :BUSY
+      }
+
+      loop {
+        @img_que << @camera.capture
+      }
+
+    rescue Stop
+      $logger.info("main") {"accept stop request"}
+      @state = :READY
+
+    rescue => e
+      $logger.error("main") {"camera error occured (#{e.message})"}
+      @state = :ABORTED
+
+    ensure
+      @camera&.stop if @camera&.busy?
+      @camera&.close
+      @camera = nil
+
+      $logger.info("main") {"camera thread stop"}
+    end
+    private :camera_thread
+
+    def sender_thread
+      $logger.info("main") {"sender thread start"}
+
+      loop {
+        data = @img_que.deq
+        @clients.each {|c| c[:que] << data}
+        broadcast(:update_image, {:type => "image/jpeg", :data => data})
+      }
+
+    rescue Stop
+      $logger.info("main") {"accept stop request"}
+      @clients.each {|c| c[:que] << nil}
+
+    ensure
+      $logger.info("main") {"sender thread stop"}
+    end
+
+    def get_camera_info
+      @mutex.synchronize {
+        ret = {
+          :device => $target,
+          :state  => @state
+        }
+
+        ret.merge!(:bus => @camera.bus, :name => @camera.name) if @camera
+
+        return ret
+      }
+    end
+
+    def get_ident_string
+      raise("state violation") if @state != :BUSY
+      return "#{@camera.name}@#{@camera.bus}"
+    end
+
+    def get_config
+      raise("state violation") if @state != :BUSY
+      return @config
+    end
+
+    def set_image_size(width, height)
+      raise("state violation") if @state != :BUSY
+
+      @mutex.synchronize {
+        @config[:image_width]  = width
+        @config[:image_height] = height
+      }
+
+      restart_camera()
+      broadcast(:update_image_size, width, height)
+    end
+
+    def set_framerate(num, deno)
+      raise("state violation") if @state != :BUSY
+
+      @mutex.synchronize {
+        @config[:framerate] = [num, deno]
+      }
+
+      restart_camera()
+      broadcast(:update_framerate, num, deno)
+    end
+
+    def set_control(id, val)
+      raise("state violation") if @state != :BUSY
+
+      entry = nil
+
+      @mutex.synchronize {
+        entry = @config[:controls].find {|obj| obj[:id] == id} 
+        entry[:value] = val if entry
+      }
+
+      if entry
+        restart_camera()
+        broadcast(:update_control, id, val)
+      end
+    end
+
+    def save_config
+      @mutex.synchronize {
+        $db_file.binwrite(@db.to_msgpack)
+      }
+    end
+
+    def add_client(que)
+      @clients << {:que => que}
+    end
+
+    def remove_client(que)
+      @clients.reject! {|c| c[:que] == que}
+    end
+  end
+end

data/lib/ipcam/version.rb

@@ -0,0 +1,3 @@
+module IPCam
+  VERSION = "0.1.0"
+end

data/lib/ipcam/webserver.rb

@@ -0,0 +1,178 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+#
+# Sample for v4l2-ruby
+#
+#   Copyright (C) 2019 Hiroshi Kuwagata <kgt9221@gmail.com>
+#
+
+require 'sinatra/base'
+require 'sinatra/streaming'
+require 'puma'
+require 'puma/configuration'
+require 'puma/events'
+require 'eventmachine'
+require 'securerandom'
+
+module IPCam
+  class WebServer < Sinatra::Base
+    set :environment, (($develop_mode)? %s{development}: %s{production})
+    set :views, APP_RESOURCE_DIR + "views"
+    set :threaded, true
+    set :quiet, true
+
+    enable :logging
+
+    use Rack::CommonLogger, $logger
+
+    configure :development do
+      before do
+        cache_control :no_store, :no_cache, :must_revalidate,
+                      :max_age => 0, :post_check => 0, :pre_check => 0
+        headers "Pragma" => "no-cache"
+      end
+    end
+
+    helpers do
+      def app
+        return (@app ||= settings.app)
+      end
+
+      def find_resource(type, name)
+        ret = RESOURCE_DIR + "extern" + type + name
+        return ret if ret.exist?
+
+        ret = RESOURCE_DIR + "common" + type + name
+        return ret if ret.exist?
+
+        ret = APP_RESOURCE_DIR + type + name
+        return ret if ret.exist?
+
+        return nil
+      end
+    end
+
+    get "/" do
+      redirect "/main"
+    end
+
+    get "/main" do
+      erb :main
+    end
+
+    get "/settings" do
+      erb :settings
+    end
+
+    get "/stream" do
+      boundary = SecureRandom.hex(20)
+      queue    = Thread::Queue.new
+
+      content_type("multipart/x-mixed-replace; boundary=#{boundary}")
+
+      # pumaで:keep_openが動作しないのでちょっと面倒な方法で
+      # 対応
+      stream do |port|
+        port.callback {
+          app.remove_client(queue)
+          queue.clear
+          queue << nil
+        }
+
+        port << "\r\n"
+        app.add_client(queue)
+
+        loop {
+          data = queue.deq
+          break if not data
+
+          port << <<~EOT.b
+            --#{boundary}
+            Content-Type: image/jpeg\r
+            Content-Length: #{data.bytesize}\r
+            \r
+          EOT
+
+          port << data
+        }
+      end
+    end
+
+    get %r{/css/(.+).scss} do |name|
+      content_type('text/css')
+      scss name.to_sym, :views => APP_RESOURCE_DIR + "scss"
+    end
+
+    get %r{/(css|js|fonts)/(.+)} do |type, name|
+      path = find_resource(type, name)
+      
+      if path
+        send_file(path)
+      else
+        halt 404
+      end
+    end
+
+    class << self
+      def bind_url
+        if $bind_addr.include?(":")
+          addr = "[#{$bind_addr}]" if $bind_addr.include?(":")
+        else
+          addr = $bind_addr
+        end
+
+        return "tcp://#{addr}:#{$http_port}"
+      end
+      private :bind_url
+
+      def env_string
+        return ($develop_mode)? 'development':'production'
+      end
+
+      def start(app)
+        set :app, app
+
+        config  = Puma::Configuration.new { |user_config|
+          user_config.quiet
+          user_config.threads(4, 4)
+          user_config.bind(bind_url())
+          user_config.environment(env_string())
+          user_config.force_shutdown_after(-1)
+          user_config.app(WebServer)
+        }
+
+        @events = Puma::Events.new($log_device, $log_device)
+        @launch = Puma::Launcher.new(config, :events => @events)
+
+        # pumaのランチャークラスでのシグナルのハンドリングが
+        # 邪魔なのでオーバライドして無効化する
+        def @launch.setup_signals
+          # nothing
+        end
+
+        @thread = Thread.start {
+          begin
+            $logger.info('webserver') {"started #{bind_url()}"}
+            @launch.run
+          ensure
+            $logger.info('webserver') {"stopped"}
+          end
+        }
+
+        # サーバが立ち上がりきるまで待つ
+        booted  = false
+        @events.on_booted {booted = true}
+        sleep 0.2 until booted
+      end
+
+      def stop
+        @launch.stop
+        @thread.join
+
+        remove_instance_variable(:@launch)
+        remove_instance_variable(:@thread)
+      end
+    end
+  end
+end