rawparse: Add new raw audio and video parser elements

The new rawaudioparse and rawvideoparse elements are based on GstBaseParse
and completely replace audioparse and videoparse

https://bugzilla.gnome.org/show_bug.cgi?id=767011

12 files changed, 3649 insertions, 2 deletions

diff --git a/gst/rawparse/Makefile.am b/gst/rawparse/Makefile.am
index 3bd843867..f3ad3c414 100644
--- a/gst/rawparse/Makefile.am
+++ b/gst/rawparse/Makefile.am
@@ -4,8 +4,12 @@ plugin_LTLIBRARIES = libgstrawparse.la
 libgstrawparse_la_SOURCES = \
 	gstrawparse.c \
 	gstunalignedaudioparse.c \
+	gstunalignedvideoparse.c \
 	gstaudioparse.c \
 	gstvideoparse.c \
+	gstrawbaseparse.c \
+	gstrawaudioparse.c \
+	gstrawvideoparse.c \
 	plugin.c
 libgstrawparse_la_CFLAGS = \
 		$(GST_PLUGINS_BASE_CFLAGS) \
@@ -21,7 +25,12 @@ libgstrawparse_la_LIBTOOLFLAGS = $(GST_PLUGIN_LIBTOOLFLAGS)
 
 noinst_HEADERS = \
 	unalignedaudio.h \
+	unalignedvideo.h \
 	gstunalignedaudioparse.h \
+	gstunalignedvideoparse.h \
 	gstaudioparse.h \
 	gstrawparse.h \
