coderrr-video-accel 0.0.1

data/README.markdown

@@ -0,0 +1,10 @@
+Video what?
+====
+
+video-accel is an accelerator for streaming videos on the web.  It acts very similar to a download accelerator.
+
+A download accelerator will split a file up into a small (~5) number of even parts.  It will then download each part simultaneously.  This gets past the per-connection bandwidth cap and allows you to max out your total bandwidth cap.  The problem with this is that it doesn't help you watch videos while they're downloading since the first 1/5 of the file will still be downloading at normal speed, and that's the part you want to start watching now.
+
+So instead of splitting the file up into a small number of even parts, video-accel splits the file up into a large number of even parts and then downloads a small number at a time, but it downloads them *in order*.  The fact that it downloads them in order is what allows you to still stream the video while it is being downloaded at a faster rate.
+
+Currently video-accel only works with Linux.

data/Rakefile

@@ -0,0 +1 @@
+load 'video-accel.gemspec'

data/bin/vdl

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+load File.dirname(__FILE__) + '/../lib/vdl.rb'

data/bin/vplayer

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH << File.dirname(__FILE__) + "/lib"
+
+require 'video_player'
+
+VideoPlayer.new(ARGV[0]).play

data/lib/clip_nabber.rb

@@ -0,0 +1,21 @@
+require 'uri'
+
+class ClipNabber
+  URI = ::URI.parse("http://clipnabber.com/gethint.php?mode=1")
+  
+  def initialize(url)
+    @url = url
+  end
+  
+  def download_link
+    body = Net::HTTP.start(URI.host, URI.port) do |h|
+      h.request_get(URI.request_uri + "&url=#{@url}&sid=#{rand}", 'Referer' => 'http://clipnabber.com').body
+    end
+    
+    if body =~ %r{<a href='([^']+).*?><strong>FLV download link}im
+      $1
+    else 
+      nil
+    end
+  end
+end

data/lib/core_ext.rb

@@ -0,0 +1,17 @@
+class IO
+  def while_reading(data = nil, &b)
+    while buf = readpartial_rescued(16384)
+      data << buf  if data
+      yield buf  if block_given?
+    end
+    data
+  end
+
+  private
+
+  def readpartial_rescued(size)
+    readpartial(size)
+  rescue EOFError
+    nil
+  end
+end

data/lib/speed_stream.rb

