gstreamer/samples/DecodeBinTranscoder.cs

//
// DecodeBinTranscoder.cs: sample transcoder using DecodeBin binding
//
// Authors:
//   Aaron Bockover (abockover@novell.com)
//
// (C) 2006 Novell, Inc.
//

using System;
using Gst;
using Gst.CorePlugins;
using Gst.BasePlugins;

public delegate void ErrorHandler (object o, ErrorArgs args);
public delegate void ProgressHandler (object o, ProgressArgs args);

public class ErrorArgs : EventArgs {
  public string Error;
}

public class ProgressArgs : EventArgs {
  public long Duration;
  public long Position;
}

public class DecodeBinTranscoder : IDisposable {
  private Pipeline pipeline;
  private FileSrc filesrc;
  private FileSink filesink;
  private Element audioconvert;
  private Element encoder;
  private DecodeBin decodebin;

  private uint progress_timeout;

  public event EventHandler Finished;
  public event ErrorHandler Error;
  public event ProgressHandler Progress;

  public DecodeBinTranscoder() {
    ConstructPipeline();
  }

  public void Transcode (string inputFile, string outputFile) {
    filesrc.Location = inputFile;
    filesink.Location = outputFile;

    pipeline.SetState (State.Playing);
    progress_timeout = GLib.Timeout.Add (250, OnProgressTimeout);
  }

  public void Dispose() {
    pipeline.Dispose();
  }

  protected virtual void OnFinished() {
    EventHandler handler = Finished;
    if (handler != null) {
      handler (this, new EventArgs());
    }
  }

  protected virtual void OnError (string error) {
    ErrorHandler handler = Error;
    if (handler != null) {
      ErrorArgs args = new ErrorArgs();
      args.Error = error;
      handler (this, args);
    }
  }

  protected virtual void OnProgress (long position, long duration) {
    ProgressHandler handler = Progress;
    if (handler != null) {
      ProgressArgs args = new ProgressArgs();
      args.Position = position;
      args.Duration = duration;
      handler (this, args);
    }
  }

  private void ConstructPipeline() {
    pipeline = new Pipeline ("pipeline");

    filesrc = ElementFactory.Make ("filesrc", "filesrc") as FileSrc;
    filesink = ElementFactory.Make ("filesink", "filesink") as FileSink;
    audioconvert = ElementFactory.Make ("audioconvert", "audioconvert");
    encoder = ElementFactory.Make ("wavenc", "wavenc");
    decodebin = ElementFactory.Make ("decodebin", "decodebin") as DecodeBin;
    decodebin.NewDecodedPad += OnNewDecodedPad;

    pipeline.Add (filesrc, decodebin, audioconvert, encoder, filesink);

    filesrc.Link (decodebin);
    audioconvert.Link (encoder);
    encoder.Link (filesink);

    pipeline.Bus.AddWatch (new BusFunc (OnBusMessage));
  }

  private void OnNewDecodedPad (object o, DecodeBin.NewDecodedPadArgs args) {
    Pad sinkpad = audioconvert.GetStaticPad ("sink");

    if (sinkpad.IsLinked) {
      return;
    }

    Caps caps = args.Pad.Caps;
    Structure structure = caps[0];

    if (!structure.Name.StartsWith ("audio")) {
      return;
    }

    args.Pad.Link (sinkpad);
  }

  private bool OnBusMessage (Bus bus, Message message) {
    switch (message.Type) {
      case MessageType.Error:
        string msg;
        Enum err;
        message.ParseError (out err, out msg);
        GLib.Source.Remove (progress_timeout);
        OnError (msg);
        break;
      case MessageType.Eos:
        pipeline.SetState (State.Null);
        GLib.Source.Remove (progress_timeout);
        OnFinished();
        break;
    }

    return true;
  }

  private bool OnProgressTimeout() {
    long duration, position;
    Gst.Format fmt = Gst.Format.Time;

    if (pipeline.QueryDuration (ref fmt, out duration) && fmt == Gst.Format.Time && encoder.QueryPosition (ref fmt, out position) && fmt == Gst.Format.Time) {
      OnProgress (position, duration);
    }

    return true;
  }

  private static GLib.MainLoop loop;

  public static void Main (string [] args) {
    if (args.Length < 2) {
      Console.WriteLine ("Usage: mono decodebin-transcoder.exe <input-file> <output-file>");
      return;
    }

    Gst.Application.Init();
    loop = new GLib.MainLoop();

    DecodeBinTranscoder transcoder = new DecodeBinTranscoder();

    transcoder.Error += delegate (object o, ErrorArgs eargs) {
      Console.WriteLine ("Error: {0}", eargs.Error);
      transcoder.Dispose();
      loop.Quit();
    };

    transcoder.Finished += delegate {
      Console.WriteLine ("\nFinished");
      transcoder.Dispose();
      loop.Quit();
    };

    transcoder.Progress += delegate (object o, ProgressArgs pargs) {
      Console.Write ("\rEncoding: {0} / {1} ({2:00.00}%) ",
                     new TimeSpan ( (pargs.Position / (long) Clock.Second) * TimeSpan.TicksPerSecond),
                     new TimeSpan ( (pargs.Duration / (long) Clock.Second) * TimeSpan.TicksPerSecond),
                     ( (double) pargs.Position / (double) pargs.Duration) * 100.0);
    };

    transcoder.Transcode (args[0], args[1]);

    loop.Run();
  }
}