gstreamer 1.2.6 → 2.0.0

data/sample/media-type2.rb

@@ -1,268 +0,0 @@
-
-# This is a Ruby implementation of the GStreamer media-info library,
-# graciously provided by Nikolai Weilbull <lone-star@home.se>.
-#
-# It works exactly like media-type.rb.
-
-require 'gst'
-
-class MediaInfoStream
-  def initialize
-    @length_tracks = 0
-    @length_time = 0
-    @bitrate = 0
-    @seekable = false
-    @path = nil
-    @mime = nil
-    @tracks = []
-  end
-  attr_accessor :length_time, :length_tracks, :path, :mime, :bitrate, :tracks
-end
-
-class MediaInfoTrack
-  def initialize
-    @metadata = nil
-    @streaminfo = nil
-    @format = nil
-    @length_time = 0
-    @con_streams = nil
-  end
-
-  attr_accessor :metadata, :streaminfo, :format
-end
-
-class MediaInfo
-  # TODO: add signals
-  INFO_ALL = (0..4).to_a.length - 1
-  INFO_STREAM, INFO_MIME, INFO_METADATA, INFO_STREAMINFO, INFO_FORMAT = *(0..4).to_a
-  def initialize(source_element)
-    @pipeline = Gst::Pipeline.new 'media-info'
-    @typefind = Gst::ElementFactory.make 'typefind', 'typefind'
-    @source_element = source_element
-    @source = Gst::ElementFactory.make @source_element, 'source'
-    if @source != nil
-      @pipeline.add @source
-    else
-      @source_element = nil
-      @source = nil
-    end
-    @decoder = @type = @format = @metadata = @stream = nil
-    @decoders = Hash.new
-    @pipeline.signal_connect 'deep_notify' do |obj, origin, pspec|
-      case pspec.name
-      when 'metadata'
-	@metadata = origin.metadata
-      when 'caps'
-	@format = origin.caps if origin == @decoder_pad
-      when 'streaminfo'
-	@streaminfo = origin.streaminfo
-      end
-    end
-  end
-
-  def reset
-    @format = nil
-    @metadata = nil
-    @stream = nil
-  end
-
-  def seek_to_track(track)
-    track_format = Gst::Format.find 'logical_stream'
-    return false if track_format == nil
-    @pipeline.play
-		# XXX: todo, need Gst::Event
-    event = gst_event_new_seek(format.id | Gst::EventSeek::METHOD_SET |
-			       Gst::EventSeek::FLAG_FLUSH)
-    return false if event == nil
-    @metadata = nil
-    @streaminfo = nil
-    return true
-  end
-
-  def get_decoder(mime)
-    decoder = @decoders[mime]
-    if decoder == nil
-      factories = {
-	'application/x-ogg' => 'vorbisfile',
-	'audio/x-mp3' => 'mad',
-	'audio/x-wav' => 'wavparse'
-      }
-      factory = factories[mime]
-      return nil if factory == nil
-      decoder = Gst::ElementFactory.make factory, 'decoder'
-      @decoders[mime] = decoder if decoder != nil
-    end
-    return decoder
-  end
-
-  def find_type(location)
-    @type = nil
-    @pipeline.add @typefind
-    @source.location = location
-    @source >> @typefind
-    @typefind.signal_connect 'have-type' do |typefind, type|
-      @type = type
-    end
-    @pipeline.play
-    while @type == nil && @pipeline.iterate do end
-    @pipeline.ready
-    # TODO: this is different
-    @source.unlink_pads @typefind
-    @pipeline.remove @typefind
-  end
-
-  def get_stream(stream)
-    @pipeline.play
-    while @format == nil && @pipeline.iterate do end
-    @pipeline.pause
-    return nil if @format == nil
-    track_format = Gst::Format.find 'logical_stream'
-    @decoder_pad.formats.each do |format|
-      value = @decoder_pad.query(Gst::QueryType::TOTAL, format.type_id)
-      case format.type_id
-      when Gst::Format::TIME
-	stream.length_time = value ? value : 1
-      else
-	stream.length_tracks = value if format == track_format && value != nil
-      end
-    end
-    stream.length_tracks = 1 if stream.length_tracks == 0
-    value = @source_pad.query(Gst::QueryType::TOTAL, Gst::Format::BYTES)
-    if value
-      seconds = stream.length_time.to_f / Gst::SECOND 
-      bits = value * 8
-      stream.bitrate = bits / seconds
-    end
-    return stream
-  end
-
-  def find_metadata
-    @pipeline.play
-    while @metadata == nil && @pipeline.iterate do end
-    @pipeline.pause
-    metadata = @metadata
-    @metadata = nil
-    return metadata
-  end
-
-  def find_streaminfo
-    @pipeline.play
-    while @streaminfo == nil && @pipeline.iterate do end
-    @pipeline.pause
-    streaminfo = @streaminfo
-    @streaminfo = nil
-
-    track_format = Gst::Format.find 'logical_stream'
-    if track_format != nil
-      start = @decoder_pad.query(Gst::QueryType::POSITION, track_format.type_id)
-      track_num = start
-      # XXX: need Gst::Pad#convert
-    end
-    return streaminfo
-  end
-
-  def find_format
-    @pipeline.play
-    while @format == nil && @pipeline.iterate do end
-    @pipeline.pause
-    format = @format
-    @format = nil
-    return format
-  end
-
-  def clear_decoder
-    if @decoder != nil
-      @pipeline.ready
-      @source.unlink_pads @decoder
-      @pipeline.remove @decoder
-      @decoder = nil
-    end
-  end
-
-  def set_decoder(decoder)
-    @decoder = decoder
-    @pipeline.add @decoder
-    @source >> @decoder
-    @decoder_pad = @decoder.get_pad 'src'
-    @source_pad = @source.get_pad 'src'
-  end
-
-  def set_source(source)
-    src = Gst::ElementFactory.make source, 'new-source'
-    return false if src == nil
-    if @source != nil
-      @pipeline.remove @source
-      @source_element = nil if @source_element != nil
-    end
-    src.name = 'source'
-    @pipeline.add src
-    @source = src
-    @source_element = source
-    return true
-  end
-
-  def read(location, flags)
-    reset
-    find_type location
-    return nil if @type == nil
-    stream = MediaInfoStream.new
-    mime = @type.mime
-    stream.mime = mime if flags & INFO_MIME
-    stream.path = location
-    decoder = get_decoder mime
-    return nil if decoder == nil
-    set_decoder decoder
-    stream = get_stream stream
-    stream.length_tracks.times do |i|
-      track = MediaInfoTrack.new
-      track.metadata = find_metadata if flags & INFO_METADATA
-      track.streaminfo = find_streaminfo if flags & INFO_STREAMINFO
-      track.format = find_format if flags & INFO_FORMAT
-      stream.tracks << track
-    end
-    clear_decoder
-    return stream
-  end
-end
-
-def usage
-  puts "Usage: #{__FILE__} FILE..."
-  exit 1
-end
-
-def print_caps(caps)
-  return if caps == nil
-  caps.each_property do |name, value, fixed|
-    puts "          #{name}: #{value}"
-  end
-end
-
-def print_info(path, stream)
-  if stream
-    puts "#{path}:"
-    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}"
-    puts "  tracks:"
-    stream.tracks.each_with_index do |track, i|
-      puts "    - track #{i + 1}:"
-      puts "        metadata:"
-      print_caps track.metadata
-      puts "        streaminfo:"
-      print_caps track.streaminfo
-      puts "        format:"
-      print_caps track.format
-    end
-  else
-    puts "No media info found for file #{path}"
-  end
-end
-
-usage if ARGV.empty?
-Gst.init
-mediainfo = MediaInfo.new 'filesrc'
-ARGV.each do |path|
-  print_info path, mediainfo.read(path, MediaInfo::INFO_ALL)
-end
-

