activevlc 0.0.1 → 0.0.3

data/lib/activevlc/libvlc/instance.rb

@@ -0,0 +1,71 @@
+module ActiveVlc::LibVlc
+  # This is just a hack to have the libvlc_instance released when
+  # the Instance class is GC'ed
+  class InstancePtr < FFI::ManagedStruct
+    layout :nothing, :pointer
+
+    def self.release(ptr)
+      #puts "Releasing an InstancePtr #{ptr.inspect}"
+      Api.libvlc_release(ptr)
+    end
+  end
+
+  class Instance
+    attr_reader :exit_callback, :ptr
+
+    def initialize(args = [""])
+      argc = args.length
+      @argv = args.map{ |a| FFI::MemoryPointer.from_string a}
+      test = FFI::MemoryPointer.new(:pointer, argc)
+      test.put_array_of_pointer(0, @argv)
+
+      @ptr = InstancePtr.new Api.libvlc_new(argc, test)
+      raise "Unable to create a libvlc_instance_t" if @ptr.null?
+    end
+
+    def create_media(mrl)
+      if mrl =~ /\A[a-z]+:\/\/.+/
+        m = Api.libvlc_media_new_location(@ptr, mrl)
+      else
+        m = Api.libvlc_media_new_path(@ptr, mrl)
+      end
+      raise "Unable to create a libvlc_media_t" if m.null?
+      Media.new(m, mrl)
+    end
+
+    def create_media_list
+      ml = Api.libvlc_media_list_new(@ptr)
+      raise "Unable to create a libvlc_media_list_t" if ml.null?
+      MediaList.new(ml)
+    end
+
+    def create_list_player(list = nil, player = nil)
+      mlp = Api.libvlc_media_list_player_new(@ptr)
+      raise "Unable to create a libvlc_media_list_player_t" if mlp.null?
+      MediaListPlayer.new(mlp, list, player)
+    end
+
+    def create_player(media = nil)
+      if media and media.is_a?(Media)
+        MediaPlayer.new(media)
+      else
+        MediaPlayer.new self
+      end
+    end
+
+    def wait!
+      Api.libvlc_wait(@ptr)
+    end
+
+    def at_exit(&block)
+      Api.libvlc_set_exit_handler(@ptr, nil, nil)
+      @exit_callback = block
+      Api.libvlc_set_exit_handler(@ptr, @exit_callback, nil)
+    end
+
+    def add_interface(name = nil)
+      Api.libvlc_add_intf(@ptr, name)
+    end
+  end
+
+end

data/lib/activevlc/libvlc/media.rb

@@ -0,0 +1,32 @@
+module ActiveVlc::LibVlc
+  # See InstancePtr in instance.rb
+  class MediaPtr < FFI::ManagedStruct
+    layout :nothing, :pointer
+
+    def self.release(ptr)
+      # puts "Releasing a MediaPtr #{ptr.inspect}"
+      Api.libvlc_media_release(ptr)
+    end
+  end
+
+  class Media
+    attr_reader :ptr, :mrl
+
+    def initialize(ptr, mrl)
+      @ptr = MediaPtr.new(ptr)
+      @mrl = mrl
+    end
+
+    def <<(option)
+      raise "option must be a String" unless option.is_a?(String)
+
+      Api.libvlc_media_add_option(@ptr, option)
+      self
+    end
+
+    def event_manager
+      EventManager.new Api.libvlc_media_event_manager(@ptr)
+    end
+
+  end
+end

data/lib/activevlc/libvlc/media_list.rb

