src/camera.c

   1 /*
   2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3 *
   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
   7 *
   8 * http://www.apache.org/licenses/LICENSE-2.0
   9 *
  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.
  15 */
  16
  17
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <mm.h>
  22 #include <mm_types.h>
  23 #include <camera.h>
  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>
  29 //#include <glib.h>
  30 #include <dlog.h>
  31 #include <Elementary.h>
  32 #include <mm_camcorder_client.h>
  33 #include <Evas.h>
  34 #ifdef HAVE_WAYLAND
  35 #include <Ecore_Wayland.h>
  36 #else
  37 #include <Ecore.h>
  38 #endif
  39
  40 #ifdef LOG_TAG
  41 #undef LOG_TAG
  42 #endif
  43 #define LOG_TAG "TIZEN_N_CAMERA_CLIENT"
  44
  45
  46 static int _import_tbm_key(tbm_bufmgr bufmgr, unsigned int tbm_key, tbm_bo *bo, tbm_bo_handle *bo_handle)
  47 {
  48         tbm_bo tmp_bo = NULL;
  49         tbm_bo_handle tmp_bo_handle = {NULL, };
  50
  51         if (bufmgr == NULL || bo == NULL || bo_handle == NULL || tbm_key == 0) {
  52                 LOGE("invalid parameter - bufmgr %p, bo %p, bo_handle %p, key %d",
  53                      bufmgr, bo, bo_handle, tbm_key);
  54                 return false;
  55         }
  56
  57         tmp_bo = tbm_bo_import(bufmgr, tbm_key);
  58         if (tmp_bo == NULL) {
  59                 LOGE("bo import failed - bufmgr %p, key %d", bufmgr, tbm_key);
  60                 return false;
  61         }
  62
  63         tmp_bo_handle = tbm_bo_map(tmp_bo, TBM_DEVICE_CPU, TBM_OPTION_READ);
  64         if (tmp_bo_handle.ptr == NULL) {
  65                 LOGE("bo map failed %p", tmp_bo);
  66                 tbm_bo_unref(tmp_bo);
  67                 tmp_bo = NULL;
  68                 return false;
  69         }
  70
  71         /* set bo and bo_handle */
  72         *bo = tmp_bo;
  73         *bo_handle = tmp_bo_handle;
  74
  75         return true;
  76 }
  77
  78 static void _release_imported_bo(tbm_bo *bo)
  79 {
  80         if (bo == NULL || *bo == NULL) {
  81                 LOGE("NULL bo");
  82                 return;
  83         }
  84
  85         tbm_bo_unmap(*bo);
  86         tbm_bo_unref(*bo);
  87         *bo = NULL;
  88
  89         return;
  90 }
  91
  92 static int client_wait_for_cb_return(muse_camera_api_e api, callback_cb_info_s *cb_info, int time_out)
  93 {
  94         int ret = CAMERA_ERROR_NONE;
  95         gint64 end_time;
  96
  97         LOGD("Enter api : %d", api);
  98         g_mutex_lock(&(cb_info->pMutex[api]));
  99
 100         if (cb_info->activating[api] == 0) {
 101                 end_time = g_get_monotonic_time() + time_out * G_TIME_SPAN_SECOND;
 102                 if (g_cond_wait_until(&(cb_info->pCond[api]), &(cb_info->pMutex[api]), end_time)) {
 103                         LOGD("cb_info->recvApiMsg : %s", cb_info->recvApiMsg);
 104                         if (!muse_camera_msg_get(ret, cb_info->recvApiMsg)) {
 105                                 LOGE("Get cb msg failed.");
 106                                 ret = CAMERA_ERROR_INVALID_OPERATION;
 107                         } else {
 108                                 LOGD("Wait passed, ret : 0x%x", ret);
 109                         }
 110                         if (cb_info->activating[api])
 111                                 cb_info->activating[api] = 0;
 112                 } else {
 113                         LOGD("api %d was TIMED OUT!", api);
 114                         ret = CAMERA_ERROR_INVALID_OPERATION;
 115                 }
 116         } else {
 117                 LOGE("condition is already checked for the api : %d.", api);
 118                 if (!muse_camera_msg_get(ret, cb_info->recvApiMsg)) {
 119                         LOGE("Get cb msg failed.");
 120                         ret = CAMERA_ERROR_INVALID_OPERATION;
 121                 } else {
 122                         LOGD("Already checked condition, Wait passed, ret : 0x%x", ret);
 123                 }
 124         }
 125         g_mutex_unlock(&(cb_info->pMutex[api]));
 126         LOGD("ret : 0x%x", ret);
 127         return ret;
 128 }
 129
 130 static void _client_user_callback(callback_cb_info_s *cb_info, char *recvMsg, muse_camera_event_e event)
 131 {
 132         int param1 = 0;
 133         int param2 = 0;
 134         int tbm_key = 0;
 135         tbm_bo bo = NULL;
 136         tbm_bo_handle bo_handle = {NULL, };
 137
 138         if (recvMsg == NULL || event >= MUSE_CAMERA_EVENT_TYPE_NUM) {
 139                 LOGE("invalid parameter - msg %p, event %d", recvMsg, event);
 140                 return;
 141         }
 142
 143         LOGD("get msg %s, event %d", recvMsg, event);
 144
 145         if (cb_info->user_cb[event] == NULL) {
 146                 LOGW("user callback for event %d is not set", event);
 147                 return;
 148         }
 149
 150         switch (event) {
 151         case MUSE_CAMERA_EVENT_TYPE_STATE_CHANGE:
 152                 {
 153                         int previous = 0;
 154                         int current = 0;
 155                         int by_policy = 0;
 156
 157                         muse_camera_msg_get(previous, recvMsg);
 158                         muse_camera_msg_get(current, recvMsg);
 159                         muse_camera_msg_get(by_policy, recvMsg);
 160
 161                         LOGD("STATE CHANGE - previous %d, current %d, by_policy %d",
 162                              previous, current, by_policy);
 163
 164                         ((camera_state_changed_cb)cb_info->user_cb[event])((camera_state_e)previous,
 165                                                                            (camera_state_e)current,
 166                                                                            (bool)by_policy,
 167                                                                            cb_info->user_data[event]);
 168                 }
 169                 break;
 170         case MUSE_CAMERA_EVENT_TYPE_FOCUS_CHANGE:
 171                 {
 172                         int state = 0;
 173
 174                         muse_camera_msg_get(state, recvMsg);
 175
 176                         LOGD("FOCUS state - %d", state);
 177
 178                         ((camera_focus_changed_cb)cb_info->user_cb[event])((camera_focus_state_e)state,
 179                                                                            cb_info->user_data[event]);
 180                 }
 181                 break;
 182         case MUSE_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE:
 183                 LOGD("CAPTURE_COMPLETED");
 184                 ((camera_capture_completed_cb)cb_info->user_cb[event])(cb_info->user_data[event]);
 185                 break;
 186         case MUSE_CAMERA_EVENT_TYPE_PREVIEW:
 187                 {
 188                         unsigned char *buf_pos = NULL;
 189                         camera_preview_data_s *frame = NULL;
 190                         int total_size = 0;
 191
 192                         muse_camera_msg_get(tbm_key, recvMsg);
 193
 194                         if (tbm_key <= 0) {
 195                                 LOGE("invalid key %d", tbm_key);
 196                                 break;
 197                         }
 198
 199                         /* import tbm bo and get virtual address */
 200                         if (!_import_tbm_key(cb_info->bufmgr, tbm_key, &bo, &bo_handle)) {
 201                                 break;
 202                         }
 203
 204                         buf_pos = (unsigned char *)bo_handle.ptr;
 205
 206                         frame = (camera_preview_data_s *)buf_pos;
 207                         buf_pos += sizeof(camera_preview_data_s);
 208
 209                         switch (frame->num_of_planes) {
 210                         case 1:
 211                                 frame->data.single_plane.yuv = buf_pos;
 212                                 total_size = frame->data.single_plane.size;
 213                         case 2:
 214                                 frame->data.double_plane.y = buf_pos;
 215                                 buf_pos += frame->data.double_plane.y_size;
 216                                 frame->data.double_plane.uv = buf_pos;
 217                                 total_size = frame->data.double_plane.y_size + \
 218                                              frame->data.double_plane.uv_size;
 219                         case 3:
 220                                 frame->data.triple_plane.y = buf_pos;
 221                                 buf_pos += frame->data.triple_plane.y_size;
 222                                 frame->data.triple_plane.u = buf_pos;
 223                                 buf_pos += frame->data.triple_plane.u_size;
 224                                 frame->data.triple_plane.v = buf_pos;
 225                                 total_size = frame->data.triple_plane.y_size + \
 226                                              frame->data.triple_plane.u_size + \
 227                                              frame->data.triple_plane.v_size;
 228                         default:
 229                                 break;
 230                         }
 231
 232                         LOGD("PREVIEW_CB - format %d, %dx%d, size %d plane num %d",
 233                              frame->format, frame->width, frame->height, total_size, frame->num_of_planes);
 234
 235                         ((camera_preview_cb)cb_info->user_cb[event])(frame, cb_info->user_data[event]);
 236
 237                         LOGD("PREVIEW_CB retuned");
 238
 239                         /* unmap and unref tbm bo */
 240                         _release_imported_bo(&bo);
 241
 242                         /* return buffer */
 243                         muse_camera_msg_send1_no_return(MUSE_CAMERA_API_RETURN_BUFFER,
 244                                                         cb_info->fd, cb_info,
 245                                                         INT, tbm_key);
 246
 247                         LOGD("return buffer Done");
 248                 }
 249                 break;
 250         case MUSE_CAMERA_EVENT_TYPE_MEDIA_PACKET_PREVIEW:
 251                 ((camera_media_packet_preview_cb)cb_info->user_cb[event])(NULL, cb_info->user_data[event]);
 252                 break;
 253         case MUSE_CAMERA_EVENT_TYPE_HDR_PROGRESS:
 254                 {
 255                         int percent = 0;
 256
 257                         muse_camera_msg_get(percent, recvMsg);
 258
 259                         LOGD("HDR progress - %d \%", percent);
 260
 261                         ((camera_attr_hdr_progress_cb)cb_info->user_cb[event])(percent, cb_info->user_data[event]);
 262                 }
 263                 break;
 264         case MUSE_CAMERA_EVENT_TYPE_INTERRUPTED:
 265                 {
 266                         int policy = 0;
 267                         int previous = 0;
 268                         int current = 0;
 269
 270                         muse_camera_msg_get(policy, recvMsg);
 271                         muse_camera_msg_get(previous, recvMsg);
 272                         muse_camera_msg_get(current, recvMsg);
 273
 274                         LOGD("INTERRUPTED - policy %d, state previous %d, current %d",
 275                              policy, previous, current);
 276
 277                         ((camera_interrupted_cb)cb_info->user_cb[event])((camera_policy_e)policy,
 278                                                                          (camera_state_e)previous,
 279                                                                          (camera_state_e)current,
 280                                                                          cb_info->user_data[event]);
 281                 }
 282                 break;
 283         case MUSE_CAMERA_EVENT_TYPE_FACE_DETECTION:
 284                 {
 285                         int count = 0;
 286                         camera_detected_face_s *faces = NULL;
 287
 288                         muse_camera_msg_get(count, recvMsg);
 289                         muse_camera_msg_get(tbm_key, recvMsg);
 290
 291                         if (count > 0 && tbm_key > 0) {
 292                                 LOGD("FACE_DETECTION - count %d, tbm_key %d", count, tbm_key);
 293
 294                                 if (!_import_tbm_key(cb_info->bufmgr, tbm_key, &bo, &bo_handle)) {
 295                                         break;
 296                                 }
 297
 298                                 /* set face info */
 299                                 faces = bo_handle.ptr;
 300
 301                                 ((camera_face_detected_cb)cb_info->user_cb[event])(faces, count, cb_info->user_data[event]);
 302
 303 #if 0
 304                                 {
 305                                         int i = 0;
 306
 307                                         for (i = 0 ; i < count ; i++) {
 308                                                 LOGD("id[%2d] - score %d, position (%d,%d,%dx%d)",
 309                                                      i, faces[i].score, faces[i].x, faces[i].y, faces[i].width, faces[i].height);
 310                                         }
 311                                 }
 312 #endif
 313
 314                                 /* release bo */
 315                                 _release_imported_bo(&bo);
 316
 317                                 /* return buffer */
 318                                 muse_camera_msg_send1_no_return(MUSE_CAMERA_API_RETURN_BUFFER,
 319                                                                 cb_info->fd, cb_info,
 320                                                                 INT, tbm_key);
 321
 322                                 LOGD("return buffer done");
 323                         } else {
 324                                 LOGE("invalid message - count %d, key %d", count, tbm_key);
 325                         }
 326                 }
 327                 break;
 328         case MUSE_CAMERA_EVENT_TYPE_ERROR:
 329                 {
 330                         int error = 0;
 331                         int current_state = 0;
 332
 333                         muse_camera_msg_get(error, recvMsg);
 334                         muse_camera_msg_get(current_state, recvMsg);
 335
 336                         LOGE("ERROR - error 0x%x, current_state %d", error, current_state);
 337
 338                         ((camera_error_cb)cb_info->user_cb[event])((camera_error_e)error,
 339                                                                    (camera_state_e)current_state,
 340                                                                    cb_info->user_data[event]);
 341                 }
 342                 break;
 343         case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_RESOLUTION:
 344                 muse_camera_msg_get(param1, recvMsg);
 345                 muse_camera_msg_get(param2, recvMsg);
 346
 347                 LOGD("SUPPORTED_PREVIEW_RESOLUTION - %d x %d", param1, param2);
 348
 349                 ((camera_supported_preview_resolution_cb)cb_info->user_cb[event])(param1, param2, cb_info->user_data[event]);
 350                 break;
 351         case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_RESOLUTION:
 352                 muse_camera_msg_get(param1, recvMsg);
 353                 muse_camera_msg_get(param2, recvMsg);
 354
 355                 LOGD("SUPPORTED_CAPTURE_RESOLUTION - %d x %d", param1, param2);
 356
 357                 ((camera_supported_capture_resolution_cb)cb_info->user_cb[event])(param1, param2, cb_info->user_data[event]);
 358                 break;
 359         case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_FORMAT:
 360                 muse_camera_msg_get(param1, recvMsg);
 361
 362                 LOGD("SUPPORTED_CAPTURE_FORMAT - %d ", param1);
 363
 364                 ((camera_supported_capture_format_cb)cb_info->user_cb[event])((camera_pixel_format_e)param1, cb_info->user_data[event]);
 365                 break;
 366         case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_FORMAT:
 367                 muse_camera_msg_get(param1, recvMsg);
 368
 369                 LOGD("SUPPORTED_PREVIEW_FORMAT - %d ", param1);
 370
 371                 ((camera_supported_preview_format_cb)cb_info->user_cb[event])((camera_pixel_format_e)param1, cb_info->user_data[event]);
 372                 break;
 373         case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_AF_MODE:
 374                 muse_camera_msg_get(param1, recvMsg);
 375
 376                 LOGD("SUPPORTED_AF_MODE - %d ", param1);
 377
 378                 ((camera_attr_supported_af_mode_cb)cb_info->user_cb[event])((camera_attr_af_mode_e)param1, cb_info->user_data[event]);
 379                 break;
 380         case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EXPOSURE_MODE:
 381                 muse_camera_msg_get(param1, recvMsg);
 382
 383                 LOGD("SUPPORTED_EXPOSURE_MODE - %d ", param1);
 384
 385                 ((camera_attr_supported_exposure_mode_cb)cb_info->user_cb[event])((camera_attr_exposure_mode_e)param1, cb_info->user_data[event]);
 386                 break;
 387         case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_ISO:
 388                 muse_camera_msg_get(param1, recvMsg);
 389
 390                 LOGD("SUPPORTED_ISO - %d ", param1);
 391
 392                 ((camera_attr_supported_iso_cb)cb_info->user_cb[event])((camera_attr_iso_e)param1, cb_info->user_data[event]);
 393                 break;
 394         case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_WHITEBALANCE:
 395                 muse_camera_msg_get(param1, recvMsg);
 396
 397                 LOGD("SUPPORTED_WHITEBALANCE - %d ", param1);
 398
 399                 ((camera_attr_supported_whitebalance_cb)cb_info->user_cb[event])((camera_attr_whitebalance_e)param1, cb_info->user_data[event]);
 400                 break;
 401         case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EFFECT:
 402                 muse_camera_msg_get(param1, recvMsg);
 403
 404                 LOGD("SUPPORTED_EFFECT - %d ", param1);
 405
 406                 ((camera_attr_supported_effect_cb)cb_info->user_cb[event])((camera_attr_effect_mode_e)param1, cb_info->user_data[event]);
 407                 break;
 408         case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_SCENE_MODE:
 409                 muse_camera_msg_get(param1, recvMsg);
 410
 411                 LOGD("SUPPORTED_SCENE_MODE - %d ", param1);
 412
 413                 ((camera_attr_supported_scene_mode_cb)cb_info->user_cb[event])((camera_attr_scene_mode_e)param1, cb_info->user_data[event]);
 414                 break;
 415         case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FLASH_MODE:
 416                 muse_camera_msg_get(param1, recvMsg);
 417
 418                 LOGD("SUPPORTED_FLASH_MODE - %d ", param1);
 419
 420                 ((camera_attr_supported_flash_mode_cb)cb_info->user_cb[event])((camera_attr_flash_mode_e)param1, cb_info->user_data[event]);
 421                 break;
 422         case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS:
 423                 muse_camera_msg_get(param1, recvMsg);
 424
 425                 LOGD("SUPPORTED_FPS - %d ", param1);
 426
 427                 ((camera_attr_supported_fps_cb)cb_info->user_cb[event])((camera_attr_fps_e)param1, cb_info->user_data[event]);
 428                 break;
 429         case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS_BY_RESOLUTION:
 430                 muse_camera_msg_get(param1, recvMsg);
 431
 432                 LOGD("SUPPORTED_FPS_BY_RESOLUTION - %d ", param1);
 433
 434                 ((camera_attr_supported_fps_cb)cb_info->user_cb[event])((camera_attr_fps_e)param1, cb_info->user_data[event]);
 435                 break;
 436         case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_FLIP:
 437                 muse_camera_msg_get(param1, recvMsg);
 438
 439                 LOGD("SUPPORTED_STREAM_FLIP - %d ", param1);
 440
 441                 ((camera_attr_supported_stream_flip_cb)cb_info->user_cb[event])((camera_flip_e)param1, cb_info->user_data[event]);
 442                 break;
 443         case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_ROTATION:
 444                 muse_camera_msg_get(param1, recvMsg);
 445
 446                 LOGD("SUPPORTED_STREAM_ROTATION - %d ", param1);
 447
 448                 ((camera_attr_supported_stream_rotation_cb)cb_info->user_cb[event])((camera_rotation_e)param1, cb_info->user_data[event]);
 449                 break;
 450         case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_THEATER_MODE:
 451                 muse_camera_msg_get(param1, recvMsg);
 452
 453                 LOGD("SUPPORTED_THEATER_MODE - %d ", param1);
 454
 455                 ((camera_attr_supported_theater_mode_cb)cb_info->user_cb[event])((camera_attr_theater_mode_e)param1, cb_info->user_data[event]);
 456                 break;
 457         case MUSE_CAMERA_EVENT_TYPE_CAPTURE:
 458                 {
 459                         camera_image_data_s *rImage = NULL;
 460                         camera_image_data_s *rPostview = NULL;
 461                         camera_image_data_s *rThumbnail = NULL;
 462                         unsigned char *buf_pos = NULL;
 463                         int is_postview = 0;
 464                         int is_thumbnail = 0;
 465
 466                         muse_camera_msg_get(tbm_key, recvMsg);
 467                         muse_camera_msg_get(is_postview, recvMsg);
 468                         muse_camera_msg_get(is_thumbnail, recvMsg);
 469
 470                         LOGD("camera capture callback came in. key %d, postview %d, thumbnail %d",
 471                              tbm_key, is_postview, is_thumbnail);
 472
 473                         if (tbm_key <= 0) {
 474                                 LOGE("invalid key %d", tbm_key);
 475                                 break;
 476                         }
 477
 478                         /* import tbm bo and get virtual address */
 479                         if (!_import_tbm_key(cb_info->bufmgr, tbm_key, &bo, &bo_handle)) {
 480                                 break;
 481                         }
 482
 483                         buf_pos = (unsigned char *)bo_handle.ptr;
 484                         rImage = (camera_image_data_s *)buf_pos;
 485                         rImage->data = buf_pos + sizeof(camera_image_data_s);
 486                         buf_pos += sizeof(camera_image_data_s) + rImage->size;
 487
 488                         if (is_postview) {
 489                                 rPostview = (camera_image_data_s *)buf_pos;
 490                                 LOGD("rPostview->size : %d", rPostview->size);
 491                                 rPostview->data = buf_pos + sizeof(camera_image_data_s);
 492                                 buf_pos += sizeof(camera_image_data_s) + rPostview->size;
 493                         }
 494
 495                         if (is_thumbnail) {
 496                                 rThumbnail = (camera_image_data_s *)buf_pos;
 497                                 LOGD("rThumbnail->size : %d", rThumbnail->size);
 498                                 rThumbnail->data = buf_pos + sizeof(camera_image_data_s);
 499                                 buf_pos += sizeof(camera_image_data_s) + rThumbnail->size;
 500                         }
 501
 502                         LOGD("image info %dx%d, size : %d", rImage->height, rImage->width, rImage->size);
 503
 504                         ((camera_capturing_cb)cb_info->user_cb[event])(rImage, rPostview, rThumbnail, cb_info->user_data[event]);
 505
 506                         /* unmap and unref tbm bo */
 507                         _release_imported_bo(&bo);
 508
 509                         /* return buffer */
 510                         muse_camera_msg_send1_no_return(MUSE_CAMERA_API_RETURN_BUFFER,
 511                                                         cb_info->fd,
 512                                                         cb_info,
 513                                                         INT, tbm_key);
 514
 515                         LOGD("return buffer done");
 516                 }
 517                 break;
 518         case MUSE_CAMERA_EVENT_TYPE_VIDEO_FRAME_RENDER_ERROR:
 519                 break;
 520         default:
 521                 LOGW("Unknown event : %d", event);
 522                 break;
 523         }
 524
 525         return;
 526 }
 527
 528 static void *_event_handler(gpointer data)
 529 {
 530         event_info_s *e_info = NULL;
 531         callback_cb_info_s *cb_info = (callback_cb_info_s *)data;
 532
 533         if (cb_info == NULL) {
 534                 LOGE("cb_info NULL");
 535                 return NULL;
 536         }
 537
 538         LOGD("start");
 539
 540         g_mutex_lock(&cb_info->event_mutex);
 541
 542         while (g_atomic_int_get(&cb_info->event_thread_running)) {
 543                 if (g_queue_is_empty(cb_info->event_queue)) {
 544                         LOGD("signal wait...");
 545                         g_cond_wait(&cb_info->event_cond, &cb_info->event_mutex);
 546                         LOGD("signal received");
 547
 548                         if (g_atomic_int_get(&cb_info->event_thread_running) == 0) {
 549                                 LOGD("stop event thread");
 550                                 break;
 551                         }
 552                 }
 553
 554                 e_info = (event_info_s *)g_queue_pop_head(cb_info->event_queue);
 555
 556                 g_mutex_unlock(&cb_info->event_mutex);
 557
 558                 if (e_info) {
 559                         _client_user_callback(e_info->cb_info, e_info->recvMsg, e_info->event);
 560                         free(e_info);
 561                         e_info = NULL;
 562                 } else {
 563                         LOGW("NULL event info");
 564                 }
 565
 566                 g_mutex_lock(&cb_info->event_mutex);
 567         }
 568
 569         /* remove remained event */
 570         while (!g_queue_is_empty(cb_info->event_queue)) {
 571                 e_info = (event_info_s *)g_queue_pop_head(cb_info->event_queue);
 572                 if (e_info) {
 573                         LOGD("remove event info %p", e_info);
 574                         free(e_info);
 575                         e_info = NULL;
 576                 } else {
 577                         LOGW("NULL event info");
 578                 }
 579         }
 580
 581         g_mutex_unlock(&cb_info->event_mutex);
 582
 583         LOGD("return");
 584
 585         return NULL;
 586 }
 587
 588 static bool _camera_idle_event_callback(void *data)
 589 {
 590         event_info_s *e_info = (event_info_s *)data;
 591
 592         if (e_info == NULL) {
 593                 LOGE("event info is NULL");
 594                 return false;
 595         }
 596
 597         _client_user_callback(e_info->cb_info, e_info->recvMsg, e_info->event);
 598         free(e_info);
 599         e_info = NULL;
 600
 601         return false;
 602 }
 603
 604 static void *client_cb_handler(gpointer data)
 605 {
 606         int ret = 0;
 607         int api = 0;
 608         int num_token = 0;
 609         int i = 0;
 610         int str_pos = 0;
 611         int prev_pos = 0;
 612         callback_cb_info_s *cb_info = (callback_cb_info_s *)data;
 613         char *recvMsg = NULL;
 614         char **parseStr = NULL;
 615
 616         if (cb_info == NULL) {
 617                 LOGE("cb_info NULL");
 618                 return NULL;
 619         }
 620
 621         LOGD("start");
 622
 623         parseStr = (char **)malloc(sizeof(char *) * CAMERA_PARSE_STRING_SIZE);
 624         if (parseStr == NULL) {
 625                 LOGE("parseStr malloc failed");
 626                 return NULL;
 627         }
 628
 629         for (i = 0 ; i < CAMERA_PARSE_STRING_SIZE ; i++) {
 630                 parseStr[i] = (char *)malloc(sizeof(char) * MUSE_CAMERA_MSG_MAX_LENGTH);
 631                 if (parseStr[i] == NULL) {
 632                         LOGE("parseStr[%d] malloc failed", i);
 633                         goto CB_HANDLER_EXIT;
 634                 }
 635         }
 636
 637         recvMsg = cb_info->recvMsg;
 638
 639         while (g_atomic_int_get(&cb_info->rcv_thread_running)) {
 640                 ret = muse_core_ipc_recv_msg(cb_info->fd, recvMsg);
 641                 if (ret <= 0)
 642                         break;
 643                 recvMsg[ret] = '\0';
 644
 645                 str_pos = 0;
 646                 prev_pos = 0;
 647                 num_token = 0;
 648
 649                 LOGD("recvMSg : %s, length : %d", recvMsg, ret);
 650
 651                 /* Need to split the combined entering msgs.
 652                     This module supports up to 200 combined msgs. */
 653                 for (str_pos = 0; str_pos < ret; str_pos++) {
 654                         if(recvMsg[str_pos] == '}') {
 655                                 memset(parseStr[num_token], 0x0, sizeof(char) * MUSE_CAMERA_MSG_MAX_LENGTH);
 656                                 strncpy(parseStr[num_token], recvMsg + prev_pos, str_pos - prev_pos + 1);
 657                                 LOGD("splitted msg : [%s], Index : %d", parseStr[num_token], num_token);
 658                                 prev_pos = str_pos+1;
 659                                 num_token++;
 660                         }
 661                 }
 662
 663                 LOGD("num_token : %d", num_token);
 664
 665                 /* Re-construct to the useful single msg. */
 666                 for (i = 0; i < num_token; i++) {
 667
 668                         if (i >= CAMERA_PARSE_STRING_SIZE)
 669                                 break;
 670
 671                         if (muse_camera_msg_get(api, parseStr[i])) {
 672                                 if(api < MUSE_CAMERA_API_MAX){
 673                                         LOGD("Set Condition - api %d", api);
 674                                         g_mutex_lock(&(cb_info->pMutex[api]));
 675
 676                                         /* The api msgs should be distinguished from the event msg. */
 677                                         memset(cb_info->recvApiMsg, 0, strlen(cb_info->recvApiMsg));
 678                                         strcpy(cb_info->recvApiMsg, parseStr[i]);
 679                                         LOGD("cb_info->recvApiMsg : [%s]", cb_info->recvApiMsg);
 680                                         cb_info->activating[api] = 1;
 681                                         g_cond_signal(&(cb_info->pCond[api]));
 682                                         g_mutex_unlock(&(cb_info->pMutex[api]));
 683
 684                                         if (api == MUSE_CAMERA_API_CREATE) {
 685                                                 if (muse_camera_msg_get(ret, cb_info->recvApiMsg)) {
 686                                                         if (ret != CAMERA_ERROR_NONE) {
 687                                                                 g_atomic_int_set(&cb_info->rcv_thread_running, 0);
 688                                                                 LOGE("camera create error 0x%x. close client cb handler", ret);
 689                                                         }
 690                                                 } else {
 691                                                         LOGE("failed to get api return");
 692                                                 }
 693                                         } else if (api == MUSE_CAMERA_API_DESTROY) {
 694                                                 if (muse_camera_msg_get(ret, cb_info->recvApiMsg)) {
 695                                                         if (ret == CAMERA_ERROR_NONE) {
 696                                                                 g_atomic_int_set(&cb_info->rcv_thread_running, 0);
 697                                                                 LOGD("camera destroy done. close client cb handler");
 698                                                         }
 699                                                 } else {
 700                                                         LOGE("failed to get api return");
 701                                                 }
 702                                         }
 703                                 } else if(api == MUSE_CAMERA_CB_EVENT) {
 704                                         int event = -1;
 705                                         int class = -1;
 706
 707                                         if (muse_camera_msg_get(event, parseStr[i]) &&
 708                                             muse_camera_msg_get(class, parseStr[i])) {
 709                                                 event_info_s *e_info = NULL;
 710
 711                                                 if (class == MUSE_CAMERA_EVENT_CLASS_NORMAL ||
 712                                                     class == MUSE_CAMERA_EVENT_CLASS_IDLE) {
 713                                                         e_info = (event_info_s *)malloc(sizeof(event_info_s));
 714                                                         if (e_info) {
 715                                                                 e_info->event = event;
 716                                                                 e_info->cb_info = cb_info;
 717                                                                 memcpy(e_info->recvMsg, recvMsg, sizeof(e_info->recvMsg));
 718
 719                                                                 if (class == MUSE_CAMERA_EVENT_CLASS_NORMAL) {
 720                                                                         LOGD("add event to EVENT QUEUE : %d", event);
 721                                                                         g_mutex_lock(&cb_info->event_mutex);
 722                                                                         g_queue_push_tail(cb_info->event_queue, (gpointer)e_info);
 723                                                                         g_cond_signal(&cb_info->event_cond);
 724                                                                         g_mutex_unlock(&cb_info->event_mutex);
 725                                                                 } else {
 726                                                                         LOGD("add event to IDLE : %d", event);
 727                                                                         g_idle_add_full(G_PRIORITY_DEFAULT, (GSourceFunc)_camera_idle_event_callback, (gpointer)e_info, NULL);
 728                                                                 }
 729                                                         } else {
 730                                                                 LOGE("e_info alloc failed");
 731                                                         }
 732                                                 } else if (class == MUSE_CAMERA_EVENT_CLASS_IMMEDIATE) {
 733                                                         _client_user_callback(cb_info, recvMsg, event);
 734                                                 } else {
 735                                                         LOGE("unknown class %d", class);
 736                                                 }
 737                                         }
 738                                 } else {
 739                                         LOGW("unknown api : %d", api);
 740                                 }
 741                         }else{
 742                                 LOGE("Get Msg Failed");
 743                         }
 744                 }
 745
 746         }
 747
 748         LOGD("client cb exit");
 749
 750 CB_HANDLER_EXIT:
 751         if (parseStr) {
 752                 for (i = 0 ; i < CAMERA_PARSE_STRING_SIZE ; i++) {
 753                         if (parseStr[i]) {
 754                                 free(parseStr[i]);
 755                                 parseStr[i] = NULL;
 756                         }
 757                 }
 758
 759                 free(parseStr);
 760                 parseStr = NULL;
 761         }
 762
 763         return NULL;
 764 }
 765
 766 static callback_cb_info_s *client_callback_new(gint sockfd)
 767 {
 768         callback_cb_info_s *cb_info;
 769         GCond *camera_cond;
 770         GMutex *camera_mutex;
 771         gint *camera_activ;
 772         g_return_val_if_fail(sockfd > 0, NULL);
 773
 774         cb_info = g_new0(callback_cb_info_s, 1);
 775         camera_cond = g_new0(GCond, MUSE_CAMERA_API_MAX);
 776         camera_mutex = g_new0(GMutex, MUSE_CAMERA_API_MAX);
 777         camera_activ = g_new0(gint, MUSE_CAMERA_API_MAX);
 778
 779         g_atomic_int_set(&cb_info->rcv_thread_running, 1);
 780         cb_info->fd = sockfd;
 781         cb_info->pCond = camera_cond;
 782         cb_info->pMutex = camera_mutex;
 783         cb_info->activating = camera_activ;
 784         cb_info->msg_rcv_thread = g_thread_new("msg_rcv_thread", client_cb_handler, (gpointer)cb_info);
 785
 786         g_atomic_int_set(&cb_info->event_thread_running, 1);
 787         g_mutex_init(&cb_info->event_mutex);
 788         g_cond_init(&cb_info->event_cond);
 789         cb_info->event_queue = g_queue_new();
 790         cb_info->event_thread = g_thread_new("event_thread", _event_handler, (gpointer)cb_info);
 791
 792         return cb_info;
 793 }
 794
 795 static void client_callback_destroy(callback_cb_info_s * cb_info)
 796 {
 797         g_return_if_fail(cb_info != NULL);
 798
 799         LOGI("MSG receive thread[%p] destroy", cb_info->msg_rcv_thread);
 800
 801         g_thread_join(cb_info->msg_rcv_thread);
 802         g_thread_unref(cb_info->msg_rcv_thread);
 803         cb_info->msg_rcv_thread = NULL;
 804
 805         LOGD("msg thread removed");
 806
 807         g_mutex_lock(&cb_info->event_mutex);
 808         g_atomic_int_set(&cb_info->event_thread_running, 0);
 809         g_cond_signal(&cb_info->event_cond);
 810         g_mutex_unlock(&cb_info->event_mutex);
 811
 812         g_thread_join(cb_info->event_thread);
 813         g_thread_unref(cb_info->event_thread);
 814         cb_info->event_thread = NULL;
 815
 816         g_queue_free(cb_info->event_queue);
 817         cb_info->event_queue = NULL;
 818         g_mutex_clear(&cb_info->event_mutex);
 819         g_cond_clear(&cb_info->event_cond);
 820
 821         LOGD("event thread removed");
 822
 823         if (cb_info->bufmgr) {
 824                 tbm_bufmgr_deinit(cb_info->bufmgr);
 825                 cb_info->bufmgr = NULL;
 826         }
 827
 828         if (cb_info->pCond) {
 829                 g_free(cb_info->pCond);
 830         }
 831         if (cb_info->pMutex) {
 832                 g_free(cb_info->pMutex);
 833         }
 834         if (cb_info->activating) {
 835                 g_free(cb_info->activating);
 836         }
 837
 838         g_free(cb_info);
 839
 840         return;
 841 }
 842
 843 int camera_create(camera_device_e device, camera_h* camera)
 844 {
 845         int sock_fd = -1;
 846         char *sndMsg;
 847         int ret = CAMERA_ERROR_NONE;
 848         int pid = 0;
 849         camera_cli_s *pc = NULL;
 850         tbm_bufmgr bufmgr = NULL;
 851
 852         muse_camera_api_e api = MUSE_CAMERA_API_CREATE;
 853         muse_core_api_module_e muse_module = MUSE_CAMERA;
 854         int device_type = (int)device;
 855
 856         if (camera == NULL){
 857                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
 858                 return CAMERA_ERROR_INVALID_PARAMETER;
 859         }
 860
 861         bufmgr = tbm_bufmgr_init(-1);
 862         if (bufmgr == NULL) {
 863                 LOGE("get tbm bufmgr failed");
 864                 return CAMERA_ERROR_INVALID_OPERATION;
 865         }
 866
 867         sock_fd = muse_core_client_new();
 868         if (sock_fd < 0) {
 869                 LOGE("muse_core_client_new failed - returned fd %d", sock_fd);
 870                 ret = CAMERA_ERROR_INVALID_OPERATION;
 871                 goto ErrorExit;
 872         }
 873
 874         pid = getpid();
 875
 876         sndMsg = muse_core_msg_json_factory_new(api,
 877                                                 MUSE_TYPE_INT, "module", muse_module,
 878                                                 MUSE_TYPE_INT, PARAM_DEVICE_TYPE, device_type,
 879                                                 MUSE_TYPE_INT, "pid", pid,
 880                                                 0);
 881
 882         muse_core_ipc_send_msg(sock_fd, sndMsg);
 883         muse_core_msg_json_factory_free(sndMsg);
 884
 885         pc = g_new0(camera_cli_s, 1);
 886         if (pc == NULL) {
 887                 ret = CAMERA_ERROR_OUT_OF_MEMORY;
 888                 goto ErrorExit;
 889         }
 890
 891         pc->cb_info = client_callback_new(sock_fd);
 892
 893         LOGD("cb info : %d", pc->cb_info->fd);
 894
 895         ret = client_wait_for_cb_return(api, pc->cb_info, CALLBACK_TIME_OUT);
 896         if (ret == CAMERA_ERROR_NONE) {
 897                 intptr_t handle = 0;
 898                 muse_camera_msg_get_pointer(handle, pc->cb_info->recvMsg);
 899                 if (handle == 0) {
 900                         LOGE("Receiving Handle Failed!!");
 901                         ret = CAMERA_ERROR_INVALID_OPERATION;
 902                         goto ErrorExit;
 903                 }
 904
 905                 pc->remote_handle = handle;
 906                 pc->cb_info->bufmgr = bufmgr;
 907
 908                 LOGD("camera create 0x%x", pc->remote_handle);
 909                 *camera = (camera_h) pc;
 910         } else {
 911                 goto ErrorExit;
 912         }
 913
 914         return ret;
 915
 916 ErrorExit:
 917         tbm_bufmgr_deinit(bufmgr);
 918         bufmgr = NULL;
 919
 920         if (pc) {
 921                 client_callback_destroy(pc->cb_info);
 922                 pc->cb_info = NULL;
 923                 g_free(pc);
 924                 pc = NULL;
 925         }
 926
 927         LOGE("camera create error : 0x%x", ret);
 928
 929         return ret;
 930 }
 931
 932  int camera_destroy(camera_h camera)
 933 {
 934         if (camera == NULL) {
 935                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
 936                 return CAMERA_ERROR_INVALID_PARAMETER;
 937         }
 938
 939         int ret = CAMERA_ERROR_NONE;
 940         muse_camera_api_e api = MUSE_CAMERA_API_DESTROY;
 941         camera_cli_s *pc = (camera_cli_s *)camera;
 942         int sock_fd = pc->cb_info->fd;
 943         LOGD("ENTER");
 944
 945         if (pc == NULL) {
 946                 LOGE("pc is already nul!!");
 947                 return CAMERA_ERROR_INVALID_PARAMETER;
 948         } else if (pc->cb_info == NULL) {
 949                 return CAMERA_ERROR_INVALID_PARAMETER;
 950         }
 951
 952         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
 953         if (ret == CAMERA_ERROR_NONE) {
 954                 client_callback_destroy(pc->cb_info);
 955                 g_free(pc);
 956                 pc = NULL;
 957         } else {
 958                 LOGE("camera destroy error : 0x%x", ret);
 959         }
 960
 961         return ret;
 962 }
 963
 964 int camera_start_preview(camera_h camera)
 965 {
 966         LOGD("start");
 967         if (camera == NULL) {
 968                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
 969                 return CAMERA_ERROR_INVALID_PARAMETER;
 970         }
 971
 972         int ret = CAMERA_ERROR_NONE;
 973         muse_camera_api_e api = MUSE_CAMERA_API_START_PREVIEW;
 974         camera_cli_s *pc = (camera_cli_s *)camera;
 975         int sock_fd;
 976         char caps[MUSE_CAMERA_MSG_MAX_LENGTH] = {0};
 977
 978         if (pc->cb_info == NULL) {
 979                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
 980                 return CAMERA_ERROR_INVALID_PARAMETER;
 981         }
 982
 983         sock_fd = pc->cb_info->fd;
 984
 985         muse_camera_msg_send_longtime(api, sock_fd, pc->cb_info, ret);
 986         LOGD("Enter,  ret :0x%x", ret);
 987         if(ret == CAMERA_ERROR_NONE) {
 988                 muse_camera_msg_get_string(caps, pc->cb_info->recvMsg);
 989                 LOGD("caps : %s", caps);
 990                 if (pc->cli_display_handle != 0) {
 991                         LOGD("client's display handle is : 0x%x", pc->cli_display_handle);
 992                         if(strlen(caps) > 0 &&
 993                                         mm_camcorder_client_realize(pc->client_handle, caps) != MM_ERROR_NONE)
 994                                 ret = CAMERA_ERROR_INVALID_OPERATION;
 995                 } else {
 996                         LOGD("display handle is NULL");
 997                 }
 998         }
 999         LOGD("ret : 0x%x", ret);
1000         return ret;
1001 }
1002
1003 int camera_stop_preview(camera_h camera)
1004 {
1005         if (camera == NULL) {
1006                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1007                 return CAMERA_ERROR_INVALID_PARAMETER;
1008         }
1009         int ret = CAMERA_ERROR_NONE;
1010         camera_cli_s *pc = (camera_cli_s *)camera;
1011         int sock_fd;
1012         muse_camera_api_e api = MUSE_CAMERA_API_STOP_PREVIEW;
1013
1014         if (pc->cb_info == NULL) {
1015                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1016                 return CAMERA_ERROR_INVALID_PARAMETER;
1017         }
1018
1019         sock_fd = pc->cb_info->fd;
1020         LOGD("Enter");
1021         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1022
1023         if(ret == CAMERA_ERROR_NONE) {
1024                 if (pc->cli_display_handle != 0) {
1025                         LOGD("Unrealize client");
1026                         if (pc->client_handle != NULL) {
1027                                 ret = mm_camcorder_client_unrealize(pc->client_handle);
1028                                 mm_camcorder_client_destroy(pc->client_handle);
1029                         }
1030                 } else {
1031                         LOGD("Client did not realized : Display handle is NULL");
1032                 }
1033         }
1034         LOGD("ret : 0x%x", ret);
1035         return ret;
1036 }
1037
1038 int camera_start_capture(camera_h camera, camera_capturing_cb capturing_cb , camera_capture_completed_cb completed_cb , void *user_data)
1039 {
1040         if (camera == NULL) {
1041                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1042                 return CAMERA_ERROR_INVALID_PARAMETER;
1043         }
1044         int ret = CAMERA_ERROR_NONE;
1045
1046         camera_cli_s *pc = (camera_cli_s *)camera;
1047         muse_camera_api_e api = MUSE_CAMERA_API_START_CAPTURE;
1048         int sock_fd;
1049         int is_capturing_cb = 0;
1050         int is_completed_cb = 0;
1051         LOGD("Enter, handle :%x", pc->remote_handle);
1052
1053         if (pc->cb_info == NULL) {
1054                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1055                 return CAMERA_ERROR_INVALID_PARAMETER;
1056         }
1057
1058         sock_fd = pc->cb_info->fd;
1059
1060         if (capturing_cb != NULL) {
1061                 is_capturing_cb = 1;
1062                 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_CAPTURE] = capturing_cb;
1063                 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_CAPTURE] = user_data;
1064         }
1065
1066         if(completed_cb != NULL) {
1067                 is_completed_cb = 1;
1068                 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = completed_cb;
1069                 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = user_data;
1070         }
1071
1072         muse_camera_msg_send2(api, sock_fd, pc->cb_info, ret, INT, is_capturing_cb, INT, is_completed_cb);
1073         LOGD("is_capturing_cb :%d, is_completed_cb : %d", is_capturing_cb, is_completed_cb);
1074         LOGD("ret : 0x%x", ret);
1075         return ret;
1076 }
1077
1078 bool camera_is_supported_continuous_capture(camera_h camera)
1079 {
1080         if (camera == NULL) {
1081                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1082                 return false;
1083         }
1084
1085         int ret = CAMERA_ERROR_NONE;
1086         camera_cli_s *pc = (camera_cli_s *)camera;
1087         muse_camera_api_e api = MUSE_CAMERA_API_SUPPORT_CONTINUOUS_CAPTURE;
1088         int sock_fd;
1089
1090         if (pc->cb_info == NULL) {
1091                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1092                 return CAMERA_ERROR_INVALID_PARAMETER;
1093         }
1094
1095         sock_fd = pc->cb_info->fd;
1096
1097         LOGD("Enter, remote_handle : %x", pc->remote_handle);
1098         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1099         LOGD("ret : 0x%x", ret);
1100         return (bool)ret;
1101 }
1102
1103 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)
1104 {
1105         if (camera == NULL) {
1106                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
1107                 return CAMERA_ERROR_INVALID_PARAMETER;
1108         }
1109
1110         int ret = CAMERA_ERROR_NONE;
1111
1112         camera_cli_s *pc = (camera_cli_s *)camera;
1113         muse_camera_api_e api = MUSE_CAMERA_API_START_CONTINUOUS_CAPTURE;
1114
1115         LOGD("Enter, handle :%x", pc->remote_handle);
1116
1117         int sock_fd;
1118         if (pc->cb_info == NULL) {
1119                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1120                 return CAMERA_ERROR_INVALID_PARAMETER;
1121         }
1122         sock_fd = pc->cb_info->fd;
1123
1124         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_CAPTURE] = capturing_cb;
1125         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_CAPTURE] = user_data;
1126         pc->cb_info->user_cb_completed[MUSE_CAMERA_EVENT_TYPE_CAPTURE] = completed_cb;
1127
1128         muse_camera_msg_send2(api, sock_fd, pc->cb_info, ret, INT, count, INT, interval);
1129         LOGD("ret : 0x%x", ret);
1130         return ret;
1131 }
1132
1133 int camera_stop_continuous_capture(camera_h camera)
1134 {
1135         if (camera == NULL) {
1136                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1137                 return CAMERA_ERROR_INVALID_PARAMETER;
1138         }
1139
1140
1141         int ret = CAMERA_ERROR_NONE;
1142
1143         camera_cli_s *pc = (camera_cli_s *)camera;
1144         muse_camera_api_e api = MUSE_CAMERA_API_STOP_CONTINUOUS_CAPTURE;
1145         LOGD("Enter,  handle :%x", pc->remote_handle);
1146         int sock_fd;
1147         if (pc->cb_info == NULL) {
1148                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1149                 return CAMERA_ERROR_INVALID_PARAMETER;
1150         }
1151         sock_fd = pc->cb_info->fd;
1152         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1153         LOGD("ret : 0x%x", ret);
1154         return ret;
1155 }
1156
1157 bool camera_is_supported_face_detection(camera_h camera)
1158 {
1159         if (camera == NULL) {
1160                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1161                 return false;
1162         }
1163         int ret = CAMERA_ERROR_NONE;
1164
1165         camera_cli_s *pc = (camera_cli_s *)camera;
1166         muse_camera_api_e api = MUSE_CAMERA_API_SUPPORT_FACE_DETECTION;
1167         int sock_fd;
1168         if (pc->cb_info == NULL) {
1169                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1170                 return CAMERA_ERROR_INVALID_PARAMETER;
1171         }
1172         sock_fd = pc->cb_info->fd;
1173
1174         LOGD("Enter, remote_handle : %x", pc->remote_handle);
1175         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1176         LOGD("ret : 0x%x", ret);
1177         return (bool)ret;
1178 }
1179
1180 bool camera_is_supported_zero_shutter_lag(camera_h camera)
1181 {
1182         if (camera == NULL) {
1183                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1184                 return false;
1185         }
1186         int ret = CAMERA_ERROR_NONE;
1187
1188         camera_cli_s *pc = (camera_cli_s *)camera;
1189         muse_camera_api_e api = MUSE_CAMERA_API_SUPPORT_ZERO_SHUTTER_LAG;
1190         int sock_fd;
1191         if (pc->cb_info == NULL) {
1192                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1193                 return CAMERA_ERROR_INVALID_PARAMETER;
1194         }
1195         sock_fd = pc->cb_info->fd;
1196
1197         LOGD("Enter, remote_handle : %x", pc->remote_handle);
1198         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1199         LOGD("ret : 0x%x", ret);
1200         return (bool)ret;
1201 }
1202
1203 bool camera_is_supported_media_packet_preview_cb(camera_h camera)
1204 {
1205         if (camera == NULL) {
1206                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1207                 return false;
1208         }
1209
1210         int ret = CAMERA_ERROR_NONE;
1211
1212         camera_cli_s *pc = (camera_cli_s *)camera;
1213         muse_camera_api_e api = MUSE_CAMERA_API_SUPPORT_MEDIA_PACKET_PREVIEW_CB;
1214         int sock_fd;
1215         if (pc->cb_info == NULL) {
1216                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1217                 return CAMERA_ERROR_INVALID_PARAMETER;
1218         }
1219         sock_fd = pc->cb_info->fd;
1220
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);
1224         return (bool)ret;
1225 }
1226
1227 int camera_get_device_count(camera_h camera, int *device_count)
1228 {
1229         if (camera == NULL || device_count == NULL) {
1230                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
1231                 return CAMERA_ERROR_INVALID_PARAMETER;
1232         }
1233         int ret = CAMERA_ERROR_NONE;
1234
1235         camera_cli_s *pc = (camera_cli_s *)camera;
1236         muse_camera_api_e api = MUSE_CAMERA_API_GET_DEVICE_COUNT;
1237         int sock_fd;
1238         if (pc->cb_info == NULL) {
1239                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1240                 return CAMERA_ERROR_INVALID_PARAMETER;
1241         }
1242         sock_fd = pc->cb_info->fd;
1243         int get_device_count;
1244
1245         LOGD("Enter, remote_handle : %x", pc->remote_handle);
1246         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1247
1248         if (ret == CAMERA_ERROR_NONE) {
1249                 muse_camera_msg_get(get_device_count, pc->cb_info->recvMsg);
1250                 *device_count = get_device_count;
1251         }
1252         LOGD("ret : 0x%x", ret);
1253         return ret;
1254 }
1255
1256 int camera_start_face_detection(camera_h camera, camera_face_detected_cb callback, void * user_data)
1257 {
1258         if (camera == NULL) {
1259                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
1260                 return CAMERA_ERROR_INVALID_PARAMETER;
1261         }
1262
1263         int ret = CAMERA_ERROR_NONE;
1264
1265         camera_cli_s *pc = (camera_cli_s *)camera;
1266         muse_camera_api_e api = MUSE_CAMERA_API_START_FACE_DETECTION;
1267
1268         LOGD("Enter, handle :%x", pc->remote_handle);
1269         int sock_fd;
1270         if (pc->cb_info == NULL) {
1271                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1272                 return CAMERA_ERROR_INVALID_PARAMETER;
1273         }
1274         sock_fd = pc->cb_info->fd;
1275         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FACE_DETECTION] = callback;
1276         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FACE_DETECTION] = user_data;
1277
1278         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1279         LOGD("ret : 0x%x", ret);
1280         return ret;
1281 }
1282
1283 int camera_stop_face_detection(camera_h camera)
1284 {
1285         if (camera == NULL) {
1286                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1287                 return CAMERA_ERROR_INVALID_PARAMETER;
1288         }
1289
1290         int ret = CAMERA_ERROR_NONE;
1291
1292         camera_cli_s *pc = (camera_cli_s *)camera;
1293         muse_camera_api_e api = MUSE_CAMERA_API_STOP_FACE_DETECTION;
1294         LOGD("Enter,  handle :%x", pc->remote_handle);
1295         int sock_fd;
1296         if (pc->cb_info == NULL) {
1297                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1298                 return CAMERA_ERROR_INVALID_PARAMETER;
1299         }
1300         sock_fd = pc->cb_info->fd;
1301         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1302         LOGD("ret : 0x%x", ret);
1303         return ret;
1304 }
1305
1306 int camera_get_state(camera_h camera, camera_state_e * state)
1307 {
1308         if (camera == NULL || state == NULL) {
1309                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1310                 return CAMERA_ERROR_INVALID_PARAMETER;
1311         }
1312         int ret = CAMERA_ERROR_NONE;
1313
1314         camera_cli_s *pc = (camera_cli_s *)camera;
1315         muse_camera_api_e api = MUSE_CAMERA_API_GET_STATE;
1316         int sock_fd;
1317         if (pc->cb_info == NULL) {
1318                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1319                 return CAMERA_ERROR_INVALID_PARAMETER;
1320         }
1321         sock_fd = pc->cb_info->fd;
1322         int get_state;
1323
1324         LOGD("Enter, remote_handle : %x", pc->remote_handle);
1325         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1326
1327         if (ret == CAMERA_ERROR_NONE) {
1328                 muse_camera_msg_get(get_state, pc->cb_info->recvMsg);
1329                 *state = (camera_state_e)get_state;
1330         }
1331         LOGD("ret : 0x%x", ret);
1332         return ret;
1333 }
1334
1335 int camera_start_focusing(camera_h camera, bool continuous)
1336 {
1337         if( camera == NULL){
1338                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1339                 return CAMERA_ERROR_INVALID_PARAMETER;
1340         }
1341
1342         int ret = CAMERA_ERROR_NONE;
1343
1344         camera_cli_s *pc = (camera_cli_s *)camera;
1345         muse_camera_api_e api = MUSE_CAMERA_API_START_FOCUSING;
1346         int sock_fd;
1347         if (pc->cb_info == NULL) {
1348                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1349                 return CAMERA_ERROR_INVALID_PARAMETER;
1350         }
1351         sock_fd = pc->cb_info->fd;
1352         int is_continuous = (int)continuous;
1353
1354         LOGD("Enter, remote_handle : %x", pc->remote_handle);
1355         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, is_continuous);
1356         LOGD("ret : 0x%x", ret);
1357         return ret;
1358 }
1359
1360 int camera_cancel_focusing(camera_h camera)
1361 {
1362         if (camera == NULL) {
1363                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1364                 return CAMERA_ERROR_INVALID_PARAMETER;
1365         }
1366
1367         int ret = CAMERA_ERROR_NONE;
1368
1369         camera_cli_s *pc = (camera_cli_s *)camera;
1370         muse_camera_api_e api = MUSE_CAMERA_API_CANCEL_FOCUSING;
1371         int sock_fd;
1372         if (pc->cb_info == NULL) {
1373                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1374                 return CAMERA_ERROR_INVALID_PARAMETER;
1375         }
1376         sock_fd = pc->cb_info->fd;
1377
1378         LOGD("Enter, remote_handle : %x", pc->remote_handle);
1379         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1380         LOGD("ret : 0x%x", ret);
1381         return ret;
1382 }
1383
1384 int camera_set_display(camera_h camera, camera_display_type_e type, camera_display_h display)
1385 {
1386         int ret = CAMERA_ERROR_NONE;
1387         int display_surface;
1388         void *set_display_handle = NULL;
1389         int set_surface = MM_DISPLAY_SURFACE_X;
1390         Evas_Object *obj = NULL;
1391         const char *object_type = NULL;
1392         char socket_path[MUSE_CAMERA_MSG_MAX_LENGTH] = {0,};
1393
1394         if (camera == NULL) {
1395                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
1396                 return CAMERA_ERROR_INVALID_PARAMETER;
1397         }
1398
1399         if (type != CAMERA_DISPLAY_TYPE_NONE && display == NULL) {
1400                 LOGE("display type[%d] is not NONE, but display handle is NULL", type);
1401                 return CAMERA_ERROR_INVALID_PARAMETER;
1402         }
1403
1404         int display_type = (int)type;
1405         camera_cli_s *pc = (camera_cli_s *)camera;
1406         muse_camera_api_e api = MUSE_CAMERA_API_SET_DISPLAY;
1407         int sock_fd;
1408         if (pc->cb_info == NULL) {
1409                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1410                 return CAMERA_ERROR_INVALID_PARAMETER;
1411         }
1412         sock_fd = pc->cb_info->fd;
1413
1414         LOGD("Enter, remote_handle : %x display : 0x%x", pc->remote_handle, display);
1415
1416         if (type == CAMERA_DISPLAY_TYPE_NONE) {
1417                 set_display_handle = 0;
1418                 set_surface = MM_DISPLAY_SURFACE_NULL;
1419                 LOGD("display type NONE");
1420         } else {
1421                 obj = (Evas_Object *)display;
1422                 object_type = evas_object_type_get(obj);
1423                 if (object_type) {
1424                         if (type == CAMERA_DISPLAY_TYPE_OVERLAY && !strcmp(object_type, "elm_win")) {
1425 #ifdef HAVE_WAYLAND
1426                                 MMCamWaylandInfo *wl_info = g_new0(MMCamWaylandInfo, 1);
1427
1428                                 if (wl_info == NULL) {
1429                                         LOGE("wl_info alloc failed : %d", sizeof(MMCamWaylandInfo));
1430                                         return CAMERA_ERROR_OUT_OF_MEMORY;
1431                                 }
1432
1433                                 wl_info->evas_obj = (void *)obj;
1434                                 wl_info->window = (void *)elm_win_wl_window_get(obj);
1435                                 wl_info->surface = (void *)ecore_wl_window_surface_get(wl_info->window);
1436                                 wl_info->display = (void *)ecore_wl_display_get();
1437
1438                                 if (wl_info->window == NULL || wl_info->surface == NULL || wl_info->display == NULL) {
1439                                         LOGE("something is NULL %p, %p, %p", wl_info->window, wl_info->surface, wl_info->display);
1440                                         return CAMERA_ERROR_INVALID_OPERATION;
1441                                 }
1442
1443                                 evas_object_geometry_get(obj, &wl_info->window_x, &wl_info->window_y,
1444                                                               &wl_info->window_width, &wl_info->window_height);
1445
1446                                 /* set wayland info */
1447                                 pc->wl_info = wl_info;
1448                                 set_surface = MM_DISPLAY_SURFACE_X;
1449                                 set_display_handle = (void *)wl_info;
1450
1451                                 LOGD("wayland obj %p, window %p, surface %p, display %p, size %d,%d,%dx%d",
1452                                      wl_info->evas_obj, wl_info->window, wl_info->surface, wl_info->display,
1453                                      wl_info->window_x, wl_info->window_y, wl_info->window_width, wl_info->window_height);
1454 #else /* HAVE_WAYLAND */
1455                                 /* x window overlay surface */
1456                                 set_display_handle = (void *)elm_win_xwindow_get(obj);
1457                                 set_surface = MM_DISPLAY_SURFACE_X;
1458                                 LOGD("display type OVERLAY : handle %p", set_display_handle);
1459 #endif
1460                         } else if (type == CAMERA_DISPLAY_TYPE_EVAS && !strcmp(object_type, "image")) {
1461                                 /* evas object surface */
1462                                 set_display_handle = (void *)display;
1463                                 set_surface = MM_DISPLAY_SURFACE_EVAS;
1464                                 LOGD("display type EVAS : handle %p", set_display_handle);
1465                         } else {
1466                                 LOGE("unknown evas object [%p,%s] or type [%d] mismatch", obj, object_type, type);
1467                                 return CAMERA_ERROR_INVALID_PARAMETER;
1468                         }
1469                 } else {
1470                         LOGE("failed to get evas object type from %p", obj);
1471                         return CAMERA_ERROR_INVALID_PARAMETER;
1472                 }
1473         }
1474
1475         pc->cli_display_handle = (intptr_t)set_display_handle;
1476         display_surface = (int)set_surface;
1477         muse_camera_msg_send2(api, sock_fd, pc->cb_info, ret,
1478                                                             INT, display_type,
1479                                                             INT, display_surface);
1480
1481         if (ret == CAMERA_ERROR_NONE && type == CAMERA_DISPLAY_TYPE_OVERLAY && !strcmp(object_type, "elm_win")) {
1482                 if (mm_camcorder_client_create(&(pc->client_handle))) {
1483                         LOGE("camera client create Failed");
1484                         return CAMERA_ERROR_INVALID_OPERATION;
1485                 }
1486                 muse_camera_msg_get_string(socket_path, pc->cb_info->recvMsg);
1487                 LOGD("shmsrc stream path : %s", socket_path);
1488                 if(mm_camcorder_client_set_shm_socket_path(pc->client_handle, socket_path)
1489                                 != MM_ERROR_NONE)
1490                         return CAMERA_ERROR_INVALID_OPERATION;
1491                 ret = mm_camcorder_set_attributes(pc->client_handle, NULL,
1492                                                   MMCAM_DISPLAY_SURFACE, set_surface,
1493                                                   NULL);
1494                 if (ret == MM_ERROR_NONE && type != CAMERA_DISPLAY_TYPE_NONE) {
1495                         ret = mm_camcorder_set_attributes(pc->client_handle, NULL,
1496                                                           MMCAM_DISPLAY_HANDLE, pc->cli_display_handle, sizeof(void *),
1497                                                           NULL);
1498                         LOGD("ret : 0x%x", ret);
1499                 }
1500         }
1501         LOGD("ret : 0x%x", ret);
1502         return ret;
1503 }
1504
1505 int camera_set_preview_resolution(camera_h camera,  int width, int height)
1506 {
1507         if( camera == NULL){
1508                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1509                 return CAMERA_ERROR_INVALID_PARAMETER;
1510         }
1511         int ret = CAMERA_ERROR_NONE;
1512
1513         camera_cli_s *pc = (camera_cli_s *)camera;
1514         muse_camera_api_e api = MUSE_CAMERA_API_SET_PREVIEW_RESOLUTION;
1515         int sock_fd;
1516         if (pc->cb_info == NULL) {
1517                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1518                 return CAMERA_ERROR_INVALID_PARAMETER;
1519         }
1520         sock_fd = pc->cb_info->fd;
1521
1522         LOGD("Enter, remote_handle : %x", pc->remote_handle);
1523         muse_camera_msg_send2(api, sock_fd, pc->cb_info, ret, INT, width, INT, height);
1524         LOGD("ret : 0x%x", ret);
1525         return ret;
1526 }
1527
1528
1529 int camera_set_capture_resolution(camera_h camera,  int width, int height)
1530 {
1531         if (camera == NULL) {
1532                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1533                 return CAMERA_ERROR_INVALID_PARAMETER;
1534         }
1535
1536         int ret = CAMERA_ERROR_NONE;
1537
1538         camera_cli_s *pc = (camera_cli_s *)camera;
1539         muse_camera_api_e api = MUSE_CAMERA_API_SET_CAPTURE_RESOLUTION;
1540         int sock_fd;
1541         if (pc->cb_info == NULL) {
1542                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1543                 return CAMERA_ERROR_INVALID_PARAMETER;
1544         }
1545         sock_fd = pc->cb_info->fd;
1546
1547         LOGD("Enter, remote_handle : %x", pc->remote_handle);
1548         muse_camera_msg_send2(api, sock_fd, pc->cb_info, ret, INT, width, INT, height);
1549         LOGD("ret : 0x%x", ret);
1550         return ret;
1551 }
1552
1553 int camera_set_capture_format(camera_h camera, camera_pixel_format_e format)
1554 {
1555         if (camera == NULL) {
1556                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1557                 return CAMERA_ERROR_INVALID_PARAMETER;
1558         }
1559
1560         int ret = CAMERA_ERROR_NONE;
1561         int set_format = (int)format;
1562
1563         camera_cli_s *pc = (camera_cli_s *)camera;
1564         muse_camera_api_e api = MUSE_CAMERA_API_SET_CAPTURE_FORMAT;
1565         int sock_fd;
1566         if (pc->cb_info == NULL) {
1567                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1568                 return CAMERA_ERROR_INVALID_PARAMETER;
1569         }
1570         sock_fd = pc->cb_info->fd;
1571
1572         LOGD("Enter, remote_handle : %x, capture_format: %d", pc->remote_handle, set_format);
1573         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_format);
1574         LOGD("ret : 0x%x", ret);
1575         return ret;
1576 }
1577
1578 int camera_set_preview_format(camera_h camera, camera_pixel_format_e format)
1579 {
1580         if (camera == NULL) {
1581                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1582                 return CAMERA_ERROR_INVALID_PARAMETER;
1583         }
1584
1585         int ret = CAMERA_ERROR_NONE;
1586         int set_format = (int)format;
1587
1588         camera_cli_s *pc = (camera_cli_s *)camera;
1589         muse_camera_api_e api = MUSE_CAMERA_API_SET_PREVIEW_FORMAT;
1590         int sock_fd;
1591         if (pc->cb_info == NULL) {
1592                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1593                 return CAMERA_ERROR_INVALID_PARAMETER;
1594         }
1595         sock_fd = pc->cb_info->fd;
1596
1597         LOGD("Enter, remote_handle : %x, capture_format: %d", pc->remote_handle, set_format);
1598         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_format);
1599         LOGD("ret : 0x%x", ret);
1600         return ret;
1601 }
1602
1603 int camera_get_preview_resolution(camera_h camera,  int *width, int *height)
1604 {
1605         if (camera == NULL || width == NULL || height == NULL) {
1606                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1607                 return CAMERA_ERROR_INVALID_PARAMETER;
1608         }
1609
1610
1611         int ret = CAMERA_ERROR_NONE;
1612
1613         camera_cli_s *pc = (camera_cli_s *)camera;
1614         muse_camera_api_e api = MUSE_CAMERA_API_GET_PREVIEW_RESOLUTION;
1615         int sock_fd;
1616         if (pc->cb_info == NULL) {
1617                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1618                 return CAMERA_ERROR_INVALID_PARAMETER;
1619         }
1620         sock_fd = pc->cb_info->fd;
1621         int get_width;
1622         int get_height;
1623
1624         LOGD("Enter, remote_handle : %x", pc->remote_handle);
1625         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1626
1627         if (ret == CAMERA_ERROR_NONE) {
1628                 muse_camera_msg_get(get_width, pc->cb_info->recvMsg);
1629                 muse_camera_msg_get(get_height, pc->cb_info->recvMsg);
1630                 *width = get_width;
1631                 *height = get_height;
1632         }
1633         LOGD("ret : 0x%x", ret);
1634         return ret;
1635 }
1636
1637 int camera_set_display_rotation(camera_h camera, camera_rotation_e rotation)
1638 {
1639         if( camera == NULL){
1640                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1641                 return CAMERA_ERROR_INVALID_PARAMETER;
1642         }
1643
1644         int ret = CAMERA_ERROR_NONE;
1645         camera_cli_s *pc = (camera_cli_s *)camera;
1646         muse_camera_api_e api = MUSE_CAMERA_API_SET_DISPLAY_ROTATION;
1647         int sock_fd;
1648         if (pc->cb_info == NULL) {
1649                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1650                 return CAMERA_ERROR_INVALID_PARAMETER;
1651         }
1652         sock_fd = pc->cb_info->fd;
1653         int set_rotation = (int)rotation;
1654
1655         LOGD("Enter, remote_handle : %x", pc->remote_handle);
1656         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_rotation);
1657         LOGD("ret : 0x%x", ret);
1658         return ret;
1659 }
1660
1661 int camera_get_display_rotation(camera_h camera, camera_rotation_e *rotation)
1662 {
1663         if( camera == NULL || rotation == NULL ){
1664                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1665                 return CAMERA_ERROR_INVALID_PARAMETER;
1666         }
1667
1668         int ret = CAMERA_ERROR_NONE;
1669
1670         camera_cli_s *pc = (camera_cli_s *)camera;
1671         muse_camera_api_e api = MUSE_CAMERA_API_GET_DISPLAY_ROTATION;
1672         int sock_fd;
1673         if (pc->cb_info == NULL) {
1674                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1675                 return CAMERA_ERROR_INVALID_PARAMETER;
1676         }
1677         sock_fd = pc->cb_info->fd;
1678         int get_rotation;
1679
1680         LOGD("Enter, remote_handle : %x", pc->remote_handle);
1681         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1682
1683         if (ret == CAMERA_ERROR_NONE) {
1684                 muse_camera_msg_get(get_rotation, pc->cb_info->recvMsg);
1685                 *rotation = (camera_rotation_e)get_rotation;
1686         }
1687         LOGD("ret : 0x%x", ret);
1688         return ret;
1689 }
1690
1691 int camera_set_display_flip(camera_h camera, camera_flip_e flip)
1692 {
1693         if( camera == NULL){
1694                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1695                 return CAMERA_ERROR_INVALID_PARAMETER;
1696         }
1697
1698         int ret = CAMERA_ERROR_NONE;
1699
1700         camera_cli_s *pc = (camera_cli_s *)camera;
1701         muse_camera_api_e api = MUSE_CAMERA_API_SET_DISPLAY_FLIP;
1702         int sock_fd;
1703         if (pc->cb_info == NULL) {
1704                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1705                 return CAMERA_ERROR_INVALID_PARAMETER;
1706         }
1707         sock_fd = pc->cb_info->fd;
1708         int set_flip = (int)flip;
1709
1710         LOGD("Enter, remote_handle : %x", pc->remote_handle);
1711         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_flip);
1712         LOGD("ret : 0x%x", ret);
1713         return ret;
1714 }
1715
1716 int camera_get_display_flip(camera_h camera, camera_flip_e *flip)
1717 {
1718         if( camera == NULL || flip == NULL ){
1719                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1720                 return CAMERA_ERROR_INVALID_PARAMETER;
1721         }
1722
1723         int ret = CAMERA_ERROR_NONE;
1724
1725         camera_cli_s *pc = (camera_cli_s *)camera;
1726         muse_camera_api_e api = MUSE_CAMERA_API_GET_DISPLAY_FLIP;
1727         int sock_fd;
1728         if (pc->cb_info == NULL) {
1729                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1730                 return CAMERA_ERROR_INVALID_PARAMETER;
1731         }
1732         sock_fd = pc->cb_info->fd;
1733         int get_flip;
1734
1735         LOGD("Enter, remote_handle : %x", pc->remote_handle);
1736         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1737
1738         if (ret == CAMERA_ERROR_NONE) {
1739                 muse_camera_msg_get(get_flip, pc->cb_info->recvMsg);
1740                 *flip = (camera_flip_e)get_flip;
1741         }
1742         LOGD("ret : 0x%x", ret);
1743         return ret;
1744 }
1745
1746 int camera_set_display_visible(camera_h camera, bool visible)
1747 {
1748         if( camera == NULL){
1749                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1750                 return CAMERA_ERROR_INVALID_PARAMETER;
1751         }
1752
1753         int ret = CAMERA_ERROR_NONE;
1754
1755         camera_cli_s *pc = (camera_cli_s *)camera;
1756         muse_camera_api_e api = MUSE_CAMERA_API_SET_DISPLAY_VISIBLE;
1757         int set_visible = (int)visible;
1758         int sock_fd;
1759         if (pc->cb_info == NULL) {
1760                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1761                 return CAMERA_ERROR_INVALID_PARAMETER;
1762         }
1763         sock_fd = pc->cb_info->fd;
1764
1765         LOGD("Enter, remote_handle : %x", pc->remote_handle);
1766         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_visible);
1767         LOGD("ret : 0x%x", ret);
1768         return ret;
1769 }
1770
1771 int camera_is_display_visible(camera_h camera, bool* visible)
1772 {
1773         if( camera == NULL || visible == NULL){
1774                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1775                 return CAMERA_ERROR_INVALID_PARAMETER;
1776         }
1777
1778         int ret = CAMERA_ERROR_NONE;
1779
1780         camera_cli_s *pc = (camera_cli_s *)camera;
1781         muse_camera_api_e api = MUSE_CAMERA_API_IS_DISPLAY_VISIBLE;
1782         int sock_fd;
1783         if (pc->cb_info == NULL) {
1784                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1785                 return CAMERA_ERROR_INVALID_PARAMETER;
1786         }
1787         sock_fd = pc->cb_info->fd;
1788         int get_visible;
1789
1790         LOGD("Enter, remote_handle : %x", pc->remote_handle);
1791         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1792
1793         if (ret == CAMERA_ERROR_NONE) {
1794                 muse_camera_msg_get(get_visible, pc->cb_info->recvMsg);
1795                 *visible = (bool)get_visible;
1796         }
1797         LOGD("ret : 0x%x", ret);
1798         return ret;
1799 }
1800
1801 int camera_set_display_mode(camera_h camera, camera_display_mode_e mode)
1802 {
1803         if (camera == NULL) {
1804                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1805                 return CAMERA_ERROR_INVALID_PARAMETER;
1806         }
1807
1808         int ret = CAMERA_ERROR_NONE;
1809         int set_mode = (int)mode;
1810
1811         camera_cli_s *pc = (camera_cli_s *)camera;
1812         muse_camera_api_e api = MUSE_CAMERA_API_SET_DISPLAY_MODE;
1813         int sock_fd;
1814         if (pc->cb_info == NULL) {
1815                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1816                 return CAMERA_ERROR_INVALID_PARAMETER;
1817         }
1818         sock_fd = pc->cb_info->fd;
1819
1820         LOGD("Enter, remote_handle : %x", pc->remote_handle);
1821         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_mode);
1822         LOGD("ret : 0x%x", ret);
1823         return ret;
1824 }
1825
1826 int camera_get_display_mode(camera_h camera, camera_display_mode_e* mode)
1827 {
1828         if( camera == NULL || mode == NULL){
1829                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1830                 return CAMERA_ERROR_INVALID_PARAMETER;
1831         }
1832
1833         int ret = CAMERA_ERROR_NONE;
1834
1835         camera_cli_s *pc = (camera_cli_s *)camera;
1836         muse_camera_api_e api = MUSE_CAMERA_API_GET_DISPLAY_MODE;
1837         int sock_fd;
1838         if (pc->cb_info == NULL) {
1839                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1840                 return CAMERA_ERROR_INVALID_PARAMETER;
1841         }
1842         sock_fd = pc->cb_info->fd;
1843         int get_mode;
1844
1845         LOGD("Enter, remote_handle : %x", pc->remote_handle);
1846         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1847
1848         if (ret == CAMERA_ERROR_NONE) {
1849                 muse_camera_msg_get(get_mode, pc->cb_info->recvMsg);
1850                 *mode = (camera_display_mode_e)get_mode;
1851         }
1852         LOGD("ret : 0x%x", ret);
1853         return ret;
1854 }
1855
1856 int camera_get_capture_resolution(camera_h camera, int *width, int *height)
1857 {
1858         if( camera == NULL || width== NULL || height == NULL){
1859                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1860                 return CAMERA_ERROR_INVALID_PARAMETER;
1861         }
1862         int ret = CAMERA_ERROR_NONE;
1863
1864         camera_cli_s *pc = (camera_cli_s *)camera;
1865         muse_camera_api_e api = MUSE_CAMERA_API_GET_CAPTURE_RESOLUTION;
1866         int sock_fd;
1867         if (pc->cb_info == NULL) {
1868                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1869                 return CAMERA_ERROR_INVALID_PARAMETER;
1870         }
1871         sock_fd = pc->cb_info->fd;
1872         int get_width;
1873         int get_height;
1874
1875         LOGD("Enter, remote_handle : %x", pc->remote_handle);
1876         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1877
1878         if (ret == CAMERA_ERROR_NONE) {
1879                 muse_camera_msg_get(get_width, pc->cb_info->recvMsg);
1880                 muse_camera_msg_get(get_height, pc->cb_info->recvMsg);
1881                 *width = get_width;
1882                 *height = get_height;
1883         }
1884         LOGD("ret : 0x%x", ret);
1885         return ret;
1886 }
1887
1888 int camera_get_capture_format(camera_h camera, camera_pixel_format_e *format)
1889 {
1890         if( camera == NULL || format == NULL){
1891                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1892                 return CAMERA_ERROR_INVALID_PARAMETER;
1893         }
1894         int ret = CAMERA_ERROR_NONE;
1895
1896         camera_cli_s *pc = (camera_cli_s *)camera;
1897         muse_camera_api_e api = MUSE_CAMERA_API_GET_CAPTURE_FORMAT;
1898         int get_format;
1899         int sock_fd;
1900         if (pc->cb_info == NULL) {
1901                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1902                 return CAMERA_ERROR_INVALID_PARAMETER;
1903         }
1904         sock_fd = pc->cb_info->fd;
1905
1906         LOGD("Enter, remote_handle : %x", pc->remote_handle);
1907         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1908
1909         if (ret == CAMERA_ERROR_NONE) {
1910                 muse_camera_msg_get(get_format, pc->cb_info->recvMsg);
1911                 *format = (camera_pixel_format_e)get_format;
1912         }
1913         LOGD("ret : 0x%x", ret);
1914         return ret;
1915 }
1916
1917 int camera_get_preview_format(camera_h camera, camera_pixel_format_e *format)
1918 {
1919         if( camera == NULL || format == NULL){
1920                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1921                 return CAMERA_ERROR_INVALID_PARAMETER;
1922         }
1923
1924         int ret = CAMERA_ERROR_NONE;
1925
1926         camera_cli_s *pc = (camera_cli_s *)camera;
1927         muse_camera_api_e api = MUSE_CAMERA_API_GET_PREVIEW_FORMAT;
1928         int get_format;
1929         int sock_fd;
1930         if (pc->cb_info == NULL) {
1931                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1932                 return CAMERA_ERROR_INVALID_PARAMETER;
1933         }
1934         sock_fd = pc->cb_info->fd;
1935
1936         LOGD("Enter, remote_handle : %x", pc->remote_handle);
1937         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1938
1939         if (ret == CAMERA_ERROR_NONE) {
1940                 muse_camera_msg_get(get_format, pc->cb_info->recvMsg);
1941                 *format = (camera_pixel_format_e)get_format;
1942         }
1943         LOGD("ret : 0x%x", ret);
1944         return ret;
1945 }
1946
1947 int camera_set_preview_cb(camera_h camera, camera_preview_cb callback, void* user_data)
1948 {
1949         if (camera == NULL || callback == NULL) {
1950                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1951                 return CAMERA_ERROR_INVALID_PARAMETER;
1952         }
1953         int ret = CAMERA_ERROR_NONE;
1954
1955         camera_cli_s *pc = (camera_cli_s *)camera;
1956         int sock_fd;
1957         if (pc->cb_info == NULL) {
1958                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1959                 return CAMERA_ERROR_INVALID_PARAMETER;
1960         }
1961         sock_fd = pc->cb_info->fd;
1962         muse_camera_api_e api = MUSE_CAMERA_API_SET_PREVIEW_CB;
1963
1964         LOGD("Enter, handle :%x", pc->remote_handle);
1965
1966         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_PREVIEW] = callback;
1967         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_PREVIEW] = user_data;
1968
1969         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1970         LOGD("ret : 0x%x", ret);
1971         return ret;
1972 }
1973
1974 int camera_unset_preview_cb(camera_h camera)
1975 {
1976         if (camera == NULL) {
1977                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1978                 return CAMERA_ERROR_INVALID_PARAMETER;
1979         }
1980
1981         int ret = CAMERA_ERROR_NONE;
1982
1983         camera_cli_s *pc = (camera_cli_s *)camera;
1984         muse_camera_api_e api = MUSE_CAMERA_API_UNSET_PREVIEW_CB;
1985
1986         LOGD("Enter, handle :%x", pc->remote_handle);
1987
1988         int sock_fd;
1989         if (pc->cb_info == NULL) {
1990                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
1991                 return CAMERA_ERROR_INVALID_PARAMETER;
1992         }
1993         sock_fd = pc->cb_info->fd;
1994         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_PREVIEW] = (void *)NULL;
1995         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_PREVIEW] = (void *)NULL;
1996
1997         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1998         LOGD("ret : 0x%x", ret);
1999         return ret;
2000 }
2001
2002 int camera_set_media_packet_preview_cb(camera_h camera, camera_media_packet_preview_cb callback, void* user_data)
2003 {
2004         if (camera == NULL) {
2005                 LOGE("INVALID_PARAMETER(0x%08x) - handle", CAMERA_ERROR_INVALID_PARAMETER);
2006                 return CAMERA_ERROR_INVALID_PARAMETER;
2007         }
2008
2009         if (callback == NULL) {
2010                 LOGE("INVALID_PARAMETER(0x%08x) - callback", CAMERA_ERROR_INVALID_PARAMETER);
2011                 return CAMERA_ERROR_NOT_SUPPORTED;
2012         }
2013
2014         int ret = CAMERA_ERROR_NONE;
2015
2016         camera_cli_s *pc = (camera_cli_s *)camera;
2017         muse_camera_api_e api = MUSE_CAMERA_API_SET_MEDIA_PACKET_PREVIEW_CB;
2018
2019         LOGD("Enter, handle :%x", pc->remote_handle);
2020
2021         int sock_fd;
2022         if (pc->cb_info == NULL) {
2023                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2024                 return CAMERA_ERROR_INVALID_PARAMETER;
2025         }
2026         sock_fd = pc->cb_info->fd;
2027         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_MEDIA_PACKET_PREVIEW] = callback;
2028         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_MEDIA_PACKET_PREVIEW] = user_data;
2029
2030         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2031         LOGD("ret : 0x%x", ret);
2032         return ret;
2033 }
2034
2035 int camera_unset_media_packet_preview_cb(camera_h camera)
2036 {
2037         if (camera == NULL) {
2038                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2039                 return CAMERA_ERROR_INVALID_PARAMETER;
2040         }
2041
2042         int ret = CAMERA_ERROR_NONE;
2043
2044         camera_cli_s *pc = (camera_cli_s *)camera;
2045         muse_camera_api_e api = MUSE_CAMERA_API_UNSET_MEDIA_PACKET_PREVIEW_CB;
2046
2047         LOGD("Enter, handle :%x", pc->remote_handle);
2048
2049         int sock_fd;
2050         if (pc->cb_info == NULL) {
2051                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2052                 return CAMERA_ERROR_INVALID_PARAMETER;
2053         }
2054         sock_fd = pc->cb_info->fd;
2055         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_MEDIA_PACKET_PREVIEW] = (void *)NULL;
2056         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_MEDIA_PACKET_PREVIEW] = (void *)NULL;
2057
2058         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2059         LOGD("ret : 0x%x", ret);
2060         return ret;
2061 }
2062
2063 int camera_set_state_changed_cb(camera_h camera, camera_state_changed_cb callback, void* user_data)
2064 {
2065         if( camera == NULL || callback == NULL){
2066                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2067                 return CAMERA_ERROR_INVALID_PARAMETER;
2068         }
2069         int ret = CAMERA_ERROR_NONE;
2070
2071         camera_cli_s *pc = (camera_cli_s *)camera;
2072         muse_camera_api_e api = MUSE_CAMERA_API_SET_STATE_CHANGED_CB;
2073
2074         LOGD("Enter, handle :%x", pc->remote_handle);
2075
2076         int sock_fd;
2077         if (pc->cb_info == NULL) {
2078                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2079                 return CAMERA_ERROR_INVALID_PARAMETER;
2080         }
2081         sock_fd = pc->cb_info->fd;
2082         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_STATE_CHANGE] = callback;
2083         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_STATE_CHANGE] = user_data;
2084
2085         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2086         LOGD("ret : 0x%x", ret);
2087         return ret;
2088 }
2089 int camera_unset_state_changed_cb(camera_h camera)
2090 {
2091         if( camera == NULL){
2092                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2093                 return CAMERA_ERROR_INVALID_PARAMETER;
2094         }
2095         int ret = CAMERA_ERROR_NONE;
2096
2097         camera_cli_s *pc = (camera_cli_s *)camera;
2098         muse_camera_api_e api = MUSE_CAMERA_API_UNSET_STATE_CHANGED_CB;
2099
2100         LOGD("Enter, handle :%x", pc->remote_handle);
2101
2102         int sock_fd;
2103         if (pc->cb_info == NULL) {
2104                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2105                 return CAMERA_ERROR_INVALID_PARAMETER;
2106         }
2107         sock_fd = pc->cb_info->fd;
2108         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_STATE_CHANGE] = (void *)NULL;
2109         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_STATE_CHANGE] = (void *)NULL;
2110
2111         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2112         LOGD("ret : 0x%x", ret);
2113         return ret;
2114 }
2115
2116 int camera_set_interrupted_cb(camera_h camera, camera_interrupted_cb callback, void *user_data)
2117 {
2118         if( camera == NULL || callback == NULL){
2119                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2120                 return CAMERA_ERROR_INVALID_PARAMETER;
2121         }
2122         int ret = CAMERA_ERROR_NONE;
2123
2124         camera_cli_s *pc = (camera_cli_s *)camera;
2125         muse_camera_api_e api = MUSE_CAMERA_API_SET_INTERRUPTED_CB;
2126
2127         LOGD("Enter, handle :%x", pc->remote_handle);
2128
2129         int sock_fd;
2130         if (pc->cb_info == NULL) {
2131                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2132                 return CAMERA_ERROR_INVALID_PARAMETER;
2133         }
2134         sock_fd = pc->cb_info->fd;
2135         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_INTERRUPTED] = callback;
2136         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_INTERRUPTED] = user_data;
2137
2138         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2139         LOGD("ret : 0x%x", ret);
2140         return ret;
2141 }
2142
2143 int camera_unset_interrupted_cb(camera_h camera)
2144 {
2145         if( camera == NULL){
2146                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2147                 return CAMERA_ERROR_INVALID_PARAMETER;
2148         }
2149         int ret = CAMERA_ERROR_NONE;
2150
2151         camera_cli_s *pc = (camera_cli_s *)camera;
2152         muse_camera_api_e api = MUSE_CAMERA_API_UNSET_INTERRUPTED_CB;
2153
2154         LOGD("Enter, handle :%x", pc->remote_handle);
2155
2156         int sock_fd;
2157         if (pc->cb_info == NULL) {
2158                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2159                 return CAMERA_ERROR_INVALID_PARAMETER;
2160         }
2161         sock_fd = pc->cb_info->fd;
2162         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_INTERRUPTED] = (void *)NULL;
2163         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_INTERRUPTED] = (void *)NULL;
2164
2165         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2166         LOGD("ret : 0x%x", ret);
2167         return ret;
2168 }
2169
2170 int camera_set_focus_changed_cb(camera_h camera, camera_focus_changed_cb callback, void* user_data)
2171 {
2172         if( camera == NULL || callback == NULL){
2173                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2174                 return CAMERA_ERROR_INVALID_PARAMETER;
2175         }
2176         int ret = CAMERA_ERROR_NONE;
2177
2178         camera_cli_s *pc = (camera_cli_s *)camera;
2179         muse_camera_api_e api = MUSE_CAMERA_API_SET_FOCUS_CHANGED_CB;
2180
2181         LOGD("Enter, handle :%x", pc->remote_handle);
2182
2183         int sock_fd;
2184         if (pc->cb_info == NULL) {
2185                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2186                 return CAMERA_ERROR_INVALID_PARAMETER;
2187         }
2188         sock_fd = pc->cb_info->fd;
2189         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = callback;
2190         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = user_data;
2191
2192         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2193         LOGD("ret : 0x%x", ret);
2194         return ret;
2195 }
2196
2197 int camera_unset_focus_changed_cb(camera_h camera)
2198 {
2199         if( camera == NULL){
2200                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2201                 return CAMERA_ERROR_INVALID_PARAMETER;
2202         }
2203         int ret = CAMERA_ERROR_NONE;
2204
2205         camera_cli_s *pc = (camera_cli_s *)camera;
2206         muse_camera_api_e api = MUSE_CAMERA_API_UNSET_FOCUS_CHANGED_CB;
2207
2208         LOGD("Enter, handle :%x", pc->remote_handle);
2209
2210         int sock_fd;
2211         if (pc->cb_info == NULL) {
2212                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2213                 return CAMERA_ERROR_INVALID_PARAMETER;
2214         }
2215         sock_fd = pc->cb_info->fd;
2216         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = (void *)NULL;
2217         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = (void *)NULL;
2218
2219         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2220         LOGD("ret : 0x%x", ret);
2221         return ret;
2222 }
2223
2224 int camera_set_error_cb(camera_h camera, camera_error_cb callback, void *user_data)
2225 {
2226         if( camera == NULL || callback == NULL){
2227                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2228                 return CAMERA_ERROR_INVALID_PARAMETER;
2229         }
2230         int ret = CAMERA_ERROR_NONE;
2231
2232         camera_cli_s *pc = (camera_cli_s *)camera;
2233         muse_camera_api_e api = MUSE_CAMERA_API_SET_ERROR_CB;
2234
2235         LOGD("Enter, handle :%x", pc->remote_handle);
2236
2237         int sock_fd;
2238         if (pc->cb_info == NULL) {
2239                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2240                 return CAMERA_ERROR_INVALID_PARAMETER;
2241         }
2242         sock_fd = pc->cb_info->fd;
2243         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_ERROR] = callback;
2244         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_ERROR] = user_data;
2245
2246         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2247         LOGD("ret : 0x%x", ret);
2248         return ret;
2249 }
2250
2251 int camera_unset_error_cb(camera_h camera)
2252 {
2253         if( camera == NULL){
2254                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2255                 return CAMERA_ERROR_INVALID_PARAMETER;
2256         }
2257         int ret = CAMERA_ERROR_NONE;
2258
2259         camera_cli_s *pc = (camera_cli_s *)camera;
2260         muse_camera_api_e api = MUSE_CAMERA_API_UNSET_ERROR_CB;
2261
2262         LOGD("Enter, handle :%x", pc->remote_handle);
2263
2264         int sock_fd;
2265         if (pc->cb_info == NULL) {
2266                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2267                 return CAMERA_ERROR_INVALID_PARAMETER;
2268         }
2269         sock_fd = pc->cb_info->fd;
2270         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_ERROR] = (void *)NULL;
2271         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_ERROR] = (void *)NULL;
2272
2273         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2274         LOGD("ret : 0x%x", ret);
2275         return ret;
2276 }
2277
2278 int camera_foreach_supported_preview_resolution(camera_h camera, camera_supported_preview_resolution_cb foreach_cb , void *user_data)
2279 {
2280         if( camera == NULL || foreach_cb == NULL){
2281                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2282                 return CAMERA_ERROR_INVALID_PARAMETER;
2283         }
2284         int ret = CAMERA_ERROR_NONE;
2285
2286         camera_cli_s *pc = (camera_cli_s *)camera;
2287         muse_camera_api_e api = MUSE_CAMERA_API_SET_FOREACH_SUPPORTED_PREVIEW_RESOLUTION;
2288
2289         LOGD("Enter, handle :%x", pc->remote_handle);
2290
2291         int sock_fd;
2292         if (pc->cb_info == NULL) {
2293                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2294                 return CAMERA_ERROR_INVALID_PARAMETER;
2295         }
2296         sock_fd = pc->cb_info->fd;
2297         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_RESOLUTION] = foreach_cb;
2298         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_RESOLUTION] = user_data;
2299
2300         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2301         LOGD("ret : 0x%x", ret);
2302         return ret;
2303 }
2304
2305 int camera_foreach_supported_capture_resolution(camera_h camera, camera_supported_capture_resolution_cb foreach_cb , void *user_data)
2306 {
2307         if( camera == NULL || foreach_cb == NULL){
2308                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2309                 return CAMERA_ERROR_INVALID_PARAMETER;
2310         }
2311         int ret = CAMERA_ERROR_NONE;
2312
2313         camera_cli_s *pc = (camera_cli_s *)camera;
2314         muse_camera_api_e api = MUSE_CAMERA_API_SET_FOREACH_SUPPORTED_CAPTURE_RESOLUTION;
2315
2316         LOGD("Enter, handle :%x", pc->remote_handle);
2317
2318         int sock_fd;
2319         if (pc->cb_info == NULL) {
2320                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2321                 return CAMERA_ERROR_INVALID_PARAMETER;
2322         }
2323         sock_fd = pc->cb_info->fd;
2324         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_RESOLUTION] = foreach_cb;
2325         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_RESOLUTION] = user_data;
2326
2327         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2328         LOGD("ret : 0x%x", ret);
2329         return ret;
2330 }
2331
2332 int camera_foreach_supported_capture_format(camera_h camera, camera_supported_capture_format_cb foreach_cb , void *user_data)
2333 {
2334         if( camera == NULL || foreach_cb == NULL){
2335                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2336                 return CAMERA_ERROR_INVALID_PARAMETER;
2337         }
2338         int ret = CAMERA_ERROR_NONE;
2339
2340         camera_cli_s *pc = (camera_cli_s *)camera;
2341         muse_camera_api_e api = MUSE_CAMERA_API_SET_FOREACH_SUPPORTED_CAPTURE_FORMAT;
2342
2343         LOGD("Enter, handle :%x", pc->remote_handle);
2344
2345         int sock_fd;
2346         if (pc->cb_info == NULL) {
2347                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2348                 return CAMERA_ERROR_INVALID_PARAMETER;
2349         }
2350         sock_fd = pc->cb_info->fd;
2351         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_FORMAT] = foreach_cb;
2352         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_FORMAT] = user_data;
2353
2354         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2355         LOGD("ret : 0x%x", ret);
2356         return ret;
2357 }
2358
2359
2360 int camera_foreach_supported_preview_format(camera_h camera, camera_supported_preview_format_cb foreach_cb , void *user_data)
2361 {
2362         if( camera == NULL || foreach_cb == NULL){
2363                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2364                 return CAMERA_ERROR_INVALID_PARAMETER;
2365         }
2366         int ret = CAMERA_ERROR_NONE;
2367
2368         camera_cli_s *pc = (camera_cli_s *)camera;
2369         muse_camera_api_e api = MUSE_CAMERA_API_SET_FOREACH_SUPPORTED_PREVIEW_FORMAT;
2370
2371         LOGD("Enter, handle :%x", pc->remote_handle);
2372
2373         int sock_fd;
2374         if (pc->cb_info == NULL) {
2375                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2376                 return CAMERA_ERROR_INVALID_PARAMETER;
2377         }
2378         sock_fd = pc->cb_info->fd;
2379         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_FORMAT] = foreach_cb;
2380         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_FORMAT] = user_data;
2381
2382         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2383         LOGD("ret : 0x%x", ret);
2384         return ret;
2385 }
2386
2387
2388 int camera_get_recommended_preview_resolution(camera_h camera, int *width, int *height)
2389 {
2390         if (camera == NULL || width == NULL || height == NULL) {
2391                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2392                 return CAMERA_ERROR_INVALID_PARAMETER;
2393         }
2394         int ret = CAMERA_ERROR_NONE;
2395
2396         camera_cli_s *pc = (camera_cli_s *)camera;
2397         muse_camera_api_e api = MUSE_CAMERA_API_GET_RECOMMENDED_PREVIEW_RESOLUTION;
2398         int sock_fd;
2399         if (pc->cb_info == NULL) {
2400                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2401                 return CAMERA_ERROR_INVALID_PARAMETER;
2402         }
2403         sock_fd = pc->cb_info->fd;
2404         int get_width;
2405         int get_height;
2406
2407         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2408         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2409
2410         if (ret == CAMERA_ERROR_NONE) {
2411                 muse_camera_msg_get(get_width, pc->cb_info->recvMsg);
2412                 muse_camera_msg_get(get_height, pc->cb_info->recvMsg);
2413                 *width = get_width;
2414                 *height = get_height;
2415         }
2416         LOGD("ret : 0x%x", ret);
2417         return ret;
2418 }
2419
2420
2421 int camera_attr_get_lens_orientation(camera_h camera, int *angle)
2422 {
2423         if( camera == NULL || angle == NULL){
2424                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2425                 return CAMERA_ERROR_INVALID_PARAMETER;
2426         }
2427         int ret = CAMERA_ERROR_NONE;
2428
2429         camera_cli_s *pc = (camera_cli_s *)camera;
2430         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_LENS_ORIENTATION;
2431         int sock_fd;
2432         if (pc->cb_info == NULL) {
2433                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2434                 return CAMERA_ERROR_INVALID_PARAMETER;
2435         }
2436         sock_fd = pc->cb_info->fd;
2437         int get_angle;
2438
2439         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2440         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2441
2442         if (ret == CAMERA_ERROR_NONE) {
2443                 muse_camera_msg_get(get_angle, pc->cb_info->recvMsg);
2444                 *angle = get_angle;
2445         }
2446         LOGD("ret : 0x%x", ret);
2447         return ret;
2448 }
2449
2450 int camera_attr_set_theater_mode(camera_h camera, camera_attr_theater_mode_e mode)
2451 {
2452         if (camera == NULL) {
2453                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2454                 return CAMERA_ERROR_INVALID_PARAMETER;
2455         }
2456         int ret = CAMERA_ERROR_NONE;
2457         camera_cli_s *pc = (camera_cli_s *)camera;
2458         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_THEATER_MODE;
2459         int sock_fd;
2460         if (pc->cb_info == NULL) {
2461                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2462                 return CAMERA_ERROR_INVALID_PARAMETER;
2463         }
2464         sock_fd = pc->cb_info->fd;
2465         int set_mode = (int)mode;
2466         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2467         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_mode);
2468         LOGD("ret : 0x%x", ret);
2469         return ret;
2470 }
2471
2472 int camera_attr_get_theater_mode(camera_h camera, camera_attr_theater_mode_e *mode)
2473 {
2474         if (camera == NULL || mode == NULL) {
2475                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2476                 return CAMERA_ERROR_INVALID_PARAMETER;
2477         }
2478
2479         int ret = CAMERA_ERROR_NONE;
2480         camera_cli_s *pc = (camera_cli_s *)camera;
2481         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_THEATER_MODE;
2482         int sock_fd;
2483         if (pc->cb_info == NULL) {
2484                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2485                 return CAMERA_ERROR_INVALID_PARAMETER;
2486         }
2487         sock_fd = pc->cb_info->fd;
2488         int get_mode;
2489         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2490         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2491
2492         if (ret == CAMERA_ERROR_NONE) {
2493                 muse_camera_msg_get(get_mode, pc->cb_info->recvMsg);
2494                 *mode = (camera_attr_theater_mode_e)get_mode;
2495         }
2496         LOGD("ret : 0x%x", ret);
2497         return ret;
2498 }
2499
2500 int camera_attr_foreach_supported_theater_mode(camera_h camera, camera_attr_supported_theater_mode_cb foreach_cb, void *user_data)
2501 {
2502         if (camera == NULL || foreach_cb == NULL) {
2503                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2504                 return CAMERA_ERROR_INVALID_PARAMETER;
2505         }
2506         int ret = CAMERA_ERROR_NONE;
2507
2508         camera_cli_s *pc = (camera_cli_s *)camera;
2509         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_THEATER_MODE;
2510
2511         LOGD("Enter, handle :%x", pc->remote_handle);
2512
2513         int sock_fd;
2514         if (pc->cb_info == NULL) {
2515                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2516                 return CAMERA_ERROR_INVALID_PARAMETER;
2517         }
2518         sock_fd = pc->cb_info->fd;
2519         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_THEATER_MODE] = foreach_cb;
2520         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_THEATER_MODE] = user_data;
2521
2522         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2523
2524         LOGD("Finish, return :%x", ret);
2525
2526         return ret;
2527 }
2528
2529 int camera_attr_set_preview_fps(camera_h camera,  camera_attr_fps_e fps)
2530 {
2531         if( camera == NULL){
2532                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2533                 return CAMERA_ERROR_INVALID_PARAMETER;
2534         }
2535         int ret = CAMERA_ERROR_NONE;
2536         camera_cli_s *pc = (camera_cli_s *)camera;
2537         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_PREVIEW_FPS;
2538         int sock_fd;
2539         if (pc->cb_info == NULL) {
2540                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2541                 return CAMERA_ERROR_INVALID_PARAMETER;
2542         }
2543         sock_fd = pc->cb_info->fd;
2544         int set_fps = (int)fps;
2545         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2546         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_fps);
2547         LOGD("ret : 0x%x", ret);
2548         return ret;
2549 }
2550
2551
2552 int camera_attr_set_image_quality(camera_h camera,  int quality)
2553 {
2554         if( camera == NULL){
2555                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2556                 return CAMERA_ERROR_INVALID_PARAMETER;
2557         }
2558         int ret = CAMERA_ERROR_NONE;
2559
2560         camera_cli_s *pc = (camera_cli_s *)camera;
2561         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_IMAGE_QUALITY;
2562         int sock_fd;
2563         if (pc->cb_info == NULL) {
2564                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2565                 return CAMERA_ERROR_INVALID_PARAMETER;
2566         }
2567         sock_fd = pc->cb_info->fd;
2568         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2569         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, quality);
2570         LOGD("ret : 0x%x", ret);
2571         return ret;
2572 }
2573
2574 int camera_attr_get_preview_fps(camera_h camera,  camera_attr_fps_e *fps)
2575 {
2576         if( camera == NULL || fps == NULL){
2577                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2578                 return CAMERA_ERROR_INVALID_PARAMETER;
2579         }
2580         int ret = CAMERA_ERROR_NONE;
2581
2582         camera_cli_s *pc = (camera_cli_s *)camera;
2583         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_PREVIEW_FPS;
2584         int get_fps;
2585         int sock_fd;
2586         if (pc->cb_info == NULL) {
2587                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2588                 return CAMERA_ERROR_INVALID_PARAMETER;
2589         }
2590         sock_fd = pc->cb_info->fd;
2591
2592         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2593         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2594
2595         if (ret == CAMERA_ERROR_NONE) {
2596                 muse_camera_msg_get(get_fps, pc->cb_info->recvMsg);
2597                 *fps = (camera_attr_fps_e)get_fps;
2598         }
2599         LOGD("ret : 0x%x", ret);
2600         return ret;
2601 }
2602
2603
2604 int camera_attr_get_image_quality(camera_h camera, int *quality)
2605 {
2606         if( camera == NULL || quality == NULL){
2607                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2608                 return CAMERA_ERROR_INVALID_PARAMETER;
2609         }
2610         int ret = CAMERA_ERROR_NONE;
2611
2612         camera_cli_s *pc = (camera_cli_s *)camera;
2613         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_IMAGE_QUALITY;
2614         int sock_fd;
2615         if (pc->cb_info == NULL) {
2616                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2617                 return CAMERA_ERROR_INVALID_PARAMETER;
2618         }
2619         sock_fd = pc->cb_info->fd;
2620         int get_quality;
2621         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2622         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2623
2624         if (ret == CAMERA_ERROR_NONE) {
2625                 muse_camera_msg_get(get_quality, pc->cb_info->recvMsg);
2626                 *quality = get_quality;
2627         }
2628         LOGD("ret : 0x%x", ret);
2629         return ret;
2630 }
2631
2632
2633 int camera_attr_set_zoom(camera_h camera, int zoom)
2634 {
2635         if( camera == NULL){
2636                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2637                 return CAMERA_ERROR_INVALID_PARAMETER;
2638         }
2639         int ret = CAMERA_ERROR_NONE;
2640
2641         camera_cli_s *pc = (camera_cli_s *)camera;
2642         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_ZOOM;
2643         int sock_fd;
2644         if (pc->cb_info == NULL) {
2645                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2646                 return CAMERA_ERROR_INVALID_PARAMETER;
2647         }
2648         sock_fd = pc->cb_info->fd;
2649
2650         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2651         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, zoom);
2652         LOGD("ret : 0x%x", ret);
2653         return ret;
2654 }
2655
2656 int camera_attr_set_af_mode(camera_h camera,  camera_attr_af_mode_e mode)
2657 {
2658         if( camera == NULL){
2659                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2660                 return CAMERA_ERROR_INVALID_PARAMETER;
2661         }
2662         int ret = CAMERA_ERROR_NONE;
2663
2664         camera_cli_s *pc = (camera_cli_s *)camera;
2665         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_AF_MODE;
2666         int sock_fd;
2667         if (pc->cb_info == NULL) {
2668                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2669                 return CAMERA_ERROR_INVALID_PARAMETER;
2670         }
2671         sock_fd = pc->cb_info->fd;
2672         int set_mode = (int)mode;
2673         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2674         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_mode);
2675         LOGD("ret : 0x%x", ret);
2676         return ret;
2677 }
2678
2679 int camera_attr_set_af_area(camera_h camera, int x, int y)
2680 {
2681         if( camera == NULL){
2682                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2683                 return CAMERA_ERROR_INVALID_PARAMETER;
2684         }
2685         int ret = CAMERA_ERROR_NONE;
2686         camera_cli_s *pc = (camera_cli_s *)camera;
2687         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_AF_AREA;
2688         int sock_fd = pc->cb_info->fd;
2689         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2690         muse_camera_msg_send2(api, sock_fd, pc->cb_info, ret, INT, x, INT, y);
2691         LOGD("ret : 0x%x", ret);
2692         return ret;
2693 }
2694
2695
2696 int camera_attr_clear_af_area(camera_h camera)
2697 {
2698         if( camera == NULL){
2699                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2700                 return CAMERA_ERROR_INVALID_PARAMETER;
2701         }
2702         int ret = CAMERA_ERROR_NONE;
2703
2704         camera_cli_s *pc = (camera_cli_s *)camera;
2705         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_CLEAR_AF_AREA;
2706         int sock_fd;
2707         if (pc->cb_info == NULL) {
2708                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2709                 return CAMERA_ERROR_INVALID_PARAMETER;
2710         }
2711         sock_fd = pc->cb_info->fd;
2712         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2713         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2714         LOGD("ret : 0x%x", ret);
2715         return ret;
2716 }
2717
2718
2719 int camera_attr_set_exposure_mode(camera_h camera,  camera_attr_exposure_mode_e mode)
2720 {
2721         if( camera == NULL){
2722                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2723                 return CAMERA_ERROR_INVALID_PARAMETER;
2724         }
2725
2726         if (mode < CAMERA_ATTR_EXPOSURE_MODE_OFF || mode > CAMERA_ATTR_EXPOSURE_MODE_CUSTOM) {
2727                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_NOT_SUPPORTED);
2728                 return CAMERA_ERROR_NOT_SUPPORTED;
2729         }
2730
2731         int ret = CAMERA_ERROR_NONE;
2732         camera_cli_s *pc = (camera_cli_s *)camera;
2733         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_EXPOSURE_MODE;
2734         int set_mode = (int)mode;
2735         int sock_fd;
2736         if (pc->cb_info == NULL) {
2737                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2738                 return CAMERA_ERROR_INVALID_PARAMETER;
2739         }
2740         sock_fd = pc->cb_info->fd;
2741         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2742         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_mode);
2743         LOGD("ret : 0x%x", ret);
2744         return ret;
2745 }
2746
2747
2748 int camera_attr_set_exposure(camera_h camera, int value)
2749 {
2750         if( camera == NULL){
2751                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2752                 return CAMERA_ERROR_INVALID_PARAMETER;
2753         }
2754         int ret = CAMERA_ERROR_NONE;
2755
2756         camera_cli_s *pc = (camera_cli_s *)camera;
2757         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_EXPOSURE;
2758         int sock_fd;
2759         if (pc->cb_info == NULL) {
2760                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2761                 return CAMERA_ERROR_INVALID_PARAMETER;
2762         }
2763         sock_fd = pc->cb_info->fd;
2764
2765         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2766         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, value);
2767         LOGD("ret : 0x%x", ret);
2768         return ret;
2769 }
2770
2771
2772 int camera_attr_set_iso(camera_h camera, camera_attr_iso_e iso)
2773 {
2774         if( camera == NULL){
2775                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2776                 return CAMERA_ERROR_INVALID_PARAMETER;
2777         }
2778         int ret = CAMERA_ERROR_NONE;
2779
2780         camera_cli_s *pc = (camera_cli_s *)camera;
2781         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_ISO;
2782         int sock_fd;
2783         if (pc->cb_info == NULL) {
2784                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2785                 return CAMERA_ERROR_INVALID_PARAMETER;
2786         }
2787         sock_fd = pc->cb_info->fd;
2788         int set_iso = (int)iso;
2789         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2790         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_iso);
2791         LOGD("ret : 0x%x", ret);
2792         return ret;
2793 }
2794
2795
2796 int camera_attr_set_brightness(camera_h camera, int level)
2797 {
2798         if( camera == NULL){
2799                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2800                 return CAMERA_ERROR_INVALID_PARAMETER;
2801         }
2802         int ret = CAMERA_ERROR_NONE;
2803
2804         camera_cli_s *pc = (camera_cli_s *)camera;
2805         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_BRIGHTNESS;
2806         int sock_fd;
2807         if (pc->cb_info == NULL) {
2808                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2809                 return CAMERA_ERROR_INVALID_PARAMETER;
2810         }
2811         sock_fd = pc->cb_info->fd;
2812
2813         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2814         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, level);
2815         LOGD("ret : 0x%x", ret);
2816         return ret;
2817 }
2818
2819
2820 int camera_attr_set_contrast(camera_h camera, int level)
2821 {
2822         if( camera == NULL){
2823                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2824                 return CAMERA_ERROR_INVALID_PARAMETER;
2825         }
2826         int ret = CAMERA_ERROR_NONE;
2827
2828         camera_cli_s *pc = (camera_cli_s *)camera;
2829         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_CONTRAST;
2830         int sock_fd;
2831         if (pc->cb_info == NULL) {
2832                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2833                 return CAMERA_ERROR_INVALID_PARAMETER;
2834         }
2835         sock_fd = pc->cb_info->fd;
2836
2837         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2838         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, level);
2839         LOGD("ret : 0x%x", ret);
2840         return ret;
2841 }
2842
2843
2844 int camera_attr_set_whitebalance(camera_h camera, camera_attr_whitebalance_e wb)
2845 {
2846         if (camera == NULL) {
2847                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2848                 return CAMERA_ERROR_INVALID_PARAMETER;
2849         }
2850
2851         if (wb < CAMERA_ATTR_WHITE_BALANCE_NONE || wb > CAMERA_ATTR_WHITE_BALANCE_CUSTOM) {
2852                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_NOT_SUPPORTED);
2853                 return CAMERA_ERROR_NOT_SUPPORTED;
2854         }
2855
2856         int ret = CAMERA_ERROR_NONE;
2857
2858         camera_cli_s *pc = (camera_cli_s *)camera;
2859         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_WHITEBALANCE;
2860         int sock_fd;
2861         if (pc->cb_info == NULL) {
2862                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2863                 return CAMERA_ERROR_INVALID_PARAMETER;
2864         }
2865         sock_fd = pc->cb_info->fd;
2866         int set_whitebalance = (int)wb;
2867         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2868         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_whitebalance);
2869         LOGD("ret : 0x%x", ret);
2870         return ret;
2871 }
2872
2873
2874 int camera_attr_set_effect(camera_h camera, camera_attr_effect_mode_e effect)
2875 {
2876         if( camera == NULL){
2877                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2878                 return CAMERA_ERROR_INVALID_PARAMETER;
2879         }
2880         int ret = CAMERA_ERROR_NONE;
2881
2882         camera_cli_s *pc = (camera_cli_s *)camera;
2883         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_EFFECT;
2884         int sock_fd;
2885         if (pc->cb_info == NULL) {
2886                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2887                 return CAMERA_ERROR_INVALID_PARAMETER;
2888         }
2889         sock_fd = pc->cb_info->fd;
2890         int set_effect = (int)effect;
2891         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2892         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_effect);
2893         LOGD("ret : 0x%x", ret);
2894         return ret;
2895 }
2896
2897
2898 int camera_attr_set_scene_mode(camera_h camera, camera_attr_scene_mode_e mode)
2899 {
2900         if( camera == NULL){
2901                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2902                 return CAMERA_ERROR_INVALID_PARAMETER;
2903         }
2904         int ret = CAMERA_ERROR_NONE;
2905
2906         camera_cli_s *pc = (camera_cli_s *)camera;
2907         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_SCENE_MODE;
2908         int sock_fd;
2909         if (pc->cb_info == NULL) {
2910                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2911                 return CAMERA_ERROR_INVALID_PARAMETER;
2912         }
2913         sock_fd = pc->cb_info->fd;
2914         int set_mode = (int)mode;
2915         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2916         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_mode);
2917         LOGD("ret : 0x%x", ret);
2918         return ret;
2919 }
2920
2921
2922 int camera_attr_enable_tag(camera_h camera, bool enable)
2923 {
2924         if( camera == NULL){
2925                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2926                 return CAMERA_ERROR_INVALID_PARAMETER;
2927         }
2928         int ret = CAMERA_ERROR_NONE;
2929         camera_cli_s *pc = (camera_cli_s *)camera;
2930         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_ENABLE_TAG;
2931         int sock_fd;
2932         if (pc->cb_info == NULL) {
2933                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2934                 return CAMERA_ERROR_INVALID_PARAMETER;
2935         }
2936         sock_fd = pc->cb_info->fd;
2937         int set_enable = (int)enable;
2938
2939         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2940         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_enable);
2941         LOGD("ret : 0x%x", ret);
2942         return ret;
2943 }
2944
2945
2946 int camera_attr_set_tag_image_description(camera_h camera, const char *description)
2947 {
2948         if( camera == NULL){
2949                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2950                 return CAMERA_ERROR_INVALID_PARAMETER;
2951         }
2952         if( description == NULL){
2953                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2954                 return CAMERA_ERROR_INVALID_PARAMETER;
2955         }
2956         int ret = CAMERA_ERROR_NONE;
2957         camera_cli_s *pc = (camera_cli_s *)camera;
2958         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_TAG_IMAGE_DESCRIPTION;
2959         int sock_fd;
2960         if (pc->cb_info == NULL) {
2961                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2962                 return CAMERA_ERROR_INVALID_PARAMETER;
2963         }
2964         sock_fd = pc->cb_info->fd;
2965         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2966         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, STRING, description);
2967         LOGD("ret : 0x%x", ret);
2968         return ret;
2969 }
2970
2971
2972 int camera_attr_set_tag_orientation(camera_h camera,  camera_attr_tag_orientation_e orientation)
2973 {
2974         if( camera == NULL){
2975                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2976                 return CAMERA_ERROR_INVALID_PARAMETER;
2977         }
2978         int ret = CAMERA_ERROR_NONE;
2979         camera_cli_s *pc = (camera_cli_s *)camera;
2980         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_TAG_ORIENTATION;
2981         int sock_fd;
2982         if (pc->cb_info == NULL) {
2983                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
2984                 return CAMERA_ERROR_INVALID_PARAMETER;
2985         }
2986         sock_fd = pc->cb_info->fd;
2987         int set_orientation = (int)orientation;
2988
2989         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2990         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_orientation);
2991         LOGD("ret : 0x%x", ret);
2992         return ret;
2993 }
2994
2995
2996 int camera_attr_set_tag_software(camera_h camera,  const char *software)
2997 {
2998         if( camera == NULL){
2999                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3000                 return CAMERA_ERROR_INVALID_PARAMETER;
3001         }
3002         if( software == NULL){
3003                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3004                 return CAMERA_ERROR_INVALID_PARAMETER;
3005         }
3006         int ret = CAMERA_ERROR_NONE;
3007         camera_cli_s *pc = (camera_cli_s *)camera;
3008         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_TAG_SOFTWARE;
3009         int sock_fd;
3010         if (pc->cb_info == NULL) {
3011                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3012                 return CAMERA_ERROR_INVALID_PARAMETER;
3013         }
3014         sock_fd = pc->cb_info->fd;
3015         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3016         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, STRING, software);
3017         LOGD("ret : 0x%x", ret);
3018         return ret;
3019 }
3020
3021
3022 int camera_attr_set_geotag(camera_h camera, double latitude , double longitude, double altitude)
3023 {
3024         if( camera == NULL){
3025                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3026                 return CAMERA_ERROR_INVALID_PARAMETER;
3027         }
3028         int ret = CAMERA_ERROR_NONE;
3029         camera_cli_s *pc = (camera_cli_s *)camera;
3030         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_GEOTAG;
3031         int sock_fd;
3032         if (pc->cb_info == NULL) {
3033                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3034                 return CAMERA_ERROR_INVALID_PARAMETER;
3035         }
3036         sock_fd = pc->cb_info->fd;
3037         double set_geotag[3] = { latitude, longitude, altitude };
3038
3039         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3040         muse_camera_msg_send_array(api, sock_fd, pc->cb_info, ret,
3041                                                                         set_geotag, sizeof(set_geotag), sizeof(double));
3042         LOGD("ret : 0x%x", ret);
3043         return ret;
3044 }
3045
3046
3047 int camera_attr_remove_geotag(camera_h camera)
3048 {
3049         if( camera == NULL){
3050                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3051                 return CAMERA_ERROR_INVALID_PARAMETER;
3052         }
3053         int ret = CAMERA_ERROR_NONE;
3054         camera_cli_s *pc = (camera_cli_s *)camera;
3055         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_REMOVE_GEOTAG;
3056         int sock_fd;
3057         if (pc->cb_info == NULL) {
3058                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3059                 return CAMERA_ERROR_INVALID_PARAMETER;
3060         }
3061         sock_fd = pc->cb_info->fd;
3062         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3063         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3064         LOGD("ret : 0x%x", ret);
3065         return ret;
3066 }
3067
3068
3069 int camera_attr_set_flash_mode(camera_h camera, camera_attr_flash_mode_e mode)
3070 {
3071         if( camera == NULL){
3072                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3073                 return CAMERA_ERROR_INVALID_PARAMETER;
3074         }
3075         int ret = CAMERA_ERROR_NONE;
3076         camera_cli_s *pc = (camera_cli_s *)camera;
3077         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_FLASH_MODE;
3078         int sock_fd;
3079         if (pc->cb_info == NULL) {
3080                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3081                 return CAMERA_ERROR_INVALID_PARAMETER;
3082         }
3083         sock_fd = pc->cb_info->fd;
3084         int set_mode = (int)mode;
3085
3086         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3087         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_mode);
3088         LOGD("ret : 0x%x", ret);
3089         return ret;
3090 }
3091
3092
3093 int camera_attr_get_zoom(camera_h camera, int *zoom)
3094 {
3095         if( camera == NULL || zoom == NULL){
3096                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3097                 return CAMERA_ERROR_INVALID_PARAMETER;
3098         }
3099         int ret = CAMERA_ERROR_NONE;
3100
3101         camera_cli_s *pc = (camera_cli_s *)camera;
3102         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_ZOOM;
3103         int get_zoom;
3104         int sock_fd;
3105         if (pc->cb_info == NULL) {
3106                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3107                 return CAMERA_ERROR_INVALID_PARAMETER;
3108         }
3109         sock_fd = pc->cb_info->fd;
3110
3111         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3112         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3113
3114         if (ret == CAMERA_ERROR_NONE) {
3115                 muse_camera_msg_get(get_zoom, pc->cb_info->recvMsg);
3116                 *zoom = get_zoom;
3117         }
3118         LOGD("ret : 0x%x", ret);
3119         return ret;
3120 }
3121
3122
3123 int camera_attr_get_zoom_range(camera_h camera, int *min, int *max)
3124 {
3125         if( camera == NULL || min == NULL || max == NULL ){
3126                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3127                 return CAMERA_ERROR_INVALID_PARAMETER;
3128         }
3129         int ret = CAMERA_ERROR_NONE;
3130         camera_cli_s *pc = (camera_cli_s *)camera;
3131         int sock_fd;
3132         if (pc->cb_info == NULL) {
3133                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3134                 return CAMERA_ERROR_INVALID_PARAMETER;
3135         }
3136         sock_fd = pc->cb_info->fd;
3137         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_ZOOM_RANGE;
3138         int get_min;
3139         int get_max;
3140
3141         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3142         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3143
3144         if (ret == CAMERA_ERROR_NONE) {
3145                 muse_camera_msg_get(get_min, pc->cb_info->recvMsg);
3146                 muse_camera_msg_get(get_max, pc->cb_info->recvMsg);
3147                 *min = get_min;
3148                 *max = get_max;
3149         }
3150         LOGD("ret : 0x%x", ret);
3151         return ret;
3152 }
3153
3154
3155 int camera_attr_get_af_mode( camera_h camera,  camera_attr_af_mode_e *mode)
3156 {
3157         if( camera == NULL || mode == NULL){
3158                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3159                 return CAMERA_ERROR_INVALID_PARAMETER;
3160         }
3161         int ret = CAMERA_ERROR_NONE;
3162         camera_cli_s *pc = (camera_cli_s *)camera;
3163         int sock_fd;
3164         if (pc->cb_info == NULL) {
3165                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3166                 return CAMERA_ERROR_INVALID_PARAMETER;
3167         }
3168         sock_fd = pc->cb_info->fd;
3169         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_AF_MODE;
3170         int get_mode;
3171
3172         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3173         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3174
3175         if (ret == CAMERA_ERROR_NONE) {
3176                 muse_camera_msg_get(get_mode, pc->cb_info->recvMsg);
3177                 *mode = (camera_attr_af_mode_e)get_mode;
3178         }
3179         LOGD("ret : 0x%x", ret);
3180         return ret;
3181 }
3182
3183
3184 int camera_attr_get_exposure_mode( camera_h camera, camera_attr_exposure_mode_e *mode)
3185 {
3186         if( camera == NULL|| mode == NULL){
3187                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3188                 return CAMERA_ERROR_INVALID_PARAMETER;
3189         }
3190         int ret = CAMERA_ERROR_NONE;
3191         camera_cli_s *pc = (camera_cli_s *)camera;
3192         int sock_fd;
3193         if (pc->cb_info == NULL) {
3194                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3195                 return CAMERA_ERROR_INVALID_PARAMETER;
3196         }
3197         sock_fd = pc->cb_info->fd;
3198         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_EXPOSURE_MODE;
3199         int get_mode;
3200
3201         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3202         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3203
3204         if (ret == CAMERA_ERROR_NONE) {
3205                 muse_camera_msg_get(get_mode, pc->cb_info->recvMsg);
3206                 *mode = (camera_attr_exposure_mode_e)get_mode;
3207         }
3208         LOGD("ret : 0x%x", ret);
3209         return ret;
3210 }
3211
3212 int camera_attr_get_exposure(camera_h camera, int *value)
3213 {
3214         if( camera == NULL || value == NULL){
3215                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3216                 return CAMERA_ERROR_INVALID_PARAMETER;
3217         }
3218         int ret = CAMERA_ERROR_NONE;
3219         camera_cli_s *pc = (camera_cli_s *)camera;
3220         int sock_fd;
3221         if (pc->cb_info == NULL) {
3222                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3223                 return CAMERA_ERROR_INVALID_PARAMETER;
3224         }
3225         sock_fd = pc->cb_info->fd;
3226         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_EXPOSURE;
3227         int get_value;
3228
3229         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3230         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3231
3232         if (ret == CAMERA_ERROR_NONE) {
3233                 muse_camera_msg_get(get_value, pc->cb_info->recvMsg);
3234                 *value = get_value;
3235         }
3236         LOGD("ret : 0x%x", ret);
3237         return ret;
3238 }
3239
3240
3241 int camera_attr_get_exposure_range(camera_h camera, int *min, int *max)
3242 {
3243         if( camera == NULL || min == NULL || max == NULL ){
3244                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3245                 return CAMERA_ERROR_INVALID_PARAMETER;
3246         }
3247         int ret = CAMERA_ERROR_NONE;
3248         camera_cli_s *pc = (camera_cli_s *)camera;
3249         int sock_fd;
3250         if (pc->cb_info == NULL) {
3251                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3252                 return CAMERA_ERROR_INVALID_PARAMETER;
3253         }
3254         sock_fd = pc->cb_info->fd;
3255         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_EXPOSURE_RANGE;
3256         int get_min;
3257         int get_max;
3258
3259         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3260         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3261
3262         if (ret == CAMERA_ERROR_NONE) {
3263                 muse_camera_msg_get(get_min, pc->cb_info->recvMsg);
3264                 muse_camera_msg_get(get_max, pc->cb_info->recvMsg);
3265                 *min = get_min;
3266                 *max = get_max;
3267         }
3268         LOGD("ret : 0x%x", ret);
3269         return ret;
3270 }
3271
3272
3273 int camera_attr_get_iso( camera_h camera,  camera_attr_iso_e *iso)
3274 {
3275         if( camera == NULL || iso == NULL){
3276                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3277                 return CAMERA_ERROR_INVALID_PARAMETER;
3278         }
3279         int ret = CAMERA_ERROR_NONE;
3280         camera_cli_s *pc = (camera_cli_s *)camera;
3281         int sock_fd;
3282         if (pc->cb_info == NULL) {
3283                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3284                 return CAMERA_ERROR_INVALID_PARAMETER;
3285         }
3286         sock_fd = pc->cb_info->fd;
3287         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_ISO;
3288         int get_iso;
3289
3290         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3291         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3292
3293         if (ret == CAMERA_ERROR_NONE) {
3294                 muse_camera_msg_get(get_iso, pc->cb_info->recvMsg);
3295                 *iso = (camera_attr_iso_e)get_iso;
3296         }
3297         LOGD("ret : 0x%x", ret);
3298         return ret;
3299 }
3300
3301
3302 int camera_attr_get_brightness(camera_h camera,  int *level)
3303 {
3304         if( camera == NULL || level == NULL){
3305                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3306                 return CAMERA_ERROR_INVALID_PARAMETER;
3307         }
3308         int ret = CAMERA_ERROR_NONE;
3309         camera_cli_s *pc = (camera_cli_s *)camera;
3310         int sock_fd;
3311         if (pc->cb_info == NULL) {
3312                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3313                 return CAMERA_ERROR_INVALID_PARAMETER;
3314         }
3315         sock_fd = pc->cb_info->fd;
3316         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_BRIGHTNESS;
3317         int get_level;
3318
3319         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3320         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3321
3322         if (ret == CAMERA_ERROR_NONE) {
3323                 muse_camera_msg_get(get_level, pc->cb_info->recvMsg);
3324                 *level = get_level;
3325         }
3326         LOGD("ret : 0x%x", ret);
3327         return ret;
3328 }
3329
3330
3331 int camera_attr_get_brightness_range(camera_h camera, int *min, int *max)
3332 {
3333         if( camera == NULL || min == NULL || max == NULL ){
3334                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3335                 return CAMERA_ERROR_INVALID_PARAMETER;
3336         }
3337         int ret = CAMERA_ERROR_NONE;
3338         camera_cli_s *pc = (camera_cli_s *)camera;
3339         int sock_fd;
3340         if (pc->cb_info == NULL) {
3341                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3342                 return CAMERA_ERROR_INVALID_PARAMETER;
3343         }
3344         sock_fd = pc->cb_info->fd;
3345         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_BRIGHTNESS_RANGE;
3346         int get_min;
3347         int get_max;
3348
3349         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3350         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3351
3352         if (ret == CAMERA_ERROR_NONE) {
3353                 muse_camera_msg_get(get_min, pc->cb_info->recvMsg);
3354                 muse_camera_msg_get(get_max, pc->cb_info->recvMsg);
3355                 *min = get_min;
3356                 *max = get_max;
3357         }
3358         LOGD("ret : 0x%x", ret);
3359         return ret;
3360 }
3361
3362
3363 int camera_attr_get_contrast(camera_h camera,  int *level)
3364 {
3365         if( camera == NULL || level == NULL){
3366                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3367                 return CAMERA_ERROR_INVALID_PARAMETER;
3368         }
3369         int ret = CAMERA_ERROR_NONE;
3370         camera_cli_s *pc = (camera_cli_s *)camera;
3371         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_CONTRAST;
3372         int sock_fd;
3373         if (pc->cb_info == NULL) {
3374                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3375                 return CAMERA_ERROR_INVALID_PARAMETER;
3376         }
3377         sock_fd = pc->cb_info->fd;
3378         int get_level;
3379
3380         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3381         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3382
3383         if (ret == CAMERA_ERROR_NONE) {
3384                 muse_camera_msg_get(get_level, pc->cb_info->recvMsg);
3385                 *level = get_level;
3386         }
3387         LOGD("ret : 0x%x", ret);
3388         return ret;
3389 }
3390
3391
3392 int camera_attr_get_contrast_range(camera_h camera, int *min , int *max)
3393 {
3394         if( camera == NULL || min == NULL || max == NULL ){
3395                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3396                 return CAMERA_ERROR_INVALID_PARAMETER;
3397         }
3398         int ret = CAMERA_ERROR_NONE;
3399         camera_cli_s *pc = (camera_cli_s *)camera;
3400         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_CONTRAST_RANGE;
3401         int sock_fd;
3402         if (pc->cb_info == NULL) {
3403                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3404                 return CAMERA_ERROR_INVALID_PARAMETER;
3405         }
3406         sock_fd = pc->cb_info->fd;
3407         int get_min;
3408         int get_max;
3409
3410         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3411         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3412
3413         if (ret == CAMERA_ERROR_NONE) {
3414                 muse_camera_msg_get(get_min, pc->cb_info->recvMsg);
3415                 muse_camera_msg_get(get_max, pc->cb_info->recvMsg);
3416                 *min = get_min;
3417                 *max = get_max;
3418         }
3419         LOGD("ret : 0x%x", ret);
3420         return ret;
3421 }
3422
3423
3424 int camera_attr_get_whitebalance(camera_h camera,  camera_attr_whitebalance_e *wb)
3425 {
3426         if( camera == NULL || wb == NULL){
3427                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3428                 return CAMERA_ERROR_INVALID_PARAMETER;
3429         }
3430         int ret = CAMERA_ERROR_NONE;
3431         camera_cli_s *pc = (camera_cli_s *)camera;
3432         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_WHITEBALANCE;
3433         int sock_fd;
3434         if (pc->cb_info == NULL) {
3435                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3436                 return CAMERA_ERROR_INVALID_PARAMETER;
3437         }
3438         sock_fd = pc->cb_info->fd;
3439         int get_wb;
3440
3441         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3442         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3443
3444         if (ret == CAMERA_ERROR_NONE) {
3445                 muse_camera_msg_get(get_wb, pc->cb_info->recvMsg);
3446                 *wb = (camera_attr_whitebalance_e)get_wb;
3447         }
3448         LOGD("ret : 0x%x", ret);
3449         return ret;
3450 }
3451
3452
3453 int camera_attr_get_effect(camera_h camera, camera_attr_effect_mode_e *effect)
3454 {
3455         if( camera == NULL || effect == NULL ){
3456                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3457                 return CAMERA_ERROR_INVALID_PARAMETER;
3458         }
3459
3460         int ret = CAMERA_ERROR_NONE;
3461         camera_cli_s *pc = (camera_cli_s *)camera;
3462         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_EFFECT;
3463         int sock_fd;
3464         if (pc->cb_info == NULL) {
3465                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3466                 return CAMERA_ERROR_INVALID_PARAMETER;
3467         }
3468         sock_fd = pc->cb_info->fd;
3469         int get_effect;
3470
3471         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3472         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3473
3474         if (ret == CAMERA_ERROR_NONE) {
3475                 muse_camera_msg_get(get_effect, pc->cb_info->recvMsg);
3476                 *effect = (camera_attr_effect_mode_e)get_effect;
3477         }
3478         LOGD("ret : 0x%x", ret);
3479         return ret;
3480 }
3481
3482
3483 int camera_attr_get_scene_mode(camera_h camera,  camera_attr_scene_mode_e *mode)
3484 {
3485         if( camera == NULL || mode == NULL){
3486                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3487                 return CAMERA_ERROR_INVALID_PARAMETER;
3488         }
3489
3490         int ret = CAMERA_ERROR_NONE;
3491         camera_cli_s *pc = (camera_cli_s *)camera;
3492         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_SCENE_MODE;
3493         int sock_fd;
3494         if (pc->cb_info == NULL) {
3495                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3496                 return CAMERA_ERROR_INVALID_PARAMETER;
3497         }
3498         sock_fd = pc->cb_info->fd;
3499         int get_mode;
3500
3501         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3502         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3503
3504         if (ret == CAMERA_ERROR_NONE) {
3505                 muse_camera_msg_get(get_mode, pc->cb_info->recvMsg);
3506                 *mode = (camera_attr_scene_mode_e)get_mode;
3507         }
3508         LOGD("ret : 0x%x", ret);
3509         return ret;
3510 }
3511
3512
3513 int camera_attr_is_enabled_tag(camera_h camera,  bool *enable)
3514 {
3515         if( camera == NULL || enable == NULL){
3516                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3517                 return CAMERA_ERROR_INVALID_PARAMETER;
3518         }
3519
3520         int ret = CAMERA_ERROR_NONE;
3521         camera_cli_s *pc = (camera_cli_s *)camera;
3522         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_ENABLED_TAG;
3523         int sock_fd;
3524         if (pc->cb_info == NULL) {
3525                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3526                 return CAMERA_ERROR_INVALID_PARAMETER;
3527         }
3528         sock_fd = pc->cb_info->fd;
3529         int get_enabled;
3530
3531         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3532         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3533
3534         if (ret == CAMERA_ERROR_NONE) {
3535                 muse_camera_msg_get(get_enabled, pc->cb_info->recvMsg);
3536                 *enable = (bool)get_enabled;
3537         }
3538         LOGD("ret : 0x%x", ret);
3539         return ret;
3540 }
3541
3542
3543 int camera_attr_get_tag_image_description(camera_h camera,  char **description)
3544 {
3545         if( camera == NULL || description == NULL){
3546                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3547                 return CAMERA_ERROR_INVALID_PARAMETER;
3548         }
3549
3550         int ret = CAMERA_ERROR_NONE;
3551         camera_cli_s *pc = (camera_cli_s *)camera;
3552         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_TAG_IMAGE_DESCRIPTION;
3553         int sock_fd;
3554         if (pc->cb_info == NULL) {
3555                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3556                 return CAMERA_ERROR_INVALID_PARAMETER;
3557         }
3558         sock_fd = pc->cb_info->fd;
3559         char get_description[MUSE_CAMERA_MSG_MAX_LENGTH] = {0,};
3560
3561         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3562         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3563
3564         if (ret == CAMERA_ERROR_NONE) {
3565                 muse_camera_msg_get_string(get_description, pc->cb_info->recvMsg);
3566                 *description = strdup(get_description);
3567         }
3568         LOGD("ret : 0x%x", ret);
3569         return ret;
3570 }
3571
3572
3573 int camera_attr_get_tag_orientation(camera_h camera, camera_attr_tag_orientation_e *orientation)
3574 {
3575         if( camera == NULL || orientation == NULL){
3576                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3577                 return CAMERA_ERROR_INVALID_PARAMETER;
3578         }
3579
3580         int ret = CAMERA_ERROR_NONE;
3581         camera_cli_s *pc = (camera_cli_s *)camera;
3582         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_TAG_ORIENTATION;
3583         int sock_fd;
3584         if (pc->cb_info == NULL) {
3585                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3586                 return CAMERA_ERROR_INVALID_PARAMETER;
3587         }
3588         sock_fd = pc->cb_info->fd;
3589         int get_orientation;
3590
3591         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3592         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3593
3594         if (ret == CAMERA_ERROR_NONE) {
3595                 muse_camera_msg_get(get_orientation, pc->cb_info->recvMsg);
3596                 *orientation = (camera_attr_tag_orientation_e)get_orientation;
3597                 LOGD("success, orientation : %d", *orientation);
3598         }
3599         LOGD("ret : 0x%x", ret);
3600         return ret;
3601 }
3602
3603
3604 int camera_attr_get_tag_software(camera_h camera, char **software)
3605 {
3606         if( camera == NULL || software == NULL ){
3607                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3608                 return CAMERA_ERROR_INVALID_PARAMETER;
3609         }
3610
3611         int ret = CAMERA_ERROR_NONE;
3612         camera_cli_s *pc = (camera_cli_s *)camera;
3613         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_TAG_SOFTWARE;
3614         int sock_fd;
3615         if (pc->cb_info == NULL) {
3616                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3617                 return CAMERA_ERROR_INVALID_PARAMETER;
3618         }
3619         sock_fd = pc->cb_info->fd;
3620         char get_software[MUSE_CAMERA_MSG_MAX_LENGTH] = {0,};
3621
3622         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3623         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3624
3625         if (ret == CAMERA_ERROR_NONE) {
3626                 muse_camera_msg_get_string(get_software, pc->cb_info->recvMsg);
3627                 *software = strdup(get_software);
3628         }
3629         LOGD("ret : 0x%x", ret);
3630         return ret;
3631 }
3632
3633
3634 int camera_attr_get_geotag(camera_h camera, double *latitude , double *longitude, double *altitude)
3635 {
3636         if( camera == NULL || latitude == NULL || longitude == NULL || altitude == NULL){
3637                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3638                 return CAMERA_ERROR_INVALID_PARAMETER;
3639         }
3640
3641         int ret = CAMERA_ERROR_NONE;
3642         camera_cli_s *pc = (camera_cli_s *)camera;
3643         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_GEOTAG;
3644         double get_geotag[3] = {0,};
3645         int sock_fd;
3646         if (pc->cb_info == NULL) {
3647                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3648                 return CAMERA_ERROR_INVALID_PARAMETER;
3649         }
3650         sock_fd = pc->cb_info->fd;
3651         int valid = 0;
3652         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3653         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3654
3655         if (ret == CAMERA_ERROR_NONE) {
3656                 muse_camera_msg_get_array(get_geotag, pc->cb_info->recvMsg);
3657                 *latitude = get_geotag[0];
3658                 *longitude = get_geotag[1];
3659                 *altitude = get_geotag[2];
3660         } else {
3661                 LOGE("Returned value is not valid : 0x%x", valid);
3662         }
3663
3664         LOGD("ret : 0x%x", ret);
3665
3666         return ret;
3667 }
3668
3669
3670 int camera_attr_get_flash_mode(camera_h camera,  camera_attr_flash_mode_e *mode)
3671 {
3672         if( camera == NULL || mode == NULL){
3673                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3674                 return CAMERA_ERROR_INVALID_PARAMETER;
3675         }
3676
3677         int ret = CAMERA_ERROR_NONE;
3678         camera_cli_s *pc = (camera_cli_s *)camera;
3679         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_FLASH_MODE;
3680         int sock_fd;
3681         if (pc->cb_info == NULL) {
3682                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3683                 return CAMERA_ERROR_INVALID_PARAMETER;
3684         }
3685         sock_fd = pc->cb_info->fd;
3686         int get_mode;
3687
3688         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3689         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3690
3691         if (ret == CAMERA_ERROR_NONE) {
3692                 muse_camera_msg_get(get_mode, pc->cb_info->recvMsg);
3693                 *mode = (camera_attr_flash_mode_e)get_mode;
3694         }
3695         LOGD("ret : 0x%x", ret);
3696         return ret;
3697 }
3698
3699
3700 int camera_attr_foreach_supported_af_mode( camera_h camera, camera_attr_supported_af_mode_cb foreach_cb , void *user_data)
3701 {
3702         if( camera == NULL || foreach_cb == NULL){
3703                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3704                 return CAMERA_ERROR_INVALID_PARAMETER;
3705         }
3706         int ret = CAMERA_ERROR_NONE;
3707
3708         camera_cli_s *pc = (camera_cli_s *)camera;
3709         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_AF_MODE;
3710
3711         LOGD("Enter, handle :%x", pc->remote_handle);
3712
3713         int sock_fd;
3714         if (pc->cb_info == NULL) {
3715                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3716                 return CAMERA_ERROR_INVALID_PARAMETER;
3717         }
3718         sock_fd = pc->cb_info->fd;
3719         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_AF_MODE] = foreach_cb;
3720         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_AF_MODE] = user_data;
3721
3722         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3723         LOGD("ret : 0x%x", ret);
3724         return ret;
3725 }
3726
3727
3728 int camera_attr_foreach_supported_exposure_mode(camera_h camera, camera_attr_supported_exposure_mode_cb foreach_cb , void *user_data)
3729 {
3730         if( camera == NULL || foreach_cb == NULL){
3731                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3732                 return CAMERA_ERROR_INVALID_PARAMETER;
3733         }
3734         int ret = CAMERA_ERROR_NONE;
3735
3736         camera_cli_s *pc = (camera_cli_s *)camera;
3737         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_EXPOSURE_MODE;
3738
3739         LOGD("Enter, handle :%x", pc->remote_handle);
3740
3741         int sock_fd;
3742         if (pc->cb_info == NULL) {
3743                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3744                 return CAMERA_ERROR_INVALID_PARAMETER;
3745         }
3746         sock_fd = pc->cb_info->fd;
3747         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EXPOSURE_MODE] = foreach_cb;
3748         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EXPOSURE_MODE] = user_data;
3749
3750         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3751         LOGD("ret : 0x%x", ret);
3752         return ret;
3753 }
3754
3755
3756 int camera_attr_foreach_supported_iso( camera_h camera, camera_attr_supported_iso_cb foreach_cb , void *user_data)
3757 {
3758         if( camera == NULL || foreach_cb == NULL){
3759                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3760                 return CAMERA_ERROR_INVALID_PARAMETER;
3761         }
3762         int ret = CAMERA_ERROR_NONE;
3763
3764         camera_cli_s *pc = (camera_cli_s *)camera;
3765         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_ISO;
3766
3767         LOGD("Enter, handle :%x", pc->remote_handle);
3768
3769         int sock_fd;
3770         if (pc->cb_info == NULL) {
3771                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3772                 return CAMERA_ERROR_INVALID_PARAMETER;
3773         }
3774         sock_fd = pc->cb_info->fd;
3775         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_ISO] = foreach_cb;
3776         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_ISO] = user_data;
3777
3778         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3779         LOGD("ret : 0x%x", ret);
3780         return ret;
3781 }
3782
3783
3784 int camera_attr_foreach_supported_whitebalance(camera_h camera, camera_attr_supported_whitebalance_cb foreach_cb , void *user_data)
3785 {
3786         if( camera == NULL || foreach_cb == NULL){
3787                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3788                 return CAMERA_ERROR_INVALID_PARAMETER;
3789         }
3790         int ret = CAMERA_ERROR_NONE;
3791
3792         camera_cli_s *pc = (camera_cli_s *)camera;
3793         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_WHITEBALANCE;
3794
3795         LOGD("Enter, handle :%x", pc->remote_handle);
3796
3797         int sock_fd;
3798         if (pc->cb_info == NULL) {
3799                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3800                 return CAMERA_ERROR_INVALID_PARAMETER;
3801         }
3802         sock_fd = pc->cb_info->fd;
3803         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_WHITEBALANCE] = foreach_cb;
3804         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_WHITEBALANCE] = user_data;
3805
3806         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3807         LOGD("ret : 0x%x", ret);
3808         return ret;
3809 }
3810
3811
3812 int camera_attr_foreach_supported_effect(camera_h camera, camera_attr_supported_effect_cb foreach_cb , void *user_data)
3813 {
3814         if( camera == NULL || foreach_cb == NULL){
3815                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3816                 return CAMERA_ERROR_INVALID_PARAMETER;
3817         }
3818         int ret = CAMERA_ERROR_NONE;
3819
3820         camera_cli_s *pc = (camera_cli_s *)camera;
3821         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_EFFECT;
3822
3823         LOGD("Enter, handle :%x", pc->remote_handle);
3824
3825         int sock_fd;
3826         if (pc->cb_info == NULL) {
3827                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3828                 return CAMERA_ERROR_INVALID_PARAMETER;
3829         }
3830         sock_fd = pc->cb_info->fd;
3831         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EFFECT] = foreach_cb;
3832         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EFFECT] = user_data;
3833
3834         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3835         LOGD("ret : 0x%x", ret);
3836         return ret;
3837 }
3838
3839
3840 int camera_attr_foreach_supported_scene_mode(camera_h camera, camera_attr_supported_scene_mode_cb foreach_cb , void *user_data)
3841 {
3842         if( camera == NULL || foreach_cb == NULL){
3843                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3844                 return CAMERA_ERROR_INVALID_PARAMETER;
3845         }
3846         int ret = CAMERA_ERROR_NONE;
3847
3848         camera_cli_s *pc = (camera_cli_s *)camera;
3849         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_SCENE_MODE;
3850
3851         LOGD("Enter, handle :%x", pc->remote_handle);
3852
3853         int sock_fd;
3854         if (pc->cb_info == NULL) {
3855                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3856                 return CAMERA_ERROR_INVALID_PARAMETER;
3857         }
3858         sock_fd = pc->cb_info->fd;
3859         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_SCENE_MODE] = foreach_cb;
3860         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_SCENE_MODE] = user_data;
3861
3862         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3863         LOGD("ret : 0x%x", ret);
3864         return ret;
3865 }
3866
3867
3868 int camera_attr_foreach_supported_flash_mode(camera_h camera, camera_attr_supported_flash_mode_cb foreach_cb , void *user_data)
3869 {
3870         if( camera == NULL || foreach_cb == NULL){
3871                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3872                 return CAMERA_ERROR_INVALID_PARAMETER;
3873         }
3874         int ret = CAMERA_ERROR_NONE;
3875
3876         camera_cli_s *pc = (camera_cli_s *)camera;
3877         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_FLASH_MODE;
3878
3879         LOGD("Enter, handle :%x", pc->remote_handle);
3880
3881         int sock_fd;
3882         if (pc->cb_info == NULL) {
3883                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3884                 return CAMERA_ERROR_INVALID_PARAMETER;
3885         }
3886         sock_fd = pc->cb_info->fd;
3887         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FLASH_MODE] = foreach_cb;
3888         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FLASH_MODE] = user_data;
3889
3890         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3891         LOGD("ret : 0x%x", ret);
3892         return ret;
3893 }
3894
3895
3896 int camera_attr_foreach_supported_fps(camera_h camera, camera_attr_supported_fps_cb foreach_cb , void *user_data)
3897 {
3898         if( camera == NULL || foreach_cb == NULL){
3899                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3900                 return CAMERA_ERROR_INVALID_PARAMETER;
3901         }
3902         int ret = CAMERA_ERROR_NONE;
3903
3904         camera_cli_s *pc = (camera_cli_s *)camera;
3905         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_FPS;
3906         int sock_fd;
3907         if (pc->cb_info == NULL) {
3908                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3909                 return CAMERA_ERROR_INVALID_PARAMETER;
3910         }
3911         sock_fd = pc->cb_info->fd;
3912         LOGD("Enter, handle :%x", pc->remote_handle);
3913         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS] = foreach_cb;
3914         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS] = user_data;
3915
3916         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3917         LOGD("Enter, handle :%x", pc->remote_handle);
3918         return ret;
3919 }
3920
3921 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)
3922 {
3923         if( camera == NULL || foreach_cb == NULL){
3924                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3925                 return CAMERA_ERROR_INVALID_PARAMETER;
3926         }
3927         int ret = CAMERA_ERROR_NONE;
3928
3929         camera_cli_s *pc = (camera_cli_s *)camera;
3930         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_FPS_BY_RESOLUTION;
3931         int sock_fd;
3932         if (pc->cb_info == NULL) {
3933                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3934                 return CAMERA_ERROR_INVALID_PARAMETER;
3935         }
3936         sock_fd = pc->cb_info->fd;
3937         LOGD("Enter, handle :%x", pc->remote_handle);
3938         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS_BY_RESOLUTION] = foreach_cb;
3939         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS_BY_RESOLUTION] = user_data;
3940
3941         muse_camera_msg_send2(api, sock_fd, pc->cb_info, ret, INT, width, INT, height);
3942         LOGD("ret : 0x%x", ret);
3943         return ret;
3944 }
3945
3946 int camera_attr_foreach_supported_stream_flip(camera_h camera, camera_attr_supported_stream_flip_cb foreach_cb, void *user_data)
3947 {
3948         if( camera == NULL || foreach_cb == NULL){
3949                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3950                 return CAMERA_ERROR_INVALID_PARAMETER;
3951         }
3952         int ret = CAMERA_ERROR_NONE;
3953
3954         camera_cli_s *pc = (camera_cli_s *)camera;
3955         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_STREAM_FLIP;
3956         int sock_fd;
3957         if (pc->cb_info == NULL) {
3958                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3959                 return CAMERA_ERROR_INVALID_PARAMETER;
3960         }
3961         sock_fd = pc->cb_info->fd;
3962         LOGD("Enter, handle :%x", pc->remote_handle);
3963         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_FLIP] = foreach_cb;
3964         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_FLIP] = user_data;
3965
3966         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3967         LOGD("ret : 0x%x", ret);
3968         return ret;
3969 }
3970
3971
3972 int camera_attr_foreach_supported_stream_rotation(camera_h camera, camera_attr_supported_stream_rotation_cb foreach_cb, void *user_data)
3973 {
3974         if( camera == NULL || foreach_cb == NULL){
3975                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3976                 return CAMERA_ERROR_INVALID_PARAMETER;
3977         }
3978         int ret = CAMERA_ERROR_NONE;
3979
3980         camera_cli_s *pc = (camera_cli_s *)camera;
3981         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_STREAM_ROTATION;
3982         int sock_fd;
3983         if (pc->cb_info == NULL) {
3984                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
3985                 return CAMERA_ERROR_INVALID_PARAMETER;
3986         }
3987         sock_fd = pc->cb_info->fd;
3988         LOGD("Enter, handle :%x", pc->remote_handle);
3989         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_ROTATION] = foreach_cb;
3990         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_ROTATION] = user_data;
3991
3992         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3993         LOGD("ret : 0x%x", ret);
3994         return ret;
3995 }
3996
3997
3998 int camera_attr_set_stream_rotation(camera_h camera , camera_rotation_e rotation)
3999 {
4000         if( camera == NULL){
4001                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4002                 return CAMERA_ERROR_INVALID_PARAMETER;
4003         }
4004
4005         int ret = CAMERA_ERROR_NONE;
4006         camera_cli_s *pc = (camera_cli_s *)camera;
4007         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_STREAM_ROTATION;
4008         int sock_fd;
4009         if (pc->cb_info == NULL) {
4010                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4011                 return CAMERA_ERROR_INVALID_PARAMETER;
4012         }
4013         sock_fd = pc->cb_info->fd;
4014         int set_rotation = (int)rotation;
4015
4016         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4017         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_rotation);
4018         LOGD("ret : 0x%x", ret);
4019         return ret;
4020 }
4021
4022
4023 int camera_attr_get_stream_rotation(camera_h camera , camera_rotation_e *rotation)
4024 {
4025         if( camera == NULL || rotation == NULL ){
4026                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4027                 return CAMERA_ERROR_INVALID_PARAMETER;
4028         }
4029
4030         int ret = CAMERA_ERROR_NONE;
4031         camera_cli_s *pc = (camera_cli_s *)camera;
4032         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_STREAM_ROTATION;
4033         int sock_fd;
4034         if (pc->cb_info == NULL) {
4035                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4036                 return CAMERA_ERROR_INVALID_PARAMETER;
4037         }
4038         sock_fd = pc->cb_info->fd;
4039         int get_rotation;
4040
4041         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4042         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4043
4044         if (ret == CAMERA_ERROR_NONE) {
4045                 muse_camera_msg_get(get_rotation, pc->cb_info->recvMsg);
4046                 *rotation = (camera_rotation_e)get_rotation;
4047         }
4048         LOGD("ret : 0x%x", ret);
4049         return ret;
4050 }
4051
4052
4053 int camera_attr_set_stream_flip(camera_h camera , camera_flip_e flip)
4054 {
4055         if( camera == NULL){
4056                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4057                 return CAMERA_ERROR_INVALID_PARAMETER;
4058         }
4059
4060         int ret = CAMERA_ERROR_NONE;
4061         camera_cli_s *pc = (camera_cli_s *)camera;
4062         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_STREAM_FLIP;
4063         int sock_fd;
4064         if (pc->cb_info == NULL) {
4065                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4066                 return CAMERA_ERROR_INVALID_PARAMETER;
4067         }
4068         sock_fd = pc->cb_info->fd;
4069         int set_flip = (int)flip;
4070
4071         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4072         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_flip);
4073         LOGD("ret : 0x%x", ret);
4074         return ret;
4075 }
4076
4077
4078 int camera_attr_get_stream_flip(camera_h camera , camera_flip_e *flip)
4079 {
4080         if( camera == NULL || flip == NULL ){
4081                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4082                 return CAMERA_ERROR_INVALID_PARAMETER;
4083         }
4084
4085         int ret = CAMERA_ERROR_NONE;
4086         camera_cli_s *pc = (camera_cli_s *)camera;
4087         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_STREAM_FLIP;
4088         int sock_fd;
4089         if (pc->cb_info == NULL) {
4090                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4091                 return CAMERA_ERROR_INVALID_PARAMETER;
4092         }
4093         sock_fd = pc->cb_info->fd;
4094         int get_flip;
4095
4096         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4097         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4098
4099         if (ret == CAMERA_ERROR_NONE) {
4100                 muse_camera_msg_get(get_flip, pc->cb_info->recvMsg);
4101                 *flip = (camera_flip_e)get_flip;
4102         }
4103         LOGD("ret : 0x%x", ret);
4104         return ret;
4105 }
4106
4107 int camera_attr_set_hdr_mode(camera_h camera, camera_attr_hdr_mode_e mode)
4108 {
4109         if( camera == NULL){
4110                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4111                 return CAMERA_ERROR_INVALID_PARAMETER;
4112         }
4113
4114         int ret = CAMERA_ERROR_NONE;
4115         camera_cli_s *pc = (camera_cli_s *)camera;
4116         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_HDR_MODE;
4117         int sock_fd;
4118         if (pc->cb_info == NULL) {
4119                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4120                 return CAMERA_ERROR_INVALID_PARAMETER;
4121         }
4122         sock_fd = pc->cb_info->fd;
4123         int set_mode = (int)mode;
4124
4125         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4126         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_mode);
4127         LOGD("ret : 0x%x", ret);
4128         return ret;
4129 }
4130
4131
4132 int camera_attr_get_hdr_mode(camera_h camera, camera_attr_hdr_mode_e *mode)
4133 {
4134         if (camera == NULL) {
4135                 LOGE("INVALID_PARAMETER(0x%08x) - handle",CAMERA_ERROR_INVALID_PARAMETER);
4136                 return CAMERA_ERROR_INVALID_PARAMETER;
4137         }
4138         if (mode == NULL) {
4139                 LOGE("CAMERA_ERROR_NOT_SUPPORTED(0x%08x) - mode",CAMERA_ERROR_NOT_SUPPORTED);
4140                 return CAMERA_ERROR_NOT_SUPPORTED;
4141         }
4142         int ret = CAMERA_ERROR_NONE;
4143         camera_cli_s *pc = (camera_cli_s *)camera;
4144         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_HDR_MODE;
4145         int sock_fd;
4146         if (pc->cb_info == NULL) {
4147                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4148                 return CAMERA_ERROR_INVALID_PARAMETER;
4149         }
4150         sock_fd = pc->cb_info->fd;
4151         int get_mode;
4152
4153         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4154         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4155
4156         if (ret == CAMERA_ERROR_NONE) {
4157                 muse_camera_msg_get(get_mode, pc->cb_info->recvMsg);
4158                 *mode = (camera_attr_hdr_mode_e)get_mode;
4159         }
4160         LOGD("ret : 0x%x", ret);
4161         return ret;
4162 }
4163
4164
4165 bool camera_attr_is_supported_hdr_capture(camera_h camera)
4166 {
4167         if( camera == NULL){
4168                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4169                 return false;
4170         }
4171
4172         int ret = CAMERA_ERROR_NONE;
4173         camera_cli_s *pc = (camera_cli_s *)camera;
4174         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_SUPPORTED_HDR_CAPTURE;
4175         int sock_fd;
4176         if (pc->cb_info == NULL) {
4177                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4178                 return CAMERA_ERROR_INVALID_PARAMETER;
4179         }
4180         sock_fd = pc->cb_info->fd;
4181         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4182         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4183         LOGD("ret : 0x%x", ret);
4184         return (bool)ret;
4185 }
4186
4187
4188 int camera_attr_set_hdr_capture_progress_cb(camera_h camera, camera_attr_hdr_progress_cb callback, void* user_data)
4189 {
4190         if (camera == NULL) {
4191                 LOGE("INVALID_PARAMETER(0x%08x) - handle", CAMERA_ERROR_INVALID_PARAMETER);
4192                 return CAMERA_ERROR_INVALID_PARAMETER;
4193         }
4194         if (callback == NULL) {
4195                 LOGE("CAMERA_ERROR_NOT_SUPPORTED(0x%08x) - callback", CAMERA_ERROR_NOT_SUPPORTED);
4196                 return CAMERA_ERROR_NOT_SUPPORTED;
4197         }
4198         int ret = CAMERA_ERROR_NONE;
4199
4200         camera_cli_s *pc = (camera_cli_s *)camera;
4201         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_HDR_CAPTURE_PROGRESS_CB;
4202         int sock_fd;
4203         if (pc->cb_info == NULL) {
4204                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4205                 return CAMERA_ERROR_INVALID_PARAMETER;
4206         }
4207         sock_fd = pc->cb_info->fd;
4208         LOGD("Enter, handle :%x", pc->remote_handle);
4209
4210         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_HDR_PROGRESS] = callback;
4211         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_HDR_PROGRESS] = user_data;
4212
4213         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4214         LOGD("ret : 0x%x", ret);
4215         return ret;
4216 }
4217
4218
4219 int camera_attr_unset_hdr_capture_progress_cb(camera_h camera)
4220 {
4221         if( camera == NULL){
4222                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4223                 return CAMERA_ERROR_INVALID_PARAMETER;
4224         }
4225
4226         int ret = CAMERA_ERROR_NONE;
4227
4228         camera_cli_s *pc = (camera_cli_s *)camera;
4229         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_UNSET_HDR_CAPTURE_PROGRESS_CB;
4230         int sock_fd;
4231         if (pc->cb_info == NULL) {
4232                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4233                 return CAMERA_ERROR_INVALID_PARAMETER;
4234         }
4235         sock_fd = pc->cb_info->fd;
4236         LOGD("Enter, handle :%x", pc->remote_handle);
4237
4238         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_HDR_PROGRESS] = (void *)NULL;
4239         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_HDR_PROGRESS] = (void *)NULL;
4240
4241         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4242         LOGD("ret : 0x%x", ret);
4243         return ret;
4244 }
4245
4246
4247 int camera_attr_enable_anti_shake(camera_h camera, bool enable)
4248 {
4249         if (camera == NULL) {
4250                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4251                 return CAMERA_ERROR_INVALID_PARAMETER;
4252         }
4253
4254         int ret = CAMERA_ERROR_NONE;
4255         camera_cli_s *pc = (camera_cli_s *)camera;
4256         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_ENABLE_ANTI_SHAKE;
4257         int sock_fd;
4258         if (pc->cb_info == NULL) {
4259                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4260                 return CAMERA_ERROR_INVALID_PARAMETER;
4261         }
4262         sock_fd = pc->cb_info->fd;
4263         int set_enable = (int)enable;
4264
4265         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4266         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_enable);
4267         LOGD("ret : 0x%x", ret);
4268         return ret;
4269 }
4270
4271
4272 int camera_attr_is_enabled_anti_shake(camera_h camera , bool *enabled)
4273 {
4274         if (camera == NULL) {
4275                 LOGE("INVALID_PARAMETER(0x%08x) - handle", CAMERA_ERROR_INVALID_PARAMETER);
4276                 return CAMERA_ERROR_INVALID_PARAMETER;
4277         }
4278         if (enabled == NULL) {
4279                 LOGE("INVALID_PARAMETER(0x%08x) - enabled", CAMERA_ERROR_INVALID_PARAMETER);
4280                 return CAMERA_ERROR_NOT_SUPPORTED;
4281         }
4282         int ret = CAMERA_ERROR_NONE;
4283         camera_cli_s *pc = (camera_cli_s *)camera;
4284         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_ENABLED_ANTI_SHAKE;
4285         int sock_fd;
4286         if (pc->cb_info == NULL) {
4287                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4288                 return CAMERA_ERROR_INVALID_PARAMETER;
4289         }
4290         sock_fd = pc->cb_info->fd;
4291         int get_enabled;
4292
4293         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4294         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4295
4296         if (ret == CAMERA_ERROR_NONE) {
4297                 muse_camera_msg_get(get_enabled, pc->cb_info->recvMsg);
4298                 *enabled = (bool)get_enabled;
4299         }
4300         LOGD("ret : 0x%x", ret);
4301         return ret;
4302 }
4303
4304
4305 bool camera_attr_is_supported_anti_shake(camera_h camera)
4306 {
4307
4308         if( camera == NULL){
4309                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4310                 return false;
4311         }
4312
4313         int ret = CAMERA_ERROR_NONE;
4314         camera_cli_s *pc = (camera_cli_s *)camera;
4315         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_SUPPORTED_ANTI_SHAKE;
4316         int sock_fd;
4317         if (pc->cb_info == NULL) {
4318                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4319                 return CAMERA_ERROR_INVALID_PARAMETER;
4320         }
4321         sock_fd = pc->cb_info->fd;
4322         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4323         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4324         LOGD("ret : 0x%x", ret);
4325         return ret;
4326 }
4327
4328
4329 int camera_attr_enable_video_stabilization(camera_h camera, bool enable)
4330 {
4331         if (camera == NULL) {
4332                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4333                 return CAMERA_ERROR_INVALID_PARAMETER;
4334         }
4335
4336         int ret = CAMERA_ERROR_NONE;
4337         camera_cli_s *pc = (camera_cli_s *)camera;
4338         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_ENABLE_VIDEO_STABILIZATION;
4339         int sock_fd;
4340         if (pc->cb_info == NULL) {
4341                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4342                 return CAMERA_ERROR_INVALID_PARAMETER;
4343         }
4344         sock_fd = pc->cb_info->fd;
4345         int set_enable = (int)enable;
4346
4347         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4348         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_enable);
4349         LOGD("ret : 0x%x", ret);
4350         return ret;
4351 }
4352
4353
4354 int camera_attr_is_enabled_video_stabilization(camera_h camera, bool *enabled)
4355 {
4356         if (camera == NULL) {
4357                 LOGE("INVALID_PARAMETER(0x%08x) - handle",CAMERA_ERROR_INVALID_PARAMETER);
4358                 return CAMERA_ERROR_INVALID_PARAMETER;
4359         }
4360         if (enabled == NULL) {
4361                 LOGE("INVALID_PARAMETER(0x%08x) - enabled",CAMERA_ERROR_INVALID_PARAMETER);
4362                 return CAMERA_ERROR_NOT_SUPPORTED;
4363         }
4364         int ret = CAMERA_ERROR_NONE;
4365         camera_cli_s *pc = (camera_cli_s *)camera;
4366         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_ENABLED_VIDEO_STABILIZATION;
4367         int sock_fd;
4368         if (pc->cb_info == NULL) {
4369                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4370                 return CAMERA_ERROR_INVALID_PARAMETER;
4371         }
4372         sock_fd = pc->cb_info->fd;
4373         int get_enabled;
4374
4375         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4376         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4377
4378         if (ret == CAMERA_ERROR_NONE) {
4379                 muse_camera_msg_get(get_enabled, pc->cb_info->recvMsg);
4380                 *enabled = (bool)get_enabled;
4381         }
4382         LOGD("ret : 0x%x", ret);
4383         return ret;
4384 }
4385
4386
4387 bool camera_attr_is_supported_video_stabilization(camera_h camera)
4388 {
4389         if( camera == NULL){
4390                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4391                 return false;
4392         }
4393
4394         int ret = CAMERA_ERROR_NONE;
4395         camera_cli_s *pc = (camera_cli_s *)camera;
4396         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_SUPPORTED_VIDEO_STABILIZATION;
4397         int sock_fd;
4398         if (pc->cb_info == NULL) {
4399                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4400                 return CAMERA_ERROR_INVALID_PARAMETER;
4401         }
4402         sock_fd = pc->cb_info->fd;
4403         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4404         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4405         LOGD("ret : 0x%x", ret);
4406         return ret;
4407 }
4408
4409
4410 int camera_attr_enable_auto_contrast(camera_h camera, bool enable)
4411 {
4412         if( camera == NULL){
4413                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4414                 return CAMERA_ERROR_INVALID_PARAMETER;
4415         }
4416
4417         int ret = CAMERA_ERROR_NONE;
4418         camera_cli_s *pc = (camera_cli_s *)camera;
4419         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_ENABLE_AUTO_CONTRAST;
4420         int sock_fd;
4421         if (pc->cb_info == NULL) {
4422                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4423                 return CAMERA_ERROR_INVALID_PARAMETER;
4424         }
4425         sock_fd = pc->cb_info->fd;
4426         int set_enable = (int)enable;
4427
4428         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4429         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_enable);
4430         LOGD("ret : 0x%x", ret);
4431         return ret;
4432 }
4433
4434
4435 int camera_attr_is_enabled_auto_contrast(camera_h camera, bool *enabled)
4436 {
4437         if (camera == NULL) {
4438                 LOGE("INVALID_PARAMETER(0x%08x) - handle", CAMERA_ERROR_INVALID_PARAMETER);
4439                 return CAMERA_ERROR_INVALID_PARAMETER;
4440         }
4441         if (enabled == NULL) {
4442                 LOGE("INVALID_PARAMETER(0x%08x) - enabled", CAMERA_ERROR_INVALID_PARAMETER);
4443                 return CAMERA_ERROR_INVALID_PARAMETER;
4444         }
4445         int ret = CAMERA_ERROR_NONE;
4446         camera_cli_s *pc = (camera_cli_s *)camera;
4447         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_ENABLED_AUTO_CONTRAST;
4448         int sock_fd;
4449         if (pc->cb_info == NULL) {
4450                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4451                 return CAMERA_ERROR_INVALID_PARAMETER;
4452         }
4453         sock_fd = pc->cb_info->fd;
4454         int get_enabled;
4455
4456         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4457         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4458
4459         if (ret == CAMERA_ERROR_NONE) {
4460                 muse_camera_msg_get(get_enabled, pc->cb_info->recvMsg);
4461                 *enabled = (bool)get_enabled;
4462         }
4463         LOGD("ret : 0x%x", ret);
4464         return ret;
4465 }
4466
4467
4468 bool camera_attr_is_supported_auto_contrast(camera_h camera)
4469 {
4470         if( camera == NULL){
4471                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4472                 return false;
4473         }
4474
4475         int ret = CAMERA_ERROR_NONE;
4476         camera_cli_s *pc = (camera_cli_s *)camera;
4477         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_SUPPORTED_AUTO_CONTRAST;
4478         int sock_fd;
4479         if (pc->cb_info == NULL) {
4480                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4481                 return CAMERA_ERROR_INVALID_PARAMETER;
4482         }
4483         sock_fd = pc->cb_info->fd;
4484         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4485         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4486         LOGD("ret : 0x%x", ret);
4487         return ret;
4488 }
4489
4490
4491 int camera_attr_disable_shutter_sound(camera_h camera, bool disable)
4492 {
4493         if (camera == NULL) {
4494                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4495                 return CAMERA_ERROR_INVALID_PARAMETER;
4496         }
4497
4498         int ret = CAMERA_ERROR_NONE;
4499         camera_cli_s *pc = (camera_cli_s *)camera;
4500         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_DISABLE_SHUTTER_SOUND;
4501         int sock_fd;
4502         if (pc->cb_info == NULL) {
4503                 LOGE("INVALID_PARAMETER(0x%08x)",CAMERA_ERROR_INVALID_PARAMETER);
4504                 return CAMERA_ERROR_INVALID_PARAMETER;
4505         }
4506         sock_fd = pc->cb_info->fd;
4507         int set_disable = (int)disable;
4508
4509         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4510         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_disable);
4511         LOGD("ret : 0x%x", ret);
4512         return ret;
4513 }