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 <muse_core_module.h>
  28 #include <camera_private.h>
  29 #include <muse_core.h>
  30 #include <dlog.h>
  31 #include <Elementary.h>
  32 #include <tbm_surface_internal.h>
  33 #include <gst/gst.h>
  34 #include <mm_camcorder.h>
  35 #include <mm_camcorder_client.h>
  36 #include <Evas.h>
  37 #ifdef HAVE_WAYLAND
  38 #include <Ecore_Wayland.h>
  39 #else
  40 #include <Ecore.h>
  41 #endif
  42
  43 #ifdef LOG_TAG
  44 #undef LOG_TAG
  45 #endif
  46 #define LOG_TAG "TIZEN_N_CAMERA"
  47
  48
  49 int __convert_camera_error_code(const char *func, int code)
  50 {
  51         int ret = CAMERA_ERROR_NONE;
  52         const char *errorstr = NULL;
  53
  54         switch (code) {
  55         case MM_ERROR_NONE:
  56                 ret = CAMERA_ERROR_NONE;
  57                 errorstr = "ERROR_NONE";
  58                 break;
  59         case MM_ERROR_CAMCORDER_INVALID_ARGUMENT:
  60         case MM_ERROR_COMMON_INVALID_ATTRTYPE:
  61                 ret = CAMERA_ERROR_INVALID_PARAMETER;
  62                 errorstr = "INVALID_PARAMETER";
  63                 break;
  64         case MM_ERROR_CAMCORDER_NOT_INITIALIZED:
  65         case MM_ERROR_CAMCORDER_INVALID_STATE:
  66                 ret = CAMERA_ERROR_INVALID_STATE;
  67                 errorstr = "INVALID_STATE";
  68                 break;
  69         case MM_ERROR_CAMCORDER_DEVICE_NOT_FOUND:
  70                 ret = CAMERA_ERROR_DEVICE_NOT_FOUND;
  71                 errorstr = "DEVICE_NOT_FOUND";
  72                 break;
  73         case MM_ERROR_CAMCORDER_DEVICE_BUSY:
  74         case MM_ERROR_CAMCORDER_DEVICE_OPEN:
  75         case MM_ERROR_CAMCORDER_CMD_IS_RUNNING:
  76                 ret = CAMERA_ERROR_DEVICE_BUSY;
  77                 errorstr = "DEVICE_BUSY";
  78                 break;
  79         case MM_ERROR_CAMCORDER_DEVICE:
  80         case MM_ERROR_CAMCORDER_DEVICE_IO:
  81         case MM_ERROR_CAMCORDER_DEVICE_TIMEOUT:
  82         case MM_ERROR_CAMCORDER_DEVICE_WRONG_JPEG:
  83         case MM_ERROR_CAMCORDER_DEVICE_LACK_BUFFER:
  84                 ret = CAMERA_ERROR_DEVICE;
  85                 errorstr = "ERROR_DEVICE";
  86                 break;
  87         case MM_ERROR_CAMCORDER_GST_CORE:
  88         case MM_ERROR_CAMCORDER_GST_LIBRARY:
  89         case MM_ERROR_CAMCORDER_GST_RESOURCE:
  90         case MM_ERROR_CAMCORDER_GST_STREAM:
  91         case MM_ERROR_CAMCORDER_GST_STATECHANGE:
  92         case MM_ERROR_CAMCORDER_GST_NEGOTIATION:
  93         case MM_ERROR_CAMCORDER_GST_LINK:
  94         case MM_ERROR_CAMCORDER_GST_FLOW_ERROR:
  95         case MM_ERROR_CAMCORDER_ENCODER:
  96         case MM_ERROR_CAMCORDER_ENCODER_BUFFER:
  97         case MM_ERROR_CAMCORDER_ENCODER_WRONG_TYPE:
  98         case MM_ERROR_CAMCORDER_ENCODER_WORKING:
  99         case MM_ERROR_CAMCORDER_INTERNAL:
 100         case MM_ERROR_CAMCORDER_RESPONSE_TIMEOUT:
 101         case MM_ERROR_CAMCORDER_DSP_FAIL:
 102         case MM_ERROR_CAMCORDER_AUDIO_EMPTY:
 103         case MM_ERROR_CAMCORDER_CREATE_CONFIGURE:
 104         case MM_ERROR_CAMCORDER_FILE_SIZE_OVER:
 105         case MM_ERROR_CAMCORDER_DISPLAY_DEVICE_OFF:
 106         case MM_ERROR_CAMCORDER_INVALID_CONDITION:
 107                 ret = CAMERA_ERROR_INVALID_OPERATION;
 108                 errorstr = "INVALID_OPERATION";
 109                 break;
 110         case MM_ERROR_CAMCORDER_RESOURCE_CREATION:
 111         case MM_ERROR_COMMON_OUT_OF_MEMORY:
 112                 ret = CAMERA_ERROR_OUT_OF_MEMORY;
 113                 errorstr = "OUT_OF_MEMORY";
 114                 break;
 115         case MM_ERROR_POLICY_BLOCKED:
 116                 ret = CAMERA_ERROR_SOUND_POLICY;
 117                 errorstr = "ERROR_SOUND_POLICY";
 118                 break;
 119         case MM_ERROR_POLICY_BLOCKED_BY_CALL:
 120                 ret = CAMERA_ERROR_SOUND_POLICY_BY_CALL;
 121                 errorstr = "ERROR_SOUND_POLICY_BY_CALL";
 122                 break;
 123         case MM_ERROR_POLICY_BLOCKED_BY_ALARM:
 124                 ret = CAMERA_ERROR_SOUND_POLICY_BY_ALARM;
 125                 errorstr = "ERROR_SOUND_POLICY_BY_ALARM";
 126                 break;
 127         case MM_ERROR_POLICY_RESTRICTED:
 128                 ret = CAMERA_ERROR_SECURITY_RESTRICTED;
 129                 errorstr = "ERROR_RESTRICTED";
 130                 break;
 131         case MM_ERROR_CAMCORDER_DEVICE_REG_TROUBLE:
 132                 ret = CAMERA_ERROR_ESD;
 133                 errorstr = "ERROR_ESD";
 134                 break;
 135         case MM_ERROR_COMMON_INVALID_PERMISSION:
 136                 ret = CAMERA_ERROR_PERMISSION_DENIED;
 137                 errorstr = "ERROR_PERMISSION_DENIED";
 138                 break;
 139         case MM_ERROR_COMMON_OUT_OF_ARRAY:
 140         case MM_ERROR_COMMON_OUT_OF_RANGE:
 141         case MM_ERROR_COMMON_ATTR_NOT_EXIST:
 142         case MM_ERROR_CAMCORDER_NOT_SUPPORTED:
 143                 ret = CAMERA_ERROR_NOT_SUPPORTED;
 144                 errorstr = "ERROR_NOT_SUPPORTED";
 145                 break;
 146         default:
 147                 ret = CAMERA_ERROR_INVALID_OPERATION;
 148                 errorstr = "INVALID_OPERATION";
 149         }
 150
 151         if (code != MM_ERROR_NONE)
 152                 LOGE("[%s] %s(0x%08x) : core frameworks error code(0x%08x)", func ? func : "NULL_FUNC", errorstr, ret, code);
 153
 154         return ret;
 155 }
 156
 157 #ifdef HAVE_WAYLAND
 158 static MMCamWaylandInfo *_get_wl_info(Evas_Object *obj)
 159 {
 160         MMCamWaylandInfo *wl_info = NULL;
 161
 162         if (obj == NULL) {
 163                 LOGE("evas object is NULL");
 164                 return NULL;
 165         }
 166
 167         wl_info = g_new0(MMCamWaylandInfo, 1);
 168         if (wl_info == NULL) {
 169                 LOGE("wl_info alloc failed : %d", sizeof(MMCamWaylandInfo));
 170                 return NULL;
 171         }
 172
 173         wl_info->evas_obj = (void *)obj;
 174         wl_info->window = (void *)elm_win_wl_window_get(obj);
 175         wl_info->surface = (void *)ecore_wl_window_surface_get(wl_info->window);
 176         wl_info->display = (void *)ecore_wl_display_get();
 177
 178         if (wl_info->window == NULL || wl_info->surface == NULL || wl_info->display == NULL) {
 179                 LOGE("something is NULL %p, %p, %p", wl_info->window, wl_info->surface, wl_info->display);
 180                 g_free(wl_info);
 181                 return NULL;
 182         }
 183
 184         evas_object_geometry_get(obj, &wl_info->window_x, &wl_info->window_y,
 185                 &wl_info->window_width, &wl_info->window_height);
 186
 187         LOGD("wayland obj %p, window %p, surface %p, display %p, size %d,%d,%dx%d",
 188              wl_info->evas_obj, wl_info->window, wl_info->surface, wl_info->display,
 189              wl_info->window_x, wl_info->window_y, wl_info->window_width, wl_info->window_height);
 190
 191         return wl_info;
 192 }
 193 #endif /* HAVE_WAYLAND */
 194
 195 static int _import_tbm_key(tbm_bufmgr bufmgr, unsigned int tbm_key, tbm_bo *bo, tbm_bo_handle *bo_handle)
 196 {
 197         tbm_bo tmp_bo = NULL;
 198         tbm_bo_handle tmp_bo_handle = {NULL, };
 199
 200         if (bufmgr == NULL || bo == NULL || bo_handle == NULL || tbm_key == 0) {
 201                 LOGE("invalid parameter - bufmgr %p, bo %p, bo_handle %p, key %d",
 202                      bufmgr, bo, bo_handle, tbm_key);
 203                 return false;
 204         }
 205
 206         tmp_bo = tbm_bo_import(bufmgr, tbm_key);
 207         if (tmp_bo == NULL) {
 208                 LOGE("bo import failed - bufmgr %p, key %d", bufmgr, tbm_key);
 209                 return false;
 210         }
 211
 212         tmp_bo_handle = tbm_bo_map(tmp_bo, TBM_DEVICE_CPU, TBM_OPTION_READ);
 213         if (tmp_bo_handle.ptr == NULL) {
 214                 LOGE("bo map failed %p", tmp_bo);
 215                 tbm_bo_unref(tmp_bo);
 216                 tmp_bo = NULL;
 217                 return false;
 218         }
 219
 220         /* set bo and bo_handle */
 221         *bo = tmp_bo;
 222         *bo_handle = tmp_bo_handle;
 223
 224         return true;
 225 }
 226
 227 static void _release_imported_bo(tbm_bo *bo)
 228 {
 229         if (bo == NULL || *bo == NULL) {
 230                 LOGW("NULL bo");
 231                 return;
 232         }
 233
 234         tbm_bo_unmap(*bo);
 235         tbm_bo_unref(*bo);
 236         *bo = NULL;
 237
 238         return;
 239 }
 240
 241 static int _client_wait_for_cb_return(muse_camera_api_e api, camera_cb_info_s *cb_info, int time_out)
 242 {
 243         int ret = CAMERA_ERROR_NONE;
 244         gint64 end_time;
 245
 246         LOGD("Enter api : %d", api);
 247
 248         g_mutex_lock(&(cb_info->api_mutex[api]));
 249
 250         if (cb_info->api_activating[api] == 0) {
 251                 end_time = g_get_monotonic_time() + time_out * G_TIME_SPAN_SECOND;
 252                 if (g_cond_wait_until(&(cb_info->api_cond[api]), &(cb_info->api_mutex[api]), end_time)) {
 253                         ret = cb_info->api_ret[api];
 254                         cb_info->api_activating[api] = 0;
 255
 256                         LOGD("return value : 0x%x", ret);
 257                 } else {
 258                         ret = CAMERA_ERROR_INVALID_OPERATION;
 259
 260                         LOGE("api %d was TIMED OUT!", api);
 261                 }
 262         } else {
 263                 ret = cb_info->api_ret[api];
 264                 cb_info->api_activating[api] = 0;
 265
 266                 LOGD("condition is already checked for the api[%d], return[0x%x]", api, ret);
 267         }
 268
 269         g_mutex_unlock(&(cb_info->api_mutex[api]));
 270
 271         return ret;
 272 }
 273
 274 int _camera_get_tbm_surface_format(int in_format, uint32_t *out_format)
 275 {
 276         if (in_format <= MM_PIXEL_FORMAT_INVALID ||
 277             in_format >= MM_PIXEL_FORMAT_NUM ||
 278             out_format == NULL) {
 279                 LOGE("INVALID_PARAMETER : in_format %d, out_format ptr %p", in_format, out_format);
 280                 return CAMERA_ERROR_INVALID_PARAMETER;
 281         }
 282
 283         switch (in_format) {
 284         case MM_PIXEL_FORMAT_NV12:
 285         case MM_PIXEL_FORMAT_NV12T:
 286                 *out_format = TBM_FORMAT_NV12;
 287                 break;
 288         case MM_PIXEL_FORMAT_NV16:
 289                 *out_format = TBM_FORMAT_NV16;
 290                 break;
 291         case MM_PIXEL_FORMAT_NV21:
 292                 *out_format = TBM_FORMAT_NV21;
 293                 break;
 294         case MM_PIXEL_FORMAT_YUYV:
 295                 *out_format = TBM_FORMAT_YUYV;
 296                 break;
 297         case MM_PIXEL_FORMAT_UYVY:
 298         case MM_PIXEL_FORMAT_ITLV_JPEG_UYVY:
 299                 *out_format = TBM_FORMAT_UYVY;
 300                 break;
 301         case MM_PIXEL_FORMAT_422P:
 302                 *out_format = TBM_FORMAT_YUV422;
 303                 break;
 304         case MM_PIXEL_FORMAT_I420:
 305                 *out_format = TBM_FORMAT_YUV420;
 306                 break;
 307         case MM_PIXEL_FORMAT_YV12:
 308                 *out_format = TBM_FORMAT_YVU420;
 309                 break;
 310         case MM_PIXEL_FORMAT_RGB565:
 311                 *out_format = TBM_FORMAT_RGB565;
 312                 break;
 313         case MM_PIXEL_FORMAT_RGB888:
 314                 *out_format = TBM_FORMAT_RGB888;
 315                 break;
 316         case MM_PIXEL_FORMAT_RGBA:
 317                 *out_format = TBM_FORMAT_RGBA8888;
 318                 break;
 319         case MM_PIXEL_FORMAT_ARGB:
 320                 *out_format = TBM_FORMAT_ARGB8888;
 321                 break;
 322         default:
 323                 LOGE("invalid in_format %d", in_format);
 324                 return CAMERA_ERROR_INVALID_PARAMETER;
 325         }
 326
 327         return CAMERA_ERROR_NONE;
 328 }
 329
 330
 331 int _camera_get_media_packet_mimetype(int in_format, media_format_mimetype_e *mimetype)
 332 {
 333         if (in_format <= MM_PIXEL_FORMAT_INVALID ||
 334             in_format >= MM_PIXEL_FORMAT_NUM ||
 335             mimetype == NULL) {
 336                 LOGE("INVALID_PARAMETER : in_format %d, mimetype ptr %p", in_format, mimetype);
 337                 return CAMERA_ERROR_INVALID_PARAMETER;
 338         }
 339
 340         switch (in_format) {
 341         case MM_PIXEL_FORMAT_NV12:
 342         case MM_PIXEL_FORMAT_NV12T:
 343                 *mimetype = MEDIA_FORMAT_NV12;
 344                 break;
 345         case MM_PIXEL_FORMAT_NV16:
 346                 *mimetype = MEDIA_FORMAT_NV16;
 347                 break;
 348         case MM_PIXEL_FORMAT_NV21:
 349                 *mimetype = MEDIA_FORMAT_NV21;
 350                 break;
 351         case MM_PIXEL_FORMAT_YUYV:
 352                 *mimetype = MEDIA_FORMAT_YUYV;
 353                 break;
 354         case MM_PIXEL_FORMAT_UYVY:
 355         case MM_PIXEL_FORMAT_ITLV_JPEG_UYVY:
 356                 *mimetype = MEDIA_FORMAT_UYVY;
 357                 break;
 358         case MM_PIXEL_FORMAT_422P:
 359                 *mimetype = MEDIA_FORMAT_422P;
 360                 break;
 361         case MM_PIXEL_FORMAT_I420:
 362                 *mimetype = MEDIA_FORMAT_I420;
 363                 break;
 364         case MM_PIXEL_FORMAT_YV12:
 365                 *mimetype = MEDIA_FORMAT_YV12;
 366                 break;
 367         case MM_PIXEL_FORMAT_RGB565:
 368                 *mimetype = MEDIA_FORMAT_RGB565;
 369                 break;
 370         case MM_PIXEL_FORMAT_RGB888:
 371                 *mimetype = MEDIA_FORMAT_RGB888;
 372                 break;
 373         case MM_PIXEL_FORMAT_RGBA:
 374                 *mimetype = MEDIA_FORMAT_RGBA;
 375                 break;
 376         case MM_PIXEL_FORMAT_ARGB:
 377                 *mimetype = MEDIA_FORMAT_ARGB;
 378                 break;
 379         default:
 380                 LOGE("invalid in_format %d", in_format);
 381                 return CAMERA_ERROR_INVALID_PARAMETER;
 382         }
 383
 384         return CAMERA_ERROR_NONE;
 385 }
 386
 387 int _camera_media_packet_finalize(media_packet_h pkt, int error_code, void *user_data)
 388 {
 389         int i = 0;
 390         int ret = 0;
 391         camera_cb_info_s *cb_info = (camera_cb_info_s *)user_data;
 392         camera_media_packet_data *mp_data = NULL;
 393         tbm_surface_h tsurf = NULL;
 394
 395         if (pkt == NULL || cb_info == NULL) {
 396                 LOGE("invalid parameter buffer %p, cb_info %p", pkt, cb_info);
 397                 return MEDIA_PACKET_FINALIZE;
 398         }
 399
 400         ret = media_packet_get_extra(pkt, (void **)&mp_data);
 401         if (ret != MEDIA_PACKET_ERROR_NONE) {
 402                 LOGE("media_packet_get_extra failed 0x%x", ret);
 403                 return MEDIA_PACKET_FINALIZE;
 404         }
 405
 406         /*LOGD("mp_data %p", mp_data);*/
 407
 408         if (mp_data) {
 409                 int tbm_key = mp_data->tbm_key;
 410
 411                 /* release imported bo */
 412                 for (i = 0 ; i < mp_data->num_buffer_key ; i++) {
 413                         tbm_bo_unref(mp_data->buffer_bo[i]);
 414                         mp_data->buffer_bo[i] = NULL;
 415                 }
 416
 417                 /* unmap and unref tbm bo */
 418                 _release_imported_bo(&mp_data->bo);
 419
 420                 /* return buffer */
 421                 muse_camera_msg_send1_no_return(MUSE_CAMERA_API_RETURN_BUFFER,
 422                         cb_info->fd, cb_info, INT, tbm_key);
 423                 g_free(mp_data);
 424                 mp_data = NULL;
 425         }
 426
 427         ret = media_packet_get_tbm_surface(pkt, &tsurf);
 428         if (ret != MEDIA_PACKET_ERROR_NONE) {
 429                 LOGE("media_packet_get_tbm_surface failed 0x%x", ret);
 430                 return MEDIA_PACKET_FINALIZE;
 431         }
 432
 433         if (tsurf) {
 434                 tbm_surface_destroy(tsurf);
 435                 tsurf = NULL;
 436         }
 437
 438         return MEDIA_PACKET_FINALIZE;
 439 }
 440
 441 static void _client_user_callback(camera_cb_info_s *cb_info, char *recv_msg, muse_camera_event_e event)
 442 {
 443         int param1 = 0;
 444         int param2 = 0;
 445         int tbm_key = 0;
 446         tbm_bo bo = NULL;
 447         tbm_bo_handle bo_handle = {NULL, };
 448
 449         if (recv_msg == NULL || event >= MUSE_CAMERA_EVENT_TYPE_NUM) {
 450                 LOGE("invalid parameter - camera msg %p, event %d", recv_msg, event);
 451                 return;
 452         }
 453
 454         LOGD("get camera msg %s, event %d", recv_msg, event);
 455
 456         if (event == MUSE_CAMERA_EVENT_TYPE_PREVIEW) {
 457                 if (cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_PREVIEW] == NULL &&
 458                         cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_MEDIA_PACKET_PREVIEW] == NULL) {
 459                         LOGW("all preview callback from user are NULL");
 460                         return;
 461                 }
 462         } else if (cb_info->user_cb[event] == NULL) {
 463                 LOGW("user callback for event %d is not set", event);
 464                 return;
 465         }
 466
 467         switch (event) {
 468         case MUSE_CAMERA_EVENT_TYPE_STATE_CHANGE:
 469                 {
 470                         int previous = 0;
 471                         int current = 0;
 472                         int by_policy = 0;
 473
 474                         muse_camera_msg_get(previous, recv_msg);
 475                         muse_camera_msg_get(current, recv_msg);
 476                         muse_camera_msg_get(by_policy, recv_msg);
 477
 478                         LOGD("STATE CHANGE - previous %d, current %d, by_policy %d",
 479                              previous, current, by_policy);
 480
 481                         ((camera_state_changed_cb)cb_info->user_cb[event])((camera_state_e)previous,
 482                                 (camera_state_e)current, (bool)by_policy, cb_info->user_data[event]);
 483                 }
 484                 break;
 485         case MUSE_CAMERA_EVENT_TYPE_FOCUS_CHANGE:
 486                 {
 487                         int state = 0;
 488
 489                         muse_camera_msg_get(state, recv_msg);
 490
 491                         LOGD("FOCUS state - %d", state);
 492
 493                         ((camera_focus_changed_cb)cb_info->user_cb[event])((camera_focus_state_e)state, cb_info->user_data[event]);
 494                 }
 495                 break;
 496         case MUSE_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE:
 497                 LOGD("CAPTURE_COMPLETED");
 498                 ((camera_capture_completed_cb)cb_info->user_cb[event])(cb_info->user_data[event]);
 499                 break;
 500         case MUSE_CAMERA_EVENT_TYPE_PREVIEW:
 501         case MUSE_CAMERA_EVENT_TYPE_MEDIA_PACKET_PREVIEW:
 502                 {
 503                         camera_preview_data_s frame;
 504                         unsigned char *buf_pos = NULL;
 505                         MMCamcorderVideoStreamDataType *stream = NULL;
 506                         int i = 0;
 507                         int total_size = 0;
 508                         int num_buffer_key = 0;
 509                         int buffer_key[BUFFER_MAX_PLANE_NUM] = {0, };
 510                         tbm_bo buffer_bo[BUFFER_MAX_PLANE_NUM] = {NULL, };
 511                         tbm_bo_handle buffer_bo_handle[BUFFER_MAX_PLANE_NUM] = {{.ptr = NULL}, };
 512                         camera_media_packet_data *mp_data = NULL;
 513
 514                         muse_camera_msg_get(tbm_key, recv_msg);
 515                         muse_camera_msg_get(num_buffer_key, recv_msg);
 516                         muse_camera_msg_get_array(buffer_key, recv_msg);
 517
 518                         memset(&frame, 0x0, sizeof(camera_preview_data_s));
 519
 520                         if (tbm_key <= 0) {
 521                                 LOGE("invalid key %d", tbm_key);
 522                                 break;
 523                         }
 524
 525                         /* import tbm bo and get virtual address */
 526                         if (!_import_tbm_key(cb_info->bufmgr, tbm_key, &bo, &bo_handle)) {
 527                                 LOGE("failed to import key %d", tbm_key);
 528
 529                                 muse_camera_msg_send1_no_return(MUSE_CAMERA_API_RETURN_BUFFER,
 530                                         cb_info->fd, cb_info, INT, tbm_key);
 531                                 break;
 532                         }
 533
 534                         buf_pos = (unsigned char *)bo_handle.ptr;
 535
 536                         /* get stream info */
 537                         stream = (MMCamcorderVideoStreamDataType *)buf_pos;
 538
 539                         for (i = 0 ; i < num_buffer_key ; i++) {
 540                                 /* import buffer bo and get virtual address */
 541                                 if (!_import_tbm_key(cb_info->bufmgr, buffer_key[i], &buffer_bo[i], &buffer_bo_handle[i])) {
 542                                         LOGE("failed to import buffer key %d", buffer_key[i]);
 543
 544                                         /* release imported bo */
 545                                         for (i -= 1 ; i >= 0 ; i--)
 546                                                 _release_imported_bo(&buffer_bo[i]);
 547
 548                                         _release_imported_bo(&bo);
 549
 550                                         /* send return buffer */
 551                                         muse_camera_msg_send1_no_return(MUSE_CAMERA_API_RETURN_BUFFER,
 552                                                 cb_info->fd, cb_info, INT, tbm_key);
 553                                         return;
 554                                 }
 555                         }
 556
 557                         if (cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_PREVIEW]) {
 558                                 /* set frame info */
 559                                 if (stream->format == MM_PIXEL_FORMAT_ITLV_JPEG_UYVY)
 560                                         frame.format  = MM_PIXEL_FORMAT_UYVY;
 561                                 else
 562                                         frame.format = stream->format;
 563                                 frame.width = stream->width;
 564                                 frame.height = stream->height;
 565                                 frame.timestamp = stream->timestamp;
 566                                 frame.num_of_planes = stream->num_planes;
 567
 568                                 if (num_buffer_key == 0) {
 569                                         /* non-zero copy */
 570                                         buf_pos += sizeof(MMCamcorderVideoStreamDataType);
 571
 572                                         if (stream->format == MM_PIXEL_FORMAT_ENCODED_H264) {
 573                                                 frame.data.encoded_plane.data = buf_pos;
 574                                                 frame.data.encoded_plane.size = stream->data.encoded.length_data;
 575                                                 total_size = stream->data.encoded.length_data;
 576                                         } else {
 577                                                 switch (stream->num_planes) {
 578                                                 case 1:
 579                                                         frame.data.single_plane.yuv = buf_pos;
 580                                                         frame.data.single_plane.size = stream->data.yuv420.length_yuv;
 581                                                         total_size = stream->data.yuv420.length_yuv;
 582                                                         break;
 583                                                 case 2:
 584                                                         frame.data.double_plane.y = buf_pos;
 585                                                         frame.data.double_plane.y_size = stream->data.yuv420sp.length_y;
 586                                                         buf_pos += stream->data.yuv420sp.length_y;
 587                                                         frame.data.double_plane.uv = buf_pos;
 588                                                         frame.data.double_plane.uv_size = stream->data.yuv420sp.length_uv;
 589                                                         total_size = stream->data.yuv420sp.length_y + \
 590                                                                 stream->data.yuv420sp.length_uv;
 591                                                         break;
 592                                                 case 3:
 593                                                         frame.data.triple_plane.y = buf_pos;
 594                                                         frame.data.triple_plane.y_size = stream->data.yuv420p.length_y;
 595                                                         buf_pos += stream->data.yuv420p.length_y;
 596                                                         frame.data.triple_plane.u = buf_pos;
 597                                                         frame.data.triple_plane.u_size = stream->data.yuv420p.length_u;
 598                                                         buf_pos += stream->data.yuv420p.length_u;
 599                                                         frame.data.triple_plane.v = buf_pos;
 600                                                         frame.data.triple_plane.v_size = stream->data.yuv420p.length_v;
 601                                                         total_size = stream->data.yuv420p.length_y + \
 602                                                                 stream->data.yuv420p.length_u + \
 603                                                                 stream->data.yuv420p.length_v;
 604                                                         break;
 605                                                 default:
 606                                                         break;
 607                                                 }
 608                                         }
 609                                 } else {
 610                                         /* zero copy */
 611                                         switch (stream->num_planes) {
 612                                         case 1:
 613                                                 frame.data.single_plane.yuv = buffer_bo_handle[0].ptr;
 614                                                 frame.data.single_plane.size = stream->data.yuv420.length_yuv;
 615                                                 total_size = stream->data.yuv420.length_yuv;
 616                                                 break;
 617                                         case 2:
 618                                                 frame.data.double_plane.y = buffer_bo_handle[0].ptr;
 619                                                 if (stream->num_planes == (unsigned int)num_buffer_key)
 620                                                         frame.data.double_plane.uv = buffer_bo_handle[1].ptr;
 621                                                 else
 622                                                         frame.data.double_plane.uv = buffer_bo_handle[0].ptr + stream->data.yuv420sp.length_y;
 623                                                 frame.data.double_plane.y_size = stream->data.yuv420sp.length_y;
 624                                                 frame.data.double_plane.uv_size = stream->data.yuv420sp.length_uv;
 625                                                 total_size = stream->data.yuv420sp.length_y + \
 626                                                         stream->data.yuv420sp.length_uv;
 627                                                 break;
 628                                         case 3:
 629                                                 frame.data.triple_plane.y = buffer_bo_handle[0].ptr;
 630                                                 if (stream->num_planes == (unsigned int)num_buffer_key) {
 631                                                         frame.data.triple_plane.u = buffer_bo_handle[1].ptr;
 632                                                         frame.data.triple_plane.v = buffer_bo_handle[2].ptr;
 633                                                 } else {
 634                                                         frame.data.triple_plane.u = buffer_bo_handle[0].ptr + stream->data.yuv420p.length_y;
 635                                                         frame.data.triple_plane.v = buffer_bo_handle[1].ptr + stream->data.yuv420p.length_u;
 636                                                 }
 637                                                 frame.data.triple_plane.y_size = stream->data.yuv420p.length_y;
 638                                                 frame.data.triple_plane.u_size = stream->data.yuv420p.length_u;
 639                                                 frame.data.triple_plane.v_size = stream->data.yuv420p.length_v;
 640                                                 total_size = stream->data.yuv420p.length_y + \
 641                                                         stream->data.yuv420p.length_u + \
 642                                                         stream->data.yuv420p.length_v;
 643                                                 break;
 644                                         default:
 645                                                 break;
 646                                         }
 647                                 }
 648
 649                                 /*
 650                                 LOGD("PREVIEW_CB - format %d, %dx%d, size %d plane num %d",
 651                                      frame.format, frame.width, frame.height, total_size, frame.num_of_planes);
 652                                 */
 653
 654                                 ((camera_preview_cb)cb_info->user_cb[event])(&frame, cb_info->user_data[event]);
 655
 656                                 /*LOGD("PREVIEW_CB retuned");*/
 657                         }
 658
 659                         if (cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_MEDIA_PACKET_PREVIEW]) {
 660                                 media_packet_h pkt = NULL;
 661                                 tbm_surface_h tsurf = NULL;
 662                                 uint32_t bo_format = 0;
 663                                 int ret = 0;
 664                                 media_format_mimetype_e mimetype = MEDIA_FORMAT_NV12;
 665                                 bool make_pkt_fmt = false;
 666                                 tbm_surface_info_s tsurf_info;
 667
 668                                 memset(&tsurf_info, 0x0, sizeof(tbm_surface_info_s));
 669
 670                                 /* unmap buffer bo */
 671                                 for (i = 0 ; i < num_buffer_key ; i++) {
 672                                         if (buffer_bo[i])
 673                                                 tbm_bo_unmap(buffer_bo[i]);
 674                                 }
 675
 676                                 /* create tbm surface */
 677                                 for (i = 0 ; i < BUFFER_MAX_PLANE_NUM ; i++)
 678                                         tsurf_info.planes[i].stride = stream->stride[i];
 679
 680                                 /* get tbm surface format */
 681                                 ret = _camera_get_tbm_surface_format(stream->format, &bo_format);
 682                                 ret |= _camera_get_media_packet_mimetype(stream->format, &mimetype);
 683
 684                                 if (num_buffer_key > 0 && ret == CAMERA_ERROR_NONE) {
 685                                         tsurf_info.width = stream->width;
 686                                         tsurf_info.height = stream->height;
 687                                         tsurf_info.format = bo_format;
 688                                         tsurf_info.bpp = tbm_surface_internal_get_bpp(bo_format);
 689                                         tsurf_info.num_planes = tbm_surface_internal_get_num_planes(bo_format);
 690
 691                                         switch (bo_format) {
 692                                         case TBM_FORMAT_NV12:
 693                                         case TBM_FORMAT_NV21:
 694                                                 tsurf_info.planes[0].size = stream->stride[0] * stream->elevation[0];
 695                                                 tsurf_info.planes[1].size = stream->stride[1] * stream->elevation[1];
 696                                                 tsurf_info.planes[0].offset = 0;
 697                                                 if (num_buffer_key == 1)
 698                                                         tsurf_info.planes[1].offset = tsurf_info.planes[0].size;
 699                                                 tsurf_info.size = tsurf_info.planes[0].size + tsurf_info.planes[1].size;
 700                                                 break;
 701                                         case TBM_FORMAT_YUV420:
 702                                         case TBM_FORMAT_YVU420:
 703                                                 tsurf_info.planes[0].size = stream->stride[0] * stream->elevation[0];
 704                                                 tsurf_info.planes[1].size = stream->stride[1] * stream->elevation[1];
 705                                                 tsurf_info.planes[2].size = stream->stride[2] * stream->elevation[2];
 706                                                 tsurf_info.planes[0].offset = 0;
 707                                                 if (num_buffer_key == 1) {
 708                                                         tsurf_info.planes[1].offset = tsurf_info.planes[0].size;
 709                                                         tsurf_info.planes[2].offset = tsurf_info.planes[0].size + tsurf_info.planes[1].size;
 710                                                 }
 711                                                 tsurf_info.size = tsurf_info.planes[0].size + tsurf_info.planes[1].size + tsurf_info.planes[2].size;
 712                                                 break;
 713                                         case TBM_FORMAT_UYVY:
 714                                         case TBM_FORMAT_YUYV:
 715                                                 tsurf_info.planes[0].size = (stream->stride[0] * stream->elevation[0]) << 1;
 716                                                 tsurf_info.planes[0].offset = 0;
 717                                                 tsurf_info.size = tsurf_info.planes[0].size;
 718                                                 break;
 719                                         default:
 720                                                 break;
 721                                         }
 722
 723                                         tsurf = tbm_surface_internal_create_with_bos(&tsurf_info, buffer_bo, num_buffer_key);
 724                                         /*LOGD("tbm surface %p", tsurf);*/
 725                                 }
 726
 727                                 if (tsurf) {
 728                                         /* check media packet format */
 729                                         if (cb_info->pkt_fmt) {
 730                                                 int pkt_fmt_width = 0;
 731                                                 int pkt_fmt_height = 0;
 732                                                 media_format_mimetype_e pkt_fmt_mimetype = MEDIA_FORMAT_NV12;
 733
 734                                                 media_format_get_video_info(cb_info->pkt_fmt, &pkt_fmt_mimetype, &pkt_fmt_width, &pkt_fmt_height, NULL, NULL);
 735                                                 if (pkt_fmt_mimetype != mimetype ||
 736                                                     pkt_fmt_width != stream->width ||
 737                                                     pkt_fmt_height != stream->height) {
 738                                                         LOGW("different format. current 0x%x, %dx%d, new 0x%x, %dx%d",
 739                                                              pkt_fmt_mimetype, pkt_fmt_width, pkt_fmt_height, mimetype, stream->width, stream->height);
 740                                                         media_format_unref(cb_info->pkt_fmt);
 741                                                         cb_info->pkt_fmt = NULL;
 742                                                         make_pkt_fmt = true;
 743                                                 }
 744                                         } else {
 745                                                 make_pkt_fmt = true;
 746                                         }
 747
 748                                         /* create packet format */
 749                                         if (make_pkt_fmt) {
 750                                                 LOGW("make new pkt_fmt - mimetype 0x%x, %dx%d", mimetype, stream->width, stream->height);
 751                                                 ret = media_format_create(&cb_info->pkt_fmt);
 752                                                 if (ret == MEDIA_FORMAT_ERROR_NONE) {
 753                                                         ret = media_format_set_video_mime(cb_info->pkt_fmt, mimetype);
 754                                                         ret |= media_format_set_video_width(cb_info->pkt_fmt, stream->width);
 755                                                         ret |= media_format_set_video_height(cb_info->pkt_fmt, stream->height);
 756                                                         LOGW("media_format_set_video_mime,width,height ret : 0x%x", ret);
 757                                                 } else {
 758                                                         LOGW("media_format_create failed");
 759                                                 }
 760                                         }
 761
 762                                         /* create media packet */
 763                                         ret = media_packet_create_from_tbm_surface(cb_info->pkt_fmt,
 764                                                 tsurf, (media_packet_finalize_cb)_camera_media_packet_finalize,
 765                                                 (void *)cb_info, &pkt);
 766                                         if (ret != MEDIA_PACKET_ERROR_NONE) {
 767                                                 LOGE("media_packet_create_from_tbm_surface failed");
 768
 769                                                 tbm_surface_destroy(tsurf);
 770                                                 tsurf = NULL;
 771                                         }
 772                                 } else {
 773                                         LOGE("failed to create tbm surface %dx%d, format %d, num_buffer_key %d",
 774                                              stream->width, stream->height, stream->format, num_buffer_key);
 775                                 }
 776
 777                                 if (pkt) {
 778                                         /*LOGD("media packet %p, internal buffer %p", pkt, stream->internal_buffer);*/
 779
 780                                         mp_data = g_new0(camera_media_packet_data, 1);
 781                                         if (mp_data) {
 782                                                 mp_data->tbm_key = tbm_key;
 783                                                 mp_data->num_buffer_key = num_buffer_key;
 784                                                 mp_data->bo = bo;
 785                                                 for (i = 0 ; i < num_buffer_key ; i++)
 786                                                         mp_data->buffer_bo[i] = buffer_bo[i];
 787
 788                                                 /* set media packet data */
 789                                                 ret = media_packet_set_extra(pkt, (void *)mp_data);
 790                                                 if (ret != MEDIA_PACKET_ERROR_NONE) {
 791                                                         LOGE("media_packet_set_extra failed");
 792
 793                                                         if (mp_data) {
 794                                                                 g_free(mp_data);
 795                                                                 mp_data = NULL;
 796                                                         }
 797
 798                                                         media_packet_destroy(pkt);
 799                                                         pkt = NULL;
 800                                                 } else {
 801                                                         int e_type = MUSE_CAMERA_EVENT_TYPE_MEDIA_PACKET_PREVIEW;
 802
 803                                                         /* set timestamp : msec -> nsec */
 804                                                         if (media_packet_set_pts(pkt, (uint64_t)(stream->timestamp) * 1000000) != MEDIA_PACKET_ERROR_NONE)
 805                                                                 LOGW("media_packet_set_pts failed");
 806
 807                                                         /* call media packet callback */
 808                                                         ((camera_media_packet_preview_cb)cb_info->user_cb[e_type])(pkt, cb_info->user_data[e_type]);
 809                                                 }
 810                                         } else {
 811                                                 LOGE("failed to alloc media packet data");
 812                                         }
 813                                 }
 814                         }
 815
 816                         /* send message for preview callback return */
 817                         muse_camera_msg_send_no_return(MUSE_CAMERA_API_PREVIEW_CB_RETURN, cb_info->fd, cb_info);
 818
 819                         if (mp_data == NULL) {
 820                                 /* release imported bo */
 821                                 for (i = 0 ; i < num_buffer_key ; i++)
 822                                         _release_imported_bo(&buffer_bo[i]);
 823
 824                                 /* unmap and unref tbm bo */
 825                                 _release_imported_bo(&bo);
 826
 827                                 /* return buffer */
 828                                 muse_camera_msg_send1_no_return(MUSE_CAMERA_API_RETURN_BUFFER,
 829                                         cb_info->fd, cb_info, INT, tbm_key);
 830
 831                                 /*LOGD("return buffer Done");*/
 832                         }
 833                 }
 834                 break;
 835         case MUSE_CAMERA_EVENT_TYPE_HDR_PROGRESS:
 836                 {
 837                         int percent = 0;
 838
 839                         muse_camera_msg_get(percent, recv_msg);
 840
 841                         LOGD("HDR progress - %d \%", percent);
 842
 843                         ((camera_attr_hdr_progress_cb)cb_info->user_cb[event])(percent, cb_info->user_data[event]);
 844                 }
 845                 break;
 846         case MUSE_CAMERA_EVENT_TYPE_INTERRUPTED:
 847                 {
 848                         int policy = 0;
 849                         int previous = 0;
 850                         int current = 0;
 851
 852                         muse_camera_msg_get(policy, recv_msg);
 853                         muse_camera_msg_get(previous, recv_msg);
 854                         muse_camera_msg_get(current, recv_msg);
 855
 856                         LOGD("INTERRUPTED - policy %d, state previous %d, current %d",
 857                              policy, previous, current);
 858
 859                         ((camera_interrupted_cb)cb_info->user_cb[event])((camera_policy_e)policy,
 860                                 (camera_state_e)previous, (camera_state_e)current, cb_info->user_data[event]);
 861                 }
 862                 break;
 863         case MUSE_CAMERA_EVENT_TYPE_FACE_DETECTION:
 864                 {
 865                         int count = 0;
 866                         camera_detected_face_s *faces = NULL;
 867
 868                         muse_camera_msg_get(count, recv_msg);
 869                         muse_camera_msg_get(tbm_key, recv_msg);
 870
 871                         if (count > 0 && tbm_key > 0) {
 872                                 LOGD("FACE_DETECTION - count %d, tbm_key %d", count, tbm_key);
 873
 874                                 if (!_import_tbm_key(cb_info->bufmgr, tbm_key, &bo, &bo_handle))
 875                                         break;
 876
 877                                 /* set face info */
 878                                 faces = bo_handle.ptr;
 879
 880                                 ((camera_face_detected_cb)cb_info->user_cb[event])(faces, count, cb_info->user_data[event]);
 881
 882 #if 0
 883                                 {
 884                                         int i = 0;
 885
 886                                         for (i = 0 ; i < count ; i++) {
 887                                                 LOGD("id[%2d] - score %d, position (%d,%d,%dx%d)",
 888                                                      i, faces[i].score, faces[i].x, faces[i].y, faces[i].width, faces[i].height);
 889                                         }
 890                                 }
 891 #endif
 892
 893                                 /* release bo */
 894                                 _release_imported_bo(&bo);
 895
 896                                 /* return buffer */
 897                                 muse_camera_msg_send1_no_return(MUSE_CAMERA_API_RETURN_BUFFER,
 898                                         cb_info->fd, cb_info, INT, tbm_key);
 899
 900                                 LOGD("return buffer done");
 901                         } else {
 902                                 LOGE("invalid message - count %d, key %d", count, tbm_key);
 903                         }
 904                 }
 905                 break;
 906         case MUSE_CAMERA_EVENT_TYPE_ERROR:
 907                 {
 908                         int error = 0;
 909                         int current_state = 0;
 910
 911                         muse_camera_msg_get(error, recv_msg);
 912                         muse_camera_msg_get(current_state, recv_msg);
 913
 914                         LOGE("ERROR - error 0x%x, current_state %d", error, current_state);
 915
 916                         ((camera_error_cb)cb_info->user_cb[event])((camera_error_e)error,
 917                                 (camera_state_e)current_state, cb_info->user_data[event]);
 918                 }
 919                 break;
 920         case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_RESOLUTION:
 921                 muse_camera_msg_get(param1, recv_msg);
 922                 muse_camera_msg_get(param2, recv_msg);
 923
 924                 LOGD("SUPPORTED_PREVIEW_RESOLUTION - %d x %d", param1, param2);
 925
 926                 if (((camera_supported_preview_resolution_cb)cb_info->user_cb[event])(param1, param2, cb_info->user_data[event]) == false) {
 927                         cb_info->user_cb[event] = NULL;
 928                         cb_info->user_data[event] = NULL;
 929                         LOGD("stop foreach callback for SUPPORTED_PREVIEW_RESOLUTION");
 930                 }
 931                 break;
 932         case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_RESOLUTION:
 933                 muse_camera_msg_get(param1, recv_msg);
 934                 muse_camera_msg_get(param2, recv_msg);
 935
 936                 LOGD("SUPPORTED_CAPTURE_RESOLUTION - %d x %d", param1, param2);
 937
 938                 if (((camera_supported_capture_resolution_cb)cb_info->user_cb[event])(param1, param2, cb_info->user_data[event]) == false) {
 939                         cb_info->user_cb[event] = NULL;
 940                         cb_info->user_data[event] = NULL;
 941                         LOGD("stop foreach callback for SUPPORTED_CAPTURE_RESOLUTION");
 942                 }
 943                 break;
 944         case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_FORMAT:
 945                 muse_camera_msg_get(param1, recv_msg);
 946
 947                 LOGD("SUPPORTED_CAPTURE_FORMAT - %d ", param1);
 948
 949                 if (((camera_supported_capture_format_cb)cb_info->user_cb[event])((camera_pixel_format_e)param1, cb_info->user_data[event]) == false) {
 950                         cb_info->user_cb[event] = NULL;
 951                         cb_info->user_data[event] = NULL;
 952                         LOGD("stop foreach callback for SUPPORTED_CAPTURE_FORMAT");
 953                 }
 954                 break;
 955         case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_FORMAT:
 956                 muse_camera_msg_get(param1, recv_msg);
 957
 958                 LOGD("SUPPORTED_PREVIEW_FORMAT - %d ", param1);
 959
 960                 if (((camera_supported_preview_format_cb)cb_info->user_cb[event])((camera_pixel_format_e)param1, cb_info->user_data[event]) == false) {
 961                         cb_info->user_cb[event] = NULL;
 962                         cb_info->user_data[event] = NULL;
 963                         LOGD("stop foreach callback for SUPPORTED_PREVIEW_FORMAT");
 964                 }
 965                 break;
 966         case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_AF_MODE:
 967                 muse_camera_msg_get(param1, recv_msg);
 968
 969                 LOGD("SUPPORTED_AF_MODE - %d ", param1);
 970
 971                 if (((camera_attr_supported_af_mode_cb)cb_info->user_cb[event])((camera_attr_af_mode_e)param1, cb_info->user_data[event]) == false) {
 972                         cb_info->user_cb[event] = NULL;
 973                         cb_info->user_data[event] = NULL;
 974                         LOGD("stop foreach callback for SUPPORTED_AF_MODE");
 975                 }
 976                 break;
 977         case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EXPOSURE_MODE:
 978                 muse_camera_msg_get(param1, recv_msg);
 979
 980                 LOGD("SUPPORTED_EXPOSURE_MODE - %d ", param1);
 981
 982                 if (((camera_attr_supported_exposure_mode_cb)cb_info->user_cb[event])((camera_attr_exposure_mode_e)param1, cb_info->user_data[event]) == false) {
 983                         cb_info->user_cb[event] = NULL;
 984                         cb_info->user_data[event] = NULL;
 985                         LOGD("stop foreach callback for SUPPORTED_EXPOSURE_MODE");
 986                 }
 987                 break;
 988         case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_ISO:
 989                 muse_camera_msg_get(param1, recv_msg);
 990
 991                 LOGD("SUPPORTED_ISO - %d ", param1);
 992
 993                 if (((camera_attr_supported_iso_cb)cb_info->user_cb[event])((camera_attr_iso_e)param1, cb_info->user_data[event]) == false) {
 994                         cb_info->user_cb[event] = NULL;
 995                         cb_info->user_data[event] = NULL;
 996                         LOGD("stop foreach callback for SUPPORTED_ISO");
 997                 }
 998                 break;
 999         case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_WHITEBALANCE:
