| LOCAL FUNCTION PROTOTYPES: |\r
---------------------------------------------------------------------------*/\r
static gboolean __mmplayer_video_capture_probe (GstPad *pad, GstBuffer *buffer, gpointer u_data);\r
-static int __mmplayer_get_video_frame_from_buffer(mm_player_t* player, GstBuffer *buffer);\r
+//static int __mmplayer_get_video_frame_from_buffer(mm_player_t* player, GstBuffer *buffer);\r
static gpointer __mmplayer_capture_thread(gpointer data);\r
static void __csc_tiled_to_linear_crop(unsigned char *yuv420_dest, unsigned char *nv12t_src, int yuv420_width, int yuv420_height, int left, int top, int right, int buttom);\r
static int __tile_4x2_read(int x_size, int y_size, int x_pos, int y_pos);\r
GstBuffer *buf = NULL;\r
g_object_get(player->pipeline->videobin[MMPLAYER_V_SINK].gst, "last-buffer", &buf, NULL);\r
\r
+\r
if (buf)\r
{\r
- ret = __mmplayer_get_video_frame_from_buffer(player, buf);\r
+ //ret = __mmplayer_get_video_frame_from_buffer(player, buf);\r
gst_buffer_unref(buf);\r
}\r
return ret;\r
pad = gst_element_get_static_pad(player->pipeline->videobin[MMPLAYER_V_SINK].gst, "sink" );\r
\r
/* register probe */\r
+#ifndef GST_API_VERSION_1\r
player->video_capture_cb_probe_id = gst_pad_add_buffer_probe (pad,\r
G_CALLBACK (__mmplayer_video_capture_probe), player);\r
+#else\r
+ player->video_capture_cb_probe_id = gst_pad_add_probe (pad, GST_PAD_PROBE_TYPE_BUFFER,\r
+ __mmplayer_video_capture_probe, player, NULL);\r
+#endif\r
\r
gst_object_unref(GST_OBJECT(pad));\r
pad = NULL;\r
-\r
debug_fleave();\r
\r
return ret;\r
/**\r
* The output is fixed as RGB888\r
*/\r
+#if 0\r
+#ifdef GST_API_VERSION_1\r
static int\r
__mmplayer_get_video_frame_from_buffer(mm_player_t* player, GstBuffer *buffer)\r
{\r
if (gst_structure_has_name(structure, "video/x-raw-yuv"))\r
{\r
gst_structure_get_fourcc (structure, "format", &fourcc);\r
-\r
switch(fourcc)\r
{\r
/* NV12T */\r
if ( !proved || !proved->a[0] || !proved->a[1] )\r
return MM_ERROR_PLAYER_INTERNAL;\r
\r
+ yplane_size = (proved->s[0] * proved->e[0]);\r
+ uvplane_size = (proved->s[1] * proved->e[1]);\r
+\r
+ memset(&player->captured, 0x00, sizeof(MMPlayerMPlaneImage));\r
+ memcpy(&player->captured, proved, sizeof(MMPlayerMPlaneImage));\r
+\r
+ player->captured.a[0] = g_try_malloc(yplane_size);\r
+ if ( !player->captured.a[0] )\r
+ return MM_ERROR_SOUND_NO_FREE_SPACE;\r
+\r
+ player->captured.a[1] = g_try_malloc(uvplane_size);\r
+ if ( !player->captured.a[1] )\r
+ return MM_ERROR_SOUND_NO_FREE_SPACE;\r
+\r
+ memcpy(player->captured.a[0], proved->a[0], yplane_size);\r
+ memcpy(player->captured.a[1], proved->a[1], uvplane_size);\r
+ goto DONE;\r
+ }\r
+ break;\r
+\r
+ case GST_MAKE_FOURCC ('I', '4', '2', '0'):\r
+ {\r
+ src_fmt = MM_UTIL_IMG_FMT_I420;\r
+ }\r
+ break;\r
+\r
+ default:\r
+ {\r
+ goto UNKNOWN;\r
+ }\r
+ break;\r
+ }\r
+ }\r
+ else if (gst_structure_has_name(structure, "video/x-raw-rgb"))\r
+ {\r
+ gint bpp;\r
+ gint depth;\r
+ gint endianess;\r
+ gint blue_mask;\r
+ gboolean bigendian = FALSE;\r
+ gboolean isbluefirst = FALSE;\r
+\r
+ /**\r
+\r
+ * The followings will be considered.\r
+ * RGBx, xRGB, BGRx, xBGR\r
+ * RGB888, BGR888\r
+ * RGB565\r
+ *\r
+ */\r
+ gst_structure_get_int (structure, "bpp", &bpp);\r
+ gst_structure_get_int (structure, "depth", &depth);\r
+ gst_structure_get_int (structure, "endianness", &endianess);\r
+ gst_structure_get_int (structure, "blue_mask", &blue_mask);\r
+\r
+ if (endianess == 4321)\r
+ bigendian = TRUE;\r
+\r
+ if (blue_mask == -16777216)\r
+ isbluefirst = TRUE;\r
+\r
+ switch(bpp)\r
+ {\r
+ case 32:\r
+ {\r
+ switch(depth)\r
+ {\r
+ case 32:\r
+ if (bigendian && isbluefirst)\r
+ src_fmt = MM_UTIL_IMG_FMT_BGRA8888;\r
+ case 24:\r
+ if (bigendian && isbluefirst)\r
+ src_fmt = MM_UTIL_IMG_FMT_BGRX8888;\r
+ break;\r
+ default:\r
+ goto UNKNOWN;\r
+ break;\r
+ }\r
+ }\r
+ break;\r
+\r
+ case 24:\r
+ default:\r
+ {\r
+ goto UNKNOWN;\r
+ }\r
+ break;\r
+ }\r
+ }\r
+ else\r
+ {\r
+ goto UNKNOWN;\r
+ }\r
+ GstMapInfo info;\r
+ gst_buffer_map (buffer, &info, GST_MAP_WRITE);\r
+ __mm_player_convert_colorspace(player, info.data, src_fmt, src_width, src_height, dst_fmt);\r
+ gst_buffer_unmap (buffer, &info);\r
+\r
+DONE:\r
+ /* do convert colorspace */\r
+ g_cond_signal( player->capture_thread_cond );\r
+\r
+ debug_fleave();\r
+\r
+ return MM_ERROR_NONE;\r
+\r
+UNKNOWN:\r
+ debug_error("unknown format to capture\n");\r
+ return MM_ERROR_PLAYER_INTERNAL;\r
+}\r
+#else\r
+/**\r
+ * The output is fixed as RGB888\r
+ */\r
+static int\r
+__mmplayer_get_video_frame_from_buffer(mm_player_t* player, GstBuffer *buffer)\r
+{\r
+ gint yplane_size = 0;\r
+ gint uvplane_size = 0;\r
+ gint src_width = 0;\r
+ gint src_height = 0;\r
+ const gchar *fmt;\r
+ GstCaps *caps = NULL;\r
+ GstStructure *structure = NULL;\r
+ mm_util_img_format src_fmt = MM_UTIL_IMG_FMT_YUV420;\r
+ mm_util_img_format dst_fmt = MM_UTIL_IMG_FMT_RGB888; // fixed\r
+\r
+ debug_fenter();\r
+\r
+ return_val_if_fail ( player, MM_ERROR_PLAYER_NOT_INITIALIZED );\r
+ return_val_if_fail ( buffer, MM_ERROR_INVALID_ARGUMENT );\r
+\r
+ /* get fourcc */\r
+ caps = GST_BUFFER_CAPS(buffer);\r
+\r
+ return_val_if_fail ( caps, MM_ERROR_INVALID_ARGUMENT );\r
+ debug_log("caps to capture: %s\n", gst_caps_to_string(caps));\r
+\r
+ structure = gst_caps_get_structure (caps, 0);\r
+\r
+ return_val_if_fail (structure != NULL, MM_ERROR_PLAYER_INTERNAL);\r
+\r
+ /* init capture image buffer */\r
+ memset(&player->capture, 0x00, sizeof(MMPlayerVideoCapture));\r
+\r
+ gst_structure_get_int (structure, "width", &src_width);\r
+ gst_structure_get_int (structure, "height", &src_height);\r
+\r
+ /* check rgb or yuv */\r
+ if (gst_structure_has_name(structure, "video/x-raw-yuv"))\r
+ {\r
+ fmt = gst_structure_get_string (structure, "format");\r
+ switch (GST_STR_FOURCC (fmt))\r
+ {\r
+ /* NV12T */\r
+ case GST_MAKE_FOURCC ('S', 'T', '1', '2'):\r
+ {\r
+ debug_msg ("captured format is ST12\n");\r
+\r
+ MMPlayerMPlaneImage *proved = NULL;\r
+ player->video_cs = MM_PLAYER_COLORSPACE_NV12_TILED;\r
+\r
+ /* get video frame info from proved buffer */\r
+ proved = (MMPlayerMPlaneImage *)gst_buffer_copy (buffer);\r
+\r
+ if ( !proved || !proved->a[0] || !proved->a[1] )\r
+ return MM_ERROR_PLAYER_INTERNAL;\r
+\r
yplane_size = proved->y_size;\r
uvplane_size = proved->uv_size;\r
\r
debug_error("unknown format to capture\n");\r
return MM_ERROR_PLAYER_INTERNAL;\r
}\r
+#endif\r
+#endif\r
\r
static gboolean\r
__mmplayer_video_capture_probe (GstPad *pad, GstBuffer *buffer, gpointer u_data)\r
return_val_if_fail ( buffer, FALSE);\r
debug_fenter();\r
\r
- ret = __mmplayer_get_video_frame_from_buffer(player, buffer);\r
+ //ret = __mmplayer_get_video_frame_from_buffer(player, buffer);\r
\r
if ( ret != MM_ERROR_NONE)\r
{\r
/* remove probe to be called at one time */\r
if (player->video_capture_cb_probe_id)\r
{\r
+#ifndef GST_API_VERSION_1\r
gst_pad_remove_buffer_probe (pad, player->video_capture_cb_probe_id);\r
+#else\r
+ gst_pad_remove_probe (pad, player->video_capture_cb_probe_id);\r
+#endif\r
player->video_capture_cb_probe_id = 0;\r
}\r
\r
#include <glib.h>
#include <gst/gst.h>
#include <gst/app/gstappsrc.h>
+#ifndef GST_API_VERSION_1
#include <gst/interfaces/xoverlay.h>
+#else
+#include <gst/video/videooverlay.h>
+#endif
#include <unistd.h>
#include <string.h>
#include <sys/time.h>
+#include <sys/stat.h>
#include <stdlib.h>
#include <mm_error.h>
gboolean missing_only = FALSE;
gboolean all = FALSE;
+#ifndef GST_API_VERSION_1
GstFormat fmt = GST_FORMAT_TIME;
+#endif
gint64 dur_nsec = 0;
GstStructure* p = NULL;
MMHandleType attrs = 0;
debug_log("try to update duration");
has_duration = FALSE;
+#ifdef GST_API_VERSION_1
+ if (gst_element_query_duration(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, GST_FORMAT_TIME, &dur_nsec ))
+ {
+ player->duration = dur_nsec;
+ debug_log("duration : %lld msec", GST_TIME_AS_MSECONDS(dur_nsec));
+ }
+#else
if (gst_element_query_duration(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, &fmt, &dur_nsec ))
{
player->duration = dur_nsec;
debug_log("duration : %lld msec", GST_TIME_AS_MSECONDS(dur_nsec));
}
+#endif
/* try to get streaming service type */
stream_service_type = __mmplayer_get_stream_service_type( player );
if ( pad )
{
+#ifdef GST_API_VERSION_1
+ caps_a = gst_pad_get_current_caps( pad );
+#else
caps_a = gst_pad_get_negotiated_caps( pad );
+#endif
if ( caps_a )
{
pad = gst_element_get_static_pad( player->pipeline->videobin[MMPLAYER_V_SINK].gst, "sink" );
if ( pad )
{
+#ifdef GST_API_VERSION_1
+ caps_v = gst_pad_get_current_caps( pad );
+#else
caps_v = gst_pad_get_negotiated_caps( pad );
+#endif
if (caps_v)
{
p = gst_caps_get_structure (caps_v, 0);
return_val_if_fail ( player, FALSE );
return_val_if_fail ( msg && GST_IS_MESSAGE(msg), FALSE );
+#ifdef GST_API_VERSION_1
+ const GstStructure *structure;
+ structure = gst_message_get_structure (msg);
+#endif
+
switch ( GST_MESSAGE_TYPE( msg ) )
{
case GST_MESSAGE_UNKNOWN:
debug_error("release audio callback\n");
/* release audio callback */
+#ifdef GST_API_VERSION_1
+ gst_pad_remove_probe (pad, player->audio_cb_probe_id);
+#else
gst_pad_remove_buffer_probe (pad, player->audio_cb_probe_id);
+#endif
player->audio_cb_probe_id = 0;
/* audio callback should be free because it can be called even though probe remove.*/
player->audio_stream_cb = NULL;
gst_message_parse_error( msg, &error, &debug );
msg_src_element = GST_ELEMENT_NAME( GST_ELEMENT_CAST( msg->src ) );
+#ifdef GST_API_VERSION_1
+ if ( gst_structure_has_name ( structure, "streaming_error" ) )
+ {
+ /* Note : the streaming error from the streaming source is handled
+ * using __mmplayer_handle_streaming_error.
+ */
+ __mmplayer_handle_streaming_error ( player, msg );
+
+ /* dump state of all element */
+ __mmplayer_dump_pipeline_state( player );
+ }
+ else
+ {
+ /* traslate gst error code to msl error code. then post it
+ * to application if needed
+ */
+ __mmplayer_handle_gst_error( player, msg, error );
+
+ /* dump state of all element */
+ __mmplayer_dump_pipeline_state( player );
+
+ }
+#else
if ( gst_structure_has_name ( msg->structure, "streaming_error" ) )
{
/* Note : the streaming error from the streaming source is handled
}
+#endif
+
+
if (MMPLAYER_IS_HTTP_PD(player))
{
_mmplayer_unrealize_pd_downloader ((MMHandleType)player);
break;
/* get state info from msg */
+#ifdef GST_API_VERSION_1
+ voldstate = gst_structure_get_value (structure, "old-state");
+ vnewstate = gst_structure_get_value (structure, "new-state");
+ vpending = gst_structure_get_value (structure, "pending-state");
+#else
voldstate = gst_structure_get_value (msg->structure, "old-state");
vnewstate = gst_structure_get_value (msg->structure, "new-state");
vpending = gst_structure_get_value (msg->structure, "pending-state");
+#endif
oldstate = (GstState)voldstate->data[0].v_int;
newstate = (GstState)vnewstate->data[0].v_int;
}\
}
+#ifdef GST_API_VERSION_1
+#define MMPLAYER_UPDATE_TAG_IMAGE(gsttag, attribute, playertag) \
+value = gst_tag_list_get_value_index(tag_list, gsttag, index); \
+if (value) \
+{\
+ GstMapInfo info; \
+ gst_buffer_map (buffer, &info, GST_MAP_WRITE); \
+ buffer = gst_value_get_buffer (value); \
+ debug_log ( "update album cover data : %p, size : %d\n", info.data, gst_buffer_get_size(buffer)); \
+ player->album_art = (gchar *)g_malloc(gst_buffer_get_size(buffer)); \
+ if (player->album_art); \
+ { \
+ memcpy(player->album_art, info.data, gst_buffer_get_size(buffer)); \
+ mm_attrs_set_data_by_name(attribute, playertag, (void *)player->album_art, gst_buffer_get_size(buffer)); \
+ } \
+gst_buffer_unmap (buffer, &info); \
+}
+#else
#define MMPLAYER_UPDATE_TAG_IMAGE(gsttag, attribute, playertag) \
value = gst_tag_list_get_value_index(tag_list, gsttag, index); \
if (value) \
mm_attrs_set_data_by_name(attribute, playertag, (void *)player->album_art, GST_BUFFER_SIZE(buffer)); \
} \
}
+#endif
#define MMPLAYER_UPDATE_TAG_UINT(gsttag, attribute, playertag) \
if (gst_tag_list_get_uint(tag_list, gsttag, &v_uint))\
else /* NOTE : use pad's caps directely. if enabled. what I am assuming is there's no elemnt has dynamic pad */
{
debug_log("using pad caps to autopluging instead of doing typefind\n");
-
+#ifdef GST_API_VERSION_1
+ caps = gst_pad_get_current_caps( pad );
+#else
caps = gst_pad_get_caps( pad );
+#endif
MMPLAYER_CHECK_NULL( caps );
}
/* get mimetype from caps */
+#ifdef GST_API_VERSION_1
+ caps = gst_pad_get_current_caps( pad );
+#else
caps = gst_pad_get_caps( pad );
+#endif
if ( !caps )
{
debug_error("cannot get caps from pad.\n");
mm_attrs_get_int_by_name(attrs, "display_height", &height);
/* resize video frame with requested values for fimcconvert */
+#ifdef GST_API_VERSION_1
+ ename = GST_OBJECT (gst_element_get_factory(player->pipeline->videobin[MMPLAYER_V_CONV].gst));
+#else
ename = GST_PLUGIN_FEATURE_NAME(gst_element_get_factory(player->pipeline->videobin[MMPLAYER_V_CONV].gst));
+#endif
if (g_strrstr(ename, "fimcconvert"))
{
}
debug_log("set video param : xid %d", *(int*)xid);
+#ifdef GST_API_VERSION_1
+ gst_video_overlay_set_window_handle( GST_VIDEO_OVERLAY( player->pipeline->videobin[MMPLAYER_V_SINK].gst ), *(int*)xid );
+#else
gst_x_overlay_set_xwindow_id( GST_X_OVERLAY( player->pipeline->videobin[MMPLAYER_V_SINK].gst ), *(int*)xid );
+#endif
}
else
{
if ((srcpad = gst_element_get_static_pad(player->pipeline->mainbin[MMPLAYER_M_DEMUX].gst, "src")))
{
+#ifdef GST_API_VERSION_1
+ if ((caps = gst_pad_get_current_caps(srcpad)))
+ {
+ MMPLAYER_LOG_GST_CAPS_TYPE(caps);
+ GstStructure *str = gst_caps_get_structure(caps, 0);
+ if (str)
+ gst_structure_get_int (str, "channels", &channels);
+ gst_caps_unref(caps);
+ }
+#else
if ((caps = gst_pad_get_caps(srcpad)))
{
MMPLAYER_LOG_GST_CAPS_TYPE(caps);
gst_structure_get_int (str, "channels", &channels);
gst_caps_unref(caps);
}
+#endif
gst_object_unref(srcpad);
}
}
gint size;
guint8 *data;
+#ifdef GST_API_VERSION_1
+ GstMapInfo info;
+ gst_buffer_map (buffer, &info, GST_MAP_WRITE);
+ data = info.data;
+ size = gst_buffer_get_size(buffer);
+
+ if (player->audio_stream_cb && size && data)
+ player->audio_stream_cb((void *)data, size, player->audio_stream_cb_user_param);
+
+ gst_buffer_unmap (buffer, &info);
+#else
data = GST_BUFFER_DATA(buffer);
size = GST_BUFFER_SIZE(buffer);
if (player->audio_stream_cb && size && data)
player->audio_stream_cb((void *)data, size, player->audio_stream_cb_user_param);
+#endif
return TRUE;
}
return MM_ERROR_PLAYER_INTERNAL;
}
+#ifdef GST_API_VERSION_1
+gboolean
+__mmplayer_update_subtitle( GstElement* object, GstBuffer *buffer, GstPad *pad, gpointer data)
+{
+ mm_player_t* player = (mm_player_t*) data;
+ MMMessageParamType msg = {0, };
+ GstClockTime duration = 0;
+ guint8 *text = NULL;
+ gboolean ret = TRUE;
+ GstMapInfo info;
+
+ debug_fenter();
+
+ return_val_if_fail ( player, FALSE );
+ return_val_if_fail ( buffer, FALSE );
+
+ gst_buffer_map (buffer, &info, GST_MAP_WRITE);
+ text = info.data;
+ gst_buffer_unmap (buffer, &info);
+
+ duration = GST_BUFFER_DURATION(buffer);
+
+ if ( player->is_subtitle_off )
+ {
+ debug_log("subtitle is OFF.\n" );
+ return TRUE;
+ }
+
+ if ( !text )
+ {
+ debug_log("There is no subtitle to be displayed.\n" );
+ return TRUE;
+ }
+
+ msg.data = (void *) text;
+ msg.subtitle.duration = GST_TIME_AS_MSECONDS(duration);
+
+ debug_warning("update subtitle : [%ld msec] %s\n'", msg.subtitle.duration, (char*)msg.data );
+
+ MMPLAYER_POST_MSG( player, MM_MESSAGE_UPDATE_SUBTITLE, &msg );
+
+ debug_fleave();
+
+ return ret;
+}
+#else
gboolean
__mmplayer_update_subtitle( GstElement* object, GstBuffer *buffer, GstPad *pad, gpointer data)
{
return ret;
}
+#endif
static int __gst_adjust_subtitle_position(mm_player_t* player, int format, int position)
{
{
case MM_PLAYER_POS_FORMAT_TIME:
{
- /* check current postion */
if (__gst_get_position(player, MM_PLAYER_POS_FORMAT_TIME, ¤t_pos ))
{
debug_error("failed to get position");
return MM_ERROR_NONE;
}
+#ifdef GST_API_VERSION_1
+static void
+__gst_appsrc_feed_data_mem(GstElement *element, guint size, gpointer user_data) // @
+{
+ GstElement *appsrc = element;
+ tBuffer *buf = (tBuffer *)user_data;
+ GstBuffer *buffer = NULL;
+ GstFlowReturn ret = GST_FLOW_OK;
+ gint len = size;
+
+ return_if_fail ( element );
+ return_if_fail ( buf );
+
+ //buffer = gst_buffer_new ();
+
+ if (buf->offset >= buf->len)
+ {
+ debug_log("call eos appsrc\n");
+ g_signal_emit_by_name (appsrc, "end-of-stream", &ret);
+ return;
+ }
+
+ if ( buf->len - buf->offset < size)
+ {
+ len = buf->len - buf->offset + buf->offset;
+ }
+
+ buffer = gst_buffer_new();
+ GstMapInfo info;
+
+ info.data = (guint8*)(buf->buf + buf->offset);
+ gst_buffer_set_size(buffer, len);
+
+ //GST_BUFFER_DATA(buffer) = (guint8*)(buf->buf + buf->offset);
+ //GST_BUFFER_SIZE(buffer) = len;
+ GST_BUFFER_OFFSET(buffer) = buf->offset;
+ GST_BUFFER_OFFSET_END(buffer) = buf->offset + len;
+ gst_buffer_map (buffer, &info, GST_MAP_WRITE);
+
+ debug_log("feed buffer %p, offset %u-%u length %u\n", buffer, buf->offset, buf->len,len);
+ g_signal_emit_by_name (appsrc, "push-buffer", buffer, &ret);
+
+ buf->offset += len;
+}
+#else
static void
__gst_appsrc_feed_data_mem(GstElement *element, guint size, gpointer user_data) // @
{
buf->offset += len;
}
+#endif
static gboolean
__gst_appsrc_seek_data_mem(GstElement *element, guint64 size, gpointer user_data) // @
return TRUE;
}
+#ifdef GST_API_VERSION_1
+int
+_mmplayer_push_buffer(MMHandleType hplayer, unsigned char *buf, int size) // @
+{
+ mm_player_t* player = (mm_player_t*)hplayer;
+ GstBuffer *buffer = NULL;
+ GstMapInfo info;
+ GstFlowReturn gst_ret = GST_FLOW_OK;
+ int ret = MM_ERROR_NONE;
+
+ debug_fenter();
+
+ return_val_if_fail ( player, MM_ERROR_PLAYER_NOT_INITIALIZED );
+
+ /* check current state */
+// MMPLAYER_CHECK_STATE_RETURN_IF_FAIL( player, MMPLAYER_COMMAND_START );
+
+
+ /* NOTE : we should check and create pipeline again if not created as we destroy
+ * whole pipeline when stopping in streamming playback
+ */
+ if ( ! player->pipeline )
+ {
+ if ( MM_ERROR_NONE != __gst_realize( player ) )
+ {
+ debug_error("failed to realize before starting. only in streamming\n");
+ return MM_ERROR_PLAYER_INTERNAL;
+ }
+ }
+
+ debug_msg("app-src: pushing data\n");
+
+ if ( buf == NULL )
+ {
+ debug_error("buf is null\n");
+ return MM_ERROR_NONE;
+ }
+
+ buffer = gst_buffer_new ();
+
+ if (size <= 0)
+ {
+ debug_log("call eos appsrc\n");
+ g_signal_emit_by_name (player->pipeline->mainbin[MMPLAYER_M_SRC].gst, "end-of-stream", &gst_ret);
+ return MM_ERROR_NONE;
+ }
+
+ info.data = (guint8*)(buf);
+ gst_buffer_set_size(buffer, size);
+ gst_buffer_map (buffer, &info, GST_MAP_WRITE);
+
+ debug_log("feed buffer %p, length %u\n", buf, size);
+ g_signal_emit_by_name (player->pipeline->mainbin[MMPLAYER_M_SRC].gst, "push-buffer", buffer, &gst_ret);
+
+ debug_fleave();
+
+ return ret;
+}
+#else
int
_mmplayer_push_buffer(MMHandleType hplayer, unsigned char *buf, int size) // @
{
return ret;
}
+#endif
static GstBusSyncReply
__mmplayer_bus_sync_callback (GstBus * bus, GstMessage * message, gpointer data)
debug_error ("fakesink element could not be created\n");
goto INIT_ERROR;
}
+#ifdef GST_API_VERSION_1
+ GST_OBJECT_FLAG_UNSET (mainbin[MMPLAYER_M_SRC_FAKESINK].gst, GST_ELEMENT_FLAG_SINK);
+#else
GST_OBJECT_FLAG_UNSET (mainbin[MMPLAYER_M_SRC_FAKESINK].gst, GST_ELEMENT_IS_SINK);
+#endif
/* take ownership of fakesink. we are reusing it */
gst_object_ref( mainbin[MMPLAYER_M_SRC_FAKESINK].gst );
}
/* set sync handler to get tag synchronously */
+#ifdef GST_API_VERSION_1
+ gst_bus_set_sync_handler(bus, __mmplayer_bus_sync_callback, player, NULL);
+#else
gst_bus_set_sync_handler(bus, __mmplayer_bus_sync_callback, player);
-
+#endif
/* finished */
gst_object_unref(GST_OBJECT(bus));
g_list_free(element_bucket);
GstPad *pad = NULL;
pad = gst_element_get_static_pad(player->pipeline->mainbin[MMPLAYER_M_SRC].gst, "src" );
+#ifdef GST_API_VERSION_1
+ gst_pad_remove_probe (pad, ahs_appsrc_cb_probe_id);
+#else
gst_pad_remove_buffer_probe (pad, ahs_appsrc_cb_probe_id);
+#endif
gst_object_unref(pad);
pad = NULL;
ahs_appsrc_cb_probe_id = 0;
MMPlayerGstElement* videobin = player->pipeline->videobin;
MMPlayerGstElement* textbin = player->pipeline->textbin;
GstBus *bus = gst_pipeline_get_bus (GST_PIPELINE (mainbin[MMPLAYER_M_PIPE].gst));
+
+#ifdef GST_API_VERSION_1
+ gst_bus_set_sync_handler (bus, NULL, NULL, NULL);
+#else
gst_bus_set_sync_handler (bus, NULL, NULL);
+#endif
gst_object_unref(bus);
debug_log("pipeline status before set state to NULL\n");
/* clean bus sync handler because it's not needed any more */
bus = gst_pipeline_get_bus (GST_PIPELINE(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst));
- gst_bus_set_sync_handler (bus, NULL, NULL);
+#ifdef GST_API_VERSION_1
+ gst_bus_set_sync_handler (bus, NULL, NULL, NULL);
+#else
+ gst_bus_set_sync_handler (bus, NULL, NULL);
+#endif
gst_object_unref(bus);
/* set pipeline state to PLAYING */
static int
__gst_set_position(mm_player_t* player, int format, unsigned long position, gboolean internal_called) // @
{
+#ifndef GST_API_VERSION_1
GstFormat fmt = GST_FORMAT_TIME;
+#endif
unsigned long dur_msec = 0;
gint64 dur_nsec = 0;
gint64 pos_nsec = 0;
*/
if ( !player->duration )
{
+#ifdef GST_API_VERSION_1
+ if ( !gst_element_query_duration( player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, GST_FORMAT_TIME, &dur_nsec ))
+ {
+ goto SEEK_ERROR;
+ }
+#else
if ( !gst_element_query_duration( player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, &fmt, &dur_nsec ))
{
goto SEEK_ERROR;
}
+#endif
player->duration = dur_nsec;
}
__gst_get_position(mm_player_t* player, int format, unsigned long* position) // @
{
MMPlayerStateType current_state = MM_PLAYER_STATE_NONE;
+#ifndef GST_API_VERSION_1
GstFormat fmt = GST_FORMAT_TIME;
+#endif
signed long long pos_msec = 0;
gboolean ret = TRUE;
*/
if ( current_state != MM_PLAYER_STATE_PAUSED )
{
+#ifdef GST_API_VERSION_1
+ ret = gst_element_query_position(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, GST_FORMAT_TIME, &pos_msec);
+#else
ret = gst_element_query_position(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, &fmt, &pos_msec);
+#endif
}
/* NOTE : get last point to overcome some bad operation of some elements
_mmplayer_pause(MMHandleType hplayer) // @
{
mm_player_t* player = (mm_player_t*)hplayer;
+#ifndef GST_API_VERSION_1
GstFormat fmt = GST_FORMAT_TIME;
+#endif
gint64 pos_msec = 0;
gboolean async = FALSE;
gint ret = MM_ERROR_NONE;
* ( returning zero when getting current position in paused state) of some
* elements
*/
- if ( !gst_element_query_position(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, &fmt, &pos_msec))
- debug_warning("getting current position failed in paused\n");
+#ifdef GST_API_VERSION_1
+ ret = gst_element_query_position(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, GST_FORMAT_TIME, &pos_msec);
+#else
+ ret = gst_element_query_position(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, &fmt, &pos_msec);
+#endif
+ if ( ! ret )
+ debug_warning("getting current position failed in paused\n");
player->last_position = pos_msec;
}
static int
__mmplayer_set_pcm_extraction(mm_player_t* player)
{
- gint64 start_nsec = 0;
- gint64 end_nsec = 0;
- gint64 dur_nsec = 0;
- gint64 dur_msec = 0;
+ guint64 start_nsec = 0;
+ guint64 end_nsec = 0;
+ guint64 dur_nsec = 0;
+ guint64 dur_msec = 0;
+#ifndef GST_API_VERSION_1
GstFormat fmt = GST_FORMAT_TIME;
+#endif
int required_start = 0;
int required_end = 0;
int ret = 0;
}
/* get duration */
+#ifdef GST_API_VERSION_1
+ ret = gst_element_query_duration(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, GST_FORMAT_TIME, &dur_nsec);
+#else
ret = gst_element_query_duration(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, &fmt, &dur_nsec);
+#endif
if ( !ret )
{
debug_error("failed to get duration");
{
mm_player_t* player = (mm_player_t*)hplayer;
gint64 cur_pos = 0;
+#ifndef GST_API_VERSION_1
GstFormat fmt = GST_FORMAT_TIME;
+#endif
gint onetime = 1;
debug_fenter();
player->section_repeat = FALSE;
__mmplayer_set_play_count( player, onetime );
-
+#ifdef GST_API_VERSION_1
+ gst_element_query_position(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, GST_FORMAT_TIME, &cur_pos);
+#else
gst_element_query_position(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, &fmt, &cur_pos);
+#endif
if ( (!__gst_seek( player, player->pipeline->mainbin[MMPLAYER_M_PIPE].gst,
1.0,
signed long long pos_msec = 0;
int ret = MM_ERROR_NONE;
int mute = FALSE;
+#ifndef GST_API_VERSION_1
GstFormat format =GST_FORMAT_TIME;
+#endif
MMPlayerStateType current_state = MM_PLAYER_STATE_NONE;
debug_fenter();
player->playback_rate = rate;
current_state = MMPLAYER_CURRENT_STATE(player);
-
+#ifdef GST_API_VERSION_1
+ if ( current_state != MM_PLAYER_STATE_PAUSED )
+ ret = gst_element_query_position(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, GST_FORMAT_TIME, &pos_msec);
+#else
if ( current_state != MM_PLAYER_STATE_PAUSED )
ret = gst_element_query_position(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, &format, &pos_msec);
+#endif
debug_log ("pos_msec = %"GST_TIME_FORMAT" and ret = %d and state = %d", GST_TIME_ARGS (pos_msec), ret, current_state);
if (ret != GST_STATE_CHANGE_SUCCESS)
{
+#ifdef GST_API_VERSION_1
+ debug_error ("resource conflict so, %s unusable\n", gst_object_get_name (GST_OBJECT (factory)));
+#else
debug_error ("resource conflict so, %s unusable\n", GST_PLUGIN_FEATURE_NAME (factory));
+#endif
usable = FALSE;
}
skip = FALSE;
/* filtering exclude keyword */
+#ifdef GST_API_VERSION_1
+ for ( idx = 0; PLAYER_INI()->exclude_element_keyword[idx][0] != '\0'; idx++ )
+ {
+ if ( g_strrstr(gst_object_get_name (GST_OBJECT (factory)),
+ PLAYER_INI()->exclude_element_keyword[idx]) )
+ {
+ debug_warning("skipping [%s] by exculde keyword [%s]\n",
+ gst_object_get_name (GST_OBJECT (factory)),
+ PLAYER_INI()->exclude_element_keyword[idx] );
+
+ skip = TRUE;
+ break;
+ }
+ }
+#else
for ( idx = 0; PLAYER_INI()->exclude_element_keyword[idx][0] != '\0'; idx++ )
{
if ( g_strrstr(GST_PLUGIN_FEATURE_NAME (factory),
break;
}
}
+#endif
if ( skip ) continue;
*/
if ( g_strrstr(klass, "Codec/Decoder/Image") )
{
- debug_log("skipping [%s] by not required\n", GST_PLUGIN_FEATURE_NAME (factory));
+#ifdef GST_API_VERSION_1
+ debug_log("skipping [%s] by not required\n",
+ gst_object_get_name (GST_OBJECT (factory)) );
+#else
+ debug_log("skipping [%s] by not required\n",
+ GST_PLUGIN_FEATURE_NAME (factory) );
+#endif
continue;
}
if( res && !gst_caps_is_empty(res) )
{
+#ifdef GST_API_VERSION_1
+ GstElement *new_element;
+ GList *elements = player->parsers;
+ char *name_template = g_strdup(temp1->name_template);
+ gchar *name_to_plug = gst_object_get_name (GST_OBJECT (factory));
+
+ gst_caps_unref(res);
+
+ debug_log("found %s to plug\n", name_to_plug);
+
+ new_element = gst_element_factory_create(GST_ELEMENT_FACTORY(factory), NULL);
+ if ( ! new_element )
+ {
+ debug_error("failed to create element [%s]. continue with next.\n",
+ gst_object_get_name (GST_OBJECT (factory)));
+
+ MMPLAYER_FREEIF(name_template);
+
+ continue;
+ }
+#else
GstElement *new_element;
GList *elements = player->parsers;
char *name_template = g_strdup(temp1->name_template);
continue;
}
+#endif
/* check and skip it if it was already used. Otherwise, it can be an infinite loop
* because parser can accept its own output as input.
{
GstPad *pad = NULL;
+#ifdef GST_API_VERSION_1
pad = gst_element_get_static_pad (player->pipeline->audiobin[MMPLAYER_A_SINK].gst, "sink");
+#else
+ pad = gst_element_get_pad (player->pipeline->audiobin[MMPLAYER_A_SINK].gst, "sink");
+#endif
if ( !pad )
{
return FALSE;
}
+#ifdef GST_API_VERSION_1
+ player->audio_cb_probe_id = gst_pad_add_probe (pad, GST_PAD_PROBE_TYPE_BUFFER,
+ __mmplayer_audio_stream_probe, player, NULL);
+#else
player->audio_cb_probe_id = gst_pad_add_buffer_probe (pad,
G_CALLBACK (__mmplayer_audio_stream_probe), player);
+#endif
gst_object_unref (pad);
return_if_fail ( player );
+#ifdef GST_API_VERSION_1
+ player->factories = gst_registry_feature_filter(gst_registry_get(),
+ (GstPluginFeatureFilter)__mmplayer_feature_filter, FALSE, NULL);
+#else
player->factories = gst_registry_feature_filter(gst_registry_get_default(),
(GstPluginFeatureFilter)__mmplayer_feature_filter, FALSE, NULL);
+#endif
player->factories = g_list_sort(player->factories, (GCompareFunc)util_factory_rank_compare);
gchar *parser_name = NULL;
GstCaps *dcaps = NULL;
+#ifdef GST_API_VERSION_1
+ dcaps = gst_pad_get_current_caps(srcpad);
+#else
dcaps = gst_pad_get_caps(srcpad);
+#endif
demux_caps = gst_caps_to_string(dcaps);
if (g_strrstr(demux_caps, "video/x-h264"))
/* to check the video/audio type set the proper flag*/
{
+#ifdef GST_API_VERSION_1
+ srccaps = gst_pad_get_current_caps( srcpad );
+#else
srccaps = gst_pad_get_caps( srcpad );
+#endif
if ( !srccaps )
goto ERROR;
{
if (MMPLAYER_IS_HTTP_STREAMING(player))
{
+#ifndef GST_API_VERSION_1
GstFormat fmt = GST_FORMAT_BYTES;
+#endif
gint64 dur_bytes = 0L;
gchar *file_buffering_path = NULL;
gboolean use_file_buffer = FALSE;
if ( !MMPLAYER_IS_HTTP_LIVE_STREAMING(player))
{
+#ifdef GST_API_VERSION_1
+ if ( !gst_element_query_duration(player->pipeline->mainbin[MMPLAYER_M_SRC].gst, GST_FORMAT_BYTES, &dur_bytes))
+ debug_error("fail to get duration.\n");
+#else
if ( !gst_element_query_duration(player->pipeline->mainbin[MMPLAYER_M_SRC].gst, &fmt, &dur_bytes))
debug_error("fail to get duration.\n");
+#endif
if (dur_bytes>0)
{
case GST_PAD_ALWAYS:
{
GstPad *srcpad = gst_element_get_static_pad(sinkelement, "src");
+#ifdef GST_API_VERSION_1
+ GstCaps *caps = gst_pad_get_current_caps(srcpad);
+#else
GstCaps *caps = gst_pad_get_caps(srcpad);
+#endif
/* Check whether caps has many types */
if ( gst_caps_get_size (caps) > 1 && g_strrstr(klass, "Parser")) {
return_if_fail ( unused )
return_if_fail ( data )
+#ifdef GST_API_VERSION_1
+ caps = gst_pad_get_current_caps(pad);
+#else
caps = gst_pad_get_caps(pad);
+#endif
if ( !caps )
return;
return_if_fail ( pad );
GST_OBJECT_LOCK (pad);
+#ifdef GST_API_VERSION_1
+ if ((caps = gst_pad_get_current_caps (pad)))
+ gst_caps_ref(caps);
+#else
if ((caps = GST_PAD_CAPS(pad)))
gst_caps_ref(caps);
+#endif
GST_OBJECT_UNLOCK (pad);
if ( NULL == caps )
{
+#ifdef GST_API_VERSION_1
+ caps = gst_pad_get_current_caps(pad);
+#else
caps = gst_pad_get_caps(pad);
+#endif
if ( !caps ) return;
}
return_val_if_fail ( srcpad, FALSE );
/* to check any of the decoder (video/audio) need to be linked to parser*/
+#ifdef GST_API_VERSION_1
+ srccaps = gst_pad_get_current_caps( srcpad );
+#else
srccaps = gst_pad_get_caps( srcpad );
+#endif
if ( !srccaps )
goto ERROR;
return_val_if_fail ( srcpad, FALSE );
/* to check any of the decoder (video/audio) need to be linked to parser*/
+#ifdef GST_API_VERSION_1
+ srccaps = gst_pad_get_current_caps( srcpad );
+#else
srccaps = gst_pad_get_caps( srcpad );
+#endif
if ( !srccaps )
goto ERROR;
projects / platform / core / multimedia / libmm-player.git / commitdiff