/*=======================================================================================
| INCLUDE FILES |
=======================================================================================*/
-#include <stdio.h>
-#include <stdlib.h>
-#include <glib.h>
-#include <sys/time.h>
-#include <camera.h>
-#include <recorder.h>
-#include <Elementary.h>
-#include <sound_manager.h>
-#include <appcore-efl.h>
+#include "recorder_test.h"
/*-----------------------------------------------------------------------
- | GLOBAL VARIABLE DEFINITIONS: |
+ | GLOBAL VARIABLES: |
-----------------------------------------------------------------------*/
-#define EXPORT_API __attribute__((__visibility__("default")))
-
-
-static int app_create(void *data);
-static int app_terminate(void *data);
-
-struct _appdata {
- Evas_Object *win;
- Evas_Object *eo;
- Evas_Object *bg;
- Evas_Object *rect;
-};
-typedef struct _appdata appdata;
-
-static struct appcore_ops ops = {
- .create = app_create,
- .terminate = app_terminate,
-};
-
-static appdata ad;
-static GIOChannel *stdin_channel;
-static int recorder_state;
-static GTimer *timer = NULL;
+static int g_recorder_state;
+static GTimer *g_recorder_timer = NULL;
static int g_recorder_device_changed_cb_id;
-static int ve_frame_count = 0;
-
-/*-----------------------------------------------------------------------
- | GLOBAL CONSTANT DEFINITIONS: |
- -----------------------------------------------------------------------*/
+static int g_recorder_ve_frame_count = 0;
+static cam_handle_t *g_cam_handle;
/*-----------------------------------------------------------------------
- | IMPORTED VARIABLE DECLARATIONS: |
- -----------------------------------------------------------------------*/
-
-
-/*-----------------------------------------------------------------------
- | IMPORTED FUNCTION DECLARATIONS: |
- -----------------------------------------------------------------------*/
-
-
-/*-----------------------------------------------------------------------
- | LOCAL #defines: |
+ | DEFINITIONS: |
-----------------------------------------------------------------------*/
#define SRC_VIDEO_FRAME_RATE_15 15 /* video input frame rate */
#define SRC_VIDEO_FRAME_RATE_30 30 /* video input frame rate */
-
#define TARGET_FILENAME_PATH "/opt/usr/home/owner/media/"
#define TARGET_FILENAME_VIDEO TARGET_FILENAME_PATH"test_rec_video.mp4"
#define TARGET_FILENAME_AUDIO TARGET_FILENAME_PATH"test_rec_audio.m4a"
#define TARGET_FILENAME_MUXED_CB TARGET_FILENAME_PATH"muxed_stream_cb.mp4"
#define TARGET_FILENAME_VE_DECISION_CB TARGET_FILENAME_PATH"ve_decision_cb.data"
-
#define AUDIO_SOURCE_SAMPLERATE_AAC 44100
#define AUDIO_SOURCE_SAMPLERATE_AMR 8000
#define AUDIO_SOURCE_CHANNEL_AAC 2
#define AUDIO_SOURCE_CHANNEL_AMR 1
#define VIDEO_ENCODE_BITRATE 40000000 /* bps */
-
#define CHECK_MM_ERROR(expr) \
do {\
int ret = 0; \
return; \
} \
} while (0)
-
#ifndef SAFE_FREE
#define SAFE_FREE(x) if (x) { g_free(x); x = NULL; }
#endif
-static struct timeval previous;
-static struct timeval current;
-static struct timeval res;
-
-
/*-----------------------------------------------------------------------
- | LOCAL CONSTANT DEFINITIONS: |
+ | ENUMS: |
-----------------------------------------------------------------------*/
enum {
MODE_VIDEO_CAPTURE, /* recording and image capture mode */
- MODE_AUDIO, /* audio recording*/
+ MODE_AUDIO, /* audio recording*/
MODE_NUM,
};
};
/*-----------------------------------------------------------------------
- | LOCAL DATA TYPE DEFINITIONS: |
+ | DATA STRUCTURES: |
-----------------------------------------------------------------------*/
-typedef struct _cam_handle {
- camera_h camera;
- recorder_h recorder;
- int mode; /*video/audio(recording) mode */
- int menu_state;
- int fps;
- bool isMute;
- unsigned long long elapsed_time;
-} cam_handle_t;
-
typedef struct {
int width[20];
int height[20];
int count;
-} resolution_stack;
+} resolution_stack_t;
/*---------------------------------------------------------------------------
- | LOCAL VARIABLE DEFINITIONS: |
+ | CONSTANT VARIABLES: |
---------------------------------------------------------------------------*/
-static cam_handle_t *hcamcorder;
-
-const char *video_codec[4] = {
+static const char *video_codec[] = {
"H.263",
"H.264",
"MPEG4",
"THEORA"
};
-const char *audio_codec[5] = {
+static const char *audio_codec[] = {
"AMR",
"AAC",
"VORBIS",
"MP3"
};
-const char *file_format[7] = {
+static const char *file_format[] = {
"3GP",
"MP4",
"AMR",
"M2TS"
};
-const char *display_mode[6] = {
+static const char *display_mode[] = {
"Letter Box mode",
"Original Size mode",
"Full Screen mode",
"ROI mode"
};
-const char* strobe_mode[] = {
+static const char* strobe_mode[] = {
"OFF",
"ON",
"Auto",
"Permanent",
};
-const char *vs_mode[] = {
+static const char *vs_mode[] = {
"OFF",
"ON",
};
+
/*---------------------------------------------------------------------------
- | LOCAL FUNCTION PROTOTYPES: |
+ | FUNCTION PROTOTYPES: |
---------------------------------------------------------------------------*/
-static void print_menu();
-static gboolean cmd_input(GIOChannel *channel, GIOCondition condition, gpointer data);
static gboolean init(int type);
static gboolean mode_change(gchar buf);
static bool resolution_cb(int width, int height, void *user_data)
{
- resolution_stack *data = (resolution_stack*)user_data;
+ resolution_stack_t *data = (resolution_stack_t*)user_data;
if (data == NULL) {
g_print("NULL data\n");
static bool _recording_video_encode_decision_cb(recorder_video_data_s *frame, void *user_data)
{
- if (ve_frame_count == 0) {
+ if (g_recorder_ve_frame_count == 0) {
g_print("==== VE decision cb : file[%s][fmt %d, %dx%d, plane %d] ====\n",
TARGET_FILENAME_VE_DECISION_CB,
frame->format, frame->width, frame->height, frame->num_of_planes);
_dump_video_frame(frame);
}
- if ((ve_frame_count++ % 10) >= 5) {
+ if ((g_recorder_ve_frame_count++ % 10) >= 5) {
g_print("-------- VE decision cb : [ret:false]\n");
return false;
} else {
}
-static inline void flush_stdin()
+void flush_stdin()
{
int ch;
while ((ch = getchar()) != EOF && ch != '\n');
{
g_print("destroy recorder handle\n\n");
- recorder_destroy(hcamcorder->recorder);
- hcamcorder->recorder = NULL;
- hcamcorder->menu_state = MENU_STATE_INIT;
+ recorder_destroy(g_cam_handle->recorder);
+ g_cam_handle->recorder = NULL;
+ g_cam_handle->menu_state = MENU_STATE_INIT;
print_menu();
return 0;
switch (idx) {
case 1:
- return recorder_set_muxed_stream_cb(hcamcorder->recorder, _recording_muxed_stream_cb, NULL);
+ return recorder_set_muxed_stream_cb(g_cam_handle->recorder, _recording_muxed_stream_cb, NULL);
case 2:
- return recorder_unset_muxed_stream_cb(hcamcorder->recorder);
+ return recorder_unset_muxed_stream_cb(g_cam_handle->recorder);
default:
return RECORDER_ERROR_INVALID_PARAMETER;
}
flush_stdin();
g_print("-1. DISABLE\n");
- recorder_foreach_supported_audio_encoder(hcamcorder->recorder, audio_codec_cb, (void *)hcamcorder);
+ recorder_foreach_supported_audio_encoder(g_cam_handle->recorder, audio_codec_cb, (void *)g_cam_handle);
err = scanf("%d", &encoder);
- return recorder_set_audio_encoder(hcamcorder->recorder, encoder);
+ return recorder_set_audio_encoder(g_cam_handle->recorder, encoder);
}
flush_stdin();
- recorder_foreach_supported_file_format(hcamcorder->recorder, file_format_cb, (void *)hcamcorder);
+ recorder_foreach_supported_file_format(g_cam_handle->recorder, file_format_cb, (void *)g_cam_handle);
err = scanf("%d", &format);
- return recorder_set_file_format(hcamcorder->recorder, format);
+ return recorder_set_file_format(g_cam_handle->recorder, format);
}
err = scanf("%d", &limit);
- return recorder_attr_set_size_limit(hcamcorder->recorder, limit);
+ return recorder_attr_set_size_limit(g_cam_handle->recorder, limit);
}
err = scanf("%d", &limit);
- return recorder_attr_set_time_limit(hcamcorder->recorder, limit);
+ return recorder_attr_set_time_limit(g_cam_handle->recorder, limit);
}
err = scanf("%d", &samplerate);
- return recorder_attr_set_audio_samplerate(hcamcorder->recorder, samplerate);
+ return recorder_attr_set_audio_samplerate(g_cam_handle->recorder, samplerate);
}
err = scanf("%d", &channel);
- return recorder_attr_set_audio_channel(hcamcorder->recorder, channel);
+ return recorder_attr_set_audio_channel(g_cam_handle->recorder, channel);
}
switch (type) {
case 1:
- return recorder_attr_set_audio_encoder_bitrate(hcamcorder->recorder, bitrate);
+ return recorder_attr_set_audio_encoder_bitrate(g_cam_handle->recorder, bitrate);
case 2:
- return recorder_attr_set_video_encoder_bitrate(hcamcorder->recorder, bitrate);
+ return recorder_attr_set_video_encoder_bitrate(g_cam_handle->recorder, bitrate);
default:
g_print("invalid type [%d]", type);
return -1;
}
-static void print_menu()
+void print_menu()
{
- switch (hcamcorder->menu_state) {
+ switch (g_cam_handle->menu_state) {
case MENU_STATE_INIT:
g_print("\n\t=======================================\n");
g_print("\t RECORDER_TESTSUIT\n");
break;
case MENU_STATE_MAIN:
g_print("\n\t=======================================\n");
- if (hcamcorder->mode == MODE_VIDEO_CAPTURE)
+ if (g_cam_handle->mode == MODE_VIDEO_CAPTURE)
g_print("\t Video + Audio Recording\n");
else
g_print("\t Audio Recording\n");
g_print("\t=======================================\n");
- if (recorder_state <= RECORDER_STATE_NONE) {
+ if (g_recorder_state <= RECORDER_STATE_NONE) {
g_print("\t '1' Start Recording\n");
g_print("\t '2' Setting\n");
g_print("\t 'b' back\n");
- } else if (recorder_state == RECORDER_STATE_RECORDING) {
+ } else if (g_recorder_state == RECORDER_STATE_RECORDING) {
g_print("\t 'p' Pause Recording\n");
g_print("\t 'c' Cancel\n");
g_print("\t 's' Save\n");
- } else if (recorder_state == RECORDER_STATE_PAUSED) {
+ } else if (g_recorder_state == RECORDER_STATE_PAUSED) {
g_print("\t 'r' Resume Recording\n");
g_print("\t 'c' Cancel\n");
g_print("\t 's' Save\n");
break;
case MENU_STATE_SETTING:
- if (hcamcorder->mode == MODE_VIDEO_CAPTURE) {
+ if (g_cam_handle->mode == MODE_VIDEO_CAPTURE) {
g_print("\n\t=======================================\n");
g_print("\t Video + Audio recording > Setting\n");
g_print("\t=======================================\n");
g_print("\t >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [etc]\n");
g_print("\t 's' Strobe (Flash) \n");
g_print("\t 'z' Video-stabilization \n");
- g_print("\t 'm' Camcorder Motion Rate setting \n");
+ g_print("\t 'm' Recording Motion Rate setting \n");
g_print("\t 'M' Set/Unset muxed stream callback \n");
g_print("\t 'E' Set/Unset video encode decision callback \n");
g_print("\t 'F' Set file name - %s\n", TARGET_FILENAME_VIDEO);
{
int err = 0;
- if (hcamcorder->mode != MODE_VIDEO_CAPTURE && hcamcorder->mode != MODE_AUDIO) {
+ if (g_cam_handle->mode != MODE_VIDEO_CAPTURE && g_cam_handle->mode != MODE_AUDIO) {
g_print("\t Invalid mode, back to upper menu \n");
- hcamcorder->menu_state = MENU_STATE_INIT;
+ g_cam_handle->menu_state = MENU_STATE_INIT;
return;
}
- if (recorder_state == RECORDER_STATE_NONE) {
+ if (g_recorder_state == RECORDER_STATE_NONE) {
switch (buf) {
case '1': /* Start Recording */
g_print("*Recording start!\n");
- hcamcorder->elapsed_time = 0;
- ve_frame_count = 0;
+ g_cam_handle->elapsed_time = 0;
+ g_recorder_ve_frame_count = 0;
- g_timer_reset(timer);
- err = recorder_start(hcamcorder->recorder);
+ g_timer_reset(g_recorder_timer);
+ err = recorder_start(g_cam_handle->recorder);
if (err != 0)
g_print("Rec start camcorder_record 0x%x\n", err);
- recorder_state = RECORDER_STATE_RECORDING;
+ g_recorder_state = RECORDER_STATE_RECORDING;
break;
case '2': /* Setting */
- hcamcorder->menu_state = MENU_STATE_SETTING;
+ g_cam_handle->menu_state = MENU_STATE_SETTING;
break;
case 'b': /* back */
- recorder_unprepare(hcamcorder->recorder);
- recorder_destroy(hcamcorder->recorder);
- hcamcorder->recorder = NULL;
+ recorder_unprepare(g_cam_handle->recorder);
+ recorder_destroy(g_cam_handle->recorder);
+ g_cam_handle->recorder = NULL;
- if (hcamcorder->camera) {
- camera_destroy(hcamcorder->camera);
- hcamcorder->camera = NULL;
+ if (g_cam_handle->camera) {
+ camera_destroy(g_cam_handle->camera);
+ g_cam_handle->camera = NULL;
}
- hcamcorder->menu_state = MENU_STATE_INIT;
+ g_cam_handle->menu_state = MENU_STATE_INIT;
break;
default:
g_print("\t Invalid input \n");
break;
}
- } else if (recorder_state == RECORDER_STATE_RECORDING || recorder_state == RECORDER_STATE_PAUSED) {
+ } else if (g_recorder_state == RECORDER_STATE_RECORDING || g_recorder_state == RECORDER_STATE_PAUSED) {
switch (buf) {
case 'p': /* Pause Recording */
g_print("*Pause!\n");
- err = recorder_pause(hcamcorder->recorder);
+ err = recorder_pause(g_cam_handle->recorder);
if (err < 0)
g_print("Rec pause camcorder_pause = %x\n", err);
- recorder_state = RECORDER_STATE_PAUSED;
+ g_recorder_state = RECORDER_STATE_PAUSED;
break;
case 'r': /* Resume Recording */
g_print("*Resume!\n");
- err = recorder_start(hcamcorder->recorder);
+ err = recorder_start(g_cam_handle->recorder);
if (err < 0)
g_print("Rec start camcorder_record = %x\n", err);
- recorder_state = RECORDER_STATE_RECORDING;
+ g_recorder_state = RECORDER_STATE_RECORDING;
break;
case 'c': /* Cancel */
g_print("*Cancel Recording !\n");
- err = recorder_cancel(hcamcorder->recorder);
+ err = recorder_cancel(g_cam_handle->recorder);
if (err < 0)
g_print("Cancel recording camcorder_cancel = %x\n", err);
- recorder_state = RECORDER_STATE_NONE;
+ g_recorder_state = RECORDER_STATE_NONE;
break;
case 's': /* Save */
g_print("*Save Recording!\n");
- g_timer_reset(timer);
+ g_timer_reset(g_recorder_timer);
- err = recorder_commit(hcamcorder->recorder);
+ err = recorder_commit(g_cam_handle->recorder);
if (err < 0)
g_print("Save recording recorder_commit = %x\n", err);
- recorder_state = RECORDER_STATE_NONE;
+ g_recorder_state = RECORDER_STATE_NONE;
break;
default:
int result = 0;
int bitrate = 0;
- if (hcamcorder->mode == MODE_VIDEO_CAPTURE) {
+ if (g_cam_handle->mode == MODE_VIDEO_CAPTURE) {
int x = 0;
int y = 0;
int width = 0;
int height = 0;
float motion_rate = 0.0;
- resolution_stack resolution_list;
+ resolution_stack_t resolution_list;
switch (buf) {
/* Camera/Recorder setting */
flush_stdin();
- camera_foreach_supported_preview_resolution(hcamcorder->camera,
+ camera_foreach_supported_preview_resolution(g_cam_handle->camera,
resolution_cb, &resolution_list);
err = scanf("%d", &idx);
g_print("----------------- SET %dx%d ---------------------\n",
resolution_list.width[idx], resolution_list.height[idx]);
- result = camera_set_preview_resolution(hcamcorder->camera,
+ result = camera_set_preview_resolution(g_cam_handle->camera,
resolution_list.width[idx], resolution_list.height[idx]);
} else {
g_print("invalid input %d\n", idx);
flush_stdin();
- recorder_foreach_supported_video_resolution(hcamcorder->recorder,
+ recorder_foreach_supported_video_resolution(g_cam_handle->recorder,
resolution_cb, &resolution_list);
err = scanf("%d", &idx);
g_print("----------------- SET %dx%d ---------------------\n",
resolution_list.width[idx], resolution_list.height[idx]);
- result = recorder_set_video_resolution(hcamcorder->recorder,
+ result = recorder_set_video_resolution(g_cam_handle->recorder,
resolution_list.width[idx], resolution_list.height[idx]);
} else {
g_print("invalid input %d\n", idx);
flush_stdin();
- recorder_foreach_supported_video_encoder(hcamcorder->recorder, video_codec_cb, (void *)hcamcorder);
+ recorder_foreach_supported_video_encoder(g_cam_handle->recorder, video_codec_cb, (void *)g_cam_handle);
err = scanf("%d", &idx);
- result = recorder_set_video_encoder(hcamcorder->recorder, idx);
+ result = recorder_set_video_encoder(g_cam_handle->recorder, idx);
break;
case '3': /* Setting > Audio codec */
err = scanf("%d", &idx);
- result = camera_set_display_visible(hcamcorder->camera, idx);
+ result = camera_set_display_visible(g_cam_handle->camera, idx);
break;
case 'd': /* Setting > Display mode */
err = scanf("%d %d %d %d", &x, &y, &width, &height);
}
- result = camera_set_display_mode(hcamcorder->camera, idx - 1);
+ result = camera_set_display_mode(g_cam_handle->camera, idx - 1);
if (idx == CAMERA_DISPLAY_MODE_CUSTOM_ROI)
- result |= camera_attr_set_display_roi_area(hcamcorder->camera, x, y, width, height);
+ result |= camera_attr_set_display_roi_area(g_cam_handle->camera, x, y, width, height);
break;
case 'r': /* Setting > Display Rotate */
err = scanf("%d", &idx);
- result = camera_set_display_rotation(hcamcorder->camera, idx);
+ result = camera_set_display_rotation(g_cam_handle->camera, idx);
break;
case 'f': /* Setting > Display Flip */
err = scanf("%d", &idx);
- result = camera_set_display_flip(hcamcorder->camera, idx);
+ result = camera_set_display_flip(g_cam_handle->camera, idx);
break;
/* ext. setting */
flush_stdin();
- camera_attr_foreach_supported_flash_mode(hcamcorder->camera, strobe_mode_cb, NULL);
+ camera_attr_foreach_supported_flash_mode(g_cam_handle->camera, strobe_mode_cb, NULL);
err = scanf("%d", &idx);
- result = camera_attr_set_flash_mode(hcamcorder->camera, idx);
+ result = camera_attr_set_flash_mode(g_cam_handle->camera, idx);
break;
case 'z': /* Setting > Video-stabilization */
if (idx == 2) {
g_print("\n Restart preview with NV12 and 720p resolution\n");
- result = camera_stop_preview(hcamcorder->camera);
- result |= camera_set_preview_resolution(hcamcorder->camera, 1280, 720);
- result |= camera_set_preview_format(hcamcorder->camera, CAMERA_PIXEL_FORMAT_NV12);
+ result = camera_stop_preview(g_cam_handle->camera);
+ result |= camera_set_preview_resolution(g_cam_handle->camera, 1280, 720);
+ result |= camera_set_preview_format(g_cam_handle->camera, CAMERA_PIXEL_FORMAT_NV12);
- result |= camera_attr_enable_video_stabilization(hcamcorder->camera, idx-1);
+ result |= camera_attr_enable_video_stabilization(g_cam_handle->camera, idx-1);
if (result == 0)
- result |= camera_start_preview(hcamcorder->camera);
+ result |= camera_start_preview(g_cam_handle->camera);
}
break;
case 'm':
- g_print("*Camcorder Motion Rate setting! (should be bigger than zero)\n");
+ g_print("*Recording Motion Rate setting! (should be bigger than zero)\n");
flush_stdin();
err = scanf("%f", &motion_rate);
- result = recorder_attr_set_recording_motion_rate(hcamcorder->recorder, motion_rate);
+ result = recorder_attr_set_recording_motion_rate(g_cam_handle->recorder, motion_rate);
break;
case 'M': /* Setting > muxed stream callback */
err = scanf("%d", &idx);
if (idx == 1)
- result = recorder_set_video_encode_decision_cb(hcamcorder->recorder, _recording_video_encode_decision_cb, NULL);
+ result = recorder_set_video_encode_decision_cb(g_cam_handle->recorder, _recording_video_encode_decision_cb, NULL);
else if (idx == 2)
- result = recorder_unset_video_encode_decision_cb(hcamcorder->recorder);
+ result = recorder_unset_video_encode_decision_cb(g_cam_handle->recorder);
else
result = RECORDER_ERROR_INVALID_PARAMETER;
break;
case 'F': /* Set file name */
- result = recorder_set_filename(hcamcorder->recorder, TARGET_FILENAME_VIDEO);
+ result = recorder_set_filename(g_cam_handle->recorder, TARGET_FILENAME_VIDEO);
break;
case 'b': /* back */
- hcamcorder->menu_state = MENU_STATE_MAIN;
+ g_cam_handle->menu_state = MENU_STATE_MAIN;
break;
default:
err = scanf("%d", &bitrate);
- result = recorder_attr_set_audio_encoder_bitrate(hcamcorder->recorder, bitrate);
+ result = recorder_attr_set_audio_encoder_bitrate(g_cam_handle->recorder, bitrate);
break;
case 'M': /* Setting > muxed stream callback */
break;
case 'F': /* Set file name */
- result = recorder_set_filename(hcamcorder->recorder, TARGET_FILENAME_AUDIO);
+ result = recorder_set_filename(g_cam_handle->recorder, TARGET_FILENAME_AUDIO);
break;
case 'b': /* back */
- hcamcorder->menu_state = MENU_STATE_MAIN;
+ g_cam_handle->menu_state = MENU_STATE_MAIN;
break;
default:
}
-/**
- * This function is to execute command.
- *
- * @param channel [in] 1st parameter
- *
- * @return This function returns TRUE/FALSE
- * @remark
- * @see
- */
-static gboolean cmd_input(GIOChannel *channel, GIOCondition condition, gpointer data)
+gboolean cmd_input(GIOChannel *channel, GIOCondition condition, gpointer data)
{
gchar *buf = NULL;
gsize read_size;
if (buf) {
g_strstrip(buf);
- g_print("\n\tMenu Status : %d\n", hcamcorder->menu_state);
- switch (hcamcorder->menu_state) {
+ g_print("\n\tMenu Status : %d\n", g_cam_handle->menu_state);
+ switch (g_cam_handle->menu_state) {
case MENU_STATE_INIT:
mode_change(buf[0]);
break;
{
int ret;
- if (!hcamcorder || !hcamcorder->recorder) {
- g_print("NULL handle[%p]\n", hcamcorder);
+ if (!g_cam_handle || !g_cam_handle->recorder) {
+ g_print("NULL handle[%p]\n", g_cam_handle);
return FALSE;
}
- ret = recorder_set_file_format(hcamcorder->recorder, RECORDER_FILE_FORMAT_MP4);
+ ret = recorder_set_file_format(g_cam_handle->recorder, RECORDER_FILE_FORMAT_MP4);
if (ret != RECORDER_ERROR_NONE) {
g_print("recorder_set_file_format failed[0x%x]\n", ret);
return FALSE;
}
- ret = recorder_attr_set_audio_device(hcamcorder->recorder, RECORDER_AUDIO_DEVICE_MIC);
+ ret = recorder_attr_set_audio_device(g_cam_handle->recorder, RECORDER_AUDIO_DEVICE_MIC);
if (ret != RECORDER_ERROR_NONE) {
g_print("recorder_attr_set_audio_device failed[0x%x]\n", ret);
return FALSE;
}
- ret = recorder_set_audio_encoder(hcamcorder->recorder, RECORDER_AUDIO_CODEC_AAC);
+ ret = recorder_set_audio_encoder(g_cam_handle->recorder, RECORDER_AUDIO_CODEC_AAC);
if (ret != RECORDER_ERROR_NONE) {
g_print("recorder_set_audio_encoder failed[0x%x]\n", ret);
return FALSE;
}
- ret = recorder_attr_set_audio_samplerate(hcamcorder->recorder, AUDIO_SOURCE_SAMPLERATE_AAC);
+ ret = recorder_attr_set_audio_samplerate(g_cam_handle->recorder, AUDIO_SOURCE_SAMPLERATE_AAC);
if (ret != RECORDER_ERROR_NONE) {
g_print("recorder_attr_set_audio_samplerate failed[0x%x]\n", ret);
return FALSE;
}
- ret = recorder_attr_set_audio_channel(hcamcorder->recorder, AUDIO_SOURCE_CHANNEL_AAC);
+ ret = recorder_attr_set_audio_channel(g_cam_handle->recorder, AUDIO_SOURCE_CHANNEL_AAC);
if (ret != RECORDER_ERROR_NONE) {
g_print("recorder_attr_set_audio_channel failed[0x%x]\n", ret);
return FALSE;
/*================================================================================
Video capture mode
*=================================================================================*/
- ret = recorder_set_video_encoder(hcamcorder->recorder, RECORDER_VIDEO_CODEC_MPEG4);
+ ret = recorder_set_video_encoder(g_cam_handle->recorder, RECORDER_VIDEO_CODEC_MPEG4);
if (ret != RECORDER_ERROR_NONE) {
g_print("recorder_set_video_encoder failed[0x%x]\n", ret);
return FALSE;
}
- ret = recorder_attr_set_video_encoder_bitrate(hcamcorder->recorder, VIDEO_ENCODE_BITRATE);
+ ret = recorder_attr_set_video_encoder_bitrate(g_cam_handle->recorder, VIDEO_ENCODE_BITRATE);
if (ret != RECORDER_ERROR_NONE) {
g_print("recorder_attr_set_video_encoder_bitrate failed[0x%x]\n", ret);
return FALSE;
/*================================================================================
Audio mode
*=================================================================================*/
- ret = recorder_attr_set_time_limit(hcamcorder->recorder, 360000);
+ ret = recorder_attr_set_time_limit(g_cam_handle->recorder, 360000);
if (ret != RECORDER_ERROR_NONE) {
g_print("recorder_attr_set_time_limit failed[0x%x]\n", ret);
return FALSE;
}
- ret = recorder_attr_set_audio_encoder_bitrate(hcamcorder->recorder, 128000);
+ ret = recorder_attr_set_audio_encoder_bitrate(g_cam_handle->recorder, 128000);
if (ret != RECORDER_ERROR_NONE) {
g_print("recorder_attr_set_audio_encoder_bitrate failed[0x%x]\n", ret);
return FALSE;
}
}
- recorder_set_error_cb(hcamcorder->recorder, _recorder_error_cb, NULL);
- recorder_set_state_changed_cb(hcamcorder->recorder, _state_changed_cb, NULL);
- recorder_set_interrupted_cb(hcamcorder->recorder, _interrupted_cb, NULL);
- recorder_set_recording_status_cb(hcamcorder->recorder, _recording_status_cb, NULL);
- recorder_set_recording_limit_reached_cb(hcamcorder->recorder, _recording_limit_reached_cb, NULL);
+ recorder_set_error_cb(g_cam_handle->recorder, _recorder_error_cb, NULL);
+ recorder_set_state_changed_cb(g_cam_handle->recorder, _state_changed_cb, NULL);
+ recorder_set_interrupted_cb(g_cam_handle->recorder, _interrupted_cb, NULL);
+ recorder_set_recording_status_cb(g_cam_handle->recorder, _recording_status_cb, NULL);
+ recorder_set_recording_limit_reached_cb(g_cam_handle->recorder, _recording_limit_reached_cb, NULL);
g_print("Init DONE.\n");
return TRUE;
}
-static gboolean init_handle()
+cam_handle_t *init_handle()
{
- hcamcorder->mode = MODE_VIDEO_CAPTURE; /* image(capture)/video(recording) mode */
- hcamcorder->menu_state = MENU_STATE_INIT;
- hcamcorder->isMute = FALSE;
- hcamcorder->elapsed_time = 0;
- hcamcorder->fps = SRC_VIDEO_FRAME_RATE_15; /*SRC_VIDEO_FRAME_RATE_30;*/
+ g_cam_handle = g_new0(cam_handle_t, 1);
- return TRUE;
+ g_cam_handle->mode = MODE_VIDEO_CAPTURE; /* image(capture)/video(recording) mode */
+ g_cam_handle->menu_state = MENU_STATE_INIT;
+ g_cam_handle->isMute = FALSE;
+ g_cam_handle->elapsed_time = 0;
+ g_cam_handle->fps = SRC_VIDEO_FRAME_RATE_15; /*SRC_VIDEO_FRAME_RATE_30;*/
+
+ return g_cam_handle;
}
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,
int state = RECORDER_STATE_NONE;
char media_type = '\0';
bool check = FALSE;
+ struct timeval time_previous;
+ struct timeval time_current;
+ struct timeval time_result;
recorder_device_state_e device_state = RECORDER_DEVICE_STATE_IDLE;
sound_stream_info_h stream_info = NULL;
- gettimeofday(&previous, NULL);
- g_timer_reset(timer);
+ gettimeofday(&time_previous, NULL);
+ g_timer_reset(g_recorder_timer);
- if (hcamcorder->recorder) {
- err = recorder_get_state(hcamcorder->recorder, (recorder_state_e*)&state);
+ if (g_cam_handle->recorder) {
+ err = recorder_get_state(g_cam_handle->recorder, (recorder_state_e*)&state);
if (state != RECORDER_STATE_NONE) {
if (state == RECORDER_STATE_RECORDING ||
state == RECORDER_STATE_PAUSED) {
g_print("recorder_cancel\n");
- err = recorder_cancel(hcamcorder->recorder);
+ err = recorder_cancel(g_cam_handle->recorder);
if (err != RECORDER_ERROR_NONE) {
g_print("exit recorder_cancel failed 0x%x\n", err);
return FALSE;
}
}
- err = recorder_get_state(hcamcorder->recorder, (recorder_state_e*)&state);
+ err = recorder_get_state(g_cam_handle->recorder, (recorder_state_e*)&state);
if (state == RECORDER_STATE_READY) {
g_print("recorder_unprepare\n");
- recorder_unprepare(hcamcorder->recorder);
+ recorder_unprepare(g_cam_handle->recorder);
}
- err = recorder_get_state(hcamcorder->recorder, (recorder_state_e*)&state);
+ err = recorder_get_state(g_cam_handle->recorder, (recorder_state_e*)&state);
if (state == RECORDER_STATE_CREATED) {
g_print("recorder_destroy\n");
- err = recorder_destroy(hcamcorder->recorder);
+ err = recorder_destroy(g_cam_handle->recorder);
if (err == RECORDER_ERROR_NONE) {
g_print("recorder_destroy done\n");
- hcamcorder->recorder = NULL;
+ g_cam_handle->recorder = NULL;
}
}
}
}
- init_handle();
-
switch (buf) {
case '1':
- hcamcorder->mode = MODE_VIDEO_CAPTURE;
-
- g_print("camera_create\n");
+ g_cam_handle->mode = MODE_VIDEO_CAPTURE;
- err = camera_create(CAMERA_DEVICE_CAMERA0, &hcamcorder->camera);
+ err = camera_create(CAMERA_DEVICE_CAMERA0, &g_cam_handle->camera);
if (err != CAMERA_ERROR_NONE) {
g_print("camera create failed 0x%d\n", err);
return FALSE;
}
- err = camera_set_display(hcamcorder->camera, CAMERA_DISPLAY_TYPE_OVERLAY, GET_DISPLAY(ad.win));
- if (err != CAMERA_ERROR_NONE) {
- g_print("set display failed 0x%d\n", err);
- camera_destroy(hcamcorder->camera);
- hcamcorder->camera = NULL;
- return FALSE;
- }
+ set_display(g_cam_handle);
- err = recorder_create_videorecorder(hcamcorder->camera, &hcamcorder->recorder);
+ err = recorder_create_videorecorder(g_cam_handle->camera, &g_cam_handle->recorder);
if (err != RECORDER_ERROR_NONE) {
g_print("video recorder create failed 0x%d\n", err);
- camera_stop_preview(hcamcorder->camera);
- camera_destroy(hcamcorder->camera);
- hcamcorder->camera = NULL;
+ camera_stop_preview(g_cam_handle->camera);
+ camera_destroy(g_cam_handle->camera);
+ g_cam_handle->camera = NULL;
return FALSE;
}
check = TRUE;
break;
case '2':
- hcamcorder->mode = MODE_AUDIO;
- err = recorder_create_audiorecorder(&hcamcorder->recorder);
+ g_cam_handle->mode = MODE_AUDIO;
+ err = recorder_create_audiorecorder(&g_cam_handle->recorder);
if (err != RECORDER_ERROR_NONE) {
g_print("audio recorder create failed 0x%x\n", err);
return FALSE;
check = TRUE;
break;
case '3':
- hcamcorder->mode = MODE_AUDIO;
- err = recorder_create_audiorecorder(&hcamcorder->recorder);
+ g_cam_handle->mode = MODE_AUDIO;
+ err = recorder_create_audiorecorder(&g_cam_handle->recorder);
if (err != RECORDER_ERROR_NONE) {
g_print("audio recorder create failed 0x%d\n", err);
return FALSE;
}
- sound_manager_create_stream_information(SOUND_STREAM_TYPE_MEDIA, _sound_stream_focus_state_changed_cb, hcamcorder, &stream_info);
+ sound_manager_create_stream_information(SOUND_STREAM_TYPE_MEDIA, _sound_stream_focus_state_changed_cb, g_cam_handle, &stream_info);
if (stream_info) {
- recorder_set_sound_stream_info(hcamcorder->recorder, stream_info);
+ recorder_set_sound_stream_info(g_cam_handle->recorder, stream_info);
sound_manager_destroy_stream_information(stream_info);
}
g_print("get result 0x%x - video state %d\n", err, device_state);
return FALSE;
case 'q':
- g_print("\t Quit Camcorder Testsuite!!\n");
- hcamcorder->mode = -1;
- elm_exit();
+ g_print("\t Quit Recorder Testsuite!!\n");
+ g_cam_handle->mode = -1;
+ quit_test();
return FALSE;
default:
g_print("\t Invalid media type(%c)\n", media_type);
return FALSE;
}
- if (!init(hcamcorder->mode)) {
+ if (!init(g_cam_handle->mode)) {
g_print("testsuite init() failed.\n");
return FALSE;
}
- err = recorder_prepare(hcamcorder->recorder);
+ err = recorder_prepare(g_cam_handle->recorder);
- g_print("recorder_prepare() : %12.6lfs\n", g_timer_elapsed(timer, NULL));
+ g_print("recorder_prepare() : %12.6lfs\n", g_timer_elapsed(g_recorder_timer, NULL));
if (err != RECORDER_ERROR_NONE) {
g_print("recorder_prepare = %x\n", err);
return FALSE;
}
- gettimeofday(¤t, NULL);
- timersub(¤t, &previous, &res);
+ gettimeofday(&time_current, NULL);
+ timersub(&time_current, &time_previous, &time_result);
- g_print("Recorder Preparing Time : %ld.%lds\n", res.tv_sec, res.tv_usec);
+ g_print("Recorder Preparing Time : %ld.%lds\n", time_result.tv_sec, time_result.tv_usec);
- hcamcorder->menu_state = MENU_STATE_MAIN;
+ g_cam_handle->menu_state = MENU_STATE_MAIN;
return TRUE;
}
-
-
-static int app_create(void *data)
-{
- appdata *app_data = data;
- int w = 0;
- int h = 0;
- Evas_Object *win = NULL;
- Evas_Object *eo = NULL;
- Evas_Object *bg = NULL;
- Evas_Object *rect = NULL;
-
- if (app_data == NULL) {
- g_print("\t\nappdata is NULL\n");
- return 0;
- }
-
- /* use gl backend */
- elm_config_accel_preference_set("opengl");
-
- win = elm_win_add(NULL, "camera_test", ELM_WIN_BASIC);
- if (win) {
- elm_win_title_set(win, "camera_test");
- elm_win_borderless_set(win, EINA_TRUE);
- elm_win_screen_size_get(win, NULL, NULL, &w, &h);
- g_print("\n\tscreen size %dx%d\n\n", w, h);
- evas_object_resize(win, w, h);
- elm_win_autodel_set(win, EINA_TRUE);
- elm_win_alpha_set(win, EINA_TRUE);
- } else {
- g_print("\n\tfailed to get window\n\n");
- return 1;
- }
-
- bg = elm_bg_add(win);
- if (bg) {
- elm_win_resize_object_add(win, bg);
- evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
- evas_object_show(bg);
- } else {
- g_print("\n\tfailed to get elm bg\n\n");
- return 1;
- }
-
- rect = evas_object_rectangle_add(evas_object_evas_get(win));
- if (rect) {
- evas_object_color_set(rect, 0, 0, 0, 0);
- evas_object_render_op_set(rect, EVAS_RENDER_COPY);
- } else {
- g_print("\n\tfailed to get rectangle\n\n");
- return 1;
- }
-
- elm_win_resize_object_add(win, rect);
- evas_object_size_hint_weight_set(rect, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
- evas_object_show(rect);
-
- /* Create evas image object for EVAS surface */
- eo = evas_object_image_add(evas_object_evas_get(win));
- evas_object_image_size_set(eo, w, h);
- evas_object_image_fill_set(eo, 0, 0, w, h);
- evas_object_resize(eo, w, h);
- evas_object_show(eo);
-
- elm_win_activate(win);
- evas_object_show(win);
-
- app_data->win = win;
- app_data->eo = eo;
-
- timer = g_timer_new();
- g_timer_reset(timer);
-
- init_handle();
-
- print_menu();
-
- return 0;
-}
-
-static int app_terminate(void *data)
-{
- appdata *app_data = data;
-
- if (app_data == NULL) {
- g_print("\n\tappdata is NULL\n");
- return 0;
- }
-
- if (timer) {
- g_timer_stop(timer);
- g_timer_destroy(timer);
- timer = NULL;
- }
-
- return 0;
-}
-
-
-/**
- * This function is the example main function for mmcamcorder API.
- *
- * @param
- *
- * @return This function returns 0.
- * @remark
- * @see other functions
- */
-int main(int argc, char **argv)
-{
- int bret;
-
- hcamcorder = (cam_handle_t *)g_malloc0(sizeof(cam_handle_t));
- recorder_state = RECORDER_STATE_NONE;
-
- stdin_channel = g_io_channel_unix_new(fileno(stdin));/* read from stdin */
- g_io_add_watch(stdin_channel, G_IO_IN, (GIOFunc)cmd_input, NULL);
-
- memset(&ad, 0x0, sizeof(appdata));
- ops.data = &ad;
-
- bret = appcore_efl_main("recorder_test", &argc, &argv, &ops);
-
- g_print("\n\treturn appcore_efl : %d\n\n", bret);
-
- g_free(hcamcorder);
- g_io_channel_unref(stdin_channel);
-
- return bret;
-}
-/*EOF*/
projects / platform / core / api / recorder.git / commitdiff