@@ -0,0 +1,55 @@
+module ActiveVlc::LibVlc
+  # See InstancePtr in instance.rb
+  class MediaListPtr < FFI::ManagedStruct
+    layout :media_list, :pointer
+
+    def self.release(ptr)
+      # puts "Releasing an MediaListPtr"
+      Api.libvlc_media_list_release(ptr)
+    end
+  end
+
+  class MediaList
+    attr_reader :ptr
+
+    def initialize(ptr)
+      @ptr = MediaListPtr.new(ptr)
+    end
+
+    # Execute the given block with the media_list lock acquired.
+    def locked!
+      if block_given?
+        _lock!
+        res = yield
+        _unlock!
+        res
+      end
+    end
+
+    def event_manager
+      EventManager.new Api.libvlc_media_list_event_manager(@ptr)
+    end
+
+    def media=(media)
+      Api.libvlc_media_list_set_media(@ptr, media.ptr)
+    end
+
+    def <<(media)
+      locked! { Api.libvlc_media_list_add_media(@ptr, media.ptr) }
+    end
+
+    def length
+      locked! { Api.libvlc_media_list_count(@ptr) }
+    end
+
+    protected
+    def _lock!
+      Api.libvlc_media_list_lock(@ptr)
+    end
+    def _unlock!
+      Api.libvlc_media_list_unlock(@ptr)
+    end
+
+
+  end
+end

data/lib/activevlc/libvlc/media_list_player.rb

@@ -0,0 +1,64 @@
+module ActiveVlc::LibVlc
+  class MediaListPlayerPtr < FFI::ManagedStruct
+    layout :nothing, :pointer
+
+    def self.release(ptr)
+      # puts "Releasing a MediaListPlayerPtr #{ptr.inspect}"
+      Api.libvlc_media_list_player_release(ptr)
+    end
+  end
+
+  class MediaListPlayer
+    attr_reader :ptr, :player, :list
+
+    def initialize(ptr, media_list = nil, media_player = nil)
+      @ptr = MediaListPlayerPtr.new(ptr)
+      @list = media_list
+      @player = media_player
+
+      self.media_list = media_list if media_list
+      self.media_player = media_player if media_player
+    end
+
+    def media_list=(list)
+      if list and list.is_a?(MediaList)
+        @list = list
+        Api.libvlc_media_list_player_set_media_list(@ptr, list.ptr)
+      else
+        raise "You must provide a valid MediaList"
+      end
+    end
+
+    def event_manager
+      EventManager.new Api.libvlc_media_list_player_event_manager(@ptr)
+    end
+
+    def playing?
+      Api.libvlc_media_list_player_is_playing(@ptr) != 0
+    end
+
+    def media_player=(player)
+      if player.is_a?(MediaPlayer) and not playing?
+        raise "Player already has a media" if player.media
+        @player = player
+        Api.libvlc_media_list_player_set_media_player(@ptr, player.ptr)
+      end
+    end
+
+    def play
+      Api.libvlc_media_list_player_play(@ptr)
+    end
+    def pause
+      Api.libvlc_media_list_player_pause(@ptr)
+    end
+    def stop
+      Api.libvlc_media_list_player_stop(@ptr)
+    end
+    def next
+      Api.libvlc_media_list_player_next(@ptr)
+    end
+    def previous
+      Api.libvlc_media_list_player_previous(@ptr)
+    end
+  end
+end

data/lib/activevlc/libvlc/media_player.rb

