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