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 <mm_types.h>
  21 #include <recorder.h>
  22 #include <muse_recorder.h>
  23 #include <muse_recorder_msg.h>
  24 #include <muse_core_ipc.h>
  25 #include <recorder_private.h>
  26 #include <glib.h>
  27 #include <muse_core.h>
  28 #include <muse_core_msg_json.h>
  29 #include <mm_camcorder_client.h>
  30 #include <dlog.h>
  31
  32 #ifdef LOG_TAG
  33 #undef LOG_TAG
  34 #endif
  35 #define LOG_TAG "TIZEN_N_RECORDER"
  36
  37
  38 static int _recorder_import_tbm_key(tbm_bufmgr bufmgr, unsigned int tbm_key, tbm_bo *bo, tbm_bo_handle *bo_handle)
  39 {
  40         tbm_bo tmp_bo = NULL;
  41         tbm_bo_handle tmp_bo_handle = {NULL, };
  42
  43         if (bufmgr == NULL || bo == NULL || bo_handle == NULL || tbm_key == 0) {
  44                 LOGE("invalid parameter - bufmgr %p, bo %p, bo_handle %p, key %d",
  45                      bufmgr, bo, bo_handle, tbm_key);
  46                 return false;
  47         }
  48
  49         tmp_bo = tbm_bo_import(bufmgr, tbm_key);
  50         if (tmp_bo == NULL) {
  51                 LOGE("bo import failed - bufmgr %p, key %d", bufmgr, tbm_key);
  52                 return false;
  53         }
  54
  55         tmp_bo_handle = tbm_bo_map(tmp_bo, TBM_DEVICE_CPU, TBM_OPTION_READ);
  56         if (tmp_bo_handle.ptr == NULL) {
  57                 LOGE("bo map failed %p", tmp_bo);
  58                 tbm_bo_unref(tmp_bo);
  59                 tmp_bo = NULL;
  60                 return false;
  61         }
  62
  63         /* set bo and bo_handle */
  64         *bo = tmp_bo;
  65         *bo_handle = tmp_bo_handle;
  66
  67         return true;
  68 }
  69
  70 static void _recorder_release_imported_bo(tbm_bo *bo)
  71 {
  72         if (bo == NULL || *bo == NULL) {
  73                 LOGW("NULL bo");
  74                 return;
  75         }
  76
  77         tbm_bo_unmap(*bo);
  78         tbm_bo_unref(*bo);
  79         *bo = NULL;
  80
  81         return;
  82 }
  83
  84 static void _client_user_callback(callback_cb_info_s * cb_info, muse_recorder_event_e event)
  85 {
  86         char *recvMsg = cb_info->recvMsg;
  87         LOGD("get event %d", event);
  88
  89         switch (event) {
  90                 case MUSE_RECORDER_EVENT_TYPE_STATE_CHANGE:
  91                 {
  92                         int previous = 0;
  93                         int current = 0;
  94                         int by_policy = 0;
  95
  96                         muse_recorder_msg_get(previous, recvMsg);
  97                         muse_recorder_msg_get(current, recvMsg);
  98                         muse_recorder_msg_get(by_policy, recvMsg);
  99
 100                         ((recorder_state_changed_cb)cb_info->user_cb[event])((recorder_state_e)previous,
 101                                                                              (recorder_state_e)current,
 102                                                                              (bool)by_policy,
 103                                                                              cb_info->user_data[event]);
 104                         break;
 105                 }
 106                 case MUSE_RECORDER_EVENT_TYPE_RECORDING_LIMITED:
 107                 {
 108                         int type = 0;
 109
 110                         muse_recorder_msg_get(type, recvMsg);
 111
 112                         ((recorder_recording_limit_reached_cb)cb_info->user_cb[event])((recorder_recording_limit_type_e)type,
 113                                                                                        cb_info->user_data[event]);
 114                         break;
 115                 }
 116                 case MUSE_RECORDER_EVENT_TYPE_RECORDING_STATUS:
 117                 {
 118                         int64_t cb_elapsed_time = 0;
 119                         int64_t cb_file_size = 0;
 120
 121                         muse_recorder_msg_get(cb_elapsed_time, recvMsg);
 122                         muse_recorder_msg_get(cb_file_size, recvMsg);
 123
 124                         ((recorder_recording_status_cb)cb_info->user_cb[event])((unsigned long long)cb_elapsed_time,
 125                                                                                 (unsigned long long)cb_file_size,
 126                                                                                 cb_info->user_data[event]);
 127                         break;
 128                 }
 129                 case MUSE_RECORDER_EVENT_TYPE_INTERRUPTED:
 130                 {
 131                         int policy = 0;
 132                         int previous = 0;
 133                         int current = 0;
 134
 135                         muse_recorder_msg_get(policy, recvMsg);
 136                         muse_recorder_msg_get(previous, recvMsg);
 137                         muse_recorder_msg_get(current, recvMsg);
 138
 139                         ((recorder_interrupted_cb)cb_info->user_cb[event])((recorder_policy_e)policy,
 140                                                                            (recorder_state_e)previous,
 141                                                                            (recorder_state_e)current,
 142                                                                            cb_info->user_data[event]);
 143                         break;
 144                 }
 145                 case MUSE_RECORDER_EVENT_TYPE_AUDIO_STREAM:
 146                 {
 147                         int tbm_key = 0;
 148                         int size = 0;
 149                         int format = 0;
 150                         int channel = 0;
 151                         int timestamp = 0;
 152                         tbm_bo bo = NULL;
 153                         tbm_bo_handle bo_handle = {.ptr = NULL};
 154
 155                         muse_recorder_msg_get(tbm_key, recvMsg);
 156                         if (tbm_key == 0) {
 157                                 LOGE("invalid key");
 158                                 break;
 159                         }
 160
 161                         if (!_recorder_import_tbm_key(cb_info->bufmgr, tbm_key, &bo, &bo_handle)) {
 162                                 LOGE("tbm key %d import failed", tbm_key);
 163                                 break;
 164                         }
 165
 166                         muse_recorder_msg_get(size, recvMsg);
 167                         muse_recorder_msg_get(format, recvMsg);
 168                         muse_recorder_msg_get(channel, recvMsg);
 169                         muse_recorder_msg_get(timestamp, recvMsg);
 170
 171                         ((recorder_audio_stream_cb)cb_info->user_cb[event])((void *)bo_handle.ptr,
 172                                                                             size,
 173                                                                             (audio_sample_type_e)format,
 174                                                                             channel,
 175                                                                             (unsigned int)timestamp,
 176                                                                             cb_info->user_data[event]);
 177
 178                         /* release imported bo */
 179                         _recorder_release_imported_bo(&bo);
 180
 181                         /* return buffer */
 182                         muse_recorder_msg_send1_no_return(MUSE_RECORDER_API_RETURN_BUFFER,
 183                                                           cb_info->fd, cb_info,
 184                                                           INT, tbm_key);
 185                         break;
 186                 }
 187                 case MUSE_RECORDER_EVENT_TYPE_ERROR:
 188                 {
 189                         int error = 0;
 190                         int current_state = 0;
 191
 192                         muse_recorder_msg_get(error, recvMsg);
 193                         muse_recorder_msg_get(current_state, recvMsg);
 194
 195                         ((recorder_error_cb)cb_info->user_cb[event])((recorder_error_e)error,
 196                                                                      (recorder_state_e)current_state,
 197                                                                      cb_info->user_data[event]);
 198                         break;
 199                 }
 200                 case MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_AUDIO_ENCODER:
 201                 {
 202                         int codec = 0;
 203
 204                         muse_recorder_msg_get(codec, recvMsg);
 205
 206                         ((recorder_supported_audio_encoder_cb)cb_info->user_cb[event])((recorder_audio_codec_e)codec,
 207                                                                                        cb_info->user_data[event]);
 208                         break;
 209                 }
 210                 case MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_FILE_FORMAT:
 211                 {
 212                         int format = 0;
 213
 214                         muse_recorder_msg_get(format, recvMsg);
 215
 216                         ((recorder_supported_file_format_cb)cb_info->user_cb[event])((recorder_file_format_e)format,
 217                                                                                      cb_info->user_data[event]);
 218                         break;
 219                 }
 220                 case MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_ENCODER:
 221                 {
 222                         int codec = 0;
 223
 224                         muse_recorder_msg_get(codec, recvMsg);
 225
 226                         ((recorder_supported_video_encoder_cb)cb_info->user_cb[event])((recorder_video_codec_e)codec,
 227                                                                                        cb_info->user_data[event]);
 228                         break;
 229                 }
 230                 case MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_RESOLUTION:
 231                 {
 232                         int width = 0;
 233                         int height = 0;
 234
 235                         muse_recorder_msg_get(width, recvMsg);
 236                         muse_recorder_msg_get(height, recvMsg);
 237
 238                         ((recorder_supported_video_resolution_cb)cb_info->user_cb[event])(width, height,
 239                                                                                           cb_info->user_data[event]);
 240                         break;
 241                 }
 242
 243                 default:
 244                         LOGE("Unknonw event");
 245                         break;
 246         }
 247         return;
 248 }
 249
 250 static void *_client_cb_handler(gpointer data)
 251 {
 252         int ret = 0;
 253         int api = 0;
 254         int num_token = 0;
 255         int i = 0;
 256         int str_pos = 0;
 257         int prev_pos = 0;
 258         callback_cb_info_s *cb_info = data;
 259         char *recvMsg = NULL;
 260         char **parseStr = NULL;
 261
 262         if (cb_info == NULL) {
 263                 LOGE("cb_info NULL");
 264                 return NULL;
 265         }
 266
 267         parseStr = (char **)malloc(sizeof(char *) * RECORDER_PARSE_STRING_SIZE);
 268         if (parseStr == NULL) {
 269                 LOGE("parseStr malloc failed");
 270                 return NULL;
 271         }
 272
 273         for (i = 0 ; i < RECORDER_PARSE_STRING_SIZE ; i++) {
 274                 parseStr[i] = (char *)malloc(sizeof(char) * MUSE_RECORDER_MSG_MAX_LENGTH);
 275                 if (parseStr[i] == NULL) {
 276                         LOGE("parseStr[%d] malloc failed", i);
 277                         goto CB_HANDLER_EXIT;
 278                 }
 279         }
 280
 281         recvMsg = cb_info->recvMsg;
 282
 283         while (g_atomic_int_get(&cb_info->running)) {
 284                 ret = muse_core_ipc_recv_msg(cb_info->fd, recvMsg);
 285                 if (ret <= 0)
 286                         break;
 287                 recvMsg[ret] = '\0';
 288
 289                 str_pos = 0;
 290                 prev_pos = 0;
 291                 num_token = 0;
 292
 293                 LOGD("recvMSg : %s, length : %d", recvMsg, ret);
 294
 295                 /* Need to split the combined entering msgs.
 296                     This module supports up to 5 combined msgs. */
 297                 for (str_pos = 0; str_pos < ret; str_pos++) {
 298                         if(recvMsg[str_pos] == '}') {
 299                                 memset(parseStr[num_token], 0x0, sizeof(char) * MUSE_RECORDER_MSG_MAX_LENGTH);
 300                                 strncpy(&(parseStr[num_token][0]), recvMsg + prev_pos, str_pos - prev_pos + 1);
 301                                 LOGD("splitted msg : %s, Index : %d", &(parseStr[num_token][0]), num_token);
 302                                 prev_pos = str_pos+1;
 303                                 num_token++;
 304                         }
 305                 }
 306
 307                 LOGD("num_token : %d", num_token);
 308
 309                 /* Re-construct to the useful single msg. */
 310                 for (i = 0 ; i < num_token ; i++) {
 311                         if (i >= RECORDER_PARSE_STRING_SIZE) {
 312                                 LOGE("invalid index %d", i);
 313                                 break;
 314                         }
 315
 316                         if (muse_recorder_msg_get(api, &(parseStr[i][0]))) {
 317                                 if(api < MUSE_RECORDER_API_MAX){
 318                                         LOGD("api : %d, wait ends.", api);
 319
 320                                         g_mutex_lock(&(cb_info->pMutex[api]));
 321
 322                                         /* The api msgs should be distinguished from the event msg. */
 323                                         memset(cb_info->recvApiMsg, 0, strlen(cb_info->recvApiMsg));
 324                                         strcpy(cb_info->recvApiMsg, &(parseStr[i][0]));
 325
 326                                         LOGD("cb_info->recvApiMsg : %s", cb_info->recvApiMsg);
 327
 328                                         cb_info->activating[api] = 1;
 329
 330                                         if (api == MUSE_RECORDER_API_CREATE) {
 331                                                 if (muse_recorder_msg_get(ret, cb_info->recvApiMsg)) {
 332                                                         if (ret != RECORDER_ERROR_NONE) {
 333                                                                 g_atomic_int_set(&cb_info->running, 0);
 334                                                                 LOGE("recorder create error 0x%x. close client cb handler", ret);
 335                                                         }
 336                                                 } else {
 337                                                         LOGE("failed to get api return");
 338                                                 }
 339                                         } else if (api == MUSE_RECORDER_API_DESTROY) {
 340                                                 if (muse_recorder_msg_get(ret, cb_info->recvApiMsg)) {
 341                                                         if (ret == RECORDER_ERROR_NONE) {
 342                                                                 g_atomic_int_set(&cb_info->running, 0);
 343                                                                 LOGD("recorder destroy done. close client cb handler");
 344                                                         }
 345                                                 } else {
 346                                                         LOGE("failed to get api return");
 347                                                 }
 348                                         }
 349
 350                                         g_cond_signal(&(cb_info->pCond[api]));
 351                                         g_mutex_unlock(&(cb_info->pMutex[api]));
 352                                 } else if (api == MUSE_RECORDER_CB_EVENT) {
 353                                         int event = -1;
 354
 355                                         if (muse_recorder_msg_get(event, &(parseStr[i][0]))) {
 356                                                 LOGD("go callback : %d", event);
 357                                                 _client_user_callback(cb_info, event);
 358                                         }
 359                                 }
 360                         }else{
 361                                 LOGD("muse_recorder_msg_get FAIL");
 362                         }
 363                 }
 364         }
 365
 366         LOGD("client cb exit");
 367
 368 CB_HANDLER_EXIT:
 369         if (parseStr) {
 370                 for (i = 0 ; i < RECORDER_PARSE_STRING_SIZE ; i++) {
 371                         if (parseStr[i]) {
 372                                 free(parseStr[i]);
 373                                 parseStr[i] = NULL;
 374                         }
 375                 }
 376
 377                 free(parseStr);
 378                 parseStr = NULL;
 379         }
 380
 381         return NULL;
 382 }
 383
 384 static callback_cb_info_s *_client_callback_new(gint sockfd)
 385 {
 386         callback_cb_info_s *cb_info = NULL;
 387         GCond *recorder_cond = NULL;
 388         GMutex *recorder_mutex = NULL;
 389         gint *recorder_activ = NULL;
 390         g_return_val_if_fail(sockfd > 0, NULL);
 391
 392         cb_info = g_new0(callback_cb_info_s, 1);
 393         if (cb_info == NULL) {
 394                 LOGE("cb_info_s alloc failed");
 395                 goto _ERR_RECORDER_EXIT;
 396         }
 397
 398         recorder_cond = g_new0(GCond, MUSE_RECORDER_API_MAX);
 399         if (recorder_cond == NULL) {
 400                 LOGE("recorder_cond alloc failed");
 401                 goto _ERR_RECORDER_EXIT;
 402         }
 403         recorder_mutex = g_new0(GMutex, MUSE_RECORDER_API_MAX);
 404         if (recorder_mutex == NULL) {
 405                 LOGE("recorder_mutex alloc failed");
 406                 goto _ERR_RECORDER_EXIT;
 407         }
 408         recorder_activ = g_new0(gint, MUSE_RECORDER_API_MAX);
 409         if (recorder_activ == NULL) {
 410                 LOGE("recorder_activ alloc failed");
 411                 goto _ERR_RECORDER_EXIT;
 412         }
 413
 414         g_atomic_int_set(&cb_info->running, 1);
 415         cb_info->fd = sockfd;
 416         cb_info->pCond = recorder_cond;
 417         cb_info->pMutex = recorder_mutex;
 418         cb_info->activating = recorder_activ;
 419         cb_info->thread = g_thread_try_new("callback_thread",
 420                                            _client_cb_handler,
 421                                            (gpointer)cb_info,
 422                                            NULL);
 423         if (cb_info->thread == NULL) {
 424                 LOGE("thread create failed");
 425                 goto _ERR_RECORDER_EXIT;
 426         }
 427
 428         return cb_info;
 429
 430 _ERR_RECORDER_EXIT:
 431         if (cb_info) {
 432                 g_free(cb_info);
 433                 cb_info = NULL;
 434         }
 435         if (recorder_cond) {
 436                 g_free(recorder_cond);
 437                 recorder_cond = NULL;
 438         }
 439         if (recorder_mutex) {
 440                 g_free(recorder_mutex);
 441                 recorder_mutex = NULL;
 442         }
 443         if (recorder_activ) {
 444                 g_free(recorder_activ);
 445                 recorder_activ = NULL;
 446         }
 447
 448         return NULL;
 449 }
 450
 451 static int client_wait_for_cb_return(muse_recorder_api_e api, callback_cb_info_s *cb_info, int time_out)
 452 {
 453         int ret = RECORDER_ERROR_NONE;
 454         gint64 end_time;
 455
 456         LOGD("Enter api : %d", api);
 457         g_mutex_lock(&(cb_info->pMutex[api]));
 458
 459         end_time = g_get_monotonic_time() + time_out * G_TIME_SPAN_SECOND;
 460         if (cb_info->activating[api] != 1) {
 461                 if (g_cond_wait_until(&(cb_info->pCond[api]), &(cb_info->pMutex[api]), end_time)) {
 462                         LOGD("cb_info->recvApiMsg : %s", cb_info->recvApiMsg);
 463                         if (!muse_recorder_msg_get(ret, cb_info->recvApiMsg)) {
 464                                 ret = RECORDER_ERROR_INVALID_OPERATION;
 465                         } else {
 466                                 LOGD("API %d passed successfully", api);
 467                         }
 468                 } else {
 469                         ret = RECORDER_ERROR_INVALID_OPERATION;
 470                 }
 471         } else {
 472                 LOGD("condition is already checked for the api : %d.", api);
 473                 cb_info->activating[api] = 0;
 474                 if (!muse_recorder_msg_get(ret, cb_info->recvApiMsg)) {
 475                         ret = RECORDER_ERROR_INVALID_OPERATION;
 476                 } else {
 477                         LOGD("Already checked condition, Wait passed, ret : 0x%x", ret);
 478                 }
 479         }
 480         g_mutex_unlock(&(cb_info->pMutex[api]));
 481         LOGD("ret of api %d : 0x%x", api, ret);
 482         return ret;
 483 }
 484
 485 static void _client_callback_destroy(callback_cb_info_s * cb_info)
 486 {
 487         g_return_if_fail(cb_info != NULL);
 488
 489         LOGD("destroy thread %p", cb_info->thread);
 490
 491         g_thread_join(cb_info->thread);
 492         g_thread_unref(cb_info->thread);
 493
 494         if (cb_info->pCond) {
 495                 g_free(cb_info->pCond);
 496                 cb_info->pCond = NULL;
 497         }
 498         if (cb_info->pMutex) {
 499                 g_free(cb_info->pMutex);
 500                 cb_info->pMutex = NULL;
 501         }
 502
 503         g_free(cb_info);
 504         cb_info = NULL;
 505
 506         return;
 507 }
 508
 509 static int _recorder_create_common(recorder_h *recorder, muse_recorder_type_e type, camera_h camera)
 510 {
 511         int ret = RECORDER_ERROR_NONE;
 512         int destroy_ret = RECORDER_ERROR_NONE;
 513         int sock_fd = -1;
 514         char *send_msg = NULL;
 515         char *root_directory = NULL;
 516         intptr_t camera_handle = 0;
 517         intptr_t handle = 0;
 518         tbm_bufmgr bufmgr = NULL;
 519         recorder_cli_s *pc = NULL;
 520
 521         LOGD("Enter - type %d", type);
 522
 523         if (recorder == NULL) {
 524                 LOGE("NULL pointer for recorder handle");
 525                 return RECORDER_ERROR_INVALID_PARAMETER;
 526         }
 527
 528         if (type == MUSE_RECORDER_TYPE_VIDEO && camera == NULL) {
 529                 LOGE("NULL pointer for camera handle on video recorder mode");
 530                 return RECORDER_ERROR_INVALID_PARAMETER;
 531         }
 532
 533         bufmgr = tbm_bufmgr_init(-1);
 534         if (bufmgr == NULL) {
 535                 LOGE("get tbm bufmgr failed");
 536                 return RECORDER_ERROR_INVALID_OPERATION;
 537         }
 538
 539         pc = g_new0(recorder_cli_s, 1);
 540         if (pc == NULL) {
 541                 ret = RECORDER_ERROR_OUT_OF_MEMORY;
 542                 goto _ERR_RECORDER_EXIT;
 543         }
 544
 545         sock_fd = muse_core_client_new();
 546         if (sock_fd < 0) {
 547                 LOGE("muse_core_client_new failed - returned fd %d", sock_fd);
 548                 ret = RECORDER_ERROR_INVALID_OPERATION;
 549                 goto _ERR_RECORDER_EXIT;
 550         }
 551
 552         if (type == MUSE_RECORDER_TYPE_AUDIO) {
 553                 send_msg = muse_core_msg_json_factory_new(MUSE_RECORDER_API_CREATE,
 554                                                           MUSE_TYPE_INT, "module", MUSE_RECORDER,
 555                                                           MUSE_TYPE_INT, PARAM_RECORDER_TYPE, MUSE_RECORDER_TYPE_AUDIO,
 556                                                           MUSE_TYPE_INT, "pid", getpid(),
 557                                                           0);
 558         } else {
 559                 camera_handle = (intptr_t)((camera_cli_s *)camera)->remote_handle;
 560                 send_msg = muse_core_msg_json_factory_new(MUSE_RECORDER_API_CREATE,
 561                                                           MUSE_TYPE_INT, "module", MUSE_RECORDER,
 562                                                           MUSE_TYPE_INT, PARAM_RECORDER_TYPE, MUSE_RECORDER_TYPE_VIDEO,
 563                                                           MUSE_TYPE_POINTER, "camera_handle", camera_handle,
 564                                                           0);
 565         }
 566
 567         LOGD("sock_fd : %d, msg : %s", sock_fd, send_msg);
 568
 569         muse_core_ipc_send_msg(sock_fd, send_msg);
 570         muse_core_msg_json_factory_free(send_msg);
 571
 572         pc->cb_info = _client_callback_new(sock_fd);
 573         if (pc->cb_info == NULL) {
 574                 ret = RECORDER_ERROR_OUT_OF_MEMORY;
 575                 goto _ERR_RECORDER_EXIT;
 576         }
 577
 578         ret = client_wait_for_cb_return(MUSE_RECORDER_API_CREATE, pc->cb_info, CALLBACK_TIME_OUT);
 579         if (ret == RECORDER_ERROR_NONE) {
 580                 muse_recorder_msg_get_pointer(handle, pc->cb_info->recvMsg);
 581                 if (handle == 0) {
 582                         LOGE("Receiving Handle Failed!!");
 583                         goto _ERR_RECORDER_EXIT;
 584                 }
 585
 586                 if (mm_camcorder_client_get_root_directory(&root_directory) != MM_ERROR_NONE ||
 587                     root_directory == NULL) {
 588                         LOGE("failed to get root directory of internal storage");
 589                         ret = RECORDER_ERROR_INVALID_OPERATION;
 590                         goto _ERR_RECORDER_AFTER_CREATE;
 591                 }
 592
 593                 LOGD("set root directory [%s]", root_directory);
 594
 595                 muse_recorder_msg_send1(MUSE_RECORDER_API_ATTR_SET_ROOT_DIRECTORY,
 596                                         sock_fd, pc->cb_info, ret, STRING, root_directory);
 597                 if (ret != RECORDER_ERROR_NONE) {
 598                         LOGE("failed to set root directory %s", root_directory);
 599                         ret = RECORDER_ERROR_INVALID_OPERATION;
 600                         goto _ERR_RECORDER_AFTER_CREATE;
 601                 }
 602
 603                 free(root_directory);
 604                 root_directory = NULL;
 605
 606                 pc->remote_handle = handle;
 607                 pc->cb_info->bufmgr = bufmgr;
 608
 609                 LOGD("recorder[type %d] %p create success : remote handle 0x%x",
 610                      type, pc, pc->remote_handle);
 611
 612                 *recorder = (recorder_h) pc;
 613         } else {
 614                 goto _ERR_RECORDER_EXIT;
 615         }
 616
 617         LOGD("done");
 618
 619         return RECORDER_ERROR_NONE;
 620
 621 _ERR_RECORDER_AFTER_CREATE:
 622         muse_recorder_msg_send(MUSE_RECORDER_API_DESTROY, sock_fd, pc->cb_info, destroy_ret);
 623         LOGE("destroy return 0x%x", destroy_ret);
 624
 625 _ERR_RECORDER_EXIT:
 626         tbm_bufmgr_deinit(bufmgr);
 627         bufmgr = NULL;
 628
 629         if (root_directory) {
 630                 free(root_directory);
 631                 root_directory = NULL;
 632         }
 633
 634         if (pc) {
 635                 if (pc->cb_info) {
 636                         _client_callback_destroy(pc->cb_info);
 637                         pc->cb_info = NULL;
 638                 }
 639                 g_free(pc);
 640                 pc = NULL;
 641         }
 642
 643         return ret;
 644 }
 645
 646 int recorder_create_videorecorder(camera_h camera, recorder_h *recorder)
 647 {
 648         return _recorder_create_common(recorder, MUSE_RECORDER_TYPE_VIDEO, camera);
 649 }
 650
 651
 652 int recorder_create_audiorecorder(recorder_h *recorder)
 653 {
 654         return _recorder_create_common(recorder, MUSE_RECORDER_TYPE_AUDIO, NULL);
 655 }
 656
 657 int recorder_get_state(recorder_h recorder, recorder_state_e *state)
 658 {
 659         if (recorder == NULL) {
 660                 LOGE("NULL pointer handle");
 661                 return RECORDER_ERROR_INVALID_PARAMETER;
 662         }
 663         if (state == NULL) {
 664                 LOGE("NULL pointer state");
 665                 return RECORDER_ERROR_INVALID_PARAMETER;
 666         }
 667
 668         int ret = RECORDER_ERROR_NONE;
 669
 670         recorder_cli_s *pc = (recorder_cli_s *)recorder;
 671         muse_recorder_api_e api = MUSE_RECORDER_API_GET_STATE;
 672         int sock_fd;
 673         if (pc->cb_info == NULL) {
 674                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
 675                 return RECORDER_ERROR_INVALID_PARAMETER;
 676         }
 677         sock_fd = pc->cb_info->fd;
 678         int get_state;
 679
 680         LOGD("Enter, remote_handle : %x", pc->remote_handle);
 681
 682         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
 683
 684         if (ret == RECORDER_ERROR_NONE) {
 685                 muse_recorder_msg_get(get_state, pc->cb_info->recvMsg);
 686                 *state = (recorder_state_e)get_state;
 687         }
 688
 689         LOGD("ret : 0x%x, get_state : %d", ret, get_state);
 690
 691         return ret;
 692 }
 693
 694
 695 int recorder_destroy(recorder_h recorder)
 696 {
 697         if (recorder == NULL) {
 698                 LOGE("NULL pointer handle");
 699                 return RECORDER_ERROR_INVALID_PARAMETER;
 700         }
 701         int ret = RECORDER_ERROR_NONE;
 702         muse_recorder_api_e api = MUSE_RECORDER_API_DESTROY;
 703         recorder_cli_s *pc = (recorder_cli_s *)recorder;
 704         int sock_fd;
 705         if (pc->cb_info == NULL) {
 706                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
 707                 return RECORDER_ERROR_INVALID_PARAMETER;
 708         }
 709         sock_fd = pc->cb_info->fd;
 710
 711         LOGD("ENTER");
 712
 713         if (pc == NULL) {
 714                 return RECORDER_ERROR_INVALID_OPERATION;
 715         } else if (pc->cb_info == NULL) {
 716                 return RECORDER_ERROR_INVALID_OPERATION;
 717         }
 718
 719         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
 720         _client_callback_destroy(pc->cb_info);
 721         g_free(pc);
 722         pc = NULL;
 723         LOGD("ret : 0x%x", ret);
 724         return ret;
 725 }
 726
 727
 728 int recorder_prepare(recorder_h recorder)
 729 {
 730         if (recorder == NULL) {
 731                 LOGE("NULL pointer handle");
 732                 return RECORDER_ERROR_INVALID_PARAMETER;
 733         }
 734
 735         int ret = RECORDER_ERROR_NONE;
 736         muse_recorder_api_e api = MUSE_RECORDER_API_PREPARE;
 737         recorder_cli_s *pc = (recorder_cli_s *)recorder;
 738         int sock_fd;
 739         if (pc->cb_info == NULL) {
 740                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
 741                 return RECORDER_ERROR_INVALID_PARAMETER;
 742         }
 743         sock_fd = pc->cb_info->fd;
 744
 745         LOGD("ENTER");
 746
 747         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
 748
 749         LOGD("ret : 0x%x", ret);
 750
 751         return ret;
 752 }
 753
 754
 755 int recorder_unprepare(recorder_h recorder)
 756 {
 757         if (recorder == NULL) {
 758                 LOGE("NULL pointer handle");
 759                 return RECORDER_ERROR_INVALID_PARAMETER;
 760         }
 761         int ret = RECORDER_ERROR_NONE;
 762         muse_recorder_api_e api = MUSE_RECORDER_API_UNPREPARE;
 763         recorder_cli_s *pc = (recorder_cli_s *)recorder;
 764         int sock_fd;
 765         if (pc->cb_info == NULL) {
 766                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
 767                 return RECORDER_ERROR_INVALID_PARAMETER;
 768         }
 769         sock_fd = pc->cb_info->fd;
 770
 771         LOGD("ENTER");
 772
 773         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
 774         LOGD("ret : 0x%x", ret);
 775         return ret;
 776 }
 777
 778
 779 int recorder_start(recorder_h recorder)
 780 {
 781         if (recorder == NULL) {
 782                 LOGE("NULL pointer handle");
 783                 return RECORDER_ERROR_INVALID_PARAMETER;
 784         }
 785         int ret = RECORDER_ERROR_NONE;
 786         muse_recorder_api_e api = MUSE_RECORDER_API_START;
 787         recorder_cli_s *pc = (recorder_cli_s *)recorder;
 788         int sock_fd;
 789         if (pc->cb_info == NULL) {
 790                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
 791                 return RECORDER_ERROR_INVALID_PARAMETER;
 792         }
 793         sock_fd = pc->cb_info->fd;
 794
 795         LOGD("ENTER");
 796
 797         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
 798         LOGD("ret : 0x%x", ret);
 799         return ret;
 800 }
 801
 802
 803 int recorder_pause(recorder_h recorder)
 804 {
 805         if (recorder == NULL) {
 806                 LOGE("NULL pointer handle");
 807                 return RECORDER_ERROR_INVALID_PARAMETER;
 808         }
 809         int ret = RECORDER_ERROR_NONE;
 810         muse_recorder_api_e api = MUSE_RECORDER_API_PAUSE;
 811         recorder_cli_s *pc = (recorder_cli_s *)recorder;
 812         int sock_fd;
 813         if (pc->cb_info == NULL) {
 814                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
 815                 return RECORDER_ERROR_INVALID_PARAMETER;
 816         }
 817         sock_fd = pc->cb_info->fd;
 818
 819         LOGD("ENTER");
 820
 821         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
 822         LOGD("ret : 0x%x", ret);
 823         return ret;
 824 }
 825
 826
 827 int recorder_commit(recorder_h recorder)
 828 {
 829         if (recorder == NULL) {
 830                 LOGE("NULL pointer handle");
 831                 return RECORDER_ERROR_INVALID_PARAMETER;
 832         }
 833         int ret = RECORDER_ERROR_NONE;
 834         muse_recorder_api_e api = MUSE_RECORDER_API_COMMIT;
 835         recorder_cli_s *pc = (recorder_cli_s *)recorder;
 836         int sock_fd;
 837         if (pc->cb_info == NULL) {
 838                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
 839                 return RECORDER_ERROR_INVALID_PARAMETER;
 840         }
 841         sock_fd = pc->cb_info->fd;
 842
 843         LOGD("ENTER");
 844
 845         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
 846         LOGD("ret : 0x%x", ret);
 847         return ret;
 848 }
 849
 850
 851 int recorder_cancel(recorder_h recorder)
 852 {
 853         if (recorder == NULL) {
 854                 LOGE("NULL pointer handle");
 855                 return RECORDER_ERROR_INVALID_PARAMETER;
 856         }
 857         int ret = RECORDER_ERROR_NONE;
 858         muse_recorder_api_e api = MUSE_RECORDER_API_CANCEL;
 859         recorder_cli_s *pc = (recorder_cli_s *)recorder;
 860         int sock_fd;
 861         if (pc->cb_info == NULL) {
 862                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
 863                 return RECORDER_ERROR_INVALID_PARAMETER;
 864         }
 865         sock_fd = pc->cb_info->fd;
 866
 867         LOGD("ENTER");
 868
 869         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
 870         LOGD("ret : 0x%x", ret);
 871         return ret;
 872 }
 873
 874
 875 int recorder_set_video_resolution(recorder_h recorder, int width, int height)
 876 {
 877         if (recorder == NULL) {
 878                 LOGE("NULL pointer handle");
 879                 return RECORDER_ERROR_INVALID_PARAMETER;
 880         }
 881         int ret = RECORDER_ERROR_NONE;
 882         muse_recorder_api_e api = MUSE_RECORDER_API_SET_VIDEO_RESOLUTION;
 883         recorder_cli_s *pc = (recorder_cli_s *)recorder;
 884         int sock_fd;
 885         if (pc->cb_info == NULL) {
 886                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
 887                 return RECORDER_ERROR_INVALID_PARAMETER;
 888         }
 889         sock_fd = pc->cb_info->fd;
 890
 891         LOGD("ENTER");
 892
 893         muse_recorder_msg_send2(api,
 894                                                         sock_fd,
 895                                                         pc->cb_info,
 896                                                         ret,
 897                                                         INT, width,
 898                                                         INT, height);
 899         LOGD("ret : 0x%x", ret);
 900         return ret;
 901 }
 902
 903
 904 int recorder_get_video_resolution(recorder_h recorder, int *width, int *height)
 905 {
 906         if (recorder == NULL) {
 907                 LOGE("NULL pointer handle");
 908                 return RECORDER_ERROR_INVALID_PARAMETER;
 909         }
 910         if (!width || !height) {
 911                 LOGE("NULL pointer width = [%p], height = [%p]", width, height);
 912                 return RECORDER_ERROR_INVALID_PARAMETER;
 913         }
 914         int ret = RECORDER_ERROR_NONE;
 915         muse_recorder_api_e api = MUSE_RECORDER_API_GET_VIDEO_RESOLUTION;
 916         recorder_cli_s *pc = (recorder_cli_s *)recorder;
 917         int sock_fd;
 918         if (pc->cb_info == NULL) {
 919                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
 920                 return RECORDER_ERROR_INVALID_PARAMETER;
 921         }
 922         sock_fd = pc->cb_info->fd;
 923         int get_width;
 924         int get_height;
 925
 926         LOGD("ENTER");
 927
 928         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
 929         if (ret == RECORDER_ERROR_NONE) {
 930                 muse_recorder_msg_get(get_width, pc->cb_info->recvMsg);
 931                 muse_recorder_msg_get(get_height, pc->cb_info->recvMsg);
 932                 *width = get_width;
 933                 *height = get_height;
 934         }
 935         LOGD("ret : 0x%x", ret);
 936         return ret;
 937 }
 938
 939
 940 int recorder_foreach_supported_video_resolution(recorder_h recorder,
 941                                                 recorder_supported_video_resolution_cb foreach_cb, void *user_data)
 942 {
 943         if( recorder == NULL || foreach_cb == NULL){
 944                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
 945                 return RECORDER_ERROR_INVALID_PARAMETER;
 946         }
 947         int ret = RECORDER_ERROR_NONE;
 948
 949         recorder_cli_s *pc = (recorder_cli_s *)recorder;
 950         muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_VIDEO_RESOLUTION;
 951
 952         LOGD("Enter, handle :%x", pc->remote_handle);
 953
 954         int sock_fd;
 955         if (pc->cb_info == NULL) {
 956                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
 957                 return RECORDER_ERROR_INVALID_PARAMETER;
 958         }
 959         sock_fd = pc->cb_info->fd;
 960         pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_RESOLUTION] = foreach_cb;
 961         pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_RESOLUTION] = user_data;
 962
 963         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
 964         LOGD("ret : 0x%x", ret);
 965         return ret;
 966 }
 967
 968
 969 int recorder_get_audio_level(recorder_h recorder, double *level)
 970 {
 971         if (recorder == NULL || level == NULL) {
 972                 LOGE("NULL pointer %p %p", recorder, level);
 973                 return RECORDER_ERROR_INVALID_PARAMETER;
 974         }
 975
 976         int ret = RECORDER_ERROR_NONE;
 977         muse_recorder_api_e api = MUSE_RECORDER_API_GET_AUDIO_LEVEL;
 978         recorder_cli_s *pc = (recorder_cli_s *)recorder;
 979         int sock_fd;
 980         if (pc->cb_info == NULL) {
 981                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
 982                 return RECORDER_ERROR_INVALID_PARAMETER;
 983         }
 984         sock_fd = pc->cb_info->fd;
 985         double get_level;
 986
 987         LOGD("ENTER");
 988
 989         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
 990         if (ret == RECORDER_ERROR_NONE) {
 991                 muse_recorder_msg_get_double(get_level, pc->cb_info->recvMsg);
 992                 *level = get_level;
 993         }
 994         LOGD("ret : 0x%x", ret);
 995         return ret;
 996 }
 997
 998
 999 int recorder_set_filename(recorder_h recorder,  const char *filename)