@@ -0,0 +1,63 @@
+module ActiveVlc::LibVlc
+  # See InstancePtr in instance.rb
+  class MediaPlayerPtr < FFI::ManagedStruct
+    layout :media_list, :pointer
+
+    def self.release(ptr)
+      # puts "Releasing an MediaPlayerPtr"
+      Api.libvlc_media_player_release(ptr)
+    end
+  end
+
+  class MediaPlayer
+    attr_reader :ptr, :media
+
+    def initialize(vlc_or_media)
+      @media = nil
+      if vlc_or_media.is_a?(Media)
+        @media = vlc_or_media
+        @ptr = Api.libvlc_media_player_new_from_media(vlc_or_media.ptr)
+      else
+        @ptr = Api.libvlc_media_player_new(vlc_or_media.ptr)
+      end
+    end
+
+    def event_manager
+      event_manger = Api.libvlc_media_player_event_manager(@ptr)
+      raise "Unable to get EventManager for MediaPlayer #{@ptr.inspect}" unless event_manger
+      EventManager.new event_manger
+    end
+
+    def media=(new_media)
+      raise "You must provide a valid Media" unless new_media and new_media.is_a?(Media)
+      @media = new_media
+      Api.libvlc_media_player_set_media(@ptr, @media.ptr)
+    end
+
+    def play
+      if_media { Api.libvlc_media_player_play @ptr }
+    end
+    def stop
+      if_media { Api.libvlc_media_player_stop @ptr }
+    end
+    def pause
+      if_media { Api.libvlc_media_player_pause @ptr}
+    end
+
+    def playing?
+      Api.libvlc_media_player_is_playing @ptr
+    end
+
+    def state
+      Api.libvlc_media_player_get_state @ptr
+    end
+
+    protected
+    def if_media
+      if block_given?
+        raise "MediaPlayer: No media set" unless @media
+        yield
+      end
+    end
+  end
+end

data/lib/activevlc/libvlc.rb

@@ -0,0 +1,33 @@
+##
+## libvlc.rb
+## Login : <lta@still>
+## Started on  Wed Jun 12 20:46:52 2013 Lta Akr
+## $Id$
+##
+## Author(s):
+##  - Lta Akr <>
+##
+## Copyright (C) 2013 Lta Akr
+
+require "ffi"
+
+module ActiveVlc
+  module LibVlc
+    VLC_SO_NAMES = [
+      'libvlc'.freeze,
+      'libvlc.so.5'.freeze
+      ].freeze
+    VLCCORE_SO_NAMES = [
+      'libvlccore'.freeze,
+      'libvlccore.so.5'.freeze
+      ].freeze
+  end
+end
+
+require 'activevlc/libvlc/api'
+require 'activevlc/libvlc/media'
+require 'activevlc/libvlc/instance'
+require 'activevlc/libvlc/media_player'
+require 'activevlc/libvlc/media_list'
+require 'activevlc/libvlc/media_list_player'
+require 'activevlc/libvlc/event_manager'

data/lib/activevlc/pipeline.rb

@@ -20,9 +20,11 @@ module ActiveVlc
 
     attr_reader :input, :sout
 
-    def initialize(input_array_or_string)
+    def initialize(input_array_or_string = nil, &block)
       @input = Stage::Input.new(input_array_or_string)
-      @sout = Stage::Stream.new  # SOut = Stream Out
+      @sout = Stage::Stream.new # SOut = Stream Out
+
+      ::ActiveVlc::DSL::Stream.new(@sout).instance_eval(&block) if block_given?
     end
 
     def fragment

data/lib/activevlc/pipeline_dump.rb

@@ -9,8 +9,6 @@
 ##
 ## Copyright (C) 2013 Lta Akr
 
-require 'debugger'
-
 module ActiveVlc
   module PipelineDump
     extend ActiveSupport::Concern

data/lib/activevlc/runner.rb