data/sample/ogg-audio-player.rb

@@ -1,54 +0,0 @@
-#!/usr/bin/env ruby
-
-if ARGV.size != 1
-  puts "Usage: #{$0} ogg-audio-file"
-  exit
-end
-
-require 'gst'
-
-loop = GLib::MainLoop.new(nil, false)
-
-pipeline = Gst::Pipeline.new("ogg-audio-player")
-source = Gst::ElementFactory.make("filesrc", "file-source")
-parser = Gst::ElementFactory.make("oggdemux", "ogg-parser")
-decoder = Gst::ElementFactory.make("vorbisdec", "vorbis-decoder")
-converter = Gst::ElementFactory.make("audioconvert", "converter")
-sink = Gst::ElementFactory.make("alsasink", "alsa-output")
-
-source.location = ARGV.shift
-
-bus = pipeline.bus
-bus.add_watch do |bus, message|
-  case message.type
-  when Gst::Message::EOS
-    loop.quit
-  when Gst::Message::ERROR
-    p message.parse
-    loop.quit
-  end
-  true
-end
-
-
-pipeline.add(source, parser, decoder, converter, sink)
-source >> parser
-decoder >> converter >> sink
-
-parser.signal_connect("pad-added") do |element, pad|
-  sink_pad = decoder.get_pad("sink")
-  pad.link(sink_pad)
-end
-
-puts "Setting to PLAYING"
-pipeline.play
-puts "Running"
-begin
-  loop.run
-  print "Returned, "
-rescue Interrupt
-  print "Interrupted, "
-ensure
-  puts "stopping playback"
-  pipeline.stop
-end