1000                 muse_camera_msg_get(param1, recv_msg);
1001
1002                 LOGD("SUPPORTED_WHITEBALANCE - %d ", param1);
1003
1004                 if (((camera_attr_supported_whitebalance_cb)cb_info->user_cb[event])((camera_attr_whitebalance_e)param1, cb_info->user_data[event]) == false) {
1005                         cb_info->user_cb[event] = NULL;
1006                         cb_info->user_data[event] = NULL;
1007                         LOGD("stop foreach callback for SUPPORTED_WHITEBALANCE");
1008                 }
1009                 break;
1010         case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EFFECT:
1011                 muse_camera_msg_get(param1, recv_msg);
1012
1013                 LOGD("SUPPORTED_EFFECT - %d ", param1);
1014
1015                 if (((camera_attr_supported_effect_cb)cb_info->user_cb[event])((camera_attr_effect_mode_e)param1, cb_info->user_data[event]) == false) {
1016                         cb_info->user_cb[event] = NULL;
1017                         cb_info->user_data[event] = NULL;
1018                         LOGD("stop foreach callback for SUPPORTED_EFFECT");
1019                 }
1020                 break;
1021         case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_SCENE_MODE:
1022                 muse_camera_msg_get(param1, recv_msg);
1023
1024                 LOGD("SUPPORTED_SCENE_MODE - %d ", param1);
1025
1026                 if (((camera_attr_supported_scene_mode_cb)cb_info->user_cb[event])((camera_attr_scene_mode_e)param1, cb_info->user_data[event]) == false) {
1027                         cb_info->user_cb[event] = NULL;
1028                         cb_info->user_data[event] = NULL;
1029                         LOGD("stop foreach callback for SUPPORTED_SCENE_MODE");
1030                 }
1031                 break;
1032         case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FLASH_MODE:
1033                 muse_camera_msg_get(param1, recv_msg);
1034
1035                 LOGD("SUPPORTED_FLASH_MODE - %d ", param1);
1036
1037                 if (((camera_attr_supported_flash_mode_cb)cb_info->user_cb[event])((camera_attr_flash_mode_e)param1, cb_info->user_data[event]) == false) {
1038                         cb_info->user_cb[event] = NULL;
1039                         cb_info->user_data[event] = NULL;
1040                         LOGD("stop foreach callback for SUPPORTED_FLASH_MODE");
1041                 }
1042                 break;
1043         case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS:
1044                 muse_camera_msg_get(param1, recv_msg);
1045
1046                 LOGD("SUPPORTED_FPS - %d ", param1);
1047
1048                 if (((camera_attr_supported_fps_cb)cb_info->user_cb[event])((camera_attr_fps_e)param1, cb_info->user_data[event]) == false) {
1049                         cb_info->user_cb[event] = NULL;
1050                         cb_info->user_data[event] = NULL;
1051                         LOGD("stop foreach callback for SUPPORTED_FPS");
1052                 }
1053                 break;
1054         case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS_BY_RESOLUTION:
1055                 muse_camera_msg_get(param1, recv_msg);
1056
1057                 LOGD("SUPPORTED_FPS_BY_RESOLUTION - %d ", param1);
1058
1059                 if (((camera_attr_supported_fps_cb)cb_info->user_cb[event])((camera_attr_fps_e)param1, cb_info->user_data[event]) == false) {
1060                         cb_info->user_cb[event] = NULL;
1061                         cb_info->user_data[event] = NULL;
1062                         LOGD("stop foreach callback for SUPPORTED_FPS_BY_RESOLUTION");
1063                 }
1064                 break;
1065         case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_FLIP:
1066                 muse_camera_msg_get(param1, recv_msg);
1067
1068                 LOGD("SUPPORTED_STREAM_FLIP - %d ", param1);
1069
1070                 if (((camera_attr_supported_stream_flip_cb)cb_info->user_cb[event])((camera_flip_e)param1, cb_info->user_data[event]) == false) {
1071                         cb_info->user_cb[event] = NULL;
1072                         cb_info->user_data[event] = NULL;
1073                         LOGD("stop foreach callback for SUPPORTED_STREAM_FLIP");
1074                 }
1075                 break;
1076         case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_ROTATION:
1077                 muse_camera_msg_get(param1, recv_msg);
1078
1079                 LOGD("SUPPORTED_STREAM_ROTATION - %d ", param1);
1080
1081                 if (((camera_attr_supported_stream_rotation_cb)cb_info->user_cb[event])((camera_rotation_e)param1, cb_info->user_data[event]) == false) {
1082                         cb_info->user_cb[event] = NULL;
1083                         cb_info->user_data[event] = NULL;
1084                         LOGD("stop foreach callback for SUPPORTED_STREAM_ROTATION");
1085                 }
1086                 break;
1087         case MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_THEATER_MODE:
1088                 muse_camera_msg_get(param1, recv_msg);
1089
1090                 LOGD("SUPPORTED_THEATER_MODE - %d ", param1);
1091
1092                 if (((camera_attr_supported_theater_mode_cb)cb_info->user_cb[event])((camera_attr_theater_mode_e)param1, cb_info->user_data[event]) == false) {
1093                         cb_info->user_cb[event] = NULL;
1094                         cb_info->user_data[event] = NULL;
1095                         LOGD("stop foreach callback for SUPPORTED_THEATER_MODE");
1096                 }
1097                 break;
1098         case MUSE_CAMERA_EVENT_TYPE_CAPTURE:
1099                 {
1100                         camera_image_data_s *rImage = NULL;
1101                         camera_image_data_s *rPostview = NULL;
1102                         camera_image_data_s *rThumbnail = NULL;
1103                         unsigned char *buf_pos = NULL;
1104                         int is_postview = 0;
1105                         int is_thumbnail = 0;
1106
1107                         muse_camera_msg_get(tbm_key, recv_msg);
1108                         muse_camera_msg_get(is_postview, recv_msg);
1109                         muse_camera_msg_get(is_thumbnail, recv_msg);
1110
1111                         LOGD("camera capture callback came in. key %d, postview %d, thumbnail %d",
1112                              tbm_key, is_postview, is_thumbnail);
1113
1114                         if (tbm_key <= 0) {
1115                                 LOGE("invalid key %d", tbm_key);
1116                                 break;
1117                         }
1118
1119                         /* import tbm bo and get virtual address */
1120                         if (!_import_tbm_key(cb_info->bufmgr, tbm_key, &bo, &bo_handle))
1121                                 break;
1122
1123                         buf_pos = (unsigned char *)bo_handle.ptr;
1124                         rImage = (camera_image_data_s *)buf_pos;
1125                         rImage->data = buf_pos + sizeof(camera_image_data_s);
1126                         buf_pos += sizeof(camera_image_data_s) + rImage->size;
1127
1128                         if (is_postview) {
1129                                 rPostview = (camera_image_data_s *)buf_pos;
1130                                 LOGD("rPostview->size : %d", rPostview->size);
1131                                 rPostview->data = buf_pos + sizeof(camera_image_data_s);
1132                                 buf_pos += sizeof(camera_image_data_s) + rPostview->size;
1133                         }
1134
1135                         if (is_thumbnail) {
1136                                 rThumbnail = (camera_image_data_s *)buf_pos;
1137                                 LOGD("rThumbnail->size : %d", rThumbnail->size);
1138                                 rThumbnail->data = buf_pos + sizeof(camera_image_data_s);
1139                                 buf_pos += sizeof(camera_image_data_s) + rThumbnail->size;
1140                         }
1141
1142                         LOGD("image info %dx%d, size : %d", rImage->height, rImage->width, rImage->size);
1143
1144                         ((camera_capturing_cb)cb_info->user_cb[event])(rImage, rPostview, rThumbnail, cb_info->user_data[event]);
1145
1146                         /* unmap and unref tbm bo */
1147                         _release_imported_bo(&bo);
1148
1149                         /* return buffer */
1150                         muse_camera_msg_send1_no_return(MUSE_CAMERA_API_RETURN_BUFFER,
1151                                 cb_info->fd, cb_info, INT, tbm_key);
1152
1153                         LOGD("return buffer done");
1154                 }
1155                 break;
1156         case MUSE_CAMERA_EVENT_TYPE_VIDEO_FRAME_RENDER_ERROR:
1157                 break;
1158         default:
1159                 LOGW("Unknown event : %d", event);
1160                 break;
1161         }
1162
1163         return;
1164 }
1165
1166 static bool _camera_idle_event_callback(void *data)
1167 {
1168         camera_cb_info_s *cb_info = NULL;
1169         camera_idle_event_s *cam_idle_event = (camera_idle_event_s *)data;
1170
1171         if (cam_idle_event == NULL) {
1172                 LOGE("cam_idle_event is NULL");
1173                 return false;
1174         }
1175
1176         /* lock event */
1177         g_mutex_lock(&cam_idle_event->event_mutex);
1178
1179         cb_info = cam_idle_event->cb_info;
1180         if (cb_info == NULL) {
1181                 LOGW("camera cb_info is NULL. event %d", cam_idle_event->event);
1182                 goto IDLE_EVENT_CALLBACK_DONE;
1183         }
1184
1185         /* remove event from list */
1186         g_mutex_lock(&cb_info->idle_event_mutex);
1187         if (cb_info->idle_event_list)
1188                 cb_info->idle_event_list = g_list_remove(cb_info->idle_event_list, (gpointer)cam_idle_event);
1189
1190         /*LOGD("remove camera idle event %p, %p", cam_idle_event, cb_info->idle_event_list);*/
1191         g_mutex_unlock(&cb_info->idle_event_mutex);
1192
1193         /* user callback */
1194         _client_user_callback(cam_idle_event->cb_info, cam_idle_event->recv_msg, cam_idle_event->event);
1195
1196         /* send signal for waiting thread */
1197         g_cond_signal(&cb_info->idle_event_cond);
1198
1199 IDLE_EVENT_CALLBACK_DONE:
1200         /* unlock and release event */
1201         g_mutex_unlock(&cam_idle_event->event_mutex);
1202         g_mutex_clear(&cam_idle_event->event_mutex);
1203
1204         free(cam_idle_event);
1205         cam_idle_event = NULL;
1206
1207         return false;
1208 }
1209
1210 static void *_camera_msg_handler_func(gpointer data)
1211 {
1212         int ret = 0;
1213         int api = 0;
1214         int event = 0;
1215         int event_class = 0;
1216         camera_message_s *cam_msg = NULL;
1217         camera_idle_event_s *cam_idle_event = NULL;
1218         camera_cb_info_s *cb_info = (camera_cb_info_s *)data;
1219
1220         if (cb_info == NULL) {
1221                 LOGE("cb_info NULL");
1222                 return NULL;
1223         }
1224
1225         LOGD("start");
1226
1227         g_mutex_lock(&cb_info->msg_handler_mutex);
1228
1229         while (g_atomic_int_get(&cb_info->msg_handler_running)) {
1230                 if (g_queue_is_empty(cb_info->msg_queue)) {
1231                         LOGD("signal wait...");
1232                         g_cond_wait(&cb_info->msg_handler_cond, &cb_info->msg_handler_mutex);
1233                         LOGD("signal received");
1234
1235                         if (g_atomic_int_get(&cb_info->msg_handler_running) == 0) {
1236                                 LOGD("stop event thread");
1237                                 break;
1238                         }
1239                 }
1240
1241                 cam_msg = (camera_message_s *)g_queue_pop_head(cb_info->msg_queue);
1242
1243                 g_mutex_unlock(&cb_info->msg_handler_mutex);
1244
1245                 if (cam_msg == NULL) {
1246                         LOGE("NULL message");
1247                         g_mutex_lock(&cb_info->msg_handler_mutex);
1248                         continue;
1249                 }
1250
1251                 api = cam_msg->api;
1252
1253                 if (api < MUSE_CAMERA_API_MAX) {
1254                         g_mutex_lock(&cb_info->api_mutex[api]);
1255
1256                         if (muse_camera_msg_get(ret, cam_msg->recv_msg)) {
1257                                 cb_info->api_ret[api] = ret;
1258                                 cb_info->api_activating[api] = 1;
1259
1260                                 LOGD("camera api %d - return 0x%x", ret);
1261
1262                                 g_cond_signal(&cb_info->api_cond[api]);
1263                         } else {
1264                                 LOGE("failed to get camera ret for api %d, msg %s", api, cam_msg->recv_msg);
1265                         }
1266
1267                         g_mutex_unlock(&cb_info->api_mutex[api]);
1268                 } else if (api == MUSE_CAMERA_CB_EVENT) {
1269                         event = -1;
1270                         event_class = -1;
1271
1272                         if (!muse_camera_msg_get(event, cam_msg->recv_msg) ||
1273                             !muse_camera_msg_get(event_class, cam_msg->recv_msg)) {
1274                                 LOGE("failed to get camera event %d, class %d", event, event_class);
1275
1276                                 g_free(cam_msg);
1277                                 cam_msg = NULL;
1278
1279                                 g_mutex_lock(&cb_info->msg_handler_mutex);
1280                                 continue;
1281                         }
1282
1283                         switch (event_class) {
1284                         case MUSE_CAMERA_EVENT_CLASS_THREAD_SUB:
1285                                 _client_user_callback(cb_info, cam_msg->recv_msg, event);
1286                                 break;
1287                         case MUSE_CAMERA_EVENT_CLASS_THREAD_MAIN:
1288                                 cam_idle_event = (camera_idle_event_s *)malloc(sizeof(camera_idle_event_s));
1289                                 if (cam_idle_event == NULL) {
1290                                         LOGE("cam_idle_event alloc failed");
1291                                         break;
1292                                 }
1293
1294                                 cam_idle_event->event = event;
1295                                 cam_idle_event->cb_info = cb_info;
1296                                 g_mutex_init(&cam_idle_event->event_mutex);
1297                                 memcpy(cam_idle_event->recv_msg, cam_msg->recv_msg, sizeof(cam_idle_event->recv_msg));
1298
1299                                 LOGD("add camera event[%d, %p] to IDLE", event, cam_idle_event);
1300
1301                                 g_mutex_lock(&cb_info->idle_event_mutex);
1302                                 cb_info->idle_event_list = g_list_append(cb_info->idle_event_list, (gpointer)cam_idle_event);
1303                                 g_mutex_unlock(&cb_info->idle_event_mutex);
1304
1305                                 g_idle_add_full(G_PRIORITY_DEFAULT,
1306                                         (GSourceFunc)_camera_idle_event_callback,
1307                                         (gpointer)cam_idle_event,
1308                                         NULL);
1309                                 break;
1310                         default:
1311                                 LOGE("unknown camera event class %d", event_class);
1312                                 break;
1313                         }
1314                 } else {
1315                         LOGE("unknown camera api[%d] message[%s]", api, cam_msg->recv_msg);
1316                 }
1317
1318                 free(cam_msg);
1319                 cam_msg = NULL;
1320
1321                 g_mutex_lock(&cb_info->msg_handler_mutex);
1322         }
1323
1324         /* remove remained event */
1325         while (!g_queue_is_empty(cb_info->msg_queue)) {
1326                 cam_msg = (camera_message_s *)g_queue_pop_head(cb_info->msg_queue);
1327                 if (cam_msg) {
1328                         LOGD("remove camera message %p", cam_msg);
1329                         free(cam_msg);
1330                         cam_msg = NULL;
1331                 } else {
1332                         LOGW("NULL camera message");
1333                 }
1334         }
1335
1336         g_mutex_unlock(&cb_info->msg_handler_mutex);
1337
1338         LOGD("return");
1339
1340         return NULL;
1341 }
1342
1343 static void _camera_remove_idle_event_all(camera_cb_info_s *cb_info)
1344 {
1345         camera_idle_event_s *cam_idle_event = NULL;
1346         gboolean ret = TRUE;
1347         GList *list = NULL;
1348         gint64 end_time = 0;
1349
1350         if (cb_info == NULL) {
1351                 LOGE("cb_info is NULL");
1352                 return;
1353         }
1354
1355         g_mutex_lock(&cb_info->idle_event_mutex);
1356
1357         if (cb_info->idle_event_list == NULL) {
1358                 LOGD("No idle event is remained.");
1359         } else {
1360                 list = cb_info->idle_event_list;
1361
1362                 while (list) {
1363                         cam_idle_event = list->data;
1364                         list = g_list_next(list);
1365
1366                         if (!cam_idle_event) {
1367                                 LOGW("Fail to remove idle event. The event is NULL");
1368                         } else {
1369                                 if (g_mutex_trylock(&cam_idle_event->event_mutex)) {
1370                                         ret = g_idle_remove_by_data(cam_idle_event);
1371
1372                                         LOGD("remove idle event [%p], ret[%d]", cam_idle_event, ret);
1373
1374                                         if (ret == FALSE) {
1375                                                 cam_idle_event->cb_info = NULL;
1376                                                 LOGW("idle callback for event %p will be called later", cam_idle_event);
1377                                         }
1378
1379                                         cb_info->idle_event_list = g_list_remove(cb_info->idle_event_list, (gpointer)cam_idle_event);
1380
1381                                         g_mutex_unlock(&cam_idle_event->event_mutex);
1382
1383                                         if (ret == TRUE) {
1384                                                 g_mutex_clear(&cam_idle_event->event_mutex);
1385
1386                                                 free(cam_idle_event);
1387                                                 cam_idle_event = NULL;
1388
1389                                                 LOGD("remove idle event done");
1390                                         }
1391                                 } else {
1392                                         LOGW("event lock failed. it's being called...");
1393
1394                                         end_time = g_get_monotonic_time() + G_TIME_SPAN_MILLISECOND * 100;
1395
1396                                         if (g_cond_wait_until(&cb_info->idle_event_cond, &cb_info->idle_event_mutex, end_time))
1397                                                 LOGW("signal received");
1398                                         else
1399                                                 LOGW("timeout");
1400                                 }
1401                         }
1402                 }
1403
1404                 g_list_free(cb_info->idle_event_list);
1405                 cb_info->idle_event_list = NULL;
1406         }
1407
1408         g_mutex_unlock(&cb_info->idle_event_mutex);
1409
1410         return;
1411 }
1412
1413 static void *_camera_msg_recv_func(gpointer data)
1414 {
1415         int i = 0;
1416         int ret = 0;
1417         int api = 0;
1418         int api_class = 0;
1419         int num_token = 0;
1420         int str_pos = 0;
1421         int prev_pos = 0;
1422         char *recv_msg = NULL;
1423         char **parse_str = NULL;
1424         camera_cb_info_s *cb_info = (camera_cb_info_s *)data;
1425
1426         if (cb_info == NULL) {
1427                 LOGE("cb_info NULL");
1428                 return NULL;
1429         }
1430
1431         LOGD("start");
1432
1433         parse_str = (char **)malloc(sizeof(char *) * CAMERA_PARSE_STRING_SIZE);
1434         if (parse_str == NULL) {
1435                 LOGE("parse_str malloc failed");
1436                 return NULL;
1437         }
1438
1439         for (i = 0 ; i < CAMERA_PARSE_STRING_SIZE ; i++) {
1440                 parse_str[i] = (char *)malloc(sizeof(char) * MUSE_CAMERA_MSG_MAX_LENGTH);
1441                 if (parse_str[i] == NULL) {
1442                         LOGE("parse_str[%d] malloc failed", i);
1443                         goto CB_HANDLER_EXIT;
1444                 }
1445         }
1446
1447         recv_msg = cb_info->recv_msg;
1448
1449         while (g_atomic_int_get(&cb_info->msg_recv_running)) {
1450                 ret = muse_core_ipc_recv_msg(cb_info->fd, recv_msg);
1451                 if (ret <= 0)
1452                         break;
1453                 recv_msg[ret] = '\0';
1454
1455                 str_pos = 0;
1456                 prev_pos = 0;
1457                 num_token = 0;
1458
1459                 /*LOGD("recvMSg : %s, length : %d", recv_msg, ret);*/
1460
1461                 /* Need to split the combined entering msgs.
1462                     This module supports up to 200 combined msgs. */
1463                 for (str_pos = 0; str_pos < ret; str_pos++) {
1464                         if (recv_msg[str_pos] == '}') {
1465                                 memset(parse_str[num_token], 0x0, sizeof(char) * MUSE_CAMERA_MSG_MAX_LENGTH);
1466                                 strncpy(parse_str[num_token], recv_msg + prev_pos, str_pos - prev_pos + 1);
1467                                 LOGD("splitted msg : [%s], Index : %d", parse_str[num_token], num_token);
1468                                 prev_pos = str_pos+1;
1469                                 num_token++;
1470                         }
1471                 }
1472
1473                 /*LOGD("num_token : %d", num_token);*/
1474
1475                 /* Re-construct to the useful single msg. */
1476                 for (i = 0; i < num_token; i++) {
1477                         if (i >= CAMERA_PARSE_STRING_SIZE) {
1478                                 LOGE("invalid token index %d", i);
1479                                 break;
1480                         }
1481
1482                         api = -1;
1483                         api_class = -1;
1484
1485                         if (!muse_camera_msg_get(api, parse_str[i])) {
1486                                 LOGE("failed to get camera api");
1487                                 continue;
1488                         }
1489
1490                         if (muse_camera_msg_get(api_class, parse_str[i]))
1491                                 LOGD("camera api_class[%d]", api_class);
1492
1493                         if (api_class == MUSE_CAMERA_API_CLASS_IMMEDIATE) {
1494                                 g_mutex_lock(&cb_info->api_mutex[api]);
1495
1496                                 if (!muse_camera_msg_get(ret, parse_str[i])) {
1497                                         LOGE("failed to get camera ret");
1498                                         g_mutex_unlock(&cb_info->api_mutex[api]);
1499                                         continue;
1500                                 }
1501
1502                                 cb_info->api_ret[api] = ret;
1503                                 cb_info->api_activating[api] = 1;
1504
1505                                 if (api == MUSE_CAMERA_API_CREATE) {
1506                                         if (ret != CAMERA_ERROR_NONE) {
1507                                                 g_atomic_int_set(&cb_info->msg_recv_running, 0);
1508                                                 LOGE("camera create error 0x%x. close client cb handler", ret);
1509                                         }
1510                                 } else if (api == MUSE_CAMERA_API_DESTROY) {
1511                                         if (ret == CAMERA_ERROR_NONE) {
1512                                                 g_atomic_int_set(&cb_info->msg_recv_running, 0);
1513                                                 LOGD("camera destroy done. close client cb handler");
1514                                         }
1515                                 } else if (api == MUSE_CAMERA_API_START_PREVIEW) {
1516                                         int prev_state = CAMERA_STATE_NONE;
1517                                         gchar caps[MUSE_CAMERA_MSG_MAX_LENGTH] = {'\0',};
1518
1519                                         muse_camera_msg_get(prev_state, parse_str[i]);
1520
1521                                         cb_info->prev_state = prev_state;
1522                                         if (prev_state == CAMERA_STATE_CREATED) {
1523                                                 if (cb_info->caps) {
1524                                                         g_free(cb_info->caps);
1525                                                         cb_info->caps = NULL;
1526                                                 }
1527
1528                                                 muse_camera_msg_get(caps, parse_str[i]);
1529                                                 if (strlen(caps) > 0) {
1530                                                         cb_info->caps = g_strdup(caps);
1531                                                         if (cb_info->caps) {
1532                                                                 LOGD("caps from server [%s]", cb_info->caps);
1533                                                         } else {
1534                                                                 LOGE("failed to copy caps string");
1535                                                         }
1536                                                 } else {
1537                                                         LOGE("no string for caps");
1538                                                 }
1539                                         }
1540                                 }
1541
1542                                 g_cond_signal(&cb_info->api_cond[api]);
1543                                 g_mutex_unlock(&cb_info->api_mutex[api]);
1544                         } else if (api_class == MUSE_CAMERA_API_CLASS_THREAD_SUB || api == MUSE_CAMERA_CB_EVENT) {
1545                                 camera_message_s *cam_msg = g_new0(camera_message_s, 1);
1546                                 if (cam_msg == NULL) {
1547                                         LOGE("failed to alloc cam_msg");
1548                                         continue;
1549                                 }
1550
1551                                 cam_msg->api = api;
1552                                 memcpy(cam_msg->recv_msg, parse_str[i], sizeof(cam_msg->recv_msg));
1553
1554                                 LOGD("add camera message to queue : api %d", api);
1555
1556                                 g_mutex_lock(&cb_info->msg_handler_mutex);
1557                                 g_queue_push_tail(cb_info->msg_queue, (gpointer)cam_msg);
1558                                 g_cond_signal(&cb_info->msg_handler_cond);
1559                                 g_mutex_unlock(&cb_info->msg_handler_mutex);
1560                         } else {
1561                                 LOGW("unknown camera api %d and api_class %d", api, api_class);
1562                         }
1563                 }
1564
1565         }
1566
1567         LOGD("client cb exit");
1568
1569 CB_HANDLER_EXIT:
1570         if (parse_str) {
1571                 for (i = 0 ; i < CAMERA_PARSE_STRING_SIZE ; i++) {
1572                         if (parse_str[i]) {
1573                                 free(parse_str[i]);
1574                                 parse_str[i] = NULL;
1575                         }
1576                 }
1577
1578                 free(parse_str);
1579                 parse_str = NULL;
1580         }
1581
1582         return NULL;
1583 }
1584
1585 static camera_cb_info_s *_client_callback_new(gint sockfd)
1586 {
1587         camera_cb_info_s *cb_info = NULL;
1588         gint *tmp_activating = NULL;
1589         gint *tmp_ret = NULL;
1590         gint i = 0;
1591
1592         g_return_val_if_fail(sockfd > 0, NULL);
1593
1594         cb_info = g_new0(camera_cb_info_s, 1);
1595         if (cb_info == NULL) {
1596                 LOGE("cb_info failed");
1597                 goto ErrorExit;
1598         }
1599
1600         g_mutex_init(&cb_info->msg_handler_mutex);
1601         g_cond_init(&cb_info->msg_handler_cond);
1602         g_mutex_init(&cb_info->idle_event_mutex);
1603         g_cond_init(&cb_info->idle_event_cond);
1604
1605         for (i = 0 ; i < MUSE_CAMERA_API_MAX ; i++) {
1606                 g_mutex_init(&cb_info->api_mutex[i]);
1607                 g_cond_init(&cb_info->api_cond[i]);
1608         }
1609
1610         tmp_activating = g_new0(gint, MUSE_CAMERA_API_MAX);
1611         if (tmp_activating == NULL) {
1612                 LOGE("tmp_activating failed");
1613                 goto ErrorExit;
1614         }
1615
1616         tmp_ret = g_new0(gint, MUSE_CAMERA_API_MAX);
1617         if (tmp_ret == NULL) {
1618                 LOGE("tmp_ret failed");
1619                 goto ErrorExit;
1620         }
1621
1622         cb_info->msg_queue = g_queue_new();
1623         if (cb_info->msg_queue == NULL) {
1624                 LOGE("msg_queue new failed");
1625                 goto ErrorExit;
1626         }
1627
1628         g_atomic_int_set(&cb_info->msg_handler_running, 1);
1629         cb_info->msg_handler_thread = g_thread_try_new("camera_msg_handler",
1630                 _camera_msg_handler_func, (gpointer)cb_info, NULL);
1631         if (cb_info->msg_handler_thread == NULL) {
1632                 LOGE("message handler thread creation failed");
1633                 goto ErrorExit;
1634         }
1635
1636         cb_info->fd = sockfd;
1637         cb_info->api_activating = tmp_activating;
1638         cb_info->api_ret = tmp_ret;
1639
1640         g_atomic_int_set(&cb_info->msg_recv_running, 1);
1641         cb_info->msg_recv_thread = g_thread_try_new("camera_msg_recv",
1642                 _camera_msg_recv_func, (gpointer)cb_info, NULL);
1643         if (cb_info->msg_recv_thread == NULL) {
1644                 LOGE("message receive thread creation failed");
1645                 goto ErrorExit;
1646         }
1647
1648         return cb_info;
1649
1650 ErrorExit:
1651         if (cb_info) {
1652                 if (cb_info->msg_handler_thread) {
1653                         g_mutex_lock(&cb_info->msg_handler_mutex);
1654                         g_atomic_int_set(&cb_info->msg_handler_running, 0);
1655                         g_cond_signal(&cb_info->msg_handler_cond);
1656                         g_mutex_unlock(&cb_info->msg_handler_mutex);
1657
1658                         g_thread_join(cb_info->msg_handler_thread);
1659                         g_thread_unref(cb_info->msg_handler_thread);
1660                         cb_info->msg_handler_thread = NULL;
1661                 }
1662
1663                 for (i = 0 ; i < MUSE_CAMERA_API_MAX ; i++) {
1664                         g_mutex_clear(&cb_info->api_mutex[i]);
1665                         g_cond_clear(&cb_info->api_cond[i]);
1666                 }
1667
1668                 g_mutex_clear(&cb_info->msg_handler_mutex);
1669                 g_cond_clear(&cb_info->msg_handler_cond);
1670                 g_mutex_clear(&cb_info->idle_event_mutex);
1671                 g_cond_clear(&cb_info->idle_event_cond);
1672
1673                 if (cb_info->msg_queue) {
1674                         g_queue_free(cb_info->msg_queue);
1675                         cb_info->msg_queue = NULL;
1676                 }
1677
1678                 g_free(cb_info);
1679                 cb_info = NULL;
1680         }
1681
1682         if (tmp_activating) {
1683                 g_free(tmp_activating);
1684                 tmp_activating = NULL;
1685         }
1686         if (tmp_ret) {
1687                 g_free(tmp_ret);
1688                 tmp_ret = NULL;
1689         }
1690
1691         return NULL;
1692 }
1693
1694 static void _client_callback_destroy(camera_cb_info_s *cb_info)
1695 {
1696         gint i = 0;
1697
1698         g_return_if_fail(cb_info != NULL);
1699
1700         LOGD("MSG receive thread[%p] destroy", cb_info->msg_recv_thread);
1701
1702         g_thread_join(cb_info->msg_recv_thread);
1703         g_thread_unref(cb_info->msg_recv_thread);
1704         cb_info->msg_recv_thread = NULL;
1705
1706         LOGD("msg thread removed");
1707
1708         g_mutex_lock(&cb_info->msg_handler_mutex);
1709         g_atomic_int_set(&cb_info->msg_handler_running, 0);
1710         g_cond_signal(&cb_info->msg_handler_cond);
1711         g_mutex_unlock(&cb_info->msg_handler_mutex);
1712
1713         g_thread_join(cb_info->msg_handler_thread);
1714         g_thread_unref(cb_info->msg_handler_thread);
1715         cb_info->msg_handler_thread = NULL;
1716
1717         g_queue_free(cb_info->msg_queue);
1718         cb_info->msg_queue = NULL;
1719
1720         for (i = 0 ; i < MUSE_CAMERA_API_MAX ; i++) {
1721                 g_mutex_clear(&cb_info->api_mutex[i]);
1722                 g_cond_clear(&cb_info->api_cond[i]);
1723         }
1724
1725         g_mutex_clear(&cb_info->msg_handler_mutex);
1726         g_cond_clear(&cb_info->msg_handler_cond);
1727         g_mutex_clear(&cb_info->idle_event_mutex);
1728         g_cond_clear(&cb_info->idle_event_cond);
1729
1730         LOGD("event thread removed");
1731
1732         if (cb_info->fd > -1) {
1733                 muse_core_connection_close(cb_info->fd);
1734                 cb_info->fd = -1;
1735         }
1736
1737         if (cb_info->bufmgr) {
1738                 tbm_bufmgr_deinit(cb_info->bufmgr);
1739                 cb_info->bufmgr = NULL;
1740         }
1741         if (cb_info->api_activating) {
1742                 g_free(cb_info->api_activating);
1743                 cb_info->api_activating = NULL;
1744         }
1745         if (cb_info->api_ret) {
1746                 g_free(cb_info->api_ret);
1747                 cb_info->api_ret = NULL;
1748         }
1749         if (cb_info->pkt_fmt) {
1750                 media_format_unref(cb_info->pkt_fmt);
1751                 cb_info->pkt_fmt = NULL;
1752         }
1753         if (cb_info->caps) {
1754                 g_free(cb_info->caps);
1755                 cb_info->caps = NULL;
1756         }
1757
1758         g_free(cb_info);
1759         cb_info = NULL;
1760
1761         return;
1762 }
1763
1764 int camera_create(camera_device_e device, camera_h* camera)
1765 {
1766         int sock_fd = -1;
1767         char *sndMsg;
1768         int ret = CAMERA_ERROR_NONE;
1769         int pid = 0;
1770         camera_cli_s *pc = NULL;
1771         tbm_bufmgr bufmgr = NULL;
1772
1773         muse_camera_api_e api = MUSE_CAMERA_API_CREATE;
1774         muse_core_api_module_e muse_module = MUSE_CAMERA;
1775         int device_type = (int)device;
1776
1777         if (camera == NULL) {
1778                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
1779                 return CAMERA_ERROR_INVALID_PARAMETER;
1780         }
1781
1782         bufmgr = tbm_bufmgr_init(-1);
1783         if (bufmgr == NULL) {
1784                 LOGE("get tbm bufmgr failed");
1785                 return CAMERA_ERROR_INVALID_OPERATION;
1786         }
1787
1788         sock_fd = muse_core_client_new();
1789         if (sock_fd < 0) {
1790                 LOGE("muse_core_client_new failed - returned fd %d", sock_fd);
1791                 ret = CAMERA_ERROR_INVALID_OPERATION;
1792                 goto ErrorExit;
1793         }
1794
1795         pid = getpid();
1796
1797         sndMsg = muse_core_msg_json_factory_new(api,
1798                 MUSE_TYPE_INT, "module", muse_module,
1799                 MUSE_TYPE_INT, PARAM_DEVICE_TYPE, device_type,
1800                 MUSE_TYPE_INT, "pid", pid,
1801                 0);
1802
1803         muse_core_ipc_send_msg(sock_fd, sndMsg);
1804         muse_core_msg_json_factory_free(sndMsg);
1805
1806         pc = g_new0(camera_cli_s, 1);
1807         if (pc == NULL) {
1808                 LOGE("camera_cli_s alloc failed");
1809                 ret = CAMERA_ERROR_OUT_OF_MEMORY;
1810                 goto ErrorExit;
1811         }
1812
1813         pc->cb_info = _client_callback_new(sock_fd);
1814         if (pc->cb_info == NULL) {
1815                 LOGE("cb_info alloc failed");
1816                 ret = CAMERA_ERROR_OUT_OF_MEMORY;
1817                 goto ErrorExit;
1818         }
1819
1820         LOGD("cb info : %d", pc->cb_info->fd);
1821
1822         ret = _client_wait_for_cb_return(api, pc->cb_info, CALLBACK_TIME_OUT);
1823         if (ret == CAMERA_ERROR_NONE) {
1824                 intptr_t handle = 0;
1825                 muse_camera_msg_get_pointer(handle, pc->cb_info->recv_msg);
1826                 if (handle == 0) {
1827                         LOGE("Receiving Handle Failed!!");
1828                         ret = CAMERA_ERROR_INVALID_OPERATION;
1829                         goto ErrorExit;
1830                 }
1831
1832                 pc->remote_handle = handle;
1833                 pc->cb_info->bufmgr = bufmgr;
1834
1835                 LOGD("camera create 0x%x", pc->remote_handle);
1836                 *camera = (camera_h) pc;
1837         } else {
1838                 goto ErrorExit;
1839         }
1840
1841         return ret;
1842
1843 ErrorExit:
1844         tbm_bufmgr_deinit(bufmgr);
1845         bufmgr = NULL;
1846
1847         if (pc) {
1848                 _client_callback_destroy(pc->cb_info);
1849                 pc->cb_info = NULL;
1850                 g_free(pc);
1851                 pc = NULL;
1852         }
1853
1854         LOGE("camera create error : 0x%x", ret);
1855
1856         return ret;
1857 }
1858
1859 int camera_destroy(camera_h camera)
1860 {
1861         if (camera == NULL) {
1862                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
1863                 return CAMERA_ERROR_INVALID_PARAMETER;
1864         }
1865
1866         int ret = CAMERA_ERROR_NONE;
1867         muse_camera_api_e api = MUSE_CAMERA_API_DESTROY;
1868         camera_cli_s *pc = (camera_cli_s *)camera;
1869         int sock_fd = 0;
1870
1871         LOGD("ENTER");
1872
1873         if (pc->cb_info == NULL) {
1874                 LOGE("cb_info NULL, INVALID_PARAMETER");
1875                 return CAMERA_ERROR_INVALID_PARAMETER;
1876         }
1877
1878         sock_fd = pc->cb_info->fd;
1879
1880         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1881         if (ret == CAMERA_ERROR_NONE) {
1882                 if (pc->client_handle) {
1883                         mm_camcorder_client_destroy(pc->client_handle);
1884                         pc->client_handle = NULL;
1885                 }
1886                 _camera_remove_idle_event_all(pc->cb_info);
1887                 _client_callback_destroy(pc->cb_info);
1888                 pc->cb_info = NULL;
1889
1890 #ifdef HAVE_WAYLAND
1891                 if (pc->wl_info) {
1892                         g_free(pc->wl_info);
1893                         pc->wl_info = NULL;
1894                 }
1895 #endif /* HAVE_WAYLAND */
1896
1897                 g_free(pc);
1898                 pc = NULL;
1899         } else {
1900                 LOGE("camera destroy error : 0x%x", ret);
1901         }
1902
1903         return ret;
1904 }
1905
1906 int camera_start_preview(camera_h camera)
1907 {
1908         int ret = CAMERA_ERROR_NONE;
1909         muse_camera_api_e api = MUSE_CAMERA_API_START_PREVIEW;
1910         camera_cli_s *pc = (camera_cli_s *)camera;
1911         int sock_fd = 0;
1912
1913         if (camera == NULL) {
1914                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
1915                 return CAMERA_ERROR_INVALID_PARAMETER;
1916         }
1917
1918         if (pc->cb_info == NULL) {
1919                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
1920                 return CAMERA_ERROR_INVALID_PARAMETER;
1921         }
1922
1923         LOGD("start");
1924
1925         sock_fd = pc->cb_info->fd;
1926
1927         if (pc->client_handle == NULL) {
1928                 LOGW("set display is not called by application. set NONE type internally");
1929                 ret = camera_set_display(camera, CAMERA_DISPLAY_TYPE_NONE, NULL);
1930                 if (ret != CAMERA_ERROR_NONE) {
1931                         LOGE("Internal camera_set_display failed 0x%x", ret);
1932                         return ret;
1933                 }
1934         }
1935
1936         muse_camera_msg_send_longtime(api, sock_fd, pc->cb_info, ret);
1937
1938         if (ret != CAMERA_ERROR_NONE) {
1939                 LOGE("start preview failed 0x%x", ret);
1940                 return ret;
1941         }
1942
1943         if (pc->cb_info->prev_state == CAMERA_STATE_CREATED) {
1944                 if (pc->cb_info->caps == NULL) {
1945                         LOGE("caps string is NULL");
1946                         goto _START_PREVIEW_ERROR;
1947                 }
1948
1949                 ret = mm_camcorder_client_realize(pc->client_handle, pc->cb_info->caps);
1950                 if (ret != MM_ERROR_NONE) {
1951                         LOGE("client realize failed 0x%x", ret);
1952                         goto _START_PREVIEW_ERROR;
1953                 }
1954         }
1955
1956         LOGD("ret : 0x%x", ret);
1957
1958         return CAMERA_ERROR_NONE;
1959
1960 _START_PREVIEW_ERROR:
1961         muse_camera_msg_send_longtime(MUSE_CAMERA_API_STOP_PREVIEW, sock_fd, pc->cb_info, ret);
1962
1963         return CAMERA_ERROR_INVALID_OPERATION;
1964 }
1965
1966 int camera_stop_preview(camera_h camera)
1967 {
1968         int ret = CAMERA_ERROR_NONE;
1969         int client_ret = MM_ERROR_NONE;
1970         int sock_fd = 0;
1971         camera_cli_s *pc = NULL;
1972         muse_camera_api_e api = MUSE_CAMERA_API_STOP_PREVIEW;
1973
1974         if (camera == NULL) {
1975                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
1976                 return CAMERA_ERROR_INVALID_PARAMETER;
1977         }
1978
1979         pc = (camera_cli_s *)camera;
1980
1981         if (pc->cb_info == NULL) {
1982                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
1983                 return CAMERA_ERROR_INVALID_PARAMETER;
1984         }
1985
1986         sock_fd = pc->cb_info->fd;
1987
1988         LOGD("Enter");
1989
1990         /* destroy client pipeline first */
1991         if (pc->client_handle != NULL) {
1992                 client_ret = mm_camcorder_client_unrealize(pc->client_handle);
1993         } else {
1994                 LOGW("client handle is NULL");
1995         }
1996
1997         /* send stop preview message */
1998         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1999
2000         if (ret == MM_ERROR_NONE && client_ret != MM_ERROR_NONE) {
2001                 LOGE("client unrealize failed, restart preview");
2002                 muse_camera_msg_send_longtime(MUSE_CAMERA_API_START_PREVIEW, sock_fd, pc->cb_info, ret);
2003                 ret = CAMERA_ERROR_INVALID_OPERATION;
2004         } else if (ret != MM_ERROR_NONE && client_ret == MM_ERROR_NONE) {
2005                 LOGE("stop preview failed, realize client again");
2006                 mm_camcorder_client_realize(pc->client_handle, pc->cb_info->caps);
2007                 ret = CAMERA_ERROR_INVALID_OPERATION;
2008         }
2009
2010         LOGD("ret : 0x%x", ret);
2011
2012         return ret;
2013 }
2014
2015 int camera_start_capture(camera_h camera, camera_capturing_cb capturing_cb, camera_capture_completed_cb completed_cb, void *user_data)
2016 {
2017         if (camera == NULL) {
2018                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2019                 return CAMERA_ERROR_INVALID_PARAMETER;
2020         }
2021         int ret = CAMERA_ERROR_NONE;
2022
2023         camera_cli_s *pc = (camera_cli_s *)camera;
2024         muse_camera_api_e api = MUSE_CAMERA_API_START_CAPTURE;
2025         int sock_fd;
2026         int is_capturing_cb = 0;
2027         int is_completed_cb = 0;
2028         LOGD("Enter, handle :%x", pc->remote_handle);
2029
2030         if (pc->cb_info == NULL) {
2031                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2032                 return CAMERA_ERROR_INVALID_PARAMETER;
2033         }
2034
2035         sock_fd = pc->cb_info->fd;
2036
2037         if (capturing_cb != NULL) {
2038                 is_capturing_cb = 1;
2039                 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_CAPTURE] = capturing_cb;
2040                 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_CAPTURE] = user_data;
2041         }
2042
2043         if (completed_cb != NULL) {
2044                 is_completed_cb = 1;
2045                 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = completed_cb;
2046                 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = user_data;
2047         }
2048
2049         muse_camera_msg_send2(api, sock_fd, pc->cb_info, ret, INT, is_capturing_cb, INT, is_completed_cb);
2050         LOGD("is_capturing_cb :%d, is_completed_cb : %d", is_capturing_cb, is_completed_cb);
2051         LOGD("ret : 0x%x", ret);
2052         return ret;
2053 }
2054
2055 bool camera_is_supported_continuous_capture(camera_h camera)
2056 {
2057         if (camera == NULL) {
2058                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2059                 return false;
2060         }
2061
2062         int ret = CAMERA_ERROR_NONE;
2063         camera_cli_s *pc = (camera_cli_s *)camera;
2064         muse_camera_api_e api = MUSE_CAMERA_API_SUPPORT_CONTINUOUS_CAPTURE;
2065         int sock_fd;
2066
2067         if (pc->cb_info == NULL) {
2068                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2069                 return CAMERA_ERROR_INVALID_PARAMETER;
2070         }
2071
2072         sock_fd = pc->cb_info->fd;
2073
2074         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2075         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2076         LOGD("ret : 0x%x", ret);
2077         return (bool)ret;
2078 }
2079
2080 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)
2081 {
2082         if (camera == NULL) {
2083                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2084                 return CAMERA_ERROR_INVALID_PARAMETER;
2085         }
2086
2087         int ret = CAMERA_ERROR_NONE;
2088
2089         camera_cli_s *pc = (camera_cli_s *)camera;
2090         muse_camera_api_e api = MUSE_CAMERA_API_START_CONTINUOUS_CAPTURE;
2091
2092         LOGD("Enter, handle :%x", pc->remote_handle);
2093
2094         int sock_fd;
2095         if (pc->cb_info == NULL) {
2096                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2097                 return CAMERA_ERROR_INVALID_PARAMETER;
2098         }
2099         sock_fd = pc->cb_info->fd;
2100
2101         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_CAPTURE] = capturing_cb;
2102         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_CAPTURE] = user_data;
2103         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = completed_cb;
2104
2105         muse_camera_msg_send2(api, sock_fd, pc->cb_info, ret, INT, count, INT, interval);
2106
2107         LOGD("ret : 0x%x", ret);
2108
2109         return ret;
2110 }
2111
2112 int camera_stop_continuous_capture(camera_h camera)
2113 {
2114         if (camera == NULL) {
2115                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2116                 return CAMERA_ERROR_INVALID_PARAMETER;
2117         }
2118
2119
2120         int ret = CAMERA_ERROR_NONE;
2121
2122         camera_cli_s *pc = (camera_cli_s *)camera;
2123         muse_camera_api_e api = MUSE_CAMERA_API_STOP_CONTINUOUS_CAPTURE;
2124         LOGD("Enter,  handle :%x", pc->remote_handle);
2125         int sock_fd;
2126         if (pc->cb_info == NULL) {
2127                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2128                 return CAMERA_ERROR_INVALID_PARAMETER;
2129         }
2130         sock_fd = pc->cb_info->fd;
2131         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2132         LOGD("ret : 0x%x", ret);
2133         return ret;
2134 }
2135
2136 bool camera_is_supported_face_detection(camera_h camera)
2137 {
2138         if (camera == NULL) {
2139                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2140                 return false;
2141         }
2142         int ret = CAMERA_ERROR_NONE;
2143
2144         camera_cli_s *pc = (camera_cli_s *)camera;
2145         muse_camera_api_e api = MUSE_CAMERA_API_SUPPORT_FACE_DETECTION;
2146         int sock_fd;
2147         if (pc->cb_info == NULL) {
2148                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2149                 return CAMERA_ERROR_INVALID_PARAMETER;
2150         }
2151         sock_fd = pc->cb_info->fd;
2152
2153         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2154         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2155         LOGD("ret : 0x%x", ret);
2156         return (bool)ret;
2157 }
2158
2159 bool camera_is_supported_zero_shutter_lag(camera_h camera)
2160 {
2161         if (camera == NULL) {
2162                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2163                 return false;
2164         }
2165         int ret = CAMERA_ERROR_NONE;
2166
2167         camera_cli_s *pc = (camera_cli_s *)camera;
2168         muse_camera_api_e api = MUSE_CAMERA_API_SUPPORT_ZERO_SHUTTER_LAG;
2169         int sock_fd;
2170         if (pc->cb_info == NULL) {
2171                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2172                 return CAMERA_ERROR_INVALID_PARAMETER;
2173         }
2174         sock_fd = pc->cb_info->fd;
2175
2176         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2177         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2178         LOGD("ret : 0x%x", ret);
2179         return (bool)ret;
2180 }
2181
2182 bool camera_is_supported_media_packet_preview_cb(camera_h camera)
2183 {
2184         if (camera == NULL) {
2185                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2186                 return false;
2187         }
2188
2189         int ret = CAMERA_ERROR_NONE;
2190
2191         camera_cli_s *pc = (camera_cli_s *)camera;
2192         muse_camera_api_e api = MUSE_CAMERA_API_SUPPORT_MEDIA_PACKET_PREVIEW_CB;
2193         int sock_fd;
2194         if (pc->cb_info == NULL) {
2195                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2196                 return CAMERA_ERROR_INVALID_PARAMETER;
2197         }
2198         sock_fd = pc->cb_info->fd;
2199
2200         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2201         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2202         LOGD("ret : 0x%x", ret);
2203         return (bool)ret;
2204 }
2205
2206 int camera_get_device_count(camera_h camera, int *device_count)
2207 {
2208         if (camera == NULL || device_count == NULL) {
2209                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2210                 return CAMERA_ERROR_INVALID_PARAMETER;
2211         }
2212         int ret = CAMERA_ERROR_NONE;
2213
2214         camera_cli_s *pc = (camera_cli_s *)camera;
2215         muse_camera_api_e api = MUSE_CAMERA_API_GET_DEVICE_COUNT;
2216         int sock_fd;
2217         if (pc->cb_info == NULL) {
2218                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2219                 return CAMERA_ERROR_INVALID_PARAMETER;
2220         }
2221         sock_fd = pc->cb_info->fd;
2222         int get_device_count;
2223
2224         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2225         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2226
2227         if (ret == CAMERA_ERROR_NONE) {
2228                 muse_camera_msg_get(get_device_count, pc->cb_info->recv_msg);
2229                 *device_count = get_device_count;
2230         }
2231         LOGD("ret : 0x%x", ret);
2232         return ret;
2233 }
2234
2235 int camera_start_face_detection(camera_h camera, camera_face_detected_cb callback, void * user_data)
2236 {
2237         if (camera == NULL) {
2238                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2239                 return CAMERA_ERROR_INVALID_PARAMETER;
2240         }
2241
2242         int ret = CAMERA_ERROR_NONE;
2243
2244         camera_cli_s *pc = (camera_cli_s *)camera;
2245         muse_camera_api_e api = MUSE_CAMERA_API_START_FACE_DETECTION;
2246
2247         LOGD("Enter, handle :%x", pc->remote_handle);
2248         int sock_fd;
2249         if (pc->cb_info == NULL) {
2250                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2251                 return CAMERA_ERROR_INVALID_PARAMETER;
2252         }
2253         sock_fd = pc->cb_info->fd;
2254         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FACE_DETECTION] = callback;
2255         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FACE_DETECTION] = user_data;
2256
2257         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2258         LOGD("ret : 0x%x", ret);
2259         return ret;
2260 }
2261
2262 int camera_stop_face_detection(camera_h camera)
2263 {
2264         if (camera == NULL) {
2265                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2266                 return CAMERA_ERROR_INVALID_PARAMETER;
2267         }
2268
2269         int ret = CAMERA_ERROR_NONE;
2270
2271         camera_cli_s *pc = (camera_cli_s *)camera;
2272         muse_camera_api_e api = MUSE_CAMERA_API_STOP_FACE_DETECTION;
2273         LOGD("Enter,  handle :%x", pc->remote_handle);
2274         int sock_fd;
2275         if (pc->cb_info == NULL) {
2276                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2277                 return CAMERA_ERROR_INVALID_PARAMETER;
2278         }
2279         sock_fd = pc->cb_info->fd;
2280         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2281         LOGD("ret : 0x%x", ret);
2282         return ret;
2283 }
2284
2285 int camera_get_state(camera_h camera, camera_state_e * state)
2286 {
2287         if (camera == NULL || state == NULL) {
2288                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2289                 return CAMERA_ERROR_INVALID_PARAMETER;
2290         }
2291         int ret = CAMERA_ERROR_NONE;
2292
2293         camera_cli_s *pc = (camera_cli_s *)camera;
2294         muse_camera_api_e api = MUSE_CAMERA_API_GET_STATE;
2295         int sock_fd;
2296         if (pc->cb_info == NULL) {
2297                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2298                 return CAMERA_ERROR_INVALID_PARAMETER;
2299         }
2300         sock_fd = pc->cb_info->fd;
2301         int get_state;
2302
2303         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2304         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2305
2306         if (ret == CAMERA_ERROR_NONE) {
2307                 muse_camera_msg_get(get_state, pc->cb_info->recv_msg);
2308                 *state = (camera_state_e)get_state;
2309         }
2310         LOGD("ret : 0x%x", ret);
2311         return ret;
2312 }
2313
2314 int camera_start_focusing(camera_h camera, bool continuous)
2315 {
2316         if (camera == NULL) {
2317                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2318                 return CAMERA_ERROR_INVALID_PARAMETER;
2319         }
2320
2321         int ret = CAMERA_ERROR_NONE;
2322
2323         camera_cli_s *pc = (camera_cli_s *)camera;
2324         muse_camera_api_e api = MUSE_CAMERA_API_START_FOCUSING;
2325         int sock_fd;
2326         if (pc->cb_info == NULL) {
2327                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2328                 return CAMERA_ERROR_INVALID_PARAMETER;
2329         }
2330         sock_fd = pc->cb_info->fd;
2331         int is_continuous = (int)continuous;
2332
2333         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2334         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, is_continuous);
2335         LOGD("ret : 0x%x", ret);
2336         return ret;
2337 }
2338
2339 int camera_cancel_focusing(camera_h camera)
2340 {
2341         if (camera == NULL) {
2342                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2343                 return CAMERA_ERROR_INVALID_PARAMETER;
2344         }
2345
2346         int ret = CAMERA_ERROR_NONE;
2347
2348         camera_cli_s *pc = (camera_cli_s *)camera;
2349         muse_camera_api_e api = MUSE_CAMERA_API_CANCEL_FOCUSING;
2350         int sock_fd;
2351         if (pc->cb_info == NULL) {
2352                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2353                 return CAMERA_ERROR_INVALID_PARAMETER;
2354         }
2355         sock_fd = pc->cb_info->fd;
2356
2357         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2358         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2359         LOGD("ret : 0x%x", ret);
2360         return ret;
2361 }
2362
2363 int camera_set_display(camera_h camera, camera_display_type_e type, camera_display_h display)
2364 {
2365         int ret = CAMERA_ERROR_NONE;
2366         void *set_display_handle = NULL;
2367         int set_surface = MM_DISPLAY_SURFACE_X;
2368         Evas_Object *obj = NULL;
2369         const char *object_type = NULL;
2370         char socket_path[MUSE_CAMERA_MSG_MAX_LENGTH] = {0,};
2371 #ifdef HAVE_WAYLAND
2372         MMCamWaylandInfo *wl_info = NULL;
2373 #endif /* HAVE_WAYLAND */
2374
2375         if (camera == NULL) {
2376                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2377                 return CAMERA_ERROR_INVALID_PARAMETER;
2378         }
2379
2380         if (type != CAMERA_DISPLAY_TYPE_NONE && display == NULL) {
2381                 LOGE("display type[%d] is not NONE, but display handle is NULL", type);
2382                 return CAMERA_ERROR_INVALID_PARAMETER;
2383         }
2384
2385         camera_cli_s *pc = (camera_cli_s *)camera;
2386         muse_camera_api_e api = MUSE_CAMERA_API_SET_DISPLAY;
2387         int sock_fd;
2388         if (pc->cb_info == NULL) {
2389                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2390                 return CAMERA_ERROR_INVALID_PARAMETER;
2391         }
2392         sock_fd = pc->cb_info->fd;
2393
2394         LOGD("Enter, remote_handle : %x display : 0x%x", pc->remote_handle, display);
2395
2396         if (type == CAMERA_DISPLAY_TYPE_NONE) {
2397                 set_display_handle = 0;
2398                 set_surface = MM_DISPLAY_SURFACE_NULL;
2399                 LOGD("display type NONE");
2400         } else {
2401                 obj = (Evas_Object *)display;
2402                 object_type = evas_object_type_get(obj);
2403                 if (object_type) {
2404                         if (type == CAMERA_DISPLAY_TYPE_OVERLAY && !strcmp(object_type, "elm_win")) {
2405 #ifdef HAVE_WAYLAND
2406                                 /* set wayland info */
2407                                 wl_info = _get_wl_info(obj);
2408                                 if (wl_info == NULL) {
2409                                         LOGE("failed to get wl_info");
2410                                         return CAMERA_ERROR_INVALID_OPERATION;
2411                                 }
2412
2413                                 set_display_handle = (void *)wl_info;
2414 #else /* HAVE_WAYLAND */
2415                                 /* x window overlay surface */
2416                                 set_display_handle = (void *)elm_win_xwindow_get(obj);
2417 #endif
2418                                 set_surface = MM_DISPLAY_SURFACE_X;
2419                                 LOGD("display type OVERLAY : handle %p", set_display_handle);
2420                         } else if (type == CAMERA_DISPLAY_TYPE_EVAS && !strcmp(object_type, "image")) {
2421                                 /* evas object surface */
2422                                 set_display_handle = (void *)display;
2423                                 set_surface = MM_DISPLAY_SURFACE_EVAS;
2424                                 LOGD("display type EVAS : handle %p", set_display_handle);
2425                         } else {
2426                                 LOGE("unknown evas object [%p,%s] or type [%d] mismatch", obj, object_type, type);
2427                                 return CAMERA_ERROR_INVALID_PARAMETER;
2428                         }
2429                 } else {
2430                         LOGE("failed to get evas object type from %p", obj);
2431                         return CAMERA_ERROR_INVALID_PARAMETER;
2432                 }
2433         }
2434
2435         pc->display_handle = (intptr_t)set_display_handle;
2436
2437         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2438
2439         if (ret == CAMERA_ERROR_NONE) {
2440                 if (pc->client_handle == NULL) {
2441                         ret = mm_camcorder_client_create(&pc->client_handle);
2442                         if (ret != MM_ERROR_NONE) {
2443                                 LOGE("camera client create Failed 0x%x", ret);
2444                                 goto _SET_DISPLAY_ERROR;
2445                         }
2446                 }
2447
2448                 if (muse_camera_msg_get_string(socket_path, pc->cb_info->recv_msg) == FALSE) {
2449                         LOGE("failed to get socket path");
2450                         goto _SET_DISPLAY_ERROR;
2451                 }
2452
2453                 LOGD("socket path : %s", socket_path);
2454
2455                 ret = mm_camcorder_client_set_socket_path(pc->client_handle, socket_path);
2456                 if (ret != MM_ERROR_NONE) {
2457                         LOGE("failed to set socket path 0x%x", ret);
2458                         goto _SET_DISPLAY_ERROR;
2459                 }
2460
2461                 ret = mm_camcorder_set_attributes(pc->client_handle, NULL,
2462                         MMCAM_DISPLAY_SURFACE, set_surface,
2463                         NULL);
2464                 if (ret != MM_ERROR_NONE) {
2465                         LOGE("set display surface failed 0x%x", ret);
2466                         goto _SET_DISPLAY_ERROR;
2467                 }
2468
2469                 if (type != CAMERA_DISPLAY_TYPE_NONE) {
2470                         ret = mm_camcorder_set_attributes(pc->client_handle, NULL,
2471                                 MMCAM_DISPLAY_HANDLE, set_display_handle, sizeof(void *),
2472                                 NULL);
2473                         if (ret != MM_ERROR_NONE) {
2474                                 LOGE("set display handle failed 0x%x", ret);
2475                                 goto _SET_DISPLAY_ERROR;
2476                         }
2477                 }
2478
2479 #ifdef HAVE_WAYLAND
2480                 if (pc->wl_info) {
2481                         g_free(pc->wl_info);
2482                         pc->wl_info = NULL;
2483                 }
2484
2485                 pc->wl_info = wl_info;
2486 #endif /* HAVE_WAYLAND */
2487
2488                 return CAMERA_ERROR_NONE;;
2489         } else {
2490                 LOGE("set display error - 0x%x");
2491                 return ret;
2492         }
2493
2494 _SET_DISPLAY_ERROR:
2495 #ifdef HAVE_WAYLAND
2496         if (wl_info) {
2497                 g_free(wl_info);
2498                 wl_info = NULL;
2499         }
2500 #endif /* HAVE_WAYLAND */
2501
2502         return __convert_camera_error_code(__func__, ret);
2503 }
2504
2505 int camera_set_preview_resolution(camera_h camera,  int width, int height)
2506 {
2507         if (camera == NULL) {
2508                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2509                 return CAMERA_ERROR_INVALID_PARAMETER;
2510         }
2511         int ret = CAMERA_ERROR_NONE;
2512
2513         camera_cli_s *pc = (camera_cli_s *)camera;
2514         muse_camera_api_e api = MUSE_CAMERA_API_SET_PREVIEW_RESOLUTION;
2515         int sock_fd;
2516         if (pc->cb_info == NULL) {
2517                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2518                 return CAMERA_ERROR_INVALID_PARAMETER;
2519         }
2520         sock_fd = pc->cb_info->fd;
2521
2522         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2523         muse_camera_msg_send2(api, sock_fd, pc->cb_info, ret, INT, width, INT, height);
2524         LOGD("ret : 0x%x", ret);
2525         return ret;
2526 }
2527
2528
2529 int camera_set_capture_resolution(camera_h camera,  int width, int height)
2530 {
2531         if (camera == NULL) {
2532                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2533                 return CAMERA_ERROR_INVALID_PARAMETER;
2534         }
2535
2536         int ret = CAMERA_ERROR_NONE;
2537
2538         camera_cli_s *pc = (camera_cli_s *)camera;
2539         muse_camera_api_e api = MUSE_CAMERA_API_SET_CAPTURE_RESOLUTION;
2540         int sock_fd;
2541         if (pc->cb_info == NULL) {
2542                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2543                 return CAMERA_ERROR_INVALID_PARAMETER;
2544         }
2545         sock_fd = pc->cb_info->fd;
2546
2547         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2548         muse_camera_msg_send2(api, sock_fd, pc->cb_info, ret, INT, width, INT, height);
2549         LOGD("ret : 0x%x", ret);
2550         return ret;
2551 }
2552
2553 int camera_set_capture_format(camera_h camera, camera_pixel_format_e format)
2554 {
2555         if (camera == NULL) {
2556                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2557                 return CAMERA_ERROR_INVALID_PARAMETER;
2558         }
2559
2560         int ret = CAMERA_ERROR_NONE;
2561         int set_format = (int)format;
2562
2563         camera_cli_s *pc = (camera_cli_s *)camera;
2564         muse_camera_api_e api = MUSE_CAMERA_API_SET_CAPTURE_FORMAT;
2565         int sock_fd;
2566         if (pc->cb_info == NULL) {
2567                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2568                 return CAMERA_ERROR_INVALID_PARAMETER;
2569         }
2570         sock_fd = pc->cb_info->fd;
2571
2572         LOGD("Enter, remote_handle : %x, capture_format: %d", pc->remote_handle, set_format);
2573         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_format);
2574         LOGD("ret : 0x%x", ret);
2575         return ret;
2576 }
2577
2578 int camera_set_preview_format(camera_h camera, camera_pixel_format_e format)
2579 {
2580         if (camera == NULL) {
2581                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2582                 return CAMERA_ERROR_INVALID_PARAMETER;
2583         }
2584
2585         int ret = CAMERA_ERROR_NONE;
2586         int set_format = (int)format;
2587
2588         camera_cli_s *pc = (camera_cli_s *)camera;
2589         muse_camera_api_e api = MUSE_CAMERA_API_SET_PREVIEW_FORMAT;
2590         int sock_fd;
2591         if (pc->cb_info == NULL) {
2592                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2593                 return CAMERA_ERROR_INVALID_PARAMETER;
2594         }
2595         sock_fd = pc->cb_info->fd;
2596
2597         LOGD("Enter, remote_handle : %x, capture_format: %d", pc->remote_handle, set_format);
2598         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_format);
2599         LOGD("ret : 0x%x", ret);
2600         return ret;
2601 }
2602
2603 int camera_get_preview_resolution(camera_h camera,  int *width, int *height)
2604 {
2605         if (camera == NULL || width == NULL || height == NULL) {
2606                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2607                 return CAMERA_ERROR_INVALID_PARAMETER;
2608         }
2609
2610
2611         int ret = CAMERA_ERROR_NONE;
2612
2613         camera_cli_s *pc = (camera_cli_s *)camera;
2614         muse_camera_api_e api = MUSE_CAMERA_API_GET_PREVIEW_RESOLUTION;
2615         int sock_fd;
2616         if (pc->cb_info == NULL) {
2617                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2618                 return CAMERA_ERROR_INVALID_PARAMETER;
2619         }
2620         sock_fd = pc->cb_info->fd;
2621         int get_width;
2622         int get_height;
2623
2624         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2625         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2626
2627         if (ret == CAMERA_ERROR_NONE) {
2628                 muse_camera_msg_get(get_width, pc->cb_info->recv_msg);
2629                 muse_camera_msg_get(get_height, pc->cb_info->recv_msg);
2630                 *width = get_width;
2631                 *height = get_height;
2632         }
2633         LOGD("ret : 0x%x", ret);
2634         return ret;
2635 }
2636
2637 int camera_set_display_rotation(camera_h camera, camera_rotation_e rotation)
2638 {
2639         if (camera == NULL) {
2640                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2641                 return CAMERA_ERROR_INVALID_PARAMETER;
2642         }
2643
2644         int ret = CAMERA_ERROR_NONE;
2645         camera_cli_s *pc = (camera_cli_s *)camera;
2646         muse_camera_api_e api = MUSE_CAMERA_API_SET_DISPLAY_ROTATION;
2647         int sock_fd;
2648         if (pc->cb_info == NULL) {
2649                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2650                 return CAMERA_ERROR_INVALID_PARAMETER;
2651         }
2652         sock_fd = pc->cb_info->fd;
2653         int set_rotation = (int)rotation;
2654
2655         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2656         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_rotation);
2657         LOGD("ret : 0x%x", ret);
2658         return ret;
2659 }
2660
2661 int camera_get_display_rotation(camera_h camera, camera_rotation_e *rotation)
2662 {
2663         if (camera == NULL || rotation == NULL) {
2664                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2665                 return CAMERA_ERROR_INVALID_PARAMETER;
2666         }
2667
2668         int ret = CAMERA_ERROR_NONE;
2669
2670         camera_cli_s *pc = (camera_cli_s *)camera;
2671         muse_camera_api_e api = MUSE_CAMERA_API_GET_DISPLAY_ROTATION;
2672         int sock_fd;
2673         if (pc->cb_info == NULL) {
2674                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2675                 return CAMERA_ERROR_INVALID_PARAMETER;
2676         }
2677         sock_fd = pc->cb_info->fd;
2678         int get_rotation;
2679
2680         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2681         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2682
2683         if (ret == CAMERA_ERROR_NONE) {
2684                 muse_camera_msg_get(get_rotation, pc->cb_info->recv_msg);
2685                 *rotation = (camera_rotation_e)get_rotation;
2686         }
2687         LOGD("ret : 0x%x", ret);
2688         return ret;
2689 }
2690
2691 int camera_set_display_flip(camera_h camera, camera_flip_e flip)
2692 {
2693         if (camera == NULL) {
2694                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2695                 return CAMERA_ERROR_INVALID_PARAMETER;
2696         }
2697
2698         int ret = CAMERA_ERROR_NONE;
2699
2700         camera_cli_s *pc = (camera_cli_s *)camera;
2701         muse_camera_api_e api = MUSE_CAMERA_API_SET_DISPLAY_FLIP;
2702         int sock_fd;
2703         if (pc->cb_info == NULL) {
2704                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2705                 return CAMERA_ERROR_INVALID_PARAMETER;
2706         }
2707         sock_fd = pc->cb_info->fd;
2708         int set_flip = (int)flip;
2709
2710         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2711         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_flip);
2712         LOGD("ret : 0x%x", ret);
2713         return ret;
2714 }
2715
2716 int camera_get_display_flip(camera_h camera, camera_flip_e *flip)
2717 {
2718         if (camera == NULL || flip == NULL) {
2719                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2720                 return CAMERA_ERROR_INVALID_PARAMETER;
2721         }
2722
2723         int ret = CAMERA_ERROR_NONE;
2724
2725         camera_cli_s *pc = (camera_cli_s *)camera;
2726         muse_camera_api_e api = MUSE_CAMERA_API_GET_DISPLAY_FLIP;
2727         int sock_fd;
2728         if (pc->cb_info == NULL) {
2729                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2730                 return CAMERA_ERROR_INVALID_PARAMETER;
2731         }
2732         sock_fd = pc->cb_info->fd;
2733         int get_flip;
2734
2735         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2736         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2737
2738         if (ret == CAMERA_ERROR_NONE) {
2739                 muse_camera_msg_get(get_flip, pc->cb_info->recv_msg);
2740                 *flip = (camera_flip_e)get_flip;
2741         }
2742         LOGD("ret : 0x%x", ret);
2743         return ret;
2744 }
2745
2746 int camera_set_display_visible(camera_h camera, bool visible)
2747 {
2748         if (camera == NULL) {
2749                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2750                 return CAMERA_ERROR_INVALID_PARAMETER;
2751         }
2752
2753         int ret = CAMERA_ERROR_NONE;
2754
2755         camera_cli_s *pc = (camera_cli_s *)camera;
2756         muse_camera_api_e api = MUSE_CAMERA_API_SET_DISPLAY_VISIBLE;
2757         int set_visible = (int)visible;
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, set_visible);
2767         LOGD("ret : 0x%x", ret);
2768         return ret;
2769 }
2770
2771 int camera_is_display_visible(camera_h camera, bool* visible)
2772 {
2773         if (camera == NULL || visible == NULL) {
2774                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2775                 return CAMERA_ERROR_INVALID_PARAMETER;
2776         }
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_IS_DISPLAY_VISIBLE;
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 get_visible;
2789
2790         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2791         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2792
2793         if (ret == CAMERA_ERROR_NONE) {
2794                 muse_camera_msg_get(get_visible, pc->cb_info->recv_msg);
2795                 *visible = (bool)get_visible;
2796         }
2797         LOGD("ret : 0x%x", ret);
2798         return ret;
2799 }
2800
2801 int camera_set_display_mode(camera_h camera, camera_display_mode_e mode)
2802 {
2803         if (camera == NULL) {
2804                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2805                 return CAMERA_ERROR_INVALID_PARAMETER;
2806         }
2807
2808         int ret = CAMERA_ERROR_NONE;
2809         int set_mode = (int)mode;
2810
2811         camera_cli_s *pc = (camera_cli_s *)camera;
2812         muse_camera_api_e api = MUSE_CAMERA_API_SET_DISPLAY_MODE;
2813         int sock_fd;
2814         if (pc->cb_info == NULL) {
2815                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2816                 return CAMERA_ERROR_INVALID_PARAMETER;
2817         }
2818         sock_fd = pc->cb_info->fd;
2819
2820         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2821         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_mode);
2822         LOGD("ret : 0x%x", ret);
2823         return ret;
2824 }
2825
2826 int camera_get_display_mode(camera_h camera, camera_display_mode_e* mode)
2827 {
2828         if (camera == NULL || mode == NULL) {
2829                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2830                 return CAMERA_ERROR_INVALID_PARAMETER;
2831         }
2832
2833         int ret = CAMERA_ERROR_NONE;
2834
2835         camera_cli_s *pc = (camera_cli_s *)camera;
2836         muse_camera_api_e api = MUSE_CAMERA_API_GET_DISPLAY_MODE;
2837         int sock_fd;
2838         if (pc->cb_info == NULL) {
2839                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2840                 return CAMERA_ERROR_INVALID_PARAMETER;
2841         }
2842         sock_fd = pc->cb_info->fd;
2843         int get_mode;
2844
2845         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2846         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2847
2848         if (ret == CAMERA_ERROR_NONE) {
2849                 muse_camera_msg_get(get_mode, pc->cb_info->recv_msg);
2850                 *mode = (camera_display_mode_e)get_mode;
2851         }
2852         LOGD("ret : 0x%x", ret);
2853         return ret;
2854 }
2855
2856 int camera_get_capture_resolution(camera_h camera, int *width, int *height)
2857 {
2858         if (camera == NULL || width == NULL || height == NULL) {
2859                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2860                 return CAMERA_ERROR_INVALID_PARAMETER;
2861         }
2862         int ret = CAMERA_ERROR_NONE;
2863
2864         camera_cli_s *pc = (camera_cli_s *)camera;
2865         muse_camera_api_e api = MUSE_CAMERA_API_GET_CAPTURE_RESOLUTION;
2866         int sock_fd;
2867         if (pc->cb_info == NULL) {
2868                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2869                 return CAMERA_ERROR_INVALID_PARAMETER;
2870         }
2871         sock_fd = pc->cb_info->fd;
2872         int get_width;
2873         int get_height;
2874
2875         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2876         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2877
2878         if (ret == CAMERA_ERROR_NONE) {
2879                 muse_camera_msg_get(get_width, pc->cb_info->recv_msg);
2880                 muse_camera_msg_get(get_height, pc->cb_info->recv_msg);
2881                 *width = get_width;
2882                 *height = get_height;
2883         }
2884         LOGD("ret : 0x%x", ret);
2885         return ret;
2886 }
2887
2888 int camera_get_capture_format(camera_h camera, camera_pixel_format_e *format)
2889 {
2890         if (camera == NULL || format == NULL) {
2891                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2892                 return CAMERA_ERROR_INVALID_PARAMETER;
2893         }
2894         int ret = CAMERA_ERROR_NONE;
2895
2896         camera_cli_s *pc = (camera_cli_s *)camera;
2897         muse_camera_api_e api = MUSE_CAMERA_API_GET_CAPTURE_FORMAT;
2898         int get_format;
2899         int sock_fd;
2900         if (pc->cb_info == NULL) {
2901                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2902                 return CAMERA_ERROR_INVALID_PARAMETER;
2903         }
2904         sock_fd = pc->cb_info->fd;
2905
2906         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2907         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2908
2909         if (ret == CAMERA_ERROR_NONE) {
2910                 muse_camera_msg_get(get_format, pc->cb_info->recv_msg);
2911                 *format = (camera_pixel_format_e)get_format;
2912         }
2913         LOGD("ret : 0x%x", ret);
2914         return ret;
2915 }
2916
2917 int camera_get_preview_format(camera_h camera, camera_pixel_format_e *format)
2918 {
2919         if (camera == NULL || format == NULL) {
2920                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2921                 return CAMERA_ERROR_INVALID_PARAMETER;
2922         }
2923
2924         int ret = CAMERA_ERROR_NONE;
2925
2926         camera_cli_s *pc = (camera_cli_s *)camera;
2927         muse_camera_api_e api = MUSE_CAMERA_API_GET_PREVIEW_FORMAT;
2928         int get_format;
2929         int sock_fd;
2930         if (pc->cb_info == NULL) {
2931                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2932                 return CAMERA_ERROR_INVALID_PARAMETER;
2933         }
2934         sock_fd = pc->cb_info->fd;
2935
2936         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2937         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2938
2939         if (ret == CAMERA_ERROR_NONE) {
2940                 muse_camera_msg_get(get_format, pc->cb_info->recv_msg);
2941                 *format = (camera_pixel_format_e)get_format;
2942         }
2943         LOGD("ret : 0x%x", ret);
2944         return ret;
2945 }
2946
2947 int camera_get_facing_direction(camera_h camera, camera_facing_direction_e *facing_direciton)
2948 {
2949         if (camera == NULL || facing_direciton == NULL) {
2950                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2951                 return CAMERA_ERROR_INVALID_PARAMETER;
2952         }
2953
2954         int ret = CAMERA_ERROR_NONE;
2955
2956         camera_cli_s *pc = (camera_cli_s *)camera;
2957         muse_camera_api_e api = MUSE_CAMERA_API_GET_FACING_DIRECTION;
2958         int sock_fd;
2959         if (pc->cb_info == NULL) {
2960                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2961                 return CAMERA_ERROR_INVALID_PARAMETER;
2962         }
2963         sock_fd = pc->cb_info->fd;
2964         int get_facing_direction;
2965
2966         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2967         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2968
2969         if (ret == CAMERA_ERROR_NONE) {
2970                 muse_camera_msg_get(get_facing_direction, pc->cb_info->recv_msg);
2971                 *facing_direciton = (camera_facing_direction_e)get_facing_direction;
2972         }
2973         LOGD("ret : 0x%x", ret);
2974         return ret;
2975 }
2976
2977 int camera_set_preview_cb(camera_h camera, camera_preview_cb callback, void* user_data)
2978 {
2979         if (camera == NULL || callback == NULL) {
2980                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2981                 return CAMERA_ERROR_INVALID_PARAMETER;
2982         }
2983         int ret = CAMERA_ERROR_NONE;
2984
2985         camera_cli_s *pc = (camera_cli_s *)camera;
2986         int sock_fd;
2987         if (pc->cb_info == NULL) {
2988                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2989                 return CAMERA_ERROR_INVALID_PARAMETER;
2990         }
2991         sock_fd = pc->cb_info->fd;
2992         muse_camera_api_e api = MUSE_CAMERA_API_SET_PREVIEW_CB;
2993
2994         LOGD("Enter, handle :%x", pc->remote_handle);
2995
2996         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_PREVIEW] = callback;
2997         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_PREVIEW] = user_data;
2998
2999         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3000         LOGD("ret : 0x%x", ret);
3001         return ret;
3002 }
3003
3004 int camera_unset_preview_cb(camera_h camera)
3005 {
3006         if (camera == NULL) {
3007                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3008                 return CAMERA_ERROR_INVALID_PARAMETER;
3009         }
3010
3011         int ret = CAMERA_ERROR_NONE;
3012
3013         camera_cli_s *pc = (camera_cli_s *)camera;
3014         muse_camera_api_e api = MUSE_CAMERA_API_UNSET_PREVIEW_CB;
3015
3016         LOGD("Enter, handle :%x", pc->remote_handle);
3017
3018         int sock_fd;
3019         if (pc->cb_info == NULL) {
3020                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3021                 return CAMERA_ERROR_INVALID_PARAMETER;
3022         }
3023         sock_fd = pc->cb_info->fd;
3024         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_PREVIEW] = (void *)NULL;
3025         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_PREVIEW] = (void *)NULL;
3026
3027         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3028         LOGD("ret : 0x%x", ret);
3029         return ret;
3030 }
3031
3032 int camera_set_media_packet_preview_cb(camera_h camera, camera_media_packet_preview_cb callback, void* user_data)
3033 {
3034         if (camera == NULL) {
3035                 LOGE("INVALID_PARAMETER(0x%08x) - handle", CAMERA_ERROR_INVALID_PARAMETER);
3036                 return CAMERA_ERROR_INVALID_PARAMETER;
3037         }
3038
3039         if (camera_is_supported_media_packet_preview_cb(camera) == false) {
3040                 LOGE("NOT SUPPORTED");
3041                 return CAMERA_ERROR_NOT_SUPPORTED;
3042         }
3043
3044         if (callback == NULL) {
3045                 LOGE("INVALID_PARAMETER(0x%08x) - callback", CAMERA_ERROR_INVALID_PARAMETER);
3046                 return CAMERA_ERROR_INVALID_PARAMETER;
3047         }
3048
3049         int ret = CAMERA_ERROR_NONE;
3050
3051         camera_cli_s *pc = (camera_cli_s *)camera;
3052         muse_camera_api_e api = MUSE_CAMERA_API_SET_MEDIA_PACKET_PREVIEW_CB;
3053
3054         LOGD("Enter, handle :%x", pc->remote_handle);
3055
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         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_MEDIA_PACKET_PREVIEW] = callback;
3063         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_MEDIA_PACKET_PREVIEW] = user_data;
3064
3065         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3066         LOGD("ret : 0x%x", ret);
3067         return ret;
3068 }
3069
3070 int camera_unset_media_packet_preview_cb(camera_h camera)
3071 {
3072         if (camera == NULL) {
3073                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3074                 return CAMERA_ERROR_INVALID_PARAMETER;
3075         }
3076
3077         int ret = CAMERA_ERROR_NONE;
3078
3079         camera_cli_s *pc = (camera_cli_s *)camera;
3080         muse_camera_api_e api = MUSE_CAMERA_API_UNSET_MEDIA_PACKET_PREVIEW_CB;
3081
3082         LOGD("Enter, handle :%x", pc->remote_handle);
3083
3084         int sock_fd;
3085         if (pc->cb_info == NULL) {
3086                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3087                 return CAMERA_ERROR_INVALID_PARAMETER;
3088         }
3089         sock_fd = pc->cb_info->fd;
3090         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_MEDIA_PACKET_PREVIEW] = (void *)NULL;
3091         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_MEDIA_PACKET_PREVIEW] = (void *)NULL;
3092
3093         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3094         LOGD("ret : 0x%x", ret);
3095         return ret;
3096 }
3097
3098 int camera_set_state_changed_cb(camera_h camera, camera_state_changed_cb callback, void* user_data)
3099 {
3100         if (camera == NULL || callback == NULL) {
3101                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3102                 return CAMERA_ERROR_INVALID_PARAMETER;
3103         }
3104         int ret = CAMERA_ERROR_NONE;
3105
3106         camera_cli_s *pc = (camera_cli_s *)camera;
3107         muse_camera_api_e api = MUSE_CAMERA_API_SET_STATE_CHANGED_CB;
3108
3109         LOGD("Enter, handle :%x", pc->remote_handle);
3110
3111         int sock_fd;
3112         if (pc->cb_info == NULL) {
3113                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3114                 return CAMERA_ERROR_INVALID_PARAMETER;
3115         }
3116         sock_fd = pc->cb_info->fd;
3117         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_STATE_CHANGE] = callback;
3118         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_STATE_CHANGE] = user_data;
3119
3120         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3121         LOGD("ret : 0x%x", ret);
3122         return ret;
3123 }
3124 int camera_unset_state_changed_cb(camera_h camera)
3125 {
3126         if (camera == NULL) {
3127                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3128                 return CAMERA_ERROR_INVALID_PARAMETER;
3129         }
3130         int ret = CAMERA_ERROR_NONE;
3131
3132         camera_cli_s *pc = (camera_cli_s *)camera;
3133         muse_camera_api_e api = MUSE_CAMERA_API_UNSET_STATE_CHANGED_CB;
3134
3135         LOGD("Enter, handle :%x", pc->remote_handle);
3136
3137         int sock_fd;
3138         if (pc->cb_info == NULL) {
3139                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3140                 return CAMERA_ERROR_INVALID_PARAMETER;
3141         }
3142         sock_fd = pc->cb_info->fd;
3143         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_STATE_CHANGE] = (void *)NULL;
3144         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_STATE_CHANGE] = (void *)NULL;
3145
3146         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3147         LOGD("ret : 0x%x", ret);
3148         return ret;
3149 }
3150
3151 int camera_set_interrupted_cb(camera_h camera, camera_interrupted_cb callback, void *user_data)
3152 {
3153         if (camera == NULL || callback == NULL) {
3154                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3155                 return CAMERA_ERROR_INVALID_PARAMETER;
3156         }
3157         int ret = CAMERA_ERROR_NONE;
3158
3159         camera_cli_s *pc = (camera_cli_s *)camera;
3160         muse_camera_api_e api = MUSE_CAMERA_API_SET_INTERRUPTED_CB;
3161
3162         LOGD("Enter, handle :%x", pc->remote_handle);
3163
3164         int sock_fd;
3165         if (pc->cb_info == NULL) {
3166                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3167                 return CAMERA_ERROR_INVALID_PARAMETER;
3168         }
3169         sock_fd = pc->cb_info->fd;
3170         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_INTERRUPTED] = callback;
3171         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_INTERRUPTED] = user_data;
3172
3173         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3174         LOGD("ret : 0x%x", ret);
3175         return ret;
3176 }
3177
3178 int camera_unset_interrupted_cb(camera_h camera)
3179 {
3180         if (camera == NULL) {
3181                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3182                 return CAMERA_ERROR_INVALID_PARAMETER;
3183         }
3184         int ret = CAMERA_ERROR_NONE;
3185
3186         camera_cli_s *pc = (camera_cli_s *)camera;
3187         muse_camera_api_e api = MUSE_CAMERA_API_UNSET_INTERRUPTED_CB;
3188
3189         LOGD("Enter, handle :%x", pc->remote_handle);
3190
3191         int sock_fd;
3192         if (pc->cb_info == NULL) {
3193                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3194                 return CAMERA_ERROR_INVALID_PARAMETER;
3195         }
3196         sock_fd = pc->cb_info->fd;
3197         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_INTERRUPTED] = (void *)NULL;
3198         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_INTERRUPTED] = (void *)NULL;
3199
3200         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3201         LOGD("ret : 0x%x", ret);
3202         return ret;
3203 }
3204
3205 int camera_set_focus_changed_cb(camera_h camera, camera_focus_changed_cb callback, void* user_data)
3206 {
3207         if (camera == NULL || callback == NULL) {
3208                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3209                 return CAMERA_ERROR_INVALID_PARAMETER;
3210         }
3211         int ret = CAMERA_ERROR_NONE;
3212
3213         camera_cli_s *pc = (camera_cli_s *)camera;
3214         muse_camera_api_e api = MUSE_CAMERA_API_SET_FOCUS_CHANGED_CB;
3215
3216         LOGD("Enter, handle :%x", pc->remote_handle);
3217
3218         int sock_fd;
3219         if (pc->cb_info == NULL) {
3220                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3221                 return CAMERA_ERROR_INVALID_PARAMETER;
3222         }
3223         sock_fd = pc->cb_info->fd;
3224         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = callback;
3225         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = user_data;
3226
3227         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3228         LOGD("ret : 0x%x", ret);
3229         return ret;
3230 }
3231
3232 int camera_unset_focus_changed_cb(camera_h camera)
3233 {
3234         if (camera == NULL) {
3235                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3236                 return CAMERA_ERROR_INVALID_PARAMETER;
3237         }
3238         int ret = CAMERA_ERROR_NONE;
3239
3240         camera_cli_s *pc = (camera_cli_s *)camera;
3241         muse_camera_api_e api = MUSE_CAMERA_API_UNSET_FOCUS_CHANGED_CB;
3242
3243         LOGD("Enter, handle :%x", pc->remote_handle);
3244
3245         int sock_fd;
3246         if (pc->cb_info == NULL) {
3247                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3248                 return CAMERA_ERROR_INVALID_PARAMETER;
3249         }
3250         sock_fd = pc->cb_info->fd;
3251         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = (void *)NULL;
3252         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = (void *)NULL;
3253
3254         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3255         LOGD("ret : 0x%x", ret);
3256         return ret;
3257 }
3258
3259 int camera_set_error_cb(camera_h camera, camera_error_cb callback, void *user_data)
3260 {
3261         if (camera == NULL || callback == NULL) {
3262                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3263                 return CAMERA_ERROR_INVALID_PARAMETER;
3264         }
3265         int ret = CAMERA_ERROR_NONE;
3266
3267         camera_cli_s *pc = (camera_cli_s *)camera;
3268         muse_camera_api_e api = MUSE_CAMERA_API_SET_ERROR_CB;
3269
3270         LOGD("Enter, handle :%x", pc->remote_handle);
3271
3272         int sock_fd;
3273         if (pc->cb_info == NULL) {
3274                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3275                 return CAMERA_ERROR_INVALID_PARAMETER;
3276         }
3277         sock_fd = pc->cb_info->fd;
3278         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_ERROR] = callback;
3279         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_ERROR] = user_data;
3280
3281         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3282         LOGD("ret : 0x%x", ret);
3283         return ret;
3284 }
3285
3286 int camera_unset_error_cb(camera_h camera)
3287 {
3288         if (camera == NULL) {
3289                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3290                 return CAMERA_ERROR_INVALID_PARAMETER;
3291         }
3292         int ret = CAMERA_ERROR_NONE;
3293
3294         camera_cli_s *pc = (camera_cli_s *)camera;
3295         muse_camera_api_e api = MUSE_CAMERA_API_UNSET_ERROR_CB;
3296
3297         LOGD("Enter, handle :%x", pc->remote_handle);
3298
3299         int sock_fd;
3300         if (pc->cb_info == NULL) {
3301                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3302                 return CAMERA_ERROR_INVALID_PARAMETER;
3303         }
3304         sock_fd = pc->cb_info->fd;
3305         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_ERROR] = (void *)NULL;
3306         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_ERROR] = (void *)NULL;
3307
3308         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3309         LOGD("ret : 0x%x", ret);
3310         return ret;
3311 }
3312
3313 int camera_foreach_supported_preview_resolution(camera_h camera, camera_supported_preview_resolution_cb foreach_cb , void *user_data)
3314 {
3315         if (camera == NULL || foreach_cb == NULL) {
3316                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3317                 return CAMERA_ERROR_INVALID_PARAMETER;
3318         }
3319         int ret = CAMERA_ERROR_NONE;
3320
3321         camera_cli_s *pc = (camera_cli_s *)camera;
3322         muse_camera_api_e api = MUSE_CAMERA_API_SET_FOREACH_SUPPORTED_PREVIEW_RESOLUTION;
3323
3324         LOGD("Enter, handle :%x", pc->remote_handle);
3325
3326         int sock_fd;
3327         if (pc->cb_info == NULL) {
3328                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3329                 return CAMERA_ERROR_INVALID_PARAMETER;
3330         }
3331         sock_fd = pc->cb_info->fd;
3332         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_RESOLUTION] = foreach_cb;
3333         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_RESOLUTION] = user_data;
3334
3335         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3336         LOGD("ret : 0x%x", ret);
3337         return ret;
3338 }
3339
3340 int camera_foreach_supported_capture_resolution(camera_h camera, camera_supported_capture_resolution_cb foreach_cb , void *user_data)
3341 {
3342         if (camera == NULL || foreach_cb == NULL) {
3343                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3344                 return CAMERA_ERROR_INVALID_PARAMETER;
3345         }
3346         int ret = CAMERA_ERROR_NONE;
3347
3348         camera_cli_s *pc = (camera_cli_s *)camera;
3349         muse_camera_api_e api = MUSE_CAMERA_API_SET_FOREACH_SUPPORTED_CAPTURE_RESOLUTION;
3350
3351         LOGD("Enter, handle :%x", pc->remote_handle);
3352
3353         int sock_fd;
3354         if (pc->cb_info == NULL) {
3355                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3356                 return CAMERA_ERROR_INVALID_PARAMETER;
3357         }
3358         sock_fd = pc->cb_info->fd;
3359         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_RESOLUTION] = foreach_cb;
3360         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_RESOLUTION] = user_data;
3361
3362         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3363         LOGD("ret : 0x%x", ret);
3364         return ret;
3365 }
3366
3367 int camera_foreach_supported_capture_format(camera_h camera, camera_supported_capture_format_cb foreach_cb , void *user_data)
3368 {
3369         if (camera == NULL || foreach_cb == NULL) {
3370                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3371                 return CAMERA_ERROR_INVALID_PARAMETER;
3372         }
3373         int ret = CAMERA_ERROR_NONE;
3374
3375         camera_cli_s *pc = (camera_cli_s *)camera;
3376         muse_camera_api_e api = MUSE_CAMERA_API_SET_FOREACH_SUPPORTED_CAPTURE_FORMAT;
3377
3378         LOGD("Enter, handle :%x", pc->remote_handle);
3379
3380         int sock_fd;
3381         if (pc->cb_info == NULL) {
3382                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3383                 return CAMERA_ERROR_INVALID_PARAMETER;
3384         }
3385         sock_fd = pc->cb_info->fd;
3386         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_FORMAT] = foreach_cb;
3387         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_FORMAT] = user_data;
3388
3389         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3390         LOGD("ret : 0x%x", ret);
3391         return ret;
3392 }
3393
3394
3395 int camera_foreach_supported_preview_format(camera_h camera, camera_supported_preview_format_cb foreach_cb , void *user_data)
3396 {
3397         if (camera == NULL || foreach_cb == NULL) {
3398                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3399                 return CAMERA_ERROR_INVALID_PARAMETER;
3400         }
3401         int ret = CAMERA_ERROR_NONE;
3402
3403         camera_cli_s *pc = (camera_cli_s *)camera;
3404         muse_camera_api_e api = MUSE_CAMERA_API_SET_FOREACH_SUPPORTED_PREVIEW_FORMAT;
3405
3406         LOGD("Enter, handle :%x", pc->remote_handle);
3407
3408         int sock_fd;
3409         if (pc->cb_info == NULL) {
3410                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3411                 return CAMERA_ERROR_INVALID_PARAMETER;
3412         }
3413         sock_fd = pc->cb_info->fd;
3414         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_FORMAT] = foreach_cb;
3415         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_FORMAT] = user_data;
3416
3417         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3418         LOGD("ret : 0x%x", ret);
3419         return ret;
3420 }
3421
3422
3423 int camera_get_recommended_preview_resolution(camera_h camera, int *width, int *height)
3424 {
3425         if (camera == NULL || width == NULL || height == NULL) {
3426                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3427                 return CAMERA_ERROR_INVALID_PARAMETER;
3428         }
3429         int ret = CAMERA_ERROR_NONE;
3430
3431         camera_cli_s *pc = (camera_cli_s *)camera;
3432         muse_camera_api_e api = MUSE_CAMERA_API_GET_RECOMMENDED_PREVIEW_RESOLUTION;
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_width;
3440         int get_height;
3441
3442         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3443         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3444
3445         if (ret == CAMERA_ERROR_NONE) {
3446                 muse_camera_msg_get(get_width, pc->cb_info->recv_msg);
3447                 muse_camera_msg_get(get_height, pc->cb_info->recv_msg);
3448                 *width = get_width;
3449                 *height = get_height;
3450         }
3451         LOGD("ret : 0x%x", ret);
3452         return ret;
3453 }
3454
3455
3456 int camera_attr_get_lens_orientation(camera_h camera, int *angle)
3457 {
3458         if (camera == NULL || angle == NULL) {
3459                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3460                 return CAMERA_ERROR_INVALID_PARAMETER;
3461         }
3462         int ret = CAMERA_ERROR_NONE;
3463
3464         camera_cli_s *pc = (camera_cli_s *)camera;
3465         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_LENS_ORIENTATION;
3466         int sock_fd;
3467         if (pc->cb_info == NULL) {
3468                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3469                 return CAMERA_ERROR_INVALID_PARAMETER;
3470         }
3471         sock_fd = pc->cb_info->fd;
3472         int get_angle;
3473
3474         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3475         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3476
3477         if (ret == CAMERA_ERROR_NONE) {
3478                 muse_camera_msg_get(get_angle, pc->cb_info->recv_msg);
3479                 *angle = get_angle;
3480         }
3481         LOGD("ret : 0x%x", ret);
3482         return ret;
3483 }
3484
3485 int camera_attr_set_theater_mode(camera_h camera, camera_attr_theater_mode_e mode)
3486 {
3487         if (camera == NULL) {
3488                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3489                 return CAMERA_ERROR_INVALID_PARAMETER;
3490         }
3491         int ret = CAMERA_ERROR_NONE;
3492         camera_cli_s *pc = (camera_cli_s *)camera;
3493         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_THEATER_MODE;
3494         int sock_fd;
3495         if (pc->cb_info == NULL) {
3496                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3497                 return CAMERA_ERROR_INVALID_PARAMETER;
3498         }
3499         sock_fd = pc->cb_info->fd;
3500         int set_mode = (int)mode;
3501         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3502         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_mode);
3503         LOGD("ret : 0x%x", ret);
3504         return ret;
3505 }
3506
3507 int camera_attr_get_theater_mode(camera_h camera, camera_attr_theater_mode_e *mode)
3508 {
3509         if (camera == NULL || mode == NULL) {
3510                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3511                 return CAMERA_ERROR_INVALID_PARAMETER;
3512         }
3513
3514         int ret = CAMERA_ERROR_NONE;
3515         camera_cli_s *pc = (camera_cli_s *)camera;
3516         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_THEATER_MODE;
3517         int sock_fd;
3518         if (pc->cb_info == NULL) {
3519                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3520                 return CAMERA_ERROR_INVALID_PARAMETER;
3521         }
3522         sock_fd = pc->cb_info->fd;
3523         int get_mode;
3524         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3525         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3526
3527         if (ret == CAMERA_ERROR_NONE) {
3528                 muse_camera_msg_get(get_mode, pc->cb_info->recv_msg);
3529                 *mode = (camera_attr_theater_mode_e)get_mode;
3530         }
3531         LOGD("ret : 0x%x", ret);
3532         return ret;
3533 }
3534
3535 int camera_attr_foreach_supported_theater_mode(camera_h camera, camera_attr_supported_theater_mode_cb foreach_cb, void *user_data)
3536 {
3537         if (camera == NULL || foreach_cb == NULL) {
3538                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3539                 return CAMERA_ERROR_INVALID_PARAMETER;
3540         }
3541         int ret = CAMERA_ERROR_NONE;
3542
3543         camera_cli_s *pc = (camera_cli_s *)camera;
3544         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_THEATER_MODE;
3545
3546         LOGD("Enter, handle :%x", pc->remote_handle);
3547
3548         int sock_fd;
3549         if (pc->cb_info == NULL) {
3550                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3551                 return CAMERA_ERROR_INVALID_PARAMETER;
3552         }
3553         sock_fd = pc->cb_info->fd;
3554         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_THEATER_MODE] = foreach_cb;
3555         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_THEATER_MODE] = user_data;
3556
3557         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3558
3559         LOGD("Finish, return :%x", ret);
3560
3561         return ret;
3562 }
3563
3564 int camera_attr_set_preview_fps(camera_h camera,  camera_attr_fps_e fps)
3565 {
3566         if (camera == NULL) {
3567                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3568                 return CAMERA_ERROR_INVALID_PARAMETER;
3569         }
3570         int ret = CAMERA_ERROR_NONE;
3571         camera_cli_s *pc = (camera_cli_s *)camera;
3572         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_PREVIEW_FPS;
3573         int sock_fd;
3574         if (pc->cb_info == NULL) {
3575                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3576                 return CAMERA_ERROR_INVALID_PARAMETER;
3577         }
3578         sock_fd = pc->cb_info->fd;
3579         int set_fps = (int)fps;
3580         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3581         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_fps);
3582         LOGD("ret : 0x%x", ret);
3583         return ret;
3584 }
3585
3586
3587 int camera_attr_set_image_quality(camera_h camera,  int quality)
3588 {
3589         if (camera == NULL) {
3590                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3591                 return CAMERA_ERROR_INVALID_PARAMETER;
3592         }
3593         int ret = CAMERA_ERROR_NONE;
3594
3595         camera_cli_s *pc = (camera_cli_s *)camera;
3596         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_IMAGE_QUALITY;
3597         int sock_fd;
3598         if (pc->cb_info == NULL) {
3599                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3600                 return CAMERA_ERROR_INVALID_PARAMETER;
3601         }
3602         sock_fd = pc->cb_info->fd;
3603         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3604         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, quality);
3605         LOGD("ret : 0x%x", ret);
3606         return ret;
3607 }
3608
3609 int camera_attr_get_preview_fps(camera_h camera,  camera_attr_fps_e *fps)
3610 {
3611         if (camera == NULL || fps == NULL) {
3612                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3613                 return CAMERA_ERROR_INVALID_PARAMETER;
3614         }
3615         int ret = CAMERA_ERROR_NONE;
3616
3617         camera_cli_s *pc = (camera_cli_s *)camera;
3618         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_PREVIEW_FPS;
3619         int get_fps;
3620         int sock_fd;
3621         if (pc->cb_info == NULL) {
3622                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3623                 return CAMERA_ERROR_INVALID_PARAMETER;
3624         }
3625         sock_fd = pc->cb_info->fd;
3626
3627         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3628         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3629
3630         if (ret == CAMERA_ERROR_NONE) {
3631                 muse_camera_msg_get(get_fps, pc->cb_info->recv_msg);
3632                 *fps = (camera_attr_fps_e)get_fps;
3633         }
3634         LOGD("ret : 0x%x", ret);
3635         return ret;
3636 }
3637
3638
3639 int camera_attr_get_image_quality(camera_h camera, int *quality)
3640 {
3641         if (camera == NULL || quality == NULL) {
3642                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3643                 return CAMERA_ERROR_INVALID_PARAMETER;
3644         }
3645         int ret = CAMERA_ERROR_NONE;
3646
3647         camera_cli_s *pc = (camera_cli_s *)camera;
3648         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_IMAGE_QUALITY;
3649         int sock_fd;
3650         if (pc->cb_info == NULL) {
3651                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3652                 return CAMERA_ERROR_INVALID_PARAMETER;
3653         }
3654         sock_fd = pc->cb_info->fd;
3655         int get_quality;
3656         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3657         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3658
3659         if (ret == CAMERA_ERROR_NONE) {
3660                 muse_camera_msg_get(get_quality, pc->cb_info->recv_msg);
3661                 *quality = get_quality;
3662         }
3663         LOGD("ret : 0x%x", ret);
3664         return ret;
3665 }
3666
3667
3668 int camera_attr_set_zoom(camera_h camera, int zoom)
3669 {
3670         if (camera == NULL) {
3671                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3672                 return CAMERA_ERROR_INVALID_PARAMETER;
3673         }
3674         int ret = CAMERA_ERROR_NONE;
3675
3676         camera_cli_s *pc = (camera_cli_s *)camera;
3677         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_ZOOM;
3678         int sock_fd;
3679         if (pc->cb_info == NULL) {
3680                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3681                 return CAMERA_ERROR_INVALID_PARAMETER;
3682         }
3683         sock_fd = pc->cb_info->fd;
3684
3685         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3686         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, zoom);
3687         LOGD("ret : 0x%x", ret);
3688         return ret;
3689 }
3690
3691 int camera_attr_set_af_mode(camera_h camera,  camera_attr_af_mode_e mode)
3692 {
3693         if (camera == NULL) {
3694                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3695                 return CAMERA_ERROR_INVALID_PARAMETER;
3696         }
3697         int ret = CAMERA_ERROR_NONE;
3698
3699         camera_cli_s *pc = (camera_cli_s *)camera;
3700         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_AF_MODE;
3701         int sock_fd;
3702         if (pc->cb_info == NULL) {
3703                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3704                 return CAMERA_ERROR_INVALID_PARAMETER;
3705         }
3706         sock_fd = pc->cb_info->fd;
3707         int set_mode = (int)mode;
3708         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3709         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_mode);
3710         LOGD("ret : 0x%x", ret);
3711         return ret;
3712 }
3713
3714 int camera_attr_set_af_area(camera_h camera, int x, int y)
3715 {
3716         if (camera == NULL) {
3717                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3718                 return CAMERA_ERROR_INVALID_PARAMETER;
3719         }
3720         int ret = CAMERA_ERROR_NONE;
3721         camera_cli_s *pc = (camera_cli_s *)camera;
3722         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_AF_AREA;
3723         int sock_fd = pc->cb_info->fd;
3724         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3725         muse_camera_msg_send2(api, sock_fd, pc->cb_info, ret, INT, x, INT, y);
3726         LOGD("ret : 0x%x", ret);
3727         return ret;
3728 }
3729
3730
3731 int camera_attr_clear_af_area(camera_h camera)
3732 {
3733         if (camera == NULL) {
3734                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3735                 return CAMERA_ERROR_INVALID_PARAMETER;
3736         }
3737         int ret = CAMERA_ERROR_NONE;
3738
3739         camera_cli_s *pc = (camera_cli_s *)camera;
3740         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_CLEAR_AF_AREA;
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         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3748         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3749         LOGD("ret : 0x%x", ret);
3750         return ret;
3751 }
3752
3753
3754 int camera_attr_set_exposure_mode(camera_h camera,  camera_attr_exposure_mode_e mode)
3755 {
3756         if (camera == NULL) {
3757                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3758                 return CAMERA_ERROR_INVALID_PARAMETER;
3759         }
3760
3761         if (mode < CAMERA_ATTR_EXPOSURE_MODE_OFF || mode > CAMERA_ATTR_EXPOSURE_MODE_CUSTOM) {
3762                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3763                 return CAMERA_ERROR_INVALID_PARAMETER;
3764         }
3765
3766         int ret = CAMERA_ERROR_NONE;
3767         camera_cli_s *pc = (camera_cli_s *)camera;
3768         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_EXPOSURE_MODE;
3769         int set_mode = (int)mode;
3770         int sock_fd;
3771         if (pc->cb_info == NULL) {
3772                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3773                 return CAMERA_ERROR_INVALID_PARAMETER;
3774         }
3775         sock_fd = pc->cb_info->fd;
3776         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3777         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_mode);
3778         LOGD("ret : 0x%x", ret);
3779         return ret;
3780 }
3781
3782
3783 int camera_attr_set_exposure(camera_h camera, int value)
3784 {
3785         if (camera == NULL) {
3786                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3787                 return CAMERA_ERROR_INVALID_PARAMETER;
3788         }
3789         int ret = CAMERA_ERROR_NONE;
3790
3791         camera_cli_s *pc = (camera_cli_s *)camera;
3792         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_EXPOSURE;
3793         int sock_fd;
3794         if (pc->cb_info == NULL) {
3795                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3796                 return CAMERA_ERROR_INVALID_PARAMETER;
3797         }
3798         sock_fd = pc->cb_info->fd;
3799
3800         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3801         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, value);
3802         LOGD("ret : 0x%x", ret);
3803         return ret;
3804 }
3805
3806
3807 int camera_attr_set_iso(camera_h camera, camera_attr_iso_e iso)
3808 {
3809         if (camera == NULL) {
3810                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3811                 return CAMERA_ERROR_INVALID_PARAMETER;
3812         }
3813         int ret = CAMERA_ERROR_NONE;
3814
3815         camera_cli_s *pc = (camera_cli_s *)camera;
3816         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_ISO;
3817         int sock_fd;
3818         if (pc->cb_info == NULL) {
3819                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3820                 return CAMERA_ERROR_INVALID_PARAMETER;
3821         }
3822         sock_fd = pc->cb_info->fd;
3823         int set_iso = (int)iso;
3824         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3825         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_iso);
3826         LOGD("ret : 0x%x", ret);
3827         return ret;
3828 }
3829
3830
3831 int camera_attr_set_brightness(camera_h camera, int level)
3832 {
3833         if (camera == NULL) {
3834                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3835                 return CAMERA_ERROR_INVALID_PARAMETER;
3836         }
3837         int ret = CAMERA_ERROR_NONE;
3838
3839         camera_cli_s *pc = (camera_cli_s *)camera;
3840         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_BRIGHTNESS;
3841         int sock_fd;
3842         if (pc->cb_info == NULL) {
3843                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3844                 return CAMERA_ERROR_INVALID_PARAMETER;
3845         }
3846         sock_fd = pc->cb_info->fd;
3847
3848         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3849         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, level);
3850         LOGD("ret : 0x%x", ret);
3851         return ret;
3852 }
3853
3854
3855 int camera_attr_set_contrast(camera_h camera, int level)
3856 {
3857         if (camera == NULL) {
3858                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3859                 return CAMERA_ERROR_INVALID_PARAMETER;
3860         }
3861         int ret = CAMERA_ERROR_NONE;
3862
3863         camera_cli_s *pc = (camera_cli_s *)camera;
3864         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_CONTRAST;
3865         int sock_fd;
3866         if (pc->cb_info == NULL) {
3867                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3868                 return CAMERA_ERROR_INVALID_PARAMETER;
3869         }
3870         sock_fd = pc->cb_info->fd;
3871
3872         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3873         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, level);
3874         LOGD("ret : 0x%x", ret);
3875         return ret;
3876 }
3877
3878
3879 int camera_attr_set_whitebalance(camera_h camera, camera_attr_whitebalance_e wb)
3880 {
3881         if (camera == NULL) {
3882                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3883                 return CAMERA_ERROR_INVALID_PARAMETER;
3884         }
3885
3886         if (wb < CAMERA_ATTR_WHITE_BALANCE_NONE || wb > CAMERA_ATTR_WHITE_BALANCE_CUSTOM) {
3887                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_NOT_SUPPORTED);
3888                 return CAMERA_ERROR_NOT_SUPPORTED;
3889         }
3890
3891         int ret = CAMERA_ERROR_NONE;
3892
3893         camera_cli_s *pc = (camera_cli_s *)camera;
3894         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_WHITEBALANCE;
3895         int sock_fd;
3896         if (pc->cb_info == NULL) {
3897                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3898                 return CAMERA_ERROR_INVALID_PARAMETER;
3899         }
3900         sock_fd = pc->cb_info->fd;
3901         int set_whitebalance = (int)wb;
3902         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3903         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_whitebalance);
3904         LOGD("ret : 0x%x", ret);
3905         return ret;
3906 }
3907
3908
3909 int camera_attr_set_effect(camera_h camera, camera_attr_effect_mode_e effect)
3910 {
3911         if (camera == NULL) {
3912                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3913                 return CAMERA_ERROR_INVALID_PARAMETER;
3914         }
3915         int ret = CAMERA_ERROR_NONE;
3916
3917         camera_cli_s *pc = (camera_cli_s *)camera;
3918         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_EFFECT;
3919         int sock_fd;
3920         if (pc->cb_info == NULL) {
3921                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3922                 return CAMERA_ERROR_INVALID_PARAMETER;
3923         }
3924         sock_fd = pc->cb_info->fd;
3925         int set_effect = (int)effect;
3926         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3927         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_effect);
3928         LOGD("ret : 0x%x", ret);
3929         return ret;
3930 }
3931
3932
3933 int camera_attr_set_scene_mode(camera_h camera, camera_attr_scene_mode_e mode)
3934 {
3935         if (camera == NULL) {
3936                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3937                 return CAMERA_ERROR_INVALID_PARAMETER;
3938         }
3939         int ret = CAMERA_ERROR_NONE;
3940
3941         camera_cli_s *pc = (camera_cli_s *)camera;
3942         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_SCENE_MODE;
3943         int sock_fd;
3944         if (pc->cb_info == NULL) {
3945                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3946                 return CAMERA_ERROR_INVALID_PARAMETER;
3947         }
3948         sock_fd = pc->cb_info->fd;
3949         int set_mode = (int)mode;
3950         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3951         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_mode);
3952         LOGD("ret : 0x%x", ret);
3953         return ret;
3954 }
3955
3956
3957 int camera_attr_enable_tag(camera_h camera, bool enable)
3958 {
3959         if (camera == NULL) {
3960                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3961                 return CAMERA_ERROR_INVALID_PARAMETER;
3962         }
3963         int ret = CAMERA_ERROR_NONE;
3964         camera_cli_s *pc = (camera_cli_s *)camera;
3965         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_ENABLE_TAG;
3966         int sock_fd;
3967         if (pc->cb_info == NULL) {
3968                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3969                 return CAMERA_ERROR_INVALID_PARAMETER;
3970         }
3971         sock_fd = pc->cb_info->fd;
3972         int set_enable = (int)enable;
3973
3974         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3975         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_enable);
3976         LOGD("ret : 0x%x", ret);
3977         return ret;
3978 }
3979
3980
3981 int camera_attr_set_tag_image_description(camera_h camera, const char *description)
3982 {
3983         if (camera == NULL) {
3984                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3985                 return CAMERA_ERROR_INVALID_PARAMETER;
3986         }
3987         if (description == NULL) {
3988                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3989                 return CAMERA_ERROR_INVALID_PARAMETER;
3990         }
3991         int ret = CAMERA_ERROR_NONE;
3992         camera_cli_s *pc = (camera_cli_s *)camera;
3993         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_TAG_IMAGE_DESCRIPTION;
3994         int sock_fd;
3995         if (pc->cb_info == NULL) {
3996                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3997                 return CAMERA_ERROR_INVALID_PARAMETER;
3998         }
3999         sock_fd = pc->cb_info->fd;
4000         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4001         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, STRING, description);
4002         LOGD("ret : 0x%x", ret);
4003         return ret;
4004 }
4005
4006
4007 int camera_attr_set_tag_orientation(camera_h camera,  camera_attr_tag_orientation_e orientation)
4008 {
4009         if (camera == NULL) {
4010                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4011                 return CAMERA_ERROR_INVALID_PARAMETER;
4012         }
4013         int ret = CAMERA_ERROR_NONE;
4014         camera_cli_s *pc = (camera_cli_s *)camera;
4015         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_TAG_ORIENTATION;
4016         int sock_fd;
4017         if (pc->cb_info == NULL) {
4018                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4019                 return CAMERA_ERROR_INVALID_PARAMETER;
4020         }
4021         sock_fd = pc->cb_info->fd;
4022         int set_orientation = (int)orientation;
4023
4024         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4025         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_orientation);
4026         LOGD("ret : 0x%x", ret);
4027         return ret;
4028 }
4029
4030
4031 int camera_attr_set_tag_software(camera_h camera,  const char *software)
4032 {
4033         if (camera == NULL) {
4034                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4035                 return CAMERA_ERROR_INVALID_PARAMETER;
4036         }
4037         if (software == NULL) {
4038                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4039                 return CAMERA_ERROR_INVALID_PARAMETER;
4040         }
4041         int ret = CAMERA_ERROR_NONE;
4042         camera_cli_s *pc = (camera_cli_s *)camera;
4043         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_TAG_SOFTWARE;
4044         int sock_fd;
4045         if (pc->cb_info == NULL) {
4046                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4047                 return CAMERA_ERROR_INVALID_PARAMETER;
4048         }
4049         sock_fd = pc->cb_info->fd;
4050         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4051         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, STRING, software);
4052         LOGD("ret : 0x%x", ret);
4053         return ret;
4054 }
4055
4056
4057 int camera_attr_set_geotag(camera_h camera, double latitude , double longitude, double altitude)
4058 {
4059         if (camera == NULL) {
4060                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4061                 return CAMERA_ERROR_INVALID_PARAMETER;
4062         }
4063         int ret = CAMERA_ERROR_NONE;
4064         camera_cli_s *pc = (camera_cli_s *)camera;
4065         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_GEOTAG;
4066         int sock_fd;
4067         if (pc->cb_info == NULL) {
4068                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4069                 return CAMERA_ERROR_INVALID_PARAMETER;
4070         }
4071         sock_fd = pc->cb_info->fd;
4072         double set_geotag[3] = { latitude, longitude, altitude };
4073
4074         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4075         muse_camera_msg_send_array(api, sock_fd, pc->cb_info, ret,
4076                                                                         set_geotag, sizeof(set_geotag), sizeof(double));
4077         LOGD("ret : 0x%x", ret);
4078         return ret;
4079 }
4080
4081
4082 int camera_attr_remove_geotag(camera_h camera)
4083 {
4084         if (camera == NULL) {
4085                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4086                 return CAMERA_ERROR_INVALID_PARAMETER;
4087         }
4088         int ret = CAMERA_ERROR_NONE;
4089         camera_cli_s *pc = (camera_cli_s *)camera;
4090         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_REMOVE_GEOTAG;
4091         int sock_fd;
4092         if (pc->cb_info == NULL) {
4093                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4094                 return CAMERA_ERROR_INVALID_PARAMETER;
4095         }
4096         sock_fd = pc->cb_info->fd;
4097         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4098         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4099         LOGD("ret : 0x%x", ret);
4100         return ret;
4101 }
4102
4103
4104 int camera_attr_set_flash_mode(camera_h camera, camera_attr_flash_mode_e mode)
4105 {
4106         if (camera == NULL) {
4107                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4108                 return CAMERA_ERROR_INVALID_PARAMETER;
4109         }
4110         int ret = CAMERA_ERROR_NONE;
4111         camera_cli_s *pc = (camera_cli_s *)camera;
4112         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_FLASH_MODE;
4113         int sock_fd;
4114         if (pc->cb_info == NULL) {
4115                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4116                 return CAMERA_ERROR_INVALID_PARAMETER;
4117         }
4118         sock_fd = pc->cb_info->fd;
4119         int set_mode = (int)mode;
4120
4121         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4122         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_mode);
4123         LOGD("ret : 0x%x", ret);
4124         return ret;
4125 }
4126
4127
4128 int camera_attr_get_zoom(camera_h camera, int *zoom)
4129 {
4130         if (camera == NULL || zoom == NULL) {
4131                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4132                 return CAMERA_ERROR_INVALID_PARAMETER;
4133         }
4134         int ret = CAMERA_ERROR_NONE;
4135
4136         camera_cli_s *pc = (camera_cli_s *)camera;
4137         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_ZOOM;
4138         int get_zoom;
4139         int sock_fd;
4140         if (pc->cb_info == NULL) {
4141                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4142                 return CAMERA_ERROR_INVALID_PARAMETER;
4143         }
4144         sock_fd = pc->cb_info->fd;
4145
4146         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4147         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4148
4149         if (ret == CAMERA_ERROR_NONE) {
4150                 muse_camera_msg_get(get_zoom, pc->cb_info->recv_msg);
4151                 *zoom = get_zoom;
4152         }
4153         LOGD("ret : 0x%x", ret);
4154         return ret;
4155 }
4156
4157
4158 int camera_attr_get_zoom_range(camera_h camera, int *min, int *max)
4159 {
4160         if (camera == NULL || min == NULL || max == NULL) {
4161                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4162                 return CAMERA_ERROR_INVALID_PARAMETER;
4163         }
4164         int ret = CAMERA_ERROR_NONE;
4165         camera_cli_s *pc = (camera_cli_s *)camera;
4166         int sock_fd;
4167         if (pc->cb_info == NULL) {
4168                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4169                 return CAMERA_ERROR_INVALID_PARAMETER;
4170         }
4171         sock_fd = pc->cb_info->fd;
4172         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_ZOOM_RANGE;
4173         int get_min;
4174         int get_max;
4175
4176         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4177         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4178
4179         if (ret == CAMERA_ERROR_NONE) {
4180                 muse_camera_msg_get(get_min, pc->cb_info->recv_msg);
4181                 muse_camera_msg_get(get_max, pc->cb_info->recv_msg);
4182                 *min = get_min;
4183                 *max = get_max;
4184         }
4185         LOGD("ret : 0x%x", ret);
4186         return ret;
4187 }
4188
4189
4190 int camera_attr_get_af_mode(camera_h camera, camera_attr_af_mode_e *mode)
4191 {
4192         if (camera == NULL || mode == NULL) {
4193                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4194                 return CAMERA_ERROR_INVALID_PARAMETER;
4195         }
4196         int ret = CAMERA_ERROR_NONE;
4197         camera_cli_s *pc = (camera_cli_s *)camera;
4198         int sock_fd;
4199         if (pc->cb_info == NULL) {
4200                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4201                 return CAMERA_ERROR_INVALID_PARAMETER;
4202         }
4203         sock_fd = pc->cb_info->fd;
4204         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_AF_MODE;
4205         int get_mode;
4206
4207         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4208         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4209
4210         if (ret == CAMERA_ERROR_NONE) {
4211                 muse_camera_msg_get(get_mode, pc->cb_info->recv_msg);
4212                 *mode = (camera_attr_af_mode_e)get_mode;
4213         }
4214         LOGD("ret : 0x%x", ret);
4215         return ret;
4216 }
4217
4218
4219 int camera_attr_get_exposure_mode(camera_h camera, camera_attr_exposure_mode_e *mode)
4220 {
4221         if (camera == NULL || mode == NULL) {
4222                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4223                 return CAMERA_ERROR_INVALID_PARAMETER;
4224         }
4225         int ret = CAMERA_ERROR_NONE;
4226         camera_cli_s *pc = (camera_cli_s *)camera;
4227         int sock_fd;
4228         if (pc->cb_info == NULL) {
4229                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4230                 return CAMERA_ERROR_INVALID_PARAMETER;
4231         }
4232         sock_fd = pc->cb_info->fd;
4233         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_EXPOSURE_MODE;
4234         int get_mode;
4235
4236         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4237         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4238
4239         if (ret == CAMERA_ERROR_NONE) {
4240                 muse_camera_msg_get(get_mode, pc->cb_info->recv_msg);
4241                 *mode = (camera_attr_exposure_mode_e)get_mode;
4242         }
4243         LOGD("ret : 0x%x", ret);
4244         return ret;
4245 }
4246
4247 int camera_attr_get_exposure(camera_h camera, int *value)
4248 {
4249         if (camera == NULL || value == NULL) {
4250                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4251                 return CAMERA_ERROR_INVALID_PARAMETER;
4252         }
4253         int ret = CAMERA_ERROR_NONE;
4254         camera_cli_s *pc = (camera_cli_s *)camera;
4255         int sock_fd;
4256         if (pc->cb_info == NULL) {
4257                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4258                 return CAMERA_ERROR_INVALID_PARAMETER;
4259         }
4260         sock_fd = pc->cb_info->fd;
4261         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_EXPOSURE;
4262         int get_value;
4263
4264         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4265         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4266
4267         if (ret == CAMERA_ERROR_NONE) {
4268                 muse_camera_msg_get(get_value, pc->cb_info->recv_msg);
4269                 *value = get_value;
4270         }
4271         LOGD("ret : 0x%x", ret);
4272         return ret;
4273 }
4274
4275
4276 int camera_attr_get_exposure_range(camera_h camera, int *min, int *max)
4277 {
4278         if (camera == NULL || min == NULL || max == NULL) {
4279                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4280                 return CAMERA_ERROR_INVALID_PARAMETER;
4281         }
4282         int ret = CAMERA_ERROR_NONE;
4283         camera_cli_s *pc = (camera_cli_s *)camera;
4284         int sock_fd;
4285         if (pc->cb_info == NULL) {
4286                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4287                 return CAMERA_ERROR_INVALID_PARAMETER;
4288         }
4289         sock_fd = pc->cb_info->fd;
4290         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_EXPOSURE_RANGE;
4291         int get_min;
4292         int get_max;
4293
4294         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4295         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4296
4297         if (ret == CAMERA_ERROR_NONE) {
4298                 muse_camera_msg_get(get_min, pc->cb_info->recv_msg);
4299                 muse_camera_msg_get(get_max, pc->cb_info->recv_msg);
4300                 *min = get_min;
4301                 *max = get_max;
4302         }
4303         LOGD("ret : 0x%x", ret);
4304         return ret;
4305 }
4306
4307
4308 int camera_attr_get_iso(camera_h camera, camera_attr_iso_e *iso)
4309 {
4310         if (camera == NULL || iso == NULL) {
4311                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4312                 return CAMERA_ERROR_INVALID_PARAMETER;
4313         }
4314         int ret = CAMERA_ERROR_NONE;
4315         camera_cli_s *pc = (camera_cli_s *)camera;
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         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_ISO;
4323         int get_iso;
4324
4325         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4326         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4327
4328         if (ret == CAMERA_ERROR_NONE) {
4329                 muse_camera_msg_get(get_iso, pc->cb_info->recv_msg);
4330                 *iso = (camera_attr_iso_e)get_iso;
4331         }
4332         LOGD("ret : 0x%x", ret);
4333         return ret;
4334 }
4335
4336
4337 int camera_attr_get_brightness(camera_h camera,  int *level)
4338 {
4339         if (camera == NULL || level == NULL) {
4340                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4341                 return CAMERA_ERROR_INVALID_PARAMETER;
4342         }
4343         int ret = CAMERA_ERROR_NONE;
4344         camera_cli_s *pc = (camera_cli_s *)camera;
4345         int sock_fd;
4346         if (pc->cb_info == NULL) {
4347                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4348                 return CAMERA_ERROR_INVALID_PARAMETER;
4349         }
4350         sock_fd = pc->cb_info->fd;
4351         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_BRIGHTNESS;
4352         int get_level;
4353
4354         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4355         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4356
4357         if (ret == CAMERA_ERROR_NONE) {
4358                 muse_camera_msg_get(get_level, pc->cb_info->recv_msg);
4359                 *level = get_level;
4360         }
4361         LOGD("ret : 0x%x", ret);
4362         return ret;
4363 }
4364
4365
4366 int camera_attr_get_brightness_range(camera_h camera, int *min, int *max)
4367 {
4368         if (camera == NULL || min == NULL || max == NULL) {
4369                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4370                 return CAMERA_ERROR_INVALID_PARAMETER;
4371         }
4372         int ret = CAMERA_ERROR_NONE;
4373         camera_cli_s *pc = (camera_cli_s *)camera;
4374         int sock_fd;
4375         if (pc->cb_info == NULL) {
4376                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4377                 return CAMERA_ERROR_INVALID_PARAMETER;
4378         }
4379         sock_fd = pc->cb_info->fd;
4380         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_BRIGHTNESS_RANGE;
4381         int get_min;
4382         int get_max;
4383
4384         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4385         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4386
4387         if (ret == CAMERA_ERROR_NONE) {
4388                 muse_camera_msg_get(get_min, pc->cb_info->recv_msg);
4389                 muse_camera_msg_get(get_max, pc->cb_info->recv_msg);
4390                 *min = get_min;
4391                 *max = get_max;
4392         }
4393         LOGD("ret : 0x%x", ret);
4394         return ret;
4395 }
4396
4397
4398 int camera_attr_get_contrast(camera_h camera,  int *level)
4399 {
4400         if (camera == NULL || level == NULL) {
4401                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4402                 return CAMERA_ERROR_INVALID_PARAMETER;
4403         }
4404         int ret = CAMERA_ERROR_NONE;
4405         camera_cli_s *pc = (camera_cli_s *)camera;
4406         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_CONTRAST;
4407         int sock_fd;
4408         if (pc->cb_info == NULL) {
4409                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4410                 return CAMERA_ERROR_INVALID_PARAMETER;
4411         }
4412         sock_fd = pc->cb_info->fd;
4413         int get_level;
4414
4415         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4416         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4417
4418         if (ret == CAMERA_ERROR_NONE) {
4419                 muse_camera_msg_get(get_level, pc->cb_info->recv_msg);
4420                 *level = get_level;
4421         }
4422         LOGD("ret : 0x%x", ret);
4423         return ret;
4424 }
4425
4426
4427 int camera_attr_get_contrast_range(camera_h camera, int *min , int *max)
4428 {
4429         if (camera == NULL || min == NULL || max == NULL) {
4430                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4431                 return CAMERA_ERROR_INVALID_PARAMETER;
4432         }
4433         int ret = CAMERA_ERROR_NONE;
4434         camera_cli_s *pc = (camera_cli_s *)camera;
4435         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_CONTRAST_RANGE;
4436         int sock_fd;
4437         if (pc->cb_info == NULL) {
4438                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4439                 return CAMERA_ERROR_INVALID_PARAMETER;
4440         }
4441         sock_fd = pc->cb_info->fd;
4442         int get_min;
4443         int get_max;
4444
4445         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4446         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4447
4448         if (ret == CAMERA_ERROR_NONE) {
4449                 muse_camera_msg_get(get_min, pc->cb_info->recv_msg);
4450                 muse_camera_msg_get(get_max, pc->cb_info->recv_msg);
4451                 *min = get_min;
4452                 *max = get_max;
4453         }
4454         LOGD("ret : 0x%x", ret);
4455         return ret;
4456 }
4457
4458
4459 int camera_attr_get_whitebalance(camera_h camera,  camera_attr_whitebalance_e *wb)
4460 {
4461         if (camera == NULL || wb == NULL) {
4462                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4463                 return CAMERA_ERROR_INVALID_PARAMETER;
4464         }
4465         int ret = CAMERA_ERROR_NONE;
4466         camera_cli_s *pc = (camera_cli_s *)camera;
4467         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_WHITEBALANCE;
4468         int sock_fd;
4469         if (pc->cb_info == NULL) {
4470                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4471                 return CAMERA_ERROR_INVALID_PARAMETER;
4472         }
4473         sock_fd = pc->cb_info->fd;
4474         int get_wb;
4475
4476         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4477         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4478
4479         if (ret == CAMERA_ERROR_NONE) {
4480                 muse_camera_msg_get(get_wb, pc->cb_info->recv_msg);
4481                 *wb = (camera_attr_whitebalance_e)get_wb;
4482         }
4483         LOGD("ret : 0x%x", ret);
4484         return ret;
4485 }
4486
4487
4488 int camera_attr_get_effect(camera_h camera, camera_attr_effect_mode_e *effect)
4489 {
4490         if (camera == NULL || effect == NULL) {
4491                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4492                 return CAMERA_ERROR_INVALID_PARAMETER;
4493         }
4494
4495         int ret = CAMERA_ERROR_NONE;
4496         camera_cli_s *pc = (camera_cli_s *)camera;
4497         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_EFFECT;
4498         int sock_fd;
4499         if (pc->cb_info == NULL) {
4500                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4501                 return CAMERA_ERROR_INVALID_PARAMETER;
4502         }
4503         sock_fd = pc->cb_info->fd;
4504         int get_effect;
4505
4506         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4507         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4508
4509         if (ret == CAMERA_ERROR_NONE) {
4510                 muse_camera_msg_get(get_effect, pc->cb_info->recv_msg);
4511                 *effect = (camera_attr_effect_mode_e)get_effect;
4512         }
4513         LOGD("ret : 0x%x", ret);
4514         return ret;
4515 }
4516
4517
4518 int camera_attr_get_scene_mode(camera_h camera,  camera_attr_scene_mode_e *mode)
4519 {
4520         if (camera == NULL || mode == NULL) {
4521                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4522                 return CAMERA_ERROR_INVALID_PARAMETER;
4523         }
4524
4525         int ret = CAMERA_ERROR_NONE;
4526         camera_cli_s *pc = (camera_cli_s *)camera;
4527         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_SCENE_MODE;
4528         int sock_fd;
4529         if (pc->cb_info == NULL) {
4530                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4531                 return CAMERA_ERROR_INVALID_PARAMETER;
4532         }
4533         sock_fd = pc->cb_info->fd;
4534         int get_mode;
4535
4536         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4537         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4538
4539         if (ret == CAMERA_ERROR_NONE) {
4540                 muse_camera_msg_get(get_mode, pc->cb_info->recv_msg);
4541                 *mode = (camera_attr_scene_mode_e)get_mode;
4542         }
4543         LOGD("ret : 0x%x", ret);
4544         return ret;
4545 }
4546
4547
4548 int camera_attr_is_enabled_tag(camera_h camera,  bool *enable)
4549 {
4550         if (camera == NULL || enable == NULL) {
4551                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4552                 return CAMERA_ERROR_INVALID_PARAMETER;
4553         }
4554
4555         int ret = CAMERA_ERROR_NONE;
4556         camera_cli_s *pc = (camera_cli_s *)camera;
4557         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_ENABLED_TAG;
4558         int sock_fd;
4559         if (pc->cb_info == NULL) {
4560                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4561                 return CAMERA_ERROR_INVALID_PARAMETER;
4562         }
4563         sock_fd = pc->cb_info->fd;
4564         int get_enabled;
4565
4566         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4567         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4568
4569         if (ret == CAMERA_ERROR_NONE) {
4570                 muse_camera_msg_get(get_enabled, pc->cb_info->recv_msg);
4571                 *enable = (bool)get_enabled;
4572         }
4573         LOGD("ret : 0x%x", ret);
4574         return ret;
4575 }
4576
4577
4578 int camera_attr_get_tag_image_description(camera_h camera,  char **description)
4579 {
4580         if (camera == NULL || description == NULL) {
4581                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4582                 return CAMERA_ERROR_INVALID_PARAMETER;
4583         }
4584
4585         int ret = CAMERA_ERROR_NONE;
4586         camera_cli_s *pc = (camera_cli_s *)camera;
4587         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_TAG_IMAGE_DESCRIPTION;
4588         int sock_fd;
4589         if (pc->cb_info == NULL) {
4590                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4591                 return CAMERA_ERROR_INVALID_PARAMETER;
4592         }
4593         sock_fd = pc->cb_info->fd;
4594         char get_description[MUSE_CAMERA_MSG_MAX_LENGTH] = {0,};
4595
4596         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4597         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4598
4599         if (ret == CAMERA_ERROR_NONE) {
4600                 muse_camera_msg_get_string(get_description, pc->cb_info->recv_msg);
4601                 *description = strdup(get_description);
4602         }
4603         LOGD("ret : 0x%x", ret);
4604         return ret;
4605 }
4606
4607
4608 int camera_attr_get_tag_orientation(camera_h camera, camera_attr_tag_orientation_e *orientation)
4609 {
4610         if (camera == NULL || orientation == NULL) {
4611                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4612                 return CAMERA_ERROR_INVALID_PARAMETER;
4613         }
4614
4615         int ret = CAMERA_ERROR_NONE;
4616         camera_cli_s *pc = (camera_cli_s *)camera;
4617         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_TAG_ORIENTATION;
4618         int sock_fd;
4619         if (pc->cb_info == NULL) {
4620                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4621                 return CAMERA_ERROR_INVALID_PARAMETER;
4622         }
4623         sock_fd = pc->cb_info->fd;
4624         int get_orientation;
4625
4626         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4627         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4628
4629         if (ret == CAMERA_ERROR_NONE) {
4630                 muse_camera_msg_get(get_orientation, pc->cb_info->recv_msg);
4631                 *orientation = (camera_attr_tag_orientation_e)get_orientation;
4632                 LOGD("success, orientation : %d", *orientation);
4633         }
4634         LOGD("ret : 0x%x", ret);
4635         return ret;
4636 }
4637
4638
4639 int camera_attr_get_tag_software(camera_h camera, char **software)
4640 {
4641         if (camera == NULL || software == NULL) {
4642                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4643                 return CAMERA_ERROR_INVALID_PARAMETER;
4644         }
4645
4646         int ret = CAMERA_ERROR_NONE;
4647         camera_cli_s *pc = (camera_cli_s *)camera;
4648         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_TAG_SOFTWARE;
4649         int sock_fd;
4650         if (pc->cb_info == NULL) {
4651                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4652                 return CAMERA_ERROR_INVALID_PARAMETER;
4653         }
4654         sock_fd = pc->cb_info->fd;
4655         char get_software[MUSE_CAMERA_MSG_MAX_LENGTH] = {0,};
4656
4657         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4658         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4659
4660         if (ret == CAMERA_ERROR_NONE) {
4661                 muse_camera_msg_get_string(get_software, pc->cb_info->recv_msg);
4662                 *software = strdup(get_software);
4663         }
4664         LOGD("ret : 0x%x", ret);
4665         return ret;
4666 }
4667
4668
4669 int camera_attr_get_geotag(camera_h camera, double *latitude , double *longitude, double *altitude)
4670 {
4671         if (camera == NULL || latitude == NULL || longitude == NULL || altitude == NULL) {
4672                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4673                 return CAMERA_ERROR_INVALID_PARAMETER;
4674         }
4675
4676         int ret = CAMERA_ERROR_NONE;
4677         camera_cli_s *pc = (camera_cli_s *)camera;
4678         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_GEOTAG;
4679         double get_geotag[3] = {0,};
4680         int sock_fd;
4681         if (pc->cb_info == NULL) {
4682                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4683                 return CAMERA_ERROR_INVALID_PARAMETER;
4684         }
4685         sock_fd = pc->cb_info->fd;
4686         int valid = 0;
4687         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4688         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4689
4690         if (ret == CAMERA_ERROR_NONE) {
4691                 muse_camera_msg_get_array(get_geotag, pc->cb_info->recv_msg);
4692                 *latitude = get_geotag[0];
4693                 *longitude = get_geotag[1];
4694                 *altitude = get_geotag[2];
4695         } else {
4696                 LOGE("Returned value is not valid : 0x%x", valid);
4697         }
4698
4699         LOGD("ret : 0x%x", ret);
4700
4701         return ret;
4702 }
4703
4704
4705 int camera_attr_get_flash_mode(camera_h camera,  camera_attr_flash_mode_e *mode)
4706 {
4707         if (camera == NULL || mode == NULL) {
4708                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4709                 return CAMERA_ERROR_INVALID_PARAMETER;
4710         }
4711
4712         int ret = CAMERA_ERROR_NONE;
4713         camera_cli_s *pc = (camera_cli_s *)camera;
4714         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_FLASH_MODE;
4715         int sock_fd;
4716         if (pc->cb_info == NULL) {
4717                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4718                 return CAMERA_ERROR_INVALID_PARAMETER;
4719         }
4720         sock_fd = pc->cb_info->fd;
4721         int get_mode;
4722
4723         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4724         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4725
4726         if (ret == CAMERA_ERROR_NONE) {
4727                 muse_camera_msg_get(get_mode, pc->cb_info->recv_msg);
4728                 *mode = (camera_attr_flash_mode_e)get_mode;
4729         }
4730         LOGD("ret : 0x%x", ret);
4731         return ret;
4732 }
4733
4734
4735 int camera_attr_foreach_supported_af_mode(camera_h camera, camera_attr_supported_af_mode_cb foreach_cb, void *user_data)
4736 {
4737         if (camera == NULL || foreach_cb == NULL) {
4738                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4739                 return CAMERA_ERROR_INVALID_PARAMETER;
4740         }
4741         int ret = CAMERA_ERROR_NONE;
4742
4743         camera_cli_s *pc = (camera_cli_s *)camera;
4744         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_AF_MODE;
4745
4746         LOGD("Enter, handle :%x", pc->remote_handle);
4747
4748         int sock_fd;
4749         if (pc->cb_info == NULL) {
4750                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4751                 return CAMERA_ERROR_INVALID_PARAMETER;
4752         }
4753         sock_fd = pc->cb_info->fd;
4754         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_AF_MODE] = foreach_cb;
4755         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_AF_MODE] = user_data;
4756
4757         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4758         LOGD("ret : 0x%x", ret);
4759         return ret;
4760 }
4761
4762
4763 int camera_attr_foreach_supported_exposure_mode(camera_h camera, camera_attr_supported_exposure_mode_cb foreach_cb , void *user_data)
4764 {
4765         if (camera == NULL || foreach_cb == NULL) {
4766                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4767                 return CAMERA_ERROR_INVALID_PARAMETER;
4768         }
4769         int ret = CAMERA_ERROR_NONE;
4770
4771         camera_cli_s *pc = (camera_cli_s *)camera;
4772         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_EXPOSURE_MODE;
4773
4774         LOGD("Enter, handle :%x", pc->remote_handle);
4775
4776         int sock_fd;
4777         if (pc->cb_info == NULL) {
4778                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4779                 return CAMERA_ERROR_INVALID_PARAMETER;
4780         }
4781         sock_fd = pc->cb_info->fd;
4782         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EXPOSURE_MODE] = foreach_cb;
4783         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EXPOSURE_MODE] = user_data;
4784
4785         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4786         LOGD("ret : 0x%x", ret);
4787         return ret;
4788 }
4789
4790
4791 int camera_attr_foreach_supported_iso(camera_h camera, camera_attr_supported_iso_cb foreach_cb, void *user_data)
4792 {
4793         if (camera == NULL || foreach_cb == NULL) {
4794                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4795                 return CAMERA_ERROR_INVALID_PARAMETER;
4796         }
4797         int ret = CAMERA_ERROR_NONE;
4798
4799         camera_cli_s *pc = (camera_cli_s *)camera;
4800         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_ISO;
4801
4802         LOGD("Enter, handle :%x", pc->remote_handle);
4803
4804         int sock_fd;
4805         if (pc->cb_info == NULL) {
4806                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4807                 return CAMERA_ERROR_INVALID_PARAMETER;
4808         }
4809         sock_fd = pc->cb_info->fd;
4810         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_ISO] = foreach_cb;
4811         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_ISO] = user_data;
4812
4813         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4814         LOGD("ret : 0x%x", ret);
4815         return ret;
4816 }
4817
4818
4819 int camera_attr_foreach_supported_whitebalance(camera_h camera, camera_attr_supported_whitebalance_cb foreach_cb , void *user_data)
4820 {
4821         if (camera == NULL || foreach_cb == NULL) {
4822                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4823                 return CAMERA_ERROR_INVALID_PARAMETER;
4824         }
4825         int ret = CAMERA_ERROR_NONE;
4826
4827         camera_cli_s *pc = (camera_cli_s *)camera;
4828         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_WHITEBALANCE;
4829
4830         LOGD("Enter, handle :%x", pc->remote_handle);
4831
4832         int sock_fd;
4833         if (pc->cb_info == NULL) {
4834                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4835                 return CAMERA_ERROR_INVALID_PARAMETER;
4836         }
4837         sock_fd = pc->cb_info->fd;
4838         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_WHITEBALANCE] = foreach_cb;
4839         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_WHITEBALANCE] = user_data;
4840
4841         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4842         LOGD("ret : 0x%x", ret);
4843         return ret;
4844 }
4845
4846
4847 int camera_attr_foreach_supported_effect(camera_h camera, camera_attr_supported_effect_cb foreach_cb , void *user_data)
4848 {
4849         if (camera == NULL || foreach_cb == NULL) {
4850                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4851                 return CAMERA_ERROR_INVALID_PARAMETER;
4852         }
4853         int ret = CAMERA_ERROR_NONE;
4854
4855         camera_cli_s *pc = (camera_cli_s *)camera;
4856         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_EFFECT;
4857
4858         LOGD("Enter, handle :%x", pc->remote_handle);
4859
4860         int sock_fd;
4861         if (pc->cb_info == NULL) {
4862                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4863                 return CAMERA_ERROR_INVALID_PARAMETER;
4864         }
4865         sock_fd = pc->cb_info->fd;
4866         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EFFECT] = foreach_cb;
4867         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EFFECT] = user_data;
4868
4869         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4870         LOGD("ret : 0x%x", ret);
4871         return ret;
4872 }
4873
4874
4875 int camera_attr_foreach_supported_scene_mode(camera_h camera, camera_attr_supported_scene_mode_cb foreach_cb , void *user_data)
4876 {
4877         if (camera == NULL || foreach_cb == NULL) {
4878                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4879                 return CAMERA_ERROR_INVALID_PARAMETER;
4880         }
4881         int ret = CAMERA_ERROR_NONE;
4882
4883         camera_cli_s *pc = (camera_cli_s *)camera;
4884         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_SCENE_MODE;
4885
4886         LOGD("Enter, handle :%x", pc->remote_handle);
4887
4888         int sock_fd;
4889         if (pc->cb_info == NULL) {
4890                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4891                 return CAMERA_ERROR_INVALID_PARAMETER;
4892         }
4893         sock_fd = pc->cb_info->fd;
4894         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_SCENE_MODE] = foreach_cb;
4895         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_SCENE_MODE] = user_data;
4896
4897         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4898         LOGD("ret : 0x%x", ret);
4899         return ret;
4900 }
4901
4902
4903 int camera_attr_foreach_supported_flash_mode(camera_h camera, camera_attr_supported_flash_mode_cb foreach_cb , void *user_data)
4904 {
4905         if (camera == NULL || foreach_cb == NULL) {
4906                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4907                 return CAMERA_ERROR_INVALID_PARAMETER;
4908         }
4909         int ret = CAMERA_ERROR_NONE;
4910
4911         camera_cli_s *pc = (camera_cli_s *)camera;
4912         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_FLASH_MODE;
4913
4914         LOGD("Enter, handle :%x", pc->remote_handle);
4915
4916         int sock_fd;
4917         if (pc->cb_info == NULL) {
4918                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4919                 return CAMERA_ERROR_INVALID_PARAMETER;
4920         }
4921         sock_fd = pc->cb_info->fd;
4922         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FLASH_MODE] = foreach_cb;
4923         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FLASH_MODE] = user_data;
4924
4925         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4926         LOGD("ret : 0x%x", ret);
4927         return ret;
4928 }
4929
4930
4931 int camera_attr_foreach_supported_fps(camera_h camera, camera_attr_supported_fps_cb foreach_cb , void *user_data)
4932 {
4933         if (camera == NULL || foreach_cb == NULL) {
4934                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4935                 return CAMERA_ERROR_INVALID_PARAMETER;
4936         }
4937         int ret = CAMERA_ERROR_NONE;
4938
4939         camera_cli_s *pc = (camera_cli_s *)camera;
4940         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_FPS;
4941         int sock_fd;
4942         if (pc->cb_info == NULL) {
4943                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4944                 return CAMERA_ERROR_INVALID_PARAMETER;
4945         }
4946         sock_fd = pc->cb_info->fd;
4947         LOGD("Enter, handle :%x", pc->remote_handle);
4948         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS] = foreach_cb;
4949         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS] = user_data;
4950
4951         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4952         LOGD("Enter, handle :%x", pc->remote_handle);
4953         return ret;
4954 }
4955
4956 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)
4957 {
4958         if (camera == NULL || foreach_cb == NULL) {
4959                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4960                 return CAMERA_ERROR_INVALID_PARAMETER;
4961         }
4962         int ret = CAMERA_ERROR_NONE;
4963
4964         camera_cli_s *pc = (camera_cli_s *)camera;
4965         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_FPS_BY_RESOLUTION;
4966         int sock_fd;
4967         if (pc->cb_info == NULL) {
4968                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4969                 return CAMERA_ERROR_INVALID_PARAMETER;
4970         }
4971         sock_fd = pc->cb_info->fd;
4972         LOGD("Enter, handle :%x", pc->remote_handle);
4973         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS_BY_RESOLUTION] = foreach_cb;
4974         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS_BY_RESOLUTION] = user_data;
4975
4976         muse_camera_msg_send2(api, sock_fd, pc->cb_info, ret, INT, width, INT, height);
4977         LOGD("ret : 0x%x", ret);
4978         return ret;
4979 }
4980
4981 int camera_attr_foreach_supported_stream_flip(camera_h camera, camera_attr_supported_stream_flip_cb foreach_cb, void *user_data)
4982 {
4983         if (camera == NULL || foreach_cb == NULL) {
4984                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4985                 return CAMERA_ERROR_INVALID_PARAMETER;
4986         }
4987         int ret = CAMERA_ERROR_NONE;
4988
4989         camera_cli_s *pc = (camera_cli_s *)camera;
4990         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_STREAM_FLIP;
4991         int sock_fd;
4992         if (pc->cb_info == NULL) {
4993                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4994                 return CAMERA_ERROR_INVALID_PARAMETER;
4995         }
4996         sock_fd = pc->cb_info->fd;
4997         LOGD("Enter, handle :%x", pc->remote_handle);
4998         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_FLIP] = foreach_cb;
4999         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_FLIP] = user_data;
5000
5001         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
5002         LOGD("ret : 0x%x", ret);
5003         return ret;
5004 }
5005
5006
5007 int camera_attr_foreach_supported_stream_rotation(camera_h camera, camera_attr_supported_stream_rotation_cb foreach_cb, void *user_data)
5008 {
5009         if (camera == NULL || foreach_cb == NULL) {
5010                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5011                 return CAMERA_ERROR_INVALID_PARAMETER;
5012         }
5013         int ret = CAMERA_ERROR_NONE;
5014
5015         camera_cli_s *pc = (camera_cli_s *)camera;
5016         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_STREAM_ROTATION;
5017         int sock_fd;
5018         if (pc->cb_info == NULL) {
5019                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5020                 return CAMERA_ERROR_INVALID_PARAMETER;
5021         }
5022         sock_fd = pc->cb_info->fd;
5023         LOGD("Enter, handle :%x", pc->remote_handle);
5024         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_ROTATION] = foreach_cb;
5025         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_ROTATION] = user_data;
5026
5027         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
5028         LOGD("ret : 0x%x", ret);
5029         return ret;
5030 }
5031
5032
5033 int camera_attr_set_stream_rotation(camera_h camera , camera_rotation_e rotation)
5034 {
5035         if (camera == NULL) {
5036                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5037                 return CAMERA_ERROR_INVALID_PARAMETER;
5038         }
5039
5040         int ret = CAMERA_ERROR_NONE;
5041         camera_cli_s *pc = (camera_cli_s *)camera;
5042         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_STREAM_ROTATION;
5043         int sock_fd;
5044         if (pc->cb_info == NULL) {
5045                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5046                 return CAMERA_ERROR_INVALID_PARAMETER;
5047         }
5048         sock_fd = pc->cb_info->fd;
5049         int set_rotation = (int)rotation;
5050
5051         LOGD("Enter, remote_handle : %x", pc->remote_handle);
5052         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_rotation);
5053         LOGD("ret : 0x%x", ret);
5054         return ret;
5055 }
5056
5057
5058 int camera_attr_get_stream_rotation(camera_h camera , camera_rotation_e *rotation)
5059 {
5060         if (camera == NULL || rotation == NULL) {
5061                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5062                 return CAMERA_ERROR_INVALID_PARAMETER;
5063         }
5064
5065         int ret = CAMERA_ERROR_NONE;
5066         camera_cli_s *pc = (camera_cli_s *)camera;
5067         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_STREAM_ROTATION;
5068         int sock_fd;
5069         if (pc->cb_info == NULL) {
5070                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5071                 return CAMERA_ERROR_INVALID_PARAMETER;
5072         }
5073         sock_fd = pc->cb_info->fd;
5074         int get_rotation;
5075
5076         LOGD("Enter, remote_handle : %x", pc->remote_handle);
5077         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
5078
5079         if (ret == CAMERA_ERROR_NONE) {
5080                 muse_camera_msg_get(get_rotation, pc->cb_info->recv_msg);
5081                 *rotation = (camera_rotation_e)get_rotation;
5082         }
5083         LOGD("ret : 0x%x", ret);
5084         return ret;
5085 }
5086
5087
5088 int camera_attr_set_stream_flip(camera_h camera , camera_flip_e flip)
5089 {
5090         if (camera == NULL) {
5091                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5092                 return CAMERA_ERROR_INVALID_PARAMETER;
5093         }
5094
5095         int ret = CAMERA_ERROR_NONE;
5096         camera_cli_s *pc = (camera_cli_s *)camera;
5097         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_STREAM_FLIP;
5098         int sock_fd;
5099         if (pc->cb_info == NULL) {
5100                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5101                 return CAMERA_ERROR_INVALID_PARAMETER;
5102         }
5103         sock_fd = pc->cb_info->fd;
5104         int set_flip = (int)flip;
5105
5106         LOGD("Enter, remote_handle : %x", pc->remote_handle);
5107         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_flip);
5108         LOGD("ret : 0x%x", ret);
5109         return ret;
5110 }
5111
5112
5113 int camera_attr_get_stream_flip(camera_h camera , camera_flip_e *flip)
5114 {
5115         if (camera == NULL || flip == NULL) {
5116                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5117                 return CAMERA_ERROR_INVALID_PARAMETER;
5118         }
5119
5120         int ret = CAMERA_ERROR_NONE;
5121         camera_cli_s *pc = (camera_cli_s *)camera;
5122         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_STREAM_FLIP;
5123         int sock_fd;
5124         if (pc->cb_info == NULL) {
5125                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5126                 return CAMERA_ERROR_INVALID_PARAMETER;
5127         }
5128         sock_fd = pc->cb_info->fd;
5129         int get_flip;
5130
5131         LOGD("Enter, remote_handle : %x", pc->remote_handle);
5132         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
5133
5134         if (ret == CAMERA_ERROR_NONE) {
5135                 muse_camera_msg_get(get_flip, pc->cb_info->recv_msg);
5136                 *flip = (camera_flip_e)get_flip;
5137         }
5138         LOGD("ret : 0x%x", ret);
5139         return ret;
5140 }
5141
5142 int camera_attr_set_hdr_mode(camera_h camera, camera_attr_hdr_mode_e mode)
5143 {
5144         if (camera == NULL) {
5145                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5146                 return CAMERA_ERROR_INVALID_PARAMETER;
5147         }
5148
5149         int ret = CAMERA_ERROR_NONE;
5150         camera_cli_s *pc = (camera_cli_s *)camera;
5151         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_HDR_MODE;
5152         int sock_fd;
5153         if (pc->cb_info == NULL) {
5154                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5155                 return CAMERA_ERROR_INVALID_PARAMETER;
5156         }
5157         sock_fd = pc->cb_info->fd;
5158         int set_mode = (int)mode;
5159
5160         LOGD("Enter, remote_handle : %x", pc->remote_handle);
5161         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_mode);
5162         LOGD("ret : 0x%x", ret);
5163         return ret;
5164 }
5165
5166
5167 int camera_attr_get_hdr_mode(camera_h camera, camera_attr_hdr_mode_e *mode)
5168 {
5169         if (camera == NULL) {
5170                 LOGE("INVALID_PARAMETER(0x%08x) - handle", CAMERA_ERROR_INVALID_PARAMETER);
5171                 return CAMERA_ERROR_INVALID_PARAMETER;
5172         }
5173         if (mode == NULL) {
5174                 LOGE("CAMERA_ERROR_NOT_SUPPORTED(0x%08x) - mode", CAMERA_ERROR_NOT_SUPPORTED);
5175                 return CAMERA_ERROR_NOT_SUPPORTED;
5176         }
5177         int ret = CAMERA_ERROR_NONE;
5178         camera_cli_s *pc = (camera_cli_s *)camera;
5179         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_HDR_MODE;
5180         int sock_fd;
5181         if (pc->cb_info == NULL) {
5182                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5183                 return CAMERA_ERROR_INVALID_PARAMETER;
5184         }
5185         sock_fd = pc->cb_info->fd;
5186         int get_mode;
5187
5188         LOGD("Enter, remote_handle : %x", pc->remote_handle);
5189         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
5190
5191         if (ret == CAMERA_ERROR_NONE) {
5192                 muse_camera_msg_get(get_mode, pc->cb_info->recv_msg);
5193                 *mode = (camera_attr_hdr_mode_e)get_mode;
5194         }
5195         LOGD("ret : 0x%x", ret);
5196         return ret;
5197 }
5198
5199
5200 bool camera_attr_is_supported_hdr_capture(camera_h camera)
5201 {
5202         if (camera == NULL) {
5203                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5204                 return false;
5205         }
5206
5207         int ret = CAMERA_ERROR_NONE;
5208         camera_cli_s *pc = (camera_cli_s *)camera;
5209         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_SUPPORTED_HDR_CAPTURE;
5210         int sock_fd;
5211         if (pc->cb_info == NULL) {
5212                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5213                 return CAMERA_ERROR_INVALID_PARAMETER;
5214         }
5215         sock_fd = pc->cb_info->fd;
5216         LOGD("Enter, remote_handle : %x", pc->remote_handle);
5217         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
5218         LOGD("ret : 0x%x", ret);
5219         return (bool)ret;
5220 }
5221
5222
5223 int camera_attr_set_hdr_capture_progress_cb(camera_h camera, camera_attr_hdr_progress_cb callback, void* user_data)
5224 {
5225         if (camera == NULL) {
5226                 LOGE("INVALID_PARAMETER(0x%08x) - handle", CAMERA_ERROR_INVALID_PARAMETER);
5227                 return CAMERA_ERROR_INVALID_PARAMETER;
5228         }
5229         if (callback == NULL) {
5230                 LOGE("CAMERA_ERROR_NOT_SUPPORTED(0x%08x) - callback", CAMERA_ERROR_NOT_SUPPORTED);
5231                 return CAMERA_ERROR_NOT_SUPPORTED;
5232         }
5233         int ret = CAMERA_ERROR_NONE;
5234
5235         camera_cli_s *pc = (camera_cli_s *)camera;
5236         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_HDR_CAPTURE_PROGRESS_CB;
5237         int sock_fd;
5238         if (pc->cb_info == NULL) {
5239                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5240                 return CAMERA_ERROR_INVALID_PARAMETER;
5241         }
5242         sock_fd = pc->cb_info->fd;
5243         LOGD("Enter, handle :%x", pc->remote_handle);
5244
5245         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_HDR_PROGRESS] = callback;
5246         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_HDR_PROGRESS] = user_data;
5247
5248         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
5249         LOGD("ret : 0x%x", ret);
5250         return ret;
5251 }
5252
5253
5254 int camera_attr_unset_hdr_capture_progress_cb(camera_h camera)
5255 {
5256         if (camera == NULL) {
5257                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5258                 return CAMERA_ERROR_INVALID_PARAMETER;
5259         }
5260
5261         int ret = CAMERA_ERROR_NONE;
5262
5263         camera_cli_s *pc = (camera_cli_s *)camera;
5264         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_UNSET_HDR_CAPTURE_PROGRESS_CB;
5265         int sock_fd;
5266         if (pc->cb_info == NULL) {
5267                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5268                 return CAMERA_ERROR_INVALID_PARAMETER;
5269         }
5270         sock_fd = pc->cb_info->fd;
5271         LOGD("Enter, handle :%x", pc->remote_handle);
5272
5273         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_HDR_PROGRESS] = (void *)NULL;
5274         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_HDR_PROGRESS] = (void *)NULL;
5275
5276         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
5277         LOGD("ret : 0x%x", ret);
5278         return ret;
5279 }
5280
5281
5282 int camera_attr_enable_anti_shake(camera_h camera, bool enable)
5283 {
5284         if (camera == NULL) {
5285                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5286                 return CAMERA_ERROR_INVALID_PARAMETER;
5287         }
5288
5289         int ret = CAMERA_ERROR_NONE;
5290         camera_cli_s *pc = (camera_cli_s *)camera;
5291         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_ENABLE_ANTI_SHAKE;
5292         int sock_fd;
5293         if (pc->cb_info == NULL) {
5294                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5295                 return CAMERA_ERROR_INVALID_PARAMETER;
5296         }
5297         sock_fd = pc->cb_info->fd;
5298         int set_enable = (int)enable;
5299
5300         LOGD("Enter, remote_handle : %x", pc->remote_handle);
5301         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_enable);
5302         LOGD("ret : 0x%x", ret);
5303         return ret;
5304 }
5305
5306
5307 int camera_attr_is_enabled_anti_shake(camera_h camera , bool *enabled)
5308 {
5309         if (camera == NULL) {
5310                 LOGE("INVALID_PARAMETER(0x%08x) - handle", CAMERA_ERROR_INVALID_PARAMETER);
5311                 return CAMERA_ERROR_INVALID_PARAMETER;
5312         }
5313         if (enabled == NULL) {
5314                 LOGE("INVALID_PARAMETER(0x%08x) - enabled", CAMERA_ERROR_INVALID_PARAMETER);
5315                 return CAMERA_ERROR_NOT_SUPPORTED;
5316         }
5317         int ret = CAMERA_ERROR_NONE;
5318         camera_cli_s *pc = (camera_cli_s *)camera;
5319         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_ENABLED_ANTI_SHAKE;
5320         int sock_fd;
5321         if (pc->cb_info == NULL) {
5322                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5323                 return CAMERA_ERROR_INVALID_PARAMETER;
5324         }
5325         sock_fd = pc->cb_info->fd;
5326         int get_enabled;
5327
5328         LOGD("Enter, remote_handle : %x", pc->remote_handle);
5329         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
5330
5331         if (ret == CAMERA_ERROR_NONE) {
5332                 muse_camera_msg_get(get_enabled, pc->cb_info->recv_msg);
5333                 *enabled = (bool)get_enabled;
5334         }
5335         LOGD("ret : 0x%x", ret);
5336         return ret;
5337 }
5338
5339
5340 bool camera_attr_is_supported_anti_shake(camera_h camera)
5341 {
5342
5343         if (camera == NULL) {
5344                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5345                 return false;
5346         }
5347
5348         int ret = CAMERA_ERROR_NONE;
5349         camera_cli_s *pc = (camera_cli_s *)camera;
5350         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_SUPPORTED_ANTI_SHAKE;
5351         int sock_fd;
5352         if (pc->cb_info == NULL) {
5353                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5354                 return CAMERA_ERROR_INVALID_PARAMETER;
5355         }
5356         sock_fd = pc->cb_info->fd;
5357         LOGD("Enter, remote_handle : %x", pc->remote_handle);
5358         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
5359         LOGD("ret : 0x%x", ret);
5360         return ret;
5361 }
5362
5363
5364 int camera_attr_enable_video_stabilization(camera_h camera, bool enable)
5365 {
5366         if (camera == NULL) {
5367                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5368                 return CAMERA_ERROR_INVALID_PARAMETER;
5369         }
5370
5371         int ret = CAMERA_ERROR_NONE;
5372         camera_cli_s *pc = (camera_cli_s *)camera;
5373         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_ENABLE_VIDEO_STABILIZATION;
5374         int sock_fd;
5375         if (pc->cb_info == NULL) {
5376                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5377                 return CAMERA_ERROR_INVALID_PARAMETER;
5378         }
5379         sock_fd = pc->cb_info->fd;
5380         int set_enable = (int)enable;
5381
5382         LOGD("Enter, remote_handle : %x", pc->remote_handle);
5383         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_enable);
5384         LOGD("ret : 0x%x", ret);
5385         return ret;
5386 }
5387
5388
5389 int camera_attr_is_enabled_video_stabilization(camera_h camera, bool *enabled)
5390 {
5391         if (camera == NULL) {
5392                 LOGE("INVALID_PARAMETER(0x%08x) - handle", CAMERA_ERROR_INVALID_PARAMETER);
5393                 return CAMERA_ERROR_INVALID_PARAMETER;
5394         }
5395         if (enabled == NULL) {
5396                 LOGE("INVALID_PARAMETER(0x%08x) - enabled", CAMERA_ERROR_INVALID_PARAMETER);
5397                 return CAMERA_ERROR_NOT_SUPPORTED;
5398         }
5399         int ret = CAMERA_ERROR_NONE;
5400         camera_cli_s *pc = (camera_cli_s *)camera;
5401         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_ENABLED_VIDEO_STABILIZATION;
5402         int sock_fd;
5403         if (pc->cb_info == NULL) {
5404                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5405                 return CAMERA_ERROR_INVALID_PARAMETER;
5406         }
5407         sock_fd = pc->cb_info->fd;
5408         int get_enabled;
5409
5410         LOGD("Enter, remote_handle : %x", pc->remote_handle);
5411         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
5412
5413         if (ret == CAMERA_ERROR_NONE) {
5414                 muse_camera_msg_get(get_enabled, pc->cb_info->recv_msg);
5415                 *enabled = (bool)get_enabled;
5416         }
5417         LOGD("ret : 0x%x", ret);
5418         return ret;
5419 }
5420
5421
5422 bool camera_attr_is_supported_video_stabilization(camera_h camera)
5423 {
5424         if (camera == NULL) {
5425                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5426                 return false;
5427         }
5428
5429         int ret = CAMERA_ERROR_NONE;
5430         camera_cli_s *pc = (camera_cli_s *)camera;
5431         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_SUPPORTED_VIDEO_STABILIZATION;
5432         int sock_fd;
5433         if (pc->cb_info == NULL) {
5434                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5435                 return CAMERA_ERROR_INVALID_PARAMETER;
5436         }
5437         sock_fd = pc->cb_info->fd;
5438         LOGD("Enter, remote_handle : %x", pc->remote_handle);
5439         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
5440         LOGD("ret : 0x%x", ret);
5441         return ret;
5442 }
5443
5444
5445 int camera_attr_enable_auto_contrast(camera_h camera, bool enable)
5446 {
5447         if (camera == NULL) {
5448                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5449                 return CAMERA_ERROR_INVALID_PARAMETER;
5450         }
5451
5452         int ret = CAMERA_ERROR_NONE;
5453         camera_cli_s *pc = (camera_cli_s *)camera;
5454         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_ENABLE_AUTO_CONTRAST;
5455         int sock_fd;
5456         if (pc->cb_info == NULL) {
5457                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5458                 return CAMERA_ERROR_INVALID_PARAMETER;
5459         }
5460         sock_fd = pc->cb_info->fd;
5461         int set_enable = (int)enable;
5462
5463         LOGD("Enter, remote_handle : %x", pc->remote_handle);
5464         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_enable);
5465         LOGD("ret : 0x%x", ret);
5466         return ret;
5467 }
5468
5469
5470 int camera_attr_is_enabled_auto_contrast(camera_h camera, bool *enabled)
5471 {
5472         if (camera == NULL) {
5473                 LOGE("INVALID_PARAMETER(0x%08x) - handle", CAMERA_ERROR_INVALID_PARAMETER);
5474                 return CAMERA_ERROR_INVALID_PARAMETER;
5475         }
5476         if (enabled == NULL) {
5477                 LOGE("INVALID_PARAMETER(0x%08x) - enabled", CAMERA_ERROR_INVALID_PARAMETER);
5478                 return CAMERA_ERROR_INVALID_PARAMETER;
5479         }
5480         int ret = CAMERA_ERROR_NONE;
5481         camera_cli_s *pc = (camera_cli_s *)camera;
5482         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_ENABLED_AUTO_CONTRAST;
5483         int sock_fd;
5484         if (pc->cb_info == NULL) {
5485                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5486                 return CAMERA_ERROR_INVALID_PARAMETER;
5487         }
5488         sock_fd = pc->cb_info->fd;
5489         int get_enabled;
5490
5491         LOGD("Enter, remote_handle : %x", pc->remote_handle);
5492         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
5493
5494         if (ret == CAMERA_ERROR_NONE) {
5495                 muse_camera_msg_get(get_enabled, pc->cb_info->recv_msg);
5496                 *enabled = (bool)get_enabled;
5497         }
5498         LOGD("ret : 0x%x", ret);
5499         return ret;
5500 }
5501
5502
5503 bool camera_attr_is_supported_auto_contrast(camera_h camera)
5504 {
5505         if (camera == NULL) {
5506                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5507                 return false;
5508         }
5509
5510         int ret = CAMERA_ERROR_NONE;
5511         camera_cli_s *pc = (camera_cli_s *)camera;
5512         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_SUPPORTED_AUTO_CONTRAST;
5513         int sock_fd;
5514         if (pc->cb_info == NULL) {
5515                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5516                 return CAMERA_ERROR_INVALID_PARAMETER;
5517         }
5518         sock_fd = pc->cb_info->fd;
5519         LOGD("Enter, remote_handle : %x", pc->remote_handle);
5520         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
5521         LOGD("ret : 0x%x", ret);
5522         return ret;
5523 }
5524
5525
5526 int camera_attr_disable_shutter_sound(camera_h camera, bool disable)
5527 {
5528         if (camera == NULL) {
5529                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5530                 return CAMERA_ERROR_INVALID_PARAMETER;
5531         }
5532
5533         int ret = CAMERA_ERROR_NONE;
5534         camera_cli_s *pc = (camera_cli_s *)camera;
5535         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_DISABLE_SHUTTER_SOUND;
5536         int sock_fd;
5537         if (pc->cb_info == NULL) {
5538                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5539                 return CAMERA_ERROR_INVALID_PARAMETER;
5540         }
5541         sock_fd = pc->cb_info->fd;
5542         int set_disable = (int)disable;
5543
5544         LOGD("Enter, remote_handle : %x", pc->remote_handle);
5545         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_disable);
5546         LOGD("ret : 0x%x", ret);
5547         return ret;
5548 }