@@ -0,0 +1,71 @@
+#
+# Small note about this file code's coverage
+# Since most of the code is wan in another process
+# (see #run), the code coverage cannot be reported.
+# This file have around 100% of test code coverage
+#
+module ActiveVlc
+  class Runner
+    def initialize(pipeline, *args)
+      @pipeline = pipeline
+      @args = args
+    end
+
+    # Nobody can escape his faith.
+    def stop_runner!
+      @running = false
+    end
+
+    def run(fork = false)
+      if fork and Process.respond_to? :fork
+        pid = Process.fork { _run }
+        Process.wait pid
+      else
+        _run
+      end
+    end
+
+    protected
+    # Here we setup the media/list/player/event_manager
+    # to run the pipeline using LibVlc. There's a big unavoidable
+    # hack to run synchronously / 'join' the libvlc instance.
+    def _run
+      # Preparing instance/list/player/sout fragment/event manager
+      @api = LibVlc::Instance.new @args
+      sout = @pipeline.sout.fragment
+      list = @api.create_media_list
+      player = @api.create_player
+      events = player.event_manager
+
+      sout.gsub!('\'', '').gsub!('"', '')
+
+      # Building the medias with the right options
+      medias = @pipeline.input.inputs.map do |input|
+        #puts sout
+        @api.create_media(input) << sout
+      end
+      medias.each { |media| list << media }
+      list_player = @api.create_list_player list, player
+
+      # Set callbacks to 'know' when the processing is over
+      stop_events = [
+        :MediaPlayerPaused,
+        :MediaPlayerStopped,
+        :MediaPlayerEndReached,
+        :MediaPlayerEncounteredError
+      ]
+      events.on(stop_events) { stop_runner! }
+
+      # Let's rock and roll
+      list_player.play
+
+      # Busy Wait loop hack to synchronize with libvlc which doesn't have
+      # any synchronous interface (due to it's profound asynchronous nature)
+      @running = true
+      while @running
+        sleep 0.5
+      end
+    end
+
+  end
+end

data/lib/activevlc/stage/input.rb

@@ -22,6 +22,7 @@ module ActiveVlc::Stage
 
       @inputs = [array_or_string] if array_or_string.is_a? String
       @inputs ||= array_or_string
+      @inputs ||= []
     end
 
     def <<(new_inputs)

data/lib/activevlc/syntactic_sugar.rb

@@ -0,0 +1,11 @@
+module ActiveVlc
+  def self.pipe(inputs = nil, &block)
+    ActiveVlc::Pipeline.new(inputs, &block)
+  end
+  def self.pipe_for(inputs = nil, &block)
+    self.pipe(inputs, &block)
+  end
+  def self.parse(path)
+    ActiveVlc::Pipeline.parse(path)
+  end
+end

data/lib/activevlc/version.rb

@@ -1,3 +1,3 @@
 module ActiveVlc
-  VERSION = "0.0.1"
+  VERSION = "0.0.3"
 end

data/lib/activevlc.rb

@@ -1,7 +1,10 @@
+module ActiveVlc
+end
+
 require 'active_support'
 require 'activevlc/version'
 require 'activevlc/pipeline'
 require 'activevlc/dsl'
-
-module ActiveVlc
-end
+require 'activevlc/libvlc'
+require 'activevlc/runner'
+require 'activevlc/syntactic_sugar'

data/spec/event_manager_spec.rb

