/* GStreamer

 * Copyright (C) <2011> Stefan Kost <ensonic@users.sf.net>

 * Copyright (C) <2015> Luis de Bethencourt <luis@debethencourt.com>

 *

 * gstaudiovisualizer.h: base class for audio visualisation elements

 *

 * 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:gstaudiovisualizer

 * @title: GstAudioVisualizer

 *

 * A baseclass for scopes (visualizers). It takes care of re-fitting the

 * audio-rate to video-rate and handles renegotiation (downstream video size

 * changes).

 *

 * It also provides several background shading effects. These effects are

 * applied to a previous picture before the render() implementation can draw a

 * new frame.

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <string.h>

#include <gst/video/video.h>

#include <gst/video/gstvideometa.h>

#include <gst/video/gstvideopool.h>

#include "gstaudiovisualizer.h"

#include "pbutils-enumtypes.h"

GST_DEBUG_CATEGORY_STATIC (audio_visualizer_debug);

#define GST_CAT_DEFAULT (audio_visualizer_debug)

#define DEFAULT_SHADER GST_AUDIO_VISUALIZER_SHADER_FADE

#define DEFAULT_SHADE_AMOUNT   0x000a0a0a

enum

{

  PROP_0,

  PROP_SHADER,

  PROP_SHADE_AMOUNT

};

static GstBaseTransformClass *parent_class = NULL;

static void gst_audio_visualizer_class_init (GstAudioVisualizerClass * klass);

static void gst_audio_visualizer_init (GstAudioVisualizer * scope,

    GstAudioVisualizerClass * g_class);

static void gst_audio_visualizer_set_property (GObject * object,

    guint prop_id, const GValue * value, GParamSpec * pspec);

static void gst_audio_visualizer_get_property (GObject * object,

    guint prop_id, GValue * value, GParamSpec * pspec);

static void gst_audio_visualizer_dispose (GObject * object);

static gboolean gst_audio_visualizer_src_negotiate (GstAudioVisualizer * scope);

static gboolean gst_audio_visualizer_src_setcaps (GstAudioVisualizer *

    scope, GstCaps * caps);

static gboolean gst_audio_visualizer_sink_setcaps (GstAudioVisualizer *

    scope, GstCaps * caps);

static GstFlowReturn gst_audio_visualizer_chain (GstPad * pad,

    GstObject * parent, GstBuffer * buffer);

static gboolean gst_audio_visualizer_src_event (GstPad * pad,

    GstObject * parent, GstEvent * event);

static gboolean gst_audio_visualizer_sink_event (GstPad * pad,

    GstObject * parent, GstEvent * event);

static gboolean gst_audio_visualizer_src_query (GstPad * pad,

    GstObject * parent, GstQuery * query);

static GstStateChangeReturn gst_audio_visualizer_change_state (GstElement *

    element, GstStateChange transition);

static gboolean gst_audio_visualizer_do_bufferpool (GstAudioVisualizer * scope,

    GstCaps * outcaps);

static gboolean

default_decide_allocation (GstAudioVisualizer * scope, GstQuery * query);

#define GST_AUDIO_VISUALIZER_GET_PRIVATE(obj)  \

    (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_AUDIO_VISUALIZER, GstAudioVisualizerPrivate))

struct _GstAudioVisualizerPrivate

{

  gboolean negotiated;

  GstBufferPool *pool;

  gboolean pool_active;

  GstAllocator *allocator;

  GstAllocationParams params;

  GstQuery *query;

  /* pads */

  GstPad *srcpad, *sinkpad;

  GstAudioVisualizerShader shader_type;

  GstAudioVisualizerShaderFunc shader;

  guint32 shade_amount;

  GstAdapter *adapter;

  GstBuffer *inbuf;

  GstBuffer *tempbuf;

  GstVideoFrame tempframe;

  guint spf;                    /* samples per video frame */

  guint64 frame_duration;

  /* QoS stuff *//* with LOCK */

  gdouble proportion;

  GstClockTime earliest_time;

  guint dropped;                /* frames dropped / not dropped */

  guint processed;

  /* configuration mutex */

  GMutex config_lock;

  GstSegment segment;

};

