* @brief Enumeration for error code of the media recorder.
* @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
*/
-typedef enum
-{
+typedef enum {
RECORDER_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful */
RECORDER_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */
RECORDER_ERROR_INVALID_STATE = RECORDER_ERROR_CLASS | 0x02, /**< Invalid state */
* @brief Enumeration for recorder states.
* @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
*/
-typedef enum
-{
+typedef enum {
RECORDER_STATE_NONE, /**< Recorder is not created */
RECORDER_STATE_CREATED, /**< Recorder is created, but not prepared */
RECORDER_STATE_READY, /**< Recorder is ready to record \n In case of video recorder, preview display will be shown */
* @brief Enumeration for the recording limit.
* @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
*/
-typedef enum
-{
+typedef enum {
RECORDER_RECORDING_LIMIT_TIME, /**< Time limit (second) of recording file */
RECORDER_RECORDING_LIMIT_SIZE, /**< Size limit (kilo bytes [KB]) of recording file */
RECORDER_RECORDING_LIMIT_FREE_SPACE, /**< No free space in storage */
* @brief Enumeration for the file container format.
* @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
*/
-typedef enum
-{
+typedef enum {
RECORDER_FILE_FORMAT_3GP, /**< 3GP file format */
RECORDER_FILE_FORMAT_MP4, /**< MP4 file format */
RECORDER_FILE_FORMAT_AMR, /**< AMR file format */
* @brief Enumeration for the audio codec.
* @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
*/
-typedef enum
-{
+typedef enum {
RECORDER_AUDIO_CODEC_DISABLE = -1, /**< Disable audio track */
RECORDER_AUDIO_CODEC_AMR = 0, /**< AMR codec */
RECORDER_AUDIO_CODEC_AAC, /**< AAC codec */
* @brief Enumeration for the video codec.
* @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
*/
-typedef enum
-{
+typedef enum {
RECORDER_VIDEO_CODEC_H263, /**< H263 codec */
RECORDER_VIDEO_CODEC_H264, /**< H264 codec */
RECORDER_VIDEO_CODEC_MPEG4, /**< MPEG4 codec */
* @brief Enumeration for audio capture devices.
* @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
*/
-typedef enum
-{
+typedef enum {
RECORDER_AUDIO_DEVICE_MIC, /**< Mic device */
RECORDER_AUDIO_DEVICE_MODEM, /**< Modem */
} recorder_audio_device_e;
* @brief Enumeration for the recorder rotation type.
* @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
*/
-typedef enum
-{
+typedef enum {
RECORDER_ROTATION_NONE, /**< No rotation */
RECORDER_ROTATION_90, /**< 90 degree rotation */
RECORDER_ROTATION_180, /**< 180 degree rotation */
* @brief Enumeration for the recorder policy.
* @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
*/
-typedef enum
-{
+typedef enum {
RECORDER_POLICY_NONE = 0, /**< None */
RECORDER_POLICY_SOUND, /**< Sound policy */
RECORDER_POLICY_SOUND_BY_CALL, /**< Sound policy by CALL */
* @see recorder_commit()
* @see recorder_cancel()
*/
-typedef void (*recorder_state_changed_cb)(recorder_state_e previous , recorder_state_e current , bool by_policy, void *user_data);
+typedef void (*recorder_state_changed_cb)(recorder_state_e previous, recorder_state_e current, bool by_policy, void *user_data);
/**
* @brief Called when the recorder is interrupted by a policy.
* @see recorder_supported_video_resolution_cb()
*/
int legacy_recorder_foreach_supported_video_resolution(recorder_h recorder,
- recorder_supported_video_resolution_cb foreach_cb, void *user_data);
+ recorder_supported_video_resolution_cb foreach_cb, void *user_data);
/**
* @}
* @see recorder_unset_interrupted_cb()
* @see recorder_interrupted_cb()
*/
-int legacy_recorder_set_interrupted_cb(recorder_h recorder, recorder_interrupted_cb callback,
- void *user_data);
+int legacy_recorder_set_interrupted_cb(recorder_h recorder, recorder_interrupted_cb callback, void *user_data);
/**
* @brief Unregisters the callback function.
* @pre The recorder state must be #RECORDER_STATE_CREATED or #RECORDER_STATE_READY.
* @see recorder_attr_get_recording_motion_rate()
*/
-int legacy_recorder_attr_set_recording_motion_rate(recorder_h recorder , double rate);
+int legacy_recorder_attr_set_recording_motion_rate(recorder_h recorder, double rate);
/**
* @brief Gets the recording motion rate.
* @retval #RECORDER_ERROR_NOT_SUPPORTED The feature is not supported
* @see recorder_attr_set_recording_motion_rate()
*/
-int legacy_recorder_attr_get_recording_motion_rate(recorder_h recorder , double *rate);
+int legacy_recorder_attr_get_recording_motion_rate(recorder_h recorder, double *rate);
/**
* @brief Sets the number of the audio channel.
}
#endif
-#endif //__TIZEN_MULTIMEDIA_LEGACY_RECORDER_INTERNAL_H__
+#endif /* __TIZEN_MULTIMEDIA_LEGACY_RECORDER_INTERNAL_H__ */
extern "C" {
#endif
-typedef union _mediaSource{
+typedef union _mediaSource {
camera_h camera;
-}mediasource;
+} mediasource;
typedef enum {
_RECORDER_EVENT_TYPE_AUDIO_STREAM,
_RECORDER_EVENT_TYPE_ERROR,
_RECORDER_EVENT_TYPE_NUM
-}_recorder_event_e;
+} _recorder_event_e;
typedef enum {
_RECORDER_TYPE_AUDIO = 0,
_RECORDER_TYPE_VIDEO
-}_recorder_type_e;
+} _recorder_type_e;
typedef enum {
_RECORDER_SOURCE_TYPE_UNKNOWN,
_RECORDER_SOURCE_TYPE_CAMERA,
-}_recorder_source_type_e;
+} _recorder_source_type_e;
-typedef struct _recorder_s{
+typedef struct _recorder_s {
MMHandleType mm_handle;
mediasource mm_source;
void* user_cb[_RECORDER_EVENT_TYPE_NUM];
}
#endif
-#endif //__TIZEN_MULTIMEDIA_RECORDER_PRIVATE_H__
+#endif /* __TIZEN_MULTIMEDIA_RECORDER_PRIVATE_H__ */
int new_code = code;
switch (code) {
- case CAMERA_ERROR_INVALID_STATE :
+ case CAMERA_ERROR_INVALID_STATE:
new_code = RECORDER_ERROR_INVALID_STATE;
break;
case CAMERA_ERROR_DEVICE:
ret = RECORDER_ERROR_NONE;
errorstr = "ERROR_NONE";
break;
- case MM_ERROR_CAMCORDER_INVALID_ARGUMENT :
- case MM_ERROR_COMMON_INVALID_ATTRTYPE :
+ case MM_ERROR_CAMCORDER_INVALID_ARGUMENT:
+ case MM_ERROR_COMMON_INVALID_ATTRTYPE:
ret = RECORDER_ERROR_INVALID_PARAMETER;
errorstr = "INVALID_PARAMETER";
break;
- case MM_ERROR_COMMON_INVALID_PERMISSION :
+ 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 :
+ 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 :
+ 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 :
- case MM_ERROR_CAMCORDER_GST_STREAM :
- case MM_ERROR_CAMCORDER_GST_STATECHANGE :
- case MM_ERROR_CAMCORDER_GST_NEGOTIATION :
- case MM_ERROR_CAMCORDER_GST_LINK :
- case MM_ERROR_CAMCORDER_GST_FLOW_ERROR :
- case MM_ERROR_CAMCORDER_ENCODER :
- case MM_ERROR_CAMCORDER_ENCODER_BUFFER :
- case MM_ERROR_CAMCORDER_ENCODER_WRONG_TYPE :
- case MM_ERROR_CAMCORDER_ENCODER_WORKING :
- case MM_ERROR_CAMCORDER_INTERNAL :
- case MM_ERROR_CAMCORDER_RESPONSE_TIMEOUT :
- case MM_ERROR_CAMCORDER_CMD_IS_RUNNING :
- case MM_ERROR_CAMCORDER_DSP_FAIL :
- case MM_ERROR_CAMCORDER_AUDIO_EMPTY :
- case MM_ERROR_CAMCORDER_CREATE_CONFIGURE :
- case MM_ERROR_CAMCORDER_FILE_SIZE_OVER :
- case MM_ERROR_CAMCORDER_DISPLAY_DEVICE_OFF :
- case MM_ERROR_CAMCORDER_INVALID_CONDITION :
+ case MM_ERROR_CAMCORDER_GST_CORE:
+ case MM_ERROR_CAMCORDER_GST_LIBRARY:
+ case MM_ERROR_CAMCORDER_GST_RESOURCE:
+ case MM_ERROR_CAMCORDER_GST_STREAM:
+ case MM_ERROR_CAMCORDER_GST_STATECHANGE:
+ case MM_ERROR_CAMCORDER_GST_NEGOTIATION:
+ case MM_ERROR_CAMCORDER_GST_LINK:
+ case MM_ERROR_CAMCORDER_GST_FLOW_ERROR:
+ case MM_ERROR_CAMCORDER_ENCODER:
+ case MM_ERROR_CAMCORDER_ENCODER_BUFFER:
+ case MM_ERROR_CAMCORDER_ENCODER_WRONG_TYPE:
+ case MM_ERROR_CAMCORDER_ENCODER_WORKING:
+ case MM_ERROR_CAMCORDER_INTERNAL:
+ case MM_ERROR_CAMCORDER_RESPONSE_TIMEOUT:
+ case MM_ERROR_CAMCORDER_CMD_IS_RUNNING:
+ case MM_ERROR_CAMCORDER_DSP_FAIL:
+ case MM_ERROR_CAMCORDER_AUDIO_EMPTY:
+ case MM_ERROR_CAMCORDER_CREATE_CONFIGURE:
+ case MM_ERROR_CAMCORDER_FILE_SIZE_OVER:
+ case MM_ERROR_CAMCORDER_DISPLAY_DEVICE_OFF:
+ case MM_ERROR_CAMCORDER_INVALID_CONDITION:
ret = RECORDER_ERROR_INVALID_OPERATION;
errorstr = "INVALID_OPERATION";
break;
- case MM_ERROR_CAMCORDER_RESOURCE_CREATION :
+ case MM_ERROR_CAMCORDER_RESOURCE_CREATION:
case MM_ERROR_COMMON_OUT_OF_MEMORY:
ret = RECORDER_ERROR_OUT_OF_MEMORY;
errorstr = "OUT_OF_MEMORY";
LOGE("RECORDER_POLICY_SECURITY");
}
- if (previous_state != handle->state && handle->user_cb[_RECORDER_EVENT_TYPE_STATE_CHANGE]) {
+ 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]);
- }
/* should change intermediate state MM_CAMCORDER_STATE_READY is not valid in capi , change to NULL state */
if (policy != RECORDER_POLICY_NONE &&
- (m->state.current == MM_CAMCORDER_STATE_PAUSED || m->state.current == MM_CAMCORDER_STATE_NULL)) {
- if (handle->user_cb[_RECORDER_EVENT_TYPE_INTERRUPTED]) {
+ (m->state.current == MM_CAMCORDER_STATE_PAUSED || m->state.current == MM_CAMCORDER_STATE_NULL)) {
+ if (handle->user_cb[_RECORDER_EVENT_TYPE_INTERRUPTED])
((recorder_interrupted_cb)handle->user_cb[_RECORDER_EVENT_TYPE_INTERRUPTED])(policy, previous_state, handle->state, handle->user_data[_RECORDER_EVENT_TYPE_INTERRUPTED]);
- } else {
+ else
LOGW("_RECORDER_EVENT_TYPE_INTERRUPTED cb is NULL");
- }
}
break;
case MM_MESSAGE_CAMCORDER_MAX_SIZE:
case MM_MESSAGE_CAMCORDER_NO_FREE_SPACE:
case MM_MESSAGE_CAMCORDER_TIME_LIMIT:
- if (MM_MESSAGE_CAMCORDER_MAX_SIZE == message) {
+ if (MM_MESSAGE_CAMCORDER_MAX_SIZE == message)
type = RECORDER_RECORDING_LIMIT_SIZE;
- } else if (MM_MESSAGE_CAMCORDER_NO_FREE_SPACE == message) {
+ else if (MM_MESSAGE_CAMCORDER_NO_FREE_SPACE == message)
type = RECORDER_RECORDING_LIMIT_FREE_SPACE;
- } else {
+ else
type = RECORDER_RECORDING_LIMIT_TIME;
- }
- if (handle->user_cb[_RECORDER_EVENT_TYPE_RECORDING_LIMITED]) {
- ((recorder_recording_limit_reached_cb)handle->user_cb[_RECORDER_EVENT_TYPE_RECORDING_LIMITED])(type, handle->user_data[_RECORDER_EVENT_TYPE_RECORDING_LIMITED]);
- }
+
+ if (handle->user_cb[_RECORDER_EVENT_TYPE_RECORDING_LIMITED])
+ ((recorder_recording_limit_reached_cb)handle->user_cb[_RECORDER_EVENT_TYPE_RECORDING_LIMITED])(type,
+ handle->user_data[_RECORDER_EVENT_TYPE_RECORDING_LIMITED]);
break;
case MM_MESSAGE_CAMCORDER_RECORDING_STATUS:
- if (handle->user_cb[_RECORDER_EVENT_TYPE_RECORDING_STATUS]) {
- ((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]);
- }
+ if (handle->user_cb[_RECORDER_EVENT_TYPE_RECORDING_STATUS])
+ ((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;
case MM_MESSAGE_CAMCORDER_ERROR:
switch (m->code) {
break;
}
- if (recorder_error != 0 && handle->user_cb[_RECORDER_EVENT_TYPE_ERROR]) {
+ if (recorder_error != 0 && handle->user_cb[_RECORDER_EVENT_TYPE_ERROR])
((recorder_error_cb)handle->user_cb[_RECORDER_EVENT_TYPE_ERROR])(recorder_error, handle->state, handle->user_data[_RECORDER_EVENT_TYPE_ERROR]);
- }
break;
case MM_MESSAGE_CAMCORDER_CURRENT_VOLUME:
- if (handle->last_max_input_level < m->rec_volume_dB) {
+ if (handle->last_max_input_level < m->rec_volume_dB)
handle->last_max_input_level = m->rec_volume_dB;
- }
break;
default:
break;
static int __mm_audio_stream_cb(MMCamcorderAudioStreamDataType *stream, void *user_param)
{
- if (user_param == NULL || stream == NULL) {
+ if (user_param == NULL || stream == NULL)
return 0;
- }
recorder_s *handle = (recorder_s *)user_param;
audio_sample_type_e format = AUDIO_SAMPLE_TYPE_U8;
- if (stream->format == MM_CAMCORDER_AUDIO_FORMAT_PCM_S16_LE) {
+ if (stream->format == MM_CAMCORDER_AUDIO_FORMAT_PCM_S16_LE)
format = AUDIO_SAMPLE_TYPE_S16_LE;
- }
- if( handle->user_cb[_RECORDER_EVENT_TYPE_AUDIO_STREAM] ){
+ if (handle->user_cb[_RECORDER_EVENT_TYPE_AUDIO_STREAM]) {
((recorder_audio_stream_cb)(handle->user_cb[_RECORDER_EVENT_TYPE_AUDIO_STREAM]))(stream->data, stream->length, format,
- stream->channel, stream->timestamp,
- handle->user_data[_RECORDER_EVENT_TYPE_AUDIO_STREAM]);
+ stream->channel, stream->timestamp,
+ handle->user_data[_RECORDER_EVENT_TYPE_AUDIO_STREAM]);
}
return 1;
if (handle->type == _RECORDER_TYPE_AUDIO && mmstate == MM_CAMCORDER_STATE_PREPARE) {
mm_camcorder_get_attributes(handle->mm_handle, NULL,
- MMCAM_AUDIO_DISABLE, ¤t_audio_disable,
- attribute_name, ¤t_value,
- NULL);
+ MMCAM_AUDIO_DISABLE, ¤t_audio_disable,
+ attribute_name, ¤t_value,
+ NULL);
if (current_value != set_value) {
LOGD("try to reset pipeline");
if (!strcmp(attribute_name, MMCAM_AUDIO_ENCODER)) {
if (set_value == RECORDER_AUDIO_CODEC_DISABLE) {
ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
- MMCAM_AUDIO_DISABLE, true,
- NULL);
+ MMCAM_AUDIO_DISABLE, true,
+ NULL);
} else {
ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
- MMCAM_AUDIO_DISABLE, false,
- MMCAM_AUDIO_ENCODER, set_value,
- NULL);
+ MMCAM_AUDIO_DISABLE, false,
+ MMCAM_AUDIO_ENCODER, set_value,
+ NULL);
}
} else {
ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
- attribute_name, set_value,
- NULL);
+ attribute_name, set_value,
+ NULL);
}
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
LOGE("set [%s] failed 0x%x", attribute_name, ret);
- }
if (reset_pipeline) {
ret2 = mm_camcorder_realize(handle->mm_handle);
if (ret2 != MM_ERROR_NONE) {
restore_set = true;
+
/* determine return value */
- if (ret == MM_ERROR_NONE) {
+ if (ret == MM_ERROR_NONE)
ret = ret2;
- }
}
}
if (restore_set) {
ret2 = mm_camcorder_set_attributes(handle->mm_handle, NULL,
- MMCAM_AUDIO_DISABLE, current_audio_disable,
- attribute_name, current_value,
- NULL);
+ MMCAM_AUDIO_DISABLE, current_audio_disable,
+ attribute_name, current_value,
+ NULL);
LOGW("restore attribute set : 0x%x", ret2);
ret2 = mm_camcorder_realize(handle->mm_handle);
return RECORDER_ERROR_INVALID_PARAMETER;
}
- handle = (recorder_s*)malloc( sizeof(recorder_s) );
- if(handle == NULL){
+ handle = (recorder_s*)malloc(sizeof(recorder_s));
+ if (handle == NULL) {
LOGE("[%s] malloc error", __func__);
return RECORDER_ERROR_OUT_OF_MEMORY;
}
legacy_recorder_get_state((recorder_h)handle, (recorder_state_e*)&handle->state);
mm_camcorder_get_attributes(handle->mm_handle, NULL,
- MMCAM_CAMERA_FORMAT, &preview_format,
- NULL);
+ MMCAM_CAMERA_FORMAT, &preview_format,
+ NULL);
handle->origin_preview_format = preview_format;
+
mm_camcorder_get_attributes(handle->mm_handle, NULL,
- MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_RECORDING, &preview_format,
- NULL);
- ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL,
- MMCAM_CAMERA_DEVICE_COUNT, &camera_device_count,
- NULL);
+ MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_RECORDING, &preview_format,
+ NULL);
+
+ ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
+ MMCAM_CAMERA_DEVICE_COUNT, &camera_device_count,
+ NULL);
if (ret != MM_ERROR_NONE) {
free(handle);
handle = NULL;
LOGE("get device count error");
return __convert_recorder_error_code(__func__, ret);
}
+
if (camera_device_count == 0) {
free(handle);
handle = NULL;
_camera_set_use(camera, true);
if (handle->state == RECORDER_STATE_CREATED) {
ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
- MMCAM_CAMERA_FORMAT, preview_format,
- NULL);
- if (ret == MM_ERROR_NONE) {
+ MMCAM_CAMERA_FORMAT, preview_format,
+ NULL);
+ if (ret == MM_ERROR_NONE)
handle->changed_preview_format = preview_format;
- }
}
*recorder = (recorder_h)handle;
}
ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
- MMCAM_MODE, MM_CAMCORDER_MODE_AUDIO,
- NULL);
-
+ MMCAM_MODE, MM_CAMCORDER_MODE_AUDIO,
+ NULL);
if (ret != MM_ERROR_NONE) {
mm_camcorder_destroy(handle->mm_handle);
free(handle);
LOGE("AUDIO mode setting fail");
return __convert_recorder_error_code(__func__, ret);
}
- ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL,
- MMCAM_CAMERA_DEVICE_COUNT, &camera_device_count, NULL);
+
+ ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
+ MMCAM_CAMERA_DEVICE_COUNT, &camera_device_count,
+ NULL);
if (ret != MM_ERROR_NONE) {
mm_camcorder_destroy(handle->mm_handle);
free(handle);
recorder_s *handle = (recorder_s*)recorder;
ret = mm_camcorder_get_state(handle->mm_handle, &mmstate);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
return __convert_recorder_error_code(__func__, ret);
- }
*state = __recorder_state_convert(mmstate);
/* set to unsed */
_camera_set_use(handle->mm_source.camera, false);
ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
- MMCAM_CAMERA_FORMAT, &preview_format,
- NULL);
+ MMCAM_CAMERA_FORMAT, &preview_format,
+ NULL);
/* preview format was changed? */
if (ret == MM_ERROR_NONE && preview_format == handle->changed_preview_format) {
ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
- MMCAM_CAMERA_FORMAT, handle->origin_preview_format,
- NULL);
+ MMCAM_CAMERA_FORMAT, handle->origin_preview_format,
+ NULL);
}
- if (ret == MM_ERROR_NONE) {
+ if (ret == MM_ERROR_NONE)
_camera_set_relay_mm_message_callback(handle->mm_source.camera, NULL, NULL);
- }
} else {
ret = mm_camcorder_destroy(handle->mm_handle);
}
- if (ret == MM_ERROR_NONE) {
+ if (ret == MM_ERROR_NONE)
free(handle);
- }
return __convert_recorder_error_code(__func__, ret);
}
return RECORDER_ERROR_INVALID_PARAMETER;
}
- if (handle->type == _RECORDER_TYPE_VIDEO) {
+ if (handle->type == _RECORDER_TYPE_VIDEO)
return __convert_error_code_camera_to_recorder(legacy_camera_start_preview(handle->mm_source.camera));
- }
ret = mm_camcorder_get_state(handle->mm_handle, &mmstate);
ret = mm_camcorder_get_state(handle->mm_handle, &mmstate);
if (ret == MM_ERROR_NONE && mmstate == MM_CAMCORDER_STATE_PREPARE) {
ret = mm_camcorder_stop(handle->mm_handle);
- if( ret != MM_ERROR_NONE){
+ if (ret != MM_ERROR_NONE)
LOGE("mm_camcorder_stop fail");
- }
}
if (ret == MM_ERROR_NONE) {
}
ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
- MMCAM_VIDEO_WIDTH, width,
- MMCAM_VIDEO_HEIGHT, height,
- NULL);
+ MMCAM_VIDEO_WIDTH, width,
+ MMCAM_VIDEO_HEIGHT, height,
+ NULL);
return __convert_recorder_error_code(__func__, ret);
}
}
ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
- MMCAM_VIDEO_WIDTH, width,
- MMCAM_VIDEO_HEIGHT, height,
- NULL);
+ MMCAM_VIDEO_WIDTH, width,
+ MMCAM_VIDEO_HEIGHT, height,
+ NULL);
return __convert_recorder_error_code(__func__, ret);
}
int legacy_recorder_foreach_supported_video_resolution(recorder_h recorder,
- recorder_supported_video_resolution_cb foreach_cb, void *user_data)
+ recorder_supported_video_resolution_cb foreach_cb, void *user_data)
{
int i = 0;
int ret = MM_ERROR_NONE;
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);
- if (ret != MM_ERROR_NONE ) {
+ if (ret != MM_ERROR_NONE)
return __convert_recorder_error_code(__func__, ret);
- }
for (i = 0 ; i < video_width.int_array.count ; i++) {
- if (!foreach_cb(video_width.int_array.array[i], video_height.int_array.array[i], user_data)) {
+ if (!foreach_cb(video_width.int_array.array[i], video_height.int_array.array[i], user_data))
break;
- }
}
return RECORDER_ERROR_NONE;
}
ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
- MMCAM_TARGET_FILENAME, filename, strlen(filename),
- NULL);
+ MMCAM_TARGET_FILENAME, filename, strlen(filename),
+ NULL);
return __convert_recorder_error_code(__func__, ret);
}
int legacy_recorder_set_file_format(recorder_h recorder, recorder_file_format_e format)
{
- int format_table[7] = { MM_FILE_FORMAT_3GP, /* RECORDER_FILE_FORMAT_3GP */
- MM_FILE_FORMAT_MP4, /* RECORDER_FILE_FORMAT_MP4 */
- MM_FILE_FORMAT_AMR, /* RECORDER_FILE_FORMAT_AMR */
- MM_FILE_FORMAT_AAC, /* RECORDER_FILE_FORMAT_ADTS */
- MM_FILE_FORMAT_WAV, /* RECORDER_FILE_FORMAT_WAV */
- MM_FILE_FORMAT_OGG, /* RECORDER_FILE_FORMAT_OGG */
- MM_FILE_FORMAT_M2TS /* RECORDER_FILE_FORMAT_M2TS */
+ int format_table[7] = {
+ MM_FILE_FORMAT_3GP, /* RECORDER_FILE_FORMAT_3GP */
+ MM_FILE_FORMAT_MP4, /* RECORDER_FILE_FORMAT_MP4 */
+ MM_FILE_FORMAT_AMR, /* RECORDER_FILE_FORMAT_AMR */
+ MM_FILE_FORMAT_AAC, /* RECORDER_FILE_FORMAT_ADTS */
+ MM_FILE_FORMAT_WAV, /* RECORDER_FILE_FORMAT_WAV */
+ MM_FILE_FORMAT_OGG, /* RECORDER_FILE_FORMAT_OGG */
+ MM_FILE_FORMAT_M2TS /* RECORDER_FILE_FORMAT_M2TS */
};
if (format < RECORDER_FILE_FORMAT_3GP || format > RECORDER_FILE_FORMAT_M2TS) {
}
ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
- MMCAM_FILE_FORMAT, &mm_format,
- NULL);
+ MMCAM_FILE_FORMAT, &mm_format,
+ NULL);
if (ret == MM_ERROR_NONE) {
switch (mm_format) {
case MM_FILE_FORMAT_3GP:
*format = RECORDER_FILE_FORMAT_3GP;
break;
- case MM_FILE_FORMAT_MP4 :
+ case MM_FILE_FORMAT_MP4:
*format = RECORDER_FILE_FORMAT_MP4;
break;
- case MM_FILE_FORMAT_AMR :
+ case MM_FILE_FORMAT_AMR:
*format = RECORDER_FILE_FORMAT_AMR;
break;
- case MM_FILE_FORMAT_AAC :
+ case MM_FILE_FORMAT_AAC:
*format = RECORDER_FILE_FORMAT_ADTS;
break;
case MM_FILE_FORMAT_WAV:
case MM_FILE_FORMAT_M2TS:
*format = RECORDER_FILE_FORMAT_M2TS;
break;
- default :
+ default:
ret = MM_ERROR_CAMCORDER_INTERNAL;
break;
}
}
ret = mm_camcorder_set_audio_stream_callback(handle->mm_handle, __mm_audio_stream_cb, handle);
- if (ret == MM_ERROR_NONE){
+ if (ret == MM_ERROR_NONE) {
handle->user_cb[_RECORDER_EVENT_TYPE_AUDIO_STREAM] = callback;
handle->user_data[_RECORDER_EVENT_TYPE_AUDIO_STREAM] = user_data;
}
case MM_FILE_FORMAT_3GP:
format = RECORDER_FILE_FORMAT_3GP;
break;
- case MM_FILE_FORMAT_MP4 :
+ case MM_FILE_FORMAT_MP4:
format = RECORDER_FILE_FORMAT_MP4;
break;
- case MM_FILE_FORMAT_AMR :
+ case MM_FILE_FORMAT_AMR:
format = RECORDER_FILE_FORMAT_AMR;
break;
case MM_FILE_FORMAT_AAC:
case MM_FILE_FORMAT_M2TS:
format = RECORDER_FILE_FORMAT_M2TS;
break;
- default :
+ default:
format = -1;
break;
}
- if (format != -1 && !foreach_cb(format,user_data)) {
+ if (format != -1 && !foreach_cb(format, user_data))
break;
- }
}
return RECORDER_ERROR_NONE;
}
ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
- MMCAM_TARGET_MAX_SIZE, kbyte,
- NULL);
+ MMCAM_TARGET_MAX_SIZE, kbyte,
+ NULL);
return __convert_recorder_error_code(__func__, ret);
}
}
ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
- MMCAM_TARGET_TIME_LIMIT, second,
- NULL);
+ MMCAM_TARGET_TIME_LIMIT, second,
+ NULL);
return __convert_recorder_error_code(__func__, ret);
}
}
ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
- MMCAM_AUDIO_ENCODER, &mm_codec,
- MMCAM_AUDIO_DISABLE, &audio_disable,
- NULL);
+ MMCAM_AUDIO_ENCODER, &mm_codec,
+ MMCAM_AUDIO_DISABLE, &audio_disable,
+ NULL);
if (ret == MM_ERROR_NONE && audio_disable == 0) {
switch (mm_codec) {
- case MM_AUDIO_CODEC_AMR :
+ case MM_AUDIO_CODEC_AMR:
*codec = RECORDER_AUDIO_CODEC_AMR;
break;
- case MM_AUDIO_CODEC_AAC :
+ case MM_AUDIO_CODEC_AAC:
*codec = RECORDER_AUDIO_CODEC_AAC;
break;
case MM_AUDIO_CODEC_VORBIS:
case MM_AUDIO_CODEC_WAVE:
*codec = RECORDER_AUDIO_CODEC_PCM;
break;
- default :
+ default:
ret = MM_ERROR_CAMCORDER_INTERNAL;
break;
}
int legacy_recorder_set_video_encoder(recorder_h recorder, recorder_video_codec_e codec)
{
int ret = MM_ERROR_NONE;
- int video_table[4] = { MM_VIDEO_CODEC_H263, /* RECORDER_VIDEO_CODEC_H263 */
- MM_VIDEO_CODEC_H264, /* RECORDER_VIDEO_CODEC_H264 */
- MM_VIDEO_CODEC_MPEG4, /* RECORDER_VIDEO_CODEC_MPEG4 */
- MM_VIDEO_CODEC_THEORA /* RECORDER_VIDEO_CODEC_THEORA */
+ int video_table[4] = {
+ MM_VIDEO_CODEC_H263, /* RECORDER_VIDEO_CODEC_H263 */
+ MM_VIDEO_CODEC_H264, /* RECORDER_VIDEO_CODEC_H264 */
+ MM_VIDEO_CODEC_MPEG4, /* RECORDER_VIDEO_CODEC_MPEG4 */
+ MM_VIDEO_CODEC_THEORA /* RECORDER_VIDEO_CODEC_THEORA */
};
recorder_s *handle = (recorder_s *)recorder;
}
ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
- MMCAM_VIDEO_ENCODER, video_table[codec],
- NULL);
+ MMCAM_VIDEO_ENCODER, video_table[codec],
+ NULL);
return __convert_recorder_error_code(__func__, ret);
}
}
ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
- MMCAM_VIDEO_ENCODER, &mm_codec,
- NULL);
+ MMCAM_VIDEO_ENCODER, &mm_codec,
+ NULL);
if (ret == MM_ERROR_NONE) {
- switch(mm_codec) {
- case MM_VIDEO_CODEC_H263 :
+ switch (mm_codec) {
+ case MM_VIDEO_CODEC_H263:
*codec = RECORDER_VIDEO_CODEC_H263;
break;
- case MM_VIDEO_CODEC_H264 :
+ case MM_VIDEO_CODEC_H264:
*codec = RECORDER_VIDEO_CODEC_H264;
break;
- case MM_VIDEO_CODEC_MPEG4 :
+ case MM_VIDEO_CODEC_MPEG4:
*codec = RECORDER_VIDEO_CODEC_MPEG4;
break;
case MM_VIDEO_CODEC_THEORA:
*codec = RECORDER_VIDEO_CODEC_THEORA;
break;
- default :
+ default:
ret = MM_ERROR_CAMCORDER_INTERNAL;
break;
}
}
ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
- MMCAM_VIDEO_ENCODER_BITRATE, bitrate,
- NULL);
+ MMCAM_VIDEO_ENCODER_BITRATE, bitrate,
+ NULL);
return __convert_recorder_error_code(__func__, ret);
}
}
ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
- MMCAM_TARGET_MAX_SIZE, kbyte,
- NULL);
+ MMCAM_TARGET_MAX_SIZE, kbyte,
+ NULL);
return __convert_recorder_error_code(__func__, ret);
}
}
ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
- MMCAM_TARGET_TIME_LIMIT, second,
- NULL);
+ MMCAM_TARGET_TIME_LIMIT, second,
+ NULL);
return __convert_recorder_error_code(__func__, ret);
}
}
ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
- MMCAM_AUDIO_DEVICE, device,
- NULL);
+ MMCAM_AUDIO_DEVICE, device,
+ NULL);
return __convert_recorder_error_code(__func__, ret);
}
}
ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
- MMCAM_AUDIO_SAMPLERATE, samplerate,
- NULL);
+ MMCAM_AUDIO_SAMPLERATE, samplerate,
+ NULL);
return __convert_recorder_error_code(__func__, ret);
}
}
ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
- MMCAM_AUDIO_ENCODER_BITRATE, bitrate,
- NULL);
+ MMCAM_AUDIO_ENCODER_BITRATE, bitrate,
+ NULL);
return __convert_recorder_error_code(__func__, ret);
}
LOGE("RECORDER_ERROR_NOT_SUPPORTED");
return RECORDER_ERROR_NOT_SUPPORTED;
}
+
ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
- MMCAM_VIDEO_ENCODER_BITRATE, bitrate,
- NULL);
+ MMCAM_VIDEO_ENCODER_BITRATE, bitrate,
+ NULL);
return __convert_recorder_error_code(__func__, ret);
}
}
ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_AUDIO_ENCODER, &info);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
return __convert_recorder_error_code(__func__, ret);
- }
for (i = 0 ; i < info.int_array.count ; i++) {
switch (info.int_array.array[i]) {
case MM_AUDIO_CODEC_AMR:
codec = RECORDER_AUDIO_CODEC_AMR;
break;
- case MM_AUDIO_CODEC_AAC :
+ case MM_AUDIO_CODEC_AAC:
codec = RECORDER_AUDIO_CODEC_AAC;
break;
case MM_AUDIO_CODEC_VORBIS:
case MM_AUDIO_CODEC_WAVE:
codec = RECORDER_AUDIO_CODEC_PCM;
break;
- default :
+ default:
codec = -1;
break;
}
- if (codec != -1 && !foreach_cb(codec,user_data)) {
+
+ if (codec != -1 && !foreach_cb(codec, user_data))
break;
- }
}
return RECORDER_ERROR_NONE;
}
ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_VIDEO_ENCODER, &info);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
return __convert_recorder_error_code(__func__, ret);
- }
for (i = 0 ; i < info.int_array.count ; i++) {
- switch (info.int_array.array[i]){
- case MM_VIDEO_CODEC_H263 :
+ switch (info.int_array.array[i]) {
+ case MM_VIDEO_CODEC_H263:
codec = RECORDER_VIDEO_CODEC_H263;
break;
- case MM_VIDEO_CODEC_H264 :
+ case MM_VIDEO_CODEC_H264:
codec = RECORDER_VIDEO_CODEC_H264;
break;
- case MM_VIDEO_CODEC_MPEG4 :
+ case MM_VIDEO_CODEC_MPEG4:
codec = RECORDER_VIDEO_CODEC_MPEG4;
break;
- case MM_VIDEO_CODEC_THEORA :
+ case MM_VIDEO_CODEC_THEORA:
codec = RECORDER_VIDEO_CODEC_THEORA;
break;
- default :
+ default:
codec = -1;
break;
}
- if (codec != -1 && !foreach_cb(codec,user_data)) {
+ if (codec != -1 && !foreach_cb(codec, user_data))
break;
- }
}
return RECORDER_ERROR_NONE;
}
ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
- MMCAM_AUDIO_VOLUME, enable ? 0.0 : 1.0,
- NULL);
+ MMCAM_AUDIO_VOLUME, enable ? 0.0 : 1.0,
+ NULL);
return __convert_recorder_error_code(__func__, ret);
}
}
ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
- MMCAM_AUDIO_VOLUME, &volume,
- NULL);
+ MMCAM_AUDIO_VOLUME, &volume,
+ NULL);
set_last_result(__convert_recorder_error_code(__func__, ret));
- if (volume == 0.0) {
+ if (volume == 0.0)
return true;
- } else {
+ else
return false;
- }
}
}
ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
- MMCAM_CAMERA_RECORDING_MOTION_RATE, rate,
- NULL);
+ MMCAM_CAMERA_RECORDING_MOTION_RATE, rate,
+ NULL);
return __convert_recorder_error_code(__func__, ret);
}
}
ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
- MMCAM_CAMERA_RECORDING_MOTION_RATE, rate,
- NULL);
+ MMCAM_CAMERA_RECORDING_MOTION_RATE, rate,
+ NULL);
return __convert_recorder_error_code(__func__, ret);
}
}
ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
- MMCAM_AUDIO_CHANNEL, channel_count,
- NULL);
+ MMCAM_AUDIO_CHANNEL, channel_count,
+ NULL);
return __convert_recorder_error_code(__func__, ret);
}
}
ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
- MMCAM_RECORDER_TAG_ENABLE, true,
- MMCAM_TAG_VIDEO_ORIENTATION, orientation,
- NULL);
+ MMCAM_RECORDER_TAG_ENABLE, true,
+ MMCAM_TAG_VIDEO_ORIENTATION, orientation,
+ NULL);
return __convert_recorder_error_code(__func__, ret);
}
}
ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
- MMCAM_TAG_VIDEO_ORIENTATION, orientation,
- NULL);
+ MMCAM_TAG_VIDEO_ORIENTATION, orientation,
+ NULL);
return __convert_recorder_error_code(__func__, ret);
}
}
ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
- MMCAM_ROOT_DIRECTORY, root_directory, strlen(root_directory),
- NULL);
+ MMCAM_ROOT_DIRECTORY, root_directory, strlen(root_directory),
+ NULL);
return __convert_recorder_error_code(__func__, ret);
}
LOGD("pid %d", pid);
ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
- MMCAM_PID_FOR_SOUND_FOCUS, pid,
- NULL);
+ MMCAM_PID_FOR_SOUND_FOCUS, pid,
+ NULL);
return __convert_recorder_error_code(__func__, ret);
}
* @brief Enumeration for the muse recorder apis.
*/
typedef enum {
- MUSE_RECORDER_API_CREATE, //0
+ MUSE_RECORDER_API_CREATE, /* 0 */
MUSE_RECORDER_API_DESTROY,
MUSE_RECORDER_API_GET_STATE,
MUSE_RECORDER_API_PREPARE,
MUSE_RECORDER_API_UNPREPARE,
- MUSE_RECORDER_API_START, //5
+ MUSE_RECORDER_API_START, /* 5 */
MUSE_RECORDER_API_PAUSE,
MUSE_RECORDER_API_COMMIT,
MUSE_RECORDER_API_CANCEL,
MUSE_RECORDER_API_SET_VIDEO_RESOLUTION,
- MUSE_RECORDER_API_GET_VIDEO_RESOLUTION, //10
+ MUSE_RECORDER_API_GET_VIDEO_RESOLUTION, /* 10 */
MUSE_RECORDER_API_FOREACH_SUPPORTED_VIDEO_RESOLUTION,
MUSE_RECORDER_API_GET_AUDIO_LEVEL,
MUSE_RECORDER_API_SET_FILENAME,
MUSE_RECORDER_API_GET_FILENAME,
- MUSE_RECORDER_API_SET_FILE_FORMAT, //15
+ MUSE_RECORDER_API_SET_FILE_FORMAT, /* 15 */
MUSE_RECORDER_API_GET_FILE_FORMAT,
MUSE_RECORDER_API_SET_STATE_CHANGED_CB,
MUSE_RECORDER_API_UNSET_STATE_CHANGED_CB,
MUSE_RECORDER_API_SET_INTERRUPTED_CB,
- MUSE_RECORDER_API_UNSET_INTERRUPTED_CB, //20
+ MUSE_RECORDER_API_UNSET_INTERRUPTED_CB, /* 20 */
MUSE_RECORDER_API_SET_AUDIO_STREAM_CB,
MUSE_RECORDER_API_UNSET_AUDIO_STREAM_CB,
MUSE_RECORDER_API_SET_ERROR_CB,
MUSE_RECORDER_API_UNSET_ERROR_CB,
- MUSE_RECORDER_API_SET_RECORDING_STATUS_CB, //25
+ MUSE_RECORDER_API_SET_RECORDING_STATUS_CB, /* 25 */
MUSE_RECORDER_API_UNSET_RECORDING_STATUS_CB,
MUSE_RECORDER_API_SET_RECORDING_LIMIT_REACHED_CB,
MUSE_RECORDER_API_UNSET_RECORDING_LIMIT_REACHED_CB,
MUSE_RECORDER_API_FOREACH_SUPPORTED_FILE_FORMAT,
- MUSE_RECORDER_API_ATTR_SET_SIZE_LIMIT, //30
+ MUSE_RECORDER_API_ATTR_SET_SIZE_LIMIT, /* 30 */
MUSE_RECORDER_API_ATTR_SET_TIME_LIMIT,
MUSE_RECORDER_API_ATTR_SET_AUDIO_DEVICE,
MUSE_RECORDER_API_SET_AUDIO_ENCODER,
MUSE_RECORDER_API_GET_AUDIO_ENCODER,
- MUSE_RECORDER_API_SET_VIDEO_ENCODER, //35
+ MUSE_RECORDER_API_SET_VIDEO_ENCODER, /* 35 */
MUSE_RECORDER_API_GET_VIDEO_ENCODER,
MUSE_RECORDER_API_ATTR_SET_AUDIO_SAMPLERATE,
MUSE_RECORDER_API_ATTR_SET_AUDIO_ENCODER_BITRATE,
MUSE_RECORDER_API_ATTR_SET_VIDEO_ENCODER_BITRATE,
- MUSE_RECORDER_API_ATTR_GET_SIZE_LIMIT, //40
+ MUSE_RECORDER_API_ATTR_GET_SIZE_LIMIT, /* 40 */
MUSE_RECORDER_API_ATTR_GET_TIME_LIMIT,
MUSE_RECORDER_API_ATTR_GET_AUDIO_DEVICE,
MUSE_RECORDER_API_ATTR_GET_AUDIO_SAMPLERATE,
MUSE_RECORDER_API_ATTR_GET_AUDIO_ENCODER_BITRATE,
- MUSE_RECORDER_API_ATTR_GET_VIDEO_ENCODER_BITRATE, //45
+ MUSE_RECORDER_API_ATTR_GET_VIDEO_ENCODER_BITRATE, /* 45 */
MUSE_RECORDER_API_FOREACH_SUPPORTED_AUDIO_ENCODER,
MUSE_RECORDER_API_FOREACH_SUPPORTED_VIDEO_ENCODER,
MUSE_RECORDER_API_ATTR_SET_MUTE,
MUSE_RECORDER_API_ATTR_IS_MUTED,
- MUSE_RECORDER_API_ATTR_SET_RECORDING_MOTION_RATE, //50
+ MUSE_RECORDER_API_ATTR_SET_RECORDING_MOTION_RATE, /* 50 */
MUSE_RECORDER_API_ATTR_GET_RECORDING_MOTION_RATE,
MUSE_RECORDER_API_ATTR_SET_AUDIO_CHANNEL,
MUSE_RECORDER_API_ATTR_GET_AUDIO_CHANNEL,
MUSE_RECORDER_API_ATTR_SET_ORIENTATION_TAG,
- MUSE_RECORDER_API_ATTR_GET_ORIENTATION_TAG, //55
+ MUSE_RECORDER_API_ATTR_GET_ORIENTATION_TAG, /* 55 */
MUSE_RECORDER_API_ATTR_SET_ROOT_DIRECTORY,
MUSE_RECORDER_API_RETURN_BUFFER,
MUSE_RECORDER_API_SET_SOUND_STREAM_INFO,
/**
* @brief Definition for the wait time of the ipc callback.
*/
-#define RECORDER_CALLBACK_TIME_OUT 3
+#define RECORDER_CALLBACK_TIME_OUT 3
#ifdef __cplusplus
* @param[out] ret The delivered return value from the module to proxy side.
*/
#define muse_recorder_msg_send(api, fd, cb_info, ret) \
- do{ \
+ do { \
char *__sndMsg__; \
int __len__; \
__sndMsg__ = muse_core_msg_json_factory_new(api, 0); \
} else \
ret = client_wait_for_cb_return(api, cb_info, RECORDER_CALLBACK_TIME_OUT); \
muse_core_msg_json_factory_free(__sndMsg__); \
- }while(0)
+ } while (0)
/**
* @param[in] param A single parameter to be included in the message.
*/
#define muse_recorder_msg_send1(api, fd, cb_info, ret, type, param) \
- do{ \
+ do { \
char *__sndMsg__; \
int __len__; \
type __value__ = (type)param; \
__sndMsg__ = muse_core_msg_json_factory_new(api, \
- MUSE_TYPE_##type, #param, __value__, \
- 0); \
+ MUSE_TYPE_##type, #param, __value__, \
+ 0); \
__len__ = muse_core_ipc_send_msg(fd, __sndMsg__); \
if (__len__ <= 0) { \
LOGE("sending message failed"); \
} else \
ret = client_wait_for_cb_return(api, cb_info, RECORDER_CALLBACK_TIME_OUT); \
muse_core_msg_json_factory_free(__sndMsg__); \
- }while(0)
+ } while (0)
/**
* @brief Send the message from proxy to module via ipc, adding 1 more parameter.
* @param[in] param A single parameter to be included in the message.
*/
#define muse_recorder_msg_send1_no_return(api, fd, cb_info, type, param) \
- do{ \
+ do { \
char *__sndMsg__; \
int __len__; \
type __value__ = (type)param; \
__sndMsg__ = muse_core_msg_json_factory_new(api, \
- MUSE_TYPE_##type, #param, __value__, \
- 0); \
+ MUSE_TYPE_##type, #param, __value__, \
+ 0); \
__len__ = muse_core_ipc_send_msg(fd, __sndMsg__); \
if (__len__ <= 0) { \
LOGE("sending message failed"); \
} \
muse_core_msg_json_factory_free(__sndMsg__); \
- }while(0)
+ } while (0)
/**
* @brief Send the message from proxy to module via ipc, adding 2 more parameters.
* @param[in] param2 The 2nd parameter to be included in the message.
*/
#define muse_recorder_msg_send2(api, fd, cb_info, ret, type1, param1, type2, param2) \
- do{ \
+ do { \
char *__sndMsg__; \
int __len__; \
type1 __value1__ = (type1)param1; \
type2 __value2__ = (type2)param2; \
__sndMsg__ = muse_core_msg_json_factory_new(api, \
- MUSE_TYPE_##type1, #param1, __value1__, \
- MUSE_TYPE_##type2, #param2, __value2__, \
- 0); \
+ MUSE_TYPE_##type1, #param1, __value1__, \
+ MUSE_TYPE_##type2, #param2, __value2__, \
+ 0); \
__len__ = muse_core_ipc_send_msg(fd, __sndMsg__); \
if (__len__ <= 0) { \
LOGE("sending message failed"); \
} else \
ret = client_wait_for_cb_return(api, cb_info, RECORDER_CALLBACK_TIME_OUT); \
muse_core_msg_json_factory_free(__sndMsg__); \
- }while(0)
+ } while (0)
/**
* @param[in] datum_size The size of the array.
*/
#define muse_recorder_msg_send_array(api, fd, cb_info, ret, param, length, datum_size) \
- do{ \
+ do { \
char *__sndMsg__; \
int __len__; \
int *__value__ = (int *)param; \
__sndMsg__ = muse_core_msg_json_factory_new(api, \
- MUSE_TYPE_INT, #length, length, \
- MUSE_TYPE_ARRAY, #param, \
- datum_size == sizeof(int)? length : \
- length / sizeof(int) + (length % sizeof(int)?1:0), \
- __value__, \
- 0); \
+ MUSE_TYPE_INT, #length, length, \
+ MUSE_TYPE_ARRAY, #param, \
+ datum_size == sizeof(int) ? length : \
+ length / sizeof(int) + (length % sizeof(int) ? 1 : 0), \
+ __value__, \
+ 0); \
__len__ = muse_core_ipc_send_msg(fd, __sndMsg__); \
if (__len__ <= 0) { \
LOGE("sending message failed"); \
} else \
ret = client_wait_for_cb_return(api, cb_info, RECORDER_CALLBACK_TIME_OUT); \
muse_core_msg_json_factory_free(__sndMsg__); \
- }while(0)
+ } while (0)
/**
* @brief Returning the ack message from the server to client side.
* @param[in] module The module info for the ipc transportation.
*/
#define muse_recorder_msg_return(api, class, ret, module) \
- do{ \
+ do { \
char *__sndMsg__; \
int __len__; \
__sndMsg__ = muse_core_msg_json_factory_new(api, \
- MUSE_TYPE_INT, PARAM_API_CLASS, class, \
- MUSE_TYPE_INT, PARAM_RET, ret, \
- 0); \
+ MUSE_TYPE_INT, PARAM_API_CLASS, class, \
+ MUSE_TYPE_INT, PARAM_RET, ret, \
+ 0); \
__len__ = muse_core_ipc_send_msg(muse_core_client_get_msg_fd(module), __sndMsg__); \
if (__len__ <= 0) { \
LOGE("sending message failed"); \
ret = RECORDER_ERROR_INVALID_OPERATION; \
} \
muse_core_msg_json_factory_free(__sndMsg__); \
- }while(0)
+ } while (0)
/**
* @brief Returning the ack message from the server to client side.
* @param[in] param A parameter to be included in the message.
*/
#define muse_recorder_msg_return1(api, class, ret, module, type, param) \
- do{ \
+ do { \
char *__sndMsg__; \
int __len__; \
type __value__ = (type)param; \
__sndMsg__ = muse_core_msg_json_factory_new(api, \
- MUSE_TYPE_INT, PARAM_API_CLASS, class, \
- MUSE_TYPE_INT, PARAM_RET, ret, \
- MUSE_TYPE_##type, #param, __value__, \
- 0); \
+ MUSE_TYPE_INT, PARAM_API_CLASS, class, \
+ MUSE_TYPE_INT, PARAM_RET, ret, \
+ MUSE_TYPE_##type, #param, __value__, \
+ 0); \
__len__ = muse_core_ipc_send_msg(muse_core_client_get_msg_fd(module), __sndMsg__); \
if (__len__ <= 0) { \
LOGE("sending message failed"); \
ret = RECORDER_ERROR_INVALID_OPERATION; \
} \
muse_core_msg_json_factory_free(__sndMsg__); \
- }while(0)
+ } while (0)
/**
* @brief Returning the ack message from the server to client side, adding 2 parameters.
* @param[in] param2 The 2nd parameter to be included in the message.
*/
#define muse_recorder_msg_return2(api, class, ret, module, type1, param1, type2, param2) \
- do{ \
+ do { \
char *__sndMsg__; \
int __len__; \
type1 __value1__ = (type1)param1; \
type2 __value2__ = (type2)param2; \
__sndMsg__ = muse_core_msg_json_factory_new(api, \
- MUSE_TYPE_INT, PARAM_API_CLASS, class, \
- MUSE_TYPE_INT, PARAM_RET, ret, \
- MUSE_TYPE_##type1, #param1, __value1__, \
- MUSE_TYPE_##type2, #param2, __value2__, \
- 0); \
+ MUSE_TYPE_INT, PARAM_API_CLASS, class, \
+ MUSE_TYPE_INT, PARAM_RET, ret, \
+ MUSE_TYPE_##type1, #param1, __value1__, \
+ MUSE_TYPE_##type2, #param2, __value2__, \
+ 0); \
__len__ = muse_core_ipc_send_msg(muse_core_client_get_msg_fd(module), __sndMsg__); \
if (__len__ <= 0) { \
LOGE("sending message failed"); \
ret = RECORDER_ERROR_INVALID_OPERATION; \
} \
muse_core_msg_json_factory_free(__sndMsg__); \
- }while(0)
+ } while (0)
/**
* @brief Returning the ack message from the server to client side, adding 3 parameters.
* @param[in] param3 The 3rd parameter to be included in the message.
*/
#define muse_recorder_msg_return3(api, class, ret, module, type1, param1, type2, param2, type3, param3) \
- do{ \
+ do { \
char *__sndMsg__; \
int __len__; \
type1 __value1__ = (type1)param1; \
type2 __value2__ = (type2)param2; \
type3 __value3__ = (type3)param3; \
__sndMsg__ = muse_core_msg_json_factory_new(api, \
- MUSE_TYPE_INT, PARAM_API_CLASS, class, \
- MUSE_TYPE_INT, PARAM_RET, ret, \
- MUSE_TYPE_##type1, #param1, __value1__, \
- MUSE_TYPE_##type2, #param2, __value2__, \
- MUSE_TYPE_##type3, #param3, __value3__, \
- 0); \
+ MUSE_TYPE_INT, PARAM_API_CLASS, class, \
+ MUSE_TYPE_INT, PARAM_RET, ret, \
+ MUSE_TYPE_##type1, #param1, __value1__, \
+ MUSE_TYPE_##type2, #param2, __value2__, \
+ MUSE_TYPE_##type3, #param3, __value3__, \
+ 0); \
__len__ = muse_core_ipc_send_msg(muse_core_client_get_msg_fd(module), __sndMsg__); \
if (__len__ <= 0) { \
LOGE("sending message failed"); \
ret = RECORDER_ERROR_INVALID_OPERATION; \
} \
muse_core_msg_json_factory_free(__sndMsg__); \
- }while(0)
+ } while (0)
/**
* @brief Returning the ack message from the server to client side, adding array parameter.
* @param[in] datum_size The size of the array.
*/
#define muse_recorder_msg_return_array(api, class, ret, module, param, length, datum_size) \
- do{ \
+ do { \
char *__sndMsg__; \
int __len__; \
int *__value__ = (int *)param; \
__sndMsg__ = muse_core_msg_json_factory_new(api, \
- MUSE_TYPE_INT, PARAM_API_CLASS, class, \
- MUSE_TYPE_INT, PARAM_RET, ret, \
- MUSE_TYPE_INT, #length, length, \
- MUSE_TYPE_ARRAY, #param, \
- datum_size == sizeof(int)? length : \
- length / sizeof(int) + (length % sizeof(int)?1:0), \
- __value__, \
- 0); \
+ MUSE_TYPE_INT, PARAM_API_CLASS, class, \
+ MUSE_TYPE_INT, PARAM_RET, ret, \
+ MUSE_TYPE_INT, #length, length, \
+ MUSE_TYPE_ARRAY, #param, \
+ datum_size == sizeof(int) ? length : \
+ length / sizeof(int) + (length % sizeof(int) ? 1 : 0), \
+ __value__, \
+ 0); \
__len__ = muse_core_ipc_send_msg(muse_core_client_get_msg_fd(module), __sndMsg__); \
if (__len__ <= 0) { \
LOGE("sending message failed"); \
ret = RECORDER_ERROR_INVALID_OPERATION; \
} \
muse_core_msg_json_factory_free(__sndMsg__); \
- }while(0)
+ } while (0)
/**
* @brief Returning the event ack message from the server to client side.
* @param[in] module The module info for the ipc transportation.
*/
#define muse_recorder_msg_event(api, event, class, module) \
- do{ \
+ do { \
char *__sndMsg__; \
__sndMsg__ = muse_core_msg_json_factory_new(api, \
- MUSE_TYPE_INT, PARAM_EVENT, event, \
- MUSE_TYPE_INT, PARAM_EVENT_CLASS, class, \
- 0); \
+ MUSE_TYPE_INT, PARAM_EVENT, event, \
+ MUSE_TYPE_INT, PARAM_EVENT_CLASS, class, \
+ 0); \
muse_core_ipc_send_msg(muse_core_client_get_msg_fd(module), __sndMsg__); \
muse_core_msg_json_factory_free(__sndMsg__); \
- }while(0)
+ } while (0)
/**
* @brief Returning the event ack message from the server to client side, adding a parameter.
* @param[in] param A parameter to be included in the message.
*/
#define muse_recorder_msg_event1(api, event, class, module, type, param) \
- do{ \
+ do { \
char *__sndMsg__; \
type __value__ = (type)param; \
__sndMsg__ = muse_core_msg_json_factory_new(api, \
- MUSE_TYPE_INT, PARAM_EVENT, event, \
- MUSE_TYPE_INT, PARAM_EVENT_CLASS, class, \
- MUSE_TYPE_##type, #param, __value__, \
- 0); \
+ MUSE_TYPE_INT, PARAM_EVENT, event, \
+ MUSE_TYPE_INT, PARAM_EVENT_CLASS, class, \
+ MUSE_TYPE_##type, #param, __value__, \
+ 0); \
muse_core_ipc_send_msg(muse_core_client_get_msg_fd(module), __sndMsg__); \
muse_core_msg_json_factory_free(__sndMsg__); \
- }while(0)
+ } while (0)
/**
* @brief Returning the event ack message from the server to client side, adding 2 parameters.
* @param[in] param2 The 2nd parameter to be included in the message.
*/
#define muse_recorder_msg_event2(api, event, class, module, type1, param1, type2, param2) \
- do{ \
+ do { \
char *__sndMsg__; \
type1 __value1__ = (type1)param1; \
type2 __value2__ = (type2)param2; \
__sndMsg__ = muse_core_msg_json_factory_new(api, \
- MUSE_TYPE_INT, PARAM_EVENT, event, \
- MUSE_TYPE_INT, PARAM_EVENT_CLASS, class, \
- MUSE_TYPE_##type1, #param1, __value1__, \
- MUSE_TYPE_##type2, #param2, __value2__, \
- 0); \
+ MUSE_TYPE_INT, PARAM_EVENT, event, \
+ MUSE_TYPE_INT, PARAM_EVENT_CLASS, class, \
+ MUSE_TYPE_##type1, #param1, __value1__, \
+ MUSE_TYPE_##type2, #param2, __value2__, \
+ 0); \
muse_core_ipc_send_msg(muse_core_client_get_msg_fd(module), __sndMsg__); \
muse_core_msg_json_factory_free(__sndMsg__); \
- }while(0)
+ } while (0)
/**
* @brief Returning the event ack message from the server to client side, adding 3 parameters.
* @param[in] param3 The 3rd parameter to be included in the message.
*/
#define muse_recorder_msg_event3(api, event, class, module, type1, param1, type2, param2, type3, param3) \
- do{ \
+ do { \
char *__sndMsg__; \
type1 __value1__ = (type1)param1; \
type2 __value2__ = (type2)param2; \
type3 __value3__ = (type3)param3; \
__sndMsg__ = muse_core_msg_json_factory_new(api, \
- MUSE_TYPE_INT, PARAM_EVENT, event, \
- MUSE_TYPE_INT, PARAM_EVENT_CLASS, class, \
- MUSE_TYPE_##type1, #param1, __value1__, \
- MUSE_TYPE_##type2, #param2, __value2__, \
- MUSE_TYPE_##type3, #param3, __value3__, \
- 0); \
+ MUSE_TYPE_INT, PARAM_EVENT, event, \
+ MUSE_TYPE_INT, PARAM_EVENT_CLASS, class, \
+ MUSE_TYPE_##type1, #param1, __value1__, \
+ MUSE_TYPE_##type2, #param2, __value2__, \
+ MUSE_TYPE_##type3, #param3, __value3__, \
+ 0); \
muse_core_ipc_send_msg(muse_core_client_get_msg_fd(module), __sndMsg__); \
muse_core_msg_json_factory_free(__sndMsg__); \
- }while(0)
+ } while (0)
/**
* @brief Returning the event ack message from the server to client side, adding 5 parameters.
* @param[in] param5 The 5th parameter to be included in the message.
*/
#define muse_recorder_msg_event5(api, event, class, module, type1, param1, type2, param2, type3, param3, type4, param4, type5, param5) \
- do{ \
+ do { \
char *__sndMsg__; \
type1 __value1__ = (type1)param1; \
type2 __value2__ = (type2)param2; \
type4 __value4__ = (type4)param4; \
type5 __value5__ = (type5)param5; \
__sndMsg__ = muse_core_msg_json_factory_new(api, \
- MUSE_TYPE_INT, PARAM_EVENT, event, \
- MUSE_TYPE_INT, PARAM_EVENT_CLASS, class, \
- MUSE_TYPE_##type1, #param1, __value1__, \
- MUSE_TYPE_##type2, #param2, __value2__, \
- MUSE_TYPE_##type3, #param3, __value3__, \
- MUSE_TYPE_##type4, #param4, __value4__, \
- MUSE_TYPE_##type5, #param5, __value5__, \
- 0); \
+ MUSE_TYPE_INT, PARAM_EVENT, event, \
+ MUSE_TYPE_INT, PARAM_EVENT_CLASS, class, \
+ MUSE_TYPE_##type1, #param1, __value1__, \
+ MUSE_TYPE_##type2, #param2, __value2__, \
+ MUSE_TYPE_##type3, #param3, __value3__, \
+ MUSE_TYPE_##type4, #param4, __value4__, \
+ MUSE_TYPE_##type5, #param5, __value5__, \
+ 0); \
muse_core_ipc_send_msg(muse_core_client_get_msg_fd(module), __sndMsg__); \
muse_core_msg_json_factory_free(__sndMsg__); \
- }while(0)
+ } while (0)
#ifdef __cplusplus
}
}
muse_recorder_msg_event1(MUSE_RECORDER_CB_EVENT,
- MUSE_RECORDER_EVENT_TYPE_RECORDING_LIMITED,
- MUSE_RECORDER_EVENT_CLASS_THREAD_MAIN,
- module,
- INT, type);
+ MUSE_RECORDER_EVENT_TYPE_RECORDING_LIMITED,
+ MUSE_RECORDER_EVENT_CLASS_THREAD_MAIN,
+ module,
+ INT, type);
return;
}
}
muse_recorder_msg_event2(MUSE_RECORDER_CB_EVENT,
- MUSE_RECORDER_EVENT_TYPE_RECORDING_STATUS,
- MUSE_RECORDER_EVENT_CLASS_THREAD_MAIN,
- module,
- INT64, cb_elapsed_time,
- INT64, cb_file_size);
+ MUSE_RECORDER_EVENT_TYPE_RECORDING_STATUS,
+ MUSE_RECORDER_EVENT_CLASS_THREAD_MAIN,
+ module,
+ INT64, cb_elapsed_time,
+ INT64, cb_file_size);
return;
}
}
muse_recorder_msg_event3(MUSE_RECORDER_CB_EVENT,
- MUSE_RECORDER_EVENT_TYPE_STATE_CHANGE,
- MUSE_RECORDER_EVENT_CLASS_THREAD_MAIN,
- module,
- INT, previous,
- INT, current,
- INT, by_policy);
+ MUSE_RECORDER_EVENT_TYPE_STATE_CHANGE,
+ MUSE_RECORDER_EVENT_CLASS_THREAD_MAIN,
+ module,
+ INT, previous,
+ INT, current,
+ INT, by_policy);
return;
}
}
muse_recorder_msg_event3(MUSE_RECORDER_CB_EVENT,
- MUSE_RECORDER_EVENT_TYPE_INTERRUPTED,
- MUSE_RECORDER_EVENT_CLASS_THREAD_MAIN,
- module,
- INT, policy,
- INT, previous,
- INT, current);
+ MUSE_RECORDER_EVENT_TYPE_INTERRUPTED,
+ MUSE_RECORDER_EVENT_CLASS_THREAD_MAIN,
+ module,
+ INT, policy,
+ INT, previous,
+ INT, current);
return;
}
}
muse_recorder_msg_event2(MUSE_RECORDER_CB_EVENT,
- MUSE_RECORDER_EVENT_TYPE_ERROR,
- MUSE_RECORDER_EVENT_CLASS_THREAD_MAIN,
- module,
- INT, error,
- INT, current_state);
+ MUSE_RECORDER_EVENT_TYPE_ERROR,
+ MUSE_RECORDER_EVENT_CLASS_THREAD_MAIN,
+ module,
+ INT, error,
+ INT, current_state);
return;
}
tbm_bo_unmap(bo);
tbm_key = tbm_bo_export(bo);
- if(tbm_key == 0) {
+ if (tbm_key == 0) {
LOGE("Create key_info ERROR!!");
tbm_bo_unref(bo);
bo = NULL;
/* send message */
muse_recorder_msg_event5(MUSE_RECORDER_CB_EVENT,
- MUSE_RECORDER_EVENT_TYPE_AUDIO_STREAM,
- MUSE_RECORDER_EVENT_CLASS_THREAD_SUB,
- module,
- INT, size,
- INT, format,
- INT, channel,
- INT, timestamp,
- INT, tbm_key);
+ MUSE_RECORDER_EVENT_TYPE_AUDIO_STREAM,
+ MUSE_RECORDER_EVENT_CLASS_THREAD_SUB,
+ module,
+ INT, size,
+ INT, format,
+ INT, channel,
+ INT, timestamp,
+ INT, tbm_key);
return;
}
}
muse_recorder_msg_event2(MUSE_RECORDER_CB_EVENT,
- MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_RESOLUTION,
- MUSE_RECORDER_EVENT_CLASS_THREAD_SUB,
- module,
- INT, width,
- INT, height);
+ MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_RESOLUTION,
+ MUSE_RECORDER_EVENT_CLASS_THREAD_SUB,
+ module,
+ INT, width,
+ INT, height);
return;
}
}
muse_recorder_msg_event1(MUSE_RECORDER_CB_EVENT,
- MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_FILE_FORMAT,
- MUSE_RECORDER_EVENT_CLASS_THREAD_SUB,
- module,
- INT, format);
+ MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_FILE_FORMAT,
+ MUSE_RECORDER_EVENT_CLASS_THREAD_SUB,
+ module,
+ INT, format);
return;
}
}
muse_recorder_msg_event1(MUSE_RECORDER_CB_EVENT,
- MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_AUDIO_ENCODER,
- MUSE_RECORDER_EVENT_CLASS_THREAD_SUB,
- module,
- INT, codec);
+ MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_AUDIO_ENCODER,
+ MUSE_RECORDER_EVENT_CLASS_THREAD_SUB,
+ module,
+ INT, codec);
return;
}
}
muse_recorder_msg_event1(MUSE_RECORDER_CB_EVENT,
- MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_ENCODER,
- MUSE_RECORDER_EVENT_CLASS_THREAD_SUB,
- module,
- INT, codec);
+ MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_ENCODER,
+ MUSE_RECORDER_EVENT_CLASS_THREAD_SUB,
+ module,
+ INT, codec);
return;
}
g_mutex_unlock(&muse_recorder->list_lock);
- if (remove_all) {
+ if (remove_all)
LOGD("remove all done");
- } else {
+ else
LOGE("should not be reached here - key %d", key);
- }
return FALSE;
}
ret = legacy_recorder_get_video_resolution(muse_recorder->recorder_handle, &get_width, &get_height);
muse_recorder_msg_return2(api, class, ret, module,
- INT, get_width,
- INT, get_height);
+ INT, get_width,
+ INT, get_height);
return 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,
- (void *)module);
+ (recorder_supported_video_resolution_cb)_recorder_disp_foreach_supported_video_resolution_cb,
+ (void *)module);
muse_recorder_msg_return(api, class, ret, module);
}
ret = legacy_recorder_get_filename(muse_recorder->recorder_handle, &get_filename);
- if (ret == RECORDER_ERROR_NONE && get_filename) {
+ if (ret == RECORDER_ERROR_NONE && get_filename)
muse_recorder_msg_return1(api, class, ret, module, STRING, get_filename);
- } else {
+ else
muse_recorder_msg_return(api, class, ret, module);
- }
if (get_filename) {
free(get_filename);
}
ret = legacy_recorder_set_state_changed_cb(muse_recorder->recorder_handle,
- (recorder_state_changed_cb)_recorder_disp_state_changed_cb,
- (void *)module);
+ (recorder_state_changed_cb)_recorder_disp_state_changed_cb,
+ (void *)module);
muse_recorder_msg_return(api, class, ret, module);
}
ret = legacy_recorder_set_interrupted_cb(muse_recorder->recorder_handle,
- (recorder_interrupted_cb)_recorder_disp_interrupted_cb,
- (void *)module);
+ (recorder_interrupted_cb)_recorder_disp_interrupted_cb,
+ (void *)module);
muse_recorder_msg_return(api, class, ret, module);
}
ret = legacy_recorder_set_audio_stream_cb(muse_recorder->recorder_handle,
- (recorder_audio_stream_cb)_recorder_disp_audio_stream_cb,
- (void *)module);
+ (recorder_audio_stream_cb)_recorder_disp_audio_stream_cb,
+ (void *)module);
muse_recorder_msg_return(api, class, ret, module);
}
ret = legacy_recorder_set_error_cb(muse_recorder->recorder_handle,
- (recorder_error_cb)_recorder_disp_error_cb,
- (void *)module);
+ (recorder_error_cb)_recorder_disp_error_cb,
+ (void *)module);
muse_recorder_msg_return(api, class, ret, module);
}
ret = legacy_recorder_set_recording_status_cb(muse_recorder->recorder_handle,
- (recorder_recording_status_cb)_recorder_disp_recording_status_cb,
- (void *)module);
+ (recorder_recording_status_cb)_recorder_disp_recording_status_cb,
+ (void *)module);
muse_recorder_msg_return(api, class, ret, module);
}
ret = legacy_recorder_set_recording_limit_reached_cb(muse_recorder->recorder_handle,
- (recorder_recording_limit_reached_cb)_recorder_disp_recording_limit_reached_cb,
- (void *)module);
+ (recorder_recording_limit_reached_cb)_recorder_disp_recording_limit_reached_cb,
+ (void *)module);
+
muse_recorder_msg_return(api, class, ret, module);
return 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,
- (void *)module);
+ (recorder_supported_file_format_cb)_recorder_disp_foreach_supported_file_format_cb,
+ (void *)module);
muse_recorder_msg_return(api, class, ret, module);
}
ret = legacy_recorder_foreach_supported_audio_encoder(muse_recorder->recorder_handle,
- (recorder_supported_audio_encoder_cb)_recorder_disp_foreach_supported_audio_encoder_cb,
- (void *)module);
+ (recorder_supported_audio_encoder_cb)_recorder_disp_foreach_supported_audio_encoder_cb,
+ (void *)module);
muse_recorder_msg_return(api, class, ret, module);
}
ret = legacy_recorder_foreach_supported_video_encoder(muse_recorder->recorder_handle,
- (recorder_supported_video_encoder_cb)_recorder_disp_foreach_supported_video_encoder_cb,
- (void *)module);
+ (recorder_supported_video_encoder_cb)_recorder_disp_foreach_supported_video_encoder_cb,
+ (void *)module);
muse_recorder_msg_return(api, class, ret, module);
/*LOGD("handle : %p, key : %d", muse_recorder, tbm_key);*/
- if (!_recorder_remove_export_data(module, tbm_key, FALSE)) {
+ if (!_recorder_remove_export_data(module, tbm_key, FALSE))
LOGE("remove export data failed : key %d", tbm_key);
- }
return MUSE_RECORDER_ERROR_NONE;
}
Name: mmsvc-recorder
Summary: A Recorder module for muse server
-Version: 0.2.19
+Version: 0.2.20
Release: 0
Group: Multimedia/Libraries
License: Apache-2.0
projects / platform / core / multimedia / mmsvc-recorder.git / commitdiff