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