2.0 init

Change-Id: I30b088d747e390e0b44e69bb364f7b4fa33b1570

diff --git a/AUTHORS b/AUTHORS
old mode 100755 (executable)
new mode 100644 (file)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 11ae34602ee1bc4680b884f729a5688a2b4c04fd..ffcbaa5e02740f2fe39e1212cb3dedd4b84c03fb 100755 (executable)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -23,8 +23,8 @@ SET(service "media")
 SET(submodule "recorder")
 
 # for package file
 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}")
 
 
 SET(fw_name "${project_prefix}-${service}-${submodule}")
 

diff --git a/TC/_export_env.sh b/TC/_export_env.sh
new file mode 100755 (executable)
index 0000000..72a11ec
--- /dev/null
+++ b/TC/_export_env.sh
@@ -0,0 +1,8 @@
+#!/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

diff --git a/TC/_export_target_env.sh b/TC/_export_target_env.sh
new file mode 100755 (executable)
index 0000000..5ddaa53
--- /dev/null
+++ b/TC/_export_target_env.sh
@@ -0,0 +1,7 @@
+#!/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

diff --git a/TC/build.sh b/TC/build.sh
new file mode 100755 (executable)
index 0000000..72aad6c
--- /dev/null
+++ b/TC/build.sh
@@ -0,0 +1,16 @@
+#!/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

diff --git a/TC/clean.sh b/TC/clean.sh
new file mode 100755 (executable)
index 0000000..29743e0
--- /dev/null
+++ b/TC/clean.sh
@@ -0,0 +1,11 @@
+#!/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

diff --git a/TC/config.default b/TC/config.default
new file mode 100644 (file)
index 0000000..12ac1e2
--- /dev/null
+++ b/TC/config.default
@@ -0,0 +1,3 @@
+CAPI_PROJECT_ROOT=/home/abyss/capi
+TET_INSTALL_HOST_PATH=/home/abyss/TETware
+TET_INSTALL_TARGET_PATH=/mnt/nfs/TETware

diff --git a/TC/execute.sh b/TC/execute.sh
new file mode 100755 (executable)
index 0000000..a4f6095
--- /dev/null
+++ b/TC/execute.sh
@@ -0,0 +1,15 @@
+#!/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

diff --git a/TC/testcase/Makefile b/TC/testcase/Makefile
new file mode 100755 (executable)
index 0000000..40adef9
--- /dev/null
+++ b/TC/testcase/Makefile
@@ -0,0 +1,25 @@
+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)

diff --git a/TC/testcase/tslist b/TC/testcase/tslist
new file mode 100755 (executable)
index 0000000..278aacc
--- /dev/null
+++ b/TC/testcase/tslist
@@ -0,0 +1,4 @@
+/testcase/utc_media_recorder
+/testcase/utc_media_recorder_callback
+/testcase/utc_media_recorder_lifecycle
+/testcase/utc_media_recorder_working