data/sample/type-find.rb

@@ -1,46 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'gst'
-
-def type_find(file)
-  pipeline = Gst::Pipeline.new("pipeline")
-
-  source = Gst::ElementFactory.make("filesrc", "source")
-  type_find = Gst::ElementFactory.make("typefind", "type-find")
-  sink = Gst::ElementFactory.make("fakesink", "sink")
-
-  pipeline.add(source, type_find, sink)
-  source >> type_find >> sink
-
-  found_caps = nil
-  type_find.signal_connect("have-type") do |element, probability, caps|
-    found_caps = caps
-  end
-
-  loop = GLib::MainLoop.new
-  source.location = file
-  bus = pipeline.bus
-  bus.add_watch do |bus, message|
-    case message.type
-    when Gst::Message::STATE_CHANGED, Gst::Message::EOS
-      loop.quit
-    when Gst::Message::ERROR
-      p message.parse
-      loop.quit
-    end
-    true
-  end
-  pipeline.pause
-  loop.run
-  pipeline.stop
-
-  if found_caps
-    puts("#{file} - #{found_caps}")
-  else
-    puts("#{file} - No type found")
-  end
-end
-
-ARGV.each do |file|
-  type_find(file)
-end

data/sample/video-player.rb

@@ -1,57 +0,0 @@
-#!/usr/bin/env ruby
-
-if ARGV.size != 1
-  $stderr.puts "Usage: #{$0} uri"
-  exit 1
-end
-
-require 'gtk2'
-require 'gst'
-require 'uri'
-
-def normalize_uri(uri)
-  uri = URI(uri)
-  uri.scheme ||= "file"
-  if uri.scheme == "file"
-    "file://#{uri.path}"
-  else
-    uri.to_s
-  end
-end
-
-play_bin = Gst::ElementFactory.make('playbin')
-bus = play_bin.bus
-bus.add_watch do |bus, message|
-  case message.type
-  when Gst::Message::EOS
-    puts "end of stream"
-    Gtk.main_quit
-  when Gst::Message::ERROR
-    $stderr.puts "Error: #{message.parse}"
-    Gtk.main_quit
-  end
-  true
-end
-
-play_bin.uri = normalize_uri(ARGV.first)
-video_sink = Gst::ElementFactory.make('xvimagesink')
-play_bin.video_sink = video_sink
-
-window = Gtk::Window.new
-window.signal_connect('destroy') do
-  play_bin.stop
-  Gtk.main_quit
-end
-window.signal_connect('expose-event') do
-  video_sink.xwindow_id = window.window.xid
-end
-window.show_all
-
-puts "Streaming #{play_bin.uri}..."
-play_bin.play
-
-begin
-  Gtk.main
-rescue Interrupt
-  window.destroy
-end

data/sample/xml-player.rb

