mutter/clutter/clutter-audio.c

/*
 * Clutter.
 *
 * An OpenGL based 'interactive canvas' library.
 *
 * Authored By Matthew Allum  <mallum@openedhand.com>
 *             Jorn Baayen  <jorn@openedhand.com>
 *
 * Copyright (C) 2006 OpenedHand
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser 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.
 */

/**
 * SECTION:clutter-audio
 * @short_description: Object for playback of audio files.
 *
 * #ClutterAudio is an object that plays audio files.
 */

#include "clutter-audio.h"
#include "clutter-main.h"
#include "clutter-private.h" 	/* for DBG */
#include "clutter-marshal.h"

#include <gst/gst.h>
#include <gst/audio/gstbaseaudiosink.h>

#include <glib.h>

struct _ClutterAudioPrivate
{
  GstElement *playbin;
  char       *uri;
  gboolean    can_seek;
  int         buffer_percent;
  int         duration;
  guint       tick_timeout_id;
};

enum {
  PROP_0,
  /* ClutterMedia proprs */
  PROP_URI,
  PROP_PLAYING,
  PROP_POSITION,
  PROP_VOLUME,
  PROP_CAN_SEEK,
  PROP_BUFFER_PERCENT,
  PROP_DURATION
};


#define TICK_TIMEOUT 0.5

static void clutter_media_init (ClutterMediaInterface *iface);

static gboolean tick_timeout (ClutterAudio *audio);

G_DEFINE_TYPE_EXTENDED (ClutterAudio,                          \
			clutter_audio,                        \
			G_TYPE_OBJECT,                         \
			0,                                            \
			G_IMPLEMENT_INTERFACE (CLUTTER_TYPE_MEDIA,    \
					       clutter_media_init));

/* Interface implementation */

static void
set_uri (ClutterMedia *media,
	 const char   *uri)
{
  ClutterAudio        *audio = CLUTTER_AUDIO(media);
  ClutterAudioPrivate *priv; 
  GstState                    state, pending;

  g_return_if_fail (CLUTTER_IS_AUDIO (audio));

  priv = audio->priv;

  if (!priv->playbin)
    return;

  g_free (priv->uri);

  if (uri) 
    {
      priv->uri = g_strdup (uri);
    
      /**
       * Ensure the tick timeout is installed.
       * 
       * We also have it installed in PAUSED state, because
       * seeks etc may have a delayed effect on the position.
       **/
    if (priv->tick_timeout_id == 0) 
      {
	priv->tick_timeout_id = g_timeout_add (TICK_TIMEOUT * 1000,
					       (GSourceFunc) tick_timeout,
					       audio);
      }
    } 
  else 
    {
      priv->uri = NULL;
    
      if (priv->tick_timeout_id > 0) 
	{
	  g_source_remove (priv->tick_timeout_id);
	  priv->tick_timeout_id = 0;
	}
    }
  
  priv->can_seek = FALSE;
  priv->duration = 0;

  gst_element_get_state (priv->playbin, &state, &pending, 0);

  if (pending)
    state = pending;
  
  gst_element_set_state (priv->playbin, GST_STATE_NULL);
  
  g_object_set (priv->playbin,
		"uri", uri,
		NULL);
  
  /**
   * Restore state.
   **/
  if (uri) 
    gst_element_set_state (priv->playbin, state);
  
  /*
   * Emit notififications for all these to make sure UI is not showing
   * any properties of the old URI.
   */
  g_object_notify (G_OBJECT (audio), "uri");
  g_object_notify (G_OBJECT (audio), "can-seek");
  g_object_notify (G_OBJECT (audio), "duration");
  g_object_notify (G_OBJECT (audio), "position");
  
}

static const char *
get_uri (ClutterMedia *media)
{
  ClutterAudio        *audio = CLUTTER_AUDIO(media);
  ClutterAudioPrivate *priv; 

  g_return_val_if_fail (CLUTTER_IS_AUDIO (audio), NULL);

  priv = audio->priv;

  return priv->uri;
}

