summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorKolja Dummann <k.dummann@gmail.com>2011-03-05 01:07:58 +0100
committerKolja Dummann <k.dummann@gmail.com>2011-03-05 01:07:58 +0100
commite8f88a17d64a94980422c8e19fc9d190a2a92c70 (patch)
tree80d6d948140c19d890e9e93476ffae92fcc13583
parent99794ea4d1298ca384baa7f3a07b1834ea60678b (diff)
downloaddevice_samsung_aries-common-e8f88a17d64a94980422c8e19fc9d190a2a92c70.zip
device_samsung_aries-common-e8f88a17d64a94980422c8e19fc9d190a2a92c70.tar.gz
device_samsung_aries-common-e8f88a17d64a94980422c8e19fc9d190a2a92c70.tar.bz2
camera: merges from upstream and reenable Exif for NEC CE147
Diffstat
-rw-r--r--aries/libcamera/Android.mk11
-rw-r--r--aries/libcamera/SecCamera.cpp766
-rw-r--r--aries/libcamera/SecCamera.h70
-rw-r--r--aries/libcamera/SecCameraHWInterface.cpp436
-rw-r--r--aries/libcamera/SecCameraHWInterface.h43
5 files changed, 360 insertions, 966 deletions
diff --git a/aries/libcamera/Android.mk b/aries/libcamera/Android.mk
index 66990a0..c069daf 100644
--- a/aries/libcamera/Android.mk
+++ b/aries/libcamera/Android.mk
@@ -8,7 +8,6 @@ include $(CLEAR_VARS)
LOCAL_CFLAGS:=-fno-short-enums
LOCAL_CFLAGS+=-DDLOPEN_LIBSECCAMERA=$(DLOPEN_LIBSECCAMERA)
-LOCAL_CFLAGS += -DSWP1_CAMERA_ADD_ADVANCED_FUNCTION
ifdef BOARD_CAMERA_DEVICE
LOCAL_CFLAGS += -DCAMERA_DEV_NAME=\"$(BOARD_CAMERA_DEVICE)\"
@@ -19,7 +18,6 @@ ifdef BOARD_SECOND_CAMERA_DEVICE
LOCAL_CFLAGS += -DFFC_PRESENT
endif
-
LOCAL_C_INCLUDES += $(LOCAL_PATH)/../include
LOCAL_C_INCLUDES += $(LOCAL_PATH)/../libs3cjpeg
@@ -33,15 +31,6 @@ LOCAL_SHARED_LIBRARIES:= libutils libui liblog libbinder libcutils
LOCAL_SHARED_LIBRARIES+= libs3cjpeg.aries
LOCAL_SHARED_LIBRARIES+= libcamera_client
-#Enable the below code to show the video output (without GUI) on TV
-#ifeq ($(BOARD_USES_HDMI), true)
-#LOCAL_CFLAGS+=-DENABLE_HDMI_DISPLAY \
-# -DBOARD_HDMI_STD=$(BOARD_HDMI_STD)
-#
-#LOCAL_C_INCLUDES += $(LOCAL_PATH)/../include
-#LOCAL_SHARED_LIBRARIES+= libhdmi
-#endif
-
ifeq ($(BOARD_USES_OVERLAY),true)
LOCAL_CFLAGS += -DBOARD_USES_OVERLAY
endif
diff --git a/aries/libcamera/SecCamera.cpp b/aries/libcamera/SecCamera.cpp
index 4d24a59..6322485 100644
--- a/aries/libcamera/SecCamera.cpp
+++ b/aries/libcamera/SecCamera.cpp
@@ -25,7 +25,6 @@
//#define LOG_NDEBUG 0
#define LOG_TAG "SecCamera"
-#define ADD_THUMB_IMG 1
#include <utils/Log.h>
@@ -37,9 +36,6 @@
using namespace android;
-//#define PERFORMANCE //Uncomment to measure performance
-//#define DUMP_YUV //Uncomment to take a dump of YUV frame during capture
-
#define CHECK(return_value) \
if (return_value < 0) { \
LOGE("%s::%d fail. errno: %s, m_camera_id = %d\n", \
@@ -85,42 +81,6 @@ unsigned long measure_time(struct timeval *start, struct timeval *stop)
return time;
}
-static inline unsigned long check_performance()
-{
- unsigned long time = 0;
- static unsigned long max = 0;
- static unsigned long min = 0xffffffff;
-
- if (time_start.tv_sec == 0 && time_start.tv_usec == 0) {
- gettimeofday(&time_start, NULL);
- } else {
- gettimeofday(&time_stop, NULL);
- time = measure_time(&time_start, &time_stop);
- if (max < time) max = time;
- if (min > time) min = time;
- LOGV("Interval: %lu us (%2.2lf fps), min:%2.2lf fps, max:%2.2lf fps\n",
- time, 1000000.0 / time, 1000000.0 / max, 1000000.0 / min);
- gettimeofday(&time_start, NULL);
- }
-
- return time;
-}
-
-static int close_buffers(struct fimc_buffer *buffers)
-{
- int i;
-
- for (i = 0; i < MAX_BUFFERS; i++) {
- if (buffers[i].start) {
- munmap(buffers[i].start, buffers[i].length);
- //LOGV("munmap():virt. addr[%d]: 0x%x size = %d\n", i, (unsigned int) buffers[i].start, buffers[i].length);
- buffers[i].start = NULL;
- }
- }
-
- return 0;
-}
-
static int get_pixel_depth(unsigned int fmt)
{
int depth = 0;
@@ -162,21 +122,19 @@ static int get_pixel_depth(unsigned int fmt)
#define ALIGN_H(x) (((x) + 0x1F) & (~0x1F)) // Set as multiple of 32
#define ALIGN_BUF(x) (((x) + 0x1FFF)& (~0x1FFF)) // Set as multiple of 8K
-static int init_yuv_buffers(struct fimc_buffer *buffers, int width, int height, unsigned int fmt)
+static int init_preview_buffers(struct fimc_buffer *buffers, int width, int height, unsigned int fmt)
{
int i, len;
- len = (width * height * get_pixel_depth(fmt)) / 8;
+ if (fmt==V4L2_PIX_FMT_NV12T) {
+ len = ALIGN_BUF(ALIGN_W(width) * ALIGN_H(height)) +
+ ALIGN_BUF(ALIGN_W(width) * ALIGN_H(height / 2));
+ } else {
+ len = (width * height * get_pixel_depth(fmt)) / 8;
+ }
for (i = 0; i < MAX_BUFFERS; i++) {
- if (fmt==V4L2_PIX_FMT_NV12T) {
- buffers[i].start = NULL;
- buffers[i].length = ALIGN_BUF(ALIGN_W(width) * ALIGN_H(height)) +
- ALIGN_BUF(ALIGN_W(width) * ALIGN_H(height / 2));
- } else {
- buffers[i].start = NULL;
- buffers[i].length = len;
- }
+ buffers[i].length = len;
}
return 0;
@@ -203,12 +161,28 @@ static int fimc_poll(struct pollfd *events)
return ret;
}
-#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
-static int fimc_esd_poll(struct pollfd *events)
+int SecCamera::previewPoll(bool preview)
{
int ret;
- ret = poll(events, 1, 1000);
+ if (preview) {
+#ifdef ENABLE_ESD_PREVIEW_CHECK
+ int status = 0;
+
+ if (!(++m_esd_check_count % 60)) {
+ status = getCameraSensorESDStatus();
+ m_esd_check_count = 0;
+ if (status) {
+ LOGE("ERR(%s) ESD status(%d)", __func__, status);
+ return status;
+ }
+ }
+#endif
+
+ ret = poll(&m_events_c, 1, 1000);
+ } else {
+ ret = poll(&m_events_c2, 1, 1000);
+ }
if (ret < 0) {
LOGE("ERR(%s):poll error\n", __func__);
@@ -222,44 +196,6 @@ static int fimc_esd_poll(struct pollfd *events)
return ret;
}
-#endif /* SWP1_CAMERA_ADD_ADVANCED_FUNCTION */
-
-#ifdef DUMP_YUV
-static int save_yuv(struct fimc_buffer *m_buffers_c, int width, int height, int depth, int index, int frame_count)
-{
- FILE *yuv_fp = NULL;
- char filename[100], *buffer = NULL;
-
- /* file create/open, note to "wb" */
- yuv_fp = fopen("/data/main.yuv", "wb");
- if (yuv_fp == NULL) {
- LOGE("Save YUV] file open error");
- return -1;
- }
-
- buffer = (char *) malloc(m_buffers_c[index].length);
- if (buffer == NULL) {
- LOGE("Save YUV] buffer alloc failed");
- if (yuv_fp) fclose(yuv_fp);
- return -1;
- }
-
- memcpy(buffer, m_buffers_c[index].start, m_buffers_c[index].length);
-
- fflush(stdout);
-
- fwrite(buffer, 1, m_buffers_c[index].length, yuv_fp);
-
- fflush(yuv_fp);
-
- if (yuv_fp)
- fclose(yuv_fp);
- if (buffer)
- free(buffer);
-
- return 0;
-}
-#endif //DUMP_YUV
static int fimc_v4l2_querycap(int fp)
{
@@ -363,7 +299,7 @@ static int fimc_v4l2_s_fmt_cap(int fp, int width, int height, unsigned int fmt)
v4l2_fmt.fmt.pix = pixfmt;
- //LOGE("ori_w %d, ori_h %d, w %d, h %d\n", width, height, v4l2_fmt.fmt.pix.width, v4l2_fmt.fmt.pix.height);
+ LOGV("ori_w %d, ori_h %d, w %d, h %d\n", width, height, v4l2_fmt.fmt.pix.width, v4l2_fmt.fmt.pix.height);
/* Set up for capture */
ret = ioctl(fp, VIDIOC_S_FMT, &v4l2_fmt);
@@ -384,11 +320,8 @@ static int fimc_v4l2_enum_fmt(int fp, unsigned int fmt)
fmtdesc.index = 0;
while (ioctl(fp, VIDIOC_ENUM_FMT, &fmtdesc) == 0) {
-
- LOGD("found fmt = %#x found pixel format[%d]: %s\n", fmt, fmtdesc.index, fmtdesc.description);
-
if (fmtdesc.pixelformat == fmt) {
- LOGD("passed fmt = %#x found pixel format[%d]: %s\n", fmt, fmtdesc.index, fmtdesc.description);
+ LOGV("passed fmt = %#x found pixel format[%d]: %s\n", fmt, fmtdesc.index, fmtdesc.description);
found = 1;
break;
}
@@ -422,46 +355,34 @@ static int fimc_v4l2_reqbufs(int fp, enum v4l2_buf_type type, int nr_bufs)
return req.count;
}
-static int fimc_v4l2_querybuf(int fp, struct fimc_buffer *buffers, enum v4l2_buf_type type, int nr_frames)
+static int fimc_v4l2_querybuf(int fp, struct fimc_buffer *buffer, enum v4l2_buf_type type)
{
struct v4l2_buffer v4l2_buf;
- int i, ret;
-
- for (i = 0; i < nr_frames; i++) {
- v4l2_buf.type = type;
- v4l2_buf.memory = V4L2_MEMORY_MMAP;
- v4l2_buf.index = i;
-
- ret = ioctl(fp , VIDIOC_QUERYBUF, &v4l2_buf);
- if (ret < 0) {
- LOGE("ERR(%s):VIDIOC_QUERYBUF failed\n", __func__);
- return -1;
- }
+ int ret;
- if (nr_frames == 1) {
- buffers[i].length = v4l2_buf.length;
- if ((buffers[i].start = (char *)mmap(0, v4l2_buf.length, PROT_READ | PROT_WRITE, MAP_SHARED,
- fp, v4l2_buf.m.offset)) < 0) {
- LOGE("%s %d] mmap() failed\n",__func__, __LINE__);
- return -1;
- }
+ LOGI("%s :", __func__);
- //LOGV("buffers[%d].start = %p v4l2_buf.length = %d", i, buffers[i].start, v4l2_buf.length);
- } else {
+ v4l2_buf.type = type;
+ v4l2_buf.memory = V4L2_MEMORY_MMAP;
+ v4l2_buf.index = 0;
-#if defined DUMP_YUV || defined (SEND_YUV_RECORD_DATA)
- buffers[i].length = v4l2_buf.length;
- if ((buffers[i].start = (char *)mmap(0, v4l2_buf.length, PROT_READ | PROT_WRITE, MAP_SHARED,
- fp, v4l2_buf.m.offset)) < 0) {
- LOGE("%s %d] mmap() failed\n",__func__, __LINE__);
- return -1;
- }
+ ret = ioctl(fp , VIDIOC_QUERYBUF, &v4l2_buf);
+ if (ret < 0) {
+ LOGE("ERR(%s):VIDIOC_QUERYBUF failed\n", __func__);
+ return -1;
+ }
- //LOGV("buffers[%d].start = %p v4l2_buf.length = %d", i, buffers[i].start, v4l2_buf.length);
-#endif
- }
+ buffer->length = v4l2_buf.length;
+ if ((buffer->start = (char *)mmap(0, v4l2_buf.length,
+ PROT_READ | PROT_WRITE, MAP_SHARED,
+ fp, v4l2_buf.m.offset)) < 0) {
+ LOGE("%s %d] mmap() failed\n",__func__, __LINE__);
+ return -1;
}
+ LOGI("%s: buffer->start = %p v4l2_buf.length = %d",
+ __func__, buffer->start, v4l2_buf.length);
+
return 0;
}
@@ -484,9 +405,7 @@ static int fimc_v4l2_streamoff(int fp)
enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
int ret;
-#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
LOGV("%s :", __func__);
-#endif
ret = ioctl(fp, VIDIOC_STREAMOFF, &type);
if (ret < 0) {
LOGE("ERR(%s):VIDIOC_STREAMOFF failed\n", __func__);
@@ -524,7 +443,7 @@ static int fimc_v4l2_dqbuf(int fp)
ret = ioctl(fp, VIDIOC_DQBUF, &v4l2_buf);
if (ret < 0) {
- LOGE("ERR(%s):VIDIOC_DQBUF failed\n", __func__);
+ LOGE("ERR(%s):VIDIOC_DQBUF failed, dropped frame\n", __func__);
return ret;
}
@@ -567,7 +486,6 @@ static int fimc_v4l2_s_ctrl(int fp, unsigned int id, unsigned int value)
return ctrl.value;
}
-#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
static int fimc_v4l2_s_ext_ctrl(int fp, unsigned int id, void *value)
{
struct v4l2_ext_controls ctrls;
@@ -587,7 +505,6 @@ static int fimc_v4l2_s_ext_ctrl(int fp, unsigned int id, void *value)
return ret;
}
-#endif
static int fimc_v4l2_g_parm(int fp, struct v4l2_streamparm *streamparm)
{
@@ -640,7 +557,6 @@ SecCamera::SecCamera() :
m_snapshot_max_width (MAX_BACK_CAMERA_SNAPSHOT_WIDTH),
m_snapshot_max_height (MAX_BACK_CAMERA_SNAPSHOT_HEIGHT),
m_angle(-1),
- #ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
m_anti_banding(-1),
m_wdr(-1),
m_anti_shake(-1),
@@ -663,9 +579,6 @@ SecCamera::SecCamera() :
m_video_gamma(-1),
m_slow_ae(-1),
m_camera_af_flag(-1),
- #else
- m_autofocus(-1),
- #endif
m_flag_camera_start(0),
m_jpeg_thumbnail_width (0),
m_jpeg_thumbnail_height(0),
@@ -691,6 +604,8 @@ SecCamera::SecCamera() :
m_params->sharpness = -1;
m_params->white_balance = -1;
+ memset(&m_capture_buf, 0, sizeof(m_capture_buf));
+
LOGV("%s :", __func__);
}
@@ -717,25 +632,12 @@ int SecCamera::initCamera(int index)
*/
m_camera_af_flag = -1;
-#ifndef JPEG_FROM_SENSOR
- m_jpeg_fd = SsbSipJPEGEncodeInit();
- LOGD("(%s):JPEG device open ID = %d\n", __func__, m_jpeg_fd);
- if (m_jpeg_fd < 0) {
- m_jpeg_fd = 0;
- LOGE("ERR(%s):Cannot open a jpeg device file\n", __func__);
- return -1;
- }
-#endif
-
m_cam_fd_temp = -1;
m_cam_fd2_temp = -1;
m_cam_fd = open(CAMERA_DEV_NAME, O_RDWR);
if (m_cam_fd < 0) {
LOGE("ERR(%s):Cannot open %s (error : %s)\n", __func__, CAMERA_DEV_NAME, strerror(errno));
-#ifndef JPEG_FROM_SENSOR
- SsbSipJPEGEncodeDeInit(m_jpeg_fd);
-#endif
return -1;
}
@@ -777,7 +679,6 @@ int SecCamera::initCamera(int index)
ret = fimc_v4l2_s_input(m_cam_fd, index);
CHECK(ret);
-#ifdef DUAL_PORT_RECORDING
m_cam_fd2 = open(CAMERA_DEV_NAME2, O_RDWR);
if (m_cam_fd2 < 0) {
LOGE("ERR(%s):Cannot open %s (error : %s)\n", __func__, CAMERA_DEV_NAME2, strerror(errno));
@@ -832,7 +733,7 @@ int SecCamera::initCamera(int index)
return -1;
ret = fimc_v4l2_s_input(m_cam_fd2, index);
CHECK(ret);
-#endif
+
m_camera_id = index;
setExifFixedAttribute();
@@ -854,35 +755,23 @@ void SecCamera::DeinitCamera()
LOGV("%s :", __func__);
if (m_flag_init) {
-#ifndef JPEG_FROM_SENSOR
- if (m_jpeg_fd > 0) {
- if (SsbSipJPEGEncodeDeInit(m_jpeg_fd) != JPEG_OK) {
- LOGE("ERR(%s):Fail on SsbSipJPEGEncodeDeInit\n", __func__);
- }
- m_jpeg_fd = 0;
- }
-#endif
-#ifdef DUAL_PORT_RECORDING
stopRecord();
-#endif
- /* close m_cam_fd after stopRecord() because stopRecord()
- * uses m_cam_fd to change frame rate
- */
- LOGE("DeinitCamera: m_cam_fd(%d)", m_cam_fd);
+ /* close m_cam_fd after stopRecord() because stopRecord()
+ * uses m_cam_fd to change frame rate
+ */
+ LOGI("DeinitCamera: m_cam_fd(%d)", m_cam_fd);
if (m_cam_fd > -1) {
close(m_cam_fd);
m_cam_fd = -1;
}
-#ifdef DUAL_PORT_RECORDING
- LOGE("DeinitCamera: m_cam_fd2(%d)", m_cam_fd2);
+ LOGI("DeinitCamera: m_cam_fd2(%d)", m_cam_fd2);
if (m_cam_fd2 > -1) {
close(m_cam_fd2);
m_cam_fd2 = -1;
}
-#endif
if (m_cam_fd_temp != -1) {
close(m_cam_fd_temp);
@@ -907,23 +796,12 @@ int SecCamera::getCameraFd(void)
// ======================================================================
// Preview
-int SecCamera::flagPreviewStart(void)
-{
- LOGV("%s:started(%d)", __func__, m_flag_camera_start);
-
- return m_flag_camera_start > 0;
-}
-
int SecCamera::startPreview(void)
{
v4l2_streamparm streamparm;
struct sec_cam_parm *parms;
parms = (struct sec_cam_parm*)&streamparm.parm.raw_data;
-#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
LOGV("%s :", __func__);
-#else /* SWP1_CAMERA_ADD_ADVANCED_FUNCTION */
- LOGE("%s :", __func__);
-#endif /* SWP1_CAMERA_ADD_ADVANCED_FUNCTION */
// aleady started
if (m_flag_camera_start > 0) {
@@ -946,13 +824,9 @@ int SecCamera::startPreview(void)
ret = fimc_v4l2_s_fmt(m_cam_fd, m_preview_width,m_preview_height,m_preview_v4lformat, 0);
CHECK(ret);
- init_yuv_buffers(m_buffers_c, m_preview_width, m_preview_height, m_preview_v4lformat);
ret = fimc_v4l2_reqbufs(m_cam_fd, V4L2_BUF_TYPE_VIDEO_CAPTURE, MAX_BUFFERS);
CHECK(ret);
- ret = fimc_v4l2_querybuf(m_cam_fd, m_buffers_c, V4L2_BUF_TYPE_VIDEO_CAPTURE, MAX_BUFFERS);
- CHECK(ret);
-#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
LOGV("%s : m_preview_width: %d m_preview_height: %d m_angle: %d\n",
__func__, m_preview_width, m_preview_height, m_angle);
@@ -966,7 +840,6 @@ int SecCamera::startPreview(void)
CHECK(ret);
}
-#endif
/* start with all buffers in queue */
for (int i = 0; i < MAX_BUFFERS; i++) {
ret = fimc_v4l2_qbuf(m_cam_fd, i);
@@ -976,7 +849,6 @@ int SecCamera::startPreview(void)
ret = fimc_v4l2_streamon(m_cam_fd);
CHECK(ret);
-#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
m_flag_camera_start = 1;
ret = fimc_v4l2_s_parm(m_cam_fd, &m_streamparm);
@@ -989,7 +861,6 @@ int SecCamera::startPreview(void)
m_blur_level);
CHECK(ret);
}
-#endif
// It is a delay for a new frame, not to show the previous bigger ugly picture frame.
ret = fimc_poll(&m_events_c);
@@ -997,58 +868,43 @@ int SecCamera::startPreview(void)
ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_RETURN_FOCUS, 0);
CHECK(ret);
-#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
LOGV("%s: got the first frame of the preview\n", __func__);
-#endif /* SWP1_CAMERA_ADD_ADVANCED_FUNCTION */
-
-#ifndef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
- m_flag_camera_start = 1;
-#endif /* SWP1_CAMERA_ADD_ADVANCED_FUNCTION */
-#ifdef ENABLE_HDMI_DISPLAY
- hdmi_initialize(m_preview_width,m_preview_height);
- hdmi_gl_initialize(0);
- hdmi_gl_streamoff(0);
-#endif
return 0;
}
int SecCamera::stopPreview(void)
{
- LOGV("%s :", __func__);
+ int ret;
- close_buffers(m_buffers_c);
+ LOGV("%s :", __func__);
if (m_flag_camera_start == 0) {
- LOGV("%s: doing nothing because m_flag_camera_start is zero", __func__);
+ LOGW("%s: doing nothing because m_flag_camera_start is zero", __func__);
return 0;
}
if (m_params->flash_mode == FLASH_MODE_TORCH)
setFlashMode(FLASH_MODE_OFF);
-#ifdef ENABLE_HDMI_DISPLAY
- hdmi_deinitialize();
- hdmi_gl_streamon(0);
-#endif
-
if (m_cam_fd <= 0) {
LOGE("ERR(%s):Camera was closed\n", __func__);
return -1;
}
- int ret = fimc_v4l2_streamoff(m_cam_fd);
+ ret = fimc_v4l2_streamoff(m_cam_fd);
+ CHECK(ret);
m_flag_camera_start = 0;
- CHECK(ret);
return ret;
}
//Recording
-#ifdef DUAL_PORT_RECORDING
int SecCamera::startRecord(void)
{
+ int ret, i;
+
LOGV("%s :", __func__);
// aleady started
@@ -1062,37 +918,26 @@ int SecCamera::startRecord(void)
return -1;
}
- memset(&m_events_c2, 0, sizeof(m_events_c2));
- m_events_c2.fd = m_cam_fd2;
- m_events_c2.events = POLLIN | POLLERR;
-
- int m_record_v4lformat = V4L2_PIX_FMT_NV12T;
/* enum_fmt, s_fmt sample */
- int ret = fimc_v4l2_enum_fmt(m_cam_fd2,m_record_v4lformat);
+ ret = fimc_v4l2_enum_fmt(m_cam_fd2, V4L2_PIX_FMT_NV12T);
CHECK(ret);
-#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
- LOGE("%s: m_recording_width = %d, m_recording_height = %d\n", __func__, m_recording_width, m_recording_height);
-
- ret = fimc_v4l2_s_fmt(m_cam_fd2, m_recording_width, m_recording_height, m_record_v4lformat, 0);
+ LOGI("%s: m_recording_width = %d, m_recording_height = %d\n",
+ __func__, m_recording_width, m_recording_height);
+ ret = fimc_v4l2_s_fmt(m_cam_fd2, m_recording_width,
+ m_recording_height, V4L2_PIX_FMT_NV12T, 0);
CHECK(ret);
- init_yuv_buffers(m_buffers_c2, m_recording_width, m_recording_height, m_record_v4lformat);
-#else /* SWP1_CAMERA_ADD_ADVANCED_FUNCTION */
- ret = fimc_v4l2_s_fmt(m_cam_fd2, m_preview_width, m_preview_height, m_record_v4lformat, 0);
+ ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FRAME_RATE,
+ m_params->capture.timeperframe.denominator);
CHECK(ret);
- init_yuv_buffers(m_buffers_c2, m_preview_width, m_preview_height, m_record_v4lformat);
-#endif /* SWP1_CAMERA_ADD_ADVANCED_FUNCTION */
-
ret = fimc_v4l2_reqbufs(m_cam_fd2, V4L2_BUF_TYPE_VIDEO_CAPTURE, MAX_BUFFERS);
CHECK(ret);
- ret = fimc_v4l2_querybuf(m_cam_fd2, m_buffers_c2, V4L2_BUF_TYPE_VIDEO_CAPTURE, MAX_BUFFERS);
- CHECK(ret);
/* start with all buffers in queue */
- for (int i = 0; i < MAX_BUFFERS; i++) {
+ for (i = 0; i < MAX_BUFFERS; i++) {
ret = fimc_v4l2_qbuf(m_cam_fd2, i);
CHECK(ret);
}
@@ -1100,7 +945,10 @@ int SecCamera::startRecord(void)
ret = fimc_v4l2_streamon(m_cam_fd2);
CHECK(ret);
- // It is a delay for a new frame, not to show the previous bigger ugly picture frame.
+ // Get and throw away the first frame since it is often garbled.
+ memset(&m_events_c2, 0, sizeof(m_events_c2));
+ m_events_c2.fd = m_cam_fd2;
+ m_events_c2.events = POLLIN | POLLERR;
ret = fimc_poll(&m_events_c2);
CHECK(ret);
@@ -1111,21 +959,27 @@ int SecCamera::startRecord(void)
int SecCamera::stopRecord(void)
{
- if (m_flag_record_start == 0)
- return 0;
+ int ret;
LOGV("%s :", __func__);
- close_buffers(m_buffers_c2);
+ if (m_flag_record_start == 0) {
+ LOGW("%s: doing nothing because m_flag_record_start is zero", __func__);
+ return 0;
+ }
if (m_cam_fd2 <= 0) {
LOGE("ERR(%s):Camera was closed\n", __func__);
return -1;
}
- int ret = fimc_v4l2_streamoff(m_cam_fd2);
-
m_flag_record_start = 0;
+
+ ret = fimc_v4l2_streamoff(m_cam_fd2);
+ CHECK(ret);
+
+ ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FRAME_RATE,
+ FRAME_RATE_AUTO);
CHECK(ret);
return 0;
@@ -1148,7 +1002,6 @@ unsigned int SecCamera::getRecPhyAddrC(int index)
CHECK((int)addr_c);
return addr_c;
}
-#endif //DUAL_PORT_RECORDING
unsigned int SecCamera::getPhyAddrY(int index)
{
@@ -1168,17 +1021,6 @@ unsigned int SecCamera::getPhyAddrC(int index)
return addr_c;
}
-#ifdef SEND_YUV_RECORD_DATA
-#define PAGE_ALIGN(x) (((x) + 0xFFF) & (~0xFFF)) // Set as multiple of 4K
-void SecCamera::getYUVBuffers(unsigned char **virYAddr, unsigned char **virCAddr, int index)
-{
- *virYAddr = (unsigned char*)m_buffers_c[index].start;
- //*virCAddr = (unsigned char*)m_buffers_c[index].start + PAGE_ALIGN(m_preview_width * m_preview_height);
- *virCAddr = (unsigned char*)m_buffers_c[index].start +
- ALIGN_TO_8KB(ALIGN_TO_128B(m_preview_width) * ALIGN_TO_32B(m_preview_height));
-}
-#endif
-
void SecCamera::pausePreview()
{
fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_STREAM_PAUSE, 0);
@@ -1187,42 +1029,9 @@ void SecCamera::pausePreview()
int SecCamera::getPreview()
{
int index;
-#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
int ret;
-#endif
-
-#ifdef ENABLE_ESD_PREVIEW_CHECK
- int status = 0;
- if (!(++m_esd_check_count % 60)) {
- status = getCameraSensorESDStatus();
- m_esd_check_count = 0;
- }
-#endif // ENABLE_ESD_PREVIEW_CHECK
-
-#ifdef PERFORMANCE
-
- LOG_TIME_DEFINE(0)
- LOG_TIME_DEFINE(1)
-
- LOG_TIME_START(0)
- fimc_poll(&m_events_c);
- LOG_TIME_END(0)
- LOG_CAMERA("fimc_poll interval: %lu us", LOG_TIME(0));
-
- LOG_TIME_START(1)
- index = fimc_v4l2_dqbuf(m_cam_fd);
- LOG_TIME_END(1)
- LOG_CAMERA("fimc_dqbuf interval: %lu us", LOG_TIME(1));
-
-#else
-#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
-
-#ifdef ENABLE_ESD_PREVIEW_CHECK
- if (m_flag_camera_start == 0 || fimc_esd_poll(&m_events_c) == 0 || status) {
-#else
- if (m_flag_camera_start == 0 || fimc_esd_poll(&m_events_c) == 0) {
-#endif
+ if (m_flag_camera_start == 0 || previewPoll(true) == 0) {
LOGE("ERR(%s):Start Camera Device Reset \n", __func__);
/* GAUDI Project([arun.c@samsung.com]) 2010.05.20. [Implemented ESD code] */
/*
@@ -1239,110 +1048,76 @@ int SecCamera::getPreview()
return -1;
ret = fimc_v4l2_s_input(m_cam_fd, 1000);
CHECK(ret);
- //setCameraSensorReset();
ret = startPreview();
-
-#ifdef ENABLE_ESD_PREVIEW_CHECK
- m_esd_check_count = 0;
-#endif // ENABLE_ESD_PREVIEW_CHECK
-
if (ret < 0) {
LOGE("ERR(%s): startPreview() return %d\n", __func__, ret);
return 0;
}
}
-#else /* SWP1_CAMERA_ADD_ADVANCED_FUNCTION */
- fimc_poll(&m_events_c);
-#endif /* SWP1_CAMERA_ADD_ADVANCED_FUNCTION */
+
index = fimc_v4l2_dqbuf(m_cam_fd);
-#endif
if (!(0 <= index && index < MAX_BUFFERS)) {
LOGE("ERR(%s):wrong index = %d\n", __func__, index);
return -1;
}
-#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
ret = fimc_v4l2_qbuf(m_cam_fd, index);
-#else /* SWP1_CAMERA_ADD_ADVANCED_FUNCTION */
- int ret = fimc_v4l2_qbuf(m_cam_fd, index);
-#endif /* SWP1_CAMERA_ADD_ADVANCED_FUNCTION */
-
CHECK(ret);
-#ifdef ENABLE_HDMI_DISPLAY
- hdmi_set_v_param(getPhyAddrY(index), getPhyAddrC (index), m_preview_width, m_preview_height);
-#endif
return index;
-
}
-#ifdef DUAL_PORT_RECORDING
-int SecCamera::getRecord()
+int SecCamera::getRecordFrame()
{
- int index;
-
-#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
if (m_flag_record_start == 0) {
LOGE("%s: m_flag_record_start is 0", __func__);
- startRecord();
+ return -1;
}
-#endif
-
-#ifdef PERFORMANCE
- LOG_TIME_DEFINE(0)
- LOG_TIME_DEFINE(1)
-
- LOG_TIME_START(0)
- fimc_poll(&m_events_c2);
- LOG_TIME_END(0)
- LOG_CAMERA("fimc_poll interval: %lu us", LOG_TIME(0));
-
- LOG_TIME_START(1)
- index = fimc_v4l2_dqbuf(m_cam_fd2);
- LOG_TIME_END(1)
- LOG_CAMERA("fimc_dqbuf interval: %lu us", LOG_TIME(1));
+ previewPoll(false);
+ return fimc_v4l2_dqbuf(m_cam_fd2);
+}
-#else
- fimc_poll(&m_events_c2);
- index = fimc_v4l2_dqbuf(m_cam_fd2);
-#endif
- if (!(0 <= index && index < MAX_BUFFERS)) {
- LOGE("ERR(%s):wrong index = %d\n", __func__, index);
- return -1;
+int SecCamera::releaseRecordFrame(int index)
+{
+ if (!m_flag_record_start) {
+ /* this can happen when recording frames are returned after
+ * the recording is stopped at the driver level. we don't
+ * need to return the buffers in this case and we've seen
+ * cases where fimc could crash if we called qbuf and it
+ * wasn't expecting it.
+ */
+ LOGI("%s: recording not in progress, ignoring", __func__);
+ return 0;
}
- int ret = fimc_v4l2_qbuf(m_cam_fd2, index);
- CHECK(ret);
-
- return index;
+ return fimc_v4l2_qbuf(m_cam_fd2, index);
}
-#endif //DUAL_PORT_RECORDING
int SecCamera::setPreviewSize(int width, int height, int pixel_format)
{
- LOGD("%s(width(%d), height(%d), format(%d))", __func__, width, height, pixel_format);
+ LOGV("%s(width(%d), height(%d), format(%d))", __func__, width, height, pixel_format);
int v4lpixelformat = pixel_format;
-
+#if defined(LOG_NDEBUG) && LOG_NDEBUG == 0
if (v4lpixelformat == V4L2_PIX_FMT_YUV420)
- LOGD("PreviewFormat:V4L2_PIX_FMT_YUV420");
+ LOGV("PreviewFormat:V4L2_PIX_FMT_YUV420");
else if (v4lpixelformat == V4L2_PIX_FMT_NV12)
- LOGD("PreviewFormat:V4L2_PIX_FMT_NV12");
+ LOGV("PreviewFormat:V4L2_PIX_FMT_NV12");
else if (v4lpixelformat == V4L2_PIX_FMT_NV12T)
- LOGD("PreviewFormat:V4L2_PIX_FMT_NV12T");
+ LOGV("PreviewFormat:V4L2_PIX_FMT_NV12T");
else if (v4lpixelformat == V4L2_PIX_FMT_NV21)
- LOGD("PreviewFormat:V4L2_PIX_FMT_NV21");
+ LOGV("PreviewFormat:V4L2_PIX_FMT_NV21");
else if (v4lpixelformat == V4L2_PIX_FMT_YUV422P)
- LOGD("PreviewFormat:V4L2_PIX_FMT_YUV422P");
+ LOGV("PreviewFormat:V4L2_PIX_FMT_YUV422P");
else if (v4lpixelformat == V4L2_PIX_FMT_YUYV)
- LOGD("PreviewFormat:V4L2_PIX_FMT_YUYV");
+ LOGV("PreviewFormat:V4L2_PIX_FMT_YUYV");
else if (v4lpixelformat == V4L2_PIX_FMT_RGB565)
- LOGD("PreviewFormat:V4L2_PIX_FMT_RGB565");
+ LOGV("PreviewFormat:V4L2_PIX_FMT_RGB565");
else
- LOGE("PreviewFormat:UnknownFormat");
-
+ LOGV("PreviewFormat:UnknownFormat");
+#endif
m_preview_width = width;
m_preview_height = height;
m_preview_v4lformat = v4lpixelformat;
@@ -1375,7 +1150,6 @@ int SecCamera::getPreviewPixelFormat(void)
// ======================================================================
// Snapshot
-#ifdef JPEG_FROM_SENSOR
/*
* Devide getJpeg() as two funcs, setSnapshotCmd() & getJpeg() because of the shutter sound timing.
* Here, just send the capture cmd to camera ISP to start JPEG capture.
@@ -1396,6 +1170,7 @@ int SecCamera::setSnapshotCmd(void)
if (m_flag_camera_start > 0) {
LOG_TIME_START(0)
+ LOGW("WARN(%s):Camera was in preview, should have been stopped\n", __func__);
stopPreview();
LOG_TIME_END(0)
}
@@ -1411,11 +1186,9 @@ int SecCamera::setSnapshotCmd(void)
CHECK(ret);
ret = fimc_v4l2_s_fmt_cap(m_cam_fd, m_snapshot_width, m_snapshot_height, V4L2_PIX_FMT_JPEG);
CHECK(ret);
- init_yuv_buffers(m_buffers_c, m_snapshot_width, m_snapshot_height, m_snapshot_v4lformat);
-
ret = fimc_v4l2_reqbufs(m_cam_fd, V4L2_BUF_TYPE_VIDEO_CAPTURE, nframe);
CHECK(ret);
- ret = fimc_v4l2_querybuf(m_cam_fd, m_buffers_c, V4L2_BUF_TYPE_VIDEO_CAPTURE, nframe);
+ ret = fimc_v4l2_querybuf(m_cam_fd, &m_capture_buf, V4L2_BUF_TYPE_VIDEO_CAPTURE);
CHECK(ret);
ret = fimc_v4l2_qbuf(m_cam_fd, 0);
@@ -1428,6 +1201,21 @@ int SecCamera::setSnapshotCmd(void)
return 0;
}
+int SecCamera::endSnapshot(void)
+{
+ int ret;
+
+ LOGI("%s :", __func__);
+ if (m_capture_buf.start) {
+ munmap(m_capture_buf.start, m_capture_buf.length);
+ LOGI("munmap():virt. addr %p size = %d\n",
+ m_capture_buf.start, m_capture_buf.length);
+ m_capture_buf.start = NULL;
+ m_capture_buf.length = 0;
+ }
+ return 0;
+}
+
/*
* Set Jpeg quality & exif info and get JPEG data from camera ISP
*/
@@ -1440,16 +1228,14 @@ unsigned char* SecCamera::getJpeg(int *jpeg_size, unsigned int *phyaddr)
LOG_TIME_DEFINE(2)
-#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
// capture
ret = fimc_poll(&m_events_c);
CHECK_PTR(ret);
index = fimc_v4l2_dqbuf(m_cam_fd);
- if (!(0 <= index && index < MAX_BUFFERS)) {
+ if (index != 0) {
LOGE("ERR(%s):wrong index = %d\n", __func__, index);
return NULL;
}
-#endif
*jpeg_size = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAM_JPEG_MAIN_SIZE);
CHECK_PTR(*jpeg_size);
@@ -1464,7 +1250,7 @@ unsigned char* SecCamera::getJpeg(int *jpeg_size, unsigned int *phyaddr)
LOGV("\nsnapshot dqueued buffer = %d snapshot_width = %d snapshot_height = %d, size = %d\n\n",
index, m_snapshot_width, m_snapshot_height, *jpeg_size);
- addr = (unsigned char*)(m_buffers_c[index].start) + main_offset;
+ addr = (unsigned char*)(m_capture_buf.start) + main_offset;
*phyaddr = getPhyAddrY(index) + m_postview_offset;
LOG_TIME_START(2) // post
@@ -1478,7 +1264,7 @@ unsigned char* SecCamera::getJpeg(int *jpeg_size, unsigned int *phyaddr)
int SecCamera::getExif(unsigned char *pExifDst, unsigned char *pThumbSrc)
{
JpegEncoder jpgEnc;
-#if ADD_THUMB_IMG
+
LOGV("%s : m_jpeg_thumbnail_width = %d, height = %d",
__func__, m_jpeg_thumbnail_width, m_jpeg_thumbnail_height);
if ((m_jpeg_thumbnail_width > 0) && (m_jpeg_thumbnail_height > 0)) {
@@ -1530,9 +1316,6 @@ int SecCamera::getExif(unsigned char *pExifDst, unsigned char *pThumbSrc)
LOGV("%s : enableThumb set to false", __func__);
mExifInfo.enableThumb = false;
}
-#else
- mExifInfo.enableThumb = false;
-#endif
unsigned int exifSize;
@@ -1576,25 +1359,10 @@ void SecCamera::getThumbnailConfig(int *width, int *height, int *size)
}
}
-#ifdef DIRECT_DELIVERY_OF_POSTVIEW_DATA
int SecCamera::getPostViewOffset(void)
{
return m_postview_offset;
}
-#endif
-
-#else //#ifdef JPEG_FROM_SENSOR
-int SecCamera::getJpegFd(void)
-{
- return m_jpeg_fd;
-}
-
-void SecCamera::SetJpgAddr(unsigned char *addr)
-{
- SetMapAddr(addr);
-}
-
-#endif
int SecCamera::getSnapshotAndJpeg(unsigned char *yuv_buf, unsigned char *jpeg_buf,
unsigned int *output_size)
@@ -1622,6 +1390,7 @@ int SecCamera::getSnapshotAndJpeg(unsigned char *yuv_buf, unsigned char *jpeg_bu
if (m_flag_camera_start > 0) {
LOG_TIME_START(0)
+ LOGW("WARN(%s):Camera was in preview, should have been stopped\n", __func__);
stopPreview();
LOG_TIME_END(0)
}
@@ -1658,11 +1427,9 @@ int SecCamera::getSnapshotAndJpeg(unsigned char *yuv_buf, unsigned char *jpeg_bu
CHECK(ret);
ret = fimc_v4l2_s_fmt_cap(m_cam_fd, m_snapshot_width, m_snapshot_height, m_snapshot_v4lformat);
CHECK(ret);
- init_yuv_buffers(m_buffers_c, m_snapshot_width, m_snapshot_height, m_snapshot_v4lformat);
-
ret = fimc_v4l2_reqbufs(m_cam_fd, V4L2_BUF_TYPE_VIDEO_CAPTURE, nframe);
CHECK(ret);
- ret = fimc_v4l2_querybuf(m_cam_fd, m_buffers_c, V4L2_BUF_TYPE_VIDEO_CAPTURE, nframe);
+ ret = fimc_v4l2_querybuf(m_cam_fd, &m_capture_buf, V4L2_BUF_TYPE_VIDEO_CAPTURE);
CHECK(ret);
ret = fimc_v4l2_qbuf(m_cam_fd, 0);
@@ -1679,17 +1446,12 @@ int SecCamera::getSnapshotAndJpeg(unsigned char *yuv_buf, unsigned char *jpeg_bu
LOGV("\nsnapshot dequeued buffer = %d snapshot_width = %d snapshot_height = %d\n\n",
index, m_snapshot_width, m_snapshot_height);
-#ifdef DUMP_YUV
- save_yuv(m_buffers_c, m_snapshot_width, m_snapshot_height, 16, index, 0);
-#endif
LOG_TIME_END(2)
- memcpy(yuv_buf, (unsigned char*)m_buffers_c[index].start, m_snapshot_width * m_snapshot_height * 2);
+ LOGI("%s : calling memcpy from m_capture_buf", __func__);
+ memcpy(yuv_buf, (unsigned char*)m_capture_buf.start, m_snapshot_width * m_snapshot_height * 2);
LOG_TIME_START(5) // post
fimc_v4l2_streamoff(m_cam_fd);
-#ifdef DUMP_YUV
- close_buffers(m_buffers_c);
-#endif
LOG_TIME_END(5)
LOG_CAMERA("getSnapshotAndJpeg intervals : stopPreview(%lu), prepare(%lu),"
@@ -1826,21 +1588,21 @@ int SecCamera::setSnapshotPixelFormat(int pixel_format)
if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUV420)
LOGE("%s : SnapshotFormat:V4L2_PIX_FMT_YUV420", __func__);
else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV12)
- LOGE("%s : SnapshotFormat:V4L2_PIX_FMT_NV12", __func__);
+ LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_NV12", __func__);
else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV12T)
- LOGE("%s : SnapshotFormat:V4L2_PIX_FMT_NV12T", __func__);
+ LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_NV12T", __func__);
else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV21)
- LOGE("%s : SnapshotFormat:V4L2_PIX_FMT_NV21", __func__);
+ LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_NV21", __func__);
else if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUV422P)
- LOGE("%s : SnapshotFormat:V4L2_PIX_FMT_YUV422P", __func__);
+ LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_YUV422P", __func__);
else if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUYV)
- LOGE("%s : SnapshotFormat:V4L2_PIX_FMT_YUYV", __func__);
+ LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_YUYV", __func__);
else if (m_snapshot_v4lformat == V4L2_PIX_FMT_UYVY)
- LOGE("%s : SnapshotFormat:V4L2_PIX_FMT_UYVY", __func__);
+ LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_UYVY", __func__);
else if (m_snapshot_v4lformat == V4L2_PIX_FMT_RGB565)
- LOGE("%s : SnapshotFormat:V4L2_PIX_FMT_RGB565", __func__);
+ LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_RGB565", __func__);
else
- LOGE("SnapshotFormat:UnknownFormat");
+ LOGD("SnapshotFormat:UnknownFormat");
#endif
return 0;
}
@@ -1850,11 +1612,6 @@ int SecCamera::getSnapshotPixelFormat(void)
return m_snapshot_v4lformat;
}
-int SecCamera::cancelPicture(void)
-{
- return close_buffers(m_buffers_c);
-}
-
// ======================================================================
// Settings
@@ -1903,7 +1660,6 @@ int SecCamera::setAutofocus(void)
{
LOGV("%s :", __func__);
-#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
if (m_cam_fd <= 0) {
LOGE("ERR(%s):Camera was closed\n", __func__);
return -1;
@@ -1914,17 +1670,9 @@ int SecCamera::setAutofocus(void)
return -1;
}
-#else
- // kcoolsw : turn on setAutofocus initially..
- if (m_autofocus != AUTO_FOCUS_ON) {
- m_autofocus = AUTO_FOCUS_ON;
- }
-#endif
-
return 0;
}
-#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
int SecCamera::getAutoFocusResult(void)
{
int af_result;
@@ -1935,6 +1683,7 @@ int SecCamera::getAutoFocusResult(void)
return af_result;
}
+
int SecCamera::cancelAutofocus(void)
{
LOGV("%s :", __func__);
@@ -1951,7 +1700,7 @@ int SecCamera::cancelAutofocus(void)
return 0;
}
-#endif
+
// -----------------------------------
int SecCamera::zoomIn(void)
@@ -1971,7 +1720,6 @@ int SecCamera::zoomOut(void)
int SecCamera::SetRotate(int angle)
{
LOGE("%s(angle(%d))", __func__, angle);
-#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
if (m_angle != angle) {
switch (angle) {
@@ -2008,7 +1756,7 @@ int SecCamera::SetRotate(int angle)
}
}
}
-#endif
+
return 0;
}
@@ -2020,7 +1768,6 @@ int SecCamera::getRotate(void)
int SecCamera::setFrameRate(int frame_rate)
{
-#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
LOGV("%s(FrameRate(%d))", __func__, frame_rate);
if (frame_rate < FRAME_RATE_AUTO || FRAME_RATE_MAX < frame_rate )
@@ -2035,9 +1782,7 @@ int SecCamera::setFrameRate(int frame_rate)
}
}
}
-#else
- m_params->capture.timeperframe.denominator = frame_rate;
-#endif
+
return 0;
}
@@ -2083,25 +1828,19 @@ int SecCamera::setWhiteBalance(int white_balance)
{
LOGV("%s(white_balance(%d))", __func__, white_balance);
-#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
if (white_balance <= WHITE_BALANCE_BASE || WHITE_BALANCE_MAX <= white_balance) {
-#else
- if (white_balance < WHITE_BALANCE_AUTO || WHITE_BALANCE_SUNNY < white_balance) {
-#endif
LOGE("ERR(%s):Invalid white_balance(%d)", __func__, white_balance);
return -1;
}
if (m_params->white_balance != white_balance) {
m_params->white_balance = white_balance;
-#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
if (m_flag_camera_start) {
if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_WHITE_BALANCE, white_balance) < 0) {
LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_WHITE_BALANCE", __func__);
return -1;
}
}
-#endif
}
return 0;
@@ -2128,14 +1867,12 @@ int SecCamera::setBrightness(int brightness)
if (m_params->brightness != brightness) {
m_params->brightness = brightness;
-#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
if (m_flag_camera_start) {
if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_BRIGHTNESS, brightness) < 0) {
LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_BRIGHTNESS", __func__);
return -1;
}
}
-#endif
}
return 0;
@@ -2153,25 +1890,19 @@ int SecCamera::setImageEffect(int image_effect)
{
LOGV("%s(image_effect(%d))", __func__, image_effect);
-#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
if (image_effect <= IMAGE_EFFECT_BASE || IMAGE_EFFECT_MAX <= image_effect) {
-#else
- if (image_effect < IMAGE_EFFECT_ORIGINAL || IMAGE_EFFECT_SILHOUETTE < image_effect) {
-#endif
LOGE("ERR(%s):Invalid image_effect(%d)", __func__, image_effect);
return -1;
}
if (m_params->effects != image_effect) {
m_params->effects = image_effect;
-#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
if (m_flag_camera_start) {
if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_EFFECT, image_effect) < 0) {
LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_EFFECT", __func__);
return -1;
}
}
-#endif
}
return 0;
@@ -2184,7 +1915,6 @@ int SecCamera::getImageEffect(void)
}
// ======================================================================
-#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
int SecCamera::setAntiBanding(int anti_banding)
{
LOGV("%s(anti_banding(%d))", __func__, anti_banding);
@@ -3059,8 +2789,6 @@ int SecCamera::setDataLineCheckStop(void)
return 0;
}
-#endif
-
const __u8* SecCamera::getCameraSensorName(void)
{
LOGV("%s", __func__);
@@ -3083,187 +2811,6 @@ int SecCamera::getCameraSensorESDStatus(void)
// ======================================================================
// Jpeg
-#ifndef JPEG_FROM_SENSOR
-unsigned char* SecCamera::getJpeg(unsigned char *snapshot_data, int snapshot_size, int *size)
-{
- LOGV("%s :", __func__);
-
- if (m_cam_fd <= 0) {
- LOGE("ERR(%s):Camera was closed\n", __func__);
- return NULL;
- }
-
- unsigned char *jpeg_data = NULL;
- int jpeg_size = 0;
-
- jpeg_data = yuv2Jpeg(snapshot_data, snapshot_size, &jpeg_size,
- m_snapshot_width, m_snapshot_height, m_snapshot_v4lformat);
-
- *size = jpeg_size;
- return jpeg_data;
-}
-#endif
-
-#ifndef JPEG_FROM_SENSOR
-unsigned char* SecCamera::yuv2Jpeg(unsigned char *raw_data, int raw_size, int *jpeg_size,
- int width, int height, int pixel_format)
-{
- LOGV("%s:raw_data(%p), raw_size(%d), jpeg_size(%d), width(%d), height(%d), format(%d)",
- __func__, raw_data, raw_size, *jpeg_size, width, height, pixel_format);
-
- if (m_jpeg_fd <= 0) {
- LOGE("ERR(%s):JPEG device was closed\n", __func__);
- return NULL;
- }
- if (pixel_format == V4L2_PIX_FMT_RGB565) {
- LOGE("ERR(%s):It doesn't support V4L2_PIX_FMT_RGB565\n", __func__);
- return NULL;
- }
-
- unsigned char *InBuf = NULL;
- unsigned char *OutBuf = NULL;
- unsigned char *jpeg_data = NULL;
- long frameSize;
- exif_file_info_t ExifInfo;
-
- int input_file_format = JPG_MODESEL_YCBCR;
-
- int out_file_format = JPG_422;
-
- switch (pixel_format) {
- case V4L2_PIX_FMT_NV12:
- case V4L2_PIX_FMT_NV21:
- case V4L2_PIX_FMT_NV12T:
- case V4L2_PIX_FMT_YUV420:
- out_file_format = JPG_420;
- break;
- case V4L2_PIX_FMT_YUYV:
- case V4L2_PIX_FMT_UYVY:
- case V4L2_PIX_FMT_YUV422P:
- out_file_format = JPG_422;
- break;
- }
-
- //////////////////////////////////////////////////////////////
- // 2. set encode config. //
- //////////////////////////////////////////////////////////////
- LOGV("Step 1 : JPEG_SET_ENCODE_IN_FORMAT(JPG_MODESEL_YCBCR)");
- if (SsbSipJPEGSetEncConfig(JPEG_SET_ENCODE_IN_FORMAT, input_file_format) != JPEG_OK) {
- LOGE("ERR(%s):Fail on JPEG_SET_ENCODE_IN_FORMAT\n", __func__);
- goto YUV2JPEG_END;
- }
-
- LOGV("Step 2 : JPEG_SET_SAMPING_MODE(JPG_422)");
- if (SsbSipJPEGSetEncConfig(JPEG_SET_SAMPING_MODE, out_file_format) != JPEG_OK) {
- LOGE("ERR(%s):Fail on JPEG_SET_SAMPING_MODE\n", __func__);
- goto YUV2JPEG_END;
- }
-
- LOGV("Step 3 : JPEG_SET_ENCODE_WIDTH(%d)", width);
- if (SsbSipJPEGSetEncConfig(JPEG_SET_ENCODE_WIDTH, width) != JPEG_OK) {
- LOGE("ERR(%s):Fail on JPEG_SET_ENCODE_WIDTH \n", __func__);
- goto YUV2JPEG_END;
- }
-
- LOGV("Step 4 : JPEG_SET_ENCODE_HEIGHT(%d)", height);
- if (SsbSipJPEGSetEncConfig(JPEG_SET_ENCODE_HEIGHT, height) != JPEG_OK) {
- LOGE("ERR(%s):Fail on JPEG_SET_ENCODE_HEIGHT \n", __func__);
- goto YUV2JPEG_END;
- }
-
- LOGV("Step 5 : JPEG_SET_ENCODE_QUALITY(JPG_QUALITY_LEVEL_2)");
- if (SsbSipJPEGSetEncConfig(JPEG_SET_ENCODE_QUALITY, JPG_QUALITY_LEVEL_2) != JPEG_OK) {
- LOGE("ERR(%s):Fail on JPEG_SET_ENCODE_QUALITY \n", __func__);
- goto YUV2JPEG_END;
- }
-
-#if (INCLUDE_JPEG_THUMBNAIL == 1)
-
- LOGV("Step 6a : JPEG_SET_ENCODE_THUMBNAIL(TRUE)");
- if (SsbSipJPEGSetEncConfig(JPEG_SET_ENCODE_THUMBNAIL, TRUE) != JPEG_OK) {
- LOGE("ERR(%s):Fail on JPEG_SET_ENCODE_THUMBNAIL \n", __func__);
- goto YUV2JPEG_END;
- }
-
- LOGV("Step 6b : JPEG_SET_THUMBNAIL_WIDTH(%d)", m_jpeg_thumbnail_width);
- if (SsbSipJPEGSetEncConfig(JPEG_SET_THUMBNAIL_WIDTH, m_jpeg_thumbnail_width) != JPEG_OK) {
- LOGE("ERR(%s):Fail on JPEG_SET_THUMBNAIL_WIDTH(%d) \n", __func__, m_jpeg_thumbnail_height);
- goto YUV2JPEG_END;
- }
-
- LOGV("Step 6c : JPEG_SET_THUMBNAIL_HEIGHT(%d)", m_jpeg_thumbnail_height);
- if (SsbSipJPEGSetEncConfig(JPEG_SET_THUMBNAIL_HEIGHT, m_jpeg_thumbnail_height) != JPEG_OK) {
- LOGE("ERR(%s):Fail on JPEG_SET_THUMBNAIL_HEIGHT(%d) \n", __func__, m_jpeg_thumbnail_height);
- goto YUV2JPEG_END;
- }
-
-#endif
-
- if (raw_size == 0) {
- unsigned int addr_y;
- int width, height,frame_size;
- getSnapshotSize(&width, &height, &frame_size);
- if (raw_data == NULL) {
- LOGE("%s %d] Raw data is NULL \n", __func__, __LINE__);
- goto YUV2JPEG_END;
- } else {
- addr_y = (unsigned int)raw_data;
- }
-
- SsbSipJPEGSetEncodeInBuf(m_jpeg_fd, addr_y, frame_size);
- } else {
- //////////////////////////////////////////////////////////////
- // 4. get Input buffer address //
- //////////////////////////////////////////////////////////////
- LOGV("Step 7 : Input buffer size(0x%X", raw_size);
- InBuf = (unsigned char *)SsbSipJPEGGetEncodeInBuf(m_jpeg_fd, raw_size);
- if (InBuf == NULL) {
- LOGE("ERR(%s):Fail on SsbSipJPEGGetEncodeInBuf \n", __func__);
- goto YUV2JPEG_END;
- }
- //////////////////////////////////////////////////////////////
- // 5. put YUV stream to Input buffer
- //////////////////////////////////////////////////////////////
- LOGV("Step 8: memcpy(InBuf(%p), raw_data(%p), raw_size(%d)", InBuf, raw_data, raw_size);
- memcpy(InBuf, raw_data, raw_size);
- }
-
- //////////////////////////////////////////////////////////////
- // 6. Make Exif info parameters
- //////////////////////////////////////////////////////////////
- LOGV("Step 9: m_makeExifParam()");
- memset(&ExifInfo, 0x00, sizeof(exif_file_info_t));
- m_makeExifParam(&ExifInfo);
-
- //////////////////////////////////////////////////////////////
- // 7. Encode YUV stream
- //////////////////////////////////////////////////////////////
- LOGV("Step a: SsbSipJPEGEncodeExe()");
- if (SsbSipJPEGEncodeExe(m_jpeg_fd, &ExifInfo, JPEG_USE_SW_SCALER) != JPEG_OK) { //with Exif
- LOGE("ERR(%s):Fail on SsbSipJPEGEncodeExe \n", __func__);
- goto YUV2JPEG_END;
- }
- //////////////////////////////////////////////////////////////
- // 8. get output buffer address
- //////////////////////////////////////////////////////////////
- LOGV("Step b: SsbSipJPEGGetEncodeOutBuf()");
- OutBuf = (unsigned char *)SsbSipJPEGGetEncodeOutBuf(m_jpeg_fd, &frameSize);
- if (OutBuf == NULL) {
- LOGE("ERR(%s):Fail on SsbSipJPEGGetEncodeOutBuf \n", __func__);
- goto YUV2JPEG_END;
- }
- //////////////////////////////////////////////////////////////
- // 9. write JPEG result file
- //////////////////////////////////////////////////////////////
- LOGV("Done");
- jpeg_data = OutBuf;
- *jpeg_size = (int)frameSize;
-
-YUV2JPEG_END:
- return jpeg_data;
-}
-#endif
-
int SecCamera::setJpegThumbnailSize(int width, int height)
{
LOGV("%s(width(%d), height(%d))", __func__, width, height);
@@ -3395,7 +2942,8 @@ void SecCamera::setExifChangedAttribute()
shutterSpeed = 100;
}
mExifInfo.exposure_time.num = 1;
- mExifInfo.exposure_time.den = 1000.0 / shutterSpeed; /* ms -> sec */
+ // x us -> 1/x s */
+ mExifInfo.exposure_time.den = (uint32_t)(1000000 / shutterSpeed);
//3 ISO Speed Rating
int iso = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAMERA_GET_ISO);
@@ -3547,7 +3095,7 @@ void SecCamera::setExifChangedAttribute()
mExifInfo.gps_timestamp[2].num = tm_data.tm_sec;
mExifInfo.gps_timestamp[2].den = 1;
snprintf((char*)mExifInfo.gps_datestamp, sizeof(mExifInfo.gps_datestamp),
- "%04d:%02d:%02d", tm_data.tm_year, tm_data.tm_mon, tm_data.tm_mday);
+ "%04d:%02d:%02d", tm_data.tm_year + 1900, tm_data.tm_mon, tm_data.tm_mday);
mExifInfo.enableGps = true;
} else {
diff --git a/aries/libcamera/SecCamera.h b/aries/libcamera/SecCamera.h
index e1e3a1b..2983be6 100644
--- a/aries/libcamera/SecCamera.h
+++ b/aries/libcamera/SecCamera.h
@@ -34,39 +34,15 @@
#include <sys/stat.h>
#include <linux/videodev2.h>
-#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
#include <videodev2_samsung.h>
-#endif
#include "JpegEncoder.h"
-#ifdef ENABLE_HDMI_DISPLAY
-#include "hdmi_lib.h"
-#endif
-
#include <camera/CameraHardwareInterface.h>
namespace android {
-//Define this if the preview data is to be shared using memory mapped technique instead of passing physical address.
-#define PREVIEW_USING_MMAP
-//Define this if the JPEG images are obtained directly from camera sensor. Else on chip JPEG encoder will be used.
-#define JPEG_FROM_SENSOR
-
-//#define DUAL_PORT_RECORDING //Define this if 2 fimc ports are needed for recording.
-//#define SEND_YUV_RECORD_DATA //Define this to copy YUV data to encoder instead of sharing the physical address.
-
-//#define ENABLE_ESD_PREVIEW_CHECK
-
-#define INCLUDE_JPEG_THUMBNAIL 1 //Valid only for on chip JPEG encoder
-
-#if defined PREVIEW_USING_MMAP
-#define DUAL_PORT_RECORDING
-#endif
-
-#if defined JPEG_FROM_SENSOR
-#define DIRECT_DELIVERY_OF_POSTVIEW_DATA //Define this if postview data is needed in buffer instead of zero copy.
-#endif
+#define ENABLE_ESD_PREVIEW_CHECK
#if defined(LOG_NDEBUG) && LOG_NDEBUG == 0
#define LOG_CAMERA LOGD
@@ -162,19 +138,17 @@ namespace android {
#ifndef CAMERA_DEV_NAME
#define CAMERA_DEV_NAME "/dev/video0"
#endif
-
-#ifdef DUAL_PORT_RECORDING
#ifndef CAMERA_DEV_NAME2
#define CAMERA_DEV_NAME2 "/dev/video2"
#endif
-#endif
+
#define CAMERA_DEV_NAME_TEMP "/data/videotmp_000"
#define CAMERA_DEV_NAME2_TEMP "/data/videotemp_002"
#define BPP 2
#define MIN(x, y) (((x) < (y)) ? (x) : (y))
-#define MAX_BUFFERS 8
+#define MAX_BUFFERS 11
/*
* V 4 L 2 F I M C E X T E N S I O N S
@@ -239,7 +213,6 @@ public:
CAMERA_ID_FRONT = 1,
};
-#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
enum JPEG_QUALITY {
JPEG_QUALITY_ECONOMY = 0,
JPEG_QUALITY_NORMAL = 50,
@@ -283,7 +256,6 @@ public:
int m_touch_af_start_stop;
-#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
struct gps_info_latiude {
unsigned int north_south;
unsigned int dgree;
@@ -302,10 +274,6 @@ public:
unsigned int minute;
unsigned int second;
} gpsInfoAltitude;
-#endif
-
-
-#endif
SecCamera();
~SecCamera();
@@ -325,15 +293,14 @@ public:
int startPreview(void);
int stopPreview(void);
-#ifdef DUAL_PORT_RECORDING
+
int startRecord(void);
int stopRecord(void);
- int getRecord(void);
+ int getRecordFrame(void);
+ int releaseRecordFrame(int index);
unsigned int getRecPhyAddrY(int);
unsigned int getRecPhyAddrC(int);
-#endif
- int cancelPicture(void);
- int flagPreviewStart(void);
+
int getPreview(void);
int setPreviewSize(int width, int height, int pixel_format);
int getPreviewSize(int *width, int *height, int *frame_size);
@@ -373,7 +340,7 @@ public:
int setImageEffect(int image_effect);
int getImageEffect(void);
-#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
+
int setSceneMode(int scene_mode);
int getSceneMode(void);
@@ -447,6 +414,7 @@ public:
int setExifOrientationInfo(int orientationInfo);
int setBatchReflection(void);
int setSnapshotCmd(void);
+ int endSnapshot(void);
int setCameraSensorReset(void);
int setSensorMode(int sensor_mode); /* Camcorder fix fps */
int setShotMode(int shot_mode); /* Shot mode */
@@ -461,10 +429,10 @@ public:
int setDefultIMEI(int imei);
int getDefultIMEI(void);
const __u8* getCameraSensorName(void);
+ int previewPoll(bool preview);
#ifdef ENABLE_ESD_PREVIEW_CHECK
int getCameraSensorESDStatus(void);
#endif // ENABLE_ESD_PREVIEW_CHECK
-#endif
int setFrameRate(int frame_rate);
unsigned char* getJpeg(int*, unsigned int*);
@@ -472,22 +440,15 @@ public:
unsigned int *output_size);
int getExif(unsigned char *pExifDst, unsigned char *pThumbSrc);
-#ifdef JPEG_FROM_SENSOR
void getPostViewConfig(int*, int*, int*);
-#endif
void getThumbnailConfig(int *width, int *height, int *size);
-#ifdef DIRECT_DELIVERY_OF_POSTVIEW_DATA
int getPostViewOffset(void);
-#endif
int getCameraFd(void);
int getJpegFd(void);
void SetJpgAddr(unsigned char *addr);
unsigned int getPhyAddrY(int);
unsigned int getPhyAddrC(int);
-#ifdef SEND_YUV_RECORD_DATA
- void getYUVBuffers(unsigned char **virYAddr, unsigned char **virCaddr, int index);
-#endif
void pausePreview();
int initCamera(int index);
void DeinitCamera();
@@ -536,12 +497,10 @@ private:
int m_cam_fd_temp;
int m_cam_fd2_temp;
-#ifdef DUAL_PORT_RECORDING
+
int m_cam_fd2;
struct pollfd m_events_c2;
int m_flag_record_start;
- struct fimc_buffer m_buffers_c2[MAX_BUFFERS];
-#endif
int m_preview_v4lformat;
int m_preview_width;
@@ -556,10 +515,6 @@ private:
int m_snapshot_max_height;
int m_angle;
-#ifndef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
- int m_autofocus;
-#endif
-#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
int m_anti_banding;
int m_wdr;
int m_anti_shake;
@@ -587,7 +542,6 @@ private:
int m_caf_on_off;
int m_default_imei;
int m_camera_af_flag;
-#endif
int m_flag_camera_start;
@@ -604,7 +558,7 @@ private:
exif_attribute_t mExifInfo;
- struct fimc_buffer m_buffers_c[MAX_BUFFERS];
+ struct fimc_buffer m_capture_buf;
struct pollfd m_events_c;
inline int m_frameSize(int format, int width, int height);
diff --git a/aries/libcamera/SecCameraHWInterface.cpp b/aries/libcamera/SecCameraHWInterface.cpp
index 9044eda..fab4a7e 100644
--- a/aries/libcamera/SecCameraHWInterface.cpp
+++ b/aries/libcamera/SecCameraHWInterface.cpp
@@ -32,15 +32,6 @@
#define ALL_BUFFERS_FLUSHED -66
#endif
-#ifdef SEND_YUV_RECORD_DATA
-#define ALIGN_TO_32B(x) ((((x) + (1 << 5) - 1) >> 5) << 5)
-#define ALIGN_TO_128B(x) ((((x) + (1 << 7) - 1) >> 7) << 7)
-#define ALIGN_TO_8KB(x) ((((x) + (1 << 13) - 1) >> 13) << 13)
-#define RECORD_HEAP_SIZE (ALIGN_TO_8KB(ALIGN_TO_128B(1280) * \
- ALIGN_TO_32B(720)) + ALIGN_TO_8KB(ALIGN_TO_128B(1280) * \
- ALIGN_TO_32B(720 / 2)))
-#endif
-
#define VIDEO_COMMENT_MARKER_H 0xFFBE
#define VIDEO_COMMENT_MARKER_L 0xFFBF
#define VIDEO_COMMENT_MARKER_LENGTH 4
@@ -73,7 +64,6 @@ static const int EFFECT_SKIP_FRAME = 1;
CameraHardwareSec::CameraHardwareSec(int cameraId)
:
- mPreviewRunning(false),
mCaptureInProgress(false),
mParameters(),
mPreviewHeap(0),
@@ -81,9 +71,6 @@ CameraHardwareSec::CameraHardwareSec(int cameraId)
mRecordHeap(0),
mJpegHeap(0),
mSecCamera(NULL),
- mPreviewFrameSize(0),
- mRawFrameSize(0),
- mPreviewFrameRateMicrosec(33000),
mCameraSensorName(NULL),
mSkipFrame(0),
#if defined(BOARD_USES_OVERLAY)
@@ -95,14 +82,10 @@ CameraHardwareSec::CameraHardwareSec(int cameraId)
mDataCbTimestamp(0),
mCallbackCookie(0),
mMsgEnabled(0),
- mCurrentPreviewFrame(0),
- mRecordRunning(false)
-#ifdef JPEG_FROM_SENSOR
- ,
+ mRecordRunning(false),
mPostViewWidth(0),
mPostViewHeight(0),
mPostViewSize(0)
-#endif
{
LOGV("%s :", __func__);
int ret = 0;
@@ -122,22 +105,7 @@ CameraHardwareSec::CameraHardwareSec(int cameraId)
LOGE("ERR(%s):Fail on mSecCamera->flagCreate()", __func__);
}
-#ifndef PREVIEW_USING_MMAP
- int previewHeapSize = sizeof(struct addrs) * kBufferCount;
-
- LOGV("mPreviewHeap : MemoryHeapBase(previewHeapSize(%d))", previewHeapSize);
- mPreviewHeap = new MemoryHeapBase(previewHeapSize);
- if (mPreviewHeap->getHeapID() < 0) {
- LOGE("ERR(%s): Preview heap creation fail", __func__);
- mPreviewHeap.clear();
- }
-#endif
-
-#ifdef SEND_YUV_RECORD_DATA
- int recordHeapSize = RECORD_HEAP_SIZE;
-#else
int recordHeapSize = sizeof(struct addrs) * kBufferCount;
-#endif
LOGV("mRecordHeap : MemoryHeapBase(recordHeapSize(%d))", recordHeapSize);
mRecordHeap = new MemoryHeapBase(recordHeapSize);
if (mRecordHeap->getHeapID() < 0) {
@@ -145,17 +113,11 @@ CameraHardwareSec::CameraHardwareSec(int cameraId)
mRecordHeap.clear();
}
-#ifdef JPEG_FROM_SENSOR
mSecCamera->getPostViewConfig(&mPostViewWidth, &mPostViewHeight, &mPostViewSize);
LOGV("mPostViewWidth = %d mPostViewHeight = %d mPostViewSize = %d",
mPostViewWidth,mPostViewHeight,mPostViewSize);
-#endif
-#ifdef DIRECT_DELIVERY_OF_POSTVIEW_DATA
int rawHeapSize = mPostViewSize;
-#else
- int rawHeapSize = sizeof(struct addrs_cap);
-#endif
LOGV("mRawHeap : MemoryHeapBase(previewHeapSize(%d))", rawHeapSize);
mRawHeap = new MemoryHeapBase(rawHeapSize);
if (mRawHeap->getHeapID() < 0) {
@@ -166,6 +128,11 @@ CameraHardwareSec::CameraHardwareSec(int cameraId)
initDefaultParameters(cameraId);
mExitAutoFocusThread = false;
+ mExitPreviewThread = false;
+ /* whether the PreviewThread is active in preview or stopped. we
+ * create the thread but it is initially in stopped state.
+ */
+ mPreviewRunning = false;
mPreviewThread = new PreviewThread(this);
mAutoFocusThread = new AutoFocusThread(this);
mPictureThread = new PictureThread(this);
@@ -214,17 +181,13 @@ void CameraHardwareSec::initDefaultParameters(int cameraId)
LOGE("getSnapshotMaxSize fail (%d / %d) \n",
snapshot_max_width, snapshot_max_height);
-#ifdef PREVIEW_USING_MMAP
p.setPreviewFormat(CameraParameters::PIXEL_FORMAT_YUV420SP);
-#else
- p.setPreviewFormat("yuv420sp_custom");
-#endif
p.setPreviewSize(preview_max_width, preview_max_height);
p.setPictureFormat(CameraParameters::PIXEL_FORMAT_JPEG);
p.setPictureSize(snapshot_max_width, snapshot_max_height);
p.set(CameraParameters::KEY_JPEG_QUALITY, "100"); // maximum quality
-#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
+
p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS,
CameraParameters::PIXEL_FORMAT_YUV420SP);
p.set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS,
@@ -348,13 +311,12 @@ void CameraHardwareSec::initDefaultParameters(int cameraId)
ip.set("saturation-max", 4);
ip.set("contrast-min", 0);
ip.set("contrast-max", 4);
-#endif
p.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, "100");
p.set(CameraParameters::KEY_ROTATION, 0);
p.set(CameraParameters::KEY_WHITE_BALANCE, CameraParameters::WHITE_BALANCE_AUTO);
-#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
+
p.set(CameraParameters::KEY_EFFECT, CameraParameters::EFFECT_NONE);
ip.set("sharpness", SHARPNESS_DEFAULT);
@@ -369,10 +331,6 @@ void CameraHardwareSec::initDefaultParameters(int cameraId)
ip.set("vtmode", 0);
ip.set("blur", 0);
}
-#else
- ip.set("image-effects", "original");
-#endif
-
p.set(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, "51.2");
p.set(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, "39.4");
@@ -460,9 +418,37 @@ void CameraHardwareSec::setSkipFrame(int frame)
mSkipFrame = frame;
}
+int CameraHardwareSec::previewThreadWrapper()
+{
+ LOGI("%s: starting", __func__);
+ while (1) {
+ mPreviewLock.lock();
+ while (!mPreviewRunning) {
+ LOGI("%s: calling mSecCamera->stopPreview() and waiting", __func__);
+ mSecCamera->stopPreview();
+ /* signal that we're stopping */
+ mPreviewStoppedCondition.signal();
+ mPreviewCondition.wait(mPreviewLock);
+ LOGI("%s: return from wait", __func__);
+ }
+ mPreviewLock.unlock();
+
+ if (mExitPreviewThread) {
+ LOGI("%s: exiting", __func__);
+ mSecCamera->stopPreview();
+ return 0;
+ }
+ previewThread();
+ }
+}
+
int CameraHardwareSec::previewThread()
{
int index;
+ nsecs_t timestamp;
+ unsigned int phyYAddr;
+ unsigned int phyCAddr;
+ struct addrs *addrs;
index = mSecCamera->getPreview();
if (index < 0) {
@@ -477,9 +463,16 @@ int CameraHardwareSec::previewThread()
}
mSkipFrameLock.unlock();
- nsecs_t timestamp = systemTime(SYSTEM_TIME_MONOTONIC);
+ timestamp = systemTime(SYSTEM_TIME_MONOTONIC);
+
+ phyYAddr = mSecCamera->getPhyAddrY(index);
+ phyCAddr = mSecCamera->getPhyAddrC(index);
+
+ if (phyYAddr == 0xffffffff || phyCAddr == 0xffffffff) {
+ LOGE("ERR(%s):Fail on SecCamera getPhyAddr Y addr = %0x C addr = %0x", __func__, phyYAddr, phyCAddr);
+ return UNKNOWN_ERROR;
+ }
-#ifdef PREVIEW_USING_MMAP
int width, height, frame_size, offset;
mSecCamera->getPreviewSize(&width, &height, &frame_size);
@@ -487,129 +480,65 @@ int CameraHardwareSec::previewThread()
offset = (frame_size + 16) * index;
sp<MemoryBase> buffer = new MemoryBase(mPreviewHeap, offset, frame_size);
- unsigned int phyYAddr = mSecCamera->getPhyAddrY(index);
- unsigned int phyCAddr = mSecCamera->getPhyAddrC(index);
-
- if (phyYAddr == 0xffffffff || phyCAddr == 0xffffffff) {
- LOGE("ERR(%s):Fail on SecCamera. Invalid PhyAddr, Y addr = %0x C addr = %0x",
- __func__, phyYAddr, phyCAddr);
- return UNKNOWN_ERROR;
- }
memcpy(static_cast<unsigned char *>(mPreviewHeap->base()) + (offset + frame_size ), &phyYAddr, 4);
memcpy(static_cast<unsigned char *>(mPreviewHeap->base()) + (offset + frame_size + 4), &phyCAddr, 4);
#if defined(BOARD_USES_OVERLAY)
if (mUseOverlay) {
int ret;
+ overlay_buffer_t overlay_buffer;
+
mOverlayBufferIdx ^= 1;
memcpy(static_cast<unsigned char*>(mPreviewHeap->base()) + offset + frame_size + sizeof(phyYAddr) + sizeof(phyCAddr),
- &mOverlayBufferIdx, sizeof(mOverlayBufferIdx));
+ &mOverlayBufferIdx, sizeof(mOverlayBufferIdx));
ret = mOverlay->queueBuffer((void*)(static_cast<unsigned char *>(mPreviewHeap->base()) + (offset + frame_size)));
- if (ret == ALL_BUFFERS_FLUSHED) {
- goto OverlayEnd;
- } else if (ret == -1) {
+ if (ret == -1 ) {
LOGE("ERR(%s):overlay queueBuffer fail", __func__);
- goto OverlayEnd;
- }
-
- overlay_buffer_t overlay_buffer;
- ret = mOverlay->dequeueBuffer(&overlay_buffer);
-
- if (ret == ALL_BUFFERS_FLUSHED) {
- goto OverlayEnd;
- } else if (ret == -1) {
- LOGE("ERR(%s):overlay dequeueBuffer fail", __func__);
- goto OverlayEnd;
- }
- }
-
-OverlayEnd:
+ } else if (ret != ALL_BUFFERS_FLUSHED) {
+ ret = mOverlay->dequeueBuffer(&overlay_buffer);
+ if (ret == -1) {
+ LOGE("ERR(%s):overlay dequeueBuffer fail", __func__);
+ }
+ }
+ }
#endif
-#else
- unsigned int phyYAddr = mSecCamera->getPhyAddrY(index);
- unsigned int phyCAddr = mSecCamera->getPhyAddrC(index);
-
- if (phyYAddr == 0xffffffff || phyCAddr == 0xffffffff) {
- LOGE("ERR(%s):Fail on SecCamera getPhyAddr Y addr = %0x C addr = %0x", __func__, phyYAddr, phyCAddr);
- return UNKNOWN_ERROR;
- }
- struct addrs *addrs = (struct addrs *)mPreviewHeap->base();
-
- sp<MemoryBase> buffer = new MemoryBase(mPreviewHeap, index * sizeof(struct addrs), sizeof(struct addrs));
- addrs[index].addr_y = phyYAddr;
- addrs[index].addr_cbcr = phyCAddr;
-#endif //PREVIEW_USING_MMAP
-
// Notify the client of a new frame.
if (mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME) {
mDataCb(CAMERA_MSG_PREVIEW_FRAME, buffer, mCallbackCookie);
}
+ Mutex::Autolock lock(mRecordLock);
if (mRecordRunning == true) {
-#ifdef SEND_YUV_RECORD_DATA
- int width, height, frame_size;
- unsigned char *virYAddr;
- unsigned char *virCAddr;
-
- mSecCamera->getPreviewSize(&width, &height, &frame_size);
- mSecCamera->getYUVBuffers(&virYAddr, &virCAddr, index);
- sp<MemoryBase> buffer = new MemoryBase(mRecordHeap, 0, frame_size);
- //memcpy(mRecordHeap->base(), (void*)virYAddr, width * height);
- //memcpy(mRecordHeap->base() + (width*height),(void*)virCAddr, width * height * 0.5);
- memcpy(mRecordHeap->base(), (void*)virYAddr, ALIGN_TO_8KB(ALIGN_TO_128B(width) * ALIGN_TO_32B(height)));
- memcpy(mRecordHeap->base() + ALIGN_TO_8KB(ALIGN_TO_128B(width) * ALIGN_TO_32B(height)),
- (void*)virCAddr, ALIGN_TO_8KB(ALIGN_TO_128B(width) * ALIGN_TO_32B(height / 2)));
-#else
-#ifdef DUAL_PORT_RECORDING
- int index = mSecCamera->getRecord();
-
+ index = mSecCamera->getRecordFrame();
if (index < 0) {
LOGE("ERR(%s):Fail on SecCamera->getRecord()", __func__);
return UNKNOWN_ERROR;
}
- unsigned int phyYAddr = mSecCamera->getRecPhyAddrY(index);
- unsigned int phyCAddr = mSecCamera->getRecPhyAddrC(index);
+ phyYAddr = mSecCamera->getRecPhyAddrY(index);
+ phyCAddr = mSecCamera->getRecPhyAddrC(index);
if (phyYAddr == 0xffffffff || phyCAddr == 0xffffffff) {
LOGE("ERR(%s):Fail on SecCamera getRectPhyAddr Y addr = %0x C addr = %0x", __func__, phyYAddr, phyCAddr);
return UNKNOWN_ERROR;
}
-#endif//DUAL_PORT_RECORDING
- struct addrs *addrs = (struct addrs *)mRecordHeap->base();
+
+ addrs = (struct addrs *)mRecordHeap->base();
sp<MemoryBase> buffer = new MemoryBase(mRecordHeap, index * sizeof(struct addrs), sizeof(struct addrs));
addrs[index].addr_y = phyYAddr;
addrs[index].addr_cbcr = phyCAddr;
-#endif
+ addrs[index].buf_index = index;
+
// Notify the client of a new frame.
if (mMsgEnabled & CAMERA_MSG_VIDEO_FRAME) {
- //nsecs_t timestamp = systemTime(SYSTEM_TIME_MONOTONIC);
mDataCbTimestamp(timestamp, CAMERA_MSG_VIDEO_FRAME, buffer, mCallbackCookie);
+ } else {
+ mSecCamera->releaseRecordFrame(index);
}
-#ifdef DUAL_PORT_RECORDING
- } else if (mRecordRunning == false) {
- if (mSecCamera->stopRecord() < 0) {
- LOGE("ERR(%s):Fail on mSecCamera->stopRecord()", __func__);
- return UNKNOWN_ERROR;
- }
-#endif
- }
-
- // Wait for it...
- if (mTimeStart.tv_sec == 0 && mTimeStart.tv_usec == 0) {
- gettimeofday(&mTimeStart, NULL);
- } else {
- gettimeofday(&mTimeStop, NULL);
- long time = measure_time(&mTimeStart, &mTimeStop);
- int delay = (mPreviewFrameRateMicrosec > time) ? mPreviewFrameRateMicrosec - time : 0;
-
- usleep(delay);
- //LOG_CAMERA_PREVIEW("delay = %d time = %ld us\n ", delay, time);
- gettimeofday(&mTimeStart, NULL);
}
return NO_ERROR;
@@ -622,21 +551,18 @@ status_t CameraHardwareSec::startPreview()
LOGV("%s :", __func__);
Mutex::Autolock lock(mStateLock);
- if (mPreviewRunning) {
- // already running
- LOGE("%s : preview thread already running", __func__);
- return INVALID_OPERATION;
- }
-
if (mCaptureInProgress) {
LOGE("%s : capture in progress, not allowed", __func__);
return INVALID_OPERATION;
}
- memset(&mTimeStart, 0, sizeof(mTimeStart));
- memset(&mTimeStop, 0, sizeof(mTimeStop));
-
- mSecCamera->stopPreview();
+ mPreviewLock.lock();
+ if (mPreviewRunning) {
+ // already running
+ LOGE("%s : preview thread already running", __func__);
+ mPreviewLock.unlock();
+ return INVALID_OPERATION;
+ }
setSkipFrame(INITIAL_SKIP_FRAME);
@@ -648,7 +574,6 @@ status_t CameraHardwareSec::startPreview()
return -1; //UNKNOWN_ERROR;
}
-#ifdef PREVIEW_USING_MMAP
if (mPreviewHeap != NULL)
mPreviewHeap.clear();
@@ -660,27 +585,13 @@ status_t CameraHardwareSec::startPreview()
LOGD("MemoryHeapBase(fd(%d), size(%d), width(%d), height(%d))", (int)mSecCamera->getCameraFd(), (size_t)(previewHeapSize), width, height);
mPreviewHeap = new MemoryHeapBase((int)mSecCamera->getCameraFd(), (size_t)(previewHeapSize), (uint32_t)0);
-#endif
-#ifdef JPEG_FROM_SENSOR
mSecCamera->getPostViewConfig(&mPostViewWidth, &mPostViewHeight, &mPostViewSize);
LOGV("CameraHardwareSec: mPostViewWidth = %d mPostViewHeight = %d mPostViewSize = %d",mPostViewWidth,mPostViewHeight,mPostViewSize);
-#endif
-
-#ifdef DIRECT_DELIVERY_OF_POSTVIEW_DATA
- int rawHeapSize = mPostViewSize;
-#else
- int rawHeapSize = sizeof(struct addrs_cap);
-#endif
- LOGV("CameraHardwareSec: mRawHeap : MemoryHeapBase(previewHeapSize(%d))", rawHeapSize);
- mRawHeap = new MemoryHeapBase(rawHeapSize);
- if (mRawHeap->getHeapID() < 0) {
- LOGE("ERR(%s): Raw heap creation fail", __func__);
- mRawHeap.clear();
- }
mPreviewRunning = true;
- mPreviewThread->run("CameraPreviewThread", PRIORITY_URGENT_DISPLAY);
+ mPreviewCondition.signal();
+ mPreviewLock.unlock();
return NO_ERROR;
}
@@ -748,24 +659,22 @@ void CameraHardwareSec::stopPreview()
{
LOGV("%s :", __func__);
- if (!previewEnabled())
- return;
-
- /* request that the preview thread exit. we can wait because we're
- * called by CameraServices with a lock but it has disabled all preview
- * related callbacks so previewThread should not invoke any callbacks.
- */
- mPreviewThread->requestExitAndWait();
-
- if (mSecCamera->stopPreview() < 0)
- LOGE("ERR(%s):Fail on mSecCamera->stopPreview()", __func__);
-
- mPreviewRunning = false;
+ /* request that the preview thread stop. */
+ mPreviewLock.lock();
+ if (mPreviewRunning) {
+ mPreviewRunning = false;
+ mPreviewCondition.signal();
+ /* wait until preview thread is stopped */
+ mPreviewStoppedCondition.wait(mPreviewLock);
+ } else {
+ LOGI("%s : preview not running, doing nothing", __func__);
+ }
+ mPreviewLock.unlock();
}
bool CameraHardwareSec::previewEnabled()
{
- Mutex::Autolock lock(mStateLock);
+ Mutex::Autolock lock(mPreviewLock);
LOGV("%s : %d", __func__, mPreviewRunning);
return mPreviewRunning;
}
@@ -776,14 +685,15 @@ status_t CameraHardwareSec::startRecording()
{
LOGV("%s :", __func__);
-#ifdef DUAL_PORT_RECORDING
+ Mutex::Autolock lock(mRecordLock);
+
+ if (mRecordRunning == false) {
if (mSecCamera->startRecord() < 0) {
LOGE("ERR(%s):Fail on mSecCamera->startRecord()", __func__);
return UNKNOWN_ERROR;
}
-#endif
-
- mRecordRunning = true;
+ mRecordRunning = true;
+ }
return NO_ERROR;
}
@@ -791,7 +701,15 @@ void CameraHardwareSec::stopRecording()
{
LOGV("%s :", __func__);
- mRecordRunning = false;
+ Mutex::Autolock lock(mRecordLock);
+
+ if (mRecordRunning == true) {
+ if (mSecCamera->stopRecord() < 0) {
+ LOGE("ERR(%s):Fail on mSecCamera->stopRecord()", __func__);
+ return;
+ }
+ mRecordRunning = false;
+ }
}
bool CameraHardwareSec::recordingEnabled()
@@ -803,25 +721,19 @@ bool CameraHardwareSec::recordingEnabled()
void CameraHardwareSec::releaseRecordingFrame(const sp<IMemory>& mem)
{
- LOG_CAMERA_PREVIEW("%s :", __func__);
-
-// ssize_t offset; size_t size;
-// sp<MemoryBase> mem1 = mem;
-// sp<MemoryHeapBase> heap = mem->getMemory(&offset, &size);
-// sp<IMemoryHeap> heap = mem->getMemory(&offset, &size);
+ ssize_t offset;
+ sp<IMemoryHeap> heap = mem->getMemory(&offset, NULL);
+ struct addrs *addrs = (struct addrs *)((uint8_t *)heap->base() + offset);
-// mem1.clear();
-// heap.clear();
+ mSecCamera->releaseRecordFrame(addrs->buf_index);
}
// ---------------------------------------------------------------------------
int CameraHardwareSec::autoFocusThread()
{
-#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
int count =0;
int af_status =0 ;
-#endif
LOGV("%s : starting", __func__);
@@ -832,12 +744,20 @@ int CameraHardwareSec::autoFocusThread()
* in CameraServices layer.
*/
mFocusLock.lock();
- mCondition.wait(mFocusLock);
- mFocusLock.unlock();
-
/* check early exit request */
- if (mExitAutoFocusThread)
+ if (mExitAutoFocusThread) {
+ mFocusLock.unlock();
+ LOGV("%s : exiting on request0", __func__);
+ return NO_ERROR;
+ }
+ mFocusCondition.wait(mFocusLock);
+ /* check early exit request */
+ if (mExitAutoFocusThread) {
+ mFocusLock.unlock();
+ LOGV("%s : exiting on request1", __func__);
return NO_ERROR;
+ }
+ mFocusLock.unlock();
LOGV("%s : calling setAutoFocus", __func__);
if (mSecCamera->setAutofocus() < 0) {
@@ -845,8 +765,8 @@ int CameraHardwareSec::autoFocusThread()
return UNKNOWN_ERROR;
}
-#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
-
+ af_status = mSecCamera->getAutoFocusResult();
+
int i;
i = 0;
@@ -868,7 +788,6 @@ int CameraHardwareSec::autoFocusThread()
if (mMsgEnabled & CAMERA_MSG_FOCUS)
mNotifyCb(CAMERA_MSG_FOCUS, true, 0, mCallbackCookie);
}
-
//FIXME: determine that the user cancled the AF
#if 0
else if (af_status == 0x02) {
@@ -888,11 +807,8 @@ int CameraHardwareSec::autoFocusThread()
if (mMsgEnabled & CAMERA_MSG_FOCUS)
mNotifyCb(CAMERA_MSG_FOCUS, false, 0, mCallbackCookie);
}
-#else
- if (mMsgEnabled & CAMERA_MSG_FOCUS)
- mNotifyCb(CAMERA_MSG_FOCUS, true, 0, mCallbackCookie);
-#endif
+ LOGV("%s : exiting with no error", __func__);
return NO_ERROR;
}
@@ -900,21 +816,19 @@ status_t CameraHardwareSec::autoFocus()
{
LOGV("%s :", __func__);
/* signal autoFocusThread to run once */
- mCondition.signal();
+ mFocusCondition.signal();
return NO_ERROR;
}
/* 2009.10.14 by icarus for added interface */
status_t CameraHardwareSec::cancelAutoFocus()
{
-#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
LOGV("%s :", __func__);
if (mSecCamera->cancelAutofocus() < 0) {
LOGE("ERR(%s):Fail on mSecCamera->cancelAutofocus()", __func__);
return UNKNOWN_ERROR;
}
-#endif
return NO_ERROR;
}
@@ -1049,7 +963,7 @@ bool CameraHardwareSec::YUY2toNV21(void *srcBuf, void *dstBuf, uint32_t srcWidth
int CameraHardwareSec::pictureThread()
{
- LOGV("%s :", __func__);
+ LOGV("%s :", __func__);
int jpeg_size = 0;
int ret = NO_ERROR;
@@ -1076,11 +990,8 @@ int CameraHardwareSec::pictureThread()
LOG_TIME_DEFINE(0)
LOG_TIME_START(0)
-#ifdef DIRECT_DELIVERY_OF_POSTVIEW_DATA
+
sp<MemoryBase> buffer = new MemoryBase(mRawHeap, 0, mPostViewSize + 8);
-#else
- sp<MemoryBase> buffer = new MemoryBase(mRawHeap, 0, sizeof(struct addrs_cap));
-#endif
struct addrs_cap *addrs = (struct addrs_cap *)mRawHeap->base();
@@ -1105,11 +1016,9 @@ int CameraHardwareSec::pictureThread()
// Modified the shutter sound timing for Jpeg capture
if (mSecCamera->getCameraId() == SecCamera::CAMERA_ID_BACK)
mSecCamera->setSnapshotCmd();
-#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
if (mMsgEnabled & CAMERA_MSG_SHUTTER) {
mNotifyCb(CAMERA_MSG_SHUTTER, 0, 0, mCallbackCookie);
}
-#endif
if (mSecCamera->getCameraId() == SecCamera::CAMERA_ID_BACK){
jpeg_data = mSecCamera->getJpeg(&jpeg_size, &phyAddr);
@@ -1128,11 +1037,7 @@ int CameraHardwareSec::pictureThread()
LOGI("snapshotandjpeg done\n");
}
-
-#ifndef DIRECT_DELIVERY_OF_POSTVIEW_DATA
-
addrs[0].addr_y = phyAddr;
-#endif
LOG_TIME_END(1)
LOG_CAMERA("getSnapshotAndJpeg interval: %lu us", LOG_TIME(1));
@@ -1151,15 +1056,34 @@ int CameraHardwareSec::pictureThread()
}
if (mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE) {
+
memcpy(JpegHeap->base (), jpeg_data, jpeg_size + 2);
- sp<MemoryBase> mem = new MemoryBase(JpegHeap, 0, jpeg_size);
+
+ int JpegExifSize;
+ sp<MemoryHeapBase> ExifHeap = new MemoryHeapBase(EXIF_FILE_SIZE + JPG_STREAM_BUF_SIZE);
+ JpegExifSize = mSecCamera->getExif((unsigned char *)ExifHeap->base(),
+ (unsigned char *)ThumbnailHeap->base());
+
+ LOGV("JpegExifSize=%d", JpegExifSize);
+
+ if (JpegExifSize < 0) {
+ ret = UNKNOWN_ERROR;
+ goto out;
+ }
+
+ unsigned char *ExifStart = (unsigned char *)JpegHeap->base() + 2;
+ unsigned char *ImageStart = ExifStart + JpegExifSize;
+ memmove(ImageStart, ExifStart, jpeg_size - 2);
+ memcpy(ExifStart, ExifHeap->base(), JpegExifSize);
+
+ sp<MemoryBase> mem = new MemoryBase(JpegHeap, 0, jpeg_size + JpegExifSize);
mDataCb(CAMERA_MSG_COMPRESSED_IMAGE, mem, mCallbackCookie);
}
LOG_TIME_END(0)
LOG_CAMERA("pictureThread interval: %lu us", LOG_TIME(0));
-
+out:
LOGV("%s : pictureThread end", __func__);
return ret;
}
@@ -1189,9 +1113,6 @@ status_t CameraHardwareSec::cancelPicture()
{
mPictureThread->requestExitAndWait();
- mSecCamera->cancelPicture();
-
- LOGW("%s : not supported, just returning NO_ERROR", __func__);
return NO_ERROR;
}
@@ -1356,22 +1277,19 @@ int CameraHardwareSec::decodeInterleaveData(unsigned char *pInterleaveData,
int yuv_size = 0;
int i = 0;
-
- LOGV("CameraHardwareSec::decodeInterleaveData( %d,%d, %d, %d)", interleaveDataSize,
- yuvWidth, yuvHeight, pJpegSize);
LOGV("decodeInterleaveData Start~~~");
while (i < interleaveDataSize) {
if ((*interleave_ptr == 0xFFFFFFFF) || (*interleave_ptr == 0x02FFFFFF) ||
(*interleave_ptr == 0xFF02FFFF)) {
// Padding Data
- LOGV("%d(%x) padding data\n", i, *interleave_ptr);
+// LOGE("%d(%x) padding data\n", i, *interleave_ptr);
interleave_ptr++;
i += 4;
}
else if ((*interleave_ptr & 0xFFFF) == 0x05FF) {
// Start-code of YUV Data
- LOGV("%d(%x) yuv data\n", i, *interleave_ptr);
+// LOGE("%d(%x) yuv data\n", i, *interleave_ptr);
p = (unsigned char *)interleave_ptr;
p += 2;
i += 2;
@@ -1395,7 +1313,7 @@ int CameraHardwareSec::decodeInterleaveData(unsigned char *pInterleaveData,
}
} else {
// Extract JPEG Data
- //LOGV("%d(%x) jpg data, jpeg_size = %d bytes\n", i, *interleave_ptr, jpeg_size);
+// LOGE("%d(%x) jpg data, jpeg_size = %d bytes\n", i, *interleave_ptr, jpeg_size);
if (pJpegData != NULL) {
memcpy(jpeg_ptr, interleave_ptr, 4);
jpeg_ptr += 4;
@@ -1438,7 +1356,7 @@ status_t CameraHardwareSec::dump(int fd, const Vector<String16>& args) const
mSecCamera->dump(fd, args);
mParameters.dump(fd, args);
mInternalParameters.dump(fd, args);
- snprintf(buffer, 255, " preview frame(%d), size (%d), running(%s)\n", mCurrentPreviewFrame, mPreviewFrameSize, mPreviewRunning?"true": "false");
+ snprintf(buffer, 255, " preview running(%s)\n", mPreviewRunning?"true": "false");
result.append(buffer);
} else {
result.append("No camera client yet.\n");
@@ -1547,9 +1465,7 @@ status_t CameraHardwareSec::setParameters(const CameraParameters& params)
else if (!strcmp(new_str_picture_format, "uyv422i")) //Non-zero copy UYVY format
new_picture_format = V4L2_PIX_FMT_UYVY;
else if (!strcmp(new_str_picture_format, CameraParameters::PIXEL_FORMAT_JPEG))
-#ifdef JPEG_FROM_SENSOR
new_picture_format = V4L2_PIX_FMT_YUYV;
-#endif
else if (!strcmp(new_str_picture_format, "yuv422p"))
new_picture_format = V4L2_PIX_FMT_YUV422P;
else
@@ -1563,7 +1479,6 @@ status_t CameraHardwareSec::setParameters(const CameraParameters& params)
}
}
-#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
//JPEG image quality
int new_jpeg_quality = params.getInt(CameraParameters::KEY_JPEG_QUALITY);
LOGV("%s : new_jpeg_quality %d", __func__, new_jpeg_quality);
@@ -1576,17 +1491,6 @@ status_t CameraHardwareSec::setParameters(const CameraParameters& params)
mParameters.set(CameraParameters::KEY_JPEG_QUALITY, new_jpeg_quality);
}
}
-#else
- //JPEG image quality
- int new_jpeg_quality = params.getInt(CameraParameters::KEY_JPEG_QUALITY);
- LOGV("%s : new_jpeg_quality %d", __func__, new_jpeg_quality);
- if (new_jpeg_quality < 0) {
- LOGW("JPEG-image quality is not specified or is negative, defaulting to 100");
- new_jpeg_quality = 100;
- mParameters.set(CameraParameters::KEY_JPEG_QUALITY, "100");
- }
- mSecCamera->setJpegQuality(new_jpeg_quality);
-#endif
// JPEG thumbnail size
int new_jpeg_thumbnail_width = params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH);
@@ -1866,17 +1770,10 @@ status_t CameraHardwareSec::setParameters(const CameraParameters& params)
}
if (new_image_effect >= 0) {
-
if (mSecCamera->setImageEffect(new_image_effect) < 0) {
LOGE("ERR(%s):Fail on mSecCamera->setImageEffect(effect(%d))", __func__, new_image_effect);
ret = UNKNOWN_ERROR;
} else {
-
- if (mSecCamera->stopPreview() < 0) {
- LOGE("ERR(%s):Fail on mSecCamera->stopPreview", __func__);
- ret = UNKNOWN_ERROR;
- }
-
const char *old_image_effect_str = mParameters.get(CameraParameters::KEY_EFFECT);
if (old_image_effect_str) {
@@ -1886,15 +1783,7 @@ status_t CameraHardwareSec::setParameters(const CameraParameters& params)
}
mParameters.set(CameraParameters::KEY_EFFECT, new_image_effect_str);
-
- //sleep a bit to give the cam a chance to get ready
- usleep(100000);
- if (mSecCamera->startPreview() < 0) {
- LOGE("ERR(%s):Fail on mSecCamera->startPreview", __func__);
- ret = UNKNOWN_ERROR;
- }
}
-
}
}
@@ -2112,6 +2001,18 @@ status_t CameraHardwareSec::setParameters(const CameraParameters& params)
}
}
LOGV("%s return ret = %d", __func__, ret);
+
+ if (mSecCamera->stopPreview() < 0) {
+ LOGE("ERR(%s):Fail on mSecCamera->stopPreview", __func__);
+ ret = UNKNOWN_ERROR;
+ }
+
+ //sleep a bit to give the cam a chance to get ready
+ usleep(100000);
+ if (mSecCamera->startPreview() < 0) {
+ LOGE("ERR(%s):Fail on mSecCamera->startPreview", __func__);
+ ret = UNKNOWN_ERROR;
+ }
return ret;
}
@@ -2138,6 +2039,14 @@ void CameraHardwareSec::release()
* for ourself to exit, which is a deadlock.
*/
if (mPreviewThread != NULL) {
+ /* this thread is normally already in it's threadLoop but blocked
+ * on the condition variable or running. signal it so it wakes
+ * up and can exit.
+ */
+ mPreviewThread->requestExit();
+ mExitPreviewThread = true;
+ mPreviewRunning = true; /* let it run so it can exit */
+ mPreviewCondition.signal();
mPreviewThread->requestExitAndWait();
mPreviewThread.clear();
}
@@ -2145,9 +2054,11 @@ void CameraHardwareSec::release()
/* this thread is normally already in it's threadLoop but blocked
* on the condition variable. signal it so it wakes up and can exit.
*/
+ mFocusLock.lock();
mAutoFocusThread->requestExit();
mExitAutoFocusThread = true;
- mCondition.signal();
+ mFocusCondition.signal();
+ mFocusLock.unlock();
mAutoFocusThread->requestExitAndWait();
mAutoFocusThread.clear();
}
@@ -2161,8 +2072,11 @@ void CameraHardwareSec::release()
if (mJpegHeap != NULL)
mJpegHeap.clear();
- if (mPreviewHeap != NULL)
+ if (mPreviewHeap != NULL) {
+ LOGI("%s: calling mPreviewHeap.dispose()", __func__);
+ mPreviewHeap->dispose();
mPreviewHeap.clear();
+ }
if (mRecordHeap != NULL)
mRecordHeap.clear();
diff --git a/aries/libcamera/SecCameraHWInterface.h b/aries/libcamera/SecCameraHWInterface.h
index 6f52ece..75526c6 100644
--- a/aries/libcamera/SecCameraHWInterface.h
+++ b/aries/libcamera/SecCameraHWInterface.h
@@ -80,21 +80,14 @@ private:
CameraHardwareSec *mHardware;
public:
PreviewThread(CameraHardwareSec *hw):
-#ifdef SINGLE_PROCESS
- // In single process mode this thread needs to be a java thread,
- // since we won't be calling through the binder.
- Thread(true),
-#else
Thread(false),
-#endif
mHardware(hw) { }
+ virtual void onFirstRef() {
+ run("CameraPreviewThread", PRIORITY_URGENT_DISPLAY);
+ }
virtual bool threadLoop() {
- int ret = mHardware->previewThread();
- // loop until we need to quit
- if(ret == NO_ERROR)
- return true;
- else
- return false;
+ mHardware->previewThreadWrapper();
+ return false;
}
};
@@ -106,6 +99,7 @@ private:
mHardware(hw) { }
virtual bool threadLoop() {
mHardware->pictureThread();
+ mHardware->mSecCamera->endSnapshot();
return false;
}
};
@@ -128,7 +122,7 @@ private:
sp<PreviewThread> mPreviewThread;
int previewThread();
- bool mPreviewRunning;
+ int previewThreadWrapper();
sp<AutoFocusThread> mAutoFocusThread;
int autoFocusThread();
@@ -164,9 +158,16 @@ private:
void setSkipFrame(int frame);
/* used by auto focus thread to block until it's told to run */
mutable Mutex mFocusLock;
- mutable Condition mCondition;
+ mutable Condition mFocusCondition;
bool mExitAutoFocusThread;
+ /* used by preview thread to block until it's told to run */
+ mutable Mutex mPreviewLock;
+ mutable Condition mPreviewCondition;
+ mutable Condition mPreviewStoppedCondition;
+ bool mPreviewRunning;
+ bool mExitPreviewThread;
+
/* used to guard threading state */
mutable Mutex mStateLock;
@@ -181,9 +182,6 @@ private:
sp<MemoryBase> mRecordBuffers[kBufferCountForRecord];
SecCamera *mSecCamera;
- int mPreviewFrameSize;
- int mRawFrameSize;
- int mPreviewFrameRateMicrosec;
const __u8 *mCameraSensorName;
mutable Mutex mSkipFrameLock;
@@ -202,20 +200,11 @@ private:
int32_t mMsgEnabled;
- // only used from PreviewThread
- int mCurrentPreviewFrame;
- int mCurrentRecordFrame;
-
bool mRecordRunning;
-#ifdef JPEG_FROM_SENSOR
+ mutable Mutex mRecordLock;
int mPostViewWidth;
int mPostViewHeight;
int mPostViewSize;
-#endif
-
- struct timeval mTimeStart;
- struct timeval mTimeStop;
-
};
}; // namespace android
generated by cgit v1.1 at 2025-07-03 04:15:24 +0000