@@ -0,0 +1,81 @@
+require "spec_helper"
+
+describe ActiveVlc::LibVlc::EventManager do
+  let(:vlc)    { ActiveVlc::LibVlc::Instance.new [' ', '--play-and-exit'] }
+  let(:media)  { vlc.create_media 'file:///tmp/test.mp4' }
+  let(:media2) { vlc.create_media '/tmp/test2.mp4' }
+  let(:player) { vlc.create_player }
+  let(:list) do
+    l = vlc.create_media_list
+    l << media
+    l << media2
+    l
+  end
+  let(:list_player) do
+    lp = vlc.create_list_player
+    lp.media_list = list
+    lp
+  end
+  let(:player_event)      { player.event_manager }
+  let(:list_player_event) { list_player.event_manager }
+
+  it 'can be created' do
+    media.event_manager.should be_a_kind_of(ActiveVlc::LibVlc::EventManager)
+    list.event_manager.should be_a_kind_of(ActiveVlc::LibVlc::EventManager)
+    player.event_manager.should be_a_kind_of(ActiveVlc::LibVlc::EventManager)
+    list_player.event_manager.should be_a_kind_of(ActiveVlc::LibVlc::EventManager)
+  end
+
+  it 'registers and stores callbacks' do
+    event1 = ActiveVlc::LibVlc::Api::EventType[:MediaListPlayerStopped]
+    event2 = ActiveVlc::LibVlc::EventManager::EventType[:MediaListPlayerPlayed]
+    list_player_event.callbacks.keys.length.should eq(0)
+    list_player_event.on(event1) {}
+    list_player_event.on(event2) {}
+    list_player_event.on(:MediaListPlayerNextItemSet) {}
+    # For some reason the 'Played' event is invalid :-/ and the Stopped event
+    # is only triggered on very recent versions  ...
+    list_player_event.callbacks.keys.length.should be >= 1
+    list_player.play
+  end
+
+  it 'MediaPlayer\'s EventManger receives events' do
+    first_event = ActiveVlc::LibVlc::Api::EventType[:MediaPlayerMediaChanged]
+    last_event = ActiveVlc::LibVlc::Api::EventType[:MediaPlayerVout]
+    (first_event..last_event).to_a.each { |e| player_event.on(e) {} }
+    player.media = media
+    player_event.events_received.should eq(1)
+    player.play
+    sleep 0.25 # Avoid random deadlock in vlc :-/ and gives some time for vlc to run
+    player.stop
+    player_event.events_received.should eq(5)
+  end
+
+  it 'MediaListPlayer\'s EventManger receives events' do
+    list_player_event.on(:MediaListPlayerNextItemSet) {}
+    list_player_event.on(:MediaListPlayerStopped) {}
+    list_player.play
+    list_player.stop
+    list_player_event.events_received.should be >= 1
+  end
+
+  it 'calls registered callback' do
+    @cbk1_called = false
+    list_player_event.on(:MediaListPlayerNextItemSet) { @cbk1_called = true }
+    list_player.play
+    list_player.stop
+    @cbk1_called.should be_true
+  end
+
+  it 'MediaPlayer receives event when assigned as MediaListPlayer\' player' do
+    first_event = ActiveVlc::LibVlc::Api::EventType[:MediaPlayerMediaChanged]
+    last_event = ActiveVlc::LibVlc::Api::EventType[:MediaPlayerVout]
+    (first_event..last_event).to_a.each { |e| player_event.on(e) {} }
+    list_player.media_player = player
+    list_player.play
+    sleep 0.25
+    list_player.stop
+    player_event.events_received.should eq(5)
+  end
+
+end

data/spec/libvlc_spec.rb