/* shading functions */

/* we're only supporting GST_VIDEO_FORMAT_xRGB right now) */

#if G_BYTE_ORDER == G_LITTLE_ENDIAN

#define SHADE(_d, _s, _i, _r, _g, _b)                     \

G_STMT_START {                                            \

    _d[_i * 4 + 0] = (_s[_i * 4 + 0] > _b) ? _s[_i * 4 + 0] - _b : 0; \

    _d[_i * 4 + 1] = (_s[_i * 4 + 1] > _g) ? _s[_i * 4 + 1] - _g : 0; \

    _d[_i * 4 + 2] = (_s[_i * 4 + 2] > _r) ? _s[_i * 4 + 2] - _r : 0; \

    _d[_i * 4 + 3] = 0;                                       \

} G_STMT_END

#else /* G_BYTE_ORDER == G_LITTLE_ENDIAN */

#define SHADE(_d, _s, _i, _r, _g, _b)                     \

G_STMT_START {                                            \

    _d[_i * 4 + 0] = 0;                                       \

    _d[_i * 4 + 1] = (_s[_i * 4 + 1] > _r) ? _s[_i * 4 + 1] - _r : 0; \

    _d[_i * 4 + 2] = (_s[_i * 4 + 2] > _g) ? _s[_i * 4 + 2] - _g : 0; \

    _d[_i * 4 + 3] = (_s[_i * 4 + 3] > _b) ? _s[_i * 4 + 3] - _b : 0; \

} G_STMT_END

#endif

static void

shader_fade (GstAudioVisualizer * scope, const GstVideoFrame * sframe,

    GstVideoFrame * dframe)

{

  guint i, j;

  guint r = (scope->priv->shade_amount >> 16) & 0xff;

  guint g = (scope->priv->shade_amount >> 8) & 0xff;

  guint b = (scope->priv->shade_amount >> 0) & 0xff;

  guint8 *s, *d;

  gint ss, ds, width, height;

  s = GST_VIDEO_FRAME_PLANE_DATA (sframe, 0);

  ss = GST_VIDEO_FRAME_PLANE_STRIDE (sframe, 0);

  d = GST_VIDEO_FRAME_PLANE_DATA (dframe, 0);

  ds = GST_VIDEO_FRAME_PLANE_STRIDE (dframe, 0);

  width = GST_VIDEO_FRAME_WIDTH (sframe);

  height = GST_VIDEO_FRAME_HEIGHT (sframe);

  for (j = 0; j < height; j++) {

    for (i = 0; i < width; i++) {

      SHADE (d, s, i, r, g, b);

    }

    s += ss;

    d += ds;

  }

}

static void

shader_fade_and_move_up (GstAudioVisualizer * scope,

    const GstVideoFrame * sframe, GstVideoFrame * dframe)

{

  guint i, j;

  guint r = (scope->priv->shade_amount >> 16) & 0xff;

  guint g = (scope->priv->shade_amount >> 8) & 0xff;

  guint b = (scope->priv->shade_amount >> 0) & 0xff;

  guint8 *s, *d;

  gint ss, ds, width, height;

  s = GST_VIDEO_FRAME_PLANE_DATA (sframe, 0);

  ss = GST_VIDEO_FRAME_PLANE_STRIDE (sframe, 0);

  d = GST_VIDEO_FRAME_PLANE_DATA (dframe, 0);

  ds = GST_VIDEO_FRAME_PLANE_STRIDE (dframe, 0);

  width = GST_VIDEO_FRAME_WIDTH (sframe);

  height = GST_VIDEO_FRAME_HEIGHT (sframe);

  for (j = 1; j < height; j++) {

    s += ss;

    for (i = 0; i < width; i++) {

      SHADE (d, s, i, r, g, b);

    }

    d += ds;

  }

}

static void

shader_fade_and_move_down (GstAudioVisualizer * scope,

    const GstVideoFrame * sframe, GstVideoFrame * dframe)

