SET(submodule "recorder")
# for package file
-SET(dependents "dlog mm-camcorder capi-media-camera")
-SET(pc_dependents "capi-base-common capi-media-camera")
+SET(dependents "dlog mm-camcorder capi-media-camera capi-media-audio-io")
+SET(pc_dependents "capi-base-common capi-media-camera capi-media-audio-io")
SET(fw_name "${project_prefix}-${service}-${submodule}")
--- /dev/null
+#!/bin/sh
+
+. ./config
+export TET_INSTALL_PATH=$TET_INSTALL_HOST_PATH # tetware root path
+export TET_TARGET_PATH=$TET_INSTALL_PATH/tetware-target # tetware target path
+export PATH=$TET_TARGET_PATH/bin:$PATH
+export LD_LIBRARY_PATH=$TET_TARGET_PATH/lib/tet3:$LD_LIBRARY_PATH
+export TET_ROOT=$TET_TARGET_PATH
--- /dev/null
+#!/bin/sh
+. ./config
+export TET_INSTALL_PATH=$TET_INSTALL_TARGET_PATH # path to path
+export TET_TARGET_PATH=$TET_INSTALL_PATH/tetware-target
+export PATH=$TET_TARGET_PATH/bin:$PATH
+export LD_LIBRARY_PATH=$TET_TARGET_PATH/lib/tet3:$LD_LIBRARY_PATH
+export TET_ROOT=$TET_TARGET_PATH
--- /dev/null
+#!/bin/sh
+
+. ./_export_env.sh # setting environment variables
+
+export TET_SUITE_ROOT=`pwd`
+FILE_NAME_EXTENSION=`date +%s`
+
+RESULT_DIR=results
+HTML_RESULT=$RESULT_DIR/build-tar-result-$FILE_NAME_EXTENSION.html
+JOURNAL_RESULT=$RESULT_DIR/build-tar-result-$FILE_NAME_EXTENSION.journal
+
+mkdir -p $RESULT_DIR
+
+tcc -c -p ./
+tcc -b -j $JOURNAL_RESULT -p ./
+grw -c 7 -f chtml -o $HTML_RESULT $JOURNAL_RESULT
--- /dev/null
+#!/bin/sh
+
+. ./_export_env.sh # setting environment variables
+
+export TET_SUITE_ROOT=`pwd`
+RESULT_DIR=results
+
+tcc -c -p ./ # executing tcc, with clean option (-c)
+rm -r $RESULT_DIR
+rm -r tet_tmp_dir
+rm testcase/tet_captured
--- /dev/null
+CAPI_PROJECT_ROOT=/home/abyss/capi
+TET_INSTALL_HOST_PATH=/home/abyss/TETware
+TET_INSTALL_TARGET_PATH=/mnt/nfs/TETware
--- /dev/null
+#!/bin/sh
+
+. ./_export_target_env.sh # setting environment variables
+
+export TET_SUITE_ROOT=`pwd`
+FILE_NAME_EXTENSION=`date +%s`
+
+RESULT_DIR=results
+HTML_RESULT=$RESULT_DIR/exec-tar-result-$FILE_NAME_EXTENSION.html
+JOURNAL_RESULT=$RESULT_DIR/exec-tar-result-$FILE_NAME_EXTENSION.journal
+
+mkdir -p $RESULT_DIR
+
+tcc -e -j $JOURNAL_RESULT -p ./
+grw -c 3 -f chtml -o $HTML_RESULT $JOURNAL_RESULT
--- /dev/null
+CC ?= gcc
+
+C_FILES = $(shell ls *.c)
+
+PKGS = capi-media-camera capi-media-recorder dlog glib-2.0 gthread-2.0
+
+LDFLAGS = `pkg-config --libs $(PKGS)`
+LDFLAGS += $(TET_ROOT)/lib/tet3/tcm_s.o
+LDFLAGS += -L$(TET_ROOT)/lib/tet3 -ltcm_s
+LDFLAGS += -L$(TET_ROOT)/lib/tet3 -lapi_s
+
+CFLAGS = -I. `pkg-config --cflags $(PKGS)`
+CFLAGS += -I$(TET_ROOT)/inc/tet3
+CFLAGS += -Wall -Werror
+
+#TARGETS = $(C_FILES:%.c=tc-%)
+TCS := $(shell ls -1 *.c | cut -d. -f1)
+
+all: $(TCS)
+
+%: %.c
+ $(CC) -o $@ $< $(CFLAGS) $(LDFLAGS)
+
+clean:
+ rm -f $(TCS)
--- /dev/null
+/testcase/utc_media_recorder
+/testcase/utc_media_recorder_callback
+/testcase/utc_media_recorder_lifecycle
+/testcase/utc_media_recorder_working
--- /dev/null
+/*
+* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+
+
+#include <tet_api.h>
+#include <media/recorder.h>
+
+#define MY_ASSERT( fun , test , msg ) \
+{\
+ if( !test ) \
+ dts_fail(fun , msg ); \
+}
+
+
+static void startup(void);
+static void cleanup(void);
+
+void (*tet_startup)(void) = startup;
+void (*tet_cleanup)(void) = cleanup;
+
+static void utc_media_recorder_attr_get_audio_device_p(void);
+static void utc_media_recorder_attr_get_audio_device_n(void);
+static void utc_media_recorder_attr_get_audio_encoder_bitrate_p(void);
+static void utc_media_recorder_attr_get_audio_encoder_bitrate_n(void);
+static void utc_media_recorder_attr_get_audio_samplerate_p(void);
+static void utc_media_recorder_attr_get_audio_samplerate_n(void);
+static void utc_media_recorder_attr_get_size_limit_p(void);
+static void utc_media_recorder_attr_get_size_limit_n(void);
+static void utc_media_recorder_attr_get_time_limit_p(void);
+static void utc_media_recorder_attr_get_time_limit_n(void);
+static void utc_media_recorder_attr_get_video_encoder_bitrate_p(void);
+static void utc_media_recorder_attr_get_video_encoder_bitrate_n(void);
+static void utc_media_recorder_attr_set_audio_device_p(void);
+static void utc_media_recorder_attr_set_audio_device_n(void);
+static void utc_media_recorder_attr_set_audio_encoder_bitrate_p(void);
+static void utc_media_recorder_attr_set_audio_encoder_bitrate_n(void);
+static void utc_media_recorder_attr_set_audio_samplerate_p(void);
+static void utc_media_recorder_attr_set_audio_samplerate_n(void);
+static void utc_media_recorder_attr_set_size_limit_p(void);
+static void utc_media_recorder_attr_set_size_limit_n(void);
+static void utc_media_recorder_attr_set_time_limit_p(void);
+static void utc_media_recorder_attr_set_time_limit_n(void);
+static void utc_media_recorder_attr_set_video_encoder_bitrate_p(void);
+static void utc_media_recorder_attr_set_video_encoder_bitrate_n(void);
+static void utc_media_recorder_get_audio_encoder_p(void);
+static void utc_media_recorder_get_audio_encoder_n(void);
+static void utc_media_recorder_get_file_format_p(void);
+static void utc_media_recorder_get_file_format_n(void);
+static void utc_media_recorder_get_video_encoder_p(void);
+static void utc_media_recorder_get_video_encoder_n(void);
+static void utc_media_recorder_set_audio_encoder_p(void);
+static void utc_media_recorder_set_audio_encoder_n(void);
+static void utc_media_recorder_set_file_format_p(void);
+static void utc_media_recorder_set_file_format_n(void);
+static void utc_media_recorder_set_filename_p(void);
+static void utc_media_recorder_set_filename_n(void);
+static void utc_media_recorder_set_video_encoder_p(void);
+static void utc_media_recorder_set_video_encoder_n(void);
+
+struct tet_testlist tet_testlist[] = {
+ { utc_media_recorder_attr_get_audio_device_p , 1 },
+ { utc_media_recorder_attr_get_audio_device_n , 2 },
+ { utc_media_recorder_attr_get_audio_encoder_bitrate_p , 1 },
+ { utc_media_recorder_attr_get_audio_encoder_bitrate_n , 2 },
+ { utc_media_recorder_attr_get_audio_samplerate_p , 1 },
+ { utc_media_recorder_attr_get_audio_samplerate_n , 2 },
+ { utc_media_recorder_attr_get_size_limit_p , 1 },
+ { utc_media_recorder_attr_get_size_limit_n , 2 },
+ { utc_media_recorder_attr_get_time_limit_p , 1 },
+ { utc_media_recorder_attr_get_time_limit_n , 2 },
+ { utc_media_recorder_attr_get_video_encoder_bitrate_p , 1 },
+ { utc_media_recorder_attr_get_video_encoder_bitrate_n , 2 },
+ { utc_media_recorder_attr_set_audio_device_p , 1 },
+ { utc_media_recorder_attr_set_audio_device_n , 2 },
+ { utc_media_recorder_attr_set_audio_encoder_bitrate_p , 1 },
+ { utc_media_recorder_attr_set_audio_encoder_bitrate_n , 2 },
+ { utc_media_recorder_attr_set_audio_samplerate_p , 1 },
+ { utc_media_recorder_attr_set_audio_samplerate_n , 2 },
+ { utc_media_recorder_attr_set_size_limit_p , 1 },
+ { utc_media_recorder_attr_set_size_limit_n , 2 },
+ { utc_media_recorder_attr_set_time_limit_p , 1 },
+ { utc_media_recorder_attr_set_time_limit_n , 2 },
+ { utc_media_recorder_attr_set_video_encoder_bitrate_p , 1 },
+ { utc_media_recorder_attr_set_video_encoder_bitrate_n , 2 },
+ { utc_media_recorder_get_audio_encoder_p , 1 },
+ { utc_media_recorder_get_audio_encoder_n , 2 },
+ { utc_media_recorder_get_file_format_p , 1 },
+ { utc_media_recorder_get_file_format_n , 2 },
+ { utc_media_recorder_get_video_encoder_p , 1 },
+ { utc_media_recorder_get_video_encoder_n , 2 },
+ { utc_media_recorder_set_audio_encoder_p , 1 },
+ { utc_media_recorder_set_audio_encoder_n , 2 },
+ { utc_media_recorder_set_file_format_p , 1 },
+ { utc_media_recorder_set_file_format_n , 2 },
+ { utc_media_recorder_set_filename_p , 1 },
+ { utc_media_recorder_set_filename_n , 2 },
+ { utc_media_recorder_set_video_encoder_p , 1 },
+ { utc_media_recorder_set_video_encoder_n , 2 },
+ { NULL, 0 },
+};
+
+recorder_h recorder;
+
+static void startup(void)
+{
+ /* start of TC */
+ int ret;
+ ret = recorder_create_audiorecorder(&recorder);
+ if( ret != 0 )
+ dts_fail("recorder_create_audiorecorder", "Could not create audio recorder");
+}
+
+static void cleanup(void)
+{
+ /* end of TC */
+ recorder_destroy(recorder);
+}
+
+static void utc_media_recorder_attr_get_audio_device_p(void)
+{
+ int ret;
+ recorder_audio_device_e device;
+ ret = recorder_attr_get_audio_device(recorder, &device);
+ dts_check_eq("utc_media_recorder_attr_get_audio_device_p", ret , RECORDER_ERROR_NONE , "error get audio device");
+}
+
+static void utc_media_recorder_attr_get_audio_device_n(void)
+{
+ tet_printf("utc_recorder_attr_get_audio_device_negative\n");
+
+ int ret;
+ ret = recorder_attr_get_audio_device (recorder, NULL);
+ dts_check_ne("utc_media_recorder_attr_get_audio_device_n", ret, RECORDER_ERROR_NONE,"recorder_attr_set_audio_device get by NULL should be fail");
+}
+
+static void utc_media_recorder_attr_get_audio_encoder_bitrate_p(void)
+{
+ int ret;
+ int bitrate;
+ ret = recorder_attr_get_audio_encoder_bitrate(recorder, &bitrate);
+ dts_check_eq(__func__, ret , RECORDER_ERROR_NONE, "fail audio encoder bitrate get");
+}
+
+static void utc_media_recorder_attr_get_audio_encoder_bitrate_n(void)
+{
+ int ret;
+ ret = recorder_attr_get_audio_encoder_bitrate(recorder, NULL);
+ dts_check_ne(__func__, ret , RECORDER_ERROR_NONE, "out parameter must not be null");
+}
+
+static void utc_media_recorder_attr_get_audio_samplerate_p(void)
+{
+ int ret;
+ int samplerate;
+ ret = recorder_attr_get_audio_samplerate(recorder, &samplerate);
+ dts_check_eq(__func__ , ret , RECORDER_ERROR_NONE , "error get audio samplerate");
+
+}
+
+static void utc_media_recorder_attr_get_audio_samplerate_n(void)
+{
+ int ret;
+ ret = recorder_attr_get_audio_samplerate(recorder, NULL);
+ dts_check_ne(__func__, ret , RECORDER_ERROR_NONE, "out parameter must not be null");
+}
+
+
+static void utc_media_recorder_attr_get_size_limit_p(void)
+{
+ int ret;
+ int size;
+ ret = recorder_attr_get_size_limit(recorder, &size);
+ dts_check_eq(__func__ , ret , RECORDER_ERROR_NONE, "error get limit size");
+}
+
+static void utc_media_recorder_attr_get_size_limit_n(void)
+{
+ int ret;
+ ret = recorder_attr_get_size_limit(recorder, NULL);
+ dts_check_ne(__func__, ret , RECORDER_ERROR_NONE, "out parameter must not be null");
+}
+
+static void utc_media_recorder_attr_get_time_limit_p(void)
+{
+ int ret;
+ int value;
+ ret = recorder_attr_get_time_limit(recorder, &value);
+ dts_check_eq(__func__ , ret , RECORDER_ERROR_NONE, "error get limit time");
+
+}
+
+static void utc_media_recorder_attr_get_time_limit_n(void)
+{
+ int ret;
+ ret = recorder_attr_get_time_limit(recorder, NULL);
+ dts_check_ne(__func__, ret , RECORDER_ERROR_NONE, "out parameter must not be null");
+
+}
+
+static void utc_media_recorder_attr_get_video_encoder_bitrate_p(void)
+{
+ int ret;
+ int value;
+ ret = recorder_attr_get_video_encoder_bitrate(recorder, &value);
+ dts_check_eq(__func__ , ret , RECORDER_ERROR_NONE, "error get video encoder bitrate");
+}
+
+static void utc_media_recorder_attr_get_video_encoder_bitrate_n(void)
+{
+ int ret;
+ ret = recorder_attr_get_video_encoder_bitrate(recorder, NULL);
+ dts_check_ne(__func__, ret , RECORDER_ERROR_NONE, "out parameter must not be null");
+}
+
+static void utc_media_recorder_attr_set_audio_device_p(void)
+{
+ int ret;
+ ret = recorder_attr_set_audio_device(recorder, 1);
+ dts_check_eq(__func__ , ret , RECORDER_ERROR_NONE, "error set audio device");
+
+}
+
+static void utc_media_recorder_attr_set_audio_device_n(void)
+{
+ int ret;
+ ret = recorder_attr_set_audio_device(recorder, 10);
+ dts_check_ne(__func__, ret , RECORDER_ERROR_NONE, "out of bound error is must occured");
+}
+
+static void utc_media_recorder_attr_set_audio_encoder_bitrate_p(void)
+{
+ int ret;
+ ret = recorder_attr_set_audio_encoder_bitrate(recorder, 11111);
+ dts_check_eq(__func__ , ret , RECORDER_ERROR_NONE , "can be set 11111");
+}
+
+static void utc_media_recorder_attr_set_audio_encoder_bitrate_n(void)
+{
+ int ret;
+ ret = recorder_attr_set_audio_encoder_bitrate(recorder, -1);
+ dts_check_ne(__func__, ret , RECORDER_ERROR_NONE, "-1 is not allowed");
+
+}
+
+static void utc_media_recorder_attr_set_audio_samplerate_p(void)
+{
+ int ret;
+ ret = recorder_attr_set_audio_samplerate(recorder, 11111);
+ dts_check_eq(__func__ , ret , RECORDER_ERROR_NONE, "11111 is allow");
+
+}
+
+static void utc_media_recorder_attr_set_audio_samplerate_n(void)
+{
+ int ret;
+ ret = recorder_attr_set_audio_samplerate(recorder, -1);
+ dts_check_ne(__func__, ret , RECORDER_ERROR_NONE, "-1 is not allowed");
+}
+
+static void utc_media_recorder_attr_set_size_limit_p(void)
+{
+ int ret;
+ ret = recorder_attr_set_size_limit(recorder, 0);
+ dts_check_eq(__func__ , ret , RECORDER_ERROR_NONE , "can be set 0");
+}
+
+static void utc_media_recorder_attr_set_size_limit_n(void)
+{
+ int ret;
+ ret = recorder_attr_set_size_limit(recorder, -1);
+ dts_check_ne(__func__, ret , RECORDER_ERROR_NONE, "-1 is not allowed");
+}
+
+static void utc_media_recorder_attr_set_time_limit_p(void)
+{
+ int ret;
+ ret = recorder_attr_set_time_limit(recorder, 11111);
+ dts_check_eq(__func__ , ret , RECORDER_ERROR_NONE, "11111 is allow");
+
+}
+
+static void utc_media_recorder_attr_set_time_limit_n(void)
+{
+ int ret;
+ ret = recorder_attr_set_time_limit(recorder, -1);
+ dts_check_ne(__func__, ret , RECORDER_ERROR_NONE, "-1 is not allowed");
+
+}
+
+static void utc_media_recorder_attr_set_video_encoder_bitrate_p(void)
+{
+ int ret;
+ ret = recorder_attr_set_video_encoder_bitrate(recorder, 0);
+ dts_check_eq(__func__ , ret , RECORDER_ERROR_NONE , "can be set 0");
+}
+
+static void utc_media_recorder_attr_set_video_encoder_bitrate_n(void)
+{
+ int ret;
+ ret = recorder_attr_set_video_encoder_bitrate(recorder, -1);
+ dts_check_ne(__func__, ret , RECORDER_ERROR_NONE, "-1 is not allowed");
+
+}
+
+static void utc_media_recorder_get_audio_encoder_p(void)
+{
+ int ret;
+ recorder_audio_codec_e value;
+ ret = recorder_get_audio_encoder(recorder,&value);
+ dts_check_eq(__func__, ret , RECORDER_ERROR_NONE, "error");
+}
+
+static void utc_media_recorder_get_audio_encoder_n(void)
+{
+ int ret;
+ ret = recorder_get_audio_encoder(recorder,NULL);
+ dts_check_ne(__func__, ret , RECORDER_ERROR_NONE, "out parameter must not be null");
+}
+
+static void utc_media_recorder_get_file_format_p(void)
+{
+ int ret;
+ recorder_file_format_e value;
+ ret = recorder_get_file_format(recorder,&value);
+ dts_check_eq(__func__, ret , RECORDER_ERROR_NONE, "error");
+}
+
+static void utc_media_recorder_get_file_format_n(void)
+{
+ int ret;
+ ret = recorder_get_file_format(recorder,NULL);
+ dts_check_ne(__func__, ret , RECORDER_ERROR_NONE, "out parameter must not be null");
+
+}
+
+static void utc_media_recorder_get_video_encoder_p(void)
+{
+ int ret;
+ recorder_video_codec_e value;
+ ret = recorder_get_video_encoder(recorder,&value);
+ dts_check_eq(__func__, ret , RECORDER_ERROR_NONE, "error");
+}
+
+static void utc_media_recorder_get_video_encoder_n(void)
+{
+ int ret;
+ ret = recorder_get_video_encoder(recorder,NULL);
+ dts_check_ne(__func__, ret , RECORDER_ERROR_NONE, "out parameter must not be null");
+}
+
+static void utc_media_recorder_set_audio_encoder_p(void)
+{
+ int ret;
+ ret = recorder_set_audio_encoder(recorder, -1);
+ dts_check_ne(__func__, ret , RECORDER_ERROR_NONE, "-1 is not allowed");
+}
+
+static void utc_media_recorder_set_audio_encoder_n(void)
+{
+ int ret;
+ ret = recorder_set_audio_encoder(recorder, 0);
+ dts_check_eq(__func__ , ret , RECORDER_ERROR_NONE, "0 is allow");
+}
+
+static void utc_media_recorder_set_file_format_p(void)
+{
+ int ret;
+ ret = recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_3GP);
+ dts_check_eq(__func__, ret , RECORDER_ERROR_NONE, "RECORDER_FILE_FORMAT_3GP is not supported");
+}
+
+static void utc_media_recorder_set_file_format_n(void)
+{
+ int ret;
+ ret = recorder_set_file_format(recorder, -1);
+ dts_check_ne(__func__, ret , RECORDER_ERROR_NONE, "RECORDER_FILE_FORMAT_INVALID is not allowed");
+}
+
+static void utc_media_recorder_set_filename_p(void)
+{
+ int ret;
+ char *filename;
+ ret = recorder_set_filename(recorder, "/mnt/nfs/test.test");
+ MY_ASSERT(__func__, ret == 0 , "Fail recorder_set_filename");
+ ret = recorder_get_filename(recorder, &filename);
+ free(filename);
+ MY_ASSERT(__func__, ret == 0 , "Fail recorder_get_filename");
+ dts_pass(__func__, "PASS");
+}
+
+static void utc_media_recorder_set_filename_n(void)
+{
+ int ret;
+ ret = recorder_set_filename(recorder, NULL);
+ dts_check_ne(__func__, ret , RECORDER_ERROR_NONE, "NULL is not allowed");
+}
+
+static void utc_media_recorder_set_video_encoder_p(void)
+{
+ int ret;
+ ret = recorder_set_video_encoder(recorder, RECORDER_VIDEO_CODEC_MPEG4);
+ dts_check_eq(__func__, ret , RECORDER_ERROR_NONE, "RECORDER_VIDEO_CODEC_MPEG4 is not supported");
+}
+
+static void utc_media_recorder_set_video_encoder_n(void)
+{
+ int ret;
+ ret = recorder_set_video_encoder(recorder, -1);
+ dts_check_ne(__func__, ret , RECORDER_ERROR_NONE, "-1 is not allowed");
+}
+
--- /dev/null
+/*
+* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+
+
+#include <tet_api.h>
+#include <media/recorder.h>
+
+static void startup(void);
+static void cleanup(void);
+
+void (*tet_startup)(void) = startup;
+void (*tet_cleanup)(void) = cleanup;
+
+
+static void utc_media_recorder_foreach_supported_audio_encoder_p(void);
+static void utc_media_recorder_foreach_supported_audio_encoder_n(void);
+static void utc_media_recorder_foreach_supported_file_format_p(void);
+static void utc_media_recorder_foreach_supported_file_format_n(void);
+static void utc_media_recorder_foreach_supported_video_encoder_p(void);
+static void utc_media_recorder_foreach_supported_video_encoder_n(void);
+static void utc_media_recorder_set_recording_limit_reached_cb_p(void);
+static void utc_media_recorder_set_recording_limit_reached_cb_n(void);
+static void utc_media_recorder_set_recording_status_cb_p(void);
+static void utc_media_recorder_set_recording_status_cb_n(void);
+static void utc_media_recorder_set_state_changed_cb_p(void);
+static void utc_media_recorder_set_state_changed_cb_n(void);
+static void utc_media_recorder_unset_recording_limit_reached_cb_p(void);
+static void utc_media_recorder_unset_recording_limit_reached_cb_n(void);
+static void utc_media_recorder_unset_recording_status_cb_p(void);
+static void utc_media_recorder_unset_recording_status_cb_n(void);
+static void utc_media_recorder_unset_state_changed_cb_p(void);
+static void utc_media_recorder_unset_state_changed_cb_n(void);
+
+
+struct tet_testlist tet_testlist[] = {
+ { utc_media_recorder_foreach_supported_audio_encoder_p , 1 },
+ { utc_media_recorder_foreach_supported_audio_encoder_n , 2 },
+ { utc_media_recorder_foreach_supported_file_format_p , 1 },
+ { utc_media_recorder_foreach_supported_file_format_n , 2 },
+ { utc_media_recorder_foreach_supported_video_encoder_p , 1 },
+ { utc_media_recorder_foreach_supported_video_encoder_n , 2 },
+ { utc_media_recorder_set_recording_limit_reached_cb_p , 1 },
+ { utc_media_recorder_set_recording_limit_reached_cb_n , 2 },
+ { utc_media_recorder_set_recording_status_cb_p , 1 },
+ { utc_media_recorder_set_recording_status_cb_n , 2 },
+ { utc_media_recorder_set_state_changed_cb_p , 1 },
+ { utc_media_recorder_set_state_changed_cb_n , 2 },
+ { utc_media_recorder_unset_recording_limit_reached_cb_p , 1 },
+ { utc_media_recorder_unset_recording_limit_reached_cb_n , 2 },
+ { utc_media_recorder_unset_recording_status_cb_p , 1 },
+ { utc_media_recorder_unset_recording_status_cb_n , 2 },
+ { utc_media_recorder_unset_state_changed_cb_p , 1 },
+ { utc_media_recorder_unset_state_changed_cb_n , 2 },
+ { NULL, 0 },
+};
+
+recorder_h recorder;
+
+static void startup(void)
+{
+ /* start of TC */
+ int ret;
+ ret = recorder_create_audiorecorder(&recorder);
+ if( ret != 0 )
+ dts_fail("recorder_create_audiorecorder", "Could not create audio recorder");
+}
+
+static void cleanup(void)
+{
+ /* end of TC */
+ recorder_destroy(recorder);
+}
+
+bool _audio_encoder_cb(recorder_audio_codec_e codec , void *user_data){
+ return false;
+}
+
+bool _file_format_cb(recorder_file_format_e format , void *user_data){
+ return false;
+}
+
+bool _video_encoder_cb(recorder_video_codec_e codec , void *user_data){
+ return false;
+}
+
+void _limit_reached_cb(recorder_recording_limit_type_e type, void *user_data){
+}
+
+void _recording_statis_cb(int elapsed_time, int file_size, void *user_data){
+}
+
+void _state_changed_cb(recorder_state_e previous , recorder_state_e current , bool by_asm, void *user_data)
+{
+}
+
+
+static void utc_media_recorder_foreach_supported_audio_encoder_p(void)
+{
+ int ret;
+ ret = recorder_foreach_supported_audio_encoder(recorder, _audio_encoder_cb, NULL);
+ dts_check_eq(__func__, ret, RECORDER_ERROR_NONE, "error");
+}
+
+static void utc_media_recorder_foreach_supported_audio_encoder_n(void)
+{
+ int ret;
+ ret = recorder_foreach_supported_audio_encoder(recorder, NULL, NULL);
+ dts_check_ne(__func__, ret, RECORDER_ERROR_NONE, "not allow NULL");
+}
+
+static void utc_media_recorder_foreach_supported_file_format_p(void)
+{
+ int ret;
+ ret = recorder_foreach_supported_file_format(recorder, _file_format_cb, NULL);
+ dts_check_eq(__func__, ret, RECORDER_ERROR_NONE, "error");
+}
+
+static void utc_media_recorder_foreach_supported_file_format_n(void)
+{
+ int ret;
+ ret = recorder_foreach_supported_file_format(recorder, NULL, NULL);
+ dts_check_ne(__func__, ret, RECORDER_ERROR_NONE, "not allow NULL");
+}
+
+static void utc_media_recorder_foreach_supported_video_encoder_p(void)
+{
+ int ret;
+ ret = recorder_foreach_supported_video_encoder(recorder, _video_encoder_cb, NULL);
+ dts_check_eq(__func__, ret, RECORDER_ERROR_NONE, "error");
+}
+
+static void utc_media_recorder_foreach_supported_video_encoder_n(void)
+{
+ int ret;
+ ret = recorder_foreach_supported_video_encoder(recorder, NULL, NULL);
+ dts_check_ne(__func__, ret, RECORDER_ERROR_NONE, "not allow NULL");
+}
+
+static void utc_media_recorder_set_recording_limit_reached_cb_p(void)
+{
+ int ret;
+ ret = recorder_set_recording_limit_reached_cb(recorder, _limit_reached_cb, NULL);
+ dts_check_eq(__func__, ret , RECORDER_ERROR_NONE, "fail recording limited reached cb set");
+}
+
+static void utc_media_recorder_set_recording_limit_reached_cb_n(void)
+{
+ int ret;
+ ret = recorder_set_recording_limit_reached_cb(recorder, NULL, NULL);
+ dts_check_ne(__func__, ret , RECORDER_ERROR_NONE, "NULL is not allowed");
+
+}
+
+static void utc_media_recorder_set_recording_status_cb_p(void)
+{
+ int ret;
+ ret = recorder_set_recording_status_cb(recorder, _recording_statis_cb, NULL);
+ dts_check_eq(__func__, ret , RECORDER_ERROR_NONE, "error");
+}
+
+static void utc_media_recorder_set_recording_status_cb_n(void)
+{
+ int ret;
+ ret = recorder_set_recording_status_cb(recorder, NULL, NULL);
+ dts_check_ne(__func__, ret , RECORDER_ERROR_NONE, "NULL is not allowed");
+}
+
+static void utc_media_recorder_set_state_changed_cb_p(void)
+{
+ int ret;
+ ret = recorder_set_state_changed_cb(recorder, _state_changed_cb, NULL);
+ dts_check_eq(__func__, ret , RECORDER_ERROR_NONE, "error");
+}
+
+static void utc_media_recorder_set_state_changed_cb_n(void)
+{
+ int ret;
+ ret = recorder_set_state_changed_cb(recorder, NULL, NULL);
+ dts_check_ne(__func__, ret , RECORDER_ERROR_NONE, "NULL is not allowed");
+
+}
+
+static void utc_media_recorder_unset_recording_limit_reached_cb_p(void)
+{
+ int ret;
+ ret = recorder_unset_recording_limit_reached_cb(recorder);
+ dts_check_eq(__func__, ret , RECORDER_ERROR_NONE, "fail unset limited callback");
+}
+
+static void utc_media_recorder_unset_recording_limit_reached_cb_n(void)
+{
+ int ret;
+ ret = recorder_unset_recording_limit_reached_cb(NULL);
+ dts_check_ne(__func__, ret , RECORDER_ERROR_NONE, "NULL is not allowed");
+}
+
+static void utc_media_recorder_unset_recording_status_cb_p(void)
+{
+ int ret;
+ ret = recorder_unset_recording_status_cb(recorder);
+ dts_check_eq(__func__, ret , RECORDER_ERROR_NONE, "fail unset limited callback");
+}
+
+static void utc_media_recorder_unset_recording_status_cb_n(void)
+{
+ int ret;
+ ret = recorder_unset_recording_status_cb(NULL);
+ dts_check_ne(__func__, ret , RECORDER_ERROR_NONE, "NULL is not allowed");
+
+}
+
+static void utc_media_recorder_unset_state_changed_cb_p(void)
+{
+ int ret;
+ ret = recorder_unset_state_changed_cb(recorder);
+ dts_check_eq(__func__, ret , RECORDER_ERROR_NONE, "fail unset limited callback");
+}
+
+static void utc_media_recorder_unset_state_changed_cb_n(void)
+{
+ int ret;
+ ret = recorder_unset_state_changed_cb(NULL);
+ dts_check_ne(__func__, ret , RECORDER_ERROR_NONE, "NULL is not allowed");
+}
--- /dev/null
+/*
+* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+
+
+#include <tet_api.h>
+#include <media/recorder.h>
+
+static void startup(void);
+static void cleanup(void);
+
+void (*tet_startup)(void) = startup;
+void (*tet_cleanup)(void) = cleanup;
+
+static void utc_media_recorder_create_audiorecorder_p(void);
+static void utc_media_recorder_create_audiorecorder_n(void);
+static void utc_media_recorder_cancel_p(void);
+static void utc_media_recorder_cancel_n(void);
+static void utc_media_recorder_commit_p(void);
+static void utc_media_recorder_commit_n(void);
+static void utc_media_recorder_create_videorecorder_p(void);
+static void utc_media_recorder_create_videorecorder_n(void);
+static void utc_media_recorder_destroy_p(void);
+static void utc_media_recorder_destroy_n(void);
+static void utc_media_recorder_pause_p(void);
+static void utc_media_recorder_pause_n(void);
+static void utc_media_recorder_ready_p(void);
+static void utc_media_recorder_ready_n(void);
+static void utc_media_recorder_start_p(void);
+static void utc_media_recorder_start_n(void);
+static void utc_media_recorder_unready_p(void);
+static void utc_media_recorder_unready_n(void);
+
+
+struct tet_testlist tet_testlist[] = {
+ { utc_media_recorder_create_audiorecorder_p, 1 },
+ { utc_media_recorder_create_audiorecorder_n, 2 },
+ { utc_media_recorder_cancel_p , 1 },
+ { utc_media_recorder_cancel_n , 2 },
+ { utc_media_recorder_commit_p , 1 },
+ { utc_media_recorder_commit_n , 2 },
+ { utc_media_recorder_create_videorecorder_p , 1 },
+ { utc_media_recorder_create_videorecorder_n , 2 },
+ { utc_media_recorder_destroy_p , 1 },
+ { utc_media_recorder_destroy_n , 2 },
+ { utc_media_recorder_pause_p , 1 },
+ { utc_media_recorder_pause_n , 2 },
+ { utc_media_recorder_ready_p , 1 },
+ { utc_media_recorder_ready_n , 2 },
+ { utc_media_recorder_start_p , 1 },
+ { utc_media_recorder_start_n , 2 },
+ { utc_media_recorder_unready_p , 1 },
+ { utc_media_recorder_unready_n , 2 },
+ { NULL, 0 },
+};
+
+static void startup(void)
+{
+ /* start of TC */
+}
+
+static void cleanup(void)
+{
+ /* end of TC */
+}
+
+/**
+ * @brief Negative test case of recorder_create_audiorecorder()
+ */
+static void utc_media_recorder_create_audiorecorder_n(void)
+{
+ int ret;
+ ret = recorder_create_audiorecorder(NULL);
+ dts_check_ne(__func__, ret, RECORDER_ERROR_NONE, "not allow NULL");
+
+}
+
+static void utc_media_recorder_create_audiorecorder_p(void)
+{
+ int ret;
+ recorder_h recorder;
+ ret = recorder_create_audiorecorder(&recorder);
+ dts_check_eq(__func__, ret, RECORDER_ERROR_NONE, "create_audiorecorder is faild");
+ recorder_destroy(recorder);
+}
+
+
+static void utc_media_recorder_cancel_p(void)
+{
+ int ret;
+ recorder_h recorder;
+ ret = recorder_create_audiorecorder(&recorder);
+ ret |= recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AMR);
+ ret |= recorder_set_file_format(recorder,RECORDER_FILE_FORMAT_AMR);
+ ret |= recorder_prepare(recorder);
+ ret |= recorder_start(recorder);
+ dts_check_eq(__func__ , ret , RECORDER_ERROR_NONE , "recorder prepare is faild");
+ sleep(2);
+ ret = recorder_cancel(recorder);
+ dts_check_eq(__func__, ret, RECORDER_ERROR_NONE, "record commit is fail");
+ recorder_unprepare(recorder);
+ recorder_destroy(recorder);
+}
+
+static void utc_media_recorder_cancel_n(void)
+{
+ int ret;
+ recorder_h recorder;
+ ret = recorder_create_audiorecorder(&recorder);
+ ret |= recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AMR);
+ ret |= recorder_set_file_format(recorder,RECORDER_FILE_FORMAT_AMR);
+ ret |= recorder_prepare(recorder);
+ dts_check_eq(__func__ , ret , RECORDER_ERROR_NONE , "recorder prepare is faild");
+ ret = recorder_cancel(recorder);
+ dts_check_ne(__func__, ret, RECORDER_ERROR_NONE, "invalid state");
+ recorder_unprepare(recorder);
+ recorder_destroy(recorder);
+}
+
+
+static void utc_media_recorder_commit_p(void)
+{
+ int ret;
+ recorder_h recorder;
+ ret = recorder_create_audiorecorder(&recorder);
+ ret |= recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AMR);
+ ret |= recorder_set_file_format(recorder,RECORDER_FILE_FORMAT_AMR);
+ ret |= recorder_prepare(recorder);
+ ret |= recorder_start(recorder);
+ dts_check_eq(__func__ , ret , RECORDER_ERROR_NONE , "recorder prepare is faild");
+ sleep(2);
+ ret = recorder_commit(recorder);
+ dts_check_eq(__func__, ret, RECORDER_ERROR_NONE, "record commit is fail");
+ recorder_unprepare(recorder);
+ recorder_destroy(recorder);
+}
+
+static void utc_media_recorder_commit_n(void)
+{
+ int ret;
+ recorder_h recorder;
+ ret =recorder_create_audiorecorder(&recorder);
+ ret |= recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AMR);
+ ret |= recorder_set_file_format(recorder,RECORDER_FILE_FORMAT_AMR);
+ ret |= recorder_prepare(recorder);
+ dts_check_eq(__func__ , ret , RECORDER_ERROR_NONE , "recorder prepare is faild");
+ ret = recorder_commit(recorder);
+ dts_check_ne(__func__, ret, RECORDER_ERROR_NONE, "invalid state");
+ recorder_unprepare(recorder);
+ recorder_destroy(recorder);
+}
+
+static void utc_media_recorder_create_videorecorder_p(void)
+{
+ recorder_h recorder;
+ camera_h camera;
+ int ret;
+ ret = camera_create(CAMERA_DEVICE_CAMERA0, &camera);
+ dts_check_eq(__func__, ret, CAMERA_ERROR_NONE, "create camera is faild");
+
+ ret = recorder_create_videorecorder(camera, &recorder);
+ dts_check_eq(__func__, ret, RECORDER_ERROR_NONE, "create recorder is faild");
+ recorder_destroy(recorder);
+ camera_destroy(camera);
+}
+
+static void utc_media_recorder_create_videorecorder_n(void)
+{
+ recorder_h recorder;
+ int ret;
+ ret = recorder_create_videorecorder(NULL, &recorder);
+ dts_check_ne(__func__, ret, RECORDER_ERROR_NONE, "not allow NULL");
+}
+
+static void utc_media_recorder_destroy_p(void)
+{
+ recorder_h recorder;
+ int ret;
+ ret = recorder_create_audiorecorder(&recorder);
+ dts_check_eq(__func__, ret, RECORDER_ERROR_NONE, "create recorder is faild");
+ ret = recorder_destroy(recorder);
+ dts_check_eq(__func__, ret, RECORDER_ERROR_NONE, "recorder_destroy is faild");
+}
+
+static void utc_media_recorder_destroy_n(void)
+{
+ int ret;
+ ret = recorder_destroy(NULL);
+ dts_check_ne(__func__, ret, RECORDER_ERROR_NONE, "not allow NULL");
+}
+
+static void utc_media_recorder_pause_p(void)
+{
+ int ret;
+ recorder_h recorder;
+ ret = recorder_create_audiorecorder(&recorder);
+ ret |= recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AMR);
+ ret |= recorder_set_file_format(recorder,RECORDER_FILE_FORMAT_AMR);
+ ret |= recorder_prepare(recorder);
+ ret |= recorder_start(recorder);
+ dts_check_eq(__func__ , ret , RECORDER_ERROR_NONE , "recorder prepare is faild");
+ sleep(2);
+ ret = recorder_pause(recorder);
+ dts_check_eq(__func__, ret, RECORDER_ERROR_NONE, "record commit is fail");
+ recorder_cancel(recorder);
+ recorder_unprepare(recorder);
+ recorder_destroy(recorder);
+
+}
+
+static void utc_media_recorder_pause_n(void)
+{
+ int ret;
+ recorder_h recorder;
+ ret = recorder_create_audiorecorder(&recorder);
+ ret |= recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AMR);
+ ret |= recorder_set_file_format(recorder,RECORDER_FILE_FORMAT_AMR);
+ ret |= recorder_prepare(recorder);
+ dts_check_eq(__func__ , ret , RECORDER_ERROR_NONE , "recorder prepare is faild");
+ ret = recorder_pause(recorder);
+ dts_check_ne(__func__, ret, RECORDER_ERROR_NONE, "invalid state");
+ recorder_unprepare(recorder);
+ recorder_destroy(recorder);
+}
+
+static void utc_media_recorder_ready_p(void)
+{
+ int ret;
+ recorder_h recorder;
+ ret = recorder_create_audiorecorder(&recorder);
+ ret |= recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AMR);
+ ret |= recorder_set_file_format(recorder,RECORDER_FILE_FORMAT_AMR);
+ dts_check_eq(__func__ , ret , RECORDER_ERROR_NONE , "recorder prepare is faild");
+ ret = recorder_prepare(recorder);
+ dts_check_eq(__func__, ret, RECORDER_ERROR_NONE, "invalid state");
+ recorder_unprepare(recorder);
+ recorder_destroy(recorder);
+}
+
+static void utc_media_recorder_ready_n(void)
+{
+ int ret;
+ recorder_h recorder;
+ ret = recorder_create_audiorecorder(&recorder);
+ ret |= recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AMR);
+ ret |= recorder_set_file_format(recorder,RECORDER_FILE_FORMAT_AMR);
+ ret |= recorder_prepare(recorder);
+ dts_check_eq(__func__ , ret , RECORDER_ERROR_NONE , "recorder prepare is faild");
+ ret = recorder_prepare(recorder);
+ dts_check_eq(__func__, ret, RECORDER_ERROR_NONE, "invalid state");
+ recorder_unprepare(recorder);
+ recorder_destroy(recorder);
+}
+
+static void utc_media_recorder_start_p(void)
+{
+ int ret;
+ recorder_h recorder;
+ ret = recorder_create_audiorecorder(&recorder);
+ ret |= recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AMR);
+ ret |= recorder_set_file_format(recorder,RECORDER_FILE_FORMAT_AMR);
+ ret |= recorder_prepare(recorder);
+ dts_check_eq(__func__, ret , RECORDER_ERROR_NONE, "recorder create fail");
+ ret = recorder_start(recorder);
+ dts_check_eq(__func__, ret , RECORDER_ERROR_NONE, "recorder start record fail");
+ recorder_cancel(recorder);
+ recorder_unprepare(recorder);
+ recorder_destroy(recorder);
+}
+
+static void utc_media_recorder_start_n(void)
+{
+ int ret;
+ recorder_h recorder;
+ ret = recorder_create_audiorecorder(&recorder);
+ dts_check_eq(__func__, ret , RECORDER_ERROR_NONE, "recorder create fail");
+
+ ret = recorder_start(recorder);
+ dts_check_ne(__func__, ret , RECORDER_ERROR_NONE, "expect invalid state");
+ recorder_destroy(recorder);
+}
+
+static void utc_media_recorder_unready_p(void)
+{
+ int ret;
+ recorder_h recorder;
+ ret = recorder_create_audiorecorder(&recorder);
+ ret |= recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AMR);
+ ret |= recorder_set_file_format(recorder,RECORDER_FILE_FORMAT_AMR);
+ ret |= recorder_prepare(recorder);
+ dts_check_eq(__func__, ret , RECORDER_ERROR_NONE, "recorder create fail");
+ ret = recorder_unprepare(recorder);
+ dts_check_eq(__func__, ret , RECORDER_ERROR_NONE, "recorder unready fail");
+ recorder_destroy(recorder);
+}
+
+static void utc_media_recorder_unready_n(void)
+{
+ int ret;
+ recorder_h recorder;
+ ret = recorder_create_audiorecorder(&recorder);
+ dts_check_eq(__func__, ret , RECORDER_ERROR_NONE, "recorder create fail");
+
+ ret = recorder_unprepare(recorder);
+ dts_check_ne(__func__, ret , RECORDER_ERROR_NONE, "expect invalid state");
+ recorder_destroy(recorder);
+}
+
+
+
--- /dev/null
+/*
+* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+
+
+
+#include <tet_api.h>
+#include <media/camera.h>
+#include <stdio.h>
+#include <glib.h>
+#include <media/recorder.h>
+
+#define MY_ASSERT( fun , test , msg ) \
+{\
+ if( !test ) \
+ dts_fail(fun , msg ); \
+}
+
+static GMainLoop *g_mainloop = NULL;
+static GThread *event_thread;
+int preview_win = 0;
+
+
+static void utc_media_recorder_attribute_test(void);
+static void utc_media_recorder_state_change_test(void);
+static void utc_media_recorder_recoding_status_cb_test(void);
+static void utc_media_recorder_limit_cb_test(void);
+
+
+static void startup(void);
+static void cleanup(void);
+
+void (*tet_startup)(void) = startup;
+void (*tet_cleanup)(void) = cleanup;
+
+
+struct tet_testlist tet_testlist[] = {
+ { utc_media_recorder_attribute_test, 1 },
+ { utc_media_recorder_state_change_test , 2 },
+ { utc_media_recorder_recoding_status_cb_test , 3 },
+ { utc_media_recorder_limit_cb_test , 4 },
+ { NULL, 0 },
+};
+
+
+gpointer GmainThread(gpointer data){
+ g_mainloop = g_main_loop_new (NULL, 0);
+ g_main_loop_run (g_mainloop);
+
+ return NULL;
+}
+
+
+static void startup(void)
+{
+ if( !g_thread_supported() )
+ {
+ g_thread_init(NULL);
+ }
+
+ GError *gerr = NULL;
+ event_thread = g_thread_create(GmainThread, NULL, 1, &gerr);
+}
+
+static void cleanup(void)
+{
+ g_main_loop_quit (g_mainloop);
+ g_thread_join(event_thread);
+}
+
+
+
+
+void record_state_cb(recorder_state_e previous , recorder_state_e current , int by_asm, void *user_data){
+ char * state_table[] = {
+ "MEDIARECORDER_STATE_NONE", /**< recorder is not created yet */
+ "MEDIARECORDER_STATE_CREATED", /**< recorder is created, but not initialized yet */
+ "MEDIARECORDER_STATE_READY", /**< ready to record if video recorder is playing preview */
+ "MEDIARECORDER_STATE_RECORDING", /**< While recording */
+ "MEDIARECORDER_STATE_PAUSED", /**< Pause recording */
+ "MEDIARECORDER_STATE_NUM" /**< Number of recorder states */
+ };
+ printf("%s\n", state_table[current]);
+}
+
+int recording_limit_size_test(recorder_h recorder){
+ int ret;
+ int fail=0;
+ int int_value;
+ // negative test
+ printf("-------------limit size test----------------------\n");
+ printf("-nagative test\n");
+ ret = recorder_attr_set_size_limit(recorder, -1);
+ if( ret == 0 ){
+ printf("FAIL\n");
+ fail++;
+ }else
+ printf("PASS\n");
+
+ printf("-0 test\n");
+ ret = recorder_attr_set_size_limit(recorder, 0);
+ if( ret != 0 ){
+ printf("FAIL\n");
+ fail++;
+ }else
+ printf("PASS\n");
+
+ ret = recorder_attr_get_size_limit(recorder,&int_value);
+ if( int_value != 0){
+ printf("FAIL\n");
+ fail++;
+ }else
+ printf("PASS\n");
+
+
+ printf("-1212 set test\n");
+ ret = recorder_attr_set_size_limit(recorder, 1212);
+ if( ret != 0 ){
+ printf("FAIL\n");
+ fail++;
+ }else
+ printf("PASS\n");
+
+ ret = recorder_attr_get_size_limit(recorder,&int_value);
+ if( int_value != 1212){
+ printf("FAIL\n");
+ fail++;
+ }else
+ printf("PASS\n");
+
+ return -fail;
+}
+
+int recording_time_limit_test(recorder_h recorder){
+ int ret;
+ int fail=0;
+ int int_value;
+ // negative test
+ printf("-------------limit time test----------------------\n");
+
+ ret = recorder_attr_set_time_limit(recorder, -1);
+ if( ret == 0 ){
+ printf("FAIL\n");
+ fail++;
+ }else
+ printf("PASS\n");
+
+ printf("-0 test\n");
+ ret = recorder_attr_set_time_limit(recorder, 0);
+ if( ret != 0 ){
+ printf("FAIL\n");
+ fail++;
+ }else
+ printf("PASS\n");
+
+ ret = recorder_attr_get_time_limit(recorder,&int_value);
+ if( int_value != 0){
+ printf("FAIL\n");
+ fail++;
+ }else
+ printf("PASS\n");
+
+
+ printf("-1212 set test\n");
+ ret = recorder_attr_set_time_limit(recorder, 1212);
+ if( ret != 0 ){
+ printf("FAIL\n");
+ fail++;
+ }else
+ printf("PASS\n");
+
+ ret = recorder_attr_get_time_limit(recorder,&int_value);
+ if( int_value != 1212){
+ printf("FAIL\n");
+ fail++;
+ }else
+ printf("PASS\n");
+
+
+ return -fail;
+}
+
+int fileformat_test_fail = 0;
+bool _file_format_test_cb(recorder_file_format_e format, void *user_data){
+ int ret;
+ recorder_h recorder = (recorder_h)user_data;
+ recorder_file_format_e get_format;
+ ret = recorder_set_file_format(recorder, format);
+ recorder_get_file_format(recorder, &get_format);
+
+ if( get_format != format){
+ printf("FAIL\n");
+ fileformat_test_fail++;
+ }else
+ printf("PASS\n");
+ return true;
+}
+
+
+int fileformat_test(recorder_h recorder){
+ fileformat_test_fail = 0;
+ printf("----------------file format test ------------------\n");
+ recorder_foreach_supported_file_format(recorder, _file_format_test_cb, recorder);
+ return -fileformat_test_fail;
+}
+
+int videoencoder_test_fail = 0;
+bool _video_encoder_test_cb(recorder_video_codec_e codec, void *user_data){
+ int ret;
+ recorder_h recorder = (recorder_h)user_data;
+ recorder_video_codec_e get_codec;
+ ret = recorder_set_video_encoder(recorder, codec);
+ recorder_get_video_encoder(recorder, &get_codec);
+
+
+ if( get_codec != codec){
+ printf("FAIL\n");
+ videoencoder_test_fail++;
+ }else
+ printf("PASS\n");
+ return true;
+}
+
+
+int video_encoder_test(recorder_h recorder){
+ videoencoder_test_fail = 0;
+ printf("----------------video encorder test ------------------\n");
+ recorder_foreach_supported_video_encoder(recorder, _video_encoder_test_cb, recorder);
+ return -videoencoder_test_fail;
+}
+
+int audioencoder_test_fail = 0;
+bool _audio_encoder_test_cb(recorder_audio_codec_e codec, void *user_data){
+ int ret;
+ recorder_h recorder = (recorder_h)user_data;
+ recorder_audio_codec_e get_codec;
+ ret = recorder_set_audio_encoder(recorder, codec);
+ recorder_get_audio_encoder(recorder, &get_codec);
+
+
+ if( get_codec != codec){
+ printf("FAIL\n");
+ audioencoder_test_fail++;
+ }else
+ printf("PASS\n");
+ return true;
+}
+
+
+int audio_encoder_test(recorder_h recorder){
+ audioencoder_test_fail = 0;
+ printf("----------------audio encorder test ------------------\n");
+ recorder_foreach_supported_audio_encoder(recorder, _audio_encoder_test_cb, recorder);
+ return -audioencoder_test_fail;
+}
+
+int recording_audio_device_test(recorder_h recorder)
+{
+ int ret;
+ int fail=0;
+ recorder_audio_device_e int_value;
+ // negative test
+ printf("-------------audio device test----------------------\n");
+ printf("-nagative test\n");
+ ret = recorder_attr_set_audio_device (recorder, -1);
+ if( ret == 0 ){
+ printf("FAIL\n");
+ fail++;
+ }else
+ printf("PASS\n");
+
+ printf("-RECORDER_AUDIO_DEVICE_MIC test\n");
+ ret = recorder_attr_set_audio_device(recorder, RECORDER_AUDIO_DEVICE_MIC);
+ if( ret != 0 ){
+ printf("FAIL\n");
+ fail++;
+ }else
+ printf("PASS\n");
+
+ ret = recorder_attr_get_audio_device(recorder,&int_value);
+ if( int_value != RECORDER_AUDIO_DEVICE_MIC){
+ printf("FAIL\n");
+ fail++;
+ }else
+ printf("PASS\n");
+
+
+ printf("-RECORDER_AUDIO_DEVICE_MODEM set test\n");
+ ret = recorder_attr_set_audio_device(recorder, RECORDER_AUDIO_DEVICE_MODEM );
+ if( ret != 0 ){
+ printf("FAIL\n");
+ fail++;
+ }else
+ printf("PASS\n");
+
+ ret = recorder_attr_get_audio_device(recorder,&int_value);
+ if( int_value != RECORDER_AUDIO_DEVICE_MODEM){
+ printf("FAIL\n");
+ fail++;
+ }else
+ printf("PASS\n");
+
+ return -fail;
+}
+
+int recording_samplerate_test(recorder_h recorder){
+ int ret;
+ int fail=0;
+ int int_value;
+ // negative test
+ printf("-------------samplerate test----------------------\n");
+
+ ret = recorder_attr_set_audio_samplerate(recorder, -1);
+ if( ret == 0 ){
+ printf("FAIL\n");
+ fail++;
+ }else
+ printf("PASS\n");
+
+ printf("-44100 test\n");
+ ret = recorder_attr_set_audio_samplerate(recorder, 44100);
+ if( ret != 0 ){
+ printf("FAIL\n");
+ fail++;
+ }else
+ printf("PASS\n");
+
+ ret = recorder_attr_get_audio_samplerate(recorder,&int_value);
+ if( int_value != 44100){
+ printf("FAIL\n");
+ fail++;
+ }else
+ printf("PASS\n");
+
+
+ printf("-1212 set test\n");
+ ret = recorder_attr_set_audio_samplerate(recorder, 1212);
+ if( ret != 0 ){
+ printf("FAIL\n");
+ fail++;
+ }else
+ printf("PASS\n");
+
+ ret = recorder_attr_get_audio_samplerate(recorder,&int_value);
+ if( int_value != 1212){
+ printf("FAIL\n");
+ fail++;
+ }else
+ printf("PASS\n");
+
+
+ return -fail;
+}
+
+
+int recording_audio_encoder_bitrate_test(recorder_h recorder){
+ int ret;
+ int fail=0;
+ int int_value;
+ // negative test
+ printf("-------------audio encoder bitrate test----------------------\n");
+ printf("-negative test\n");
+ ret = recorder_attr_set_audio_encoder_bitrate (recorder, -2);
+ if( ret == 0 ){
+ printf("FAIL\n");
+ fail++;
+ }else
+ printf("PASS\n");
+
+ printf("-12200 test\n");
+ ret = recorder_attr_set_audio_encoder_bitrate (recorder, 12200);
+ if( ret != 0 ){
+ printf("FAIL\n");
+ fail++;
+ }else
+ printf("PASS\n");
+
+ ret = recorder_attr_get_audio_encoder_bitrate (recorder,&int_value);
+ if( int_value != 12200){
+ printf("FAIL\n");
+ fail++;
+ }else
+ printf("PASS\n");
+
+
+ printf("-288000 set test\n");
+ ret = recorder_attr_set_audio_encoder_bitrate (recorder, 288000 );
+ if( ret != 0 ){
+ printf("FAIL\n");
+ fail++;
+ }else
+ printf("PASS\n");
+
+ ret = recorder_attr_get_audio_encoder_bitrate (recorder,&int_value);
+ if( int_value != 288000 ){
+ printf("FAIL\n");
+ fail++;
+ }else
+ printf("PASS\n");
+
+ printf("-1212 set test\n");
+ ret = recorder_attr_set_audio_encoder_bitrate (recorder, 1212 );
+ if( ret != 0 ){
+ printf("FAIL\n");
+ fail++;
+ }else
+ printf("PASS\n");
+
+ ret = recorder_attr_get_audio_encoder_bitrate (recorder,&int_value);
+ if( int_value != 1212 ){
+ printf("FAIL\n");
+ fail++;
+ }else
+ printf("PASS\n");
+
+ return -fail;
+}
+
+int recording_video_encoder_bitrate_test(recorder_h recorder){
+ int ret;
+ int fail=0;
+ int int_value;
+ // negative test
+ printf("-------------video encoder bitrate test----------------------\n");
+ printf("-negative test\n");
+ ret = recorder_attr_set_video_encoder_bitrate (recorder, -2);
+ if( ret == 0 ){
+ printf("FAIL\n");
+ fail++;
+ }else
+ printf("PASS\n");
+
+ printf("-12200 test\n");
+ ret = recorder_attr_set_video_encoder_bitrate (recorder, 12200);
+ if( ret != 0 ){
+ printf("FAIL\n");
+ fail++;
+ }else
+ printf("PASS\n");
+
+ ret = recorder_attr_get_video_encoder_bitrate (recorder,&int_value);
+ if( int_value != 12200){
+ printf("FAIL\n");
+ fail++;
+ }else
+ printf("PASS\n");
+
+
+ printf("-288000 set test\n");
+ ret = recorder_attr_set_video_encoder_bitrate (recorder, 288000 );
+ if( ret != 0 ){
+ printf("FAIL\n");
+ fail++;
+ }else
+ printf("PASS\n");
+
+ ret = recorder_attr_get_video_encoder_bitrate (recorder,&int_value);
+ if( int_value != 288000 ){
+ printf("FAIL\n");
+ fail++;
+ }else
+ printf("PASS\n");
+
+ printf("-1212 set test\n");
+ ret = recorder_attr_set_video_encoder_bitrate (recorder, 1212 );
+ if( ret != 0 ){
+ printf("FAIL\n");
+ fail++;
+ }else
+ printf("PASS\n");
+
+ ret = recorder_attr_get_video_encoder_bitrate (recorder,&int_value);
+ if( int_value != 1212 ){
+ printf("FAIL\n");
+ fail++;
+ }else
+ printf("PASS\n");
+
+ return -fail;
+}
+
+
+typedef struct{
+ bool iscalled;
+ bool isready;
+ bool isrecording;
+ bool ispaused;
+ recorder_state_e state;
+} state_change_data;
+
+void _state_change_test_cb(recorder_state_e previous, recorder_state_e current, bool by_asm, void *user_data){
+ state_change_data * data = (state_change_data*)user_data;
+ if( current == RECORDER_STATE_READY )
+ data->isready = true;
+ if( current == RECORDER_STATE_RECORDING )
+ data->isrecording = true;
+ if( current == RECORDER_STATE_PAUSED )
+ data->ispaused = true;
+
+ data->state = current;
+
+ //printf("state %d\n",current);
+
+}
+
+void utc_media_recorder_state_change_test(void){
+ recorder_h recorder;
+ state_change_data data;
+ int ret;
+ recorder_create_audiorecorder(&recorder);
+ data.iscalled = false;
+ data.isready = false;
+ data.isrecording = false;
+ data.ispaused = false;
+ data.state = 0;
+ printf("-------------------------recorder state change test -------------------\n");
+ recorder_set_state_changed_cb(recorder, _state_change_test_cb, &data);
+ recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_AMR);
+ recorder_prepare(recorder);
+ ret = recorder_start(recorder);
+ sleep(1);
+ ret = recorder_pause(recorder);
+ ret =recorder_commit(recorder);
+ sleep(2);
+
+ if( data.isready && data.isrecording && data.ispaused && data.state == RECORDER_STATE_READY ){
+ printf("PASS\n");
+ ret = 0;
+ }else{
+ printf("FAIL data.isready %d, data.isrecording %d, data.ispaused %d, data.state %d \n", data.isready , data.isrecording , data.ispaused , data.state );
+ ret = -1;
+ }
+
+ recorder_unprepare(recorder);
+ recorder_destroy(recorder);
+
+
+ MY_ASSERT(__func__, ret == 0 , "Fail state change test");
+ dts_pass(__func__, "PASS");
+
+}
+
+
+typedef struct {
+ int elapsed_time;
+ int file_size;
+} recording_result;
+void _recording_status_test_cb(int elapsed_time, int file_size, void *user_data){
+ recording_result *result = (recording_result*)user_data;
+ result->elapsed_time = elapsed_time;
+ result->file_size = file_size;
+
+}
+
+void utc_media_recorder_recoding_status_cb_test(void){
+ recorder_h recorder;
+ recording_result result;
+ int ret;
+
+ printf("--------------recording status cb test-------------------\n");
+ recorder_create_audiorecorder(&recorder);
+ recorder_set_recording_status_cb(recorder,_recording_status_test_cb, &result);
+ recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_AMR);
+ recorder_prepare(recorder);
+ ret = recorder_start(recorder);
+ result.elapsed_time = 0;
+ result.file_size = 0;
+ sleep(3);
+ ret = recorder_cancel(recorder);
+ ret =recorder_unprepare(recorder);
+ ret =recorder_destroy(recorder);
+ if( result.elapsed_time > 0 && result.file_size > 0){
+ printf("PASS\n");
+ dts_pass(__func__, "PASS");
+ }else{
+ printf("FAIL\n");
+ dts_fail(__func__, "status cb Fail");
+ }
+}
+
+
+void utc_media_recorder_attribute_test(void){
+ int fail =0;
+ int ret;
+ recorder_h recorder;
+ ret = recorder_create_audiorecorder(&recorder);
+ fail = recording_limit_size_test(recorder);
+ fail +=recording_time_limit_test(recorder);
+ fail +=fileformat_test(recorder);
+ fail +=video_encoder_test(recorder);
+ fail +=audio_encoder_test(recorder);
+ fail +=recording_audio_device_test(recorder);
+ fail +=recording_samplerate_test(recorder);
+ fail +=recording_audio_encoder_bitrate_test(recorder);
+ fail +=recording_video_encoder_bitrate_test(recorder);
+ MY_ASSERT(__func__, fail == 0 , "Fail recorder attribute");
+ dts_pass(__func__, "PASS");
+}
+
+
+
+void _recording_status_cb2(int elapsed_time, int file_size, void *user_data){
+ //printf("elapsed time :%d , file_size :%d\n", elapsed_time , file_size);
+
+}
+
+void _recording_limited_reached_cb(recorder_recording_limit_type_e type, void *user_data){
+ printf("limited!! %d\n", type);
+ int *ischeck = (int*)user_data;
+ *ischeck = 1;
+}
+
+
+void utc_media_recorder_limit_cb_test(void){
+ recorder_h recorder;
+ int ischeck = 0;
+ int ret =0;
+ recorder_state_e state;
+ recorder_create_audiorecorder(&recorder);
+ printf("------------------------limit cb test -------------------------\n");
+ //recorder_set_state_change_cb(recorder, record_state_cb, NULL);
+ recorder_set_recording_status_cb(recorder, _recording_status_cb2, NULL);
+ recorder_set_recording_limit_reached_cb(recorder, _recording_limited_reached_cb, &ischeck);
+ recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_AMR);
+ recorder_prepare(recorder);
+
+ recorder_get_state(recorder, &state);
+
+
+ printf("-time limit test\n");
+ recorder_attr_set_time_limit(recorder, 2);
+ recorder_start(recorder);
+ sleep(5);
+ recorder_cancel(recorder);
+ if( ischeck ){
+ printf("PASS\n");
+ }else{
+ printf("FAIL\n");
+ ret--;
+ }
+
+
+ printf("-time unlimit test\n");
+ //recorder_unready(recorder);
+ recorder_attr_set_time_limit(recorder, 0);
+ //recorder_ready(recorder);
+
+ recorder_start(recorder);
+ ischeck = 0;
+ sleep(5);
+ recorder_cancel(recorder);
+ if( ischeck ){
+ printf("FAIL\n");
+ ret--;
+ }else{
+ printf("PASS\n");
+ }
+
+
+ printf("-size limit test\n");
+ ischeck = 0;
+ recorder_attr_set_size_limit(recorder, 2);
+ recorder_start(recorder);
+ sleep(5);
+ recorder_cancel(recorder);
+
+ if( ischeck ){
+ printf("PASS\n");
+ }else{
+ printf("FAIL\n");
+ ret--;
+ }
+
+ printf("-size unlimit test\n");
+ ischeck = 0;
+ recorder_attr_set_size_limit(recorder, 0);
+ recorder_start(recorder);
+ sleep(5);
+ recorder_cancel(recorder);
+
+ if( ischeck ){
+ printf("FAIL\n");
+ ret--;
+ }else{
+ printf("PASS\n");
+ }
+
+
+ recorder_unprepare(recorder);
+ recorder_destroy(recorder);
+
+ MY_ASSERT(__func__, ret == 0 , "fail limit cb");
+ dts_pass(__func__, "PASS");
+}
+
--- /dev/null
+all
+ ^TEST
+##### Scenarios for TEST #####
+
+# Test scenario
+TEST
+ :include:/testcase/tslist
--- /dev/null
+TET_OUTPUT_CAPTURE=True # capture option for build operation checking
+TET_BUILD_TOOL=make # build with using make command
+TET_BUILD_FILE=-f Makefile # execution file (Makefile) for build
+TET_API_COMPLIANT=True # use TET API in Test Case ?
+TET_PASS_TC_NAME=True # report passed TC name in Journal file?
--- /dev/null
+TET_OUTPUT_CAPTURE=True # capture option
+TET_CLEAN_TOOL= make clean # clean tool
+TET_CLEAN_FILE= Makefile # file for clean
+TET_API_COMPLIANT=True # TET API useage
+TET_PASS_TC_NAME=True # showing name , passed TC
--- /dev/null
+TET_OUTPUT_CAPTURE=True # capturing execution or not
+TET_EXEC_TOOL= # ex) exec : execution tool set up/ Optional
+TET_EXEC_FILE= # ex) exectool : execution file/ Optional
+TET_API_COMPLIANT=True # Test case or Tool usesTET API?
+TET_PASS_TC_NAME=True # showing Passed TC name ?
+++ /dev/null
-/usr/include/*
-/usr/include/*/*
-/usr/lib/pkgconfig/*.pc
-
+++ /dev/null
-/usr/lib/lib*.so*
+++ /dev/null
-capi-media-recorder (0.1.0-8) unstable; urgency=low
-
- * update dependency
- * Git: slp-source.sec.samsung.net:slp/api/recorder
- * Tag: capi-media-recorder_0.1.0-8
-
- -- Seungkeun Lee <sngn.lee@samsung.com> Wed, 14 Mar 2012 12:06:14 +0900
-
-capi-media-recorder (0.1.0-7) unstable; urgency=low
-
- * new API added : mute , audio_level
- * Git: slp-source.sec.samsung.net:slp/api/recorder
- * Tag: capi-media-recorder_0.1.0-7
-
- -- Seungkeun Lee <sngn.lee@samsung.com> Thu, 08 Mar 2012 17:43:04 +0900
-
-capi-media-recorder (0.1.0-6) unstable; urgency=low
-
- * add static , change internal function name
- * Git: slp-source.sec.samsung.net:slp/api/recorder
- * Tag: capi-media-recorder_0.1.0-6
-
- -- Seungkeun Lee <sngn.lee@samsung.com> Mon, 20 Feb 2012 15:52:26 +0900
-
-capi-media-recorder (0.1.0-5) unstable; urgency=low
-
- * add so version
- * Git: slp-source.sec.samsung.net:slp/api/recorder
- * Tag: capi-media-recorder_0.1.0-5
-
- -- Seungkeun Lee <sngn.lee@samsung.com> Tue, 14 Feb 2012 16:51:44 +0900
-
-capi-media-recorder (0.1.0-4) unstable; urgency=low
-
- * Update version
-
- -- Seungkeun Lee <sngn.lee@samsung.com> Thu, 15 Dec 2011 12:54:39 +0900
-
-capi-media-recorder (0.0.1-1) unstable; urgency=low
-
- * Initial release.
-
- -- Seungkeun Lee <sngn.lee@samsung.com> Thu, 08 Dec 2011 08:57:45 +0900
+++ /dev/null
-
-Source: capi-media-recorder
-Section: libs
-Priority: extra
-Maintainer: Seungkeun Lee <sngn.lee@samsung.com>, Kangho Hur<kagho.hur@samsung.com>
-Build-Depends: debhelper (>= 5), libmm-camcorder-dev, libmm-common-dev, capi-media-camera-dev, dlog-dev
-
-Package: capi-media-recorder
-Architecture: any
-Depends: ${shlibs:Depends}, ${misc:Depends}
-Description: A Camera library in Tizen Native API
-
-Package: capi-media-recorder-dev
-Architecture: any
-Depends: ${shlibs:Depends}, ${misc:Depends}, capi-media-recorder (= ${Source-Version}), capi-base-common-dev, capi-media-camera-dev
-Description: A Camera library in Tizen Native API (DEV)
-
-Package: capi-media-recorder-dbg
-Architecture: any
-Depends: ${shlibs:Depends}, ${misc:Depends}, capi-media-recorder (= ${Source-Version})
-Description: A Camera library in Tizen Native API (DBG)
-
+++ /dev/null
-#!/usr/bin/make -f
-
-CFLAGS = -Wall -g
-
-FULLVER ?= $(shell dpkg-parsechangelog | grep Version: | cut -d ' ' -f 2 | cut -d '-' -f 1)
-MAJORVER ?= $(shell echo $(FULLVER) | cut -d '.' -f 1)
-
-
-ifneq (,$(findstring noopt,$(DEB_BUILD_OPTIONS)))
- CFLAGS += -O0
-else
- CFLAGS += -O2
-endif
-CMAKE_ROOT_DIR ?= $(CURDIR)
-CMAKE_BUILD_DIR ?= $(CURDIR)/cmake_build_tmp
-
-configure: configure-stamp
-configure-stamp:
- dh_testdir
- mkdir -p $(CMAKE_BUILD_DIR) && cd $(CMAKE_BUILD_DIR) && cmake .. -DFULLVER=${FULLVER} -DMAJORVER=${MAJORVER}
- touch configure-stamp
-
-
-build: build-stamp
-build-stamp: configure-stamp
- dh_testdir
- cd $(CMAKE_BUILD_DIR) && $(MAKE)
- touch $@
-
-clean:
- cd $(CMAKE_ROOT_DIR)
- dh_testdir
- dh_testroot
- rm -f build-stamp configure-stamp
- rm -f
- rm -rf $(CMAKE_BUILD_DIR)
- dh_clean
-
-install: build
- dh_testdir
- dh_testroot
- dh_clean -k
- dh_installdirs
-
- cd $(CMAKE_BUILD_DIR) && $(MAKE) DESTDIR=$(CURDIR)/debian/tmp install
-
-binary-indep: build install
-
-binary-arch: build install
- dh_testdir
- dh_testroot
- dh_installchangelogs
- dh_installdocs
- dh_installexamples
- dh_install --sourcedir=debian/tmp
- dh_installman
- dh_link
- dh_strip --dbg-package=capi-media-recorder-dbg
- dh_fixperms
- dh_makeshlibs
- dh_installdeb
- dh_shlibdeps
- dh_gencontrol
- dh_md5sums
- dh_builddeb
-
-binary: binary-indep binary-arch
-.PHONY: build clean binary-indep binary-arch binary install configure
-
#define __TIZEN_MULTIMEDIA_RECORDER_H__
#include <tizen.h>
#include <camera.h>
+#include <audio_io.h>
#ifdef __cplusplus
extern "C" {
RECORDER_ERROR_DEVICE = RECORDER_ERROR_CLASS | 0x04, /**< Device error */
RECORDER_ERROR_INVALID_OPERATION = TIZEN_ERROR_INVALID_OPERATION, /**< Internal error */
RECORDER_ERROR_SOUND_POLICY = RECORDER_ERROR_CLASS | 0x06, /**< Blocked by Audio Session Manager */
+ RECORDER_ERROR_SECURITY_RESTRICTED = RECORDER_ERROR_CLASS | 0x07, /**< Restricted by security system policy */
} recorder_error_e;
/**
RECORDER_FILE_FORMAT_3GP, /**< 3GP file format */
RECORDER_FILE_FORMAT_MP4, /**< MP4 file format */
RECORDER_FILE_FORMAT_AMR, /**< AMR file format */
+ RECORDER_FILE_FORMAT_ADTS, /**< ADTS file format */
+ RECORDER_FILE_FORMAT_WAV, /**< WAV file format */
} recorder_file_format_e;
*/
typedef enum
{
- RECORDER_AUDIO_CODEC_AMR, /**< AMR codec */
+ RECORDER_AUDIO_CODEC_DISABLE = -1, /**< Disable audio track */
+ RECORDER_AUDIO_CODEC_AMR = 0, /**< AMR codec */
RECORDER_AUDIO_CODEC_AAC, /**< AAC codec */
+ RECORDER_AUDIO_CODEC_VORBIS, /**< Vorbis codec */
+ RECORDER_AUDIO_CODEC_PCM /**< PCM codec */
} recorder_audio_codec_e;
/**
RECORDER_VIDEO_CODEC_H263, /**< H263 codec */
RECORDER_VIDEO_CODEC_H264, /**< H264 codec */
RECORDER_VIDEO_CODEC_MPEG4, /**< MPEG4 codec */
+ RECORDER_VIDEO_CODEC_THEORA /**< Theora codec */
} recorder_video_codec_e;
/**
RECORDER_AUDIO_DEVICE_MODEM, /**< Modem */
} recorder_audio_device_e;
+/**
+ * @brief Enumerations of the recorder rotation type.
+ */
+typedef enum
+{
+ RECORDER_ROTATION_NONE, /**< No rotation */
+ RECORDER_ROTATION_90, /**< 90 degree rotation */
+ RECORDER_ROTATION_180, /**< 180 degree rotation */
+ RECORDER_ROTATION_270, /**< 270 degree rotation */
+} recorder_rotation_e;
+
+/**
+ * @brief Enumerations of the recorder policy.
+ */
+typedef enum
+{
+ RECORDER_POLICY_NONE = 0, /**< None */
+ RECORDER_POLICY_SOUND, /**< Sound policy */
+ RECORDER_POLICY_SECURITY /**< Security policy */
+} recorder_policy_e;
/**
* @}
* @brief Called when the record state has changed.
* @param[in] previous The previous state of recorder
* @param[in] current The current state of recorder
- * @param[in] by_policy @c true if the recorder state is changed by sound policy, otherwise @c false
+ * @param[in] by_policy @c true if the state is changed by policy, otherwise @c false
* @param[in] user_data The user data passed from the callback registration function
* @pre This function is required to register a callback using recorder_set_state_changed_cb()
* @see recorder_set_state_changed_cb()
*/
typedef void (*recorder_state_changed_cb)(recorder_state_e previous , recorder_state_e current , bool by_policy, void *user_data);
+/**
+ * @brief Called when the recorder interrupted by policy
+ *
+ * @param[in] policy The policy that interrupting the recorder
+ * @param[in] previous The previous state of the recorder
+ * @param[in] current The current state of the recorder
+ * @param[in] user_data The user data passed from the callback registration function
+ * @see recorder_set_interrupted_cb()
+ */
+typedef void (*recorder_interrupted_cb)(recorder_policy_e policy, recorder_state_e previous, recorder_state_e current, void *user_data);
+
+/**
+ * @brief Called when audio stream data was delivering just before storing in record file.
+ * @remarks
+ * The callback function holds the same buffer that will be recorded.\n
+ * So if an user change the buffer, the result file will has the buffer.\n
+ * The callback is called via internal thread of Frameworks. so don't be invoke UI API, recorder_unprepare(), recorder_commit() and recorder_cancel() in callback.
+ *
+ * @param[in] stream The audio stream data
+ * @param[in] size The size of stream data
+ * @param[in] format The audio format
+ * @param[in] channel The number of channel
+ * @param[in] timestamp The timestamp of stream buffer( in msec )
+ * @param[in] user_data The user data passed from the callback registration function
+ *
+ * @see recorder_set_audio_stream_cb()
+ */
+typedef void (*recorder_audio_stream_cb)(void* stream, int size, audio_sample_type_e format, int channel, unsigned int timestamp, void *user_data);
+
+/**
+ * @brief Called when the error occurred.
+ *
+ * @remarks
+ * This callback inform critical error situation.\n
+ * When invoked this callback, user should release the resource and terminate application.\n
+ * These error code will be occurred\n
+ * #RECORDER_ERROR_DEVICE\n
+ * #RECORDER_ERROR_INVALID_OPERATION\n
+ * #RECORDER_ERROR_OUT_OF_MEMORY\n
+ *
+ * @param[in] error The error code
+ * @param[in] current_state The current state of the recorder
+ * @param[in] user_data The user data passed from the callback registration function
+ *
+ * @pre This callback function is invoked if you register this callback using recorder_set_error_cb().
+ * @see recorder_set_error_cb()
+ * @see recorder_unset_error_cb()
+ */
+typedef void (*recorder_error_cb)(recorder_error_e error, recorder_state_e current_state, void *user_data);
+
+
/**
* @}
*/
*/
int recorder_get_file_format(recorder_h recorder, recorder_file_format_e *format);
+
/**
* @}
*/
/**
* @brief Sets the audio codec for encoding audio stream
- * @remarks You can get available audio encoders by using recorder_foreach_supported_audio_encoder().
+ * @remarks You can get available audio encoders by using recorder_foreach_supported_audio_encoder().\n
+ * if set to RECORDER_AUDIO_CODEC_DISABLE, audio track is not created in recording files.
* @param[in] recorder The handle to media recorder
* @param[in] codec The audio codec
* @return 0 on success, otherwise a negative error value.
* @retval #RECORDER_ERROR_NONE Successful
* @retval #RECORDER_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #RECORDER_ERROR_INVALID_STATE Invalid state
- * @pre The recorder state must be #RECORDER_STATE_CREATED
+ * @pre The recorder state must be #RECORDER_STATE_CREATED or #RECORDER_STATE_READY
* @see recorder_get_audio_encoder()
* @see recorder_foreach_supported_audio_encoder()
*/
* @retval #RECORDER_ERROR_NONE Successful
* @retval #RECORDER_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #RECORDER_ERROR_INVALID_STATE Invalid state
- * @pre The recorder state must be #RECORDER_STATE_CREATED
+ * @pre The recorder state must be #RECORDER_STATE_CREATED or #RECORDER_STATE_READY
* @see recorder_get_video_encoder()
* @see recorder_foreach_supported_video_encoder()
*/
*/
int recorder_unset_state_changed_cb(recorder_h recorder);
+/**
+ * @brief Registers a callback function to be called when recorder interrupted by policy.
+ *
+ * @param[in] recorder The handle to the recorder
+ * @param[in] callback The callback function to register
+ * @param[in] user_data The user data to be passed to the callback function
+ *
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #RECORDER_ERROR_NONE Successful
+ * @retval #RECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ *
+ * @see recorder_unset_interrupted_cb()
+ * @see recorder_interrupted_cb()
+ */
+int recorder_set_interrupted_cb(recorder_h recorder, recorder_interrupted_cb callback,
+ void *user_data);
+
+/**
+ * @brief Unregisters the callback function.
+ *
+ * @param[in] recorder The handle to the recorder
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #RECORDER_ERROR_NONE Successful
+ * @retval #RECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ *
+ * @see recorder_set_interrupted_cb()
+ */
+int recorder_unset_interrupted_cb(recorder_h recorder);
+
+/**
+ * @brief Registers a callback function to be called when audio stream data was delivering
+ *
+ * @remarks
+ * This callback function holds the same buffer that will be recorded.\n
+ * So if an user change the buffer, the result file will has the buffer.\n
+ * The callback is called via internal thread of Frameworks. so don't be invoke UI API, recorder_unprepare(), recorder_commit() and recorder_cancel() in callback.\n
+ * This callback function to be called in RECORDER_STATE_RECORDING and RECORDER_STATE_PAUSE state.
+ *
+ * @param[in] recorder The handle to the recorder
+ * @param[in] callback The callback function to register
+ * @param[in] user_data The user data to be passed to the callback function
+ *
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #RECORDER_ERROR_NONE Successful
+ * @retval #RECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @pre The recorder state should be #RECORDER_STATE_READY or #RECORDER_STATE_CREATED.
+ *
+ * @see recorder_unset_audio_stream_cb()
+ * @see recorder_audio_stream_cb()
+ */
+int recorder_set_audio_stream_cb(recorder_h recorder, recorder_audio_stream_cb callback, void* user_data);
+
+/**
+ * @brief Unregisters the callback function.
+ *
+ * @param[in] recorder The handle to the recorder
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #RECORDER_ERROR_NONE Successful
+ * @retval #RECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ *
+ * @see recorder_set_audio_stream_cb()
+ */
+int recorder_unset_audio_stream_cb(recorder_h recorder);
+
/**
* @brief Registers a callback function to be invoked when the recording information changes.
*/
int recorder_unset_recording_limit_reached_cb(recorder_h recorder);
+
+/**
+ * @brief Registers a callback function to be called when an asynchronous operation error occurred.
+ *
+ * @remarks
+ * This callback inform critical error situation.\n
+ * When invoked this callback, user should release the resource and terminate application.\n
+ * These error code will be occurred\n
+ * #RECORDER_ERROR_DEVICE\n
+ * #RECORDER_ERROR_INVALID_OPERATION\n
+ * #RECORDER_ERROR_OUT_OF_MEMORY\n
+ *
+ * @param[in] recorder The handle to the recorder
+ * @param[in] callback The callback function to register
+ * @param[in] user_data The user data to be passed to the callback function
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #RECORDER_ERROR_NONE Successful
+ * @retval #RECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @post This function will invoke recorder_error_cb() when an asynchronous operation error occur.
+ *
+ * @see recorder_unset_error_cb()
+ * @see recorder_error_cb()
+ */
+int recorder_set_error_cb(recorder_h recorder, recorder_error_cb callback, void *user_data);
+
+
+/**
+ * @brief Unregisters the callback function.
+ *
+ * @param[in] recorder The handle to the recorder
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #RECORDER_ERROR_NONE Successful
+ * @retval #RECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ *
+ * @see recorder_set_error_cb()
+ */
+int recorder_unset_error_cb(recorder_h recorder);
+
+
/**
* @}
*/
* @brief Gets the mute state of recorder
* @param[in] recorder The handle to media recorder
* @return true if the recorder is not recording any sound,\nelse false
- * @retval #RECORDER_ERROR_NONE Successful
- * @retval #RECORDER_ERROR_INVALID_PARAMETER Invalid parameter
* @see recorder_attr_set_mute()
*/
bool recorder_attr_is_muted(recorder_h recorder);
+/**
+ * @brief Sets recording motion rate
+ * @remarks
+ * This attribute is valid only in video recorder.\n
+ * If the rate bigger than 0 and smaller than 1, video is recorded slow motion mode.\n
+ * If the rate bigger than 1, video is recorded fast motion mode(time lapse recording).
+ * Audio data is not recorded.\n
+ * To reset slow motion recording, setting rate to 1.
+ * @param[in] recorder The handle to media recorder
+ * @param[in] rate The recording motion rate. it is computed with fps. (0<rate<1 for slow motion, 1<rate for fast motion(time lapse recording), 1 to reset )
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #RECORDER_ERROR_NONE Successful
+ * @retval #RECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @pre The recorder state must be #RECORDER_STATE_CREATED or #RECORDER_STATE_READY
+ * @see recorder_attr_get_recording_motion_rate()
+ */
+int recorder_attr_set_recording_motion_rate(recorder_h recorder , double rate);
+
+/**
+ * @brief Gets the recording motion rate
+ * @remarks
+ * This attribute is valid only in video recorder.\n
+ * If the rate bigger than 0 and smaller than 1, video is recorded slow motion mode.\n
+ * If the rate bigger than 1, video is recorded fast motion mode(time lapse recording).
+ * Audio data is not recorded.\n
+ * To reset slow motion recording, setting rate to 1.
+ * @param[in] recorder The handle to media recorder
+ * @param[out] rate The recording motion rate. it is computed with fps.
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #RECORDER_ERROR_NONE Successful
+ * @retval #RECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @see recorder_attr_set_recording_motion_rate()
+ */
+int recorder_attr_get_recording_motion_rate(recorder_h recorder , double *rate);
+__attribute__ ((deprecated)) int recorder_attr_set_slow_motion_rate(recorder_h recorder , double rate);
+__attribute__ ((deprecated)) int recorder_attr_get_slow_motion_rate(recorder_h recorder , double *rate);
+
+/**
+ * @brief Sets the numer of audio channel.
+ * @remarks This attribute is applied only in RECORDER_STATE_CREATED state.\n
+ * For mono recording, setting channel to 1.\n
+ * For stereo recording, setting channel to 2.
+ * @param[in] recorder The handle to media recorder
+ * @param[in] channel_count The number of audio channel
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #RECORDER_ERROR_NONE Successful
+ * @retval #RECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @pre The recorder state must be #RECORDER_STATE_CREATED
+ * @see recorder_attr_get_audio_channel()
+ */
+int recorder_attr_set_audio_channel(recorder_h recorder, int channel_count);
+
+/**
+ * @brief Gets the numer of audio channel.
+ * @param[in] recorder The handle to media recorder
+ * @param[out] channel_count The number of audio channel
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #RECORDER_ERROR_NONE Successful
+ * @retval #RECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @see recorder_attr_set_audio_channel()
+ */
+int recorder_attr_get_audio_channel(recorder_h recorder, int *channel_count);
+
+/**
+ * @brief Sets the orientation of video recording data
+ * @remarks
+ * This attribute is valid only in video recorder.\n
+ * @param[in] recorder The handle to media recorder
+ * @param[in] orientation The orientation of video recording data
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #RECORDER_ERROR_NONE Successful
+ * @retval #RECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @see recorder_attr_get_recording_orientation()
+ */
+int recorder_attr_set_recording_orientation(recorder_h recorder, recorder_rotation_e orientation);
+
+/**
+ * @brief Gets the orientation of video recording data
+ * @remarks
+ * This attribute is valid only in video recorder.\n
+ * @param[in] recorder The handle to media recorder
+ * @param[out] orientation The orientation of video recording data
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #RECORDER_ERROR_NONE Successful
+ * @retval #RECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @see recorder_attr_set_recording_orientation()
+ */
+int recorder_attr_get_recording_orientation(recorder_h recorder, recorder_rotation_e *orientation);
/**
* @}
_RECORDER_EVENT_TYPE_STATE_CHANGE,
_RECORDER_EVENT_TYPE_RECORDING_LIMITED,
_RECORDER_EVENT_TYPE_RECORDING_STATUS,
+ _RECORDER_EVENT_TYPE_INTERRUPTED,
+ _RECORDER_EVENT_TYPE_AUDIO_STREAM,
+ _RECORDER_EVENT_TYPE_ERROR,
_RECORDER_EVENT_TYPE_NUM
}_recorder_event_e;
Name: capi-media-recorder
-Summary: A Camera library in Tizen Native API
+Summary: A Recorder library in Tizen C API
Version: 0.1.0
-Release: 8
-Group: TO_BE/FILLED_IN
+Release: 22
+Group: libdevel
License: Apache-2.0
Source0: %{name}-%{version}.tar.gz
BuildRequires: cmake
BuildRequires: pkgconfig(mm-camcorder)
BuildRequires: pkgconfig(capi-base-common)
BuildRequires: pkgconfig(capi-media-camera)
+BuildRequires: pkgconfig(capi-media-audio-io)
Requires(post): /sbin/ldconfig
Requires(postun): /sbin/ldconfig
%description
%package devel
-Summary: A Camera library in Tizen Native API (Development)
+Summary: A Recorder library in Tizen C API (Development)
Group: TO_BE/FILLED_IN
Requires: %{name} = %{version}-%{release}
/*
- * camera_private
- * It should be sync with camera_private.h
+ * camera_private function
*/
-int __mm_camera_message_callback(int message, void *param, void *user_data);
-
-typedef enum {
- _CAMERA_EVENT_TYPE_STATE_CHANGE,
- _CAMERA_EVENT_TYPE_FOCUS_CHANGE,
- _CAMERA_EVENT_TYPE_CAPTURE_COMPLETE,
- _CAMERA_EVENT_TYPE_PREVIEW,
- _CAMERA_EVENT_TYPE_CAPTURE,
- _CAMERA_EVENT_TYPE_ERROR,
- _CAMERA_EVENT_TYPE_NUM
-}_camera_event_e;
-
-typedef struct _camera_s{
- MMHandleType mm_handle;
-
- void* user_cb[_CAMERA_EVENT_TYPE_NUM];
- void* user_data[_CAMERA_EVENT_TYPE_NUM];
- void* display_handle;
- camera_display_type_e display_type;
- int state;
-
-} camera_s;
-
+int _camera_get_mm_handle(camera_h camera , MMHandleType *handle);
+int _camera_set_relay_mm_message_callback(camera_h camera, MMMessageCallback callback, void *user_data);
/*
- * end of camera_private
+ * end of camera_private function
*/
-
+static int __mm_audio_stream_cb(MMCamcorderAudioStreamDataType *stream, void *user_param);
static int __mm_recorder_msg_cb(int message, void *param, void *user_data);
+static int __convert_error_code_camera_to_recorder(int code){
+ int new_code = code;
+ switch(code)
+ {
+ case CAMERA_ERROR_INVALID_STATE :
+ new_code = RECORDER_ERROR_INVALID_STATE;
+ break;
+ case CAMERA_ERROR_DEVICE:
+ new_code = RECORDER_ERROR_DEVICE;
+ break;
+ case CAMERA_ERROR_SOUND_POLICY:
+ new_code = RECORDER_ERROR_SOUND_POLICY;
+ break;
+ case CAMERA_ERROR_SECURITY_RESTRICTED:
+ new_code = RECORDER_ERROR_SECURITY_RESTRICTED;
+ break;
+ }
+ return new_code;
+}
static int __convert_recorder_error_code(const char *func, int code){
int ret = RECORDER_ERROR_INVALID_OPERATION;
errorstr = "ERROR_SOUND_POLICY";
break;
+ case MM_ERROR_POLICY_RESTRICTED:
+ ret = RECORDER_ERROR_SECURITY_RESTRICTED;
+ errorstr = "ERROR_RESTRICTED";
+ break;
+
default:
ret = RECORDER_ERROR_INVALID_OPERATION;
errorstr = "INVALID_OPERATION";
case MM_CAMCORDER_STATE_PREPARE:
state = RECORDER_STATE_READY;
break;
+ case MM_CAMCORDER_STATE_CAPTURING:
+ state = RECORDER_STATE_READY;
+ break;
case MM_CAMCORDER_STATE_RECORDING:
state = RECORDER_STATE_RECORDING;
break;
}
static int __mm_recorder_msg_cb(int message, void *param, void *user_data){
-
recorder_s * handle = (recorder_s*)user_data;
MMMessageParamType *m = (MMMessageParamType*)param;
recorder_state_e previous_state;
switch(message){
case MM_MESSAGE_CAMCORDER_STATE_CHANGED:
case MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_ASM:
+ case MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_SECURITY:
previous_state = handle->state;
handle->state = __recorder_state_convert(m->state.current);
-
+ recorder_policy_e policy = RECORDER_POLICY_NONE;
+ if(message == MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_ASM )
+ policy = RECORDER_POLICY_SOUND;
+ else if( message == MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_SECURITY )
+ policy = RECORDER_POLICY_SECURITY;
+
if( previous_state != handle->state && handle->user_cb[_RECORDER_EVENT_TYPE_STATE_CHANGE] ){
- ((recorder_state_changed_cb)handle->user_cb[_RECORDER_EVENT_TYPE_STATE_CHANGE])(previous_state, handle->state, message == MM_MESSAGE_CAMCORDER_STATE_CHANGED ? 0 : 1 , handle->user_data[_RECORDER_EVENT_TYPE_STATE_CHANGE]);
+ ((recorder_state_changed_cb)handle->user_cb[_RECORDER_EVENT_TYPE_STATE_CHANGE])(previous_state, handle->state, policy , handle->user_data[_RECORDER_EVENT_TYPE_STATE_CHANGE]);
}
-
// should change intermediate state MM_CAMCORDER_STATE_READY is not valid in capi , change to NULL state
- if( message == MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_ASM ){
+ if( policy != RECORDER_POLICY_NONE ){
+ if( previous_state != handle->state && handle->user_cb[_RECORDER_EVENT_TYPE_INTERRUPTED] ){
+ ((recorder_interrupted_cb)handle->user_cb[_RECORDER_EVENT_TYPE_INTERRUPTED])(policy, previous_state, handle->state, handle->user_data[_RECORDER_EVENT_TYPE_INTERRUPTED]);
+ }
if( m->state.previous == MM_CAMCORDER_STATE_PREPARE && m->state.current == MM_CAMCORDER_STATE_PREPARE ){
mm_camcorder_unrealize(handle->mm_handle);
}
break;
case MM_MESSAGE_CAMCORDER_CAPTURED :
{
- MMCamRecordingReport *report = (MMCamRecordingReport *)m ->data;
- int mode;
- mm_camcorder_get_attributes(handle->mm_handle ,NULL,MMCAM_MODE, &mode, NULL);
-
- if( mode != MM_CAMCORDER_MODE_IMAGE){
- if( report && report->recording_filename ){
+ if( handle->type == _RECORDER_TYPE_AUDIO ){
+ MMCamRecordingReport *report = (MMCamRecordingReport *)m ->data;
+ if( report != NULL && report->recording_filename ){
free(report->recording_filename );
report->recording_filename = NULL;
}
}
break;
}
+ case MM_MESSAGE_CAMCORDER_ERROR:
+ {
+ int errorcode = m->code;
+ int recorder_error = 0;
+ switch( errorcode ){
+ case MM_ERROR_CAMCORDER_DEVICE :
+ case MM_ERROR_CAMCORDER_DEVICE_TIMEOUT :
+ case MM_ERROR_CAMCORDER_DEVICE_REG_TROUBLE :
+ case MM_ERROR_CAMCORDER_DEVICE_WRONG_JPEG :
+ recorder_error = RECORDER_ERROR_DEVICE;
+ break;
+ case MM_ERROR_CAMCORDER_GST_CORE :
+ case MM_ERROR_CAMCORDER_GST_LIBRARY :
+ case MM_ERROR_CAMCORDER_GST_RESOURCE :
+ case MM_ERROR_CAMCORDER_GST_STREAM :
+ case MM_ERROR_CAMCORDER_GST_NEGOTIATION :
+ case MM_ERROR_CAMCORDER_GST_FLOW_ERROR :
+ case MM_ERROR_CAMCORDER_ENCODER :
+ case MM_ERROR_CAMCORDER_ENCODER_BUFFER :
+ case MM_ERROR_CAMCORDER_ENCODER_WORKING :
+ case MM_ERROR_CAMCORDER_MNOTE_CREATION :
+ case MM_ERROR_CAMCORDER_MNOTE_ADD_ENTRY :
+ case MM_ERROR_CAMCORDER_INTERNAL :
+ recorder_error = RECORDER_ERROR_INVALID_OPERATION;
+ break;
+ case MM_ERROR_CAMCORDER_LOW_MEMORY :
+ case MM_ERROR_CAMCORDER_MNOTE_MALLOC :
+ recorder_error = RECORDER_ERROR_OUT_OF_MEMORY;
+ break;
+ }
+ if( recorder_error != 0 && handle->user_cb[_RECORDER_EVENT_TYPE_ERROR] )
+ ((recorder_error_cb)handle->user_cb[_RECORDER_EVENT_TYPE_ERROR])(errorcode, handle->state , handle->user_data[_RECORDER_EVENT_TYPE_ERROR]);
+ break;
+ }
case MM_MESSAGE_CAMCORDER_CURRENT_VOLUME:
if( handle->last_max_input_level < m->rec_volume_dB )
handle->last_max_input_level = m->rec_volume_dB;
return 1;
}
+static int __mm_audio_stream_cb(MMCamcorderAudioStreamDataType *stream, void *user_param){
+ if( user_param == NULL || stream == NULL)
+ return 0;
+
+ recorder_s * handle = (recorder_s*)user_param;
+ audio_sample_type_e format = AUDIO_SAMPLE_TYPE_U8;
+ if( stream->format == MM_CAMCORDER_AUDIO_FORMAT_PCM_S16_LE)
+ format = AUDIO_SAMPLE_TYPE_S16_LE;
+
+ if( handle->user_cb[_RECORDER_EVENT_TYPE_AUDIO_STREAM] ){
+ ((recorder_audio_stream_cb)(handle->user_cb[_RECORDER_EVENT_TYPE_AUDIO_STREAM]))(stream->data,
+ stream->length,
+ format,
+ stream->channel,
+ stream->timestamp,
+ handle->user_data[_RECORDER_EVENT_TYPE_AUDIO_STREAM]);
+ }
+ return 1;
+}
+
+
int recorder_create_videorecorder( camera_h camera, recorder_h* recorder){
if( camera == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
int preview_format;
camera_get_state(camera, &camera_state);
+ //TODO. if allow compatible with video mode / image mode, it should be changed
if( camera_state != CAMERA_STATE_CREATED){
LOGE("[%s] camera state(%d) is not CAMERA_STATE_CREATED ", __func__, camera_state);
return RECORDER_ERROR_INVALID_PARAMETER;
memset(handle, 0 , sizeof(recorder_s));
handle->last_max_input_level = LOWSET_DECIBEL;
-
- handle->mm_handle = ((camera_s*)camera)->mm_handle;
handle->camera = camera;
+ //TODO if allow compatible with video mode / image mode, it should be changed.
handle->state = RECORDER_STATE_CREATED;
+ _camera_get_mm_handle(camera, &handle->mm_handle);
+ _camera_set_relay_mm_message_callback(camera, __mm_recorder_msg_cb , (void*)handle);
- mm_camcorder_set_message_callback(handle->mm_handle, __mm_recorder_msg_cb, (void*)handle);
-
- //((camera_s*)camera)->relay_callback = __mm_recorder_msg_cb;
- //((camera_s*)camera)->relay_user_data = handle;
handle->type = _RECORDER_TYPE_VIDEO;
*recorder = (recorder_h)handle;
MMCAM_CAPTURE_FORMAT, MM_PIXEL_FORMAT_ENCODED,
MMCAM_CAPTURE_COUNT, 1,
(void*)NULL);
-
- mm_camcorder_set_message_callback(handle->mm_handle, __mm_camera_message_callback, (void*)handle->camera);
+ _camera_set_relay_mm_message_callback(handle->camera , NULL, NULL);
}else{
ret = mm_camcorder_destroy(handle->mm_handle);
}
int ret = 0;
recorder_s *handle = (recorder_s*)recorder;
+ if( handle->type == _RECORDER_TYPE_VIDEO ){
+ return __convert_error_code_camera_to_recorder(camera_start_preview(handle->camera));
+ }
+
MMCamcorderStateType mmstate ;
- mm_camcorder_get_state(handle->mm_handle, &mmstate);
+ mm_camcorder_get_state(handle->mm_handle, &mmstate);
if( mmstate != MM_CAMCORDER_STATE_READY){
-
ret = mm_camcorder_realize(handle->mm_handle);
if( ret != MM_ERROR_NONE){
LOGE("[%s] mm_camcorder_realize fail", __func__);
return __convert_recorder_error_code(__func__, ret);
}
-
}
-
+
ret = mm_camcorder_start(handle->mm_handle);
-
+
if( ret != MM_ERROR_NONE){
LOGE("[%s] mm_camcorder_start fail", __func__);
mm_camcorder_unrealize(handle->mm_handle);
}
int recorder_unprepare( recorder_h recorder){
-
if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
int ret = 0;
recorder_s *handle = (recorder_s*)recorder;
if( recorder == NULL || level == NULL ) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
recorder_s *handle = (recorder_s*)recorder;
- if( handle->state < RECORDER_STATE_RECORDING )
+ recorder_state_e state;
+ recorder_get_state(recorder, &state);
+ if( state < RECORDER_STATE_RECORDING ){
+ LOGE("[%s]RECORDER_ERROR_INVALID_STATE(0x%08x) ",__func__, RECORDER_ERROR_INVALID_STATE);
return RECORDER_ERROR_INVALID_STATE;
+ }
*level = handle->last_max_input_level ;
handle->last_max_input_level = LOWSET_DECIBEL;
if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
int ret;
- int format_table[3] = { MM_FILE_FORMAT_3GP , // RECORDER_FILE_FORMAT_3GP,
+ int format_table[5] = { MM_FILE_FORMAT_3GP , // RECORDER_FILE_FORMAT_3GP,
MM_FILE_FORMAT_MP4 , //RECORDER_FILE_FORMAT_MP4,
- MM_FILE_FORMAT_AMR //RECORDER_FILE_FORMAT_AMR,
+ MM_FILE_FORMAT_AMR, //RECORDER_FILE_FORMAT_AMR,
+ MM_FILE_FORMAT_AAC, //RECORDER_FILE_FORMAT_ADTS
+ MM_FILE_FORMAT_WAV //RECORDER_FILE_FORMAT_WAV
};
-
- if( format < RECORDER_FILE_FORMAT_3GP || format > RECORDER_FILE_FORMAT_AMR )
+
+ if( format < RECORDER_FILE_FORMAT_3GP || format > RECORDER_FILE_FORMAT_WAV )
return RECORDER_ERROR_INVALID_PARAMETER;
-
+
recorder_s * handle = (recorder_s*)recorder;
ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_FILE_FORMAT , format_table[format], NULL);
return __convert_recorder_error_code(__func__, ret);
break;
case MM_FILE_FORMAT_AMR :
*format = RECORDER_FILE_FORMAT_AMR;
- break;
+ break;
+ case MM_FILE_FORMAT_AAC :
+ *format = RECORDER_FILE_FORMAT_ADTS;
+ break;
+ case MM_FILE_FORMAT_WAV:
+ *format = RECORDER_FILE_FORMAT_WAV;
+ break;
default :
ret = MM_ERROR_CAMCORDER_INTERNAL;
break;
}
- }
+ }
return __convert_recorder_error_code(__func__, ret);
}
return RECORDER_ERROR_NONE;
}
+int recorder_set_interrupted_cb(recorder_h recorder, recorder_interrupted_cb callback, void *user_data){
+ if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
+ recorder_s *handle = (recorder_s*)recorder;
+ if( callback == NULL )
+ return RECORDER_ERROR_INVALID_PARAMETER;
+
+ handle->user_cb[_RECORDER_EVENT_TYPE_INTERRUPTED] = callback;
+ handle->user_data[_RECORDER_EVENT_TYPE_INTERRUPTED] = user_data;
+
+ return RECORDER_ERROR_NONE;
+}
+int recorder_unset_interrupted_cb(recorder_h recorder){
+ if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
+ recorder_s *handle = (recorder_s*)recorder;
+
+ handle->user_cb[_RECORDER_EVENT_TYPE_INTERRUPTED] = NULL;
+ handle->user_data[_RECORDER_EVENT_TYPE_INTERRUPTED] = NULL;
+
+ return RECORDER_ERROR_NONE;
+}
+
+int recorder_set_audio_stream_cb(recorder_h recorder, recorder_audio_stream_cb callback, void* user_data){
+ if( recorder == NULL || callback == NULL ) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
+ int ret;
+ recorder_s *handle = (recorder_s*)recorder;
+ ret = mm_camcorder_set_audio_stream_callback( handle->mm_handle, __mm_audio_stream_cb, handle);
+ if( ret == 0 ){
+ handle->user_cb[_RECORDER_EVENT_TYPE_AUDIO_STREAM] = callback;
+ handle->user_data[_RECORDER_EVENT_TYPE_AUDIO_STREAM] = user_data;
+ }
+ return __convert_recorder_error_code(__func__, ret);
+}
+
+int recorder_unset_audio_stream_cb(recorder_h recorder){
+ if( recorder == NULL ) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
+ int ret;
+ recorder_s *handle = (recorder_s*)recorder;
+ handle->user_cb[_RECORDER_EVENT_TYPE_AUDIO_STREAM] = NULL;
+ handle->user_data[_RECORDER_EVENT_TYPE_AUDIO_STREAM] = NULL;
+ ret = mm_camcorder_set_audio_stream_callback( handle->mm_handle, NULL, NULL);
+ return __convert_recorder_error_code(__func__, ret);
+}
+
+int recorder_set_error_cb(recorder_h recorder, recorder_error_cb callback, void *user_data){
+ if( recorder == NULL || callback == NULL ) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
+ recorder_s *handle = (recorder_s*)recorder;
+ handle->user_cb[_RECORDER_EVENT_TYPE_ERROR] = callback;
+ handle->user_data[_RECORDER_EVENT_TYPE_ERROR] = user_data;
+ return RECORDER_ERROR_NONE;
+}
+
+int recorder_unset_error_cb(recorder_h recorder){
+ if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
+ recorder_s *handle = (recorder_s*)recorder;
+ handle->user_cb[_RECORDER_EVENT_TYPE_ERROR] = NULL;
+ handle->user_data[_RECORDER_EVENT_TYPE_ERROR] = NULL;
+ return RECORDER_ERROR_NONE;
+}
+
int recorder_set_recording_status_cb(recorder_h recorder, recorder_recording_status_cb callback, void* user_data){
if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
break;
case MM_FILE_FORMAT_AMR :
format = RECORDER_FILE_FORMAT_AMR;
- break;
+ break;
+ case MM_FILE_FORMAT_AAC:
+ format = RECORDER_FILE_FORMAT_ADTS;
+ break;
+ case MM_FILE_FORMAT_WAV:
+ format = RECORDER_FILE_FORMAT_WAV;
+ break;
default :
format = -1;
- }
-
+ }
+
if ( format != -1 && !foreach_cb(format,user_data) )
break;
}
if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- if( codec < RECORDER_AUDIO_CODEC_AMR || codec > RECORDER_AUDIO_CODEC_AAC)
+ if( codec != RECORDER_AUDIO_CODEC_DISABLE && ( codec < RECORDER_AUDIO_CODEC_AMR || codec > RECORDER_AUDIO_CODEC_PCM) )
return RECORDER_ERROR_INVALID_PARAMETER;
-
- int audio_table[2] = { MM_AUDIO_CODEC_AMR , //RECORDER_AUDIO_CODEC_AMR
- MM_AUDIO_CODEC_AAC //RECORDER_AUDIO_CODEC_AAC
+ int audio_table[4] = { MM_AUDIO_CODEC_AMR, //RECORDER_AUDIO_CODEC_AMR
+ MM_AUDIO_CODEC_AAC, //RECORDER_AUDIO_CODEC_AAC
+ MM_AUDIO_CODEC_VORBIS, //RECORDER_AUDIO_CODEC_VORBIS
+ MM_AUDIO_CODEC_WAVE //RECORDER_AUDIO_CODEC_PCM
};
-
-
int ret;
recorder_s * handle = (recorder_s*)recorder;
- if( handle->state != RECORDER_STATE_CREATED )
- return RECORDER_ERROR_INVALID_STATE;
-
- ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_AUDIO_ENCODER , audio_table[codec], NULL);
+ if( codec == RECORDER_AUDIO_CODEC_DISABLE )
+ ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_AUDIO_DISABLE , 1, NULL);
+ else
+ ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_AUDIO_ENCODER , audio_table[codec], MMCAM_AUDIO_DISABLE, 0, NULL);
return __convert_recorder_error_code(__func__, ret);
g_return_val_if_fail(codec != NULL, RECORDER_ERROR_INVALID_PARAMETER);
int ret;
int mm_codec = 0;
+ int audio_disable = 0;
recorder_s * handle = (recorder_s*)recorder;
- ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_AUDIO_ENCODER , &mm_codec , NULL);
- if( ret == 0 ){
+ ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_AUDIO_ENCODER , &mm_codec , MMCAM_AUDIO_DISABLE, &audio_disable, NULL);
+ if( ret == 0 && audio_disable == 0 ){
switch( mm_codec ){
case MM_AUDIO_CODEC_AMR :
*codec = RECORDER_AUDIO_CODEC_AMR;
case MM_AUDIO_CODEC_AAC :
*codec = RECORDER_AUDIO_CODEC_AAC;
break;
+ case MM_AUDIO_CODEC_VORBIS:
+ *codec = RECORDER_AUDIO_CODEC_VORBIS;
+ break;
+ case MM_AUDIO_CODEC_WAVE:
+ *codec = RECORDER_AUDIO_CODEC_PCM;
+ break;
default :
ret = MM_ERROR_CAMCORDER_INTERNAL;
break;
}
+ }else if( ret == 0 && audio_disable ){
+ *codec = RECORDER_AUDIO_CODEC_DISABLE;
}
return __convert_recorder_error_code(__func__, ret);
if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
int ret;
- int video_table[3] = { MM_VIDEO_CODEC_H263, //RECORDER_VIDEO_CODEC_H263, /**< H263 codec */
+ int video_table[4] = { MM_VIDEO_CODEC_H263, //RECORDER_VIDEO_CODEC_H263, /**< H263 codec */
MM_VIDEO_CODEC_H264, //RECORDER_VIDEO_CODEC_H264, /**< H264 codec */
- MM_VIDEO_CODEC_MPEG4 //RECORDER_VIDEO_CODEC_MPEG4, /**< MPEG4 codec */
+ MM_VIDEO_CODEC_MPEG4, //RECORDER_VIDEO_CODEC_MPEG4, /**< MPEG4 codec */
+ MM_VIDEO_CODEC_THEORA //RECORDER_VIDEO_CODEC_THEORA
};
- if( codec < RECORDER_VIDEO_CODEC_H263 || codec > RECORDER_VIDEO_CODEC_MPEG4 )
+ if( codec < RECORDER_VIDEO_CODEC_H263 || codec > RECORDER_VIDEO_CODEC_THEORA )
return RECORDER_ERROR_INVALID_PARAMETER;
-
recorder_s * handle = (recorder_s*)recorder;
- if( handle->state != RECORDER_STATE_CREATED )
- return RECORDER_ERROR_INVALID_STATE;
ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_VIDEO_ENCODER , video_table[codec], NULL);
return __convert_recorder_error_code(__func__, ret);
break;
case MM_VIDEO_CODEC_MPEG4 :
*codec = RECORDER_VIDEO_CODEC_MPEG4;
- break;
+ break;
+ case MM_VIDEO_CODEC_THEORA:
+ *codec = RECORDER_VIDEO_CODEC_THEORA;
+ break;
default :
ret = MM_ERROR_CAMCORDER_INTERNAL;
break;
case MM_AUDIO_CODEC_AAC :
codec = RECORDER_AUDIO_CODEC_AAC;
break;
+ case MM_AUDIO_CODEC_VORBIS:
+ codec = RECORDER_AUDIO_CODEC_VORBIS;
+ break;
+ case MM_AUDIO_CODEC_WAVE:
+ codec = RECORDER_AUDIO_CODEC_PCM;
+ break;
default :
codec = -1;
}
break;
case MM_VIDEO_CODEC_MPEG4 :
codec = RECORDER_VIDEO_CODEC_MPEG4;
- break;
+ break;
+ case MM_VIDEO_CODEC_THEORA :
+ codec = RECORDER_VIDEO_CODEC_THEORA;
+ break;
default :
codec = -1;
}
if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
recorder_s * handle = (recorder_s*)recorder;
int ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_AUDIO_VOLUME , enable ? 0.0 : 1.0 , NULL);
- return __convert_recorder_error_code(__func__, ret);;
+ return __convert_recorder_error_code(__func__, ret);
}
bool recorder_attr_is_muted(recorder_h recorder){
else
return false;
}
+
+int recorder_attr_set_recording_motion_rate(recorder_h recorder , double rate){
+ if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
+ recorder_s * handle = (recorder_s*)recorder;
+ int ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, "camera-recording-motion-rate" , rate, NULL);
+ return __convert_recorder_error_code(__func__, ret);
+}
+
+int recorder_attr_get_recording_motion_rate(recorder_h recorder , double *rate){
+ if( recorder == NULL || rate == NULL )
+ return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
+
+ recorder_s * handle = (recorder_s*)recorder;
+ int ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, "camera-recording-motion-rate" , rate , NULL);
+ return __convert_recorder_error_code(__func__, ret);
+}
+
+
+
+int recorder_attr_set_slow_motion_rate(recorder_h recorder , double rate){
+ return recorder_attr_set_recording_motion_rate(recorder, rate);
+}
+
+int recorder_attr_get_slow_motion_rate(recorder_h recorder , double *rate){
+ return recorder_attr_get_recording_motion_rate(recorder, rate);
+}
+
+
+int recorder_attr_set_audio_channel(recorder_h recorder, int channel_count){
+ if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
+ recorder_s * handle = (recorder_s*)recorder;
+ int ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_AUDIO_CHANNEL, channel_count, NULL);
+ return __convert_recorder_error_code(__func__, ret);
+}
+
+int recorder_attr_get_audio_channel(recorder_h recorder, int *channel_count){
+ if( recorder == NULL || channel_count == NULL )
+ return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
+
+ recorder_s * handle = (recorder_s*)recorder;
+ int ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_AUDIO_CHANNEL , channel_count, NULL);
+ return __convert_recorder_error_code(__func__, ret);
+}
+
+int recorder_attr_set_recording_orientation(recorder_h recorder, recorder_rotation_e orientation){
+ if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
+ recorder_s * handle = (recorder_s*)recorder;
+ int ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, "camcorder-rotation", orientation, NULL);
+ return __convert_recorder_error_code(__func__, ret);
+}
+
+int recorder_attr_get_recording_orientation(recorder_h recorder, recorder_rotation_e *orientation){
+ if( recorder == NULL || orientation == NULL ) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
+ recorder_s * handle = (recorder_s*)recorder;
+ int ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, "camcorder-rotation" , orientation, NULL);
+ return __convert_recorder_error_code(__func__, ret);
+}
--- /dev/null
+!_TAG_FILE_FORMAT 2 /extended format; --format=1 will not append ;" to lines/
+!_TAG_FILE_SORTED 1 /0=unsorted, 1=sorted, 2=foldcase/
+!_TAG_PROGRAM_AUTHOR Darren Hiebert /dhiebert@users.sourceforge.net/
+!_TAG_PROGRAM_NAME Exuberant Ctags //
+!_TAG_PROGRAM_URL http://ctags.sourceforge.net /official site/
+!_TAG_PROGRAM_VERSION 5.8 //
+-dbg-package debian/rules /^ dh_strip --dbg-package=capi-media-recorder-dbg$/;" m
+-sourcedir debian/rules /^ dh_install --sourcedir=debian\/tmp$/;" m
+CC TC/testcase/Makefile /^CC ?= gcc$/;" m
+CFLAGS TC/testcase/Makefile /^CFLAGS = -I. `pkg-config --cflags $(PKGS)`$/;" m
+CFLAGS debian/rules /^CFLAGS = -Wall -g$/;" m
+CMAKE_BUILD_DIR debian/rules /^CMAKE_BUILD_DIR ?= $(CURDIR)\/cmake_build_tmp$/;" m
+CMAKE_ROOT_DIR debian/rules /^CMAKE_ROOT_DIR ?= $(CURDIR)$/;" m
+C_FILES TC/testcase/Makefile /^C_FILES = $(shell ls *.c)$/;" m
+DLOG_D src/recorder.c 38;" d file:
+DLOG_I src/recorder.c 37;" d file:
+DLOG_V src/recorder.c 36;" d file:
+GmainThread TC/testcase/utc_media_recorder_working.c /^gpointer GmainThread(gpointer data){$/;" f
+LDFLAGS TC/testcase/Makefile /^LDFLAGS = `pkg-config --libs $(PKGS)`$/;" m
+LOG_TAG src/recorder.c 33;" d file:
+LOG_TAG src/recorder.c 35;" d file:
+MY_ASSERT TC/testcase/utc_media_recorder.c 21;" d file:
+MY_ASSERT TC/testcase/utc_media_recorder_working.c 25;" d file:
+PKGS TC/testcase/Makefile /^PKGS = capi-media-camera capi-media-recorder dlog glib-2.0$/;" m
+RECORDER_AUDIO_CODEC_AAC include/recorder.h /^ RECORDER_AUDIO_CODEC_AAC, \/**< AAC codec *\/$/;" e enum:__anon9
+RECORDER_AUDIO_CODEC_AMR include/recorder.h /^ RECORDER_AUDIO_CODEC_AMR, \/**< AMR codec *\/$/;" e enum:__anon9
+RECORDER_AUDIO_DEVICE_MIC include/recorder.h /^ RECORDER_AUDIO_DEVICE_MIC, \/**< Mic device *\/$/;" e enum:__anon11
+RECORDER_AUDIO_DEVICE_MODEM include/recorder.h /^ RECORDER_AUDIO_DEVICE_MODEM, \/**< Modem *\/$/;" e enum:__anon11
+RECORDER_ERROR_CLASS include/recorder.h 30;" d
+RECORDER_ERROR_DEVICE include/recorder.h /^ RECORDER_ERROR_DEVICE = RECORDER_ERROR_CLASS | 0x04, \/**< Device error *\/$/;" e enum:__anon5
+RECORDER_ERROR_INVALID_OPERATION include/recorder.h /^ RECORDER_ERROR_INVALID_OPERATION = TIZEN_ERROR_INVALID_OPERATION, \/**< Internal error *\/$/;" e enum:__anon5
+RECORDER_ERROR_INVALID_PARAMETER include/recorder.h /^ RECORDER_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, \/**< Invalid parameter *\/$/;" e enum:__anon5
+RECORDER_ERROR_INVALID_STATE include/recorder.h /^ RECORDER_ERROR_INVALID_STATE = RECORDER_ERROR_CLASS | 0x02, \/**< Invalid state *\/$/;" e enum:__anon5
+RECORDER_ERROR_NONE include/recorder.h /^ RECORDER_ERROR_NONE = TIZEN_ERROR_OK, \/**< Successful *\/$/;" e enum:__anon5
+RECORDER_ERROR_OUT_OF_MEMORY include/recorder.h /^ RECORDER_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY , \/**< Out of memory *\/$/;" e enum:__anon5
+RECORDER_ERROR_SOUND_POLICY include/recorder.h /^ RECORDER_ERROR_SOUND_POLICY = RECORDER_ERROR_CLASS | 0x06, \/**< Blocked by Audio Session Manager *\/$/;" e enum:__anon5
+RECORDER_FILE_FORMAT_3GP include/recorder.h /^ RECORDER_FILE_FORMAT_3GP, \/**< 3GP file format *\/$/;" e enum:__anon8
+RECORDER_FILE_FORMAT_AMR include/recorder.h /^ RECORDER_FILE_FORMAT_AMR, \/**< AMR file format *\/$/;" e enum:__anon8
+RECORDER_FILE_FORMAT_MP4 include/recorder.h /^ RECORDER_FILE_FORMAT_MP4, \/**< MP4 file format *\/$/;" e enum:__anon8
+RECORDER_RECORDING_LIMIT_FREE_SPACE include/recorder.h /^ RECORDER_RECORDING_LIMIT_FREE_SPACE, \/**< No free space in storage *\/$/;" e enum:__anon7
+RECORDER_RECORDING_LIMIT_SIZE include/recorder.h /^ RECORDER_RECORDING_LIMIT_SIZE, \/**< Size limit (kilo bytes [KB]) of recording file *\/$/;" e enum:__anon7
+RECORDER_RECORDING_LIMIT_TIME include/recorder.h /^ RECORDER_RECORDING_LIMIT_TIME, \/**< Time limit (second) of recording file *\/$/;" e enum:__anon7
+RECORDER_STATE_CREATED include/recorder.h /^ RECORDER_STATE_CREATED, \/**< Recorder is created, but not prepared*\/$/;" e enum:__anon6
+RECORDER_STATE_NONE include/recorder.h /^ RECORDER_STATE_NONE, \/**< Recorder is not created *\/$/;" e enum:__anon6
+RECORDER_STATE_PAUSED include/recorder.h /^ RECORDER_STATE_PAUSED, \/**< Recorder is paused while recording media*\/$/;" e enum:__anon6
+RECORDER_STATE_READY include/recorder.h /^ RECORDER_STATE_READY, \/**< Recorder is ready to record\\n In case of video recoder, preview display will be shown *\/$/;" e enum:__anon6
+RECORDER_STATE_RECORDING include/recorder.h /^ RECORDER_STATE_RECORDING, \/**< Recorder is recording media*\/$/;" e enum:__anon6
+RECORDER_VIDEO_CODEC_H263 include/recorder.h /^ RECORDER_VIDEO_CODEC_H263, \/**< H263 codec *\/$/;" e enum:__anon10
+RECORDER_VIDEO_CODEC_H264 include/recorder.h /^ RECORDER_VIDEO_CODEC_H264, \/**< H264 codec *\/$/;" e enum:__anon10
+RECORDER_VIDEO_CODEC_MPEG4 include/recorder.h /^ RECORDER_VIDEO_CODEC_MPEG4, \/**< MPEG4 codec *\/$/;" e enum:__anon10
+TCS TC/testcase/Makefile /^TCS := $(shell ls -1 *.c | cut -d. -f1)$/;" m
+_CAMERA_EVENT_TYPE_CAPTURE src/recorder.c /^ _CAMERA_EVENT_TYPE_CAPTURE, $/;" e enum:__anon12 file:
+_CAMERA_EVENT_TYPE_CAPTURE_COMPLETE src/recorder.c /^ _CAMERA_EVENT_TYPE_CAPTURE_COMPLETE,$/;" e enum:__anon12 file:
+_CAMERA_EVENT_TYPE_ERROR src/recorder.c /^ _CAMERA_EVENT_TYPE_ERROR, $/;" e enum:__anon12 file:
+_CAMERA_EVENT_TYPE_FOCUS_CHANGE src/recorder.c /^ _CAMERA_EVENT_TYPE_FOCUS_CHANGE, $/;" e enum:__anon12 file:
+_CAMERA_EVENT_TYPE_NUM src/recorder.c /^ _CAMERA_EVENT_TYPE_NUM$/;" e enum:__anon12 file:
+_CAMERA_EVENT_TYPE_PREVIEW src/recorder.c /^ _CAMERA_EVENT_TYPE_PREVIEW,$/;" e enum:__anon12 file:
+_CAMERA_EVENT_TYPE_STATE_CHANGE src/recorder.c /^ _CAMERA_EVENT_TYPE_STATE_CHANGE,$/;" e enum:__anon12 file:
+_RECORDER_EVENT_TYPE_NUM include/recorder_private.h /^ _RECORDER_EVENT_TYPE_NUM$/;" e enum:__anon3
+_RECORDER_EVENT_TYPE_RECORDING_LIMITED include/recorder_private.h /^ _RECORDER_EVENT_TYPE_RECORDING_LIMITED, $/;" e enum:__anon3
+_RECORDER_EVENT_TYPE_RECORDING_STATUS include/recorder_private.h /^ _RECORDER_EVENT_TYPE_RECORDING_STATUS,$/;" e enum:__anon3
+_RECORDER_EVENT_TYPE_STATE_CHANGE include/recorder_private.h /^ _RECORDER_EVENT_TYPE_STATE_CHANGE,$/;" e enum:__anon3
+_RECORDER_TYPE_AUDIO include/recorder_private.h /^ _RECORDER_TYPE_AUDIO= 0,$/;" e enum:__anon4
+_RECORDER_TYPE_VIDEO include/recorder_private.h /^ _RECORDER_TYPE_VIDEO$/;" e enum:__anon4
+__TIZEN_MULTIMEDIA_RECORDER_H__ include/recorder.h 22;" d
+__TIZEN_MULTIMEDIA_RECORDER_PRIVATE_H__ include/recorder_private.h 21;" d
+_audio_encoder_cb TC/testcase/utc_media_recorder_callback.c /^bool _audio_encoder_cb(recorder_audio_codec_e codec , void *user_data){$/;" f
+_audio_encoder_test_cb TC/testcase/utc_media_recorder_working.c /^bool _audio_encoder_test_cb(recorder_audio_codec_e codec, void *user_data){$/;" f
+_audio_encoder_test_cb test/multimedia_recorder_test.c /^bool _audio_encoder_test_cb(recorder_audio_codec_e codec, void *user_data){$/;" f
+_camera_event_e src/recorder.c /^}_camera_event_e;$/;" t typeref:enum:__anon12 file:
+_camera_s src/recorder.c /^typedef struct _camera_s{$/;" s file:
+_convert_recorder_error_code src/recorder.c /^int _convert_recorder_error_code(int code){$/;" f
+_file_format_cb TC/testcase/utc_media_recorder_callback.c /^bool _file_format_cb(recorder_file_format_e format , void *user_data){$/;" f
+_file_format_test_cb TC/testcase/utc_media_recorder_working.c /^bool _file_format_test_cb(recorder_file_format_e format, void *user_data){$/;" f
+_file_format_test_cb test/multimedia_recorder_test.c /^bool _file_format_test_cb(recorder_file_format_e format, void *user_data){$/;" f
+_limit_reached_cb TC/testcase/utc_media_recorder_callback.c /^void _limit_reached_cb(recorder_recording_limit_type_e type, void *user_data){$/;" f
+_recorder_event_e include/recorder_private.h /^}_recorder_event_e;$/;" t typeref:enum:__anon3
+_recorder_s include/recorder_private.h /^typedef struct _recorder_s{$/;" s
+_recorder_state_convert src/recorder.c /^recorder_state_e _recorder_state_convert(MMCamcorderStateType mm_state )$/;" f
+_recorder_type_e include/recorder_private.h /^}_recorder_type_e;$/;" t typeref:enum:__anon4
+_recording_limit_reached_cb test/multimedia_recorder_test.c /^void _recording_limit_reached_cb(recorder_recording_limit_type_e type, void *user_data){$/;" f
+_recording_limited_reached_cb TC/testcase/utc_media_recorder_working.c /^void _recording_limited_reached_cb(recorder_recording_limit_type_e type, void *user_data){$/;" f
+_recording_statis_cb TC/testcase/utc_media_recorder_callback.c /^void _recording_statis_cb(int elapsed_time, int file_size, void *user_data){$/;" f
+_recording_status_cb2 TC/testcase/utc_media_recorder_working.c /^void _recording_status_cb2(int elapsed_time, int file_size, void *user_data){$/;" f
+_recording_status_cb2 test/multimedia_recorder_test.c /^void _recording_status_cb2(int elapsed_time, int file_size, void *user_data){$/;" f
+_recording_status_test_cb TC/testcase/utc_media_recorder_working.c /^void _recording_status_test_cb(int elapsed_time, int file_size, void *user_data){$/;" f
+_recording_status_test_cb test/multimedia_recorder_test.c /^void _recording_status_test_cb(int elapsed_time, int file_size, void *user_data){$/;" f
+_state_change_test_cb TC/testcase/utc_media_recorder_working.c /^void _state_change_test_cb(recorder_state_e previous, recorder_state_e current, bool by_asm, void *user_data){$/;" f
+_state_change_test_cb test/multimedia_recorder_test.c /^void _state_change_test_cb(recorder_state_e previous, recorder_state_e current, bool by_asm, void *user_data){$/;" f
+_state_changed_cb TC/testcase/utc_media_recorder_callback.c /^void _state_changed_cb(recorder_state_e previous , recorder_state_e current , bool by_asm, void *user_data)$/;" f
+_video_encoder_cb TC/testcase/utc_media_recorder_callback.c /^bool _video_encoder_cb(recorder_video_codec_e codec , void *user_data){$/;" f
+_video_encoder_test_cb TC/testcase/utc_media_recorder_working.c /^bool _video_encoder_test_cb(recorder_video_codec_e codec, void *user_data){$/;" f
+_video_encoder_test_cb test/multimedia_recorder_test.c /^bool _video_encoder_test_cb(recorder_video_codec_e codec, void *user_data){$/;" f
+audio_encoder_test TC/testcase/utc_media_recorder_working.c /^int audio_encoder_test(recorder_h recorder){$/;" f
+audio_encoder_test test/multimedia_recorder_test.c /^int audio_encoder_test(recorder_h recorder){$/;" f
+audioencoder_test_fail TC/testcase/utc_media_recorder_working.c /^int audioencoder_test_fail = 0;$/;" v
+audioencoder_test_fail test/multimedia_recorder_test.c /^int audioencoder_test_fail = 0;$/;" v
+camera include/recorder_private.h /^ camera_h camera;$/;" m struct:_recorder_s
+camera_s src/recorder.c /^} camera_s;$/;" t typeref:struct:_camera_s file:
+cleanup TC/testcase/utc_media_recorder.c /^static void cleanup(void)$/;" f file:
+cleanup TC/testcase/utc_media_recorder_callback.c /^static void cleanup(void)$/;" f file:
+cleanup TC/testcase/utc_media_recorder_lifecycle.c /^static void cleanup(void)$/;" f file:
+cleanup TC/testcase/utc_media_recorder_working.c /^static void cleanup(void)$/;" f file:
+display_handle src/recorder.c /^ unsigned long display_handle;$/;" m struct:_camera_s file:
+elapsed_time TC/testcase/utc_media_recorder_working.c /^ int elapsed_time;$/;" m struct:__anon2 file:
+elapsed_time test/multimedia_recorder_test.c /^ int elapsed_time;$/;" m struct:__anon14 file:
+event_thread TC/testcase/utc_media_recorder_working.c /^static GThread *event_thread;$/;" v file:
+file_size TC/testcase/utc_media_recorder_working.c /^ int file_size;$/;" m struct:__anon2 file:
+file_size test/multimedia_recorder_test.c /^ int file_size;$/;" m struct:__anon14 file:
+fileformat_test TC/testcase/utc_media_recorder_working.c /^int fileformat_test(recorder_h recorder){$/;" f
+fileformat_test test/multimedia_recorder_test.c /^int fileformat_test(recorder_h recorder){$/;" f
+fileformat_test_fail TC/testcase/utc_media_recorder_working.c /^int fileformat_test_fail = 0;$/;" v
+fileformat_test_fail test/multimedia_recorder_test.c /^int fileformat_test_fail = 0;$/;" v
+g_mainloop TC/testcase/utc_media_recorder_working.c /^static GMainLoop *g_mainloop = NULL;$/;" v file:
+iscalled TC/testcase/utc_media_recorder_working.c /^ bool iscalled;$/;" m struct:__anon1 file:
+iscalled test/multimedia_recorder_test.c /^ bool iscalled;$/;" m struct:__anon13 file:
+ispaused TC/testcase/utc_media_recorder_working.c /^ bool ispaused;$/;" m struct:__anon1 file:
+ispaused test/multimedia_recorder_test.c /^ bool ispaused;$/;" m struct:__anon13 file:
+isprepare test/multimedia_recorder_test.c /^ bool isprepare;$/;" m struct:__anon13 file:
+isready TC/testcase/utc_media_recorder_working.c /^ bool isready;$/;" m struct:__anon1 file:
+isrecording TC/testcase/utc_media_recorder_working.c /^ bool isrecording;$/;" m struct:__anon1 file:
+isrecording test/multimedia_recorder_test.c /^ bool isrecording;$/;" m struct:__anon13 file:
+mEvasWindow test/multimedia_recorder_test.c /^Evas_Object* mEvasWindow;$/;" v
+mXwindow test/multimedia_recorder_test.c /^Ecore_X_Window mXwindow; $/;" v
+main test/multimedia_recorder_test.c /^int main(int argc, char ** argv)$/;" f
+mm_handle include/recorder_private.h /^ MMHandleType mm_handle;$/;" m struct:_recorder_s
+mm_handle src/recorder.c /^ MMHandleType mm_handle;$/;" m struct:_camera_s file:
+mm_recorder_msg_cb src/recorder.c /^int mm_recorder_msg_cb(int message, void *param, void *user_data){$/;" f
+mm_test test/multimedia_recorder_test.c /^int mm_test(){$/;" f
+origin_preview_format include/recorder_private.h /^ int origin_preview_format;$/;" m struct:_recorder_s
+preview_win TC/testcase/utc_media_recorder_working.c /^int preview_win = 0; $/;" v
+preview_win test/multimedia_recorder_test.c /^Ecore_X_Window preview_win;$/;" v
+record_state_cb TC/testcase/utc_media_recorder_working.c /^void record_state_cb(recorder_state_e previous , recorder_state_e current , int by_asm, void *user_data){$/;" f
+record_state_cb test/multimedia_recorder_test.c /^bool record_state_cb(recorder_state_e previous , recorder_state_e current , int by_asm, void *user_data){$/;" f
+recorder TC/testcase/utc_media_recorder.c /^recorder_h recorder;$/;" v
+recorder TC/testcase/utc_media_recorder_callback.c /^recorder_h recorder;$/;" v
+recorder_attr_get_audio_device src/recorder.c /^int recorder_attr_get_audio_device(recorder_h recorder , recorder_audio_device_e *device){$/;" f
+recorder_attr_get_audio_encoder_bitrate src/recorder.c /^int recorder_attr_get_audio_encoder_bitrate(recorder_h recorder, int *bitrate){$/;" f
+recorder_attr_get_audio_samplerate src/recorder.c /^int recorder_attr_get_audio_samplerate(recorder_h recorder, int *samplerate){$/;" f
+recorder_attr_get_audio_volume src/recorder.c /^int recorder_attr_get_audio_volume(recorder_h recorder, double *volume){$/;" f
+recorder_attr_get_size_limit src/recorder.c /^int recorder_attr_get_size_limit(recorder_h recorder, int *kbyte){$/;" f
+recorder_attr_get_time_limit src/recorder.c /^int recorder_attr_get_time_limit(recorder_h recorder, int *second){$/;" f
+recorder_attr_get_video_encoder_bitrate src/recorder.c /^int recorder_attr_get_video_encoder_bitrate(recorder_h recorder, int *bitrate){$/;" f
+recorder_attr_set_audio_device src/recorder.c /^int recorder_attr_set_audio_device(recorder_h recorder , recorder_audio_device_e device){$/;" f
+recorder_attr_set_audio_encoder_bitrate src/recorder.c /^int recorder_attr_set_audio_encoder_bitrate(recorder_h recorder, int bitrate){$/;" f
+recorder_attr_set_audio_samplerate src/recorder.c /^int recorder_attr_set_audio_samplerate(recorder_h recorder, int samplerate){$/;" f
+recorder_attr_set_audio_volume src/recorder.c /^int recorder_attr_set_audio_volume(recorder_h recorder, double volume){$/;" f
+recorder_attr_set_size_limit src/recorder.c /^int recorder_attr_set_size_limit(recorder_h recorder, int kbyte){$/;" f
+recorder_attr_set_time_limit src/recorder.c /^int recorder_attr_set_time_limit(recorder_h recorder, int second){$/;" f
+recorder_attr_set_video_encoder_bitrate src/recorder.c /^int recorder_attr_set_video_encoder_bitrate(recorder_h recorder, int bitrate){$/;" f
+recorder_attribute_test test/multimedia_recorder_test.c /^int recorder_attribute_test(){$/;" f
+recorder_audio_codec_e include/recorder.h /^} recorder_audio_codec_e;$/;" t typeref:enum:__anon9
+recorder_audio_device_e include/recorder.h /^} recorder_audio_device_e;$/;" t typeref:enum:__anon11
+recorder_cancel src/recorder.c /^int recorder_cancel( recorder_h recorder){$/;" f
+recorder_commit src/recorder.c /^int recorder_commit( recorder_h recorder){$/;" f
+recorder_create_audiorecorder src/recorder.c /^int recorder_create_audiorecorder( recorder_h* recorder){$/;" f
+recorder_create_videorecorder src/recorder.c /^int recorder_create_videorecorder( camera_h camera, recorder_h* recorder){$/;" f
+recorder_destroy src/recorder.c /^int recorder_destroy( recorder_h recorder){$/;" f
+recorder_encoder_test test/multimedia_recorder_test.c /^int recorder_encoder_test(){$/;" f
+recorder_error_e include/recorder.h /^} recorder_error_e;$/;" t typeref:enum:__anon5
+recorder_file_format_e include/recorder.h /^} recorder_file_format_e;$/;" t typeref:enum:__anon8
+recorder_foreach_supported_audio_encoder src/recorder.c /^int recorder_foreach_supported_audio_encoder(recorder_h recorder, recorder_supported_audio_encoder_cb foreach_cb , void *user_data){$/;" f
+recorder_foreach_supported_file_format src/recorder.c /^int recorder_foreach_supported_file_format(recorder_h recorder, recorder_supported_file_format_cb foreach_cb , void *user_data){$/;" f
+recorder_foreach_supported_video_encoder src/recorder.c /^int recorder_foreach_supported_video_encoder(recorder_h recorder, recorder_supported_video_encoder_cb foreach_cb , void *user_data){$/;" f
+recorder_get_audio_encoder src/recorder.c /^int recorder_get_audio_encoder(recorder_h recorder, recorder_audio_codec_e *codec){$/;" f
+recorder_get_file_format src/recorder.c /^int recorder_get_file_format(recorder_h recorder, recorder_file_format_e *format){$/;" f
+recorder_get_filename src/recorder.c /^int recorder_get_filename(recorder_h recorder, char **filename){$/;" f
+recorder_get_state src/recorder.c /^int recorder_get_state(recorder_h recorder, recorder_state_e * state){$/;" f
+recorder_get_video_encoder src/recorder.c /^int recorder_get_video_encoder(recorder_h recorder, recorder_video_codec_e *codec){$/;" f
+recorder_h include/recorder.h /^typedef struct recorder_s *recorder_h;$/;" t typeref:struct:recorder_s
+recorder_limit_cb_test test/multimedia_recorder_test.c /^int recorder_limit_cb_test(){$/;" f
+recorder_pause src/recorder.c /^int recorder_pause( recorder_h recorder){$/;" f
+recorder_prepare src/recorder.c /^int recorder_prepare( recorder_h recorder){$/;" f
+recorder_recoding_status_cb_test test/multimedia_recorder_test.c /^int recorder_recoding_status_cb_test(){$/;" f
+recorder_recording_limit_reached_cb include/recorder.h /^typedef void (*recorder_recording_limit_reached_cb)(recorder_recording_limit_type_e type, void *user_data);$/;" t
+recorder_recording_limit_type_e include/recorder.h /^} recorder_recording_limit_type_e;$/;" t typeref:enum:__anon7
+recorder_recording_status_cb include/recorder.h /^typedef void (*recorder_recording_status_cb)(int elapsed_time, int file_size, void *user_data);$/;" t
+recorder_s include/recorder_private.h /^} recorder_s;$/;" t typeref:struct:_recorder_s
+recorder_set_audio_encoder src/recorder.c /^int recorder_set_audio_encoder(recorder_h recorder, recorder_audio_codec_e codec){$/;" f
+recorder_set_file_format src/recorder.c /^int recorder_set_file_format(recorder_h recorder, recorder_file_format_e format){$/;" f
+recorder_set_filename src/recorder.c /^int recorder_set_filename(recorder_h recorder, const char *filename){$/;" f
+recorder_set_recording_limit_reached_cb src/recorder.c /^int recorder_set_recording_limit_reached_cb(recorder_h recorder, recorder_recording_limit_reached_cb callback, void* user_data){$/;" f
+recorder_set_recording_status_cb src/recorder.c /^int recorder_set_recording_status_cb(recorder_h recorder, recorder_recording_status_cb callback, void* user_data){$/;" f
+recorder_set_state_changed_cb src/recorder.c /^int recorder_set_state_changed_cb(recorder_h recorder, recorder_state_changed_cb callback, void* user_data){$/;" f
+recorder_set_video_encoder src/recorder.c /^int recorder_set_video_encoder(recorder_h recorder, recorder_video_codec_e codec){$/;" f
+recorder_start src/recorder.c /^int recorder_start( recorder_h recorder){$/;" f
+recorder_state_change_test test/multimedia_recorder_test.c /^int recorder_state_change_test(){$/;" f
+recorder_state_changed_cb include/recorder.h /^typedef void (*recorder_state_changed_cb)(recorder_state_e previous , recorder_state_e current , bool by_policy, void *user_data);$/;" t
+recorder_state_e include/recorder.h /^} recorder_state_e;$/;" t typeref:enum:__anon6
+recorder_supported_audio_encoder_cb include/recorder.h /^typedef bool (*recorder_supported_audio_encoder_cb)(recorder_audio_codec_e codec, void *user_data);$/;" t
+recorder_supported_file_format_cb include/recorder.h /^typedef bool (*recorder_supported_file_format_cb)(recorder_file_format_e format, void *user_data);$/;" t
+recorder_supported_video_encoder_cb include/recorder.h /^typedef bool (*recorder_supported_video_encoder_cb)(recorder_video_codec_e codec, void *user_data);$/;" t
+recorder_unprepare src/recorder.c /^int recorder_unprepare( recorder_h recorder){$/;" f
+recorder_unset_recording_limit_reached_cb src/recorder.c /^int recorder_unset_recording_limit_reached_cb(recorder_h recorder){$/;" f
+recorder_unset_recording_status_cb src/recorder.c /^int recorder_unset_recording_status_cb(recorder_h recorder){$/;" f
+recorder_unset_state_changed_cb src/recorder.c /^int recorder_unset_state_changed_cb(recorder_h recorder){$/;" f
+recorder_video_codec_e include/recorder.h /^} recorder_video_codec_e;$/;" t typeref:enum:__anon10
+recording_audio_device_test TC/testcase/utc_media_recorder_working.c /^int recording_audio_device_test(recorder_h recorder)$/;" f
+recording_audio_device_test test/multimedia_recorder_test.c /^int recording_audio_device_test(recorder_h recorder)$/;" f
+recording_audio_encoder_bitrate_test TC/testcase/utc_media_recorder_working.c /^int recording_audio_encoder_bitrate_test(recorder_h recorder){$/;" f
+recording_audio_encoder_bitrate_test test/multimedia_recorder_test.c /^int recording_audio_encoder_bitrate_test(recorder_h recorder){$/;" f
+recording_limit_size_test TC/testcase/utc_media_recorder_working.c /^int recording_limit_size_test(recorder_h recorder){$/;" f
+recording_result TC/testcase/utc_media_recorder_working.c /^} recording_result;$/;" t typeref:struct:__anon2 file:
+recording_result test/multimedia_recorder_test.c /^} recording_result;$/;" t typeref:struct:__anon14 file:
+recording_samplerate_test TC/testcase/utc_media_recorder_working.c /^int recording_samplerate_test(recorder_h recorder){$/;" f
+recording_samplerate_test test/multimedia_recorder_test.c /^int recording_samplerate_test(recorder_h recorder){$/;" f
+recording_size_limit_test test/multimedia_recorder_test.c /^int recording_size_limit_test(recorder_h recorder){$/;" f
+recording_time_limit_test TC/testcase/utc_media_recorder_working.c /^int recording_time_limit_test(recorder_h recorder){$/;" f
+recording_time_limit_test test/multimedia_recorder_test.c /^int recording_time_limit_test(recorder_h recorder){$/;" f
+recording_video_encoder_bitrate_test TC/testcase/utc_media_recorder_working.c /^int recording_video_encoder_bitrate_test(recorder_h recorder){$/;" f
+recording_video_encoder_bitrate_test test/multimedia_recorder_test.c /^int recording_video_encoder_bitrate_test(recorder_h recorder){$/;" f
+startup TC/testcase/utc_media_recorder.c /^static void startup(void)$/;" f file:
+startup TC/testcase/utc_media_recorder_callback.c /^static void startup(void)$/;" f file:
+startup TC/testcase/utc_media_recorder_lifecycle.c /^static void startup(void)$/;" f file:
+startup TC/testcase/utc_media_recorder_working.c /^static void startup(void)$/;" f file:
+state TC/testcase/utc_media_recorder_working.c /^ recorder_state_e state;$/;" m struct:__anon1 file:
+state include/recorder_private.h /^ int state;$/;" m struct:_recorder_s
+state src/recorder.c /^ int state;$/;" m struct:_camera_s file:
+state test/multimedia_recorder_test.c /^ recorder_state_e state;$/;" m struct:__anon13 file:
+state_change_data TC/testcase/utc_media_recorder_working.c /^} state_change_data;$/;" t typeref:struct:__anon1 file:
+state_change_data test/multimedia_recorder_test.c /^} state_change_data;$/;" t typeref:struct:__anon13 file:
+test_main test/multimedia_recorder_test.c /^void* test_main(void *arg){$/;" f
+tet_cleanup TC/testcase/utc_media_recorder.c /^void (*tet_cleanup)(void) = cleanup;$/;" v
+tet_cleanup TC/testcase/utc_media_recorder_callback.c /^void (*tet_cleanup)(void) = cleanup;$/;" v
+tet_cleanup TC/testcase/utc_media_recorder_lifecycle.c /^void (*tet_cleanup)(void) = cleanup;$/;" v
+tet_cleanup TC/testcase/utc_media_recorder_working.c /^void (*tet_cleanup)(void) = cleanup;$/;" v
+tet_startup TC/testcase/utc_media_recorder.c /^void (*tet_startup)(void) = startup;$/;" v
+tet_startup TC/testcase/utc_media_recorder_callback.c /^void (*tet_startup)(void) = startup;$/;" v
+tet_startup TC/testcase/utc_media_recorder_lifecycle.c /^void (*tet_startup)(void) = startup;$/;" v
+tet_startup TC/testcase/utc_media_recorder_working.c /^void (*tet_startup)(void) = startup;$/;" v
+tet_testlist TC/testcase/utc_media_recorder.c /^struct tet_testlist tet_testlist[] = { $/;" v typeref:struct:tet_testlist
+tet_testlist TC/testcase/utc_media_recorder_callback.c /^struct tet_testlist tet_testlist[] = {$/;" v typeref:struct:tet_testlist
+tet_testlist TC/testcase/utc_media_recorder_lifecycle.c /^struct tet_testlist tet_testlist[] = {$/;" v typeref:struct:tet_testlist
+tet_testlist TC/testcase/utc_media_recorder_working.c /^struct tet_testlist tet_testlist[] = {$/;" v typeref:struct:tet_testlist
+type include/recorder_private.h /^ _recorder_type_e type;$/;" m struct:_recorder_s
+user_cb include/recorder_private.h /^ void* user_cb[_RECORDER_EVENT_TYPE_NUM];$/;" m struct:_recorder_s
+user_cb src/recorder.c /^ void* user_cb[_CAMERA_EVENT_TYPE_NUM];$/;" m struct:_camera_s file:
+user_data include/recorder_private.h /^ void* user_data[_RECORDER_EVENT_TYPE_NUM];$/;" m struct:_recorder_s
+user_data src/recorder.c /^ void* user_data[_CAMERA_EVENT_TYPE_NUM];$/;" m struct:_camera_s file:
+utc_media_recorder_attr_get_audio_device_n TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_attr_get_audio_device_n(void)$/;" f file:
+utc_media_recorder_attr_get_audio_device_p TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_attr_get_audio_device_p(void)$/;" f file:
+utc_media_recorder_attr_get_audio_encoder_bitrate_n TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_attr_get_audio_encoder_bitrate_n(void)$/;" f file:
+utc_media_recorder_attr_get_audio_encoder_bitrate_p TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_attr_get_audio_encoder_bitrate_p(void)$/;" f file:
+utc_media_recorder_attr_get_audio_samplerate_n TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_attr_get_audio_samplerate_n(void)$/;" f file:
+utc_media_recorder_attr_get_audio_samplerate_p TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_attr_get_audio_samplerate_p(void)$/;" f file:
+utc_media_recorder_attr_get_size_limit_n TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_attr_get_size_limit_n(void)$/;" f file:
+utc_media_recorder_attr_get_size_limit_p TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_attr_get_size_limit_p(void)$/;" f file:
+utc_media_recorder_attr_get_time_limit_n TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_attr_get_time_limit_n(void)$/;" f file:
+utc_media_recorder_attr_get_time_limit_p TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_attr_get_time_limit_p(void)$/;" f file:
+utc_media_recorder_attr_get_video_encoder_bitrate_n TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_attr_get_video_encoder_bitrate_n(void)$/;" f file:
+utc_media_recorder_attr_get_video_encoder_bitrate_p TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_attr_get_video_encoder_bitrate_p(void)$/;" f file:
+utc_media_recorder_attr_set_audio_device_n TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_attr_set_audio_device_n(void)$/;" f file:
+utc_media_recorder_attr_set_audio_device_p TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_attr_set_audio_device_p(void)$/;" f file:
+utc_media_recorder_attr_set_audio_encoder_bitrate_n TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_attr_set_audio_encoder_bitrate_n(void)$/;" f file:
+utc_media_recorder_attr_set_audio_encoder_bitrate_p TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_attr_set_audio_encoder_bitrate_p(void)$/;" f file:
+utc_media_recorder_attr_set_audio_samplerate_n TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_attr_set_audio_samplerate_n(void)$/;" f file:
+utc_media_recorder_attr_set_audio_samplerate_p TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_attr_set_audio_samplerate_p(void)$/;" f file:
+utc_media_recorder_attr_set_size_limit_n TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_attr_set_size_limit_n(void)$/;" f file:
+utc_media_recorder_attr_set_size_limit_p TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_attr_set_size_limit_p(void)$/;" f file:
+utc_media_recorder_attr_set_time_limit_n TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_attr_set_time_limit_n(void)$/;" f file:
+utc_media_recorder_attr_set_time_limit_p TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_attr_set_time_limit_p(void)$/;" f file:
+utc_media_recorder_attr_set_video_encoder_bitrate_n TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_attr_set_video_encoder_bitrate_n(void)$/;" f file:
+utc_media_recorder_attr_set_video_encoder_bitrate_p TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_attr_set_video_encoder_bitrate_p(void)$/;" f file:
+utc_media_recorder_attribute_test TC/testcase/utc_media_recorder_working.c /^void utc_media_recorder_attribute_test(void){$/;" f
+utc_media_recorder_cancel_n TC/testcase/utc_media_recorder_lifecycle.c /^static void utc_media_recorder_cancel_n(void)$/;" f file:
+utc_media_recorder_cancel_p TC/testcase/utc_media_recorder_lifecycle.c /^static void utc_media_recorder_cancel_p(void)$/;" f file:
+utc_media_recorder_commit_n TC/testcase/utc_media_recorder_lifecycle.c /^static void utc_media_recorder_commit_n(void)$/;" f file:
+utc_media_recorder_commit_p TC/testcase/utc_media_recorder_lifecycle.c /^static void utc_media_recorder_commit_p(void)$/;" f file:
+utc_media_recorder_create_audiorecorder_n TC/testcase/utc_media_recorder_lifecycle.c /^static void utc_media_recorder_create_audiorecorder_n(void)$/;" f file:
+utc_media_recorder_create_audiorecorder_p TC/testcase/utc_media_recorder_lifecycle.c /^static void utc_media_recorder_create_audiorecorder_p(void)$/;" f file:
+utc_media_recorder_create_videorecorder_n TC/testcase/utc_media_recorder_lifecycle.c /^static void utc_media_recorder_create_videorecorder_n(void)$/;" f file:
+utc_media_recorder_create_videorecorder_p TC/testcase/utc_media_recorder_lifecycle.c /^static void utc_media_recorder_create_videorecorder_p(void)$/;" f file:
+utc_media_recorder_destroy_n TC/testcase/utc_media_recorder_lifecycle.c /^static void utc_media_recorder_destroy_n(void)$/;" f file:
+utc_media_recorder_destroy_p TC/testcase/utc_media_recorder_lifecycle.c /^static void utc_media_recorder_destroy_p(void)$/;" f file:
+utc_media_recorder_foreach_supported_audio_encoder_n TC/testcase/utc_media_recorder_callback.c /^static void utc_media_recorder_foreach_supported_audio_encoder_n(void)$/;" f file:
+utc_media_recorder_foreach_supported_audio_encoder_p TC/testcase/utc_media_recorder_callback.c /^static void utc_media_recorder_foreach_supported_audio_encoder_p(void)$/;" f file:
+utc_media_recorder_foreach_supported_file_format_n TC/testcase/utc_media_recorder_callback.c /^static void utc_media_recorder_foreach_supported_file_format_n(void)$/;" f file:
+utc_media_recorder_foreach_supported_file_format_p TC/testcase/utc_media_recorder_callback.c /^static void utc_media_recorder_foreach_supported_file_format_p(void)$/;" f file:
+utc_media_recorder_foreach_supported_video_encoder_n TC/testcase/utc_media_recorder_callback.c /^static void utc_media_recorder_foreach_supported_video_encoder_n(void)$/;" f file:
+utc_media_recorder_foreach_supported_video_encoder_p TC/testcase/utc_media_recorder_callback.c /^static void utc_media_recorder_foreach_supported_video_encoder_p(void)$/;" f file:
+utc_media_recorder_get_audio_encoder_n TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_get_audio_encoder_n(void)$/;" f file:
+utc_media_recorder_get_audio_encoder_p TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_get_audio_encoder_p(void)$/;" f file:
+utc_media_recorder_get_file_format_n TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_get_file_format_n(void)$/;" f file:
+utc_media_recorder_get_file_format_p TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_get_file_format_p(void)$/;" f file:
+utc_media_recorder_get_video_encoder_n TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_get_video_encoder_n(void)$/;" f file:
+utc_media_recorder_get_video_encoder_p TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_get_video_encoder_p(void)$/;" f file:
+utc_media_recorder_limit_cb_test TC/testcase/utc_media_recorder_working.c /^void utc_media_recorder_limit_cb_test(void){$/;" f
+utc_media_recorder_pause_n TC/testcase/utc_media_recorder_lifecycle.c /^static void utc_media_recorder_pause_n(void)$/;" f file:
+utc_media_recorder_pause_p TC/testcase/utc_media_recorder_lifecycle.c /^static void utc_media_recorder_pause_p(void)$/;" f file:
+utc_media_recorder_ready_n TC/testcase/utc_media_recorder_lifecycle.c /^static void utc_media_recorder_ready_n(void)$/;" f file:
+utc_media_recorder_ready_p TC/testcase/utc_media_recorder_lifecycle.c /^static void utc_media_recorder_ready_p(void)$/;" f file:
+utc_media_recorder_recoding_status_cb_test TC/testcase/utc_media_recorder_working.c /^void utc_media_recorder_recoding_status_cb_test(void){$/;" f
+utc_media_recorder_set_audio_encoder_n TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_set_audio_encoder_n(void)$/;" f file:
+utc_media_recorder_set_audio_encoder_p TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_set_audio_encoder_p(void)$/;" f file:
+utc_media_recorder_set_file_format_n TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_set_file_format_n(void)$/;" f file:
+utc_media_recorder_set_file_format_p TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_set_file_format_p(void)$/;" f file:
+utc_media_recorder_set_filename_n TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_set_filename_n(void)$/;" f file:
+utc_media_recorder_set_filename_p TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_set_filename_p(void)$/;" f file:
+utc_media_recorder_set_recording_limit_reached_cb_n TC/testcase/utc_media_recorder_callback.c /^static void utc_media_recorder_set_recording_limit_reached_cb_n(void)$/;" f file:
+utc_media_recorder_set_recording_limit_reached_cb_p TC/testcase/utc_media_recorder_callback.c /^static void utc_media_recorder_set_recording_limit_reached_cb_p(void)$/;" f file:
+utc_media_recorder_set_recording_status_cb_n TC/testcase/utc_media_recorder_callback.c /^static void utc_media_recorder_set_recording_status_cb_n(void)$/;" f file:
+utc_media_recorder_set_recording_status_cb_p TC/testcase/utc_media_recorder_callback.c /^static void utc_media_recorder_set_recording_status_cb_p(void)$/;" f file:
+utc_media_recorder_set_state_changed_cb_n TC/testcase/utc_media_recorder_callback.c /^static void utc_media_recorder_set_state_changed_cb_n(void)$/;" f file:
+utc_media_recorder_set_state_changed_cb_p TC/testcase/utc_media_recorder_callback.c /^static void utc_media_recorder_set_state_changed_cb_p(void)$/;" f file:
+utc_media_recorder_set_video_encoder_n TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_set_video_encoder_n(void)$/;" f file:
+utc_media_recorder_set_video_encoder_p TC/testcase/utc_media_recorder.c /^static void utc_media_recorder_set_video_encoder_p(void)$/;" f file:
+utc_media_recorder_start_n TC/testcase/utc_media_recorder_lifecycle.c /^static void utc_media_recorder_start_n(void)$/;" f file:
+utc_media_recorder_start_p TC/testcase/utc_media_recorder_lifecycle.c /^static void utc_media_recorder_start_p(void)$/;" f file:
+utc_media_recorder_state_change_test TC/testcase/utc_media_recorder_working.c /^void utc_media_recorder_state_change_test(void){$/;" f
+utc_media_recorder_unready_n TC/testcase/utc_media_recorder_lifecycle.c /^static void utc_media_recorder_unready_n(void)$/;" f file:
+utc_media_recorder_unready_p TC/testcase/utc_media_recorder_lifecycle.c /^static void utc_media_recorder_unready_p(void)$/;" f file:
+utc_media_recorder_unset_recording_limit_reached_cb_n TC/testcase/utc_media_recorder_callback.c /^static void utc_media_recorder_unset_recording_limit_reached_cb_n(void)$/;" f file:
+utc_media_recorder_unset_recording_limit_reached_cb_p TC/testcase/utc_media_recorder_callback.c /^static void utc_media_recorder_unset_recording_limit_reached_cb_p(void)$/;" f file:
+utc_media_recorder_unset_recording_status_cb_n TC/testcase/utc_media_recorder_callback.c /^static void utc_media_recorder_unset_recording_status_cb_n(void)$/;" f file:
+utc_media_recorder_unset_recording_status_cb_p TC/testcase/utc_media_recorder_callback.c /^static void utc_media_recorder_unset_recording_status_cb_p(void)$/;" f file:
+utc_media_recorder_unset_state_changed_cb_n TC/testcase/utc_media_recorder_callback.c /^static void utc_media_recorder_unset_state_changed_cb_n(void)$/;" f file:
+utc_media_recorder_unset_state_changed_cb_p TC/testcase/utc_media_recorder_callback.c /^static void utc_media_recorder_unset_state_changed_cb_p(void)$/;" f file:
+video_encoder_test TC/testcase/utc_media_recorder_working.c /^int video_encoder_test(recorder_h recorder){$/;" f
+video_encoder_test test/multimedia_recorder_test.c /^int video_encoder_test(recorder_h recorder){$/;" f
+video_recorder_test test/multimedia_recorder_test.c /^int video_recorder_test(){$/;" f
+videoencoder_test_fail TC/testcase/utc_media_recorder_working.c /^int videoencoder_test_fail = 0;$/;" v
+videoencoder_test_fail test/multimedia_recorder_test.c /^int videoencoder_test_fail = 0;$/;" v
SET(fw_test "${fw_name}-test")
INCLUDE(FindPkgConfig)
-pkg_check_modules(${fw_test} REQUIRED mm-camcorder appcore-efl elementary evas capi-media-camera)
+pkg_check_modules(${fw_test} REQUIRED mm-camcorder elementary evas capi-media-camera)
FOREACH(flag ${${fw_test}_CFLAGS})
SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
MESSAGE(${flag})
camera_create(CAMERA_DEVICE_CAMERA0 , &camera);
recorder_create_videorecorder(camera, &recorder);
camera_set_display(camera,CAMERA_DISPLAY_TYPE_X11,GET_DISPLAY(preview_win));
- camera_set_x11_display_rotation(camera, CAMERA_DISPLAY_ROTATION_270);
+ camera_set_x11_display_rotation(camera, CAMERA_ROTATION_270);
//camera_set_preview_resolution(camera, 320, 240);
camera_attr_set_preview_fps(camera, CAMERA_ATTR_FPS_AUTO);
ret = recorder_set_file_format(recorder,RECORDER_FILE_FORMAT_MP4);
ret+=camera_create(CAMERA_DEVICE_CAMERA0,&camera);
- ret+=camera_set_x11_display_rotation(camera, CAMERA_DISPLAY_ROTATION_270);
+ ret+=camera_set_x11_display_rotation(camera, CAMERA_ROTATION_270);
ret+=camera_set_display(camera, CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(preview_win));
return ret;
}
+ Eina_Bool print_audio_level(void *data){
+ recorder_h recorder = (recorder_h)data;
+ if( recorder ){
+ double level;
+ recorder_get_audio_level(recorder,&level);
+ printf("%g\n", level);
+ }
+ return 1;
+}
+
+int audio_level_test(){
+ recorder_h recorder;
+ recorder_create_audiorecorder(&recorder);
+ recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AMR);
+ recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_AMR);
+ recorder_set_filename(recorder, "/mnt/nfs/test.amr");
+
+ recorder_prepare(recorder);
+ recorder_start(recorder);
+ ecore_timer_add(0.1, print_audio_level, recorder);
+ sleep(2);
+ return 0;
+}
+
+void _camera_state_changed_cb(camera_state_e previous, camera_state_e current,bool by_policy, void *user_data){
+ printf("camera state changed %d -> %d\n", previous , current);
+}
+
+void _recorder_state_changed_cb(recorder_state_e previous , recorder_state_e current , bool by_policy, void *user_data){
+ printf("recorder state changed %d -> %d\n", previous , current);
+}
+
+int slow_motion_test(){
+ camera_h camera;
+ recorder_h recorder;
+ int ret;
+ ret = camera_create(CAMERA_DEVICE_CAMERA0, &camera);
+ printf("camera_create ret = %x\n", ret);
+ camera_set_state_changed_cb(camera, _camera_state_changed_cb, NULL);
+ ret = recorder_create_videorecorder(camera, &recorder);
+ printf("recorder_create_videorecorder ret = %x\n", ret);
+ ret = recorder_set_state_changed_cb(recorder, _recorder_state_changed_cb , NULL);
+ ret = recorder_set_filename(recorder, "/mnt/nfs/test.3gp");
+ printf("recorder_set_filename ret = %x\n", ret);
+ ret = recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AAC);
+ printf("recorder_set_audio_encoder ret = %x\n", ret);
+ ret = recorder_set_video_encoder(recorder, RECORDER_VIDEO_CODEC_MPEG4);
+ printf("recorder_set_video_encoder ret = %x\n", ret);
+ ret = recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_3GP);
+ printf("recorder_set_file_format ret = %x\n", ret);
+ ret = recorder_attr_set_slow_motion_rate(recorder, 0.5);
+ printf("recorder_attr_set_slow_motion_rate ret = %x\n", ret);
+ ret = recorder_prepare(recorder);
+ printf("recorder_prepare ret = %x\n", ret);
+ ret = recorder_start(recorder);
+ printf("recorder_start ret = %x\n", ret);
+ sleep(10);
+ ret = recorder_commit(recorder);
+ printf("recorder_commit ret = %x\n", ret);
+ ret = recorder_unprepare(recorder);
+ printf("recorder_unprepare ret = %x\n", ret);
+ ret = recorder_destroy(recorder);
+ printf("recorder_destroy ret = %x\n", ret);
+ return 0;
+}
+
+void _capturing_cb(camera_image_data_s* image, camera_image_data_s* postview, camera_image_data_s* thumbnail, void *user_data){
+ printf("capturing callback!\n");
+}
+
+void _capture_completed_cb(void *user_data){
+ printf("capture completed callback\n");
+}
+
+
+int recording_capture_test(){
+ camera_h camera;
+ recorder_h recorder;
+ int ret;
+ ret = camera_create(CAMERA_DEVICE_CAMERA0, &camera);
+ printf("camera_create ret = %x\n", ret);
+ camera_set_state_changed_cb(camera, _camera_state_changed_cb, NULL);
+ ret = recorder_create_videorecorder(camera, &recorder);
+ printf("recorder_create_videorecorder ret = %x\n", ret);
+ ret = recorder_set_state_changed_cb(recorder, _recorder_state_changed_cb , NULL);
+ ret = recorder_set_filename(recorder, "/mnt/nfs/test.3gp");
+ printf("recorder_set_filename ret = %x\n", ret);
+ ret = recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AAC);
+ printf("recorder_set_audio_encoder ret = %x\n", ret);
+ ret = recorder_set_video_encoder(recorder, RECORDER_VIDEO_CODEC_MPEG4);
+ printf("recorder_set_video_encoder ret = %x\n", ret);
+ ret = recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_3GP);
+ printf("recorder_set_file_format ret = %x\n", ret);
+
+ camera_set_display(camera, CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(preview_win));
+ //camera_set_preview_resolution(camera, 640, 480);
+ //camera_set_capture_resolution(camera, 640, 480);
+
+ ret = recorder_prepare(recorder);
+ printf("recorder_prepare ret = %x\n", ret);
+ ret = recorder_start(recorder);
+ printf("recorder_start ret = %x\n", ret);
+ sleep(10);
+ ret = camera_start_capture(camera, _capturing_cb , _capture_completed_cb, NULL);
+ printf("camera_start_capture ret =%x\n", ret);
+ sleep(10);
+
+ ret = recorder_commit(recorder);
+ printf("recorder_commit ret = %x\n", ret);
+ ret = recorder_unprepare(recorder);
+ printf("recorder_unprepare ret = %x\n", ret);
+ ret = recorder_destroy(recorder);
+ printf("recorder_destroy ret = %x\n", ret);
+ return 0;
+}
+
+
+void _audio_stream_cb(void* stream, int size, audio_sample_type_e format, int channel, unsigned int timestamp, void *user_data){
+ printf("size = %d[%d]( %d )\n", size, format, timestamp);
+}
+
+int audio_stream_cb_test(){
+ recorder_h recorder;
+ int ret = 0;
+ ret = recorder_create_audiorecorder(&recorder);
+ printf(" create ret =%d\n", ret);
+ ret = recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AMR);
+ printf(" create2 ret =%d\n", ret);
+ ret = recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_AMR);
+ printf(" create3 ret =%d\n", ret);
+ ret = recorder_set_filename(recorder, "/mnt/nfs/test.amr");
+ printf(" create4 ret =%d\n", ret);
+ ret = recorder_set_audio_stream_cb(recorder, _audio_stream_cb, NULL);
+ printf(" recorder_set_audio_stream_cb ret =%d\n", ret);
+ ret = recorder_prepare(recorder);
+ printf(" recorder_prepare ret =%d\n", ret);
+ ret = recorder_set_audio_stream_cb(recorder, _audio_stream_cb, NULL);
+ printf(" recorder_set_audio_stream_cb ret =%d\n", ret);
+ ret = recorder_start(recorder);
+ printf(" recorder_start ret =%d\n", ret);
+ sleep(10);
+ ret = recorder_commit(recorder);
+ printf(" recorder_commit ret =%d\n", ret);
+ return 0;
+}
void* test_main(void *arg){
int ret = 0;
- ret = recorder_encoder_test();
+ //ret = recorder_encoder_test();
/*
ret = recorder_attribute_test();
ret += recorder_state_change_test();
ret = mm_test();
*/
+ //audio_level_test();
+ //slow_motion_test();
+ //recording_capture_test();
+ audio_stream_cb_test();
+
+
+
if( ret == 0 )
printf("--------------RECORDER TEST ALL PASS--------------------------\n");
else
//elm_win_fullscreen_set(mEvasWindow, 1);
evas_object_color_set(mEvasWindow, 0,0,0,0);
- elm_win_transparent_set(mEvasWindow, 1);
preview_win = elm_win_xwindow_get(mEvasWindow);
fprintf(stderr, "end of elm\n");
projects / framework / api / recorder.git / commitdiff