From 09771e5d3cbe2c22de0b8724260b9a991d3accb7 Mon Sep 17 00:00:00 2001 From: Jeongmo Yang Date: Tue, 21 Aug 2012 20:00:02 +0900 Subject: [PATCH] 2.0 init Change-Id: I30b088d747e390e0b44e69bb364f7b4fa33b1570 --- AUTHORS | 0 CMakeLists.txt | 4 +- TC/_export_env.sh | 8 + TC/_export_target_env.sh | 7 + TC/build.sh | 16 + TC/clean.sh | 11 + TC/config.default | 3 + TC/execute.sh | 15 + TC/testcase/Makefile | 25 + TC/testcase/tslist | 4 + TC/testcase/utc_media_recorder.c | 425 +++++++++++++++++ TC/testcase/utc_media_recorder_callback.c | 238 ++++++++++ TC/testcase/utc_media_recorder_lifecycle.c | 323 +++++++++++++ TC/testcase/utc_media_recorder_working.c | 708 +++++++++++++++++++++++++++++ TC/tet_scen | 7 + TC/tetbuild.cfg | 5 + TC/tetclean.cfg | 5 + TC/tetexec.cfg | 5 + capi-media-recorder.pc.in | 0 debian/README | 0 debian/capi-media-recorder-dev.install | 4 - debian/capi-media-recorder-dev.postinst | 1 - debian/capi-media-recorder.install | 1 - debian/capi-media-recorder.postinst | 1 - debian/changelog | 43 -- debian/compat | 1 - debian/control | 22 - debian/rules | 69 --- include/recorder.h | 284 +++++++++++- include/recorder_private.h | 3 + packaging/capi-media-recorder.spec | 9 +- src/recorder.c | 382 ++++++++++++---- tags | 322 +++++++++++++ test/CMakeLists.txt | 2 +- test/multimedia_recorder_test.c | 159 ++++++- 35 files changed, 2868 insertions(+), 244 deletions(-) mode change 100755 => 100644 AUTHORS create mode 100755 TC/_export_env.sh create mode 100755 TC/_export_target_env.sh create mode 100755 TC/build.sh create mode 100755 TC/clean.sh create mode 100644 TC/config.default create mode 100755 TC/execute.sh create mode 100755 TC/testcase/Makefile create mode 100755 TC/testcase/tslist create mode 100755 TC/testcase/utc_media_recorder.c create mode 100755 TC/testcase/utc_media_recorder_callback.c create mode 100755 TC/testcase/utc_media_recorder_lifecycle.c create mode 100755 TC/testcase/utc_media_recorder_working.c create mode 100755 TC/tet_scen create mode 100644 TC/tetbuild.cfg create mode 100644 TC/tetclean.cfg create mode 100644 TC/tetexec.cfg mode change 100755 => 100644 capi-media-recorder.pc.in delete mode 100755 debian/README delete mode 100755 debian/capi-media-recorder-dev.install delete mode 100755 debian/capi-media-recorder-dev.postinst delete mode 100755 debian/capi-media-recorder.install delete mode 100755 debian/capi-media-recorder.postinst delete mode 100755 debian/changelog delete mode 100755 debian/compat delete mode 100755 debian/control delete mode 100755 debian/rules create mode 100644 tags mode change 100755 => 100644 test/CMakeLists.txt diff --git a/AUTHORS b/AUTHORS old mode 100755 new mode 100644 diff --git a/CMakeLists.txt b/CMakeLists.txt index 11ae346..ffcbaa5 100755 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -23,8 +23,8 @@ SET(service "media") 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}") diff --git a/TC/_export_env.sh b/TC/_export_env.sh new file mode 100755 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 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 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 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 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 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 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 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 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 +#include + +#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 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 +#include + +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 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 +#include + +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 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 +#include +#include +#include +#include + +#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 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 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 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 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 new mode 100644 diff --git a/debian/README b/debian/README deleted file mode 100755 index e69de29..0000000 diff --git a/debian/capi-media-recorder-dev.install b/debian/capi-media-recorder-dev.install deleted file mode 100755 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 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 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 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 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 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 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 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 Tue, 14 Feb 2012 16:51:44 +0900 - -capi-media-recorder (0.1.0-4) unstable; urgency=low - - * Update version - - -- Seungkeun Lee Thu, 15 Dec 2011 12:54:39 +0900 - -capi-media-recorder (0.0.1-1) unstable; urgency=low - - * Initial release. - - -- Seungkeun Lee Thu, 08 Dec 2011 08:57:45 +0900 diff --git a/debian/compat b/debian/compat deleted file mode 100755 index 7ed6ff8..0000000 --- a/debian/compat +++ /dev/null @@ -1 +0,0 @@ -5 diff --git a/debian/control b/debian/control deleted file mode 100755 index 7e8b397..0000000 --- a/debian/control +++ /dev/null @@ -1,22 +0,0 @@ - -Source: capi-media-recorder -Section: libs -Priority: extra -Maintainer: Seungkeun Lee , Kangho Hur -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 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 ddfc345..4994510 100755 --- a/include/recorder.h +++ b/include/recorder.h @@ -20,6 +20,7 @@ #define __TIZEN_MULTIMEDIA_RECORDER_H__ #include #include +#include #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_SECURITY_RESTRICTED = RECORDER_ERROR_CLASS | 0x07, /**< Restricted by security system policy */ } 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_ADTS, /**< ADTS file format */ + RECORDER_FILE_FORMAT_WAV, /**< WAV file format */ } recorder_file_format_e; @@ -95,8 +99,11 @@ 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_VORBIS, /**< Vorbis codec */ + RECORDER_AUDIO_CODEC_PCM /**< PCM codec */ } 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_THEORA /**< Theora codec */ } recorder_video_codec_e; /** @@ -118,6 +126,26 @@ typedef enum 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 - * @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() @@ -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); +/** + * @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); + /** * @} */ @@ -511,14 +591,15 @@ int recorder_foreach_supported_file_format(recorder_h recorder, recorder_support /** * @brief Sets the audio codec for encoding audio stream - * @remarks You can get available audio encoders by using recorder_foreach_supported_audio_encoder(). + * @remarks You can get available audio encoders by using recorder_foreach_supported_audio_encoder().\n + * if set to RECORDER_AUDIO_CODEC_DISABLE, audio track is not created in recording files. * @param[in] recorder The handle to media recorder * @param[in] codec The audio codec * @return 0 on success, otherwise a negative error value. * @retval #RECORDER_ERROR_NONE Successful * @retval #RECORDER_ERROR_INVALID_PARAMETER Invalid parameter * @retval #RECORDER_ERROR_INVALID_STATE Invalid state - * @pre The recorder state must be #RECORDER_STATE_CREATED + * @pre The recorder state must be #RECORDER_STATE_CREATED or #RECORDER_STATE_READY * @see recorder_get_audio_encoder() * @see recorder_foreach_supported_audio_encoder() */ @@ -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 - * @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() */ @@ -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); +/** + * @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. @@ -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); + +/** + * @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 - * @retval #RECORDER_ERROR_NONE Successful - * @retval #RECORDER_ERROR_INVALID_PARAMETER Invalid parameter * @see recorder_attr_set_mute() */ bool recorder_attr_is_muted(recorder_h recorder); +/** + * @brief Sets recording motion rate + * @remarks + * This attribute is valid only in video recorder.\n + * If the rate bigger than 0 and smaller than 1, video is recorded slow motion mode.\n + * If the rate bigger than 1, video is recorded fast motion mode(time lapse recording). + * Audio data is not recorded.\n + * To reset slow motion recording, setting rate to 1. + * @param[in] recorder The handle to media recorder + * @param[in] rate The recording motion rate. it is computed with fps. (0state; handle->state = __recorder_state_convert(m->state.current); - + recorder_policy_e policy = RECORDER_POLICY_NONE; + if(message == MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_ASM ) + policy = RECORDER_POLICY_SOUND; + else if( message == MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_SECURITY ) + policy = RECORDER_POLICY_SECURITY; + if( previous_state != handle->state && handle->user_cb[_RECORDER_EVENT_TYPE_STATE_CHANGE] ){ - ((recorder_state_changed_cb)handle->user_cb[_RECORDER_EVENT_TYPE_STATE_CHANGE])(previous_state, handle->state, message == MM_MESSAGE_CAMCORDER_STATE_CHANGED ? 0 : 1 , handle->user_data[_RECORDER_EVENT_TYPE_STATE_CHANGE]); + ((recorder_state_changed_cb)handle->user_cb[_RECORDER_EVENT_TYPE_STATE_CHANGE])(previous_state, handle->state, policy , handle->user_data[_RECORDER_EVENT_TYPE_STATE_CHANGE]); } - // should change intermediate state MM_CAMCORDER_STATE_READY is not valid in capi , change to NULL state - if( message == MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_ASM ){ + if( policy != RECORDER_POLICY_NONE ){ + if( previous_state != handle->state && handle->user_cb[_RECORDER_EVENT_TYPE_INTERRUPTED] ){ + ((recorder_interrupted_cb)handle->user_cb[_RECORDER_EVENT_TYPE_INTERRUPTED])(policy, previous_state, handle->state, handle->user_data[_RECORDER_EVENT_TYPE_INTERRUPTED]); + } if( m->state.previous == MM_CAMCORDER_STATE_PREPARE && m->state.current == MM_CAMCORDER_STATE_PREPARE ){ mm_camcorder_unrealize(handle->mm_handle); } @@ -239,12 +251,9 @@ static int __mm_recorder_msg_cb(int message, void *param, void *user_data){ 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; } @@ -255,6 +264,40 @@ static int __mm_recorder_msg_cb(int message, void *param, void *user_data){ } 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; @@ -264,6 +307,27 @@ static int __mm_recorder_msg_cb(int message, void *param, void *user_data){ 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); @@ -275,6 +339,7 @@ int recorder_create_videorecorder( camera_h camera, recorder_h* recorder){ 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; @@ -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; - - handle->mm_handle = ((camera_s*)camera)->mm_handle; handle->camera = camera; + //TODO if allow compatible with video mode / image mode, it should be changed. handle->state = RECORDER_STATE_CREATED; + _camera_get_mm_handle(camera, &handle->mm_handle); + _camera_set_relay_mm_message_callback(camera, __mm_recorder_msg_cb , (void*)handle); - mm_camcorder_set_message_callback(handle->mm_handle, __mm_recorder_msg_cb, (void*)handle); - - //((camera_s*)camera)->relay_callback = __mm_recorder_msg_cb; - //((camera_s*)camera)->relay_user_data = handle; handle->type = _RECORDER_TYPE_VIDEO; *recorder = (recorder_h)handle; @@ -395,8 +457,7 @@ int recorder_destroy( recorder_h recorder){ 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); } @@ -414,21 +475,23 @@ int recorder_prepare( recorder_h 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 ; - mm_camcorder_get_state(handle->mm_handle, &mmstate); + mm_camcorder_get_state(handle->mm_handle, &mmstate); if( mmstate != MM_CAMCORDER_STATE_READY){ - ret = mm_camcorder_realize(handle->mm_handle); if( ret != MM_ERROR_NONE){ LOGE("[%s] mm_camcorder_realize fail", __func__); return __convert_recorder_error_code(__func__, ret); } - } - + ret = mm_camcorder_start(handle->mm_handle); - + if( ret != MM_ERROR_NONE){ LOGE("[%s] mm_camcorder_start fail", __func__); mm_camcorder_unrealize(handle->mm_handle); @@ -439,7 +502,6 @@ int recorder_prepare( 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; @@ -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( handle->state < RECORDER_STATE_RECORDING ) + recorder_state_e state; + recorder_get_state(recorder, &state); + if( state < RECORDER_STATE_RECORDING ){ + LOGE("[%s]RECORDER_ERROR_INVALID_STATE(0x%08x) ",__func__, RECORDER_ERROR_INVALID_STATE); return RECORDER_ERROR_INVALID_STATE; + } *level = handle->last_max_input_level ; handle->last_max_input_level = LOWSET_DECIBEL; @@ -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; - int format_table[3] = { MM_FILE_FORMAT_3GP , // RECORDER_FILE_FORMAT_3GP, + int format_table[5] = { MM_FILE_FORMAT_3GP , // RECORDER_FILE_FORMAT_3GP, MM_FILE_FORMAT_MP4 , //RECORDER_FILE_FORMAT_MP4, - MM_FILE_FORMAT_AMR //RECORDER_FILE_FORMAT_AMR, + MM_FILE_FORMAT_AMR, //RECORDER_FILE_FORMAT_AMR, + MM_FILE_FORMAT_AAC, //RECORDER_FILE_FORMAT_ADTS + MM_FILE_FORMAT_WAV //RECORDER_FILE_FORMAT_WAV }; - - if( format < RECORDER_FILE_FORMAT_3GP || format > RECORDER_FILE_FORMAT_AMR ) + + if( format < RECORDER_FILE_FORMAT_3GP || format > RECORDER_FILE_FORMAT_WAV ) return RECORDER_ERROR_INVALID_PARAMETER; - + recorder_s * handle = (recorder_s*)recorder; ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_FILE_FORMAT , format_table[format], NULL); return __convert_recorder_error_code(__func__, ret); @@ -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; + break; + case MM_FILE_FORMAT_AAC : + *format = RECORDER_FILE_FORMAT_ADTS; + break; + case MM_FILE_FORMAT_WAV: + *format = RECORDER_FILE_FORMAT_WAV; + break; default : ret = MM_ERROR_CAMCORDER_INTERNAL; break; } - } + } return __convert_recorder_error_code(__func__, ret); } @@ -610,6 +684,65 @@ int recorder_unset_state_changed_cb(recorder_h recorder){ 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); @@ -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; + break; + case MM_FILE_FORMAT_AAC: + format = RECORDER_FILE_FORMAT_ADTS; + break; + case MM_FILE_FORMAT_WAV: + format = RECORDER_FILE_FORMAT_WAV; + break; default : format = -1; - } - + } + if ( format != -1 && !foreach_cb(format,user_data) ) break; } @@ -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( codec < RECORDER_AUDIO_CODEC_AMR || codec > RECORDER_AUDIO_CODEC_AAC) + if( codec != RECORDER_AUDIO_CODEC_DISABLE && ( codec < RECORDER_AUDIO_CODEC_AMR || codec > RECORDER_AUDIO_CODEC_PCM) ) return RECORDER_ERROR_INVALID_PARAMETER; - - int audio_table[2] = { MM_AUDIO_CODEC_AMR , //RECORDER_AUDIO_CODEC_AMR - MM_AUDIO_CODEC_AAC //RECORDER_AUDIO_CODEC_AAC + int audio_table[4] = { MM_AUDIO_CODEC_AMR, //RECORDER_AUDIO_CODEC_AMR + MM_AUDIO_CODEC_AAC, //RECORDER_AUDIO_CODEC_AAC + MM_AUDIO_CODEC_VORBIS, //RECORDER_AUDIO_CODEC_VORBIS + MM_AUDIO_CODEC_WAVE //RECORDER_AUDIO_CODEC_PCM }; - - int ret; recorder_s * handle = (recorder_s*)recorder; - if( handle->state != RECORDER_STATE_CREATED ) - return RECORDER_ERROR_INVALID_STATE; - - ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_AUDIO_ENCODER , audio_table[codec], NULL); + if( codec == RECORDER_AUDIO_CODEC_DISABLE ) + ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_AUDIO_DISABLE , 1, NULL); + else + ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_AUDIO_ENCODER , audio_table[codec], MMCAM_AUDIO_DISABLE, 0, NULL); return __convert_recorder_error_code(__func__, ret); @@ -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; + int audio_disable = 0; recorder_s * handle = (recorder_s*)recorder; - ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_AUDIO_ENCODER , &mm_codec , NULL); - if( ret == 0 ){ + ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_AUDIO_ENCODER , &mm_codec , MMCAM_AUDIO_DISABLE, &audio_disable, NULL); + if( ret == 0 && audio_disable == 0 ){ switch( mm_codec ){ case MM_AUDIO_CODEC_AMR : *codec = RECORDER_AUDIO_CODEC_AMR; @@ -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_VORBIS: + *codec = RECORDER_AUDIO_CODEC_VORBIS; + break; + case MM_AUDIO_CODEC_WAVE: + *codec = RECORDER_AUDIO_CODEC_PCM; + break; default : ret = MM_ERROR_CAMCORDER_INTERNAL; break; } + }else if( ret == 0 && audio_disable ){ + *codec = RECORDER_AUDIO_CODEC_DISABLE; } return __convert_recorder_error_code(__func__, ret); @@ -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; - int video_table[3] = { MM_VIDEO_CODEC_H263, //RECORDER_VIDEO_CODEC_H263, /**< H263 codec */ + int video_table[4] = { MM_VIDEO_CODEC_H263, //RECORDER_VIDEO_CODEC_H263, /**< H263 codec */ MM_VIDEO_CODEC_H264, //RECORDER_VIDEO_CODEC_H264, /**< H264 codec */ - MM_VIDEO_CODEC_MPEG4 //RECORDER_VIDEO_CODEC_MPEG4, /**< MPEG4 codec */ + MM_VIDEO_CODEC_MPEG4, //RECORDER_VIDEO_CODEC_MPEG4, /**< MPEG4 codec */ + MM_VIDEO_CODEC_THEORA //RECORDER_VIDEO_CODEC_THEORA }; - if( codec < RECORDER_VIDEO_CODEC_H263 || codec > RECORDER_VIDEO_CODEC_MPEG4 ) + if( codec < RECORDER_VIDEO_CODEC_H263 || codec > RECORDER_VIDEO_CODEC_THEORA ) return RECORDER_ERROR_INVALID_PARAMETER; - recorder_s * handle = (recorder_s*)recorder; - if( handle->state != RECORDER_STATE_CREATED ) - return RECORDER_ERROR_INVALID_STATE; ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_VIDEO_ENCODER , video_table[codec], NULL); return __convert_recorder_error_code(__func__, ret); @@ -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; + break; + case MM_VIDEO_CODEC_THEORA: + *codec = RECORDER_VIDEO_CODEC_THEORA; + 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_VORBIS: + codec = RECORDER_AUDIO_CODEC_VORBIS; + break; + case MM_AUDIO_CODEC_WAVE: + codec = RECORDER_AUDIO_CODEC_PCM; + break; 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; + break; + case MM_VIDEO_CODEC_THEORA : + codec = RECORDER_VIDEO_CODEC_THEORA; + break; 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); - return __convert_recorder_error_code(__func__, ret);; + return __convert_recorder_error_code(__func__, ret); } bool recorder_attr_is_muted(recorder_h recorder){ @@ -1007,3 +1164,60 @@ bool recorder_attr_is_muted(recorder_h recorder){ else return false; } + +int recorder_attr_set_recording_motion_rate(recorder_h recorder , double rate){ + if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER); + recorder_s * handle = (recorder_s*)recorder; + int ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, "camera-recording-motion-rate" , rate, NULL); + return __convert_recorder_error_code(__func__, ret); +} + +int recorder_attr_get_recording_motion_rate(recorder_h recorder , double *rate){ + if( recorder == NULL || rate == NULL ) + return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER); + + recorder_s * handle = (recorder_s*)recorder; + int ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, "camera-recording-motion-rate" , rate , NULL); + return __convert_recorder_error_code(__func__, ret); +} + + + +int recorder_attr_set_slow_motion_rate(recorder_h recorder , double rate){ + return recorder_attr_set_recording_motion_rate(recorder, rate); +} + +int recorder_attr_get_slow_motion_rate(recorder_h recorder , double *rate){ + return recorder_attr_get_recording_motion_rate(recorder, rate); +} + + +int recorder_attr_set_audio_channel(recorder_h recorder, int channel_count){ + if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER); + recorder_s * handle = (recorder_s*)recorder; + int ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_AUDIO_CHANNEL, channel_count, NULL); + return __convert_recorder_error_code(__func__, ret); +} + +int recorder_attr_get_audio_channel(recorder_h recorder, int *channel_count){ + if( recorder == NULL || channel_count == NULL ) + return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER); + + recorder_s * handle = (recorder_s*)recorder; + int ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_AUDIO_CHANNEL , channel_count, NULL); + return __convert_recorder_error_code(__func__, ret); +} + +int recorder_attr_set_recording_orientation(recorder_h recorder, recorder_rotation_e orientation){ + if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER); + recorder_s * handle = (recorder_s*)recorder; + int ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, "camcorder-rotation", orientation, NULL); + return __convert_recorder_error_code(__func__, ret); +} + +int recorder_attr_get_recording_orientation(recorder_h recorder, recorder_rotation_e *orientation){ + if( recorder == NULL || orientation == NULL ) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER); + recorder_s * handle = (recorder_s*)recorder; + int ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, "camcorder-rotation" , orientation, NULL); + return __convert_recorder_error_code(__func__, ret); +} diff --git a/tags b/tags new file mode 100644 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 new mode 100644 index 81ff17f..c6dc36d --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -1,7 +1,7 @@ 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}) diff --git a/test/multimedia_recorder_test.c b/test/multimedia_recorder_test.c index 9b96e2b..ff26d43 100755 --- 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_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); @@ -819,7 +819,7 @@ int recorder_encoder_test(){ 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)); @@ -937,10 +937,155 @@ int recorder_encoder_test(){ return ret; } + Eina_Bool print_audio_level(void *data){ + recorder_h recorder = (recorder_h)data; + if( recorder ){ + double level; + recorder_get_audio_level(recorder,&level); + printf("%g\n", level); + } + return 1; +} + +int audio_level_test(){ + recorder_h recorder; + recorder_create_audiorecorder(&recorder); + recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AMR); + recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_AMR); + recorder_set_filename(recorder, "/mnt/nfs/test.amr"); + + recorder_prepare(recorder); + recorder_start(recorder); + ecore_timer_add(0.1, print_audio_level, recorder); + sleep(2); + return 0; +} + +void _camera_state_changed_cb(camera_state_e previous, camera_state_e current,bool by_policy, void *user_data){ + printf("camera state changed %d -> %d\n", previous , current); +} + +void _recorder_state_changed_cb(recorder_state_e previous , recorder_state_e current , bool by_policy, void *user_data){ + printf("recorder state changed %d -> %d\n", previous , current); +} + +int slow_motion_test(){ + camera_h camera; + recorder_h recorder; + int ret; + ret = camera_create(CAMERA_DEVICE_CAMERA0, &camera); + printf("camera_create ret = %x\n", ret); + camera_set_state_changed_cb(camera, _camera_state_changed_cb, NULL); + ret = recorder_create_videorecorder(camera, &recorder); + printf("recorder_create_videorecorder ret = %x\n", ret); + ret = recorder_set_state_changed_cb(recorder, _recorder_state_changed_cb , NULL); + ret = recorder_set_filename(recorder, "/mnt/nfs/test.3gp"); + printf("recorder_set_filename ret = %x\n", ret); + ret = recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AAC); + printf("recorder_set_audio_encoder ret = %x\n", ret); + ret = recorder_set_video_encoder(recorder, RECORDER_VIDEO_CODEC_MPEG4); + printf("recorder_set_video_encoder ret = %x\n", ret); + ret = recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_3GP); + printf("recorder_set_file_format ret = %x\n", ret); + ret = recorder_attr_set_slow_motion_rate(recorder, 0.5); + printf("recorder_attr_set_slow_motion_rate ret = %x\n", ret); + ret = recorder_prepare(recorder); + printf("recorder_prepare ret = %x\n", ret); + ret = recorder_start(recorder); + printf("recorder_start ret = %x\n", ret); + sleep(10); + ret = recorder_commit(recorder); + printf("recorder_commit ret = %x\n", ret); + ret = recorder_unprepare(recorder); + printf("recorder_unprepare ret = %x\n", ret); + ret = recorder_destroy(recorder); + printf("recorder_destroy ret = %x\n", ret); + return 0; +} + +void _capturing_cb(camera_image_data_s* image, camera_image_data_s* postview, camera_image_data_s* thumbnail, void *user_data){ + printf("capturing callback!\n"); +} + +void _capture_completed_cb(void *user_data){ + printf("capture completed callback\n"); +} + + +int recording_capture_test(){ + camera_h camera; + recorder_h recorder; + int ret; + ret = camera_create(CAMERA_DEVICE_CAMERA0, &camera); + printf("camera_create ret = %x\n", ret); + camera_set_state_changed_cb(camera, _camera_state_changed_cb, NULL); + ret = recorder_create_videorecorder(camera, &recorder); + printf("recorder_create_videorecorder ret = %x\n", ret); + ret = recorder_set_state_changed_cb(recorder, _recorder_state_changed_cb , NULL); + ret = recorder_set_filename(recorder, "/mnt/nfs/test.3gp"); + printf("recorder_set_filename ret = %x\n", ret); + ret = recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AAC); + printf("recorder_set_audio_encoder ret = %x\n", ret); + ret = recorder_set_video_encoder(recorder, RECORDER_VIDEO_CODEC_MPEG4); + printf("recorder_set_video_encoder ret = %x\n", ret); + ret = recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_3GP); + printf("recorder_set_file_format ret = %x\n", ret); + + camera_set_display(camera, CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(preview_win)); + //camera_set_preview_resolution(camera, 640, 480); + //camera_set_capture_resolution(camera, 640, 480); + + ret = recorder_prepare(recorder); + printf("recorder_prepare ret = %x\n", ret); + ret = recorder_start(recorder); + printf("recorder_start ret = %x\n", ret); + sleep(10); + ret = camera_start_capture(camera, _capturing_cb , _capture_completed_cb, NULL); + printf("camera_start_capture ret =%x\n", ret); + sleep(10); + + ret = recorder_commit(recorder); + printf("recorder_commit ret = %x\n", ret); + ret = recorder_unprepare(recorder); + printf("recorder_unprepare ret = %x\n", ret); + ret = recorder_destroy(recorder); + printf("recorder_destroy ret = %x\n", ret); + return 0; +} + + +void _audio_stream_cb(void* stream, int size, audio_sample_type_e format, int channel, unsigned int timestamp, void *user_data){ + printf("size = %d[%d]( %d )\n", size, format, timestamp); +} + +int audio_stream_cb_test(){ + recorder_h recorder; + int ret = 0; + ret = recorder_create_audiorecorder(&recorder); + printf(" create ret =%d\n", ret); + ret = recorder_set_audio_encoder(recorder, RECORDER_AUDIO_CODEC_AMR); + printf(" create2 ret =%d\n", ret); + ret = recorder_set_file_format(recorder, RECORDER_FILE_FORMAT_AMR); + printf(" create3 ret =%d\n", ret); + ret = recorder_set_filename(recorder, "/mnt/nfs/test.amr"); + printf(" create4 ret =%d\n", ret); + ret = recorder_set_audio_stream_cb(recorder, _audio_stream_cb, NULL); + printf(" recorder_set_audio_stream_cb ret =%d\n", ret); + ret = recorder_prepare(recorder); + printf(" recorder_prepare ret =%d\n", ret); + ret = recorder_set_audio_stream_cb(recorder, _audio_stream_cb, NULL); + printf(" recorder_set_audio_stream_cb ret =%d\n", ret); + ret = recorder_start(recorder); + printf(" recorder_start ret =%d\n", ret); + sleep(10); + ret = recorder_commit(recorder); + printf(" recorder_commit ret =%d\n", ret); + return 0; +} void* test_main(void *arg){ int ret = 0; - ret = recorder_encoder_test(); + //ret = recorder_encoder_test(); /* ret = recorder_attribute_test(); ret += recorder_state_change_test(); @@ -950,6 +1095,13 @@ void* test_main(void *arg){ 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 @@ -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_transparent_set(mEvasWindow, 1); preview_win = elm_win_xwindow_get(mEvasWindow); fprintf(stderr, "end of elm\n"); -- 2.7.4