path: root/gst/playondemand/gstplayondemand.c

/* GStreamer
 * Copyright (C) 1999-2001 Erik Walthinsen <omega@cse.ogi.edu>
 *
 * 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., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

#include <string.h>
#include <gst/gst.h>
#include <gst/audio/audio.h>
#include "gstplayondemand.h"


#define POD_MAX_PLAYS     192     /* maximum number of simultaneous plays */
#define POD_BUFPOOL_SIZE  4096    /* gstreamer buffer size to make if no
                                     bufferpool is available, must be divisible
                                     by sizeof(gfloat) */
#define POD_BUFPOOL_NUM   6       /* number of buffers to allocate per chunk in
                                     sink buffer pool */
#define POD_BUFFER_SIZE   882000  /* enough space for 10 seconds of 16-bit audio
                                     at 44100 samples per second ... */

static GstElementDetails play_on_demand_details = {
  "Play On Demand",
  "Filter/Audio/Effect",
  "Plays a stream whenever it receives a certain signal",
  VERSION,
  "Leif Morgan Johnson <lmjohns3@eos.ncsu.edu>",
  "(C) 2001",
};


/* Filter signals and args */
enum {
  /* FILL ME */
  PLAY_SIGNAL,
  RESET_SIGNAL,
  LAST_SIGNAL
};

static guint gst_pod_filter_signals[LAST_SIGNAL] = { 0 };

enum {
  ARG_0,
  ARG_SILENT,
  ARG_FOLLOWTAIL,
  ARG_BUFFERSIZE
};

static GstPadTemplate*                    
play_on_demand_sink_factory (void)            
{                                         
  static GstPadTemplate *template = NULL; 
                                          
  if (!template) {                        
    template = gst_pad_template_new 
      ("sink", GST_PAD_SINK, GST_PAD_ALWAYS,
      gst_caps_append(gst_caps_new ("sink_int",  "audio/raw",
                                    GST_AUDIO_INT_PAD_TEMPLATE_PROPS),
                      gst_caps_new ("sink_float", "audio/raw",
                                    GST_AUDIO_FLOAT_MONO_PAD_TEMPLATE_PROPS)),
      NULL);
  }                                       
  return template;                        
}

static GstPadTemplate*
play_on_demand_src_factory (void)
{
  static GstPadTemplate *template = NULL;
  
  if (!template)
    template = gst_pad_template_new 
      ("src", GST_PAD_SRC, GST_PAD_ALWAYS,
       gst_caps_append (gst_caps_new ("src_float", "audio/raw",
                                      GST_AUDIO_FLOAT_MONO_PAD_TEMPLATE_PROPS),
                        gst_caps_new ("src_int", "audio/raw",
                                      GST_AUDIO_INT_PAD_TEMPLATE_PROPS)),
       NULL);
  
  return template;
}

static void	play_on_demand_class_init	(GstPlayOnDemandClass *klass);
static void	play_on_demand_init		(GstPlayOnDemand *filter);

static void	play_on_demand_set_property	(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);
static void	play_on_demand_get_property	(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);

static GstPadConnectReturn	play_on_demand_pad_connect	(GstPad *pad, GstCaps *caps);

static void	play_on_demand_loop		(GstElement *elem);

static void	play_on_demand_play_handler	(GstElement *elem);
static void	play_on_demand_reset_handler	(GstElement *elem);

static GstElementClass *parent_class = NULL;

static GstBufferPool*
play_on_demand_get_bufferpool (GstPad *pad)
{
  GstPlayOnDemand *filter;

  filter = GST_PLAYONDEMAND(gst_pad_get_parent(pad));

  return gst_pad_get_bufferpool(filter->srcpad);
}

static GstPadConnectReturn
play_on_demand_pad_connect (GstPad *pad, GstCaps *caps)
{
  const gchar *format;
  GstPlayOnDemand *filter;
  
  g_return_val_if_fail(caps != NULL, GST_PAD_CONNECT_DELAYED);
  g_return_val_if_fail(pad  != NULL, GST_PAD_CONNECT_DELAYED);

  filter = GST_PLAYONDEMAND(GST_PAD_PARENT(pad));

  gst_caps_get_string(caps, "format", &format);
  
  gst_caps_get_int(caps, "rate",     &filter->rate);
  gst_caps_get_int(caps, "channels", &filter->channels);
  
  if (strcmp(format, "int") == 0) {
    filter->format     = GST_PLAYONDEMAND_FORMAT_INT;
    gst_caps_get_int     (caps, "width",      &filter->width);
    gst_caps_get_int     (caps, "depth",      &filter->depth);
    gst_caps_get_int     (caps, "law",        &filter->law);
    gst_caps_get_int     (caps, "endianness", &filter->endianness);
    gst_caps_get_boolean (caps, "signed",     &filter->is_signed);

    if (!filter->silent) {
      g_print ("PlayOnDemand : channels %d, rate %d\n",  
               filter->channels, filter->rate);
      g_print ("PlayOnDemand : format int, bit width %d, endianness %d, signed %s\n",
               filter->width, filter->endianness, filter->is_signed ? "yes" : "no");
    }
  } else if (strcmp(format, "float") == 0) {
    filter->format     = GST_PLAYONDEMAND_FORMAT_FLOAT;
    gst_caps_get_string (caps, "layout",    &filter->layout);
    gst_caps_get_float  (caps, "intercept", &filter->intercept);
    gst_caps_get_float  (caps, "slope",     &filter->slope);

    if (!filter->silent) {
      g_print ("PlayOnDemand : channels %d, rate %d\n",  
               filter->channels, filter->rate);
      g_print ("PlayOnDemand : format float, layout %s, intercept %f, slope %f\n",
               filter->layout, filter->intercept, filter->slope);
    }
  }

  if (GST_CAPS_IS_FIXED (caps))
    return gst_pad_try_set_caps (filter->srcpad, caps);
  return GST_PAD_CONNECT_DELAYED;
}