-	gstvideoparse.h
+	gstvideoparse.h \
+	gstrawbaseparse.h \
+	gstrawaudioparse.h \
+	gstrawvideoparse.h
diff --git a/gst/rawparse/gstrawaudioparse.c b/gst/rawparse/gstrawaudioparse.c
new file mode 100644
index 000000000..d955f0e59
--- /dev/null
+++ b/gst/rawparse/gstrawaudioparse.c
@@ -0,0 +1,1088 @@
+/* GStreamer
+ * Copyright (C) <2016> Carlos Rafael Giani <dv at pseudoterminal dot org>
+ *
+ * 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.
+ */
+
+/**
+ * SECTION:element-rawaudioparse
+ *
+ * This element parses incoming data as raw audio samples and timestamps it.
+ * It also handles seek queries in said raw audio data, and ensures that output
+ * buffers contain an integer number of samples, even if the input buffers don't.
+ * For example, with sample format S16LE and 2 channels, an input buffer of 411
+ * bytes contains 102.75 samples. rawaudioparse will then output 102 samples
+ * (= 408 bytes) and keep the remaining 3 bytes. These will then be prepended to
+ * the next input data.
+ *
+ * The element implements the properties and sink caps configuration as specified
+ * in the #GstRawBaseParse documentation. The properties configuration can be
+ * modified by using the sample-rate, num-channels, channel-positions, format,
+ * and pcm-format properties.
+ *
+ * Currently, this parser supports raw data in a-law, mu-law, or linear PCM format.
+ *
+ * To facilitate operation with the unalignedaudioparse element, rawaudioparse
+ * supports the "audio/x-unaligned-raw" media type. This is treated identically to
+ * "audio/x-raw", except that it is used by source elements which do not guarantee
+ * that the buffers they push out are timestamped and contain an integer amount of
+ * samples (see the 411 bytes example above). By using a different media type, it
+ * is guaranteed that unalignedaudioparse is autoplugged, making sure that the
+ * autoplugged chain does not push unparsed content downstream. The source caps'
+ * media type with linear PCM data is always "audio/x-raw", even if the sink caps
+ * use "audio/x-unaligned-raw".
+ *
+ * The channel-positions property can be used to set explicit position information
+ * for each channel. If the array that is passed to this property does not match
+ * the number of channels indicated by num-channels, then said number of channels
+ * is updated to the array length. If channel-positions is NULL, then the default
+ * GStreamer positioning is used. This property is also useful for swapping left
+ * and right in a stereo signal for example.
+ *
+ * <refsect2>
+ * <title>Example pipelines</title>
+ * |[
+ * gst-launch-1.0 souphttpsrc http://my-dlna-server/track.l16 \
+ *     rawaudioparse ! audioconvert ! audioresample ! autoaudiosink
+ * ]| Receive L16 data from a DLNA server, parse and timestamp it with
+ * rawaudioparse, and play it. use-sink-caps is set to true since souphttpsrc
+ * will set its source pad's caps to audio/x-unaligned-raw for the L16 stream.
+ * |[
+ * gst-launch-1.0 filesrc location=audio.raw ! rawaudioparse use-sink-caps=false \
+ *         format=pcm pcm-format=s16le sample-rate=48000 num-channels=2 \
+ *         audioconvert ! audioresample ! autoaudiosink
+ * ]| Read raw data from a local file and parse it as PCM data with 48000 Hz sample
+ * rate, signed 16 bit integer samples, and 2 channels. use-sink-caps is set to
+ * false to ensure the property information is used and the parser does not expect
+ * audio/x-raw or audio/x-unaligned-raw caps.
+ * </refsect2>
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+
+/* FIXME: GValueArray is deprecated, but there is currently no viabla alternative
+ * See https://bugzilla.gnome.org/show_bug.cgi?id=667228 */
+#define GLIB_DISABLE_DEPRECATION_WARNINGS
+
+#include <string.h>
+#include "gstrawaudioparse.h"
+#include "unalignedaudio.h"
+
+
+GST_DEBUG_CATEGORY_STATIC (raw_audio_parse_debug);
+#define GST_CAT_DEFAULT raw_audio_parse_debug
+
+
+enum
+{
+  PROP_0,
+  PROP_FORMAT,
+  PROP_PCM_FORMAT,
+  PROP_SAMPLE_RATE,
+  PROP_NUM_CHANNELS,
+  PROP_INTERLEAVED,
+  PROP_CHANNEL_POSITIONS
+};
+
+
+#define DEFAULT_FORMAT         GST_RAW_AUDIO_PARSE_FORMAT_PCM
+#define DEFAULT_PCM_FORMAT     GST_AUDIO_FORMAT_S16
+#define DEFAULT_SAMPLE_RATE    44100
+#define DEFAULT_NUM_CHANNELS   2
+#define DEFAULT_INTERLEAVED    TRUE
+
+
+#define GST_RAW_AUDIO_PARSE_CAPS \
+  GST_AUDIO_CAPS_MAKE(GST_AUDIO_FORMATS_ALL) \
+  ", layout = (string) { interleaved, non-interleaved }; " \
+  "audio/x-alaw, rate = (int) [ 1, MAX ], channels = (int) [ 1, MAX ]; " \
+  "audio/x-mulaw, rate = (int) [ 1, MAX ], channels = (int) [ 1, MAX ]; "
+
+
+static GstStaticPadTemplate static_sink_template =
+    GST_STATIC_PAD_TEMPLATE ("sink",
+    GST_PAD_SINK,
+    GST_PAD_ALWAYS,
+    GST_STATIC_CAPS (GST_UNALIGNED_RAW_AUDIO_CAPS "; " GST_RAW_AUDIO_PARSE_CAPS)
+    );
+
+
+static GstStaticPadTemplate static_src_template =
+GST_STATIC_PAD_TEMPLATE ("src",
+    GST_PAD_SRC,
+    GST_PAD_ALWAYS,
+    GST_STATIC_CAPS (GST_RAW_AUDIO_PARSE_CAPS)
+    );
+
+
+#define gst_raw_audio_parse_parent_class parent_class
+G_DEFINE_TYPE (GstRawAudioParse, gst_raw_audio_parse, GST_TYPE_RAW_BASE_PARSE);
+
+
+static void gst_raw_audio_parse_set_property (GObject * object, guint prop_id,
+    GValue const *value, GParamSpec * pspec);
+static void gst_raw_audio_parse_get_property (GObject * object, guint prop_id,
+    GValue * value, GParamSpec * pspec);
+
+static gboolean gst_raw_audio_parse_stop (GstBaseParse * parse);
+
+static gboolean gst_raw_audio_parse_set_current_config (GstRawBaseParse *
+    raw_base_parse, GstRawBaseParseConfig config);
+static GstRawBaseParseConfig
+gst_raw_audio_parse_get_current_config (GstRawBaseParse * raw_base_parse);
+static gboolean gst_raw_audio_parse_set_config_from_caps (GstRawBaseParse *
+    raw_base_parse, GstRawBaseParseConfig config, GstCaps * caps);
+static gboolean gst_raw_audio_parse_get_caps_from_config (GstRawBaseParse *
+    raw_base_parse, GstRawBaseParseConfig config, GstCaps ** caps);
+static gsize gst_raw_audio_parse_get_config_frame_size (GstRawBaseParse *
+    raw_base_parse, GstRawBaseParseConfig config);
+static gboolean gst_raw_audio_parse_is_config_ready (GstRawBaseParse *
+    raw_base_parse, GstRawBaseParseConfig config);
+static gboolean gst_raw_audio_parse_process (GstRawBaseParse * raw_base_parse,
+    GstRawBaseParseConfig config, GstBuffer * in_data, gsize total_num_in_bytes,
+    gsize num_valid_in_bytes, GstBuffer ** processed_data);
+static gboolean gst_raw_audio_parse_is_unit_format_supported (GstRawBaseParse *
+    raw_base_parse, GstFormat format);
+static void gst_raw_audio_parse_get_units_per_second (GstRawBaseParse *
+    raw_base_parse, GstFormat format, GstRawBaseParseConfig config,
+    gsize * units_per_sec_n, gsize * units_per_sec_d);
+
+static gboolean gst_raw_audio_parse_is_using_sink_caps (GstRawAudioParse *
+    raw_audio_parse);
+static GstRawAudioParseConfig
+    * gst_raw_audio_parse_get_config_ptr (GstRawAudioParse * raw_audio_parse,
+    GstRawBaseParseConfig config);
+
+static void gst_raw_audio_parse_init_config (GstRawAudioParseConfig * config);
+static gboolean gst_raw_audio_parse_set_config_channels (GstRawAudioParseConfig
+    * config, guint num_channels, guint64 channel_mask, gboolean set_positions);
+static gboolean
+gst_raw_audio_parse_update_channel_reordering_flag (GstRawAudioParseConfig *
+    config);
+static void gst_raw_audio_parse_update_config_bpf (GstRawAudioParseConfig *
+    config);
+static gboolean gst_raw_audio_parse_caps_to_config (GstRawAudioParse *
+    raw_audio_parse, GstCaps * caps, GstRawAudioParseConfig * config);
+static gboolean gst_raw_audio_parse_config_to_caps (GstRawAudioParse *
+    raw_audio_parse, GstCaps ** caps, GstRawAudioParseConfig * config);
+
+
+
+static void
+gst_raw_audio_parse_class_init (GstRawAudioParseClass * klass)
+{
+  GObjectClass *object_class;
+  GstElementClass *element_class;
+  GstBaseParseClass *baseparse_class;
+  GstRawBaseParseClass *rawbaseparse_class;
+
+  GST_DEBUG_CATEGORY_INIT (raw_audio_parse_debug, "rawaudioparse", 0,
+      "rawaudioparse element");
+
+  object_class = G_OBJECT_CLASS (klass);
+  element_class = GST_ELEMENT_CLASS (klass);
+  baseparse_class = GST_BASE_PARSE_CLASS (klass);
+  rawbaseparse_class = GST_RAW_BASE_PARSE_CLASS (klass);
+
+  gst_element_class_add_pad_template (element_class,
+      gst_static_pad_template_get (&static_sink_template));
+  gst_element_class_add_pad_template (element_class,
+      gst_static_pad_template_get (&static_src_template));
+
+  object_class->set_property =
+      GST_DEBUG_FUNCPTR (gst_raw_audio_parse_set_property);
+  object_class->get_property =
+      GST_DEBUG_FUNCPTR (gst_raw_audio_parse_get_property);
+
+  baseparse_class->stop = GST_DEBUG_FUNCPTR (gst_raw_audio_parse_stop);
+
+  rawbaseparse_class->set_current_config =
+      GST_DEBUG_FUNCPTR (gst_raw_audio_parse_set_current_config);
+  rawbaseparse_class->get_current_config =
+      GST_DEBUG_FUNCPTR (gst_raw_audio_parse_get_current_config);
+  rawbaseparse_class->set_config_from_caps =
+      GST_DEBUG_FUNCPTR (gst_raw_audio_parse_set_config_from_caps);
+  rawbaseparse_class->get_caps_from_config =
+      GST_DEBUG_FUNCPTR (gst_raw_audio_parse_get_caps_from_config);
+  rawbaseparse_class->get_config_frame_size =
+      GST_DEBUG_FUNCPTR (gst_raw_audio_parse_get_config_frame_size);
+  rawbaseparse_class->is_config_ready =
+      GST_DEBUG_FUNCPTR (gst_raw_audio_parse_is_config_ready);
+  rawbaseparse_class->process = GST_DEBUG_FUNCPTR (gst_raw_audio_parse_process);
+  rawbaseparse_class->is_unit_format_supported =
+      GST_DEBUG_FUNCPTR (gst_raw_audio_parse_is_unit_format_supported);
+  rawbaseparse_class->get_units_per_second =
+      GST_DEBUG_FUNCPTR (gst_raw_audio_parse_get_units_per_second);
+
+  g_object_class_install_property (object_class,
+      PROP_FORMAT,
+      g_param_spec_enum ("format",
+          "Format",
+          "Format of the raw audio stream",
+          gst_raw_audio_parse_format_get_type (),
+          GST_RAW_AUDIO_PARSE_FORMAT_PCM,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
+      );
+  g_object_class_install_property (object_class,
+      PROP_PCM_FORMAT,
+      g_param_spec_enum ("pcm-format",
+          "PCM format",
+          "Format of audio samples in PCM stream (ignored if format property is not set to pcm)",
+          GST_TYPE_AUDIO_FORMAT,
+          GST_RAW_AUDIO_PARSE_FORMAT_PCM,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
+      );
+  g_object_class_install_property (object_class,
+      PROP_SAMPLE_RATE,
+      g_param_spec_int ("sample-rate",
+          "Sample rate",
+          "Rate of audio samples in raw stream",
+          1, INT_MAX,
+          DEFAULT_SAMPLE_RATE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
+      );
+  g_object_class_install_property (object_class,
+      PROP_NUM_CHANNELS,
+      g_param_spec_int ("num-channels",
+          "Number of channels",
+          "Number of channels in raw stream",
+          1, INT_MAX,
+          DEFAULT_NUM_CHANNELS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
+      );
+  g_object_class_install_property (object_class,
+      PROP_INTERLEAVED,
+      g_param_spec_boolean ("interleaved",
+          "Interleaved layout",
+          "True if audio has interleaved layout",
+          DEFAULT_INTERLEAVED, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
+      );
+  g_object_class_install_property (object_class,
+      PROP_CHANNEL_POSITIONS,
+      g_param_spec_value_array ("channel-positions",
+          "Channel positions",
+          "Channel positions used on the output",
+          g_param_spec_enum ("channel-position",
+              "Channel position",
+              "Channel position of the n-th input",
+              GST_TYPE_AUDIO_CHANNEL_POSITION,
+              GST_AUDIO_CHANNEL_POSITION_NONE,
+              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS),
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
+      );
+
+  gst_element_class_set_static_metadata (element_class,
+      "rawaudioparse",
+      "Codec/Parser/Audio",
+      "Converts unformatted data streams into timestamped raw audio frames",
+      "Carlos Rafael Giani <dv@pseudoterminal.org>");
+}
+
+
+static void
+gst_raw_audio_parse_init (GstRawAudioParse * raw_audio_parse)
+{
+  /* Setup configs and select which one shall be the current one from the start. */
+  gst_raw_audio_parse_init_config (&(raw_audio_parse->properties_config));
+  gst_raw_audio_parse_init_config (&(raw_audio_parse->sink_caps_config));
+  /* As required by GstRawBaseParse, ensure that the current configuration
+   * is initially set to be the properties config */
+  raw_audio_parse->current_config = &(raw_audio_parse->properties_config);
+
+  /* Properties config must be valid from the start, so set its ready value
+   * to TRUE, and make sure its bpf value is valid. */
+  raw_audio_parse->properties_config.ready = TRUE;
+  gst_raw_audio_parse_update_config_bpf (&(raw_audio_parse->properties_config));
+}
+
+
+static void
+gst_raw_audio_parse_set_property (GObject * object, guint prop_id,
+    GValue const *value, GParamSpec * pspec)
+{
+  GstBaseParse *base_parse = GST_BASE_PARSE (object);
+  GstRawBaseParse *raw_base_parse = GST_RAW_BASE_PARSE (object);
+  GstRawAudioParse *raw_audio_parse = GST_RAW_AUDIO_PARSE (object);
+
+  /* All properties are handled similarly:
+   * - if the new value is the same as the current value, nothing is done
+   * - the parser lock is held while the new value is set
+   * - if the properties config is the current config, the source caps are
+   *   invalidated to ensure that the code in handle_frame pushes a new CAPS
+   *   event out
+   * - properties that affect the bpf value call the function to update
+   *   the bpf and also call gst_base_parse_set_min_frame_size() to ensure
+   *   that the minimum frame size can hold 1 frame (= one sample for each
+   *   channel)
+   */
+
+  switch (prop_id) {
+    case PROP_FORMAT:
+    {
+      GstRawAudioParseFormat new_format = g_value_get_enum (value);
+
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object);
+
+      if (new_format != raw_audio_parse->properties_config.format) {
+        raw_audio_parse->properties_config.format = new_format;
+        gst_raw_audio_parse_update_config_bpf (&
+            (raw_audio_parse->properties_config));
+
+        if (!gst_raw_audio_parse_is_using_sink_caps (raw_audio_parse)) {
+          gst_raw_base_parse_invalidate_src_caps (raw_base_parse);
+          gst_base_parse_set_min_frame_size (base_parse,
+              raw_audio_parse->properties_config.bpf);
+        }
+      }
+
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+      break;
+    }
+
+    case PROP_PCM_FORMAT:
+    {
+      GstAudioFormat new_pcm_format = g_value_get_enum (value);
+
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object);
+
+      if (new_pcm_format != raw_audio_parse->properties_config.pcm_format) {
+        raw_audio_parse->properties_config.pcm_format = new_pcm_format;
+        gst_raw_audio_parse_update_config_bpf (&
+            (raw_audio_parse->properties_config));
+
+        if (!gst_raw_audio_parse_is_using_sink_caps (raw_audio_parse)) {
+          gst_raw_base_parse_invalidate_src_caps (raw_base_parse);
+          gst_base_parse_set_min_frame_size (base_parse,
+              raw_audio_parse->properties_config.bpf);
+        }
+      }
+
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+      break;
+    }
+
+    case PROP_SAMPLE_RATE:
+    {
+      guint new_sample_rate = g_value_get_int (value);
+
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object);
+
+      if (new_sample_rate != raw_audio_parse->properties_config.sample_rate) {
+        raw_audio_parse->properties_config.sample_rate = new_sample_rate;
+
+        if (!gst_raw_audio_parse_is_using_sink_caps (raw_audio_parse))
+          gst_raw_base_parse_invalidate_src_caps (raw_base_parse);
+      }
+
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+      break;
+    }
+
+    case PROP_NUM_CHANNELS:
+    {
+      guint new_num_channels = g_value_get_int (value);
+
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object);
+
+      if (new_num_channels != raw_audio_parse->properties_config.num_channels) {
+        gst_raw_audio_parse_set_config_channels (&
+            (raw_audio_parse->properties_config), new_num_channels, 0, TRUE);
+
+        raw_audio_parse->properties_config.num_channels = new_num_channels;
+        gst_raw_audio_parse_update_config_bpf (&
+            (raw_audio_parse->properties_config));
+
+        if (!gst_raw_audio_parse_is_using_sink_caps (raw_audio_parse)) {
+          gst_raw_base_parse_invalidate_src_caps (raw_base_parse);
+          gst_base_parse_set_min_frame_size (base_parse,
+              raw_audio_parse->properties_config.bpf);
+        }
+      }
+
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+      break;
+    }
+
+    case PROP_INTERLEAVED:
+    {
+      gboolean new_interleaved = g_value_get_boolean (value);
+
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object);
+
+      if (new_interleaved != raw_audio_parse->properties_config.interleaved) {
+        raw_audio_parse->properties_config.interleaved = new_interleaved;
+
+        if (!gst_raw_audio_parse_is_using_sink_caps (raw_audio_parse))
+          gst_raw_base_parse_invalidate_src_caps (raw_base_parse);
+      }
+
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+      break;
+    }
+
+    case PROP_CHANNEL_POSITIONS:
+    {
+      GValueArray *valarray = g_value_get_boxed (value);
+      GstRawAudioParseConfig *config = &(raw_audio_parse->properties_config);
+
+      /* Sanity check - reject empty arrays */
+      if ((valarray != NULL) && (valarray->n_values == 0)) {
+        GST_ELEMENT_ERROR (raw_audio_parse, LIBRARY, SETTINGS,
+            ("channel position property holds an empty array"), (NULL));
+        break;
+      }
+
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object);
+
+      if ((valarray == NULL) && (config->num_channels > 0)) {
+        /* NULL value given, and number of channels is nonzero.
+         * Use the default GStreamer positioning. Call
+         * set_config_channels with the set_positions parameter
+         * set to TRUE to ensure the position values are filled. */
+        gst_raw_audio_parse_set_config_channels (&
+            (raw_audio_parse->properties_config), config->num_channels, 0,
+            TRUE);
+      } else {
+        /* Non-NULL value given. Make sure the channel_positions
+         * array in the properties config has enough room, and that
+         * the num_channels value equals the array length. Then copy
+         * the values from the valarray to channel_positions, and
+         * produce a copy of that array in case its channel positions
+         * are not in a valid GStreamer order (to be able to apply
+         * channel reordering later).
+         */
+
+        guint i;
+
+        if (valarray->n_values != config->num_channels) {
+          /* Call with set_positions == FALSE to ensure that
+           * the array is properly allocated but not filled
+           * (it is filled below) */
+          gst_raw_audio_parse_set_config_channels (config, valarray->n_values,
+              0, FALSE);
+        }
+
+        for (i = 0; i < config->num_channels; ++i) {
+          GValue *val = g_value_array_get_nth (valarray, i);
+          config->channel_positions[i] = g_value_get_enum (val);
+        }
+
+        gst_raw_audio_parse_update_channel_reordering_flag (config);
+      }
+
+      gst_raw_audio_parse_update_config_bpf (&
+          (raw_audio_parse->properties_config));
+
+      if (!gst_raw_audio_parse_is_using_sink_caps (raw_audio_parse)) {
+        gst_raw_base_parse_invalidate_src_caps (raw_base_parse);
+        gst_base_parse_set_min_frame_size (base_parse,
+            raw_audio_parse->properties_config.bpf);
+      }
+
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+      break;
+    }
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+  }
+}
+
+
+static void
+gst_raw_audio_parse_get_property (GObject * object, guint prop_id,
+    GValue * value, GParamSpec * pspec)
+{
+  GstRawAudioParse *raw_audio_parse = GST_RAW_AUDIO_PARSE (object);
+
+  switch (prop_id) {
+    case PROP_FORMAT:
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object);
+      g_value_set_enum (value, raw_audio_parse->properties_config.format);
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+      break;
+
+    case PROP_PCM_FORMAT:
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object);
+      g_value_set_enum (value, raw_audio_parse->properties_config.pcm_format);
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+      break;
+
+    case PROP_SAMPLE_RATE:
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object);
+      g_value_set_int (value, raw_audio_parse->properties_config.sample_rate);
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+      break;
+
+    case PROP_NUM_CHANNELS:
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object);
+      g_value_set_int (value, raw_audio_parse->properties_config.num_channels);
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+      break;
+
+    case PROP_INTERLEAVED:
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object);
+      g_value_set_boolean (value,
+          raw_audio_parse->properties_config.interleaved);
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+      break;
+
+    case PROP_CHANNEL_POSITIONS:
+    {
+      GstRawAudioParseConfig *config;
+      GValueArray *valarray;
+
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object);
+
+      valarray = NULL;
+      config = &(raw_audio_parse->properties_config);
+
+      /* Copy channel positions into the valuearray */
+      if (config->num_channels > 0) {
+        guint i;
+        GValue val = G_VALUE_INIT;
+        g_assert (config->channel_positions);
+
+        g_value_init (&val, GST_TYPE_AUDIO_CHANNEL_POSITION);
+        valarray = g_value_array_new (config->num_channels);
+
+        for (i = 0; i < config->num_channels; ++i) {
+          g_value_set_enum (&val, config->channel_positions[i]);
+          g_value_array_insert (valarray, i, &val);
+        }
+
+        g_value_unset (&val);
+      }
+
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+
+      /* Pass on ownership to the value array,
+       * since we don't need it anymore */
+      g_value_take_boxed (value, valarray);
+
+      break;
+    }
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+  }
+}
+
+
+static gboolean
+gst_raw_audio_parse_stop (GstBaseParse * parse)
+{
+  GstRawAudioParse *raw_audio_parse = GST_RAW_AUDIO_PARSE (parse);
+
+  /* Sink caps config is not ready until caps come in.
+   * We are stopping processing, the element is being reset,
+   * so the config has to be un-readied.
+   * (Since the properties config is not depending on caps,
+   * its ready status is always TRUE.) */
+  raw_audio_parse->sink_caps_config.ready = FALSE;
+
+  return GST_BASE_PARSE_CLASS (parent_class)->stop (parse);
+}
+
+
+static gboolean
+gst_raw_audio_parse_set_current_config (GstRawBaseParse * raw_base_parse,
+    GstRawBaseParseConfig config)
+{
+  GstRawAudioParse *raw_audio_parse = GST_RAW_AUDIO_PARSE (raw_base_parse);
+
+  switch (config) {
+    case GST_RAW_BASE_PARSE_CONFIG_PROPERTIES:
+      raw_audio_parse->current_config = &(raw_audio_parse->properties_config);
+      break;
+
+    case GST_RAW_BASE_PARSE_CONFIG_SINKCAPS:
+      raw_audio_parse->current_config = &(raw_audio_parse->sink_caps_config);
+      break;
+
+    default:
+      g_assert_not_reached ();
+  }
+
+  return TRUE;
+}
+
+
+static GstRawBaseParseConfig
+gst_raw_audio_parse_get_current_config (GstRawBaseParse * raw_base_parse)
+{
+  GstRawAudioParse *raw_audio_parse = GST_RAW_AUDIO_PARSE (raw_base_parse);
+  return gst_raw_audio_parse_is_using_sink_caps (raw_audio_parse) ?
+      GST_RAW_BASE_PARSE_CONFIG_SINKCAPS : GST_RAW_BASE_PARSE_CONFIG_PROPERTIES;
+}
+
+
+static gboolean
+gst_raw_audio_parse_set_config_from_caps (GstRawBaseParse * raw_base_parse,
+    GstRawBaseParseConfig config, GstCaps * caps)
+{
+  GstRawAudioParse *raw_audio_parse = GST_RAW_AUDIO_PARSE (raw_base_parse);
+  return gst_raw_audio_parse_caps_to_config (raw_audio_parse, caps,
+      gst_raw_audio_parse_get_config_ptr (raw_audio_parse, config));
+}
+
+
+static gboolean
+gst_raw_audio_parse_get_caps_from_config (GstRawBaseParse * raw_base_parse,
+    GstRawBaseParseConfig config, GstCaps ** caps)
+{
+  GstRawAudioParse *raw_audio_parse = GST_RAW_AUDIO_PARSE (raw_base_parse);
+  return gst_raw_audio_parse_config_to_caps (raw_audio_parse, caps,
+      gst_raw_audio_parse_get_config_ptr (raw_audio_parse, config));
+}
+
+
+static gsize
+gst_raw_audio_parse_get_config_frame_size (GstRawBaseParse * raw_base_parse,
+    GstRawBaseParseConfig config)
+{
+  GstRawAudioParse *raw_audio_parse = GST_RAW_AUDIO_PARSE (raw_base_parse);
+  return gst_raw_audio_parse_get_config_ptr (raw_audio_parse, config)->bpf;
+}
+
+
+static gboolean
+gst_raw_audio_parse_is_config_ready (GstRawBaseParse * raw_base_parse,
+    GstRawBaseParseConfig config)
+{
+  GstRawAudioParse *raw_audio_parse = GST_RAW_AUDIO_PARSE (raw_base_parse);
+  return gst_raw_audio_parse_get_config_ptr (raw_audio_parse, config)->ready;
+}
+
+
+static gboolean
+gst_raw_audio_parse_process (GstRawBaseParse * raw_base_parse,
+    GstRawBaseParseConfig config, GstBuffer * in_data, gsize total_num_in_bytes,
+    gsize num_valid_in_bytes, GstBuffer ** processed_data)
+{
+  GstRawAudioParse *raw_audio_parse = GST_RAW_AUDIO_PARSE (raw_base_parse);
+  GstRawAudioParseConfig *config_ptr =
+      gst_raw_audio_parse_get_config_ptr (raw_audio_parse, config);
+
+  if ((config_ptr->format == GST_RAW_AUDIO_PARSE_FORMAT_PCM)
+      && config_ptr->needs_channel_reordering) {
+    /* Need to reorder samples, since they are in an invalid
+     * channel order. */
+
+    GstBuffer *outbuf;
+
+    GST_LOG_OBJECT (raw_audio_parse,
+        "using %" G_GSIZE_FORMAT " bytes out of the %" G_GSIZE_FORMAT
+        " bytes from the input buffer with reordering", num_valid_in_bytes,
+        total_num_in_bytes);
+
+    outbuf =
+        gst_buffer_copy_region (in_data,
+        GST_BUFFER_COPY_FLAGS | GST_BUFFER_COPY_TIMESTAMPS |
+        GST_BUFFER_COPY_META | GST_BUFFER_COPY_MEMORY, 0, num_valid_in_bytes);
+
+    gst_audio_buffer_reorder_channels (outbuf,
+        config_ptr->pcm_format,
+        config_ptr->num_channels,
+        config_ptr->channel_positions, config_ptr->reordered_channel_positions);
+
+    *processed_data = outbuf;
+  } else {
+    /* Nothing needs to be done with the sample data.
+     * Instruct the baseparse class to just take out_size bytes
+     * from the input buffer */
+
+    GST_LOG_OBJECT (raw_audio_parse,
+        "using %" G_GSIZE_FORMAT " bytes out of the %" G_GSIZE_FORMAT
+        " bytes from the input buffer without reordering", num_valid_in_bytes,
+        total_num_in_bytes);
+
+    *processed_data = NULL;
+  }
+
+  return TRUE;
+}
+
+
+static gboolean
+gst_raw_audio_parse_is_unit_format_supported (G_GNUC_UNUSED GstRawBaseParse *
+    raw_base_parse, GstFormat format)
+{
+  switch (format) {
+    case GST_FORMAT_BYTES:
+    case GST_FORMAT_DEFAULT:
+      return TRUE;
+    default:
+      return FALSE;
+  }
+}
+
+
+static void
+gst_raw_audio_parse_get_units_per_second (GstRawBaseParse * raw_base_parse,
+    GstFormat format, GstRawBaseParseConfig config, gsize * units_per_sec_n,
+    gsize * units_per_sec_d)
+{
+  GstRawAudioParse *raw_audio_parse = GST_RAW_AUDIO_PARSE (raw_base_parse);
+  GstRawAudioParseConfig *config_ptr =
+      gst_raw_audio_parse_get_config_ptr (raw_audio_parse, config);
+
+  switch (format) {
+    case GST_FORMAT_BYTES:
+      *units_per_sec_n = config_ptr->sample_rate * config_ptr->bpf;
+      *units_per_sec_d = 1;
+      break;
+
+    case GST_FORMAT_DEFAULT:
+      *units_per_sec_n = config_ptr->sample_rate;
+      *units_per_sec_d = 1;
+      break;
+
+    default:
+      g_assert_not_reached ();
+  }
+}
+
+
+static gboolean
+gst_raw_audio_parse_is_using_sink_caps (GstRawAudioParse * raw_audio_parse)
+{
+  return raw_audio_parse->current_config ==
+      &(raw_audio_parse->sink_caps_config);
+}
+
+
+static GstRawAudioParseConfig *
+gst_raw_audio_parse_get_config_ptr (GstRawAudioParse * raw_audio_parse,
+    GstRawBaseParseConfig config)
+{
+  g_assert (raw_audio_parse->current_config != NULL);
+
+  switch (config) {
+    case GST_RAW_BASE_PARSE_CONFIG_PROPERTIES:
+      return &(raw_audio_parse->properties_config);
+
+    case GST_RAW_BASE_PARSE_CONFIG_SINKCAPS:
+      return &(raw_audio_parse->sink_caps_config);
+
+    default:
+      g_assert (raw_audio_parse->current_config != NULL);
+      return raw_audio_parse->current_config;
+  }
+}
+
+
+static void
+gst_raw_audio_parse_init_config (GstRawAudioParseConfig * config)
+{
+  config->ready = FALSE;
+  config->format = DEFAULT_FORMAT;
+  config->pcm_format = DEFAULT_PCM_FORMAT;
+  config->bpf = 0;
+  config->sample_rate = DEFAULT_SAMPLE_RATE;
+  config->num_channels = DEFAULT_NUM_CHANNELS;
+  config->interleaved = DEFAULT_INTERLEAVED;
+  config->needs_channel_reordering = FALSE;
+
+  gst_raw_audio_parse_set_config_channels (config, config->num_channels, 0,
+      TRUE);
+}
+
+
+static gboolean
+gst_raw_audio_parse_set_config_channels (GstRawAudioParseConfig * config,
+    guint num_channels, guint64 channel_mask, gboolean set_positions)
+{
+  g_assert (num_channels > 0);
+
+  config->num_channels = num_channels;
+  /* Setting this to FALSE, since initially, after setting the channels,
+   * the default GStreamer channel ordering is used. */
+  config->needs_channel_reordering = FALSE;
+
+  /* Set the channel positions based on the given channel mask if set_positions
+   * is set to TRUE. A channel mask of 0 signifies that a fallback mask should be
+   * used for the given number of channels. */
+  if (set_positions) {
+    if (channel_mask == 0)
+      channel_mask = gst_audio_channel_get_fallback_mask (config->num_channels);
+
+    return gst_audio_channel_positions_from_mask (config->num_channels,
+        channel_mask, config->channel_positions);
+  } else {
+    return TRUE;
+  }
+}
+
+
+static gboolean
+gst_raw_audio_parse_update_channel_reordering_flag (GstRawAudioParseConfig *
+    config)
+{
+  g_assert (config->num_channels > 0);
+
+  /* If the channel_positions array contains channel positions which are in an
+   * order that conforms to the valid GStreamer order, ensure that channel
+   * reordering is disabled.
+   * Otherwise, if the order of the positions in the channel_positions array
+   * does not conform to the GStreamer order, ensure it is enabled.
+   */
+
+  if (gst_audio_check_valid_channel_positions (config->channel_positions,
+          config->num_channels, TRUE)) {
+
+    config->needs_channel_reordering = FALSE;
+
+    return TRUE;
+  } else {
+    config->needs_channel_reordering = TRUE;
+    memcpy (config->reordered_channel_positions, config->channel_positions,
+        sizeof (GstAudioChannelPosition) * config->num_channels);
+    return
+        gst_audio_channel_positions_to_valid_order
+        (config->reordered_channel_positions, config->num_channels);
+  }
+}
+
+
+static void
+gst_raw_audio_parse_update_config_bpf (GstRawAudioParseConfig * config)
+{
+  switch (config->format) {
+    case GST_RAW_AUDIO_PARSE_FORMAT_PCM:
+    {
+      GstAudioFormatInfo const *fmt_info =
+          gst_audio_format_get_info (config->pcm_format);
+      g_assert (fmt_info != NULL);
+
+      config->bpf =
+          GST_AUDIO_FORMAT_INFO_WIDTH (fmt_info) * config->num_channels / 8;
+
+      break;
+    }
+
+    case GST_RAW_AUDIO_PARSE_FORMAT_ALAW:
+    case GST_RAW_AUDIO_PARSE_FORMAT_MULAW:
+      /* A-law and mu-law both use 1 byte per sample */
+      config->bpf = 1 * config->num_channels;
+      break;
+
+    default:
+      g_assert_not_reached ();
+  }
+}
+
+
+static gboolean
+gst_raw_audio_parse_caps_to_config (GstRawAudioParse * raw_audio_parse,
+    GstCaps * caps, GstRawAudioParseConfig * config)
+{
+  gboolean ret = FALSE;
+  GstStructure *structure;
+
+  /* Caps might get copied, and the copy needs to be unref'd.
+   * Also, the caller retains ownership over the original caps.
+   * So, to make this mechanism also work with cases where the
+   * caps are *not* copied, ref the original caps here first. */
+  gst_caps_ref (caps);
+
+  structure = gst_caps_get_structure (caps, 0);
+
+  /* For unaligned raw data, the output caps stay the same,
+   * except that audio/x-unaligned-raw becomes audio/x-raw,
+   * since the parser aligns the sample data */
+  if (gst_structure_has_name (structure, "audio/x-unaligned-raw")) {
+    /* Copy the caps to be able to modify them */
+    GstCaps *new_caps = gst_caps_copy (caps);
+    gst_caps_unref (caps);
+    caps = new_caps;
+
+    /* Change the media type to audio/x-raw , otherwise
+     * gst_audio_info_from_caps() won't work */
+    structure = gst_caps_get_structure (caps, 0);
+    gst_structure_set_name (structure, "audio/x-raw");
+  }
+
+  if (gst_structure_has_name (structure, "audio/x-raw")) {
+    guint num_channels;
+    GstAudioInfo info;
+    if (!gst_audio_info_from_caps (&info, caps)) {
+      GST_ERROR_OBJECT (raw_audio_parse,
+          "failed to parse caps %" GST_PTR_FORMAT, (gpointer) caps);
+      goto done;
+    }
+
+    num_channels = GST_AUDIO_INFO_CHANNELS (&info);
+
+    config->format = GST_RAW_AUDIO_PARSE_FORMAT_PCM;
+    config->pcm_format = GST_AUDIO_INFO_FORMAT (&info);
+    config->bpf = GST_AUDIO_INFO_BPF (&info);
+    config->sample_rate = GST_AUDIO_INFO_RATE (&info);
+    config->interleaved =
+        (GST_AUDIO_INFO_LAYOUT (&info) == GST_AUDIO_LAYOUT_INTERLEAVED);
+
+    gst_raw_audio_parse_set_config_channels (config, num_channels, 0, FALSE);
+    memcpy (config->channel_positions, &(GST_AUDIO_INFO_POSITION (&info, 0)),
+        sizeof (GstAudioChannelPosition) * num_channels);
+  } else if (gst_structure_has_name (structure, "audio/x-alaw")
+      || gst_structure_has_name (structure, "audio/x-mulaw")) {
+    gint i;
+    guint64 channel_mask;
+    guint num_channels;
+
+    config->format =
+        gst_structure_has_name (structure,
+        "audio/x-alaw") ? GST_RAW_AUDIO_PARSE_FORMAT_ALAW :
+        GST_RAW_AUDIO_PARSE_FORMAT_MULAW;
+
+    if (!gst_structure_get_int (structure, "rate", &i)) {
+      GST_ERROR_OBJECT (raw_audio_parse,
+          "missing rate value in caps %" GST_PTR_FORMAT, (gpointer) caps);
+      goto done;
+    }
+    config->sample_rate = i;
+
+    if (!gst_structure_get_int (structure, "channels", &i)) {
+      GST_ERROR_OBJECT (raw_audio_parse,
+          "missing channels value in caps %" GST_PTR_FORMAT, (gpointer) caps);
+      goto done;
+    }
+    num_channels = i;
+
+    if (!gst_structure_get (structure, "channel-mask", GST_TYPE_BITMASK,
+            &channel_mask, NULL)) {
+      channel_mask = gst_audio_channel_get_fallback_mask (num_channels);
+      GST_DEBUG_OBJECT (raw_audio_parse,
+          "input caps have no channel mask - using fallback mask %#lx for %u channels",
+          channel_mask, num_channels);
+    }
+
+    if (!gst_raw_audio_parse_set_config_channels (config, num_channels,
+            channel_mask, TRUE)) {
+      GST_ERROR_OBJECT (raw_audio_parse,
+          "could not use channel mask %#lx for channel positions",
+          channel_mask);
+      goto done;
+    }
+
+    /* A-law and mu-law both use 1 byte per sample */
+    config->bpf = 1 * num_channels;
+  } else {
+    GST_ERROR_OBJECT (raw_audio_parse,
+        "caps %" GST_PTR_FORMAT " have an unsupported media type",
+        (gpointer) caps);
+    goto done;
+  }
+
+  ret = TRUE;
+
+done:
+  gst_caps_unref (caps);
+  if (ret)
+    config->ready = TRUE;
+  return ret;
+}
+
+
+static gboolean
+gst_raw_audio_parse_config_to_caps (GstRawAudioParse * raw_audio_parse,
+    GstCaps ** caps, GstRawAudioParseConfig * config)
+{
+  gboolean ret = TRUE;
+  GstAudioChannelPosition *channel_positions;
+
+  g_assert (caps != NULL);
+
+  if (config->bpf == 0) {
+    GST_ERROR_OBJECT (raw_audio_parse,
+        "cannot convert config to caps - config not filled with valid values");
+    *caps = NULL;
+    return FALSE;
+  }
+
+  channel_positions =
+      config->needs_channel_reordering ? &(config->
+      reordered_channel_positions[0]) : &(config->channel_positions[0]);
+
+  switch (config->format) {
+    case GST_RAW_AUDIO_PARSE_FORMAT_PCM:
+    {
+      GstAudioInfo info;
+      gst_audio_info_init (&info);
+      gst_audio_info_set_format (&info,
+          config->pcm_format,
+          config->sample_rate, config->num_channels, channel_positions);
+
+      *caps = gst_audio_info_to_caps (&info);
+
+      break;
+    }
+
+    case GST_RAW_AUDIO_PARSE_FORMAT_ALAW:
+    case GST_RAW_AUDIO_PARSE_FORMAT_MULAW:
+    {
+      guint64 channel_mask;
+
+      if (!gst_audio_channel_positions_to_mask (channel_positions,
+              config->num_channels, TRUE, &channel_mask)) {
+        GST_ERROR_OBJECT (raw_audio_parse, "invalid channel positions");
+        ret = FALSE;
+        break;
+      }
+
+      *caps = gst_caps_new_simple (
+          (config->format ==
+              GST_RAW_AUDIO_PARSE_FORMAT_ALAW) ? "audio/x-alaw" :
+          "audio/x-mulaw", "rate", G_TYPE_INT, config->sample_rate, "channels",
+          G_TYPE_INT, config->num_channels, "channel-mask", GST_TYPE_BITMASK,
+          channel_mask, NULL);
+
+      break;
+    }
+
+    default:
+      g_assert_not_reached ();
+      ret = FALSE;
+  }
+
+  if (!ret)
+    *caps = NULL;
+
+  return ret;
+}
+
+
+
+
+GType
+gst_raw_audio_parse_format_get_type (void)
+{
+  static GType audio_parse_format_gtype = 0;
+  static const GEnumValue types[] = {
+    {GST_RAW_AUDIO_PARSE_FORMAT_PCM, "PCM", "pcm"},
+    {GST_RAW_AUDIO_PARSE_FORMAT_ALAW, "A-Law", "alaw"},
+    {GST_RAW_AUDIO_PARSE_FORMAT_MULAW, "\302\265-Law", "mulaw"},
+    {0, NULL, NULL}
+  };
+
+  if (!audio_parse_format_gtype)
+    audio_parse_format_gtype =
+        g_enum_register_static ("GstRawAudioParseFormat", types);
+
+  return audio_parse_format_gtype;
+}
diff --git a/gst/rawparse/gstrawaudioparse.h b/gst/rawparse/gstrawaudioparse.h
new file mode 100644
index 000000000..f1e0766e5
--- /dev/null
+++ b/gst/rawparse/gstrawaudioparse.h
@@ -0,0 +1,131 @@
+/* GStreamer
+ * Copyright (C) <2016> Carlos Rafael Giani <dv at pseudoterminal dot org>
+ *
+ * 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_RAW_AUDIO_PARSE_H__
+#define __GST_RAW_AUDIO_PARSE_H__
+
+#include <gst/gst.h>
+#include <gst/audio/audio.h>
+#include "gstrawbaseparse.h"
+
+G_BEGIN_DECLS
+
+#define GST_TYPE_RAW_AUDIO_PARSE \
+  (gst_raw_audio_parse_get_type())
+#define GST_RAW_AUDIO_PARSE(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj), GST_TYPE_RAW_AUDIO_PARSE, GstRawAudioParse))
+#define GST_RAW_AUDIO_PARSE_CAST(obj) \
+  ((GstRawAudioParse *)(obj))
+#define GST_RAW_AUDIO_PARSE_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_RAW_AUDIO_PARSE, GstRawAudioParseClass))
+#define GST_IS_RAW_AUDIO_PARSE(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj), GST_TYPE_RAW_AUDIO_PARSE))
+#define GST_IS_RAW_AUDIO_PARSE_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_TYPE((klass), GST_TYPE_RAW_AUDIO_PARSE))
+
+
+typedef enum _GstRawAudioParseFormat GstRawAudioParseFormat;
+
+typedef struct _GstRawAudioParseConfig GstRawAudioParseConfig;
+typedef struct _GstRawAudioParse GstRawAudioParse;
+typedef struct _GstRawAudioParseClass GstRawAudioParseClass;
+
+
+enum _GstRawAudioParseFormat
+{
+  GST_RAW_AUDIO_PARSE_FORMAT_PCM,
+  GST_RAW_AUDIO_PARSE_FORMAT_MULAW,
+  GST_RAW_AUDIO_PARSE_FORMAT_ALAW
+};
+
+
+/* Contains information about the sample rate, format, and channel count to use. */
+struct _GstRawAudioParseConfig
+{
+  /* If TRUE, then this configuration is ready to use */
+  gboolean ready;
+  /* Format of the configuration. Can be PCM, a-law, mu-law. */
+  GstRawAudioParseFormat format;
+  /* If format is set to PCM, this specifies the exact PCM format in use.
+   * Meaningless if format is set to anything other than PCM. */
+  GstAudioFormat pcm_format;
+  /* Bytes per frame. Calculated as: bpf = bytes_per_sample * num_channels
+   * Must be nonzero. This is the size of one frame, the value returned
+   * by the GstRawBaseParseClass get_config_frame_size() vfunc. */
+  guint bpf;
+  /* Sample rate in Hz - must be nonzero */
+  guint sample_rate;
+  /* Number of channels - must be nonzero */
+  guint num_channels;
+  /* TRUE if the data is interleaved, FALSE otherwise */
+  gboolean interleaved;
+
+  /* Array of channel positions, one position per channel; its first
+   * num_channels values are valid. They are computed out of the number
+   * of channels if no positions are explicitely given. */
+  GstAudioChannelPosition channel_positions[64];
+
+  /* If the channel_positions are in a valid GStreamer channel order, then
+   * this is not used, and needs_channel_reordering is FALSE. Otherwise,
+   * this contains the same positions as in channel_positions, but in the
+   * order GStreamer expects. needs_channel_reordering will be TRUE in that
+   * case. This is used for reordering samples in outgoing buffers if
+   * necessary. */
+  GstAudioChannelPosition reordered_channel_positions[64];
+
+  /* TRUE if channel reordering is necessary, FALSE otherwise. See above
+   * for details. */
+  gboolean needs_channel_reordering;
+};
+
+
+struct _GstRawAudioParse
+{
+  GstRawBaseParse parent;
+
+  /*< private > */
+
+  /* Configuration controlled by the object properties. Its ready value
+   * is set to TRUE from the start, so it can be used right away.
+   */
+  GstRawAudioParseConfig properties_config;
+  /* Configuration controlled by the sink caps. Its ready value is
+   * initially set to FALSE until valid sink caps come in. It is set to
+   * FALSE again when the stream-start event is observed.
+   */
+  GstRawAudioParseConfig sink_caps_config;
+  /* Currently active configuration. Points either to properties_config
+   * or to sink_caps_config. This is never NULL. */
+  GstRawAudioParseConfig *current_config;
+};
+
+
+struct _GstRawAudioParseClass
+{
+  GstRawBaseParseClass parent_class;
+};
+
+
+GType gst_raw_audio_parse_get_type (void);
+GType gst_raw_audio_parse_format_get_type (void);
+
+
+G_END_DECLS
+
+#endif
diff --git a/gst/rawparse/gstrawbaseparse.c b/gst/rawparse/gstrawbaseparse.c
new file mode 100644
index 000000000..e90f400fa
--- /dev/null
+++ b/gst/rawparse/gstrawbaseparse.c
@@ -0,0 +1,748 @@
+/* GStreamer
+ * Copyright (C) <2016> Carlos Rafael Giani <dv at pseudoterminal dot org>
+ *
+ * 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.
+ */
+
+/**
+ * SECTION:gstrawbaseparse
+ * @short_description: Base class for raw media data parsers
+ *
+ * This base class is for parsers which read raw media data and output
+ * timestamped buffers with an integer number of frames inside.
+ *
+ * The format of the raw media data is specified in one of two ways: either,
+ * the information from the sink pad's caps is taken, or the information from
+ * the properties is used (this is chosen by the use-sink-caps property).
+ * These two ways are internally referred to as "configurations". The configuration
+ * that receives its information from the sink pad's caps is called the
+ * "sink caps configuration", while the one that depends on the information from
+ * the properties is the "properties configuration". Configurations have a
+ * "readiness". A configuration is "ready" when it contains valid information.
+ * For example, with an audio parser, a configuration is not ready unless it
+ * contains a valid sample rate, sample format, and channel count.
+ *
+ * The properties configuration must always be ready, even right from the start.
+ * Subclasses must ensure this. The underlying reason is that properties have valid
+ * values right from the start, and with the properties configuration, there is
+ * nothing that readies it before actual data is sent (unlike with the sink caps
+ * configuration, where a sink caps event will ready it before data is pushed
+ * downstream).
+ *
+ * It is possible to switch between the configurations during a stream by
+ * setting the use-sink-caps property. Subclasses typically allow for updating the
+ * properties configuration during a stream by setting the various properties
+ * (like sample-rate for a raw audio parser).
+ * In these cases, the parser will produce a new CAPS event and push it downstream
+ * to announce the caps for the new configuration. This also happens if the sink
+ * caps change.
+ *
+ * A common mistake when trying to parse raw data with no input caps (for example,
+ * a file with raw PCM samples when using rawaudioparse) is to forget to set the
+ * use-sink-caps property to FALSE. In this case, the parser will report an error
+ * when it tries to access the current configuration (because then the sink caps
+ * configuration will be the current one and it will not contain valid values
+ * since no sink caps were seen at this point).
+ *
+ * Subclasses must ensure that the properties configuration is the default one.
+ *
+ * The sink caps configuration is mostly useful with push-based sources, because these
+ * will produce caps events and send them downstream. With pull-based sources, it is
+ * possible that this doesn't happen. Since the sink caps configuration requires a caps
+ * event to arrive at the sinkpad, this will cause the parser to fail then.
+ *
+ * The base class identifies the configurations by means of the GstRawAudioParseConfig
+ * enum. It instructs the subclass to switch between configurations this way, and
+ * also requests information about the current configuration, a configuration's
+ * frame size, its readiness, etc. Subclasses are not required to use any particular
+ * structure for the configuration implementations.
+ *
+ * Use the GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK and GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK
+ * macros to protect configuration modifications.
+ *
+ * <listitem>
+ *   <itemizedlist>
+ *   <title>Summary of the subclass requirements</title>
+ *     <listitem><para>
+ *       Sink caps and properties configurations must both be
+ *       implemented and supported. It must also be ensured that there is a
+ *       "current" configuration.
+ *     </para></listitem>
+ *       Modifications to the configurations must be protected with the
+ *       GstRawBaseParse lock. This is typically necessary when the
+ *       properties configuration is modified by setting new property values.
+ *       (Note that the lock is held during *all* vfunc calls.)
+ *     <listitem><para>
+ *       If the properties configuration is updated (typically by
+ *       setting new property values), gst_raw_base_parse_invalidate_src_caps()
+ *       must be called if the properties config is the current one. This is
+ *       necessary to ensure that GstBaseParse pushes a new caps event downstream
+ *       which contains caps from the updated configuration.
+ *     </para></listitem>
+ *     <listitem><para>
+ *       In case there are bytes in each frame that aren't part of the actual
+ *       payload, the get_overhead_size() vfunc must be defined, and the
+ *       @get_config_frame_size() vfunc must return a frame size that includes
+ *       the number of non-payload bytes (= the overhead). Otherwise, the
+ *       timestamps will incorrectly include the overhead bytes.
+ *     </para></listitem>
+ * </listitem>
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+
+#include <string.h>
+#include "gstrawbaseparse.h"
+
+
+GST_DEBUG_CATEGORY_STATIC (raw_base_parse_debug);
+#define GST_CAT_DEFAULT raw_base_parse_debug
+
+
+enum
+{
+  PROP_0,
+  PROP_USE_SINK_CAPS
+};
+
+
+#define DEFAULT_USE_SINK_CAPS  FALSE
+#define INITIAL_PARSER_CONFIG \
+  ((DEFAULT_USE_SINK_CAPS) ? GST_RAW_BASE_PARSE_CONFIG_SINKCAPS : \
+   GST_RAW_BASE_PARSE_CONFIG_PROPERTIES)
+
+
+#define gst_raw_base_parse_parent_class parent_class
+G_DEFINE_ABSTRACT_TYPE (GstRawBaseParse, gst_raw_base_parse,
+    GST_TYPE_BASE_PARSE);
+
+
+static void gst_raw_base_parse_finalize (GObject * object);
+static void gst_raw_base_parse_set_property (GObject * object, guint prop_id,
+    GValue const *value, GParamSpec * pspec);
+static void gst_raw_base_parse_get_property (GObject * object, guint prop_id,
+    GValue * value, GParamSpec * pspec);
+static gboolean gst_raw_base_parse_start (GstBaseParse * parse);
+static gboolean gst_raw_base_parse_stop (GstBaseParse * parse);
+static gboolean gst_raw_base_parse_set_sink_caps (GstBaseParse * parse,
+    GstCaps * caps);
+static GstFlowReturn gst_raw_base_parse_handle_frame (GstBaseParse * parse,
+    GstBaseParseFrame * frame, gint * skipsize);
+static gboolean gst_raw_base_parse_convert (GstBaseParse * parse,
+    GstFormat src_format, gint64 src_value, GstFormat dest_format,
+    gint64 * dest_value);
+
+static gboolean gst_raw_base_parse_is_using_sink_caps (GstRawBaseParse *
+    raw_base_parse);
+static gboolean gst_raw_base_parse_is_gstformat_supported (GstRawBaseParse *
+    raw_base_parse, GstFormat format);
+
+
+
+static void
+gst_raw_base_parse_class_init (GstRawBaseParseClass * klass)
+{
+  GObjectClass *object_class;
+  GstBaseParseClass *baseparse_class;
+
+  GST_DEBUG_CATEGORY_INIT (raw_base_parse_debug, "rawbaseparse", 0,
+      "raw base parse class");
+
+  object_class = G_OBJECT_CLASS (klass);
+  baseparse_class = GST_BASE_PARSE_CLASS (klass);
+
+  object_class->finalize = GST_DEBUG_FUNCPTR (gst_raw_base_parse_finalize);
+  object_class->set_property =
+      GST_DEBUG_FUNCPTR (gst_raw_base_parse_set_property);
+  object_class->get_property =
+      GST_DEBUG_FUNCPTR (gst_raw_base_parse_get_property);
+
+  baseparse_class->start = GST_DEBUG_FUNCPTR (gst_raw_base_parse_start);
+  baseparse_class->stop = GST_DEBUG_FUNCPTR (gst_raw_base_parse_stop);
+  baseparse_class->set_sink_caps =
+      GST_DEBUG_FUNCPTR (gst_raw_base_parse_set_sink_caps);
+  baseparse_class->handle_frame =
+      GST_DEBUG_FUNCPTR (gst_raw_base_parse_handle_frame);
+  baseparse_class->convert = GST_DEBUG_FUNCPTR (gst_raw_base_parse_convert);
+
+  /**
+   * GstRawBaseParse::use-sink-caps:
+   *
+   * Use sink caps configuration. If set to false, the parser
+   * will use the properties configuration instead. It is possible
+   * to switch between these during playback.
+   */
+  g_object_class_install_property (object_class,
+      PROP_USE_SINK_CAPS,
+      g_param_spec_boolean ("use-sink-caps",
+          "Use sink caps",
+          "Use the sink caps for defining the output format",
+          DEFAULT_USE_SINK_CAPS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
+      );
+}
+
+
+static void
+gst_raw_base_parse_init (GstRawBaseParse * raw_base_parse)
+{
+  raw_base_parse->src_caps_set = FALSE;
+  g_mutex_init (&(raw_base_parse->config_mutex));
+}
+
+
+static void
+gst_raw_base_parse_finalize (GObject * object)
+{
+  GstRawBaseParse *raw_base_parse = GST_RAW_BASE_PARSE (object);
+
+  g_mutex_clear (&(raw_base_parse->config_mutex));
+
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+
+static void
+gst_raw_base_parse_set_property (GObject * object, guint prop_id,
+    GValue const *value, GParamSpec * pspec)
+{
+  GstBaseParse *base_parse = GST_BASE_PARSE (object);
+  GstRawBaseParse *raw_base_parse = GST_RAW_BASE_PARSE (object);
+  GstRawBaseParseClass *klass = GST_RAW_BASE_PARSE_GET_CLASS (object);
+
+  g_assert (klass->is_config_ready);
+  g_assert (klass->set_current_config);
+
+  switch (prop_id) {
+    case PROP_USE_SINK_CAPS:
+    {
+      gboolean new_state, cur_state;
+      GstRawBaseParseConfig new_config;
+
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object);
+
+      /* Check to ensure nothing is done if the value stays the same */
+      new_state = g_value_get_boolean (value);
+      cur_state = gst_raw_base_parse_is_using_sink_caps (raw_base_parse);
+      if (new_state == cur_state) {
+        GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+        break;
+      }
+
+      GST_DEBUG_OBJECT (raw_base_parse, "switching to %s config",
+          new_state ? "sink caps" : "properties");
+      new_config =
+          new_state ? GST_RAW_BASE_PARSE_CONFIG_SINKCAPS :
+          GST_RAW_BASE_PARSE_CONFIG_PROPERTIES;
+
+      if (!klass->set_current_config (raw_base_parse, new_config)) {
+        GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+        GST_ELEMENT_ERROR (raw_base_parse, STREAM, FAILED,
+            ("could not set new current config"), ("use-sink-caps property: %d",
+                new_state));
+        break;
+      }
+
+      /* Update the minimum frame size if the config is ready. This ensures that
+       * the next buffer that is passed to handle_frame contains complete frames.
+       * If the current config is the properties config, then it will always be
+       * ready, and its frame size will be valid. Ensure that the baseparse minimum
+       * frame size is set properly then.
+       * If the current config is the sink caps config, then it will initially not
+       * be ready until the sink caps are set, so the minimum frame size cannot be
+       * set right here. However, since the caps always come in *before* the actual
+       * data, the config will be readied in the set_sink_caps function, and be ready
+       * by the time handle_frame is called. There, the minimum frame size is set as
+       * well. */
+      if (klass->is_config_ready (raw_base_parse,
+              GST_RAW_BASE_PARSE_CONFIG_CURRENT)) {
+        gsize frame_size = klass->get_config_frame_size (raw_base_parse,
+            GST_RAW_BASE_PARSE_CONFIG_CURRENT);
+        gst_base_parse_set_min_frame_size (base_parse, frame_size);
+      }
+
+      /* Since the current config was switched, the source caps change. Ensure the
+       * new caps are pushed downstream by setting src_caps_set to FALSE: This way,
+       * the next handle_frame call will take care of that. */
+      raw_base_parse->src_caps_set = FALSE;
+
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+
+      break;
+    }
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+  }
+}
+
+
+static void
+gst_raw_base_parse_get_property (GObject * object, guint prop_id,
+    GValue * value, GParamSpec * pspec)
+{
+  GstRawBaseParse *raw_base_parse = GST_RAW_BASE_PARSE (object);
+
+  switch (prop_id) {
+    case PROP_USE_SINK_CAPS:
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object);
+      g_value_set_boolean (value,
+          gst_raw_base_parse_is_using_sink_caps (raw_base_parse));
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+  }
+}
+
+
+static gboolean
+gst_raw_base_parse_start (GstBaseParse * parse)
+{
+  GstBaseParse *base_parse = GST_BASE_PARSE (parse);
+  GstRawBaseParse *raw_base_parse = GST_RAW_BASE_PARSE (parse);
+  GstRawBaseParseClass *klass = GST_RAW_BASE_PARSE_GET_CLASS (parse);
+
+  g_assert (klass->set_current_config);
+
+  GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (raw_base_parse);
+
+  /* If the config is ready from the start, set the min frame size
+   * (this will happen with the properties config) */
+  if (klass->is_config_ready (raw_base_parse,
+          GST_RAW_BASE_PARSE_CONFIG_CURRENT)) {
+    gsize frame_size = klass->get_config_frame_size (raw_base_parse,
+        GST_RAW_BASE_PARSE_CONFIG_CURRENT);
+    gst_base_parse_set_min_frame_size (base_parse, frame_size);
+  }
+
+  GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (raw_base_parse);
+
+  return TRUE;
+}
+
+
+static gboolean
+gst_raw_base_parse_stop (GstBaseParse * parse)
+{
+  GstRawBaseParse *raw_base_parse = GST_RAW_BASE_PARSE (parse);
+
+  GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (raw_base_parse);
+  raw_base_parse->src_caps_set = FALSE;
+  GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (raw_base_parse);
+
+  return TRUE;
+}
+
+
+static gboolean
+gst_raw_base_parse_set_sink_caps (GstBaseParse * parse, GstCaps * caps)
+{
+  gboolean ret = FALSE;
+  GstRawBaseParse *raw_base_parse = GST_RAW_BASE_PARSE (parse);
+  GstRawBaseParseClass *klass = GST_RAW_BASE_PARSE_GET_CLASS (parse);
+
+  g_assert (klass->set_config_from_caps);
+  g_assert (klass->get_caps_from_config);
+  g_assert (klass->get_config_frame_size);
+
+
+  GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (raw_base_parse);
+
+  GST_DEBUG_OBJECT (parse, "getting config from new sink caps");
+
+  /* Convert the new sink caps to sink caps config. This also
+   * readies the config. */
+  ret =
+      klass->set_config_from_caps (raw_base_parse,
+      GST_RAW_BASE_PARSE_CONFIG_SINKCAPS, caps);
+  if (!ret) {
+    GST_ERROR_OBJECT (raw_base_parse, "could not get config from sink caps");
+    goto done;
+  }
+
+  /* If the sink caps config is currently active, push caps downstream,
+   * set the minimum frame size (to guarantee that input buffers hold
+   * complete frames), and update the src_caps_set flag. If the sink
+   * caps config isn't the currently active config, just exit, since in
+   * that case, the caps will always be pushed downstream in handle_frame. */
+  if (gst_raw_base_parse_is_using_sink_caps (raw_base_parse)) {
+    GstCaps *new_src_caps;
+    gsize frame_size;
+
+    GST_DEBUG_OBJECT (parse,
+        "sink caps config is the current one; trying to push new caps downstream");
+
+    /* Convert back to caps. The caps may have changed, for example
+     * audio/x-unaligned-raw may have been replaced with audio/x-raw.
+     * (Also, this keeps the behavior in sync with that of the block
+     * in handle_frame that pushes caps downstream if not done already.) */
+    if (!klass->get_caps_from_config (raw_base_parse,
+            GST_RAW_BASE_PARSE_CONFIG_CURRENT, &new_src_caps)) {
+      GST_ERROR_OBJECT (raw_base_parse,
+          "could not get src caps from current config");
+      goto done;
+    }
+
+    GST_DEBUG_OBJECT (raw_base_parse,
+        "got new sink caps; updating src caps to %" GST_PTR_FORMAT,
+        (gpointer) new_src_caps);
+
+    frame_size =
+        klass->get_config_frame_size (raw_base_parse,
+        GST_RAW_BASE_PARSE_CONFIG_CURRENT);
+    gst_base_parse_set_min_frame_size (parse, frame_size);
+
+    raw_base_parse->src_caps_set = TRUE;
+
+    GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (raw_base_parse);
+
+    /* Push caps outside of the lock */
+    gst_pad_push_event (GST_BASE_PARSE_SRC_PAD (raw_base_parse),
+        gst_event_new_caps (new_src_caps)
+        );
+
+    gst_caps_unref (new_src_caps);
+  } else {
+    GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (raw_base_parse);
+  }
+
+  ret = TRUE;
+
+done:
+  return ret;
+}
+
+
+static GstFlowReturn
+gst_raw_base_parse_handle_frame (GstBaseParse * parse,
+    GstBaseParseFrame * frame, gint * skipsize)
+{
+  gsize in_size, out_size;
+  guint frame_size;
+  guint num_out_frames;
+  gsize units_n, units_d;
+  guint64 buffer_duration;
+  GstFlowReturn flow_ret = GST_FLOW_OK;
+  GstEvent *new_caps_event = NULL;
+  GstRawBaseParse *raw_base_parse = GST_RAW_BASE_PARSE (parse);
+  GstRawBaseParseClass *klass = GST_RAW_BASE_PARSE_GET_CLASS (parse);
+
+  g_assert (klass->is_config_ready);
+  g_assert (klass->get_caps_from_config);
+  g_assert (klass->get_config_frame_size);
+  g_assert (klass->get_units_per_second);
+
+
+  /* We never skip any bytes this way. Instead, subclass takes care
+   * of skipping any overhead (necessary, since the way it needs to
+   * be skipped is completely subclass specific). */
+  *skipsize = 0;
+
+
+  /* The operations below access the current config. Protect
+   * against race conditions by using the object lock. */
+  GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (raw_base_parse);
+
+
+  /* If the source pad caps haven't been set yet, or need to be
+   * set again, do so now, BEFORE any buffers are pushed out */
+  if (G_UNLIKELY (!raw_base_parse->src_caps_set)) {
+    GstCaps *new_src_caps;
+
+    if (G_UNLIKELY (!klass->is_config_ready (raw_base_parse,
+                GST_RAW_BASE_PARSE_CONFIG_CURRENT))) {
+      /* The current configuration is not ready. No caps can be
+       * generated out of it.
+       * The most likely reason for this is that the sink caps config
+       * is the current one and no valid sink caps have been pushed
+       * by upstream. Report the problem and exit. */
+
+      if (gst_raw_base_parse_is_using_sink_caps (raw_base_parse)) {
+        goto config_not_ready;
+      } else {
+        /* This should not be reached if the property config is active */
+        g_assert_not_reached ();
+      }
+    }
+
+    GST_DEBUG_OBJECT (parse,
+        "setting src caps since this has not been done yet");
+
+    /* Convert the current config to a caps structure to
+     * inform downstream about the new format */
+    if (!klass->get_caps_from_config (raw_base_parse,
+            GST_RAW_BASE_PARSE_CONFIG_CURRENT, &new_src_caps)) {
+      GST_ERROR_OBJECT (raw_base_parse,
+          "could not get src caps from current config");
+      flow_ret = GST_FLOW_NOT_NEGOTIATED;
+      goto error_locked;
+    }
+
+    new_caps_event = gst_event_new_caps (new_src_caps);
+    gst_caps_unref (new_src_caps);
+
+    raw_base_parse->src_caps_set = TRUE;
+  }
+
+  frame_size =
+      klass->get_config_frame_size (raw_base_parse,
+      GST_RAW_BASE_PARSE_CONFIG_CURRENT);
+
+
+  in_size = gst_buffer_get_size (frame->buffer);
+
+  /* gst_base_parse_set_min_frame_size() is called when the current
+   * configuration changes and the change affects the frame size. This
+   * means that a buffer must contain at least as many bytes as indicated
+   * by the frame size. If there are fewer inside an error occurred;
+   * either something in the parser went wrong, or the min frame size
+   * wasn't updated properly. */
+  g_assert (in_size >= frame_size);
+
+  /* Determine how many complete frames would fit in the input buffer.
+   * Then check if this amount exceeds the maximum number of frames
+   * as indicated by the subclass. */
+  num_out_frames = (in_size / frame_size);
+  if (klass->get_max_frames_per_buffer) {
+    guint max_num_out_frames = klass->get_max_frames_per_buffer (raw_base_parse,
+        GST_RAW_BASE_PARSE_CONFIG_CURRENT);
+    num_out_frames = MIN (num_out_frames, max_num_out_frames);
+  }
+
+  /* Ensure that the size of the buffers that get pushed downstream
+   * is always an integer multiple of the frame size to prevent cases
+   * where downstream gets buffers with incomplete frames. */
+  out_size = num_out_frames * frame_size;
+
+  /* Set the overhead size to ensure that timestamping excludes these
+   * extra overhead bytes. */
+  frame->overhead =
+      klass->get_overhead_size ? klass->get_overhead_size (raw_base_parse,
+      GST_RAW_BASE_PARSE_CONFIG_CURRENT) : 0;
+
+  g_assert (out_size >= (guint) (frame->overhead));
+  out_size -= frame->overhead;
+
+  GST_LOG_OBJECT (raw_base_parse,
+      "%" G_GSIZE_FORMAT " bytes input  %" G_GSIZE_FORMAT
+      " bytes output (%u frame(s))  %d bytes overhead", in_size, out_size,
+      num_out_frames, frame->overhead);
+
+  /* Calculate buffer duration */
+  klass->get_units_per_second (raw_base_parse, GST_FORMAT_BYTES,
+      GST_RAW_BASE_PARSE_CONFIG_CURRENT, &units_n, &units_d);
+  if (units_n == 0 || units_d == 0)
+    buffer_duration = GST_CLOCK_TIME_NONE;
+  else
+    buffer_duration =
+        gst_util_uint64_scale (out_size, GST_SECOND * units_d, units_n);
+
+  if (klass->process) {
+    GstBuffer *processed_data = NULL;
+
+    if (!klass->process (raw_base_parse, GST_RAW_BASE_PARSE_CONFIG_CURRENT,
+            frame->buffer, in_size, out_size, &processed_data))
+      goto process_error;
+
+    frame->out_buffer = processed_data;
+  } else {
+    frame->out_buffer = NULL;
+  }
+
+  /* Set the duration of the output buffer, or if none exists, of
+   * the input buffer. Do this after the process() call, since in
+   * case out_buffer is set, the subclass has created a new buffer.
+   * Instead of requiring subclasses to set the duration (which
+   * anyway must always be buffer_duration), let's do it here. */
+  if (frame->out_buffer != NULL)
+    GST_BUFFER_DURATION (frame->out_buffer) = buffer_duration;
+  else
+    GST_BUFFER_DURATION (frame->buffer) = buffer_duration;
+
+  /* Access to the current config is not needed in subsequent
+   * operations, so the lock can be released */
+  GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (raw_base_parse);
+
+
+  /* If any new caps have to be pushed downstrean, do so
+   * *before* the frame is finished */
+  if (G_UNLIKELY (new_caps_event != NULL)) {
+    gst_pad_push_event (GST_BASE_PARSE_SRC_PAD (raw_base_parse),
+        new_caps_event);
+    new_caps_event = NULL;
+  }
+
+  gst_base_parse_finish_frame (parse, frame, out_size + frame->overhead);
+
+
+  return flow_ret;
+
+
+config_not_ready:
+  GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (raw_base_parse);
+  GST_ELEMENT_ERROR (parse, STREAM, FORMAT,
+      ("sink caps config is the current config, and it is not ready -"
+          "upstream may not have pushed a caps event yet"), (NULL));
+  flow_ret = GST_FLOW_ERROR;
+  goto error_end;
+
+process_error:
+  GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (raw_base_parse);
+  GST_ELEMENT_ERROR (parse, STREAM, DECODE, ("could not process data"), (NULL));
+  flow_ret = GST_FLOW_ERROR;
+  goto error_end;
+
+error_locked:
+  GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (raw_base_parse);
+  goto error_end;
+
+error_end:
+  frame->flags |= GST_BASE_PARSE_FRAME_FLAG_DROP;
+  if (new_caps_event != NULL)
+    gst_event_unref (new_caps_event);
+  return flow_ret;
+}
+
+
+static gboolean
+gst_raw_base_parse_convert (GstBaseParse * parse, GstFormat src_format,
+    gint64 src_value, GstFormat dest_format, gint64 * dest_value)
+{
+  GstRawBaseParse *raw_base_parse = GST_RAW_BASE_PARSE (parse);
+  GstRawBaseParseClass *klass = GST_RAW_BASE_PARSE_GET_CLASS (parse);
+  gboolean ret = TRUE;
+  gsize units_n, units_d;
+
+  g_assert (klass->is_config_ready);
+  g_assert (klass->get_units_per_second);
+
+
+  /* The operations below access the current config. Protect
+   * against race conditions by using the object lock. */
+  GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (raw_base_parse);
+
+
+  if (!klass->is_config_ready (raw_base_parse,
+          GST_RAW_BASE_PARSE_CONFIG_CURRENT)) {
+    if (gst_raw_base_parse_is_using_sink_caps (raw_base_parse)) {
+      goto config_not_ready;
+    } else {
+      /* This should not be reached if the property config is active */
+      g_assert_not_reached ();
+    }
+  }
+
+  if (G_UNLIKELY (src_format == dest_format)) {
+    *dest_value = src_value;
+  } else if ((src_format == GST_FORMAT_TIME || dest_format == GST_FORMAT_TIME)
+      && gst_raw_base_parse_is_gstformat_supported (raw_base_parse, src_format)
+      && gst_raw_base_parse_is_gstformat_supported (raw_base_parse, src_format)) {
+    /* Perform conversions here if either the src or dest format
+     * are GST_FORMAT_TIME and the other format is supported by
+     * the subclass. This is because we perform TIME<->non-TIME
+     * conversions here. Typically, subclasses only support
+     * BYTES and DEFAULT formats. */
+
+    if (src_format == GST_FORMAT_TIME) {
+      /* The source format is time, so perform a TIME -> non-TIME conversion */
+      klass->get_units_per_second (raw_base_parse, dest_format,
+          GST_RAW_BASE_PARSE_CONFIG_CURRENT, &units_n, &units_d);
+      *dest_value = (units_n == 0
+          || units_d == 0) ? src_value : gst_util_uint64_scale (src_value,
+          units_n, GST_SECOND * units_d);
+    } else {
+      /* The dest format is time, so perform a non-TIME -> TIME conversion */
+      klass->get_units_per_second (raw_base_parse, src_format,
+          GST_RAW_BASE_PARSE_CONFIG_CURRENT, &units_n, &units_d);
+      *dest_value = (units_n == 0
+          || units_d == 0) ? src_value : gst_util_uint64_scale (src_value,
+          GST_SECOND * units_d, units_n);
+    }
+  } else {
+    /* Fallback for other conversions */
+    ret =
+        gst_base_parse_convert_default (parse, src_format, src_value,
+        dest_format, dest_value);
+  }
+
+  GST_DEBUG_OBJECT (parse,
+      "converted %s -> %s  %" G_GINT64_FORMAT " -> %" GST_TIME_FORMAT,
+      gst_format_get_name (src_format), gst_format_get_name (dest_format),
+      src_value, GST_TIME_ARGS (*dest_value));
+
+  GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (raw_base_parse);
+  return ret;
+
+
+config_not_ready:
+  GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (raw_base_parse);
+  GST_ELEMENT_ERROR (parse, STREAM, FORMAT,
+      ("sink caps config is the current config, and it is not ready - "
+          "upstream may not have pushed a caps event yet"), (NULL));
+  return FALSE;
+}
+
+
+static gboolean
+gst_raw_base_parse_is_using_sink_caps (GstRawBaseParse * raw_base_parse)
+{
+  /* must be called with lock */
+  GstRawBaseParseClass *klass = GST_RAW_BASE_PARSE_GET_CLASS (raw_base_parse);
+  g_assert (klass->get_current_config);
+  return klass->get_current_config (raw_base_parse) ==
+      GST_RAW_BASE_PARSE_CONFIG_SINKCAPS;
+}
+
+
+static gboolean
+gst_raw_base_parse_is_gstformat_supported (GstRawBaseParse * raw_base_parse,
+    GstFormat format)
+{
+  /* must be called with lock */
+  GstRawBaseParseClass *klass = GST_RAW_BASE_PARSE_GET_CLASS (raw_base_parse);
+  g_assert (klass->is_unit_format_supported);
+  return klass->is_unit_format_supported (raw_base_parse, format);
+}
+
+
+
+
+
+/**
+ * gst_raw_base_parse_invalidate_src_caps:
+ * @raw_base_parse: a #GstRawBaseParse instance
+ *
+ * Flags the current source caps as invalid. Before the next downstream
+ * buffer push, @get_caps_from_config is called, and the created caps are
+ * pushed downstream in a new caps event, This is used if for example the
+ * properties configuration is modified in the subclass.
+ *
+ * Note that this must be called with the parser lock held. Use the
+ * GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK() and GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK()
+ * macros for this purpose.
+ */
+void
+gst_raw_base_parse_invalidate_src_caps (GstRawBaseParse * raw_base_parse)
+{
+  /* must be called with lock */
+  g_assert (raw_base_parse != NULL);
+  raw_base_parse->src_caps_set = FALSE;
+}
diff --git a/gst/rawparse/gstrawbaseparse.h b/gst/rawparse/gstrawbaseparse.h
new file mode 100644
index 000000000..519b409ed
--- /dev/null
+++ b/gst/rawparse/gstrawbaseparse.h
@@ -0,0 +1,207 @@
+/* GStreamer
+ * Copyright (C) <2016> Carlos Rafael Giani <dv at pseudoterminal dot org>
+ *
+ * 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_RAW_BASE_PARSE_H__
+#define __GST_RAW_BASE_PARSE_H__
+
+#include <gst/gst.h>
+#include <gst/base/base.h>
+
+G_BEGIN_DECLS
+
+#define GST_TYPE_RAW_BASE_PARSE \
+  (gst_raw_base_parse_get_type())
+#define GST_RAW_BASE_PARSE(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj), GST_TYPE_RAW_BASE_PARSE, GstRawBaseParse))
+#define GST_RAW_BASE_PARSE_CAST(obj) \
+  ((GstRawBaseParse *)(obj))
+#define GST_RAW_BASE_PARSE_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_RAW_BASE_PARSE, GstRawBaseParseClass))
+#define GST_RAW_BASE_PARSE_GET_CLASS(obj) \
+  (G_TYPE_INSTANCE_GET_CLASS((obj), GST_TYPE_RAW_BASE_PARSE, GstRawBaseParseClass))
+#define GST_IS_RAW_BASE_PARSE(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj), GST_TYPE_RAW_BASE_PARSE))
+#define GST_IS_RAW_BASE_PARSE_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_TYPE((klass), GST_TYPE_RAW_BASE_PARSE))
+
+#define GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK(obj)   g_mutex_lock(&(((GstRawBaseParse *)(obj))->config_mutex))
+#define GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK(obj) g_mutex_unlock(&(((GstRawBaseParse *)(obj))->config_mutex))
+
+
+typedef enum _GstRawBaseParseConfig GstRawBaseParseConfig;
+typedef struct _GstRawBaseParse GstRawBaseParse;
+typedef struct _GstRawBaseParseClass GstRawBaseParseClass;
+
+
+/**
+ * GstRawBaseParseConfig:
+ * @GST_RAW_BASE_PARSE_CONFIG_CURRENT: configuration that is currently active
+ * @GST_RAW_BASE_PARSE_CONFIG_SINKCAPS: configuration that is defined by the input sink caps
+ * @GST_RAW_BASE_PARSE_CONFIG_PROPERTIES: configuration that is defined by class properties
+ *
+ * Identifier for the type of parser configuration.
+ */
+enum _GstRawBaseParseConfig
+{
+  GST_RAW_BASE_PARSE_CONFIG_CURRENT = 1,
+  GST_RAW_BASE_PARSE_CONFIG_SINKCAPS,
+  GST_RAW_BASE_PARSE_CONFIG_PROPERTIES
+};
+
+
+/**
+ * GstRawBaseParse:
+ *
+ * The opaque #GstRawBaseParse data structure.
+ */
+struct _GstRawBaseParse
+{
+  GstBaseParse parent;
+
+  /*< private > */
+
+  /* TRUE if the source pad caps have been set already. This is used
+   * for checking if the source pad caps have to be set. */
+  gboolean src_caps_set;
+
+  /* Mutex which protects access to and modifications on the configs. */
+  GMutex config_mutex;
+};
+
+
+/**
+ * GstRawBaseParseClass:
+ * @parent_class:              The parent class structure
+ * @set_current_config:        Sets the new current configuration. Subclasses must internally
+ *                             switch to this new configuration. Return FALSE if this failed,
+ *                             TRUE otherwise.
+ * @get_current_config:        Gets the current configuration. All return values except
+ *                             except GST_RAW_BASE_PARSE_CONFIG_CURRENT are valid.
+ * @set_config_from_caps:      Parses the caps and copies its information to the configuration.
+ *                             Returns FALSE if this failed, TRUE otheriwse. Specified caps
+ *                             are not unref'd.
+ * @get_caps_from_config:      Creates a new caps structure out of the information from the
+ *                             specified configuration. Ownership over the returned caps are
+ *                             transferred to the caller. If something fails during the caps
+ *                             creation, the vfunc must make sure to destroy any partially
+ *                             created caps; the *caps value is always set to NULL in case of
+ *                             failure. Returns FALSE in case of failure,
+ *                             TRUE in case of success.
+ * @get_config_frame_size:     Gets the size of one frame, in bytes, from the specified
+ *                             configuration. This must be the size of the complete frame,
+ *                             including any overhead (metadata, headers, padding bytes etc.).
+ * @get_max_frames_per_buffer: Optional.
+ *                             Returns up to how many complete frames one output buffer may
+ *                             contain. The value must be nonzero. This is useful for example
+ *                             with video parsers which need to ensure that one output buffer
+ *                             contains only one video frame, even if the input buffer contains
+ *                             several complete frames. If this vfunc is not set, then there
+ *                             is no maximum number of frames per buffer - the parser reads
+ *                             as many complete frames as possible from the input buffer.
+ * @is_config_ready:           Returns TRUE if the specified configuration is ready, FALSE
+ *                             otherwise.
+ * @process:                   Optional.
+ *                             This is useful to do any last minute processing before the
+ *                             data is pushed downstream. One example is channel reordering
+ *                             in audio parsers.
+ *                             in_data is the complete input buffer, total_num_in_bytes is
+ *                             the total amount of bytes this input buffer contains (including
+ *                             excess bytes that form an incomplete rame). num_valid_in_bytes
+ *                             is the subset of these bytes that are to be pushed downstream.
+ *                             If for example the frame size is 4, and total_num_in_bytes is
+ *                             411, then num_valid_in_bytes will be 408, since the last 3
+ *                             bytes form an incomplete frame.
+ *                             The value of num_valid_in_bytes excludes the overhead bytes
+ *                             indicated by @get_overhead_size.
+ *                             If the subclass creates a new buffer here, *processed_data
+ *                             must be set to the new buffer's pointer. If the subclass does
+ *                             not create any new buffer, and just expects the first
+ *                             num_valid_in_bytes of the input buffer to be pushed downstream,
+ *                             then *processed_data must be set to NULL.
+ *                             If this vfunc is not set, then the parser behaves as if this
+ *                             vfunc set *processed_data data to NULL.
+ * @is_unit_format_supported:  Returns TRUE if the given format is supported by the
+ *                             @get_units_per_second function, FALSE otherwise.
+ * @get_units_per_second:      Returns how many units per second exist for a given format.
+ *                             For example, with an audio parser and format DEFAULT, the units
+ *                             per second are typically the number of samples per second
+ *                             (= the sample rate). For video parsers, this would be the frame
+ *                             rate. If BYTES or TIME are used as format, then the result must
+ *                             not include any extra overhead (metadata, headers, padding etc.)
+ * @get_overhead_size:         Optional.
+ *                             Returns the number of bytes that make up the portion of a frame
+ *                             that isn't payload. Examples are padding bytes, headers, and
+ *                             other kinds of metadata. If this vfunc isn't defined, then an
+ *                             overhead size of 0 bytes is assumed.
+ *
+ * Subclasses are required to override all vfuncs except for @process, which is optional.
+ * The raw base parser lock is held during all vfunc calls.
+ */
+struct _GstRawBaseParseClass
+{
+  GstBaseParseClass parent_class;
+
+  gboolean              (*set_current_config)        (GstRawBaseParse *raw_base_parse,
+                                                      GstRawBaseParseConfig config);
+  GstRawBaseParseConfig (*get_current_config)        (GstRawBaseParse *raw_base_parse);
+
+  gboolean              (*set_config_from_caps)      (GstRawBaseParse * raw_base_parse,
+                                                      GstRawBaseParseConfig config,
+                                                      GstCaps * caps);
+  gboolean              (*get_caps_from_config)      (GstRawBaseParse * raw_base_parse,
+                                                      GstRawBaseParseConfig config,
+                                                      GstCaps ** caps);
+
+  gsize                 (*get_config_frame_size)     (GstRawBaseParse * raw_base_parse,
+                                                      GstRawBaseParseConfig config);
+  guint                 (*get_max_frames_per_buffer) (GstRawBaseParse * raw_base_parse,
+                                                      GstRawBaseParseConfig config);
+
+  gboolean              (*is_config_ready)           (GstRawBaseParse * raw_base_parse,
+                                                      GstRawBaseParseConfig config);
+
+  gboolean              (*process)                   (GstRawBaseParse * raw_base_parse,
+                                                      GstRawBaseParseConfig config,
+                                                      GstBuffer * in_data,
+                                                      gsize total_num_in_bytes,
+                                                      gsize num_valid_in_bytes,
+                                                      GstBuffer ** processed_data);
+
+  gboolean              (*is_unit_format_supported)  (GstRawBaseParse * raw_base_parse,
+                                                      GstFormat format);
+  void                  (*get_units_per_second)      (GstRawBaseParse * raw_base_parse,
+                                                      GstFormat format,
+                                                      GstRawBaseParseConfig config,
+                                                      gsize * units_per_sec_n,
+                                                      gsize * units_per_sec_d);
+
+  gint                  (*get_overhead_size)         (GstRawBaseParse * raw_base_parse,
+                                                      GstRawBaseParseConfig config);
+};
+
+
+void gst_raw_base_parse_invalidate_src_caps (GstRawBaseParse * raw_base_parse);
+
+
+GType gst_raw_base_parse_get_type (void);
+
+
+G_END_DECLS
+
+#endif
diff --git a/gst/rawparse/gstrawvideoparse.c b/gst/rawparse/gstrawvideoparse.c
new file mode 100644
index 000000000..03db577b0
--- /dev/null
+++ b/gst/rawparse/gstrawvideoparse.c
@@ -0,0 +1,1131 @@
+/* GStreamer
+ * Copyright (C) <2016> Carlos Rafael Giani <dv at pseudoterminal dot org>
+ *
+ * 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.
+ */
+
+/**
+ * SECTION:element-rawvideoparse
+ *
+ * This element parses incoming data as raw video frames and timestamps these.
+ * It also handles seek queries in said raw video data, and ensures that output
+ * buffers contain exactly one frame, even if the input buffers contain only
+ * partial frames or multiple frames. In the former case, it will continue to
+ * receive buffers until there is enough input data to output one frame. In the
+ * latter case, it will extract the first frame in the buffer and output it, then
+ * the second one etc. until the remaining unparsed bytes aren't enough to form
+ * a complete frame, and it will then continue as described in the earlier case.
+ *
+ * The element implements the properties and sink caps configuration as specified
+ * in the #GstRawBaseParse documentation. The properties configuration can be
+ * modified by using the width, height, pixel-aspect-ratio, framerate, interlaced,
+ * top-field-first, plane-strides, plane-offsets, and frame-stride properties.
+ *
+ * If the properties configuration is used, be sure to set valid plane stride
+ * offsets and values, otherwise the produced frames will not have a correct size.
+ * Merely setting the format is not enough.
+ *
+ * The frame stride property is useful in cases where there is extra data between
+ * the frames (for example, trailing metadata, or headers). The parser calculates 
+ * the actual frame size out of the other properties and compares it with this
+ * frame-stride value. If the frame stride is larger than the calculated size,
+ * then the extra bytes after the end of the frame are skipped. For example, with
+ * 8-bit grayscale frames and a frame size of 100x10 pixels and a frame stride of
+ * 1500 bytes, there are 500 excess bytes at the end of the actual frame which
+ * are then skipped. It is safe to set the frame stride to a value that is smaller
+ * than the actual frame size (in fact, its default value is 0); if it is smaller,
+ * then no trailing data will be skipped.
+ *
+ * If a framerate of 0 Hz is set (for example, 0/1), then output buffers will have
+ * no duration set. The first output buffer will have a PTS 0, all subsequent ones
+ * an unset PTS.
+ *
+ * <refsect2>
+ * <title>Example pipelines</title>
+ * |[
+ * gst-launch-1.0 filesrc location=video.raw ! rawvideoparse use-sink-caps=false \
+ *         width=500 height=400 format=y444 ! autovideosink
+ * ]| Read raw data from a local file and parse it as video data with 500x400 pixels
+ * and Y444 video format.
+ * |[
+ * gst-launch-1.0 filesrc location=video.raw ! queue ! "video/x-raw, width=320, \
+ *         height=240, format=I420, framerate=1/1" ! rawvideoparse \
+ *         use-sink-caps=true ! autovideosink
+ * ]| Read raw data from a local file and parse it as video data with 320x240 pixels
+ * and I420 video format. The queue element here is to force push based scheduling.
+ * See the documentation in #GstRawBaseParse for the reason why.
+ * </refsect2>
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+
+/* FIXME: GValueArray is deprecated, but there is currently no viabla alternative
+ * See https://bugzilla.gnome.org/show_bug.cgi?id=667228 */
+#define GLIB_DISABLE_DEPRECATION_WARNINGS
+
+#include <string.h>
+#include "gstrawvideoparse.h"
+#include "unalignedvideo.h"
+
+
+GST_DEBUG_CATEGORY_STATIC (raw_video_parse_debug);
+#define GST_CAT_DEFAULT raw_video_parse_debug
+
+
+enum
+{
+  PROP_0,
+  PROP_WIDTH,
+  PROP_HEIGHT,
+  PROP_FORMAT,
+  PROP_PIXEL_ASPECT_RATIO,
+  PROP_FRAMERATE,
+  PROP_INTERLACED,
+  PROP_TOP_FIELD_FIRST,
+  PROP_PLANE_STRIDES,
+  PROP_PLANE_OFFSETS,
+  PROP_FRAME_STRIDE
+};
+
+
+#define DEFAULT_WIDTH                 320
+#define DEFAULT_HEIGHT                240
+#define DEFAULT_FORMAT                GST_VIDEO_FORMAT_I420
+#define DEFAULT_PIXEL_ASPECT_RATIO_N  1
+#define DEFAULT_PIXEL_ASPECT_RATIO_D  1
+#define DEFAULT_FRAMERATE_N           25
+#define DEFAULT_FRAMERATE_D           1
+#define DEFAULT_INTERLACED            FALSE
+#define DEFAULT_TOP_FIELD_FIRST       FALSE
+#define DEFAULT_FRAME_STRIDE          0
+
+
+#define GST_RAW_VIDEO_PARSE_CAPS \
+	GST_VIDEO_CAPS_MAKE(GST_VIDEO_FORMATS_ALL) "; "
+
+
+static GstStaticPadTemplate static_sink_template =
+    GST_STATIC_PAD_TEMPLATE ("sink",
+    GST_PAD_SINK,
+    GST_PAD_ALWAYS,
+    GST_STATIC_CAPS (GST_UNALIGNED_RAW_VIDEO_CAPS "; " GST_RAW_VIDEO_PARSE_CAPS)
+    );
+
+
+static GstStaticPadTemplate static_src_template =
+GST_STATIC_PAD_TEMPLATE ("src",
+    GST_PAD_SRC,
+    GST_PAD_ALWAYS,
+    GST_STATIC_CAPS (GST_RAW_VIDEO_PARSE_CAPS)
+    );
+
+
+#define gst_raw_video_parse_parent_class parent_class
+G_DEFINE_TYPE (GstRawVideoParse, gst_raw_video_parse, GST_TYPE_RAW_BASE_PARSE);
+
+
+static void gst_raw_video_parse_set_property (GObject * object, guint prop_id,
+    GValue const *value, GParamSpec * pspec);
+static void gst_raw_video_parse_get_property (GObject * object, guint prop_id,
+    GValue * value, GParamSpec * pspec);
+
+static gboolean gst_raw_video_parse_stop (GstBaseParse * parse);
+
+static gboolean gst_raw_video_parse_set_current_config (GstRawBaseParse *
+    raw_base_parse, GstRawBaseParseConfig config);
+static GstRawBaseParseConfig
+gst_raw_video_parse_get_current_config (GstRawBaseParse * raw_base_parse);
+static gboolean gst_raw_video_parse_set_config_from_caps (GstRawBaseParse *
+    raw_base_parse, GstRawBaseParseConfig config, GstCaps * caps);
+static gboolean gst_raw_video_parse_get_caps_from_config (GstRawBaseParse *
+    raw_base_parse, GstRawBaseParseConfig config, GstCaps ** caps);
+static gsize gst_raw_video_parse_get_config_frame_size (GstRawBaseParse *
+    raw_base_parse, GstRawBaseParseConfig config);
+static guint gst_raw_video_parse_get_max_frames_per_buffer (GstRawBaseParse *
+    raw_base_parse, GstRawBaseParseConfig config);
+static gboolean gst_raw_video_parse_is_config_ready (GstRawBaseParse *
+    raw_base_parse, GstRawBaseParseConfig config);
+static gboolean gst_raw_video_parse_process (GstRawBaseParse * raw_base_parse,
+    GstRawBaseParseConfig config, GstBuffer * in_data, gsize total_num_in_bytes,
+    gsize num_valid_in_bytes, GstBuffer ** processed_data);
+static gboolean gst_raw_video_parse_is_unit_format_supported (GstRawBaseParse *
+    raw_base_parse, GstFormat format);
+static void gst_raw_video_parse_get_units_per_second (GstRawBaseParse *
+    raw_base_parse, GstFormat format, GstRawBaseParseConfig config,
+    gsize * units_per_sec_n, gsize * units_per_sec_d);
+
+static gint gst_raw_video_parse_get_overhead_size (GstRawBaseParse *
+    raw_base_parse, GstRawBaseParseConfig config);
+
+static gboolean gst_raw_video_parse_is_using_sink_caps (GstRawVideoParse *
+    raw_video_parse);
+static GstRawVideoParseConfig
+    * gst_raw_video_parse_get_config_ptr (GstRawVideoParse * raw_video_parse,
+    GstRawBaseParseConfig config);
+
+static void gst_raw_video_parse_init_config (GstRawVideoParseConfig * config);
+static void gst_raw_video_parse_update_info (GstRawVideoParseConfig * config);
+
+
+
+static void
+gst_raw_video_parse_class_init (GstRawVideoParseClass * klass)
+{
+  GObjectClass *object_class;
+  GstElementClass *element_class;
+  GstBaseParseClass *baseparse_class;
+  GstRawBaseParseClass *rawbaseparse_class;
+
+  GST_DEBUG_CATEGORY_INIT (raw_video_parse_debug, "rawvideoparse", 0,
+      "rawvideoparse element");
+
+  object_class = G_OBJECT_CLASS (klass);
+  element_class = GST_ELEMENT_CLASS (klass);
+  baseparse_class = GST_BASE_PARSE_CLASS (klass);
+  rawbaseparse_class = GST_RAW_BASE_PARSE_CLASS (klass);
+
+  gst_element_class_add_pad_template (element_class,
+      gst_static_pad_template_get (&static_sink_template));
+  gst_element_class_add_pad_template (element_class,
+      gst_static_pad_template_get (&static_src_template));
+
+  object_class->set_property =
+      GST_DEBUG_FUNCPTR (gst_raw_video_parse_set_property);
+  object_class->get_property =
+      GST_DEBUG_FUNCPTR (gst_raw_video_parse_get_property);
+
+  baseparse_class->stop = GST_DEBUG_FUNCPTR (gst_raw_video_parse_stop);
+
+  rawbaseparse_class->set_current_config =
+      GST_DEBUG_FUNCPTR (gst_raw_video_parse_set_current_config);
+  rawbaseparse_class->get_current_config =
+      GST_DEBUG_FUNCPTR (gst_raw_video_parse_get_current_config);
+  rawbaseparse_class->set_config_from_caps =
+      GST_DEBUG_FUNCPTR (gst_raw_video_parse_set_config_from_caps);
+  rawbaseparse_class->get_caps_from_config =
+      GST_DEBUG_FUNCPTR (gst_raw_video_parse_get_caps_from_config);
+  rawbaseparse_class->get_config_frame_size =
+      GST_DEBUG_FUNCPTR (gst_raw_video_parse_get_config_frame_size);
+  rawbaseparse_class->get_max_frames_per_buffer =
+      GST_DEBUG_FUNCPTR (gst_raw_video_parse_get_max_frames_per_buffer);
+  rawbaseparse_class->is_config_ready =
+      GST_DEBUG_FUNCPTR (gst_raw_video_parse_is_config_ready);
+  rawbaseparse_class->process = GST_DEBUG_FUNCPTR (gst_raw_video_parse_process);
+  rawbaseparse_class->is_unit_format_supported =
+      GST_DEBUG_FUNCPTR (gst_raw_video_parse_is_unit_format_supported);
+  rawbaseparse_class->get_units_per_second =
+      GST_DEBUG_FUNCPTR (gst_raw_video_parse_get_units_per_second);
+  rawbaseparse_class->get_overhead_size =
+      GST_DEBUG_FUNCPTR (gst_raw_video_parse_get_overhead_size);
+
+  g_object_class_install_property (object_class,
+      PROP_WIDTH,
+      g_param_spec_int ("width",
+          "Width",
+          "Width of frames in raw stream",
+          0, G_MAXINT, DEFAULT_WIDTH,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
+      );
+  g_object_class_install_property (object_class,
+      PROP_HEIGHT,
+      g_param_spec_int ("height",
+          "Height",
+          "Height of frames in raw stream",
+          0, G_MAXINT,
+          DEFAULT_HEIGHT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
+      );
+  g_object_class_install_property (object_class,
+      PROP_FORMAT,
+      g_param_spec_enum ("format",
+          "Format",
+          "Format of frames in raw stream",
+          GST_TYPE_VIDEO_FORMAT,
+          DEFAULT_FORMAT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
+      );
+  g_object_class_install_property (object_class,
+      PROP_FRAMERATE,
+      gst_param_spec_fraction ("framerate",
+          "Frame rate",
+          "Rate of frames in raw stream",
+          0, 1, G_MAXINT, 1,
+          DEFAULT_FRAMERATE_N, DEFAULT_FRAMERATE_D,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
+      );
+  g_object_class_install_property (object_class,
+      PROP_PIXEL_ASPECT_RATIO,
+      gst_param_spec_fraction ("pixel-aspect-ratio",
+          "Pixel aspect ratio",
+          "Pixel aspect ratio of frames in raw stream",
+          1, 100, 100, 1,
+          DEFAULT_PIXEL_ASPECT_RATIO_N, DEFAULT_PIXEL_ASPECT_RATIO_D,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
+      );
+  g_object_class_install_property (object_class,
+      PROP_INTERLACED,
+      g_param_spec_boolean ("interlaced",
+          "Interlaced flag",
+          "True if frames in raw stream are interlaced",
+          DEFAULT_INTERLACED, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
+      );
+  g_object_class_install_property (object_class,
+      PROP_TOP_FIELD_FIRST,
+      g_param_spec_boolean ("top-field-first",
+          "Top field first",
+          "True if top field in frames in raw stream come first (not used if frames aren't interlaced)",
+          DEFAULT_INTERLACED, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
+      );
+  g_object_class_install_property (object_class,
+      PROP_PLANE_STRIDES,
+      g_param_spec_value_array ("plane-strides",
+          "Plane strides",
+          "Strides of the planets in bytes",
+          g_param_spec_uint ("plane-stride",
+              "Plane stride",
+              "Stride of the n-th plane in bytes (0 = stride equals width*bytes-per-pixel)",
+              0, G_MAXUINT,
+              0,
+              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS),
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
+      );
+  g_object_class_install_property (object_class,
+      PROP_PLANE_OFFSETS,
+      g_param_spec_value_array ("plane-offsets",
+          "Plane offsets",
+          "Offsets of the planets in bytes",
+          g_param_spec_uint ("plane-offset",
+              "Plane offset",
+              "Offset of the n-th plane in bytes",
+              0, G_MAXUINT,
+              0,
+              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS),
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
+      );
+  g_object_class_install_property (object_class,
+      PROP_FRAME_STRIDE,
+      g_param_spec_uint ("frame-stride",
+          "Frame stride",
+          "Stride between whole frames (0 = frames are tightly packed together)",
+          0, G_MAXUINT,
+          DEFAULT_FRAME_STRIDE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
+      );
+
+  gst_element_class_set_static_metadata (element_class,
+      "rawvideoparse",
+      "Codec/Parser/Video",
+      "Converts unformatted data streams into timestamped raw video frames",
+      "Carlos Rafael Giani <dv@pseudoterminal.org>");
+}
+
+
+static void
+gst_raw_video_parse_init (GstRawVideoParse * raw_video_parse)
+{
+  gst_raw_video_parse_init_config (&(raw_video_parse->properties_config));
+  gst_raw_video_parse_init_config (&(raw_video_parse->sink_caps_config));
+
+  /* As required by GstRawBaseParse, ensure that the current configuration
+   * is initially set to be the properties config */
+  raw_video_parse->current_config = &(raw_video_parse->properties_config);
+
+  /* Properties config must be valid from the start, so set its ready value
+   * to TRUE, and make sure its bpf value is valid. */
+  raw_video_parse->properties_config.ready = TRUE;
+  raw_video_parse->properties_config.top_field_first = DEFAULT_TOP_FIELD_FIRST;
+  raw_video_parse->properties_config.frame_stride = DEFAULT_FRAME_STRIDE;
+}
+
+
+static void
+gst_raw_video_parse_set_property (GObject * object, guint prop_id,
+    GValue const *value, GParamSpec * pspec)
+{
+  GstBaseParse *base_parse = GST_BASE_PARSE (object);
+  GstRawBaseParse *raw_base_parse = GST_RAW_BASE_PARSE (object);
+  GstRawVideoParse *raw_video_parse = GST_RAW_VIDEO_PARSE (object);
+  GstRawVideoParseConfig *props_cfg = &(raw_video_parse->properties_config);
+
+  /* All properties are handled similarly:
+   * - if the new value is the same as the current value, nothing is done
+   * - the parser lock is held while the new value is set
+   * - if the properties config is the current config, the source caps are
+   *   invalidated to ensure that the code in handle_frame pushes a new CAPS
+   *   event out
+   * - properties that affect the video frame size call the function to update
+   *   the info and also call gst_base_parse_set_min_frame_size() to ensure
+   *   that the minimum frame size can hold 1 frame (= one sample for each
+   *   channel); to ensure that the min frame size includes any extra padding,
+   *   it is set to the result of gst_raw_video_parse_get_config_frame_size()
+   * - property configuration values that require video info updates aren't
+   *   written directory into the video info structure, but in the extra
+   *   fields instead (gst_raw_video_parse_update_info() then copies the values
+   *   from these fields into the video info); see the documentation inside
+   *   gst_raw_video_parse_update_info() for the reason why
+   */
+
+  switch (prop_id) {
+    case PROP_WIDTH:
+    {
+      gint new_width = g_value_get_int (value);
+
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object);
+
+      if (new_width != props_cfg->width) {
+        props_cfg->width = new_width;
+        gst_raw_video_parse_update_info (props_cfg);
+
+        if (!gst_raw_video_parse_is_using_sink_caps (raw_video_parse)) {
+          gst_raw_base_parse_invalidate_src_caps (raw_base_parse);
+          gst_base_parse_set_min_frame_size (base_parse,
+              gst_raw_video_parse_get_config_frame_size (raw_base_parse,
+                  GST_RAW_BASE_PARSE_CONFIG_PROPERTIES));
+        }
+      }
+
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+      break;
+    }
+
+    case PROP_HEIGHT:
+    {
+      gint new_height = g_value_get_int (value);
+
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object);
+
+      if (new_height != props_cfg->height) {
+        props_cfg->height = new_height;
+        gst_raw_video_parse_update_info (props_cfg);
+
+        if (!gst_raw_video_parse_is_using_sink_caps (raw_video_parse)) {
+          gst_raw_base_parse_invalidate_src_caps (raw_base_parse);
+          gst_base_parse_set_min_frame_size (base_parse,
+              gst_raw_video_parse_get_config_frame_size (raw_base_parse,
+                  GST_RAW_BASE_PARSE_CONFIG_PROPERTIES));
+        }
+      }
+
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+      break;
+    }
+
+    case PROP_FORMAT:
+    {
+      GstVideoFormat new_format = g_value_get_enum (value);
+
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object);
+
+      if (new_format != props_cfg->format) {
+        props_cfg->format = new_format;
+        gst_raw_video_parse_update_info (props_cfg);
+
+        if (!gst_raw_video_parse_is_using_sink_caps (raw_video_parse)) {
+          gst_raw_base_parse_invalidate_src_caps (raw_base_parse);
+          gst_base_parse_set_min_frame_size (base_parse,
+              gst_raw_video_parse_get_config_frame_size (raw_base_parse,
+                  GST_RAW_BASE_PARSE_CONFIG_PROPERTIES));
+        }
+      }
+
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+      break;
+    }
+
+    case PROP_PIXEL_ASPECT_RATIO:
+    {
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object);
+
+      /* The pixel aspect ratio does not affect the video frame size,
+       * so it is just set directly without any updates */
+      props_cfg->pixel_aspect_ratio_n =
+          GST_VIDEO_INFO_PAR_N (&(props_cfg->info)) =
+          gst_value_get_fraction_numerator (value);
+      props_cfg->pixel_aspect_ratio_d =
+          GST_VIDEO_INFO_PAR_D (&(props_cfg->info)) =
+          gst_value_get_fraction_denominator (value);
+      GST_DEBUG_OBJECT (raw_video_parse, "setting pixel aspect ratio to %u/%u",
+          props_cfg->pixel_aspect_ratio_n, props_cfg->pixel_aspect_ratio_d);
+
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+      break;
+    }
+
+    case PROP_FRAMERATE:
+    {
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object);
+
+      /* The framerate does not affect the video frame size,
+       * so it is just set directly without any updates */
+      props_cfg->framerate_n = GST_VIDEO_INFO_FPS_N (&(props_cfg->info)) =
+          gst_value_get_fraction_numerator (value);
+      props_cfg->framerate_d = GST_VIDEO_INFO_FPS_D (&(props_cfg->info)) =
+          gst_value_get_fraction_denominator (value);
+      GST_DEBUG_OBJECT (raw_video_parse, "setting framerate to %u/%u",
+          props_cfg->framerate_n, props_cfg->framerate_d);
+
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+      break;
+    }
+
+    case PROP_INTERLACED:
+    {
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object);
+
+      /* Interlacing does not affect the video frame size,
+       * so it is just set directly without any updates */
+      props_cfg->interlaced = g_value_get_boolean (value);
+      GST_VIDEO_INFO_INTERLACE_MODE (&(props_cfg->info)) =
+          props_cfg->interlaced ? GST_VIDEO_INTERLACE_MODE_INTERLEAVED :
+          GST_VIDEO_INTERLACE_MODE_PROGRESSIVE;
+
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+
+      break;
+    }
+
+    case PROP_TOP_FIELD_FIRST:
+    {
+      /* The top-field-first flag is a detail related to
+       * interlacing, so no video info update is needed */
+
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object);
+      props_cfg->top_field_first = g_value_get_boolean (value);
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+      break;
+    }
+
+    case PROP_PLANE_STRIDES:
+    {
+      GValueArray *valarray = g_value_get_boxed (value);
+      guint n_planes;
+      guint i;
+
+      /* Sanity check - reject empty arrays */
+      if ((valarray != NULL) && (valarray->n_values == 0)) {
+        GST_ELEMENT_ERROR (raw_video_parse, LIBRARY, SETTINGS,
+            ("plane strides property holds an empty array"), (NULL));
+        break;
+      }
+
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object);
+
+      n_planes = GST_VIDEO_INFO_N_PLANES (&(props_cfg->info));
+
+      /* Check that the valarray holds the right number of values */
+      if (valarray->n_values != n_planes) {
+        GST_ELEMENT_ERROR (raw_video_parse, LIBRARY, SETTINGS,
+            ("incorrect number of elements in plane strides property"),
+            ("expected: %u, got: %u", n_planes, valarray->n_values));
+        GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+        break;
+      }
+
+      /* Copy the values to the stride array */
+      for (i = 0; i < n_planes; ++i) {
+        GValue *val = g_value_array_get_nth (valarray, i);
+        props_cfg->plane_strides[i] = g_value_get_uint (val);
+        GST_DEBUG_OBJECT (raw_video_parse, "plane #%u stride: %d", i,
+            props_cfg->plane_strides[i]);
+      }
+
+      gst_raw_video_parse_update_info (props_cfg);
+
+      if (!gst_raw_video_parse_is_using_sink_caps (raw_video_parse))
+        gst_base_parse_set_min_frame_size (base_parse,
+            gst_raw_video_parse_get_config_frame_size (raw_base_parse,
+                GST_RAW_BASE_PARSE_CONFIG_PROPERTIES));
+
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+      break;
+    }
+
+    case PROP_PLANE_OFFSETS:
+    {
+      GValueArray *valarray = g_value_get_boxed (value);
+      guint n_planes;
+      guint i;
+
+      /* Sanity check - reject empty arrays */
+      if ((valarray != NULL) && (valarray->n_values == 0)) {
+        GST_ELEMENT_ERROR (raw_video_parse, LIBRARY, SETTINGS,
+            ("plane offsets property holds an empty array"), (NULL));
+        break;
+      }
+
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object);
+
+      n_planes = GST_VIDEO_INFO_N_PLANES (&(props_cfg->info));
+
+      /* Check that the valarray holds the right number of values */
+      if (valarray->n_values != n_planes) {
+        GST_ELEMENT_ERROR (raw_video_parse, LIBRARY, SETTINGS,
+            ("incorrect number of elements in plane offsets property"),
+            ("expected: %u, got: %u", n_planes, valarray->n_values));
+        GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+        break;
+      }
+
+      /* Copy the values to the offset array */
+      for (i = 0; i < n_planes; ++i) {
+        GValue *val = g_value_array_get_nth (valarray, i);
+        props_cfg->plane_offsets[i] = g_value_get_uint (val);
+        GST_DEBUG_OBJECT (raw_video_parse, "plane #%u offset: %" G_GSIZE_FORMAT,
+            i, props_cfg->plane_offsets[i]);
+      }
+
+      gst_raw_video_parse_update_info (props_cfg);
+
+      if (!gst_raw_video_parse_is_using_sink_caps (raw_video_parse))
+        gst_base_parse_set_min_frame_size (base_parse,
+            gst_raw_video_parse_get_config_frame_size (raw_base_parse,
+                GST_RAW_BASE_PARSE_CONFIG_PROPERTIES));
+
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+      break;
+    }
+
+    case PROP_FRAME_STRIDE:
+    {
+      /* The frame stride does not affect the video frame size,
+       * so it is just set directly without any updates */
+
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object);
+      props_cfg->frame_stride = g_value_get_uint (value);
+      gst_raw_video_parse_update_info (props_cfg);
+      if (!gst_raw_video_parse_is_using_sink_caps (raw_video_parse))
+        gst_base_parse_set_min_frame_size (base_parse,
+            gst_raw_video_parse_get_config_frame_size (raw_base_parse,
+                GST_RAW_BASE_PARSE_CONFIG_PROPERTIES));
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+
+      break;
+    }
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+  }
+}
+
+
+static void
+gst_raw_video_parse_get_property (GObject * object, guint prop_id,
+    GValue * value, GParamSpec * pspec)
+{
+  GstRawVideoParse *raw_video_parse = GST_RAW_VIDEO_PARSE (object);
+  GstRawVideoParseConfig *props_cfg = &(raw_video_parse->properties_config);
+
+  switch (prop_id) {
+    case PROP_WIDTH:
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object);
+      g_value_set_int (value, props_cfg->width);
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+      break;
+
+    case PROP_HEIGHT:
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object);
+      g_value_set_int (value, props_cfg->height);
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+      break;
+
+    case PROP_FORMAT:
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object);
+      g_value_set_enum (value, props_cfg->format);
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+      break;
+
+    case PROP_PIXEL_ASPECT_RATIO:
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object);
+      gst_value_set_fraction (value, props_cfg->pixel_aspect_ratio_n,
+          props_cfg->pixel_aspect_ratio_d);
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+
+      break;
+
+    case PROP_FRAMERATE:
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object);
+      gst_value_set_fraction (value, props_cfg->framerate_n,
+          props_cfg->framerate_d);
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+      break;
+
+    case PROP_INTERLACED:
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object);
+      g_value_set_boolean (value, props_cfg->interlaced);
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+      break;
+
+    case PROP_TOP_FIELD_FIRST:
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object);
+      g_value_set_boolean (value, props_cfg->top_field_first);
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+      break;
+
+    case PROP_PLANE_STRIDES:
+    {
+      guint i, n_planes;
+      GValue val = G_VALUE_INIT;
+      GValueArray *valarray;
+
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object);
+
+      n_planes = GST_VIDEO_INFO_N_PLANES (&(props_cfg->info));
+      valarray = g_value_array_new (n_planes);
+      g_value_init (&val, G_TYPE_UINT);
+
+      for (i = 0; i < n_planes; ++i) {
+        g_value_set_uint (&val, props_cfg->plane_strides[i]);
+        g_value_array_insert (valarray, i, &val);
+      }
+
+      g_value_unset (&val);
+
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+
+      /* Pass on ownership to the value array,
+       * since we don't need it anymore */
+      g_value_take_boxed (value, valarray);
+      break;
+    }
+
+    case PROP_PLANE_OFFSETS:
+    {
+      guint i, n_planes;
+      GValue val = G_VALUE_INIT;
+      GValueArray *valarray;
+
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object);
+
+      n_planes = GST_VIDEO_INFO_N_PLANES (&(props_cfg->info));
+      valarray = g_value_array_new (n_planes);
+      g_value_init (&val, G_TYPE_UINT);
+
+      for (i = 0; i < n_planes; ++i) {
+        g_value_set_uint (&val, props_cfg->plane_offsets[i]);
+        g_value_array_insert (valarray, i, &val);
+      }
+
+      g_value_unset (&val);
+
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+
+      /* Pass on ownership to the value array,
+       * since we don't need it anymore */
+      g_value_take_boxed (value, valarray);
+      break;
+    }
+
+    case PROP_FRAME_STRIDE:
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_LOCK (object);
+      g_value_set_uint (value, raw_video_parse->properties_config.frame_stride);
+      GST_RAW_BASE_PARSE_CONFIG_MUTEX_UNLOCK (object);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+  }
+}
+
+
+static gboolean
+gst_raw_video_parse_stop (GstBaseParse * parse)
+{
+  GstRawVideoParse *raw_video_parse = GST_RAW_VIDEO_PARSE (parse);
+
+  /* Sink caps config is not ready until caps come in.
+   * We are stopping processing, the element is being reset,
+   * so the config has to be un-readied.
+   * (Since the properties config is not depending on caps,
+   * its ready status is always TRUE.) */
+  raw_video_parse->sink_caps_config.ready = FALSE;
+
+  return GST_BASE_PARSE_CLASS (parent_class)->stop (parse);
+}
+
+
+static gboolean
+gst_raw_video_parse_set_current_config (GstRawBaseParse * raw_base_parse,
+    GstRawBaseParseConfig config)
+{
+  GstRawVideoParse *raw_video_parse = GST_RAW_VIDEO_PARSE (raw_base_parse);
+
+  switch (config) {
+    case GST_RAW_BASE_PARSE_CONFIG_PROPERTIES:
+      raw_video_parse->current_config = &(raw_video_parse->properties_config);
+      break;
+
+    case GST_RAW_BASE_PARSE_CONFIG_SINKCAPS:
+      raw_video_parse->current_config = &(raw_video_parse->sink_caps_config);
+      break;
+
+    default:
+      g_assert_not_reached ();
+  }
+
+  return TRUE;
+}
+
+
+static GstRawBaseParseConfig
+gst_raw_video_parse_get_current_config (GstRawBaseParse * raw_base_parse)
+{
+  GstRawVideoParse *raw_video_parse = GST_RAW_VIDEO_PARSE (raw_base_parse);
+  return gst_raw_video_parse_is_using_sink_caps (raw_video_parse) ?
+      GST_RAW_BASE_PARSE_CONFIG_SINKCAPS : GST_RAW_BASE_PARSE_CONFIG_PROPERTIES;
+}
+
+
+static gboolean
+gst_raw_video_parse_set_config_from_caps (GstRawBaseParse * raw_base_parse,
+    GstRawBaseParseConfig config, GstCaps * caps)
+{
+  int i;
+  GstStructure *structure;
+  GstRawVideoParse *raw_video_parse = GST_RAW_VIDEO_PARSE (raw_base_parse);
+  GstRawVideoParseConfig *config_ptr =
+      gst_raw_video_parse_get_config_ptr (raw_video_parse, config);
+
+  g_assert (caps != NULL);
+
+  /* Caps might get copied, and the copy needs to be unref'd.
+   * Also, the caller retains ownership over the original caps.
+   * So, to make this mechanism also work with cases where the
+   * caps are *not* copied, ref the original caps here first. */
+  gst_caps_ref (caps);
+
+  structure = gst_caps_get_structure (caps, 0);
+
+  /* For unaligned raw data, the output caps stay the same,
+   * except that video/x-unaligned-raw becomes video/x-raw,
+   * since the parser aligns the frame data */
+  if (gst_structure_has_name (structure, "video/x-unaligned-raw")) {
+    /* Copy the caps to be able to modify them */
+    GstCaps *new_caps = gst_caps_copy (caps);
+    gst_caps_unref (caps);
+    caps = new_caps;
+
+    /* Change the media type to video/x-raw , otherwise
+     * gst_video_info_from_caps() won't work */
+    structure = gst_caps_get_structure (caps, 0);
+    gst_structure_set_name (structure, "video/x-raw");
+  }
+
+  config_ptr->ready = gst_video_info_from_caps (&(config_ptr->info), caps);
+
+  if (config_ptr->ready) {
+    config_ptr->width = GST_VIDEO_INFO_WIDTH (&(config_ptr->info));
+    config_ptr->height = GST_VIDEO_INFO_HEIGHT (&(config_ptr->info));
+    config_ptr->pixel_aspect_ratio_n =
+        GST_VIDEO_INFO_PAR_N (&(config_ptr->info));
+    config_ptr->pixel_aspect_ratio_d =
+        GST_VIDEO_INFO_PAR_D (&(config_ptr->info));
+    config_ptr->framerate_n = GST_VIDEO_INFO_FPS_N (&(config_ptr->info));
+    config_ptr->framerate_d = GST_VIDEO_INFO_FPS_D (&(config_ptr->info));
+    config_ptr->interlaced = GST_VIDEO_INFO_IS_INTERLACED (&(config_ptr->info));
+    config_ptr->height = GST_VIDEO_INFO_HEIGHT (&(config_ptr->info));
+    config_ptr->top_field_first = 0;
+    config_ptr->frame_stride = 0;
+
+    for (i = 0; i < GST_VIDEO_MAX_PLANES; ++i) {
+      config_ptr->plane_offsets[i] =
+          GST_VIDEO_INFO_PLANE_OFFSET (&(config_ptr->info), i);
+      config_ptr->plane_strides[i] =
+          GST_VIDEO_INFO_PLANE_STRIDE (&(config_ptr->info), i);
+    }
+  }
+
+  gst_caps_unref (caps);
+
+  return config_ptr->ready;
+}
+
+
+static gboolean
+gst_raw_video_parse_get_caps_from_config (GstRawBaseParse * raw_base_parse,
+    GstRawBaseParseConfig config, GstCaps ** caps)
+{
+  GstRawVideoParse *raw_video_parse = GST_RAW_VIDEO_PARSE (raw_base_parse);
+  GstRawVideoParseConfig *config_ptr =
+      gst_raw_video_parse_get_config_ptr (raw_video_parse, config);
+
+  g_assert (caps != NULL);
+
+  *caps = gst_video_info_to_caps (&(config_ptr->info));
+
+  return *caps != NULL;
+}
+
+
+static gsize
+gst_raw_video_parse_get_config_frame_size (GstRawBaseParse * raw_base_parse,
+    GstRawBaseParseConfig config)
+{
+  GstRawVideoParse *raw_video_parse = GST_RAW_VIDEO_PARSE (raw_base_parse);
+  GstRawVideoParseConfig *config_ptr =
+      gst_raw_video_parse_get_config_ptr (raw_video_parse, config);
+  return MAX (GST_VIDEO_INFO_SIZE (&(config_ptr->info)),
+      (gsize) (config_ptr->frame_stride));
+}
+
+
+static guint
+gst_raw_video_parse_get_max_frames_per_buffer (G_GNUC_UNUSED GstRawBaseParse *
+    raw_base_parse, G_GNUC_UNUSED GstRawBaseParseConfig config)
+{
+  /* We want exactly one frame per buffer */
+  return 1;
+}
+
+
+static gboolean
+gst_raw_video_parse_is_config_ready (GstRawBaseParse * raw_base_parse,
+    GstRawBaseParseConfig config)
+{
+  GstRawVideoParse *raw_video_parse = GST_RAW_VIDEO_PARSE (raw_base_parse);
+  return gst_raw_video_parse_get_config_ptr (raw_video_parse, config)->ready;
+}
+
+
+static gboolean
+gst_raw_video_parse_process (GstRawBaseParse * raw_base_parse,
+    GstRawBaseParseConfig config, GstBuffer * in_data,
+    G_GNUC_UNUSED gsize total_num_in_bytes,
+    G_GNUC_UNUSED gsize num_valid_in_bytes, GstBuffer ** processed_data)
+{
+  GstRawVideoParse *raw_video_parse = GST_RAW_VIDEO_PARSE (raw_base_parse);
+  GstRawVideoParseConfig *config_ptr =
+      gst_raw_video_parse_get_config_ptr (raw_video_parse, config);
+  guint frame_flags = 0;
+  GstVideoInfo *video_info = &(config_ptr->info);
+  GstVideoMeta *videometa;
+  GstBuffer *out_data;
+
+  /* In case of extra padding bytes, get a subbuffer without the padding bytes.
+   * Otherwise, just add the video meta. */
+  if (GST_VIDEO_INFO_SIZE (video_info) < config_ptr->frame_stride) {
+    *processed_data = out_data =
+        gst_buffer_copy_region (in_data,
+        GST_BUFFER_COPY_FLAGS | GST_BUFFER_COPY_TIMESTAMPS |
+        GST_BUFFER_COPY_MEMORY, 0, GST_VIDEO_INFO_SIZE (video_info));
+  } else {
+    out_data = in_data;
+    *processed_data = NULL;
+  }
+
+  if (config_ptr->interlaced) {
+    GST_BUFFER_FLAG_SET (out_data, GST_VIDEO_BUFFER_FLAG_INTERLACED);
+    frame_flags |= GST_VIDEO_FRAME_FLAG_INTERLACED;
+
+    if (config_ptr->top_field_first) {
+      GST_BUFFER_FLAG_SET (out_data, GST_VIDEO_BUFFER_FLAG_TFF);
+      frame_flags |= GST_VIDEO_FRAME_FLAG_TFF;
+    } else
+      GST_BUFFER_FLAG_UNSET (out_data, GST_VIDEO_BUFFER_FLAG_TFF);
+  }
+
+  /* Remove any existing videometa - it will be replaced by the new videometa
+   * from here */
+  while ((videometa = gst_buffer_get_video_meta (out_data))) {
+    GST_LOG_OBJECT (raw_base_parse, "removing existing videometa from buffer");
+    gst_buffer_remove_meta (out_data, (GstMeta *) videometa);
+  }
+
+  gst_buffer_add_video_meta_full (out_data,
+      frame_flags,
+      config_ptr->format,
+      config_ptr->width,
+      config_ptr->height,
+      GST_VIDEO_INFO_N_PLANES (video_info),
+      config_ptr->plane_offsets, config_ptr->plane_strides);
+
+
+  return TRUE;
+}
+
+
+static gboolean
+gst_raw_video_parse_is_unit_format_supported (G_GNUC_UNUSED GstRawBaseParse *
+    raw_base_parse, GstFormat format)
+{
+  switch (format) {
+    case GST_FORMAT_BYTES:
+    case GST_FORMAT_DEFAULT:
+      return TRUE;
+    default:
+      return FALSE;
+  }
+}
+
+
+static void
+gst_raw_video_parse_get_units_per_second (GstRawBaseParse * raw_base_parse,
+    GstFormat format, GstRawBaseParseConfig config, gsize * units_per_sec_n,
+    gsize * units_per_sec_d)
+{
+  GstRawVideoParse *raw_video_parse = GST_RAW_VIDEO_PARSE (raw_base_parse);
+  GstRawVideoParseConfig *config_ptr =
+      gst_raw_video_parse_get_config_ptr (raw_video_parse, config);
+
+  switch (format) {
+    case GST_FORMAT_BYTES:
+    {
+      gsize framesize = GST_VIDEO_INFO_SIZE (&(config_ptr->info));
+      gint64 n = framesize * config_ptr->framerate_n;
+      gint64 d = config_ptr->framerate_d;
+      gint64 common_div = gst_util_greatest_common_divisor_int64 (n, d);
+      GST_DEBUG_OBJECT (raw_video_parse,
+          "n: %" G_GINT64_FORMAT " d: %" G_GINT64_FORMAT " common divisor: %"
+          G_GINT64_FORMAT, n, d, common_div);
+
+      /* Divide numerator and denominator by greatest common divisor.
+       * This minimizes the risk of integer overflows in the baseparse class. */
+      *units_per_sec_n = n / common_div;
+      *units_per_sec_d = d / common_div;
+
+      break;
+    }
+
+    case GST_FORMAT_DEFAULT:
+    {
+      *units_per_sec_n = config_ptr->framerate_n;
+      *units_per_sec_d = config_ptr->framerate_d;
+      break;
+    }
+
+    default:
+      g_assert_not_reached ();
+  }
+}
+
+
+static gint
+gst_raw_video_parse_get_overhead_size (GstRawBaseParse * raw_base_parse,
+    GstRawBaseParseConfig config)
+{
+  GstRawVideoParse *raw_video_parse = GST_RAW_VIDEO_PARSE (raw_base_parse);
+  GstRawVideoParseConfig *config_ptr =
+      gst_raw_video_parse_get_config_ptr (raw_video_parse, config);
+  gint64 frame_size = GST_VIDEO_INFO_SIZE (&(config_ptr->info));
+  gint64 frame_stride = config_ptr->frame_stride;
+
+  /* In the video parser, the overhead is defined by the difference between
+   * the frame stride and the actual frame size. If the former is larger,
+   * then the additional bytes are considered padding bytes and get ignored
+   * by the base class. */
+
+  GST_LOG_OBJECT (raw_video_parse,
+      "frame size: %" G_GINT64_FORMAT "  frame stride: %" G_GINT64_FORMAT,
+      frame_size, frame_stride);
+
+  return (frame_size < frame_stride) ? (gint) (frame_stride - frame_size) : 0;
+}
+
+
+static gboolean
+gst_raw_video_parse_is_using_sink_caps (GstRawVideoParse * raw_video_parse)
+{
+  return raw_video_parse->current_config ==
+      &(raw_video_parse->sink_caps_config);
+}
+
+
+static GstRawVideoParseConfig *
+gst_raw_video_parse_get_config_ptr (GstRawVideoParse * raw_video_parse,
+    GstRawBaseParseConfig config)
+{
+  g_assert (raw_video_parse->current_config != NULL);
+
+  switch (config) {
+    case GST_RAW_BASE_PARSE_CONFIG_PROPERTIES:
+      return &(raw_video_parse->properties_config);
+
+    case GST_RAW_BASE_PARSE_CONFIG_SINKCAPS:
+      return &(raw_video_parse->sink_caps_config);
+
+    default:
+      g_assert (raw_video_parse->current_config != NULL);
+      return raw_video_parse->current_config;
+  }
+}
+
+
+static void
+gst_raw_video_parse_init_config (GstRawVideoParseConfig * config)
+{
+  int i;
+
+  config->ready = FALSE;
+  config->width = DEFAULT_WIDTH;
+  config->height = DEFAULT_HEIGHT;
+  config->format = DEFAULT_FORMAT;
+  config->pixel_aspect_ratio_n = DEFAULT_PIXEL_ASPECT_RATIO_N;
+  config->pixel_aspect_ratio_d = DEFAULT_PIXEL_ASPECT_RATIO_D;
+  config->framerate_n = DEFAULT_FRAMERATE_N;
+  config->framerate_d = DEFAULT_FRAMERATE_D;
+  config->interlaced = DEFAULT_INTERLACED;
+
+  config->top_field_first = DEFAULT_TOP_FIELD_FIRST;
+  config->frame_stride = DEFAULT_FRAME_STRIDE;
+
+  gst_video_info_set_format (&(config->info), DEFAULT_FORMAT, DEFAULT_WIDTH,
+      DEFAULT_HEIGHT);
+  for (i = 0; i < GST_VIDEO_MAX_PLANES; ++i) {
+    config->plane_offsets[i] = GST_VIDEO_INFO_PLANE_OFFSET (&(config->info), i);
+    config->plane_strides[i] = GST_VIDEO_INFO_PLANE_STRIDE (&(config->info), i);
+  }
+}
+
+
+static void
+gst_raw_video_parse_update_info (GstRawVideoParseConfig * config)
+{
+  int i;
+  guint n_planes;
+  gsize last_plane_offset, last_plane_size;
+  GstVideoInfo *info = &(config->info);
+
+  gst_video_info_set_format (info, config->format, config->width,
+      config->height);
+
+  GST_VIDEO_INFO_PAR_N (info) = config->pixel_aspect_ratio_n;
+  GST_VIDEO_INFO_PAR_D (info) = config->pixel_aspect_ratio_d;
+  GST_VIDEO_INFO_FPS_N (info) = config->framerate_n;
+  GST_VIDEO_INFO_FPS_D (info) = config->framerate_d;
+  GST_VIDEO_INFO_INTERLACE_MODE (info) =
+      config->interlaced ? GST_VIDEO_INTERLACE_MODE_INTERLEAVED :
+      GST_VIDEO_INTERLACE_MODE_PROGRESSIVE;
+  for (i = 0; i < GST_VIDEO_MAX_PLANES; ++i) {
+    GST_VIDEO_INFO_PLANE_OFFSET (info, i) = config->plane_offsets[i];
+    GST_VIDEO_INFO_PLANE_STRIDE (info, i) = config->plane_strides[i];
+  }
+
+  n_planes = GST_VIDEO_INFO_N_PLANES (info);
+  if (n_planes < 1)
+    n_planes = 1;
+
+  last_plane_offset = GST_VIDEO_INFO_PLANE_OFFSET (info, n_planes - 1);
+  last_plane_size =
+      GST_VIDEO_INFO_PLANE_STRIDE (info,
+      n_planes - 1) * GST_VIDEO_FORMAT_INFO_SCALE_HEIGHT (info->finfo,
+      n_planes - 1, config->height);
+
+  GST_VIDEO_INFO_SIZE (info) = last_plane_offset + last_plane_size;
+
+  GST_DEBUG ("last plane offset: %" G_GSIZE_FORMAT " last plane size: %"
+      G_GSIZE_FORMAT " => frame size minus extra padding: %" G_GSIZE_FORMAT,
+      last_plane_offset, last_plane_size, GST_VIDEO_INFO_SIZE (info));
+}
diff --git a/gst/rawparse/gstrawvideoparse.h b/gst/rawparse/gstrawvideoparse.h
new file mode 100644
index 000000000..fea395598
--- /dev/null
+++ b/gst/rawparse/gstrawvideoparse.h
@@ -0,0 +1,116 @@
+/* GStreamer
+ * Copyright (C) <2016> Carlos Rafael Giani <dv at pseudoterminal dot org>
+ *
+ * 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_RAW_VIDEO_PARSE_H__
+#define __GST_RAW_VIDEO_PARSE_H__
+
+#include <gst/gst.h>
+#include <gst/video/video.h>
+#include "gstrawbaseparse.h"
+
+G_BEGIN_DECLS
+
+#define GST_TYPE_RAW_VIDEO_PARSE \
+  (gst_raw_video_parse_get_type())
+#define GST_RAW_VIDEO_PARSE(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj), GST_TYPE_RAW_VIDEO_PARSE, GstRawVideoParse))
+#define GST_RAW_VIDEO_PARSE_CAST(obj) \
+  ((GstRawVideoParse *)(obj))
+#define GST_RAW_VIDEO_PARSE_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_RAW_VIDEO_PARSE, GstRawVideoParseClass))
+#define GST_IS_RAW_VIDEO_PARSE(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj), GST_TYPE_RAW_VIDEO_PARSE))
+#define GST_IS_RAW_VIDEO_PARSE_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_TYPE((klass), GST_TYPE_RAW_VIDEO_PARSE))
+
+
+typedef struct _GstRawVideoParseConfig GstRawVideoParseConfig;
+typedef struct _GstRawVideoParse GstRawVideoParse;
+typedef struct _GstRawVideoParseClass GstRawVideoParseClass;
+
+
+/* Contains information about the video frame format. */
+struct _GstRawVideoParseConfig
+{
+  /* If TRUE, then this configuration is ready to use */
+  gboolean ready;
+
+  /* FIXME: These values should not be necessary, since there's
+   * GstVideoInfo. However, setting these values in the video
+   * info independently is currently difficult. For example,
+   * setting the video format requires the gst_video_info_set_format()
+   * function, but this function also overwrites plane strides
+   * and offsets. */
+  gint width, height;
+  GstVideoFormat format;
+  gint pixel_aspect_ratio_n, pixel_aspect_ratio_d;
+  gint framerate_n, framerate_d;
+  gboolean interlaced;
+  gsize plane_offsets[GST_VIDEO_MAX_PLANES];
+  gint plane_strides[GST_VIDEO_MAX_PLANES];
+
+  /* If TRUE, then TFF flags are added to outgoing buffers and
+   * their video metadata */
+  gboolean top_field_first;
+
+  /* Distance between the start of each frame, in bytes. If this value
+   * is larger than the actual size of a frame, then the extra bytes
+   * are skipped. For example, with frames that have 115200 bytes, a
+   * frame_stride value of 120000 means that 4800 trailing bytes are
+   * skipped after the 115200 frame bytes. This is useful to skip
+   * metadata in between frames. */
+  guint frame_stride;
+
+  GstVideoInfo info;
+};
+
+
+struct _GstRawVideoParse
+{
+  GstRawBaseParse parent;
+
+  /*< private > */
+
+  /* Configuration controlled by the object properties. Its ready value
+   * is set to TRUE from the start, so it can be used right away.
+   */
+  GstRawVideoParseConfig properties_config;
+  /* Configuration controlled by the sink caps. Its ready value is
+   * initially set to FALSE until valid sink caps come in. It is set to
+   * FALSE again when the stream-start event is observed.
+   */
+  GstRawVideoParseConfig sink_caps_config;
+  /* Currently active configuration. Points either to properties_config
+   * or to sink_caps_config. This is never NULL. */
+  GstRawVideoParseConfig *current_config;
+};
+
+
+struct _GstRawVideoParseClass
+{
+  GstRawBaseParseClass parent_class;
+};
+
+
+GType gst_raw_video_parse_get_type (void);
+
+
+G_END_DECLS
+
+#endif
diff --git a/gst/rawparse/gstunalignedaudioparse.c b/gst/rawparse/gstunalignedaudioparse.c
index 62a83f363..786f4f444 100644
--- a/gst/rawparse/gstunalignedaudioparse.c
+++ b/gst/rawparse/gstunalignedaudioparse.c
@@ -96,7 +96,7 @@ gst_unaligned_audio_parse_init (GstUnalignedAudioParse * unaligned_audio_parse)
   GstPad *ghostpad;
 
   unaligned_audio_parse->inner_parser =
