gstreamer 1.2.6 → 2.0.0

data/sample/gst-gi.rb

@@ -1,55 +0,0 @@
-# Copyright (C) 2013  Ruby-GNOME2 Project Team
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License, or (at your option) any later version.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-
-require "gobject-introspection"
-
-base_dir = Pathname.new(__FILE__).dirname.dirname.dirname.expand_path
-vendor_dir = base_dir + "vendor" + "local"
-vendor_bin_dir = vendor_dir + "bin"
-GLib.prepend_environment_path(vendor_bin_dir)
-
-module Gst
-  LOG_DOMAIN = "GStreamer"
-  GLib::Log.set_log_domain(LOG_DOMAIN)
-
-  class << self
-    @initialized = false
-    def init(argv=ARGV)
-      return if @initialized
-      @initialized = true
-      loader = Loader.new(self, argv)
-      loader.load("Gst")
-    end
-  end
-
-  class Loader < GObjectIntrospection::Loader
-    def initialize(base_module, init_arguments)
-      super(base_module)
-      @init_arguments = init_arguments
-    end
-
-    private
-    def pre_load(repository, namespace)
-      init = repository.find(namespace, "init")
-      argc, argv = init.invoke(1 + @init_arguments.size,
-                               [$0] + @init_arguments)
-      @init_arguments.replace(argv)
-    end
-
-    def post_load(repository, namespace)
-    end
-  end
-end

data/sample/gst-inspect.rb