@@ -0,0 +1,137 @@
+#!/usr/bin/env ruby
+
+require 'net/http'
+require 'cgi'
+require 'threadpool'
+require 'core_ext'
+Thread.abort_on_exception = true
+
+class SpeedStream
+  USER_AGENT = %{Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.0.3) Gecko/2008092510 Ubuntu/8.04 (hardy) Firefox/3.0.3}
+  BUF_SIZE = 1024
+
+  attr_reader :uri, :bytes_per_conn, :output_file, :file_handle, :concurrent_connections, :cookies
+  attr_accessor :on_progress
+  
+  def initialize(uri, output_file)
+    @uri = URI.parse(uri)
+    @output_file = output_file
+    @write_mutex = Mutex.new
+    @finished = []
+    @bytes_per_conn = 30_000
+    @concurrent_connections = 10
+    @cookies = {}
+    @extra_file_length_headers = {'Range' => 'bytes=1-'}
+  end
+  
+  def download!
+    @start_time = Time.now
+    @bytes_written = 0
+    pool = ThreadPool.new(concurrent_connections, 999999)
+    
+    File.open(output_file, "wb") do |f|
+      @file_handle = f
+  
+      begin
+        ranges.each do |range|
+          pool.add_work(range) do |range|
+            download_range range
+          end
+        end
+      ensure
+        pool.shutdown
+      end
+    end
+  end
+  
+  
+  private 
+  
+  def download_range(range)
+    file_offset = range.begin
+    
+    data = get_with_redirects(range)
+    write_file(file_offset, data)
+    
+    process_progress(range)
+  end
+  
+  def process_progress(range)
+    pos = range.begin/bytes_per_conn
+    @finished[pos] = 1
+    total_pos = file_length/bytes_per_conn
+    time_passed = Time.now - @start_time
+    
+    completed_count = (@finished.index(nil)||@finished.size)
+    completed_bytes = completed_count * bytes_per_conn
+    bps = 1.0 * @bytes_written/time_passed
+    percent = 100.0 * completed_count / total_pos
+
+    on_progress.call(completed_bytes, bps, percent)  if on_progress
+  end
+
+  def get_with_redirects(range)
+    loop do
+      Net::HTTP.start(uri.host, uri.port) do |h|
+        req = h.request_get(uri.request_uri, 'Range' => "bytes=#{range.begin}-#{range.end}", 'Cookie' => cookie_string)
+        if loc = req['location']
+          @uri = URI.parse(loc)
+          next
+        end
+
+        return req.body
+      end
+    end
+  end
+  
+  def write_file(pos, buf)
+    @bytes_written += buf.size
+    @write_mutex.synchronize do
+      file_handle.seek(pos, IO::SEEK_SET)
+      file_handle.write buf
+      file_handle.flush
+    end
+  end
+  
+  def ranges
+    @ranges ||= begin
+      rs = []
+      (file_length/bytes_per_conn).times do |n|
+        rs << (n*bytes_per_conn..(n+1)*bytes_per_conn)
+      end
+      rs[-1] = (rs[-1].begin..file_length)
+      rs
+    end
+  end
+  
+  def file_length
+    @file_length ||= begin
+      current_uri = uri
+      loop do
+        Net::HTTP.start(current_uri.host, current_uri.port) do |h|
+          headers = {'Host' => current_uri.host, 'User-Agent' => USER_AGENT, 'Cookie' => cookie_string}
+          headers.merge! @extra_file_length_headers
+          resp = h.request_head(current_uri.request_uri, headers)
+                   
+          cookies.merge! parse_cookies(resp['set-cookie'])  if resp['set-cookie']
+          
+          if loc = resp['location']
+            current_uri = URI.parse(loc)
+            next
+          end
+
+          @uri = current_uri
+          return resp['content-length'].to_i
+        end
+      end
+    end
+  end
+  
+  def parse_cookies(header)
+    Hash[*header.scan(/(?:^|, )(\w+)=([^;]+)/).flatten]
+  end
+  
+  def cookie_string
+    cookies.map {|k,v| "#{k}=#{v}"}.join '; '
+  end
+end

data/lib/threadpool.rb