diff --git a/TC/testcase/utc_media_recorder.c b/TC/testcase/utc_media_recorder.c
new file mode 100755 (executable)
index 0000000..1b5aa2a
--- /dev/null
+++ b/TC/testcase/utc_media_recorder.c
@@ -0,0 +1,425 @@
+/*
+* 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");
+}
+

diff --git a/TC/testcase/utc_media_recorder_callback.c b/TC/testcase/utc_media_recorder_callback.c
new file mode 100755 (executable)
index 0000000..66fd5c9
--- /dev/null
+++ b/TC/testcase/utc_media_recorder_callback.c
@@ -0,0 +1,238 @@
+/*
+* 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");
+}

diff --git a/TC/testcase/utc_media_recorder_lifecycle.c b/TC/testcase/utc_media_recorder_lifecycle.c
new file mode 100755 (executable)
index 0000000..713b090
--- /dev/null
+++ b/TC/testcase/utc_media_recorder_lifecycle.c
@@ -0,0 +1,323 @@
+/*
+* 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);
+}
+ 
+
+

diff --git a/TC/testcase/utc_media_recorder_working.c b/TC/testcase/utc_media_recorder_working.c
new file mode 100755 (executable)
index 0000000..dce0402
--- /dev/null
+++ b/TC/testcase/utc_media_recorder_working.c
@@ -0,0 +1,708 @@
+/*
+* 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");
+}
+

diff --git a/TC/tet_scen b/TC/tet_scen
new file mode 100755 (executable)
index 0000000..03f029a
--- /dev/null
+++ b/TC/tet_scen
@@ -0,0 +1,7 @@
+all
+       ^TEST
+##### Scenarios for TEST #####
+
+# Test scenario
+TEST
+       :include:/testcase/tslist

diff --git a/TC/tetbuild.cfg b/TC/tetbuild.cfg
new file mode 100644 (file)
index 0000000..f7eda55
--- /dev/null
+++ b/TC/tetbuild.cfg
@@ -0,0 +1,5 @@
+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?

diff --git a/TC/tetclean.cfg b/TC/tetclean.cfg
new file mode 100644 (file)
index 0000000..02d7030
--- /dev/null
+++ b/TC/tetclean.cfg
@@ -0,0 +1,5 @@
+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

diff --git a/TC/tetexec.cfg b/TC/tetexec.cfg
new file mode 100644 (file)
index 0000000..ef3e452
--- /dev/null
+++ b/TC/tetexec.cfg
@@ -0,0 +1,5 @@
+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 ?

diff --git a/capi-media-recorder.pc.in b/capi-media-recorder.pc.in
old mode 100755 (executable)
new mode 100644 (file)

diff --git a/debian/README b/debian/README
deleted file mode 100755 (executable)
index e69de29..0000000

diff --git a/debian/capi-media-recorder-dev.install b/debian/capi-media-recorder-dev.install
deleted file mode 100755 (executable)
index 761a28b..0000000
--- a/debian/capi-media-recorder-dev.install
+++ /dev/null
@@ -1,4 +0,0 @@
-/usr/include/*
-/usr/include/*/*
-/usr/lib/pkgconfig/*.pc
-

diff --git a/debian/capi-media-recorder-dev.postinst b/debian/capi-media-recorder-dev.postinst
deleted file mode 100755 (executable)
index 1a24852..0000000
--- a/debian/capi-media-recorder-dev.postinst
+++ /dev/null
@@ -1 +0,0 @@
-#!/bin/sh

diff --git a/debian/capi-media-recorder.install b/debian/capi-media-recorder.install
deleted file mode 100755 (executable)
index 4a755a4..0000000
--- a/debian/capi-media-recorder.install
+++ /dev/null
@@ -1 +0,0 @@
-/usr/lib/lib*.so*

diff --git a/debian/capi-media-recorder.postinst b/debian/capi-media-recorder.postinst
deleted file mode 100755 (executable)
index 1a24852..0000000
--- a/debian/capi-media-recorder.postinst
+++ /dev/null
@@ -1 +0,0 @@
-#!/bin/sh

diff --git a/debian/changelog b/debian/changelog
deleted file mode 100755 (executable)
index 9c2af03..0000000
--- a/debian/changelog
+++ /dev/null
@@ -1,43 +0,0 @@
-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

diff --git a/debian/compat b/debian/compat
deleted file mode 100755 (executable)
index 7ed6ff8..0000000
--- a/debian/compat
+++ /dev/null
@@ -1 +0,0 @@
-5

diff --git a/debian/control b/debian/control
deleted file mode 100755 (executable)
index 7e8b397..0000000
--- a/debian/control
+++ /dev/null
@@ -1,22 +0,0 @@
-
-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)
-

diff --git a/debian/rules b/debian/rules
deleted file mode 100755 (executable)
index 4c376ac..0000000
--- a/debian/rules
+++ /dev/null
@@ -1,69 +0,0 @@
-#!/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
-

diff --git a/include/recorder.h b/include/recorder.h
index ddfc3459d4d321fad784965aece779b5576783e0..4994510dd786584310c7ea7cffafb0227b6fd24d 100755 (executable)
--- a/include/recorder.h
+++ b/include/recorder.h
@@ -20,6 +20,7 @@
 #define        __TIZEN_MULTIMEDIA_RECORDER_H__
 #include <tizen.h>
 #include <camera.h>
 #define        __TIZEN_MULTIMEDIA_RECORDER_H__
 #include <tizen.h>
 #include <camera.h>

+#include <audio_io.h>

 
 #ifdef __cplusplus
 extern "C" {
 
 #ifdef __cplusplus
 extern "C" {


@@ -55,6 +56,7 @@ typedef enum
                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_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_error_e;
 
 /**


@@ -87,6 +89,8 @@ typedef enum
         RECORDER_FILE_FORMAT_3GP,                     /**< 3GP file format */
         RECORDER_FILE_FORMAT_MP4,                     /**< MP4 file format */
         RECORDER_FILE_FORMAT_AMR,                     /**< AMR file format */
         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;
 
 
 } recorder_file_format_e;
 
 