-      gst_element_factory_make ("audioparse", "inner_parser");
+      gst_element_factory_make ("rawaudioaudioparse", "inner_parser");
   g_assert (unaligned_audio_parse->inner_parser != NULL);
 
   g_object_set (G_OBJECT (unaligned_audio_parse->inner_parser),
diff --git a/gst/rawparse/gstunalignedvideoparse.c b/gst/rawparse/gstunalignedvideoparse.c
new file mode 100644
index 000000000..d6e8cf36e
--- /dev/null
+++ b/gst/rawparse/gstunalignedvideoparse.c
@@ -0,0 +1,124 @@
+/* GStreamer
+ * Copyright (C) 2016 Carlos Rafael Giani <dv@pseudoterminal.org>
+ *
+ * gstunalignedvideoparse.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.
+ */
+
+#include <string.h>
+#include <stdio.h>
+#include <gst/gst.h>
+#include <gst/video/video.h>
+#include "gstunalignedvideoparse.h"
+#include "unalignedvideo.h"
+
+
+GST_DEBUG_CATEGORY (unaligned_video_parse_debug);
+#define GST_CAT_DEFAULT unaligned_video_parse_debug
+
+
+struct _GstUnalignedVideoParse
+{
+  GstBin parent;
+  GstElement *inner_parser;
+};
+
+
+struct _GstUnalignedVideoParseClass
+{
+  GstBinClass parent_class;
+};
+
+
+static GstStaticPadTemplate static_sink_template =
+GST_STATIC_PAD_TEMPLATE ("sink",
+    GST_PAD_SINK,
+    GST_PAD_ALWAYS,
+    GST_STATIC_CAPS (GST_UNALIGNED_RAW_VIDEO_CAPS)
+    );
+
+
+static GstStaticPadTemplate static_src_template =
+GST_STATIC_PAD_TEMPLATE ("src",
+    GST_PAD_SRC,
+    GST_PAD_ALWAYS,
+    GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE (GST_VIDEO_FORMATS_ALL))
+    );
+
+
+
+
+G_DEFINE_TYPE (GstUnalignedVideoParse, gst_unaligned_video_parse, GST_TYPE_BIN);
+
+
+static void
+gst_unaligned_video_parse_class_init (GstUnalignedVideoParseClass * klass)
+{
+  GstElementClass *element_class;
+
+  GST_DEBUG_CATEGORY_INIT (unaligned_video_parse_debug, "unalignedvideoparse",
+      0, "Unaligned raw video parser");
+
+  element_class = GST_ELEMENT_CLASS (klass);
+
+  gst_element_class_add_pad_template (element_class,
+      gst_static_pad_template_get (&static_sink_template));
+  gst_element_class_add_pad_template (element_class,
+      gst_static_pad_template_get (&static_src_template));
+
+  gst_element_class_set_static_metadata (element_class,
+      "unalignedvideoparse",
+      "Codec/Parser/Bin/Video",
+      "Parse unaligned raw video data",
+      "Carlos Rafael Giani <dv@pseudoterminal.org>");
+}
+
+
+static void
+gst_unaligned_video_parse_init (GstUnalignedVideoParse * unaligned_video_parse)
+{
+  GstPad *inner_pad;
+  GstPad *ghostpad;
+
+  unaligned_video_parse->inner_parser =
+      gst_element_factory_make ("rawvideoparse", "inner_parser");
+  g_assert (unaligned_video_parse->inner_parser != NULL);
+
+  g_object_set (G_OBJECT (unaligned_video_parse->inner_parser),
+      "use-sink-caps", TRUE, NULL);
+
+  gst_bin_add (GST_BIN (unaligned_video_parse),
+      unaligned_video_parse->inner_parser);
+
+  inner_pad =
+      gst_element_get_static_pad (unaligned_video_parse->inner_parser, "sink");
+  ghostpad =
+      gst_ghost_pad_new_from_template ("sink", inner_pad,
+      gst_element_class_get_pad_template (GST_ELEMENT_GET_CLASS
+          (unaligned_video_parse), "sink"));
+  gst_element_add_pad (GST_ELEMENT (unaligned_video_parse), ghostpad);
+  gst_object_unref (GST_OBJECT (inner_pad));
+
+  inner_pad = gst_element_get_static_pad (unaligned_video_parse->inner_parser,
+      "src");
+  ghostpad =
+      gst_ghost_pad_new_from_template ("src", inner_pad,
+      gst_element_class_get_pad_template (GST_ELEMENT_GET_CLASS
+          (unaligned_video_parse), "src"));
+  gst_element_add_pad (GST_ELEMENT (unaligned_video_parse), ghostpad);
+  gst_object_unref (GST_OBJECT (inner_pad));
+}
diff --git a/gst/rawparse/gstunalignedvideoparse.h b/gst/rawparse/gstunalignedvideoparse.h
new file mode 100644
index 000000000..da40ac942
--- /dev/null
+++ b/gst/rawparse/gstunalignedvideoparse.h
@@ -0,0 +1,49 @@
+/* GStreamer
+ * Copyright (C) 2016 Carlos Rafael Giani <dv@pseudoterminal.org>
+ *
+ * gstunalignedvideoparse.h:
+ *
+ * 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_UNALIGNED_VIDEO_PARSE_H___
+#define __GST_UNALIGNED_VIDEO_PARSE_H___
+
+#include <gst/gst.h>
+
+G_BEGIN_DECLS
+
+#define GST_TYPE_UNALIGNED_VIDEO_PARSE \
+  (gst_unaligned_video_parse_get_type())
+#define GST_UNALIGNED_VIDEO_PARSE(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj), GST_TYPE_UNALIGNED_VIDEO_PARSE, GstUnalignedVideoParse))
+#define GST_UNALIGNED_VIDEO_PARSE_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_UNALIGNED_VIDEO_PARSE, GstUnalignedVideoParseClass))
+#define GST_UNALIGNED_VIDEO_PARSE_CAST(obj) \
+  ((GstUnalignedVideoParse *)(obj))
+#define GST_IS_UNALIGNED_VIDEO_PARSE(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj), GST_TYPE_UNALIGNED_VIDEO_PARSE))
+#define GST_IS_UNALIGNED_VIDEO_PARSE_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_TYPE((klass), GST_TYPE_UNALIGNED_VIDEO_PARSE))
+
+typedef struct _GstUnalignedVideoParse GstUnalignedVideoParse;
+typedef struct _GstUnalignedVideoParseClass GstUnalignedVideoParseClass;
+
+GType gst_unaligned_video_parse_get_type (void);
+
+G_END_DECLS
+
+#endif /* __GST_UNALIGNED_VIDEO_PARSE_H___ */
diff --git a/gst/rawparse/plugin.c b/gst/rawparse/plugin.c
index bb21f77b1..72b3e49ea 100644
--- a/gst/rawparse/plugin.c
+++ b/gst/rawparse/plugin.c
@@ -3,7 +3,10 @@
 #endif
 
 #include <gst/gst.h>
