tizenencodebin/src/gsttizenencodebin.c

   1 /*
   2  * GStreamer encodebin
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: JongHyuk Choi <jhchoi.choi@samsung.com>
   7  *
   8  * This library is free software; you can redistribute it and/or modify it under
   9  * the terms of the GNU Lesser General Public License as published by the
  10  * Free Software Foundation; either version 2.1 of the License, or (at your option)
  11  * any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful, but WITHOUT ANY
  14  * WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
  16  * License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public License
  19  * along with this library; if not, write to the Free Software Foundation, Inc., 51
  20  * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  *
  22  */
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include "config.h"
  26 #endif
  27
  28 #include <string.h>
  29 #include <gst/gst.h>
  30 #include <gst/video/video.h>
  31
  32 #include "gsttizenencodebin.h"
  33
  34 #ifdef GST_EXT_PAD_LINK_UNCHECKED
  35 #define _GST_ELEMENT_LINK_MANY          gst_element_link_many_unchecked
  36 #define _GST_ELEMENT_LINK                       gst_element_link_unchecked
  37 #define _GST_PAD_LINK                           gst_pad_link_unchecked
  38 #else
  39 #define _GST_ELEMENT_LINK_MANY          gst_element_link_many
  40 #define _GST_ELEMENT_LINK                       gst_element_link
  41 #define _GST_PAD_LINK                           gst_pad_link
  42 #endif
  43
  44 #ifndef VIDEO_ENC_QUE_TIME
  45 #define VIDEO_ENC_QUE_TIME              1
  46 #endif
  47 #ifndef AUDIO_ENC_QUE_TIME
  48 #define AUDIO_ENC_QUE_TIME      1
  49 #endif
  50
  51 //define USE_ENCODER_QUEUE_SET
  52 #ifdef USE_ENCODER_QUEUE_SET
  53 #define ENCODER_QUEUE_SET(x_queue, x_byte, x_buffer, x_time /*sec*/) \
  54 {\
  55 g_object_set(G_OBJECT(x_queue), \
  56                         "max-size-bytes", (guint)x_byte, \
  57                         "max-size-buffers", (guint)x_buffer, \
  58                         "max-size-time", (guint64)(x_time*GST_SECOND), \
  59                         NULL); \
  60                         GST_INFO("Set to [%s], max [%d] byte, max [%d] buffer, max [%d] time(sec) ", GST_OBJECT_NAME(x_queue), x_byte, x_buffer, x_time);\
  61 }
  62 #else
  63 #define ENCODER_QUEUE_SET(x_queue, x_byte, x_buffer, x_time)
  64 #endif
  65
  66 #define _GST_PAD_LINK_UNREF( srcpad, sinkpad, if_fail_goto )\
  67 {\
  68       GstPadLinkReturn ret = _GST_PAD_LINK( srcpad, sinkpad );\
  69       gst_object_unref( srcpad ); srcpad = NULL;\
  70       gst_object_unref( sinkpad ); sinkpad = NULL;\
  71       if( ret != GST_PAD_LINK_OK) goto if_fail_goto;\
  72 }
  73
  74 #define _GST_PAD_UNLINK_UNREF( srcpad, sinkpad)\
  75 {\
  76       gst_pad_unlink( srcpad, sinkpad );\
  77       gst_object_unref( srcpad ); srcpad = NULL;\
  78       gst_object_unref( sinkpad ); sinkpad = NULL;\
  79 }
  80
  81 #define DEFAULT_PROP_PROFILE            0
  82 #define DEFAULT_PROP_HIGH_SPEED         0
  83 #define DEFAULT_PROP_VENC_NAME          "avenc_h263"
  84 #define DEFAULT_PROP_AENC_NAME          "secenc_amr"
  85 #define DEFAULT_PROP_IENC_NAME          "jpegenc"
  86 #define DEFAULT_PROP_MUX_NAME           "avmux_3gp"
  87 #define DEFAULT_PROP_VCONV_NAME         "videoconvert"
  88
  89 /* props */
  90 enum
  91 {
  92         PROP_0,
  93         // encodebin mode :  a/v, audio only, stillshot
  94         PROP_PROFILE,
  95         //support slow motion capture
  96         PROP_HIGH_SPEED,
  97         //elements name
  98         PROP_VENC_NAME,
  99         PROP_AENC_NAME,
 100         PROP_IENC_NAME,
 101         PROP_MUX_NAME,
 102         PROP_VCONV_NAME,
 103         //caps
 104         PROP_VCAPS,
 105         PROP_ACAPS,
 106         PROP_ICAPS,
 107         //functions
 108         PROP_AUTO_AUDIO_CONVERT,
 109         PROP_AUTO_AUDIO_RESAMPLE,
 110         PROP_AUTO_COLORSPACE,
 111         PROP_BLOCK,
 112         PROP_PAUSE,
 113         PROP_VENC_QUEUE,
 114         PROP_AENC_QUEUE,
 115         //elements pointer
 116         PROP_VIDEO_ENC,
 117         PROP_AUDIO_ENC,
 118         PROP_IMAGE_ENC,
 119         PROP_MUX,
 120         PROP_VIDEO_CONV,
 121         //options
 122         PROP_USE_VIDEO_TOGGLE,
 123 };
 124
 125 #ifdef TIZEN_FEATURE_TIZEN_ENCODE_BIN_SIGNAL_ENABLE
 126 /* signals */
 127 enum
 128 {
 129   SIGNAL_STREAM_BLOCK,
 130   SIGNAL_STREAM_UNBLOCK,
 131   SIGNAL_STREAM_PAUSE,
 132   SIGNAL_STREAM_RESUME,
 133   LAST_SIGNAL
 134 };
 135 #endif
 136
 137 typedef enum {
 138         TIZEN_ENCODEBIN_ELEMENT_VENC,
 139         TIZEN_ENCODEBIN_ELEMENT_AENC,
 140         TIZEN_ENCODEBIN_ELEMENT_IENC,
 141         TIZEN_ENCODEBIN_ELEMENT_MUX,
 142         TIZEN_ENCODEBIN_ELEMENT_VIDEO_CONV
 143 }GstTizenEncodeBinElement;
 144
 145 typedef enum {
 146         TIZEN_ENCODEBIN_MUX_AUDIO_SINK,
 147         TIZEN_ENCODEBIN_MUX_VIDEO_SINK,
 148 }GstTizenEncodeBinMuxSinkPad;
 149
 150
 151 /* FIX ME */
 152
 153 #if (G_BYTE_ORDER == G_LITTLE_ENDIAN)
 154 # define ENDIANNESS   "LITTLE_ENDIAN, BIG_ENDIAN"
 155 #else
 156 # define ENDIANNESS   "BIG_ENDIAN, LITTLE_ENDIAN"
 157 #endif
 158
 159 /* generic templates */
 160 #define STATIC_AUDIO_CAPS \
 161 GST_STATIC_CAPS ( \
 162   "audio/x-raw, " \
 163     "format = (string) { F64LE, F64BE }, " \
 164     "rate = (int) [ 1, MAX ], " \
 165     "channels = (int) [ 1, 8 ]; " \
 166   "audio/x-raw, " \
 167     "format = (string) { F32LE, F32BE }, " \
 168     "rate = (int) [ 1, MAX ], " \
 169     "channels = (int) [ 1, 8 ]; " \
 170   "audio/x-raw, " \
 171     "format = (string) { S32LE, S32BE, U32LE, U32BE }, " \
 172     "rate = (int) [ 1, MAX ], " \
 173     "channels = (int) [ 1, 8 ]; " \
 174   "audio/x-raw, "   \
 175     "format = (string) { S24LE, S24BE, U24LE, U24BE }, " \
 176     "rate = (int) [ 1, MAX ], " \
 177     "channels = (int) [ 1, 8 ]; "       \
 178   "audio/x-raw, " \
 179     "format = (string) { S16LE, S16BE, U16LE, U16BE }, " \
 180     "rate = (int) [ 1, MAX ], " \
 181     "channels = (int) [ 1, 8 ]; " \
 182   "audio/x-raw, " \
 183     "format = (string) { S8, U8 }, " \
 184     "rate = (int) [ 1, MAX ], " \
 185     "channels = (int) [ 1, 8 ]; " \
 186 )
 187
 188 #define STATIC_VIDEO_CAPS \
 189 GST_STATIC_CAPS ( \
 190   GST_VIDEO_CAPS_MAKE("I420") ";" \
 191   GST_VIDEO_CAPS_MAKE("YV12") ";" \
 192   GST_VIDEO_CAPS_MAKE("YUY2") ";" \
 193   GST_VIDEO_CAPS_MAKE("RGB") ";" \
 194   GST_VIDEO_CAPS_MAKE("BGR") ";" \
 195   GST_VIDEO_CAPS_MAKE("Y42B") ";" \
 196   GST_VIDEO_CAPS_MAKE("Y444") ";" \
 197   GST_VIDEO_CAPS_MAKE("BGRA") ";" \
 198   GST_VIDEO_CAPS_MAKE("ARGB") ";" \
 199   GST_VIDEO_CAPS_MAKE("ABGR") ";" \
 200   GST_VIDEO_CAPS_MAKE("RGBA") ";" \
 201   GST_VIDEO_CAPS_MAKE("BGRx") ";" \
 202   GST_VIDEO_CAPS_MAKE("xBGR") ";" \
 203   GST_VIDEO_CAPS_MAKE("xRGB") ";" \
 204   GST_VIDEO_CAPS_MAKE("RGBx") ";" \
 205   GST_VIDEO_CAPS_MAKE("YUV9") ";" \
 206   GST_VIDEO_CAPS_MAKE("YVU9") ";" \
 207   GST_VIDEO_CAPS_MAKE("Y41B") ";" \
 208   GST_VIDEO_CAPS_MAKE("RGB16") ";" \
 209   GST_VIDEO_CAPS_MAKE("RGB15") ";" \
 210   GST_VIDEO_CAPS_MAKE("GRAY8") ";" \
 211   GST_VIDEO_CAPS_MAKE("RGB8P") ";" \
 212   GST_VIDEO_CAPS_MAKE("UYVY") ";" \
 213   GST_VIDEO_CAPS_MAKE("IYU1") ";" \
 214   GST_VIDEO_CAPS_MAKE("AYUV") \
 215 )
 216
 217
 218 static GstStaticPadTemplate tizen_encode_bin_src_template =
 219 GST_STATIC_PAD_TEMPLATE ("src",
 220     GST_PAD_SRC,
 221     GST_PAD_ALWAYS,
 222     GST_STATIC_CAPS_ANY);
 223
 224 static GstStaticPadTemplate tizen_encode_bin_video_sink_template =
 225 GST_STATIC_PAD_TEMPLATE ("video",
 226     GST_PAD_SINK,
 227     GST_PAD_REQUEST,
 228     STATIC_VIDEO_CAPS
 229     );
 230
 231 static GstStaticPadTemplate tizen_encode_bin_audio_sink_template =
 232 GST_STATIC_PAD_TEMPLATE ("audio",
 233     GST_PAD_SINK,
 234     GST_PAD_REQUEST,
 235     STATIC_AUDIO_CAPS
 236     );
 237
 238 static GstStaticPadTemplate tizen_encode_bin_image_sink_template =
 239 GST_STATIC_PAD_TEMPLATE ("image",
 240     GST_PAD_SINK,
 241     GST_PAD_REQUEST,
 242     GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE ("I420"))
 243     );
 244
 245 GST_DEBUG_CATEGORY_STATIC (gst_tizen_encode_bin_debug);
 246 #define GST_CAT_DEFAULT gst_tizen_encode_bin_debug
 247
 248 static void gst_tizen_encode_bin_class_init (GstTizenEncodeBinClass *klass);
 249 static void gst_tizen_encode_bin_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec);
 250 static void gst_tizen_encode_bin_set_property (GObject * object,  guint prop_id, const GValue * value, GParamSpec * pspec);
 251 static void gst_tizen_encode_bin_init (GstTizenEncodeBin * encodebin);
 252 static void gst_tizen_encode_bin_dispose (GObject * object);
 253 static void gst_tizen_encode_bin_finalize (GObject * object);
 254 static GstPad *gst_tizen_encode_bin_request_new_pad (GstElement *element, GstPadTemplate *templ, const gchar* name, const GstCaps *caps);
 255
 256 static GstStateChangeReturn gst_tizen_encode_bin_change_state (GstElement * element, GstStateChange transition);
 257 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 258 static void gst_tizen_encode_bin_release_pad (GstElement * element, GstPad * pad);
 259 static gint pad_compare_name (GstPad * pad1, const gchar * name);
 260 static gboolean gst_tizen_encode_bin_add_element_by_name (GstTizenEncodeBin *encodebin, GstTizenEncodeBinElement type, const gchar *name);
 261 static gboolean gst_tizen_encode_bin_remove_element (GstTizenEncodeBin *encodebin, GstElement * element);
 262 static gboolean gst_tizen_encode_bin_link_elements (GstTizenEncodeBin *encodebin);
 263 static gboolean gst_tizen_encode_bin_unlink_elements (GstTizenEncodeBin *encodebin);
 264 static gboolean gst_tizen_encode_bin_init_video_elements (GstElement *element, gpointer user_data);
 265 static gboolean gst_tizen_encode_bin_init_audio_elements (GstElement *element, gpointer user_data);
 266 static gboolean gst_tizen_encode_bin_init_image_elements (GstElement *element, gpointer user_data);
 267 static gboolean gst_tizen_encode_bin_block(GstTizenEncodeBin *encodebin, gboolean value);
 268 static gboolean gst_tizen_encode_bin_pause(GstTizenEncodeBin *encodebin, gboolean value);
 269 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 270 static GstPad*  gst_tizen_encode_bin_get_mux_sink_pad(GstElement *mux, GstTizenEncodeBinMuxSinkPad type);
 271
 272 //Data probe
 273 static GstPadProbeReturn gst_tizen_encode_bin_video_probe(GstPad *pad, GstPadProbeInfo *info, GstTizenEncodeBin *encodebin);
 274 static GstPadProbeReturn gst_tizen_encode_bin_audio_probe(GstPad *pad, GstPadProbeInfo *info, GstTizenEncodeBin *encodebin);
 275 static GstPadProbeReturn gst_tizen_encode_bin_video_probe_hs(GstPad *pad, GstPadProbeInfo *info, GstTizenEncodeBin *encodebin);
 276
 277 static GstElementClass *parent_class;
 278
 279 #ifdef TIZEN_FEATURE_TIZEN_ENCODE_BIN_SIGNAL_ENABLE
 280 static guint gst_tizen_encode_bin_signals[LAST_SIGNAL] = { 0 };
 281 #endif
 282
 283 typedef enum {
 284         GST_TIZEN_ENCODE_BIN_PROFILE_AV,
 285         GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO,
 286         GST_TIZEN_ENCODE_BIN_PROFILE_IMAGE,
 287 } GstTizenEncodeBinProfile;
 288
 289 GType
 290 gst_tizen_encode_bin_profile_get_type (void)
 291 {
 292         static GType tizen_encode_bin_profile_type = 0;
 293         static const GEnumValue profile_types[] = {
 294                 {GST_TIZEN_ENCODE_BIN_PROFILE_AV, "Audio and Video Recording", "A/V"},
 295                 {GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO, "Audio Only Recording", "Audio"},
 296                 {GST_TIZEN_ENCODE_BIN_PROFILE_IMAGE, "Image Stillshot", "Image"},
 297                 {0, NULL, NULL}
 298         };
 299
 300         if (!tizen_encode_bin_profile_type) {
 301                 tizen_encode_bin_profile_type =
 302                         g_enum_register_static ("GstTizenEncodeBinProfile", profile_types);
 303         }
 304         return tizen_encode_bin_profile_type;
 305 }
 306
 307 GType
 308 gst_tizen_encode_bin_get_type (void)
 309 {
 310         static GType gst_tizen_encode_bin_type = 0;
 311
 312         if (!gst_tizen_encode_bin_type) {
 313                 static const GTypeInfo gst_tizen_encode_bin_info = {
 314                         sizeof (GstTizenEncodeBinClass),
 315                         NULL,
 316                         NULL,
 317                         (GClassInitFunc) gst_tizen_encode_bin_class_init,
 318                         NULL,
 319                         NULL,
 320                         sizeof (GstTizenEncodeBin),
 321                         0,
 322                         (GInstanceInitFunc) gst_tizen_encode_bin_init,
 323                         NULL
 324         };
 325
 326         gst_tizen_encode_bin_type =
 327                 g_type_register_static (GST_TYPE_BIN, "GstTizenEncodeBin",
 328                 &gst_tizen_encode_bin_info, 0);
 329   }
 330
 331         return gst_tizen_encode_bin_type;
 332 }
 333
 334 static void
 335 queue_overun_cb (GstElement * queue, GstTizenEncodeBin *encodebin)
 336 {
 337 #if 0
 338         guint queue_size = 0;
 339         guint queue_bufnum = 0;
 340 //      guint64 queue_time= (guint64)0;
 341
 342         GstClockTime now = gst_util_get_timestamp ();
 343
 344         g_object_get(G_OBJECT(queue), "current-level-bytes", &queue_size,
 345                                                                 "current-level-buffers", &queue_bufnum,
 346         //                                                      "current-level-time", &queue_time,
 347                                                                 NULL);
 348        GST_ELEMENT_WARNING (encodebin, STREAM, TOO_LAZY,
 349            ("[%" GST_TIME_FORMAT "][%s], [%u b], [%u]",
 350            GST_TIME_ARGS(now), GST_OBJECT_NAME(queue), queue_size, queue_bufnum), (NULL));
 351 #else
 352        GST_ELEMENT_WARNING (encodebin, STREAM, TOO_LAZY,
 353            ("%s overrun", GST_OBJECT_NAME(queue)), (NULL));
 354 #endif
 355 }
 356
 357 static void
 358 gst_tizen_encode_bin_get_property (GObject * object,
 359     guint prop_id, GValue * value, GParamSpec * pspec)
 360 {
 361         GstTizenEncodeBin *encodebin;
 362
 363         encodebin = GST_TIZEN_ENCODE_BIN (object);
 364
 365         switch (prop_id) {
 366                 case PROP_PROFILE:
 367                         g_value_set_enum (value, encodebin->profile);
 368                         break;
 369                 case PROP_HIGH_SPEED:
 370                         g_value_set_int (value, encodebin->high_speed_fps);
 371                         break;
 372                 //elements name
 373                 case PROP_VENC_NAME:
 374                         g_value_set_string (value, encodebin->venc_name);
 375                         break;
 376                 case PROP_AENC_NAME:
 377                         g_value_set_string (value, encodebin->aenc_name);
 378                         break;
 379                 case PROP_IENC_NAME:
 380                         g_value_set_string (value, encodebin->ienc_name);
 381                         break;
 382                 case PROP_MUX_NAME:
 383                         g_value_set_string (value, encodebin->mux_name);
 384                         break;
 385                 case PROP_VCONV_NAME:
 386                         g_value_set_string (value, encodebin->vconv_name);
 387                         break;
 388                 //caps
 389                 case PROP_VCAPS:
 390                         gst_value_set_caps (value, encodebin->vcaps);
 391                         break;
 392                 case PROP_ACAPS:
 393                         gst_value_set_caps (value, encodebin->acaps);
 394                         break;
 395                 case PROP_ICAPS:
 396                         gst_value_set_caps (value, encodebin->icaps);
 397                         break;
 398                 //functions
 399                 case PROP_AUTO_AUDIO_CONVERT:
 400                         g_value_set_boolean (value, encodebin->auto_audio_convert);
 401                         break;
 402                 case PROP_AUTO_AUDIO_RESAMPLE:
 403                         g_value_set_boolean (value, encodebin->auto_audio_resample);
 404                         break;
 405                 case PROP_AUTO_COLORSPACE:
 406                         g_value_set_boolean (value, encodebin->auto_color_space);
 407                         break;
 408                 case PROP_BLOCK:
 409                         g_value_set_boolean (value, encodebin->block);
 410                         break;
 411                 case PROP_PAUSE:
 412                         g_value_set_boolean (value, encodebin->pause);
 413                         break;
 414                 case PROP_VENC_QUEUE:
 415 //                      g_value_set_boolean (value, encodebin->use_venc_queue);
 416                         if((encodebin->video_encode_queue == NULL) && (encodebin->profile == GST_TIZEN_ENCODE_BIN_PROFILE_AV)) {
 417                                 encodebin->video_encode_queue = gst_element_factory_make ("queue", "video_encode_queue");
 418                                 if(encodebin->video_encode_queue != NULL)
 419                                         gst_bin_add(GST_BIN(encodebin), encodebin->video_encode_queue);
 420                         }
 421                         g_value_set_object (value, encodebin->video_encode_queue);
 422                         break;
 423                 case PROP_AENC_QUEUE:
 424 //                      g_value_set_boolean (value, encodebin->use_aenc_queue);
 425                         if((encodebin->audio_encode_queue == NULL) && (encodebin->profile <= GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO)) {
 426                                 encodebin->audio_encode_queue = gst_element_factory_make ("queue", "audio_encode_queue");
 427                                 if(encodebin->audio_encode_queue != NULL)
 428                                         gst_bin_add(GST_BIN(encodebin), encodebin->audio_encode_queue);
 429                         }
 430                         g_value_set_object (value, encodebin->audio_encode_queue);
 431                         break;
 432                 //elements pointer
 433                 case PROP_VIDEO_ENC:
 434                         if((encodebin->video_encode == NULL) && (encodebin->profile == GST_TIZEN_ENCODE_BIN_PROFILE_AV)) {
 435                                 encodebin->video_encode = gst_element_factory_make (encodebin->venc_name, "video_encode");
 436                                 if(encodebin->video_encode != NULL)
 437                                         gst_bin_add(GST_BIN(encodebin), encodebin->video_encode);
 438                         }
 439                         g_value_set_object (value, encodebin->video_encode);
 440                         break;
 441                 case PROP_AUDIO_ENC:
 442                         if(encodebin->audio_encode == NULL && (encodebin->profile <= GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO)) {
 443                                 encodebin->audio_encode = gst_element_factory_make (encodebin->aenc_name, "audio_encode");
 444                                 if(encodebin->audio_encode != NULL)
 445                                         gst_bin_add(GST_BIN(encodebin), encodebin->audio_encode);
 446                         }
 447                         g_value_set_object (value, encodebin->audio_encode);
 448                         break;
 449                 case PROP_IMAGE_ENC:
 450                         if(encodebin->image_encode == NULL && (encodebin->profile == GST_TIZEN_ENCODE_BIN_PROFILE_IMAGE)) {
 451                                 encodebin->image_encode = gst_element_factory_make (encodebin->ienc_name, "image_encode");
 452                                 if(encodebin->image_encode != NULL)
 453                                         gst_bin_add(GST_BIN(encodebin), encodebin->image_encode);
 454                         }
 455                         g_value_set_object (value, encodebin->image_encode);
 456                         break;
 457                 case PROP_MUX:
 458                         if(encodebin->mux == NULL && (encodebin->profile <= GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO)) {
 459                                 encodebin->mux = gst_element_factory_make (encodebin->mux_name, "mux");
 460                                 if(encodebin->mux != NULL)
 461                                         gst_bin_add(GST_BIN(encodebin), encodebin->mux);
 462                         }
 463                         g_value_set_object (value, encodebin->mux);
 464                         break;
 465                 case PROP_VIDEO_CONV:
 466                         if(encodebin->color_space == NULL && (encodebin->profile != GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO)) {
 467                                 encodebin->color_space = gst_element_factory_make (encodebin->vconv_name, "video_convert");
 468                                 if(encodebin->color_space != NULL)
 469                                         gst_bin_add(GST_BIN(encodebin), encodebin->color_space);
 470                         }
 471                         g_value_set_object (value, encodebin->color_space);
 472                         break;
 473                 case PROP_USE_VIDEO_TOGGLE:
 474                         g_value_set_boolean( value, encodebin->use_video_toggle );
 475                         break;
 476                 default:
 477                         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 478                         break;
 479         }
 480 }
 481
 482 static void
 483 gst_tizen_encode_bin_set_property (GObject * object,
 484     guint prop_id, const GValue * value, GParamSpec * pspec)
 485 {
 486         GstTizenEncodeBin *encodebin;
 487
 488         encodebin = GST_TIZEN_ENCODE_BIN (object);
 489
 490         switch (prop_id) {
 491                 case PROP_PROFILE:
 492                         encodebin->profile = g_value_get_enum (value);
 493                         /*
 494                         gboolean newprofile = g_value_get_enum (value);
 495                         if(encodebin->profile != newprofile) {
 496                           gst_tizen_encode_bin_change_profile(encodebin, newprofile);
 497                         encodebin->profile = newprofile;
 498                                 }
 499                         */
 500                         break;
 501                 case PROP_HIGH_SPEED:
 502                         encodebin->high_speed_fps = g_value_get_int (value);
 503                         break;
 504                 case PROP_VENC_NAME: {
 505                         const gchar  *new_name;
 506                         if(encodebin->profile > GST_TIZEN_ENCODE_BIN_PROFILE_AV) {
 507                                 GST_WARNING_OBJECT(encodebin, "Profile isn't match, change profile first!");
 508                                 break;
 509                         }
 510                         new_name = g_value_get_string (value);
 511
 512                         if(encodebin->video_encode == NULL) {
 513                                 if(gst_tizen_encode_bin_add_element_by_name(encodebin, TIZEN_ENCODEBIN_ELEMENT_VENC, new_name))
 514                                         encodebin->venc_name = g_strdup (new_name);
 515                         } else {
 516                                 if(strcmp (encodebin->venc_name, new_name)) {
 517                                         gst_tizen_encode_bin_remove_element(encodebin, encodebin->video_encode);
 518                                         if(gst_tizen_encode_bin_add_element_by_name(encodebin, TIZEN_ENCODEBIN_ELEMENT_VENC, new_name))
 519                                                 encodebin->venc_name = g_strdup (new_name);
 520                                 }
 521                         }
 522                         break;
 523                 }
 524                 case PROP_AENC_NAME: {
 525                         const gchar  *new_name;
 526                         if(encodebin->profile > GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO) {
 527                                 GST_WARNING_OBJECT(encodebin, "Profile isn't match, change profile first!");
 528                                 break;
 529                         }
 530                         new_name = g_value_get_string (value);
 531
 532                         if(encodebin->audio_encode == NULL) {
 533                                 if(gst_tizen_encode_bin_add_element_by_name(encodebin, TIZEN_ENCODEBIN_ELEMENT_AENC, new_name))
 534                                         encodebin->aenc_name = g_strdup (new_name);
 535                         } else {
 536                                 if(strcmp (encodebin->aenc_name, new_name)) {
 537                                         gst_tizen_encode_bin_remove_element(encodebin, encodebin->audio_encode);
 538                                         if(gst_tizen_encode_bin_add_element_by_name(encodebin, TIZEN_ENCODEBIN_ELEMENT_AENC, new_name))
 539                                                 encodebin->aenc_name = g_strdup (new_name);
 540                                 }
 541                         }
 542                         break;
 543                 }
 544                 case PROP_IENC_NAME: {
 545                         const gchar  *new_name;
 546                         if(encodebin->profile < GST_TIZEN_ENCODE_BIN_PROFILE_IMAGE) {
 547                                 GST_WARNING_OBJECT(encodebin, "Profile isn't match, change profile first!");
 548                                 break;
 549                         }
 550                         new_name = g_value_get_string (value);
 551
 552                         if(encodebin->image_encode == NULL) {
 553                                 if(gst_tizen_encode_bin_add_element_by_name(encodebin, TIZEN_ENCODEBIN_ELEMENT_IENC, new_name))
 554                                         encodebin->ienc_name = g_strdup (new_name);
 555                         } else {
 556                                 if(strcmp (encodebin->ienc_name, new_name)) {
 557                                         gst_tizen_encode_bin_remove_element(encodebin, encodebin->image_encode);
 558                                         if(gst_tizen_encode_bin_add_element_by_name(encodebin, TIZEN_ENCODEBIN_ELEMENT_IENC, new_name))
 559                                                 encodebin->ienc_name = g_strdup (new_name);
 560                                 }
 561                         }
 562                         break;
 563                 }
 564                 case PROP_MUX_NAME: {
 565                         const gchar  *new_name;
 566                         if(encodebin->profile > GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO) {
 567                                 GST_WARNING_OBJECT(encodebin, "Profile isn't match");
 568                                 break;
 569                         }
 570                         new_name = g_value_get_string (value);
 571
 572                         if(encodebin->mux == NULL) {
 573                                 if(gst_tizen_encode_bin_add_element_by_name(encodebin, TIZEN_ENCODEBIN_ELEMENT_MUX, new_name))
 574                                         encodebin->mux_name = g_strdup (new_name);
 575                         } else {
 576                                 if(strcmp (encodebin->mux_name, new_name)) {
 577                                         gst_tizen_encode_bin_remove_element(encodebin, encodebin->mux);
 578                                         if(gst_tizen_encode_bin_add_element_by_name(encodebin, TIZEN_ENCODEBIN_ELEMENT_MUX, new_name))
 579                                                 encodebin->mux_name = g_strdup (new_name);
 580                                 }
 581                         }
 582                         break;
 583                 }
 584                 case PROP_VCONV_NAME: {
 585                         const gchar  *new_name;
 586                         if (encodebin->profile == GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO) {
 587                                 GST_WARNING_OBJECT(encodebin, "Profile isn't match");
 588                                 break;
 589                         }
 590                         new_name = g_value_get_string(value);
 591
 592                         if (encodebin->color_space == NULL) {
 593                                 if(gst_tizen_encode_bin_add_element_by_name(encodebin, TIZEN_ENCODEBIN_ELEMENT_VIDEO_CONV, new_name))
 594                                         encodebin->vconv_name = g_strdup (new_name);
 595                         } else {
 596                                 if(strcmp (encodebin->vconv_name, new_name)) {
 597                                         gst_tizen_encode_bin_remove_element(encodebin, encodebin->color_space);
 598                                         if(gst_tizen_encode_bin_add_element_by_name(encodebin, TIZEN_ENCODEBIN_ELEMENT_VIDEO_CONV, new_name))
 599                                                 encodebin->vconv_name = g_strdup (new_name);
 600                                 }
 601                         }
 602                         break;
 603                 }
 604                 //caps
 605                 case PROP_VCAPS: {
 606                         GstCaps *new_caps;
 607                         GstCaps *old_caps;
 608                         const GstCaps *new_caps_val = gst_value_get_caps (value);
 609
 610                         if (new_caps_val == NULL) {
 611                                 new_caps = gst_caps_new_any ();
 612                         } else {
 613                                 new_caps = (GstCaps *) new_caps_val;
 614                                 gst_caps_ref (new_caps);
 615                         }
 616
 617                         old_caps = encodebin->vcaps;
 618                         encodebin->vcaps = new_caps;
 619                         gst_caps_unref (old_caps);
 620                         break;
 621                 }
 622                 case PROP_ACAPS: {
 623                         GstCaps *new_caps;
 624                         GstCaps *old_caps;
 625                         const GstCaps *new_caps_val = gst_value_get_caps (value);
 626
 627                         if (new_caps_val == NULL) {
 628                                 new_caps = gst_caps_new_any ();
 629                         } else {
 630                                 new_caps = (GstCaps *) new_caps_val;
 631                                 gst_caps_ref (new_caps);
 632                         }
 633
 634                         old_caps = encodebin->acaps;
 635                         encodebin->acaps = new_caps;
 636                         gst_caps_unref (old_caps);
 637                         break;
 638                 }
 639                 case PROP_ICAPS: {
 640                         GstCaps *new_caps;
 641                         GstCaps *old_caps;
 642                         const GstCaps *new_caps_val = gst_value_get_caps (value);
 643
 644                         if (new_caps_val == NULL) {
 645                                 new_caps = gst_caps_new_any ();
 646                         } else {
 647                                 new_caps = (GstCaps *) new_caps_val;
 648                                 gst_caps_ref (new_caps);
 649                         }
 650
 651                         old_caps = encodebin->icaps;
 652                         encodebin->icaps = new_caps;
 653                         gst_caps_unref (old_caps);
 654                         break;
 655                 }
 656                 //functions
 657                 case PROP_AUTO_AUDIO_CONVERT:
 658                    encodebin->auto_audio_convert = g_value_get_boolean (value);
 659                   break;
 660                 case PROP_AUTO_AUDIO_RESAMPLE:
 661                   encodebin->auto_audio_resample = g_value_get_boolean (value);
 662                   break;
 663                 case PROP_AUTO_COLORSPACE:
 664                   encodebin->auto_color_space = g_value_get_boolean (value);
 665                   break;
 666                 case PROP_BLOCK: {
 667                         gboolean newval = g_value_get_boolean (value);
 668                         if(encodebin->block != newval) {
 669                                 if(!gst_tizen_encode_bin_block(encodebin, newval)) {
 670 #ifdef TIZEN_FEATURE_TIZEN_ENCODE_BIN_SIGNAL_ENABLE
 671                                         if(newval) {
 672                                                 g_signal_emit (G_OBJECT (encodebin), gst_tizen_encode_bin_signals[SIGNAL_STREAM_BLOCK], 0, FALSE);
 673                                         } else {
 674                                                 g_signal_emit (G_OBJECT (encodebin), gst_tizen_encode_bin_signals[SIGNAL_STREAM_UNBLOCK], 0, FALSE);
 675                                         }
 676 #endif
 677                                         break;
 678                                 }
 679                         }
 680 #ifdef TIZEN_FEATURE_TIZEN_ENCODE_BIN_SIGNAL_ENABLE
 681                         if(newval) {
 682                                 g_signal_emit (G_OBJECT (encodebin), gst_tizen_encode_bin_signals[SIGNAL_STREAM_BLOCK], 0, TRUE);
 683                         } else {
 684                                 g_signal_emit (G_OBJECT (encodebin), gst_tizen_encode_bin_signals[SIGNAL_STREAM_UNBLOCK], 0, TRUE);
 685                         }
 686 #endif
 687                         break;
 688                 }
 689                 case PROP_PAUSE: {
 690                         gboolean newval = g_value_get_boolean (value);
 691                         if(encodebin->pause != newval) {
 692                                 if(!gst_tizen_encode_bin_pause(encodebin, newval))
 693                                         break;
 694                         }
 695 #ifdef TIZEN_FEATURE_TIZEN_ENCODE_BIN_SIGNAL_ENABLE
 696                         if(newval) {
 697                                 g_signal_emit (G_OBJECT (encodebin), gst_tizen_encode_bin_signals[SIGNAL_STREAM_PAUSE], 0, TRUE);
 698                         } else {
 699                                 g_signal_emit (G_OBJECT (encodebin), gst_tizen_encode_bin_signals[SIGNAL_STREAM_RESUME], 0, TRUE);
 700                         }
 701 #endif
 702                         break;
 703                 }
 704                 case PROP_VENC_QUEUE:
 705 //                encodebin->use_venc_queue = g_value_get_boolean (value);
 706                 {
 707                         GstElement *newelement = g_value_get_object (value);
 708                         if(encodebin->profile > GST_TIZEN_ENCODE_BIN_PROFILE_AV) {
 709                                 GST_WARNING_OBJECT(encodebin, "Profile isn't match, change profile first!");
 710                                 break;
 711                         }
 712                         if(newelement != NULL) {
 713                                 gst_tizen_encode_bin_remove_element(encodebin, encodebin->video_encode_queue);
 714                                 encodebin->video_encode_queue = newelement;
 715                                 gst_object_ref_sink (GST_OBJECT_CAST (encodebin->video_encode_queue)); // take ownership ??
 716                                 gst_bin_add(GST_BIN(encodebin), encodebin->video_encode_queue);
 717                         }
 718                         break;
 719                 }
 720                   break;
 721                 case PROP_AENC_QUEUE:
 722 //                encodebin->use_aenc_queue = g_value_get_boolean (value);
 723                 {
 724                         GstElement *newelement = g_value_get_object (value);
 725                         if(encodebin->profile > GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO) {
 726                                 GST_WARNING_OBJECT(encodebin, "Profile isn't match, change profile first!");
 727                                 break;
 728                         }
 729                         if(newelement != NULL) {
 730                                 gst_tizen_encode_bin_remove_element(encodebin, encodebin->audio_encode_queue);
 731                                 encodebin->audio_encode_queue = newelement;
 732                                 gst_object_ref_sink (GST_OBJECT_CAST (encodebin->audio_encode_queue));
 733                                 gst_bin_add(GST_BIN(encodebin), encodebin->audio_encode_queue);
 734                         }
 735                         break;
 736                 }
 737                   break;
 738                 case PROP_VIDEO_ENC:
 739                 {
 740                         GstElement *newelement = g_value_get_object (value);
 741                         if(encodebin->profile > GST_TIZEN_ENCODE_BIN_PROFILE_AV) {
 742                                 GST_WARNING_OBJECT(encodebin, "Profile isn't match, change profile first!");
 743                                 break;
 744                         }
 745                         if(newelement != NULL) {
 746                                 gst_tizen_encode_bin_remove_element(encodebin, encodebin->video_encode);
 747                                 encodebin->video_encode = newelement;
 748                                 gst_object_ref_sink (GST_OBJECT_CAST (encodebin->video_encode)); // take ownership ??
 749                                 gst_bin_add(GST_BIN(encodebin), encodebin->video_encode);
 750                         }
 751                         break;
 752                 }
 753                 case PROP_AUDIO_ENC:
 754                 {
 755                         GstElement *newelement = g_value_get_object (value);
 756                         if(encodebin->profile > GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO) {
 757                                 GST_WARNING_OBJECT(encodebin, "Profile isn't match, change profile first!");
 758                                 break;
 759                         }
 760                         if(newelement != NULL) {
 761                                 gst_tizen_encode_bin_remove_element(encodebin, encodebin->audio_encode);
 762                                 encodebin->audio_encode = newelement;
 763                                 gst_object_ref_sink (GST_OBJECT_CAST (encodebin->audio_encode));
 764                                 gst_bin_add(GST_BIN(encodebin), encodebin->audio_encode);
 765                         }
 766                         break;
 767                 }
 768                 case PROP_IMAGE_ENC: {
 769                         GstElement *newelement = g_value_get_object (value);
 770                         if(encodebin->profile < GST_TIZEN_ENCODE_BIN_PROFILE_IMAGE) {
 771                                 GST_WARNING_OBJECT(encodebin, "Profile isn't match, change profile first!");
 772                                 break;
 773                         }
 774                         if(newelement != NULL) {
 775                                 gst_tizen_encode_bin_remove_element(encodebin, encodebin->image_encode);
 776                                 encodebin->image_encode = newelement;
 777                                 gst_object_ref_sink (GST_OBJECT_CAST (encodebin->image_encode));
 778                                 gst_bin_add(GST_BIN(encodebin), encodebin->image_encode);
 779                         }
 780                         break;
 781                 }
 782                 case PROP_MUX: {
 783                         GstElement *newelement = g_value_get_object (value);
 784                         if(encodebin->profile > GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO) {
 785                                 GST_WARNING_OBJECT(encodebin, "Profile isn't match, change profile first!");
 786                                 break;
 787                         }
 788                         if(newelement != NULL) {
 789                                 gst_tizen_encode_bin_remove_element(encodebin, encodebin->mux);
 790                                 encodebin->mux = newelement;
 791                                 gst_object_ref_sink (GST_OBJECT_CAST (encodebin->mux));
 792                                 gst_bin_add(GST_BIN(encodebin), encodebin->mux);
 793                         }
 794                         break;
 795                 }
 796                 case PROP_VIDEO_CONV: {
 797                         GstElement *newelement = g_value_get_object (value);
 798                         if(encodebin->profile == GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO) {
 799                                 GST_WARNING_OBJECT(encodebin, "Profile isn't match, change profile first!");
 800                                 break;
 801                         }
 802                         if(newelement != NULL) {
 803                                 gst_tizen_encode_bin_remove_element(encodebin, encodebin->color_space);
 804                                 encodebin->color_space = newelement;
 805                                 gst_object_ref_sink (GST_OBJECT_CAST (encodebin->color_space));
 806                                 gst_bin_add(GST_BIN(encodebin), encodebin->color_space);
 807                         }
 808                         break;
 809                 }
 810                 case PROP_USE_VIDEO_TOGGLE:
 811                         encodebin->use_video_toggle = g_value_get_boolean( value );
 812                         break;
 813                 default:
 814                         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 815                         break;
 816         }
 817 }
 818
 819 static GstPad *
 820 gst_tizen_encode_bin_request_new_pad (GstElement *element, GstPadTemplate *templ,
 821         const gchar* name, const GstCaps *caps)
 822 {
 823         GstTizenEncodeBin *encodebin = NULL;
 824         GstElementClass *klass = GST_ELEMENT_GET_CLASS (element);
 825         GstPad *pad = NULL;
 826
 827         g_return_val_if_fail (templ != NULL, NULL);
 828
 829         if (templ->direction != GST_PAD_SINK) {
 830                 GST_WARNING_OBJECT (GST_IS_TIZEN_ENCODE_BIN (element), "encodebin: request pad that is not a SINK pad\n");
 831                 return NULL;
 832         }
 833
 834         g_return_val_if_fail (GST_IS_TIZEN_ENCODE_BIN (element), NULL);
 835
 836         encodebin = GST_TIZEN_ENCODE_BIN (element);
 837
 838  /* FIXME */
 839         if (templ == gst_element_class_get_pad_template (klass, "audio")) {
 840                 if (encodebin->profile <= GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO) {
 841                         gst_tizen_encode_bin_init_audio_elements(element, NULL); //??
 842
 843                         if(encodebin->audio_sinkpad == NULL)
 844                         {
 845                                 pad = gst_element_get_static_pad (encodebin->audio_queue, "sink");
 846                                 encodebin->audio_sinkpad = gst_ghost_pad_new ("audio", pad);
 847                                 gst_object_unref(pad);
 848                                 pad = NULL;
 849                         }
 850                         else
 851                         {
 852                                 GST_WARNING_OBJECT (GST_IS_TIZEN_ENCODE_BIN (element), "encodebin: audio pad is aleady existed, return existing audio pad\n");
 853                                 return encodebin->audio_sinkpad;
 854                         }
 855
 856                         gst_element_add_pad (element, encodebin->audio_sinkpad);
 857                         return encodebin->audio_sinkpad;
 858                 } else
 859                         return NULL;
 860         } else if (templ == gst_element_class_get_pad_template (klass, "video")) {
 861                 if (encodebin->profile == GST_TIZEN_ENCODE_BIN_PROFILE_AV) {
 862                         gst_tizen_encode_bin_init_video_elements(element, NULL); //??
 863
 864                         if(encodebin->video_sinkpad == NULL)
 865                         {
 866                                 pad = gst_element_get_static_pad (encodebin->video_queue, "sink");
 867                                 encodebin->video_sinkpad = gst_ghost_pad_new ("video", pad);
 868                                 gst_object_unref(pad);
 869                                 pad = NULL;
 870                         }
 871                         else
 872                         {
 873                                 GST_WARNING_OBJECT (GST_IS_TIZEN_ENCODE_BIN (element), "encodebin: video pad is aleady existed, return existing video pad\n");
 874                                 return encodebin->video_sinkpad;
 875                         }
 876
 877                         gst_element_add_pad (element, encodebin->video_sinkpad);
 878                         return encodebin->video_sinkpad;
 879                 } else if (encodebin->profile == GST_TIZEN_ENCODE_BIN_PROFILE_IMAGE) {
 880                         gst_tizen_encode_bin_init_image_elements(element, NULL); //??
 881
 882                         if(encodebin->image_sinkpad == NULL)
 883                         {
 884                                 pad = gst_element_get_static_pad (encodebin->image_queue, "sink");
 885                                 encodebin->image_sinkpad = gst_ghost_pad_new ("image", pad);
 886                                 gst_object_unref(pad);
 887                                 pad = NULL;
 888                         }
 889                         else
 890                         {
 891                                 GST_WARNING_OBJECT (GST_IS_TIZEN_ENCODE_BIN (element), "encodebin: image pad is aleady existed, return existing image pad\n");
 892                                 return encodebin->image_sinkpad;
 893                         }
 894
 895                         gst_element_add_pad (element, encodebin->image_sinkpad);
 896                         return encodebin->image_sinkpad;
 897                 } else
 898                         return NULL;
 899         } else {
 900                 if (encodebin->profile == GST_TIZEN_ENCODE_BIN_PROFILE_IMAGE) {
 901                         gst_tizen_encode_bin_init_image_elements(element, NULL); //??
 902
 903                         if(encodebin->image_sinkpad == NULL)
 904                         {
 905                                 pad = gst_element_get_static_pad (encodebin->image_queue, "sink");
 906                                 encodebin->image_sinkpad = gst_ghost_pad_new ("image", pad);
 907                                 gst_object_unref(pad);
 908                                 pad = NULL;
 909                         }
 910                         else
 911                         {
 912                                 GST_WARNING_OBJECT (GST_IS_TIZEN_ENCODE_BIN (element), "encodebin: image pad is aleady existed, return existing image pad\n");
 913                                 return encodebin->image_sinkpad;
 914                         }
 915
 916                         gst_element_add_pad (element, encodebin->image_sinkpad);
 917                         return encodebin->image_sinkpad;
 918                 } else
 919                         return NULL;
 920         }
 921 }
 922
 923 static void
 924 gst_tizen_encode_bin_class_init (GstTizenEncodeBinClass *klass)
 925 {
 926         GObjectClass *gobject_klass;
 927         GstElementClass *gstelement_klass;
 928
 929         gobject_klass = (GObjectClass *) klass;
 930         gstelement_klass = (GstElementClass *) klass;
 931
 932         parent_class = g_type_class_peek_parent (klass);
 933
 934         gobject_klass->get_property = gst_tizen_encode_bin_get_property;
 935         gobject_klass->set_property = gst_tizen_encode_bin_set_property;
 936         gobject_klass->dispose = GST_DEBUG_FUNCPTR (gst_tizen_encode_bin_dispose);
 937         gobject_klass->finalize = GST_DEBUG_FUNCPTR (gst_tizen_encode_bin_finalize);
 938
 939
 940         g_object_class_install_property (gobject_klass, PROP_PROFILE,
 941           g_param_spec_enum ("profile", "PROFILE", "Profile of the media to record",
 942               GST_TYPE_TIZEN_ENCODE_BIN_PROFILE, DEFAULT_PROP_PROFILE,
 943               G_PARAM_READWRITE));
 944
 945         g_object_class_install_property (gobject_klass, PROP_HIGH_SPEED,
 946           g_param_spec_int ("high-speed-fps", "high speed rec. fps", "framerate for high speed recording", 0, G_MAXINT,
 947                 DEFAULT_PROP_HIGH_SPEED, G_PARAM_READWRITE));
 948
 949         g_object_class_install_property (gobject_klass, PROP_VENC_NAME,
 950           g_param_spec_string ("venc-name", "video encoder name", "the name of video encoder to use",
 951               DEFAULT_PROP_VENC_NAME, G_PARAM_READWRITE));
 952
 953         g_object_class_install_property (gobject_klass, PROP_AENC_NAME,
 954           g_param_spec_string ("aenc-name", "audio encoder name", "the name of audio encoder to use",
 955               DEFAULT_PROP_AENC_NAME, G_PARAM_READWRITE));
 956
 957         g_object_class_install_property (gobject_klass, PROP_IENC_NAME,
 958           g_param_spec_string ("ienc-name", "image encoder name", "the name of image encoder to use",
 959               DEFAULT_PROP_IENC_NAME, G_PARAM_READWRITE));
 960
 961         g_object_class_install_property (gobject_klass, PROP_MUX_NAME,
 962           g_param_spec_string ("mux-name", "muxer name", "the name of muxer to use",
 963               DEFAULT_PROP_MUX_NAME, G_PARAM_READWRITE));
 964
 965         g_object_class_install_property (gobject_klass, PROP_VCONV_NAME,
 966           g_param_spec_string ("vconv-name", "Video converter name", "the name of video color converter to use",
 967               DEFAULT_PROP_VCONV_NAME, G_PARAM_READWRITE));
 968
 969         g_object_class_install_property (gobject_klass, PROP_VCAPS,
 970           g_param_spec_boxed ("vcaps", "caps for video","caps for video recording",
 971               GST_TYPE_CAPS, G_PARAM_READWRITE));
 972
 973         g_object_class_install_property (gobject_klass, PROP_ACAPS,
 974           g_param_spec_boxed ("acaps", "caps for audio","caps for audio recording",
 975               GST_TYPE_CAPS, G_PARAM_READWRITE));
 976
 977         g_object_class_install_property (gobject_klass, PROP_ICAPS,
 978           g_param_spec_boxed ("icaps", "caps for image","caps for image stillshot",
 979               GST_TYPE_CAPS, G_PARAM_READWRITE));
 980
 981         g_object_class_install_property (gobject_klass, PROP_AUTO_AUDIO_CONVERT,
 982           g_param_spec_boolean ("auto-audio-convert", "auto audio convert",
 983               "Support for auto audio convert", TRUE, G_PARAM_READWRITE));
 984
 985         g_object_class_install_property (gobject_klass, PROP_AUTO_AUDIO_RESAMPLE,
 986           g_param_spec_boolean ("auto-audio-resample", "auto audio resample",
 987               "Support for auto audio resample", TRUE, G_PARAM_READWRITE));
 988
 989         g_object_class_install_property (gobject_klass, PROP_AUTO_COLORSPACE,
 990           g_param_spec_boolean ("auto-colorspace", "auto colorspace",
 991               "Support for auto colorspace", TRUE, G_PARAM_READWRITE));
 992
 993         g_object_class_install_property (gobject_klass, PROP_BLOCK,
 994           g_param_spec_boolean ("block", "stream block",
 995               "Support for stream block", FALSE, G_PARAM_READWRITE));
 996
 997         g_object_class_install_property (gobject_klass, PROP_PAUSE,
 998           g_param_spec_boolean ("runtime-pause", "recording pause",
 999               "Support for recording pause/resume", FALSE, G_PARAM_READWRITE));
1000
1001 #if 0
1002         g_object_class_install_property (gobject_klass, PROP_VENC_QUEUE,
1003           g_param_spec_boolean ("use-venc-queue", "use queue between venc and mux",
1004               "add queue between venc and mux(only for custom optimization)", FALSE, G_PARAM_READWRITE));
1005
1006         g_object_class_install_property (gobject_klass, PROP_AENC_QUEUE,
1007           g_param_spec_boolean ("use-aenc-queue", "use queue between aenc and mux",
1008               "add queue between aenc and mux(only for custom optimization)", FALSE, G_PARAM_READWRITE));
1009 #else
1010         g_object_class_install_property (gobject_klass, PROP_VENC_QUEUE,
1011           g_param_spec_object ("use-venc-queue", "Video Encoder queue",
1012               "add queue between venc and mux(only for custom optimization)",
1013               GST_TYPE_ELEMENT, G_PARAM_READWRITE));
1014
1015         g_object_class_install_property (gobject_klass, PROP_AENC_QUEUE,
1016           g_param_spec_object ("use-aenc-queue", "Audio Encoder queue",
1017               "add queue between aenc and mux(only for custom optimization)",
1018               GST_TYPE_ELEMENT, G_PARAM_READWRITE));
1019 #endif
1020
1021         g_object_class_install_property (gobject_klass, PROP_VIDEO_ENC,
1022           g_param_spec_object ("video-encode", "Video Encoder",
1023               "the video encoder element to use",
1024               GST_TYPE_ELEMENT, G_PARAM_READWRITE));
1025
1026         g_object_class_install_property (gobject_klass, PROP_AUDIO_ENC,
1027           g_param_spec_object ("audio-encode", "Audio Encoder",
1028               "the audio encoder element to use",
1029               GST_TYPE_ELEMENT, G_PARAM_READWRITE));
1030
1031         g_object_class_install_property (gobject_klass, PROP_IMAGE_ENC,
1032           g_param_spec_object ("image-encode", "Image Encoder",
1033               "the Image encoder element to use",
1034               GST_TYPE_ELEMENT, G_PARAM_READWRITE));
1035
1036         g_object_class_install_property (gobject_klass, PROP_MUX,
1037           g_param_spec_object ("mux", "Muxer",
1038               "the muxer element to use",
1039               GST_TYPE_ELEMENT, G_PARAM_READWRITE));
1040
1041         g_object_class_install_property (gobject_klass, PROP_VIDEO_CONV,
1042           g_param_spec_object ("video-convert", "Video converter",
1043               "the video converter element to use",
1044               GST_TYPE_ELEMENT, G_PARAM_READWRITE));
1045
1046         g_object_class_install_property (gobject_klass, PROP_USE_VIDEO_TOGGLE,
1047                 g_param_spec_boolean ("use-video-toggle", "Use video toggle",
1048                 "Use video toggle while AV recording", TRUE, G_PARAM_READWRITE));
1049
1050 #ifdef TIZEN_FEATURE_TIZEN_ENCODE_BIN_SIGNAL_ENABLE
1051         gst_tizen_encode_bin_signals[SIGNAL_STREAM_BLOCK] =
1052                 g_signal_new ("stream-block", G_TYPE_FROM_CLASS (klass),
1053                 G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstTizenEncodeBinClass, stream_block),
1054                 NULL, NULL, g_cclosure_marshal_VOID__BOOLEAN, G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
1055
1056         gst_tizen_encode_bin_signals[SIGNAL_STREAM_UNBLOCK] =
1057                 g_signal_new ("stream-unblock", G_TYPE_FROM_CLASS (klass),
1058                 G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstTizenEncodeBinClass, stream_unblock),
1059                 NULL, NULL, g_cclosure_marshal_VOID__BOOLEAN, G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
1060
1061         gst_tizen_encode_bin_signals[SIGNAL_STREAM_PAUSE] =
1062                 g_signal_new ("stream-pause", G_TYPE_FROM_CLASS (klass),
1063                 G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstTizenEncodeBinClass, stream_pause),
1064                 NULL, NULL, g_cclosure_marshal_VOID__BOOLEAN, G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
1065
1066         gst_tizen_encode_bin_signals[SIGNAL_STREAM_RESUME] =
1067                 g_signal_new ("stream-resume", G_TYPE_FROM_CLASS (klass),
1068                 G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstTizenEncodeBinClass, stream_resume),
1069                 NULL, NULL, g_cclosure_marshal_VOID__BOOLEAN, G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
1070 #endif
1071
1072         gst_element_class_add_pad_template (gstelement_klass,
1073           gst_static_pad_template_get (&tizen_encode_bin_src_template));
1074         gst_element_class_add_pad_template (gstelement_klass,
1075           gst_static_pad_template_get (&tizen_encode_bin_audio_sink_template));
1076         gst_element_class_add_pad_template (gstelement_klass,
1077           gst_static_pad_template_get (&tizen_encode_bin_video_sink_template));
1078         gst_element_class_add_pad_template (gstelement_klass,
1079           gst_static_pad_template_get (&tizen_encode_bin_image_sink_template));
1080
1081         gst_element_class_set_static_metadata(gstelement_klass, "Samsung Electronics Co. Encoder Bin",
1082                                                          "Generic/Bin/Encoder",
1083                                                          "Autoplug and encode to muxed media",
1084                                                          "Jeonghoon Park <jh1979.park@samsung.com>, Wonhyung Cho <wh01.cho@samsung.com>, Sangho Park <sangho.g.park@samsung.com>");
1085
1086         gstelement_klass->request_new_pad =
1087           GST_DEBUG_FUNCPTR (gst_tizen_encode_bin_request_new_pad);
1088         gstelement_klass->release_pad =
1089           GST_DEBUG_FUNCPTR (gst_tizen_encode_bin_release_pad);
1090         gstelement_klass->change_state =
1091           GST_DEBUG_FUNCPTR (gst_tizen_encode_bin_change_state);
1092 }
1093
1094 static void
1095 gst_tizen_encode_bin_init (GstTizenEncodeBin *encodebin)
1096 {
1097         if (encodebin->srcpad == NULL) {
1098                 encodebin->srcpad = gst_ghost_pad_new_no_target ("src", GST_PAD_SRC);
1099                 gst_element_add_pad (GST_ELEMENT(encodebin), encodebin->srcpad);
1100         }
1101
1102         encodebin->video_sinkpad = NULL;
1103         encodebin->audio_sinkpad = NULL;
1104         encodebin->image_sinkpad = NULL;
1105         encodebin->mux_audio_sinkpad = NULL;
1106         encodebin->mux_video_sinkpad = NULL;
1107
1108         encodebin->profile = DEFAULT_PROP_PROFILE;
1109         encodebin->fps = 0;
1110         encodebin->high_speed_fps = DEFAULT_PROP_HIGH_SPEED;
1111         encodebin->multiple = 1;
1112
1113         encodebin->auto_audio_convert = TRUE;
1114         encodebin->auto_audio_resample = TRUE;
1115         encodebin->auto_color_space = TRUE;
1116         encodebin->block = FALSE;
1117         encodebin->pause= FALSE;
1118         encodebin->use_video_toggle = TRUE;
1119         encodebin->use_venc_queue= FALSE;
1120         encodebin->use_aenc_queue= FALSE;
1121
1122         encodebin->venc_name = g_strdup(DEFAULT_PROP_VENC_NAME);
1123         encodebin->aenc_name = g_strdup(DEFAULT_PROP_AENC_NAME);
1124         encodebin->ienc_name = g_strdup(DEFAULT_PROP_IENC_NAME);
1125         encodebin->mux_name = g_strdup(DEFAULT_PROP_MUX_NAME);
1126         encodebin->vconv_name = g_strdup(DEFAULT_PROP_VCONV_NAME);
1127
1128         encodebin->vcaps = gst_caps_new_any ();
1129         encodebin->acaps = gst_caps_new_any ();
1130         encodebin->icaps = gst_caps_new_any ();
1131
1132         encodebin->audio_queue = NULL;
1133         encodebin->video_queue = NULL;
1134         encodebin->video_encode_queue = NULL;
1135         encodebin->image_queue = NULL;
1136
1137         encodebin->audio_encode = NULL;
1138         encodebin->video_encode = NULL;
1139         encodebin->image_encode = NULL;
1140
1141         encodebin->vcapsfilter = NULL;
1142         encodebin->acapsfilter = NULL;
1143         encodebin->icapsfilter = NULL;
1144
1145         encodebin->video_toggle = NULL;
1146         encodebin->image_toggle = NULL;
1147         encodebin->color_space = NULL;
1148         encodebin->audio_conv = NULL;
1149         encodebin->audio_sample = NULL;
1150
1151         encodebin->mux = NULL;
1152
1153         encodebin->paused_time = 0;
1154         encodebin->total_offset_time = 0;
1155
1156         encodebin->vsink_probeid = 0;
1157         encodebin->vsink_hs_probeid = 0;
1158         encodebin->asink_probeid = 0;
1159         encodebin->veque_sig_id = 0;
1160         encodebin->aeque_sig_id = 0;
1161 }
1162
1163 static void
1164 gst_tizen_encode_bin_dispose (GObject * object)
1165 {
1166         GstTizenEncodeBin *encodebin = GST_TIZEN_ENCODE_BIN (object);
1167
1168         g_free(encodebin->venc_name);
1169         encodebin->venc_name = NULL;
1170
1171         g_free(encodebin->aenc_name);
1172         encodebin->aenc_name = NULL;
1173
1174         g_free(encodebin->ienc_name);
1175         encodebin->ienc_name = NULL;
1176
1177         g_free(encodebin->mux_name);
1178         encodebin->mux_name = NULL;
1179
1180         g_free(encodebin->vconv_name);
1181         encodebin->vconv_name = NULL;
1182
1183         gst_caps_replace (&encodebin->vcaps, NULL);
1184         gst_caps_replace (&encodebin->acaps, NULL);
1185         gst_caps_replace (&encodebin->icaps, NULL);
1186
1187         if (encodebin->srcpad != NULL) {
1188                 gst_element_remove_pad(GST_ELEMENT(encodebin), encodebin->srcpad);
1189                 encodebin->srcpad = NULL;
1190         }
1191
1192         G_OBJECT_CLASS (parent_class)->dispose (object);
1193
1194         encodebin->video_sinkpad = NULL;
1195         encodebin->audio_sinkpad = NULL;
1196         encodebin->image_sinkpad = NULL;
1197         encodebin->mux_audio_sinkpad = NULL;
1198         encodebin->mux_video_sinkpad = NULL;
1199
1200         encodebin->audio_queue = NULL;
1201         encodebin->video_queue = NULL;
1202         encodebin->image_queue = NULL;
1203
1204         encodebin->audio_encode = NULL;
1205         encodebin->video_encode = NULL;
1206         encodebin->video_encode_queue = NULL;
1207         encodebin->image_encode = NULL;
1208
1209         encodebin->vcapsfilter = NULL;
1210         encodebin->acapsfilter = NULL;
1211         encodebin->icapsfilter = NULL;
1212
1213         encodebin->video_toggle = NULL;
1214         encodebin->image_toggle = NULL;
1215         encodebin->color_space = NULL;
1216         encodebin->audio_conv = NULL;
1217         encodebin->audio_sample = NULL;
1218         encodebin->mux = NULL;
1219 }
1220
1221 static void
1222 gst_tizen_encode_bin_finalize (GObject * object)
1223 {
1224         G_OBJECT_CLASS (parent_class)->finalize (object);
1225 }
1226
1227 static GstStateChangeReturn
1228 gst_tizen_encode_bin_change_state (GstElement * element, GstStateChange transition)
1229 {
1230         GstStateChangeReturn ret;
1231         GstTizenEncodeBin *encode_bin;
1232
1233         encode_bin = GST_TIZEN_ENCODE_BIN (element);
1234
1235         switch (transition) {
1236                 case GST_STATE_CHANGE_NULL_TO_READY:
1237                         gst_tizen_encode_bin_link_elements(encode_bin);
1238                         break;
1239                 case GST_STATE_CHANGE_READY_TO_PAUSED:
1240                         /* reset time related values */
1241                         encode_bin->paused_time = 0;
1242                         encode_bin->total_offset_time = 0;
1243                         break;
1244                 case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
1245                         break;
1246                 case GST_STATE_CHANGE_PAUSED_TO_READY:
1247                         break;
1248                 default:
1249                         break;
1250         }
1251
1252         ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
1253
1254         switch (transition) {
1255         case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
1256                 break;
1257         case GST_STATE_CHANGE_PAUSED_TO_READY:
1258                 break;
1259         case GST_STATE_CHANGE_READY_TO_NULL:
1260                 gst_tizen_encode_bin_unlink_elements(encode_bin);
1261                 break;
1262         default:
1263                 break;
1264         }
1265
1266 //  if (ret == GST_STATE_CHANGE_FAILURE)
1267 //    goto done;
1268 //done:
1269         return ret;
1270 }
1271
1272 static void
1273 gst_tizen_encode_bin_release_pad (GstElement * element, GstPad * pad)
1274 {
1275         GstTizenEncodeBin *encodebin = GST_TIZEN_ENCODE_BIN (element);
1276
1277         if(!pad_compare_name(pad, "video")) {
1278 #if 0
1279                 gst_tizen_encode_bin_remove_element(encodebin, encodebin->video_queue);
1280                 encodebin->video_queue = NULL;
1281                 gst_tizen_encode_bin_remove_element(encodebin, encodebin->video_toggle);
1282                 encodebin->video_toggle = NULL;
1283                 gst_tizen_encode_bin_remove_element(encodebin, encodebin->color_space);
1284                 encodebin->color_space = NULL;
1285                 gst_tizen_encode_bin_remove_element(encodebin, encodebin->vcapsfilter);
1286                 encodebin->vcapsfilter = NULL;
1287                 gst_tizen_encode_bin_remove_element(encodebin, encodebin->video_encode_queue);
1288                 encodebin->video_encode_queue =  NULL;
1289                 gst_tizen_encode_bin_remove_element(encodebin, encodebin->video_encode);
1290                 encodebin->video_encode =  NULL;
1291
1292                 gst_element_release_request_pad(encodebin->mux, encodebin->mux_video_sinkpad);
1293                 encodebin->mux_video_sinkpad = NULL;
1294
1295                 if(encodebin->mux_audio_sinkpad == NULL) {
1296                         gst_tizen_encode_bin_remove_element(encodebin, encodebin->mux);
1297                         encodebin->mux = NULL;
1298                 }
1299                 else
1300                 {
1301                         encodebin->mux_audio_sinkpad = NULL;
1302                 }
1303 #endif
1304
1305                 if(encodebin->mux_video_sinkpad != NULL)
1306                 {
1307                         gst_element_release_request_pad(encodebin->mux, encodebin->mux_video_sinkpad);
1308                         encodebin->mux_video_sinkpad = NULL;
1309                 }
1310
1311                 gst_pad_set_active (pad, FALSE); //??
1312                 gst_element_remove_pad(element, pad);
1313                 encodebin->video_sinkpad = NULL;
1314         } else if(!pad_compare_name(pad, "audio")) {
1315 #if 0
1316                 gst_tizen_encode_bin_remove_element(encodebin, encodebin->audio_queue);
1317                 encodebin->audio_queue = NULL;
1318                 gst_tizen_encode_bin_remove_element(encodebin, encodebin->audio_sample);
1319                 encodebin->audio_sample = NULL;
1320                 gst_tizen_encode_bin_remove_element(encodebin, encodebin->audio_conv);
1321                 encodebin->audio_conv = NULL;
1322                 gst_tizen_encode_bin_remove_element(encodebin, encodebin->acapsfilter);
1323                 encodebin->acapsfilter = NULL;
1324                 gst_tizen_encode_bin_remove_element(encodebin, encodebin->audio_encode_queue);
1325                 encodebin->audio_encode_queue =  NULL;
1326                 gst_tizen_encode_bin_remove_element(encodebin, encodebin->audio_encode);
1327                 encodebin->audio_encode = NULL;
1328
1329                 encodebin->mux_audio_sinkpad;
1330                 gst_element_release_request_pad(encodebin->mux, encodebin->mux_audio_sinkpad);
1331
1332                 if(encodebin->mux_video_sinkpad == NULL) {
1333                         gst_tizen_encode_bin_remove_element(encodebin, encodebin->mux);
1334                         encodebin->mux = NULL;
1335                 }
1336                 else
1337                 {
1338                         encodebin->mux_video_sinkpad = NULL;
1339                 }
1340 #endif
1341                 if(encodebin->mux_audio_sinkpad != NULL)
1342                 {
1343                         gst_element_release_request_pad(encodebin->mux, encodebin->mux_audio_sinkpad);
1344 //                      gst_object_unref(encodebin->mux_audio_sinkpad);         //***
1345                         encodebin->mux_audio_sinkpad = NULL;
1346                 }
1347
1348                 gst_pad_set_active (pad, FALSE); //??
1349                 gst_element_remove_pad(element, pad);
1350                 encodebin->audio_sinkpad = NULL;
1351         } else {
1352 #if 0
1353                 gst_tizen_encode_bin_remove_element(encodebin, encodebin->image_queue);
1354                 encodebin->image_queue = NULL;
1355                 gst_tizen_encode_bin_remove_element(encodebin, encodebin->image_toggle);
1356                 encodebin->image_toggle = NULL;
1357                 gst_tizen_encode_bin_remove_element(encodebin, encodebin->color_space);
1358                 encodebin->color_space = NULL;
1359                 gst_tizen_encode_bin_remove_element(encodebin, encodebin->icapsfilter);
1360                 encodebin->icapsfilter = NULL;
1361                 gst_tizen_encode_bin_remove_element(encodebin, encodebin->image_encode);
1362                 encodebin->image_encode = NULL;
1363 #endif
1364                 gst_pad_set_active (pad, FALSE); //??
1365                 gst_element_remove_pad(element, pad);
1366                 encodebin->image_sinkpad = NULL;
1367         }
1368 }
1369
1370 static gint
1371 pad_compare_name (GstPad * pad1, const gchar * name)
1372 {
1373         gint result;
1374
1375         GST_OBJECT_LOCK (pad1);
1376                 result = strcmp (GST_PAD_NAME (pad1), name);
1377         GST_OBJECT_UNLOCK (pad1);
1378
1379         return result;
1380 }
1381
1382 static gboolean
1383 gst_tizen_encode_bin_add_element_by_name (GstTizenEncodeBin *encodebin, GstTizenEncodeBinElement type, const gchar *name)
1384 {
1385         switch(type) {
1386                 case TIZEN_ENCODEBIN_ELEMENT_VENC:
1387                         encodebin->video_encode = gst_element_factory_make (name, "video_encode");
1388                         if(encodebin->video_encode != NULL) {
1389                                 gst_bin_add(GST_BIN(encodebin), encodebin->video_encode);
1390                                 g_free(encodebin->venc_name);
1391                                 encodebin->venc_name = NULL;
1392                         } else {
1393                                 goto element_make_fail;
1394                         }
1395                         break;
1396                 case TIZEN_ENCODEBIN_ELEMENT_AENC:
1397                         encodebin->audio_encode = gst_element_factory_make (name, "audio_encode");
1398                         if(encodebin->audio_encode != NULL) {
1399                                 gst_bin_add(GST_BIN(encodebin), encodebin->audio_encode);
1400                                 g_free(encodebin->aenc_name);
1401                                 encodebin->aenc_name = NULL;
1402                         } else {
1403                                 goto element_make_fail;
1404                         }
1405                         break;
1406                 case TIZEN_ENCODEBIN_ELEMENT_IENC:
1407                         encodebin->image_encode = gst_element_factory_make (name, "image_encode");
1408                         if(encodebin->image_encode != NULL) {
1409                                 gst_bin_add(GST_BIN(encodebin), encodebin->image_encode);
1410                                 g_free(encodebin->ienc_name);
1411                                 encodebin->ienc_name = NULL;
1412                         } else {
1413                                 goto element_make_fail;
1414                         }
1415                         break;
1416                 case TIZEN_ENCODEBIN_ELEMENT_MUX:
1417                         encodebin->mux = gst_element_factory_make (name, "mux");
1418                         if(encodebin->mux != NULL) {
1419                                 gst_bin_add(GST_BIN(encodebin), encodebin->mux);
1420                                 g_free(encodebin->mux_name);
1421                                 encodebin->mux_name = NULL;
1422                         } else {
1423                                 goto element_make_fail;
1424                         }
1425                         break;
1426                 case TIZEN_ENCODEBIN_ELEMENT_VIDEO_CONV:
1427                         encodebin->color_space = gst_element_factory_make(name, "video_convert");
1428                         if (encodebin->color_space != NULL) {
1429                                 gst_bin_add(GST_BIN(encodebin), encodebin->color_space);
1430                                 g_free(encodebin->vconv_name);
1431                                 encodebin->vconv_name = NULL;
1432                         } else {
1433                                 goto element_make_fail;
1434                         }
1435                         break;
1436                 default:
1437                         GST_WARNING_OBJECT(encodebin, "Invalid element type = %d", type);
1438                         break;
1439         }
1440
1441         return TRUE;
1442
1443 element_make_fail:
1444         GST_WARNING_OBJECT(encodebin, "no such element factory \"%s\"!", name);
1445         return FALSE;
1446 }
1447
1448
1449 static gboolean
1450 gst_tizen_encode_bin_remove_element (GstTizenEncodeBin *encodebin, GstElement * element)
1451 {
1452         GstObject *parent;
1453         gchar *ename = NULL;
1454         GST_INFO_OBJECT (encodebin, "gst_tizen_encode_bin_remove_element");
1455
1456         if (element == NULL) {
1457                 GST_INFO_OBJECT (encodebin, "element is already NULL");
1458                 return TRUE;
1459         }
1460
1461         gst_element_set_state (element, GST_STATE_NULL);
1462         parent = gst_element_get_parent (element);
1463
1464         if (parent != NULL) {
1465                 if(!gst_bin_remove (GST_BIN_CAST (parent), element)) {
1466                         gst_object_unref (parent);
1467                         ename = gst_element_get_name (element);
1468                         GST_ERROR_OBJECT (encodebin, "gst_tizen_encode_bin_remove_element() [%s] remove fail", ename);
1469                         g_free (ename);
1470                         return FALSE;
1471                 } else {
1472                         gst_object_unref(parent);
1473                 }
1474         } else {
1475                 gst_object_unref(element);
1476         }
1477
1478         return TRUE;
1479 }
1480
1481 static gboolean
1482 gst_tizen_encode_bin_link_elements (GstTizenEncodeBin *encodebin)  // need to return ????
1483 {
1484         GstPad *srcpad = NULL, *sinkpad = NULL;
1485         switch(encodebin->profile) {
1486                 case GST_TIZEN_ENCODE_BIN_PROFILE_AV :
1487                         if (!gst_caps_is_any(encodebin->vcaps)) {
1488                                 gchar *caps_str = NULL;
1489                                 caps_str = gst_caps_to_string(encodebin->vcaps);
1490                                 if (caps_str) {
1491                                         GST_INFO_OBJECT(encodebin, "vconv caps [%s]", caps_str);
1492                                         g_free(caps_str);
1493                                         caps_str = NULL;
1494                                 }
1495
1496                                 g_object_set(encodebin->vcapsfilter, "caps", encodebin->vcaps, NULL);
1497                         }
1498
1499                         if (encodebin->auto_color_space) {
1500                                 if(encodebin->color_space == NULL) {
1501                                         encodebin->color_space = gst_element_factory_make (encodebin->vconv_name, "video_convert");
1502                                         gst_bin_add (GST_BIN (encodebin), encodebin->color_space);
1503                                 }
1504
1505                                 srcpad = gst_element_get_static_pad(encodebin->video_queue, "src");
1506                                 if( encodebin->video_toggle )
1507                                 {
1508                                         sinkpad = gst_element_get_static_pad(encodebin->video_toggle, "sink");
1509                                         _GST_PAD_LINK_UNREF(srcpad, sinkpad, video_link_fail);
1510
1511                                         srcpad = gst_element_get_static_pad(encodebin->video_toggle, "src");
1512                                 }
1513                                 sinkpad = gst_element_get_static_pad(encodebin->color_space, "sink");
1514                                 _GST_PAD_LINK_UNREF(srcpad, sinkpad, video_link_fail);
1515
1516                                 srcpad = gst_element_get_static_pad(encodebin->color_space, "src");
1517                                 sinkpad = gst_element_get_static_pad(encodebin->vcapsfilter, "sink");
1518                                 _GST_PAD_LINK_UNREF(srcpad, sinkpad, video_link_fail);
1519
1520                                 srcpad = gst_element_get_static_pad(encodebin->vcapsfilter, "src");
1521                                 sinkpad = gst_element_get_static_pad(encodebin->video_encode, "sink");
1522                                 _GST_PAD_LINK_UNREF(srcpad, sinkpad, video_link_fail);
1523 #if 0
1524                                 if(encodebin->use_venc_queue)
1525                                 {
1526                                         if(encodebin->video_encode_queue == NULL) {
1527                                             encodebin->video_encode_queue  = gst_element_factory_make ("queue","video_encode_queue");
1528                                             gst_bin_add (GST_BIN (encodebin), encodebin->video_encode_queue);
1529
1530               ENCODER_QUEUE_SET(encodebin->video_encode_queue, 0, 0, VIDEO_ENC_QUE_TIME);
1531               encodebin->veque_sig_id = g_signal_connect( G_OBJECT(encodebin->video_encode_queue), "overrun",
1532                                G_CALLBACK(queue_overun_cb), encodebin);
1533
1534                                         }
1535
1536                                         srcpad = gst_element_get_static_pad(encodebin->video_encode, "src");
1537                                         sinkpad = gst_element_get_static_pad(encodebin->video_encode_queue, "sink");
1538                                         _GST_PAD_LINK_UNREF(srcpad, sinkpad, video_link_fail);
1539                                 }
1540 #else
1541                                 if(encodebin->video_encode_queue)
1542                                 {
1543                                     ENCODER_QUEUE_SET(encodebin->video_encode_queue, 0, 0, VIDEO_ENC_QUE_TIME);
1544                                     encodebin->veque_sig_id = g_signal_connect( G_OBJECT(encodebin->video_encode_queue), "overrun",
1545                                                                                                                                 G_CALLBACK(queue_overun_cb), encodebin);
1546 #if 0
1547                                     g_object_set(G_OBJECT(encodebin->video_queue),
1548                                                 "max-size-bytes", (guint)0,
1549                                                 "max-size-buffers", (guint)1,
1550                                                 "max-size-time", (guint64)0,
1551                                                 NULL);
1552 #endif
1553                                         srcpad = gst_element_get_static_pad(encodebin->video_encode, "src");
1554                                         sinkpad = gst_element_get_static_pad(encodebin->video_encode_queue, "sink");
1555                                         _GST_PAD_LINK_UNREF(srcpad, sinkpad, video_link_fail);
1556                                 }
1557 #endif
1558
1559                         }
1560                         else {
1561                                 srcpad = gst_element_get_static_pad(encodebin->video_queue, "src");
1562                                 if( encodebin->video_toggle )
1563                                 {
1564                                         sinkpad = gst_element_get_static_pad(encodebin->video_toggle, "sink");
1565                                         _GST_PAD_LINK_UNREF(srcpad, sinkpad, video_link_fail);
1566
1567                                         srcpad = gst_element_get_static_pad(encodebin->video_toggle, "src");
1568                                 }
1569                                 sinkpad = gst_element_get_static_pad(encodebin->vcapsfilter, "sink");
1570                                 _GST_PAD_LINK_UNREF(srcpad, sinkpad, video_link_fail);
1571
1572                                 srcpad = gst_element_get_static_pad(encodebin->vcapsfilter, "src");
1573                                 sinkpad = gst_element_get_static_pad(encodebin->video_encode, "sink");
1574                                 _GST_PAD_LINK_UNREF(srcpad, sinkpad, video_link_fail);
1575  #if 0
1576                                 if(encodebin->use_venc_queue)
1577                                 {
1578                                         if(encodebin->video_encode_queue == NULL) {
1579                                             encodebin->video_encode_queue  = gst_element_factory_make ("queue","video_encode_queue");
1580                                             gst_bin_add (GST_BIN (encodebin), encodebin->video_encode_queue);
1581
1582                                             ENCODER_QUEUE_SET(encodebin->video_encode_queue, 0, 0, VIDEO_ENC_QUE_TIME);
1583                                             encodebin->veque_sig_id = g_signal_connect( G_OBJECT(encodebin->video_encode_queue), "overrun",
1584                                                                                                                                 G_CALLBACK(queue_overun_cb), encodebin);
1585                                         }
1586
1587                                         srcpad = gst_element_get_static_pad(encodebin->video_encode, "src");
1588                                         sinkpad = gst_element_get_static_pad(encodebin->video_encode_queue, "sink");
1589                                         _GST_PAD_LINK_UNREF(srcpad, sinkpad, video_link_fail);
1590
1591                                 }
1592 #else
1593                                 if(encodebin->video_encode_queue)
1594                                 {
1595                                     ENCODER_QUEUE_SET(encodebin->video_encode_queue, 0, 0, VIDEO_ENC_QUE_TIME);
1596                                     encodebin->veque_sig_id = g_signal_connect( G_OBJECT(encodebin->video_encode_queue), "overrun",
1597                                                                                                                                 G_CALLBACK(queue_overun_cb), encodebin);
1598 #if 0
1599                                     g_object_set(G_OBJECT(encodebin->video_queue),
1600                                                 "max-size-bytes", (guint)0,
1601                                                 "max-size-buffers", (guint)1,
1602                                                 "max-size-time", (guint64)0,
1603                                                 NULL);
1604 #endif
1605
1606                                         srcpad = gst_element_get_static_pad(encodebin->video_encode, "src");
1607                                         sinkpad = gst_element_get_static_pad(encodebin->video_encode_queue, "sink");
1608                                         _GST_PAD_LINK_UNREF(srcpad, sinkpad, video_link_fail);
1609                                 }
1610 #endif
1611
1612                         }
1613
1614 //                      gst_element_get_request_pad (encodebin->mux, "video_%d");
1615 #if 0
1616                         if(encodebin->use_venc_queue)
1617                         {
1618                                 srcpad = gst_element_get_static_pad(encodebin->video_encode_queue, "src");
1619                                 sinkpad = encodebin->mux_video_sinkpad = gst_tizen_encode_bin_get_mux_sink_pad(encodebin->mux, TIZEN_ENCODEBIN_MUX_VIDEO_SINK);
1620                                 _GST_PAD_LINK_UNREF(srcpad, sinkpad, video_link_fail);
1621                         }
1622 #else
1623                         if(encodebin->video_encode_queue)
1624                         {
1625                                 srcpad = gst_element_get_static_pad(encodebin->video_encode_queue, "src");
1626                                 sinkpad = encodebin->mux_video_sinkpad = gst_tizen_encode_bin_get_mux_sink_pad(encodebin->mux, TIZEN_ENCODEBIN_MUX_VIDEO_SINK);
1627                                 _GST_PAD_LINK_UNREF(srcpad, sinkpad, video_link_fail);
1628                         }
1629 #endif
1630                         else
1631                         {
1632                                 srcpad = gst_element_get_static_pad(encodebin->video_encode, "src");
1633                                 sinkpad = encodebin->mux_video_sinkpad = gst_tizen_encode_bin_get_mux_sink_pad(encodebin->mux, TIZEN_ENCODEBIN_MUX_VIDEO_SINK);
1634                                 _GST_PAD_LINK_UNREF(srcpad, sinkpad, video_link_fail);
1635                         }
1636
1637                         srcpad = gst_element_get_static_pad(encodebin->mux, "src");
1638                         if(gst_ghost_pad_get_target(GST_GHOST_PAD (encodebin->srcpad)) != srcpad)
1639                                 gst_ghost_pad_set_target(GST_GHOST_PAD (encodebin->srcpad), srcpad);
1640                         gst_object_unref(srcpad);
1641                         srcpad = NULL;
1642
1643                         /* For pause/resume control */
1644 //                      encodebin->vsink_probeid = gst_pad_add_data_probe (gst_element_get_static_pad (encodebin->video_queue, "sink"),
1645                         sinkpad = gst_element_get_static_pad (encodebin->video_queue, "sink");
1646                         encodebin->vsink_probeid = gst_pad_add_probe(sinkpad, GST_PAD_PROBE_TYPE_BUFFER, (GstPadProbeCallback)gst_tizen_encode_bin_video_probe, encodebin, NULL);
1647                         gst_object_unref(sinkpad);
1648                         sinkpad = NULL;
1649
1650                         if(encodebin->high_speed_fps > DEFAULT_PROP_HIGH_SPEED)
1651                         {
1652 //                              encodebin->vsink_hs_probeid = gst_pad_add_data_probe (gst_element_get_static_pad (encodebin->video_encode, "sink"),
1653                                 sinkpad = gst_element_get_static_pad (encodebin->video_encode, "sink");
1654                                 encodebin->vsink_hs_probeid = gst_pad_add_probe (sinkpad, GST_PAD_PROBE_TYPE_BUFFER, (GstPadProbeCallback)gst_tizen_encode_bin_video_probe_hs, encodebin, NULL);
1655                                 gst_object_unref(sinkpad);
1656                                 sinkpad = NULL;
1657                         }
1658
1659                         if(encodebin->audio_queue == NULL)
1660                         {
1661                                 GST_WARNING_OBJECT(encodebin, "Audio pad isn't requested, recording video only mode");
1662                                 break;
1663                         }
1664                 case GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO :
1665                         if(!gst_caps_is_any(encodebin->acaps))
1666                         {
1667                                 g_object_set(encodebin->acapsfilter, "caps", encodebin->acaps, NULL);
1668                         }
1669                         if (encodebin->auto_audio_convert ||encodebin->auto_audio_resample) {
1670                                 if (!encodebin->auto_audio_convert) {
1671                                         if(encodebin->audio_sample == NULL) {
1672                                                 encodebin->audio_sample = gst_element_factory_make ("audioresample","audio_sample");
1673                                                gst_bin_add (GST_BIN (encodebin), encodebin->audio_sample);
1674                                         }
1675                                         srcpad = gst_element_get_static_pad(encodebin->audio_queue, "src");
1676                                         sinkpad = gst_element_get_static_pad(encodebin->audio_sample, "sink");
1677                                         _GST_PAD_LINK_UNREF(srcpad, sinkpad, audio_link_fail);
1678
1679                                         srcpad = gst_element_get_static_pad(encodebin->audio_sample, "src");
1680                                         sinkpad = gst_element_get_static_pad(encodebin->acapsfilter, "sink");
1681                                         _GST_PAD_LINK_UNREF(srcpad, sinkpad, audio_link_fail);
1682
1683                                         srcpad = gst_element_get_static_pad(encodebin->acapsfilter, "src");
1684                                         sinkpad = gst_element_get_static_pad(encodebin->audio_encode, "sink");
1685                                         _GST_PAD_LINK_UNREF(srcpad, sinkpad, audio_link_fail);
1686 #if 0
1687                                         if(encodebin->use_aenc_queue)
1688                                         {
1689                                                 if(encodebin->audio_encode_queue == NULL) {
1690                                                     encodebin->audio_encode_queue  = gst_element_factory_make ("queue","audio_encode_queue");
1691                                                     gst_bin_add (GST_BIN (encodebin), encodebin->audio_encode_queue);
1692
1693                 ENCODER_QUEUE_SET(encodebin->audio_encode_queue, 0, 0, AUDIO_ENC_QUE_TIME);
1694                 encodebin->aeque_sig_id = g_signal_connect( G_OBJECT(encodebin->audio_encode_queue), "overrun",
1695                               G_CALLBACK(queue_overun_cb), encodebin);
1696                                                 }
1697
1698                                                 srcpad = gst_element_get_static_pad(encodebin->audio_encode, "src");
1699                                                 sinkpad = gst_element_get_static_pad(encodebin->audio_encode_queue, "sink");
1700                                                 _GST_PAD_LINK_UNREF(srcpad, sinkpad, audio_link_fail);
1701                                         }
1702 #else
1703                                         if(encodebin->audio_encode_queue)
1704                                         {
1705
1706                                                 ENCODER_QUEUE_SET(encodebin->audio_encode_queue, 0, 0, AUDIO_ENC_QUE_TIME);
1707                                                 encodebin->aeque_sig_id = g_signal_connect( G_OBJECT(encodebin->audio_encode_queue), "overrun",
1708                                                                                                                         G_CALLBACK(queue_overun_cb), encodebin);
1709
1710                                                 srcpad = gst_element_get_static_pad(encodebin->audio_encode, "src");
1711                                                 sinkpad = gst_element_get_static_pad(encodebin->audio_encode_queue, "sink");
1712                                                 _GST_PAD_LINK_UNREF(srcpad, sinkpad, audio_link_fail);
1713                                         }
1714 #endif
1715
1716                                 } else if (!encodebin->auto_audio_resample) {
1717                                           if (encodebin->audio_conv == NULL) {
1718                                                 encodebin->audio_conv = gst_element_factory_make ("audioconvert","audio_conv");
1719                                               gst_bin_add (GST_BIN (encodebin), encodebin->audio_conv);
1720                                            }
1721
1722                                         srcpad = gst_element_get_static_pad(encodebin->audio_queue, "src");
1723                                         sinkpad = gst_element_get_static_pad(encodebin->audio_conv, "sink");
1724                                         _GST_PAD_LINK_UNREF(srcpad, sinkpad, audio_link_fail);
1725
1726                                         srcpad = gst_element_get_static_pad(encodebin->audio_conv, "src");
1727                                         sinkpad = gst_element_get_static_pad(encodebin->acapsfilter, "sink");
1728                                         _GST_PAD_LINK_UNREF(srcpad, sinkpad, audio_link_fail);
1729
1730                                         srcpad = gst_element_get_static_pad(encodebin->acapsfilter, "src");
1731                                         sinkpad = gst_element_get_static_pad(encodebin->audio_encode, "sink");
1732                                         _GST_PAD_LINK_UNREF(srcpad, sinkpad, audio_link_fail);
1733 #if 0
1734                                         if(encodebin->use_aenc_queue)
1735                                         {
1736                                                 if(encodebin->audio_encode_queue == NULL) {
1737                                                     encodebin->audio_encode_queue  = gst_element_factory_make ("queue","audio_encode_queue");
1738                                                     gst_bin_add (GST_BIN (encodebin), encodebin->audio_encode_queue);
1739
1740                 ENCODER_QUEUE_SET(encodebin->audio_encode_queue, 0, 0, AUDIO_ENC_QUE_TIME);
1741                 encodebin->aeque_sig_id = g_signal_connect( G_OBJECT(encodebin->audio_encode_queue), "overrun",
1742                              G_CALLBACK(queue_overun_cb), encodebin);
1743             }
1744
1745                                                 srcpad = gst_element_get_static_pad(encodebin->audio_encode, "src");
1746                                                 sinkpad = gst_element_get_static_pad(encodebin->audio_encode_queue, "sink");
1747                                                 _GST_PAD_LINK_UNREF(srcpad, sinkpad, audio_link_fail);
1748
1749                                         }
1750 #else
1751                                         if(encodebin->audio_encode_queue)
1752                                         {
1753
1754                                                 ENCODER_QUEUE_SET(encodebin->audio_encode_queue, 0, 0, AUDIO_ENC_QUE_TIME);
1755                                                 encodebin->aeque_sig_id = g_signal_connect( G_OBJECT(encodebin->audio_encode_queue), "overrun",
1756                                                                                                                         G_CALLBACK(queue_overun_cb), encodebin);
1757
1758                                                 srcpad = gst_element_get_static_pad(encodebin->audio_encode, "src");
1759                                                 sinkpad = gst_element_get_static_pad(encodebin->audio_encode_queue, "sink");
1760                                                 _GST_PAD_LINK_UNREF(srcpad, sinkpad, audio_link_fail);
1761                                         }
1762 #endif
1763
1764                                 } else {
1765                                         if(encodebin->audio_sample == NULL) {
1766                                                 encodebin->audio_sample = gst_element_factory_make ("audioresample","audio_sample");
1767                                                gst_bin_add (GST_BIN (encodebin), encodebin->audio_sample);
1768                                         }
1769                                         if (encodebin->audio_conv == NULL) {
1770                                                 encodebin->audio_conv = gst_element_factory_make ("audioconvert","audio_conv");
1771                                               gst_bin_add (GST_BIN (encodebin), encodebin->audio_conv);
1772                                         }
1773
1774                                         srcpad = gst_element_get_static_pad(encodebin->audio_queue, "src");
1775                                         sinkpad = gst_element_get_static_pad(encodebin->audio_conv, "sink");
1776                                         _GST_PAD_LINK_UNREF(srcpad, sinkpad, audio_link_fail);
1777
1778                                         srcpad = gst_element_get_static_pad(encodebin->audio_conv, "src");
1779                                         sinkpad = gst_element_get_static_pad(encodebin->audio_sample, "sink");
1780                                         _GST_PAD_LINK_UNREF(srcpad, sinkpad, audio_link_fail);
1781
1782                                         srcpad = gst_element_get_static_pad(encodebin->audio_sample, "src");
1783                                         sinkpad = gst_element_get_static_pad(encodebin->acapsfilter, "sink");
1784                                         _GST_PAD_LINK_UNREF(srcpad, sinkpad, audio_link_fail);
1785
1786                                         srcpad = gst_element_get_static_pad(encodebin->acapsfilter, "src");
1787                                         sinkpad = gst_element_get_static_pad(encodebin->audio_encode, "sink");
1788                                         _GST_PAD_LINK_UNREF(srcpad, sinkpad, audio_link_fail);
1789 #if 0
1790                                         if(encodebin->use_aenc_queue)
1791                                         {
1792                                                 if(encodebin->audio_encode_queue == NULL) {
1793                                                     encodebin->audio_encode_queue  = gst_element_factory_make ("queue","audio_encode_queue");
1794                                                     gst_bin_add (GST_BIN (encodebin), encodebin->audio_encode_queue);
1795
1796                 ENCODER_QUEUE_SET(encodebin->audio_encode_queue, 0, 0, AUDIO_ENC_QUE_TIME);
1797                 encodebin->aeque_sig_id = g_signal_connect( G_OBJECT(encodebin->audio_encode_queue), "overrun",
1798                               G_CALLBACK(queue_overun_cb), encodebin);
1799                                                 }
1800
1801                                                 srcpad = gst_element_get_static_pad(encodebin->audio_encode, "src");
1802                                                 sinkpad = gst_element_get_static_pad(encodebin->audio_encode_queue, "sink");
1803                                                 _GST_PAD_LINK_UNREF(srcpad, sinkpad, audio_link_fail);
1804
1805                                         }
1806 #else
1807                                         if(encodebin->audio_encode_queue)
1808                                         {
1809
1810                                                 ENCODER_QUEUE_SET(encodebin->audio_encode_queue, 0, 0, AUDIO_ENC_QUE_TIME);
1811                                                 encodebin->aeque_sig_id = g_signal_connect( G_OBJECT(encodebin->audio_encode_queue), "overrun",
1812                                                                                                                         G_CALLBACK(queue_overun_cb), encodebin);
1813
1814                                                 srcpad = gst_element_get_static_pad(encodebin->audio_encode, "src");
1815                                                 sinkpad = gst_element_get_static_pad(encodebin->audio_encode_queue, "sink");
1816                                                 _GST_PAD_LINK_UNREF(srcpad, sinkpad, audio_link_fail);
1817                                         }
1818 #endif
1819
1820                                 }
1821                         }else {
1822
1823                                 srcpad = gst_element_get_static_pad(encodebin->audio_queue, "src");
1824                                 sinkpad = gst_element_get_static_pad(encodebin->acapsfilter, "sink");
1825                                 _GST_PAD_LINK_UNREF(srcpad, sinkpad, audio_link_fail);
1826
1827                                 srcpad = gst_element_get_static_pad(encodebin->acapsfilter, "src");
1828                                 sinkpad = gst_element_get_static_pad(encodebin->audio_encode, "sink");
1829                                 _GST_PAD_LINK_UNREF(srcpad, sinkpad, audio_link_fail);
1830 #if 0
1831                                 if(encodebin->use_aenc_queue)
1832                                 {
1833                                         if(encodebin->audio_encode_queue == NULL) {
1834                                             encodebin->audio_encode_queue  = gst_element_factory_make ("queue","audio_encode_queue");
1835                                             gst_bin_add (GST_BIN (encodebin), encodebin->audio_encode_queue);
1836
1837                                             ENCODER_QUEUE_SET(encodebin->audio_encode_queue, 0, 0, AUDIO_ENC_QUE_TIME);
1838               encodebin->aeque_sig_id = g_signal_connect( G_OBJECT(encodebin->audio_encode_queue), "overrun",
1839                              G_CALLBACK(queue_overun_cb), encodebin);
1840                                         }
1841
1842                                         srcpad = gst_element_get_static_pad(encodebin->audio_encode, "src");
1843                                         sinkpad = gst_element_get_static_pad(encodebin->audio_encode_queue, "sink");
1844                                         _GST_PAD_LINK_UNREF(srcpad, sinkpad, audio_link_fail);
1845                                 }
1846 #else
1847                                         if(encodebin->audio_encode_queue)
1848                                         {
1849
1850                                                 ENCODER_QUEUE_SET(encodebin->audio_encode_queue, 0, 0, AUDIO_ENC_QUE_TIME);
1851                                                 encodebin->aeque_sig_id = g_signal_connect( G_OBJECT(encodebin->audio_encode_queue), "overrun",
1852                                                                                                                         G_CALLBACK(queue_overun_cb), encodebin);
1853
1854                                                 srcpad = gst_element_get_static_pad(encodebin->audio_encode, "src");
1855                                                 sinkpad = gst_element_get_static_pad(encodebin->audio_encode_queue, "sink");
1856                                                 _GST_PAD_LINK_UNREF(srcpad, sinkpad, audio_link_fail);
1857                                         }
1858 #endif
1859
1860                         }
1861 #if 0
1862                         if(encodebin->use_aenc_queue)
1863                         {
1864                                 srcpad = gst_element_get_static_pad(encodebin->audio_encode_queue, "src");
1865                                 sinkpad = encodebin->mux_audio_sinkpad = gst_tizen_encode_bin_get_mux_sink_pad(encodebin->mux, TIZEN_ENCODEBIN_MUX_AUDIO_SINK);
1866                                 _GST_PAD_LINK_UNREF(srcpad, sinkpad, audio_link_fail);
1867
1868                         }
1869 #else
1870
1871                         if(encodebin->audio_encode_queue)
1872                         {
1873                                 srcpad = gst_element_get_static_pad(encodebin->audio_encode_queue, "src");
1874                                 sinkpad = encodebin->mux_audio_sinkpad = gst_tizen_encode_bin_get_mux_sink_pad(encodebin->mux, TIZEN_ENCODEBIN_MUX_AUDIO_SINK);
1875                                 _GST_PAD_LINK_UNREF(srcpad, sinkpad, audio_link_fail);
1876
1877                         }
1878 #endif
1879                         else
1880                         {
1881                                 srcpad = gst_element_get_static_pad(encodebin->audio_encode, "src");
1882                                 sinkpad = encodebin->mux_audio_sinkpad = gst_tizen_encode_bin_get_mux_sink_pad(encodebin->mux, TIZEN_ENCODEBIN_MUX_AUDIO_SINK);
1883                                 _GST_PAD_LINK_UNREF(srcpad, sinkpad, audio_link_fail);
1884
1885                         }
1886
1887                         srcpad = gst_element_get_static_pad(encodebin->mux, "src");
1888                         if(gst_ghost_pad_get_target(GST_GHOST_PAD (encodebin->srcpad)) != srcpad)
1889                                 gst_ghost_pad_set_target(GST_GHOST_PAD (encodebin->srcpad), srcpad);
1890                         gst_object_unref(srcpad);
1891                         srcpad = NULL;
1892
1893                         /* For pause/resume control */
1894                         sinkpad = gst_element_get_static_pad (encodebin->audio_queue, "sink");
1895                         encodebin->asink_probeid = gst_pad_add_probe (sinkpad, GST_PAD_PROBE_TYPE_BUFFER, (GstPadProbeCallback)gst_tizen_encode_bin_audio_probe, encodebin, NULL);
1896                         gst_object_unref(sinkpad);
1897                         sinkpad = NULL;
1898
1899                         break;
1900                 case GST_TIZEN_ENCODE_BIN_PROFILE_IMAGE :
1901                         if(!gst_caps_is_any(encodebin->icaps))
1902                         {
1903                                 g_object_set(encodebin->icapsfilter, "caps", encodebin->icaps, NULL);
1904                         }
1905
1906                         if (encodebin->auto_color_space) {
1907                                 if(encodebin->color_space == NULL) {
1908                                     encodebin->color_space  = gst_element_factory_make ("videoconvert","color_space");
1909                                     gst_bin_add (GST_BIN (encodebin), encodebin->color_space);
1910                                 }
1911
1912                                 srcpad = gst_element_get_static_pad(encodebin->image_queue, "src");
1913                                 sinkpad = gst_element_get_static_pad(encodebin->image_toggle, "sink");
1914                                 _GST_PAD_LINK_UNREF(srcpad, sinkpad, image_link_fail);
1915
1916                                 srcpad = gst_element_get_static_pad(encodebin->image_toggle, "src");
1917                                 sinkpad = gst_element_get_static_pad(encodebin->color_space, "sink");
1918                                 _GST_PAD_LINK_UNREF(srcpad, sinkpad, image_link_fail);
1919
1920                                 srcpad = gst_element_get_static_pad(encodebin->color_space, "src");
1921                                 sinkpad = gst_element_get_static_pad(encodebin->icapsfilter, "sink");
1922                                 _GST_PAD_LINK_UNREF(srcpad, sinkpad, image_link_fail);
1923
1924                                 srcpad = gst_element_get_static_pad(encodebin->icapsfilter, "src");
1925                                 sinkpad = gst_element_get_static_pad(encodebin->image_encode, "sink");
1926                                 _GST_PAD_LINK_UNREF(srcpad, sinkpad, image_link_fail);
1927
1928                         }
1929                         else {
1930
1931                                 srcpad = gst_element_get_static_pad(encodebin->image_queue, "src");
1932                                 sinkpad = gst_element_get_static_pad(encodebin->image_toggle, "sink");
1933                                 _GST_PAD_LINK_UNREF(srcpad, sinkpad, image_link_fail);
1934
1935                                 srcpad = gst_element_get_static_pad(encodebin->image_toggle, "src");
1936                                 sinkpad = gst_element_get_static_pad(encodebin->icapsfilter, "sink");
1937                                 _GST_PAD_LINK_UNREF(srcpad, sinkpad, image_link_fail);
1938
1939                                 srcpad = gst_element_get_static_pad(encodebin->icapsfilter, "src");
1940                                 sinkpad = gst_element_get_static_pad(encodebin->image_encode, "sink");
1941                                 _GST_PAD_LINK_UNREF(srcpad, sinkpad, image_link_fail);
1942
1943                         }
1944                         srcpad =  gst_element_get_static_pad (encodebin->image_encode, "src");
1945                         if(gst_ghost_pad_get_target(GST_GHOST_PAD (encodebin->srcpad)) != srcpad)
1946                                 gst_ghost_pad_set_target(GST_GHOST_PAD (encodebin->srcpad), srcpad);
1947                         gst_object_unref(srcpad);
1948                         srcpad = NULL;
1949                         break;
1950                 default:
1951                       GST_WARNING_OBJECT(encodebin, "Invalid profile number = %d", encodebin->profile);
1952                       return FALSE;
1953                       break;
1954         }
1955 //      gst_pad_set_active(encodebin->srcpad, TRUE);
1956         return TRUE;
1957
1958 video_link_fail:
1959         // remove elements
1960         gst_tizen_encode_bin_remove_element(encodebin, encodebin->color_space);
1961         GST_WARNING_OBJECT(encodebin, "encodebin link video elements fail");
1962         return FALSE;
1963
1964 audio_link_fail:
1965         // remove element
1966         gst_tizen_encode_bin_remove_element(encodebin, encodebin->audio_conv);
1967         gst_tizen_encode_bin_remove_element(encodebin, encodebin->audio_sample);
1968         GST_WARNING_OBJECT(encodebin, "encodebin link audio elements fail");
1969         return FALSE;
1970
1971 image_link_fail:
1972         // remove element
1973         gst_tizen_encode_bin_remove_element(encodebin, encodebin->color_space);
1974         GST_WARNING_OBJECT(encodebin, "encodebin link image elements fail");
1975         return FALSE;
1976
1977
1978 }
1979
1980 static gboolean
1981 gst_tizen_encode_bin_unlink_elements (GstTizenEncodeBin *encodebin)
1982 {
1983         GstPad *pad = NULL;
1984
1985         switch(encodebin->profile) {
1986                 case GST_TIZEN_ENCODE_BIN_PROFILE_AV :
1987                         if (encodebin->auto_color_space) {
1988                                 if (encodebin->video_toggle) {
1989                                         gst_element_unlink_many(
1990                                                 encodebin->video_queue,
1991                                                 encodebin->video_toggle,
1992                                                 encodebin->color_space,
1993                                                 encodebin->vcapsfilter,
1994                                                 encodebin->video_encode,
1995                                                 //encodebin->video_encode_queue,
1996                                                 NULL);
1997                                 } else {
1998                                         gst_element_unlink_many(
1999                                                 encodebin->video_queue,
2000                                                 encodebin->color_space,
2001                                                 encodebin->vcapsfilter,
2002                                                 encodebin->video_encode,
2003                                                 //encodebin->video_encode_queue,
2004                                                 NULL);
2005                                 }
2006                         } else {
2007                                 if (encodebin->video_toggle) {
2008                                         gst_element_unlink_many(
2009                                                 encodebin->video_queue,
2010                                                 encodebin->video_toggle,
2011                                                 encodebin->vcapsfilter,
2012                                                 encodebin->video_encode,
2013                                                 //encodebin->video_encode_queue,
2014                                                 NULL);
2015                                 } else {
2016                                         gst_element_unlink_many(
2017                                                 encodebin->video_queue,
2018                                                 encodebin->vcapsfilter,
2019                                                 encodebin->video_encode,
2020                                                 //encodebin->video_encode_queue,
2021                                                 NULL);
2022                                 }
2023                         }
2024
2025                         if(encodebin->mux_video_sinkpad != NULL)
2026                         {
2027                                 if(encodebin->video_encode_queue)
2028                                 {
2029                                         gst_element_unlink(encodebin->video_encode, encodebin->video_encode_queue);
2030
2031                                         pad = gst_element_get_static_pad (encodebin->video_encode_queue, "src");
2032                                         gst_pad_unlink(pad, encodebin->mux_video_sinkpad);
2033                                         gst_object_unref(pad);
2034                                         pad = NULL;
2035
2036                                         if ( g_signal_handler_is_connected ( encodebin->video_encode_queue, encodebin->veque_sig_id) )
2037                                         {
2038                                                 g_signal_handler_disconnect (  encodebin->video_encode_queue, encodebin->veque_sig_id );
2039                                         }
2040                                 }
2041                                 else
2042                                 {
2043                                         pad = gst_element_get_static_pad (encodebin->video_encode, "src");
2044                                         gst_pad_unlink(pad, encodebin->mux_video_sinkpad);
2045                                         gst_object_unref(pad);
2046                                         pad = NULL;
2047                                 }
2048
2049                                 gst_element_release_request_pad(encodebin->mux, encodebin->mux_video_sinkpad);
2050 //                              gst_object_unref(encodebin->mux_video_sinkpad); //***
2051                                 encodebin->mux_video_sinkpad = NULL;
2052                         }
2053
2054                         if(encodebin->vsink_probeid)
2055                         {
2056                                 pad = gst_element_get_static_pad (encodebin->video_queue, "sink");
2057                                 gst_pad_remove_probe(pad, encodebin->vsink_probeid);
2058                                 encodebin->vsink_probeid = 0;
2059                                 gst_object_unref(pad);
2060                                 pad = NULL;
2061                         }
2062
2063
2064                         if(encodebin->vsink_hs_probeid)
2065                         {
2066                                 pad = gst_element_get_static_pad (encodebin->video_encode, "sink");
2067                                 gst_pad_remove_probe(pad, encodebin->vsink_hs_probeid);
2068                                 encodebin->vsink_hs_probeid = 0;
2069                                 gst_object_unref(pad);
2070                                 pad = NULL;
2071                         }
2072
2073                         if(encodebin->audio_queue == NULL)
2074                         {
2075                                 break;
2076                         }
2077                 case GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO :
2078                         if (encodebin->auto_audio_convert ||encodebin->auto_audio_resample) {
2079                                 if (!encodebin->auto_audio_convert) {
2080                                                 gst_element_unlink_many  (
2081                                                         encodebin->audio_queue,
2082                                                         encodebin->audio_sample,
2083                                                         encodebin->acapsfilter,
2084                                                         encodebin->audio_encode,
2085                                                         NULL);
2086                                 } else if (!encodebin->auto_audio_resample) {
2087                                                 gst_element_unlink_many  (
2088                                                         encodebin->audio_queue,
2089                                                         encodebin->audio_conv,
2090                                                         encodebin->acapsfilter,
2091                                                         encodebin->audio_encode,
2092                                                         NULL);
2093                                 } else {
2094                                                 gst_element_unlink_many  (
2095                                                         encodebin->audio_queue,
2096                                                         encodebin->audio_conv,
2097                                                         encodebin->audio_sample,
2098                                                         encodebin->acapsfilter,
2099                                                         encodebin->audio_encode,
2100                                                         NULL);
2101                                 }
2102                         }
2103                         else {
2104                                 gst_element_unlink_many  (
2105                                         encodebin->audio_queue,
2106                                         encodebin->acapsfilter,
2107                                         encodebin->audio_encode,
2108                                         NULL);
2109                         }
2110
2111                         if(encodebin->mux_audio_sinkpad != NULL)
2112                         {
2113 #if 0
2114                                 if(encodebin->use_aenc_queue)
2115                                 {
2116                                         gst_element_unlink(encodebin->audio_encode, encodebin->audio_encode_queue);
2117
2118                                         pad = gst_element_get_static_pad (encodebin->audio_encode_queue, "src");
2119                                         gst_pad_unlink(pad, muxpad);
2120                                         gst_object_unref(pad);
2121                                         pad = NULL;
2122
2123                                         if ( g_signal_handler_is_connected ( encodebin->audio_encode_queue, encodebin->veque_sig_id) )
2124                                         {
2125                                                 g_signal_handler_disconnect (  encodebin->audio_encode_queue, encodebin->veque_sig_id );
2126                                         }
2127                                 }
2128 #else
2129                                 if(encodebin->audio_encode_queue)
2130                                 {
2131                                         gst_element_unlink(encodebin->audio_encode, encodebin->audio_encode_queue);
2132
2133                                         pad = gst_element_get_static_pad (encodebin->audio_encode_queue, "src");
2134                                         gst_pad_unlink(pad, encodebin->mux_audio_sinkpad);
2135                                         gst_object_unref(pad);
2136                                         pad = NULL;
2137
2138                                         if ( g_signal_handler_is_connected ( encodebin->audio_encode_queue, encodebin->veque_sig_id) )
2139                                         {
2140                                                 g_signal_handler_disconnect (  encodebin->audio_encode_queue, encodebin->veque_sig_id );
2141                                         }
2142                                 }
2143 #endif
2144                                 else
2145                                 {
2146                                         pad = gst_element_get_static_pad (encodebin->audio_encode, "src");
2147                                         gst_pad_unlink(pad, encodebin->mux_audio_sinkpad);
2148                                         gst_object_unref(pad);
2149                                         pad = NULL;
2150                                 }
2151
2152                                 gst_element_release_request_pad(encodebin->mux, encodebin->mux_audio_sinkpad);
2153 //                              gst_object_unref(encodebin->mux_audio_sinkpad);         //***
2154                                 encodebin->mux_audio_sinkpad = NULL;
2155                         }
2156
2157                         if(encodebin->asink_probeid)
2158                         {
2159                                 pad = gst_element_get_static_pad (encodebin->audio_queue, "sink");
2160                                 gst_pad_remove_probe(pad, encodebin->asink_probeid);
2161                                 encodebin->asink_probeid =0;
2162                                 gst_object_unref(pad);
2163                                 pad = NULL;
2164                         }
2165
2166                         break;
2167                 case GST_TIZEN_ENCODE_BIN_PROFILE_IMAGE :
2168                         if (encodebin->auto_color_space) {
2169                                 gst_element_unlink_many  (
2170                                         encodebin->image_queue,
2171                                         encodebin->image_toggle,
2172                                         encodebin->color_space,
2173                                         encodebin->icapsfilter,
2174                                         encodebin->image_encode,
2175                                         NULL);
2176                         }
2177                         else {
2178                                 gst_element_unlink_many  (
2179                                         encodebin->image_queue,
2180                                         encodebin->image_toggle,
2181                                         encodebin->icapsfilter,
2182                                         encodebin->image_encode,
2183                                         NULL);
2184                         }
2185                         break;
2186                 default:
2187                           GST_WARNING_OBJECT(encodebin, "Invalid profile number = %d", encodebin->profile);
2188                           return FALSE;
2189                   break;
2190         }
2191         //      gst_pad_set_active(encodebin->srcpad, TRUE);
2192         return TRUE;
2193
2194 }
2195
2196 static gboolean
2197 gst_tizen_encode_bin_init_video_elements (GstElement *element, gpointer user_data)
2198 {
2199         GstTizenEncodeBin *encodebin = GST_TIZEN_ENCODE_BIN (element);
2200
2201         if(encodebin->profile != GST_TIZEN_ENCODE_BIN_PROFILE_AV)
2202                 return FALSE;
2203
2204         if(encodebin->video_queue == NULL) {
2205                 encodebin->video_queue = gst_element_factory_make ("queue","video_queue");
2206                 gst_bin_add (GST_BIN (element), encodebin->video_queue);
2207         }
2208
2209         if( encodebin->use_video_toggle )
2210         {
2211                 if( encodebin->video_toggle == NULL )
2212                 {
2213                         encodebin->video_toggle = gst_element_factory_make ("toggle","video_toggle");
2214                         gst_bin_add (GST_BIN (element), encodebin->video_toggle);
2215                 }
2216                 GST_INFO_OBJECT( encodebin, "Video toggle is Enabled" );
2217         }
2218         else
2219         {
2220                 GST_INFO_OBJECT( encodebin, "Video toggle is Disabled" );
2221         }
2222
2223         if(encodebin->vcapsfilter == NULL) {
2224                 encodebin->vcapsfilter = gst_element_factory_make ("capsfilter","vcapsfilter");
2225                 gst_bin_add (GST_BIN (element), encodebin->vcapsfilter);
2226         }
2227 #if 0
2228         encodebin->vcaps = gst_caps_new_simple("video/x-raw",
2229                 "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('I', '4', '2', '0'),
2230                 "width", G_TYPE_INT, 320,
2231                 "height", G_TYPE_INT, 240,
2232                 "framerate", GST_TYPE_FRACTION, 30, 1,
2233                 NULL);
2234
2235 #endif
2236         if(encodebin->video_encode == NULL) {
2237                 encodebin->video_encode = gst_element_factory_make (encodebin->venc_name, "video_encode");
2238                 gst_bin_add (GST_BIN (element), encodebin->video_encode);
2239         }
2240
2241 #if 0
2242         if(encodebin->video_encode_queue == NULL) {
2243                 encodebin->video_encode_queue = gst_element_factory_make ("queue", "video_encode_queue");
2244                 gst_bin_add (GST_BIN (element), encodebin->video_encode_queue);
2245         }
2246
2247         g_object_set(G_OBJECT(encodebin->video_encode_queue), "max-size-bytes", (unsigned int)0, NULL);
2248 #endif
2249
2250         if(encodebin->mux == NULL) {
2251                 encodebin->mux = gst_element_factory_make (encodebin->mux_name, "mux");
2252                 gst_bin_add (GST_BIN (element), encodebin->mux);
2253         }
2254
2255         if (!encodebin->video_encode
2256 //              || !encodebin->video_encode_queue
2257                 || !encodebin->mux
2258                 || !encodebin->video_queue
2259                 || !encodebin->vcapsfilter
2260                 || !encodebin->srcpad )
2261         {
2262                 GST_ERROR_OBJECT(encodebin, "Faild create element \n");
2263                 return FALSE;
2264         }
2265
2266         if( encodebin->use_video_toggle && !encodebin->video_toggle )
2267         {
2268                 GST_ERROR_OBJECT(encodebin, "Faild create video toggle element \n");
2269                 return FALSE;
2270         }
2271
2272 #if 0
2273   if (encodebin->auto_color_space && (encodebin->color_space == NULL)) {
2274       encodebin->color_space = gst_element_factory_make ("videoconvert","color_space");
2275       gst_bin_add (GST_BIN (element), encodebin->color_space);
2276    }
2277 #endif
2278   return TRUE;
2279 }
2280
2281 static gboolean
2282 gst_tizen_encode_bin_init_audio_elements (GstElement *element, gpointer user_data)
2283 {
2284         GstTizenEncodeBin *encodebin = GST_TIZEN_ENCODE_BIN (element);
2285
2286         if(encodebin->profile > GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO)
2287                 return FALSE;
2288
2289         if(encodebin->audio_queue == NULL) {
2290                 encodebin->audio_queue = gst_element_factory_make ("queue","audio_queue");
2291                 gst_bin_add (GST_BIN (element), encodebin->audio_queue);
2292         }
2293
2294         if(encodebin->acapsfilter == NULL) {
2295                 encodebin->acapsfilter = gst_element_factory_make ("capsfilter","acapsfilter");
2296                 gst_bin_add (GST_BIN (element), encodebin->acapsfilter);
2297         }
2298 #if 0
2299 encodebin->acaps = gst_caps_new_simple("audio/x-raw",
2300         "rate", G_TYPE_INT, 8000,
2301         "channels", G_TYPE_INT, 2,
2302         "depth", G_TYPE_INT, 16,
2303         NULL);
2304 #endif
2305
2306         if(encodebin->audio_encode == NULL) {
2307                 encodebin->audio_encode = gst_element_factory_make (encodebin->aenc_name, "audio_encode");
2308                 gst_bin_add (GST_BIN (element), encodebin->audio_encode);
2309         }
2310
2311         if(encodebin->mux == NULL) {
2312                 encodebin->mux = gst_element_factory_make (encodebin->mux_name, "mux");
2313                 gst_bin_add (GST_BIN (element), encodebin->mux);
2314         }
2315
2316         if (!encodebin->audio_encode
2317                 || !encodebin->audio_queue
2318                 || !encodebin->mux
2319                 || !encodebin->acapsfilter
2320                 || !encodebin->srcpad )
2321         {
2322                 GST_ERROR_OBJECT(encodebin, "Faild create element \n");
2323                 return FALSE;
2324         }
2325 #if 0
2326         if (encodebin->auto_audio_convert && (encodebin->audio_conv == NULL)) {
2327                 encodebin->audio_conv = gst_element_factory_make ("audioconvert","audio_conv");
2328                 gst_bin_add (GST_BIN (element), encodebin->audio_conv);
2329         }
2330
2331         if (encodebin->auto_audio_resample && (encodebin->audio_sample == NULL)) {
2332                 encodebin->audio_sample = gst_element_factory_make ("audioresample","audio_sample");
2333                 gst_bin_add (GST_BIN (element), encodebin->audio_sample);
2334         }
2335 #endif
2336         return TRUE;
2337 }
2338
2339
2340 static gboolean
2341 gst_tizen_encode_bin_init_image_elements (GstElement *element, gpointer user_data)
2342 {
2343         GstTizenEncodeBin *encodebin = GST_TIZEN_ENCODE_BIN (element);
2344
2345         if(encodebin->profile < GST_TIZEN_ENCODE_BIN_PROFILE_IMAGE)
2346                 return FALSE;
2347
2348         if(encodebin->image_queue == NULL) {
2349                 encodebin->image_queue = gst_element_factory_make ("queue","image_queue");
2350                 gst_bin_add (GST_BIN (element), encodebin->image_queue);
2351         }
2352
2353         if(encodebin->image_toggle == NULL) {
2354                 encodebin->image_toggle = gst_element_factory_make ("toggle","image_toggle");
2355                 gst_bin_add (GST_BIN (element), encodebin->image_toggle);
2356         }
2357
2358         if(encodebin->icapsfilter == NULL) {
2359                 encodebin->icapsfilter = gst_element_factory_make ("capsfilter","icapsfilter");
2360                 gst_bin_add (GST_BIN (element), encodebin->icapsfilter);
2361         }
2362
2363         if(encodebin->image_encode == NULL) {
2364                 encodebin->image_encode = gst_element_factory_make (encodebin->ienc_name, "image_encode");
2365                 gst_bin_add (GST_BIN (element), encodebin->image_encode);
2366         }
2367
2368         if (!encodebin->image_encode
2369                 || !encodebin->image_queue
2370                 || !encodebin->image_toggle
2371                 || !encodebin->icapsfilter
2372                 || !encodebin->srcpad )
2373         {
2374                 GST_ERROR_OBJECT(encodebin, "Faild create element \n");
2375                 return FALSE;
2376         }
2377 #if 0
2378         if (encodebin->auto_color_space && (encodebin->color_space == NULL)) {
2379                 encodebin->color_space = gst_element_factory_make ("videoconvert","color_space");
2380                 gst_bin_add (GST_BIN (element), encodebin->color_space);
2381         }
2382 #endif
2383         return TRUE;
2384 }
2385
2386 static gboolean gst_tizen_encode_bin_block(GstTizenEncodeBin *encodebin, gboolean value)
2387 {
2388
2389         if(value) { //block stream
2390                 switch(encodebin->profile) {
2391                         case GST_TIZEN_ENCODE_BIN_PROFILE_AV:
2392                                 if(encodebin->audio_queue == NULL && encodebin->video_queue == NULL) {
2393                                         goto block_fail;
2394                                 } else {
2395                                         if(g_object_class_find_property(G_OBJECT_GET_CLASS(GST_OBJECT(encodebin->video_queue)),
2396                                                 "empty-buffers") == NULL) {
2397                                                 GST_ERROR_OBJECT(encodebin, "The queue element doesn't support 'empty-buffers' property");
2398                                                 goto block_fail;
2399                                         }
2400                                         if( encodebin->video_toggle )
2401                                         {
2402                                                 g_object_set(encodebin->video_toggle, "block-data", TRUE , NULL);
2403                                                 GST_INFO_OBJECT( encodebin, "video_toggle block-data TRUE" );
2404                                         }
2405
2406                                         g_object_set(encodebin->video_queue, "empty-buffers", TRUE , NULL);
2407                                         GST_INFO_OBJECT( encodebin, "video_queue empty-buffers TRUE" );
2408                                         if(encodebin->audio_queue != NULL)
2409                                         {
2410                                                 g_object_set(encodebin->audio_queue, "empty-buffers", TRUE , NULL);
2411                                                 GST_INFO_OBJECT( encodebin, "audio_queue empty-buffers TRUE" );
2412                                         }
2413                                 }
2414                                 break;
2415                         case GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO:
2416                                 if(encodebin->audio_queue == NULL) {
2417                                         goto block_fail;
2418                                 } else {
2419                                         if(g_object_class_find_property(G_OBJECT_GET_CLASS(GST_OBJECT(encodebin->audio_queue)),
2420                                                 "empty-buffers") == NULL) {
2421                                                 GST_ERROR_OBJECT(encodebin, "The queue element doesn't support 'empty-buffers' property");
2422                                                 goto block_fail;
2423                                         }
2424                                         g_object_set(encodebin->audio_queue, "empty-buffers", TRUE , NULL);
2425                                         GST_INFO_OBJECT( encodebin, "audio_queue empty-buffers TRUE" );
2426                                 }
2427                                 break;
2428                         case GST_TIZEN_ENCODE_BIN_PROFILE_IMAGE:
2429                                 if(encodebin->image_toggle == NULL) {
2430                                         goto block_fail;
2431                                 } else {
2432                                         g_object_set(encodebin->image_toggle, "block_data", TRUE, NULL);
2433                                         GST_INFO_OBJECT( encodebin, "image_toggle block_data TRUE" );
2434                                 }
2435                                 break;
2436                         default:
2437                                 GST_WARNING_OBJECT (encodebin,"Invalid profile number = %d", encodebin->profile);
2438                                 goto block_fail;
2439                                 break;
2440                 }
2441         } else { //release blocked-stream
2442                 switch(encodebin->profile) {
2443                         case GST_TIZEN_ENCODE_BIN_PROFILE_AV:
2444                                 if(encodebin->audio_queue == NULL && encodebin->video_queue == NULL) {
2445                                         goto unblock_fail;
2446                                 } else {
2447                                         if(g_object_class_find_property(G_OBJECT_GET_CLASS(GST_OBJECT(encodebin->video_queue)),
2448                                                 "empty-buffers") == NULL) {
2449                                                 GST_ERROR_OBJECT(encodebin, "The queue element doesn't support 'empty-buffers' property");
2450                                                 goto unblock_fail;
2451                                         }
2452                                         if( encodebin->video_toggle )
2453                                         {
2454                                                 g_object_set(encodebin->video_toggle, "block-data", FALSE , NULL);
2455                                                 GST_INFO_OBJECT( encodebin, "video_toggle block-data FALSE" );
2456                                         }
2457
2458                                         if(encodebin->audio_queue != NULL)
2459                                         {
2460                                                 g_object_set(encodebin->audio_queue, "empty-buffers", FALSE , NULL);
2461                                                 GST_INFO_OBJECT( encodebin, "audio_queue empty-buffers FALSE" );
2462                                         }
2463                                         g_object_set(encodebin->video_queue, "empty-buffers", FALSE , NULL);
2464                                         GST_INFO_OBJECT( encodebin, "video_queue empty-buffers FALSE" );
2465                                 }
2466                                 break;
2467                         case GST_TIZEN_ENCODE_BIN_PROFILE_AUDIO:
2468                                 if(encodebin->audio_queue == NULL) {
2469                                         goto unblock_fail;
2470                                 } else {
2471                                         if(g_object_class_find_property(G_OBJECT_GET_CLASS(GST_OBJECT(encodebin->audio_queue)),
2472                                                 "empty-buffers") == NULL) {
2473                                                 GST_ERROR_OBJECT(encodebin, "The queue element doesn't support 'empty-buffers' property");
2474                                                 goto unblock_fail;
2475                                         }
2476                                         g_object_set(encodebin->audio_queue, "empty-buffers", FALSE , NULL);
2477                                         GST_INFO_OBJECT( encodebin, "audio_queue empty-buffers FALSE" );
2478                                 }
2479                                 break;
2480                         case GST_TIZEN_ENCODE_BIN_PROFILE_IMAGE:
2481                                 if(encodebin->image_toggle == NULL) {
2482                                         goto unblock_fail;
2483                                 } else {
2484                                         g_object_set(encodebin->image_toggle, "block_data", FALSE, NULL);
2485                                         GST_INFO_OBJECT( encodebin, "image_toggle block_data FALSE" );
2486                                 }
2487                                 break;
2488                         default:
2489                                 GST_WARNING_OBJECT (encodebin,"Invalid profile number = %d", encodebin->profile);
2490                                 goto unblock_fail;
2491                                 break;
2492                 }
2493         }
2494         encodebin->block = value;
2495         return TRUE;
2496
2497 block_fail:
2498         GST_ERROR_OBJECT(encodebin, "encodebin block failed");
2499         return FALSE;
2500
2501 unblock_fail:
2502         GST_ERROR_OBJECT(encodebin, "encodebin unblock failed");
2503         return FALSE;
2504 }
2505
2506 static gboolean gst_tizen_encode_bin_pause(GstTizenEncodeBin *encodebin, gboolean value)
2507 {
2508         GstClock *clock = NULL;
2509
2510         if(value) {
2511                 /* pause stream*/
2512                 //Block src of encode bin
2513                 if (!gst_tizen_encode_bin_block(encodebin, TRUE))
2514                 {
2515                         GST_WARNING_OBJECT (encodebin, "Fail to block Encodebin.");
2516                         goto pause_fail;
2517                 }
2518
2519                 if (encodebin->paused_time == 0)
2520                 {
2521                         //get steam time
2522                         clock = GST_ELEMENT_CLOCK(encodebin);
2523                         if (clock)              //before PLAYING, this would be NULL. Need to check.
2524                         {
2525                                 GstClockTime current_time, base_time;
2526
2527                                 current_time = gst_clock_get_time(clock);
2528                                 base_time = gst_element_get_base_time(GST_ELEMENT(encodebin));
2529
2530                                 encodebin->paused_time = current_time - base_time;
2531
2532                                 GST_INFO_OBJECT (encodebin, "Encodebin is in running-pause at [%"GST_TIME_FORMAT"]."
2533                                         , GST_TIME_ARGS(encodebin->paused_time));
2534                         }
2535                         else
2536                         {
2537                                 encodebin->paused_time = 0;
2538                                 encodebin->total_offset_time = 0;
2539
2540                                 GST_WARNING_OBJECT (encodebin, "There is no clock in Encodebin.");
2541                         }
2542                 }
2543 #if 0 //def TIZEN_FEATURE_TIZEN_ENCODE_BIN_SIGNAL_ENABLE
2544                 g_signal_emit (G_OBJECT (encodebin), gst_tizen_encode_bin_signals[SIGNAL_STREAM_PAUSE], 0, TRUE);
2545 #endif
2546         }
2547         else {
2548                 /* release paused-stream*/
2549                 if (encodebin->paused_time != 0)
2550                 {
2551                         clock = GST_ELEMENT_CLOCK(encodebin);
2552                         if (clock)
2553                         {
2554                                 GstClockTime current_time, base_time;
2555                                 GstClockTime paused_gap;
2556
2557                                 current_time = gst_clock_get_time(clock);
2558                                 base_time = gst_element_get_base_time(GST_ELEMENT(encodebin));
2559                                 paused_gap = current_time - base_time - encodebin->paused_time;
2560
2561                                 encodebin->total_offset_time += paused_gap;
2562                                 encodebin->paused_time = 0;
2563
2564                                 GST_INFO_OBJECT (encodebin, "Encodebin now resumes. Offset delay [%"GST_TIME_FORMAT"], Total offset delay [%"GST_TIME_FORMAT"]"
2565                                         , GST_TIME_ARGS(paused_gap) , GST_TIME_ARGS(encodebin->total_offset_time));
2566                         }
2567                         else
2568                         {
2569                                 encodebin->paused_time = 0;
2570                                 encodebin->total_offset_time = 0;
2571
2572                                 GST_WARNING_OBJECT (encodebin, "There is no clock in Encodebin.");
2573                         }
2574                 }
2575
2576                 //TODO : How about qos?
2577
2578                 //Unblock src of encode bin
2579                 if (!gst_tizen_encode_bin_block(encodebin, FALSE))
2580                 {
2581                         GST_WARNING_OBJECT (encodebin, "Fail to Unblock Encodebin.");
2582                         goto resume_fail;
2583                 }
2584 #if 0 //def TIZEN_FEATURE_TIZEN_ENCODE_BIN_SIGNAL_ENABLE
2585                 g_signal_emit (G_OBJECT (encodebin), gst_tizen_encode_bin_signals[SIGNAL_STREAM_RESUME], 0, TRUE);
2586 #endif
2587         }
2588         encodebin->pause = value;
2589         return TRUE;
2590
2591 pause_fail:
2592         GST_WARNING_OBJECT (encodebin, "Fail to pause Encodebin");
2593 #ifdef TIZEN_FEATURE_TIZEN_ENCODE_BIN_SIGNAL_ENABLE
2594                 g_signal_emit (G_OBJECT (encodebin), gst_tizen_encode_bin_signals[SIGNAL_STREAM_PAUSE], 0, FALSE);
2595 #endif
2596         return FALSE;
2597
2598 resume_fail:
2599         GST_WARNING_OBJECT (encodebin, "Fail to resume Encodebin");
2600 #ifdef TIZEN_FEATURE_TIZEN_ENCODE_BIN_SIGNAL_ENABLE
2601                 g_signal_emit (G_OBJECT (encodebin), gst_tizen_encode_bin_signals[SIGNAL_STREAM_RESUME], 0, FALSE);
2602 #endif
2603         return FALSE;
2604 }
2605
2606 static GstPadProbeReturn
2607 gst_tizen_encode_bin_video_probe(GstPad *pad, GstPadProbeInfo *info, GstTizenEncodeBin *encodebin)
2608 {
2609         if (!encodebin)
2610         {
2611                 GST_WARNING_OBJECT (encodebin, "encodebin is Null.");
2612                 return GST_PAD_PROBE_OK;
2613         }
2614
2615         //Adjusting timestamp of video source
2616         GST_BUFFER_PTS(gst_pad_probe_info_get_buffer(info)) -= encodebin->total_offset_time;
2617         GST_BUFFER_DTS(gst_pad_probe_info_get_buffer(info)) = GST_BUFFER_PTS(gst_pad_probe_info_get_buffer(info));
2618
2619         return GST_PAD_PROBE_OK;
2620 }
2621
2622 static GstPadProbeReturn
2623 gst_tizen_encode_bin_video_probe_hs(GstPad *pad, GstPadProbeInfo *info, GstTizenEncodeBin *encodebin)
2624 {
2625         if (!encodebin)
2626         {
2627                 GST_WARNING_OBJECT (encodebin, "encodebin is Null.");
2628                 return GST_PAD_PROBE_OK;
2629         }
2630
2631         GST_BUFFER_PTS(gst_pad_probe_info_get_buffer(info)) *= encodebin->multiple;
2632         GST_BUFFER_DTS(gst_pad_probe_info_get_buffer(info)) = GST_BUFFER_PTS(gst_pad_probe_info_get_buffer(info));
2633
2634         return GST_PAD_PROBE_OK;
2635 }
2636
2637 static GstPadProbeReturn
2638 gst_tizen_encode_bin_audio_probe(GstPad *pad, GstPadProbeInfo *info, GstTizenEncodeBin *encodebin)
2639 {
2640         if (!encodebin)
2641         {
2642                 GST_WARNING_OBJECT (encodebin, "encodebin is Null.");
2643                 return GST_PAD_PROBE_OK;
2644         }
2645
2646         //Adjusting timestamp of video source
2647         GST_BUFFER_PTS(gst_pad_probe_info_get_buffer(info)) -= encodebin->total_offset_time;
2648         GST_BUFFER_DTS(gst_pad_probe_info_get_buffer(info)) = GST_BUFFER_PTS(gst_pad_probe_info_get_buffer(info));
2649
2650         return GST_PAD_PROBE_OK;
2651 }
2652
2653 static GstPad*
2654 gst_tizen_encode_bin_get_mux_sink_pad(GstElement *mux, GstTizenEncodeBinMuxSinkPad type)
2655 {
2656         GstElementClass *elemclass = NULL;
2657         GList *walk = NULL;
2658         GstPad *pad = NULL;
2659
2660         elemclass = GST_ELEMENT_GET_CLASS (mux);
2661
2662         walk = gst_element_class_get_pad_template_list (elemclass);
2663
2664         while (walk) {
2665                 GstPadTemplate *templ;
2666
2667                 templ = (GstPadTemplate *) walk->data;
2668                 if (GST_PAD_TEMPLATE_DIRECTION (templ) == GST_PAD_SINK) {
2669                         /* ENHANCE ME: Please add other specific mux's case */
2670                         if (((type == TIZEN_ENCODEBIN_MUX_AUDIO_SINK) && strstr(GST_PAD_TEMPLATE_NAME_TEMPLATE (templ), "audio")) ||    //audio, audio_%d,... ex)ffmux_3gp
2671                                 ((type == TIZEN_ENCODEBIN_MUX_VIDEO_SINK) && strstr(GST_PAD_TEMPLATE_NAME_TEMPLATE (templ), "video")) ||        //video, video_%d,... ex)ffmux_3gp
2672                                 strstr(GST_PAD_TEMPLATE_NAME_TEMPLATE (templ), "sink")  //sink, sink_%d, wavparse_sink, ... ex)oggmux, wavparse
2673                         ) {
2674                                 g_print("PRINT TEMPLATE(%s)\n", GST_PAD_TEMPLATE_NAME_TEMPLATE (templ));
2675                                 pad = gst_element_get_request_pad (mux, GST_PAD_TEMPLATE_NAME_TEMPLATE (templ));
2676                                 break;
2677                         }
2678                 }
2679                 walk = g_list_next (walk);
2680         }
2681
2682         return pad;
2683 }
2684
2685 static gboolean
2686 plugin_init (GstPlugin * plugin)
2687 {
2688   GST_DEBUG_CATEGORY_INIT (gst_tizen_encode_bin_debug, "tizenencodebin", 0, "Tizen encodebin");
2689
2690 #ifdef ENABLE_NLS
2691   GST_DEBUG ("binding text domain %s to locale dir %s", GETTEXT_PACKAGE,
2692       LOCALEDIR);
2693   bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
2694 #endif /* ENABLE_NLS */
2695
2696   return gst_element_register (plugin, "tizenencodebin", GST_RANK_NONE,
2697       GST_TYPE_TIZEN_ENCODE_BIN);
2698 }
2699
2700 GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
2701     GST_VERSION_MINOR,
2702     tizenencodebin,
2703     "Tizen encodebin plugin",
2704     plugin_init, VERSION, "LGPL", "Samsung Electronics Co", "http://www.samsung.com/")