@@ -1,417 +0,0 @@
-#!/usr/bin/evn ruby
-
-require 'optparse'
-require 'ostruct'
-
-argv = ARGV.dup
-ARGV.clear
-
-require 'gst'
-
-def parse(argv)
-  options = OpenStruct.new
-  options.print_all = false
-  options.print_auto_install_info = false
-
-  opts = OptionParser.new do |opts|
-    opts.banner += " [ELEMENT-NAME|PLUGIN-NAME]"
-
-    opts.version = Gst.version
-
-    opts.separator("")
-    opts.on("-a", "--print-all", "Print all elements") do
-      options.print_all = true
-    end
-
-    opts.on("--print-plugin-auto-install-info",
-            "Print a machine-parsable list of features",
-            "the specified plugin provides.",
-            "Useful in connection with external",
-            "automatic plugin installation mechanisms") do
-      options.print_auto_install_info = true
-    end
-  end
-  opts.parse!(argv)
-
-  [options, argv.first]
-end
-
-class Inspector
-  def initialize
-    @prefix = ""
-  end
-
-  def print_list(print_all)
-    plugins = {}
-    n_features = 0
-    each_feature do |plugin, feature|
-      plugins[plugin.name] = nil
-      n_features += 1
-      if print_all
-        if feature.is_a?(Gst::ElementFactory)
-          print_element_factory(feature, true)
-        end
-      else
-        print_feature(plugin, feature)
-      end
-    end
-    puts
-    puts("Total count: #{plugins.size} plugins, #{n_features} features")
-  end
-
-  def print_element(name)
-    factory = Gst::ElementFactory.find(name)
-    print_element_factory(factory, false)
-  end
-
-  private
-  def puts(*args)
-    if args.empty?
-      super(@prefix)
-    else
-      super(*(args.collect {|arg| "#{@prefix}#{arg}"}))
-    end
-  end
-
-  def prefix(new_prefix)
-    prefix, @prefix = @prefix, new_prefix
-    yield
-  ensure
-    @prefix = prefix
-  end
-
-  def each_feature
-    registry = Gst::Registry.default
-    registry.plugins.sort_by {|plugin| plugin.name}.each do |plugin|
-      features = registry.get_features(plugin.name)
-      features.sort_by {|feature| feature.name}.each do |feature|
-        yield(plugin, feature)
-      end
-    end
-  end
-
-  def print_factory_details_info(factory)
-    rank_name = factory.rank.name
-    rank_name ||= "unknown"
-    rank_name = rank_name.gsub(/GST_RANK_/, '').downcase
-
-    puts("Factory Details:",
-         "  Long name:\t#{factory.long_name}",
-         "  Class:\t#{factory.klass}",
-         "  Description:\t#{factory.description}",
-         "  Author(s):\t#{factory.author}",
-         "  Rank:\t\t#{rank_name} (#{factory.rank.to_i})",
-         "")
-  end
-
-  def print_plugin_info(name)
-    return if name.nil?
-    registry = Gst::Registry.default
-    plugin = registry.find_plugin(name)
-    return if plugin.nil?
-
-    puts("Plugin Details:",
-         "  Name:\t\t\t#{plugin.name}",
-         "  Description:\t\t#{plugin.description}",
-         "  Filename:\t\t#{plugin.filename || '(null)'}",
-         "  Version:\t\t#{plugin.version}",
-         "  License:\t\t#{plugin.license}",
-         "  Source module:\t#{plugin.source}",
-         "  Binary package:\t#{plugin.package}",
-         "  Origin URL:\t\t#{plugin.origin}",
-         "")
-  end
-
-  def print_hierarchy(element)
-    ancestors = []
-    type = element.gtype
-    while type
-      ancestors << type
-      type = type.parent
-    end
-    ancestors.reverse.each_with_index do |klass, i|
-      if i.zero?
-        mark = ""
-      else
-        mark = " " + ("      " * (i - 1)) + "+----"
-      end
-      puts("#{mark}#{klass.name}")
-    end
-    puts
-  end
-
-  def print_interfaces(element)
-    interfaces = element.gtype.interfaces
-    return if interfaces.empty?
-
-    puts("Implemented Interfaces:")
-    interfaces.each do |interface|
-      puts("  #{interface.name}")
-    end
-    puts
-  end
-
-  def print_caps(caps)
-    if caps.any?
-      puts("ANY")
-      return
-    end
-    if caps.empty?
-      puts("EMPTY")
-      return
-    end
-
-    caps.each do |structure|
-      puts(structure.name)
-      structure.each do |key, value|
-        puts("  %15s: %s" % [key, value.inspect])
-      end
-    end
-  end
-
-  def print_pad_template_info(template)
-    prefix("#{@prefix}  ") do
-      puts("#{template.direction.nick.upcase} template: '#{template.name}'")
-      prefix("#{@prefix}  ") do
-        if template.presence == Gst::Pad::REQUEST
-          puts("Availability: On request")
-        else
-          puts("Availability: #{template.presence.nick.capitalize}")
-        end
-      end
-    end
-
-    static_caps = template.caps
-    return if static_caps.description.nil?
-    prefix("#{@prefix}    ") do
-      puts("Capabilities:")
-      prefix("#{@prefix}  ") do
-        print_caps(static_caps.to_caps)
-      end
-    end
-    puts
-  end
-
-  def print_pad_templates_info(element, factory)
-    puts("Pad Templates:")
-    templates = factory.pad_templates
-
-    if templates.empty?
-      puts("  none")
-      return
-    end
-
-    templates.each do |template|
-      print_pad_template_info(template)
-    end
-  end
-
-  def print_element_flag_info(element)
-    puts("Element Flags")
-    puts("  no flags set")
-    puts
-
-    return unless element.is_a?(Gst::Bin)
-    puts("Bin Flags:")
-    puts("  no flags set")
-    puts
-  end
-
-  def print_implementation_info(element)
-    puts("Element Implementation:")
-    puts("  not supported")
-    puts
-  end
-
-  def print_clocking_info(element)
-    if !element.require_clock? and
-        !element.provide_clock? and
-        element.clock.nil?
-      puts("Element has no clocking capabilities.")
-      puts
-      return
-    end
-
-    puts("Clocking Interaction:")
-    puts("  element requires a clock") if element.require_clock?
-    if element.provide_clock?
-      clock = element.clock
-      if clock.nil?
-        puts("  element is supported tot provide a clock but returned nil")
-      else
-        puts("  element provides a clock: #{clock.name}")
-      end
-    end
-    puts
-  end
-
-  def print_index_info(element)
-    if element.indexable?
-      puts("Indexing capabilities:")
-      puts("  element can do indexing")
-    else
-      puts("Element has no indexing capabilities.")
-    end
-    puts
-  end
-
-  def print_pad_info(element)
-    puts("Pads:")
-    pads = element.pads
-    if pads.empty?
-      puts("  none")
-      return
-    end
-
-    pads.each do |pad|
-      prefix("#{@prefix}  ") do
-        puts("#{pad.direction.nick.upcase}: '#{pad.name}'")
-        prefix("#{@prefix}  ") do
-          template = pad.template
-          puts("Pad Template: '#{template.name}'") if template
-
-          caps = pad.caps
-          break if caps.nil?
-          puts("Capabilities:")
-          prefix("#{@prefix}  ") do
-            print_caps(caps)
-          end
-        end
-      end
-    end
-    puts
-  end
-
-  def print_element_properties_info(element)
-    puts("Element Properties:")
-    properties = element.class.properties
-    if properties.empty?
-      puts(" none")
-      return
-    end
-
-    properties.each do |name|
-      param = element.class.property(name)
-      puts("  %-20s: %s" % [param.name, param.blurb])
-
-      flags = []
-      flags << "readable" if param.readable?
-      flags << "writable" if param.writable?
-      # flags << "controllable" if param.controllable?
-
-      prefix("#{@prefix}#{' ' * 23} ") do
-        puts("flags: #{flags.join(', ')}")
-        type_name = param.value_type.name
-        if param.readable?
-          current_value = element.get_property(name)
-          value = "Default: #{param.default.inspect} "
-          value << "Current: #{current_value.inspect}"
-        end
-        write_only = param.readable? ? "" : " Write only"
-        puts("#{type_name}. #{value}#{write_only}")
-      end
-    end
-    puts
-  end
-
-  def print_signal_info(element, signal)
-    args = ["object(#{element.class})"]
-    signal.param_types.each_with_index do |name, i|
-      args << "arg#{i}(#{name})"
-    end
-    args = args.join(", ")
-    signature = "{|#{args}| ...} # => #{signal.return_type}"
-    puts("  #{signal.name.inspect}: #{signature}")
-  end
-
-  def print_signals_info(element)
-    signals = []
-    actions = []
-    element.class.signals.each do |name|
-      signal = element.class.signal(name)
-      next if signal.owner >= Gst::Element
-      if signal.action?
-        actions << signal
-      else
-        signals << signal
-      end
-    end
-
-    [[signals, "Signals"],
-     [actions, "Actions"]].each do |target_signals, description|
-      unless target_signals.empty?
-        puts("Element #{description}:")
-        target_signals.each do |signal|
-          print_signal_info(element, signal)
-        end
-      end
-    end
-    puts
-  end
-
-  def print_children_info(element)
-    return unless element.is_a?(Gst::Bin)
-    children = element.children
-    return if children.empty?
-
-    puts("Children:")
-    children.each do |child|
-      puts("  #{child.name}")
-    end
-  end
-
-  def print_element_factory(factory, print_names)
-    if !factory.load!
-      puts("element plugin (#{factory.name}) couldn't be loaded\n")
-      return
-    end
-
-    element = factory.create
-
-    prefix(print_names ? "#{factory.name}: " : "") do
-      print_factory_details_info(factory)
-      print_plugin_info(factory.plugin_name)
-
-      print_hierarchy(element)
-      print_interfaces(element)
-
-      print_pad_templates_info(element, factory)
-      print_element_flag_info(element)
-      print_implementation_info(element)
-      print_clocking_info(element)
-      print_index_info(element)
-      print_pad_info(element)
-      print_element_properties_info(element)
-      print_signals_info(element)
-      print_children_info(element)
-    end
-  end
-
-  def print_feature(plugin, feature)
-    prefix("#{plugin.name}: #{feature.name}") do
-      case feature
-      when Gst::ElementFactory
-        puts(": #{feature.long_name}")
-      when Gst::IndexFactory
-        puts(": #{feature.description}")
-      when Gst::TypeFindFactory
-        if feature.extensions.empty?
-          message = "no extensions"
-        else
-          message = feature.extensions.join(", ")
-        end
-        puts(": #{message}")
-      else
-        puts(" (#{feature.gtype})")
-      end
-    end
-  end
-end
-
-options, element_name = parse(argv)
-inspector = Inspector.new
-if element_name
-  inspector.print_element(element_name)
-else
-  inspector.print_list(options.print_all)
-end

