activevlc 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2cfe489b2cfbfad5e9f2e34f8047568c0d0d2308
-  data.tar.gz: bcb80b8ed6a3cd149d0a2d394885ee46ba780ca8
+  metadata.gz: e7277724b68e5a47757cd221b47c6522bc74cf0c
+  data.tar.gz: 19a56e502c9d73feb2c0fdeb114dcaf98162d665
 SHA512:
-  metadata.gz: f7c078deb42fcad7eec5913ea57f994552e123e1293911b2e2c48eb52367e896d62b81e88371878d06a20604b362d073907312650ef45dd2d8f4f2227be11477
-  data.tar.gz: 01ac07764a7d0b86bebc5b816f0a2f900391909214e93f74d08f14ee443286b1065d3ee7e0b43ba2c0d31ef3958eea704af5bacacbea99151336ffe116bb36fb
+  metadata.gz: eaf8db920f751616a47ba9a46bcc252684d04120cf82703071ce66f6bf46fa9896165f26c383fa66866b453c3a27a6f0aa139ee8a542a4238dfa4084c5887014
+  data.tar.gz: 01bf1845e930f5ad7ee4cf4e0a929a869b986e1fb3ddc94f8c33547d4dff0d6ea782906ce1f84e958151cd479de2d88360e62de7ee5e5e8b2b49071dc7da2f22

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - jruby-19mode # JRuby in 1.9 mode
+before_install: 'sudo apt-get update && sudo apt-get install -y vlc-nox'

data/README.md

@@ -1,25 +1,54 @@
 # ActiveVlc
 
