vncrec 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 44f235ad8e44ea1bab090676b4b011ba3eb53993
+  data.tar.gz: 314f906e6b36542cc0c8ed42b61fe14c0de4dc31
+SHA512:
+  metadata.gz: bcab87f697e3d8ea4da518a1e2bde030235b83016d1c6c48a327168f365d75f4c962589f037fcc4465b5faa09eb88ae4b77b2470fdfe1185fb35c4677ae529a6
+  data.tar.gz: ee53667bcbfc8f44e2e86304cd82932d3f095090dedfeabf59618f42680fb942fac35d69dc3b2c93e3aba33f3e0f8e875a6e318f916ad43b0dfa95a81e9fc30a

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+*.swp
+mkmf.log
+tags

data/.rspec

@@ -0,0 +1,4 @@
+--color
+--warnings
+--require spec_helper
+-f doc

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 slowness pc
+
+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.md

@@ -0,0 +1,36 @@
+VNCRec
+===========
+
+VNCRec is a gem that provides you 
+tools to record VNC session.
+
+##Usage
+There is a binary called `vncrec`, which is a recorder tool.
+
+With no host specified, it will listen on
+given port (5900 by default) for connection
+from VNC server (they refer to that mode as
+_reverse connection_). This is intended to
+be used when you want to record remote
+desktop and you don't know if it's available.
+
+Call `vncrec -h` for list of available options.
+To stop recording send `SIGINT` (press ^C).
+
+You can also use `VNCRec::Recorder` class in your ruby code.
+
+```ruby
+require 'vncrec'
+
+r = VNCRec::Recorder.new(filename: "myvncsession.mp4")
+r.run
+# loop do 
+#   sleep 100
+# end
+```
+
+If you have FFmpeg installed, file extension is passed just through to it, so
+you can specify encoder you want by passing .mp4 or .flv, etc. If no filename
+specified, `vncrec` assumes raw. There is also a way to 
+record raw video by specifying filename with extension .raw. This way FFmpeg is 
+not required.

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler/gem_tasks'
+require 'rake/extensiontask'
+Rake::ExtensionTask.new('enchex_c')
+
+CLEAN.add '*.mp4'
+CLEAN.add '*.raw'
+CLEAN.add '*.jpg'
+CLEAN.add 'somefile'

data/bin/vncrec

@@ -0,0 +1,80 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require 'optparse'
+require 'vncrec'
+
+options = VNCRec::Recorder::DEFAULTS
+
+OptionParser.new do |opts|
+  opts.on('--pix_fmt F', 'Specify pixel format. List available with --pix_fmts') do |d|
+    options[:pix_fmt] = d.dup
+  end
+  opts.on('--pix_fmts', 'List available pix_fmts') do
+    puts 'Available pixel formats:'
+    puts "bgr8\t8 bits color palette"
+    puts "bgra\t32 bits color palette"
+    puts
+    exit 0
+  end
+  opts.on('--debug', 'Enable debugger, gem pry-debugger required') do
+    require 'pry-byebug'
+    options[:debug] = true
+  end
+  opts.on('-e ENC', '--encoding', 'Specify encoding') do |e|
+    name = "ENC_#{e.upcase}".to_sym
+    if VNCRec.constants.index(name)
+      options[:encoding] = VNCRec.const_get(name)
+    else
+      puts 'Unsupported encoding type. Pass option --encodings to see a list of available encodings.'
+      exit 1
+    end
+  end
+  opts.on('--encodings', 'Print list of available encodings') do
+    puts 'Available encodings are:'
+    puts "\traw"
+    puts "\thextile"
+    puts "\tzrle(not yet supported)"
+    puts
+    exit
+  end
+  opts.on('-g GEOM', '--geometry GEOM', 'Screen resolution, <X>x<Y>') do |opt|
+    unless opt =~ /\d+x\d+/
+      puts 'Unknown screen resolution format, use <x>x<y>'
+      exit 1
+    end
+    options[:geometry] = opt
+  end
+  opts.on('-h', '--help', 'Display this message') do
+    puts opts
+    exit
+  end
+  opts.on('--logging', 'Enable logging to stderr') do
+    options[:logging] = true
+  end
+  opts.on('-o NAME', '--output', 'Specify filename to write to. Special name is "stdout"') do |f|
+    options[:filename] = f.to_s
+  end
+  opts.on('-p PORT', '--port', 'Choose port to listen on') do |p|
+    options[:port] = p.to_i
+  end
+  opts.on('-r RATE', '--framerate <rate>', 'Specify framerate') do |r|
+    options[:fps] = r.to_i
+  end
+  opts.on('-s', '--server SERVER', 'Specify host address') do |s|
+    options[:host] = s
+  end
+end.parse!
+
+v = VNCRec::Recorder.new(options)
+v.on_exit << ->() { exit }
+Signal.trap('INT') { v.running? ? v.stop : exit }
+Signal.trap('USR1') do
+  puts v.filesize
+  $stdout.flush
+end
+
+v.run
+loop do
+  sleep 100
+end

