/*---------------------------------------------------------------------------------------
| GLOBAL VARIABLE DEFINITIONS for internal |
---------------------------------------------------------------------------------------*/
-#define MM_CAMCORDER_START_CHANGE_STATE _MMCamcorderStartHelperFunc((void *)hcamcorder)
-#define MM_CAMCORDER_STOP_CHANGE_STATE _MMCamcorderStopHelperFunc((void *)hcamcorder)
+
/*---------------------------------------------------------------------------------------
| LOCAL VARIABLE DEFINITIONS for internal |
---------------------------------------------------------------------------------------*/
#define RESET_PAUSE_TIME 0
-#define _MMCAMCORDER_AUDIO_MINIMUM_SPACE (100*1024)
-#define _MMCAMCORDER_AUDIO_MARGIN_SPACE (1*1024)
+#define _MMCAMCORDER_AUDIO_MINIMUM_SPACE ((100*1024) + (5*1024))
#define _MMCAMCORDER_RETRIAL_COUNT 10
#define _MMCAMCORDER_FRAME_WAIT_TIME 200000 /* micro second */
#define _MMCAMCORDER_FREE_SPACE_CHECK_INTERVAL 10
static int __mmcamcorder_create_audiop_with_encodebin(MMHandleType handle)
{
int err = MM_ERROR_NONE;
+ int file_name_len = 0;
+
+ char *file_name = NULL;
const char *aenc_name = NULL;
const char *mux_name = NULL;
+ const char *sink_name = NULL;
GstBus *bus = NULL;
GstPad *srcpad = NULL;
_MMCamcorderSubContext *sc = NULL;
type_element *aenc_elem = NULL;
type_element *mux_elem = NULL;
+ type_element *sink_elem = NULL;
mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
_mmcam_dbg_log("");
mux_elem = _mmcamcorder_get_type_element(handle, MM_CAM_FILE_FORMAT);
- err = _mmcamcorder_conf_get_value_element_name( mux_elem, &mux_name );
+ err = _mmcamcorder_conf_get_value_element_name(mux_elem, &mux_name);
if (!mux_name || !strcmp(mux_name, "wavenc")) {
/* IF MUX in not chosen then record in raw file */
_MMCAMCORDER_PIPELINE_MAKE(sc, sc->encode_element, _MMCAMCORDER_ENCODE_MAIN_PIPE, "camcorder_pipeline", err);
err = _mmcamcorder_create_audiosrc_bin(handle);
- if (err != MM_ERROR_NONE) {
+ if (err != MM_ERROR_NONE)
return err;
- }
if (info->bMuxing) {
/* Muxing. can use encodebin. */
err = _mmcamcorder_create_encodesink_bin((MMHandleType)hcamcorder, MM_CAMCORDER_ENCBIN_PROFILE_AUDIO);
- if (err != MM_ERROR_NONE) {
+ if (err != MM_ERROR_NONE)
return err;
- }
+
+ /* Add and link elements */
+ gst_bin_add_many(GST_BIN(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst),
+ sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst,
+ sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst,
+ NULL);
+
+ srcpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst, "src");
+ sinkpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst, "audio_sink0");
+ _MM_GST_PAD_LINK_UNREF(srcpad, sinkpad, err, pipeline_creation_error);
} else {
+ err = mm_camcorder_get_attributes(handle, NULL,
+ MMCAM_TARGET_FILENAME, &file_name, &file_name_len,
+ NULL);
+ if (err != MM_ERROR_NONE) {
+ _mmcam_dbg_err("failed to get filename [0x%x]", err);
+ err = MM_ERROR_CAMCORDER_RESOURCE_CREATION;
+ goto pipeline_creation_error;
+ }
+
/* without muxing. can't use encodebin. */
aenc_elem = _mmcamcorder_get_type_element(handle, MM_CAM_AUDIO_ENCODER);
if (!aenc_elem) {
goto pipeline_creation_error;
}
+ element_list = g_list_append(element_list, &sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN]);
+
_MMCAMCORDER_ELEMENT_MAKE(sc, sc->encode_element, _MMCAMCORDER_ENCSINK_AQUE, "queue", NULL, element_list, err);
- if (strcmp(aenc_name, "wavenc") != 0) {
+ if (strcmp(aenc_name, "wavenc") != 0)
_MMCAMCORDER_ELEMENT_MAKE(sc, sc->encode_element, _MMCAMCORDER_ENCSINK_CONV, "audioconvert", NULL, element_list, err);
- }
_MMCAMCORDER_ELEMENT_MAKE(sc, sc->encode_element, _MMCAMCORDER_ENCSINK_AENC, aenc_name, NULL, element_list, err);
- _MMCAMCORDER_ELEMENT_MAKE(sc, sc->encode_element, _MMCAMCORDER_ENCSINK_SINK, "filesink", NULL, element_list, err);
- }
+ _mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
+ CONFIGURE_CATEGORY_MAIN_RECORD,
+ "RecordsinkElement",
+ &sink_elem);
+ _mmcamcorder_conf_get_value_element_name(sink_elem, &sink_name);
- /* Add and link elements */
- if (info->bMuxing) {
- /* IF MUX is indicated create MUX */
- gst_bin_add_many(GST_BIN(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst),
- sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst,
- sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst,
- NULL);
+ _mmcam_dbg_log("encode sink : %s", sink_name);
- srcpad = gst_element_get_static_pad (sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst, "src");
- sinkpad = gst_element_get_static_pad (sc->encode_element[_MMCAMCORDER_ENCSINK_BIN].gst, "audio_sink0");
- _MM_GST_PAD_LINK_UNREF(srcpad, sinkpad, err, pipeline_creation_error);
- } else {
- /* IF MUX in not chosen then record in raw amr file */
- if (!strcmp(aenc_name, "wavenc")) {
- gst_bin_add_many(GST_BIN(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst),
- sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst,
- sc->encode_element[_MMCAMCORDER_ENCSINK_AQUE].gst,
- sc->encode_element[_MMCAMCORDER_ENCSINK_AENC].gst,
- sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst,
- NULL);
-
- if (!_MM_GST_ELEMENT_LINK_MANY(sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst,
- sc->encode_element[_MMCAMCORDER_ENCSINK_AQUE].gst,
- sc->encode_element[_MMCAMCORDER_ENCSINK_AENC].gst,
- sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst,
- NULL)) {
- err = MM_ERROR_CAMCORDER_GST_LINK;
- goto pipeline_creation_error;
- }
- } else {
- gst_bin_add_many(GST_BIN(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst),
- sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst,
- sc->encode_element[_MMCAMCORDER_ENCSINK_AQUE].gst,
- sc->encode_element[_MMCAMCORDER_ENCSINK_CONV].gst,
- sc->encode_element[_MMCAMCORDER_ENCSINK_AENC].gst,
- sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst,
- NULL);
-
- if (!_MM_GST_ELEMENT_LINK_MANY(sc->encode_element[_MMCAMCORDER_AUDIOSRC_BIN].gst,
- sc->encode_element[_MMCAMCORDER_ENCSINK_AQUE].gst,
- sc->encode_element[_MMCAMCORDER_ENCSINK_CONV].gst,
- sc->encode_element[_MMCAMCORDER_ENCSINK_AENC].gst,
- sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst,
- NULL)) {
- err = MM_ERROR_CAMCORDER_GST_LINK;
- goto pipeline_creation_error;
- }
+ _MMCAMCORDER_ELEMENT_MAKE(sc, sc->encode_element, _MMCAMCORDER_ENCSINK_SINK, sink_name, NULL, element_list, err);
+
+ _mmcamcorder_conf_set_value_element_property(sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst, sink_elem);
+
+ /* add elements to encode pipeline */
+ if (!_mmcamcorder_add_elements_to_bin(GST_BIN(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst), element_list)) {
+ _mmcam_dbg_err("add encode elements error.");
+ err = MM_ERROR_CAMCORDER_RESOURCE_CREATION;
+ goto pipeline_creation_error;
+ }
+
+ /* link elements */
+ if (!_mmcamcorder_link_elements(element_list)) {
+ _mmcam_dbg_err("encode element link error.");
+ err = MM_ERROR_CAMCORDER_GST_LINK;
+ goto pipeline_creation_error;
}
}
/* set data probe function */
srcpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst, "src");
MMCAMCORDER_ADD_BUFFER_PROBE(srcpad, _MMCAMCORDER_HANDLER_AUDIOREC,
- __mmcamcorder_audio_dataprobe_voicerecorder, hcamcorder);
+ __mmcamcorder_audio_dataprobe_voicerecorder, hcamcorder);
gst_object_unref(srcpad);
srcpad = NULL;
srcpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_AENC].gst, "src");
MMCAMCORDER_ADD_BUFFER_PROBE(srcpad, _MMCAMCORDER_HANDLER_AUDIOREC,
- __mmcamcorder_audio_dataprobe_record, hcamcorder);
+ __mmcamcorder_audio_dataprobe_record, hcamcorder);
+
+ /* for replay gain tag */
+ MMCAMCORDER_ADD_EVENT_PROBE(srcpad, _MMCAMCORDER_HANDLER_AUDIOREC,
+ __mmcamcorder_eventprobe_monitor, hcamcorder);
+
gst_object_unref(srcpad);
srcpad = NULL;
+ sinkpad = gst_element_get_static_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst, "sink");
+ MMCAMCORDER_ADD_BUFFER_PROBE(sinkpad, _MMCAMCORDER_HANDLER_AUDIOREC,
+ __mmcamcorder_muxed_dataprobe, hcamcorder);
+ MMCAMCORDER_ADD_EVENT_PROBE(sinkpad, _MMCAMCORDER_HANDLER_AUDIOREC,
+ __mmcamcorder_eventprobe_monitor, hcamcorder);
+ gst_object_unref(sinkpad);
+ sinkpad = NULL;
+
bus = gst_pipeline_get_bus(GST_PIPELINE(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst));
/* register message callback */
hcamcorder->pipeline_cb_event_id = gst_bus_add_watch(bus, (GstBusFunc)_mmcamcorder_pipeline_cb_message, hcamcorder);
/* set sync callback */
- gst_bus_set_sync_handler(bus, _mmcamcorder_audio_pipeline_bus_sync_callback, hcamcorder, NULL);
+ gst_bus_set_sync_handler(bus, _mmcamcorder_encode_pipeline_bus_sync_callback, hcamcorder, NULL);
gst_object_unref(bus);
bus = NULL;
int
_mmcamcorder_create_audio_pipeline(MMHandleType handle)
{
- mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_MMCamcorderSubContext *sc = NULL;
mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
gst_element_release_request_pad(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, reqpad);
gst_object_unref(reqpad);
- if(GST_IS_ELEMENT(sc->encode_element[_MMCAMCORDER_ENCSINK_MUX].gst) &&
+ if (GST_IS_ELEMENT(sc->encode_element[_MMCAMCORDER_ENCSINK_MUX].gst) &&
GST_OBJECT_REFCOUNT(sc->encode_element[_MMCAMCORDER_ENCSINK_MUX].gst) > 1) {
gst_object_unref(sc->encode_element[_MMCAMCORDER_ENCSINK_MUX].gst);
}
}
-/**
- * This function operates each command on audio mode.
- *
- * @param c [in] Handle of camcorder context.
- * @param command [in] command type received from Multimedia Framework.
- *
- * @return This function returns MM_ERROR_NONE on success, or the other values
- * on error.
- * @remark
- * @see _mmcamcorder_set_functions()
- *
- */
- /* ADDED BY SISO */
-
-
-void* _MMCamcorderStartHelperFunc(void *handle)
-{
- mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
- _mmcamcorder_set_state((MMHandleType)hcamcorder, hcamcorder->target_state);
-
- return NULL;
-}
-
-void* _MMCamcorderStopHelperFunc(void *handle)
-{
- mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
- _mmcamcorder_set_state((MMHandleType)hcamcorder, hcamcorder->target_state);
-
- return NULL;
-}
-
-
int
_mmcamcorder_audio_command(MMHandleType handle, int command)
{
int cmd = command;
int ret = MM_ERROR_NONE;
int err = 0;
- int size=0;
guint64 free_space = 0;
- guint64 free_space_exceptsystem = 0;
- char *dir_name = NULL;
char *err_attr_name = NULL;
GstElement *pipeline = NULL;
guint imax_size = 0;
guint imax_time = 0;
char *temp_filename = NULL;
+ char *dir_name = NULL;
int file_system_type = 0;
+ int filename_length = 0;
+ int root_directory_length = 0;
- if(sc->pipeline_time) {
+ if (sc->pipeline_time)
gst_element_set_start_time(pipeline, sc->pipeline_time);
- }
+
sc->pipeline_time = RESET_PAUSE_TIME;
ret = mm_camcorder_get_attributes(handle, &err_attr_name,
- MMCAM_TARGET_MAX_SIZE, &imax_size,
- MMCAM_TARGET_TIME_LIMIT, &imax_time,
- MMCAM_FILE_FORMAT, &(info->fileformat),
- MMCAM_TARGET_FILENAME, &temp_filename, &size,
- NULL);
+ MMCAM_TARGET_MAX_SIZE, &imax_size,
+ MMCAM_TARGET_TIME_LIMIT, &imax_time,
+ MMCAM_FILE_FORMAT, &(info->fileformat),
+ MMCAM_TARGET_FILENAME, &temp_filename, &filename_length,
+ MMCAM_ROOT_DIRECTORY, &hcamcorder->root_directory, &root_directory_length,
+ NULL);
if (ret != MM_ERROR_NONE) {
_mmcam_dbg_warn("failed to get attribute. (%s:%x)", err_attr_name, ret);
SAFE_FREE(err_attr_name);
goto _ERR_CAMCORDER_AUDIO_COMMAND;
}
- if (temp_filename == NULL) {
- _mmcam_dbg_err("filename is not set");
+ if (!temp_filename && !hcamcorder->mstream_cb) {
+ _mmcam_dbg_err("filename is not set and muxed stream cb is NULL");
ret = MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
goto _ERR_CAMCORDER_AUDIO_COMMAND;
}
- info->filename = strdup(temp_filename);
- if (!info->filename) {
- _mmcam_dbg_err("STRDUP was failed");
- goto _ERR_CAMCORDER_AUDIO_COMMAND;
- }
+ SAFE_G_FREE(info->filename);
+
+ if (temp_filename) {
+ info->filename = g_strdup(temp_filename);
+ if (!info->filename) {
+ _mmcam_dbg_err("STRDUP was failed for [%s]", temp_filename);
+ goto _ERR_CAMCORDER_AUDIO_COMMAND;
+ }
- _mmcam_dbg_log("Record start : set file name using attribute - %s\n ",info->filename);
+ _mmcam_dbg_log("Record start : file name [%s]", info->filename);
- MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst, "location", info->filename);
+ MMCAMCORDER_G_OBJECT_SET_POINTER(sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst, "location", info->filename);
+ } else {
+ _mmcam_dbg_log("Recorded data will be written in [%s]", _MMCamcorder_FILENAME_NULL);
+ MMCAMCORDER_G_OBJECT_SET_POINTER(sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst, "location", _MMCamcorder_FILENAME_NULL);
+ }
sc->ferror_send = FALSE;
sc->ferror_count = 0;
sc->bget_eos = FALSE;
- info->filesize =0;
+ sc->muxed_stream_offset = 0;
+ info->filesize = 0;
/* set max size */
- if (imax_size <= 0) {
+ if (imax_size <= 0)
info->max_size = 0; /* do not check */
- } else {
+ else
info->max_size = ((guint64)imax_size) << 10; /* to byte */
- }
/* set max time */
- if (imax_time <= 0) {
+ if (imax_time <= 0)
info->max_time = 0; /* do not check */
- } else {
+ else
info->max_time = ((guint64)imax_time) * 1000; /* to millisecond */
- }
/* TODO : check free space before recording start */
dir_name = g_path_get_dirname(info->filename);
if (dir_name) {
- err = _mmcamcorder_get_freespace(dir_name, &free_space);
- if(_mmcamcorder_check_file_path(dir_name)) {
- if (_mmcamcorder_get_freespace_except_system(&free_space_exceptsystem) == MM_ERROR_NONE) {
- hcamcorder->system_memory = free_space - free_space_exceptsystem;
- free_space = free_space - hcamcorder->system_memory;
- } else {
- hcamcorder->system_memory = 0;
- }
+ err = _mmcamcorder_get_storage_info(dir_name, hcamcorder->root_directory, &hcamcorder->storage_info);
+ if (err != 0) {
+ _mmcam_dbg_err("get storage info failed");
+ g_free(dir_name);
+ dir_name = NULL;
+ return MM_ERROR_OUT_OF_STORAGE;
}
- _mmcam_dbg_warn("current space - %s [%" G_GUINT64_FORMAT "], system [%" G_GUINT64_FORMAT "]",
- dir_name, free_space, hcamcorder->system_memory);
+ err = _mmcamcorder_get_freespace(hcamcorder->storage_info.type, &free_space);
+
+ _mmcam_dbg_warn("current space - %s [%" G_GUINT64_FORMAT "]", dir_name, free_space);
if (_mmcamcorder_get_file_system_type(dir_name, &file_system_type) == 0) {
/* MSDOS_SUPER_MAGIC : 0x4d44 */
if (file_system_type == MSDOS_SUPER_MAGIC &&
(info->max_size == 0 || info->max_size > FAT32_FILE_SYSTEM_MAX_SIZE)) {
- _mmcam_dbg_warn("FAT32 and too large max[%"G_GUINT64_FORMAT"], set max as %"G_GUINT64_FORMAT,
- info->max_size, FAT32_FILE_SYSTEM_MAX_SIZE);
+ _mmcam_dbg_warn("FAT32 and too large max[%"G_GUINT64_FORMAT"], set max as %lu",
+ info->max_size, FAT32_FILE_SYSTEM_MAX_SIZE);
info->max_size = FAT32_FILE_SYSTEM_MAX_SIZE;
} else {
_mmcam_dbg_warn("file system 0x%x, max size %"G_GUINT64_FORMAT,
- file_system_type, info->max_size);
+ file_system_type, info->max_size);
}
} else {
_mmcam_dbg_warn("_mmcamcorder_get_file_system_type failed");
err = -1;
}
- if ((err == -1) || free_space <= (_MMCAMCORDER_AUDIO_MINIMUM_SPACE+(5*1024))) {
+ if (temp_filename &&
+ (err == -1 || free_space <= _MMCAMCORDER_AUDIO_MINIMUM_SPACE)) {
_mmcam_dbg_err("OUT of STORAGE [err:%d or free space [%" G_GUINT64_FORMAT "] is smaller than [%d]",
- err, free_space, (_MMCAMCORDER_AUDIO_MINIMUM_SPACE+(5*1024)));
+ err, free_space, _MMCAMCORDER_AUDIO_MINIMUM_SPACE);
return MM_ERROR_OUT_OF_STORAGE;
}
}
ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_PLAYING);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
goto _ERR_CAMCORDER_AUDIO_COMMAND;
- }
+
break;
case _MMCamcorder_CMD_PAUSE:
break;
} else if (count == _MMCAMCORDER_RETRIAL_COUNT) {
_mmcam_dbg_err("Pause fail, wait 200 ms, but file size is %lld",
- info->filesize);
+ info->filesize);
return MM_ERROR_CAMCORDER_INVALID_CONDITION;
} else {
_mmcam_dbg_warn("Wait for enough audio frame, retry count[%d], file size is %lld",
- count, info->filesize);
+ count, info->filesize);
}
usleep(_MMCAMCORDER_FRAME_WAIT_TIME);
}
ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_PAUSED);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
goto _ERR_CAMCORDER_AUDIO_COMMAND;
- }
/* FIXME: consider delay. */
pipe_clock = gst_pipeline_get_clock(GST_PIPELINE(pipeline));
}
ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_READY);
- if (ret != MM_ERROR_NONE) {
+ if (ret != MM_ERROR_NONE)
goto _ERR_CAMCORDER_AUDIO_COMMAND;
- }
- if (info->bMuxing) {
+ if (info->bMuxing)
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", FALSE);
- } else {
+ else
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_AQUE].gst, "empty-buffers", FALSE);
- }
_mmcamcorder_gst_set_state(handle, sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst, GST_STATE_NULL);
if (info->filename) {
_mmcam_dbg_log("file delete(%s)", info->filename);
unlink(info->filename);
- g_free(info->filename);
- info->filename = NULL;
+ SAFE_G_FREE(info->filename);
}
break;
case _MMCamcorder_CMD_COMMIT:
{
int count = 0;
-
+ guint64 free_space = 0;
_mmcam_dbg_log("_MMCamcorder_CMD_COMMIT");
if (info->b_commiting) {
return MM_ERROR_CAMCORDER_INVALID_CONDITION;
} else {
_mmcam_dbg_warn("Waiting for enough audio frame, re-count[%d], file size is %lld",
- count, info->filesize);
+ count, info->filesize);
}
usleep(_MMCAMCORDER_FRAME_WAIT_TIME);
}
+ _mmcamcorder_get_freespace(hcamcorder->storage_info.type, &free_space);
+ if (free_space < _MMCAMCORDER_AUDIO_MINIMUM_SPACE) {
+ _mmcam_dbg_warn("_MMCamcorder_CMD_COMMIT out of storage [%" G_GUINT64_FORMAT "]", free_space);
+ ret = MM_ERROR_OUT_OF_STORAGE;
+ goto _ERR_CAMCORDER_AUDIO_COMMAND;
+ }
+
if (audioSrc) {
- ret = gst_element_send_event(audioSrc, gst_event_new_eos());
+ if (gst_element_send_event(audioSrc, gst_event_new_eos()) == FALSE) {
+ _mmcam_dbg_err("send EOS failed");
+ info->b_commiting = FALSE;
+ ret = MM_ERROR_CAMCORDER_INTERNAL;
+ goto _ERR_CAMCORDER_AUDIO_COMMAND;
+ }
+
+ _mmcam_dbg_log("send EOS done");
+
/* for pause -> commit case */
if (_mmcamcorder_get_state((MMHandleType)hcamcorder) == MM_CAMCORDER_STATE_PAUSED) {
ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_PLAYING);
goto _ERR_CAMCORDER_AUDIO_COMMAND;
}
}
+ } else {
+ _mmcam_dbg_err("No audio stream source");
+ info->b_commiting = FALSE;
+ ret = MM_ERROR_CAMCORDER_INTERNAL;
+ goto _ERR_CAMCORDER_AUDIO_COMMAND;
}
/* wait until finishing EOS */
_mmcam_dbg_log("Start to wait EOS");
- if ((ret =_mmcamcorder_get_eos_message(handle)) != MM_ERROR_NONE) {
+ if ((ret = _mmcamcorder_get_eos_message(handle)) != MM_ERROR_NONE) {
info->b_commiting = FALSE;
goto _ERR_CAMCORDER_AUDIO_COMMAND;
}
}
case _MMCamcorder_CMD_PREVIEW_START:
- //MM_CAMCORDER_START_CHANGE_STATE;
+ /*MM_CAMCORDER_START_CHANGE_STATE;*/
break;
case _MMCamcorder_CMD_PREVIEW_STOP:
- //MM_CAMCORDER_STOP_CHANGE_STATE;
- //void
+ /*MM_CAMCORDER_STOP_CHANGE_STATE;*/
+ /*void*/
break;
default:
int _mmcamcorder_audio_handle_eos(MMHandleType handle)
{
int err = MM_ERROR_NONE;
- mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_MMCamcorderSubContext *sc = NULL;
_MMCamcorderAudioInfo *info = NULL;
GstElement *pipeline = NULL;
pipeline = sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst;
err = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_READY);
- if (err != MM_ERROR_NONE) {
+ if (err != MM_ERROR_NONE)
_mmcam_dbg_warn("Failed:_MMCamcorder_CMD_COMMIT:GST_STATE_READY. err[%x]", err);
- }
/* Send recording report message to application */
msg.id = MM_MESSAGE_CAMCORDER_AUDIO_CAPTURED;
- report = (MMCamRecordingReport*) malloc(sizeof(MMCamRecordingReport));
+ report = (MMCamRecordingReport*) g_malloc(sizeof(MMCamRecordingReport));
if (!report) {
_mmcam_dbg_err("Recording report fail(%s). Out of memory.", info->filename);
return FALSE;
}
/* START TAG HERE */
- // MM_AUDIO_CODEC_AAC + MM_FILE_FORMAT_MP4
- if(info->fileformat == MM_FILE_FORMAT_3GP || info->fileformat == MM_FILE_FORMAT_MP4){
+ /* MM_AUDIO_CODEC_AAC + MM_FILE_FORMAT_MP4 */
+ if (info->fileformat == MM_FILE_FORMAT_3GP || info->fileformat == MM_FILE_FORMAT_MP4)
__mmcamcorder_audio_add_metadata_info_m4a(handle);
- }
/* END TAG HERE */
- report->recording_filename = strdup(info->filename);
- msg.param.data= report;
+ report->recording_filename = g_strdup(info->filename);
+ msg.param.data = report;
- _mmcamcroder_send_message(handle, &msg);
+ _mmcamcorder_send_message(handle, &msg);
- if (info->bMuxing) {
+ if (info->bMuxing)
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", FALSE);
- } else {
+ else
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_AQUE].gst, "empty-buffers", FALSE);
- }
_mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_NULL);
sc->isMaxsizePausing = FALSE;
sc->isMaxtimePausing = FALSE;
- g_free(info->filename);
- info->filename = NULL;
+ SAFE_G_FREE(info->filename);
_mmcam_dbg_err("_MMCamcorder_CMD_COMMIT : end");
if (format == MM_CAMCORDER_AUDIO_FORMAT_PCM_S16_LE)
depthByte = 2;
- else //MM_CAMCORDER_AUDIO_FORMAT_PCM_U8
+ else /*MM_CAMCORDER_AUDIO_FORMAT_PCM_U8*/
depthByte = 1;
- for( ; i < size ; i += (depthByte<<1) )
- {
- if (depthByte == 1)
- {
+ for ( ; i < size ; i += (depthByte<<1)) {
+ if (depthByte == 1) {
pcm8 = (char *)(raw + i);
- square_sum += (*pcm8)*(*pcm8);
- }
- else //2byte
- {
+ square_sum += (*pcm8) * (*pcm8);
+ } else { /*2byte*/
pcm16 = (short*)(raw + i);
- square_sum += (*pcm16)*(*pcm16);
+ square_sum += (*pcm16) * (*pcm16);
}
count++;
}
if (count > 0) {
- rms = sqrt( square_sum/count );
- if (depthByte == 1) {
- db = 20 * log10( rms/MAX_AMPLITUDE_MEAN_08BIT );
- } else {
- db = 20 * log10( rms/MAX_AMPLITUDE_MEAN_16BIT );
- }
+ rms = sqrt((double)square_sum/(double)count);
+
+ if (depthByte == 1)
+ db = 20 * log10(rms/MAX_AMPLITUDE_MEAN_08BIT);
+ else
+ db = 20 * log10(rms/MAX_AMPLITUDE_MEAN_16BIT);
}
/*
_mmcam_dbg_log("size[%d],depthByte[%d],count[%d],rms[%f],db[%f]",
- size, depthByte, count, rms, db);
+ size, depthByte, count, rms, db);
*/
return db;
{
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(u_data);
double volume = 0.0;
+ int current_state = MM_CAMCORDER_STATE_NONE;
int format = 0;
int channel = 0;
float curdcb = 0.0;
mmf_return_val_if_fail(hcamcorder, GST_PAD_PROBE_OK);
+ current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder);
+ if (current_state < MM_CAMCORDER_STATE_PREPARE) {
+ _mmcam_dbg_warn("Not ready for stream callback");
+ return GST_PAD_PROBE_OK;
+ }
+
memset(&mapinfo, 0x0, sizeof(GstMapInfo));
/* Set volume to audio input */
err = mm_camcorder_get_attributes((MMHandleType)hcamcorder, &err_name,
- MMCAM_AUDIO_VOLUME, &volume,
- MMCAM_AUDIO_FORMAT, &format,
- MMCAM_AUDIO_CHANNEL, &channel,
- NULL);
+ MMCAM_AUDIO_VOLUME, &volume,
+ MMCAM_AUDIO_FORMAT, &format,
+ MMCAM_AUDIO_CHANNEL, &channel,
+ NULL);
+
if (err < 0) {
_mmcam_dbg_warn("Get attrs fail. (%s:%x)", err_name, err);
SAFE_FREE(err_name);
gst_buffer_map(buffer, &mapinfo, GST_MAP_READWRITE);
- if(volume == 0){
+ if (volume == 0)
memset(mapinfo.data, 0, mapinfo.size);
- }
/* Get current volume level of real input stream */
curdcb = __mmcamcorder_get_decibel(mapinfo.data, mapinfo.size, format);
msg.id = MM_MESSAGE_CAMCORDER_CURRENT_VOLUME;
msg.param.rec_volume_dB = curdcb;
- _mmcamcroder_send_message((MMHandleType)hcamcorder, &msg);
+ _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
+
+ _MMCAMCORDER_LOCK_ASTREAM_CALLBACK(hcamcorder);
/* CALL audio stream callback */
- if ((hcamcorder->astream_cb) && buffer && mapinfo.data && mapinfo.size > 0)
- {
+ if (hcamcorder->astream_cb && buffer && mapinfo.data && mapinfo.size > 0) {
MMCamcorderAudioStreamDataType stream;
- if (_mmcamcorder_get_state((MMHandleType)hcamcorder) < MM_CAMCORDER_STATE_PREPARE)
- {
- _mmcam_dbg_warn("Not ready for stream callback");
- gst_buffer_unmap(buffer, &mapinfo);
- return GST_PAD_PROBE_OK;
- }
-
/*
_mmcam_dbg_log("Call audio steramCb, data[%p], format[%d], channel[%d], length[%d], volume_dB[%f]",
- GST_BUFFER_DATA(buffer), format, channel, GST_BUFFER_SIZE(buffer), curdcb);
+ GST_BUFFER_DATA(buffer), format, channel, GST_BUFFER_SIZE(buffer), curdcb);
*/
stream.data = (void *)mapinfo.data;
stream.format = format;
stream.channel = channel;
stream.length = mapinfo.size;
- stream.timestamp = (unsigned int)(GST_BUFFER_PTS(buffer)/1000000); //nano -> msecond
+ stream.timestamp = (unsigned int)(GST_BUFFER_PTS(buffer)/1000000); /* nano -> msecond */
stream.volume_dB = curdcb;
- _MMCAMCORDER_LOCK_ASTREAM_CALLBACK( hcamcorder );
-
- if(hcamcorder->astream_cb)
- {
- hcamcorder->astream_cb(&stream, hcamcorder->astream_cb_param);
- }
-
- _MMCAMCORDER_UNLOCK_ASTREAM_CALLBACK( hcamcorder );
+ hcamcorder->astream_cb(&stream, hcamcorder->astream_cb_param);
}
+ _MMCAMCORDER_UNLOCK_ASTREAM_CALLBACK(hcamcorder);
+
gst_buffer_unmap(buffer, &mapinfo);
+
return GST_PAD_PROBE_OK;
}
guint64 free_space = 0;
guint64 buffer_size = 0;
guint64 trailer_size = 0;
- char *filename = NULL;
unsigned long long remained_time = 0;
+ int get_trailer_size = 0;
_MMCamcorderSubContext *sc = NULL;
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(u_data);
if (sc->isMaxtimePausing || sc->isMaxsizePausing) {
_mmcam_dbg_warn("isMaxtimePausing[%d],isMaxsizePausing[%d]",
- sc->isMaxtimePausing, sc->isMaxsizePausing);
+ sc->isMaxtimePausing, sc->isMaxsizePausing);
return GST_PAD_PROBE_DROP;
}
buffer_size = gst_buffer_get_size(buffer);
if (audioinfo->filesize == 0) {
- if (audioinfo->fileformat == MM_FILE_FORMAT_WAV) {
+ if (audioinfo->fileformat == MM_FILE_FORMAT_WAV)
audioinfo->filesize += 44; /* wave header size */
- } else if (audioinfo->fileformat == MM_FILE_FORMAT_AMR) {
+ else if (audioinfo->fileformat == MM_FILE_FORMAT_AMR)
audioinfo->filesize += 6; /* amr header size */
- }
audioinfo->filesize += buffer_size;
return GST_PAD_PROBE_OK;
}
/* get trailer size */
- if (audioinfo->fileformat == MM_FILE_FORMAT_3GP ||
- audioinfo->fileformat == MM_FILE_FORMAT_MP4 ||
- audioinfo->fileformat == MM_FILE_FORMAT_AAC) {
+ get_trailer_size = (
+ audioinfo->fileformat == MM_FILE_FORMAT_3GP ||
+ audioinfo->fileformat == MM_FILE_FORMAT_MP4 ||
+ audioinfo->fileformat == MM_FILE_FORMAT_AAC) ? TRUE : FALSE;
+ if (get_trailer_size) {
MMCAMCORDER_G_OBJECT_GET(sc->encode_element[_MMCAMCORDER_ENCSINK_MUX].gst, "expected-trailer-size", &trailer_size);
/*_mmcam_dbg_log("trailer_size %d", trailer_size);*/
} else {
trailer_size = 0; /* no trailer */
}
- filename = audioinfo->filename;
-
/* to minimizing free space check overhead */
count = count % _MMCAMCORDER_FREE_SPACE_CHECK_INTERVAL;
if (count++ == 0) {
- gint free_space_ret = _mmcamcorder_get_freespace(filename, &free_space);
+ gint free_space_ret = 0;
+ storage_state_e storage_state = STORAGE_STATE_UNMOUNTABLE;
- if(_mmcamcorder_check_file_path(filename) && hcamcorder->system_memory) {
- free_space = free_space - hcamcorder->system_memory;
- }
-
- /*_mmcam_dbg_log("check free space for recording");*/
-
- switch (free_space_ret) {
- case -2: /* file not exist */
- case -1: /* failed to get free space */
+ /* check free space */
+ free_space_ret = _mmcamcorder_get_freespace(hcamcorder->storage_info.type, &free_space);
+ if (free_space_ret != 0) {
_mmcam_dbg_err("Error occured. [%d]", free_space_ret);
if (sc->ferror_count == 2 && sc->ferror_send == FALSE) {
sc->ferror_send = TRUE;
+
msg.id = MM_MESSAGE_CAMCORDER_ERROR;
- if (free_space_ret == -2) {
- msg.param.code = MM_ERROR_FILE_NOT_FOUND;
- } else {
- msg.param.code = MM_ERROR_FILE_READ;
- }
- _mmcamcroder_send_message((MMHandleType)hcamcorder, &msg);
+ msg.param.code = MM_ERROR_FILE_READ;
+
+ _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
} else {
sc->ferror_count++;
}
return GST_PAD_PROBE_DROP; /* skip this buffer */
+ }
+
+ if (free_space == 0) {
+ /* check storage state */
+ storage_get_state(hcamcorder->storage_info.id, &storage_state);
+
+ _mmcam_dbg_warn("storage state %d", storage_state);
+
+ if (storage_state == STORAGE_STATE_REMOVED ||
+ storage_state == STORAGE_STATE_UNMOUNTABLE) {
+ _mmcam_dbg_err("storage was removed!");
+
+ _MMCAMCORDER_LOCK(hcamcorder);
+
+ if (sc->ferror_send == FALSE) {
+ _mmcam_dbg_err("OUT_OF_STORAGE error");
+
+ sc->ferror_send = TRUE;
+
+ _MMCAMCORDER_UNLOCK(hcamcorder);
- default: /* succeeded to get free space */
- /* check free space for recording */
- if (free_space < (guint64)(_MMCAMCORDER_AUDIO_MINIMUM_SPACE + buffer_size + trailer_size)) {
- _mmcam_dbg_warn("No more space for recording!!!");
- _mmcam_dbg_warn("Free Space : [%" G_GUINT64_FORMAT "], file size : [%" G_GUINT64_FORMAT "]",
- free_space, audioinfo->filesize);
+ msg.id = MM_MESSAGE_CAMCORDER_ERROR;
+ msg.param.code = MM_ERROR_OUT_OF_STORAGE;
- if (audioinfo->bMuxing) {
- MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", TRUE);
+ _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
} else {
- MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_AQUE].gst, "empty-buffers", TRUE);
+ _MMCAMCORDER_UNLOCK(hcamcorder);
+ _mmcam_dbg_warn("error was already sent");
}
- sc->isMaxsizePausing = TRUE;
- msg.id = MM_MESSAGE_CAMCORDER_NO_FREE_SPACE;
- _mmcamcroder_send_message((MMHandleType)hcamcorder, &msg);
-
- return GST_PAD_PROBE_DROP; /* skip this buffer */
+ return GST_PAD_PROBE_DROP;
}
- break;
+ }
+
+ if (free_space < (guint64)(_MMCAMCORDER_AUDIO_MINIMUM_SPACE + buffer_size + trailer_size)) {
+ _mmcam_dbg_warn("No more space for recording!!!");
+ _mmcam_dbg_warn("Free Space : [%" G_GUINT64_FORMAT "], file size : [%" G_GUINT64_FORMAT "]",
+ free_space, audioinfo->filesize);
+
+ if (audioinfo->bMuxing)
+ MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", TRUE);
+ else
+ MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_AQUE].gst, "empty-buffers", TRUE);
+
+ sc->isMaxsizePausing = TRUE;
+ msg.id = MM_MESSAGE_CAMCORDER_NO_FREE_SPACE;
+ _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
+
+ return GST_PAD_PROBE_DROP; /* skip this buffer */
}
}
audioinfo->max_size < audioinfo->filesize + buffer_size + trailer_size + _MMCAMCORDER_MMS_MARGIN_SPACE) {
_mmcam_dbg_warn("Max size!!! Recording is paused.");
_mmcam_dbg_warn("Max [%" G_GUINT64_FORMAT "], file [%" G_GUINT64_FORMAT "], trailer : [%" G_GUINT64_FORMAT "]", \
- audioinfo->max_size, audioinfo->filesize, trailer_size);
+ audioinfo->max_size, audioinfo->filesize, trailer_size);
/* just same as pause status. After blocking two queue, this function will not call again. */
- if (audioinfo->bMuxing) {
+ if (audioinfo->bMuxing)
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", TRUE);
- } else {
+ else
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_AQUE].gst, "empty-buffers", TRUE);
- }
msg.id = MM_MESSAGE_CAMCORDER_RECORDING_STATUS;
msg.param.recording_status.elapsed = (unsigned long long)rec_pipe_time;
msg.param.recording_status.filesize = (unsigned long long)((audioinfo->filesize + trailer_size) >> 10);
msg.param.recording_status.remained_time = 0;
- _mmcamcroder_send_message((MMHandleType)hcamcorder, &msg);
+ _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
- _mmcam_dbg_warn("Last filesize sent by message : %d", audioinfo->filesize + trailer_size);
+ _mmcam_dbg_warn("Last filesize sent by message : %"G_GUINT64_FORMAT, audioinfo->filesize + trailer_size);
sc->isMaxsizePausing = TRUE;
msg.id = MM_MESSAGE_CAMCORDER_MAX_SIZE;
- _mmcamcroder_send_message((MMHandleType)hcamcorder, &msg);
+ _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
/* skip this buffer */
return GST_PAD_PROBE_DROP;
/* check recording time limit and send recording status message */
if (audioinfo->max_time > 0 && rec_pipe_time > audioinfo->max_time) {
_mmcam_dbg_warn("Current time : [%" G_GUINT64_FORMAT "], Maximum time : [%" G_GUINT64_FORMAT "]", \
- rec_pipe_time, audioinfo->max_time);
+ rec_pipe_time, audioinfo->max_time);
- if (audioinfo->bMuxing) {
+ if (audioinfo->bMuxing)
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", TRUE);
- } else {
+ else
MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_ENCSINK_AQUE].gst, "empty-buffers", TRUE);
- }
sc->isMaxtimePausing = TRUE;
msg.id = MM_MESSAGE_CAMCORDER_TIME_LIMIT;
- _mmcamcroder_send_message((MMHandleType)hcamcorder, &msg);
+ _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
/* skip this buffer */
return GST_PAD_PROBE_DROP;
msg.param.recording_status.elapsed = (unsigned long long)rec_pipe_time;
msg.param.recording_status.filesize = (unsigned long long)((audioinfo->filesize + trailer_size) >> 10);
msg.param.recording_status.remained_time = remained_time;
- _mmcamcroder_send_message((MMHandleType)hcamcorder, &msg);
+ _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
return GST_PAD_PROBE_OK;
} else {
gint64 current_pos = 0;
gint64 moov_pos = 0;
gint64 udta_pos = 0;
- // supporting audio geo tag for mobile
+ /* supporting audio geo tag for mobile */
int gps_enable = 0;
- char *err_name = NULL;
gdouble longitude = 0;
gdouble latitude = 0;
gdouble altitude = 0;
- _MMCamcorderLocationInfo geo_info = {0,0,0};
- _MMCamcorderLocationInfo loc_info = {0,0,0};
+ _MMCamcorderLocationInfo geo_info = {0, 0, 0};
+ _MMCamcorderLocationInfo loc_info = {0, 0, 0};
char err_msg[128] = {'\0',};
mmf_return_val_if_fail(sc->info_audio, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
info = sc->info_audio;
- mm_camcorder_get_attributes(handle, &err_name,
- MMCAM_TAG_GPS_ENABLE, &gps_enable,
- NULL);
+ mm_camcorder_get_attributes(handle, NULL,
+ MMCAM_TAG_GPS_ENABLE, &gps_enable,
+ NULL);
if (gps_enable) {
- mm_camcorder_get_attributes(handle, &err_name,
- MMCAM_TAG_LATITUDE, &latitude,
- MMCAM_TAG_LONGITUDE, &longitude,
- MMCAM_TAG_ALTITUDE, &altitude,
- NULL);
+ mm_camcorder_get_attributes(handle, NULL,
+ MMCAM_TAG_LATITUDE, &latitude,
+ MMCAM_TAG_LONGITUDE, &longitude,
+ MMCAM_TAG_ALTITUDE, &altitude,
+ NULL);
loc_info.longitude = _mmcamcorder_double_to_fix(longitude);
loc_info.latitude = _mmcamcorder_double_to_fix(latitude);
loc_info.altitude = _mmcamcorder_double_to_fix(altitude);
geo_info.altitude = altitude *10000;
}
- f = fopen(info->filename, "rb+");
+ f = fopen64(info->filename, "rb+");
if (f == NULL) {
strerror_r(errno, err_msg, 128);
_mmcam_dbg_err("file open failed [%s]", err_msg);
- if (err_name) {
- free(err_name);
- err_name = NULL;
- }
return FALSE;
}
/* find udta container.
if, there are udta container, write loci box after that
else, make udta container and write loci box. */
- if (_mmcamcorder_find_fourcc(f, MMCAM_FOURCC('u','d','t','a'), TRUE)) {
+ if (_mmcamcorder_find_fourcc(f, MMCAM_FOURCC('u', 'd', 't', 'a'), TRUE)) {
size_t nread = 0;
_mmcam_dbg_log("find udta container");
/* read size */
- if (fseek(f, -8L, SEEK_CUR) != 0) {
+ if (fseek(f, -8L, SEEK_CUR) != 0)
goto fail;
- }
- udta_pos = ftell(f);
- if (udta_pos < 0) {
+ udta_pos = ftello(f);
+ if (udta_pos < 0)
goto ftell_fail;
- }
nread = fread(&buf, sizeof(char), sizeof(buf), f);
udta_size = _mmcamcorder_get_container_size(buf);
/* goto end of udta and write 'smta' box */
- if (fseek(f, (udta_size-4L), SEEK_CUR) != 0) {
+ if (fseek(f, (udta_size-4L), SEEK_CUR) != 0)
goto fail;
- }
if (gps_enable) {
- if (!_mmcamcorder_write_loci(f, loc_info)) {
+ if (!_mmcamcorder_write_loci(f, loc_info))
goto fail;
- }
- if (!_mmcamcorder_write_geodata( f, geo_info )) {
+ if (!_mmcamcorder_write_geodata(f, geo_info))
goto fail;
- }
}
- current_pos = ftell(f);
- if (current_pos < 0) {
+ current_pos = ftello(f);
+ if (current_pos < 0)
goto ftell_fail;
- }
- if (!_mmcamcorder_update_size(f, udta_pos, current_pos)) {
+ if (!_mmcamcorder_update_size(f, udta_pos, current_pos))
goto fail;
- }
} else {
_mmcam_dbg_log("No udta container");
- if (fseek(f, 0, SEEK_END) != 0) {
+ if (fseek(f, 0, SEEK_END) != 0)
goto fail;
- }
- if (!_mmcamcorder_write_udta(f, gps_enable, loc_info, geo_info)) {
+ if (!_mmcamcorder_write_udta(f, gps_enable, loc_info, geo_info))
goto fail;
- }
}
/* find moov container.
update moov container size. */
- if((current_pos = ftell(f))<0)
+ if ((current_pos = ftello(f)) < 0)
goto ftell_fail;
- if (_mmcamcorder_find_fourcc(f, MMCAM_FOURCC('m','o','o','v'), TRUE)) {
+ if (_mmcamcorder_find_fourcc(f, MMCAM_FOURCC('m', 'o', 'o', 'v'), TRUE)) {
_mmcam_dbg_log("found moov container");
- if (fseek(f, -8L, SEEK_CUR) !=0) {
+ if (fseek(f, -8L, SEEK_CUR) != 0)
goto fail;
- }
- moov_pos = ftell(f);
- if (moov_pos < 0) {
+ moov_pos = ftello(f);
+ if (moov_pos < 0)
goto ftell_fail;
- }
- if (!_mmcamcorder_update_size(f, moov_pos, current_pos)) {
+ if (!_mmcamcorder_update_size(f, moov_pos, current_pos))
goto fail;
- }
-
} else {
_mmcam_dbg_err("No 'moov' container");
}
fclose(f);
- if (err_name) {
- free(err_name);
- err_name = NULL;
- }
+
return TRUE;
fail:
fclose(f);
- if (err_name) {
- free(err_name);
- err_name = NULL;
- }
return FALSE;
ftell_fail:
_mmcam_dbg_err("ftell() returns negative value.");
fclose(f);
- if (err_name) {
- free(err_name);
- err_name = NULL;
- }
return FALSE;
}
projects / platform / core / multimedia / libmm-camcorder.git / blobdiff