-Do you know VLC, the famous media player ? I'm pretty sure you do ! 
+[![Gem Version](https://badge.fury.io/rb/activevlc.png)](http://badge.fury.io/rb/activevlc)
+[![Code Climate](https://codeclimate.com/github/elthariel/activevlc.png)](https://codeclimate.com/github/elthariel/activevlc)
+[![Build Status](https://travis-ci.org/elthariel/activevlc.png?branch=master)](https://travis-ci.org/elthariel/activevlc)
+
+Do you know VLC, the famous media player ? I'm pretty sure you do !
 Do you know this is also a pretty powerfull media processing and streaming framework ? Maybe...
-Do you understand something about the command line syntax to access vlc's underlying 
+Do you understand something about the command line syntax to access vlc's underlying
 powers ? If you don't this tool is for you !
 
-ActiveVlc provides a simple syntax to configure and run transcoding/streaming/processing 
+ActiveVlc provides a simple syntax to configure and run transcoding/streaming/processing
 operations using VLC. Here's a simple example :
 
+## Installation
+
+First and foremost, you must have VLC and libvlc installed on your system and
+the vlc binary must be in your PATH since we doesn't provide yet a cool
+configuration system for this (contribution welcomed !)
+
+Add this line to your application's Gemfile:
+
+    gem 'activevlc'
+
+And then execute:
+
+    $ bundle
+
+Or use the master branch on GitHub to test de development version by replacing
+the line in your Gemfile by this one:
+
+    gem 'activevlc', github: 'elthariel/activevlc'
+
+Or install it yourself as:
+
+    $ gem install activevlc
+
 ## Example
 
-Let's say you want to read an mp4 file, transcode it using different options, save the result to 
+### Command line
+
+Let's say you want to read an mp4 file, transcode it using different options, save the result to
 another file while displaying it to control what's happening. Using the standard vlc's chain syntax
 you'd have to write
 
     vlc input.mp4 :sout="#transcode{deinterlace, acodec=aac, ab=128, channels=2, vcodec=h264, venc=x264{bpyramid=strict, bframes=4, no-cabac}, vb=512}:duplicate{dst=standard{mux=mp4, dst='output.mp4'}, dst=display}"
-    
+
 Not very readable isn't it ? Let's try the same with ActiveVlc :
 
 ```ruby
-AtiveVlc::Pipeline.for 'input.mp4' do
+AtiveVlc::pipe do
   transcode do
     deinterlace
     audio :aac do
@@ -45,45 +74,71 @@ AtiveVlc::Pipeline.for 'input.mp4' do
 end
 ```
 
-This sintax might be a lot more verbose than the original vlc's one, 
+This sintax might be a lot more verbose than the original vlc's one,
 it is still A LOT more readable and understandable, and since this is plain ruby
 you can add comment and arbitrary code !
 Then you can run it using :
 
-    activevlc exec /path/to/the/pipeline.rb
-    
-## Development status
+    activevlc exec /path/to/the/pipeline.rb input.mp4
 
-This gem is not yet published yet and is still under active 
-development althought it might already be usable for many usages
+### From Ruby code
 
-## Installation
+You can also use ActiveVlc programmatically from your ruby code :
 
-First and foremost, you must have VLC installed on your system and the
-vlc binary must be in your PATH since we doesn't provide yet a cool 
-configuration system for this (contribution welcomed !)
+```ruby
+def my_encoding_method(input, output)
+  # Create the pipeline.
+  pipe = ActiveVlc::pipe input do
+    transcode do
+      # Same syntax as above, also see spec/pipes
+    end
+    to :file, output
+  end
 
-Add this line to your application's Gemfile:
+  # Run it synchronously
+  ActiveVlc::Runner.new(pipe).run
+  # Your transcoding operation is over (except if there were strong errors)
+end
+```
 
-    gem 'activevlc'
+## Development status
 
-And then execute:
+This gem is still under active development
+althought it might already be usable for many usages.
 
-    $ bundle
+If you have any trouble, idea or question, please use GitHub issue
+system. If you have an idea with code attached to it, got to the
+'Contributing' section below.
 
-Or install it yourself as:
+## Supported system/rubies
 
-    $ gem install activevlc
+Ruby 1.8 is _NOT_ supported.
+
+This gem is developped using MRI 2.0.0 on Debian 7 / Ubuntu 13.04 but it should work OOB on MRI 1.9 and other GNU/Linux systems.
+
+Altough there might me some threading issues between the interpreter and libvlc, the specs are eported to pass against :
+* Jruby (1.7)
+* Rubinius (head) (with some minor problems)
+
+I doesn't have access to any OSX boxes so but it should work as well, please let me know if you encounter any issue.
 
 ## Usage
 
-Currently, the best documentation is to have a look to the spec (/spec/pipes) 
+Currently, the best documentation is to have a look to the spec (/spec/pipes)
 or to run the CLI tool to get the embedded help.
 
+## Known Issues
+
+* We use a pretty ugly hack to be able to run pipelines synchronously
+* You cannot (yet) configure output(s) from the command line, only with ruby
+* There's currently almost no error reporting except from the one vlc's outputting on STDOUT. Vlc's logging and error reporting is pretty complex, i still need to take some time to figure it out.
+
 ## Contributing
 
 1. Fork it
 2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+3. Write some specs for your feature
+4. Implements your feature and make your test pass
+5. Commit your changes (`git commit -am 'Add some feature'`)
+6. Push to the branch (`git push origin my-new-feature`)
+7. Create new Pull Request

data/Rakefile

@@ -1 +1,6 @@
 require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/TODO.md

@@ -6,7 +6,6 @@ TODO file for ActiveVlc
   - Preset support (this is also a cool way of documenting vlc's features
   - vlc team suggestions (jb/etix)
     - Some syntactic sugar for http-live will be helpfull, pay attention to this shitty module
-    - duplicate -> transcode, transcode -> duplicate
   - Long-term ideas
     - carrierwave integration
 

data/activevlc.gemspec

@@ -19,11 +19,12 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rspec", "~> 2.6"
+  spec.add_development_dependency "rspec", "~> 2.14"
   spec.add_development_dependency "simplecov"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "debugger"
+  #spec.add_development_dependency "debugger"
 
   spec.add_dependency 'thor'
   spec.add_dependency 'activesupport'
+  spec.add_dependency 'ffi'
 end

data/examples/basic.rb

@@ -0,0 +1,14 @@
+##
+## basic.rb
+## Login : <lta@still>
+## Started on  Wed Jun 12 14:41:04 2013 Lta Akr
+## $Id$
+##
+## Author(s):
+##  - Lta Akr <>
+##
+## Copyright (C) 2013 Lta Akr
+
+# Basic pipe for rspec testing
+
+ActiveVlc::Pipeline.for 'input.mp4'

data/examples/duplicate.rb

@@ -0,0 +1,18 @@
+##
+## duplicate.rb
+## Login : <lta@still>
+## Started on  Wed Sep  4 17:29:45 2013 Lta Akr
+## $Id$
+##
+## Author(s):
+##  - Lta Akr <>
+##
+## Copyright (C) 2013 Lta Akr
+
+# input.mp3 :sout="#duplicate{dst=display, dst=std{dst='output.mp3'}}"
+ActiveVlc::Pipeline.for 'input.mp3' do
+  duplicate do
+    to :display
+    to file: 'output.mp3'
+  end
+end

data/examples/duplicate_then_transcode.rb

@@ -0,0 +1,29 @@
+##
+## duplicate_then_transcode.rb
+## Login : <lta@still>
+## Started on  Tue Sep 10 18:30:41 2013 Lta Akr
+## $Id$
+##
+## Author(s):
+##  - Lta Akr <>
+##
+## Copyright (C) 2013 Lta Akr
+
+ActiveVlc::Pipeline.for 'input.mp4' do
+  duplicate do
+    to :chain do
+      #debugger
+      transcode do
+        audio :aac
+        video :h264
+        subtitle :svcd
+      end
+      to :file do
+        mux :mp4
+        dst 'output.mp4'
+      end
+    end
+    to :display
+  end
+end
+

data/examples/transcode_and_display.rb

@@ -0,0 +1,25 @@
+##
+## transcode_and_display.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_for 'input.mp4' do
+  transcode do
+    audio :aac
+    video :h264
+    subtitle :svcd
+  end
+  duplicate do
+    to :file do
+      mux :mp4
+      dst 'output.mp4'
+    end
+    to :display
+  end
+end

data/examples/transcode_and_display_with_options.rb

@@ -0,0 +1,36 @@
+##
+## transcode_and_display.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::Pipeline.for 'input.mp4' do
+  gather
+  transcode do
+    deinterlace
+    audio :aac do
+      bitrate 128 # 128 kpbs
+      channels 2
+    end
+    video :h264 do
+      encoder :x264 do
+        bpyramid :strict
+        bframes 4
+        cabac false
+      end
+      bitrate 512 # 512 kbps
+    end
+  end
+  duplicate do
+    to :file do
+      mux :mp4
+      dst 'output.mp4'
+    end
+    to :display
+  end
+end

data/lib/activevlc/cli.rb

@@ -29,10 +29,10 @@ module ActiveVlc
       puts "ActiveVlc version #{ActiveVlc::VERSION}"
     end
 
-    desc 'vlc SUBCOMMAND ...ARGS', 'vlc specific commands'
+    desc 'vlc ', 'VLC specific commands. See activevlc help vlc for details'
     subcommand 'vlc', ActiveVlc::CLI::Vlc
 
-    desc 'fragment PIPE_PATH', 'Outputs vlc :sout=chain fragment for the pipe defined in \'PIPE_PATH\' file'
+    desc 'fragment path', 'Outputs vlc \':sout=...\' string for the pipeline defined in the \'path\' file'
     def fragment(path)
       if File.readable?(path)
         pipe = eval(File.read(path))
@@ -43,11 +43,12 @@ module ActiveVlc
       end
     end
 
-    desc 'exec PIPE_PATH', 'Run the PIPE_PATH pipe file in VLC'
-    def exec(path)
+    desc 'exec path [input_file_1 [input_file_2] [...]]', 'Launch vlc executable to run the pipeline described in path file'
+    def exec(path, *inputs)
       if File.readable?(path)
         begin
-          pipe = eval(File.read(path))
+          pipe = ActiveVlc::parse(path)
+          pipe.inputs << inputs
           fragment = pipe.fragment
         rescue
           puts "Error while parsing pipe file"
@@ -60,7 +61,25 @@ module ActiveVlc
         exit $?.exitstatus
     end
 
-    desc 'dump PIPE_PATH', 'Dump the internal representation of the pipeline defined in the file PIPE_PATH'
+    desc 'run path [input_file_1 [input_file_2] [...]]', 'Run the path pipeline using LibVlc (usually better than exec)'
+    def run(path, *inputs)
+      if File.readable?(path)
+        begin
+          pipe = ActiveVlc::parse(path)
+          pipe.inputs << inputs
+          fragment = pipe.fragment
+        rescue
+          puts "Error while parsing pipe file"
+          exit 43
+        end
+        ActiveVlc::Runner.new(pipe).run
+      else
+        puts "Error: file [#{path}] doesn't exist or reading permission denied."
+      end
+      exit 0
+    end
+
+    desc 'dump path', 'Dump the internal representation of the pipeline defined in the file path'
     def dump(path)
       if File.readable?(path)
         puts eval(File.read(path)).dump

data/lib/activevlc/libvlc/api.rb

@@ -0,0 +1,196 @@
+##
+## api.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
+
+module ActiveVlc::LibVlc
+  def self.version
+    Api.libvlc_get_version
+  end
+  def self.compiler
+    Api.libvlc_get_compiler
+  end
+
+  module Api
+    extend FFI::Library
+    ffi_lib ActiveVlc::LibVlc::VLC_SO_NAMES
+
+    #
+    # Core functions
+    #
+    callback :exit_handler, [:pointer], :void
+
+    core_functions = {
+     new:               [[:int, :pointer], :pointer],
+     release:           [[:pointer], :void],
+     retain:            [[:pointer], :void],
+     add_intf:          [[:pointer, :string], :int],
+     set_exit_handler:  [[:pointer, :exit_handler, :pointer], :void],
+     wait:              [[:pointer], :void],
+     set_user_agent:    [[:pointer, :string, :string], :void],
+     get_version:       [[], :string],
+     get_compiler:      [[], :string],
+     free:              [[:pointer], :void]
+    }
+
+    #
+    # Media functions
+    #
+    media_functions = {
+      media_new_location:     [[:pointer, :string], :pointer],
+      media_new_path:         [[:pointer, :string], :pointer],
+      media_add_option:       [[:pointer, :string], :void],
+      media_add_option_flag:  [[:pointer, :string, :int], :void],
+      media_duplicate:        [[:pointer], :pointer],
+      media_event_manager:    [[:pointer], :pointer],
+      media_retain:           [[:pointer], :void],
+      media_release:          [[:pointer], :void],
+      media_get_mrl:          [[:pointer], :string]
+    }
+
+    #
+    # Media List functions
+    #
+    media_list_functions = {
+      media_list_new:             [[:pointer], :pointer],
+      media_list_retain:          [[:pointer], :void],
+      media_list_release:         [[:pointer], :void],
+      media_list_lock:            [[:pointer], :void],
+      media_list_unlock:          [[:pointer], :void],
+      media_list_event_manager:   [[:pointer], :pointer],
+      media_list_set_media:       [[:pointer, :pointer], :void],
+      media_list_add_media:       [[:pointer, :pointer], :int],
+      media_list_insert_media:    [[:pointer, :pointer, :int], :int],
+      media_list_count:           [[:pointer], :int]
+    }
+
+
+    #
+    # Media Player functions and type
+    #
+    PlayerState = enum(:NothingSpecial,
+                       :Opening,
+                       :Buffering,
+                       :Playing,
+                       :Paused,
+                       :Stopped,
+                       :Ended,
+                       :Error)
+
+    media_player_functions = {
+      media_player_new:             [[:pointer], :pointer],
+      media_player_new_from_media:  [[:pointer], :pointer],
+      media_player_retain:          [[:pointer], :void],
+      media_player_release:         [[:pointer], :void],
+      media_player_set_media:       [[:pointer, :pointer], :void],
+      media_player_get_media:       [[:pointer], :pointer],
+      media_player_event_manager:   [[:pointer], :pointer],
+      media_player_is_playing:      [[:pointer], :int],
+      media_player_play:            [[:pointer], :int],
+      media_player_pause:           [[:pointer], :void],
+      media_player_stop:            [[:pointer], :void],
+      media_player_get_state:       [[:pointer], PlayerState]
+    }
+
+    #
+    # Media List Player functions
+    #
+    media_list_player_functions = {
+      media_list_player_new:                [[:pointer], :pointer],
+      media_list_player_retain:             [[:pointer], :void],
+      media_list_player_release:            [[:pointer], :void],
+      media_list_player_event_manager:      [[:pointer], :pointer],
+      media_list_player_set_media_list:     [[:pointer, :pointer], :void],
+      media_list_player_set_media_player:   [[:pointer, :pointer], :void],
+      media_list_player_play:               [[:pointer], :void],
+      media_list_player_pause:              [[:pointer], :void],
+      media_list_player_stop:               [[:pointer], :void],
+      media_list_player_next:               [[:pointer], :void],
+      media_list_player_previous:           [[:pointer], :void],
+      media_list_player_is_playing:         [[:pointer], :int]
+    }
+
+    #
+    # Event manager functions and types
+    #
+    callback :event_handler, [:pointer, :pointer], :void
+
+    EventType = enum(
+      :MediaMetaChanged,          0,
+      :MediaSubItemAdded,
+      :MediaDurationChanged,
+      :MediaParsedChanged,
+      :MediaFreed,
+      :MediaStateChanged,
+
+      :MediaPlayerMediaChanged,   0x100,
+      :MediaPlayerNothingSpecial,
+      :MediaPlayerOpening,
+      :MediaPlayerBuffering,
+      :MediaPlayerPlaying,
+      :MediaPlayerPaused,
+      :MediaPlayerStopped,
+      :MediaPlayerForward,
+      :MediaPlayerBackward,
+      :MediaPlayerEndReached,
+      :MediaPlayerEncounteredError,
+      :MediaPlayerTimeChanged,
+      :MediaPlayerPositionChanged,
+      :MediaPlayerSeekableChanged,
+      :MediaPlayerPausableChanged,
+      :MediaPlayerTitleChanged,
+      :MediaPlayerSnapshotTaken,
+      :MediaPlayerLengthChanged,
+      :MediaPlayerVout,
+
+      :MediaListItemAdded,        0x200,
+      :MediaListWillAddItem,
+      :MediaListItemDeleted,
+      :MediaListWillDeleteItem,
+
+      :MediaListViewItemAdded,    0x300,
+      :MediaListViewWillAddItem,
+      :MediaListViewItemDeleted,
+      :MediaListViewWillDeleteItem,
+
+      :MediaListPlayerPlayed,     0x400,
+      :MediaListPlayerNextItemSet,
+      :MediaListPlayerStopped,
+
+      :MediaDiscovererStarted,    0x500,
+      :MediaDiscovererEnded,
+
+      :VlmMediaAdded,             0x600,
+      :VlmMediaRemoved,
+      :VlmMediaChanged,
+      :VlmMediaInstanceStarted,
+      :VlmMediaInstanceStopped,
+      :VlmMediaInstanceStatusInit,
+      :VlmMediaInstanceStatusOpening,
+      :VlmMediaInstanceStatusPlaying,
+      :VlmMediaInstanceStatusPause,
+      :VlmMediaInstanceStatusEnd,
+      :VlmMediaInstanceStatusError
+      )
+
+    event_manager_functions = {
+      event_attach:     [[:pointer, EventType, :event_handler, :pointer], :int],
+      event_detach:     [[:pointer, EventType, :event_handler, :pointer], :void],
+      event_type_name:  [[:int], :string]
+    }
+
+    # Here we use all these data and actually attache the functions.
+    [ core_functions, media_functions, media_list_functions, media_player_functions,
+      media_list_player_functions, event_manager_functions].each do |functions|
+      functions.each do |symbol, args|
+        attach_function "libvlc_#{symbol}".to_sym, args[0], args[1]
+      end
+    end
+  end
+end

data/lib/activevlc/libvlc/event_manager.rb

@@ -0,0 +1,53 @@
+module ActiveVlc::LibVlc
+  class Event < FFI::Struct
+    layout :type, :int,
+           :object, :pointer
+  end
+
+  class EventManager
+    EventType = Api::EventType
+
+    attr_reader :callbacks, :events_received
+
+    def initialize(ptr)
+      @ptr = ptr
+      @callbacks = {}
+      @events_received = 0
+
+      @event_handler = Proc.new { |event, void| _event(event, void) }
+    end
+
+    def on(types, &block)
+      event_is_valid = true
+      types = [types] unless types.is_a? Array
+      # Get the enum value if we gat a Symbol or String
+
+      types.each do |type|
+        if type.is_a?(String) or type.is_a?(Symbol)
+          type = EventType[type.to_sym]
+        end
+
+        # If this is the first callback for this type, register the :event_handler
+        # using vlc's API and create the proc array for that 'type'.
+        unless @callbacks[type]
+          event_is_valid = Api.libvlc_event_attach(@ptr, type, @event_handler, nil) == 0
+          @callbacks[type] = Array.new if event_is_valid
+        end
+        @callbacks[type].push block if event_is_valid
+      end
+    end
+
+    protected
+    def _event(event, void)
+      event = Event.new(event)
+      type = EventType[event[:type]]
+
+      @events_received += 1;
+
+      puts "Received event (#{@events_received}): #{EventType[event[:type]]}"
+
+      return unless @callbacks[event[:type]].is_a? Array
+      @callbacks[event[:type]].each { |proc| proc.call(type) }
+    end
+  end
+end