ext/shout2/gstshout2.c

   1 /* GStreamer
   2  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include "config.h"
  22 #endif
  23 #include "gstshout2.h"
  24 #include <stdlib.h>
  25 #include <string.h>
  26
  27 GST_DEBUG_CATEGORY (shout2_debug);
  28 #define GST_CAT_DEFAULT shout2_debug
  29
  30 /* elementfactory information */
  31 static GstElementDetails shout2send_details =
  32 GST_ELEMENT_DETAILS ("Icecast network sink",
  33     "Sink/Network",
  34     "Sends data to an icecast server",
  35     "Wim Taymans <wim.taymans@chello.be>\n"
  36     "Pedro Corte-Real <typo@netcabo.pt>\n"
  37     "Zaheer Abbas Merali <zaheerabbas at merali dot org>");
  38
  39
  40 /* Shout2send signals and args */
  41 enum
  42 {
  43   /* FILL ME */
  44   SIGNAL_CONNECTION_PROBLEM,
  45   LAST_SIGNAL
  46 };
  47
  48 enum
  49 {
  50   ARG_0,
  51   ARG_IP,                       /* the ip of the server */
  52   ARG_PORT,                     /* the encoder port number on the server */
  53   ARG_PASSWORD,                 /* the encoder password on the server */
  54   ARG_PUBLIC,                   /* is this stream public? */
  55   ARG_STREAMNAME,               /* Name of the stream */
  56   ARG_DESCRIPTION,              /* Description of the stream */
  57   ARG_GENRE,                    /* Genre of the stream */
  58
  59   ARG_PROTOCOL,                 /* Protocol to connect with */
  60
  61   ARG_MOUNT,                    /* mountpoint of stream (icecast only) */
  62   ARG_URL,                      /* Url of stream (I'm guessing) */
  63   ARG_SYNC                      /* Sync with clock */
  64 };
  65
  66 static GstElementClass *parent_class = NULL;
  67
  68 static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink",
  69     GST_PAD_SINK,
  70     GST_PAD_ALWAYS,
  71     GST_STATIC_CAPS ("application/ogg; "
  72         "audio/mpeg, mpegversion = (int) 1, layer = (int) [ 1, 3 ]")
  73     );
  74 static void gst_shout2send_class_init (GstShout2sendClass * klass);
  75 static void gst_shout2send_base_init (GstShout2sendClass * klass);
  76 static void gst_shout2send_init (GstShout2send * shout2send);
  77
  78 static gboolean gst_shout2send_event (GstBaseSink * sink, GstEvent * event);
  79 static GstFlowReturn gst_shout2send_render (GstBaseSink * sink,
  80     GstBuffer * buffer);
  81
  82 static void gst_shout2send_set_property (GObject * object, guint prop_id,
  83     const GValue * value, GParamSpec * pspec);
  84 static void gst_shout2send_get_property (GObject * object, guint prop_id,
  85     GValue * value, GParamSpec * pspec);
  86
  87 static GstStateChangeReturn gst_shout2send_change_state (GstElement * element,
  88     GstStateChange transition);
  89 static gboolean gst_shout2send_setcaps (GstPad * pad, GstCaps * caps);
  90
  91 static guint gst_shout2send_signals[LAST_SIGNAL] = { 0 };
  92
  93 #define GST_TYPE_SHOUT_PROTOCOL (gst_shout2send_protocol_get_type())
  94 static GType
  95 gst_shout2send_protocol_get_type (void)
  96 {
  97   static GType shout2send_protocol_type = 0;
  98   static GEnumValue shout2send_protocol[] = {
  99     {SHOUT2SEND_PROTOCOL_XAUDIOCAST,
 100         "Xaudiocast Protocol (icecast 1.3.x)", "xaudiocast"},
 101     {SHOUT2SEND_PROTOCOL_ICY, "Icy Protocol (ShoutCast)", "icy"},
 102     {SHOUT2SEND_PROTOCOL_HTTP, "Http Protocol (icecast 2.x)", "http"},
 103     {0, NULL, NULL},
 104   };
 105
 106   if (!shout2send_protocol_type) {
 107     shout2send_protocol_type =
 108         g_enum_register_static ("GstShout2SendProtocol", shout2send_protocol);
 109   }
 110
 111
 112   return shout2send_protocol_type;
 113 }
 114
 115 GType
 116 gst_shout2send_get_type (void)
 117 {
 118   static GType shout2send_type = 0;
 119
 120   if (!shout2send_type) {
 121     static const GTypeInfo shout2send_info = {
 122       sizeof (GstShout2sendClass),
 123       (GBaseInitFunc) gst_shout2send_base_init,
 124       NULL,
 125       (GClassInitFunc) gst_shout2send_class_init,
 126       NULL,
 127       NULL,
 128       sizeof (GstShout2send),
 129       0,
 130       (GInstanceInitFunc) gst_shout2send_init,
 131     };
 132
 133     static const GInterfaceInfo tag_setter_info = {
 134       NULL,
 135       NULL,
 136       NULL
 137     };
 138
 139     shout2send_type =
 140         g_type_register_static (GST_TYPE_BASE_SINK, "GstShout2send",
 141         &shout2send_info, 0);
 142
 143     g_type_add_interface_static (shout2send_type, GST_TYPE_TAG_SETTER,
 144         &tag_setter_info);
 145
 146   }
 147   return shout2send_type;
 148 }
 149
 150 static void
 151 gst_shout2send_base_init (GstShout2sendClass * klass)
 152 {
 153   GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
 154
 155   element_class->change_state = gst_shout2send_change_state;
 156   gst_element_class_add_pad_template (element_class,
 157       gst_static_pad_template_get (&sink_template));
 158   gst_element_class_set_details (element_class, &shout2send_details);
 159 }
 160
 161 static void
 162 gst_shout2send_class_init (GstShout2sendClass * klass)
 163 {
 164   GObjectClass *gobject_class;
 165   GstBaseSinkClass *gstbasesink_class;
 166
 167   gobject_class = (GObjectClass *) klass;
 168   gstbasesink_class = (GstBaseSinkClass *) klass;
 169
 170   parent_class = g_type_class_peek_parent (klass);
 171
 172   gobject_class->set_property = gst_shout2send_set_property;
 173   gobject_class->get_property = gst_shout2send_get_property;
 174
 175   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_IP, g_param_spec_string ("ip", "ip", "ip", NULL, G_PARAM_READWRITE));    /* CHECKME */
 176   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_PORT, g_param_spec_int ("port", "port", "port", 1, G_MAXUSHORT, 8000, G_PARAM_READWRITE));       /* CHECKME */
 177
 178   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_PASSWORD, g_param_spec_string ("password", "password", "password", NULL, G_PARAM_READWRITE));    /* CHECKME */
 179
 180   /* metadata */
 181   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_STREAMNAME, g_param_spec_string ("streamname", "streamname", "name of the stream", NULL, G_PARAM_READWRITE));    /* CHECKME */
 182
 183   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_DESCRIPTION, g_param_spec_string ("description", "description", "description", NULL, G_PARAM_READWRITE));        /* CHECKME */
 184
 185   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_GENRE, g_param_spec_string ("genre", "genre", "genre", NULL, G_PARAM_READWRITE));        /* CHECKME */
 186
 187   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_PROTOCOL,
 188       g_param_spec_enum ("protocol", "protocol", "Connection Protocol to use",
 189           GST_TYPE_SHOUT_PROTOCOL, SHOUT2SEND_PROTOCOL_HTTP,
 190           G_PARAM_READWRITE));
 191
 192
 193   /* icecast only */
 194   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_MOUNT, g_param_spec_string ("mount", "mount", "mount", NULL, G_PARAM_READWRITE));        /* CHECKME */
 195
 196   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_URL, g_param_spec_string ("url", "url", "url", NULL, G_PARAM_READWRITE));        /* CHECKME */
 197
 198   /* sync to clock */
 199   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SYNC,
 200       g_param_spec_boolean ("sync", "Sync", "Sync on the clock", FALSE,
 201           G_PARAM_READWRITE));
 202
 203   /* signals */
 204   gst_shout2send_signals[SIGNAL_CONNECTION_PROBLEM] =
 205       g_signal_new ("connection-problem", G_TYPE_FROM_CLASS (klass),
 206       G_SIGNAL_RUN_CLEANUP, G_STRUCT_OFFSET (GstShout2sendClass,
 207           connection_problem), NULL, NULL, g_cclosure_marshal_VOID__INT,
 208       G_TYPE_NONE, 1, G_TYPE_INT);
 209
 210   gstbasesink_class->render = GST_DEBUG_FUNCPTR (gst_shout2send_render);
 211   gstbasesink_class->event = GST_DEBUG_FUNCPTR (gst_shout2send_event);
 212   GST_DEBUG_CATEGORY_INIT (shout2_debug, "shout2", 0, "shout2send element");
 213 }
 214
 215 static void
 216 gst_shout2send_init (GstShout2send * shout2send)
 217 {
 218   GstPad *pad;
 219
 220   pad = GST_BASE_SINK_PAD (shout2send);
 221
 222   gst_pad_set_setcaps_function (pad, gst_shout2send_setcaps);
 223   shout2send->clock = NULL;
 224   shout2send->ip = g_strdup ("127.0.0.1");
 225   shout2send->port = 8000;
 226   shout2send->password = g_strdup ("hackme");
 227   shout2send->streamname = g_strdup ("");
 228   shout2send->description = g_strdup ("");
 229   shout2send->genre = g_strdup ("");
 230   shout2send->mount = g_strdup ("");
 231   shout2send->url = g_strdup ("");
 232   shout2send->tags = gst_tag_list_new ();
 233   shout2send->protocol = SHOUT2SEND_PROTOCOL_HTTP;
 234   shout2send->conn = NULL;
 235   shout2send->audio_format = SHOUT_FORMAT_VORBIS;
 236   shout2send->sync = FALSE;
 237   shout2send->started = FALSE;
 238   shout2send->songmetadata = NULL;
 239 }
 240
 241 static void
 242 set_shout_metadata (const GstTagList * list, const gchar * tag,
 243     gpointer user_data)
 244 {
 245   char **shout_metadata = (char **) user_data;
 246   gchar *value, *temp;
 247
 248   GST_DEBUG ("tag: %s being added", tag);
 249   if (strcmp (tag, GST_TAG_ARTIST) == 0) {
 250     if (gst_tag_get_type (tag) == G_TYPE_STRING) {
 251       if (!gst_tag_list_get_string (list, tag, &value)) {
 252         GST_DEBUG ("Error reading \"%s\" tag value\n", tag);
 253         return;
 254       }
 255       /* shout_metadata should be NULL if title is after artist in  list */
 256       if (*shout_metadata == NULL) {
 257         *shout_metadata = g_strdup (value);
 258       } else {
 259         temp = g_strdup_printf ("%s - %s", value, *shout_metadata);
 260         g_free (*shout_metadata);
 261         *shout_metadata = temp;
 262       }
 263
 264     }
 265   } else if (strcmp (tag, GST_TAG_TITLE) == 0) {
 266     if (gst_tag_get_type (tag) == G_TYPE_STRING) {
 267       if (!gst_tag_list_get_string (list, tag, &value)) {
 268         GST_DEBUG ("Error reading \"%s\" tag value\n", tag);
 269         return;
 270       }
 271       /* shout_metadata should be NULL if title is before artist in  list */
 272       if (*shout_metadata == NULL) {
 273         *shout_metadata = g_strdup (value);
 274       } else {
 275         temp = g_strdup_printf ("%s - %s", *shout_metadata, value);
 276         g_free (*shout_metadata);
 277         *shout_metadata = temp;
 278       }
 279     }
 280   }
 281   GST_DEBUG ("shout metadata is now: %s", *shout_metadata);
 282 }
 283
 284 #if 0
 285 static void
 286 gst_shout2send_set_metadata (GstShout2send * shout2send)
 287 {
 288   const GstTagList *user_tags;
 289   GstTagList *copy;
 290   char *tempmetadata;
 291   shout_metadata_t *pmetadata;
 292
 293   g_return_if_fail (shout2send != NULL);
 294   user_tags = gst_tag_setter_get_tag_list (GST_TAG_SETTER (shout2send));
 295
 296   if ((shout2send->tags == NULL) && (user_tags == NULL)) {
 297     return;
 298   }
 299   copy = gst_tag_list_merge (user_tags, shout2send->tags,
 300       gst_tag_setter_get_tag_merge_mode (GST_TAG_SETTER (shout2send)));
 301
 302   /* lets get the artist and song tags */
 303   tempmetadata = NULL;
 304   gst_tag_list_foreach ((GstTagList *) copy, set_shout_metadata,
 305       (gpointer) & tempmetadata);
 306   if (tempmetadata) {
 307     pmetadata = shout_metadata_new ();
 308     shout_metadata_add (pmetadata, "song", tempmetadata);
 309     shout_set_metadata (shout2send->conn, pmetadata);
 310     shout_metadata_free (pmetadata);
 311   }
 312
 313   gst_tag_list_free (copy);
 314 }
 315 #endif
 316
 317
 318 static gboolean
 319 gst_shout2send_event (GstBaseSink * sink, GstEvent * event)
 320 {
 321   GstShout2send *shout2send;
 322
 323   shout2send = GST_SHOUT2SEND (sink);
 324
 325   switch (GST_EVENT_TYPE (event)) {
 326     case GST_EVENT_TAG:
 327       GST_DEBUG ("tag event received");
 328       /* vorbis audio doesnt need metadata setting on the icecast level, only mp3 */
 329       if (shout2send->tags && shout2send->audio_format == SHOUT_FORMAT_MP3) {
 330         GstTagList *list;
 331
 332         gst_event_parse_tag (event, &list);
 333
 334         gst_tag_list_insert (shout2send->tags,
 335             list,
 336             gst_tag_setter_get_tag_merge_mode (GST_TAG_SETTER (shout2send)));
 337         /* lets get the artist and song tags */
 338         gst_tag_list_foreach ((GstTagList *) shout2send->tags,
 339             set_shout_metadata, &shout2send->songmetadata);
 340         if (shout2send->songmetadata) {
 341           shout_metadata_t *pmetadata;
 342
 343           GST_DEBUG ("shout metadata now: %s", shout2send->songmetadata);
 344           pmetadata = shout_metadata_new ();
 345           shout_metadata_add (pmetadata, "song", shout2send->songmetadata);
 346           shout_set_metadata (shout2send->conn, pmetadata);
 347           shout_metadata_free (pmetadata);
 348         }
 349       }
 350       break;
 351     default:
 352       GST_DEBUG ("some other event received");
 353       break;
 354   }
 355
 356   return TRUE;
 357 }
 358
 359 static GstFlowReturn
 360 gst_shout2send_render (GstBaseSink * sink, GstBuffer * buf)
 361 {
 362   GstShout2send *shout2send;
 363   glong ret;
 364
 365
 366   shout2send = GST_SHOUT2SEND (sink);
 367
 368   if (!shout2send->started) {
 369 /* connect */
 370     GST_DEBUG ("Connection format is: %s",
 371         shout2send->audio_format == SHOUT_FORMAT_VORBIS ? "vorbis" :
 372         (shout2send->audio_format == SHOUT_FORMAT_MP3 ? "mp3" : "unknown"));
 373     if (shout_set_format (shout2send->conn,
 374             shout2send->audio_format) != SHOUTERR_SUCCESS) {
 375       GST_ERROR ("Error setting connection format: %s\n",
 376           shout_get_error (shout2send->conn));
 377     }
 378
 379     if (shout_open (shout2send->conn) == SHOUTERR_SUCCESS) {
 380       g_print ("connected to server...\n");
 381       /* lets set metadata */
 382       if (shout2send->songmetadata) {
 383         shout_metadata_t *pmetadata;
 384
 385         GST_DEBUG ("shout metadata now: %s", shout2send->songmetadata);
 386         pmetadata = shout_metadata_new ();
 387         shout_metadata_add (pmetadata, "song", shout2send->songmetadata);
 388         shout_set_metadata (shout2send->conn, pmetadata);
 389         shout_metadata_free (pmetadata);
 390       }
 391
 392       shout2send->started = TRUE;
 393
 394     } else {
 395       GST_ERROR_OBJECT (shout2send, "Couldn't connect to server: %s",
 396           shout_get_error (shout2send->conn));
 397       GST_ELEMENT_ERROR (shout2send, RESOURCE, OPEN_WRITE,
 398           (NULL), GST_ERROR_SYSTEM);
 399       g_signal_emit (G_OBJECT (shout2send),
 400           gst_shout2send_signals[SIGNAL_CONNECTION_PROBLEM], 0,
 401           shout_get_errno (shout2send->conn));
 402       shout_free (shout2send->conn);
 403       shout2send->conn = NULL;
 404       return GST_FLOW_ERROR;
 405     }
 406   }
 407
 408
 409   if (shout2send->clock && shout2send->sync) {
 410     //GST_DEBUG("using GStreamer clock to sync");
 411     //gst_element_wait (GST_ELEMENT (shout2send), GST_BUFFER_TIMESTAMP (buf));
 412   } else {
 413     //GST_DEBUG("using libshout to sync");
 414     shout_sync (shout2send->conn);
 415   }
 416   ret = shout_send (shout2send->conn, GST_BUFFER_DATA (buf),
 417       GST_BUFFER_SIZE (buf));
 418   if (ret != SHOUTERR_SUCCESS) {
 419     GST_WARNING ("send error: %s...\n", shout_get_error (shout2send->conn));
 420     g_signal_emit (G_OBJECT (shout2send),
 421         gst_shout2send_signals[SIGNAL_CONNECTION_PROBLEM], 0,
 422         shout_get_errno (shout2send->conn));
 423   }
 424
 425   return GST_FLOW_OK;
 426 }
 427
 428 static void
 429 gst_shout2send_set_property (GObject * object, guint prop_id,
 430     const GValue * value, GParamSpec * pspec)
 431 {
 432   GstShout2send *shout2send;
 433
 434   g_return_if_fail (GST_IS_SHOUT2SEND (object));
 435   shout2send = GST_SHOUT2SEND (object);
 436
 437   switch (prop_id) {
 438
 439     case ARG_IP:
 440       if (shout2send->ip)
 441         g_free (shout2send->ip);
 442       shout2send->ip = g_strdup (g_value_get_string (value));
 443       break;
 444
 445     case ARG_PORT:
 446       shout2send->port = g_value_get_int (value);
 447       break;
 448
 449     case ARG_PASSWORD:
 450       if (shout2send->password)
 451         g_free (shout2send->password);
 452       shout2send->password = g_strdup (g_value_get_string (value));
 453       break;
 454
 455     case ARG_STREAMNAME:       /* Name of the stream */
 456       if (shout2send->streamname)
 457         g_free (shout2send->streamname);
 458       shout2send->streamname = g_strdup (g_value_get_string (value));
 459       break;
 460
 461     case ARG_DESCRIPTION:      /* Description of the stream */
 462       if (shout2send->description)
 463         g_free (shout2send->description);
 464       shout2send->description = g_strdup (g_value_get_string (value));
 465       break;
 466
 467     case ARG_GENRE:            /* Genre of the stream */
 468       if (shout2send->genre)
 469         g_free (shout2send->genre);
 470       shout2send->genre = g_strdup (g_value_get_string (value));
 471       break;
 472
 473     case ARG_PROTOCOL:         /* protocol to connect with */
 474       shout2send->protocol = g_value_get_enum (value);
 475       break;
 476
 477     case ARG_MOUNT:            /* mountpoint of stream (icecast only) */
 478       if (shout2send->mount)
 479         g_free (shout2send->mount);
 480       shout2send->mount = g_strdup (g_value_get_string (value));
 481       break;
 482
 483     case ARG_URL:              /* Url of the stream (I'm guessing) */
 484       if (shout2send->url)
 485         g_free (shout2send->url);
 486       shout2send->url = g_strdup (g_value_get_string (value));
 487       break;
 488     case ARG_SYNC:
 489       shout2send->sync = g_value_get_boolean (value);
 490       break;
 491     default:
 492       break;
 493   }
 494 }
 495
 496 static void
 497 gst_shout2send_get_property (GObject * object, guint prop_id, GValue * value,
 498     GParamSpec * pspec)
 499 {
 500   GstShout2send *shout2send;
 501
 502   g_return_if_fail (GST_IS_SHOUT2SEND (object));
 503   shout2send = GST_SHOUT2SEND (object);
 504
 505   switch (prop_id) {
 506
 507     case ARG_IP:
 508       g_value_set_string (value, shout2send->ip);
 509       break;
 510     case ARG_PORT:
 511       g_value_set_int (value, shout2send->port);
 512       break;
 513     case ARG_PASSWORD:
 514       g_value_set_string (value, shout2send->password);
 515       break;
 516
 517     case ARG_STREAMNAME:       /* Name of the stream */
 518       g_value_set_string (value, shout2send->streamname);
 519       break;
 520
 521     case ARG_DESCRIPTION:      /* Description of the stream */
 522       g_value_set_string (value, shout2send->description);
 523       break;
 524
 525     case ARG_GENRE:            /* Genre of the stream */
 526       g_value_set_string (value, shout2send->genre);
 527       break;
 528
 529     case ARG_PROTOCOL:         /* protocol to connect with */
 530       g_value_set_enum (value, shout2send->protocol);
 531       break;
 532
 533     case ARG_MOUNT:            /* mountpoint of stream (icecast only) */
 534       g_value_set_string (value, shout2send->mount);
 535       break;
 536
 537     case ARG_URL:              /* Url of stream (I'm guessing) */
 538       g_value_set_string (value, shout2send->url);
 539       break;
 540     case ARG_SYNC:             /* Sync to clock */
 541       g_value_set_boolean (value, shout2send->sync);
 542       break;
 543     default:
 544       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 545       break;
 546   }
 547 }
 548
 549 static gboolean
 550 gst_shout2send_setcaps (GstPad * pad, GstCaps * caps)
 551 {
 552   const gchar *mimetype;
 553   GstShout2send *shout2send;
 554   gboolean ret = TRUE;
 555
 556   shout2send = GST_SHOUT2SEND (GST_OBJECT_PARENT (pad));
 557   mimetype = gst_structure_get_name (gst_caps_get_structure (caps, 0));
 558   GST_DEBUG ("in setcaps function, mimetype of caps given is: %s", mimetype);
 559   if (!strcmp (mimetype, "audio/mpeg")) {
 560     shout2send->audio_format = SHOUT_FORMAT_MP3;
 561   }
 562
 563   else if (!strcmp (mimetype, "application/ogg")) {
 564     shout2send->audio_format = SHOUT_FORMAT_VORBIS;
 565   } else {
 566     ret = FALSE;
 567   }
 568   gst_caps_unref (caps);
 569
 570   return ret;
 571
 572 }
 573
 574 static GstStateChangeReturn
 575 gst_shout2send_change_state (GstElement * element, GstStateChange transition)
 576 {
 577   GstShout2send *shout2send;
 578   GstStateChangeReturn ret;
 579
 580   gshort proto = 3;
 581
 582   gchar *version_string;
 583
 584   g_return_val_if_fail (GST_IS_SHOUT2SEND (element), GST_STATE_CHANGE_FAILURE);
 585
 586   shout2send = GST_SHOUT2SEND (element);
 587
 588   GST_DEBUG ("state pending %d", GST_STATE_PENDING (element));
 589
 590   /* if going down into NULL state, close the file if it's open */
 591   switch (transition) {
 592     case GST_STATE_CHANGE_NULL_TO_READY:
 593       shout2send->conn = shout_new ();
 594
 595       switch (shout2send->protocol) {
 596         case SHOUT2SEND_PROTOCOL_XAUDIOCAST:
 597           proto = SHOUT_PROTOCOL_XAUDIOCAST;
 598           break;
 599         case SHOUT2SEND_PROTOCOL_ICY:
 600           proto = SHOUT_PROTOCOL_ICY;
 601           break;
 602         case SHOUT2SEND_PROTOCOL_HTTP:
 603           proto = SHOUT_PROTOCOL_HTTP;
 604           break;
 605       }
 606
 607       if (shout_set_protocol (shout2send->conn, proto) != SHOUTERR_SUCCESS) {
 608         GST_DEBUG ("shout2send configured with protocol: %d",
 609             shout2send->protocol);
 610         g_error ("Error setting protocol: %s\n",
 611             shout_get_error (shout2send->conn));
 612       }
 613
 614       /* --- FIXME: shout requires an ip, and fails if it is given a host. */
 615       /* may want to put convert_to_ip(shout2send->ip) here */
 616
 617
 618       if (shout_set_host (shout2send->conn, shout2send->ip) != SHOUTERR_SUCCESS) {
 619         g_error ("Error setting host: %s\n",
 620             shout_get_error (shout2send->conn));
 621       }
 622       /* --- */
 623
 624       if (shout_set_port (shout2send->conn,
 625               shout2send->port) != SHOUTERR_SUCCESS) {
 626         g_error ("Error setting port: %s\n",
 627             shout_get_error (shout2send->conn));
 628       }
 629
 630       if (shout_set_password (shout2send->conn,
 631               shout2send->password) != SHOUTERR_SUCCESS) {
 632         g_error ("Error setting password: %s\n",
 633             shout_get_error (shout2send->conn));
 634       }
 635
 636       if (shout_set_name (shout2send->conn,
 637               shout2send->streamname) != SHOUTERR_SUCCESS) {
 638         g_error ("Error setting stream name: %s\n",
 639             shout_get_error (shout2send->conn));
 640       }
 641
 642       if (shout_set_description (shout2send->conn,
 643               shout2send->description) != SHOUTERR_SUCCESS) {
 644         g_error ("Error setting name: %s\n",
 645             shout_get_error (shout2send->conn));
 646       }
 647
 648       if (shout_set_genre (shout2send->conn,
 649               shout2send->genre) != SHOUTERR_SUCCESS) {
 650         g_error ("Error setting name: %s\n",
 651             shout_get_error (shout2send->conn));
 652       }
 653
 654       if (shout_set_mount (shout2send->conn,
 655               shout2send->mount) != SHOUTERR_SUCCESS) {
 656         g_error ("Error setting mount point: %s\n",
 657             shout_get_error (shout2send->conn));
 658       }
 659
 660       if (shout_set_user (shout2send->conn, "source") != SHOUTERR_SUCCESS) {
 661         g_error ("Error setting user: %s\n",
 662             shout_get_error (shout2send->conn));
 663       }
 664
 665       version_string = gst_version_string ();
 666
 667       if (shout_set_agent (shout2send->conn,
 668               version_string) != SHOUTERR_SUCCESS) {
 669         g_error ("Error setting agent: %s\n",
 670             shout_get_error (shout2send->conn));
 671       }
 672
 673       g_free (version_string);
 674
 675
 676
 677       break;
 678     case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
 679       break;
 680     case GST_STATE_CHANGE_READY_TO_PAUSED:
 681       break;
 682
 683
 684     default:
 685       break;
 686   }
 687
 688   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
 689
 690   switch (transition) {
 691     case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
 692       break;
 693     case GST_STATE_CHANGE_PAUSED_TO_READY:
 694       if (shout2send->started) {
 695         shout_close (shout2send->conn);
 696         shout_free (shout2send->conn);
 697         shout2send->started = FALSE;
 698         g_free (shout2send->songmetadata);
 699         shout2send->songmetadata = NULL;
 700       }
 701       break;
 702     case GST_STATE_CHANGE_READY_TO_NULL:
 703       break;
 704     default:
 705       break;
 706   }
 707
 708   return ret;
 709 }
 710
 711 static gboolean
 712 plugin_init (GstPlugin * plugin)
 713 {
 714   return gst_element_register (plugin, "shout2send", GST_RANK_NONE,
 715       GST_TYPE_SHOUT2SEND);
 716 }
 717
 718 GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
 719     GST_VERSION_MINOR,
 720     "shout2send",
 721     "Sends data to an icecast server using libshout2",
 722     plugin_init,
 723     VERSION, "LGPL", "libshout2", "http://www.icecast.org/download.html")