#include <gst/gst.h>
#include <gst/video/video.h>
-#include "gstencodebin.h"
+#include "gsttizenencodebin.h"
#ifdef GST_EXT_PAD_LINK_UNCHECKED
#define _GST_ELEMENT_LINK_MANY gst_element_link_many_unchecked
PROP_USE_VIDEO_TOGGLE,
};
-#ifdef TIZEN_FEATURE_ENCODE_BIN_SIGNAL_ENABLE
+#ifdef TIZEN_FEATURE_TIZEN_ENCODE_BIN_SIGNAL_ENABLE
/* signals */
enum
{
#endif
typedef enum {
- ENCODEBIN_ELEMENT_VENC,
- ENCODEBIN_ELEMENT_AENC,
- ENCODEBIN_ELEMENT_IENC,
- ENCODEBIN_ELEMENT_MUX,
- ENCODEBIN_ELEMENT_VIDEO_CONV
-}GstEncodeBinElement;
+ TIZEN_ENCODEBIN_ELEMENT_VENC,
+ TIZEN_ENCODEBIN_ELEMENT_AENC,
+ TIZEN_ENCODEBIN_ELEMENT_IENC,
+ TIZEN_ENCODEBIN_ELEMENT_MUX,
+ TIZEN_ENCODEBIN_ELEMENT_VIDEO_CONV
+}GstTizenEncodeBinElement;
typedef enum {
- ENCODEBIN_MUX_AUDIO_SINK,
- ENCODEBIN_MUX_VIDEO_SINK,
-}GstEncodeBinMuxSinkPad;
+ TIZEN_ENCODEBIN_MUX_AUDIO_SINK,
+ TIZEN_ENCODEBIN_MUX_VIDEO_SINK,
+}GstTizenEncodeBinMuxSinkPad;
/* FIX ME */
)
-static GstStaticPadTemplate encoder_bin_src_template =
+static GstStaticPadTemplate tizen_encode_bin_src_template =
GST_STATIC_PAD_TEMPLATE ("src",
GST_PAD_SRC,
GST_PAD_ALWAYS,
GST_STATIC_CAPS_ANY);
-static GstStaticPadTemplate encoder_bin_video_sink_template =
+static GstStaticPadTemplate tizen_encode_bin_video_sink_template =
GST_STATIC_PAD_TEMPLATE ("video",
GST_PAD_SINK,
GST_PAD_REQUEST,
STATIC_VIDEO_CAPS
);
-static GstStaticPadTemplate encoder_bin_audio_sink_template =
+static GstStaticPadTemplate tizen_encode_bin_audio_sink_template =
GST_STATIC_PAD_TEMPLATE ("audio",
GST_PAD_SINK,
GST_PAD_REQUEST,
STATIC_AUDIO_CAPS
);
-static GstStaticPadTemplate encoder_bin_image_sink_template =
+static GstStaticPadTemplate tizen_encode_bin_image_sink_template =
GST_STATIC_PAD_TEMPLATE ("image",
GST_PAD_SINK,
GST_PAD_REQUEST,
GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE ("I420"))
);
-GST_DEBUG_CATEGORY_STATIC (gst_encode_bin_debug);
-#define GST_CAT_DEFAULT gst_encode_bin_debug
+GST_DEBUG_CATEGORY_STATIC (gst_tizen_encode_bin_debug);
+#define GST_CAT_DEFAULT gst_tizen_encode_bin_debug
-static void gst_encode_bin_class_init (GstEncodeBinClass *klass);
-static void gst_encode_bin_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec);
-static void gst_encode_bin_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec);
-static void gst_encode_bin_init (GstEncodeBin * encodebin);
-static void gst_encode_bin_dispose (GObject * object);
-static void gst_encode_bin_finalize (GObject * object);
-static GstPad *gst_encode_bin_request_new_pad (GstElement *element, GstPadTemplate *templ, const gchar* name, const GstCaps *caps);
+static void gst_tizen_encode_bin_class_init (GstTizenEncodeBinClass *klass);
+static void gst_tizen_encode_bin_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec);
+static void gst_tizen_encode_bin_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec);
+static void gst_tizen_encode_bin_init (GstTizenEncodeBin * encodebin);
+static void gst_tizen_encode_bin_dispose (GObject * object);
+static void gst_tizen_encode_bin_finalize (GObject * object);
+static GstPad *gst_tizen_encode_bin_request_new_pad (GstElement *element, GstPadTemplate *templ, const gchar* name, const GstCaps *caps);
-static GstStateChangeReturn gst_encode_bin_change_state (GstElement * element, GstStateChange transition);
+static GstStateChangeReturn gst_tizen_encode_bin_change_state (GstElement * element, GstStateChange transition);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-static void gst_encode_bin_release_pad (GstElement * element, GstPad * pad);
+static void gst_tizen_encode_bin_release_pad (GstElement * element, GstPad * pad);
static gint pad_compare_name (GstPad * pad1, const gchar * name);
-static gboolean gst_encode_bin_add_element_by_name (GstEncodeBin *encodebin, GstEncodeBinElement type, const gchar *name);
-static gboolean gst_encode_bin_remove_element (GstEncodeBin *encodebin, GstElement * element);
-static gboolean gst_encode_bin_link_elements (GstEncodeBin *encodebin);
-static gboolean gst_encode_bin_unlink_elements (GstEncodeBin *encodebin);
-static gboolean gst_encode_bin_init_video_elements (GstElement *element, gpointer user_data);
-static gboolean gst_encode_bin_init_audio_elements (GstElement *element, gpointer user_data);
-static gboolean gst_encode_bin_init_image_elements (GstElement *element, gpointer user_data);
-static gboolean gst_encode_bin_block(GstEncodeBin *encodebin, gboolean value);
-static gboolean gst_encode_bin_pause(GstEncodeBin *encodebin, gboolean value);
+static gboolean gst_tizen_encode_bin_add_element_by_name (GstTizenEncodeBin *encodebin, GstTizenEncodeBinElement type, const gchar *name);
+static gboolean gst_tizen_encode_bin_remove_element (GstTizenEncodeBin *encodebin, GstElement * element);
+static gboolean gst_tizen_encode_bin_link_elements (GstTizenEncodeBin *encodebin);
+static gboolean gst_tizen_encode_bin_unlink_elements (GstTizenEncodeBin *encodebin);
+static gboolean gst_tizen_encode_bin_init_video_elements (GstElement *element, gpointer user_data);
+static gboolean gst_tizen_encode_bin_init_audio_elements (GstElement *element, gpointer user_data);
+static gboolean gst_tizen_encode_bin_init_image_elements (GstElement *element, gpointer user_data);
+static gboolean gst_tizen_encode_bin_block(GstTizenEncodeBin *encodebin, gboolean value);
+static gboolean gst_tizen_encode_bin_pause(GstTizenEncodeBin *encodebin, gboolean value);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-static GstPad* gst_encode_bin_get_mux_sink_pad(GstElement *mux, GstEncodeBinMuxSinkPad type);
+static GstPad* gst_tizen_encode_bin_get_mux_sink_pad(GstElement *mux, GstTizenEncodeBinMuxSinkPad type);
//Data probe
-static GstPadProbeReturn gst_encode_bin_video_probe(GstPad *pad, GstPadProbeInfo *info, GstEncodeBin *encodebin);
-static GstPadProbeReturn gst_encode_bin_audio_probe(GstPad *pad, GstPadProbeInfo *info, GstEncodeBin *encodebin);
-static GstPadProbeReturn gst_encode_bin_video_probe_hs(GstPad *pad, GstPadProbeInfo *info, GstEncodeBin *encodebin);
+static GstPadProbeReturn gst_tizen_encode_bin_video_probe(GstPad *pad, GstPadProbeInfo *info, GstTizenEncodeBin *encodebin);
+static GstPadProbeReturn gst_tizen_encode_bin_audio_probe(GstPad *pad, GstPadProbeInfo *info, GstTizenEncodeBin *encodebin);
+static GstPadProbeReturn gst_tizen_encode_bin_video_probe_hs(GstPad *pad, GstPadProbeInfo *info, GstTizenEncodeBin *encodebin);
static GstElementClass *parent_class;
-#ifdef TIZEN_FEATURE_ENCODE_BIN_SIGNAL_ENABLE
-static guint gst_encode_bin_signals[LAST_SIGNAL] = { 0 };
+#ifdef TIZEN_FEATURE_TIZEN_ENCODE_BIN_SIGNAL_ENABLE
+static guint gst_tizen_encode_bin_signals[LAST_SIGNAL] = { 0 };
#endif
typedef enum {
- GST_ENCODE_BIN_PROFILE_AV,
- GST_ENCODE_BIN_PROFILE_AUDIO,
- GST_ENCODE_BIN_PROFILE_IMAGE,
-} GstEncodeBinProfile;
+ GST_TIZEN_ENCODE_BIN_PROFILE_AV,
+ GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO,
+ GST_TIZEN_ENCODE_BIN_PROFILE_IMAGE,
+} GstTizenEncodeBinProfile;
GType
-gst_encode_bin_profile_get_type (void)
+gst_tizen_encode_bin_profile_get_type (void)
{
- static GType encode_bin_profile_type = 0;
+ static GType tizen_encode_bin_profile_type = 0;
static const GEnumValue profile_types[] = {
- {GST_ENCODE_BIN_PROFILE_AV, "Audio and Video Recording", "A/V"},
- {GST_ENCODE_BIN_PROFILE_AUDIO, "Audio Only Recording", "Audio"},
- {GST_ENCODE_BIN_PROFILE_IMAGE, "Image Stillshot", "Image"},
+ {GST_TIZEN_ENCODE_BIN_PROFILE_AV, "Audio and Video Recording", "A/V"},
+ {GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO, "Audio Only Recording", "Audio"},
+ {GST_TIZEN_ENCODE_BIN_PROFILE_IMAGE, "Image Stillshot", "Image"},
{0, NULL, NULL}
};
- if (!encode_bin_profile_type) {
- encode_bin_profile_type =
- g_enum_register_static ("GstEncodeBinProfile",profile_types);
+ if (!tizen_encode_bin_profile_type) {
+ tizen_encode_bin_profile_type =
+ g_enum_register_static ("GstTizenEncodeBinProfile", profile_types);
}
- return encode_bin_profile_type;
+ return tizen_encode_bin_profile_type;
}
GType
-gst_encode_bin_get_type (void)
+gst_tizen_encode_bin_get_type (void)
{
- static GType gst_encode_bin_type = 0;
+ static GType gst_tizen_encode_bin_type = 0;
- if (!gst_encode_bin_type) {
- static const GTypeInfo gst_encode_bin_info = {
- sizeof (GstEncodeBinClass),
+ if (!gst_tizen_encode_bin_type) {
+ static const GTypeInfo gst_tizen_encode_bin_info = {
+ sizeof (GstTizenEncodeBinClass),
NULL,
NULL,
- (GClassInitFunc) gst_encode_bin_class_init,
+ (GClassInitFunc) gst_tizen_encode_bin_class_init,
NULL,
NULL,
- sizeof (GstEncodeBin),
+ sizeof (GstTizenEncodeBin),
0,
- (GInstanceInitFunc) gst_encode_bin_init,
+ (GInstanceInitFunc) gst_tizen_encode_bin_init,
NULL
};
- gst_encode_bin_type =
- g_type_register_static (GST_TYPE_BIN, "GstEncodeBin",
- &gst_encode_bin_info, 0);
+ gst_tizen_encode_bin_type =
+ g_type_register_static (GST_TYPE_BIN, "GstTizenEncodeBin",
+ &gst_tizen_encode_bin_info, 0);
}
- return gst_encode_bin_type;
+ return gst_tizen_encode_bin_type;
}
static void
-queue_overun_cb (GstElement * queue, GstEncodeBin *encodebin)
+queue_overun_cb (GstElement * queue, GstTizenEncodeBin *encodebin)
{
#if 0
guint queue_size = 0;
}
static void
-gst_encode_bin_get_property (GObject * object,
+gst_tizen_encode_bin_get_property (GObject * object,
guint prop_id, GValue * value, GParamSpec * pspec)
{
- GstEncodeBin *encodebin;
+ GstTizenEncodeBin *encodebin;
- encodebin = GST_ENCODE_BIN (object);
+ encodebin = GST_TIZEN_ENCODE_BIN (object);
switch (prop_id) {
case PROP_PROFILE:
break;
case PROP_VENC_QUEUE:
// g_value_set_boolean (value, encodebin->use_venc_queue);
- if((encodebin->video_encode_queue == NULL) && (encodebin->profile == GST_ENCODE_BIN_PROFILE_AV)) {
+ if((encodebin->video_encode_queue == NULL) && (encodebin->profile == GST_TIZEN_ENCODE_BIN_PROFILE_AV)) {
encodebin->video_encode_queue = gst_element_factory_make ("queue", "video_encode_queue");
if(encodebin->video_encode_queue != NULL)
gst_bin_add(GST_BIN(encodebin), encodebin->video_encode_queue);
break;
case PROP_AENC_QUEUE:
// g_value_set_boolean (value, encodebin->use_aenc_queue);
- if((encodebin->audio_encode_queue == NULL) && (encodebin->profile <= GST_ENCODE_BIN_PROFILE_AUDIO)) {
+ if((encodebin->audio_encode_queue == NULL) && (encodebin->profile <= GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO)) {
encodebin->audio_encode_queue = gst_element_factory_make ("queue", "audio_encode_queue");
if(encodebin->audio_encode_queue != NULL)
gst_bin_add(GST_BIN(encodebin), encodebin->audio_encode_queue);
break;
//elements pointer
case PROP_VIDEO_ENC:
- if((encodebin->video_encode == NULL) && (encodebin->profile == GST_ENCODE_BIN_PROFILE_AV)) {
+ if((encodebin->video_encode == NULL) && (encodebin->profile == GST_TIZEN_ENCODE_BIN_PROFILE_AV)) {
encodebin->video_encode = gst_element_factory_make (encodebin->venc_name, "video_encode");
if(encodebin->video_encode != NULL)
gst_bin_add(GST_BIN(encodebin), encodebin->video_encode);
g_value_set_object (value, encodebin->video_encode);
break;
case PROP_AUDIO_ENC:
- if(encodebin->audio_encode == NULL && (encodebin->profile <= GST_ENCODE_BIN_PROFILE_AUDIO)) {
+ if(encodebin->audio_encode == NULL && (encodebin->profile <= GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO)) {
encodebin->audio_encode = gst_element_factory_make (encodebin->aenc_name, "audio_encode");
if(encodebin->audio_encode != NULL)
gst_bin_add(GST_BIN(encodebin), encodebin->audio_encode);
g_value_set_object (value, encodebin->audio_encode);
break;
case PROP_IMAGE_ENC:
- if(encodebin->image_encode == NULL && (encodebin->profile == GST_ENCODE_BIN_PROFILE_IMAGE)) {
+ if(encodebin->image_encode == NULL && (encodebin->profile == GST_TIZEN_ENCODE_BIN_PROFILE_IMAGE)) {
encodebin->image_encode = gst_element_factory_make (encodebin->ienc_name, "image_encode");
if(encodebin->image_encode != NULL)
gst_bin_add(GST_BIN(encodebin), encodebin->image_encode);
g_value_set_object (value, encodebin->image_encode);
break;
case PROP_MUX:
- if(encodebin->mux == NULL && (encodebin->profile <= GST_ENCODE_BIN_PROFILE_AUDIO)) {
+ if(encodebin->mux == NULL && (encodebin->profile <= GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO)) {
encodebin->mux = gst_element_factory_make (encodebin->mux_name, "mux");
if(encodebin->mux != NULL)
gst_bin_add(GST_BIN(encodebin), encodebin->mux);
g_value_set_object (value, encodebin->mux);
break;
case PROP_VIDEO_CONV:
- if(encodebin->color_space == NULL && (encodebin->profile != GST_ENCODE_BIN_PROFILE_AUDIO)) {
+ if(encodebin->color_space == NULL && (encodebin->profile != GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO)) {
encodebin->color_space = gst_element_factory_make (encodebin->vconv_name, "video_convert");
if(encodebin->color_space != NULL)
gst_bin_add(GST_BIN(encodebin), encodebin->color_space);
}
static void
-gst_encode_bin_set_property (GObject * object,
+gst_tizen_encode_bin_set_property (GObject * object,
guint prop_id, const GValue * value, GParamSpec * pspec)
{
- GstEncodeBin *encodebin;
+ GstTizenEncodeBin *encodebin;
- encodebin = GST_ENCODE_BIN (object);
+ encodebin = GST_TIZEN_ENCODE_BIN (object);
switch (prop_id) {
case PROP_PROFILE:
/*
gboolean newprofile = g_value_get_enum (value);
if(encodebin->profile != newprofile) {
- gst_encode_bin_change_profile(encodebin, newprofile);
+ gst_tizen_encode_bin_change_profile(encodebin, newprofile);
encodebin->profile = newprofile;
}
*/
break;
case PROP_VENC_NAME: {
const gchar *new_name;
- if(encodebin->profile > GST_ENCODE_BIN_PROFILE_AV) {
+ if(encodebin->profile > GST_TIZEN_ENCODE_BIN_PROFILE_AV) {
GST_WARNING_OBJECT(encodebin, "Profile isn't match, change profile first!");
break;
}
new_name = g_value_get_string (value);
if(encodebin->video_encode == NULL) {
- if(gst_encode_bin_add_element_by_name(encodebin, ENCODEBIN_ELEMENT_VENC, new_name))
+ if(gst_tizen_encode_bin_add_element_by_name(encodebin, TIZEN_ENCODEBIN_ELEMENT_VENC, new_name))
encodebin->venc_name = g_strdup (new_name);
} else {
if(strcmp (encodebin->venc_name, new_name)) {
- gst_encode_bin_remove_element(encodebin, encodebin->video_encode);
- if(gst_encode_bin_add_element_by_name(encodebin, ENCODEBIN_ELEMENT_VENC, new_name))
+ gst_tizen_encode_bin_remove_element(encodebin, encodebin->video_encode);
+ if(gst_tizen_encode_bin_add_element_by_name(encodebin, TIZEN_ENCODEBIN_ELEMENT_VENC, new_name))
encodebin->venc_name = g_strdup (new_name);
}
}
}
case PROP_AENC_NAME: {
const gchar *new_name;
- if(encodebin->profile > GST_ENCODE_BIN_PROFILE_AUDIO) {
+ if(encodebin->profile > GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO) {
GST_WARNING_OBJECT(encodebin, "Profile isn't match, change profile first!");
break;
}
new_name = g_value_get_string (value);
if(encodebin->audio_encode == NULL) {
- if(gst_encode_bin_add_element_by_name(encodebin, ENCODEBIN_ELEMENT_AENC, new_name))
+ if(gst_tizen_encode_bin_add_element_by_name(encodebin, TIZEN_ENCODEBIN_ELEMENT_AENC, new_name))
encodebin->aenc_name = g_strdup (new_name);
} else {
if(strcmp (encodebin->aenc_name, new_name)) {
- gst_encode_bin_remove_element(encodebin, encodebin->audio_encode);
- if(gst_encode_bin_add_element_by_name(encodebin, ENCODEBIN_ELEMENT_AENC, new_name))
+ gst_tizen_encode_bin_remove_element(encodebin, encodebin->audio_encode);
+ if(gst_tizen_encode_bin_add_element_by_name(encodebin, TIZEN_ENCODEBIN_ELEMENT_AENC, new_name))
encodebin->aenc_name = g_strdup (new_name);
}
}
}
case PROP_IENC_NAME: {
const gchar *new_name;
- if(encodebin->profile < GST_ENCODE_BIN_PROFILE_IMAGE) {
+ if(encodebin->profile < GST_TIZEN_ENCODE_BIN_PROFILE_IMAGE) {
GST_WARNING_OBJECT(encodebin, "Profile isn't match, change profile first!");
break;
}
new_name = g_value_get_string (value);
if(encodebin->image_encode == NULL) {
- if(gst_encode_bin_add_element_by_name(encodebin, ENCODEBIN_ELEMENT_IENC, new_name))
+ if(gst_tizen_encode_bin_add_element_by_name(encodebin, TIZEN_ENCODEBIN_ELEMENT_IENC, new_name))
encodebin->ienc_name = g_strdup (new_name);
} else {
if(strcmp (encodebin->ienc_name, new_name)) {
- gst_encode_bin_remove_element(encodebin, encodebin->image_encode);
- if(gst_encode_bin_add_element_by_name(encodebin, ENCODEBIN_ELEMENT_IENC, new_name))
+ gst_tizen_encode_bin_remove_element(encodebin, encodebin->image_encode);
+ if(gst_tizen_encode_bin_add_element_by_name(encodebin, TIZEN_ENCODEBIN_ELEMENT_IENC, new_name))
encodebin->ienc_name = g_strdup (new_name);
}
}
}
case PROP_MUX_NAME: {
const gchar *new_name;
- if(encodebin->profile > GST_ENCODE_BIN_PROFILE_AUDIO) {
+ if(encodebin->profile > GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO) {
GST_WARNING_OBJECT(encodebin, "Profile isn't match");
break;
}
new_name = g_value_get_string (value);
if(encodebin->mux == NULL) {
- if(gst_encode_bin_add_element_by_name(encodebin, ENCODEBIN_ELEMENT_MUX, new_name))
+ if(gst_tizen_encode_bin_add_element_by_name(encodebin, TIZEN_ENCODEBIN_ELEMENT_MUX, new_name))
encodebin->mux_name = g_strdup (new_name);
} else {
if(strcmp (encodebin->mux_name, new_name)) {
- gst_encode_bin_remove_element(encodebin, encodebin->mux);
- if(gst_encode_bin_add_element_by_name(encodebin, ENCODEBIN_ELEMENT_MUX, new_name))
+ gst_tizen_encode_bin_remove_element(encodebin, encodebin->mux);
+ if(gst_tizen_encode_bin_add_element_by_name(encodebin, TIZEN_ENCODEBIN_ELEMENT_MUX, new_name))
encodebin->mux_name = g_strdup (new_name);
}
}
}
case PROP_VCONV_NAME: {
const gchar *new_name;
- if (encodebin->profile == GST_ENCODE_BIN_PROFILE_AUDIO) {
+ if (encodebin->profile == GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO) {
GST_WARNING_OBJECT(encodebin, "Profile isn't match");
break;
}
new_name = g_value_get_string(value);
if (encodebin->color_space == NULL) {
- if(gst_encode_bin_add_element_by_name(encodebin, ENCODEBIN_ELEMENT_VIDEO_CONV, new_name))
+ if(gst_tizen_encode_bin_add_element_by_name(encodebin, TIZEN_ENCODEBIN_ELEMENT_VIDEO_CONV, new_name))
encodebin->vconv_name = g_strdup (new_name);
} else {
if(strcmp (encodebin->vconv_name, new_name)) {
- gst_encode_bin_remove_element(encodebin, encodebin->color_space);
- if(gst_encode_bin_add_element_by_name(encodebin, ENCODEBIN_ELEMENT_VIDEO_CONV, new_name))
+ gst_tizen_encode_bin_remove_element(encodebin, encodebin->color_space);
+ if(gst_tizen_encode_bin_add_element_by_name(encodebin, TIZEN_ENCODEBIN_ELEMENT_VIDEO_CONV, new_name))
encodebin->vconv_name = g_strdup (new_name);
}
}
case PROP_BLOCK: {
gboolean newval = g_value_get_boolean (value);
if(encodebin->block != newval) {
- if(!gst_encode_bin_block(encodebin, newval)) {
-#ifdef TIZEN_FEATURE_ENCODE_BIN_SIGNAL_ENABLE
+ if(!gst_tizen_encode_bin_block(encodebin, newval)) {
+#ifdef TIZEN_FEATURE_TIZEN_ENCODE_BIN_SIGNAL_ENABLE
if(newval) {
- g_signal_emit (G_OBJECT (encodebin), gst_encode_bin_signals[SIGNAL_STREAM_BLOCK], 0, FALSE);
+ g_signal_emit (G_OBJECT (encodebin), gst_tizen_encode_bin_signals[SIGNAL_STREAM_BLOCK], 0, FALSE);
} else {
- g_signal_emit (G_OBJECT (encodebin), gst_encode_bin_signals[SIGNAL_STREAM_UNBLOCK], 0, FALSE);
+ g_signal_emit (G_OBJECT (encodebin), gst_tizen_encode_bin_signals[SIGNAL_STREAM_UNBLOCK], 0, FALSE);
}
#endif
break;
}
}
-#ifdef TIZEN_FEATURE_ENCODE_BIN_SIGNAL_ENABLE
+#ifdef TIZEN_FEATURE_TIZEN_ENCODE_BIN_SIGNAL_ENABLE
if(newval) {
- g_signal_emit (G_OBJECT (encodebin), gst_encode_bin_signals[SIGNAL_STREAM_BLOCK], 0, TRUE);
+ g_signal_emit (G_OBJECT (encodebin), gst_tizen_encode_bin_signals[SIGNAL_STREAM_BLOCK], 0, TRUE);
} else {
- g_signal_emit (G_OBJECT (encodebin), gst_encode_bin_signals[SIGNAL_STREAM_UNBLOCK], 0, TRUE);
+ g_signal_emit (G_OBJECT (encodebin), gst_tizen_encode_bin_signals[SIGNAL_STREAM_UNBLOCK], 0, TRUE);
}
#endif
break;
case PROP_PAUSE: {
gboolean newval = g_value_get_boolean (value);
if(encodebin->pause != newval) {
- if(!gst_encode_bin_pause(encodebin, newval))
+ if(!gst_tizen_encode_bin_pause(encodebin, newval))
break;
}
-#ifdef TIZEN_FEATURE_ENCODE_BIN_SIGNAL_ENABLE
+#ifdef TIZEN_FEATURE_TIZEN_ENCODE_BIN_SIGNAL_ENABLE
if(newval) {
- g_signal_emit (G_OBJECT (encodebin), gst_encode_bin_signals[SIGNAL_STREAM_PAUSE], 0, TRUE);
+ g_signal_emit (G_OBJECT (encodebin), gst_tizen_encode_bin_signals[SIGNAL_STREAM_PAUSE], 0, TRUE);
} else {
- g_signal_emit (G_OBJECT (encodebin), gst_encode_bin_signals[SIGNAL_STREAM_RESUME], 0, TRUE);
+ g_signal_emit (G_OBJECT (encodebin), gst_tizen_encode_bin_signals[SIGNAL_STREAM_RESUME], 0, TRUE);
}
#endif
break;
// encodebin->use_venc_queue = g_value_get_boolean (value);
{
GstElement *newelement = g_value_get_object (value);
- if(encodebin->profile > GST_ENCODE_BIN_PROFILE_AV) {
+ if(encodebin->profile > GST_TIZEN_ENCODE_BIN_PROFILE_AV) {
GST_WARNING_OBJECT(encodebin, "Profile isn't match, change profile first!");
break;
}
if(newelement != NULL) {
- gst_encode_bin_remove_element(encodebin, encodebin->video_encode_queue);
+ gst_tizen_encode_bin_remove_element(encodebin, encodebin->video_encode_queue);
encodebin->video_encode_queue = newelement;
gst_object_ref_sink (GST_OBJECT_CAST (encodebin->video_encode_queue)); // take ownership ??
gst_bin_add(GST_BIN(encodebin), encodebin->video_encode_queue);
// encodebin->use_aenc_queue = g_value_get_boolean (value);
{
GstElement *newelement = g_value_get_object (value);
- if(encodebin->profile > GST_ENCODE_BIN_PROFILE_AUDIO) {
+ if(encodebin->profile > GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO) {
GST_WARNING_OBJECT(encodebin, "Profile isn't match, change profile first!");
break;
}
if(newelement != NULL) {
- gst_encode_bin_remove_element(encodebin, encodebin->audio_encode_queue);
+ gst_tizen_encode_bin_remove_element(encodebin, encodebin->audio_encode_queue);
encodebin->audio_encode_queue = newelement;
gst_object_ref_sink (GST_OBJECT_CAST (encodebin->audio_encode_queue));
gst_bin_add(GST_BIN(encodebin), encodebin->audio_encode_queue);
case PROP_VIDEO_ENC:
{
GstElement *newelement = g_value_get_object (value);
- if(encodebin->profile > GST_ENCODE_BIN_PROFILE_AV) {
+ if(encodebin->profile > GST_TIZEN_ENCODE_BIN_PROFILE_AV) {
GST_WARNING_OBJECT(encodebin, "Profile isn't match, change profile first!");
break;
}
if(newelement != NULL) {
- gst_encode_bin_remove_element(encodebin, encodebin->video_encode);
+ gst_tizen_encode_bin_remove_element(encodebin, encodebin->video_encode);
encodebin->video_encode = newelement;
gst_object_ref_sink (GST_OBJECT_CAST (encodebin->video_encode)); // take ownership ??
gst_bin_add(GST_BIN(encodebin), encodebin->video_encode);
case PROP_AUDIO_ENC:
{
GstElement *newelement = g_value_get_object (value);
- if(encodebin->profile > GST_ENCODE_BIN_PROFILE_AUDIO) {
+ if(encodebin->profile > GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO) {
GST_WARNING_OBJECT(encodebin, "Profile isn't match, change profile first!");
break;
}
if(newelement != NULL) {
- gst_encode_bin_remove_element(encodebin, encodebin->audio_encode);
+ gst_tizen_encode_bin_remove_element(encodebin, encodebin->audio_encode);
encodebin->audio_encode = newelement;
gst_object_ref_sink (GST_OBJECT_CAST (encodebin->audio_encode));
gst_bin_add(GST_BIN(encodebin), encodebin->audio_encode);
}
case PROP_IMAGE_ENC: {
GstElement *newelement = g_value_get_object (value);
- if(encodebin->profile < GST_ENCODE_BIN_PROFILE_IMAGE) {
+ if(encodebin->profile < GST_TIZEN_ENCODE_BIN_PROFILE_IMAGE) {
GST_WARNING_OBJECT(encodebin, "Profile isn't match, change profile first!");
break;
}
if(newelement != NULL) {
- gst_encode_bin_remove_element(encodebin, encodebin->image_encode);
+ gst_tizen_encode_bin_remove_element(encodebin, encodebin->image_encode);
encodebin->image_encode = newelement;
gst_object_ref_sink (GST_OBJECT_CAST (encodebin->image_encode));
gst_bin_add(GST_BIN(encodebin), encodebin->image_encode);
}
case PROP_MUX: {
GstElement *newelement = g_value_get_object (value);
- if(encodebin->profile > GST_ENCODE_BIN_PROFILE_AUDIO) {
+ if(encodebin->profile > GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO) {
GST_WARNING_OBJECT(encodebin, "Profile isn't match, change profile first!");
break;
}
if(newelement != NULL) {
- gst_encode_bin_remove_element(encodebin, encodebin->mux);
+ gst_tizen_encode_bin_remove_element(encodebin, encodebin->mux);
encodebin->mux = newelement;
gst_object_ref_sink (GST_OBJECT_CAST (encodebin->mux));
gst_bin_add(GST_BIN(encodebin), encodebin->mux);
}
case PROP_VIDEO_CONV: {
GstElement *newelement = g_value_get_object (value);
- if(encodebin->profile == GST_ENCODE_BIN_PROFILE_AUDIO) {
+ if(encodebin->profile == GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO) {
GST_WARNING_OBJECT(encodebin, "Profile isn't match, change profile first!");
break;
}
if(newelement != NULL) {
- gst_encode_bin_remove_element(encodebin, encodebin->color_space);
+ gst_tizen_encode_bin_remove_element(encodebin, encodebin->color_space);
encodebin->color_space = newelement;
gst_object_ref_sink (GST_OBJECT_CAST (encodebin->color_space));
gst_bin_add(GST_BIN(encodebin), encodebin->color_space);
}
static GstPad *
-gst_encode_bin_request_new_pad (GstElement *element, GstPadTemplate *templ,
+gst_tizen_encode_bin_request_new_pad (GstElement *element, GstPadTemplate *templ,
const gchar* name, const GstCaps *caps)
{
- GstEncodeBin *encodebin = NULL;
+ GstTizenEncodeBin *encodebin = NULL;
GstElementClass *klass = GST_ELEMENT_GET_CLASS (element);
GstPad *pad = NULL;
g_return_val_if_fail (templ != NULL, NULL);
if (templ->direction != GST_PAD_SINK) {
- GST_WARNING_OBJECT (GST_IS_ENCODE_BIN (element), "encodebin: request pad that is not a SINK pad\n");
+ GST_WARNING_OBJECT (GST_IS_TIZEN_ENCODE_BIN (element), "encodebin: request pad that is not a SINK pad\n");
return NULL;
}
- g_return_val_if_fail (GST_IS_ENCODE_BIN (element), NULL);
+ g_return_val_if_fail (GST_IS_TIZEN_ENCODE_BIN (element), NULL);
- encodebin = GST_ENCODE_BIN (element);
+ encodebin = GST_TIZEN_ENCODE_BIN (element);
/* FIXME */
if (templ == gst_element_class_get_pad_template (klass, "audio")) {
- if (encodebin->profile <= GST_ENCODE_BIN_PROFILE_AUDIO) {
- gst_encode_bin_init_audio_elements(element, NULL); //??
+ if (encodebin->profile <= GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO) {
+ gst_tizen_encode_bin_init_audio_elements(element, NULL); //??
if(encodebin->audio_sinkpad == NULL)
{
}
else
{
- GST_WARNING_OBJECT (GST_IS_ENCODE_BIN (element), "encodebin: audio pad is aleady existed, return existing audio pad\n");
+ GST_WARNING_OBJECT (GST_IS_TIZEN_ENCODE_BIN (element), "encodebin: audio pad is aleady existed, return existing audio pad\n");
return encodebin->audio_sinkpad;
}
} else
return NULL;
} else if (templ == gst_element_class_get_pad_template (klass, "video")) {
- if (encodebin->profile == GST_ENCODE_BIN_PROFILE_AV) {
- gst_encode_bin_init_video_elements(element, NULL); //??
+ if (encodebin->profile == GST_TIZEN_ENCODE_BIN_PROFILE_AV) {
+ gst_tizen_encode_bin_init_video_elements(element, NULL); //??
if(encodebin->video_sinkpad == NULL)
{
}
else
{
- GST_WARNING_OBJECT (GST_IS_ENCODE_BIN (element), "encodebin: video pad is aleady existed, return existing video pad\n");
+ GST_WARNING_OBJECT (GST_IS_TIZEN_ENCODE_BIN (element), "encodebin: video pad is aleady existed, return existing video pad\n");
return encodebin->video_sinkpad;
}
gst_element_add_pad (element, encodebin->video_sinkpad);
return encodebin->video_sinkpad;
- } else if (encodebin->profile == GST_ENCODE_BIN_PROFILE_IMAGE) {
- gst_encode_bin_init_image_elements(element, NULL); //??
+ } else if (encodebin->profile == GST_TIZEN_ENCODE_BIN_PROFILE_IMAGE) {
+ gst_tizen_encode_bin_init_image_elements(element, NULL); //??
if(encodebin->image_sinkpad == NULL)
{
}
else
{
- GST_WARNING_OBJECT (GST_IS_ENCODE_BIN (element), "encodebin: image pad is aleady existed, return existing image pad\n");
+ GST_WARNING_OBJECT (GST_IS_TIZEN_ENCODE_BIN (element), "encodebin: image pad is aleady existed, return existing image pad\n");
return encodebin->image_sinkpad;
}
} else
return NULL;
} else {
- if (encodebin->profile == GST_ENCODE_BIN_PROFILE_IMAGE) {
- gst_encode_bin_init_image_elements(element, NULL); //??
+ if (encodebin->profile == GST_TIZEN_ENCODE_BIN_PROFILE_IMAGE) {
+ gst_tizen_encode_bin_init_image_elements(element, NULL); //??
if(encodebin->image_sinkpad == NULL)
{
}
else
{
- GST_WARNING_OBJECT (GST_IS_ENCODE_BIN (element), "encodebin: image pad is aleady existed, return existing image pad\n");
+ GST_WARNING_OBJECT (GST_IS_TIZEN_ENCODE_BIN (element), "encodebin: image pad is aleady existed, return existing image pad\n");
return encodebin->image_sinkpad;
}
}
static void
-gst_encode_bin_class_init (GstEncodeBinClass *klass)
+gst_tizen_encode_bin_class_init (GstTizenEncodeBinClass *klass)
{
GObjectClass *gobject_klass;
GstElementClass *gstelement_klass;
parent_class = g_type_class_peek_parent (klass);
- gobject_klass->get_property = gst_encode_bin_get_property;
- gobject_klass->set_property = gst_encode_bin_set_property;
- gobject_klass->dispose = GST_DEBUG_FUNCPTR (gst_encode_bin_dispose);
- gobject_klass->finalize = GST_DEBUG_FUNCPTR (gst_encode_bin_finalize);
+ gobject_klass->get_property = gst_tizen_encode_bin_get_property;
+ gobject_klass->set_property = gst_tizen_encode_bin_set_property;
+ gobject_klass->dispose = GST_DEBUG_FUNCPTR (gst_tizen_encode_bin_dispose);
+ gobject_klass->finalize = GST_DEBUG_FUNCPTR (gst_tizen_encode_bin_finalize);
g_object_class_install_property (gobject_klass, PROP_PROFILE,
g_param_spec_enum ("profile", "PROFILE", "Profile of the media to record",
- GST_TYPE_ENCODE_BIN_PROFILE, DEFAULT_PROP_PROFILE,
+ GST_TYPE_TIZEN_ENCODE_BIN_PROFILE, DEFAULT_PROP_PROFILE,
G_PARAM_READWRITE));
g_object_class_install_property (gobject_klass, PROP_HIGH_SPEED,
g_param_spec_boolean ("use-video-toggle", "Use video toggle",
"Use video toggle while AV recording", TRUE, G_PARAM_READWRITE));
-#ifdef TIZEN_FEATURE_ENCODE_BIN_SIGNAL_ENABLE
- gst_encode_bin_signals[SIGNAL_STREAM_BLOCK] =
+#ifdef TIZEN_FEATURE_TIZEN_ENCODE_BIN_SIGNAL_ENABLE
+ gst_tizen_encode_bin_signals[SIGNAL_STREAM_BLOCK] =
g_signal_new ("stream-block", G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstEncodeBinClass, stream_block),
+ G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstTizenEncodeBinClass, stream_block),
NULL, NULL, g_cclosure_marshal_VOID__BOOLEAN, G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
- gst_encode_bin_signals[SIGNAL_STREAM_UNBLOCK] =
+ gst_tizen_encode_bin_signals[SIGNAL_STREAM_UNBLOCK] =
g_signal_new ("stream-unblock", G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstEncodeBinClass, stream_unblock),
+ G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstTizenEncodeBinClass, stream_unblock),
NULL, NULL, g_cclosure_marshal_VOID__BOOLEAN, G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
- gst_encode_bin_signals[SIGNAL_STREAM_PAUSE] =
+ gst_tizen_encode_bin_signals[SIGNAL_STREAM_PAUSE] =
g_signal_new ("stream-pause", G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstEncodeBinClass, stream_pause),
+ G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstTizenEncodeBinClass, stream_pause),
NULL, NULL, g_cclosure_marshal_VOID__BOOLEAN, G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
- gst_encode_bin_signals[SIGNAL_STREAM_RESUME] =
+ gst_tizen_encode_bin_signals[SIGNAL_STREAM_RESUME] =
g_signal_new ("stream-resume", G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstEncodeBinClass, stream_resume),
+ G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstTizenEncodeBinClass, stream_resume),
NULL, NULL, g_cclosure_marshal_VOID__BOOLEAN, G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
#endif
gst_element_class_add_pad_template (gstelement_klass,
- gst_static_pad_template_get (&encoder_bin_src_template));
+ gst_static_pad_template_get (&tizen_encode_bin_src_template));
gst_element_class_add_pad_template (gstelement_klass,
- gst_static_pad_template_get (&encoder_bin_audio_sink_template));
+ gst_static_pad_template_get (&tizen_encode_bin_audio_sink_template));
gst_element_class_add_pad_template (gstelement_klass,
- gst_static_pad_template_get (&encoder_bin_video_sink_template));
+ gst_static_pad_template_get (&tizen_encode_bin_video_sink_template));
gst_element_class_add_pad_template (gstelement_klass,
- gst_static_pad_template_get (&encoder_bin_image_sink_template));
+ gst_static_pad_template_get (&tizen_encode_bin_image_sink_template));
gst_element_class_set_static_metadata(gstelement_klass, "Samsung Electronics Co. Encoder Bin",
"Generic/Bin/Encoder",
"Jeonghoon Park <jh1979.park@samsung.com>, Wonhyung Cho <wh01.cho@samsung.com>, Sangho Park <sangho.g.park@samsung.com>");
gstelement_klass->request_new_pad =
- GST_DEBUG_FUNCPTR (gst_encode_bin_request_new_pad);
+ GST_DEBUG_FUNCPTR (gst_tizen_encode_bin_request_new_pad);
gstelement_klass->release_pad =
- GST_DEBUG_FUNCPTR (gst_encode_bin_release_pad);
+ GST_DEBUG_FUNCPTR (gst_tizen_encode_bin_release_pad);
gstelement_klass->change_state =
- GST_DEBUG_FUNCPTR (gst_encode_bin_change_state);
+ GST_DEBUG_FUNCPTR (gst_tizen_encode_bin_change_state);
}
static void
-gst_encode_bin_init (GstEncodeBin *encodebin)
+gst_tizen_encode_bin_init (GstTizenEncodeBin *encodebin)
{
if (encodebin->srcpad == NULL) {
encodebin->srcpad = gst_ghost_pad_new_no_target ("src", GST_PAD_SRC);
}
static void
-gst_encode_bin_dispose (GObject * object)
+gst_tizen_encode_bin_dispose (GObject * object)
{
- GstEncodeBin *encodebin = GST_ENCODE_BIN (object);
+ GstTizenEncodeBin *encodebin = GST_TIZEN_ENCODE_BIN (object);
g_free(encodebin->venc_name);
encodebin->venc_name = NULL;
}
static void
-gst_encode_bin_finalize (GObject * object)
+gst_tizen_encode_bin_finalize (GObject * object)
{
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static GstStateChangeReturn
-gst_encode_bin_change_state (GstElement * element, GstStateChange transition)
+gst_tizen_encode_bin_change_state (GstElement * element, GstStateChange transition)
{
GstStateChangeReturn ret;
- GstEncodeBin *encode_bin;
+ GstTizenEncodeBin *encode_bin;
- encode_bin = GST_ENCODE_BIN (element);
+ encode_bin = GST_TIZEN_ENCODE_BIN (element);
switch (transition) {
case GST_STATE_CHANGE_NULL_TO_READY:
- gst_encode_bin_link_elements(encode_bin);
+ gst_tizen_encode_bin_link_elements(encode_bin);
break;
case GST_STATE_CHANGE_READY_TO_PAUSED:
/* reset time related values */
case GST_STATE_CHANGE_PAUSED_TO_READY:
break;
case GST_STATE_CHANGE_READY_TO_NULL:
- gst_encode_bin_unlink_elements(encode_bin);
+ gst_tizen_encode_bin_unlink_elements(encode_bin);
break;
default:
break;
}
static void
-gst_encode_bin_release_pad (GstElement * element, GstPad * pad)
+gst_tizen_encode_bin_release_pad (GstElement * element, GstPad * pad)
{
- GstEncodeBin *encodebin = GST_ENCODE_BIN (element);
+ GstTizenEncodeBin *encodebin = GST_TIZEN_ENCODE_BIN (element);
if(!pad_compare_name(pad, "video")) {
#if 0
- gst_encode_bin_remove_element(encodebin, encodebin->video_queue);
+ gst_tizen_encode_bin_remove_element(encodebin, encodebin->video_queue);
encodebin->video_queue = NULL;
- gst_encode_bin_remove_element(encodebin, encodebin->video_toggle);
+ gst_tizen_encode_bin_remove_element(encodebin, encodebin->video_toggle);
encodebin->video_toggle = NULL;
- gst_encode_bin_remove_element(encodebin, encodebin->color_space);
+ gst_tizen_encode_bin_remove_element(encodebin, encodebin->color_space);
encodebin->color_space = NULL;
- gst_encode_bin_remove_element(encodebin, encodebin->vcapsfilter);
+ gst_tizen_encode_bin_remove_element(encodebin, encodebin->vcapsfilter);
encodebin->vcapsfilter = NULL;
- gst_encode_bin_remove_element(encodebin, encodebin->video_encode_queue);
+ gst_tizen_encode_bin_remove_element(encodebin, encodebin->video_encode_queue);
encodebin->video_encode_queue = NULL;
- gst_encode_bin_remove_element(encodebin, encodebin->video_encode);
+ gst_tizen_encode_bin_remove_element(encodebin, encodebin->video_encode);
encodebin->video_encode = NULL;
gst_element_release_request_pad(encodebin->mux, encodebin->mux_video_sinkpad);
encodebin->mux_video_sinkpad = NULL;
if(encodebin->mux_audio_sinkpad == NULL) {
- gst_encode_bin_remove_element(encodebin, encodebin->mux);
+ gst_tizen_encode_bin_remove_element(encodebin, encodebin->mux);
encodebin->mux = NULL;
}
else
encodebin->video_sinkpad = NULL;
} else if(!pad_compare_name(pad, "audio")) {
#if 0
- gst_encode_bin_remove_element(encodebin, encodebin->audio_queue);
+ gst_tizen_encode_bin_remove_element(encodebin, encodebin->audio_queue);
encodebin->audio_queue = NULL;
- gst_encode_bin_remove_element(encodebin, encodebin->audio_sample);
+ gst_tizen_encode_bin_remove_element(encodebin, encodebin->audio_sample);
encodebin->audio_sample = NULL;
- gst_encode_bin_remove_element(encodebin, encodebin->audio_conv);
+ gst_tizen_encode_bin_remove_element(encodebin, encodebin->audio_conv);
encodebin->audio_conv = NULL;
- gst_encode_bin_remove_element(encodebin, encodebin->acapsfilter);
+ gst_tizen_encode_bin_remove_element(encodebin, encodebin->acapsfilter);
encodebin->acapsfilter = NULL;
- gst_encode_bin_remove_element(encodebin, encodebin->audio_encode_queue);
+ gst_tizen_encode_bin_remove_element(encodebin, encodebin->audio_encode_queue);
encodebin->audio_encode_queue = NULL;
- gst_encode_bin_remove_element(encodebin, encodebin->audio_encode);
+ gst_tizen_encode_bin_remove_element(encodebin, encodebin->audio_encode);
encodebin->audio_encode = NULL;
encodebin->mux_audio_sinkpad;
gst_element_release_request_pad(encodebin->mux, encodebin->mux_audio_sinkpad);
if(encodebin->mux_video_sinkpad == NULL) {
- gst_encode_bin_remove_element(encodebin, encodebin->mux);
+ gst_tizen_encode_bin_remove_element(encodebin, encodebin->mux);
encodebin->mux = NULL;
}
else
encodebin->audio_sinkpad = NULL;
} else {
#if 0
- gst_encode_bin_remove_element(encodebin, encodebin->image_queue);
+ gst_tizen_encode_bin_remove_element(encodebin, encodebin->image_queue);
encodebin->image_queue = NULL;
- gst_encode_bin_remove_element(encodebin, encodebin->image_toggle);
+ gst_tizen_encode_bin_remove_element(encodebin, encodebin->image_toggle);
encodebin->image_toggle = NULL;
- gst_encode_bin_remove_element(encodebin, encodebin->color_space);
+ gst_tizen_encode_bin_remove_element(encodebin, encodebin->color_space);
encodebin->color_space = NULL;
- gst_encode_bin_remove_element(encodebin, encodebin->icapsfilter);
+ gst_tizen_encode_bin_remove_element(encodebin, encodebin->icapsfilter);
encodebin->icapsfilter = NULL;
- gst_encode_bin_remove_element(encodebin, encodebin->image_encode);
+ gst_tizen_encode_bin_remove_element(encodebin, encodebin->image_encode);
encodebin->image_encode = NULL;
#endif
gst_pad_set_active (pad, FALSE); //??
}
static gboolean
-gst_encode_bin_add_element_by_name (GstEncodeBin *encodebin, GstEncodeBinElement type, const gchar *name)
+gst_tizen_encode_bin_add_element_by_name (GstTizenEncodeBin *encodebin, GstTizenEncodeBinElement type, const gchar *name)
{
switch(type) {
- case ENCODEBIN_ELEMENT_VENC:
+ case TIZEN_ENCODEBIN_ELEMENT_VENC:
encodebin->video_encode = gst_element_factory_make (name, "video_encode");
if(encodebin->video_encode != NULL) {
gst_bin_add(GST_BIN(encodebin), encodebin->video_encode);
goto element_make_fail;
}
break;
- case ENCODEBIN_ELEMENT_AENC:
+ case TIZEN_ENCODEBIN_ELEMENT_AENC:
encodebin->audio_encode = gst_element_factory_make (name, "audio_encode");
if(encodebin->audio_encode != NULL) {
gst_bin_add(GST_BIN(encodebin), encodebin->audio_encode);
goto element_make_fail;
}
break;
- case ENCODEBIN_ELEMENT_IENC:
+ case TIZEN_ENCODEBIN_ELEMENT_IENC:
encodebin->image_encode = gst_element_factory_make (name, "image_encode");
if(encodebin->image_encode != NULL) {
gst_bin_add(GST_BIN(encodebin), encodebin->image_encode);
goto element_make_fail;
}
break;
- case ENCODEBIN_ELEMENT_MUX:
+ case TIZEN_ENCODEBIN_ELEMENT_MUX:
encodebin->mux = gst_element_factory_make (name, "mux");
if(encodebin->mux != NULL) {
gst_bin_add(GST_BIN(encodebin), encodebin->mux);
goto element_make_fail;
}
break;
- case ENCODEBIN_ELEMENT_VIDEO_CONV:
+ case TIZEN_ENCODEBIN_ELEMENT_VIDEO_CONV:
encodebin->color_space = gst_element_factory_make(name, "video_convert");
if (encodebin->color_space != NULL) {
gst_bin_add(GST_BIN(encodebin), encodebin->color_space);
static gboolean
-gst_encode_bin_remove_element (GstEncodeBin *encodebin, GstElement * element)
+gst_tizen_encode_bin_remove_element (GstTizenEncodeBin *encodebin, GstElement * element)
{
GstObject *parent;
gchar *ename = NULL;
- GST_INFO_OBJECT (encodebin, "gst_encode_bin_remove_element");
+ GST_INFO_OBJECT (encodebin, "gst_tizen_encode_bin_remove_element");
if (element == NULL) {
GST_INFO_OBJECT (encodebin, "element is already NULL");
if(!gst_bin_remove (GST_BIN_CAST (parent), element)) {
gst_object_unref (parent);
ename = gst_element_get_name (element);
- GST_ERROR_OBJECT (encodebin, "gst_encode_bin_remove_element() [%s] remove fail", ename);
+ GST_ERROR_OBJECT (encodebin, "gst_tizen_encode_bin_remove_element() [%s] remove fail", ename);
g_free (ename);
return FALSE;
} else {
}
static gboolean
-gst_encode_bin_link_elements (GstEncodeBin *encodebin) // need to return ????
+gst_tizen_encode_bin_link_elements (GstTizenEncodeBin *encodebin) // need to return ????
{
GstPad *srcpad = NULL, *sinkpad = NULL;
switch(encodebin->profile) {
- case GST_ENCODE_BIN_PROFILE_AV :
+ case GST_TIZEN_ENCODE_BIN_PROFILE_AV :
if (!gst_caps_is_any(encodebin->vcaps)) {
gchar *caps_str = NULL;
caps_str = gst_caps_to_string(encodebin->vcaps);
if(encodebin->use_venc_queue)
{
srcpad = gst_element_get_static_pad(encodebin->video_encode_queue, "src");
- sinkpad = encodebin->mux_video_sinkpad = gst_encode_bin_get_mux_sink_pad(encodebin->mux, ENCODEBIN_MUX_VIDEO_SINK);
+ sinkpad = encodebin->mux_video_sinkpad = gst_tizen_encode_bin_get_mux_sink_pad(encodebin->mux, TIZEN_ENCODEBIN_MUX_VIDEO_SINK);
_GST_PAD_LINK_UNREF(srcpad, sinkpad, video_link_fail);
}
#else
if(encodebin->video_encode_queue)
{
srcpad = gst_element_get_static_pad(encodebin->video_encode_queue, "src");
- sinkpad = encodebin->mux_video_sinkpad = gst_encode_bin_get_mux_sink_pad(encodebin->mux, ENCODEBIN_MUX_VIDEO_SINK);
+ sinkpad = encodebin->mux_video_sinkpad = gst_tizen_encode_bin_get_mux_sink_pad(encodebin->mux, TIZEN_ENCODEBIN_MUX_VIDEO_SINK);
_GST_PAD_LINK_UNREF(srcpad, sinkpad, video_link_fail);
}
#endif
else
{
srcpad = gst_element_get_static_pad(encodebin->video_encode, "src");
- sinkpad = encodebin->mux_video_sinkpad = gst_encode_bin_get_mux_sink_pad(encodebin->mux, ENCODEBIN_MUX_VIDEO_SINK);
+ sinkpad = encodebin->mux_video_sinkpad = gst_tizen_encode_bin_get_mux_sink_pad(encodebin->mux, TIZEN_ENCODEBIN_MUX_VIDEO_SINK);
_GST_PAD_LINK_UNREF(srcpad, sinkpad, video_link_fail);
}
/* For pause/resume control */
// encodebin->vsink_probeid = gst_pad_add_data_probe (gst_element_get_static_pad (encodebin->video_queue, "sink"),
sinkpad = gst_element_get_static_pad (encodebin->video_queue, "sink");
- encodebin->vsink_probeid = gst_pad_add_probe(sinkpad, GST_PAD_PROBE_TYPE_BUFFER, (GstPadProbeCallback)gst_encode_bin_video_probe, encodebin, NULL);
+ encodebin->vsink_probeid = gst_pad_add_probe(sinkpad, GST_PAD_PROBE_TYPE_BUFFER, (GstPadProbeCallback)gst_tizen_encode_bin_video_probe, encodebin, NULL);
gst_object_unref(sinkpad);
sinkpad = NULL;
{
// encodebin->vsink_hs_probeid = gst_pad_add_data_probe (gst_element_get_static_pad (encodebin->video_encode, "sink"),
sinkpad = gst_element_get_static_pad (encodebin->video_encode, "sink");
- encodebin->vsink_hs_probeid = gst_pad_add_probe (sinkpad, GST_PAD_PROBE_TYPE_BUFFER, (GstPadProbeCallback)gst_encode_bin_video_probe_hs, encodebin, NULL);
+ encodebin->vsink_hs_probeid = gst_pad_add_probe (sinkpad, GST_PAD_PROBE_TYPE_BUFFER, (GstPadProbeCallback)gst_tizen_encode_bin_video_probe_hs, encodebin, NULL);
gst_object_unref(sinkpad);
sinkpad = NULL;
}
GST_WARNING_OBJECT(encodebin, "Audio pad isn't requested, recording video only mode");
break;
}
- case GST_ENCODE_BIN_PROFILE_AUDIO :
+ case GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO :
if(!gst_caps_is_any(encodebin->acaps))
{
g_object_set(encodebin->acapsfilter, "caps", encodebin->acaps, NULL);
if(encodebin->use_aenc_queue)
{
srcpad = gst_element_get_static_pad(encodebin->audio_encode_queue, "src");
- sinkpad = encodebin->mux_audio_sinkpad = gst_encode_bin_get_mux_sink_pad(encodebin->mux, ENCODEBIN_MUX_AUDIO_SINK);
+ sinkpad = encodebin->mux_audio_sinkpad = gst_tizen_encode_bin_get_mux_sink_pad(encodebin->mux, TIZEN_ENCODEBIN_MUX_AUDIO_SINK);
_GST_PAD_LINK_UNREF(srcpad, sinkpad, audio_link_fail);
}
if(encodebin->audio_encode_queue)
{
srcpad = gst_element_get_static_pad(encodebin->audio_encode_queue, "src");
- sinkpad = encodebin->mux_audio_sinkpad = gst_encode_bin_get_mux_sink_pad(encodebin->mux, ENCODEBIN_MUX_AUDIO_SINK);
+ sinkpad = encodebin->mux_audio_sinkpad = gst_tizen_encode_bin_get_mux_sink_pad(encodebin->mux, TIZEN_ENCODEBIN_MUX_AUDIO_SINK);
_GST_PAD_LINK_UNREF(srcpad, sinkpad, audio_link_fail);
}
else
{
srcpad = gst_element_get_static_pad(encodebin->audio_encode, "src");
- sinkpad = encodebin->mux_audio_sinkpad = gst_encode_bin_get_mux_sink_pad(encodebin->mux, ENCODEBIN_MUX_AUDIO_SINK);
+ sinkpad = encodebin->mux_audio_sinkpad = gst_tizen_encode_bin_get_mux_sink_pad(encodebin->mux, TIZEN_ENCODEBIN_MUX_AUDIO_SINK);
_GST_PAD_LINK_UNREF(srcpad, sinkpad, audio_link_fail);
}
/* For pause/resume control */
sinkpad = gst_element_get_static_pad (encodebin->audio_queue, "sink");
- encodebin->asink_probeid = gst_pad_add_probe (sinkpad, GST_PAD_PROBE_TYPE_BUFFER, (GstPadProbeCallback)gst_encode_bin_audio_probe, encodebin, NULL);
+ encodebin->asink_probeid = gst_pad_add_probe (sinkpad, GST_PAD_PROBE_TYPE_BUFFER, (GstPadProbeCallback)gst_tizen_encode_bin_audio_probe, encodebin, NULL);
gst_object_unref(sinkpad);
sinkpad = NULL;
break;
- case GST_ENCODE_BIN_PROFILE_IMAGE :
+ case GST_TIZEN_ENCODE_BIN_PROFILE_IMAGE :
if(!gst_caps_is_any(encodebin->icaps))
{
g_object_set(encodebin->icapsfilter, "caps", encodebin->icaps, NULL);
video_link_fail:
// remove elements
- gst_encode_bin_remove_element(encodebin, encodebin->color_space);
+ gst_tizen_encode_bin_remove_element(encodebin, encodebin->color_space);
GST_WARNING_OBJECT(encodebin, "encodebin link video elements fail");
return FALSE;
audio_link_fail:
// remove element
- gst_encode_bin_remove_element(encodebin, encodebin->audio_conv);
- gst_encode_bin_remove_element(encodebin, encodebin->audio_sample);
+ gst_tizen_encode_bin_remove_element(encodebin, encodebin->audio_conv);
+ gst_tizen_encode_bin_remove_element(encodebin, encodebin->audio_sample);
GST_WARNING_OBJECT(encodebin, "encodebin link audio elements fail");
return FALSE;
image_link_fail:
// remove element
- gst_encode_bin_remove_element(encodebin, encodebin->color_space);
+ gst_tizen_encode_bin_remove_element(encodebin, encodebin->color_space);
GST_WARNING_OBJECT(encodebin, "encodebin link image elements fail");
return FALSE;
}
static gboolean
-gst_encode_bin_unlink_elements (GstEncodeBin *encodebin)
+gst_tizen_encode_bin_unlink_elements (GstTizenEncodeBin *encodebin)
{
GstPad *pad = NULL;
switch(encodebin->profile) {
- case GST_ENCODE_BIN_PROFILE_AV :
+ case GST_TIZEN_ENCODE_BIN_PROFILE_AV :
if (encodebin->auto_color_space) {
if (encodebin->video_toggle) {
gst_element_unlink_many(
{
break;
}
- case GST_ENCODE_BIN_PROFILE_AUDIO :
+ case GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO :
if (encodebin->auto_audio_convert ||encodebin->auto_audio_resample) {
if (!encodebin->auto_audio_convert) {
gst_element_unlink_many (
}
break;
- case GST_ENCODE_BIN_PROFILE_IMAGE :
+ case GST_TIZEN_ENCODE_BIN_PROFILE_IMAGE :
if (encodebin->auto_color_space) {
gst_element_unlink_many (
encodebin->image_queue,
}
static gboolean
-gst_encode_bin_init_video_elements (GstElement *element, gpointer user_data)
+gst_tizen_encode_bin_init_video_elements (GstElement *element, gpointer user_data)
{
- GstEncodeBin *encodebin = GST_ENCODE_BIN (element);
+ GstTizenEncodeBin *encodebin = GST_TIZEN_ENCODE_BIN (element);
- if(encodebin->profile != GST_ENCODE_BIN_PROFILE_AV)
+ if(encodebin->profile != GST_TIZEN_ENCODE_BIN_PROFILE_AV)
return FALSE;
if(encodebin->video_queue == NULL) {
}
static gboolean
-gst_encode_bin_init_audio_elements (GstElement *element, gpointer user_data)
+gst_tizen_encode_bin_init_audio_elements (GstElement *element, gpointer user_data)
{
- GstEncodeBin *encodebin = GST_ENCODE_BIN (element);
+ GstTizenEncodeBin *encodebin = GST_TIZEN_ENCODE_BIN (element);
- if(encodebin->profile > GST_ENCODE_BIN_PROFILE_AUDIO)
+ if(encodebin->profile > GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO)
return FALSE;
if(encodebin->audio_queue == NULL) {
static gboolean
-gst_encode_bin_init_image_elements (GstElement *element, gpointer user_data)
+gst_tizen_encode_bin_init_image_elements (GstElement *element, gpointer user_data)
{
- GstEncodeBin *encodebin = GST_ENCODE_BIN (element);
+ GstTizenEncodeBin *encodebin = GST_TIZEN_ENCODE_BIN (element);
- if(encodebin->profile < GST_ENCODE_BIN_PROFILE_IMAGE)
+ if(encodebin->profile < GST_TIZEN_ENCODE_BIN_PROFILE_IMAGE)
return FALSE;
if(encodebin->image_queue == NULL) {
return TRUE;
}
-static gboolean gst_encode_bin_block(GstEncodeBin *encodebin, gboolean value)
+static gboolean gst_tizen_encode_bin_block(GstTizenEncodeBin *encodebin, gboolean value)
{
if(value) { //block stream
switch(encodebin->profile) {
- case GST_ENCODE_BIN_PROFILE_AV:
+ case GST_TIZEN_ENCODE_BIN_PROFILE_AV:
if(encodebin->audio_queue == NULL && encodebin->video_queue == NULL) {
goto block_fail;
} else {
}
}
break;
- case GST_ENCODE_BIN_PROFILE_AUDIO:
+ case GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO:
if(encodebin->audio_queue == NULL) {
goto block_fail;
} else {
GST_INFO_OBJECT( encodebin, "audio_queue empty-buffers TRUE" );
}
break;
- case GST_ENCODE_BIN_PROFILE_IMAGE:
+ case GST_TIZEN_ENCODE_BIN_PROFILE_IMAGE:
if(encodebin->image_toggle == NULL) {
goto block_fail;
} else {
}
} else { //release blocked-stream
switch(encodebin->profile) {
- case GST_ENCODE_BIN_PROFILE_AV:
+ case GST_TIZEN_ENCODE_BIN_PROFILE_AV:
if(encodebin->audio_queue == NULL && encodebin->video_queue == NULL) {
goto unblock_fail;
} else {
GST_INFO_OBJECT( encodebin, "video_queue empty-buffers FALSE" );
}
break;
- case GST_ENCODE_BIN_PROFILE_AUDIO:
+ case GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO:
if(encodebin->audio_queue == NULL) {
goto unblock_fail;
} else {
GST_INFO_OBJECT( encodebin, "audio_queue empty-buffers FALSE" );
}
break;
- case GST_ENCODE_BIN_PROFILE_IMAGE:
+ case GST_TIZEN_ENCODE_BIN_PROFILE_IMAGE:
if(encodebin->image_toggle == NULL) {
goto unblock_fail;
} else {
return FALSE;
}
-static gboolean gst_encode_bin_pause(GstEncodeBin *encodebin, gboolean value)
+static gboolean gst_tizen_encode_bin_pause(GstTizenEncodeBin *encodebin, gboolean value)
{
GstClock *clock = NULL;
if(value) {
/* pause stream*/
//Block src of encode bin
- if (!gst_encode_bin_block(encodebin, TRUE))
+ if (!gst_tizen_encode_bin_block(encodebin, TRUE))
{
GST_WARNING_OBJECT (encodebin, "Fail to block Encodebin.");
goto pause_fail;
GST_WARNING_OBJECT (encodebin, "There is no clock in Encodebin.");
}
}
-#if 0 //def TIZEN_FEATURE_ENCODE_BIN_SIGNAL_ENABLE
- g_signal_emit (G_OBJECT (encodebin), gst_encode_bin_signals[SIGNAL_STREAM_PAUSE], 0, TRUE);
+#if 0 //def TIZEN_FEATURE_TIZEN_ENCODE_BIN_SIGNAL_ENABLE
+ g_signal_emit (G_OBJECT (encodebin), gst_tizen_encode_bin_signals[SIGNAL_STREAM_PAUSE], 0, TRUE);
#endif
}
else {
//TODO : How about qos?
//Unblock src of encode bin
- if (!gst_encode_bin_block(encodebin, FALSE))
+ if (!gst_tizen_encode_bin_block(encodebin, FALSE))
{
GST_WARNING_OBJECT (encodebin, "Fail to Unblock Encodebin.");
goto resume_fail;
}
-#if 0 //def TIZEN_FEATURE_ENCODE_BIN_SIGNAL_ENABLE
- g_signal_emit (G_OBJECT (encodebin), gst_encode_bin_signals[SIGNAL_STREAM_RESUME], 0, TRUE);
+#if 0 //def TIZEN_FEATURE_TIZEN_ENCODE_BIN_SIGNAL_ENABLE
+ g_signal_emit (G_OBJECT (encodebin), gst_tizen_encode_bin_signals[SIGNAL_STREAM_RESUME], 0, TRUE);
#endif
}
encodebin->pause = value;
pause_fail:
GST_WARNING_OBJECT (encodebin, "Fail to pause Encodebin");
-#ifdef TIZEN_FEATURE_ENCODE_BIN_SIGNAL_ENABLE
- g_signal_emit (G_OBJECT (encodebin), gst_encode_bin_signals[SIGNAL_STREAM_PAUSE], 0, FALSE);
+#ifdef TIZEN_FEATURE_TIZEN_ENCODE_BIN_SIGNAL_ENABLE
+ g_signal_emit (G_OBJECT (encodebin), gst_tizen_encode_bin_signals[SIGNAL_STREAM_PAUSE], 0, FALSE);
#endif
return FALSE;
resume_fail:
GST_WARNING_OBJECT (encodebin, "Fail to resume Encodebin");
-#ifdef TIZEN_FEATURE_ENCODE_BIN_SIGNAL_ENABLE
- g_signal_emit (G_OBJECT (encodebin), gst_encode_bin_signals[SIGNAL_STREAM_RESUME], 0, FALSE);
+#ifdef TIZEN_FEATURE_TIZEN_ENCODE_BIN_SIGNAL_ENABLE
+ g_signal_emit (G_OBJECT (encodebin), gst_tizen_encode_bin_signals[SIGNAL_STREAM_RESUME], 0, FALSE);
#endif
return FALSE;
}
static GstPadProbeReturn
-gst_encode_bin_video_probe(GstPad *pad, GstPadProbeInfo *info, GstEncodeBin *encodebin)
+gst_tizen_encode_bin_video_probe(GstPad *pad, GstPadProbeInfo *info, GstTizenEncodeBin *encodebin)
{
if (!encodebin)
{
}
static GstPadProbeReturn
-gst_encode_bin_video_probe_hs(GstPad *pad, GstPadProbeInfo *info, GstEncodeBin *encodebin)
+gst_tizen_encode_bin_video_probe_hs(GstPad *pad, GstPadProbeInfo *info, GstTizenEncodeBin *encodebin)
{
if (!encodebin)
{
}
static GstPadProbeReturn
-gst_encode_bin_audio_probe(GstPad *pad, GstPadProbeInfo *info, GstEncodeBin *encodebin)
+gst_tizen_encode_bin_audio_probe(GstPad *pad, GstPadProbeInfo *info, GstTizenEncodeBin *encodebin)
{
if (!encodebin)
{
}
static GstPad*
-gst_encode_bin_get_mux_sink_pad(GstElement *mux, GstEncodeBinMuxSinkPad type)
+gst_tizen_encode_bin_get_mux_sink_pad(GstElement *mux, GstTizenEncodeBinMuxSinkPad type)
{
GstElementClass *elemclass = NULL;
GList *walk = NULL;
templ = (GstPadTemplate *) walk->data;
if (GST_PAD_TEMPLATE_DIRECTION (templ) == GST_PAD_SINK) {
/* ENHANCE ME: Please add other specific mux's case */
- if (((type == ENCODEBIN_MUX_AUDIO_SINK) && strstr(GST_PAD_TEMPLATE_NAME_TEMPLATE (templ), "audio")) || //audio, audio_%d,... ex)ffmux_3gp
- ((type == ENCODEBIN_MUX_VIDEO_SINK) && strstr(GST_PAD_TEMPLATE_NAME_TEMPLATE (templ), "video")) || //video, video_%d,... ex)ffmux_3gp
+ if (((type == TIZEN_ENCODEBIN_MUX_AUDIO_SINK) && strstr(GST_PAD_TEMPLATE_NAME_TEMPLATE (templ), "audio")) || //audio, audio_%d,... ex)ffmux_3gp
+ ((type == TIZEN_ENCODEBIN_MUX_VIDEO_SINK) && strstr(GST_PAD_TEMPLATE_NAME_TEMPLATE (templ), "video")) || //video, video_%d,... ex)ffmux_3gp
strstr(GST_PAD_TEMPLATE_NAME_TEMPLATE (templ), "sink") //sink, sink_%d, wavparse_sink, ... ex)oggmux, wavparse
) {
g_print("PRINT TEMPLATE(%s)\n", GST_PAD_TEMPLATE_NAME_TEMPLATE (templ));
static gboolean
plugin_init (GstPlugin * plugin)
{
- GST_DEBUG_CATEGORY_INIT (gst_encode_bin_debug, "encodebin", 0, "encoder bin");
+ GST_DEBUG_CATEGORY_INIT (gst_tizen_encode_bin_debug, "tizenencodebin", 0, "Tizen encodebin");
#ifdef ENABLE_NLS
GST_DEBUG ("binding text domain %s to locale dir %s", GETTEXT_PACKAGE,
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
#endif /* ENABLE_NLS */
- return gst_element_register (plugin, "encodebin", GST_RANK_NONE,
- GST_TYPE_ENCODE_BIN);
+ return gst_element_register (plugin, "tizenencodebin", GST_RANK_NONE,
+ GST_TYPE_TIZEN_ENCODE_BIN);
}
GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
GST_VERSION_MINOR,
- encodebin,
- "EXT encoder bin",
+ tizenencodebin,
+ "Tizen encodebin plugin",
plugin_init, VERSION, "LGPL", "Samsung Electronics Co", "http://www.samsung.com/")
projects / platform / upstream / gst-plugins-tizen.git / commitdiff