Name: libmm-player
Summary: Multimedia Framework Player Library
-Version: 0.2.4
-Release: 1
+Version: 0.2.5
+Release: 0
Group: System/Libraries
License: TBD
Source0: %{name}-%{version}.tar.gz
<td>N/A</td>
</tr>
<tr>
- <td>"display_overlay_ext"</td>
- <td>data</td>
- <td>N/A</td>
- </tr>
- <tr>
<td>"display_rotation"</td>
<td>int</td>
<td>range</td>
{
/* general */
gboolean use_decodebin; // @
- gint video_surface;
gchar videosink_element_x[PLAYER_INI_MAX_STRLEN];
gchar videosink_element_evas[PLAYER_INI_MAX_STRLEN];
gchar videosink_element_fake[PLAYER_INI_MAX_STRLEN];
#define DEFAULT_DELAY_BEFORE_REPEAT 50 /* msec */
#define DEFAULT_EOS_DELAY 150 /* msec */
#define DEFAULT_DRMSRC "drmsrc"
-#define DEFAULT_VIDEO_SURFACE MM_DISPLAY_SURFACE_X
#define DEFAULT_VIDEOSINK_X "xvimagesink"
#define DEFAULT_VIDEOSINK_EVAS "evasimagesink"
#define DEFAULT_VIDEOSINK_FAKE "fakesink"
*/
int mm_player_push_buffer(MMHandleType player, unsigned char *buf, int size);
+/**
+ * This function changes the previous videosink plugin for a new one
+ *
+ * @param player [in] Handle of player.
+ * @param display_surface_type [in] display surface type to set
+ * @param display_overlay [in] display overlay to set
+ *
+ * @return This function returns zero on success, or negative value with error
+ * code.
+ * @remark Not supported
+ * @see
+ * @since
+ */
+int mm_player_change_videosink(MMHandleType player, MMDisplaySurfaceType display_surface_type, void *display_overlay);
/**
@}
MMPLAYER_V_CONV,
MMPLAYER_V_SCALE,
MMPLAYER_V_CAPS,
- MMPLAYER_V_TEE,
MMPLAYER_V_SINK,
MMPLAYER_V_NUM
};
/* gstreamer pipeline */
MMPlayerGstPipelineInfo *pipeline;
gboolean pipeline_is_constructed;
-
+
/* Buffering support cbs*/
mm_player_buffer_need_data_callback need_data_cb;
mm_player_buffer_enough_data_callback enough_data_cb;
#define GST_ELEMENT_LINK_FILTERED gst_element_link_filtered
#define GST_ELEMENT_LINK_MANY gst_element_link_many
#define GST_ELEMENT_LINK gst_element_link
+#define GST_ELEMENT_UNLINK gst_element_unlink
#define GST_ELEMENT_LINK_PADS gst_element_link_pads
#define GST_PAD_LINK gst_pad_link
#endif
return result;
}
+/* NOTE : Not supported */
+int mm_player_change_videosink(MMHandleType player, MMDisplaySurfaceType display_surface_type, void *display_overlay)
+{
+ int result = MM_ERROR_NONE;
+
+ debug_log("\n");
+
+ return_val_if_fail(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+
+ return MM_ERROR_NOT_SUPPORT_API;
+}
int mm_player_push_buffer(MMHandleType player, unsigned char *buf, int size)
{
return_val_if_fail(handle, MM_ERROR_COMMON_INVALID_ARGUMENT);
return_val_if_fail(attribute_name, MM_ERROR_COMMON_INVALID_ARGUMENT);
- attrs = MM_PLAYER_GET_ATTRS(handle);;
+ attrs = MM_PLAYER_GET_ATTRS(handle);
player = MM_PLAYER_CAST(handle);
if ( g_strrstr(attribute_name, "display") )
!player->pipeline->videobin ||
!player->pipeline->videobin[MMPLAYER_V_SINK].gst )
{
- debug_warning("videosink element is not yet ready\n");
+ debug_warning("videosink element is not yet ready");
/*
* The attribute should be committed even though videobin is not created yet.
* So, true should be returned here.
if ( MM_ERROR_NONE != _mmplayer_update_video_param( player ) )
{
- debug_error("failed to update video param\n");
+ debug_error("failed to update video param");
return MM_ERROR_PLAYER_INTERNAL;
}
}
0
},
{
- "display_overlay_ext",
- MM_ATTRS_TYPE_DATA,
- MM_ATTRS_FLAG_RW,
- (void *) NULL,
- MM_ATTRS_VALID_TYPE_NONE,
- 0,
- 0
- },
- {
"display_zoom",
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
"display_surface_type",
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) 0,
+ (void *) MM_DISPLAY_SURFACE_NULL,
MM_ATTRS_VALID_TYPE_INT_RANGE,
MM_DISPLAY_SURFACE_X,
MM_DISPLAY_SURFACE_NULL
},
{
- "display_surface_use_multi",
- MM_ATTRS_TYPE_INT,
- MM_ATTRS_FLAG_RW,
- (void *) FALSE,
- MM_ATTRS_VALID_TYPE_INT_RANGE,
- FALSE,
- TRUE
- },
- {
"display_evas_surface_sink",
MM_ATTRS_TYPE_STRING,
MM_ATTRS_FLAG_READABLE,
g_player_ini.use_decodebin = iniparser_getboolean(dict, "general:use decodebin", DEFAULT_USE_DECODEBIN);
g_player_ini.disable_segtrap = iniparser_getboolean(dict, "general:disable segtrap", DEFAULT_DISABLE_SEGTRAP);
g_player_ini.skip_rescan = iniparser_getboolean(dict, "general:skip rescan", DEFAULT_SKIP_RESCAN);
- g_player_ini.video_surface = DEFAULT_VIDEO_SURFACE;
g_player_ini.generate_dot = iniparser_getboolean(dict, "general:generate dot", DEFAULT_GENERATE_DOT);
g_player_ini.provide_clock= iniparser_getboolean(dict, "general:provide clock", DEFAULT_PROVIDE_CLOCK);
g_player_ini.live_state_change_timeout = iniparser_getint(dict, "general:live state change timeout", DEFAULT_LIVE_STATE_CHANGE_TIMEOUT);
g_player_ini.use_audio_filter_preset = DEFAULT_USE_AUDIO_FILTER_PRESET;
g_player_ini.use_audio_filter_custom = DEFAULT_USE_AUDIO_FILTER_CUSTOM;
g_player_ini.skip_rescan = DEFAULT_SKIP_RESCAN;
- g_player_ini.video_surface = DEFAULT_VIDEO_SURFACE;
strncpy( g_player_ini.videosink_element_x, DEFAULT_VIDEOSINK_X, PLAYER_INI_MAX_STRLEN - 1 );
strncpy( g_player_ini.videosink_element_evas, DEFAULT_VIDEOSINK_EVAS, PLAYER_INI_MAX_STRLEN - 1 );
strncpy( g_player_ini.videosink_element_fake, DEFAULT_VIDEOSINK_FAKE, PLAYER_INI_MAX_STRLEN - 1 );
debug_log("use_audio_filter_custom : %d\n", g_player_ini.use_audio_filter_custom);
debug_log("disable_segtrap : %d\n", g_player_ini.disable_segtrap);
debug_log("skip rescan : %d\n", g_player_ini.skip_rescan);
- debug_log("video surface(0:X, 1:EVAS, 2:GL, 3:NULL) : %d\n", g_player_ini.video_surface);
debug_log("videosink element x: %s\n", g_player_ini.videosink_element_x);
debug_log("videosink element evas: %s\n", g_player_ini.videosink_element_evas);
debug_log("videosink element fake: %s\n", g_player_ini.videosink_element_fake);
---------------------------------------------------------------------------*/
static gboolean __mmplayer_set_state(mm_player_t* player, int state);
static int __mmplayer_get_state(mm_player_t* player);
-static int __mmplayer_gst_create_video_pipeline(mm_player_t* player, GstCaps *caps);
+static int __mmplayer_gst_create_video_pipeline(mm_player_t* player, GstCaps *caps, MMDisplaySurfaceType surface_type);
static int __mmplayer_gst_create_audio_pipeline(mm_player_t* player);
static int __mmplayer_gst_create_text_pipeline(mm_player_t* player);
static int __mmplayer_gst_create_subtitle_pipeline(mm_player_t* player);
static int __mmplayer_check_not_supported_codec(mm_player_t* player, gchar* mime);
static gboolean __mmplayer_configure_audio_callback(mm_player_t* player);
static void __mmplayer_add_sink( mm_player_t* player, GstElement* sink);
+static void __mmplayer_del_sink( mm_player_t* player, GstElement* sink);
static void __mmplayer_release_signal_connection(mm_player_t* player);
static void __mmplayer_set_antishock( mm_player_t* player, gboolean disable_by_force);
static gpointer __mmplayer_repeat_thread(gpointer data);
static gint __gst_transform_gsterror( mm_player_t* player, GstMessage * message, GError* error);
static gboolean __gst_send_event_to_sink( mm_player_t* player, GstEvent* event );
-static int __mmplayer_get_video_frame_from_buffer(mm_player_t* player, GstBuffer *buffer);
static int __mmplayer_set_pcm_extraction(mm_player_t* player);
static gboolean __mmplayer_can_extract_pcm( mm_player_t* player );
static void __mmplayer_add_new_caps(GstPad* pad, GParamSpec* unused, gpointer data);
static void __mmplayer_set_unlinked_mime_type(mm_player_t* player, GstCaps *caps);
-static void __mmplayer_set_videosink_type(mm_player_t* player);
/* util */
const gchar * __get_state_name ( int state );
return TRUE;
}
- /* update player states */
- MMPLAYER_PREV_STATE(player) = MMPLAYER_CURRENT_STATE(player);
- MMPLAYER_CURRENT_STATE(player) = new_state;
- if ( MMPLAYER_CURRENT_STATE(player) == MMPLAYER_PENDING_STATE(player) )
- MMPLAYER_PENDING_STATE(player) = MM_PLAYER_STATE_NONE;
-
/* print state */
MMPLAYER_PRINT_STATE(player);
if (MMPLAYER_TARGET_STATE(player) == new_state)
{
/* fill the message with state of player */
- msg.state.previous = MMPLAYER_PREV_STATE(player);
- msg.state.current = MMPLAYER_CURRENT_STATE(player);
+ msg.state.previous = MMPLAYER_CURRENT_STATE(player);
+ msg.state.current = new_state;
/* state changed by asm callback */
if ( player->sm.by_asm_cb )
debug_log ("intermediate state, do nothing.\n");
return TRUE;
}
-
+
+ /* update player states */
+ MMPLAYER_PREV_STATE(player) = MMPLAYER_CURRENT_STATE(player);
+ MMPLAYER_CURRENT_STATE(player) = new_state;
+ if ( MMPLAYER_CURRENT_STATE(player) == MMPLAYER_PENDING_STATE(player) )
+ MMPLAYER_PENDING_STATE(player) = MM_PLAYER_STATE_NONE;
+
switch ( MMPLAYER_TARGET_STATE(player) )
{
case MM_PLAYER_STATE_NULL:
{
if (player->pipeline->videobin == NULL)
{
- __mmplayer_set_videosink_type(player);
+ /* NOTE : not make videobin because application dose not want to play it even though file has video stream.
+ */
- /* NOTE : not make videobin because application dose not want to play it even though file has video stream.
- */
- if (PLAYER_INI()->video_surface == MM_DISPLAY_SURFACE_NULL)
- {
- debug_log("not make videobin because it dose not want\n");
- goto ERROR;
- }
+ /* get video surface type */
+ int surface_type = 0;
+ mm_attrs_get_int_by_name (player->attrs, "display_surface_type", &surface_type);
+ debug_log("check display surface type attribute: %d", surface_type);
+ if (surface_type == MM_DISPLAY_SURFACE_NULL)
+ {
+ debug_log("not make videobin because it dose not want\n");
+ goto ERROR;
+ }
__ta__("__mmplayer_gst_create_video_pipeline",
- if (MM_ERROR_NONE != __mmplayer_gst_create_video_pipeline(player, caps) )
- {
- debug_error("failed to create videobin. continuing without video\n");
- goto ERROR;
- }
+ if (MM_ERROR_NONE != __mmplayer_gst_create_video_pipeline(player, caps, surface_type) )
+ {
+ debug_error("failed to create videobin. continuing without video\n");
+ goto ERROR;
+ }
)
sinkbin = player->pipeline->videobin[MMPLAYER_V_BIN].gst;
_mmplayer_update_video_param(mm_player_t* player) // @
{
MMHandleType attrs = 0;
- gint videosink_idx_x = 0;
- gint videosink_idx_evas = 0;
+ MMDisplaySurfaceType surface_type = 0;
debug_fenter();
}
/* update display surface */
- __mmplayer_set_videosink_type(player);
+ mm_attrs_get_int_by_name (player->attrs, "display_surface_type", &surface_type);
+ debug_log("check display surface type attribute: %d", surface_type);
/* check video stream callback is used */
if( player->use_video_stream )
return MM_ERROR_NONE;
}
- videosink_idx_x = videosink_idx_evas = MMPLAYER_V_SINK;
-
/* configuring display */
- switch ( PLAYER_INI()->video_surface )
+ switch ( surface_type )
{
case MM_DISPLAY_SURFACE_X:
{
mm_attrs_get_int_by_name(attrs, "display_roi_height", &roi_h);
mm_attrs_get_int_by_name(attrs, "display_visible", &visible);
- g_object_set(player->pipeline->videobin[videosink_idx_x].gst,
+ g_object_set(player->pipeline->videobin[MMPLAYER_V_SINK].gst,
"force-aspect-ratio", force_aspect_ratio,
"zoom", zoom,
"rotate", degree,
mm_attrs_get_int_by_name(attrs, "display_evas_do_scaling", &scaling);
if (object)
{
- g_object_set(player->pipeline->videobin[videosink_idx_evas].gst,
+ g_object_set(player->pipeline->videobin[MMPLAYER_V_SINK].gst,
"evas-object", object,
"visible", visible,
NULL);
mm_attrs_get_int_by_name(attrs, "display_roi_width", &roi_w);
mm_attrs_get_int_by_name(attrs, "display_roi_height", &roi_h);
- g_object_set(player->pipeline->videobin[videosink_idx_evas].gst,
+ g_object_set(player->pipeline->videobin[MMPLAYER_V_SINK].gst,
"force-aspect-ratio", force_aspect_ratio,
"origin-size", origin_size,
"dst-roi-x", roi_x,
*
* @param player [in] handle of player
* caps [in] src caps of decoder
+ * surface_type [in] surface type for video rendering
*
* @return This function returns zero on success.
* @remark
* - evas surface (x86) : videoconvertor ! evasimagesink
*/
static int
-__mmplayer_gst_create_video_pipeline(mm_player_t* player, GstCaps* caps)
+__mmplayer_gst_create_video_pipeline(mm_player_t* player, GstCaps* caps, MMDisplaySurfaceType surface_type)
{
GstPad *pad = NULL;
MMHandleType attrs;
MMPlayerGstElement* first_element = NULL;
MMPlayerGstElement* videobin = NULL;
gchar* vconv_factory = NULL;
- char *videosink_element = NULL;
+ gchar *videosink_element = NULL;
debug_fenter();
videobin[MMPLAYER_V_BIN].gst = gst_bin_new("videobin");
if ( !videobin[MMPLAYER_V_BIN].gst )
{
- debug_critical("failed to create audiobin\n");
+ debug_critical("failed to create videobin");
goto ERROR;
}
if (player->is_nv12_tiled)
{
- if ( ((PLAYER_INI()->video_surface == MM_DISPLAY_SURFACE_EVAS) && !strcmp(PLAYER_INI()->videosink_element_evas, "evasimagesink")) )
+ if ( ((surface_type == MM_DISPLAY_SURFACE_EVAS) && !strcmp(PLAYER_INI()->videosink_element_evas, "evasimagesink")) )
{
vconv_factory = "fimcconvert";
}
#endif
/* set video sink */
- switch (PLAYER_INI()->video_surface)
+ switch (surface_type)
{
case MM_DISPLAY_SURFACE_X:
if (strlen(PLAYER_INI()->videosink_element_x) > 0)
goto ERROR;
}
- MMPLAYER_CREATE_ELEMENT(videobin, MMPLAYER_V_SINK, videosink_element, "videosink", TRUE);
+ MMPLAYER_CREATE_ELEMENT(videobin, MMPLAYER_V_SINK, videosink_element, videosink_element, TRUE);
debug_log("selected videosink name: %s", videosink_element);
}
static int
__mmplayer_gst_create_subtitle_pipeline(mm_player_t* player)
{
- GstBus *bus = NULL;
MMPlayerGstElement* subtitlebin = NULL;
MMHandleType attrs = 0;
gchar *subtitle_uri =NULL;
{
gint timeout = 0;
int ret = MM_ERROR_NONE;
- int i = 0;
debug_fenter();
MMPLAYER_FREEIF( audiobin );
MMPLAYER_FREEIF( videobin );
MMPLAYER_FREEIF( textbin );
+ MMPLAYER_FREEIF( subtitlebin);
MMPLAYER_FREEIF( mainbin );
}
/* Just set state to PAUESED and the rewind. it's usual player behavior. */
timeout = MMPLAYER_STATE_CHANGE_TIMEOUT ( player );
- if ( player->profile.uri_type == MM_PLAYER_URI_TYPE_BUFF )
+ if ( player->profile.uri_type == MM_PLAYER_URI_TYPE_BUFF || player->profile.uri_type == MM_PLAYER_URI_TYPE_HLS)
{
ret = __mmplayer_gst_set_state(player,
player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, GST_STATE_READY, FALSE, timeout );
{
mm_player_t* player = (mm_player_t*) cb_data;
ASM_cb_result_t cb_res = ASM_CB_RES_IGNORE;
- MMHandleType attrs = 0;
int result = MM_ERROR_NONE;
gboolean lazy_pause = FALSE;
return MM_ERROR_NONE;
}
-static
-void __mmplayer_set_videosink_type(mm_player_t* player)
-{
- int type = 0;
-
- debug_fenter();
-
- return_if_fail( player );
-
- mm_attrs_get_int_by_name (player->attrs, "display_surface_type", &type);
-
- debug_log("check display surface attribute: %d\n", type);
-
- if (type >=MM_DISPLAY_SURFACE_X)
- {
- PLAYER_INI()->video_surface = type;
- }
-
- debug_fleave();
-
- return;
-}
-
int
_mmplayer_deactivate_section_repeat(MMHandleType hplayer)
{
debug_fleave();
}
+static void
+__mmplayer_del_sink( mm_player_t* player, GstElement* sink )
+{
+ debug_fenter();
+
+ return_if_fail ( player );
+ return_if_fail ( sink );
+
+ player->sink_elements =
+ g_list_remove(player->sink_elements, sink);
+
+ debug_fleave();
+}
+
static gboolean
__gst_seek(mm_player_t* player, GstElement * element, gdouble rate,
GstFormat format, GstSeekFlags flags, GstSeekType cur_type,
{
debug_fenter();
int result = MM_ERROR_NONE;
- gboolean is_earphone = NULL;
+ mm_sound_device_in device_in;
+ mm_sound_device_out device_out;
int i = 0;
return_val_if_fail ( player, MM_ERROR_PLAYER_NOT_INITIALIZED );
- /* get status if earphone is activated */
- result = mm_sound_is_route_available(MM_SOUND_ROUTE_OUT_WIRED_ACCESSORY, &is_earphone);
+ /* get status if speaker is activated */
+ result = mm_sound_get_active_device(&device_in, &device_out);
if ( result ) {
- debug_error("mm_sound_is_route_available() failed [%x]!!\n", result);
+ debug_error("mm_sound_get_active_device() failed [%x]!!\n", result);
return result;
}
{
for ( i = 0; i < MM_AUDIO_FILTER_PRESET_NUM; i++ )
{
- if (is_earphone) {
- if (PLAYER_INI()->audio_filter_preset_list[i])
+ if (PLAYER_INI()->audio_filter_preset_list[i] )
+ {
+ if (device_out == MM_SOUND_DEVICE_OUT_SPEAKER &&
+ PLAYER_INI()->audio_filter_preset_earphone_only_list[i])
{
- if (!foreach_cb(filter_type, i, user_data))
- {
- goto CALLBACK_ERROR;
- }
+ continue;
}
- }
- else
- {
- if (PLAYER_INI()->audio_filter_preset_list[i] && !PLAYER_INI()->audio_filter_preset_earphone_only_list[i])
+ if (!foreach_cb(filter_type,i, user_data))
{
- if (!foreach_cb(filter_type, i, user_data))
- {
- goto CALLBACK_ERROR;
- }
+ goto CALLBACK_ERROR;
}
-
}
}
}
{
for ( i = 0; i < MM_AUDIO_FILTER_CUSTOM_NUM; i++ )
{
- if (is_earphone)
+ if (PLAYER_INI()->audio_filter_custom_list[i] )
{
- if (PLAYER_INI()->audio_filter_custom_list[i])
+ if (device_out == MM_SOUND_DEVICE_OUT_SPEAKER &&
+ PLAYER_INI()->audio_filter_custom_earphone_only_list[i])
{
- if (!foreach_cb(filter_type, i, user_data))
- {
- goto CALLBACK_ERROR;
- }
+ continue;
}
- }
- else
- {
- if (PLAYER_INI()->audio_filter_custom_list[i] && !PLAYER_INI()->audio_filter_custom_earphone_only_list[i])
+ if (!foreach_cb(filter_type,i, user_data))
{
- if (!foreach_cb(filter_type,i, user_data))
- {
- goto CALLBACK_ERROR;
- }
+ goto CALLBACK_ERROR;
}
}
}
GstElement *filter_element = NULL;
int result = MM_ERROR_NONE;
int output_type = 0;
- bool is_earphone = FALSE;
+ mm_sound_device_in device_in;
+ mm_sound_device_out device_out;
+
debug_fenter();
return_val_if_fail( player, MM_ERROR_PLAYER_NOT_INITIALIZED );
filter_element = player->pipeline->audiobin[MMPLAYER_A_FILTER].gst;
- /* get status if earphone is activated */
- result = mm_sound_is_route_available(MM_SOUND_ROUTE_OUT_WIRED_ACCESSORY, &is_earphone);
+ /* get status if speaker is activated */
+ result = mm_sound_get_active_device(&device_in, &device_out);
if ( result ) {
- debug_error("mm_sound_is_route_available() failed [%x]!!\n", result);
+ debug_error("mm_sound_get_active_device() failed [%x]!!\n", result);
return result;
}
- if (is_earphone)
- {
- output_type = MM_AUDIO_FILTER_OUTPUT_EAR;
- }
- else
+ /* SPEAKER case */
+ if (device_out == MM_SOUND_DEVICE_OUT_SPEAKER)
{
output_type = MM_AUDIO_FILTER_OUTPUT_SPK;
if (__mmplayer_is_earphone_only_filter_type(player, MM_AUDIO_FILTER_TYPE_PRESET, filter_type))
return MM_ERROR_PLAYER_SOUND_EFFECT_INVALID_STATUS;
}
}
+ /* Other case, include WIRED_ACCESSORY, BLUETOOTH, DOCK */
+ else
+ {
+ output_type = MM_AUDIO_FILTER_OUTPUT_EAR;
+ }
/* set filter output mode as SPEAKER or EARPHONE */
g_object_set(filter_element, "filter-output-mode", output_type, NULL);
}
else
{
- int output_type;
- bool is_earphone = FALSE;
+ int output_type = 0;
+ mm_sound_device_in device_in;
+ mm_sound_device_out device_out;
+
return_val_if_fail( player->pipeline->audiobin, MM_ERROR_PLAYER_NOT_INITIALIZED );
filter_element = player->pipeline->audiobin[MMPLAYER_A_FILTER].gst;
- /* get status if earphone is activated */
- result = mm_sound_is_route_available(MM_SOUND_ROUTE_OUT_WIRED_ACCESSORY, &is_earphone);
+ /* get status if speaker is activated */
+ result = mm_sound_get_active_device(&device_in, &device_out);
if ( result ) {
- debug_error("mm_sound_is_route_available() failed [%x]!!\n", result);
+ debug_error("mm_sound_get_active_device() failed [%x]!!\n", result);
return result;
}
- if (is_earphone)
- {
- output_type = MM_AUDIO_FILTER_OUTPUT_EAR;
- }
- else
+ /* SPEAKER case */
+ if (device_out == MM_SOUND_DEVICE_OUT_SPEAKER)
{
output_type = MM_AUDIO_FILTER_OUTPUT_SPK;
if (__mmplayer_is_earphone_only_filter_type(player, MM_AUDIO_FILTER_TYPE_CUSTOM, NULL))
return MM_ERROR_PLAYER_SOUND_EFFECT_INVALID_STATUS;
}
}
+ /* Other case, include WIRED_ACCESSORY, BLUETOOTH, DOCK */
+ else
+ {
+ output_type = MM_AUDIO_FILTER_OUTPUT_EAR;
+ }
/* set filter output mode as SPEAKER or EARPHONE */
g_object_set(filter_element, "filter-output-mode", output_type, NULL);
projects / platform / core / multimedia / libmm-player.git / commitdiff