static int __mm_recorder_msg_cb(int message, void *param, void *user_data);
+//LCOV_EXCL_START
static int __convert_error_code_camera_to_recorder(int code)
{
int new_code = code;
return new_code;
}
+//LCOV_EXCL_STOP
int __convert_recorder_error_code(const char *func, int code)
ret = RECORDER_ERROR_INVALID_PARAMETER;
errorstr = "INVALID_PARAMETER";
break;
- case MM_ERROR_COMMON_INVALID_PERMISSION:
- ret = RECORDER_ERROR_PERMISSION_DENIED;
- errorstr = "ERROR_PERMISSION_DENIED";
- break;
case MM_ERROR_CAMCORDER_NOT_INITIALIZED:
case MM_ERROR_CAMCORDER_INVALID_STATE:
ret = RECORDER_ERROR_INVALID_STATE;
errorstr = "INVALID_STATE";
break;
- case MM_ERROR_CAMCORDER_DEVICE:
- case MM_ERROR_CAMCORDER_DEVICE_NOT_FOUND:
- case MM_ERROR_CAMCORDER_DEVICE_BUSY:
- case MM_ERROR_CAMCORDER_DEVICE_OPEN:
- case MM_ERROR_CAMCORDER_DEVICE_IO:
- case MM_ERROR_CAMCORDER_DEVICE_TIMEOUT:
- case MM_ERROR_CAMCORDER_DEVICE_WRONG_JPEG:
- case MM_ERROR_CAMCORDER_DEVICE_LACK_BUFFER:
- ret = RECORDER_ERROR_DEVICE;
- errorstr = "ERROR_DEVICE";
- break;
case MM_ERROR_CAMCORDER_GST_CORE:
case MM_ERROR_CAMCORDER_GST_LIBRARY:
case MM_ERROR_CAMCORDER_GST_RESOURCE:
ret = RECORDER_ERROR_OUT_OF_MEMORY;
errorstr = "OUT_OF_MEMORY";
break;
- case MM_ERROR_POLICY_RESTRICTED:
- ret = RECORDER_ERROR_SECURITY_RESTRICTED;
- errorstr = "ERROR_RESTRICTED";
+ case MM_ERROR_COMMON_OUT_OF_ARRAY:
+ case MM_ERROR_COMMON_OUT_OF_RANGE:
+ case MM_ERROR_COMMON_ATTR_NOT_EXIST:
+ case MM_ERROR_CAMCORDER_NOT_SUPPORTED:
+ ret = RECORDER_ERROR_NOT_SUPPORTED;
+ errorstr = "NOT_SUPPORTED";
+ break;
+//LCOV_EXCL_START
+ case MM_ERROR_COMMON_INVALID_PERMISSION:
+ ret = RECORDER_ERROR_PERMISSION_DENIED;
+ errorstr = "ERROR_PERMISSION_DENIED";
+ break;
+ case MM_ERROR_CAMCORDER_DEVICE:
+ case MM_ERROR_CAMCORDER_DEVICE_NOT_FOUND:
+ case MM_ERROR_CAMCORDER_DEVICE_BUSY:
+ case MM_ERROR_CAMCORDER_DEVICE_OPEN:
+ case MM_ERROR_CAMCORDER_DEVICE_IO:
+ case MM_ERROR_CAMCORDER_DEVICE_TIMEOUT:
+ case MM_ERROR_CAMCORDER_DEVICE_WRONG_JPEG:
+ case MM_ERROR_CAMCORDER_DEVICE_LACK_BUFFER:
+ ret = RECORDER_ERROR_DEVICE;
+ errorstr = "ERROR_DEVICE";
break;
case MM_ERROR_CAMCORDER_DEVICE_REG_TROUBLE:
ret = RECORDER_ERROR_ESD;
errorstr = "ERROR_ESD";
break;
+ case MM_ERROR_POLICY_RESTRICTED:
+ ret = RECORDER_ERROR_SECURITY_RESTRICTED;
+ errorstr = "ERROR_RESTRICTED";
+ break;
case MM_ERROR_OUT_OF_STORAGE:
ret = RECORDER_ERROR_OUT_OF_STORAGE;
errorstr = "OUT_OF_STORAGE";
break;
- case MM_ERROR_COMMON_OUT_OF_ARRAY:
- case MM_ERROR_COMMON_OUT_OF_RANGE:
- case MM_ERROR_COMMON_ATTR_NOT_EXIST:
- case MM_ERROR_CAMCORDER_NOT_SUPPORTED:
- ret = RECORDER_ERROR_NOT_SUPPORTED;
- errorstr = "NOT_SUPPORTED";
- break;
case MM_ERROR_RESOURCE_INTERNAL:
ret = RECORDER_ERROR_RESOURCE_CONFLICT;
errorstr = "ERROR_RESOURCE_CONFLICT";
ret = RECORDER_ERROR_INVALID_OPERATION;
errorstr = "INVALID_OPERATION";
break;
+//LCOV_EXCL_STOP
}
LOGE("[%s] %s(0x%08x) : core frameworks error code(0x%08x)", func, errorstr, ret, code);
}
break;
case MM_CAMCORDER_STATE_PREPARE:
- state = RECORDER_STATE_READY;
- break;
+ /* fall through */
case MM_CAMCORDER_STATE_CAPTURING:
state = RECORDER_STATE_READY;
break;
previous_state = handle->state;
handle->state = __recorder_state_convert(m->state.current, m->state.previous);
+//LCOV_EXCL_START
if (message == MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_SECURITY) {
policy = RECORDER_POLICY_SECURITY;
LOGE("RECORDER_POLICY_SECURITY");
interrupt_state = previous_state;
LOGD("interrupt state %d", interrupt_state);
}
+//LCOV_EXCL_STOP
if (previous_state != handle->state && handle->user_cb[_RECORDER_EVENT_TYPE_STATE_CHANGE])
((recorder_state_changed_cb)handle->user_cb[_RECORDER_EVENT_TYPE_STATE_CHANGE])(previous_state, handle->state, policy, handle->user_data[_RECORDER_EVENT_TYPE_STATE_CHANGE]);
+//LCOV_EXCL_START
if (policy != RECORDER_POLICY_NONE) {
if (policy == RECORDER_POLICY_SECURITY ||
m->state.current == MM_CAMCORDER_STATE_PAUSED ||
}
}
break;
+//LCOV_EXCL_STOP
case MM_MESSAGE_CAMCORDER_MAX_SIZE:
case MM_MESSAGE_CAMCORDER_NO_FREE_SPACE:
case MM_MESSAGE_CAMCORDER_TIME_LIMIT:
((recorder_recording_status_cb)handle->user_cb[_RECORDER_EVENT_TYPE_RECORDING_STATUS])(m->recording_status.elapsed,
m->recording_status.filesize, handle->user_data[_RECORDER_EVENT_TYPE_RECORDING_STATUS]);
break;
+//LCOV_EXCL_START
case MM_MESSAGE_CAMCORDER_ERROR:
switch (m->code) {
case MM_ERROR_CAMCORDER_DEVICE:
else
LOGW("ERROR cb was not set");
break;
+//LCOV_EXCL_STOP
case MM_MESSAGE_CAMCORDER_CURRENT_VOLUME:
if (handle->last_max_input_level < m->rec_volume_dB)
handle->last_max_input_level = m->rec_volume_dB;
static int __mm_audio_stream_cb(MMCamcorderAudioStreamDataType *stream, void *user_param)
{
- recorder_s *handle = NULL;
+ recorder_s *handle = (recorder_s *)user_param;
recorder_sample_type_e format = RECORDER_SAMPLE_TYPE_U8;
int type = _RECORDER_EVENT_TYPE_AUDIO_STREAM;
- if (!user_param || !stream) {
- LOGE("NULL parameter %p %p", user_param, stream);
- return 0;
- }
-
- handle = (recorder_s *)user_param;
+ recorder_return_val_if_fail(handle && stream, 0);
if (stream->format == MM_CAMCORDER_AUDIO_FORMAT_PCM_S16_LE)
format = RECORDER_SAMPLE_TYPE_S16_LE;
static int __mm_muxed_stream_cb(MMCamcorderMuxedStreamDataType *stream, void *user_param)
{
- recorder_s *handle = NULL;
+ recorder_s *handle = (recorder_s *)user_param;
int type = _RECORDER_EVENT_TYPE_MUXED_STREAM;
- if (!user_param || !stream) {
- LOGE("NULL parameter %p %p", user_param, stream);
- return 0;
- }
-
- handle = (recorder_s *)user_param;
+ recorder_return_val_if_fail(handle && stream, 0);
if (handle->user_cb[type]) {
((recorder_muxed_stream_cb)(handle->user_cb[type]))(stream->data, stream->length,
recorder_s *handle = (recorder_s *)recorder;
MMCamcorderStateType mmstate = MM_CAMCORDER_STATE_NONE;
- if (recorder == NULL) {
- LOGE("handle is NULL");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
mm_camcorder_get_state(handle->mm_handle, &mmstate);
- if (mmstate >= MM_CAMCORDER_STATE_RECORDING) {
- LOGE("invalid state %d", mmstate);
- return RECORDER_ERROR_INVALID_STATE;
- }
+
+ recorder_return_val_if_fail(mmstate < MM_CAMCORDER_STATE_RECORDING, RECORDER_ERROR_INVALID_STATE);
if (handle->type == _RECORDER_TYPE_AUDIO && mmstate == MM_CAMCORDER_STATE_PREPARE) {
mm_camcorder_get_attributes(handle->mm_handle, NULL,
int legacy_recorder_create_videorecorder(camera_h camera, recorder_h *recorder)
{
int ret = MM_ERROR_NONE;
- recorder_s *handle = NULL;
int preview_format = MM_PIXEL_FORMAT_NV12;
int camera_device_count = 0;
+ recorder_s *handle = NULL;
- if (camera == NULL) {
- LOGE("NULL pointer camera handle");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
- if (recorder == NULL) {
- LOGE("NULL pointer recorder handle");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(camera && recorder, RECORDER_ERROR_INVALID_PARAMETER);
/* Check already used in another recorder */
if (legacy_camera_is_used(camera)) {
return RECORDER_ERROR_INVALID_PARAMETER;
}
- handle = (recorder_s*)malloc(sizeof(recorder_s));
- if (handle == NULL) {
- LOGE("[%s] malloc error", __func__);
- return RECORDER_ERROR_OUT_OF_MEMORY;
- }
+ handle = g_new0(recorder_s, 1);
- memset(handle, 0 , sizeof(recorder_s));
handle->src_type = _RECORDER_SOURCE_TYPE_CAMERA;
handle->last_max_input_level = LOWSET_DECIBEL;
handle->changed_preview_format = -1;
MMCAM_CAMERA_DEVICE_COUNT, &camera_device_count,
NULL);
if (ret != MM_ERROR_NONE) {
- free(handle);
- handle = NULL;
+ g_free(handle);
LOGE("get device count error");
return __convert_recorder_error_code(__func__, ret);
}
if (camera_device_count == 0) {
- free(handle);
- handle = NULL;
+ g_free(handle);
LOGE("RECORDER_ERROR_NOT_SUPPORTED");
return RECORDER_ERROR_NOT_SUPPORTED;
} else {
int legacy_recorder_create_audiorecorder(recorder_h *recorder)
{
int ret = MM_ERROR_NONE;
+ int camera_device_count = 0;
recorder_s *handle = NULL;
MMCamPreset info;
- int camera_device_count = 0;
- if (recorder == NULL) {
- LOGE("NULL pointer handle");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(recorder, RECORDER_ERROR_INVALID_PARAMETER);
info.videodev_type = MM_VIDEO_DEVICE_NONE;
- handle = (recorder_s *)malloc(sizeof(recorder_s));
- if (handle == NULL) {
- LOGE("OUT_OF_MEMORY(0x%08x)", RECORDER_ERROR_OUT_OF_MEMORY);
- return RECORDER_ERROR_OUT_OF_MEMORY;
- }
-
- memset(handle, 0, sizeof(recorder_s));
+ handle = g_new0(recorder_s, 1);
handle->last_max_input_level = LOWSET_DECIBEL;
ret = mm_camcorder_create(&handle->mm_handle, &info);
if (ret != MM_ERROR_NONE) {
- free(handle);
- handle = NULL;
+ g_free(handle);
LOGE("mm_camcorder_create fail");
return __convert_recorder_error_code(__func__, ret);
}
NULL);
if (ret != MM_ERROR_NONE) {
mm_camcorder_destroy(handle->mm_handle);
- free(handle);
- handle = NULL;
+ g_free(handle);
LOGE("AUDIO mode setting fail");
return __convert_recorder_error_code(__func__, ret);
}
NULL);
if (ret != MM_ERROR_NONE) {
mm_camcorder_destroy(handle->mm_handle);
- free(handle);
- handle = NULL;
+ g_free(handle);
LOGE("get device count error");
return __convert_recorder_error_code(__func__, ret);
} else {
int legacy_recorder_get_state(recorder_h recorder, recorder_state_e *state)
{
int ret = MM_ERROR_NONE;
+ recorder_s *handle = (recorder_s *)recorder;
MMCamcorderStateType mm_state = MM_CAMCORDER_STATE_NONE;
MMCamcorderStateType mm_old_state = MM_CAMCORDER_STATE_NONE;
- if (recorder == NULL) {
- LOGE("NULL pointer handle");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
- if (state == NULL) {
- LOGE("NULL pointer state");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
-
- recorder_s *handle = (recorder_s*)recorder;
+ recorder_return_val_if_fail(handle && state, RECORDER_ERROR_INVALID_PARAMETER);
ret = mm_camcorder_get_state2(handle->mm_handle, &mm_state, &mm_old_state);
if (ret != MM_ERROR_NONE)
int legacy_recorder_destroy(recorder_h recorder)
{
- recorder_s *handle = NULL;
int ret = MM_ERROR_NONE;
int preview_format;
+ recorder_s *handle = (recorder_s *)recorder;
- if (recorder == NULL) {
- LOGE("NULL pointer handle");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
-
- handle = (recorder_s *)recorder;
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
if (handle->type == _RECORDER_TYPE_VIDEO) {
MMCamcorderStateType mm_state = MM_CAMCORDER_STATE_NONE;
return RECORDER_ERROR_INVALID_STATE;
}
- /* set to unsed */
+ /* set to unused */
legacy_camera_lock(handle->mm_source.camera, true);
_camera_set_use(handle->mm_source.camera, false);
}
if (ret == MM_ERROR_NONE)
- free(handle);
+ g_free(handle);
return __convert_recorder_error_code(__func__, ret);
}
recorder_s *handle = (recorder_s *)recorder;
MMCamcorderStateType mmstate;
- if (recorder == NULL) {
- LOGE("NULL pointer handle");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
if (handle->type == _RECORDER_TYPE_VIDEO)
return __convert_error_code_camera_to_recorder(legacy_camera_start_preview(handle->mm_source.camera));
recorder_s *handle = (recorder_s *)recorder;
MMCamcorderStateType mmstate;
- if (recorder == NULL) {
- LOGE("NULL pointer handle");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
ret = mm_camcorder_get_state(handle->mm_handle, &mmstate);
if (ret == MM_ERROR_NONE && mmstate == MM_CAMCORDER_STATE_PREPARE) {
{
recorder_s *handle = (recorder_s *)recorder;
- if (recorder == NULL) {
- LOGE("NULL pointer handle");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
return __convert_recorder_error_code(__func__, mm_camcorder_record(handle->mm_handle));
}
{
recorder_s *handle = (recorder_s *)recorder;
- if (recorder == NULL) {
- LOGE("NULL pointer handle");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
return __convert_recorder_error_code(__func__, mm_camcorder_pause(handle->mm_handle));
}
{
recorder_s *handle = (recorder_s *)recorder;
- if (recorder == NULL) {
- LOGE("NULL pointer handle");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
return __convert_recorder_error_code(__func__, mm_camcorder_commit(handle->mm_handle));
}
{
recorder_s *handle = (recorder_s *)recorder;
- if (recorder == NULL) {
- LOGE("NULL pointer handle");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
return __convert_recorder_error_code(__func__, mm_camcorder_cancel(handle->mm_handle));
}
int legacy_recorder_set_video_resolution(recorder_h recorder, int width, int height)
{
int ret = MM_ERROR_NONE;
- recorder_s *handle = (recorder_s*)recorder;
+ recorder_s *handle = (recorder_s *)recorder;
recorder_state_e state = RECORDER_STATE_NONE;
- if (handle == NULL) {
- LOGE("NULL pointer handle");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
-
- if (handle->camera_device_count == 0) {
- LOGE("RECORDER_ERROR_NOT_SUPPORTED");
- return RECORDER_ERROR_NOT_SUPPORTED;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
+ recorder_return_val_if_fail(handle->camera_device_count > 0, RECORDER_ERROR_NOT_SUPPORTED);
legacy_recorder_get_state(recorder, &state);
- if (state > RECORDER_STATE_READY) {
- LOGE("RECORDER_ERROR_INVALID_STATE (state:%d)", state);
- return RECORDER_ERROR_INVALID_STATE;
- }
+ recorder_return_val_if_fail(state <= RECORDER_STATE_READY, RECORDER_ERROR_INVALID_STATE);
ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
MMCAM_VIDEO_WIDTH, width,
int legacy_recorder_get_video_resolution(recorder_h recorder, int *width, int *height)
{
int ret = MM_ERROR_NONE;
- recorder_s *handle = (recorder_s*)recorder;
-
- if (!handle) {
- LOGE("NULL pointer handle");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
-
- if (handle->camera_device_count == 0) {
- LOGE("RECORDER_ERROR_NOT_SUPPORTED");
- return RECORDER_ERROR_NOT_SUPPORTED;
- }
+ recorder_s *handle = (recorder_s *)recorder;
- if (!width || !height) {
- LOGE("NULL pointer width = [%p], height = [%p]", width, height);
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
+ recorder_return_val_if_fail(handle->camera_device_count > 0, RECORDER_ERROR_NOT_SUPPORTED);
+ recorder_return_val_if_fail(width && height, RECORDER_ERROR_INVALID_PARAMETER);
ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
MMCAM_VIDEO_WIDTH, width,
{
int i = 0;
int ret = MM_ERROR_NONE;
- recorder_s * handle = (recorder_s*)recorder;
+ recorder_s *handle = (recorder_s *)recorder;
MMCamAttrsInfo video_width;
MMCamAttrsInfo video_height;
- if (!handle) {
- LOGE("NULL pointer handle");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
-
- if (handle->camera_device_count == 0) {
- LOGE("RECORDER_ERROR_NOT_SUPPORTED");
- return RECORDER_ERROR_NOT_SUPPORTED;
- }
-
- if (!foreach_cb) {
- LOGE("NULL pointer callback");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
+ recorder_return_val_if_fail(handle->camera_device_count > 0, RECORDER_ERROR_NOT_SUPPORTED);
+ recorder_return_val_if_fail(foreach_cb, RECORDER_ERROR_INVALID_PARAMETER);
ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_VIDEO_WIDTH, &video_width);
ret |= mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_VIDEO_HEIGHT, &video_height);
recorder_s *handle = (recorder_s *)recorder;
recorder_state_e state;
- if (recorder == NULL || level == NULL) {
- LOGE("NULL pointer %p %p", recorder, level);
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle && level, RECORDER_ERROR_INVALID_PARAMETER);
legacy_recorder_get_state(recorder, &state);
- if (state < RECORDER_STATE_RECORDING) {
- LOGE("RECORDER_ERROR_INVALID_STATE(0x%08x)", RECORDER_ERROR_INVALID_STATE);
- return RECORDER_ERROR_INVALID_STATE;
- }
+
+ recorder_return_val_if_fail(state >= RECORDER_STATE_RECORDING, RECORDER_ERROR_INVALID_STATE);
*level = handle->last_max_input_level;
handle->last_max_input_level = LOWSET_DECIBEL;
recorder_s *handle = (recorder_s *)recorder;
MMCamcorderStateType mmstate = MM_CAMCORDER_STATE_NONE;
- if (recorder == NULL) {
- LOGE("handle is NULL");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
-
- if (filename == NULL) {
- LOGE("filename is NULL");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle && filename, RECORDER_ERROR_INVALID_PARAMETER);
mm_camcorder_get_state(handle->mm_handle, &mmstate);
- if (mmstate >= MM_CAMCORDER_STATE_RECORDING) {
- LOGE("invalid state %d", mmstate);
- return RECORDER_ERROR_INVALID_STATE;
- }
+
+ recorder_return_val_if_fail(mmstate < MM_CAMCORDER_STATE_RECORDING, RECORDER_ERROR_INVALID_STATE);
ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
MMCAM_TARGET_FILENAME, filename, strlen(filename),
int record_filename_size;
recorder_s *handle = (recorder_s *)recorder;
- if (recorder == NULL) {
- LOGE("handle is NULL");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
-
- if (filename == NULL) {
- LOGE("filename is NULL");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle && filename, RECORDER_ERROR_INVALID_PARAMETER);
ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
- MMCAM_TARGET_FILENAME, &record_filename, &record_filename_size,
- NULL);
+ MMCAM_TARGET_FILENAME, &record_filename, &record_filename_size,
+ NULL);
if (ret == MM_ERROR_NONE && record_filename) {
*filename = strdup(record_filename);
} else {
MM_FILE_FORMAT_M2TS /* RECORDER_FILE_FORMAT_M2TS */
};
- if (format > RECORDER_FILE_FORMAT_M2TS) {
- LOGE("invalid format %d", format);
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(format <= RECORDER_FILE_FORMAT_M2TS, RECORDER_ERROR_INVALID_PARAMETER);
return _recorder_check_and_set_attribute(recorder, MMCAM_FILE_FORMAT, format_table[format]);
}
recorder_s *handle = (recorder_s *)recorder;
int mm_format;
- if (recorder == NULL) {
- LOGE("handle is NULL");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
-
- if (format == NULL) {
- LOGE("format is NULL");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle && format, RECORDER_ERROR_INVALID_PARAMETER);
ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
MMCAM_FILE_FORMAT, &mm_format,
{
recorder_s *handle = (recorder_s *)recorder;
- if (recorder == NULL) {
- LOGE("NULL pointer handle");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
-
- if (callback == NULL) {
- LOGE("NULL pointer callback");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle && callback, RECORDER_ERROR_INVALID_PARAMETER);
handle->user_cb[_RECORDER_EVENT_TYPE_STATE_CHANGE] = callback;
handle->user_data[_RECORDER_EVENT_TYPE_STATE_CHANGE] = user_data;
{
recorder_s *handle = (recorder_s *)recorder;
- if (recorder == NULL) {
- LOGE("NULL pointer handle");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
handle->user_cb[_RECORDER_EVENT_TYPE_STATE_CHANGE] = NULL;
handle->user_data[_RECORDER_EVENT_TYPE_STATE_CHANGE] = NULL;
{
recorder_s *handle = (recorder_s *)recorder;
- if (recorder == NULL) {
- LOGE("NULL pointer handle");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
- if (callback == NULL) {
- LOGE("NULL pointer callback");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle && callback, RECORDER_ERROR_INVALID_PARAMETER);
handle->user_cb[_RECORDER_EVENT_TYPE_INTERRUPTED] = callback;
handle->user_data[_RECORDER_EVENT_TYPE_INTERRUPTED] = user_data;
{
recorder_s *handle = (recorder_s *)recorder;
- if (recorder == NULL) {
- LOGE("NULL pointer handle");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
handle->user_cb[_RECORDER_EVENT_TYPE_INTERRUPTED] = NULL;
handle->user_data[_RECORDER_EVENT_TYPE_INTERRUPTED] = NULL;
{
recorder_s *handle = (recorder_s *)recorder;
- if (recorder == NULL) {
- LOGE("NULL pointer handle");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
- if (callback == NULL) {
- LOGE("NULL pointer callback");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle && callback, RECORDER_ERROR_INVALID_PARAMETER);
handle->user_cb[_RECORDER_EVENT_TYPE_INTERRUPT_STARTED] = callback;
handle->user_data[_RECORDER_EVENT_TYPE_INTERRUPT_STARTED] = user_data;
{
recorder_s *handle = (recorder_s *)recorder;
- if (recorder == NULL) {
- LOGE("NULL pointer handle");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
handle->user_cb[_RECORDER_EVENT_TYPE_INTERRUPT_STARTED] = NULL;
handle->user_data[_RECORDER_EVENT_TYPE_INTERRUPT_STARTED] = NULL;
int ret = MM_ERROR_NONE;
recorder_s *handle = (recorder_s *)recorder;
- if (recorder == NULL) {
- LOGE("NULL pointer handle");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
- if (callback == NULL) {
- LOGE("NULL pointer callback");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle && callback, RECORDER_ERROR_INVALID_PARAMETER);
ret = mm_camcorder_set_audio_stream_callback(handle->mm_handle, __mm_audio_stream_cb, handle);
if (ret == MM_ERROR_NONE) {
int ret = MM_ERROR_NONE;
recorder_s *handle = (recorder_s *)recorder;
- if (recorder == NULL) {
- LOGE("NULL pointer handle");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
handle->user_cb[_RECORDER_EVENT_TYPE_AUDIO_STREAM] = NULL;
handle->user_data[_RECORDER_EVENT_TYPE_AUDIO_STREAM] = NULL;
recorder_s *handle = (recorder_s *)recorder;
recorder_state_e state = RECORDER_STATE_NONE;
- if (!recorder || !callback) {
- LOGE("Invalid parameter %p %p", recorder, callback);
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle && callback, RECORDER_ERROR_INVALID_PARAMETER);
legacy_recorder_get_state(recorder, &state);
- if (state > RECORDER_STATE_READY) {
- LOGE("Invalid state %d", state);
- return RECORDER_ERROR_INVALID_STATE;
- }
+
+ recorder_return_val_if_fail(state <= RECORDER_STATE_READY, RECORDER_ERROR_INVALID_STATE);
ret = mm_camcorder_set_muxed_stream_callback(handle->mm_handle, __mm_muxed_stream_cb, handle);
if (ret == MM_ERROR_NONE) {
recorder_s *handle = (recorder_s *)recorder;
recorder_state_e state = RECORDER_STATE_NONE;
- if (recorder == NULL) {
- LOGE("NULL pointer handle");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
legacy_recorder_get_state(recorder, &state);
- if (state > RECORDER_STATE_READY) {
- LOGE("Invalid state %d", state);
- return RECORDER_ERROR_INVALID_STATE;
- }
+
+ recorder_return_val_if_fail(state <= RECORDER_STATE_READY, RECORDER_ERROR_INVALID_STATE);
ret = mm_camcorder_set_muxed_stream_callback(handle->mm_handle, NULL, NULL);
if (ret == MM_ERROR_NONE) {
{
recorder_s *handle = (recorder_s *)recorder;
- if (recorder == NULL) {
- LOGE("NULL pointer handle");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
- if (callback == NULL) {
- LOGE("NULL pointer callback");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle && callback, RECORDER_ERROR_INVALID_PARAMETER);
handle->user_cb[_RECORDER_EVENT_TYPE_ERROR] = callback;
handle->user_data[_RECORDER_EVENT_TYPE_ERROR] = user_data;
{
recorder_s *handle = (recorder_s *)recorder;
- if (recorder == NULL) {
- LOGE("NULL pointer handle");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
handle->user_cb[_RECORDER_EVENT_TYPE_ERROR] = NULL;
handle->user_data[_RECORDER_EVENT_TYPE_ERROR] = NULL;
{
recorder_s *handle = (recorder_s *)recorder;
- if (recorder == NULL) {
- LOGE("NULL pointer handle");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
- if (callback == NULL) {
- LOGE("NULL pointer callback");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle && callback, RECORDER_ERROR_INVALID_PARAMETER);
handle->user_cb[_RECORDER_EVENT_TYPE_RECORDING_STATUS] = callback;
handle->user_data[_RECORDER_EVENT_TYPE_RECORDING_STATUS] = user_data;
{
recorder_s *handle = (recorder_s *)recorder;
- if (recorder == NULL) {
- LOGE("NULL pointer handle");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
handle->user_cb[_RECORDER_EVENT_TYPE_RECORDING_STATUS] = NULL;
handle->user_data[_RECORDER_EVENT_TYPE_RECORDING_STATUS] = NULL;
{
recorder_s *handle = (recorder_s *)recorder;
- if (recorder == NULL) {
- LOGE("NULL pointer handle");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
- if (callback == NULL) {
- LOGE("NULL pointer callback");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle && callback, RECORDER_ERROR_INVALID_PARAMETER);
handle->user_cb[_RECORDER_EVENT_TYPE_RECORDING_LIMITED] = callback;
handle->user_data[_RECORDER_EVENT_TYPE_RECORDING_LIMITED] = user_data;
{
recorder_s *handle = (recorder_s *)recorder;
- if (recorder == NULL) {
- LOGE("NULL pointer handle");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
handle->user_cb[_RECORDER_EVENT_TYPE_RECORDING_LIMITED] = NULL;
handle->user_data[_RECORDER_EVENT_TYPE_RECORDING_LIMITED] = NULL;
MMCamAttrsInfo info;
int format;
- if (recorder == NULL) {
- LOGE("NULL pointer handle");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
- if (foreach_cb == NULL) {
- LOGE("NULL pointer foreach_cb");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle && foreach_cb, RECORDER_ERROR_INVALID_PARAMETER);
ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_FILE_FORMAT, &info);
if (ret != MM_ERROR_NONE) {
int ret = MM_ERROR_NONE;
recorder_s *handle = (recorder_s *)recorder;
- if (recorder == NULL) {
- LOGE("NULL pointer handle");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
-
- if (kbyte < 0) {
- LOGE("invalid kbyte %d", kbyte);
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
+ recorder_return_val_if_fail(kbyte >= 0, RECORDER_ERROR_INVALID_PARAMETER);
ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
MMCAM_TARGET_MAX_SIZE, kbyte,
int ret = MM_ERROR_NONE;
recorder_s *handle = (recorder_s *)recorder;
- if (recorder == NULL) {
- LOGE("NULL pointer handle");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
-
- if (second < 0) {
- LOGE("invalid second %d", second);
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
+ recorder_return_val_if_fail(second >= 0, RECORDER_ERROR_INVALID_PARAMETER);
ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
MMCAM_TARGET_TIME_LIMIT, second,
int legacy_recorder_attr_set_audio_device(recorder_h recorder, recorder_audio_device_e device)
{
- if (device > RECORDER_AUDIO_DEVICE_MODEM) {
- LOGE("invalid device %d", device);
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(device <= RECORDER_AUDIO_DEVICE_MODEM, RECORDER_ERROR_INVALID_PARAMETER);
return _recorder_check_and_set_attribute(recorder, MMCAM_AUDIO_DEVICE, device);
}
MM_AUDIO_CODEC_MP3 /* RECORDER_AUDIO_CODEC_MP3 */
};
- if (recorder == NULL) {
- LOGE("handle is NULL");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
-
- if (codec < RECORDER_AUDIO_CODEC_DISABLE || codec > RECORDER_AUDIO_CODEC_MP3) {
- LOGE("invalid parameter : codec %d", codec);
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
-
- if (handle->type == _RECORDER_TYPE_AUDIO && codec == RECORDER_AUDIO_CODEC_DISABLE) {
- LOGE("AUDIO_CODEC_DISABLE is not supported in audio mode");
- return RECORDER_ERROR_NOT_SUPPORTED;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
+ recorder_return_val_if_fail(codec >= RECORDER_AUDIO_CODEC_DISABLE && \
+ codec <= RECORDER_AUDIO_CODEC_MP3, RECORDER_ERROR_INVALID_PARAMETER);
+ recorder_return_val_if_fail(handle->type != _RECORDER_TYPE_AUDIO || \
+ codec != RECORDER_AUDIO_CODEC_DISABLE, RECORDER_ERROR_NOT_SUPPORTED);
return _recorder_check_and_set_attribute(recorder, MMCAM_AUDIO_ENCODER,
codec == RECORDER_AUDIO_CODEC_DISABLE ? RECORDER_AUDIO_CODEC_DISABLE : audio_table[codec]);
int audio_disable = 0;
recorder_s *handle = (recorder_s *)recorder;
- if (recorder == NULL) {
- LOGE("handle is NULL");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
-
- if (codec == NULL) {
- LOGE("codec is NULL");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle && codec, RECORDER_ERROR_INVALID_PARAMETER);
ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
MMCAM_AUDIO_ENCODER, &mm_codec,
recorder_s *handle = (recorder_s *)recorder;
recorder_state_e state = RECORDER_STATE_NONE;
- if (handle == NULL) {
- LOGE("handle is NULL");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
-
- if (handle->camera_device_count == 0) {
- LOGE("RECORDER_ERROR_NOT_SUPPORTED");
- return RECORDER_ERROR_NOT_SUPPORTED;
- }
-
- if (codec > RECORDER_VIDEO_CODEC_THEORA) {
- LOGE("invalid codec %d", codec);
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
+ recorder_return_val_if_fail(handle->camera_device_count > 0, RECORDER_ERROR_NOT_SUPPORTED);
+ recorder_return_val_if_fail(codec <= RECORDER_VIDEO_CODEC_THEORA, RECORDER_ERROR_INVALID_PARAMETER);
legacy_recorder_get_state(recorder, &state);
- if (state > RECORDER_STATE_READY) {
- LOGE("RECORDER_ERROR_INVALID_STATE (state:%d)", state);
- return RECORDER_ERROR_INVALID_STATE;
- }
+
+ recorder_return_val_if_fail(state <= RECORDER_STATE_READY, RECORDER_ERROR_INVALID_STATE);
ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
MMCAM_VIDEO_ENCODER, video_table[codec],
int mm_codec = 0;
recorder_s *handle = (recorder_s *)recorder;
- if (handle == NULL) {
- LOGE("handle is NULL");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
- if (handle->camera_device_count == 0) {
- LOGE("RECORDER_ERROR_NOT_SUPPORTED");
- return RECORDER_ERROR_NOT_SUPPORTED;
- }
- if (codec == NULL) {
- LOGE("codec is NULL");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
+ recorder_return_val_if_fail(handle->camera_device_count > 0, RECORDER_ERROR_NOT_SUPPORTED);
+ recorder_return_val_if_fail(codec, RECORDER_ERROR_INVALID_PARAMETER);
ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
MMCAM_VIDEO_ENCODER, &mm_codec,
int legacy_recorder_attr_set_audio_samplerate(recorder_h recorder, int samplerate)
{
- if (samplerate < 1) {
- LOGE("invalid samplerate %d", samplerate);
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(samplerate > 0, RECORDER_ERROR_INVALID_PARAMETER);
return _recorder_check_and_set_attribute(recorder, MMCAM_AUDIO_SAMPLERATE, samplerate);
}
int legacy_recorder_attr_set_audio_encoder_bitrate(recorder_h recorder, int bitrate)
{
- if (bitrate < 1) {
- LOGE("invalid bitrate %d", bitrate);
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(bitrate > 0, RECORDER_ERROR_INVALID_PARAMETER);
return _recorder_check_and_set_attribute(recorder, MMCAM_AUDIO_ENCODER_BITRATE, bitrate);
}
int ret = MM_ERROR_NONE;
recorder_s *handle = (recorder_s *)recorder;
- if (handle == NULL) {
- LOGE("handle is NULL");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
- if (handle->camera_device_count == 0) {
- LOGE("RECORDER_ERROR_NOT_SUPPORTED");
- return RECORDER_ERROR_NOT_SUPPORTED;
- }
- if (bitrate <= 0) {
- LOGE("invalid bitrate %d", bitrate);
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
+ recorder_return_val_if_fail(handle->camera_device_count > 0, RECORDER_ERROR_NOT_SUPPORTED);
+ recorder_return_val_if_fail(bitrate > 0, RECORDER_ERROR_INVALID_PARAMETER);
ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
MMCAM_VIDEO_ENCODER_BITRATE, bitrate,
int ret = MM_ERROR_NONE;
recorder_s *handle = (recorder_s *)recorder;
- if (recorder == NULL) {
- LOGE("handle is NULL");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
MMCAM_TARGET_MAX_SIZE, kbyte,
int ret = MM_ERROR_NONE;
recorder_s *handle = (recorder_s *)recorder;
- if (recorder == NULL) {
- LOGE("handle is NULL");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
MMCAM_TARGET_TIME_LIMIT, second,
int ret = MM_ERROR_NONE;
recorder_s *handle = (recorder_s *)recorder;
- if (recorder == NULL) {
- LOGE("handle is NULL");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
MMCAM_AUDIO_DEVICE, device,
int ret = MM_ERROR_NONE;
recorder_s *handle = (recorder_s *)recorder;
- if (recorder == NULL) {
- LOGE("handle is NULL");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
MMCAM_AUDIO_SAMPLERATE, samplerate,
int ret = MM_ERROR_NONE;
recorder_s *handle = (recorder_s *)recorder;
- if (recorder == NULL) {
- LOGE("handle is NULL");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
MMCAM_AUDIO_ENCODER_BITRATE, bitrate,
int ret = MM_ERROR_NONE;
recorder_s *handle = (recorder_s *)recorder;
- if (handle == NULL) {
- LOGE("handle is NULL");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
- if (handle->camera_device_count == 0) {
- LOGE("RECORDER_ERROR_NOT_SUPPORTED");
- return RECORDER_ERROR_NOT_SUPPORTED;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
+ recorder_return_val_if_fail(handle->camera_device_count > 0, RECORDER_ERROR_NOT_SUPPORTED);
ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
MMCAM_VIDEO_ENCODER_BITRATE, bitrate,
recorder_s *handle = (recorder_s *)recorder;
MMCamAttrsInfo info;
- if (recorder == NULL) {
- LOGE("handle is NULL");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
- if (foreach_cb == NULL) {
- LOGE("foreach_cb is NULL");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle && foreach_cb, RECORDER_ERROR_INVALID_PARAMETER);
ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_AUDIO_ENCODER, &info);
if (ret != MM_ERROR_NONE)
recorder_s *handle = (recorder_s *)recorder;
MMCamAttrsInfo info;
- if (handle == NULL) {
- LOGE("handle is NULL");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
- if (handle->camera_device_count == 0) {
- LOGE("RECORDER_ERROR_NOT_SUPPORTED");
- return RECORDER_ERROR_NOT_SUPPORTED;
- }
- if (foreach_cb == NULL) {
- LOGE("foreach_cb is NULL");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
+ recorder_return_val_if_fail(handle->camera_device_count > 0, RECORDER_ERROR_NOT_SUPPORTED);
+ recorder_return_val_if_fail(foreach_cb, RECORDER_ERROR_INVALID_PARAMETER);
ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_VIDEO_ENCODER, &info);
if (ret != MM_ERROR_NONE)
int ret = MM_ERROR_NONE;
recorder_s *handle = (recorder_s *)recorder;
- if (recorder == NULL) {
- LOGE("handle is NULL");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
MMCAM_AUDIO_VOLUME, enable ? 0.0 : 1.0,
double volume = 1.0;
recorder_s *handle = (recorder_s *)recorder;
- if (recorder == NULL) {
- LOGE("handle is NULL");
- return false;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
MMCAM_AUDIO_VOLUME, &volume,
int ret = MM_ERROR_NONE;
recorder_s *handle = (recorder_s *)recorder;
- if (handle == NULL) {
- LOGE("handle is NULL");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
- if (handle->camera_device_count == 0) {
- LOGE("RECORDER_ERROR_NOT_SUPPORTED");
- return RECORDER_ERROR_NOT_SUPPORTED;
- }
- if (rate <= 0.0) {
- LOGE("invalid rate %lf", rate);
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
+ recorder_return_val_if_fail(handle->camera_device_count > 0, RECORDER_ERROR_NOT_SUPPORTED);
+ recorder_return_val_if_fail(rate > 0.0, RECORDER_ERROR_INVALID_PARAMETER);
ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
MMCAM_CAMERA_RECORDING_MOTION_RATE, rate,
int ret = MM_ERROR_NONE;
recorder_s *handle = (recorder_s *)recorder;
- if (handle == NULL) {
- LOGE("handle is NULL");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
- if (handle->camera_device_count == 0) {
- LOGE("RECORDER_ERROR_NOT_SUPPORTED");
- return RECORDER_ERROR_NOT_SUPPORTED;
- }
- if (rate == NULL) {
- LOGE("rate is NULL");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
+ recorder_return_val_if_fail(handle->camera_device_count > 0, RECORDER_ERROR_NOT_SUPPORTED);
+ recorder_return_val_if_fail(rate, RECORDER_ERROR_INVALID_PARAMETER);
ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
MMCAM_CAMERA_RECORDING_MOTION_RATE, rate,
int legacy_recorder_attr_set_audio_channel(recorder_h recorder, int channel_count)
{
- if (channel_count < 1 || channel_count > 2) {
- LOGE("invalid channel %d", channel_count);
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(channel_count == 1 || channel_count == 2, RECORDER_ERROR_INVALID_PARAMETER);
return _recorder_check_and_set_attribute(recorder, MMCAM_AUDIO_CHANNEL, channel_count);
}
int ret = MM_ERROR_NONE;
recorder_s *handle = (recorder_s *)recorder;
- if (recorder == NULL) {
- LOGE("handle is NULL");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
- if (channel_count == NULL) {
- LOGE("channel_count is NULL");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle && channel_count, RECORDER_ERROR_INVALID_PARAMETER);
ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
MMCAM_AUDIO_CHANNEL, channel_count,
int ret = MM_ERROR_NONE;
recorder_s *handle = (recorder_s *)recorder;
- if (handle == NULL) {
- LOGE("handle is NULL");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
- if (handle->camera_device_count == 0) {
- LOGE("RECORDER_ERROR_NOT_SUPPORTED");
- return RECORDER_ERROR_NOT_SUPPORTED;
- }
- if (orientation > RECORDER_ROTATION_270) {
- LOGE("invalid orientation %d", orientation);
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
+ recorder_return_val_if_fail(handle->camera_device_count > 0, RECORDER_ERROR_NOT_SUPPORTED);
+ recorder_return_val_if_fail(orientation <= RECORDER_ROTATION_270, RECORDER_ERROR_INVALID_PARAMETER);
ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
MMCAM_RECORDER_TAG_ENABLE, true,
int ret = MM_ERROR_NONE;
recorder_s *handle = (recorder_s *)recorder;
- if (handle == NULL) {
- LOGE("handle is NULL");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
- if (handle->camera_device_count == 0) {
- LOGE("RECORDER_ERROR_NOT_SUPPORTED");
- return RECORDER_ERROR_NOT_SUPPORTED;
- }
- if (orientation == NULL) {
- LOGE("orientation is NULL");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
+ recorder_return_val_if_fail(handle->camera_device_count > 0, RECORDER_ERROR_NOT_SUPPORTED);
+ recorder_return_val_if_fail(orientation, RECORDER_ERROR_INVALID_PARAMETER);
ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
MMCAM_TAG_VIDEO_ORIENTATION, orientation,
recorder_s *handle = (recorder_s *)recorder;
MMCamcorderStateType mmstate = MM_CAMCORDER_STATE_NONE;
- if (recorder == NULL) {
- LOGE("handle is NULL");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
-
- if (root_directory == NULL) {
- LOGE("filename is NULL");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle && root_directory, RECORDER_ERROR_INVALID_PARAMETER);
mm_camcorder_get_state(handle->mm_handle, &mmstate);
- if (mmstate >= MM_CAMCORDER_STATE_RECORDING) {
- LOGE("invalid state %d", mmstate);
- return RECORDER_ERROR_INVALID_STATE;
- }
+
+ recorder_return_val_if_fail(mmstate < MM_CAMCORDER_STATE_RECORDING, RECORDER_ERROR_INVALID_STATE);
ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
MMCAM_ROOT_DIRECTORY, root_directory, strlen(root_directory),
recorder_s *handle = (recorder_s *)recorder;
MMCamcorderStateType mmstate = MM_CAMCORDER_STATE_NONE;
- if (recorder == NULL) {
- LOGE("handle is NULL");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
-
- if (stream_type == NULL || stream_index < 0) {
- LOGE("invalid parameter %p %d", stream_type, stream_index);
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
+ recorder_return_val_if_fail(stream_type && stream_index >= 0, RECORDER_ERROR_INVALID_PARAMETER);
mm_camcorder_get_state(handle->mm_handle, &mmstate);
- if (mmstate >= MM_CAMCORDER_STATE_RECORDING) {
- LOGE("invalid state %d", mmstate);
- return RECORDER_ERROR_INVALID_STATE;
- }
+
+ recorder_return_val_if_fail(mmstate < MM_CAMCORDER_STATE_RECORDING, RECORDER_ERROR_INVALID_STATE);
ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
MMCAM_SOUND_STREAM_TYPE, stream_type, strlen(stream_type),
int ret = MM_ERROR_NONE;
recorder_s *handle = (recorder_s *)recorder;
- if (recorder == NULL) {
- LOGE("handle is NULL");
- return RECORDER_ERROR_INVALID_PARAMETER;
- }
+ recorder_return_val_if_fail(handle, RECORDER_ERROR_INVALID_PARAMETER);
LOGW("storage state %d", storage_state);
#define RECORDER_DEVICE_STATE_KEY_AUDIO "device_state_recorder_audio"
#define RECORDER_DEVICE_STATE_KEY_VIDEO "device_state_recorder_video"
+#define recorder_return_if_fail(expr) \
+ do { \
+ if (!(expr)) { \
+ LOGE("failed [%s]", #expr); \
+ return; \
+ } \
+ } while (0)
+
+#define recorder_return_val_if_fail(expr, val) \
+ do { \
+ if (!(expr)) { \
+ LOGE("failed [%s]", #expr); \
+ return (val); \
+ } \
+ } while (0)
+
+#define recorder_send_msg_return_err_if_fail(expr, ret, err) \
+ do { \
+ if (!(expr)) { \
+ int _ret = ret; \
+ LOGE("failed [%s]", #expr); \
+ muse_recorder_msg_return(api, class, _ret, module); \
+ return err; \
+ } \
+ } while (0)
+
static GMutex g_recorder_device_state_lock;
{
muse_module_h module = (muse_module_h)user_data;
- if (module == NULL) {
- LOGE("NULL module");
- return;
- }
+ recorder_return_if_fail(module);
muse_recorder_msg_event1(MUSE_RECORDER_CB_EVENT,
MUSE_RECORDER_EVENT_TYPE_RECORDING_LIMITED,
int64_t cb_elapsed_time = (int64_t)elapsed_time;
int64_t cb_file_size = (int64_t)file_size;
- if (module == NULL) {
- LOGE("NULL module");
- return;
- }
+ recorder_return_if_fail(module);
muse_recorder_msg_event2(MUSE_RECORDER_CB_EVENT,
MUSE_RECORDER_EVENT_TYPE_RECORDING_STATUS,
RECORDER_DEVICE_STATE_IDLE /* 1:MUSE_RECORDER_TYPE_VIDEO */
};
- if (module == NULL) {
- LOGE("NULL module");
- return;
- }
+ recorder_return_if_fail(module);
muse_recorder_msg_event3(MUSE_RECORDER_CB_EVENT,
MUSE_RECORDER_EVENT_TYPE_STATE_CHANGE,
INT, by_policy);
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (!muse_recorder) {
- LOGW("NULL muse recorder handle");
- return;
- }
+
+ recorder_return_if_fail(muse_recorder);
g_mutex_lock(&g_recorder_device_state_lock);
return;
}
+//LCOV_EXCL_START
void _recorder_disp_interrupted_cb(recorder_policy_e policy, recorder_state_e previous, recorder_state_e current, void *user_data)
{
muse_module_h module = (muse_module_h)user_data;
- if (module == NULL) {
- LOGE("NULL module");
- return;
- }
+ recorder_return_if_fail(module);
muse_recorder_msg_event3(MUSE_RECORDER_CB_EVENT,
MUSE_RECORDER_EVENT_TYPE_INTERRUPTED,
{
muse_module_h module = (muse_module_h)user_data;
- if (module == NULL) {
- LOGE("NULL module");
- return;
- }
+ recorder_return_if_fail(module);
muse_recorder_msg_event2(MUSE_RECORDER_CB_EVENT,
MUSE_RECORDER_EVENT_TYPE_INTERRUPT_STARTED,
{
muse_module_h module = (muse_module_h)user_data;
- if (module == NULL) {
- LOGE("NULL module");
- return;
- }
+ recorder_return_if_fail(module);
muse_recorder_msg_event2(MUSE_RECORDER_CB_EVENT,
MUSE_RECORDER_EVENT_TYPE_ERROR,
return;
}
+//LCOV_EXCL_STOP
void _recorder_disp_audio_stream_cb(void* stream, int size, recorder_sample_type_e format, int channel, unsigned int timestamp, void *user_data)
{
tbm_bo bo = NULL;
tbm_bo_handle bo_handle = {.ptr = NULL};
- if (module == NULL || stream == NULL) {
- LOGE("NULL data %p, %p", module, stream);
- return;
- }
+ recorder_return_if_fail(module && stream);
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- return;
- }
+
+ recorder_return_if_fail(muse_recorder);
export_data = g_new0(muse_recorder_export_data, 1);
- if (export_data == NULL) {
- LOGE("alloc export_data failed");
- return;
- }
- LOGD("Enter");
+ /*LOGD("Enter");*/
/* make tbm bo */
bo = tbm_bo_alloc(muse_recorder->bufmgr, size, TBM_BO_DEFAULT);
tbm_bo bo = NULL;
tbm_bo_handle bo_handle = {.ptr = NULL};
- if (!module || !stream) {
- LOGE("NULL data %p, %p", module, stream);
- return;
- }
+ recorder_return_if_fail(module && stream);
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (!muse_recorder) {
- LOGE("NULL handle");
- return;
- }
+
+ recorder_return_if_fail(muse_recorder);
export_data = g_new0(muse_recorder_export_data, 1);
- if (export_data == NULL) {
- LOGE("alloc export_data failed");
- return;
- }
/*LOGD("Enter");*/
{
muse_module_h module = (muse_module_h)user_data;
- if (module == NULL) {
- LOGE("NULL module");
- return false;
- }
+ recorder_return_val_if_fail(module, false);
muse_recorder_msg_event2(MUSE_RECORDER_CB_EVENT,
MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_RESOLUTION,
{
muse_module_h module = (muse_module_h)user_data;
- if (module == NULL) {
- LOGE("NULL module");
- return false;
- }
+ recorder_return_val_if_fail(module, false);
muse_recorder_msg_event1(MUSE_RECORDER_CB_EVENT,
MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_FILE_FORMAT,
{
muse_module_h module = (muse_module_h)user_data;
- if (module == NULL) {
- LOGE("NULL module");
- return false;
- }
+ recorder_return_val_if_fail(module, false);
muse_recorder_msg_event1(MUSE_RECORDER_CB_EVENT,
MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_AUDIO_ENCODER,
{
muse_module_h module = (muse_module_h)user_data;
- if (module == NULL) {
- LOGE("NULL module");
- return false;
- }
+ recorder_return_val_if_fail(module, false);
muse_recorder_msg_event1(MUSE_RECORDER_CB_EVENT,
MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_ENCODER,
GList *tmp_list = NULL;
muse_recorder_export_data *export_data = NULL;
- if (module == NULL || (fd < 0 && remove_all == FALSE)) {
- LOGE("invalid parameter %p, %d", module, fd);
- return FALSE;
- }
+ recorder_return_val_if_fail(module && (fd >= 0 || remove_all), FALSE);
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- return FALSE;
- }
+
+ recorder_return_val_if_fail(muse_recorder, FALSE);
g_mutex_lock(&muse_recorder->list_lock);
bool feature_supported = false;
const char *feature_name = NULL;
- if (type != MUSE_RECORDER_TYPE_AUDIO && type != MUSE_RECORDER_TYPE_VIDEO) {
- LOGE("invalid type %d", type);
- return false;
- }
+ recorder_return_val_if_fail(type == MUSE_RECORDER_TYPE_AUDIO || type == MUSE_RECORDER_TYPE_VIDEO, false);
if (type == MUSE_RECORDER_TYPE_AUDIO)
feature_name = AUDIO_RECORDING_FEATURE_NAME;
LOGD("Enter - type %d", recorder_type);
/* init handle */
- muse_recorder = (muse_recorder_handle_s *)malloc(sizeof(muse_recorder_handle_s));
- if (muse_recorder == NULL) {
- ret = RECORDER_ERROR_OUT_OF_MEMORY;
- LOGE("handle alloc failed 0x%x", ret);
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_INVALID;
- }
-
- memset(muse_recorder, 0x0, sizeof(muse_recorder_handle_s));
+ muse_recorder = g_new0(muse_recorder_handle_s, 1);
muse_recorder->type = recorder_type;
g_mutex_init(&muse_recorder->list_lock);
if (muse_server_ipc_get_bufmgr(&muse_recorder->bufmgr) != MM_ERROR_NONE ||
muse_server_ipc_get_gdbus_connection((GDBusConnection **)&gdbus_connection) != MM_ERROR_NONE) {
- LOGE("tbm bufmgr or gdbus conntection failed %p %p", muse_recorder->bufmgr, gdbus_connection);
+ LOGE("tbm bufmgr or gdbus connection failed %p %p", muse_recorder->bufmgr, gdbus_connection);
ret = RECORDER_ERROR_INVALID_OPERATION;
goto _CREATE_ERROR;
}
muse_recorder_msg_return1(api, class, ret, module, POINTER, handle);
return MUSE_RECORDER_ERROR_NONE;
-
+//LCOV_EXCL_START
_CREATE_ERROR:
if (muse_recorder->recorder_handle) {
legacy_recorder_destroy(muse_recorder->recorder_handle);
}
g_mutex_clear(&muse_recorder->list_lock);
- free(muse_recorder);
- muse_recorder = NULL;
+ g_free(muse_recorder);
LOGE("error 0x%x", ret);
muse_recorder_msg_return(api, class, ret, module);
return MUSE_RECORDER_ERROR_INVALID;
+//LCOV_EXCL_STOP
}
int recorder_dispatcher_destroy(muse_module_h module)
muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
ret = legacy_recorder_destroy(muse_recorder->recorder_handle);
if (ret == RECORDER_ERROR_NONE) {
muse_recorder->bufmgr = NULL;
- free(muse_recorder);
- muse_recorder = NULL;
+ g_free(muse_recorder);
} else {
LOGE("recorder destroy failed 0x%x", ret);
}
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
ret = legacy_recorder_get_state(muse_recorder->recorder_handle, &get_state);
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
if (muse_recorder->type == MUSE_RECORDER_TYPE_VIDEO) {
client_fd = muse_server_module_get_msg_fd(module);
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
ret = legacy_recorder_unprepare(muse_recorder->recorder_handle);
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
/* privilege check */
client_fd = muse_server_module_get_msg_fd(module);
if (client_fd < 0) {
+//LCOV_EXCL_START
ret = RECORDER_ERROR_INVALID_OPERATION;
LOGE("failed to get fd %d", client_fd);
muse_recorder_msg_return(api, class, ret, module);
return MUSE_RECORDER_ERROR_INVALID;
+//LCOV_EXCL_STOP
}
if (!muse_server_security_check_cynara(client_fd, RECORDER_PRIVILEGE_NAME)) {
+//LCOV_EXCL_START
LOGE("security(recorder) check failed");
ret = RECORDER_ERROR_PERMISSION_DENIED;
muse_recorder_msg_return(api, class, ret, module);
return MUSE_RECORDER_ERROR_INVALID;
+//LCOV_EXCL_STOP
}
ret = legacy_recorder_start(muse_recorder->recorder_handle);
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
ret = legacy_recorder_pause(muse_recorder->recorder_handle);
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
ret = legacy_recorder_commit(muse_recorder->recorder_handle);
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
ret = legacy_recorder_cancel(muse_recorder->recorder_handle);
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
muse_recorder_msg_get(width, muse_server_module_get_msg(module));
muse_recorder_msg_get(height, muse_server_module_get_msg(module));
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
ret = legacy_recorder_get_video_resolution(muse_recorder->recorder_handle, &get_width, &get_height);
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
ret = legacy_recorder_foreach_supported_video_resolution(muse_recorder->recorder_handle,
(recorder_supported_video_resolution_cb)_recorder_disp_foreach_supported_video_resolution_cb,
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
ret = legacy_recorder_get_audio_level(muse_recorder->recorder_handle, &get_level);
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
muse_recorder_msg_get_string(set_filename, muse_server_module_get_msg(module));
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
ret = legacy_recorder_get_filename(muse_recorder->recorder_handle, &get_filename);
if (ret == RECORDER_ERROR_NONE && get_filename)
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
muse_recorder_msg_get(set_format, muse_server_module_get_msg(module));
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
ret = legacy_recorder_get_file_format(muse_recorder->recorder_handle, &get_format);
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
ret = legacy_recorder_set_interrupted_cb(muse_recorder->recorder_handle,
(recorder_interrupted_cb)_recorder_disp_interrupted_cb,
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
ret = legacy_recorder_unset_interrupted_cb(muse_recorder->recorder_handle);
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
ret = legacy_recorder_set_interrupt_started_cb(muse_recorder->recorder_handle,
(recorder_interrupt_started_cb)_recorder_disp_interrupt_started_cb,
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
ret = legacy_recorder_unset_interrupt_started_cb(muse_recorder->recorder_handle);
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- } else {
- ret = legacy_recorder_set_audio_stream_cb(muse_recorder->recorder_handle,
- (recorder_audio_stream_cb)_recorder_disp_audio_stream_cb, (void *)module);
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
+
+ ret = legacy_recorder_set_audio_stream_cb(muse_recorder->recorder_handle,
+ (recorder_audio_stream_cb)_recorder_disp_audio_stream_cb, (void *)module);
muse_recorder_msg_return(api, class, ret, module);
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- } else {
- ret = legacy_recorder_unset_audio_stream_cb(muse_recorder->recorder_handle);
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
+
+ ret = legacy_recorder_unset_audio_stream_cb(muse_recorder->recorder_handle);
muse_recorder_msg_return(api, class, ret, module);
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
ret = legacy_recorder_set_error_cb(muse_recorder->recorder_handle,
(recorder_error_cb)_recorder_disp_error_cb,
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
ret = legacy_recorder_unset_error_cb(muse_recorder->recorder_handle);
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
ret = legacy_recorder_set_recording_status_cb(muse_recorder->recorder_handle,
(recorder_recording_status_cb)_recorder_disp_recording_status_cb,
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
ret = legacy_recorder_unset_recording_status_cb(muse_recorder->recorder_handle);
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
ret = legacy_recorder_set_recording_limit_reached_cb(muse_recorder->recorder_handle,
(recorder_recording_limit_reached_cb)_recorder_disp_recording_limit_reached_cb,
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
ret = legacy_recorder_unset_recording_limit_reached_cb(muse_recorder->recorder_handle);
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
ret = legacy_recorder_foreach_supported_file_format(muse_recorder->recorder_handle,
(recorder_supported_file_format_cb)_recorder_disp_foreach_supported_file_format_cb,
return MUSE_RECORDER_ERROR_NONE;
}
+//LCOV_EXCL_START
int recorder_dispatcher_foreach_supported_file_format_by_audio_encoder(muse_module_h module)
{
int ret = RECORDER_ERROR_NONE;
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
muse_recorder_msg_get(audio_codec, muse_server_module_get_msg(module));
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
muse_recorder_msg_get(video_codec, muse_server_module_get_msg(module));
return MUSE_RECORDER_ERROR_NONE;
}
+//LCOV_EXCL_STOP
int recorder_dispatcher_attr_set_size_limit(muse_module_h module)
{
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
muse_recorder_msg_get(kbyte, muse_server_module_get_msg(module));
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
muse_recorder_msg_get(second, muse_server_module_get_msg(module));
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
muse_recorder_msg_get(set_device, muse_server_module_get_msg(module));
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
muse_recorder_msg_get(set_codec, muse_server_module_get_msg(module));
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
ret = legacy_recorder_get_audio_encoder(muse_recorder->recorder_handle, &get_codec);
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
muse_recorder_msg_get(set_codec, muse_server_module_get_msg(module));
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
ret = legacy_recorder_get_video_encoder(muse_recorder->recorder_handle, &get_codec);
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
muse_recorder_msg_get(samplerate, muse_server_module_get_msg(module));
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
muse_recorder_msg_get(bitrate, muse_server_module_get_msg(module));
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
muse_recorder_msg_get(bitrate, muse_server_module_get_msg(module));
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
ret = legacy_recorder_attr_get_size_limit(muse_recorder->recorder_handle, &get_kbyte);
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
ret = legacy_recorder_attr_get_time_limit(muse_recorder->recorder_handle, &get_second);
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
ret = legacy_recorder_attr_get_audio_device(muse_recorder->recorder_handle, &get_device);
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
ret = legacy_recorder_attr_get_audio_samplerate(muse_recorder->recorder_handle, &get_samplerate);
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
ret = legacy_recorder_attr_get_audio_encoder_bitrate(muse_recorder->recorder_handle, &get_bitrate);
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
ret = legacy_recorder_attr_get_video_encoder_bitrate(muse_recorder->recorder_handle, &get_bitrate);
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
ret = legacy_recorder_foreach_supported_audio_encoder(muse_recorder->recorder_handle,
(recorder_supported_audio_encoder_cb)_recorder_disp_foreach_supported_audio_encoder_cb,
return MUSE_RECORDER_ERROR_NONE;
}
+//LCOV_EXCL_START
int recorder_dispatcher_foreach_supported_audio_encoder_by_file_format(muse_module_h module)
{
int ret = RECORDER_ERROR_NONE;
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
muse_recorder_msg_get(file_format, muse_server_module_get_msg(module));
return MUSE_RECORDER_ERROR_NONE;
}
+//LCOV_EXCL_STOP
int recorder_dispatcher_foreach_supported_video_encoder(muse_module_h module)
{
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
ret = legacy_recorder_foreach_supported_video_encoder(muse_recorder->recorder_handle,
(recorder_supported_video_encoder_cb)_recorder_disp_foreach_supported_video_encoder_cb,
return MUSE_RECORDER_ERROR_NONE;
}
+//LCOV_EXCL_START
int recorder_dispatcher_foreach_supported_video_encoder_by_file_format(muse_module_h module)
{
int ret = RECORDER_ERROR_NONE;
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
muse_recorder_msg_get(file_format, muse_server_module_get_msg(module));
return MUSE_RECORDER_ERROR_NONE;
}
+//LCOV_EXCL_STOP
int recorder_dispatcher_attr_set_mute(muse_module_h module)
{
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
muse_recorder_msg_get(set_enable, muse_server_module_get_msg(module));
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
ret = legacy_recorder_attr_is_muted(muse_recorder->recorder_handle);
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
muse_recorder_msg_get_double(rate, muse_server_module_get_msg(module));
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
ret = legacy_recorder_attr_get_recording_motion_rate(muse_recorder->recorder_handle, &get_rate);
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
muse_recorder_msg_get(channel_count, muse_server_module_get_msg(module));
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
ret = legacy_recorder_attr_get_audio_channel(muse_recorder->recorder_handle, &get_channel_count);
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
muse_recorder_msg_get(set_orientation, muse_server_module_get_msg(module));
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
ret = legacy_recorder_attr_get_orientation_tag(muse_recorder->recorder_handle, &get_orientation);
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
muse_recorder_msg_get_string(root_directory, muse_server_module_get_msg(module));
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_return_val_if_fail(muse_recorder, MUSE_RECORDER_ERROR_NONE);
muse_recorder_msg_get(ret_fd, muse_server_module_get_msg(module));
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- muse_recorder_msg_return(api, class, ret, module);
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
muse_recorder_msg_get_string(stream_type, muse_server_module_get_msg(module));
muse_recorder_msg_get(stream_index, muse_server_module_get_msg(module));
/* recording feature check */
if (!_recorder_check_supported_feature(recorder_type)) {
+//LCOV_EXCL_START
LOGE("feature not supported");
ret = RECORDER_ERROR_NOT_SUPPORTED;
muse_recorder_msg_return(api, class, ret, module);
return MUSE_RECORDER_ERROR_NONE;
+//LCOV_EXCL_STOP
}
if (recorder_type == RECORDER_TYPE_AUDIO)
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (!muse_recorder) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- } else {
- ret = legacy_recorder_set_muxed_stream_cb(muse_recorder->recorder_handle,
- (recorder_muxed_stream_cb)_recorder_disp_muxed_stream_cb, (void *)module);
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
+
+ ret = legacy_recorder_set_muxed_stream_cb(muse_recorder->recorder_handle,
+ (recorder_muxed_stream_cb)_recorder_disp_muxed_stream_cb, (void *)module);
muse_recorder_msg_return(api, class, ret, module);
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (!muse_recorder) {
- LOGE("NULL handle");
- ret = RECORDER_ERROR_INVALID_OPERATION;
- } else {
- ret = legacy_recorder_unset_muxed_stream_cb(muse_recorder->recorder_handle);
- }
+
+ recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
+
+ ret = legacy_recorder_unset_muxed_stream_cb(muse_recorder->recorder_handle);
muse_recorder_msg_return(api, class, ret, module);
/******************/
/* cmd dispatcher */
/******************/
+//LCOV_EXCL_START
static int recorder_cmd_dispatcher_initialize(muse_module_h module)
{
int item_count = 0;
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_return_val_if_fail(muse_recorder, MUSE_RECORDER_ERROR_NONE);
legacy_recorder_get_state(muse_recorder->recorder_handle, &state);
muse_recorder_handle_s *muse_recorder = NULL;
muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
- if (muse_recorder == NULL) {
- LOGE("NULL handle");
- return MUSE_RECORDER_ERROR_NONE;
- }
+
+ recorder_return_val_if_fail(muse_recorder, MUSE_RECORDER_ERROR_NONE);
storage_state = (int)(long)muse_server_get_user_data(module);
return MUSE_RECORDER_ERROR_NONE;
}
+//LCOV_EXCL_STOP
int (*cmd_dispatcher[MUSE_MODULE_COMMAND_MAX])(muse_module_h module) = {
projects / platform / core / multimedia / mmsvc-recorder.git / commitdiff