src/recorder.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 <stdio.h>
  18 #include <stdlib.h>
  19 #include <string.h>
  20 #include <camera_internal.h>
  21 #include <recorder.h>
  22 #include <sound_manager.h>
  23 #include <sound_manager_internal.h>
  24 #include <storage.h>
  25 #include <muse_recorder.h>
  26 #include <muse_recorder_msg.h>
  27 #include <muse_core_ipc.h>
  28 #include <muse_core_module.h>
  29 #include <recorder_private.h>
  30 #include <glib.h>
  31 #include <dlog.h>
  32
  33 #ifdef LOG_TAG
  34 #undef LOG_TAG
  35 #endif
  36 #define LOG_TAG "TIZEN_N_RECORDER"
  37
  38
  39 static int _recorder_import_tbm_key(tbm_bufmgr bufmgr, unsigned int tbm_key, tbm_bo *bo, tbm_bo_handle *bo_handle)
  40 {
  41         tbm_bo tmp_bo = NULL;
  42         tbm_bo_handle tmp_bo_handle = {NULL, };
  43
  44         if (bufmgr == NULL || bo == NULL || bo_handle == NULL || tbm_key == 0) {
  45                 LOGE("invalid parameter - bufmgr %p, bo %p, bo_handle %p, key %d",
  46                      bufmgr, bo, bo_handle, tbm_key);
  47                 return false;
  48         }
  49
  50         tmp_bo = tbm_bo_import(bufmgr, tbm_key);
  51         if (tmp_bo == NULL) {
  52                 LOGE("bo import failed - bufmgr %p, key %d", bufmgr, tbm_key);
  53                 return false;
  54         }
  55
  56         tmp_bo_handle = tbm_bo_map(tmp_bo, TBM_DEVICE_CPU, TBM_OPTION_READ);
  57         if (tmp_bo_handle.ptr == NULL) {
  58                 LOGE("bo map failed %p", tmp_bo);
  59                 tbm_bo_unref(tmp_bo);
  60                 tmp_bo = NULL;
  61                 return false;
  62         }
  63
  64         /* set bo and bo_handle */
  65         *bo = tmp_bo;
  66         *bo_handle = tmp_bo_handle;
  67
  68         return true;
  69 }
  70
  71 static void _recorder_release_imported_bo(tbm_bo *bo)
  72 {
  73         if (bo == NULL || *bo == NULL) {
  74                 LOGW("NULL bo");
  75                 return;
  76         }
  77
  78         tbm_bo_unmap(*bo);
  79         tbm_bo_unref(*bo);
  80         *bo = NULL;
  81
  82         return;
  83 }
  84
  85 static void _client_user_callback(recorder_cb_info_s *cb_info, char *recv_msg, muse_recorder_event_e event)
  86 {
  87         if (recv_msg == NULL || event >= MUSE_RECORDER_EVENT_TYPE_NUM) {
  88                 LOGE("invalid parameter - recorder msg %p, event %d", recv_msg, event);
  89                 return;
  90         }
  91
  92         LOGD("get recorder msg %s, event %d", recv_msg, event);
  93
  94         if (cb_info->user_cb[event] == NULL) {
  95                 LOGW("user callback for event %d is not set", event);
  96                 return;
  97         }
  98
  99         switch (event) {
 100         case MUSE_RECORDER_EVENT_TYPE_STATE_CHANGE:
 101                 {
 102                         int previous = 0;
 103                         int current = 0;
 104                         int by_policy = 0;
 105
 106                         muse_recorder_msg_get(previous, recv_msg);
 107                         muse_recorder_msg_get(current, recv_msg);
 108                         muse_recorder_msg_get(by_policy, recv_msg);
 109
 110                         ((recorder_state_changed_cb)cb_info->user_cb[event])((recorder_state_e)previous,
 111                                 (recorder_state_e)current,
 112                                 (bool)by_policy,
 113                                 cb_info->user_data[event]);
 114                         break;
 115                 }
 116         case MUSE_RECORDER_EVENT_TYPE_RECORDING_LIMITED:
 117                 {
 118                         int type = 0;
 119
 120                         muse_recorder_msg_get(type, recv_msg);
 121
 122                         ((recorder_recording_limit_reached_cb)cb_info->user_cb[event])((recorder_recording_limit_type_e)type,
 123                                 cb_info->user_data[event]);
 124                         break;
 125                 }
 126         case MUSE_RECORDER_EVENT_TYPE_RECORDING_STATUS:
 127                 {
 128                         int64_t cb_elapsed_time = 0;
 129                         int64_t cb_file_size = 0;
 130
 131                         muse_recorder_msg_get(cb_elapsed_time, recv_msg);
 132                         muse_recorder_msg_get(cb_file_size, recv_msg);
 133
 134                         ((recorder_recording_status_cb)cb_info->user_cb[event])((unsigned long long)cb_elapsed_time,
 135                                 (unsigned long long)cb_file_size,
 136                                 cb_info->user_data[event]);
 137                         break;
 138                 }
 139         case MUSE_RECORDER_EVENT_TYPE_INTERRUPTED:
 140                 {
 141                         int policy = 0;
 142                         int previous = 0;
 143                         int current = 0;
 144
 145                         muse_recorder_msg_get(policy, recv_msg);
 146                         muse_recorder_msg_get(previous, recv_msg);
 147                         muse_recorder_msg_get(current, recv_msg);
 148
 149                         ((recorder_interrupted_cb)cb_info->user_cb[event])((recorder_policy_e)policy,
 150                                 (recorder_state_e)previous,
 151                                 (recorder_state_e)current,
 152                                 cb_info->user_data[event]);
 153                         break;
 154                 }
 155         case MUSE_RECORDER_EVENT_TYPE_AUDIO_STREAM:
 156                 {
 157                         int tbm_key = 0;
 158                         int size = 0;
 159                         int format = 0;
 160                         int channel = 0;
 161                         int timestamp = 0;
 162                         tbm_bo bo = NULL;
 163                         tbm_bo_handle bo_handle = {.ptr = NULL};
 164
 165                         muse_recorder_msg_get(tbm_key, recv_msg);
 166                         if (tbm_key == 0) {
 167                                 LOGE("invalid key");
 168                                 break;
 169                         }
 170
 171                         if (!_recorder_import_tbm_key(cb_info->bufmgr, tbm_key, &bo, &bo_handle)) {
 172                                 LOGE("tbm key %d import failed", tbm_key);
 173                                 break;
 174                         }
 175
 176                         muse_recorder_msg_get(size, recv_msg);
 177                         muse_recorder_msg_get(format, recv_msg);
 178                         muse_recorder_msg_get(channel, recv_msg);
 179                         muse_recorder_msg_get(timestamp, recv_msg);
 180
 181                         ((recorder_audio_stream_cb)cb_info->user_cb[event])((void *)bo_handle.ptr,
 182                                 size,
 183                                 (audio_sample_type_e)format,
 184                                 channel,
 185                                 (unsigned int)timestamp,
 186                                 cb_info->user_data[event]);
 187
 188                         /* release imported bo */
 189                         _recorder_release_imported_bo(&bo);
 190
 191                         /* return buffer */
 192                         muse_recorder_msg_send1_no_return(MUSE_RECORDER_API_RETURN_BUFFER,
 193                                 cb_info->fd, cb_info,
 194                                 INT, tbm_key);
 195                         break;
 196                 }
 197         case MUSE_RECORDER_EVENT_TYPE_ERROR:
 198                 {
 199                         int error = 0;
 200                         int current_state = 0;
 201
 202                         muse_recorder_msg_get(error, recv_msg);
 203                         muse_recorder_msg_get(current_state, recv_msg);
 204
 205                         ((recorder_error_cb)cb_info->user_cb[event])((recorder_error_e)error,
 206                                 (recorder_state_e)current_state,
 207                                 cb_info->user_data[event]);
 208                         break;
 209                 }
 210         case MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_AUDIO_ENCODER:
 211                 {
 212                         int codec = 0;
 213
 214                         muse_recorder_msg_get(codec, recv_msg);
 215
 216                         if (((recorder_supported_audio_encoder_cb)cb_info->user_cb[event])((recorder_audio_codec_e)codec, cb_info->user_data[event]) == false) {
 217                                 cb_info->user_cb[event] = NULL;
 218                                 cb_info->user_data[event] = NULL;
 219                                 LOGD("stop foreach callback for SUPPORTED_AUDIO_ENCODER");
 220                         }
 221                         break;
 222                 }
 223         case MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_FILE_FORMAT:
 224                 {
 225                         int format = 0;
 226
 227                         muse_recorder_msg_get(format, recv_msg);
 228
 229                         if (((recorder_supported_file_format_cb)cb_info->user_cb[event])((recorder_file_format_e)format, cb_info->user_data[event]) == false) {
 230                                 cb_info->user_cb[event] = NULL;
 231                                 cb_info->user_data[event] = NULL;
 232                                 LOGD("stop foreach callback for SUPPORTED_FILE_FORMAT");
 233                         }
 234                         break;
 235                 }
 236         case MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_ENCODER:
 237                 {
 238                         int codec = 0;
 239
 240                         muse_recorder_msg_get(codec, recv_msg);
 241
 242                         if (((recorder_supported_video_encoder_cb)cb_info->user_cb[event])((recorder_video_codec_e)codec, cb_info->user_data[event]) == false) {
 243                                 cb_info->user_cb[event] = NULL;
 244                                 cb_info->user_data[event] = NULL;
 245                                 LOGD("stop foreach callback for SUPPORTED_VIDEO_ENCODER");
 246                         }
 247                         break;
 248                 }
 249         case MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_RESOLUTION:
 250                 {
 251                         int width = 0;
 252                         int height = 0;
 253
 254                         muse_recorder_msg_get(width, recv_msg);
 255                         muse_recorder_msg_get(height, recv_msg);
 256
 257                         if (((recorder_supported_video_resolution_cb)cb_info->user_cb[event])(width, height, cb_info->user_data[event]) == false) {
 258                                 cb_info->user_cb[event] = NULL;
 259                                 cb_info->user_data[event] = NULL;
 260                                 LOGD("stop foreach callback for SUPPORTED_VIDEO_RESOLUTION");
 261                         }
 262                         break;
 263                 }
 264
 265         default:
 266                         LOGE("Unknonw recorder event %d", event);
 267                         break;
 268         }
 269
 270         return;
 271 }
 272
 273
 274 static bool _recorder_idle_event_callback(void *data)
 275 {
 276         recorder_cb_info_s *cb_info = NULL;
 277         recorder_idle_event_s *rec_idle_event = (recorder_idle_event_s *)data;
 278
 279         if (rec_idle_event == NULL) {
 280                 LOGE("rec_idle_event is NULL");
 281                 return false;
 282         }
 283
 284         /* lock event */
 285         g_mutex_lock(&rec_idle_event->event_mutex);
 286
 287         cb_info = rec_idle_event->cb_info;
 288         if (cb_info == NULL) {
 289                 LOGW("recorder cb_info is NULL. event %d", rec_idle_event->event);
 290                 goto IDLE_EVENT_CALLBACK_DONE;
 291         }
 292
 293         /* remove event from list */
 294         g_mutex_lock(&cb_info->idle_event_mutex);
 295         if (cb_info->idle_event_list)
 296                 cb_info->idle_event_list = g_list_remove(cb_info->idle_event_list, (gpointer)rec_idle_event);
 297
 298         /*LOGD("remove recorder idle event %p, %p", rec_idle_event, cb_info->idle_event_list);*/
 299         g_mutex_unlock(&cb_info->idle_event_mutex);
 300
 301         /* user callback */
 302         _client_user_callback(rec_idle_event->cb_info, rec_idle_event->recv_msg, rec_idle_event->event);
 303
 304         /* send signal for waiting thread */
 305         g_cond_signal(&cb_info->idle_event_cond);
 306
 307 IDLE_EVENT_CALLBACK_DONE:
 308         /* unlock and release event */
 309         g_mutex_unlock(&rec_idle_event->event_mutex);
 310         g_mutex_clear(&rec_idle_event->event_mutex);
 311
 312         g_free(rec_idle_event);
 313         rec_idle_event = NULL;
 314
 315         return false;
 316 }
 317
 318
 319 static void _recorder_remove_idle_event_all(recorder_cb_info_s *cb_info)
 320 {
 321         recorder_idle_event_s *rec_idle_event = NULL;
 322         gboolean ret = TRUE;
 323         GList *list = NULL;
 324         gint64 end_time = 0;
 325
 326         if (cb_info == NULL) {
 327                 LOGE("cb_info is NULL");
 328                 return;
 329         }
 330
 331         g_mutex_lock(&cb_info->idle_event_mutex);
 332
 333         if (cb_info->idle_event_list == NULL) {
 334                 LOGD("No idle event is remained.");
 335         } else {
 336                 list = cb_info->idle_event_list;
 337
 338                 while (list) {
 339                         rec_idle_event = list->data;
 340                         list = g_list_next(list);
 341
 342                         if (!rec_idle_event) {
 343                                 LOGW("Fail to remove idle event. The event is NULL");
 344                         } else {
 345                                 if (g_mutex_trylock(&rec_idle_event->event_mutex)) {
 346                                         ret = g_idle_remove_by_data(rec_idle_event);
 347
 348                                         LOGD("remove idle event [%p], ret[%d]", rec_idle_event, ret);
 349
 350                                         if (ret == FALSE) {
 351                                                 rec_idle_event->cb_info = NULL;
 352                                                 LOGW("idle callback for event %p will be called later", rec_idle_event);
 353                                         }
 354
 355                                         cb_info->idle_event_list = g_list_remove(cb_info->idle_event_list, (gpointer)rec_idle_event);
 356
 357                                         g_mutex_unlock(&rec_idle_event->event_mutex);
 358
 359                                         if (ret == TRUE) {
 360                                                 g_mutex_clear(&rec_idle_event->event_mutex);
 361
 362                                                 g_free(rec_idle_event);
 363                                                 rec_idle_event = NULL;
 364
 365                                                 LOGD("remove idle event done");
 366                                         }
 367                                 } else {
 368                                         LOGW("event lock failed. it's being called...");
 369
 370                                         end_time = g_get_monotonic_time() + G_TIME_SPAN_MILLISECOND * 100;
 371
 372                                         if (g_cond_wait_until(&cb_info->idle_event_cond, &cb_info->idle_event_mutex, end_time))
 373                                                 LOGW("signal received");
 374                                         else
 375                                                 LOGW("timeout");
 376                                 }
 377                         }
 378                 }
 379
 380                 g_list_free(cb_info->idle_event_list);
 381                 cb_info->idle_event_list = NULL;
 382         }
 383
 384         g_mutex_unlock(&cb_info->idle_event_mutex);
 385
 386         return;
 387 }
 388
 389
 390 static void *_recorder_msg_handler_func(gpointer data)
 391 {
 392         int ret = 0;
 393         int api = 0;
 394         int event = 0;
 395         int event_class = 0;
 396         recorder_message_s *rec_msg = NULL;
 397         recorder_idle_event_s *rec_idle_event = NULL;
 398         recorder_cb_info_s *cb_info = (recorder_cb_info_s *)data;
 399
 400         if (cb_info == NULL) {
 401                 LOGE("cb_info NULL");
 402                 return NULL;
 403         }
 404
 405         LOGD("start");
 406
 407         g_mutex_lock(&cb_info->msg_handler_mutex);
 408
 409         while (g_atomic_int_get(&cb_info->msg_handler_running)) {
 410                 if (g_queue_is_empty(cb_info->msg_queue)) {
 411                         /*LOGD("signal wait...");*/
 412                         g_cond_wait(&cb_info->msg_handler_cond, &cb_info->msg_handler_mutex);
 413                         /*LOGD("signal received");*/
 414
 415                         if (g_atomic_int_get(&cb_info->msg_handler_running) == 0) {
 416                                 LOGD("stop event thread");
 417                                 break;
 418                         }
 419                 }
 420
 421                 rec_msg = (recorder_message_s *)g_queue_pop_head(cb_info->msg_queue);
 422                 g_mutex_unlock(&cb_info->msg_handler_mutex);
 423                 if (rec_msg == NULL) {
 424                         LOGE("NULL message");
 425                         g_mutex_lock(&cb_info->msg_handler_mutex);
 426                         continue;
 427                 }
 428                 api = rec_msg->api;
 429                 if (api < MUSE_RECORDER_API_MAX) {
 430                         g_mutex_lock(&cb_info->api_mutex[api]);
 431                         if (muse_recorder_msg_get(ret, rec_msg->recv_msg)) {
 432                                 cb_info->api_ret[api] = ret;
 433                                 cb_info->api_activating[api] = 1;
 434
 435                                 /*LOGD("recorder api %d - return 0x%x", ret);*/
 436
 437                                 g_cond_signal(&cb_info->api_cond[api]);
 438                         } else {
 439                                 LOGE("failed to get ret for api %d, msg %s", rec_msg->api, rec_msg->recv_msg);
 440                         }
 441
 442                         g_mutex_unlock(&cb_info->api_mutex[api]);
 443                 } else if (api == MUSE_RECORDER_CB_EVENT) {
 444                         event = -1;
 445                         event_class = -1;
 446
 447                         if (!muse_recorder_msg_get(event, rec_msg->recv_msg) ||
 448                             !muse_recorder_msg_get(event_class, rec_msg->recv_msg)) {
 449                                 LOGE("failed to get recorder event %d, class %d", event, event_class);
 450
 451                                 g_free(rec_msg);
 452                                 rec_msg = NULL;
 453
 454                                 g_mutex_lock(&cb_info->msg_handler_mutex);
 455                                 continue;
 456                         }
 457
 458                         switch (event_class) {
 459                         case MUSE_RECORDER_EVENT_CLASS_THREAD_SUB:
 460                                 _client_user_callback(cb_info, rec_msg->recv_msg, event);
 461                                 break;
 462                         case MUSE_RECORDER_EVENT_CLASS_THREAD_MAIN:
 463                                 rec_idle_event = g_new0(recorder_idle_event_s, 1);
 464                                 if (rec_idle_event == NULL) {
 465                                         LOGE("rec_idle_event alloc failed");
 466                                         break;
 467                                 }
 468
 469                                 rec_idle_event->event = event;
 470                                 rec_idle_event->cb_info = cb_info;
 471                                 g_mutex_init(&rec_idle_event->event_mutex);
 472                                 memcpy(rec_idle_event->recv_msg, rec_msg->recv_msg, sizeof(rec_idle_event->recv_msg));
 473
 474                                 /*LOGD("add recorder event[%d, %p] to IDLE", event, rec_idle_event);*/
 475
 476                                 g_mutex_lock(&cb_info->idle_event_mutex);
 477                                 cb_info->idle_event_list = g_list_append(cb_info->idle_event_list, (gpointer)rec_idle_event);
 478                                 g_mutex_unlock(&cb_info->idle_event_mutex);
 479
 480                                 g_idle_add_full(G_PRIORITY_DEFAULT,
 481                                         (GSourceFunc)_recorder_idle_event_callback,
 482                                         (gpointer)rec_idle_event,
 483                                         NULL);
 484                                 break;
 485                         default:
 486                                 LOGE("unknown recorder event class %d", event_class);
 487                                 break;
 488                         }
 489                 } else {
 490                         LOGE("unknown recorder api[%d] message", api);
 491                 }
 492
 493                 g_free(rec_msg);
 494                 rec_msg = NULL;
 495
 496                 g_mutex_lock(&cb_info->msg_handler_mutex);
 497         }
 498
 499         /* remove remained event */
 500         while (!g_queue_is_empty(cb_info->msg_queue)) {
 501                 rec_msg = (recorder_message_s *)g_queue_pop_head(cb_info->msg_queue);
 502                 if (rec_msg) {
 503                         LOGD("remove recorder message %p", rec_msg);
 504                         free(rec_msg);
 505                         rec_msg = NULL;
 506                 } else {
 507                         LOGW("NULL recorder message");
 508                 }
 509         }
 510
 511         g_mutex_unlock(&cb_info->msg_handler_mutex);
 512
 513         LOGD("return");
 514
 515         return NULL;
 516 }
 517
 518
 519 static void *_recorder_msg_recv_func(gpointer data)
 520 {
 521         int i = 0;
 522         int ret = 0;
 523         int api = 0;
 524         int api_class = 0;
 525         int num_token = 0;
 526         int str_pos = 0;
 527         int prev_pos = 0;
 528         char *recv_msg = NULL;
 529         char **parse_str = NULL;
 530         recorder_cb_info_s *cb_info = (recorder_cb_info_s *)data;
 531
 532         if (cb_info == NULL) {
 533                 LOGE("cb_info NULL");
 534                 return NULL;
 535         }
 536
 537         LOGD("start");
 538
 539         parse_str = (char **)malloc(sizeof(char *) * RECORDER_PARSE_STRING_SIZE);
 540         if (parse_str == NULL) {
 541                 LOGE("parse_str malloc failed");
 542                 return NULL;
 543         }
 544
 545         for (i = 0 ; i < RECORDER_PARSE_STRING_SIZE ; i++) {
 546                 parse_str[i] = (char *)malloc(sizeof(char) * MUSE_RECORDER_MSG_MAX_LENGTH);
 547                 if (parse_str[i] == NULL) {
 548                         LOGE("parse_str[%d] malloc failed", i);
 549                         goto CB_HANDLER_EXIT;
 550                 }
 551         }
 552
 553         recv_msg = cb_info->recv_msg;
 554
 555         while (g_atomic_int_get(&cb_info->msg_recv_running)) {
 556                 ret = muse_core_ipc_recv_msg(cb_info->fd, recv_msg);
 557                 if (ret <= 0)
 558                         break;
 559                 recv_msg[ret] = '\0';
 560
 561                 str_pos = 0;
 562                 prev_pos = 0;
 563                 num_token = 0;
 564
 565                 /*LOGD("recvMSg : %s, length : %d", recv_msg, ret);*/
 566
 567                 /* Need to split the combined entering msgs.
 568                     This module supports up to 200 combined msgs. */
 569                 for (str_pos = 0; str_pos < ret; str_pos++) {
 570                         if (recv_msg[str_pos] == '}') {
 571                                 memset(parse_str[num_token], 0x0, sizeof(char) * MUSE_RECORDER_MSG_MAX_LENGTH);
 572                                 strncpy(parse_str[num_token], recv_msg + prev_pos, str_pos - prev_pos + 1);
 573                                 /*LOGD("splitted msg : [%s], Index : %d", parse_str[num_token], num_token);*/
 574                                 prev_pos = str_pos+1;
 575                                 num_token++;
 576                         }
 577                 }
 578
 579                 /*LOGD("num_token : %d", num_token);*/
 580
 581                 /* Re-construct to the useful single msg. */
 582                 for (i = 0; i < num_token; i++) {
 583                         if (i >= RECORDER_PARSE_STRING_SIZE) {
 584                                 LOGE("invalid token index %d", i);
 585                                 break;
 586                         }
 587
 588                         api = -1;
 589                         api_class = -1;
 590
 591                         if (!muse_recorder_msg_get(api, parse_str[i])) {
 592                                 LOGE("failed to get recorder api");
 593                                 continue;
 594                         }
 595
 596                         if (api != MUSE_RECORDER_CB_EVENT) {
 597                                 if (!muse_recorder_msg_get(api_class, parse_str[i])) {
 598                                         LOGE("failed to get recorder api_class");
 599                                         continue;
 600                                 }
 601                         }
 602
 603                         if (api_class == MUSE_RECORDER_API_CLASS_IMMEDIATE) {
 604                                 if (api >= MUSE_RECORDER_API_MAX) {
 605                                         LOGE("invalid api %d", api);
 606                                         continue;
 607                                 }
 608
 609                                 g_mutex_lock(&cb_info->api_mutex[api]);
 610
 611                                 if (!muse_recorder_msg_get(ret, parse_str[i])) {
 612                                         LOGE("failed to get recorder ret");
 613                                         g_mutex_unlock(&cb_info->api_mutex[api]);
 614                                         continue;
 615                                 }
 616
 617                                 cb_info->api_ret[api] = ret;
 618                                 cb_info->api_activating[api] = 1;
 619
 620                                 switch (api) {
 621                                 case MUSE_RECORDER_API_CREATE:
 622                                         if (ret != RECORDER_ERROR_NONE) {
 623                                                 g_atomic_int_set(&cb_info->msg_recv_running, 0);
 624                                                 LOGE("recorder create error 0x%x. close client cb handler", ret);
 625                                         }
 626                                         break;
 627                                 case MUSE_RECORDER_API_DESTROY:
 628                                         if (ret == RECORDER_ERROR_NONE) {
 629                                                 g_atomic_int_set(&cb_info->msg_recv_running, 0);
 630                                                 LOGD("recorder destroy done. close client cb handler");
 631                                         }
 632                                         break;
 633                                 case MUSE_RECORDER_API_GET_STATE:
 634                                         {
 635                                                 int get_state = 0;
 636                                                 muse_recorder_msg_get(get_state, parse_str[i]);
 637                                                 cb_info->get_int_value[_RECORDER_GET_INT_STATE] = get_state;
 638                                         }
 639                                         break;
 640                                 case MUSE_RECORDER_API_GET_VIDEO_RESOLUTION:
 641                                         {
 642                                                 int get_width = 0;
 643                                                 int get_height = 0;
 644                                                 muse_recorder_msg_get(get_width, parse_str[i]);
 645                                                 muse_recorder_msg_get(get_height, parse_str[i]);
 646                                                 cb_info->get_int_value[_RECORDER_GET_INT_VIDEO_RESOLUTION] = get_width << 16;
 647                                                 cb_info->get_int_value[_RECORDER_GET_INT_VIDEO_RESOLUTION] |= get_height;
 648                                         }
 649                                         break;
 650                                 case MUSE_RECORDER_API_GET_FILE_FORMAT:
 651                                         {
 652                                                 int get_format = 0;
 653                                                 muse_recorder_msg_get(get_format, parse_str[i]);
 654                                                 cb_info->get_int_value[_RECORDER_GET_INT_FILE_FORMAT] = get_format;
 655                                         }
 656                                         break;
 657                                 case MUSE_RECORDER_API_GET_AUDIO_ENCODER:
 658                                         {
 659                                                 int get_codec = 0;
 660                                                 muse_recorder_msg_get(get_codec, parse_str[i]);
 661                                                 cb_info->get_int_value[_RECORDER_GET_INT_AUDIO_ENCODER] = get_codec;
 662                                         }
 663                                         break;
 664                                 case MUSE_RECORDER_API_GET_VIDEO_ENCODER:
 665                                         {
 666                                                 int get_codec = 0;
 667                                                 muse_recorder_msg_get(get_codec, parse_str[i]);
 668                                                 cb_info->get_int_value[_RECORDER_GET_INT_VIDEO_ENCODER] = get_codec;
 669                                         }
 670                                         break;
 671                                 case MUSE_RECORDER_API_ATTR_GET_SIZE_LIMIT:
 672                                         {
 673                                                 int get_kbyte = 0;
 674                                                 muse_recorder_msg_get(get_kbyte, parse_str[i]);
 675                                                 cb_info->get_int_value[_RECORDER_GET_INT_SIZE_LIMIT] = get_kbyte;
 676                                         }
 677                                         break;
 678                                 case MUSE_RECORDER_API_ATTR_GET_TIME_LIMIT:
 679                                         {
 680                                                 int get_second = 0;
 681                                                 muse_recorder_msg_get(get_second, parse_str[i]);
 682                                                 cb_info->get_int_value[_RECORDER_GET_INT_TIME_LIMIT] = get_second;
 683                                         }
 684                                         break;
 685                                 case MUSE_RECORDER_API_ATTR_GET_AUDIO_DEVICE:
 686                                         {
 687                                                 int get_device = 0;
 688                                                 muse_recorder_msg_get(get_device, parse_str[i]);
 689                                                 cb_info->get_int_value[_RECORDER_GET_INT_AUDIO_DEVICE] = get_device;
 690                                         }
 691                                         break;
 692                                 case MUSE_RECORDER_API_ATTR_GET_AUDIO_SAMPLERATE:
 693                                         {
 694                                                 int get_samplerate = 0;
 695                                                 muse_recorder_msg_get(get_samplerate, parse_str[i]);
 696                                                 cb_info->get_int_value[_RECORDER_GET_INT_AUDIO_SAMPLERATE] = get_samplerate;
 697                                         }
 698                                         break;
 699                                 case MUSE_RECORDER_API_ATTR_GET_AUDIO_ENCODER_BITRATE:
 700                                         {
 701                                                 int get_bitrate = 0;
 702                                                 muse_recorder_msg_get(get_bitrate, parse_str[i]);
 703                                                 cb_info->get_int_value[_RECORDER_GET_INT_AUDIO_ENCODER_BITRATE] = get_bitrate;
 704                                         }
 705                                         break;
 706                                 case MUSE_RECORDER_API_ATTR_GET_VIDEO_ENCODER_BITRATE:
 707                                         {
 708                                                 int get_bitrate = 0;
 709                                                 muse_recorder_msg_get(get_bitrate, parse_str[i]);
 710                                                 cb_info->get_int_value[_RECORDER_GET_INT_VIDEO_ENCODER_BITRATE] = get_bitrate;
 711                                         }
 712                                         break;
 713                                 case MUSE_RECORDER_API_ATTR_GET_RECORDING_MOTION_RATE:
 714                                         {
 715                                                 double get_rate = 0;
 716                                                 muse_recorder_msg_get_double(get_rate, parse_str[i]);
 717                                                 cb_info->get_double_value[_RECORDER_GET_DOUBLE_RECORDING_MOTION_RATE] = get_rate;
 718                                         }
 719                                         break;
 720                                 case MUSE_RECORDER_API_ATTR_GET_AUDIO_CHANNEL:
 721                                         {
 722                                                 int get_channel_count = 0;
 723                                                 muse_recorder_msg_get(get_channel_count, parse_str[i]);
 724                                                 cb_info->get_int_value[_RECORDER_GET_INT_AUDIO_CHANNEL] = get_channel_count;
 725                                         }
 726                                         break;
 727                                 case MUSE_RECORDER_API_ATTR_GET_ORIENTATION_TAG:
 728                                         {
 729                                                 int get_orientation = 0;
 730                                                 muse_recorder_msg_get(get_orientation, parse_str[i]);
 731                                                 cb_info->get_int_value[_RECORDER_GET_INT_ORIENTATION_TAG] = get_orientation;
 732                                         }
 733                                         break;
 734                                 case MUSE_RECORDER_API_GET_AUDIO_LEVEL:
 735                                         {
 736                                                 double get_level = 0.0;
 737                                                 muse_recorder_msg_get_double(get_level, parse_str[i]);
 738                                                 cb_info->get_double_value[_RECORDER_GET_DOUBLE_AUDIO_LEVEL] = get_level;
 739                                         }
 740                                         break;
 741                                 case MUSE_RECORDER_API_GET_FILENAME:
 742                                         {
 743                                                 char get_filename[MUSE_RECORDER_MSG_MAX_LENGTH] = {'\0',};
 744                                                 muse_recorder_msg_get_string(get_filename, parse_str[i]);
 745                                                 if (cb_info->get_filename) {
 746                                                         free(cb_info->get_filename);
 747                                                         cb_info->get_filename = NULL;
 748                                                 }
 749                                                 cb_info->get_filename = strdup(get_filename);
 750                                         }
 751                                         break;
 752                                 default:
 753                                         break;
 754                                 }
 755
 756                                 g_cond_signal(&cb_info->api_cond[api]);
 757                                 g_mutex_unlock(&cb_info->api_mutex[api]);
 758                         } else if (api_class == MUSE_RECORDER_API_CLASS_THREAD_SUB ||
 759                                         api == MUSE_RECORDER_CB_EVENT) {
 760                                 recorder_message_s *rec_msg = g_new0(recorder_message_s, 1);
 761                                 if (rec_msg == NULL) {
 762                                         LOGE("failed to alloc rec_msg");
 763                                         continue;
 764                                 }
 765
 766                                 rec_msg->api = api;
 767                                 memcpy(rec_msg->recv_msg, parse_str[i], sizeof(rec_msg->recv_msg));
 768
 769                                 /*LOGD("add recorder message to queue : api %d", api);*/
 770
 771                                 g_mutex_lock(&cb_info->msg_handler_mutex);
 772                                 g_queue_push_tail(cb_info->msg_queue, (gpointer)rec_msg);
 773                                 g_cond_signal(&cb_info->msg_handler_cond);
 774                                 g_mutex_unlock(&cb_info->msg_handler_mutex);
 775                         } else {
 776                                 LOGW("unknown recorder api %d and api_class %d", api, api_class);
 777                         }
 778                 }
 779         }
 780
 781         LOGD("client cb exit");
 782
 783 CB_HANDLER_EXIT:
 784         if (parse_str) {
 785                 for (i = 0 ; i < RECORDER_PARSE_STRING_SIZE ; i++) {
 786                         if (parse_str[i]) {
 787                                 free(parse_str[i]);
 788                                 parse_str[i] = NULL;
 789                         }
 790                 }
 791
 792                 free(parse_str);
 793                 parse_str = NULL;
 794         }
 795
 796         return NULL;
 797 }
 798
 799 static recorder_cb_info_s *_client_callback_new(gint sockfd)
 800 {
 801         recorder_cb_info_s *cb_info = NULL;
 802         gint *tmp_activating = NULL;
 803         gint *tmp_ret = NULL;
 804         gint i = 0;
 805
 806         g_return_val_if_fail(sockfd > 0, NULL);
 807
 808         cb_info = g_new0(recorder_cb_info_s, 1);
 809         if (cb_info == NULL) {
 810                 LOGE("cb_info failed");
 811                 goto ErrorExit;
 812         }
 813
 814         g_mutex_init(&cb_info->msg_handler_mutex);
 815         g_cond_init(&cb_info->msg_handler_cond);
 816         g_mutex_init(&cb_info->idle_event_mutex);
 817         g_cond_init(&cb_info->idle_event_cond);
 818
 819         for (i = 0 ; i < MUSE_RECORDER_API_MAX ; i++) {
 820                 g_mutex_init(&cb_info->api_mutex[i]);
 821                 g_cond_init(&cb_info->api_cond[i]);
 822         }
 823
 824         tmp_activating = g_new0(gint, MUSE_RECORDER_API_MAX);
 825         if (tmp_activating == NULL) {
 826                 LOGE("tmp_activating failed");
 827                 goto ErrorExit;
 828         }
 829
 830         tmp_ret = g_new0(gint, MUSE_RECORDER_API_MAX);
 831         if (tmp_ret == NULL) {
 832                 LOGE("tmp_ret failed");
 833                 goto ErrorExit;
 834         }
 835
 836         cb_info->msg_queue = g_queue_new();
 837         if (cb_info->msg_queue == NULL) {
 838                 LOGE("msg_queue new failed");
 839                 goto ErrorExit;
 840         }
 841
 842         g_atomic_int_set(&cb_info->msg_handler_running, 1);
 843         cb_info->msg_handler_thread = g_thread_try_new("recorder_msg_handler",
 844                 _recorder_msg_handler_func,
 845                 (gpointer)cb_info,
 846                 NULL);
 847         if (cb_info->msg_handler_thread == NULL) {
 848                 LOGE("message handler thread creation failed");
 849                 goto ErrorExit;
 850         }
 851
 852         cb_info->fd = sockfd;
 853         cb_info->api_activating = tmp_activating;
 854         cb_info->api_ret = tmp_ret;
 855
 856         g_atomic_int_set(&cb_info->msg_recv_running, 1);
 857         cb_info->msg_recv_thread = g_thread_try_new("recorder_msg_recv",
 858                 _recorder_msg_recv_func,
 859                 (gpointer)cb_info,
 860                 NULL);
 861         if (cb_info->msg_recv_thread == NULL) {
 862                 LOGE("message receive thread creation failed");
 863                 goto ErrorExit;
 864         }
 865
 866         return cb_info;
 867
 868
 869 ErrorExit:
 870         if (cb_info) {
 871                 if (cb_info->msg_handler_thread) {
 872                         g_mutex_lock(&cb_info->msg_handler_mutex);
 873                         g_atomic_int_set(&cb_info->msg_handler_running, 0);
 874                         g_cond_signal(&cb_info->msg_handler_cond);
 875                         g_mutex_unlock(&cb_info->msg_handler_mutex);
 876
 877                         g_thread_join(cb_info->msg_handler_thread);
 878                         g_thread_unref(cb_info->msg_handler_thread);
 879                         cb_info->msg_handler_thread = NULL;
 880                 }
 881
 882                 for (i = 0 ; i < MUSE_RECORDER_API_MAX ; i++) {
 883                         g_mutex_clear(&cb_info->api_mutex[i]);
 884                         g_cond_clear(&cb_info->api_cond[i]);
 885                 }
 886
 887                 g_mutex_clear(&cb_info->msg_handler_mutex);
 888                 g_cond_clear(&cb_info->msg_handler_cond);
 889                 g_mutex_clear(&cb_info->idle_event_mutex);
 890                 g_cond_clear(&cb_info->idle_event_cond);
 891
 892                 if (cb_info->msg_queue) {
 893                         g_queue_free(cb_info->msg_queue);
 894                         cb_info->msg_queue = NULL;
 895                 }
 896
 897                 g_free(cb_info);
 898                 cb_info = NULL;
 899         }
 900
 901         if (tmp_activating) {
 902                 g_free(tmp_activating);
 903                 tmp_activating = NULL;
 904         }
 905         if (tmp_ret) {
 906                 g_free(tmp_ret);
 907                 tmp_ret = NULL;
 908         }
 909
 910         return NULL;
 911 }
 912
 913 static int client_wait_for_cb_return(muse_recorder_api_e api, recorder_cb_info_s *cb_info, int time_out)
 914 {
 915         int ret = RECORDER_ERROR_NONE;
 916         gint64 end_time;
 917
 918         /*LOGD("Enter api : %d", api);*/
 919
 920         g_mutex_lock(&(cb_info->api_mutex[api]));
 921
 922         if (cb_info->api_activating[api] == 0) {
 923                 end_time = g_get_monotonic_time() + time_out * G_TIME_SPAN_SECOND;
 924                 if (g_cond_wait_until(&(cb_info->api_cond[api]), &(cb_info->api_mutex[api]), end_time)) {
 925                         ret = cb_info->api_ret[api];
 926                         cb_info->api_activating[api] = 0;
 927
 928                         /*LOGD("return value : 0x%x", ret);*/
 929                 } else {
 930                         ret = RECORDER_ERROR_INVALID_OPERATION;
 931
 932                         LOGE("api %d was TIMED OUT!", api);
 933                 }
 934         } else {
 935                 ret = cb_info->api_ret[api];
 936                 cb_info->api_activating[api] = 0;
 937
 938                 /*LOGD("condition is already checked for the api[%d], return[0x%x]", api, ret);*/
 939         }
 940
 941         g_mutex_unlock(&(cb_info->api_mutex[api]));
 942
 943         return ret;
 944 }
 945
 946 static void _client_callback_destroy(recorder_cb_info_s *cb_info)
 947 {
 948         gint i = 0;
 949
 950         g_return_if_fail(cb_info != NULL);
 951
 952         LOGD("MSG receive thread[%p] destroy", cb_info->msg_recv_thread);
 953
 954         g_thread_join(cb_info->msg_recv_thread);
 955         g_thread_unref(cb_info->msg_recv_thread);
 956         cb_info->msg_recv_thread = NULL;
 957
 958         LOGD("msg thread removed");
 959
 960         g_mutex_lock(&cb_info->msg_handler_mutex);
 961         g_atomic_int_set(&cb_info->msg_handler_running, 0);
 962         g_cond_signal(&cb_info->msg_handler_cond);
 963         g_mutex_unlock(&cb_info->msg_handler_mutex);
 964
 965         g_thread_join(cb_info->msg_handler_thread);
 966         g_thread_unref(cb_info->msg_handler_thread);
 967         cb_info->msg_handler_thread = NULL;
 968
 969         g_queue_free(cb_info->msg_queue);
 970         cb_info->msg_queue = NULL;
 971         g_mutex_clear(&cb_info->msg_handler_mutex);
 972         g_cond_clear(&cb_info->msg_handler_cond);
 973         g_mutex_clear(&cb_info->idle_event_mutex);
 974         g_cond_clear(&cb_info->idle_event_cond);
 975
 976         for (i = 0 ; i < MUSE_RECORDER_API_MAX ; i++) {
 977                 g_mutex_clear(&cb_info->api_mutex[i]);
 978                 g_cond_clear(&cb_info->api_cond[i]);
 979         }
 980
 981         LOGD("event thread removed");
 982
 983         if (cb_info->fd > -1) {
 984                 muse_core_connection_close(cb_info->fd);
 985                 cb_info->fd = -1;
 986         }
 987
 988         if (cb_info->bufmgr) {
 989                 tbm_bufmgr_deinit(cb_info->bufmgr);
 990                 cb_info->bufmgr = NULL;
 991         }
 992         if (cb_info->api_activating) {
 993                 g_free(cb_info->api_activating);
 994                 cb_info->api_activating = NULL;
 995         }
 996         if (cb_info->api_ret) {
 997                 g_free(cb_info->api_ret);
 998                 cb_info->api_ret = NULL;
 999         }
1000         if (cb_info->get_filename) {
1001                 free(cb_info->get_filename);
1002                 cb_info->get_filename = NULL;
1003         }
1004
1005         g_free(cb_info);
1006         cb_info = NULL;
1007
1008         return;
1009 }
1010
1011 static int _recorder_storage_device_supported_cb(int storage_id, storage_type_e type, storage_state_e state, const char *path, void *user_data)
1012 {
1013         char **root_directory = (char **)user_data;
1014
1015         if (root_directory == NULL) {
1016                 LOGE("user data is NULL");
1017                 return FALSE;
1018         }
1019
1020         LOGD("storage id %d, type %d, state %d, path %s",
1021                 storage_id, type, state, path ? path : "NULL");
1022
1023         if (type == STORAGE_TYPE_INTERNAL && path) {
1024                 if (*root_directory) {
1025                         free(*root_directory);
1026                         *root_directory = NULL;
1027                 }
1028
1029                 *root_directory = strdup(path);
1030                 if (*root_directory) {
1031                         LOGD("get root directory %s", *root_directory);
1032                         return FALSE;
1033                 } else {
1034                         LOGE("strdup %s failed");
1035                 }
1036         }
1037
1038         return TRUE;
1039 }
1040
1041 static int _client_get_root_directory(char **root_directory)
1042 {
1043         int ret = STORAGE_ERROR_NONE;
1044
1045         if (root_directory == NULL) {
1046                 LOGE("user data is NULL");
1047                 return false;
1048         }
1049
1050         ret = storage_foreach_device_supported((storage_device_supported_cb)_recorder_storage_device_supported_cb, root_directory);
1051         if (ret != STORAGE_ERROR_NONE) {
1052                 LOGE("storage_foreach_device_supported failed 0x%x", ret);
1053                 return false;
1054         }
1055
1056         return true;
1057 }
1058
1059 static int _recorder_create_common(recorder_h *recorder, muse_recorder_type_e type, camera_h camera)
1060 {
1061         int ret = RECORDER_ERROR_NONE;
1062         int destroy_ret = RECORDER_ERROR_NONE;
1063         int sock_fd = -1;
1064         char *send_msg = NULL;
1065         char *root_directory = NULL;
1066         intptr_t camera_handle = 0;
1067         intptr_t handle = 0;
1068         tbm_bufmgr bufmgr = NULL;
1069         recorder_cli_s *pc = NULL;
1070
1071         LOGD("Enter - type %d", type);
1072
1073         if (recorder == NULL) {
1074                 LOGE("NULL pointer for recorder handle");
1075                 return RECORDER_ERROR_INVALID_PARAMETER;
1076         }
1077
1078         if (type == MUSE_RECORDER_TYPE_VIDEO && camera == NULL) {
1079                 LOGE("NULL pointer for camera handle on video recorder mode");
1080                 return RECORDER_ERROR_INVALID_PARAMETER;
1081         }
1082
1083         bufmgr = tbm_bufmgr_init(-1);
1084         if (bufmgr == NULL) {
1085                 LOGE("get tbm bufmgr failed");
1086                 return RECORDER_ERROR_INVALID_OPERATION;
1087         }
1088
1089         pc = g_new0(recorder_cli_s, 1);
1090         if (pc == NULL) {
1091                 ret = RECORDER_ERROR_OUT_OF_MEMORY;
1092                 goto _ERR_RECORDER_EXIT;
1093         }
1094
1095         sock_fd = muse_core_client_new();
1096         if (sock_fd < 0) {
1097                 LOGE("muse_core_client_new failed - returned fd %d", sock_fd);
1098                 ret = RECORDER_ERROR_INVALID_OPERATION;
1099                 goto _ERR_RECORDER_EXIT;
1100         }
1101
1102         if (type == MUSE_RECORDER_TYPE_AUDIO) {
1103                 send_msg = muse_core_msg_json_factory_new(MUSE_RECORDER_API_CREATE,
1104                         MUSE_TYPE_INT, "module", MUSE_RECORDER,
1105                         MUSE_TYPE_INT, PARAM_RECORDER_TYPE, MUSE_RECORDER_TYPE_AUDIO,
1106                         MUSE_TYPE_INT, "pid", getpid(),
1107                         0);
1108         } else {
1109                 pc->camera = camera;
1110                 camera_handle = (intptr_t)((camera_cli_s *)camera)->remote_handle;
1111                 send_msg = muse_core_msg_json_factory_new(MUSE_RECORDER_API_CREATE,
1112                         MUSE_TYPE_INT, "module", MUSE_RECORDER,
1113                         MUSE_TYPE_INT, PARAM_RECORDER_TYPE, MUSE_RECORDER_TYPE_VIDEO,
1114                         MUSE_TYPE_POINTER, "camera_handle", camera_handle,
1115                         0);
1116         }
1117
1118         LOGD("sock_fd : %d, msg : %s", sock_fd, send_msg);
1119
1120         muse_core_ipc_send_msg(sock_fd, send_msg);
1121         muse_core_msg_json_factory_free(send_msg);
1122
1123         pc->cb_info = _client_callback_new(sock_fd);
1124         if (pc->cb_info == NULL) {
1125                 ret = RECORDER_ERROR_OUT_OF_MEMORY;
1126                 goto _ERR_RECORDER_EXIT;
1127         }
1128
1129         ret = client_wait_for_cb_return(MUSE_RECORDER_API_CREATE, pc->cb_info, RECORDER_CALLBACK_TIME_OUT);
1130         if (ret == RECORDER_ERROR_NONE) {
1131                 muse_recorder_msg_get_pointer(handle, pc->cb_info->recv_msg);
1132                 if (handle == 0) {
1133                         LOGE("Receiving Handle Failed!!");
1134                         goto _ERR_RECORDER_EXIT;
1135                 }
1136
1137                 if (!_client_get_root_directory(&root_directory) || root_directory == NULL) {
1138                         LOGE("failed to get root directory of internal storage");
1139                         ret = RECORDER_ERROR_INVALID_OPERATION;
1140                         goto _ERR_RECORDER_AFTER_CREATE;
1141                 }
1142
1143                 LOGD("set root directory [%s]", root_directory);
1144
1145                 muse_recorder_msg_send1(MUSE_RECORDER_API_ATTR_SET_ROOT_DIRECTORY,
1146                         sock_fd, pc->cb_info, ret, STRING, root_directory);
1147                 if (ret != RECORDER_ERROR_NONE) {
1148                         LOGE("failed to set root directory %s", root_directory);
1149                         ret = RECORDER_ERROR_INVALID_OPERATION;
1150                         goto _ERR_RECORDER_AFTER_CREATE;
1151                 }
1152
1153                 free(root_directory);
1154                 root_directory = NULL;
1155
1156                 pc->remote_handle = handle;
1157                 pc->cb_info->bufmgr = bufmgr;
1158
1159                 LOGD("recorder[type %d] %p create success : remote handle 0x%x",
1160                      type, pc, pc->remote_handle);
1161
1162                 *recorder = (recorder_h) pc;
1163         } else {
1164                 goto _ERR_RECORDER_EXIT;
1165         }
1166
1167         LOGD("done");
1168
1169         return RECORDER_ERROR_NONE;
1170
1171 _ERR_RECORDER_AFTER_CREATE:
1172         muse_recorder_msg_send(MUSE_RECORDER_API_DESTROY, sock_fd, pc->cb_info, destroy_ret);
1173         LOGE("destroy return 0x%x", destroy_ret);
1174
1175 _ERR_RECORDER_EXIT:
1176         tbm_bufmgr_deinit(bufmgr);
1177         bufmgr = NULL;
1178
1179         if (root_directory) {
1180                 free(root_directory);
1181                 root_directory = NULL;
1182         }
1183
1184         if (pc) {
1185                 if (pc->cb_info) {
1186                         _client_callback_destroy(pc->cb_info);
1187                         pc->cb_info = NULL;
1188                 }
1189                 g_free(pc);
1190                 pc = NULL;
1191         }
1192
1193         return ret;
1194 }
1195
1196 int recorder_create_videorecorder(camera_h camera, recorder_h *recorder)
1197 {
1198         return _recorder_create_common(recorder, MUSE_RECORDER_TYPE_VIDEO, camera);
1199 }
1200
1201
1202 int recorder_create_audiorecorder(recorder_h *recorder)
1203 {
1204         return _recorder_create_common(recorder, MUSE_RECORDER_TYPE_AUDIO, NULL);
1205 }
1206
1207 int recorder_get_state(recorder_h recorder, recorder_state_e *state)
1208 {
1209         int ret = RECORDER_ERROR_NONE;
1210         int sock_fd = 0;
1211         recorder_cli_s *pc = NULL;
1212         muse_recorder_api_e api = MUSE_RECORDER_API_GET_STATE;
1213
1214         if (recorder == NULL) {
1215                 LOGE("NULL pointer handle");
1216                 return RECORDER_ERROR_INVALID_PARAMETER;
1217         }
1218
1219         if (state == NULL) {
1220                 LOGE("NULL pointer state");
1221                 return RECORDER_ERROR_INVALID_PARAMETER;
1222         }
1223
1224         pc = (recorder_cli_s *)recorder;
1225         if (pc->cb_info == NULL) {
1226                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
1227                 return RECORDER_ERROR_INVALID_PARAMETER;
1228         }
1229
1230         sock_fd = pc->cb_info->fd;
1231
1232         LOGD("Enter, remote_handle : %x", pc->remote_handle);
1233
1234         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1235
1236         if (ret == RECORDER_ERROR_NONE)
1237                 *state = (recorder_state_e)pc->cb_info->get_int_value[_RECORDER_GET_INT_STATE];
1238
1239         LOGD("ret : 0x%x, state : %d", ret, *state);
1240
1241         return ret;
1242 }
1243
1244
1245 int recorder_destroy(recorder_h recorder)
1246 {
1247         if (recorder == NULL) {
1248                 LOGE("NULL pointer handle");
1249                 return RECORDER_ERROR_INVALID_PARAMETER;
1250         }
1251         int ret = RECORDER_ERROR_NONE;
1252         muse_recorder_api_e api = MUSE_RECORDER_API_DESTROY;
1253         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1254         int sock_fd = 0;
1255
1256         if (pc->cb_info == NULL) {
1257                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
1258                 return RECORDER_ERROR_INVALID_PARAMETER;
1259         }
1260
1261         sock_fd = pc->cb_info->fd;
1262
1263         LOGD("ENTER");
1264
1265         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1266         if (ret == RECORDER_ERROR_NONE) {
1267                 _recorder_remove_idle_event_all(pc->cb_info);
1268                 _client_callback_destroy(pc->cb_info);
1269                 g_free(pc);
1270                 pc = NULL;
1271         }
1272
1273         LOGD("ret : 0x%x", ret);
1274
1275         return ret;
1276 }
1277
1278
1279 int recorder_prepare(recorder_h recorder)
1280 {
1281         if (recorder == NULL) {
1282                 LOGE("NULL pointer handle");
1283                 return RECORDER_ERROR_INVALID_PARAMETER;
1284         }
1285
1286         int ret = RECORDER_ERROR_NONE;
1287         muse_recorder_api_e api = MUSE_RECORDER_API_PREPARE;
1288         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1289         int sock_fd;
1290         if (pc->cb_info == NULL) {
1291                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
1292                 return RECORDER_ERROR_INVALID_PARAMETER;
1293         }
1294         sock_fd = pc->cb_info->fd;
1295
1296         LOGD("ENTER");
1297
1298         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1299
1300         LOGD("ret : 0x%x", ret);
1301
1302         if (ret == RECORDER_ERROR_NONE && pc->camera)
1303                 camera_start_evas_rendering(pc->camera);
1304
1305         return ret;
1306 }
1307
1308
1309 int recorder_unprepare(recorder_h recorder)
1310 {
1311         int ret = RECORDER_ERROR_NONE;
1312         muse_recorder_api_e api = MUSE_RECORDER_API_UNPREPARE;
1313         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1314         int sock_fd;
1315         camera_state_e camera_state = CAMERA_STATE_NONE;
1316
1317         if (recorder == NULL) {
1318                 LOGE("NULL pointer handle");
1319                 return RECORDER_ERROR_INVALID_PARAMETER;
1320         }
1321
1322         if (pc->cb_info == NULL) {
1323                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
1324                 return RECORDER_ERROR_INVALID_PARAMETER;
1325         }
1326
1327         sock_fd = pc->cb_info->fd;
1328
1329         LOGD("ENTER");
1330
1331         if (pc->camera) {
1332                 ret = camera_get_state(pc->camera, &camera_state);
1333                 if (ret != CAMERA_ERROR_NONE) {
1334                         LOGE("failed to get camera state 0x%x", ret);
1335                         return RECORDER_ERROR_INVALID_OPERATION;
1336                 }
1337
1338                 if (camera_state == CAMERA_STATE_PREVIEW) {
1339                         ret = camera_stop_evas_rendering(pc->camera, false);
1340                         if (ret != CAMERA_ERROR_NONE) {
1341                                 LOGE("camera_stop_evas_rendering failed 0x%x", ret);
1342                                 return RECORDER_ERROR_INVALID_OPERATION;
1343                         }
1344                 }
1345         }
1346
1347         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1348
1349         LOGD("ret : 0x%x", ret);
1350
1351         return ret;
1352 }
1353
1354
1355 int recorder_start(recorder_h recorder)
1356 {
1357         int ret = RECORDER_ERROR_NONE;
1358         muse_recorder_api_e api = MUSE_RECORDER_API_START;
1359         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1360         int sock_fd;
1361         recorder_state_e current_state = RECORDER_STATE_NONE;
1362
1363         if (recorder == NULL) {
1364                 LOGE("NULL pointer handle");
1365                 return RECORDER_ERROR_INVALID_PARAMETER;
1366         }
1367
1368         if (pc->cb_info == NULL) {
1369                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
1370                 return RECORDER_ERROR_INVALID_PARAMETER;
1371         }
1372         sock_fd = pc->cb_info->fd;
1373
1374         LOGD("ENTER");
1375
1376         if (pc->camera) {
1377                 ret = recorder_get_state(recorder, &current_state);
1378                 if (ret != RECORDER_ERROR_NONE) {
1379                         LOGE("failed to get current state 0x%x", ret);
1380                         return RECORDER_ERROR_INVALID_OPERATION;
1381                 }
1382
1383                 if (current_state == RECORDER_STATE_READY) {
1384                         ret = camera_stop_evas_rendering(pc->camera, true);
1385                         if (ret != CAMERA_ERROR_NONE) {
1386                                 LOGE("camera_stop_evas_rendering failed 0x%x", ret);
1387                                 return RECORDER_ERROR_INVALID_OPERATION;
1388                         }
1389                 }
1390         }
1391
1392         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1393
1394         if (pc->camera && current_state == RECORDER_STATE_READY)
1395                 camera_start_evas_rendering(pc->camera);
1396
1397         LOGD("ret : 0x%x", ret);
1398
1399         return ret;
1400 }
1401
1402
1403 int recorder_pause(recorder_h recorder)
1404 {
1405         if (recorder == NULL) {
1406                 LOGE("NULL pointer handle");
1407                 return RECORDER_ERROR_INVALID_PARAMETER;
1408         }
1409         int ret = RECORDER_ERROR_NONE;
1410         muse_recorder_api_e api = MUSE_RECORDER_API_PAUSE;
1411         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1412         int sock_fd;
1413         if (pc->cb_info == NULL) {
1414                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
1415                 return RECORDER_ERROR_INVALID_PARAMETER;
1416         }
1417         sock_fd = pc->cb_info->fd;
1418
1419         LOGD("ENTER");
1420
1421         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1422         LOGD("ret : 0x%x", ret);
1423         return ret;
1424 }
1425
1426
1427 int recorder_commit(recorder_h recorder)
1428 {
1429         int ret = RECORDER_ERROR_NONE;
1430         muse_recorder_api_e api = MUSE_RECORDER_API_COMMIT;
1431         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1432         int sock_fd;
1433         recorder_state_e current_state = RECORDER_STATE_NONE;
1434
1435         if (recorder == NULL) {
1436                 LOGE("NULL pointer handle");
1437                 return RECORDER_ERROR_INVALID_PARAMETER;
1438         }
1439
1440         if (pc->cb_info == NULL) {
1441                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
1442                 return RECORDER_ERROR_INVALID_PARAMETER;
1443         }
1444         sock_fd = pc->cb_info->fd;
1445
1446         LOGD("ENTER");
1447
1448         if (pc->camera) {
1449                 ret = recorder_get_state(recorder, &current_state);
1450                 if (ret != RECORDER_ERROR_NONE) {
1451                         LOGE("failed to get current state 0x%x", ret);
1452                         return RECORDER_ERROR_INVALID_OPERATION;
1453                 }
1454
1455                 if (current_state >= RECORDER_STATE_RECORDING) {
1456                         ret = camera_stop_evas_rendering(pc->camera, true);
1457                         if (ret != CAMERA_ERROR_NONE) {
1458                                 LOGE("camera_stop_evas_rendering failed 0x%x", ret);
1459                                 return RECORDER_ERROR_INVALID_OPERATION;
1460                         }
1461                 }
1462         }
1463
1464         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1465
1466         if (pc->camera && current_state >= RECORDER_STATE_RECORDING)
1467                 camera_start_evas_rendering(pc->camera);
1468
1469         LOGD("ret : 0x%x", ret);
1470
1471         return ret;
1472 }
1473
1474
1475 int recorder_cancel(recorder_h recorder)
1476 {
1477         int ret = RECORDER_ERROR_NONE;
1478         muse_recorder_api_e api = MUSE_RECORDER_API_CANCEL;
1479         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1480         int sock_fd;
1481         recorder_state_e current_state = RECORDER_STATE_NONE;
1482
1483         if (recorder == NULL) {
1484                 LOGE("NULL pointer handle");
1485                 return RECORDER_ERROR_INVALID_PARAMETER;
1486         }
1487
1488         if (pc->cb_info == NULL) {
1489                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
1490                 return RECORDER_ERROR_INVALID_PARAMETER;
1491         }
1492
1493         sock_fd = pc->cb_info->fd;
1494
1495         LOGD("ENTER");
1496
1497         if (pc->camera) {
1498                 ret = recorder_get_state(recorder, &current_state);
1499                 if (ret != RECORDER_ERROR_NONE) {
1500                         LOGE("failed to get current state 0x%x", ret);
1501                         return RECORDER_ERROR_INVALID_OPERATION;
1502                 }
1503
1504                 if (current_state >= RECORDER_STATE_RECORDING) {
1505                         ret = camera_stop_evas_rendering(pc->camera, true);
1506                         if (ret != CAMERA_ERROR_NONE) {
1507                                 LOGE("camera_stop_evas_rendering failed 0x%x", ret);
1508                                 return RECORDER_ERROR_INVALID_OPERATION;
1509                         }
1510                 }
1511         }
1512
1513         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1514
1515         if (pc->camera && current_state >= RECORDER_STATE_RECORDING)
1516                 camera_start_evas_rendering(pc->camera);
1517
1518         LOGD("ret : 0x%x", ret);
1519
1520         return ret;
1521 }
1522
1523
1524 int recorder_set_video_resolution(recorder_h recorder, int width, int height)
1525 {
1526         if (recorder == NULL) {
1527                 LOGE("NULL pointer handle");
1528                 return RECORDER_ERROR_INVALID_PARAMETER;
1529         }
1530         int ret = RECORDER_ERROR_NONE;
1531         muse_recorder_api_e api = MUSE_RECORDER_API_SET_VIDEO_RESOLUTION;
1532         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1533         int sock_fd;
1534         if (pc->cb_info == NULL) {
1535                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
1536                 return RECORDER_ERROR_INVALID_PARAMETER;
1537         }
1538         sock_fd = pc->cb_info->fd;
1539
1540         LOGD("ENTER");
1541
1542         muse_recorder_msg_send2(api,
1543                 sock_fd,
1544                 pc->cb_info,
1545                 ret,
1546                 INT, width,
1547                 INT, height);
1548         LOGD("ret : 0x%x", ret);
1549         return ret;
1550 }
1551
1552
1553 int recorder_get_video_resolution(recorder_h recorder, int *width, int *height)
1554 {
1555         int ret = RECORDER_ERROR_NONE;
1556         int sock_fd = 0;
1557         muse_recorder_api_e api = MUSE_RECORDER_API_GET_VIDEO_RESOLUTION;
1558         recorder_cli_s *pc = NULL;
1559
1560         if (recorder == NULL) {
1561                 LOGE("NULL pointer handle");
1562                 return RECORDER_ERROR_INVALID_PARAMETER;
1563         }
1564
1565         if (!width || !height) {
1566                 LOGE("NULL pointer width = [%p], height = [%p]", width, height);
1567                 return RECORDER_ERROR_INVALID_PARAMETER;
1568         }
1569
1570         pc = (recorder_cli_s *)recorder;
1571         if (pc->cb_info == NULL) {
1572                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
1573                 return RECORDER_ERROR_INVALID_PARAMETER;
1574         }
1575
1576         sock_fd = pc->cb_info->fd;
1577
1578         LOGD("ENTER");
1579
1580         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1581
1582         if (ret == RECORDER_ERROR_NONE) {
1583                 *width = pc->cb_info->get_int_value[_RECORDER_GET_INT_VIDEO_RESOLUTION] >> 16;
1584                 *height = (0x0000ffff & pc->cb_info->get_int_value[_RECORDER_GET_INT_VIDEO_RESOLUTION]);
1585         }
1586
1587         LOGD("ret : 0x%x, %dx%d", ret, *width, *height);
1588
1589         return ret;
1590 }
1591
1592
1593 int recorder_foreach_supported_video_resolution(recorder_h recorder,
1594         recorder_supported_video_resolution_cb foreach_cb, void *user_data)
1595 {
1596         if (recorder == NULL || foreach_cb == NULL) {
1597                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
1598                 return RECORDER_ERROR_INVALID_PARAMETER;
1599         }
1600         int ret = RECORDER_ERROR_NONE;
1601
1602         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1603         muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_VIDEO_RESOLUTION;
1604
1605         LOGD("Enter, handle :%x", pc->remote_handle);
1606
1607         int sock_fd;
1608         if (pc->cb_info == NULL) {
1609                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
1610                 return RECORDER_ERROR_INVALID_PARAMETER;
1611         }
1612         sock_fd = pc->cb_info->fd;
1613         pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_RESOLUTION] = foreach_cb;
1614         pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_RESOLUTION] = user_data;
1615
1616         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1617         LOGD("ret : 0x%x", ret);
1618         return ret;
1619 }
1620
1621
1622 int recorder_get_audio_level(recorder_h recorder, double *level)
1623 {
1624         int ret = RECORDER_ERROR_NONE;
1625         int sock_fd = 0;
1626         muse_recorder_api_e api = MUSE_RECORDER_API_GET_AUDIO_LEVEL;
1627         recorder_cli_s *pc = NULL;
1628
1629         if (recorder == NULL || level == NULL) {
1630                 LOGE("NULL pointer %p %p", recorder, level);
1631                 return RECORDER_ERROR_INVALID_PARAMETER;
1632         }
1633
1634         pc = (recorder_cli_s *)recorder;
1635         if (pc->cb_info == NULL) {
1636                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
1637                 return RECORDER_ERROR_INVALID_PARAMETER;
1638         }
1639
1640         sock_fd = pc->cb_info->fd;
1641
1642         LOGD("ENTER");
1643
1644         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1645
1646         if (ret == RECORDER_ERROR_NONE)
1647                 *level = pc->cb_info->get_double_value[_RECORDER_GET_DOUBLE_AUDIO_LEVEL];
1648
1649         LOGD("ret : 0x%x, level %lf", ret, *level);
1650
1651         return ret;
1652 }
1653
1654
1655 int recorder_set_filename(recorder_h recorder,  const char *filename)
1656 {
1657         if (recorder == NULL) {
1658                 LOGE("handle is NULL");
1659                 return RECORDER_ERROR_INVALID_PARAMETER;
1660         }
1661
1662         if (filename == NULL) {
1663                 LOGE("filename is NULL");
1664                 return RECORDER_ERROR_INVALID_PARAMETER;
1665         }
1666         int ret = RECORDER_ERROR_NONE;
1667         muse_recorder_api_e api = MUSE_RECORDER_API_SET_FILENAME;
1668         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1669         int sock_fd;
1670         if (pc->cb_info == NULL) {
1671                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
1672                 return RECORDER_ERROR_INVALID_PARAMETER;
1673         }
1674         sock_fd = pc->cb_info->fd;
1675
1676         LOGD("ENTER");
1677
1678         muse_recorder_msg_send1(api, sock_fd, pc->cb_info, ret, STRING, filename);
1679         LOGD("ret : 0x%x", ret);
1680         return ret;
1681 }
1682
1683
1684 int recorder_get_filename(recorder_h recorder,  char **filename)
1685 {
1686         int ret = RECORDER_ERROR_NONE;
1687         int sock_fd = 0;
1688         muse_recorder_api_e api = MUSE_RECORDER_API_GET_FILENAME;
1689         recorder_cli_s *pc = NULL;
1690
1691         if (recorder == NULL) {
1692                 LOGE("handle is NULL");
1693                 return RECORDER_ERROR_INVALID_PARAMETER;
1694         }
1695
1696         if (filename == NULL) {
1697                 LOGE("filename is NULL");
1698                 return RECORDER_ERROR_INVALID_PARAMETER;
1699         }
1700
1701         pc = (recorder_cli_s *)recorder;
1702         if (pc->cb_info == NULL) {
1703                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
1704                 return RECORDER_ERROR_INVALID_PARAMETER;
1705         }
1706
1707         sock_fd = pc->cb_info->fd;
1708
1709         LOGD("ENTER");
1710
1711         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1712
1713         if (ret == RECORDER_ERROR_NONE) {
1714                 *filename = pc->cb_info->get_filename;
1715                 pc->cb_info->get_filename = NULL;
1716         }
1717
1718         LOGD("ret : 0x%x, filename : [%s]", ret, (*filename) ? *filename : "NULL");
1719
1720         return ret;
1721 }
1722
1723
1724 int recorder_set_file_format(recorder_h recorder, recorder_file_format_e format)
1725 {
1726         if (recorder == NULL) {
1727                 LOGE("NULL pointer handle");
1728                 return RECORDER_ERROR_INVALID_PARAMETER;
1729         }
1730         if (format < RECORDER_FILE_FORMAT_3GP || format > RECORDER_FILE_FORMAT_M2TS) {
1731                 LOGE("invalid format %d", format);
1732                 return RECORDER_ERROR_INVALID_PARAMETER;
1733         }
1734         int ret = RECORDER_ERROR_NONE;
1735         muse_recorder_api_e api = MUSE_RECORDER_API_SET_FILE_FORMAT;
1736         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1737         int sock_fd;
1738         if (pc->cb_info == NULL) {
1739                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
1740                 return RECORDER_ERROR_INVALID_PARAMETER;
1741         }
1742         sock_fd = pc->cb_info->fd;
1743         int set_format = (int)format;
1744
1745         LOGD("ENTER, set_format : %d", set_format);
1746
1747         muse_recorder_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_format);
1748         LOGD("ret : 0x%x", ret);
1749         return ret;
1750 }
1751
1752
1753 int recorder_get_file_format(recorder_h recorder, recorder_file_format_e *format)
1754 {
1755         int ret = RECORDER_ERROR_NONE;
1756         int sock_fd = 0;
1757         muse_recorder_api_e api = MUSE_RECORDER_API_GET_FILE_FORMAT;
1758         recorder_cli_s *pc = NULL;
1759
1760         if (recorder == NULL) {
1761                 LOGE("NULL pointer handle");
1762                 return RECORDER_ERROR_INVALID_PARAMETER;
1763         }
1764
1765         if (format == NULL) {
1766                 LOGE("NULL pointer data");
1767                 return RECORDER_ERROR_INVALID_PARAMETER;
1768         }
1769
1770         pc = (recorder_cli_s *)recorder;
1771         if (pc->cb_info == NULL) {
1772                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
1773                 return RECORDER_ERROR_INVALID_PARAMETER;
1774         }
1775
1776         sock_fd = pc->cb_info->fd;
1777
1778         LOGD("ENTER");
1779
1780         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1781
1782         if (ret == RECORDER_ERROR_NONE)
1783                 *format = (recorder_file_format_e)pc->cb_info->get_int_value[_RECORDER_GET_INT_FILE_FORMAT];
1784
1785         LOGD("ret : 0x%x, format %d", ret, *format);
1786
1787         return ret;
1788 }
1789
1790
1791 int recorder_set_sound_stream_info(recorder_h recorder, sound_stream_info_h stream_info)
1792 {
1793         int ret = RECORDER_ERROR_NONE;
1794         muse_recorder_api_e api = MUSE_RECORDER_API_SET_SOUND_STREAM_INFO;
1795         recorder_cli_s *pc = NULL;
1796         bool is_available = false;
1797         int sock_fd;
1798         int stream_index = 0;
1799         char *stream_type = NULL;
1800
1801         if (recorder == NULL || stream_info == NULL) {
1802                 LOGE("NULL pointer handle");
1803                 return RECORDER_ERROR_INVALID_PARAMETER;
1804         }
1805
1806         pc = (recorder_cli_s *)recorder;
1807         if (pc->cb_info == NULL) {
1808                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
1809                 return RECORDER_ERROR_INVALID_PARAMETER;
1810         }
1811
1812         sock_fd = pc->cb_info->fd;
1813
1814         LOGD("ENTER");
1815
1816         ret = sound_manager_is_available_stream_information(stream_info, NATIVE_API_RECORDER, &is_available);
1817         if (ret != SOUND_MANAGER_ERROR_NONE) {
1818                 LOGE("stream info verification failed");
1819                 return RECORDER_ERROR_INVALID_OPERATION;
1820         }
1821
1822         if (is_available == false) {
1823                 LOGE("stream information is not available");
1824                 return RECORDER_ERROR_INVALID_OPERATION;
1825         }
1826
1827         ret = sound_manager_get_type_from_stream_information(stream_info, &stream_type);
1828         ret |= sound_manager_get_index_from_stream_information(stream_info, &stream_index);
1829
1830         LOGD("sound manager return [0x%x]", ret);
1831
1832         if (ret == SOUND_MANAGER_ERROR_NONE)
1833                 muse_recorder_msg_send2(api, sock_fd, pc->cb_info, ret, STRING, stream_type, INT, stream_index);
1834         else
1835                 ret = RECORDER_ERROR_INVALID_OPERATION;
1836
1837         return ret;
1838 }
1839
1840
1841 int recorder_set_state_changed_cb(recorder_h recorder, recorder_state_changed_cb callback, void* user_data)
1842 {
1843         if (recorder == NULL || callback == NULL) {
1844                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
1845                 return RECORDER_ERROR_INVALID_PARAMETER;
1846         }
1847         int ret = RECORDER_ERROR_NONE;
1848
1849         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1850         muse_recorder_api_e api = MUSE_RECORDER_API_SET_STATE_CHANGED_CB;
1851
1852         LOGD("Enter, handle :%x", pc->remote_handle);
1853
1854         int sock_fd;
1855         if (pc->cb_info == NULL) {
1856                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
1857                 return RECORDER_ERROR_INVALID_PARAMETER;
1858         }
1859         sock_fd = pc->cb_info->fd;
1860         pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_STATE_CHANGE] = callback;
1861         pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_STATE_CHANGE] = user_data;
1862
1863         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1864         LOGD("ret : 0x%x", ret);
1865         return ret;
1866 }
1867
1868
1869 int recorder_unset_state_changed_cb(recorder_h recorder)
1870 {
1871         if (recorder == NULL) {
1872                 LOGE("NULL pointer handle");
1873                 return RECORDER_ERROR_INVALID_PARAMETER;
1874         }
1875         int ret = RECORDER_ERROR_NONE;
1876         muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_STATE_CHANGED_CB;
1877         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1878         int sock_fd;
1879         if (pc->cb_info == NULL) {
1880                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
1881                 return RECORDER_ERROR_INVALID_PARAMETER;
1882         }
1883         sock_fd = pc->cb_info->fd;
1884
1885         LOGD("ENTER");
1886
1887         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1888         LOGD("ret : 0x%x", ret);
1889         return ret;
1890 }
1891
1892
1893 int recorder_set_interrupted_cb(recorder_h recorder, recorder_interrupted_cb callback, void *user_data)
1894 {
1895         if (recorder == NULL || callback == NULL) {
1896                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
1897                 return RECORDER_ERROR_INVALID_PARAMETER;
1898         }
1899         int ret = RECORDER_ERROR_NONE;
1900
1901         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1902         muse_recorder_api_e api = MUSE_RECORDER_API_SET_INTERRUPTED_CB;
1903
1904         LOGD("Enter, handle :%x", pc->remote_handle);
1905
1906         int sock_fd;
1907         if (pc->cb_info == NULL) {
1908                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
1909                 return RECORDER_ERROR_INVALID_PARAMETER;
1910         }
1911         sock_fd = pc->cb_info->fd;
1912         pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_INTERRUPTED] = callback;
1913         pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_INTERRUPTED] = user_data;
1914
1915         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1916         LOGD("ret : 0x%x", ret);
1917         return ret;
1918 }
1919
1920
1921 int recorder_unset_interrupted_cb(recorder_h recorder)
1922 {
1923         if (recorder == NULL) {
1924                 LOGE("NULL pointer handle");
1925                 return RECORDER_ERROR_INVALID_PARAMETER;
1926         }
1927         int ret = RECORDER_ERROR_NONE;
1928         muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_INTERRUPTED_CB;
1929         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1930         int sock_fd;
1931         if (pc->cb_info == NULL) {
1932                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
1933                 return RECORDER_ERROR_INVALID_PARAMETER;
1934         }
1935         sock_fd = pc->cb_info->fd;
1936
1937         LOGD("ENTER");
1938
1939         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1940         LOGD("ret : 0x%x", ret);
1941         return ret;
1942 }
1943
1944
1945 int recorder_set_audio_stream_cb(recorder_h recorder, recorder_audio_stream_cb callback, void* user_data)
1946 {
1947         if (recorder == NULL || callback == NULL) {
1948                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
1949                 return RECORDER_ERROR_INVALID_PARAMETER;
1950         }
1951         int ret = RECORDER_ERROR_NONE;
1952
1953         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1954         muse_recorder_api_e api = MUSE_RECORDER_API_SET_AUDIO_STREAM_CB;
1955
1956         LOGD("Enter, handle :%x", pc->remote_handle);
1957
1958         int sock_fd;
1959         if (pc->cb_info == NULL) {
1960                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
1961                 return RECORDER_ERROR_INVALID_PARAMETER;
1962         }
1963         sock_fd = pc->cb_info->fd;
1964         pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_AUDIO_STREAM] = callback;
1965         pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_AUDIO_STREAM] = user_data;
1966
1967         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1968         LOGD("ret : 0x%x", ret);
1969         return ret;
1970 }
1971
1972
1973 int recorder_unset_audio_stream_cb(recorder_h recorder)
1974 {
1975         if (recorder == NULL) {
1976                 LOGE("NULL pointer handle");
1977                 return RECORDER_ERROR_INVALID_PARAMETER;
1978         }
1979         int ret = RECORDER_ERROR_NONE;
1980         muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_AUDIO_STREAM_CB;
1981         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1982         int sock_fd;
1983         if (pc->cb_info == NULL) {
1984                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
1985                 return RECORDER_ERROR_INVALID_PARAMETER;
1986         }
1987         sock_fd = pc->cb_info->fd;
1988
1989         LOGD("ENTER");
1990
1991         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1992         LOGD("ret : 0x%x", ret);
1993         return ret;
1994 }
1995
1996
1997 int recorder_set_error_cb(recorder_h recorder, recorder_error_cb callback, void *user_data)
1998 {
1999         if (recorder == NULL || callback == NULL) {
2000                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2001                 return RECORDER_ERROR_INVALID_PARAMETER;
2002         }
2003         int ret = RECORDER_ERROR_NONE;
2004
2005         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2006         muse_recorder_api_e api = MUSE_RECORDER_API_SET_ERROR_CB;
2007
2008         LOGD("Enter, handle :%x", pc->remote_handle);
2009
2010         int sock_fd;
2011         if (pc->cb_info == NULL) {
2012                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2013                 return RECORDER_ERROR_INVALID_PARAMETER;
2014         }
2015         sock_fd = pc->cb_info->fd;
2016         pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_ERROR] = callback;
2017         pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_ERROR] = user_data;
2018
2019         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
2020         LOGD("ret : 0x%x", ret);
2021         return ret;
2022 }
2023
2024
2025 int recorder_unset_error_cb(recorder_h recorder)
2026 {
2027         if (recorder == NULL) {
2028                 LOGE("NULL pointer handle");
2029                 return RECORDER_ERROR_INVALID_PARAMETER;
2030         }
2031         int ret = RECORDER_ERROR_NONE;
2032         muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_ERROR_CB;
2033         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2034         int sock_fd;
2035         if (pc->cb_info == NULL) {
2036                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2037                 return RECORDER_ERROR_INVALID_PARAMETER;
2038         }
2039         sock_fd = pc->cb_info->fd;
2040
2041         LOGD("ENTER");
2042
2043         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
2044         LOGD("ret : 0x%x", ret);
2045         return ret;
2046 }
2047
2048
2049 int recorder_set_recording_status_cb(recorder_h recorder, recorder_recording_status_cb callback, void* user_data)
2050 {
2051         if (recorder == NULL || callback == NULL) {
2052                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2053                 return RECORDER_ERROR_INVALID_PARAMETER;
2054         }
2055         int ret = RECORDER_ERROR_NONE;
2056
2057         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2058         muse_recorder_api_e api = MUSE_RECORDER_API_SET_RECORDING_STATUS_CB;
2059
2060         LOGD("Enter, handle :%x", pc->remote_handle);
2061
2062         int sock_fd;
2063         if (pc->cb_info == NULL) {
2064                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2065                 return RECORDER_ERROR_INVALID_PARAMETER;
2066         }
2067         sock_fd = pc->cb_info->fd;
2068         pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_RECORDING_STATUS] = callback;
2069         pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_RECORDING_STATUS] = user_data;
2070
2071         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
2072         LOGD("ret : 0x%x", ret);
2073         return ret;
2074 }
2075
2076
2077 int recorder_unset_recording_status_cb(recorder_h recorder)
2078 {
2079         if (recorder == NULL) {
2080                 LOGE("NULL pointer handle");
2081                 return RECORDER_ERROR_INVALID_PARAMETER;
2082         }
2083         int ret = RECORDER_ERROR_NONE;
2084         muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_RECORDING_STATUS_CB;
2085         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2086         int sock_fd;
2087         if (pc->cb_info == NULL) {
2088                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2089                 return RECORDER_ERROR_INVALID_PARAMETER;
2090         }
2091         sock_fd = pc->cb_info->fd;
2092
2093         LOGD("ENTER");
2094
2095         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
2096         LOGD("ret : 0x%x", ret);
2097         return ret;
2098 }
2099
2100
2101 int recorder_set_recording_limit_reached_cb(recorder_h recorder, recorder_recording_limit_reached_cb callback, void* user_data)
2102 {
2103         if (recorder == NULL || callback == NULL) {
2104                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2105                 return RECORDER_ERROR_INVALID_PARAMETER;
2106         }
2107         int ret = RECORDER_ERROR_NONE;
2108
2109         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2110         muse_recorder_api_e api = MUSE_RECORDER_API_SET_RECORDING_LIMIT_REACHED_CB;
2111
2112         LOGD("Enter, handle :%x", pc->remote_handle);
2113
2114         int sock_fd;
2115         if (pc->cb_info == NULL) {
2116                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2117                 return RECORDER_ERROR_INVALID_PARAMETER;
2118         }
2119         sock_fd = pc->cb_info->fd;
2120         pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_RECORDING_LIMITED] = callback;
2121         pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_RECORDING_LIMITED] = user_data;
2122
2123         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
2124         LOGD("ret : 0x%x", ret);
2125         return ret;
2126 }
2127
2128
2129 int recorder_unset_recording_limit_reached_cb(recorder_h recorder)
2130 {
2131         if (recorder == NULL) {
2132                 LOGE("NULL pointer handle");
2133                 return RECORDER_ERROR_INVALID_PARAMETER;
2134         }
2135         int ret = RECORDER_ERROR_NONE;
2136         muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_RECORDING_LIMIT_REACHED_CB;
2137         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2138         int sock_fd;
2139         if (pc->cb_info == NULL) {
2140                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2141                 return RECORDER_ERROR_INVALID_PARAMETER;
2142         }
2143         sock_fd = pc->cb_info->fd;
2144
2145         LOGD("ENTER");
2146
2147         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
2148         LOGD("ret : 0x%x", ret);
2149         return ret;
2150 }
2151
2152
2153 int recorder_foreach_supported_file_format(recorder_h recorder, recorder_supported_file_format_cb foreach_cb, void *user_data)
2154 {
2155         if (recorder == NULL || foreach_cb == NULL) {
2156                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2157                 return RECORDER_ERROR_INVALID_PARAMETER;
2158         }
2159         int ret = RECORDER_ERROR_NONE;
2160
2161         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2162         muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_FILE_FORMAT;
2163
2164         LOGD("Enter, handle :%x", pc->remote_handle);
2165
2166         int sock_fd;
2167         if (pc->cb_info == NULL) {
2168                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2169                 return RECORDER_ERROR_INVALID_PARAMETER;
2170         }
2171         sock_fd = pc->cb_info->fd;
2172         pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_FILE_FORMAT] = foreach_cb;
2173         pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_FILE_FORMAT] = user_data;
2174
2175         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
2176         LOGD("ret : 0x%x", ret);
2177         return ret;
2178 }
2179
2180
2181 int recorder_attr_set_size_limit(recorder_h recorder, int kbyte)
2182 {
2183         if (recorder == NULL) {
2184                 LOGE("NULL pointer handle");
2185                 return RECORDER_ERROR_INVALID_PARAMETER;
2186         }
2187         int ret = RECORDER_ERROR_NONE;
2188         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_SIZE_LIMIT;
2189         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2190         int sock_fd;
2191         if (pc->cb_info == NULL) {
2192                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2193                 return RECORDER_ERROR_INVALID_PARAMETER;
2194         }
2195         sock_fd = pc->cb_info->fd;
2196
2197         LOGD("ENTER");
2198
2199         muse_recorder_msg_send1(api,
2200                                                         sock_fd,
2201                                                         pc->cb_info,
2202                                                         ret,
2203                                                         INT, kbyte);
2204         LOGD("ret : 0x%x", ret);
2205         return ret;
2206 }
2207
2208
2209 int recorder_attr_set_time_limit(recorder_h recorder, int second)
2210 {
2211         if (recorder == NULL) {
2212                 LOGE("NULL pointer handle");
2213                 return RECORDER_ERROR_INVALID_PARAMETER;
2214         }
2215         int ret = RECORDER_ERROR_NONE;
2216         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_TIME_LIMIT;
2217         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2218         int sock_fd;
2219         if (pc->cb_info == NULL) {
2220                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2221                 return RECORDER_ERROR_INVALID_PARAMETER;
2222         }
2223         sock_fd = pc->cb_info->fd;
2224
2225         LOGD("ENTER");
2226
2227         muse_recorder_msg_send1(api,
2228                                                         sock_fd,
2229                                                         pc->cb_info,
2230                                                         ret,
2231                                                         INT, second);
2232         LOGD("ret : 0x%x", ret);
2233         return ret;
2234 }
2235
2236
2237 int recorder_attr_set_audio_device(recorder_h recorder, recorder_audio_device_e device)
2238 {
2239         if (recorder == NULL) {
2240                 LOGE("NULL pointer handle");
2241                 return RECORDER_ERROR_INVALID_PARAMETER;
2242         }
2243         int ret = RECORDER_ERROR_NONE;
2244         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_AUDIO_DEVICE;
2245         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2246         int sock_fd;
2247         if (pc->cb_info == NULL) {
2248                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2249                 return RECORDER_ERROR_INVALID_PARAMETER;
2250         }
2251         sock_fd = pc->cb_info->fd;
2252         int set_device = (int)device;
2253
2254         LOGD("ENTER");
2255
2256         muse_recorder_msg_send1(api,
2257                                                         sock_fd,
2258                                                         pc->cb_info,
2259                                                         ret,
2260                                                         INT, set_device);
2261         LOGD("ret : 0x%x", ret);
2262         return ret;
2263 }
2264
2265
2266 int recorder_set_audio_encoder(recorder_h recorder, recorder_audio_codec_e codec)
2267 {
2268         int ret = RECORDER_ERROR_NONE;
2269         muse_recorder_api_e api = MUSE_RECORDER_API_SET_AUDIO_ENCODER;
2270         recorder_cli_s *pc = NULL;
2271         int sock_fd = 0;
2272         int set_codec = (int)codec;
2273
2274         if (recorder == NULL) {
2275                 LOGE("NULL pointer handle");
2276                 return RECORDER_ERROR_INVALID_PARAMETER;
2277         }
2278
2279         pc = (recorder_cli_s *)recorder;
2280         if (pc->cb_info == NULL) {
2281                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2282                 return RECORDER_ERROR_INVALID_PARAMETER;
2283         }
2284
2285         LOGD("ENTER");
2286
2287         sock_fd = pc->cb_info->fd;
2288         muse_recorder_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_codec);
2289
2290         LOGD("ret : 0x%x", ret);
2291
2292         return ret;
2293 }
2294
2295
2296 int recorder_get_audio_encoder(recorder_h recorder, recorder_audio_codec_e *codec)
2297 {
2298         int ret = RECORDER_ERROR_NONE;
2299         int sock_fd = 0;
2300         muse_recorder_api_e api = MUSE_RECORDER_API_GET_AUDIO_ENCODER;
2301         recorder_cli_s *pc = NULL;
2302
2303         if (recorder == NULL) {
2304                 LOGE("NULL pointer handle");
2305                 return RECORDER_ERROR_INVALID_PARAMETER;
2306         }
2307
2308         if (codec == NULL) {
2309                 LOGE("codec is NULL");
2310                 return RECORDER_ERROR_INVALID_PARAMETER;
2311         }
2312
2313         pc = (recorder_cli_s *)recorder;
2314         if (pc->cb_info == NULL) {
2315                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2316                 return RECORDER_ERROR_INVALID_PARAMETER;
2317         }
2318
2319         sock_fd = pc->cb_info->fd;
2320
2321         LOGD("ENTER");
2322
2323         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
2324
2325         if (ret == RECORDER_ERROR_NONE)
2326                 *codec = (recorder_audio_codec_e)pc->cb_info->get_int_value[_RECORDER_GET_INT_AUDIO_ENCODER];
2327
2328         LOGD("ret : 0x%x, codec %d", ret, *codec);
2329
2330         return ret;
2331 }
2332
2333
2334 int recorder_set_video_encoder(recorder_h recorder, recorder_video_codec_e codec)
2335 {
2336         if (recorder == NULL) {
2337                 LOGE("NULL pointer handle");
2338                 return RECORDER_ERROR_INVALID_PARAMETER;
2339         }
2340         if (codec < RECORDER_VIDEO_CODEC_H263 || codec > RECORDER_VIDEO_CODEC_THEORA) {
2341                 LOGE("invalid codec %d", codec);
2342                 return RECORDER_ERROR_INVALID_PARAMETER;
2343         }
2344         int ret = RECORDER_ERROR_NONE;
2345         muse_recorder_api_e api = MUSE_RECORDER_API_SET_VIDEO_ENCODER;
2346         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2347         int sock_fd;
2348         if (pc->cb_info == NULL) {
2349                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2350                 return RECORDER_ERROR_INVALID_PARAMETER;
2351         }
2352         sock_fd = pc->cb_info->fd;
2353         int set_codec = (int)codec;
2354
2355         LOGD("ENTER");
2356
2357         muse_recorder_msg_send1(api,
2358                                                         sock_fd,
2359                                                         pc->cb_info,
2360                                                         ret,
2361                                                         INT, set_codec);
2362         LOGD("ret : 0x%x", ret);
2363         return ret;
2364 }
2365
2366
2367 int recorder_get_video_encoder(recorder_h recorder, recorder_video_codec_e *codec)
2368 {
2369         int ret = RECORDER_ERROR_NONE;
2370         int sock_fd = 0;
2371         muse_recorder_api_e api = MUSE_RECORDER_API_GET_VIDEO_ENCODER;
2372         recorder_cli_s *pc = NULL;
2373
2374         if (recorder == NULL) {
2375                 LOGE("NULL pointer handle");
2376                 return RECORDER_ERROR_INVALID_PARAMETER;
2377         }
2378
2379         if (codec == NULL) {
2380                 LOGE("codec is NULL");
2381                 return RECORDER_ERROR_INVALID_PARAMETER;
2382         }
2383
2384         pc = (recorder_cli_s *)recorder;
2385         if (pc->cb_info == NULL) {
2386                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2387                 return RECORDER_ERROR_INVALID_PARAMETER;
2388         }
2389
2390         sock_fd = pc->cb_info->fd;
2391
2392         LOGD("ENTER");
2393
2394         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
2395
2396         if (ret == RECORDER_ERROR_NONE)
2397                 *codec = (recorder_audio_codec_e)pc->cb_info->get_int_value[_RECORDER_GET_INT_VIDEO_ENCODER];
2398
2399         LOGD("ret : 0x%x, codec %d", ret, *codec);
2400
2401         return ret;
2402 }
2403
2404
2405 int recorder_attr_set_audio_samplerate(recorder_h recorder, int samplerate)
2406 {
2407         if (recorder == NULL) {
2408                 LOGE("NULL pointer handle");
2409                 return RECORDER_ERROR_INVALID_PARAMETER;
2410         }
2411         if (samplerate < 1) {
2412                 LOGE("invalid samplerate %d", samplerate);
2413                 return RECORDER_ERROR_INVALID_PARAMETER;
2414         }
2415         int ret = RECORDER_ERROR_NONE;
2416         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_AUDIO_SAMPLERATE;
2417         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2418         int sock_fd;
2419         if (pc->cb_info == NULL) {
2420                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2421                 return RECORDER_ERROR_INVALID_PARAMETER;
2422         }
2423         sock_fd = pc->cb_info->fd;
2424
2425         LOGD("ENTER, samplerate : %d", samplerate);
2426
2427         muse_recorder_msg_send1(api,
2428                                                         sock_fd,
2429                                                         pc->cb_info,
2430                                                         ret,
2431                                                         INT, samplerate);
2432         LOGD("ret : 0x%x, samplerate : %d", ret, samplerate);
2433         return ret;
2434 }
2435
2436
2437 int recorder_attr_set_audio_encoder_bitrate(recorder_h recorder, int bitrate)
2438 {
2439         if (recorder == NULL) {
2440                 LOGE("NULL pointer handle");
2441                 return RECORDER_ERROR_INVALID_PARAMETER;
2442         }
2443         if (bitrate < 1) {
2444                 LOGE("invalid bitrate %d", bitrate);
2445                 return RECORDER_ERROR_INVALID_PARAMETER;
2446         }
2447         int ret = RECORDER_ERROR_NONE;
2448         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_AUDIO_ENCODER_BITRATE;
2449         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2450         int sock_fd;
2451         if (pc->cb_info == NULL) {
2452                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2453                 return RECORDER_ERROR_INVALID_PARAMETER;
2454         }
2455         sock_fd = pc->cb_info->fd;
2456
2457         LOGD("ENTER");
2458
2459         muse_recorder_msg_send1(api,
2460                                                         sock_fd,
2461                                                         pc->cb_info,
2462                                                         ret,
2463                                                         INT, bitrate);
2464         LOGD("ret : 0x%x", ret);
2465         return ret;
2466 }
2467
2468
2469 int recorder_attr_set_video_encoder_bitrate(recorder_h recorder, int bitrate)
2470 {
2471         if (recorder == NULL) {
2472                 LOGE("NULL pointer handle");
2473                 return RECORDER_ERROR_INVALID_PARAMETER;
2474         }
2475
2476         int ret = RECORDER_ERROR_NONE;
2477         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_VIDEO_ENCODER_BITRATE;
2478         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2479         int sock_fd;
2480         if (pc->cb_info == NULL) {
2481                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2482                 return RECORDER_ERROR_INVALID_PARAMETER;
2483         }
2484         sock_fd = pc->cb_info->fd;
2485
2486         LOGD("ENTER");
2487
2488         muse_recorder_msg_send1(api,
2489                                                         sock_fd,
2490                                                         pc->cb_info,
2491                                                         ret,
2492                                                         INT, bitrate);
2493         LOGD("ret : 0x%x", ret);
2494         return ret;
2495 }
2496
2497
2498 int recorder_attr_get_size_limit(recorder_h recorder, int *kbyte)
2499 {
2500         int ret = RECORDER_ERROR_NONE;
2501         int sock_fd = 0;
2502         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_SIZE_LIMIT;
2503         recorder_cli_s *pc = NULL;
2504
2505         if (recorder == NULL) {
2506                 LOGE("NULL pointer handle");
2507                 return RECORDER_ERROR_INVALID_PARAMETER;
2508         }
2509
2510         if (kbyte == NULL) {
2511                 LOGE("NULL pointer kbyte");
2512                 return RECORDER_ERROR_INVALID_PARAMETER;
2513         }
2514
2515         pc = (recorder_cli_s *)recorder;
2516         if (pc->cb_info == NULL) {
2517                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2518                 return RECORDER_ERROR_INVALID_PARAMETER;
2519         }
2520
2521         sock_fd = pc->cb_info->fd;
2522
2523         LOGD("ENTER");
2524
2525         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
2526
2527         if (ret == RECORDER_ERROR_NONE)
2528                 *kbyte = pc->cb_info->get_int_value[_RECORDER_GET_INT_SIZE_LIMIT];
2529
2530         LOGD("ret : 0x%x, %d kbyte", ret, *kbyte);
2531
2532         return ret;
2533 }
2534
2535
2536 int recorder_attr_get_time_limit(recorder_h recorder, int *second)
2537 {
2538         int ret = RECORDER_ERROR_NONE;
2539         int sock_fd = 0;
2540         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_TIME_LIMIT;
2541         recorder_cli_s *pc = NULL;
2542
2543         if (recorder == NULL) {
2544                 LOGE("NULL pointer handle");
2545                 return RECORDER_ERROR_INVALID_PARAMETER;
2546         }
2547
2548         if (second == NULL) {
2549                 LOGE("NULL pointer second");
2550                 return RECORDER_ERROR_INVALID_PARAMETER;
2551         }
2552
2553         pc = (recorder_cli_s *)recorder;
2554         if (pc->cb_info == NULL) {
2555                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2556                 return RECORDER_ERROR_INVALID_PARAMETER;
2557         }
2558
2559         sock_fd = pc->cb_info->fd;
2560
2561         LOGD("ENTER");
2562
2563         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
2564
2565         if (ret == RECORDER_ERROR_NONE)
2566                 *second = pc->cb_info->get_int_value[_RECORDER_GET_INT_TIME_LIMIT];
2567
2568         LOGD("ret : 0x%x, %d second", ret, *second);
2569
2570         return ret;
2571 }
2572
2573
2574 int recorder_attr_get_audio_device(recorder_h recorder, recorder_audio_device_e *device)
2575 {
2576         int ret = RECORDER_ERROR_NONE;
2577         int sock_fd = 0;
2578         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_AUDIO_DEVICE;
2579         recorder_cli_s *pc = NULL;
2580
2581         if (recorder == NULL) {
2582                 LOGE("NULL pointer handle");
2583                 return RECORDER_ERROR_INVALID_PARAMETER;
2584         }
2585
2586         if (device == NULL) {
2587                 LOGE("NULL pointer device");
2588                 return RECORDER_ERROR_INVALID_PARAMETER;
2589         }
2590
2591         pc = (recorder_cli_s *)recorder;
2592         if (pc->cb_info == NULL) {
2593                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2594                 return RECORDER_ERROR_INVALID_PARAMETER;
2595         }
2596
2597         sock_fd = pc->cb_info->fd;
2598
2599         LOGD("ENTER");
2600
2601         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
2602
2603         if (ret == RECORDER_ERROR_NONE)
2604                 *device = (recorder_audio_device_e)pc->cb_info->get_int_value[_RECORDER_GET_INT_AUDIO_DEVICE];
2605
2606         LOGD("ret : 0x%x, device %d", ret, *device);
2607
2608         return ret;
2609 }
2610
2611
2612 int recorder_attr_get_audio_samplerate(recorder_h recorder, int *samplerate)
2613 {
2614         int ret = RECORDER_ERROR_NONE;
2615         int sock_fd = 0;
2616         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_AUDIO_SAMPLERATE;
2617         recorder_cli_s *pc = NULL;
2618
2619         if (recorder == NULL) {
2620                 LOGE("NULL pointer handle");
2621                 return RECORDER_ERROR_INVALID_PARAMETER;
2622         }
2623
2624         if (samplerate == NULL) {
2625                 LOGE("NULL pointer handle");
2626                 return RECORDER_ERROR_INVALID_PARAMETER;
2627         }
2628
2629         pc = (recorder_cli_s *)recorder;
2630         if (pc->cb_info == NULL) {
2631                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2632                 return RECORDER_ERROR_INVALID_PARAMETER;
2633         }
2634
2635         sock_fd = pc->cb_info->fd;
2636
2637         LOGD("ENTER");
2638
2639         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
2640
2641         if (ret == RECORDER_ERROR_NONE)
2642                 *samplerate = pc->cb_info->get_int_value[_RECORDER_GET_INT_AUDIO_SAMPLERATE];
2643
2644         LOGD("ret : 0x%x, samplerate %d", ret, *samplerate);
2645
2646         return ret;
2647 }
2648
2649
2650 int recorder_attr_get_audio_encoder_bitrate(recorder_h recorder, int *bitrate)
2651 {
2652         int ret = RECORDER_ERROR_NONE;
2653         int sock_fd = 0;
2654         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_AUDIO_ENCODER_BITRATE;
2655         recorder_cli_s *pc = NULL;
2656
2657         if (recorder == NULL) {
2658                 LOGE("NULL pointer handle");
2659                 return RECORDER_ERROR_INVALID_PARAMETER;
2660         }
2661
2662         if (bitrate == NULL) {
2663                 LOGE("NULL pointer");
2664                 return RECORDER_ERROR_INVALID_PARAMETER;
2665         }
2666
2667         pc = (recorder_cli_s *)recorder;
2668         if (pc->cb_info == NULL) {
2669                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2670                 return RECORDER_ERROR_INVALID_PARAMETER;
2671         }
2672
2673         sock_fd = pc->cb_info->fd;
2674
2675         LOGD("ENTER");
2676
2677         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
2678
2679         if (ret == RECORDER_ERROR_NONE)
2680                 *bitrate = pc->cb_info->get_int_value[_RECORDER_GET_INT_AUDIO_ENCODER_BITRATE];
2681
2682         LOGD("ret : 0x%x, bitrate %d", ret, *bitrate);
2683
2684         return ret;
2685 }
2686
2687
2688 int recorder_attr_get_video_encoder_bitrate(recorder_h recorder, int *bitrate)
2689 {
2690         int ret = RECORDER_ERROR_NONE;
2691         int sock_fd = 0;
2692         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_VIDEO_ENCODER_BITRATE;
2693         recorder_cli_s *pc = NULL;
2694
2695         if (recorder == NULL) {
2696                 LOGE("NULL pointer handle");
2697                 return RECORDER_ERROR_INVALID_PARAMETER;
2698         }
2699
2700         if (bitrate == NULL) {
2701                 LOGE("NULL pointer");
2702                 return RECORDER_ERROR_INVALID_PARAMETER;
2703         }
2704
2705         pc = (recorder_cli_s *)recorder;
2706         if (pc->cb_info == NULL) {
2707                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2708                 return RECORDER_ERROR_INVALID_PARAMETER;
2709         }
2710
2711         sock_fd = pc->cb_info->fd;
2712
2713         LOGD("ENTER");
2714
2715         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
2716
2717         if (ret == RECORDER_ERROR_NONE)
2718                 *bitrate = pc->cb_info->get_int_value[_RECORDER_GET_INT_VIDEO_ENCODER_BITRATE];
2719
2720         LOGD("ret : 0x%x", ret);
2721
2722         return ret;
2723 }
2724
2725
2726 int recorder_foreach_supported_audio_encoder(recorder_h recorder, recorder_supported_audio_encoder_cb foreach_cb, void *user_data)
2727 {
2728         if (recorder == NULL || foreach_cb == NULL) {
2729                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2730                 return RECORDER_ERROR_INVALID_PARAMETER;
2731         }
2732         int ret = RECORDER_ERROR_NONE;
2733
2734         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2735         muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_AUDIO_ENCODER;
2736
2737         LOGD("Enter, handle :%x", pc->remote_handle);
2738
2739         int sock_fd;
2740         if (pc->cb_info == NULL) {
2741                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2742                 return RECORDER_ERROR_INVALID_PARAMETER;
2743         }
2744         sock_fd = pc->cb_info->fd;
2745         pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_AUDIO_ENCODER] = foreach_cb;
2746         pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_AUDIO_ENCODER] = user_data;
2747
2748         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
2749         LOGD("ret : 0x%x", ret);
2750         return ret;
2751 }
2752
2753
2754 int recorder_foreach_supported_video_encoder(recorder_h recorder, recorder_supported_video_encoder_cb foreach_cb, void *user_data)
2755 {
2756         if (recorder == NULL || foreach_cb == NULL) {
2757                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2758                 return RECORDER_ERROR_INVALID_PARAMETER;
2759         }
2760         int ret = RECORDER_ERROR_NONE;
2761
2762         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2763         muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_VIDEO_ENCODER;
2764
2765         LOGD("Enter, handle :%x", pc->remote_handle);
2766
2767         int sock_fd;
2768         if (pc->cb_info == NULL) {
2769                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2770                 return RECORDER_ERROR_INVALID_PARAMETER;
2771         }
2772         sock_fd = pc->cb_info->fd;
2773         pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_ENCODER] = foreach_cb;
2774         pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_ENCODER] = user_data;
2775
2776         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
2777         LOGD("ret : 0x%x", ret);
2778         return ret;
2779 }
2780
2781
2782 int recorder_attr_set_mute(recorder_h recorder, bool enable)
2783 {
2784         if (recorder == NULL) {
2785                 LOGE("NULL pointer handle");
2786                 return RECORDER_ERROR_INVALID_PARAMETER;
2787         }
2788         int ret = RECORDER_ERROR_NONE;
2789         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_MUTE;
2790         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2791         int sock_fd;
2792         if (pc->cb_info == NULL) {
2793                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2794                 return RECORDER_ERROR_INVALID_PARAMETER;
2795         }
2796         sock_fd = pc->cb_info->fd;
2797         int set_enable = (int)enable;
2798
2799         LOGD("ENTER");
2800
2801         muse_recorder_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_enable);
2802
2803         LOGD("ret : 0x%x", ret);
2804
2805         return ret;
2806 }
2807
2808
2809 bool recorder_attr_is_muted(recorder_h recorder)
2810 {
2811         if (recorder == NULL) {
2812                 LOGE("NULL pointer handle");
2813                 return false;
2814         }
2815         int ret = RECORDER_ERROR_NONE;
2816         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_IS_MUTED;
2817         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2818         int sock_fd;
2819         if (pc->cb_info == NULL) {
2820                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2821                 return RECORDER_ERROR_INVALID_PARAMETER;
2822         }
2823         sock_fd = pc->cb_info->fd;
2824
2825         LOGD("ENTER");
2826
2827         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
2828         LOGD("ret : 0x%x", ret);
2829         return ret;
2830 }
2831
2832
2833 int recorder_attr_set_recording_motion_rate(recorder_h recorder, double rate)
2834 {
2835         if (recorder == NULL) {
2836                 LOGE("NULL pointer handle");
2837                 return RECORDER_ERROR_INVALID_PARAMETER;
2838         }
2839         int ret = RECORDER_ERROR_NONE;
2840         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_RECORDING_MOTION_RATE;
2841         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2842         int sock_fd;
2843         if (pc->cb_info == NULL) {
2844                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2845                 return RECORDER_ERROR_INVALID_PARAMETER;
2846         }
2847         sock_fd = pc->cb_info->fd;
2848
2849         LOGD("ENTER - %.20lf", rate);
2850
2851         muse_recorder_msg_send1(api,
2852                                                         sock_fd,
2853                                                         pc->cb_info,
2854                                                         ret,
2855                                                         DOUBLE, rate);
2856
2857         LOGD("ret : 0x%x", ret);
2858
2859         return ret;
2860 }
2861
2862
2863 int recorder_attr_get_recording_motion_rate(recorder_h recorder, double *rate)
2864 {
2865         int ret = RECORDER_ERROR_NONE;
2866         int sock_fd = 0;
2867         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_RECORDING_MOTION_RATE;
2868         recorder_cli_s *pc = NULL;
2869
2870         if (recorder == NULL) {
2871                 LOGE("NULL pointer handle");
2872                 return RECORDER_ERROR_INVALID_PARAMETER;
2873         }
2874
2875         if (rate == NULL) {
2876                 LOGE("rate is NULL");
2877                 return RECORDER_ERROR_INVALID_PARAMETER;
2878         }
2879
2880         pc = (recorder_cli_s *)recorder;
2881         if (pc->cb_info == NULL) {
2882                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2883                 return RECORDER_ERROR_INVALID_PARAMETER;
2884         }
2885
2886         sock_fd = pc->cb_info->fd;
2887
2888         LOGD("ENTER");
2889
2890         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
2891         if (ret == RECORDER_ERROR_NONE)
2892                 *rate = pc->cb_info->get_double_value[_RECORDER_GET_DOUBLE_RECORDING_MOTION_RATE];
2893
2894         LOGD("ret : 0x%x - rate %lf", ret, *rate);
2895
2896         return ret;
2897 }
2898
2899
2900 int recorder_attr_set_audio_channel(recorder_h recorder, int channel_count)
2901 {
2902         if (recorder == NULL) {
2903                 LOGE("NULL pointer handle");
2904                 return RECORDER_ERROR_INVALID_PARAMETER;
2905         }
2906         int ret = RECORDER_ERROR_NONE;
2907         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_AUDIO_CHANNEL;
2908         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2909         int sock_fd;
2910         if (pc->cb_info == NULL) {
2911                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2912                 return RECORDER_ERROR_INVALID_PARAMETER;
2913         }
2914         sock_fd = pc->cb_info->fd;
2915
2916         LOGD("ENTER");
2917
2918         muse_recorder_msg_send1(api,
2919                                                         sock_fd,
2920                                                         pc->cb_info,
2921                                                         ret,
2922                                                         INT, channel_count);
2923         LOGD("ret : 0x%x", ret);
2924         return ret;
2925 }
2926
2927
2928 int recorder_attr_get_audio_channel(recorder_h recorder, int *channel_count)
2929 {
2930         int ret = RECORDER_ERROR_NONE;
2931         int sock_fd = 0;
2932         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_AUDIO_CHANNEL;
2933         recorder_cli_s *pc = NULL;
2934
2935         if (recorder == NULL) {
2936                 LOGE("NULL pointer handle");
2937                 return RECORDER_ERROR_INVALID_PARAMETER;
2938         }
2939
2940         if (channel_count == NULL) {
2941                 LOGE("channel_count is NULL");
2942                 return RECORDER_ERROR_INVALID_PARAMETER;
2943         }
2944
2945         pc = (recorder_cli_s *)recorder;
2946         if (pc->cb_info == NULL) {
2947                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2948                 return RECORDER_ERROR_INVALID_PARAMETER;
2949         }
2950
2951         sock_fd = pc->cb_info->fd;
2952
2953         LOGD("ENTER");
2954
2955         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
2956
2957         if (ret == RECORDER_ERROR_NONE)
2958                 *channel_count = pc->cb_info->get_int_value[_RECORDER_GET_INT_AUDIO_CHANNEL];
2959
2960         LOGD("ret : 0x%x, channel count %d", ret, *channel_count);
2961
2962         return ret;
2963 }
2964
2965
2966 int recorder_attr_set_orientation_tag(recorder_h recorder, recorder_rotation_e orientation)
2967 {
2968         if (recorder == NULL) {
2969                 LOGE("NULL pointer handle");
2970                 return RECORDER_ERROR_INVALID_PARAMETER;
2971         }
2972         if (orientation > RECORDER_ROTATION_270) {
2973                 LOGE("invalid orientation %d", orientation);
2974                 return RECORDER_ERROR_INVALID_PARAMETER;
2975         }
2976         int ret = RECORDER_ERROR_NONE;
2977         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_ORIENTATION_TAG;
2978         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2979         int sock_fd;
2980         if (pc->cb_info == NULL) {
2981                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2982                 return RECORDER_ERROR_INVALID_PARAMETER;
2983         }
2984         sock_fd = pc->cb_info->fd;
2985         int set_orientation = (int)orientation;
2986
2987         LOGD("ENTER");
2988
2989         muse_recorder_msg_send1(api,
2990                                                         sock_fd,
2991                                                         pc->cb_info,
2992                                                         ret,
2993                                                         INT, set_orientation);
2994         LOGD("ret : 0x%x", ret);
2995         return ret;
2996 }
2997
2998
2999 int  recorder_attr_get_orientation_tag(recorder_h recorder, recorder_rotation_e *orientation)
3000 {
3001         int ret = RECORDER_ERROR_NONE;
3002         int sock_fd = 0;
3003         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_ORIENTATION_TAG;
3004         recorder_cli_s *pc = NULL;
3005
3006         if (recorder == NULL) {
3007                 LOGE("NULL pointer handle");
3008                 return RECORDER_ERROR_INVALID_PARAMETER;
3009         }
3010
3011         if (orientation == NULL) {
3012                 LOGE("orientation is NULL");
3013                 return RECORDER_ERROR_INVALID_PARAMETER;
3014         }
3015
3016         pc = (recorder_cli_s *)recorder;
3017         if (pc->cb_info == NULL) {
3018                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
3019                 return RECORDER_ERROR_INVALID_PARAMETER;
3020         }
3021
3022         sock_fd = pc->cb_info->fd;
3023
3024         LOGD("ENTER");
3025
3026         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
3027
3028         if (ret == RECORDER_ERROR_NONE)
3029                 *orientation = (recorder_rotation_e)pc->cb_info->get_int_value[_RECORDER_GET_INT_ORIENTATION_TAG];
3030
3031         LOGD("ret : 0x%x, orientation %d", ret, *orientation);
3032
3033         return ret;
3034 }