Name: libmm-radio
Summary: Multimedia Framework Radio Library
-Version: 0.2.8
+Version: 0.2.9
Release: 0
Group: System/Libraries
License: Apache-2.0
* @endcode
*/
-int mm_radio_get_frequency(MMHandleType hradio, int* pFreq);
+int mm_radio_get_frequency(MMHandleType hradio, int *pFreq);
/**
* This function is to start for getting all effective frequencies. \n
*/
int mm_radio_get_channel_spacing(MMHandleType hradio, int *channel_spacing);
+/**
+ * This function is to get volume
+ *
+ * @param hradio [in] Handle of radio.
+ * @param volume [in] volume value (0 ~ 1.0)
+ *
+ * @return This function returns zero on success, or negative value with errors
+ * @pre None
+ * @post None
+ * @see mm_radio_get_volume()
+ */
+int mm_radio_set_volume(MMHandleType hradio, float volume);
+
+/**
+ * This function is to get volume
+ *
+ * @param hradio [in] Handle of radio.
+ * @param pVolume [out] volume value (0 ~ 1.0)
+ *
+ * @return This function returns zero on success, or negative value with errors
+ * @pre None
+ * @post None
+ * @see mm_radio_set_volume()
+ */
+int mm_radio_get_volume(MMHandleType hradio, float *pVolume);
/**
@}
/*---------------------------------------------------------------------------
GLOBAL #defines:
---------------------------------------------------------------------------*/
-#define SAMPLEDELAY 15000
+#define SAMPLEDELAY 15000
/* si470x dependent define */
#define SYSCONFIG1 4 /* System Configuration 1 */
/*---------------------------------------------------------------------------
GLOBAL CONSTANT DEFINITIONS:
---------------------------------------------------------------------------*/
-typedef enum
-{
+typedef enum {
MMRADIO_COMMAND_CREATE = 0,
MMRADIO_COMMAND_DESTROY,
MMRADIO_COMMAND_REALIZE,
MMRADIO_COMMAND_SEEK,
MMRADIO_COMMAND_SET_REGION,
MMRADIO_COMMAND_GET_REGION,
+ MMRADIO_COMMAND_SET_VOLUME,
+ MMRADIO_COMMAND_GET_VOLUME,
MMRADIO_COMMAND_NUM
} MMRadioCommand;
/* max and mix frequency types, KHz */
-typedef enum
-{
+typedef enum {
MM_RADIO_FREQ_NONE = 0,
/* min band types */
MM_RADIO_FREQ_MIN_76100_KHZ = 76100,
/* max band types */
MM_RADIO_FREQ_MAX_89900_KHZ = 89900,
MM_RADIO_FREQ_MAX_108000_KHZ = 108000,
-}MMRadioFreqTypes;
+} MMRadioFreqTypes;
/* de-emphasis types */
-typedef enum
-{
+typedef enum {
MM_RADIO_DEEMPHASIS_NONE = 0,
MM_RADIO_DEEMPHASIS_50_US,
MM_RADIO_DEEMPHASIS_75_US,
-}MMRadioDeemphasis;
+} MMRadioDeemphasis;
/* radio region settings */
-typedef struct
-{
+typedef struct {
MMRadioRegionType country;
MMRadioDeemphasis deemphasis; // unit : us
MMRadioFreqTypes band_min; // <- freq. range, unit : KHz
MMRadioFreqTypes band_max; // ->
int channel_spacing; // TBD
-}MMRadioRegion_t;
+} MMRadioRegion_t;
/*---------------------------------------------------------------------------
GLOBAL DATA TYPE DEFINITIONS:
#define USE_GST_PIPELINE
#ifdef USE_GST_PIPELINE
-typedef struct _mm_radio_gstreamer_s
-{
+typedef struct _mm_radio_gstreamer_s {
GMainLoop *loop;
GstElement *pipeline;
GstElement *audiosrc;
mm_radio_gstreamer_s* pGstreamer_s;
#endif
unsigned int subs_id;
+ float local_volume;
/* region settings */
MMRadioRegion_t region_setting;
/*===========================================================================================
GLOBAL FUNCTION PROTOTYPES
========================================================================================== */
-int _mmradio_create_radio(mm_radio_t* radio);
-int _mmradio_destroy(mm_radio_t* radio);
-int _mmradio_realize(mm_radio_t* radio);
-int _mmradio_unrealize(mm_radio_t* radio);
-int _mmradio_set_message_callback(mm_radio_t* radio, MMMessageCallback callback, void *user_param);
-int _mmradio_get_state(mm_radio_t* radio, int* pState);
-int _mmradio_set_frequency(mm_radio_t* radio, int freq);
-int _mmradio_get_frequency(mm_radio_t* radio, int* pFreq);
-int _mmradio_mute(mm_radio_t* radio);
-int _mmradio_unmute(mm_radio_t* radio);
-int _mmradio_start(mm_radio_t* radio);
-int _mmradio_stop(mm_radio_t* radio);
-int _mmradio_seek(mm_radio_t* radio, MMRadioSeekDirectionType direction);
-int _mmradio_start_scan(mm_radio_t* radio);
-int _mmradio_stop_scan(mm_radio_t* radio);
-int _mm_radio_get_signal_strength(mm_radio_t* radio, int *value);
+int _mmradio_create_radio(mm_radio_t *radio);
+int _mmradio_destroy(mm_radio_t *radio);
+int _mmradio_realize(mm_radio_t *radio);
+int _mmradio_unrealize(mm_radio_t *radio);
+int _mmradio_set_message_callback(mm_radio_t *radio, MMMessageCallback callback, void *user_param);
+int _mmradio_get_state(mm_radio_t *radio, int *pState);
+int _mmradio_set_frequency(mm_radio_t *radio, int freq);
+int _mmradio_get_frequency(mm_radio_t *radio, int *pFreq);
+int _mmradio_mute(mm_radio_t *radio);
+int _mmradio_unmute(mm_radio_t *radio);
+int _mmradio_start(mm_radio_t *radio);
+int _mmradio_stop(mm_radio_t *radio);
+int _mmradio_seek(mm_radio_t *radio, MMRadioSeekDirectionType direction);
+int _mmradio_start_scan(mm_radio_t *radio);
+int _mmradio_stop_scan(mm_radio_t *radio);
+int _mm_radio_get_signal_strength(mm_radio_t *radio, int *strength);
#ifdef USE_GST_PIPELINE
-int _mmradio_realize_pipeline( mm_radio_t* radio);
-int _mmradio_start_pipeline(mm_radio_t* radio);
-int _mmradio_stop_pipeline( mm_radio_t* radio);
-int _mmradio_destroy_pipeline(mm_radio_t* radio);
-#endif
-int _mmradio_apply_region(mm_radio_t*radio, MMRadioRegionType region, bool update);
-int _mmradio_get_region_type(mm_radio_t*radio, MMRadioRegionType *type);
-int _mmradio_get_region_frequency_range(mm_radio_t* radio, unsigned int *min_freq, unsigned int *max_freq);
-int _mmradio_get_channel_spacing(mm_radio_t* radio, unsigned int *ch_spacing);
-
-#if 0
-int mmradio_set_attrs(mm_radio_t* radio, MMRadioAttrsType type, MMHandleType attrs);
-MMHandleType mmradio_get_attrs(mm_radio_t* radio, MMRadioAttrsType type);
+int _mmradio_realize_pipeline( mm_radio_t *radio);
+int _mmradio_start_pipeline(mm_radio_t *radio);
+int _mmradio_stop_pipeline( mm_radio_t *radio);
+int _mmradio_destroy_pipeline(mm_radio_t *radio);
#endif
+int _mmradio_apply_region(mm_radio_t *radio, MMRadioRegionType region, bool update);
+int _mmradio_get_region_type(mm_radio_t *radio, MMRadioRegionType *type);
+int _mmradio_get_region_frequency_range(mm_radio_t *radio, unsigned int *min_freq, unsigned int *max_freq);
+int _mmradio_get_channel_spacing(mm_radio_t *radio, unsigned int *ch_spacing);
+int _mmradio_set_volume(mm_radio_t *radio, float volume);
+int _mmradio_get_volume(mm_radio_t *radio, float *pVolume);
#ifdef __cplusplus
}
MMRADIO_COMMAND_SEEK,
MMRADIO_COMMAND_SET_REGION,
MMRADIO_COMMAND_GET_REGION,
+ MMRADIO_COMMAND_SET_VOLUME,
+ MMRADIO_COMMAND_GET_VOLUME,
MMRADIO_COMMAND_NUM
} MMRadioCommand;
sound_stream_info_h stream_info;
virtual_sound_stream_h vstream;
#endif
+ unsigned int volume_subs_id;
int freq;
+ /* command lock */
+ pthread_mutex_t volume_lock;
+
+ unsigned int max_media_volume;
+ unsigned int media_volume;
+ float local_volume;
+
/* region settings */
MMRadioRegion_t region_setting;
int _mmradio_get_region_type(mm_radio_t*radio, MMRadioRegionType *type);
int _mmradio_get_region_frequency_range(mm_radio_t *radio, unsigned int *min_freq, unsigned int *max_freq);
int _mmradio_get_channel_spacing(mm_radio_t* radio, unsigned int *ch_spacing);
+int _mmradio_set_volume(mm_radio_t *radio, float volume);
+int _mmradio_get_volume(mm_radio_t *radio, float *pVolume);
#ifdef __cplusplus
}
}
/* command locking for multithreading */
-#define MMRADIO_CMD_LOCK(x_radio) pthread_mutex_lock( &((mm_radio_t*)x_radio)->cmd_lock )
-#define MMRADIO_CMD_UNLOCK(x_radio) pthread_mutex_unlock( &((mm_radio_t*)x_radio)->cmd_lock )
+#define MMRADIO_CMD_LOCK(x_radio) pthread_mutex_lock(&((mm_radio_t *)x_radio)->cmd_lock)
+#define MMRADIO_CMD_UNLOCK(x_radio) pthread_mutex_unlock(&((mm_radio_t *)x_radio)->cmd_lock)
+
+#define MMRADIO_VOLUME_LOCK(x_radio) pthread_mutex_lock(&((mm_radio_t *)x_radio)->volume_lock)
+#define MMRADIO_VOLUME_UNLOCK(x_radio) pthread_mutex_unlock(&((mm_radio_t *)x_radio)->volume_lock)
/* message posting */
#define MMRADIO_POST_MSG( x_radio, x_msgtype, x_msg_param ) \
int radio_hal_get_signal_strength(mm_radio_hal_interface *radio_handle, uint32_t *strength);
int radio_hal_mute(mm_radio_hal_interface *radio_handle);
int radio_hal_unmute(mm_radio_hal_interface *radio_handle);
+int radio_hal_set_volume(mm_radio_hal_interface *radio_handle, float volume);
+int radio_hal_get_volume(mm_radio_hal_interface *radio_handle, float *volume);
+
#ifdef __cplusplus
}
#endif
radio_error_t (*mute)(void *radio_handle);
radio_error_t (*unmute)(void *radio_handle);
radio_error_t (*get_signal_strength)(void *radio_handle, uint32_t *strength);
+ radio_error_t (*get_volume)(void *radio_handle, float *volume);
+ radio_error_t (*set_volume)(void *radio_handle, float volume);
} radio_interface_t;
/**
* @brief Initializes new handle of radio HAL.
* @since_tizen 3.0
- * @param[out] radio_handle A newly returned handle to the radio HAL
+ * @param[out] radio_handle A newly returned the radio HAL handle
* @return @c 0 on success, otherwise a negative error value
* @retval #RADIO_ERROR_NONE Successful
* @retval #RADIO_ERROR_INVALID_PARAMETER Invalid parameter
radio_error_t radio_init(void **radio_handle);
/**
- * @brief Deinitializes handle of camera HAL.
+ * @brief Deinitializes handle of radio HAL.
* @since_tizen 3.0
- * @param[in] radio_handle The handle to the radio HAL
+ * @param[in] radio_handle The radio HAL handle
* @return @c 0 on success, otherwise a negative error value
* @retval #RADIO_ERROR_NONE Successful
* @retval #RADIO_ERROR_INVALID_PARAMETER Invalid parameter
/**
* @brief Prepare the device of radio.
* @since_tizen 3.0
- * @param[in] radio_handle The handle to the radio HAL
+ * @param[in] radio_handle The radio HAL handle
* @return @c 0 on success, otherwise a negative error value
* @retval #RADIO_ERROR_NONE Successful
* @retval #RADIO_ERROR_INVALID_PARAMETER Invalid parameter
/**
* @brief Unprepare the device of radio.
* @since_tizen 3.0
- * @param[in] radio_handle The handle to the radio HAL
+ * @param[in] radio_handle The radio HAL handle
* @return @c 0 on success, otherwise a negative error value
* @retval #RADIO_ERROR_NONE Successful
* @retval #RADIO_ERROR_INVALID_PARAMETER Invalid parameter
/**
* @brief Opens the device of radio.
* @since_tizen 3.0
- * @param[in] radio_handle The handle to the radio HAL
+ * @param[in] radio_handle The radio HAL handle
* @return @c 0 on success, otherwise a negative error value
* @retval #RADIO_ERROR_NONE Successful
* @retval #RADIO_ERROR_INVALID_PARAMETER Invalid parameter
/**
* @brief Closes the device of radio.
* @since_tizen 3.0
- * @param[in] radio_handle The handle to the radio HAL
+ * @param[in] radio_handle The radio HAL handle
* @return @c 0 on success, otherwise a negative error value
* @retval #RADIO_ERROR_NONE Successful
* @retval #RADIO_ERROR_INVALID_PARAMETER Invalid parameter
/**
* @brief Starts the device of radio.
* @since_tizen 3.0
- * @param[in] radio_handle The handle to the radio HAL
+ * @param[in] radio_handle The radio HAL handle
* @return @c 0 on success, otherwise a negative error value
* @retval #RADIO_ERROR_NONE Successful
* @retval #RADIO_ERROR_INVALID_PARAMETER Invalid parameter
/**
* @brief Stops the device of radio.
* @since_tizen 3.0
- * @param[in] radio_handle The handle to the radio HAL
+ * @param[in] radio_handle The radio HAL handle
* @return @c 0 on success, otherwise a negative error value
* @retval #RADIO_ERROR_NONE Successful
* @retval #RADIO_ERROR_INVALID_PARAMETER Invalid parameter
/**
* @brief Seeks (up or down) the effective frequency of the radio.
* @since_tizen 3.0
- * @param[in] radio_handle The handle to the radio HAL
+ * @param[in] radio_handle The radio HAL handle
* @param[in] direction The seek direction type (up or down)
* @return @c 0 on success, otherwise a negative error value
* @retval #RADIO_ERROR_NONE Successful
/**
* @brief Gets the radio frequency.
* @since_tizen 3.0
- * @param[in] radio_handle The handle to the radio HAL
+ * @param[in] radio_handle The radio HAL handle
* @param[out] frequency The current frequency (khz)
* @return @c 0 on success, otherwise a negative error value
* @retval #RADIO_ERROR_NONE Successful
/**
* @brief Sets the radio frequency.
* @since_tizen 3.0
- * @param[in] radio_handle The handle to the radio HAL
+ * @param[in] radio_handle The radio HAL handle
* @param[in] frequency The frequency to set (khz)
* @return @c 0 on success, otherwise a negative error value
* @retval #RADIO_ERROR_NONE Successful
/**
* @brief Sets the radio's mute
* @since_tizen 3.0
- * @param[in] radio_handle The handle to the radio HAL
+ * @param[in] radio_handle The radio HAL handle
* @return @c 0 on success, otherwise a negative error value
* @retval #RADIO_ERROR_NONE Successful
* @retval #RADIO_ERROR_INVALID_PARAMETER Invalid parameter
/**
* @brief Unsets the radio's mute
* @since_tizen 3.0
- * @param[in] radio_handle The handle to the radio HAL
+ * @param[in] radio_handle The radio HAL handle
* @return @c 0 on success, otherwise a negative error value
* @retval #RADIO_ERROR_NONE Successful
* @retval #RADIO_ERROR_INVALID_PARAMETER Invalid parameter
/**
* @brief Gets the current signal strength of the radio
* @since_tizen 3.0
- * @param[in] radio_handle The handle to the radio HAL
+ * @param[in] radio_handle The radio HAL handle
* @param[out] strength The current signal strength (dBm)
* @return @c 0 on success, otherwise a negative error value
* @retval #RADIO_ERROR_NONE Successful
radio_error_t radio_get_signal_strength(void *radio_handle, uint32_t *strength);
/**
+ * @brief Gets the radio's current volume.
+ * @since_tizen 3.0
+ * @param[in] radio_handle The radio HAL handle
+ * @param[out] volume The current radio volume (0.0 ~ 1.0)
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #RADIO_ERROR_NONE Successful
+ * @retval #RADIO_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #RADIO_ERROR_INVALID_OPERATION Invalid operation
+ */
+radio_error_t radio_get_volume(void *radio_handle, float *volume);
+
+/**
+ * @brief Sets the current radio's volume.
+ * @since_tizen 3.0
+ * @param[in] radio_handle The radio HAL handle
+ * @param[in] volume The radio volume to set (0.0 ~ 1.0)
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #RADIO_ERROR_NONE Successful
+ * @retval #RADIO_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #RADIO_ERROR_INVALID_OPERATION Invalid operation
+ */
+radio_error_t radio_set_volume(void *radio_handle, float volume);
+
+/**
* @}
*/
MMRADIO_LOG_FLEAVE();
return result;
}
+
+int mm_radio_set_volume(MMHandleType hradio, float volume)
+{
+ int result = MM_ERROR_NONE;
+ mm_radio_t *radio = (mm_radio_t *)hradio;
+
+ MMRADIO_LOG_FENTER();
+
+ return_val_if_fail(radio, MM_ERROR_RADIO_NOT_INITIALIZED);
+
+ MMRADIO_CMD_LOCK(radio);
+
+ result = _mmradio_set_volume(radio, volume);
+
+ MMRADIO_CMD_UNLOCK(radio);
+
+ MMRADIO_LOG_FLEAVE();
+
+ return result;
+}
+
+int mm_radio_get_volume(MMHandleType hradio, float *pVolume)
+{
+ int result = MM_ERROR_NONE;
+ mm_radio_t *radio = (mm_radio_t *)hradio;
+ float volume = 0.0;
+
+ MMRADIO_LOG_FENTER();
+
+ return_val_if_fail(radio, MM_ERROR_RADIO_NOT_INITIALIZED);
+ return_val_if_fail(pVolume, MM_ERROR_INVALID_ARGUMENT);
+
+ MMRADIO_CMD_LOCK(radio);
+
+ result = _mmradio_get_volume(radio, &volume);
+
+ if (result == MM_ERROR_NONE)
+ *pVolume = volume;
+
+ MMRADIO_CMD_UNLOCK(radio);
+
+ MMRADIO_LOG_FLEAVE();
+
+ return result;
+}
+
#define RADIO_DEFAULT_REGION MM_RADIO_REGION_GROUP_USA
#define EMULATOR_FREQ_MAX 5
+#define RADIO_MIN_VOLUME 0.0
+#define RADIO_MAX_VOLUME 1.0
/*---------------------------------------------------------------------------
LOCAL CONSTANT DEFINITIONS:
radio->freq = DEFAULT_FREQ;
memset(&radio->region_setting, 0, sizeof(MMRadioRegion_t));
radio->subs_id = 0;
+ radio->local_volume = 1.0;
/* create command lock */
ret = pthread_mutex_init(&radio->cmd_lock, NULL);
/* set stored frequency */
_mmradio_set_frequency(radio, radio->freq);
+ _mmradio_set_volume(radio, radio->local_volume);
+
/* unmute */
/* if( _mmradio_unmute(radio) != MM_ERROR_NONE) */
/* return MM_ERROR_RADIO_NOT_INITIALIZED; */
g_object_set(radio->pGstreamer_s->audiosrc, "wave", val, "volume", 0.8, NULL);
if (!radio->pGstreamer_s->pipeline || !radio->pGstreamer_s->audiosrc || !radio->pGstreamer_s->queue2 || !radio->pGstreamer_s->volume || !radio->pGstreamer_s->audiosink) {
- MMRADIO_LOG_DEBUG("[%s][%05d] One element could not be created. Exiting.\n", __func__, __LINE__);
+ MMRADIO_LOG_DEBUG("One element could not be created. Exiting.\n");
return MM_ERROR_RADIO_NOT_INITIALIZED;
}
gst_bin_add_many(GST_BIN(radio->pGstreamer_s->pipeline),
- radio->pGstreamer_s->audiosrc,
- radio->pGstreamer_s->queue2,
- radio->pGstreamer_s->volume,
- radio->pGstreamer_s->audiosink,
- NULL);
+ radio->pGstreamer_s->audiosrc,
+ radio->pGstreamer_s->queue2,
+ radio->pGstreamer_s->volume,
+ radio->pGstreamer_s->audiosink,
+ NULL);
if (!gst_element_link_many(
- radio->pGstreamer_s->audiosrc,
- radio->pGstreamer_s->queue2,
- radio->pGstreamer_s->volume,
- radio->pGstreamer_s->audiosink,
- NULL)) {
- MMRADIO_LOG_DEBUG(, "[%s][%05d] Fail to link b/w appsrc and ffmpeg in rotate\n", __func__, __LINE__);
+ radio->pGstreamer_s->audiosrc,
+ radio->pGstreamer_s->queue2,
+ radio->pGstreamer_s->volume,
+ radio->pGstreamer_s->audiosink,
+ NULL)) {
+ MMRADIO_LOG_DEBUG("Fail to link b/w appsrc and ffmpeg in rotate\n");
return MM_ERROR_RADIO_NOT_INITIALIZED;
}
MMRADIO_LOG_FLEAVE();
g_free(radio->pGstreamer_s);
return MM_ERROR_RADIO_INVALID_STATE;
} else {
- MMRADIO_LOG_DEBUG("[%s][%05d] GST_STATE_NULL ret_state = %d (GST_STATE_CHANGE_SUCCESS)\n", __func__, __LINE__, ret_state);
+ MMRADIO_LOG_DEBUG("GST_STATE_NULL ret_state = %d (GST_STATE_CHANGE_SUCCESS)\n", ret_state);
}
MMRADIO_LOG_FLEAVE();
g_free(radio->pGstreamer_s);
return MM_ERROR_RADIO_INVALID_STATE;
} else {
- MMRADIO_LOG_DEBUG("[%s][%05d] GST_STATE_NULL ret_state = %d (GST_STATE_CHANGE_SUCCESS)\n", __func__, __LINE__, ret_state);
+ MMRADIO_LOG_DEBUG("GST_STATE_NULL ret_state = %d (GST_STATE_CHANGE_SUCCESS)\n", ret_state);
}
MMRADIO_LOG_FLEAVE();
return ret;
g_free(radio->pGstreamer_s);
return MM_ERROR_RADIO_INVALID_STATE;
} else {
- MMRADIO_LOG_DEBUG("[%s][%05d] GST_STATE_NULL ret_state = %d (GST_STATE_CHANGE_SUCCESS)\n", __func__, __LINE__, ret_state);
+ MMRADIO_LOG_DEBUG("GST_STATE_NULL ret_state = %d (GST_STATE_CHANGE_SUCCESS)\n", ret_state);
}
gst_object_unref(radio->pGstreamer_s->pipeline);
if (_mmradio_set_frequency(radio, radio->region_setting.band_min) != MM_ERROR_NONE)
goto FINISHED;
- if (radio->old_state == MM_RADIO_STATE_PLAYING) {
+ if (radio->old_state == MM_RADIO_STATE_PLAYING)
_mmradio_mute(radio);
- }
MMRADIO_POST_MSG(radio, MM_MESSAGE_RADIO_SCAN_START, NULL);
MMRADIO_SET_STATE(radio, MM_RADIO_STATE_SCANNING);
MMRADIO_CHECK_INSTANCE(radio);
MMRADIO_LOG_DEBUG("radio state : current : [%d] old : [%d] pending : [%d]\n",
- radio->current_state, radio->old_state, radio->pending_state);
+ radio->current_state, radio->old_state, radio->pending_state);
return radio->current_state;
}
MMRADIO_LOG_FLEAVE();
return val;
}
+
+int _mmradio_set_volume(mm_radio_t *radio, float volume)
+{
+ MMRADIO_LOG_FENTER();
+
+ MMRADIO_CHECK_INSTANCE(radio);
+ MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_SET_VOLUME);
+
+ MMRADIO_SLOG_DEBUG("Setting %f volume", volume);
+
+ if (radio->radio_fd < 0) {
+ MMRADIO_LOG_DEBUG("radio device is not opened yet\n");
+ radio->local_volume = volume;
+ return MM_ERROR_NONE;
+ }
+
+ /* check volume range */
+ if (volume < RADIO_MIN_VOLUME || volume > RADIO_MAX_VOLUME) {
+ MMRADIO_LOG_ERROR("out of volume range");
+ return MM_ERROR_INVALID_ARGUMENT;
+ }
+
+ radio->local_volume = volume;
+
+#ifdef USE_GST_PIPELINE
+ if (radio->pGstreamer_s && radio->pGstreamer_s->volume) {
+ g_object_set(radio->pGstreamer_s->volume, "volume", volume, NULL);
+ MMRADIO_LOG_DEBUG("g_object set volume\n");
+ }
+#endif
+ MMRADIO_LOG_FLEAVE();
+
+ return MM_ERROR_NONE;
+
+}
+int _mmradio_get_volume(mm_radio_t *radio, float *pVolume)
+{
+ MMRADIO_LOG_FENTER();
+
+ MMRADIO_CHECK_INSTANCE(radio);
+ MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_GET_VOLUME);
+
+ return_val_if_fail(pVolume, MM_ERROR_INVALID_ARGUMENT);
+
+ MMRADIO_SLOG_DEBUG("volume : %f\n", radio->local_volume);
+
+ *pVolume = radio->local_volume;
+
+ MMRADIO_LOG_FLEAVE();
+
+ return MM_ERROR_NONE;
+}
+
#include <stdlib.h>
#include <string.h>
#include <math.h>
+#include <float.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <mm_error.h>
#include <mm_debug.h>
#include <mm_message.h>
+#include <mm_sound.h>
#include "mm_radio_priv_hal.h"
#define RADIO_DEFAULT_REGION MM_RADIO_REGION_GROUP_USA
#define READ_MAX_BUFFER_SIZE 1024
+#define DEFAULT_MAX_MEDIA_VOLUME 15
/*---------------------------------------------------------------------------
LOCAL CONSTANT DEFINITIONS:
---------------------------------------------------------------------------*/
const char *additional_info, void *user_data);
#endif
+static void __mmradio_volume_changed_cb(volume_type_t type, unsigned int volume, void *user_data);
+int __mmradio_set_total_volume(mm_radio_t *radio);
+
int _mmradio_apply_region(mm_radio_t *radio, MMRadioRegionType region, bool update)
{
int ret = MM_ERROR_NONE;
memset(&radio->sound_focus, 0, sizeof(mm_radio_sound_focus));
#endif
memset(&radio->region_setting, 0, sizeof(MMRadioRegion_t));
+ radio->local_volume = 1.0;
/* create command lock */
ret = pthread_mutex_init(&radio->cmd_lock, NULL);
return MM_ERROR_RADIO_INTERNAL;
}
+ ret = pthread_mutex_init(&radio->volume_lock, NULL);
+ if (ret) {
+ MMRADIO_LOG_ERROR("volume mutex creation failed\n");
+ return MM_ERROR_RADIO_INTERNAL;
+ }
+
MMRADIO_SET_STATE(radio, MM_RADIO_STATE_NULL);
#ifdef TIZEN_FEATURE_SOUND_FOCUS
{
int ret = MM_ERROR_NONE;
bool update = false;
+ int max = 0;
+ unsigned volume = 0;
MMRadioRegionType region = MM_RADIO_REGION_GROUP_NONE;
MMRADIO_LOG_FENTER();
ret = pthread_mutex_init(&radio->seek_cancel_mutex, NULL);
if (ret < 0) {
MMRADIO_LOG_DEBUG("Mutex creation failed %d", ret);
+ return MM_ERROR_RADIO_INTERNAL;
}
if (radio->region_setting.country == MM_RADIO_REGION_GROUP_NONE) {
return ret;
}
#endif
+
+ ret = sound_manager_get_max_volume(SOUND_TYPE_MEDIA, &max);
+ if (ret != MM_ERROR_NONE) {
+ MMRADIO_LOG_WARNING("sound_manager_get_max_volume error");
+ radio->max_media_volume = DEFAULT_MAX_MEDIA_VOLUME;
+ } else {
+ radio->max_media_volume = max;
+ }
+
+ ret = mm_sound_volume_get_value(VOLUME_TYPE_MEDIA, &volume);
+
+ if (ret != MM_ERROR_NONE)
+ MMRADIO_LOG_WARNING("failed to get MEDIA_VOLUME");
+
+ MMRADIO_VOLUME_LOCK(radio);
+ radio->media_volume = volume;
+ MMRADIO_VOLUME_UNLOCK(radio);
+
+ ret = mm_sound_add_volume_changed_callback(__mmradio_volume_changed_cb, (void *)radio, &radio->volume_subs_id);
+ if (ret != MM_ERROR_NONE)
+ MMRADIO_LOG_WARNING("mm_sound_add_volume_changed_callback error");
+
MMRADIO_SET_STATE(radio, MM_RADIO_STATE_READY);
MMRADIO_LOG_FLEAVE();
MMRADIO_CHECK_INSTANCE(radio);
MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_UNREALIZE);
- ret = radio_hal_unmute(radio->hal_inf);
- if (ret == MM_ERROR_NOT_SUPPORT_API) {
- MMRADIO_LOG_WARNING("radio_hal_unmute is not supported");
- } else if (ret != MM_ERROR_NONE) {
- MMRADIO_LOG_ERROR("radio_hal_unmute error");
- MMRADIO_LOG_FLEAVE();
- return ret;
- }
-
/*Finish if there are scans*/
_mmradio_stop_scan(radio);
MMRADIO_LOG_FLEAVE();
- return MM_ERROR_NONE;
+ return ret;
}
int _mmradio_destroy(mm_radio_t *radio)
int _mmradio_start(mm_radio_t *radio)
{
int ret = MM_ERROR_NONE;
+ unsigned int volume = 0;
MMRADIO_LOG_FENTER();
MMRADIO_LOG_WARNING("radio_hal_prepare is not supported");
} else if (ret != MM_ERROR_NONE) {
MMRADIO_LOG_ERROR("radio_hal_prepare_device error");
- goto error;
+ goto error2;
}
ret = radio_hal_open(radio->hal_inf);
MMRADIO_LOG_WARNING("radio_hal_open is not supported");
} else if (ret != MM_ERROR_NONE) {
MMRADIO_LOG_ERROR("radio_hal_init error");
- goto error;
+ goto error1;
}
radio->is_ready = TRUE;
} else {
MMRADIO_LOG_DEBUG("radio prepared and opened");
}
+ ret = mm_sound_volume_get_value(VOLUME_TYPE_MEDIA, &volume);
+
+ if (ret != MM_ERROR_NONE)
+ MMRADIO_LOG_WARNING("failed to get MEDIA_VOLUME");
+
+ MMRADIO_VOLUME_LOCK(radio);
+ radio->media_volume = volume;
+ MMRADIO_VOLUME_UNLOCK(radio);
+
+ ret = __mmradio_set_total_volume(radio);
+ if (ret == MM_ERROR_NOT_SUPPORT_API) {
+ MMRADIO_LOG_WARNING("radio_hal_start is not supported");
+ } else if (ret) {
+ MMRADIO_LOG_ERROR("failed to radio_hal_start\n");
+ goto error1;
+ }
+
ret = radio_hal_start(radio->hal_inf);
if (ret == MM_ERROR_NOT_SUPPORT_API) {
MMRADIO_LOG_WARNING("radio_hal_start is not supported");
} else if (ret) {
MMRADIO_LOG_ERROR("failed to radio_hal_start\n");
- goto error;
+ goto error1;
}
/* set stored frequency */
ret = radio_hal_set_frequency(radio->hal_inf, radio->freq);
if (ret) {
MMRADIO_LOG_ERROR("failed to radio_hal_set_frequency\n");
- goto error;
+ goto error1;
}
#ifdef TIZEN_FEATURE_SOUND_VSTREAM
return MM_ERROR_NONE;
-error:
#ifdef TIZEN_FEATURE_SOUND_VSTREAM
+error:
sound_manager_stop_virtual_stream(radio->vstream);
#endif
+error1:
radio_hal_close(radio->hal_inf);
+error2:
radio_hal_unprepare(radio->hal_inf);
+ radio->is_ready = FALSE;
return ret;
}
_mmradio_seek_cancel(radio);
#ifdef TIZEN_FEATURE_SOUND_VSTREAM
ret = sound_manager_stop_virtual_stream(radio->vstream);
-#endif
- ret = radio_hal_mute(radio->hal_inf);
- if (ret == MM_ERROR_NOT_SUPPORT_API) {
- MMRADIO_LOG_WARNING("radio_hal_unmute is not supported");
- } else if (ret) {
- MMRADIO_LOG_ERROR("failed to radio_hal_mute\n");
+ if (ret != MM_ERROR_NONE) {
+ MMRADIO_LOG_ERROR("failed to set sound focus");
return ret;
}
+#endif
ret = radio_hal_stop(radio->hal_inf);
if (ret == MM_ERROR_NOT_SUPPORT_API) {
pthread_exit(NULL);
return;
- SEEK_FAILED:
+SEEK_FAILED:
if (radio->seek_unmute) {
/* now turn on radio
case MMRADIO_COMMAND_SET_FREQ:
case MMRADIO_COMMAND_GET_FREQ:
case MMRADIO_COMMAND_SET_REGION:
+ case MMRADIO_COMMAND_SET_VOLUME:
+ case MMRADIO_COMMAND_GET_VOLUME:
{
/* we can do it at any state */
}
}
#endif
+int __mmradio_set_total_volume(mm_radio_t *radio)
+{
+ int ret = MM_ERROR_NONE;
+ float total_volume = 0.0f;
+
+ MMRADIO_CHECK_INSTANCE(radio);
+
+ MMRADIO_VOLUME_LOCK(radio);
+ if (radio->max_media_volume != 0)
+ total_volume = ((float)radio->media_volume / (float)radio->max_media_volume) * radio->local_volume;
+ else
+ MMRADIO_LOG_WARNING("max media voulme is zero");
+
+ ret = radio_hal_set_volume(radio->hal_inf, total_volume);
+ if (ret != MM_ERROR_NONE)
+ MMRADIO_LOG_ERROR("radio_hal_set_volume error");
+
+ MMRADIO_VOLUME_UNLOCK(radio);
+ return ret;
+
+}
+
+static void __mmradio_volume_changed_cb(volume_type_t type, unsigned int volume, void *user_data)
+{
+ mm_radio_t *radio = (mm_radio_t *)user_data;
+ MMRADIO_CHECK_INSTANCE_RETURN_VOID(radio);
+ if (type == VOLUME_TYPE_MEDIA) {
+ MMRADIO_LOG_DEBUG("Change FM Radio volume to %d", volume);
+ MMRADIO_VOLUME_LOCK(radio);
+ radio->media_volume = volume;
+ MMRADIO_VOLUME_UNLOCK(radio);
+ __mmradio_set_total_volume(radio);
+ }
+}
+
int _mmradio_get_region_type(mm_radio_t *radio, MMRadioRegionType *type)
{
MMRADIO_LOG_FENTER();
MMRADIO_LOG_FLEAVE();
return MM_ERROR_NONE;
}
+
+int _mmradio_set_volume(mm_radio_t *radio, float volume)
+{
+ int ret = MM_ERROR_NONE;
+
+ MMRADIO_LOG_FENTER();
+
+ MMRADIO_CHECK_INSTANCE(radio);
+ MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_SET_VOLUME);
+
+ MMRADIO_LOG_DEBUG("Setting %f volume\n", volume);
+
+ MMRADIO_VOLUME_LOCK(radio);
+ radio->local_volume = volume;
+ MMRADIO_VOLUME_UNLOCK(radio);
+
+ ret = __mmradio_set_total_volume(radio);
+
+ MMRADIO_LOG_FLEAVE();
+ return ret;
+
+}
+
+int _mmradio_get_volume(mm_radio_t *radio, float *pVolume)
+{
+ int ret = MM_ERROR_NONE;
+ float total_volume = 0.0;
+ float volume = 0.0;
+ MMRADIO_LOG_FENTER();
+
+ MMRADIO_CHECK_INSTANCE(radio);
+ MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_GET_VOLUME);
+
+ return_val_if_fail(pVolume, MM_ERROR_INVALID_ARGUMENT);
+
+ ret = radio_hal_get_volume(radio->hal_inf, &total_volume);
+ if (ret != MM_ERROR_NONE) {
+ MMRADIO_LOG_ERROR("radio_hal_get_volume error");
+ *pVolume = 0;
+ return ret;
+ }
+
+ MMRADIO_VOLUME_LOCK(radio);
+
+ if (radio->media_volume)
+ volume = total_volume * ((float)radio->max_media_volume / (float)radio->media_volume);
+
+ MMRADIO_LOG_DEBUG("total_volume = %f, max_media_volue = %d, media_volume = %d, volume = %f",
+ total_volume, radio->max_media_volume, radio->media_volume, volume);
+
+ /* update volume in handle */
+ if (fabs(radio->local_volume - volume) >= FLT_EPSILON) {
+ radio->local_volume = volume;
+ }
+
+ *pVolume = (float)radio->local_volume;
+ MMRADIO_VOLUME_UNLOCK(radio);
+
+ MMRADIO_LOG_FLEAVE();
+
+ return ret;
+}
+
switch (code) {
- case RADIO_ERROR_NONE :
+ case RADIO_ERROR_NONE:
ret = MM_ERROR_NONE;
msg = "MM_ERROR_NONE";
break;
- case RADIO_ERROR_INVALID_PARAMETER :
+ case RADIO_ERROR_INVALID_PARAMETER:
ret = MM_ERROR_COMMON_INVALID_ARGUMENT;
msg = "MM_ERROR_COMMON_INVALID_ARGUMENT";
break;
- case RADIO_ERROR_INVALID_STATE :
+ case RADIO_ERROR_INVALID_STATE:
ret = MM_ERROR_RADIO_INVALID_STATE;
msg = "MM_ERROR_RADIO_INVALID_STATE";
break;
- case RADIO_ERROR_OUT_OF_MEMORY :
+ case RADIO_ERROR_OUT_OF_MEMORY:
ret = MM_ERROR_RADIO_NO_FREE_SPACE;
msg = "MM_ERROR_RADIO_NO_FREE_SPACE";
break;
- case RADIO_ERROR_PERMISSION_DENIED :
+ case RADIO_ERROR_PERMISSION_DENIED:
case RADIO_ERROR_DEVICE_NOT_PREPARED :
ret = MM_ERROR_RADIO_PERMISSION_DENIED;
msg = "MM_ERROR_RADIO_PERMISSION_DENIED";
break;
- case RADIO_ERROR_DEVICE_NOT_OPENED :
+ case RADIO_ERROR_DEVICE_NOT_OPENED:
ret = MM_ERROR_RADIO_DEVICE_NOT_OPENED;
msg = "MM_ERROR_RADIO_DEVICE_NOT_OPENED";
break;
- case RADIO_ERROR_NOT_SUPPORTED :
- case RADIO_ERROR_DEVICE_NOT_SUPPORTED :
- case RADIO_ERROR_DEVICE_NOT_FOUND :
+ case RADIO_ERROR_NOT_SUPPORTED:
+ case RADIO_ERROR_DEVICE_NOT_SUPPORTED:
+ case RADIO_ERROR_DEVICE_NOT_FOUND:
ret = MM_ERROR_RADIO_DEVICE_NOT_FOUND;
msg = "MM_ERROR_RADIO_DEVICE_NOT_FOUND";
break;
ret = MM_ERROR_RADIO_NO_ANTENNA;
msg = "MM_ERROR_RADIO_NO_ANTENNA";
break;
- case RADIO_ERROR_UNKNOWN :
- case RADIO_ERROR_INTERNAL :
+ case RADIO_ERROR_UNKNOWN:
+ case RADIO_ERROR_INTERNAL:
default:
ret = MM_ERROR_RADIO_INTERNAL;
msg = "MM_ERROR_RADIO_INTERNAL";
h->intf.mute = dlsym(h->dl_handle, "radio_mute");
h->intf.unmute = dlsym(h->dl_handle, "radio_unmute");
h->intf.get_signal_strength = dlsym(h->dl_handle, "radio_get_signal_strength");
+ h->intf.get_volume = dlsym(h->dl_handle, "radio_get_volume");
+ h->intf.set_volume = dlsym(h->dl_handle, "radio_set_volume");
if (h->intf.init == NULL || h->intf.deinit == NULL) {
MMRADIO_LOG_ERROR("could not get mandatory funtion");
}
+int radio_hal_set_volume(mm_radio_hal_interface *radio_handle, float volume)
+{
+ radio_error_t ret = RADIO_ERROR_NONE;
+ MMRADIO_CHECK_ARG(radio_handle);
+ if (radio_handle->intf.set_volume) {
+ ret = radio_handle->intf.set_volume(radio_handle->rh_handle, volume);
+ if (ret != RADIO_ERROR_NONE)
+ return __convert_error_code(ret, (char *)__FUNCTION__);
+ } else {
+ MMRADIO_LOG_WARNING("radio_hal unmute is NULL");
+ return MM_ERROR_NOT_SUPPORT_API;
+ }
+ return MM_ERROR_NONE;
+
+}
+
+int radio_hal_get_volume(mm_radio_hal_interface *radio_handle, float *volume)
+{
+ radio_error_t ret = RADIO_ERROR_NONE;
+ MMRADIO_CHECK_ARG(radio_handle);
+ if (radio_handle->intf.get_volume) {
+ ret = radio_handle->intf.get_volume(radio_handle->rh_handle, volume);
+ if (ret != RADIO_ERROR_NONE)
+ return __convert_error_code(ret, (char *)__FUNCTION__);
+ } else {
+ MMRADIO_LOG_WARNING("radio_hal unmute is NULL");
+ return MM_ERROR_NOT_SUPPORT_API;
+ }
+ return MM_ERROR_NONE;
+
+}
+
+
#ifdef __cplusplus
}
#endif /* __cplusplus */
projects / platform / core / multimedia / libmm-radio.git / commitdiff