--- /dev/null
+/* Demo Recorder for MAEMO 5
+* Copyright (C) 2010 Dru Moore <usr@dru-id.co.uk>
+* This program is free software; you can redistribute it and/or modify
+* it under the terms of the GNU General Public License version 2,
+* or (at your option) any later version, as published by the Free
+* Software Foundation
+*
+* This program 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 General Public License for more details
+*
+* You should have received a copy of the GNU General Public
+* License along with this program; if not, write to the
+* Free Software Foundation, Inc.,
+* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*/
+namespace IdWorks {
+
+public class TrackPipeline : GLib.Object {
+
+ Gst.Bin bin;
+ Gst.Element src;
+ Gst.Element decoder;
+ Gst.Element converter;
+ Gst.Element equalizer;
+ Gst.Element panorama;
+ Gst.Element volume;
+ Gst.Element sink;
+ string track_title;
+ Gst.Query duration_query;
+ Gst.Query position_query;
+ int64 position;
+ int64 duration;
+
+ public void set_sink(Gst.Element sink) {
+ this.sink = sink;
+ }
+
+ public void link_track(Gst.Element adder) {
+ volume.link(adder);
+ }
+
+ //define a delegate function to handle tags
+ private static Gst.TagForeachFunc handle_tags_delegate;
+
+ public signal void position_duration(int64 position, int64 duration);
+ public signal void tag_parsed(string tag, string val);
+ public signal void end_of_stream();
+ public signal void stream_error(string msg);
+
+ public TrackPipeline(string name) {
+ //set the tag handling delegate
+ this.handle_tags_delegate = this.handle_tags;
+ //set some default values
+ this.position=0;
+ this.duration=0;
+ this.construct_bin(name);
+ //define the queries
+ duration_query = new Gst.Query.duration(Gst.Format.TIME);
+ position_query = new Gst.Query.position(Gst.Format.TIME);
+ }
+
+ private void construct_bin(string name) {
+ bin = new Gst.Bin(name);
+ src = Gst.ElementFactory.make("fakesrc", "source");
+ bin.add(src);
+ decoder = Gst.ElementFactory.make("decodebin", "decoder");
+ decoder.connect ("swapped-object-signal::new-decoded-pad", new_decoded_pad, this);
+ bin.add(decoder);
+ converter = Gst.ElementFactory.make("audioconvert", "converter");
+ bin.add(converter);
+ panorama = Gst.ElementFactory.make("audiopanorama", "panorama");
+ bin.add(panorama);
+ //echo = ElementFactory.make("audioecho", "echo");
+ //echo.set_property("delay", 500000000);
+ //echo.set_property("feedback", 0.4);
+ //echo.set_property("intensity", 0.5);
+ //echo.set_property("max-delay", 500000000);
+ //pipeline.add(echo);
+ //converter2 = ElementFactory.make("audioconvert", "converter2");
+ //pipeline.add(converter2);
+ equalizer = Gst.ElementFactory.make("equalizer-10bands", "eq");
+ bin.add(equalizer);
+ volume = Gst.ElementFactory.make("volume", "vol");
+ bin.add(volume);
+ sink = Gst.ElementFactory.make("autoaudiosink", "audio-output");
+ /* TODO How does bin handle this */ //pipeline.add(sink);
+ converter.link(equalizer);
+ equalizer.link(panorama);
+ panorama.link(volume);
+ /* TODO How does bin handle this */ //volume.link(sink);
+ //we need to receive signals from the pipelines bus
+ Gst.Bus bus = this.bin.get_bus( );
+ //make sure we are watching the signals on the bus
+ bus.add_signal_watch();
+ //what do we do when a tag is part of the bus signal?
+ bus.message.connect(
+ (bus,message)=> {
+ this.bus_message(message);
+ }
+ );
+ }
+
+
+ public void foreach_tag (Gst.TagList list, string tag) {
+ stdout.printf("foreach_tag called\n");
+ stdout.flush();
+ switch (tag) {
+ case "title":
+ list.get_string (tag, out track_title);
+ stdout.printf ("%s\n", track_title);
+ stdout.flush();
+ //info_label.set_markup("<b>" + track_title + "</b><br>" + track_uri);
+ break;
+ default:
+ break;
+ }
+ }
+
+ public void handle_tags(Gst.TagList list, string tag) {
+ if (tag != null) {
+ switch (tag) {
+ case "artist":
+ case "title":
+ case "album":
+ case "channel-mode":
+ case "comment":
+ case "audio-codec":
+ string val="Unknown";
+ list.get_string(tag,out val);
+ tag_parsed(tag, val);
+ break;
+ case "track-number":
+ case "bitrate":
+ uint val;
+ list.get_uint(tag,out val);
+ //tag_parsed(tag,(string)val);
+ break;
+ default:
+ //stdout.printf("%s\n",tag);
+ //stdout.flush();
+ break;
+ }
+ }
+ }
+
+
+ public void bus_message(Gst.Message message) {
+ Gst.TagList tag_list;
+ switch(message.type) {
+ case Gst.MessageType.ERROR:
+ GLib.Error err;
+ string debug;
+ message.parse_error (out err, out debug);
+ stream_error(err.message);
+ break;
+ case Gst.MessageType.TAG:
+ message.parse_tag(out tag_list);
+ //we need to get the key and value from the tag
+ tag_list.foreach( this.handle_tags_delegate );
+ break;
+ case Gst.MessageType.STATE_CHANGED:
+ //stdout.printf("state changed\n");
+ Gst.State oldstate;
+ Gst.State newstate;
+ Gst.State pending;
+ message.parse_state_changed (out oldstate, out newstate, out pending);
+ //stdout.printf ("%s->%s:%s\n", oldstate.to_string(), newstate.to_string(), pending.to_string());
+ //stdout.flush();
+ break;
+ case Gst.MessageType.EOS:
+ end_of_stream();
+ break;
+ default:
+ break;
+ }
+ }
+
+ public bool bus_callback (Gst.Bus bus, Gst.Message message) {
+ stdout.printf("state changed\n");
+ stdout.flush();
+ switch (message.type) {
+ case Gst.MessageType.ERROR:
+ GLib.Error err;
+ string debug;
+ message.parse_error (out err, out debug);
+ stdout.printf("%s\n", err.message);
+ stdout.flush();
+ break;
+ case Gst.MessageType.EOS:
+ stdout.printf ("end of stream\n");
+ stdout.flush();
+ break;
+ case Gst.MessageType.STATE_CHANGED:
+ Gst.State oldstate;
+ Gst.State newstate;
+ Gst.State pending;
+ message.parse_state_changed (out oldstate, out newstate, out pending);
+ stdout.printf ("%s->%s:%s\n", oldstate.to_string(), newstate.to_string(), pending.to_string());
+ stdout.flush();
+ break;
+ case Gst.MessageType.TAG:
+ Gst.TagList tag_list;
+ message.parse_tag (out tag_list);
+ tag_list.foreach (foreach_tag);
+ break;
+ default:
+ break;
+ }
+ return true;
+ }
+
+ public void get_duration_info() {
+ bool duration_result,position_result;
+ Gst.Format format = Gst.Format.TIME;
+ duration_result = this.bin.query(this.duration_query);
+ position_result = this.bin.query(this.position_query);
+ if ( duration_result && position_result ) {
+ this.duration_query.parse_duration(out format, out this.duration);
+ this.position_query.parse_position(out format, out this.position);
+ this.position_duration(this.position,this.duration);
+ }
+ }
+
+ public void play() {
+ bin.set_state(Gst.State.PLAYING);
+ }
+
+ public void pause() {
+ bin.set_state(Gst.State.PAUSED);
+ }
+
+ public void stop() {
+ bin.set_state(Gst.State.READY);
+ }
+
+ public void move_to(int64 newloc) {
+ if (0 > newloc) newloc = 0;
+ this.converter.seek_simple(Gst.Format.TIME, Gst.SeekFlags.KEY_UNIT | Gst.SeekFlags.FLUSH, newloc);
+ this.play();
+ }
+
+ public void seek(int percent) {
+ move_to((int64) this.position + (this.duration * percent / 100));
+ }
+
+ public void seek_forward(int percent) {
+ seek(percent);
+ }
+
+ public void seek_backward(int percent) {
+ seek(-percent);
+ }
+
+ public void set_uri(string uri) {
+ this.bin.set_state(Gst.State.NULL);
+ try {
+ //is there a src pipeline?
+ this.bin.remove(this.src);
+ } finally {
+ //do nothing, the src doesn't exist
+ }
+ this.src = Gst.Element.make_from_uri(Gst.URIType.SRC, uri, "my_src");
+ Gst.Bus bus = this.src.get_bus();
+ bus.add_watch (bus_callback);
+ this.bin.add(this.src);
+ this.src.link(this.decoder);
+ }
+
+ public void set_volume(double val)
+ requires (val >= 0.0 && val <= 10.0) {
+ volume.set_property("volume",val);
+ }
+
+ public double get_volume() {
+ GLib.Value ret = 0.0;
+ volume.get_property("volume", ref ret);
+ return ret.get_double();
+ }
+
+ public void set_panorama(double val)
+ requires (val >= -1.0 && val <= 1.0) {
+ panorama.set_property("panorama", val);
+ }
+
+ public double get_panorama() {
+ GLib.Value ret = 0.0;
+ panorama.get_property("panorama", ref ret);
+ return ret.get_double();
+ }
+
+ public void set_eq(int band, double val)
+ requires (band > -1 && band < 10)
+ requires (val >= -24 && val <= 12) {
+ equalizer.set_property("band" + band.to_string(), val);
+ }
+
+ public double get_eq(int band) {
+ GLib.Value ret = 0.0;
+ equalizer.get_property("band" + band.to_string(), ref ret);
+ return ret.get_double();
+ }
+
+ public bool new_decoded_pad(Gst.Pad decodebin, bool arg1, void* data) {
+ //link the pad to the audioconverter
+ decodebin.link( converter.get_static_pad("sink") );
+ return true;
+ }
+
+}
+
+}
projects / demorecorder / blobdiff