# HG changeset patch # User renatofilho # Date 1177350632 -3600 # Node ID bd0ad44171e7c0082b4cafe90974ad24cc00d9a4 # Parent a1783dab9ba6cda42de25470b307764e23c9269f [svn r592] app implementation diff -r a1783dab9ba6 -r bd0ad44171e7 gmyth-stream/gmemcoder/src/Makefile.am --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gmyth-stream/gmemcoder/src/Makefile.am Mon Apr 23 18:50:32 2007 +0100 @@ -0,0 +1,17 @@ +bin_PROGRAMS = \ + gmencoder + +gmencoder_SOURCES = \ + main.c \ + gmemcoder.c \ + gmemcoder.h + +gmencoder_LDADD = \ + $(GLIB_LIBS) \ + $(GST_LIBS) + +AM_CPPFLAGS = \ + $(GLIB_CFLAGS) \ + $(GST_CFLAGS) + +CLEANFILES = diff -r a1783dab9ba6 -r bd0ad44171e7 gmyth-stream/gmemcoder/src/gmemcoder.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gmyth-stream/gmemcoder/src/gmemcoder.c Mon Apr 23 18:50:32 2007 +0100 @@ -0,0 +1,551 @@ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include +#include +#include + +#include "gmemcoder.h" + +#define G_MENCODER_GET_PRIVATE(obj) \ + (G_TYPE_INSTANCE_GET_PRIVATE ((obj), G_TYPE_MENCODER, GMencoderPrivate)) + + +typedef struct _GMencoderPrivate GMencoderPrivate; + +struct _GMencoderPrivate +{ + GstElement *pipe; + GstElement *abin; + GstElement *vbin; + GstElement *sink; + gboolean ready; +}; + +enum { + READY, + PAUSED, + PLAYING, + STOPED, + EOS, + ERROR, + LAST_SIGNAL +}; + +static void g_mencoder_class_init (GMencoderClass *klass); +static void g_mencoder_init (GMencoder *object); +static void g_mencoder_dispose (GObject *object); +static void g_mencoder_finalize (GObject *object); +static gboolean + _pipeline_bus_cb (GstBus *bus, + GstMessage *msg, + gpointer user_data); + +static void _decodebin_new_pad_cb (GstElement* object, + GstPad* pad, + gboolean flag, + gpointer user_data); +static void _decodebin_unknown_type_cb (GstElement* object, + GstPad* pad, + GstCaps* caps, + gpointer user_data); + +static guint g_mencoder_signals[LAST_SIGNAL] = { 0 }; + +G_DEFINE_TYPE(GMencoder, g_mencoder, G_TYPE_OBJECT) + +static void +g_mencoder_class_init (GMencoderClass *klass) +{ + GObjectClass *object_class; + + object_class = (GObjectClass *) klass; + + g_type_class_add_private (klass, sizeof (GMencoderPrivate)); + + object_class->dispose = g_mencoder_dispose; + object_class->finalize = g_mencoder_finalize; + + g_mencoder_signals[READY] = + g_signal_new ("ready", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_FIRST, + 0, NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + + g_mencoder_signals[PAUSED] = + g_signal_new ("paused", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_FIRST, + 0, NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + + g_mencoder_signals[PLAYING] = + g_signal_new ("playing", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_FIRST, + 0, NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + + g_mencoder_signals[STOPED] = + g_signal_new ("stoped", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_FIRST, + 0, NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + + g_mencoder_signals[EOS] = + g_signal_new ("eos", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_FIRST, + 0, NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + + + g_mencoder_signals[ERROR] = + g_signal_new ("error", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_FIRST, + 0, NULL, NULL, + g_cclosure_marshal_VOID__STRING, + G_TYPE_NONE, 1, G_TYPE_STRING); +} + +static void +g_mencoder_init (GMencoder *self) +{ +} + +static void +g_mencoder_dispose (GObject *object) +{ +} + +static void +g_mencoder_finalize (GObject *object) +{ + g_mencoder_close_stream (G_MENCODER (object)); +} + +GMencoder* +g_mencoder_new (void) +{ + return g_object_new (G_TYPE_MENCODER, NULL); +} + + +gboolean +g_mencoder_setup_stream (GMencoder *self, + const gchar* uri, + guint width, guint height, + gint out_fd) +{ + GstBus *bus = NULL; + GstElement *pipe = NULL; + GstElement *decode = NULL; + GstElement *fdsink = NULL; + GstElement *mux = NULL; + + GstCaps *vscale_caps = NULL; + GstPad *asinkpad = NULL; + GstPad *vsinkpad = NULL; + GstPad *video_src_pad = NULL; + GstPad *audio_src_pad = NULL; + GstPad *mux_pad = NULL; + GstElement *src = NULL; + GstElement *vbin, *vqueue, *vcolorspace, *vscale, *vrate, *vencode, *vqueue_src; + GstElement *abin, *aqueue, *aconvert, *aencode, *aqueue_src; + GMencoderPrivate *priv = G_MENCODER_GET_PRIVATE (self); + + vbin = vqueue = vscale = vrate = vencode = vqueue_src = NULL; + abin = aqueue = aconvert = aencode = aqueue_src = NULL; + + pipe = gst_pipeline_new ("pipe"); + src = gst_element_make_from_uri (GST_URI_SRC, uri, "src"); + if (src == NULL) + goto error; + + decode = gst_element_factory_make ("decodebin", "decode"); + if (decode == NULL) + goto error; + + mux = gst_element_factory_make ("ffmux_mpeg", "mux"); + if (mux == NULL) + goto error; + + fdsink = gst_element_factory_make ("fdsink", "sink"); + if (fdsink == NULL) + goto error; + + g_debug ("Setting fd to %d", out_fd); + g_object_set (G_OBJECT (fdsink), "fd", out_fd, NULL); + + //queue ! videoscale ! video/x-raw-yuv,width=240,height=144 ! videorate ! ffenc_h263p bitrate=256000 me-method=2 ! rtph263ppay ! udpsink host=224.0.0.1 port=5000 + + vbin = gst_bin_new ("vbin"); + vqueue = gst_element_factory_make ("queue", "vqueue"); + vscale = gst_element_factory_make ("videoscale", "vscale"); + vcolorspace = gst_element_factory_make ("ffmpegcolorspace", "colorspace"); + vrate = gst_element_factory_make ("videorate", "vrate"); + vencode = gst_element_factory_make ("ffenc_mpeg1video", "vencode"); + vqueue_src = gst_element_factory_make ("queue", "queue_src"); + + + if ((vbin == NULL) || (vqueue == NULL) || (vcolorspace == NULL) + || (vscale == NULL) || (vrate == NULL) + || (vencode == NULL) || (vqueue_src == NULL)) { + g_warning ("Video elements not found"); + goto error; + } + + g_object_set (G_OBJECT (vencode), "bitrate", 200, "pass", 2, "quantizer", 5, NULL); + + gst_bin_add_many (GST_BIN (vbin), vqueue, vscale, vcolorspace, vrate, vencode, vqueue_src, NULL); + gst_element_link (vqueue, vscale); + + + vscale_caps = gst_caps_new_simple ("video/x-raw-yuv", + "width", G_TYPE_INT, 320, + "height", G_TYPE_INT, 288, + NULL); + + if (gst_element_link_filtered (vscale, vcolorspace, vscale_caps) == FALSE) { + g_warning ("Fail to resize video"); + goto error; + } + + if (gst_element_link (vcolorspace, vrate) == FALSE) { + g_warning ("Fail to link video elements"); + goto error; + } + + gst_caps_unref (vscale_caps); + + vscale_caps = gst_caps_new_simple ("video/x-raw-yuv", + "framerate", GST_TYPE_FRACTION, 10, 1, NULL); + + if (gst_element_link_filtered (vrate, vencode, vscale_caps) == FALSE) { + g_warning ("Fail to link vrate with vencode."); + goto error; + + } + + gst_element_link (vencode, vqueue_src); + + // ghost pad the video bin + vsinkpad = gst_element_get_pad (vqueue, "sink"); + gst_element_add_pad (vbin, gst_ghost_pad_new ("sink", vsinkpad)); + gst_object_unref (vsinkpad); + + video_src_pad = gst_element_get_pad (vqueue_src, "src"); + gst_element_add_pad (vbin, gst_ghost_pad_new ("src", video_src_pad)); + gst_object_unref (video_src_pad); + + + //audio/x-raw-int ! queue ! audioconvert ! faac ! rtpmp4gpay ! udpsink name=upd_audio host=224.0.0.1 port=5002 + abin = gst_bin_new ("abin"); + aqueue = gst_element_factory_make ("queue", "aqueue"); + aconvert= gst_element_factory_make ("audioconvert", "aconvert"); + aencode = gst_element_factory_make ("lame", "aencode"); + aqueue_src= gst_element_factory_make ("queue", "aqueue_src"); + + if ((abin == NULL) || (aqueue == NULL) || (aconvert == NULL) + || (aencode == NULL) || (aqueue_src == NULL)) { + g_warning ("Audio elements not found"); + goto error; + } + + gst_bin_add_many (GST_BIN (abin), aqueue, aconvert, aencode, aqueue_src, NULL); + gst_element_link_many (aqueue, aconvert, aencode, aqueue_src, NULL); + + + // ghost pad the audio bin + asinkpad = gst_element_get_pad (aqueue, "sink"); + gst_element_add_pad (abin, gst_ghost_pad_new("sink", asinkpad)); + gst_object_unref (asinkpad); + + audio_src_pad = gst_element_get_pad (aqueue_src, "src"); + gst_element_add_pad (abin, gst_ghost_pad_new("src", audio_src_pad)); + gst_object_unref (audio_src_pad); + + + // Finish Pipe + gst_bin_add_many (GST_BIN (pipe), src, decode, abin, vbin, mux, fdsink, NULL); + gst_element_link (src, decode); + + //Link bins with mux + audio_src_pad = gst_element_get_pad (abin, "src"); + mux_pad = gst_element_get_pad (mux, "audio_0"); + if (gst_pad_link (audio_src_pad, mux_pad) != GST_PAD_LINK_OK) { + g_warning ("Fail link audio and mux"); + goto error; + + } + gst_object_unref (audio_src_pad); + gst_object_unref (mux_pad); + audio_src_pad = NULL; + mux_pad = NULL; + + video_src_pad = gst_element_get_pad (vbin, "src"); + mux_pad = gst_element_get_pad (mux, "video_0"); + if (gst_pad_link (video_src_pad, mux_pad) != GST_PAD_LINK_OK) { + g_warning ("Fail link video and mux"); + goto error; + } + gst_object_unref (video_src_pad); + gst_object_unref (mux_pad); + video_src_pad = NULL; + mux_pad = NULL; + + //Link mux with sink + gst_element_link (mux, fdsink); + + bus = gst_pipeline_get_bus (GST_PIPELINE (pipe)); + gst_bus_add_watch (bus, _pipeline_bus_cb, self); + gst_object_unref (bus); + + g_signal_connect (G_OBJECT (decode), + "new-decoded-pad", + G_CALLBACK (_decodebin_new_pad_cb), + self); + + g_signal_connect (G_OBJECT (decode), + "unknown-type", + G_CALLBACK (_decodebin_unknown_type_cb), + self); + + g_debug ("Setting pipe to PAUSE"); + + priv->pipe = pipe; + priv->abin = abin; + priv->vbin = vbin; + priv->sink = fdsink; + priv->ready = FALSE; + + gst_element_set_state (pipe, GST_STATE_PAUSED); + g_debug ("End SETUP"); + return TRUE; + +error: + g_warning ("Invalid uri"); + + if (pipe != NULL) + gst_object_unref (pipe); + + if (src != NULL) + gst_object_unref (src); + + if (decode != NULL) + gst_object_unref (decode); + + if (vscale_caps != NULL) + gst_caps_unref (vscale_caps); + + if (vbin != NULL) + gst_object_unref (vbin); + + if (vqueue != NULL) + gst_object_unref (vqueue); + + if (vrate != NULL) + gst_object_unref (vrate); + + if (vencode != NULL) + gst_object_unref (vencode); + + if (vqueue_src != NULL) + gst_object_unref (vqueue_src); + + if (abin != NULL) + gst_object_unref (abin); + + if (aqueue != NULL) + gst_object_unref (aqueue); + + if (aconvert != NULL) + gst_object_unref (aconvert); + + if (aencode != NULL) + gst_object_unref (aencode); + + if (aqueue_src != NULL) + gst_object_unref (aqueue_src); + + if (video_src_pad != NULL) { + gst_object_unref (video_src_pad); + } + + if (audio_src_pad != NULL) { + gst_object_unref (audio_src_pad); + } + + if (mux != NULL) { + gst_object_unref (mux); + } + + if (mux_pad != NULL) { + gst_object_unref (mux_pad); + } + + if (fdsink != NULL) + gst_object_unref (fdsink); + + return FALSE; +} + +gboolean +g_mencoder_play_stream (GMencoder *self) +{ + GMencoderPrivate *priv = G_MENCODER_GET_PRIVATE (self); + + g_return_val_if_fail (priv->ready == TRUE, FALSE); + + if (gst_element_set_state (priv->pipe, GST_STATE_PLAYING) != GST_STATE_CHANGE_FAILURE) { + g_debug ("PLAYING"); + return TRUE; + } + return FALSE; +} + +gboolean +g_mencoder_pause_stream (GMencoder *self) +{ + GMencoderPrivate *priv = G_MENCODER_GET_PRIVATE (self); + + g_return_val_if_fail (priv->ready == TRUE, FALSE); + + if (gst_element_set_state (priv->pipe, GST_STATE_PAUSED) != GST_STATE_CHANGE_FAILURE) { + g_debug ("PAUSED"); + return TRUE; + } + return FALSE; +} + +void +g_mencoder_close_stream (GMencoder *self) +{ + + GMencoderPrivate *priv = G_MENCODER_GET_PRIVATE (self); + + g_return_if_fail (priv->ready == TRUE); + + gst_element_set_state (priv->pipe, GST_STATE_NULL); + gst_object_unref (priv->pipe); + priv->pipe = NULL; + priv->abin = NULL; + priv->vbin = NULL; + priv->sink = NULL; + priv->ready = FALSE; +} + +static gboolean +_pipeline_bus_cb (GstBus *bus, + GstMessage *msg, + gpointer user_data) +{ + switch (GST_MESSAGE_TYPE (msg)) + { + case GST_MESSAGE_STATE_CHANGED: + { + GstState oldstate; + GstState newstate; + GstState pendingstate; + + GMencoderPrivate *priv = G_MENCODER_GET_PRIVATE (user_data); + + gst_message_parse_state_changed (msg, &oldstate, + &newstate, &pendingstate); + + if (pendingstate != GST_STATE_VOID_PENDING) + break; + + if ((oldstate == GST_STATE_READY) && + (newstate == GST_STATE_PAUSED)) { + if (priv->ready) + g_signal_emit (user_data, g_mencoder_signals[PAUSED], 0); + else { + priv->ready = TRUE; + g_signal_emit (user_data, g_mencoder_signals[READY], 0); + } + } else if ((oldstate == GST_STATE_PAUSED) && + (newstate == GST_STATE_PLAYING)) { + g_signal_emit (user_data, g_mencoder_signals[PLAYING], 0); + } else if ((oldstate == GST_STATE_READY) && + (newstate == GST_STATE_NULL)) { + g_signal_emit (user_data, g_mencoder_signals[STOPED], 0); + } + break; + } + case GST_MESSAGE_ERROR: + { + GError *error; + gchar *debug; + gchar *err_str; + + gst_message_parse_error (msg, &error, &debug); + err_str = g_strdup_printf ("Error [%d] %s (%s)", error->code, + error->message, + debug); + g_signal_emit (user_data, g_mencoder_signals[ERROR], 0, err_str); + g_free (err_str); + g_clear_error (&error); + g_free (debug); + break; + } + + case GST_MESSAGE_EOS: + g_signal_emit (user_data, g_mencoder_signals[EOS], 0); + break; + default: + break; + } + return TRUE; +} + +static void +_decodebin_new_pad_cb (GstElement* object, + GstPad* pad, + gboolean flag, + gpointer user_data) +{ + GstCaps *caps; + gchar *str_caps = NULL; + GMencoderPrivate *priv = G_MENCODER_GET_PRIVATE (user_data); + + caps = gst_pad_get_caps (pad); + str_caps = gst_caps_to_string (caps); + g_debug ("CAPS : %s", str_caps); + + if (strstr (str_caps, "audio") != NULL) { + GstPad *apad = gst_element_get_pad (priv->abin, "sink"); + g_debug ("Linked with Audio"); + gst_pad_link (pad, apad); + gst_object_unref (apad); + } else if (strstr (str_caps, "video") != NULL) { + GstPad *vpad = gst_element_get_pad (priv->vbin, "sink"); + g_debug ("Linked with Video"); + gst_pad_link (pad, vpad); + gst_object_unref (vpad); + } else { + g_warning ("invalid caps %s", str_caps); + } + + g_free (str_caps); + gst_caps_unref (caps); + g_debug ("OK"); +} + +static void +_decodebin_unknown_type_cb (GstElement* object, + GstPad* pad, + GstCaps* caps, + gpointer user_data) +{ + g_warning ("Unknown Type"); +} diff -r a1783dab9ba6 -r bd0ad44171e7 gmyth-stream/gmemcoder/src/gmemcoder.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gmyth-stream/gmemcoder/src/gmemcoder.h Mon Apr 23 18:50:32 2007 +0100 @@ -0,0 +1,46 @@ +#ifndef __G_MENCODER_H__ +#define __G_MENCODER_H__ + +#include + +G_BEGIN_DECLS + +typedef struct _GMencoder GMencoder; +typedef struct _GMencoderClass GMencoderClass; + +struct _GMencoderClass { + GObjectClass parent_class; +}; + +struct _GMencoder { + GObject parent; +}; + +/* TYPE MACROS */ +#define G_TYPE_MENCODER \ + (g_mencoder_get_type()) +#define G_MENCODER(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_MENCODER, GMencoder)) +#define G_MENCODER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_MENCODER, GMencoderClass)) +#define G_IS_MENCODER(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_MENCODER)) +#define G_IS_MENCODER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_MENCODER)) +#define G_MENCODER_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), G_TYPE_MENCODER, GMencoderClass)) + + +GType g_mencoder_get_type (void); +GMencoder* g_mencoder_new (void); +gboolean g_mencoder_setup_stream (GMencoder *self, + const gchar* uri, + guint width, guint height, + gint out_fd); +gboolean g_mencoder_play_stream (GMencoder *self); +gboolean g_mencoder_pause_stream (GMencoder *self); +void g_mencoder_close_stream (GMencoder *self); + +G_END_DECLS + +#endif diff -r a1783dab9ba6 -r bd0ad44171e7 gmyth-stream/gmemcoder/src/main.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gmyth-stream/gmemcoder/src/main.c Mon Apr 23 18:50:32 2007 +0100 @@ -0,0 +1,105 @@ +#include +#include +#include +#include + +#include +#include + +#include "gmemcoder.h" + +//#define FILE_OUT 1 + +static GMainLoop *mainloop = NULL; + +static void +_mencoder_ready_cb (GMencoder *mencoder, gpointer data) +{ + g_mencoder_play_stream (mencoder); +} + +static void +_mencoder_eos_cb (GMencoder *mencoder, gpointer data) +{ + g_print ("EOS\n"); + g_main_loop_quit ((GMainLoop *) data); +} + +static void +_mencoder_error_cb (GMencoder *mencoder, const gchar* msg, gpointer data) +{ + g_print ("Error: %s\n", msg); + g_main_loop_quit ((GMainLoop *) data); +} + +static gboolean +_io_channel_cb (GIOChannel *ch, + GIOCondition condition, + gpointer data) +{ + GString *cmd = g_string_new (""); + g_io_channel_read_line_string (ch, cmd, NULL, NULL); + + if (strcmp (cmd->str, "PLAY\n") == 0) { + g_mencoder_play_stream (G_MENCODER (data)); + } else if (strcmp (cmd->str, "PAUSE\n") == 0) { + g_mencoder_pause_stream (G_MENCODER (data)); + } else if (strcmp (cmd->str, "STOP\n") == 0) { + g_mencoder_close_stream (G_MENCODER (data)); + } else if (strcmp (cmd->str, "QUIT\n") == 0) { + g_mencoder_close_stream (G_MENCODER (data)); + g_main_loop_quit (mainloop); + } + g_string_free (cmd, TRUE); + return TRUE; +} + +int +main (int argc, char** argv) +{ + GMencoder *coder; + GIOChannel *ch; + + g_type_init (); + gst_init (&argc, &argv); + + g_set_prgname ("gmemcoder"); + + coder = g_mencoder_new (); + ch = g_io_channel_unix_new (0); + +#ifdef FILE_OUT + int fd = open (argv[2], O_WRONLY | O_CREAT | O_TRUNC); + g_debug ("FD %d", fd); + g_mencoder_setup_stream (coder, argv[1], 320, 288, fd); +#else + g_mencoder_setup_stream (coder, argv[1], 320, 288, atoi (argv[2])); +#endif + + mainloop = g_main_loop_new (NULL, FALSE); + g_io_add_watch (ch, G_IO_IN, _io_channel_cb, coder); + + + g_signal_connect (G_OBJECT (coder), + "ready", + G_CALLBACK (_mencoder_ready_cb), + NULL); + + g_signal_connect (G_OBJECT (coder), + "eos", + G_CALLBACK (_mencoder_eos_cb), + mainloop); + + g_signal_connect (G_OBJECT (coder), + "error", + G_CALLBACK (_mencoder_error_cb), + mainloop); + + g_main_loop_run (mainloop); + +#if FILE_OUT + close (fd); +#endif + + return 0; +}