10/10/07 wh01.cho@samsung.com Created
12/30/08 jh1979.park@samsung.com Modified
08/31/11 sc11.lee@samsung.com Modified (Reorganized for easy look)
+10/23/14 p.gamov@samsung.com Upgraded to Gstreamer 1.0
*/
#include "../src/include/mm_camcorder_internal.h"
#include "../src/include/mm_camcorder_util.h"
#include <gst/video/colorbalance.h>
-#include <mm_ta.h>
/*-----------------------------------------------------------------------
| GLOBAL VARIABLE DEFINITIONS: |
#define SRC_H_480 480
//QVGA
-#define SRC_W_320 320 // video input width
+#define SRC_W_320 320 // video input width
#define SRC_H_240 240 // video input height
//QCIF
-#define SRC_W_176 176 // video input width
+#define SRC_W_176 176 // video input width
#define SRC_H_144 144 // video input height
//QQVGA
-#define SRC_W_160 160 // video input width
+#define SRC_W_160 160 // video input width
#define SRC_H_120 120 // video input heith
//special resolution
-#define SRC_W_400 400 // video input width
+#define SRC_W_400 400 // video input width
#define SRC_H_300 300 // video input height
-#define SRC_W_192 192 // video input width
+#define SRC_W_192 192 // video input width
#define SRC_H_256 256 // video input height
-#define SRC_W_144 144 // video input width
+#define SRC_W_144 144 // video input width
#define SRC_H_176 176 // video input height
#define SRC_W_300 300
#define SRC_W_400 400
-#define DISPLAY_X_0 0 //for direct FB
-#define DISPLAY_Y_0 0 //for direct FB
+#define DISPLAY_X_0 0 //for direct FB
+#define DISPLAY_Y_0 0 //for direct FB
-#define DISPLAY_W_320 320 //for direct FB
-#define DISPLAY_H_240 240 //for direct FB
+#define DISPLAY_W_320 320 //for direct FB
+#define DISPLAY_H_240 240 //for direct FB
#define SRC_VIDEO_FRAME_RATE_15 15 // video input frame rate
#define SRC_VIDEO_FRAME_RATE_30 30 // video input frame rate
-#define IMAGE_ENC_QUALITY 85 // quality of jpeg
+#define IMAGE_ENC_QUALITY 85 // quality of jpeg
#define IMAGE_CAPTURE_COUNT_STILL 1 // the number of still-shot
#define IMAGE_CAPTURE_COUNT_MULTI 3 // default the number of multi-shot
#define IMAGE_CAPTURE_COUNT_INTERVAL 100 // mili seconds
#define EXT_AMR "amr"
#define EXT_MKV "mkv"
-#define STILL_CAPTURE_FILE_PATH_NAME "/opt/media/StillshotCapture"
-#define MULTI_CAPTURE_FILE_PATH_NAME "/opt/media/MultishotCapture"
-#define IMAGE_CAPTURE_THUMBNAIL_PATH "/opt/media/thumbnail.jpg"
-#define IMAGE_CAPTURE_SCREENNAIL_PATH "/opt/media/screennail.yuv"
-#define IMAGE_CAPTURE_EXIF_PATH "/opt/media/exif.raw"
-#define TARGET_FILENAME_PATH "/opt/media/"
-#define TARGET_FILENAME_VIDEO "/opt/media/test_rec_video.3gp"
-#define TARGET_FILENAME_AUDIO "/opt/media/test_rec_audio.amr"
+#define TARGET_FILENAME_PATH "/opt/usr/media/"
+#define STILL_CAPTURE_FILE_PATH_NAME TARGET_FILENAME_PATH"StillshotCapture"
+#define MULTI_CAPTURE_FILE_PATH_NAME TARGET_FILENAME_PATH"MultishotCapture"
+#define IMAGE_CAPTURE_THUMBNAIL_PATH TARGET_FILENAME_PATH"thumbnail.jpg"
+#define IMAGE_CAPTURE_SCREENNAIL_PATH TARGET_FILENAME_PATH"screennail.yuv"
+#define IMAGE_CAPTURE_EXIF_PATH TARGET_FILENAME_PATH"exif.raw"
+#define TARGET_FILENAME_VIDEO TARGET_FILENAME_PATH"test_rec_video.mp4"
+#define TARGET_FILENAME_AUDIO TARGET_FILENAME_PATH"test_rec_audio.m4a"
#define CAPTURE_FILENAME_LEN 256
#define AUDIO_SOURCE_SAMPLERATE_AAC 44100
int ret = 0; \
ret = expr; \
if (ret != MM_ERROR_NONE) {\
- printf("[%s:%d] error code : %x \n", __func__, __LINE__, ret); \
+ g_print("[%s:%d] error code : %x \n", __func__, __LINE__, ret); \
return; \
}\
} while(0)
do { \
fprintf(stderr, MMF_DEBUG"[%s:%05d] " fmt "\n",__func__, __LINE__, ##arg); \
} while(0)
-
+
#define err_msg_t(fmt,arg...) \
do { \
fprintf(stderr, MMF_ERR"[%s:%05d] " fmt "\n",__func__, __LINE__, ##arg); \
} while(0)
#ifndef SAFE_FREE
-#define SAFE_FREE(x) if(x) {g_free(x); x = NULL;}
+#define SAFE_FREE(x) if(x) {free(x); x = NULL;}
#endif
+#ifndef SAFE_G_FREE
+#define SAFE_G_FREE(x) if(x) {g_free(x); x = NULL;}
+#endif
GTimeVal previous;
GTimeVal current;
* Enumerations for command
*/
#define SENSOR_WHITEBALANCE_NUM 10
-#define SENSOR_COLOR_TONE_NUM 37
+#define SENSOR_COLOR_TONE_NUM 30
#define SENSOR_FLIP_NUM 3
#define SENSOR_PROGRAM_MODE_NUM 15
#define SENSOR_FOCUS_NUM 6
/*-----------------------------------------------------------------------
| LOCAL CONSTANT DEFINITIONS: |
-----------------------------------------------------------------------*/
-enum
+enum
{
MODE_VIDEO_CAPTURE, /* recording and image capture mode */
- MODE_AUDIO, /* audio recording*/
- MODE_NUM,
+ MODE_AUDIO, /* audio recording*/
+ MODE_NUM,
};
enum
bool isMultishot; /* flag for multishot mode */
int stillshot_count; /* total stillshot count */
int multishot_count; /* total multishot count */
- char *stillshot_filename; /* stored filename of stillshot */
- char *multishot_filename; /* stored filename of multishot */
+ const char *stillshot_filename; /* stored filename of stillshot */
+ const char *multishot_filename; /* stored filename of multishot */
int menu_state;
int fps;
bool isMute;
typedef struct _cam_xypair
{
- char* attr_subcat_x;
- char* attr_subcat_y;
+ const char *attr_subcat_x;
+ const char *attr_subcat_y;
int x;
int y;
} cam_xypair_t;
---------------------------------------------------------------------------*/
static cam_handle_t *hcamcorder ;
-char *wb[SENSOR_WHITEBALANCE_NUM]={
+const char *wb[SENSOR_WHITEBALANCE_NUM]={
"None",
"Auto",
"Daylight",
"Cloudy",
- "Fluoroscent",
+ "Fluoroscent",
"Incandescent",
"Shade",
"Horizon",
"Custom",
};
-char *ct[SENSOR_COLOR_TONE_NUM] = {
+const char *ct[SENSOR_COLOR_TONE_NUM] = {
"NONE",
"MONO",
"SEPIA",
"SELECTVE_COLOR_RED_YELLOW",
};
-char *flip[SENSOR_FLIP_NUM] = {
+const char *flip[SENSOR_FLIP_NUM] = {
"Horizontal",
"Vertical",
"Not flipped",
};
-char *program_mode[SENSOR_PROGRAM_MODE_NUM] = {
+const char *program_mode[SENSOR_PROGRAM_MODE_NUM] = {
"NORMAL",
"PORTRAIT",
"LANDSCAPE",
"BACKLIGHT",
};
-char *focus_mode[SENSOR_FOCUS_NUM] = {
+const char *focus_mode[SENSOR_FOCUS_NUM] = {
"None",
"Pan",
"Auto",
"Continuous Auto",
};
-char *camera_rotation[SENSOR_INPUT_ROTATION] = {
+const char *camera_rotation[SENSOR_INPUT_ROTATION] = {
"None",
"90",
"180",
"270",
};
-char *af_scan[SENSOR_AF_SCAN_NUM] = {
+const char *af_scan[SENSOR_AF_SCAN_NUM] = {
"None",
"Normal",
"Macro mode",
"Full mode",
};
-char *iso_name[SENSOR_ISO_NUM] = {
+const char *iso_name[SENSOR_ISO_NUM] = {
"ISO Auto",
"ISO 50",
"ISO 100",
"ISO 3200",
};
-char *exposure_mode[SENSOR_EXPOSURE_NUM] = {
+const char *exposure_mode[SENSOR_EXPOSURE_NUM] = {
"AE off",
"AE all mode",
"AE center 1 mode",
"AE center 2 mode",
"AE center 3 mode",
- "AE spot 1 mode",
- "AE spot 2 mode",
+ "AE spot 1 mode",
+ "AE spot 2 mode",
"AE custom 1 mode",
"AE custom 2 mode",
};
-char *image_fmt[SENSOR_IMAGE_FORMAT] = {
+const char *image_fmt[SENSOR_IMAGE_FORMAT] = {
"NV12",
"NV12T",
"NV16",
"YV12",
};
-char *face_zoom_mode[] = {
+const char *face_zoom_mode[] = {
"Face Zoom OFF",
"Face Zoom ON",
};
-char *display_mode[] = {
+const char *display_mode[] = {
"Default",
"Primary Video ON and Secondary Video Full Screen",
"Primary Video OFF and Secondary Video Full Screen",
};
-char *output_mode[] = {
+const char *output_mode[] = {
"Letter Box mode",
"Original Size mode",
"Full Screen mode",
"ROI mode",
};
-char *rotate_mode[] = {
+const char *capture_sound[] = {
+ "Default",
+ "Extra 01",
+ "Extra 02",
+};
+
+const char *rotate_mode[] = {
"0",
"90",
"180",
"270",
};
-char* strobe_mode[] = {
+const char* strobe_mode[] = {
"Strobe OFF",
"Strobe ON",
"Strobe Auto",
"Strobe Permanent",
};
-char *detection_mode[2] = {
+const char *detection_mode[2] = {
"Face Detection OFF",
"Face Detection ON",
};
-char *wdr_mode[] = {
+const char *wdr_mode[] = {
"WDR OFF",
"WDR ON",
"WDR AUTO",
};
-char *hdr_mode[] = {
+const char *hdr_mode[] = {
"HDR OFF",
"HDR ON",
"HDR ON and Original",
};
-char *ahs_mode[] = {
+const char *ahs_mode[] = {
"Anti-handshake OFF",
"Anti-handshake ON",
"Anti-handshake AUTO",
"Anti-handshake MOVIE",
};
-char *vs_mode[] = {
+const char *vs_mode[] = {
"Video-stabilization OFF",
"Video-stabilization ON",
};
-char *visible_mode[] = {
+const char *visible_mode[] = {
"Display OFF",
- "Display ON",
+ "Display ON",
};
static gboolean msg_callback(int message, void *msg_param, void *user_param);
static gboolean init(int type);
static gboolean mode_change();
-int camcordertest_set_attr_int(char* attr_subcategory, int value);
+int camcordertest_set_attr_int(const char* attr_subcategory, int value);
static inline void flush_stdin()
cam_utils_convert_YUYV_to_UYVY(unsigned char* dst, unsigned char* src, gint length)
{
int i = 0;
-
+
//memset dst
memset(dst, 0x00, length);
memcpy(dst, src + 1, length-1);
static int camcordertest_audio_stream_cb(MMCamcorderAudioStreamDataType *stream, void *user_param)
{
audio_stream_cb_cnt++;
- printf("audio_stream cb is called (stream:%p, data:%p, format:%d, channel:%d, volume_dB:%f, length:%d, timestamp:%d)\n",
+ g_print("audio_stream cb is called (stream:%p, data:%p, format:%d, channel:%d, volume_dB:%f, length:%d, timestamp:%d)\n",
stream, stream->data, stream->format, stream->channel, stream->volume_dB, stream->length, stream->timestamp);
return TRUE;
{
video_stream_cb_cnt++;
- printf("VIDEO STREAM CALLBACK total length :%u, size %dx%d\n", stream->length_total, stream->width, stream->height);
+ g_print("VIDEO STREAM CALLBACK total length :%u, size %dx%d\n", stream->length_total, stream->width, stream->height);
return TRUE;
}
FILE *fp = NULL;
if (!path || !data || size <= 0) {
- printf("ERROR %p %p %d\n", path, data, size);
+ g_print("ERROR %p %p %d\n", path, data, size);
+ return;
+ }
+
+ fp = fopen(path, "w");
+ if (fp == NULL) {
+ g_print("open error! [%s], errno %d\n", path, errno);
+ return;
+ } else {
+ g_print("open success [%s]\n", path);
+ if (fwrite(data, size, 1, fp) != 1) {
+ g_print("write error! errno %d\n", errno);
+ } else {
+ g_print("write success [%s]\n", path);
+ }
+
+ fclose(fp);
+ fp = NULL;
+ }
+}
+
+static void _file_write2(const char *path, void *data, int size)
+{
+ FILE *fp = NULL;
+
+ if (!path || !data || size <= 0) {
+ g_print("ERROR %p %p %d\n", path, data, size);
return;
}
fp = fopen(path, "w");
if (fp == NULL) {
- printf("open error! [%s], errno %d\n", path, errno);
+ g_print("open error! [%s], errno %d\n", path, errno);
return;
} else {
- printf("open success [%s]\n", path);
+ g_print("open success [%s]\n", path);
if (fwrite(data, size, 1, fp) != 1) {
- printf("write error! errno %d\n", errno);
+ g_print("write error! errno %d\n", errno);
} else {
- printf("write success [%s]\n", path);
+ g_print("write success [%s]\n", path);
}
fclose(fp);
void *dst = NULL;
nret = _mmcamcorder_encode_jpeg(main->data, main->width, main->height, main->format,
- main->length, 90, &dst, &dst_size);
+ main->length, 90, &dst, &dst_size);
if (nret) {
_file_write(m_filename, dst, dst_size);
} else {
- printf("Failed to encode YUV(%d) -> JPEG. \n", main->format);
+ g_print("Failed to encode YUV(%d) -> JPEG. \n", main->format);
}
-
- free(dst);
- dst = NULL;
+ SAFE_FREE(dst);
} else if (!hcamcorder->isMultishot) {
- printf("MM_PIXEL_FORMAT_ENCODED main->data=%p main->length=%d, main->width=%d, main->heigtht=%d \n",
+ g_print("MM_PIXEL_FORMAT_ENCODED main->data=%p main->length=%d, main->width=%d, main->heigtht=%d \n",
main->data, main->length, main->width, main->height);
/* main image */
/* thumbnail */
if (thumb != NULL) {
- _file_write(IMAGE_CAPTURE_THUMBNAIL_PATH, thumb->data, thumb->length);
+ _file_write2(IMAGE_CAPTURE_THUMBNAIL_PATH, thumb->data, thumb->length);
}
/* screennail */
"captured-screennail", &scrnl, &scrnl_size,
NULL);
if (scrnl != NULL) {
- _file_write(IMAGE_CAPTURE_SCREENNAIL_PATH, scrnl->data, scrnl->length);
+ _file_write2(IMAGE_CAPTURE_SCREENNAIL_PATH, scrnl->data, scrnl->length);
} else {
- printf( "Screennail buffer is NULL.\n" );
+ g_print( "Screennail buffer is NULL.\n" );
}
/* EXIF data */
"captured-exif-raw-data", &exif_data, &exif_size,
NULL);
if (exif_data) {
- _file_write(IMAGE_CAPTURE_EXIF_PATH, exif_data, exif_size);
+ _file_write2(IMAGE_CAPTURE_EXIF_PATH, exif_data, exif_size);
}
}
g_timer_reset(timer);
err = mm_camcorder_capture_start(hcamcorder->camcorder);
- if (err < 0)
- {
-// if(hcamcorder->isMultishot == TRUE)
-// hcamcorder->isMultishot = FALSE;
+ if (err < 0) {
warn_msg_t("Multishot mm_camcorder_capture_start = %x", err);
- }
+ }
return FALSE;
}
-int camcordertest_set_attr_int(char * attr_subcategory, int value)
+int camcordertest_set_attr_int(const char * attr_subcategory, int value)
{
char * err_attr_name = NULL;
int err;
char * err_attr_name = NULL;
int err;
- if (hcamcorder)
- {
- if (hcamcorder->camcorder)
- {
+ if (hcamcorder) {
+ if (hcamcorder->camcorder) {
debug_msg_t("camcordertest_set_attr_xypair((%s, %s), (%d, %d))", pair.attr_subcat_x, pair.attr_subcat_y, pair.x, pair.y);
err = mm_camcorder_set_attributes(hcamcorder->camcorder, &err_attr_name,
pair.attr_subcat_x, pair.x,
pair.attr_subcat_y, pair.y,
NULL);
- if (err < 0)
- {
+ if (err < 0) {
err_msg_t("camcordertest_set_attr_xypair : Error(%s:%x)!!", err_attr_name, err);
- SAFE_FREE (err_attr_name);
+ SAFE_FREE(err_attr_name);
return FALSE;
}
//success
+ SAFE_FREE(err_attr_name);
return TRUE;
}
return FALSE;
}
-int camcordertest_get_attr_valid_intarray(char * attr_name, int ** array, int *count)
+int camcordertest_get_attr_valid_intarray(const char * attr_name, int ** array, int *count)
{
MMCamAttrsInfo info;
int err;
return FALSE;
}
-int camcordertest_get_attr_valid_intrange(char * attr_name, int *min, int *max)
+int camcordertest_get_attr_valid_intrange(const char * attr_name, int *min, int *max)
{
MMCamAttrsInfo info;
int err;
err = mm_camcorder_get_attribute_info(hcamcorder->camcorder, attr_name, &info);
if (err != MM_ERROR_NONE) {
- err_msg_t("camcordertest_get_attr_valid_intarray : Error(%x)!!", err);
+ err_msg_t("camcordertest_get_attr_valid_intrange : Error(%x)!!", err);
return FALSE;
} else {
if (info.type == MM_CAM_ATTRS_TYPE_INT) {
}
}
- err_msg_t("camcordertest_get_attr_valid_intarray : Type mismatched!!");
+ err_msg_t("camcordertest_get_attr_valid_intrange : Type mismatched!!");
return FALSE;
}
//success
}
- debug_msg_t("camcordertest_get_attr_valid_intarray(!hcamcorder->camcorde)");
+ debug_msg_t("camcordertest_get_attr_valid_intrange(!hcamcorder->camcorde)");
}
- debug_msg_t("camcordertest_get_attr_valid_intarray(!hcamcorder)");
+ debug_msg_t("camcordertest_get_attr_valid_intrange(!hcamcorder)");
return FALSE;
}
g_print("\t Video Capture > Setting\n");
g_print("\t=======================================\n");
g_print("\t >>>>>>>>>>>>>>>>>>>>>>>>>>>> [Camera] \n");
+ g_print("\t '0' Preview resolution \n");
g_print("\t '1' Capture resolution \n");
g_print("\t '2' Digital zoom level \n");
g_print("\t '3' Optical zoom level \n");
g_print("\t 'K' Video-stabilization \n");
g_print("\t 'u' Touch AF area \n");
g_print("\t 'm' Stream callback function \n");
+ g_print("\t 'M' Camcorder Motion Rate setting \n");
g_print("\t 'b' back\n");
g_print("\t=======================================\n");
break;
if(hcamcorder->isMultishot) {
int interval = 0;
flush_stdin();
- printf("\ninput interval(ms) \n");
+ g_print("\ninput interval(ms) \n");
err = scanf("%d", &interval);
if (err == EOF) {
- printf("\nscanf error : errno %d\n", errno);
+ g_print("\nscanf error : errno %d\n", errno);
interval = 300;
}
err = mm_camcorder_set_attributes(hcamcorder->camcorder, &err_attr_name,
NULL);
if (err != MM_ERROR_NONE) {
err_msg_t("Attribute setting fail : (%s:%x)", err_attr_name, err);
- SAFE_FREE (err_attr_name);
+ SAFE_FREE(err_attr_name);
}
} else {
err = mm_camcorder_set_attributes(hcamcorder->camcorder, &err_attr_name,
NULL);
if (err != MM_ERROR_NONE) {
err_msg_t("Attribute setting fail : (%s:%x)", err_attr_name, err);
- SAFE_FREE (err_attr_name);
+ SAFE_FREE(err_attr_name);
}
}
g_print("*Recording start!\n");
video_stream_cb_cnt = 0;
audio_stream_cb_cnt = 0;
+ hcamcorder->elapsed_time = 0;
g_timer_reset(timer);
err = mm_camcorder_record(hcamcorder->camcorder);
switch(buf) {
case '1' : // Start Recording
g_print("*Recording start!\n");
+ hcamcorder->elapsed_time = 0;
g_timer_reset(timer);
err = mm_camcorder_record(hcamcorder->camcorder);
static void setting_menu(gchar buf)
{
gboolean bret = FALSE;
- int index=0;
+ int idx = 0;
int min = 0;
int max = 0;
int width_count = 0;
if (hcamcorder->mode == MODE_VIDEO_CAPTURE) {
switch (buf) {
/* Camera setting */
+ case '0': // Setting > Preview Resolution setting
+ g_print("*Select the preview resolution!\n");
+ camcordertest_get_attr_valid_intarray(MMCAM_CAMERA_WIDTH, &width_array, &width_count);
+ camcordertest_get_attr_valid_intarray(MMCAM_CAMERA_HEIGHT, &height_array, &height_count);
+
+ if(width_count != height_count) {
+ err_msg_t("System has wrong information!!\n");
+ } else if (width_count == 0) {
+ g_print("Not supported!!\n");
+ } else {
+ flush_stdin();
+
+ for ( i = 0; i < width_count; i++) {
+ g_print("\t %d. %d*%d\n", i+1, width_array[i], height_array[i]);
+ }
+ err = scanf("%d",&idx);
+ if (err == EOF) {
+ g_print("\nscanf error : errno %d\n", errno);
+ } else {
+ if( idx > 0 && idx <= width_count ) {
+ //Set capture size first
+ input_pair.attr_subcat_x = MMCAM_CAMERA_WIDTH;
+ input_pair.attr_subcat_y = MMCAM_CAMERA_HEIGHT;
+ input_pair.x = width_array[idx-1];
+ input_pair.y = height_array[idx-1];
+ bret = camcordertest_set_attr_xypair(input_pair);
+ }
+ }
+ }
+ break;
case '1' : // Setting > Capture Resolution setting
/* check recommend preview resolution */
camcordertest_get_attr_valid_intarray(MMCAM_RECOMMEND_CAMERA_WIDTH, &width_array, &width_count);
g_print("MMCAM_RECOMMEND_CAMERA_WIDTH/HEIGHT Not supported!!\n");
} else {
g_print("\n - MMCAM_RECOMMEND_CAMERA_WIDTH and HEIGHT (count %d) -\n", width_count);
- g_print("\t NORMAL ratio : %dx%d\n",
- width_array[MM_CAMCORDER_PREVIEW_TYPE_NORMAL], height_array[MM_CAMCORDER_PREVIEW_TYPE_NORMAL]);
- if (width_count >= 2) {
- g_print("\t WIDE ratio : %dx%d\n\n",
- width_array[MM_CAMCORDER_PREVIEW_TYPE_WIDE], height_array[MM_CAMCORDER_PREVIEW_TYPE_WIDE]);
- } else {
- g_print("\t There is ONLY NORMAL resolution\n\n");
+ if (width_count > 0) {
+ g_print("\t NORMAL ratio : %dx%d\n", width_array[MM_CAMCORDER_PREVIEW_TYPE_NORMAL], height_array[MM_CAMCORDER_PREVIEW_TYPE_NORMAL]);
+ }
+ if (width_count > 1) {
+ g_print("\t WIDE ratio : %dx%d\n", width_array[MM_CAMCORDER_PREVIEW_TYPE_WIDE], height_array[MM_CAMCORDER_PREVIEW_TYPE_WIDE]);
+ }
+ if (width_count > 2) {
+ g_print("\t SQUARE ratio : %dx%d\n", width_array[MM_CAMCORDER_PREVIEW_TYPE_SQUARE], height_array[MM_CAMCORDER_PREVIEW_TYPE_SQUARE]);
}
}
for ( i = 0; i < width_count; i++) {
g_print("\t %d. %d*%d\n", i+1, width_array[i], height_array[i]);
}
- err = scanf("%d",&index);
+ err = scanf("%d",&idx);
if (err == EOF) {
- printf("\nscanf error : errno %d\n", errno);
+ g_print("\nscanf error : errno %d\n", errno);
} else {
- if( index > 0 && index <= width_count ) {
+ if( idx > 0 && idx <= width_count ) {
//Set capture size first
input_pair.attr_subcat_x = "capture-width";
input_pair.attr_subcat_y = "capture-height";
- input_pair.x = width_array[index-1];
- input_pair.y = height_array[index-1];
+ input_pair.x = width_array[idx-1];
+ input_pair.y = height_array[idx-1];
bret = camcordertest_set_attr_xypair(input_pair);
}
}
} else {
flush_stdin();
g_print("\n Select Digital zoom level (%d ~ %d)\n", min, max);
- err = scanf("%d",&index);
- bret = camcordertest_set_attr_int("camera-digital-zoom", index);
+ err = scanf("%d",&idx);
+ bret = camcordertest_set_attr_int("camera-digital-zoom", idx);
}
break;
} else {
flush_stdin();
g_print("\n Select Optical zoom level (%d ~ %d)\n", min, max);
- err = scanf("%d",&index);
- bret = camcordertest_set_attr_int("camera-optical-zoom", index);
+ err = scanf("%d",&idx);
+ bret = camcordertest_set_attr_int("camera-optical-zoom", idx);
}
break;
g_print("\t2. AF Stop !\n\n");
flush_stdin();
- err = scanf("%d", &index);
+ err = scanf("%d", &idx);
- switch (index) {
+ switch (idx) {
case 0:
{
g_print("*Focus mode !\n");
for (i = 0 ; i < count ; i++) {
g_print("\t %d. %s\n", array[i], focus_mode[array[i]]);
}
- err = scanf("%d",&index);
- bret = camcordertest_set_attr_int("camera-focus-mode", index);
+ err = scanf("%d",&idx);
+ bret = camcordertest_set_attr_int("camera-focus-mode", idx);
}
}
break;
mm_camcorder_stop_focusing(hcamcorder->camcorder);
break;
default:
- g_print("Wrong Input[%d] !! \n", index);
+ g_print("Wrong Input[%d] !! \n", idx);
break;
}
break;
for ( i = 0; i < count; i++) {
g_print("\t %d. %s\n", array[i], af_scan[array[i]]);
}
- err = scanf("%d",&index);
- camcordertest_set_attr_int("camera-af-scan-range", index);
+ err = scanf("%d",&idx);
+ camcordertest_set_attr_int("camera-af-scan-range", idx);
}
break;
for ( i = 0; i < count; i++) {
g_print("\t %d. %s\n", array[i], exposure_mode[array[i]]);
}
- err = scanf("%d",&index);
- bret = camcordertest_set_attr_int("camera-exposure-mode", index);
+ err = scanf("%d",&idx);
+ bret = camcordertest_set_attr_int("camera-exposure-mode", idx);
}
break;
} else {
flush_stdin();
g_print("\n Select Exposure value(%d ~ %d)\n", min, max);
- err = scanf("%d",&index);
- bret = camcordertest_set_attr_int("camera-exposure-value", index);
+ err = scanf("%d",&idx);
+ bret = camcordertest_set_attr_int("camera-exposure-value", idx);
}
break;
for ( i = 0; i < count; i++) {
g_print("\t %d. %d \n", i+1, array[i]);
}
- err = scanf("%d",&index);
+ err = scanf("%d",&idx);
- if( index > 0 && index <= count ) {
- bret = camcordertest_set_attr_int("camera-shutter-speed", array[index-1]);
+ if( idx > 0 && idx <= count && count <= 30) {
+ bret = camcordertest_set_attr_int("camera-shutter-speed", array[idx-1]);
}
}
break;
for ( i = 0; i < count; i++) {
g_print("\t %d. %s\n", array[i], iso_name[array[i]]);
}
- err = scanf("%d",&index);
- bret = camcordertest_set_attr_int("camera-iso", index);
+ err = scanf("%d",&idx);
+ bret = camcordertest_set_attr_int("camera-iso", idx);
}
break;
case 'r' : // Setting > Rotate camera input when recording
g_print("*Rotate camera input\n");
- camcordertest_get_attr_valid_intrange(MMCAM_CAMERA_ROTATION, &min, &max);
+ camcordertest_get_attr_valid_intarray(MMCAM_CAMERA_ROTATION, &array, &count);
- if(min >= max) {
+ if(count <= 0) {
g_print("Not supported !! \n");
} else {
flush_stdin();
- for (i = min ; i <= max ; i++) {
- g_print("\t %d. %s\n", i, camera_rotation[i]);
+ for ( i = 0; i < count; i++) {
+ g_print("\t %d. %s\n", array[i], camera_rotation[array[i]]);
}
- err = scanf("%d",&index);
+ err = scanf("%d",&idx);
CHECK_MM_ERROR(mm_camcorder_stop(hcamcorder->camcorder));
- bret = camcordertest_set_attr_int(MMCAM_CAMERA_ROTATION, index);
+ bret = camcordertest_set_attr_int(MMCAM_CAMERA_ROTATION, idx);
CHECK_MM_ERROR(mm_camcorder_start(hcamcorder->camcorder));
}
break;
g_print(" 2. Flip VERTICAL\n");
g_print(" 3. Flip BOTH\n");
- err = scanf("%d", &index);
+ err = scanf("%d", &idx);
CHECK_MM_ERROR(mm_camcorder_stop(hcamcorder->camcorder));
CHECK_MM_ERROR(mm_camcorder_unrealize(hcamcorder->camcorder));
- camcordertest_set_attr_int(MMCAM_CAMERA_FLIP, index);
+ camcordertest_set_attr_int(MMCAM_CAMERA_FLIP, idx);
CHECK_MM_ERROR(mm_camcorder_realize(hcamcorder->camcorder));
CHECK_MM_ERROR(mm_camcorder_start(hcamcorder->camcorder));
} else {
flush_stdin();
g_print("\n Select Jpeg quality (%d ~ %d)\n", min, max);
- err = scanf("%d",&index);
- bret = camcordertest_set_attr_int("image-encoder-quality", index);
+ err = scanf("%d",&idx);
+ bret = camcordertest_set_attr_int("image-encoder-quality", idx);
}
break;
for ( i = 0; i < count; i++) {
g_print("\t %d. %s\n", array[i], image_fmt[array[i]]);
}
- err = scanf("%d",&index);
- bret = camcordertest_set_attr_int("camera-format", index);
+ err = scanf("%d",&idx);
+ bret = camcordertest_set_attr_int("camera-format", idx);
CHECK_MM_ERROR(mm_camcorder_stop(hcamcorder->camcorder));
CHECK_MM_ERROR(mm_camcorder_unrealize(hcamcorder->camcorder));
CHECK_MM_ERROR(mm_camcorder_realize(hcamcorder->camcorder));
g_print("\t 8. LEFT_BOTTOM\n");
flush_stdin();
- err = scanf("%d", &index);
+ err = scanf("%d", &idx);
- if (index < 1 || index > 8) {
- g_print("Wrong INPUT[%d]!! \n", index);
+ if (idx < 1 || idx > 8) {
+ g_print("Wrong INPUT[%d]!! \n", idx);
} else {
- camcordertest_set_attr_int(MMCAM_TAG_ORIENTATION, index);
+ camcordertest_set_attr_int(MMCAM_TAG_ORIENTATION, idx);
}
break;
for (i = 0 ; i < count ; i++) {
g_print("\t %d. %s\n", array[i], display_mode[array[i]]);
}
- err = scanf("%d",&index);
- bret = camcordertest_set_attr_int(MMCAM_DISPLAY_MODE, index);
+ err = scanf("%d",&idx);
+ bret = camcordertest_set_attr_int(MMCAM_DISPLAY_MODE, idx);
}
break;
for( i = min ; i <= max ; i++ ) {
g_print( "%d. %s\n", i, output_mode[i] );
}
- err = scanf("%d",&index);
- bret = camcordertest_set_attr_int("display-geometry-method", index);
+ err = scanf("%d",&idx);
+ bret = camcordertest_set_attr_int("display-geometry-method", idx);
}
break;
flush_stdin();
g_print("\n Select Rotate mode(%d ~ %d)\n", min, max);
g_print("\t0. 0\n\t1. 90\n\t2. 180\n\t3. 270\n\n");
- err = scanf("%d",&index);
- bret = camcordertest_set_attr_int(MMCAM_DISPLAY_ROTATION, index);
+ err = scanf("%d",&idx);
+ bret = camcordertest_set_attr_int(MMCAM_DISPLAY_ROTATION, idx);
}
break;
flush_stdin();
g_print("\n Select Rotate mode(%d ~ %d)\n", min, max);
g_print("\t0. NONE\n\t1. HORIZONTAL\n\t2. VERTICAL\n\t3. BOTH\n\n");
- err = scanf("%d",&index);
- camcordertest_set_attr_int(MMCAM_DISPLAY_FLIP, index);
+ err = scanf("%d",&idx);
+ camcordertest_set_attr_int(MMCAM_DISPLAY_FLIP, idx);
break;
case 'g' : // Setting > Brightness
} else {
flush_stdin();
g_print("\n Select brightness (%d ~ %d)\n", min, max);
- err = scanf("%d",&index);
- bret = camcordertest_set_attr_int("filter-brightness", index);
+ err = scanf("%d",&idx);
+ bret = camcordertest_set_attr_int("filter-brightness", idx);
}
break;
} else {
flush_stdin();
g_print("\n Select Contrast (%d ~ %d)\n", min, max);
- err = scanf("%d",&index);
- bret = camcordertest_set_attr_int("filter-contrast", index);
+ err = scanf("%d",&idx);
+ bret = camcordertest_set_attr_int("filter-contrast", idx);
}
break;
} else {
flush_stdin();
g_print("\n Select Saturation (%d ~ %d)\n", min, max);
- err = scanf("%d",&index);
- bret = camcordertest_set_attr_int("filter-saturation", index);
+ err = scanf("%d",&idx);
+ bret = camcordertest_set_attr_int("filter-saturation", idx);
}
break;
} else {
flush_stdin();
g_print("\n Select Hue (%d ~ %d)\n", min, max);
- err = scanf("%d",&index);
- bret = camcordertest_set_attr_int("filter-hue", index);
+ err = scanf("%d",&idx);
+ bret = camcordertest_set_attr_int("filter-hue", idx);
}
break;
} else {
flush_stdin();
g_print("\n Select Sharpness (%d ~ %d)\n", min, max);
- err = scanf("%d",&index);
- bret = camcordertest_set_attr_int("filter-sharpness", index);
+ err = scanf("%d",&idx);
+ bret = camcordertest_set_attr_int("filter-sharpness", idx);
}
break;
for ( i = 0; i < count; i++) {
g_print("\t %d. %s\n", array[i], wb[array[i]]);
}
- err = scanf("%d",&index);
- bret = camcordertest_set_attr_int("filter-wb", index);
+ err = scanf("%d",&idx);
+ bret = camcordertest_set_attr_int("filter-wb", idx);
}
break;
for ( i = 0; i < count; i++) {
g_print("\t %d. %s\n", array[i], ct[array[i]]);
}
- err = scanf("%d",&index);
- bret = camcordertest_set_attr_int("filter-color-tone", index);
+ err = scanf("%d",&idx);
+ bret = camcordertest_set_attr_int("filter-color-tone", idx);
}
break;
for ( i = 0; i < count; i++) {
g_print("\t %d. %s\n", array[i], wdr_mode[array[i]]);
}
- err = scanf("%d",&index);
- bret = camcordertest_set_attr_int("camera-wdr", index);
+ err = scanf("%d",&idx);
+ bret = camcordertest_set_attr_int("camera-wdr", idx);
}
break;
for ( i = 0; i < count; i++) {
g_print("\t %d. %s\n", array[i], program_mode[array[i]]);
}
- err = scanf("%d",&index);
- bret = camcordertest_set_attr_int("filter-scene-mode", index);
+ err = scanf("%d",&idx);
+ bret = camcordertest_set_attr_int("filter-scene-mode", idx);
}
break;
for ( i = 0; i < count; i++) {
g_print("\t %d. %s\n", array[i], strobe_mode[array[i]]);
}
- err = scanf("%d",&index);
- bret = camcordertest_set_attr_int("strobe-mode", index);
+ err = scanf("%d",&idx);
+ bret = camcordertest_set_attr_int("strobe-mode", idx);
}
break;
g_print("*Select Capture mode!\n");
flush_stdin();
g_print(" \n\t1. Stillshot mode\n\t2. Multishot mode\n\t3. HDR capture\n");
- err = scanf("%d",&index);
+ err = scanf("%d",&idx);
- switch (index) {
+ switch (idx) {
case 1:
g_print("stillshot mode selected and capture callback is set!!!!\n");
hcamcorder->isMultishot = FALSE;
camcordertest_set_attr_int(MMCAM_CAMERA_HDR_CAPTURE, 0);
- index = 0;
+ idx = 0;
min = 0;
max = 0;
flush_stdin();
//g_print("\n Check Point!!! [Change resolution to 800x480]\n");
g_print("Select mulitshot number (%d ~ %d)\n", min, max);
- err = scanf("%d",&index);
- if( index >= min && index <= max ) {
- multishot_num = index;
+ err = scanf("%d",&idx);
+ if( idx >= min && idx <= max ) {
+ multishot_num = idx;
mm_camcorder_set_attributes(hcamcorder->camcorder, &err_attr_name,
MMCAM_CAPTURE_COUNT, multishot_num,
NULL);
for ( i = 0; i < count; i++) {
g_print("\t %d. %s\n", array[i], hdr_mode[array[i]]);
}
- err = scanf("%d",&index);
- bret = camcordertest_set_attr_int(MMCAM_CAMERA_HDR_CAPTURE, index);
+ err = scanf("%d",&idx);
+ bret = camcordertest_set_attr_int(MMCAM_CAMERA_HDR_CAPTURE, idx);
}
break;
default:
for ( i = 0; i < count; i++) {
g_print("\t %d. %s \n", array[i], detection_mode[array[i]]);
}
- err = scanf("%d",&index);
+ err = scanf("%d",&idx);
- if( index >= 0 && index < count ) {
- bret = camcordertest_set_attr_int("detect-mode", array[index]);
+ if( idx >= 0 && idx < count ) {
+ bret = camcordertest_set_attr_int("detect-mode", array[idx]);
} else {
g_print("Wrong input value. Try again!!\n");
bret = FALSE;
for ( i = 0; i < count; i++) {
g_print("\t %d. %s\n", array[i], ahs_mode[array[i]]);
}
- err = scanf("%d",&index);
- bret = camcordertest_set_attr_int(MMCAM_CAMERA_ANTI_HANDSHAKE, index);
+ err = scanf("%d",&idx);
+ bret = camcordertest_set_attr_int(MMCAM_CAMERA_ANTI_HANDSHAKE, idx);
}
break;
for ( i = 0; i < count; i++) {
g_print("\t %d. %s\n", array[i], vs_mode[array[i]]);
}
- err = scanf("%d",&index);
+ err = scanf("%d",&idx);
- if (index == MM_CAMCORDER_VIDEO_STABILIZATION_ON) {
+ if (idx == MM_CAMCORDER_VIDEO_STABILIZATION_ON) {
g_print("\n Restart preview with NV12 and 720p resolution\n");
err = mm_camcorder_stop(hcamcorder->camcorder);
input_pair.y = 720;
camcordertest_set_attr_xypair(input_pair);
camcordertest_set_attr_int(MMCAM_CAMERA_FORMAT, MM_PIXEL_FORMAT_NV12);
- camcordertest_set_attr_int(MMCAM_CAMERA_VIDEO_STABILIZATION, index);
+ camcordertest_set_attr_int(MMCAM_CAMERA_VIDEO_STABILIZATION, idx);
if (err == MM_ERROR_NONE) {
err = mm_camcorder_realize(hcamcorder->camcorder);
g_print("\n Restart FAILED! %x\n", err);
}
} else {
- camcordertest_set_attr_int(MMCAM_CAMERA_VIDEO_STABILIZATION, index);
+ camcordertest_set_attr_int(MMCAM_CAMERA_VIDEO_STABILIZATION, idx);
}
}
break;
if( err != MM_ERROR_NONE ) {
g_print( "Failed to set touch AF area.(%x)(%s)\n", err, err_attr_name );
- free( err_attr_name );
- err_attr_name = NULL;
+ SAFE_FREE(err_attr_name);
} else {
g_print( "Succeed to set touch AF area.\n" );
}
g_print("\t 1. Set Video Stream Callback \n");
g_print("\t 2. Unset Video Stream Callback \n");
flush_stdin();
- err = scanf("%d", &index);
- if(index == 1) {
+ err = scanf("%d", &idx);
+ if(idx == 1) {
video_stream_cb_cnt = 0;
error_num = mm_camcorder_set_video_stream_callback(hcamcorder->camcorder, (mm_camcorder_video_stream_callback)camcordertest_video_stream_cb, (void*)hcamcorder->camcorder);
if( error_num == MM_ERROR_NONE ) {
} else {
g_print("\n Setting Failure\n");
}
- } else if(index == 2) {
+ } else if(idx == 2) {
mm_camcorder_set_video_stream_callback(hcamcorder->camcorder, NULL, (void*)hcamcorder->camcorder);
video_stream_cb_cnt = 0;
audio_stream_cb_cnt = 0;
}
break;
+ case 'M':
+ {
+ float motion_rate = 0.0;
+
+ flush_stdin();
+
+ g_print("*Camcorder Motion Rate setting! (should be bigger than zero)\n");
+
+ err = scanf("%f", &motion_rate);
+ err = mm_camcorder_set_attributes(hcamcorder->camcorder, &err_attr_name,
+ MMCAM_CAMERA_RECORDING_MOTION_RATE, motion_rate,
+ NULL);
+ if (err != MM_ERROR_NONE) {
+ g_print("Failed to set Camcorder Motion Rate %f [err:0x%x]\n", motion_rate, err);
+ SAFE_FREE(err_attr_name);
+ } else {
+ g_print("Succeed to set Motion Rate %f\n", motion_rate);
+ }
+ }
+ break;
+
case 'b' : // back
hcamcorder->menu_state = MENU_STATE_MAIN;
break;
g_print("\t Invalid mode, back to upper menu \n");
hcamcorder->menu_state = MENU_STATE_MAIN;
}
+
+ g_print("\t bret : 0x%x \n", bret);
+
+ SAFE_FREE(err_attr_name);
+
+ return;
}
*/
static gboolean cmd_input(GIOChannel *channel)
{
- gchar buf[256];
- gsize read;
+ gchar *buf = NULL;
+ gsize read_size;
+ GError *g_error = NULL;
debug_msg_t("ENTER");
- g_io_channel_read(channel, buf, CAPTURE_FILENAME_LEN, &read);
- buf[read] = '\0';
- g_strstrip(buf);
+ g_io_channel_read_line(channel, &buf, &read_size, NULL, &g_error);
+ if (g_error) {
+ debug_msg_t("g_io_channel_read_chars error");
+ g_error_free(g_error);
+ g_error = NULL;
+ }
- debug_msg_t("Menu Status : %d", hcamcorder->menu_state);
- switch(hcamcorder->menu_state)
- {
- case MENU_STATE_MAIN:
- main_menu(buf[0]);
- break;
- case MENU_STATE_SETTING:
- setting_menu(buf[0]);
- break;
- default:
- break;
+ if (buf) {
+ g_strstrip(buf);
+
+ debug_msg_t("Menu Status : %d", hcamcorder->menu_state);
+ switch(hcamcorder->menu_state)
+ {
+ case MENU_STATE_MAIN:
+ main_menu(buf[0]);
+ break;
+ case MENU_STATE_SETTING:
+ setting_menu(buf[0]);
+ break;
+ default:
+ break;
+ }
+
+ SAFE_G_FREE(buf);
+ print_menu();
+ } else {
+ debug_msg_t("No read input");
}
- print_menu();
+
return TRUE;
}
void validity_print(MMCamAttrsInfo *info)
{
- printf("info(%d,%d, %d))\n", info->type, info->flag, info->validity_type);
- if (info->validity_type == MM_CAM_ATTRS_VALID_TYPE_INT_ARRAY)
- {
- printf("int array(%p, %d)\n", info->int_array.array, info->int_array.count);
- }
- else if (info->validity_type == MM_CAM_ATTRS_VALID_TYPE_INT_RANGE)
- {
- printf("int range(%d, %d)\n", info->int_range.min, info->int_range.max);
- }
- else if (info->validity_type == MM_CAM_ATTRS_VALID_TYPE_DOUBLE_ARRAY)
- {
- printf("double array(%p, %d)\n", info->double_array.array, info->double_array.count);
- }
- else if(info->validity_type == MM_CAM_ATTRS_VALID_TYPE_DOUBLE_RANGE)
- {
- printf("double range(%f, %f)\n", info->double_range.min, info->double_range.max);
- }
- else
- {
- printf("validity none\n");
- }
- return;
+ g_print("info(%d,%d, %d))\n", info->type, info->flag, info->validity_type);
+ if (info->validity_type == MM_CAM_ATTRS_VALID_TYPE_INT_ARRAY)
+ {
+ g_print("int array(%p, %d)\n", info->int_array.array, info->int_array.count);
+ }
+ else if (info->validity_type == MM_CAM_ATTRS_VALID_TYPE_INT_RANGE)
+ {
+ g_print("int range(%d, %d)\n", info->int_range.min, info->int_range.max);
+ }
+ else if (info->validity_type == MM_CAM_ATTRS_VALID_TYPE_DOUBLE_ARRAY)
+ {
+ g_print("double array(%p, %d)\n", info->double_array.array, info->double_array.count);
+ }
+ else if(info->validity_type == MM_CAM_ATTRS_VALID_TYPE_DOUBLE_RANGE)
+ {
+ g_print("double range(%f, %f)\n", info->double_range.min, info->double_range.max);
+ }
+ else
+ {
+ g_print("validity none\n");
+ }
+ return;
}
int err;
int size;
int preview_format = MM_PIXEL_FORMAT_NV12;
+ int support_zero_copy_format = 0;
+ int support_media_packet_preview_cb = 0;
+ int recommend_display_rotation = 0;
MMHandleType cam_handle = 0;
char *err_attr_name = NULL;
if (type == MODE_VIDEO_CAPTURE) {
mm_camcorder_get_attributes((MMHandleType)cam_handle, NULL,
MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_CAPTURE, &preview_format,
+ MMCAM_SUPPORT_ZERO_COPY_FORMAT, &support_zero_copy_format,
+ MMCAM_SUPPORT_MEDIA_PACKET_PREVIEW_CB, &support_media_packet_preview_cb,
+ MMCAM_RECOMMEND_DISPLAY_ROTATION, &recommend_display_rotation,
NULL);
+ warn_msg_t("MMCAM_SUPPORT_ZERO_COPY_FORMAT %d", support_zero_copy_format);
+ warn_msg_t("MMCAM_SUPPORT_MEDIA_PACKET_PREVIEW_CB %d", support_media_packet_preview_cb);
+ warn_msg_t("MMCAM_RECOMMEND_DISPLAY_ROTATION %d", recommend_display_rotation);
+
/* camcorder attribute setting */
err = mm_camcorder_set_attributes( (MMHandleType)cam_handle, &err_attr_name,
MMCAM_MODE, MM_CAMCORDER_MODE_VIDEO_CAPTURE,
MMCAM_TAG_LATITUDE, 35.3036944,
MMCAM_TAG_LONGITUDE, 176.67837,
MMCAM_TAG_ALTITUDE, 190.3455,
- MMCAM_DISPLAY_DEVICE, MM_DISPLAY_DEVICE_MAINLCD,
- MMCAM_DISPLAY_SURFACE, MM_DISPLAY_SURFACE_X,
- MMCAM_DISPLAY_RECT_X, DISPLAY_X_0,
- MMCAM_DISPLAY_RECT_Y, DISPLAY_Y_0,
- MMCAM_DISPLAY_RECT_WIDTH, 480,
- MMCAM_DISPLAY_RECT_HEIGHT, 640,
- MMCAM_DISPLAY_ROTATION, MM_DISPLAY_ROTATION_270,
- //MMCAM_DISPLAY_FLIP, MM_FLIP_HORIZONTAL,
+ MMCAM_DISPLAY_SURFACE, MM_DISPLAY_SURFACE_OVERLAY,
MMCAM_DISPLAY_GEOMETRY_METHOD, MM_DISPLAY_METHOD_LETTER_BOX,
MMCAM_CAPTURE_COUNT, IMAGE_CAPTURE_COUNT_STILL,
- "capture-thumbnail", TRUE,
+ MMCAM_TAG_GPS_ENABLE, TRUE,
"tag-gps-time-stamp", 72815.5436243543,
"tag-gps-date-stamp", "2010:09:20", 10,
"tag-gps-processing-method", "GPS NETWORK HYBRID ARE ALL FINE.", 32,
MMCAM_AUDIO_ENCODER, MM_AUDIO_CODEC_AAC,
MMCAM_VIDEO_ENCODER, MM_VIDEO_CODEC_MPEG4,
MMCAM_VIDEO_ENCODER_BITRATE, VIDEO_ENCODE_BITRATE,
- MMCAM_FILE_FORMAT, MM_FILE_FORMAT_3GP,
+ MMCAM_FILE_FORMAT, MM_FILE_FORMAT_MP4,
MMCAM_CAMERA_FPS, SRC_VIDEO_FRAME_RATE_30,
MMCAM_CAMERA_FPS_AUTO, 0,
MMCAM_CAMERA_ROTATION, MM_VIDEO_INPUT_ROTATION_NONE,
//MMCAM_AUDIO_DISABLE, TRUE,
MMCAM_TARGET_FILENAME, TARGET_FILENAME_VIDEO, strlen(TARGET_FILENAME_VIDEO),
//MMCAM_TARGET_TIME_LIMIT, 360000,
-#ifndef _TIZEN_PUBLIC_
//MMCAM_TARGET_MAX_SIZE, 102400,
-#endif /* _TIZEN_PUBLIC_ */
+ MMCAM_RECORDER_TAG_ENABLE, 1,
+ MMCAM_TAG_VIDEO_ORIENTATION, 1,
+ MMCAM_DISPLAY_ROTATION, recommend_display_rotation,
NULL );
if (err != MM_ERROR_NONE) {
warn_msg_t("Init fail. (%s:%x)", err_attr_name, err);
- SAFE_FREE (err_attr_name);
+ SAFE_FREE(err_attr_name);
goto ERROR;
}
err = mm_camcorder_set_attributes( hcamcorder->camcorder, &err_attr_name,
MMCAM_MODE, MM_CAMCORDER_MODE_AUDIO,
MMCAM_AUDIO_DEVICE, MM_AUDIO_DEVICE_MIC,
- MMCAM_AUDIO_ENCODER, MM_AUDIO_CODEC_AMR,
- MMCAM_FILE_FORMAT, MM_FILE_FORMAT_AMR,
- MMCAM_AUDIO_SAMPLERATE, AUDIO_SOURCE_SAMPLERATE_AMR,
+ MMCAM_AUDIO_ENCODER, MM_AUDIO_CODEC_AAC,
+ MMCAM_FILE_FORMAT, MM_FILE_FORMAT_MP4,
+ MMCAM_AUDIO_SAMPLERATE, AUDIO_SOURCE_SAMPLERATE_AAC,
MMCAM_AUDIO_FORMAT, AUDIO_SOURCE_FORMAT,
MMCAM_AUDIO_CHANNEL, AUDIO_SOURCE_CHANNEL_AAC,
MMCAM_TARGET_FILENAME, TARGET_FILENAME_AUDIO, size,
MMCAM_TARGET_TIME_LIMIT, 360000,
- MMCAM_AUDIO_ENCODER_BITRATE, 12200,
-#ifndef _TIZEN_PUBLIC_
+ MMCAM_AUDIO_ENCODER_BITRATE, 128000,
MMCAM_TARGET_MAX_SIZE, 300,
-#endif /* _TIZEN_PUBLIC_ */
NULL);
-
+
if (err < 0) {
warn_msg_t("Init fail. (%s:%x)", err_attr_name, err);
- SAFE_FREE (err_attr_name);
+ SAFE_FREE(err_attr_name);
goto ERROR;
}
mm_camcorder_set_audio_stream_callback(hcamcorder->camcorder, (mm_camcorder_audio_stream_callback)camcordertest_audio_stream_cb, (void*)hcamcorder->camcorder);
#endif /* USE_AUDIO_STREAM_CB */
}
-
+ SAFE_FREE (err_attr_name);
debug_msg_t("Init DONE.");
return TRUE;
-
+
ERROR:
err_msg_t("init failed.");
return FALSE;
/**
* This function is to represent messagecallback
*
- * @param message [in] Specifies the message
+ * @param message [in] Specifies the message
* @param param [in] Specifies the message type
* @param user_param [in] Specifies the user poiner for passing to callback function
* @return This function returns TRUE/FALSE
{
MMMessageParamType *param = (MMMessageParamType *) msg_param;
-
+
switch (message) {
case MM_MESSAGE_CAMCORDER_ERROR:
g_print("MM_MESSAGE_ERROR : code = %x", param->code);
debug_msg_t("Camcorder State is [NULL]");
break;
case MM_CAMCORDER_STATE_READY :
- mmcamcorder_state = MM_CAMCORDER_STATE_READY;
+ mmcamcorder_state = MM_CAMCORDER_STATE_READY;
debug_msg_t("Camcorder State is [READY]");
break;
case MM_CAMCORDER_STATE_PREPARE :
mmcamcorder_state = MM_CAMCORDER_STATE_PAUSED;
debug_msg_t("Camcorder State is [PAUSED]");
break;
+ default:
+ debug_msg_t("Unknown State [%d]", g_current_state);
+ break;
}
break;
g_print("*******************************************************\n");
g_print("[Camcorder Testsuite] Camcorder Captured(filename=%s)\n", report->recording_filename);
g_print("*******************************************************\n");
-
- SAFE_FREE (report->recording_filename);
- SAFE_FREE (report);
} else {
g_print( "[Camcorder Testsuite] report is NULL.\n" );
}
hour, minute, second, param->recording_status.remained_time, param->recording_status.filesize);
}
}
- break;
- case MM_MESSAGE_CAMCORDER_MAX_SIZE:
- {
+ break;
+ case MM_MESSAGE_CAMCORDER_MAX_SIZE:
+ {
int err;
g_print("*Save Recording because receives message : MM_MESSAGE_CAMCORDER_MAX_SIZE\n");
g_timer_reset(timer);
err = mm_camcorder_commit(hcamcorder->camcorder);
- if (err < 0)
+ if (err < 0)
{
warn_msg_t("Save recording mm_camcorder_commit = %x", err);
// goto ERROR;
case MM_MESSAGE_CAMCORDER_CURRENT_VOLUME:
break;
case MM_MESSAGE_CAMCORDER_NO_FREE_SPACE:
- {
+ {
int err;
g_print("*Save Recording because receives message : MM_MESSAGE_CAMCORDER_NO_FREE_SPACE\n");
g_timer_reset(timer);
err = mm_camcorder_commit(hcamcorder->camcorder);
- if (err < 0)
+ if (err < 0)
{
warn_msg_t("Save recording mm_camcorder_commit = %x", err);
// goto ERROR;
break;
case MM_MESSAGE_CAMCORDER_FACE_DETECT_INFO:
{
- static int info_count = 0;
MMCamFaceDetectInfo *cam_fd_info = NULL;
cam_fd_info = (MMCamFaceDetectInfo *)(param->data);
cam_fd_info->face_info[i].rect.width,
cam_fd_info->face_info[i].rect.height);
}
-
- if (info_count == 0) {
- mm_camcorder_set_attributes(hcamcorder->camcorder, NULL,
- MMCAM_CAMERA_FACE_ZOOM_MODE, MM_CAMCORDER_FACE_ZOOM_MODE_ON,
- MMCAM_CAMERA_FACE_ZOOM_X, cam_fd_info->face_info[0].rect.x + (cam_fd_info->face_info[0].rect.width>>1),
- MMCAM_CAMERA_FACE_ZOOM_Y, cam_fd_info->face_info[0].rect.y + (cam_fd_info->face_info[0].rect.height>>1),
- MMCAM_CAMERA_FACE_ZOOM_LEVEL, 0,
- NULL);
- info_count = 1;
- g_print("\n\t##### START FACE ZOOM [%d,%d] #####\n", cam_fd_info->face_info[0].rect.x, cam_fd_info->face_info[0].rect.y);
- } else if (info_count++ == 90) {
- mm_camcorder_set_attributes(hcamcorder->camcorder, NULL,
- MMCAM_CAMERA_FACE_ZOOM_MODE, MM_CAMCORDER_FACE_ZOOM_MODE_OFF,
- NULL);
- g_print("\n\t##### STOP FACE ZOOM #####\n");
- info_count = -60;
- }
}
}
break;
hcamcorder->isMultishot = FALSE;
hcamcorder->stillshot_count = 0; /* total stillshot count */
hcamcorder->multishot_count = 0; /* total multishot count */
- hcamcorder->stillshot_filename = STILL_CAPTURE_FILE_PATH_NAME; /* stored filename of stillshot */
- hcamcorder->multishot_filename = MULTI_CAPTURE_FILE_PATH_NAME; /* stored filename of multishot */
+ hcamcorder->stillshot_filename = STILL_CAPTURE_FILE_PATH_NAME; /* stored filename of stillshot */
+ hcamcorder->multishot_filename = MULTI_CAPTURE_FILE_PATH_NAME; /* stored filename of multishot */
hcamcorder->menu_state = MENU_STATE_MAIN;
hcamcorder->isMute = FALSE;
hcamcorder->elapsed_time = 0;
debug_msg_t("mm_camcorder_cancel");
err = mm_camcorder_cancel(hcamcorder->camcorder);
- if (err < 0)
+ if (err < 0)
{
warn_msg_t("exit mm_camcorder_cancel = %x", err);
return FALSE;
debug_msg_t("mm_camcorder_capture_stop");
err = mm_camcorder_capture_stop(hcamcorder->camcorder);
- if (err < 0)
+ if (err < 0)
{
warn_msg_t("exit mmcamcorder_capture_stop = %x", err);
return FALSE;
debug_msg_t("mm_camcorder_stop");
mm_camcorder_stop(hcamcorder->camcorder);
}
-
+
err = mm_camcorder_get_state(hcamcorder->camcorder, (MMCamcorderStateType *)&state);
if(state == MM_CAMCORDER_STATE_READY)
{
debug_msg_t("mm_camcorder_unrealize");
mm_camcorder_unrealize(hcamcorder->camcorder);
}
-
+
err = mm_camcorder_get_state(hcamcorder->camcorder, (MMCamcorderStateType *)&state);
if(state == MM_CAMCORDER_STATE_NULL)
- {
+ {
debug_msg_t("mm_camcorder_destroy");
mm_camcorder_destroy(hcamcorder->camcorder);
mmcamcorder_state = MM_CAMCORDER_STATE_NONE;
}
}
-
+
init_handle();
mmcamcorder_print_state = MM_CAMCORDER_STATE_PREPARE;
while(!check) {
g_print("\t 'q' Exit\n");
g_print("\t=======================================\n");
- g_print("\t Enter the media type:\n\t");
+ g_print("\t Enter the media type:\n\t");
err = scanf("%c", &media_type);
-
+ if (err == EOF) {
+ g_print("\t!!!read input error!!!\n");
+ continue;
+ }
+
switch (media_type) {
case '1':
hcamcorder->mode= MODE_VIDEO_CAPTURE;
return -1;
}
- g_get_current_time(¤t);
+ g_get_current_time(¤t);
timersub(¤t, &previous, &result);
time_msg_t("Camera Starting Time : %ld.%lds", result.tv_sec, result.tv_usec);
/**
* This function is the example main function for mmcamcorder API.
*
- * @param
+ * @param
*
* @return This function returns 0.
* @remark
{
int bret;
- if (!g_thread_supported())
- g_thread_init (NULL);
-
timer = g_timer_new();
gst_init(&argc, &argv);
projects / platform / core / multimedia / libmm-camcorder.git / blobdiff