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
1951                 g_free(pc->cb_info->caps);
1952                 pc->cb_info->caps = NULL;
1953
1954                 if (ret != MM_ERROR_NONE) {
1955                         LOGE("client realize failed 0x%x", ret);
1956                         goto _START_PREVIEW_ERROR;
1957                 }
1958         }
1959
1960         LOGD("ret : 0x%x", ret);
1961
1962         return CAMERA_ERROR_NONE;
1963
1964 _START_PREVIEW_ERROR:
1965         muse_camera_msg_send_longtime(MUSE_CAMERA_API_STOP_PREVIEW, sock_fd, pc->cb_info, ret);
1966
1967         return CAMERA_ERROR_INVALID_OPERATION;
1968 }
1969
1970 int camera_stop_preview(camera_h camera)
1971 {
1972         if (camera == NULL) {
1973                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
1974                 return CAMERA_ERROR_INVALID_PARAMETER;
1975         }
1976         int ret = CAMERA_ERROR_NONE;
1977         camera_cli_s *pc = (camera_cli_s *)camera;
1978         int sock_fd;
1979         muse_camera_api_e api = MUSE_CAMERA_API_STOP_PREVIEW;
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         LOGD("Enter");
1988         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
1989
1990         if (ret != CAMERA_ERROR_NONE) {
1991                 LOGE("stop preview failed 0x%x", ret);
1992                 return ret;
1993         }
1994
1995         if (pc->client_handle != NULL) {
1996                 if (mm_camcorder_client_unrealize(pc->client_handle) == MM_ERROR_NONE) {
1997                         LOGD("client unrealize done");
1998                 } else {
1999                         LOGE("client unrealize failed. restart preview...");
2000                         muse_camera_msg_send_longtime(MUSE_CAMERA_API_START_PREVIEW, sock_fd, pc->cb_info, ret);
2001                         return CAMERA_ERROR_INVALID_OPERATION;
2002                 }
2003         } else {
2004                 LOGW("client handle is NULL");
2005         }
2006
2007         LOGD("ret : 0x%x", ret);
2008
2009         return ret;
2010 }
2011
2012 int camera_start_capture(camera_h camera, camera_capturing_cb capturing_cb, camera_capture_completed_cb completed_cb, void *user_data)
2013 {
2014         if (camera == NULL) {
2015                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2016                 return CAMERA_ERROR_INVALID_PARAMETER;
2017         }
2018         int ret = CAMERA_ERROR_NONE;
2019
2020         camera_cli_s *pc = (camera_cli_s *)camera;
2021         muse_camera_api_e api = MUSE_CAMERA_API_START_CAPTURE;
2022         int sock_fd;
2023         int is_capturing_cb = 0;
2024         int is_completed_cb = 0;
2025         LOGD("Enter, handle :%x", pc->remote_handle);
2026
2027         if (pc->cb_info == NULL) {
2028                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2029                 return CAMERA_ERROR_INVALID_PARAMETER;
2030         }
2031
2032         sock_fd = pc->cb_info->fd;
2033
2034         if (capturing_cb != NULL) {
2035                 is_capturing_cb = 1;
2036                 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_CAPTURE] = capturing_cb;
2037                 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_CAPTURE] = user_data;
2038         }
2039
2040         if (completed_cb != NULL) {
2041                 is_completed_cb = 1;
2042                 pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = completed_cb;
2043                 pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = user_data;
2044         }
2045
2046         muse_camera_msg_send2(api, sock_fd, pc->cb_info, ret, INT, is_capturing_cb, INT, is_completed_cb);
2047         LOGD("is_capturing_cb :%d, is_completed_cb : %d", is_capturing_cb, is_completed_cb);
2048         LOGD("ret : 0x%x", ret);
2049         return ret;
2050 }
2051
2052 bool camera_is_supported_continuous_capture(camera_h camera)
2053 {
2054         if (camera == NULL) {
2055                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2056                 return false;
2057         }
2058
2059         int ret = CAMERA_ERROR_NONE;
2060         camera_cli_s *pc = (camera_cli_s *)camera;
2061         muse_camera_api_e api = MUSE_CAMERA_API_SUPPORT_CONTINUOUS_CAPTURE;
2062         int sock_fd;
2063
2064         if (pc->cb_info == NULL) {
2065                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2066                 return CAMERA_ERROR_INVALID_PARAMETER;
2067         }
2068
2069         sock_fd = pc->cb_info->fd;
2070
2071         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2072         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2073         LOGD("ret : 0x%x", ret);
2074         return (bool)ret;
2075 }
2076
2077 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)
2078 {
2079         if (camera == NULL) {
2080                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2081                 return CAMERA_ERROR_INVALID_PARAMETER;
2082         }
2083
2084         int ret = CAMERA_ERROR_NONE;
2085
2086         camera_cli_s *pc = (camera_cli_s *)camera;
2087         muse_camera_api_e api = MUSE_CAMERA_API_START_CONTINUOUS_CAPTURE;
2088
2089         LOGD("Enter, handle :%x", pc->remote_handle);
2090
2091         int sock_fd;
2092         if (pc->cb_info == NULL) {
2093                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2094                 return CAMERA_ERROR_INVALID_PARAMETER;
2095         }
2096         sock_fd = pc->cb_info->fd;
2097
2098         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_CAPTURE] = capturing_cb;
2099         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_CAPTURE] = user_data;
2100         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE] = completed_cb;
2101
2102         muse_camera_msg_send2(api, sock_fd, pc->cb_info, ret, INT, count, INT, interval);
2103
2104         LOGD("ret : 0x%x", ret);
2105
2106         return ret;
2107 }
2108
2109 int camera_stop_continuous_capture(camera_h camera)
2110 {
2111         if (camera == NULL) {
2112                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2113                 return CAMERA_ERROR_INVALID_PARAMETER;
2114         }
2115
2116
2117         int ret = CAMERA_ERROR_NONE;
2118
2119         camera_cli_s *pc = (camera_cli_s *)camera;
2120         muse_camera_api_e api = MUSE_CAMERA_API_STOP_CONTINUOUS_CAPTURE;
2121         LOGD("Enter,  handle :%x", pc->remote_handle);
2122         int sock_fd;
2123         if (pc->cb_info == NULL) {
2124                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2125                 return CAMERA_ERROR_INVALID_PARAMETER;
2126         }
2127         sock_fd = pc->cb_info->fd;
2128         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2129         LOGD("ret : 0x%x", ret);
2130         return ret;
2131 }
2132
2133 bool camera_is_supported_face_detection(camera_h camera)
2134 {
2135         if (camera == NULL) {
2136                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2137                 return false;
2138         }
2139         int ret = CAMERA_ERROR_NONE;
2140
2141         camera_cli_s *pc = (camera_cli_s *)camera;
2142         muse_camera_api_e api = MUSE_CAMERA_API_SUPPORT_FACE_DETECTION;
2143         int sock_fd;
2144         if (pc->cb_info == NULL) {
2145                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2146                 return CAMERA_ERROR_INVALID_PARAMETER;
2147         }
2148         sock_fd = pc->cb_info->fd;
2149
2150         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2151         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2152         LOGD("ret : 0x%x", ret);
2153         return (bool)ret;
2154 }
2155
2156 bool camera_is_supported_zero_shutter_lag(camera_h camera)
2157 {
2158         if (camera == NULL) {
2159                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2160                 return false;
2161         }
2162         int ret = CAMERA_ERROR_NONE;
2163
2164         camera_cli_s *pc = (camera_cli_s *)camera;
2165         muse_camera_api_e api = MUSE_CAMERA_API_SUPPORT_ZERO_SHUTTER_LAG;
2166         int sock_fd;
2167         if (pc->cb_info == NULL) {
2168                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2169                 return CAMERA_ERROR_INVALID_PARAMETER;
2170         }
2171         sock_fd = pc->cb_info->fd;
2172
2173         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2174         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2175         LOGD("ret : 0x%x", ret);
2176         return (bool)ret;
2177 }
2178
2179 bool camera_is_supported_media_packet_preview_cb(camera_h camera)
2180 {
2181         if (camera == NULL) {
2182                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2183                 return false;
2184         }
2185
2186         int ret = CAMERA_ERROR_NONE;
2187
2188         camera_cli_s *pc = (camera_cli_s *)camera;
2189         muse_camera_api_e api = MUSE_CAMERA_API_SUPPORT_MEDIA_PACKET_PREVIEW_CB;
2190         int sock_fd;
2191         if (pc->cb_info == NULL) {
2192                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2193                 return CAMERA_ERROR_INVALID_PARAMETER;
2194         }
2195         sock_fd = pc->cb_info->fd;
2196
2197         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2198         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2199         LOGD("ret : 0x%x", ret);
2200         return (bool)ret;
2201 }
2202
2203 int camera_get_device_count(camera_h camera, int *device_count)
2204 {
2205         if (camera == NULL || device_count == NULL) {
2206                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2207                 return CAMERA_ERROR_INVALID_PARAMETER;
2208         }
2209         int ret = CAMERA_ERROR_NONE;
2210
2211         camera_cli_s *pc = (camera_cli_s *)camera;
2212         muse_camera_api_e api = MUSE_CAMERA_API_GET_DEVICE_COUNT;
2213         int sock_fd;
2214         if (pc->cb_info == NULL) {
2215                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2216                 return CAMERA_ERROR_INVALID_PARAMETER;
2217         }
2218         sock_fd = pc->cb_info->fd;
2219         int get_device_count;
2220
2221         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2222         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2223
2224         if (ret == CAMERA_ERROR_NONE) {
2225                 muse_camera_msg_get(get_device_count, pc->cb_info->recv_msg);
2226                 *device_count = get_device_count;
2227         }
2228         LOGD("ret : 0x%x", ret);
2229         return ret;
2230 }
2231
2232 int camera_start_face_detection(camera_h camera, camera_face_detected_cb callback, void * user_data)
2233 {
2234         if (camera == NULL) {
2235                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2236                 return CAMERA_ERROR_INVALID_PARAMETER;
2237         }
2238
2239         int ret = CAMERA_ERROR_NONE;
2240
2241         camera_cli_s *pc = (camera_cli_s *)camera;
2242         muse_camera_api_e api = MUSE_CAMERA_API_START_FACE_DETECTION;
2243
2244         LOGD("Enter, handle :%x", pc->remote_handle);
2245         int sock_fd;
2246         if (pc->cb_info == NULL) {
2247                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2248                 return CAMERA_ERROR_INVALID_PARAMETER;
2249         }
2250         sock_fd = pc->cb_info->fd;
2251         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FACE_DETECTION] = callback;
2252         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FACE_DETECTION] = user_data;
2253
2254         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2255         LOGD("ret : 0x%x", ret);
2256         return ret;
2257 }
2258
2259 int camera_stop_face_detection(camera_h camera)
2260 {
2261         if (camera == NULL) {
2262                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2263                 return CAMERA_ERROR_INVALID_PARAMETER;
2264         }
2265
2266         int ret = CAMERA_ERROR_NONE;
2267
2268         camera_cli_s *pc = (camera_cli_s *)camera;
2269         muse_camera_api_e api = MUSE_CAMERA_API_STOP_FACE_DETECTION;
2270         LOGD("Enter,  handle :%x", pc->remote_handle);
2271         int sock_fd;
2272         if (pc->cb_info == NULL) {
2273                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2274                 return CAMERA_ERROR_INVALID_PARAMETER;
2275         }
2276         sock_fd = pc->cb_info->fd;
2277         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2278         LOGD("ret : 0x%x", ret);
2279         return ret;
2280 }
2281
2282 int camera_get_state(camera_h camera, camera_state_e * state)
2283 {
2284         if (camera == NULL || state == NULL) {
2285                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2286                 return CAMERA_ERROR_INVALID_PARAMETER;
2287         }
2288         int ret = CAMERA_ERROR_NONE;
2289
2290         camera_cli_s *pc = (camera_cli_s *)camera;
2291         muse_camera_api_e api = MUSE_CAMERA_API_GET_STATE;
2292         int sock_fd;
2293         if (pc->cb_info == NULL) {
2294                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2295                 return CAMERA_ERROR_INVALID_PARAMETER;
2296         }
2297         sock_fd = pc->cb_info->fd;
2298         int get_state;
2299
2300         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2301         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2302
2303         if (ret == CAMERA_ERROR_NONE) {
2304                 muse_camera_msg_get(get_state, pc->cb_info->recv_msg);
2305                 *state = (camera_state_e)get_state;
2306         }
2307         LOGD("ret : 0x%x", ret);
2308         return ret;
2309 }
2310
2311 int camera_start_focusing(camera_h camera, bool continuous)
2312 {
2313         if (camera == NULL) {
2314                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2315                 return CAMERA_ERROR_INVALID_PARAMETER;
2316         }
2317
2318         int ret = CAMERA_ERROR_NONE;
2319
2320         camera_cli_s *pc = (camera_cli_s *)camera;
2321         muse_camera_api_e api = MUSE_CAMERA_API_START_FOCUSING;
2322         int sock_fd;
2323         if (pc->cb_info == NULL) {
2324                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2325                 return CAMERA_ERROR_INVALID_PARAMETER;
2326         }
2327         sock_fd = pc->cb_info->fd;
2328         int is_continuous = (int)continuous;
2329
2330         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2331         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, is_continuous);
2332         LOGD("ret : 0x%x", ret);
2333         return ret;
2334 }
2335
2336 int camera_cancel_focusing(camera_h camera)
2337 {
2338         if (camera == NULL) {
2339                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2340                 return CAMERA_ERROR_INVALID_PARAMETER;
2341         }
2342
2343         int ret = CAMERA_ERROR_NONE;
2344
2345         camera_cli_s *pc = (camera_cli_s *)camera;
2346         muse_camera_api_e api = MUSE_CAMERA_API_CANCEL_FOCUSING;
2347         int sock_fd;
2348         if (pc->cb_info == NULL) {
2349                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2350                 return CAMERA_ERROR_INVALID_PARAMETER;
2351         }
2352         sock_fd = pc->cb_info->fd;
2353
2354         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2355         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2356         LOGD("ret : 0x%x", ret);
2357         return ret;
2358 }
2359
2360 int camera_set_display(camera_h camera, camera_display_type_e type, camera_display_h display)
2361 {
2362         int ret = CAMERA_ERROR_NONE;
2363         void *set_display_handle = NULL;
2364         int set_surface = MM_DISPLAY_SURFACE_X;
2365         Evas_Object *obj = NULL;
2366         const char *object_type = NULL;
2367         char socket_path[MUSE_CAMERA_MSG_MAX_LENGTH] = {0,};
2368 #ifdef HAVE_WAYLAND
2369         MMCamWaylandInfo *wl_info = NULL;
2370 #endif /* HAVE_WAYLAND */
2371
2372         if (camera == NULL) {
2373                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2374                 return CAMERA_ERROR_INVALID_PARAMETER;
2375         }
2376
2377         if (type != CAMERA_DISPLAY_TYPE_NONE && display == NULL) {
2378                 LOGE("display type[%d] is not NONE, but display handle is NULL", type);
2379                 return CAMERA_ERROR_INVALID_PARAMETER;
2380         }
2381
2382         camera_cli_s *pc = (camera_cli_s *)camera;
2383         muse_camera_api_e api = MUSE_CAMERA_API_SET_DISPLAY;
2384         int sock_fd;
2385         if (pc->cb_info == NULL) {
2386                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2387                 return CAMERA_ERROR_INVALID_PARAMETER;
2388         }
2389         sock_fd = pc->cb_info->fd;
2390
2391         LOGD("Enter, remote_handle : %x display : 0x%x", pc->remote_handle, display);
2392
2393         if (type == CAMERA_DISPLAY_TYPE_NONE) {
2394                 set_display_handle = 0;
2395                 set_surface = MM_DISPLAY_SURFACE_NULL;
2396                 LOGD("display type NONE");
2397         } else {
2398                 obj = (Evas_Object *)display;
2399                 object_type = evas_object_type_get(obj);
2400                 if (object_type) {
2401                         if (type == CAMERA_DISPLAY_TYPE_OVERLAY && !strcmp(object_type, "elm_win")) {
2402 #ifdef HAVE_WAYLAND
2403                                 /* set wayland info */
2404                                 wl_info = _get_wl_info(obj);
2405                                 if (wl_info == NULL) {
2406                                         LOGE("failed to get wl_info");
2407                                         return CAMERA_ERROR_INVALID_OPERATION;
2408                                 }
2409
2410                                 set_display_handle = (void *)wl_info;
2411 #else /* HAVE_WAYLAND */
2412                                 /* x window overlay surface */
2413                                 set_display_handle = (void *)elm_win_xwindow_get(obj);
2414 #endif
2415                                 set_surface = MM_DISPLAY_SURFACE_X;
2416                                 LOGD("display type OVERLAY : handle %p", set_display_handle);
2417                         } else if (type == CAMERA_DISPLAY_TYPE_EVAS && !strcmp(object_type, "image")) {
2418                                 /* evas object surface */
2419                                 set_display_handle = (void *)display;
2420                                 set_surface = MM_DISPLAY_SURFACE_EVAS;
2421                                 LOGD("display type EVAS : handle %p", set_display_handle);
2422                         } else {
2423                                 LOGE("unknown evas object [%p,%s] or type [%d] mismatch", obj, object_type, type);
2424                                 return CAMERA_ERROR_INVALID_PARAMETER;
2425                         }
2426                 } else {
2427                         LOGE("failed to get evas object type from %p", obj);
2428                         return CAMERA_ERROR_INVALID_PARAMETER;
2429                 }
2430         }
2431
2432         pc->display_handle = (intptr_t)set_display_handle;
2433
2434         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2435
2436         if (ret == CAMERA_ERROR_NONE) {
2437                 if (pc->client_handle == NULL) {
2438                         ret = mm_camcorder_client_create(&pc->client_handle);
2439                         if (ret != MM_ERROR_NONE) {
2440                                 LOGE("camera client create Failed 0x%x", ret);
2441                                 goto _SET_DISPLAY_ERROR;
2442                         }
2443                 }
2444
2445                 if (muse_camera_msg_get_string(socket_path, pc->cb_info->recv_msg) == FALSE) {
2446                         LOGE("failed to get socket path");
2447                         goto _SET_DISPLAY_ERROR;
2448                 }
2449
2450                 LOGD("socket path : %s", socket_path);
2451
2452                 ret = mm_camcorder_client_set_socket_path(pc->client_handle, socket_path);
2453                 if (ret != MM_ERROR_NONE) {
2454                         LOGE("failed to set socket path 0x%x", ret);
2455                         goto _SET_DISPLAY_ERROR;
2456                 }
2457
2458                 ret = mm_camcorder_set_attributes(pc->client_handle, NULL,
2459                         MMCAM_DISPLAY_SURFACE, set_surface,
2460                         NULL);
2461                 if (ret != MM_ERROR_NONE) {
2462                         LOGE("set display surface failed 0x%x", ret);
2463                         goto _SET_DISPLAY_ERROR;
2464                 }
2465
2466                 if (type != CAMERA_DISPLAY_TYPE_NONE) {
2467                         ret = mm_camcorder_set_attributes(pc->client_handle, NULL,
2468                                 MMCAM_DISPLAY_HANDLE, set_display_handle, sizeof(void *),
2469                                 NULL);
2470                         if (ret != MM_ERROR_NONE) {
2471                                 LOGE("set display handle failed 0x%x", ret);
2472                                 goto _SET_DISPLAY_ERROR;
2473                         }
2474                 }
2475
2476 #ifdef HAVE_WAYLAND
2477                 if (pc->wl_info) {
2478                         g_free(pc->wl_info);
2479                         pc->wl_info = NULL;
2480                 }
2481
2482                 pc->wl_info = wl_info;
2483 #endif /* HAVE_WAYLAND */
2484
2485                 return CAMERA_ERROR_NONE;;
2486         } else {
2487                 LOGE("set display error - 0x%x");
2488                 return ret;
2489         }
2490
2491 _SET_DISPLAY_ERROR:
2492 #ifdef HAVE_WAYLAND
2493         if (wl_info) {
2494                 g_free(wl_info);
2495                 wl_info = NULL;
2496         }
2497 #endif /* HAVE_WAYLAND */
2498
2499         return __convert_camera_error_code(__func__, ret);
2500 }
2501
2502 int camera_set_preview_resolution(camera_h camera,  int width, int height)
2503 {
2504         if (camera == NULL) {
2505                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2506                 return CAMERA_ERROR_INVALID_PARAMETER;
2507         }
2508         int ret = CAMERA_ERROR_NONE;
2509
2510         camera_cli_s *pc = (camera_cli_s *)camera;
2511         muse_camera_api_e api = MUSE_CAMERA_API_SET_PREVIEW_RESOLUTION;
2512         int sock_fd;
2513         if (pc->cb_info == NULL) {
2514                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2515                 return CAMERA_ERROR_INVALID_PARAMETER;
2516         }
2517         sock_fd = pc->cb_info->fd;
2518
2519         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2520         muse_camera_msg_send2(api, sock_fd, pc->cb_info, ret, INT, width, INT, height);
2521         LOGD("ret : 0x%x", ret);
2522         return ret;
2523 }
2524
2525
2526 int camera_set_capture_resolution(camera_h camera,  int width, int height)
2527 {
2528         if (camera == NULL) {
2529                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2530                 return CAMERA_ERROR_INVALID_PARAMETER;
2531         }
2532
2533         int ret = CAMERA_ERROR_NONE;
2534
2535         camera_cli_s *pc = (camera_cli_s *)camera;
2536         muse_camera_api_e api = MUSE_CAMERA_API_SET_CAPTURE_RESOLUTION;
2537         int sock_fd;
2538         if (pc->cb_info == NULL) {
2539                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2540                 return CAMERA_ERROR_INVALID_PARAMETER;
2541         }
2542         sock_fd = pc->cb_info->fd;
2543
2544         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2545         muse_camera_msg_send2(api, sock_fd, pc->cb_info, ret, INT, width, INT, height);
2546         LOGD("ret : 0x%x", ret);
2547         return ret;
2548 }
2549
2550 int camera_set_capture_format(camera_h camera, camera_pixel_format_e format)
2551 {
2552         if (camera == NULL) {
2553                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2554                 return CAMERA_ERROR_INVALID_PARAMETER;
2555         }
2556
2557         int ret = CAMERA_ERROR_NONE;
2558         int set_format = (int)format;
2559
2560         camera_cli_s *pc = (camera_cli_s *)camera;
2561         muse_camera_api_e api = MUSE_CAMERA_API_SET_CAPTURE_FORMAT;
2562         int sock_fd;
2563         if (pc->cb_info == NULL) {
2564                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2565                 return CAMERA_ERROR_INVALID_PARAMETER;
2566         }
2567         sock_fd = pc->cb_info->fd;
2568
2569         LOGD("Enter, remote_handle : %x, capture_format: %d", pc->remote_handle, set_format);
2570         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_format);
2571         LOGD("ret : 0x%x", ret);
2572         return ret;
2573 }
2574
2575 int camera_set_preview_format(camera_h camera, camera_pixel_format_e format)
2576 {
2577         if (camera == NULL) {
2578                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2579                 return CAMERA_ERROR_INVALID_PARAMETER;
2580         }
2581
2582         int ret = CAMERA_ERROR_NONE;
2583         int set_format = (int)format;
2584
2585         camera_cli_s *pc = (camera_cli_s *)camera;
2586         muse_camera_api_e api = MUSE_CAMERA_API_SET_PREVIEW_FORMAT;
2587         int sock_fd;
2588         if (pc->cb_info == NULL) {
2589                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2590                 return CAMERA_ERROR_INVALID_PARAMETER;
2591         }
2592         sock_fd = pc->cb_info->fd;
2593
2594         LOGD("Enter, remote_handle : %x, capture_format: %d", pc->remote_handle, set_format);
2595         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_format);
2596         LOGD("ret : 0x%x", ret);
2597         return ret;
2598 }
2599
2600 int camera_get_preview_resolution(camera_h camera,  int *width, int *height)
2601 {
2602         if (camera == NULL || width == NULL || height == NULL) {
2603                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2604                 return CAMERA_ERROR_INVALID_PARAMETER;
2605         }
2606
2607
2608         int ret = CAMERA_ERROR_NONE;
2609
2610         camera_cli_s *pc = (camera_cli_s *)camera;
2611         muse_camera_api_e api = MUSE_CAMERA_API_GET_PREVIEW_RESOLUTION;
2612         int sock_fd;
2613         if (pc->cb_info == NULL) {
2614                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2615                 return CAMERA_ERROR_INVALID_PARAMETER;
2616         }
2617         sock_fd = pc->cb_info->fd;
2618         int get_width;
2619         int get_height;
2620
2621         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2622         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2623
2624         if (ret == CAMERA_ERROR_NONE) {
2625                 muse_camera_msg_get(get_width, pc->cb_info->recv_msg);
2626                 muse_camera_msg_get(get_height, pc->cb_info->recv_msg);
2627                 *width = get_width;
2628                 *height = get_height;
2629         }
2630         LOGD("ret : 0x%x", ret);
2631         return ret;
2632 }
2633
2634 int camera_set_display_rotation(camera_h camera, camera_rotation_e rotation)
2635 {
2636         if (camera == NULL) {
2637                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2638                 return CAMERA_ERROR_INVALID_PARAMETER;
2639         }
2640
2641         int ret = CAMERA_ERROR_NONE;
2642         camera_cli_s *pc = (camera_cli_s *)camera;
2643         muse_camera_api_e api = MUSE_CAMERA_API_SET_DISPLAY_ROTATION;
2644         int sock_fd;
2645         if (pc->cb_info == NULL) {
2646                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2647                 return CAMERA_ERROR_INVALID_PARAMETER;
2648         }
2649         sock_fd = pc->cb_info->fd;
2650         int set_rotation = (int)rotation;
2651
2652         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2653         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_rotation);
2654         LOGD("ret : 0x%x", ret);
2655         return ret;
2656 }
2657
2658 int camera_get_display_rotation(camera_h camera, camera_rotation_e *rotation)
2659 {
2660         if (camera == NULL || rotation == NULL) {
2661                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2662                 return CAMERA_ERROR_INVALID_PARAMETER;
2663         }
2664
2665         int ret = CAMERA_ERROR_NONE;
2666
2667         camera_cli_s *pc = (camera_cli_s *)camera;
2668         muse_camera_api_e api = MUSE_CAMERA_API_GET_DISPLAY_ROTATION;
2669         int sock_fd;
2670         if (pc->cb_info == NULL) {
2671                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2672                 return CAMERA_ERROR_INVALID_PARAMETER;
2673         }
2674         sock_fd = pc->cb_info->fd;
2675         int get_rotation;
2676
2677         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2678         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2679
2680         if (ret == CAMERA_ERROR_NONE) {
2681                 muse_camera_msg_get(get_rotation, pc->cb_info->recv_msg);
2682                 *rotation = (camera_rotation_e)get_rotation;
2683         }
2684         LOGD("ret : 0x%x", ret);
2685         return ret;
2686 }
2687
2688 int camera_set_display_flip(camera_h camera, camera_flip_e flip)
2689 {
2690         if (camera == NULL) {
2691                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2692                 return CAMERA_ERROR_INVALID_PARAMETER;
2693         }
2694
2695         int ret = CAMERA_ERROR_NONE;
2696
2697         camera_cli_s *pc = (camera_cli_s *)camera;
2698         muse_camera_api_e api = MUSE_CAMERA_API_SET_DISPLAY_FLIP;
2699         int sock_fd;
2700         if (pc->cb_info == NULL) {
2701                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2702                 return CAMERA_ERROR_INVALID_PARAMETER;
2703         }
2704         sock_fd = pc->cb_info->fd;
2705         int set_flip = (int)flip;
2706
2707         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2708         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_flip);
2709         LOGD("ret : 0x%x", ret);
2710         return ret;
2711 }
2712
2713 int camera_get_display_flip(camera_h camera, camera_flip_e *flip)
2714 {
2715         if (camera == NULL || flip == NULL) {
2716                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2717                 return CAMERA_ERROR_INVALID_PARAMETER;
2718         }
2719
2720         int ret = CAMERA_ERROR_NONE;
2721
2722         camera_cli_s *pc = (camera_cli_s *)camera;
2723         muse_camera_api_e api = MUSE_CAMERA_API_GET_DISPLAY_FLIP;
2724         int sock_fd;
2725         if (pc->cb_info == NULL) {
2726                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2727                 return CAMERA_ERROR_INVALID_PARAMETER;
2728         }
2729         sock_fd = pc->cb_info->fd;
2730         int get_flip;
2731
2732         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2733         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2734
2735         if (ret == CAMERA_ERROR_NONE) {
2736                 muse_camera_msg_get(get_flip, pc->cb_info->recv_msg);
2737                 *flip = (camera_flip_e)get_flip;
2738         }
2739         LOGD("ret : 0x%x", ret);
2740         return ret;
2741 }
2742
2743 int camera_set_display_visible(camera_h camera, bool visible)
2744 {
2745         if (camera == NULL) {
2746                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2747                 return CAMERA_ERROR_INVALID_PARAMETER;
2748         }
2749
2750         int ret = CAMERA_ERROR_NONE;
2751
2752         camera_cli_s *pc = (camera_cli_s *)camera;
2753         muse_camera_api_e api = MUSE_CAMERA_API_SET_DISPLAY_VISIBLE;
2754         int set_visible = (int)visible;
2755         int sock_fd;
2756         if (pc->cb_info == NULL) {
2757                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2758                 return CAMERA_ERROR_INVALID_PARAMETER;
2759         }
2760         sock_fd = pc->cb_info->fd;
2761
2762         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2763         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_visible);
2764         LOGD("ret : 0x%x", ret);
2765         return ret;
2766 }
2767
2768 int camera_is_display_visible(camera_h camera, bool* visible)
2769 {
2770         if (camera == NULL || visible == NULL) {
2771                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2772                 return CAMERA_ERROR_INVALID_PARAMETER;
2773         }
2774
2775         int ret = CAMERA_ERROR_NONE;
2776
2777         camera_cli_s *pc = (camera_cli_s *)camera;
2778         muse_camera_api_e api = MUSE_CAMERA_API_IS_DISPLAY_VISIBLE;
2779         int sock_fd;
2780         if (pc->cb_info == NULL) {
2781                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2782                 return CAMERA_ERROR_INVALID_PARAMETER;
2783         }
2784         sock_fd = pc->cb_info->fd;
2785         int get_visible;
2786
2787         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2788         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2789
2790         if (ret == CAMERA_ERROR_NONE) {
2791                 muse_camera_msg_get(get_visible, pc->cb_info->recv_msg);
2792                 *visible = (bool)get_visible;
2793         }
2794         LOGD("ret : 0x%x", ret);
2795         return ret;
2796 }
2797
2798 int camera_set_display_mode(camera_h camera, camera_display_mode_e mode)
2799 {
2800         if (camera == NULL) {
2801                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2802                 return CAMERA_ERROR_INVALID_PARAMETER;
2803         }
2804
2805         int ret = CAMERA_ERROR_NONE;
2806         int set_mode = (int)mode;
2807
2808         camera_cli_s *pc = (camera_cli_s *)camera;
2809         muse_camera_api_e api = MUSE_CAMERA_API_SET_DISPLAY_MODE;
2810         int sock_fd;
2811         if (pc->cb_info == NULL) {
2812                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2813                 return CAMERA_ERROR_INVALID_PARAMETER;
2814         }
2815         sock_fd = pc->cb_info->fd;
2816
2817         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2818         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_mode);
2819         LOGD("ret : 0x%x", ret);
2820         return ret;
2821 }
2822
2823 int camera_get_display_mode(camera_h camera, camera_display_mode_e* mode)
2824 {
2825         if (camera == NULL || mode == NULL) {
2826                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2827                 return CAMERA_ERROR_INVALID_PARAMETER;
2828         }
2829
2830         int ret = CAMERA_ERROR_NONE;
2831
2832         camera_cli_s *pc = (camera_cli_s *)camera;
2833         muse_camera_api_e api = MUSE_CAMERA_API_GET_DISPLAY_MODE;
2834         int sock_fd;
2835         if (pc->cb_info == NULL) {
2836                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2837                 return CAMERA_ERROR_INVALID_PARAMETER;
2838         }
2839         sock_fd = pc->cb_info->fd;
2840         int get_mode;
2841
2842         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2843         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2844
2845         if (ret == CAMERA_ERROR_NONE) {
2846                 muse_camera_msg_get(get_mode, pc->cb_info->recv_msg);
2847                 *mode = (camera_display_mode_e)get_mode;
2848         }
2849         LOGD("ret : 0x%x", ret);
2850         return ret;
2851 }
2852
2853 int camera_get_capture_resolution(camera_h camera, int *width, int *height)
2854 {
2855         if (camera == NULL || width == NULL || height == NULL) {
2856                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2857                 return CAMERA_ERROR_INVALID_PARAMETER;
2858         }
2859         int ret = CAMERA_ERROR_NONE;
2860
2861         camera_cli_s *pc = (camera_cli_s *)camera;
2862         muse_camera_api_e api = MUSE_CAMERA_API_GET_CAPTURE_RESOLUTION;
2863         int sock_fd;
2864         if (pc->cb_info == NULL) {
2865                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2866                 return CAMERA_ERROR_INVALID_PARAMETER;
2867         }
2868         sock_fd = pc->cb_info->fd;
2869         int get_width;
2870         int get_height;
2871
2872         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2873         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2874
2875         if (ret == CAMERA_ERROR_NONE) {
2876                 muse_camera_msg_get(get_width, pc->cb_info->recv_msg);
2877                 muse_camera_msg_get(get_height, pc->cb_info->recv_msg);
2878                 *width = get_width;
2879                 *height = get_height;
2880         }
2881         LOGD("ret : 0x%x", ret);
2882         return ret;
2883 }
2884
2885 int camera_get_capture_format(camera_h camera, camera_pixel_format_e *format)
2886 {
2887         if (camera == NULL || format == NULL) {
2888                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2889                 return CAMERA_ERROR_INVALID_PARAMETER;
2890         }
2891         int ret = CAMERA_ERROR_NONE;
2892
2893         camera_cli_s *pc = (camera_cli_s *)camera;
2894         muse_camera_api_e api = MUSE_CAMERA_API_GET_CAPTURE_FORMAT;
2895         int get_format;
2896         int sock_fd;
2897         if (pc->cb_info == NULL) {
2898                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2899                 return CAMERA_ERROR_INVALID_PARAMETER;
2900         }
2901         sock_fd = pc->cb_info->fd;
2902
2903         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2904         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2905
2906         if (ret == CAMERA_ERROR_NONE) {
2907                 muse_camera_msg_get(get_format, pc->cb_info->recv_msg);
2908                 *format = (camera_pixel_format_e)get_format;
2909         }
2910         LOGD("ret : 0x%x", ret);
2911         return ret;
2912 }
2913
2914 int camera_get_preview_format(camera_h camera, camera_pixel_format_e *format)
2915 {
2916         if (camera == NULL || format == NULL) {
2917                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2918                 return CAMERA_ERROR_INVALID_PARAMETER;
2919         }
2920
2921         int ret = CAMERA_ERROR_NONE;
2922
2923         camera_cli_s *pc = (camera_cli_s *)camera;
2924         muse_camera_api_e api = MUSE_CAMERA_API_GET_PREVIEW_FORMAT;
2925         int get_format;
2926         int sock_fd;
2927         if (pc->cb_info == NULL) {
2928                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2929                 return CAMERA_ERROR_INVALID_PARAMETER;
2930         }
2931         sock_fd = pc->cb_info->fd;
2932
2933         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2934         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2935
2936         if (ret == CAMERA_ERROR_NONE) {
2937                 muse_camera_msg_get(get_format, pc->cb_info->recv_msg);
2938                 *format = (camera_pixel_format_e)get_format;
2939         }
2940         LOGD("ret : 0x%x", ret);
2941         return ret;
2942 }
2943
2944 int camera_get_facing_direction(camera_h camera, camera_facing_direction_e *facing_direciton)
2945 {
2946         if (camera == NULL || facing_direciton == NULL) {
2947                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2948                 return CAMERA_ERROR_INVALID_PARAMETER;
2949         }
2950
2951         int ret = CAMERA_ERROR_NONE;
2952
2953         camera_cli_s *pc = (camera_cli_s *)camera;
2954         muse_camera_api_e api = MUSE_CAMERA_API_GET_FACING_DIRECTION;
2955         int sock_fd;
2956         if (pc->cb_info == NULL) {
2957                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2958                 return CAMERA_ERROR_INVALID_PARAMETER;
2959         }
2960         sock_fd = pc->cb_info->fd;
2961         int get_facing_direction;
2962
2963         LOGD("Enter, remote_handle : %x", pc->remote_handle);
2964         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2965
2966         if (ret == CAMERA_ERROR_NONE) {
2967                 muse_camera_msg_get(get_facing_direction, pc->cb_info->recv_msg);
2968                 *facing_direciton = (camera_facing_direction_e)get_facing_direction;
2969         }
2970         LOGD("ret : 0x%x", ret);
2971         return ret;
2972 }
2973
2974 int camera_set_preview_cb(camera_h camera, camera_preview_cb callback, void* user_data)
2975 {
2976         if (camera == NULL || callback == NULL) {
2977                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2978                 return CAMERA_ERROR_INVALID_PARAMETER;
2979         }
2980         int ret = CAMERA_ERROR_NONE;
2981
2982         camera_cli_s *pc = (camera_cli_s *)camera;
2983         int sock_fd;
2984         if (pc->cb_info == NULL) {
2985                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
2986                 return CAMERA_ERROR_INVALID_PARAMETER;
2987         }
2988         sock_fd = pc->cb_info->fd;
2989         muse_camera_api_e api = MUSE_CAMERA_API_SET_PREVIEW_CB;
2990
2991         LOGD("Enter, handle :%x", pc->remote_handle);
2992
2993         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_PREVIEW] = callback;
2994         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_PREVIEW] = user_data;
2995
2996         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
2997         LOGD("ret : 0x%x", ret);
2998         return ret;
2999 }
3000
3001 int camera_unset_preview_cb(camera_h camera)
3002 {
3003         if (camera == NULL) {
3004                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3005                 return CAMERA_ERROR_INVALID_PARAMETER;
3006         }
3007
3008         int ret = CAMERA_ERROR_NONE;
3009
3010         camera_cli_s *pc = (camera_cli_s *)camera;
3011         muse_camera_api_e api = MUSE_CAMERA_API_UNSET_PREVIEW_CB;
3012
3013         LOGD("Enter, handle :%x", pc->remote_handle);
3014
3015         int sock_fd;
3016         if (pc->cb_info == NULL) {
3017                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3018                 return CAMERA_ERROR_INVALID_PARAMETER;
3019         }
3020         sock_fd = pc->cb_info->fd;
3021         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_PREVIEW] = (void *)NULL;
3022         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_PREVIEW] = (void *)NULL;
3023
3024         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3025         LOGD("ret : 0x%x", ret);
3026         return ret;
3027 }
3028
3029 int camera_set_media_packet_preview_cb(camera_h camera, camera_media_packet_preview_cb callback, void* user_data)
3030 {
3031         if (camera == NULL) {
3032                 LOGE("INVALID_PARAMETER(0x%08x) - handle", CAMERA_ERROR_INVALID_PARAMETER);
3033                 return CAMERA_ERROR_INVALID_PARAMETER;
3034         }
3035
3036         if (camera_is_supported_media_packet_preview_cb(camera) == false) {
3037                 LOGE("NOT SUPPORTED");
3038                 return CAMERA_ERROR_NOT_SUPPORTED;
3039         }
3040
3041         if (callback == NULL) {
3042                 LOGE("INVALID_PARAMETER(0x%08x) - callback", CAMERA_ERROR_INVALID_PARAMETER);
3043                 return CAMERA_ERROR_INVALID_PARAMETER;
3044         }
3045
3046         int ret = CAMERA_ERROR_NONE;
3047
3048         camera_cli_s *pc = (camera_cli_s *)camera;
3049         muse_camera_api_e api = MUSE_CAMERA_API_SET_MEDIA_PACKET_PREVIEW_CB;
3050
3051         LOGD("Enter, handle :%x", pc->remote_handle);
3052
3053         int sock_fd;
3054         if (pc->cb_info == NULL) {
3055                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3056                 return CAMERA_ERROR_INVALID_PARAMETER;
3057         }
3058         sock_fd = pc->cb_info->fd;
3059         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_MEDIA_PACKET_PREVIEW] = callback;
3060         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_MEDIA_PACKET_PREVIEW] = user_data;
3061
3062         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3063         LOGD("ret : 0x%x", ret);
3064         return ret;
3065 }
3066
3067 int camera_unset_media_packet_preview_cb(camera_h camera)
3068 {
3069         if (camera == NULL) {
3070                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3071                 return CAMERA_ERROR_INVALID_PARAMETER;
3072         }
3073
3074         int ret = CAMERA_ERROR_NONE;
3075
3076         camera_cli_s *pc = (camera_cli_s *)camera;
3077         muse_camera_api_e api = MUSE_CAMERA_API_UNSET_MEDIA_PACKET_PREVIEW_CB;
3078
3079         LOGD("Enter, handle :%x", pc->remote_handle);
3080
3081         int sock_fd;
3082         if (pc->cb_info == NULL) {
3083                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3084                 return CAMERA_ERROR_INVALID_PARAMETER;
3085         }
3086         sock_fd = pc->cb_info->fd;
3087         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_MEDIA_PACKET_PREVIEW] = (void *)NULL;
3088         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_MEDIA_PACKET_PREVIEW] = (void *)NULL;
3089
3090         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3091         LOGD("ret : 0x%x", ret);
3092         return ret;
3093 }
3094
3095 int camera_set_state_changed_cb(camera_h camera, camera_state_changed_cb callback, void* user_data)
3096 {
3097         if (camera == NULL || callback == NULL) {
3098                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3099                 return CAMERA_ERROR_INVALID_PARAMETER;
3100         }
3101         int ret = CAMERA_ERROR_NONE;
3102
3103         camera_cli_s *pc = (camera_cli_s *)camera;
3104         muse_camera_api_e api = MUSE_CAMERA_API_SET_STATE_CHANGED_CB;
3105
3106         LOGD("Enter, handle :%x", pc->remote_handle);
3107
3108         int sock_fd;
3109         if (pc->cb_info == NULL) {
3110                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3111                 return CAMERA_ERROR_INVALID_PARAMETER;
3112         }
3113         sock_fd = pc->cb_info->fd;
3114         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_STATE_CHANGE] = callback;
3115         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_STATE_CHANGE] = user_data;
3116
3117         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3118         LOGD("ret : 0x%x", ret);
3119         return ret;
3120 }
3121 int camera_unset_state_changed_cb(camera_h camera)
3122 {
3123         if (camera == NULL) {
3124                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3125                 return CAMERA_ERROR_INVALID_PARAMETER;
3126         }
3127         int ret = CAMERA_ERROR_NONE;
3128
3129         camera_cli_s *pc = (camera_cli_s *)camera;
3130         muse_camera_api_e api = MUSE_CAMERA_API_UNSET_STATE_CHANGED_CB;
3131
3132         LOGD("Enter, handle :%x", pc->remote_handle);
3133
3134         int sock_fd;
3135         if (pc->cb_info == NULL) {
3136                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3137                 return CAMERA_ERROR_INVALID_PARAMETER;
3138         }
3139         sock_fd = pc->cb_info->fd;
3140         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_STATE_CHANGE] = (void *)NULL;
3141         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_STATE_CHANGE] = (void *)NULL;
3142
3143         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3144         LOGD("ret : 0x%x", ret);
3145         return ret;
3146 }
3147
3148 int camera_set_interrupted_cb(camera_h camera, camera_interrupted_cb callback, void *user_data)
3149 {
3150         if (camera == NULL || callback == NULL) {
3151                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3152                 return CAMERA_ERROR_INVALID_PARAMETER;
3153         }
3154         int ret = CAMERA_ERROR_NONE;
3155
3156         camera_cli_s *pc = (camera_cli_s *)camera;
3157         muse_camera_api_e api = MUSE_CAMERA_API_SET_INTERRUPTED_CB;
3158
3159         LOGD("Enter, handle :%x", pc->remote_handle);
3160
3161         int sock_fd;
3162         if (pc->cb_info == NULL) {
3163                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3164                 return CAMERA_ERROR_INVALID_PARAMETER;
3165         }
3166         sock_fd = pc->cb_info->fd;
3167         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_INTERRUPTED] = callback;
3168         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_INTERRUPTED] = user_data;
3169
3170         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3171         LOGD("ret : 0x%x", ret);
3172         return ret;
3173 }
3174
3175 int camera_unset_interrupted_cb(camera_h camera)
3176 {
3177         if (camera == NULL) {
3178                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3179                 return CAMERA_ERROR_INVALID_PARAMETER;
3180         }
3181         int ret = CAMERA_ERROR_NONE;
3182
3183         camera_cli_s *pc = (camera_cli_s *)camera;
3184         muse_camera_api_e api = MUSE_CAMERA_API_UNSET_INTERRUPTED_CB;
3185
3186         LOGD("Enter, handle :%x", pc->remote_handle);
3187
3188         int sock_fd;
3189         if (pc->cb_info == NULL) {
3190                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3191                 return CAMERA_ERROR_INVALID_PARAMETER;
3192         }
3193         sock_fd = pc->cb_info->fd;
3194         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_INTERRUPTED] = (void *)NULL;
3195         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_INTERRUPTED] = (void *)NULL;
3196
3197         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3198         LOGD("ret : 0x%x", ret);
3199         return ret;
3200 }
3201
3202 int camera_set_focus_changed_cb(camera_h camera, camera_focus_changed_cb callback, void* user_data)
3203 {
3204         if (camera == NULL || callback == NULL) {
3205                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3206                 return CAMERA_ERROR_INVALID_PARAMETER;
3207         }
3208         int ret = CAMERA_ERROR_NONE;
3209
3210         camera_cli_s *pc = (camera_cli_s *)camera;
3211         muse_camera_api_e api = MUSE_CAMERA_API_SET_FOCUS_CHANGED_CB;
3212
3213         LOGD("Enter, handle :%x", pc->remote_handle);
3214
3215         int sock_fd;
3216         if (pc->cb_info == NULL) {
3217                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3218                 return CAMERA_ERROR_INVALID_PARAMETER;
3219         }
3220         sock_fd = pc->cb_info->fd;
3221         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = callback;
3222         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = user_data;
3223
3224         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3225         LOGD("ret : 0x%x", ret);
3226         return ret;
3227 }
3228
3229 int camera_unset_focus_changed_cb(camera_h camera)
3230 {
3231         if (camera == NULL) {
3232                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3233                 return CAMERA_ERROR_INVALID_PARAMETER;
3234         }
3235         int ret = CAMERA_ERROR_NONE;
3236
3237         camera_cli_s *pc = (camera_cli_s *)camera;
3238         muse_camera_api_e api = MUSE_CAMERA_API_UNSET_FOCUS_CHANGED_CB;
3239
3240         LOGD("Enter, handle :%x", pc->remote_handle);
3241
3242         int sock_fd;
3243         if (pc->cb_info == NULL) {
3244                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3245                 return CAMERA_ERROR_INVALID_PARAMETER;
3246         }
3247         sock_fd = pc->cb_info->fd;
3248         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = (void *)NULL;
3249         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOCUS_CHANGE] = (void *)NULL;
3250
3251         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3252         LOGD("ret : 0x%x", ret);
3253         return ret;
3254 }
3255
3256 int camera_set_error_cb(camera_h camera, camera_error_cb callback, void *user_data)
3257 {
3258         if (camera == NULL || callback == NULL) {
3259                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3260                 return CAMERA_ERROR_INVALID_PARAMETER;
3261         }
3262         int ret = CAMERA_ERROR_NONE;
3263
3264         camera_cli_s *pc = (camera_cli_s *)camera;
3265         muse_camera_api_e api = MUSE_CAMERA_API_SET_ERROR_CB;
3266
3267         LOGD("Enter, handle :%x", pc->remote_handle);
3268
3269         int sock_fd;
3270         if (pc->cb_info == NULL) {
3271                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3272                 return CAMERA_ERROR_INVALID_PARAMETER;
3273         }
3274         sock_fd = pc->cb_info->fd;
3275         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_ERROR] = callback;
3276         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_ERROR] = user_data;
3277
3278         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3279         LOGD("ret : 0x%x", ret);
3280         return ret;
3281 }
3282
3283 int camera_unset_error_cb(camera_h camera)
3284 {
3285         if (camera == NULL) {
3286                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3287                 return CAMERA_ERROR_INVALID_PARAMETER;
3288         }
3289         int ret = CAMERA_ERROR_NONE;
3290
3291         camera_cli_s *pc = (camera_cli_s *)camera;
3292         muse_camera_api_e api = MUSE_CAMERA_API_UNSET_ERROR_CB;
3293
3294         LOGD("Enter, handle :%x", pc->remote_handle);
3295
3296         int sock_fd;
3297         if (pc->cb_info == NULL) {
3298                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3299                 return CAMERA_ERROR_INVALID_PARAMETER;
3300         }
3301         sock_fd = pc->cb_info->fd;
3302         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_ERROR] = (void *)NULL;
3303         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_ERROR] = (void *)NULL;
3304
3305         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3306         LOGD("ret : 0x%x", ret);
3307         return ret;
3308 }
3309
3310 int camera_foreach_supported_preview_resolution(camera_h camera, camera_supported_preview_resolution_cb foreach_cb , void *user_data)
3311 {
3312         if (camera == NULL || foreach_cb == NULL) {
3313                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3314                 return CAMERA_ERROR_INVALID_PARAMETER;
3315         }
3316         int ret = CAMERA_ERROR_NONE;
3317
3318         camera_cli_s *pc = (camera_cli_s *)camera;
3319         muse_camera_api_e api = MUSE_CAMERA_API_SET_FOREACH_SUPPORTED_PREVIEW_RESOLUTION;
3320
3321         LOGD("Enter, handle :%x", pc->remote_handle);
3322
3323         int sock_fd;
3324         if (pc->cb_info == NULL) {
3325                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3326                 return CAMERA_ERROR_INVALID_PARAMETER;
3327         }
3328         sock_fd = pc->cb_info->fd;
3329         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_RESOLUTION] = foreach_cb;
3330         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_RESOLUTION] = user_data;
3331
3332         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3333         LOGD("ret : 0x%x", ret);
3334         return ret;
3335 }
3336
3337 int camera_foreach_supported_capture_resolution(camera_h camera, camera_supported_capture_resolution_cb foreach_cb , void *user_data)
3338 {
3339         if (camera == NULL || foreach_cb == NULL) {
3340                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3341                 return CAMERA_ERROR_INVALID_PARAMETER;
3342         }
3343         int ret = CAMERA_ERROR_NONE;
3344
3345         camera_cli_s *pc = (camera_cli_s *)camera;
3346         muse_camera_api_e api = MUSE_CAMERA_API_SET_FOREACH_SUPPORTED_CAPTURE_RESOLUTION;
3347
3348         LOGD("Enter, handle :%x", pc->remote_handle);
3349
3350         int sock_fd;
3351         if (pc->cb_info == NULL) {
3352                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3353                 return CAMERA_ERROR_INVALID_PARAMETER;
3354         }
3355         sock_fd = pc->cb_info->fd;
3356         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_RESOLUTION] = foreach_cb;
3357         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_RESOLUTION] = user_data;
3358
3359         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3360         LOGD("ret : 0x%x", ret);
3361         return ret;
3362 }
3363
3364 int camera_foreach_supported_capture_format(camera_h camera, camera_supported_capture_format_cb foreach_cb , void *user_data)
3365 {
3366         if (camera == NULL || foreach_cb == NULL) {
3367                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3368                 return CAMERA_ERROR_INVALID_PARAMETER;
3369         }
3370         int ret = CAMERA_ERROR_NONE;
3371
3372         camera_cli_s *pc = (camera_cli_s *)camera;
3373         muse_camera_api_e api = MUSE_CAMERA_API_SET_FOREACH_SUPPORTED_CAPTURE_FORMAT;
3374
3375         LOGD("Enter, handle :%x", pc->remote_handle);
3376
3377         int sock_fd;
3378         if (pc->cb_info == NULL) {
3379                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3380                 return CAMERA_ERROR_INVALID_PARAMETER;
3381         }
3382         sock_fd = pc->cb_info->fd;
3383         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_FORMAT] = foreach_cb;
3384         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_FORMAT] = user_data;
3385
3386         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3387         LOGD("ret : 0x%x", ret);
3388         return ret;
3389 }
3390
3391
3392 int camera_foreach_supported_preview_format(camera_h camera, camera_supported_preview_format_cb foreach_cb , void *user_data)
3393 {
3394         if (camera == NULL || foreach_cb == NULL) {
3395                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3396                 return CAMERA_ERROR_INVALID_PARAMETER;
3397         }
3398         int ret = CAMERA_ERROR_NONE;
3399
3400         camera_cli_s *pc = (camera_cli_s *)camera;
3401         muse_camera_api_e api = MUSE_CAMERA_API_SET_FOREACH_SUPPORTED_PREVIEW_FORMAT;
3402
3403         LOGD("Enter, handle :%x", pc->remote_handle);
3404
3405         int sock_fd;
3406         if (pc->cb_info == NULL) {
3407                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3408                 return CAMERA_ERROR_INVALID_PARAMETER;
3409         }
3410         sock_fd = pc->cb_info->fd;
3411         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_FORMAT] = foreach_cb;
3412         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_FORMAT] = user_data;
3413
3414         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3415         LOGD("ret : 0x%x", ret);
3416         return ret;
3417 }
3418
3419
3420 int camera_get_recommended_preview_resolution(camera_h camera, int *width, int *height)
3421 {
3422         if (camera == NULL || width == NULL || height == NULL) {
3423                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3424                 return CAMERA_ERROR_INVALID_PARAMETER;
3425         }
3426         int ret = CAMERA_ERROR_NONE;
3427
3428         camera_cli_s *pc = (camera_cli_s *)camera;
3429         muse_camera_api_e api = MUSE_CAMERA_API_GET_RECOMMENDED_PREVIEW_RESOLUTION;
3430         int sock_fd;
3431         if (pc->cb_info == NULL) {
3432                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3433                 return CAMERA_ERROR_INVALID_PARAMETER;
3434         }
3435         sock_fd = pc->cb_info->fd;
3436         int get_width;
3437         int get_height;
3438
3439         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3440         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3441
3442         if (ret == CAMERA_ERROR_NONE) {
3443                 muse_camera_msg_get(get_width, pc->cb_info->recv_msg);
3444                 muse_camera_msg_get(get_height, pc->cb_info->recv_msg);
3445                 *width = get_width;
3446                 *height = get_height;
3447         }
3448         LOGD("ret : 0x%x", ret);
3449         return ret;
3450 }
3451
3452
3453 int camera_attr_get_lens_orientation(camera_h camera, int *angle)
3454 {
3455         if (camera == NULL || angle == NULL) {
3456                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3457                 return CAMERA_ERROR_INVALID_PARAMETER;
3458         }
3459         int ret = CAMERA_ERROR_NONE;
3460
3461         camera_cli_s *pc = (camera_cli_s *)camera;
3462         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_LENS_ORIENTATION;
3463         int sock_fd;
3464         if (pc->cb_info == NULL) {
3465                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3466                 return CAMERA_ERROR_INVALID_PARAMETER;
3467         }
3468         sock_fd = pc->cb_info->fd;
3469         int get_angle;
3470
3471         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3472         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3473
3474         if (ret == CAMERA_ERROR_NONE) {
3475                 muse_camera_msg_get(get_angle, pc->cb_info->recv_msg);
3476                 *angle = get_angle;
3477         }
3478         LOGD("ret : 0x%x", ret);
3479         return ret;
3480 }
3481
3482 int camera_attr_set_theater_mode(camera_h camera, camera_attr_theater_mode_e mode)
3483 {
3484         if (camera == NULL) {
3485                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3486                 return CAMERA_ERROR_INVALID_PARAMETER;
3487         }
3488         int ret = CAMERA_ERROR_NONE;
3489         camera_cli_s *pc = (camera_cli_s *)camera;
3490         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_THEATER_MODE;
3491         int sock_fd;
3492         if (pc->cb_info == NULL) {
3493                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3494                 return CAMERA_ERROR_INVALID_PARAMETER;
3495         }
3496         sock_fd = pc->cb_info->fd;
3497         int set_mode = (int)mode;
3498         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3499         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_mode);
3500         LOGD("ret : 0x%x", ret);
3501         return ret;
3502 }
3503
3504 int camera_attr_get_theater_mode(camera_h camera, camera_attr_theater_mode_e *mode)
3505 {
3506         if (camera == NULL || mode == NULL) {
3507                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3508                 return CAMERA_ERROR_INVALID_PARAMETER;
3509         }
3510
3511         int ret = CAMERA_ERROR_NONE;
3512         camera_cli_s *pc = (camera_cli_s *)camera;
3513         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_THEATER_MODE;
3514         int sock_fd;
3515         if (pc->cb_info == NULL) {
3516                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3517                 return CAMERA_ERROR_INVALID_PARAMETER;
3518         }
3519         sock_fd = pc->cb_info->fd;
3520         int get_mode;
3521         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3522         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3523
3524         if (ret == CAMERA_ERROR_NONE) {
3525                 muse_camera_msg_get(get_mode, pc->cb_info->recv_msg);
3526                 *mode = (camera_attr_theater_mode_e)get_mode;
3527         }
3528         LOGD("ret : 0x%x", ret);
3529         return ret;
3530 }
3531
3532 int camera_attr_foreach_supported_theater_mode(camera_h camera, camera_attr_supported_theater_mode_cb foreach_cb, void *user_data)
3533 {
3534         if (camera == NULL || foreach_cb == NULL) {
3535                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3536                 return CAMERA_ERROR_INVALID_PARAMETER;
3537         }
3538         int ret = CAMERA_ERROR_NONE;
3539
3540         camera_cli_s *pc = (camera_cli_s *)camera;
3541         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_THEATER_MODE;
3542
3543         LOGD("Enter, handle :%x", pc->remote_handle);
3544
3545         int sock_fd;
3546         if (pc->cb_info == NULL) {
3547                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3548                 return CAMERA_ERROR_INVALID_PARAMETER;
3549         }
3550         sock_fd = pc->cb_info->fd;
3551         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_THEATER_MODE] = foreach_cb;
3552         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_THEATER_MODE] = user_data;
3553
3554         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3555
3556         LOGD("Finish, return :%x", ret);
3557
3558         return ret;
3559 }
3560
3561 int camera_attr_set_preview_fps(camera_h camera,  camera_attr_fps_e fps)
3562 {
3563         if (camera == NULL) {
3564                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3565                 return CAMERA_ERROR_INVALID_PARAMETER;
3566         }
3567         int ret = CAMERA_ERROR_NONE;
3568         camera_cli_s *pc = (camera_cli_s *)camera;
3569         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_PREVIEW_FPS;
3570         int sock_fd;
3571         if (pc->cb_info == NULL) {
3572                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3573                 return CAMERA_ERROR_INVALID_PARAMETER;
3574         }
3575         sock_fd = pc->cb_info->fd;
3576         int set_fps = (int)fps;
3577         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3578         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_fps);
3579         LOGD("ret : 0x%x", ret);
3580         return ret;
3581 }
3582
3583
3584 int camera_attr_set_image_quality(camera_h camera,  int quality)
3585 {
3586         if (camera == NULL) {
3587                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3588                 return CAMERA_ERROR_INVALID_PARAMETER;
3589         }
3590         int ret = CAMERA_ERROR_NONE;
3591
3592         camera_cli_s *pc = (camera_cli_s *)camera;
3593         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_IMAGE_QUALITY;
3594         int sock_fd;
3595         if (pc->cb_info == NULL) {
3596                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3597                 return CAMERA_ERROR_INVALID_PARAMETER;
3598         }
3599         sock_fd = pc->cb_info->fd;
3600         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3601         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, quality);
3602         LOGD("ret : 0x%x", ret);
3603         return ret;
3604 }
3605
3606 int camera_attr_get_preview_fps(camera_h camera,  camera_attr_fps_e *fps)
3607 {
3608         if (camera == NULL || fps == NULL) {
3609                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3610                 return CAMERA_ERROR_INVALID_PARAMETER;
3611         }
3612         int ret = CAMERA_ERROR_NONE;
3613
3614         camera_cli_s *pc = (camera_cli_s *)camera;
3615         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_PREVIEW_FPS;
3616         int get_fps;
3617         int sock_fd;
3618         if (pc->cb_info == NULL) {
3619                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3620                 return CAMERA_ERROR_INVALID_PARAMETER;
3621         }
3622         sock_fd = pc->cb_info->fd;
3623
3624         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3625         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3626
3627         if (ret == CAMERA_ERROR_NONE) {
3628                 muse_camera_msg_get(get_fps, pc->cb_info->recv_msg);
3629                 *fps = (camera_attr_fps_e)get_fps;
3630         }
3631         LOGD("ret : 0x%x", ret);
3632         return ret;
3633 }
3634
3635
3636 int camera_attr_get_image_quality(camera_h camera, int *quality)
3637 {
3638         if (camera == NULL || quality == NULL) {
3639                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3640                 return CAMERA_ERROR_INVALID_PARAMETER;
3641         }
3642         int ret = CAMERA_ERROR_NONE;
3643
3644         camera_cli_s *pc = (camera_cli_s *)camera;
3645         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_IMAGE_QUALITY;
3646         int sock_fd;
3647         if (pc->cb_info == NULL) {
3648                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3649                 return CAMERA_ERROR_INVALID_PARAMETER;
3650         }
3651         sock_fd = pc->cb_info->fd;
3652         int get_quality;
3653         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3654         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3655
3656         if (ret == CAMERA_ERROR_NONE) {
3657                 muse_camera_msg_get(get_quality, pc->cb_info->recv_msg);
3658                 *quality = get_quality;
3659         }
3660         LOGD("ret : 0x%x", ret);
3661         return ret;
3662 }
3663
3664
3665 int camera_attr_set_zoom(camera_h camera, int zoom)
3666 {
3667         if (camera == NULL) {
3668                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3669                 return CAMERA_ERROR_INVALID_PARAMETER;
3670         }
3671         int ret = CAMERA_ERROR_NONE;
3672
3673         camera_cli_s *pc = (camera_cli_s *)camera;
3674         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_ZOOM;
3675         int sock_fd;
3676         if (pc->cb_info == NULL) {
3677                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3678                 return CAMERA_ERROR_INVALID_PARAMETER;
3679         }
3680         sock_fd = pc->cb_info->fd;
3681
3682         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3683         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, zoom);
3684         LOGD("ret : 0x%x", ret);
3685         return ret;
3686 }
3687
3688 int camera_attr_set_af_mode(camera_h camera,  camera_attr_af_mode_e mode)
3689 {
3690         if (camera == NULL) {
3691                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3692                 return CAMERA_ERROR_INVALID_PARAMETER;
3693         }
3694         int ret = CAMERA_ERROR_NONE;
3695
3696         camera_cli_s *pc = (camera_cli_s *)camera;
3697         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_AF_MODE;
3698         int sock_fd;
3699         if (pc->cb_info == NULL) {
3700                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3701                 return CAMERA_ERROR_INVALID_PARAMETER;
3702         }
3703         sock_fd = pc->cb_info->fd;
3704         int set_mode = (int)mode;
3705         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3706         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_mode);
3707         LOGD("ret : 0x%x", ret);
3708         return ret;
3709 }
3710
3711 int camera_attr_set_af_area(camera_h camera, int x, int y)
3712 {
3713         if (camera == NULL) {
3714                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3715                 return CAMERA_ERROR_INVALID_PARAMETER;
3716         }
3717         int ret = CAMERA_ERROR_NONE;
3718         camera_cli_s *pc = (camera_cli_s *)camera;
3719         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_AF_AREA;
3720         int sock_fd = pc->cb_info->fd;
3721         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3722         muse_camera_msg_send2(api, sock_fd, pc->cb_info, ret, INT, x, INT, y);
3723         LOGD("ret : 0x%x", ret);
3724         return ret;
3725 }
3726
3727
3728 int camera_attr_clear_af_area(camera_h camera)
3729 {
3730         if (camera == NULL) {
3731                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3732                 return CAMERA_ERROR_INVALID_PARAMETER;
3733         }
3734         int ret = CAMERA_ERROR_NONE;
3735
3736         camera_cli_s *pc = (camera_cli_s *)camera;
3737         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_CLEAR_AF_AREA;
3738         int sock_fd;
3739         if (pc->cb_info == NULL) {
3740                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3741                 return CAMERA_ERROR_INVALID_PARAMETER;
3742         }
3743         sock_fd = pc->cb_info->fd;
3744         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3745         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
3746         LOGD("ret : 0x%x", ret);
3747         return ret;
3748 }
3749
3750
3751 int camera_attr_set_exposure_mode(camera_h camera,  camera_attr_exposure_mode_e mode)
3752 {
3753         if (camera == NULL) {
3754                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3755                 return CAMERA_ERROR_INVALID_PARAMETER;
3756         }
3757
3758         if (mode < CAMERA_ATTR_EXPOSURE_MODE_OFF || mode > CAMERA_ATTR_EXPOSURE_MODE_CUSTOM) {
3759                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3760                 return CAMERA_ERROR_INVALID_PARAMETER;
3761         }
3762
3763         int ret = CAMERA_ERROR_NONE;
3764         camera_cli_s *pc = (camera_cli_s *)camera;
3765         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_EXPOSURE_MODE;
3766         int set_mode = (int)mode;
3767         int sock_fd;
3768         if (pc->cb_info == NULL) {
3769                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3770                 return CAMERA_ERROR_INVALID_PARAMETER;
3771         }
3772         sock_fd = pc->cb_info->fd;
3773         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3774         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_mode);
3775         LOGD("ret : 0x%x", ret);
3776         return ret;
3777 }
3778
3779
3780 int camera_attr_set_exposure(camera_h camera, int value)
3781 {
3782         if (camera == NULL) {
3783                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3784                 return CAMERA_ERROR_INVALID_PARAMETER;
3785         }
3786         int ret = CAMERA_ERROR_NONE;
3787
3788         camera_cli_s *pc = (camera_cli_s *)camera;
3789         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_EXPOSURE;
3790         int sock_fd;
3791         if (pc->cb_info == NULL) {
3792                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3793                 return CAMERA_ERROR_INVALID_PARAMETER;
3794         }
3795         sock_fd = pc->cb_info->fd;
3796
3797         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3798         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, value);
3799         LOGD("ret : 0x%x", ret);
3800         return ret;
3801 }
3802
3803
3804 int camera_attr_set_iso(camera_h camera, camera_attr_iso_e iso)
3805 {
3806         if (camera == NULL) {
3807                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3808                 return CAMERA_ERROR_INVALID_PARAMETER;
3809         }
3810         int ret = CAMERA_ERROR_NONE;
3811
3812         camera_cli_s *pc = (camera_cli_s *)camera;
3813         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_ISO;
3814         int sock_fd;
3815         if (pc->cb_info == NULL) {
3816                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3817                 return CAMERA_ERROR_INVALID_PARAMETER;
3818         }
3819         sock_fd = pc->cb_info->fd;
3820         int set_iso = (int)iso;
3821         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3822         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_iso);
3823         LOGD("ret : 0x%x", ret);
3824         return ret;
3825 }
3826
3827
3828 int camera_attr_set_brightness(camera_h camera, int level)
3829 {
3830         if (camera == NULL) {
3831                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3832                 return CAMERA_ERROR_INVALID_PARAMETER;
3833         }
3834         int ret = CAMERA_ERROR_NONE;
3835
3836         camera_cli_s *pc = (camera_cli_s *)camera;
3837         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_BRIGHTNESS;
3838         int sock_fd;
3839         if (pc->cb_info == NULL) {
3840                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3841                 return CAMERA_ERROR_INVALID_PARAMETER;
3842         }
3843         sock_fd = pc->cb_info->fd;
3844
3845         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3846         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, level);
3847         LOGD("ret : 0x%x", ret);
3848         return ret;
3849 }
3850
3851
3852 int camera_attr_set_contrast(camera_h camera, int level)
3853 {
3854         if (camera == NULL) {
3855                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3856                 return CAMERA_ERROR_INVALID_PARAMETER;
3857         }
3858         int ret = CAMERA_ERROR_NONE;
3859
3860         camera_cli_s *pc = (camera_cli_s *)camera;
3861         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_CONTRAST;
3862         int sock_fd;
3863         if (pc->cb_info == NULL) {
3864                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3865                 return CAMERA_ERROR_INVALID_PARAMETER;
3866         }
3867         sock_fd = pc->cb_info->fd;
3868
3869         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3870         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, level);
3871         LOGD("ret : 0x%x", ret);
3872         return ret;
3873 }
3874
3875
3876 int camera_attr_set_whitebalance(camera_h camera, camera_attr_whitebalance_e wb)
3877 {
3878         if (camera == NULL) {
3879                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3880                 return CAMERA_ERROR_INVALID_PARAMETER;
3881         }
3882
3883         if (wb < CAMERA_ATTR_WHITE_BALANCE_NONE || wb > CAMERA_ATTR_WHITE_BALANCE_CUSTOM) {
3884                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_NOT_SUPPORTED);
3885                 return CAMERA_ERROR_NOT_SUPPORTED;
3886         }
3887
3888         int ret = CAMERA_ERROR_NONE;
3889
3890         camera_cli_s *pc = (camera_cli_s *)camera;
3891         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_WHITEBALANCE;
3892         int sock_fd;
3893         if (pc->cb_info == NULL) {
3894                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3895                 return CAMERA_ERROR_INVALID_PARAMETER;
3896         }
3897         sock_fd = pc->cb_info->fd;
3898         int set_whitebalance = (int)wb;
3899         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3900         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_whitebalance);
3901         LOGD("ret : 0x%x", ret);
3902         return ret;
3903 }
3904
3905
3906 int camera_attr_set_effect(camera_h camera, camera_attr_effect_mode_e effect)
3907 {
3908         if (camera == NULL) {
3909                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3910                 return CAMERA_ERROR_INVALID_PARAMETER;
3911         }
3912         int ret = CAMERA_ERROR_NONE;
3913
3914         camera_cli_s *pc = (camera_cli_s *)camera;
3915         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_EFFECT;
3916         int sock_fd;
3917         if (pc->cb_info == NULL) {
3918                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3919                 return CAMERA_ERROR_INVALID_PARAMETER;
3920         }
3921         sock_fd = pc->cb_info->fd;
3922         int set_effect = (int)effect;
3923         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3924         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_effect);
3925         LOGD("ret : 0x%x", ret);
3926         return ret;
3927 }
3928
3929
3930 int camera_attr_set_scene_mode(camera_h camera, camera_attr_scene_mode_e mode)
3931 {
3932         if (camera == NULL) {
3933                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3934                 return CAMERA_ERROR_INVALID_PARAMETER;
3935         }
3936         int ret = CAMERA_ERROR_NONE;
3937
3938         camera_cli_s *pc = (camera_cli_s *)camera;
3939         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_SCENE_MODE;
3940         int sock_fd;
3941         if (pc->cb_info == NULL) {
3942                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3943                 return CAMERA_ERROR_INVALID_PARAMETER;
3944         }
3945         sock_fd = pc->cb_info->fd;
3946         int set_mode = (int)mode;
3947         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3948         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_mode);
3949         LOGD("ret : 0x%x", ret);
3950         return ret;
3951 }
3952
3953
3954 int camera_attr_enable_tag(camera_h camera, bool enable)
3955 {
3956         if (camera == NULL) {
3957                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3958                 return CAMERA_ERROR_INVALID_PARAMETER;
3959         }
3960         int ret = CAMERA_ERROR_NONE;
3961         camera_cli_s *pc = (camera_cli_s *)camera;
3962         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_ENABLE_TAG;
3963         int sock_fd;
3964         if (pc->cb_info == NULL) {
3965                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3966                 return CAMERA_ERROR_INVALID_PARAMETER;
3967         }
3968         sock_fd = pc->cb_info->fd;
3969         int set_enable = (int)enable;
3970
3971         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3972         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_enable);
3973         LOGD("ret : 0x%x", ret);
3974         return ret;
3975 }
3976
3977
3978 int camera_attr_set_tag_image_description(camera_h camera, const char *description)
3979 {
3980         if (camera == NULL) {
3981                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3982                 return CAMERA_ERROR_INVALID_PARAMETER;
3983         }
3984         if (description == NULL) {
3985                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3986                 return CAMERA_ERROR_INVALID_PARAMETER;
3987         }
3988         int ret = CAMERA_ERROR_NONE;
3989         camera_cli_s *pc = (camera_cli_s *)camera;
3990         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_TAG_IMAGE_DESCRIPTION;
3991         int sock_fd;
3992         if (pc->cb_info == NULL) {
3993                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
3994                 return CAMERA_ERROR_INVALID_PARAMETER;
3995         }
3996         sock_fd = pc->cb_info->fd;
3997         LOGD("Enter, remote_handle : %x", pc->remote_handle);
3998         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, STRING, description);
3999         LOGD("ret : 0x%x", ret);
4000         return ret;
4001 }
4002
4003
4004 int camera_attr_set_tag_orientation(camera_h camera,  camera_attr_tag_orientation_e orientation)
4005 {
4006         if (camera == NULL) {
4007                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4008                 return CAMERA_ERROR_INVALID_PARAMETER;
4009         }
4010         int ret = CAMERA_ERROR_NONE;
4011         camera_cli_s *pc = (camera_cli_s *)camera;
4012         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_TAG_ORIENTATION;
4013         int sock_fd;
4014         if (pc->cb_info == NULL) {
4015                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4016                 return CAMERA_ERROR_INVALID_PARAMETER;
4017         }
4018         sock_fd = pc->cb_info->fd;
4019         int set_orientation = (int)orientation;
4020
4021         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4022         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_orientation);
4023         LOGD("ret : 0x%x", ret);
4024         return ret;
4025 }
4026
4027
4028 int camera_attr_set_tag_software(camera_h camera,  const char *software)
4029 {
4030         if (camera == NULL) {
4031                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4032                 return CAMERA_ERROR_INVALID_PARAMETER;
4033         }
4034         if (software == NULL) {
4035                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4036                 return CAMERA_ERROR_INVALID_PARAMETER;
4037         }
4038         int ret = CAMERA_ERROR_NONE;
4039         camera_cli_s *pc = (camera_cli_s *)camera;
4040         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_TAG_SOFTWARE;
4041         int sock_fd;
4042         if (pc->cb_info == NULL) {
4043                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4044                 return CAMERA_ERROR_INVALID_PARAMETER;
4045         }
4046         sock_fd = pc->cb_info->fd;
4047         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4048         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, STRING, software);
4049         LOGD("ret : 0x%x", ret);
4050         return ret;
4051 }
4052
4053
4054 int camera_attr_set_geotag(camera_h camera, double latitude , double longitude, double altitude)
4055 {
4056         if (camera == NULL) {
4057                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4058                 return CAMERA_ERROR_INVALID_PARAMETER;
4059         }
4060         int ret = CAMERA_ERROR_NONE;
4061         camera_cli_s *pc = (camera_cli_s *)camera;
4062         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_GEOTAG;
4063         int sock_fd;
4064         if (pc->cb_info == NULL) {
4065                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4066                 return CAMERA_ERROR_INVALID_PARAMETER;
4067         }
4068         sock_fd = pc->cb_info->fd;
4069         double set_geotag[3] = { latitude, longitude, altitude };
4070
4071         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4072         muse_camera_msg_send_array(api, sock_fd, pc->cb_info, ret,
4073                                                                         set_geotag, sizeof(set_geotag), sizeof(double));
4074         LOGD("ret : 0x%x", ret);
4075         return ret;
4076 }
4077
4078
4079 int camera_attr_remove_geotag(camera_h camera)
4080 {
4081         if (camera == NULL) {
4082                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4083                 return CAMERA_ERROR_INVALID_PARAMETER;
4084         }
4085         int ret = CAMERA_ERROR_NONE;
4086         camera_cli_s *pc = (camera_cli_s *)camera;
4087         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_REMOVE_GEOTAG;
4088         int sock_fd;
4089         if (pc->cb_info == NULL) {
4090                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4091                 return CAMERA_ERROR_INVALID_PARAMETER;
4092         }
4093         sock_fd = pc->cb_info->fd;
4094         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4095         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4096         LOGD("ret : 0x%x", ret);
4097         return ret;
4098 }
4099
4100
4101 int camera_attr_set_flash_mode(camera_h camera, camera_attr_flash_mode_e mode)
4102 {
4103         if (camera == NULL) {
4104                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4105                 return CAMERA_ERROR_INVALID_PARAMETER;
4106         }
4107         int ret = CAMERA_ERROR_NONE;
4108         camera_cli_s *pc = (camera_cli_s *)camera;
4109         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_FLASH_MODE;
4110         int sock_fd;
4111         if (pc->cb_info == NULL) {
4112                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4113                 return CAMERA_ERROR_INVALID_PARAMETER;
4114         }
4115         sock_fd = pc->cb_info->fd;
4116         int set_mode = (int)mode;
4117
4118         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4119         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_mode);
4120         LOGD("ret : 0x%x", ret);
4121         return ret;
4122 }
4123
4124
4125 int camera_attr_get_zoom(camera_h camera, int *zoom)
4126 {
4127         if (camera == NULL || zoom == NULL) {
4128                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4129                 return CAMERA_ERROR_INVALID_PARAMETER;
4130         }
4131         int ret = CAMERA_ERROR_NONE;
4132
4133         camera_cli_s *pc = (camera_cli_s *)camera;
4134         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_ZOOM;
4135         int get_zoom;
4136         int sock_fd;
4137         if (pc->cb_info == NULL) {
4138                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4139                 return CAMERA_ERROR_INVALID_PARAMETER;
4140         }
4141         sock_fd = pc->cb_info->fd;
4142
4143         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4144         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4145
4146         if (ret == CAMERA_ERROR_NONE) {
4147                 muse_camera_msg_get(get_zoom, pc->cb_info->recv_msg);
4148                 *zoom = get_zoom;
4149         }
4150         LOGD("ret : 0x%x", ret);
4151         return ret;
4152 }
4153
4154
4155 int camera_attr_get_zoom_range(camera_h camera, int *min, int *max)
4156 {
4157         if (camera == NULL || min == NULL || max == NULL) {
4158                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4159                 return CAMERA_ERROR_INVALID_PARAMETER;
4160         }
4161         int ret = CAMERA_ERROR_NONE;
4162         camera_cli_s *pc = (camera_cli_s *)camera;
4163         int sock_fd;
4164         if (pc->cb_info == NULL) {
4165                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4166                 return CAMERA_ERROR_INVALID_PARAMETER;
4167         }
4168         sock_fd = pc->cb_info->fd;
4169         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_ZOOM_RANGE;
4170         int get_min;
4171         int get_max;
4172
4173         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4174         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4175
4176         if (ret == CAMERA_ERROR_NONE) {
4177                 muse_camera_msg_get(get_min, pc->cb_info->recv_msg);
4178                 muse_camera_msg_get(get_max, pc->cb_info->recv_msg);
4179                 *min = get_min;
4180                 *max = get_max;
4181         }
4182         LOGD("ret : 0x%x", ret);
4183         return ret;
4184 }
4185
4186
4187 int camera_attr_get_af_mode(camera_h camera, camera_attr_af_mode_e *mode)
4188 {
4189         if (camera == NULL || mode == NULL) {
4190                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4191                 return CAMERA_ERROR_INVALID_PARAMETER;
4192         }
4193         int ret = CAMERA_ERROR_NONE;
4194         camera_cli_s *pc = (camera_cli_s *)camera;
4195         int sock_fd;
4196         if (pc->cb_info == NULL) {
4197                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4198                 return CAMERA_ERROR_INVALID_PARAMETER;
4199         }
4200         sock_fd = pc->cb_info->fd;
4201         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_AF_MODE;
4202         int get_mode;
4203
4204         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4205         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4206
4207         if (ret == CAMERA_ERROR_NONE) {
4208                 muse_camera_msg_get(get_mode, pc->cb_info->recv_msg);
4209                 *mode = (camera_attr_af_mode_e)get_mode;
4210         }
4211         LOGD("ret : 0x%x", ret);
4212         return ret;
4213 }
4214
4215
4216 int camera_attr_get_exposure_mode(camera_h camera, camera_attr_exposure_mode_e *mode)
4217 {
4218         if (camera == NULL || mode == NULL) {
4219                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4220                 return CAMERA_ERROR_INVALID_PARAMETER;
4221         }
4222         int ret = CAMERA_ERROR_NONE;
4223         camera_cli_s *pc = (camera_cli_s *)camera;
4224         int sock_fd;
4225         if (pc->cb_info == NULL) {
4226                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4227                 return CAMERA_ERROR_INVALID_PARAMETER;
4228         }
4229         sock_fd = pc->cb_info->fd;
4230         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_EXPOSURE_MODE;
4231         int get_mode;
4232
4233         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4234         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4235
4236         if (ret == CAMERA_ERROR_NONE) {
4237                 muse_camera_msg_get(get_mode, pc->cb_info->recv_msg);
4238                 *mode = (camera_attr_exposure_mode_e)get_mode;
4239         }
4240         LOGD("ret : 0x%x", ret);
4241         return ret;
4242 }
4243
4244 int camera_attr_get_exposure(camera_h camera, int *value)
4245 {
4246         if (camera == NULL || value == NULL) {
4247                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4248                 return CAMERA_ERROR_INVALID_PARAMETER;
4249         }
4250         int ret = CAMERA_ERROR_NONE;
4251         camera_cli_s *pc = (camera_cli_s *)camera;
4252         int sock_fd;
4253         if (pc->cb_info == NULL) {
4254                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4255                 return CAMERA_ERROR_INVALID_PARAMETER;
4256         }
4257         sock_fd = pc->cb_info->fd;
4258         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_EXPOSURE;
4259         int get_value;
4260
4261         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4262         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4263
4264         if (ret == CAMERA_ERROR_NONE) {
4265                 muse_camera_msg_get(get_value, pc->cb_info->recv_msg);
4266                 *value = get_value;
4267         }
4268         LOGD("ret : 0x%x", ret);
4269         return ret;
4270 }
4271
4272
4273 int camera_attr_get_exposure_range(camera_h camera, int *min, int *max)
4274 {
4275         if (camera == NULL || min == NULL || max == NULL) {
4276                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4277                 return CAMERA_ERROR_INVALID_PARAMETER;
4278         }
4279         int ret = CAMERA_ERROR_NONE;
4280         camera_cli_s *pc = (camera_cli_s *)camera;
4281         int sock_fd;
4282         if (pc->cb_info == NULL) {
4283                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4284                 return CAMERA_ERROR_INVALID_PARAMETER;
4285         }
4286         sock_fd = pc->cb_info->fd;
4287         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_EXPOSURE_RANGE;
4288         int get_min;
4289         int get_max;
4290
4291         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4292         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4293
4294         if (ret == CAMERA_ERROR_NONE) {
4295                 muse_camera_msg_get(get_min, pc->cb_info->recv_msg);
4296                 muse_camera_msg_get(get_max, pc->cb_info->recv_msg);
4297                 *min = get_min;
4298                 *max = get_max;
4299         }
4300         LOGD("ret : 0x%x", ret);
4301         return ret;
4302 }
4303
4304
4305 int camera_attr_get_iso(camera_h camera, camera_attr_iso_e *iso)
4306 {
4307         if (camera == NULL || iso == NULL) {
4308                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4309                 return CAMERA_ERROR_INVALID_PARAMETER;
4310         }
4311         int ret = CAMERA_ERROR_NONE;
4312         camera_cli_s *pc = (camera_cli_s *)camera;
4313         int sock_fd;
4314         if (pc->cb_info == NULL) {
4315                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4316                 return CAMERA_ERROR_INVALID_PARAMETER;
4317         }
4318         sock_fd = pc->cb_info->fd;
4319         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_ISO;
4320         int get_iso;
4321
4322         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4323         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4324
4325         if (ret == CAMERA_ERROR_NONE) {
4326                 muse_camera_msg_get(get_iso, pc->cb_info->recv_msg);
4327                 *iso = (camera_attr_iso_e)get_iso;
4328         }
4329         LOGD("ret : 0x%x", ret);
4330         return ret;
4331 }
4332
4333
4334 int camera_attr_get_brightness(camera_h camera,  int *level)
4335 {
4336         if (camera == NULL || level == NULL) {
4337                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4338                 return CAMERA_ERROR_INVALID_PARAMETER;
4339         }
4340         int ret = CAMERA_ERROR_NONE;
4341         camera_cli_s *pc = (camera_cli_s *)camera;
4342         int sock_fd;
4343         if (pc->cb_info == NULL) {
4344                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4345                 return CAMERA_ERROR_INVALID_PARAMETER;
4346         }
4347         sock_fd = pc->cb_info->fd;
4348         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_BRIGHTNESS;
4349         int get_level;
4350
4351         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4352         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4353
4354         if (ret == CAMERA_ERROR_NONE) {
4355                 muse_camera_msg_get(get_level, pc->cb_info->recv_msg);
4356                 *level = get_level;
4357         }
4358         LOGD("ret : 0x%x", ret);
4359         return ret;
4360 }
4361
4362
4363 int camera_attr_get_brightness_range(camera_h camera, int *min, int *max)
4364 {
4365         if (camera == NULL || min == NULL || max == NULL) {
4366                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4367                 return CAMERA_ERROR_INVALID_PARAMETER;
4368         }
4369         int ret = CAMERA_ERROR_NONE;
4370         camera_cli_s *pc = (camera_cli_s *)camera;
4371         int sock_fd;
4372         if (pc->cb_info == NULL) {
4373                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4374                 return CAMERA_ERROR_INVALID_PARAMETER;
4375         }
4376         sock_fd = pc->cb_info->fd;
4377         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_BRIGHTNESS_RANGE;
4378         int get_min;
4379         int get_max;
4380
4381         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4382         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4383
4384         if (ret == CAMERA_ERROR_NONE) {
4385                 muse_camera_msg_get(get_min, pc->cb_info->recv_msg);
4386                 muse_camera_msg_get(get_max, pc->cb_info->recv_msg);
4387                 *min = get_min;
4388                 *max = get_max;
4389         }
4390         LOGD("ret : 0x%x", ret);
4391         return ret;
4392 }
4393
4394
4395 int camera_attr_get_contrast(camera_h camera,  int *level)
4396 {
4397         if (camera == NULL || level == NULL) {
4398                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4399                 return CAMERA_ERROR_INVALID_PARAMETER;
4400         }
4401         int ret = CAMERA_ERROR_NONE;
4402         camera_cli_s *pc = (camera_cli_s *)camera;
4403         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_CONTRAST;
4404         int sock_fd;
4405         if (pc->cb_info == NULL) {
4406                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4407                 return CAMERA_ERROR_INVALID_PARAMETER;
4408         }
4409         sock_fd = pc->cb_info->fd;
4410         int get_level;
4411
4412         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4413         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4414
4415         if (ret == CAMERA_ERROR_NONE) {
4416                 muse_camera_msg_get(get_level, pc->cb_info->recv_msg);
4417                 *level = get_level;
4418         }
4419         LOGD("ret : 0x%x", ret);
4420         return ret;
4421 }
4422
4423
4424 int camera_attr_get_contrast_range(camera_h camera, int *min , int *max)
4425 {
4426         if (camera == NULL || min == NULL || max == NULL) {
4427                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4428                 return CAMERA_ERROR_INVALID_PARAMETER;
4429         }
4430         int ret = CAMERA_ERROR_NONE;
4431         camera_cli_s *pc = (camera_cli_s *)camera;
4432         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_CONTRAST_RANGE;
4433         int sock_fd;
4434         if (pc->cb_info == NULL) {
4435                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4436                 return CAMERA_ERROR_INVALID_PARAMETER;
4437         }
4438         sock_fd = pc->cb_info->fd;
4439         int get_min;
4440         int get_max;
4441
4442         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4443         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4444
4445         if (ret == CAMERA_ERROR_NONE) {
4446                 muse_camera_msg_get(get_min, pc->cb_info->recv_msg);
4447                 muse_camera_msg_get(get_max, pc->cb_info->recv_msg);
4448                 *min = get_min;
4449                 *max = get_max;
4450         }
4451         LOGD("ret : 0x%x", ret);
4452         return ret;
4453 }
4454
4455
4456 int camera_attr_get_whitebalance(camera_h camera,  camera_attr_whitebalance_e *wb)
4457 {
4458         if (camera == NULL || wb == NULL) {
4459                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4460                 return CAMERA_ERROR_INVALID_PARAMETER;
4461         }
4462         int ret = CAMERA_ERROR_NONE;
4463         camera_cli_s *pc = (camera_cli_s *)camera;
4464         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_WHITEBALANCE;
4465         int sock_fd;
4466         if (pc->cb_info == NULL) {
4467                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4468                 return CAMERA_ERROR_INVALID_PARAMETER;
4469         }
4470         sock_fd = pc->cb_info->fd;
4471         int get_wb;
4472
4473         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4474         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4475
4476         if (ret == CAMERA_ERROR_NONE) {
4477                 muse_camera_msg_get(get_wb, pc->cb_info->recv_msg);
4478                 *wb = (camera_attr_whitebalance_e)get_wb;
4479         }
4480         LOGD("ret : 0x%x", ret);
4481         return ret;
4482 }
4483
4484
4485 int camera_attr_get_effect(camera_h camera, camera_attr_effect_mode_e *effect)
4486 {
4487         if (camera == NULL || effect == NULL) {
4488                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4489                 return CAMERA_ERROR_INVALID_PARAMETER;
4490         }
4491
4492         int ret = CAMERA_ERROR_NONE;
4493         camera_cli_s *pc = (camera_cli_s *)camera;
4494         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_EFFECT;
4495         int sock_fd;
4496         if (pc->cb_info == NULL) {
4497                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4498                 return CAMERA_ERROR_INVALID_PARAMETER;
4499         }
4500         sock_fd = pc->cb_info->fd;
4501         int get_effect;
4502
4503         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4504         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4505
4506         if (ret == CAMERA_ERROR_NONE) {
4507                 muse_camera_msg_get(get_effect, pc->cb_info->recv_msg);
4508                 *effect = (camera_attr_effect_mode_e)get_effect;
4509         }
4510         LOGD("ret : 0x%x", ret);
4511         return ret;
4512 }
4513
4514
4515 int camera_attr_get_scene_mode(camera_h camera,  camera_attr_scene_mode_e *mode)
4516 {
4517         if (camera == NULL || mode == NULL) {
4518                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4519                 return CAMERA_ERROR_INVALID_PARAMETER;
4520         }
4521
4522         int ret = CAMERA_ERROR_NONE;
4523         camera_cli_s *pc = (camera_cli_s *)camera;
4524         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_SCENE_MODE;
4525         int sock_fd;
4526         if (pc->cb_info == NULL) {
4527                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4528                 return CAMERA_ERROR_INVALID_PARAMETER;
4529         }
4530         sock_fd = pc->cb_info->fd;
4531         int get_mode;
4532
4533         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4534         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4535
4536         if (ret == CAMERA_ERROR_NONE) {
4537                 muse_camera_msg_get(get_mode, pc->cb_info->recv_msg);
4538                 *mode = (camera_attr_scene_mode_e)get_mode;
4539         }
4540         LOGD("ret : 0x%x", ret);
4541         return ret;
4542 }
4543
4544
4545 int camera_attr_is_enabled_tag(camera_h camera,  bool *enable)
4546 {
4547         if (camera == NULL || enable == NULL) {
4548                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4549                 return CAMERA_ERROR_INVALID_PARAMETER;
4550         }
4551
4552         int ret = CAMERA_ERROR_NONE;
4553         camera_cli_s *pc = (camera_cli_s *)camera;
4554         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_ENABLED_TAG;
4555         int sock_fd;
4556         if (pc->cb_info == NULL) {
4557                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4558                 return CAMERA_ERROR_INVALID_PARAMETER;
4559         }
4560         sock_fd = pc->cb_info->fd;
4561         int get_enabled;
4562
4563         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4564         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4565
4566         if (ret == CAMERA_ERROR_NONE) {
4567                 muse_camera_msg_get(get_enabled, pc->cb_info->recv_msg);
4568                 *enable = (bool)get_enabled;
4569         }
4570         LOGD("ret : 0x%x", ret);
4571         return ret;
4572 }
4573
4574
4575 int camera_attr_get_tag_image_description(camera_h camera,  char **description)
4576 {
4577         if (camera == NULL || description == NULL) {
4578                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4579                 return CAMERA_ERROR_INVALID_PARAMETER;
4580         }
4581
4582         int ret = CAMERA_ERROR_NONE;
4583         camera_cli_s *pc = (camera_cli_s *)camera;
4584         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_TAG_IMAGE_DESCRIPTION;
4585         int sock_fd;
4586         if (pc->cb_info == NULL) {
4587                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4588                 return CAMERA_ERROR_INVALID_PARAMETER;
4589         }
4590         sock_fd = pc->cb_info->fd;
4591         char get_description[MUSE_CAMERA_MSG_MAX_LENGTH] = {0,};
4592
4593         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4594         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4595
4596         if (ret == CAMERA_ERROR_NONE) {
4597                 muse_camera_msg_get_string(get_description, pc->cb_info->recv_msg);
4598                 *description = strdup(get_description);
4599         }
4600         LOGD("ret : 0x%x", ret);
4601         return ret;
4602 }
4603
4604
4605 int camera_attr_get_tag_orientation(camera_h camera, camera_attr_tag_orientation_e *orientation)
4606 {
4607         if (camera == NULL || orientation == NULL) {
4608                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4609                 return CAMERA_ERROR_INVALID_PARAMETER;
4610         }
4611
4612         int ret = CAMERA_ERROR_NONE;
4613         camera_cli_s *pc = (camera_cli_s *)camera;
4614         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_TAG_ORIENTATION;
4615         int sock_fd;
4616         if (pc->cb_info == NULL) {
4617                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4618                 return CAMERA_ERROR_INVALID_PARAMETER;
4619         }
4620         sock_fd = pc->cb_info->fd;
4621         int get_orientation;
4622
4623         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4624         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4625
4626         if (ret == CAMERA_ERROR_NONE) {
4627                 muse_camera_msg_get(get_orientation, pc->cb_info->recv_msg);
4628                 *orientation = (camera_attr_tag_orientation_e)get_orientation;
4629                 LOGD("success, orientation : %d", *orientation);
4630         }
4631         LOGD("ret : 0x%x", ret);
4632         return ret;
4633 }
4634
4635
4636 int camera_attr_get_tag_software(camera_h camera, char **software)
4637 {
4638         if (camera == NULL || software == NULL) {
4639                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4640                 return CAMERA_ERROR_INVALID_PARAMETER;
4641         }
4642
4643         int ret = CAMERA_ERROR_NONE;
4644         camera_cli_s *pc = (camera_cli_s *)camera;
4645         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_TAG_SOFTWARE;
4646         int sock_fd;
4647         if (pc->cb_info == NULL) {
4648                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4649                 return CAMERA_ERROR_INVALID_PARAMETER;
4650         }
4651         sock_fd = pc->cb_info->fd;
4652         char get_software[MUSE_CAMERA_MSG_MAX_LENGTH] = {0,};
4653
4654         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4655         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4656
4657         if (ret == CAMERA_ERROR_NONE) {
4658                 muse_camera_msg_get_string(get_software, pc->cb_info->recv_msg);
4659                 *software = strdup(get_software);
4660         }
4661         LOGD("ret : 0x%x", ret);
4662         return ret;
4663 }
4664
4665
4666 int camera_attr_get_geotag(camera_h camera, double *latitude , double *longitude, double *altitude)
4667 {
4668         if (camera == NULL || latitude == NULL || longitude == NULL || altitude == NULL) {
4669                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4670                 return CAMERA_ERROR_INVALID_PARAMETER;
4671         }
4672
4673         int ret = CAMERA_ERROR_NONE;
4674         camera_cli_s *pc = (camera_cli_s *)camera;
4675         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_GEOTAG;
4676         double get_geotag[3] = {0,};
4677         int sock_fd;
4678         if (pc->cb_info == NULL) {
4679                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4680                 return CAMERA_ERROR_INVALID_PARAMETER;
4681         }
4682         sock_fd = pc->cb_info->fd;
4683         int valid = 0;
4684         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4685         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4686
4687         if (ret == CAMERA_ERROR_NONE) {
4688                 muse_camera_msg_get_array(get_geotag, pc->cb_info->recv_msg);
4689                 *latitude = get_geotag[0];
4690                 *longitude = get_geotag[1];
4691                 *altitude = get_geotag[2];
4692         } else {
4693                 LOGE("Returned value is not valid : 0x%x", valid);
4694         }
4695
4696         LOGD("ret : 0x%x", ret);
4697
4698         return ret;
4699 }
4700
4701
4702 int camera_attr_get_flash_mode(camera_h camera,  camera_attr_flash_mode_e *mode)
4703 {
4704         if (camera == NULL || mode == NULL) {
4705                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4706                 return CAMERA_ERROR_INVALID_PARAMETER;
4707         }
4708
4709         int ret = CAMERA_ERROR_NONE;
4710         camera_cli_s *pc = (camera_cli_s *)camera;
4711         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_FLASH_MODE;
4712         int sock_fd;
4713         if (pc->cb_info == NULL) {
4714                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4715                 return CAMERA_ERROR_INVALID_PARAMETER;
4716         }
4717         sock_fd = pc->cb_info->fd;
4718         int get_mode;
4719
4720         LOGD("Enter, remote_handle : %x", pc->remote_handle);
4721         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4722
4723         if (ret == CAMERA_ERROR_NONE) {
4724                 muse_camera_msg_get(get_mode, pc->cb_info->recv_msg);
4725                 *mode = (camera_attr_flash_mode_e)get_mode;
4726         }
4727         LOGD("ret : 0x%x", ret);
4728         return ret;
4729 }
4730
4731
4732 int camera_attr_foreach_supported_af_mode(camera_h camera, camera_attr_supported_af_mode_cb foreach_cb, void *user_data)
4733 {
4734         if (camera == NULL || foreach_cb == NULL) {
4735                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4736                 return CAMERA_ERROR_INVALID_PARAMETER;
4737         }
4738         int ret = CAMERA_ERROR_NONE;
4739
4740         camera_cli_s *pc = (camera_cli_s *)camera;
4741         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_AF_MODE;
4742
4743         LOGD("Enter, handle :%x", pc->remote_handle);
4744
4745         int sock_fd;
4746         if (pc->cb_info == NULL) {
4747                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4748                 return CAMERA_ERROR_INVALID_PARAMETER;
4749         }
4750         sock_fd = pc->cb_info->fd;
4751         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_AF_MODE] = foreach_cb;
4752         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_AF_MODE] = user_data;
4753
4754         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4755         LOGD("ret : 0x%x", ret);
4756         return ret;
4757 }
4758
4759
4760 int camera_attr_foreach_supported_exposure_mode(camera_h camera, camera_attr_supported_exposure_mode_cb foreach_cb , void *user_data)
4761 {
4762         if (camera == NULL || foreach_cb == NULL) {
4763                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4764                 return CAMERA_ERROR_INVALID_PARAMETER;
4765         }
4766         int ret = CAMERA_ERROR_NONE;
4767
4768         camera_cli_s *pc = (camera_cli_s *)camera;
4769         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_EXPOSURE_MODE;
4770
4771         LOGD("Enter, handle :%x", pc->remote_handle);
4772
4773         int sock_fd;
4774         if (pc->cb_info == NULL) {
4775                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4776                 return CAMERA_ERROR_INVALID_PARAMETER;
4777         }
4778         sock_fd = pc->cb_info->fd;
4779         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EXPOSURE_MODE] = foreach_cb;
4780         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EXPOSURE_MODE] = user_data;
4781
4782         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4783         LOGD("ret : 0x%x", ret);
4784         return ret;
4785 }
4786
4787
4788 int camera_attr_foreach_supported_iso(camera_h camera, camera_attr_supported_iso_cb foreach_cb, void *user_data)
4789 {
4790         if (camera == NULL || foreach_cb == NULL) {
4791                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4792                 return CAMERA_ERROR_INVALID_PARAMETER;
4793         }
4794         int ret = CAMERA_ERROR_NONE;
4795
4796         camera_cli_s *pc = (camera_cli_s *)camera;
4797         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_ISO;
4798
4799         LOGD("Enter, handle :%x", pc->remote_handle);
4800
4801         int sock_fd;
4802         if (pc->cb_info == NULL) {
4803                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4804                 return CAMERA_ERROR_INVALID_PARAMETER;
4805         }
4806         sock_fd = pc->cb_info->fd;
4807         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_ISO] = foreach_cb;
4808         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_ISO] = user_data;
4809
4810         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4811         LOGD("ret : 0x%x", ret);
4812         return ret;
4813 }
4814
4815
4816 int camera_attr_foreach_supported_whitebalance(camera_h camera, camera_attr_supported_whitebalance_cb foreach_cb , void *user_data)
4817 {
4818         if (camera == NULL || foreach_cb == NULL) {
4819                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4820                 return CAMERA_ERROR_INVALID_PARAMETER;
4821         }
4822         int ret = CAMERA_ERROR_NONE;
4823
4824         camera_cli_s *pc = (camera_cli_s *)camera;
4825         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_WHITEBALANCE;
4826
4827         LOGD("Enter, handle :%x", pc->remote_handle);
4828
4829         int sock_fd;
4830         if (pc->cb_info == NULL) {
4831                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4832                 return CAMERA_ERROR_INVALID_PARAMETER;
4833         }
4834         sock_fd = pc->cb_info->fd;
4835         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_WHITEBALANCE] = foreach_cb;
4836         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_WHITEBALANCE] = user_data;
4837
4838         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4839         LOGD("ret : 0x%x", ret);
4840         return ret;
4841 }
4842
4843
4844 int camera_attr_foreach_supported_effect(camera_h camera, camera_attr_supported_effect_cb foreach_cb , void *user_data)
4845 {
4846         if (camera == NULL || foreach_cb == NULL) {
4847                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4848                 return CAMERA_ERROR_INVALID_PARAMETER;
4849         }
4850         int ret = CAMERA_ERROR_NONE;
4851
4852         camera_cli_s *pc = (camera_cli_s *)camera;
4853         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_EFFECT;
4854
4855         LOGD("Enter, handle :%x", pc->remote_handle);
4856
4857         int sock_fd;
4858         if (pc->cb_info == NULL) {
4859                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4860                 return CAMERA_ERROR_INVALID_PARAMETER;
4861         }
4862         sock_fd = pc->cb_info->fd;
4863         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EFFECT] = foreach_cb;
4864         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EFFECT] = user_data;
4865
4866         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4867         LOGD("ret : 0x%x", ret);
4868         return ret;
4869 }
4870
4871
4872 int camera_attr_foreach_supported_scene_mode(camera_h camera, camera_attr_supported_scene_mode_cb foreach_cb , void *user_data)
4873 {
4874         if (camera == NULL || foreach_cb == NULL) {
4875                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4876                 return CAMERA_ERROR_INVALID_PARAMETER;
4877         }
4878         int ret = CAMERA_ERROR_NONE;
4879
4880         camera_cli_s *pc = (camera_cli_s *)camera;
4881         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_SCENE_MODE;
4882
4883         LOGD("Enter, handle :%x", pc->remote_handle);
4884
4885         int sock_fd;
4886         if (pc->cb_info == NULL) {
4887                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4888                 return CAMERA_ERROR_INVALID_PARAMETER;
4889         }
4890         sock_fd = pc->cb_info->fd;
4891         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_SCENE_MODE] = foreach_cb;
4892         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_SCENE_MODE] = user_data;
4893
4894         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4895         LOGD("ret : 0x%x", ret);
4896         return ret;
4897 }
4898
4899
4900 int camera_attr_foreach_supported_flash_mode(camera_h camera, camera_attr_supported_flash_mode_cb foreach_cb , void *user_data)
4901 {
4902         if (camera == NULL || foreach_cb == NULL) {
4903                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4904                 return CAMERA_ERROR_INVALID_PARAMETER;
4905         }
4906         int ret = CAMERA_ERROR_NONE;
4907
4908         camera_cli_s *pc = (camera_cli_s *)camera;
4909         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_FLASH_MODE;
4910
4911         LOGD("Enter, handle :%x", pc->remote_handle);
4912
4913         int sock_fd;
4914         if (pc->cb_info == NULL) {
4915                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4916                 return CAMERA_ERROR_INVALID_PARAMETER;
4917         }
4918         sock_fd = pc->cb_info->fd;
4919         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FLASH_MODE] = foreach_cb;
4920         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FLASH_MODE] = user_data;
4921
4922         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4923         LOGD("ret : 0x%x", ret);
4924         return ret;
4925 }
4926
4927
4928 int camera_attr_foreach_supported_fps(camera_h camera, camera_attr_supported_fps_cb foreach_cb , void *user_data)
4929 {
4930         if (camera == NULL || foreach_cb == NULL) {
4931                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4932                 return CAMERA_ERROR_INVALID_PARAMETER;
4933         }
4934         int ret = CAMERA_ERROR_NONE;
4935
4936         camera_cli_s *pc = (camera_cli_s *)camera;
4937         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_FPS;
4938         int sock_fd;
4939         if (pc->cb_info == NULL) {
4940                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4941                 return CAMERA_ERROR_INVALID_PARAMETER;
4942         }
4943         sock_fd = pc->cb_info->fd;
4944         LOGD("Enter, handle :%x", pc->remote_handle);
4945         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS] = foreach_cb;
4946         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS] = user_data;
4947
4948         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4949         LOGD("Enter, handle :%x", pc->remote_handle);
4950         return ret;
4951 }
4952
4953 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)
4954 {
4955         if (camera == NULL || foreach_cb == NULL) {
4956                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4957                 return CAMERA_ERROR_INVALID_PARAMETER;
4958         }
4959         int ret = CAMERA_ERROR_NONE;
4960
4961         camera_cli_s *pc = (camera_cli_s *)camera;
4962         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_FPS_BY_RESOLUTION;
4963         int sock_fd;
4964         if (pc->cb_info == NULL) {
4965                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4966                 return CAMERA_ERROR_INVALID_PARAMETER;
4967         }
4968         sock_fd = pc->cb_info->fd;
4969         LOGD("Enter, handle :%x", pc->remote_handle);
4970         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS_BY_RESOLUTION] = foreach_cb;
4971         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS_BY_RESOLUTION] = user_data;
4972
4973         muse_camera_msg_send2(api, sock_fd, pc->cb_info, ret, INT, width, INT, height);
4974         LOGD("ret : 0x%x", ret);
4975         return ret;
4976 }
4977
4978 int camera_attr_foreach_supported_stream_flip(camera_h camera, camera_attr_supported_stream_flip_cb foreach_cb, void *user_data)
4979 {
4980         if (camera == NULL || foreach_cb == NULL) {
4981                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4982                 return CAMERA_ERROR_INVALID_PARAMETER;
4983         }
4984         int ret = CAMERA_ERROR_NONE;
4985
4986         camera_cli_s *pc = (camera_cli_s *)camera;
4987         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_STREAM_FLIP;
4988         int sock_fd;
4989         if (pc->cb_info == NULL) {
4990                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
4991                 return CAMERA_ERROR_INVALID_PARAMETER;
4992         }
4993         sock_fd = pc->cb_info->fd;
4994         LOGD("Enter, handle :%x", pc->remote_handle);
4995         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_FLIP] = foreach_cb;
4996         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_FLIP] = user_data;
4997
4998         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
4999         LOGD("ret : 0x%x", ret);
5000         return ret;
5001 }
5002
5003
5004 int camera_attr_foreach_supported_stream_rotation(camera_h camera, camera_attr_supported_stream_rotation_cb foreach_cb, void *user_data)
5005 {
5006         if (camera == NULL || foreach_cb == NULL) {
5007                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5008                 return CAMERA_ERROR_INVALID_PARAMETER;
5009         }
5010         int ret = CAMERA_ERROR_NONE;
5011
5012         camera_cli_s *pc = (camera_cli_s *)camera;
5013         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_STREAM_ROTATION;
5014         int sock_fd;
5015         if (pc->cb_info == NULL) {
5016                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5017                 return CAMERA_ERROR_INVALID_PARAMETER;
5018         }
5019         sock_fd = pc->cb_info->fd;
5020         LOGD("Enter, handle :%x", pc->remote_handle);
5021         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_ROTATION] = foreach_cb;
5022         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_ROTATION] = user_data;
5023
5024         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
5025         LOGD("ret : 0x%x", ret);
5026         return ret;
5027 }
5028
5029
5030 int camera_attr_set_stream_rotation(camera_h camera , camera_rotation_e rotation)
5031 {
5032         if (camera == NULL) {
5033                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5034                 return CAMERA_ERROR_INVALID_PARAMETER;
5035         }
5036
5037         int ret = CAMERA_ERROR_NONE;
5038         camera_cli_s *pc = (camera_cli_s *)camera;
5039         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_STREAM_ROTATION;
5040         int sock_fd;
5041         if (pc->cb_info == NULL) {
5042                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5043                 return CAMERA_ERROR_INVALID_PARAMETER;
5044         }
5045         sock_fd = pc->cb_info->fd;
5046         int set_rotation = (int)rotation;
5047
5048         LOGD("Enter, remote_handle : %x", pc->remote_handle);
5049         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_rotation);
5050         LOGD("ret : 0x%x", ret);
5051         return ret;
5052 }
5053
5054
5055 int camera_attr_get_stream_rotation(camera_h camera , camera_rotation_e *rotation)
5056 {
5057         if (camera == NULL || rotation == NULL) {
5058                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5059                 return CAMERA_ERROR_INVALID_PARAMETER;
5060         }
5061
5062         int ret = CAMERA_ERROR_NONE;
5063         camera_cli_s *pc = (camera_cli_s *)camera;
5064         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_STREAM_ROTATION;
5065         int sock_fd;
5066         if (pc->cb_info == NULL) {
5067                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5068                 return CAMERA_ERROR_INVALID_PARAMETER;
5069         }
5070         sock_fd = pc->cb_info->fd;
5071         int get_rotation;
5072
5073         LOGD("Enter, remote_handle : %x", pc->remote_handle);
5074         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
5075
5076         if (ret == CAMERA_ERROR_NONE) {
5077                 muse_camera_msg_get(get_rotation, pc->cb_info->recv_msg);
5078                 *rotation = (camera_rotation_e)get_rotation;
5079         }
5080         LOGD("ret : 0x%x", ret);
5081         return ret;
5082 }
5083
5084
5085 int camera_attr_set_stream_flip(camera_h camera , camera_flip_e flip)
5086 {
5087         if (camera == NULL) {
5088                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5089                 return CAMERA_ERROR_INVALID_PARAMETER;
5090         }
5091
5092         int ret = CAMERA_ERROR_NONE;
5093         camera_cli_s *pc = (camera_cli_s *)camera;
5094         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_STREAM_FLIP;
5095         int sock_fd;
5096         if (pc->cb_info == NULL) {
5097                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5098                 return CAMERA_ERROR_INVALID_PARAMETER;
5099         }
5100         sock_fd = pc->cb_info->fd;
5101         int set_flip = (int)flip;
5102
5103         LOGD("Enter, remote_handle : %x", pc->remote_handle);
5104         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_flip);
5105         LOGD("ret : 0x%x", ret);
5106         return ret;
5107 }
5108
5109
5110 int camera_attr_get_stream_flip(camera_h camera , camera_flip_e *flip)
5111 {
5112         if (camera == NULL || flip == NULL) {
5113                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5114                 return CAMERA_ERROR_INVALID_PARAMETER;
5115         }
5116
5117         int ret = CAMERA_ERROR_NONE;
5118         camera_cli_s *pc = (camera_cli_s *)camera;
5119         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_STREAM_FLIP;
5120         int sock_fd;
5121         if (pc->cb_info == NULL) {
5122                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5123                 return CAMERA_ERROR_INVALID_PARAMETER;
5124         }
5125         sock_fd = pc->cb_info->fd;
5126         int get_flip;
5127
5128         LOGD("Enter, remote_handle : %x", pc->remote_handle);
5129         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
5130
5131         if (ret == CAMERA_ERROR_NONE) {
5132                 muse_camera_msg_get(get_flip, pc->cb_info->recv_msg);
5133                 *flip = (camera_flip_e)get_flip;
5134         }
5135         LOGD("ret : 0x%x", ret);
5136         return ret;
5137 }
5138
5139 int camera_attr_set_hdr_mode(camera_h camera, camera_attr_hdr_mode_e mode)
5140 {
5141         if (camera == NULL) {
5142                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5143                 return CAMERA_ERROR_INVALID_PARAMETER;
5144         }
5145
5146         int ret = CAMERA_ERROR_NONE;
5147         camera_cli_s *pc = (camera_cli_s *)camera;
5148         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_HDR_MODE;
5149         int sock_fd;
5150         if (pc->cb_info == NULL) {
5151                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5152                 return CAMERA_ERROR_INVALID_PARAMETER;
5153         }
5154         sock_fd = pc->cb_info->fd;
5155         int set_mode = (int)mode;
5156
5157         LOGD("Enter, remote_handle : %x", pc->remote_handle);
5158         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_mode);
5159         LOGD("ret : 0x%x", ret);
5160         return ret;
5161 }
5162
5163
5164 int camera_attr_get_hdr_mode(camera_h camera, camera_attr_hdr_mode_e *mode)
5165 {
5166         if (camera == NULL) {
5167                 LOGE("INVALID_PARAMETER(0x%08x) - handle", CAMERA_ERROR_INVALID_PARAMETER);
5168                 return CAMERA_ERROR_INVALID_PARAMETER;
5169         }
5170         if (mode == NULL) {
5171                 LOGE("CAMERA_ERROR_NOT_SUPPORTED(0x%08x) - mode", CAMERA_ERROR_NOT_SUPPORTED);
5172                 return CAMERA_ERROR_NOT_SUPPORTED;
5173         }
5174         int ret = CAMERA_ERROR_NONE;
5175         camera_cli_s *pc = (camera_cli_s *)camera;
5176         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_HDR_MODE;
5177         int sock_fd;
5178         if (pc->cb_info == NULL) {
5179                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5180                 return CAMERA_ERROR_INVALID_PARAMETER;
5181         }
5182         sock_fd = pc->cb_info->fd;
5183         int get_mode;
5184
5185         LOGD("Enter, remote_handle : %x", pc->remote_handle);
5186         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
5187
5188         if (ret == CAMERA_ERROR_NONE) {
5189                 muse_camera_msg_get(get_mode, pc->cb_info->recv_msg);
5190                 *mode = (camera_attr_hdr_mode_e)get_mode;
5191         }
5192         LOGD("ret : 0x%x", ret);
5193         return ret;
5194 }
5195
5196
5197 bool camera_attr_is_supported_hdr_capture(camera_h camera)
5198 {
5199         if (camera == NULL) {
5200                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5201                 return false;
5202         }
5203
5204         int ret = CAMERA_ERROR_NONE;
5205         camera_cli_s *pc = (camera_cli_s *)camera;
5206         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_SUPPORTED_HDR_CAPTURE;
5207         int sock_fd;
5208         if (pc->cb_info == NULL) {
5209                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5210                 return CAMERA_ERROR_INVALID_PARAMETER;
5211         }
5212         sock_fd = pc->cb_info->fd;
5213         LOGD("Enter, remote_handle : %x", pc->remote_handle);
5214         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
5215         LOGD("ret : 0x%x", ret);
5216         return (bool)ret;
5217 }
5218
5219
5220 int camera_attr_set_hdr_capture_progress_cb(camera_h camera, camera_attr_hdr_progress_cb callback, void* user_data)
5221 {
5222         if (camera == NULL) {
5223                 LOGE("INVALID_PARAMETER(0x%08x) - handle", CAMERA_ERROR_INVALID_PARAMETER);
5224                 return CAMERA_ERROR_INVALID_PARAMETER;
5225         }
5226         if (callback == NULL) {
5227                 LOGE("CAMERA_ERROR_NOT_SUPPORTED(0x%08x) - callback", CAMERA_ERROR_NOT_SUPPORTED);
5228                 return CAMERA_ERROR_NOT_SUPPORTED;
5229         }
5230         int ret = CAMERA_ERROR_NONE;
5231
5232         camera_cli_s *pc = (camera_cli_s *)camera;
5233         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_HDR_CAPTURE_PROGRESS_CB;
5234         int sock_fd;
5235         if (pc->cb_info == NULL) {
5236                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5237                 return CAMERA_ERROR_INVALID_PARAMETER;
5238         }
5239         sock_fd = pc->cb_info->fd;
5240         LOGD("Enter, handle :%x", pc->remote_handle);
5241
5242         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_HDR_PROGRESS] = callback;
5243         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_HDR_PROGRESS] = user_data;
5244
5245         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
5246         LOGD("ret : 0x%x", ret);
5247         return ret;
5248 }
5249
5250
5251 int camera_attr_unset_hdr_capture_progress_cb(camera_h camera)
5252 {
5253         if (camera == NULL) {
5254                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5255                 return CAMERA_ERROR_INVALID_PARAMETER;
5256         }
5257
5258         int ret = CAMERA_ERROR_NONE;
5259
5260         camera_cli_s *pc = (camera_cli_s *)camera;
5261         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_UNSET_HDR_CAPTURE_PROGRESS_CB;
5262         int sock_fd;
5263         if (pc->cb_info == NULL) {
5264                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5265                 return CAMERA_ERROR_INVALID_PARAMETER;
5266         }
5267         sock_fd = pc->cb_info->fd;
5268         LOGD("Enter, handle :%x", pc->remote_handle);
5269
5270         pc->cb_info->user_cb[MUSE_CAMERA_EVENT_TYPE_HDR_PROGRESS] = (void *)NULL;
5271         pc->cb_info->user_data[MUSE_CAMERA_EVENT_TYPE_HDR_PROGRESS] = (void *)NULL;
5272
5273         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
5274         LOGD("ret : 0x%x", ret);
5275         return ret;
5276 }
5277
5278
5279 int camera_attr_enable_anti_shake(camera_h camera, bool enable)
5280 {
5281         if (camera == NULL) {
5282                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5283                 return CAMERA_ERROR_INVALID_PARAMETER;
5284         }
5285
5286         int ret = CAMERA_ERROR_NONE;
5287         camera_cli_s *pc = (camera_cli_s *)camera;
5288         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_ENABLE_ANTI_SHAKE;
5289         int sock_fd;
5290         if (pc->cb_info == NULL) {
5291                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5292                 return CAMERA_ERROR_INVALID_PARAMETER;
5293         }
5294         sock_fd = pc->cb_info->fd;
5295         int set_enable = (int)enable;
5296
5297         LOGD("Enter, remote_handle : %x", pc->remote_handle);
5298         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_enable);
5299         LOGD("ret : 0x%x", ret);
5300         return ret;
5301 }
5302
5303
5304 int camera_attr_is_enabled_anti_shake(camera_h camera , bool *enabled)
5305 {
5306         if (camera == NULL) {
5307                 LOGE("INVALID_PARAMETER(0x%08x) - handle", CAMERA_ERROR_INVALID_PARAMETER);
5308                 return CAMERA_ERROR_INVALID_PARAMETER;
5309         }
5310         if (enabled == NULL) {
5311                 LOGE("INVALID_PARAMETER(0x%08x) - enabled", CAMERA_ERROR_INVALID_PARAMETER);
5312                 return CAMERA_ERROR_NOT_SUPPORTED;
5313         }
5314         int ret = CAMERA_ERROR_NONE;
5315         camera_cli_s *pc = (camera_cli_s *)camera;
5316         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_ENABLED_ANTI_SHAKE;
5317         int sock_fd;
5318         if (pc->cb_info == NULL) {
5319                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5320                 return CAMERA_ERROR_INVALID_PARAMETER;
5321         }
5322         sock_fd = pc->cb_info->fd;
5323         int get_enabled;
5324
5325         LOGD("Enter, remote_handle : %x", pc->remote_handle);
5326         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
5327
5328         if (ret == CAMERA_ERROR_NONE) {
5329                 muse_camera_msg_get(get_enabled, pc->cb_info->recv_msg);
5330                 *enabled = (bool)get_enabled;
5331         }
5332         LOGD("ret : 0x%x", ret);
5333         return ret;
5334 }
5335
5336
5337 bool camera_attr_is_supported_anti_shake(camera_h camera)
5338 {
5339
5340         if (camera == NULL) {
5341                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5342                 return false;
5343         }
5344
5345         int ret = CAMERA_ERROR_NONE;
5346         camera_cli_s *pc = (camera_cli_s *)camera;
5347         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_SUPPORTED_ANTI_SHAKE;
5348         int sock_fd;
5349         if (pc->cb_info == NULL) {
5350                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5351                 return CAMERA_ERROR_INVALID_PARAMETER;
5352         }
5353         sock_fd = pc->cb_info->fd;
5354         LOGD("Enter, remote_handle : %x", pc->remote_handle);
5355         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
5356         LOGD("ret : 0x%x", ret);
5357         return ret;
5358 }
5359
5360
5361 int camera_attr_enable_video_stabilization(camera_h camera, bool enable)
5362 {
5363         if (camera == NULL) {
5364                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5365                 return CAMERA_ERROR_INVALID_PARAMETER;
5366         }
5367
5368         int ret = CAMERA_ERROR_NONE;
5369         camera_cli_s *pc = (camera_cli_s *)camera;
5370         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_ENABLE_VIDEO_STABILIZATION;
5371         int sock_fd;
5372         if (pc->cb_info == NULL) {
5373                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5374                 return CAMERA_ERROR_INVALID_PARAMETER;
5375         }
5376         sock_fd = pc->cb_info->fd;
5377         int set_enable = (int)enable;
5378
5379         LOGD("Enter, remote_handle : %x", pc->remote_handle);
5380         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_enable);
5381         LOGD("ret : 0x%x", ret);
5382         return ret;
5383 }
5384
5385
5386 int camera_attr_is_enabled_video_stabilization(camera_h camera, bool *enabled)
5387 {
5388         if (camera == NULL) {
5389                 LOGE("INVALID_PARAMETER(0x%08x) - handle", CAMERA_ERROR_INVALID_PARAMETER);
5390                 return CAMERA_ERROR_INVALID_PARAMETER;
5391         }
5392         if (enabled == NULL) {
5393                 LOGE("INVALID_PARAMETER(0x%08x) - enabled", CAMERA_ERROR_INVALID_PARAMETER);
5394                 return CAMERA_ERROR_NOT_SUPPORTED;
5395         }
5396         int ret = CAMERA_ERROR_NONE;
5397         camera_cli_s *pc = (camera_cli_s *)camera;
5398         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_ENABLED_VIDEO_STABILIZATION;
5399         int sock_fd;
5400         if (pc->cb_info == NULL) {
5401                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5402                 return CAMERA_ERROR_INVALID_PARAMETER;
5403         }
5404         sock_fd = pc->cb_info->fd;
5405         int get_enabled;
5406
5407         LOGD("Enter, remote_handle : %x", pc->remote_handle);
5408         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
5409
5410         if (ret == CAMERA_ERROR_NONE) {
5411                 muse_camera_msg_get(get_enabled, pc->cb_info->recv_msg);
5412                 *enabled = (bool)get_enabled;
5413         }
5414         LOGD("ret : 0x%x", ret);
5415         return ret;
5416 }
5417
5418
5419 bool camera_attr_is_supported_video_stabilization(camera_h camera)
5420 {
5421         if (camera == NULL) {
5422                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5423                 return false;
5424         }
5425
5426         int ret = CAMERA_ERROR_NONE;
5427         camera_cli_s *pc = (camera_cli_s *)camera;
5428         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_SUPPORTED_VIDEO_STABILIZATION;
5429         int sock_fd;
5430         if (pc->cb_info == NULL) {
5431                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5432                 return CAMERA_ERROR_INVALID_PARAMETER;
5433         }
5434         sock_fd = pc->cb_info->fd;
5435         LOGD("Enter, remote_handle : %x", pc->remote_handle);
5436         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
5437         LOGD("ret : 0x%x", ret);
5438         return ret;
5439 }
5440
5441
5442 int camera_attr_enable_auto_contrast(camera_h camera, bool enable)
5443 {
5444         if (camera == NULL) {
5445                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5446                 return CAMERA_ERROR_INVALID_PARAMETER;
5447         }
5448
5449         int ret = CAMERA_ERROR_NONE;
5450         camera_cli_s *pc = (camera_cli_s *)camera;
5451         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_ENABLE_AUTO_CONTRAST;
5452         int sock_fd;
5453         if (pc->cb_info == NULL) {
5454                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5455                 return CAMERA_ERROR_INVALID_PARAMETER;
5456         }
5457         sock_fd = pc->cb_info->fd;
5458         int set_enable = (int)enable;
5459
5460         LOGD("Enter, remote_handle : %x", pc->remote_handle);
5461         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_enable);
5462         LOGD("ret : 0x%x", ret);
5463         return ret;
5464 }
5465
5466
5467 int camera_attr_is_enabled_auto_contrast(camera_h camera, bool *enabled)
5468 {
5469         if (camera == NULL) {
5470                 LOGE("INVALID_PARAMETER(0x%08x) - handle", CAMERA_ERROR_INVALID_PARAMETER);
5471                 return CAMERA_ERROR_INVALID_PARAMETER;
5472         }
5473         if (enabled == NULL) {
5474                 LOGE("INVALID_PARAMETER(0x%08x) - enabled", CAMERA_ERROR_INVALID_PARAMETER);
5475                 return CAMERA_ERROR_INVALID_PARAMETER;
5476         }
5477         int ret = CAMERA_ERROR_NONE;
5478         camera_cli_s *pc = (camera_cli_s *)camera;
5479         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_ENABLED_AUTO_CONTRAST;
5480         int sock_fd;
5481         if (pc->cb_info == NULL) {
5482                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5483                 return CAMERA_ERROR_INVALID_PARAMETER;
5484         }
5485         sock_fd = pc->cb_info->fd;
5486         int get_enabled;
5487
5488         LOGD("Enter, remote_handle : %x", pc->remote_handle);
5489         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
5490
5491         if (ret == CAMERA_ERROR_NONE) {
5492                 muse_camera_msg_get(get_enabled, pc->cb_info->recv_msg);
5493                 *enabled = (bool)get_enabled;
5494         }
5495         LOGD("ret : 0x%x", ret);
5496         return ret;
5497 }
5498
5499
5500 bool camera_attr_is_supported_auto_contrast(camera_h camera)
5501 {
5502         if (camera == NULL) {
5503                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5504                 return false;
5505         }
5506
5507         int ret = CAMERA_ERROR_NONE;
5508         camera_cli_s *pc = (camera_cli_s *)camera;
5509         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_SUPPORTED_AUTO_CONTRAST;
5510         int sock_fd;
5511         if (pc->cb_info == NULL) {
5512                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5513                 return CAMERA_ERROR_INVALID_PARAMETER;
5514         }
5515         sock_fd = pc->cb_info->fd;
5516         LOGD("Enter, remote_handle : %x", pc->remote_handle);
5517         muse_camera_msg_send(api, sock_fd, pc->cb_info, ret);
5518         LOGD("ret : 0x%x", ret);
5519         return ret;
5520 }
5521
5522
5523 int camera_attr_disable_shutter_sound(camera_h camera, bool disable)
5524 {
5525         if (camera == NULL) {
5526                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5527                 return CAMERA_ERROR_INVALID_PARAMETER;
5528         }
5529
5530         int ret = CAMERA_ERROR_NONE;
5531         camera_cli_s *pc = (camera_cli_s *)camera;
5532         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_DISABLE_SHUTTER_SOUND;
5533         int sock_fd;
5534         if (pc->cb_info == NULL) {
5535                 LOGE("INVALID_PARAMETER(0x%08x)", CAMERA_ERROR_INVALID_PARAMETER);
5536                 return CAMERA_ERROR_INVALID_PARAMETER;
5537         }
5538         sock_fd = pc->cb_info->fd;
5539         int set_disable = (int)disable;
5540
5541         LOGD("Enter, remote_handle : %x", pc->remote_handle);
5542         muse_camera_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_disable);
5543         LOGD("ret : 0x%x", ret);
5544         return ret;
5545 }