GType
gst_play_on_demand_get_type (void)
{
  static GType play_on_demand_type = 0;

  if (! play_on_demand_type) {
    static const GTypeInfo play_on_demand_info = {
      sizeof(GstPlayOnDemandClass),
      NULL,
      NULL,
      (GClassInitFunc) play_on_demand_class_init,
      NULL,
      NULL,
      sizeof(GstPlayOnDemand),
      0,
      (GInstanceInitFunc) play_on_demand_init,
    };
    play_on_demand_type = g_type_register_static(GST_TYPE_ELEMENT, "GstPlayOnDemand", &play_on_demand_info, 0);
  }
  return play_on_demand_type;
}

static void
play_on_demand_class_init (GstPlayOnDemandClass *klass)
{
  GObjectClass    *gobject_class;
  GstElementClass *gstelement_class;

  gobject_class    = (GObjectClass *)    klass;
  gstelement_class = (GstElementClass *) klass;

  gst_pod_filter_signals[PLAY_SIGNAL] =
    g_signal_new("play",
                 G_TYPE_FROM_CLASS(klass),
                 G_SIGNAL_RUN_LAST,
                 G_STRUCT_OFFSET(GstPlayOnDemandClass, play),
                 NULL, NULL,
                 g_cclosure_marshal_VOID__VOID,
                 G_TYPE_NONE, 0);

  gst_pod_filter_signals[RESET_SIGNAL] =
    g_signal_new("reset",
                 G_TYPE_FROM_CLASS(klass),
                 G_SIGNAL_RUN_LAST,
                 G_STRUCT_OFFSET(GstPlayOnDemandClass, reset),
                 NULL, NULL,
                 g_cclosure_marshal_VOID__VOID,
                 G_TYPE_NONE, 0);

  klass->play  = play_on_demand_play_handler;
  klass->reset = play_on_demand_reset_handler;

  parent_class = g_type_class_ref(GST_TYPE_ELEMENT);

  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_SILENT,
    g_param_spec_boolean("silent","silent","silent",
                         TRUE, G_PARAM_READWRITE));

  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_FOLLOWTAIL,
    g_param_spec_boolean("follow-stream-tail","follow-stream-tail","follow-stream-tail",
                         FALSE, G_PARAM_READWRITE));

  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_BUFFERSIZE,
    g_param_spec_uint("buffer-size","buffer-size","buffer-size",
                      0, G_MAXUINT - 1, POD_BUFFER_SIZE, G_PARAM_READWRITE));

  gobject_class->set_property = play_on_demand_set_property;
  gobject_class->get_property = play_on_demand_get_property;
}

static void
play_on_demand_init (GstPlayOnDemand *filter)
{
  guint i;
  
  filter->srcpad = gst_pad_new_from_template(play_on_demand_src_factory(), "src");
  filter->sinkpad = gst_pad_new_from_template(play_on_demand_sink_factory(), "sink");

  gst_pad_set_bufferpool_function(filter->sinkpad, play_on_demand_get_bufferpool);
  gst_pad_set_connect_function(filter->sinkpad, play_on_demand_pad_connect);
  
  gst_element_add_pad(GST_ELEMENT(filter), filter->sinkpad);
  gst_element_add_pad(GST_ELEMENT(filter), filter->srcpad);

  gst_element_set_loop_function(GST_ELEMENT(filter), play_on_demand_loop);

  filter->follow_stream_tail = FALSE;  
  filter->silent      = TRUE;

  filter->buffer      = g_new(gchar, POD_BUFFER_SIZE);
  filter->buffer_size = POD_BUFFER_SIZE;
  filter->start       = 0;
  filter->write       = 0;

  filter->eos         = FALSE;

  /* the plays are stored as an array of buffer offsets. this initializes the
     array to `blank' values (G_MAXUINT is an invalid index for this filter). */
  filter->plays  = g_new(guint, POD_MAX_PLAYS);
  for (i = 0; i < POD_MAX_PLAYS; i++) {
    filter->plays[i] = G_MAXUINT;
  }
}