@@ -0,0 +1,115 @@
+require 'thread'
+require 'monitor'
+
+class ThreadPool
+
+  class PoolStopped < Exception; end
+
+  def initialize(thread_size=10, queue_size=100)
+    @mutex = Monitor.new
+    @cv = @mutex.new_cond
+    @queue = []
+    @max_queue_size = queue_size
+    @threads = []
+    @stopped = false
+    thread_size.times { @threads << Thread.new { start_worker } }
+  end
+
+  def add_work(*args, &callback)
+    push_task(Task.new(*args, &callback))
+  end
+
+  def push_task(task)
+    @mutex.synchronize do
+      raise PoolStopped.new if @stopped
+      @cv.wait_while { @max_queue_size > 0 && @queue.size >= @max_queue_size }
+      @queue.push(task)
+      @cv.broadcast
+    end
+    task
+  end
+
+  def pop_task
+    task = nil
+    @mutex.synchronize do
+      @cv.wait_while { @queue.size == 0 }
+      task = @queue.shift
+      @cv.broadcast
+    end
+    task
+  end
+
+  def shutdown
+    @mutex.synchronize do
+      @stopped = true
+      @threads.each { @queue.push(:stop) }
+      @cv.broadcast
+    end
+    @threads.each { |thread| thread.join }
+  end
+
+  def start_worker
+    while true
+      task = pop_task
+      return if task == :stop
+      task.execute
+    end
+  end
+
+  # wait for current work to complete
+  def sync
+    tasks = @mutex.synchronize { @queue.dup }
+    tasks.each { |task| task.join }
+  end
+
+  class Task
+
+    attr_reader :result, :exception
+
+    def initialize(*args, &callback)
+      @args = args
+      @callback = callback
+      @done = false
+      @result = nil
+      @exception = nil
+      @mutex = Monitor.new
+      @cv = @mutex.new_cond
+    end
+
+    def execute
+      begin
+        @result = @callback.call(*@args)
+      rescue Exception => e
+        @exception = e
+  STDERR.puts "Error in thread #{Thread.current} - #{e}"
+  e.backtrace.each { |element| STDERR.puts(element) }
+      end
+      @mutex.synchronize do
+        @done = true
+        @cv.broadcast
+      end
+    end
+
+    def join
+      @mutex.synchronize { @cv.wait_until { @done } }
+    end
+
+  end
+
+end
+#
+#tasks = []
+#tp = ThreadPool.new(10, 1000)
+#sleep(1)
+#100.times do |id|
+#  STDERR.puts "adding work"
+#  tasks << tp.add_work do
+#    puts "Running #{id} #{Thread.current}"
+#    sleep 5
+#    puts "Ending #{id} #{Thread.current}"
+#  end
+#end
+#
+#puts "Waiting for shutdown"
+#tp.shutdown
+#puts "done"

