diff --git a/configure.ac b/configure.ac
index 1e4b869..6045bfb 100644
--- a/configure.ac
+++ b/configure.ac
@@ -405,6 +405,7 @@ AG_GST_CHECK_PLUGIN(removesilence)
 AG_GST_CHECK_PLUGIN(sdi)
 AG_GST_CHECK_PLUGIN(sdp)
 AG_GST_CHECK_PLUGIN(segmentclip)
+AG_GST_CHECK_PLUGIN(sequences)
 AG_GST_CHECK_PLUGIN(siren)
 AG_GST_CHECK_PLUGIN(smooth)
 AG_GST_CHECK_PLUGIN(speed)
@@ -3221,6 +3222,7 @@ gst/removesilence/Makefile
 gst/sdi/Makefile
 gst/sdp/Makefile
 gst/segmentclip/Makefile
+gst/sequences/Makefile
 gst/siren/Makefile
 gst/smooth/Makefile
 gst/speed/Makefile
diff --git a/gst/sequences/Makefile.am b/gst/sequences/Makefile.am
new file mode 100644
index 0000000..6c591cf
--- /dev/null
+++ b/gst/sequences/Makefile.am
@@ -0,0 +1,27 @@
+
+plugin_LTLIBRARIES = libgstsequences.la
+
+libgstsequences_la_SOURCES = \
+	gstimagesequencesrc.c   \
+    gstimagesequence.c
+libgstsequences_la_CFLAGS = $(GST_PLUGINS_BASE_CFLAGS) $(GST_BASE_CFLAGS) $(GST_CFLAGS) $(GIO_CFLAGS)
+libgstsequences_la_LIBADD = $(GST_PLUGINS_BASE_LIBS) -lgstvideo-@GST_API_VERSION@ $(GST_BASE_LIBS) $(GST_LIBS) $(GIO_LIBS)
+libgstsequences_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)
+libgstsequences_la_LIBTOOLFLAGS = $(GST_PLUGIN_LIBTOOLFLAGS)
+
+noinst_HEADERS = gstimagesequencesrc.h 
+
+
+Android.mk: Makefile.am $(BUILT_SOURCES)
+	androgenizer \
+	-:PROJECT libgstsequences -:SHARED libgstsequences \
+	 -:TAGS eng debug \
+         -:REL_TOP $(top_srcdir) -:ABS_TOP $(abs_top_srcdir) \
+	 -:SOURCES $(libgstsequences_la_SOURCES) \
+	 -:CFLAGS $(DEFS) $(DEFAULT_INCLUDES) $(libgstsequences_la_CFLAGS) \
+	 -:LDFLAGS $(libgstsequences_la_LDFLAGS) \
+	           $(libgstsequences_la_LIBADD) \
+	           -ldl \
+	 -:PASSTHROUGH LOCAL_ARM_MODE:=arm \
+		       LOCAL_MODULE_PATH:='$$(TARGET_OUT)/lib/gstreamer-0.10' \
+	> $@
diff --git a/gst/sequences/gstimagesequence.c b/gst/sequences/gstimagesequence.c
new file mode 100644
index 0000000..1649bdc
--- /dev/null
+++ b/gst/sequences/gstimagesequence.c
@@ -0,0 +1,42 @@
+/* GStreamer
+ * Copyright (C) 2014 <cfoch.fabian@gmail.com>
+ *
+ * gstimagesequence.c:
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+
+#include <gst/gst.h>
+
+#include "gstimagesequencesrc.h"
+
+
+static gboolean
+plugin_init (GstPlugin * plugin)
+{
+  return gst_element_register (plugin, "imagesequencesrc", GST_RANK_NONE,
+      gst_imagesequencesrc_get_type ());
+}
+
+GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
+    GST_VERSION_MINOR,
+    imagesequence,
+    "Reads/Writes buffers from sequentially named image files",
+    plugin_init, VERSION, "LGPL", PACKAGE_NAME, GST_PACKAGE_ORIGIN)
diff --git a/gst/sequences/gstimagesequencesrc.c b/gst/sequences/gstimagesequencesrc.c
new file mode 100644
index 0000000..de74ad2
--- /dev/null
+++ b/gst/sequences/gstimagesequencesrc.c
@@ -0,0 +1,735 @@
+/* GStreamer
+ * Copyright (C) 2014 <cfoch.fabian@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Suite 500,
+ * Boston, MA 02110-1335, USA.
+ */
+/**
+ * SECTION:element-gstimagesequencesrc
+ *
+ * Reads buffers from sequentially named files. 
+ *
+ * <refsect2>
+ * <title>Example launch line</title>
+ * |[
+ * gst-launch-1.0 -v  imagesequencesrc location="*.png" framerate="24/1" ! decodebin ! videoconvert ! xvimagesink
+ * ]|
+ * Plays a sequence of all images which matches the given location at 24 fps.
+ * </refsect2>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <gst/gst.h>
+#include <gio/gio.h>
+#include <stdlib.h>
+#include "gstimagesequencesrc.h"
+
+/* prototypes */
+static GstFlowReturn gst_imagesequencesrc_create (GstPushSrc * src,
+    GstBuffer ** buffer);
+static void gst_imagesequencesrc_set_property (GObject * object,
+    guint property_id, const GValue * value, GParamSpec * pspec);
+static void gst_imagesequencesrc_get_property (GObject * object,
+    guint property_id, GValue * value, GParamSpec * pspec);
+static void gst_imagesequencesrc_dispose (GObject * object);
+static GstCaps *gst_imagesequencesrc_getcaps (GstBaseSrc * bsrc,
+    GstCaps * filter);
+static gboolean gst_imagesequencesrc_query (GstBaseSrc * bsrc,
+    GstQuery * query);
+
+/* pad templates */
+static GstStaticPadTemplate gst_imagesequencesrc_src_template =
+GST_STATIC_PAD_TEMPLATE ("src",
+    GST_PAD_SRC,
+    GST_PAD_ALWAYS,
+    GST_STATIC_CAPS_ANY);
+
+/* Utilities */
+static void gst_imagesequencesrc_parse_uri (GstImageSequenceSrc * src,
+    const gchar * uri);
+static void gst_imagesequencesrc_set_duration (GstImageSequenceSrc * src);
+static void gst_imagesequencesrc_set_caps (GstImageSequenceSrc * src,
+    GstCaps * value);
+
+GST_DEBUG_CATEGORY_STATIC (gst_imagesequencesrc_debug_category);
+#define GST_CAT_DEFAULT gst_imagesequencesrc_debug_category
+
+enum
+{
+  PROP_0,
+  PROP_LOCATION,
+  PROP_INDEX,
+  PROP_START_INDEX,
+  PROP_STOP_INDEX,
+  PROP_FRAMERATE,
+  PROP_LOOP,
+  PROP_FILENAMES
+};
+
+#define DEFAULT_LOCATION "."
+#define DEFAULT_FRAMERATE "1/1"
+#define DEFAULT_INDEX 0
+#define DEFAULT_START 0
+#define DEFAULT_STOP 0
+
+
+static void gst_imagesequencesrc_uri_handler_init (gpointer g_iface,
+    gpointer iface_data);
+
+#define _do_init \
+  G_IMPLEMENT_INTERFACE (GST_TYPE_URI_HANDLER, gst_imagesequencesrc_uri_handler_init); \
+  GST_DEBUG_CATEGORY_INIT (gst_imagesequencesrc_debug_category, "imagesequencesrc", 0, "imagesequencesrc element");
+#define gst_imagesequencesrc_parent_class parent_class
+
+G_DEFINE_TYPE_WITH_CODE (GstImageSequenceSrc, gst_imagesequencesrc,
+    GST_TYPE_PUSH_SRC, _do_init);
+
+static gboolean
+is_seekable (GstBaseSrc * bsrc)
+{
+  GstImageSequenceSrc *src = GST_IMAGESEQUENCESRC (bsrc);
+
+  if (src->filenames != NULL)
+    return TRUE;
+  return FALSE;
+}
+
+static gboolean
+do_seek (GstBaseSrc * bsrc, GstSegment * segment)
+{
+  /* FIXME: Improve precision of seeking */
+
+  gboolean reverse;
+  GstClockTime position;
+  GstImageSequenceSrc *src;
+
+  src = GST_IMAGESEQUENCESRC (bsrc);
+
+  segment->time = segment->start;
+  position = segment->position;
+  reverse = segment->rate < 0;
+
+  if (reverse) {
+    GST_FIXME_OBJECT (src, "Handle reverse playback");
+
+    return FALSE;
+  }
+  /* now move to the position indicated */
+  if (src->fps_n) {
+    src->index = gst_util_uint64_scale (position,
+        src->fps_n, src->fps_d * GST_SECOND);
+  } else {
+    src->index = 0;
+    GST_WARNING_OBJECT (src, "No FPS set, can not seek");
+
+    return FALSE;
+  }
+
+  return TRUE;
+}
+
+static void
+gst_imagesequencesrc_class_init (GstImageSequenceSrcClass * klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+  GstPushSrcClass *gstpushsrc_class = GST_PUSH_SRC_CLASS (klass);
+  GstBaseSrcClass *gstbasesrc_class = GST_BASE_SRC_CLASS (klass);
+  GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);
+
+  gobject_class->set_property = gst_imagesequencesrc_set_property;
+  gobject_class->get_property = gst_imagesequencesrc_get_property;
+
+  /* Setting properties */
+  g_object_class_install_property (gobject_class, PROP_LOCATION,
+      g_param_spec_string ("location", "File Location",
+          "Pattern to create image-sequence video. This pattern looks like: \n"
+          "1) /some/folder/with/images/ or .\n"
+          "2) /a/path/img.jpg,/other/path/img2.jpg or img1.png,img2.png \n"
+          "3) /a/path/*.JPEG or *.png", DEFAULT_LOCATION,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+  g_object_class_install_property (gobject_class, PROP_FRAMERATE,
+      g_param_spec_string ("framerate", "Framerate",
+          "Set the framerate to caps.", DEFAULT_FRAMERATE,
+          G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS));
+  g_object_class_install_property (gobject_class, PROP_LOOP,
+      g_param_spec_boolean ("loop", "Loop",
+          "Whether to repeat from the beginning when all files have been read.",
+          FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+  g_object_class_install_property (gobject_class, PROP_FILENAMES,
+      g_param_spec_pointer ("filenames-list", "Filenames GList",
+          "Set a list of filenames directly instead of a location pattern."
+          "If you *get* the current list, you will obtain a copy of it.",
+          G_PARAM_READWRITE));
+  g_object_class_install_property (gobject_class, PROP_INDEX,
+      g_param_spec_int ("index", "File Index",
+          "Index to use with location property to create file names.  The "
+          "index is incremented by one for each buffer read.",
+          0, INT_MAX, DEFAULT_INDEX,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+  g_object_class_install_property (gobject_class, PROP_START_INDEX,
+      g_param_spec_int ("start-index", "Start Index",
+          "Start value of index.  The initial value of index can be set "
+          "either by setting index or start-index.  When the end of the loop "
+          "is reached, the index will be set to the value start-index.",
+          0, INT_MAX, DEFAULT_START,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+  g_object_class_install_property (gobject_class, PROP_STOP_INDEX,
+      g_param_spec_int ("stop-index", "Stop Index",
+          "Stop value of index.  The special value -1 means no stop.",
+          -1, INT_MAX, DEFAULT_STOP,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+
+  /* Setting up pads and setting metadata should be moved to
+     base_class_init if you intend to subclass this class. */
+  gst_element_class_add_pad_template (gstelement_class,
+      gst_static_pad_template_get (&gst_imagesequencesrc_src_template));
+
+  gst_element_class_set_static_metadata (gstelement_class,
+      "ImageSequenceSrc plugin", "Src/File", "FIXME Description",
+      "Fabian Orccon <cfoch.fabian@gmail.com>");
+
+  gstbasesrc_class->get_caps = gst_imagesequencesrc_getcaps;
+  gstbasesrc_class->query = gst_imagesequencesrc_query;
+  gstbasesrc_class->is_seekable = is_seekable;
+  gstbasesrc_class->do_seek = do_seek;
+
+  gstpushsrc_class->create = gst_imagesequencesrc_create;
+
+  gobject_class->dispose = gst_imagesequencesrc_dispose;
+}
+
+static void
+gst_imagesequencesrc_init (GstImageSequenceSrc * src)
+{
+  src->duration = GST_CLOCK_TIME_NONE;
+  src->location = g_strdup (DEFAULT_LOCATION);
+  src->filenames = NULL;
+  src->index = 0;
+  src->start_index = 0;
+  src->stop_index = 0;
+  src->fps_n = src->fps_d = -1;
+}
+
+static GstCaps *
+gst_imagesequencesrc_getcaps (GstBaseSrc * bsrc, GstCaps * filter)
+{
+  GstImageSequenceSrc *src = GST_IMAGESEQUENCESRC (bsrc);
+
+  GST_DEBUG_OBJECT (src, "returning %" GST_PTR_FORMAT, src->caps);
+
+  if (src->caps) {
+    if (filter)
+      return gst_caps_intersect_full (filter, src->caps,
+          GST_CAPS_INTERSECT_FIRST);
+    else
+      return gst_caps_ref (src->caps);
+  } else {
+    if (filter)
+      return gst_caps_ref (filter);
+    else
+      return gst_caps_new_any ();
+  }
+}
+
+static gboolean
+gst_imagesequencesrc_query (GstBaseSrc * bsrc, GstQuery * query)
+{
+  gboolean ret;
+  GstImageSequenceSrc *src;
+
+  src = GST_IMAGESEQUENCESRC (bsrc);
+
+  switch (GST_QUERY_TYPE (query)) {
+    case GST_QUERY_DURATION:
+    {
+      GstFormat format;
+
+      gst_query_parse_duration (query, &format, NULL);
+
+      switch (format) {
+        case GST_FORMAT_TIME:
+          if (src->filenames != NULL) {
+            gst_query_set_duration (query, format, src->duration);
+          } else {
+            gst_query_set_duration (query, format, -1);
+          }
+          ret = TRUE;
+          break;
+        default:
+          ret = GST_BASE_SRC_CLASS (parent_class)->query (bsrc, query);
+      }
+      break;
+    }
+    default:
+      ret = GST_BASE_SRC_CLASS (parent_class)->query (bsrc, query);
+      break;
+  }
+
+  return ret;
+}
+
+static const gchar *
+gst_imagesequencesrc_get_mime (GstImageSequenceSrc * src)
+{
+  gchar *mime;
+  gchar *filename;
+
+  if (!src->iter_list)
+    return NULL;
+
+  filename = (gchar *) src->iter_list->data;
+  mime = g_content_type_guess (filename, NULL, 9, NULL);
+
+  return mime;
+}
+
+static gboolean
+gst_imagesequencesrc_set_location (GstImageSequenceSrc * src,
+    const gchar * location)
+{
+  g_free (src->location);
+  if (location != NULL) {
+    src->location = g_strdup (location);
+
+    if (g_strrstr (src->location, "*.") != NULL) {
+      /* case: '*.png' */
+      gchar **tokens;
+      gchar *path, *extension;
+
+      tokens = g_strsplit (src->location, "*.", 2);
+      path = tokens[0];
+      extension = tokens[1];
+
+      if (extension) {
+        GDir *directory;
+        GError *error = NULL;
+
+        if (g_strcmp0 (g_strdup (path), "") == 0)
+          path = g_strdup (".");
+
+        directory = g_dir_open (path, 0, &error);
+        if (directory) {
+          const gchar *afilename;
+          const gchar *absolute_path;
+
+          while ((afilename = g_dir_read_name (directory)) != NULL) {
+            if (g_pattern_match_simple (g_strconcat ("*.", extension, NULL),
+                    afilename)) {
+              absolute_path = g_strconcat (path, "/", afilename, NULL);
+              src->filenames = g_list_insert_sorted (src->filenames,
+                  g_strdup (absolute_path), (GCompareFunc) g_strcmp0);
+            }
+          }
+          g_dir_close (directory);
+        }
+        g_free (error);
+        g_strfreev (tokens);
+      }
+    } else if (g_strrstr (src->location, ",")) {
+      /* case: '1.png,2.png,3.png,8.png,10.png' */
+      gchar **tokens;
+      gint i;
+
+      /* Spliting filenames separated by commas. */
+      tokens = g_strsplit (src->location, ",", 0);
+
+      i = 0;
+      while (tokens[i] != NULL) {
+        gchar *filename;
+
+        filename = tokens[i];
+        src->filenames = g_list_append (src->filenames, g_strdup (filename));
+        i++;
+      }
+    } else {
+      GDir *directory;
+      GError *error = NULL;
+
+      directory = g_dir_open (src->location, 0, &error);
+      if (directory) {
+        const gchar *afilename;
+        const gchar *absolute_path;
+        /* FIXME: Consider only a valid mime type image */
+
+        while ((afilename = g_dir_read_name (directory)) != NULL) {
+          absolute_path = g_strconcat (src->location, "/", afilename, NULL);
+          src->filenames = g_list_insert_sorted (src->filenames,
+              g_strdup (absolute_path), (GCompareFunc) g_strcmp0);
+        }
+        g_dir_close (directory);
+      }
+    }
+  } else {
+    src->location = NULL;
+  }
+
+  /* Set src->stop value */
+  src->stop_index = g_list_length (src->filenames) - 1;
+
+  return TRUE;
+}
+
+static void
+gst_imagesequencesrc_set_duration (GstImageSequenceSrc * src)
+{
+  /* Calculating duration */
+  src->duration = GST_SECOND * (src->stop_index - src->start_index + 1) *
+      src->fps_d / src->fps_n;
+}
+
+static void
+gst_imagesequencesrc_set_caps (GstImageSequenceSrc * src, GstCaps * caps)
+{
+  GstCaps *new_caps;
+  if (caps == NULL) {
+    if (src->iter_list) {
+      const gchar *mime = gst_imagesequencesrc_get_mime (src);
+      new_caps = gst_caps_new_simple (mime,
+          "framerate", GST_TYPE_FRACTION, src->fps_n, src->fps_d, NULL);
+    } else {
+      new_caps = gst_caps_new_any ();
+    }
+  } else {
+    new_caps = gst_caps_copy (caps);
+  }
+
+  gst_caps_replace (&src->caps, new_caps);
+  gst_pad_set_caps (GST_BASE_SRC_PAD (src), new_caps);
+}
+
+void
+gst_imagesequencesrc_set_property (GObject * object, guint property_id,
+    const GValue * value, GParamSpec * pspec)
+{
+  GstImageSequenceSrc *src = GST_IMAGESEQUENCESRC (object);
+
+  GST_DEBUG_OBJECT (src, "set_property");
+
+  switch (property_id) {
+    case PROP_LOCATION:
+      gst_imagesequencesrc_set_location (src, g_value_get_string (value));
+      break;
+    case PROP_FRAMERATE:
+    {
+      const gchar *mime;
+      gchar *strcaps;
+      GstCaps *caps;
+      GstStructure *st;
+
+      mime = gst_imagesequencesrc_get_mime (src);
+
+      /* FIXME: This is hacky */
+      if (!mime)
+        mime = "image/jpeg";
+
+      strcaps = g_strconcat (mime, ",",
+          "framerate=", g_value_get_string (value), NULL);
+
+      caps = gst_caps_from_string (strcaps);
+
+      st = gst_caps_get_structure (caps, 0);
+
+      /* Set src->fps_n and src->fps_d values */
+      gst_structure_get_fraction (st, "framerate", &src->fps_n, &src->fps_d);
+
+      g_free (strcaps);
+    }
+      break;
+    case PROP_INDEX:
+      src->index = g_value_get_int (value);
+      break;
+    case PROP_START_INDEX:
+    {
+      guint max_start = g_list_length (src->filenames) - 1;
+
+      src->start_index = g_value_get_int (value);
+
+      g_assert (src->start_index >= 0 && max_start >= 0);
+      g_assert (src->start_index <= max_start);
+
+      /* Move index to the start */
+      src->index = g_value_get_int (value);
+      src->iter_list = g_list_nth (src->filenames, src->index);
+      break;
+    }
+    case PROP_STOP_INDEX:
+    {
+      guint max_stop = g_list_length (src->filenames) - 1;
+
+      src->stop_index = g_value_get_int (value);
+
+      g_assert (src->stop_index >= 0 && max_stop >= 0);
+      g_assert (src->stop_index >= src->index && src->stop_index <= max_stop);
+      break;
+    }
+    case PROP_LOOP:
+      src->loop = g_value_get_boolean (value);
+      break;
+    case PROP_FILENAMES:
+    {
+      src->iter_list = NULL;
+      src->index = 0;
+      g_list_free_full (src->filenames, g_free);
+      src->filenames = g_value_get_pointer (value);
+    }
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+  }
+}
+
+void
+gst_imagesequencesrc_get_property (GObject * object, guint property_id,
+    GValue * value, GParamSpec * pspec)
+{
+  GstImageSequenceSrc *src = GST_IMAGESEQUENCESRC (object);
+
+  GST_DEBUG_OBJECT (src, "get_property");
+
+  switch (property_id) {
+    case PROP_LOCATION:
+      g_value_set_string (value, src->location);
+      break;
+    case PROP_INDEX:
+      g_value_set_int (value, src->index);
+      break;
+    case PROP_LOOP:
+      g_value_set_boolean (value, src->loop);
+      break;
+    case PROP_FILENAMES:
+    {
+      GList *ret_filenames;
+      ret_filenames =
+          g_list_copy_deep (src->filenames, (GCopyFunc) g_strdup, NULL);
+      g_value_set_pointer (value, ret_filenames);
+    }
+      break;
+    case PROP_START_INDEX:
+      g_value_set_int (value, src->start_index);
+      break;
+    case PROP_STOP_INDEX:
+      g_value_set_int (value, src->stop_index);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+  }
+}
+
+static void
+gst_imagesequencesrc_dispose (GObject * object)
+{
+  GstImageSequenceSrc *src = GST_IMAGESEQUENCESRC (object);
+
+  g_free (src->location);
+  src->location = NULL;
+  if (src->caps)
+    gst_caps_unref (src->caps);
+  g_list_free_full (src->filenames, g_free);
+  g_free (src->framerate);
+
+  G_OBJECT_CLASS (parent_class)->dispose (object);
+}
+
+static GstFlowReturn
+gst_imagesequencesrc_create (GstPushSrc * bsrc, GstBuffer ** buffer)
+{
+  GstImageSequenceSrc *src;
+  gsize size;
+  gchar *data;
+  gchar *filename;
+  GstBuffer *buf;
+  gboolean ret;
+  GError *error = NULL;
+
+  src = GST_IMAGESEQUENCESRC (bsrc);
+
+  g_assert (src->filenames != NULL);
+
+
+  if (src->index > src->stop_index) {
+    if (src->loop) {
+      src->index = src->start_index;
+    } else {
+      src->index--;
+      return GST_FLOW_EOS;
+    }
+  }
+  if (src->index == src->start_index) {
+    src->iter_list = g_list_nth (src->filenames, src->index);
+  }
+
+  if ((src->index == src->start_index) && (!src->caps)) {
+    gst_imagesequencesrc_set_duration (src);
+    gst_imagesequencesrc_set_caps (src, NULL);
+  }
+
+  filename = (gchar *) src->iter_list->data;
+
+  GST_DEBUG_OBJECT (src, "reading from file \"%s\".", filename);
+
+  ret = g_file_get_contents (filename, &data, &size, &error);
+
+  if (!ret)
+    goto handle_error;
+
+  buf = gst_buffer_new ();
+  gst_buffer_append_memory (buf,
+      gst_memory_new_wrapped (0, data, size, 0, size, data, g_free));
+  GST_BUFFER_OFFSET (buf) = src->offset;
+  GST_BUFFER_OFFSET_END (buf) = src->offset + size;
+  src->offset += size;
+
+  GST_DEBUG_OBJECT (src, "read file \"%s\".", filename);
+
+  *buffer = buf;
+
+  src->iter_list = src->iter_list->next;
+  src->index++;
+  return GST_FLOW_OK;
+
+handle_error:
+  {
+    if (error != NULL) {
+      GST_ELEMENT_ERROR (src, RESOURCE, READ,
+          ("Error while reading from file \"%s\".", filename),
+          ("%s", error->message));
+      g_error_free (error);
+    } else {
+      GST_ELEMENT_ERROR (src, RESOURCE, READ,
+          ("Error while reading from file \"%s\".", filename),
+          ("%s", g_strerror (errno)));
+    }
+    g_free (filename);
+    return GST_FLOW_ERROR;
+  }
+}
+
+/**************** GstURIHandlerInterface ******************/
+
+static GstURIType
+gst_imagesequencesrc_uri_get_type (GType type)
+{
+  return GST_URI_SRC;
+}
+
+static const gchar *const *
+gst_imagesequencesrc_uri_get_protocols (GType type)
+{
+  static const gchar *protocols[] = { GST_IMAGESEQUENCE_URI_PROTOCOL, NULL };
+
+  return protocols;
+}
+
+static gchar *
+gst_imagesequencesrc_uri_get_uri (GstURIHandler * handler)
+{
+  GstImageSequenceSrc *src = GST_IMAGESEQUENCESRC (handler);
+
+  return src->uri;
+}
+
+static gboolean
+gst_imagesequencesrc_uri_set_uri (GstURIHandler * handler, const gchar * uri,
+    GError ** err)
+{
+  GstImageSequenceSrc *src = GST_IMAGESEQUENCESRC (handler);
+
+  src->uri = g_strdup (uri);
+  gst_imagesequencesrc_parse_uri (src, uri);
+  return TRUE;
+}
+
+static void
+gst_imagesequencesrc_uri_handler_init (gpointer g_iface, gpointer iface_data)
+{
+  GstURIHandlerInterface *iface = (GstURIHandlerInterface *) g_iface;
+
+  iface->get_type = gst_imagesequencesrc_uri_get_type;
+  iface->get_protocols = gst_imagesequencesrc_uri_get_protocols;
+  iface->get_uri = gst_imagesequencesrc_uri_get_uri;
+  iface->set_uri = gst_imagesequencesrc_uri_set_uri;
+}
+
+
+/**
+  * gst_imagesequencesrc_parse_uri
+  *
+  * Reads start/stop index and location from a imagesequence uri.
+  * URL-like pattern
+  * gst-launch imagesequencesrc uri="imagesequence:///a/path/%d.png?framerate=1/1"
+  *
+  */
+
+static void
+gst_imagesequencesrc_parse_uri (GstImageSequenceSrc * src, const gchar * uri)
+{
+  gchar **tokens1, **tokens2;
+  gchar *prefix, *uri_params;
+
+  prefix = g_strconcat (GST_IMAGESEQUENCE_URI_PROTOCOL, "://", NULL);
+
+  tokens1 = g_strsplit (uri, prefix, 0);
+
+  uri_params = tokens1[1];
+  tokens2 = g_strsplit (uri_params, "?", 0);
+
+  /* Set the location */
+  g_object_set (src, "location", g_strdup (tokens2[0]), NULL);
+
+  if (tokens2[1]) {
+    gchar **param_values;
+    gchar **param_value;
+    const gchar *param;
+    const gchar *value;
+    gint i;
+
+    param_values = g_strsplit (tokens2[1], "&", 0);
+    i = 0;
+
+    while (param_values[i]) {
+      param_value = g_strsplit (param_values[i], "=", 0);
+
+      param = param_value[0];
+      value = param_value[1];
+
+      if (g_strcmp0 (param, "index") == 0) {
+        gint index = atoi (value);
+        g_object_set (src, "index", index, NULL);
+      } else if (g_strcmp0 (param, "start-index") == 0) {
+        gint start_index = atoi (value);
+        g_object_set (src, "start-index", start_index, NULL);
+      } else if (g_strcmp0 (param, "stop-index") == 0) {
+        gint stop_index = atoi (value);
+        g_object_set (src, "stop-index", stop_index, NULL);
+      } else if (g_strcmp0 (param, "framerate") == 0) {
+        g_object_set (src, "framerate", value, NULL);
+      } else if (g_strcmp0 (param, "loop") == 0) {
+        gboolean loop = atoi (value);
+        g_object_set (src, "loop", loop, NULL);
+      }
+      i++;
+      g_strfreev (param_value);
+    }
+    g_strfreev (param_values);
+  }
+
+  g_strfreev (tokens1);
+  g_strfreev (tokens2);
+}
diff --git a/gst/sequences/gstimagesequencesrc.h b/gst/sequences/gstimagesequencesrc.h
new file mode 100644
index 0000000..68e9780
--- /dev/null
+++ b/gst/sequences/gstimagesequencesrc.h
@@ -0,0 +1,68 @@
+/* GStreamer
+ * Copyright (C) 2014 <cfoch.fabian@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef _GST_IMAGESEQUENCESRC_H_
+#define _GST_IMAGESEQUENCESRC_H_
+
+#include <gst/gst.h>
+#include <gst/base/gstpushsrc.h>
+
+G_BEGIN_DECLS
+
+#define GST_TYPE_IMAGESEQUENCESRC   (gst_imagesequencesrc_get_type())
+#define GST_IMAGESEQUENCESRC(obj)   (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_IMAGESEQUENCESRC,GstImageSequenceSrc))
+#define GST_IMAGESEQUENCESRC_CLASS(klass)   (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_IMAGESEQUENCESRC,GstImageSequenceSrcClass))
+#define GST_IS_IMAGESEQUENCESRC(obj)   (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_IMAGESEQUENCESRC))
+#define GST_IS_IMAGESEQUENCESRC_CLASS(obj)   (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_IMAGESEQUENCESRC))
+
+typedef struct _GstImageSequenceSrc GstImageSequenceSrc;
+typedef struct _GstImageSequenceSrcClass GstImageSequenceSrcClass;
+
+struct _GstImageSequenceSrc
+{
+  GstPushSrc parent;
+  GstCaps *caps;
+  GList *filenames;
+  GList *iter_list;
+  int offset;
+  GstClockTime duration;
+  gint fps_n, fps_d;
+  gchar *uri;
+
+  /* properties */
+  gchar *location;
+  guint index;
+  guint start_index;
+  guint stop_index;
+  gchar *framerate;
+  gboolean loop;
+};
+
+struct _GstImageSequenceSrcClass
+{
+  GstPushSrcClass parent_class;
+};
+
+#define GST_IMAGESEQUENCE_URI_PROTOCOL "imagesequence"
+
+G_GNUC_INTERNAL GType gst_imagesequencesrc_get_type (void);
+
+G_END_DECLS
+
+#endif
