/*===========================================================================================
| |
| INCLUDE FILES |
-| |
+| |
========================================================================================== */
#include <string.h>
/*===========================================================================================
| |
| LOCAL DEFINITIONS AND DECLARATIONS FOR MODULE |
-| |
+| |
========================================================================================== */
/*---------------------------------------------------------------------------
/*===========================================================================
| |
| FUNCTION DEFINITIONS |
-| |
+| |
========================================================================== */
int mm_radio_create(MMHandleType *hradio)
{
int result = MM_ERROR_NONE;
- mm_radio_t* new_radio = NULL;
+ mm_radio_t *new_radio = NULL;
MMRADIO_LOG_FENTER();
return_val_if_fail(hradio, MM_ERROR_RADIO_NOT_INITIALIZED);
-
/* alloc radio structure */
- new_radio = (mm_radio_t*) malloc(sizeof(mm_radio_t));
- if ( ! new_radio )
- {
+ new_radio = (mm_radio_t *)malloc(sizeof(mm_radio_t));
+ if (!new_radio) {
debug_critical("cannot allocate memory for radio\n");
goto ERROR;
}
memset(new_radio, 0, sizeof(mm_radio_t));
/* internal creation stuffs */
- result = _mmradio_create_radio( new_radio );
+ result = _mmradio_create_radio(new_radio);
- if(result != MM_ERROR_NONE)
+ if (result != MM_ERROR_NONE)
goto ERROR;
*hradio = (MMHandleType)new_radio;
ERROR:
- if ( new_radio )
- {
- MMRADIO_FREEIF( new_radio );
- }
+ if (new_radio)
+ MMRADIO_FREEIF(new_radio);
*hradio = (MMHandleType)0;
return result;
}
-int mm_radio_destroy(MMHandleType hradio)
+int mm_radio_destroy(MMHandleType hradio)
{
int result = MM_ERROR_NONE;
- mm_radio_t* radio = (mm_radio_t*)hradio;
+ mm_radio_t *radio = (mm_radio_t *)hradio;
MMRADIO_LOG_FENTER();
return_val_if_fail(radio, MM_ERROR_RADIO_NOT_INITIALIZED);
- result = _mmradio_destroy( radio );
+ result = _mmradio_destroy(radio);
- if ( result != MM_ERROR_NONE )
- {
+ if (result != MM_ERROR_NONE)
debug_error("failed to destroy radio\n");
- }
/* free radio */
- MMRADIO_FREEIF( radio );
-
-
+ MMRADIO_FREEIF(radio);
MMRADIO_LOG_FLEAVE();
int mm_radio_realize(MMHandleType hradio)
{
int result = MM_ERROR_NONE;
- mm_radio_t* radio = (mm_radio_t*)hradio;
+ 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 );
+ MMRADIO_CMD_LOCK(radio);
- result = _mmradio_realize( radio );
+ result = _mmradio_realize(radio);
- MMRADIO_CMD_UNLOCK( radio );
+ MMRADIO_CMD_UNLOCK(radio);
MMRADIO_LOG_FLEAVE();
int mm_radio_unrealize(MMHandleType hradio)
{
int result = MM_ERROR_NONE;
- mm_radio_t* radio = (mm_radio_t*)hradio;
+ mm_radio_t *radio = (mm_radio_t *)hradio;
MMRadioStateType state = 0;
MMRADIO_LOG_FENTER();
mm_radio_get_state((hradio), &state);
MMRADIO_LOG_DEBUG("mm_radio_unrealize state: %d\n", state);
- if(state == MM_RADIO_STATE_SCANNING)
- {
+ if (state == MM_RADIO_STATE_SCANNING)
mm_radio_scan_stop(hradio);
- }
- MMRADIO_CMD_LOCK( radio );
+ MMRADIO_CMD_LOCK(radio);
- result = _mmradio_unrealize( radio );
+ result = _mmradio_unrealize(radio);
- MMRADIO_CMD_UNLOCK( radio );
+ MMRADIO_CMD_UNLOCK(radio);
MMRADIO_LOG_FLEAVE();
int mm_radio_set_message_callback(MMHandleType hradio, MMMessageCallback callback, void *user_param)
{
int result = MM_ERROR_NONE;
- mm_radio_t* radio = (mm_radio_t*)hradio;
+ 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 );
+ MMRADIO_CMD_LOCK(radio);
- result = _mmradio_set_message_callback( radio, callback, user_param );
+ result = _mmradio_set_message_callback(radio, callback, user_param);
- MMRADIO_CMD_UNLOCK( radio );
+ MMRADIO_CMD_UNLOCK(radio);
MMRADIO_LOG_FLEAVE();
return result;
}
-int mm_radio_get_state(MMHandleType hradio, MMRadioStateType* pState)
+int mm_radio_get_state(MMHandleType hradio, MMRadioStateType *pState)
{
int result = MM_ERROR_NONE;
- mm_radio_t* radio = (mm_radio_t*)hradio;
+ mm_radio_t *radio = (mm_radio_t *)hradio;
int state = 0;
MMRADIO_LOG_FENTER();
return_val_if_fail(radio, MM_ERROR_RADIO_NOT_INITIALIZED);
return_val_if_fail(pState, MM_ERROR_COMMON_INVALID_ARGUMENT);
- MMRADIO_CMD_LOCK( radio );
+ MMRADIO_CMD_LOCK(radio);
- result = _mmradio_get_state( radio, &state );
+ result = _mmradio_get_state(radio, &state);
*pState = state;
- MMRADIO_CMD_UNLOCK( radio );
+ MMRADIO_CMD_UNLOCK(radio);
MMRADIO_LOG_FLEAVE();
int mm_radio_start(MMHandleType hradio)
{
int result = MM_ERROR_NONE;
- mm_radio_t* radio = (mm_radio_t*)hradio;
+ 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 );
+ MMRADIO_CMD_LOCK(radio);
- result = _mmradio_start( radio );
+ result = _mmradio_start(radio);
- MMRADIO_CMD_UNLOCK( radio );
+ MMRADIO_CMD_UNLOCK(radio);
MMRADIO_LOG_FLEAVE();
return result;
}
-int mm_radio_stop(MMHandleType hradio)
+int mm_radio_stop(MMHandleType hradio)
{
int result = MM_ERROR_NONE;
- mm_radio_t* radio = (mm_radio_t*)hradio;
+ 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 );
+ MMRADIO_CMD_LOCK(radio);
- result = _mmradio_stop( radio );
+ result = _mmradio_stop(radio);
- MMRADIO_CMD_UNLOCK( radio );
+ MMRADIO_CMD_UNLOCK(radio);
MMRADIO_LOG_FLEAVE();
int mm_radio_seek(MMHandleType hradio, MMRadioSeekDirectionType direction)
{
int result = MM_ERROR_NONE;
- mm_radio_t* radio = (mm_radio_t*)hradio;
+ mm_radio_t *radio = (mm_radio_t *)hradio;
MMRADIO_LOG_FENTER();
return_val_if_fail(radio, MM_ERROR_RADIO_NOT_INITIALIZED);
return_val_if_fail(direction >= MM_RADIO_SEEK_UP && direction <= MM_RADIO_SEEK_DOWN, MM_ERROR_INVALID_ARGUMENT);
- MMRADIO_CMD_LOCK( radio );
+ MMRADIO_CMD_LOCK(radio);
radio->seek_direction = direction;
- result = _mmradio_seek( radio, direction );
+ result = _mmradio_seek(radio, direction);
- MMRADIO_CMD_UNLOCK( radio );
+ MMRADIO_CMD_UNLOCK(radio);
MMRADIO_LOG_FLEAVE();
int mm_radio_set_frequency(MMHandleType hradio, int freq)
{
int result = MM_ERROR_NONE;
- mm_radio_t* radio = (mm_radio_t*)hradio;
+ 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 );
+ MMRADIO_CMD_LOCK(radio);
- result = _mmradio_set_frequency( radio, freq );
+ result = _mmradio_set_frequency(radio, freq);
- MMRADIO_CMD_UNLOCK( radio );
+ MMRADIO_CMD_UNLOCK(radio);
MMRADIO_LOG_FLEAVE();
return result;
}
-int mm_radio_get_frequency(MMHandleType hradio, int* pFreq)
+int mm_radio_get_frequency(MMHandleType hradio, int *pFreq)
{
int result = MM_ERROR_NONE;
- mm_radio_t* radio = (mm_radio_t*)hradio;
+ mm_radio_t *radio = (mm_radio_t *)hradio;
int freq = 0;
MMRADIO_LOG_FENTER();
return_val_if_fail(radio, MM_ERROR_RADIO_NOT_INITIALIZED);
return_val_if_fail(pFreq, MM_ERROR_INVALID_ARGUMENT);
- MMRADIO_CMD_LOCK( radio );
+ MMRADIO_CMD_LOCK(radio);
- result = _mmradio_get_frequency( radio, &freq );
+ result = _mmradio_get_frequency(radio, &freq);
*pFreq = freq;
- MMRADIO_CMD_UNLOCK( radio );
+ MMRADIO_CMD_UNLOCK(radio);
MMRADIO_LOG_FLEAVE();
int mm_radio_scan_start(MMHandleType hradio)
{
int result = MM_ERROR_NONE;
- mm_radio_t* radio = (mm_radio_t*)hradio;
+ 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 );
+ MMRADIO_CMD_LOCK(radio);
- result = _mmradio_start_scan( radio );
+ result = _mmradio_start_scan(radio);
- MMRADIO_CMD_UNLOCK( radio );
+ MMRADIO_CMD_UNLOCK(radio);
MMRADIO_LOG_FLEAVE();
int mm_radio_scan_stop(MMHandleType hradio)
{
int result = MM_ERROR_NONE;
- mm_radio_t* radio = (mm_radio_t*)hradio;
+ 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 );
+ MMRADIO_CMD_LOCK(radio);
- result = _mmradio_stop_scan( radio );
+ result = _mmradio_stop_scan(radio);
- MMRADIO_CMD_UNLOCK( radio );
+ MMRADIO_CMD_UNLOCK(radio);
MMRADIO_LOG_FLEAVE();
int mm_radio_set_mute(MMHandleType hradio, bool muted)
{
int result = MM_ERROR_NONE;
- mm_radio_t* radio = (mm_radio_t*)hradio;
+ mm_radio_t *radio = (mm_radio_t *)hradio;
MMRADIO_LOG_FENTER();
MMRADIO_CMD_LOCK(radio);
if (muted)
- {
result = _mmradio_mute(radio);
- }
else
- {
result = _mmradio_unmute(radio);
- }
MMRADIO_CMD_UNLOCK(radio);
int ret = MM_ERROR_NONE;
- mm_radio_t* radio = (mm_radio_t*)hradio;
+ mm_radio_t *radio = (mm_radio_t *)hradio;
- MMRADIO_CMD_LOCK( radio );
+ MMRADIO_CMD_LOCK(radio);
ret = _mm_radio_get_signal_strength(radio, value);
- MMRADIO_CMD_UNLOCK( radio );
+ MMRADIO_CMD_UNLOCK(radio);
MMRADIO_LOG_DEBUG("signal strength = %d\n", *value);
MMRADIO_LOG_FLEAVE();
return_val_if_fail(type, MM_ERROR_INVALID_ARGUMENT);
int result = MM_ERROR_NONE;
- mm_radio_t* radio = (mm_radio_t*)hradio;
+ mm_radio_t *radio = (mm_radio_t *)hradio;
MMRadioRegionType cur_type = MM_RADIO_REGION_GROUP_NONE;
result = _mmradio_get_region_type(radio, &cur_type);
return result;
}
-int mm_radio_get_region_frequency_range(MMHandleType hradio, unsigned int *min, unsigned int*max)
+int mm_radio_get_region_frequency_range(MMHandleType hradio, unsigned int *min, unsigned int *max)
{
MMRADIO_LOG_FENTER();
return_val_if_fail(min && max, MM_ERROR_INVALID_ARGUMENT);
int result = MM_ERROR_NONE;
- mm_radio_t* radio = (mm_radio_t*)hradio;
+ mm_radio_t *radio = (mm_radio_t *)hradio;
unsigned int min_freq = 0;
unsigned int max_freq = 0;
result = _mmradio_get_region_frequency_range(radio, &min_freq, &max_freq);
- if (result == MM_ERROR_NONE)
- {
+ if (result == MM_ERROR_NONE) {
*min = min_freq;
*max = max_freq;
}
return_val_if_fail(channel_spacing, MM_ERROR_INVALID_ARGUMENT);
int result = MM_ERROR_NONE;
- mm_radio_t* radio = (mm_radio_t*)hradio;
+ mm_radio_t *radio = (mm_radio_t *)hradio;
unsigned int ch_spacing = 0;
result = _mmradio_get_channel_spacing(radio, &ch_spacing);
if (result == MM_ERROR_NONE)
- {
*channel_spacing = ch_spacing;
- }
MMRADIO_LOG_FLEAVE();
return result;
}
-
-
/*===========================================================================================
| |
| INCLUDE FILES |
-| |
+| |
========================================================================================== */
#include <stdbool.h>
#include <stdio.h>
#define FREQ_FRAC 16
#define RADIO_FREQ_FORMAT_SET(x_freq) ((x_freq) * FREQ_FRAC)
#define RADIO_FREQ_FORMAT_GET(x_freq) ((x_freq) / FREQ_FRAC)
-#define DEFAULT_WRAP_AROUND 1 //If non-zero, wrap around when at the end of the frequency range, else stop seeking
+/* If non-zero, wrap around when at the end of the frequency range, else stop seeking */
+#define DEFAULT_WRAP_AROUND 1
-#define RADIO_DEFAULT_REGION MM_RADIO_REGION_GROUP_USA
-#define READ_MAX_BUFFER_SIZE 1024
+#define RADIO_DEFAULT_REGION MM_RADIO_REGION_GROUP_USA
+#define READ_MAX_BUFFER_SIZE 1024
/*---------------------------------------------------------------------------
LOCAL CONSTANT DEFINITIONS:
---------------------------------------------------------------------------*/
LOCAL VARIABLE DEFINITIONS:
---------------------------------------------------------------------------*/
/* radio region configuration table */
-static const MMRadioRegion_t region_table[] =
-{
- { /* Notrh America, South America, South Korea, Taiwan, Australia */
- MM_RADIO_REGION_GROUP_USA, // region type
- MM_RADIO_DEEMPHASIS_75_US, // de-emphasis
- MM_RADIO_FREQ_MIN_87500_KHZ, // min freq.
- MM_RADIO_FREQ_MAX_108000_KHZ, // max freq.
- 50,
- },
- { /* China, Europe, Africa, Middle East, Hong Kong, India, Indonesia, Russia, Singapore */
- MM_RADIO_REGION_GROUP_EUROPE,
- MM_RADIO_DEEMPHASIS_50_US,
- MM_RADIO_FREQ_MIN_87500_KHZ,
- MM_RADIO_FREQ_MAX_108000_KHZ,
- 50,
- },
- {
- MM_RADIO_REGION_GROUP_JAPAN,
- MM_RADIO_DEEMPHASIS_50_US,
- MM_RADIO_FREQ_MIN_76100_KHZ,
- MM_RADIO_FREQ_MAX_89900_KHZ,
- 50,
- },
+static const MMRadioRegion_t region_table[] = {
+ { /* Notrh America, South America, South Korea, Taiwan, Australia */
+ MM_RADIO_REGION_GROUP_USA, /* region type */
+ MM_RADIO_DEEMPHASIS_75_US, /* de-emphasis */
+ MM_RADIO_FREQ_MIN_87500_KHZ, /* min freq. */
+ MM_RADIO_FREQ_MAX_108000_KHZ, /* max freq. */
+ 50,
+ },
+ { /* China, Europe, Africa, Middle East, Hong Kong, India, Indonesia, Russia, Singapore */
+ MM_RADIO_REGION_GROUP_EUROPE,
+ MM_RADIO_DEEMPHASIS_50_US,
+ MM_RADIO_FREQ_MIN_87500_KHZ,
+ MM_RADIO_FREQ_MAX_108000_KHZ,
+ 50,
+ },
+ {
+ MM_RADIO_REGION_GROUP_JAPAN,
+ MM_RADIO_DEEMPHASIS_50_US,
+ MM_RADIO_FREQ_MIN_76100_KHZ,
+ MM_RADIO_FREQ_MAX_89900_KHZ,
+ 50,
+ },
};
+
/*---------------------------------------------------------------------------
LOCAL FUNCTION PROTOTYPES:
---------------------------------------------------------------------------*/
-static bool __mmradio_post_message(mm_radio_t* radio, enum MMMessageType msgtype, MMMessageParamType* param);
-static int __mmradio_check_state(mm_radio_t* radio, MMRadioCommand command);
-static int __mmradio_get_state(mm_radio_t* radio);
-static bool __mmradio_set_state(mm_radio_t* radio, int new_state);
-static void __mmradio_seek_thread(mm_radio_t* radio);
-static void __mmradio_scan_thread(mm_radio_t* radio);
-static bool __is_tunable_frequency(mm_radio_t* radio, int freq);
-static int __mmradio_set_deemphasis(mm_radio_t* radio);
-static int __mmradio_set_band_range(mm_radio_t* radio);
+static bool __mmradio_post_message(mm_radio_t *radio, enum MMMessageType msgtype, MMMessageParamType *param);
+static int __mmradio_check_state(mm_radio_t *radio, MMRadioCommand command);
+static int __mmradio_get_state(mm_radio_t *radio);
+static bool __mmradio_set_state(mm_radio_t *radio, int new_state);
+static void __mmradio_seek_thread(mm_radio_t *radio);
+static void __mmradio_scan_thread(mm_radio_t *radio);
+static bool __is_tunable_frequency(mm_radio_t *radio, int freq);
+static int __mmradio_set_deemphasis(mm_radio_t *radio);
+static int __mmradio_set_band_range(mm_radio_t *radio);
static void __mmradio_sound_focus_cb(int id, mm_sound_focus_type_e focus_type,
- mm_sound_focus_state_e focus_state, const char *reason_for_change,
- const char *additional_info, void *user_data);
+ mm_sound_focus_state_e focus_state, const char *reason_for_change,
+ const char *additional_info, void *user_data);
static void __mmradio_device_connected_cb(MMSoundDevice_t device, bool is_connected, void *user_data);
/*===========================================================================
* Name : _mmradio_apply_region()
* Desc : update radio region information and set values to device
* Param :
- * [in] radio : radio handle
- * [in] region : region type
- * [in] update : update region values or not
+ * [in] radio : radio handle
+ * [in] region : region type
+ * [in] update : update region values or not
* Return : zero on success, or negative value with error code
*---------------------------------------------------------------------------*/
-int
-_mmradio_apply_region(mm_radio_t* radio, MMRadioRegionType region, bool update)
+int _mmradio_apply_region(mm_radio_t *radio, MMRadioRegionType region, bool update)
{
int ret = MM_ERROR_NONE;
int count = 0;
MMRADIO_LOG_FENTER();
- MMRADIO_CHECK_INSTANCE( radio );
- MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_SET_REGION );
+ MMRADIO_CHECK_INSTANCE(radio);
+ MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_SET_REGION);
/* if needed, radio region must be updated.
- * Otherwise, just applying settings to device without it.
- */
- if ( update )
- {
+ * Otherwise, just applying settings to device without it.
+ */
+ if (update) {
count = ARRAY_SIZE(region_table);
- //TODO: if auto is supported...get the region info. here
+ /* TODO: if auto is supported...get the region info. here */
/* update radio region settings */
- for ( index = 0; index < count; index++ )
- {
- /* find the region from pre-defined table*/
- if (region_table[index].country == region)
- {
+ for (index = 0; index < count; index++) {
+ /* find the region from pre-defined table */
+ if (region_table[index].country == region) {
radio->region_setting.country = region_table[index].country;
radio->region_setting.deemphasis = region_table[index].deemphasis;
radio->region_setting.band_min = region_table[index].band_min;
}
}
- /* chech device is opened or not. if it's not ready, skip to apply region to device now*/
- if (radio->radio_fd < 0)
- {
+ /* chech device is opened or not. if it's not ready, skip to apply region to device now */
+ if (radio->radio_fd < 0) {
MMRADIO_LOG_DEBUG("not opened device. just updating region info. \n");
return MM_ERROR_NONE;
}
MMRADIO_LOG_DEBUG("setting region - country: %d, de-emphasis: %d, band range: %d ~ %d KHz\n",
- radio->region_setting.country, radio->region_setting.deemphasis, radio->region_setting.band_min, radio->region_setting.band_max);
+ radio->region_setting.country, radio->region_setting.deemphasis,
+ radio->region_setting.band_min, radio->region_setting.band_max);
/* set de-emphsasis to device */
ret = __mmradio_set_deemphasis(radio);
MMRADIO_CHECK_RETURN_IF_FAIL(ret, "set de-emphasis");
/* set band range to device */
- ret = __mmradio_set_band_range(radio);
+ ret = __mmradio_set_band_range(radio);
MMRADIO_CHECK_RETURN_IF_FAIL(ret, "set band range");
return ret;
}
-int
-_mmradio_create_radio(mm_radio_t* radio)
+int _mmradio_create_radio(mm_radio_t *radio)
{
- int ret = 0;
+ int ret = 0;
MMRADIO_LOG_FENTER();
- MMRADIO_CHECK_INSTANCE( radio );
- MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_CREATE );
+ MMRADIO_CHECK_INSTANCE(radio);
+ MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_CREATE);
/* set default value */
radio->radio_fd = -1;
radio->subs_id = 0;
/* create command lock */
- ret = pthread_mutex_init( &radio->cmd_lock, NULL );
- if ( ret )
- {
+ ret = pthread_mutex_init(&radio->cmd_lock, NULL);
+ if (ret) {
MMRADIO_LOG_ERROR("mutex creation failed\n");
return MM_ERROR_RADIO_INTERNAL;
}
- MMRADIO_SET_STATE( radio, MM_RADIO_STATE_NULL );
+ MMRADIO_SET_STATE(radio, MM_RADIO_STATE_NULL);
/* add device conneted callback */
ret = mm_sound_add_device_connected_callback(MM_SOUND_DEVICE_STATE_ACTIVATED_FLAG,
- (mm_sound_device_connected_cb)__mmradio_device_connected_cb,
- (void *)radio, &radio->subs_id);
- if ( ret )
- {
+ (mm_sound_device_connected_cb)__mmradio_device_connected_cb,
+ (void *)radio, &radio->subs_id);
+ if (ret) {
MMRADIO_LOG_ERROR("mm_sound_add_device_connected_callback is failed\n");
return MM_ERROR_RADIO_INTERNAL;
}
/* register to audio focus */
ret = mmradio_audio_focus_register(&radio->sm, __mmradio_sound_focus_cb, (void *)radio);
- if ( ret )
- {
+ if (ret) {
/* NOTE : we are dealing it as an error since we cannot expect it's behavior */
MMRADIO_LOG_ERROR("mmradio_audio_focus_register is failed\n");
return MM_ERROR_RADIO_INTERNAL;
return MM_ERROR_NONE;
}
-int
-_mmradio_realize(mm_radio_t* radio)
+int _mmradio_realize(mm_radio_t *radio)
{
int ret = MM_ERROR_NONE;
char str_error[READ_MAX_BUFFER_SIZE];
MMRADIO_LOG_FENTER();
- MMRADIO_CHECK_INSTANCE( radio );
- MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_REALIZE );
+ MMRADIO_CHECK_INSTANCE(radio);
+ MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_REALIZE);
/* open radio device */
- if(radio->radio_fd == -1)
- {
+ if (radio->radio_fd == -1) {
MMRadioRegionType region = MM_RADIO_REGION_GROUP_NONE;
bool update = false;
/* open device */
radio->radio_fd = open(DEFAULT_DEVICE, O_RDONLY);
- if (radio->radio_fd < 0)
- {
+ if (radio->radio_fd < 0) {
MMRADIO_LOG_ERROR("failed to open radio device[%s] because of %s(%d)\n",
- DEFAULT_DEVICE, strerror_r(errno, str_error, sizeof(str_error)), errno);
+ DEFAULT_DEVICE, strerror_r(errno, str_error, sizeof(str_error)), errno);
/* check error */
- switch (errno)
- {
- case ENOENT:
- return MM_ERROR_RADIO_DEVICE_NOT_FOUND;
- case EACCES:
- return MM_ERROR_RADIO_PERMISSION_DENIED;
- default:
- return MM_ERROR_RADIO_DEVICE_NOT_OPENED;
+ switch (errno) {
+ case ENOENT:
+ return MM_ERROR_RADIO_DEVICE_NOT_FOUND;
+ case EACCES:
+ return MM_ERROR_RADIO_PERMISSION_DENIED;
+ default:
+ return MM_ERROR_RADIO_DEVICE_NOT_OPENED;
}
}
MMRADIO_LOG_DEBUG("radio device fd : %d\n", radio->radio_fd);
/* query radio device capabilities. */
- if (ioctl(radio->radio_fd, VIDIOC_QUERYCAP, &(radio->vc)) < 0)
- {
+ if (ioctl(radio->radio_fd, VIDIOC_QUERYCAP, &(radio->vc)) < 0) {
MMRADIO_LOG_ERROR("VIDIOC_QUERYCAP failed!\n");
goto error;
}
- if ( ! ( radio->vc.capabilities & V4L2_CAP_TUNER) )
- {
+ if (!(radio->vc.capabilities & V4L2_CAP_TUNER)) {
MMRADIO_LOG_ERROR("this system can't support fm-radio!\n");
goto error;
}
/* set tuner audio mode */
ioctl(radio->radio_fd, VIDIOC_G_TUNER, &(radio->vt));
- if ( ! ( (radio->vt).capability & V4L2_TUNER_CAP_STEREO) )
- {
+ if (!((radio->vt).capability & V4L2_TUNER_CAP_STEREO)) {
MMRADIO_LOG_ERROR("this system can support mono!\n");
(radio->vt).audmode = V4L2_TUNER_MODE_MONO;
- }
- else
- {
+ } else {
(radio->vt).audmode = V4L2_TUNER_MODE_STEREO;
}
ioctl(radio->radio_fd, VIDIOC_S_TUNER, &(radio->vt));
/* check region country type if it's updated or not */
- if ( radio->region_setting.country == MM_RADIO_REGION_GROUP_NONE)
- {
+ if (radio->region_setting.country == MM_RADIO_REGION_GROUP_NONE) {
/* not initialized yet. set it with default region */
region = RADIO_DEFAULT_REGION;
update = true;
- }
- else // already initialized by application
- {
+ } else {
+ /* already initialized by application */
region = radio->region_setting.country;
}
}
/* ready but nosound */
- if( _mmradio_mute(radio) != MM_ERROR_NONE)
+ if (_mmradio_mute(radio) != MM_ERROR_NONE)
goto error;
- MMRADIO_SET_STATE( radio, MM_RADIO_STATE_READY );
+ MMRADIO_SET_STATE(radio, MM_RADIO_STATE_READY);
#ifdef USE_GST_PIPELINE
ret = _mmradio_realize_pipeline(radio);
- if ( ret ) {
+ if (ret) {
debug_error("_mmradio_realize_pipeline is failed\n");
return ret;
}
return MM_ERROR_NONE;
error:
- if (radio->radio_fd >= 0)
- {
+ if (radio->radio_fd >= 0) {
close(radio->radio_fd);
radio->radio_fd = -1;
}
return MM_ERROR_RADIO_INTERNAL;
}
-int
-_mmradio_unrealize(mm_radio_t* radio)
+int _mmradio_unrealize(mm_radio_t *radio)
{
int ret = MM_ERROR_NONE;
MMRADIO_LOG_FENTER();
- MMRADIO_CHECK_INSTANCE( radio );
- MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_UNREALIZE );
+ MMRADIO_CHECK_INSTANCE(radio);
+ MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_UNREALIZE);
- if( _mmradio_mute(radio) != MM_ERROR_NONE)
+ if (_mmradio_mute(radio) != MM_ERROR_NONE)
return MM_ERROR_RADIO_NOT_INITIALIZED;
/* close radio device here !!!! */
- if (radio->radio_fd >= 0)
- {
+ if (radio->radio_fd >= 0) {
close(radio->radio_fd);
radio->radio_fd = -1;
}
- MMRADIO_SET_STATE( radio, MM_RADIO_STATE_NULL );
+ MMRADIO_SET_STATE(radio, MM_RADIO_STATE_NULL);
ret = mmradio_release_audio_focus(&radio->sm);
- if (ret)
- {
+ if (ret) {
MMRADIO_LOG_ERROR("mmradio_release_audio_focus is failed\n");
return ret;
}
#ifdef USE_GST_PIPELINE
- ret= _mmradio_destroy_pipeline(radio);
- if ( ret ) {
+ ret = _mmradio_destroy_pipeline(radio);
+ if (ret) {
debug_error("_mmradio_destroy_pipeline is failed\n");
return ret;
}
return MM_ERROR_NONE;
}
-int
-_mmradio_destroy(mm_radio_t* radio)
+int _mmradio_destroy(mm_radio_t *radio)
{
int ret = 0;
MMRADIO_LOG_FENTER();
- MMRADIO_CHECK_INSTANCE( radio );
- MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_DESTROY );
+ MMRADIO_CHECK_INSTANCE(radio);
+ MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_DESTROY);
ret = mmradio_audio_focus_deregister(&radio->sm);
- if ( ret )
- {
+ if (ret) {
MMRADIO_LOG_ERROR("failed to deregister audio focus\n");
return MM_ERROR_RADIO_INTERNAL;
}
ret = mm_sound_remove_device_connected_callback(radio->subs_id);
- if ( ret )
- {
+ if (ret) {
MMRADIO_LOG_ERROR("mm_sound_remove_device_connected_callback error %d\n", ret);
return MM_ERROR_RADIO_INTERNAL;
}
- _mmradio_unrealize( radio );
+ _mmradio_unrealize(radio);
MMRADIO_LOG_FLEAVE();
return MM_ERROR_NONE;
}
-
-int
-_mmradio_set_frequency(mm_radio_t* radio, int freq) // unit should be KHz
+/* unit should be KHz */
+int _mmradio_set_frequency(mm_radio_t *radio, int freq)
{
MMRADIO_LOG_FENTER();
- MMRADIO_CHECK_INSTANCE( radio );
- MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_SET_FREQ );
+ MMRADIO_CHECK_INSTANCE(radio);
+ MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_SET_FREQ);
MMRADIO_LOG_DEBUG("Setting %d frequency\n", freq);
radio->freq = freq;
- if (radio->radio_fd < 0)
- {
+ if (radio->radio_fd < 0) {
MMRADIO_LOG_DEBUG("radio device is not opened yet\n");
return MM_ERROR_NONE;
}
/* check frequency range */
- if ( freq < radio->region_setting.band_min
- || freq > radio->region_setting.band_max )
- {
+ if (freq < radio->region_setting.band_min || freq > radio->region_setting.band_max) {
MMRADIO_LOG_ERROR("out of frequency range\n", freq);
return MM_ERROR_INVALID_ARGUMENT;
}
(radio->vf).tuner = 0;
(radio->vf).frequency = RADIO_FREQ_FORMAT_SET(freq);
- if(ioctl(radio->radio_fd, VIDIOC_S_FREQUENCY, &(radio->vf))< 0)
- {
+ if (ioctl(radio->radio_fd, VIDIOC_S_FREQUENCY, &(radio->vf)) < 0)
return MM_ERROR_RADIO_NOT_INITIALIZED;
- }
MMRADIO_LOG_FLEAVE();
}
-int
-_mmradio_get_frequency(mm_radio_t* radio, int* pFreq)
+int _mmradio_get_frequency(mm_radio_t *radio, int *pFreq)
{
int freq = 0;
MMRADIO_LOG_FENTER();
- MMRADIO_CHECK_INSTANCE( radio );
- MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_GET_FREQ );
+ MMRADIO_CHECK_INSTANCE(radio);
+ MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_GET_FREQ);
- return_val_if_fail( pFreq, MM_ERROR_INVALID_ARGUMENT );
+ return_val_if_fail(pFreq, MM_ERROR_INVALID_ARGUMENT);
/* just return stored frequency if radio device is not ready */
- if ( radio->radio_fd < 0 )
- {
+ if (radio->radio_fd < 0) {
MMRADIO_LOG_DEBUG("freq : %d\n", radio->freq);
*pFreq = radio->freq;
return MM_ERROR_NONE;
}
- if (ioctl(radio->radio_fd, VIDIOC_G_FREQUENCY, &(radio->vf)) < 0)
- {
+ if (ioctl(radio->radio_fd, VIDIOC_G_FREQUENCY, &(radio->vf)) < 0) {
MMRADIO_LOG_ERROR("failed to do VIDIOC_G_FREQUENCY\n");
return MM_ERROR_RADIO_INTERNAL;
}
return MM_ERROR_NONE;
}
-int
-_mmradio_mute(mm_radio_t* radio)
+int _mmradio_mute(mm_radio_t *radio)
{
MMRADIO_LOG_FENTER();
- MMRADIO_CHECK_INSTANCE( radio );
- MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_MUTE );
+ MMRADIO_CHECK_INSTANCE(radio);
+ MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_MUTE);
if (radio->radio_fd < 0)
- {
return MM_ERROR_RADIO_NOT_INITIALIZED;
- }
(radio->vctrl).id = V4L2_CID_AUDIO_MUTE;
- (radio->vctrl).value = 1; //mute
+ /* mute */
+ (radio->vctrl).value = 1;
if (ioctl(radio->radio_fd, VIDIOC_S_CTRL, &(radio->vctrl)) < 0)
- {
return MM_ERROR_RADIO_NOT_INITIALIZED;
- }
MMRADIO_LOG_FLEAVE();
}
-int
-_mmradio_unmute(mm_radio_t* radio)
+int _mmradio_unmute(mm_radio_t *radio)
{
MMRADIO_LOG_FENTER();
- MMRADIO_CHECK_INSTANCE( radio );
- MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_UNMUTE );
- MMRADIO_CHECK_DEVICE_STATE( radio );
+ MMRADIO_CHECK_INSTANCE(radio);
+ MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_UNMUTE);
+ MMRADIO_CHECK_DEVICE_STATE(radio);
(radio->vctrl).id = V4L2_CID_AUDIO_MUTE;
- (radio->vctrl).value = 0; //unmute
+ /* unmute */
+ (radio->vctrl).value = 0;
if (ioctl(radio->radio_fd, VIDIOC_S_CTRL, &(radio->vctrl)) < 0)
- {
return MM_ERROR_RADIO_NOT_INITIALIZED;
- }
MMRADIO_LOG_FLEAVE();
* [in] radio : radio handle
* Return : zero on success, or negative value with error code
*---------------------------------------------------------------------------*/
-int
-__mmradio_set_deemphasis(mm_radio_t* radio)
+int __mmradio_set_deemphasis(mm_radio_t *radio)
{
int value = 0;
MMRADIO_LOG_FENTER();
- MMRADIO_CHECK_INSTANCE( radio );
+ MMRADIO_CHECK_INSTANCE(radio);
/* get de-emphasis */
- switch (radio->region_setting.deemphasis)
- {
- case MM_RADIO_DEEMPHASIS_50_US:
- value = 1;//V4L2_DEEMPHASIS_50_uS;
- break;
+ switch (radio->region_setting.deemphasis) {
+ case MM_RADIO_DEEMPHASIS_50_US:
+ /* V4L2_DEEMPHASIS_50_uS; */
+ value = 1;
+ break;
- case MM_RADIO_DEEMPHASIS_75_US:
- value = 2;//V4L2_DEEMPHASIS_75_uS;
- break;
+ case MM_RADIO_DEEMPHASIS_75_US:
+ /* V4L2_DEEMPHASIS_75_uS; */
+ value = 2;
+ break;
- default:
- MMRADIO_LOG_ERROR("not availabe de-emphasis value\n");
- return MM_ERROR_COMMON_INVALID_ARGUMENT;
+ default:
+ MMRADIO_LOG_ERROR("not availabe de-emphasis value\n");
+ return MM_ERROR_COMMON_INVALID_ARGUMENT;
}
/* set it to device */
- (radio->vctrl).id = (0x009d0000 | 0x900) +1;//V4L2_CID_TUNE_DEEMPHASIS;
+ /* V4L2_CID_TUNE_DEEMPHASIS; */
+ (radio->vctrl).id = (0x009d0000 | 0x900) + 1;
(radio->vctrl).value = value;
- if (ioctl(radio->radio_fd, VIDIOC_S_CTRL, &(radio->vctrl)) < 0)
- {
+ if (ioctl(radio->radio_fd, VIDIOC_S_CTRL, &(radio->vctrl)) < 0) {
MMRADIO_LOG_ERROR("failed to set de-emphasis\n");
return MM_ERROR_RADIO_INTERNAL;
}
* [in] radio : radio handle
* Return : zero on success, or negative value with error code
*---------------------------------------------------------------------------*/
-int
-__mmradio_set_band_range(mm_radio_t* radio)
+int __mmradio_set_band_range(mm_radio_t *radio)
{
MMRADIO_LOG_FENTER();
- MMRADIO_CHECK_INSTANCE( radio );
+ MMRADIO_CHECK_INSTANCE(radio);
/* get min and max freq. */
(radio->vt).rangelow = RADIO_FREQ_FORMAT_SET(radio->region_setting.band_min);
(radio->vt).rangehigh = RADIO_FREQ_FORMAT_SET(radio->region_setting.band_max);
/* set it to device */
- if (ioctl(radio->radio_fd, VIDIOC_S_TUNER, &(radio->vt)) < 0 )
- {
+ if (ioctl(radio->radio_fd, VIDIOC_S_TUNER, &(radio->vt)) < 0) {
MMRADIO_LOG_ERROR("failed to set band range\n");
return MM_ERROR_RADIO_INTERNAL;
}
return MM_ERROR_NONE;
}
-int
-_mmradio_set_message_callback(mm_radio_t* radio, MMMessageCallback callback, void *user_param)
+int _mmradio_set_message_callback(mm_radio_t *radio, MMMessageCallback callback, void *user_param)
{
MMRADIO_LOG_FENTER();
- MMRADIO_CHECK_INSTANCE( radio );
+ MMRADIO_CHECK_INSTANCE(radio);
radio->msg_cb = callback;
radio->msg_cb_param = user_param;
- MMRADIO_LOG_DEBUG("msg_cb : 0x%x msg_cb_param : 0x%x\n", (unsigned int)callback, (unsigned int)user_param);
+ MMRADIO_LOG_DEBUG("msg_cb : 0x%x msg_cb_param : 0x%x\n",
+ (unsigned int)callback, (unsigned int)user_param);
MMRADIO_LOG_FLEAVE();
return MM_ERROR_NONE;
}
-int
-_mmradio_get_state(mm_radio_t* radio, int* pState)
+int _mmradio_get_state(mm_radio_t *radio, int *pState)
{
int state = 0;
MMRADIO_LOG_FENTER();
- MMRADIO_CHECK_INSTANCE( radio );
- return_val_if_fail( pState, MM_ERROR_INVALID_ARGUMENT );
+ MMRADIO_CHECK_INSTANCE(radio);
+ return_val_if_fail(pState, MM_ERROR_INVALID_ARGUMENT);
- state = __mmradio_get_state( radio );
+ state = __mmradio_get_state(radio);
*pState = state;
return MM_ERROR_NONE;
}
-int
-_mmradio_start(mm_radio_t* radio)
+int _mmradio_start(mm_radio_t *radio)
{
int ret = MM_ERROR_NONE;
MMRADIO_LOG_FENTER();
- MMRADIO_CHECK_INSTANCE( radio );
- MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_START );
+ MMRADIO_CHECK_INSTANCE(radio);
+ MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_START);
MMRADIO_LOG_DEBUG("now tune to frequency : %d\n", radio->freq);
ret = mmradio_acquire_audio_focus(&radio->sm);
- if ( ret )
- {
+ if (ret) {
MMRADIO_LOG_ERROR("failed to set audio focus\n");
return ret;
}
/* set stored frequency */
- _mmradio_set_frequency( radio, radio->freq );
+ _mmradio_set_frequency(radio, radio->freq);
/* unmute */
- if( _mmradio_unmute(radio) != MM_ERROR_NONE)
+ if (_mmradio_unmute(radio) != MM_ERROR_NONE)
return MM_ERROR_RADIO_NOT_INITIALIZED;
- MMRADIO_SET_STATE( radio, MM_RADIO_STATE_PLAYING );
+ MMRADIO_SET_STATE(radio, MM_RADIO_STATE_PLAYING);
#ifdef USE_GST_PIPELINE
- ret = _mmradio_start_pipeline( radio );
- if ( ret ) {
+ ret = _mmradio_start_pipeline(radio);
+ if (ret) {
debug_error("_mmradio_start_pipeline is failed\n");
return ret;
}
return ret;
}
-int
-_mmradio_stop(mm_radio_t* radio)
+int _mmradio_stop(mm_radio_t *radio)
{
int ret = MM_ERROR_NONE;
MMRADIO_LOG_FENTER();
- MMRADIO_CHECK_INSTANCE( radio );
- MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_STOP );
+ MMRADIO_CHECK_INSTANCE(radio);
+ MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_STOP);
- if( _mmradio_mute(radio) != MM_ERROR_NONE)
+ if (_mmradio_mute(radio) != MM_ERROR_NONE)
return MM_ERROR_RADIO_NOT_INITIALIZED;
- MMRADIO_SET_STATE( radio, MM_RADIO_STATE_READY );
+ MMRADIO_SET_STATE(radio, MM_RADIO_STATE_READY);
#ifdef USE_GST_PIPELINE
- ret= _mmradio_stop_pipeline( radio );
- if ( ret ) {
+ ret = _mmradio_stop_pipeline(radio);
+ if (ret) {
debug_error("_mmradio_stop_pipeline is failed\n");
return ret;
}
}
#ifdef USE_GST_PIPELINE
-int
-_mmradio_realize_pipeline(mm_radio_t* radio)
+int _mmradio_realize_pipeline(mm_radio_t *radio)
{
int ret = MM_ERROR_NONE;
- gst_init (NULL, NULL);
- radio->pGstreamer_s = g_new0 (mm_radio_gstreamer_s, 1);
+ gst_init(NULL, NULL);
+ radio->pGstreamer_s = g_new0(mm_radio_gstreamer_s, 1);
- radio->pGstreamer_s->pipeline= gst_pipeline_new ("fmradio");
+ radio->pGstreamer_s->pipeline = gst_pipeline_new("fmradio");
- radio->pGstreamer_s->audiosrc= gst_element_factory_make("pulsesrc","fm audio src");
- radio->pGstreamer_s->queue2= gst_element_factory_make("queue2","queue2");
- radio->pGstreamer_s->audiosink= gst_element_factory_make("pulsesink","audio sink");
+ radio->pGstreamer_s->audiosrc = gst_element_factory_make("pulsesrc", "fm audio src");
+ radio->pGstreamer_s->queue2 = gst_element_factory_make("queue2", "queue2");
+ radio->pGstreamer_s->audiosink = gst_element_factory_make("pulsesink", "audio sink");
-// g_object_set(radio->pGstreamer_s->audiosrc, "latency", 2, NULL);
+ /* g_object_set(radio->pGstreamer_s->audiosrc, "latency", 2, NULL); */
g_object_set(radio->pGstreamer_s->audiosink, "sync", false, NULL);
- if (!radio->pGstreamer_s->pipeline || !radio->pGstreamer_s->audiosrc || !radio->pGstreamer_s->queue2 || !radio->pGstreamer_s->audiosink) {
+ if (!radio->pGstreamer_s->pipeline || !radio->pGstreamer_s->audiosrc ||
+ !radio->pGstreamer_s->queue2 || !radio->pGstreamer_s->audiosink) {
debug_error("[%s][%05d] One element could not be created. Exiting.\n", __func__, __LINE__);
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->audiosink,
- NULL);
- if(!gst_element_link_many(
- radio->pGstreamer_s->audiosrc,
- radio->pGstreamer_s->queue2,
- radio->pGstreamer_s->audiosink,
- NULL)) {
+ radio->pGstreamer_s->audiosrc, radio->pGstreamer_s->queue2,
+ radio->pGstreamer_s->audiosink, NULL);
+ if (!gst_element_link_many(radio->pGstreamer_s->audiosrc,
+ radio->pGstreamer_s->queue2, radio->pGstreamer_s->audiosink, NULL)) {
debug_error("[%s][%05d] Fail to link b/w appsrc and ffmpeg in rotate\n", __func__, __LINE__);
return MM_ERROR_RADIO_NOT_INITIALIZED;
}
return ret;
}
-int
-_mmradio_start_pipeline(mm_radio_t* radio)
+int _mmradio_start_pipeline(mm_radio_t *radio)
{
int ret = MM_ERROR_NONE;
GstStateChangeReturn ret_state;
debug_log("\n");
- if(gst_element_set_state (radio->pGstreamer_s->pipeline, GST_STATE_PLAYING) == GST_STATE_CHANGE_FAILURE) {
+ if (gst_element_set_state(radio->pGstreamer_s->pipeline, GST_STATE_PLAYING) == GST_STATE_CHANGE_FAILURE) {
debug_error("Fail to change pipeline state");
- gst_object_unref (radio->pGstreamer_s->pipeline);
- g_free (radio->pGstreamer_s);
+ gst_object_unref(radio->pGstreamer_s->pipeline);
+ g_free(radio->pGstreamer_s);
return MM_ERROR_RADIO_INVALID_STATE;
}
- ret_state = gst_element_get_state (radio->pGstreamer_s->pipeline, NULL, NULL, GST_CLOCK_TIME_NONE);
+ ret_state = gst_element_get_state(radio->pGstreamer_s->pipeline, NULL, NULL, GST_CLOCK_TIME_NONE);
if (ret_state == GST_STATE_CHANGE_FAILURE) {
debug_error("GST_STATE_CHANGE_FAILURE");
- gst_object_unref (radio->pGstreamer_s->pipeline);
- g_free (radio->pGstreamer_s);
+ gst_object_unref(radio->pGstreamer_s->pipeline);
+ g_free(radio->pGstreamer_s);
return MM_ERROR_RADIO_INVALID_STATE;
} else {
debug_log("[%s][%05d] GST_STATE_NULL ret_state = %d (GST_STATE_CHANGE_SUCCESS)\n", __func__, __LINE__, ret_state);
return ret;
}
-int
-_mmradio_stop_pipeline(mm_radio_t* radio)
+int _mmradio_stop_pipeline(mm_radio_t *radio)
{
int ret = MM_ERROR_NONE;
GstStateChangeReturn ret_state;
debug_log("\n");
- if(gst_element_set_state (radio->pGstreamer_s->pipeline, GST_STATE_READY) == GST_STATE_CHANGE_FAILURE) {
+ if (gst_element_set_state(radio->pGstreamer_s->pipeline, GST_STATE_READY) == GST_STATE_CHANGE_FAILURE) {
debug_error("Fail to change pipeline state");
- gst_object_unref (radio->pGstreamer_s->pipeline);
- g_free (radio->pGstreamer_s);
+ gst_object_unref(radio->pGstreamer_s->pipeline);
+ g_free(radio->pGstreamer_s);
return MM_ERROR_RADIO_INVALID_STATE;
}
- ret_state = gst_element_get_state (radio->pGstreamer_s->pipeline, NULL, NULL, GST_CLOCK_TIME_NONE);
+ ret_state = gst_element_get_state(radio->pGstreamer_s->pipeline, NULL, NULL, GST_CLOCK_TIME_NONE);
if (ret_state == GST_STATE_CHANGE_FAILURE) {
debug_error("GST_STATE_CHANGE_FAILURE");
- gst_object_unref (radio->pGstreamer_s->pipeline);
- g_free (radio->pGstreamer_s);
+ gst_object_unref(radio->pGstreamer_s->pipeline);
+ g_free(radio->pGstreamer_s);
return MM_ERROR_RADIO_INVALID_STATE;
} else {
debug_log("[%s][%05d] GST_STATE_NULL ret_state = %d (GST_STATE_CHANGE_SUCCESS)\n", __func__, __LINE__, ret_state);
return ret;
}
-int
-_mmradio_destroy_pipeline(mm_radio_t * radio)
+int _mmradio_destroy_pipeline(mm_radio_t *radio)
{
int ret = 0;
GstStateChangeReturn ret_state;
debug_log("\n");
- if(gst_element_set_state (radio->pGstreamer_s->pipeline, GST_STATE_NULL) == GST_STATE_CHANGE_FAILURE) {
+ if (gst_element_set_state(radio->pGstreamer_s->pipeline, GST_STATE_NULL) == GST_STATE_CHANGE_FAILURE) {
debug_error("Fail to change pipeline state");
- gst_object_unref (radio->pGstreamer_s->pipeline);
- g_free (radio->pGstreamer_s);
+ gst_object_unref(radio->pGstreamer_s->pipeline);
+ g_free(radio->pGstreamer_s);
return MM_ERROR_RADIO_INVALID_STATE;
}
- ret_state = gst_element_get_state (radio->pGstreamer_s->pipeline, NULL, NULL, GST_CLOCK_TIME_NONE);
+ ret_state = gst_element_get_state(radio->pGstreamer_s->pipeline, NULL, NULL, GST_CLOCK_TIME_NONE);
if (ret_state == GST_STATE_CHANGE_FAILURE) {
debug_error("GST_STATE_CHANGE_FAILURE");
- gst_object_unref (radio->pGstreamer_s->pipeline);
- g_free (radio->pGstreamer_s);
+ gst_object_unref(radio->pGstreamer_s->pipeline);
+ g_free(radio->pGstreamer_s);
return MM_ERROR_RADIO_INVALID_STATE;
} else {
debug_log("[%s][%05d] GST_STATE_NULL ret_state = %d (GST_STATE_CHANGE_SUCCESS)\n", __func__, __LINE__, ret_state);
}
- gst_object_unref (radio->pGstreamer_s->pipeline);
- g_free (radio->pGstreamer_s);
+ gst_object_unref(radio->pGstreamer_s->pipeline);
+ g_free(radio->pGstreamer_s);
return ret;
}
#endif
-int
-_mmradio_seek(mm_radio_t* radio, MMRadioSeekDirectionType direction)
+int _mmradio_seek(mm_radio_t *radio, MMRadioSeekDirectionType direction)
{
MMRADIO_LOG_FENTER();
- MMRADIO_CHECK_INSTANCE( radio );
- MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_SEEK );
+ MMRADIO_CHECK_INSTANCE(radio);
+ MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_SEEK);
- int ret = 0;
+ int ret = 0;
- if( _mmradio_mute(radio) != MM_ERROR_NONE)
+ if (_mmradio_mute(radio) != MM_ERROR_NONE)
return MM_ERROR_RADIO_NOT_INITIALIZED;
MMRADIO_LOG_DEBUG("trying to seek. direction[0:UP/1:DOWN) %d\n", direction);
radio->seek_direction = direction;
- ret = pthread_create(&radio->seek_thread, NULL,
- (void *)__mmradio_seek_thread, (void *)radio);
+ ret = pthread_create(&radio->seek_thread, NULL, (void *)__mmradio_seek_thread, (void *)radio);
- if ( ret )
- {
+ if (ret) {
MMRADIO_LOG_DEBUG("failed create thread\n");
return MM_ERROR_RADIO_INTERNAL;
}
return MM_ERROR_NONE;
}
-int
-_mmradio_start_scan(mm_radio_t* radio)
+int _mmradio_start_scan(mm_radio_t *radio)
{
MMRADIO_LOG_FENTER();
- MMRADIO_CHECK_INSTANCE( radio );
- MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_START_SCAN );
+ MMRADIO_CHECK_INSTANCE(radio);
+ MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_START_SCAN);
int scan_tr_id = 0;
radio->stop_scan = false;
- scan_tr_id = pthread_create(&radio->scan_thread, NULL,
- (void *)__mmradio_scan_thread, (void *)radio);
+ scan_tr_id = pthread_create(&radio->scan_thread, NULL, (void *)__mmradio_scan_thread, (void *)radio);
- if (scan_tr_id != 0)
- {
+ if (scan_tr_id != 0) {
MMRADIO_LOG_DEBUG("failed to create thread : scan\n");
return MM_ERROR_RADIO_NOT_INITIALIZED;
}
- MMRADIO_SET_STATE( radio, MM_RADIO_STATE_SCANNING );
+ MMRADIO_SET_STATE(radio, MM_RADIO_STATE_SCANNING);
MMRADIO_LOG_FLEAVE();
return MM_ERROR_NONE;
}
-int
-_mmradio_stop_scan(mm_radio_t* radio)
+int _mmradio_stop_scan(mm_radio_t *radio)
{
MMRADIO_LOG_FENTER();
- MMRADIO_CHECK_INSTANCE( radio );
- MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_STOP_SCAN );
+ MMRADIO_CHECK_INSTANCE(radio);
+ MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_STOP_SCAN);
radio->stop_scan = true;
- if( radio->scan_thread > 0 )
- {
+ if (radio->scan_thread > 0) {
pthread_cancel(radio->scan_thread);
pthread_join(radio->scan_thread, NULL);
- radio->scan_thread = 0;
+ radio->scan_thread = 0;
}
- MMRADIO_SET_STATE( radio, MM_RADIO_STATE_READY );
+ MMRADIO_SET_STATE(radio, MM_RADIO_STATE_READY);
MMRADIO_POST_MSG(radio, MM_MESSAGE_RADIO_SCAN_STOP, NULL);
MMRADIO_LOG_FLEAVE();
return MM_ERROR_NONE;
}
-int
-_mm_radio_get_signal_strength(mm_radio_t* radio, int *value)
+int _mm_radio_get_signal_strength(mm_radio_t *radio, int *value)
{
MMRADIO_LOG_FENTER();
- MMRADIO_CHECK_INSTANCE( radio );
+ MMRADIO_CHECK_INSTANCE(radio);
- return_val_if_fail( value, MM_ERROR_INVALID_ARGUMENT );
+ return_val_if_fail(value, MM_ERROR_INVALID_ARGUMENT);
/* just return stored frequency if radio device is not ready */
- if ( radio->radio_fd < 0 )
- {
+ if (radio->radio_fd < 0) {
MMRADIO_LOG_DEBUG("Device not ready so sending 0\n");
*value = 0;
return MM_ERROR_NONE;
}
- if (ioctl(radio->radio_fd, VIDIOC_G_TUNER, &(radio->vt)) < 0)
- {
+ if (ioctl(radio->radio_fd, VIDIOC_G_TUNER, &(radio->vt)) < 0) {
debug_error("ioctl VIDIOC_G_TUNER error\n");
return MM_ERROR_RADIO_INTERNAL;
}
- *value = radio->vt.signal;
+ *value = radio->vt.signal;
MMRADIO_LOG_FLEAVE();
return MM_ERROR_NONE;
}
-void
-__mmradio_scan_thread(mm_radio_t* radio)
+void __mmradio_scan_thread(mm_radio_t *radio)
{
int ret = 0;
int prev_freq = 0;
char str_error[READ_MAX_BUFFER_SIZE];
- struct v4l2_hw_freq_seek vs = {0,};
+ struct v4l2_hw_freq_seek vs = { 0, };
vs.tuner = TUNER_INDEX;
vs.type = V4L2_TUNER_RADIO;
- vs.wrap_around = 0; /* around:1 not around:0 */
- vs.seek_upward = 1; /* up : 1 ------- down : 0 */
+ vs.wrap_around = 0; /* around:1 not around:0 */
+ vs.seek_upward = 1; /* up : 1 ------- down : 0 */
MMRADIO_LOG_FENTER();
- MMRADIO_CHECK_INSTANCE_RETURN_VOID( radio );
- if( _mmradio_mute(radio) != MM_ERROR_NONE)
+ MMRADIO_CHECK_INSTANCE_RETURN_VOID(radio);
+ if (_mmradio_mute(radio) != MM_ERROR_NONE)
goto FINISHED;
- if( _mmradio_set_frequency(radio, radio->region_setting.band_min) != MM_ERROR_NONE)
+ if (_mmradio_set_frequency(radio, radio->region_setting.band_min) != MM_ERROR_NONE)
goto FINISHED;
MMRADIO_POST_MSG(radio, MM_MESSAGE_RADIO_SCAN_START, NULL);
- MMRADIO_SET_STATE( radio, MM_RADIO_STATE_SCANNING );
+ MMRADIO_SET_STATE(radio, MM_RADIO_STATE_SCANNING);
- while( ! radio->stop_scan )
- {
+ while (!radio->stop_scan) {
int freq = 0;
- MMMessageParamType param = {0,};
+ MMMessageParamType param = { 0, };
MMRADIO_LOG_DEBUG("scanning....\n");
ret = ioctl(radio->radio_fd, VIDIOC_S_HW_FREQ_SEEK, &vs);
- if( ret == -1 )
- {
- if ( errno == EAGAIN )
- {
+ if (ret == -1) {
+ if (errno == EAGAIN) {
MMRADIO_LOG_ERROR("scanning timeout\n");
continue;
- }
- else if ( errno == EINVAL )
- {
+ } else if (errno == EINVAL) {
MMRADIO_LOG_ERROR("The tuner index is out of bounds or the value in the type field is wrong.");
break;
- }
- else
- {
+ } else {
MMRADIO_LOG_ERROR("Error: %s, %d\n", strerror_r(errno, str_error, sizeof(str_error)), errno);
break;
}
/* now we can get new frequency from radio device */
- if ( radio->stop_scan ) break;
+ if (radio->stop_scan)
+ break;
ret = _mmradio_get_frequency(radio, &freq);
- if ( ret )
- {
+ if (ret) {
MMRADIO_LOG_ERROR("failed to get current frequency\n");
- }
- else
- {
- if ( freq < prev_freq )
- {
+ } else {
+ if (freq < prev_freq) {
MMRADIO_LOG_DEBUG("scanning wrapped around. stopping scan\n");
break;
}
- if ( freq == prev_freq)
+ if (freq == prev_freq)
continue;
prev_freq = param.radio_scan.frequency = freq;
MMRADIO_LOG_DEBUG("scanning : new frequency : [%d]\n", param.radio_scan.frequency);
/* drop if max freq is scanned */
- if (param.radio_scan.frequency == radio->region_setting.band_max )
- {
+ if (param.radio_scan.frequency == radio->region_setting.band_max) {
MMRADIO_LOG_DEBUG("%d freq is dropping...and stopping scan\n", param.radio_scan.frequency);
break;
}
- if ( radio->stop_scan ) break; // doesn't need to post
+ if (radio->stop_scan) {
+ /* doesn't need to post */
+ break;
+ }
MMRADIO_POST_MSG(radio, MM_MESSAGE_RADIO_SCAN_INFO, ¶m);
}
}
-FINISHED:
+ FINISHED:
radio->scan_thread = 0;
- MMRADIO_SET_STATE( radio, MM_RADIO_STATE_READY );
+ MMRADIO_SET_STATE(radio, MM_RADIO_STATE_READY);
- if ( ! radio->stop_scan )
- {
+ if (!radio->stop_scan)
MMRADIO_POST_MSG(radio, MM_MESSAGE_RADIO_SCAN_FINISH, NULL);
- }
MMRADIO_LOG_FLEAVE();
return;
}
-bool
-__is_tunable_frequency(mm_radio_t* radio, int freq)
+bool __is_tunable_frequency(mm_radio_t *radio, int freq)
{
MMRADIO_LOG_FENTER();
- MMRADIO_CHECK_INSTANCE( radio );
+ MMRADIO_CHECK_INSTANCE(radio);
- if ( freq == radio->region_setting.band_max|| freq == radio->region_setting.band_min )
+ if (freq == radio->region_setting.band_max || freq == radio->region_setting.band_min)
return false;
MMRADIO_LOG_FLEAVE();
return true;
}
-void
-__mmradio_seek_thread(mm_radio_t* radio)
+void __mmradio_seek_thread(mm_radio_t *radio)
{
int ret = 0;
int freq = 0;
char str_error[READ_MAX_BUFFER_SIZE];
bool seek_stop = false;
- MMMessageParamType param = {0,};
- struct v4l2_hw_freq_seek vs = {0,};
+ MMMessageParamType param = {0, };
+ struct v4l2_hw_freq_seek vs = {0, };
vs.tuner = TUNER_INDEX;
vs.type = V4L2_TUNER_RADIO;
vs.wrap_around = DEFAULT_WRAP_AROUND;
MMRADIO_LOG_FENTER();
- MMRADIO_CHECK_INSTANCE_RETURN_VOID( radio );
+ MMRADIO_CHECK_INSTANCE_RETURN_VOID(radio);
/* check direction */
- switch( radio->seek_direction )
- {
- case MM_RADIO_SEEK_UP:
- vs.seek_upward = 1;
- break;
- default:
- vs.seek_upward = 0;
- break;
+ switch (radio->seek_direction) {
+ case MM_RADIO_SEEK_UP:
+ vs.seek_upward = 1;
+ break;
+ default:
+ vs.seek_upward = 0;
+ break;
}
MMRADIO_POST_MSG(radio, MM_MESSAGE_RADIO_SEEK_START, NULL);
MMRADIO_LOG_DEBUG("seeking....\n");
- while ( ! seek_stop )
- {
- ret = ioctl( radio->radio_fd, VIDIOC_S_HW_FREQ_SEEK, &vs );
+ while (!seek_stop) {
+ ret = ioctl(radio->radio_fd, VIDIOC_S_HW_FREQ_SEEK, &vs);
- if( ret == -1 )
- {
- if ( errno == EAGAIN )
- {
+ if (ret == -1) {
+ if (errno == EAGAIN) {
/* FIXIT : we need retrying code here */
MMRADIO_LOG_ERROR("scanning timeout\n");
goto SEEK_FAILED;
- }
- else if ( errno == EINVAL )
- {
+ } else if (errno == EINVAL) {
MMRADIO_LOG_ERROR("The tuner index is out of bounds or the value in the type field is wrong.");
goto SEEK_FAILED;
- }
- else
- {
+ } else {
MMRADIO_LOG_ERROR("Error: %s, %d\n", strerror_r(errno, str_error, sizeof(str_error)), errno);
goto SEEK_FAILED;
}
/* now we can get new frequency from radio device */
ret = _mmradio_get_frequency(radio, &freq);
- if ( ret )
- {
+ if (ret) {
MMRADIO_LOG_ERROR("failed to get current frequency\n");
goto SEEK_FAILED;
}
MMRADIO_LOG_DEBUG("found frequency\n");
/* if same freq is found, ignore it and search next one. */
- if ( freq == radio->prev_seek_freq )
- {
+ if (freq == radio->prev_seek_freq) {
MMRADIO_LOG_DEBUG("It's same with previous found one. So, trying next one. \n");
continue;
}
- if ( __is_tunable_frequency(radio, freq) ) // check if it's limit freq or not
- {
+ /* check if it's limit freq or not */
+ if (__is_tunable_frequency(radio, freq)) {
/* now tune to new frequency */
ret = _mmradio_set_frequency(radio, freq);
- if ( ret )
- {
+ if (ret) {
MMRADIO_LOG_ERROR("failed to tune to new frequency\n");
goto SEEK_FAILED;
}
}
/* now turn on radio
- * In the case of limit freq, tuner should be unmuted.
- * Otherwise, sound can't output even though application set new frequency.
- */
+ * In the case of limit freq, tuner should be unmuted.
+ * Otherwise, sound can't output even though application set new frequency.
+ */
ret = _mmradio_unmute(radio);
- if ( ret )
- {
+ if (ret) {
MMRADIO_LOG_ERROR("failed to tune to new frequency\n");
goto SEEK_FAILED;
}
pthread_exit(NULL);
return;
-SEEK_FAILED:
+ SEEK_FAILED:
/* freq -1 means it's failed to seek */
param.radio_scan.frequency = -1;
MMRADIO_POST_MSG(radio, MM_MESSAGE_RADIO_SEEK_FINISH, ¶m);
return;
}
-static bool
-__mmradio_post_message(mm_radio_t* radio, enum MMMessageType msgtype, MMMessageParamType* param)
+static bool __mmradio_post_message(mm_radio_t *radio, enum MMMessageType msgtype, MMMessageParamType *param)
{
- MMRADIO_CHECK_INSTANCE( radio );
+ MMRADIO_CHECK_INSTANCE(radio);
MMRADIO_LOG_FENTER();
- if ( !radio->msg_cb )
- {
+ if (!radio->msg_cb) {
debug_warning("failed to post a message\n");
return false;
}
return true;
}
-static int
- __mmradio_check_state(mm_radio_t* radio, MMRadioCommand command)
- {
- MMRadioStateType radio_state = MM_RADIO_STATE_NUM;
+static int __mmradio_check_state(mm_radio_t *radio, MMRadioCommand command)
+{
+ MMRadioStateType radio_state = MM_RADIO_STATE_NUM;
MMRADIO_LOG_FENTER();
- MMRADIO_CHECK_INSTANCE( radio );
+ MMRADIO_CHECK_INSTANCE(radio);
- radio_state = __mmradio_get_state( radio );
+ radio_state = __mmradio_get_state(radio);
- MMRADIO_LOG_DEBUG("incomming command : %d current state : %d\n", command, radio_state);
+ MMRADIO_LOG_DEBUG("incomming command : %d current state : %d\n", command, radio_state);
- switch( command )
- {
- case MMRADIO_COMMAND_CREATE:
- {
- if ( radio_state != 0 )
- goto NO_OP;
- }
- break;
+ switch (command) {
+ case MMRADIO_COMMAND_CREATE:
+ {
+ if (radio_state != 0)
+ goto NO_OP;
+ }
+ break;
- case MMRADIO_COMMAND_REALIZE:
- {
- if ( radio_state == MM_RADIO_STATE_READY ||
- radio_state == MM_RADIO_STATE_PLAYING ||
- radio_state == MM_RADIO_STATE_SCANNING )
+ case MMRADIO_COMMAND_REALIZE:
+ {
+ if (radio_state == MM_RADIO_STATE_READY ||
+ radio_state == MM_RADIO_STATE_PLAYING ||
+ radio_state == MM_RADIO_STATE_SCANNING)
goto NO_OP;
- if ( radio_state == 0 )
+ if (radio_state == 0)
goto INVALID_STATE;
- }
- break;
+ }
+ break;
- case MMRADIO_COMMAND_UNREALIZE:
- {
- if ( radio_state == MM_RADIO_STATE_NULL )
+ case MMRADIO_COMMAND_UNREALIZE:
+ {
+ if (radio_state == MM_RADIO_STATE_NULL)
goto NO_OP;
/* we can call unrealize at any higher state */
- }
- break;
-
- case MMRADIO_COMMAND_START:
- {
- if ( radio_state == MM_RADIO_STATE_PLAYING )
- goto NO_OP;
-
- if ( radio_state != MM_RADIO_STATE_READY )
- goto INVALID_STATE;
- }
- break;
-
- case MMRADIO_COMMAND_STOP:
- {
- if ( radio_state == MM_RADIO_STATE_READY )
- goto NO_OP;
-
- if ( radio_state != MM_RADIO_STATE_PLAYING )
- goto INVALID_STATE;
- }
- break;
-
- case MMRADIO_COMMAND_START_SCAN:
- {
- if ( radio_state == MM_RADIO_STATE_SCANNING )
- goto NO_OP;
-
- if ( radio_state != MM_RADIO_STATE_READY )
- goto INVALID_STATE;
- }
- break;
-
- case MMRADIO_COMMAND_STOP_SCAN:
- {
- if ( radio_state == MM_RADIO_STATE_READY )
- goto NO_OP;
-
- if ( radio_state != MM_RADIO_STATE_SCANNING )
- goto INVALID_STATE;
- }
- break;
-
- case MMRADIO_COMMAND_DESTROY:
- case MMRADIO_COMMAND_MUTE:
- case MMRADIO_COMMAND_UNMUTE:
- case MMRADIO_COMMAND_SET_FREQ:
- case MMRADIO_COMMAND_GET_FREQ:
- case MMRADIO_COMMAND_SET_REGION:
- {
+ }
+ break;
+
+ case MMRADIO_COMMAND_START:
+ {
+ if (radio_state == MM_RADIO_STATE_PLAYING)
+ goto NO_OP;
+
+ if (radio_state != MM_RADIO_STATE_READY)
+ goto INVALID_STATE;
+ }
+ break;
+
+ case MMRADIO_COMMAND_STOP:
+ {
+ if (radio_state == MM_RADIO_STATE_READY)
+ goto NO_OP;
+
+ if (radio_state != MM_RADIO_STATE_PLAYING)
+ goto INVALID_STATE;
+ }
+ break;
+
+ case MMRADIO_COMMAND_START_SCAN:
+ {
+ if (radio_state == MM_RADIO_STATE_SCANNING)
+ goto NO_OP;
+
+ if (radio_state != MM_RADIO_STATE_READY)
+ goto INVALID_STATE;
+ }
+ break;
+
+ case MMRADIO_COMMAND_STOP_SCAN:
+ {
+ if (radio_state == MM_RADIO_STATE_READY)
+ goto NO_OP;
+
+ if (radio_state != MM_RADIO_STATE_SCANNING)
+ goto INVALID_STATE;
+ }
+ break;
+
+ case MMRADIO_COMMAND_DESTROY:
+ case MMRADIO_COMMAND_MUTE:
+ case MMRADIO_COMMAND_UNMUTE:
+ case MMRADIO_COMMAND_SET_FREQ:
+ case MMRADIO_COMMAND_GET_FREQ:
+ case MMRADIO_COMMAND_SET_REGION:
+ {
/* we can do it at any state */
- }
- break;
+ }
+ break;
- case MMRADIO_COMMAND_SEEK:
- {
- if ( radio_state != MM_RADIO_STATE_PLAYING )
+ case MMRADIO_COMMAND_SEEK:
+ {
+ if (radio_state != MM_RADIO_STATE_PLAYING)
goto INVALID_STATE;
- }
- break;
+ }
+ break;
- case MMRADIO_COMMAND_GET_REGION:
+ case MMRADIO_COMMAND_GET_REGION:
{
- if ( radio_state == MM_RADIO_STATE_NULL )
+ if (radio_state == MM_RADIO_STATE_NULL)
goto INVALID_STATE;
}
break;
- default:
- MMRADIO_LOG_DEBUG("not handled in FSM. don't care it\n");
- break;
- }
+ default:
+ MMRADIO_LOG_DEBUG("not handled in FSM. don't care it\n");
+ break;
+ }
- MMRADIO_LOG_DEBUG("status OK\n");
+ MMRADIO_LOG_DEBUG("status OK\n");
- radio->cmd = command;
+ radio->cmd = command;
MMRADIO_LOG_FLEAVE();
- return MM_ERROR_NONE;
-
+ return MM_ERROR_NONE;
INVALID_STATE:
- debug_warning("invalid state. current : %d command : %d\n",
- radio_state, command);
+ debug_warning("invalid state. current : %d command : %d\n", radio_state, command);
MMRADIO_LOG_FLEAVE();
- return MM_ERROR_RADIO_INVALID_STATE;
-
+ return MM_ERROR_RADIO_INVALID_STATE;
NO_OP:
- debug_warning("mm-radio is in the desired state(%d). doing noting\n", radio_state);
+ debug_warning("mm-radio is in the desired state(%d). doing noting\n", radio_state);
MMRADIO_LOG_FLEAVE();
- return MM_ERROR_RADIO_NO_OP;
+ return MM_ERROR_RADIO_NO_OP;
- }
+}
-static bool
-__mmradio_set_state(mm_radio_t* radio, int new_state)
+static bool __mmradio_set_state(mm_radio_t *radio, int new_state)
{
- MMMessageParamType msg = {0, };
+ MMMessageParamType msg = { 0, };
int msg_type = MM_MESSAGE_UNKNOWN;
MMRADIO_LOG_FENTER();
- MMRADIO_CHECK_INSTANCE( radio );
+ MMRADIO_CHECK_INSTANCE(radio);
- if ( ! radio )
- {
+ if (!radio) {
debug_warning("calling set_state with invalid radio handle\n");
return false;
}
- if ( radio->current_state == new_state && radio->pending_state == 0 )
- {
+ if (radio->current_state == new_state && radio->pending_state == 0) {
debug_warning("we are in same state\n");
return true;
}
msg.state.current = radio->current_state;
/* post message to application */
- switch( radio->sm.by_focus_cb )
- {
- case MMRADIO_FOCUS_CB_NONE:
+ switch (radio->sm.by_focus_cb) {
+ case MMRADIO_FOCUS_CB_NONE:
{
msg_type = MM_MESSAGE_STATE_CHANGED;
- MMRADIO_POST_MSG( radio, msg_type, &msg );
+ MMRADIO_POST_MSG(radio, msg_type, &msg);
}
break;
- case MMRADIO_FOCUS_CB_POSTMSG:
+ case MMRADIO_FOCUS_CB_POSTMSG:
{
msg_type = MM_MESSAGE_STATE_INTERRUPTED;
msg.union_type = MM_MSG_UNION_CODE;
msg.code = radio->sm.event_src;
- MMRADIO_POST_MSG( radio, msg_type, &msg );
+ MMRADIO_POST_MSG(radio, msg_type, &msg);
}
break;
- case MMRADIO_FOCUS_CB_SKIP_POSTMSG:
- default:
+ case MMRADIO_FOCUS_CB_SKIP_POSTMSG:
+ default:
break;
}
return true;
}
-static int
-__mmradio_get_state(mm_radio_t* radio)
+static int __mmradio_get_state(mm_radio_t *radio)
{
- MMRADIO_CHECK_INSTANCE( radio );
+ 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;
}
-static void
-__mmradio_sound_focus_cb(int id, mm_sound_focus_type_e focus_type,
- mm_sound_focus_state_e focus_state, const char *reason_for_change,
- const char *additional_info, void *user_data)
+static void __mmradio_sound_focus_cb(int id, mm_sound_focus_type_e focus_type,
+ mm_sound_focus_state_e focus_state, const char *reason_for_change,
+ const char *additional_info, void *user_data)
{
- mm_radio_t *radio = (mm_radio_t *) user_data;
+ mm_radio_t *radio = (mm_radio_t *)user_data;
enum MMMessageInterruptedCode event_source;
int result = MM_ERROR_NONE;
int postMsg = false;
radio->sm.event_src = event_source;
switch (focus_state) {
- case FOCUS_IS_RELEASED: {
- radio->sm.cur_focus_type &= ~focus_type;
- radio->sm.by_focus_cb = MMRADIO_FOCUS_CB_POSTMSG;
+ case FOCUS_IS_RELEASED:{
+ radio->sm.cur_focus_type &= ~focus_type;
+ radio->sm.by_focus_cb = MMRADIO_FOCUS_CB_POSTMSG;
- result = _mmradio_stop(radio);
- if (result) {
- MMRADIO_LOG_ERROR("failed to stop radio\n");
- }
- MMRADIO_LOG_DEBUG("FOCUS_IS_RELEASED cur_focus_type : %d\n", radio->sm.cur_focus_type);
- }
- break;
+ result = _mmradio_stop(radio);
+ if (result)
+ MMRADIO_LOG_ERROR("failed to stop radio\n");
- case FOCUS_IS_ACQUIRED: {
- MMMessageParamType msg = {0,};
- msg.union_type = MM_MSG_UNION_CODE;
- msg.code = event_source;
+ MMRADIO_LOG_DEBUG("FOCUS_IS_RELEASED cur_focus_type : %d\n", radio->sm.cur_focus_type);
+ }
+ break;
- radio->sm.cur_focus_type |= focus_type;
+ case FOCUS_IS_ACQUIRED:{
+ MMMessageParamType msg = { 0, };
+ msg.union_type = MM_MSG_UNION_CODE;
+ msg.code = event_source;
- if ((postMsg) && (FOCUS_FOR_BOTH == radio->sm.cur_focus_type))
- MMRADIO_POST_MSG(radio, MM_MESSAGE_READY_TO_RESUME, &msg);
+ radio->sm.cur_focus_type |= focus_type;
- radio->sm.by_focus_cb = MMRADIO_FOCUS_CB_NONE;
+ if ((postMsg) && (FOCUS_FOR_BOTH == radio->sm.cur_focus_type))
+ MMRADIO_POST_MSG(radio, MM_MESSAGE_READY_TO_RESUME, &msg);
- MMRADIO_LOG_DEBUG("FOCUS_IS_ACQUIRED cur_focus_type : %d\n", radio->sm.cur_focus_type);
- }
- break;
+ radio->sm.by_focus_cb = MMRADIO_FOCUS_CB_NONE;
- default:
- MMRADIO_LOG_DEBUG("Unknown focus_state\n");
- break;
+ MMRADIO_LOG_DEBUG("FOCUS_IS_ACQUIRED cur_focus_type : %d\n", radio->sm.cur_focus_type);
+ }
+ break;
+
+ default:
+ MMRADIO_LOG_DEBUG("Unknown focus_state\n");
+ break;
}
MMRADIO_LOG_FLEAVE();
}
-static void
-__mmradio_device_connected_cb(MMSoundDevice_t device, bool is_connected, void *user_data)
+static void __mmradio_device_connected_cb(MMSoundDevice_t device, bool is_connected, void *user_data)
{
- mm_radio_t *radio = (mm_radio_t *) user_data;
+ mm_radio_t *radio = (mm_radio_t *)user_data;
int result = MM_ERROR_NONE;
mm_sound_device_type_e type;
MMRADIO_LOG_FENTER();
MMRADIO_CHECK_INSTANCE_RETURN_VOID(radio);
- if (mm_sound_get_device_type (device, &type) != MM_ERROR_NONE)
- {
+ if (mm_sound_get_device_type(device, &type) != MM_ERROR_NONE) {
debug_error("getting device type failed");
- }
- else
- {
- switch (type)
- {
- case MM_SOUND_DEVICE_TYPE_AUDIOJACK:
- case MM_SOUND_DEVICE_TYPE_BLUETOOTH:
- case MM_SOUND_DEVICE_TYPE_HDMI:
- case MM_SOUND_DEVICE_TYPE_MIRRORING:
- case MM_SOUND_DEVICE_TYPE_USB_AUDIO:
- if (!is_connected)
- {
+ } else {
+ switch (type) {
+ case MM_SOUND_DEVICE_TYPE_AUDIOJACK:
+ case MM_SOUND_DEVICE_TYPE_BLUETOOTH:
+ case MM_SOUND_DEVICE_TYPE_HDMI:
+ case MM_SOUND_DEVICE_TYPE_MIRRORING:
+ case MM_SOUND_DEVICE_TYPE_USB_AUDIO:
+ if (!is_connected) {
MMRADIO_LOG_ERROR("sound device unplugged");
radio->sm.by_focus_cb = MMRADIO_FOCUS_CB_POSTMSG;
radio->sm.event_src = MM_MSG_CODE_INTERRUPTED_BY_EARJACK_UNPLUG;
result = _mmradio_stop(radio);
if (result != MM_ERROR_NONE)
- {
MMRADIO_LOG_ERROR("failed to stop radio\n");
- }
}
break;
- default:
+ default:
break;
}
}
MMRADIO_LOG_FLEAVE();
}
-int _mmradio_get_region_type(mm_radio_t*radio, MMRadioRegionType *type)
+int _mmradio_get_region_type(mm_radio_t *radio, MMRadioRegionType *type)
{
MMRADIO_LOG_FENTER();
- MMRADIO_CHECK_INSTANCE( radio );
- MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_GET_REGION );
+ MMRADIO_CHECK_INSTANCE(radio);
+ MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_GET_REGION);
- return_val_if_fail( type, MM_ERROR_INVALID_ARGUMENT );
+ return_val_if_fail(type, MM_ERROR_INVALID_ARGUMENT);
*type = radio->region_setting.country;
return MM_ERROR_NONE;
}
-int _mmradio_get_region_frequency_range(mm_radio_t* radio, unsigned int *min_freq, unsigned int *max_freq)
+int _mmradio_get_region_frequency_range(mm_radio_t *radio, unsigned int *min_freq, unsigned int *max_freq)
{
MMRADIO_LOG_FENTER();
- MMRADIO_CHECK_INSTANCE( radio );
- MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_GET_REGION );
+ MMRADIO_CHECK_INSTANCE(radio);
+ MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_GET_REGION);
- return_val_if_fail( min_freq && max_freq, MM_ERROR_INVALID_ARGUMENT );
+ return_val_if_fail(min_freq && max_freq, MM_ERROR_INVALID_ARGUMENT);
*min_freq = radio->region_setting.band_min;
*max_freq = radio->region_setting.band_max;
return MM_ERROR_NONE;
}
-int _mmradio_get_channel_spacing(mm_radio_t* radio, unsigned int *ch_spacing)
+int _mmradio_get_channel_spacing(mm_radio_t *radio, unsigned int *ch_spacing)
{
MMRADIO_LOG_FENTER();
- MMRADIO_CHECK_INSTANCE( radio );
- MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_GET_REGION );
+ MMRADIO_CHECK_INSTANCE(radio);
+ MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_GET_REGION);
- return_val_if_fail( ch_spacing, MM_ERROR_INVALID_ARGUMENT );
+ return_val_if_fail(ch_spacing, MM_ERROR_INVALID_ARGUMENT);
*ch_spacing = radio->region_setting.channel_spacing;
MMRADIO_LOG_FLEAVE();
return MM_ERROR_NONE;
}
-
-
projects / platform / core / multimedia / libmm-radio.git / commitdiff