server/sttd_recorder.c

   1 /*
   2 * Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd All Rights Reserved
   3 *  Licensed under the Apache License, Version 2.0 (the "License");
   4 *  you may not use this file except in compliance with the License.
   5 *  You may obtain a copy of the License at
   6 *  http://www.apache.org/licenses/LICENSE-2.0
   7 *  Unless required by applicable law or agreed to in writing, software
   8 *  distributed under the License is distributed on an "AS IS" BASIS,
   9 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  10 *  See the License for the specific language governing permissions and
  11 *  limitations under the License.
  12 */
  13
  14
  15 #include <mm_error.h>
  16 #include <mm_player.h>
  17 #include <mm_types.h>
  18 #include <mm_sound.h>
  19 #include <mm_camcorder.h>
  20 #include <mm_session.h>
  21
  22 /* private Header */
  23 #include "sttd_recorder.h"
  24 #include "sttd_main.h"
  25
  26 /* Contant values  */
  27 #define DEF_TIMELIMIT 120
  28 #define DEF_SAMPLERATE 16000
  29 #define DEF_BITRATE_AMR 12200
  30 #define DEF_MAXSIZE 1024 * 1024 * 5
  31 #define DEF_SOURCECHANNEL 1
  32 #define DEF_BUFFER_SIZE 1024
  33
  34 /* Sound buf save */
  35 //#define BUF_SAVE_MODE
  36
  37 typedef struct {
  38         unsigned int    size_limit;
  39         unsigned int    time_limit;
  40         unsigned int    now;
  41         unsigned int    now_ms;
  42         unsigned int    frame;
  43         float           volume;
  44
  45         /* For MMF */
  46         unsigned int    bitrate;
  47         unsigned int    samplerate;
  48         sttd_recorder_channel   channel;
  49         sttd_recorder_state     state;
  50         sttd_recorder_audio_type        audio_type;
  51
  52         sttvr_audio_cb  streamcb;
  53
  54         MMHandleType    rec_handle;
  55         MMHandleType    ply_handle;
  56 } sttd_recorder_s;
  57
  58
  59 static sttd_recorder_s *g_objRecorer = NULL;
  60 static bool g_init = false;
  61
  62 static char g_temp_file_name[128] = {'\0',};
  63
  64 #ifdef BUF_SAVE_MODE
  65 static FILE* g_pFile;
  66 #endif
  67
  68 /* Recorder obj */
  69 sttd_recorder_s *__recorder_getinstance();
  70 void __recorder_state_set(sttd_recorder_state state);
  71
  72 /* MMFW caller */
  73 int __recorder_setup();
  74 int __recorder_run();
  75 int __recorder_pause();
  76 int __recorder_send_buf_from_file();
  77
  78 int __recorder_cancel_to_stop();
  79 int __recorder_commit_to_stop();
  80
  81
  82 /* Event Callback Function */
  83 gboolean _mm_recorder_audio_stream_cb (MMCamcorderAudioStreamDataType *stream, void *user_param)
  84 {
  85         sttd_recorder_s *pVr = __recorder_getinstance();
  86
  87         if (stream->length > 0 && stream->data) {
  88                 pVr->frame++;
  89
  90                 /* If stream callback is set */
  91                 if (STTD_RECORDER_PCM_S16 == pVr->audio_type || STTD_RECORDER_PCM_U8 == pVr->audio_type) {
  92 #ifdef BUF_SAVE_MODE
  93                         /* write pcm buffer */
  94                         fwrite(stream->data, 1, stream->length, g_pFile);
  95 #else
  96                         if (pVr->streamcb) {
  97                                 pVr->streamcb(stream->data, stream->length);
  98                         }
  99 #endif
 100                 }
 101         }
 102
 103         return TRUE;
 104 }
 105
 106
 107 int _camcorder_message_cb (int id, void *param, void *user_param)
 108 {
 109         MMMessageParamType *m = (MMMessageParamType *)param;
 110
 111         sttd_recorder_s *pVr = __recorder_getinstance();
 112
 113         if (pVr) {
 114                 switch(id) {
 115                 case MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_ASM:
 116                         break;
 117                 case MM_MESSAGE_CAMCORDER_STATE_CHANGED:
 118                         break;
 119                 case MM_MESSAGE_CAMCORDER_MAX_SIZE:
 120                         SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] MM_MESSAGE_CAMCORDER_MAX_SIZE");
 121                         sttd_recorder_stop();
 122                         break;
 123                 case MM_MESSAGE_CAMCORDER_NO_FREE_SPACE:
 124                         SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] MM_MESSAGE_CAMCORDER_NO_FREE_SPACE");
 125                         sttd_recorder_cancel();
 126                         break;
 127                 case MM_MESSAGE_CAMCORDER_TIME_LIMIT:
 128                         SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] MM_MESSAGE_CAMCORDER_TIME_LIMIT");
 129                         sttd_recorder_stop();
 130                         break;
 131                 case MM_MESSAGE_CAMCORDER_ERROR:
 132                         SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] MM_MESSAGE_CAMCORDER_ERROR");
 133                         sttd_recorder_cancel();
 134                         break;
 135                 case MM_MESSAGE_CAMCORDER_RECORDING_STATUS:
 136                         break;
 137                 case MM_MESSAGE_CAMCORDER_CURRENT_VOLUME:
 138                         pVr->volume = m->rec_volume_dB;
 139                         break;
 140                 default:
 141                         SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Other Message=%d", id);
 142                         break;
 143                 }
 144         } else {
 145                 return -1;
 146         }
 147
 148         return 0;
 149 }
 150
 151
 152 sttd_recorder_s *__recorder_getinstance()
 153 {
 154         if (!g_objRecorer) {
 155                 g_objRecorer = NULL;
 156                 g_objRecorer = g_malloc0(sizeof(sttd_recorder_s));
 157
 158                 /* set default value */
 159                 g_objRecorer->time_limit = DEF_TIMELIMIT;
 160                 g_objRecorer->size_limit = DEF_MAXSIZE;
 161                 g_objRecorer->now        = 0;
 162                 g_objRecorer->now_ms     = 0;
 163                 g_objRecorer->frame      = 0;
 164                 g_objRecorer->volume     = 0.0f;
 165                 g_objRecorer->state      = STTD_RECORDER_STATE_READY;
 166                 g_objRecorer->channel    = STTD_RECORDER_CHANNEL_MONO;
 167                 g_objRecorer->audio_type = STTD_RECORDER_PCM_S16;
 168                 g_objRecorer->samplerate = DEF_SAMPLERATE;
 169                 g_objRecorer->streamcb   = NULL;
 170         }
 171
 172         return g_objRecorer;
 173 }
 174
 175 void __recorder_state_set(sttd_recorder_state state)
 176 {
 177         sttd_recorder_s* pVr = __recorder_getinstance();
 178         pVr->state = state;
 179 }
 180
 181 void __recorder_remove_temp_file()
 182 {
 183         /* NOTE: temp file can cause permission problem */
 184         if (0 != access(g_temp_file_name, R_OK|W_OK)) {
 185                 SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] *** You don't have access right to temp file");
 186         } else {
 187                 if (0 != remove(g_temp_file_name)) {
 188                         SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] Fail to remove temp file");
 189                 }
 190         }
 191 }
 192
 193
 194 /* MMFW Interface functions */
 195 int __recorder_setup()
 196 {
 197         sttd_recorder_s *pVr = __recorder_getinstance();
 198
 199         /* mm-camcorder preset */
 200         MMCamPreset cam_info;
 201
 202         int     mmf_ret = MM_ERROR_NONE;
 203         int     err = 0;
 204         char*   err_attr_name = NULL;
 205
 206         cam_info.videodev_type = MM_VIDEO_DEVICE_NONE;
 207
 208         /* Create camcorder */
 209         mmf_ret = mm_camcorder_create( &pVr->rec_handle, &cam_info);
 210         if (MM_ERROR_NONE != mmf_ret) {
 211                 SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] Fail mm_camcorder_create ret=(%X)", mmf_ret);
 212                 return mmf_ret;
 213         }
 214
 215         switch (pVr->audio_type) {
 216         case STTD_RECORDER_PCM_U8:
 217                 SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] STTD_RECORDER_PCM_U8");
 218                 err = mm_camcorder_set_attributes(pVr->rec_handle,
 219                         &err_attr_name,
 220                         MMCAM_MODE, MM_CAMCORDER_MODE_AUDIO,
 221                         MMCAM_AUDIO_DEVICE, MM_AUDIO_DEVICE_MIC,
 222
 223                         MMCAM_AUDIO_ENCODER, MM_AUDIO_CODEC_AAC,
 224                         MMCAM_FILE_FORMAT, MM_FILE_FORMAT_3GP,
 225
 226                         MMCAM_AUDIO_SAMPLERATE, pVr->samplerate,
 227                         MMCAM_AUDIO_FORMAT, MM_CAMCORDER_AUDIO_FORMAT_PCM_U8,
 228                         MMCAM_AUDIO_CHANNEL, pVr->channel,
 229                         MMCAM_AUDIO_INPUT_ROUTE, MM_AUDIOROUTE_CAPTURE_NORMAL,
 230                         NULL );
 231
 232                 if (MM_ERROR_NONE != err) {
 233                         /* Error */
 234                         SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Fail mm_camcorder_set_attributes ret=(%X)", mmf_ret);
 235                         return err;
 236                 }
 237
 238                 break;
 239
 240         case STTD_RECORDER_PCM_S16:
 241                 SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] STTD_RECORDER_PCM_S16");
 242                 err = mm_camcorder_set_attributes(pVr->rec_handle,
 243                         &err_attr_name,
 244                         MMCAM_MODE, MM_CAMCORDER_MODE_AUDIO,
 245                         MMCAM_AUDIO_DEVICE, MM_AUDIO_DEVICE_MIC,
 246                         MMCAM_AUDIO_ENCODER, MM_AUDIO_CODEC_AAC,
 247                         MMCAM_FILE_FORMAT, MM_FILE_FORMAT_3GP,
 248                         MMCAM_AUDIO_SAMPLERATE, pVr->samplerate,
 249                         MMCAM_AUDIO_FORMAT, MM_CAMCORDER_AUDIO_FORMAT_PCM_S16_LE,
 250                         MMCAM_AUDIO_CHANNEL, pVr->channel,
 251                         MMCAM_AUDIO_INPUT_ROUTE, MM_AUDIOROUTE_CAPTURE_NORMAL,
 252                         NULL );
 253
 254                 if (MM_ERROR_NONE != err) {
 255                         /* Error */
 256                         SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Fail mm_camcorder_set_attributes ret=(%X)", mmf_ret);
 257                         return err;
 258                 }
 259                 break;
 260
 261         case STTD_RECORDER_AMR:
 262                 SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] STTD_RECORDER_AMR");
 263                 err = mm_camcorder_set_attributes(pVr->rec_handle,
 264                         &err_attr_name,
 265                         MMCAM_MODE, MM_CAMCORDER_MODE_AUDIO,
 266                         MMCAM_AUDIO_DEVICE, MM_AUDIO_DEVICE_MIC,
 267
 268                         MMCAM_AUDIO_ENCODER, MM_AUDIO_CODEC_AMR,
 269                         MMCAM_FILE_FORMAT, MM_FILE_FORMAT_AMR,
 270
 271                         MMCAM_AUDIO_SAMPLERATE, pVr->samplerate,
 272                         MMCAM_AUDIO_CHANNEL, pVr->channel,
 273
 274                         MMCAM_AUDIO_INPUT_ROUTE, MM_AUDIOROUTE_CAPTURE_NORMAL,
 275                         MMCAM_TARGET_TIME_LIMIT, pVr->time_limit,
 276                         MMCAM_TARGET_FILENAME, g_temp_file_name, strlen(g_temp_file_name)+1,
 277                         NULL );
 278
 279                 if (MM_ERROR_NONE != err) {
 280                         /* Error */
 281                         SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] Fail mm_camcorder_set_attributes ret=(%X)", mmf_ret);
 282                         return err;
 283                 }
 284                 break;
 285
 286         default:
 287                 SLOG(LOG_DEBUG, TAG_STTD, "[Recorder ERROR]");
 288                 return -1;
 289                 break;
 290         }
 291
 292         mmf_ret = mm_camcorder_set_audio_stream_callback(pVr->rec_handle, (mm_camcorder_audio_stream_callback)_mm_recorder_audio_stream_cb, NULL);
 293         if (MM_ERROR_NONE != err) {
 294                 /* Error */
 295                 SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] Fail mm_camcorder_set_audio_stream_callback ret=(%X)", mmf_ret);
 296                 return err;
 297         }
 298
 299         mmf_ret = mm_camcorder_set_message_callback(pVr->rec_handle, (MMMessageCallback)_camcorder_message_cb, pVr);
 300         if (MM_ERROR_NONE != err) {
 301                 /* Error */
 302                 SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] Fail mm_camcorder_set_message_callback ret=(%X)", mmf_ret);
 303                 return err;
 304         }
 305
 306         mmf_ret = mm_camcorder_realize(pVr->rec_handle);
 307         if (MM_ERROR_NONE != err) {
 308                 /* Error */
 309                 SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Fail mm_camcorder_realize=(%X)", mmf_ret);
 310                 return err;
 311         }
 312
 313         /* Camcorder start */
 314         mmf_ret = mm_camcorder_start(pVr->rec_handle);
 315         if (MM_ERROR_NONE != mmf_ret) {
 316                 SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Fail mm_camcorder_start=(%X)", mmf_ret);
 317                 return mmf_ret;
 318         }
 319
 320         SLOG(LOG_DEBUG, TAG_STTD, " - size_limit=%3d", pVr->size_limit);
 321         SLOG(LOG_DEBUG, TAG_STTD, " - time_limit=%3d", pVr->time_limit);
 322         SLOG(LOG_DEBUG, TAG_STTD, " - Audio Type=%d", pVr->audio_type);
 323         SLOG(LOG_DEBUG, TAG_STTD, " - Sample rates=%d", pVr->samplerate);
 324         SLOG(LOG_DEBUG, TAG_STTD, " - channel=%d", pVr->channel);
 325
 326         return 0;
 327 }
 328
 329 int __recorder_run()
 330 {
 331         sttd_recorder_s *pVr = __recorder_getinstance();
 332         int     mmf_ret = MM_ERROR_NONE;
 333
 334         /* If recorder already has recording state, cancel */
 335         if (STTD_RECORDER_STATE_RECORDING == pVr->state) {
 336                 SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Stop recording first");
 337                 __recorder_cancel_to_stop();
 338         }
 339
 340         /* Reset frame number */
 341         pVr->frame = 0;
 342
 343         /* Record start */
 344         mmf_ret = mm_camcorder_record(pVr->rec_handle);
 345         if(MM_ERROR_NONE != mmf_ret ) {
 346                 /* Error */
 347                 SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Fail mm_camcorder_record=(%X)", mmf_ret);
 348                 return mmf_ret;
 349         }
 350         SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Success mm_camcorder_record");
 351
 352         return 0;
 353 }
 354
 355 int __recorder_pause()
 356 {
 357         sttd_recorder_s *pVr = __recorder_getinstance();
 358         int mmf_ret = MM_ERROR_NONE;
 359         MMCamcorderStateType state_now = MM_CAMCORDER_STATE_NONE;
 360
 361         /* Get state from MMFW */
 362         mmf_ret = mm_camcorder_get_state(pVr->rec_handle, &state_now);
 363         if(mmf_ret != MM_ERROR_NONE ) {
 364                 SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Fail to get state : mm_camcorder_get_state");
 365                 return mmf_ret;
 366         }
 367
 368         /* Check recording state */
 369         if(MM_CAMCORDER_STATE_RECORDING != state_now) {
 370                 SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Not recording state");
 371                 return mmf_ret;
 372         }
 373
 374         /* Pause recording */
 375         mmf_ret = mm_camcorder_pause(pVr->rec_handle);
 376         if(mmf_ret == MM_ERROR_NONE ) {
 377                 SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] mm_camcorder_pause OK");
 378                 return mmf_ret;
 379         }
 380
 381         return 0;
 382 }
 383
 384 int __recorder_cancel_to_stop()
 385 {
 386         sttd_recorder_s *pVr = __recorder_getinstance();
 387         int     mmf_ret = MM_ERROR_NONE;
 388         MMCamcorderStateType rec_status = MM_CAMCORDER_STATE_NONE;
 389
 390         /* Cancel camcorder */
 391         mmf_ret = mm_camcorder_cancel(pVr->rec_handle);
 392         if(mmf_ret != MM_ERROR_NONE ) {
 393                 SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Fail to mm_camcorder_cancel");
 394                 return -1;
 395         }
 396
 397         /* Stop camcorder */
 398         mmf_ret = mm_camcorder_stop(pVr->rec_handle);
 399         if(mmf_ret != MM_ERROR_NONE ) {
 400                 SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Fail to mm_camcorder_stop");
 401                 return -1;
 402         }
 403
 404         /* Release resouces */
 405         mm_camcorder_get_state(pVr->rec_handle, &rec_status);
 406         if (MM_CAMCORDER_STATE_READY == rec_status) {
 407                 mmf_ret = mm_camcorder_unrealize(pVr->rec_handle);
 408                 SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Call mm_camcorder_unrealize ret=(%X)", mmf_ret);
 409         }
 410
 411         return 0;
 412 }
 413
 414
 415 int __recorder_commit_to_stop()
 416 {
 417         sttd_recorder_s *pVr = __recorder_getinstance();
 418         int     mmf_ret = MM_ERROR_NONE;
 419         MMCamcorderStateType rec_status = MM_CAMCORDER_STATE_NONE;
 420
 421         /* Commit camcorder */
 422         mmf_ret = mm_camcorder_commit(pVr->rec_handle);
 423         if(mmf_ret != MM_ERROR_NONE ) {
 424                 SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Fail mm_camcorder_commit=%x", mmf_ret);
 425         }
 426
 427         /* Stop camcorder */
 428         mmf_ret = mm_camcorder_stop(pVr->rec_handle);
 429         if(mmf_ret != MM_ERROR_NONE ) {
 430                 SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Fail mm_camcorder_stop=%x", mmf_ret);
 431         }
 432
 433         /* Release resouces */
 434         mm_camcorder_get_state(pVr->rec_handle, &rec_status);
 435         if (MM_CAMCORDER_STATE_READY == rec_status) {
 436                 mmf_ret = mm_camcorder_unrealize(pVr->rec_handle);
 437                 SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Call mm_camcorder_unrealize ret=(%X)", mmf_ret);
 438         }
 439
 440         return 0;
 441 }
 442
 443
 444 int __recorder_send_buf_from_file()
 445 {
 446         sttd_recorder_s *pVr = __recorder_getinstance();
 447
 448         FILE * pFile;
 449         if (!pVr->streamcb) {
 450                 SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] Return callback is not set");
 451                 return -1;
 452         }
 453
 454         if (STTD_RECORDER_AMR != pVr->audio_type) {
 455 #ifndef BUF_SAVE_MODE
 456                 return 0;
 457 #else
 458                 fclose(g_pFile);
 459 #endif
 460         }
 461
 462         pFile = fopen(g_temp_file_name, "rb");
 463         if (!pFile) {
 464                 SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] File not found!");
 465                 return -1;
 466         }
 467
 468         char buff[1024];
 469         size_t read_size = 0;
 470         int ret = 0;
 471
 472         while (!feof(pFile)) {
 473                 read_size = fread(buff, 1, 1024, pFile);
 474                 if (read_size > 0) {
 475                         ret = pVr->streamcb((void*)buff, read_size);
 476
 477                         if(ret != 0) {
 478                                 SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] Fail to set recording");
 479                                 break;
 480                         }
 481                 }
 482         }
 483
 484         fclose(pFile);
 485
 486         return 0;
 487 }
 488
 489 int __vr_mmcam_destroy()
 490 {
 491         int err = 0;
 492         sttd_recorder_s *pVr = __recorder_getinstance();
 493
 494         MMCamcorderStateType rec_status = MM_CAMCORDER_STATE_NONE;
 495
 496         mm_camcorder_get_state(pVr->rec_handle, &rec_status);
 497         if (rec_status == MM_CAMCORDER_STATE_NULL) {
 498                 err = mm_camcorder_destroy(pVr->rec_handle);
 499
 500                 if (MM_ERROR_NONE == err) {
 501                         SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] mm_camcorder_destroy OK");
 502                         pVr->rec_handle = 0;
 503                 } else {
 504                         SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] Error mm_camcorder_destroy %x", err);
 505                 }
 506
 507         }
 508
 509         return 0;
 510 }
 511
 512
 513 /* External functions */
 514 int sttd_recorder_init()
 515 {
 516         /* Create recorder instance     */
 517         sttd_recorder_s *pVr = __recorder_getinstance();
 518         if (!pVr) {
 519                 SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Fail to initialize voice recorder!");
 520                 return -1;
 521         }
 522         SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Voice Recorder Initialized p=%p", pVr);
 523
 524         /* Set temp file name */
 525         snprintf(g_temp_file_name, sizeof(g_temp_file_name), "/tmp/stt_temp_%d", getpid());
 526         SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Temp file name=[%s]", g_temp_file_name);
 527
 528         g_init = true;
 529
 530         return 0;
 531 }
 532
 533 int sttd_recorder_set(sttd_recorder_audio_type type, sttd_recorder_channel ch, unsigned int sample_rate,
 534                       unsigned int max_time, sttvr_audio_cb cbfunc)
 535 {
 536         sttd_recorder_s *pVr = __recorder_getinstance();
 537         int ret = 0;
 538
 539         if (STTD_RECORDER_STATE_RECORDING == pVr->state)
 540                 __recorder_cancel_to_stop();
 541
 542         if (STTD_RECORDER_STATE_READY != pVr->state)
 543                 __vr_mmcam_destroy();
 544
 545         /* Set attributes */
 546         pVr->audio_type = type;
 547         pVr->channel    = ch;
 548         pVr->samplerate = sample_rate;
 549         pVr->time_limit = max_time;
 550
 551         /* Stream data Callback function */
 552         if (cbfunc)
 553                 pVr->streamcb = cbfunc;
 554
 555         return ret;
 556 }
 557
 558 int sttd_recorder_start()
 559 {
 560         int ret = 0;
 561
 562         __recorder_remove_temp_file();
 563
 564 #ifdef BUF_SAVE_MODE
 565         sttd_recorder_s *pVr = __recorder_getinstance();
 566         if (!pVr) {
 567                 SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Fail to initialize voice recorder!");
 568                 return -1;
 569         }
 570
 571         if (STTD_RECORDER_AMR != pVr->audio_type) {
 572                 /* open test file */
 573                 g_pFile = fopen(g_temp_file_name, "wb+");
 574                 if (!g_pFile) {
 575                         SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] File not found!");
 576                         return -1;
 577                 }
 578         }
 579 #endif
 580
 581         /* Check if initialized */
 582         ret = __recorder_setup();
 583         if (0 != ret) {
 584                 SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Fail to call __recorder_setup");
 585                 return STTD_ERROR_OPERATION_FAILED;
 586         }
 587
 588         /* Start camcorder */
 589         ret = __recorder_run();
 590         if (0 != ret) {
 591                 SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Fail to call __recorder_run");
 592                 return STTD_ERROR_OPERATION_FAILED;
 593         }
 594
 595         __recorder_state_set(STTD_RECORDER_STATE_RECORDING);
 596
 597         return 0;
 598 }
 599
 600
 601 int sttrecorder_pause()
 602 {
 603         int ret = 0;
 604
 605         ret = __recorder_pause();
 606         if (ret) {
 607                 SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Fail to call __recorder_pause");
 608                 return -1;
 609         }
 610
 611         /* Set state */
 612         __recorder_state_set(STTD_RECORDER_STATE_PAUSED);
 613
 614         return 0;
 615 }
 616
 617 int sttd_recorder_cancel()
 618 {
 619         int ret = 0;
 620         ret = __recorder_cancel_to_stop();
 621         if (ret) {
 622                 SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Fail to call __recorder_cancel_to_stop");
 623                 return -1;
 624         }
 625
 626         ret = __vr_mmcam_destroy();
 627         if (ret) {
 628                 SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Fail to call __vr_mmcam_destroy");
 629                 return -1;
 630         }
 631
 632         /* Set state */
 633         __recorder_state_set(STTD_RECORDER_STATE_READY);
 634
 635         return 0;
 636 }
 637
 638
 639 int sttd_recorder_stop()
 640 {
 641         int ret = 0;
 642
 643         ret = __recorder_commit_to_stop();
 644         if (ret) {
 645                 SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Fail to call __recorder_commit_to_stop");
 646                 return -1;
 647         }
 648
 649         ret = __recorder_send_buf_from_file();
 650         if (ret) {
 651                 SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Fail to call __recorder_send_buf_from_file");
 652                 return -1;
 653         }
 654
 655         ret = __vr_mmcam_destroy();
 656         if (ret) {
 657                 SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Fail to call __vr_mmcam_destroy");
 658                 return -1;
 659         }
 660
 661         __recorder_state_set(STTD_RECORDER_STATE_READY);
 662
 663         return 0;
 664 }
 665
 666
 667 int sttd_recorder_destroy()
 668 {
 669         /* Destroy recorder object */
 670         if (g_objRecorer)
 671                 g_free(g_objRecorer);
 672
 673         g_objRecorer = NULL;
 674
 675         __recorder_state_set(STTD_RECORDER_STATE_READY);
 676
 677         return 0;
 678 }
 679
 680
 681 int sttd_recorder_state_get(sttd_recorder_state* state)
 682 {
 683         sttd_recorder_s *pVr = __recorder_getinstance();
 684         if (!pVr) {
 685                 SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Fail to get instance");
 686                 return -1;
 687         }
 688
 689         *state = pVr->state;
 690
 691         return 0;
 692 }
 693
 694
 695 int sttd_recorder_get_volume(float *vol)
 696 {
 697         sttd_recorder_state state;
 698
 699         sttd_recorder_s *pVr = __recorder_getinstance();
 700         if (!pVr) {
 701                 SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Fail to get instance");
 702                 return -1;
 703         }
 704
 705         sttd_recorder_state_get(&state);
 706         if (STTD_RECORDER_STATE_RECORDING != state) {
 707                 SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] Not in Recording state");
 708                 return -1;
 709         }
 710         *vol = pVr->volume;
 711
 712         return 0;
 713 }