src/mm_camcorder_audiorec.c

   1 /*
   2  * libmm-camcorder
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Jeongmo Yang <jm80.yang@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 /*=======================================================================================
  23 |  INCLUDE FILES                                                                        |
  24 =======================================================================================*/
  25 #include "mm_camcorder_internal.h"
  26 #include "mm_camcorder_audiorec.h"
  27 #include "mm_camcorder_util.h"
  28 #include <math.h>
  29
  30 /*---------------------------------------------------------------------------------------
  31 |    GLOBAL VARIABLE DEFINITIONS for internal                                           |
  32 ---------------------------------------------------------------------------------------*/
  33
  34 /*---------------------------------------------------------------------------------------
  35 |    LOCAL VARIABLE DEFINITIONS for internal                                            |
  36 ---------------------------------------------------------------------------------------*/
  37 #define RESET_PAUSE_TIME                        0
  38 #define _MMCAMCORDER_AUDIO_MINIMUM_SPACE        ((100*1024) + (5*1024))
  39 #define _MMCAMCORDER_RETRIAL_COUNT              10
  40 #define _MMCAMCORDER_FRAME_WAIT_TIME            200000 /* micro second */
  41 #define _MMCAMCORDER_FREE_SPACE_CHECK_INTERVAL  10
  42
  43 /*---------------------------------------------------------------------------------------
  44 |    LOCAL FUNCTION PROTOTYPES:                                                         |
  45 ---------------------------------------------------------------------------------------*/
  46 /* STATIC INTERNAL FUNCTION */
  47 static GstPadProbeReturn __mmcamcorder_audio_dataprobe_voicerecorder(GstPad *pad, GstPadProbeInfo *info, gpointer u_data);
  48 static GstPadProbeReturn __mmcamcorder_audio_dataprobe_record(GstPad *pad, GstPadProbeInfo *info, gpointer u_data);
  49 static int __mmcamcorder_create_audiop_with_encodebin(MMHandleType handle);
  50 static gboolean __mmcamcorder_audio_add_metadata_info_m4a(MMHandleType handle);
  51
  52 /*=======================================================================================
  53 |  FUNCTION DEFINITIONS                                                                 |
  54 =======================================================================================*/
  55
  56 /*---------------------------------------------------------------------------------------
  57 |    GLOBAL FUNCTION DEFINITIONS:                                                       |
  58 ---------------------------------------------------------------------------------------*/
  59
  60 static int __mmcamcorder_create_audiop_with_encodebin(MMHandleType handle)
  61 {
  62         int err = MM_ERROR_NONE;
  63         int file_name_len = 0;
  64
  65         char *file_name = NULL;
  66         const char *aenc_name = NULL;
  67         const char *mux_name = NULL;
  68         const char *sink_name = NULL;
  69
  70         GstBus *bus = NULL;
  71         GstPad *srcpad = NULL;
  72         GstPad *sinkpad = NULL;
  73         GList *element_list = NULL;
  74
  75         _MMCamcorderAudioInfo *info = NULL;
  76         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
  77         _MMCamcorderSubContext *sc = NULL;
  78         type_element *aenc_elem = NULL;
  79         type_element *mux_elem = NULL;
  80         type_element *sink_elem = NULL;
  81
  82         mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
  83         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
  84
  85         mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
  86         mmf_return_val_if_fail(sc->element, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
  87         mmf_return_val_if_fail(sc->info_audio, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
  88
  89         info = (_MMCamcorderAudioInfo *)sc->info_audio;
  90
  91         _mmcam_dbg_log("");
  92
  93         mux_elem = _mmcamcorder_get_type_element(handle, MM_CAM_FILE_FORMAT);
  94         err = _mmcamcorder_conf_get_value_element_name(mux_elem, &mux_name);
  95
  96         if (!mux_name || !strcmp(mux_name, "wavenc")) {
  97                 /* IF MUX in not chosen then record in raw file */
  98                 _mmcam_dbg_log("Record without muxing.");
  99                 info->bMuxing = FALSE;
 100         } else {
 101                 _mmcam_dbg_log("Record with mux.");
 102                 info->bMuxing = TRUE;
 103         }
 104
 105         /* Create GStreamer pipeline */
 106         _MMCAMCORDER_PIPELINE_MAKE(sc, sc->encode_element, _MMCAMCORDER_ENCODE_MAIN_PIPE, "camcorder_pipeline", err);
 107
 108         err = _mmcamcorder_create_audiosrc_bin(handle);
 109         if (err != MM_ERROR_NONE)
 110                 return err;
 111
 112         if (info->bMuxing) {
 113                 /* Muxing. can use encodebin. */
 114                 err = _mmcamcorder_create_encodesink_bin((MMHandleType)hcamcorder, MM_CAMCORDER_ENCBIN_PROFILE_AUDIO);
 115                 if (err != MM_ERROR_NONE)
 116                         return err;
 117
 118                 /* Add and link elements */
 119                 gst_bin_add_many(GST_BIN(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst),
 120                         sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst,
 121                         sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst,
 122                         NULL);
 123
 124                 srcpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst, "src");
 125                 sinkpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst, "audio_sink0");
 126                 _MM_GST_PAD_LINK_UNREF(srcpad, sinkpad, err, pipeline_creation_error);
 127         } else {
 128                 err = mm_camcorder_get_attributes(handle, NULL,
 129                         MMCAM_TARGET_FILENAME, &file_name, &file_name_len,
 130                         NULL);
 131                 if (err != MM_ERROR_NONE) {
 132                         _mmcam_dbg_err("failed to get filename [0x%x]", err);
 133                         err = MM_ERROR_CAMCORDER_RESOURCE_CREATION;
 134                         goto pipeline_creation_error;
 135                 }
 136
 137                 /* without muxing. can't use encodebin. */
 138                 aenc_elem = _mmcamcorder_get_type_element(handle, MM_CAM_AUDIO_ENCODER);
 139                 if (!aenc_elem) {
 140                         _mmcam_dbg_err("Fail to get type element");
 141                         err = MM_ERROR_CAMCORDER_RESOURCE_CREATION;
 142                         goto pipeline_creation_error;
 143                 }
 144
 145                 err = _mmcamcorder_conf_get_value_element_name(aenc_elem, &aenc_name);
 146                 if ((!err) || (!aenc_name)) {
 147                         _mmcam_dbg_err("Fail to get element name");
 148                         err = MM_ERROR_CAMCORDER_RESOURCE_CREATION;
 149                         goto pipeline_creation_error;
 150                 }
 151
 152                 element_list = g_list_append(element_list, &sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN]);
 153
 154                 _MMCAMCORDER_ELEMENT_MAKE(sc, sc->encode_element, _MMCAMCORDER_ENCSINK_AQUE, "queue",  NULL, element_list, err);
 155
 156                 if (strcmp(aenc_name, "wavenc") != 0)
 157                         _MMCAMCORDER_ELEMENT_MAKE(sc, sc->encode_element, _MMCAMCORDER_ENCSINK_CONV, "audioconvert",  NULL, element_list, err);
 158
 159                 _MMCAMCORDER_ELEMENT_MAKE(sc, sc->encode_element, _MMCAMCORDER_ENCSINK_AENC, aenc_name, NULL, element_list, err);
 160
 161                 _mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
 162                         CONFIGURE_CATEGORY_MAIN_RECORD,
 163                         "RecordsinkElement",
 164                         &sink_elem);
 165                 _mmcamcorder_conf_get_value_element_name(sink_elem, &sink_name);
 166
 167                 _mmcam_dbg_log("encode sink : %s", sink_name);
 168
 169                 _MMCAMCORDER_ELEMENT_MAKE(sc, sc->encode_element, _MMCAMCORDER_ENCSINK_SINK, sink_name, NULL, element_list, err);
 170
 171                 _mmcamcorder_conf_set_value_element_property(sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst, sink_elem);
 172
 173                 /* add elements to encode pipeline */
 174                 if (!_mmcamcorder_add_elements_to_bin(GST_BIN(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst), element_list)) {
 175                         _mmcam_dbg_err("add encode elements error.");
 176                         err = MM_ERROR_CAMCORDER_RESOURCE_CREATION;
 177                         goto pipeline_creation_error;
 178                 }
 179
 180                 /* link elements */
 181                 if (!_mmcamcorder_link_elements(element_list)) {
 182                         _mmcam_dbg_err("encode element link error.");
 183                         err = MM_ERROR_CAMCORDER_GST_LINK;
 184                         goto pipeline_creation_error;
 185                 }
 186         }
 187
 188         /* set data probe function */
 189         srcpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst, "src");
 190         MMCAMCORDER_ADD_BUFFER_PROBE(srcpad, _MMCAMCORDER_HANDLER_AUDIOREC,
 191                 __mmcamcorder_audio_dataprobe_voicerecorder, hcamcorder);
 192         gst_object_unref(srcpad);
 193         srcpad = NULL;
 194
 195         srcpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_AENC].gst, "src");
 196         MMCAMCORDER_ADD_BUFFER_PROBE(srcpad, _MMCAMCORDER_HANDLER_AUDIOREC,
 197                 __mmcamcorder_audio_dataprobe_record, hcamcorder);
 198
 199         /* for replay gain tag */
 200         MMCAMCORDER_ADD_EVENT_PROBE(srcpad, _MMCAMCORDER_HANDLER_AUDIOREC,
 201                 __mmcamcorder_eventprobe_monitor, hcamcorder);
 202
 203         gst_object_unref(srcpad);
 204         srcpad = NULL;
 205
 206         sinkpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst, "sink");
 207         MMCAMCORDER_ADD_BUFFER_PROBE(sinkpad, _MMCAMCORDER_HANDLER_AUDIOREC,
 208                 __mmcamcorder_muxed_dataprobe, hcamcorder);
 209         MMCAMCORDER_ADD_EVENT_PROBE(sinkpad, _MMCAMCORDER_HANDLER_AUDIOREC,
 210                 __mmcamcorder_eventprobe_monitor, hcamcorder);
 211         gst_object_unref(sinkpad);
 212         sinkpad = NULL;
 213
 214         bus = gst_pipeline_get_bus(GST_PIPELINE(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst));
 215
 216         /* register message callback  */
 217         hcamcorder->pipeline_cb_event_id = gst_bus_add_watch(bus, (GstBusFunc)_mmcamcorder_pipeline_cb_message, hcamcorder);
 218
 219         /* set sync callback */
 220         gst_bus_set_sync_handler(bus, _mmcamcorder_encode_pipeline_bus_sync_callback, hcamcorder, NULL);
 221
 222         gst_object_unref(bus);
 223         bus = NULL;
 224
 225         if (element_list) {
 226                 g_list_free(element_list);
 227                 element_list = NULL;
 228         }
 229
 230         return MM_ERROR_NONE;
 231
 232 pipeline_creation_error:
 233         _MMCAMCORDER_ELEMENT_REMOVE(sc->encode_element, _MMCAMCORDER_ENCODE_MAIN_PIPE);
 234         _MMCAMCORDER_ELEMENT_REMOVE(sc->encode_element, _MMCAMCORDER_AUDIOSRC_BIN);
 235         _MMCAMCORDER_ELEMENT_REMOVE(sc->encode_element, _MMCAMCORDER_ENCSINK_AQUE);
 236         _MMCAMCORDER_ELEMENT_REMOVE(sc->encode_element, _MMCAMCORDER_ENCSINK_CONV);
 237         _MMCAMCORDER_ELEMENT_REMOVE(sc->encode_element, _MMCAMCORDER_ENCSINK_AENC);
 238         _MMCAMCORDER_ELEMENT_REMOVE(sc->encode_element, _MMCAMCORDER_ENCSINK_SINK);
 239         _MMCAMCORDER_ELEMENT_REMOVE(sc->encode_element, _MMCAMCORDER_ENCSINK_BIN);
 240
 241         if (element_list) {
 242                 g_list_free(element_list);
 243                 element_list = NULL;
 244         }
 245
 246         return err;
 247 }
 248
 249
 250 int
 251 _mmcamcorder_create_audio_pipeline(MMHandleType handle)
 252 {
 253         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 254         _MMCamcorderSubContext *sc = NULL;
 255
 256         mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
 257         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
 258
 259         mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
 260
 261         return __mmcamcorder_create_audiop_with_encodebin(handle);
 262 }
 263
 264
 265 /**
 266  * This function destroy audio pipeline.
 267  *
 268  * @param[in]   handle          Handle of camcorder.
 269  * @return      void
 270  * @remarks
 271  * @see         _mmcamcorder_destroy_pipeline()
 272  *
 273  */
 274 void
 275 _mmcamcorder_destroy_audio_pipeline(MMHandleType handle)
 276 {
 277         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 278         _MMCamcorderSubContext *sc = NULL;
 279         _MMCamcorderAudioInfo *info = NULL;
 280         mmf_return_if_fail(hcamcorder);
 281         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
 282
 283         mmf_return_if_fail(sc && sc->info_audio);
 284         mmf_return_if_fail(sc->element);
 285
 286         info = sc->info_audio;
 287
 288         _mmcam_dbg_log("start");
 289
 290         if (sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst) {
 291                 _mmcam_dbg_warn("release audio pipeline");
 292
 293                 _mmcamcorder_gst_set_state(handle, sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst, GST_STATE_NULL);
 294
 295                 _mmcamcorder_remove_all_handlers((MMHandleType)hcamcorder, _MMCAMCORDER_HANDLER_CATEGORY_ALL);
 296
 297                 if (info->bMuxing) {
 298                         GstPad *reqpad = NULL;
 299                         /* FIXME:
 300                             Release request pad
 301                             The ref_count of mux is always # of streams in here, i don't know why it happens.
 302                             So, i unref the mux manually
 303                         */
 304                         reqpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "audio");
 305                         gst_element_release_request_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, reqpad);
 306                         gst_object_unref(reqpad);
 307
 308                         if (GST_IS_ELEMENT(sc->encode_element[_MMCAMCORDER_ENCSINK_MUX].gst) &&
 309                            GST_OBJECT_REFCOUNT(sc->encode_element[_MMCAMCORDER_ENCSINK_MUX].gst) > 1) {
 310                                 gst_object_unref(sc->encode_element[_MMCAMCORDER_ENCSINK_MUX].gst);
 311                         }
 312                 }
 313                 gst_object_unref(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst);
 314         }
 315
 316         _mmcam_dbg_log("done");
 317
 318         return;
 319 }
 320
 321
 322 int
 323 _mmcamcorder_audio_command(MMHandleType handle, int command)
 324 {
 325         int cmd = command;
 326         int ret = MM_ERROR_NONE;
 327         int err = 0;
 328         guint64 free_space = 0;
 329         char *err_attr_name = NULL;
 330
 331         GstElement *pipeline = NULL;
 332         GstElement *audioSrc = NULL;
 333
 334         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 335         _MMCamcorderSubContext *sc = NULL;
 336         _MMCamcorderAudioInfo *info = NULL;
 337
 338         mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
 339         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
 340
 341         mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
 342         mmf_return_val_if_fail(sc->element, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
 343         mmf_return_val_if_fail(sc->info_audio, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
 344         pipeline = sc->element[_MMCAMCORDER_MAIN_PIPE].gst;
 345         info = sc->info_audio;
 346
 347         _mmcam_dbg_log("");
 348
 349         pipeline = sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst;
 350         audioSrc = sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst;
 351         switch (cmd) {
 352         case _MMCamcorder_CMD_RECORD:
 353                 /* check status for resume case */
 354                 if (_mmcamcorder_get_state((MMHandleType)hcamcorder) != MM_CAMCORDER_STATE_PAUSED) {
 355                         guint imax_size = 0;
 356                         guint imax_time = 0;
 357                         char *temp_filename = NULL;
 358                         char *dir_name = NULL;
 359                         int file_system_type = 0;
 360                         int filename_length = 0;
 361                         int root_directory_length = 0;
 362
 363                         if (sc->pipeline_time)
 364                                 gst_element_set_start_time(pipeline, sc->pipeline_time);
 365
 366                         sc->pipeline_time = RESET_PAUSE_TIME;
 367
 368                         ret = mm_camcorder_get_attributes(handle, &err_attr_name,
 369                                 MMCAM_TARGET_MAX_SIZE, &imax_size,
 370                                 MMCAM_TARGET_TIME_LIMIT, &imax_time,
 371                                 MMCAM_FILE_FORMAT, &(info->fileformat),
 372                                 MMCAM_TARGET_FILENAME, &temp_filename, &filename_length,
 373                                 MMCAM_ROOT_DIRECTORY, &hcamcorder->root_directory, &root_directory_length,
 374                                 NULL);
 375                         if (ret != MM_ERROR_NONE) {
 376                                 _mmcam_dbg_warn("failed to get attribute. (%s:%x)", err_attr_name, ret);
 377                                 SAFE_FREE(err_attr_name);
 378                                 goto _ERR_CAMCORDER_AUDIO_COMMAND;
 379                         }
 380
 381                         if (!temp_filename && !hcamcorder->mstream_cb) {
 382                                 _mmcam_dbg_err("filename is not set and muxed stream cb is NULL");
 383                                 ret = MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
 384                                 goto _ERR_CAMCORDER_AUDIO_COMMAND;
 385                         }
 386
 387                         SAFE_G_FREE(info->filename);
 388
 389                         if (temp_filename) {
 390                                 info->filename = g_strdup(temp_filename);
 391                                 if (!info->filename) {
 392                                         _mmcam_dbg_err("STRDUP was failed for [%s]", temp_filename);
 393                                         goto _ERR_CAMCORDER_AUDIO_COMMAND;
 394                                 }
 395
 396                                 _mmcam_dbg_log("Record start : file name [%s]", info->filename);
 397
 398                                 MMCAMCORDER_G_OBJECT_SET_POINTER(sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst, "location", info->filename);
 399                         } else {
 400                                 _mmcam_dbg_log("Recorded data will be written in [%s]", _MMCamcorder_FILENAME_NULL);
 401                                 MMCAMCORDER_G_OBJECT_SET_POINTER(sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst, "location", _MMCamcorder_FILENAME_NULL);
 402                         }
 403
 404                         sc->ferror_send = FALSE;
 405                         sc->ferror_count = 0;
 406                         sc->bget_eos = FALSE;
 407                         sc->muxed_stream_offset = 0;
 408                         info->filesize = 0;
 409
 410                         /* set max size */
 411                         if (imax_size <= 0)
 412                                 info->max_size = 0; /* do not check */
 413                         else
 414                                 info->max_size = ((guint64)imax_size) << 10; /* to byte */
 415
 416                         /* set max time */
 417                         if (imax_time <= 0)
 418                                 info->max_time = 0; /* do not check */
 419                         else
 420                                 info->max_time = ((guint64)imax_time) * 1000; /* to millisecond */
 421
 422                         /* TODO : check free space before recording start */
 423                         dir_name = g_path_get_dirname(info->filename);
 424                         if (dir_name) {
 425                                 err = _mmcamcorder_get_storage_info(dir_name, hcamcorder->root_directory, &hcamcorder->storage_info);
 426                                 if (err != 0) {
 427                                         _mmcam_dbg_err("get storage info failed");
 428                                         g_free(dir_name);
 429                                         dir_name = NULL;
 430                                         return MM_ERROR_OUT_OF_STORAGE;
 431                                 }
 432
 433                                 err = _mmcamcorder_get_freespace(hcamcorder->storage_info.type, &free_space);
 434
 435                                 _mmcam_dbg_warn("current space - %s [%" G_GUINT64_FORMAT "]", dir_name, free_space);
 436
 437                                 if (_mmcamcorder_get_file_system_type(dir_name, &file_system_type) == 0) {
 438                                         /* MSDOS_SUPER_MAGIC : 0x4d44 */
 439                                         if (file_system_type == MSDOS_SUPER_MAGIC &&
 440                                             (info->max_size == 0 || info->max_size > FAT32_FILE_SYSTEM_MAX_SIZE)) {
 441                                                 _mmcam_dbg_warn("FAT32 and too large max[%"G_GUINT64_FORMAT"], set max as %lu",
 442                                                         info->max_size, FAT32_FILE_SYSTEM_MAX_SIZE);
 443                                                 info->max_size = FAT32_FILE_SYSTEM_MAX_SIZE;
 444                                         } else {
 445                                                 _mmcam_dbg_warn("file system 0x%x, max size %"G_GUINT64_FORMAT,
 446                                                                                 file_system_type, info->max_size);
 447                                         }
 448                                 } else {
 449                                         _mmcam_dbg_warn("_mmcamcorder_get_file_system_type failed");
 450                                 }
 451
 452                                 g_free(dir_name);
 453                                 dir_name = NULL;
 454                         } else {
 455                                 _mmcam_dbg_err("failed to get directory name");
 456                                 err = -1;
 457                         }
 458
 459                         if (temp_filename &&
 460                                 (err == -1 || free_space <= _MMCAMCORDER_AUDIO_MINIMUM_SPACE)) {
 461                                 _mmcam_dbg_err("OUT of STORAGE [err:%d or free space [%" G_GUINT64_FORMAT "] is smaller than [%d]",
 462                                         err, free_space, _MMCAMCORDER_AUDIO_MINIMUM_SPACE);
 463                                 return MM_ERROR_OUT_OF_STORAGE;
 464                         }
 465                 }
 466
 467                 ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_PLAYING);
 468                 if (ret != MM_ERROR_NONE)
 469                         goto _ERR_CAMCORDER_AUDIO_COMMAND;
 470
 471                 break;
 472
 473         case _MMCamcorder_CMD_PAUSE:
 474         {
 475                 GstClock *pipe_clock = NULL;
 476                 int count = 0;
 477
 478                 if (info->b_commiting) {
 479                         _mmcam_dbg_warn("now on commiting previous file!!(cmd : %d)", cmd);
 480                         return MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
 481                 }
 482
 483                 for (count = 0 ; count <= _MMCAMCORDER_RETRIAL_COUNT ; count++) {
 484                         if (info->filesize > 0) {
 485                                 break;
 486                         } else if (count == _MMCAMCORDER_RETRIAL_COUNT) {
 487                                 _mmcam_dbg_err("Pause fail, wait 200 ms, but file size is %lld",
 488                                         info->filesize);
 489                                 return MM_ERROR_CAMCORDER_INVALID_CONDITION;
 490                         } else {
 491                                 _mmcam_dbg_warn("Wait for enough audio frame, retry count[%d], file size is %lld",
 492                                         count, info->filesize);
 493                         }
 494                         usleep(_MMCAMCORDER_FRAME_WAIT_TIME);
 495                 }
 496
 497                 ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_PAUSED);
 498                 if (ret != MM_ERROR_NONE)
 499                         goto _ERR_CAMCORDER_AUDIO_COMMAND;
 500
 501                 /* FIXME: consider delay. */
 502                 pipe_clock = gst_pipeline_get_clock(GST_PIPELINE(pipeline));
 503                 sc->pipeline_time = gst_clock_get_time(pipe_clock) - gst_element_get_base_time(GST_ELEMENT(pipeline));
 504                 break;
 505         }
 506
 507         case _MMCamcorder_CMD_CANCEL:
 508                 if (info->b_commiting) {
 509                         _mmcam_dbg_warn("now on commiting previous file!!(cmd : %d)", cmd);
 510                         return MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
 511                 }
 512
 513                 ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_READY);
 514                 if (ret != MM_ERROR_NONE)
 515                         goto _ERR_CAMCORDER_AUDIO_COMMAND;
 516
 517                 if (info->bMuxing)
 518                         MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", FALSE);
 519                 else
 520                         MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_AQUE].gst, "empty-buffers", FALSE);
 521
 522                 _mmcamcorder_gst_set_state(handle, sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst, GST_STATE_NULL);
 523
 524                 sc->pipeline_time = 0;
 525                 sc->pause_time = 0;
 526                 sc->isMaxsizePausing = FALSE;
 527                 sc->isMaxtimePausing = FALSE;
 528
 529                 if (info->filename) {
 530                         _mmcam_dbg_log("file delete(%s)", info->filename);
 531                         unlink(info->filename);
 532                         SAFE_G_FREE(info->filename);
 533                 }
 534                 break;
 535
 536         case _MMCamcorder_CMD_COMMIT:
 537         {
 538                 int count = 0;
 539                 guint64 free_space = 0;
 540                 _mmcam_dbg_log("_MMCamcorder_CMD_COMMIT");
 541
 542                 if (info->b_commiting) {
 543                         _mmcam_dbg_warn("now on commiting previous file!!(cmd : %d)", cmd);
 544                         return MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
 545                 } else {
 546                         _mmcam_dbg_log("_MMCamcorder_CMD_COMMIT : start");
 547                         info->b_commiting = TRUE;
 548                 }
 549
 550                 for (count = 0 ; count <= _MMCAMCORDER_RETRIAL_COUNT ; count++) {
 551                         if (info->filesize > 0) {
 552                                 break;
 553                         } else if (count == _MMCAMCORDER_RETRIAL_COUNT) {
 554                                 _mmcam_dbg_err("Commit fail, waited 200 ms, but file size is %lld", info->filesize);
 555                                         info->b_commiting = FALSE;
 556                                 return MM_ERROR_CAMCORDER_INVALID_CONDITION;
 557                         } else {
 558                                 _mmcam_dbg_warn("Waiting for enough audio frame, re-count[%d], file size is %lld",
 559                                         count, info->filesize);
 560                         }
 561                         usleep(_MMCAMCORDER_FRAME_WAIT_TIME);
 562                 }
 563
 564                 _mmcamcorder_get_freespace(hcamcorder->storage_info.type, &free_space);
 565                 if (free_space < _MMCAMCORDER_AUDIO_MINIMUM_SPACE) {
 566                         _mmcam_dbg_warn("_MMCamcorder_CMD_COMMIT out of storage [%" G_GUINT64_FORMAT "]", free_space);
 567                         ret = MM_ERROR_OUT_OF_STORAGE;
 568                         goto _ERR_CAMCORDER_AUDIO_COMMAND;
 569                 }
 570
 571                 if (audioSrc) {
 572                         if (gst_element_send_event(audioSrc, gst_event_new_eos()) == FALSE) {
 573                                 _mmcam_dbg_err("send EOS failed");
 574                                 info->b_commiting = FALSE;
 575                                 ret = MM_ERROR_CAMCORDER_INTERNAL;
 576                                 goto _ERR_CAMCORDER_AUDIO_COMMAND;
 577                         }
 578
 579                         _mmcam_dbg_log("send EOS done");
 580
 581                         /* for pause -> commit case */
 582                         if (_mmcamcorder_get_state((MMHandleType)hcamcorder) == MM_CAMCORDER_STATE_PAUSED) {
 583                                 ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_PLAYING);
 584                                 if (ret != MM_ERROR_NONE) {
 585                                         info->b_commiting = FALSE;
 586                                         goto _ERR_CAMCORDER_AUDIO_COMMAND;
 587                                 }
 588                         }
 589                 } else {
 590                         _mmcam_dbg_err("No audio stream source");
 591                         info->b_commiting = FALSE;
 592                         ret = MM_ERROR_CAMCORDER_INTERNAL;
 593                         goto _ERR_CAMCORDER_AUDIO_COMMAND;
 594                 }
 595
 596                 /* wait until finishing EOS */
 597                 _mmcam_dbg_log("Start to wait EOS");
 598                 if ((ret = _mmcamcorder_get_eos_message(handle)) != MM_ERROR_NONE) {
 599                         info->b_commiting = FALSE;
 600                         goto _ERR_CAMCORDER_AUDIO_COMMAND;
 601                 }
 602                 break;
 603         }
 604
 605         case _MMCamcorder_CMD_PREVIEW_START:
 606                 /*MM_CAMCORDER_START_CHANGE_STATE;*/
 607                 break;
 608
 609         case _MMCamcorder_CMD_PREVIEW_STOP:
 610                 /*MM_CAMCORDER_STOP_CHANGE_STATE;*/
 611                 /*void*/
 612                 break;
 613
 614         default:
 615                 ret = MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
 616                 break;
 617         }
 618
 619 _ERR_CAMCORDER_AUDIO_COMMAND:
 620         return ret;
 621 }
 622
 623 int _mmcamcorder_audio_handle_eos(MMHandleType handle)
 624 {
 625         int err = MM_ERROR_NONE;
 626         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 627         _MMCamcorderSubContext *sc = NULL;
 628         _MMCamcorderAudioInfo *info = NULL;
 629         GstElement *pipeline = NULL;
 630         _MMCamcorderMsgItem msg;
 631         MMCamRecordingReport * report;
 632
 633         mmf_return_val_if_fail(hcamcorder, FALSE);
 634         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
 635
 636         mmf_return_val_if_fail(sc, FALSE);
 637         mmf_return_val_if_fail(sc->info_audio, FALSE);
 638
 639         _mmcam_dbg_err("");
 640
 641         info = sc->info_audio;
 642
 643         pipeline = sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst;
 644
 645         err = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_READY);
 646         if (err != MM_ERROR_NONE)
 647                 _mmcam_dbg_warn("Failed:_MMCamcorder_CMD_COMMIT:GST_STATE_READY. err[%x]", err);
 648
 649         /* Send recording report message to application */
 650         msg.id = MM_MESSAGE_CAMCORDER_AUDIO_CAPTURED;
 651         report = (MMCamRecordingReport*) g_malloc(sizeof(MMCamRecordingReport));
 652         if (!report) {
 653                 _mmcam_dbg_err("Recording report fail(%s). Out of memory.", info->filename);
 654                 return FALSE;
 655         }
 656
 657 /* START TAG HERE */
 658         /* MM_AUDIO_CODEC_AAC + MM_FILE_FORMAT_MP4 */
 659         if (info->fileformat == MM_FILE_FORMAT_3GP || info->fileformat == MM_FILE_FORMAT_MP4)
 660                 __mmcamcorder_audio_add_metadata_info_m4a(handle);
 661 /* END TAG HERE */
 662
 663         report->recording_filename = g_strdup(info->filename);
 664         msg.param.data = report;
 665
 666         _mmcamcorder_send_message(handle, &msg);
 667
 668         if (info->bMuxing)
 669                 MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", FALSE);
 670         else
 671                 MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_AQUE].gst, "empty-buffers", FALSE);
 672
 673         _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_NULL);
 674
 675         sc->pipeline_time = 0;
 676         sc->pause_time = 0;
 677         sc->isMaxsizePausing = FALSE;
 678         sc->isMaxtimePausing = FALSE;
 679
 680         SAFE_G_FREE(info->filename);
 681
 682         _mmcam_dbg_err("_MMCamcorder_CMD_COMMIT : end");
 683
 684         info->b_commiting = FALSE;
 685
 686         return TRUE;
 687 }
 688
 689
 690 static float
 691 __mmcamcorder_get_decibel(unsigned char* raw, int size, MMCamcorderAudioFormat format)
 692 {
 693         #define MAX_AMPLITUDE_MEAN_16BIT (23170.115738161934)
 694         #define MAX_AMPLITUDE_MEAN_08BIT (89.803909382810)
 695         #define DEFAULT_DECIBEL          (-80.0)
 696
 697         int i = 0;
 698         int depthByte = 0;
 699         int count = 0;
 700
 701         short* pcm16 = 0;
 702         char* pcm8 = 0;
 703
 704         float db = DEFAULT_DECIBEL;
 705         float rms = 0.0;
 706         unsigned long long square_sum = 0;
 707
 708         if (format == MM_CAMCORDER_AUDIO_FORMAT_PCM_S16_LE)
 709                 depthByte = 2;
 710         else            /*MM_CAMCORDER_AUDIO_FORMAT_PCM_U8*/
 711                 depthByte = 1;
 712
 713         for ( ; i < size ; i += (depthByte<<1)) {
 714                 if (depthByte == 1) {
 715                         pcm8 = (char *)(raw + i);
 716                         square_sum += (*pcm8) * (*pcm8);
 717                 } else { /*2byte*/
 718                         pcm16 = (short*)(raw + i);
 719                         square_sum += (*pcm16) * (*pcm16);
 720                 }
 721
 722                 count++;
 723         }
 724
 725         if (count > 0) {
 726                 rms = sqrt((double)square_sum/(double)count);
 727
 728                 if (depthByte == 1)
 729                         db = 20 * log10(rms/MAX_AMPLITUDE_MEAN_08BIT);
 730                 else
 731                         db = 20 * log10(rms/MAX_AMPLITUDE_MEAN_16BIT);
 732         }
 733
 734         /*
 735         _mmcam_dbg_log("size[%d],depthByte[%d],count[%d],rms[%f],db[%f]",
 736                                         size, depthByte, count, rms, db);
 737         */
 738
 739         return db;
 740 }
 741
 742
 743 static GstPadProbeReturn __mmcamcorder_audio_dataprobe_voicerecorder(GstPad *pad, GstPadProbeInfo *info, gpointer u_data)
 744 {
 745         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(u_data);
 746         double volume = 0.0;
 747         int current_state = MM_CAMCORDER_STATE_NONE;
 748         int format = 0;
 749         int channel = 0;
 750         float curdcb = 0.0;
 751         _MMCamcorderMsgItem msg;
 752         int err = MM_ERROR_UNKNOWN;
 753         char *err_name = NULL;
 754         GstBuffer *buffer = GST_PAD_PROBE_INFO_BUFFER(info);
 755         GstMapInfo mapinfo;
 756
 757         mmf_return_val_if_fail(hcamcorder, GST_PAD_PROBE_OK);
 758
 759         current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder);
 760         if (current_state < MM_CAMCORDER_STATE_PREPARE) {
 761                 _mmcam_dbg_warn("Not ready for stream callback");
 762                 return GST_PAD_PROBE_OK;
 763         }
 764
 765         memset(&mapinfo, 0x0, sizeof(GstMapInfo));
 766
 767         /* Set volume to audio input */
 768         err = mm_camcorder_get_attributes((MMHandleType)hcamcorder, &err_name,
 769                 MMCAM_AUDIO_VOLUME, &volume,
 770                 MMCAM_AUDIO_FORMAT, &format,
 771                 MMCAM_AUDIO_CHANNEL, &channel,
 772                 NULL);
 773
 774         if (err < 0) {
 775                 _mmcam_dbg_warn("Get attrs fail. (%s:%x)", err_name, err);
 776                 SAFE_FREE(err_name);
 777                 return err;
 778         }
 779
 780         gst_buffer_map(buffer, &mapinfo, GST_MAP_READWRITE);
 781
 782         if (volume == 0)
 783                 memset(mapinfo.data, 0, mapinfo.size);
 784
 785         /* Get current volume level of real input stream */
 786         curdcb = __mmcamcorder_get_decibel(mapinfo.data, mapinfo.size, format);
 787
 788         msg.id = MM_MESSAGE_CAMCORDER_CURRENT_VOLUME;
 789         msg.param.rec_volume_dB = curdcb;
 790         _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
 791
 792         _MMCAMCORDER_LOCK_ASTREAM_CALLBACK(hcamcorder);
 793
 794         /* CALL audio stream callback */
 795         if (hcamcorder->astream_cb && buffer && mapinfo.data && mapinfo.size > 0) {
 796                 MMCamcorderAudioStreamDataType stream;
 797
 798                 /*
 799                 _mmcam_dbg_log("Call audio steramCb, data[%p], format[%d], channel[%d], length[%d], volume_dB[%f]",
 800                         GST_BUFFER_DATA(buffer), format, channel, GST_BUFFER_SIZE(buffer), curdcb);
 801                 */
 802
 803                 stream.data = (void *)mapinfo.data;
 804                 stream.format = format;
 805                 stream.channel = channel;
 806                 stream.length = mapinfo.size;
 807                 stream.timestamp = (unsigned int)(GST_BUFFER_PTS(buffer)/1000000);      /* nano -> msecond */
 808                 stream.volume_dB = curdcb;
 809
 810                 hcamcorder->astream_cb(&stream, hcamcorder->astream_cb_param);
 811         }
 812
 813         _MMCAMCORDER_UNLOCK_ASTREAM_CALLBACK(hcamcorder);
 814
 815         gst_buffer_unmap(buffer, &mapinfo);
 816
 817         return GST_PAD_PROBE_OK;
 818 }
 819
 820
 821 static GstPadProbeReturn __mmcamcorder_audio_dataprobe_record(GstPad *pad, GstPadProbeInfo *info, gpointer u_data)
 822 {
 823         static int count = 0;
 824         guint64 rec_pipe_time = 0;
 825         guint64 free_space = 0;
 826         guint64 buffer_size = 0;
 827         guint64 trailer_size = 0;
 828         unsigned long long remained_time = 0;
 829         int get_trailer_size = 0;
 830
 831         _MMCamcorderSubContext *sc = NULL;
 832         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(u_data);
 833         _MMCamcorderAudioInfo *audioinfo = NULL;
 834         _MMCamcorderMsgItem msg;
 835         GstBuffer *buffer = GST_PAD_PROBE_INFO_BUFFER(info);
 836
 837         mmf_return_val_if_fail(hcamcorder, GST_PAD_PROBE_DROP);
 838         mmf_return_val_if_fail(buffer, GST_PAD_PROBE_DROP);
 839
 840         sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
 841         mmf_return_val_if_fail(sc && sc->info_audio, GST_PAD_PROBE_DROP);
 842         audioinfo = sc->info_audio;
 843
 844         if (sc->isMaxtimePausing || sc->isMaxsizePausing) {
 845                 _mmcam_dbg_warn("isMaxtimePausing[%d],isMaxsizePausing[%d]",
 846                         sc->isMaxtimePausing, sc->isMaxsizePausing);
 847                 return GST_PAD_PROBE_DROP;
 848         }
 849
 850         buffer_size = gst_buffer_get_size(buffer);
 851
 852         if (audioinfo->filesize == 0) {
 853                 if (audioinfo->fileformat == MM_FILE_FORMAT_WAV)
 854                         audioinfo->filesize += 44; /* wave header size */
 855                 else if (audioinfo->fileformat == MM_FILE_FORMAT_AMR)
 856                         audioinfo->filesize += 6; /* amr header size */
 857
 858                 audioinfo->filesize += buffer_size;
 859                 return GST_PAD_PROBE_OK;
 860         }
 861
 862         if (sc->ferror_send) {
 863                 _mmcam_dbg_warn("file write error, drop frames");
 864                 return GST_PAD_PROBE_DROP;
 865         }
 866
 867         /* get trailer size */
 868         get_trailer_size = (
 869                 audioinfo->fileformat == MM_FILE_FORMAT_3GP ||
 870                 audioinfo->fileformat == MM_FILE_FORMAT_MP4 ||
 871                 audioinfo->fileformat == MM_FILE_FORMAT_AAC) ? TRUE : FALSE;
 872         if (get_trailer_size) {
 873                 MMCAMCORDER_G_OBJECT_GET(sc->encode_element[_MMCAMCORDER_ENCSINK_MUX].gst, "expected-trailer-size", &trailer_size);
 874                 /*_mmcam_dbg_log("trailer_size %d", trailer_size);*/
 875         } else {
 876                 trailer_size = 0; /* no trailer */
 877         }
 878
 879         /* to minimizing free space check overhead */
 880         count = count % _MMCAMCORDER_FREE_SPACE_CHECK_INTERVAL;
 881         if (count++ == 0) {
 882                 gint free_space_ret = 0;
 883                 storage_state_e storage_state = STORAGE_STATE_UNMOUNTABLE;
 884
 885                 /* check free space */
 886                 free_space_ret = _mmcamcorder_get_freespace(hcamcorder->storage_info.type, &free_space);
 887                 if (free_space_ret != 0) {
 888                         _mmcam_dbg_err("Error occured. [%d]", free_space_ret);
 889                         if (sc->ferror_count == 2 && sc->ferror_send == FALSE) {
 890                                 sc->ferror_send = TRUE;
 891
 892                                 msg.id = MM_MESSAGE_CAMCORDER_ERROR;
 893                                 msg.param.code = MM_ERROR_FILE_READ;
 894
 895                                 _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
 896                         } else {
 897                                 sc->ferror_count++;
 898                         }
 899
 900                         return GST_PAD_PROBE_DROP; /* skip this buffer */
 901                 }
 902
 903                 if (free_space == 0) {
 904                         /* check storage state */
 905                         storage_get_state(hcamcorder->storage_info.id, &storage_state);
 906
 907                         _mmcam_dbg_warn("storage state %d", storage_state);
 908
 909                         if (storage_state == STORAGE_STATE_REMOVED ||
 910                                 storage_state == STORAGE_STATE_UNMOUNTABLE) {
 911                                 _mmcam_dbg_err("storage was removed!");
 912
 913                                 _MMCAMCORDER_LOCK(hcamcorder);
 914
 915                                 if (sc->ferror_send == FALSE) {
 916                                         _mmcam_dbg_err("OUT_OF_STORAGE error");
 917
 918                                         sc->ferror_send = TRUE;
 919
 920                                         _MMCAMCORDER_UNLOCK(hcamcorder);
 921
 922                                         msg.id = MM_MESSAGE_CAMCORDER_ERROR;
 923                                         msg.param.code = MM_ERROR_OUT_OF_STORAGE;
 924
 925                                         _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
 926                                 } else {
 927                                         _MMCAMCORDER_UNLOCK(hcamcorder);
 928                                         _mmcam_dbg_warn("error was already sent");
 929                                 }
 930
 931                                 return GST_PAD_PROBE_DROP;
 932                         }
 933                 }
 934
 935                 if (free_space < (guint64)(_MMCAMCORDER_AUDIO_MINIMUM_SPACE + buffer_size + trailer_size)) {
 936                         _mmcam_dbg_warn("No more space for recording!!!");
 937                         _mmcam_dbg_warn("Free Space : [%" G_GUINT64_FORMAT "], file size : [%" G_GUINT64_FORMAT "]",
 938                                 free_space, audioinfo->filesize);
 939
 940                         if (audioinfo->bMuxing)
 941                                 MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", TRUE);
 942                         else
 943                                 MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_AQUE].gst, "empty-buffers", TRUE);
 944
 945                         sc->isMaxsizePausing = TRUE;
 946                         msg.id = MM_MESSAGE_CAMCORDER_NO_FREE_SPACE;
 947                         _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
 948
 949                         return GST_PAD_PROBE_DROP; /* skip this buffer */
 950                 }
 951         }
 952
 953         if (!GST_CLOCK_TIME_IS_VALID(GST_BUFFER_PTS(buffer))) {
 954                 _mmcam_dbg_err("Buffer timestamp is invalid, check it");
 955                 return GST_PAD_PROBE_DROP;
 956         }
 957
 958         rec_pipe_time = GST_TIME_AS_MSECONDS(GST_BUFFER_PTS(buffer));
 959
 960         /* calculate remained time can be recorded */
 961         if (audioinfo->max_time > 0 && audioinfo->max_time < (remained_time + rec_pipe_time)) {
 962                 remained_time = audioinfo->max_time - rec_pipe_time;
 963         } else if (audioinfo->max_size > 0) {
 964                 long double max_size = (long double)audioinfo->max_size;
 965                 long double current_size = (long double)(audioinfo->filesize + buffer_size + trailer_size);
 966
 967                 remained_time = (unsigned long long)((long double)rec_pipe_time * (max_size/current_size)) - rec_pipe_time;
 968         }
 969
 970         /*_mmcam_dbg_log("remained time : %u", remained_time);*/
 971
 972         /* check max size of recorded file */
 973         if (audioinfo->max_size > 0 &&
 974                         audioinfo->max_size < audioinfo->filesize + buffer_size + trailer_size + _MMCAMCORDER_MMS_MARGIN_SPACE) {
 975                 _mmcam_dbg_warn("Max size!!! Recording is paused.");
 976                 _mmcam_dbg_warn("Max [%" G_GUINT64_FORMAT "], file [%" G_GUINT64_FORMAT "], trailer : [%" G_GUINT64_FORMAT "]", \
 977                         audioinfo->max_size, audioinfo->filesize, trailer_size);
 978
 979                 /* just same as pause status. After blocking two queue, this function will not call again. */
 980                 if (audioinfo->bMuxing)
 981                         MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", TRUE);
 982                 else
 983                         MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_AQUE].gst, "empty-buffers", TRUE);
 984
 985                 msg.id = MM_MESSAGE_CAMCORDER_RECORDING_STATUS;
 986                 msg.param.recording_status.elapsed = (unsigned long long)rec_pipe_time;
 987                 msg.param.recording_status.filesize = (unsigned long long)((audioinfo->filesize + trailer_size) >> 10);
 988                 msg.param.recording_status.remained_time = 0;
 989                 _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
 990
 991                 _mmcam_dbg_warn("Last filesize sent by message : %"G_GUINT64_FORMAT, audioinfo->filesize + trailer_size);
 992
 993                 sc->isMaxsizePausing = TRUE;
 994                 msg.id = MM_MESSAGE_CAMCORDER_MAX_SIZE;
 995                 _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
 996
 997                 /* skip this buffer */
 998                 return GST_PAD_PROBE_DROP;
 999         }