data/examples/exit.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require 'vncrec'
+
+r = VNCRec::Recorder.new
+#  Append exit to the list of on_exit hooks.
+r.on_exit.push(->() { exit })

data/examples/mp4.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require 'vncrec'
+
+VNCRec::Recorder.new(
+  encoding: VNCRec::EncHextile,
+  filename: 'file.mp4',
+  ffmpeg_out_opts: '-vcodec libx264 -preset ultrafast'
+)

data/examples/mp4audio.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require 'vncrec'
+
+VNCRec::Recorder.new(
+  encoding: VNCRec::EncHextile,
+  filename: 'file.mp4',
+  ffmpeg_ia_opts: '-i /path/to/audio/file.mp3',
+  ffmpeg_out_opts: '-map 0 -vcodec libx264 -preset ultrafast -map 1 -acodec mp3'
+)

data/ext/enchex_c/ReadRect.c

@@ -0,0 +1,215 @@
+#include <ruby.h>
+#include <ruby/io.h>
+#include <fcntl.h>
+
+#include <math.h>
+
+int my_readbyte(VALUE io){
+  return NUM2INT( rb_funcall(io, rb_intern("readbyte"),0));
+}
+
+char *my_read(VALUE io, long nbytes){
+  char * result = (char*)malloc(nbytes+1);
+  VALUE nbytes_v = INT2NUM(nbytes);
+  VALUE rstr = rb_funcall(io, rb_intern("read"), 1,nbytes_v);
+  memcpy(
+      result,
+      RSTRING_PTR(rstr),
+      RSTRING_LEN(rstr)
+      );
+  return result;
+}
+
+VALUE mVNC = Qnil;
+VALUE mEncHextile = Qnil;
+VALUE mRFB = Qnil;
+
+void Init_enchex_c();
+
+static VALUE read_rect_c(VALUE self,VALUE io, VALUE _x, VALUE _y, VALUE _w, VALUE _h, VALUE bitspp, VALUE fb, VALUE fbw, VALUE fbh);
+
+void Init_enchex_c() {
+  mVNC = rb_define_module("VNCRec");
+  mRFB = rb_define_module_under(mVNC, "RFB");
+  mEncHextile = rb_define_module_under(mRFB, "EncHextile");
+  rb_define_module_function(mEncHextile, "read_rect", read_rect_c, 9);
+}
+
+void _read_subrect_c(int rx, int ry, int rw, int rh, int tx, int ty, char *fg, VALUE io, char* fb, int fbw, int fbh, int bpp){
+
+  unsigned char xy, wh;
+  xy = my_readbyte(io);
+  wh = my_readbyte(io);
+
+  if(!fb)
+    return;
+
+  unsigned char stx = (xy & 0xF0) >> 4;
+  unsigned char stw = ((wh & 0xF0) >> 4) + 1;
+  unsigned char sty = (xy & 0x0F);
+  unsigned char sth = (wh & 0x0F) + 1;
+  rw *= bpp;
+  rx *= bpp;
+  tx *= bpp;
+  stx *= bpp;
+  stw *= bpp;
+  char *fg_row = (char*)malloc(stw);
+  int k,l;
+  for(k = 0; k < stw; k+=bpp){
+    for(l = 0; l < bpp; l++){
+      fg_row[k+l] = fg[l];
+    }
+  }
+
+  int i;
+  for (i = 0; i < sth; i++) {
+    register int row_begin = fbw*(ry+ty+sty+i) + rx + tx + stx;
+    memcpy(&fb[row_begin], fg_row, stw);
+  }
+  free(fg_row);
+}
+
+void _read_subrect_c_raw(int rx, int ry, int rw, int rh, int tx, int ty, int tw, int th, VALUE io, char* fb, int fbw, int fbh, int bpp){
+
+  rw *= bpp;
+  rx *= bpp;
+  tw *= bpp;
+  tx *= bpp;
+
+  int trow;
+  char *data = my_read(io, tw*th);
+
+  if(!fb){
+    return;
+  }
+
+  for (trow = 0; trow < th; trow++) {
+    register int row_begin = fbw*(ry+ty+trow) + rx + tx;
+    memcpy( &fb[row_begin], &data[trow*tw],tw);
+  }
+  free(data);
+}
+
+void _fill_tile_bg(int rx, int ry, int rw, int rh, int tx, int ty, int tw, int th, char*bg, VALUE io, char* fb, int fbw, int fbh, int bpp){
+  if(!fb)
+    return;
+
+  rw *= bpp;
+  rx *= bpp;
+  tw *=bpp;
+  tx *= bpp;
+  int trow;
+  char *bg_row = (char*)malloc(tw);
+  int k,l;
+  for(k = 0; k < tw; k+=bpp){
+    for(l = 0; l < bpp; l++){
+      bg_row[k+l] = bg[l];
+    }
+  }
+  register int base_row_begin = fbw*(ry+ty) + rx + tx;
+  for (trow = 0; trow < th; trow++) {
+    register int row_begin = base_row_begin + fbw*trow;
+    memcpy(&fb[row_begin], bg_row, tw);
+  }
+  free(bg_row);
+}
+
+static VALUE read_rect_c(VALUE self,VALUE io, VALUE _x, VALUE _y, VALUE _w, VALUE _h, VALUE bitspp, VALUE _fb, VALUE _fbw, VALUE _fbh){
+  int w = NUM2INT(_w);
+  int h = NUM2INT(_h);
+  int rx = NUM2INT(_x);
+  int ry = NUM2INT(_y);
+  int fbw = NUM2INT(_fbw);
+  int fbh = NUM2INT(_fbh);
+  int bpp = (float)NUM2INT(bitspp) / 8.0;
+
+
+  int tiles_row_num = ceil((float)h/16.0);
+  int tiles_col_num = ceil((float)w/16.0);
+
+  char *fb;
+  int fbsize = fbw*fbh;
+  if(ry > fbh || rx * bpp > fbw)
+    fb = NULL; // skip
+  else
+    fb = (char*)malloc(fbsize);
+  if(fb)
+    memcpy(fb,RSTRING(_fb)->as.heap.ptr,RSTRING(_fb)->as.heap.len);
+
+  int last_tile_w = w % 16;
+  int last_tile_h = h % 16;
+
+  char prev_tile_bg[4];
+  char prev_tile_fg[4];
+
+  int i,j;
+  int tw, th;
+  int ty, tx;
+  int ti,tj,tk;
+  unsigned char subenc;
+  for (i = 0; i < tiles_row_num; i++) {
+
+    if ((i == tiles_row_num-1) && (last_tile_h > 0))
+      th = last_tile_h;
+    else
+      th = 16;
+    ty = 16 * i;
+    for (j = 0; j < tiles_col_num; j++) {
+      
+      if ((j == tiles_col_num-1) && (last_tile_w > 0))
+        tw = last_tile_w;
+      else
+        tw = 16;
+      tx = 16 * j;
+
+      subenc = my_readbyte(io);
+
+      if(subenc & 1){ //raw
+        _read_subrect_c_raw(rx,ry,w,h,tx,ty,tw,th,io,fb,fbw,fbh,bpp);
+      }
+      if(subenc & 2){//background specified
+        for (tk = 0; tk < bpp; tk++) {
+          prev_tile_bg[tk] = my_readbyte(io);
+        }
+      }
+      if(!(subenc & 1)){//should not refill raw
+        for (ti = 0; ti < th; ti++) {
+          for(tj = 0; tj < tw; tj++){
+            _fill_tile_bg(rx,ry,w,h,tx,ty,tw,th,prev_tile_bg,io,fb,fbw,fbh,bpp);
+          }
+        }
+      }
+      if(subenc & 4){//foreground specified
+        for (tk = 0; tk < bpp; tk++) {
+          prev_tile_fg[tk] = my_readbyte(io);
+        }
+      }
+      if(subenc & 8){//any subrect
+        size_t subrects_number = my_readbyte(io);
+        size_t subrect;
+        char fg[4];
+        for (subrect = 0; subrect < subrects_number; subrect++) {
+          if(subenc & 16){//subrect colored
+            for (tk = 0; tk < bpp; tk++) {
+              fg[tk] = my_readbyte(io);
+            }
+            _read_subrect_c(rx,ry,w,h,tx,ty, fg, io, fb, fbw, fbh, bpp);
+          }else{
+            _read_subrect_c(rx,ry,w,h,tx,ty, prev_tile_fg, io, fb, fbw, fbh, bpp);
+          }
+        }
+      }
+
+    } //for j
+  }//for i
+
+  if(fb) {
+    for (i = 0; i < fbh; i++) {
+      rb_str_update(_fb, i*fbw, fbw,
+          rb_str_new(&fb[i * fbw], fbw));
+    }
+    free(fb);
+  }
+
+  return Qtrue;
+}

data/ext/enchex_c/extconf.rb

@@ -0,0 +1,5 @@
+require "mkmf"
+
+extension_name = 'enchex_c'
+dir_config(extension_name)
+create_makefile("vncrec/rfb/#{extension_name}")