+#include "gstrawaudioparse.h"
+#include "gstrawvideoparse.h"
 #include "gstunalignedaudioparse.h"
+#include "gstunalignedvideoparse.h"
 #include "gstaudioparse.h"
 #include "gstvideoparse.h"
 
@@ -18,6 +21,12 @@ plugin_init (GstPlugin * plugin)
       gst_audio_parse_get_type ());
   ret &= gst_element_register (plugin, "unalignedaudioparse", GST_RANK_MARGINAL,
       gst_unaligned_audio_parse_get_type ());
+  ret &= gst_element_register (plugin, "unalignedvideoparse", GST_RANK_MARGINAL,
+      gst_unaligned_video_parse_get_type ());
+  ret &= gst_element_register (plugin, "rawaudioparse", GST_RANK_NONE,
+      gst_raw_audio_parse_get_type ());
+  ret &= gst_element_register (plugin, "rawvideoparse", GST_RANK_NONE,
+      gst_raw_video_parse_get_type ());
 
   return ret;
 }
diff --git a/gst/rawparse/unalignedvideo.h b/gst/rawparse/unalignedvideo.h
new file mode 100644
index 000000000..a5c100532
--- /dev/null
+++ b/gst/rawparse/unalignedvideo.h
@@ -0,0 +1,35 @@
+/* GStreamer
+ * Copyright (C) 2016 Carlos Rafael Giani <dv@pseudoterminal.org>
+ *
+ * unalignedvideo.h:
+ *
+ * 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_UNALIGNED_VIDEO_H__
+#define __GST_UNALIGNED_VIDEO_H__
+
+#include <gst/gst.h>
+#include <gst/video/video.h>
+
+#define GST_UNALIGNED_RAW_VIDEO_CAPS \
+  "video/x-unaligned-raw" \
+  ", format = (string) " GST_VIDEO_FORMATS_ALL \
+  ", width = " GST_VIDEO_SIZE_RANGE \
+  ", height = " GST_VIDEO_SIZE_RANGE \
+  ", framerate = " GST_VIDEO_FPS_RANGE
+
+#endif /* __GST_UNALIGNED_VIDEO_H__ */