static void
set_playing (ClutterMedia *media,
	     gboolean      playing)
{
  ClutterAudio         *audio = CLUTTER_AUDIO(media);
  ClutterAudioPrivate *priv; 

  g_return_if_fail (CLUTTER_IS_AUDIO (audio));

  priv = audio->priv;

  if (!priv->playbin)
    return;
        
  if (priv->uri) 
    {
      GstState state;
    
      if (playing)
	state = GST_STATE_PLAYING;
      else
	state = GST_STATE_PAUSED;
    
      gst_element_set_state (audio->priv->playbin, state);
    } 
  else 
    {
      if (playing)
	g_warning ("Tried to play, but no URI is loaded.");
    }
  
  g_object_notify (G_OBJECT (audio), "playing");
  g_object_notify (G_OBJECT (audio), "position");
}

static gboolean
get_playing (ClutterMedia *media)
{
  ClutterAudio        *audio = CLUTTER_AUDIO(media);
  ClutterAudioPrivate *priv; 
  GstState                    state, pending;

  g_return_val_if_fail (CLUTTER_IS_AUDIO (audio), FALSE);
	
  priv = audio->priv;

  if (!priv->playbin)
    return FALSE;
  
  gst_element_get_state (priv->playbin, &state, &pending, 0);
  
  if (pending)
    return (pending == GST_STATE_PLAYING);
  else
    return (state == GST_STATE_PLAYING);
}

static void
set_position (ClutterMedia *media,
	      int           position) /* seconds */
{
  ClutterAudio        *audio = CLUTTER_AUDIO(media);
  ClutterAudioPrivate *priv; 
  GstState                    state, pending;

  g_return_if_fail (CLUTTER_IS_AUDIO (audio));

  priv = audio->priv;

  if (!priv->playbin)
    return;

  gst_element_get_state (priv->playbin, &state, &pending, 0);

  if (pending)
    state = pending;

  gst_element_set_state (priv->playbin, GST_STATE_PAUSED);

  gst_element_seek (priv->playbin,
		    1.0,
		    GST_FORMAT_TIME,
		    GST_SEEK_FLAG_FLUSH,
		    GST_SEEK_TYPE_SET,
		    position * GST_SECOND,
		    0, 0);

  gst_element_set_state (priv->playbin, state);
}

static int
get_position (ClutterMedia *media)
{
  ClutterAudio        *audio = CLUTTER_AUDIO(media);
  ClutterAudioPrivate *priv; 
  GstQuery                   *query;
  gint64                      position;

  g_return_val_if_fail (CLUTTER_IS_AUDIO (audio), -1);

  priv = audio->priv;

  if (!priv->playbin)
    return -1;
  
  query = gst_query_new_position (GST_FORMAT_TIME);
  
  if (gst_element_query (priv->playbin, query)) 
    gst_query_parse_position (query, NULL, &position);
  else
    position = 0;
  
  gst_query_unref (query);
  
  return (position / GST_SECOND);
}

static void
set_volume (ClutterMedia *media,
	    double        volume)
{
  ClutterAudio        *audio = CLUTTER_AUDIO(media);
  ClutterAudioPrivate *priv; 

  g_return_if_fail (CLUTTER_IS_AUDIO (audio));
  // g_return_if_fail (volume >= 0.0 && volume <= GST_VOL_MAX);

  priv = audio->priv;
  
  if (!priv->playbin)
    return;
  
  g_object_set (G_OBJECT (audio->priv->playbin),
		"volume", volume,
		NULL);
  
  g_object_notify (G_OBJECT (audio), "volume");
}

static double
get_volume (ClutterMedia *media)
{
  ClutterAudio        *audio = CLUTTER_AUDIO(media);
  ClutterAudioPrivate *priv; 
  double                      volume;

  g_return_val_if_fail (CLUTTER_IS_AUDIO (audio), 0.0);

  priv = audio->priv;
  
  if (!priv->playbin)
    return 0.0;

  g_object_get (priv->playbin,
		"volume", &volume,
		NULL);
  
  return volume;
}

static gboolean
can_seek (ClutterMedia *media)
{
  ClutterAudio        *audio = CLUTTER_AUDIO(media);

  g_return_val_if_fail (CLUTTER_IS_AUDIO (audio), FALSE);
  
  return audio->priv->can_seek;
}

static int
get_buffer_percent (ClutterMedia *media)
{
  ClutterAudio         *audio = CLUTTER_AUDIO(media);

  g_return_val_if_fail (CLUTTER_IS_AUDIO (audio), -1);
  
  return audio->priv->buffer_percent;
}