1000 {
1001         if (recorder == NULL) {
1002                 LOGE("handle is NULL");
1003                 return RECORDER_ERROR_INVALID_PARAMETER;
1004         }
1005
1006         if (filename == NULL) {
1007                 LOGE("filename is NULL");
1008                 return RECORDER_ERROR_INVALID_PARAMETER;
1009         }
1010         int ret = RECORDER_ERROR_NONE;
1011         muse_recorder_api_e api = MUSE_RECORDER_API_SET_FILENAME;
1012         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1013         int sock_fd;
1014         if (pc->cb_info == NULL) {
1015                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
1016                 return RECORDER_ERROR_INVALID_PARAMETER;
1017         }
1018         sock_fd = pc->cb_info->fd;
1019
1020         LOGD("ENTER");
1021
1022         muse_recorder_msg_send1(api, sock_fd, pc->cb_info, ret, STRING, filename);
1023         LOGD("ret : 0x%x", ret);
1024         return ret;
1025 }
1026
1027
1028 int recorder_get_filename(recorder_h recorder,  char **filename)
1029 {
1030         if (recorder == NULL) {
1031                 LOGE("handle is NULL");
1032                 return RECORDER_ERROR_INVALID_PARAMETER;
1033         }
1034
1035         if (filename == NULL) {
1036                 LOGE("filename is NULL");
1037                 return RECORDER_ERROR_INVALID_PARAMETER;
1038         }
1039         int ret = RECORDER_ERROR_NONE;
1040         muse_recorder_api_e api = MUSE_RECORDER_API_GET_FILENAME;
1041         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1042         int sock_fd;
1043         if (pc->cb_info == NULL) {
1044                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
1045                 return RECORDER_ERROR_INVALID_PARAMETER;
1046         }
1047         sock_fd = pc->cb_info->fd;
1048         char get_filename[MUSE_RECORDER_MSG_MAX_LENGTH] = {0,};
1049
1050         LOGD("ENTER");
1051
1052         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1053
1054         if (ret == RECORDER_ERROR_NONE) {
1055                 muse_recorder_msg_get_string(get_filename, pc->cb_info->recvMsg);
1056                 *filename = strdup(get_filename);
1057         }
1058         LOGD("ret : 0x%x, filename : %s", ret, *filename);
1059         return ret;
1060 }
1061
1062
1063 int recorder_set_file_format(recorder_h recorder, recorder_file_format_e format)
1064 {
1065         if (recorder == NULL) {
1066                 LOGE("NULL pointer handle");
1067                 return RECORDER_ERROR_INVALID_PARAMETER;
1068         }
1069         if (format < RECORDER_FILE_FORMAT_3GP || format > RECORDER_FILE_FORMAT_OGG) {
1070                 LOGE("invalid format %d", format);
1071                 return RECORDER_ERROR_INVALID_PARAMETER;
1072         }
1073         int ret = RECORDER_ERROR_NONE;
1074         muse_recorder_api_e api = MUSE_RECORDER_API_SET_FILE_FORMAT;
1075         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1076         int sock_fd;
1077         if (pc->cb_info == NULL) {
1078                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
1079                 return RECORDER_ERROR_INVALID_PARAMETER;
1080         }
1081         sock_fd = pc->cb_info->fd;
1082         int set_format = (int)format;
1083
1084         LOGD("ENTER, set_format : %d", set_format);
1085
1086         muse_recorder_msg_send1(api, sock_fd, pc->cb_info, ret, INT, set_format);
1087         LOGD("ret : 0x%x", ret);
1088         return ret;
1089 }
1090
1091
1092 int recorder_get_file_format(recorder_h recorder, recorder_file_format_e *format)
1093 {
1094         if (recorder == NULL) {
1095                 LOGE("NULL pointer handle");
1096                 return RECORDER_ERROR_INVALID_PARAMETER;
1097         }
1098         if (format == NULL) {
1099                 LOGE("NULL pointer data");
1100                 return RECORDER_ERROR_INVALID_PARAMETER;
1101         }
1102         int ret = RECORDER_ERROR_NONE;
1103         muse_recorder_api_e api = MUSE_RECORDER_API_GET_FILE_FORMAT;
1104         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1105         int sock_fd;
1106         if (pc->cb_info == NULL) {
1107                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
1108                 return RECORDER_ERROR_INVALID_PARAMETER;
1109         }
1110         sock_fd = pc->cb_info->fd;
1111         int get_format;
1112
1113         LOGD("ENTER");
1114
1115         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1116
1117         if (ret == RECORDER_ERROR_NONE) {
1118                 muse_recorder_msg_get(get_format, pc->cb_info->recvMsg);
1119                 LOGD("get_fileformat : %d", get_format);
1120                 *format = (recorder_file_format_e)get_format;
1121         }
1122         LOGD("ret : 0x%x", ret);
1123         return ret;
1124 }
1125
1126
1127 int recorder_set_state_changed_cb(recorder_h recorder, recorder_state_changed_cb callback, void* user_data)
1128 {
1129         if( recorder == NULL || callback == NULL){
1130                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
1131                 return RECORDER_ERROR_INVALID_PARAMETER;
1132         }
1133         int ret = RECORDER_ERROR_NONE;
1134
1135         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1136         muse_recorder_api_e api = MUSE_RECORDER_API_SET_STATE_CHANGED_CB;
1137
1138         LOGD("Enter, handle :%x", pc->remote_handle);
1139
1140         int sock_fd;
1141         if (pc->cb_info == NULL) {
1142                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
1143                 return RECORDER_ERROR_INVALID_PARAMETER;
1144         }
1145         sock_fd = pc->cb_info->fd;
1146         pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_STATE_CHANGE] = callback;
1147         pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_STATE_CHANGE] = user_data;
1148
1149         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1150         LOGD("ret : 0x%x", ret);
1151         return ret;
1152 }
1153
1154
1155 int recorder_unset_state_changed_cb(recorder_h recorder)
1156 {
1157         if (recorder == NULL) {
1158                 LOGE("NULL pointer handle");
1159                 return RECORDER_ERROR_INVALID_PARAMETER;
1160         }
1161         int ret = RECORDER_ERROR_NONE;
1162         muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_STATE_CHANGED_CB;
1163         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1164         int sock_fd;
1165         if (pc->cb_info == NULL) {
1166                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
1167                 return RECORDER_ERROR_INVALID_PARAMETER;
1168         }
1169         sock_fd = pc->cb_info->fd;
1170
1171         LOGD("ENTER");
1172
1173         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1174         LOGD("ret : 0x%x", ret);
1175         return ret;
1176 }
1177
1178
1179 int recorder_set_interrupted_cb(recorder_h recorder, recorder_interrupted_cb callback, void *user_data)
1180 {
1181         if( recorder == NULL || callback == NULL){
1182                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
1183                 return RECORDER_ERROR_INVALID_PARAMETER;
1184         }
1185         int ret = RECORDER_ERROR_NONE;
1186
1187         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1188         muse_recorder_api_e api = MUSE_RECORDER_API_SET_INTERRUPTED_CB;
1189
1190         LOGD("Enter, handle :%x", pc->remote_handle);
1191
1192         int sock_fd;
1193         if (pc->cb_info == NULL) {
1194                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
1195                 return RECORDER_ERROR_INVALID_PARAMETER;
1196         }
1197         sock_fd = pc->cb_info->fd;
1198         pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_INTERRUPTED] = callback;
1199         pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_INTERRUPTED] = user_data;
1200
1201         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1202         LOGD("ret : 0x%x", ret);
1203         return ret;
1204 }
1205
1206
1207 int recorder_unset_interrupted_cb(recorder_h recorder)
1208 {
1209         if (recorder == NULL) {
1210                 LOGE("NULL pointer handle");
1211                 return RECORDER_ERROR_INVALID_PARAMETER;
1212         }
1213         int ret = RECORDER_ERROR_NONE;
1214         muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_INTERRUPTED_CB;
1215         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1216         int sock_fd;
1217         if (pc->cb_info == NULL) {
1218                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
1219                 return RECORDER_ERROR_INVALID_PARAMETER;
1220         }
1221         sock_fd = pc->cb_info->fd;
1222
1223         LOGD("ENTER");
1224
1225         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1226         LOGD("ret : 0x%x", ret);
1227         return ret;
1228 }
1229
1230
1231 int recorder_set_audio_stream_cb(recorder_h recorder, recorder_audio_stream_cb callback, void* user_data)
1232 {
1233         if( recorder == NULL || callback == NULL){
1234                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
1235                 return RECORDER_ERROR_INVALID_PARAMETER;
1236         }
1237         int ret = RECORDER_ERROR_NONE;
1238
1239         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1240         muse_recorder_api_e api = MUSE_RECORDER_API_SET_AUDIO_STREAM_CB;
1241
1242         LOGD("Enter, handle :%x", pc->remote_handle);
1243
1244         int sock_fd;
1245         if (pc->cb_info == NULL) {
1246                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
1247                 return RECORDER_ERROR_INVALID_PARAMETER;
1248         }
1249         sock_fd = pc->cb_info->fd;
1250         pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_AUDIO_STREAM] = callback;
1251         pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_AUDIO_STREAM] = user_data;
1252
1253         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1254         LOGD("ret : 0x%x", ret);
1255         return ret;
1256 }
1257
1258
1259 int recorder_unset_audio_stream_cb(recorder_h recorder)
1260 {
1261         if (recorder == NULL) {
1262                 LOGE("NULL pointer handle");
1263                 return RECORDER_ERROR_INVALID_PARAMETER;
1264         }
1265         int ret = RECORDER_ERROR_NONE;
1266         muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_AUDIO_STREAM_CB;
1267         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1268         int sock_fd;
1269         if (pc->cb_info == NULL) {
1270                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
1271                 return RECORDER_ERROR_INVALID_PARAMETER;
1272         }
1273         sock_fd = pc->cb_info->fd;
1274
1275         LOGD("ENTER");
1276
1277         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1278         LOGD("ret : 0x%x", ret);
1279         return ret;
1280 }
1281
1282
1283 int recorder_set_error_cb(recorder_h recorder, recorder_error_cb callback, void *user_data)
1284 {
1285         if( recorder == NULL || callback == NULL){
1286                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
1287                 return RECORDER_ERROR_INVALID_PARAMETER;
1288         }
1289         int ret = RECORDER_ERROR_NONE;
1290
1291         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1292         muse_recorder_api_e api = MUSE_RECORDER_API_SET_ERROR_CB;
1293
1294         LOGD("Enter, handle :%x", pc->remote_handle);
1295
1296         int sock_fd;
1297         if (pc->cb_info == NULL) {
1298                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
1299                 return RECORDER_ERROR_INVALID_PARAMETER;
1300         }
1301         sock_fd = pc->cb_info->fd;
1302         pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_ERROR] = callback;
1303         pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_ERROR] = user_data;
1304
1305         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1306         LOGD("ret : 0x%x", ret);
1307         return ret;
1308 }
1309
1310
1311 int recorder_unset_error_cb(recorder_h recorder)
1312 {
1313         if (recorder == NULL) {
1314                 LOGE("NULL pointer handle");
1315                 return RECORDER_ERROR_INVALID_PARAMETER;
1316         }
1317         int ret = RECORDER_ERROR_NONE;
1318         muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_ERROR_CB;
1319         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1320         int sock_fd;
1321         if (pc->cb_info == NULL) {
1322                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
1323                 return RECORDER_ERROR_INVALID_PARAMETER;
1324         }
1325         sock_fd = pc->cb_info->fd;
1326
1327         LOGD("ENTER");
1328
1329         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1330         LOGD("ret : 0x%x", ret);
1331         return ret;
1332 }
1333
1334
1335 int recorder_set_recording_status_cb(recorder_h recorder, recorder_recording_status_cb callback, void* user_data)
1336 {
1337         if( recorder == NULL || callback == NULL){
1338                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
1339                 return RECORDER_ERROR_INVALID_PARAMETER;
1340         }
1341         int ret = RECORDER_ERROR_NONE;
1342
1343         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1344         muse_recorder_api_e api = MUSE_RECORDER_API_SET_RECORDING_STATUS_CB;
1345
1346         LOGD("Enter, handle :%x", pc->remote_handle);
1347
1348         int sock_fd;
1349         if (pc->cb_info == NULL) {
1350                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
1351                 return RECORDER_ERROR_INVALID_PARAMETER;
1352         }
1353         sock_fd = pc->cb_info->fd;
1354         pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_RECORDING_STATUS] = callback;
1355         pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_RECORDING_STATUS] = user_data;
1356
1357         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1358         LOGD("ret : 0x%x", ret);
1359         return ret;
1360 }
1361
1362
1363 int recorder_unset_recording_status_cb(recorder_h recorder)
1364 {
1365         if (recorder == NULL) {
1366                 LOGE("NULL pointer handle");
1367                 return RECORDER_ERROR_INVALID_PARAMETER;
1368         }
1369         int ret = RECORDER_ERROR_NONE;
1370         muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_RECORDING_STATUS_CB;
1371         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1372         int sock_fd;
1373         if (pc->cb_info == NULL) {
1374                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
1375                 return RECORDER_ERROR_INVALID_PARAMETER;
1376         }
1377         sock_fd = pc->cb_info->fd;
1378
1379         LOGD("ENTER");
1380
1381         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1382         LOGD("ret : 0x%x", ret);
1383         return ret;
1384 }
1385
1386
1387 int recorder_set_recording_limit_reached_cb(recorder_h recorder, recorder_recording_limit_reached_cb callback, void* user_data)
1388 {
1389         if( recorder == NULL || callback == NULL){
1390                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
1391                 return RECORDER_ERROR_INVALID_PARAMETER;
1392         }
1393         int ret = RECORDER_ERROR_NONE;
1394
1395         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1396         muse_recorder_api_e api = MUSE_RECORDER_API_SET_RECORDING_LIMIT_REACHED_CB;
1397
1398         LOGD("Enter, handle :%x", pc->remote_handle);
1399
1400         int sock_fd;
1401         if (pc->cb_info == NULL) {
1402                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
1403                 return RECORDER_ERROR_INVALID_PARAMETER;
1404         }
1405         sock_fd = pc->cb_info->fd;
1406         pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_RECORDING_LIMITED] = callback;
1407         pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_RECORDING_LIMITED] = user_data;
1408
1409         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1410         LOGD("ret : 0x%x", ret);
1411         return ret;
1412 }
1413
1414
1415 int recorder_unset_recording_limit_reached_cb(recorder_h recorder)
1416 {
1417         if (recorder == NULL) {
1418                 LOGE("NULL pointer handle");
1419                 return RECORDER_ERROR_INVALID_PARAMETER;
1420         }
1421         int ret = RECORDER_ERROR_NONE;
1422         muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_RECORDING_LIMIT_REACHED_CB;
1423         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1424         int sock_fd;
1425         if (pc->cb_info == NULL) {
1426                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
1427                 return RECORDER_ERROR_INVALID_PARAMETER;
1428         }
1429         sock_fd = pc->cb_info->fd;
1430
1431         LOGD("ENTER");
1432
1433         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1434         LOGD("ret : 0x%x", ret);
1435         return ret;
1436 }
1437
1438
1439 int recorder_foreach_supported_file_format(recorder_h recorder, recorder_supported_file_format_cb foreach_cb, void *user_data)
1440 {
1441         if( recorder == NULL || foreach_cb == NULL){
1442                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
1443                 return RECORDER_ERROR_INVALID_PARAMETER;
1444         }
1445         int ret = RECORDER_ERROR_NONE;
1446
1447         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1448         muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_FILE_FORMAT;
1449
1450         LOGD("Enter, handle :%x", pc->remote_handle);
1451
1452         int sock_fd;
1453         if (pc->cb_info == NULL) {
1454                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
1455                 return RECORDER_ERROR_INVALID_PARAMETER;
1456         }
1457         sock_fd = pc->cb_info->fd;
1458         pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_FILE_FORMAT] = foreach_cb;
1459         pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_FILE_FORMAT] = user_data;
1460
1461         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1462         LOGD("ret : 0x%x", ret);
1463         return ret;
1464 }
1465
1466
1467 int recorder_attr_set_size_limit(recorder_h recorder, int kbyte)
1468 {
1469         if (recorder == NULL) {
1470                 LOGE("NULL pointer handle");
1471                 return RECORDER_ERROR_INVALID_PARAMETER;
1472         }
1473         int ret = RECORDER_ERROR_NONE;
1474         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_SIZE_LIMIT;
1475         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1476         int sock_fd;
1477         if (pc->cb_info == NULL) {
1478                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
1479                 return RECORDER_ERROR_INVALID_PARAMETER;
1480         }
1481         sock_fd = pc->cb_info->fd;
1482
1483         LOGD("ENTER");
1484
1485         muse_recorder_msg_send1(api,
1486                                                         sock_fd,
1487                                                         pc->cb_info,
1488                                                         ret,
1489                                                         INT, kbyte);
1490         LOGD("ret : 0x%x", ret);
1491         return ret;
1492 }
1493
1494
1495 int recorder_attr_set_time_limit(recorder_h recorder, int second)
1496 {
1497         if (recorder == NULL) {
1498                 LOGE("NULL pointer handle");
1499                 return RECORDER_ERROR_INVALID_PARAMETER;
1500         }
1501         int ret = RECORDER_ERROR_NONE;
1502         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_TIME_LIMIT;
1503         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1504         int sock_fd;
1505         if (pc->cb_info == NULL) {
1506                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
1507                 return RECORDER_ERROR_INVALID_PARAMETER;
1508         }
1509         sock_fd = pc->cb_info->fd;
1510
1511         LOGD("ENTER");
1512
1513         muse_recorder_msg_send1(api,
1514                                                         sock_fd,
1515                                                         pc->cb_info,
1516                                                         ret,
1517                                                         INT, second);
1518         LOGD("ret : 0x%x", ret);
1519         return ret;
1520 }
1521
1522
1523 int recorder_attr_set_audio_device(recorder_h recorder, recorder_audio_device_e device)
1524 {
1525         if (recorder == NULL) {
1526                 LOGE("NULL pointer handle");
1527                 return RECORDER_ERROR_INVALID_PARAMETER;
1528         }
1529         int ret = RECORDER_ERROR_NONE;
1530         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_AUDIO_DEVICE;
1531         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1532         int sock_fd;
1533         if (pc->cb_info == NULL) {
1534                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
1535                 return RECORDER_ERROR_INVALID_PARAMETER;
1536         }
1537         sock_fd = pc->cb_info->fd;
1538         int set_device = (int)device;
1539
1540         LOGD("ENTER");
1541
1542         muse_recorder_msg_send1(api,
1543                                                         sock_fd,
1544                                                         pc->cb_info,
1545                                                         ret,
1546                                                         INT, set_device);
1547         LOGD("ret : 0x%x", ret);
1548         return ret;
1549 }
1550
1551
1552 int recorder_set_audio_encoder(recorder_h recorder, recorder_audio_codec_e codec)
1553 {
1554         if (recorder == NULL) {
1555                 LOGE("NULL pointer handle");
1556                 return RECORDER_ERROR_INVALID_PARAMETER;
1557         }
1558         if (codec != RECORDER_AUDIO_CODEC_DISABLE &&
1559             (codec < RECORDER_AUDIO_CODEC_AMR || codec > RECORDER_AUDIO_CODEC_PCM)) {
1560                 LOGE("invalid parameter : codec %d", codec);
1561                 return RECORDER_ERROR_INVALID_PARAMETER;
1562         }
1563         int ret = RECORDER_ERROR_NONE;
1564         muse_recorder_api_e api = MUSE_RECORDER_API_SET_AUDIO_ENCODER;
1565         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1566         int sock_fd;
1567         if (pc->cb_info == NULL) {
1568                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
1569                 return RECORDER_ERROR_INVALID_PARAMETER;
1570         }
1571         sock_fd = pc->cb_info->fd;
1572         int set_codec = (int)codec;
1573
1574         LOGD("ENTER");
1575
1576         muse_recorder_msg_send1(api,
1577                                                         sock_fd,
1578                                                         pc->cb_info,
1579                                                         ret,
1580                                                         INT, set_codec);
1581         LOGD("ret : 0x%x", ret);
1582         return ret;
1583 }
1584
1585
1586 int recorder_get_audio_encoder(recorder_h recorder, recorder_audio_codec_e *codec)
1587 {
1588         if (recorder == NULL) {
1589                 LOGE("NULL pointer handle");
1590                 return RECORDER_ERROR_INVALID_PARAMETER;
1591         }
1592         if (codec == NULL) {
1593                 LOGE("codec is NULL");
1594                 return RECORDER_ERROR_INVALID_PARAMETER;
1595         }
1596         int ret = RECORDER_ERROR_NONE;
1597         muse_recorder_api_e api = MUSE_RECORDER_API_GET_AUDIO_ENCODER;
1598         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1599         int sock_fd;
1600         if (pc->cb_info == NULL) {
1601                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
1602                 return RECORDER_ERROR_INVALID_PARAMETER;
1603         }
1604         sock_fd = pc->cb_info->fd;
1605         int get_codec;
1606
1607         LOGD("ENTER");
1608
1609         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1610         if (ret == RECORDER_ERROR_NONE) {
1611                 muse_recorder_msg_get(get_codec, pc->cb_info->recvMsg);
1612                 *codec = (recorder_audio_codec_e)get_codec;
1613         }
1614         LOGD("ret : 0x%x", ret);
1615         return ret;
1616 }
1617
1618
1619 int recorder_set_video_encoder(recorder_h recorder, recorder_video_codec_e codec)
1620 {
1621         if (recorder == NULL) {
1622                 LOGE("NULL pointer handle");
1623                 return RECORDER_ERROR_INVALID_PARAMETER;
1624         }
1625         if (codec < RECORDER_VIDEO_CODEC_H263 || codec > RECORDER_VIDEO_CODEC_THEORA) {
1626                 LOGE("invalid codec %d", codec);
1627                 return RECORDER_ERROR_INVALID_PARAMETER;
1628         }
1629         int ret = RECORDER_ERROR_NONE;
1630         muse_recorder_api_e api = MUSE_RECORDER_API_SET_VIDEO_ENCODER;
1631         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1632         int sock_fd;
1633         if (pc->cb_info == NULL) {
1634                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
1635                 return RECORDER_ERROR_INVALID_PARAMETER;
1636         }
1637         sock_fd = pc->cb_info->fd;
1638         int set_codec = (int)codec;
1639
1640         LOGD("ENTER");
1641
1642         muse_recorder_msg_send1(api,
1643                                                         sock_fd,
1644                                                         pc->cb_info,
1645                                                         ret,
1646                                                         INT, set_codec);
1647         LOGD("ret : 0x%x", ret);
1648         return ret;
1649 }
1650
1651
1652 int recorder_get_video_encoder(recorder_h recorder, recorder_video_codec_e *codec)
1653 {
1654         if (recorder == NULL) {
1655                 LOGE("NULL pointer handle");
1656                 return RECORDER_ERROR_INVALID_PARAMETER;
1657         }
1658         if (codec == NULL) {
1659                 LOGE("codec is NULL");
1660                 return RECORDER_ERROR_INVALID_PARAMETER;
1661         }
1662         int ret = RECORDER_ERROR_NONE;
1663         muse_recorder_api_e api = MUSE_RECORDER_API_GET_VIDEO_ENCODER;
1664         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1665         int sock_fd;
1666         if (pc->cb_info == NULL) {
1667                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
1668                 return RECORDER_ERROR_INVALID_PARAMETER;
1669         }
1670         sock_fd = pc->cb_info->fd;
1671         int get_codec;
1672
1673         LOGD("ENTER");
1674
1675         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1676         if (ret == RECORDER_ERROR_NONE) {
1677                 muse_recorder_msg_get(get_codec, pc->cb_info->recvMsg);
1678                 *codec = (recorder_audio_codec_e)get_codec;
1679         }
1680         LOGD("ret : 0x%x", ret);
1681         return ret;
1682 }
1683
1684
1685 int recorder_attr_set_audio_samplerate(recorder_h recorder, int samplerate)
1686 {
1687         if (recorder == NULL) {
1688                 LOGE("NULL pointer handle");
1689                 return RECORDER_ERROR_INVALID_PARAMETER;
1690         }
1691         if (samplerate < 1) {
1692                 LOGE("invalid samplerate %d", samplerate);
1693                 return RECORDER_ERROR_INVALID_PARAMETER;
1694         }
1695         int ret = RECORDER_ERROR_NONE;
1696         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_AUDIO_SAMPLERATE;
1697         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1698         int sock_fd;
1699         if (pc->cb_info == NULL) {
1700                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
1701                 return RECORDER_ERROR_INVALID_PARAMETER;
1702         }
1703         sock_fd = pc->cb_info->fd;
1704
1705         LOGD("ENTER, samplerate : %d", samplerate);
1706
1707         muse_recorder_msg_send1(api,
1708                                                         sock_fd,
1709                                                         pc->cb_info,
1710                                                         ret,
1711                                                         INT, samplerate);
1712         LOGD("ret : 0x%x, samplerate : %d", ret, samplerate);
1713         return ret;
1714 }
1715
1716
1717 int recorder_attr_set_audio_encoder_bitrate(recorder_h recorder, int bitrate)
1718 {
1719         if (recorder == NULL) {
1720                 LOGE("NULL pointer handle");
1721                 return RECORDER_ERROR_INVALID_PARAMETER;
1722         }
1723         if (bitrate < 1) {
1724                 LOGE("invalid bitrate %d", bitrate);
1725                 return RECORDER_ERROR_INVALID_PARAMETER;
1726         }
1727         int ret = RECORDER_ERROR_NONE;
1728         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_AUDIO_ENCODER_BITRATE;
1729         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1730         int sock_fd;
1731         if (pc->cb_info == NULL) {
1732                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
1733                 return RECORDER_ERROR_INVALID_PARAMETER;
1734         }
1735         sock_fd = pc->cb_info->fd;
1736
1737         LOGD("ENTER");
1738
1739         muse_recorder_msg_send1(api,
1740                                                         sock_fd,
1741                                                         pc->cb_info,
1742                                                         ret,
1743                                                         INT, bitrate);
1744         LOGD("ret : 0x%x", ret);
1745         return ret;
1746 }
1747
1748
1749 int recorder_attr_set_video_encoder_bitrate(recorder_h recorder, int bitrate)
1750 {
1751         if (recorder == NULL) {
1752                 LOGE("NULL pointer handle");
1753                 return RECORDER_ERROR_INVALID_PARAMETER;
1754         }
1755
1756         int ret = RECORDER_ERROR_NONE;
1757         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_VIDEO_ENCODER_BITRATE;
1758         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1759         int sock_fd;
1760         if (pc->cb_info == NULL) {
1761                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
1762                 return RECORDER_ERROR_INVALID_PARAMETER;
1763         }
1764         sock_fd = pc->cb_info->fd;
1765
1766         LOGD("ENTER");
1767
1768         muse_recorder_msg_send1(api,
1769                                                         sock_fd,
1770                                                         pc->cb_info,
1771                                                         ret,
1772                                                         INT, bitrate);
1773         LOGD("ret : 0x%x", ret);
1774         return ret;
1775 }
1776
1777
1778 int recorder_attr_get_size_limit(recorder_h recorder, int *kbyte)
1779 {
1780         if (recorder == NULL) {
1781                 LOGE("NULL pointer handle");
1782                 return RECORDER_ERROR_INVALID_PARAMETER;
1783         }
1784         if (kbyte == NULL) {
1785                 LOGE("NULL pointer kbyte");
1786                 return RECORDER_ERROR_INVALID_PARAMETER;
1787         }
1788         int ret = RECORDER_ERROR_NONE;
1789         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_SIZE_LIMIT;
1790         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1791         int sock_fd;
1792         if (pc->cb_info == NULL) {
1793                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
1794                 return RECORDER_ERROR_INVALID_PARAMETER;
1795         }
1796         sock_fd = pc->cb_info->fd;
1797         int get_kbyte;
1798
1799         LOGD("ENTER");
1800
1801         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1802         if (ret == RECORDER_ERROR_NONE) {
1803                 muse_recorder_msg_get(get_kbyte, pc->cb_info->recvMsg);
1804                 *kbyte = get_kbyte;
1805         }
1806         LOGD("ret : 0x%x", ret);
1807         return ret;
1808 }
1809
1810
1811 int recorder_attr_get_time_limit(recorder_h recorder, int *second)
1812 {
1813         if (recorder == NULL) {
1814                 LOGE("NULL pointer handle");
1815                 return RECORDER_ERROR_INVALID_PARAMETER;
1816         }
1817         if (second == NULL) {
1818                 LOGE("NULL pointer second");
1819                 return RECORDER_ERROR_INVALID_PARAMETER;
1820         }
1821         int ret = RECORDER_ERROR_NONE;
1822         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_TIME_LIMIT;
1823         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1824         int sock_fd;
1825         if (pc->cb_info == NULL) {
1826                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
1827                 return RECORDER_ERROR_INVALID_PARAMETER;
1828         }
1829         sock_fd = pc->cb_info->fd;
1830         int get_second;
1831
1832         LOGD("ENTER");
1833
1834         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1835         if (ret == RECORDER_ERROR_NONE) {
1836                 muse_recorder_msg_get(get_second, pc->cb_info->recvMsg);
1837                 *second = get_second;
1838         }
1839         LOGD("ret : 0x%x", ret);
1840         return ret;
1841 }
1842
1843
1844 int recorder_attr_get_audio_device(recorder_h recorder, recorder_audio_device_e *device)
1845 {
1846         if (recorder == NULL) {
1847                 LOGE("NULL pointer handle");
1848                 return RECORDER_ERROR_INVALID_PARAMETER;
1849         }
1850         if (device == NULL) {
1851                 LOGE("NULL pointer device");
1852                 return RECORDER_ERROR_INVALID_PARAMETER;
1853         }
1854         int ret = RECORDER_ERROR_NONE;
1855         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_AUDIO_DEVICE;
1856         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1857         int sock_fd;
1858         if (pc->cb_info == NULL) {
1859                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
1860                 return RECORDER_ERROR_INVALID_PARAMETER;
1861         }
1862         sock_fd = pc->cb_info->fd;
1863         int get_device;
1864
1865         LOGD("ENTER");
1866
1867         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1868         if (ret == RECORDER_ERROR_NONE) {
1869                 muse_recorder_msg_get(get_device, pc->cb_info->recvMsg);
1870                 *device = (recorder_audio_device_e)get_device;
1871         }
1872
1873         LOGD("ret : 0x%x", ret);
1874         return ret;
1875 }
1876
1877
1878 int recorder_attr_get_audio_samplerate(recorder_h recorder, int *samplerate)
1879 {
1880         if (recorder == NULL) {
1881                 LOGE("NULL pointer handle");
1882                 return RECORDER_ERROR_INVALID_PARAMETER;
1883         }
1884         if (samplerate == NULL) {
1885                 LOGE("NULL pointer handle");
1886                 return RECORDER_ERROR_INVALID_PARAMETER;
1887         }
1888         int ret = RECORDER_ERROR_NONE;
1889         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_AUDIO_SAMPLERATE;
1890         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1891         int sock_fd;
1892         if (pc->cb_info == NULL) {
1893                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
1894                 return RECORDER_ERROR_INVALID_PARAMETER;
1895         }
1896         sock_fd = pc->cb_info->fd;
1897         int get_samplerate;
1898
1899         LOGD("ENTER");
1900
1901         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1902         if (ret == RECORDER_ERROR_NONE) {
1903                 muse_recorder_msg_get(get_samplerate, pc->cb_info->recvMsg);
1904                 *samplerate = get_samplerate;
1905         }
1906         LOGD("ret : 0x%x, get_samplerate : %d", ret, get_samplerate);
1907         return ret;
1908 }
1909
1910
1911 int recorder_attr_get_audio_encoder_bitrate(recorder_h recorder, int *bitrate)
1912 {
1913         if (recorder == NULL) {
1914                 LOGE("NULL pointer handle");
1915                 return RECORDER_ERROR_INVALID_PARAMETER;
1916         }
1917         if (bitrate == NULL) {
1918                 LOGE("NULL pointer");
1919                 return RECORDER_ERROR_INVALID_PARAMETER;
1920         }
1921         int ret = RECORDER_ERROR_NONE;
1922         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_AUDIO_ENCODER_BITRATE;
1923         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1924         int sock_fd;
1925         if (pc->cb_info == NULL) {
1926                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
1927                 return RECORDER_ERROR_INVALID_PARAMETER;
1928         }
1929         sock_fd = pc->cb_info->fd;
1930         int get_bitrate;
1931         pc->cb_info->activating[api] = 0;
1932
1933         LOGD("ENTER");
1934
1935         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1936         if (ret == RECORDER_ERROR_NONE) {
1937                 muse_recorder_msg_get(get_bitrate, pc->cb_info->recvMsg);
1938                 *bitrate = get_bitrate;
1939         }
1940         LOGD("ret : 0x%x", ret);
1941         return ret;
1942 }
1943
1944
1945 int recorder_attr_get_video_encoder_bitrate(recorder_h recorder, int *bitrate)
1946 {
1947         if (recorder == NULL) {
1948                 LOGE("NULL pointer handle");
1949                 return RECORDER_ERROR_INVALID_PARAMETER;
1950         }
1951         if (bitrate == NULL) {
1952                 LOGE("NULL pointer");
1953                 return RECORDER_ERROR_INVALID_PARAMETER;
1954         }
1955         int ret = RECORDER_ERROR_NONE;
1956         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_VIDEO_ENCODER_BITRATE;
1957         recorder_cli_s *pc = (recorder_cli_s *)recorder;
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         int get_bitrate;
1965
1966         LOGD("ENTER");
1967
1968         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
1969         if (ret == RECORDER_ERROR_NONE) {
1970                 muse_recorder_msg_get(get_bitrate, pc->cb_info->recvMsg);
1971                 *bitrate = get_bitrate;
1972         }
1973         LOGD("ret : 0x%x", ret);
1974         return ret;
1975 }
1976
1977
1978 int recorder_foreach_supported_audio_encoder(recorder_h recorder, recorder_supported_audio_encoder_cb foreach_cb, void *user_data)
1979 {
1980         if( recorder == NULL || foreach_cb == NULL){
1981                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
1982                 return RECORDER_ERROR_INVALID_PARAMETER;
1983         }
1984         int ret = RECORDER_ERROR_NONE;
1985
1986         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1987         muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_AUDIO_ENCODER;
1988
1989         LOGD("Enter, handle :%x", pc->remote_handle);
1990
1991         int sock_fd;
1992         if (pc->cb_info == NULL) {
1993                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
1994                 return RECORDER_ERROR_INVALID_PARAMETER;
1995         }
1996         sock_fd = pc->cb_info->fd;
1997         pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_AUDIO_ENCODER] = foreach_cb;
1998         pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_AUDIO_ENCODER] = user_data;
1999
2000         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
2001         LOGD("ret : 0x%x", ret);
2002         return ret;
2003 }
2004
2005
2006 int recorder_foreach_supported_video_encoder(recorder_h recorder, recorder_supported_video_encoder_cb foreach_cb, void *user_data)
2007 {
2008         if( recorder == NULL || foreach_cb == NULL){
2009                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2010                 return RECORDER_ERROR_INVALID_PARAMETER;
2011         }
2012         int ret = RECORDER_ERROR_NONE;
2013
2014         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2015         muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_VIDEO_ENCODER;
2016
2017         LOGD("Enter, handle :%x", pc->remote_handle);
2018
2019         int sock_fd;
2020         if (pc->cb_info == NULL) {
2021                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
2022                 return RECORDER_ERROR_INVALID_PARAMETER;
2023         }
2024         sock_fd = pc->cb_info->fd;
2025         pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_ENCODER] = foreach_cb;
2026         pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_ENCODER] = user_data;
2027
2028         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
2029         LOGD("ret : 0x%x", ret);
2030         return ret;
2031 }
2032
2033
2034 int recorder_attr_set_mute(recorder_h recorder, bool enable)
2035 {
2036         if (recorder == NULL) {
2037                 LOGE("NULL pointer handle");
2038                 return RECORDER_ERROR_INVALID_PARAMETER;
2039         }
2040         int ret = RECORDER_ERROR_NONE;
2041         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_MUTE;
2042         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2043         int sock_fd;
2044         if (pc->cb_info == NULL) {
2045                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
2046                 return RECORDER_ERROR_INVALID_PARAMETER;
2047         }
2048         sock_fd = pc->cb_info->fd;
2049         int set_enable = (int)enable;
2050         pc->cb_info->activating[api] = 0;
2051
2052         LOGD("ENTER");
2053
2054         muse_recorder_msg_send1(api,
2055                                                         sock_fd,
2056                                                         pc->cb_info,
2057                                                         ret,
2058                                                         INT, set_enable);
2059         LOGD("ret : 0x%x", ret);
2060         return ret;
2061 }
2062
2063
2064 bool recorder_attr_is_muted(recorder_h recorder)
2065 {
2066         if (recorder == NULL) {
2067                 LOGE("NULL pointer handle");
2068                 return false;
2069         }
2070         int ret = RECORDER_ERROR_NONE;
2071         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_IS_MUTED;
2072         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2073         int sock_fd;
2074         if (pc->cb_info == NULL) {
2075                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
2076                 return RECORDER_ERROR_INVALID_PARAMETER;
2077         }
2078         sock_fd = pc->cb_info->fd;
2079
2080         LOGD("ENTER");
2081
2082         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
2083         LOGD("ret : 0x%x", ret);
2084         return ret;
2085 }
2086
2087
2088 int recorder_attr_set_recording_motion_rate(recorder_h recorder, double rate)
2089 {
2090         if (recorder == NULL) {
2091                 LOGE("NULL pointer handle");
2092                 return RECORDER_ERROR_INVALID_PARAMETER;
2093         }
2094         int ret = RECORDER_ERROR_NONE;
2095         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_RECORDING_MOTION_RATE;
2096         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2097         int sock_fd;
2098         if (pc->cb_info == NULL) {
2099                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
2100                 return RECORDER_ERROR_INVALID_PARAMETER;
2101         }
2102         sock_fd = pc->cb_info->fd;
2103
2104         LOGD("ENTER - %.20lf", rate);
2105
2106         muse_recorder_msg_send1(api,
2107                                                         sock_fd,
2108                                                         pc->cb_info,
2109                                                         ret,
2110                                                         DOUBLE, rate);
2111
2112         LOGD("ret : 0x%x", ret);
2113
2114         return ret;
2115 }
2116
2117
2118 int recorder_attr_get_recording_motion_rate(recorder_h recorder, double *rate)
2119 {
2120         if (recorder == NULL) {
2121                 LOGE("NULL pointer handle");
2122                 return RECORDER_ERROR_INVALID_PARAMETER;
2123         }
2124         if (rate == NULL) {
2125                 LOGE("rate is NULL");
2126                 return RECORDER_ERROR_INVALID_PARAMETER;
2127         }
2128         int ret = RECORDER_ERROR_NONE;
2129         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_RECORDING_MOTION_RATE;
2130         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2131         int sock_fd;
2132         if (pc->cb_info == NULL) {
2133                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
2134                 return RECORDER_ERROR_INVALID_PARAMETER;
2135         }
2136         sock_fd = pc->cb_info->fd;
2137         double get_rate;
2138
2139         LOGD("ENTER");
2140
2141         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
2142         if (ret == RECORDER_ERROR_NONE) {
2143                 muse_recorder_msg_get_double(get_rate, pc->cb_info->recvMsg);
2144                 *rate = get_rate;
2145         }
2146         LOGD("ret : 0x%x - rate %.20lf", ret, *rate);
2147         return ret;
2148 }
2149
2150
2151 int recorder_attr_set_audio_channel(recorder_h recorder, int channel_count)
2152 {
2153         if (recorder == NULL) {
2154                 LOGE("NULL pointer handle");
2155                 return RECORDER_ERROR_INVALID_PARAMETER;
2156         }
2157         if (channel_count < 1) {
2158                 LOGE("invalid channel %d", channel_count);
2159                 return RECORDER_ERROR_INVALID_PARAMETER;
2160         }
2161         int ret = RECORDER_ERROR_NONE;
2162         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_AUDIO_CHANNEL;
2163         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2164         int sock_fd;
2165         if (pc->cb_info == NULL) {
2166                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
2167                 return RECORDER_ERROR_INVALID_PARAMETER;
2168         }
2169         sock_fd = pc->cb_info->fd;
2170
2171         LOGD("ENTER");
2172
2173         muse_recorder_msg_send1(api,
2174                                                         sock_fd,
2175                                                         pc->cb_info,
2176                                                         ret,
2177                                                         INT, channel_count);
2178         LOGD("ret : 0x%x", ret);
2179         return ret;
2180 }
2181
2182
2183 int recorder_attr_get_audio_channel(recorder_h recorder, int *channel_count)
2184 {
2185         if (recorder == NULL) {
2186                 LOGE("NULL pointer handle");
2187                 return RECORDER_ERROR_INVALID_PARAMETER;
2188         }
2189         if (channel_count == NULL) {
2190                 LOGE("channel_count is NULL");
2191                 return RECORDER_ERROR_INVALID_PARAMETER;
2192         }
2193         int ret = RECORDER_ERROR_NONE;
2194         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_AUDIO_CHANNEL;
2195         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2196         int sock_fd;
2197         if (pc->cb_info == NULL) {
2198                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
2199                 return RECORDER_ERROR_INVALID_PARAMETER;
2200         }
2201         sock_fd = pc->cb_info->fd;
2202         int get_channel_count;
2203
2204         LOGD("ENTER");
2205
2206         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
2207         if (ret == RECORDER_ERROR_NONE) {
2208                 muse_recorder_msg_get(get_channel_count, pc->cb_info->recvMsg);
2209                 *channel_count = get_channel_count;
2210         }
2211         LOGD("ret : 0x%x", ret);
2212         return ret;
2213 }
2214
2215
2216 int recorder_attr_set_orientation_tag(recorder_h recorder, recorder_rotation_e orientation)
2217 {
2218         if (recorder == NULL) {
2219                 LOGE("NULL pointer handle");
2220                 return RECORDER_ERROR_INVALID_PARAMETER;
2221         }
2222         if (orientation > RECORDER_ROTATION_270) {
2223                 LOGE("invalid orientation %d", orientation);
2224                 return RECORDER_ERROR_INVALID_PARAMETER;
2225         }
2226         int ret = RECORDER_ERROR_NONE;
2227         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_ORIENTATION_TAG;
2228         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2229         int sock_fd;
2230         if (pc->cb_info == NULL) {
2231                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
2232                 return RECORDER_ERROR_INVALID_PARAMETER;
2233         }
2234         sock_fd = pc->cb_info->fd;
2235         int set_orientation = (int)orientation;
2236
2237         LOGD("ENTER");
2238
2239         muse_recorder_msg_send1(api,
2240                                                         sock_fd,
2241                                                         pc->cb_info,
2242                                                         ret,
2243                                                         INT, set_orientation);
2244         LOGD("ret : 0x%x", ret);
2245         return ret;
2246 }
2247
2248
2249 int  recorder_attr_get_orientation_tag(recorder_h recorder, recorder_rotation_e *orientation)
2250 {
2251         if (recorder == NULL) {
2252                 LOGE("NULL pointer handle");
2253                 return RECORDER_ERROR_INVALID_PARAMETER;
2254         }
2255         if (orientation == NULL) {
2256                 LOGE("orientation is NULL");
2257                 return RECORDER_ERROR_INVALID_PARAMETER;
2258         }
2259         int ret = RECORDER_ERROR_NONE;
2260         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_ORIENTATION_TAG;
2261         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2262         int sock_fd;
2263         if (pc->cb_info == NULL) {
2264                 LOGE("INVALID_PARAMETER(0x%08x)",RECORDER_ERROR_INVALID_PARAMETER);
2265                 return RECORDER_ERROR_INVALID_PARAMETER;
2266         }
2267         sock_fd = pc->cb_info->fd;
2268         int get_orientation;
2269
2270         LOGD("ENTER");
2271
2272         muse_recorder_msg_send(api, sock_fd, pc->cb_info, ret);
2273         if (ret == RECORDER_ERROR_NONE) {
2274                 muse_recorder_msg_get(get_orientation, pc->cb_info->recvMsg);
2275                 *orientation = (recorder_rotation_e)get_orientation;
2276         }
2277         LOGD("ret : 0x%x", ret);
2278         return ret;
2279 }