muse/src/muse_camera_dispatcher.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 #include <stdlib.h>
  18 #include <string.h>
  19 #include <errno.h>
  20 #include <sys/types.h>
  21 #include <sys/socket.h>
  22 #include <sys/un.h>
  23 #include <stdio.h>
  24 #include <dlog.h>
  25 #include "muse_camera_msg.h"
  26 #include "muse_camera.h"
  27 #include <muse_core.h>
  28 #include <muse_core_ipc.h>
  29 #include <mm_types.h>
  30 #include <muse_core_security.h>
  31 #include <gst/gst.h>
  32
  33 #ifdef LOG_TAG
  34 #undef LOG_TAG
  35 #endif
  36 #define LOG_TAG "MUSED_CAMERA"
  37 #define KEY_NUM 9527
  38
  39 #define CAMERA_PRIVILEGE_NAME "http://tizen.org/privilege/camera"
  40
  41 static int _camera_remove_export_data(muse_module_h module, int key, int remove_all);
  42
  43
  44 void _camera_dispatcher_callback_supported_theater_mode(int param1, void *user_data)
  45 {
  46         muse_module_h module = (muse_module_h)user_data;
  47
  48         LOGD("Enter!! param : %d", param1);
  49
  50         muse_camera_msg_event1(MUSE_CAMERA_CB_EVENT,
  51                                MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_THEATER_MODE,
  52                                MUSE_CAMERA_EVENT_CLASS_THREAD_SUB,
  53                                module,
  54                                INT, param1);
  55 }
  56
  57 void _camera_dispatcher_callback_supported_af_mode(int param1, void *user_data)
  58 {
  59         muse_module_h module = (muse_module_h)user_data;
  60
  61         LOGD("Enter!! param : %d", param1);
  62
  63         muse_camera_msg_event1(MUSE_CAMERA_CB_EVENT,
  64                                MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_AF_MODE,
  65                                MUSE_CAMERA_EVENT_CLASS_THREAD_SUB,
  66                                module,
  67                                INT, param1);
  68 }
  69
  70 void _camera_dispatcher_callback_supported_exposure_mode(int param1, void *user_data)
  71 {
  72         muse_module_h module = (muse_module_h)user_data;
  73
  74         LOGD("Enter!! param : %d", param1);
  75
  76         muse_camera_msg_event1(MUSE_CAMERA_CB_EVENT,
  77                                MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EXPOSURE_MODE,
  78                                MUSE_CAMERA_EVENT_CLASS_THREAD_SUB,
  79                                module,
  80                                INT, param1);
  81 }
  82
  83 void _camera_dispatcher_callback_supported_iso_mode(int param1, void *user_data)
  84 {
  85         muse_module_h module = (muse_module_h)user_data;
  86
  87         LOGD("Enter!! param : %d", param1);
  88
  89         muse_camera_msg_event1(MUSE_CAMERA_CB_EVENT,
  90                                MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_ISO,
  91                                MUSE_CAMERA_EVENT_CLASS_THREAD_SUB,
  92                                module,
  93                                INT, param1);
  94 }
  95
  96 void _camera_dispatcher_callback_supported_whitebalance(int param1, void *user_data)
  97 {
  98         muse_module_h module = (muse_module_h)user_data;
  99
 100         LOGD("Enter!! param : %d", param1);
 101
 102         muse_camera_msg_event1(MUSE_CAMERA_CB_EVENT,
 103                                MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_WHITEBALANCE,
 104                                MUSE_CAMERA_EVENT_CLASS_THREAD_SUB,
 105                                module,
 106                                INT, param1);
 107 }
 108
 109 void _camera_dispatcher_callback_supported_effect(int param1, void *user_data)
 110 {
 111         muse_module_h module = (muse_module_h)user_data;
 112
 113         LOGD("Enter!! param : %d", param1);
 114
 115         muse_camera_msg_event1(MUSE_CAMERA_CB_EVENT,
 116                                MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_EFFECT,
 117                                MUSE_CAMERA_EVENT_CLASS_THREAD_SUB,
 118                                module,
 119                                INT, param1);
 120 }
 121
 122 void _camera_dispatcher_callback_supported_scene_mode(int param1, void *user_data)
 123 {
 124         muse_module_h module = (muse_module_h)user_data;
 125
 126         LOGD("Enter!! param : %d", param1);
 127
 128         muse_camera_msg_event1(MUSE_CAMERA_CB_EVENT,
 129                                MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_SCENE_MODE,
 130                                MUSE_CAMERA_EVENT_CLASS_THREAD_SUB,
 131                                module,
 132                                INT, param1);
 133 }
 134
 135 void _camera_dispatcher_callback_supported_flash_mode(int param1, void *user_data)
 136 {
 137         muse_module_h module = (muse_module_h)user_data;
 138
 139         LOGD("Enter!! param : %d", param1);
 140
 141         muse_camera_msg_event1(MUSE_CAMERA_CB_EVENT,
 142                                MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FLASH_MODE,
 143                                MUSE_CAMERA_EVENT_CLASS_THREAD_SUB,
 144                                module,
 145                                INT, param1);
 146 }
 147
 148 void _camera_dispatcher_callback_supported_fps(int param1, void *user_data)
 149 {
 150         muse_module_h module = (muse_module_h)user_data;
 151
 152         LOGD("Enter!! param : %d", param1);
 153
 154         muse_camera_msg_event1(MUSE_CAMERA_CB_EVENT,
 155                                MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS,
 156                                MUSE_CAMERA_EVENT_CLASS_THREAD_SUB,
 157                                module,
 158                                INT, param1);
 159 }
 160
 161 void _camera_dispatcher_callback_supported_fps_by_resolution(int param1, void *user_data)
 162 {
 163         muse_module_h module = (muse_module_h)user_data;
 164
 165         LOGD("Enter!! param : %d", param1);
 166
 167         muse_camera_msg_event1(MUSE_CAMERA_CB_EVENT,
 168                                MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_FPS_BY_RESOLUTION,
 169                                MUSE_CAMERA_EVENT_CLASS_THREAD_SUB,
 170                                module,
 171                                INT, param1);
 172 }
 173
 174 void _camera_dispatcher_callback_supported_stream_flip(int param1, void *user_data)
 175 {
 176         muse_module_h module = (muse_module_h)user_data;
 177
 178         LOGD("Enter!! param : %d", param1);
 179
 180         muse_camera_msg_event1(MUSE_CAMERA_CB_EVENT,
 181                                MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_FLIP,
 182                                MUSE_CAMERA_EVENT_CLASS_THREAD_SUB,
 183                                module,
 184                                INT, param1);
 185 }
 186
 187 void _camera_dispatcher_callback_supported_stream_rotation(int param1, void *user_data)
 188 {
 189         muse_module_h module = (muse_module_h)user_data;
 190
 191         LOGD("Enter!! param : %d", param1);
 192
 193         muse_camera_msg_event1(MUSE_CAMERA_CB_EVENT,
 194                                MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_STREAM_ROTATION,
 195                                MUSE_CAMERA_EVENT_CLASS_THREAD_SUB,
 196                                module,
 197                                INT, param1);
 198 }
 199
 200 void _camera_dispatcher_callback_supported_capture_format(int param1, void *user_data)
 201 {
 202         muse_module_h module = (muse_module_h)user_data;
 203
 204         LOGD("Enter!! param : %d", param1);
 205
 206         muse_camera_msg_event1(MUSE_CAMERA_CB_EVENT,
 207                                MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_FORMAT,
 208                                MUSE_CAMERA_EVENT_CLASS_THREAD_SUB,
 209                                module,
 210                                INT, param1);
 211 }
 212
 213 void _camera_dispatcher_callback_supported_preview_format(int param1, void *user_data)
 214 {
 215         muse_module_h module = (muse_module_h)user_data;
 216
 217         LOGD("Enter!! param : %d", param1);
 218
 219         muse_camera_msg_event1(MUSE_CAMERA_CB_EVENT,
 220                                MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_FORMAT,
 221                                MUSE_CAMERA_EVENT_CLASS_THREAD_SUB,
 222                                module,
 223                                INT, param1);
 224 }
 225
 226 void _camera_dispatcher_callback_supported_preview_resolution(int param1, int param2, void *user_data)
 227 {
 228         muse_module_h module = (muse_module_h)user_data;
 229
 230         LOGD("Enter!! param1 : %d, param2 : %d", param1, param2);
 231
 232         muse_camera_msg_event2(MUSE_CAMERA_CB_EVENT,
 233                                MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_PREVIEW_RESOLUTION,
 234                                MUSE_CAMERA_EVENT_CLASS_THREAD_SUB,
 235                                module,
 236                                INT, param1,
 237                                INT, param2);
 238 }
 239
 240 void _camera_dispatcher_callback_supported_capture_resolution(int param1, int param2, void *user_data)
 241 {
 242         muse_module_h module = (muse_module_h)user_data;
 243
 244         LOGD("Enter!! param1 : %d, param2 : %d", param1, param2);
 245
 246         muse_camera_msg_event2(MUSE_CAMERA_CB_EVENT,
 247                                MUSE_CAMERA_EVENT_TYPE_FOREACH_SUPPORTED_CAPTURE_RESOLUTION,
 248                                MUSE_CAMERA_EVENT_CLASS_THREAD_SUB,
 249                                module,
 250                                INT, param1,
 251                                INT, param2);
 252 }
 253
 254 static int _camera_remove_export_data(muse_module_h module, int key, int remove_all)
 255 {
 256         muse_camera_handle_s *muse_camera = NULL;
 257         GList *tmp_list = NULL;
 258         muse_camera_export_data *export_data = NULL;
 259
 260         if (module == NULL || (key <= 0 && remove_all == FALSE)) {
 261                 LOGE("invalid parameter %p, %d", module, key);
 262                 return FALSE;
 263         }
 264
 265         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
 266         if (muse_camera == NULL) {
 267                 LOGE("NULL handle");
 268                 return FALSE;
 269         }
 270
 271         g_mutex_lock(&muse_camera->list_lock);
 272
 273         tmp_list = muse_camera->data_list;
 274
 275         while (tmp_list) {
 276                 export_data = (muse_camera_export_data *)tmp_list->data;
 277                 if (export_data) {
 278                         if (export_data->key == key || remove_all) {
 279                                 /*LOGD("key %d matched, remove it (remove_all %d)", key, remove_all);*/
 280
 281                                 if (export_data->bo) {
 282                                         tbm_bo_unref(export_data->bo);
 283                                         export_data->bo = NULL;
 284                                 } else {
 285                                         LOGW("bo for key %d is NULL", key);
 286                                 }
 287                                 export_data->key = 0;
 288                                 if (export_data->internal_buffer) {
 289                                         gst_buffer_unref((GstBuffer *)export_data->internal_buffer);
 290                                         export_data->internal_buffer = NULL;
 291                                 }
 292
 293                                 muse_camera->data_list = g_list_remove(muse_camera->data_list, export_data);
 294
 295                                 g_free(export_data);
 296                                 export_data = NULL;
 297
 298                                 if (remove_all == FALSE) {
 299                                         /*LOGD("key %d, remove done");*/
 300                                         g_mutex_unlock(&muse_camera->list_lock);
 301                                         return TRUE;
 302                                 } else {
 303                                         LOGD("check next data");
 304                                 }
 305                         }
 306                 } else {
 307                         LOGW("NULL data");
 308                 }
 309
 310                 tmp_list = tmp_list->next;
 311         }
 312
 313         g_mutex_unlock(&muse_camera->list_lock);
 314
 315         if (remove_all) {
 316                 LOGD("remove all done");
 317         } else {
 318                 LOGE("should not be reached here - key %d", key);
 319         }
 320
 321         return FALSE;
 322 }
 323
 324 void _camera_dispatcher_capturing_cb(camera_image_data_s* image, camera_image_data_s* postview, camera_image_data_s* thumbnail, void *user_data)
 325 {
 326         muse_camera_handle_s *muse_camera = NULL;
 327         int data_size = 0;
 328         tbm_bo bo = NULL;
 329         tbm_bo_handle bo_handle = {.ptr = NULL};
 330         muse_camera_export_data *export_data = NULL;
 331         int tbm_key = 0;
 332         muse_module_h module = (muse_module_h)user_data;
 333         unsigned char *buf_pos = NULL;
 334         int is_postview = 0;
 335         int is_thumbnail = 0;
 336
 337         LOGD("Enter!!");
 338
 339         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
 340         if (muse_camera == NULL) {
 341                 LOGE("NULL handle");
 342                 return;
 343         }
 344
 345         export_data = g_new0(muse_camera_export_data, 1);
 346         if (export_data == NULL) {
 347                 LOGE("alloc export_data failed");
 348                 return;
 349         }
 350
 351         if (image != NULL) {
 352                 if (image->size > 0) {
 353                         data_size += (sizeof(camera_image_data_s) + image->size);
 354                 }
 355         }
 356         if (postview != NULL) {
 357                 if (postview->size > 0) {
 358                         data_size += (sizeof(camera_image_data_s) + postview->size);
 359                         is_postview = 1;
 360                 }
 361         }
 362         if (thumbnail != NULL) {
 363                 if (thumbnail->size > 0) {
 364                         data_size += (sizeof(camera_image_data_s) + thumbnail->size);
 365                         is_thumbnail = 1;
 366                 }
 367         }
 368
 369         bo = tbm_bo_alloc(muse_camera->bufmgr, data_size, TBM_BO_DEFAULT);
 370         if (bo == NULL) {
 371                 LOGE("bo alloc failed");
 372                 g_free(export_data);
 373                 export_data = NULL;
 374                 return;
 375         }
 376
 377         bo_handle = tbm_bo_map(bo, TBM_DEVICE_CPU, TBM_OPTION_READ | TBM_OPTION_WRITE);
 378         if (bo_handle.ptr == NULL) {
 379                 LOGE("bo map Error!");
 380                 tbm_bo_unref(bo);
 381                 g_free(export_data);
 382                 export_data = NULL;
 383                 return;
 384         }
 385
 386         buf_pos = (unsigned char *)bo_handle.ptr;
 387         if (image != NULL) {
 388                 if (image->size > 0) {
 389                         memcpy(buf_pos, image, sizeof(camera_image_data_s));
 390                         buf_pos += sizeof(camera_image_data_s);
 391                         memcpy(buf_pos, image->data, image->size);
 392                         buf_pos += image->size;
 393                 }
 394         }
 395
 396         if (is_postview) {
 397                 memcpy(buf_pos, postview, sizeof(camera_image_data_s));
 398                 buf_pos += sizeof(camera_image_data_s);
 399                 memcpy(buf_pos + sizeof(camera_image_data_s), postview->data, postview->size);
 400                 buf_pos += postview->size;
 401         }
 402
 403         if (is_thumbnail) {
 404                 memcpy(buf_pos, thumbnail, sizeof(camera_image_data_s));
 405                 buf_pos += sizeof(camera_image_data_s);
 406                 memcpy(buf_pos + sizeof(camera_image_data_s), thumbnail->data, thumbnail->size);
 407         }
 408
 409         tbm_bo_unmap(bo);
 410
 411         tbm_key = tbm_bo_export(bo);
 412
 413         if(tbm_key == 0) {
 414                 LOGE("Create key_info ERROR!!");
 415                 tbm_bo_unref(bo);
 416                 bo = NULL;
 417                 g_free(export_data);
 418                 export_data = NULL;
 419                 return;
 420         }
 421
 422         LOGD("bo %p, vaddr %p, size %d, key %d",
 423              bo, bo_handle.ptr, data_size, tbm_key);
 424
 425         /* set bo info */
 426         export_data->key = tbm_key;
 427         export_data->bo = bo;
 428
 429         /* add bo info to list */
 430         g_mutex_lock(&muse_camera->list_lock);
 431         muse_camera->data_list = g_list_append(muse_camera->data_list, (gpointer)export_data);
 432         g_mutex_unlock(&muse_camera->list_lock);
 433
 434         /* send message */
 435         muse_camera_msg_event3(MUSE_CAMERA_CB_EVENT,
 436                                MUSE_CAMERA_EVENT_TYPE_CAPTURE,
 437                                MUSE_CAMERA_EVENT_CLASS_THREAD_SUB,
 438                                module,
 439                                INT, tbm_key,
 440                                INT, is_postview,
 441                                INT, is_thumbnail);
 442
 443         return;
 444 }
 445
 446 void _camera_dispatcher_state_changed_cb(camera_state_e previous, camera_state_e current, bool by_policy, void *user_data)
 447 {
 448         muse_module_h module = (muse_module_h)user_data;
 449
 450         LOGD("Enter - previous %d, current %d, by_policy %d",
 451              previous, current, by_policy);
 452
 453         muse_camera_msg_event3(MUSE_CAMERA_CB_EVENT,
 454                                MUSE_CAMERA_EVENT_TYPE_STATE_CHANGE,
 455                                MUSE_CAMERA_EVENT_CLASS_THREAD_MAIN,
 456                                module,
 457                                INT, previous,
 458                                INT, current,
 459                                INT, by_policy);
 460
 461         return;
 462 }
 463
 464 void _camera_dispatcher_interrupted_cb(camera_policy_e policy, camera_state_e previous, camera_state_e current, void *user_data)
 465 {
 466         muse_module_h module = (muse_module_h)user_data;
 467
 468         LOGD("Enter - policy %d, state previous %d, current %d", policy, previous, current);
 469
 470         muse_camera_msg_event3(MUSE_CAMERA_CB_EVENT,
 471                                MUSE_CAMERA_EVENT_TYPE_INTERRUPTED,
 472                                MUSE_CAMERA_EVENT_CLASS_THREAD_MAIN,
 473                                module,
 474                                INT, policy,
 475                                INT, previous,
 476                                INT, current);
 477
 478         return;
 479 }
 480
 481 void _camera_dispatcher_preview_cb(MMCamcorderVideoStreamDataType *stream, void *user_data)
 482 {
 483         muse_camera_handle_s *muse_camera = NULL;
 484         int data_size = 0;
 485         tbm_bo bo = NULL;
 486         tbm_bo_handle bo_handle = {.ptr = NULL};
 487         muse_camera_export_data *export_data = NULL;
 488         int i = 0;
 489         int tbm_key = 0;
 490         int buffer_key[BUFFER_MAX_PLANE_NUM] = {0, };
 491         int num_buffer_key = 0;
 492         muse_module_h module = (muse_module_h)user_data;
 493         unsigned char *buf_pos = NULL;
 494         char *send_message = NULL;
 495         gint64 end_time;
 496
 497         /*LOGD("Enter");*/
 498
 499         if (module == NULL || stream == NULL) {
 500                 LOGE("NULL data %p, %p", module, stream);
 501                 return;
 502         }
 503
 504         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
 505         if (muse_camera == NULL) {
 506                 LOGE("NULL handle");
 507                 return;
 508         }
 509
 510         export_data = g_new0(muse_camera_export_data, 1);
 511         if (export_data == NULL) {
 512                 LOGE("alloc export_data failed");
 513                 return;
 514         }
 515
 516         data_size = sizeof(MMCamcorderVideoStreamDataType);
 517
 518         if (stream->bo[0] == NULL) {
 519                 switch (stream->data_type) {
 520                 case MM_CAM_STREAM_DATA_YUV420:
 521                         data_size += stream->data.yuv420.length_yuv;
 522                         break;
 523                 case MM_CAM_STREAM_DATA_YUV422:
 524                         data_size += stream->data.yuv422.length_yuv;
 525                         break;
 526                 case MM_CAM_STREAM_DATA_YUV420SP:
 527                         data_size += stream->data.yuv420sp.length_y;
 528                         data_size += stream->data.yuv420sp.length_uv;
 529                         break;
 530                 case MM_CAM_STREAM_DATA_YUV420P:
 531                         data_size += stream->data.yuv420p.length_y;
 532                         data_size += stream->data.yuv420p.length_u;
 533                         data_size += stream->data.yuv420p.length_v;
 534                         break;
 535                 case MM_CAM_STREAM_DATA_YUV422P:
 536                         data_size += stream->data.yuv422p.length_y;
 537                         data_size += stream->data.yuv422p.length_u;
 538                         data_size += stream->data.yuv422p.length_v;
 539                         break;
 540                 case MM_CAM_STREAM_DATA_ENCODED:
 541                         data_size += stream->data.encoded.length_data;
 542                         break;
 543                 default :
 544                         LOGW("unknown data type %d", stream->data_type);
 545                         break;
 546                 }
 547         }
 548
 549         bo = tbm_bo_alloc(muse_camera->bufmgr, data_size, TBM_BO_DEFAULT);
 550         if (bo == NULL) {
 551                 LOGE("bo alloc failed");
 552                 g_free(export_data);
 553                 export_data = NULL;
 554                 return;
 555         }
 556
 557         bo_handle = tbm_bo_map(bo, TBM_DEVICE_CPU, TBM_OPTION_READ | TBM_OPTION_WRITE);
 558         if (bo_handle.ptr == NULL) {
 559                 LOGE("bo map Error!");
 560                 tbm_bo_unref(bo);
 561                 g_free(export_data);
 562                 export_data = NULL;
 563                 return;
 564         }
 565
 566         buf_pos = (unsigned char *)bo_handle.ptr;
 567
 568         memcpy(buf_pos, stream, sizeof(MMCamcorderVideoStreamDataType));
 569         buf_pos += sizeof(MMCamcorderVideoStreamDataType);
 570
 571         if (stream->bo[0] == NULL) {
 572                 /* non-zero copy */
 573                 switch (stream->data_type) {
 574                 case MM_CAM_STREAM_DATA_YUV420:
 575                         memcpy(buf_pos, stream->data.yuv420.yuv, stream->data.yuv420.length_yuv);
 576                         break;
 577                 case MM_CAM_STREAM_DATA_YUV422:
 578                         memcpy(buf_pos, stream->data.yuv422.yuv, stream->data.yuv422.length_yuv);
 579                         break;
 580                 case MM_CAM_STREAM_DATA_YUV420SP:
 581                         memcpy(buf_pos, stream->data.yuv420sp.y, stream->data.yuv420sp.length_y);
 582                         memcpy(buf_pos + stream->data.yuv420sp.length_y, stream->data.yuv420sp.uv, stream->data.yuv420sp.length_uv);
 583                         break;
 584                 case MM_CAM_STREAM_DATA_YUV420P:
 585                         memcpy(buf_pos, stream->data.yuv420p.y, stream->data.yuv420p.length_y);
 586                         memcpy(buf_pos + stream->data.yuv420p.length_y, stream->data.yuv420p.u, stream->data.yuv420p.length_u);
 587                         memcpy(buf_pos + stream->data.yuv420p.length_y + stream->data.yuv420p.length_u, stream->data.yuv420p.v, stream->data.yuv420p.length_v);
 588                         break;
 589                 case MM_CAM_STREAM_DATA_YUV422P:
 590                         memcpy(buf_pos, stream->data.yuv422p.y, stream->data.yuv422p.length_y);
 591                         memcpy(buf_pos + stream->data.yuv422p.length_y, stream->data.yuv422p.u, stream->data.yuv422p.length_u);
 592                         memcpy(buf_pos + stream->data.yuv422p.length_y + stream->data.yuv422p.length_u, stream->data.yuv422p.v, stream->data.yuv422p.length_v);
 593                         break;
 594                 case MM_CAM_STREAM_DATA_ENCODED:
 595                         memcpy(buf_pos, stream->data.encoded.data, stream->data.encoded.length_data);
 596                         break;
 597                 default :
 598                         break;
 599                 }
 600         } else {
 601                 /* zero copy */
 602                 for (i = 0 ; i < BUFFER_MAX_PLANE_NUM ; i++) {
 603                         if (stream->bo[i]) {
 604                                 buffer_key[i] = tbm_bo_export(stream->bo[i]);
 605                                 if (buffer_key[i] == 0) {
 606                                         LOGE("failed to export bo %p", stream->bo[i]);
 607                                         tbm_bo_unmap(bo);
 608                                         tbm_bo_unref(bo);
 609                                         bo = NULL;
 610                                         g_free(export_data);
 611                                         export_data = NULL;
 612                                         return;
 613                                 }
 614                                 num_buffer_key++;
 615                         } else {
 616                                 LOGD("num_buffer_key %d", num_buffer_key);
 617                                 break;
 618                         }
 619                 }
 620         }
 621
 622         tbm_bo_unmap(bo);
 623
 624         tbm_key = tbm_bo_export(bo);
 625         if(tbm_key == 0) {
 626                 LOGE("Create key_info ERROR!!");
 627                 tbm_bo_unref(bo);
 628                 bo = NULL;
 629                 g_free(export_data);
 630                 export_data = NULL;
 631                 return;
 632         }
 633
 634         /*
 635         LOGD("bo %p, vaddr %p, size %d, key %d",
 636              bo, bo_handle.ptr, data_size, tbm_key);
 637         */
 638
 639         /* set bo info */
 640         export_data->key = tbm_key;
 641         export_data->bo = bo;
 642         if (stream->internal_buffer) {
 643                 export_data->internal_buffer = stream->internal_buffer;
 644                 gst_buffer_ref((GstBuffer *)export_data->internal_buffer);
 645         }
 646
 647         /* add bo info to list */
 648         g_mutex_lock(&muse_camera->list_lock);
 649         muse_camera->data_list = g_list_append(muse_camera->data_list, (gpointer)export_data);
 650         g_mutex_unlock(&muse_camera->list_lock);
 651
 652         g_mutex_lock(&muse_camera->preview_cb_lock);
 653
 654         /* send message */
 655         send_message = muse_core_msg_json_factory_new(MUSE_CAMERA_CB_EVENT,
 656                                                       MUSE_TYPE_INT, PARAM_EVENT, MUSE_CAMERA_EVENT_TYPE_PREVIEW,
 657                                                       MUSE_TYPE_INT, PARAM_EVENT_CLASS, MUSE_CAMERA_EVENT_CLASS_THREAD_SUB,
 658                                                       MUSE_TYPE_INT, "tbm_key", tbm_key,
 659                                                       MUSE_TYPE_INT, "num_buffer_key", num_buffer_key,
 660                                                       MUSE_TYPE_ARRAY, "buffer_key", BUFFER_MAX_PLANE_NUM, buffer_key,
 661                                                       0);
 662
 663         muse_core_ipc_send_msg(muse_core_client_get_msg_fd(module), send_message);
 664
 665         muse_core_msg_json_factory_free(send_message);
 666
 667         /*LOGD("wait preview callback return message");*/
 668
 669         end_time = g_get_monotonic_time () + G_TIME_SPAN_SECOND;
 670
 671         if (!g_cond_wait_until(&muse_camera->preview_cb_cond, &muse_camera->preview_cb_lock, end_time)) {
 672                 LOGW("preview callback return message timeout");
 673         } else {
 674                 /*LOGD("preview callback return message received");*/
 675         }
 676
 677         g_mutex_unlock(&muse_camera->preview_cb_lock);
 678
 679         return;
 680 }
 681
 682 void _camera_dispatcher_capture_completed_cb(void *user_data)
 683 {
 684         muse_module_h module = (muse_module_h)user_data;
 685
 686         LOGD("Enter");
 687
 688         muse_camera_msg_event(MUSE_CAMERA_CB_EVENT,
 689                               MUSE_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE,
 690                               MUSE_CAMERA_EVENT_CLASS_THREAD_MAIN,
 691                               module);
 692         return;
 693 }
 694
 695 void _camera_dispatcher_face_detected_cb(camera_detected_face_s *faces, int count, void *user_data)
 696 {
 697         muse_module_h module = (muse_module_h)user_data;
 698         muse_camera_handle_s *muse_camera = NULL;
 699         tbm_bo bo = NULL;
 700         tbm_bo_handle bo_handle = {NULL, };
 701         int bo_size = sizeof(camera_detected_face_s) * count;
 702         int tbm_key = 0;
 703         muse_camera_export_data *export_data = NULL;
 704
 705         if (count > 0) {
 706                 if (module == NULL) {
 707                         LOGE("NULL module");
 708                         return;
 709                 }
 710
 711                 muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
 712                 if (muse_camera == NULL) {
 713                         LOGE("NULL handle");
 714                         return;
 715                 }
 716
 717                 export_data = g_new0(muse_camera_export_data, 1);
 718                 if (export_data == NULL) {
 719                         LOGE("alloc export_data failed");
 720                         return;
 721                 }
 722
 723                 bo = tbm_bo_alloc(muse_camera->bufmgr, bo_size, TBM_BO_DEFAULT);
 724                 if (bo == NULL) {
 725                         LOGE("tbm_bo_alloc failed");
 726
 727                         g_free(export_data);
 728                         export_data = NULL;
 729
 730                         return;
 731                 }
 732
 733                 bo_handle = tbm_bo_map(bo, TBM_DEVICE_CPU, TBM_OPTION_READ | TBM_OPTION_WRITE);
 734                 if (bo_handle.ptr == NULL) {
 735                         LOGE("bo map Error!");
 736
 737                         tbm_bo_unref(bo);
 738                         bo = NULL;
 739
 740                         g_free(export_data);
 741                         export_data = NULL;
 742
 743                         return;
 744                 }
 745
 746                 /* copy face detection info */
 747                 memcpy(bo_handle.ptr, faces, bo_size);
 748
 749                 /* export bo */
 750                 tbm_key = tbm_bo_export(bo);
 751                 if (tbm_key == 0) {
 752                         LOGE("failed to export bo for face detection info");
 753
 754                         tbm_bo_unmap(bo);
 755                         tbm_bo_unref(bo);
 756                         bo = NULL;
 757
 758                         g_free(export_data);
 759                         export_data = NULL;
 760
 761                         return;
 762                 }
 763
 764                 LOGD("face - count %d, buffer size %d, key %d", count, bo_size, tbm_key);
 765
 766                 /* set export data */
 767                 export_data->bo = bo;
 768                 export_data->key = tbm_key;
 769
 770                 /* add bo info to list */
 771                 g_mutex_lock(&muse_camera->list_lock);
 772                 muse_camera->data_list = g_list_append(muse_camera->data_list, (gpointer)export_data);
 773                 g_mutex_unlock(&muse_camera->list_lock);
 774
 775                 /* send message */
 776                 muse_camera_msg_event2(MUSE_CAMERA_CB_EVENT,
 777                                        MUSE_CAMERA_EVENT_TYPE_FACE_DETECTION,
 778                                        MUSE_CAMERA_EVENT_CLASS_THREAD_MAIN,
 779                                        module,
 780                                        INT, count,
 781                                        INT, tbm_key);
 782         } else {
 783                 LOGW("invalid count for face detection - %d", count);
 784         }
 785
 786         return;
 787 }
 788
 789 void _camera_dispatcher_focus_changed_cb(camera_focus_state_e state, void *user_data)
 790 {
 791         muse_module_h module = (muse_module_h)user_data;
 792
 793         LOGD("Enter - state %d", state);
 794
 795         muse_camera_msg_event1(MUSE_CAMERA_CB_EVENT,
 796                                MUSE_CAMERA_EVENT_TYPE_FOCUS_CHANGE,
 797                                MUSE_CAMERA_EVENT_CLASS_THREAD_MAIN,
 798                                module,
 799                                INT, state);
 800
 801         return;
 802 }
 803
 804 void _camera_dispatcher_error_cb(camera_error_e error, camera_state_e current_state, void *user_data)
 805 {
 806         muse_module_h module = (muse_module_h)user_data;
 807
 808         LOGD("Enter - error 0x%x, current_state %d", error, current_state);
 809
 810         muse_camera_msg_event2(MUSE_CAMERA_CB_EVENT,
 811                                MUSE_CAMERA_EVENT_TYPE_ERROR,
 812                                MUSE_CAMERA_EVENT_CLASS_THREAD_MAIN,
 813                                module,
 814                                INT, error,
 815                                INT, current_state);
 816
 817         return;
 818 }
 819
 820 void _camera_dispatcher_hdr_progress_cb(int percent, void *user_data)
 821 {
 822         muse_module_h module = (muse_module_h)user_data;
 823
 824         LOGD("Enter");
 825
 826         muse_camera_msg_event1(MUSE_CAMERA_CB_EVENT,
 827                                MUSE_CAMERA_EVENT_TYPE_HDR_PROGRESS,
 828                                MUSE_CAMERA_EVENT_CLASS_THREAD_MAIN,
 829                                module,
 830                                INT, percent);
 831         return;
 832 }
 833
 834
 835 int camera_dispatcher_create(muse_module_h module)
 836 {
 837         int ret = CAMERA_ERROR_NONE;
 838         int device_type;
 839         int client_fd = -1;
 840         int pid = 0;
 841         intptr_t handle;
 842         muse_camera_handle_s *muse_camera = NULL;
 843         muse_camera_api_e api = MUSE_CAMERA_API_CREATE;
 844         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
 845
 846         muse_camera_msg_get(device_type, muse_core_client_get_msg(module));
 847         muse_camera_msg_get(pid, muse_core_client_get_msg(module));
 848
 849         LOGD("device type : %d, client pid : %d", device_type, pid);
 850
 851         /* privilege check */
 852         client_fd = muse_core_client_get_msg_fd(module);
 853         if (!muse_core_security_check_cynara(client_fd, CAMERA_PRIVILEGE_NAME)) {
 854                 ret = CAMERA_ERROR_PERMISSION_DENIED;
 855                 LOGE("security check failed 0x%x", ret);
 856                 muse_camera_msg_return(api, class, ret, module);
 857                 return MUSE_CAMERA_ERROR_NONE;
 858         }
 859
 860         /* init handle */
 861         muse_camera = (muse_camera_handle_s *)malloc(sizeof(muse_camera_handle_s));
 862         if (muse_camera == NULL) {
 863                 ret = CAMERA_ERROR_OUT_OF_MEMORY;
 864                 LOGE("handle alloc failed 0x%x", ret);
 865                 muse_camera_msg_return(api, class, ret, module);
 866                 return MUSE_CAMERA_ERROR_NONE;
 867         }
 868
 869         memset(muse_camera, 0x0, sizeof(muse_camera_handle_s));
 870
 871         g_mutex_init(&muse_camera->list_lock);
 872         g_mutex_init(&muse_camera->preview_cb_lock);
 873         g_cond_init(&muse_camera->preview_cb_cond);
 874
 875         if (muse_core_ipc_get_bufmgr(&muse_camera->bufmgr) != MM_ERROR_NONE) {
 876                 LOGE("muse_core_ipc_get_bufmgr failed");
 877
 878                 free(muse_camera);
 879                 muse_camera = NULL;
 880
 881                 ret = CAMERA_ERROR_INVALID_OPERATION;
 882                 muse_camera_msg_return(api, class, ret, module);
 883
 884                 return MUSE_CAMERA_ERROR_NONE;
 885         }
 886
 887         ret = legacy_camera_create((camera_device_e)device_type, &muse_camera->camera_handle);
 888         if (ret != CAMERA_ERROR_NONE) {
 889                 free(muse_camera);
 890                 muse_camera = NULL;
 891                 muse_camera_msg_return(api, class, ret, module);
 892
 893                 return MUSE_CAMERA_ERROR_NONE;
 894         }
 895
 896         ret = legacy_camera_set_client_pid(muse_camera->camera_handle, pid);
 897         if (ret == CAMERA_ERROR_NONE) {
 898                 LOGD("handle : 0x%x", muse_camera);
 899                 handle = (intptr_t)muse_camera;
 900                 muse_core_ipc_set_handle(module, (intptr_t)muse_camera);
 901                 muse_camera_msg_return1(api, class, ret, module, POINTER, handle);
 902         } else {
 903                 LOGE("legacy_camera_set_client_pid failed : 0x%x", ret);
 904
 905                 legacy_camera_destroy(muse_camera->camera_handle);
 906                 muse_camera->camera_handle = NULL;
 907
 908                 free(muse_camera);
 909                 muse_camera = NULL;
 910
 911                 muse_camera_msg_return(api, class, ret, module);
 912         }
 913
 914         return MUSE_CAMERA_ERROR_NONE;
 915 }
 916
 917 int camera_dispatcher_destroy(muse_module_h module)
 918 {
 919         int ret = CAMERA_ERROR_NONE;
 920         muse_camera_handle_s *muse_camera = NULL;
 921         muse_camera_api_e api = MUSE_CAMERA_API_DESTROY;
 922         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
 923
 924         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
 925
 926         LOGD("Enter, handle : %p", muse_camera);
 927
 928         ret = legacy_camera_destroy(muse_camera->camera_handle);
 929         if (ret == CAMERA_ERROR_NONE) {
 930                 _camera_remove_export_data(module, 0, TRUE);
 931
 932                 g_mutex_clear(&muse_camera->list_lock);
 933                 g_mutex_clear(&muse_camera->preview_cb_lock);
 934                 g_cond_clear(&muse_camera->preview_cb_cond);
 935
 936                 muse_camera->bufmgr = NULL;
 937
 938                 free(muse_camera);
 939                 muse_camera = NULL;
 940         }
 941
 942         muse_camera_msg_return(api, class, ret, module);
 943
 944         return MUSE_CAMERA_ERROR_NONE;
 945 }
 946
 947 int camera_dispatcher_start_preview(muse_module_h module)
 948 {
 949         int ret = CAMERA_ERROR_NONE;
 950         muse_camera_handle_s *muse_camera = NULL;
 951         muse_camera_api_e api = MUSE_CAMERA_API_START_PREVIEW;
 952         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
 953         char *caps = NULL;
 954         camera_state_e prev_state = CAMERA_STATE_NONE;
 955
 956         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
 957
 958         LOGD("handle : %p", muse_camera);
 959
 960         legacy_camera_get_state(muse_camera->camera_handle, &prev_state);
 961
 962         ret = legacy_camera_start_preview(muse_camera->camera_handle);
 963         if (ret != CAMERA_ERROR_NONE) {
 964                 LOGD("start preview failed 0x%x", ret);
 965                 muse_camera_msg_return(api, class, ret, module);
 966                 return MUSE_CAMERA_ERROR_NONE;
 967         }
 968
 969         if (prev_state == CAMERA_STATE_CREATED) {
 970                 ret = legacy_camera_get_video_caps(muse_camera->camera_handle, &caps);
 971                 if (ret == CAMERA_ERROR_NONE && caps) {
 972                         LOGD("caps : %s", caps);
 973                         muse_camera_msg_return2(api, class, ret, module, STRING, caps, INT, prev_state);
 974                         g_free(caps);
 975                 } else {
 976                         LOGD("Failed to get server's video caps. ret 0x%x, caps %p", ret, caps);
 977                         muse_camera_msg_return(api, class, ret, module);
 978                         if (legacy_camera_stop_preview(muse_camera->camera_handle) != CAMERA_ERROR_NONE) {
 979                                 LOGW("failed to stop preview");
 980                         }
 981                 }
 982         } else {
 983                 LOGD("preview started after capture");
 984                 muse_camera_msg_return1(api, class, ret, module, INT, prev_state);
 985         }
 986
 987         return MUSE_CAMERA_ERROR_NONE;
 988 }
 989
 990 int camera_dispatcher_stop_preview(muse_module_h module)
 991 {
 992         int ret = CAMERA_ERROR_NONE;
 993         muse_camera_handle_s *muse_camera = NULL;
 994         muse_camera_api_e api = MUSE_CAMERA_API_STOP_PREVIEW;
 995         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
 996
 997         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
 998
 999         LOGD("handle : %p", muse_camera);
1000
1001         ret = legacy_camera_stop_preview(muse_camera->camera_handle);
1002
1003         muse_camera_msg_return(api, class, ret, module);
1004
1005         return MUSE_CAMERA_ERROR_NONE;
1006 }
1007
1008 int camera_dispatcher_start_capture(muse_module_h module)
1009 {
1010         int ret = CAMERA_ERROR_NONE;
1011         muse_camera_handle_s *muse_camera = NULL;
1012         int is_capturing_cb = 0;
1013         int is_completed_cb = 0;
1014         void *capturing_cb = NULL;
1015         void *completed_cb = NULL;
1016         muse_camera_api_e api = MUSE_CAMERA_API_START_CAPTURE;
1017         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1018
1019         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1020
1021         muse_camera_msg_get(is_capturing_cb, muse_core_client_get_msg(module));
1022         muse_camera_msg_get(is_completed_cb, muse_core_client_get_msg(module));
1023
1024         LOGD("Enter, handle : %p, module : %p, capturing_cb %d, completed_cb %d",
1025              muse_camera, module, is_capturing_cb, is_completed_cb);
1026
1027         if (is_capturing_cb) {
1028                 capturing_cb = _camera_dispatcher_capturing_cb;
1029         }
1030         if (is_completed_cb) {
1031                 completed_cb = _camera_dispatcher_capture_completed_cb;
1032         }
1033
1034         ret = legacy_camera_start_capture(muse_camera->camera_handle,
1035                                           (camera_capturing_cb)capturing_cb,
1036                                           (camera_capture_completed_cb)completed_cb,
1037                                           (void *)module);
1038
1039         muse_camera_msg_return(api, class, ret, module);
1040
1041         return MUSE_CAMERA_ERROR_NONE;
1042 }
1043
1044 int camera_dispatcher_is_supported_continuous_capture(muse_module_h module)
1045 {
1046         int ret = CAMERA_ERROR_NONE;
1047         muse_camera_handle_s *muse_camera = NULL;
1048         muse_camera_api_e api = MUSE_CAMERA_API_SUPPORT_CONTINUOUS_CAPTURE;
1049         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1050
1051         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1052
1053         LOGD("handle : %p", muse_camera);
1054
1055         ret = legacy_camera_is_supported_continuous_capture(muse_camera->camera_handle);
1056
1057         LOGD("is supported ret : %d", ret);
1058
1059         muse_camera_msg_return(api, class, ret, module);
1060
1061         return MUSE_CAMERA_ERROR_NONE;
1062 }
1063
1064 int camera_dispatcher_start_continuous_capture(muse_module_h module)
1065 {
1066         int ret = CAMERA_ERROR_NONE;
1067         muse_camera_handle_s *muse_camera = NULL;
1068         int count;
1069         int interval;
1070         muse_camera_api_e api = MUSE_CAMERA_API_START_CONTINUOUS_CAPTURE;
1071         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1072
1073         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1074
1075         muse_camera_msg_get(count, muse_core_client_get_msg(module));
1076         muse_camera_msg_get(interval, muse_core_client_get_msg(module));
1077
1078         LOGD("Enter, handle : %p, module : %p", muse_camera, module);
1079
1080         ret = legacy_camera_start_continuous_capture(muse_camera->camera_handle,
1081                                                      count,
1082                                                      interval,
1083                                                      (camera_capturing_cb)_camera_dispatcher_capturing_cb,
1084                                                      (camera_capture_completed_cb)_camera_dispatcher_capture_completed_cb,
1085                                                      (void *)module);
1086
1087         muse_camera_msg_return(api, class, ret, module);
1088
1089         return MUSE_CAMERA_ERROR_NONE;
1090 }
1091
1092 int camera_dispatcher_stop_continuous_capture(muse_module_h module)
1093 {
1094         int ret = CAMERA_ERROR_NONE;
1095         muse_camera_handle_s *muse_camera = NULL;
1096         muse_camera_api_e api = MUSE_CAMERA_API_STOP_CONTINUOUS_CAPTURE;
1097         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1098
1099         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1100
1101         LOGD("handle : %p", muse_camera);
1102
1103         ret = legacy_camera_stop_continuous_capture(muse_camera->camera_handle);
1104
1105         muse_camera_msg_return(api, class, ret, module);
1106
1107         return MUSE_CAMERA_ERROR_NONE;
1108 }
1109
1110 int camera_dispatcher_is_supported_face_detection(muse_module_h module)
1111 {
1112         int ret = CAMERA_ERROR_NONE;
1113         muse_camera_handle_s *muse_camera = NULL;
1114         muse_camera_api_e api = MUSE_CAMERA_API_SUPPORT_FACE_DETECTION;
1115         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1116
1117         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1118
1119         LOGD("handle : %p", muse_camera);
1120
1121         ret = legacy_camera_is_supported_face_detection(muse_camera->camera_handle);
1122
1123         LOGD("is supported ret : %d", ret);
1124
1125         muse_camera_msg_return(api, class, ret, module);
1126
1127         return MUSE_CAMERA_ERROR_NONE;
1128 }
1129
1130 int camera_dispatcher_is_supported_zero_shutter_lag(muse_module_h module)
1131 {
1132         int ret = CAMERA_ERROR_NONE;
1133         muse_camera_handle_s *muse_camera = NULL;
1134         muse_camera_api_e api = MUSE_CAMERA_API_SUPPORT_ZERO_SHUTTER_LAG;
1135         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1136
1137         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1138
1139         LOGD("handle : %p", muse_camera);
1140
1141         ret = legacy_camera_is_supported_zero_shutter_lag(muse_camera->camera_handle);
1142
1143         LOGD("is supported ret : %d", ret);
1144
1145         muse_camera_msg_return(api, class, ret, module);
1146
1147         return MUSE_CAMERA_ERROR_NONE;
1148 }
1149
1150 int camera_dispatcher_is_supported_media_packet_preview_cb(muse_module_h module)
1151 {
1152         int ret = CAMERA_ERROR_NONE;
1153         muse_camera_handle_s *muse_camera = NULL;
1154         muse_camera_api_e api = MUSE_CAMERA_API_SUPPORT_MEDIA_PACKET_PREVIEW_CB;
1155         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1156
1157         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1158
1159         LOGD("handle : %p", muse_camera);
1160
1161         ret = legacy_camera_is_supported_media_packet_preview_cb(muse_camera->camera_handle);
1162
1163         LOGD("is supported ret : %d", ret);
1164
1165         muse_camera_msg_return(api, class, ret, module);
1166
1167         return MUSE_CAMERA_ERROR_NONE;
1168 }
1169
1170 int camera_dispatcher_get_device_count(muse_module_h module)
1171 {
1172         int ret = CAMERA_ERROR_NONE;
1173         muse_camera_handle_s *muse_camera = NULL;
1174         int get_device_count = 0;
1175         muse_camera_api_e api = MUSE_CAMERA_API_GET_DEVICE_COUNT;
1176         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1177
1178         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1179
1180         LOGD("handle : %p", muse_camera);
1181
1182         ret = legacy_camera_get_device_count(muse_camera->camera_handle, &get_device_count);
1183         if (ret == CAMERA_ERROR_NONE) {
1184                 muse_camera_msg_return1(api, class, ret, module, INT, get_device_count);
1185         } else {
1186                 muse_camera_msg_return(api, class, ret, module);
1187         }
1188
1189         return MUSE_CAMERA_ERROR_NONE;
1190 }
1191
1192 int camera_dispatcher_start_face_detection(muse_module_h module)
1193 {
1194         int ret = CAMERA_ERROR_NONE;
1195         muse_camera_handle_s *muse_camera = NULL;
1196         muse_camera_api_e api = MUSE_CAMERA_API_START_FACE_DETECTION;
1197         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1198
1199         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1200
1201         LOGD("Enter, handle : 0x%x, module : %d", muse_camera, module);
1202
1203         ret = legacy_camera_start_face_detection(muse_camera->camera_handle,
1204                                                  (camera_face_detected_cb)_camera_dispatcher_face_detected_cb,
1205                                                  (void *)module);
1206
1207         muse_camera_msg_return(api, class, ret, module);
1208
1209         return MUSE_CAMERA_ERROR_NONE;
1210 }
1211
1212 int camera_dispatcher_stop_face_detection(muse_module_h module)
1213 {
1214         int ret = CAMERA_ERROR_NONE;
1215         muse_camera_handle_s *muse_camera = NULL;
1216         muse_camera_api_e api = MUSE_CAMERA_API_STOP_FACE_DETECTION;
1217         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1218
1219         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1220
1221         LOGD("handle : %p", muse_camera);
1222
1223         ret = legacy_camera_stop_face_detection(muse_camera->camera_handle);
1224
1225         muse_camera_msg_return(api, class, ret, module);
1226
1227         return MUSE_CAMERA_ERROR_NONE;
1228 }
1229
1230 int camera_dispatcher_get_state(muse_module_h module)
1231 {
1232         int ret = CAMERA_ERROR_NONE;
1233         muse_camera_handle_s *muse_camera = NULL;
1234         camera_state_e get_state = CAMERA_STATE_NONE;
1235         muse_camera_api_e api = MUSE_CAMERA_API_GET_STATE;
1236         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1237
1238         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1239
1240         LOGD("handle : %p", muse_camera);
1241
1242         ret = legacy_camera_get_state(muse_camera->camera_handle, &get_state);
1243         if (ret == CAMERA_ERROR_NONE) {
1244                 muse_camera_msg_return1(api, class, ret, module, INT, get_state);
1245         } else {
1246                 muse_camera_msg_return(api, class, ret, module);
1247         }
1248
1249         return MUSE_CAMERA_ERROR_NONE;
1250 }
1251
1252 int camera_dispatcher_start_focusing(muse_module_h module)
1253 {
1254         int ret = CAMERA_ERROR_NONE;
1255         muse_camera_handle_s *muse_camera = NULL;
1256         int is_continuous;
1257         muse_camera_api_e api = MUSE_CAMERA_API_START_FOCUSING;
1258         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1259
1260         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1261
1262         muse_camera_msg_get(is_continuous, muse_core_client_get_msg(module));
1263
1264         LOGD("Enter, handle : 0x%x, module : %d", muse_camera, module);
1265
1266         ret = legacy_camera_start_focusing(muse_camera->camera_handle, (bool)is_continuous);
1267
1268         muse_camera_msg_return(api, class, ret, module);
1269
1270         return MUSE_CAMERA_ERROR_NONE;
1271 }
1272
1273 int camera_dispatcher_stop_focusing(muse_module_h module)
1274 {
1275         int ret = CAMERA_ERROR_NONE;
1276         muse_camera_handle_s *muse_camera = NULL;
1277         muse_camera_api_e api = MUSE_CAMERA_API_CANCEL_FOCUSING;
1278         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1279
1280         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1281
1282         LOGD("handle : %p", muse_camera);
1283
1284         ret = legacy_camera_cancel_focusing(muse_camera->camera_handle);
1285
1286         muse_camera_msg_return(api, class, ret, module);
1287
1288         return MUSE_CAMERA_ERROR_NONE;
1289 }
1290
1291 int camera_dispatcher_set_display(muse_module_h module)
1292 {
1293         int ret = CAMERA_ERROR_NONE;
1294         muse_camera_handle_s *muse_camera = NULL;
1295         muse_camera_api_e api = MUSE_CAMERA_API_SET_DISPLAY;
1296         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1297         static guint stream_id = 0;
1298         char socket_path[SOCKET_PATH_LENGTH] = {0,};
1299         camera_h camera;
1300
1301         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1302
1303         LOGD("handle : 0x%x", muse_camera);
1304
1305         camera = muse_camera->camera_handle;
1306         stream_id = muse_core_get_atomic_uint();
1307
1308         snprintf(socket_path, SOCKET_PATH_LENGTH, SOCKET_PATH_BASE, stream_id);
1309
1310         LOGD("socket_path : %s", socket_path);
1311
1312         ret = legacy_camera_set_display(muse_camera->camera_handle, CAMERA_DISPLAY_TYPE_REMOTE, (void *)socket_path);
1313         if (ret != CAMERA_ERROR_NONE) {
1314                 muse_camera_msg_return(api, class, ret, module);
1315         } else {
1316                 muse_camera_msg_return1(api, class, ret, module,
1317                                         STRING, socket_path);
1318         }
1319
1320         return MUSE_CAMERA_ERROR_NONE;
1321 }
1322
1323 int camera_dispatcher_set_preview_resolution(muse_module_h module)
1324 {
1325         int ret = CAMERA_ERROR_NONE;
1326         muse_camera_handle_s *muse_camera = NULL;
1327         int width;
1328         int height;
1329         muse_camera_api_e api = MUSE_CAMERA_API_SET_PREVIEW_RESOLUTION;
1330         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1331
1332         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1333
1334         muse_camera_msg_get(width, muse_core_client_get_msg(module));
1335         muse_camera_msg_get(height, muse_core_client_get_msg(module));
1336
1337         LOGD("handle : 0x%x, set_width : %d, set_height : 0x%x", muse_camera, width, height);
1338
1339         ret = legacy_camera_set_preview_resolution(muse_camera->camera_handle, width, height);
1340
1341         muse_camera_msg_return(api, class, ret, module);
1342
1343         return MUSE_CAMERA_ERROR_NONE;
1344 }
1345
1346 int camera_dispatcher_set_capture_resolution(muse_module_h module)
1347 {
1348         int ret = CAMERA_ERROR_NONE;
1349         muse_camera_handle_s *muse_camera = NULL;
1350         int width;
1351         int height;
1352         muse_camera_api_e api = MUSE_CAMERA_API_SET_CAPTURE_RESOLUTION;
1353         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1354
1355         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1356
1357         muse_camera_msg_get(width, muse_core_client_get_msg(module));
1358         muse_camera_msg_get(height, muse_core_client_get_msg(module));
1359
1360         LOGD("handle : 0x%x, set_width : %d, set_height : %d", muse_camera, width, height);
1361
1362         ret = legacy_camera_set_capture_resolution(muse_camera->camera_handle, width, height);
1363
1364         muse_camera_msg_return(api, class, ret, module);
1365
1366         return MUSE_CAMERA_ERROR_NONE;
1367 }
1368
1369 int camera_dispatcher_set_capture_format(muse_module_h module)
1370 {
1371         int ret = CAMERA_ERROR_NONE;
1372         muse_camera_handle_s *muse_camera = NULL;
1373         int set_format;
1374         muse_camera_api_e api = MUSE_CAMERA_API_SET_CAPTURE_FORMAT;
1375         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1376
1377         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1378
1379         muse_camera_msg_get(set_format, muse_core_client_get_msg(module));
1380
1381         LOGD("handle : 0x%x, set_format : %d", muse_camera, set_format);
1382
1383         ret = legacy_camera_set_capture_format(muse_camera->camera_handle, (camera_pixel_format_e)set_format);
1384
1385         muse_camera_msg_return(api, class, ret, module);
1386
1387         return MUSE_CAMERA_ERROR_NONE;
1388 }
1389
1390 int camera_dispatcher_set_preview_format(muse_module_h module)
1391 {
1392         int ret = CAMERA_ERROR_NONE;
1393         muse_camera_handle_s *muse_camera = NULL;
1394         int set_format;
1395         muse_camera_api_e api = MUSE_CAMERA_API_SET_PREVIEW_FORMAT;
1396         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1397
1398         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1399
1400         muse_camera_msg_get(set_format, muse_core_client_get_msg(module));
1401
1402         LOGD("handle : 0x%x, set_format : %d", muse_camera, set_format);
1403
1404         ret = legacy_camera_set_preview_format(muse_camera->camera_handle, (camera_pixel_format_e)set_format);
1405
1406         muse_camera_msg_return(api, class, ret, module);
1407
1408         return MUSE_CAMERA_ERROR_NONE;
1409 }
1410
1411 int camera_dispatcher_get_preview_resolution(muse_module_h module)
1412 {
1413         int ret = CAMERA_ERROR_NONE;
1414         muse_camera_handle_s *muse_camera = NULL;
1415         int get_width = 0;
1416         int get_height = 0;
1417         muse_camera_api_e api = MUSE_CAMERA_API_GET_PREVIEW_RESOLUTION;
1418         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1419
1420         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1421
1422         LOGD("handle : %p", muse_camera);
1423
1424         ret = legacy_camera_get_preview_resolution(muse_camera->camera_handle, &get_width, &get_height);
1425         if (ret == CAMERA_ERROR_NONE) {
1426                 muse_camera_msg_return2(api, class, ret, module, INT, get_width, INT, get_height);
1427         } else {
1428                 muse_camera_msg_return(api, class, ret, module);
1429         }
1430
1431         return MUSE_CAMERA_ERROR_NONE;
1432 }
1433
1434 int camera_dispatcher_set_display_rotation(muse_module_h module)
1435 {
1436         int ret = CAMERA_ERROR_NONE;
1437         muse_camera_handle_s *muse_camera = NULL;
1438         int set_rotation;
1439         muse_camera_api_e api = MUSE_CAMERA_API_SET_DISPLAY_ROTATION;
1440         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1441
1442         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1443
1444         muse_camera_msg_get(set_rotation, muse_core_client_get_msg(module));
1445
1446         LOGD("handle : 0x%x, set_rotation : %d", muse_camera, set_rotation);
1447
1448         ret = legacy_camera_set_display_rotation(muse_camera->camera_handle, (camera_rotation_e)set_rotation);
1449
1450         muse_camera_msg_return(api, class, ret, module);
1451
1452         return MUSE_CAMERA_ERROR_NONE;
1453 }
1454
1455 int camera_dispatcher_get_display_rotation(muse_module_h module)
1456 {
1457         int ret = CAMERA_ERROR_NONE;
1458         muse_camera_handle_s *muse_camera = NULL;
1459         camera_rotation_e get_rotation = CAMERA_ROTATION_NONE;
1460         muse_camera_api_e api = MUSE_CAMERA_API_GET_DISPLAY_ROTATION;
1461         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1462
1463         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1464
1465         LOGD("handle : %p", muse_camera);
1466
1467         ret = legacy_camera_get_display_rotation(muse_camera->camera_handle, &get_rotation);
1468         if (ret == CAMERA_ERROR_NONE) {
1469                 muse_camera_msg_return1(api, class, ret, module, INT, get_rotation);
1470         } else {
1471                 muse_camera_msg_return(api, class, ret, module);
1472         }
1473
1474         return MUSE_CAMERA_ERROR_NONE;
1475 }
1476
1477 int camera_dispatcher_set_display_flip(muse_module_h module)
1478 {
1479         int ret = CAMERA_ERROR_NONE;
1480         muse_camera_handle_s *muse_camera = NULL;
1481         int set_flip;
1482         muse_camera_api_e api = MUSE_CAMERA_API_SET_DISPLAY_FLIP;
1483         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1484
1485         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1486
1487         muse_camera_msg_get(set_flip, muse_core_client_get_msg(module));
1488
1489         LOGD("handle : 0x%x, set_flip : %d", muse_camera, set_flip);
1490
1491         ret = legacy_camera_set_display_flip(muse_camera->camera_handle, (camera_flip_e)set_flip);
1492
1493         muse_camera_msg_return(api, class, ret, module);
1494
1495         return MUSE_CAMERA_ERROR_NONE;
1496 }
1497
1498 int camera_dispatcher_get_display_flip(muse_module_h module)
1499 {
1500         int ret = CAMERA_ERROR_NONE;
1501         muse_camera_handle_s *muse_camera = NULL;
1502         camera_flip_e get_flip = CAMERA_FLIP_NONE;
1503         muse_camera_api_e api = MUSE_CAMERA_API_GET_DISPLAY_FLIP;
1504         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1505
1506         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1507
1508         LOGD("handle : %p", muse_camera);
1509
1510         ret = legacy_camera_get_display_flip(muse_camera->camera_handle, &get_flip);
1511         if (ret == CAMERA_ERROR_NONE) {
1512                 muse_camera_msg_return1(api, class, ret, module, INT, get_flip);
1513         } else {
1514                 muse_camera_msg_return(api, class, ret, module);
1515         }
1516
1517         return MUSE_CAMERA_ERROR_NONE;
1518 }
1519
1520 int camera_dispatcher_set_display_visible(muse_module_h module)
1521 {
1522         int ret = CAMERA_ERROR_NONE;
1523         muse_camera_handle_s *muse_camera = NULL;
1524         int set_visible;
1525         muse_camera_api_e api = MUSE_CAMERA_API_SET_DISPLAY_VISIBLE;
1526         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1527
1528         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1529
1530         muse_camera_msg_get(set_visible, muse_core_client_get_msg(module));
1531
1532         LOGD("handle : 0x%x, set_visible : %d", muse_camera, set_visible);
1533
1534         ret = legacy_camera_set_display_visible(muse_camera->camera_handle, (bool)set_visible);
1535
1536         muse_camera_msg_return(api, class, ret, module);
1537
1538         return MUSE_CAMERA_ERROR_NONE;
1539 }
1540
1541 int camera_dispatcher_is_display_visible(muse_module_h module)
1542 {
1543         int ret = CAMERA_ERROR_NONE;
1544         muse_camera_handle_s *muse_camera = NULL;
1545         bool get_visible = true;
1546         muse_camera_api_e api = MUSE_CAMERA_API_IS_DISPLAY_VISIBLE;
1547         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1548
1549         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1550
1551         LOGD("handle : %p", muse_camera);
1552
1553         ret = legacy_camera_is_display_visible(muse_camera->camera_handle, &get_visible);
1554         if (ret == CAMERA_ERROR_NONE) {
1555                 muse_camera_msg_return1(api, class, ret, module, INT, get_visible);
1556         } else {
1557                 muse_camera_msg_return(api, class, ret, module);
1558         }
1559
1560         return MUSE_CAMERA_ERROR_NONE;
1561 }
1562
1563 int camera_dispatcher_set_display_mode(muse_module_h module)
1564 {
1565         int ret = CAMERA_ERROR_NONE;
1566         muse_camera_handle_s *muse_camera = NULL;
1567         int set_mode;
1568         muse_camera_api_e api = MUSE_CAMERA_API_SET_DISPLAY_MODE;
1569         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1570
1571         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1572
1573         muse_camera_msg_get(set_mode, muse_core_client_get_msg(module));
1574
1575         LOGD("handle : 0x%x, display_mode : %d", muse_camera, set_mode);
1576
1577         ret = legacy_camera_set_display_mode(muse_camera->camera_handle, (camera_display_mode_e)set_mode);
1578
1579         LOGD("ret : 0x%x", ret);
1580
1581         muse_camera_msg_return(api, class, ret, module);
1582
1583         return MUSE_CAMERA_ERROR_NONE;
1584 }
1585
1586 int camera_dispatcher_get_display_mode(muse_module_h module)
1587 {
1588         int ret = CAMERA_ERROR_NONE;
1589         muse_camera_handle_s *muse_camera = NULL;
1590         camera_display_mode_e get_mode = CAMERA_DISPLAY_MODE_LETTER_BOX;
1591         muse_camera_api_e api = MUSE_CAMERA_API_GET_DISPLAY_MODE;
1592         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1593
1594         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1595
1596         LOGD("handle : %p", muse_camera);
1597
1598         ret = legacy_camera_get_display_mode(muse_camera->camera_handle, &get_mode);
1599         if (ret == CAMERA_ERROR_NONE) {
1600                 muse_camera_msg_return1(api, class, ret, module, INT, get_mode);
1601         } else {
1602                 muse_camera_msg_return(api, class, ret, module);
1603         }
1604
1605         return MUSE_CAMERA_ERROR_NONE;
1606 }
1607
1608 int camera_dispatcher_get_capture_resolution(muse_module_h module)
1609 {
1610         int ret = CAMERA_ERROR_NONE;
1611         muse_camera_handle_s *muse_camera = NULL;
1612         int get_width = 0;
1613         int get_height = 0;
1614         muse_camera_api_e api = MUSE_CAMERA_API_GET_CAPTURE_RESOLUTION;
1615         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1616
1617         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1618
1619         LOGD("handle : %p", muse_camera);
1620
1621         ret = legacy_camera_get_capture_resolution(muse_camera->camera_handle, &get_width, &get_height);
1622         if (ret == CAMERA_ERROR_NONE) {
1623                 muse_camera_msg_return2(api, class, ret, module, INT, get_width, INT, get_height);
1624         } else {
1625                 muse_camera_msg_return(api, class, ret, module);
1626         }
1627
1628         return MUSE_CAMERA_ERROR_NONE;
1629 }
1630
1631 int camera_dispatcher_get_capture_format(muse_module_h module)
1632 {
1633         int ret = CAMERA_ERROR_NONE;
1634         muse_camera_handle_s *muse_camera = NULL;
1635         camera_pixel_format_e get_format = CAMERA_PIXEL_FORMAT_NV12;
1636         muse_camera_api_e api = MUSE_CAMERA_API_GET_CAPTURE_FORMAT;
1637         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1638
1639         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1640
1641         LOGD("handle : %p", muse_camera);
1642
1643         ret = legacy_camera_get_capture_format(muse_camera->camera_handle, &get_format);
1644         if (ret == CAMERA_ERROR_NONE) {
1645                 muse_camera_msg_return1(api, class, ret, module, INT, get_format);
1646         } else {
1647                 muse_camera_msg_return(api, class, ret, module);
1648         }
1649
1650         return MUSE_CAMERA_ERROR_NONE;
1651 }
1652
1653 int camera_dispatcher_get_preview_format(muse_module_h module)
1654 {
1655         int ret = CAMERA_ERROR_NONE;
1656         muse_camera_handle_s *muse_camera = NULL;
1657         camera_pixel_format_e get_format = CAMERA_PIXEL_FORMAT_NV12;
1658         muse_camera_api_e api = MUSE_CAMERA_API_GET_PREVIEW_FORMAT;
1659         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1660
1661         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1662
1663         LOGD("handle : %p", muse_camera);
1664
1665         ret = legacy_camera_get_preview_format(muse_camera->camera_handle, &get_format);
1666         if (ret == CAMERA_ERROR_NONE) {
1667                 muse_camera_msg_return1(api, class, ret, module, INT, get_format);
1668         } else {
1669                 muse_camera_msg_return(api, class, ret, module);
1670         }
1671
1672         return MUSE_CAMERA_ERROR_NONE;
1673 }
1674
1675 int camera_dispatcher_get_facing_direction(muse_module_h module)
1676 {
1677         int ret = CAMERA_ERROR_NONE;
1678         muse_camera_handle_s *muse_camera = NULL;
1679         camera_facing_direction_e get_facing_direction = CAMERA_FACING_DIRECTION_REAR;
1680         muse_camera_api_e api = MUSE_CAMERA_API_GET_FACING_DIRECTION;
1681         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1682
1683         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1684
1685         LOGD("handle : %p", muse_camera);
1686
1687         ret = legacy_camera_get_facing_direction(muse_camera->camera_handle, &get_facing_direction);
1688         if (ret == CAMERA_ERROR_NONE) {
1689                 muse_camera_msg_return1(api, class, ret, module, INT, get_facing_direction);
1690         } else {
1691                 muse_camera_msg_return(api, class, ret, module);
1692         }
1693 }
1694
1695 int camera_dispatcher_set_preview_cb(muse_module_h module)
1696 {
1697         int ret = CAMERA_ERROR_NONE;
1698         muse_camera_handle_s *muse_camera = NULL;
1699         muse_camera_api_e api = MUSE_CAMERA_API_SET_PREVIEW_CB;
1700         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1701
1702         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1703
1704         LOGD("handle : %p", muse_camera);
1705
1706         ret = legacy_camera_set_preview_cb(muse_camera->camera_handle,
1707                                            (camera_preview_cb)_camera_dispatcher_preview_cb,
1708                                            (void *)module);
1709
1710         LOGD("ret : 0x%x", ret);
1711
1712         muse_camera_msg_return(api, class, ret, module);
1713
1714         return MUSE_CAMERA_ERROR_NONE;
1715 }
1716
1717 int camera_dispatcher_unset_preview_cb(muse_module_h module)
1718 {
1719         int ret = CAMERA_ERROR_NONE;
1720         muse_camera_handle_s *muse_camera = NULL;
1721         muse_camera_api_e api = MUSE_CAMERA_API_UNSET_PREVIEW_CB;
1722         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1723
1724         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1725
1726         LOGD("handle : %p", muse_camera);
1727
1728         ret = legacy_camera_unset_preview_cb(muse_camera->camera_handle);
1729
1730         LOGD("ret : 0x%x", ret);
1731
1732         muse_camera_msg_return(api, class, ret, module);
1733
1734         return MUSE_CAMERA_ERROR_NONE;
1735 }
1736
1737 int camera_dispatcher_set_media_packet_preview_cb(muse_module_h module)
1738 {
1739         int ret = CAMERA_ERROR_NONE;
1740         muse_camera_handle_s *muse_camera = NULL;
1741         muse_camera_api_e api = MUSE_CAMERA_API_SET_MEDIA_PACKET_PREVIEW_CB;
1742         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1743
1744         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1745
1746         LOGD("handle : %p", muse_camera);
1747
1748         ret = legacy_camera_set_media_packet_preview_cb(muse_camera->camera_handle,
1749                                                         (camera_preview_cb)_camera_dispatcher_preview_cb,
1750                                                         (void *)module);
1751
1752         LOGD("ret : 0x%x", ret);
1753
1754         muse_camera_msg_return(api, class, ret, module);
1755
1756         return MUSE_CAMERA_ERROR_NONE;
1757 }
1758
1759 int camera_dispatcher_unset_media_packet_preview_cb(muse_module_h module)
1760 {
1761         int ret = CAMERA_ERROR_NONE;
1762         muse_camera_handle_s *muse_camera = NULL;
1763         muse_camera_api_e api = MUSE_CAMERA_API_UNSET_MEDIA_PACKET_PREVIEW_CB;
1764         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1765
1766         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1767
1768         LOGD("handle : %p", muse_camera);
1769
1770         ret = legacy_camera_unset_media_packet_preview_cb(muse_camera->camera_handle);
1771
1772         LOGD("ret : 0x%x", ret);
1773
1774         muse_camera_msg_return(api, class, ret, module);
1775
1776         return MUSE_CAMERA_ERROR_NONE;
1777 }
1778
1779 int camera_dispatcher_set_state_changed_cb(muse_module_h module)
1780 {
1781         int ret = CAMERA_ERROR_NONE;
1782         muse_camera_handle_s *muse_camera = NULL;
1783         muse_camera_api_e api = MUSE_CAMERA_API_SET_STATE_CHANGED_CB;
1784         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1785
1786         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1787
1788         LOGD("handle : %p", muse_camera);
1789
1790         ret = legacy_camera_set_state_changed_cb(muse_camera->camera_handle,
1791                                                  (camera_state_changed_cb)_camera_dispatcher_state_changed_cb,
1792                                                  (void *)module);
1793
1794         LOGD("ret : 0x%x", ret);
1795
1796         muse_camera_msg_return(api, class, ret, module);
1797
1798         return MUSE_CAMERA_ERROR_NONE;
1799 }
1800
1801 int camera_dispatcher_unset_state_changed_cb(muse_module_h module)
1802 {
1803         int ret = CAMERA_ERROR_NONE;
1804         muse_camera_handle_s *muse_camera = NULL;
1805         muse_camera_api_e api = MUSE_CAMERA_API_UNSET_STATE_CHANGED_CB;
1806         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1807
1808         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1809
1810         LOGD("handle : %p", muse_camera);
1811
1812         ret = legacy_camera_unset_state_changed_cb(muse_camera->camera_handle);
1813
1814         LOGD("ret : 0x%x", ret);
1815
1816         muse_camera_msg_return(api, class, ret, module);
1817
1818         return MUSE_CAMERA_ERROR_NONE;
1819 }
1820
1821 int camera_dispatcher_set_interrupted_cb(muse_module_h module)
1822 {
1823         int ret = CAMERA_ERROR_NONE;
1824         muse_camera_handle_s *muse_camera = NULL;
1825         muse_camera_api_e api = MUSE_CAMERA_API_SET_INTERRUPTED_CB;
1826         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1827
1828         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1829
1830         LOGD("handle : %p", muse_camera);
1831
1832         ret = legacy_camera_set_interrupted_cb(muse_camera->camera_handle,
1833                                                (camera_interrupted_cb)_camera_dispatcher_interrupted_cb,
1834                                                (void *)module);
1835
1836         LOGD("ret : 0x%x", ret);
1837
1838         muse_camera_msg_return(api, class, ret, module);
1839
1840         return MUSE_CAMERA_ERROR_NONE;
1841 }
1842
1843 int camera_dispatcher_unset_interrupted_cb(muse_module_h module)
1844 {
1845         int ret = CAMERA_ERROR_NONE;
1846         muse_camera_handle_s *muse_camera = NULL;
1847         muse_camera_api_e api = MUSE_CAMERA_API_UNSET_INTERRUPTED_CB;
1848         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1849
1850         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1851
1852         LOGD("handle : %p", muse_camera);
1853
1854         ret = legacy_camera_unset_interrupted_cb(muse_camera->camera_handle);
1855
1856         LOGD("ret : 0x%x", ret);
1857
1858         muse_camera_msg_return(api, class, ret, module);
1859
1860         return MUSE_CAMERA_ERROR_NONE;
1861 }
1862
1863 int camera_dispatcher_set_focus_changed_cb(muse_module_h module)
1864 {
1865         int ret = CAMERA_ERROR_NONE;
1866         muse_camera_handle_s *muse_camera = NULL;
1867         muse_camera_api_e api = MUSE_CAMERA_API_SET_FOCUS_CHANGED_CB;
1868         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1869
1870         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1871
1872         LOGD("handle : %p", muse_camera);
1873
1874         ret = legacy_camera_set_focus_changed_cb(muse_camera->camera_handle,
1875                                                  (camera_focus_changed_cb)_camera_dispatcher_focus_changed_cb,
1876                                                  (void *)module);
1877
1878         LOGD("ret : 0x%x", ret);
1879
1880         muse_camera_msg_return(api, class, ret, module);
1881
1882         return MUSE_CAMERA_ERROR_NONE;
1883 }
1884
1885 int camera_dispatcher_unset_focus_changed_cb(muse_module_h module)
1886 {
1887         int ret = CAMERA_ERROR_NONE;
1888         muse_camera_handle_s *muse_camera = NULL;
1889         muse_camera_api_e api = MUSE_CAMERA_API_UNSET_FOCUS_CHANGED_CB;
1890         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1891
1892         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1893
1894         LOGD("handle : %p", muse_camera);
1895
1896         ret = legacy_camera_unset_focus_changed_cb(muse_camera->camera_handle);
1897
1898         LOGD("ret : 0x%x", ret);
1899
1900         muse_camera_msg_return(api, class, ret, module);
1901
1902         return MUSE_CAMERA_ERROR_NONE;
1903 }
1904
1905 int camera_dispatcher_set_error_cb(muse_module_h module)
1906 {
1907         int ret = CAMERA_ERROR_NONE;
1908         muse_camera_handle_s *muse_camera = NULL;
1909         muse_camera_api_e api = MUSE_CAMERA_API_SET_ERROR_CB;
1910         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1911
1912         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1913
1914         LOGD("handle : %p", muse_camera);
1915
1916         ret = legacy_camera_set_error_cb(muse_camera->camera_handle,
1917                                          (camera_error_cb)_camera_dispatcher_error_cb,
1918                                          (void *)module);
1919
1920         LOGD("ret : 0x%x", ret);
1921
1922         muse_camera_msg_return(api, class, ret, module);
1923
1924         return MUSE_CAMERA_ERROR_NONE;
1925 }
1926
1927 int camera_dispatcher_unset_error_cb(muse_module_h module)
1928 {
1929         int ret = CAMERA_ERROR_NONE;
1930         muse_camera_handle_s *muse_camera = NULL;
1931         muse_camera_api_e api = MUSE_CAMERA_API_UNSET_ERROR_CB;
1932         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1933
1934         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1935
1936         LOGD("handle : %p", muse_camera);
1937
1938         ret = legacy_camera_unset_error_cb(muse_camera->camera_handle);
1939
1940         LOGD("ret : 0x%x", ret);
1941
1942         muse_camera_msg_return(api, class, ret, module);
1943
1944         return MUSE_CAMERA_ERROR_NONE;
1945 }
1946
1947 int camera_dispatcher_foreach_supported_preview_resolution(muse_module_h module)
1948 {
1949         int ret = CAMERA_ERROR_NONE;
1950         muse_camera_handle_s *muse_camera = NULL;
1951         muse_camera_api_e api = MUSE_CAMERA_API_SET_FOREACH_SUPPORTED_PREVIEW_RESOLUTION;
1952         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_THREAD_SUB;
1953
1954         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1955
1956         LOGD("handle : %p", muse_camera);
1957
1958         ret = legacy_camera_foreach_supported_preview_resolution(muse_camera->camera_handle,
1959                                                                  (camera_supported_preview_resolution_cb)_camera_dispatcher_callback_supported_preview_resolution,
1960                                                                  (void *)module);
1961
1962         LOGD("ret : 0x%x", ret);
1963
1964         muse_camera_msg_return(api, class, ret, module);
1965
1966         return MUSE_CAMERA_ERROR_NONE;
1967 }
1968
1969 int camera_dispatcher_foreach_supported_capture_resolution(muse_module_h module)
1970 {
1971         int ret = CAMERA_ERROR_NONE;
1972         muse_camera_handle_s *muse_camera = NULL;
1973         muse_camera_api_e api = MUSE_CAMERA_API_SET_FOREACH_SUPPORTED_CAPTURE_RESOLUTION;
1974         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_THREAD_SUB;
1975
1976         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1977
1978         LOGD("handle : %p", muse_camera);
1979
1980         ret = legacy_camera_foreach_supported_capture_resolution(muse_camera->camera_handle,
1981                                                                  (camera_supported_capture_resolution_cb)_camera_dispatcher_callback_supported_capture_resolution,
1982                                                                  (void *)module);
1983
1984         LOGD("ret : 0x%x", ret);
1985
1986         muse_camera_msg_return(api, class, ret, module);
1987
1988         return MUSE_CAMERA_ERROR_NONE;
1989 }
1990
1991 int camera_dispatcher_foreach_supported_capture_format(muse_module_h module)
1992 {
1993         int ret = CAMERA_ERROR_NONE;
1994         muse_camera_handle_s *muse_camera = NULL;
1995         muse_camera_api_e api = MUSE_CAMERA_API_SET_FOREACH_SUPPORTED_CAPTURE_FORMAT;
1996         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_THREAD_SUB;
1997
1998         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1999
2000         LOGD("handle : %p", muse_camera);
2001
2002         ret = legacy_camera_foreach_supported_capture_format(muse_camera->camera_handle,
2003                                                              (camera_supported_capture_format_cb)_camera_dispatcher_callback_supported_capture_format,
2004                                                              (void *)module);
2005
2006         LOGD("ret : 0x%x", ret);
2007
2008         muse_camera_msg_return(api, class, ret, module);
2009
2010         return MUSE_CAMERA_ERROR_NONE;
2011 }
2012
2013 int camera_dispatcher_foreach_supported_preview_format(muse_module_h module)
2014 {
2015         int ret = CAMERA_ERROR_NONE;
2016         muse_camera_handle_s *muse_camera = NULL;
2017         muse_camera_api_e api = MUSE_CAMERA_API_SET_FOREACH_SUPPORTED_PREVIEW_FORMAT;
2018         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_THREAD_SUB;
2019
2020         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2021
2022         LOGD("handle : %p", muse_camera);
2023
2024         ret = legacy_camera_foreach_supported_preview_format(muse_camera->camera_handle,
2025                                                              (camera_supported_preview_format_cb)_camera_dispatcher_callback_supported_preview_format,
2026                                                              (void *)module);
2027
2028         LOGD("ret : 0x%x", ret);
2029
2030         muse_camera_msg_return(api, class, ret, module);
2031
2032         return MUSE_CAMERA_ERROR_NONE;
2033 }
2034
2035 int camera_dispatcher_get_recommended_preview_resolution(muse_module_h module)
2036 {
2037         int ret = CAMERA_ERROR_NONE;
2038         muse_camera_handle_s *muse_camera = NULL;
2039         int get_width = 0;
2040         int get_height = 0;
2041         muse_camera_api_e api = MUSE_CAMERA_API_GET_RECOMMENDED_PREVIEW_RESOLUTION;
2042         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2043
2044         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2045
2046         LOGD("handle : %p", muse_camera);
2047
2048         ret = legacy_camera_get_recommended_preview_resolution(muse_camera->camera_handle, &get_width, &get_height);
2049         if (ret == CAMERA_ERROR_NONE) {
2050                 muse_camera_msg_return2(api, class, ret, module, INT, get_width, INT, get_height);
2051         } else {
2052                 muse_camera_msg_return(api, class, ret, module);
2053         }
2054
2055         return MUSE_CAMERA_ERROR_NONE;
2056 }
2057
2058 int camera_dispatcher_attr_get_lens_orientation(muse_module_h module)
2059 {
2060         int ret = CAMERA_ERROR_NONE;
2061         muse_camera_handle_s *muse_camera = NULL;
2062         int get_angle = 0;
2063         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_LENS_ORIENTATION;
2064         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2065
2066         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2067
2068         LOGD("handle : %p", muse_camera);
2069
2070         ret = legacy_camera_attr_get_lens_orientation(muse_camera->camera_handle, &get_angle);
2071         if (ret == CAMERA_ERROR_NONE) {
2072                 muse_camera_msg_return1(api, class, ret, module, INT, get_angle);
2073         } else {
2074                 muse_camera_msg_return(api, class, ret, module);
2075         }
2076
2077         return MUSE_CAMERA_ERROR_NONE;
2078 }
2079
2080 int camera_dispatcher_attr_set_theater_mode(muse_module_h module)
2081 {
2082         int ret = CAMERA_ERROR_NONE;
2083         muse_camera_handle_s *muse_camera = NULL;
2084         int set_mode;
2085         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_THEATER_MODE;
2086         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2087
2088         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2089
2090         muse_camera_msg_get(set_mode, muse_core_client_get_msg(module));
2091
2092         LOGD("handle : %p", muse_camera);
2093
2094         ret = legacy_camera_attr_set_theater_mode(muse_camera->camera_handle, (camera_attr_theater_mode_e)set_mode);
2095
2096         muse_camera_msg_return(api, class, ret, module);
2097
2098         return MUSE_CAMERA_ERROR_NONE;
2099 }
2100
2101 int camera_dispatcher_attr_get_theater_mode(muse_module_h module)
2102 {
2103         int ret = CAMERA_ERROR_NONE;
2104         muse_camera_handle_s *muse_camera = NULL;
2105         camera_attr_theater_mode_e get_mode = CAMERA_ATTR_THEATER_MODE_DISABLE;
2106         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_THEATER_MODE;
2107         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2108
2109         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2110
2111         LOGD("handle : %p", muse_camera);
2112
2113         ret = legacy_camera_attr_get_theater_mode(muse_camera->camera_handle, &get_mode);
2114         if (ret == CAMERA_ERROR_NONE) {
2115                 muse_camera_msg_return1(api, class, ret, module, INT, get_mode);
2116         } else {
2117                 muse_camera_msg_return(api, class, ret, module);
2118         }
2119
2120         return MUSE_CAMERA_ERROR_NONE;
2121 }
2122
2123 int camera_dispatcher_attr_foreach_supported_theater_mode(muse_module_h module)
2124 {
2125         int ret = CAMERA_ERROR_NONE;
2126         muse_camera_handle_s *muse_camera = NULL;
2127         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_THEATER_MODE;
2128         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_THREAD_SUB;
2129
2130         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2131         LOGD("handle : %p", muse_camera);
2132
2133         ret = legacy_camera_attr_foreach_supported_theater_mode(muse_camera->camera_handle,
2134                                                                 (camera_attr_supported_theater_mode_cb)_camera_dispatcher_callback_supported_theater_mode,
2135                                                                 (void *)module);
2136
2137         muse_camera_msg_return(api, class, ret, module);
2138
2139         return MUSE_CAMERA_ERROR_NONE;
2140 }
2141
2142 int camera_dispatcher_attr_set_preview_fps(muse_module_h module)
2143 {
2144         int ret = CAMERA_ERROR_NONE;
2145         muse_camera_handle_s *muse_camera = NULL;
2146         int set_fps;
2147         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_PREVIEW_FPS;
2148         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2149
2150         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2151
2152         muse_camera_msg_get(set_fps, muse_core_client_get_msg(module));
2153
2154         LOGD("handle : %p", muse_camera);
2155
2156         ret = legacy_camera_attr_set_preview_fps(muse_camera->camera_handle, (camera_attr_fps_e)set_fps);
2157
2158         muse_camera_msg_return(api, class, ret, module);
2159
2160         return MUSE_CAMERA_ERROR_NONE;
2161 }
2162
2163 int camera_dispatcher_attr_set_image_quality(muse_module_h module)
2164 {
2165         int ret = CAMERA_ERROR_NONE;
2166         muse_camera_handle_s *muse_camera = NULL;
2167         int quality;
2168         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_IMAGE_QUALITY;
2169         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2170
2171         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2172
2173         muse_camera_msg_get(quality, muse_core_client_get_msg(module));
2174
2175         LOGD("handle : 0x%x, image_quality : %d", muse_camera, quality);
2176
2177         ret = legacy_camera_attr_set_image_quality(muse_camera->camera_handle, quality);
2178
2179         LOGD("ret : 0x%x", ret);
2180
2181         muse_camera_msg_return(api, class, ret, module);
2182
2183         return MUSE_CAMERA_ERROR_NONE;
2184 }
2185
2186 int camera_dispatcher_attr_get_preview_fps(muse_module_h module)
2187 {
2188         int ret = CAMERA_ERROR_NONE;
2189         muse_camera_handle_s *muse_camera = NULL;
2190         camera_attr_fps_e get_fps = CAMERA_ATTR_FPS_AUTO;
2191         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_PREVIEW_FPS;
2192         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2193
2194         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2195
2196         LOGD("handle : %p", muse_camera);
2197
2198         ret = legacy_camera_attr_get_preview_fps(muse_camera->camera_handle, &get_fps);
2199         if (ret == CAMERA_ERROR_NONE) {
2200                 muse_camera_msg_return1(api, class, ret, module, INT, get_fps);
2201         } else {
2202                 muse_camera_msg_return(api, class, ret, module);
2203         }
2204
2205         return MUSE_CAMERA_ERROR_NONE;
2206 }
2207
2208 int camera_dispatcher_attr_get_image_quality(muse_module_h module)
2209 {
2210         int ret = CAMERA_ERROR_NONE;
2211         muse_camera_handle_s *muse_camera = NULL;
2212         int get_quality = 0;
2213         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_IMAGE_QUALITY;
2214         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2215
2216         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2217
2218         LOGD("handle : %p", muse_camera);
2219
2220         ret = legacy_camera_attr_get_image_quality(muse_camera->camera_handle, &get_quality);
2221         if (ret == CAMERA_ERROR_NONE) {
2222                 muse_camera_msg_return1(api, class, ret, module, INT, get_quality);
2223         } else {
2224                 muse_camera_msg_return(api, class, ret, module);
2225         }
2226
2227         return MUSE_CAMERA_ERROR_NONE;
2228 }
2229
2230 int camera_dispatcher_attr_set_zoom(muse_module_h module)
2231 {
2232         int ret = CAMERA_ERROR_NONE;
2233         muse_camera_handle_s *muse_camera = NULL;
2234         int zoom;
2235         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_ZOOM;
2236         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2237
2238         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2239
2240         muse_camera_msg_get(zoom, muse_core_client_get_msg(module));
2241
2242         LOGD("handle : 0x%x, zoom : %d", muse_camera, zoom);
2243
2244         ret = legacy_camera_attr_set_zoom(muse_camera->camera_handle, zoom);
2245
2246         LOGD("ret : 0x%x", ret);
2247
2248         muse_camera_msg_return(api, class, ret, module);
2249
2250         return MUSE_CAMERA_ERROR_NONE;
2251 }
2252
2253 int camera_dispatcher_attr_set_af_mode(muse_module_h module)
2254 {
2255         int ret = CAMERA_ERROR_NONE;
2256         muse_camera_handle_s *muse_camera = NULL;
2257         int set_mode;
2258         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_AF_MODE;
2259         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2260
2261         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2262
2263         muse_camera_msg_get(set_mode, muse_core_client_get_msg(module));
2264
2265         LOGD("handle : 0x%x, set_mode : %d", muse_camera, set_mode);
2266
2267         ret = legacy_camera_attr_set_af_mode(muse_camera->camera_handle, (camera_attr_af_mode_e)set_mode);
2268
2269         LOGD("ret : 0x%x", ret);
2270
2271         muse_camera_msg_return(api, class, ret, module);
2272
2273         return MUSE_CAMERA_ERROR_NONE;
2274 }
2275
2276 int camera_dispatcher_attr_set_af_area(muse_module_h module)
2277 {
2278         int ret = CAMERA_ERROR_NONE;
2279         muse_camera_handle_s *muse_camera = NULL;
2280         int x;
2281         int y;
2282         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_AF_AREA;
2283         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2284
2285         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2286
2287         muse_camera_msg_get(x, muse_core_client_get_msg(module));
2288         muse_camera_msg_get(y, muse_core_client_get_msg(module));
2289
2290         LOGD("handle : %p", muse_camera);
2291
2292         ret = legacy_camera_attr_set_af_area(muse_camera->camera_handle, x, y);
2293
2294         LOGD("ret : 0x%x", ret);
2295
2296         muse_camera_msg_return(api, class, ret, module);
2297
2298         return MUSE_CAMERA_ERROR_NONE;
2299 }
2300
2301 int camera_dispatcher_attr_clear_af_area(muse_module_h module)
2302 {
2303         int ret = CAMERA_ERROR_NONE;
2304         muse_camera_handle_s *muse_camera = NULL;
2305         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_CLEAR_AF_AREA;
2306         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2307
2308         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2309
2310         LOGD("handle : %p", muse_camera);
2311
2312         ret = legacy_camera_attr_clear_af_area(muse_camera->camera_handle);
2313
2314         LOGD("ret : 0x%x", ret);
2315
2316         muse_camera_msg_return(api, class, ret, module);
2317
2318         return MUSE_CAMERA_ERROR_NONE;
2319 }
2320
2321 int camera_dispatcher_attr_set_exposure_mode(muse_module_h module)
2322 {
2323         int ret = CAMERA_ERROR_NONE;
2324         muse_camera_handle_s *muse_camera = NULL;
2325         int set_mode;
2326         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_EXPOSURE_MODE;
2327         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2328
2329         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2330
2331         muse_camera_msg_get(set_mode, muse_core_client_get_msg(module));
2332
2333         LOGD("handle : 0x%x, set_mode : %d", muse_camera, set_mode);
2334
2335         ret = legacy_camera_attr_set_exposure_mode(muse_camera->camera_handle, (camera_attr_exposure_mode_e)set_mode);
2336
2337         LOGD("ret : 0x%x", ret);
2338
2339         muse_camera_msg_return(api, class, ret, module);
2340
2341         return MUSE_CAMERA_ERROR_NONE;
2342 }
2343
2344 int camera_dispatcher_attr_set_exposure(muse_module_h module)
2345 {
2346         int ret = CAMERA_ERROR_NONE;
2347         muse_camera_handle_s *muse_camera = NULL;
2348         int value;
2349         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_EXPOSURE;
2350         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2351
2352         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2353
2354         muse_camera_msg_get(value, muse_core_client_get_msg(module));
2355
2356         LOGD("handle : 0x%x, value : %d", muse_camera, value);
2357
2358         ret = legacy_camera_attr_set_exposure(muse_camera->camera_handle, value);
2359
2360         LOGD("ret : 0x%x", ret);
2361
2362         muse_camera_msg_return(api, class, ret, module);
2363
2364         return MUSE_CAMERA_ERROR_NONE;
2365 }
2366
2367 int camera_dispatcher_attr_set_iso(muse_module_h module)
2368 {
2369         int ret = CAMERA_ERROR_NONE;
2370         muse_camera_handle_s *muse_camera = NULL;
2371         int set_iso;
2372         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_ISO;
2373         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2374
2375         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2376
2377         muse_camera_msg_get(set_iso, muse_core_client_get_msg(module));
2378
2379         LOGD("handle : 0x%x, set_iso : %d", muse_camera, set_iso);
2380
2381         ret = legacy_camera_attr_set_iso(muse_camera->camera_handle, (camera_attr_iso_e)set_iso);
2382
2383         LOGD("ret : 0x%x", ret);
2384
2385         muse_camera_msg_return(api, class, ret, module);
2386
2387         return MUSE_CAMERA_ERROR_NONE;
2388 }
2389
2390 int camera_dispatcher_attr_set_brightness(muse_module_h module)
2391 {
2392         int ret = CAMERA_ERROR_NONE;
2393         muse_camera_handle_s *muse_camera = NULL;
2394         int level;
2395         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_BRIGHTNESS;
2396         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2397
2398         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2399
2400         muse_camera_msg_get(level, muse_core_client_get_msg(module));
2401
2402         LOGD("handle : 0x%x, level : %d", muse_camera, level);
2403
2404         ret = legacy_camera_attr_set_brightness(muse_camera->camera_handle, level);
2405
2406         LOGD("ret : 0x%x", ret);
2407
2408         muse_camera_msg_return(api, class, ret, module);
2409
2410         return MUSE_CAMERA_ERROR_NONE;
2411 }
2412
2413 int camera_dispatcher_attr_set_contrast(muse_module_h module)
2414 {
2415         int ret = CAMERA_ERROR_NONE;
2416         muse_camera_handle_s *muse_camera = NULL;
2417         int level;
2418         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_CONTRAST;
2419         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2420
2421         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2422
2423         muse_camera_msg_get(level, muse_core_client_get_msg(module));
2424
2425         LOGD("handle : 0x%x, level : %d", muse_camera, level);
2426
2427         ret = legacy_camera_attr_set_contrast(muse_camera->camera_handle, level);
2428
2429         LOGD("ret : 0x%x", ret);
2430
2431         muse_camera_msg_return(api, class, ret, module);
2432
2433         return MUSE_CAMERA_ERROR_NONE;
2434 }
2435
2436 int camera_dispatcher_attr_set_whitebalance(muse_module_h module)
2437 {
2438         int ret = CAMERA_ERROR_NONE;
2439         muse_camera_handle_s *muse_camera = NULL;
2440         int set_whitebalance;
2441         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_WHITEBALANCE;
2442         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2443
2444         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2445
2446         muse_camera_msg_get(set_whitebalance, muse_core_client_get_msg(module));
2447
2448         LOGD("handle : 0x%x, set_whitebalance : %d", muse_camera, set_whitebalance);
2449
2450         ret = legacy_camera_attr_set_whitebalance(muse_camera->camera_handle, (camera_attr_whitebalance_e)set_whitebalance);
2451
2452         LOGD("ret : 0x%x", ret);
2453
2454         muse_camera_msg_return(api, class, ret, module);
2455
2456         return MUSE_CAMERA_ERROR_NONE;
2457 }
2458
2459 int camera_dispatcher_attr_set_effect(muse_module_h module)
2460 {
2461         int ret = CAMERA_ERROR_NONE;
2462         muse_camera_handle_s *muse_camera = NULL;
2463         int set_effect;
2464         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_EFFECT;
2465         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2466
2467         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2468
2469         muse_camera_msg_get(set_effect, muse_core_client_get_msg(module));
2470
2471         LOGD("handle : 0x%x, set_effect : %d", muse_camera, set_effect);
2472
2473         ret = legacy_camera_attr_set_effect(muse_camera->camera_handle, (camera_attr_effect_mode_e)set_effect);
2474
2475         LOGD("ret : 0x%x", ret);
2476
2477         muse_camera_msg_return(api, class, ret, module);
2478
2479         return MUSE_CAMERA_ERROR_NONE;
2480 }
2481
2482 int camera_dispatcher_attr_set_scene_mode(muse_module_h module)
2483 {
2484         int ret = CAMERA_ERROR_NONE;
2485         muse_camera_handle_s *muse_camera = NULL;
2486         int set_mode;
2487         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_SCENE_MODE;
2488         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2489
2490         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2491
2492         muse_camera_msg_get(set_mode, muse_core_client_get_msg(module));
2493
2494         LOGD("handle : 0x%x, set_mode : %d", muse_camera, set_mode);
2495
2496         ret = legacy_camera_attr_set_scene_mode(muse_camera->camera_handle, (camera_attr_scene_mode_e)set_mode);
2497
2498         LOGD("ret : 0x%x", ret);
2499
2500         muse_camera_msg_return(api, class, ret, module);
2501
2502         return MUSE_CAMERA_ERROR_NONE;
2503 }
2504
2505 int camera_dispatcher_attr_enable_tag(muse_module_h module)
2506 {
2507         int ret = CAMERA_ERROR_NONE;
2508         muse_camera_handle_s *muse_camera = NULL;
2509         int set_enable;
2510         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_ENABLE_TAG;
2511         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2512
2513         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2514
2515         muse_camera_msg_get(set_enable, muse_core_client_get_msg(module));
2516
2517         LOGD("handle : 0x%x, set_enable : %d", muse_camera, set_enable);
2518
2519         ret = legacy_camera_attr_enable_tag(muse_camera->camera_handle, (bool)set_enable);
2520
2521         LOGD("ret : 0x%x", ret);
2522
2523         muse_camera_msg_return(api, class, ret, module);
2524
2525         return MUSE_CAMERA_ERROR_NONE;
2526 }
2527
2528 int camera_dispatcher_attr_set_tag_image_description(muse_module_h module)
2529 {
2530         int ret = CAMERA_ERROR_NONE;
2531         muse_camera_handle_s *muse_camera = NULL;
2532         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_TAG_IMAGE_DESCRIPTION;
2533         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2534         char description[MUSE_CAMERA_MSG_MAX_LENGTH] = {0,};
2535
2536         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2537
2538         muse_camera_msg_get_string(description, muse_core_client_get_msg(module));
2539
2540         LOGD("handle : 0x%x, description : %s", muse_camera, description);
2541
2542         ret = legacy_camera_attr_set_tag_image_description(muse_camera->camera_handle, description);
2543
2544         LOGD("ret : 0x%x", ret);
2545
2546         muse_camera_msg_return(api, class, ret, module);
2547
2548         return MUSE_CAMERA_ERROR_NONE;
2549 }
2550
2551 int camera_dispatcher_attr_set_tag_orientation(muse_module_h module)
2552 {
2553         int ret = CAMERA_ERROR_NONE;
2554         muse_camera_handle_s *muse_camera = NULL;
2555         int set_orientation;
2556         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_TAG_ORIENTATION;
2557         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2558
2559         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2560
2561         muse_camera_msg_get(set_orientation, muse_core_client_get_msg(module));
2562
2563         LOGD("handle : 0x%x, set_orientation : %d", muse_camera, set_orientation);
2564
2565         ret = legacy_camera_attr_set_tag_orientation(muse_camera->camera_handle, (camera_attr_tag_orientation_e)set_orientation);
2566
2567         LOGD("ret : 0x%x", ret);
2568
2569         muse_camera_msg_return(api, class, ret, module);
2570
2571         return MUSE_CAMERA_ERROR_NONE;
2572 }
2573
2574 int camera_dispatcher_attr_set_tag_software(muse_module_h module)
2575 {
2576         int ret = CAMERA_ERROR_NONE;
2577         muse_camera_handle_s *muse_camera = NULL;
2578         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_TAG_SOFTWARE;
2579         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2580         char software[MUSE_CAMERA_MSG_MAX_LENGTH] = {0,};
2581
2582         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2583
2584         muse_camera_msg_get_string(software, muse_core_client_get_msg(module));
2585
2586         LOGD("handle : 0x%x, software : %s", muse_camera, software);
2587
2588         ret = legacy_camera_attr_set_tag_software(muse_camera->camera_handle, software);
2589
2590         LOGD("ret : 0x%x", ret);
2591
2592         muse_camera_msg_return(api, class, ret, module);
2593
2594         return MUSE_CAMERA_ERROR_NONE;
2595 }
2596
2597 int camera_dispatcher_attr_set_geotag(muse_module_h module)
2598 {
2599         int ret = CAMERA_ERROR_NONE;
2600         muse_camera_handle_s *muse_camera = NULL;
2601         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_GEOTAG;
2602         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2603         double set_geotag[3] = {0,};
2604
2605         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2606
2607         muse_camera_msg_get_array(set_geotag, muse_core_client_get_msg(module));
2608
2609         LOGD("handle : 0x%x, set_geotag1 : %d, set_geotag2 : %d, set_geotag3 : %d",
2610              muse_camera, set_geotag[0], set_geotag[1], set_geotag[2]);
2611
2612         ret = legacy_camera_attr_set_geotag(muse_camera->camera_handle, set_geotag[0], set_geotag[1], set_geotag[2]);
2613
2614         LOGD("ret : 0x%x", ret);
2615
2616         muse_camera_msg_return(api, class, ret, module);
2617
2618         return MUSE_CAMERA_ERROR_NONE;
2619 }
2620
2621 int camera_dispatcher_attr_remove_geotag(muse_module_h module)
2622 {
2623         int ret = CAMERA_ERROR_NONE;
2624         muse_camera_handle_s *muse_camera = NULL;
2625         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_REMOVE_GEOTAG;
2626         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2627
2628         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2629
2630         LOGD("handle : %p", muse_camera);
2631
2632         ret = legacy_camera_attr_remove_geotag(muse_camera->camera_handle);
2633
2634         LOGD("ret : 0x%x", ret);
2635
2636         muse_camera_msg_return(api, class, ret, module);
2637
2638         return MUSE_CAMERA_ERROR_NONE;
2639 }
2640
2641 int camera_dispatcher_attr_set_flash_mode(muse_module_h module)
2642 {
2643         int ret = CAMERA_ERROR_NONE;
2644         muse_camera_handle_s *muse_camera = NULL;
2645         int set_mode;
2646         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_FLASH_MODE;
2647         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2648
2649         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2650
2651         muse_camera_msg_get(set_mode, muse_core_client_get_msg(module));
2652
2653         LOGD("handle : 0x%x, set_mode : %d", muse_camera, set_mode);
2654
2655         ret = legacy_camera_attr_set_flash_mode(muse_camera->camera_handle, (camera_attr_flash_mode_e)set_mode);
2656
2657         LOGD("ret : 0x%x", ret);
2658
2659         muse_camera_msg_return(api, class, ret, module);
2660
2661         return MUSE_CAMERA_ERROR_NONE;
2662 }
2663
2664 int camera_dispatcher_attr_get_zoom(muse_module_h module)
2665 {
2666         int ret = CAMERA_ERROR_NONE;
2667         muse_camera_handle_s *muse_camera = NULL;
2668         int get_zoom = 0;
2669         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_ZOOM;
2670         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2671
2672         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2673
2674         LOGD("handle : %p", muse_camera);
2675
2676         ret = legacy_camera_attr_get_zoom(muse_camera->camera_handle, &get_zoom);
2677         if (ret == CAMERA_ERROR_NONE) {
2678                 muse_camera_msg_return1(api, class, ret, module, INT, get_zoom);
2679         } else {
2680                 muse_camera_msg_return(api, class, ret, module);
2681         }
2682
2683         return MUSE_CAMERA_ERROR_NONE;
2684 }
2685
2686 int camera_dispatcher_attr_get_zoom_range(muse_module_h module)
2687 {
2688         int ret = CAMERA_ERROR_NONE;
2689         muse_camera_handle_s *muse_camera = NULL;
2690         int get_min = 0;
2691         int get_max = 0;
2692         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_ZOOM_RANGE;
2693         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2694
2695         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2696
2697         LOGD("handle : %p", muse_camera);
2698
2699         ret = legacy_camera_attr_get_zoom_range(muse_camera->camera_handle, &get_min, &get_max);
2700         if (ret == CAMERA_ERROR_NONE) {
2701                 muse_camera_msg_return2(api, class, ret, module, INT, get_min, INT, get_max);
2702         } else {
2703                 muse_camera_msg_return(api, class, ret, module);
2704         }
2705
2706         return MUSE_CAMERA_ERROR_NONE;
2707 }
2708
2709 int camera_dispatcher_attr_get_af_mode(muse_module_h module)
2710 {
2711         int ret = CAMERA_ERROR_NONE;
2712         muse_camera_handle_s *muse_camera = NULL;
2713         camera_attr_af_mode_e get_mode = CAMERA_ATTR_AF_NONE;
2714         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_AF_MODE;
2715         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2716
2717         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2718
2719         LOGD("handle : %p", muse_camera);
2720
2721         ret = legacy_camera_attr_get_af_mode(muse_camera->camera_handle, &get_mode);
2722         if (ret == CAMERA_ERROR_NONE) {
2723                 muse_camera_msg_return1(api, class, ret, module, INT, get_mode);
2724         } else {
2725                 muse_camera_msg_return(api, class, ret, module);
2726         }
2727
2728         return MUSE_CAMERA_ERROR_NONE;
2729 }
2730
2731 int camera_dispatcher_attr_get_exposure_mode(muse_module_h module)
2732 {
2733         int ret = CAMERA_ERROR_NONE;
2734         muse_camera_handle_s *muse_camera = NULL;
2735         camera_attr_exposure_mode_e get_mode = CAMERA_ATTR_EXPOSURE_MODE_OFF;
2736         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_EXPOSURE_MODE;
2737         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2738
2739         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2740
2741         LOGD("handle : %p", muse_camera);
2742
2743         ret = legacy_camera_attr_get_exposure_mode(muse_camera->camera_handle, &get_mode);
2744         if (ret == CAMERA_ERROR_NONE) {
2745                 muse_camera_msg_return1(api, class, ret, module, INT, get_mode);
2746         } else {
2747                 muse_camera_msg_return(api, class, ret, module);
2748         }
2749
2750         return MUSE_CAMERA_ERROR_NONE;
2751 }
2752
2753 int camera_dispatcher_attr_get_exposure(muse_module_h module)
2754 {
2755         int ret = CAMERA_ERROR_NONE;
2756         muse_camera_handle_s *muse_camera = NULL;
2757         int get_value = 0;
2758         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_EXPOSURE;
2759         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2760
2761         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2762
2763         LOGD("handle : %p", muse_camera);
2764
2765         ret = legacy_camera_attr_get_exposure(muse_camera->camera_handle, &get_value);
2766         if (ret == CAMERA_ERROR_NONE) {
2767                 muse_camera_msg_return1(api, class, ret, module, INT, get_value);
2768         } else {
2769                 muse_camera_msg_return(api, class, ret, module);
2770         }
2771
2772         return MUSE_CAMERA_ERROR_NONE;
2773 }
2774
2775 int camera_dispatcher_attr_get_exposure_range(muse_module_h module)
2776 {
2777         int ret = CAMERA_ERROR_NONE;
2778         muse_camera_handle_s *muse_camera = NULL;
2779         int get_min = 0;
2780         int get_max = 0;
2781         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_EXPOSURE_RANGE;
2782         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2783
2784         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2785
2786         LOGD("handle : %p", muse_camera);
2787
2788         ret = legacy_camera_attr_get_exposure_range(muse_camera->camera_handle, &get_min, &get_max);
2789         if (ret == CAMERA_ERROR_NONE) {
2790                 muse_camera_msg_return2(api, class, ret, module, INT, get_min, INT, get_max);
2791         } else {
2792                 muse_camera_msg_return(api, class, ret, module);
2793         }
2794
2795         return MUSE_CAMERA_ERROR_NONE;
2796 }
2797
2798 int camera_dispatcher_attr_get_iso(muse_module_h module)
2799 {
2800         int ret = CAMERA_ERROR_NONE;
2801         muse_camera_handle_s *muse_camera = NULL;
2802         camera_attr_iso_e get_iso = CAMERA_ATTR_ISO_AUTO;
2803         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_ISO;
2804         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2805
2806         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2807
2808         LOGD("handle : %p", muse_camera);
2809
2810         ret = legacy_camera_attr_get_iso(muse_camera->camera_handle, &get_iso);
2811         if (ret == CAMERA_ERROR_NONE) {
2812                 muse_camera_msg_return1(api, class, ret, module, INT, get_iso);
2813         } else {
2814                 muse_camera_msg_return(api, class, ret, module);
2815         }
2816
2817         return MUSE_CAMERA_ERROR_NONE;
2818 }
2819
2820 int camera_dispatcher_attr_get_brightness(muse_module_h module)
2821 {
2822         int ret = CAMERA_ERROR_NONE;
2823         muse_camera_handle_s *muse_camera = NULL;
2824         int get_level = 0;
2825         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_BRIGHTNESS;
2826         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2827
2828         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2829
2830         LOGD("handle : %p", muse_camera);
2831
2832         ret = legacy_camera_attr_get_brightness(muse_camera->camera_handle, &get_level);
2833         if (ret == CAMERA_ERROR_NONE) {
2834                 muse_camera_msg_return1(api, class, ret, module, INT, get_level);
2835         } else {
2836                 muse_camera_msg_return(api, class, ret, module);
2837         }
2838
2839         return MUSE_CAMERA_ERROR_NONE;
2840 }
2841
2842 int camera_dispatcher_attr_get_brightness_range(muse_module_h module)
2843 {
2844         int ret = CAMERA_ERROR_NONE;
2845         muse_camera_handle_s *muse_camera = NULL;
2846         int get_min = 0;
2847         int get_max = 0;
2848         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_BRIGHTNESS_RANGE;
2849         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2850
2851         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2852
2853         LOGD("handle : %p", muse_camera);
2854
2855         ret = legacy_camera_attr_get_brightness_range(muse_camera->camera_handle, &get_min, &get_max);
2856         if (ret == CAMERA_ERROR_NONE) {
2857                 muse_camera_msg_return2(api, class, ret, module, INT, get_min, INT, get_max);
2858         } else {
2859                 muse_camera_msg_return(api, class, ret, module);
2860         }
2861
2862         return MUSE_CAMERA_ERROR_NONE;
2863 }
2864
2865 int camera_dispatcher_attr_get_contrast(muse_module_h module)
2866 {
2867         int ret = CAMERA_ERROR_NONE;
2868         muse_camera_handle_s *muse_camera = NULL;
2869         int get_level = 0;
2870         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_CONTRAST;
2871         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2872
2873         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2874
2875         LOGD("handle : %p", muse_camera);
2876
2877         ret = legacy_camera_attr_get_contrast(muse_camera->camera_handle, &get_level);
2878         if (ret == CAMERA_ERROR_NONE) {
2879                 muse_camera_msg_return1(api, class, ret, module, INT, get_level);
2880         } else {
2881                 muse_camera_msg_return(api, class, ret, module);
2882         }
2883
2884         return MUSE_CAMERA_ERROR_NONE;
2885 }
2886
2887 int camera_dispatcher_attr_get_contrast_range(muse_module_h module)
2888 {
2889         int ret = CAMERA_ERROR_NONE;
2890         muse_camera_handle_s *muse_camera = NULL;
2891         int get_min = 0;
2892         int get_max = 0;
2893         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_CONTRAST_RANGE;
2894         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2895
2896         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2897
2898         LOGD("handle : %p", muse_camera);
2899
2900         ret = legacy_camera_attr_get_contrast_range(muse_camera->camera_handle, &get_min, &get_max);
2901         if (ret == CAMERA_ERROR_NONE) {
2902                 muse_camera_msg_return2(api, class, ret, module, INT, get_min, INT, get_max);
2903         } else {
2904                 muse_camera_msg_return(api, class, ret, module);
2905         }
2906
2907         return MUSE_CAMERA_ERROR_NONE;
2908 }
2909
2910 int camera_dispatcher_attr_get_whitebalance(muse_module_h module)
2911 {
2912         int ret = CAMERA_ERROR_NONE;
2913         muse_camera_handle_s *muse_camera = NULL;
2914         camera_attr_whitebalance_e get_wb = CAMERA_ATTR_WHITE_BALANCE_NONE;
2915         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_WHITEBALANCE;
2916         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2917
2918         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2919
2920         LOGD("handle : %p", muse_camera);
2921
2922         ret = legacy_camera_attr_get_whitebalance(muse_camera->camera_handle, &get_wb);
2923         if (ret == CAMERA_ERROR_NONE) {
2924                 muse_camera_msg_return1(api, class, ret, module, INT, get_wb);
2925         } else {
2926                 muse_camera_msg_return(api, class, ret, module);
2927         }
2928
2929         return MUSE_CAMERA_ERROR_NONE;
2930 }
2931
2932 int camera_dispatcher_attr_get_effect(muse_module_h module)
2933 {
2934         int ret = CAMERA_ERROR_NONE;
2935         muse_camera_handle_s *muse_camera = NULL;
2936         camera_attr_effect_mode_e get_effect = CAMERA_ATTR_EFFECT_NONE;
2937         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_EFFECT;
2938         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2939
2940         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2941
2942         LOGD("handle : %p", muse_camera);
2943
2944         ret = legacy_camera_attr_get_effect(muse_camera->camera_handle, &get_effect);
2945         if (ret == CAMERA_ERROR_NONE) {
2946                 muse_camera_msg_return1(api, class, ret, module, INT, get_effect);
2947         } else {
2948                 muse_camera_msg_return(api, class, ret, module);
2949         }
2950
2951         return MUSE_CAMERA_ERROR_NONE;
2952 }
2953
2954 int camera_dispatcher_attr_get_scene_mode(muse_module_h module)
2955 {
2956         int ret = CAMERA_ERROR_NONE;
2957         muse_camera_handle_s *muse_camera = NULL;
2958         camera_attr_scene_mode_e get_mode = CAMERA_ATTR_SCENE_MODE_NORMAL;
2959         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_SCENE_MODE;
2960         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2961
2962         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2963
2964         LOGD("handle : %p", muse_camera);
2965
2966         ret = legacy_camera_attr_get_scene_mode(muse_camera->camera_handle, &get_mode);
2967         if (ret == CAMERA_ERROR_NONE) {
2968                 muse_camera_msg_return1(api, class, ret, module, INT, get_mode);
2969         } else {
2970                 muse_camera_msg_return(api, class, ret, module);
2971         }
2972
2973         return MUSE_CAMERA_ERROR_NONE;
2974 }
2975
2976 int camera_dispatcher_attr_is_enabled_tag(muse_module_h module)
2977 {
2978         int ret = CAMERA_ERROR_NONE;
2979         muse_camera_handle_s *muse_camera = NULL;
2980         bool get_enabled = false;
2981         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_ENABLED_TAG;
2982         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2983
2984         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2985
2986         LOGD("handle : %p", muse_camera);
2987
2988         ret = legacy_camera_attr_is_enabled_tag(muse_camera->camera_handle, &get_enabled);
2989         if (ret == CAMERA_ERROR_NONE) {
2990                 muse_camera_msg_return1(api, class, ret, module, INT, get_enabled);
2991         } else {
2992                 muse_camera_msg_return(api, class, ret, module);
2993         }
2994
2995         return MUSE_CAMERA_ERROR_NONE;
2996 }
2997
2998 int camera_dispatcher_attr_get_tag_image_description(muse_module_h module)
2999 {
3000         int ret = CAMERA_ERROR_NONE;
3001         muse_camera_handle_s *muse_camera = NULL;
3002         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_TAG_IMAGE_DESCRIPTION;
3003         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3004         char *get_description = NULL;
3005
3006         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3007
3008         ret = legacy_camera_attr_get_tag_image_description(muse_camera->camera_handle, &get_description);
3009         if (ret == CAMERA_ERROR_NONE) {
3010                 LOGD("get_description : %s", muse_camera, get_description);
3011                 muse_camera_msg_return1(api, class, ret, module, STRING, get_description);
3012         } else {
3013                 muse_camera_msg_return(api, class, ret, module);
3014         }
3015
3016         if (get_description) {
3017                 free(get_description);
3018                 get_description = NULL;
3019         }
3020
3021         return MUSE_CAMERA_ERROR_NONE;
3022 }
3023
3024 int camera_dispatcher_attr_get_tag_orientation(muse_module_h module)
3025 {
3026         int ret = CAMERA_ERROR_NONE;
3027         muse_camera_handle_s *muse_camera = NULL;
3028         camera_attr_tag_orientation_e get_orientation = CAMERA_ATTR_TAG_ORIENTATION_TOP_LEFT;
3029         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_TAG_ORIENTATION;
3030         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3031
3032         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3033
3034         LOGD("handle : %p", muse_camera);
3035
3036         ret = legacy_camera_attr_get_tag_orientation(muse_camera->camera_handle, &get_orientation);
3037         if (ret == CAMERA_ERROR_NONE) {
3038                 muse_camera_msg_return1(api, class, ret, module, INT, get_orientation);
3039         } else {
3040                 muse_camera_msg_return(api, class, ret, module);
3041         }
3042
3043         return MUSE_CAMERA_ERROR_NONE;
3044 }
3045
3046 int camera_dispatcher_attr_get_tag_software(muse_module_h module)
3047 {
3048         int ret = CAMERA_ERROR_NONE;
3049         muse_camera_handle_s *muse_camera = NULL;
3050         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_TAG_SOFTWARE;
3051         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3052         char *get_software = NULL;
3053
3054         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3055
3056         ret = legacy_camera_attr_get_tag_software(muse_camera->camera_handle, &get_software);
3057         if (ret == CAMERA_ERROR_NONE) {
3058                 LOGD("get_software : %s", get_software);
3059                 muse_camera_msg_return1(api, class, ret, module, STRING, get_software);
3060         } else {
3061                 muse_camera_msg_return(api, class, ret, module);
3062         }
3063
3064         if (get_software) {
3065                 free(get_software);
3066                 get_software = NULL;
3067         }
3068
3069         return MUSE_CAMERA_ERROR_NONE;
3070 }
3071
3072 int camera_dispatcher_attr_get_geotag(muse_module_h module)
3073 {
3074         int ret = CAMERA_ERROR_NONE;
3075         muse_camera_handle_s *muse_camera = NULL;
3076         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_GEOTAG;
3077         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3078         double get_geotag[3] = {0.0, 0.0, 0.0};
3079
3080         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3081
3082         LOGD("handle : %p", muse_camera);
3083
3084         ret = legacy_camera_attr_get_geotag(muse_camera->camera_handle, &get_geotag[0], &get_geotag[1], &get_geotag[2]);
3085         if (ret == CAMERA_ERROR_NONE) {
3086                 muse_camera_msg_return_array(api, class, ret, module, get_geotag, sizeof(get_geotag), sizeof(double));
3087         } else {
3088                 muse_camera_msg_return(api, class, ret, module);
3089         }
3090
3091         return MUSE_CAMERA_ERROR_NONE;
3092 }
3093
3094 int camera_dispatcher_attr_get_flash_mode(muse_module_h module)
3095 {
3096         int ret = CAMERA_ERROR_NONE;
3097         muse_camera_handle_s *muse_camera = NULL;
3098         camera_attr_flash_mode_e get_mode = CAMERA_ATTR_FLASH_MODE_OFF;
3099         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_FLASH_MODE;
3100         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3101
3102         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3103
3104         LOGD("handle : %p", muse_camera);
3105
3106         ret = legacy_camera_attr_get_flash_mode(muse_camera->camera_handle, &get_mode);
3107         if (ret == CAMERA_ERROR_NONE) {
3108                 muse_camera_msg_return1(api, class, ret, module, INT, get_mode);
3109         } else {
3110                 muse_camera_msg_return(api, class, ret, module);
3111         }
3112
3113         return MUSE_CAMERA_ERROR_NONE;
3114 }
3115
3116 int camera_dispatcher_attr_foreach_supported_af_mode(muse_module_h module)
3117 {
3118         int ret = CAMERA_ERROR_NONE;
3119         muse_camera_handle_s *muse_camera = NULL;
3120         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_AF_MODE;
3121         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_THREAD_SUB;
3122
3123         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3124
3125         LOGD("handle : %p", muse_camera);
3126
3127         ret = legacy_camera_attr_foreach_supported_af_mode(muse_camera->camera_handle,
3128                                                            (camera_attr_supported_af_mode_cb)_camera_dispatcher_callback_supported_af_mode,
3129                                                            (void *)module);
3130
3131         LOGD("ret : 0x%x", ret);
3132
3133         muse_camera_msg_return(api, class, ret, module);
3134
3135         return MUSE_CAMERA_ERROR_NONE;
3136 }
3137
3138 int camera_dispatcher_attr_foreach_supported_exposure_mode(muse_module_h module)
3139 {
3140         int ret = CAMERA_ERROR_NONE;
3141         muse_camera_handle_s *muse_camera = NULL;
3142         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_EXPOSURE_MODE;
3143         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_THREAD_SUB;
3144
3145         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3146
3147         LOGD("handle : 0x%x, api : %d", muse_camera, api);
3148
3149         ret = legacy_camera_attr_foreach_supported_exposure_mode(muse_camera->camera_handle,
3150                                                                  (camera_attr_supported_exposure_mode_cb)_camera_dispatcher_callback_supported_exposure_mode,
3151                                                                  (void *)module);
3152
3153         LOGD("ret : 0x%x", ret);
3154
3155         muse_camera_msg_return(api, class, ret, module);
3156
3157         return MUSE_CAMERA_ERROR_NONE;
3158 }
3159
3160 int camera_dispatcher_attr_foreach_supported_iso(muse_module_h module)
3161 {
3162         int ret = CAMERA_ERROR_NONE;
3163         muse_camera_handle_s *muse_camera = NULL;
3164         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_ISO;
3165         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_THREAD_SUB;
3166
3167         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3168
3169         LOGD("handle : %p", muse_camera);
3170
3171         ret = legacy_camera_attr_foreach_supported_iso(muse_camera->camera_handle,
3172                                                        (camera_attr_supported_iso_cb)_camera_dispatcher_callback_supported_iso_mode,
3173                                                        (void *)module);
3174
3175         LOGD("ret : 0x%x", ret);
3176
3177         muse_camera_msg_return(api, class, ret, module);
3178
3179         return MUSE_CAMERA_ERROR_NONE;
3180 }
3181
3182 int camera_dispatcher_attr_foreach_supported_whitebalance(muse_module_h module)
3183 {
3184         int ret = CAMERA_ERROR_NONE;
3185         muse_camera_handle_s *muse_camera = NULL;
3186         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_WHITEBALANCE;
3187         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_THREAD_SUB;
3188
3189         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3190
3191         LOGD("handle : %p", muse_camera);
3192
3193         ret = legacy_camera_attr_foreach_supported_whitebalance(muse_camera->camera_handle,
3194                                                                 (camera_attr_supported_whitebalance_cb)_camera_dispatcher_callback_supported_whitebalance,
3195                                                                 (void *)module);
3196
3197         LOGD("ret : 0x%x", ret);
3198
3199         muse_camera_msg_return(api, class, ret, module);
3200
3201         return MUSE_CAMERA_ERROR_NONE;
3202 }
3203
3204 int camera_dispatcher_attr_foreach_supported_effect(muse_module_h module)
3205 {
3206         int ret = CAMERA_ERROR_NONE;
3207         muse_camera_handle_s *muse_camera = NULL;
3208         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_EFFECT;
3209         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_THREAD_SUB;
3210
3211         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3212
3213         LOGD("handle : %p", muse_camera);
3214
3215         ret = legacy_camera_attr_foreach_supported_effect(muse_camera->camera_handle,
3216                                                           (camera_attr_supported_effect_cb)_camera_dispatcher_callback_supported_effect,
3217                                                           (void *)module);
3218
3219         LOGD("ret : 0x%x", ret);
3220
3221         muse_camera_msg_return(api, class, ret, module);
3222
3223         return MUSE_CAMERA_ERROR_NONE;
3224 }
3225
3226 int camera_dispatcher_attr_foreach_supported_scene_mode(muse_module_h module)
3227 {
3228         int ret = CAMERA_ERROR_NONE;
3229         muse_camera_handle_s *muse_camera = NULL;
3230         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_SCENE_MODE;
3231         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_THREAD_SUB;
3232
3233         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3234
3235         LOGD("handle : %p", muse_camera);
3236
3237         ret = legacy_camera_attr_foreach_supported_scene_mode(muse_camera->camera_handle,
3238                                                               (camera_attr_supported_scene_mode_cb)_camera_dispatcher_callback_supported_scene_mode,
3239                                                               (void *)module);
3240
3241         LOGD("ret : 0x%x", ret);
3242
3243         muse_camera_msg_return(api, class, ret, module);
3244
3245         return MUSE_CAMERA_ERROR_NONE;
3246 }
3247
3248 int camera_dispatcher_attr_foreach_supported_flash_mode(muse_module_h module)
3249 {
3250         int ret = CAMERA_ERROR_NONE;
3251         muse_camera_handle_s *muse_camera = NULL;
3252         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_FLASH_MODE;
3253         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_THREAD_SUB;
3254
3255         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3256
3257         LOGD("handle : %p", muse_camera);
3258
3259         ret = legacy_camera_attr_foreach_supported_flash_mode(muse_camera->camera_handle,
3260                                                               (camera_attr_supported_flash_mode_cb)_camera_dispatcher_callback_supported_flash_mode,
3261                                                               (void *)module);
3262
3263         LOGD("ret : 0x%x", ret);
3264
3265         muse_camera_msg_return(api, class, ret, module);
3266
3267         return MUSE_CAMERA_ERROR_NONE;
3268 }
3269
3270 int camera_dispatcher_attr_foreach_supported_fps(muse_module_h module)
3271 {
3272         int ret = CAMERA_ERROR_NONE;
3273         muse_camera_handle_s *muse_camera = NULL;
3274         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_FPS;
3275         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_THREAD_SUB;
3276
3277         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3278
3279         LOGD("handle : %p", muse_camera);
3280
3281         ret = legacy_camera_attr_foreach_supported_fps(muse_camera->camera_handle,
3282                                                        (camera_attr_supported_fps_cb)_camera_dispatcher_callback_supported_fps,
3283                                                        (void *)module);
3284
3285         LOGD("ret : 0x%x", ret);
3286
3287         muse_camera_msg_return(api, class, ret, module);
3288
3289         return MUSE_CAMERA_ERROR_NONE;
3290 }
3291
3292 int camera_dispatcher_attr_foreach_supported_fps_by_resolution(muse_module_h module)
3293 {
3294         int ret = CAMERA_ERROR_NONE;
3295         muse_camera_handle_s *muse_camera = NULL;
3296         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_FPS_BY_RESOLUTION;
3297         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_THREAD_SUB;
3298         int width;
3299         int height;
3300
3301         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3302
3303         muse_camera_msg_get(width, muse_core_client_get_msg(module));
3304         muse_camera_msg_get(height, muse_core_client_get_msg(module));
3305
3306         LOGD("handle : %p", muse_camera);
3307
3308         ret = legacy_camera_attr_foreach_supported_fps_by_resolution(muse_camera->camera_handle,
3309                                                                      width, height,
3310                                                                      (camera_attr_supported_fps_cb)_camera_dispatcher_callback_supported_fps_by_resolution,
3311                                                                      (void *)module);
3312
3313         LOGD("ret : 0x%x", ret);
3314
3315         muse_camera_msg_return(api, class, ret, module);
3316
3317         return MUSE_CAMERA_ERROR_NONE;
3318 }
3319
3320 int camera_dispatcher_attr_foreach_supported_stream_flip(muse_module_h module)
3321 {
3322         int ret = CAMERA_ERROR_NONE;
3323         muse_camera_handle_s *muse_camera = NULL;
3324         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_STREAM_FLIP;
3325         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_THREAD_SUB;
3326
3327         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3328
3329         LOGD("handle : %p", muse_camera);
3330
3331         ret = legacy_camera_attr_foreach_supported_stream_flip(muse_camera->camera_handle,
3332                                                                (camera_attr_supported_stream_flip_cb)_camera_dispatcher_callback_supported_stream_flip,
3333                                                                (void *)module);
3334
3335         LOGD("ret : 0x%x", ret);
3336
3337         muse_camera_msg_return(api, class, ret, module);
3338
3339         return MUSE_CAMERA_ERROR_NONE;
3340 }
3341
3342 int camera_dispatcher_attr_foreach_supported_stream_rotation(muse_module_h module)
3343 {
3344         int ret = CAMERA_ERROR_NONE;
3345         muse_camera_handle_s *muse_camera = NULL;
3346         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_STREAM_ROTATION;
3347         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_THREAD_SUB;
3348
3349         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3350
3351         LOGD("handle : %p", muse_camera);
3352
3353         ret = legacy_camera_attr_foreach_supported_stream_rotation(muse_camera->camera_handle,
3354                                                                    (camera_attr_supported_stream_rotation_cb)_camera_dispatcher_callback_supported_stream_rotation,
3355                                                                    (void *)module);
3356
3357         LOGD("ret : 0x%x", ret);
3358
3359         muse_camera_msg_return(api, class, ret, module);
3360
3361         return MUSE_CAMERA_ERROR_NONE;
3362 }
3363
3364 int camera_dispatcher_attr_set_stream_rotation(muse_module_h module)
3365 {
3366         int ret = CAMERA_ERROR_NONE;
3367         muse_camera_handle_s *muse_camera = NULL;
3368         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_STREAM_ROTATION;
3369         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3370         int set_rotation;
3371
3372         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3373
3374         muse_camera_msg_get(set_rotation, muse_core_client_get_msg(module));
3375
3376         LOGD("handle : %p", muse_camera);
3377
3378         ret = legacy_camera_attr_set_stream_rotation(muse_camera->camera_handle, (camera_rotation_e)set_rotation);
3379
3380         LOGD("ret : 0x%x", ret);
3381
3382         muse_camera_msg_return(api, class, ret, module);
3383
3384         return MUSE_CAMERA_ERROR_NONE;
3385 }
3386
3387 int camera_dispatcher_attr_get_stream_rotation(muse_module_h module)
3388 {
3389         int ret = CAMERA_ERROR_NONE;
3390         muse_camera_handle_s *muse_camera = NULL;
3391         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_STREAM_ROTATION;
3392         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3393         camera_rotation_e get_rotation = CAMERA_ROTATION_NONE;
3394
3395         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3396
3397         LOGD("handle : %p", muse_camera);
3398
3399         ret = legacy_camera_attr_get_stream_rotation(muse_camera->camera_handle, &get_rotation);
3400         if (ret == CAMERA_ERROR_NONE) {
3401                 muse_camera_msg_return1(api, class, ret, module, INT, get_rotation);
3402         } else {
3403                 muse_camera_msg_return(api, class, ret, module);
3404         }
3405
3406         return MUSE_CAMERA_ERROR_NONE;
3407 }
3408
3409 int camera_dispatcher_attr_set_stream_flip(muse_module_h module)
3410 {
3411         int ret = CAMERA_ERROR_NONE;
3412         muse_camera_handle_s *muse_camera = NULL;
3413         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_STREAM_FLIP;
3414         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3415         int set_flip;
3416
3417         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3418
3419         muse_camera_msg_get(set_flip, muse_core_client_get_msg(module));
3420
3421         LOGD("handle : %p", muse_camera);
3422
3423         ret = legacy_camera_attr_set_stream_flip(muse_camera->camera_handle, (camera_flip_e)set_flip);
3424
3425         LOGD("ret : 0x%x", ret);
3426
3427         muse_camera_msg_return(api, class, ret, module);
3428
3429         return MUSE_CAMERA_ERROR_NONE;
3430 }
3431
3432 int camera_dispatcher_attr_get_stream_flip(muse_module_h module)
3433 {
3434         int ret = CAMERA_ERROR_NONE;
3435         muse_camera_handle_s *muse_camera = NULL;
3436         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_STREAM_FLIP;
3437         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3438         camera_flip_e get_flip = CAMERA_FLIP_NONE;
3439
3440         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3441
3442         LOGD("handle : %p", muse_camera);
3443
3444         ret = legacy_camera_attr_get_stream_flip(muse_camera->camera_handle, &get_flip);
3445         if (ret == CAMERA_ERROR_NONE) {
3446                 muse_camera_msg_return1(api, class, ret, module, INT, get_flip);
3447         } else {
3448                 muse_camera_msg_return(api, class, ret, module);
3449         }
3450
3451         return MUSE_CAMERA_ERROR_NONE;
3452 }
3453
3454 int camera_dispatcher_attr_set_hdr_mode(muse_module_h module)
3455 {
3456         int ret = CAMERA_ERROR_NONE;
3457         muse_camera_handle_s *muse_camera = NULL;
3458         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_HDR_MODE;
3459         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3460         int set_mode;
3461
3462         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3463
3464         muse_camera_msg_get(set_mode, muse_core_client_get_msg(module));
3465
3466         LOGD("handle : %p", muse_camera);
3467
3468         ret = legacy_camera_attr_set_hdr_mode(muse_camera->camera_handle, (camera_attr_hdr_mode_e)set_mode);
3469
3470         LOGD("ret : 0x%x", ret);
3471
3472         muse_camera_msg_return(api, class, ret, module);
3473
3474         return MUSE_CAMERA_ERROR_NONE;
3475 }
3476
3477 int camera_dispatcher_attr_get_hdr_mode(muse_module_h module)
3478 {
3479         int ret = CAMERA_ERROR_NONE;
3480         muse_camera_handle_s *muse_camera = NULL;
3481         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_HDR_MODE;
3482         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3483         camera_attr_hdr_mode_e get_mode = CAMERA_ATTR_HDR_MODE_DISABLE;
3484
3485         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3486
3487         LOGD("handle : %p", muse_camera);
3488
3489         ret = legacy_camera_attr_get_hdr_mode(muse_camera->camera_handle, &get_mode);
3490         if (ret == CAMERA_ERROR_NONE) {
3491                 muse_camera_msg_return1(api, class, ret, module, INT, get_mode);
3492         } else {
3493                 muse_camera_msg_return(api, class, ret, module);
3494         }
3495
3496         return MUSE_CAMERA_ERROR_NONE;
3497 }
3498
3499 int camera_dispatcher_attr_is_supported_hdr_capture(muse_module_h module)
3500 {
3501         int ret = CAMERA_ERROR_NONE;
3502         muse_camera_handle_s *muse_camera = NULL;
3503         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_SUPPORTED_HDR_CAPTURE;
3504         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3505
3506         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3507
3508         LOGD("handle : %p", muse_camera);
3509
3510         ret = legacy_camera_attr_is_supported_hdr_capture(muse_camera->camera_handle);
3511
3512         LOGD("ret : 0x%x", ret);
3513
3514         muse_camera_msg_return(api, class, ret, module);
3515
3516         return MUSE_CAMERA_ERROR_NONE;
3517 }
3518
3519 int camera_dispatcher_attr_set_hdr_capture_progress_cb(muse_module_h module)
3520 {
3521         int ret = CAMERA_ERROR_NONE;
3522         muse_camera_handle_s *muse_camera = NULL;
3523         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_HDR_CAPTURE_PROGRESS_CB;
3524         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3525
3526         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3527
3528         LOGD("handle : %p", muse_camera);
3529
3530         ret = legacy_camera_attr_set_hdr_capture_progress_cb(muse_camera->camera_handle,
3531                                                              (camera_attr_hdr_progress_cb)_camera_dispatcher_hdr_progress_cb,
3532                                                              (void *)module);
3533
3534         LOGD("ret : 0x%x", ret);
3535
3536         muse_camera_msg_return(api, class, ret, module);
3537
3538         return MUSE_CAMERA_ERROR_NONE;
3539 }
3540
3541 int camera_dispatcher_attr_unset_hdr_capture_progress_cb(muse_module_h module)
3542 {
3543         int ret = CAMERA_ERROR_NONE;
3544         muse_camera_handle_s *muse_camera = NULL;
3545         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_UNSET_HDR_CAPTURE_PROGRESS_CB;
3546         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3547
3548         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3549
3550         LOGD("handle : %p", muse_camera);
3551
3552         ret = legacy_camera_attr_unset_hdr_capture_progress_cb(muse_camera->camera_handle);
3553
3554         LOGD("ret : 0x%x", ret);
3555
3556         muse_camera_msg_return(api, class, ret, module);
3557
3558         return MUSE_CAMERA_ERROR_NONE;
3559 }
3560
3561 int camera_dispatcher_attr_enable_anti_shake(muse_module_h module)
3562 {
3563         int ret = CAMERA_ERROR_NONE;
3564         muse_camera_handle_s *muse_camera = NULL;
3565         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_ENABLE_ANTI_SHAKE;
3566         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3567         int set_enable;
3568
3569         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3570
3571         muse_camera_msg_get(set_enable, muse_core_client_get_msg(module));
3572
3573         LOGD("handle : %p", muse_camera);
3574
3575         ret = legacy_camera_attr_enable_anti_shake(muse_camera->camera_handle, (bool)set_enable);
3576
3577         LOGD("ret : 0x%x", ret);
3578
3579         muse_camera_msg_return(api, class, ret, module);
3580
3581         return MUSE_CAMERA_ERROR_NONE;
3582 }
3583
3584 int camera_dispatcher_attr_is_enabled_anti_shake(muse_module_h module)
3585 {
3586         int ret = CAMERA_ERROR_NONE;
3587         muse_camera_handle_s *muse_camera = NULL;
3588         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_ENABLED_ANTI_SHAKE;
3589         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3590         bool get_enabled = false;
3591
3592         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3593
3594         LOGD("handle : %p", muse_camera);
3595
3596         ret = legacy_camera_attr_is_enabled_anti_shake(muse_camera->camera_handle, &get_enabled);
3597         if (ret == CAMERA_ERROR_NONE) {
3598                 muse_camera_msg_return1(api, class, ret, module, INT, get_enabled);
3599         } else {
3600                 muse_camera_msg_return(api, class, ret, module);
3601         }
3602
3603         return MUSE_CAMERA_ERROR_NONE;
3604 }
3605
3606 int camera_dispatcher_attr_is_supported_anti_shake(muse_module_h module)
3607 {
3608         int ret = CAMERA_ERROR_NONE;
3609         muse_camera_handle_s *muse_camera = NULL;
3610         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_SUPPORTED_ANTI_SHAKE;
3611         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3612
3613         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3614
3615         LOGD("handle : %p", muse_camera);
3616
3617         ret = legacy_camera_attr_is_supported_anti_shake(muse_camera->camera_handle);
3618
3619         LOGD("ret : 0x%x", ret);
3620
3621         muse_camera_msg_return(api, class, ret, module);
3622
3623         return MUSE_CAMERA_ERROR_NONE;
3624 }
3625
3626 int camera_dispatcher_attr_enable_video_stabilization(muse_module_h module)
3627 {
3628         int ret = CAMERA_ERROR_NONE;
3629         muse_camera_handle_s *muse_camera = NULL;
3630         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_ENABLE_VIDEO_STABILIZATION;
3631         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3632         int set_enable;
3633
3634         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3635
3636         muse_camera_msg_get(set_enable, muse_core_client_get_msg(module));
3637
3638         LOGD("handle : %p", muse_camera);
3639
3640         ret = legacy_camera_attr_enable_video_stabilization(muse_camera->camera_handle, (bool)set_enable);
3641
3642         LOGD("ret : 0x%x", ret);
3643
3644         muse_camera_msg_return(api, class, ret, module);
3645
3646         return MUSE_CAMERA_ERROR_NONE;
3647 }
3648
3649 int camera_dispatcher_attr_is_enabled_video_stabilization(muse_module_h module)
3650 {
3651         int ret = CAMERA_ERROR_NONE;
3652         muse_camera_handle_s *muse_camera = NULL;
3653         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_ENABLED_VIDEO_STABILIZATION;
3654         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3655         bool get_enabled = false;
3656
3657         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3658
3659         LOGD("handle : %p", muse_camera);
3660
3661         ret = legacy_camera_attr_is_enabled_video_stabilization(muse_camera->camera_handle, &get_enabled);
3662         if (ret == CAMERA_ERROR_NONE) {
3663                 muse_camera_msg_return1(api, class, ret, module, INT, get_enabled);
3664         } else {
3665                 muse_camera_msg_return(api, class, ret, module);
3666         }
3667
3668         return MUSE_CAMERA_ERROR_NONE;
3669 }
3670
3671 int camera_dispatcher_attr_is_supported_video_stabilization(muse_module_h module)
3672 {
3673         int ret = CAMERA_ERROR_NONE;
3674         muse_camera_handle_s *muse_camera = NULL;
3675         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_SUPPORTED_VIDEO_STABILIZATION;
3676         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3677
3678         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3679
3680         LOGD("handle : %p", muse_camera);
3681
3682         ret = legacy_camera_attr_is_supported_video_stabilization(muse_camera->camera_handle);
3683
3684         LOGD("ret : 0x%x", ret);
3685
3686         muse_camera_msg_return(api, class, ret, module);
3687
3688         return MUSE_CAMERA_ERROR_NONE;
3689 }
3690
3691 int camera_dispatcher_attr_enable_auto_contrast(muse_module_h module)
3692 {
3693         int ret = CAMERA_ERROR_NONE;
3694         muse_camera_handle_s *muse_camera = NULL;
3695         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_ENABLE_AUTO_CONTRAST;
3696         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3697         int set_enable;
3698
3699         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3700
3701         muse_camera_msg_get(set_enable, muse_core_client_get_msg(module));
3702
3703         LOGD("handle : %p", muse_camera);
3704
3705         ret = legacy_camera_attr_enable_auto_contrast(muse_camera->camera_handle, (bool)set_enable);
3706
3707         LOGD("ret : 0x%x", ret);
3708
3709         muse_camera_msg_return(api, class, ret, module);
3710
3711         return MUSE_CAMERA_ERROR_NONE;
3712 }
3713
3714 int camera_dispatcher_attr_is_enabled_auto_contrast(muse_module_h module)
3715 {
3716         int ret = CAMERA_ERROR_NONE;
3717         muse_camera_handle_s *muse_camera = NULL;
3718         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_ENABLED_AUTO_CONTRAST;
3719         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3720         bool get_enabled = false;
3721
3722         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3723
3724         LOGD("handle : %p", muse_camera);
3725
3726         ret = legacy_camera_attr_is_enabled_auto_contrast(muse_camera->camera_handle, &get_enabled);
3727         if (ret == CAMERA_ERROR_NONE) {
3728                 muse_camera_msg_return1(api, class, ret, module, INT, get_enabled);
3729         } else {
3730                 muse_camera_msg_return(api, class, ret, module);
3731         }
3732
3733         return MUSE_CAMERA_ERROR_NONE;
3734 }
3735
3736 int camera_dispatcher_attr_is_supported_auto_contrast(muse_module_h module)
3737 {
3738         int ret = CAMERA_ERROR_NONE;
3739         muse_camera_handle_s *muse_camera = NULL;
3740         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_SUPPORTED_AUTO_CONTRAST;
3741         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3742
3743         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3744
3745         LOGD("handle : %p", muse_camera);
3746
3747         ret = legacy_camera_attr_is_supported_auto_contrast(muse_camera->camera_handle);
3748
3749         LOGD("ret : 0x%x", ret);
3750
3751         muse_camera_msg_return(api, class, ret, module);
3752
3753         return MUSE_CAMERA_ERROR_NONE;
3754 }
3755
3756 int camera_dispatcher_attr_disable_shutter_sound(muse_module_h module)
3757 {
3758         int ret = CAMERA_ERROR_NONE;
3759         muse_camera_handle_s *muse_camera = NULL;
3760         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_DISABLE_SHUTTER_SOUND;
3761         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3762         int set_disable;
3763
3764         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3765
3766         muse_camera_msg_get(set_disable, muse_core_client_get_msg(module));
3767
3768         LOGD("handle : %p", muse_camera);
3769
3770         ret = legacy_camera_attr_disable_shutter_sound(muse_camera->camera_handle, (bool)set_disable);
3771
3772         LOGD("ret : 0x%x", ret);
3773
3774         muse_camera_msg_return(api, class, ret, module);
3775
3776         return MUSE_CAMERA_ERROR_NONE;
3777 }
3778
3779 int camera_dispatcher_return_buffer(muse_module_h module)
3780 {
3781         int tbm_key = 0;
3782         muse_camera_handle_s *muse_camera = NULL;
3783
3784         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3785
3786         muse_camera_msg_get(tbm_key, muse_core_client_get_msg(module));
3787
3788         /*LOGD("handle : %p, key : %d", muse_camera, tbm_key);*/
3789
3790         if (!_camera_remove_export_data(module, tbm_key, FALSE)) {
3791                 LOGE("remove export data failed : key %d", tbm_key);
3792         }
3793
3794         return MUSE_CAMERA_ERROR_NONE;
3795 }
3796
3797 int camera_dispatcher_preview_cb_return(muse_module_h module)
3798 {
3799         muse_camera_handle_s *muse_camera = NULL;
3800
3801         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3802
3803         if (muse_camera == NULL) {
3804                 LOGE("NULL handle");
3805                 return MUSE_CAMERA_ERROR_NONE;
3806         }
3807
3808         /*LOGD("ENTER");*/
3809
3810         g_mutex_lock(&muse_camera->preview_cb_lock);
3811         g_cond_signal(&muse_camera->preview_cb_cond);
3812         /*LOGD("send signal for preview callback");*/
3813         g_mutex_unlock(&muse_camera->preview_cb_lock);
3814
3815         /*LOGD("DONE");*/
3816
3817         return MUSE_CAMERA_ERROR_NONE;
3818 }
3819
3820
3821 int (*dispatcher[MUSE_CAMERA_API_MAX]) (muse_module_h module) = {
3822         camera_dispatcher_create, /* MUSE_CAMERA_API_CREATE */
3823         camera_dispatcher_destroy, /* MUSE_CAMERA_API_DESTROY */
3824         camera_dispatcher_start_preview, /* MUSE_CAMERA_START_PREVIEW */
3825         camera_dispatcher_stop_preview, /* MUSE_CAMERA_API_START_PREVIEW */
3826         camera_dispatcher_start_capture, /* MUSE_CAMERA_START_CAPTURE */
3827         camera_dispatcher_is_supported_continuous_capture, /* MUSE_CAMERA_API_SUPPORT_CONTINUOUS_CAPTURE */
3828         camera_dispatcher_start_continuous_capture, /* MUSE_CAMERA_API_START_CONTINUOUS_CAPTURE, */
3829         camera_dispatcher_stop_continuous_capture, /* MUSE_CAMERA_API_STOP_CONTINUOUS_CAPTURE, */
3830         camera_dispatcher_is_supported_face_detection, /* MUSE_CAMERA_API_SUPPORT_FACE_DETECTION, */
3831         camera_dispatcher_is_supported_zero_shutter_lag, /* MUSE_CAMERA_API_SUPPORT_ZERO_SHUTTER_LAG, */
3832         camera_dispatcher_is_supported_media_packet_preview_cb, /* MUSE_CAMERA_API_SUPPORT_MEDIA_PACKET_PREVIEW_CB, */
3833         camera_dispatcher_get_device_count, /* MUSE_CAMERA_API_GET_DEVICE_COUNT, */
3834         camera_dispatcher_start_face_detection, /* MUSE_CAMERA_API_START_FACE_DETECTION, */
3835         camera_dispatcher_stop_face_detection, /* MUSE_CAMERA_API_STOP_FACE_DETECTION, */
3836         camera_dispatcher_get_state, /* MUSE_CAMERA_API_GET_STATE, */
3837         camera_dispatcher_start_focusing, /* MUSE_CAMERA_API_START_FOCUSING, */
3838         camera_dispatcher_stop_focusing, /* MUSE_CAMERA_API_CANCEL_FOCUSING, */
3839         camera_dispatcher_set_display, /* MUSE_CAMERA_API_SET_DISPLAY, */
3840         camera_dispatcher_set_preview_resolution, /* MUSE_CAMERA_API_SET_PREVIEW_RESOLUTION, */
3841         camera_dispatcher_set_capture_resolution, /* MUSE_CAMERA_API_SET_CAPTURE_RESOLUTION, */
3842         camera_dispatcher_set_capture_format, /* MUSE_CAMERA_API_SET_CAPTURE_FORMAT, */
3843         camera_dispatcher_set_preview_format, /* MUSE_CAMERA_API_SET_PREVIEW_FORMAT, */
3844         camera_dispatcher_get_preview_resolution, /* MUSE_CAMERA_API_GET_PREVIEW_RESOLUTION, */
3845         camera_dispatcher_set_display_rotation, /* MUSE_CAMERA_API_SET_DISPLAY_ROTATION, */
3846         camera_dispatcher_get_display_rotation, /* MUSE_CAMERA_API_GET_DISPLAY_ROTATION, */
3847         camera_dispatcher_set_display_flip, /* MUSE_CAMERA_API_SET_DISPLAY_FLIP, */
3848         camera_dispatcher_get_display_flip, /* MUSE_CAMERA_API_GET_DISPLAY_FLIP, */
3849         camera_dispatcher_set_display_visible, /* MUSE_CAMERA_API_SET_DISPLAY_VISIBLE, */
3850         camera_dispatcher_is_display_visible, /* MUSE_CAMERA_API_IS_DISPLAY_VISIBLE, */
3851         camera_dispatcher_set_display_mode, /* MUSE_CAMERA_API_SET_DISPLAY_MODE, */
3852         camera_dispatcher_get_display_mode, /* MUSE_CAMERA_API_GET_DISPLAY_MODE, */
3853         camera_dispatcher_get_capture_resolution, /* MUSE_CAMERA_API_GET_CAPTURE_RESOLUTION, */
3854         camera_dispatcher_get_capture_format, /* MUSE_CAMERA_API_GET_CAPTURE_FORMAT, */
3855         camera_dispatcher_get_preview_format, /* MUSE_CAMERA_API_GET_PREVIEW_FORMAT, */
3856         camera_dispatcher_get_facing_direction, /* MUSE_CAMERA_API_GET_FACING_DIRECTION, */
3857         camera_dispatcher_set_preview_cb, /* MUSE_CAMERA_API_SET_PREVIEW_CB, */
3858         camera_dispatcher_unset_preview_cb, /* MUSE_CAMERA_API_UNSET_PREVIEW_CB, */
3859         camera_dispatcher_set_media_packet_preview_cb, /* MUSE_CAMERA_API_SET_MEDIA_PACKET_PREVIEW_CB, */
3860         camera_dispatcher_unset_media_packet_preview_cb, /* MUSE_CAMERA_API_UNSET_MEDIA_PACKET_PREVIEW_CB, */
3861         camera_dispatcher_set_state_changed_cb, /* MUSE_CAMERA_API_SET_STATE_CHANGED_CB, */
3862         camera_dispatcher_unset_state_changed_cb, /* MUSE_CAMERA_API_UNSET_STATE_CHANGED_CB, */
3863         camera_dispatcher_set_interrupted_cb, /* MUSE_CAMERA_API_SET_INTERRUPTED_CB, */
3864         camera_dispatcher_unset_interrupted_cb, /* MUSE_CAMERA_API_UNSET_INTERRUPTED_CB, */
3865         camera_dispatcher_set_focus_changed_cb, /* MUSE_CAMERA_API_SET_FOCUS_CHANGED_CB, */
3866         camera_dispatcher_unset_focus_changed_cb, /* MUSE_CAMERA_API_UNSET_FOCUS_CHANGED_CB, */
3867         camera_dispatcher_set_error_cb, /* MUSE_CAMERA_API_SET_ERROR_CB, */
3868         camera_dispatcher_unset_error_cb, /* MUSE_CAMERA_API_UNSET_ERROR_CB, */
3869         camera_dispatcher_foreach_supported_preview_resolution, /* MUSE_CAMERA_API_SET_FOREACH_SUPPORTED_PREVIEW_RESOLUTION, */
3870         camera_dispatcher_foreach_supported_capture_resolution, /* MUSE_CAMERA_API_SET_FOREACH_SUPPORTED_CAPTURE_RESOLUTION, */
3871         camera_dispatcher_foreach_supported_capture_format, /* MUSE_CAMERA_API_SET_FOREACH_SUPPORTED_CAPTURE_FORMAT, */
3872         camera_dispatcher_foreach_supported_preview_format, /* MUSE_CAMERA_API_SET_FOREACH_SUPPORTED_PREVIEW_FORMAT, */
3873         camera_dispatcher_get_recommended_preview_resolution, /* MUSE_CAMERA_API_GET_RECOMMENDED_PREVIEW_RESOLUTION, */
3874         camera_dispatcher_attr_get_lens_orientation, /* MUSE_CAMERA_API_ATTR_GET_LENS_ORIENTATION, */
3875         camera_dispatcher_attr_set_theater_mode, /* MUSE_CAMERA_API_ATTR_SET_THEATER_MODE, */
3876         camera_dispatcher_attr_get_theater_mode, /* MUSE_CAMERA_API_ATTR_GET_THEATER_MODE, */
3877         camera_dispatcher_attr_foreach_supported_theater_mode, /* MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_THEATER_MODE, */
3878         camera_dispatcher_attr_set_preview_fps, /* MUSE_CAMERA_API_ATTR_SET_PREVIEW_FPS, */
3879         camera_dispatcher_attr_set_image_quality, /* MUSE_CAMERA_API_ATTR_SET_IMAGE_QUALITY, */
3880         camera_dispatcher_attr_get_preview_fps, /* MUSE_CAMERA_API_ATTR_GET_PREVIEW_FPS, */
3881         camera_dispatcher_attr_get_image_quality, /* MUSE_CAMERA_API_ATTR_GET_IMAGE_QUALITY, */
3882         camera_dispatcher_attr_set_zoom, /* MUSE_CAMERA_API_ATTR_SET_ZOOM, */
3883         camera_dispatcher_attr_set_af_mode, /* MUSE_CAMERA_API_ATTR_SET_AF_MODE, */
3884         camera_dispatcher_attr_set_af_area, /* MUSE_CAMERA_API_ATTR_SET_AF_AREA, */
3885         camera_dispatcher_attr_clear_af_area, /* MUSE_CAMERA_API_ATTR_CLEAR_AF_AREA, */
3886         camera_dispatcher_attr_set_exposure_mode, /* MUSE_CAMERA_API_ATTR_SET_EXPOSURE_MODE, */
3887         camera_dispatcher_attr_set_exposure, /* MUSE_CAMERA_API_ATTR_SET_EXPOSURE, */
3888         camera_dispatcher_attr_set_iso, /* MUSE_CAMERA_API_ATTR_SET_ISO, */
3889         camera_dispatcher_attr_set_brightness, /* MUSE_CAMERA_API_ATTR_SET_BRIGHTNESS, */
3890         camera_dispatcher_attr_set_contrast, /* MUSE_CAMERA_API_ATTR_SET_CONTRAST, */
3891         camera_dispatcher_attr_set_whitebalance, /* MUSE_CAMERA_API_ATTR_SET_WHITEBALANCE, */
3892         camera_dispatcher_attr_set_effect, /* MUSE_CAMERA_API_ATTR_SET_EFFECT, */
3893         camera_dispatcher_attr_set_scene_mode, /* MUSE_CAMERA_API_ATTR_SET_SCENE_MODE, */
3894         camera_dispatcher_attr_enable_tag, /* MUSE_CAMERA_API_ATTR_ENABLE_TAG, */
3895         camera_dispatcher_attr_set_tag_image_description, /* MUSE_CAMERA_API_ATTR_SET_TAG_IMAGE_DESCRIPTION, */
3896         camera_dispatcher_attr_set_tag_orientation, /* MUSE_CAMERA_API_ATTR_SET_TAG_ORIENTATION, */
3897         camera_dispatcher_attr_set_tag_software, /* MUSE_CAMERA_API_ATTR_SET_TAG_SOFTWARE, */
3898         camera_dispatcher_attr_set_geotag, /* MUSE_CAMERA_API_ATTR_SET_GEOTAG, */
3899         camera_dispatcher_attr_remove_geotag, /* MUSE_CAMERA_API_ATTR_REMOVE_GEOTAG, */
3900         camera_dispatcher_attr_set_flash_mode, /* MUSE_CAMERA_API_ATTR_SET_FLASH_MODE, */
3901         camera_dispatcher_attr_get_zoom, /* MUSE_CAMERA_API_ATTR_GET_ZOOM, */
3902         camera_dispatcher_attr_get_zoom_range, /* MUSE_CAMERA_API_ATTR_GET_ZOOM_RANGE, */
3903         camera_dispatcher_attr_get_af_mode, /* MUSE_CAMERA_API_ATTR_GET_AF_MODE, */
3904         camera_dispatcher_attr_get_exposure_mode, /* MUSE_CAMERA_API_ATTR_GET_EXPOSURE_MODE, */
3905         camera_dispatcher_attr_get_exposure, /* MUSE_CAMERA_API_ATTR_GET_EXPOSURE, */
3906         camera_dispatcher_attr_get_exposure_range, /* MUSE_CAMERA_API_ATTR_GET_EXPOSURE_RANGE, */
3907         camera_dispatcher_attr_get_iso, /* MUSE_CAMERA_API_ATTR_GET_ISO, */
3908         camera_dispatcher_attr_get_brightness, /* MUSE_CAMERA_API_ATTR_GET_BRIGHTNESS, */
3909         camera_dispatcher_attr_get_brightness_range, /* MUSE_CAMERA_API_ATTR_GET_BRIGHTNESS_RANGE, */
3910         camera_dispatcher_attr_get_contrast, /* MUSE_CAMERA_API_ATTR_GET_CONTRAST, */
3911         camera_dispatcher_attr_get_contrast_range, /* MUSE_CAMERA_API_ATTR_GET_CONTRAST_RANGE, */
3912         camera_dispatcher_attr_get_whitebalance, /* MUSE_CAMERA_API_ATTR_GET_WHITEBALANCE, */
3913         camera_dispatcher_attr_get_effect, /* MUSE_CAMERA_API_ATTR_GET_EFFECT, */
3914         camera_dispatcher_attr_get_scene_mode, /* MUSE_CAMERA_API_ATTR_GET_SCENE_MODE, */
3915         camera_dispatcher_attr_is_enabled_tag, /* MUSE_CAMERA_API_ATTR_IS_ENABLED_TAG, */
3916         camera_dispatcher_attr_get_tag_image_description, /* MUSE_CAMERA_API_ATTR_GET_TAG_IMAGE_DESCRIPTION, */
3917         camera_dispatcher_attr_get_tag_orientation, /* MUSE_CAMERA_API_ATTR_GET_TAG_ORIENTATION, */
3918         camera_dispatcher_attr_get_tag_software, /* MUSE_CAMERA_API_ATTR_GET_TAG_SOFTWARE, */
3919         camera_dispatcher_attr_get_geotag, /* MUSE_CAMERA_API_ATTR_GET_GEOTAG, */
3920         camera_dispatcher_attr_get_flash_mode, /* MUSE_CAMERA_API_ATTR_GET_FLASH_MODE, */
3921         camera_dispatcher_attr_foreach_supported_af_mode, /* MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_AF_MODE, */
3922         camera_dispatcher_attr_foreach_supported_exposure_mode, /* MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_EXPOSURE_MODE, */
3923         camera_dispatcher_attr_foreach_supported_iso, /* MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_ISO, */
3924         camera_dispatcher_attr_foreach_supported_whitebalance, /* MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_WHITEBALANCE, */
3925         camera_dispatcher_attr_foreach_supported_effect, /* MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_EFFECT, */
3926         camera_dispatcher_attr_foreach_supported_scene_mode, /* MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_SCENE_MODE, */
3927         camera_dispatcher_attr_foreach_supported_flash_mode, /* MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_FLASH_MODE, */
3928         camera_dispatcher_attr_foreach_supported_fps, /* MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_FPS, */
3929         camera_dispatcher_attr_foreach_supported_fps_by_resolution, /* MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_FPS_BY_RESOLUTION, */
3930         camera_dispatcher_attr_foreach_supported_stream_flip, /* MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_STREAM_FLIP, */
3931         camera_dispatcher_attr_foreach_supported_stream_rotation, /* MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_STREAM_ROTATION, */
3932         camera_dispatcher_attr_set_stream_rotation, /* MUSE_CAMERA_API_ATTR_SET_STREAM_ROTATION, */
3933         camera_dispatcher_attr_get_stream_rotation, /* MUSE_CAMERA_API_ATTR_GET_STREAM_ROTATION, */
3934         camera_dispatcher_attr_set_stream_flip, /* MUSE_CAMERA_API_ATTR_SET_STREAM_FLIP, */
3935         camera_dispatcher_attr_get_stream_flip, /* MUSE_CAMERA_API_ATTR_GET_STREAM_FLIP, */
3936         camera_dispatcher_attr_set_hdr_mode, /* MUSE_CAMERA_API_ATTR_SET_HDR_MODE, */
3937         camera_dispatcher_attr_get_hdr_mode, /* MUSE_CAMERA_API_ATTR_GET_HDR_MODE, */
3938         camera_dispatcher_attr_is_supported_hdr_capture, /* MUSE_CAMERA_API_ATTR_IS_SUPPORTED_HDR_CAPTURE, */
3939         camera_dispatcher_attr_set_hdr_capture_progress_cb, /* MUSE_CAMERA_API_ATTR_SET_HDR_CAPTURE_PROGRESS_CB, */
3940         camera_dispatcher_attr_unset_hdr_capture_progress_cb, /* MUSE_CAMERA_API_ATTR_UNSET_HDR_CAPTURE_PROGRESS_CB, */
3941         camera_dispatcher_attr_enable_anti_shake, /* MUSE_CAMERA_API_ATTR_ENABLE_ANTI_SHAKE, */
3942         camera_dispatcher_attr_is_enabled_anti_shake, /* MUSE_CAMERA_API_ATTR_IS_ENABLED_ANTI_SHAKE, */
3943         camera_dispatcher_attr_is_supported_anti_shake, /* MUSE_CAMERA_API_ATTR_IS_SUPPORTED_ANTI_SHAKE, */
3944         camera_dispatcher_attr_enable_video_stabilization, /* MUSE_CAMERA_API_ATTR_ENABLE_VIDEO_STABILIZATION, */
3945         camera_dispatcher_attr_is_enabled_video_stabilization, /* MUSE_CAMERA_API_ATTR_IS_ENABLED_VIDEO_STABILIZATION, */
3946         camera_dispatcher_attr_is_supported_video_stabilization, /* MUSE_CAMERA_API_ATTR_IS_SUPPORTED_VIDEO_STABILIZATION, */
3947         camera_dispatcher_attr_enable_auto_contrast, /* MUSE_CAMERA_API_ATTR_ENABLE_AUTO_CONTRAST, */
3948         camera_dispatcher_attr_is_enabled_auto_contrast, /* MUSE_CAMERA_API_ATTR_IS_ENABLED_AUTO_CONTRAST, */
3949         camera_dispatcher_attr_is_supported_auto_contrast, /* MUSE_CAMERA_API_ATTR_IS_SUPPORTED_AUTO_CONTRAST, */
3950         camera_dispatcher_attr_disable_shutter_sound, /* MUSE_CAMERA_API_ATTR_DISABLE_SHUTTER_SOUND, */
3951         camera_dispatcher_return_buffer, /* MUSE_CAMERA_API_RETURN_BUFFER, */
3952         camera_dispatcher_preview_cb_return, /* MUSE_CAMERA_API_PREVIEW_CB_RETURN, */
3953 };