muse/src/muse_recorder_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 "muse_recorder.h"
  25 #include "muse_recorder_msg.h"
  26 #include "legacy_recorder.h"
  27 #include <muse_core.h>
  28 #include <muse_core_ipc.h>
  29 #include <muse_core_security.h>
  30 #include <muse_camera.h>
  31 #include <mm_types.h>
  32 #include <dlog.h>
  33
  34 #ifdef LOG_TAG
  35 #undef LOG_TAG
  36 #endif
  37 #define LOG_TAG "MMSVC_RECORDER"
  38
  39 #define RECORDER_PRIVILEGE_NAME "http://tizen.org/privilege/recorder"
  40
  41
  42 void _recorder_disp_recording_limit_reached_cb(recorder_recording_limit_type_e type, void *user_data)
  43 {
  44         muse_module_h module = (muse_module_h)user_data;
  45
  46         LOGD("Enter");
  47         int cb_type = (int)type;
  48         muse_recorder_msg_event1(MUSE_RECORDER_CB_EVENT,
  49                                                                 MUSE_RECORDER_EVENT_TYPE_RECORDING_LIMITED,
  50                                                                 module,
  51                                                                 INT, cb_type);
  52         return;
  53 }
  54
  55 void _recorder_disp_recording_status_cb(unsigned long long elapsed_time, unsigned long long file_size, void *user_data)
  56 {
  57         muse_module_h module = (muse_module_h)user_data;
  58
  59         LOGD("Enter");
  60         double cb_elapsed_time = elapsed_time;
  61         double cb_file_size = file_size;
  62         muse_recorder_msg_event2(MUSE_RECORDER_CB_EVENT,
  63                                                                 MUSE_RECORDER_EVENT_TYPE_RECORDING_STATUS,
  64                                                                 module,
  65                                                                 DOUBLE, cb_elapsed_time,
  66                                                                 DOUBLE, cb_file_size);
  67         return;
  68 }
  69
  70 void _recorder_disp_state_changed_cb(recorder_state_e previous , recorder_state_e current , bool by_policy, void *user_data)
  71 {
  72         muse_module_h module = (muse_module_h)user_data;
  73
  74         LOGD("Enter");
  75         int cb_previous = (int)previous;
  76         int cb_current = (int)current;
  77         int cb_by_policy = (int)by_policy;
  78         muse_recorder_msg_event3(MUSE_RECORDER_CB_EVENT,
  79                                                                 MUSE_RECORDER_EVENT_TYPE_STATE_CHANGE,
  80                                                                 module,
  81                                                                 INT, cb_previous,
  82                                                                 INT, cb_current,
  83                                                                 INT, cb_by_policy);
  84         return;
  85 }
  86
  87 void _recorder_disp_interrupted_cb(recorder_policy_e policy, recorder_state_e previous, recorder_state_e current, void *user_data)
  88 {
  89         muse_module_h module = (muse_module_h)user_data;
  90
  91         LOGD("Enter");
  92         int cb_policy = (int)policy;
  93         int cb_previous = (int)previous;
  94         int cb_current = (int)current;
  95         muse_recorder_msg_event3(MUSE_RECORDER_CB_EVENT,
  96                                                                 MUSE_RECORDER_EVENT_TYPE_INTERRUPTED,
  97                                                                 module,
  98                                                                 INT, cb_policy,
  99                                                                 INT, cb_previous,
 100                                                                 INT, cb_current);
 101         return;
 102 }
 103
 104 void _recorder_disp_error_cb(recorder_error_e error, recorder_state_e current_state, void *user_data)
 105 {
 106         muse_module_h module = (muse_module_h)user_data;
 107         int cb_error = (int)error;
 108         int cb_current_state = (int)current_state;
 109         LOGD("Enter");
 110
 111         muse_recorder_msg_event2(MUSE_RECORDER_CB_EVENT,
 112                                                             MUSE_RECORDER_EVENT_TYPE_INTERRUPTED,
 113                                                             module,
 114                                                             INT, cb_error,
 115                                                             INT, cb_current_state);
 116         return;
 117 }
 118
 119 void _recorder_disp_audio_stream_cb(void* stream, int size, audio_sample_type_e format, int channel, unsigned int timestamp, void *user_data)
 120 {
 121         muse_module_h module = (muse_module_h)user_data;
 122         int cb_size = size;
 123         int cb_format = (int)format;
 124         int cb_channel = channel;
 125         int cb_timestamp = timestamp;
 126         muse_recorder_transport_info_s transport_info;
 127         muse_recorder_info_s *recorder_data;
 128         int tKey = 0;
 129         LOGD("Enter");
 130
 131         /* Initial TBM setting */
 132         transport_info.data_size = size;
 133         recorder_data = (muse_recorder_info_s *)muse_core_client_get_cust_data(module);
 134         transport_info.bufmgr = recorder_data->bufmgr;
 135
 136         if (muse_recorder_ipc_make_tbm(&transport_info) == FALSE) {
 137                 LOGE("TBM Init failed");
 138                 return;
 139         }
 140         LOGD("bohandle_ptr : 0x%x, export_bo : %d, tSize : %d", transport_info.bo_handle.ptr, transport_info.bo, transport_info.data_size);
 141
 142         memcpy(transport_info.bo_handle.ptr, stream, size);
 143         tKey = muse_recorder_ipc_export_tbm(transport_info);
 144
 145         if(tKey == 0) {
 146                 LOGE("Create key_info ERROR!!");
 147                 muse_recorder_ipc_unref_tbm(&transport_info);
 148                 return;
 149         }
 150
 151         muse_recorder_msg_event5(MUSE_RECORDER_CB_EVENT,
 152                                                             MUSE_RECORDER_EVENT_TYPE_AUDIO_STREAM,
 153                                                             module,
 154                                                             INT, cb_size,
 155                                                             INT, cb_format,
 156                                                             INT, cb_channel,
 157                                                             INT, cb_timestamp,
 158                                                             INT, tKey);
 159
 160         muse_recorder_ipc_unref_tbm(&transport_info);
 161         return;
 162 }
 163
 164 void _recorder_disp_foreach_supported_video_resolution_cb(int width, int height, void *user_data)
 165 {
 166         muse_module_h module = (muse_module_h)user_data;
 167         LOGD("Enter");
 168
 169         muse_recorder_msg_event2(MUSE_RECORDER_CB_EVENT,
 170                                                             MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_RESOLUTION,
 171                                                             module,
 172                                                             INT, width,
 173                                                             INT, height);
 174         return;
 175 }
 176
 177 void _recorder_disp_foreach_supported_file_format_cb(recorder_file_format_e format, void *user_data)
 178 {
 179         muse_module_h module = (muse_module_h)user_data;
 180         int cb_format = (int)format;
 181         LOGD("Enter");
 182
 183         muse_recorder_msg_event1(MUSE_RECORDER_CB_EVENT,
 184                                                             MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_FILE_FORMAT,
 185                                                             module,
 186                                                             INT, cb_format);
 187         return;
 188 }
 189
 190 void _recorder_disp_foreach_supported_audio_encoder_cb(recorder_audio_codec_e codec, void *user_data)
 191 {
 192         muse_module_h module = (muse_module_h)user_data;
 193         int cb_codec = (int)codec;
 194         LOGD("Enter");
 195
 196         muse_recorder_msg_event1(MUSE_RECORDER_CB_EVENT,
 197                                                             MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_AUDIO_ENCODER,
 198                                                             module,
 199                                                             INT, cb_codec);
 200         return;
 201 }
 202
 203 void _recorder_disp_foreach_supported_video_encoder_cb(recorder_video_codec_e codec, void *user_data)
 204 {
 205         muse_module_h module = (muse_module_h)user_data;
 206         int cb_codec = (int)codec;
 207         LOGD("Enter");
 208
 209         muse_recorder_msg_event1(MUSE_RECORDER_CB_EVENT,
 210                                                             MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_ENCODER,
 211                                                             module,
 212                                                             INT, cb_codec);
 213         return;
 214 }
 215
 216 int recorder_dispatcher_create(muse_module_h module)
 217 {
 218         int ret = RECORDER_ERROR_NONE;
 219         muse_recorder_api_e api = MUSE_RECORDER_API_CREATE;
 220         recorder_h recorder;
 221         intptr_t camera_handle;
 222         muse_camera_handle_s *muse_camera = NULL;
 223         muse_recorder_info_s *recorder_data;
 224         tbm_bufmgr bufmgr;
 225         int recorder_type;
 226         int client_fd = -1;
 227         intptr_t handle;
 228
 229         LOGD("Enter");
 230
 231         muse_recorder_msg_get(recorder_type, muse_core_client_get_msg(module));
 232
 233         /* privilege check */
 234         client_fd = muse_core_client_get_msg_fd(module);
 235         if (!muse_core_security_check_cynara(client_fd, RECORDER_PRIVILEGE_NAME)) {
 236                 LOGE("security check failed");
 237                 ret = RECORDER_ERROR_PERMISSION_DENIED;
 238                 muse_recorder_msg_return(api, ret, module);
 239                 return MUSE_RECORDER_ERROR_NONE;
 240         }
 241
 242         if (recorder_type == MUSE_RECORDER_TYPE_VIDEO) {
 243                 muse_recorder_msg_get_pointer(camera_handle, muse_core_client_get_msg(module));
 244                 if (camera_handle == NULL) {
 245                         LOGE("NULL handle");
 246                         ret = RECORDER_ERROR_INVALID_PARAMETER;
 247                         muse_recorder_msg_return(api, ret, module);
 248                         return MUSE_RECORDER_ERROR_NONE;
 249                 }
 250
 251                 muse_camera = (muse_recorder_info_s *)camera_handle;
 252
 253                 LOGD("video type, camera handle : %p", muse_camera->camera_handle);
 254
 255                 ret = legacy_recorder_create_videorecorder(muse_camera->camera_handle, &recorder);
 256         } else if (recorder_type == MUSE_RECORDER_TYPE_AUDIO) {
 257                 LOGD("audio type");
 258                 ret = legacy_recorder_create_audiorecorder(&recorder);
 259         }
 260
 261         if (ret == RECORDER_ERROR_NONE) {
 262                 handle = (intptr_t)recorder;
 263                 LOGD("recorder handle : 0x%x, api : %d, module", handle, api, module);
 264                 muse_core_ipc_set_handle(module, handle);
 265
 266                 recorder_data = (muse_recorder_info_s *)g_new(muse_recorder_info_s, sizeof(muse_recorder_info_s));
 267                 muse_core_ipc_get_bufmgr(&bufmgr);
 268                 LOGD("bufmgr: 0x%x", bufmgr);
 269                 if (bufmgr != NULL) {
 270                         recorder_data->bufmgr = bufmgr;
 271                         muse_core_client_set_cust_data(module, (void *)recorder_data);
 272                 } else {
 273                         LOGE("TBM bufmgr is NULL => check the legacy_core.");
 274                 }
 275                 muse_recorder_msg_return1(api, ret, module, POINTER, handle);
 276         } else {
 277                 muse_recorder_msg_return(api, ret, module);
 278         }
 279
 280         return MUSE_RECORDER_ERROR_NONE;
 281 }
 282
 283 int recorder_dispatcher_destroy(muse_module_h module)
 284 {
 285         int ret = RECORDER_ERROR_NONE;
 286         intptr_t handle;
 287         muse_recorder_api_e api = MUSE_RECORDER_API_DESTROY;
 288         muse_recorder_info_s *recorder_data;
 289         handle = muse_core_ipc_get_handle(module);
 290         ret = legacy_recorder_destroy((recorder_h)handle);
 291         LOGD("handle : 0x%x", handle);
 292         muse_recorder_msg_return(api, ret, module);
 293
 294         recorder_data = (muse_recorder_info_s *)muse_core_client_get_cust_data(module);
 295         if (recorder_data != NULL) {
 296                 g_free(recorder_data);
 297                 recorder_data = NULL;
 298         }
 299
 300         return MUSE_RECORDER_ERROR_NONE;
 301 }
 302
 303 int recorder_dispatcher_get_state(muse_module_h module)
 304 {
 305         int ret = RECORDER_ERROR_NONE;
 306         muse_recorder_api_e api = MUSE_RECORDER_API_GET_STATE;
 307         intptr_t handle;
 308         recorder_state_e state;
 309         int get_state;
 310
 311         handle = muse_core_ipc_get_handle(module);
 312         ret = legacy_recorder_get_state((recorder_h)handle, &state);
 313         get_state = (int)state;
 314         LOGD("handle : 0x%x", handle);
 315         muse_recorder_msg_return1(api, ret, module, INT, get_state);
 316
 317         return MUSE_RECORDER_ERROR_NONE;
 318 }
 319
 320 int recorder_dispatcher_prepare(muse_module_h module)
 321 {
 322         int ret = RECORDER_ERROR_NONE;
 323         intptr_t handle;
 324         muse_recorder_api_e api = MUSE_RECORDER_API_PREPARE;
 325         handle = muse_core_ipc_get_handle(module);
 326         ret = legacy_recorder_prepare((recorder_h)handle);
 327         LOGD("handle : 0x%x", handle);
 328         muse_recorder_msg_return(api, ret, module);
 329
 330         return MUSE_RECORDER_ERROR_NONE;
 331 }
 332
 333 int recorder_dispatcher_unprepare(muse_module_h module)
 334 {
 335         int ret = RECORDER_ERROR_NONE;
 336         intptr_t handle;
 337         muse_recorder_api_e api = MUSE_RECORDER_API_UNPREPARE;
 338         handle = muse_core_ipc_get_handle(module);
 339         ret = legacy_recorder_unprepare((recorder_h)handle);
 340         LOGD("handle : 0x%x", handle);
 341         muse_recorder_msg_return(api, ret, module);
 342
 343         return MUSE_RECORDER_ERROR_NONE;
 344 }
 345
 346 int recorder_dispatcher_start(muse_module_h module)
 347 {
 348         int ret = RECORDER_ERROR_NONE;
 349         intptr_t handle;
 350         muse_recorder_api_e api = MUSE_RECORDER_API_START;
 351         handle = muse_core_ipc_get_handle(module);
 352         ret = legacy_recorder_start((recorder_h)handle);
 353         LOGD("handle : 0x%x", handle);
 354         muse_recorder_msg_return(api, ret, module);
 355
 356         return MUSE_RECORDER_ERROR_NONE;
 357 }
 358
 359 int recorder_dispatcher_pause(muse_module_h module)
 360 {
 361         int ret = RECORDER_ERROR_NONE;
 362         intptr_t handle;
 363         muse_recorder_api_e api = MUSE_RECORDER_API_PAUSE;
 364         handle = muse_core_ipc_get_handle(module);
 365         ret = legacy_recorder_pause((recorder_h)handle);
 366         LOGD("handle : 0x%x", handle);
 367         muse_recorder_msg_return(api, ret, module);
 368
 369         return MUSE_RECORDER_ERROR_NONE;
 370 }
 371
 372 int recorder_dispatcher_commit(muse_module_h module)
 373 {
 374         int ret = RECORDER_ERROR_NONE;
 375         intptr_t handle;
 376         muse_recorder_api_e api = MUSE_RECORDER_API_COMMIT;
 377         handle = muse_core_ipc_get_handle(module);
 378         ret = legacy_recorder_commit((recorder_h)handle);
 379         LOGD("handle : 0x%x", handle);
 380         muse_recorder_msg_return(api, ret, module);
 381
 382         return MUSE_RECORDER_ERROR_NONE;
 383 }
 384
 385 int recorder_dispatcher_cancel(muse_module_h module)
 386 {
 387         int ret = RECORDER_ERROR_NONE;
 388         intptr_t handle;
 389         muse_recorder_api_e api = MUSE_RECORDER_API_CANCEL;
 390         handle = muse_core_ipc_get_handle(module);
 391         ret = legacy_recorder_cancel((recorder_h)handle);
 392         LOGD("handle : 0x%x", handle);
 393         muse_recorder_msg_return(api, ret, module);
 394
 395         return MUSE_RECORDER_ERROR_NONE;
 396 }
 397
 398 int recorder_dispatcher_set_video_resolution(muse_module_h module)
 399 {
 400         int ret = RECORDER_ERROR_NONE;
 401         intptr_t handle;
 402         int width;
 403         int height;
 404         muse_recorder_api_e api = MUSE_RECORDER_API_SET_VIDEO_RESOLUTION;
 405         handle = muse_core_ipc_get_handle(module);
 406         muse_recorder_msg_get(width, muse_core_client_get_msg(module));
 407         muse_recorder_msg_get(height, muse_core_client_get_msg(module));
 408         ret = legacy_recorder_set_video_resolution((recorder_h)handle, width, height);
 409         LOGD("handle : 0x%x", handle);
 410         muse_recorder_msg_return(api, ret, module);
 411
 412         return MUSE_RECORDER_ERROR_NONE;
 413 }
 414
 415 int recorder_dispatcher_get_video_resolution(muse_module_h module)
 416 {
 417         int ret = RECORDER_ERROR_NONE;
 418         intptr_t handle;
 419         int get_width;
 420         int get_height;
 421         muse_recorder_api_e api = MUSE_RECORDER_API_GET_VIDEO_RESOLUTION;
 422         handle = muse_core_ipc_get_handle(module);
 423         ret = legacy_recorder_get_video_resolution((recorder_h)handle, &get_width, &get_height);
 424         LOGD("handle : 0x%x", handle);
 425         muse_recorder_msg_return2(api,
 426                                                                 ret,
 427                                                                 module,
 428                                                                 INT, get_width,
 429                                                                 INT, get_height);
 430
 431         return MUSE_RECORDER_ERROR_NONE;
 432 }
 433
 434 int recorder_dispatcher_foreach_supported_video_resolution(muse_module_h module)
 435 {
 436         int ret = RECORDER_ERROR_NONE;
 437         intptr_t handle;
 438         muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_VIDEO_RESOLUTION;
 439         handle = muse_core_ipc_get_handle(module);
 440         ret = legacy_recorder_foreach_supported_video_resolution((recorder_h)handle,
 441                                                         (recorder_supported_video_resolution_cb)_recorder_disp_foreach_supported_video_resolution_cb,
 442                                                         (void *)module);
 443         LOGD("handle : 0x%x", handle);
 444         muse_recorder_msg_return(api, ret, module);
 445
 446         return MUSE_RECORDER_ERROR_NONE;
 447 }
 448
 449 int recorder_dispatcher_get_audio_level(muse_module_h module)
 450 {
 451         int ret = RECORDER_ERROR_NONE;
 452         intptr_t handle;
 453         double get_level;
 454         muse_recorder_api_e api = MUSE_RECORDER_API_GET_AUDIO_LEVEL;
 455         handle = muse_core_ipc_get_handle(module);
 456         ret = legacy_recorder_get_audio_level((recorder_h)handle, &get_level);
 457         LOGD("handle : 0x%x", handle);
 458         muse_recorder_msg_return1(api,
 459                                                                 ret,
 460                                                                 module,
 461                                                                 DOUBLE, get_level);
 462
 463         return MUSE_RECORDER_ERROR_NONE;
 464 }
 465
 466 int recorder_dispatcher_set_filename(muse_module_h module)
 467 {
 468         int ret = RECORDER_ERROR_NONE;
 469         intptr_t handle;
 470         char filename[MUSE_RECORDER_MSG_MAX_LENGTH] = {0,};
 471         muse_recorder_api_e api = MUSE_RECORDER_API_SET_FILENAME;
 472         handle = muse_core_ipc_get_handle(module);
 473         muse_recorder_msg_get_string(filename, muse_core_client_get_msg(module));
 474         ret = legacy_recorder_set_filename((recorder_h)handle, filename);
 475         LOGD("handle : 0x%x, filename : %s", handle, filename);
 476         muse_recorder_msg_return(api, ret, module);
 477
 478         return MUSE_RECORDER_ERROR_NONE;
 479 }
 480
 481 int recorder_dispatcher_get_filename(muse_module_h module)
 482 {
 483         int ret = RECORDER_ERROR_NONE;
 484         intptr_t handle;
 485         char *get_filename;
 486         muse_recorder_api_e api = MUSE_RECORDER_API_GET_FILENAME;
 487         handle = muse_core_ipc_get_handle(module);
 488         ret = legacy_recorder_get_filename((recorder_h)handle, &get_filename);
 489         LOGD("handle : 0x%x, filename : %s", handle, get_filename);
 490         muse_recorder_msg_return1(api, ret, module, STRING, get_filename);
 491
 492         return MUSE_RECORDER_ERROR_NONE;
 493 }
 494
 495 int recorder_dispatcher_set_file_format(muse_module_h module)
 496 {
 497         int ret = RECORDER_ERROR_NONE;
 498         intptr_t handle;
 499         int set_format;
 500         muse_recorder_api_e api = MUSE_RECORDER_API_SET_FILE_FORMAT;
 501         handle = muse_core_ipc_get_handle(module);
 502         muse_recorder_msg_get(set_format, muse_core_client_get_msg(module));
 503         ret = legacy_recorder_set_file_format((recorder_h)handle, (recorder_file_format_e)set_format);
 504         LOGD("handle : 0x%x, set_format : %d", handle, set_format);
 505         muse_recorder_msg_return(api, ret, module);
 506
 507         return MUSE_RECORDER_ERROR_NONE;
 508 }
 509
 510 int recorder_dispatcher_get_file_format(muse_module_h module)
 511 {
 512         int ret = RECORDER_ERROR_NONE;
 513         intptr_t handle;
 514         recorder_file_format_e format;
 515         int get_format;
 516         muse_recorder_api_e api = MUSE_RECORDER_API_GET_FILE_FORMAT;
 517         handle = muse_core_ipc_get_handle(module);
 518         ret = legacy_recorder_get_file_format((recorder_h)handle, &format);
 519         get_format = (int)format;
 520         LOGD("handle : 0x%x, get_format : %d", handle, get_format);
 521         muse_recorder_msg_return1(api, ret, module, INT, get_format);
 522
 523         return MUSE_RECORDER_ERROR_NONE;
 524 }
 525
 526 int recorder_dispatcher_set_state_changed_cb(muse_module_h module)
 527 {
 528         int ret = RECORDER_ERROR_NONE;
 529         intptr_t handle;
 530         muse_recorder_api_e api = MUSE_RECORDER_API_SET_STATE_CHANGED_CB;
 531         handle = muse_core_ipc_get_handle(module);
 532         ret = legacy_recorder_set_state_changed_cb((recorder_h)handle,
 533                                                         (recorder_state_changed_cb)_recorder_disp_state_changed_cb,
 534                                                         (void *)module);
 535         LOGD("handle : 0x%x", handle);
 536         muse_recorder_msg_return(api, ret, module);
 537
 538         return MUSE_RECORDER_ERROR_NONE;
 539 }
 540
 541 int recorder_dispatcher_unset_state_changed_cb(muse_module_h module)
 542 {
 543         int ret = RECORDER_ERROR_NONE;
 544         intptr_t handle;
 545         muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_STATE_CHANGED_CB;
 546         handle = muse_core_ipc_get_handle(module);
 547         ret = legacy_recorder_unset_state_changed_cb((recorder_h)handle);
 548         LOGD("handle : 0x%x", handle);
 549         muse_recorder_msg_return(api, ret, module);
 550
 551         return MUSE_RECORDER_ERROR_NONE;
 552 }
 553
 554 int recorder_dispatcher_set_interrupted_cb(muse_module_h module)
 555 {
 556         int ret = RECORDER_ERROR_NONE;
 557         intptr_t handle;
 558         muse_recorder_api_e api = MUSE_RECORDER_API_SET_INTERRUPTED_CB;
 559         handle = muse_core_ipc_get_handle(module);
 560         ret = legacy_recorder_set_interrupted_cb((recorder_h)handle,
 561                                                         (recorder_interrupted_cb)_recorder_disp_interrupted_cb,
 562                                                         (void *)module);
 563         LOGD("handle : 0x%x", handle);
 564         muse_recorder_msg_return(api, ret, module);
 565
 566         return MUSE_RECORDER_ERROR_NONE;
 567 }
 568
 569 int recorder_dispatcher_unset_interrupted_cb(muse_module_h module)
 570 {
 571         int ret = RECORDER_ERROR_NONE;
 572         intptr_t handle;
 573         muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_INTERRUPTED_CB;
 574         handle = muse_core_ipc_get_handle(module);
 575         ret = legacy_recorder_unset_interrupted_cb((recorder_h)handle);
 576         LOGD("handle : 0x%x", handle);
 577         muse_recorder_msg_return(api, ret, module);
 578
 579         return MUSE_RECORDER_ERROR_NONE;
 580 }
 581
 582 int recorder_dispatcher_set_audio_stream_cb(muse_module_h module)
 583 {
 584         int ret = RECORDER_ERROR_NONE;
 585         intptr_t handle;
 586         muse_recorder_api_e api = MUSE_RECORDER_API_SET_AUDIO_STREAM_CB;
 587         handle = muse_core_ipc_get_handle(module);
 588         ret = legacy_recorder_set_audio_stream_cb((recorder_h)handle,
 589                                                         (recorder_audio_stream_cb)_recorder_disp_audio_stream_cb,
 590                                                         (void *)module);
 591         LOGD("handle : 0x%x", handle);
 592         muse_recorder_msg_return(api, ret, module);
 593
 594         return MUSE_RECORDER_ERROR_NONE;
 595 }
 596
 597 int recorder_dispatcher_unset_audio_stream_cb(muse_module_h module)
 598 {
 599         int ret = RECORDER_ERROR_NONE;
 600         intptr_t handle;
 601         muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_AUDIO_STREAM_CB;
 602         handle = muse_core_ipc_get_handle(module);
 603         ret = legacy_recorder_unset_audio_stream_cb((recorder_h)handle);
 604         LOGD("handle : 0x%x", handle);
 605         muse_recorder_msg_return(api, ret, module);
 606
 607         return MUSE_RECORDER_ERROR_NONE;
 608 }
 609
 610 int recorder_dispatcher_set_error_cb(muse_module_h module)
 611 {
 612         int ret = RECORDER_ERROR_NONE;
 613         intptr_t handle;
 614         muse_recorder_api_e api = MUSE_RECORDER_API_SET_ERROR_CB;
 615         handle = muse_core_ipc_get_handle(module);
 616         ret = legacy_recorder_set_error_cb((recorder_h)handle,
 617                                                         (recorder_error_cb)_recorder_disp_error_cb,
 618                                                         (void *)module);
 619         LOGD("handle : 0x%x", handle);
 620         muse_recorder_msg_return(api, ret, module);
 621
 622         return MUSE_RECORDER_ERROR_NONE;
 623 }
 624
 625 int recorder_dispatcher_unset_error_cb(muse_module_h module)
 626 {
 627         int ret = RECORDER_ERROR_NONE;
 628         intptr_t handle;
 629         muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_ERROR_CB;
 630         handle = muse_core_ipc_get_handle(module);
 631         ret = legacy_recorder_unset_error_cb((recorder_h)handle);
 632         LOGD("handle : 0x%x", handle);
 633         muse_recorder_msg_return(api, ret, module);
 634
 635         return MUSE_RECORDER_ERROR_NONE;
 636 }
 637
 638 int recorder_dispatcher_set_recording_status_cb(muse_module_h module)
 639 {
 640         int ret = RECORDER_ERROR_NONE;
 641         intptr_t handle;
 642         muse_recorder_api_e api = MUSE_RECORDER_API_SET_RECORDING_STATUS_CB;
 643         handle = muse_core_ipc_get_handle(module);
 644         ret = legacy_recorder_set_recording_status_cb((recorder_h)handle,
 645                                                         (recorder_recording_status_cb)_recorder_disp_recording_status_cb,
 646                                                         (void *)module);
 647         LOGD("handle : 0x%x", handle);
 648         muse_recorder_msg_return(api, ret, module);
 649
 650         return MUSE_RECORDER_ERROR_NONE;
 651 }
 652
 653 int recorder_dispatcher_unset_recording_status_cb(muse_module_h module)
 654 {
 655         int ret = RECORDER_ERROR_NONE;
 656         intptr_t handle;
 657         muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_RECORDING_STATUS_CB;
 658         handle = muse_core_ipc_get_handle(module);
 659         ret = legacy_recorder_unset_recording_status_cb((recorder_h)handle);
 660         LOGD("handle : 0x%x", handle);
 661         muse_recorder_msg_return(api, ret, module);
 662
 663         return MUSE_RECORDER_ERROR_NONE;
 664 }
 665
 666 int recorder_dispatcher_set_recording_limit_reached_cb(muse_module_h module)
 667 {
 668         int ret = RECORDER_ERROR_NONE;
 669         intptr_t handle;
 670         muse_recorder_api_e api = MUSE_RECORDER_API_SET_RECORDING_LIMIT_REACHED_CB;
 671         handle = muse_core_ipc_get_handle(module);
 672         ret = legacy_recorder_set_recording_limit_reached_cb((recorder_h)handle,
 673                                                         (recorder_recording_limit_reached_cb)_recorder_disp_recording_limit_reached_cb,
 674                                                         (void *)module);
 675         LOGD("handle : 0x%x", handle);
 676         muse_recorder_msg_return(api, ret, module);
 677
 678         return MUSE_RECORDER_ERROR_NONE;
 679 }
 680
 681 int recorder_dispatcher_unset_recording_limit_reached_cb(muse_module_h module)
 682 {
 683         int ret = RECORDER_ERROR_NONE;
 684         intptr_t handle;
 685         muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_RECORDING_LIMIT_REACHED_CB;
 686         handle = muse_core_ipc_get_handle(module);
 687         ret = legacy_recorder_unset_recording_limit_reached_cb((recorder_h)handle);
 688         LOGD("handle : 0x%x", handle);
 689         muse_recorder_msg_return(api, ret, module);
 690
 691         return MUSE_RECORDER_ERROR_NONE;
 692 }
 693
 694 int recorder_dispatcher_foreach_supported_file_format(muse_module_h module)
 695 {
 696         int ret = RECORDER_ERROR_NONE;
 697         intptr_t handle;
 698         muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_FILE_FORMAT;
 699         handle = muse_core_ipc_get_handle(module);
 700         ret = legacy_recorder_foreach_supported_file_format((recorder_h)handle,
 701                                                         (recorder_supported_file_format_cb)_recorder_disp_foreach_supported_file_format_cb,
 702                                                         (void *)module);
 703         LOGD("handle : 0x%x", handle);
 704         muse_recorder_msg_return(api, ret, module);
 705
 706         return MUSE_RECORDER_ERROR_NONE;
 707 }
 708
 709 int recorder_dispatcher_attr_set_size_limit(muse_module_h module)
 710 {
 711         int ret = RECORDER_ERROR_NONE;
 712         intptr_t handle;
 713         int kbyte;
 714         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_SIZE_LIMIT;
 715         handle = muse_core_ipc_get_handle(module);
 716         muse_recorder_msg_get(kbyte, muse_core_client_get_msg(module));
 717         ret = legacy_recorder_attr_set_size_limit((recorder_h)handle, kbyte);
 718         LOGD("handle : 0x%x", handle);
 719         muse_recorder_msg_return(api, ret, module);
 720
 721         return MUSE_RECORDER_ERROR_NONE;
 722 }
 723
 724 int recorder_dispatcher_attr_set_time_limit(muse_module_h module)
 725 {
 726         int ret = RECORDER_ERROR_NONE;
 727         intptr_t handle;
 728         int second;
 729         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_TIME_LIMIT;
 730         handle = muse_core_ipc_get_handle(module);
 731         muse_recorder_msg_get(second, muse_core_client_get_msg(module));
 732         ret = legacy_recorder_attr_set_time_limit((recorder_h)handle, second);
 733         LOGD("handle : 0x%x", handle);
 734         muse_recorder_msg_return(api, ret, module);
 735
 736         return MUSE_RECORDER_ERROR_NONE;
 737 }
 738
 739 int recorder_dispatcher_attr_set_audio_device(muse_module_h module)
 740 {
 741         int ret = RECORDER_ERROR_NONE;
 742         intptr_t handle;
 743         int set_device;
 744         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_AUDIO_DEVICE;
 745         handle = muse_core_ipc_get_handle(module);
 746         muse_recorder_msg_get(set_device, muse_core_client_get_msg(module));
 747         ret = legacy_recorder_attr_set_audio_device((recorder_h)handle, (recorder_audio_device_e)set_device);
 748         LOGD("handle : 0x%x", handle);
 749         muse_recorder_msg_return(api, ret, module);
 750
 751         return MUSE_RECORDER_ERROR_NONE;
 752 }
 753
 754 int recorder_dispatcher_set_audio_encoder(muse_module_h module)
 755 {
 756         int ret = RECORDER_ERROR_NONE;
 757         intptr_t handle;
 758         int set_codec;
 759         muse_recorder_api_e api = MUSE_RECORDER_API_SET_AUDIO_ENCODER;
 760         handle = muse_core_ipc_get_handle(module);
 761         muse_recorder_msg_get(set_codec, muse_core_client_get_msg(module));
 762         ret = legacy_recorder_set_audio_encoder((recorder_h)handle, (recorder_audio_codec_e)set_codec);
 763         LOGD("handle : 0x%x", handle);
 764         muse_recorder_msg_return(api, ret, module);
 765
 766         return MUSE_RECORDER_ERROR_NONE;
 767 }
 768
 769 int recorder_dispatcher_get_audio_encoder(muse_module_h module)
 770 {
 771         int ret = RECORDER_ERROR_NONE;
 772         intptr_t handle;
 773         recorder_audio_codec_e codec;
 774         int get_codec;
 775         muse_recorder_api_e api = MUSE_RECORDER_API_GET_AUDIO_ENCODER;
 776         handle = muse_core_ipc_get_handle(module);
 777         ret = legacy_recorder_get_audio_encoder((recorder_h)handle, &codec);
 778         get_codec = (int)codec;
 779         LOGD("handle : 0x%x", handle);
 780         muse_recorder_msg_return1(api, ret, module, INT, get_codec);
 781
 782         return MUSE_RECORDER_ERROR_NONE;
 783 }
 784
 785 int recorder_dispatcher_set_video_encoder(muse_module_h module)
 786 {
 787         int ret = RECORDER_ERROR_NONE;
 788         intptr_t handle;
 789         int set_codec;
 790         muse_recorder_api_e api = MUSE_RECORDER_API_SET_VIDEO_ENCODER;
 791         handle = muse_core_ipc_get_handle(module);
 792         muse_recorder_msg_get(set_codec, muse_core_client_get_msg(module));
 793         ret = legacy_recorder_set_video_encoder((recorder_h)handle, (recorder_video_codec_e)set_codec);
 794         LOGD("handle : 0x%x", handle);
 795         muse_recorder_msg_return(api, ret, module);
 796
 797         return MUSE_RECORDER_ERROR_NONE;
 798 }
 799
 800 int recorder_dispatcher_get_video_encoder(muse_module_h module)
 801 {
 802         int ret = RECORDER_ERROR_NONE;
 803         intptr_t handle;
 804         recorder_video_codec_e codec;
 805         int get_codec;
 806         muse_recorder_api_e api = MUSE_RECORDER_API_GET_VIDEO_ENCODER;
 807         handle = muse_core_ipc_get_handle(module);
 808         ret = legacy_recorder_get_video_encoder((recorder_h)handle, &codec);
 809         get_codec = (int)codec;
 810         LOGD("handle : 0x%x", handle);
 811         muse_recorder_msg_return1(api, ret, module, INT, get_codec);
 812
 813         return MUSE_RECORDER_ERROR_NONE;
 814 }
 815
 816 int recorder_dispatcher_attr_set_audio_samplerate(muse_module_h module)
 817 {
 818         int ret = RECORDER_ERROR_NONE;
 819         intptr_t handle;
 820         int samplerate;
 821         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_AUDIO_SAMPLERATE;
 822         handle = muse_core_ipc_get_handle(module);
 823         muse_recorder_msg_get(samplerate, muse_core_client_get_msg(module));
 824         ret = legacy_recorder_attr_set_audio_samplerate((recorder_h)handle, samplerate);
 825         LOGD("handle : 0x%x samplerate : %d", handle, samplerate);
 826         muse_recorder_msg_return(api, ret, module);
 827
 828         return MUSE_RECORDER_ERROR_NONE;
 829 }
 830
 831 int recorder_dispatcher_attr_set_audio_encoder_bitrate(muse_module_h module)
 832 {
 833         int ret = RECORDER_ERROR_NONE;
 834         intptr_t handle;
 835         int bitrate;
 836         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_AUDIO_ENCODER_BITRATE;
 837         handle = muse_core_ipc_get_handle(module);
 838         muse_recorder_msg_get(bitrate, muse_core_client_get_msg(module));
 839         ret = legacy_recorder_attr_set_audio_encoder_bitrate((recorder_h)handle, bitrate);
 840         LOGD("handle : 0x%x", handle);
 841         muse_recorder_msg_return(api, ret, module);
 842
 843         return MUSE_RECORDER_ERROR_NONE;
 844 }
 845
 846 int recorder_dispatcher_attr_set_video_encoder_bitrate(muse_module_h module)
 847 {
 848         int ret = RECORDER_ERROR_NONE;
 849         intptr_t handle;
 850         int bitrate;
 851         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_VIDEO_ENCODER_BITRATE;
 852         handle = muse_core_ipc_get_handle(module);
 853         muse_recorder_msg_get(bitrate, muse_core_client_get_msg(module));
 854         ret = legacy_recorder_attr_set_video_encoder_bitrate((recorder_h)handle, bitrate);
 855         LOGD("handle : 0x%x", handle);
 856         muse_recorder_msg_return(api, ret, module);
 857
 858         return MUSE_RECORDER_ERROR_NONE;
 859 }
 860
 861 int recorder_dispatcher_attr_get_size_limit(muse_module_h module)
 862 {
 863         int ret = RECORDER_ERROR_NONE;
 864         intptr_t handle;
 865         int get_kbyte;
 866         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_SIZE_LIMIT;
 867         handle = muse_core_ipc_get_handle(module);
 868         ret = legacy_recorder_attr_get_size_limit((recorder_h)handle, &get_kbyte);
 869         LOGD("handle : 0x%x", handle);
 870         muse_recorder_msg_return1(api, ret, module, INT, get_kbyte);
 871
 872         return MUSE_RECORDER_ERROR_NONE;
 873 }
 874
 875 int recorder_dispatcher_attr_get_time_limit(muse_module_h module)
 876 {
 877         int ret = RECORDER_ERROR_NONE;
 878         intptr_t handle;
 879         int get_second;
 880         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_TIME_LIMIT;
 881         handle = muse_core_ipc_get_handle(module);
 882         ret = legacy_recorder_attr_get_time_limit((recorder_h)handle, &get_second);
 883         LOGD("handle : 0x%x", handle);
 884         muse_recorder_msg_return1(api, ret, module, INT, get_second);
 885
 886         return MUSE_RECORDER_ERROR_NONE;
 887 }
 888
 889 int recorder_dispatcher_attr_get_audio_device(muse_module_h module)
 890 {
 891         int ret = RECORDER_ERROR_NONE;
 892         intptr_t handle;
 893         recorder_audio_device_e device;
 894         int get_device;
 895         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_AUDIO_DEVICE;
 896         handle = muse_core_ipc_get_handle(module);
 897         ret = legacy_recorder_attr_get_audio_device((recorder_h)handle, &device);
 898         get_device = (int)device;
 899         LOGD("handle : 0x%x", handle);
 900         muse_recorder_msg_return1(api, ret, module, INT, get_device);
 901
 902         return MUSE_RECORDER_ERROR_NONE;
 903 }
 904
 905 int recorder_dispatcher_attr_get_audio_samplerate(muse_module_h module)
 906 {
 907         int ret = RECORDER_ERROR_NONE;
 908         intptr_t handle;
 909         int get_samplerate;
 910         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_AUDIO_SAMPLERATE;
 911         handle = muse_core_ipc_get_handle(module);
 912         ret = legacy_recorder_attr_get_audio_samplerate((recorder_h)handle, &get_samplerate);
 913         LOGD("handle : 0x%x, get_samplerate : %d", handle, get_samplerate);
 914         muse_recorder_msg_return1(api, ret, module, INT, get_samplerate);
 915
 916         return MUSE_RECORDER_ERROR_NONE;
 917 }
 918
 919 int recorder_dispatcher_attr_get_audio_encoder_bitrate(muse_module_h module)
 920 {
 921         int ret = RECORDER_ERROR_NONE;
 922         intptr_t handle;
 923         int get_bitrate;
 924         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_AUDIO_ENCODER_BITRATE;
 925         handle = muse_core_ipc_get_handle(module);
 926         ret = legacy_recorder_attr_get_audio_encoder_bitrate((recorder_h)handle, &get_bitrate);
 927         LOGD("handle : 0x%x", handle);
 928         muse_recorder_msg_return1(api, ret, module, INT, get_bitrate);
 929
 930         return MUSE_RECORDER_ERROR_NONE;
 931 }
 932
 933 int recorder_dispatcher_attr_get_video_encoder_bitrate(muse_module_h module)
 934 {
 935         int ret = RECORDER_ERROR_NONE;
 936         intptr_t handle;
 937         int get_bitrate;
 938         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_VIDEO_ENCODER_BITRATE;
 939         handle = muse_core_ipc_get_handle(module);
 940         ret = legacy_recorder_attr_get_video_encoder_bitrate((recorder_h)handle, &get_bitrate);
 941         LOGD("handle : 0x%x", handle);
 942         muse_recorder_msg_return1(api, ret, module, INT, get_bitrate);
 943
 944         return MUSE_RECORDER_ERROR_NONE;
 945 }
 946
 947 int recorder_dispatcher_foreach_supported_audio_encoder(muse_module_h module)
 948 {
 949         int ret = RECORDER_ERROR_NONE;
 950         intptr_t handle;
 951         muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_AUDIO_ENCODER;
 952         handle = muse_core_ipc_get_handle(module);
 953         ret = legacy_recorder_foreach_supported_audio_encoder((recorder_h)handle,
 954                                                         (recorder_supported_audio_encoder_cb)_recorder_disp_foreach_supported_audio_encoder_cb,
 955                                                         (void *)module);
 956         LOGD("handle : 0x%x", handle);
 957         muse_recorder_msg_return(api, ret, module);
 958
 959         return MUSE_RECORDER_ERROR_NONE;
 960 }
 961
 962 int recorder_dispatcher_foreach_supported_video_encoder(muse_module_h module)
 963 {
 964         int ret = RECORDER_ERROR_NONE;
 965         intptr_t handle;
 966         muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_VIDEO_ENCODER;
 967         handle = muse_core_ipc_get_handle(module);
 968         ret = legacy_recorder_foreach_supported_video_encoder((recorder_h)handle,
 969                                                         (recorder_supported_video_encoder_cb)_recorder_disp_foreach_supported_video_encoder_cb,
 970                                                         (void *)module);
 971         LOGD("handle : 0x%x", handle);
 972         muse_recorder_msg_return(api, ret, module);
 973
 974         return MUSE_RECORDER_ERROR_NONE;
 975 }
 976
 977 int recorder_dispatcher_attr_set_mute(muse_module_h module)
 978 {
 979         int ret = RECORDER_ERROR_NONE;
 980         intptr_t handle;
 981         int set_enable;
 982         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_MUTE;
 983         handle = muse_core_ipc_get_handle(module);
 984         muse_recorder_msg_get(set_enable, muse_core_client_get_msg(module));
 985         ret = legacy_recorder_attr_set_mute((recorder_h)handle, (bool)set_enable);
 986         LOGD("handle : 0x%x", handle);
 987         muse_recorder_msg_return(api, ret, module);
 988
 989         return MUSE_RECORDER_ERROR_NONE;
 990 }
 991
 992 int recorder_dispatcher_attr_is_muted(muse_module_h module)
 993 {
 994         int ret = RECORDER_ERROR_NONE;
 995         intptr_t handle;
 996         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_IS_MUTED;
 997         handle = muse_core_ipc_get_handle(module);
 998         ret = legacy_recorder_attr_is_muted((recorder_h)handle);
 999         LOGD("handle : 0x%x", handle);
1000         muse_recorder_msg_return(api, ret, module);
1001
1002         return MUSE_RECORDER_ERROR_NONE;
1003 }
1004
1005 int recorder_dispatcher_attr_set_recording_motion_rate(muse_module_h module)
1006 {
1007         int ret = RECORDER_ERROR_NONE;
1008         intptr_t handle;
1009         double rate;
1010         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_RECORDING_MOTION_RATE;
1011         handle = muse_core_ipc_get_handle(module);
1012         muse_recorder_msg_get(rate, muse_core_client_get_msg(module));
1013         ret = legacy_recorder_attr_set_recording_motion_rate((recorder_h)handle, rate);
1014         LOGD("handle : 0x%x", handle);
1015         muse_recorder_msg_return(api, ret, module);
1016
1017         return MUSE_RECORDER_ERROR_NONE;
1018 }
1019
1020 int recorder_dispatcher_attr_get_recording_motion_rate(muse_module_h module)
1021 {
1022         int ret = RECORDER_ERROR_NONE;
1023         intptr_t handle;
1024         double get_rate;
1025         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_RECORDING_MOTION_RATE;
1026         handle = muse_core_ipc_get_handle(module);
1027         ret = legacy_recorder_attr_get_recording_motion_rate((recorder_h)handle, &get_rate);
1028         LOGD("handle : 0x%x", handle);
1029         muse_recorder_msg_return1(api, ret, module, DOUBLE, get_rate);
1030
1031         return MUSE_RECORDER_ERROR_NONE;
1032 }
1033
1034 int recorder_dispatcher_attr_set_audio_channel(muse_module_h module)
1035 {
1036         int ret = RECORDER_ERROR_NONE;
1037         intptr_t handle;
1038         int channel_count;
1039         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_AUDIO_CHANNEL;
1040         handle = muse_core_ipc_get_handle(module);
1041         muse_recorder_msg_get(channel_count, muse_core_client_get_msg(module));
1042         LOGD("channel_count : %d", channel_count);
1043         ret = legacy_recorder_attr_set_audio_channel((recorder_h)handle, channel_count);
1044         LOGD("handle : 0x%x", handle);
1045         muse_recorder_msg_return(api, ret, module);
1046
1047         return MUSE_RECORDER_ERROR_NONE;
1048 }
1049
1050 int recorder_dispatcher_attr_get_audio_channel(muse_module_h module)
1051 {
1052         int ret = RECORDER_ERROR_NONE;
1053         intptr_t handle;
1054         int get_channel_count;
1055         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_AUDIO_CHANNEL;
1056         handle = muse_core_ipc_get_handle(module);
1057         ret = legacy_recorder_attr_get_audio_channel((recorder_h)handle, &get_channel_count);
1058         LOGD("handle : 0x%x", handle);
1059         muse_recorder_msg_return1(api, ret, module, INT, get_channel_count);
1060
1061         return MUSE_RECORDER_ERROR_NONE;
1062 }
1063
1064 int recorder_dispatcher_attr_set_orientation_tag(muse_module_h module)
1065 {
1066         int ret = RECORDER_ERROR_NONE;
1067         intptr_t handle;
1068         int set_orientation;
1069         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_ORIENTATION_TAG;
1070         handle = muse_core_ipc_get_handle(module);
1071         muse_recorder_msg_get(set_orientation, muse_core_client_get_msg(module));
1072         ret = legacy_recorder_attr_set_orientation_tag((recorder_h)handle, (recorder_rotation_e)set_orientation);
1073         LOGD("handle : 0x%x", handle);
1074         muse_recorder_msg_return(api, ret, module);
1075
1076         return MUSE_RECORDER_ERROR_NONE;
1077 }
1078
1079 int recorder_dispatcher_attr_get_orientation_tag(muse_module_h module)
1080 {
1081         int ret = RECORDER_ERROR_NONE;
1082         intptr_t handle;
1083         recorder_rotation_e orientation;
1084         int get_orientation;
1085         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_ORIENTATION_TAG;
1086         handle = muse_core_ipc_get_handle(module);
1087         ret = legacy_recorder_attr_get_orientation_tag((recorder_h)handle, &orientation);
1088         get_orientation = (int)orientation;
1089         LOGD("handle : 0x%x", handle);
1090         muse_recorder_msg_return1(api, ret, module, INT, get_orientation);
1091
1092         return MUSE_RECORDER_ERROR_NONE;
1093 }
1094
1095 int recorder_dispatcher_attr_set_root_directory(muse_module_h module)
1096 {
1097         int ret = RECORDER_ERROR_NONE;
1098         intptr_t handle;
1099         char root_directory[MUSE_RECORDER_MSG_MAX_LENGTH] = {0,};
1100         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_ROOT_DIRECTORY;
1101
1102         handle = muse_core_ipc_get_handle(module);
1103
1104         muse_recorder_msg_get_string(root_directory, muse_core_client_get_msg(module));
1105
1106         ret = legacy_recorder_attr_set_root_directory((recorder_h)handle, root_directory);
1107
1108         LOGD("handle : 0x%x, root_directory : %s", handle, root_directory);
1109
1110         muse_recorder_msg_return(api, ret, module);
1111
1112         return MUSE_RECORDER_ERROR_NONE;
1113 }
1114
1115 int (*dispatcher[MUSE_RECORDER_API_MAX]) (muse_module_h module) = {
1116         recorder_dispatcher_create, /* MUSE_RECORDER_API_CREATE, */
1117         recorder_dispatcher_destroy, /* MUSE_RECORDER_API_DESTROY, */
1118         recorder_dispatcher_get_state, /* MUSE_RECORDER_API_GET_STATE, */
1119         recorder_dispatcher_prepare, /* MUSE_RECORDER_API_PREPARE, */
1120         recorder_dispatcher_unprepare, /* MUSE_RECORDER_API_UNPREPARE, */
1121         recorder_dispatcher_start, /* MUSE_RECORDER_API_START, */
1122         recorder_dispatcher_pause, /* MUSE_RECORDER_API_PAUSE, */
1123         recorder_dispatcher_commit, /* MUSE_RECORDER_API_COMMIT, */
1124         recorder_dispatcher_cancel, /* MUSE_RECORDER_API_CANCEL, */
1125         recorder_dispatcher_set_video_resolution, /* MUSE_RECORDER_API_SET_VIDEO_RESOLUTION, */
1126         recorder_dispatcher_get_video_resolution, /* MUSE_RECORDER_API_GET_VIDEO_RESOLUTION, */
1127         recorder_dispatcher_foreach_supported_video_resolution, /* MUSE_RECORDER_API_FOREACH_SUPPORTED_VIDEO_RESOLUTION, */
1128         recorder_dispatcher_get_audio_level, /* MUSE_RECORDER_API_GET_AUDIO_LEVEL, */
1129         recorder_dispatcher_set_filename, /* MUSE_RECORDER_API_SET_FILENAME, */
1130         recorder_dispatcher_get_filename, /* MUSE_RECORDER_API_GET_FILENAME, */
1131         recorder_dispatcher_set_file_format, /* MUSE_RECORDER_API_SET_FILE_FORMAT, */
1132         recorder_dispatcher_get_file_format, /* MUSE_RECORDER_API_GET_FILE_FORMAT, */
1133         recorder_dispatcher_set_state_changed_cb, /* MUSE_RECORDER_API_SET_STATE_CHANGED_CB, */
1134         recorder_dispatcher_unset_state_changed_cb, /* MUSE_RECORDER_API_UNSET_STATE_CHANGED_CB, */
1135         recorder_dispatcher_set_interrupted_cb, /* MUSE_RECORDER_API_SET_INTERRUPTED_CB, */
1136         recorder_dispatcher_unset_interrupted_cb, /* MUSE_RECORDER_API_UNSET_INTERRUPTED_CB, */
1137         recorder_dispatcher_set_audio_stream_cb, /* MUSE_RECORDER_API_SET_AUDIO_STREAM_CB, */
1138         recorder_dispatcher_unset_audio_stream_cb, /* MUSE_RECORDER_API_UNSET_AUDIO_STREAM_CB, */
1139         recorder_dispatcher_set_error_cb, /* MUSE_RECORDER_API_SET_ERROR_CB, */
1140         recorder_dispatcher_unset_error_cb, /* MUSE_RECORDER_API_UNSET_ERROR_CB, */
1141         recorder_dispatcher_set_recording_status_cb, /* MUSE_RECORDER_API_SET_RECORDING_STATUS_CB, */
1142         recorder_dispatcher_unset_recording_status_cb, /* MUSE_RECORDER_API_UNSET_RECORDING_STATUS_CB, */
1143         recorder_dispatcher_set_recording_limit_reached_cb, /* MUSE_RECORDER_API_SET_RECORDING_LIMIT_RECHEAD_CB, */
1144         recorder_dispatcher_unset_recording_limit_reached_cb, /* MUSE_RECORDER_API_UNSET_RECORDING_LIMIT_RECHEAD_CB, */
1145         recorder_dispatcher_foreach_supported_file_format, /* MUSE_RECORDER_API_FOREACH_SUPPORTED_FILE_FORMAT, */
1146         recorder_dispatcher_attr_set_size_limit, /* MUSE_RECORDER_API_ATTR_SET_SIZE_LIMIT, */
1147         recorder_dispatcher_attr_set_time_limit, /* MUSE_RECORDER_API_ATTR_SET_TIME_LIMIT, */
1148         recorder_dispatcher_attr_set_audio_device, /* MUSE_RECORDER_API_ATTR_SET_AUDIO_DEVICE, */
1149         recorder_dispatcher_set_audio_encoder, /* MUSE_RECORDER_API_SET_AUDIO_ENCODER, */
1150         recorder_dispatcher_get_audio_encoder, /* MUSE_RECORDER_API_GET_AUDIO_ENCODER, */
1151         recorder_dispatcher_set_video_encoder, /* MUSE_RECORDER_API_SET_VIDEO_ENCODER, */
1152         recorder_dispatcher_get_video_encoder, /* MUSE_RECORDER_API_GET_VIDEO_ENCODER, */
1153         recorder_dispatcher_attr_set_audio_samplerate, /* MUSE_RECORDER_API_ATTR_SET_AUDIO_SAMPLERATE, */
1154         recorder_dispatcher_attr_set_audio_encoder_bitrate, /* MUSE_RECORDER_API_ATTR_SET_AUDIO_ENCODER_BITRATE, */
1155         recorder_dispatcher_attr_set_video_encoder_bitrate, /* MUSE_RECORDER_API_ATTR_SET_VIDEO_ENCODER_BITRATE, */
1156         recorder_dispatcher_attr_get_size_limit, /* MUSE_RECORDER_API_ATTR_GET_SIZE_LIMIT, */
1157         recorder_dispatcher_attr_get_time_limit, /* MUSE_RECORDER_API_ATTR_GET_TIME_LIMIT, */
1158         recorder_dispatcher_attr_get_audio_device, /* MUSE_RECORDER_API_ATTR_GET_AUDIO_DEVICE, */
1159         recorder_dispatcher_attr_get_audio_samplerate, /* MUSE_RECORDER_API_ATTR_GET_AUDIO_SAMPLERATE, */
1160         recorder_dispatcher_attr_get_audio_encoder_bitrate, /* MUSE_RECORDER_API_ATTR_GET_AUDIO_ENCODER_BITRATE, */
1161         recorder_dispatcher_attr_get_video_encoder_bitrate, /* MUSE_RECORDER_API_ATTR_GET_VIDEO_ENCODER_BITRATE, */
1162         recorder_dispatcher_foreach_supported_audio_encoder, /* MUSE_RECORDER_API_FOREACH_SUPPORTED_AUDIO_ENCODER, */
1163         recorder_dispatcher_foreach_supported_video_encoder, /* MUSE_RECORDER_API_FOREACH_SUPPORTED_VIDEO_ENCODER, */
1164         recorder_dispatcher_attr_set_mute, /* MUSE_RECORDER_API_ATTR_SET_MUTE, */
1165         recorder_dispatcher_attr_is_muted, /* MUSE_RECORDER_API_ATTR_IS_MUTED, */
1166         recorder_dispatcher_attr_set_recording_motion_rate, /* MUSE_RECORDER_API_ATTR_SET_RECORDING_MOTION_RATE, */
1167         recorder_dispatcher_attr_get_recording_motion_rate, /* MUSE_RECORDER_API_ATTR_GET_RECORDING_MOTION_RATE, */
1168         recorder_dispatcher_attr_set_audio_channel, /* MUSE_RECORDER_API_ATTR_SET_AUDIO_CHANNEL, */
1169         recorder_dispatcher_attr_get_audio_channel, /* MUSE_RECORDER_API_ATTR_GET_AUDIO_CHANNEL, */
1170         recorder_dispatcher_attr_set_orientation_tag, /* MUSE_RECORDER_API_ATTR_SET_ORIENTATION_TAG, */
1171         recorder_dispatcher_attr_get_orientation_tag, /* MUSE_RECORDER_API_ATTR_GET_ORIENTATION_TAG, */
1172         recorder_dispatcher_attr_set_root_directory, /* MUSE_RECORDER_API_ATTR_SET_ROOT_DIRECTORY, */
1173 };