src/camera.c

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