static int
get_duration (ClutterMedia *media)
{
  ClutterAudio         *audio = CLUTTER_AUDIO(media);

  g_return_val_if_fail (CLUTTER_IS_AUDIO (audio), -1);

  return audio->priv->duration;
}

static void
clutter_media_init (ClutterMediaInterface *iface)
{
  iface->set_uri            = set_uri;
  iface->get_uri            = get_uri;
  iface->set_playing        = set_playing;
  iface->get_playing        = get_playing;
  iface->set_position       = set_position;
  iface->get_position       = get_position;
  iface->set_volume         = set_volume;
  iface->get_volume         = get_volume;
  iface->can_seek           = can_seek;
  iface->get_buffer_percent = get_buffer_percent;
  iface->get_duration       = get_duration;
}

static void
clutter_audio_dispose (GObject *object)
{
  ClutterAudio        *self;
  ClutterAudioPrivate *priv; 

  self = CLUTTER_AUDIO(object); 
  priv = self->priv;

  /* FIXME: flush an errors off bus ? */
  /* gst_bus_set_flushing (priv->bus, TRUE); */

  if (priv->playbin) 
    {
      gst_element_set_state (priv->playbin, GST_STATE_NULL);
      gst_object_unref (GST_OBJECT (priv->playbin));
      priv->playbin = NULL;
    }

  if (priv->tick_timeout_id > 0) 
    {
      g_source_remove (priv->tick_timeout_id);
      priv->tick_timeout_id = 0;
    }

  G_OBJECT_CLASS (clutter_audio_parent_class)->dispose (object);
}

static void
clutter_audio_finalize (GObject *object)
{
  ClutterAudio        *self;
  ClutterAudioPrivate *priv; 

  self = CLUTTER_AUDIO(object); 
  priv = self->priv;

  if (priv->uri)
    g_free(priv->uri);

  G_OBJECT_CLASS (clutter_audio_parent_class)->finalize (object);
}

static void
clutter_audio_set_property (GObject      *object, 
				    guint         property_id,
				    const GValue *value, 
				    GParamSpec   *pspec)
{
  ClutterAudio *audio;

  audio = CLUTTER_AUDIO(object);

  switch (property_id)
    {
    case PROP_URI:
      clutter_media_set_uri (CLUTTER_MEDIA(audio), 
			     g_value_get_string (value));
      break;
    case PROP_PLAYING:
      clutter_media_set_playing (CLUTTER_MEDIA(audio),
				 g_value_get_boolean (value));
      break;
    case PROP_POSITION:
      clutter_media_set_position (CLUTTER_MEDIA(audio),
				  g_value_get_int (value));
      break;
    case PROP_VOLUME:
      clutter_media_set_volume (CLUTTER_MEDIA(audio),
				g_value_get_double (value));
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
    }
}

static void
clutter_audio_get_property (GObject    *object, 
				    guint       property_id,
				    GValue     *value, 
				    GParamSpec *pspec)
{
  ClutterAudio *audio;
  ClutterMedia        *media;

  audio = CLUTTER_AUDIO (object);
  media         = CLUTTER_MEDIA (audio);

  switch (property_id)
    {
    case PROP_URI:
      g_value_set_string (value, clutter_media_get_uri (media));
      break;
    case PROP_PLAYING:
      g_value_set_boolean (value, clutter_media_get_playing (media));
      break;
    case PROP_POSITION:
      g_value_set_int (value, clutter_media_get_position (media));
      break;
    case PROP_VOLUME:
      g_value_set_double (value, clutter_media_get_volume (media));
      break;
    case PROP_CAN_SEEK:
      g_value_set_boolean (value, clutter_media_get_can_seek (media));
      break;
    case PROP_BUFFER_PERCENT:
      g_value_set_int (value, clutter_media_get_buffer_percent (media));
      break;
    case PROP_DURATION:
      g_value_set_int (value, clutter_media_get_duration (media));
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
    }
}