@@ -1,60 +0,0 @@
-#!/usr/bin/env ruby
-
-### TODO: I want to set link in build_pipeline.
-
-unless ARGV.size == 1
-  puts "Usage: #{$0} [file]"
-  exit 1
-end
-
-require 'gst'
-
-XML_FILE = "/tmp/pipeline.xml"
-PIPELINE_NAME = "our-pipeline"
-
-def build_pipeline(file)
-  source = Gst::ElementFactory.make("filesrc")
-  decoder = Gst::ElementFactory.make("decodebin")
-  audio_converter = Gst::ElementFactory.make("audioconvert")
-  audio_resample = Gst::ElementFactory.make("audioresample")
-  audio_sink = Gst::ElementFactory.make("autoaudiosink")
-  source.location = file
-  pipeline = Gst::Pipeline.new(PIPELINE_NAME)
-  pipeline.add(source, decoder, audio_converter, audio_resample, audio_sink)
-  pipeline
-end
-
-def write_pipeline(pipeline, file)
-  Gst::XML.write_file(pipeline, file)
-end
-
-def read_pipeline(file)
-  xml = Gst::XML.new
-  xml.parse_file(file)
-  pipeline = xml.get_element(PIPELINE_NAME)
-  children = pipeline.children
-  source, decoder, audio_converter, audio_resample, audio_sink = children
-  source >> decoder
-  audio_converter >> audio_resample >> audio_sink
-  decoder.signal_connect("new-decoded-pad") do |element, pad|
-    sink_pad = audio_converter.get_pad("sink")
-    pad.link(sink_pad)
-  end
-  pipeline
-end
-
-def play_pipeline(pipeline)
-  pipeline.play
-  loop = GLib::MainLoop.new(nil, false)
-  begin
-    loop.run
-  rescue Interrupt
-  ensure
-    pipeline.stop
-  end
-end
-
-pipeline = build_pipeline(ARGV.first)
-write_pipeline(pipeline, XML_FILE)
-pipeline = read_pipeline(XML_FILE)
-play_pipeline(pipeline)

data/test/gst-test-utils.rb

@@ -1,18 +0,0 @@
-module GstTestUtils
-  private
-  def only_gst_version(major, minor, micro)
-    unless Gst.check_version?(major, minor, micro)
-      omit("Require GStreamer >= #{major}.#{minor}.#{micro}")
-    end
-  end
-
-  def find_element_factory(name)
-    factory = Gst::ElementFactory.find(name)
-    assert_not_nil(factory, "#{name}'s factory should be found.")
-    factory
-  end
-
-  def create_element(element_name, name=nil)
-    find_element_factory(element_name).create(name)
-  end
-end

data/test/run-test.rb

@@ -1,25 +0,0 @@
-#!/usr/bin/env ruby
-
-# ENV["GST_DEBUG"] = "GST_BUFFER:5"
-
-base_dir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
-
-if system("which make > /dev/null")
-  system("cd #{base_dir.dump} && make > /dev/null") or exit(1)
-end
-
-glib_dir = File.expand_path(File.join(base_dir, "..", "glib2"))
-$LOAD_PATH.unshift(File.join(glib_dir, "test"))
-require 'glib-test-init'
-
-$LOAD_PATH.unshift(File.join(glib_dir, "ext", "glib2"))
-$LOAD_PATH.unshift(File.join(glib_dir, "lib"))
-
-$LOAD_PATH.unshift(File.join(base_dir, "ext", "gstreamer"))
-$LOAD_PATH.unshift(File.join(base_dir, "lib"))
-require "gst"
-
-$LOAD_PATH.unshift(File.join(base_dir, "test"))
-require 'gst-test-utils'
-
-exit Test::Unit::AutoRunner.run(true)

data/test/test_bin.rb