static void
play_on_demand_loop (GstElement *elem)
{
  GstPlayOnDemand *filter = GST_PLAYONDEMAND(elem);
  guint            num_in, num_out, num_filter;
  GstBuffer       *in, *out;
  register guint   j, k, t;
  guint            w, offset;
  
  g_return_if_fail(filter != NULL);
  g_return_if_fail(GST_IS_PLAYONDEMAND(filter));

  filter->bufpool = gst_pad_get_bufferpool(filter->srcpad);

  if (filter->bufpool == NULL) {
    filter->bufpool = gst_buffer_pool_get_default(POD_BUFPOOL_SIZE, POD_BUFPOOL_NUM);
  }

  in = gst_pad_pull(filter->sinkpad);

  if (filter->format == GST_PLAYONDEMAND_FORMAT_INT) {
    if (filter->width == 16) {
      gint16 min = -32768;
      gint16 max = 32767;
      gint16 zero = 0;
#define _TYPE_ gint16
#include "filter.func"
#undef _TYPE_
    } else if (filter->width == 8) {
      gint8 min = -128;
      gint8 max = 127;
      gint8 zero = 0;
#define _TYPE_ gint8
#include "filter.func"
#undef _TYPE_
    }
  } else if (filter->format == GST_PLAYONDEMAND_FORMAT_FLOAT) {
    gfloat min = -1.0;
    gfloat max = 1.0;
    gfloat zero = 0.0;
#define _TYPE_ gfloat
#include "filter.func"
#undef _TYPE_
  }
}

static void
play_on_demand_play_handler(GstElement *elem)
{
  GstPlayOnDemand *filter = GST_PLAYONDEMAND(elem);
  register guint i;

  for (i = 0; i < POD_MAX_PLAYS; i++) {
    if (filter->plays[i] == G_MAXUINT) {
      filter->plays[i] = filter->start;
      break;
    }
  }
}

static void
play_on_demand_reset_handler(GstElement *elem)
{
  GstPlayOnDemand *filter = GST_PLAYONDEMAND(elem);
  register guint i;
  
  for (i = 0; i < POD_MAX_PLAYS; i++) {
    filter->plays[i] = G_MAXUINT;
  }

  filter->start = 0;
  filter->write = 0;
}

static void
play_on_demand_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
{
  GstPlayOnDemand *filter;

  /* it's not null if we got it, but it might not be ours */
  g_return_if_fail(GST_IS_PLAYONDEMAND(object));
  filter = GST_PLAYONDEMAND(object);

  switch (prop_id) {
  case ARG_BUFFERSIZE:
    filter->buffer_size = g_value_get_uint(value);

    /* reallocate space for the buffer with the new size values. */
    g_free(filter->buffer);
    filter->buffer = g_new(gchar, filter->buffer_size);

    /* reset the play pointers and read/write indexes. */
    play_on_demand_reset_handler(GST_ELEMENT(filter));
    break;
  case ARG_SILENT:
    filter->silent = g_value_get_boolean(value);
    break;
  case ARG_FOLLOWTAIL:
    filter->follow_stream_tail = g_value_get_boolean(value);
    play_on_demand_reset_handler(GST_ELEMENT(filter));
    break;
  default:
    break;
  }
}

static void
play_on_demand_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
  GstPlayOnDemand *filter;

  /* it's not null if we got it, but it might not be ours */
  g_return_if_fail(GST_IS_PLAYONDEMAND(object));
  filter = GST_PLAYONDEMAND(object);

  switch (prop_id) {
  case ARG_BUFFERSIZE:
    g_value_set_uint(value, filter->buffer_size);
    break;
  case ARG_SILENT:
    g_value_set_boolean(value, filter->silent);
    break;
  case ARG_FOLLOWTAIL:
    g_value_set_boolean(value, filter->follow_stream_tail);
    break;
  default:
    G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
    break;
  }
}

static gboolean
plugin_init (GModule *module, GstPlugin *plugin)
{
  GstElementFactory *factory;

  factory = gst_element_factory_new("playondemand",
                                   GST_TYPE_PLAYONDEMAND,
                                   &play_on_demand_details);
  g_return_val_if_fail(factory != NULL, FALSE);
  
  gst_element_factory_add_pad_template(factory, play_on_demand_src_factory());
  gst_element_factory_add_pad_template(factory, play_on_demand_sink_factory());

  gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE(factory));

  return TRUE;
}

GstPluginDesc plugin_desc = {
  GST_VERSION_MAJOR,
  GST_VERSION_MINOR,
  "playondemand",
  plugin_init
};