{

  guint i, j;

  guint r = (scope->priv->shade_amount >> 16) & 0xff;

  guint g = (scope->priv->shade_amount >> 8) & 0xff;

  guint b = (scope->priv->shade_amount >> 0) & 0xff;

  guint8 *s, *d;

  gint ss, ds, width, height;

  s = GST_VIDEO_FRAME_PLANE_DATA (sframe, 0);

  ss = GST_VIDEO_FRAME_PLANE_STRIDE (sframe, 0);

  d = GST_VIDEO_FRAME_PLANE_DATA (dframe, 0);

  ds = GST_VIDEO_FRAME_PLANE_STRIDE (dframe, 0);

  width = GST_VIDEO_FRAME_WIDTH (sframe);

  height = GST_VIDEO_FRAME_HEIGHT (sframe);

  for (j = 1; j < height; j++) {

    d += ds;

    for (i = 0; i < width; i++) {

      SHADE (d, s, i, r, g, b);

    }

    s += ss;

  }

}

static void

shader_fade_and_move_left (GstAudioVisualizer * scope,

    const GstVideoFrame * sframe, GstVideoFrame * dframe)

{

  guint i, j;

  guint r = (scope->priv->shade_amount >> 16) & 0xff;

  guint g = (scope->priv->shade_amount >> 8) & 0xff;

  guint b = (scope->priv->shade_amount >> 0) & 0xff;

  guint8 *s, *d;

  gint ss, ds, width, height;

  s = GST_VIDEO_FRAME_PLANE_DATA (sframe, 0);

  ss = GST_VIDEO_FRAME_PLANE_STRIDE (sframe, 0);

  d = GST_VIDEO_FRAME_PLANE_DATA (dframe, 0);

  ds = GST_VIDEO_FRAME_PLANE_STRIDE (dframe, 0);

  width = GST_VIDEO_FRAME_WIDTH (sframe);

  height = GST_VIDEO_FRAME_HEIGHT (sframe);

  width -= 1;

  s += 4;

  /* move to the left */

  for (j = 0; j < height; j++) {

    for (i = 0; i < width; i++) {

      SHADE (d, s, i, r, g, b);

    }

    d += ds;

    s += ss;

  }

}

static void

shader_fade_and_move_right (GstAudioVisualizer * scope,

    const GstVideoFrame * sframe, GstVideoFrame * dframe)

{

  guint i, j;

  guint r = (scope->priv->shade_amount >> 16) & 0xff;

  guint g = (scope->priv->shade_amount >> 8) & 0xff;

  guint b = (scope->priv->shade_amount >> 0) & 0xff;

  guint8 *s, *d;

  gint ss, ds, width, height;

  s = GST_VIDEO_FRAME_PLANE_DATA (sframe, 0);

  ss = GST_VIDEO_FRAME_PLANE_STRIDE (sframe, 0);

  d = GST_VIDEO_FRAME_PLANE_DATA (dframe, 0);

  ds = GST_VIDEO_FRAME_PLANE_STRIDE (dframe, 0);

  width = GST_VIDEO_FRAME_WIDTH (sframe);

  height = GST_VIDEO_FRAME_HEIGHT (sframe);

  width -= 1;

  d += 4;

  /* move to the right */

  for (j = 0; j < height; j++) {

    for (i = 0; i < width; i++) {

      SHADE (d, s, i, r, g, b);

    }

    d += ds;

    s += ss;

  }

}

static void

shader_fade_and_move_horiz_out (GstAudioVisualizer * scope,

    const GstVideoFrame * sframe, GstVideoFrame * dframe)