@@ -1,167 +0,0 @@
-class TestBin < Test::Unit::TestCase
-  include GstTestUtils
-
-  def test_children
-    bin = Gst::Bin.new
-
-    element = create_element("filesink")
-    no_interface_element = create_element("fakesink")
-    bin << element << no_interface_element
-
-    assert_equal([no_interface_element, element], bin.children)
-    assert_equal([element], bin.children(Gst::ElementURIHandler))
-  end
-
-  def test_size
-    bin = Gst::Bin.new
-    assert_equal(0, bin.size)
-    bin << create_element("fakesink")
-    assert_equal(1, bin.size)
-  end
-
-  def test_children_cookie
-    bin = Gst::Bin.new
-    cookie = bin.children_cookie
-    assert_equal(cookie, bin.children_cookie)
-    bin << create_element("fakesink")
-    assert_not_equal(cookie, bin.children_cookie)
-  end
-
-  def test_child_bus
-    bin = Gst::Bin.new
-    assert_not_nil(bin.child_bus)
-  end
-
-  def test_messages
-    bin = Gst::Bin.new
-    assert_equal([], bin.messages)
-  end
-
-  def test_polling?
-    bin = Gst::Bin.new
-    assert(!bin.polling?)
-  end
-
-  def test_clock_dirty?
-    bin = Gst::Bin.new
-    assert(!bin.clock_dirty?)
-  end
-
-  def test_provided_clock
-    bin = Gst::Bin.new
-    assert_nil(bin.provided_clock)
-    bin.provided_clock = Gst::SystemClock.new
-    assert_not_nil(bin.provided_clock)
-    bin.provided_clock = nil
-    assert_nil(bin.provided_clock)
-  end
-
-  def test_clock_provider
-    bin = Gst::Bin.new
-    assert_nil(bin.clock_provider)
-  end
-
-  def test_add
-    bin = Gst::Bin.new
-    element = create_element("fakesink")
-    bin << element
-    assert_equal(element, bin.children[0])
-    assert_raise(TypeError) do
-      bin << "XXX"
-    end
-
-    element2 = create_element("fakesink")
-    element3 = create_element("fakesink")
-    bin.add(element2, element3)
-    assert_equal([element3, element2], bin.children[0, 2])
-  end
-
-  def test_remove
-    bin = Gst::Bin.new
-    element1 = create_element("fakesink")
-    element2 = create_element("fakesink")
-    bin << element1 << element2
-    assert_equal(2, bin.size)
-    bin.remove(element1, element2)
-    assert_equal(0, bin.size)
-  end
-
-  def test_clear
-    bin = Gst::Bin.new
-    element1 = create_element("fakesink")
-    element2 = create_element("fakesink")
-    bin << element1 << element2
-    assert_equal(2, bin.size)
-    bin.clear
-    assert_equal(0, bin.size)
-  end
-
-  def test_refer_by_name
-    bin = Gst::Bin.new
-    sub_bin = Gst::Bin.new
-    bin << sub_bin
-
-    element = create_element("fakesink")
-    assert_nil(bin.get_child(element.name))
-    assert_nil(sub_bin.get_child(element.name))
-    assert_nil(sub_bin.get_child(element.name, true))
-
-    bin << element
-    assert_equal(element, bin.get_child(element.name))
-    assert_equal(element, bin.get_child(element.name, true))
-    assert_nil(sub_bin.get_child(element.name))
-    assert_equal(element, sub_bin.get_child(element.name, true))
-  end
-
-  def test_refer_by_interface
-    bin = Gst::Bin.new
-    element = create_element("filesink")
-
-    assert_nil(bin.get_child(Gst::ElementURIHandler))
-
-    bin << create_element("fakesink")
-    assert_nil(bin.get_child(Gst::ElementURIHandler))
-
-    bin << element
-    assert_equal(element, bin.get_child(Gst::ElementURIHandler))
-  end
-
-  def test_refer_by_index
-    bin = Gst::Bin.new
-    element1 = create_element("filesink")
-    element2 = create_element("fakesink")
-
-    assert_nil(bin.get_child(0))
-    assert_nil(bin.get_child(1))
-    assert_nil(bin.get_child(2))
-
-    bin << element1 << element2
-    assert_equal(element2, bin.get_child(0))
-    assert_equal(element1, bin.get_child(1))
-    assert_nil(bin.get_child(2))
-  end
-
-  def test_sinks
-    bin = Gst::Bin.new
-    sink1 = create_element("filesink")
-    sink2 = create_element("fakesink")
-    src = create_element("fakesrc")
-
-    assert_equal([], bin.sinks)
-
-    bin << src << sink1 << sink2
-    assert_equal([sink2, sink1], bin.sinks)
-  end
-
-  def test_sources
-    bin = Gst::Bin.new
-    src1 = create_element("filesrc")
-    src2 = create_element("fakesrc")
-    sink = create_element("fakesink")
-
-    assert_equal([], bin.sources)
-
-    bin << src1 << src2 << sink
-    assert_equal([src2, src1], bin.sources)
-  end
-end