@@ -0,0 +1,93 @@
+
+require 'spec_helper'
+
+describe ActiveVlc::LibVlc do
+  describe "Low-level binding" do
+    it 'binds C functions' do
+      [ :new, :release, :retain, :add_intf, :wait, :set_user_agent,
+        :get_version, :get_compiler, :free, :set_exit_handler ].each do |sym|
+          ActiveVlc::LibVlc::Api.respond_to?("libvlc_#{sym}")
+            .should be_true
+        end
+    end
+
+    it 'create a libvlc instance' do
+      vlc = ActiveVlc::LibVlc::Api.libvlc_new(0, nil)
+      vlc.null?.should be_false
+    end
+
+    it 'reports libvlc version' do
+      ActiveVlc::LibVlc::Api.libvlc_get_version.should match(/\d\.\d+\.\d+/)
+      ActiveVlc::LibVlc.version.should match(/\d\.\d+\.\d+/)
+      ActiveVlc::LibVlc.compiler.should match(/\d\.\d+\.\d+/)
+    end
+  end
+
+  describe 'Ruby wrapper: Instance/MediaXXX/EventManger creation' do
+    let(:vlc)    { ActiveVlc::LibVlc::Instance.new [' ', '--play-and-exit'] }
+    let(:media)  { vlc.create_media 'file:///tmp/test.mp4' }
+    let(:media2) { vlc.create_media '/tmp/test2.mp4' }
+    let(:list)   { vlc.create_media_list }
+    let(:list_player) { vlc.create_list_player }
+
+    it 'can creates an instance' do
+      vlc.should be_a_kind_of(ActiveVlc::LibVlc::Instance)
+      vlc.ptr.null?.should be_false
+    end
+
+    it 'can creates a Media from an Instance using an MRL' do
+      media.should be_a_kind_of(ActiveVlc::LibVlc::Media)
+      media.ptr.null?.should be_false
+    end
+
+    it 'can creates a Media from an Instance using a path' do
+      media_from_path = vlc.create_media('/tmp/pwet')
+      media_from_path.should be_a_kind_of(ActiveVlc::LibVlc::Media)
+      media_from_path.ptr.null?.should be_false
+    end
+
+    it 'can set an option on a Media' do
+      media << ":sout='#display'"
+      expect { media << 42 }.to raise_error
+    end
+
+    it 'can creates a MediaList from an Instance' do
+      list.should be_a_kind_of(ActiveVlc::LibVlc::MediaList)
+      list.ptr.null?.should be_false
+    end
+
+    it 'allows setting media of a media list' do
+      list << media2
+      list.media = media
+      list.length.should eq(1)
+    end
+
+    it 'allows adding media to a MediaList' do
+      list << media
+      list << media2
+      list.length.should eq(2)
+    end
+
+    it 'allows the creation of a MediaListPlayer' do
+      list_player.should be_a_kind_of(ActiveVlc::LibVlc::MediaListPlayer)
+      list_player.ptr.null?.should be_false
+      list << media
+      list_player.media_list = list
+      expect {list_player.media_list = nil}.to raise_error
+    end
+
+    it 'allows creation of a MediaPlayer with an Instance' do
+      player = vlc.create_player
+      player.should be_a_kind_of(ActiveVlc::LibVlc::MediaPlayer)
+      player.ptr.null?.should be_false
+    end
+
+    it 'allows creation of a MediaPlayer with a Media' do
+      player = vlc.create_player media
+      player.should be_a_kind_of(ActiveVlc::LibVlc::MediaPlayer)
+      player.ptr.null?.should be_false
+      player.media.should be_a_kind_of(ActiveVlc::LibVlc::Media)
+      player.media.should be(media)
+    end
+  end
+end

data/spec/pipeline_spec.rb

@@ -71,7 +71,7 @@ describe ActiveVlc::Pipeline do
 
   describe '\'duplicate_then_transcode\' pipeline' do
     it 'is loaded' do
-      ActiveVlc::Pipeline.parse('spec/pipes/duplicate_then_transcode.rb').class
+      ActiveVlc::Pipeline::parse('spec/pipes/duplicate_then_transcode.rb').class
         .should be(ActiveVlc::Pipeline)
     end
 
@@ -81,4 +81,23 @@ describe ActiveVlc::Pipeline do
     end
   end
 
+  describe '\'no_input\' pipeline' do
+    it "is loaded" do
+      ActiveVlc::parse('spec/pipes/no_input.rb').class
+        .should be(ActiveVlc::Pipeline)
+    end
+
+    it 'produce the correct fragment' do
+      expect(ActiveVlc::parse('spec/pipes/no_input.rb').fragment)
+        .to eq(" :sout=\"#transcode{acodec=vorbis}:standard{mux=ogg, dst='output.ogg'}\"")
+    end
+
+    it 'can be assigned inputs' do
+      pipe = ActiveVlc::parse('spec/pipes/no_input.rb')
+      pipe.input << "input.mp4"
+      pipe.input << "input2.mp4"
+      pipe.fragment.should eq("input.mp4 input2.mp4 :sout=\"#transcode{acodec=vorbis}:standard{mux=ogg, dst='output.ogg'}\"")
+    end
+  end
+
 end

data/spec/pipes/no_input.rb

@@ -0,0 +1,20 @@
+##
+## no_input.rb
+## Login : <lta@still>
+## Started on  Wed Jun 12 14:45:36 2013 Lta Akr
+## $Id$
+##
+## Author(s):
+##  - Lta Akr <>
+##
+## Copyright (C) 2013 Lta Akr
+
+ActiveVlc::pipe do
+  transcode do
+    audio :vorbis
+  end
+  to(:file) do
+    mux :ogg
+    dst 'output.ogg'
+  end
+end