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 <muse_server.h>
  27 #include <muse_camera_internal.h>
  28 #include <mm_types.h>
  29 #include <dlog.h>
  30 #include <vconf.h>
  31 #include <gst/gst.h>
  32 #include "legacy_recorder_internal.h"
  33
  34 #ifdef LOG_TAG
  35 #undef LOG_TAG
  36 #endif
  37 #define LOG_TAG "MUSED_RECORDER"
  38 #define KEY_LENGTH 32
  39
  40 #define AUDIO_RECORDING_FEATURE_NAME    "http://tizen.org/feature/media.audio_recording"
  41 #define VIDEO_RECORDING_FEATURE_NAME    "http://tizen.org/feature/media.video_recording"
  42 #define CAMERA_PRIVILEGE_NAME           "http://tizen.org/privilege/camera"
  43 #define RECORDER_PRIVILEGE_NAME         "http://tizen.org/privilege/recorder"
  44 #define RECORDER_DEVICE_STATE_KEY_AUDIO "device_state_recorder_audio"
  45 #define RECORDER_DEVICE_STATE_KEY_VIDEO "device_state_recorder_video"
  46
  47 #define recorder_return_if_fail(expr) \
  48         do { \
  49                 if (!(expr)) { \
  50                         LOGE("failed [%s]", #expr); \
  51                         return; \
  52                 } \
  53         } while (0)
  54
  55 #define recorder_return_val_if_fail(expr, val) \
  56         do { \
  57                 if (!(expr)) { \
  58                         LOGE("failed [%s]", #expr); \
  59                         return (val); \
  60                 } \
  61         } while (0)
  62
  63 #define recorder_send_msg_return_err_if_fail(expr, ret, err) \
  64         do { \
  65                 if (!(expr)) { \
  66                         int _ret = ret; \
  67                         LOGE("failed [%s]", #expr); \
  68                         muse_recorder_msg_return(api, class, _ret, module); \
  69                         return err; \
  70                 } \
  71         } while (0)
  72
  73 static GMutex g_recorder_device_state_lock;
  74
  75
  76 /**
  77  * @brief The structure type for the exported bo data.
  78  */
  79 typedef struct {
  80         tbm_bo bo;
  81         tbm_fd fd;
  82 } muse_recorder_export_data;
  83
  84 typedef struct {
  85         GList *list;
  86         GMutex lock;
  87         GCond cond;
  88 } muse_recorder_data_list;
  89
  90 /**
  91  * @brief The structure type for the muse recorder.
  92  */
  93 typedef struct {
  94         recorder_h recorder_handle;
  95         tbm_bufmgr bufmgr;
  96         GMutex list_lock;
  97         muse_recorder_data_list recorder_data;
  98         muse_camera_data_list camera_data;
  99         bool video_encode_decision;
 100         muse_recorder_type_e type;
 101         muse_camera_handle_s *muse_camera;
 102 } muse_recorder_handle_s;
 103
 104
 105 void _recorder_disp_recording_limit_reached_cb(recorder_recording_limit_type_e type, void *user_data)
 106 {
 107         muse_module_h module = (muse_module_h)user_data;
 108
 109         recorder_return_if_fail(module);
 110
 111         muse_recorder_msg_event1(MUSE_RECORDER_CB_EVENT,
 112                 MUSE_RECORDER_EVENT_TYPE_RECORDING_LIMITED,
 113                 MUSE_RECORDER_EVENT_CLASS_THREAD_MAIN,
 114                 module,
 115                 INT, type);
 116
 117         return;
 118 }
 119
 120 void _recorder_disp_recording_status_cb(unsigned long long elapsed_time, unsigned long long file_size, void *user_data)
 121 {
 122         muse_module_h module = (muse_module_h)user_data;
 123         int64_t cb_elapsed_time = (int64_t)elapsed_time;
 124         int64_t cb_file_size = (int64_t)file_size;
 125
 126         recorder_return_if_fail(module);
 127
 128         muse_recorder_msg_event2(MUSE_RECORDER_CB_EVENT,
 129                 MUSE_RECORDER_EVENT_TYPE_RECORDING_STATUS,
 130                 MUSE_RECORDER_EVENT_CLASS_THREAD_MAIN,
 131                 module,
 132                 INT64, cb_elapsed_time,
 133                 INT64, cb_file_size);
 134
 135         return;
 136 }
 137
 138 void _recorder_disp_state_changed_cb(recorder_state_e previous, recorder_state_e current, bool by_policy, void *user_data)
 139 {
 140         muse_module_h module = (muse_module_h)user_data;
 141         muse_recorder_handle_s *muse_recorder = NULL;
 142         char value_key[KEY_LENGTH] = {'\0',};
 143         int emit_value = -1;
 144         int device_recording = 0;
 145         int device_paused = 0;
 146         int device_status = -1;
 147         int vconf_state_recorder = VCONFKEY_RECORDER_STATE_NULL;
 148         int vconf_state_camera = VCONFKEY_CAMERA_STATE_PREVIEW;
 149         recorder_device_state_e current_state = RECORDER_DEVICE_STATE_IDLE;
 150         static recorder_device_state_e device_state[MUSE_RECORDER_TYPE_NUM] = {
 151                 RECORDER_DEVICE_STATE_IDLE, /* 0:MUSE_RECORDER_TYPE_AUDIO */
 152                 RECORDER_DEVICE_STATE_IDLE  /* 1:MUSE_RECORDER_TYPE_VIDEO */
 153         };
 154
 155         recorder_return_if_fail(module);
 156
 157         muse_recorder_msg_event3(MUSE_RECORDER_CB_EVENT,
 158                 MUSE_RECORDER_EVENT_TYPE_STATE_CHANGE,
 159                 MUSE_RECORDER_EVENT_CLASS_THREAD_MAIN,
 160                 module,
 161                 INT, previous,
 162                 INT, current,
 163                 INT, by_policy);
 164
 165         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
 166
 167         recorder_return_if_fail(muse_recorder);
 168
 169         g_mutex_lock(&g_recorder_device_state_lock);
 170
 171         /* make key name */
 172         if (muse_recorder->type == MUSE_RECORDER_TYPE_AUDIO)
 173                 snprintf(value_key, KEY_LENGTH, "%s", RECORDER_DEVICE_STATE_KEY_AUDIO);
 174         else
 175                 snprintf(value_key, KEY_LENGTH, "%s", RECORDER_DEVICE_STATE_KEY_VIDEO);
 176
 177         /* get current status */
 178         muse_server_module_get_value(module, value_key, &device_status);
 179         device_recording = device_status >> 16;
 180         device_paused = 0x0000ffff & device_status;
 181
 182         LOGD("get [%s] 0x%8x", value_key, device_status);
 183
 184         LOGD("previous RECORDING %d, PAUSED %d", device_recording, device_paused);
 185
 186         /* adjust status */
 187         if (current == RECORDER_STATE_RECORDING)
 188                 device_recording++;
 189         else if (current == RECORDER_STATE_PAUSED)
 190                 device_paused++;
 191
 192         if (previous == RECORDER_STATE_RECORDING)
 193                 device_recording--;
 194         else if (previous == RECORDER_STATE_PAUSED)
 195                 device_paused--;
 196
 197         LOGD("current RECORDING %d, PAUSED %d", device_recording, device_paused);
 198
 199         /* make new status */
 200         device_status = device_recording << 16 | device_paused;
 201
 202         LOGD("set [%s] 0x%8x", value_key, device_status);
 203
 204         muse_server_module_set_value(module, value_key, device_status);
 205
 206         /* check whether emit signal or not */
 207         if (device_recording > 0) {
 208                 current_state = RECORDER_DEVICE_STATE_RECORDING;
 209                 vconf_state_recorder = VCONFKEY_RECORDER_STATE_RECORDING;
 210                 vconf_state_camera = VCONFKEY_CAMERA_STATE_RECORDING;
 211         } else if (device_paused > 0) {
 212                 current_state = RECORDER_DEVICE_STATE_PAUSED;
 213                 vconf_state_recorder = VCONFKEY_RECORDER_STATE_RECORDING_PAUSE;
 214                 vconf_state_camera = VCONFKEY_CAMERA_STATE_RECORDING_PAUSE;
 215         }
 216
 217         if (current_state != device_state[muse_recorder->type]) {
 218                 LOGD("old %d -> new %d", device_state[muse_recorder->type], current_state);
 219
 220                 emit_value = muse_recorder->type << 16 | current_state;
 221                 device_state[muse_recorder->type] = current_state;
 222         }
 223
 224         if (emit_value != -1) {
 225                 LOGD("recorder devce state change signal [0x%08x], vconf state : %d",
 226                         emit_value, vconf_state_recorder);
 227
 228                 legacy_recorder_emit_signal(muse_recorder->recorder_handle,
 229                         MM_CAMCORDER_DBUS_OBJECT,
 230                         MM_CAMCORDER_DBUS_INTERFACE_RECORDER,
 231                         MM_CAMCORDER_DBUS_SIGNAL_STATE_CHANGED,
 232                         emit_value);
 233
 234                 vconf_set_int(VCONFKEY_RECORDER_STATE, vconf_state_recorder);
 235
 236                 if (muse_recorder->type == MUSE_RECORDER_TYPE_VIDEO) {
 237                         LOGD("Update vconf camera device state also : %d", vconf_state_camera);
 238                         vconf_set_int(VCONFKEY_CAMERA_STATE, vconf_state_camera);
 239                 }
 240         }
 241
 242         g_mutex_unlock(&g_recorder_device_state_lock);
 243
 244         return;
 245 }
 246
 247 //LCOV_EXCL_START
 248 void _recorder_disp_interrupted_cb(recorder_policy_e policy, recorder_state_e previous, recorder_state_e current, void *user_data)
 249 {
 250         muse_module_h module = (muse_module_h)user_data;
 251
 252         recorder_return_if_fail(module);
 253
 254         muse_recorder_msg_event3(MUSE_RECORDER_CB_EVENT,
 255                 MUSE_RECORDER_EVENT_TYPE_INTERRUPTED,
 256                 MUSE_RECORDER_EVENT_CLASS_THREAD_MAIN,
 257                 module,
 258                 INT, policy,
 259                 INT, previous,
 260                 INT, current);
 261
 262         return;
 263 }
 264
 265 void _recorder_disp_interrupt_started_cb(recorder_policy_e policy, recorder_state_e state, void *user_data)
 266 {
 267         muse_module_h module = (muse_module_h)user_data;
 268
 269         recorder_return_if_fail(module);
 270
 271         muse_recorder_msg_event2(MUSE_RECORDER_CB_EVENT,
 272                 MUSE_RECORDER_EVENT_TYPE_INTERRUPT_STARTED,
 273                 MUSE_RECORDER_EVENT_CLASS_THREAD_MAIN,
 274                 module,
 275                 INT, policy,
 276                 INT, state);
 277
 278         return;
 279 }
 280
 281 void _recorder_disp_error_cb(recorder_error_e error, recorder_state_e current_state, void *user_data)
 282 {
 283         muse_module_h module = (muse_module_h)user_data;
 284
 285         recorder_return_if_fail(module);
 286
 287         muse_recorder_msg_event2(MUSE_RECORDER_CB_EVENT,
 288                 MUSE_RECORDER_EVENT_TYPE_ERROR,
 289                 MUSE_RECORDER_EVENT_CLASS_THREAD_MAIN,
 290                 module,
 291                 INT, error,
 292                 INT, current_state);
 293
 294         return;
 295 }
 296 //LCOV_EXCL_STOP
 297
 298 void _recorder_disp_audio_stream_cb(void* stream, int size, recorder_sample_type_e format, int channel, unsigned int timestamp, void *user_data)
 299 {
 300         muse_module_h module = (muse_module_h)user_data;
 301         muse_recorder_handle_s *muse_recorder = NULL;
 302         muse_recorder_export_data *export_data = NULL;
 303         int audio_fd = -1;
 304         tbm_fd tfd[MUSE_NUM_FD] = {-1, -1, -1, -1};
 305         tbm_bo bo = NULL;
 306         tbm_bo_handle bo_handle = {.ptr = NULL};
 307
 308         recorder_return_if_fail(module && stream);
 309
 310         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
 311
 312         recorder_return_if_fail(muse_recorder);
 313
 314         export_data = g_new0(muse_recorder_export_data, 1);
 315
 316         /*LOGD("Enter");*/
 317
 318         /* make tbm bo */
 319         bo = tbm_bo_alloc(muse_recorder->bufmgr, size, TBM_BO_DEFAULT);
 320         if (bo == NULL) {
 321                 LOGE("bo alloc failed : bufmgr %p, size %d", muse_recorder->bufmgr, size);
 322                 goto _BUFFER_FAILED;
 323         }
 324
 325         bo_handle = tbm_bo_map(bo, TBM_DEVICE_CPU, TBM_OPTION_READ | TBM_OPTION_WRITE);
 326         if (bo_handle.ptr == NULL) {
 327                 LOGE("bo map Error!");
 328                 goto _BUFFER_FAILED;
 329         }
 330
 331         memcpy(bo_handle.ptr, stream, size);
 332
 333         tbm_bo_unmap(bo);
 334
 335         audio_fd = tbm_bo_export_fd(bo);
 336         if (audio_fd < 0) {
 337                 LOGE("export bo ERROR");
 338                 goto _BUFFER_FAILED;
 339         }
 340
 341         /* set bo info */
 342         tfd[0] = audio_fd;
 343         export_data->fd = audio_fd;
 344         export_data->bo = bo;
 345
 346         /* add bo info to list */
 347         g_mutex_lock(&muse_recorder->recorder_data.lock);
 348         muse_recorder->recorder_data.list = g_list_append(muse_recorder->recorder_data.list, (gpointer)export_data);
 349         g_mutex_unlock(&muse_recorder->recorder_data.lock);
 350
 351         /* send message */
 352         muse_recorder_msg_event5_fd(MUSE_RECORDER_CB_EVENT,
 353                 MUSE_RECORDER_EVENT_TYPE_AUDIO_STREAM,
 354                 MUSE_RECORDER_EVENT_CLASS_THREAD_SUB,
 355                 module,
 356                 INT, size,
 357                 INT, format,
 358                 INT, channel,
 359                 INT, timestamp,
 360                 INT, audio_fd,
 361                 tfd);
 362
 363         return;
 364
 365 _BUFFER_FAILED:
 366         tbm_bo_unref(bo);
 367         g_free(export_data);
 368         return;
 369 }
 370
 371 void _recorder_disp_muxed_stream_cb(void* stream, int size, unsigned long long offset, void *user_data)
 372 {
 373         muse_module_h module = (muse_module_h)user_data;
 374         muse_recorder_handle_s *muse_recorder = NULL;
 375         muse_recorder_export_data *export_data = NULL;
 376         int muxed_fd = -1;
 377         tbm_fd tfd[MUSE_NUM_FD] = {-1, -1, -1, -1};
 378         tbm_bo bo = NULL;
 379         tbm_bo_handle bo_handle = {.ptr = NULL};
 380
 381         recorder_return_if_fail(module && stream);
 382
 383         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
 384
 385         recorder_return_if_fail(muse_recorder);
 386
 387         export_data = g_new0(muse_recorder_export_data, 1);
 388
 389         /*LOGD("Enter");*/
 390
 391         /* make tbm bo */
 392         bo = tbm_bo_alloc(muse_recorder->bufmgr, size, TBM_BO_DEFAULT);
 393         if (!bo) {
 394                 LOGE("bo alloc failed : bufmgr %p, size %d", muse_recorder->bufmgr, size);
 395                 goto _MUXED_STREAM_CB_ERROR;
 396         }
 397
 398         bo_handle = tbm_bo_map(bo, TBM_DEVICE_CPU, TBM_OPTION_READ | TBM_OPTION_WRITE);
 399         if (!bo_handle.ptr) {
 400                 LOGE("bo map Error!");
 401                 goto _MUXED_STREAM_CB_ERROR;
 402         }
 403
 404         memcpy(bo_handle.ptr, stream, size);
 405
 406         tbm_bo_unmap(bo);
 407
 408         muxed_fd = tbm_bo_export_fd(bo);
 409         if (muxed_fd < 0) {
 410                 LOGE("export bo ERROR");
 411                 goto _MUXED_STREAM_CB_ERROR;
 412         }
 413
 414         /* set bo info */
 415         tfd[0] = muxed_fd;
 416         export_data->fd = muxed_fd;
 417         export_data->bo = bo;
 418
 419         /* add bo info to list */
 420         g_mutex_lock(&muse_recorder->recorder_data.lock);
 421         muse_recorder->recorder_data.list = g_list_append(muse_recorder->recorder_data.list, (gpointer)export_data);
 422         g_mutex_unlock(&muse_recorder->recorder_data.lock);
 423
 424         /* send message */
 425         muse_recorder_msg_event3_fd(MUSE_RECORDER_CB_EVENT,
 426                 MUSE_RECORDER_EVENT_TYPE_MUXED_STREAM,
 427                 MUSE_RECORDER_EVENT_CLASS_THREAD_SUB,
 428                 module,
 429                 INT, size,
 430                 INT64, offset,
 431                 INT, muxed_fd,
 432                 tfd);
 433
 434         return;
 435
 436 _MUXED_STREAM_CB_ERROR:
 437         if (bo) {
 438                 tbm_bo_unref(bo);
 439                 bo = NULL;
 440         }
 441
 442         if (export_data) {
 443                 g_free(export_data);
 444                 export_data = NULL;
 445         }
 446
 447         return;
 448 }
 449
 450 bool _recorder_disp_video_encode_decision_cb(void *stream, void *user_data)
 451 {
 452         int send_ret = 0;
 453         char *send_message = NULL;
 454         muse_recorder_handle_s *muse_recorder = NULL;
 455         muse_camera_export_data *export_data = NULL;
 456         muse_module_h module = (muse_module_h)user_data;
 457         tbm_fd tfd[MUSE_NUM_FD] = {-1, -1, -1, -1};
 458         gint64 end_time = 0;
 459
 460         /*LOGD("Enter");*/
 461
 462         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
 463
 464         recorder_return_val_if_fail(muse_recorder, true);
 465
 466         export_data = camera_export_data_new_from_stream(stream, muse_recorder->bufmgr, tfd);
 467         if (!export_data) {
 468                 LOGE("export_data failed");
 469                 return true;
 470         }
 471
 472         /* add bo info to list */
 473         g_mutex_lock(&muse_recorder->camera_data.lock);
 474
 475         muse_recorder->camera_data.list = g_list_append(muse_recorder->camera_data.list, (gpointer)export_data);
 476
 477         /* reset decision */
 478         muse_recorder->video_encode_decision = true;
 479
 480         /* send message */
 481         send_message = muse_core_msg_new(MUSE_RECORDER_CB_EVENT,
 482                 MUSE_TYPE_INT, PARAM_EVENT, MUSE_RECORDER_EVENT_TYPE_VIDEO_ENCODE_DECISION,
 483                 MUSE_TYPE_INT, PARAM_EVENT_CLASS, MUSE_CAMERA_EVENT_CLASS_THREAD_SUB,
 484                 MUSE_TYPE_INT, "video_fd", tfd[0],
 485                 MUSE_TYPE_INT, "num_buffer_fd", export_data->num_buffer_fd,
 486                 0);
 487
 488         send_ret = muse_core_msg_send_fd(muse_server_module_get_msg_fd(module), (int *)tfd, send_message);
 489
 490         muse_core_msg_free(send_message);
 491
 492         end_time = g_get_monotonic_time() + G_TIME_SPAN_SECOND;
 493         if (!g_cond_wait_until(&muse_recorder->camera_data.cond, &muse_recorder->camera_data.lock, end_time))
 494                 LOGW("video encode decision callback return message timeout");
 495
 496         g_mutex_unlock(&muse_recorder->camera_data.lock);
 497
 498         /*LOGD("returned video_encode_decision %d", muse_recorder->video_encode_decision);*/
 499
 500         return muse_recorder->video_encode_decision;
 501 }
 502
 503 bool _recorder_disp_foreach_supported_video_resolution_cb(int width, int height, void *user_data)
 504 {
 505         muse_module_h module = (muse_module_h)user_data;
 506
 507         recorder_return_val_if_fail(module, false);
 508
 509         muse_recorder_msg_event2(MUSE_RECORDER_CB_EVENT,
 510                 MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_RESOLUTION,
 511                 MUSE_RECORDER_EVENT_CLASS_THREAD_SUB,
 512                 module,
 513                 INT, width,
 514                 INT, height);
 515
 516         return true;
 517 }
 518
 519 bool _recorder_disp_foreach_supported_file_format_cb(recorder_file_format_e format, void *user_data)
 520 {
 521         muse_module_h module = (muse_module_h)user_data;
 522
 523         recorder_return_val_if_fail(module, false);
 524
 525         muse_recorder_msg_event1(MUSE_RECORDER_CB_EVENT,
 526                 MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_FILE_FORMAT,
 527                 MUSE_RECORDER_EVENT_CLASS_THREAD_SUB,
 528                 module,
 529                 INT, format);
 530
 531         return true;
 532 }
 533
 534 bool _recorder_disp_foreach_supported_audio_encoder_cb(recorder_audio_codec_e codec, void *user_data)
 535 {
 536         muse_module_h module = (muse_module_h)user_data;
 537
 538         recorder_return_val_if_fail(module, false);
 539
 540         muse_recorder_msg_event1(MUSE_RECORDER_CB_EVENT,
 541                 MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_AUDIO_ENCODER,
 542                 MUSE_RECORDER_EVENT_CLASS_THREAD_SUB,
 543                 module,
 544                 INT, codec);
 545
 546         return true;
 547 }
 548
 549 bool _recorder_disp_foreach_supported_video_encoder_cb(recorder_video_codec_e codec, void *user_data)
 550 {
 551         muse_module_h module = (muse_module_h)user_data;
 552
 553         recorder_return_val_if_fail(module, false);
 554
 555         muse_recorder_msg_event1(MUSE_RECORDER_CB_EVENT,
 556                 MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_ENCODER,
 557                 MUSE_RECORDER_EVENT_CLASS_THREAD_SUB,
 558                 module,
 559                 INT, codec);
 560
 561         return true;
 562 }
 563
 564
 565 static void _recorder_export_data_free(gpointer data)
 566 {
 567         muse_recorder_export_data *export_data = (muse_recorder_export_data *)data;
 568
 569         if (!export_data)
 570                 return;
 571
 572         /*LOGD("fd[%d], bo[%p]", export_data->fd, export_data->bo);*/
 573
 574         /* unref bo */
 575         if (export_data->bo) {
 576                 tbm_bo_unref(export_data->bo);
 577                 export_data->bo = NULL;
 578         } else {
 579                 LOGW("bo for fd[%d] is NULL", export_data->fd);
 580         }
 581
 582         /* close exported fd */
 583         if (export_data->fd > -1) {
 584                 /*LOGD("close export_data->fd %d", export_data->fd);*/
 585                 close(export_data->fd);
 586                 export_data->fd = -1;
 587         }
 588
 589         g_free(export_data);
 590 }
 591
 592
 593 static int _recorder_export_data_compare(gconstpointer data, gconstpointer fd_to_find)
 594 {
 595         /*LOGD("%d : %d", ((muse_recorder_export_data *)data)->fd, GPOINTER_TO_INT(fd_to_find));*/
 596         return (((muse_recorder_export_data *)data)->fd != GPOINTER_TO_INT(fd_to_find));
 597 }
 598
 599
 600 static gboolean _recorder_remove_export_data(muse_recorder_data_list *recorder_data, tbm_fd fd)
 601 {
 602         GList *found_item = NULL;
 603
 604         recorder_return_val_if_fail(recorder_data, FALSE);
 605         recorder_return_val_if_fail(fd >= -1, FALSE); /* -1 means "Remove all". */
 606
 607         g_mutex_lock(&recorder_data->lock);
 608
 609         if (fd == -1) {
 610                 g_list_free_full(recorder_data->list, _recorder_export_data_free);
 611                 recorder_data->list = NULL;
 612         } else {
 613                 found_item = g_list_find_custom(recorder_data->list,
 614                         GINT_TO_POINTER(fd), _recorder_export_data_compare);
 615                 if (!found_item) {
 616                         LOGE("could not find data for fd[%d]", fd);
 617                         g_mutex_unlock(&recorder_data->lock);
 618                         return FALSE;
 619                 }
 620
 621                 recorder_data->list = g_list_remove_link(recorder_data->list, found_item);
 622                 g_list_free_full(found_item, _recorder_export_data_free);
 623         }
 624
 625         g_mutex_unlock(&recorder_data->lock);
 626
 627         return TRUE;
 628 }
 629
 630
 631 bool _recorder_check_supported_feature(int type)
 632 {
 633         bool feature_supported = false;
 634         const char *feature_name = NULL;
 635
 636         recorder_return_val_if_fail(type == MUSE_RECORDER_TYPE_AUDIO || type == MUSE_RECORDER_TYPE_VIDEO, false);
 637
 638         if (type == MUSE_RECORDER_TYPE_AUDIO)
 639                 feature_name = AUDIO_RECORDING_FEATURE_NAME;
 640         else
 641                 feature_name = VIDEO_RECORDING_FEATURE_NAME;
 642
 643         if (muse_server_get_platform_info(feature_name, &feature_supported) != MM_ERROR_NONE)
 644                 LOGE("failed to get platform info for [%s]", feature_name);
 645
 646         LOGD("[%s] -> %d", feature_name, feature_supported);
 647
 648         return feature_supported;
 649 }
 650
 651
 652 int recorder_dispatcher_create(muse_module_h module)
 653 {
 654         int ret = RECORDER_ERROR_NONE;
 655         int recorder_type = MUSE_RECORDER_TYPE_AUDIO;
 656         int pid = 0;
 657         void *gdbus_connection = NULL;
 658         muse_recorder_api_e api = MUSE_RECORDER_API_CREATE;
 659         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
 660         intptr_t camera_handle = 0;
 661         muse_recorder_handle_s *muse_recorder = NULL;
 662         intptr_t handle = 0;
 663
 664         muse_recorder_msg_get(recorder_type, muse_server_module_get_msg(module));
 665
 666         LOGD("Enter - type %d", recorder_type);
 667
 668         /* init handle */
 669         muse_recorder = g_new0(muse_recorder_handle_s, 1);
 670
 671         muse_recorder->type = recorder_type;
 672         g_mutex_init(&muse_recorder->recorder_data.lock);
 673         g_cond_init(&muse_recorder->recorder_data.cond);
 674         g_mutex_init(&muse_recorder->camera_data.lock);
 675         g_cond_init(&muse_recorder->camera_data.cond);
 676
 677         if (muse_server_ipc_get_bufmgr(&muse_recorder->bufmgr) != MM_ERROR_NONE ||
 678                 muse_server_ipc_get_gdbus_connection((GDBusConnection **)&gdbus_connection) != MM_ERROR_NONE) {
 679                 LOGE("tbm bufmgr or gdbus connection failed %p %p", muse_recorder->bufmgr, gdbus_connection);
 680                 ret = RECORDER_ERROR_INVALID_OPERATION;
 681                 goto _CREATE_ERROR;
 682         }
 683
 684         if (recorder_type == MUSE_RECORDER_TYPE_VIDEO) {
 685                 muse_recorder_msg_get_pointer(camera_handle, muse_server_module_get_msg(module));
 686                 if (camera_handle == 0) {
 687                         LOGE("NULL handle");
 688                         ret = RECORDER_ERROR_INVALID_PARAMETER;
 689                         goto _CREATE_ERROR;
 690                 }
 691
 692                 muse_recorder->muse_camera = (muse_camera_handle_s *)camera_handle;
 693
 694                 ret = legacy_recorder_create_videorecorder(muse_recorder->muse_camera->camera_handle,
 695                         &muse_recorder->recorder_handle);
 696
 697                 LOGD("video type, camera handle : %p", muse_recorder->muse_camera->camera_handle);
 698         } else if (recorder_type == MUSE_RECORDER_TYPE_AUDIO) {
 699                 muse_recorder_msg_get(pid, muse_server_module_get_msg(module));
 700
 701                 LOGD("audio type - pid %d", pid);
 702
 703                 ret = legacy_recorder_create_audiorecorder(&muse_recorder->recorder_handle);
 704                 if (ret != RECORDER_ERROR_NONE) {
 705                         LOGE("create audio recorder failed");
 706                         goto _CREATE_ERROR;
 707                 }
 708
 709                 ret = legacy_recorder_set_client_pid(muse_recorder->recorder_handle, pid);
 710                 ret |= legacy_recorder_set_gdbus_connection(muse_recorder->recorder_handle, gdbus_connection);
 711         } else {
 712                 LOGE("unknown type %d", recorder_type);
 713                 ret = RECORDER_ERROR_INVALID_OPERATION;
 714         }
 715
 716         if (ret != RECORDER_ERROR_NONE)
 717                 goto _CREATE_ERROR;
 718
 719         /* recording feature check */
 720         if (!_recorder_check_supported_feature(recorder_type)) {
 721                 LOGE("feature NOT SUPPORTED, BUT INI FILE FOR RECORDER IS EXISTED. RECOMMEND TO REMOVE IT.");
 722                 ret = RECORDER_ERROR_NOT_SUPPORTED;
 723                 goto _CREATE_ERROR;
 724         }
 725
 726         ret = legacy_recorder_set_state_changed_cb(muse_recorder->recorder_handle,
 727                 (recorder_state_changed_cb)_recorder_disp_state_changed_cb,
 728                 (void *)module);
 729         if (ret != RECORDER_ERROR_NONE)
 730                 goto _CREATE_ERROR;
 731
 732         LOGD("recorder handle : %p, module : %p", muse_recorder, module);
 733
 734         handle = (intptr_t)muse_recorder->recorder_handle;
 735         muse_server_ipc_set_handle(module, (intptr_t)muse_recorder);
 736         muse_recorder_msg_return1(api, class, ret, module, POINTER, handle);
 737
 738         return MUSE_RECORDER_ERROR_NONE;
 739 //LCOV_EXCL_START
 740 _CREATE_ERROR:
 741         if (muse_recorder->recorder_handle) {
 742                 legacy_recorder_destroy(muse_recorder->recorder_handle);
 743                 muse_recorder->recorder_handle = NULL;
 744         }
 745
 746         g_cond_init(&muse_recorder->camera_data.cond);
 747         g_mutex_init(&muse_recorder->camera_data.lock);
 748         g_cond_init(&muse_recorder->recorder_data.cond);
 749         g_mutex_init(&muse_recorder->recorder_data.lock);
 750
 751         g_free(muse_recorder);
 752
 753         LOGE("error 0x%x", ret);
 754
 755         muse_recorder_msg_return(api, class, ret, module);
 756
 757         return MUSE_RECORDER_ERROR_INVALID;
 758 //LCOV_EXCL_STOP
 759 }
 760
 761 int recorder_dispatcher_destroy(muse_module_h module)
 762 {
 763         int ret = RECORDER_ERROR_NONE;
 764         muse_recorder_handle_s *muse_recorder = NULL;
 765         muse_recorder_api_e api = MUSE_RECORDER_API_DESTROY;
 766         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
 767
 768         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
 769
 770         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
 771
 772         ret = legacy_recorder_destroy(muse_recorder->recorder_handle);
 773         if (ret == RECORDER_ERROR_NONE) {
 774                 if (muse_recorder->recorder_data.list)
 775                         _recorder_remove_export_data(&muse_recorder->recorder_data, -1);
 776                 if (muse_recorder->camera_data.list) {
 777                         /* camera_remove_export_data() should not be called if no camera data,
 778                            otherwise it will be crashed because libmuse-recorder.so does not have dependency
 779                            to libmuse-camera.so which has camera_remove_export_data().
 780                            libmuse-camera.so will be loaded when camera_data is used. */
 781                         camera_remove_export_data(&muse_recorder->camera_data, -1);
 782                 }
 783
 784                 g_cond_clear(&muse_recorder->camera_data.cond);
 785                 g_mutex_clear(&muse_recorder->camera_data.lock);
 786                 g_cond_clear(&muse_recorder->recorder_data.cond);
 787                 g_mutex_clear(&muse_recorder->recorder_data.lock);
 788
 789                 muse_recorder->bufmgr = NULL;
 790
 791                 g_free(muse_recorder);
 792         } else {
 793                 LOGE("recorder destroy failed 0x%x", ret);
 794         }
 795
 796         muse_recorder_msg_return(api, class, ret, module);
 797
 798         if (ret == RECORDER_ERROR_NONE)
 799                 return MUSE_RECORDER_ERROR_NONE;
 800         else
 801                 return MUSE_RECORDER_ERROR_INVALID;
 802 }
 803
 804 int recorder_dispatcher_get_state(muse_module_h module)
 805 {
 806         int ret = RECORDER_ERROR_NONE;
 807         muse_recorder_api_e api = MUSE_RECORDER_API_GET_STATE;
 808         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
 809         recorder_state_e get_state = RECORDER_STATE_NONE;
 810         muse_recorder_handle_s *muse_recorder = NULL;
 811
 812         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
 813
 814         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
 815
 816         ret = legacy_recorder_get_state(muse_recorder->recorder_handle, &get_state);
 817
 818         muse_recorder_msg_return1(api, class, ret, module, INT, get_state);
 819
 820         return MUSE_RECORDER_ERROR_NONE;
 821 }
 822
 823 int recorder_dispatcher_prepare(muse_module_h module)
 824 {
 825         int ret = RECORDER_ERROR_NONE;
 826         int client_fd = -1;
 827         muse_recorder_api_e api = MUSE_RECORDER_API_PREPARE;
 828         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
 829         muse_recorder_handle_s *muse_recorder = NULL;
 830
 831         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
 832
 833         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
 834
 835         if (muse_recorder->type == MUSE_RECORDER_TYPE_VIDEO) {
 836                 client_fd = muse_server_module_get_msg_fd(module);
 837                 if (client_fd < 0) {
 838                         ret = RECORDER_ERROR_INVALID_OPERATION;
 839                         LOGE("failed to get fd %d", client_fd);
 840                         muse_recorder_msg_return(api, class, ret, module);
 841                         return MUSE_RECORDER_ERROR_INVALID;
 842                 }
 843
 844                 /* public privilege for camera */
 845                 if (!muse_server_security_check_cynara(client_fd, CAMERA_PRIVILEGE_NAME)) {
 846                         ret = RECORDER_ERROR_PERMISSION_DENIED;
 847                         LOGE("privilege[%s] failed 0x%x", CAMERA_PRIVILEGE_NAME, ret);
 848                         muse_recorder_msg_return(api, class, ret, module);
 849                         return MUSE_RECORDER_ERROR_INVALID;
 850                 }
 851
 852                 /* platform privilege for camera */
 853                 if (muse_recorder->muse_camera && muse_recorder->muse_camera->platform_privilege &&
 854                         !muse_server_security_check_cynara(client_fd, muse_recorder->muse_camera->platform_privilege)) {
 855                         ret = RECORDER_ERROR_PERMISSION_DENIED;
 856                         LOGE("privilege[%s] failed 0x%x", muse_recorder->muse_camera->platform_privilege, ret);
 857                         muse_recorder_msg_return(api, class, ret, module);
 858                         return MUSE_RECORDER_ERROR_INVALID;
 859                 }
 860         }
 861
 862         ret = legacy_recorder_prepare(muse_recorder->recorder_handle);
 863
 864         muse_recorder_msg_return(api, class, ret, module);
 865
 866         return MUSE_RECORDER_ERROR_NONE;
 867 }
 868
 869 int recorder_dispatcher_unprepare(muse_module_h module)
 870 {
 871         int ret = RECORDER_ERROR_NONE;
 872         muse_recorder_api_e api = MUSE_RECORDER_API_UNPREPARE;
 873         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
 874         muse_recorder_handle_s *muse_recorder = NULL;
 875
 876         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
 877
 878         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
 879
 880         ret = legacy_recorder_unprepare(muse_recorder->recorder_handle);
 881
 882         muse_recorder_msg_return(api, class, ret, module);
 883
 884         return MUSE_RECORDER_ERROR_NONE;
 885 }
 886
 887 int recorder_dispatcher_start(muse_module_h module)
 888 {
 889         int ret = RECORDER_ERROR_NONE;
 890         int client_fd = -1;
 891         muse_recorder_api_e api = MUSE_RECORDER_API_START;
 892         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
 893         muse_recorder_handle_s *muse_recorder = NULL;
 894
 895         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
 896
 897         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
 898
 899         /* privilege check */
 900         client_fd = muse_server_module_get_msg_fd(module);
 901         if (client_fd < 0) {
 902 //LCOV_EXCL_START
 903                 ret = RECORDER_ERROR_INVALID_OPERATION;
 904                 LOGE("failed to get fd %d", client_fd);
 905                 muse_recorder_msg_return(api, class, ret, module);
 906                 return MUSE_RECORDER_ERROR_INVALID;
 907 //LCOV_EXCL_STOP
 908         }
 909
 910         if (!muse_server_security_check_cynara(client_fd, RECORDER_PRIVILEGE_NAME)) {
 911 //LCOV_EXCL_START
 912                 LOGE("security(recorder) check failed");
 913                 ret = RECORDER_ERROR_PERMISSION_DENIED;
 914                 muse_recorder_msg_return(api, class, ret, module);
 915                 return MUSE_RECORDER_ERROR_INVALID;
 916 //LCOV_EXCL_STOP
 917         }
 918
 919         ret = legacy_recorder_start(muse_recorder->recorder_handle);
 920
 921         muse_recorder_msg_return(api, class, ret, module);
 922
 923         return MUSE_RECORDER_ERROR_NONE;
 924 }
 925
 926 int recorder_dispatcher_pause(muse_module_h module)
 927 {
 928         int ret = RECORDER_ERROR_NONE;
 929         muse_recorder_api_e api = MUSE_RECORDER_API_PAUSE;
 930         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
 931         muse_recorder_handle_s *muse_recorder = NULL;
 932
 933         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
 934
 935         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
 936
 937         ret = legacy_recorder_pause(muse_recorder->recorder_handle);
 938
 939         muse_recorder_msg_return(api, class, ret, module);
 940
 941         return MUSE_RECORDER_ERROR_NONE;
 942 }
 943
 944 int recorder_dispatcher_commit(muse_module_h module)
 945 {
 946         int ret = RECORDER_ERROR_NONE;
 947         muse_recorder_api_e api = MUSE_RECORDER_API_COMMIT;
 948         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
 949         muse_recorder_handle_s *muse_recorder = NULL;
 950
 951         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
 952
 953         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
 954
 955         ret = legacy_recorder_commit(muse_recorder->recorder_handle);
 956
 957         muse_recorder_msg_return(api, class, ret, module);
 958
 959         return MUSE_RECORDER_ERROR_NONE;
 960 }
 961
 962 int recorder_dispatcher_cancel(muse_module_h module)
 963 {
 964         int ret = RECORDER_ERROR_NONE;
 965         muse_recorder_api_e api = MUSE_RECORDER_API_CANCEL;
 966         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
 967         muse_recorder_handle_s *muse_recorder = NULL;
 968
 969         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
 970
 971         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
 972
 973         ret = legacy_recorder_cancel(muse_recorder->recorder_handle);
 974
 975         muse_recorder_msg_return(api, class, ret, module);
 976
 977         return MUSE_RECORDER_ERROR_NONE;
 978 }
 979
 980 int recorder_dispatcher_set_video_resolution(muse_module_h module)
 981 {
 982         int ret = RECORDER_ERROR_NONE;
 983         int width = 0;
 984         int height = 0;
 985         muse_recorder_api_e api = MUSE_RECORDER_API_SET_VIDEO_RESOLUTION;
 986         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
 987         muse_recorder_handle_s *muse_recorder = NULL;
 988
 989         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
 990
 991         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
 992
 993         muse_recorder_msg_get(width, muse_server_module_get_msg(module));
 994         muse_recorder_msg_get(height, muse_server_module_get_msg(module));
 995
 996         ret = legacy_recorder_set_video_resolution(muse_recorder->recorder_handle, width, height);
 997
 998         muse_recorder_msg_return(api, class, ret, module);
 999
1000         return MUSE_RECORDER_ERROR_NONE;
1001 }
1002
1003 int recorder_dispatcher_get_video_resolution(muse_module_h module)
1004 {
1005         int ret = RECORDER_ERROR_NONE;
1006         int get_width = 0;
1007         int get_height = 0;
1008         muse_recorder_api_e api = MUSE_RECORDER_API_GET_VIDEO_RESOLUTION;
1009         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1010         muse_recorder_handle_s *muse_recorder = NULL;
1011
1012         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1013
1014         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1015
1016         ret = legacy_recorder_get_video_resolution(muse_recorder->recorder_handle, &get_width, &get_height);
1017
1018         muse_recorder_msg_return2(api, class, ret, module,
1019                 INT, get_width,
1020                 INT, get_height);
1021
1022         return MUSE_RECORDER_ERROR_NONE;
1023 }
1024
1025 int recorder_dispatcher_foreach_supported_video_resolution(muse_module_h module)
1026 {
1027         int ret = RECORDER_ERROR_NONE;
1028         muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_VIDEO_RESOLUTION;
1029         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_THREAD_SUB;
1030         muse_recorder_handle_s *muse_recorder = NULL;
1031
1032         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1033
1034         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1035
1036         ret = legacy_recorder_foreach_supported_video_resolution(muse_recorder->recorder_handle,
1037                 (recorder_supported_video_resolution_cb)_recorder_disp_foreach_supported_video_resolution_cb,
1038                 (void *)module);
1039
1040         muse_recorder_msg_return(api, class, ret, module);
1041
1042         return MUSE_RECORDER_ERROR_NONE;
1043 }
1044
1045 int recorder_dispatcher_get_audio_level(muse_module_h module)
1046 {
1047         int ret = RECORDER_ERROR_NONE;
1048         double get_level = 0;
1049         muse_recorder_api_e api = MUSE_RECORDER_API_GET_AUDIO_LEVEL;
1050         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1051         muse_recorder_handle_s *muse_recorder = NULL;
1052
1053         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1054
1055         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1056
1057         ret = legacy_recorder_get_audio_level(muse_recorder->recorder_handle, &get_level);
1058
1059         muse_recorder_msg_return1(api, class, ret, module, DOUBLE, get_level);
1060
1061         return MUSE_RECORDER_ERROR_NONE;
1062 }
1063
1064 int recorder_dispatcher_set_filename(muse_module_h module)
1065 {
1066         int ret = RECORDER_ERROR_NONE;
1067         char set_filename[MUSE_RECORDER_MSG_MAX_LENGTH] = {0,};
1068         muse_recorder_api_e api = MUSE_RECORDER_API_SET_FILENAME;
1069         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1070         muse_recorder_handle_s *muse_recorder = NULL;
1071
1072         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1073
1074         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1075
1076         muse_recorder_msg_get_string(set_filename, muse_server_module_get_msg(module));
1077
1078         ret = legacy_recorder_set_filename(muse_recorder->recorder_handle, set_filename);
1079
1080         muse_recorder_msg_return(api, class, ret, module);
1081
1082         return MUSE_RECORDER_ERROR_NONE;
1083 }
1084
1085 int recorder_dispatcher_get_filename(muse_module_h module)
1086 {
1087         int ret = RECORDER_ERROR_NONE;
1088         char *get_filename = NULL;
1089         muse_recorder_api_e api = MUSE_RECORDER_API_GET_FILENAME;
1090         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1091         muse_recorder_handle_s *muse_recorder = NULL;
1092
1093         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1094
1095         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1096
1097         ret = legacy_recorder_get_filename(muse_recorder->recorder_handle, &get_filename);
1098         if (ret == RECORDER_ERROR_NONE && get_filename)
1099                 muse_recorder_msg_return1(api, class, ret, module, STRING, get_filename);
1100         else
1101                 muse_recorder_msg_return(api, class, ret, module);
1102
1103         if (get_filename) {
1104                 free(get_filename);
1105                 get_filename = NULL;
1106         }
1107
1108         return MUSE_RECORDER_ERROR_NONE;
1109 }
1110
1111 int recorder_dispatcher_set_file_format(muse_module_h module)
1112 {
1113         int ret = RECORDER_ERROR_NONE;
1114         recorder_file_format_e set_format = RECORDER_FILE_FORMAT_3GP;
1115         muse_recorder_api_e api = MUSE_RECORDER_API_SET_FILE_FORMAT;
1116         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1117         muse_recorder_handle_s *muse_recorder = NULL;
1118
1119         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1120
1121         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1122
1123         muse_recorder_msg_get(set_format, muse_server_module_get_msg(module));
1124
1125         ret = legacy_recorder_set_file_format(muse_recorder->recorder_handle, set_format);
1126
1127         muse_recorder_msg_return(api, class, ret, module);
1128
1129         return MUSE_RECORDER_ERROR_NONE;
1130 }
1131
1132 int recorder_dispatcher_get_file_format(muse_module_h module)
1133 {
1134         int ret = RECORDER_ERROR_NONE;
1135         recorder_file_format_e get_format = RECORDER_FILE_FORMAT_3GP;
1136         muse_recorder_api_e api = MUSE_RECORDER_API_GET_FILE_FORMAT;
1137         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1138         muse_recorder_handle_s *muse_recorder = NULL;
1139
1140         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1141
1142         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1143
1144         ret = legacy_recorder_get_file_format(muse_recorder->recorder_handle, &get_format);
1145
1146         muse_recorder_msg_return1(api, class, ret, module, INT, get_format);
1147
1148         return MUSE_RECORDER_ERROR_NONE;
1149 }
1150
1151 int recorder_dispatcher_set_state_changed_cb(muse_module_h module)
1152 {
1153         int ret = RECORDER_ERROR_NONE;
1154         muse_recorder_api_e api = MUSE_RECORDER_API_SET_STATE_CHANGED_CB;
1155         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1156
1157         LOGD("Enter");
1158
1159         muse_recorder_msg_return(api, class, ret, module);
1160
1161         return MUSE_RECORDER_ERROR_NONE;
1162 }
1163
1164 int recorder_dispatcher_unset_state_changed_cb(muse_module_h module)
1165 {
1166         int ret = RECORDER_ERROR_NONE;
1167         muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_STATE_CHANGED_CB;
1168         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1169
1170         LOGD("Enter");
1171
1172         muse_recorder_msg_return(api, class, ret, module);
1173
1174         return MUSE_RECORDER_ERROR_NONE;
1175 }
1176
1177 int recorder_dispatcher_set_interrupted_cb(muse_module_h module)
1178 {
1179         int ret = RECORDER_ERROR_NONE;
1180         muse_recorder_api_e api = MUSE_RECORDER_API_SET_INTERRUPTED_CB;
1181         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1182         muse_recorder_handle_s *muse_recorder = NULL;
1183
1184         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1185
1186         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1187
1188         ret = legacy_recorder_set_interrupted_cb(muse_recorder->recorder_handle,
1189                 (recorder_interrupted_cb)_recorder_disp_interrupted_cb,
1190                 (void *)module);
1191
1192         muse_recorder_msg_return(api, class, ret, module);
1193
1194         return MUSE_RECORDER_ERROR_NONE;
1195 }
1196
1197 int recorder_dispatcher_unset_interrupted_cb(muse_module_h module)
1198 {
1199         int ret = RECORDER_ERROR_NONE;
1200         muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_INTERRUPTED_CB;
1201         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1202         muse_recorder_handle_s *muse_recorder = NULL;
1203
1204         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1205
1206         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1207
1208         ret = legacy_recorder_unset_interrupted_cb(muse_recorder->recorder_handle);
1209
1210         muse_recorder_msg_return(api, class, ret, module);
1211
1212         return MUSE_RECORDER_ERROR_NONE;
1213 }
1214
1215 int recorder_dispatcher_set_interrupt_started_cb(muse_module_h module)
1216 {
1217         int ret = RECORDER_ERROR_NONE;
1218         muse_recorder_api_e api = MUSE_RECORDER_API_SET_INTERRUPT_STARTED_CB;
1219         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1220         muse_recorder_handle_s *muse_recorder = NULL;
1221
1222         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1223
1224         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1225
1226         ret = legacy_recorder_set_interrupt_started_cb(muse_recorder->recorder_handle,
1227                 (recorder_interrupt_started_cb)_recorder_disp_interrupt_started_cb,
1228                 (void *)module);
1229
1230         muse_recorder_msg_return(api, class, ret, module);
1231
1232         return MUSE_RECORDER_ERROR_NONE;
1233 }
1234
1235 int recorder_dispatcher_unset_interrupt_started_cb(muse_module_h module)
1236 {
1237         int ret = RECORDER_ERROR_NONE;
1238         muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_INTERRUPT_STARTED_CB;
1239         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1240         muse_recorder_handle_s *muse_recorder = NULL;
1241
1242         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1243
1244         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1245
1246         ret = legacy_recorder_unset_interrupt_started_cb(muse_recorder->recorder_handle);
1247
1248         muse_recorder_msg_return(api, class, ret, module);
1249
1250         return MUSE_RECORDER_ERROR_NONE;
1251 }
1252
1253 int recorder_dispatcher_set_audio_stream_cb(muse_module_h module)
1254 {
1255         int ret = RECORDER_ERROR_NONE;
1256         muse_recorder_api_e api = MUSE_RECORDER_API_SET_AUDIO_STREAM_CB;
1257         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1258         muse_recorder_handle_s *muse_recorder = NULL;
1259
1260         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1261
1262         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1263
1264         ret = legacy_recorder_set_audio_stream_cb(muse_recorder->recorder_handle,
1265                 (recorder_audio_stream_cb)_recorder_disp_audio_stream_cb, (void *)module);
1266
1267         muse_recorder_msg_return(api, class, ret, module);
1268
1269         return MUSE_RECORDER_ERROR_NONE;
1270 }
1271
1272 int recorder_dispatcher_unset_audio_stream_cb(muse_module_h module)
1273 {
1274         int ret = RECORDER_ERROR_NONE;
1275         muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_AUDIO_STREAM_CB;
1276         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1277         muse_recorder_handle_s *muse_recorder = NULL;
1278
1279         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1280
1281         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1282
1283         ret = legacy_recorder_unset_audio_stream_cb(muse_recorder->recorder_handle);
1284
1285         muse_recorder_msg_return(api, class, ret, module);
1286
1287         return MUSE_RECORDER_ERROR_NONE;
1288 }
1289
1290 int recorder_dispatcher_set_error_cb(muse_module_h module)
1291 {
1292         int ret = RECORDER_ERROR_NONE;
1293         muse_recorder_api_e api = MUSE_RECORDER_API_SET_ERROR_CB;
1294         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1295         muse_recorder_handle_s *muse_recorder = NULL;
1296
1297         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1298
1299         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1300
1301         ret = legacy_recorder_set_error_cb(muse_recorder->recorder_handle,
1302                 (recorder_error_cb)_recorder_disp_error_cb,
1303                 (void *)module);
1304
1305         muse_recorder_msg_return(api, class, ret, module);
1306
1307         return MUSE_RECORDER_ERROR_NONE;
1308 }
1309
1310 int recorder_dispatcher_unset_error_cb(muse_module_h module)
1311 {
1312         int ret = RECORDER_ERROR_NONE;
1313         muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_ERROR_CB;
1314         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1315         muse_recorder_handle_s *muse_recorder = NULL;
1316
1317         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1318
1319         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1320
1321         ret = legacy_recorder_unset_error_cb(muse_recorder->recorder_handle);
1322
1323         muse_recorder_msg_return(api, class, ret, module);
1324
1325         return MUSE_RECORDER_ERROR_NONE;
1326 }
1327
1328 int recorder_dispatcher_set_recording_status_cb(muse_module_h module)
1329 {
1330         int ret = RECORDER_ERROR_NONE;
1331         muse_recorder_api_e api = MUSE_RECORDER_API_SET_RECORDING_STATUS_CB;
1332         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1333         muse_recorder_handle_s *muse_recorder = NULL;
1334
1335         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1336
1337         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1338
1339         ret = legacy_recorder_set_recording_status_cb(muse_recorder->recorder_handle,
1340                 (recorder_recording_status_cb)_recorder_disp_recording_status_cb,
1341                 (void *)module);
1342
1343         muse_recorder_msg_return(api, class, ret, module);
1344
1345         return MUSE_RECORDER_ERROR_NONE;
1346 }
1347
1348 int recorder_dispatcher_unset_recording_status_cb(muse_module_h module)
1349 {
1350         int ret = RECORDER_ERROR_NONE;
1351         muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_RECORDING_STATUS_CB;
1352         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1353         muse_recorder_handle_s *muse_recorder = NULL;
1354
1355         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1356
1357         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1358
1359         ret = legacy_recorder_unset_recording_status_cb(muse_recorder->recorder_handle);
1360
1361         muse_recorder_msg_return(api, class, ret, module);
1362
1363         return MUSE_RECORDER_ERROR_NONE;
1364 }
1365
1366 int recorder_dispatcher_set_recording_limit_reached_cb(muse_module_h module)
1367 {
1368         int ret = RECORDER_ERROR_NONE;
1369         muse_recorder_api_e api = MUSE_RECORDER_API_SET_RECORDING_LIMIT_REACHED_CB;
1370         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1371         muse_recorder_handle_s *muse_recorder = NULL;
1372
1373         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1374
1375         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1376
1377         ret = legacy_recorder_set_recording_limit_reached_cb(muse_recorder->recorder_handle,
1378                 (recorder_recording_limit_reached_cb)_recorder_disp_recording_limit_reached_cb,
1379                 (void *)module);
1380
1381         muse_recorder_msg_return(api, class, ret, module);
1382
1383         return MUSE_RECORDER_ERROR_NONE;
1384 }
1385
1386 int recorder_dispatcher_unset_recording_limit_reached_cb(muse_module_h module)
1387 {
1388         int ret = RECORDER_ERROR_NONE;
1389         muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_RECORDING_LIMIT_REACHED_CB;
1390         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1391         muse_recorder_handle_s *muse_recorder = NULL;
1392
1393         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1394
1395         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1396
1397         ret = legacy_recorder_unset_recording_limit_reached_cb(muse_recorder->recorder_handle);
1398
1399         muse_recorder_msg_return(api, class, ret, module);
1400
1401         return MUSE_RECORDER_ERROR_NONE;
1402 }
1403
1404 int recorder_dispatcher_foreach_supported_file_format(muse_module_h module)
1405 {
1406         int ret = RECORDER_ERROR_NONE;
1407         muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_FILE_FORMAT;
1408         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_THREAD_SUB;
1409         muse_recorder_handle_s *muse_recorder = NULL;
1410
1411         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1412
1413         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1414
1415         ret = legacy_recorder_foreach_supported_file_format(muse_recorder->recorder_handle,
1416                 (recorder_supported_file_format_cb)_recorder_disp_foreach_supported_file_format_cb,
1417                 NULL,
1418                 0,
1419                 (void *)module);
1420
1421         muse_recorder_msg_return(api, class, ret, module);
1422
1423         return MUSE_RECORDER_ERROR_NONE;
1424 }
1425
1426 //LCOV_EXCL_START
1427 int recorder_dispatcher_foreach_supported_file_format_by_audio_encoder(muse_module_h module)
1428 {
1429         int ret = RECORDER_ERROR_NONE;
1430         int audio_codec = RECORDER_AUDIO_CODEC_DISABLE;
1431         muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_FILE_FORMAT_BY_AUDIO_ENCORDER;
1432         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_THREAD_SUB;
1433         muse_recorder_handle_s *muse_recorder = NULL;
1434
1435         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1436
1437         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1438
1439         muse_recorder_msg_get(audio_codec, muse_server_module_get_msg(module));
1440
1441         ret = legacy_recorder_foreach_supported_file_format(muse_recorder->recorder_handle,
1442                 (recorder_supported_file_format_cb)_recorder_disp_foreach_supported_file_format_cb,
1443                 MMCAM_AUDIO_ENCODER,
1444                 audio_codec,
1445                 (void *)module);
1446
1447         muse_recorder_msg_return(api, class, ret, module);
1448
1449         return MUSE_RECORDER_ERROR_NONE;
1450 }
1451
1452 int recorder_dispatcher_foreach_supported_file_format_by_video_encoder(muse_module_h module)
1453 {
1454         int ret = RECORDER_ERROR_NONE;
1455         int video_codec = -1;
1456         muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_FILE_FORMAT_BY_VIDEO_ENCORDER;
1457         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_THREAD_SUB;
1458         muse_recorder_handle_s *muse_recorder = NULL;
1459
1460         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1461
1462         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1463
1464         muse_recorder_msg_get(video_codec, muse_server_module_get_msg(module));
1465
1466         ret = legacy_recorder_foreach_supported_file_format(muse_recorder->recorder_handle,
1467                 (recorder_supported_file_format_cb)_recorder_disp_foreach_supported_file_format_cb,
1468                 MMCAM_VIDEO_ENCODER,
1469                 video_codec,
1470                 (void *)module);
1471
1472         muse_recorder_msg_return(api, class, ret, module);
1473
1474         return MUSE_RECORDER_ERROR_NONE;
1475 }
1476 //LCOV_EXCL_STOP
1477
1478 int recorder_dispatcher_attr_set_size_limit(muse_module_h module)
1479 {
1480         int ret = RECORDER_ERROR_NONE;
1481         int kbyte = 0;
1482         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_SIZE_LIMIT;
1483         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1484         muse_recorder_handle_s *muse_recorder = NULL;
1485
1486         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1487
1488         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1489
1490         muse_recorder_msg_get(kbyte, muse_server_module_get_msg(module));
1491
1492         ret = legacy_recorder_attr_set_size_limit(muse_recorder->recorder_handle, kbyte);
1493
1494         muse_recorder_msg_return(api, class, ret, module);
1495
1496         return MUSE_RECORDER_ERROR_NONE;
1497 }
1498
1499 int recorder_dispatcher_attr_set_time_limit(muse_module_h module)
1500 {
1501         int ret = RECORDER_ERROR_NONE;
1502         int second = 0;
1503         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_TIME_LIMIT;
1504         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1505         muse_recorder_handle_s *muse_recorder = NULL;
1506
1507         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1508
1509         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1510
1511         muse_recorder_msg_get(second, muse_server_module_get_msg(module));
1512
1513         ret = legacy_recorder_attr_set_time_limit(muse_recorder->recorder_handle, second);
1514
1515         muse_recorder_msg_return(api, class, ret, module);
1516
1517         return MUSE_RECORDER_ERROR_NONE;
1518 }
1519
1520 int recorder_dispatcher_attr_set_audio_device(muse_module_h module)
1521 {
1522         int ret = RECORDER_ERROR_NONE;
1523         recorder_audio_device_e set_device = RECORDER_AUDIO_DEVICE_MIC;
1524         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_AUDIO_DEVICE;
1525         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1526         muse_recorder_handle_s *muse_recorder = NULL;
1527
1528         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1529
1530         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1531
1532         muse_recorder_msg_get(set_device, muse_server_module_get_msg(module));
1533
1534         ret = legacy_recorder_attr_set_audio_device(muse_recorder->recorder_handle, set_device);
1535
1536         muse_recorder_msg_return(api, class, ret, module);
1537
1538         return MUSE_RECORDER_ERROR_NONE;
1539 }
1540
1541 int recorder_dispatcher_set_audio_encoder(muse_module_h module)
1542 {
1543         int ret = RECORDER_ERROR_NONE;
1544         recorder_audio_codec_e set_codec = RECORDER_AUDIO_CODEC_AMR;
1545         muse_recorder_api_e api = MUSE_RECORDER_API_SET_AUDIO_ENCODER;
1546         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1547         muse_recorder_handle_s *muse_recorder = NULL;
1548
1549         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1550
1551         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1552
1553         muse_recorder_msg_get(set_codec, muse_server_module_get_msg(module));
1554
1555         ret = legacy_recorder_set_audio_encoder(muse_recorder->recorder_handle, set_codec);
1556
1557         muse_recorder_msg_return(api, class, ret, module);
1558
1559         return MUSE_RECORDER_ERROR_NONE;
1560 }
1561
1562 int recorder_dispatcher_get_audio_encoder(muse_module_h module)
1563 {
1564         int ret = RECORDER_ERROR_NONE;
1565         recorder_audio_codec_e get_codec = RECORDER_AUDIO_CODEC_AMR;
1566         muse_recorder_api_e api = MUSE_RECORDER_API_GET_AUDIO_ENCODER;
1567         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1568         muse_recorder_handle_s *muse_recorder = NULL;
1569
1570         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1571
1572         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1573
1574         ret = legacy_recorder_get_audio_encoder(muse_recorder->recorder_handle, &get_codec);
1575
1576         muse_recorder_msg_return1(api, class, ret, module, INT, get_codec);
1577
1578         return MUSE_RECORDER_ERROR_NONE;
1579 }
1580
1581 int recorder_dispatcher_set_video_encoder(muse_module_h module)
1582 {
1583         int ret = RECORDER_ERROR_NONE;
1584         recorder_video_codec_e set_codec = RECORDER_VIDEO_CODEC_MPEG4;
1585         muse_recorder_api_e api = MUSE_RECORDER_API_SET_VIDEO_ENCODER;
1586         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1587         muse_recorder_handle_s *muse_recorder = NULL;
1588
1589         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1590
1591         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1592
1593         muse_recorder_msg_get(set_codec, muse_server_module_get_msg(module));
1594
1595         ret = legacy_recorder_set_video_encoder(muse_recorder->recorder_handle, set_codec);
1596
1597         muse_recorder_msg_return(api, class, ret, module);
1598
1599         return MUSE_RECORDER_ERROR_NONE;
1600 }
1601
1602 int recorder_dispatcher_get_video_encoder(muse_module_h module)
1603 {
1604         int ret = RECORDER_ERROR_NONE;
1605         recorder_video_codec_e get_codec = RECORDER_VIDEO_CODEC_MPEG4;
1606         muse_recorder_api_e api = MUSE_RECORDER_API_GET_VIDEO_ENCODER;
1607         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1608         muse_recorder_handle_s *muse_recorder = NULL;
1609
1610         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1611
1612         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1613
1614         ret = legacy_recorder_get_video_encoder(muse_recorder->recorder_handle, &get_codec);
1615
1616         muse_recorder_msg_return1(api, class, ret, module, INT, get_codec);
1617
1618         return MUSE_RECORDER_ERROR_NONE;
1619 }
1620
1621 int recorder_dispatcher_attr_set_audio_samplerate(muse_module_h module)
1622 {
1623         int ret = RECORDER_ERROR_NONE;
1624         int samplerate = 0;
1625         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_AUDIO_SAMPLERATE;
1626         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1627         muse_recorder_handle_s *muse_recorder = NULL;
1628
1629         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1630
1631         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1632
1633         muse_recorder_msg_get(samplerate, muse_server_module_get_msg(module));
1634
1635         ret = legacy_recorder_attr_set_audio_samplerate(muse_recorder->recorder_handle, samplerate);
1636
1637         muse_recorder_msg_return(api, class, ret, module);
1638
1639         return MUSE_RECORDER_ERROR_NONE;
1640 }
1641
1642 int recorder_dispatcher_attr_set_audio_encoder_bitrate(muse_module_h module)
1643 {
1644         int ret = RECORDER_ERROR_NONE;
1645         int bitrate = 0;
1646         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_AUDIO_ENCODER_BITRATE;
1647         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1648         muse_recorder_handle_s *muse_recorder = NULL;
1649
1650         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1651
1652         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1653
1654         muse_recorder_msg_get(bitrate, muse_server_module_get_msg(module));
1655
1656         ret = legacy_recorder_attr_set_audio_encoder_bitrate(muse_recorder->recorder_handle, bitrate);
1657
1658         muse_recorder_msg_return(api, class, ret, module);
1659
1660         return MUSE_RECORDER_ERROR_NONE;
1661 }
1662
1663 int recorder_dispatcher_attr_set_video_encoder_bitrate(muse_module_h module)
1664 {
1665         int ret = RECORDER_ERROR_NONE;
1666         int bitrate = 0;
1667         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_VIDEO_ENCODER_BITRATE;
1668         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1669         muse_recorder_handle_s *muse_recorder = NULL;
1670
1671         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1672
1673         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1674
1675         muse_recorder_msg_get(bitrate, muse_server_module_get_msg(module));
1676
1677         ret = legacy_recorder_attr_set_video_encoder_bitrate(muse_recorder->recorder_handle, bitrate);
1678
1679         muse_recorder_msg_return(api, class, ret, module);
1680
1681         return MUSE_RECORDER_ERROR_NONE;
1682 }
1683
1684 int recorder_dispatcher_attr_get_size_limit(muse_module_h module)
1685 {
1686         int ret = RECORDER_ERROR_NONE;
1687         int get_kbyte = 0;
1688         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_SIZE_LIMIT;
1689         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1690         muse_recorder_handle_s *muse_recorder = NULL;
1691
1692         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1693
1694         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1695
1696         ret = legacy_recorder_attr_get_size_limit(muse_recorder->recorder_handle, &get_kbyte);
1697
1698         muse_recorder_msg_return1(api, class, ret, module, INT, get_kbyte);
1699
1700         return MUSE_RECORDER_ERROR_NONE;
1701 }
1702
1703 int recorder_dispatcher_attr_get_time_limit(muse_module_h module)
1704 {
1705         int ret = RECORDER_ERROR_NONE;
1706         int get_second = 0;
1707         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_TIME_LIMIT;
1708         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1709         muse_recorder_handle_s *muse_recorder = NULL;
1710
1711         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1712
1713         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1714
1715         ret = legacy_recorder_attr_get_time_limit(muse_recorder->recorder_handle, &get_second);
1716
1717         muse_recorder_msg_return1(api, class, ret, module, INT, get_second);
1718
1719         return MUSE_RECORDER_ERROR_NONE;
1720 }
1721
1722 int recorder_dispatcher_attr_get_audio_device(muse_module_h module)
1723 {
1724         int ret = RECORDER_ERROR_NONE;
1725         recorder_audio_device_e get_device = RECORDER_AUDIO_DEVICE_MIC;
1726         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_AUDIO_DEVICE;
1727         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1728         muse_recorder_handle_s *muse_recorder = NULL;
1729
1730         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1731
1732         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1733
1734         ret = legacy_recorder_attr_get_audio_device(muse_recorder->recorder_handle, &get_device);
1735
1736         muse_recorder_msg_return1(api, class, ret, module, INT, get_device);
1737
1738         return MUSE_RECORDER_ERROR_NONE;
1739 }
1740
1741 int recorder_dispatcher_attr_get_audio_samplerate(muse_module_h module)
1742 {
1743         int ret = RECORDER_ERROR_NONE;
1744         int get_samplerate = 0;
1745         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_AUDIO_SAMPLERATE;
1746         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1747         muse_recorder_handle_s *muse_recorder = NULL;
1748
1749         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1750
1751         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1752
1753         ret = legacy_recorder_attr_get_audio_samplerate(muse_recorder->recorder_handle, &get_samplerate);
1754
1755         muse_recorder_msg_return1(api, class, ret, module, INT, get_samplerate);
1756
1757         return MUSE_RECORDER_ERROR_NONE;
1758 }
1759
1760 int recorder_dispatcher_attr_get_audio_encoder_bitrate(muse_module_h module)
1761 {
1762         int ret = RECORDER_ERROR_NONE;
1763         int get_bitrate = 0;
1764         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_AUDIO_ENCODER_BITRATE;
1765         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1766         muse_recorder_handle_s *muse_recorder = NULL;
1767
1768         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1769
1770         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1771
1772         ret = legacy_recorder_attr_get_audio_encoder_bitrate(muse_recorder->recorder_handle, &get_bitrate);
1773
1774         muse_recorder_msg_return1(api, class, ret, module, INT, get_bitrate);
1775
1776         return MUSE_RECORDER_ERROR_NONE;
1777 }
1778
1779 int recorder_dispatcher_attr_get_video_encoder_bitrate(muse_module_h module)
1780 {
1781         int ret = RECORDER_ERROR_NONE;
1782         int get_bitrate = 0;
1783         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_VIDEO_ENCODER_BITRATE;
1784         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1785         muse_recorder_handle_s *muse_recorder = NULL;
1786
1787         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1788
1789         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1790
1791         ret = legacy_recorder_attr_get_video_encoder_bitrate(muse_recorder->recorder_handle, &get_bitrate);
1792
1793         muse_recorder_msg_return1(api, class, ret, module, INT, get_bitrate);
1794
1795         return MUSE_RECORDER_ERROR_NONE;
1796 }
1797
1798 int recorder_dispatcher_foreach_supported_audio_encoder(muse_module_h module)
1799 {
1800         int ret = RECORDER_ERROR_NONE;
1801         muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_AUDIO_ENCODER;
1802         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_THREAD_SUB;
1803         muse_recorder_handle_s *muse_recorder = NULL;
1804
1805         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1806
1807         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1808
1809         ret = legacy_recorder_foreach_supported_audio_encoder(muse_recorder->recorder_handle,
1810                 (recorder_supported_audio_encoder_cb)_recorder_disp_foreach_supported_audio_encoder_cb,
1811                 NULL,
1812                 0,
1813                 (void *)module);
1814
1815         muse_recorder_msg_return(api, class, ret, module);
1816
1817         return MUSE_RECORDER_ERROR_NONE;
1818 }
1819
1820 //LCOV_EXCL_START
1821 int recorder_dispatcher_foreach_supported_audio_encoder_by_file_format(muse_module_h module)
1822 {
1823         int ret = RECORDER_ERROR_NONE;
1824         int file_format = -1;
1825         muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_AUDIO_ENCODER_BY_FILE_FORMAT;
1826         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_THREAD_SUB;
1827         muse_recorder_handle_s *muse_recorder = NULL;
1828
1829         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1830
1831         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1832
1833         muse_recorder_msg_get(file_format, muse_server_module_get_msg(module));
1834
1835         ret = legacy_recorder_foreach_supported_audio_encoder(muse_recorder->recorder_handle,
1836                 (recorder_supported_audio_encoder_cb)_recorder_disp_foreach_supported_audio_encoder_cb,
1837                 MMCAM_AUDIO_ENCODER,
1838                 file_format,
1839                 (void *)module);
1840
1841         muse_recorder_msg_return(api, class, ret, module);
1842
1843         return MUSE_RECORDER_ERROR_NONE;
1844 }
1845 //LCOV_EXCL_STOP
1846
1847 int recorder_dispatcher_foreach_supported_video_encoder(muse_module_h module)
1848 {
1849         int ret = RECORDER_ERROR_NONE;
1850         muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_VIDEO_ENCODER;
1851         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_THREAD_SUB;
1852         muse_recorder_handle_s *muse_recorder = NULL;
1853
1854         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1855
1856         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1857
1858         ret = legacy_recorder_foreach_supported_video_encoder(muse_recorder->recorder_handle,
1859                 (recorder_supported_video_encoder_cb)_recorder_disp_foreach_supported_video_encoder_cb,
1860                 NULL,
1861                 0,
1862                 (void *)module);
1863
1864         muse_recorder_msg_return(api, class, ret, module);
1865
1866         return MUSE_RECORDER_ERROR_NONE;
1867 }
1868
1869 //LCOV_EXCL_START
1870 int recorder_dispatcher_foreach_supported_video_encoder_by_file_format(muse_module_h module)
1871 {
1872         int ret = RECORDER_ERROR_NONE;
1873         int file_format = -1;
1874         muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_VIDEO_ENCODER_BY_FILE_FORMAT;
1875         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_THREAD_SUB;
1876         muse_recorder_handle_s *muse_recorder = NULL;
1877
1878         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1879
1880         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1881
1882         muse_recorder_msg_get(file_format, muse_server_module_get_msg(module));
1883
1884         ret = legacy_recorder_foreach_supported_video_encoder(muse_recorder->recorder_handle,
1885                 (recorder_supported_video_encoder_cb)_recorder_disp_foreach_supported_video_encoder_cb,
1886                 MMCAM_VIDEO_ENCODER,
1887                 file_format,
1888                 (void *)module);
1889
1890         muse_recorder_msg_return(api, class, ret, module);
1891
1892         return MUSE_RECORDER_ERROR_NONE;
1893 }
1894 //LCOV_EXCL_STOP
1895
1896 int recorder_dispatcher_attr_set_mute(muse_module_h module)
1897 {
1898         int ret = RECORDER_ERROR_NONE;
1899         int set_enable = 0;
1900         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_MUTE;
1901         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1902         muse_recorder_handle_s *muse_recorder = NULL;
1903
1904         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1905
1906         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1907
1908         muse_recorder_msg_get(set_enable, muse_server_module_get_msg(module));
1909
1910         ret = legacy_recorder_attr_set_mute(muse_recorder->recorder_handle, (bool)set_enable);
1911
1912         muse_recorder_msg_return(api, class, ret, module);
1913
1914         return MUSE_RECORDER_ERROR_NONE;
1915 }
1916
1917 int recorder_dispatcher_attr_is_muted(muse_module_h module)
1918 {
1919         int ret = RECORDER_ERROR_NONE;
1920         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_IS_MUTED;
1921         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1922         muse_recorder_handle_s *muse_recorder = NULL;
1923
1924         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1925
1926         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1927
1928         ret = legacy_recorder_attr_is_muted(muse_recorder->recorder_handle);
1929
1930         muse_recorder_msg_return(api, class, ret, module);
1931
1932         return MUSE_RECORDER_ERROR_NONE;
1933 }
1934
1935 int recorder_dispatcher_attr_set_recording_motion_rate(muse_module_h module)
1936 {
1937         int ret = RECORDER_ERROR_NONE;
1938         double rate = 1.0;
1939         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_RECORDING_MOTION_RATE;
1940         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1941         muse_recorder_handle_s *muse_recorder = NULL;
1942
1943         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1944
1945         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1946
1947         muse_recorder_msg_get_double(rate, muse_server_module_get_msg(module));
1948
1949         ret = legacy_recorder_attr_set_recording_motion_rate(muse_recorder->recorder_handle, rate);
1950
1951         muse_recorder_msg_return(api, class, ret, module);
1952
1953         return MUSE_RECORDER_ERROR_NONE;
1954 }
1955
1956 int recorder_dispatcher_attr_get_recording_motion_rate(muse_module_h module)
1957 {
1958         int ret = RECORDER_ERROR_NONE;
1959         double get_rate = 1.0;
1960         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_RECORDING_MOTION_RATE;
1961         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1962         muse_recorder_handle_s *muse_recorder = NULL;
1963
1964         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1965
1966         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1967
1968         ret = legacy_recorder_attr_get_recording_motion_rate(muse_recorder->recorder_handle, &get_rate);
1969
1970         LOGD("get rate %lf", get_rate);
1971
1972         muse_recorder_msg_return1(api, class, ret, module, DOUBLE, get_rate);
1973
1974         return MUSE_RECORDER_ERROR_NONE;
1975 }
1976
1977 int recorder_dispatcher_attr_set_audio_channel(muse_module_h module)
1978 {
1979         int ret = RECORDER_ERROR_NONE;
1980         int channel_count = 0;
1981         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_AUDIO_CHANNEL;
1982         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
1983         muse_recorder_handle_s *muse_recorder = NULL;
1984
1985         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
1986
1987         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
1988
1989         muse_recorder_msg_get(channel_count, muse_server_module_get_msg(module));
1990
1991         ret = legacy_recorder_attr_set_audio_channel(muse_recorder->recorder_handle, channel_count);
1992
1993         muse_recorder_msg_return(api, class, ret, module);
1994
1995         return MUSE_RECORDER_ERROR_NONE;
1996 }
1997
1998 int recorder_dispatcher_attr_get_audio_channel(muse_module_h module)
1999 {
2000         int ret = RECORDER_ERROR_NONE;
2001         int get_channel_count = 0;
2002         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_AUDIO_CHANNEL;
2003         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
2004         muse_recorder_handle_s *muse_recorder = NULL;
2005
2006         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
2007
2008         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
2009
2010         ret = legacy_recorder_attr_get_audio_channel(muse_recorder->recorder_handle, &get_channel_count);
2011
2012         muse_recorder_msg_return1(api, class, ret, module, INT, get_channel_count);
2013
2014         return MUSE_RECORDER_ERROR_NONE;
2015 }
2016
2017 int recorder_dispatcher_attr_set_orientation_tag(muse_module_h module)
2018 {
2019         int ret = RECORDER_ERROR_NONE;
2020         recorder_rotation_e set_orientation = RECORDER_ROTATION_NONE;
2021         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_ORIENTATION_TAG;
2022         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
2023         muse_recorder_handle_s *muse_recorder = NULL;
2024
2025         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
2026
2027         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
2028
2029         muse_recorder_msg_get(set_orientation, muse_server_module_get_msg(module));
2030
2031         ret = legacy_recorder_attr_set_orientation_tag(muse_recorder->recorder_handle, set_orientation);
2032
2033         muse_recorder_msg_return(api, class, ret, module);
2034
2035         return MUSE_RECORDER_ERROR_NONE;
2036 }
2037
2038 int recorder_dispatcher_attr_get_orientation_tag(muse_module_h module)
2039 {
2040         int ret = RECORDER_ERROR_NONE;
2041         recorder_rotation_e get_orientation = RECORDER_ROTATION_NONE;
2042         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_ORIENTATION_TAG;
2043         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
2044         muse_recorder_handle_s *muse_recorder = NULL;
2045
2046         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
2047
2048         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
2049
2050         ret = legacy_recorder_attr_get_orientation_tag(muse_recorder->recorder_handle, &get_orientation);
2051
2052         muse_recorder_msg_return1(api, class, ret, module, INT, get_orientation);
2053
2054         return MUSE_RECORDER_ERROR_NONE;
2055 }
2056
2057 int recorder_dispatcher_attr_set_root_directory(muse_module_h module)
2058 {
2059         int ret = RECORDER_ERROR_NONE;
2060         char root_directory[MUSE_RECORDER_MSG_MAX_LENGTH] = {0,};
2061         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_ROOT_DIRECTORY;
2062         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
2063         muse_recorder_handle_s *muse_recorder = NULL;
2064
2065         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
2066
2067         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
2068
2069         muse_recorder_msg_get_string(root_directory, muse_server_module_get_msg(module));
2070
2071         ret = legacy_recorder_attr_set_root_directory(muse_recorder->recorder_handle, root_directory);
2072
2073         muse_recorder_msg_return(api, class, ret, module);
2074
2075         return MUSE_RECORDER_ERROR_NONE;
2076 }
2077
2078 int recorder_dispatcher_return_buffer(muse_module_h module)
2079 {
2080         int ret_fd = -1;
2081         int video_encode_decision = 1;
2082         muse_recorder_buffer_type_e buffer_type = MUSE_RECORDER_BUFFER_TYPE_AUDIO_STREAM;
2083         muse_recorder_handle_s *muse_recorder = NULL;
2084
2085         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
2086
2087         recorder_return_val_if_fail(muse_recorder, MUSE_RECORDER_ERROR_NONE);
2088
2089         muse_recorder_msg_get(ret_fd, muse_server_module_get_msg(module));
2090         muse_recorder_msg_get(buffer_type, muse_server_module_get_msg(module));
2091
2092         /*LOGD("handle[%p] buffer type[%d] ret_fd[%d]", muse_recorder, buffer_type, ret_fd);*/
2093
2094         if (buffer_type == MUSE_RECORDER_BUFFER_TYPE_VIDEO_ENCODE_DECISION) {
2095                 /* get decision and send signal */
2096                 muse_recorder_msg_get(video_encode_decision, muse_server_module_get_msg(module));
2097
2098                 g_mutex_lock(&muse_recorder->camera_data.lock);
2099                 muse_recorder->video_encode_decision = (bool)video_encode_decision;
2100                 /*LOGD("video_encode_decision[%d]", video_encode_decision);*/
2101                 g_cond_signal(&muse_recorder->camera_data.cond);
2102                 g_mutex_unlock(&muse_recorder->camera_data.lock);
2103
2104                 if (!camera_remove_export_data(&muse_recorder->camera_data, (tbm_fd)ret_fd))
2105                         LOGE("remove export data for video encode decision failed. fd[%d]", ret_fd);
2106         } else {
2107                 if (!_recorder_remove_export_data(&muse_recorder->recorder_data, (tbm_fd)ret_fd))
2108                         LOGE("remove export data failed. buffer type[%d] fd[%d]", buffer_type, ret_fd);
2109         }
2110
2111         return MUSE_RECORDER_ERROR_NONE;
2112 }
2113
2114
2115 int recorder_dispatcher_set_sound_stream_info(muse_module_h module)
2116 {
2117         int ret = RECORDER_ERROR_NONE;
2118         char stream_type[MUSE_RECORDER_MSG_MAX_LENGTH] = {0,};
2119         int stream_index = 0;
2120         muse_recorder_api_e api = MUSE_RECORDER_API_SET_SOUND_STREAM_INFO;
2121         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
2122         muse_recorder_handle_s *muse_recorder = NULL;
2123
2124         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
2125
2126         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
2127
2128         muse_recorder_msg_get_string(stream_type, muse_server_module_get_msg(module));
2129         muse_recorder_msg_get(stream_index, muse_server_module_get_msg(module));
2130
2131         ret = legacy_recorder_set_sound_stream_info(muse_recorder->recorder_handle, stream_type, stream_index);
2132
2133         muse_recorder_msg_return(api, class, ret, module);
2134
2135         return MUSE_RECORDER_ERROR_NONE;
2136 }
2137
2138
2139 int recorder_dispatcher_get_device_state(muse_module_h module)
2140 {
2141         int ret = RECORDER_ERROR_NONE;
2142         int device_state = 0;
2143         int device_recording = 0;
2144         int device_paused = 0;
2145         recorder_type_e recorder_type = RECORDER_TYPE_AUDIO;
2146         recorder_device_state_e get_device_state = RECORDER_DEVICE_STATE_IDLE;
2147         muse_recorder_api_e api = MUSE_RECORDER_API_GET_DEVICE_STATE;
2148         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
2149
2150         muse_recorder_msg_get(recorder_type, muse_server_module_get_msg(module));
2151
2152         if (recorder_type > RECORDER_TYPE_VIDEO) {
2153                 LOGE("invalid type %d", recorder_type);
2154                 ret = RECORDER_ERROR_INVALID_PARAMETER;
2155                 muse_recorder_msg_return(api, class, ret, module);
2156                 return MUSE_RECORDER_ERROR_NONE;
2157         }
2158
2159         /* recording feature check */
2160         if (!_recorder_check_supported_feature(recorder_type)) {
2161 //LCOV_EXCL_START
2162                 LOGE("feature not supported");
2163                 ret = RECORDER_ERROR_NOT_SUPPORTED;
2164                 muse_recorder_msg_return(api, class, ret, module);
2165                 return MUSE_RECORDER_ERROR_NONE;
2166 //LCOV_EXCL_STOP
2167         }
2168
2169         if (recorder_type == RECORDER_TYPE_AUDIO)
2170                 muse_server_module_get_value(module, RECORDER_DEVICE_STATE_KEY_AUDIO, &device_state);
2171         else
2172                 muse_server_module_get_value(module, RECORDER_DEVICE_STATE_KEY_VIDEO, &device_state);
2173
2174         device_recording = device_state >> 16;
2175         device_paused = 0x0000ffff & device_state;
2176
2177         LOGD("device recording %d, paused %d", device_recording, device_paused);
2178
2179         if (device_recording > 0)
2180                 get_device_state = RECORDER_DEVICE_STATE_RECORDING;
2181         else if (device_paused > 0)
2182                 get_device_state = RECORDER_DEVICE_STATE_PAUSED;
2183
2184         LOGD("device[%d] state : %d", recorder_type, get_device_state);
2185
2186         muse_recorder_msg_return1(api, class, ret, module, INT, get_device_state);
2187
2188         return MUSE_RECORDER_ERROR_NONE;
2189 }
2190
2191
2192 int recorder_dispatcher_set_muxed_stream_cb(muse_module_h module)
2193 {
2194         int ret = RECORDER_ERROR_NONE;
2195         muse_recorder_api_e api = MUSE_RECORDER_API_SET_MUXED_STREAM_CB;
2196         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
2197         muse_recorder_handle_s *muse_recorder = NULL;
2198
2199         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
2200
2201         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
2202
2203         ret = legacy_recorder_set_muxed_stream_cb(muse_recorder->recorder_handle,
2204                 (recorder_muxed_stream_cb)_recorder_disp_muxed_stream_cb, (void *)module);
2205
2206         muse_recorder_msg_return(api, class, ret, module);
2207
2208         return MUSE_RECORDER_ERROR_NONE;
2209 }
2210
2211
2212 int recorder_dispatcher_unset_muxed_stream_cb(muse_module_h module)
2213 {
2214         int ret = RECORDER_ERROR_NONE;
2215         muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_MUXED_STREAM_CB;
2216         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
2217         muse_recorder_handle_s *muse_recorder = NULL;
2218
2219         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
2220
2221         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
2222
2223         ret = legacy_recorder_unset_muxed_stream_cb(muse_recorder->recorder_handle);
2224
2225         muse_recorder_msg_return(api, class, ret, module);
2226
2227         return MUSE_RECORDER_ERROR_NONE;
2228 }
2229
2230
2231 int recorder_dispatcher_set_video_encode_decision_cb(muse_module_h module)
2232 {
2233         int ret = RECORDER_ERROR_NONE;
2234         muse_recorder_api_e api = MUSE_RECORDER_API_SET_VIDEO_ENCODE_DECISION_CB;
2235         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
2236         muse_recorder_handle_s *muse_recorder = NULL;
2237
2238         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
2239
2240         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
2241
2242         ret = legacy_recorder_set_video_encode_decision_cb(muse_recorder->recorder_handle,
2243                 (recorder_video_encode_decision_cb)_recorder_disp_video_encode_decision_cb, (void *)module);
2244
2245         muse_recorder_msg_return(api, class, ret, module);
2246
2247         return MUSE_RECORDER_ERROR_NONE;
2248 }
2249
2250
2251 int recorder_dispatcher_unset_video_encode_decision_cb(muse_module_h module)
2252 {
2253         int ret = RECORDER_ERROR_NONE;
2254         muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_VIDEO_ENCODE_DECISION_CB;
2255         muse_recorder_api_class_e class = MUSE_RECORDER_API_CLASS_IMMEDIATE;
2256         muse_recorder_handle_s *muse_recorder = NULL;
2257
2258         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
2259
2260         recorder_send_msg_return_err_if_fail(muse_recorder, RECORDER_ERROR_INVALID_OPERATION, MUSE_RECORDER_ERROR_NONE);
2261
2262         ret = legacy_recorder_unset_video_encode_decision_cb(muse_recorder->recorder_handle);
2263
2264         muse_recorder_msg_return(api, class, ret, module);
2265
2266         return MUSE_RECORDER_ERROR_NONE;
2267 }
2268
2269
2270 int (*dispatcher[MUSE_RECORDER_API_MAX]) (muse_module_h module) = {
2271         recorder_dispatcher_create, /* MUSE_RECORDER_API_CREATE */
2272         recorder_dispatcher_destroy, /* MUSE_RECORDER_API_DESTROY */
2273         recorder_dispatcher_get_state, /* MUSE_RECORDER_API_GET_STATE */
2274         recorder_dispatcher_prepare, /* MUSE_RECORDER_API_PREPARE */
2275         recorder_dispatcher_unprepare, /* MUSE_RECORDER_API_UNPREPARE */
2276         recorder_dispatcher_start, /* MUSE_RECORDER_API_START */
2277         recorder_dispatcher_pause, /* MUSE_RECORDER_API_PAUSE */
2278         recorder_dispatcher_commit, /* MUSE_RECORDER_API_COMMIT */
2279         recorder_dispatcher_cancel, /* MUSE_RECORDER_API_CANCEL */
2280         recorder_dispatcher_set_video_resolution, /* MUSE_RECORDER_API_SET_VIDEO_RESOLUTION */
2281         recorder_dispatcher_get_video_resolution, /* MUSE_RECORDER_API_GET_VIDEO_RESOLUTION */
2282         recorder_dispatcher_foreach_supported_video_resolution, /* MUSE_RECORDER_API_FOREACH_SUPPORTED_VIDEO_RESOLUTION */
2283         recorder_dispatcher_get_audio_level, /* MUSE_RECORDER_API_GET_AUDIO_LEVEL */
2284         recorder_dispatcher_set_filename, /* MUSE_RECORDER_API_SET_FILENAME */
2285         recorder_dispatcher_get_filename, /* MUSE_RECORDER_API_GET_FILENAME */
2286         recorder_dispatcher_set_file_format, /* MUSE_RECORDER_API_SET_FILE_FORMAT */
2287         recorder_dispatcher_get_file_format, /* MUSE_RECORDER_API_GET_FILE_FORMAT */
2288         recorder_dispatcher_set_state_changed_cb, /* MUSE_RECORDER_API_SET_STATE_CHANGED_CB */
2289         recorder_dispatcher_unset_state_changed_cb, /* MUSE_RECORDER_API_UNSET_STATE_CHANGED_CB */
2290         recorder_dispatcher_set_interrupted_cb, /* MUSE_RECORDER_API_SET_INTERRUPTED_CB */
2291         recorder_dispatcher_unset_interrupted_cb, /* MUSE_RECORDER_API_UNSET_INTERRUPTED_CB */
2292         recorder_dispatcher_set_audio_stream_cb, /* MUSE_RECORDER_API_SET_AUDIO_STREAM_CB */
2293         recorder_dispatcher_unset_audio_stream_cb, /* MUSE_RECORDER_API_UNSET_AUDIO_STREAM_CB */
2294         recorder_dispatcher_set_error_cb, /* MUSE_RECORDER_API_SET_ERROR_CB */
2295         recorder_dispatcher_unset_error_cb, /* MUSE_RECORDER_API_UNSET_ERROR_CB */
2296         recorder_dispatcher_set_recording_status_cb, /* MUSE_RECORDER_API_SET_RECORDING_STATUS_CB */
2297         recorder_dispatcher_unset_recording_status_cb, /* MUSE_RECORDER_API_UNSET_RECORDING_STATUS_CB */
2298         recorder_dispatcher_set_recording_limit_reached_cb, /* MUSE_RECORDER_API_SET_RECORDING_LIMIT_RECHEAD_CB */
2299         recorder_dispatcher_unset_recording_limit_reached_cb, /* MUSE_RECORDER_API_UNSET_RECORDING_LIMIT_RECHEAD_CB */
2300         recorder_dispatcher_foreach_supported_file_format, /* MUSE_RECORDER_API_FOREACH_SUPPORTED_FILE_FORMAT */
2301         recorder_dispatcher_foreach_supported_file_format_by_audio_encoder, /* MUSE_RECORDER_API_FOREACH_SUPPORTED_FILE_FORMAT_BY_AUDIO_ENCORDER */
2302         recorder_dispatcher_foreach_supported_file_format_by_video_encoder, /* MUSE_RECORDER_API_FOREACH_SUPPORTED_FILE_FORMAT_BY_VIDEO_ENCORDER */
2303         recorder_dispatcher_attr_set_size_limit, /* MUSE_RECORDER_API_ATTR_SET_SIZE_LIMIT */
2304         recorder_dispatcher_attr_set_time_limit, /* MUSE_RECORDER_API_ATTR_SET_TIME_LIMIT */
2305         recorder_dispatcher_attr_set_audio_device, /* MUSE_RECORDER_API_ATTR_SET_AUDIO_DEVICE */
2306         recorder_dispatcher_set_audio_encoder, /* MUSE_RECORDER_API_SET_AUDIO_ENCODER */
2307         recorder_dispatcher_get_audio_encoder, /* MUSE_RECORDER_API_GET_AUDIO_ENCODER */
2308         recorder_dispatcher_set_video_encoder, /* MUSE_RECORDER_API_SET_VIDEO_ENCODER */
2309         recorder_dispatcher_get_video_encoder, /* MUSE_RECORDER_API_GET_VIDEO_ENCODER */
2310         recorder_dispatcher_attr_set_audio_samplerate, /* MUSE_RECORDER_API_ATTR_SET_AUDIO_SAMPLERATE */
2311         recorder_dispatcher_attr_set_audio_encoder_bitrate, /* MUSE_RECORDER_API_ATTR_SET_AUDIO_ENCODER_BITRATE */
2312         recorder_dispatcher_attr_set_video_encoder_bitrate, /* MUSE_RECORDER_API_ATTR_SET_VIDEO_ENCODER_BITRATE */
2313         recorder_dispatcher_attr_get_size_limit, /* MUSE_RECORDER_API_ATTR_GET_SIZE_LIMIT */
2314         recorder_dispatcher_attr_get_time_limit, /* MUSE_RECORDER_API_ATTR_GET_TIME_LIMIT */
2315         recorder_dispatcher_attr_get_audio_device, /* MUSE_RECORDER_API_ATTR_GET_AUDIO_DEVICE */
2316         recorder_dispatcher_attr_get_audio_samplerate, /* MUSE_RECORDER_API_ATTR_GET_AUDIO_SAMPLERATE */
2317         recorder_dispatcher_attr_get_audio_encoder_bitrate, /* MUSE_RECORDER_API_ATTR_GET_AUDIO_ENCODER_BITRATE */
2318         recorder_dispatcher_attr_get_video_encoder_bitrate, /* MUSE_RECORDER_API_ATTR_GET_VIDEO_ENCODER_BITRATE */
2319         recorder_dispatcher_foreach_supported_audio_encoder, /* MUSE_RECORDER_API_FOREACH_SUPPORTED_AUDIO_ENCODER */
2320         recorder_dispatcher_foreach_supported_audio_encoder_by_file_format, /* MUSE_RECORDER_API_FOREACH_SUPPORTED_AUDIO_ENCODER_BY_FILE_FORMAT */
2321         recorder_dispatcher_foreach_supported_video_encoder, /* MUSE_RECORDER_API_FOREACH_SUPPORTED_VIDEO_ENCODER */
2322         recorder_dispatcher_foreach_supported_video_encoder_by_file_format, /* MUSE_RECORDER_API_FOREACH_SUPPORTED_VIDEO_ENCODER_BY_FILE_FORMAT */
2323         recorder_dispatcher_attr_set_mute, /* MUSE_RECORDER_API_ATTR_SET_MUTE */
2324         recorder_dispatcher_attr_is_muted, /* MUSE_RECORDER_API_ATTR_IS_MUTED */
2325         recorder_dispatcher_attr_set_recording_motion_rate, /* MUSE_RECORDER_API_ATTR_SET_RECORDING_MOTION_RATE */
2326         recorder_dispatcher_attr_get_recording_motion_rate, /* MUSE_RECORDER_API_ATTR_GET_RECORDING_MOTION_RATE */
2327         recorder_dispatcher_attr_set_audio_channel, /* MUSE_RECORDER_API_ATTR_SET_AUDIO_CHANNEL */
2328         recorder_dispatcher_attr_get_audio_channel, /* MUSE_RECORDER_API_ATTR_GET_AUDIO_CHANNEL */
2329         recorder_dispatcher_attr_set_orientation_tag, /* MUSE_RECORDER_API_ATTR_SET_ORIENTATION_TAG */
2330         recorder_dispatcher_attr_get_orientation_tag, /* MUSE_RECORDER_API_ATTR_GET_ORIENTATION_TAG */
2331         recorder_dispatcher_attr_set_root_directory, /* MUSE_RECORDER_API_ATTR_SET_ROOT_DIRECTORY */
2332         recorder_dispatcher_return_buffer, /* MUSE_RECORDER_API_RETURN_BUFFER */
2333         recorder_dispatcher_set_sound_stream_info, /* MUSE_RECORDER_API_SET_SOUND_STREAM_INFO */
2334         recorder_dispatcher_get_device_state, /* MUSE_RECORDER_API_GET_DEVICE_STATE */
2335         recorder_dispatcher_set_muxed_stream_cb, /* MUSE_RECORDER_API_SET_MUXED_STREAM_CB */
2336         recorder_dispatcher_unset_muxed_stream_cb, /* MUSE_RECORDER_API_UNSET_MUXED_STREAM_CB */
2337         recorder_dispatcher_set_interrupt_started_cb, /* MUSE_RECORDER_API_SET_INTERRUPT_STARTED_CB */
2338         recorder_dispatcher_unset_interrupt_started_cb, /* MUSE_RECORDER_API_UNSET_INTERRUPT_STARTED_CB */
2339         recorder_dispatcher_set_video_encode_decision_cb, /* MUSE_RECORDER_API_SET_VIDEO_ENCODE_DECISION_CB */
2340         recorder_dispatcher_unset_video_encode_decision_cb /* MUSE_RECORDER_API_UNSET_VIDEO_ENCODE_DECISION_CB */
2341 };
2342
2343
2344 /******************/
2345 /* cmd dispatcher */
2346 /******************/
2347 //LCOV_EXCL_START
2348 static int recorder_cmd_dispatcher_initialize(muse_module_h module)
2349 {
2350         int item_count = 0;
2351         int i = 0;
2352         GstPlugin *plugin = NULL;
2353
2354         const char *load_list[] = {
2355                 LIBDIR"/gstreamer-1.0/libgstencodebin.so",
2356         };
2357
2358         item_count = sizeof(load_list) / sizeof(load_list[0]);
2359
2360         LOGD("item count %d", item_count);
2361
2362         for (i = 0 ; i < item_count ; i++) {
2363                 plugin = gst_plugin_load_file(load_list[i], NULL);
2364                 if (plugin) {
2365                         LOGD("%s loaded", load_list[i]);
2366                         gst_object_unref(plugin);
2367                         plugin = NULL;
2368                 } else {
2369                         LOGW("failed to load %s", load_list[i]);
2370                 }
2371         }
2372
2373         LOGD("done");
2374
2375         return MUSE_RECORDER_ERROR_NONE;
2376 }
2377
2378
2379 static int recorder_cmd_dispatcher_shutdown(muse_module_h module)
2380 {
2381         int ret = RECORDER_ERROR_NONE;
2382         recorder_state_e state = RECORDER_STATE_NONE;
2383         muse_recorder_handle_s *muse_recorder = NULL;
2384
2385         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
2386
2387         recorder_return_val_if_fail(muse_recorder, MUSE_RECORDER_ERROR_NONE);
2388
2389         legacy_recorder_get_state(muse_recorder->recorder_handle, &state);
2390
2391         LOGW("shutdown handle %p [state:%d]", muse_recorder->recorder_handle, state);
2392
2393         switch (state) {
2394         case RECORDER_STATE_PAUSED:
2395         case RECORDER_STATE_RECORDING:
2396                 ret = legacy_recorder_commit(muse_recorder->recorder_handle);
2397                 if (ret != RECORDER_ERROR_NONE) {
2398                         LOGE("commit failed. cancel...");
2399                         legacy_recorder_cancel(muse_recorder->recorder_handle);
2400                 }
2401                 /* fall through */
2402         case RECORDER_STATE_READY:
2403                 legacy_recorder_unprepare(muse_recorder->recorder_handle);
2404                 /* fall through */
2405         case RECORDER_STATE_CREATED:
2406                 ret = legacy_recorder_destroy(muse_recorder->recorder_handle);
2407                 if (ret == RECORDER_ERROR_NONE) {
2408                         if (muse_recorder->recorder_data.list)
2409                                 _recorder_remove_export_data(&muse_recorder->recorder_data, -1);
2410                         if (muse_recorder->camera_data.list)
2411                                 camera_remove_export_data(&muse_recorder->camera_data, -1);
2412
2413                         g_cond_clear(&muse_recorder->camera_data.cond);
2414                         g_mutex_clear(&muse_recorder->camera_data.lock);
2415                         g_cond_clear(&muse_recorder->recorder_data.cond);
2416                         g_mutex_clear(&muse_recorder->recorder_data.lock);
2417
2418                         muse_recorder->bufmgr = NULL;
2419
2420                         free(muse_recorder);
2421                         muse_recorder = NULL;
2422                 } else {
2423                         LOGE("shutdown failed");
2424                 }
2425                 break;
2426         default:
2427                 break;
2428         }
2429
2430         LOGW("done");
2431
2432         return MUSE_RECORDER_ERROR_NONE;
2433 }
2434
2435
2436 static int recorder_cmd_external_storage_state_changed(muse_module_h module)
2437 {
2438         int ret = RECORDER_ERROR_NONE;
2439         int storage_state = 0;
2440         muse_recorder_handle_s *muse_recorder = NULL;
2441
2442         muse_recorder = (muse_recorder_handle_s *)muse_server_ipc_get_handle(module);
2443
2444         recorder_return_val_if_fail(muse_recorder, MUSE_RECORDER_ERROR_NONE);
2445
2446         storage_state = (int)(long)muse_server_get_user_data(module);
2447
2448         LOGW("storage state %d", storage_state);
2449
2450         ret = legacy_recorder_manage_external_storage_state(muse_recorder->recorder_handle, storage_state);
2451
2452         LOGW("done : 0x%x", ret);
2453
2454         return MUSE_RECORDER_ERROR_NONE;
2455 }
2456 //LCOV_EXCL_STOP
2457
2458
2459 int (*cmd_dispatcher[MUSE_MODULE_COMMAND_MAX])(muse_module_h module) = {
2460         recorder_cmd_dispatcher_initialize, /* MUSE_MODULE_COMMAND_INITIALIZE */
2461         recorder_cmd_dispatcher_shutdown, /* MUSE_MODULE_COMMAND_SHUTDOWN */
2462         NULL, /* MUSE_MODULE_COMMAND_DEBUG_INFO_DUMP */
2463         NULL, /* MUSE_MODULE_COMMAND_CREATE_SERVER_ACK */
2464         NULL, /* MUSE_MODULE_COMMAND_RESOURCE_NOT_AVAILABLE */
2465         recorder_cmd_external_storage_state_changed  /* MUSE_MODULE_COMMAND_EXTERNAL_STORAGE_STATE_CHANGED */
2466 };