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