{

  guint i, j;

  guint r = (scope->priv->shade_amount >> 16) & 0xff;

  guint g = (scope->priv->shade_amount >> 8) & 0xff;

  guint b = (scope->priv->shade_amount >> 0) & 0xff;

  guint8 *s, *d;

  gint ss, ds, width, height;

  s = GST_VIDEO_FRAME_PLANE_DATA (sframe, 0);

  ss = GST_VIDEO_FRAME_PLANE_STRIDE (sframe, 0);

  d = GST_VIDEO_FRAME_PLANE_DATA (dframe, 0);

  ds = GST_VIDEO_FRAME_PLANE_STRIDE (dframe, 0);

  width = GST_VIDEO_FRAME_WIDTH (sframe);

  height = GST_VIDEO_FRAME_HEIGHT (sframe);

  /* move upper half up */

  for (j = 0; j < height / 2; j++) {

    s += ss;

    for (i = 0; i < width; i++) {

      SHADE (d, s, i, r, g, b);

    }

    d += ds;

  }

  /* move lower half down */

  for (j = 0; j < height / 2; j++) {

    d += ds;

    for (i = 0; i < width; i++) {

      SHADE (d, s, i, r, g, b);

    }

    s += ss;

  }

}

static void

shader_fade_and_move_horiz_in (GstAudioVisualizer * scope,

    const GstVideoFrame * sframe, GstVideoFrame * dframe)

{

  guint i, j;

  guint r = (scope->priv->shade_amount >> 16) & 0xff;

  guint g = (scope->priv->shade_amount >> 8) & 0xff;

  guint b = (scope->priv->shade_amount >> 0) & 0xff;

  guint8 *s, *d;

  gint ss, ds, width, height;

  s = GST_VIDEO_FRAME_PLANE_DATA (sframe, 0);

  ss = GST_VIDEO_FRAME_PLANE_STRIDE (sframe, 0);

  d = GST_VIDEO_FRAME_PLANE_DATA (dframe, 0);

  ds = GST_VIDEO_FRAME_PLANE_STRIDE (dframe, 0);

  width = GST_VIDEO_FRAME_WIDTH (sframe);

  height = GST_VIDEO_FRAME_HEIGHT (sframe);

  /* move upper half down */

  for (j = 0; j < height / 2; j++) {

    d += ds;

    for (i = 0; i < width; i++) {

      SHADE (d, s, i, r, g, b);

    }

    s += ss;

  }

  /* move lower half up */

  for (j = 0; j < height / 2; j++) {

    s += ss;

    for (i = 0; i < width; i++) {

      SHADE (d, s, i, r, g, b);

    }

    d += ds;

  }

}

static void

shader_fade_and_move_vert_out (GstAudioVisualizer * scope,

    const GstVideoFrame * sframe, GstVideoFrame * dframe)

{

  guint i, j;

  guint r = (scope->priv->shade_amount >> 16) & 0xff;

  guint g = (scope->priv->shade_amount >> 8) & 0xff;

  guint b = (scope->priv->shade_amount >> 0) & 0xff;

  guint8 *s, *s1, *d, *d1;

  gint ss, ds, width, height;

  s = GST_VIDEO_FRAME_PLANE_DATA (sframe, 0);

  ss = GST_VIDEO_FRAME_PLANE_STRIDE (sframe, 0);

  d = GST_VIDEO_FRAME_PLANE_DATA (dframe, 0);

  ds = GST_VIDEO_FRAME_PLANE_STRIDE (dframe, 0);

  width = GST_VIDEO_FRAME_WIDTH (sframe);

  height = GST_VIDEO_FRAME_HEIGHT (sframe);

  for (j = 0; j < height; j++) {

    /* move left half to the left */

    s1 = s + 1;

    for (i = 0; i < width / 2; i++) {

      SHADE (d, s1, i, r, g, b);

    }

    /* move right half to the right */

    d1 = d + 1;

    for (; i < width - 1; i++) {

      SHADE (d1, s, i, r, g, b);

    }

    s += ss;

    d += ds;

  }

}

static void

shader_fade_and_move_vert_in (GstAudioVisualizer * scope,

    const GstVideoFrame * sframe, GstVideoFrame * dframe)