1000
1001         /* check recording time limit and send recording status message */
1002         if (audioinfo->max_time > 0 && rec_pipe_time > audioinfo->max_time) {
1003                 _mmcam_dbg_warn("Current time : [%" G_GUINT64_FORMAT "], Maximum time : [%" G_GUINT64_FORMAT "]", \
1004                         rec_pipe_time, audioinfo->max_time);
1005
1006                 if (audioinfo->bMuxing)
1007                         MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", TRUE);
1008                 else
1009                         MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_AQUE].gst, "empty-buffers", TRUE);
1010
1011                 sc->isMaxtimePausing = TRUE;
1012                 msg.id = MM_MESSAGE_CAMCORDER_TIME_LIMIT;
1013                 _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
1014
1015                 /* skip this buffer */
1016                 return GST_PAD_PROBE_DROP;
1017         }
1018
1019         /* send message for recording time and recorded file size */
1020         if (audioinfo->b_commiting == FALSE) {
1021                 audioinfo->filesize += buffer_size;
1022
1023                 msg.id = MM_MESSAGE_CAMCORDER_RECORDING_STATUS;
1024                 msg.param.recording_status.elapsed = (unsigned long long)rec_pipe_time;
1025                 msg.param.recording_status.filesize = (unsigned long long)((audioinfo->filesize + trailer_size) >> 10);
1026                 msg.param.recording_status.remained_time = remained_time;
1027                 _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
1028
1029                 return GST_PAD_PROBE_OK;
1030         } else {
1031                 /* skip this buffer if commit process has been started */
1032                 return GST_PAD_PROBE_DROP;
1033         }
1034 }
1035
1036 /* START TAG HERE */
1037 static gboolean __mmcamcorder_audio_add_metadata_info_m4a(MMHandleType handle)
1038 {
1039         FILE *f = NULL;
1040         guchar buf[4];
1041         guint64 udta_size = 0;
1042         gint64 current_pos = 0;
1043         gint64 moov_pos = 0;
1044         gint64 udta_pos = 0;
1045         /* supporting audio geo tag for mobile */
1046         int gps_enable = 0;
1047         gdouble longitude = 0;
1048         gdouble latitude = 0;
1049         gdouble altitude = 0;
1050         _MMCamcorderLocationInfo geo_info = {0, 0, 0};
1051         _MMCamcorderLocationInfo loc_info = {0, 0, 0};
1052
1053         char err_msg[128] = {'\0',};
1054
1055         _MMCamcorderAudioInfo *info = NULL;
1056         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1057         _MMCamcorderSubContext *sc = NULL;
1058
1059         mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
1060         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
1061
1062         mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
1063         mmf_return_val_if_fail(sc->info_audio, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
1064
1065         info = sc->info_audio;
1066         mm_camcorder_get_attributes(handle, NULL,
1067                 MMCAM_TAG_GPS_ENABLE, &gps_enable,
1068                 NULL);
1069
1070         if (gps_enable) {
1071                 mm_camcorder_get_attributes(handle, NULL,
1072                         MMCAM_TAG_LATITUDE, &latitude,
1073                         MMCAM_TAG_LONGITUDE, &longitude,
1074                         MMCAM_TAG_ALTITUDE, &altitude,
1075                         NULL);
1076                 loc_info.longitude = _mmcamcorder_double_to_fix(longitude);
1077                 loc_info.latitude = _mmcamcorder_double_to_fix(latitude);
1078                 loc_info.altitude = _mmcamcorder_double_to_fix(altitude);
1079                 geo_info.longitude = longitude *10000;
1080                 geo_info.latitude = latitude *10000;
1081                 geo_info.altitude = altitude *10000;
1082         }
1083
1084         f = fopen64(info->filename, "rb+");
1085         if (f == NULL) {
1086                 strerror_r(errno, err_msg, 128);
1087                 _mmcam_dbg_err("file open failed [%s]", err_msg);
1088                 return FALSE;
1089         }
1090
1091         /* find udta container.
1092            if, there are udta container, write loci box after that
1093            else, make udta container and write loci box. */
1094         if (_mmcamcorder_find_fourcc(f, MMCAM_FOURCC('u', 'd', 't', 'a'), TRUE)) {
1095                 size_t nread = 0;
1096
1097                 _mmcam_dbg_log("find udta container");
1098
1099                 /* read size */
1100                 if (fseek(f, -8L, SEEK_CUR) != 0)
1101                         goto fail;
1102
1103                 udta_pos = ftello(f);
1104                 if (udta_pos < 0)
1105                         goto ftell_fail;
1106
1107                 nread = fread(&buf, sizeof(char), sizeof(buf), f);
1108
1109                 _mmcam_dbg_log("recorded file fread %d", nread);
1110
1111                 udta_size = _mmcamcorder_get_container_size(buf);
1112
1113                 /* goto end of udta and write 'smta' box */
1114                 if (fseek(f, (udta_size-4L), SEEK_CUR) != 0)
1115                         goto fail;
1116
1117                 if (gps_enable) {
1118                         if (!_mmcamcorder_write_loci(f, loc_info))
1119                                 goto fail;
1120
1121                         if (!_mmcamcorder_write_geodata(f, geo_info))
1122                                 goto fail;
1123                 }
1124
1125                 current_pos = ftello(f);
1126                 if (current_pos < 0)
1127                         goto ftell_fail;
1128
1129                 if (!_mmcamcorder_update_size(f, udta_pos, current_pos))
1130                         goto fail;
1131         } else {
1132                 _mmcam_dbg_log("No udta container");
1133                 if (fseek(f, 0, SEEK_END) != 0)
1134                         goto fail;
1135
1136                 if (!_mmcamcorder_write_udta(f, gps_enable, loc_info, geo_info))
1137                         goto fail;
1138         }
1139
1140         /* find moov container.
1141            update moov container size. */
1142         if ((current_pos = ftello(f)) < 0)
1143                 goto ftell_fail;
1144
1145         if (_mmcamcorder_find_fourcc(f, MMCAM_FOURCC('m', 'o', 'o', 'v'), TRUE)) {
1146
1147                 _mmcam_dbg_log("found moov container");
1148                 if (fseek(f, -8L, SEEK_CUR) != 0)
1149                         goto fail;
1150
1151                 moov_pos = ftello(f);
1152                 if (moov_pos < 0)
1153                         goto ftell_fail;
1154
1155                 if (!_mmcamcorder_update_size(f, moov_pos, current_pos))
1156                         goto fail;
1157
1158         } else {
1159                 _mmcam_dbg_err("No 'moov' container");
1160                 goto fail;
1161         }
1162
1163         fclose(f);
1164
1165         return TRUE;
1166
1167 fail:
1168         fclose(f);
1169         return FALSE;
1170
1171 ftell_fail:
1172         _mmcam_dbg_err("ftell() returns negative value.");
1173         fclose(f);
1174         return FALSE;
1175 }
1176
1177 /* END TAG HERE */
1178