@@ -95,8 +99,11 @@ typedef enum
  */
 typedef enum
 {
  */
 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_AAC,                       /**< AAC codec */

+       RECORDER_AUDIO_CODEC_VORBIS,    /**< Vorbis codec */
+       RECORDER_AUDIO_CODEC_PCM                        /**< PCM codec */

 } recorder_audio_codec_e;
 
 /**
 } recorder_audio_codec_e;
 
 /**


@@ -107,6 +114,7 @@ typedef enum
        RECORDER_VIDEO_CODEC_H263,                      /**< H263 codec */
        RECORDER_VIDEO_CODEC_H264,                      /**< H264 codec */
        RECORDER_VIDEO_CODEC_MPEG4,             /**< MPEG4 codec */
        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_video_codec_e;
 
 /**


@@ -118,6 +126,26 @@ typedef enum
        RECORDER_AUDIO_DEVICE_MODEM,    /**< Modem */
 } recorder_audio_device_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;

 
 /**
  * @}
 
 /**
  * @}


@@ -160,7 +188,7 @@ typedef void (*recorder_recording_status_cb)(int elapsed_time, int file_size, vo
  * @brief  Called when the record state has changed.
  * @param[in] previous The previous state of recorder
  * @param[in] current  The current state of recorder
  * @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()
  * @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()


@@ -173,6 +201,57 @@ typedef void (*recorder_recording_status_cb)(int elapsed_time, int file_size, vo
  */
 typedef void (*recorder_state_changed_cb)(recorder_state_e previous , recorder_state_e current , bool by_policy, void *user_data);
 
  */
 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);
+
+

  /**
  * @}
 */
  /**
  * @}
 */


@@ -476,6 +555,7 @@ int recorder_set_file_format(recorder_h recorder, recorder_file_format_e format)
  */
 int recorder_get_file_format(recorder_h recorder, recorder_file_format_e *format);
 
  */
 int recorder_get_file_format(recorder_h recorder, recorder_file_format_e *format);
 

+

  /**
  * @}
 */
  /**
  * @}
 */


