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         if (muse_core_ipc_get_bufmgr(&muse_camera->bufmgr) != MM_ERROR_NONE) {
 872                 LOGE("muse_core_ipc_get_bufmgr failed");
 873
 874                 free(muse_camera);
 875                 muse_camera = NULL;
 876
 877                 ret = CAMERA_ERROR_INVALID_OPERATION;
 878                 muse_camera_msg_return(api, class, ret, module);
 879
 880                 return MUSE_CAMERA_ERROR_NONE;
 881         }
 882
 883         ret = legacy_camera_create((camera_device_e)device_type, &muse_camera->camera_handle);
 884         if (ret != CAMERA_ERROR_NONE) {
 885                 free(muse_camera);
 886                 muse_camera = NULL;
 887                 muse_camera_msg_return(api, class, ret, module);
 888
 889                 return MUSE_CAMERA_ERROR_NONE;
 890         }
 891
 892         ret = legacy_camera_set_client_pid(muse_camera->camera_handle, pid);
 893         if (ret != CAMERA_ERROR_NONE) {
 894                 LOGE("legacy_camera_set_client_pid failed : 0x%x", ret);
 895
 896                 legacy_camera_destroy(muse_camera->camera_handle);
 897                 muse_camera->camera_handle = NULL;
 898
 899                 free(muse_camera);
 900                 muse_camera = NULL;
 901                 muse_camera_msg_return(api, class, ret, module);
 902
 903                 return MUSE_CAMERA_ERROR_NONE;
 904         }
 905
 906         g_mutex_init(&muse_camera->list_lock);
 907         g_mutex_init(&muse_camera->preview_cb_lock);
 908         g_cond_init(&muse_camera->preview_cb_cond);
 909
 910         LOGD("handle : 0x%x", muse_camera);
 911         handle = (intptr_t)muse_camera;
 912         muse_core_ipc_set_handle(module, (intptr_t)muse_camera);
 913         muse_camera_msg_return1(api, class, ret, module, POINTER, handle);
 914
 915         return MUSE_CAMERA_ERROR_NONE;
 916 }
 917
 918 int camera_dispatcher_destroy(muse_module_h module)
 919 {
 920         int ret = CAMERA_ERROR_NONE;
 921         muse_camera_handle_s *muse_camera = NULL;
 922         muse_camera_api_e api = MUSE_CAMERA_API_DESTROY;
 923         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
 924
 925         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
 926
 927         LOGD("Enter, handle : %p", muse_camera);
 928
 929         ret = legacy_camera_destroy(muse_camera->camera_handle);
 930         if (ret == CAMERA_ERROR_NONE) {
 931                 _camera_remove_export_data(module, 0, TRUE);
 932
 933                 g_mutex_clear(&muse_camera->list_lock);
 934                 g_mutex_clear(&muse_camera->preview_cb_lock);
 935                 g_cond_clear(&muse_camera->preview_cb_cond);
 936
 937                 muse_camera->bufmgr = NULL;
 938
 939                 free(muse_camera);
 940                 muse_camera = NULL;
 941         }
 942
 943         muse_camera_msg_return(api, class, ret, module);
 944
 945         return MUSE_CAMERA_ERROR_NONE;
 946 }
 947
 948 int camera_dispatcher_start_preview(muse_module_h module)
 949 {
 950         int ret = CAMERA_ERROR_NONE;
 951         muse_camera_handle_s *muse_camera = NULL;
 952         muse_camera_api_e api = MUSE_CAMERA_API_START_PREVIEW;
 953         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
 954         char *caps = NULL;
 955         camera_state_e prev_state = CAMERA_STATE_NONE;
 956
 957         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
 958
 959         LOGD("handle : %p", muse_camera);
 960
 961         legacy_camera_get_state(muse_camera->camera_handle, &prev_state);
 962
 963         ret = legacy_camera_start_preview(muse_camera->camera_handle);
 964         if (ret != CAMERA_ERROR_NONE) {
 965                 LOGD("start preview failed 0x%x", ret);
 966                 muse_camera_msg_return(api, class, ret, module);
 967                 return MUSE_CAMERA_ERROR_NONE;
 968         }
 969
 970         if (prev_state == CAMERA_STATE_CREATED) {
 971                 ret = legacy_camera_get_video_caps(muse_camera->camera_handle, &caps);
 972                 if (ret == CAMERA_ERROR_NONE && caps) {
 973                         LOGD("caps : %s", caps);
 974                         muse_camera_msg_return2(api, class, ret, module, STRING, caps, INT, prev_state);
 975                         g_free(caps);
 976                 } else {
 977                         LOGD("Failed to get server's video caps. ret 0x%x, caps %p", ret, caps);
 978                         muse_camera_msg_return(api, class, ret, module);
 979                         if (legacy_camera_stop_preview(muse_camera->camera_handle) != CAMERA_ERROR_NONE) {
 980                                 LOGW("failed to stop preview");
 981                         }
 982                 }
 983         } else {
 984                 LOGD("preview started after capture");
 985                 muse_camera_msg_return1(api, class, ret, module, INT, prev_state);
 986         }
 987
 988         return MUSE_CAMERA_ERROR_NONE;
 989 }
 990
 991 int camera_dispatcher_stop_preview(muse_module_h module)
 992 {
 993         int ret = CAMERA_ERROR_NONE;
 994         muse_camera_handle_s *muse_camera = NULL;
 995         muse_camera_api_e api = MUSE_CAMERA_API_STOP_PREVIEW;
 996         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
 997
 998         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
 999
1000         LOGD("handle : %p", muse_camera);
1001
1002         ret = legacy_camera_stop_preview(muse_camera->camera_handle);
1003
1004         muse_camera_msg_return(api, class, ret, module);
1005
1006         return MUSE_CAMERA_ERROR_NONE;
1007 }
1008
1009 int camera_dispatcher_start_capture(muse_module_h module)
1010 {
1011         int ret = CAMERA_ERROR_NONE;
1012         muse_camera_handle_s *muse_camera = NULL;
1013         int is_capturing_cb = 0;
1014         int is_completed_cb = 0;
1015         void *capturing_cb = NULL;
1016         void *completed_cb = NULL;
1017         muse_camera_api_e api = MUSE_CAMERA_API_START_CAPTURE;
1018         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1019
1020         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1021
1022         muse_camera_msg_get(is_capturing_cb, muse_core_client_get_msg(module));
1023         muse_camera_msg_get(is_completed_cb, muse_core_client_get_msg(module));
1024
1025         LOGD("Enter, handle : %p, module : %p, capturing_cb %d, completed_cb %d",
1026              muse_camera, module, is_capturing_cb, is_completed_cb);
1027
1028         if (is_capturing_cb) {
1029                 capturing_cb = _camera_dispatcher_capturing_cb;
1030         }
1031         if (is_completed_cb) {
1032                 completed_cb = _camera_dispatcher_capture_completed_cb;
1033         }
1034
1035         ret = legacy_camera_start_capture(muse_camera->camera_handle,
1036                                           (camera_capturing_cb)capturing_cb,
1037                                           (camera_capture_completed_cb)completed_cb,
1038                                           (void *)module);
1039
1040         muse_camera_msg_return(api, class, ret, module);
1041
1042         return MUSE_CAMERA_ERROR_NONE;
1043 }
1044
1045 int camera_dispatcher_is_supported_continuous_capture(muse_module_h module)
1046 {
1047         int ret = CAMERA_ERROR_NONE;
1048         muse_camera_handle_s *muse_camera = NULL;
1049         muse_camera_api_e api = MUSE_CAMERA_API_SUPPORT_CONTINUOUS_CAPTURE;
1050         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1051
1052         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1053
1054         LOGD("handle : %p", muse_camera);
1055
1056         ret = legacy_camera_is_supported_continuous_capture(muse_camera->camera_handle);
1057
1058         LOGD("is supported ret : %d", ret);
1059
1060         muse_camera_msg_return(api, class, ret, module);
1061
1062         return MUSE_CAMERA_ERROR_NONE;
1063 }
1064
1065 int camera_dispatcher_start_continuous_capture(muse_module_h module)
1066 {
1067         int ret = CAMERA_ERROR_NONE;
1068         muse_camera_handle_s *muse_camera = NULL;
1069         int count;
1070         int interval;
1071         muse_camera_api_e api = MUSE_CAMERA_API_START_CONTINUOUS_CAPTURE;
1072         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1073
1074         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1075
1076         muse_camera_msg_get(count, muse_core_client_get_msg(module));
1077         muse_camera_msg_get(interval, muse_core_client_get_msg(module));
1078
1079         LOGD("Enter, handle : %p, module : %p", muse_camera, module);
1080
1081         ret = legacy_camera_start_continuous_capture(muse_camera->camera_handle,
1082                                                      count,
1083                                                      interval,
1084                                                      (camera_capturing_cb)_camera_dispatcher_capturing_cb,
1085                                                      (camera_capture_completed_cb)_camera_dispatcher_capture_completed_cb,
1086                                                      (void *)module);
1087
1088         muse_camera_msg_return(api, class, ret, module);
1089
1090         return MUSE_CAMERA_ERROR_NONE;
1091 }
1092
1093 int camera_dispatcher_stop_continuous_capture(muse_module_h module)
1094 {
1095         int ret = CAMERA_ERROR_NONE;
1096         muse_camera_handle_s *muse_camera = NULL;
1097         muse_camera_api_e api = MUSE_CAMERA_API_STOP_CONTINUOUS_CAPTURE;
1098         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1099
1100         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1101
1102         LOGD("handle : %p", muse_camera);
1103
1104         ret = legacy_camera_stop_continuous_capture(muse_camera->camera_handle);
1105
1106         muse_camera_msg_return(api, class, ret, module);
1107
1108         return MUSE_CAMERA_ERROR_NONE;
1109 }
1110
1111 int camera_dispatcher_is_supported_face_detection(muse_module_h module)
1112 {
1113         int ret = CAMERA_ERROR_NONE;
1114         muse_camera_handle_s *muse_camera = NULL;
1115         muse_camera_api_e api = MUSE_CAMERA_API_SUPPORT_FACE_DETECTION;
1116         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1117
1118         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1119
1120         LOGD("handle : %p", muse_camera);
1121
1122         ret = legacy_camera_is_supported_face_detection(muse_camera->camera_handle);
1123
1124         LOGD("is supported ret : %d", ret);
1125
1126         muse_camera_msg_return(api, class, ret, module);
1127
1128         return MUSE_CAMERA_ERROR_NONE;
1129 }
1130
1131 int camera_dispatcher_is_supported_zero_shutter_lag(muse_module_h module)
1132 {
1133         int ret = CAMERA_ERROR_NONE;
1134         muse_camera_handle_s *muse_camera = NULL;
1135         muse_camera_api_e api = MUSE_CAMERA_API_SUPPORT_ZERO_SHUTTER_LAG;
1136         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1137
1138         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1139
1140         LOGD("handle : %p", muse_camera);
1141
1142         ret = legacy_camera_is_supported_zero_shutter_lag(muse_camera->camera_handle);
1143
1144         LOGD("is supported ret : %d", ret);
1145
1146         muse_camera_msg_return(api, class, ret, module);
1147
1148         return MUSE_CAMERA_ERROR_NONE;
1149 }
1150
1151 int camera_dispatcher_is_supported_media_packet_preview_cb(muse_module_h module)
1152 {
1153         int ret = CAMERA_ERROR_NONE;
1154         muse_camera_handle_s *muse_camera = NULL;
1155         muse_camera_api_e api = MUSE_CAMERA_API_SUPPORT_MEDIA_PACKET_PREVIEW_CB;
1156         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1157
1158         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1159
1160         LOGD("handle : %p", muse_camera);
1161
1162         ret = legacy_camera_is_supported_media_packet_preview_cb(muse_camera->camera_handle);
1163
1164         LOGD("is supported ret : %d", ret);
1165
1166         muse_camera_msg_return(api, class, ret, module);
1167
1168         return MUSE_CAMERA_ERROR_NONE;
1169 }
1170
1171 int camera_dispatcher_get_device_count(muse_module_h module)
1172 {
1173         int ret = CAMERA_ERROR_NONE;
1174         muse_camera_handle_s *muse_camera = NULL;
1175         int get_device_count = 0;
1176         muse_camera_api_e api = MUSE_CAMERA_API_GET_DEVICE_COUNT;
1177         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1178
1179         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1180
1181         LOGD("handle : %p", muse_camera);
1182
1183         ret = legacy_camera_get_device_count(muse_camera->camera_handle, &get_device_count);
1184         if (ret == CAMERA_ERROR_NONE) {
1185                 muse_camera_msg_return1(api, class, ret, module, INT, get_device_count);
1186         } else {
1187                 muse_camera_msg_return(api, class, ret, module);
1188         }
1189
1190         return MUSE_CAMERA_ERROR_NONE;
1191 }
1192
1193 int camera_dispatcher_start_face_detection(muse_module_h module)
1194 {
1195         int ret = CAMERA_ERROR_NONE;
1196         muse_camera_handle_s *muse_camera = NULL;
1197         muse_camera_api_e api = MUSE_CAMERA_API_START_FACE_DETECTION;
1198         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1199
1200         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1201
1202         LOGD("Enter, handle : 0x%x, module : %d", muse_camera, module);
1203
1204         ret = legacy_camera_start_face_detection(muse_camera->camera_handle,
1205                                                  (camera_face_detected_cb)_camera_dispatcher_face_detected_cb,
1206                                                  (void *)module);
1207
1208         muse_camera_msg_return(api, class, ret, module);
1209
1210         return MUSE_CAMERA_ERROR_NONE;
1211 }
1212
1213 int camera_dispatcher_stop_face_detection(muse_module_h module)
1214 {
1215         int ret = CAMERA_ERROR_NONE;
1216         muse_camera_handle_s *muse_camera = NULL;
1217         muse_camera_api_e api = MUSE_CAMERA_API_STOP_FACE_DETECTION;
1218         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1219
1220         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1221
1222         LOGD("handle : %p", muse_camera);
1223
1224         ret = legacy_camera_stop_face_detection(muse_camera->camera_handle);
1225
1226         muse_camera_msg_return(api, class, ret, module);
1227
1228         return MUSE_CAMERA_ERROR_NONE;
1229 }
1230
1231 int camera_dispatcher_get_state(muse_module_h module)
1232 {
1233         int ret = CAMERA_ERROR_NONE;
1234         muse_camera_handle_s *muse_camera = NULL;
1235         camera_state_e get_state = CAMERA_STATE_NONE;
1236         muse_camera_api_e api = MUSE_CAMERA_API_GET_STATE;
1237         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1238
1239         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1240
1241         LOGD("handle : %p", muse_camera);
1242
1243         ret = legacy_camera_get_state(muse_camera->camera_handle, &get_state);
1244         if (ret == CAMERA_ERROR_NONE) {
1245                 muse_camera_msg_return1(api, class, ret, module, INT, get_state);
1246         } else {
1247                 muse_camera_msg_return(api, class, ret, module);
1248         }
1249
1250         return MUSE_CAMERA_ERROR_NONE;
1251 }
1252
1253 int camera_dispatcher_start_focusing(muse_module_h module)
1254 {
1255         int ret = CAMERA_ERROR_NONE;
1256         muse_camera_handle_s *muse_camera = NULL;
1257         int is_continuous;
1258         muse_camera_api_e api = MUSE_CAMERA_API_START_FOCUSING;
1259         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1260
1261         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1262
1263         muse_camera_msg_get(is_continuous, muse_core_client_get_msg(module));
1264
1265         LOGD("Enter, handle : 0x%x, module : %d", muse_camera, module);
1266
1267         ret = legacy_camera_start_focusing(muse_camera->camera_handle, (bool)is_continuous);
1268
1269         muse_camera_msg_return(api, class, ret, module);
1270
1271         return MUSE_CAMERA_ERROR_NONE;
1272 }
1273
1274 int camera_dispatcher_stop_focusing(muse_module_h module)
1275 {
1276         int ret = CAMERA_ERROR_NONE;
1277         muse_camera_handle_s *muse_camera = NULL;
1278         muse_camera_api_e api = MUSE_CAMERA_API_CANCEL_FOCUSING;
1279         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1280
1281         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1282
1283         LOGD("handle : %p", muse_camera);
1284
1285         ret = legacy_camera_cancel_focusing(muse_camera->camera_handle);
1286
1287         muse_camera_msg_return(api, class, ret, module);
1288
1289         return MUSE_CAMERA_ERROR_NONE;
1290 }
1291
1292 int camera_dispatcher_set_display(muse_module_h module)
1293 {
1294         int ret = CAMERA_ERROR_NONE;
1295         muse_camera_handle_s *muse_camera = NULL;
1296         muse_camera_api_e api = MUSE_CAMERA_API_SET_DISPLAY;
1297         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1298         static guint stream_id = 0;
1299         char socket_path[SOCKET_PATH_LENGTH] = {0,};
1300         camera_h camera;
1301
1302         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1303
1304         LOGD("handle : 0x%x", muse_camera);
1305
1306         camera = muse_camera->camera_handle;
1307         stream_id = muse_core_get_atomic_uint();
1308
1309         snprintf(socket_path, SOCKET_PATH_LENGTH, SOCKET_PATH_BASE, stream_id);
1310
1311         LOGD("socket_path : %s", socket_path);
1312
1313         ret = legacy_camera_set_display(muse_camera->camera_handle, CAMERA_DISPLAY_TYPE_REMOTE, (void *)socket_path);
1314         if (ret != CAMERA_ERROR_NONE) {
1315                 muse_camera_msg_return(api, class, ret, module);
1316         } else {
1317                 muse_camera_msg_return1(api, class, ret, module,
1318                                         STRING, socket_path);
1319         }
1320
1321         return MUSE_CAMERA_ERROR_NONE;
1322 }
1323
1324 int camera_dispatcher_set_preview_resolution(muse_module_h module)
1325 {
1326         int ret = CAMERA_ERROR_NONE;
1327         muse_camera_handle_s *muse_camera = NULL;
1328         int width;
1329         int height;
1330         muse_camera_api_e api = MUSE_CAMERA_API_SET_PREVIEW_RESOLUTION;
1331         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1332
1333         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1334
1335         muse_camera_msg_get(width, muse_core_client_get_msg(module));
1336         muse_camera_msg_get(height, muse_core_client_get_msg(module));
1337
1338         LOGD("handle : 0x%x, set_width : %d, set_height : 0x%x", muse_camera, width, height);
1339
1340         ret = legacy_camera_set_preview_resolution(muse_camera->camera_handle, width, height);
1341
1342         muse_camera_msg_return(api, class, ret, module);
1343
1344         return MUSE_CAMERA_ERROR_NONE;
1345 }
1346
1347 int camera_dispatcher_set_capture_resolution(muse_module_h module)
1348 {
1349         int ret = CAMERA_ERROR_NONE;
1350         muse_camera_handle_s *muse_camera = NULL;
1351         int width;
1352         int height;
1353         muse_camera_api_e api = MUSE_CAMERA_API_SET_CAPTURE_RESOLUTION;
1354         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1355
1356         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1357
1358         muse_camera_msg_get(width, muse_core_client_get_msg(module));
1359         muse_camera_msg_get(height, muse_core_client_get_msg(module));
1360
1361         LOGD("handle : 0x%x, set_width : %d, set_height : %d", muse_camera, width, height);
1362
1363         ret = legacy_camera_set_capture_resolution(muse_camera->camera_handle, width, height);
1364
1365         muse_camera_msg_return(api, class, ret, module);
1366
1367         return MUSE_CAMERA_ERROR_NONE;
1368 }
1369
1370 int camera_dispatcher_set_capture_format(muse_module_h module)
1371 {
1372         int ret = CAMERA_ERROR_NONE;
1373         muse_camera_handle_s *muse_camera = NULL;
1374         int set_format;
1375         muse_camera_api_e api = MUSE_CAMERA_API_SET_CAPTURE_FORMAT;
1376         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1377
1378         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1379
1380         muse_camera_msg_get(set_format, muse_core_client_get_msg(module));
1381
1382         LOGD("handle : 0x%x, set_format : %d", muse_camera, set_format);
1383
1384         ret = legacy_camera_set_capture_format(muse_camera->camera_handle, (camera_pixel_format_e)set_format);
1385
1386         muse_camera_msg_return(api, class, ret, module);
1387
1388         return MUSE_CAMERA_ERROR_NONE;
1389 }
1390
1391 int camera_dispatcher_set_preview_format(muse_module_h module)
1392 {
1393         int ret = CAMERA_ERROR_NONE;
1394         muse_camera_handle_s *muse_camera = NULL;
1395         int set_format;
1396         muse_camera_api_e api = MUSE_CAMERA_API_SET_PREVIEW_FORMAT;
1397         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1398
1399         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1400
1401         muse_camera_msg_get(set_format, muse_core_client_get_msg(module));
1402
1403         LOGD("handle : 0x%x, set_format : %d", muse_camera, set_format);
1404
1405         ret = legacy_camera_set_preview_format(muse_camera->camera_handle, (camera_pixel_format_e)set_format);
1406
1407         muse_camera_msg_return(api, class, ret, module);
1408
1409         return MUSE_CAMERA_ERROR_NONE;
1410 }
1411
1412 int camera_dispatcher_get_preview_resolution(muse_module_h module)
1413 {
1414         int ret = CAMERA_ERROR_NONE;
1415         muse_camera_handle_s *muse_camera = NULL;
1416         int get_width = 0;
1417         int get_height = 0;
1418         muse_camera_api_e api = MUSE_CAMERA_API_GET_PREVIEW_RESOLUTION;
1419         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1420
1421         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1422
1423         LOGD("handle : %p", muse_camera);
1424
1425         ret = legacy_camera_get_preview_resolution(muse_camera->camera_handle, &get_width, &get_height);
1426         if (ret == CAMERA_ERROR_NONE) {
1427                 muse_camera_msg_return2(api, class, ret, module, INT, get_width, INT, get_height);
1428         } else {
1429                 muse_camera_msg_return(api, class, ret, module);
1430         }
1431
1432         return MUSE_CAMERA_ERROR_NONE;
1433 }
1434
1435 int camera_dispatcher_set_display_rotation(muse_module_h module)
1436 {
1437         int ret = CAMERA_ERROR_NONE;
1438         muse_camera_handle_s *muse_camera = NULL;
1439         int set_rotation;
1440         muse_camera_api_e api = MUSE_CAMERA_API_SET_DISPLAY_ROTATION;
1441         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1442
1443         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1444
1445         muse_camera_msg_get(set_rotation, muse_core_client_get_msg(module));
1446
1447         LOGD("handle : 0x%x, set_rotation : %d", muse_camera, set_rotation);
1448
1449         ret = legacy_camera_set_display_rotation(muse_camera->camera_handle, (camera_rotation_e)set_rotation);
1450
1451         muse_camera_msg_return(api, class, ret, module);
1452
1453         return MUSE_CAMERA_ERROR_NONE;
1454 }
1455
1456 int camera_dispatcher_get_display_rotation(muse_module_h module)
1457 {
1458         int ret = CAMERA_ERROR_NONE;
1459         muse_camera_handle_s *muse_camera = NULL;
1460         camera_rotation_e get_rotation = CAMERA_ROTATION_NONE;
1461         muse_camera_api_e api = MUSE_CAMERA_API_GET_DISPLAY_ROTATION;
1462         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1463
1464         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1465
1466         LOGD("handle : %p", muse_camera);
1467
1468         ret = legacy_camera_get_display_rotation(muse_camera->camera_handle, &get_rotation);
1469         if (ret == CAMERA_ERROR_NONE) {
1470                 muse_camera_msg_return1(api, class, ret, module, INT, get_rotation);
1471         } else {
1472                 muse_camera_msg_return(api, class, ret, module);
1473         }
1474
1475         return MUSE_CAMERA_ERROR_NONE;
1476 }
1477
1478 int camera_dispatcher_set_display_flip(muse_module_h module)
1479 {
1480         int ret = CAMERA_ERROR_NONE;
1481         muse_camera_handle_s *muse_camera = NULL;
1482         int set_flip;
1483         muse_camera_api_e api = MUSE_CAMERA_API_SET_DISPLAY_FLIP;
1484         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1485
1486         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1487
1488         muse_camera_msg_get(set_flip, muse_core_client_get_msg(module));
1489
1490         LOGD("handle : 0x%x, set_flip : %d", muse_camera, set_flip);
1491
1492         ret = legacy_camera_set_display_flip(muse_camera->camera_handle, (camera_flip_e)set_flip);
1493
1494         muse_camera_msg_return(api, class, ret, module);
1495
1496         return MUSE_CAMERA_ERROR_NONE;
1497 }
1498
1499 int camera_dispatcher_get_display_flip(muse_module_h module)
1500 {
1501         int ret = CAMERA_ERROR_NONE;
1502         muse_camera_handle_s *muse_camera = NULL;
1503         camera_flip_e get_flip = CAMERA_FLIP_NONE;
1504         muse_camera_api_e api = MUSE_CAMERA_API_GET_DISPLAY_FLIP;
1505         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1506
1507         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1508
1509         LOGD("handle : %p", muse_camera);
1510
1511         ret = legacy_camera_get_display_flip(muse_camera->camera_handle, &get_flip);
1512         if (ret == CAMERA_ERROR_NONE) {
1513                 muse_camera_msg_return1(api, class, ret, module, INT, get_flip);
1514         } else {
1515                 muse_camera_msg_return(api, class, ret, module);
1516         }
1517
1518         return MUSE_CAMERA_ERROR_NONE;
1519 }
1520
1521 int camera_dispatcher_set_display_visible(muse_module_h module)
1522 {
1523         int ret = CAMERA_ERROR_NONE;
1524         muse_camera_handle_s *muse_camera = NULL;
1525         int set_visible;
1526         muse_camera_api_e api = MUSE_CAMERA_API_SET_DISPLAY_VISIBLE;
1527         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1528
1529         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1530
1531         muse_camera_msg_get(set_visible, muse_core_client_get_msg(module));
1532
1533         LOGD("handle : 0x%x, set_visible : %d", muse_camera, set_visible);
1534
1535         ret = legacy_camera_set_display_visible(muse_camera->camera_handle, (bool)set_visible);
1536
1537         muse_camera_msg_return(api, class, ret, module);
1538
1539         return MUSE_CAMERA_ERROR_NONE;
1540 }
1541
1542 int camera_dispatcher_is_display_visible(muse_module_h module)
1543 {
1544         int ret = CAMERA_ERROR_NONE;
1545         muse_camera_handle_s *muse_camera = NULL;
1546         bool get_visible = true;
1547         muse_camera_api_e api = MUSE_CAMERA_API_IS_DISPLAY_VISIBLE;
1548         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1549
1550         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1551
1552         LOGD("handle : %p", muse_camera);
1553
1554         ret = legacy_camera_is_display_visible(muse_camera->camera_handle, &get_visible);
1555         if (ret == CAMERA_ERROR_NONE) {
1556                 muse_camera_msg_return1(api, class, ret, module, INT, get_visible);
1557         } else {
1558                 muse_camera_msg_return(api, class, ret, module);
1559         }
1560
1561         return MUSE_CAMERA_ERROR_NONE;
1562 }
1563
1564 int camera_dispatcher_set_display_mode(muse_module_h module)
1565 {
1566         int ret = CAMERA_ERROR_NONE;
1567         muse_camera_handle_s *muse_camera = NULL;
1568         int set_mode;
1569         muse_camera_api_e api = MUSE_CAMERA_API_SET_DISPLAY_MODE;
1570         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1571
1572         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1573
1574         muse_camera_msg_get(set_mode, muse_core_client_get_msg(module));
1575
1576         LOGD("handle : 0x%x, display_mode : %d", muse_camera, set_mode);
1577
1578         ret = legacy_camera_set_display_mode(muse_camera->camera_handle, (camera_display_mode_e)set_mode);
1579
1580         LOGD("ret : 0x%x", ret);
1581
1582         muse_camera_msg_return(api, class, ret, module);
1583
1584         return MUSE_CAMERA_ERROR_NONE;
1585 }
1586
1587 int camera_dispatcher_get_display_mode(muse_module_h module)
1588 {
1589         int ret = CAMERA_ERROR_NONE;
1590         muse_camera_handle_s *muse_camera = NULL;
1591         camera_display_mode_e get_mode = CAMERA_DISPLAY_MODE_LETTER_BOX;
1592         muse_camera_api_e api = MUSE_CAMERA_API_GET_DISPLAY_MODE;
1593         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1594
1595         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1596
1597         LOGD("handle : %p", muse_camera);
1598
1599         ret = legacy_camera_get_display_mode(muse_camera->camera_handle, &get_mode);
1600         if (ret == CAMERA_ERROR_NONE) {
1601                 muse_camera_msg_return1(api, class, ret, module, INT, get_mode);
1602         } else {
1603                 muse_camera_msg_return(api, class, ret, module);
1604         }
1605
1606         return MUSE_CAMERA_ERROR_NONE;
1607 }
1608
1609 int camera_dispatcher_get_capture_resolution(muse_module_h module)
1610 {
1611         int ret = CAMERA_ERROR_NONE;
1612         muse_camera_handle_s *muse_camera = NULL;
1613         int get_width = 0;
1614         int get_height = 0;
1615         muse_camera_api_e api = MUSE_CAMERA_API_GET_CAPTURE_RESOLUTION;
1616         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1617
1618         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1619
1620         LOGD("handle : %p", muse_camera);
1621
1622         ret = legacy_camera_get_capture_resolution(muse_camera->camera_handle, &get_width, &get_height);
1623         if (ret == CAMERA_ERROR_NONE) {
1624                 muse_camera_msg_return2(api, class, ret, module, INT, get_width, INT, get_height);
1625         } else {
1626                 muse_camera_msg_return(api, class, ret, module);
1627         }
1628
1629         return MUSE_CAMERA_ERROR_NONE;
1630 }
1631
1632 int camera_dispatcher_get_capture_format(muse_module_h module)
1633 {
1634         int ret = CAMERA_ERROR_NONE;
1635         muse_camera_handle_s *muse_camera = NULL;
1636         camera_pixel_format_e get_format = CAMERA_PIXEL_FORMAT_NV12;
1637         muse_camera_api_e api = MUSE_CAMERA_API_GET_CAPTURE_FORMAT;
1638         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1639
1640         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1641
1642         LOGD("handle : %p", muse_camera);
1643
1644         ret = legacy_camera_get_capture_format(muse_camera->camera_handle, &get_format);
1645         if (ret == CAMERA_ERROR_NONE) {
1646                 muse_camera_msg_return1(api, class, ret, module, INT, get_format);
1647         } else {
1648                 muse_camera_msg_return(api, class, ret, module);
1649         }
1650
1651         return MUSE_CAMERA_ERROR_NONE;
1652 }
1653
1654 int camera_dispatcher_get_preview_format(muse_module_h module)
1655 {
1656         int ret = CAMERA_ERROR_NONE;
1657         muse_camera_handle_s *muse_camera = NULL;
1658         camera_pixel_format_e get_format = CAMERA_PIXEL_FORMAT_NV12;
1659         muse_camera_api_e api = MUSE_CAMERA_API_GET_PREVIEW_FORMAT;
1660         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1661
1662         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1663
1664         LOGD("handle : %p", muse_camera);
1665
1666         ret = legacy_camera_get_preview_format(muse_camera->camera_handle, &get_format);
1667         if (ret == CAMERA_ERROR_NONE) {
1668                 muse_camera_msg_return1(api, class, ret, module, INT, get_format);
1669         } else {
1670                 muse_camera_msg_return(api, class, ret, module);
1671         }
1672
1673         return MUSE_CAMERA_ERROR_NONE;
1674 }
1675
1676 int camera_dispatcher_get_facing_direction(muse_module_h module)
1677 {
1678         int ret = CAMERA_ERROR_NONE;
1679         muse_camera_handle_s *muse_camera = NULL;
1680         camera_facing_direction_e get_facing_direction = CAMERA_FACING_DIRECTION_REAR;
1681         muse_camera_api_e api = MUSE_CAMERA_API_GET_FACING_DIRECTION;
1682         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1683
1684         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1685
1686         LOGD("handle : %p", muse_camera);
1687
1688         ret = legacy_camera_get_facing_direction(muse_camera->camera_handle, &get_facing_direction);
1689         if (ret == CAMERA_ERROR_NONE) {
1690                 muse_camera_msg_return1(api, class, ret, module, INT, get_facing_direction);
1691         } else {
1692                 muse_camera_msg_return(api, class, ret, module);
1693         }
1694 }
1695
1696 int camera_dispatcher_set_preview_cb(muse_module_h module)
1697 {
1698         int ret = CAMERA_ERROR_NONE;
1699         muse_camera_handle_s *muse_camera = NULL;
1700         muse_camera_api_e api = MUSE_CAMERA_API_SET_PREVIEW_CB;
1701         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1702
1703         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1704
1705         LOGD("handle : %p", muse_camera);
1706
1707         ret = legacy_camera_set_preview_cb(muse_camera->camera_handle,
1708                                            (camera_preview_cb)_camera_dispatcher_preview_cb,
1709                                            (void *)module);
1710
1711         LOGD("ret : 0x%x", ret);
1712
1713         muse_camera_msg_return(api, class, ret, module);
1714
1715         return MUSE_CAMERA_ERROR_NONE;
1716 }
1717
1718 int camera_dispatcher_unset_preview_cb(muse_module_h module)
1719 {
1720         int ret = CAMERA_ERROR_NONE;
1721         muse_camera_handle_s *muse_camera = NULL;
1722         muse_camera_api_e api = MUSE_CAMERA_API_UNSET_PREVIEW_CB;
1723         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1724
1725         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1726
1727         LOGD("handle : %p", muse_camera);
1728
1729         ret = legacy_camera_unset_preview_cb(muse_camera->camera_handle);
1730
1731         LOGD("ret : 0x%x", ret);
1732
1733         muse_camera_msg_return(api, class, ret, module);
1734
1735         return MUSE_CAMERA_ERROR_NONE;
1736 }
1737
1738 int camera_dispatcher_set_media_packet_preview_cb(muse_module_h module)
1739 {
1740         int ret = CAMERA_ERROR_NONE;
1741         muse_camera_handle_s *muse_camera = NULL;
1742         muse_camera_api_e api = MUSE_CAMERA_API_SET_MEDIA_PACKET_PREVIEW_CB;
1743         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1744
1745         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1746
1747         LOGD("handle : %p", muse_camera);
1748
1749         ret = legacy_camera_set_media_packet_preview_cb(muse_camera->camera_handle,
1750                                                         (camera_preview_cb)_camera_dispatcher_preview_cb,
1751                                                         (void *)module);
1752
1753         LOGD("ret : 0x%x", ret);
1754
1755         muse_camera_msg_return(api, class, ret, module);
1756
1757         return MUSE_CAMERA_ERROR_NONE;
1758 }
1759
1760 int camera_dispatcher_unset_media_packet_preview_cb(muse_module_h module)
1761 {
1762         int ret = CAMERA_ERROR_NONE;
1763         muse_camera_handle_s *muse_camera = NULL;
1764         muse_camera_api_e api = MUSE_CAMERA_API_UNSET_MEDIA_PACKET_PREVIEW_CB;
1765         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1766
1767         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1768
1769         LOGD("handle : %p", muse_camera);
1770
1771         ret = legacy_camera_unset_media_packet_preview_cb(muse_camera->camera_handle);
1772
1773         LOGD("ret : 0x%x", ret);
1774
1775         muse_camera_msg_return(api, class, ret, module);
1776
1777         return MUSE_CAMERA_ERROR_NONE;
1778 }
1779
1780 int camera_dispatcher_set_state_changed_cb(muse_module_h module)
1781 {
1782         int ret = CAMERA_ERROR_NONE;
1783         muse_camera_handle_s *muse_camera = NULL;
1784         muse_camera_api_e api = MUSE_CAMERA_API_SET_STATE_CHANGED_CB;
1785         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1786
1787         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1788
1789         LOGD("handle : %p", muse_camera);
1790
1791         ret = legacy_camera_set_state_changed_cb(muse_camera->camera_handle,
1792                                                  (camera_state_changed_cb)_camera_dispatcher_state_changed_cb,
1793                                                  (void *)module);
1794
1795         LOGD("ret : 0x%x", ret);
1796
1797         muse_camera_msg_return(api, class, ret, module);
1798
1799         return MUSE_CAMERA_ERROR_NONE;
1800 }
1801
1802 int camera_dispatcher_unset_state_changed_cb(muse_module_h module)
1803 {
1804         int ret = CAMERA_ERROR_NONE;
1805         muse_camera_handle_s *muse_camera = NULL;
1806         muse_camera_api_e api = MUSE_CAMERA_API_UNSET_STATE_CHANGED_CB;
1807         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1808
1809         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1810
1811         LOGD("handle : %p", muse_camera);
1812
1813         ret = legacy_camera_unset_state_changed_cb(muse_camera->camera_handle);
1814
1815         LOGD("ret : 0x%x", ret);
1816
1817         muse_camera_msg_return(api, class, ret, module);
1818
1819         return MUSE_CAMERA_ERROR_NONE;
1820 }
1821
1822 int camera_dispatcher_set_interrupted_cb(muse_module_h module)
1823 {
1824         int ret = CAMERA_ERROR_NONE;
1825         muse_camera_handle_s *muse_camera = NULL;
1826         muse_camera_api_e api = MUSE_CAMERA_API_SET_INTERRUPTED_CB;
1827         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1828
1829         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1830
1831         LOGD("handle : %p", muse_camera);
1832
1833         ret = legacy_camera_set_interrupted_cb(muse_camera->camera_handle,
1834                                                (camera_interrupted_cb)_camera_dispatcher_interrupted_cb,
1835                                                (void *)module);
1836
1837         LOGD("ret : 0x%x", ret);
1838
1839         muse_camera_msg_return(api, class, ret, module);
1840
1841         return MUSE_CAMERA_ERROR_NONE;
1842 }
1843
1844 int camera_dispatcher_unset_interrupted_cb(muse_module_h module)
1845 {
1846         int ret = CAMERA_ERROR_NONE;
1847         muse_camera_handle_s *muse_camera = NULL;
1848         muse_camera_api_e api = MUSE_CAMERA_API_UNSET_INTERRUPTED_CB;
1849         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1850
1851         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1852
1853         LOGD("handle : %p", muse_camera);
1854
1855         ret = legacy_camera_unset_interrupted_cb(muse_camera->camera_handle);
1856
1857         LOGD("ret : 0x%x", ret);
1858
1859         muse_camera_msg_return(api, class, ret, module);
1860
1861         return MUSE_CAMERA_ERROR_NONE;
1862 }
1863
1864 int camera_dispatcher_set_focus_changed_cb(muse_module_h module)
1865 {
1866         int ret = CAMERA_ERROR_NONE;
1867         muse_camera_handle_s *muse_camera = NULL;
1868         muse_camera_api_e api = MUSE_CAMERA_API_SET_FOCUS_CHANGED_CB;
1869         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1870
1871         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1872
1873         LOGD("handle : %p", muse_camera);
1874
1875         ret = legacy_camera_set_focus_changed_cb(muse_camera->camera_handle,
1876                                                  (camera_focus_changed_cb)_camera_dispatcher_focus_changed_cb,
1877                                                  (void *)module);
1878
1879         LOGD("ret : 0x%x", ret);
1880
1881         muse_camera_msg_return(api, class, ret, module);
1882
1883         return MUSE_CAMERA_ERROR_NONE;
1884 }
1885
1886 int camera_dispatcher_unset_focus_changed_cb(muse_module_h module)
1887 {
1888         int ret = CAMERA_ERROR_NONE;
1889         muse_camera_handle_s *muse_camera = NULL;
1890         muse_camera_api_e api = MUSE_CAMERA_API_UNSET_FOCUS_CHANGED_CB;
1891         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1892
1893         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1894
1895         LOGD("handle : %p", muse_camera);
1896
1897         ret = legacy_camera_unset_focus_changed_cb(muse_camera->camera_handle);
1898
1899         LOGD("ret : 0x%x", ret);
1900
1901         muse_camera_msg_return(api, class, ret, module);
1902
1903         return MUSE_CAMERA_ERROR_NONE;
1904 }
1905
1906 int camera_dispatcher_set_error_cb(muse_module_h module)
1907 {
1908         int ret = CAMERA_ERROR_NONE;
1909         muse_camera_handle_s *muse_camera = NULL;
1910         muse_camera_api_e api = MUSE_CAMERA_API_SET_ERROR_CB;
1911         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1912
1913         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1914
1915         LOGD("handle : %p", muse_camera);
1916
1917         ret = legacy_camera_set_error_cb(muse_camera->camera_handle,
1918                                          (camera_error_cb)_camera_dispatcher_error_cb,
1919                                          (void *)module);
1920
1921         LOGD("ret : 0x%x", ret);
1922
1923         muse_camera_msg_return(api, class, ret, module);
1924
1925         return MUSE_CAMERA_ERROR_NONE;
1926 }
1927
1928 int camera_dispatcher_unset_error_cb(muse_module_h module)
1929 {
1930         int ret = CAMERA_ERROR_NONE;
1931         muse_camera_handle_s *muse_camera = NULL;
1932         muse_camera_api_e api = MUSE_CAMERA_API_UNSET_ERROR_CB;
1933         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
1934
1935         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1936
1937         LOGD("handle : %p", muse_camera);
1938
1939         ret = legacy_camera_unset_error_cb(muse_camera->camera_handle);
1940
1941         LOGD("ret : 0x%x", ret);
1942
1943         muse_camera_msg_return(api, class, ret, module);
1944
1945         return MUSE_CAMERA_ERROR_NONE;
1946 }
1947
1948 int camera_dispatcher_foreach_supported_preview_resolution(muse_module_h module)
1949 {
1950         int ret = CAMERA_ERROR_NONE;
1951         muse_camera_handle_s *muse_camera = NULL;
1952         muse_camera_api_e api = MUSE_CAMERA_API_SET_FOREACH_SUPPORTED_PREVIEW_RESOLUTION;
1953         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_THREAD_SUB;
1954
1955         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1956
1957         LOGD("handle : %p", muse_camera);
1958
1959         ret = legacy_camera_foreach_supported_preview_resolution(muse_camera->camera_handle,
1960                                                                  (camera_supported_preview_resolution_cb)_camera_dispatcher_callback_supported_preview_resolution,
1961                                                                  (void *)module);
1962
1963         LOGD("ret : 0x%x", ret);
1964
1965         muse_camera_msg_return(api, class, ret, module);
1966
1967         return MUSE_CAMERA_ERROR_NONE;
1968 }
1969
1970 int camera_dispatcher_foreach_supported_capture_resolution(muse_module_h module)
1971 {
1972         int ret = CAMERA_ERROR_NONE;
1973         muse_camera_handle_s *muse_camera = NULL;
1974         muse_camera_api_e api = MUSE_CAMERA_API_SET_FOREACH_SUPPORTED_CAPTURE_RESOLUTION;
1975         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_THREAD_SUB;
1976
1977         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
1978
1979         LOGD("handle : %p", muse_camera);
1980
1981         ret = legacy_camera_foreach_supported_capture_resolution(muse_camera->camera_handle,
1982                                                                  (camera_supported_capture_resolution_cb)_camera_dispatcher_callback_supported_capture_resolution,
1983                                                                  (void *)module);
1984
1985         LOGD("ret : 0x%x", ret);
1986
1987         muse_camera_msg_return(api, class, ret, module);
1988
1989         return MUSE_CAMERA_ERROR_NONE;
1990 }
1991
1992 int camera_dispatcher_foreach_supported_capture_format(muse_module_h module)
1993 {
1994         int ret = CAMERA_ERROR_NONE;
1995         muse_camera_handle_s *muse_camera = NULL;
1996         muse_camera_api_e api = MUSE_CAMERA_API_SET_FOREACH_SUPPORTED_CAPTURE_FORMAT;
1997         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_THREAD_SUB;
1998
1999         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2000
2001         LOGD("handle : %p", muse_camera);
2002
2003         ret = legacy_camera_foreach_supported_capture_format(muse_camera->camera_handle,
2004                                                              (camera_supported_capture_format_cb)_camera_dispatcher_callback_supported_capture_format,
2005                                                              (void *)module);
2006
2007         LOGD("ret : 0x%x", ret);
2008
2009         muse_camera_msg_return(api, class, ret, module);
2010
2011         return MUSE_CAMERA_ERROR_NONE;
2012 }
2013
2014 int camera_dispatcher_foreach_supported_preview_format(muse_module_h module)
2015 {
2016         int ret = CAMERA_ERROR_NONE;
2017         muse_camera_handle_s *muse_camera = NULL;
2018         muse_camera_api_e api = MUSE_CAMERA_API_SET_FOREACH_SUPPORTED_PREVIEW_FORMAT;
2019         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_THREAD_SUB;
2020
2021         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2022
2023         LOGD("handle : %p", muse_camera);
2024
2025         ret = legacy_camera_foreach_supported_preview_format(muse_camera->camera_handle,
2026                                                              (camera_supported_preview_format_cb)_camera_dispatcher_callback_supported_preview_format,
2027                                                              (void *)module);
2028
2029         LOGD("ret : 0x%x", ret);
2030
2031         muse_camera_msg_return(api, class, ret, module);
2032
2033         return MUSE_CAMERA_ERROR_NONE;
2034 }
2035
2036 int camera_dispatcher_get_recommended_preview_resolution(muse_module_h module)
2037 {
2038         int ret = CAMERA_ERROR_NONE;
2039         muse_camera_handle_s *muse_camera = NULL;
2040         int get_width = 0;
2041         int get_height = 0;
2042         muse_camera_api_e api = MUSE_CAMERA_API_GET_RECOMMENDED_PREVIEW_RESOLUTION;
2043         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2044
2045         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2046
2047         LOGD("handle : %p", muse_camera);
2048
2049         ret = legacy_camera_get_recommended_preview_resolution(muse_camera->camera_handle, &get_width, &get_height);
2050         if (ret == CAMERA_ERROR_NONE) {
2051                 muse_camera_msg_return2(api, class, ret, module, INT, get_width, INT, get_height);
2052         } else {
2053                 muse_camera_msg_return(api, class, ret, module);
2054         }
2055
2056         return MUSE_CAMERA_ERROR_NONE;
2057 }
2058
2059 int camera_dispatcher_attr_get_lens_orientation(muse_module_h module)
2060 {
2061         int ret = CAMERA_ERROR_NONE;
2062         muse_camera_handle_s *muse_camera = NULL;
2063         int get_angle = 0;
2064         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_LENS_ORIENTATION;
2065         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2066
2067         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2068
2069         LOGD("handle : %p", muse_camera);
2070
2071         ret = legacy_camera_attr_get_lens_orientation(muse_camera->camera_handle, &get_angle);
2072         if (ret == CAMERA_ERROR_NONE) {
2073                 muse_camera_msg_return1(api, class, ret, module, INT, get_angle);
2074         } else {
2075                 muse_camera_msg_return(api, class, ret, module);
2076         }
2077
2078         return MUSE_CAMERA_ERROR_NONE;
2079 }
2080
2081 int camera_dispatcher_attr_set_theater_mode(muse_module_h module)
2082 {
2083         int ret = CAMERA_ERROR_NONE;
2084         muse_camera_handle_s *muse_camera = NULL;
2085         int set_mode;
2086         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_THEATER_MODE;
2087         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2088
2089         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2090
2091         muse_camera_msg_get(set_mode, muse_core_client_get_msg(module));
2092
2093         LOGD("handle : %p", muse_camera);
2094
2095         ret = legacy_camera_attr_set_theater_mode(muse_camera->camera_handle, (camera_attr_theater_mode_e)set_mode);
2096
2097         muse_camera_msg_return(api, class, ret, module);
2098
2099         return MUSE_CAMERA_ERROR_NONE;
2100 }
2101
2102 int camera_dispatcher_attr_get_theater_mode(muse_module_h module)
2103 {
2104         int ret = CAMERA_ERROR_NONE;
2105         muse_camera_handle_s *muse_camera = NULL;
2106         camera_attr_theater_mode_e get_mode = CAMERA_ATTR_THEATER_MODE_DISABLE;
2107         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_THEATER_MODE;
2108         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2109
2110         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2111
2112         LOGD("handle : %p", muse_camera);
2113
2114         ret = legacy_camera_attr_get_theater_mode(muse_camera->camera_handle, &get_mode);
2115         if (ret == CAMERA_ERROR_NONE) {
2116                 muse_camera_msg_return1(api, class, ret, module, INT, get_mode);
2117         } else {
2118                 muse_camera_msg_return(api, class, ret, module);
2119         }
2120
2121         return MUSE_CAMERA_ERROR_NONE;
2122 }
2123
2124 int camera_dispatcher_attr_foreach_supported_theater_mode(muse_module_h module)
2125 {
2126         int ret = CAMERA_ERROR_NONE;
2127         muse_camera_handle_s *muse_camera = NULL;
2128         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_THEATER_MODE;
2129         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_THREAD_SUB;
2130
2131         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2132         LOGD("handle : %p", muse_camera);
2133
2134         ret = legacy_camera_attr_foreach_supported_theater_mode(muse_camera->camera_handle,
2135                                                                 (camera_attr_supported_theater_mode_cb)_camera_dispatcher_callback_supported_theater_mode,
2136                                                                 (void *)module);
2137
2138         muse_camera_msg_return(api, class, ret, module);
2139
2140         return MUSE_CAMERA_ERROR_NONE;
2141 }
2142
2143 int camera_dispatcher_attr_set_preview_fps(muse_module_h module)
2144 {
2145         int ret = CAMERA_ERROR_NONE;
2146         muse_camera_handle_s *muse_camera = NULL;
2147         int set_fps;
2148         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_PREVIEW_FPS;
2149         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2150
2151         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2152
2153         muse_camera_msg_get(set_fps, muse_core_client_get_msg(module));
2154
2155         LOGD("handle : %p", muse_camera);
2156
2157         ret = legacy_camera_attr_set_preview_fps(muse_camera->camera_handle, (camera_attr_fps_e)set_fps);
2158
2159         muse_camera_msg_return(api, class, ret, module);
2160
2161         return MUSE_CAMERA_ERROR_NONE;
2162 }
2163
2164 int camera_dispatcher_attr_set_image_quality(muse_module_h module)
2165 {
2166         int ret = CAMERA_ERROR_NONE;
2167         muse_camera_handle_s *muse_camera = NULL;
2168         int quality;
2169         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_IMAGE_QUALITY;
2170         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2171
2172         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2173
2174         muse_camera_msg_get(quality, muse_core_client_get_msg(module));
2175
2176         LOGD("handle : 0x%x, image_quality : %d", muse_camera, quality);
2177
2178         ret = legacy_camera_attr_set_image_quality(muse_camera->camera_handle, quality);
2179
2180         LOGD("ret : 0x%x", ret);
2181
2182         muse_camera_msg_return(api, class, ret, module);
2183
2184         return MUSE_CAMERA_ERROR_NONE;
2185 }
2186
2187 int camera_dispatcher_attr_get_preview_fps(muse_module_h module)
2188 {
2189         int ret = CAMERA_ERROR_NONE;
2190         muse_camera_handle_s *muse_camera = NULL;
2191         camera_attr_fps_e get_fps = CAMERA_ATTR_FPS_AUTO;
2192         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_PREVIEW_FPS;
2193         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2194
2195         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2196
2197         LOGD("handle : %p", muse_camera);
2198
2199         ret = legacy_camera_attr_get_preview_fps(muse_camera->camera_handle, &get_fps);
2200         if (ret == CAMERA_ERROR_NONE) {
2201                 muse_camera_msg_return1(api, class, ret, module, INT, get_fps);
2202         } else {
2203                 muse_camera_msg_return(api, class, ret, module);
2204         }
2205
2206         return MUSE_CAMERA_ERROR_NONE;
2207 }
2208
2209 int camera_dispatcher_attr_get_image_quality(muse_module_h module)
2210 {
2211         int ret = CAMERA_ERROR_NONE;
2212         muse_camera_handle_s *muse_camera = NULL;
2213         int get_quality = 0;
2214         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_IMAGE_QUALITY;
2215         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2216
2217         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2218
2219         LOGD("handle : %p", muse_camera);
2220
2221         ret = legacy_camera_attr_get_image_quality(muse_camera->camera_handle, &get_quality);
2222         if (ret == CAMERA_ERROR_NONE) {
2223                 muse_camera_msg_return1(api, class, ret, module, INT, get_quality);
2224         } else {
2225                 muse_camera_msg_return(api, class, ret, module);
2226         }
2227
2228         return MUSE_CAMERA_ERROR_NONE;
2229 }
2230
2231 int camera_dispatcher_attr_set_zoom(muse_module_h module)
2232 {
2233         int ret = CAMERA_ERROR_NONE;
2234         muse_camera_handle_s *muse_camera = NULL;
2235         int zoom;
2236         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_ZOOM;
2237         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2238
2239         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2240
2241         muse_camera_msg_get(zoom, muse_core_client_get_msg(module));
2242
2243         LOGD("handle : 0x%x, zoom : %d", muse_camera, zoom);
2244
2245         ret = legacy_camera_attr_set_zoom(muse_camera->camera_handle, zoom);
2246
2247         LOGD("ret : 0x%x", ret);
2248
2249         muse_camera_msg_return(api, class, ret, module);
2250
2251         return MUSE_CAMERA_ERROR_NONE;
2252 }
2253
2254 int camera_dispatcher_attr_set_af_mode(muse_module_h module)
2255 {
2256         int ret = CAMERA_ERROR_NONE;
2257         muse_camera_handle_s *muse_camera = NULL;
2258         int set_mode;
2259         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_AF_MODE;
2260         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2261
2262         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2263
2264         muse_camera_msg_get(set_mode, muse_core_client_get_msg(module));
2265
2266         LOGD("handle : 0x%x, set_mode : %d", muse_camera, set_mode);
2267
2268         ret = legacy_camera_attr_set_af_mode(muse_camera->camera_handle, (camera_attr_af_mode_e)set_mode);
2269
2270         LOGD("ret : 0x%x", ret);
2271
2272         muse_camera_msg_return(api, class, ret, module);
2273
2274         return MUSE_CAMERA_ERROR_NONE;
2275 }
2276
2277 int camera_dispatcher_attr_set_af_area(muse_module_h module)
2278 {
2279         int ret = CAMERA_ERROR_NONE;
2280         muse_camera_handle_s *muse_camera = NULL;
2281         int x;
2282         int y;
2283         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_AF_AREA;
2284         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2285
2286         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2287
2288         muse_camera_msg_get(x, muse_core_client_get_msg(module));
2289         muse_camera_msg_get(y, muse_core_client_get_msg(module));
2290
2291         LOGD("handle : %p", muse_camera);
2292
2293         ret = legacy_camera_attr_set_af_area(muse_camera->camera_handle, x, y);
2294
2295         LOGD("ret : 0x%x", ret);
2296
2297         muse_camera_msg_return(api, class, ret, module);
2298
2299         return MUSE_CAMERA_ERROR_NONE;
2300 }
2301
2302 int camera_dispatcher_attr_clear_af_area(muse_module_h module)
2303 {
2304         int ret = CAMERA_ERROR_NONE;
2305         muse_camera_handle_s *muse_camera = NULL;
2306         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_CLEAR_AF_AREA;
2307         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2308
2309         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2310
2311         LOGD("handle : %p", muse_camera);
2312
2313         ret = legacy_camera_attr_clear_af_area(muse_camera->camera_handle);
2314
2315         LOGD("ret : 0x%x", ret);
2316
2317         muse_camera_msg_return(api, class, ret, module);
2318
2319         return MUSE_CAMERA_ERROR_NONE;
2320 }
2321
2322 int camera_dispatcher_attr_set_exposure_mode(muse_module_h module)
2323 {
2324         int ret = CAMERA_ERROR_NONE;
2325         muse_camera_handle_s *muse_camera = NULL;
2326         int set_mode;
2327         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_EXPOSURE_MODE;
2328         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2329
2330         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2331
2332         muse_camera_msg_get(set_mode, muse_core_client_get_msg(module));
2333
2334         LOGD("handle : 0x%x, set_mode : %d", muse_camera, set_mode);
2335
2336         ret = legacy_camera_attr_set_exposure_mode(muse_camera->camera_handle, (camera_attr_exposure_mode_e)set_mode);
2337
2338         LOGD("ret : 0x%x", ret);
2339
2340         muse_camera_msg_return(api, class, ret, module);
2341
2342         return MUSE_CAMERA_ERROR_NONE;
2343 }
2344
2345 int camera_dispatcher_attr_set_exposure(muse_module_h module)
2346 {
2347         int ret = CAMERA_ERROR_NONE;
2348         muse_camera_handle_s *muse_camera = NULL;
2349         int value;
2350         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_EXPOSURE;
2351         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2352
2353         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2354
2355         muse_camera_msg_get(value, muse_core_client_get_msg(module));
2356
2357         LOGD("handle : 0x%x, value : %d", muse_camera, value);
2358
2359         ret = legacy_camera_attr_set_exposure(muse_camera->camera_handle, value);
2360
2361         LOGD("ret : 0x%x", ret);
2362
2363         muse_camera_msg_return(api, class, ret, module);
2364
2365         return MUSE_CAMERA_ERROR_NONE;
2366 }
2367
2368 int camera_dispatcher_attr_set_iso(muse_module_h module)
2369 {
2370         int ret = CAMERA_ERROR_NONE;
2371         muse_camera_handle_s *muse_camera = NULL;
2372         int set_iso;
2373         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_ISO;
2374         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2375
2376         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2377
2378         muse_camera_msg_get(set_iso, muse_core_client_get_msg(module));
2379
2380         LOGD("handle : 0x%x, set_iso : %d", muse_camera, set_iso);
2381
2382         ret = legacy_camera_attr_set_iso(muse_camera->camera_handle, (camera_attr_iso_e)set_iso);
2383
2384         LOGD("ret : 0x%x", ret);
2385
2386         muse_camera_msg_return(api, class, ret, module);
2387
2388         return MUSE_CAMERA_ERROR_NONE;
2389 }
2390
2391 int camera_dispatcher_attr_set_brightness(muse_module_h module)
2392 {
2393         int ret = CAMERA_ERROR_NONE;
2394         muse_camera_handle_s *muse_camera = NULL;
2395         int level;
2396         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_BRIGHTNESS;
2397         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2398
2399         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2400
2401         muse_camera_msg_get(level, muse_core_client_get_msg(module));
2402
2403         LOGD("handle : 0x%x, level : %d", muse_camera, level);
2404
2405         ret = legacy_camera_attr_set_brightness(muse_camera->camera_handle, level);
2406
2407         LOGD("ret : 0x%x", ret);
2408
2409         muse_camera_msg_return(api, class, ret, module);
2410
2411         return MUSE_CAMERA_ERROR_NONE;
2412 }
2413
2414 int camera_dispatcher_attr_set_contrast(muse_module_h module)
2415 {
2416         int ret = CAMERA_ERROR_NONE;
2417         muse_camera_handle_s *muse_camera = NULL;
2418         int level;
2419         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_CONTRAST;
2420         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2421
2422         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2423
2424         muse_camera_msg_get(level, muse_core_client_get_msg(module));
2425
2426         LOGD("handle : 0x%x, level : %d", muse_camera, level);
2427
2428         ret = legacy_camera_attr_set_contrast(muse_camera->camera_handle, level);
2429
2430         LOGD("ret : 0x%x", ret);
2431
2432         muse_camera_msg_return(api, class, ret, module);
2433
2434         return MUSE_CAMERA_ERROR_NONE;
2435 }
2436
2437 int camera_dispatcher_attr_set_whitebalance(muse_module_h module)
2438 {
2439         int ret = CAMERA_ERROR_NONE;
2440         muse_camera_handle_s *muse_camera = NULL;
2441         int set_whitebalance;
2442         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_WHITEBALANCE;
2443         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2444
2445         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2446
2447         muse_camera_msg_get(set_whitebalance, muse_core_client_get_msg(module));
2448
2449         LOGD("handle : 0x%x, set_whitebalance : %d", muse_camera, set_whitebalance);
2450
2451         ret = legacy_camera_attr_set_whitebalance(muse_camera->camera_handle, (camera_attr_whitebalance_e)set_whitebalance);
2452
2453         LOGD("ret : 0x%x", ret);
2454
2455         muse_camera_msg_return(api, class, ret, module);
2456
2457         return MUSE_CAMERA_ERROR_NONE;
2458 }
2459
2460 int camera_dispatcher_attr_set_effect(muse_module_h module)
2461 {
2462         int ret = CAMERA_ERROR_NONE;
2463         muse_camera_handle_s *muse_camera = NULL;
2464         int set_effect;
2465         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_EFFECT;
2466         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2467
2468         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2469
2470         muse_camera_msg_get(set_effect, muse_core_client_get_msg(module));
2471
2472         LOGD("handle : 0x%x, set_effect : %d", muse_camera, set_effect);
2473
2474         ret = legacy_camera_attr_set_effect(muse_camera->camera_handle, (camera_attr_effect_mode_e)set_effect);
2475
2476         LOGD("ret : 0x%x", ret);
2477
2478         muse_camera_msg_return(api, class, ret, module);
2479
2480         return MUSE_CAMERA_ERROR_NONE;
2481 }
2482
2483 int camera_dispatcher_attr_set_scene_mode(muse_module_h module)
2484 {
2485         int ret = CAMERA_ERROR_NONE;
2486         muse_camera_handle_s *muse_camera = NULL;
2487         int set_mode;
2488         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_SCENE_MODE;
2489         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2490
2491         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2492
2493         muse_camera_msg_get(set_mode, muse_core_client_get_msg(module));
2494
2495         LOGD("handle : 0x%x, set_mode : %d", muse_camera, set_mode);
2496
2497         ret = legacy_camera_attr_set_scene_mode(muse_camera->camera_handle, (camera_attr_scene_mode_e)set_mode);
2498
2499         LOGD("ret : 0x%x", ret);
2500
2501         muse_camera_msg_return(api, class, ret, module);
2502
2503         return MUSE_CAMERA_ERROR_NONE;
2504 }
2505
2506 int camera_dispatcher_attr_enable_tag(muse_module_h module)
2507 {
2508         int ret = CAMERA_ERROR_NONE;
2509         muse_camera_handle_s *muse_camera = NULL;
2510         int set_enable;
2511         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_ENABLE_TAG;
2512         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2513
2514         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2515
2516         muse_camera_msg_get(set_enable, muse_core_client_get_msg(module));
2517
2518         LOGD("handle : 0x%x, set_enable : %d", muse_camera, set_enable);
2519
2520         ret = legacy_camera_attr_enable_tag(muse_camera->camera_handle, (bool)set_enable);
2521
2522         LOGD("ret : 0x%x", ret);
2523
2524         muse_camera_msg_return(api, class, ret, module);
2525
2526         return MUSE_CAMERA_ERROR_NONE;
2527 }
2528
2529 int camera_dispatcher_attr_set_tag_image_description(muse_module_h module)
2530 {
2531         int ret = CAMERA_ERROR_NONE;
2532         muse_camera_handle_s *muse_camera = NULL;
2533         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_TAG_IMAGE_DESCRIPTION;
2534         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2535         char description[MUSE_CAMERA_MSG_MAX_LENGTH] = {0,};
2536
2537         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2538
2539         muse_camera_msg_get_string(description, muse_core_client_get_msg(module));
2540
2541         LOGD("handle : 0x%x, description : %s", muse_camera, description);
2542
2543         ret = legacy_camera_attr_set_tag_image_description(muse_camera->camera_handle, description);
2544
2545         LOGD("ret : 0x%x", ret);
2546
2547         muse_camera_msg_return(api, class, ret, module);
2548
2549         return MUSE_CAMERA_ERROR_NONE;
2550 }
2551
2552 int camera_dispatcher_attr_set_tag_orientation(muse_module_h module)
2553 {
2554         int ret = CAMERA_ERROR_NONE;
2555         muse_camera_handle_s *muse_camera = NULL;
2556         int set_orientation;
2557         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_TAG_ORIENTATION;
2558         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2559
2560         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2561
2562         muse_camera_msg_get(set_orientation, muse_core_client_get_msg(module));
2563
2564         LOGD("handle : 0x%x, set_orientation : %d", muse_camera, set_orientation);
2565
2566         ret = legacy_camera_attr_set_tag_orientation(muse_camera->camera_handle, (camera_attr_tag_orientation_e)set_orientation);
2567
2568         LOGD("ret : 0x%x", ret);
2569
2570         muse_camera_msg_return(api, class, ret, module);
2571
2572         return MUSE_CAMERA_ERROR_NONE;
2573 }
2574
2575 int camera_dispatcher_attr_set_tag_software(muse_module_h module)
2576 {
2577         int ret = CAMERA_ERROR_NONE;
2578         muse_camera_handle_s *muse_camera = NULL;
2579         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_TAG_SOFTWARE;
2580         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2581         char software[MUSE_CAMERA_MSG_MAX_LENGTH] = {0,};
2582
2583         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2584
2585         muse_camera_msg_get_string(software, muse_core_client_get_msg(module));
2586
2587         LOGD("handle : 0x%x, software : %s", muse_camera, software);
2588
2589         ret = legacy_camera_attr_set_tag_software(muse_camera->camera_handle, software);
2590
2591         LOGD("ret : 0x%x", ret);
2592
2593         muse_camera_msg_return(api, class, ret, module);
2594
2595         return MUSE_CAMERA_ERROR_NONE;
2596 }
2597
2598 int camera_dispatcher_attr_set_geotag(muse_module_h module)
2599 {
2600         int ret = CAMERA_ERROR_NONE;
2601         muse_camera_handle_s *muse_camera = NULL;
2602         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_GEOTAG;
2603         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2604         double set_geotag[3] = {0,};
2605
2606         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2607
2608         muse_camera_msg_get_array(set_geotag, muse_core_client_get_msg(module));
2609
2610         LOGD("handle : 0x%x, set_geotag1 : %d, set_geotag2 : %d, set_geotag3 : %d",
2611              muse_camera, set_geotag[0], set_geotag[1], set_geotag[2]);
2612
2613         ret = legacy_camera_attr_set_geotag(muse_camera->camera_handle, set_geotag[0], set_geotag[1], set_geotag[2]);
2614
2615         LOGD("ret : 0x%x", ret);
2616
2617         muse_camera_msg_return(api, class, ret, module);
2618
2619         return MUSE_CAMERA_ERROR_NONE;
2620 }
2621
2622 int camera_dispatcher_attr_remove_geotag(muse_module_h module)
2623 {
2624         int ret = CAMERA_ERROR_NONE;
2625         muse_camera_handle_s *muse_camera = NULL;
2626         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_REMOVE_GEOTAG;
2627         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2628
2629         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2630
2631         LOGD("handle : %p", muse_camera);
2632
2633         ret = legacy_camera_attr_remove_geotag(muse_camera->camera_handle);
2634
2635         LOGD("ret : 0x%x", ret);
2636
2637         muse_camera_msg_return(api, class, ret, module);
2638
2639         return MUSE_CAMERA_ERROR_NONE;
2640 }
2641
2642 int camera_dispatcher_attr_set_flash_mode(muse_module_h module)
2643 {
2644         int ret = CAMERA_ERROR_NONE;
2645         muse_camera_handle_s *muse_camera = NULL;
2646         int set_mode;
2647         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_FLASH_MODE;
2648         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2649
2650         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2651
2652         muse_camera_msg_get(set_mode, muse_core_client_get_msg(module));
2653
2654         LOGD("handle : 0x%x, set_mode : %d", muse_camera, set_mode);
2655
2656         ret = legacy_camera_attr_set_flash_mode(muse_camera->camera_handle, (camera_attr_flash_mode_e)set_mode);
2657
2658         LOGD("ret : 0x%x", ret);
2659
2660         muse_camera_msg_return(api, class, ret, module);
2661
2662         return MUSE_CAMERA_ERROR_NONE;
2663 }
2664
2665 int camera_dispatcher_attr_get_zoom(muse_module_h module)
2666 {
2667         int ret = CAMERA_ERROR_NONE;
2668         muse_camera_handle_s *muse_camera = NULL;
2669         int get_zoom = 0;
2670         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_ZOOM;
2671         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2672
2673         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2674
2675         LOGD("handle : %p", muse_camera);
2676
2677         ret = legacy_camera_attr_get_zoom(muse_camera->camera_handle, &get_zoom);
2678         if (ret == CAMERA_ERROR_NONE) {
2679                 muse_camera_msg_return1(api, class, ret, module, INT, get_zoom);
2680         } else {
2681                 muse_camera_msg_return(api, class, ret, module);
2682         }
2683
2684         return MUSE_CAMERA_ERROR_NONE;
2685 }
2686
2687 int camera_dispatcher_attr_get_zoom_range(muse_module_h module)
2688 {
2689         int ret = CAMERA_ERROR_NONE;
2690         muse_camera_handle_s *muse_camera = NULL;
2691         int get_min = 0;
2692         int get_max = 0;
2693         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_ZOOM_RANGE;
2694         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2695
2696         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2697
2698         LOGD("handle : %p", muse_camera);
2699
2700         ret = legacy_camera_attr_get_zoom_range(muse_camera->camera_handle, &get_min, &get_max);
2701         if (ret == CAMERA_ERROR_NONE) {
2702                 muse_camera_msg_return2(api, class, ret, module, INT, get_min, INT, get_max);
2703         } else {
2704                 muse_camera_msg_return(api, class, ret, module);
2705         }
2706
2707         return MUSE_CAMERA_ERROR_NONE;
2708 }
2709
2710 int camera_dispatcher_attr_get_af_mode(muse_module_h module)
2711 {
2712         int ret = CAMERA_ERROR_NONE;
2713         muse_camera_handle_s *muse_camera = NULL;
2714         camera_attr_af_mode_e get_mode = CAMERA_ATTR_AF_NONE;
2715         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_AF_MODE;
2716         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2717
2718         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2719
2720         LOGD("handle : %p", muse_camera);
2721
2722         ret = legacy_camera_attr_get_af_mode(muse_camera->camera_handle, &get_mode);
2723         if (ret == CAMERA_ERROR_NONE) {
2724                 muse_camera_msg_return1(api, class, ret, module, INT, get_mode);
2725         } else {
2726                 muse_camera_msg_return(api, class, ret, module);
2727         }
2728
2729         return MUSE_CAMERA_ERROR_NONE;
2730 }
2731
2732 int camera_dispatcher_attr_get_exposure_mode(muse_module_h module)
2733 {
2734         int ret = CAMERA_ERROR_NONE;
2735         muse_camera_handle_s *muse_camera = NULL;
2736         camera_attr_exposure_mode_e get_mode = CAMERA_ATTR_EXPOSURE_MODE_OFF;
2737         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_EXPOSURE_MODE;
2738         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2739
2740         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2741
2742         LOGD("handle : %p", muse_camera);
2743
2744         ret = legacy_camera_attr_get_exposure_mode(muse_camera->camera_handle, &get_mode);
2745         if (ret == CAMERA_ERROR_NONE) {
2746                 muse_camera_msg_return1(api, class, ret, module, INT, get_mode);
2747         } else {
2748                 muse_camera_msg_return(api, class, ret, module);
2749         }
2750
2751         return MUSE_CAMERA_ERROR_NONE;
2752 }
2753
2754 int camera_dispatcher_attr_get_exposure(muse_module_h module)
2755 {
2756         int ret = CAMERA_ERROR_NONE;
2757         muse_camera_handle_s *muse_camera = NULL;
2758         int get_value = 0;
2759         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_EXPOSURE;
2760         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2761
2762         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2763
2764         LOGD("handle : %p", muse_camera);
2765
2766         ret = legacy_camera_attr_get_exposure(muse_camera->camera_handle, &get_value);
2767         if (ret == CAMERA_ERROR_NONE) {
2768                 muse_camera_msg_return1(api, class, ret, module, INT, get_value);
2769         } else {
2770                 muse_camera_msg_return(api, class, ret, module);
2771         }
2772
2773         return MUSE_CAMERA_ERROR_NONE;
2774 }
2775
2776 int camera_dispatcher_attr_get_exposure_range(muse_module_h module)
2777 {
2778         int ret = CAMERA_ERROR_NONE;
2779         muse_camera_handle_s *muse_camera = NULL;
2780         int get_min = 0;
2781         int get_max = 0;
2782         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_EXPOSURE_RANGE;
2783         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2784
2785         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2786
2787         LOGD("handle : %p", muse_camera);
2788
2789         ret = legacy_camera_attr_get_exposure_range(muse_camera->camera_handle, &get_min, &get_max);
2790         if (ret == CAMERA_ERROR_NONE) {
2791                 muse_camera_msg_return2(api, class, ret, module, INT, get_min, INT, get_max);
2792         } else {
2793                 muse_camera_msg_return(api, class, ret, module);
2794         }
2795
2796         return MUSE_CAMERA_ERROR_NONE;
2797 }
2798
2799 int camera_dispatcher_attr_get_iso(muse_module_h module)
2800 {
2801         int ret = CAMERA_ERROR_NONE;
2802         muse_camera_handle_s *muse_camera = NULL;
2803         camera_attr_iso_e get_iso = CAMERA_ATTR_ISO_AUTO;
2804         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_ISO;
2805         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2806
2807         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2808
2809         LOGD("handle : %p", muse_camera);
2810
2811         ret = legacy_camera_attr_get_iso(muse_camera->camera_handle, &get_iso);
2812         if (ret == CAMERA_ERROR_NONE) {
2813                 muse_camera_msg_return1(api, class, ret, module, INT, get_iso);
2814         } else {
2815                 muse_camera_msg_return(api, class, ret, module);
2816         }
2817
2818         return MUSE_CAMERA_ERROR_NONE;
2819 }
2820
2821 int camera_dispatcher_attr_get_brightness(muse_module_h module)
2822 {
2823         int ret = CAMERA_ERROR_NONE;
2824         muse_camera_handle_s *muse_camera = NULL;
2825         int get_level = 0;
2826         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_BRIGHTNESS;
2827         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2828
2829         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2830
2831         LOGD("handle : %p", muse_camera);
2832
2833         ret = legacy_camera_attr_get_brightness(muse_camera->camera_handle, &get_level);
2834         if (ret == CAMERA_ERROR_NONE) {
2835                 muse_camera_msg_return1(api, class, ret, module, INT, get_level);
2836         } else {
2837                 muse_camera_msg_return(api, class, ret, module);
2838         }
2839
2840         return MUSE_CAMERA_ERROR_NONE;
2841 }
2842
2843 int camera_dispatcher_attr_get_brightness_range(muse_module_h module)
2844 {
2845         int ret = CAMERA_ERROR_NONE;
2846         muse_camera_handle_s *muse_camera = NULL;
2847         int get_min = 0;
2848         int get_max = 0;
2849         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_BRIGHTNESS_RANGE;
2850         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2851
2852         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2853
2854         LOGD("handle : %p", muse_camera);
2855
2856         ret = legacy_camera_attr_get_brightness_range(muse_camera->camera_handle, &get_min, &get_max);
2857         if (ret == CAMERA_ERROR_NONE) {
2858                 muse_camera_msg_return2(api, class, ret, module, INT, get_min, INT, get_max);
2859         } else {
2860                 muse_camera_msg_return(api, class, ret, module);
2861         }
2862
2863         return MUSE_CAMERA_ERROR_NONE;
2864 }
2865
2866 int camera_dispatcher_attr_get_contrast(muse_module_h module)
2867 {
2868         int ret = CAMERA_ERROR_NONE;
2869         muse_camera_handle_s *muse_camera = NULL;
2870         int get_level = 0;
2871         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_CONTRAST;
2872         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2873
2874         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2875
2876         LOGD("handle : %p", muse_camera);
2877
2878         ret = legacy_camera_attr_get_contrast(muse_camera->camera_handle, &get_level);
2879         if (ret == CAMERA_ERROR_NONE) {
2880                 muse_camera_msg_return1(api, class, ret, module, INT, get_level);
2881         } else {
2882                 muse_camera_msg_return(api, class, ret, module);
2883         }
2884
2885         return MUSE_CAMERA_ERROR_NONE;
2886 }
2887
2888 int camera_dispatcher_attr_get_contrast_range(muse_module_h module)
2889 {
2890         int ret = CAMERA_ERROR_NONE;
2891         muse_camera_handle_s *muse_camera = NULL;
2892         int get_min = 0;
2893         int get_max = 0;
2894         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_CONTRAST_RANGE;
2895         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2896
2897         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2898
2899         LOGD("handle : %p", muse_camera);
2900
2901         ret = legacy_camera_attr_get_contrast_range(muse_camera->camera_handle, &get_min, &get_max);
2902         if (ret == CAMERA_ERROR_NONE) {
2903                 muse_camera_msg_return2(api, class, ret, module, INT, get_min, INT, get_max);
2904         } else {
2905                 muse_camera_msg_return(api, class, ret, module);
2906         }
2907
2908         return MUSE_CAMERA_ERROR_NONE;
2909 }
2910
2911 int camera_dispatcher_attr_get_whitebalance(muse_module_h module)
2912 {
2913         int ret = CAMERA_ERROR_NONE;
2914         muse_camera_handle_s *muse_camera = NULL;
2915         camera_attr_whitebalance_e get_wb = CAMERA_ATTR_WHITE_BALANCE_NONE;
2916         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_WHITEBALANCE;
2917         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2918
2919         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2920
2921         LOGD("handle : %p", muse_camera);
2922
2923         ret = legacy_camera_attr_get_whitebalance(muse_camera->camera_handle, &get_wb);
2924         if (ret == CAMERA_ERROR_NONE) {
2925                 muse_camera_msg_return1(api, class, ret, module, INT, get_wb);
2926         } else {
2927                 muse_camera_msg_return(api, class, ret, module);
2928         }
2929
2930         return MUSE_CAMERA_ERROR_NONE;
2931 }
2932
2933 int camera_dispatcher_attr_get_effect(muse_module_h module)
2934 {
2935         int ret = CAMERA_ERROR_NONE;
2936         muse_camera_handle_s *muse_camera = NULL;
2937         camera_attr_effect_mode_e get_effect = CAMERA_ATTR_EFFECT_NONE;
2938         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_EFFECT;
2939         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2940
2941         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2942
2943         LOGD("handle : %p", muse_camera);
2944
2945         ret = legacy_camera_attr_get_effect(muse_camera->camera_handle, &get_effect);
2946         if (ret == CAMERA_ERROR_NONE) {
2947                 muse_camera_msg_return1(api, class, ret, module, INT, get_effect);
2948         } else {
2949                 muse_camera_msg_return(api, class, ret, module);
2950         }
2951
2952         return MUSE_CAMERA_ERROR_NONE;
2953 }
2954
2955 int camera_dispatcher_attr_get_scene_mode(muse_module_h module)
2956 {
2957         int ret = CAMERA_ERROR_NONE;
2958         muse_camera_handle_s *muse_camera = NULL;
2959         camera_attr_scene_mode_e get_mode = CAMERA_ATTR_SCENE_MODE_NORMAL;
2960         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_SCENE_MODE;
2961         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2962
2963         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2964
2965         LOGD("handle : %p", muse_camera);
2966
2967         ret = legacy_camera_attr_get_scene_mode(muse_camera->camera_handle, &get_mode);
2968         if (ret == CAMERA_ERROR_NONE) {
2969                 muse_camera_msg_return1(api, class, ret, module, INT, get_mode);
2970         } else {
2971                 muse_camera_msg_return(api, class, ret, module);
2972         }
2973
2974         return MUSE_CAMERA_ERROR_NONE;
2975 }
2976
2977 int camera_dispatcher_attr_is_enabled_tag(muse_module_h module)
2978 {
2979         int ret = CAMERA_ERROR_NONE;
2980         muse_camera_handle_s *muse_camera = NULL;
2981         bool get_enabled = false;
2982         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_ENABLED_TAG;
2983         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
2984
2985         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
2986
2987         LOGD("handle : %p", muse_camera);
2988
2989         ret = legacy_camera_attr_is_enabled_tag(muse_camera->camera_handle, &get_enabled);
2990         if (ret == CAMERA_ERROR_NONE) {
2991                 muse_camera_msg_return1(api, class, ret, module, INT, get_enabled);
2992         } else {
2993                 muse_camera_msg_return(api, class, ret, module);
2994         }
2995
2996         return MUSE_CAMERA_ERROR_NONE;
2997 }
2998
2999 int camera_dispatcher_attr_get_tag_image_description(muse_module_h module)
3000 {
3001         int ret = CAMERA_ERROR_NONE;
3002         muse_camera_handle_s *muse_camera = NULL;
3003         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_TAG_IMAGE_DESCRIPTION;
3004         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3005         char *get_description = NULL;
3006
3007         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3008
3009         ret = legacy_camera_attr_get_tag_image_description(muse_camera->camera_handle, &get_description);
3010         if (ret == CAMERA_ERROR_NONE) {
3011                 LOGD("get_description : %s", muse_camera, get_description);
3012                 muse_camera_msg_return1(api, class, ret, module, STRING, get_description);
3013         } else {
3014                 muse_camera_msg_return(api, class, ret, module);
3015         }
3016
3017         if (get_description) {
3018                 free(get_description);
3019                 get_description = NULL;
3020         }
3021
3022         return MUSE_CAMERA_ERROR_NONE;
3023 }
3024
3025 int camera_dispatcher_attr_get_tag_orientation(muse_module_h module)
3026 {
3027         int ret = CAMERA_ERROR_NONE;
3028         muse_camera_handle_s *muse_camera = NULL;
3029         camera_attr_tag_orientation_e get_orientation = CAMERA_ATTR_TAG_ORIENTATION_TOP_LEFT;
3030         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_TAG_ORIENTATION;
3031         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3032
3033         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3034
3035         LOGD("handle : %p", muse_camera);
3036
3037         ret = legacy_camera_attr_get_tag_orientation(muse_camera->camera_handle, &get_orientation);
3038         if (ret == CAMERA_ERROR_NONE) {
3039                 muse_camera_msg_return1(api, class, ret, module, INT, get_orientation);
3040         } else {
3041                 muse_camera_msg_return(api, class, ret, module);
3042         }
3043
3044         return MUSE_CAMERA_ERROR_NONE;
3045 }
3046
3047 int camera_dispatcher_attr_get_tag_software(muse_module_h module)
3048 {
3049         int ret = CAMERA_ERROR_NONE;
3050         muse_camera_handle_s *muse_camera = NULL;
3051         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_TAG_SOFTWARE;
3052         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3053         char *get_software = NULL;
3054
3055         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3056
3057         ret = legacy_camera_attr_get_tag_software(muse_camera->camera_handle, &get_software);
3058         if (ret == CAMERA_ERROR_NONE) {
3059                 LOGD("get_software : %s", get_software);
3060                 muse_camera_msg_return1(api, class, ret, module, STRING, get_software);
3061         } else {
3062                 muse_camera_msg_return(api, class, ret, module);
3063         }
3064
3065         if (get_software) {
3066                 free(get_software);
3067                 get_software = NULL;
3068         }
3069
3070         return MUSE_CAMERA_ERROR_NONE;
3071 }
3072
3073 int camera_dispatcher_attr_get_geotag(muse_module_h module)
3074 {
3075         int ret = CAMERA_ERROR_NONE;
3076         muse_camera_handle_s *muse_camera = NULL;
3077         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_GEOTAG;
3078         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3079         double get_geotag[3] = {0.0, 0.0, 0.0};
3080
3081         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3082
3083         LOGD("handle : %p", muse_camera);
3084
3085         ret = legacy_camera_attr_get_geotag(muse_camera->camera_handle, &get_geotag[0], &get_geotag[1], &get_geotag[2]);
3086         if (ret == CAMERA_ERROR_NONE) {
3087                 muse_camera_msg_return_array(api, class, ret, module, get_geotag, sizeof(get_geotag), sizeof(double));
3088         } else {
3089                 muse_camera_msg_return(api, class, ret, module);
3090         }
3091
3092         return MUSE_CAMERA_ERROR_NONE;
3093 }
3094
3095 int camera_dispatcher_attr_get_flash_mode(muse_module_h module)
3096 {
3097         int ret = CAMERA_ERROR_NONE;
3098         muse_camera_handle_s *muse_camera = NULL;
3099         camera_attr_flash_mode_e get_mode = CAMERA_ATTR_FLASH_MODE_OFF;
3100         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_FLASH_MODE;
3101         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3102
3103         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3104
3105         LOGD("handle : %p", muse_camera);
3106
3107         ret = legacy_camera_attr_get_flash_mode(muse_camera->camera_handle, &get_mode);
3108         if (ret == CAMERA_ERROR_NONE) {
3109                 muse_camera_msg_return1(api, class, ret, module, INT, get_mode);
3110         } else {
3111                 muse_camera_msg_return(api, class, ret, module);
3112         }
3113
3114         return MUSE_CAMERA_ERROR_NONE;
3115 }
3116
3117 int camera_dispatcher_attr_foreach_supported_af_mode(muse_module_h module)
3118 {
3119         int ret = CAMERA_ERROR_NONE;
3120         muse_camera_handle_s *muse_camera = NULL;
3121         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_AF_MODE;
3122         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_THREAD_SUB;
3123
3124         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3125
3126         LOGD("handle : %p", muse_camera);
3127
3128         ret = legacy_camera_attr_foreach_supported_af_mode(muse_camera->camera_handle,
3129                                                            (camera_attr_supported_af_mode_cb)_camera_dispatcher_callback_supported_af_mode,
3130                                                            (void *)module);
3131
3132         LOGD("ret : 0x%x", ret);
3133
3134         muse_camera_msg_return(api, class, ret, module);
3135
3136         return MUSE_CAMERA_ERROR_NONE;
3137 }
3138
3139 int camera_dispatcher_attr_foreach_supported_exposure_mode(muse_module_h module)
3140 {
3141         int ret = CAMERA_ERROR_NONE;
3142         muse_camera_handle_s *muse_camera = NULL;
3143         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_EXPOSURE_MODE;
3144         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_THREAD_SUB;
3145
3146         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3147
3148         LOGD("handle : 0x%x, api : %d", muse_camera, api);
3149
3150         ret = legacy_camera_attr_foreach_supported_exposure_mode(muse_camera->camera_handle,
3151                                                                  (camera_attr_supported_exposure_mode_cb)_camera_dispatcher_callback_supported_exposure_mode,
3152                                                                  (void *)module);
3153
3154         LOGD("ret : 0x%x", ret);
3155
3156         muse_camera_msg_return(api, class, ret, module);
3157
3158         return MUSE_CAMERA_ERROR_NONE;
3159 }
3160
3161 int camera_dispatcher_attr_foreach_supported_iso(muse_module_h module)
3162 {
3163         int ret = CAMERA_ERROR_NONE;
3164         muse_camera_handle_s *muse_camera = NULL;
3165         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_ISO;
3166         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_THREAD_SUB;
3167
3168         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3169
3170         LOGD("handle : %p", muse_camera);
3171
3172         ret = legacy_camera_attr_foreach_supported_iso(muse_camera->camera_handle,
3173                                                        (camera_attr_supported_iso_cb)_camera_dispatcher_callback_supported_iso_mode,
3174                                                        (void *)module);
3175
3176         LOGD("ret : 0x%x", ret);
3177
3178         muse_camera_msg_return(api, class, ret, module);
3179
3180         return MUSE_CAMERA_ERROR_NONE;
3181 }
3182
3183 int camera_dispatcher_attr_foreach_supported_whitebalance(muse_module_h module)
3184 {
3185         int ret = CAMERA_ERROR_NONE;
3186         muse_camera_handle_s *muse_camera = NULL;
3187         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_WHITEBALANCE;
3188         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_THREAD_SUB;
3189
3190         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3191
3192         LOGD("handle : %p", muse_camera);
3193
3194         ret = legacy_camera_attr_foreach_supported_whitebalance(muse_camera->camera_handle,
3195                                                                 (camera_attr_supported_whitebalance_cb)_camera_dispatcher_callback_supported_whitebalance,
3196                                                                 (void *)module);
3197
3198         LOGD("ret : 0x%x", ret);
3199
3200         muse_camera_msg_return(api, class, ret, module);
3201
3202         return MUSE_CAMERA_ERROR_NONE;
3203 }
3204
3205 int camera_dispatcher_attr_foreach_supported_effect(muse_module_h module)
3206 {
3207         int ret = CAMERA_ERROR_NONE;
3208         muse_camera_handle_s *muse_camera = NULL;
3209         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_EFFECT;
3210         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_THREAD_SUB;
3211
3212         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3213
3214         LOGD("handle : %p", muse_camera);
3215
3216         ret = legacy_camera_attr_foreach_supported_effect(muse_camera->camera_handle,
3217                                                           (camera_attr_supported_effect_cb)_camera_dispatcher_callback_supported_effect,
3218                                                           (void *)module);
3219
3220         LOGD("ret : 0x%x", ret);
3221
3222         muse_camera_msg_return(api, class, ret, module);
3223
3224         return MUSE_CAMERA_ERROR_NONE;
3225 }
3226
3227 int camera_dispatcher_attr_foreach_supported_scene_mode(muse_module_h module)
3228 {
3229         int ret = CAMERA_ERROR_NONE;
3230         muse_camera_handle_s *muse_camera = NULL;
3231         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_SCENE_MODE;
3232         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_THREAD_SUB;
3233
3234         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3235
3236         LOGD("handle : %p", muse_camera);
3237
3238         ret = legacy_camera_attr_foreach_supported_scene_mode(muse_camera->camera_handle,
3239                                                               (camera_attr_supported_scene_mode_cb)_camera_dispatcher_callback_supported_scene_mode,
3240                                                               (void *)module);
3241
3242         LOGD("ret : 0x%x", ret);
3243
3244         muse_camera_msg_return(api, class, ret, module);
3245
3246         return MUSE_CAMERA_ERROR_NONE;
3247 }
3248
3249 int camera_dispatcher_attr_foreach_supported_flash_mode(muse_module_h module)
3250 {
3251         int ret = CAMERA_ERROR_NONE;
3252         muse_camera_handle_s *muse_camera = NULL;
3253         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_FLASH_MODE;
3254         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_THREAD_SUB;
3255
3256         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3257
3258         LOGD("handle : %p", muse_camera);
3259
3260         ret = legacy_camera_attr_foreach_supported_flash_mode(muse_camera->camera_handle,
3261                                                               (camera_attr_supported_flash_mode_cb)_camera_dispatcher_callback_supported_flash_mode,
3262                                                               (void *)module);
3263
3264         LOGD("ret : 0x%x", ret);
3265
3266         muse_camera_msg_return(api, class, ret, module);
3267
3268         return MUSE_CAMERA_ERROR_NONE;
3269 }
3270
3271 int camera_dispatcher_attr_foreach_supported_fps(muse_module_h module)
3272 {
3273         int ret = CAMERA_ERROR_NONE;
3274         muse_camera_handle_s *muse_camera = NULL;
3275         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_FPS;
3276         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_THREAD_SUB;
3277
3278         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3279
3280         LOGD("handle : %p", muse_camera);
3281
3282         ret = legacy_camera_attr_foreach_supported_fps(muse_camera->camera_handle,
3283                                                        (camera_attr_supported_fps_cb)_camera_dispatcher_callback_supported_fps,
3284                                                        (void *)module);
3285
3286         LOGD("ret : 0x%x", ret);
3287
3288         muse_camera_msg_return(api, class, ret, module);
3289
3290         return MUSE_CAMERA_ERROR_NONE;
3291 }
3292
3293 int camera_dispatcher_attr_foreach_supported_fps_by_resolution(muse_module_h module)
3294 {
3295         int ret = CAMERA_ERROR_NONE;
3296         muse_camera_handle_s *muse_camera = NULL;
3297         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_FPS_BY_RESOLUTION;
3298         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_THREAD_SUB;
3299         int width;
3300         int height;
3301
3302         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3303
3304         muse_camera_msg_get(width, muse_core_client_get_msg(module));
3305         muse_camera_msg_get(height, muse_core_client_get_msg(module));
3306
3307         LOGD("handle : %p", muse_camera);
3308
3309         ret = legacy_camera_attr_foreach_supported_fps_by_resolution(muse_camera->camera_handle,
3310                                                                      width, height,
3311                                                                      (camera_attr_supported_fps_cb)_camera_dispatcher_callback_supported_fps_by_resolution,
3312                                                                      (void *)module);
3313
3314         LOGD("ret : 0x%x", ret);
3315
3316         muse_camera_msg_return(api, class, ret, module);
3317
3318         return MUSE_CAMERA_ERROR_NONE;
3319 }
3320
3321 int camera_dispatcher_attr_foreach_supported_stream_flip(muse_module_h module)
3322 {
3323         int ret = CAMERA_ERROR_NONE;
3324         muse_camera_handle_s *muse_camera = NULL;
3325         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_STREAM_FLIP;
3326         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_THREAD_SUB;
3327
3328         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3329
3330         LOGD("handle : %p", muse_camera);
3331
3332         ret = legacy_camera_attr_foreach_supported_stream_flip(muse_camera->camera_handle,
3333                                                                (camera_attr_supported_stream_flip_cb)_camera_dispatcher_callback_supported_stream_flip,
3334                                                                (void *)module);
3335
3336         LOGD("ret : 0x%x", ret);
3337
3338         muse_camera_msg_return(api, class, ret, module);
3339
3340         return MUSE_CAMERA_ERROR_NONE;
3341 }
3342
3343 int camera_dispatcher_attr_foreach_supported_stream_rotation(muse_module_h module)
3344 {
3345         int ret = CAMERA_ERROR_NONE;
3346         muse_camera_handle_s *muse_camera = NULL;
3347         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_STREAM_ROTATION;
3348         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_THREAD_SUB;
3349
3350         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3351
3352         LOGD("handle : %p", muse_camera);
3353
3354         ret = legacy_camera_attr_foreach_supported_stream_rotation(muse_camera->camera_handle,
3355                                                                    (camera_attr_supported_stream_rotation_cb)_camera_dispatcher_callback_supported_stream_rotation,
3356                                                                    (void *)module);
3357
3358         LOGD("ret : 0x%x", ret);
3359
3360         muse_camera_msg_return(api, class, ret, module);
3361
3362         return MUSE_CAMERA_ERROR_NONE;
3363 }
3364
3365 int camera_dispatcher_attr_set_stream_rotation(muse_module_h module)
3366 {
3367         int ret = CAMERA_ERROR_NONE;
3368         muse_camera_handle_s *muse_camera = NULL;
3369         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_STREAM_ROTATION;
3370         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3371         int set_rotation;
3372
3373         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3374
3375         muse_camera_msg_get(set_rotation, muse_core_client_get_msg(module));
3376
3377         LOGD("handle : %p", muse_camera);
3378
3379         ret = legacy_camera_attr_set_stream_rotation(muse_camera->camera_handle, (camera_rotation_e)set_rotation);
3380
3381         LOGD("ret : 0x%x", ret);
3382
3383         muse_camera_msg_return(api, class, ret, module);
3384
3385         return MUSE_CAMERA_ERROR_NONE;
3386 }
3387
3388 int camera_dispatcher_attr_get_stream_rotation(muse_module_h module)
3389 {
3390         int ret = CAMERA_ERROR_NONE;
3391         muse_camera_handle_s *muse_camera = NULL;
3392         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_STREAM_ROTATION;
3393         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3394         camera_rotation_e get_rotation = CAMERA_ROTATION_NONE;
3395
3396         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3397
3398         LOGD("handle : %p", muse_camera);
3399
3400         ret = legacy_camera_attr_get_stream_rotation(muse_camera->camera_handle, &get_rotation);
3401         if (ret == CAMERA_ERROR_NONE) {
3402                 muse_camera_msg_return1(api, class, ret, module, INT, get_rotation);
3403         } else {
3404                 muse_camera_msg_return(api, class, ret, module);
3405         }
3406
3407         return MUSE_CAMERA_ERROR_NONE;
3408 }
3409
3410 int camera_dispatcher_attr_set_stream_flip(muse_module_h module)
3411 {
3412         int ret = CAMERA_ERROR_NONE;
3413         muse_camera_handle_s *muse_camera = NULL;
3414         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_STREAM_FLIP;
3415         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3416         int set_flip;
3417
3418         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3419
3420         muse_camera_msg_get(set_flip, muse_core_client_get_msg(module));
3421
3422         LOGD("handle : %p", muse_camera);
3423
3424         ret = legacy_camera_attr_set_stream_flip(muse_camera->camera_handle, (camera_flip_e)set_flip);
3425
3426         LOGD("ret : 0x%x", ret);
3427
3428         muse_camera_msg_return(api, class, ret, module);
3429
3430         return MUSE_CAMERA_ERROR_NONE;
3431 }
3432
3433 int camera_dispatcher_attr_get_stream_flip(muse_module_h module)
3434 {
3435         int ret = CAMERA_ERROR_NONE;
3436         muse_camera_handle_s *muse_camera = NULL;
3437         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_STREAM_FLIP;
3438         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3439         camera_flip_e get_flip = CAMERA_FLIP_NONE;
3440
3441         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3442
3443         LOGD("handle : %p", muse_camera);
3444
3445         ret = legacy_camera_attr_get_stream_flip(muse_camera->camera_handle, &get_flip);
3446         if (ret == CAMERA_ERROR_NONE) {
3447                 muse_camera_msg_return1(api, class, ret, module, INT, get_flip);
3448         } else {
3449                 muse_camera_msg_return(api, class, ret, module);
3450         }
3451
3452         return MUSE_CAMERA_ERROR_NONE;
3453 }
3454
3455 int camera_dispatcher_attr_set_hdr_mode(muse_module_h module)
3456 {
3457         int ret = CAMERA_ERROR_NONE;
3458         muse_camera_handle_s *muse_camera = NULL;
3459         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_HDR_MODE;
3460         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3461         int set_mode;
3462
3463         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3464
3465         muse_camera_msg_get(set_mode, muse_core_client_get_msg(module));
3466
3467         LOGD("handle : %p", muse_camera);
3468
3469         ret = legacy_camera_attr_set_hdr_mode(muse_camera->camera_handle, (camera_attr_hdr_mode_e)set_mode);
3470
3471         LOGD("ret : 0x%x", ret);
3472
3473         muse_camera_msg_return(api, class, ret, module);
3474
3475         return MUSE_CAMERA_ERROR_NONE;
3476 }
3477
3478 int camera_dispatcher_attr_get_hdr_mode(muse_module_h module)
3479 {
3480         int ret = CAMERA_ERROR_NONE;
3481         muse_camera_handle_s *muse_camera = NULL;
3482         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_HDR_MODE;
3483         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3484         camera_attr_hdr_mode_e get_mode = CAMERA_ATTR_HDR_MODE_DISABLE;
3485
3486         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3487
3488         LOGD("handle : %p", muse_camera);
3489
3490         ret = legacy_camera_attr_get_hdr_mode(muse_camera->camera_handle, &get_mode);
3491         if (ret == CAMERA_ERROR_NONE) {
3492                 muse_camera_msg_return1(api, class, ret, module, INT, get_mode);
3493         } else {
3494                 muse_camera_msg_return(api, class, ret, module);
3495         }
3496
3497         return MUSE_CAMERA_ERROR_NONE;
3498 }
3499
3500 int camera_dispatcher_attr_is_supported_hdr_capture(muse_module_h module)
3501 {
3502         int ret = CAMERA_ERROR_NONE;
3503         muse_camera_handle_s *muse_camera = NULL;
3504         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_SUPPORTED_HDR_CAPTURE;
3505         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3506
3507         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3508
3509         LOGD("handle : %p", muse_camera);
3510
3511         ret = legacy_camera_attr_is_supported_hdr_capture(muse_camera->camera_handle);
3512
3513         LOGD("ret : 0x%x", ret);
3514
3515         muse_camera_msg_return(api, class, ret, module);
3516
3517         return MUSE_CAMERA_ERROR_NONE;
3518 }
3519
3520 int camera_dispatcher_attr_set_hdr_capture_progress_cb(muse_module_h module)
3521 {
3522         int ret = CAMERA_ERROR_NONE;
3523         muse_camera_handle_s *muse_camera = NULL;
3524         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_HDR_CAPTURE_PROGRESS_CB;
3525         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3526
3527         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3528
3529         LOGD("handle : %p", muse_camera);
3530
3531         ret = legacy_camera_attr_set_hdr_capture_progress_cb(muse_camera->camera_handle,
3532                                                              (camera_attr_hdr_progress_cb)_camera_dispatcher_hdr_progress_cb,
3533                                                              (void *)module);
3534
3535         LOGD("ret : 0x%x", ret);
3536
3537         muse_camera_msg_return(api, class, ret, module);
3538
3539         return MUSE_CAMERA_ERROR_NONE;
3540 }
3541
3542 int camera_dispatcher_attr_unset_hdr_capture_progress_cb(muse_module_h module)
3543 {
3544         int ret = CAMERA_ERROR_NONE;
3545         muse_camera_handle_s *muse_camera = NULL;
3546         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_UNSET_HDR_CAPTURE_PROGRESS_CB;
3547         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3548
3549         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3550
3551         LOGD("handle : %p", muse_camera);
3552
3553         ret = legacy_camera_attr_unset_hdr_capture_progress_cb(muse_camera->camera_handle);
3554
3555         LOGD("ret : 0x%x", ret);
3556
3557         muse_camera_msg_return(api, class, ret, module);
3558
3559         return MUSE_CAMERA_ERROR_NONE;
3560 }
3561
3562 int camera_dispatcher_attr_enable_anti_shake(muse_module_h module)
3563 {
3564         int ret = CAMERA_ERROR_NONE;
3565         muse_camera_handle_s *muse_camera = NULL;
3566         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_ENABLE_ANTI_SHAKE;
3567         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3568         int set_enable;
3569
3570         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3571
3572         muse_camera_msg_get(set_enable, muse_core_client_get_msg(module));
3573
3574         LOGD("handle : %p", muse_camera);
3575
3576         ret = legacy_camera_attr_enable_anti_shake(muse_camera->camera_handle, (bool)set_enable);
3577
3578         LOGD("ret : 0x%x", ret);
3579
3580         muse_camera_msg_return(api, class, ret, module);
3581
3582         return MUSE_CAMERA_ERROR_NONE;
3583 }
3584
3585 int camera_dispatcher_attr_is_enabled_anti_shake(muse_module_h module)
3586 {
3587         int ret = CAMERA_ERROR_NONE;
3588         muse_camera_handle_s *muse_camera = NULL;
3589         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_ENABLED_ANTI_SHAKE;
3590         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3591         bool get_enabled = false;
3592
3593         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3594
3595         LOGD("handle : %p", muse_camera);
3596
3597         ret = legacy_camera_attr_is_enabled_anti_shake(muse_camera->camera_handle, &get_enabled);
3598         if (ret == CAMERA_ERROR_NONE) {
3599                 muse_camera_msg_return1(api, class, ret, module, INT, get_enabled);
3600         } else {
3601                 muse_camera_msg_return(api, class, ret, module);
3602         }
3603
3604         return MUSE_CAMERA_ERROR_NONE;
3605 }
3606
3607 int camera_dispatcher_attr_is_supported_anti_shake(muse_module_h module)
3608 {
3609         int ret = CAMERA_ERROR_NONE;
3610         muse_camera_handle_s *muse_camera = NULL;
3611         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_SUPPORTED_ANTI_SHAKE;
3612         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3613
3614         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3615
3616         LOGD("handle : %p", muse_camera);
3617
3618         ret = legacy_camera_attr_is_supported_anti_shake(muse_camera->camera_handle);
3619
3620         LOGD("ret : 0x%x", ret);
3621
3622         muse_camera_msg_return(api, class, ret, module);
3623
3624         return MUSE_CAMERA_ERROR_NONE;
3625 }
3626
3627 int camera_dispatcher_attr_enable_video_stabilization(muse_module_h module)
3628 {
3629         int ret = CAMERA_ERROR_NONE;
3630         muse_camera_handle_s *muse_camera = NULL;
3631         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_ENABLE_VIDEO_STABILIZATION;
3632         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3633         int set_enable;
3634
3635         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3636
3637         muse_camera_msg_get(set_enable, muse_core_client_get_msg(module));
3638
3639         LOGD("handle : %p", muse_camera);
3640
3641         ret = legacy_camera_attr_enable_video_stabilization(muse_camera->camera_handle, (bool)set_enable);
3642
3643         LOGD("ret : 0x%x", ret);
3644
3645         muse_camera_msg_return(api, class, ret, module);
3646
3647         return MUSE_CAMERA_ERROR_NONE;
3648 }
3649
3650 int camera_dispatcher_attr_is_enabled_video_stabilization(muse_module_h module)
3651 {
3652         int ret = CAMERA_ERROR_NONE;
3653         muse_camera_handle_s *muse_camera = NULL;
3654         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_ENABLED_VIDEO_STABILIZATION;
3655         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3656         bool get_enabled = false;
3657
3658         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3659
3660         LOGD("handle : %p", muse_camera);
3661
3662         ret = legacy_camera_attr_is_enabled_video_stabilization(muse_camera->camera_handle, &get_enabled);
3663         if (ret == CAMERA_ERROR_NONE) {
3664                 muse_camera_msg_return1(api, class, ret, module, INT, get_enabled);
3665         } else {
3666                 muse_camera_msg_return(api, class, ret, module);
3667         }
3668
3669         return MUSE_CAMERA_ERROR_NONE;
3670 }
3671
3672 int camera_dispatcher_attr_is_supported_video_stabilization(muse_module_h module)
3673 {
3674         int ret = CAMERA_ERROR_NONE;
3675         muse_camera_handle_s *muse_camera = NULL;
3676         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_SUPPORTED_VIDEO_STABILIZATION;
3677         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3678
3679         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3680
3681         LOGD("handle : %p", muse_camera);
3682
3683         ret = legacy_camera_attr_is_supported_video_stabilization(muse_camera->camera_handle);
3684
3685         LOGD("ret : 0x%x", ret);
3686
3687         muse_camera_msg_return(api, class, ret, module);
3688
3689         return MUSE_CAMERA_ERROR_NONE;
3690 }
3691
3692 int camera_dispatcher_attr_enable_auto_contrast(muse_module_h module)
3693 {
3694         int ret = CAMERA_ERROR_NONE;
3695         muse_camera_handle_s *muse_camera = NULL;
3696         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_ENABLE_AUTO_CONTRAST;
3697         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3698         int set_enable;
3699
3700         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3701
3702         muse_camera_msg_get(set_enable, muse_core_client_get_msg(module));
3703
3704         LOGD("handle : %p", muse_camera);
3705
3706         ret = legacy_camera_attr_enable_auto_contrast(muse_camera->camera_handle, (bool)set_enable);
3707
3708         LOGD("ret : 0x%x", ret);
3709
3710         muse_camera_msg_return(api, class, ret, module);
3711
3712         return MUSE_CAMERA_ERROR_NONE;
3713 }
3714
3715 int camera_dispatcher_attr_is_enabled_auto_contrast(muse_module_h module)
3716 {
3717         int ret = CAMERA_ERROR_NONE;
3718         muse_camera_handle_s *muse_camera = NULL;
3719         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_ENABLED_AUTO_CONTRAST;
3720         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3721         bool get_enabled = false;
3722
3723         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3724
3725         LOGD("handle : %p", muse_camera);
3726
3727         ret = legacy_camera_attr_is_enabled_auto_contrast(muse_camera->camera_handle, &get_enabled);
3728         if (ret == CAMERA_ERROR_NONE) {
3729                 muse_camera_msg_return1(api, class, ret, module, INT, get_enabled);
3730         } else {
3731                 muse_camera_msg_return(api, class, ret, module);
3732         }
3733
3734         return MUSE_CAMERA_ERROR_NONE;
3735 }
3736
3737 int camera_dispatcher_attr_is_supported_auto_contrast(muse_module_h module)
3738 {
3739         int ret = CAMERA_ERROR_NONE;
3740         muse_camera_handle_s *muse_camera = NULL;
3741         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_IS_SUPPORTED_AUTO_CONTRAST;
3742         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3743
3744         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3745
3746         LOGD("handle : %p", muse_camera);
3747
3748         ret = legacy_camera_attr_is_supported_auto_contrast(muse_camera->camera_handle);
3749
3750         LOGD("ret : 0x%x", ret);
3751
3752         muse_camera_msg_return(api, class, ret, module);
3753
3754         return MUSE_CAMERA_ERROR_NONE;
3755 }
3756
3757 int camera_dispatcher_attr_disable_shutter_sound(muse_module_h module)
3758 {
3759         int ret = CAMERA_ERROR_NONE;
3760         muse_camera_handle_s *muse_camera = NULL;
3761         muse_camera_api_e api = MUSE_CAMERA_API_ATTR_DISABLE_SHUTTER_SOUND;
3762         muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
3763         int set_disable;
3764
3765         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3766
3767         muse_camera_msg_get(set_disable, muse_core_client_get_msg(module));
3768
3769         LOGD("handle : %p", muse_camera);
3770
3771         ret = legacy_camera_attr_disable_shutter_sound(muse_camera->camera_handle, (bool)set_disable);
3772
3773         LOGD("ret : 0x%x", ret);
3774
3775         muse_camera_msg_return(api, class, ret, module);
3776
3777         return MUSE_CAMERA_ERROR_NONE;
3778 }
3779
3780 int camera_dispatcher_return_buffer(muse_module_h module)
3781 {
3782         int tbm_key = 0;
3783         muse_camera_handle_s *muse_camera = NULL;
3784
3785         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3786
3787         muse_camera_msg_get(tbm_key, muse_core_client_get_msg(module));
3788
3789         /*LOGD("handle : %p, key : %d", muse_camera, tbm_key);*/
3790
3791         if (!_camera_remove_export_data(module, tbm_key, FALSE)) {
3792                 LOGE("remove export data failed : key %d", tbm_key);
3793         }
3794
3795         return MUSE_CAMERA_ERROR_NONE;
3796 }
3797
3798 int camera_dispatcher_preview_cb_return(muse_module_h module)
3799 {
3800         muse_camera_handle_s *muse_camera = NULL;
3801
3802         muse_camera = (muse_camera_handle_s *)muse_core_ipc_get_handle(module);
3803
3804         if (muse_camera == NULL) {
3805                 LOGE("NULL handle");
3806                 return MUSE_CAMERA_ERROR_NONE;
3807         }
3808
3809         /*LOGD("ENTER");*/
3810
3811         g_mutex_lock(&muse_camera->preview_cb_lock);
3812         g_cond_signal(&muse_camera->preview_cb_cond);
3813         /*LOGD("send signal for preview callback");*/
3814         g_mutex_unlock(&muse_camera->preview_cb_lock);
3815
3816         /*LOGD("DONE");*/
3817
3818         return MUSE_CAMERA_ERROR_NONE;
3819 }
3820
3821
3822 int (*dispatcher[MUSE_CAMERA_API_MAX]) (muse_module_h module) = {
3823         camera_dispatcher_create, /* MUSE_CAMERA_API_CREATE */
3824         camera_dispatcher_destroy, /* MUSE_CAMERA_API_DESTROY */
3825         camera_dispatcher_start_preview, /* MUSE_CAMERA_START_PREVIEW */
3826         camera_dispatcher_stop_preview, /* MUSE_CAMERA_API_START_PREVIEW */
3827         camera_dispatcher_start_capture, /* MUSE_CAMERA_START_CAPTURE */
3828         camera_dispatcher_is_supported_continuous_capture, /* MUSE_CAMERA_API_SUPPORT_CONTINUOUS_CAPTURE */
3829         camera_dispatcher_start_continuous_capture, /* MUSE_CAMERA_API_START_CONTINUOUS_CAPTURE, */
3830         camera_dispatcher_stop_continuous_capture, /* MUSE_CAMERA_API_STOP_CONTINUOUS_CAPTURE, */
3831         camera_dispatcher_is_supported_face_detection, /* MUSE_CAMERA_API_SUPPORT_FACE_DETECTION, */
3832         camera_dispatcher_is_supported_zero_shutter_lag, /* MUSE_CAMERA_API_SUPPORT_ZERO_SHUTTER_LAG, */
3833         camera_dispatcher_is_supported_media_packet_preview_cb, /* MUSE_CAMERA_API_SUPPORT_MEDIA_PACKET_PREVIEW_CB, */
3834         camera_dispatcher_get_device_count, /* MUSE_CAMERA_API_GET_DEVICE_COUNT, */
3835         camera_dispatcher_start_face_detection, /* MUSE_CAMERA_API_START_FACE_DETECTION, */
3836         camera_dispatcher_stop_face_detection, /* MUSE_CAMERA_API_STOP_FACE_DETECTION, */
3837         camera_dispatcher_get_state, /* MUSE_CAMERA_API_GET_STATE, */
3838         camera_dispatcher_start_focusing, /* MUSE_CAMERA_API_START_FOCUSING, */
3839         camera_dispatcher_stop_focusing, /* MUSE_CAMERA_API_CANCEL_FOCUSING, */
3840         camera_dispatcher_set_display, /* MUSE_CAMERA_API_SET_DISPLAY, */
3841         camera_dispatcher_set_preview_resolution, /* MUSE_CAMERA_API_SET_PREVIEW_RESOLUTION, */
3842         camera_dispatcher_set_capture_resolution, /* MUSE_CAMERA_API_SET_CAPTURE_RESOLUTION, */
3843         camera_dispatcher_set_capture_format, /* MUSE_CAMERA_API_SET_CAPTURE_FORMAT, */
3844         camera_dispatcher_set_preview_format, /* MUSE_CAMERA_API_SET_PREVIEW_FORMAT, */
3845         camera_dispatcher_get_preview_resolution, /* MUSE_CAMERA_API_GET_PREVIEW_RESOLUTION, */
3846         camera_dispatcher_set_display_rotation, /* MUSE_CAMERA_API_SET_DISPLAY_ROTATION, */
3847         camera_dispatcher_get_display_rotation, /* MUSE_CAMERA_API_GET_DISPLAY_ROTATION, */
3848         camera_dispatcher_set_display_flip, /* MUSE_CAMERA_API_SET_DISPLAY_FLIP, */
3849         camera_dispatcher_get_display_flip, /* MUSE_CAMERA_API_GET_DISPLAY_FLIP, */
3850         camera_dispatcher_set_display_visible, /* MUSE_CAMERA_API_SET_DISPLAY_VISIBLE, */
3851         camera_dispatcher_is_display_visible, /* MUSE_CAMERA_API_IS_DISPLAY_VISIBLE, */
3852         camera_dispatcher_set_display_mode, /* MUSE_CAMERA_API_SET_DISPLAY_MODE, */
3853         camera_dispatcher_get_display_mode, /* MUSE_CAMERA_API_GET_DISPLAY_MODE, */
3854         camera_dispatcher_get_capture_resolution, /* MUSE_CAMERA_API_GET_CAPTURE_RESOLUTION, */
3855         camera_dispatcher_get_capture_format, /* MUSE_CAMERA_API_GET_CAPTURE_FORMAT, */
3856         camera_dispatcher_get_preview_format, /* MUSE_CAMERA_API_GET_PREVIEW_FORMAT, */
3857         camera_dispatcher_get_facing_direction, /* MUSE_CAMERA_API_GET_FACING_DIRECTION, */
3858         camera_dispatcher_set_preview_cb, /* MUSE_CAMERA_API_SET_PREVIEW_CB, */
3859         camera_dispatcher_unset_preview_cb, /* MUSE_CAMERA_API_UNSET_PREVIEW_CB, */
3860         camera_dispatcher_set_media_packet_preview_cb, /* MUSE_CAMERA_API_SET_MEDIA_PACKET_PREVIEW_CB, */
3861         camera_dispatcher_unset_media_packet_preview_cb, /* MUSE_CAMERA_API_UNSET_MEDIA_PACKET_PREVIEW_CB, */
3862         camera_dispatcher_set_state_changed_cb, /* MUSE_CAMERA_API_SET_STATE_CHANGED_CB, */
3863         camera_dispatcher_unset_state_changed_cb, /* MUSE_CAMERA_API_UNSET_STATE_CHANGED_CB, */
3864         camera_dispatcher_set_interrupted_cb, /* MUSE_CAMERA_API_SET_INTERRUPTED_CB, */
3865         camera_dispatcher_unset_interrupted_cb, /* MUSE_CAMERA_API_UNSET_INTERRUPTED_CB, */
3866         camera_dispatcher_set_focus_changed_cb, /* MUSE_CAMERA_API_SET_FOCUS_CHANGED_CB, */
3867         camera_dispatcher_unset_focus_changed_cb, /* MUSE_CAMERA_API_UNSET_FOCUS_CHANGED_CB, */
3868         camera_dispatcher_set_error_cb, /* MUSE_CAMERA_API_SET_ERROR_CB, */
3869         camera_dispatcher_unset_error_cb, /* MUSE_CAMERA_API_UNSET_ERROR_CB, */
3870         camera_dispatcher_foreach_supported_preview_resolution, /* MUSE_CAMERA_API_SET_FOREACH_SUPPORTED_PREVIEW_RESOLUTION, */
3871         camera_dispatcher_foreach_supported_capture_resolution, /* MUSE_CAMERA_API_SET_FOREACH_SUPPORTED_CAPTURE_RESOLUTION, */
3872         camera_dispatcher_foreach_supported_capture_format, /* MUSE_CAMERA_API_SET_FOREACH_SUPPORTED_CAPTURE_FORMAT, */
3873         camera_dispatcher_foreach_supported_preview_format, /* MUSE_CAMERA_API_SET_FOREACH_SUPPORTED_PREVIEW_FORMAT, */
3874         camera_dispatcher_get_recommended_preview_resolution, /* MUSE_CAMERA_API_GET_RECOMMENDED_PREVIEW_RESOLUTION, */
3875         camera_dispatcher_attr_get_lens_orientation, /* MUSE_CAMERA_API_ATTR_GET_LENS_ORIENTATION, */
3876         camera_dispatcher_attr_set_theater_mode, /* MUSE_CAMERA_API_ATTR_SET_THEATER_MODE, */
3877         camera_dispatcher_attr_get_theater_mode, /* MUSE_CAMERA_API_ATTR_GET_THEATER_MODE, */
3878         camera_dispatcher_attr_foreach_supported_theater_mode, /* MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_THEATER_MODE, */
3879         camera_dispatcher_attr_set_preview_fps, /* MUSE_CAMERA_API_ATTR_SET_PREVIEW_FPS, */
3880         camera_dispatcher_attr_set_image_quality, /* MUSE_CAMERA_API_ATTR_SET_IMAGE_QUALITY, */
3881         camera_dispatcher_attr_get_preview_fps, /* MUSE_CAMERA_API_ATTR_GET_PREVIEW_FPS, */
3882         camera_dispatcher_attr_get_image_quality, /* MUSE_CAMERA_API_ATTR_GET_IMAGE_QUALITY, */
3883         camera_dispatcher_attr_set_zoom, /* MUSE_CAMERA_API_ATTR_SET_ZOOM, */
3884         camera_dispatcher_attr_set_af_mode, /* MUSE_CAMERA_API_ATTR_SET_AF_MODE, */
3885         camera_dispatcher_attr_set_af_area, /* MUSE_CAMERA_API_ATTR_SET_AF_AREA, */
3886         camera_dispatcher_attr_clear_af_area, /* MUSE_CAMERA_API_ATTR_CLEAR_AF_AREA, */
3887         camera_dispatcher_attr_set_exposure_mode, /* MUSE_CAMERA_API_ATTR_SET_EXPOSURE_MODE, */
3888         camera_dispatcher_attr_set_exposure, /* MUSE_CAMERA_API_ATTR_SET_EXPOSURE, */
3889         camera_dispatcher_attr_set_iso, /* MUSE_CAMERA_API_ATTR_SET_ISO, */
3890         camera_dispatcher_attr_set_brightness, /* MUSE_CAMERA_API_ATTR_SET_BRIGHTNESS, */
3891         camera_dispatcher_attr_set_contrast, /* MUSE_CAMERA_API_ATTR_SET_CONTRAST, */
3892         camera_dispatcher_attr_set_whitebalance, /* MUSE_CAMERA_API_ATTR_SET_WHITEBALANCE, */
3893         camera_dispatcher_attr_set_effect, /* MUSE_CAMERA_API_ATTR_SET_EFFECT, */
3894         camera_dispatcher_attr_set_scene_mode, /* MUSE_CAMERA_API_ATTR_SET_SCENE_MODE, */
3895         camera_dispatcher_attr_enable_tag, /* MUSE_CAMERA_API_ATTR_ENABLE_TAG, */
3896         camera_dispatcher_attr_set_tag_image_description, /* MUSE_CAMERA_API_ATTR_SET_TAG_IMAGE_DESCRIPTION, */
3897         camera_dispatcher_attr_set_tag_orientation, /* MUSE_CAMERA_API_ATTR_SET_TAG_ORIENTATION, */
3898         camera_dispatcher_attr_set_tag_software, /* MUSE_CAMERA_API_ATTR_SET_TAG_SOFTWARE, */
3899         camera_dispatcher_attr_set_geotag, /* MUSE_CAMERA_API_ATTR_SET_GEOTAG, */
3900         camera_dispatcher_attr_remove_geotag, /* MUSE_CAMERA_API_ATTR_REMOVE_GEOTAG, */
3901         camera_dispatcher_attr_set_flash_mode, /* MUSE_CAMERA_API_ATTR_SET_FLASH_MODE, */
3902         camera_dispatcher_attr_get_zoom, /* MUSE_CAMERA_API_ATTR_GET_ZOOM, */
3903         camera_dispatcher_attr_get_zoom_range, /* MUSE_CAMERA_API_ATTR_GET_ZOOM_RANGE, */
3904         camera_dispatcher_attr_get_af_mode, /* MUSE_CAMERA_API_ATTR_GET_AF_MODE, */
3905         camera_dispatcher_attr_get_exposure_mode, /* MUSE_CAMERA_API_ATTR_GET_EXPOSURE_MODE, */
3906         camera_dispatcher_attr_get_exposure, /* MUSE_CAMERA_API_ATTR_GET_EXPOSURE, */
3907         camera_dispatcher_attr_get_exposure_range, /* MUSE_CAMERA_API_ATTR_GET_EXPOSURE_RANGE, */
3908         camera_dispatcher_attr_get_iso, /* MUSE_CAMERA_API_ATTR_GET_ISO, */
3909         camera_dispatcher_attr_get_brightness, /* MUSE_CAMERA_API_ATTR_GET_BRIGHTNESS, */
3910         camera_dispatcher_attr_get_brightness_range, /* MUSE_CAMERA_API_ATTR_GET_BRIGHTNESS_RANGE, */
3911         camera_dispatcher_attr_get_contrast, /* MUSE_CAMERA_API_ATTR_GET_CONTRAST, */
3912         camera_dispatcher_attr_get_contrast_range, /* MUSE_CAMERA_API_ATTR_GET_CONTRAST_RANGE, */
3913         camera_dispatcher_attr_get_whitebalance, /* MUSE_CAMERA_API_ATTR_GET_WHITEBALANCE, */
3914         camera_dispatcher_attr_get_effect, /* MUSE_CAMERA_API_ATTR_GET_EFFECT, */
3915         camera_dispatcher_attr_get_scene_mode, /* MUSE_CAMERA_API_ATTR_GET_SCENE_MODE, */
3916         camera_dispatcher_attr_is_enabled_tag, /* MUSE_CAMERA_API_ATTR_IS_ENABLED_TAG, */
3917         camera_dispatcher_attr_get_tag_image_description, /* MUSE_CAMERA_API_ATTR_GET_TAG_IMAGE_DESCRIPTION, */
3918         camera_dispatcher_attr_get_tag_orientation, /* MUSE_CAMERA_API_ATTR_GET_TAG_ORIENTATION, */
3919         camera_dispatcher_attr_get_tag_software, /* MUSE_CAMERA_API_ATTR_GET_TAG_SOFTWARE, */
3920         camera_dispatcher_attr_get_geotag, /* MUSE_CAMERA_API_ATTR_GET_GEOTAG, */
3921         camera_dispatcher_attr_get_flash_mode, /* MUSE_CAMERA_API_ATTR_GET_FLASH_MODE, */
3922         camera_dispatcher_attr_foreach_supported_af_mode, /* MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_AF_MODE, */
3923         camera_dispatcher_attr_foreach_supported_exposure_mode, /* MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_EXPOSURE_MODE, */
3924         camera_dispatcher_attr_foreach_supported_iso, /* MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_ISO, */
3925         camera_dispatcher_attr_foreach_supported_whitebalance, /* MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_WHITEBALANCE, */
3926         camera_dispatcher_attr_foreach_supported_effect, /* MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_EFFECT, */
3927         camera_dispatcher_attr_foreach_supported_scene_mode, /* MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_SCENE_MODE, */
3928         camera_dispatcher_attr_foreach_supported_flash_mode, /* MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_FLASH_MODE, */
3929         camera_dispatcher_attr_foreach_supported_fps, /* MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_FPS, */
3930         camera_dispatcher_attr_foreach_supported_fps_by_resolution, /* MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_FPS_BY_RESOLUTION, */
3931         camera_dispatcher_attr_foreach_supported_stream_flip, /* MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_STREAM_FLIP, */
3932         camera_dispatcher_attr_foreach_supported_stream_rotation, /* MUSE_CAMERA_API_ATTR_FOREACH_SUPPORTED_STREAM_ROTATION, */
3933         camera_dispatcher_attr_set_stream_rotation, /* MUSE_CAMERA_API_ATTR_SET_STREAM_ROTATION, */
3934         camera_dispatcher_attr_get_stream_rotation, /* MUSE_CAMERA_API_ATTR_GET_STREAM_ROTATION, */
3935         camera_dispatcher_attr_set_stream_flip, /* MUSE_CAMERA_API_ATTR_SET_STREAM_FLIP, */
3936         camera_dispatcher_attr_get_stream_flip, /* MUSE_CAMERA_API_ATTR_GET_STREAM_FLIP, */
3937         camera_dispatcher_attr_set_hdr_mode, /* MUSE_CAMERA_API_ATTR_SET_HDR_MODE, */
3938         camera_dispatcher_attr_get_hdr_mode, /* MUSE_CAMERA_API_ATTR_GET_HDR_MODE, */
3939         camera_dispatcher_attr_is_supported_hdr_capture, /* MUSE_CAMERA_API_ATTR_IS_SUPPORTED_HDR_CAPTURE, */
3940         camera_dispatcher_attr_set_hdr_capture_progress_cb, /* MUSE_CAMERA_API_ATTR_SET_HDR_CAPTURE_PROGRESS_CB, */
3941         camera_dispatcher_attr_unset_hdr_capture_progress_cb, /* MUSE_CAMERA_API_ATTR_UNSET_HDR_CAPTURE_PROGRESS_CB, */
3942         camera_dispatcher_attr_enable_anti_shake, /* MUSE_CAMERA_API_ATTR_ENABLE_ANTI_SHAKE, */
3943         camera_dispatcher_attr_is_enabled_anti_shake, /* MUSE_CAMERA_API_ATTR_IS_ENABLED_ANTI_SHAKE, */
3944         camera_dispatcher_attr_is_supported_anti_shake, /* MUSE_CAMERA_API_ATTR_IS_SUPPORTED_ANTI_SHAKE, */
3945         camera_dispatcher_attr_enable_video_stabilization, /* MUSE_CAMERA_API_ATTR_ENABLE_VIDEO_STABILIZATION, */
3946         camera_dispatcher_attr_is_enabled_video_stabilization, /* MUSE_CAMERA_API_ATTR_IS_ENABLED_VIDEO_STABILIZATION, */
3947         camera_dispatcher_attr_is_supported_video_stabilization, /* MUSE_CAMERA_API_ATTR_IS_SUPPORTED_VIDEO_STABILIZATION, */
3948         camera_dispatcher_attr_enable_auto_contrast, /* MUSE_CAMERA_API_ATTR_ENABLE_AUTO_CONTRAST, */
3949         camera_dispatcher_attr_is_enabled_auto_contrast, /* MUSE_CAMERA_API_ATTR_IS_ENABLED_AUTO_CONTRAST, */
3950         camera_dispatcher_attr_is_supported_auto_contrast, /* MUSE_CAMERA_API_ATTR_IS_SUPPORTED_AUTO_CONTRAST, */
3951         camera_dispatcher_attr_disable_shutter_sound, /* MUSE_CAMERA_API_ATTR_DISABLE_SHUTTER_SOUND, */
3952         camera_dispatcher_return_buffer, /* MUSE_CAMERA_API_RETURN_BUFFER, */
3953         camera_dispatcher_preview_cb_return, /* MUSE_CAMERA_API_PREVIEW_CB_RETURN, */
3954 };