data/sample/install-plugins.rb

@@ -1,40 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require 'gtk2'
-require 'gst'
-
-def usage
-  $stderr.puts "Usage: #{$0} uri"
-  exit 1
-end
-
-usage unless ARGV.length==1
-
-playbin=Gst::ElementFactory.make('playbin')
-playbin.ready
-playbin.bus.add_watch {|bus, message|
-  case message
-  when Gst::MessageError
-    $stderr.puts "ERROR: "+message.parse.to_s
-  when Gst::MissingMessage
-    puts "Installer detail: "+message.installer_detail.to_s
-    if Gst::InstallPlugins.supported?
-      context=Gst::InstallPluginsContext.new
-      Gst::InstallPlugins.async([message.installer_detail], context){|ret| p ret}
-    else
-      $stderr.puts "Plugins installation is not supported."
-    end
-  end
-  true
-}
-playbin.uri=ARGV[0]
-playbin.play
-
-label=Gtk::Label.new(ARGV[0])
-window=Gtk::Window.new
-window.add(label)
-window.show_all
-window.signal_connect('delete-event'){playbin.stop; Gtk.main_quit}
-
-Gtk.main

data/sample/media-type.rb

@@ -1,55 +0,0 @@
-
-#  This program uses the media-info library to display information
-#  embedded in media files (tags in MP3/OGG files for instance).
-
-require 'gst'
-
-def print_hash(hash)
-    hash.each { |key, val| puts "      #{key}: #{val}" } 
-end
-
-def print_info(stream)
-    puts "- mime type: #{stream.mime}"
-    puts "- length: #{stream.length_time / Gst::SECOND} seconds"
-    puts "- bitrate: #{stream.bitrate / 1000.0} kbps"
-    puts "- number of tracks: #{stream.length_tracks}"
-    i = 0 
-    stream.tracks.each do |x|
-        puts "- track #{i += 1}:"
-        puts "  - metadata:"
-        if hash = x.metadata
-            print_hash(hash)
-        end
-        puts "  - streaminfo:"
-        if hash = x.streaminfo 
-            print_hash(hash)
-        end
-        puts "  - format:"
-        if caps = x.format
-            caps.length.times { |i| print_hash(caps.get_structure(i)) }
-        end
-    end
-end
-
-Gst.init
-
-if ARGV.empty?
-    $stderr.puts "Usage: #{__FILE__} files..."
-    exit 1
-end
-
-begin
-    info = Gst::MediaInfo.new
-    info.source = "filesrc" 
-
-    ARGV.each do |x|
-        if stream = info.read(x)
-            print_info(stream)
-        else
-            $stderr.puts "No media info found for file #{x}."
-        end 
-    end
-rescue => e
-    $stderr.puts "Media error: #{e}."
-    exit 1
-end