@@ -511,14 +591,15 @@ int recorder_foreach_supported_file_format(recorder_h recorder, recorder_support
 
 /**
  * @brief  Sets the audio codec for encoding audio stream
 
 /**
  * @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
  * @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()
  */
  * @see        recorder_get_audio_encoder()
  * @see recorder_foreach_supported_audio_encoder()
  */


@@ -579,7 +660,7 @@ int recorder_foreach_supported_audio_encoder(recorder_h recorder, recorder_suppo
  * @retval #RECORDER_ERROR_NONE Successful
  * @retval #RECORDER_ERROR_INVALID_PARAMETER Invalid parameter
  * @retval #RECORDER_ERROR_INVALID_STATE Invalid state
  * @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()
  */
  * @see recorder_get_video_encoder()
  * @see recorder_foreach_supported_video_encoder()
  */


@@ -656,6 +737,70 @@ int recorder_set_state_changed_cb(recorder_h recorder, recorder_state_changed_cb
  */
 int recorder_unset_state_changed_cb(recorder_h recorder);
 
  */
 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.
 
 /**
  * @brief  Registers a callback function to be invoked when the recording information changes.


@@ -710,6 +855,45 @@ int recorder_set_recording_limit_reached_cb(recorder_h recorder, recorder_record
  */
 int recorder_unset_recording_limit_reached_cb(recorder_h recorder);
 
  */
 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);
+
+

 /**
  * @}
  */
 /**
  * @}
  */


@@ -898,13 +1082,99 @@ int recorder_attr_set_mute(recorder_h recorder, bool enable);
  * @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
  * @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);
 
  * @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);

 
 /**
  * @}
 
 /**
  * @}

diff --git a/include/recorder_private.h b/include/recorder_private.h
index 1f349b2b05dfdffad3fedaf64cf485fd723b2650..55027a98aa4e764782a2a2a0b218712ed50100ed 100755 (executable)
--- a/include/recorder_private.h
+++ b/include/recorder_private.h
@@ -30,6 +30,9 @@ typedef enum {
        _RECORDER_EVENT_TYPE_STATE_CHANGE,
        _RECORDER_EVENT_TYPE_RECORDING_LIMITED, 
        _RECORDER_EVENT_TYPE_RECORDING_STATUS,
        _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;
 
        _RECORDER_EVENT_TYPE_NUM
 }_recorder_event_e;
 

diff --git a/packaging/capi-media-recorder.spec b/packaging/capi-media-recorder.spec
index 34cd470d284f6b479dd89d679325265d195b78c3..7d1f5f63160c76fa5bb1ee1b89fe9a797421a123 100755 (executable)
--- a/packaging/capi-media-recorder.spec
+++ b/packaging/capi-media-recorder.spec
@@ -1,8 +1,8 @@
 Name:       capi-media-recorder
 Name:       capi-media-recorder

-Summary:    A Camera library in Tizen Native API
+Summary:    A Recorder library in Tizen C API

 Version:    0.1.0
 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
 License:    Apache-2.0
 Source0:    %{name}-%{version}.tar.gz
 BuildRequires:  cmake


@@ -10,13 +10,14 @@ BuildRequires:  pkgconfig(dlog)
 BuildRequires:  pkgconfig(mm-camcorder)
 BuildRequires:  pkgconfig(capi-base-common)
 BuildRequires:  pkgconfig(capi-media-camera)
 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
 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}
 
 Group:    TO_BE/FILLED_IN
 Requires: %{name} = %{version}-%{release}
 

diff --git a/src/recorder.c b/src/recorder.c
index f315072693611d0cc565ebfabd810d665b19fda1..5489ef63c9d004a926bee205584d70524f50f8dc 100755 (executable)
--- a/src/recorder.c
+++ b/src/recorder.c
@@ -37,40 +37,37 @@
 
 
 /*
 
 
 /*

- *     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 __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;
 
 static int __convert_recorder_error_code(const char *func, int code){
        int ret = RECORDER_ERROR_INVALID_OPERATION;


@@ -150,6 +147,11 @@ static int __convert_recorder_error_code(const char *func, int code){
                        errorstr = "ERROR_SOUND_POLICY";                        
                        break;
 
                        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";
                default:
                        ret = RECORDER_ERROR_INVALID_OPERATION;
                        errorstr = "INVALID_OPERATION";


@@ -178,6 +180,9 @@ static recorder_state_e __recorder_state_convert(MMCamcorderStateType mm_state )
                case MM_CAMCORDER_STATE_PREPARE:
                        state = RECORDER_STATE_READY;
                        break;
                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;
                case MM_CAMCORDER_STATE_RECORDING:
                        state = RECORDER_STATE_RECORDING;
                        break;


@@ -193,7 +198,6 @@ static recorder_state_e __recorder_state_convert(MMCamcorderStateType mm_state )
 }
 
 static int __mm_recorder_msg_cb(int message, void *param, void *user_data){
 }
 
 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;
        recorder_s * handle = (recorder_s*)user_data;
        MMMessageParamType *m = (MMMessageParamType*)param;
        recorder_state_e previous_state;


@@ -201,15 +205,23 @@ static int __mm_recorder_msg_cb(int message, void *param, void *user_data){
        switch(message){
                case MM_MESSAGE_CAMCORDER_STATE_CHANGED:
                case MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_ASM:
        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);
                                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] ){
                                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
                                // 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);
                                        }
                                        if( m->state.previous == MM_CAMCORDER_STATE_PREPARE && m->state.current == MM_CAMCORDER_STATE_PREPARE ){
                                                mm_camcorder_unrealize(handle->mm_handle);
                                        }


@@ -239,12 +251,9 @@ static int __mm_recorder_msg_cb(int message, void *param, void *user_data){
                        break;
                case MM_MESSAGE_CAMCORDER_CAPTURED :
                {
                        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;
                                }
                                        free(report->recording_filename );
                                        report->recording_filename = NULL;
                                }


@@ -255,6 +264,40 @@ static int __mm_recorder_msg_cb(int message, void *param, void *user_data){
                        }
                        break;
                }
                        }
                        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;
                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;


@@ -264,6 +307,27 @@ static int __mm_recorder_msg_cb(int message, void *param, void *user_data){
        return 1;
 }
 
        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 recorder_create_videorecorder( camera_h camera, recorder_h* recorder){
        
        if( camera == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);


@@ -275,6 +339,7 @@ int recorder_create_videorecorder( camera_h camera, recorder_h* recorder){
        int preview_format;     
 
        camera_get_state(camera, &camera_state);
        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;
        if( camera_state != CAMERA_STATE_CREATED){
                LOGE("[%s] camera state(%d) is not CAMERA_STATE_CREATED ", __func__, camera_state);
                return RECORDER_ERROR_INVALID_PARAMETER;


@@ -288,15 +353,12 @@ int recorder_create_videorecorder( camera_h camera, recorder_h* recorder){
 
        memset(handle, 0 , sizeof(recorder_s));         
        handle->last_max_input_level = LOWSET_DECIBEL;
 
        memset(handle, 0 , sizeof(recorder_s));         
        handle->last_max_input_level = LOWSET_DECIBEL;

-
-       handle->mm_handle = ((camera_s*)camera)->mm_handle;

        handle->camera = camera;
        handle->camera = camera;

+       //TODO if allow compatible with video mode / image mode, it should be changed.

        handle->state = RECORDER_STATE_CREATED;
        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;
 
        handle->type = _RECORDER_TYPE_VIDEO;
        *recorder = (recorder_h)handle;
 


@@ -395,8 +457,7 @@ int recorder_destroy( recorder_h recorder){
                                                                                                                                MMCAM_CAPTURE_FORMAT, MM_PIXEL_FORMAT_ENCODED,
                                                                                                                                MMCAM_CAPTURE_COUNT, 1,
                                                                                                                                (void*)NULL);
                                                                                                                                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);
        }
        }else{
                ret = mm_camcorder_destroy(handle->mm_handle);
        }


@@ -414,21 +475,23 @@ int recorder_prepare( recorder_h recorder){
        int ret = 0;
        recorder_s *handle = (recorder_s*)recorder;
 
        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 ;
        MMCamcorderStateType mmstate ;

-       mm_camcorder_get_state(handle->mm_handle, &mmstate);    
+       mm_camcorder_get_state(handle->mm_handle, &mmstate);

 
        if( mmstate !=  MM_CAMCORDER_STATE_READY){
 
        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_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);
        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);
        if( ret != MM_ERROR_NONE){
                LOGE("[%s] mm_camcorder_start fail", __func__); 
                mm_camcorder_unrealize(handle->mm_handle);


@@ -439,7 +502,6 @@ int recorder_prepare( recorder_h recorder){
 }
 
 int recorder_unprepare( recorder_h recorder){
 }
 
 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) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER); 
        int ret = 0;
        recorder_s *handle = (recorder_s*)recorder;


@@ -499,8 +561,12 @@ int recorder_get_audio_level(recorder_h recorder, double *level){
        if( recorder == NULL || level == NULL ) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
        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;
                return RECORDER_ERROR_INVALID_STATE;

+       }

 
        *level = handle->last_max_input_level ;
        handle->last_max_input_level = LOWSET_DECIBEL;
 
        *level = handle->last_max_input_level ;
        handle->last_max_input_level = LOWSET_DECIBEL;


@@ -541,14 +607,16 @@ int recorder_set_file_format(recorder_h recorder, recorder_file_format_e format)
        
        if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);         
        int ret;
        
        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_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;
                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);
        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);


@@ -574,12 +642,18 @@ int recorder_get_file_format(recorder_h recorder, recorder_file_format_e *format
                                break;
                        case MM_FILE_FORMAT_AMR :
                                *format = RECORDER_FILE_FORMAT_AMR;
                                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;
                }
                        default :
                                ret = MM_ERROR_CAMCORDER_INTERNAL;
                                break;
                }

-       }       
+       }

        return __convert_recorder_error_code(__func__, ret);
 }
 
        return __convert_recorder_error_code(__func__, ret);
 }
 


@@ -610,6 +684,65 @@ int recorder_unset_state_changed_cb(recorder_h recorder){
        return RECORDER_ERROR_NONE;     
 }
 
        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);         
 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);         


@@ -684,11 +817,17 @@ int recorder_foreach_supported_file_format(recorder_h recorder, recorder_support
                                break;
                        case MM_FILE_FORMAT_AMR :
                                format = RECORDER_FILE_FORMAT_AMR;
                                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;
                        default :
                                format = -1;

-               }       
-       
+               }
+

                if ( format != -1 && !foreach_cb(format,user_data) )
                        break;
        }
                if ( format != -1 && !foreach_cb(format,user_data) )
                        break;
        }


@@ -730,21 +869,20 @@ int recorder_set_audio_encoder(recorder_h recorder, recorder_audio_codec_e  code
        
        if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);         
 
        
        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;
                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;
        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);
        
 
        return __convert_recorder_error_code(__func__, ret);
        


@@ -756,10 +894,11 @@ int recorder_get_audio_encoder(recorder_h recorder, recorder_audio_codec_e *code
        g_return_val_if_fail(codec != NULL, RECORDER_ERROR_INVALID_PARAMETER);          
        int ret;
        int mm_codec = 0;
        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;
        
        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;
                switch( mm_codec ){
                        case MM_AUDIO_CODEC_AMR :
                                *codec = RECORDER_AUDIO_CODEC_AMR;


@@ -767,10 +906,18 @@ int recorder_get_audio_encoder(recorder_h recorder, recorder_audio_codec_e *code
                        case MM_AUDIO_CODEC_AAC :
                                *codec = RECORDER_AUDIO_CODEC_AAC;
                                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 :
                                ret = MM_ERROR_CAMCORDER_INTERNAL;
                                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);    
        }
                
        return __convert_recorder_error_code(__func__, ret);    


@@ -781,16 +928,14 @@ int recorder_set_video_encoder(recorder_h recorder, recorder_video_codec_e  code
        if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);         
        int 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_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;
                return RECORDER_ERROR_INVALID_PARAMETER;

-       

        recorder_s * handle = (recorder_s*)recorder;
        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);
 
        ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_VIDEO_ENCODER   , video_table[codec], NULL);
        return __convert_recorder_error_code(__func__, ret);


@@ -818,7 +963,10 @@ int recorder_get_video_encoder(recorder_h recorder, recorder_video_codec_e *code
                                break;
                        case MM_VIDEO_CODEC_MPEG4 :
                                *codec = RECORDER_VIDEO_CODEC_MPEG4;
                                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;
                        default :
                                ret = MM_ERROR_CAMCORDER_INTERNAL;
                                break;


@@ -941,6 +1089,12 @@ int recorder_foreach_supported_audio_encoder(recorder_h recorder, recorder_suppo
                        case MM_AUDIO_CODEC_AAC :
                                codec = RECORDER_AUDIO_CODEC_AAC;
                                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;
                }       
                        default :
                                codec = -1;
                }       


@@ -974,7 +1128,10 @@ int recorder_foreach_supported_video_encoder(recorder_h recorder, recorder_suppo
                                break;
                        case MM_VIDEO_CODEC_MPEG4 :
                                codec = RECORDER_VIDEO_CODEC_MPEG4;
                                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;
                }       
                        default :
                                codec = -1;
                }       


@@ -991,7 +1148,7 @@ int recorder_attr_set_mute(recorder_h recorder, bool enable){
        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);
        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){
 }
 
 bool recorder_attr_is_muted(recorder_h recorder){


@@ -1007,3 +1164,60 @@ bool recorder_attr_is_muted(recorder_h recorder){
        else
                return false;
 }
        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);
+}

diff --git a/tags b/tags
new file mode 100644 (file)
index 0000000..acc4108
--- /dev/null
+++ b/tags
@@ -0,0 +1,322 @@
+!_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

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
old mode 100755 (executable)
new mode 100644 (file)
index 81ff17f..c6dc36d
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -1,7 +1,7 @@
 SET(fw_test "${fw_name}-test")
 
 INCLUDE(FindPkgConfig)
 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})
 FOREACH(flag ${${fw_test}_CFLAGS})
     SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
     MESSAGE(${flag})

diff --git a/test/multimedia_recorder_test.c b/test/multimedia_recorder_test.c
index 9b96e2bf57787b02d9da5484f9ea492c5767e102..ff26d439ae18cf0fc4c40d04a529176561dea798 100755 (executable)
--- a/test/multimedia_recorder_test.c
+++ b/test/multimedia_recorder_test.c
@@ -683,7 +683,7 @@ int video_recorder_test(){
        camera_create(CAMERA_DEVICE_CAMERA0 , &camera);
        recorder_create_videorecorder(camera, &recorder);
        camera_set_display(camera,CAMERA_DISPLAY_TYPE_X11,GET_DISPLAY(preview_win));
        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);
        //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);


@@ -819,7 +819,7 @@ int recorder_encoder_test(){
        
 
        ret+=camera_create(CAMERA_DEVICE_CAMERA0,&camera);
        
 
        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));
 
 
        ret+=camera_set_display(camera, CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(preview_win));
 
 


@@ -937,10 +937,155 @@ int recorder_encoder_test(){
        return ret;
 }
 
        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;
 
 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 = recorder_attribute_test();
        ret += recorder_state_change_test();


@@ -950,6 +1095,13 @@ void* test_main(void *arg){
        ret = mm_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
        if( ret == 0 )
                printf("--------------RECORDER TEST ALL PASS--------------------------\n");
        else


@@ -978,7 +1130,6 @@ int main(int argc, char ** argv)
        //elm_win_fullscreen_set(mEvasWindow, 1);
        
        evas_object_color_set(mEvasWindow, 0,0,0,0);
        //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");
        preview_win = elm_win_xwindow_get(mEvasWindow);
 
        fprintf(stderr, "end of elm\n");