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