SET(CAPI_LIB "capi-media-recorder")
SET(TC_SOURCES
+ utc_media_recorder_util.c
utc_media_recorder.c
utc_media_recorder_callback.c
utc_media_recorder_lifecycle.c
#include "assert.h"
#include <media/recorder.h>
-#include <storage.h>
#include <string.h>
#include <system_info.h>
#include <sound_manager.h>
+#include "utc_media_recorder_util.h"
-static char *media = ".test_record.amr";
-static char *media_path = NULL;
static bool audio_recording_supported = false;
static recorder_h recorder = NULL;
static int startup_ret = RECORDER_ERROR_NONE;
static camera_h camera = NULL;
static int startup_ret_camera = CAMERA_ERROR_NONE;
-#define UTC_AUDIO_CODEC_NUM 5
-#define UTC_FILE_FORMAT_NUM 7
-
-enum {
- USER_DATA_AUDIO_CODEC,
- USER_DATA_FILE_FORMAT,
- USER_DATA_MAX
-};
-
-static bool audiocodec_fileformat_compatibility_table[UTC_AUDIO_CODEC_NUM][UTC_FILE_FORMAT_NUM] =
-{ /* 3GP MP4 AMR ADTS WAV OGG M2TS */
-/*AMR*/ {1, 0, 1, 0, 0, 0, 0},
-/*AAC*/ {1, 1, 0, 0, 0, 0, 1},
-/*VORBIS*/ {0, 0, 0, 0, 0, 1, 0},
-/*PCM*/ {0, 0, 0, 0, 1, 0, 0},
-/*MP3*/ {0, 1, 0, 0, 0, 0, 1}
-};
-
-static bool _audio_encoder_cb(recorder_audio_codec_e codec, void *user_data)
-{
- if (user_data != NULL) {
- *((recorder_audio_codec_e *)user_data) = codec;
- return false;
- }
-
- return true;
-}
-
-static bool _file_format_cb(recorder_file_format_e format, void *user_data)
-{
- int *l_user_data = NULL;
-
- if (user_data != NULL) {
- l_user_data = (int *)user_data;
- if (audiocodec_fileformat_compatibility_table[l_user_data[USER_DATA_AUDIO_CODEC]][(int)format]) {
- l_user_data[USER_DATA_FILE_FORMAT] = (int)format;
- return false;
- }
- }
-
- return true;
-}
-
-static int _get_supported_audio_encoder_and_file_format(recorder_h recorder, int *audio_codec, int *file_format)
-{
- int ret = RECORDER_ERROR_NONE;
- int l_audio_codec = RECORDER_AUDIO_CODEC_DISABLE;
- int l_file_format = -1;
- int user_data[USER_DATA_MAX];
-
- if (audio_codec == NULL || file_format == NULL)
- return RECORDER_ERROR_INVALID_PARAMETER;
-
- memset(user_data, 0, sizeof(int) * USER_DATA_MAX);
- ret = recorder_foreach_supported_audio_encoder(recorder, _audio_encoder_cb, &l_audio_codec);
- assert_eq(ret, RECORDER_ERROR_NONE);
-
- if ((int)l_audio_codec >= 0 && (int)l_audio_codec < UTC_AUDIO_CODEC_NUM) {
- user_data[USER_DATA_AUDIO_CODEC] = (int)l_audio_codec;
- ret = recorder_foreach_supported_file_format(recorder, _file_format_cb, user_data);
- assert_eq(ret, RECORDER_ERROR_NONE);
-
- l_file_format = (recorder_file_format_e)user_data[USER_DATA_FILE_FORMAT];
- if ((int)l_file_format >= 0 && (int)l_file_format < UTC_FILE_FORMAT_NUM) {
- *audio_codec = l_audio_codec;
- *file_format = l_file_format;
-
- return RECORDER_ERROR_NONE;
- }
- }
-
- return RECORDER_ERROR_NOT_SUPPORTED;
-}
-
-static bool _storage_device_cb(int storage_id, storage_type_e type, storage_state_e state, const char *path, void *user_data)
-{
- int size_of_path = 0;
-
- if (type == STORAGE_TYPE_INTERNAL) {
- size_of_path = strlen(path) + strlen(media) + 2;
- media_path = (char *)malloc(size_of_path);
- if (media_path != NULL) {
- snprintf(media_path, size_of_path, "%s/%s", path, media);
- }
-
- return false;
- }
-
- return true;
-}
static void _sound_stream_focus_state_changed_cb(sound_stream_info_h stream_info, sound_stream_focus_mask_e focus_mask, sound_stream_focus_state_e focus_state,
sound_stream_focus_change_reason_e reason_for_change, int sound_behavior, const char *additional_info, void *user_data)
*/
void utc_media_recorder_startup(void)
{
- storage_foreach_device_supported(_storage_device_cb, NULL);
-
- system_info_get_platform_bool("http://tizen.org/feature/media.audio_recording", &audio_recording_supported);
- system_info_get_platform_bool("http://tizen.org/feature/media.video_recording", &video_recording_supported);
+ utc_media_recorder_util_get_recording_supported(&audio_recording_supported, &video_recording_supported);
startup_ret = recorder_create_audiorecorder(&recorder);
startup_ret_camera = camera_create(CAMERA_DEVICE_CAMERA0, &camera);
int utc_media_recorder_attr_is_muted_p(void)
{
int ret=RECORDER_ERROR_NONE;
- int audio_codec = RECORDER_AUDIO_CODEC_DISABLE;
- int file_format = -1;
if (!audio_recording_supported) {
assert_eq(startup_ret, RECORDER_ERROR_NOT_SUPPORTED);
return 0;
}
- ret = _get_supported_audio_encoder_and_file_format(recorder, &audio_codec, &file_format);
- assert_eq(ret, RECORDER_ERROR_NONE);
-
- if (audio_codec < 0 || file_format < 0) {
- fprintf(stderr, "Audio codec(or file format) is not supported.\n");
+ ret = utc_media_recorder_util_prepare_audio_recorder(recorder);
+ if (ret != RECORDER_ERROR_NONE)
return 1;
- }
-
- ret = recorder_set_audio_encoder(recorder, audio_codec);
- ret |= recorder_set_file_format(recorder, file_format);
- ret |= recorder_set_filename(recorder, media_path);
- ret |= recorder_prepare(recorder);
- assert_eq(ret, RECORDER_ERROR_NONE);
ret = recorder_start(recorder);
assert_eq(ret, RECORDER_ERROR_NONE);
{
double value = 0.0;
int ret = RECORDER_ERROR_NONE;
- int audio_codec = RECORDER_AUDIO_CODEC_DISABLE;
- int file_format = -1;
if (!audio_recording_supported) {
assert_eq(startup_ret, RECORDER_ERROR_NOT_SUPPORTED);
return 0;
}
- ret = _get_supported_audio_encoder_and_file_format(recorder, &audio_codec, &file_format);
- assert_eq(ret, RECORDER_ERROR_NONE);
-
- if (audio_codec < 0 || file_format < 0) {
- fprintf(stderr, "Audio codec(or file format) is not supported.\n");
- return 1;
- }
-
- ret = recorder_set_audio_encoder(recorder, audio_codec);
- ret |= recorder_set_file_format(recorder, file_format);
- ret |= recorder_set_filename(recorder, media_path);
- ret |= recorder_prepare(recorder);
+ ret = utc_media_recorder_util_prepare_audio_recorder(recorder);
assert_eq(ret, RECORDER_ERROR_NONE);
ret = recorder_start(recorder);
int utc_media_recorder_set_filename_p(void)
{
int ret = RECORDER_ERROR_NONE;
+ char *media_path = NULL;
if (!audio_recording_supported) {
assert_eq(startup_ret, RECORDER_ERROR_NOT_SUPPORTED);
return 0;
}
+ utc_media_recorder_util_get_media_path(&media_path);
+ assert(media_path);
+
ret = recorder_set_filename(recorder, media_path);
+
+ g_free(media_path);
+
assert_eq(ret, RECORDER_ERROR_NONE);
return 0;
int utc_media_recorder_get_filename_p(void)
{
int ret = RECORDER_ERROR_NONE;
- char *f_name = NULL;
+ char *set_name = NULL;
+ char *get_name = NULL;
if (!audio_recording_supported) {
assert_eq(startup_ret, RECORDER_ERROR_NOT_SUPPORTED);
return 0;
}
- ret = recorder_set_filename(recorder, media_path);
+ utc_media_recorder_util_get_media_path(&set_name);
+ assert(set_name);
+
+ ret = recorder_set_filename(recorder, set_name);
+
assert_eq(ret, RECORDER_ERROR_NONE);
- ret = recorder_get_filename(recorder, &f_name);
- if (f_name) {
- free(f_name);
- f_name = NULL;
- }
+ ret = recorder_get_filename(recorder, &get_name);
+
+ assert_eq(strcmp(set_name, get_name), 0);
+
+ g_free(set_name);
+ free(get_name);
assert_eq(ret, RECORDER_ERROR_NONE);
#include "assert.h"
#include <media/recorder.h>
#include <system_info.h>
+#include "utc_media_recorder_util.h"
+
+#define CALLBACK_CHECK_COUNT 10
static recorder_h recorder = NULL;
static camera_h camera = NULL;
*/
void utc_media_recorder_callback_startup(void)
{
- /* start of TC */
- system_info_get_platform_bool("http://tizen.org/feature/media.audio_recording", &audio_recording_supported);
- system_info_get_platform_bool("http://tizen.org/feature/media.video_recording", &video_recording_supported);
+ utc_media_recorder_util_get_recording_supported(&audio_recording_supported, &video_recording_supported);
startup_ret = recorder_create_audiorecorder(&recorder);
startup_ret_camera = camera_create(CAMERA_DEVICE_CAMERA0, &camera);
return;
}
-static bool _audio_encoder_cb(recorder_audio_codec_e codec, void *user_data)
-{
- return true;
-}
-
-static bool _file_format_cb(recorder_file_format_e format, void *user_data)
-{
- return true;
-}
-
static bool _video_encoder_cb(recorder_video_codec_e codec, void *user_data)
{
- return true;
+ return false;
}
static bool _video_resolution_cb(int width, int height, void *user_data)
{
- return true;
+ return false;
}
static void _limit_reached_cb(recorder_recording_limit_type_e type, void *user_data)
{
+ utc_media_recorder_util_mainloop_quit(user_data);
+
return;
}
-static void _recording_statis_cb(unsigned long long elapsed_time, unsigned long long file_size, void *user_data)
+static void _recording_status_cb(unsigned long long elapsed_time, unsigned long long file_size, void *user_data)
{
+ int *status_count = (int *)user_data;
+
+ if (!status_count)
+ return;
+
+ if ((*status_count)++ == CALLBACK_CHECK_COUNT)
+ utc_media_recorder_util_mainloop_quit(user_data);
+
return;
}
static void _state_changed_cb(recorder_state_e previous, recorder_state_e current, bool by_asm, void *user_data)
{
+ if (current == RECORDER_STATE_READY)
+ utc_media_recorder_util_mainloop_quit(user_data);
+
return;
}
static void _audio_stream_cb(void *stream, int size, audio_sample_type_e format, int channel, unsigned int timestamp, void *user_data)
{
+ int *buffer_count = (int *)user_data;
+
+ if (!buffer_count)
+ return;
+
+ if ((*buffer_count)++ == CALLBACK_CHECK_COUNT)
+ utc_media_recorder_util_mainloop_quit(user_data);
+
return;
}
static void _device_state_changed_cb(recorder_type_e type, recorder_device_state_e state, void *user_data)
{
+ if (state == RECORDER_DEVICE_STATE_RECORDING)
+ utc_media_recorder_util_mainloop_quit(user_data);
+
return;
}
static void _muxed_stream_cb(void *stream, int size, unsigned long long offset, void *user_data)
{
+ int *buffer_count = (int *)user_data;
+
+ if (!buffer_count)
+ return;
+
+ if ((*buffer_count)++ == CALLBACK_CHECK_COUNT)
+ utc_media_recorder_util_mainloop_quit(user_data);
+
return;
}
static bool _video_encode_decision_cb(recorder_video_data_s *frame, void *user_data)
{
+ int *buffer_count = (int *)user_data;
+
+ if (!buffer_count)
+ return true;
+
+ if ((*buffer_count)++ == CALLBACK_CHECK_COUNT)
+ utc_media_recorder_util_mainloop_quit(user_data);
+
return true;
}
int utc_media_recorder_foreach_supported_video_resolution_p(void)
{
int ret = RECORDER_ERROR_NONE;
+ recorder_h video_recorder = NULL;
if (!video_recording_supported) {
assert_eq(startup_ret_camera, CAMERA_ERROR_NOT_SUPPORTED);
return 0;
}
- ret = recorder_foreach_supported_video_resolution(recorder, _video_resolution_cb, NULL);
+ ret = recorder_create_videorecorder(camera, &video_recorder);
assert_eq(ret, RECORDER_ERROR_NONE);
+ ret = recorder_foreach_supported_video_resolution(video_recorder, _video_resolution_cb, NULL);
+ assert_eq(ret, RECORDER_ERROR_NONE);
+
+ recorder_destroy(video_recorder);
+
return 0;
}
ret = recorder_set_recording_limit_reached_cb(recorder, _limit_reached_cb, NULL);
assert_eq(ret, RECORDER_ERROR_NONE);
+ ret = recorder_attr_set_time_limit(recorder, 2);
+ assert_eq(ret, RECORDER_ERROR_NONE);
+
+ ret = utc_media_recorder_util_prepare_audio_recorder(recorder);
+ assert_eq(ret, RECORDER_ERROR_NONE);
+
+ ret = recorder_start(recorder);
+ assert_eq(ret, RECORDER_ERROR_NONE);
+
+ utc_media_recorder_util_mainloop_run();
+
+ recorder_cancel(recorder);
+ recorder_unprepare(recorder);
+
return 0;
}
int utc_media_recorder_set_recording_status_cb_p(void)
{
int ret = RECORDER_ERROR_NONE;
+ int status_count = 0;
if (!audio_recording_supported) {
assert_eq(startup_ret, RECORDER_ERROR_NOT_SUPPORTED);
return 0;
}
- ret = recorder_set_recording_status_cb(recorder, _recording_statis_cb, NULL);
+ ret = recorder_set_recording_status_cb(recorder, _recording_status_cb, (void *)&status_count);
assert_eq(ret, RECORDER_ERROR_NONE);
+ ret = utc_media_recorder_util_prepare_audio_recorder(recorder);
+ assert_eq(ret, RECORDER_ERROR_NONE);
+
+ ret = recorder_start(recorder);
+ assert_eq(ret, RECORDER_ERROR_NONE);
+
+ utc_media_recorder_util_mainloop_run();
+
+ recorder_cancel(recorder);
+ recorder_unprepare(recorder);
+
return 0;
}
ret = recorder_set_state_changed_cb(recorder, _state_changed_cb, NULL);
assert_eq(ret, RECORDER_ERROR_NONE);
+ ret = utc_media_recorder_util_prepare_audio_recorder(recorder);
+ assert_eq(ret, RECORDER_ERROR_NONE);
+
+ utc_media_recorder_util_mainloop_run();
+
+ recorder_unprepare(recorder);
+
return 0;
}
int utc_media_recorder_set_audio_stream_cb_p(void)
{
int ret = RECORDER_ERROR_NONE;
+ int buffer_count = 0;
if (!audio_recording_supported) {
assert_eq(startup_ret, RECORDER_ERROR_NOT_SUPPORTED);
return 0;
}
- ret = recorder_set_audio_stream_cb(recorder, _audio_stream_cb, NULL);
+ ret = recorder_set_audio_stream_cb(recorder, _audio_stream_cb, (void *)&buffer_count);
assert_eq(ret, RECORDER_ERROR_NONE);
+ ret = utc_media_recorder_util_prepare_audio_recorder(recorder);
+ assert_eq(ret, RECORDER_ERROR_NONE);
+
+ ret = recorder_start(recorder);
+ assert_eq(ret, RECORDER_ERROR_NONE);
+
+ utc_media_recorder_util_mainloop_run();
+
+ recorder_cancel(recorder);
+ recorder_unprepare(recorder);
+
return 0;
}
int utc_media_recorder_add_device_state_changed_cb_p(void)
{
int ret = RECORDER_ERROR_NONE;
- int check_ret = RECORDER_ERROR_NONE;
int cb_id = 0;
ret = recorder_add_device_state_changed_cb(_device_state_changed_cb, NULL, &cb_id);
- if (audio_recording_supported)
- check_ret = RECORDER_ERROR_NONE;
- else
- check_ret = RECORDER_ERROR_NOT_SUPPORTED;
+ if (audio_recording_supported) {
+ assert_eq(ret, RECORDER_ERROR_NONE);
+
+ ret = utc_media_recorder_util_prepare_audio_recorder(recorder);
+ assert_eq(ret, RECORDER_ERROR_NONE);
+
+ ret = recorder_start(recorder);
+ assert_eq(ret, RECORDER_ERROR_NONE);
+
+ utc_media_recorder_util_mainloop_run();
- if (cb_id > 0)
recorder_remove_device_state_changed_cb(cb_id);
- assert_eq(ret, check_ret);
+ recorder_cancel(recorder);
+ recorder_unprepare(recorder);
+ } else {
+ assert_eq(ret, RECORDER_ERROR_NOT_SUPPORTED);
+ }
return 0;
}
int utc_media_recorder_set_muxed_stream_cb_p(void)
{
int ret = RECORDER_ERROR_NONE;
+ int buffer_count = 0;
if (!audio_recording_supported) {
assert_eq(startup_ret, RECORDER_ERROR_NOT_SUPPORTED);
return 0;
}
- ret = recorder_set_muxed_stream_cb(recorder, _muxed_stream_cb, NULL);
+ ret = recorder_set_muxed_stream_cb(recorder, _muxed_stream_cb, (void *)&buffer_count);
assert_eq(ret, RECORDER_ERROR_NONE);
+ ret = utc_media_recorder_util_prepare_audio_recorder(recorder);
+ assert_eq(ret, RECORDER_ERROR_NONE);
+
+ ret = recorder_start(recorder);
+ assert_eq(ret, RECORDER_ERROR_NONE);
+
+ utc_media_recorder_util_mainloop_run();
+
+ recorder_cancel(recorder);
+ recorder_unprepare(recorder);
+
return 0;
}
int utc_media_recorder_set_video_encode_decision_cb_p(void)
{
int ret = RECORDER_ERROR_NONE;
+ int buffer_count = 0;
+ char *media_path = NULL;
+ recorder_h video_recorder = NULL;
if (!video_recording_supported) {
assert_eq(startup_ret_camera, CAMERA_ERROR_NOT_SUPPORTED);
return 0;
}
- ret = recorder_set_video_encode_decision_cb(recorder, _video_encode_decision_cb, NULL);
+ ret = recorder_create_videorecorder(camera, &video_recorder);
+ assert_eq(ret, RECORDER_ERROR_NONE);
+
+ ret = recorder_set_video_encode_decision_cb(video_recorder, _video_encode_decision_cb, (void *)&buffer_count);
+ assert_eq(ret, RECORDER_ERROR_NONE);
+
+ utc_media_recorder_util_get_media_path(&media_path);
+
+ ret = recorder_set_audio_encoder(video_recorder, RECORDER_AUDIO_CODEC_DISABLE);
+ ret |= recorder_set_video_encoder(video_recorder, RECORDER_VIDEO_CODEC_MPEG4);
+ ret |= recorder_set_file_format(video_recorder, RECORDER_FILE_FORMAT_3GP);
+ ret |= recorder_set_filename(video_recorder, media_path);
+ ret |= recorder_prepare(video_recorder);
+ ret |= recorder_start(video_recorder);
+
+ g_free(media_path);
+
assert_eq(ret, RECORDER_ERROR_NONE);
+ utc_media_recorder_util_mainloop_run();
+
+ recorder_cancel(video_recorder);
+ recorder_unprepare(video_recorder);
+ recorder_destroy(video_recorder);
+
return 0;
}
#include <string.h>
#include <storage.h>
#include <system_info.h>
+#include "utc_media_recorder_util.h"
+
-static char *media = ".test_record.amr";
-static char *media_path = NULL;
static bool video_recording_supported = false;
static bool audio_recording_supported = false;
-#define UTC_AUDIO_CODEC_NUM 5
-#define UTC_FILE_FORMAT_NUM 7
-
-enum {
- USER_DATA_AUDIO_CODEC,
- USER_DATA_FILE_FORMAT,
- USER_DATA_MAX
-};
-
-static bool audiocodec_fileformat_compatibility_table[UTC_AUDIO_CODEC_NUM][UTC_FILE_FORMAT_NUM] =
-{ /* 3GP MP4 AMR ADTS WAV OGG M2TS */
-/*AMR*/ {1, 0, 1, 0, 0, 0, 0},
-/*AAC*/ {1, 1, 0, 0, 0, 0, 1},
-/*VORBIS*/ {0, 0, 0, 0, 0, 1, 0},
-/*PCM*/ {0, 0, 0, 0, 1, 0, 0},
-/*MP3*/ {0, 1, 0, 0, 0, 0, 1}
-};
-
-static bool _audio_encoder_cb(recorder_audio_codec_e codec, void *user_data)
-{
- if (user_data != NULL) {
- *((recorder_audio_codec_e *)user_data) = codec;
- return false;
- }
-
- return true;
-}
-
-static bool _file_format_cb(recorder_file_format_e format, void *user_data)
-{
- int *l_user_data = NULL;
-
- if (user_data != NULL) {
- l_user_data = (int *)user_data;
- if (audiocodec_fileformat_compatibility_table[l_user_data[USER_DATA_AUDIO_CODEC]][(int)format]) {
- l_user_data[USER_DATA_FILE_FORMAT] = (int)format;
- return false;
- }
- }
-
- return true;
-}
-
-static int _get_supported_audio_encoder_and_file_format(recorder_h recorder, int *audio_codec, int *file_format)
-{
- int ret = RECORDER_ERROR_NONE;
- int l_audio_codec = RECORDER_AUDIO_CODEC_DISABLE;
- int l_file_format = -1;
- int user_data[USER_DATA_MAX];
-
- if (audio_codec == NULL || file_format == NULL)
- return RECORDER_ERROR_INVALID_PARAMETER;
-
- memset(user_data, 0, sizeof(int) * USER_DATA_MAX);
- ret = recorder_foreach_supported_audio_encoder(recorder, _audio_encoder_cb, &l_audio_codec);
- assert_eq(ret, RECORDER_ERROR_NONE);
-
- if ((int)l_audio_codec >= 0 && (int)l_audio_codec < UTC_AUDIO_CODEC_NUM) {
- user_data[USER_DATA_AUDIO_CODEC] = (int)l_audio_codec;
- ret = recorder_foreach_supported_file_format(recorder, _file_format_cb, user_data);
- assert_eq(ret, RECORDER_ERROR_NONE);
-
- l_file_format = (recorder_file_format_e)user_data[USER_DATA_FILE_FORMAT];
- if ((int)l_file_format >= 0 && (int)l_file_format < UTC_FILE_FORMAT_NUM) {
- *audio_codec = l_audio_codec;
- *file_format = l_file_format;
-
- return RECORDER_ERROR_NONE;
- }
- }
-
- return RECORDER_ERROR_NOT_SUPPORTED;
-}
-
-static bool _storage_device_cb(int storage_id, storage_type_e type, storage_state_e state, const char* path, void* user_data)
-{
- int size_of_path = 0;
-
- if (type == STORAGE_TYPE_INTERNAL) {
- size_of_path = strlen(path) + strlen(media) + 6;
- media_path = (char *)malloc(size_of_path);
- if (media_path != NULL) {
- snprintf(media_path, size_of_path, "%s/%s", path, media);
- }
-
- return false;
- }
-
- return true;
-}
/**
* @function utc_media_recorder_lifecycle_startup
*/
void utc_media_recorder_lifecycle_startup(void)
{
- storage_foreach_device_supported(_storage_device_cb, NULL);
-
- system_info_get_platform_bool("http://tizen.org/feature/media.audio_recording", &audio_recording_supported);
- system_info_get_platform_bool("http://tizen.org/feature/media.video_recording", &video_recording_supported);
+ utc_media_recorder_util_get_recording_supported(&audio_recording_supported, &video_recording_supported);
return;
}
{
int ret = RECORDER_ERROR_NONE;
recorder_h recorder = NULL;
- int audio_codec = RECORDER_AUDIO_CODEC_DISABLE;
- int file_format = -1;
ret = recorder_create_audiorecorder(&recorder);
if (audio_recording_supported) {
- ret = _get_supported_audio_encoder_and_file_format(recorder, &audio_codec, &file_format);
+ ret = utc_media_recorder_util_prepare_audio_recorder(recorder);
assert_eq(ret, RECORDER_ERROR_NONE);
- if (audio_codec < 0 || file_format < 0) {
- fprintf(stderr, "Audio codec(or file format) is not supported.\n");
- return 1;
- }
-
- ret = recorder_set_audio_encoder(recorder, audio_codec);
- ret |= recorder_set_file_format(recorder, file_format);
- ret |= recorder_set_filename(recorder, media_path);
- ret |= recorder_prepare(recorder);
- ret |= recorder_start(recorder);
-
+ ret = recorder_start(recorder);
assert_eq(ret, RECORDER_ERROR_NONE);
- sleep(2);
+ sleep(1);
ret = recorder_cancel(recorder);
{
int ret = RECORDER_ERROR_NONE;
recorder_h recorder = NULL;
- int audio_codec = RECORDER_AUDIO_CODEC_DISABLE;
- int file_format = -1;
ret = recorder_create_audiorecorder(&recorder);
if (audio_recording_supported) {
- ret = _get_supported_audio_encoder_and_file_format(recorder, &audio_codec, &file_format);
- assert_eq(ret, RECORDER_ERROR_NONE);
-
- if (audio_codec < 0 || file_format < 0) {
- fprintf(stderr, "Audio codec(or file format) is not supported.\n");
- return 1;
- }
-
- ret = recorder_set_audio_encoder(recorder, audio_codec);
- ret |= recorder_set_file_format(recorder, file_format);
- ret |= recorder_prepare(recorder);
-
+ ret = utc_media_recorder_util_prepare_audio_recorder(recorder);
assert_eq(ret, RECORDER_ERROR_NONE);
ret = recorder_cancel(recorder);
{
int ret = RECORDER_ERROR_NONE;
recorder_h recorder = NULL;
- int audio_codec = RECORDER_AUDIO_CODEC_DISABLE;
- int file_format = -1;
ret = recorder_create_audiorecorder(&recorder);
if (audio_recording_supported) {
- ret = _get_supported_audio_encoder_and_file_format(recorder, &audio_codec, &file_format);
- assert_eq(ret, RECORDER_ERROR_NONE);
-
- if (audio_codec < 0 || file_format < 0) {
- fprintf(stderr, "Audio codec(or file format) is not supported.\n");
- return 1;
- }
-
- ret = recorder_set_audio_encoder(recorder, audio_codec);
- ret |= recorder_set_file_format(recorder, file_format);
- ret |= recorder_set_filename(recorder, media_path);
- ret |= recorder_prepare(recorder);
+ ret = utc_media_recorder_util_prepare_audio_recorder(recorder);
ret |= recorder_start(recorder);
assert_eq(ret, RECORDER_ERROR_NONE);
{
int ret = RECORDER_ERROR_NONE;
recorder_h recorder = NULL;
- int audio_codec = RECORDER_AUDIO_CODEC_DISABLE;
- int file_format = -1;
ret = recorder_create_audiorecorder(&recorder);
if (audio_recording_supported) {
- ret = _get_supported_audio_encoder_and_file_format(recorder, &audio_codec, &file_format);
- assert_eq(ret, RECORDER_ERROR_NONE);
-
- if (audio_codec < 0 || file_format < 0) {
- fprintf(stderr, "Audio codec(or file format) is not supported.\n");
- return 1;
- }
-
- ret = recorder_set_audio_encoder(recorder, audio_codec);
- ret |= recorder_set_file_format(recorder, file_format);
- ret |= recorder_prepare(recorder);
-
+ ret = utc_media_recorder_util_prepare_audio_recorder(recorder);
assert_eq(ret, RECORDER_ERROR_NONE);
ret = recorder_commit(recorder);
recorder_unprepare(recorder);
recorder_destroy(recorder);
- assert_neq(ret, RECORDER_ERROR_NONE);
+ assert_eq(ret, RECORDER_ERROR_INVALID_STATE);
} else {
assert_eq(ret,RECORDER_ERROR_NOT_SUPPORTED);
}
{
int ret = RECORDER_ERROR_NONE;
recorder_h recorder = NULL;
- int audio_codec = RECORDER_AUDIO_CODEC_DISABLE;
- int file_format = -1;
ret = recorder_create_audiorecorder(&recorder);
if (audio_recording_supported) {
- ret = _get_supported_audio_encoder_and_file_format(recorder, &audio_codec, &file_format);
- assert_eq(ret, RECORDER_ERROR_NONE);
-
- if (audio_codec < 0 || file_format < 0) {
- fprintf(stderr, "Audio codec(or file format) is not supported.\n");
- return 1;
- }
-
- ret = recorder_set_audio_encoder(recorder, audio_codec);
- ret |= recorder_set_file_format(recorder, file_format);
- ret |= recorder_set_filename(recorder, media_path);
- ret |= recorder_prepare(recorder);
+ ret = utc_media_recorder_util_prepare_audio_recorder(recorder);
ret |= recorder_start(recorder);
assert_eq(ret, RECORDER_ERROR_NONE);
{
int ret = RECORDER_ERROR_NONE;
recorder_h recorder = NULL;
- int audio_codec = RECORDER_AUDIO_CODEC_DISABLE;
- int file_format = -1;
ret = recorder_create_audiorecorder(&recorder);
if (audio_recording_supported) {
- ret = _get_supported_audio_encoder_and_file_format(recorder, &audio_codec, &file_format);
- assert_eq(ret, RECORDER_ERROR_NONE);
-
- if (audio_codec < 0 || file_format < 0) {
- fprintf(stderr, "Audio codec(or file format) is not supported.\n");
- return 1;
- }
-
- ret = recorder_set_audio_encoder(recorder, audio_codec);
- ret |= recorder_set_file_format(recorder, file_format);
- ret |= recorder_prepare(recorder);
-
+ ret = utc_media_recorder_util_prepare_audio_recorder(recorder);
assert_eq(ret, RECORDER_ERROR_NONE);
ret = recorder_pause(recorder);
{
int ret = RECORDER_ERROR_NONE;
recorder_h recorder = NULL;
- int audio_codec = RECORDER_AUDIO_CODEC_DISABLE;
- int file_format = -1;
ret = recorder_create_audiorecorder(&recorder);
if (audio_recording_supported) {
- ret = _get_supported_audio_encoder_and_file_format(recorder, &audio_codec, &file_format);
+ ret = utc_media_recorder_util_prepare_audio_recorder(recorder);
assert_eq(ret, RECORDER_ERROR_NONE);
- if (audio_codec < 0 || file_format < 0) {
- fprintf(stderr, "Audio codec(or file format) is not supported.\n");
- return 1;
- }
-
- ret = recorder_set_audio_encoder(recorder, audio_codec);
- ret |= recorder_set_file_format(recorder,file_format);
-
- assert_eq(ret, RECORDER_ERROR_NONE);
-
- ret = recorder_prepare(recorder);
-
recorder_unprepare(recorder);
recorder_destroy(recorder);
{
int ret = RECORDER_ERROR_NONE;
recorder_h recorder = NULL;
- int audio_codec = RECORDER_AUDIO_CODEC_DISABLE;
- int file_format = -1;
ret = recorder_create_audiorecorder(&recorder);
if (audio_recording_supported) {
- ret = _get_supported_audio_encoder_and_file_format(recorder, &audio_codec, &file_format);
- assert_eq(ret, RECORDER_ERROR_NONE);
-
- if (audio_codec < 0 || file_format < 0) {
- fprintf(stderr, "Audio codec(or file format) is not supported.\n");
- return 1;
- }
-
- ret = recorder_set_audio_encoder(recorder, audio_codec);
- ret |= recorder_set_file_format(recorder,file_format);
- ret |= recorder_set_filename(recorder, media_path);
- ret |= recorder_prepare(recorder);
-
+ ret = utc_media_recorder_util_prepare_audio_recorder(recorder);
assert_eq(ret, RECORDER_ERROR_NONE);
ret = recorder_start(recorder);
{
int ret = RECORDER_ERROR_NONE;
recorder_h recorder = NULL;
- int audio_codec = RECORDER_AUDIO_CODEC_DISABLE;
- int file_format = -1;
ret = recorder_create_audiorecorder(&recorder);
if (audio_recording_supported) {
- ret = _get_supported_audio_encoder_and_file_format(recorder, &audio_codec, &file_format);
- assert_eq(ret, RECORDER_ERROR_NONE);
-
- if (audio_codec < 0 || file_format < 0) {
- fprintf(stderr, "Audio codec(or file format) is not supported.\n");
- return 1;
- }
-
- ret = recorder_set_audio_encoder(recorder, audio_codec);
- ret |= recorder_set_file_format(recorder,file_format);
- ret |= recorder_prepare(recorder);
-
+ ret = utc_media_recorder_util_prepare_audio_recorder(recorder);
assert_eq(ret, RECORDER_ERROR_NONE);
ret = recorder_unprepare(recorder);
--- /dev/null
+/*
+ * Copyright (c) 2023 Samsung Electronics Co., Ltd.
+ *
+ * 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 <dlog.h>
+#include <storage.h>
+#include <recorder.h>
+#include "utc_media_recorder_util.h"
+
+
+#define RECORDER_AUDIO_CODEC_NUM 5
+#define RECORDER_FILE_FORMAT_NUM 7
+#define RECORDER_MEDIA_NAME ".test_record"
+#define RECORDER_MAINLOOP_TIMEOUT 5000 /* milliseconds */
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+#define LOG_TAG "UTC_RECORDER_UTIL"
+
+
+static GMainLoop *g_recorder_mainloop;
+static guint g_recorder_timeout_id;
+
+
+enum {
+ USER_DATA_AUDIO_CODEC,
+ USER_DATA_FILE_FORMAT,
+ USER_DATA_MAX
+};
+
+static bool _storage_device_cb(int storage_id, storage_type_e type, storage_state_e state, const char *path, void *user_data)
+{
+ char **media_path = (char **)user_data;
+
+ if (!media_path)
+ return false;
+
+ if (type != STORAGE_TYPE_INTERNAL)
+ return true;
+
+ *media_path = g_strdup_printf("%s/%s", path, RECORDER_MEDIA_NAME);
+
+ dlog_print(DLOG_INFO, LOG_TAG, "recorder media path[%s]", *media_path);
+
+ return false;
+}
+
+static bool audiocodec_fileformat_compatibility_table[RECORDER_AUDIO_CODEC_NUM][RECORDER_FILE_FORMAT_NUM] =
+{ /* 3GP MP4 AMR ADTS WAV OGG M2TS */
+/*AMR*/ {1, 0, 1, 0, 0, 0, 0},
+/*AAC*/ {1, 1, 0, 0, 0, 0, 1},
+/*VORBIS*/ {0, 0, 0, 0, 0, 1, 0},
+/*PCM*/ {0, 0, 0, 0, 1, 0, 0},
+/*MP3*/ {0, 1, 0, 0, 0, 0, 1}
+};
+
+bool _audio_encoder_cb(recorder_audio_codec_e codec, void *user_data)
+{
+ if (user_data) {
+ *((recorder_audio_codec_e *)user_data) = codec;
+ return false;
+ }
+
+ return true;
+}
+
+bool _file_format_cb(recorder_file_format_e format, void *user_data)
+{
+ int *l_user_data = NULL;
+
+ if (user_data) {
+ l_user_data = (int *)user_data;
+ if (audiocodec_fileformat_compatibility_table[l_user_data[USER_DATA_AUDIO_CODEC]][(int)format]) {
+ l_user_data[USER_DATA_FILE_FORMAT] = (int)format;
+ return false;
+ }
+ }
+
+ return true;
+}
+
+static int _get_supported_audio_encoder_and_file_format(recorder_h recorder, int *audio_codec, int *file_format)
+{
+ int ret = RECORDER_ERROR_NONE;
+ int l_audio_codec = RECORDER_AUDIO_CODEC_DISABLE;
+ int l_file_format = -1;
+ int user_data[USER_DATA_MAX];
+
+ if (audio_codec == NULL || file_format == NULL)
+ return RECORDER_ERROR_INVALID_PARAMETER;
+
+ memset(user_data, 0, sizeof(int) * USER_DATA_MAX);
+ ret = recorder_foreach_supported_audio_encoder(recorder, _audio_encoder_cb, &l_audio_codec);
+ assert_eq(ret, RECORDER_ERROR_NONE);
+
+ if ((int)l_audio_codec >= 0 && (int)l_audio_codec < RECORDER_AUDIO_CODEC_NUM) {
+ user_data[USER_DATA_AUDIO_CODEC] = (int)l_audio_codec;
+ ret = recorder_foreach_supported_file_format(recorder, _file_format_cb, user_data);
+ assert_eq(ret, RECORDER_ERROR_NONE);
+
+ l_file_format = (recorder_file_format_e)user_data[USER_DATA_FILE_FORMAT];
+ if ((int)l_file_format >= 0 && (int)l_file_format < RECORDER_FILE_FORMAT_NUM) {
+ *audio_codec = l_audio_codec;
+ *file_format = l_file_format;
+
+ return RECORDER_ERROR_NONE;
+ }
+ }
+
+ return RECORDER_ERROR_NOT_SUPPORTED;
+}
+
+void utc_media_recorder_util_get_media_path(char **media_path)
+{
+ if (!media_path)
+ return;
+
+ storage_foreach_device_supported(_storage_device_cb, (void *)media_path);
+}
+
+int utc_media_recorder_util_prepare_audio_recorder(recorder_h recorder)
+{
+ int ret = RECORDER_ERROR_NONE;
+ int audio_codec = RECORDER_AUDIO_CODEC_DISABLE;
+ int file_format = -1;
+ char *media_path = NULL;
+
+ ret = _get_supported_audio_encoder_and_file_format(recorder, &audio_codec, &file_format);
+
+ if (ret != RECORDER_ERROR_NONE || audio_codec < 0 || file_format < 0) {
+ dlog_print(DLOG_INFO, LOG_TAG, "Audio recording not supported[0x%x,%d,%d]",
+ ret, audio_codec, file_format);
+ return RECORDER_ERROR_NOT_SUPPORTED;
+ }
+
+ utc_media_recorder_util_get_media_path(&media_path);
+
+ ret = recorder_set_audio_encoder(recorder, audio_codec);
+ ret |= recorder_set_file_format(recorder,file_format);
+ ret |= recorder_set_filename(recorder, media_path);
+ ret |= recorder_prepare(recorder);
+
+ dlog_print(DLOG_INFO, LOG_TAG, "Prepare audio recorder ret[0x%x]", ret);
+
+ g_free(media_path);
+
+ return ret;
+}
+
+void utc_media_recorder_util_get_recording_supported(bool *audio_recording_supported, bool *video_recording_supported)
+{
+ if (audio_recording_supported) {
+ system_info_get_platform_bool("http://tizen.org/feature/media.audio_recording", audio_recording_supported);
+ dlog_print(DLOG_INFO, LOG_TAG, "Feature: Audio Recording [%d]", *audio_recording_supported);
+ }
+
+ if (video_recording_supported) {
+ system_info_get_platform_bool("http://tizen.org/feature/media.video_recording", video_recording_supported);
+ dlog_print(DLOG_INFO, LOG_TAG, "Feature: Video Recording [%d]", *video_recording_supported);
+ }
+}
+
+gboolean utc_media_recorder_util_mainloop_quit(gpointer user_data)
+{
+ if (!g_recorder_mainloop)
+ return FALSE;
+
+ dlog_print(DLOG_INFO, LOG_TAG, "QUIT MAINLOOP");
+
+ g_main_loop_quit(g_recorder_mainloop);
+
+ return FALSE;
+}
+
+void utc_media_recorder_util_mainloop_run(void)
+{
+ g_recorder_timeout_id = g_timeout_add(RECORDER_MAINLOOP_TIMEOUT, utc_media_recorder_util_mainloop_quit, NULL);
+ if (g_recorder_timeout_id == 0) {
+ dlog_print(DLOG_ERROR, LOG_TAG, "Failed to add timer");
+ return;
+ }
+
+ g_recorder_mainloop = g_main_loop_new(NULL, FALSE);
+ if (!g_recorder_mainloop) {
+ dlog_print(DLOG_ERROR, LOG_TAG, "Failed to get new mainloop");
+ g_source_remove(g_recorder_timeout_id);
+ g_recorder_timeout_id = 0;
+ return;
+ }
+
+ g_main_loop_run(g_recorder_mainloop);
+
+ if (g_main_context_find_source_by_id(NULL, g_recorder_timeout_id)) {
+ dlog_print(DLOG_INFO, LOG_TAG, "FOUND source[%u]", g_recorder_timeout_id);
+ g_source_remove(g_recorder_timeout_id);
+ } else {
+ dlog_print(DLOG_WARN, LOG_TAG, "NOT FOUND source[%u]", g_recorder_timeout_id);
+ }
+
+ g_recorder_timeout_id = 0;
+
+ g_main_loop_unref(g_recorder_mainloop);
+ g_recorder_mainloop = NULL;
+}
--- /dev/null
+/*
+ * Copyright (c) 2023 Samsung Electronics Co., Ltd.
+ *
+ * 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.
+ */
+
+#ifndef __UTC_MEDIA_RECORDER_UTIL_H__
+#define __UTC_MEDIA_RECORDER_UTIL_H__
+
+#include <glib.h>
+
+bool _audio_encoder_cb(recorder_audio_codec_e codec, void *user_data);
+bool _file_format_cb(recorder_file_format_e format, void *user_data);
+
+int utc_media_recorder_util_prepare_audio_recorder(recorder_h recorder);
+void utc_media_recorder_util_get_media_path(char **media_path);
+void utc_media_recorder_util_get_recording_supported(bool *audio_recording_supported, bool *video_recording_supported);
+
+gboolean utc_media_recorder_util_mainloop_quit(gpointer user_data);
+void utc_media_recorder_util_mainloop_run(void);
+
+#endif /* __UTC_MEDIA_RECORDER_UTIL_H__ */
projects / test / tct / native / api.git / commitdiff