gstreamer 0.90.6

data/sample/media-type2.rb

@@ -0,0 +1,268 @@
+
+# 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

@@ -0,0 +1,54 @@
+#!/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

@@ -0,0 +1,46 @@
+#!/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

@@ -0,0 +1,57 @@
+#!/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

@@ -0,0 +1,60 @@
+#!/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)