{

  guint i, j;

  guint r = (scope->priv->shade_amount >> 16) & 0xff;

  guint g = (scope->priv->shade_amount >> 8) & 0xff;

  guint b = (scope->priv->shade_amount >> 0) & 0xff;

  guint8 *s, *s1, *d, *d1;

  gint ss, ds, width, height;

  s = GST_VIDEO_FRAME_PLANE_DATA (sframe, 0);

  ss = GST_VIDEO_FRAME_PLANE_STRIDE (sframe, 0);

  d = GST_VIDEO_FRAME_PLANE_DATA (dframe, 0);

  ds = GST_VIDEO_FRAME_PLANE_STRIDE (dframe, 0);

  width = GST_VIDEO_FRAME_WIDTH (sframe);

  height = GST_VIDEO_FRAME_HEIGHT (sframe);

  for (j = 0; j < height; j++) {

    /* move left half to the right */

    d1 = d + 1;

    for (i = 0; i < width / 2; i++) {

      SHADE (d1, s, i, r, g, b);

    }

    /* move right half to the left */

    s1 = s + 1;

    for (; i < width - 1; i++) {

      SHADE (d, s1, i, r, g, b);

    }

    s += ss;

    d += ds;

  }

}

static void

gst_audio_visualizer_change_shader (GstAudioVisualizer * scope)

{

  switch (scope->priv->shader_type) {

    case GST_AUDIO_VISUALIZER_SHADER_NONE:

      scope->priv->shader = NULL;

      break;

    case GST_AUDIO_VISUALIZER_SHADER_FADE:

      scope->priv->shader = shader_fade;

      break;

    case GST_AUDIO_VISUALIZER_SHADER_FADE_AND_MOVE_UP:

      scope->priv->shader = shader_fade_and_move_up;

      break;

    case GST_AUDIO_VISUALIZER_SHADER_FADE_AND_MOVE_DOWN:

      scope->priv->shader = shader_fade_and_move_down;

      break;

    case GST_AUDIO_VISUALIZER_SHADER_FADE_AND_MOVE_LEFT:

      scope->priv->shader = shader_fade_and_move_left;

      break;

    case GST_AUDIO_VISUALIZER_SHADER_FADE_AND_MOVE_RIGHT:

      scope->priv->shader = shader_fade_and_move_right;

      break;

    case GST_AUDIO_VISUALIZER_SHADER_FADE_AND_MOVE_HORIZ_OUT:

      scope->priv->shader = shader_fade_and_move_horiz_out;

      break;

    case GST_AUDIO_VISUALIZER_SHADER_FADE_AND_MOVE_HORIZ_IN:

      scope->priv->shader = shader_fade_and_move_horiz_in;

      break;

    case GST_AUDIO_VISUALIZER_SHADER_FADE_AND_MOVE_VERT_OUT:

      scope->priv->shader = shader_fade_and_move_vert_out;

      break;

    case GST_AUDIO_VISUALIZER_SHADER_FADE_AND_MOVE_VERT_IN:

      scope->priv->shader = shader_fade_and_move_vert_in;

      break;

    default:

      GST_ERROR ("invalid shader function");

      scope->priv->shader = NULL;

      break;

  }

}

/* base class */

GType

gst_audio_visualizer_get_type (void)

{

  static volatile gsize audio_visualizer_type = 0;

  if (g_once_init_enter (&audio_visualizer_type)) {

    static const GTypeInfo audio_visualizer_info = {

      sizeof (GstAudioVisualizerClass),

      NULL,

      NULL,

      (GClassInitFunc) gst_audio_visualizer_class_init,

      NULL,

      NULL,

      sizeof (GstAudioVisualizer),

      0,

      (GInstanceInitFunc) gst_audio_visualizer_init,

    };

    GType _type;

    /* TODO: rename when exporting it as a library */

    _type = g_type_register_static (GST_TYPE_ELEMENT,

        "GstAudioVisualizer", &audio_visualizer_info, G_TYPE_FLAG_ABSTRACT);

    g_once_init_leave (&audio_visualizer_type, _type);

  }

  return (GType) audio_visualizer_type;

}

static void

gst_audio_visualizer_class_init (GstAudioVisualizerClass * klass)

