src/camera.c

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