data/lib/vdl.rb

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH << File.dirname(__FILE__)
+require 'optparse'
+require 'fileutils'
+require 'clip_nabber'
+require 'youtube_speed_stream'
+
+skip_resolve = nil
+player = "vplayer"
+terminal = "gnome-terminal -e"
+
+(opts = OptionParser.new do |o|
+  o.on("-s", "--skip-resolve") { skip_resolve = true }
+  o.on("-p", "--player CMD") { |a| player = a }
+  o.on("-t", "--terminal CMD") { |a| terminal = a }
+end).parse!  rescue (puts opts; exit)
+url = ARGV.shift
+url = "http://#{url}"  if url !~ /https?:\/\//i
+puts "URL: #{url}"
+
+# random name
+ltrs=('a'..'z').to_a
+name = ([nil]*3).map{ltrs[rand(ltrs.size)]}*''
+dir = File.expand_path('~/.movies')
+FileUtils.mkdir_p dir
+file = File.join dir, name
+
+unless skip_resolve
+  puts "resolving url"
+  dl_url = ClipNabber.new(url).download_link
+  if ! (URI.parse(dl_url) rescue false)
+    puts "problem resolving #{url}"
+    exit
+  end
+  puts "resolved to #{dl_url}"
+  url = dl_url
+end
+
+klass = (url =~ /youtube\.com\//) ? YoutubeSpeedStream : SpeedStream
+stream = klass.new url, file
+
+started = false
+stream.on_progress = lambda do |bytes, bps, percent|
+  print "\ec"
+  puts "downloading #{url} to #{file}..."
+  puts "#{'%.2f'%bps} b/s   #{'%.2f%'%percent}"
+
+  if !started and bytes > 1_000_000
+    started = true
+    system(%{#{terminal} "#{player} #{file}" &})
+  end
+end
+
+stream.download!

data/lib/video_player.rb

@@ -0,0 +1,54 @@
+class VideoPlayer
+  MP_ARGS = [
+    "",
+    "-autosync 30 -mc 2.0",
+    "-autosync 0 -mc 0.0"
+  ]
+  
+  def initialize(file)
+    @file = file
+    @mplayer_arg = 0
+  end
+  
+  def wait_for_cmd
+    rdy = IO.select([STDIN])
+    if rdy.first.include? STDIN
+      process_cmd STDIN.getc.chr
+    end
+  end
+  
+  def process_cmd(cmd)
+    puts "process #{cmd}"
+    case cmd
+    when 'q' then exit!
+    when 'm'
+      @pid.kill!  if @pid
+      @pid = spawn("mplayer -msglevel all=0 #{MP_ARGS[@mplayer_arg]} #{@file}")
+      @mplayer_arg = (@mplayer_arg + 1)%MP_ARGS.size
+    when 'v'
+      @pid.kill!  if @pid
+      @pid = spawn("vlc #{@file}")
+    end
+  end
+  
+  def spawn(cmd)
+    pid = fork do
+      exec(cmd)
+    end
+    
+    o = Object.new
+    (class <<o;self;end).send :define_method, :kill! do
+      puts "killing #{pid}"
+      ret = Process.kill 9, pid
+    end
+    
+    o
+  end
+  
+  def play
+    process_cmd('m')
+    loop do
+      wait_for_cmd
+    end
+  end
+end

data/lib/youtube_speed_stream.rb

@@ -0,0 +1,46 @@
+require 'speed_stream'
+
+class YoutubeSpeedStream < SpeedStream
+  def initialize(*a)
+    super
+    @concurrent_connections = 20
+    @extra_file_length_headers = {}
+  end
+
+  private 
+  
+  def get_with_redirects(range)
+    current_uri = uri
+
+    loop do
+      TCPSocket.open(current_uri.host, current_uri.port) do |s|
+        uri_str = current_uri.request_uri
+        if uri_str.include? "&start="
+          uri_str.gsub(/&start=\d+/, "&start=#{range.begin}")
+        else
+          uri_str << "&start=#{range.begin}"
+        end
+        s.write("GET #{uri_str} HTTP/1.1\r\nHost: #{current_uri.host}\r\nCookie: #{cookie_string}\r\n\r\n")
+        
+        s.while_reading(data = "") { break  if data =~ /\r?\n\r?\n/ }
+        
+        if data =~ /^Location: (.+?)\r?$/
+          current_uri = URI.parse($1)
+          next
+        end
+        
+        # strip off header and keep reading
+        data.gsub!(/\A.+?\r?\n\r?\n/m,'')
+        
+        while buf = (s.readpartial(16384) rescue nil)
+          data << buf
+          break  if range.begin + data.size > range.end
+        end
+
+        # strip FLV headers on all parts except first
+        start = range.begin == 0 ? 0 : 13
+        return data[start, range.end - range.begin]
+      end
+    end
+  end
+end

data/video-accel.gemspec

@@ -0,0 +1,14 @@
+spec = Gem::Specification.new do |s|
+  s.name = "video-accel"
+  s.version = "0.0.1"
+  s.author = "coderrr"
+  s.email = "coderrr.contact@gmail.com"
+#  s.homepage = "http://blogs.cocoondev.org/crafterm/"
+  s.platform = Gem::Platform::RUBY
+  s.summary = "accelerate video streams"
+  s.files =  ["lib/vdl.rb", "lib/speed_stream.rb", "lib/youtube_speed_stream.rb", "lib/threadpool.rb", "lib/core_ext.rb", "lib/clip_nabber.rb", "lib/video_player.rb", "bin/vdl", "bin/vplayer"] +
+           %w(Rakefile README.markdown video-accel.gemspec)
+  s.require_path = "lib"
+  s.bindir = "bin"
+  s.executables = ["vdl", "vplayer"]
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification 
+name: coderrr-video-accel
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- coderrr
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-10-09 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: coderrr.contact@gmail.com
+executables: 
+- vdl
+- vplayer
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/vdl.rb
+- lib/speed_stream.rb
+- lib/youtube_speed_stream.rb
+- lib/threadpool.rb
+- lib/core_ext.rb
+- lib/clip_nabber.rb
+- lib/video_player.rb
+- bin/vdl
+- bin/vplayer
+- Rakefile
+- README.markdown
+- video-accel.gemspec
+has_rdoc: false
+homepage: 
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: accelerate video streams
+test_files: []
+