{

  GObjectClass *gobject_class = (GObjectClass *) klass;

  GstElementClass *element_class = (GstElementClass *) klass;

  g_type_class_add_private (klass, sizeof (GstAudioVisualizerPrivate));

  parent_class = g_type_class_peek_parent (klass);

  GST_DEBUG_CATEGORY_INIT (audio_visualizer_debug,

      "baseaudiovisualizer-libvisual", 0,

      "scope audio visualisation base class");

  gobject_class->set_property = gst_audio_visualizer_set_property;

  gobject_class->get_property = gst_audio_visualizer_get_property;

  gobject_class->dispose = gst_audio_visualizer_dispose;

  element_class->change_state =

      GST_DEBUG_FUNCPTR (gst_audio_visualizer_change_state);

  klass->decide_allocation = GST_DEBUG_FUNCPTR (default_decide_allocation);

  g_object_class_install_property (gobject_class, PROP_SHADER,

      g_param_spec_enum ("shader", "shader type",

          "Shader function to apply on each frame",

          GST_TYPE_AUDIO_VISUALIZER_SHADER, DEFAULT_SHADER,

          G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_SHADE_AMOUNT,

      g_param_spec_uint ("shade-amount", "shade amount",

          "Shading color to use (big-endian ARGB)", 0, G_MAXUINT32,

          DEFAULT_SHADE_AMOUNT,

          G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS));

}

static void

gst_audio_visualizer_init (GstAudioVisualizer * scope,

    GstAudioVisualizerClass * g_class)

{

  GstPadTemplate *pad_template;

  scope->priv = GST_AUDIO_VISUALIZER_GET_PRIVATE (scope);

  /* create the sink and src pads */

  pad_template =

      gst_element_class_get_pad_template (GST_ELEMENT_CLASS (g_class), "sink");

  g_return_if_fail (pad_template != NULL);

  scope->priv->sinkpad = gst_pad_new_from_template (pad_template, "sink");

  gst_pad_set_chain_function (scope->priv->sinkpad,

      GST_DEBUG_FUNCPTR (gst_audio_visualizer_chain));

  gst_pad_set_event_function (scope->priv->sinkpad,

      GST_DEBUG_FUNCPTR (gst_audio_visualizer_sink_event));

  gst_element_add_pad (GST_ELEMENT (scope), scope->priv->sinkpad);

  pad_template =

      gst_element_class_get_pad_template (GST_ELEMENT_CLASS (g_class), "src");

  g_return_if_fail (pad_template != NULL);

  scope->priv->srcpad = gst_pad_new_from_template (pad_template, "src");

  gst_pad_set_event_function (scope->priv->srcpad,

      GST_DEBUG_FUNCPTR (gst_audio_visualizer_src_event));

  gst_pad_set_query_function (scope->priv->srcpad,

      GST_DEBUG_FUNCPTR (gst_audio_visualizer_src_query));

  gst_element_add_pad (GST_ELEMENT (scope), scope->priv->srcpad);

  scope->priv->adapter = gst_adapter_new ();

  scope->priv->inbuf = gst_buffer_new ();

  /* properties */

  scope->priv->shader_type = DEFAULT_SHADER;

  gst_audio_visualizer_change_shader (scope);

  scope->priv->shade_amount = DEFAULT_SHADE_AMOUNT;

  /* reset the initial video state */

  gst_video_info_init (&scope->vinfo);

  scope->priv->frame_duration = GST_CLOCK_TIME_NONE;

  /* reset the initial state */

  gst_audio_info_init (&scope->ainfo);

  gst_video_info_init (&scope->vinfo);

  g_mutex_init (&scope->priv->config_lock);

}

static void

gst_audio_visualizer_set_property (GObject * object, guint prop_id,

    const GValue * value, GParamSpec * pspec)

{

  GstAudioVisualizer *scope = GST_AUDIO_VISUALIZER (object);

  switch (prop_id) {

    case PROP_SHADER:

      scope->priv->shader_type = g_value_get_enum (value);

      gst_audio_visualizer_change_shader (scope);

      break;

    case PROP_SHADE_AMOUNT:

      scope->priv->shade_amount = g_value_get_uint (value);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

  }

}

static void

gst_audio_visualizer_get_property (GObject * object, guint prop_id,

    GValue * value, GParamSpec * pspec)

{

  GstAudioVisualizer *scope = GST_AUDIO_VISUALIZER (object);

  switch (prop_id) {

    case PROP_SHADER:

      g_value_set_enum (value, scope->priv->shader_type);

      break;

    case PROP_SHADE_AMOUNT:

      g_value_set_uint (value, scope->priv->shade_amount);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

  }

}

static void

gst_audio_visualizer_dispose (GObject * object)

{

  GstAudioVisualizer *scope = GST_AUDIO_VISUALIZER (object);

  if (scope->priv->adapter) {

    g_object_unref (scope->priv->adapter);

    scope->priv->adapter = NULL;

  }

  if (scope->priv->inbuf) {

    gst_buffer_unref (scope->priv->inbuf);

    scope->priv->inbuf = NULL;

  }

  if (scope->priv->tempbuf) {

    gst_video_frame_unmap (&scope->priv->tempframe);

    gst_buffer_unref (scope->priv->tempbuf);

    scope->priv->tempbuf = NULL;

  }

  if (scope->priv->config_lock.p) {

    g_mutex_clear (&scope->priv->config_lock);

    scope->priv->config_lock.p = NULL;

  }

  G_OBJECT_CLASS (parent_class)->dispose (object);

}

static void

gst_audio_visualizer_reset (GstAudioVisualizer * scope)

{

  gst_adapter_clear (scope->priv->adapter);

  gst_segment_init (&scope->priv->segment, GST_FORMAT_UNDEFINED);

  GST_OBJECT_LOCK (scope);

  scope->priv->proportion = 1.0;

  scope->priv->earliest_time = -1;

  scope->priv->dropped = 0;

  scope->priv->processed = 0;

  GST_OBJECT_UNLOCK (scope);

}

static gboolean

gst_audio_visualizer_sink_setcaps (GstAudioVisualizer * scope, GstCaps * caps)

{

  GstAudioInfo info;

  if (!gst_audio_info_from_caps (&info, caps))

    goto wrong_caps;

  scope->ainfo = info;

  GST_DEBUG_OBJECT (scope, "audio: channels %d, rate %d",

      GST_AUDIO_INFO_CHANNELS (&info), GST_AUDIO_INFO_RATE (&info));

  if (!gst_audio_visualizer_src_negotiate (scope)) {

    goto not_negotiated;

  }

  return TRUE;

  /* Errors */

wrong_caps:

  {

    GST_WARNING_OBJECT (scope, "could not parse caps");

    return FALSE;

  }

not_negotiated:

  {

    GST_WARNING_OBJECT (scope, "failed to negotiate");

    return FALSE;

  }

}

static gboolean

gst_audio_visualizer_src_setcaps (GstAudioVisualizer * scope, GstCaps * caps)

{

  GstVideoInfo info;

  GstAudioVisualizerClass *klass;

  gboolean res;

  if (!gst_video_info_from_caps (&info, caps))

    goto wrong_caps;

  klass = GST_AUDIO_VISUALIZER_CLASS (G_OBJECT_GET_CLASS (scope));

  scope->vinfo = info;

  scope->priv->frame_duration = gst_util_uint64_scale_int (GST_SECOND,

      GST_VIDEO_INFO_FPS_D (&info), GST_VIDEO_INFO_FPS_N (&info));

  scope->priv->spf =

      gst_util_uint64_scale_int (GST_AUDIO_INFO_RATE (&scope->ainfo),

      GST_VIDEO_INFO_FPS_D (&info), GST_VIDEO_INFO_FPS_N (&info));

  scope->req_spf = scope->priv->spf;

  if (scope->priv->tempbuf) {

    gst_video_frame_unmap (&scope->priv->tempframe);

    gst_buffer_unref (scope->priv->tempbuf);

  }

  scope->priv->tempbuf = gst_buffer_new_wrapped (g_malloc0 (scope->vinfo.size),

      scope->vinfo.size);

  gst_video_frame_map (&scope->priv->tempframe, &scope->vinfo,

      scope->priv->tempbuf, GST_MAP_READWRITE);

  if (klass->setup && !klass->setup (scope))

    goto setup_failed;

  GST_DEBUG_OBJECT (scope, "video: dimension %dx%d, framerate %d/%d",

      GST_VIDEO_INFO_WIDTH (&info), GST_VIDEO_INFO_HEIGHT (&info),

      GST_VIDEO_INFO_FPS_N (&info), GST_VIDEO_INFO_FPS_D (&info));

  GST_DEBUG_OBJECT (scope, "blocks: spf %u, req_spf %u",

      scope->priv->spf, scope->req_spf);

  gst_pad_set_caps (scope->priv->srcpad, caps);

  /* find a pool for the negotiated caps now */

  res = gst_audio_visualizer_do_bufferpool (scope, caps);

  gst_caps_unref (caps);

  return res;

  /* ERRORS */

wrong_caps:

  {

    gst_caps_unref (caps);

    GST_DEBUG_OBJECT (scope, "error parsing caps");

    return FALSE;

  }

setup_failed:

  {

    GST_WARNING_OBJECT (scope, "failed to set up");

    return FALSE;

  }

}

static gboolean

gst_audio_visualizer_src_negotiate (GstAudioVisualizer * scope)

{

  GstCaps *othercaps, *target;

  GstStructure *structure;

  GstCaps *templ;

  gboolean ret;

  templ = gst_pad_get_pad_template_caps (scope->priv->srcpad);

  GST_DEBUG_OBJECT (scope, "performing negotiation");

  /* see what the peer can do */

  othercaps = gst_pad_peer_query_caps (scope->priv->srcpad, NULL);

  if (othercaps) {

    target = gst_caps_intersect (othercaps, templ);

    gst_caps_unref (othercaps);

    gst_caps_unref (templ);

    if (gst_caps_is_empty (target))

      goto no_format;

    target = gst_caps_truncate (target);

  } else {

    target = templ;

  }

  target = gst_caps_make_writable (target);

  structure = gst_caps_get_structure (target, 0);

  gst_structure_fixate_field_nearest_int (structure, "width", 320);

  gst_structure_fixate_field_nearest_int (structure, "height", 200);

  gst_structure_fixate_field_nearest_fraction (structure, "framerate", 25, 1);

  if (gst_structure_has_field (structure, "pixel-aspect-ratio"))

    gst_structure_fixate_field_nearest_fraction (structure,

        "pixel-aspect-ratio", 1, 1);

  target = gst_caps_fixate (target);

  GST_DEBUG_OBJECT (scope, "final caps are %" GST_PTR_FORMAT, target);

  ret = gst_audio_visualizer_src_setcaps (scope, target);

  return ret;

no_format:

  {

    gst_caps_unref (target);

    return FALSE;

  }

}

/* takes ownership of the pool, allocator and query */

static gboolean

gst_audio_visualizer_set_allocation (GstAudioVisualizer * scope,

    GstBufferPool * pool, GstAllocator * allocator,

    GstAllocationParams * params, GstQuery * query)

{

  GstAllocator *oldalloc;

  GstBufferPool *oldpool;

  GstQuery *oldquery;

  GstAudioVisualizerPrivate *priv = scope->priv;

  GST_OBJECT_LOCK (scope);

  oldpool = priv->pool;

  priv->pool = pool;

  priv->pool_active = FALSE;

  oldalloc = priv->allocator;

  priv->allocator = allocator;

  oldquery = priv->query;

  priv->query = query;

  if (params)

    priv->params = *params;

  else

    gst_allocation_params_init (&priv->params);

  GST_OBJECT_UNLOCK (scope);

  if (oldpool) {

    GST_DEBUG_OBJECT (scope, "deactivating old pool %p", oldpool);

    gst_buffer_pool_set_active (oldpool, FALSE);

    gst_object_unref (oldpool);

  }

  if (oldalloc) {

    gst_object_unref (oldalloc);

  }

  if (oldquery) {

    gst_query_unref (oldquery);

  }

  return TRUE;

}

static gboolean

gst_audio_visualizer_do_bufferpool (GstAudioVisualizer * scope,

    GstCaps * outcaps)

{

  GstQuery *query;