server/sttd_recorder.c

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