static void
clutter_audio_class_init (ClutterAudioClass *klass)
{
  GObjectClass        *object_class;

  object_class = (GObjectClass*)klass;

  object_class->dispose      = clutter_audio_dispose;
  object_class->finalize     = clutter_audio_finalize;
  object_class->set_property = clutter_audio_set_property;
  object_class->get_property = clutter_audio_get_property;

  /* Interface props */

  g_object_class_override_property (object_class, PROP_URI, "uri");
  g_object_class_override_property (object_class, PROP_PLAYING, "playing");
  g_object_class_override_property (object_class, PROP_POSITION, "position");
  g_object_class_override_property (object_class, PROP_VOLUME, "volume");
  g_object_class_override_property (object_class, PROP_CAN_SEEK, "can-seek");
  g_object_class_override_property (object_class, PROP_DURATION, "duration");
  g_object_class_override_property (object_class, PROP_BUFFER_PERCENT, 
				    "buffer-percent" );
}

static void
bus_message_error_cb (GstBus            *bus,
                      GstMessage        *message,
                      ClutterAudio *audio)
{
  GError *error;

  error = NULL;
  gst_message_parse_error (message, &error, NULL);
        
  g_signal_emit_by_name (CLUTTER_MEDIA(audio), "error", error);

  g_error_free (error);
}

static void
bus_message_eos_cb (GstBus            *bus,
                    GstMessage        *message,
                    ClutterAudio *audio)
{
  g_object_notify (G_OBJECT (audio), "position");

  g_signal_emit_by_name (CLUTTER_MEDIA(audio), "eos");
}

static void
bus_message_tag_cb (GstBus            *bus,
                    GstMessage        *message,
                    ClutterAudio *audio)
{
  GstTagList *tag_list;

  gst_message_parse_tag (message, &tag_list);

  g_signal_emit_by_name (CLUTTER_MEDIA(audio), 
			 "metadata-available", 
			 tag_list);
  
  gst_tag_list_free (tag_list);
}

static void
bus_message_buffering_cb (GstBus            *bus,
                          GstMessage        *message,
                          ClutterAudio *audio)
{
  const GstStructure *str;
  
  str = gst_message_get_structure (message);
  if (!str)
    return;

  if (!gst_structure_get_int (str,
			      "buffer-percent",
			      &audio->priv->buffer_percent))
    return;
        
  g_object_notify (G_OBJECT (audio), "buffer-percent");
}

static void
bus_message_duration_cb (GstBus            *bus,
                         GstMessage        *message,
                         ClutterAudio *audio)
{
  GstFormat format;
  gint64 duration;

  gst_message_parse_duration (message,
			      &format,
			      &duration);

  if (format != GST_FORMAT_TIME)
    return;
  
  audio->priv->duration = duration / GST_SECOND;

  g_object_notify (G_OBJECT (audio), "duration");
}

static void
bus_message_state_change_cb (GstBus            *bus,
                             GstMessage        *message,
                             ClutterAudio *audio)
{
  gpointer src;
  GstState old_state, new_state;

  src = GST_MESSAGE_SRC (message);
        
  if (src != audio->priv->playbin)
    return;

  gst_message_parse_state_changed (message, &old_state, &new_state, NULL);

  if (old_state == GST_STATE_READY && 
      new_state == GST_STATE_PAUSED) 
    {
      GstQuery *query;
      
      /**
       * Determine whether we can seek.
       **/
      query = gst_query_new_seeking (GST_FORMAT_TIME);
      
      if (gst_element_query (audio->priv->playbin, query)) {
	gst_query_parse_seeking (query,
				 NULL,
				 &audio->priv->can_seek,
				 NULL,
				 NULL);
      } else {
	/*
	 * Could not query for ability to seek. Determine
	 * using URI.
	 */
	
	if (g_str_has_prefix (audio->priv->uri,
			      "http://")) {
	  audio->priv->can_seek = FALSE;
	} else {
	  audio->priv->can_seek = TRUE;
	}
      }
      
      gst_query_unref (query);
      
      g_object_notify (G_OBJECT (audio), "can-seek");
      
      /**
       * Determine the duration.
       **/
      query = gst_query_new_duration (GST_FORMAT_TIME);
      
      if (gst_element_query (audio->priv->playbin, query)) 
	{
	  gint64 duration;
	  
	  gst_query_parse_duration (query, NULL, &duration);

	  audio->priv->duration = duration / GST_SECOND;
                        
	  g_object_notify (G_OBJECT (audio), "duration");
	}

      gst_query_unref (query);
    }
}

