2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
24 #include <muse_camera.h>
25 #include <muse_camera_msg.h>
26 #include <muse_core_ipc.h>
27 #include <camera_private.h>
28 #include <muse_core.h>
31 #include <Elementary.h>
32 #include <mm_camcorder_client.h>
35 #include <Ecore_Wayland.h>
43 #define LOG_TAG "TIZEN_N_CAMERA_CLIENT"
46 static int client_wait_for_cb_return(muse_camera_api_e api, callback_cb_info_s *cb_info, int time_out)
48 int ret = CAMERA_ERROR_NONE;
51 LOGD("Enter api : %d", api);
52 g_mutex_lock(&(cb_info->pMutex[api]));
54 if (cb_info->activating[api] == 0) {
55 end_time = g_get_monotonic_time() + time_out * G_TIME_SPAN_SECOND;
56 if (g_cond_wait_until(&(cb_info->pCond[api]), &(cb_info->pMutex[api]), end_time)) {
57 LOGD("cb_info->recvApiMsg : %s", cb_info->recvApiMsg);
58 if (!muse_camera_msg_get(ret, cb_info->recvApiMsg)) {
59 LOGE("Get cb msg failed.");
60 ret = CAMERA_ERROR_INVALID_OPERATION;
62 LOGD("Wait passed, ret : 0x%x", ret);
64 if (cb_info->activating[api])
65 cb_info->activating[api] = 0;
67 LOGD("api %d was TIMED OUT!", api);
68 ret = CAMERA_ERROR_INVALID_OPERATION;
71 LOGE("condition is already checked for the api : %d.", api);
72 if (!muse_camera_msg_get(ret, cb_info->recvApiMsg)) {
73 LOGE("Get cb msg failed.");
74 ret = CAMERA_ERROR_INVALID_OPERATION;
76 LOGD("Already checked condition, Wait passed, ret : 0x%x", ret);
79 g_mutex_unlock(&(cb_info->pMutex[api]));
80 LOGD("ret : 0x%x", ret);
84 static void _client_user_callback(callback_cb_info_s *cb_info, char *recvMsg, muse_camera_event_e event)
90 if (recvMsg == NULL) {
91 LOGE("NULL message for event %d", event);
95 LOGD("get event %d", event);
98 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_RESOLUTION:
99 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_RESOLUTION:
100 muse_camera_msg_get(param1, recvMsg);
101 muse_camera_msg_get(param2, recvMsg);
103 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_THEATER_MODE:
104 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_FORMAT:
105 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_FORMAT:
106 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_AF_MODE:
107 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EXPOSURE_MODE:
108 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_ISO:
109 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_WHITEBALANCE:
110 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EFFECT:
111 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_SCENE_MODE:
112 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FLASH_MODE:
113 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS:
114 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS_BY_RESOLUTION:
115 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_FLIP:
116 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_ROTATION:
117 muse_camera_msg_get(param, recvMsg);
124 case MUSE_CAMERA_EVENT_TYPE_STATE_CHANGE:
126 int cb_previous, cb_current, cb_by_policy;
127 muse_camera_msg_get(cb_previous, recvMsg);
128 muse_camera_msg_get(cb_current, recvMsg);
129 muse_camera_msg_get(cb_by_policy, recvMsg);
130 ((camera_state_changed_cb)cb_info->user_cb[event])((camera_state_e)cb_previous,
131 (camera_state_e)cb_current,
133 cb_info->user_data[event]);
136 case MUSE_CAMERA_EVENT_TYPE_FOCUS_CHANGE:
139 muse_camera_msg_get(cb_state, recvMsg);
140 ((camera_focus_changed_cb)cb_info->user_cb[event])((camera_focus_state_e)cb_state,
141 cb_info->user_data[event]);
144 case MUSE_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE:
145 ((camera_capture_completed_cb)cb_info->user_cb[event])(cb_info->user_data[event]);
147 case MUSE_CAMERA_EVENT_TYPE_PREVIEW:
150 tbm_bo_handle bo_handle;
152 unsigned char *buf_pos = NULL;
153 camera_preview_data_s *frame = NULL;
154 muse_camera_msg_get(tbm_key, recvMsg);
157 LOGE("invalid key %d", tbm_key);
161 /* import tbm bo and get virtual address */
162 bo = tbm_bo_import(cb_info->bufmgr, tbm_key);
164 LOGE("bo import failed - bufmgr %p, key %d", cb_info->bufmgr, tbm_key);
168 bo_handle = tbm_bo_map(bo, TBM_DEVICE_CPU, TBM_OPTION_READ);
169 if (bo_handle.ptr == NULL) {
170 LOGE("bo map failed %p", bo);
175 buf_pos = (unsigned char *)bo_handle.ptr;
177 frame = (camera_preview_data_s *)buf_pos;
179 buf_pos += sizeof(camera_preview_data_s);
181 switch (frame->num_of_planes) {
183 frame->data.single_plane.yuv = buf_pos;
185 frame->data.double_plane.y = buf_pos;
186 buf_pos += frame->data.double_plane.y_size;
187 frame->data.double_plane.uv = buf_pos;
189 frame->data.triple_plane.y = buf_pos;
190 buf_pos += frame->data.triple_plane.y_size;
191 frame->data.triple_plane.u = buf_pos;
192 buf_pos += frame->data.triple_plane.u_size;
193 frame->data.triple_plane.v = buf_pos;
197 if (cb_info->user_cb[event]) {
198 ((camera_preview_cb)cb_info->user_cb[event])(frame,
199 cb_info->user_data[event]);
201 LOGW("preview cb is NULL");
205 muse_camera_msg_send1_no_return(MUSE_CAMERA_API_RETURN_BUFFER,
210 LOGD("return buffer Done");
212 /* unmap and unref tbm bo */
219 case MUSE_CAMERA_EVENT_TYPE_MEDIA_PACKET_PREVIEW:
220 ((camera_media_packet_preview_cb)cb_info->user_cb[event])(NULL,
221 cb_info->user_data[event]);
223 case MUSE_CAMERA_EVENT_TYPE_HDR_PROGRESS:
226 muse_camera_msg_get(progress, recvMsg);
227 ((camera_attr_hdr_progress_cb)cb_info->user_cb[event])(progress,
228 cb_info->user_data[event]);
231 case MUSE_CAMERA_EVENT_TYPE_INTERRUPTED:
233 int cb_policy, cb_previous, cb_current;
234 muse_camera_msg_get(cb_policy, recvMsg);
235 muse_camera_msg_get(cb_previous, recvMsg);
236 muse_camera_msg_get(cb_current, recvMsg);
237 ((camera_interrupted_cb)cb_info->user_cb[event])((camera_policy_e)cb_policy,
238 (camera_state_e)cb_previous,
239 (camera_state_e)cb_current,
240 cb_info->user_data[event]);
243 case MUSE_CAMERA_EVENT_TYPE_FACE_DETECTION:
246 muse_camera_msg_get(count, recvMsg);
247 ((camera_face_detected_cb)cb_info->user_cb[event])(NULL,
249 cb_info->user_data[event]);
252 case MUSE_CAMERA_EVENT_TYPE_ERROR:
254 int cb_error, cb_current_state;
255 muse_camera_msg_get(cb_error, recvMsg);
256 muse_camera_msg_get(cb_current_state, recvMsg);
257 ((camera_error_cb)cb_info->user_cb[event])((camera_error_e)cb_error,
258 (camera_state_e)cb_current_state,
259 cb_info->user_data[event]);
262 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_RESOLUTION:
263 ((camera_supported_preview_resolution_cb)cb_info->user_cb[event])(param1, param2,
264 cb_info->user_data[event]);
266 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_RESOLUTION:
267 ((camera_supported_capture_resolution_cb)cb_info->user_cb[event])(param1, param2,
268 cb_info->user_data[event]);
270 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_FORMAT:
271 ((camera_supported_capture_format_cb)cb_info->user_cb[event])((camera_pixel_format_e)param,
272 cb_info->user_data[event]);
274 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_FORMAT:
275 ((camera_supported_preview_format_cb)cb_info->user_cb[event])((camera_pixel_format_e)param,
276 cb_info->user_data[event]);
278 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_AF_MODE:
279 ((camera_attr_supported_af_mode_cb)cb_info->user_cb[event])((camera_attr_af_mode_e)param,
280 cb_info->user_data[event]);
282 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EXPOSURE_MODE:
283 ((camera_attr_supported_exposure_mode_cb)cb_info->user_cb[event])((camera_attr_exposure_mode_e)param,
284 cb_info->user_data[event]);
286 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_ISO:
287 ((camera_attr_supported_iso_cb)cb_info->user_cb[event])((camera_attr_iso_e)param,
288 cb_info->user_data[event]);
290 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_WHITEBALANCE:
291 ((camera_attr_supported_whitebalance_cb)cb_info->user_cb[event])((camera_attr_whitebalance_e)param,
292 cb_info->user_data[event]);
294 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EFFECT:
295 ((camera_attr_supported_effect_cb)cb_info->user_cb[event])((camera_attr_effect_mode_e)param,
296 cb_info->user_data[event]);
298 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_SCENE_MODE:
299 ((camera_attr_supported_scene_mode_cb)cb_info->user_cb[event])((camera_attr_scene_mode_e)param,
300 cb_info->user_data[event]);
302 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FLASH_MODE:
303 ((camera_attr_supported_flash_mode_cb)cb_info->user_cb[event])((camera_attr_flash_mode_e)param,
304 cb_info->user_data[event]);
306 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS:
307 ((camera_attr_supported_fps_cb)cb_info->user_cb[event])((camera_attr_fps_e)param,
308 cb_info->user_data[event]);
310 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS_BY_RESOLUTION:
311 ((camera_attr_supported_fps_cb)cb_info->user_cb[event])((camera_attr_fps_e)param,
312 cb_info->user_data[event]);
314 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_FLIP:
315 ((camera_attr_supported_stream_flip_cb)cb_info->user_cb[event])((camera_flip_e)param,
316 cb_info->user_data[event]);
318 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_ROTATION:
319 ((camera_attr_supported_stream_rotation_cb)cb_info->user_cb[event])((camera_rotation_e)param,
320 cb_info->user_data[event]);
322 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_THEATER_MODE:
323 ((camera_attr_supported_theater_mode_cb)cb_info->user_cb[event])((camera_attr_theater_mode_e)param,
324 cb_info->user_data[event]);
326 case MUSE_CAMERA_EVENT_TYPE_CAPTURE:
328 camera_image_data_s *rImage = NULL;
329 camera_image_data_s *rPostview = NULL;
330 camera_image_data_s *rThumbnail = NULL;
331 unsigned char *buf_pos = NULL;
333 tbm_bo_handle bo_handle;
336 int is_thumbnail = 0;
338 muse_camera_msg_get(tbm_key, recvMsg);
339 muse_camera_msg_get(is_postview, recvMsg);
340 muse_camera_msg_get(is_thumbnail, recvMsg);
342 LOGD("camera capture callback came in. key %d, postview %d, thumbnail %d",
343 tbm_key, is_postview, is_thumbnail);
346 LOGE("invalid key %d", tbm_key);
350 /* import tbm bo and get virtual address */
351 bo = tbm_bo_import(cb_info->bufmgr, tbm_key);
353 LOGE("bo import failed - bufmgr %p, key %d", cb_info->bufmgr, tbm_key);
357 bo_handle = tbm_bo_map(bo, TBM_DEVICE_CPU, TBM_OPTION_READ);
358 if (bo_handle.ptr == NULL) {
359 LOGE("bo map failed %p", bo);
365 buf_pos = (unsigned char *)bo_handle.ptr;
366 rImage = (camera_image_data_s *)buf_pos;
367 rImage->data = buf_pos + sizeof(camera_image_data_s);
368 buf_pos += sizeof(camera_image_data_s) + rImage->size;
371 rPostview = (camera_image_data_s *)buf_pos;
372 LOGD("rPostview->size : %d", rPostview->size);
373 rPostview->data = buf_pos + sizeof(camera_image_data_s);
374 buf_pos += sizeof(camera_image_data_s) + rPostview->size;
378 rThumbnail = (camera_image_data_s *)buf_pos;
379 LOGD("rThumbnail->size : %d", rThumbnail->size);
380 rThumbnail->data = buf_pos + sizeof(camera_image_data_s);
381 buf_pos += sizeof(camera_image_data_s) + rThumbnail->size;
384 LOGD("read image info height: %d, width : %d, size : %d", rImage->height, rImage->width, rImage->size);
386 if (cb_info->user_cb[event]) {
387 ((camera_capturing_cb)cb_info->user_cb[event])(rImage, rPostview, rThumbnail, cb_info->user_data[event]);
389 LOGW("capture cb is NULL");
393 muse_camera_msg_send1_no_return(MUSE_CAMERA_API_RETURN_BUFFER,
398 LOGD("return buffer done");
400 /* unmap and unref tbm bo */
407 case MUSE_CAMERA_EVENT_TYPE_VIDEO_FRAME_RENDER_ERROR:
411 LOGE("Unknonw event : %d", event);
418 static void *_event_handler(gpointer data)
420 event_info_s *e_info = NULL;
421 callback_cb_info_s *cb_info = (callback_cb_info_s *)data;
423 if (cb_info == NULL) {
424 LOGE("cb_info NULL");
430 g_mutex_lock(&cb_info->event_mutex);
432 while (g_atomic_int_get(&cb_info->event_thread_running)) {
433 if (g_queue_is_empty(cb_info->event_queue)) {
434 LOGD("signal wait...");
435 g_cond_wait(&cb_info->event_cond, &cb_info->event_mutex);
436 LOGD("signal received");
438 if (g_atomic_int_get(&cb_info->event_thread_running) == 0) {
439 LOGD("stop event thread");
444 e_info = (event_info_s *)g_queue_pop_head(cb_info->event_queue);
446 g_mutex_unlock(&cb_info->event_mutex);
449 _client_user_callback(cb_info, e_info->recvMsg, e_info->event);
453 LOGW("NULL event info");
456 g_mutex_lock(&cb_info->event_mutex);
459 /* remove remained event */
460 while (!g_queue_is_empty(cb_info->event_queue)) {
461 e_info = (event_info_s *)g_queue_pop_head(cb_info->event_queue);
463 LOGD("remove event info %p", e_info);
467 LOGW("NULL event info");
471 g_mutex_unlock(&cb_info->event_mutex);
478 static void *client_cb_handler(gpointer data)
486 callback_cb_info_s *cb_info = (callback_cb_info_s *)data;
487 char *recvMsg = NULL;
488 char parseStr[CAMERA_PARSE_STRING_SIZE][MUSE_CAMERA_MSG_MAX_LENGTH] = {{0,0},};
490 if (cb_info == NULL) {
491 LOGE("cb_info NULL");
497 recvMsg = cb_info->recvMsg;
499 while (g_atomic_int_get(&cb_info->rcv_thread_running)) {
500 ret = muse_core_ipc_recv_msg(cb_info->fd, recvMsg);
508 memset(parseStr, 0, CAMERA_PARSE_STRING_SIZE * MUSE_CAMERA_MSG_MAX_LENGTH);
510 LOGD("recvMSg : %s, length : %d", recvMsg, ret);
512 /* Need to split the combined entering msgs.
513 This module supports up to 200 combined msgs. */
514 for (str_pos = 0; str_pos < ret; str_pos++) {
515 if(recvMsg[str_pos] == '}') {
516 strncpy(&(parseStr[num_token][0]), recvMsg + prev_pos, str_pos - prev_pos + 1);
517 LOGD("splitted msg : %s, Index : %d", &(parseStr[num_token][0]), num_token);
518 prev_pos = str_pos+1;
522 LOGD("num_token : %d", num_token);
524 /* Re-construct to the useful single msg. */
525 for (i = 0; i < num_token; i++) {
527 if (i >= CAMERA_PARSE_STRING_SIZE)
530 if (muse_camera_msg_get(api, &(parseStr[i][0]))) {
531 if(api < MUSE_CAMERA_API_MAX){
532 LOGD("Set Condition");
533 g_mutex_lock(&(cb_info->pMutex[api]));
535 /* The api msgs should be distinguished from the event msg. */
536 memset(cb_info->recvApiMsg, 0, strlen(cb_info->recvApiMsg));
537 strcpy(cb_info->recvApiMsg, &(parseStr[i][0]));
538 LOGD("cb_info->recvApiMsg : %s", cb_info->recvApiMsg);
539 cb_info->activating[api] = 1;
540 g_cond_signal(&(cb_info->pCond[api]));
541 g_mutex_unlock(&(cb_info->pMutex[api]));
543 if (api == MUSE_CAMERA_API_CREATE) {
544 if (muse_camera_msg_get(ret, cb_info->recvApiMsg)) {
545 if (ret != CAMERA_ERROR_NONE) {
546 g_atomic_int_set(&cb_info->rcv_thread_running, 0);
547 LOGE("camera create error. close client cb handler");
550 LOGE("failed to get api return");
552 } else if (api == MUSE_CAMERA_API_DESTROY) {
553 if (muse_camera_msg_get(ret, cb_info->recvApiMsg)) {
554 if (ret == CAMERA_ERROR_NONE) {
555 g_atomic_int_set(&cb_info->rcv_thread_running, 0);
556 LOGD("camera destroy done. close client cb handler");
559 LOGE("failed to get api return");
562 } else if(api == MUSE_CAMERA_CB_EVENT) {
564 if (muse_camera_msg_get(event, &(parseStr[i][0]))) {
565 event_info_s *e_info = NULL;
568 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_RESOLUTION:
569 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_RESOLUTION:
570 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_THEATER_MODE:
571 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_FORMAT:
572 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_FORMAT:
573 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_AF_MODE:
574 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EXPOSURE_MODE:
575 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_ISO:
576 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_WHITEBALANCE:
577 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EFFECT:
578 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_SCENE_MODE:
579 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FLASH_MODE:
580 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS:
581 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS_BY_RESOLUTION:
582 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_FLIP:
583 case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_ROTATION:
584 _client_user_callback(cb_info, recvMsg, event);
587 e_info = (event_info_s *)malloc(sizeof(event_info_s));
589 LOGD("add event to queue : %d", event);
590 g_mutex_lock(&cb_info->event_mutex);
592 e_info->event = event;
593 memcpy(e_info->recvMsg, recvMsg, sizeof(e_info->recvMsg));
594 g_queue_push_tail(cb_info->event_queue, (gpointer)e_info);
596 g_cond_signal(&cb_info->event_cond);
597 g_mutex_unlock(&cb_info->event_mutex);
599 LOGE("e_info alloc failed");
605 LOGW("unknown api : %d", api);
608 LOGE("Get Msg Failed");
614 LOGD("client cb exit");
619 static callback_cb_info_s *client_callback_new(gint sockfd)
621 callback_cb_info_s *cb_info;
623 GMutex *camera_mutex;
625 g_return_val_if_fail(sockfd > 0, NULL);
627 cb_info = g_new0(callback_cb_info_s, 1);
628 camera_cond = g_new0(GCond, MUSE_CAMERA_API_MAX);
629 camera_mutex = g_new0(GMutex, MUSE_CAMERA_API_MAX);
630 camera_activ = g_new0(gint, MUSE_CAMERA_API_MAX);
632 g_atomic_int_set(&cb_info->rcv_thread_running, 1);
633 cb_info->fd = sockfd;
634 cb_info->pCond = camera_cond;
635 cb_info->pMutex = camera_mutex;
636 cb_info->activating = camera_activ;
637 cb_info->msg_rcv_thread = g_thread_new("msg_rcv_thread", client_cb_handler, (gpointer)cb_info);
639 g_atomic_int_set(&cb_info->event_thread_running, 1);
640 g_mutex_init(&cb_info->event_mutex);
641 g_cond_init(&cb_info->event_cond);
642 cb_info->event_queue = g_queue_new();
643 cb_info->event_thread = g_thread_new("event_thread", _event_handler, (gpointer)cb_info);
648 static void client_callback_destroy(callback_cb_info_s * cb_info)
650 g_return_if_fail(cb_info != NULL);
652 LOGI("MSG receive thread[%p] destroy", cb_info->msg_rcv_thread);
654 g_thread_join(cb_info->msg_rcv_thread);
655 g_thread_unref(cb_info->msg_rcv_thread);
656 cb_info->msg_rcv_thread = NULL;
658 LOGD("msg thread removed");
660 g_mutex_lock(&cb_info->event_mutex);
661 g_atomic_int_set(&cb_info->event_thread_running, 0);
662 g_cond_signal(&cb_info->event_cond);
663 g_mutex_unlock(&cb_info->event_mutex);
665 g_thread_join(cb_info->event_thread);
666 g_thread_unref(cb_info->event_thread);
667 cb_info->event_thread = NULL;
669 g_queue_free(cb_info->event_queue);
670 cb_info->event_queue = NULL;
671 g_mutex_clear(&cb_info->event_mutex);
672 g_cond_clear(&cb_info->event_cond);
674 LOGD("event thread removed");
676 if (cb_info->bufmgr) {
677 tbm_bufmgr_deinit(cb_info->bufmgr);
678 cb_info->bufmgr = NULL;
681 if (cb_info->pCond) {
682 g_free(cb_info->pCond);
684 if (cb_info->pMutex) {
685 g_free(cb_info->pMutex);
687 if (cb_info->activating) {
688 g_free(cb_info->activating);
696 int camera_create(camera_device_e device, camera_h* camera)
700 int ret = CAMERA_ERROR_NONE;
701 camera_cli_s *pc = NULL;
702 tbm_bufmgr bufmgr = NULL;
704 muse_camera_api_e api = MUSE_CAMERA_API_CREATE;
705 muse_core_api_module_e muse_module = MUSE_CAMERA;
706 int device_type = (int)device;
709 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
710 return CAMERA_ERROR_INVALID_PARAMETER;
713 bufmgr = tbm_bufmgr_init(-1);
714 if (bufmgr == NULL) {
715 LOGE("get tbm bufmgr failed");
716 return CAMERA_ERROR_INVALID_OPERATION;
719 sock_fd = muse_core_client_new();
721 sndMsg = muse_core_msg_json_factory_new(api,
722 MUSE_TYPE_INT, "module", muse_module,
723 MUSE_TYPE_INT, PARAM_DEVICE_TYPE, (int)device_type,
726 muse_core_ipc_send_msg(sock_fd, sndMsg);
727 muse_core_msg_json_factory_free(sndMsg);
729 pc = g_new0(camera_cli_s, 1);
731 ret = CAMERA_ERROR_OUT_OF_MEMORY;
735 pc->cb_info = client_callback_new(sock_fd);
737 LOGD("cb info : %d", pc->cb_info->fd);
739 ret = client_wait_for_cb_return(api, pc->cb_info, CALLBACK_TIME_OUT);
740 if (ret == CAMERA_ERROR_NONE) {
742 muse_camera_msg_get_pointer(handle, pc->cb_info->recvMsg);
744 LOGE("Receiving Handle Failed!!");
745 ret = CAMERA_ERROR_INVALID_OPERATION;
748 pc->remote_handle = handle;
749 pc->cb_info->bufmgr = bufmgr;
751 LOGD("camera create 0x%x", pc->remote_handle);
752 *camera = (camera_h) pc;
760 tbm_bufmgr_deinit(bufmgr);
764 client_callback_destroy(pc->cb_info);
770 LOGE("camera create error : 0x%x", ret);
775 int camera_destroy(camera_h camera)
777 if (camera == NULL) {
778 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
779 return CAMERA_ERROR_INVALID_PARAMETER;
782 int ret = CAMERA_ERROR_NONE;
783 muse_camera_api_e api = MUSE_CAMERA_API_DESTROY;
784 camera_cli_s *pc = (camera_cli_s *)camera;
785 int sock_fd = pc->cb_info->fd;
789 LOGE("pc is already nul!!");
790 return CAMERA_ERROR_INVALID_PARAMETER;
791 } else if (pc->cb_info == NULL) {
792 return CAMERA_ERROR_INVALID_PARAMETER;
795 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
796 if (ret == CAMERA_ERROR_NONE) {
797 client_callback_destroy(pc->cb_info);
801 LOGE("camera destroy error : 0x%x", ret);
807 int camera_start_preview(camera_h camera)
810 if (camera == NULL) {
811 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
812 return CAMERA_ERROR_INVALID_PARAMETER;
815 int ret = CAMERA_ERROR_NONE;
816 muse_camera_api_e api = MUSE_CAMERA_API_START_PREVIEW;
817 camera_cli_s *pc = (camera_cli_s *)camera;
819 char caps[MUSE_CAMERA_MSG_MAX_LENGTH] = {0};
821 if (pc->cb_info == NULL) {
822 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
823 return CAMERA_ERROR_INVALID_PARAMETER;
826 sock_fd = pc->cb_info->fd;
828 muse_camera_msg_send_longtime(api, sock_fd, pc->cb_info, ret);
829 LOGD("Enter, ret :0x%x", ret);
830 if(ret == CAMERA_ERROR_NONE) {
831 muse_camera_msg_get_string(caps, pc->cb_info->recvMsg);
832 LOGD("caps : %s", caps);
833 if (pc->cli_display_handle != 0) {
834 LOGD("client's display handle is : 0x%x", pc->cli_display_handle);
835 if(strlen(caps) > 0 &&
836 mm_camcorder_client_realize(pc->client_handle, caps) != MM_ERROR_NONE)
837 ret = CAMERA_ERROR_INVALID_OPERATION;
839 LOGD("display handle is NULL");
842 LOGD("ret : 0x%x", ret);
846 int camera_stop_preview(camera_h camera)
848 if (camera == NULL) {
849 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
850 return CAMERA_ERROR_INVALID_PARAMETER;
852 int ret = CAMERA_ERROR_NONE;
853 camera_cli_s *pc = (camera_cli_s *)camera;
855 muse_camera_api_e api = MUSE_CAMERA_API_STOP_PREVIEW;
857 if (pc->cb_info == NULL) {
858 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
859 return CAMERA_ERROR_INVALID_PARAMETER;
862 sock_fd = pc->cb_info->fd;
864 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
866 if(ret == CAMERA_ERROR_NONE) {
867 if (pc->cli_display_handle != 0) {
868 LOGD("Unrealize client");
869 if (pc->client_handle != NULL) {
870 ret = mm_camcorder_client_unrealize(pc->client_handle);
871 mm_camcorder_client_destroy(pc->client_handle);
874 LOGD("Client did not realized : Display handle is NULL");
877 LOGD("ret : 0x%x", ret);
881 int camera_start_capture(camera_h camera, camera_capturing_cb capturing_cb , camera_capture_completed_cb completed_cb , void *user_data)
883 if (camera == NULL) {
884 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
885 return CAMERA_ERROR_INVALID_PARAMETER;
887 int ret = CAMERA_ERROR_NONE;
889 camera_cli_s *pc = (camera_cli_s *)camera;
890 muse_camera_api_e api = MUSE_CAMERA_API_START_CAPTURE;
892 int is_capturing_cb = 0;
893 int is_completed_cb = 0;
894 LOGD("Enter, handle :%x", pc->remote_handle);
896 if (pc->cb_info == NULL) {
897 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
898 return CAMERA_ERROR_INVALID_PARAMETER;
901 sock_fd = pc->cb_info->fd;
903 if (capturing_cb != NULL) {
905 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_CAPTURE] = capturing_cb;
906 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_CAPTURE] = user_data;
909 if(completed_cb != NULL) {
911 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = completed_cb;
912 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = user_data;
915 muse_camera_msg_send2(api, sock_fd, pc->cb_info, ret, INT, is_capturing_cb, INT, is_completed_cb);
916 LOGD("is_capturing_cb :%d, is_completed_cb : %d", is_capturing_cb, is_completed_cb);
917 LOGD("ret : 0x%x", ret);
921 bool camera_is_supported_continuous_capture(camera_h camera)
923 if (camera == NULL) {
924 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
928 int ret = CAMERA_ERROR_NONE;
929 camera_cli_s *pc = (camera_cli_s *)camera;
930 muse_camera_api_e api = MUSE_CAMERA_API_SUPPORT_CONTINUOUS_CAPTURE;
933 if (pc->cb_info == NULL) {
934 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
935 return CAMERA_ERROR_INVALID_PARAMETER;
938 sock_fd = pc->cb_info->fd;
940 LOGD("Enter, remote_handle : %x", pc->remote_handle);
941 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
942 LOGD("ret : 0x%x", ret);
946 int camera_start_continuous_capture(camera_h camera, int count, int interval, camera_capturing_cb capturing_cb, camera_capture_completed_cb completed_cb , void *user_data)
948 if (camera == NULL) {
949 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
950 return CAMERA_ERROR_INVALID_PARAMETER;
953 int ret = CAMERA_ERROR_NONE;
955 camera_cli_s *pc = (camera_cli_s *)camera;
956 muse_camera_api_e api = MUSE_CAMERA_API_START_CONTINUOUS_CAPTURE;
958 LOGD("Enter, handle :%x", pc->remote_handle);
961 if (pc->cb_info == NULL) {
962 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
963 return CAMERA_ERROR_INVALID_PARAMETER;
965 sock_fd = pc->cb_info->fd;
967 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_CAPTURE] = capturing_cb;
968 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_CAPTURE] = user_data;
969 pc->cb_info->user_cb_completed[MUSE_CAMERA_EVENT_TYPE_CAPTURE] = completed_cb;
971 muse_camera_msg_send2(api, sock_fd, pc->cb_info, ret, INT, count, INT, interval);
972 LOGD("ret : 0x%x", ret);
976 int camera_stop_continuous_capture(camera_h camera)
978 if (camera == NULL) {
979 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
980 return CAMERA_ERROR_INVALID_PARAMETER;
984 int ret = CAMERA_ERROR_NONE;
986 camera_cli_s *pc = (camera_cli_s *)camera;
987 muse_camera_api_e api = MUSE_CAMERA_API_STOP_CONTINUOUS_CAPTURE;
988 LOGD("Enter, handle :%x", pc->remote_handle);
990 if (pc->cb_info == NULL) {
991 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
992 return CAMERA_ERROR_INVALID_PARAMETER;
994 sock_fd = pc->cb_info->fd;
995 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
996 LOGD("ret : 0x%x", ret);
1000 bool camera_is_supported_face_detection(camera_h camera)
1002 if (camera == NULL) {
1003 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1006 int ret = CAMERA_ERROR_NONE;
1008 camera_cli_s *pc = (camera_cli_s *)camera;
1009 muse_camera_api_e api = MUSE_CAMERA_API_SUPPORT_FACE_DETECTION;
1011 if (pc->cb_info == NULL) {
1012 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1013 return CAMERA_ERROR_INVALID_PARAMETER;
1015 sock_fd = pc->cb_info->fd;
1017 LOGD("Enter, remote_handle : %x", pc->remote_handle);
1018 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1019 LOGD("ret : 0x%x", ret);
1023 bool camera_is_supported_zero_shutter_lag(camera_h camera)
1025 if (camera == NULL) {
1026 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1029 int ret = CAMERA_ERROR_NONE;
1031 camera_cli_s *pc = (camera_cli_s *)camera;
1032 muse_camera_api_e api = MUSE_CAMERA_API_SUPPORT_ZERO_SHUTTER_LAG;
1034 if (pc->cb_info == NULL) {
1035 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1036 return CAMERA_ERROR_INVALID_PARAMETER;
1038 sock_fd = pc->cb_info->fd;
1040 LOGD("Enter, remote_handle : %x", pc->remote_handle);
1041 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1042 LOGD("ret : 0x%x", ret);
1046 bool camera_is_supported_media_packet_preview_cb(camera_h camera)
1048 if (camera == NULL) {
1049 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1053 int ret = CAMERA_ERROR_NONE;
1055 camera_cli_s *pc = (camera_cli_s *)camera;
1056 muse_camera_api_e api = MUSE_CAMERA_API_SUPPORT_MEDIA_PACKET_PREVIEW_CB;
1058 if (pc->cb_info == NULL) {
1059 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1060 return CAMERA_ERROR_INVALID_PARAMETER;
1062 sock_fd = pc->cb_info->fd;
1064 LOGD("Enter, remote_handle : %x", pc->remote_handle);
1065 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1066 LOGD("ret : 0x%x", ret);
1070 int camera_get_device_count(camera_h camera, int *device_count)
1072 if (camera == NULL || device_count == NULL) {
1073 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
1074 return CAMERA_ERROR_INVALID_PARAMETER;
1076 int ret = CAMERA_ERROR_NONE;
1078 camera_cli_s *pc = (camera_cli_s *)camera;
1079 muse_camera_api_e api = MUSE_CAMERA_API_GET_DEVICE_COUNT;
1081 if (pc->cb_info == NULL) {
1082 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1083 return CAMERA_ERROR_INVALID_PARAMETER;
1085 sock_fd = pc->cb_info->fd;
1086 int get_device_count;
1088 LOGD("Enter, remote_handle : %x", pc->remote_handle);
1089 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1091 if (ret == CAMERA_ERROR_NONE) {
1092 muse_camera_msg_get(get_device_count, pc->cb_info->recvMsg);
1093 *device_count = get_device_count;
1095 LOGD("ret : 0x%x", ret);
1099 int camera_start_face_detection(camera_h camera, camera_face_detected_cb callback, void * user_data)
1101 if (camera == NULL) {
1102 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
1103 return CAMERA_ERROR_INVALID_PARAMETER;
1106 int ret = CAMERA_ERROR_NONE;
1108 camera_cli_s *pc = (camera_cli_s *)camera;
1109 muse_camera_api_e api = MUSE_CAMERA_API_START_FACE_DETECTION;
1111 LOGD("Enter, handle :%x", pc->remote_handle);
1113 if (pc->cb_info == NULL) {
1114 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1115 return CAMERA_ERROR_INVALID_PARAMETER;
1117 sock_fd = pc->cb_info->fd;
1118 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FACE_DETECTION] = callback;
1119 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FACE_DETECTION] = user_data;
1121 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1122 LOGD("ret : 0x%x", ret);
1126 int camera_stop_face_detection(camera_h camera)
1128 if (camera == NULL) {
1129 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1130 return CAMERA_ERROR_INVALID_PARAMETER;
1133 int ret = CAMERA_ERROR_NONE;
1135 camera_cli_s *pc = (camera_cli_s *)camera;
1136 muse_camera_api_e api = MUSE_CAMERA_API_STOP_FACE_DETECTION;
1137 LOGD("Enter, handle :%x", pc->remote_handle);
1139 if (pc->cb_info == NULL) {
1140 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1141 return CAMERA_ERROR_INVALID_PARAMETER;
1143 sock_fd = pc->cb_info->fd;
1144 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1145 LOGD("ret : 0x%x", ret);
1149 int camera_get_state(camera_h camera, camera_state_e * state)
1151 if (camera == NULL || state == NULL) {
1152 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1153 return CAMERA_ERROR_INVALID_PARAMETER;
1155 int ret = CAMERA_ERROR_NONE;
1157 camera_cli_s *pc = (camera_cli_s *)camera;
1158 muse_camera_api_e api = MUSE_CAMERA_API_GET_STATE;
1160 if (pc->cb_info == NULL) {
1161 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1162 return CAMERA_ERROR_INVALID_PARAMETER;
1164 sock_fd = pc->cb_info->fd;
1167 LOGD("Enter, remote_handle : %x", pc->remote_handle);
1168 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1170 if (ret == CAMERA_ERROR_NONE) {
1171 muse_camera_msg_get(get_state, pc->cb_info->recvMsg);
1172 *state = (camera_state_e)get_state;
1174 LOGD("ret : 0x%x", ret);
1178 int camera_start_focusing(camera_h camera, bool continuous)
1180 if( camera == NULL){
1181 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1182 return CAMERA_ERROR_INVALID_PARAMETER;
1185 int ret = CAMERA_ERROR_NONE;
1187 camera_cli_s *pc = (camera_cli_s *)camera;
1188 muse_camera_api_e api = MUSE_CAMERA_API_START_FOCUSING;
1190 if (pc->cb_info == NULL) {
1191 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1192 return CAMERA_ERROR_INVALID_PARAMETER;
1194 sock_fd = pc->cb_info->fd;
1195 int is_continuous = (int)continuous;
1197 LOGD("Enter, remote_handle : %x", pc->remote_handle);
1198 muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, is_continuous);
1199 LOGD("ret : 0x%x", ret);
1203 int camera_cancel_focusing(camera_h camera)
1205 if (camera == NULL) {
1206 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1207 return CAMERA_ERROR_INVALID_PARAMETER;
1210 int ret = CAMERA_ERROR_NONE;
1212 camera_cli_s *pc = (camera_cli_s *)camera;
1213 muse_camera_api_e api = MUSE_CAMERA_API_CANCEL_FOCUSING;
1215 if (pc->cb_info == NULL) {
1216 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1217 return CAMERA_ERROR_INVALID_PARAMETER;
1219 sock_fd = pc->cb_info->fd;
1221 LOGD("Enter, remote_handle : %x", pc->remote_handle);
1222 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1223 LOGD("ret : 0x%x", ret);
1227 int camera_set_display(camera_h camera, camera_display_type_e type, camera_display_h display)
1229 int ret = CAMERA_ERROR_NONE;
1230 int display_surface;
1231 void *set_display_handle = NULL;
1232 int set_surface = MM_DISPLAY_SURFACE_X;
1233 Evas_Object *obj = NULL;
1234 const char *object_type = NULL;
1235 char socket_path[MUSE_CAMERA_MSG_MAX_LENGTH] = {0,};
1237 if (camera == NULL) {
1238 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
1239 return CAMERA_ERROR_INVALID_PARAMETER;
1242 if (type != CAMERA_DISPLAY_TYPE_NONE && display == NULL) {
1243 LOGE("display type[%d] is not NONE, but display handle is NULL", type);
1244 return CAMERA_ERROR_INVALID_PARAMETER;
1247 int display_type = (int)type;
1248 camera_cli_s *pc = (camera_cli_s *)camera;
1249 muse_camera_api_e api = MUSE_CAMERA_API_SET_DISPLAY;
1251 if (pc->cb_info == NULL) {
1252 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1253 return CAMERA_ERROR_INVALID_PARAMETER;
1255 sock_fd = pc->cb_info->fd;
1257 LOGD("Enter, remote_handle : %x display : 0x%x", pc->remote_handle, display);
1259 if (type == CAMERA_DISPLAY_TYPE_NONE) {
1260 set_display_handle = 0;
1261 set_surface = MM_DISPLAY_SURFACE_NULL;
1262 LOGD("display type NONE");
1264 obj = (Evas_Object *)display;
1265 object_type = evas_object_type_get(obj);
1267 if (type == CAMERA_DISPLAY_TYPE_OVERLAY && !strcmp(object_type, "elm_win")) {
1269 MMCamWaylandInfo *wl_info = g_new0(MMCamWaylandInfo, 1);
1271 if (wl_info == NULL) {
1272 LOGE("wl_info alloc failed : %d", sizeof(MMCamWaylandInfo));
1273 return CAMERA_ERROR_OUT_OF_MEMORY;
1276 wl_info->evas_obj = (void *)obj;
1277 wl_info->window = (void *)elm_win_wl_window_get(obj);
1278 wl_info->surface = (void *)ecore_wl_window_surface_get(wl_info->window);
1279 wl_info->display = (void *)ecore_wl_display_get();
1281 if (wl_info->window == NULL || wl_info->surface == NULL || wl_info->display == NULL) {
1282 LOGE("something is NULL %p, %p, %p", wl_info->window, wl_info->surface, wl_info->display);
1283 return CAMERA_ERROR_INVALID_OPERATION;
1286 evas_object_geometry_get(obj, &wl_info->window_x, &wl_info->window_y,
1287 &wl_info->window_width, &wl_info->window_height);
1289 /* set wayland info */
1290 pc->wl_info = wl_info;
1291 set_surface = MM_DISPLAY_SURFACE_X;
1292 set_display_handle = (void *)wl_info;
1294 LOGD("wayland obj %p, window %p, surface %p, display %p, size %d,%d,%dx%d",
1295 wl_info->evas_obj, wl_info->window, wl_info->surface, wl_info->display,
1296 wl_info->window_x, wl_info->window_y, wl_info->window_width, wl_info->window_height);
1297 #else /* HAVE_WAYLAND */
1298 /* x window overlay surface */
1299 set_display_handle = (void *)elm_win_xwindow_get(obj);
1300 set_surface = MM_DISPLAY_SURFACE_X;
1301 LOGD("display type OVERLAY : handle %p", set_display_handle);
1303 } else if (type == CAMERA_DISPLAY_TYPE_EVAS && !strcmp(object_type, "image")) {
1304 /* evas object surface */
1305 set_display_handle = (void *)display;
1306 set_surface = MM_DISPLAY_SURFACE_EVAS;
1307 LOGD("display type EVAS : handle %p", set_display_handle);
1309 LOGE("unknown evas object [%p,%s] or type [%d] mismatch", obj, object_type, type);
1310 return CAMERA_ERROR_INVALID_PARAMETER;
1313 LOGE("failed to get evas object type from %p", obj);
1314 return CAMERA_ERROR_INVALID_PARAMETER;
1318 pc->cli_display_handle = (intptr_t)set_display_handle;
1319 display_surface = (int)set_surface;
1320 muse_camera_msg_send2(api, sock_fd, pc->cb_info, ret,
1322 INT, display_surface);
1324 if (ret == CAMERA_ERROR_NONE && type == CAMERA_DISPLAY_TYPE_OVERLAY && !strcmp(object_type, "elm_win")) {
1325 if (mm_camcorder_client_create(&(pc->client_handle))) {
1326 LOGE("camera client create Failed");
1327 return CAMERA_ERROR_INVALID_OPERATION;
1329 muse_camera_msg_get_string(socket_path, pc->cb_info->recvMsg);
1330 LOGD("shmsrc stream path : %s", socket_path);
1331 if(mm_camcorder_client_set_shm_socket_path(pc->client_handle, socket_path)
1333 return CAMERA_ERROR_INVALID_OPERATION;
1334 ret = mm_camcorder_set_attributes(pc->client_handle, NULL,
1335 MMCAM_DISPLAY_SURFACE, set_surface,
1337 if (ret == MM_ERROR_NONE && type != CAMERA_DISPLAY_TYPE_NONE) {
1338 ret = mm_camcorder_set_attributes(pc->client_handle, NULL,
1339 MMCAM_DISPLAY_HANDLE, pc->cli_display_handle, sizeof(void *),
1341 LOGD("ret : 0x%x", ret);
1344 LOGD("ret : 0x%x", ret);
1348 int camera_set_preview_resolution(camera_h camera, int width, int height)
1350 if( camera == NULL){
1351 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1352 return CAMERA_ERROR_INVALID_PARAMETER;
1354 int ret = CAMERA_ERROR_NONE;
1356 camera_cli_s *pc = (camera_cli_s *)camera;
1357 muse_camera_api_e api = MUSE_CAMERA_API_SET_PREVIEW_RESOLUTION;
1359 if (pc->cb_info == NULL) {
1360 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1361 return CAMERA_ERROR_INVALID_PARAMETER;
1363 sock_fd = pc->cb_info->fd;
1365 LOGD("Enter, remote_handle : %x", pc->remote_handle);
1366 muse_camera_msg_send2(api, sock_fd, pc->cb_info, ret, INT, width, INT, height);
1367 LOGD("ret : 0x%x", ret);
1372 int camera_set_capture_resolution(camera_h camera, int width, int height)
1374 if (camera == NULL) {
1375 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1376 return CAMERA_ERROR_INVALID_PARAMETER;
1379 int ret = CAMERA_ERROR_NONE;
1381 camera_cli_s *pc = (camera_cli_s *)camera;
1382 muse_camera_api_e api = MUSE_CAMERA_API_SET_CAPTURE_RESOLUTION;
1384 if (pc->cb_info == NULL) {
1385 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1386 return CAMERA_ERROR_INVALID_PARAMETER;
1388 sock_fd = pc->cb_info->fd;
1390 LOGD("Enter, remote_handle : %x", pc->remote_handle);
1391 muse_camera_msg_send2(api, sock_fd, pc->cb_info, ret, INT, width, INT, height);
1392 LOGD("ret : 0x%x", ret);
1396 int camera_set_capture_format(camera_h camera, camera_pixel_format_e format)
1398 if (camera == NULL) {
1399 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1400 return CAMERA_ERROR_INVALID_PARAMETER;
1403 int ret = CAMERA_ERROR_NONE;
1404 int set_format = (int)format;
1406 camera_cli_s *pc = (camera_cli_s *)camera;
1407 muse_camera_api_e api = MUSE_CAMERA_API_SET_CAPTURE_FORMAT;
1409 if (pc->cb_info == NULL) {
1410 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1411 return CAMERA_ERROR_INVALID_PARAMETER;
1413 sock_fd = pc->cb_info->fd;
1415 LOGD("Enter, remote_handle : %x, capture_format: %d", pc->remote_handle, set_format);
1416 muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_format);
1417 LOGD("ret : 0x%x", ret);
1421 int camera_set_preview_format(camera_h camera, camera_pixel_format_e format)
1423 if (camera == NULL) {
1424 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1425 return CAMERA_ERROR_INVALID_PARAMETER;
1428 int ret = CAMERA_ERROR_NONE;
1429 int set_format = (int)format;
1431 camera_cli_s *pc = (camera_cli_s *)camera;
1432 muse_camera_api_e api = MUSE_CAMERA_API_SET_PREVIEW_FORMAT;
1434 if (pc->cb_info == NULL) {
1435 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1436 return CAMERA_ERROR_INVALID_PARAMETER;
1438 sock_fd = pc->cb_info->fd;
1440 LOGD("Enter, remote_handle : %x, capture_format: %d", pc->remote_handle, set_format);
1441 muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_format);
1442 LOGD("ret : 0x%x", ret);
1446 int camera_get_preview_resolution(camera_h camera, int *width, int *height)
1448 if (camera == NULL || width == NULL || height == NULL) {
1449 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1450 return CAMERA_ERROR_INVALID_PARAMETER;
1454 int ret = CAMERA_ERROR_NONE;
1456 camera_cli_s *pc = (camera_cli_s *)camera;
1457 muse_camera_api_e api = MUSE_CAMERA_API_GET_PREVIEW_RESOLUTION;
1459 if (pc->cb_info == NULL) {
1460 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1461 return CAMERA_ERROR_INVALID_PARAMETER;
1463 sock_fd = pc->cb_info->fd;
1467 LOGD("Enter, remote_handle : %x", pc->remote_handle);
1468 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1470 if (ret == CAMERA_ERROR_NONE) {
1471 muse_camera_msg_get(get_width, pc->cb_info->recvMsg);
1472 muse_camera_msg_get(get_height, pc->cb_info->recvMsg);
1474 *height = get_height;
1476 LOGD("ret : 0x%x", ret);
1480 int camera_set_display_rotation(camera_h camera, camera_rotation_e rotation)
1482 if( camera == NULL){
1483 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1484 return CAMERA_ERROR_INVALID_PARAMETER;
1487 int ret = CAMERA_ERROR_NONE;
1488 camera_cli_s *pc = (camera_cli_s *)camera;
1489 muse_camera_api_e api = MUSE_CAMERA_API_SET_DISPLAY_ROTATION;
1491 if (pc->cb_info == NULL) {
1492 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1493 return CAMERA_ERROR_INVALID_PARAMETER;
1495 sock_fd = pc->cb_info->fd;
1496 int set_rotation = (int)rotation;
1498 LOGD("Enter, remote_handle : %x", pc->remote_handle);
1499 muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_rotation);
1500 LOGD("ret : 0x%x", ret);
1504 int camera_get_display_rotation(camera_h camera, camera_rotation_e *rotation)
1506 if( camera == NULL || rotation == NULL ){
1507 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1508 return CAMERA_ERROR_INVALID_PARAMETER;
1511 int ret = CAMERA_ERROR_NONE;
1513 camera_cli_s *pc = (camera_cli_s *)camera;
1514 muse_camera_api_e api = MUSE_CAMERA_API_GET_DISPLAY_ROTATION;
1516 if (pc->cb_info == NULL) {
1517 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1518 return CAMERA_ERROR_INVALID_PARAMETER;
1520 sock_fd = pc->cb_info->fd;
1523 LOGD("Enter, remote_handle : %x", pc->remote_handle);
1524 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1526 if (ret == CAMERA_ERROR_NONE) {
1527 muse_camera_msg_get(get_rotation, pc->cb_info->recvMsg);
1528 *rotation = (camera_rotation_e)get_rotation;
1530 LOGD("ret : 0x%x", ret);
1534 int camera_set_display_flip(camera_h camera, camera_flip_e flip)
1536 if( camera == NULL){
1537 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1538 return CAMERA_ERROR_INVALID_PARAMETER;
1541 int ret = CAMERA_ERROR_NONE;
1543 camera_cli_s *pc = (camera_cli_s *)camera;
1544 muse_camera_api_e api = MUSE_CAMERA_API_SET_DISPLAY_FLIP;
1546 if (pc->cb_info == NULL) {
1547 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1548 return CAMERA_ERROR_INVALID_PARAMETER;
1550 sock_fd = pc->cb_info->fd;
1551 int set_flip = (int)flip;
1553 LOGD("Enter, remote_handle : %x", pc->remote_handle);
1554 muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_flip);
1555 LOGD("ret : 0x%x", ret);
1559 int camera_get_display_flip(camera_h camera, camera_flip_e *flip)
1561 if( camera == NULL || flip == NULL ){
1562 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1563 return CAMERA_ERROR_INVALID_PARAMETER;
1566 int ret = CAMERA_ERROR_NONE;
1568 camera_cli_s *pc = (camera_cli_s *)camera;
1569 muse_camera_api_e api = MUSE_CAMERA_API_GET_DISPLAY_FLIP;
1571 if (pc->cb_info == NULL) {
1572 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1573 return CAMERA_ERROR_INVALID_PARAMETER;
1575 sock_fd = pc->cb_info->fd;
1578 LOGD("Enter, remote_handle : %x", pc->remote_handle);
1579 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1581 if (ret == CAMERA_ERROR_NONE) {
1582 muse_camera_msg_get(get_flip, pc->cb_info->recvMsg);
1583 *flip = (camera_flip_e)get_flip;
1585 LOGD("ret : 0x%x", ret);
1589 int camera_set_display_visible(camera_h camera, bool visible)
1591 if( camera == NULL){
1592 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1593 return CAMERA_ERROR_INVALID_PARAMETER;
1596 int ret = CAMERA_ERROR_NONE;
1598 camera_cli_s *pc = (camera_cli_s *)camera;
1599 muse_camera_api_e api = MUSE_CAMERA_API_SET_DISPLAY_VISIBLE;
1600 int set_visible = (int)visible;
1602 if (pc->cb_info == NULL) {
1603 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1604 return CAMERA_ERROR_INVALID_PARAMETER;
1606 sock_fd = pc->cb_info->fd;
1608 LOGD("Enter, remote_handle : %x", pc->remote_handle);
1609 muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_visible);
1610 LOGD("ret : 0x%x", ret);
1614 int camera_is_display_visible(camera_h camera, bool* visible)
1616 if( camera == NULL || visible == NULL){
1617 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1618 return CAMERA_ERROR_INVALID_PARAMETER;
1621 int ret = CAMERA_ERROR_NONE;
1623 camera_cli_s *pc = (camera_cli_s *)camera;
1624 muse_camera_api_e api = MUSE_CAMERA_API_IS_DISPLAY_VISIBLE;
1626 if (pc->cb_info == NULL) {
1627 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1628 return CAMERA_ERROR_INVALID_PARAMETER;
1630 sock_fd = pc->cb_info->fd;
1633 LOGD("Enter, remote_handle : %x", pc->remote_handle);
1634 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1636 if (ret == CAMERA_ERROR_NONE) {
1637 muse_camera_msg_get(get_visible, pc->cb_info->recvMsg);
1638 *visible = (bool)get_visible;
1640 LOGD("ret : 0x%x", ret);
1644 int camera_set_display_mode(camera_h camera, camera_display_mode_e mode)
1646 if (camera == NULL) {
1647 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1648 return CAMERA_ERROR_INVALID_PARAMETER;
1651 int ret = CAMERA_ERROR_NONE;
1652 int set_mode = (int)mode;
1654 camera_cli_s *pc = (camera_cli_s *)camera;
1655 muse_camera_api_e api = MUSE_CAMERA_API_SET_DISPLAY_MODE;
1657 if (pc->cb_info == NULL) {
1658 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1659 return CAMERA_ERROR_INVALID_PARAMETER;
1661 sock_fd = pc->cb_info->fd;
1663 LOGD("Enter, remote_handle : %x", pc->remote_handle);
1664 muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_mode);
1665 LOGD("ret : 0x%x", ret);
1669 int camera_get_display_mode(camera_h camera, camera_display_mode_e* mode)
1671 if( camera == NULL || mode == NULL){
1672 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1673 return CAMERA_ERROR_INVALID_PARAMETER;
1676 int ret = CAMERA_ERROR_NONE;
1678 camera_cli_s *pc = (camera_cli_s *)camera;
1679 muse_camera_api_e api = MUSE_CAMERA_API_GET_DISPLAY_MODE;
1681 if (pc->cb_info == NULL) {
1682 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1683 return CAMERA_ERROR_INVALID_PARAMETER;
1685 sock_fd = pc->cb_info->fd;
1688 LOGD("Enter, remote_handle : %x", pc->remote_handle);
1689 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1691 if (ret == CAMERA_ERROR_NONE) {
1692 muse_camera_msg_get(get_mode, pc->cb_info->recvMsg);
1693 *mode = (camera_display_mode_e)get_mode;
1695 LOGD("ret : 0x%x", ret);
1699 int camera_get_capture_resolution(camera_h camera, int *width, int *height)
1701 if( camera == NULL || width== NULL || height == NULL){
1702 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1703 return CAMERA_ERROR_INVALID_PARAMETER;
1705 int ret = CAMERA_ERROR_NONE;
1707 camera_cli_s *pc = (camera_cli_s *)camera;
1708 muse_camera_api_e api = MUSE_CAMERA_API_GET_CAPTURE_RESOLUTION;
1710 if (pc->cb_info == NULL) {
1711 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1712 return CAMERA_ERROR_INVALID_PARAMETER;
1714 sock_fd = pc->cb_info->fd;
1718 LOGD("Enter, remote_handle : %x", pc->remote_handle);
1719 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1721 if (ret == CAMERA_ERROR_NONE) {
1722 muse_camera_msg_get(get_width, pc->cb_info->recvMsg);
1723 muse_camera_msg_get(get_height, pc->cb_info->recvMsg);
1725 *height = get_height;
1727 LOGD("ret : 0x%x", ret);
1731 int camera_get_capture_format(camera_h camera, camera_pixel_format_e *format)
1733 if( camera == NULL || format == NULL){
1734 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1735 return CAMERA_ERROR_INVALID_PARAMETER;
1737 int ret = CAMERA_ERROR_NONE;
1739 camera_cli_s *pc = (camera_cli_s *)camera;
1740 muse_camera_api_e api = MUSE_CAMERA_API_GET_CAPTURE_FORMAT;
1743 if (pc->cb_info == NULL) {
1744 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1745 return CAMERA_ERROR_INVALID_PARAMETER;
1747 sock_fd = pc->cb_info->fd;
1749 LOGD("Enter, remote_handle : %x", pc->remote_handle);
1750 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1752 if (ret == CAMERA_ERROR_NONE) {
1753 muse_camera_msg_get(get_format, pc->cb_info->recvMsg);
1754 *format = (camera_pixel_format_e)get_format;
1756 LOGD("ret : 0x%x", ret);
1760 int camera_get_preview_format(camera_h camera, camera_pixel_format_e *format)
1762 if( camera == NULL || format == NULL){
1763 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1764 return CAMERA_ERROR_INVALID_PARAMETER;
1767 int ret = CAMERA_ERROR_NONE;
1769 camera_cli_s *pc = (camera_cli_s *)camera;
1770 muse_camera_api_e api = MUSE_CAMERA_API_GET_PREVIEW_FORMAT;
1773 if (pc->cb_info == NULL) {
1774 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1775 return CAMERA_ERROR_INVALID_PARAMETER;
1777 sock_fd = pc->cb_info->fd;
1779 LOGD("Enter, remote_handle : %x", pc->remote_handle);
1780 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1782 if (ret == CAMERA_ERROR_NONE) {
1783 muse_camera_msg_get(get_format, pc->cb_info->recvMsg);
1784 *format = (camera_pixel_format_e)get_format;
1786 LOGD("ret : 0x%x", ret);
1790 int camera_set_preview_cb(camera_h camera, camera_preview_cb callback, void* user_data)
1792 if (camera == NULL || callback == NULL) {
1793 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1794 return CAMERA_ERROR_INVALID_PARAMETER;
1796 int ret = CAMERA_ERROR_NONE;
1798 camera_cli_s *pc = (camera_cli_s *)camera;
1800 if (pc->cb_info == NULL) {
1801 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1802 return CAMERA_ERROR_INVALID_PARAMETER;
1804 sock_fd = pc->cb_info->fd;
1805 muse_camera_api_e api = MUSE_CAMERA_API_SET_PREVIEW_CB;
1807 LOGD("Enter, handle :%x", pc->remote_handle);
1809 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_PREVIEW] = callback;
1810 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_PREVIEW] = user_data;
1812 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1813 LOGD("ret : 0x%x", ret);
1817 int camera_unset_preview_cb(camera_h camera)
1819 if (camera == NULL) {
1820 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1821 return CAMERA_ERROR_INVALID_PARAMETER;
1824 int ret = CAMERA_ERROR_NONE;
1826 camera_cli_s *pc = (camera_cli_s *)camera;
1827 muse_camera_api_e api = MUSE_CAMERA_API_UNSET_PREVIEW_CB;
1829 LOGD("Enter, handle :%x", pc->remote_handle);
1832 if (pc->cb_info == NULL) {
1833 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1834 return CAMERA_ERROR_INVALID_PARAMETER;
1836 sock_fd = pc->cb_info->fd;
1837 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_PREVIEW] = (void *)NULL;
1838 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_PREVIEW] = (void *)NULL;
1840 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1841 LOGD("ret : 0x%x", ret);
1845 int camera_set_media_packet_preview_cb(camera_h camera, camera_media_packet_preview_cb callback, void* user_data)
1847 if (camera == NULL) {
1848 LOGE("INVALID_PARAMETER(0x%08x) - handle", CAMERA_ERROR_INVALID_PARAMETER);
1849 return CAMERA_ERROR_INVALID_PARAMETER;
1852 if (callback == NULL) {
1853 LOGE("INVALID_PARAMETER(0x%08x) - callback", CAMERA_ERROR_INVALID_PARAMETER);
1854 return CAMERA_ERROR_NOT_SUPPORTED;
1857 int ret = CAMERA_ERROR_NONE;
1859 camera_cli_s *pc = (camera_cli_s *)camera;
1860 muse_camera_api_e api = MUSE_CAMERA_API_SET_MEDIA_PACKET_PREVIEW_CB;
1862 LOGD("Enter, handle :%x", pc->remote_handle);
1865 if (pc->cb_info == NULL) {
1866 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1867 return CAMERA_ERROR_INVALID_PARAMETER;
1869 sock_fd = pc->cb_info->fd;
1870 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_MEDIA_PACKET_PREVIEW] = callback;
1871 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_MEDIA_PACKET_PREVIEW] = user_data;
1873 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1874 LOGD("ret : 0x%x", ret);
1878 int camera_unset_media_packet_preview_cb(camera_h camera)
1880 if (camera == NULL) {
1881 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
1882 return CAMERA_ERROR_INVALID_PARAMETER;
1885 int ret = CAMERA_ERROR_NONE;
1887 camera_cli_s *pc = (camera_cli_s *)camera;
1888 muse_camera_api_e api = MUSE_CAMERA_API_UNSET_MEDIA_PACKET_PREVIEW_CB;
1890 LOGD("Enter, handle :%x", pc->remote_handle);
1893 if (pc->cb_info == NULL) {
1894 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1895 return CAMERA_ERROR_INVALID_PARAMETER;
1897 sock_fd = pc->cb_info->fd;
1898 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_MEDIA_PACKET_PREVIEW] = (void *)NULL;
1899 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_MEDIA_PACKET_PREVIEW] = (void *)NULL;
1901 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1902 LOGD("ret : 0x%x", ret);
1906 int camera_set_state_changed_cb(camera_h camera, camera_state_changed_cb callback, void* user_data)
1908 if( camera == NULL || callback == NULL){
1909 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1910 return CAMERA_ERROR_INVALID_PARAMETER;
1912 int ret = CAMERA_ERROR_NONE;
1914 camera_cli_s *pc = (camera_cli_s *)camera;
1915 muse_camera_api_e api = MUSE_CAMERA_API_SET_STATE_CHANGED_CB;
1917 LOGD("Enter, handle :%x", pc->remote_handle);
1920 if (pc->cb_info == NULL) {
1921 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1922 return CAMERA_ERROR_INVALID_PARAMETER;
1924 sock_fd = pc->cb_info->fd;
1925 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_STATE_CHANGE] = callback;
1926 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_STATE_CHANGE] = user_data;
1928 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1929 LOGD("ret : 0x%x", ret);
1932 int camera_unset_state_changed_cb(camera_h camera)
1934 if( camera == NULL){
1935 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1936 return CAMERA_ERROR_INVALID_PARAMETER;
1938 int ret = CAMERA_ERROR_NONE;
1940 camera_cli_s *pc = (camera_cli_s *)camera;
1941 muse_camera_api_e api = MUSE_CAMERA_API_UNSET_STATE_CHANGED_CB;
1943 LOGD("Enter, handle :%x", pc->remote_handle);
1946 if (pc->cb_info == NULL) {
1947 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1948 return CAMERA_ERROR_INVALID_PARAMETER;
1950 sock_fd = pc->cb_info->fd;
1951 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_STATE_CHANGE] = (void *)NULL;
1952 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_STATE_CHANGE] = (void *)NULL;
1954 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1955 LOGD("ret : 0x%x", ret);
1959 int camera_set_interrupted_cb(camera_h camera, camera_interrupted_cb callback, void *user_data)
1961 if( camera == NULL || callback == NULL){
1962 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1963 return CAMERA_ERROR_INVALID_PARAMETER;
1965 int ret = CAMERA_ERROR_NONE;
1967 camera_cli_s *pc = (camera_cli_s *)camera;
1968 muse_camera_api_e api = MUSE_CAMERA_API_SET_INTERRUPTED_CB;
1970 LOGD("Enter, handle :%x", pc->remote_handle);
1973 if (pc->cb_info == NULL) {
1974 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1975 return CAMERA_ERROR_INVALID_PARAMETER;
1977 sock_fd = pc->cb_info->fd;
1978 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_INTERRUPTED] = callback;
1979 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_INTERRUPTED] = user_data;
1981 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1982 LOGD("ret : 0x%x", ret);
1986 int camera_unset_interrupted_cb(camera_h camera)
1988 if( camera == NULL){
1989 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1990 return CAMERA_ERROR_INVALID_PARAMETER;
1992 int ret = CAMERA_ERROR_NONE;
1994 camera_cli_s *pc = (camera_cli_s *)camera;
1995 muse_camera_api_e api = MUSE_CAMERA_API_UNSET_INTERRUPTED_CB;
1997 LOGD("Enter, handle :%x", pc->remote_handle);
2000 if (pc->cb_info == NULL) {
2001 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2002 return CAMERA_ERROR_INVALID_PARAMETER;
2004 sock_fd = pc->cb_info->fd;
2005 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_INTERRUPTED] = (void *)NULL;
2006 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_INTERRUPTED] = (void *)NULL;
2008 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2009 LOGD("ret : 0x%x", ret);
2013 int camera_set_focus_changed_cb(camera_h camera, camera_focus_changed_cb callback, void* user_data)
2015 if( camera == NULL || callback == NULL){
2016 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2017 return CAMERA_ERROR_INVALID_PARAMETER;
2019 int ret = CAMERA_ERROR_NONE;
2021 camera_cli_s *pc = (camera_cli_s *)camera;
2022 muse_camera_api_e api = MUSE_CAMERA_API_SET_FOCUS_CHANGED_CB;
2024 LOGD("Enter, handle :%x", pc->remote_handle);
2027 if (pc->cb_info == NULL) {
2028 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2029 return CAMERA_ERROR_INVALID_PARAMETER;
2031 sock_fd = pc->cb_info->fd;
2032 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = callback;
2033 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = user_data;
2035 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2036 LOGD("ret : 0x%x", ret);
2040 int camera_unset_focus_changed_cb(camera_h camera)
2042 if( camera == NULL){
2043 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2044 return CAMERA_ERROR_INVALID_PARAMETER;
2046 int ret = CAMERA_ERROR_NONE;
2048 camera_cli_s *pc = (camera_cli_s *)camera;
2049 muse_camera_api_e api = MUSE_CAMERA_API_UNSET_FOCUS_CHANGED_CB;
2051 LOGD("Enter, handle :%x", pc->remote_handle);
2054 if (pc->cb_info == NULL) {
2055 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2056 return CAMERA_ERROR_INVALID_PARAMETER;
2058 sock_fd = pc->cb_info->fd;
2059 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = (void *)NULL;
2060 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = (void *)NULL;
2062 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2063 LOGD("ret : 0x%x", ret);
2067 int camera_set_error_cb(camera_h camera, camera_error_cb callback, void *user_data)
2069 if( camera == NULL || callback == NULL){
2070 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2071 return CAMERA_ERROR_INVALID_PARAMETER;
2073 int ret = CAMERA_ERROR_NONE;
2075 camera_cli_s *pc = (camera_cli_s *)camera;
2076 muse_camera_api_e api = MUSE_CAMERA_API_SET_ERROR_CB;
2078 LOGD("Enter, handle :%x", pc->remote_handle);
2081 if (pc->cb_info == NULL) {
2082 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2083 return CAMERA_ERROR_INVALID_PARAMETER;
2085 sock_fd = pc->cb_info->fd;
2086 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_ERROR] = callback;
2087 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_ERROR] = user_data;
2089 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2090 LOGD("ret : 0x%x", ret);
2094 int camera_unset_error_cb(camera_h camera)
2096 if( camera == NULL){
2097 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2098 return CAMERA_ERROR_INVALID_PARAMETER;
2100 int ret = CAMERA_ERROR_NONE;
2102 camera_cli_s *pc = (camera_cli_s *)camera;
2103 muse_camera_api_e api = MUSE_CAMERA_API_UNSET_ERROR_CB;
2105 LOGD("Enter, handle :%x", pc->remote_handle);
2108 if (pc->cb_info == NULL) {
2109 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2110 return CAMERA_ERROR_INVALID_PARAMETER;
2112 sock_fd = pc->cb_info->fd;
2113 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_ERROR] = (void *)NULL;
2114 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_ERROR] = (void *)NULL;
2116 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2117 LOGD("ret : 0x%x", ret);
2121 int camera_foreach_supported_preview_resolution(camera_h camera, camera_supported_preview_resolution_cb foreach_cb , void *user_data)
2123 if( camera == NULL || foreach_cb == NULL){
2124 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2125 return CAMERA_ERROR_INVALID_PARAMETER;
2127 int ret = CAMERA_ERROR_NONE;
2129 camera_cli_s *pc = (camera_cli_s *)camera;
2130 muse_camera_api_e api = MUSE_CAMERA_API_SET_FOREACH_SUPPORTED_PREVIEW_RESOLUTION;
2132 LOGD("Enter, handle :%x", pc->remote_handle);
2135 if (pc->cb_info == NULL) {
2136 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2137 return CAMERA_ERROR_INVALID_PARAMETER;
2139 sock_fd = pc->cb_info->fd;
2140 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_RESOLUTION] = foreach_cb;
2141 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_RESOLUTION] = user_data;
2143 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2144 LOGD("ret : 0x%x", ret);
2148 int camera_foreach_supported_capture_resolution(camera_h camera, camera_supported_capture_resolution_cb foreach_cb , void *user_data)
2150 if( camera == NULL || foreach_cb == NULL){
2151 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2152 return CAMERA_ERROR_INVALID_PARAMETER;
2154 int ret = CAMERA_ERROR_NONE;
2156 camera_cli_s *pc = (camera_cli_s *)camera;
2157 muse_camera_api_e api = MUSE_CAMERA_API_SET_FOREACH_SUPPORTED_CAPTURE_RESOLUTION;
2159 LOGD("Enter, handle :%x", pc->remote_handle);
2162 if (pc->cb_info == NULL) {
2163 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2164 return CAMERA_ERROR_INVALID_PARAMETER;
2166 sock_fd = pc->cb_info->fd;
2167 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_RESOLUTION] = foreach_cb;
2168 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_RESOLUTION] = user_data;
2170 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2171 LOGD("ret : 0x%x", ret);
2175 int camera_foreach_supported_capture_format(camera_h camera, camera_supported_capture_format_cb foreach_cb , void *user_data)
2177 if( camera == NULL || foreach_cb == NULL){
2178 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2179 return CAMERA_ERROR_INVALID_PARAMETER;
2181 int ret = CAMERA_ERROR_NONE;
2183 camera_cli_s *pc = (camera_cli_s *)camera;
2184 muse_camera_api_e api = MUSE_CAMERA_API_SET_FOREACH_SUPPORTED_CAPTURE_FORMAT;
2186 LOGD("Enter, handle :%x", pc->remote_handle);
2189 if (pc->cb_info == NULL) {
2190 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2191 return CAMERA_ERROR_INVALID_PARAMETER;
2193 sock_fd = pc->cb_info->fd;
2194 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_FORMAT] = foreach_cb;
2195 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_FORMAT] = user_data;
2197 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2198 LOGD("ret : 0x%x", ret);
2203 int camera_foreach_supported_preview_format(camera_h camera, camera_supported_preview_format_cb foreach_cb , void *user_data)
2205 if( camera == NULL || foreach_cb == NULL){
2206 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2207 return CAMERA_ERROR_INVALID_PARAMETER;
2209 int ret = CAMERA_ERROR_NONE;
2211 camera_cli_s *pc = (camera_cli_s *)camera;
2212 muse_camera_api_e api = MUSE_CAMERA_API_SET_FOREACH_SUPPORTED_PREVIEW_FORMAT;
2214 LOGD("Enter, handle :%x", pc->remote_handle);
2217 if (pc->cb_info == NULL) {
2218 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2219 return CAMERA_ERROR_INVALID_PARAMETER;
2221 sock_fd = pc->cb_info->fd;
2222 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_FORMAT] = foreach_cb;
2223 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_FORMAT] = user_data;
2225 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2226 LOGD("ret : 0x%x", ret);
2231 int camera_get_recommended_preview_resolution(camera_h camera, int *width, int *height)
2233 if (camera == NULL || width == NULL || height == NULL) {
2234 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2235 return CAMERA_ERROR_INVALID_PARAMETER;
2237 int ret = CAMERA_ERROR_NONE;
2239 camera_cli_s *pc = (camera_cli_s *)camera;
2240 muse_camera_api_e api = MUSE_CAMERA_API_GET_RECOMMENDED_PREVIEW_RESOLUTION;
2242 if (pc->cb_info == NULL) {
2243 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2244 return CAMERA_ERROR_INVALID_PARAMETER;
2246 sock_fd = pc->cb_info->fd;
2250 LOGD("Enter, remote_handle : %x", pc->remote_handle);
2251 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2253 if (ret == CAMERA_ERROR_NONE) {
2254 muse_camera_msg_get(get_width, pc->cb_info->recvMsg);
2255 muse_camera_msg_get(get_height, pc->cb_info->recvMsg);
2257 *height = get_height;
2259 LOGD("ret : 0x%x", ret);
2264 int camera_attr_get_lens_orientation(camera_h camera, int *angle)
2266 if( camera == NULL || angle == NULL){
2267 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2268 return CAMERA_ERROR_INVALID_PARAMETER;
2270 int ret = CAMERA_ERROR_NONE;
2272 camera_cli_s *pc = (camera_cli_s *)camera;
2273 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_LENS_ORIENTATION;
2275 if (pc->cb_info == NULL) {
2276 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2277 return CAMERA_ERROR_INVALID_PARAMETER;
2279 sock_fd = pc->cb_info->fd;
2282 LOGD("Enter, remote_handle : %x", pc->remote_handle);
2283 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2285 if (ret == CAMERA_ERROR_NONE) {
2286 muse_camera_msg_get(get_angle, pc->cb_info->recvMsg);
2289 LOGD("ret : 0x%x", ret);
2293 int camera_attr_set_theater_mode(camera_h camera, camera_attr_theater_mode_e mode)
2295 if (camera == NULL) {
2296 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2297 return CAMERA_ERROR_INVALID_PARAMETER;
2299 int ret = CAMERA_ERROR_NONE;
2300 camera_cli_s *pc = (camera_cli_s *)camera;
2301 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_THEATER_MODE;
2303 if (pc->cb_info == NULL) {
2304 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2305 return CAMERA_ERROR_INVALID_PARAMETER;
2307 sock_fd = pc->cb_info->fd;
2308 int set_mode = (int)mode;
2309 LOGD("Enter, remote_handle : %x", pc->remote_handle);
2310 muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_mode);
2311 LOGD("ret : 0x%x", ret);
2315 int camera_attr_get_theater_mode(camera_h camera, camera_attr_theater_mode_e *mode)
2317 if (camera == NULL || mode == NULL) {
2318 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2319 return CAMERA_ERROR_INVALID_PARAMETER;
2322 int ret = CAMERA_ERROR_NONE;
2323 camera_cli_s *pc = (camera_cli_s *)camera;
2324 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_THEATER_MODE;
2326 if (pc->cb_info == NULL) {
2327 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2328 return CAMERA_ERROR_INVALID_PARAMETER;
2330 sock_fd = pc->cb_info->fd;
2332 LOGD("Enter, remote_handle : %x", pc->remote_handle);
2333 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2335 if (ret == CAMERA_ERROR_NONE) {
2336 muse_camera_msg_get(get_mode, pc->cb_info->recvMsg);
2337 *mode = (camera_attr_theater_mode_e)get_mode;
2339 LOGD("ret : 0x%x", ret);
2343 int camera_attr_foreach_supported_theater_mode(camera_h camera, camera_attr_supported_theater_mode_cb foreach_cb, void *user_data)
2345 if (camera == NULL || foreach_cb == NULL) {
2346 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2347 return CAMERA_ERROR_INVALID_PARAMETER;
2349 int ret = CAMERA_ERROR_NONE;
2351 camera_cli_s *pc = (camera_cli_s *)camera;
2352 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_THEATER_MODE;
2354 LOGD("Enter, handle :%x", pc->remote_handle);
2357 if (pc->cb_info == NULL) {
2358 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2359 return CAMERA_ERROR_INVALID_PARAMETER;
2361 sock_fd = pc->cb_info->fd;
2362 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_THEATER_MODE] = foreach_cb;
2363 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_THEATER_MODE] = user_data;
2365 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2367 LOGD("Finish, return :%x", ret);
2372 int camera_attr_set_preview_fps(camera_h camera, camera_attr_fps_e fps)
2374 if( camera == NULL){
2375 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2376 return CAMERA_ERROR_INVALID_PARAMETER;
2378 int ret = CAMERA_ERROR_NONE;
2379 camera_cli_s *pc = (camera_cli_s *)camera;
2380 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_PREVIEW_FPS;
2382 if (pc->cb_info == NULL) {
2383 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2384 return CAMERA_ERROR_INVALID_PARAMETER;
2386 sock_fd = pc->cb_info->fd;
2387 int set_fps = (int)fps;
2388 LOGD("Enter, remote_handle : %x", pc->remote_handle);
2389 muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_fps);
2390 LOGD("ret : 0x%x", ret);
2395 int camera_attr_set_image_quality(camera_h camera, int quality)
2397 if( camera == NULL){
2398 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2399 return CAMERA_ERROR_INVALID_PARAMETER;
2401 int ret = CAMERA_ERROR_NONE;
2403 camera_cli_s *pc = (camera_cli_s *)camera;
2404 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_IMAGE_QUALITY;
2406 if (pc->cb_info == NULL) {
2407 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2408 return CAMERA_ERROR_INVALID_PARAMETER;
2410 sock_fd = pc->cb_info->fd;
2411 LOGD("Enter, remote_handle : %x", pc->remote_handle);
2412 muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, quality);
2413 LOGD("ret : 0x%x", ret);
2417 int camera_attr_get_preview_fps(camera_h camera, camera_attr_fps_e *fps)
2419 if( camera == NULL || fps == NULL){
2420 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2421 return CAMERA_ERROR_INVALID_PARAMETER;
2423 int ret = CAMERA_ERROR_NONE;
2425 camera_cli_s *pc = (camera_cli_s *)camera;
2426 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_PREVIEW_FPS;
2429 if (pc->cb_info == NULL) {
2430 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2431 return CAMERA_ERROR_INVALID_PARAMETER;
2433 sock_fd = pc->cb_info->fd;
2435 LOGD("Enter, remote_handle : %x", pc->remote_handle);
2436 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2438 if (ret == CAMERA_ERROR_NONE) {
2439 muse_camera_msg_get(get_fps, pc->cb_info->recvMsg);
2440 *fps = (camera_attr_fps_e)get_fps;
2442 LOGD("ret : 0x%x", ret);
2447 int camera_attr_get_image_quality(camera_h camera, int *quality)
2449 if( camera == NULL || quality == NULL){
2450 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2451 return CAMERA_ERROR_INVALID_PARAMETER;
2453 int ret = CAMERA_ERROR_NONE;
2455 camera_cli_s *pc = (camera_cli_s *)camera;
2456 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_IMAGE_QUALITY;
2458 if (pc->cb_info == NULL) {
2459 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2460 return CAMERA_ERROR_INVALID_PARAMETER;
2462 sock_fd = pc->cb_info->fd;
2464 LOGD("Enter, remote_handle : %x", pc->remote_handle);
2465 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2467 if (ret == CAMERA_ERROR_NONE) {
2468 muse_camera_msg_get(get_quality, pc->cb_info->recvMsg);
2469 *quality = get_quality;
2471 LOGD("ret : 0x%x", ret);
2476 int camera_attr_set_zoom(camera_h camera, int zoom)
2478 if( camera == NULL){
2479 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2480 return CAMERA_ERROR_INVALID_PARAMETER;
2482 int ret = CAMERA_ERROR_NONE;
2484 camera_cli_s *pc = (camera_cli_s *)camera;
2485 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_ZOOM;
2487 if (pc->cb_info == NULL) {
2488 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2489 return CAMERA_ERROR_INVALID_PARAMETER;
2491 sock_fd = pc->cb_info->fd;
2493 LOGD("Enter, remote_handle : %x", pc->remote_handle);
2494 muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, zoom);
2495 LOGD("ret : 0x%x", ret);
2499 int camera_attr_set_af_mode(camera_h camera, camera_attr_af_mode_e mode)
2501 if( camera == NULL){
2502 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2503 return CAMERA_ERROR_INVALID_PARAMETER;
2505 int ret = CAMERA_ERROR_NONE;
2507 camera_cli_s *pc = (camera_cli_s *)camera;
2508 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_AF_MODE;
2510 if (pc->cb_info == NULL) {
2511 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2512 return CAMERA_ERROR_INVALID_PARAMETER;
2514 sock_fd = pc->cb_info->fd;
2515 int set_mode = (int)mode;
2516 LOGD("Enter, remote_handle : %x", pc->remote_handle);
2517 muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_mode);
2518 LOGD("ret : 0x%x", ret);
2522 int camera_attr_set_af_area(camera_h camera, int x, int y)
2524 if( camera == NULL){
2525 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2526 return CAMERA_ERROR_INVALID_PARAMETER;
2528 int ret = CAMERA_ERROR_NONE;
2529 camera_cli_s *pc = (camera_cli_s *)camera;
2530 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_AF_AREA;
2531 int sock_fd = pc->cb_info->fd;
2532 LOGD("Enter, remote_handle : %x", pc->remote_handle);
2533 muse_camera_msg_send2(api, sock_fd, pc->cb_info, ret, INT, x, INT, y);
2534 LOGD("ret : 0x%x", ret);
2539 int camera_attr_clear_af_area(camera_h camera)
2541 if( camera == NULL){
2542 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2543 return CAMERA_ERROR_INVALID_PARAMETER;
2545 int ret = CAMERA_ERROR_NONE;
2547 camera_cli_s *pc = (camera_cli_s *)camera;
2548 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_CLEAR_AF_AREA;
2550 if (pc->cb_info == NULL) {
2551 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2552 return CAMERA_ERROR_INVALID_PARAMETER;
2554 sock_fd = pc->cb_info->fd;
2555 LOGD("Enter, remote_handle : %x", pc->remote_handle);
2556 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2557 LOGD("ret : 0x%x", ret);
2562 int camera_attr_set_exposure_mode(camera_h camera, camera_attr_exposure_mode_e mode)
2564 if( camera == NULL){
2565 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2566 return CAMERA_ERROR_INVALID_PARAMETER;
2569 if (mode < CAMERA_ATTR_EXPOSURE_MODE_OFF || mode > CAMERA_ATTR_EXPOSURE_MODE_CUSTOM) {
2570 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_NOT_SUPPORTED);
2571 return CAMERA_ERROR_NOT_SUPPORTED;
2574 int ret = CAMERA_ERROR_NONE;
2575 camera_cli_s *pc = (camera_cli_s *)camera;
2576 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_EXPOSURE_MODE;
2577 int set_mode = (int)mode;
2579 if (pc->cb_info == NULL) {
2580 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2581 return CAMERA_ERROR_INVALID_PARAMETER;
2583 sock_fd = pc->cb_info->fd;
2584 LOGD("Enter, remote_handle : %x", pc->remote_handle);
2585 muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_mode);
2586 LOGD("ret : 0x%x", ret);
2591 int camera_attr_set_exposure(camera_h camera, int value)
2593 if( camera == NULL){
2594 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2595 return CAMERA_ERROR_INVALID_PARAMETER;
2597 int ret = CAMERA_ERROR_NONE;
2599 camera_cli_s *pc = (camera_cli_s *)camera;
2600 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_EXPOSURE;
2602 if (pc->cb_info == NULL) {
2603 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2604 return CAMERA_ERROR_INVALID_PARAMETER;
2606 sock_fd = pc->cb_info->fd;
2608 LOGD("Enter, remote_handle : %x", pc->remote_handle);
2609 muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, value);
2610 LOGD("ret : 0x%x", ret);
2615 int camera_attr_set_iso(camera_h camera, camera_attr_iso_e iso)
2617 if( camera == NULL){
2618 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2619 return CAMERA_ERROR_INVALID_PARAMETER;
2621 int ret = CAMERA_ERROR_NONE;
2623 camera_cli_s *pc = (camera_cli_s *)camera;
2624 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_ISO;
2626 if (pc->cb_info == NULL) {
2627 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2628 return CAMERA_ERROR_INVALID_PARAMETER;
2630 sock_fd = pc->cb_info->fd;
2631 int set_iso = (int)iso;
2632 LOGD("Enter, remote_handle : %x", pc->remote_handle);
2633 muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_iso);
2634 LOGD("ret : 0x%x", ret);
2639 int camera_attr_set_brightness(camera_h camera, int level)
2641 if( camera == NULL){
2642 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2643 return CAMERA_ERROR_INVALID_PARAMETER;
2645 int ret = CAMERA_ERROR_NONE;
2647 camera_cli_s *pc = (camera_cli_s *)camera;
2648 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_BRIGHTNESS;
2650 if (pc->cb_info == NULL) {
2651 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2652 return CAMERA_ERROR_INVALID_PARAMETER;
2654 sock_fd = pc->cb_info->fd;
2656 LOGD("Enter, remote_handle : %x", pc->remote_handle);
2657 muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, level);
2658 LOGD("ret : 0x%x", ret);
2663 int camera_attr_set_contrast(camera_h camera, int level)
2665 if( camera == NULL){
2666 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2667 return CAMERA_ERROR_INVALID_PARAMETER;
2669 int ret = CAMERA_ERROR_NONE;
2671 camera_cli_s *pc = (camera_cli_s *)camera;
2672 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_CONTRAST;
2674 if (pc->cb_info == NULL) {
2675 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2676 return CAMERA_ERROR_INVALID_PARAMETER;
2678 sock_fd = pc->cb_info->fd;
2680 LOGD("Enter, remote_handle : %x", pc->remote_handle);
2681 muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, level);
2682 LOGD("ret : 0x%x", ret);
2687 int camera_attr_set_whitebalance(camera_h camera, camera_attr_whitebalance_e wb)
2689 if (camera == NULL) {
2690 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2691 return CAMERA_ERROR_INVALID_PARAMETER;
2694 if (wb < CAMERA_ATTR_WHITE_BALANCE_NONE || wb > CAMERA_ATTR_WHITE_BALANCE_CUSTOM) {
2695 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_NOT_SUPPORTED);
2696 return CAMERA_ERROR_NOT_SUPPORTED;
2699 int ret = CAMERA_ERROR_NONE;
2701 camera_cli_s *pc = (camera_cli_s *)camera;
2702 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_WHITEBALANCE;
2704 if (pc->cb_info == NULL) {
2705 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2706 return CAMERA_ERROR_INVALID_PARAMETER;
2708 sock_fd = pc->cb_info->fd;
2709 int set_whitebalance = (int)wb;
2710 LOGD("Enter, remote_handle : %x", pc->remote_handle);
2711 muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_whitebalance);
2712 LOGD("ret : 0x%x", ret);
2717 int camera_attr_set_effect(camera_h camera, camera_attr_effect_mode_e effect)
2719 if( camera == NULL){
2720 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2721 return CAMERA_ERROR_INVALID_PARAMETER;
2723 int ret = CAMERA_ERROR_NONE;
2725 camera_cli_s *pc = (camera_cli_s *)camera;
2726 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_EFFECT;
2728 if (pc->cb_info == NULL) {
2729 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2730 return CAMERA_ERROR_INVALID_PARAMETER;
2732 sock_fd = pc->cb_info->fd;
2733 int set_effect = (int)effect;
2734 LOGD("Enter, remote_handle : %x", pc->remote_handle);
2735 muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_effect);
2736 LOGD("ret : 0x%x", ret);
2741 int camera_attr_set_scene_mode(camera_h camera, camera_attr_scene_mode_e mode)
2743 if( camera == NULL){
2744 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2745 return CAMERA_ERROR_INVALID_PARAMETER;
2747 int ret = CAMERA_ERROR_NONE;
2749 camera_cli_s *pc = (camera_cli_s *)camera;
2750 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_SCENE_MODE;
2752 if (pc->cb_info == NULL) {
2753 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2754 return CAMERA_ERROR_INVALID_PARAMETER;
2756 sock_fd = pc->cb_info->fd;
2757 int set_mode = (int)mode;
2758 LOGD("Enter, remote_handle : %x", pc->remote_handle);
2759 muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_mode);
2760 LOGD("ret : 0x%x", ret);
2765 int camera_attr_enable_tag(camera_h camera, bool enable)
2767 if( camera == NULL){
2768 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2769 return CAMERA_ERROR_INVALID_PARAMETER;
2771 int ret = CAMERA_ERROR_NONE;
2772 camera_cli_s *pc = (camera_cli_s *)camera;
2773 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_ENABLE_TAG;
2775 if (pc->cb_info == NULL) {
2776 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2777 return CAMERA_ERROR_INVALID_PARAMETER;
2779 sock_fd = pc->cb_info->fd;
2780 int set_enable = (int)enable;
2782 LOGD("Enter, remote_handle : %x", pc->remote_handle);
2783 muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_enable);
2784 LOGD("ret : 0x%x", ret);
2789 int camera_attr_set_tag_image_description(camera_h camera, const char *description)
2791 if( camera == NULL){
2792 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2793 return CAMERA_ERROR_INVALID_PARAMETER;
2795 if( description == NULL){
2796 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2797 return CAMERA_ERROR_INVALID_PARAMETER;
2799 int ret = CAMERA_ERROR_NONE;
2800 camera_cli_s *pc = (camera_cli_s *)camera;
2801 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_TAG_IMAGE_DESCRIPTION;
2803 if (pc->cb_info == NULL) {
2804 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2805 return CAMERA_ERROR_INVALID_PARAMETER;
2807 sock_fd = pc->cb_info->fd;
2808 LOGD("Enter, remote_handle : %x", pc->remote_handle);
2809 muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, STRING, description);
2810 LOGD("ret : 0x%x", ret);
2815 int camera_attr_set_tag_orientation(camera_h camera, camera_attr_tag_orientation_e orientation)
2817 if( camera == NULL){
2818 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2819 return CAMERA_ERROR_INVALID_PARAMETER;
2821 int ret = CAMERA_ERROR_NONE;
2822 camera_cli_s *pc = (camera_cli_s *)camera;
2823 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_TAG_ORIENTATION;
2825 if (pc->cb_info == NULL) {
2826 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2827 return CAMERA_ERROR_INVALID_PARAMETER;
2829 sock_fd = pc->cb_info->fd;
2830 int set_orientation = (int)orientation;
2832 LOGD("Enter, remote_handle : %x", pc->remote_handle);
2833 muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_orientation);
2834 LOGD("ret : 0x%x", ret);
2839 int camera_attr_set_tag_software(camera_h camera, const char *software)
2841 if( camera == NULL){
2842 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2843 return CAMERA_ERROR_INVALID_PARAMETER;
2845 if( software == NULL){
2846 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2847 return CAMERA_ERROR_INVALID_PARAMETER;
2849 int ret = CAMERA_ERROR_NONE;
2850 camera_cli_s *pc = (camera_cli_s *)camera;
2851 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_TAG_SOFTWARE;
2853 if (pc->cb_info == NULL) {
2854 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2855 return CAMERA_ERROR_INVALID_PARAMETER;
2857 sock_fd = pc->cb_info->fd;
2858 LOGD("Enter, remote_handle : %x", pc->remote_handle);
2859 muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, STRING, software);
2860 LOGD("ret : 0x%x", ret);
2865 int camera_attr_set_geotag(camera_h camera, double latitude , double longitude, double altitude)
2867 if( camera == NULL){
2868 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2869 return CAMERA_ERROR_INVALID_PARAMETER;
2871 int ret = CAMERA_ERROR_NONE;
2872 camera_cli_s *pc = (camera_cli_s *)camera;
2873 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_GEOTAG;
2875 if (pc->cb_info == NULL) {
2876 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2877 return CAMERA_ERROR_INVALID_PARAMETER;
2879 sock_fd = pc->cb_info->fd;
2880 double set_geotag[3] = { latitude, longitude, altitude };
2882 LOGD("Enter, remote_handle : %x", pc->remote_handle);
2883 muse_camera_msg_send_array(api, sock_fd, pc->cb_info, ret,
2884 set_geotag, sizeof(set_geotag), sizeof(double));
2885 LOGD("ret : 0x%x", ret);
2890 int camera_attr_remove_geotag(camera_h camera)
2892 if( camera == NULL){
2893 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2894 return CAMERA_ERROR_INVALID_PARAMETER;
2896 int ret = CAMERA_ERROR_NONE;
2897 camera_cli_s *pc = (camera_cli_s *)camera;
2898 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_REMOVE_GEOTAG;
2900 if (pc->cb_info == NULL) {
2901 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2902 return CAMERA_ERROR_INVALID_PARAMETER;
2904 sock_fd = pc->cb_info->fd;
2905 LOGD("Enter, remote_handle : %x", pc->remote_handle);
2906 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2907 LOGD("ret : 0x%x", ret);
2912 int camera_attr_set_flash_mode(camera_h camera, camera_attr_flash_mode_e mode)
2914 if( camera == NULL){
2915 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2916 return CAMERA_ERROR_INVALID_PARAMETER;
2918 int ret = CAMERA_ERROR_NONE;
2919 camera_cli_s *pc = (camera_cli_s *)camera;
2920 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_FLASH_MODE;
2922 if (pc->cb_info == NULL) {
2923 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2924 return CAMERA_ERROR_INVALID_PARAMETER;
2926 sock_fd = pc->cb_info->fd;
2927 int set_mode = (int)mode;
2929 LOGD("Enter, remote_handle : %x", pc->remote_handle);
2930 muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_mode);
2931 LOGD("ret : 0x%x", ret);
2936 int camera_attr_get_zoom(camera_h camera, int *zoom)
2938 if( camera == NULL || zoom == NULL){
2939 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2940 return CAMERA_ERROR_INVALID_PARAMETER;
2942 int ret = CAMERA_ERROR_NONE;
2944 camera_cli_s *pc = (camera_cli_s *)camera;
2945 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_ZOOM;
2948 if (pc->cb_info == NULL) {
2949 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2950 return CAMERA_ERROR_INVALID_PARAMETER;
2952 sock_fd = pc->cb_info->fd;
2954 LOGD("Enter, remote_handle : %x", pc->remote_handle);
2955 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2957 if (ret == CAMERA_ERROR_NONE) {
2958 muse_camera_msg_get(get_zoom, pc->cb_info->recvMsg);
2961 LOGD("ret : 0x%x", ret);
2966 int camera_attr_get_zoom_range(camera_h camera, int *min, int *max)
2968 if( camera == NULL || min == NULL || max == NULL ){
2969 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2970 return CAMERA_ERROR_INVALID_PARAMETER;
2972 int ret = CAMERA_ERROR_NONE;
2973 camera_cli_s *pc = (camera_cli_s *)camera;
2975 if (pc->cb_info == NULL) {
2976 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2977 return CAMERA_ERROR_INVALID_PARAMETER;
2979 sock_fd = pc->cb_info->fd;
2980 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_ZOOM_RANGE;
2984 LOGD("Enter, remote_handle : %x", pc->remote_handle);
2985 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2987 if (ret == CAMERA_ERROR_NONE) {
2988 muse_camera_msg_get(get_min, pc->cb_info->recvMsg);
2989 muse_camera_msg_get(get_max, pc->cb_info->recvMsg);
2993 LOGD("ret : 0x%x", ret);
2998 int camera_attr_get_af_mode( camera_h camera, camera_attr_af_mode_e *mode)
3000 if( camera == NULL || mode == NULL){
3001 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3002 return CAMERA_ERROR_INVALID_PARAMETER;
3004 int ret = CAMERA_ERROR_NONE;
3005 camera_cli_s *pc = (camera_cli_s *)camera;
3007 if (pc->cb_info == NULL) {
3008 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3009 return CAMERA_ERROR_INVALID_PARAMETER;
3011 sock_fd = pc->cb_info->fd;
3012 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_AF_MODE;
3015 LOGD("Enter, remote_handle : %x", pc->remote_handle);
3016 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3018 if (ret == CAMERA_ERROR_NONE) {
3019 muse_camera_msg_get(get_mode, pc->cb_info->recvMsg);
3020 *mode = (camera_attr_af_mode_e)get_mode;
3022 LOGD("ret : 0x%x", ret);
3027 int camera_attr_get_exposure_mode( camera_h camera, camera_attr_exposure_mode_e *mode)
3029 if( camera == NULL|| mode == NULL){
3030 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3031 return CAMERA_ERROR_INVALID_PARAMETER;
3033 int ret = CAMERA_ERROR_NONE;
3034 camera_cli_s *pc = (camera_cli_s *)camera;
3036 if (pc->cb_info == NULL) {
3037 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3038 return CAMERA_ERROR_INVALID_PARAMETER;
3040 sock_fd = pc->cb_info->fd;
3041 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_EXPOSURE_MODE;
3044 LOGD("Enter, remote_handle : %x", pc->remote_handle);
3045 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3047 if (ret == CAMERA_ERROR_NONE) {
3048 muse_camera_msg_get(get_mode, pc->cb_info->recvMsg);
3049 *mode = (camera_attr_exposure_mode_e)get_mode;
3051 LOGD("ret : 0x%x", ret);
3055 int camera_attr_get_exposure(camera_h camera, int *value)
3057 if( camera == NULL || value == NULL){
3058 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3059 return CAMERA_ERROR_INVALID_PARAMETER;
3061 int ret = CAMERA_ERROR_NONE;
3062 camera_cli_s *pc = (camera_cli_s *)camera;
3064 if (pc->cb_info == NULL) {
3065 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3066 return CAMERA_ERROR_INVALID_PARAMETER;
3068 sock_fd = pc->cb_info->fd;
3069 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_EXPOSURE;
3072 LOGD("Enter, remote_handle : %x", pc->remote_handle);
3073 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3075 if (ret == CAMERA_ERROR_NONE) {
3076 muse_camera_msg_get(get_value, pc->cb_info->recvMsg);
3079 LOGD("ret : 0x%x", ret);
3084 int camera_attr_get_exposure_range(camera_h camera, int *min, int *max)
3086 if( camera == NULL || min == NULL || max == NULL ){
3087 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3088 return CAMERA_ERROR_INVALID_PARAMETER;
3090 int ret = CAMERA_ERROR_NONE;
3091 camera_cli_s *pc = (camera_cli_s *)camera;
3093 if (pc->cb_info == NULL) {
3094 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3095 return CAMERA_ERROR_INVALID_PARAMETER;
3097 sock_fd = pc->cb_info->fd;
3098 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_EXPOSURE_RANGE;
3102 LOGD("Enter, remote_handle : %x", pc->remote_handle);
3103 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3105 if (ret == CAMERA_ERROR_NONE) {
3106 muse_camera_msg_get(get_min, pc->cb_info->recvMsg);
3107 muse_camera_msg_get(get_max, pc->cb_info->recvMsg);
3111 LOGD("ret : 0x%x", ret);
3116 int camera_attr_get_iso( camera_h camera, camera_attr_iso_e *iso)
3118 if( camera == NULL || iso == NULL){
3119 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3120 return CAMERA_ERROR_INVALID_PARAMETER;
3122 int ret = CAMERA_ERROR_NONE;
3123 camera_cli_s *pc = (camera_cli_s *)camera;
3125 if (pc->cb_info == NULL) {
3126 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3127 return CAMERA_ERROR_INVALID_PARAMETER;
3129 sock_fd = pc->cb_info->fd;
3130 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_ISO;
3133 LOGD("Enter, remote_handle : %x", pc->remote_handle);
3134 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3136 if (ret == CAMERA_ERROR_NONE) {
3137 muse_camera_msg_get(get_iso, pc->cb_info->recvMsg);
3138 *iso = (camera_attr_iso_e)get_iso;
3140 LOGD("ret : 0x%x", ret);
3145 int camera_attr_get_brightness(camera_h camera, int *level)
3147 if( camera == NULL || level == NULL){
3148 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3149 return CAMERA_ERROR_INVALID_PARAMETER;
3151 int ret = CAMERA_ERROR_NONE;
3152 camera_cli_s *pc = (camera_cli_s *)camera;
3154 if (pc->cb_info == NULL) {
3155 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3156 return CAMERA_ERROR_INVALID_PARAMETER;
3158 sock_fd = pc->cb_info->fd;
3159 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_BRIGHTNESS;
3162 LOGD("Enter, remote_handle : %x", pc->remote_handle);
3163 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3165 if (ret == CAMERA_ERROR_NONE) {
3166 muse_camera_msg_get(get_level, pc->cb_info->recvMsg);
3169 LOGD("ret : 0x%x", ret);
3174 int camera_attr_get_brightness_range(camera_h camera, int *min, int *max)
3176 if( camera == NULL || min == NULL || max == NULL ){
3177 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3178 return CAMERA_ERROR_INVALID_PARAMETER;
3180 int ret = CAMERA_ERROR_NONE;
3181 camera_cli_s *pc = (camera_cli_s *)camera;
3183 if (pc->cb_info == NULL) {
3184 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3185 return CAMERA_ERROR_INVALID_PARAMETER;
3187 sock_fd = pc->cb_info->fd;
3188 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_BRIGHTNESS_RANGE;
3192 LOGD("Enter, remote_handle : %x", pc->remote_handle);
3193 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3195 if (ret == CAMERA_ERROR_NONE) {
3196 muse_camera_msg_get(get_min, pc->cb_info->recvMsg);
3197 muse_camera_msg_get(get_max, pc->cb_info->recvMsg);
3201 LOGD("ret : 0x%x", ret);
3206 int camera_attr_get_contrast(camera_h camera, int *level)
3208 if( camera == NULL || level == NULL){
3209 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3210 return CAMERA_ERROR_INVALID_PARAMETER;
3212 int ret = CAMERA_ERROR_NONE;
3213 camera_cli_s *pc = (camera_cli_s *)camera;
3214 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_CONTRAST;
3216 if (pc->cb_info == NULL) {
3217 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3218 return CAMERA_ERROR_INVALID_PARAMETER;
3220 sock_fd = pc->cb_info->fd;
3223 LOGD("Enter, remote_handle : %x", pc->remote_handle);
3224 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3226 if (ret == CAMERA_ERROR_NONE) {
3227 muse_camera_msg_get(get_level, pc->cb_info->recvMsg);
3230 LOGD("ret : 0x%x", ret);
3235 int camera_attr_get_contrast_range(camera_h camera, int *min , int *max)
3237 if( camera == NULL || min == NULL || max == NULL ){
3238 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3239 return CAMERA_ERROR_INVALID_PARAMETER;
3241 int ret = CAMERA_ERROR_NONE;
3242 camera_cli_s *pc = (camera_cli_s *)camera;
3243 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_CONTRAST_RANGE;
3245 if (pc->cb_info == NULL) {
3246 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3247 return CAMERA_ERROR_INVALID_PARAMETER;
3249 sock_fd = pc->cb_info->fd;
3253 LOGD("Enter, remote_handle : %x", pc->remote_handle);
3254 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3256 if (ret == CAMERA_ERROR_NONE) {
3257 muse_camera_msg_get(get_min, pc->cb_info->recvMsg);
3258 muse_camera_msg_get(get_max, pc->cb_info->recvMsg);
3262 LOGD("ret : 0x%x", ret);
3267 int camera_attr_get_whitebalance(camera_h camera, camera_attr_whitebalance_e *wb)
3269 if( camera == NULL || wb == NULL){
3270 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3271 return CAMERA_ERROR_INVALID_PARAMETER;
3273 int ret = CAMERA_ERROR_NONE;
3274 camera_cli_s *pc = (camera_cli_s *)camera;
3275 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_WHITEBALANCE;
3277 if (pc->cb_info == NULL) {
3278 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3279 return CAMERA_ERROR_INVALID_PARAMETER;
3281 sock_fd = pc->cb_info->fd;
3284 LOGD("Enter, remote_handle : %x", pc->remote_handle);
3285 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3287 if (ret == CAMERA_ERROR_NONE) {
3288 muse_camera_msg_get(get_wb, pc->cb_info->recvMsg);
3289 *wb = (camera_attr_whitebalance_e)get_wb;
3291 LOGD("ret : 0x%x", ret);
3296 int camera_attr_get_effect(camera_h camera, camera_attr_effect_mode_e *effect)
3298 if( camera == NULL || effect == NULL ){
3299 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3300 return CAMERA_ERROR_INVALID_PARAMETER;
3303 int ret = CAMERA_ERROR_NONE;
3304 camera_cli_s *pc = (camera_cli_s *)camera;
3305 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_EFFECT;
3307 if (pc->cb_info == NULL) {
3308 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3309 return CAMERA_ERROR_INVALID_PARAMETER;
3311 sock_fd = pc->cb_info->fd;
3314 LOGD("Enter, remote_handle : %x", pc->remote_handle);
3315 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3317 if (ret == CAMERA_ERROR_NONE) {
3318 muse_camera_msg_get(get_effect, pc->cb_info->recvMsg);
3319 *effect = (camera_attr_effect_mode_e)get_effect;
3321 LOGD("ret : 0x%x", ret);
3326 int camera_attr_get_scene_mode(camera_h camera, camera_attr_scene_mode_e *mode)
3328 if( camera == NULL || mode == NULL){
3329 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3330 return CAMERA_ERROR_INVALID_PARAMETER;
3333 int ret = CAMERA_ERROR_NONE;
3334 camera_cli_s *pc = (camera_cli_s *)camera;
3335 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_SCENE_MODE;
3337 if (pc->cb_info == NULL) {
3338 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3339 return CAMERA_ERROR_INVALID_PARAMETER;
3341 sock_fd = pc->cb_info->fd;
3344 LOGD("Enter, remote_handle : %x", pc->remote_handle);
3345 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3347 if (ret == CAMERA_ERROR_NONE) {
3348 muse_camera_msg_get(get_mode, pc->cb_info->recvMsg);
3349 *mode = (camera_attr_scene_mode_e)get_mode;
3351 LOGD("ret : 0x%x", ret);
3356 int camera_attr_is_enabled_tag(camera_h camera, bool *enable)
3358 if( camera == NULL || enable == NULL){
3359 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3360 return CAMERA_ERROR_INVALID_PARAMETER;
3363 int ret = CAMERA_ERROR_NONE;
3364 camera_cli_s *pc = (camera_cli_s *)camera;
3365 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_ENABLED_TAG;
3367 if (pc->cb_info == NULL) {
3368 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3369 return CAMERA_ERROR_INVALID_PARAMETER;
3371 sock_fd = pc->cb_info->fd;
3374 LOGD("Enter, remote_handle : %x", pc->remote_handle);
3375 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3377 if (ret == CAMERA_ERROR_NONE) {
3378 muse_camera_msg_get(get_enable, pc->cb_info->recvMsg);
3379 *enable = (bool)get_enable;
3381 LOGD("ret : 0x%x", ret);
3386 int camera_attr_get_tag_image_description(camera_h camera, char **description)
3388 if( camera == NULL || description == NULL){
3389 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3390 return CAMERA_ERROR_INVALID_PARAMETER;
3393 int ret = CAMERA_ERROR_NONE;
3394 camera_cli_s *pc = (camera_cli_s *)camera;
3395 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_TAG_IMAGE_DESCRIPTION;
3397 if (pc->cb_info == NULL) {
3398 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3399 return CAMERA_ERROR_INVALID_PARAMETER;
3401 sock_fd = pc->cb_info->fd;
3402 char get_description[MUSE_CAMERA_MSG_MAX_LENGTH] = {0,};
3404 LOGD("Enter, remote_handle : %x", pc->remote_handle);
3405 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3407 if (ret == CAMERA_ERROR_NONE) {
3408 muse_camera_msg_get_string(get_description, pc->cb_info->recvMsg);
3409 *description = strdup(get_description);
3411 LOGD("ret : 0x%x", ret);
3416 int camera_attr_get_tag_orientation(camera_h camera, camera_attr_tag_orientation_e *orientation)
3418 if( camera == NULL || orientation == NULL){
3419 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3420 return CAMERA_ERROR_INVALID_PARAMETER;
3423 int ret = CAMERA_ERROR_NONE;
3424 camera_cli_s *pc = (camera_cli_s *)camera;
3425 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_TAG_ORIENTATION;
3427 if (pc->cb_info == NULL) {
3428 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3429 return CAMERA_ERROR_INVALID_PARAMETER;
3431 sock_fd = pc->cb_info->fd;
3432 int get_orientation;
3434 LOGD("Enter, remote_handle : %x", pc->remote_handle);
3435 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3437 if (ret == CAMERA_ERROR_NONE) {
3438 muse_camera_msg_get(get_orientation, pc->cb_info->recvMsg);
3439 *orientation = (camera_attr_tag_orientation_e)get_orientation;
3440 LOGD("success, orientation : %d", *orientation);
3442 LOGD("ret : 0x%x", ret);
3447 int camera_attr_get_tag_software(camera_h camera, char **software)
3449 if( camera == NULL || software == NULL ){
3450 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3451 return CAMERA_ERROR_INVALID_PARAMETER;
3454 int ret = CAMERA_ERROR_NONE;
3455 camera_cli_s *pc = (camera_cli_s *)camera;
3456 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_TAG_SOFTWARE;
3458 if (pc->cb_info == NULL) {
3459 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3460 return CAMERA_ERROR_INVALID_PARAMETER;
3462 sock_fd = pc->cb_info->fd;
3463 char get_software[MUSE_CAMERA_MSG_MAX_LENGTH] = {0,};
3465 LOGD("Enter, remote_handle : %x", pc->remote_handle);
3466 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3468 if (ret == CAMERA_ERROR_NONE) {
3469 muse_camera_msg_get_string(get_software, pc->cb_info->recvMsg);
3470 *software = strdup(get_software);
3472 LOGD("ret : 0x%x", ret);
3477 int camera_attr_get_geotag(camera_h camera, double *latitude , double *longitude, double *altitude)
3479 if( camera == NULL || latitude == NULL || longitude == NULL || altitude == NULL){
3480 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3481 return CAMERA_ERROR_INVALID_PARAMETER;
3484 int ret = CAMERA_ERROR_NONE;
3485 camera_cli_s *pc = (camera_cli_s *)camera;
3486 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_GEOTAG;
3487 double get_geotag[3] = {0,};
3489 if (pc->cb_info == NULL) {
3490 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3491 return CAMERA_ERROR_INVALID_PARAMETER;
3493 sock_fd = pc->cb_info->fd;
3495 LOGD("Enter, remote_handle : %x", pc->remote_handle);
3496 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3498 if (ret == CAMERA_ERROR_NONE) {
3499 muse_camera_msg_get_array(get_geotag, pc->cb_info->recvMsg);
3500 *latitude = get_geotag[0];
3501 *longitude = get_geotag[1];
3502 *altitude = get_geotag[2];
3504 LOGE("Returned value is not valid : 0x%x", valid);
3509 LOGD("ret : 0x%x", ret);
3514 int camera_attr_get_flash_mode(camera_h camera, camera_attr_flash_mode_e *mode)
3516 if( camera == NULL || mode == NULL){
3517 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3518 return CAMERA_ERROR_INVALID_PARAMETER;
3521 int ret = CAMERA_ERROR_NONE;
3522 camera_cli_s *pc = (camera_cli_s *)camera;
3523 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_FLASH_MODE;
3525 if (pc->cb_info == NULL) {
3526 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3527 return CAMERA_ERROR_INVALID_PARAMETER;
3529 sock_fd = pc->cb_info->fd;
3532 LOGD("Enter, remote_handle : %x", pc->remote_handle);
3533 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3535 if (ret == CAMERA_ERROR_NONE) {
3536 muse_camera_msg_get(get_mode, pc->cb_info->recvMsg);
3537 *mode = (camera_attr_flash_mode_e)get_mode;
3539 LOGD("ret : 0x%x", ret);
3544 int camera_attr_foreach_supported_af_mode( camera_h camera, camera_attr_supported_af_mode_cb foreach_cb , void *user_data)
3546 if( camera == NULL || foreach_cb == NULL){
3547 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3548 return CAMERA_ERROR_INVALID_PARAMETER;
3550 int ret = CAMERA_ERROR_NONE;
3552 camera_cli_s *pc = (camera_cli_s *)camera;
3553 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_AF_MODE;
3555 LOGD("Enter, handle :%x", pc->remote_handle);
3558 if (pc->cb_info == NULL) {
3559 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3560 return CAMERA_ERROR_INVALID_PARAMETER;
3562 sock_fd = pc->cb_info->fd;
3563 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_AF_MODE] = foreach_cb;
3564 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_AF_MODE] = user_data;
3566 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3567 LOGD("ret : 0x%x", ret);
3572 int camera_attr_foreach_supported_exposure_mode(camera_h camera, camera_attr_supported_exposure_mode_cb foreach_cb , void *user_data)
3574 if( camera == NULL || foreach_cb == NULL){
3575 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3576 return CAMERA_ERROR_INVALID_PARAMETER;
3578 int ret = CAMERA_ERROR_NONE;
3580 camera_cli_s *pc = (camera_cli_s *)camera;
3581 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_EXPOSURE_MODE;
3583 LOGD("Enter, handle :%x", pc->remote_handle);
3586 if (pc->cb_info == NULL) {
3587 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3588 return CAMERA_ERROR_INVALID_PARAMETER;
3590 sock_fd = pc->cb_info->fd;
3591 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EXPOSURE_MODE] = foreach_cb;
3592 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EXPOSURE_MODE] = user_data;
3594 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3595 LOGD("ret : 0x%x", ret);
3600 int camera_attr_foreach_supported_iso( camera_h camera, camera_attr_supported_iso_cb foreach_cb , void *user_data)
3602 if( camera == NULL || foreach_cb == NULL){
3603 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3604 return CAMERA_ERROR_INVALID_PARAMETER;
3606 int ret = CAMERA_ERROR_NONE;
3608 camera_cli_s *pc = (camera_cli_s *)camera;
3609 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_ISO;
3611 LOGD("Enter, handle :%x", pc->remote_handle);
3614 if (pc->cb_info == NULL) {
3615 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3616 return CAMERA_ERROR_INVALID_PARAMETER;
3618 sock_fd = pc->cb_info->fd;
3619 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_ISO] = foreach_cb;
3620 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_ISO] = user_data;
3622 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3623 LOGD("ret : 0x%x", ret);
3628 int camera_attr_foreach_supported_whitebalance(camera_h camera, camera_attr_supported_whitebalance_cb foreach_cb , void *user_data)
3630 if( camera == NULL || foreach_cb == NULL){
3631 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3632 return CAMERA_ERROR_INVALID_PARAMETER;
3634 int ret = CAMERA_ERROR_NONE;
3636 camera_cli_s *pc = (camera_cli_s *)camera;
3637 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_WHITEBALANCE;
3639 LOGD("Enter, handle :%x", pc->remote_handle);
3642 if (pc->cb_info == NULL) {
3643 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3644 return CAMERA_ERROR_INVALID_PARAMETER;
3646 sock_fd = pc->cb_info->fd;
3647 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_WHITEBALANCE] = foreach_cb;
3648 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_WHITEBALANCE] = user_data;
3650 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3651 LOGD("ret : 0x%x", ret);
3656 int camera_attr_foreach_supported_effect(camera_h camera, camera_attr_supported_effect_cb foreach_cb , void *user_data)
3658 if( camera == NULL || foreach_cb == NULL){
3659 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3660 return CAMERA_ERROR_INVALID_PARAMETER;
3662 int ret = CAMERA_ERROR_NONE;
3664 camera_cli_s *pc = (camera_cli_s *)camera;
3665 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_EFFECT;
3667 LOGD("Enter, handle :%x", pc->remote_handle);
3670 if (pc->cb_info == NULL) {
3671 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3672 return CAMERA_ERROR_INVALID_PARAMETER;
3674 sock_fd = pc->cb_info->fd;
3675 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EFFECT] = foreach_cb;
3676 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EFFECT] = user_data;
3678 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3679 LOGD("ret : 0x%x", ret);
3684 int camera_attr_foreach_supported_scene_mode(camera_h camera, camera_attr_supported_scene_mode_cb foreach_cb , void *user_data)
3686 if( camera == NULL || foreach_cb == NULL){
3687 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3688 return CAMERA_ERROR_INVALID_PARAMETER;
3690 int ret = CAMERA_ERROR_NONE;
3692 camera_cli_s *pc = (camera_cli_s *)camera;
3693 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_SCENE_MODE;
3695 LOGD("Enter, handle :%x", pc->remote_handle);
3698 if (pc->cb_info == NULL) {
3699 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3700 return CAMERA_ERROR_INVALID_PARAMETER;
3702 sock_fd = pc->cb_info->fd;
3703 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_SCENE_MODE] = foreach_cb;
3704 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_SCENE_MODE] = user_data;
3706 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3707 LOGD("ret : 0x%x", ret);
3712 int camera_attr_foreach_supported_flash_mode(camera_h camera, camera_attr_supported_flash_mode_cb foreach_cb , void *user_data)
3714 if( camera == NULL || foreach_cb == NULL){
3715 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3716 return CAMERA_ERROR_INVALID_PARAMETER;
3718 int ret = CAMERA_ERROR_NONE;
3720 camera_cli_s *pc = (camera_cli_s *)camera;
3721 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_FLASH_MODE;
3723 LOGD("Enter, handle :%x", pc->remote_handle);
3726 if (pc->cb_info == NULL) {
3727 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3728 return CAMERA_ERROR_INVALID_PARAMETER;
3730 sock_fd = pc->cb_info->fd;
3731 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FLASH_MODE] = foreach_cb;
3732 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FLASH_MODE] = user_data;
3734 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3735 LOGD("ret : 0x%x", ret);
3740 int camera_attr_foreach_supported_fps(camera_h camera, camera_attr_supported_fps_cb foreach_cb , void *user_data)
3742 if( camera == NULL || foreach_cb == NULL){
3743 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3744 return CAMERA_ERROR_INVALID_PARAMETER;
3746 int ret = CAMERA_ERROR_NONE;
3748 camera_cli_s *pc = (camera_cli_s *)camera;
3749 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_FPS;
3751 if (pc->cb_info == NULL) {
3752 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3753 return CAMERA_ERROR_INVALID_PARAMETER;
3755 sock_fd = pc->cb_info->fd;
3756 LOGD("Enter, handle :%x", pc->remote_handle);
3757 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS] = foreach_cb;
3758 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS] = user_data;
3760 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3761 LOGD("Enter, handle :%x", pc->remote_handle);
3765 int camera_attr_foreach_supported_fps_by_resolution(camera_h camera, int width, int height, camera_attr_supported_fps_cb foreach_cb, void *user_data)
3767 if( camera == NULL || foreach_cb == NULL){
3768 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3769 return CAMERA_ERROR_INVALID_PARAMETER;
3771 int ret = CAMERA_ERROR_NONE;
3773 camera_cli_s *pc = (camera_cli_s *)camera;
3774 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_FPS_BY_RESOLUTION;
3776 if (pc->cb_info == NULL) {
3777 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3778 return CAMERA_ERROR_INVALID_PARAMETER;
3780 sock_fd = pc->cb_info->fd;
3781 LOGD("Enter, handle :%x", pc->remote_handle);
3782 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS_BY_RESOLUTION] = foreach_cb;
3783 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS_BY_RESOLUTION] = user_data;
3785 muse_camera_msg_send2(api, sock_fd, pc->cb_info, ret, INT, width, INT, height);
3786 LOGD("ret : 0x%x", ret);
3790 int camera_attr_foreach_supported_stream_flip(camera_h camera, camera_attr_supported_stream_flip_cb foreach_cb, void *user_data)
3792 if( camera == NULL || foreach_cb == NULL){
3793 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3794 return CAMERA_ERROR_INVALID_PARAMETER;
3796 int ret = CAMERA_ERROR_NONE;
3798 camera_cli_s *pc = (camera_cli_s *)camera;
3799 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_STREAM_FLIP;
3801 if (pc->cb_info == NULL) {
3802 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3803 return CAMERA_ERROR_INVALID_PARAMETER;
3805 sock_fd = pc->cb_info->fd;
3806 LOGD("Enter, handle :%x", pc->remote_handle);
3807 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_FLIP] = foreach_cb;
3808 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_FLIP] = user_data;
3810 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3811 LOGD("ret : 0x%x", ret);
3816 int camera_attr_foreach_supported_stream_rotation(camera_h camera, camera_attr_supported_stream_rotation_cb foreach_cb, void *user_data)
3818 if( camera == NULL || foreach_cb == NULL){
3819 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3820 return CAMERA_ERROR_INVALID_PARAMETER;
3822 int ret = CAMERA_ERROR_NONE;
3824 camera_cli_s *pc = (camera_cli_s *)camera;
3825 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_STREAM_ROTATION;
3827 if (pc->cb_info == NULL) {
3828 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3829 return CAMERA_ERROR_INVALID_PARAMETER;
3831 sock_fd = pc->cb_info->fd;
3832 LOGD("Enter, handle :%x", pc->remote_handle);
3833 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_ROTATION] = foreach_cb;
3834 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_ROTATION] = user_data;
3836 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3837 LOGD("ret : 0x%x", ret);
3842 int camera_attr_set_stream_rotation(camera_h camera , camera_rotation_e rotation)
3844 if( camera == NULL){
3845 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3846 return CAMERA_ERROR_INVALID_PARAMETER;
3849 int ret = CAMERA_ERROR_NONE;
3850 camera_cli_s *pc = (camera_cli_s *)camera;
3851 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_STREAM_ROTATION;
3853 if (pc->cb_info == NULL) {
3854 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3855 return CAMERA_ERROR_INVALID_PARAMETER;
3857 sock_fd = pc->cb_info->fd;
3858 int set_rotation = (int)rotation;
3860 LOGD("Enter, remote_handle : %x", pc->remote_handle);
3861 muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_rotation);
3862 LOGD("ret : 0x%x", ret);
3867 int camera_attr_get_stream_rotation(camera_h camera , camera_rotation_e *rotation)
3869 if( camera == NULL || rotation == NULL ){
3870 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3871 return CAMERA_ERROR_INVALID_PARAMETER;
3874 int ret = CAMERA_ERROR_NONE;
3875 camera_cli_s *pc = (camera_cli_s *)camera;
3876 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_STREAM_ROTATION;
3878 if (pc->cb_info == NULL) {
3879 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3880 return CAMERA_ERROR_INVALID_PARAMETER;
3882 sock_fd = pc->cb_info->fd;
3885 LOGD("Enter, remote_handle : %x", pc->remote_handle);
3886 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3888 if (ret == CAMERA_ERROR_NONE) {
3889 muse_camera_msg_get(get_rotation, pc->cb_info->recvMsg);
3890 *rotation = (camera_rotation_e)get_rotation;
3892 LOGD("ret : 0x%x", ret);
3897 int camera_attr_set_stream_flip(camera_h camera , camera_flip_e flip)
3899 if( camera == NULL){
3900 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3901 return CAMERA_ERROR_INVALID_PARAMETER;
3904 int ret = CAMERA_ERROR_NONE;
3905 camera_cli_s *pc = (camera_cli_s *)camera;
3906 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_STREAM_FLIP;
3908 if (pc->cb_info == NULL) {
3909 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3910 return CAMERA_ERROR_INVALID_PARAMETER;
3912 sock_fd = pc->cb_info->fd;
3913 int set_flip = (int)flip;
3915 LOGD("Enter, remote_handle : %x", pc->remote_handle);
3916 muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_flip);
3917 LOGD("ret : 0x%x", ret);
3922 int camera_attr_get_stream_flip(camera_h camera , camera_flip_e *flip)
3924 if( camera == NULL || flip == NULL ){
3925 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3926 return CAMERA_ERROR_INVALID_PARAMETER;
3929 int ret = CAMERA_ERROR_NONE;
3930 camera_cli_s *pc = (camera_cli_s *)camera;
3931 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_STREAM_FLIP;
3933 if (pc->cb_info == NULL) {
3934 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3935 return CAMERA_ERROR_INVALID_PARAMETER;
3937 sock_fd = pc->cb_info->fd;
3940 LOGD("Enter, remote_handle : %x", pc->remote_handle);
3941 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3943 if (ret == CAMERA_ERROR_NONE) {
3944 muse_camera_msg_get(get_flip, pc->cb_info->recvMsg);
3945 *flip = (camera_flip_e)get_flip;
3947 LOGD("ret : 0x%x", ret);
3951 int camera_attr_set_hdr_mode(camera_h camera, camera_attr_hdr_mode_e mode)
3953 if( camera == NULL){
3954 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3955 return CAMERA_ERROR_INVALID_PARAMETER;
3958 int ret = CAMERA_ERROR_NONE;
3959 camera_cli_s *pc = (camera_cli_s *)camera;
3960 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_HDR_MODE;
3962 if (pc->cb_info == NULL) {
3963 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3964 return CAMERA_ERROR_INVALID_PARAMETER;
3966 sock_fd = pc->cb_info->fd;
3967 int set_mode = (int)mode;
3969 LOGD("Enter, remote_handle : %x", pc->remote_handle);
3970 muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_mode);
3971 LOGD("ret : 0x%x", ret);
3976 int camera_attr_get_hdr_mode(camera_h camera, camera_attr_hdr_mode_e *mode)
3978 if (camera == NULL) {
3979 LOGE("INVALID_PARAMETER(0x%08x) - handle",CAMERA_ERROR_INVALID_PARAMETER);
3980 return CAMERA_ERROR_INVALID_PARAMETER;
3983 LOGE("CAMERA_ERROR_NOT_SUPPORTED(0x%08x) - mode",CAMERA_ERROR_NOT_SUPPORTED);
3984 return CAMERA_ERROR_NOT_SUPPORTED;
3986 int ret = CAMERA_ERROR_NONE;
3987 camera_cli_s *pc = (camera_cli_s *)camera;
3988 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_HDR_MODE;
3990 if (pc->cb_info == NULL) {
3991 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3992 return CAMERA_ERROR_INVALID_PARAMETER;
3994 sock_fd = pc->cb_info->fd;
3997 LOGD("Enter, remote_handle : %x", pc->remote_handle);
3998 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4000 if (ret == CAMERA_ERROR_NONE) {
4001 muse_camera_msg_get(get_mode, pc->cb_info->recvMsg);
4002 *mode = (camera_attr_hdr_mode_e)get_mode;
4004 LOGD("ret : 0x%x", ret);
4009 bool camera_attr_is_supported_hdr_capture(camera_h camera)
4011 if( camera == NULL){
4012 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4016 int ret = CAMERA_ERROR_NONE;
4017 camera_cli_s *pc = (camera_cli_s *)camera;
4018 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_SUPPORTED_HDR_CAPTURE;
4020 if (pc->cb_info == NULL) {
4021 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4022 return CAMERA_ERROR_INVALID_PARAMETER;
4024 sock_fd = pc->cb_info->fd;
4025 LOGD("Enter, remote_handle : %x", pc->remote_handle);
4026 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4027 LOGD("ret : 0x%x", ret);
4032 int camera_attr_set_hdr_capture_progress_cb(camera_h camera, camera_attr_hdr_progress_cb callback, void* user_data)
4034 if (camera == NULL) {
4035 LOGE("INVALID_PARAMETER(0x%08x) - handle", CAMERA_ERROR_INVALID_PARAMETER);
4036 return CAMERA_ERROR_INVALID_PARAMETER;
4038 if (callback == NULL) {
4039 LOGE("CAMERA_ERROR_NOT_SUPPORTED(0x%08x) - callback", CAMERA_ERROR_NOT_SUPPORTED);
4040 return CAMERA_ERROR_NOT_SUPPORTED;
4042 int ret = CAMERA_ERROR_NONE;
4044 camera_cli_s *pc = (camera_cli_s *)camera;
4045 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_HDR_CAPTURE_PROGRESS_CB;
4047 if (pc->cb_info == NULL) {
4048 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4049 return CAMERA_ERROR_INVALID_PARAMETER;
4051 sock_fd = pc->cb_info->fd;
4052 LOGD("Enter, handle :%x", pc->remote_handle);
4054 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_HDR_PROGRESS] = callback;
4055 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_HDR_PROGRESS] = user_data;
4057 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4058 LOGD("ret : 0x%x", ret);
4063 int camera_attr_unset_hdr_capture_progress_cb(camera_h camera)
4065 if( camera == NULL){
4066 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4067 return CAMERA_ERROR_INVALID_PARAMETER;
4070 int ret = CAMERA_ERROR_NONE;
4072 camera_cli_s *pc = (camera_cli_s *)camera;
4073 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_UNSET_HDR_CAPTURE_PROGRESS_CB;
4075 if (pc->cb_info == NULL) {
4076 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4077 return CAMERA_ERROR_INVALID_PARAMETER;
4079 sock_fd = pc->cb_info->fd;
4080 LOGD("Enter, handle :%x", pc->remote_handle);
4082 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_HDR_PROGRESS] = (void *)NULL;
4083 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_HDR_PROGRESS] = (void *)NULL;
4085 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4086 LOGD("ret : 0x%x", ret);
4091 int camera_attr_enable_anti_shake(camera_h camera, bool enable)
4093 if (camera == NULL) {
4094 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4095 return CAMERA_ERROR_INVALID_PARAMETER;
4098 int ret = CAMERA_ERROR_NONE;
4099 camera_cli_s *pc = (camera_cli_s *)camera;
4100 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_ENABLE_ANTI_SHAKE;
4102 if (pc->cb_info == NULL) {
4103 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4104 return CAMERA_ERROR_INVALID_PARAMETER;
4106 sock_fd = pc->cb_info->fd;
4107 int set_enable = (int)enable;
4109 LOGD("Enter, remote_handle : %x", pc->remote_handle);
4110 muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_enable);
4111 LOGD("ret : 0x%x", ret);
4116 int camera_attr_is_enabled_anti_shake(camera_h camera , bool *enabled)
4118 if (camera == NULL) {
4119 LOGE("INVALID_PARAMETER(0x%08x) - handle", CAMERA_ERROR_INVALID_PARAMETER);
4120 return CAMERA_ERROR_INVALID_PARAMETER;
4122 if (enabled == NULL) {
4123 LOGE("INVALID_PARAMETER(0x%08x) - enabled", CAMERA_ERROR_INVALID_PARAMETER);
4124 return CAMERA_ERROR_NOT_SUPPORTED;
4126 int ret = CAMERA_ERROR_NONE;
4127 camera_cli_s *pc = (camera_cli_s *)camera;
4128 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_ENABLED_ANTI_SHAKE;
4130 if (pc->cb_info == NULL) {
4131 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4132 return CAMERA_ERROR_INVALID_PARAMETER;
4134 sock_fd = pc->cb_info->fd;
4137 LOGD("Enter, remote_handle : %x", pc->remote_handle);
4138 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4140 if (ret == CAMERA_ERROR_NONE) {
4141 muse_camera_msg_get(get_enabled, pc->cb_info->recvMsg);
4142 *enabled = (bool)get_enabled;
4144 LOGD("ret : 0x%x", ret);
4149 bool camera_attr_is_supported_anti_shake(camera_h camera)
4152 if( camera == NULL){
4153 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4157 int ret = CAMERA_ERROR_NONE;
4158 camera_cli_s *pc = (camera_cli_s *)camera;
4159 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_SUPPORTED_ANTI_SHAKE;
4161 if (pc->cb_info == NULL) {
4162 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4163 return CAMERA_ERROR_INVALID_PARAMETER;
4165 sock_fd = pc->cb_info->fd;
4166 LOGD("Enter, remote_handle : %x", pc->remote_handle);
4167 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4168 LOGD("ret : 0x%x", ret);
4173 int camera_attr_enable_video_stabilization(camera_h camera, bool enable)
4175 if (camera == NULL) {
4176 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4177 return CAMERA_ERROR_INVALID_PARAMETER;
4180 int ret = CAMERA_ERROR_NONE;
4181 camera_cli_s *pc = (camera_cli_s *)camera;
4182 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_ENABLE_VIDEO_STABILIZATION;
4184 if (pc->cb_info == NULL) {
4185 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4186 return CAMERA_ERROR_INVALID_PARAMETER;
4188 sock_fd = pc->cb_info->fd;
4189 int set_enable = (int)enable;
4191 LOGD("Enter, remote_handle : %x", pc->remote_handle);
4192 muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_enable);
4193 LOGD("ret : 0x%x", ret);
4198 int camera_attr_is_enabled_video_stabilization(camera_h camera, bool *enabled)
4200 if (camera == NULL) {
4201 LOGE("INVALID_PARAMETER(0x%08x) - handle",CAMERA_ERROR_INVALID_PARAMETER);
4202 return CAMERA_ERROR_INVALID_PARAMETER;
4204 if (enabled == NULL) {
4205 LOGE("INVALID_PARAMETER(0x%08x) - enabled",CAMERA_ERROR_INVALID_PARAMETER);
4206 return CAMERA_ERROR_NOT_SUPPORTED;
4208 int ret = CAMERA_ERROR_NONE;
4209 camera_cli_s *pc = (camera_cli_s *)camera;
4210 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_ENABLED_VIDEO_STABILIZATION;
4212 if (pc->cb_info == NULL) {
4213 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4214 return CAMERA_ERROR_INVALID_PARAMETER;
4216 sock_fd = pc->cb_info->fd;
4219 LOGD("Enter, remote_handle : %x", pc->remote_handle);
4220 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4222 if (ret == CAMERA_ERROR_NONE) {
4223 muse_camera_msg_get(get_enabled, pc->cb_info->recvMsg);
4224 *enabled = (bool)get_enabled;
4226 LOGD("ret : 0x%x", ret);
4231 bool camera_attr_is_supported_video_stabilization(camera_h camera)
4233 if( camera == NULL){
4234 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4238 int ret = CAMERA_ERROR_NONE;
4239 camera_cli_s *pc = (camera_cli_s *)camera;
4240 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_SUPPORTED_VIDEO_STABILIZATION;
4242 if (pc->cb_info == NULL) {
4243 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4244 return CAMERA_ERROR_INVALID_PARAMETER;
4246 sock_fd = pc->cb_info->fd;
4247 LOGD("Enter, remote_handle : %x", pc->remote_handle);
4248 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4249 LOGD("ret : 0x%x", ret);
4254 int camera_attr_enable_auto_contrast(camera_h camera, bool enable)
4256 if( camera == NULL){
4257 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4258 return CAMERA_ERROR_INVALID_PARAMETER;
4261 int ret = CAMERA_ERROR_NONE;
4262 camera_cli_s *pc = (camera_cli_s *)camera;
4263 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_ENABLE_AUTO_CONTRAST;
4265 if (pc->cb_info == NULL) {
4266 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4267 return CAMERA_ERROR_INVALID_PARAMETER;
4269 sock_fd = pc->cb_info->fd;
4270 int set_enable = (int)enable;
4272 LOGD("Enter, remote_handle : %x", pc->remote_handle);
4273 muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_enable);
4274 LOGD("ret : 0x%x", ret);
4279 int camera_attr_is_enabled_auto_contrast(camera_h camera, bool *enabled)
4281 if (camera == NULL) {
4282 LOGE("INVALID_PARAMETER(0x%08x) - handle", CAMERA_ERROR_INVALID_PARAMETER);
4283 return CAMERA_ERROR_INVALID_PARAMETER;
4285 if (enabled == NULL) {
4286 LOGE("INVALID_PARAMETER(0x%08x) - enabled", CAMERA_ERROR_INVALID_PARAMETER);
4287 return CAMERA_ERROR_INVALID_PARAMETER;
4289 int ret = CAMERA_ERROR_NONE;
4290 camera_cli_s *pc = (camera_cli_s *)camera;
4291 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_ENABLED_AUTO_CONTRAST;
4293 if (pc->cb_info == NULL) {
4294 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4295 return CAMERA_ERROR_INVALID_PARAMETER;
4297 sock_fd = pc->cb_info->fd;
4300 LOGD("Enter, remote_handle : %x", pc->remote_handle);
4301 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4303 if (ret == CAMERA_ERROR_NONE) {
4304 muse_camera_msg_get(get_enabled, pc->cb_info->recvMsg);
4305 *enabled = (bool)get_enabled;
4307 LOGD("ret : 0x%x", ret);
4312 bool camera_attr_is_supported_auto_contrast(camera_h camera)
4314 if( camera == NULL){
4315 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4319 int ret = CAMERA_ERROR_NONE;
4320 camera_cli_s *pc = (camera_cli_s *)camera;
4321 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_SUPPORTED_AUTO_CONTRAST;
4323 if (pc->cb_info == NULL) {
4324 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4325 return CAMERA_ERROR_INVALID_PARAMETER;
4327 sock_fd = pc->cb_info->fd;
4328 LOGD("Enter, remote_handle : %x", pc->remote_handle);
4329 muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4330 LOGD("ret : 0x%x", ret);
4335 int camera_attr_disable_shutter_sound(camera_h camera, bool disable)
4337 if (camera == NULL) {
4338 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4339 return CAMERA_ERROR_INVALID_PARAMETER;
4342 int ret = CAMERA_ERROR_NONE;
4343 camera_cli_s *pc = (camera_cli_s *)camera;
4344 muse_camera_api_e api = MUSE_CAMERA_API_ATTR_DISABLE_SHUTTER_SOUND;
4346 if (pc->cb_info == NULL) {
4347 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4348 return CAMERA_ERROR_INVALID_PARAMETER;
4350 sock_fd = pc->cb_info->fd;
4351 int set_disable = (int)disable;
4353 LOGD("Enter, remote_handle : %x", pc->remote_handle);
4354 muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_disable);
4355 LOGD("ret : 0x%x", ret);