static gboolean
tick_timeout (ClutterAudio *audio)
{
  g_object_notify (G_OBJECT (audio), "position");

  return TRUE;
}

static void
fakesink_handoff_cb (GstElement *fakesrc, 
		     GstBuffer  *buffer,
		     GstPad     *pad, 
		     gpointer    user_data)
{
  GstStructure  *structure;
  int            width, height;
  GdkPixbuf     *pixb;

  structure = gst_caps_get_structure(GST_CAPS(buffer->caps), 0);
  gst_structure_get_int(structure, "width", &width);
  gst_structure_get_int(structure, "height", &height);

  /* FIXME: We really dont want to do this every time as gobject creation
   *        really need a clutter_texture_set_from_data call ?
  */
  pixb = gdk_pixbuf_new_from_data (GST_BUFFER_DATA (buffer),
				   GDK_COLORSPACE_RGB, 
				   FALSE, 
				   8, 
				   width, 
				   height,
				   (3 * width + 3) &~ 3,
				   NULL,
				   NULL);
  
  if (pixb)
    {
      clutter_texture_set_pixbuf (CLUTTER_TEXTURE(user_data), pixb);
      g_object_unref(G_OBJECT(pixb));
    }
}

static gboolean
lay_pipeline (ClutterAudio *audio)
{
  ClutterAudioPrivate *priv;
  GstElement                 *audio_sink = NULL;

  priv = audio->priv;

  priv->playbin = gst_element_factory_make ("playbin", "playbin");

  if (!priv->playbin) 
    {
      g_warning ("Unable to create playbin GST element.");
      return FALSE;
    }

  audio_sink = gst_element_factory_make ("gconfaudiosink", "audio-sink");
  if (!audio_sink) 
    {
      audio_sink = gst_element_factory_make ("autoaudiosink", "audio-sink");
      if (!audio_sink) 
	{
	  audio_sink = gst_element_factory_make ("alsasink", "audio-sink");
	  g_warning ("Could not create a GST audio_sink. "
		     "Audio unavailable.");

	  if (!audio_sink) 	/* Need to bother ? */
	    audio_sink = gst_element_factory_make ("fakesink", "audio-sink");
	}
    }

  g_object_set (G_OBJECT (priv->playbin),
		"audio-sink", audio_sink,
		NULL);

  return TRUE;
}

static void
clutter_audio_init (ClutterAudio *audio)
{
  ClutterAudioPrivate *priv;
  GstBus                     *bus;

  priv                 = g_new0 (ClutterAudioPrivate, 1);
  audio->priv  = priv;

  if (!lay_pipeline(audio))
    {
      g_warning("Failed to initiate suitable playback pipeline.");
      return;
    }

  bus = gst_pipeline_get_bus (GST_PIPELINE (priv->playbin));

  gst_bus_add_signal_watch (bus);

  g_signal_connect_object (bus,
			   "message::error",
			   G_CALLBACK (bus_message_error_cb),
			   audio,
			   0);

  g_signal_connect_object (bus,
			   "message::eos",
			   G_CALLBACK (bus_message_eos_cb),
			   audio,
			   0);

  g_signal_connect_object (bus,
			   "message::tag",
			   G_CALLBACK (bus_message_tag_cb),
			   audio,
			   0);

  g_signal_connect_object (bus,
			   "message::buffering",
			   G_CALLBACK (bus_message_buffering_cb),
			   audio,
			   0);

  g_signal_connect_object (bus,
			   "message::duration",
			   G_CALLBACK (bus_message_duration_cb),
			   audio,
			   0);

  g_signal_connect_object (bus,
			   "message::state-changed",
			   G_CALLBACK (bus_message_state_change_cb),
			   audio,
			   0);

  gst_object_unref (GST_OBJECT (bus));

  return;
}

/**
 * clutter_audio_new:
 *
 * Creates #ClutterAudio object.
 *
 * Return value: A newly allocated #ClutterAudio object.
 */
ClutterAudio*
clutter_audio_new (void)
{
  return g_object_new (CLUTTER_TYPE_AUDIO, NULL);
}