exynos hal: jellybean compat
diff --git a/exynos5/hal/include/sec_utils.h b/exynos5/hal/include/sec_utils.h
index 4aed6e0..26b63a1 100644
--- a/exynos5/hal/include/sec_utils.h
+++ b/exynos5/hal/include/sec_utils.h
@@ -134,7 +134,7 @@
break;
default:
- LOGE("%s::unmatched HAL_PIXEL_FORMAT color_space(0x%x)\n",
+ ALOGE("%s::unmatched HAL_PIXEL_FORMAT color_space(0x%x)\n",
__func__, HAL_PIXEL_FORMAT);
break;
}
@@ -216,7 +216,7 @@
break;
default:
- LOGE("%s::unmatched V4L2_PIX color_space(%d)\n",
+ ALOGE("%s::unmatched V4L2_PIX color_space(%d)\n",
__func__, V4L2_PIX);
break;
}
@@ -295,7 +295,7 @@
break;
default:
- LOGD("%s::no matching source colorformat(0x%x), w(%d), h(%d) fail\n",
+ ALOGD("%s::no matching source colorformat(0x%x), w(%d), h(%d) fail\n",
__func__, HAL_PIXEL_FORMAT, w, h);
break;
}
diff --git a/exynos5/hal/include/sec_utils_v4l2.h b/exynos5/hal/include/sec_utils_v4l2.h
index 5c05c1d..b74eaed 100644
--- a/exynos5/hal/include/sec_utils_v4l2.h
+++ b/exynos5/hal/include/sec_utils_v4l2.h
@@ -151,7 +151,7 @@
break;
default:
- LOGE("%s::unmatched HAL_PIXEL_FORMAT color_space(0x%x)\n",
+ ALOGE("%s::unmatched HAL_PIXEL_FORMAT color_space(0x%x)\n",
__func__, HAL_PIXEL_FORMAT);
break;
}
@@ -239,7 +239,7 @@
break;
default:
- LOGE("%s::unmatched V4L2_PIX color_space(%d)\n",
+ ALOGE("%s::unmatched V4L2_PIX color_space(%d)\n",
__func__, V4L2_PIX);
break;
}
@@ -319,7 +319,7 @@
break;
default:
- LOGD("%s::no matching source colorformat(0x%x), w(%d), h(%d) fail\n",
+ ALOGD("%s::no matching source colorformat(0x%x), w(%d), h(%d) fail\n",
__func__, HAL_PIXEL_FORMAT, w, h);
break;
}
diff --git a/exynos5/hal/libcamera/SecCamera.cpp b/exynos5/hal/libcamera/SecCamera.cpp
index 2b434c5..bd18479 100644
--- a/exynos5/hal/libcamera/SecCamera.cpp
+++ b/exynos5/hal/libcamera/SecCamera.cpp
@@ -23,8 +23,8 @@
*************************************
*/
-//#define LOG_NDEBUG 0
-#define LOG_TAG "SecCamera"
+//#define ALOG_NDEBUG 0
+#define ALOG_TAG "SecCamera"
#include <utils/Log.h>
#include <string.h>
@@ -40,14 +40,14 @@
#define CHECK(return_value) \
if (return_value < 0) { \
- LOGE("%s::%d fail. errno: %s, m_camera_id = %d", \
+ ALOGE("%s::%d fail. errno: %s, m_camera_id = %d", \
__func__, __LINE__, strerror(errno), m_camera_id); \
return -1; \
}
#define CHECK_PTR(return_value) \
if (return_value < 0) { \
- LOGE("%s::%d fail, errno: %s, m_camera_id = %d", \
+ ALOGE("%s::%d fail, errno: %s, m_camera_id = %d", \
__func__,__LINE__, strerror(errno), m_camera_id); \
return NULL; \
}
@@ -60,7 +60,7 @@
static struct timeval time_stop;
int cam_fd1, cam_fd2;
-#if defined(LOG_NDEBUG) && LOG_NDEBUG == 0
+#if defined(ALOG_NDEBUG) && LOG_NDEBUG == 0
unsigned long measure_time_camera(struct timeval *start, struct timeval *stop)
{
unsigned long sec, usec, time;
@@ -87,14 +87,14 @@
id += GSC_VD_NODE_OFFSET;
sprintf(node, "%s%d", PFX_NODE_GSC, id);
- LOGE("(%s): %s%d", __func__, PFX_NODE_GSC, id);
+ ALOGE("(%s): %s%d", __func__, PFX_NODE_GSC, id);
fd = open(node, O_RDWR, 0);
if(fd < 0) {
- LOGE("ERR(%s): Open gscaler video device failed", __func__);
+ ALOGE("ERR(%s): Open gscaler video device failed", __func__);
return -1;
}
- LOGE("%s open", node);
+ ALOGE("%s open", node);
return fd;
}
@@ -152,7 +152,7 @@
break;
default:
- LOGE("ERR(%s):Get depth failed.", __func__);
+ ALOGE("ERR(%s):Get depth failed.", __func__);
break;
}
@@ -168,12 +168,12 @@
*/
ret = poll(events, 1, 10000);
if (ret < 0) {
- LOGE("ERR(%s):poll error", __func__);
+ ALOGE("ERR(%s):poll error", __func__);
return ret;
}
if (ret == 0) {
- LOGE("ERR(%s):No data in 10 secs..", __func__);
+ ALOGE("ERR(%s):No data in 10 secs..", __func__);
return ret;
}
@@ -185,16 +185,16 @@
struct v4l2_capability cap;
if (ioctl(fp, VIDIOC_QUERYCAP, &cap) < 0) {
- LOGE("ERR(%s):VIDIOC_QUERYCAP failed", __func__);
+ ALOGE("ERR(%s):VIDIOC_QUERYCAP failed", __func__);
return -1;
}
if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE_MPLANE)) {
- LOGE("ERR(%s):no capture devices", __func__);
+ ALOGE("ERR(%s):no capture devices", __func__);
return -1;
}
if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
- LOGE("ERR(%s):no streaming capture devices", __func__);
+ ALOGE("ERR(%s):no streaming capture devices", __func__);
return -1;
}
@@ -207,10 +207,10 @@
input.index = index;
if (ioctl(fp, VIDIOC_ENUMINPUT, &input) != 0) {
- LOGE("ERR(%s):No matching index found", __func__);
+ ALOGE("ERR(%s):No matching index found", __func__);
return NULL;
}
- LOGI("Name of input channel[%d] is %s", input.index, input.name);
+ ALOGI("Name of input channel[%d] is %s", input.index, input.name);
return input.name;
}
@@ -222,7 +222,7 @@
input.index = index;
if (ioctl(fp, VIDIOC_S_INPUT, &input) < 0) {
- LOGE("ERR(%s):VIDIOC_S_INPUT failed", __func__);
+ ALOGE("ERR(%s):VIDIOC_S_INPUT failed", __func__);
return -1;
}
@@ -236,7 +236,7 @@
v4l2_fmt.type = V4L2_BUF_TYPE;
if(ioctl(fp, VIDIOC_G_FMT, &v4l2_fmt) < 0){
- LOGE("ERR(%s):VIDIOC_G_FMT failed", __func__);
+ ALOGE("ERR(%s):VIDIOC_G_FMT failed", __func__);
return -1;
}
@@ -268,14 +268,14 @@
v4l2_fmt.fmt.pix_mp.plane_fmt[1].sizeimage = ALIGN(width/2, 8) * ALIGN(height/2, 8);
v4l2_fmt.fmt.pix_mp.plane_fmt[2].sizeimage = ALIGN(width/2, 8) * ALIGN(height/2, 8);
} else {
- LOGE("ERR(%s): Invalid plane number", __func__);
+ ALOGE("ERR(%s): Invalid plane number", __func__);
return -1;
}
v4l2_fmt.fmt.pix_mp.num_planes = num_plane;
/* Set up for capture */
if (ioctl(fp, VIDIOC_S_FMT, &v4l2_fmt) < 0) {
- LOGE("ERR(%s):VIDIOC_S_FMT failed", __func__);
+ ALOGE("ERR(%s):VIDIOC_S_FMT failed", __func__);
return -1;
}
@@ -301,7 +301,7 @@
/* Set up for capture */
if (ioctl(fp, VIDIOC_S_FMT, &v4l2_fmt) < 0) {
- LOGE("ERR(%s):VIDIOC_S_FMT failed", __func__);
+ ALOGE("ERR(%s):VIDIOC_S_FMT failed", __func__);
return -1;
}
@@ -326,7 +326,7 @@
/* Set up for capture */
if (ioctl(fp, VIDIOC_S_FMT, &v4l2_fmt) < 0) {
- LOGE("ERR(%s):VIDIOC_S_FMT failed", __func__);
+ ALOGE("ERR(%s):VIDIOC_S_FMT failed", __func__);
return -1;
}
@@ -343,7 +343,7 @@
while (ioctl(fp, VIDIOC_ENUM_FMT, &fmtdesc) == 0) {
if (fmtdesc.pixelformat == fmt) {
- LOGV("Passed fmt = %#x found pixel format[%d]: %s", fmt, fmtdesc.index, fmtdesc.description);
+ ALOGV("Passed fmt = %#x found pixel format[%d]: %s", fmt, fmtdesc.index, fmtdesc.description);
found = 1;
break;
}
@@ -352,7 +352,7 @@
}
if (!found) {
- LOGE("unsupported pixel format");
+ ALOGE("unsupported pixel format");
return -1;
}
@@ -368,12 +368,12 @@
req.memory = V4L2_MEMORY_TYPE;
if (ioctl(fp, VIDIOC_REQBUFS, &req) < 0) {
- LOGE("ERR(%s):VIDIOC_REQBUFS failed", __func__);
+ ALOGE("ERR(%s):VIDIOC_REQBUFS failed", __func__);
return -1;
}
if (req.count > MAX_BUFFERS ) {
- LOGE("ERR(%s):Insufficient buffer memory on", __func__);
+ ALOGE("ERR(%s):Insufficient buffer memory on", __func__);
return -1;
}
@@ -392,28 +392,28 @@
v4l2_buf.index = i;
v4l2_buf.m.planes = planes;
v4l2_buf.length = num_plane; // this is for multi-planar
- LOGV("QUERYBUF(index=%d)", i);
- LOGV("Memory plane is %d", v4l2_buf.length);
+ ALOGV("QUERYBUF(index=%d)", i);
+ ALOGV("Memory plane is %d", v4l2_buf.length);
if (ioctl(fp, VIDIOC_QUERYBUF, &v4l2_buf) < 0) {
- LOGE("ERR(%s):VIDIOC_QUERYBUF failed", __func__);
+ ALOGE("ERR(%s):VIDIOC_QUERYBUF failed", __func__);
return -1;
}
for (plane_index = 0; plane_index < num_plane; plane_index++) {
- LOGV("Offset : 0x%x", v4l2_buf.m.planes[plane_index].m.mem_offset);
- LOGV("Plane Length : 0x%x", v4l2_buf.m.planes[plane_index].length);
+ ALOGV("Offset : 0x%x", v4l2_buf.m.planes[plane_index].m.mem_offset);
+ ALOGV("Plane Length : 0x%x", v4l2_buf.m.planes[plane_index].length);
buffers[i].phys.extP[plane_index] = (unsigned int)v4l2_buf.m.planes[plane_index].cookie;
buffers[i].size.extS[plane_index] = v4l2_buf.m.planes[plane_index].length;
- LOGV("Length[%d] : 0x%x", i, buffers[i].size.extS[plane_index]);
+ ALOGV("Length[%d] : 0x%x", i, buffers[i].size.extS[plane_index]);
if ((buffers[i].virt.extP[plane_index] = (char *)mmap(0, v4l2_buf.m.planes[plane_index].length,
PROT_READ | PROT_WRITE, MAP_SHARED, fp, v4l2_buf.m.planes[plane_index].m.mem_offset)) < 0) {
- LOGE("mmap failed");
+ ALOGE("mmap failed");
return -1;
}
- LOGV("vaddr[%d][%d] : 0x%x", i, plane_index, (__u32) buffers[i].virt.extP[plane_index]);
+ ALOGV("vaddr[%d][%d] : 0x%x", i, plane_index, (__u32) buffers[i].virt.extP[plane_index]);
}
}
return 0;
@@ -424,10 +424,10 @@
enum v4l2_buf_type type = V4L2_BUF_TYPE;
int ret;
- LOGV("%s : On streaming I/O", __func__);
+ ALOGV("%s : On streaming I/O", __func__);
ret = ioctl(fp, VIDIOC_STREAMON, &type);
if (ret < 0) {
- LOGE("ERR(%s):VIDIOC_STREAMON failed", __func__);
+ ALOGE("ERR(%s):VIDIOC_STREAMON failed", __func__);
return ret;
}
@@ -439,10 +439,10 @@
enum v4l2_buf_type type = V4L2_BUF_TYPE;
int ret;
- LOGV("%s :", __func__);
+ ALOGV("%s :", __func__);
ret = ioctl(fp, VIDIOC_STREAMOFF, &type);
if (ret < 0) {
- LOGE("ERR(%s):VIDIOC_STREAMOFF failed", __func__);
+ ALOGE("ERR(%s):VIDIOC_STREAMOFF failed", __func__);
return ret;
}
@@ -480,7 +480,7 @@
v4l2_buf.m.planes[2].m.userptr = (long unsigned int)vaddr[index].virt.extP[2];
v4l2_buf.m.planes[2].length = ALIGN(width/2, 8) * ALIGN(height/2, 8);
} else {
- LOGE("ERR(%s): Invalid plane number", __func__);
+ ALOGE("ERR(%s): Invalid plane number", __func__);
return -1;
}
}
@@ -496,7 +496,7 @@
ret = ioctl(fp, VIDIOC_QBUF, &v4l2_buf);
if (ret < 0) {
- LOGE("ERR(%s):VIDIOC_QBUF failed", __func__);
+ ALOGE("ERR(%s):VIDIOC_QBUF failed", __func__);
return ret;
}
@@ -518,7 +518,7 @@
ret = ioctl(fp, VIDIOC_DQBUF, &v4l2_buf);
if (ret < 0) {
- LOGE("ERR(%s):VIDIOC_DQBUF failed, dropped frame", __func__);
+ ALOGE("ERR(%s):VIDIOC_DQBUF failed, dropped frame", __func__);
return ret;
}
@@ -534,7 +534,7 @@
ret = ioctl(fp, VIDIOC_G_CTRL, &ctrl);
if (ret < 0) {
- LOGE("ERR(%s): VIDIOC_G_CTRL(id = 0x%x (%d)) failed, ret = %d",
+ ALOGE("ERR(%s): VIDIOC_G_CTRL(id = 0x%x (%d)) failed, ret = %d",
__func__, id, id-V4L2_CID_PRIVATE_BASE, ret);
return ret;
}
@@ -552,7 +552,7 @@
ret = ioctl(fp, VIDIOC_S_CTRL, &ctrl);
if (ret < 0) {
- LOGE("ERR(%s):VIDIOC_S_CTRL(id = %#x (%d), value = %d) failed ret = %d",
+ ALOGE("ERR(%s):VIDIOC_S_CTRL(id = %#x (%d), value = %d) failed ret = %d",
__func__, id, id-V4L2_CID_PRIVATE_BASE, value, ret);
return ret;
@@ -575,7 +575,7 @@
ret = ioctl(fp, VIDIOC_S_EXT_CTRLS, &ctrls);
if (ret < 0)
- LOGE("ERR(%s):VIDIOC_S_EXT_CTRLS failed", __func__);
+ ALOGE("ERR(%s):VIDIOC_S_EXT_CTRLS failed", __func__);
return ret;
}
@@ -588,11 +588,11 @@
ret = ioctl(fp, VIDIOC_G_PARM, streamparm);
if (ret < 0) {
- LOGE("ERR(%s):VIDIOC_G_PARM failed", __func__);
+ ALOGE("ERR(%s):VIDIOC_G_PARM failed", __func__);
return ret;
}
- LOGV("%s : timeperframe: numerator %d, denominator %d", __func__,
+ ALOGV("%s : timeperframe: numerator %d, denominator %d", __func__,
streamparm->parm.capture.timeperframe.numerator,
streamparm->parm.capture.timeperframe.denominator);
@@ -607,7 +607,7 @@
ret = ioctl(fp, VIDIOC_S_PARM, streamparm);
if (ret < 0) {
- LOGE("ERR(%s):VIDIOC_S_PARM failed", __func__);
+ ALOGE("ERR(%s):VIDIOC_S_PARM failed", __func__);
return ret;
}
@@ -620,7 +620,7 @@
fd = open(entity->devname, O_RDWR, 0);
if(fd < 0){
- LOGE("ERR(%s): Open failed.", __func__);
+ ALOGE("ERR(%s): Open failed.", __func__);
return -1;
}
@@ -630,7 +630,7 @@
static int v4l2_subdev_get_fmt(int fd, struct v4l2_subdev_format *fmt)
{
if(ioctl(fd, VIDIOC_SUBDEV_G_FMT, fmt)) {
- LOGE("ERR(%s): subdev get foramt failed.", __func__);
+ ALOGE("ERR(%s): subdev get foramt failed.", __func__);
return -1;
}
@@ -718,18 +718,18 @@
SecCamera::~SecCamera()
{
- LOGV("%s :", __func__);
+ ALOGV("%s :", __func__);
DestroyCamera();
}
bool SecCamera::CreateCamera(int index)
{
- LOGV("%s:", __func__);
+ ALOGV("%s:", __func__);
char node[30];
int i;
int ret = 0;
- LOGV("%s: m_flagCreate : %d", __func__, m_flagCreate);
+ ALOGV("%s: m_flagCreate : %d", __func__, m_flagCreate);
if (!m_flagCreate) {
/* Arun C
* Reset the lense position only during camera starts; don't do
@@ -739,11 +739,11 @@
m_camera_af_flag = -1;
/* media device open */
- LOGV("%s: m_flagCreate : %d", __func__, m_flagCreate);
+ ALOGV("%s: m_flagCreate : %d", __func__, m_flagCreate);
media = media_open();
if (media == NULL) {
- LOGE("ERR(%s):Cannot open media device (error : %s)", __func__, strerror(errno));
+ ALOGE("ERR(%s):Cannot open media device (error : %s)", __func__, strerror(errno));
return -1;
}
@@ -753,39 +753,39 @@
//////////////////
/* camera subdev */
strcpy(node, M5MOLS_ENTITY_NAME);
- LOGV("%s : node : %s", __func__, node);
+ ALOGV("%s : node : %s", __func__, node);
camera_sd_entity = media_get_entity_by_name(media, node, strlen(node));
- LOGV("%s : camera_sd_entity : 0x%p", __func__, camera_sd_entity);
+ ALOGV("%s : camera_sd_entity : 0x%p", __func__, camera_sd_entity);
/* mipi-csis subdev */
sprintf(node, "%s.%d", PFX_SUBDEV_ENTITY_MIPI_CSIS, MIPI_NUM);
- LOGV("%s : node : %s", __func__, node);
+ ALOGV("%s : node : %s", __func__, node);
mipi_sd_entity = media_get_entity_by_name(media, node, strlen(node));
- LOGV("%s : mipi_sd_entity : 0x%p", __func__, mipi_sd_entity);
+ ALOGV("%s : mipi_sd_entity : 0x%p", __func__, mipi_sd_entity);
/* fimc-lite subdev */
sprintf(node, "%s.%d", PFX_SUBDEV_ENTITY_FLITE, FLITE_NUM);
- LOGV("%s : node : %s", __func__, node);
+ ALOGV("%s : node : %s", __func__, node);
flite_sd_entity = media_get_entity_by_name(media, node, strlen(node));
- LOGV("%s : flite_sd_entity : 0x%p", __func__, flite_sd_entity);
+ ALOGV("%s : flite_sd_entity : 0x%p", __func__, flite_sd_entity);
/* gscaler-capture subdev */
sprintf(node, "%s.%d", PFX_SUBDEV_ENTITY_GSC_CAP, GSC_NUM);
- LOGV("%s : node : %s", __func__, node);
+ ALOGV("%s : node : %s", __func__, node);
gsc_cap_sd_entity = media_get_entity_by_name(media, node, strlen(node));
- LOGV("%s : gsc_cap_sd_entity : 0x%p", __func__, gsc_cap_sd_entity);
+ ALOGV("%s : gsc_cap_sd_entity : 0x%p", __func__, gsc_cap_sd_entity);
/* gscaler-capture subdev */
sprintf(node, "%s.%d", PFX_VIDEODEV_ENTITY_GSC_CAP, GSC_NUM);
- LOGV("%s : node : %s", __func__, node);
+ ALOGV("%s : node : %s", __func__, node);
gsc_cap_vd_entity = media_get_entity_by_name(media, node, strlen(node));
- LOGV("%s : gsc_cap_vd_entity : 0x%p", __func__, gsc_cap_vd_entity);
+ ALOGV("%s : gsc_cap_vd_entity : 0x%p", __func__, gsc_cap_vd_entity);
- LOGV("camera_sd : numlink : %d", camera_sd_entity->num_links);
- LOGV("mipi_sd : numlink : %d", mipi_sd_entity->num_links);
- LOGV("flite_sd : numlink : %d", flite_sd_entity->num_links);
- LOGV("gsc_cap_sd : numlink : %d", gsc_cap_sd_entity->num_links);
- LOGV("gsc_cap_vd : numlink : %d", gsc_cap_vd_entity->num_links);
+ ALOGV("camera_sd : numlink : %d", camera_sd_entity->num_links);
+ ALOGV("mipi_sd : numlink : %d", mipi_sd_entity->num_links);
+ ALOGV("flite_sd : numlink : %d", flite_sd_entity->num_links);
+ ALOGV("gsc_cap_sd : numlink : %d", gsc_cap_sd_entity->num_links);
+ ALOGV("gsc_cap_vd : numlink : %d", gsc_cap_vd_entity->num_links);
//////////////////
/* SETUP LINKS */
@@ -795,68 +795,68 @@
if (links == NULL ||
links->source->entity != camera_sd_entity ||
links->sink->entity != mipi_sd_entity) {
- LOGE("ERR(%s): Cannot make link camera sensor to mipi-csis", __func__);
+ ALOGE("ERR(%s): Cannot make link camera sensor to mipi-csis", __func__);
return -1;
}
if (media_setup_link(media, links->source, links->sink, MEDIA_LNK_FL_ENABLED) < 0) {
- LOGE("ERR(%s): Cannot make setup camera sensor to mipi-csis", __func__);
+ ALOGE("ERR(%s): Cannot make setup camera sensor to mipi-csis", __func__);
return -1;
}
- LOGV("[LINK SUCCESS] camera seneor to mipi-csis");
+ ALOGV("[LINK SUCCESS] camera seneor to mipi-csis");
/*mipi-csis to fimc-lite*/
for(i = 0; i < mipi_sd_entity->num_links; i++) {
links = &mipi_sd_entity->links[i];
- LOGV("(%s), i=%d: links->source->entity : %p, mipi_sd_entity : %p", __func__, i,
+ ALOGV("(%s), i=%d: links->source->entity : %p, mipi_sd_entity : %p", __func__, i,
links->source->entity, mipi_sd_entity);
- LOGV("(%s), i=%d: links->sink->entity : %p, flite_sd_entity : %p", __func__, i,
+ ALOGV("(%s), i=%d: links->sink->entity : %p, flite_sd_entity : %p", __func__, i,
links->sink->entity, flite_sd_entity);
if (links == NULL ||
links->source->entity != mipi_sd_entity ||
links->sink->entity != flite_sd_entity) {
continue;
} else if (media_setup_link(media, links->source, links->sink, MEDIA_LNK_FL_ENABLED) < 0) {
- LOGE("ERR(%s): Cannot make setup mipi-csis to fimc-lite", __func__);
+ ALOGE("ERR(%s): Cannot make setup mipi-csis to fimc-lite", __func__);
return -1;
}
}
- LOGV("[LINK SUCCESS] mipi-csis to fimc-lite");
+ ALOGV("[LINK SUCCESS] mipi-csis to fimc-lite");
/*fimc-lite to gscaler capture device*/
for(i = 0; i < gsc_cap_sd_entity->num_links; i++) {
links = &gsc_cap_sd_entity->links[i];
- LOGV("(%s), i=%d: links->source->entity : %p, flite_sd_entity : %p", __func__, i,
+ ALOGV("(%s), i=%d: links->source->entity : %p, flite_sd_entity : %p", __func__, i,
links->source->entity, flite_sd_entity);
- LOGV("(%s), i=%d: links->sink->entity : %p, gsc_cap_sd_entity : %p", __func__, i,
+ ALOGV("(%s), i=%d: links->sink->entity : %p, gsc_cap_sd_entity : %p", __func__, i,
links->sink->entity, gsc_cap_sd_entity);
if (links == NULL ||
links->source->entity != flite_sd_entity ||
links->sink->entity != gsc_cap_sd_entity) {
continue;
} else if (media_setup_link(media, links->source, links->sink, MEDIA_LNK_FL_ENABLED) < 0) {
- LOGE("ERR(%s): Cannot make setup fimc-lite to gscaler capture device", __func__);
+ ALOGE("ERR(%s): Cannot make setup fimc-lite to gscaler capture device", __func__);
return -1;
}
}
- LOGV("[LINK SUCCESS] fimc-lite to gscaler capture device");
+ ALOGV("[LINK SUCCESS] fimc-lite to gscaler capture device");
/*gscaler capture device to gscaler video device*/
for(i = 0; i < gsc_cap_vd_entity->num_links; i++) {
links = &gsc_cap_vd_entity->links[i];
- LOGV("(%s), i=%d: links->source->entity : %p, gsc_cap_sd_entity : %p", __func__, i,
+ ALOGV("(%s), i=%d: links->source->entity : %p, gsc_cap_sd_entity : %p", __func__, i,
links->source->entity, gsc_cap_sd_entity);
- LOGV("(%s), i=%d: links->sink->entity : %p, gsc_cap_vd_entity : %p", __func__, i,
+ ALOGV("(%s), i=%d: links->sink->entity : %p, gsc_cap_vd_entity : %p", __func__, i,
links->sink->entity, gsc_cap_vd_entity);
if (links == NULL ||
links->source->entity != gsc_cap_sd_entity ||
links->sink->entity != gsc_cap_vd_entity) {
continue;
} else if (media_setup_link(media, links->source, links->sink, MEDIA_LNK_FL_ENABLED) < 0) {
- LOGE("ERR(%s): Cannot make setup gscaler capture device to gscaler video device", __func__);
+ ALOGE("ERR(%s): Cannot make setup gscaler capture device to gscaler video device", __func__);
return -1;
}
}
- LOGV("[LINK SUCCESS] gscaler capture device to gscaler video device");
+ ALOGV("[LINK SUCCESS] gscaler capture device to gscaler video device");
#else
//////////////////////////////
// internal IS
@@ -895,12 +895,12 @@
strcpy(node, ISP_VIDEO_3DNR_NAME);
isp_3dnr_entity = media_get_entity_by_name(media, node, strlen(node));
- LOGV("isp_sensor_entity : numlink : %d", isp_sensor_entity->num_links);
- LOGV("isp_front_entity : numlink : %d", isp_front_entity->num_links);
- LOGV("isp_back_entity : numlink : %d", isp_back_entity->num_links);
- LOGV("isp_scalerc_entity : numlink : %d", isp_scalerc_entity->num_links);
- LOGV("isp_scalerp_entity : numlink : %d", isp_scalerp_entity->num_links);
- LOGV("isp_3dnr_entity : numlink : %d", isp_3dnr_entity->num_links);
+ ALOGV("isp_sensor_entity : numlink : %d", isp_sensor_entity->num_links);
+ ALOGV("isp_front_entity : numlink : %d", isp_front_entity->num_links);
+ ALOGV("isp_back_entity : numlink : %d", isp_back_entity->num_links);
+ ALOGV("isp_scalerc_entity : numlink : %d", isp_scalerc_entity->num_links);
+ ALOGV("isp_scalerp_entity : numlink : %d", isp_scalerp_entity->num_links);
+ ALOGV("isp_3dnr_entity : numlink : %d", isp_3dnr_entity->num_links);
//////////////////
/* SETUP LINKS */
@@ -910,14 +910,14 @@
if (links == NULL ||
links->source->entity != isp_sensor_entity ||
links->sink->entity != isp_front_entity) {
- LOGE("[ERR] Can not make link isp_sensor to isp_front\n");
+ ALOGE("[ERR] Can not make link isp_sensor to isp_front\n");
return -1;
}
if(media_setup_link(media, links->source, links->sink, MEDIA_LNK_FL_ENABLED) < 0) {
- LOGE("[ERR] Can not make setup isp_sensor to isp_front\n");
+ ALOGE("[ERR] Can not make setup isp_sensor to isp_front\n");
return -1;
}
- LOGV("[LINK SUCCESS] Sensor to front");
+ ALOGV("[LINK SUCCESS] Sensor to front");
/* FRONT TO BACK */
for (i = 0; i < isp_front_entity->num_links; i++){
@@ -925,17 +925,17 @@
if (links == NULL ||
links->source->entity != isp_front_entity ||
links->sink->entity != isp_back_entity) {
- LOGV("(%s), i=%d: links->source->entity : %p, isp_front_entity : %p", __func__, i,
+ ALOGV("(%s), i=%d: links->source->entity : %p, isp_front_entity : %p", __func__, i,
links->source->entity, isp_front_entity);
- LOGV("(%s), i=%d: links->sink->entity : %p, isp_back_entity : %p", __func__, i,
+ ALOGV("(%s), i=%d: links->sink->entity : %p, isp_back_entity : %p", __func__, i,
links->sink->entity, isp_back_entity);
continue;
} else if(media_setup_link(media, links->source, links->sink, MEDIA_LNK_FL_ENABLED) < 0) {
- LOGE("[ERR] Can not make setup isp_front to isp_back\n");
+ ALOGE("[ERR] Can not make setup isp_front to isp_back\n");
return -1;
}
}
- LOGV("[LINK SUCCESS] front to back");
+ ALOGV("[LINK SUCCESS] front to back");
/* BACK TO ScalerP Video*/
for (i = 0; i < isp_back_entity->num_links; i++){
@@ -943,30 +943,30 @@
if (links == NULL ||
links->source->entity != isp_back_entity ||
links->sink->entity != isp_scalerp_entity) {
- LOGV("(%s), i=%d: links->source->entity : %p, isp_front_entity : %p", __func__, i,
+ ALOGV("(%s), i=%d: links->source->entity : %p, isp_front_entity : %p", __func__, i,
links->source->entity, isp_front_entity);
- LOGV("(%s), i=%d: links->sink->entity : %p, isp_back_entity : %p", __func__, i,
+ ALOGV("(%s), i=%d: links->sink->entity : %p, isp_back_entity : %p", __func__, i,
links->sink->entity, isp_back_entity);
continue;
}
if(media_setup_link(media, links->source, links->sink, MEDIA_LNK_FL_ENABLED) < 0) {
- LOGE("[ERR] Can not make setup isp_back to scalerP\n");
+ ALOGE("[ERR] Can not make setup isp_back to scalerP\n");
return -1;
}
}
- LOGV("[LINK SUCCESS] back to scalerP");
+ ALOGV("[LINK SUCCESS] back to scalerP");
#endif
m_gsc_vd_fd = gsc_cap_open(0);
cam_fd1 = m_gsc_vd_fd;
if (m_gsc_vd_fd < 0) {
- LOGE("ERR(%s):Cannot open %s (error : %s)", __func__, PFX_NODE_GSC, strerror(errno));
+ ALOGE("ERR(%s):Cannot open %s (error : %s)", __func__, PFX_NODE_GSC, strerror(errno));
return -1;
}
#ifndef GAIA_FW_BETA
if (!v4l2_gsc_cap_enuminput(m_gsc_vd_fd, index)) {
- LOGE("m_gsc_vd_fd(%d) v4l2_gsc_cap_enuminput fail", m_gsc_vd_fd);
+ ALOGE("m_gsc_vd_fd(%d) v4l2_gsc_cap_enuminput fail", m_gsc_vd_fd);
return -1;
}
@@ -999,14 +999,14 @@
void SecCamera::resetCamera()
{
- LOGV("%s :", __func__);
+ ALOGV("%s :", __func__);
DestroyCamera();
CreateCamera(m_camera_id);
}
bool SecCamera::DestroyCamera()
{
- LOGV("%s :", __func__);
+ ALOGV("%s :", __func__);
if (m_flagCreate) {
@@ -1015,13 +1015,13 @@
/* close m_gsc_vd_fd after stopRecord() because stopRecord()
* uses m_gsc_vd_fd to change frame rate
*/
- LOGI("DestroyCamera: m_gsc_vd_fd(%d)", m_gsc_vd_fd);
+ ALOGI("DestroyCamera: m_gsc_vd_fd(%d)", m_gsc_vd_fd);
if (m_gsc_vd_fd > -1) {
close(m_gsc_vd_fd);
m_gsc_vd_fd = -1;
}
- LOGI("DestroyCamera: m_cam_fd2(%d)", m_cam_fd2);
+ ALOGI("DestroyCamera: m_cam_fd2(%d)", m_cam_fd2);
if (m_cam_fd2 > -1) {
close(m_cam_fd2);
m_cam_fd2 = -1;
@@ -1029,7 +1029,7 @@
m_flagCreate = 0;
} else
- LOGI("%s : already deinitialized", __func__);
+ ALOGI("%s : already deinitialized", __func__);
return 0;
}
@@ -1051,16 +1051,16 @@
int ret;
parms = (struct sec_cam_parm*)&streamparm.parm.raw_data;
- LOGV("%s :", __func__);
+ ALOGV("%s :", __func__);
// check preview is aleady started.
if (m_flag_camera_start > 0) {
- LOGE("ERR(%s):Preview was already started", __func__);
+ ALOGE("ERR(%s):Preview was already started", __func__);
return 0;
}
if (m_gsc_vd_fd <= 0) {
- LOGE("ERR(%s):Camera was closed", __func__);
+ ALOGE("ERR(%s):Camera was closed", __func__);
return -1;
}
@@ -1074,7 +1074,7 @@
CHECK(ret);
int Internal_is = !strncmp((const char*)getCameraSensorName(), "ISP Camera", 10);
- LOGV("Internal_is(%d), %s", Internal_is, (const char*)getCameraSensorName());
+ ALOGV("Internal_is(%d), %s", Internal_is, (const char*)getCameraSensorName());
if (Internal_is) {
if (!m_recording_en)
@@ -1104,10 +1104,10 @@
ret = v4l2_gsc_cap_reqbufs(m_gsc_vd_fd, V4L2_BUF_TYPE, MAX_BUFFERS);
CHECK(ret);
- LOGV("%s : m_preview_width: %d m_preview_height: %d m_angle: %d",
+ ALOGV("%s : m_preview_width: %d m_preview_height: %d m_angle: %d",
__func__, m_preview_width, m_preview_height, m_angle);
- LOGV("m_camera_id : %d", m_camera_id);
+ ALOGV("m_camera_id : %d", m_camera_id);
/* start with all buffers in queue */
for (int i = 0; i < MAX_BUFFERS; i++) {
@@ -1121,10 +1121,10 @@
m_flag_camera_start = 1;
/* TO DO : Frame Rate set is will be availeable.
if (setFrameRate(m_params->capture.timeperframe.denominator) < 0)
- LOGE("ERR(%s):Fail on setFrameRate(%d)",
+ ALOGE("ERR(%s):Fail on setFrameRate(%d)",
__func__, m_params->capture.timeperframe.denominator);
*/
- LOGV("%s: got the first frame of the preview", __func__);
+ ALOGV("%s: got the first frame of the preview", __func__);
return 0;
}
@@ -1133,10 +1133,10 @@
{
int ret;
- LOGV("%s :", __func__);
+ ALOGV("%s :", __func__);
if (m_flag_camera_start == 0) {
- LOGW("%s: doing nothing because m_flag_camera_start is zero", __func__);
+ ALOGW("%s: doing nothing because m_flag_camera_start is zero", __func__);
return 0;
}
@@ -1144,7 +1144,7 @@
setFlashMode(FLASH_MODE_OFF);
if (m_gsc_vd_fd <= 0) {
- LOGE("ERR(%s):Camera was closed", __func__);
+ ALOGE("ERR(%s):Camera was closed", __func__);
return -1;
}
@@ -1165,16 +1165,16 @@
{
int ret, i;
- LOGV("%s :", __func__);
+ ALOGV("%s :", __func__);
// aleady started
if (m_flag_record_start > 0) {
- LOGE("ERR(%s):Preview was already started", __func__);
+ ALOGE("ERR(%s):Preview was already started", __func__);
return 0;
}
if (m_cam_fd2 <= 0) {
- LOGE("ERR(%s):Camera was closed", __func__);
+ ALOGE("ERR(%s):Camera was closed", __func__);
return -1;
}
@@ -1182,11 +1182,11 @@
ret = v4l2_gsc_cap_enum_fmt(m_cam_fd2, RECORD_PIX_FMT);
CHECK(ret);
- LOGI("%s: m_recording_width = %d, m_recording_height = %d",
+ ALOGI("%s: m_recording_width = %d, m_recording_height = %d",
__func__, m_recording_width, m_recording_height);
int Internal_is = !strncmp((const char*)getCameraSensorName(), "ISP Camera", 10);
- LOGV("Internal_is(%d), %s", Internal_is, (const char*)getCameraSensorName());
+ ALOGV("Internal_is(%d), %s", Internal_is, (const char*)getCameraSensorName());
// if (Internal_is)
// v4l2_gsc_cap_s_fmt_is(m_cam_fd2, m_recording_width, m_recording_height, RECORD_PIX_FMT, (enum v4l2_field) IS_MODE_CAPTURE_VIDEO);
@@ -1221,15 +1221,15 @@
{
int ret;
- LOGV("%s :", __func__);
+ ALOGV("%s :", __func__);
if (m_flag_record_start == 0) {
- LOGW("%s: doing nothing because m_flag_record_start is zero", __func__);
+ ALOGW("%s: doing nothing because m_flag_record_start is zero", __func__);
return 0;
}
if (m_cam_fd2 <= 0) {
- LOGE("ERR(%s):Camera was closed", __func__);
+ ALOGE("ERR(%s):Camera was closed", __func__);
return -1;
}
@@ -1270,7 +1270,7 @@
m_buffers_record[index].virt.extP[0] = (char *)ptr;
m_buffers_record[index].virt.extP[1] = (char *)ptr + ((ALIGN(m_recording_width, 16) * ALIGN(m_recording_height, 16)));
} else
- LOGE("%s: Invalid fd!!!", __func__);
+ ALOGE("%s: Invalid fd!!!", __func__);
}
int SecCamera::getPreview()
@@ -1278,9 +1278,9 @@
int index;
int ret;
- LOGV("%s: ", __func__);
+ ALOGV("%s: ", __func__);
if (m_flag_camera_start == 0 || gsc_cap_poll(&m_events_c) == 0) {
- LOGE("ERR(%s):Start Camera Device Reset", __func__);
+ ALOGE("ERR(%s):Start Camera Device Reset", __func__);
/*
* When there is no data for more than 1 second from the camera we inform
* the FIMC driver by calling v4l2_gsc_cap_s_input() with a special value = 1000
@@ -1301,14 +1301,14 @@
return -1;
ret = startPreview();
if (ret < 0) {
- LOGE("ERR(%s): startPreview() return %d", __func__, ret);
+ ALOGE("ERR(%s): startPreview() return %d", __func__, ret);
return 0;
}
}
index = v4l2_gsc_cap_dqbuf(m_gsc_vd_fd, PREVIEW_NUM_PLANE);
if (!(0 <= index && index < MAX_BUFFERS)) {
- LOGE("ERR(%s):wrong index = %d", __func__, index);
+ ALOGE("ERR(%s):wrong index = %d", __func__, index);
return -1;
}
@@ -1327,14 +1327,14 @@
int SecCamera::getRecordFrame()
{
if (m_flag_record_start == 0) {
- LOGE("%s: m_flag_record_start is 0", __func__);
+ ALOGE("%s: m_flag_record_start is 0", __func__);
return -1;
}
gsc_cap_poll(&m_events_c2);
int index = v4l2_gsc_cap_dqbuf(m_cam_fd2, RECORD_NUM_PLANE);
if (!(0 <= index && index < MAX_BUFFERS)) {
- LOGE("ERR(%s):wrong index = %d", __func__, index);
+ ALOGE("ERR(%s):wrong index = %d", __func__, index);
return -1;
}
@@ -1350,7 +1350,7 @@
* cases where fimc could crash if we called qbuf and it
* wasn't expecting it.
*/
- LOGI("%s: recording not in progress, ignoring", __func__);
+ ALOGI("%s: recording not in progress, ignoring", __func__);
return 0;
}
@@ -1359,33 +1359,33 @@
int SecCamera::setPreviewSize(int width, int height, int pixel_format)
{
- LOGV("%s(width(%d), height(%d), format(%d))", __func__, width, height, pixel_format);
+ ALOGV("%s(width(%d), height(%d), format(%d))", __func__, width, height, pixel_format);
int v4lpixelformat = pixel_format;
-#if defined(LOG_NDEBUG) && LOG_NDEBUG == 0
+#if defined(ALOG_NDEBUG) && LOG_NDEBUG == 0
if (v4lpixelformat == V4L2_PIX_FMT_YUV420)
- LOGV("PreviewFormat:V4L2_PIX_FMT_YUV420");
+ ALOGV("PreviewFormat:V4L2_PIX_FMT_YUV420");
else if (v4lpixelformat == V4L2_PIX_FMT_YVU420)
- LOGV("PreviewFormat:V4L2_PIX_FMT_YVU420");
+ ALOGV("PreviewFormat:V4L2_PIX_FMT_YVU420");
else if (v4lpixelformat == V4L2_PIX_FMT_YVU420M)
- LOGV("PreviewFormat:V4L2_PIX_FMT_YVU420M");
+ ALOGV("PreviewFormat:V4L2_PIX_FMT_YVU420M");
else if (v4lpixelformat == V4L2_PIX_FMT_NV12)
- LOGV("PreviewFormat:V4L2_PIX_FMT_NV12");
+ ALOGV("PreviewFormat:V4L2_PIX_FMT_NV12");
else if (v4lpixelformat == V4L2_PIX_FMT_NV12M)
- LOGV("PreviewFormat:V4L2_PIX_FMT_NV12M");
+ ALOGV("PreviewFormat:V4L2_PIX_FMT_NV12M");
else if (v4lpixelformat == V4L2_PIX_FMT_NV12T)
- LOGV("PreviewFormat:V4L2_PIX_FMT_NV12T");
+ ALOGV("PreviewFormat:V4L2_PIX_FMT_NV12T");
else if (v4lpixelformat == V4L2_PIX_FMT_NV21)
- LOGV("PreviewFormat:V4L2_PIX_FMT_NV21");
+ ALOGV("PreviewFormat:V4L2_PIX_FMT_NV21");
else if (v4lpixelformat == V4L2_PIX_FMT_YUV422P)
- LOGV("PreviewFormat:V4L2_PIX_FMT_YUV422P");
+ ALOGV("PreviewFormat:V4L2_PIX_FMT_YUV422P");
else if (v4lpixelformat == V4L2_PIX_FMT_YUYV)
- LOGV("PreviewFormat:V4L2_PIX_FMT_YUYV");
+ ALOGV("PreviewFormat:V4L2_PIX_FMT_YUYV");
else if (v4lpixelformat == V4L2_PIX_FMT_RGB565)
- LOGV("PreviewFormat:V4L2_PIX_FMT_RGB565");
+ ALOGV("PreviewFormat:V4L2_PIX_FMT_RGB565");
else
- LOGV("PreviewFormat:UnknownFormat");
+ ALOGV("PreviewFormat:UnknownFormat");
#endif
m_preview_width = width;
m_preview_height = height;
@@ -1421,17 +1421,17 @@
*/
int SecCamera::setSnapshotCmd(void)
{
- LOGV("%s :", __func__);
+ ALOGV("%s :", __func__);
int ret = 0;
if (m_gsc_vd_fd <= 0) {
- LOGE("ERR(%s):Camera was closed", __func__);
+ ALOGE("ERR(%s):Camera was closed", __func__);
return 0;
}
if (m_flag_camera_start > 0) {
- LOGW("WARN(%s):Camera was in preview, should have been stopped", __func__);
+ ALOGW("WARN(%s):Camera was in preview, should have been stopped", __func__);
stopPreview();
}
@@ -1465,10 +1465,10 @@
{
int ret;
- LOGI("%s :", __func__);
+ ALOGI("%s :", __func__);
if (m_capture_buf.virt.extP[0]) {
munmap(m_capture_buf.virt.extP[0], m_capture_buf.size.extS[0]);
- LOGI("munmap():virt. addr %p size = %d",
+ ALOGI("munmap():virt. addr %p size = %d",
m_capture_buf.virt.extP[0], m_capture_buf.size.extS[0]);
m_capture_buf.virt.extP[0] = NULL;
m_capture_buf.size.extS[0] = 0;
@@ -1491,7 +1491,7 @@
index = v4l2_gsc_cap_dqbuf(m_gsc_vd_fd, 1);
if (index != 0) {
- LOGE("ERR(%s):wrong index = %d", __func__, index);
+ ALOGE("ERR(%s):wrong index = %d", __func__, index);
return NULL;
}
@@ -1505,7 +1505,7 @@
ret = v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_STREAM_PAUSE, 0);
CHECK_PTR(ret);
- LOGV("\nsnapshot dqueued buffer = %d snapshot_width = %d snapshot_height = %d, size = %d",
+ ALOGV("\nsnapshot dqueued buffer = %d snapshot_width = %d snapshot_height = %d, size = %d",
index, m_snapshot_width, m_snapshot_height, *jpeg_size);
addr = (unsigned char*)(m_capture_buf.virt.extP[0]) + main_offset;
@@ -1529,7 +1529,7 @@
*width = m_snapshot_width;
*height = m_snapshot_height;
*size = FRAME_SIZE(V4L2_PIX_2_HAL_PIXEL_FORMAT(m_snapshot_v4lformat), *width, *height);
- LOGV("[5B] m_preview_width : %d, mPostViewWidth = %d mPostViewHeight = %d mPostViewSize = %d",
+ ALOGV("[5B] m_preview_width : %d, mPostViewWidth = %d mPostViewHeight = %d mPostViewSize = %d",
m_preview_width, *width, *height, *size);
}
@@ -1548,19 +1548,19 @@
int SecCamera::getSnapshotAndJpeg(unsigned char *yuv_buf, unsigned char *jpeg_buf,
unsigned int *output_size)
{
- LOGV("%s :", __func__);
+ ALOGV("%s :", __func__);
int index;
unsigned char *addr;
int ret = 0;
if (m_gsc_vd_fd <= 0) {
- LOGE("ERR(%s):Camera was closed", __func__);
+ ALOGE("ERR(%s):Camera was closed", __func__);
return -1;
}
if (m_flag_camera_start > 0) {
- LOGW("WARN(%s):Camera was in preview, should have been stopped", __func__);
+ ALOGW("WARN(%s):Camera was in preview, should have been stopped", __func__);
stopPreview();
}
@@ -1568,25 +1568,25 @@
m_events_c.fd = m_gsc_vd_fd;
m_events_c.events = POLLIN | POLLERR;
-#if defined(LOG_NDEBUG) && LOG_NDEBUG == 0
+#if defined(ALOG_NDEBUG) && LOG_NDEBUG == 0
if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUV420)
- LOGV("SnapshotFormat:V4L2_PIX_FMT_YUV420");
+ ALOGV("SnapshotFormat:V4L2_PIX_FMT_YUV420");
else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV12)
- LOGV("SnapshotFormat:V4L2_PIX_FMT_NV12");
+ ALOGV("SnapshotFormat:V4L2_PIX_FMT_NV12");
else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV12T)
- LOGV("SnapshotFormat:V4L2_PIX_FMT_NV12T");
+ ALOGV("SnapshotFormat:V4L2_PIX_FMT_NV12T");
else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV21)
- LOGV("SnapshotFormat:V4L2_PIX_FMT_NV21");
+ ALOGV("SnapshotFormat:V4L2_PIX_FMT_NV21");
else if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUV422P)
- LOGV("SnapshotFormat:V4L2_PIX_FMT_YUV422P");
+ ALOGV("SnapshotFormat:V4L2_PIX_FMT_YUV422P");
else if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUYV)
- LOGV("SnapshotFormat:V4L2_PIX_FMT_YUYV");
+ ALOGV("SnapshotFormat:V4L2_PIX_FMT_YUYV");
else if (m_snapshot_v4lformat == V4L2_PIX_FMT_UYVY)
- LOGV("SnapshotFormat:V4L2_PIX_FMT_UYVY");
+ ALOGV("SnapshotFormat:V4L2_PIX_FMT_UYVY");
else if (m_snapshot_v4lformat == V4L2_PIX_FMT_RGB565)
- LOGV("SnapshotFormat:V4L2_PIX_FMT_RGB565");
+ ALOGV("SnapshotFormat:V4L2_PIX_FMT_RGB565");
else
- LOGV("SnapshotFormat:UnknownFormat");
+ ALOGV("SnapshotFormat:UnknownFormat");
#endif
int nframe = 1;
@@ -1595,7 +1595,7 @@
CHECK(ret);
int Internal_is = !strncmp((const char*)getCameraSensorName(), "ISP Camera", 10);
- LOGV("Internal_is(%d), %s", Internal_is, (const char*)getCameraSensorName());
+ ALOGV("Internal_is(%d), %s", Internal_is, (const char*)getCameraSensorName());
ret = v4l2_gsc_cap_s_fmt_cap(m_gsc_vd_fd, m_snapshot_width, m_snapshot_height, m_snapshot_v4lformat);
CHECK(ret);
@@ -1631,7 +1631,7 @@
#ifdef GAIA_FW_BETA
ret = v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_STREAM_PAUSE, 0);
CHECK_PTR(ret);
- LOGV("\nsnapshot dequeued buffer = %d snapshot_width = %d snapshot_height = %d",
+ ALOGV("\nsnapshot dequeued buffer = %d snapshot_width = %d snapshot_height = %d",
index, m_snapshot_width, m_snapshot_height);
yuv_buf = (unsigned char*)m_capture_buf.virt.extP[0];
@@ -1646,7 +1646,7 @@
int SecCamera::setSnapshotSize(int width, int height)
{
- LOGV("%s(width(%d), height(%d))", __func__, width, height);
+ ALOGV("%s(width(%d), height(%d))", __func__, width, height);
m_snapshot_width = width;
m_snapshot_height = height;
@@ -1701,25 +1701,25 @@
m_snapshot_v4lformat = v4lpixelformat;
}
-#if defined(LOG_NDEBUG) && LOG_NDEBUG == 0
+#if defined(ALOG_NDEBUG) && LOG_NDEBUG == 0
if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUV420)
- LOGE("%s : SnapshotFormat:V4L2_PIX_FMT_YUV420", __func__);
+ ALOGE("%s : SnapshotFormat:V4L2_PIX_FMT_YUV420", __func__);
else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV12)
- LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_NV12", __func__);
+ ALOGD("%s : SnapshotFormat:V4L2_PIX_FMT_NV12", __func__);
else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV12T)
- LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_NV12T", __func__);
+ ALOGD("%s : SnapshotFormat:V4L2_PIX_FMT_NV12T", __func__);
else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV21)
- LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_NV21", __func__);
+ ALOGD("%s : SnapshotFormat:V4L2_PIX_FMT_NV21", __func__);
else if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUV422P)
- LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_YUV422P", __func__);
+ ALOGD("%s : SnapshotFormat:V4L2_PIX_FMT_YUV422P", __func__);
else if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUYV)
- LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_YUYV", __func__);
+ ALOGD("%s : SnapshotFormat:V4L2_PIX_FMT_YUYV", __func__);
else if (m_snapshot_v4lformat == V4L2_PIX_FMT_UYVY)
- LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_UYVY", __func__);
+ ALOGD("%s : SnapshotFormat:V4L2_PIX_FMT_UYVY", __func__);
else if (m_snapshot_v4lformat == V4L2_PIX_FMT_RGB565)
- LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_RGB565", __func__);
+ ALOGD("%s : SnapshotFormat:V4L2_PIX_FMT_RGB565", __func__);
else
- LOGD("SnapshotFormat:UnknownFormat");
+ ALOGD("SnapshotFormat:UnknownFormat");
#endif
return 0;
}
@@ -1736,15 +1736,15 @@
int SecCamera::setAutofocus(void)
{
- LOGV("%s :", __func__);
+ ALOGV("%s :", __func__);
if (m_gsc_vd_fd <= 0) {
- LOGE("ERR(%s):Camera was closed", __func__);
+ ALOGE("ERR(%s):Camera was closed", __func__);
return -1;
}
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_CAMERA_SET_AUTO_FOCUS, AUTO_FOCUS_ON) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SET_AUTO_FOCUS", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SET_AUTO_FOCUS", __func__);
return -1;
}
@@ -1757,17 +1757,17 @@
af_result = v4l2_gsc_cap_g_ctrl(m_gsc_vd_fd, V4L2_CID_CAMERA_AUTO_FOCUS_RESULT);
- LOGV("%s : returning %d", __func__, af_result);
+ ALOGV("%s : returning %d", __func__, af_result);
return af_result;
}
int SecCamera::cancelAutofocus(void)
{
- LOGV("%s :", __func__);
+ ALOGV("%s :", __func__);
if (m_gsc_vd_fd <= 0) {
- LOGE("ERR(%s):Camera was closed", __func__);
+ ALOGE("ERR(%s):Camera was closed", __func__);
return -1;
}
@@ -1776,7 +1776,7 @@
int SecCamera::SetRotate(int angle)
{
- LOGE("%s(angle(%d))", __func__, angle);
+ ALOGE("%s(angle(%d))", __func__, angle);
if (m_angle != angle) {
switch (angle) {
@@ -1802,13 +1802,13 @@
break;
default:
- LOGE("ERR(%s):Invalid angle(%d)", __func__, angle);
+ ALOGE("ERR(%s):Invalid angle(%d)", __func__, angle);
return -1;
}
if (m_flag_camera_start) {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_ROTATION, angle) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_ROTATION", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_ROTATION", __func__);
return -1;
}
}
@@ -1819,21 +1819,21 @@
int SecCamera::getRotate(void)
{
- LOGV("%s : angle(%d)", __func__, m_angle);
+ ALOGV("%s : angle(%d)", __func__, m_angle);
return m_angle;
}
int SecCamera::setFrameRate(int frame_rate)
{
- LOGV("%s(FrameRate(%d))", __func__, frame_rate);
+ ALOGV("%s(FrameRate(%d))", __func__, frame_rate);
if (frame_rate < FRAME_RATE_AUTO || FRAME_RATE_MAX < frame_rate )
- LOGE("ERR(%s):Invalid frame_rate(%d)", __func__, frame_rate);
+ ALOGE("ERR(%s):Invalid frame_rate(%d)", __func__, frame_rate);
m_params->capture.timeperframe.denominator = frame_rate;
if (m_flag_camera_start) {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_CAMERA_FRAME_RATE, frame_rate) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FRAME_RATE", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FRAME_RATE", __func__);
return -1;
}
}
@@ -1843,15 +1843,15 @@
int SecCamera::setVerticalMirror(void)
{
- LOGV("%s :", __func__);
+ ALOGV("%s :", __func__);
if (m_gsc_vd_fd <= 0) {
- LOGE("ERR(%s):Camera was closed", __func__);
+ ALOGE("ERR(%s):Camera was closed", __func__);
return -1;
}
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_VFLIP, 0) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_VFLIP", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_VFLIP", __func__);
return -1;
}
@@ -1860,15 +1860,15 @@
int SecCamera::setHorizontalMirror(void)
{
- LOGV("%s :", __func__);
+ ALOGV("%s :", __func__);
if (m_gsc_vd_fd <= 0) {
- LOGE("ERR(%s):Camera was closed", __func__);
+ ALOGE("ERR(%s):Camera was closed", __func__);
return -1;
}
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_HFLIP, 0) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_HFLIP", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_HFLIP", __func__);
return -1;
}
@@ -1877,17 +1877,17 @@
int SecCamera::setWhiteBalance(int white_balance)
{
- LOGV("%s(white_balance(%d))", __func__, white_balance);
+ ALOGV("%s(white_balance(%d))", __func__, white_balance);
int Internal_is = !strncmp((const char*)getCameraSensorName(), "ISP Camera", 10);
if (Internal_is) {
if (white_balance < IS_AWB_AUTO || IS_AWB_MAX <= white_balance) {
- LOGE("ERR(%s):Invalid white_balance(%d)", __func__, white_balance);
+ ALOGE("ERR(%s):Invalid white_balance(%d)", __func__, white_balance);
return -1;
}
} else {
if (white_balance <= WHITE_BALANCE_BASE || WHITE_BALANCE_MAX <= white_balance) {
- LOGE("ERR(%s):Invalid white_balance(%d)", __func__, white_balance);
+ ALOGE("ERR(%s):Invalid white_balance(%d)", __func__, white_balance);
return -1;
}
}
@@ -1897,12 +1897,12 @@
if (m_flag_camera_start) {
if (Internal_is) {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_IS_CAMERA_AWB_MODE, white_balance) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_IS_CAMERA_AWB_MODE", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_IS_CAMERA_AWB_MODE", __func__);
return -1;
}
} else {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_CAMERA_WHITE_BALANCE, white_balance) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_WHITE_BALANCE", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_WHITE_BALANCE", __func__);
return -1;
}
}
@@ -1914,23 +1914,23 @@
int SecCamera::getWhiteBalance(void)
{
- LOGV("%s : white_balance(%d)", __func__, m_params->white_balance);
+ ALOGV("%s : white_balance(%d)", __func__, m_params->white_balance);
return m_params->white_balance;
}
int SecCamera::setBrightness(int brightness)
{
- LOGV("%s(brightness(%d))", __func__, brightness);
+ ALOGV("%s(brightness(%d))", __func__, brightness);
int Internal_is = !strncmp((const char*)getCameraSensorName(), "ISP Camera", 10);
if (Internal_is) {
brightness += IS_BRIGHTNESS_DEFAULT;
if (brightness < IS_BRIGHTNESS_MINUS_2 || IS_BRIGHTNESS_PLUS2 < brightness) {
- LOGE("ERR(%s):Invalid brightness(%d)", __func__, brightness);
+ ALOGE("ERR(%s):Invalid brightness(%d)", __func__, brightness);
return -1;
}
} else {
- LOGW("WARN(%s):Not supported brightness setting", __func__);
+ ALOGW("WARN(%s):Not supported brightness setting", __func__);
return 0;
}
@@ -1938,7 +1938,7 @@
m_params->brightness = brightness;
if (m_flag_camera_start) {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_IS_CAMERA_BRIGHTNESS, brightness) < EV_MINUS_4) {
- LOGE("ERR(%s):Fail on V4L2_CID_IS_CAMERA_BRIGHTNESS", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_IS_CAMERA_BRIGHTNESS", __func__);
return -1;
}
}
@@ -1949,25 +1949,25 @@
int SecCamera::getBrightness(void)
{
- LOGV("%s : brightness(%d)", __func__, m_params->brightness);
+ ALOGV("%s : brightness(%d)", __func__, m_params->brightness);
return m_params->brightness;
}
int SecCamera::setExposure(int exposure)
{
- LOGV("%s(exposure(%d))", __func__, exposure);
+ ALOGV("%s(exposure(%d))", __func__, exposure);
int Internal_is = !strncmp((const char*)getCameraSensorName(), "ISP Camera", 10);
if (Internal_is) {
exposure += IS_EXPOSURE_DEFAULT;
if (exposure < IS_EXPOSURE_MINUS_2 || IS_EXPOSURE_PLUS2 < exposure) {
- LOGE("ERR(%s):Invalid exposure(%d)", __func__, exposure);
+ ALOGE("ERR(%s):Invalid exposure(%d)", __func__, exposure);
return -1;
}
} else {
exposure += EV_DEFAULT;
if (exposure < EV_MINUS_4 || EV_PLUS_4 < exposure) {
- LOGE("ERR(%s):Invalid exposure(%d)", __func__, exposure);
+ ALOGE("ERR(%s):Invalid exposure(%d)", __func__, exposure);
return -1;
}
}
@@ -1977,12 +1977,12 @@
if (m_flag_camera_start) {
if (Internal_is) {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_IS_CAMERA_EXPOSURE, exposure) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_IS_CAMERA_EXPOSURE", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_IS_CAMERA_EXPOSURE", __func__);
return -1;
}
} else {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_CAMERA_BRIGHTNESS, exposure) < EV_MINUS_4) {
- LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_BRIGHTNESS", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_BRIGHTNESS", __func__);
return -1;
}
}
@@ -1994,23 +1994,23 @@
int SecCamera::getExposure(void)
{
- LOGV("%s : exposure(%d)", __func__, m_params->exposure);
+ ALOGV("%s : exposure(%d)", __func__, m_params->exposure);
return m_params->exposure;
}
int SecCamera::setImageEffect(int image_effect)
{
- LOGV("%s(image_effect(%d))", __func__, image_effect);
+ ALOGV("%s(image_effect(%d))", __func__, image_effect);
int Internal_is = !strncmp((const char*)getCameraSensorName(), "ISP Camera", 10);
if (Internal_is) {
if (image_effect < IS_IMAGE_EFFECT_DISABLE || IS_IMAGE_EFFECT_MAX <= image_effect) {
- LOGE("ERR(%s):Invalid image_effect(%d)", __func__, image_effect);
+ ALOGE("ERR(%s):Invalid image_effect(%d)", __func__, image_effect);
return -1;
}
} else {
if (image_effect <= IMAGE_EFFECT_BASE || IMAGE_EFFECT_MAX <= image_effect) {
- LOGE("ERR(%s):Invalid image_effect(%d)", __func__, image_effect);
+ ALOGE("ERR(%s):Invalid image_effect(%d)", __func__, image_effect);
return -1;
}
}
@@ -2020,12 +2020,12 @@
if (m_flag_camera_start) {
if (Internal_is) {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_IS_CAMERA_IMAGE_EFFECT, image_effect) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_IS_CAMERA_IMAGE_EFFECT", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_IS_CAMERA_IMAGE_EFFECT", __func__);
return -1;
}
} else {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_CAMERA_EFFECT, image_effect) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_EFFECT", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_EFFECT", __func__);
return -1;
}
}
@@ -2037,23 +2037,23 @@
int SecCamera::getImageEffect(void)
{
- LOGV("%s : image_effect(%d)", __func__, m_params->effects);
+ ALOGV("%s : image_effect(%d)", __func__, m_params->effects);
return m_params->effects;
}
int SecCamera::setAntiBanding(int anti_banding)
{
- LOGV("%s(anti_banding(%d))", __func__, anti_banding);
+ ALOGV("%s(anti_banding(%d))", __func__, anti_banding);
int Internal_is = !strncmp((const char*)getCameraSensorName(), "ISP Camera", 10);
if (Internal_is) {
if (anti_banding < IS_AFC_DISABLE || IS_AFC_MAX <= anti_banding) {
- LOGE("ERR(%s):Invalid anti_banding (%d)", __func__, anti_banding);
+ ALOGE("ERR(%s):Invalid anti_banding (%d)", __func__, anti_banding);
return -1;
}
} else {
if (anti_banding < ANTI_BANDING_AUTO || ANTI_BANDING_OFF < anti_banding) {
- LOGE("ERR(%s):Invalid anti_banding (%d)", __func__, anti_banding);
+ ALOGE("ERR(%s):Invalid anti_banding (%d)", __func__, anti_banding);
return -1;
}
}
@@ -2063,12 +2063,12 @@
if (m_flag_camera_start) {
if (Internal_is) {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_IS_CAMERA_AFC_MODE, anti_banding) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_IS_CAMERA_AFC_MODE", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_IS_CAMERA_AFC_MODE", __func__);
return -1;
}
} else {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_CAMERA_ANTI_BANDING, anti_banding) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_ANTI_BANDING", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_ANTI_BANDING", __func__);
return -1;
}
}
@@ -2080,10 +2080,10 @@
int SecCamera::setSceneMode(int scene_mode)
{
- LOGV("%s(scene_mode(%d))", __func__, scene_mode);
+ ALOGV("%s(scene_mode(%d))", __func__, scene_mode);
if (scene_mode <= SCENE_MODE_BASE || SCENE_MODE_MAX <= scene_mode) {
- LOGE("ERR(%s):Invalid scene_mode (%d)", __func__, scene_mode);
+ ALOGE("ERR(%s):Invalid scene_mode (%d)", __func__, scene_mode);
return -1;
}
@@ -2091,7 +2091,7 @@
m_params->scene_mode = scene_mode;
if (m_flag_camera_start) {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_CAMERA_SCENE_MODE, scene_mode) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SCENE_MODE", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SCENE_MODE", __func__);
return -1;
}
}
@@ -2107,17 +2107,17 @@
int SecCamera::setFlashMode(int flash_mode)
{
- LOGV("%s(flash_mode(%d))", __func__, flash_mode);
+ ALOGV("%s(flash_mode(%d))", __func__, flash_mode);
int Internal_is = !strncmp((const char*)getCameraSensorName(), "ISP Camera", 10);
if (Internal_is) {
if (flash_mode <= IS_FLASH_MODE_OFF || IS_FLASH_MODE_MAX <= flash_mode) {
- LOGE("ERR(%s):Invalid flash_mode (%d)", __func__, flash_mode);
+ ALOGE("ERR(%s):Invalid flash_mode (%d)", __func__, flash_mode);
return -1;
}
} else {
if (flash_mode <= FLASH_MODE_BASE || FLASH_MODE_MAX <= flash_mode) {
- LOGE("ERR(%s):Invalid flash_mode (%d)", __func__, flash_mode);
+ ALOGE("ERR(%s):Invalid flash_mode (%d)", __func__, flash_mode);
return -1;
}
}
@@ -2127,12 +2127,12 @@
if (m_flag_camera_start) {
if (Internal_is) {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_IS_CAMERA_FLASH_MODE, flash_mode) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_IS_CAMERA_FLASH_MODE", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_IS_CAMERA_FLASH_MODE", __func__);
return -1;
}
} else {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_CAMERA_FLASH_MODE, flash_mode) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FLASH_MODE", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FLASH_MODE", __func__);
return -1;
}
}
@@ -2149,17 +2149,17 @@
int SecCamera::setISO(int iso_value)
{
- LOGV("%s(iso_value(%d))", __func__, iso_value);
+ ALOGV("%s(iso_value(%d))", __func__, iso_value);
int Internal_is = !strncmp((const char*)getCameraSensorName(), "ISP Camera", 10);
if (Internal_is) {
if (iso_value < IS_ISO_AUTO || IS_ISO_MAX <= iso_value) {
- LOGE("ERR(%s):Invalid iso_value (%d)", __func__, iso_value);
+ ALOGE("ERR(%s):Invalid iso_value (%d)", __func__, iso_value);
return -1;
}
} else {
if (iso_value < ISO_AUTO || ISO_MAX <= iso_value) {
- LOGE("ERR(%s):Invalid iso_value (%d)", __func__, iso_value);
+ ALOGE("ERR(%s):Invalid iso_value (%d)", __func__, iso_value);
return -1;
}
}
@@ -2169,12 +2169,12 @@
if (m_flag_camera_start) {
if (Internal_is) {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_IS_CAMERA_ISO, iso_value) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_IS_CAMERA_ISO", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_IS_CAMERA_ISO", __func__);
return -1;
}
} else {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_CAMERA_ISO, iso_value) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_ISO", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_ISO", __func__);
return -1;
}
}
@@ -2191,17 +2191,17 @@
int SecCamera::setContrast(int contrast_value)
{
- LOGV("%s(contrast_value(%d))", __func__, contrast_value);
+ ALOGV("%s(contrast_value(%d))", __func__, contrast_value);
int Internal_is = !strncmp((const char*)getCameraSensorName(), "ISP Camera", 10);
if (Internal_is) {
if (contrast_value < IS_CONTRAST_AUTO || IS_CONTRAST_MAX <= contrast_value) {
- LOGE("ERR(%s):Invalid contrast_value (%d)", __func__, contrast_value);
+ ALOGE("ERR(%s):Invalid contrast_value (%d)", __func__, contrast_value);
return -1;
}
} else {
if (contrast_value < CONTRAST_MINUS_2 || CONTRAST_MAX <= contrast_value) {
- LOGE("ERR(%s):Invalid contrast_value (%d)", __func__, contrast_value);
+ ALOGE("ERR(%s):Invalid contrast_value (%d)", __func__, contrast_value);
return -1;
}
}
@@ -2211,12 +2211,12 @@
if (m_flag_camera_start) {
if (Internal_is) {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_IS_CAMERA_CONTRAST, contrast_value) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_IS_CAMERA_CONTRAST", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_IS_CAMERA_CONTRAST", __func__);
return -1;
}
} else {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_CAMERA_CONTRAST, contrast_value) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_CONTRAST", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_CONTRAST", __func__);
return -1;
}
}
@@ -2233,19 +2233,19 @@
int SecCamera::setSaturation(int saturation_value)
{
- LOGV("%s(saturation_value(%d))", __func__, saturation_value);
+ ALOGV("%s(saturation_value(%d))", __func__, saturation_value);
int Internal_is = !strncmp((const char*)getCameraSensorName(), "ISP Camera", 10);
if (Internal_is) {
saturation_value += IS_SATURATION_DEFAULT;
if (saturation_value < IS_SATURATION_MINUS_2 || IS_SATURATION_MAX <= saturation_value) {
- LOGE("ERR(%s):Invalid saturation_value (%d)", __func__, saturation_value);
+ ALOGE("ERR(%s):Invalid saturation_value (%d)", __func__, saturation_value);
return -1;
}
} else {
saturation_value += SATURATION_DEFAULT;
if (saturation_value < SATURATION_MINUS_2 || SATURATION_MAX <= saturation_value) {
- LOGE("ERR(%s):Invalid saturation_value (%d)", __func__, saturation_value);
+ ALOGE("ERR(%s):Invalid saturation_value (%d)", __func__, saturation_value);
return -1;
}
}
@@ -2255,12 +2255,12 @@
if (m_flag_camera_start) {
if (Internal_is) {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_IS_CAMERA_SATURATION, saturation_value) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SATURATION", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SATURATION", __func__);
return -1;
}
} else {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_CAMERA_SATURATION, saturation_value) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SATURATION", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SATURATION", __func__);
return -1;
}
}
@@ -2277,19 +2277,19 @@
int SecCamera::setSharpness(int sharpness_value)
{
- LOGV("%s(sharpness_value(%d))", __func__, sharpness_value);
+ ALOGV("%s(sharpness_value(%d))", __func__, sharpness_value);
int Internal_is = !strncmp((const char*)getCameraSensorName(), "ISP Camera", 10);
if (Internal_is) {
sharpness_value += IS_SHARPNESS_DEFAULT;
if (sharpness_value < IS_SHARPNESS_MINUS_2 || IS_SHARPNESS_MAX <= sharpness_value) {
- LOGE("ERR(%s):Invalid sharpness_value (%d)", __func__, sharpness_value);
+ ALOGE("ERR(%s):Invalid sharpness_value (%d)", __func__, sharpness_value);
return -1;
}
} else {
sharpness_value += SHARPNESS_DEFAULT;
if (sharpness_value < SHARPNESS_MINUS_2 || SHARPNESS_MAX <= sharpness_value) {
- LOGE("ERR(%s):Invalid sharpness_value (%d)", __func__, sharpness_value);
+ ALOGE("ERR(%s):Invalid sharpness_value (%d)", __func__, sharpness_value);
return -1;
}
}
@@ -2299,12 +2299,12 @@
if (m_flag_camera_start) {
if (Internal_is) {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_IS_CAMERA_SHARPNESS, sharpness_value) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SHARPNESS", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SHARPNESS", __func__);
return -1;
}
} else {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_CAMERA_SHARPNESS, sharpness_value) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SHARPNESS", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SHARPNESS", __func__);
return -1;
}
}
@@ -2321,17 +2321,17 @@
int SecCamera::setHue(int hue_value)
{
- LOGV("%s(hue_value(%d))", __func__, hue_value);
+ ALOGV("%s(hue_value(%d))", __func__, hue_value);
int Internal_is = !strncmp((const char*)getCameraSensorName(), "ISP Camera", 10);
if (Internal_is) {
hue_value += IS_HUE_DEFAULT;
if (hue_value < IS_HUE_MINUS_2 || IS_HUE_MAX <= hue_value) {
- LOGE("ERR(%s):Invalid hue_value (%d)", __func__, hue_value);
+ ALOGE("ERR(%s):Invalid hue_value (%d)", __func__, hue_value);
return -1;
}
} else {
- LOGW("WARN(%s):Not supported hue setting", __func__);
+ ALOGW("WARN(%s):Not supported hue setting", __func__);
return 0;
}
@@ -2339,7 +2339,7 @@
m_params->hue = hue_value;
if (m_flag_camera_start) {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_IS_CAMERA_HUE, hue_value) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_HUE", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_HUE", __func__);
return -1;
}
}
@@ -2355,17 +2355,17 @@
int SecCamera::setWDR(int wdr_value)
{
- LOGV("%s(wdr_value(%d))", __func__, wdr_value);
+ ALOGV("%s(wdr_value(%d))", __func__, wdr_value);
int Internal_is = !strncmp((const char*)getCameraSensorName(), "ISP Camera", 10);
if (Internal_is) {
if (wdr_value < IS_DRC_BYPASS_DISABLE || IS_DRC_BYPASS_MAX <= wdr_value) {
- LOGE("ERR(%s):Invalid drc_value (%d)", __func__, wdr_value);
+ ALOGE("ERR(%s):Invalid drc_value (%d)", __func__, wdr_value);
return -1;
}
} else {
if (wdr_value < WDR_OFF || WDR_MAX <= wdr_value) {
- LOGE("ERR(%s):Invalid wdr_value (%d)", __func__, wdr_value);
+ ALOGE("ERR(%s):Invalid wdr_value (%d)", __func__, wdr_value);
return -1;
}
}
@@ -2375,12 +2375,12 @@
if (m_flag_camera_start) {
if (Internal_is) {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_IS_SET_DRC, wdr_value) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_IS_SET_DRC", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_IS_SET_DRC", __func__);
return -1;
}
} else {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_CAMERA_WDR, wdr_value) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_WDR", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_WDR", __func__);
return -1;
}
}
@@ -2397,10 +2397,10 @@
int SecCamera::setAntiShake(int anti_shake)
{
- LOGV("%s(anti_shake(%d))", __func__, anti_shake);
+ ALOGV("%s(anti_shake(%d))", __func__, anti_shake);
if (anti_shake < ANTI_SHAKE_OFF || ANTI_SHAKE_MAX <= anti_shake) {
- LOGE("ERR(%s):Invalid anti_shake (%d)", __func__, anti_shake);
+ ALOGE("ERR(%s):Invalid anti_shake (%d)", __func__, anti_shake);
return -1;
}
@@ -2408,7 +2408,7 @@
m_anti_shake = anti_shake;
if (m_flag_camera_start) {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_CAMERA_ANTI_SHAKE, anti_shake) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_ANTI_SHAKE", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_ANTI_SHAKE", __func__);
return -1;
}
}
@@ -2424,17 +2424,17 @@
int SecCamera::setMetering(int metering_value)
{
- LOGV("%s(metering (%d))", __func__, metering_value);
+ ALOGV("%s(metering (%d))", __func__, metering_value);
int Internal_is = !strncmp((const char*)getCameraSensorName(), "ISP Camera", 10);
if (Internal_is) {
if (metering_value < IS_METERING_AVERAGE || IS_METERING_MAX <= metering_value) {
- LOGE("ERR(%s):Invalid metering_value (%d)", __func__, metering_value);
+ ALOGE("ERR(%s):Invalid metering_value (%d)", __func__, metering_value);
return -1;
}
} else {
if (metering_value <= METERING_BASE || METERING_MAX <= metering_value) {
- LOGE("ERR(%s):Invalid metering_value (%d)", __func__, metering_value);
+ ALOGE("ERR(%s):Invalid metering_value (%d)", __func__, metering_value);
return -1;
}
}
@@ -2444,12 +2444,12 @@
if (m_flag_camera_start) {
if (Internal_is) {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_IS_CAMERA_METERING, metering_value) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_IS_CAMERA_METERING", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_IS_CAMERA_METERING", __func__);
return -1;
}
} else {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_CAMERA_METERING, metering_value) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_METERING", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_METERING", __func__);
return -1;
}
}
@@ -2466,10 +2466,10 @@
int SecCamera::setJpegQuality(int jpeg_quality)
{
- LOGV("%s(jpeg_quality (%d))", __func__, jpeg_quality);
+ ALOGV("%s(jpeg_quality (%d))", __func__, jpeg_quality);
if (jpeg_quality < JPEG_QUALITY_ECONOMY || JPEG_QUALITY_MAX <= jpeg_quality) {
- LOGE("ERR(%s):Invalid jpeg_quality (%d)", __func__, jpeg_quality);
+ ALOGE("ERR(%s):Invalid jpeg_quality (%d)", __func__, jpeg_quality);
return -1;
}
@@ -2478,7 +2478,7 @@
#ifdef JPEG_FROM_SENSOR
if (m_flag_camera_start && (m_camera_id == CAMERA_ID_BACK)) {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_CAM_JPEG_QUALITY, jpeg_quality) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_CAM_JPEG_QUALITY", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_CAM_JPEG_QUALITY", __func__);
return -1;
}
}
@@ -2495,10 +2495,10 @@
int SecCamera::setZoom(int zoom_level)
{
- LOGV("%s(zoom_level (%d))", __func__, zoom_level);
+ ALOGV("%s(zoom_level (%d))", __func__, zoom_level);
if (zoom_level < ZOOM_LEVEL_0 || ZOOM_LEVEL_MAX <= zoom_level) {
- LOGE("ERR(%s):Invalid zoom_level (%d)", __func__, zoom_level);
+ ALOGE("ERR(%s):Invalid zoom_level (%d)", __func__, zoom_level);
return -1;
}
@@ -2506,7 +2506,7 @@
m_zoom_level = zoom_level;
if (m_flag_camera_start) {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_CAMERA_ZOOM, zoom_level) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_ZOOM", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_ZOOM", __func__);
return -1;
}
}
@@ -2522,10 +2522,10 @@
int SecCamera::setObjectTracking(int object_tracking)
{
- LOGV("%s(object_tracking (%d))", __func__, object_tracking);
+ ALOGV("%s(object_tracking (%d))", __func__, object_tracking);
if (object_tracking < OBJECT_TRACKING_OFF || OBJECT_TRACKING_MAX <= object_tracking) {
- LOGE("ERR(%s):Invalid object_tracking (%d)", __func__, object_tracking);
+ ALOGE("ERR(%s):Invalid object_tracking (%d)", __func__, object_tracking);
return -1;
}
@@ -2549,12 +2549,12 @@
int SecCamera::setObjectTrackingStartStop(int start_stop)
{
- LOGV("%s(object_tracking_start_stop (%d))", __func__, start_stop);
+ ALOGV("%s(object_tracking_start_stop (%d))", __func__, start_stop);
if (m_object_tracking_start_stop != start_stop) {
m_object_tracking_start_stop = start_stop;
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_CAMERA_OBJ_TRACKING_START_STOP, start_stop) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_OBJ_TRACKING_START_STOP", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_OBJ_TRACKING_START_STOP", __func__);
return -1;
}
}
@@ -2564,12 +2564,12 @@
int SecCamera::setTouchAFStartStop(int start_stop)
{
- LOGV("%s(touch_af_start_stop (%d))", __func__, start_stop);
+ ALOGV("%s(touch_af_start_stop (%d))", __func__, start_stop);
if (m_touch_af_start_stop != start_stop) {
m_touch_af_start_stop = start_stop;
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_CAMERA_TOUCH_AF_START_STOP, start_stop) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_TOUCH_AF_START_STOP", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_TOUCH_AF_START_STOP", __func__);
return -1;
}
}
@@ -2579,10 +2579,10 @@
int SecCamera::setSmartAuto(int smart_auto)
{
- LOGV("%s(smart_auto (%d))", __func__, smart_auto);
+ ALOGV("%s(smart_auto (%d))", __func__, smart_auto);
if (smart_auto < SMART_AUTO_OFF || SMART_AUTO_MAX <= smart_auto) {
- LOGE("ERR(%s):Invalid smart_auto (%d)", __func__, smart_auto);
+ ALOGE("ERR(%s):Invalid smart_auto (%d)", __func__, smart_auto);
return -1;
}
@@ -2590,7 +2590,7 @@
m_smart_auto = smart_auto;
if (m_flag_camera_start) {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_CAMERA_SMART_AUTO, smart_auto) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SMART_AUTO", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SMART_AUTO", __func__);
return -1;
}
}
@@ -2612,7 +2612,7 @@
autoscene_status = v4l2_gsc_cap_g_ctrl(m_gsc_vd_fd, V4L2_CID_CAMERA_SMART_AUTO_STATUS);
if ((autoscene_status < SMART_AUTO_STATUS_AUTO) || (autoscene_status > SMART_AUTO_STATUS_MAX)) {
- LOGE("ERR(%s):Invalid getAutosceneStatus (%d)", __func__, autoscene_status);
+ ALOGE("ERR(%s):Invalid getAutosceneStatus (%d)", __func__, autoscene_status);
return -1;
}
}
@@ -2621,10 +2621,10 @@
int SecCamera::setBeautyShot(int beauty_shot)
{
- LOGV("%s(beauty_shot (%d))", __func__, beauty_shot);
+ ALOGV("%s(beauty_shot (%d))", __func__, beauty_shot);
if (beauty_shot < BEAUTY_SHOT_OFF || BEAUTY_SHOT_MAX <= beauty_shot) {
- LOGE("ERR(%s):Invalid beauty_shot (%d)", __func__, beauty_shot);
+ ALOGE("ERR(%s):Invalid beauty_shot (%d)", __func__, beauty_shot);
return -1;
}
@@ -2632,7 +2632,7 @@
m_beauty_shot = beauty_shot;
if (m_flag_camera_start) {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_CAMERA_BEAUTY_SHOT, beauty_shot) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_BEAUTY_SHOT", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_BEAUTY_SHOT", __func__);
return -1;
}
}
@@ -2650,10 +2650,10 @@
int SecCamera::setVintageMode(int vintage_mode)
{
- LOGV("%s(vintage_mode(%d))", __func__, vintage_mode);
+ ALOGV("%s(vintage_mode(%d))", __func__, vintage_mode);
if (vintage_mode <= VINTAGE_MODE_BASE || VINTAGE_MODE_MAX <= vintage_mode) {
- LOGE("ERR(%s):Invalid vintage_mode (%d)", __func__, vintage_mode);
+ ALOGE("ERR(%s):Invalid vintage_mode (%d)", __func__, vintage_mode);
return -1;
}
@@ -2661,7 +2661,7 @@
m_vintage_mode = vintage_mode;
if (m_flag_camera_start) {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_CAMERA_VINTAGE_MODE, vintage_mode) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_VINTAGE_MODE", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_VINTAGE_MODE", __func__);
return -1;
}
}
@@ -2677,17 +2677,17 @@
int SecCamera::setFocusMode(int focus_mode)
{
- LOGV("%s(focus_mode(%d))", __func__, focus_mode);
+ ALOGV("%s(focus_mode(%d))", __func__, focus_mode);
int Internal_is = !strncmp((const char*)getCameraSensorName(), "ISP Camera", 10);
if (Internal_is) {
if (IS_FOCUS_MODE_MAX <= focus_mode) {
- LOGE("ERR(%s):Invalid focus_mode (%d)", __func__, focus_mode);
+ ALOGE("ERR(%s):Invalid focus_mode (%d)", __func__, focus_mode);
return -1;
}
} else {
if (FOCUS_MODE_MAX <= focus_mode) {
- LOGE("ERR(%s):Invalid focus_mode (%d)", __func__, focus_mode);
+ ALOGE("ERR(%s):Invalid focus_mode (%d)", __func__, focus_mode);
return -1;
}
}
@@ -2698,12 +2698,12 @@
if (m_flag_camera_start) {
if (Internal_is) {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_IS_CAMERA_FOCUS_MODE, focus_mode) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_IS_CAMERA_FOCUS_MODE", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_IS_CAMERA_FOCUS_MODE", __func__);
return -1;
}
} else {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_CAMERA_FOCUS_MODE, focus_mode) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FOCUS_MODE", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FOCUS_MODE", __func__);
return -1;
}
}
@@ -2721,7 +2721,7 @@
int SecCamera::setFaceDetect(int face_detect)
{
- LOGV("%s(face_detect(%d))", __func__, face_detect);
+ ALOGV("%s(face_detect(%d))", __func__, face_detect);
int Internal_is = !strncmp((const char*)getCameraSensorName(), "ISP Camera", 10);
if (m_face_detect != face_detect) {
@@ -2730,24 +2730,24 @@
if (m_face_detect != FACE_DETECTION_OFF) {
if (Internal_is) {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_IS_CAMERA_FOCUS_MODE, IS_FOCUS_MODE_AUTO) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_IS_CAMERA_FOCUS_MODin face detecion", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_IS_CAMERA_FOCUS_MODin face detecion", __func__);
return -1;
}
} else {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_CAMERA_FOCUS_MODE, FOCUS_MODE_AUTO) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FOCUS_MODin face detecion", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FOCUS_MODin face detecion", __func__);
return -1;
}
}
}
if (Internal_is) {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_IS_CMD_FD, face_detect) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_IS_CMD_FD", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_IS_CMD_FD", __func__);
return -1;
}
} else {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_CAMERA_FACE_DETECTION, face_detect) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FACE_DETECTION", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FACE_DETECTION", __func__);
return -1;
}
}
@@ -2765,7 +2765,7 @@
int SecCamera::setGPSLatitude(const char *gps_latitude)
{
double conveted_latitude = 0;
- LOGV("%s(gps_latitude(%s))", __func__, gps_latitude);
+ ALOGV("%s(gps_latitude(%s))", __func__, gps_latitude);
if (gps_latitude == NULL)
m_gps_latitude = 0;
else {
@@ -2773,14 +2773,14 @@
m_gps_latitude = (long)(conveted_latitude * 10000 / 1);
}
- LOGV("%s(m_gps_latitude(%ld))", __func__, m_gps_latitude);
+ ALOGV("%s(m_gps_latitude(%ld))", __func__, m_gps_latitude);
return 0;
}
int SecCamera::setGPSLongitude(const char *gps_longitude)
{
double conveted_longitude = 0;
- LOGV("%s(gps_longitude(%s))", __func__, gps_longitude);
+ ALOGV("%s(gps_longitude(%s))", __func__, gps_longitude);
if (gps_longitude == NULL)
m_gps_longitude = 0;
else {
@@ -2788,14 +2788,14 @@
m_gps_longitude = (long)(conveted_longitude * 10000 / 1);
}
- LOGV("%s(m_gps_longitude(%ld))", __func__, m_gps_longitude);
+ ALOGV("%s(m_gps_longitude(%ld))", __func__, m_gps_longitude);
return 0;
}
int SecCamera::setGPSAltitude(const char *gps_altitude)
{
double conveted_altitude = 0;
- LOGV("%s(gps_altitude(%s))", __func__, gps_altitude);
+ ALOGV("%s(gps_altitude(%s))", __func__, gps_altitude);
if (gps_altitude == NULL)
m_gps_altitude = 0;
else {
@@ -2803,25 +2803,25 @@
m_gps_altitude = (long)(conveted_altitude * 100 / 1);
}
- LOGV("%s(m_gps_altitude(%ld))", __func__, m_gps_altitude);
+ ALOGV("%s(m_gps_altitude(%ld))", __func__, m_gps_altitude);
return 0;
}
int SecCamera::setGPSTimeStamp(const char *gps_timestamp)
{
- LOGV("%s(gps_timestamp(%s))", __func__, gps_timestamp);
+ ALOGV("%s(gps_timestamp(%s))", __func__, gps_timestamp);
if (gps_timestamp == NULL)
m_gps_timestamp = 0;
else
m_gps_timestamp = atol(gps_timestamp);
- LOGV("%s(m_gps_timestamp(%ld))", __func__, m_gps_timestamp);
+ ALOGV("%s(m_gps_timestamp(%ld))", __func__, m_gps_timestamp);
return 0;
}
int SecCamera::setGPSProcessingMethod(const char *gps_processing_method)
{
- LOGV("%s(gps_processing_method(%s))", __func__, gps_processing_method);
+ ALOGV("%s(gps_processing_method(%s))", __func__, gps_processing_method);
memset(mExifInfo.gps_processing_method, 0, sizeof(mExifInfo.gps_processing_method));
if (gps_processing_method != NULL) {
size_t len = strlen(gps_processing_method);
@@ -2835,10 +2835,10 @@
int SecCamera::setFaceDetectLockUnlock(int facedetect_lockunlock)
{
- LOGV("%s(facedetect_lockunlock(%d))", __func__, facedetect_lockunlock);
+ ALOGV("%s(facedetect_lockunlock(%d))", __func__, facedetect_lockunlock);
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_CAMERA_FACEDETECT_LOCKUNLOCK, facedetect_lockunlock) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FACEDETECT_LOCKUNLOCK", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FACEDETECT_LOCKUNLOCK", __func__);
return -1;
}
@@ -2847,18 +2847,18 @@
int SecCamera::setObjectPosition(int x, int y)
{
- LOGV("%s(setObjectPosition(x=%d, y=%d))", __func__, x, y);
+ ALOGV("%s(setObjectPosition(x=%d, y=%d))", __func__, x, y);
if (m_preview_width ==640)
x = x - 80;
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_CAMERA_OBJECT_POSITION_X, x) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_OBJECT_POSITION_X", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_OBJECT_POSITION_X", __func__);
return -1;
}
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_CAMERA_OBJECT_POSITION_Y, y) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_OBJECT_POSITION_Y", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_OBJECT_POSITION_Y", __func__);
return -1;
}
@@ -2867,10 +2867,10 @@
int SecCamera::setGamma(int gamma)
{
- LOGV("%s(gamma(%d))", __func__, gamma);
+ ALOGV("%s(gamma(%d))", __func__, gamma);
if (gamma < GAMMA_OFF || GAMMA_MAX <= gamma) {
- LOGE("ERR(%s):Invalid gamma (%d)", __func__, gamma);
+ ALOGE("ERR(%s):Invalid gamma (%d)", __func__, gamma);
return -1;
}
@@ -2878,7 +2878,7 @@
m_video_gamma = gamma;
if (m_flag_camera_start) {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_CAMERA_SET_GAMMA, gamma) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SET_GAMMA", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SET_GAMMA", __func__);
return -1;
}
}
@@ -2889,10 +2889,10 @@
int SecCamera::setSlowAE(int slow_ae)
{
- LOGV("%s(slow_ae(%d))", __func__, slow_ae);
+ ALOGV("%s(slow_ae(%d))", __func__, slow_ae);
if (slow_ae < GAMMA_OFF || GAMMA_MAX <= slow_ae) {
- LOGE("ERR(%s):Invalid slow_ae (%d)", __func__, slow_ae);
+ ALOGE("ERR(%s):Invalid slow_ae (%d)", __func__, slow_ae);
return -1;
}
@@ -2900,7 +2900,7 @@
m_slow_ae = slow_ae;
if (m_flag_camera_start) {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_CAMERA_SET_SLOW_AE, slow_ae) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SET_SLOW_AE", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SET_SLOW_AE", __func__);
return -1;
}
}
@@ -2911,7 +2911,7 @@
int SecCamera::setRecording(int recording_en)
{
- LOGV("%s(recoding_en(%d))", __func__, recording_en);
+ ALOGV("%s(recoding_en(%d))", __func__, recording_en);
m_recording_en = recording_en;
@@ -2920,7 +2920,7 @@
int SecCamera::setRecordingSize(int width, int height)
{
- LOGV("%s(width(%d), height(%d))", __func__, width, height);
+ ALOGV("%s(width(%d), height(%d))", __func__, width, height);
m_recording_width = width;
m_recording_height = height;
@@ -2938,10 +2938,10 @@
int SecCamera::setExifOrientationInfo(int orientationInfo)
{
- LOGV("%s(orientationInfo(%d))", __func__, orientationInfo);
+ ALOGV("%s(orientationInfo(%d))", __func__, orientationInfo);
if (orientationInfo < 0) {
- LOGE("ERR(%s):Invalid orientationInfo (%d)", __func__, orientationInfo);
+ ALOGE("ERR(%s):Invalid orientationInfo (%d)", __func__, orientationInfo);
return -1;
}
m_exif_orientation = orientationInfo;
@@ -2953,7 +2953,7 @@
{
if (m_flag_camera_start) {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_CAMERA_BATCH_REFLECTION, 1) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_BATCH_REFLECTION", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_BATCH_REFLECTION", __func__);
return -1;
}
}
@@ -2964,10 +2964,10 @@
/* Camcorder fix fps */
int SecCamera::setSensorMode(int sensor_mode)
{
- LOGV("%s(sensor_mode (%d))", __func__, sensor_mode);
+ ALOGV("%s(sensor_mode (%d))", __func__, sensor_mode);
if (sensor_mode < SENSOR_MODE_CAMERA || SENSOR_MODE_MOVIE < sensor_mode) {
- LOGE("ERR(%s):Invalid sensor mode (%d)", __func__, sensor_mode);
+ ALOGE("ERR(%s):Invalid sensor mode (%d)", __func__, sensor_mode);
return -1;
}
@@ -2986,9 +2986,9 @@
*/
int SecCamera::setShotMode(int shot_mode)
{
- LOGV("%s(shot_mode (%d))", __func__, shot_mode);
+ ALOGV("%s(shot_mode (%d))", __func__, shot_mode);
if (shot_mode < SHOT_MODE_SINGLE || SHOT_MODE_SELF < shot_mode) {
- LOGE("ERR(%s):Invalid shot_mode (%d)", __func__, shot_mode);
+ ALOGE("ERR(%s):Invalid shot_mode (%d)", __func__, shot_mode);
return -1;
}
m_shot_mode = shot_mode;
@@ -2998,10 +2998,10 @@
int SecCamera::setDataLineCheck(int chk_dataline)
{
- LOGV("%s(chk_dataline (%d))", __func__, chk_dataline);
+ ALOGV("%s(chk_dataline (%d))", __func__, chk_dataline);
if (chk_dataline < CHK_DATALINE_OFF || CHK_DATALINE_MAX <= chk_dataline) {
- LOGE("ERR(%s):Invalid chk_dataline (%d)", __func__, chk_dataline);
+ ALOGE("ERR(%s):Invalid chk_dataline (%d)", __func__, chk_dataline);
return -1;
}
@@ -3017,11 +3017,11 @@
int SecCamera::setDataLineCheckStop(void)
{
- LOGV("%s", __func__);
+ ALOGV("%s", __func__);
if (m_flag_camera_start) {
if (v4l2_gsc_cap_s_ctrl(m_gsc_vd_fd, V4L2_CID_CAMERA_CHECK_DATALINE_STOP, 1) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_CHECK_DATALINE_STOP", __func__);
+ ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_CHECK_DATALINE_STOP", __func__);
return -1;
}
}
@@ -3030,7 +3030,7 @@
const __u8* SecCamera::getCameraSensorName(void)
{
- LOGV("%s", __func__);
+ ALOGV("%s", __func__);
return v4l2_gsc_cap_enuminput(m_gsc_vd_fd, getCameraId());
}
@@ -3038,7 +3038,7 @@
#ifdef ENABLE_ESD_PREVIEW_CHECK
int SecCamera::getCameraSensorESDStatus(void)
{
- LOGV("%s", __func__);
+ ALOGV("%s", __func__);
// 0 : normal operation, 1 : abnormal operation
int status = v4l2_gsc_cap_g_ctrl(m_gsc_vd_fd, V4L2_CID_ESD_INT);
@@ -3049,7 +3049,7 @@
int SecCamera::setJpegThumbnailSize(int width, int height)
{
- LOGV("%s(width(%d), height(%d))", __func__, width, height);
+ ALOGV("%s(width(%d), height(%d))", __func__, width, height);
m_jpeg_thumbnail_width = width;
m_jpeg_thumbnail_height = height;
@@ -3069,10 +3069,10 @@
int SecCamera::setJpegThumbnailQuality(int jpeg_thumbnail_quality)
{
- LOGV("%s(jpeg_thumbnail_quality (%d))", __func__, jpeg_thumbnail_quality);
+ ALOGV("%s(jpeg_thumbnail_quality (%d))", __func__, jpeg_thumbnail_quality);
if (jpeg_thumbnail_quality < JPEG_QUALITY_ECONOMY || JPEG_QUALITY_MAX <= jpeg_thumbnail_quality) {
- LOGE("ERR(%s):Invalid jpeg_thumbnail_quality (%d)", __func__, jpeg_thumbnail_quality);
+ ALOGE("ERR(%s):Invalid jpeg_thumbnail_quality (%d)", __func__, jpeg_thumbnail_quality);
return -1;
}
@@ -3193,7 +3193,7 @@
it current returns a negative err value, so avoid putting
odd value into exif for now */
if (shutterSpeed < 0) {
- LOGE("%s: error %d getting shutterSpeed, camera_id = %d, using 100",
+ ALOGE("%s: error %d getting shutterSpeed, camera_id = %d, using 100",
__func__, shutterSpeed, m_camera_id);
shutterSpeed = 100;
}
@@ -3208,7 +3208,7 @@
it current returns a negative err value, so avoid putting
odd value into exif for now */
if (iso < 0) {
- LOGE("%s: error %d getting iso, camera_id = %d, using 100",
+ ALOGE("%s: error %d getting iso, camera_id = %d, using 100",
__func__, iso, m_camera_id);
iso = ISO_100;
}
@@ -3242,8 +3242,8 @@
sv = APEX_ISO_TO_FILMSENSITIVITY(mExifInfo.iso_speed_rating);
bv = av + tv - sv;
ev = av + tv;
- LOGD("Shutter speed=%d us, iso=%d", shutterSpeed, mExifInfo.iso_speed_rating);
- LOGD("AV=%d, TV=%d, SV=%d", av, tv, sv);
+ ALOGD("Shutter speed=%d us, iso=%d", shutterSpeed, mExifInfo.iso_speed_rating);
+ ALOGD("AV=%d, TV=%d, SV=%d", av, tv, sv);
//3 Shutter Speed
mExifInfo.shutter_speed.num = tv*EXIF_DEF_APEX_DEN;
@@ -3595,7 +3595,7 @@
unsigned char size_mm[2] = {(tmp >> 8) & 0xFF, tmp & 0xFF};
memcpy(pApp1Start, size_mm, 2);
- LOGD("makeExif X");
+ ALOGD("makeExif X");
return 0;
}
diff --git a/exynos5/hal/libcamera/SecCamera.h b/exynos5/hal/libcamera/SecCamera.h
index 1af19ee..300a214 100644
--- a/exynos5/hal/libcamera/SecCamera.h
+++ b/exynos5/hal/libcamera/SecCamera.h
@@ -59,9 +59,9 @@
//#define ENABLE_ESD_PREVIEW_CHECK
-#if defined(LOG_NDEBUG) && (LOG_NDEBUG == 0)
-#define LOG_CAMERA LOGD
-#define LOG_CAMERA_PREVIEW LOGD
+#if defined(ALOG_NDEBUG) && (ALOG_NDEBUG == 0)
+#define LOG_CAMERA ALOGD
+#define LOG_CAMERA_PREVIEW ALOGD
#define LOG_TIME_DEFINE(n) \
struct timeval time_start_##n, time_stop_##n; unsigned long log_time_##n = 0;
diff --git a/exynos5/hal/libcamera/SecCameraHWInterface.cpp b/exynos5/hal/libcamera/SecCameraHWInterface.cpp
index 8cfbccc..3609902 100644
--- a/exynos5/hal/libcamera/SecCameraHWInterface.cpp
+++ b/exynos5/hal/libcamera/SecCameraHWInterface.cpp
@@ -15,8 +15,8 @@
** See the License for the specific language governing permissions and
** limitations under the License.
*/
-//#define LOG_NDEBUG 0
-#define LOG_TAG "CameraHardwareSec"
+//#define ALOG_NDEBUG 0
+#define ALOG_TAG "CameraHardwareSec"
#include <utils/Log.h>
#include "SecCameraHWInterface.h"
@@ -24,7 +24,7 @@
#include <fcntl.h>
#include <sys/mman.h>
#include <camera/Camera.h>
-#include <media/stagefright/MetadataBufferType.h>
+#include <media/hardware/MetadataBufferType.h>
#define VIDEO_COMMENT_MARKER_H 0xFFBE
#define VIDEO_COMMENT_MARKER_L 0xFFBF
@@ -94,7 +94,7 @@
mPostViewSize(0),
mHalDevice(dev)
{
- LOGV("%s :", __func__);
+ ALOGV("%s :", __func__);
int ret = 0;
mPreviewWindow = NULL;
@@ -108,12 +108,12 @@
if (!mGrallocHal) {
ret = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, (const hw_module_t **)&mGrallocHal);
if (ret)
- LOGE("ERR(%s):Fail on loading gralloc HAL", __func__);
+ ALOGE("ERR(%s):Fail on loading gralloc HAL", __func__);
}
ret = mSecCamera->CreateCamera(cameraId);
if (ret < 0) {
- LOGE("ERR(%s):Fail on mSecCamera init", __func__);
+ ALOGE("ERR(%s):Fail on mSecCamera init", __func__);
mSecCamera->DestroyCamera();
}
@@ -139,7 +139,7 @@
void CameraHardwareSec::initDefaultParameters(int cameraId)
{
if (mSecCamera == NULL) {
- LOGE("ERR(%s):mSecCamera object is NULL", __func__);
+ ALOGE("ERR(%s):mSecCamera object is NULL", __func__);
return;
}
@@ -149,10 +149,10 @@
#ifndef GAIA_FW_BETA
mCameraSensorName = mSecCamera->getCameraSensorName();
if (mCameraSensorName == NULL) {
- LOGE("ERR(%s):mCameraSensorName is NULL", __func__);
+ ALOGE("ERR(%s):mCameraSensorName is NULL", __func__);
return;
}
- LOGV("CameraSensorName: %s", mCameraSensorName);
+ ALOGV("CameraSensorName: %s", mCameraSensorName);
int Internal_is = !strncmp((const char*)mCameraSensorName, "ISP Camera", 10);
#else
int Internal_is = 0;
@@ -187,11 +187,11 @@
// sizes at zero to catch the error.
if (mSecCamera->getPreviewMaxSize(&preview_max_width,
&preview_max_height) < 0)
- LOGE("getPreviewMaxSize fail (%d / %d)",
+ ALOGE("getPreviewMaxSize fail (%d / %d)",
preview_max_width, preview_max_height);
if (mSecCamera->getSnapshotMaxSize(&snapshot_max_width,
&snapshot_max_height) < 0)
- LOGE("getSnapshotMaxSize fail (%d / %d)",
+ ALOGE("getSnapshotMaxSize fail (%d / %d)",
snapshot_max_width, snapshot_max_height);
p.setPreviewFormat(CameraParameters::PIXEL_FORMAT_YUV420P); mFrameSizeDelta = 16;
@@ -383,7 +383,7 @@
CameraHardwareSec::~CameraHardwareSec()
{
- LOGV("%s", __func__);
+ ALOGV("%s", __func__);
mSecCamera->DestroyCamera();
}
@@ -392,33 +392,33 @@
int min_bufs;
mPreviewWindow = w;
- LOGV("%s: mPreviewWindow %p", __func__, mPreviewWindow);
+ ALOGV("%s: mPreviewWindow %p", __func__, mPreviewWindow);
if (!w) {
- LOGE("preview window is NULL!");
+ ALOGE("preview window is NULL!");
return OK;
}
mPreviewLock.lock();
if (mPreviewRunning && !mPreviewStartDeferred) {
- LOGI("stop preview (window change)");
+ ALOGI("stop preview (window change)");
stopPreviewInternal();
}
if (w->get_min_undequeued_buffer_count(w, &min_bufs)) {
- LOGE("%s: could not retrieve min undequeued buffer count", __func__);
+ ALOGE("%s: could not retrieve min undequeued buffer count", __func__);
return INVALID_OPERATION;
}
if (min_bufs >= BUFFER_COUNT_FOR_GRALLOC) {
- LOGE("%s: min undequeued buffer count %d is too high (expecting at most %d)", __func__,
+ ALOGE("%s: min undequeued buffer count %d is too high (expecting at most %d)", __func__,
min_bufs, BUFFER_COUNT_FOR_GRALLOC - 1);
}
- LOGV("%s: setting buffer count to %d", __func__, BUFFER_COUNT_FOR_GRALLOC);
+ ALOGV("%s: setting buffer count to %d", __func__, BUFFER_COUNT_FOR_GRALLOC);
if (w->set_buffer_count(w, BUFFER_COUNT_FOR_GRALLOC)) {
- LOGE("%s: could not set buffer count", __func__);
+ ALOGE("%s: could not set buffer count", __func__);
return INVALID_OPERATION;
}
@@ -429,7 +429,7 @@
int hal_pixel_format;
const char *str_preview_format = mParameters.getPreviewFormat();
- LOGV("%s: str preview format %s width : %d height : %d ", __func__, str_preview_format, preview_width, preview_height);
+ ALOGV("%s: str preview format %s width : %d height : %d ", __func__, str_preview_format, preview_width, preview_height);
mFrameSizeDelta = 16;
hal_pixel_format = HAL_PIXEL_FORMAT_YV12;
@@ -451,13 +451,13 @@
#ifdef USE_EGL
if (w->set_usage(w, GRALLOC_USAGE_SW_WRITE_OFTEN | GRALLOC_USAGE_HW_ION)) {
- LOGE("%s: could not set usage on gralloc buffer", __func__);
+ ALOGE("%s: could not set usage on gralloc buffer", __func__);
return INVALID_OPERATION;
}
#else
if (w->set_usage(w, GRALLOC_USAGE_SW_WRITE_OFTEN
| GRALLOC_USAGE_HWC_HWOVERLAY | GRALLOC_USAGE_HW_ION)) {
- LOGE("%s: could not set usage on gralloc buffer", __func__);
+ ALOGE("%s: could not set usage on gralloc buffer", __func__);
return INVALID_OPERATION;
}
#endif
@@ -465,19 +465,19 @@
if (w->set_buffers_geometry(w,
preview_width, preview_height,
hal_pixel_format)) {
- LOGE("%s: could not set buffers geometry to %s",
+ ALOGE("%s: could not set buffers geometry to %s",
__func__, str_preview_format);
return INVALID_OPERATION;
}
for(int i = 0; i < BUFFER_COUNT_FOR_ARRAY; i++)
if (0 != mPreviewWindow->dequeue_buffer(mPreviewWindow, &mBufferHandle[i], &mStride[i])) {
- LOGE("%s: Could not dequeue gralloc buffer[%d]!!", __func__, i);
+ ALOGE("%s: Could not dequeue gralloc buffer[%d]!!", __func__, i);
return INVALID_OPERATION;
}
if (mPreviewRunning && mPreviewStartDeferred) {
- LOGV("start/resume preview");
+ ALOGV("start/resume preview");
status_t ret = startPreviewInternal();
if (ret == OK) {
mPreviewStartDeferred = false;
@@ -504,14 +504,14 @@
void CameraHardwareSec::enableMsgType(int32_t msgType)
{
- LOGV("%s : msgType = 0x%x, mMsgEnabled before = 0x%x",
+ ALOGV("%s : msgType = 0x%x, mMsgEnabled before = 0x%x",
__func__, msgType, mMsgEnabled);
mMsgEnabled |= msgType;
mPreviewLock.lock();
if ((msgType & (CAMERA_MSG_PREVIEW_FRAME | CAMERA_MSG_VIDEO_FRAME)) &&
mPreviewRunning && mPreviewStartDeferred) {
- LOGV("%s: starting deferred preview", __func__);
+ ALOGV("%s: starting deferred preview", __func__);
if (startPreviewInternal() == OK) {
mPreviewStartDeferred = false;
mPreviewCondition.signal();
@@ -519,15 +519,15 @@
}
mPreviewLock.unlock();
- LOGV("%s : mMsgEnabled = 0x%x", __func__, mMsgEnabled);
+ ALOGV("%s : mMsgEnabled = 0x%x", __func__, mMsgEnabled);
}
void CameraHardwareSec::disableMsgType(int32_t msgType)
{
- LOGV("%s : msgType = 0x%x, mMsgEnabled before = 0x%x",
+ ALOGV("%s : msgType = 0x%x, mMsgEnabled before = 0x%x",
__func__, msgType, mMsgEnabled);
mMsgEnabled &= ~msgType;
- LOGV("%s : mMsgEnabled = 0x%x", __func__, mMsgEnabled);
+ ALOGV("%s : mMsgEnabled = 0x%x", __func__, mMsgEnabled);
}
bool CameraHardwareSec::msgTypeEnabled(int32_t msgType)
@@ -546,21 +546,21 @@
int CameraHardwareSec::previewThreadWrapper()
{
- LOGI("%s: starting", __func__);
+ ALOGI("%s: starting", __func__);
while (1) {
mPreviewLock.lock();
while (!mPreviewRunning) {
- LOGI("%s: calling mSecCamera->stopPreview() and waiting", __func__);
+ ALOGI("%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__);
+ ALOGI("%s: return from wait", __func__);
}
mPreviewLock.unlock();
if (mExitPreviewThread) {
- LOGI("%s: exiting", __func__);
+ ALOGI("%s: exiting", __func__);
mSecCamera->stopPreview();
return 0;
}
@@ -580,7 +580,7 @@
index = mSecCamera->getPreview();
if (index < 0) {
- LOGE("ERR(%s):Fail on SecCamera->getPreview()", __func__);
+ ALOGE("ERR(%s):Fail on SecCamera->getPreview()", __func__);
if (mSecCamera->getPreviewState()) {
stopPreview();
startPreview();
@@ -593,9 +593,9 @@
if (mSkipFrame > 0) {
mSkipFrame--;
mSkipFrameLock.unlock();
- LOGV("%s: index %d skipping frame", __func__, index);
+ ALOGV("%s: index %d skipping frame", __func__, index);
if (mSecCamera->setPreviewFrame(index) < 0) {
- LOGE("%s: Could not qbuff[%d]!!", __func__, index);
+ ALOGE("%s: Could not qbuff[%d]!!", __func__, index);
return UNKNOWN_ERROR;
}
return NO_ERROR;
@@ -624,14 +624,14 @@
mGrallocHal->unlock(mGrallocHal, *mBufferHandle[index]);
if (0 != mPreviewWindow->enqueue_buffer(mPreviewWindow, mBufferHandle[index])) {
- LOGE("%s: Could not enqueue gralloc buffer[%d]!!", __func__, index);
+ ALOGE("%s: Could not enqueue gralloc buffer[%d]!!", __func__, index);
goto callbacks;
}
numArray = index;
if (0 != mPreviewWindow->dequeue_buffer(mPreviewWindow, &mBufferHandle[numArray], &mStride[numArray])) {
- LOGE("%s: Could not dequeue gralloc buffer[%d]!!", __func__, numArray);
+ ALOGE("%s: Could not dequeue gralloc buffer[%d]!!", __func__, numArray);
goto callbacks;
}
@@ -654,10 +654,10 @@
mSecCamera->setUserBufferAddr(virAddr, index, PREVIEW_MODE);
}
else
- LOGE("%s: could not obtain gralloc buffer", __func__);
+ ALOGE("%s: could not obtain gralloc buffer", __func__);
if (mSecCamera->setPreviewFrame(index) < 0) {
- LOGE("%s: Fail qbuf, index(%d)", __func__, index);
+ ALOGE("%s: Fail qbuf, index(%d)", __func__, index);
goto callbacks;
}
index = 0;
@@ -674,7 +674,7 @@
index = mSecCamera->getRecordFrame();
if (index < 0) {
- LOGE("ERR(%s):Fail on SecCamera->getRecordFrame()", __func__);
+ ALOGE("ERR(%s):Fail on SecCamera->getRecordFrame()", __func__);
return UNKNOWN_ERROR;
}
@@ -695,18 +695,18 @@
{
int ret = 0;
- LOGV("%s :", __func__);
+ ALOGV("%s :", __func__);
Mutex::Autolock lock(mStateLock);
if (mCaptureInProgress) {
- LOGE("%s : capture in progress, not allowed", __func__);
+ ALOGE("%s : capture in progress, not allowed", __func__);
return INVALID_OPERATION;
}
mPreviewLock.lock();
if (mPreviewRunning) {
// already running
- LOGE("%s : preview thread already running", __func__);
+ ALOGE("%s : preview thread already running", __func__);
mPreviewLock.unlock();
return INVALID_OPERATION;
}
@@ -717,7 +717,7 @@
if (!mPreviewWindow &&
!(mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME) &&
!(mMsgEnabled & CAMERA_MSG_VIDEO_FRAME)) {
- LOGI("%s : deferring", __func__);
+ ALOGI("%s : deferring", __func__);
mPreviewStartDeferred = true;
mPreviewLock.unlock();
return NO_ERROR;
@@ -733,11 +733,11 @@
status_t CameraHardwareSec::startPreviewInternal()
{
- LOGV("%s", __func__);
+ ALOGV("%s", __func__);
int width, height, frame_size;
mSecCamera->getPreviewSize(&width, &height, &frame_size);
- LOGD("mPreviewHeap(fd(%d), size(%d), width(%d), height(%d))",
+ ALOGD("mPreviewHeap(fd(%d), size(%d), width(%d), height(%d))",
mSecCamera->getCameraFd(), frame_size + mFrameSizeDelta, width, height);
void *vaddr[3];
@@ -758,10 +758,10 @@
}
int ret = mSecCamera->startPreview();
- LOGV("%s : mSecCamera->startPreview() returned %d", __func__, ret);
+ ALOGV("%s : mSecCamera->startPreview() returned %d", __func__, ret);
if (ret < 0) {
- LOGE("ERR(%s):Fail on mSecCamera->startPreview()", __func__);
+ ALOGE("ERR(%s):Fail on mSecCamera->startPreview()", __func__);
return UNKNOWN_ERROR;
}
@@ -773,7 +773,7 @@
}
mSecCamera->getPostViewConfig(&mPostViewWidth, &mPostViewHeight, &mPostViewSize);
- LOGV("CameraHardwareSec: mPostViewWidth = %d mPostViewHeight = %d mPostViewSize = %d",
+ ALOGV("CameraHardwareSec: mPostViewWidth = %d mPostViewHeight = %d mPostViewSize = %d",
mPostViewWidth,mPostViewHeight,mPostViewSize);
return NO_ERROR;
@@ -781,7 +781,7 @@
void CameraHardwareSec::stopPreviewInternal()
{
- LOGV("%s :", __func__);
+ ALOGV("%s :", __func__);
/* request that the preview thread stop. */
if (mPreviewRunning) {
@@ -793,18 +793,18 @@
for (int i = 0; i < MAX_BUFFERS; i++) {
if (0 != mPreviewWindow->enqueue_buffer(mPreviewWindow, mBufferHandle[i]))
- LOGE("%s: Fail to enqueue buffer[%d]", __func__, i);
+ ALOGE("%s: Fail to enqueue buffer[%d]", __func__, i);
}
}
else
- LOGV("%s : preview running but deferred, doing nothing", __func__);
+ ALOGV("%s : preview running but deferred, doing nothing", __func__);
} else
- LOGI("%s : preview not running, doing nothing", __func__);
+ ALOGI("%s : preview not running, doing nothing", __func__);
}
void CameraHardwareSec::stopPreview()
{
- LOGV("%s :", __func__);
+ ALOGV("%s :", __func__);
/* request that the preview thread stop. */
mPreviewLock.lock();
@@ -815,13 +815,13 @@
bool CameraHardwareSec::previewEnabled()
{
Mutex::Autolock lock(mPreviewLock);
- LOGV("%s : %d", __func__, mPreviewRunning);
+ ALOGV("%s : %d", __func__, mPreviewRunning);
return mPreviewRunning;
}
status_t CameraHardwareSec::startRecording()
{
- LOGV("%s :", __func__);
+ ALOGV("%s :", __func__);
Mutex::Autolock lock(mRecordLock);
@@ -838,16 +838,16 @@
+ ALIGN((ALIGN(width, 16) * ALIGN(height >> 1, 8)), 2048)), 1, NULL);
mSecCamera->setUserBufferAddr((void *)(mRecordHeap[i]->data), i, RECORD_MODE);
if (!mRecordHeap[i]) {
- LOGE("ERR(%s): Record heap[%d] creation fail", __func__, i);
+ ALOGE("ERR(%s): Record heap[%d] creation fail", __func__, i);
return UNKNOWN_ERROR;
}
}
- LOGV("mRecordHeaps alloc done");
+ ALOGV("mRecordHeaps alloc done");
if (mRecordRunning == false) {
if (mSecCamera->startRecord() < 0) {
- LOGE("ERR(%s):Fail on mSecCamera->startRecord()", __func__);
+ ALOGE("ERR(%s):Fail on mSecCamera->startRecord()", __func__);
return UNKNOWN_ERROR;
}
mRecordRunning = true;
@@ -857,13 +857,13 @@
void CameraHardwareSec::stopRecording()
{
- LOGV("%s :", __func__);
+ ALOGV("%s :", __func__);
Mutex::Autolock lock(mRecordLock);
if (mRecordRunning == true) {
if (mSecCamera->stopRecord() < 0) {
- LOGE("ERR(%s):Fail on mSecCamera->stopRecord()", __func__);
+ ALOGE("ERR(%s):Fail on mSecCamera->stopRecord()", __func__);
return;
}
mRecordRunning = false;
@@ -872,8 +872,8 @@
bool CameraHardwareSec::recordingEnabled()
{
- LOGV("%s :", __func__);
- LOGV("%s : %d", __func__, mPreviewRunning);
+ ALOGV("%s :", __func__);
+ ALOGV("%s : %d", __func__, mPreviewRunning);
return mRecordRunning;
}
@@ -893,7 +893,7 @@
int count =0;
int af_status =0 ;
- LOGV("%s : starting", __func__);
+ ALOGV("%s : starting", __func__);
/* block until we're told to start. we don't want to use
@@ -906,14 +906,14 @@
/* check early exit request */
if (mExitAutoFocusThread) {
mFocusLock.unlock();
- LOGV("%s : exiting on request0", __func__);
+ ALOGV("%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__);
+ ALOGV("%s : exiting on request1", __func__);
return NO_ERROR;
}
mFocusLock.unlock();
@@ -922,14 +922,14 @@
if (mMsgEnabled & CAMERA_MSG_FOCUS)
mNotifyCb(CAMERA_MSG_FOCUS, false, 0, mCallbackCookie);
- //LOGV("%s : exiting with no error", __func__);
+ //ALOGV("%s : exiting with no error", __func__);
return NO_ERROR;
#else
#ifdef AF_SUPPORT
- LOGV("%s : calling setAutoFocus", __func__);
+ ALOGV("%s : calling setAutoFocus", __func__);
if (mSecCamera->setAutofocus() < 0) {
- LOGE("ERR(%s):Fail on mSecCamera->setAutofocus()", __func__);
+ ALOGE("ERR(%s):Fail on mSecCamera->setAutofocus()", __func__);
return UNKNOWN_ERROR;
}
@@ -940,11 +940,11 @@
#endif
if (af_status == 0x01) {
- LOGV("%s : AF Success!!", __func__);
+ ALOGV("%s : AF Success!!", __func__);
if (mMsgEnabled & CAMERA_MSG_FOCUS)
mNotifyCb(CAMERA_MSG_FOCUS, true, 0, mCallbackCookie);
} else if (af_status == 0x02) {
- LOGV("%s : AF Cancelled !!", __func__);
+ ALOGV("%s : AF Cancelled !!", __func__);
if (mMsgEnabled & CAMERA_MSG_FOCUS) {
/* CAMERA_MSG_FOCUS only takes a bool. true for
* finished and false for failure. cancel is still
@@ -953,20 +953,20 @@
mNotifyCb(CAMERA_MSG_FOCUS, true, 0, mCallbackCookie);
}
} else {
- LOGV("%s : AF Fail !!", __func__);
- LOGV("%s : mMsgEnabled = 0x%x", __func__, mMsgEnabled);
+ ALOGV("%s : AF Fail !!", __func__);
+ ALOGV("%s : mMsgEnabled = 0x%x", __func__, mMsgEnabled);
if (mMsgEnabled & CAMERA_MSG_FOCUS)
mNotifyCb(CAMERA_MSG_FOCUS, false, 0, mCallbackCookie);
}
- LOGV("%s : exiting with no error", __func__);
+ ALOGV("%s : exiting with no error", __func__);
return NO_ERROR;
#endif
}
status_t CameraHardwareSec::autoFocus()
{
- LOGV("%s :", __func__);
+ ALOGV("%s :", __func__);
/* signal autoFocusThread to run once */
mFocusCondition.signal();
return NO_ERROR;
@@ -974,11 +974,11 @@
status_t CameraHardwareSec::cancelAutoFocus()
{
- LOGV("%s :", __func__);
+ ALOGV("%s :", __func__);
#ifndef GAIA_FW_BETA
if (mSecCamera->cancelAutofocus() < 0) {
- LOGE("ERR(%s):Fail on mSecCamera->cancelAutofocus()", __func__);
+ ALOGE("ERR(%s):Fail on mSecCamera->cancelAutofocus()", __func__);
return UNKNOWN_ERROR;
}
#endif
@@ -993,14 +993,14 @@
/* file create/open, note to "wb" */
yuv_fp = fopen("/data/camera_dump.jpeg", "wb");
if (yuv_fp == NULL) {
- LOGE("Save jpeg file open error");
+ ALOGE("Save jpeg file open error");
return -1;
}
- LOGV("[BestIQ] real_jpeg size ========> %d", jpeg_size);
+ ALOGV("[BestIQ] real_jpeg size ========> %d", jpeg_size);
buffer = (char *) malloc(jpeg_size);
if (buffer == NULL) {
- LOGE("Save YUV] buffer alloc failed");
+ ALOGE("Save YUV] buffer alloc failed");
if (yuv_fp)
fclose(yuv_fp);
@@ -1029,24 +1029,24 @@
int cnt = 0;
uint32_t written = 0;
- LOGD("opening file [%s]", fname);
+ ALOGD("opening file [%s]", fname);
int fd = open(fname, O_RDWR | O_CREAT);
if (fd < 0) {
- LOGE("failed to create file [%s]: %s", fname, strerror(errno));
+ ALOGE("failed to create file [%s]: %s", fname, strerror(errno));
return;
}
- LOGD("writing %d bytes to file [%s]", size, fname);
+ ALOGD("writing %d bytes to file [%s]", size, fname);
while (written < size) {
nw = ::write(fd, buf + written, size - written);
if (nw < 0) {
- LOGE("failed to write to file %d [%s]: %s",written,fname, strerror(errno));
+ ALOGE("failed to write to file %d [%s]: %s",written,fname, strerror(errno));
break;
}
written += nw;
cnt++;
}
- LOGD("done writing %d bytes to file [%s] in %d passes",size, fname, cnt);
+ ALOGD("done writing %d bytes to file [%s] in %d passes",size, fname, cnt);
::close(fd);
}
@@ -1058,7 +1058,7 @@
int32_t x, y, src_y_start_pos, dst_pos, src_pos;
if (dstWidth % 2 != 0 || dstHeight % 2 != 0) {
- LOGE("scale_down_yuv422: invalid width, height for scaling");
+ ALOGE("scale_down_yuv422: invalid width, height for scaling");
return false;
}
@@ -1115,7 +1115,7 @@
int CameraHardwareSec::pictureThread()
{
- LOGV("%s :", __func__);
+ ALOGV("%s :", __func__);
int jpeg_size = 0;
int ret = NO_ERROR;
@@ -1144,7 +1144,7 @@
//sp<MemoryBase> buffer = new MemoryBase(mRawHeap, 0, mPostViewSize + 8);
- LOGV("[5B] mPostViewWidth = %d mPostViewHeight = %d\n",mPostViewWidth,mPostViewHeight);
+ ALOGV("[5B] mPostViewWidth = %d mPostViewHeight = %d\n",mPostViewWidth,mPostViewHeight);
camera_memory_t *JpegHeap = mGetMemoryCb(-1, mJpegHeapSize, 1, 0);
#ifndef GAIA_FW_BETA
@@ -1171,7 +1171,7 @@
if (mSecCamera->getCameraId() == SecCamera::CAMERA_ID_BACK){
jpeg_data = mSecCamera->getJpeg(&jpeg_size, &phyAddr);
if (jpeg_data == NULL) {
- LOGE("ERR(%s):Fail on SecCamera->getSnapshot()", __func__);
+ ALOGE("ERR(%s):Fail on SecCamera->getSnapshot()", __func__);
ret = UNKNOWN_ERROR;
}
} else {
@@ -1186,7 +1186,7 @@
JpegHeap->release(JpegHeap);
return UNKNOWN_ERROR;
}
- LOGI("snapshotandjpeg done");
+ ALOGI("snapshotandjpeg done");
#ifdef JPEG_FROM_SENSOR
}
#endif
@@ -1197,10 +1197,10 @@
#ifdef JPEG_FROM_SENSOR
if (mSecCamera->getCameraId() == SecCamera::CAMERA_ID_BACK) {
- LOGV("%s, %s", __func__, (const char*)mCameraSensorName); //to check sensor name
+ ALOGV("%s, %s", __func__, (const char*)mCameraSensorName); //to check sensor name
isLSISensor = !strncmp((const char*)mCameraSensorName, "S5K4ECGX", 8);
if (isLSISensor) {
- LOGI("== Camera Sensor Detect %s - Samsung LSI SOC 5M ==", mCameraSensorName);
+ ALOGI("== Camera Sensor Detect %s - Samsung LSI SOC 5M ==", mCameraSensorName);
// LSI 5M SOC
if (!SplitFrame(jpeg_data, SecCamera::getInterleaveDataSize(),
SecCamera::getJpegLineLength(),
@@ -1211,7 +1211,7 @@
return UNKNOWN_ERROR;
}
} else {
- LOGI("== Camera Sensor Detect %s Sony SOC 5M ==", mCameraSensorName);
+ ALOGI("== Camera Sensor Detect %s Sony SOC 5M ==", mCameraSensorName);
decodeInterleaveData(jpeg_data,
SecCamera::getInterleaveDataSize(),
mPostViewWidth, mPostViewHeight,
@@ -1226,10 +1226,10 @@
#ifdef GAIA_FW_BETA
int rawHeapSize = mPostViewSize;
- LOGV("mRawHeap : MemoryHeapBase(previewHeapSize(%d))", rawHeapSize);
+ ALOGV("mRawHeap : MemoryHeapBase(previewHeapSize(%d))", rawHeapSize);
mRawHeap = mGetMemoryCb((int)mSecCamera->getCameraFd(), rawHeapSize, 1, 0);
if (!mRawHeap)
- LOGE("ERR(%s): Raw heap creation fail", __func__);
+ ALOGE("ERR(%s): Raw heap creation fail", __func__);
if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE)
mDataCb(CAMERA_MSG_RAW_IMAGE, mRawHeap, 0, NULL, mCallbackCookie);
@@ -1245,7 +1245,7 @@
JpegExifSize = mSecCamera->getExif((unsigned char *)ExifHeap->data,
(unsigned char *)ThumbnailHeap->base());
- LOGV("JpegExifSize=%d", JpegExifSize);
+ ALOGV("JpegExifSize=%d", JpegExifSize);
if (JpegExifSize < 0) {
ret = UNKNOWN_ERROR;
@@ -1275,7 +1275,7 @@
}
}
- LOGV("%s : pictureThread end", __func__);
+ ALOGV("%s : pictureThread end", __func__);
out:
if (JpegHeap) {
@@ -1293,18 +1293,18 @@
status_t CameraHardwareSec::takePicture()
{
- LOGV("%s :", __func__);
+ ALOGV("%s :", __func__);
stopPreview();
Mutex::Autolock lock(mStateLock);
if (mCaptureInProgress) {
- LOGE("%s : capture already in progress", __func__);
+ ALOGE("%s : capture already in progress", __func__);
return INVALID_OPERATION;
}
if (mPictureThread->run("CameraPictureThread", PRIORITY_DEFAULT) != NO_ERROR) {
- LOGE("%s : couldn't run picture thread", __func__);
+ ALOGE("%s : couldn't run picture thread", __func__);
return INVALID_OPERATION;
}
mCaptureInProgress = true;
@@ -1314,12 +1314,12 @@
status_t CameraHardwareSec::cancelPicture()
{
- LOGV("%s", __func__);
+ ALOGV("%s", __func__);
if (mPictureThread.get()) {
- LOGV("%s: waiting for picture thread to exit", __func__);
+ ALOGV("%s: waiting for picture thread to exit", __func__);
mPictureThread->requestExitAndWait();
- LOGV("%s: picture thread has exited", __func__);
+ ALOGV("%s: picture thread has exited", __func__);
}
return NO_ERROR;
@@ -1328,7 +1328,7 @@
bool CameraHardwareSec::CheckVideoStartMarker(unsigned char *pBuf)
{
if (!pBuf) {
- LOGE("CheckVideoStartMarker() => pBuf is NULL");
+ ALOGE("CheckVideoStartMarker() => pBuf is NULL");
return false;
}
@@ -1342,7 +1342,7 @@
bool CameraHardwareSec::CheckEOIMarker(unsigned char *pBuf)
{
if (!pBuf) {
- LOGE("CheckEOIMarker() => pBuf is NULL");
+ ALOGE("CheckEOIMarker() => pBuf is NULL");
return false;
}
@@ -1356,7 +1356,7 @@
bool CameraHardwareSec::FindEOIMarkerInJPEG(unsigned char *pBuf, int dwBufSize, int *pnJPEGsize)
{
if (NULL == pBuf || 0 >= dwBufSize) {
- LOGE("FindEOIMarkerInJPEG() => There is no contents.");
+ ALOGE("FindEOIMarkerInJPEG() => There is no contents.");
return false;
}
@@ -1377,15 +1377,15 @@
void *pJPEG, int *pdwJPEGSize,
void *pVideo, int *pdwVideoSize)
{
- LOGV("===========SplitFrame Start==============");
+ ALOGV("===========SplitFrame Start==============");
if (NULL == pFrame || 0 >= dwSize) {
- LOGE("There is no contents (pFrame=%p, dwSize=%d", pFrame, dwSize);
+ ALOGE("There is no contents (pFrame=%p, dwSize=%d", pFrame, dwSize);
return false;
}
if (0 == dwJPEGLineLength || 0 == dwVideoLineLength) {
- LOGE("There in no input information for decoding interleaved jpeg");
+ ALOGE("There in no input information for decoding interleaved jpeg");
return false;
}
@@ -1454,14 +1454,14 @@
if (pdwVideoSize)
*pdwVideoSize = dwVSize;
} else {
- LOGE("DecodeInterleaveJPEG_WithOutDT() => Can not find EOI");
+ ALOGE("DecodeInterleaveJPEG_WithOutDT() => Can not find EOI");
bRet = false;
if (pdwJPEGSize)
*pdwJPEGSize = 0;
if (pdwVideoSize)
*pdwVideoSize = 0;
}
- LOGV("===========SplitFrame end==============");
+ ALOGV("===========SplitFrame end==============");
return bRet;
}
@@ -1487,7 +1487,7 @@
int i = 0;
- LOGV("decodeInterleaveData Start~~~");
+ ALOGV("decodeInterleaveData Start~~~");
while (i < interleaveDataSize) {
if ((*interleave_ptr == 0xFFFFFFFF) || (*interleave_ptr == 0x02FFFFFF) ||
(*interleave_ptr == 0xFF02FFFF)) {
@@ -1547,7 +1547,7 @@
}
}
}
- LOGV("decodeInterleaveData End~~~");
+ ALOGV("decodeInterleaveData End~~~");
return ret;
}
@@ -1586,7 +1586,7 @@
status_t CameraHardwareSec::setParameters(const CameraParameters& params)
{
- LOGV("%s :", __func__);
+ ALOGV("%s :", __func__);
#ifndef GAIA_FW_BETA
int Internal_is = !strncmp((const char*)mSecCamera->getCameraSensorName(), "ISP Camera", 10);
#else
@@ -1601,7 +1601,7 @@
mStateLock.lock();
if (mCaptureInProgress) {
mStateLock.unlock();
- LOGE("%s : capture in progress, not allowed", __func__);
+ ALOGE("%s : capture in progress, not allowed", __func__);
return UNKNOWN_ERROR;
}
mStateLock.unlock();
@@ -1616,7 +1616,7 @@
params.getPreviewSize(&new_preview_width, &new_preview_height);
#endif
const char *new_str_preview_format = params.getPreviewFormat();
- LOGV("%s : new_preview_width x new_preview_height = %dx%d, format = %s",
+ ALOGV("%s : new_preview_width x new_preview_height = %dx%d, format = %s",
__func__, new_preview_width, new_preview_height, new_str_preview_format);
if (0 < new_preview_width && 0 < new_preview_height &&
@@ -1662,32 +1662,32 @@
current_pixel_format != new_preview_format) {
if (mSecCamera->setPreviewSize(new_preview_width, new_preview_height,
new_preview_format) < 0) {
- LOGE("ERR(%s):Fail on mSecCamera->setPreviewSize(width(%d), height(%d), format(%d))",
+ ALOGE("ERR(%s):Fail on mSecCamera->setPreviewSize(width(%d), height(%d), format(%d))",
__func__, new_preview_width, new_preview_height, new_preview_format);
ret = UNKNOWN_ERROR;
} else {
if (mPreviewWindow) {
if (mPreviewRunning && !mPreviewStartDeferred) {
- LOGE("ERR(%s): preview is running, cannot change size and format!",
+ ALOGE("ERR(%s): preview is running, cannot change size and format!",
__func__);
ret = INVALID_OPERATION;
}
- LOGV("%s: mPreviewWindow (%p) set_buffers_geometry", __func__, mPreviewWindow);
- LOGV("%s: mPreviewWindow->set_buffers_geometry (%p)", __func__,
+ ALOGV("%s: mPreviewWindow (%p) set_buffers_geometry", __func__, mPreviewWindow);
+ ALOGV("%s: mPreviewWindow->set_buffers_geometry (%p)", __func__,
mPreviewWindow->set_buffers_geometry);
mPreviewWindow->set_buffers_geometry(mPreviewWindow,
new_preview_width, new_preview_height,
new_preview_format);
- LOGV("%s: DONE mPreviewWindow (%p) set_buffers_geometry", __func__, mPreviewWindow);
+ ALOGV("%s: DONE mPreviewWindow (%p) set_buffers_geometry", __func__, mPreviewWindow);
}
mParameters.setPreviewSize(new_preview_width, new_preview_height);
mParameters.setPreviewFormat(new_str_preview_format);
}
}
- else LOGV("%s: preview size and format has not changed", __func__);
+ else ALOGV("%s: preview size and format has not changed", __func__);
} else {
- LOGE("%s: Invalid preview size(%dx%d)",
+ ALOGE("%s: Invalid preview size(%dx%d)",
__func__, new_preview_width, new_preview_height);
ret = INVALID_OPERATION;
@@ -1698,11 +1698,11 @@
int new_picture_height = 0;
params.getPictureSize(&new_picture_width, &new_picture_height);
- LOGV("%s : new_picture_width x new_picture_height = %dx%d", __func__, new_picture_width, new_picture_height);
+ ALOGV("%s : new_picture_width x new_picture_height = %dx%d", __func__, new_picture_width, new_picture_height);
if (0 < new_picture_width && 0 < new_picture_height) {
- LOGV("%s: setSnapshotSize", __func__);
+ ALOGV("%s: setSnapshotSize", __func__);
if (mSecCamera->setSnapshotSize(new_picture_width, new_picture_height) < 0) {
- LOGE("ERR(%s):Fail on mSecCamera->setSnapshotSize(width(%d), height(%d))",
+ ALOGE("ERR(%s):Fail on mSecCamera->setSnapshotSize(width(%d), height(%d))",
__func__, new_picture_width, new_picture_height);
ret = UNKNOWN_ERROR;
} else
@@ -1711,7 +1711,7 @@
// picture format
const char *new_str_picture_format = params.getPictureFormat();
- LOGV("%s : new_str_picture_format %s", __func__, new_str_picture_format);
+ ALOGV("%s : new_str_picture_format %s", __func__, new_str_picture_format);
if (new_str_picture_format != NULL) {
int new_picture_format = 0;
@@ -1739,7 +1739,7 @@
new_picture_format = V4L2_PIX_FMT_NV21; //for 3rd party
if (mSecCamera->setSnapshotPixelFormat(new_picture_format) < 0) {
- LOGE("ERR(%s):Fail on mSecCamera->setSnapshotPixelFormat(format(%d))", __func__, new_picture_format);
+ ALOGE("ERR(%s):Fail on mSecCamera->setSnapshotPixelFormat(format(%d))", __func__, new_picture_format);
ret = UNKNOWN_ERROR;
} else
mParameters.setPictureFormat(new_str_picture_format);
@@ -1747,11 +1747,11 @@
// JPEG image quality
int new_jpeg_quality = params.getInt(CameraParameters::KEY_JPEG_QUALITY);
- LOGV("%s : new_jpeg_quality %d", __func__, new_jpeg_quality);
+ ALOGV("%s : new_jpeg_quality %d", __func__, new_jpeg_quality);
/* we ignore bad values */
if (new_jpeg_quality >=1 && new_jpeg_quality <= 100) {
if (mSecCamera->setJpegQuality(new_jpeg_quality) < 0) {
- LOGE("ERR(%s):Fail on mSecCamera->setJpegQuality(quality(%d))", __func__, new_jpeg_quality);
+ ALOGE("ERR(%s):Fail on mSecCamera->setJpegQuality(quality(%d))", __func__, new_jpeg_quality);
ret = UNKNOWN_ERROR;
} else
mParameters.set(CameraParameters::KEY_JPEG_QUALITY, new_jpeg_quality);
@@ -1762,7 +1762,7 @@
int new_jpeg_thumbnail_height= params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);
if (0 <= new_jpeg_thumbnail_width && 0 <= new_jpeg_thumbnail_height) {
if (mSecCamera->setJpegThumbnailSize(new_jpeg_thumbnail_width, new_jpeg_thumbnail_height) < 0) {
- LOGE("ERR(%s):Fail on mSecCamera->setJpegThumbnailSize(width(%d), height(%d))", __func__, new_jpeg_thumbnail_width, new_jpeg_thumbnail_height);
+ ALOGE("ERR(%s):Fail on mSecCamera->setJpegThumbnailSize(width(%d), height(%d))", __func__, new_jpeg_thumbnail_width, new_jpeg_thumbnail_height);
ret = UNKNOWN_ERROR;
} else {
mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, new_jpeg_thumbnail_width);
@@ -1772,11 +1772,11 @@
// JPEG thumbnail quality
int new_jpeg_thumbnail_quality = params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY);
- LOGV("%s : new_jpeg_thumbnail_quality %d", __func__, new_jpeg_thumbnail_quality);
+ ALOGV("%s : new_jpeg_thumbnail_quality %d", __func__, new_jpeg_thumbnail_quality);
/* we ignore bad values */
if (new_jpeg_thumbnail_quality >=1 && new_jpeg_thumbnail_quality <= 100) {
if (mSecCamera->setJpegThumbnailQuality(new_jpeg_thumbnail_quality) < 0) {
- LOGE("ERR(%s):Fail on mSecCamera->setJpegThumbnailQuality(quality(%d))",
+ ALOGE("ERR(%s):Fail on mSecCamera->setJpegThumbnailQuality(quality(%d))",
__func__, new_jpeg_thumbnail_quality);
ret = UNKNOWN_ERROR;
} else
@@ -1790,7 +1790,7 @@
*/
if (new_frame_rate != mParameters.getPreviewFrameRate()) {
if (mSecCamera->setFrameRate(new_frame_rate) < 0){
- LOGE("ERR(%s):Fail on mSecCamera->setFrameRate(%d)", __func__, new_frame_rate);
+ ALOGE("ERR(%s):Fail on mSecCamera->setFrameRate(%d)", __func__, new_frame_rate);
ret = UNKNOWN_ERROR;
} else {
mParameters.setPreviewFrameRate(new_frame_rate);
@@ -1799,11 +1799,11 @@
// rotation
int new_rotation = params.getInt(CameraParameters::KEY_ROTATION);
- LOGV("%s : new_rotation %d", __func__, new_rotation);
+ ALOGV("%s : new_rotation %d", __func__, new_rotation);
if (0 <= new_rotation) {
- LOGV("%s : set orientation:%d", __func__, new_rotation);
+ ALOGV("%s : set orientation:%d", __func__, new_rotation);
if (mSecCamera->setExifOrientationInfo(new_rotation) < 0) {
- LOGE("ERR(%s):Fail on mSecCamera->setExifOrientationInfo(%d)", __func__, new_rotation);
+ ALOGE("ERR(%s):Fail on mSecCamera->setExifOrientationInfo(%d)", __func__, new_rotation);
ret = UNKNOWN_ERROR;
} else
mParameters.set(CameraParameters::KEY_ROTATION, new_rotation);
@@ -1813,11 +1813,11 @@
int new_brightness = params.getInt("brightness");
int max_brightness = params.getInt("brightness-max");
int min_brightness = params.getInt("brightness-min");
- LOGV("%s : new_brightness %d", __func__, new_brightness);
+ ALOGV("%s : new_brightness %d", __func__, new_brightness);
if ((min_brightness <= new_brightness) &&
(max_brightness >= new_brightness)) {
if (mSecCamera->setBrightness(new_brightness) < 0) {
- LOGE("ERR(%s):Fail on mSecCamera->setBrightness(brightness(%d))", __func__, new_brightness);
+ ALOGE("ERR(%s):Fail on mSecCamera->setBrightness(brightness(%d))", __func__, new_brightness);
ret = UNKNOWN_ERROR;
} else {
mParameters.set("brightness", new_brightness);
@@ -1828,11 +1828,11 @@
int new_saturation = params.getInt("saturation");
int max_saturation = params.getInt("saturation-max");
int min_saturation = params.getInt("saturation-min");
- LOGV("%s : new_saturation %d", __func__, new_saturation);
+ ALOGV("%s : new_saturation %d", __func__, new_saturation);
if ((min_saturation <= new_saturation) &&
(max_saturation >= new_saturation)) {
if (mSecCamera->setSaturation(new_saturation) < 0) {
- LOGE("ERR(%s):Fail on mSecCamera->setSaturation(saturation(%d))", __func__, new_saturation);
+ ALOGE("ERR(%s):Fail on mSecCamera->setSaturation(saturation(%d))", __func__, new_saturation);
ret = UNKNOWN_ERROR;
} else {
mParameters.set("saturation", new_saturation);
@@ -1843,11 +1843,11 @@
int new_sharpness = params.getInt("sharpness");
int max_sharpness = params.getInt("sharpness-max");
int min_sharpness = params.getInt("sharpness-min");
- LOGV("%s : new_sharpness %d", __func__, new_sharpness);
+ ALOGV("%s : new_sharpness %d", __func__, new_sharpness);
if ((min_sharpness <= new_sharpness) &&
(max_sharpness >= new_sharpness)) {
if (mSecCamera->setSharpness(new_sharpness) < 0) {
- LOGE("ERR(%s):Fail on mSecCamera->setSharpness(sharpness(%d))", __func__, new_sharpness);
+ ALOGE("ERR(%s):Fail on mSecCamera->setSharpness(sharpness(%d))", __func__, new_sharpness);
ret = UNKNOWN_ERROR;
} else {
mParameters.set("sharpness", new_sharpness);
@@ -1858,11 +1858,11 @@
int new_hue = params.getInt("hue");
int max_hue = params.getInt("hue-max");
int min_hue = params.getInt("hue-min");
- LOGV("%s : new_hue %d", __func__, new_hue);
+ ALOGV("%s : new_hue %d", __func__, new_hue);
if ((min_hue <= new_hue) &&
(max_hue >= new_hue)) {
if (mSecCamera->setHue(new_hue) < 0) {
- LOGE("ERR(%s):Fail on mSecCamera->setHue(hue(%d))", __func__, new_hue);
+ ALOGE("ERR(%s):Fail on mSecCamera->setHue(hue(%d))", __func__, new_hue);
ret = UNKNOWN_ERROR;
} else {
mParameters.set("hue", new_hue);
@@ -1873,11 +1873,11 @@
int new_exposure_compensation = params.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION);
int max_exposure_compensation = params.getInt(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION);
int min_exposure_compensation = params.getInt(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION);
- LOGV("%s : new_exposure_compensation %d", __func__, new_exposure_compensation);
+ ALOGV("%s : new_exposure_compensation %d", __func__, new_exposure_compensation);
if ((min_exposure_compensation <= new_exposure_compensation) &&
(max_exposure_compensation >= new_exposure_compensation)) {
if (mSecCamera->setExposure(new_exposure_compensation) < 0) {
- LOGE("ERR(%s):Fail on mSecCamera->setExposure(exposure(%d))", __func__, new_exposure_compensation);
+ ALOGE("ERR(%s):Fail on mSecCamera->setExposure(exposure(%d))", __func__, new_exposure_compensation);
ret = UNKNOWN_ERROR;
} else {
mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, new_exposure_compensation);
@@ -1886,7 +1886,7 @@
// ISO
const char *new_iso_str = params.get("iso");
- LOGV("%s : new_iso_str %s", __func__, new_iso_str);
+ ALOGV("%s : new_iso_str %s", __func__, new_iso_str);
if (new_iso_str != NULL) {
int new_iso = -1;
@@ -1926,13 +1926,13 @@
else
new_iso = ISO_1600;
} else {
- LOGE("ERR(%s):Invalid iso value(%s)", __func__, new_iso_str);
+ ALOGE("ERR(%s):Invalid iso value(%s)", __func__, new_iso_str);
ret = UNKNOWN_ERROR;
}
if (0 <= new_iso) {
if (mSecCamera->setISO(new_iso) < 0) {
- LOGE("ERR(%s):Fail on mSecCamera->setISO(iso(%d))", __func__, new_iso);
+ ALOGE("ERR(%s):Fail on mSecCamera->setISO(iso(%d))", __func__, new_iso);
ret = UNKNOWN_ERROR;
} else {
mParameters.set("iso", new_iso_str);
@@ -1942,7 +1942,7 @@
// whitebalance
const char *new_white_str = params.get(CameraParameters::KEY_WHITE_BALANCE);
- LOGV("%s : new_white_str %s", __func__, new_white_str);
+ ALOGV("%s : new_white_str %s", __func__, new_white_str);
if (new_white_str != NULL) {
int new_white = -1;
@@ -1976,13 +1976,13 @@
else
new_white = WHITE_BALANCE_TUNGSTEN;
} else {
- LOGE("ERR(%s):Invalid white balance(%s)", __func__, new_white_str); //twilight, shade, warm_flourescent
+ ALOGE("ERR(%s):Invalid white balance(%s)", __func__, new_white_str); //twilight, shade, warm_flourescent
ret = UNKNOWN_ERROR;
}
if (0 <= new_white) {
if (mSecCamera->setWhiteBalance(new_white) < 0) {
- LOGE("ERR(%s):Fail on mSecCamera->setWhiteBalance(white(%d))", __func__, new_white);
+ ALOGE("ERR(%s):Fail on mSecCamera->setWhiteBalance(white(%d))", __func__, new_white);
ret = UNKNOWN_ERROR;
} else {
mParameters.set(CameraParameters::KEY_WHITE_BALANCE, new_white_str);
@@ -1992,7 +1992,7 @@
// Metering
const char *new_metering_str = params.get("metering");
- LOGV("%s : new_metering_str %s", __func__, new_metering_str);
+ ALOGV("%s : new_metering_str %s", __func__, new_metering_str);
if (new_metering_str != NULL) {
int new_metering = -1;
@@ -2012,13 +2012,13 @@
else
new_metering = METERING_MATRIX;
} else {
- LOGE("ERR(%s):Invalid metering value(%s)", __func__, new_metering_str);
+ ALOGE("ERR(%s):Invalid metering value(%s)", __func__, new_metering_str);
ret = UNKNOWN_ERROR;
}
if (0 <= new_metering) {
if (mSecCamera->setMetering(new_metering) < 0) {
- LOGE("ERR(%s):Fail on mSecCamera->setMetering(metering(%d))", __func__, new_metering);
+ ALOGE("ERR(%s):Fail on mSecCamera->setMetering(metering(%d))", __func__, new_metering);
ret = UNKNOWN_ERROR;
} else {
mParameters.set("metering", new_metering_str);
@@ -2028,7 +2028,7 @@
// AFC
const char *new_antibanding_str = params.get(CameraParameters::KEY_ANTIBANDING);
- LOGV("%s : new_antibanding_str %s", __func__, new_antibanding_str);
+ ALOGV("%s : new_antibanding_str %s", __func__, new_antibanding_str);
if (new_antibanding_str != NULL) {
int new_antibanding = -1;
@@ -2053,13 +2053,13 @@
else
new_antibanding = ANTI_BANDING_OFF;
} else {
- LOGE("ERR(%s):Invalid antibanding value(%s)", __func__, new_antibanding_str);
+ ALOGE("ERR(%s):Invalid antibanding value(%s)", __func__, new_antibanding_str);
ret = UNKNOWN_ERROR;
}
if (0 <= new_antibanding) {
if (mSecCamera->setAntiBanding(new_antibanding) < 0) {
- LOGE("ERR(%s):Fail on mSecCamera->setAntiBanding(antibanding(%d))", __func__, new_antibanding);
+ ALOGE("ERR(%s):Fail on mSecCamera->setAntiBanding(antibanding(%d))", __func__, new_antibanding);
ret = UNKNOWN_ERROR;
} else {
mParameters.set(CameraParameters::KEY_ANTIBANDING, new_antibanding_str);
@@ -2084,9 +2084,9 @@
if (new_scene_mode_str && current_scene_mode_str) {
if (!strcmp(new_scene_mode_str, current_scene_mode_str)) {
if ((new_min_fps != current_min_fps) || (new_max_fps != current_max_fps)) {
- LOGW("%s : requested new_min_fps = %d, new_max_fps = %d not allowed",
+ ALOGW("%s : requested new_min_fps = %d, new_max_fps = %d not allowed",
__func__, new_min_fps, new_max_fps);
- LOGE("%s : current_min_fps = %d, current_max_fps = %d",
+ ALOGE("%s : current_min_fps = %d, current_max_fps = %d",
__func__, current_min_fps, current_max_fps);
ret = UNKNOWN_ERROR;
}
@@ -2154,7 +2154,7 @@
CameraParameters::SCENE_MODE_CANDLELIGHT)) {
new_scene_mode = SCENE_MODE_CANDLE_LIGHT;
} else {
- LOGE("%s::unmatched scene_mode(%s)",
+ ALOGE("%s::unmatched scene_mode(%s)",
__func__, new_scene_mode_str); //action, night-portrait, theatre, steadyphoto
ret = UNKNOWN_ERROR;
}
@@ -2180,13 +2180,13 @@
mParameters.set(CameraParameters::KEY_FOCUS_DISTANCES,
BACK_CAMERA_INFINITY_FOCUS_DISTANCES_STR);
} else {
- LOGE("%s::unmatched focus_mode(%s)", __func__, new_focus_mode_str);
+ ALOGE("%s::unmatched focus_mode(%s)", __func__, new_focus_mode_str);
ret = UNKNOWN_ERROR;
}
if (0 <= new_focus_mode) {
if (mSecCamera->setFocusMode(new_focus_mode) < 0) {
- LOGE("%s::mSecCamera->setFocusMode(%d) fail", __func__, new_focus_mode);
+ ALOGE("%s::mSecCamera->setFocusMode(%d) fail", __func__, new_focus_mode);
ret = UNKNOWN_ERROR;
} else {
mParameters.set(CameraParameters::KEY_FOCUS_MODE, new_focus_mode_str);
@@ -2207,12 +2207,12 @@
else if (!strcmp(new_flash_mode_str, CameraParameters::FLASH_MODE_TORCH))
new_flash_mode = FLASH_MODE_TORCH;
else {
- LOGE("%s::unmatched flash_mode(%s)", __func__, new_flash_mode_str); //red-eye
+ ALOGE("%s::unmatched flash_mode(%s)", __func__, new_flash_mode_str); //red-eye
ret = UNKNOWN_ERROR;
}
if (0 <= new_flash_mode) {
if (mSecCamera->setFlashMode(new_flash_mode) < 0) {
- LOGE("%s::mSecCamera->setFlashMode(%d) fail", __func__, new_flash_mode);
+ ALOGE("%s::mSecCamera->setFlashMode(%d) fail", __func__, new_flash_mode);
ret = UNKNOWN_ERROR;
} else {
mParameters.set(CameraParameters::KEY_FLASH_MODE, new_flash_mode_str);
@@ -2223,7 +2223,7 @@
// scene..
if (0 <= new_scene_mode) {
if (mSecCamera->setSceneMode(new_scene_mode) < 0) {
- LOGE("%s::mSecCamera->setSceneMode(%d) fail", __func__, new_scene_mode);
+ ALOGE("%s::mSecCamera->setSceneMode(%d) fail", __func__, new_scene_mode);
ret = UNKNOWN_ERROR;
} else {
mParameters.set(CameraParameters::KEY_SCENE_MODE, new_scene_mode_str);
@@ -2258,16 +2258,16 @@
if (Internal_is)
new_image_effect = IS_IMAGE_EFFECT_NEGATIVE_MONO;
else
- LOGW("WARN(%s):Invalid effect value (%s)", __func__, new_image_effect_str);
+ ALOGW("WARN(%s):Invalid effect value (%s)", __func__, new_image_effect_str);
} else {
//posterize, whiteboard, blackboard, solarize
- LOGE("ERR(%s):Invalid effect(%s)", __func__, new_image_effect_str);
+ ALOGE("ERR(%s):Invalid effect(%s)", __func__, new_image_effect_str);
ret = UNKNOWN_ERROR;
}
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);
+ ALOGE("ERR(%s):Fail on mSecCamera->setImageEffect(effect(%d))", __func__, new_image_effect);
ret = UNKNOWN_ERROR;
} else {
const char *old_image_effect_str = mParameters.get(CameraParameters::KEY_EFFECT);
@@ -2285,7 +2285,7 @@
//contrast
const char *new_contrast_str = params.get("contrast");
- LOGV("%s : new_contrast_str %s", __func__, new_contrast_str);
+ ALOGV("%s : new_contrast_str %s", __func__, new_contrast_str);
if (new_contrast_str != NULL) {
int new_contrast = -1;
@@ -2293,7 +2293,7 @@
if (Internal_is)
new_contrast = IS_CONTRAST_AUTO;
else
- LOGW("WARN(%s):Invalid contrast value (%s)", __func__, new_contrast_str);
+ ALOGW("WARN(%s):Invalid contrast value (%s)", __func__, new_contrast_str);
} else if (!strcmp(new_contrast_str, "-2")) {
if (Internal_is)
new_contrast = IS_CONTRAST_MINUS_2;
@@ -2320,13 +2320,13 @@
else
new_contrast = CONTRAST_PLUS_2;
} else {
- LOGE("ERR(%s):Invalid contrast value(%s)", __func__, new_contrast_str);
+ ALOGE("ERR(%s):Invalid contrast value(%s)", __func__, new_contrast_str);
ret = UNKNOWN_ERROR;
}
if (0 <= new_contrast) {
if (mSecCamera->setContrast(new_contrast) < 0) {
- LOGE("ERR(%s):Fail on mSecCamera->setContrast(contrast(%d))", __func__, new_contrast);
+ ALOGE("ERR(%s):Fail on mSecCamera->setContrast(contrast(%d))", __func__, new_contrast);
ret = UNKNOWN_ERROR;
} else {
mParameters.set("contrast", new_contrast_str);
@@ -2336,11 +2336,11 @@
//WDR
int new_wdr = params.getInt("wdr");
- LOGV("%s : new_wdr %d", __func__, new_wdr);
+ ALOGV("%s : new_wdr %d", __func__, new_wdr);
if (0 <= new_wdr) {
if (mSecCamera->setWDR(new_wdr) < 0) {
- LOGE("ERR(%s):Fail on mSecCamera->setWDR(%d)", __func__, new_wdr);
+ ALOGE("ERR(%s):Fail on mSecCamera->setWDR(%d)", __func__, new_wdr);
ret = UNKNOWN_ERROR;
}
}
@@ -2350,7 +2350,7 @@
if (0 <= new_anti_shake) {
if (mSecCamera->setAntiShake(new_anti_shake) < 0) {
- LOGE("ERR(%s):Fail on mSecCamera->setWDR(%d)", __func__, new_anti_shake);
+ ALOGE("ERR(%s):Fail on mSecCamera->setWDR(%d)", __func__, new_anti_shake);
ret = UNKNOWN_ERROR;
}
}
@@ -2358,7 +2358,7 @@
// gps latitude
const char *new_gps_latitude_str = params.get(CameraParameters::KEY_GPS_LATITUDE);
if (mSecCamera->setGPSLatitude(new_gps_latitude_str) < 0) {
- LOGE("%s::mSecCamera->setGPSLatitude(%s) fail", __func__, new_gps_latitude_str);
+ ALOGE("%s::mSecCamera->setGPSLatitude(%s) fail", __func__, new_gps_latitude_str);
ret = UNKNOWN_ERROR;
} else {
if (new_gps_latitude_str) {
@@ -2372,7 +2372,7 @@
const char *new_gps_longitude_str = params.get(CameraParameters::KEY_GPS_LONGITUDE);
if (mSecCamera->setGPSLongitude(new_gps_longitude_str) < 0) {
- LOGE("%s::mSecCamera->setGPSLongitude(%s) fail", __func__, new_gps_longitude_str);
+ ALOGE("%s::mSecCamera->setGPSLongitude(%s) fail", __func__, new_gps_longitude_str);
ret = UNKNOWN_ERROR;
} else {
if (new_gps_longitude_str) {
@@ -2386,7 +2386,7 @@
const char *new_gps_altitude_str = params.get(CameraParameters::KEY_GPS_ALTITUDE);
if (mSecCamera->setGPSAltitude(new_gps_altitude_str) < 0) {
- LOGE("%s::mSecCamera->setGPSAltitude(%s) fail", __func__, new_gps_altitude_str);
+ ALOGE("%s::mSecCamera->setGPSAltitude(%s) fail", __func__, new_gps_altitude_str);
ret = UNKNOWN_ERROR;
} else {
if (new_gps_altitude_str) {
@@ -2400,7 +2400,7 @@
const char *new_gps_timestamp_str = params.get(CameraParameters::KEY_GPS_TIMESTAMP);
if (mSecCamera->setGPSTimeStamp(new_gps_timestamp_str) < 0) {
- LOGE("%s::mSecCamera->setGPSTimeStamp(%s) fail", __func__, new_gps_timestamp_str);
+ ALOGE("%s::mSecCamera->setGPSTimeStamp(%s) fail", __func__, new_gps_timestamp_str);
ret = UNKNOWN_ERROR;
} else {
if (new_gps_timestamp_str) {
@@ -2414,7 +2414,7 @@
const char *new_gps_processing_method_str = params.get(CameraParameters::KEY_GPS_PROCESSING_METHOD);
if (mSecCamera->setGPSProcessingMethod(new_gps_processing_method_str) < 0) {
- LOGE("%s::mSecCamera->setGPSProcessingMethod(%s) fail", __func__, new_gps_processing_method_str);
+ ALOGE("%s::mSecCamera->setGPSProcessingMethod(%s) fail", __func__, new_gps_processing_method_str);
ret = UNKNOWN_ERROR;
} else {
if (new_gps_processing_method_str) {
@@ -2428,19 +2428,19 @@
int new_recording_width = 0;
int new_recording_height = 0;
params.getVideoSize(&new_recording_width, &new_recording_height);
- LOGV("new_recording_width (%d) new_recording_height (%d)",
+ ALOGV("new_recording_width (%d) new_recording_height (%d)",
new_recording_width, new_recording_height);
int current_recording_width, current_recording_height;
mSecCamera->getRecordingSize(¤t_recording_width, ¤t_recording_height);
- LOGV("current_recording_width (%d) current_recording_height (%d)",
+ ALOGV("current_recording_width (%d) current_recording_height (%d)",
current_recording_width, current_recording_height);
if (0 < new_recording_width && 0 < new_recording_height) {
if (current_recording_width != new_recording_width ||
current_recording_height != new_recording_height) {
if (mSecCamera->setRecordingSize(new_recording_width, new_recording_height) < 0) {
- LOGE("ERR(%s):Fail on mSecCamera->setRecordingSize(width(%d), height(%d))",
+ ALOGE("ERR(%s):Fail on mSecCamera->setRecordingSize(width(%d), height(%d))",
__func__, new_recording_width, new_recording_height);
ret = UNKNOWN_ERROR;
} else {
@@ -2455,7 +2455,7 @@
mParameters.setVideoSize(new_recording_width, new_recording_height);
} else {
if (mSecCamera->setRecordingSize(new_preview_width, new_preview_height) < 0) {
- LOGE("ERR(%s):Fail on mSecCamera->setRecordingSize(width(%d), height(%d))",
+ ALOGE("ERR(%s):Fail on mSecCamera->setRecordingSize(width(%d), height(%d))",
__func__, new_preview_width, new_preview_height);
ret = UNKNOWN_ERROR;
}
@@ -2471,13 +2471,13 @@
else if (!strcmp(new_gamma_str, "on"))
new_gamma = GAMMA_ON;
else {
- LOGE("%s::unmatched gamma(%s)", __func__, new_gamma_str);
+ ALOGE("%s::unmatched gamma(%s)", __func__, new_gamma_str);
ret = UNKNOWN_ERROR;
}
if (0 <= new_gamma) {
if (mSecCamera->setGamma(new_gamma) < 0) {
- LOGE("%s::mSecCamera->setGamma(%d) fail", __func__, new_gamma);
+ ALOGE("%s::mSecCamera->setGamma(%d) fail", __func__, new_gamma);
ret = UNKNOWN_ERROR;
}
}
@@ -2494,13 +2494,13 @@
else if (!strcmp(new_slow_ae_str, "on"))
new_slow_ae = SLOW_AE_ON;
else {
- LOGE("%s::unmatched slow_ae(%s)", __func__, new_slow_ae_str);
+ ALOGE("%s::unmatched slow_ae(%s)", __func__, new_slow_ae_str);
ret = UNKNOWN_ERROR;
}
if (0 <= new_slow_ae) {
if (mSecCamera->setSlowAE(new_slow_ae) < 0) {
- LOGE("%s::mSecCamera->setSlowAE(%d) fail", __func__, new_slow_ae);
+ ALOGE("%s::mSecCamera->setSlowAE(%d) fail", __func__, new_slow_ae);
ret = UNKNOWN_ERROR;
}
}
@@ -2511,7 +2511,7 @@
if (0 <= new_sensor_mode) {
if (mSecCamera->setSensorMode(new_sensor_mode) < 0) {
- LOGE("ERR(%s):Fail on mSecCamera->setSensorMode(%d)", __func__, new_sensor_mode);
+ ALOGE("ERR(%s):Fail on mSecCamera->setSensorMode(%d)", __func__, new_sensor_mode);
ret = UNKNOWN_ERROR;
}
} else {
@@ -2523,7 +2523,7 @@
if (0 <= new_shot_mode) {
if (mSecCamera->setShotMode(new_shot_mode) < 0) {
- LOGE("ERR(%s):Fail on mSecCamera->setShotMode(%d)", __func__, new_shot_mode);
+ ALOGE("ERR(%s):Fail on mSecCamera->setShotMode(%d)", __func__, new_shot_mode);
ret = UNKNOWN_ERROR;
}
} else {
@@ -2535,11 +2535,11 @@
if (0 <= new_dataline) {
if (mSecCamera->setDataLineCheck(new_dataline) < 0) {
- LOGE("ERR(%s):Fail on mSecCamera->setDataLineCheck(%d)", __func__, new_dataline);
+ ALOGE("ERR(%s):Fail on mSecCamera->setDataLineCheck(%d)", __func__, new_dataline);
ret = UNKNOWN_ERROR;
}
}
- LOGV("%s return ret = %d", __func__, ret);
+ ALOGV("%s return ret = %d", __func__, ret);
#endif
return ret;
@@ -2547,7 +2547,7 @@
CameraParameters CameraHardwareSec::getParameters() const
{
- LOGV("%s :", __func__);
+ ALOGV("%s :", __func__);
return mParameters;
}
@@ -2558,7 +2558,7 @@
void CameraHardwareSec::release()
{
- LOGV("%s", __func__);
+ ALOGV("%s", __func__);
/* shut down any threads we have that might be running. do it here
* instead of the destructor. we're guaranteed to be on another thread
@@ -2630,7 +2630,7 @@
status_t CameraHardwareSec::storeMetaDataInBuffers(bool enable)
{
if (!enable) {
- LOGE("Non-metadata buffer mode is not supported!");
+ ALOGE("Non-metadata buffer mode is not supported!");
return INVALID_OPERATION;
}
return OK;
@@ -2642,7 +2642,7 @@
static int HAL_camera_device_close(struct hw_device_t* device)
{
- LOGI("%s", __func__);
+ ALOGI("%s", __func__);
if (device) {
camera_device_t *cam_device = (camera_device_t *)device;
delete static_cast<CameraHardwareSec *>(cam_device->priv);
@@ -2661,7 +2661,7 @@
static int HAL_camera_device_set_preview_window(struct camera_device *dev,
struct preview_stream_ops *buf)
{
- LOGV("%s", __func__);
+ ALOGV("%s", __func__);
return obj(dev)->setPreviewWindow(buf);
}
@@ -2673,7 +2673,7 @@
camera_request_memory get_memory,
void* user)
{
- LOGV("%s", __func__);
+ ALOGV("%s", __func__);
obj(dev)->setCallbacks(notify_cb, data_cb, data_cb_timestamp,
get_memory,
user);
@@ -2689,7 +2689,7 @@
*/
static void HAL_camera_device_enable_msg_type(struct camera_device *dev, int32_t msg_type)
{
- LOGV("%s", __func__);
+ ALOGV("%s", __func__);
obj(dev)->enableMsgType(msg_type);
}
@@ -2705,7 +2705,7 @@
*/
static void HAL_camera_device_disable_msg_type(struct camera_device *dev, int32_t msg_type)
{
- LOGV("%s", __func__);
+ ALOGV("%s", __func__);
obj(dev)->disableMsgType(msg_type);
}
@@ -2716,7 +2716,7 @@
*/
static int HAL_camera_device_msg_type_enabled(struct camera_device *dev, int32_t msg_type)
{
- LOGV("%s", __func__);
+ ALOGV("%s", __func__);
return obj(dev)->msgTypeEnabled(msg_type);
}
@@ -2725,7 +2725,7 @@
*/
static int HAL_camera_device_start_preview(struct camera_device *dev)
{
- LOGV("%s", __func__);
+ ALOGV("%s", __func__);
return obj(dev)->startPreview();
}
@@ -2734,7 +2734,7 @@
*/
static void HAL_camera_device_stop_preview(struct camera_device *dev)
{
- LOGV("%s", __func__);
+ ALOGV("%s", __func__);
obj(dev)->stopPreview();
}
@@ -2743,7 +2743,7 @@
*/
static int HAL_camera_device_preview_enabled(struct camera_device *dev)
{
- LOGV("%s", __func__);
+ ALOGV("%s", __func__);
return obj(dev)->previewEnabled();
}
@@ -2779,7 +2779,7 @@
*/
static int HAL_camera_device_store_meta_data_in_buffers(struct camera_device *dev, int enable)
{
- LOGV("%s", __func__);
+ ALOGV("%s", __func__);
return obj(dev)->storeMetaDataInBuffers(enable);
}
@@ -2795,7 +2795,7 @@
*/
static int HAL_camera_device_start_recording(struct camera_device *dev)
{
- LOGV("%s", __func__);
+ ALOGV("%s", __func__);
return obj(dev)->startRecording();
}
@@ -2804,7 +2804,7 @@
*/
static void HAL_camera_device_stop_recording(struct camera_device *dev)
{
- LOGV("%s", __func__);
+ ALOGV("%s", __func__);
obj(dev)->stopRecording();
}
@@ -2813,7 +2813,7 @@
*/
static int HAL_camera_device_recording_enabled(struct camera_device *dev)
{
- LOGV("%s", __func__);
+ ALOGV("%s", __func__);
return obj(dev)->recordingEnabled();
}
@@ -2829,7 +2829,7 @@
static void HAL_camera_device_release_recording_frame(struct camera_device *dev,
const void *opaque)
{
- LOGV("%s", __func__);
+ ALOGV("%s", __func__);
obj(dev)->releaseRecordingFrame(opaque);
}
@@ -2840,7 +2840,7 @@
*/
static int HAL_camera_device_auto_focus(struct camera_device *dev)
{
- LOGV("%s", __func__);
+ ALOGV("%s", __func__);
return obj(dev)->autoFocus();
}
@@ -2852,7 +2852,7 @@
*/
static int HAL_camera_device_cancel_auto_focus(struct camera_device *dev)
{
- LOGV("%s", __func__);
+ ALOGV("%s", __func__);
return obj(dev)->cancelAutoFocus();
}
@@ -2861,7 +2861,7 @@
*/
static int HAL_camera_device_take_picture(struct camera_device *dev)
{
- LOGV("%s", __func__);
+ ALOGV("%s", __func__);
return obj(dev)->takePicture();
}
@@ -2871,7 +2871,7 @@
*/
static int HAL_camera_device_cancel_picture(struct camera_device *dev)
{
- LOGV("%s", __func__);
+ ALOGV("%s", __func__);
return obj(dev)->cancelPicture();
}
@@ -2882,7 +2882,7 @@
static int HAL_camera_device_set_parameters(struct camera_device *dev,
const char *parms)
{
- LOGV("%s", __func__);
+ ALOGV("%s", __func__);
String8 str(parms);
CameraParameters p(str);
return obj(dev)->setParameters(p);
@@ -2891,7 +2891,7 @@
/** Return the camera parameters. */
char *HAL_camera_device_get_parameters(struct camera_device *dev)
{
- LOGV("%s", __func__);
+ ALOGV("%s", __func__);
String8 str;
CameraParameters parms = obj(dev)->getParameters();
str = parms.flatten();
@@ -2900,7 +2900,7 @@
static void HAL_camera_device_put_parameters(struct camera_device *dev, char *parms)
{
- LOGV("%s", __func__);
+ ALOGV("%s", __func__);
free(parms);
}
@@ -2910,7 +2910,7 @@
static int HAL_camera_device_send_command(struct camera_device *dev,
int32_t cmd, int32_t arg1, int32_t arg2)
{
- LOGV("%s", __func__);
+ ALOGV("%s", __func__);
return obj(dev)->sendCommand(cmd, arg1, arg2);
}
@@ -2920,7 +2920,7 @@
*/
static void HAL_camera_device_release(struct camera_device *dev)
{
- LOGV("%s", __func__);
+ ALOGV("%s", __func__);
obj(dev)->release();
}
@@ -2929,19 +2929,19 @@
*/
static int HAL_camera_device_dump(struct camera_device *dev, int fd)
{
- LOGV("%s", __func__);
+ ALOGV("%s", __func__);
return obj(dev)->dump(fd);
}
static int HAL_getNumberOfCameras()
{
- LOGV("%s", __func__);
+ ALOGV("%s", __func__);
return sizeof(sCameraInfo) / sizeof(sCameraInfo[0]);
}
static int HAL_getCameraInfo(int cameraId, struct camera_info *cameraInfo)
{
- LOGV("%s", __func__);
+ ALOGV("%s", __func__);
memcpy(cameraInfo, &sCameraInfo[cameraId], sizeof(CameraInfo));
return 0;
}
@@ -2980,20 +2980,20 @@
const char *id,
struct hw_device_t** device)
{
- LOGV("%s", __func__);
+ ALOGV("%s", __func__);
int cameraId = atoi(id);
if (cameraId < 0 || cameraId >= HAL_getNumberOfCameras()) {
- LOGE("Invalid camera ID %s", id);
+ ALOGE("Invalid camera ID %s", id);
return -EINVAL;
}
if (g_cam_device) {
if (obj(g_cam_device)->getCameraId() == cameraId) {
- LOGV("returning existing camera ID %s", id);
+ ALOGV("returning existing camera ID %s", id);
goto done;
} else {
- LOGE("Cannot open camera %d. camera %d is already running!",
+ ALOGE("Cannot open camera %d. camera %d is already running!",
cameraId, obj(g_cam_device)->getCameraId());
return -ENOSYS;
}
@@ -3010,13 +3010,13 @@
g_cam_device->ops = &camera_device_ops;
- LOGI("%s: open camera %s", __func__, id);
+ ALOGI("%s: open camera %s", __func__, id);
g_cam_device->priv = new CameraHardwareSec(cameraId, g_cam_device);
done:
*device = (hw_device_t *)g_cam_device;
- LOGI("%s: opened camera %s (%p)", __func__, id, *device);
+ ALOGI("%s: opened camera %s (%p)", __func__, id, *device);
return 0;
}
diff --git a/exynos5/hal/libcamera/mediactl.cpp b/exynos5/hal/libcamera/mediactl.cpp
index 468acc4..951acc0 100644
--- a/exynos5/hal/libcamera/mediactl.cpp
+++ b/exynos5/hal/libcamera/mediactl.cpp
@@ -20,8 +20,8 @@
*/
//#include "config.h"
-#define LOG_NDEBUG 0
-#define LOG_TAG "Mediactl"
+#define ALOG_NDEBUG 0
+#define ALOG_TAG "Mediactl"
#include <utils/Log.h>
#include <sys/ioctl.h>
@@ -129,7 +129,7 @@
}
if (i == source->entity->num_links) {
- LOGE("%s: Link not found", __func__);
+ ALOGE("%s: Link not found", __func__);
return -ENOENT;
}
@@ -147,7 +147,7 @@
ret = ioctl(media->fd, MEDIA_IOC_SETUP_LINK, &ulink);
if (ret == -1) {
- LOGE("%s: Unable to setup link (%s)",
+ ALOGE("%s: Unable to setup link (%s)",
__func__, strerror(errno));
return -errno;
}
@@ -205,7 +205,7 @@
static int media_enum_links(struct media_device *media)
{
- LOGV("%s: start", __func__);
+ ALOGV("%s: start", __func__);
__u32 id;
int ret = 0;
@@ -219,7 +219,7 @@
links.links = (struct media_link_desc*)malloc(entity->info.links * sizeof(struct media_link_desc));
if (ioctl(media->fd, MEDIA_IOC_ENUM_LINKS, &links) < 0) {
- LOGE(
+ ALOGE(
"%s: Unable to enumerate pads and links (%s).",
__func__, strerror(errno));
free(links.pads);
@@ -243,7 +243,7 @@
source = media_get_entity_by_id(media, link->source.entity);
sink = media_get_entity_by_id(media, link->sink.entity);
if (source == NULL || sink == NULL) {
- LOGE(
+ ALOGE(
"WARNING entity %u link %u from %u/%u to %u/%u is invalid!",
id, i, link->source.entity,
link->source.index,
@@ -302,7 +302,7 @@
return -EINVAL;
devnum = makedev(entity->info.v4l.major, entity->info.v4l.minor);
- LOGE("looking up device: %u:%u",
+ ALOGE("looking up device: %u:%u",
major(devnum), minor(devnum));
device = udev_device_new_from_devnum(udev, 'c', devnum);
if (device) {
@@ -371,14 +371,14 @@
char *ptr;
char media_buf[6];
- LOGV("%s(%s)", __func__, MEDIA_DEV);
+ ALOGV("%s(%s)", __func__, MEDIA_DEV);
media->fd = open(MEDIA_DEV, O_RDWR, 0);
if( media->fd < 0) {
- LOGE("Open sysfs media device failed, media->fd : 0x%p", media->fd);
+ ALOGE("Open sysfs media device failed, media->fd : 0x%p", media->fd);
return -1;
}
- LOGV("media->fd : %p", media->fd);
+ ALOGV("media->fd : %p", media->fd);
return media->fd;
@@ -431,7 +431,7 @@
/* Fall back to get the device name via sysfs */
media_get_devname_sysfs(entity);
if (ret < 0)
- LOGE("media_get_devname failed");
+ ALOGE("media_get_devname failed");
}
return ret;
@@ -467,40 +467,40 @@
media = (struct media_device*)calloc(1, sizeof(struct media_device));
if (media == NULL) {
- LOGE("%s: media : %p", __func__, media);
+ ALOGE("%s: media : %p", __func__, media);
return NULL;
}
media_debug_set_handler(media, debug_handler, debug_priv);
- LOGV("Opening media device %s", name);
- LOGV("%s: media : %p", __func__, media);
+ ALOGV("Opening media device %s", name);
+ ALOGV("%s: media : %p", __func__, media);
media->fd = get_media_fd(media);
if (media->fd < 0) {
media_close(media);
- LOGE("%s: failed get_media_fd %s",
+ ALOGE("%s: failed get_media_fd %s",
__func__, name);
return NULL;
}
- LOGV("%s: media->fd : %p", __func__, media->fd);
+ ALOGV("%s: media->fd : %p", __func__, media->fd);
ret = media_enum_entities(media);
if (ret < 0) {
- LOGE(
+ ALOGE(
"%s: Unable to enumerate entities for device %s (%s)",
__func__, name, strerror(-ret));
media_close(media);
return NULL;
}
- LOGV("Found %u entities", media->entities_count);
- LOGV("Enumerating pads and links");
+ ALOGV("Found %u entities", media->entities_count);
+ ALOGV("Enumerating pads and links");
ret = media_enum_links(media);
if (ret < 0) {
- LOGE(
+ ALOGE(
"%s: Unable to enumerate pads and linksfor device %s",
__func__, name);
media_close(media);
@@ -621,28 +621,28 @@
link = media_parse_link(media, p, &end);
if (link == NULL) {
- LOGE(
+ ALOGE(
"%s: Unable to parse link", __func__);
return -EINVAL;
}
p = end;
if (*p++ != '[') {
- LOGE("Unable to parse link flags");
+ ALOGE("Unable to parse link flags");
return -EINVAL;
}
flags = strtoul(p, &end, 10);
for (p = end; isspace(*p); p++);
if (*p++ != ']') {
- LOGE("Unable to parse link flags");
+ ALOGE("Unable to parse link flags");
return -EINVAL;
}
for (; isspace(*p); p++);
*endp = (char *)p;
- LOGV(
+ ALOGV(
"Setting up link %u:%u -> %u:%u [%u]",
link->source->entity->info.id, link->source->index,
link->sink->entity->info.id, link->sink->index,
diff --git a/exynos5/hal/libfimg4x/FimgApi.cpp b/exynos5/hal/libfimg4x/FimgApi.cpp
index ff11b8d..57d0f27 100644
--- a/exynos5/hal/libfimg4x/FimgApi.cpp
+++ b/exynos5/hal/libfimg4x/FimgApi.cpp
@@ -17,8 +17,8 @@
**
*/
-#define LOG_NDEBUG 0
-#define LOG_TAG "SKIA"
+#define ALOG_NDEBUG 0
+#define ALOG_TAG "SKIA"
#include <utils/Log.h>
#include "FimgApi.h"
@@ -270,14 +270,14 @@
void printDataBlit(char *title, struct fimg2d_blit *cmd)
{
- LOGI("%s\n", title);
+ ALOGI("%s\n", title);
- LOGI(" sequence_no. = %u\n", cmd->seq_no);
- LOGI(" blit_op = %d(%s)\n", cmd->op, optbl[cmd->op].str);
- LOGI(" fill_color = %X\n", cmd->solid_color);
- LOGI(" global_alpha = %u\n", (unsigned int)cmd->g_alpha);
- LOGI(" PREMULT = %s\n", cmd->premult == PREMULTIPLIED ? "PREMULTIPLIED" : "NON-PREMULTIPLIED");
- LOGI(" do_dither = %s\n", cmd->dither == true ? "dither" : "no-dither");
+ ALOGI(" sequence_no. = %u\n", cmd->seq_no);
+ ALOGI(" blit_op = %d(%s)\n", cmd->op, optbl[cmd->op].str);
+ ALOGI(" fill_color = %X\n", cmd->solid_color);
+ ALOGI(" global_alpha = %u\n", (unsigned int)cmd->g_alpha);
+ ALOGI(" PREMULT = %s\n", cmd->premult == PREMULTIPLIED ? "PREMULTIPLIED" : "NON-PREMULTIPLIED");
+ ALOGI(" do_dither = %s\n", cmd->dither == true ? "dither" : "no-dither");
printDataBlitRotate(cmd->rotate);
@@ -297,80 +297,80 @@
void printDataBlitImage(char *title, struct fimg2d_image *image)
{
if (NULL != image) {
- LOGI(" Image_%s\n", title);
- LOGI(" addr = %X\n", image->addr.start);
- LOGI(" size = %u\n", image->addr.size);
- LOGI(" (width, height) = (%d, %d)\n", image->width, image->height);
- LOGI(" format = %d\n", image->fmt);
+ ALOGI(" Image_%s\n", title);
+ ALOGI(" addr = %X\n", image->addr.start);
+ ALOGI(" size = %u\n", image->addr.size);
+ ALOGI(" (width, height) = (%d, %d)\n", image->width, image->height);
+ ALOGI(" format = %d\n", image->fmt);
} else
- LOGI(" Image_%s : NULL\n", title);
+ ALOGI(" Image_%s : NULL\n", title);
}
void printDataBlitRect(char *title, struct fimg2d_rect *rect)
{
if (NULL != rect) {
- LOGI(" RECT_%s\n", title);
- LOGI(" (x1, y1) = (%d, %d)\n", rect->x1, rect->y1);
- LOGI(" (x2, y2) = (%d, %d)\n", rect->x2, rect->y2);
- LOGI(" (width, height) = (%d, %d)\n", rect->x2 - rect->x1, rect->y2 - rect->y1);
+ ALOGI(" RECT_%s\n", title);
+ ALOGI(" (x1, y1) = (%d, %d)\n", rect->x1, rect->y1);
+ ALOGI(" (x2, y2) = (%d, %d)\n", rect->x2, rect->y2);
+ ALOGI(" (width, height) = (%d, %d)\n", rect->x2 - rect->x1, rect->y2 - rect->y1);
} else
- LOGI(" RECT_%s : NULL\n", title);
+ ALOGI(" RECT_%s : NULL\n", title);
}
void printDataBlitRotate(enum rotation rotate)
{
- LOGI(" ROTATE : %d\n", rotate);
+ ALOGI(" ROTATE : %d\n", rotate);
}
void printDataBlitClip(struct fimg2d_clip *clip)
{
if (NULL != clip) {
- LOGI(" CLIP\n");
- LOGI(" clip %s\n", clip->enable == true ? "enabled" : "disabled");
- LOGI(" (x1, y1) = (%d, %d)\n", clip->x1, clip->y1);
- LOGI(" (x2, y2) = (%d, %d)\n", clip->x2, clip->y2);
- LOGI(" (width, hight) = (%d, %d)\n", clip->x2 - clip->x1, clip->y2 - clip->y1);
+ ALOGI(" CLIP\n");
+ ALOGI(" clip %s\n", clip->enable == true ? "enabled" : "disabled");
+ ALOGI(" (x1, y1) = (%d, %d)\n", clip->x1, clip->y1);
+ ALOGI(" (x2, y2) = (%d, %d)\n", clip->x2, clip->y2);
+ ALOGI(" (width, hight) = (%d, %d)\n", clip->x2 - clip->x1, clip->y2 - clip->y1);
} else
- LOGI(" CLIP : NULL\n");
+ ALOGI(" CLIP : NULL\n");
}
void printDataBlitScale(struct fimg2d_scale *scaling)
{
if (NULL != scaling) {
- LOGI(" SCALING\n");
- LOGI(" scale_mode : %s\n", scaling->mode == 0 ?
+ ALOGI(" SCALING\n");
+ ALOGI(" scale_mode : %s\n", scaling->mode == 0 ?
"NO_SCALING" :
(scaling->mode == 1 ? "SCALING_NEAREST" : "SCALING_BILINEAR"));
- LOGI(" scaling_factor_unit : %s\n", scaling->factor == 0 ? "PERCENT" : "PIXEL");
+ ALOGI(" scaling_factor_unit : %s\n", scaling->factor == 0 ? "PERCENT" : "PIXEL");
if (scaling->factor == 0)
- LOGI(" scaling_factor : (scale_w, scale_y) = (%d, %d)\n", scaling->scale_w, scaling->scale_h);
+ ALOGI(" scaling_factor : (scale_w, scale_y) = (%d, %d)\n", scaling->scale_w, scaling->scale_h);
else {
- LOGI(" src : (src_w, src_h) = (%d, %d)\n", scaling->src_w, scaling->src_h);
- LOGI(" dst : (dst_w, dst_h) = (%d, %d)\n", scaling->dst_w, scaling->dst_h);
- LOGI(" scaling_factor : (scale_w, scale_y) = (%3.2f, %3.2f)\n", (double)scaling->dst_w / scaling->src_w, (double)scaling->dst_h / scaling->src_h);
+ ALOGI(" src : (src_w, src_h) = (%d, %d)\n", scaling->src_w, scaling->src_h);
+ ALOGI(" dst : (dst_w, dst_h) = (%d, %d)\n", scaling->dst_w, scaling->dst_h);
+ ALOGI(" scaling_factor : (scale_w, scale_y) = (%3.2f, %3.2f)\n", (double)scaling->dst_w / scaling->src_w, (double)scaling->dst_h / scaling->src_h);
}
} else
- LOGI(" SCALING : NULL(NO SCALE MODE)\n");
+ ALOGI(" SCALING : NULL(NO SCALE MODE)\n");
}
void printDataMatrix(int matrixType)
{
- LOGI(" MATRIX\n");
+ ALOGI(" MATRIX\n");
if (matrixType & SkMatrix::kIdentity_Mask)
- LOGI(" Matrix_type : Identity_Mask\n");
+ ALOGI(" Matrix_type : Identity_Mask\n");
if (matrixType & SkMatrix::kTranslate_Mask)
- LOGI(" Matrix_type : Translate_Mask(the matrix has translation)\n");
+ ALOGI(" Matrix_type : Translate_Mask(the matrix has translation)\n");
if (matrixType & SkMatrix::kScale_Mask)
- LOGI(" Matrix_type : Scale_Mask(the matrix has X or Y scale)\n");
+ ALOGI(" Matrix_type : Scale_Mask(the matrix has X or Y scale)\n");
if (matrixType & SkMatrix::kAffine_Mask)
- LOGI(" Matrix_type : Affine_Mask(the matrix skews or rotates)\n");
+ ALOGI(" Matrix_type : Affine_Mask(the matrix skews or rotates)\n");
if (matrixType & SkMatrix::kPerspective_Mask)
- LOGI(" Matrix_type : Perspective_Mask(the matrix is in perspective)\n");
+ ALOGI(" Matrix_type : Perspective_Mask(the matrix is in perspective)\n");
}
diff --git a/exynos5/hal/libfimg4x/FimgApi.h b/exynos5/hal/libfimg4x/FimgApi.h
index a2c9eac..378fd1b 100644
--- a/exynos5/hal/libfimg4x/FimgApi.h
+++ b/exynos5/hal/libfimg4x/FimgApi.h
@@ -30,8 +30,8 @@
#if defined(REAL_DEBUG)
#ifdef ANDROID_LOG
-#define PRINT LOGE
-#define PRINTD LOGD
+#define PRINT ALOGE
+#define PRINTD ALOGD
#else
#define PRINT printf
#define PRINTD printf
diff --git a/exynos5/hal/libfimg4x/FimgExynos5.cpp b/exynos5/hal/libfimg4x/FimgExynos5.cpp
index 87c8527..59d8394 100644
--- a/exynos5/hal/libfimg4x/FimgExynos5.cpp
+++ b/exynos5/hal/libfimg4x/FimgExynos5.cpp
@@ -17,8 +17,8 @@
**
*/
-#define LOG_NDEBUG 0
-#define LOG_TAG "FimgExynos5"
+#define ALOG_NDEBUG 0
+#define ALOG_TAG "FimgExynos5"
#include <utils/Log.h>
#include "FimgExynos5.h"
diff --git a/exynos5/hal/libgralloc_ump/Android.mk b/exynos5/hal/libgralloc_ump/Android.mk
index a4354d4..84cac10 100644
--- a/exynos5/hal/libgralloc_ump/Android.mk
+++ b/exynos5/hal/libgralloc_ump/Android.mk
@@ -40,14 +40,14 @@
ifeq ($(TARGET_PRODUCT), armboard_v7a)
# Support for ARM platforms
-LOCAL_CFLAGS:= -DLOG_TAG=\"gralloc\" -DGRALLOC_16_BITS -DSTANDARD_LINUX_SCREEN \
+LOCAL_CFLAGS:= -DALOG_TAG=\"gralloc\" -DGRALLOC_16_BITS -DSTANDARD_LINUX_SCREEN \
-march=armv7-a \
-mfloat-abi=softfp
LOCAL_MODULE := gralloc.default
else
#Default to goldfish
-LOCAL_CFLAGS:= -DLOG_TAG=\"gralloc\" -DSTANDARD_LINUX_SCREEN \
+LOCAL_CFLAGS:= -DALOG_TAG=\"gralloc\" -DSTANDARD_LINUX_SCREEN \
-march=armv7-a \
-mfloat-abi=softfp \
-DVITHAR_HACK
diff --git a/exynos5/hal/libgralloc_ump/alloc_device.cpp b/exynos5/hal/libgralloc_ump/alloc_device.cpp
index 64be027..52c8724 100644
--- a/exynos5/hal/libgralloc_ump/alloc_device.cpp
+++ b/exynos5/hal/libgralloc_ump/alloc_device.cpp
@@ -68,13 +68,13 @@
private_module_t* m = reinterpret_cast<private_module_t*>(dev->common.module);
ion_fd = ion_alloc(m->ion_client, size, 0, ION_HEAP_EXYNOS_MASK);
if (ion_fd < 0) {
- LOGE("Failed to ion_alloc");
+ ALOGE("Failed to ion_alloc");
return -1;
}
cpu_ptr = ion_map(ion_fd, size, 0);
if (NULL == cpu_ptr) {
- LOGE("Failed to ion_map");
+ ALOGE("Failed to ion_map");
ion_free(ion_fd);
return -1;
}
@@ -83,7 +83,7 @@
if (UMP_INVALID_MEMORY_HANDLE != ump_mem_handle) {
priv_alloc_flag = private_handle_t::PRIV_FLAGS_USES_ION;
} else {
- LOGE("gralloc_alloc_buffer() failed to import ION memory");
+ ALOGE("gralloc_alloc_buffer() failed to import ION memory");
ion_unmap(cpu_ptr, size);
ion_free(ion_fd);
return -1;
@@ -120,7 +120,7 @@
if (UMP_INVALID_MEMORY_HANDLE != ump_mem_handle)
cpu_ptr = ump_map(ump_mem_handle, 0, size);
else
- LOGE("gralloc_alloc_buffer() failed to allcoate UMP memory");
+ ALOGE("gralloc_alloc_buffer() failed to allcoate UMP memory");
}
if (NULL != cpu_ptr) {
@@ -144,15 +144,15 @@
hnd->voffset = ((EXYNOS_ALIGN((hnd->width >> 1), 8) * EXYNOS_ALIGN((hnd->height >> 1), 8)));
return 0;
} else {
- LOGE("gralloc_alloc_buffer() failed to allocate handle");
+ ALOGE("gralloc_alloc_buffer() failed to allocate handle");
}
} else {
- LOGE("gralloc_alloc_buffer() failed to retrieve valid secure id");
+ ALOGE("gralloc_alloc_buffer() failed to retrieve valid secure id");
}
ump_unmap(ump_mem_handle, cpu_ptr, size);
} else {
- LOGE("gralloc_alloc_buffer() failed to map UMP memory");
+ ALOGE("gralloc_alloc_buffer() failed to map UMP memory");
}
ump_release(ump_mem_handle);
@@ -187,13 +187,13 @@
*/
int newUsage = (usage & ~GRALLOC_USAGE_HW_FB) | GRALLOC_USAGE_HW_2D;
- LOGD("fallback to single buffering");
+ ALOGD("fallback to single buffering");
return gralloc_alloc_buffer(dev, bufferSize, newUsage, pHandle, w, h, format, bpp, 0, 0);
}
if (bufferMask >= ((1LU<<numBuffers)-1)) {
- LOGE("Ran out of buffers");
+ ALOGE("Ran out of buffers");
return -ENOMEM;
}
@@ -236,7 +236,7 @@
int usage, buffer_handle_t* pHandle, int* pStride)
{
if (!pHandle || !pStride) {
- LOGE("Invalid Handle, Stride value");
+ ALOGE("Invalid Handle, Stride value");
return -EINVAL;
}
@@ -269,7 +269,7 @@
bpp = 4;
break;
default:
- LOGE("Not Support Pixel Format");
+ ALOGE("Not Support Pixel Format");
return -EINVAL;
}
@@ -289,7 +289,7 @@
format, 0, (int)stride_raw, (int)stride);
if (err < 0) {
- LOGE("Fail to alloc Gralloc memory");
+ ALOGE("Fail to alloc Gralloc memory");
return err;
}
@@ -300,7 +300,7 @@
static int alloc_device_free(alloc_device_t* dev, buffer_handle_t handle)
{
if (private_handle_t::validate(handle) < 0) {
- LOGE("Invalid Value : private_handle");
+ ALOGE("Invalid Value : private_handle");
return -EINVAL;
}
@@ -346,19 +346,19 @@
dev = new alloc_device_t;
if (NULL == dev) {
- LOGE("Fail to create alloc_device");
+ ALOGE("Fail to create alloc_device");
return -1;
}
dev->common.module = const_cast<hw_module_t*>(module);
private_module_t* m = reinterpret_cast<private_module_t*>(dev->common.module);
m->ion_client=ion_client_create();
- LOGI("gralloc create ion_client %d", m->ion_client);
+ ALOGI("gralloc create ion_client %d", m->ion_client);
ump_result ump_res = ump_open();
if ((UMP_OK != ump_res) || (0 > m->ion_client)) {
- LOGE("UMP open failed, ump_res %d, ion_client %d", ump_res, m->ion_client);
+ ALOGE("UMP open failed, ump_res %d, ion_client %d", ump_res, m->ion_client);
delete dev;
return -1;
}
diff --git a/exynos5/hal/libgralloc_ump/framebuffer_device.cpp b/exynos5/hal/libgralloc_ump/framebuffer_device.cpp
index 0015e54..1e64d72 100644
--- a/exynos5/hal/libgralloc_ump/framebuffer_device.cpp
+++ b/exynos5/hal/libgralloc_ump/framebuffer_device.cpp
@@ -73,7 +73,7 @@
#ifdef STANDARD_LINUX_SCREEN
if (ioctl(m->framebuffer->fd, FBIOPAN_DISPLAY, &m->info) == -1) {
- LOGE("FBIOPAN_DISPLAY failed");
+ ALOGE("FBIOPAN_DISPLAY failed");
m->base.unlock(&m->base, buffer);
return 0;
}
@@ -81,13 +81,13 @@
/* wait for VSYNC */
int crtc = 0;
if (ioctl(m->framebuffer->fd, FBIO_WAITFORVSYNC, &crtc) < 0) {
- LOGE("FBIO_WAITFORVSYNC failed");
+ ALOGE("FBIO_WAITFORVSYNC failed");
return 0;
}
#else
/* Standard Android way */
if (ioctl(m->framebuffer->fd, FBIOPUT_VSCREENINFO, &m->info) == -1) {
- LOGE("FBIOPUT_VSCREENINFO failed");
+ ALOGE("FBIOPUT_VSCREENINFO failed");
m->base.unlock(&m->base, buffer);
return -errno;
}
@@ -135,19 +135,19 @@
}
if (fd < 0) {
- LOGE("/dev/graphics/fb, /dev/fb Open fail");
+ ALOGE("/dev/graphics/fb, /dev/fb Open fail");
return -errno;
}
struct fb_fix_screeninfo finfo;
if (ioctl(fd, FBIOGET_FSCREENINFO, &finfo) == -1) {
- LOGE("Fail to get FB Screen Info");
+ ALOGE("Fail to get FB Screen Info");
return -errno;
}
struct fb_var_screeninfo info;
if (ioctl(fd, FBIOGET_VSCREENINFO, &info) == -1) {
- LOGE("First, Fail to get FB VScreen Info");
+ ALOGE("First, Fail to get FB VScreen Info");
return -errno;
}
@@ -195,19 +195,19 @@
if (ioctl(fd, FBIOPUT_VSCREENINFO, &info) == -1) {
info.yres_virtual = info.yres;
flags &= ~PAGE_FLIP;
- LOGW("FBIOPUT_VSCREENINFO failed, page flipping not supported");
+ ALOGW("FBIOPUT_VSCREENINFO failed, page flipping not supported");
}
if (info.yres_virtual < info.yres * 2) {
/* we need at least 2 for page-flipping */
info.yres_virtual = info.yres;
flags &= ~PAGE_FLIP;
- LOGW("page flipping not supported (yres_virtual=%d, requested=%d)",
+ ALOGW("page flipping not supported (yres_virtual=%d, requested=%d)",
info.yres_virtual, info.yres*2);
}
if (ioctl(fd, FBIOGET_VSCREENINFO, &info) == -1) {
- LOGE("Second, Fail to get FB VScreen Info");
+ ALOGE("Second, Fail to get FB VScreen Info");
return -errno;
}
@@ -231,7 +231,7 @@
float ydpi = (info.yres * 25.4f) / info.height;
float fps = refreshRate / 1000.0f;
- LOGI("using (fd=%d)\n"
+ ALOGI("using (fd=%d)\n"
"id = %s\n"
"xres = %d px\n"
"yres = %d px\n"
@@ -252,7 +252,7 @@
info.green.offset, info.green.length,
info.blue.offset, info.blue.length);
- LOGI("width = %d mm (%f dpi)\n"
+ ALOGI("width = %d mm (%f dpi)\n"
"height = %d mm (%f dpi)\n"
"refresh rate = %.2f Hz\n",
info.width, xdpi,
@@ -260,12 +260,12 @@
fps);
if (ioctl(fd, FBIOGET_FSCREENINFO, &finfo) == -1) {
- LOGE("Fail to get FScreen Info");
+ ALOGE("Fail to get FScreen Info");
return -errno;
}
if (finfo.smem_len <= 0) {
- LOGE("Invalid Value : finfo.smem_len");
+ ALOGE("Invalid Value : finfo.smem_len");
return -errno;
}
@@ -282,7 +282,7 @@
size_t fbSize = round_up_to_page_size(finfo.line_length * info.yres_virtual);
void* vaddr = mmap(0, fbSize, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
if (vaddr == MAP_FAILED) {
- LOGE("Error mapping the framebuffer (%s)", strerror(errno));
+ ALOGE("Error mapping the framebuffer (%s)", strerror(errno));
return -errno;
}
@@ -346,14 +346,14 @@
alloc_device_t* gralloc_device;
status = gralloc_open(module, &gralloc_device);
if (status < 0) {
- LOGE("Fail to Open gralloc device");
+ ALOGE("Fail to Open gralloc device");
return status;
}
private_module_t* m = (private_module_t*)module;
status = init_frame_buffer(m);
if (status < 0) {
- LOGE("Fail to init framebuffer");
+ ALOGE("Fail to init framebuffer");
gralloc_close(gralloc_device);
return status;
}
diff --git a/exynos5/hal/libgralloc_ump/gralloc_module.cpp b/exynos5/hal/libgralloc_ump/gralloc_module.cpp
index 8ca500b..d33e5d1 100644
--- a/exynos5/hal/libgralloc_ump/gralloc_module.cpp
+++ b/exynos5/hal/libgralloc_ump/gralloc_module.cpp
@@ -47,15 +47,15 @@
void *mappedAddress = ion_map(hnd->fd, size, 0);
if (mappedAddress == MAP_FAILED) {
- LOGE("Could not ion_map %s fd(%d)", strerror(errno), hnd->fd);
+ ALOGE("Could not ion_map %s fd(%d)", strerror(errno), hnd->fd);
return -errno;
}
hnd->base = intptr_t(mappedAddress) + hnd->offset;
- LOGD("gralloc_map() succeeded fd=%d, off=%d, size=%d, vaddr=%p",
+ ALOGD("gralloc_map() succeeded fd=%d, off=%d, size=%d, vaddr=%p",
hnd->fd, hnd->offset, hnd->size, mappedAddress);
} else {
- LOGE("In case of ION, It could not reach here!");
+ ALOGE("In case of ION, It could not reach here!");
}
}
*vaddr = (void*)hnd->base;
@@ -72,10 +72,10 @@
if (hnd->flags & private_handle_t::PRIV_FLAGS_USES_ION) {
void* base = (void*)hnd->base;
size_t size = hnd->size;
- LOGD("unmapping from %p, size=%d", base, size);
+ ALOGD("unmapping from %p, size=%d", base, size);
if (ion_unmap(base, size) < 0)
- LOGE("Could not ion_unmap %s", strerror(errno));
+ ALOGE("Could not ion_unmap %s", strerror(errno));
ion_client_destroy(hnd->ion_client);
}
@@ -88,7 +88,7 @@
{
int status = -EINVAL;
- LOGI("Opening ARM Gralloc device");
+ ALOGI("Opening ARM Gralloc device");
if (!strcmp(name, GRALLOC_HARDWARE_GPU0))
status = alloc_device_open(module, name, device);
@@ -103,14 +103,14 @@
int retval = -EINVAL;
void *vaddr;
if (private_handle_t::validate(handle) < 0) {
- LOGE("Registering invalid buffer, returning error");
+ ALOGE("Registering invalid buffer, returning error");
return -EINVAL;
}
// if this handle was created in this process, then we keep it as is.
private_handle_t* hnd = (private_handle_t*)handle;
if (hnd->pid == getpid()) {
- LOGE("Invalid Process ID from Private_Handle");
+ ALOGE("Invalid Process ID from Private_Handle");
return 0;
}
@@ -119,7 +119,7 @@
ump_result res = ump_open();
if (res != UMP_OK) {
pthread_mutex_unlock(&s_map_lock);
- LOGE("Failed to open UMP library");
+ ALOGE("Failed to open UMP library");
return retval;
}
s_ump_is_open = 1;
@@ -137,18 +137,18 @@
pthread_mutex_unlock(&s_map_lock);
return 0;
} else {
- LOGE("Failed to map UMP handle");
+ ALOGE("Failed to map UMP handle");
}
ump_release(hnd->ump_mem_handle);
} else {
- LOGE("Failed to create UMP handle");
+ ALOGE("Failed to create UMP handle");
}
} else if (hnd->flags & private_handle_t::PRIV_FLAGS_USES_ION) {
hnd->ump_mem_handle = ump_handle_create_from_secure_id(hnd->ump_id);
retval = gralloc_map(module, handle, &vaddr);
} else {
- LOGE("registering non-UMP&ION buffer not supported");
+ ALOGE("registering non-UMP&ION buffer not supported");
}
pthread_mutex_unlock(&s_map_lock);
@@ -159,13 +159,13 @@
static int gralloc_unregister_buffer(gralloc_module_t const* module, buffer_handle_t handle)
{
if (private_handle_t::validate(handle) < 0) {
- LOGE("unregistering invalid buffer, returning error");
+ ALOGE("unregistering invalid buffer, returning error");
return -EINVAL;
}
private_handle_t* hnd = (private_handle_t*)handle;
- LOGE_IF(hnd->lockState & private_handle_t::LOCK_STATE_READ_MASK,
+ ALOGE_IF(hnd->lockState & private_handle_t::LOCK_STATE_READ_MASK,
"[unregister] handle %p still locked (state=%08x)", hnd, hnd->lockState);
/* never unmap buffers that were created in this process */
@@ -189,7 +189,7 @@
hnd->lockState = 0;
hnd->writeOwner = 0;
} else {
- LOGE("unregistering non-UMP buffer not supported");
+ ALOGE("unregistering non-UMP buffer not supported");
}
hnd->base = 0;
@@ -206,7 +206,7 @@
int usage, int l, int t, int w, int h, void** vaddr)
{
if (private_handle_t::validate(handle) < 0) {
- LOGE("Locking invalid buffer, returning error");
+ ALOGE("Locking invalid buffer, returning error");
return -EINVAL;
}
@@ -233,7 +233,7 @@
static int gralloc_unlock(gralloc_module_t const* module, buffer_handle_t handle)
{
if (private_handle_t::validate(handle) < 0) {
- LOGE("Unlocking invalid buffer, returning error");
+ ALOGE("Unlocking invalid buffer, returning error");
return -EINVAL;
}
diff --git a/exynos5/hal/libhdmi/SecHdmi/SecGscaler.cpp b/exynos5/hal/libhdmi/SecHdmi/SecGscaler.cpp
index 0a84d11..6920042 100644
--- a/exynos5/hal/libhdmi/SecHdmi/SecGscaler.cpp
+++ b/exynos5/hal/libhdmi/SecHdmi/SecGscaler.cpp
@@ -16,7 +16,7 @@
*/
//#define DEBUG_LIB_FIMC
-#define LOG_TAG "libgscaler"
+#define ALOG_TAG "libgscaler"
//#define USE_GSC_USERPTR
#include <cutils/log.h>
#include "../libhdmi/SecHdmi/SecGscaler.h"
@@ -49,34 +49,34 @@
void dump_pixfmt_mp(struct v4l2_pix_format_mplane *pix_mp)
{
- LOGI("w: %d", pix_mp->width);
- LOGI("h: %d", pix_mp->height);
- LOGI("color: %x", pix_mp->colorspace);
+ ALOGI("w: %d", pix_mp->width);
+ ALOGI("h: %d", pix_mp->height);
+ ALOGI("color: %x", pix_mp->colorspace);
switch (pix_mp->pixelformat) {
case V4L2_PIX_FMT_YUYV:
- LOGI ("YUYV");
+ ALOGI ("YUYV");
break;
case V4L2_PIX_FMT_UYVY:
- LOGI ("UYVY");
+ ALOGI ("UYVY");
break;
case V4L2_PIX_FMT_RGB565:
- LOGI ("RGB565");
+ ALOGI ("RGB565");
break;
case V4L2_PIX_FMT_RGB565X:
- LOGI ("RGB565X");
+ ALOGI ("RGB565X");
break;
default:
- LOGI("not supported");
+ ALOGI("not supported");
}
}
void dump_crop(struct v4l2_rect *rect)
{
- LOGI("crop l: %d", rect->left);
- LOGI("crop t: %d", rect->top);
- LOGI("crop w: %d", rect->width);
- LOGI("crop h: %d", rect->height);
+ ALOGI("crop l: %d", rect->left);
+ ALOGI("crop t: %d", rect->top);
+ ALOGI("crop w: %d", rect->width);
+ ALOGI("crop h: %d", rect->height);
}
void gsc_v4l2_dump_state(int fd)
@@ -89,14 +89,14 @@
if (ioctl(fd, VIDIOC_G_FMT, &format) < 0)
return;
- LOGI("dumping driver state:");
+ ALOGI("dumping driver state:");
dump_pixfmt_mp(&format.fmt.pix_mp);
crop.type = format.type;
if (ioctl(fd, VIDIOC_G_CROP, &crop) < 0)
return;
- LOGI("input image crop:");
+ ALOGI("input image crop:");
dump_crop(&(crop.c));
sCrop.pad = GSC_SUBDEV_PAD_SOURCE;
@@ -104,7 +104,7 @@
if (ioctl(fd, VIDIOC_SUBDEV_G_CROP, &sCrop) < 0)
return;
- LOGI("output image crop:");
+ ALOGI("output image crop:");
dump_crop(&(sCrop.rect));
}
@@ -112,22 +112,22 @@
int gsc_v4l2_querycap(int fd, char *node)
{
#ifdef DEBUG_LIB_FIMC
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
struct v4l2_capability v4l2cap;
if (ioctl(fd, VIDIOC_QUERYCAP, &v4l2cap) < 0) {
- LOGE("%s::VIDIOC_QUERYCAP failed", __func__);
+ ALOGE("%s::VIDIOC_QUERYCAP failed", __func__);
return -1;
}
if (!(v4l2cap.capabilities & V4L2_CAP_STREAMING)) {
- LOGE("%s::%s is not support streaming", __func__, node);
+ ALOGE("%s::%s is not support streaming", __func__, node);
return -1;
}
if (!(v4l2cap.capabilities & V4L2_CAP_VIDEO_OUTPUT_MPLANE)) {
- LOGE("%s::%s is not support video output mplane", __func__, node);
+ ALOGE("%s::%s is not support video output mplane", __func__, node);
return -1;
}
@@ -137,7 +137,7 @@
int gsc_v4l2_query_buf(int fd, SecBuffer *secBuf, enum v4l2_buf_type type, enum v4l2_memory memory, unsigned int buf_index, int num_plane)
{
#ifdef DEBUG_LIB_FIMC
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
struct v4l2_buffer buf;
struct v4l2_plane planes[MAX_PLANES_GSCALER];
@@ -148,7 +148,7 @@
memset(&planes[i], 0, sizeof(struct v4l2_plane));
if (MAX_BUFFERS_GSCALER <= buf_index || MAX_PLANES_GSCALER < num_plane) {
- LOGE("%s::exceed MAX! : buf_index=%d, num_plane=%d", __func__, buf_index, num_plane);
+ ALOGE("%s::exceed MAX! : buf_index=%d, num_plane=%d", __func__, buf_index, num_plane);
return -1;
}
@@ -159,24 +159,24 @@
buf.m.planes = planes;
if (ioctl(fd, VIDIOC_QUERYBUF, &buf) < 0) {
- LOGE("%s::VIDIOC_QUERYBUF failed, plane_cnt=%d", __func__, buf.length);
+ ALOGE("%s::VIDIOC_QUERYBUF failed, plane_cnt=%d", __func__, buf.length);
return -1;
}
for (int i = 0; i < num_plane; i++) {
if ((secBuf->virt.extP[i] = (char *)mmap(0, buf.m.planes[i].length,
PROT_READ | PROT_WRITE, MAP_SHARED, fd, buf.m.planes[i].m.mem_offset)) < 0) {
- LOGE("%s::mmap failed", __func__);
- LOGE("%s::Offset = 0x%x", __func__, buf.m.planes[i].m.mem_offset);
- LOGE("%s::Legnth = %d" , __func__, buf.m.planes[i].length);
- LOGE("%s::vaddr[%d][%d] = 0x%x", __func__, buf_index, i, (unsigned int)secBuf->virt.extP[i]);
+ ALOGE("%s::mmap failed", __func__);
+ ALOGE("%s::Offset = 0x%x", __func__, buf.m.planes[i].m.mem_offset);
+ ALOGE("%s::Legnth = %d" , __func__, buf.m.planes[i].length);
+ ALOGE("%s::vaddr[%d][%d] = 0x%x", __func__, buf_index, i, (unsigned int)secBuf->virt.extP[i]);
return -1;
}
secBuf->size.extS[i] = buf.m.planes[i].length;
#ifdef DEBUG_LIB_FIMC
- LOGD("%s::vaddr[bufindex=%d][planeindex=%d] = 0x%x", __func__, buf_index, i, (unsigned int)secBuf->virt.extP[i]);
- LOGD("%s::Legnth = %d" , __func__, buf.m.planes[i].length);
+ ALOGD("%s::vaddr[bufindex=%d][planeindex=%d] = 0x%x", __func__, buf_index, i, (unsigned int)secBuf->virt.extP[i]);
+ ALOGD("%s::Legnth = %d" , __func__, buf.m.planes[i].length);
#endif
}
@@ -186,7 +186,7 @@
int gsc_v4l2_req_buf(int fd, enum v4l2_buf_type type, enum v4l2_memory memory, unsigned int num_bufs)
{
#ifdef DEBUG_LIB_FIMC
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
struct v4l2_requestbuffers reqbuf;
@@ -195,20 +195,20 @@
reqbuf.count = num_bufs;
#ifdef DEBUG_LIB_FIMC
- LOGI("%d buffers needed", reqbuf.count);
+ ALOGI("%d buffers needed", reqbuf.count);
#endif
if (ioctl(fd, VIDIOC_REQBUFS, &reqbuf) < 0) {
- LOGE("%s::VIDIOC_REQBUFS failed, reqbuf.count=%d", __func__, reqbuf.count);
+ ALOGE("%s::VIDIOC_REQBUFS failed, reqbuf.count=%d", __func__, reqbuf.count);
return -1;
}
#ifdef DEBUG_LIB_FIMC
- LOGI("%d buffers allocated", reqbuf.count);
+ ALOGI("%d buffers allocated", reqbuf.count);
#endif
if (reqbuf.count < num_bufs) {
- LOGE("%s::VIDIOC_REQBUFS failed ((reqbuf.count(%d) < num_bufs(%d))",
+ ALOGE("%s::VIDIOC_REQBUFS failed ((reqbuf.count(%d) < num_bufs(%d))",
__func__, reqbuf.count, num_bufs);
return -1;
}
@@ -219,7 +219,7 @@
int gsc_v4l2_s_ctrl(int fd, int id, int value)
{
#ifdef DEBUG_LIB_FIMC
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
struct v4l2_control vc;
@@ -227,7 +227,7 @@
vc.value = value;
if (ioctl(fd, VIDIOC_S_CTRL, &vc) < 0) {
- LOGE("%s::VIDIOC_S_CTRL (id=%d,value=%d) failed", __func__, id, value);
+ ALOGE("%s::VIDIOC_S_CTRL (id=%d,value=%d) failed", __func__, id, value);
return -1;
}
@@ -237,17 +237,17 @@
int gsc_v4l2_set_fmt(int fd, enum v4l2_buf_type type, enum v4l2_field field, s5p_fimc_img_info *img_info)
{
#ifdef DEBUG_LIB_FIMC
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
struct v4l2_format fmt;
struct v4l2_crop crop;
fmt.type = type;
#ifdef DEBUG_LIB_FIMC
- LOGD("%s::fmt.type=%d", __func__, fmt.type);
+ ALOGD("%s::fmt.type=%d", __func__, fmt.type);
#endif
if (ioctl(fd, VIDIOC_G_FMT, &fmt) < 0) {
- LOGE("%s::VIDIOC_G_FMT failed", __func__);
+ ALOGE("%s::VIDIOC_G_FMT failed", __func__);
return -1;
}
@@ -268,14 +268,14 @@
fmt.fmt.pix_mp.num_planes = img_info->planes;
break;
default:
- LOGE("%s::invalid buffer type", __func__);
+ ALOGE("%s::invalid buffer type", __func__);
return -1;
break;
}
#ifdef DEBUG_LIB_FIMC
for (int i = 0; i < 3; i++) {
- LOGD("%s::fmt.fmt.pix_mp. w=%d, h=%d, pixelformat=0x%08x, filed=%d, num_planes=%d",
+ ALOGD("%s::fmt.fmt.pix_mp. w=%d, h=%d, pixelformat=0x%08x, filed=%d, num_planes=%d",
__func__,
fmt.fmt.pix_mp.width, fmt.fmt.pix_mp.height,
fmt.fmt.pix_mp.pixelformat, fmt.fmt.pix_mp.field,
@@ -284,14 +284,14 @@
#endif
if (ioctl(fd, VIDIOC_S_FMT, &fmt) < 0) {
- LOGE("%s::VIDIOC_S_FMT failed", __func__);
+ ALOGE("%s::VIDIOC_S_FMT failed", __func__);
return -1;
}
#ifdef DEBUG_LIB_FIMC
for (int i = 0; i < 3; i++) {
- LOGD("%s::pix_mp.pix_mp.plane_fmt[%d].sizeimage =0x%08x", __func__, i, fmt.fmt.pix_mp.plane_fmt[i].sizeimage);
- LOGD("%s::pix_mp.pix_mp.plane_fmt[%d].bytesperline=0x%08x", __func__, i, fmt.fmt.pix_mp.plane_fmt[i].bytesperline);
+ ALOGD("%s::pix_mp.pix_mp.plane_fmt[%d].sizeimage =0x%08x", __func__, i, fmt.fmt.pix_mp.plane_fmt[i].sizeimage);
+ ALOGD("%s::pix_mp.pix_mp.plane_fmt[%d].bytesperline=0x%08x", __func__, i, fmt.fmt.pix_mp.plane_fmt[i].bytesperline);
}
#endif
@@ -302,7 +302,7 @@
crop.c.height = img_info->height;
if (ioctl(fd, VIDIOC_S_CROP, &crop) < 0) {
- LOGE("%s::VIDIOC_S_CROP (x=%d, y=%d, w=%d, h=%d) failed",
+ ALOGE("%s::VIDIOC_S_CROP (x=%d, y=%d, w=%d, h=%d) failed",
__func__,
img_info->start_x,
img_info->start_y,
@@ -312,9 +312,9 @@
}
#ifdef DEBUG_LIB_FIMC
- LOGD("%s::pix_mp pixelformat=0x%08x", __func__, fmt.fmt.pix_mp.pixelformat);
- LOGD("%s::pix_mp w=%d, h=%d, planes=%d", __func__, fmt.fmt.pix_mp.width, fmt.fmt.pix_mp.height, fmt.fmt.pix_mp.num_planes);
- LOGD("%s::crop x=%d, y=%d, w=%d, h=%d", __func__, crop.c.left, crop.c.top, crop.c.width, crop.c.height);
+ ALOGD("%s::pix_mp pixelformat=0x%08x", __func__, fmt.fmt.pix_mp.pixelformat);
+ ALOGD("%s::pix_mp w=%d, h=%d, planes=%d", __func__, fmt.fmt.pix_mp.width, fmt.fmt.pix_mp.height, fmt.fmt.pix_mp.num_planes);
+ ALOGD("%s::crop x=%d, y=%d, w=%d, h=%d", __func__, crop.c.left, crop.c.top, crop.c.width, crop.c.height);
#endif
return 0;
@@ -323,10 +323,10 @@
int gsc_v4l2_stream_on(int fd, enum v4l2_buf_type type)
{
#ifdef DEBUG_LIB_FIMC
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
if (ioctl(fd, VIDIOC_STREAMON, &type) < 0) {
- LOGE("%s::VIDIOC_STREAMON failed", __func__);
+ ALOGE("%s::VIDIOC_STREAMON failed", __func__);
return -1;
}
@@ -336,8 +336,8 @@
int gsc_v4l2_queue(int fd, SecBuffer *secBuf, enum v4l2_buf_type type, enum v4l2_memory memory, unsigned int index, int num_plane)
{
#ifdef DEBUG_LIB_FIMC
- LOGD("%s", __func__);
- LOGD("%s::num_plane=%d", __func__, num_plane);
+ ALOGD("%s", __func__);
+ ALOGD("%s::num_plane=%d", __func__, num_plane);
#endif
struct v4l2_buffer buf;
struct v4l2_plane planes[MAX_PLANES_GSCALER];
@@ -358,15 +358,15 @@
buf.m.planes[i].length = secBuf->size.extS[i];
buf.m.planes[i].bytesused = buf.m.planes[i].length;
#ifdef DEBUG_LIB_FIMC
- LOGD("%s::buf.index=%d", __func__, buf.index);
- LOGD("%s::buf.m.planes[%d].m.userptr=0x%08x", __func__, i, (unsigned int)buf.m.planes[i].m.userptr);
- LOGD("%s::buf.m.planes[%d].length =0x%08x", __func__, i, buf.m.planes[i].length);
- LOGD("%s::buf.m.planes[%d].bytesused=0x%08x", __func__, i, buf.m.planes[i].bytesused);
+ ALOGD("%s::buf.index=%d", __func__, buf.index);
+ ALOGD("%s::buf.m.planes[%d].m.userptr=0x%08x", __func__, i, (unsigned int)buf.m.planes[i].m.userptr);
+ ALOGD("%s::buf.m.planes[%d].length =0x%08x", __func__, i, buf.m.planes[i].length);
+ ALOGD("%s::buf.m.planes[%d].bytesused=0x%08x", __func__, i, buf.m.planes[i].bytesused);
#endif
}
if (ioctl(fd, VIDIOC_QBUF, &buf) < 0) {
- LOGE("%s::VIDIOC_QBUF failed", __func__);
+ ALOGE("%s::VIDIOC_QBUF failed", __func__);
return -1;
}
@@ -376,7 +376,7 @@
int gsc_v4l2_dequeue(int fd, enum v4l2_buf_type type, enum v4l2_memory memory, unsigned int *index, int num_plane)
{
#ifdef DEBUG_LIB_FIMC
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
struct v4l2_buffer buf;
struct v4l2_plane planes[MAX_PLANES_GSCALER];
@@ -393,14 +393,14 @@
buf.m.planes = planes;
if (ioctl(fd, VIDIOC_DQBUF, &buf) < 0) {
- LOGE("%s::VIDIOC_DQBUF failed", __func__);
+ ALOGE("%s::VIDIOC_DQBUF failed", __func__);
return -1;
}
*index = buf.index;
#ifdef DEBUG_LIB_FIMC
- LOGD("%s::buf.index=%d", __func__, buf.index);
+ ALOGD("%s::buf.index=%d", __func__, buf.index);
#endif
return 0;
@@ -409,10 +409,10 @@
int gsc_v4l2_stream_off(int fd, enum v4l2_buf_type type)
{
#ifdef DEBUG_LIB_FIMC
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
if (ioctl(fd, VIDIOC_STREAMOFF, &type) < 0) {
- LOGE("%s::VIDIOC_STREAMOFF failed", __func__);
+ ALOGE("%s::VIDIOC_STREAMOFF failed", __func__);
return -1;
}
@@ -422,7 +422,7 @@
int gsc_v4l2_clr_buf(int fd, enum v4l2_buf_type type, enum v4l2_memory memory)
{
#ifdef DEBUG_LIB_FIMC
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
struct v4l2_requestbuffers req;
@@ -431,7 +431,7 @@
req.memory = memory;
if (ioctl(fd, VIDIOC_REQBUFS, &req) < 0) {
- LOGE("%s::VIDIOC_REQBUFS failed", __func__);
+ ALOGE("%s::VIDIOC_REQBUFS failed", __func__);
return -1;
}
@@ -441,7 +441,7 @@
int gsc_subdev_set_fmt(int fd, unsigned int pad, enum v4l2_mbus_pixelcode code, s5p_fimc_img_info *img_info)
{
#ifdef DEBUG_LIB_FIMC
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
struct v4l2_subdev_format fmt;
struct v4l2_subdev_crop crop;
@@ -453,7 +453,7 @@
fmt.format.code = code;
if (ioctl(fd, VIDIOC_SUBDEV_S_FMT, &fmt) < 0) {
- LOGE("%s::VIDIOC_SUBDEV_S_FMT failed", __func__);
+ ALOGE("%s::VIDIOC_SUBDEV_S_FMT failed", __func__);
return -1;
}
@@ -465,12 +465,12 @@
crop.rect.height = img_info->height;
#ifdef DEBUG_LIB_FIMC
- LOGD("%s::pix_mp w=%d, h=%d", __func__, fmt.format.width, fmt.format.height);
- LOGD("%s::crop x=%d, y=%d, w=%d, h=%d", __func__, crop.rect.left, crop.rect.top, crop.rect.width, crop.rect.height);
+ ALOGD("%s::pix_mp w=%d, h=%d", __func__, fmt.format.width, fmt.format.height);
+ ALOGD("%s::crop x=%d, y=%d, w=%d, h=%d", __func__, crop.rect.left, crop.rect.top, crop.rect.width, crop.rect.height);
#endif
if (ioctl(fd, VIDIOC_SUBDEV_S_CROP, &crop) < 0) {
- LOGE("%s::VIDIOC_SUBDEV_S_CROP failed", __func__);
+ ALOGE("%s::VIDIOC_SUBDEV_S_CROP failed", __func__);
return -1;
}
@@ -507,10 +507,10 @@
SecGscaler::~SecGscaler()
{
if (mFlagCreate == true) {
- LOGE("%s::this is not Destroyed fail", __func__);
+ ALOGE("%s::this is not Destroyed fail", __func__);
if (destroy() == false)
- LOGE("%s::destroy failed", __func__);
+ ALOGE("%s::destroy failed", __func__);
}
}
@@ -523,10 +523,10 @@
bool SecGscaler::create(enum DEV dev, unsigned int numOfBuf)
{
#ifdef DEBUG_LIB_FIMC
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
if (mFlagCreate == true) {
- LOGE("%s::Already Created", __func__);
+ ALOGE("%s::Already Created", __func__);
return true;
}
@@ -576,7 +576,7 @@
mSubdevNodeNum = 3; // need to modify //carrotsm
break;
default:
- LOGE("%s::invalid mDev(%d)", __func__, mDev);
+ ALOGE("%s::invalid mDev(%d)", __func__, mDev);
goto err;
break;
}
@@ -585,7 +585,7 @@
mMediadevFd = open(node, O_RDONLY);
if (mMediadevFd < 0) {
- LOGE("%s::open(%s) failed : O_RDONLY", __func__, node);
+ ALOGE("%s::open(%s) failed : O_RDONLY", __func__, node);
goto err;
}
@@ -597,15 +597,15 @@
if (ioctl(mMediadevFd, MEDIA_IOC_ENUM_ENTITIES, &entity_desc) < 0) {
if (errno == EINVAL) {
- LOGD("%s::MEDIA_IOC_ENUM_ENTITIES ended", __func__);
+ ALOGD("%s::MEDIA_IOC_ENUM_ENTITIES ended", __func__);
break;
}
- LOGE("%s::MEDIA_IOC_ENUM_ENTITIES failed", __func__);
+ ALOGE("%s::MEDIA_IOC_ENUM_ENTITIES failed", __func__);
goto err;
}
#ifdef DEBUG_LIB_FIMC
- LOGD("%s::entity_desc.id=%d, .minor=%d .name=%s", __func__, entity_desc.id, entity_desc.v4l.minor, entity_desc.name);
+ ALOGD("%s::entity_desc.id=%d, .minor=%d .name=%s", __func__, entity_desc.id, entity_desc.v4l.minor, entity_desc.name);
#endif
if (strncmp(entity_desc.name, subdevname, strlen(subdevname)) == 0)
@@ -622,20 +622,20 @@
sprintf(node, "%s%d", PFX_NODE_SUBDEV, mSubdevNodeNum);
mSubdevFd = open(node, O_RDWR);
if (mSubdevFd < 0) {
- LOGE("%s::open(%s) failed", __func__, node);
+ ALOGE("%s::open(%s) failed", __func__, node);
goto err;
}
sprintf(node, "%s%d", PFX_NODE_VIDEODEV, mVideoNodeNum);
mVideodevFd = open(node, O_RDWR);
if (mVideodevFd < 0) {
- LOGE("%s::open(%s) failed", __func__, node);
+ ALOGE("%s::open(%s) failed", __func__, node);
goto err;
}
/* check capability */
if (gsc_v4l2_querycap(mVideodevFd, node) < 0 ) {
- LOGE("%s::tvout_std_v4l2_querycap failed", __func__);
+ ALOGE("%s::tvout_std_v4l2_querycap failed", __func__);
goto err;
}
@@ -665,18 +665,18 @@
s5p_fimc_params_t *params = &(mS5pFimc.params);
if (mFlagCreate == false) {
- LOGE("%s::Already Destroyed", __func__);
+ ALOGE("%s::Already Destroyed", __func__);
return true;
}
if (mFlagStreamOn == true) {
if (streamOff() == false) {
- LOGE("%s::streamOff() failed", __func__);
+ ALOGE("%s::streamOff() failed", __func__);
return false;
}
if (closeVideodevFd() == false) {
- LOGE("%s::closeVideodevFd() failed", __func__);
+ ALOGE("%s::closeVideodevFd() failed", __func__);
return false;
}
@@ -720,7 +720,7 @@
sprintf(node, "%s%d", PFX_NODE_VIDEODEV, mVideoNodeNum);
mVideodevFd = open(node, O_RDWR);
if (mVideodevFd < 0) {
- LOGE("%s::open(%s) failed", __func__, node);
+ ALOGE("%s::open(%s) failed", __func__, node);
return false;
}
@@ -731,14 +731,14 @@
{
if (mFlagSetSrcParam == true) {
if (gsc_v4l2_clr_buf(mVideodevFd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_MEMORY_TYPE) < 0) {
- LOGE("%s::gsc_v4l2_clr_buf() failed", __func__);
+ ALOGE("%s::gsc_v4l2_clr_buf() failed", __func__);
return false;
}
}
if (0 < mVideodevFd) {
if (close(mVideodevFd) < 0) {
- LOGE("%s::close Videodev failed", __func__);
+ ALOGE("%s::close Videodev failed", __func__);
return false;
}
}
@@ -770,7 +770,7 @@
SecBuffer * SecGscaler::getSrcBufferAddr(int index)
{
if (mFlagCreate == false) {
- LOGE("%s::Not yet created", __func__);
+ ALOGE("%s::Not yet created", __func__);
return false;
}
@@ -784,17 +784,17 @@
bool forceChange)
{
#ifdef DEBUG_LIB_FIMC
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
if (mFlagCreate == false) {
- LOGE("%s::Not yet created", __func__);
+ ALOGE("%s::Not yet created", __func__);
return false;
}
int v4l2ColorFormat = HAL_PIXEL_FORMAT_2_V4L2_PIX(colorFormat);
if (v4l2ColorFormat < 0) {
- LOGE("%s::not supported color format", __func__);
+ ALOGE("%s::not supported color format", __func__);
return false;
}
@@ -809,18 +809,18 @@
if (m_checkSrcSize(width, height, cropX, cropY,
&fimcWidth, &fimcHeight, v4l2ColorFormat, false) == false) {
- LOGE("%s::::size align error!", __func__);
+ ALOGE("%s::::size align error!", __func__);
return false;
}
if (fimcWidth != *cropWidth || fimcHeight != *cropHeight) {
if (forceChange == true) {
#ifdef DEBUG_LIB_FIMC
- LOGD("size is changed from [w=%d, h=%d] to [w=%d, h=%d]",
+ ALOGD("size is changed from [w=%d, h=%d] to [w=%d, h=%d]",
*cropWidth, *cropHeight, fimcWidth, fimcHeight);
#endif
} else {
- LOGE("%s::invalid source params", __func__);
+ ALOGE("%s::invalid source params", __func__);
return false;
}
}
@@ -874,7 +874,7 @@
mSrcBuffer[buf_index].size.extS[0] = (frame_size * 3) >> 1;
break;
default:
- LOGE("%s::invalid color type", __func__);
+ ALOGE("%s::invalid color type", __func__);
return false;
break;
}
@@ -888,7 +888,7 @@
mSrcBuffer[buf_index].size.extS[2] = frame_size / frame_ratio;
break;
default:
- LOGE("%s::invalid color foarmt", __func__);
+ ALOGE("%s::invalid color foarmt", __func__);
return false;
break;
}
@@ -900,25 +900,25 @@
if (mFlagSetSrcParam == true) {
if (gsc_v4l2_clr_buf(mVideodevFd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_MEMORY_TYPE) < 0) {
- LOGE("%s::gsc_v4l2_clr_buf() failed", __func__);
+ ALOGE("%s::gsc_v4l2_clr_buf() failed", __func__);
return false;
}
}
if (gsc_v4l2_set_fmt(mVideodevFd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_FIELD_NONE, &(params->src)) < 0) {
- LOGE("%s::fimc_v4l2_set_fmt()[src] failed", __func__);
+ ALOGE("%s::fimc_v4l2_set_fmt()[src] failed", __func__);
return false;
}
if (gsc_v4l2_req_buf(mVideodevFd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_MEMORY_TYPE, mNumOfBuf) < 0) {
- LOGE("%s::fimc_v4l2_req_buf()[src] failed", __func__);
+ ALOGE("%s::fimc_v4l2_req_buf()[src] failed", __func__);
return false;
}
#ifdef USE_GSC_USERPTR
#else
for (unsigned int buf_index = 0; buf_index < MAX_BUFFERS_GSCALER; buf_index++) {
if (gsc_v4l2_query_buf(mVideodevFd, &mSrcBuffer[buf_index], V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_MEMORY_MMAP, buf_index, params->src.planes) < 0) {
- LOGE("%s::gsc_v4l2_query_buf() failed", __func__);
+ ALOGE("%s::gsc_v4l2_query_buf() failed", __func__);
return false;
}
}
@@ -943,7 +943,7 @@
fmt.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
if (ioctl(mVideodevFd, VIDIOC_G_FMT, &fmt) < 0) {
- LOGE("%s::VIDIOC_G_FMT(fmt.type : %d) failed", __func__, fmt.type);
+ ALOGE("%s::VIDIOC_G_FMT(fmt.type : %d) failed", __func__, fmt.type);
return false;
}
@@ -962,14 +962,14 @@
*v4l2colorFormat = fmt.fmt.pix_mp.pixelformat;
break;
default:
- LOGE("%s::Invalid buffer type", __func__);
+ ALOGE("%s::Invalid buffer type", __func__);
return false;
break;
}
crop.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
if (ioctl(mVideodevFd, VIDIOC_G_CROP, &crop) < 0) {
- LOGE("%s::VIDIOC_G_CROP failed", __func__);
+ ALOGE("%s::VIDIOC_G_CROP failed", __func__);
return false;
}
@@ -987,16 +987,16 @@
int colorFormat)
{
#ifdef DEBUG_LIB_FIMC
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
if (mFlagCreate == false) {
- LOGE("%s::Not yet created", __func__);
+ ALOGE("%s::Not yet created", __func__);
return false;
}
if (mFlagSetSrcParam == false) {
- LOGE("%s::mFlagSetSrcParam == false", __func__);
+ ALOGE("%s::mFlagSetSrcParam == false", __func__);
return false;
}
@@ -1026,11 +1026,11 @@
bool forceChange)
{
#ifdef DEBUG_LIB_FIMC
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
if (mFlagCreate == false) {
- LOGE("%s::Not yet created", __func__);
+ ALOGE("%s::Not yet created", __func__);
return false;
}
@@ -1044,7 +1044,7 @@
if( m_checkDstSize(width, height, cropX, cropY,
&fimcWidth, &fimcHeight, V4L2_PIX_FMT_YUV444,
mRotVal, true) == false) {
- LOGE("%s::size align error!", __func__);
+ ALOGE("%s::size align error!", __func__);
return false;
}
@@ -1052,11 +1052,11 @@
if (fimcWidth != *cropWidth || fimcHeight != *cropHeight) {
if (forceChange == true) {
#ifdef DEBUG_LIB_FIMC
- LOGD("size is changed from [w = %d, h= %d] to [w = %d, h = %d]",
+ ALOGD("size is changed from [w = %d, h= %d] to [w = %d, h = %d]",
*cropWidth, *cropHeight, fimcWidth, fimcHeight);
#endif
} else {
- LOGE("%s::Invalid destination params", __func__);
+ ALOGE("%s::Invalid destination params", __func__);
return false;
}
}
@@ -1095,7 +1095,7 @@
}
if (gsc_subdev_set_fmt(mSubdevFd, GSC_SUBDEV_PAD_SOURCE, V4L2_MBUS_FMT_YUV8_1X24, &(params->dst)) < 0) {
- LOGE("%s::gsc_subdev_set_fmt()[dst] failed", __func__);
+ ALOGE("%s::gsc_subdev_set_fmt()[dst] failed", __func__);
return false;
}
@@ -1116,7 +1116,7 @@
fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
if (ioctl(mSubdevFd, VIDIOC_SUBDEV_G_FMT, &fmt) < 0) {
- LOGE("%s::VIDIOC_SUBDEV_S_FMT", __func__);
+ ALOGE("%s::VIDIOC_SUBDEV_S_FMT", __func__);
return -1;
}
@@ -1128,7 +1128,7 @@
crop.which = V4L2_SUBDEV_FORMAT_ACTIVE;
if (ioctl(mSubdevFd, VIDIOC_SUBDEV_G_CROP, &crop) < 0) {
- LOGE("%s::VIDIOC_SUBDEV_S_CROP", __func__);
+ ALOGE("%s::VIDIOC_SUBDEV_S_CROP", __func__);
return -1;
}
@@ -1143,11 +1143,11 @@
bool SecGscaler::setDstAddr(unsigned int YAddr, unsigned int CbAddr, unsigned int CrAddr, int buf_index)
{
#ifdef DEBUG_LIB_FIMC
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
if (mFlagCreate == false) {
- LOGE("%s::Not yet created", __func__);
+ ALOGE("%s::Not yet created", __func__);
return false;
}
@@ -1159,12 +1159,12 @@
struct v4l2_control vc;
if (mFlagCreate == false) {
- LOGE("%s::Not yet created", __func__);
+ ALOGE("%s::Not yet created", __func__);
return false;
}
if (gsc_v4l2_s_ctrl(mVideodevFd, V4L2_CID_ROTATE, rotVal) < 0) {
- LOGE("%s::fimc_v4l2_s_ctrl(V4L2_CID_ROTATE) failed", __func__);
+ ALOGE("%s::fimc_v4l2_s_ctrl(V4L2_CID_ROTATE) failed", __func__);
return false;
}
@@ -1175,12 +1175,12 @@
bool SecGscaler::setGlobalAlpha(bool enable, int alpha)
{
if (mFlagCreate == false) {
- LOGE("%s::Not yet created", __func__);
+ ALOGE("%s::Not yet created", __func__);
return false;
}
if (mFlagStreamOn == true) {
- LOGE("%s::mFlagStreamOn == true", __func__);
+ ALOGE("%s::mFlagStreamOn == true", __func__);
return false;
}
@@ -1194,12 +1194,12 @@
bool SecGscaler::setLocalAlpha(bool enable)
{
if (mFlagCreate == false) {
- LOGE("%s::Not yet created", __func__);
+ ALOGE("%s::Not yet created", __func__);
return false;
}
if (mFlagStreamOn == true) {
- LOGE("%s::mFlagStreamOn == true", __func__);
+ ALOGE("%s::mFlagStreamOn == true", __func__);
return false;
}
@@ -1212,12 +1212,12 @@
bool SecGscaler::setColorKey(bool enable, int colorKey)
{
if (mFlagCreate == false) {
- LOGE("%s::Not yet created", __func__);
+ ALOGE("%s::Not yet created", __func__);
return false;
}
if (mFlagStreamOn == true) {
- LOGE("%s::mFlagStreamOn == true", __func__);
+ ALOGE("%s::mFlagStreamOn == true", __func__);
return false;
}
@@ -1230,21 +1230,21 @@
bool SecGscaler::run()
{
#ifdef DEBUG_LIB_FIMC
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
if (mFlagCreate == false) {
- LOGE("%s::Not yet created", __func__);
+ ALOGE("%s::Not yet created", __func__);
return false;
}
if (mFlagSetSrcParam == false) {
- LOGE("%s::faild : Need to set source parameters of Gscaler", __func__);
+ ALOGE("%s::faild : Need to set source parameters of Gscaler", __func__);
return false;
}
if (mFlagSetDstParam == false) {
- LOGE("%s::faild : Need to set destination parameters of Gscaler", __func__);
+ ALOGE("%s::faild : Need to set destination parameters of Gscaler", __func__);
return false;
}
@@ -1254,7 +1254,7 @@
src_planes = (src_planes == -1) ? 1 : src_planes;
if (gsc_v4l2_queue(mVideodevFd, &(mSrcBuffer[mSrcIndex]), V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_MEMORY_TYPE, mSrcIndex, src_planes) < 0) {
- LOGE("%s::fimc_v4l2_queue[src](mNumOfBuf : %d,mSrcIndex=%d) failed", __func__, mNumOfBuf, mSrcIndex);
+ ALOGE("%s::fimc_v4l2_queue[src](mNumOfBuf : %d,mSrcIndex=%d) failed", __func__, mNumOfBuf, mSrcIndex);
return false;
}
@@ -1264,7 +1264,7 @@
}
if (gsc_v4l2_dequeue(mVideodevFd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_MEMORY_TYPE, &dqIndex, src_planes) < 0) {
- LOGE("%s::fimc_v4l2_dequeue[src](mNumOfBuf : %d, dqIndex=%d) failed", __func__, mNumOfBuf, dqIndex);
+ ALOGE("%s::fimc_v4l2_dequeue[src](mNumOfBuf : %d, dqIndex=%d) failed", __func__, mNumOfBuf, dqIndex);
return false;
}
@@ -1274,16 +1274,16 @@
bool SecGscaler::streamOn(void)
{
#ifdef DEBUG_LIB_FIMC
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
if (mFlagCreate == false) {
- LOGE("%s::Not yet created", __func__);
+ ALOGE("%s::Not yet created", __func__);
return false;
}
if (mFlagStreamOn == true) {
- LOGE("%s::already streamon", __func__);
+ ALOGE("%s::already streamon", __func__);
return true;
}
@@ -1292,14 +1292,14 @@
src_planes = (src_planes == -1) ? 1 : src_planes;
if (gsc_v4l2_queue(mVideodevFd, &(mSrcBuffer[mSrcIndex]), V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_MEMORY_TYPE, mSrcIndex, src_planes) < 0) {
- LOGE("%s::fimc_v4l2_queue[src](mNumOfBuf : %d,mSrcIndex=%d) failed", __func__, mNumOfBuf, mSrcIndex);
+ ALOGE("%s::fimc_v4l2_queue[src](mNumOfBuf : %d,mSrcIndex=%d) failed", __func__, mNumOfBuf, mSrcIndex);
return false;
}
mSrcIndex++;
if (mSrcIndex == MAX_BUFFERS_GSCALER - 1) {
if (gsc_v4l2_stream_on(mVideodevFd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) < 0) {
- LOGE("%s::fimc_v4l2_stream_on() failed", __func__);
+ ALOGE("%s::fimc_v4l2_stream_on() failed", __func__);
return false;
}
mFlagStreamOn = true;
@@ -1315,21 +1315,21 @@
bool SecGscaler::streamOff(void)
{
#ifdef DEBUG_LIB_FIMC
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
if (mFlagCreate == false) {
- LOGE("%s::Not yet created", __func__);
+ ALOGE("%s::Not yet created", __func__);
return false;
}
if (mFlagStreamOn == false) {
- LOGE("%s::already streamoff", __func__);
+ ALOGE("%s::already streamoff", __func__);
return true;
}
if (gsc_v4l2_stream_off(mVideodevFd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) < 0) {
- LOGE("%s::fimc_v4l2_stream_off() failed", __func__);
+ ALOGE("%s::fimc_v4l2_stream_off() failed", __func__);
return false;
}
diff --git a/exynos5/hal/libhdmi/SecHdmi/SecHdmi.cpp b/exynos5/hal/libhdmi/SecHdmi/SecHdmi.cpp
index 8f0f80b..8c0970b 100644
--- a/exynos5/hal/libhdmi/SecHdmi/SecHdmi.cpp
+++ b/exynos5/hal/libhdmi/SecHdmi/SecHdmi.cpp
@@ -15,8 +15,8 @@
*/
//#define DEBUG_MSG_ENABLE
-//#define LOG_NDEBUG 0
-//#define LOG_TAG "libhdmi"
+//#define ALOG_NDEBUG 0
+//#define ALOG_TAG "libhdmi"
#include <cutils/log.h>
#include "ion.h"
#include "SecHdmi.h"
@@ -42,7 +42,7 @@
SecHdmi::CECThread::~CECThread()
{
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
mFlagRunning = false;
}
@@ -74,18 +74,18 @@
opcode = buffer[1];
if (CECIgnoreMessage(opcode, lsrc)) {
- LOGE("### ignore message coming from address 15 (unregistered)\n");
+ ALOGE("### ignore message coming from address 15 (unregistered)\n");
return true;
}
if (!CECCheckMessageSize(opcode, size)) {
- LOGE("### invalid message size: %d(opcode: 0x%x) ###\n", size, opcode);
+ ALOGE("### invalid message size: %d(opcode: 0x%x) ###\n", size, opcode);
return true;
}
/* check if message broadcasted/directly addressed */
if (!CECCheckMessageMode(opcode, (buffer[0] & 0x0F) == CEC_MSG_BROADCAST ? 1 : 0)) {
- LOGE("### invalid message mode (directly addressed/broadcast) ###\n");
+ ALOGE("### invalid message mode (directly addressed/broadcast) ###\n");
return true;
}
@@ -106,14 +106,14 @@
break;
case CEC_OPCODE_REQUEST_ACTIVE_SOURCE:
- LOGD("[CEC_OPCODE_REQUEST_ACTIVE_SOURCE]\n");
+ ALOGD("[CEC_OPCODE_REQUEST_ACTIVE_SOURCE]\n");
/* responce with "Active Source" */
buffer[0] = (mLaddr << 4) | CEC_MSG_BROADCAST;
buffer[1] = CEC_OPCODE_ACTIVE_SOURCE;
buffer[2] = (mPaddr >> 8) & 0xFF;
buffer[3] = mPaddr & 0xFF;
size = 4;
- LOGD("Tx : [CEC_OPCODE_ACTIVE_SOURCE]\n");
+ ALOGD("Tx : [CEC_OPCODE_ACTIVE_SOURCE]\n");
break;
case CEC_OPCODE_ABORT:
@@ -129,7 +129,7 @@
}
if (CECSendMessage(buffer, size) != size)
- LOGE("CECSendMessage() failed!!!\n");
+ ALOGE("CECSendMessage() failed!!!\n");
}
return true;
@@ -138,33 +138,33 @@
bool SecHdmi::CECThread::start()
{
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
Mutex::Autolock lock(mThreadControlLock);
if (exitPending()) {
if (requestExitAndWait() == WOULD_BLOCK) {
- LOGE("mCECThread.requestExitAndWait() == WOULD_BLOCK");
+ ALOGE("mCECThread.requestExitAndWait() == WOULD_BLOCK");
return false;
}
}
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("EDIDGetCECPhysicalAddress");
+ ALOGD("EDIDGetCECPhysicalAddress");
#endif
/* set to not valid physical address */
mPaddr = CEC_NOT_VALID_PHYSICAL_ADDRESS;
if (!EDIDGetCECPhysicalAddress(&mPaddr)) {
- LOGE("Error: EDIDGetCECPhysicalAddress() failed.\n");
+ ALOGE("Error: EDIDGetCECPhysicalAddress() failed.\n");
return false;
}
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("CECOpen");
+ ALOGD("CECOpen");
#endif
if (!CECOpen()) {
- LOGE("CECOpen() failed!!!\n");
+ ALOGE("CECOpen() failed!!!\n");
return false;
}
@@ -178,24 +178,24 @@
*/
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("CECAllocLogicalAddress");
+ ALOGD("CECAllocLogicalAddress");
#endif
mLaddr = CECAllocLogicalAddress(mPaddr, mDevtype);
if (!mLaddr) {
- LOGE("CECAllocLogicalAddress() failed!!!\n");
+ ALOGE("CECAllocLogicalAddress() failed!!!\n");
if (!CECClose())
- LOGE("CECClose() failed!\n");
+ ALOGE("CECClose() failed!\n");
return false;
}
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("request to run CECThread");
+ ALOGD("request to run CECThread");
#endif
status_t ret = run("SecHdmi::CECThread", PRIORITY_DISPLAY);
if (ret != NO_ERROR) {
- LOGE("%s fail to run thread", __func__);
+ ALOGE("%s fail to run thread", __func__);
return false;
}
return true;
@@ -204,16 +204,16 @@
bool SecHdmi::CECThread::stop()
{
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s request Exit", __func__);
+ ALOGD("%s request Exit", __func__);
#endif
Mutex::Autolock lock(mThreadControlLock);
if (requestExitAndWait() == WOULD_BLOCK) {
- LOGE("mCECThread.requestExitAndWait() == WOULD_BLOCK");
+ ALOGE("mCECThread.requestExitAndWait() == WOULD_BLOCK");
return false;
}
if (!CECClose())
- LOGE("CECClose() failed!\n");
+ ALOGE("CECClose() failed!\n");
mFlagRunning = false;
return true;
@@ -264,7 +264,7 @@
mDisplayHeight(DEFALULT_DISPLAY_HEIGHT)
{
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
for (int i = 0; i < HDMI_LAYER_MAX; i++) {
mFlagLayerEnable[i] = false;
@@ -311,10 +311,10 @@
SecHdmi::~SecHdmi()
{
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
if (mFlagCreate == true)
- LOGE("%s::this is not Destroyed fail", __func__);
+ ALOGE("%s::this is not Destroyed fail", __func__);
else
disconnect();
}
@@ -352,36 +352,36 @@
#endif
#ifdef DEBUG_MSG_ENABLE
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
if (mFlagCreate == true) {
- LOGE("%s::Already Created", __func__);
+ ALOGE("%s::Already Created", __func__);
return true;
}
if (mDefaultFBFd <= 0) {
if ((mDefaultFBFd = fb_open(DEFAULT_FB)) < 0) {
- LOGE("%s:Failed to open default FB", __func__);
+ ALOGE("%s:Failed to open default FB", __func__);
return false;
}
}
if (mSecGscaler.create(SecGscaler::DEV_3, MAX_BUFFERS_GSCALER) == false) {
- LOGE("%s::SecGscaler create() failed", __func__);
+ ALOGE("%s::SecGscaler create() failed", __func__);
goto CREATE_FAIL;
}
mIonClient = ion_client_create();
if (mIonClient < 0) {
mIonClient = -1;
- LOGE("%s::ion_client_create() failed", __func__);
+ ALOGE("%s::ion_client_create() failed", __func__);
goto CREATE_FAIL;
}
// get framebuffer virtual address for LCD
if (ioctl(mDefaultFBFd, S3CFB_GET_ION_USER_HANDLE, &ion_handle) == -1) {
- LOGE("%s:ioctl(S3CFB_GET_ION_USER_HANDLE) failed", __func__);
+ ALOGE("%s:ioctl(S3CFB_GET_ION_USER_HANDLE) failed", __func__);
return false;
}
@@ -393,11 +393,11 @@
ionfd_G2D = ion_alloc(mIonClient, ALIGN(g2d_reserved_memory_size * 2, PAGE_SIZE), 0, ION_HEAP_EXYNOS_MASK);
if (ionfd_G2D < 0) {
- LOGE("%s::ION memory allocation failed", __func__);
+ ALOGE("%s::ION memory allocation failed", __func__);
} else {
ion_base_addr = ion_map(ionfd_G2D, ALIGN(g2d_reserved_memory_size * 2, PAGE_SIZE), 0);
if (ion_base_addr == MAP_FAILED)
- LOGE("%s::ION mmap failed", __func__);
+ ALOGE("%s::ION mmap failed", __func__);
}
g2d_reserved_memory0 = (unsigned int)ion_base_addr;
@@ -408,49 +408,49 @@
__u32 preset_id;
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s::mHdmiOutputMode(%d) \n", __func__, mHdmiOutputMode);
+ ALOGD("%s::mHdmiOutputMode(%d) \n", __func__, mHdmiOutputMode);
#endif
if (mHdmiOutputMode == COMPOSITE_OUTPUT_MODE) {
std_id = composite_std_2_v4l2_std_id(mCompositeStd);
if ((int)std_id < 0) {
- LOGE("%s::composite_std_2_v4l2_std_id(%d) fail\n", __func__, mCompositeStd);
+ ALOGE("%s::composite_std_2_v4l2_std_id(%d) fail\n", __func__, mCompositeStd);
goto CREATE_FAIL;
}
if (m_setCompositeResolution(mCompositeStd) == false) {
- LOGE("%s::m_setCompositeResolution(%d) fail\n", __func__, mCompositeStd);
+ ALOGE("%s::m_setCompositeResolution(%d) fail\n", __func__, mCompositeStd);
goto CREATE_FAIL;
}
} else if (mHdmiOutputMode >= HDMI_OUTPUT_MODE_YCBCR &&
mHdmiOutputMode <= HDMI_OUTPUT_MODE_DVI) {
if (hdmi_resolution_2_std_id(mHdmiResolutionValue, &mHdmiDstWidth, &mHdmiDstHeight, &std_id, &preset_id) < 0) {
- LOGE("%s::hdmi_resolution_2_std_id(%d) fail\n", __func__, mHdmiResolutionValue);
+ ALOGE("%s::hdmi_resolution_2_std_id(%d) fail\n", __func__, mHdmiResolutionValue);
goto CREATE_FAIL;
}
}
if (m_setupLink() == false) {
- LOGE("%s:Enable the link failed", __func__);
+ ALOGE("%s:Enable the link failed", __func__);
return false;
}
for (int layer = HDMI_LAYER_BASE + 1; layer < HDMI_LAYER_MAX; layer++) {
if (m_openLayer(layer) == false)
- LOGE("%s::hdmi_init_layer(%d) failed", __func__, layer);
+ ALOGE("%s::hdmi_init_layer(%d) failed", __func__, layer);
}
for (int layer = HDMI_LAYER_BASE + 2; layer < HDMI_LAYER_MAX; layer++) {
if (tvout_std_v4l2_s_ctrl(mVideodevFd[layer], V4L2_CID_TV_LAYER_BLEND_ENABLE, 1) < 0) {
- LOGE("%s::tvout_std_v4l2_s_ctrl [layer=%d] (V4L2_CID_TV_LAYER_BLEND_ENABLE) failed", __func__, layer);
+ ALOGE("%s::tvout_std_v4l2_s_ctrl [layer=%d] (V4L2_CID_TV_LAYER_BLEND_ENABLE) failed", __func__, layer);
return false;
}
if (tvout_std_v4l2_s_ctrl(mVideodevFd[layer], V4L2_CID_TV_PIXEL_BLEND_ENABLE, 1) < 0) {
- LOGE("%s::tvout_std_v4l2_s_ctrl [layer=%d] (V4L2_CID_TV_LAYER_BLEND_ENABLE) failed", __func__, layer);
+ ALOGE("%s::tvout_std_v4l2_s_ctrl [layer=%d] (V4L2_CID_TV_LAYER_BLEND_ENABLE) failed", __func__, layer);
return false;
}
if (tvout_std_v4l2_s_ctrl(mVideodevFd[layer], V4L2_CID_TV_LAYER_BLEND_ALPHA, 255) < 0) {
- LOGE("%s::tvout_std_v4l2_s_ctrl [layer=%d] (V4L2_CID_TV_LAYER_BLEND_ALPHA) failed", __func__, layer);
+ ALOGE("%s::tvout_std_v4l2_s_ctrl [layer=%d] (V4L2_CID_TV_LAYER_BLEND_ALPHA) failed", __func__, layer);
return false;
}
}
@@ -463,7 +463,7 @@
if (mSecGscaler.flagCreate() == true &&
mSecGscaler.destroy() == false)
- LOGE("%s::Gscaler destory failed", __func__);
+ ALOGE("%s::Gscaler destory failed", __func__);
return false;
}
@@ -471,31 +471,31 @@
bool SecHdmi::destroy(void)
{
#ifdef DEBUG_MSG_ENABLE
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
char node[32];
Mutex::Autolock lock(mLock);
if (mFlagCreate == false) {
- LOGE("%s::Already Destroyed fail \n", __func__);
+ ALOGE("%s::Already Destroyed fail \n", __func__);
goto DESTROY_FAIL;
}
for (int layer = HDMI_LAYER_BASE + 1; layer < HDMI_LAYER_MAX; layer++) {
if (mFlagHdmiStart[layer] == true && m_stopHdmi(layer) == false) {
- LOGE("%s::m_stopHdmi: layer[%d] fail \n", __func__, layer);
+ ALOGE("%s::m_stopHdmi: layer[%d] fail \n", __func__, layer);
goto DESTROY_FAIL;
}
}
for (int layer = HDMI_LAYER_BASE + 1; layer < HDMI_LAYER_MAX; layer++) {
if (m_closeLayer(layer) == false)
- LOGE("%s::hdmi_deinit_layer(%d) failed", __func__, layer);
+ ALOGE("%s::hdmi_deinit_layer(%d) failed", __func__, layer);
}
if (mSecGscaler.flagCreate() == true && mSecGscaler.destroy() == false) {
- LOGE("%s::fimc destory fail \n", __func__);
+ ALOGE("%s::fimc destory fail \n", __func__);
goto DESTROY_FAIL;
}
@@ -522,19 +522,19 @@
mMediadevFd = open(node, O_RDONLY);
if (mMediadevFd < 0) {
- LOGE("%s::open(%s) failed", __func__, node);
+ ALOGE("%s::open(%s) failed", __func__, node);
goto DESTROY_FAIL;
}
mlink_desc.flags = 0;
if (ioctl(mMediadevFd, MEDIA_IOC_SETUP_LINK, &mlink_desc) < 0) {
- LOGE("%s::MEDIA_IOC_SETUP_UNLINK failed", __func__);
+ ALOGE("%s::MEDIA_IOC_SETUP_UNLINK failed", __func__);
goto DESTROY_FAIL;
}
for (int layer = HDMI_LAYER_BASE + 1; layer < HDMI_LAYER_MAX; layer++) {
if (m_closeLayer(layer) == false)
- LOGE("%s::hdmi_deinit_layer(%d) failed", __func__, layer);
+ ALOGE("%s::hdmi_deinit_layer(%d) failed", __func__, layer);
}
if (0 < mMediadevFd)
@@ -558,37 +558,37 @@
bool SecHdmi::connect(void)
{
#ifdef DEBUG_MSG_ENABLE
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
{
Mutex::Autolock lock(mLock);
if (mFlagCreate == false) {
- LOGE("%s::Not Yet Created \n", __func__);
+ ALOGE("%s::Not Yet Created \n", __func__);
return false;
}
if (mFlagConnected == true) {
- LOGD("%s::Already Connected.. \n", __func__);
+ ALOGD("%s::Already Connected.. \n", __func__);
return true;
}
if (mHdmiOutputMode >= HDMI_OUTPUT_MODE_YCBCR &&
mHdmiOutputMode <= HDMI_OUTPUT_MODE_DVI) {
if (m_flagHWConnected() == false) {
- LOGD("%s::m_flagHWConnected() fail \n", __func__);
+ ALOGD("%s::m_flagHWConnected() fail \n", __func__);
return false;
}
#if defined(BOARD_USES_EDID)
if (!EDIDOpen())
- LOGE("EDIDInit() failed!\n");
+ ALOGE("EDIDInit() failed!\n");
if (!EDIDRead()) {
- LOGE("EDIDRead() failed!\n");
+ ALOGE("EDIDRead() failed!\n");
if (!EDIDClose())
- LOGE("EDIDClose() failed!\n");
+ ALOGE("EDIDClose() failed!\n");
}
#endif
@@ -600,18 +600,18 @@
}
if (this->setHdmiOutputMode(mHdmiOutputMode, true) == false)
- LOGE("%s::setHdmiOutputMode(%d) fail \n", __func__, mHdmiOutputMode);
+ ALOGE("%s::setHdmiOutputMode(%d) fail \n", __func__, mHdmiOutputMode);
if (mHdmiOutputMode >= HDMI_OUTPUT_MODE_YCBCR &&
mHdmiOutputMode <= HDMI_OUTPUT_MODE_DVI) {
if (this->setHdmiResolution(mHdmiResolutionValue, true) == false)
- LOGE("%s::setHdmiResolution(%d) fail \n", __func__, mHdmiResolutionValue);
+ ALOGE("%s::setHdmiResolution(%d) fail \n", __func__, mHdmiResolutionValue);
if (this->setHdcpMode(mHdcpMode, false) == false)
- LOGE("%s::setHdcpMode(%d) fail \n", __func__, mHdcpMode);
+ ALOGE("%s::setHdcpMode(%d) fail \n", __func__, mHdcpMode);
/* if (this->m_setAudioMode(mAudioMode) == false)
- LOGE("%s::m_setAudioMode(%d) fail \n", __func__, mAudioMode);
+ ALOGE("%s::m_setAudioMode(%d) fail \n", __func__, mAudioMode);
*/
mHdmiInfoChange = true;
mFlagConnected = true;
@@ -627,18 +627,18 @@
bool SecHdmi::disconnect(void)
{
#ifdef DEBUG_MSG_ENABLE
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
Mutex::Autolock lock(mLock);
if (mFlagCreate == false) {
- LOGE("%s::Not Yet Created \n", __func__);
+ ALOGE("%s::Not Yet Created \n", __func__);
return false;
}
if (mFlagConnected == false) {
- LOGE("%s::Already Disconnected.. \n", __func__);
+ ALOGE("%s::Already Disconnected.. \n", __func__);
return true;
}
@@ -651,7 +651,7 @@
#if defined(BOARD_USES_EDID)
if (!EDIDClose()) {
- LOGE("EDIDClose() failed!\n");
+ ALOGE("EDIDClose() failed!\n");
return false;
}
#endif
@@ -659,7 +659,7 @@
for (int layer = HDMI_LAYER_BASE + 1; layer < HDMI_LAYER_MAX; layer++) {
if (mFlagHdmiStart[layer] == true && m_stopHdmi(layer) == false) {
- LOGE("%s::hdmiLayer(%d) layer fail \n", __func__, layer);
+ ALOGE("%s::hdmiLayer(%d) layer fail \n", __func__, layer);
return false;
}
}
@@ -682,13 +682,13 @@
bool SecHdmi::startHdmi(int hdmiLayer)
{
#ifdef DEBUG_MSG_ENABLE
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
Mutex::Autolock lock(mLock);
if (mFlagHdmiStart[hdmiLayer] == false &&
m_startHdmi(hdmiLayer) == false) {
- LOGE("%s::hdmiLayer(%d) fail \n", __func__, hdmiLayer);
+ ALOGE("%s::hdmiLayer(%d) fail \n", __func__, hdmiLayer);
return false;
}
return true;
@@ -697,13 +697,13 @@
bool SecHdmi::stopHdmi(int hdmiLayer)
{
#ifdef DEBUG_MSG_ENABLE
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
Mutex::Autolock lock(mLock);
if (mFlagHdmiStart[hdmiLayer] == true &&
m_stopHdmi(hdmiLayer) == false) {
- LOGE("%s::hdmiLayer(%d) layer fail \n", __func__, hdmiLayer);
+ ALOGE("%s::hdmiLayer(%d) layer fail \n", __func__, hdmiLayer);
return false;
}
tvout_deinit();
@@ -713,13 +713,13 @@
bool SecHdmi::flagConnected(void)
{
#ifdef DEBUG_MSG_ENABLE
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
Mutex::Autolock lock(mLock);
if (mFlagCreate == false) {
- LOGE("%s::Not Yet Created \n", __func__);
+ ALOGE("%s::Not Yet Created \n", __func__);
return false;
}
@@ -733,22 +733,22 @@
int num_of_hwc_layer)
{
#ifdef DEBUG_MSG_ENABLE
- LOGD("%s::hdmiLayer=%d", __func__, hdmiLayer);
+ ALOGD("%s::hdmiLayer=%d", __func__, hdmiLayer);
#endif
Mutex::Autolock lock(mLock);
#ifdef DEBUG_MSG_ENABLE
- LOGD("%s [srcW = %d, srcH = %d, srcColorFormat = 0x%x, srcYAddr= 0x%x, srcCbAddr = 0x%x, srcCrAddr = 0x%x, dstX = %d, dstY = %d, hdmiLayer = %d, num_of_hwc_layer=%d",
+ ALOGD("%s [srcW = %d, srcH = %d, srcColorFormat = 0x%x, srcYAddr= 0x%x, srcCbAddr = 0x%x, srcCrAddr = 0x%x, dstX = %d, dstY = %d, hdmiLayer = %d, num_of_hwc_layer=%d",
__func__, srcW, srcH, srcColorFormat,
srcYAddr, srcCbAddr, srcCrAddr,
dstX, dstY, hdmiLayer, num_of_hwc_layer);
- LOGD("saved param(%d, %d, %d)",
+ ALOGD("saved param(%d, %d, %d)",
mSrcWidth[hdmiLayer], mSrcHeight[hdmiLayer], mSrcColorFormat[hdmiLayer]);
#endif
if (mFlagCreate == false) {
- LOGE("%s::Not Yet Created", __func__);
+ ALOGE("%s::Not Yet Created", __func__);
return false;
}
@@ -760,14 +760,14 @@
num_of_hwc_layer != mPreviousNumofHwLayer[hdmiLayer] ||
mHdmiInfoChange == true) {
#ifdef DEBUG_MSG_ENABLE
- LOGD("m_reset param(%d, %d, %d, %d, %d, %d, %d)",
+ ALOGD("m_reset param(%d, %d, %d, %d, %d, %d, %d)",
srcW, mSrcWidth[hdmiLayer],
srcH, mSrcHeight[hdmiLayer],
srcColorFormat, mSrcColorFormat[hdmiLayer],
hdmiLayer);
#endif
if (m_reset(srcW, srcH, dstX, dstY, srcColorFormat, hdmiLayer, num_of_hwc_layer) == false) {
- LOGE("%s::m_reset(%d, %d, %d, %d) failed", __func__, srcW, srcH, srcColorFormat, hdmiLayer);
+ ALOGE("%s::m_reset(%d, %d, %d, %d) failed", __func__, srcW, srcH, srcColorFormat, hdmiLayer);
return false;
}
}
@@ -783,13 +783,13 @@
mFBoffset = 0;
#ifdef DEBUG_MSG_ENABLE
- LOGD("%s::mFBaddr=0x%08x, srcYAddr=0x%08x, mFBoffset=0x%08x", __func__, mFBaddr, srcYAddr, mFBoffset);
+ ALOGD("%s::mFBaddr=0x%08x, srcYAddr=0x%08x, mFBoffset=0x%08x", __func__, mFBaddr, srcYAddr, mFBoffset);
#endif
}
if (hdmiLayer == HDMI_LAYER_VIDEO) {
if (mSecGscaler.setSrcAddr(srcYAddr, srcCbAddr, srcCrAddr, srcColorFormat) == false) {
- LOGE("%s::setSrcAddr(0x%08x, 0x%08x, 0x%08x)", __func__, srcYAddr, srcCbAddr, srcCrAddr);
+ ALOGE("%s::setSrcAddr(0x%08x, 0x%08x, 0x%08x)", __func__, srcYAddr, srcCbAddr, srcCrAddr);
return false;
}
} else {
@@ -831,20 +831,20 @@
#if CHECK_GRAPHIC_LAYER_TIME
end = systemTime();
- LOGD("[UI] hdmi_gl_set_param[end-start] = %ld ms", long(ns2ms(end)) - long(ns2ms(start)));
+ ALOGD("[UI] hdmi_gl_set_param[end-start] = %ld ms", long(ns2ms(end)) - long(ns2ms(start)));
#endif
}
if (mFlagConnected) {
if (mFlagHdmiStart[hdmiLayer] == true) {
if (m_run(hdmiLayer) == false) {
- LOGE("%s::m_run(%d) failed", __func__, hdmiLayer);
+ ALOGE("%s::m_run(%d) failed", __func__, hdmiLayer);
return false;
}
}
if (mFlagHdmiStart[hdmiLayer] == false && m_startHdmi(hdmiLayer) == false) {
- LOGE("%s::start hdmiLayer(%d) failed", __func__, hdmiLayer);
+ ALOGE("%s::start hdmiLayer(%d) failed", __func__, hdmiLayer);
return false;
}
}
@@ -854,17 +854,17 @@
bool SecHdmi::clear(int hdmiLayer)
{
#ifdef DEBUG_MSG_ENABLE
- LOGD("%s::hdmiLayer = %d", __func__, hdmiLayer);
+ ALOGD("%s::hdmiLayer = %d", __func__, hdmiLayer);
#endif
Mutex::Autolock lock(mLock);
if (mFlagCreate == false) {
- LOGE("%s::Not Yet Created \n", __func__);
+ ALOGE("%s::Not Yet Created \n", __func__);
return false;
}
if (mFlagHdmiStart[hdmiLayer] == true && m_stopHdmi(hdmiLayer) == false) {
- LOGE("%s::m_stopHdmi: layer[%d] fail \n", __func__, hdmiLayer);
+ ALOGE("%s::m_stopHdmi: layer[%d] fail \n", __func__, hdmiLayer);
return false;
}
return true;
@@ -881,7 +881,7 @@
{
Mutex::Autolock lock(mLock);
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s::hdmiLayer(%d)",__func__, hdmiLayer);
+ ALOGD("%s::hdmiLayer(%d)",__func__, hdmiLayer);
#endif
switch (hdmiLayer) {
case HDMI_LAYER_VIDEO:
@@ -901,7 +901,7 @@
{
Mutex::Autolock lock(mLock);
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s::hdmiLayer(%d)",__func__, hdmiLayer);
+ ALOGD("%s::hdmiLayer(%d)",__func__, hdmiLayer);
#endif
switch (hdmiLayer) {
case HDMI_LAYER_VIDEO:
@@ -909,7 +909,7 @@
case HDMI_LAYER_GRAPHIC_1:
if (mFlagConnected == true && mFlagLayerEnable[hdmiLayer])
if (m_stopHdmi(hdmiLayer) == false )
- LOGE("%s::m_stopHdmi: layer[%d] fail \n", __func__, hdmiLayer);
+ ALOGE("%s::m_stopHdmi: layer[%d] fail \n", __func__, hdmiLayer);
mFlagLayerEnable[hdmiLayer] = false;
break;
@@ -922,19 +922,19 @@
bool SecHdmi::setHdmiOutputMode(int hdmiOutputMode, bool forceRun)
{
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s::hdmiOutputMode = %d, forceRun = %d", __func__, hdmiOutputMode, forceRun);
+ ALOGD("%s::hdmiOutputMode = %d, forceRun = %d", __func__, hdmiOutputMode, forceRun);
#endif
Mutex::Autolock lock(mLock);
if (mFlagCreate == false) {
- LOGE("%s::Not Yet Created \n", __func__);
+ ALOGE("%s::Not Yet Created \n", __func__);
return false;
}
if (forceRun == false && mHdmiOutputMode == hdmiOutputMode) {
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s::same hdmiOutputMode(%d) \n", __func__, hdmiOutputMode);
+ ALOGD("%s::same hdmiOutputMode(%d) \n", __func__, hdmiOutputMode);
#endif
return true;
}
@@ -943,7 +943,7 @@
int v4l2OutputType = hdmi_outputmode_2_v4l2_output_type(hdmiOutputMode);
if (v4l2OutputType < 0) {
- LOGD("%s::hdmi_outputmode_2_v4l2_output_type(%d) fail\n", __func__, hdmiOutputMode);
+ ALOGD("%s::hdmi_outputmode_2_v4l2_output_type(%d) fail\n", __func__, hdmiOutputMode);
return false;
}
@@ -952,11 +952,11 @@
if (newV4l2OutputType != v4l2OutputType) {
newHdmiOutputMode = hdmi_v4l2_output_type_2_outputmode(newV4l2OutputType);
if (newHdmiOutputMode < 0) {
- LOGD("%s::hdmi_v4l2_output_type_2_outputmode(%d) fail\n", __func__, newV4l2OutputType);
+ ALOGD("%s::hdmi_v4l2_output_type_2_outputmode(%d) fail\n", __func__, newV4l2OutputType);
return false;
}
- LOGD("%s::calibration mode(%d -> %d)... \n", __func__, hdmiOutputMode, newHdmiOutputMode);
+ ALOGD("%s::calibration mode(%d -> %d)... \n", __func__, hdmiOutputMode, newHdmiOutputMode);
mHdmiInfoChange = true;
}
#endif
@@ -972,19 +972,19 @@
bool SecHdmi::setHdmiResolution(unsigned int hdmiResolutionValue, bool forceRun)
{
#ifdef DEBUG_MSG_ENABLE
- LOGD("%s::hdmiResolutionValue = %d, forceRun = %d", __func__, hdmiResolutionValue, forceRun);
+ ALOGD("%s::hdmiResolutionValue = %d, forceRun = %d", __func__, hdmiResolutionValue, forceRun);
#endif
Mutex::Autolock lock(mLock);
if (mFlagCreate == false) {
- LOGE("%s::Not Yet Created \n", __func__);
+ ALOGE("%s::Not Yet Created \n", __func__);
return false;
}
if (forceRun == false && mHdmiResolutionValue == hdmiResolutionValue) {
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s::same hdmiResolutionValue(%d) \n", __func__, hdmiResolutionValue);
+ ALOGD("%s::same hdmiResolutionValue(%d) \n", __func__, hdmiResolutionValue);
#endif
return true;
}
@@ -1012,15 +1012,15 @@
}
if (flagFoundIndex == false) {
- LOGE("%s::hdmi cannot control this resolution(%d) fail \n", __func__, hdmiResolutionValue);
+ ALOGE("%s::hdmi cannot control this resolution(%d) fail \n", __func__, hdmiResolutionValue);
// Set resolution to 480P
newHdmiResolutionValue = mHdmiResolutionValueList[mHdmiSizeOfResolutionValueList-2];
} else {
- LOGD("%s::HDMI resolutions size is calibrated(%d -> %d)..\n", __func__, hdmiResolutionValue, newHdmiResolutionValue);
+ ALOGD("%s::HDMI resolutions size is calibrated(%d -> %d)..\n", __func__, hdmiResolutionValue, newHdmiResolutionValue);
}
} else {
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s::find resolutions(%d) at once\n", __func__, hdmiResolutionValue);
+ ALOGD("%s::find resolutions(%d) at once\n", __func__, hdmiResolutionValue);
#endif
}
#endif
@@ -1036,19 +1036,19 @@
bool SecHdmi::setHdcpMode(bool hdcpMode, bool forceRun)
{
#ifdef DEBUG_MSG_ENABLE
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
Mutex::Autolock lock(mLock);
if (mFlagCreate == false) {
- LOGE("%s::Not Yet Created \n", __func__);
+ ALOGE("%s::Not Yet Created \n", __func__);
return false;
}
if (forceRun == false && mHdcpMode == hdcpMode) {
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s::same hdcpMode(%d) \n", __func__, hdcpMode);
+ ALOGD("%s::same hdcpMode(%d) \n", __func__, hdcpMode);
#endif
return true;
}
@@ -1062,18 +1062,18 @@
bool SecHdmi::setUIRotation(unsigned int rotVal, unsigned int hwcLayer)
{
#ifdef DEBUG_MSG_ENABLE
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
Mutex::Autolock lock(mLock);
if (mFlagCreate == false) {
- LOGE("%s::Not Yet Created \n", __func__);
+ ALOGE("%s::Not Yet Created \n", __func__);
return false;
}
if (rotVal % 90 != 0) {
- LOGE("%s::Invalid rotation value(%d)", __func__, rotVal);
+ ALOGE("%s::Invalid rotation value(%d)", __func__, rotVal);
return false;
}
@@ -1117,7 +1117,7 @@
int num_of_hwc_layer)
{
#ifdef DEBUG_MSG_ENABLE
-LOGD("%s [srcW = %d, srcH = %d, srcColorFormat = 0x%x, srcYAddr= 0x%x, srcCbAddr = 0x%x, dstX = %d, dstY = %d, hdmiLayer = %d",
+ALOGD("%s [srcW = %d, srcH = %d, srcColorFormat = 0x%x, srcYAddr= 0x%x, srcCbAddr = 0x%x, dstX = %d, dstY = %d, hdmiLayer = %d",
__func__, srcW, srcH, srcColorFormat, srcYAddr, srcCbAddr, dstX, dstY, hdmiLayer);
#endif
@@ -1137,7 +1137,7 @@
bool SecHdmi::m_setupLink(void)
{
#ifdef DEBUG_MSG_ENABLE
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
int ret;
char node[32];
@@ -1150,7 +1150,7 @@
sprintf(node, "%s%d", PFX_NODE_MEDIADEV, 0);
mMediadevFd = open(node, O_RDWR);
if (mMediadevFd < 0) {
- LOGE("%s::open(%s) failed", __func__, node);
+ ALOGE("%s::open(%s) failed", __func__, node);
goto err;
}
@@ -1161,13 +1161,13 @@
if (ioctl(mMediadevFd, MEDIA_IOC_ENUM_ENTITIES, &entity_desc) < 0) {
if (errno == EINVAL) {
- LOGD("%s::MEDIA_IOC_ENUM_ENTITIES ended", __func__);
+ ALOGD("%s::MEDIA_IOC_ENUM_ENTITIES ended", __func__);
break;
}
- LOGE("%s::MEDIA_IOC_ENUM_ENTITIES failed", __func__);
+ ALOGE("%s::MEDIA_IOC_ENUM_ENTITIES failed", __func__);
goto err;
}
- LOGD("%s::entity_desc.id=%d, .minor=%d .name=%s", __func__, entity_desc.id, entity_desc.v4l.minor, entity_desc.name);
+ ALOGD("%s::entity_desc.id=%d, .minor=%d .name=%s", __func__, entity_desc.id, entity_desc.v4l.minor, entity_desc.name);
if (strncmp(entity_desc.name, subdevname, strlen(subdevname)) == 0)
mMixerSubdevEntity = entity_desc.id;
@@ -1183,19 +1183,19 @@
mlink_desc.flags = MEDIA_LNK_FL_ENABLED;
#ifdef DEBUG_MSG_ENABLE
- LOGD("%s::mlink_desc.source.entity=%02d, .pad=%d", __func__, mlink_desc.source.entity, mlink_desc.source.index);
- LOGD("%s::mlink_desc.sink.entity =%02d, .pad=%d", __func__, mlink_desc.sink.entity, mlink_desc.sink.index);
+ ALOGD("%s::mlink_desc.source.entity=%02d, .pad=%d", __func__, mlink_desc.source.entity, mlink_desc.source.index);
+ ALOGD("%s::mlink_desc.sink.entity =%02d, .pad=%d", __func__, mlink_desc.sink.entity, mlink_desc.sink.index);
#endif
if (ioctl(mMediadevFd, MEDIA_IOC_SETUP_LINK, &mlink_desc) < 0) {
- LOGE("%s::MEDIA_IOC_SETUP_LINK [src.entity=%d->sink.entity=%d] failed", __func__, mlink_desc.source.entity, mlink_desc.sink.entity);
+ ALOGE("%s::MEDIA_IOC_SETUP_LINK [src.entity=%d->sink.entity=%d] failed", __func__, mlink_desc.source.entity, mlink_desc.sink.entity);
goto err;
}
sprintf(node, "%s%d", PFX_NODE_SUBDEV, 4); // Mixer0 minor=132 /dev/v4l-subdev4 // need to modify //carrotsm
mSubdevMixerFd = open(node, O_RDWR, 0);
if (mSubdevMixerFd < 0) {
- LOGE("%s::open(%s) failed", __func__, node);
+ ALOGE("%s::open(%s) failed", __func__, node);
goto err;
}
@@ -1222,7 +1222,7 @@
bool SecHdmi::m_openLayer(int layer)
{
#ifdef DEBUG_MSG_ENABLE
- LOGD("%s::layer=%d", __func__, layer);
+ ALOGD("%s::layer=%d", __func__, layer);
#endif
char node[32];
@@ -1231,12 +1231,12 @@
mVideodevFd[layer] = mSecGscaler.getVideodevFd();
if (0 < mVideodevFd[layer]) {
- LOGD("%s::Layer[%d] device already opened", __func__, layer);
+ ALOGD("%s::Layer[%d] device already opened", __func__, layer);
return true;
}
if (mSecGscaler.openVideodevFd() == false)
- LOGE("%s::open(%s) failed", __func__, node);
+ ALOGE("%s::open(%s) failed", __func__, node);
else
mVideodevFd[layer] = mSecGscaler.getVideodevFd();
@@ -1249,25 +1249,25 @@
sprintf(node, "%s", TVOUT0_DEV_G1);
break;
default:
- LOGE("%s::unmatched layer[%d]", __func__, layer);
+ ALOGE("%s::unmatched layer[%d]", __func__, layer);
return false;
break;
}
mVideodevFd[layer] = open(node, O_RDWR);
if (mVideodevFd[layer] < 0) {
- LOGE("%s::open(%s) failed", __func__, node);
+ ALOGE("%s::open(%s) failed", __func__, node);
goto err;
}
open_success :
#ifdef DEBUG_MSG_ENABLE
- LOGD("layer=%d, mVideodevFd=%d", layer, mVideodevFd[layer]);
+ ALOGD("layer=%d, mVideodevFd=%d", layer, mVideodevFd[layer]);
#endif
if (tvout_std_v4l2_querycap(mVideodevFd[layer], node) < 0 ) {
- LOGE("%s::tvout_std_v4l2_querycap failed", __func__);
+ ALOGE("%s::tvout_std_v4l2_querycap failed", __func__);
goto err;
}
@@ -1287,14 +1287,14 @@
bool SecHdmi::m_closeLayer(int layer)
{
#ifdef DEBUG_MSG_ENABLE
- LOGD("%s::layer=%d", __func__, layer);
+ ALOGD("%s::layer=%d", __func__, layer);
#endif
switch (layer) {
case HDMI_LAYER_VIDEO:
mVideodevFd[layer] = mSecGscaler.getVideodevFd();
if (mVideodevFd[layer] < 0) {
- LOGD("%s::Layer[%d] device already closed", __func__, layer);
+ ALOGD("%s::Layer[%d] device already closed", __func__, layer);
return true;
} else {
mSecGscaler.closeVideodevFd();
@@ -1307,20 +1307,20 @@
/* clear buffer */
if (0 < mVideodevFd[layer]) {
if (tvout_std_v4l2_reqbuf(mVideodevFd[layer], V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_MEMORY_USERPTR, 0) < 0) {
- LOGE("%s::tvout_std_v4l2_reqbuf(buf_num=%d)[graphic layer] failed", __func__, 0);
+ ALOGE("%s::tvout_std_v4l2_reqbuf(buf_num=%d)[graphic layer] failed", __func__, 0);
return -1;
}
}
break;
default:
- LOGE("%s::unmatched layer[%d]", __func__, layer);
+ ALOGE("%s::unmatched layer[%d]", __func__, layer);
return false;
break;
}
if (0 < mVideodevFd[layer]) {
if (close(mVideodevFd[layer]) < 0) {
- LOGE("%s::close %d layer failed", __func__, layer);
+ ALOGE("%s::close %d layer failed", __func__, layer);
return false;
}
}
@@ -1335,7 +1335,7 @@
bool SecHdmi::m_reset(int w, int h, int dstX, int dstY, int colorFormat, int hdmiLayer, int num_of_hwc_layer)
{
#ifdef DEBUG_MSG_ENABLE
- LOGD("%s::w=%d, h=%d, dstX=%d, dstY=%d, colorFormat=%d, hdmiLayer=%d, num_of_hwc_layer=%d",
+ ALOGD("%s::w=%d, h=%d, dstX=%d, dstY=%d, colorFormat=%d, hdmiLayer=%d, num_of_hwc_layer=%d",
__func__, w, h, dstX, dstY, colorFormat, hdmiLayer, num_of_hwc_layer);
#endif
@@ -1347,17 +1347,17 @@
int dstH = 0;
if (mFlagHdmiStart[hdmiLayer] == true && m_stopHdmi(hdmiLayer) == false) {
- LOGE("%s::m_stopHdmi: layer[%d] failed", __func__, hdmiLayer);
+ ALOGE("%s::m_stopHdmi: layer[%d] failed", __func__, hdmiLayer);
return false;
}
if (m_closeLayer(hdmiLayer) == false) {
- LOGE("%s::m_closeLayer: layer[%d] failed", __func__, hdmiLayer);
+ ALOGE("%s::m_closeLayer: layer[%d] failed", __func__, hdmiLayer);
return false;
}
if (m_openLayer(hdmiLayer) == false) {
- LOGE("%s::m_closeLayer: layer[%d] failed", __func__, hdmiLayer);
+ ALOGE("%s::m_closeLayer: layer[%d] failed", __func__, hdmiLayer);
return false;
}
@@ -1376,7 +1376,7 @@
preVideoSrcColorFormat != HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP &&
preVideoSrcColorFormat != HAL_PIXEL_FORMAT_CUSTOM_YCrCb_420_SP &&
preVideoSrcColorFormat != HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP_TILED) {
- LOGI("%s: Unsupported preVideoSrcColorFormat = 0x%x", __func__, preVideoSrcColorFormat);
+ ALOGI("%s: Unsupported preVideoSrcColorFormat = 0x%x", __func__, preVideoSrcColorFormat);
preVideoSrcColorFormat = HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP_TILED;
}
@@ -1386,7 +1386,7 @@
if (mSecGscaler.setSrcParams(full_wdith, full_height, 0, 0,
(unsigned int*)&w, (unsigned int*)&h, colorFormat, true) == false) {
- LOGE("%s::mSecGscaler.setSrcParams(w=%d, h=%d, color=%d) failed",
+ ALOGE("%s::mSecGscaler.setSrcParams(w=%d, h=%d, color=%d) failed",
__func__, w, h, colorFormat);
return false;
}
@@ -1405,7 +1405,7 @@
if (mSecGscaler.setDstParams((unsigned int)rect.width, (unsigned int)rect.height, 0, 0,
(unsigned int*)&rect.width, (unsigned int*)&rect.height, mGscalerDstColorFormat, true) == false) {
- LOGE("%s::mSecGscaler.setDstParams(w=%d, h=%d, V4L2_MBUS_FMT_YUV8_1X24) failed",
+ ALOGE("%s::mSecGscaler.setDstParams(w=%d, h=%d, V4L2_MBUS_FMT_YUV8_1X24) failed",
__func__, rect.width, rect.height);
return false;
}
@@ -1413,17 +1413,17 @@
hdmi_set_videolayer(mSubdevMixerFd, mHdmiDstWidth, mHdmiDstHeight, &rect);
} else {
if (tvout_std_v4l2_s_ctrl(mVideodevFd[hdmiLayer], V4L2_CID_TV_LAYER_BLEND_ENABLE, 1) < 0) {
- LOGE("%s::tvout_std_v4l2_s_ctrl [layer=%d] (V4L2_CID_TV_LAYER_BLEND_ENABLE) failed", __func__, hdmiLayer);
+ ALOGE("%s::tvout_std_v4l2_s_ctrl [layer=%d] (V4L2_CID_TV_LAYER_BLEND_ENABLE) failed", __func__, hdmiLayer);
return false;
}
if (tvout_std_v4l2_s_ctrl(mVideodevFd[hdmiLayer], V4L2_CID_TV_PIXEL_BLEND_ENABLE, 1) < 0) {
- LOGE("%s::tvout_std_v4l2_s_ctrl [layer=%d] (V4L2_CID_TV_LAYER_BLEND_ENABLE) failed", __func__, hdmiLayer);
+ ALOGE("%s::tvout_std_v4l2_s_ctrl [layer=%d] (V4L2_CID_TV_LAYER_BLEND_ENABLE) failed", __func__, hdmiLayer);
return false;
}
if (tvout_std_v4l2_s_ctrl(mVideodevFd[hdmiLayer], V4L2_CID_TV_LAYER_BLEND_ALPHA, 255) < 0) {
- LOGE("%s::tvout_std_v4l2_s_ctrl [layer=%d] (V4L2_CID_TV_LAYER_BLEND_ALPHA) failed", __func__, hdmiLayer);
+ ALOGE("%s::tvout_std_v4l2_s_ctrl [layer=%d] (V4L2_CID_TV_LAYER_BLEND_ALPHA) failed", __func__, hdmiLayer);
return false;
}
@@ -1472,7 +1472,7 @@
mSrcBuffer[hdmiLayer][buf_index].size.s = gr_frame_size << 1;
break;
default:
- LOGE("%s::invalid color type", __func__);
+ ALOGE("%s::invalid color type", __func__);
return false;
break;
}
@@ -1492,7 +1492,7 @@
mPreviousNumofHwLayer[hdmiLayer] = num_of_hwc_layer;
#ifdef DEBUG_MSG_ENABLE
- LOGD("m_reset saved param(%d, %d, %d, %d, %d, %d, %d)",
+ ALOGD("m_reset saved param(%d, %d, %d, %d, %d, %d, %d)",
srcW, mSrcWidth[hdmiLayer], \
srcH, mSrcHeight[hdmiLayer], \
colorFormat,mSrcColorFormat[hdmiLayer], \
@@ -1502,7 +1502,7 @@
if (mHdmiInfoChange == true) {
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("mHdmiInfoChange: %d", mHdmiInfoChange);
+ ALOGD("mHdmiInfoChange: %d", mHdmiInfoChange);
#endif
#if defined(BOARD_USES_CEC)
@@ -1514,28 +1514,28 @@
#endif
if (m_setHdmiOutputMode(mHdmiOutputMode) == false) {
- LOGE("%s::m_setHdmiOutputMode() failed", __func__);
+ ALOGE("%s::m_setHdmiOutputMode() failed", __func__);
return false;
}
if (mHdmiOutputMode == COMPOSITE_OUTPUT_MODE) {
std_id = composite_std_2_v4l2_std_id(mCompositeStd);
if ((int)std_id < 0) {
- LOGE("%s::composite_std_2_v4l2_std_id(%d) failed", __func__, mCompositeStd);
+ ALOGE("%s::composite_std_2_v4l2_std_id(%d) failed", __func__, mCompositeStd);
return false;
}
if (m_setCompositeResolution(mCompositeStd) == false) {
- LOGE("%s::m_setCompositeRsolution() failed", __func__);
+ ALOGE("%s::m_setCompositeRsolution() failed", __func__);
return false;
}
} else if (mHdmiOutputMode >= HDMI_OUTPUT_MODE_YCBCR &&
mHdmiOutputMode <= HDMI_OUTPUT_MODE_DVI) {
if (m_setHdmiResolution(mHdmiResolutionValue) == false) {
- LOGE("%s::m_setHdmiResolution() failed", __func__);
+ ALOGE("%s::m_setHdmiResolution() failed", __func__);
return false;
}
if (m_setHdcpMode(mHdcpMode) == false) {
- LOGE("%s::m_setHdcpMode() failed", __func__);
+ ALOGE("%s::m_setHdcpMode() failed", __func__);
return false;
}
std_id = mHdmiStdId;
@@ -1544,13 +1544,13 @@
if (mPreviousHdmiPresetId != mHdmiPresetId) {
for (int layer = HDMI_LAYER_BASE + 1; layer < HDMI_LAYER_MAX; layer++) {
if (m_stopHdmi(layer) == false) {
- LOGE("%s::m_stopHdmi(%d) failed", __func__, layer);
+ ALOGE("%s::m_stopHdmi(%d) failed", __func__, layer);
return false;
}
}
if (tvout_init(mVideodevFd[HDMI_LAYER_GRAPHIC_0], mHdmiPresetId) < 0) {
- LOGE("%s::tvout_init(mHdmiPresetId=%d) failed", __func__, mHdmiPresetId);
+ ALOGE("%s::tvout_init(mHdmiPresetId=%d) failed", __func__, mHdmiPresetId);
return false;
}
mPreviousHdmiPresetId = mHdmiPresetId;
@@ -1564,7 +1564,7 @@
#endif
/* if (m_setAudioMode(mAudioMode) == false)
- LOGE("%s::m_setAudioMode() failed", __func__);
+ ALOGE("%s::m_setAudioMode() failed", __func__);
*/
}
@@ -1578,16 +1578,16 @@
bool SecHdmi::m_streamOn(int hdmiLayer)
{
#ifdef DEBUG_MSG_ENABLE
- LOGD("%s::hdmiLayer = %d", __func__, hdmiLayer);
+ ALOGD("%s::hdmiLayer = %d", __func__, hdmiLayer);
#endif
if (mFlagCreate == false) {
- LOGE("%s::Not yet created", __func__);
+ ALOGE("%s::Not yet created", __func__);
return false;
}
if (mFlagHdmiStart[hdmiLayer] == true) {
- LOGE("%s::[layer=%d] already streamon", __func__, hdmiLayer);
+ ALOGE("%s::[layer=%d] already streamon", __func__, hdmiLayer);
return true;
}
@@ -1597,21 +1597,21 @@
case HDMI_LAYER_GRAPHIC_1:
break;
default :
- LOGE("%s::unmathced layer(%d) failed", __func__, hdmiLayer);
+ ALOGE("%s::unmathced layer(%d) failed", __func__, hdmiLayer);
return false;
break;
}
if (tvout_std_v4l2_qbuf(mVideodevFd[hdmiLayer], V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_MEMORY_USERPTR,
mSrcIndex[hdmiLayer], 1, &mSrcBuffer[hdmiLayer][0]) < 0) {
- LOGE("%s::gsc_v4l2_queue(index : %d) (mSrcBufNum : %d) failed", __func__, mSrcIndex[hdmiLayer], 1);
+ ALOGE("%s::gsc_v4l2_queue(index : %d) (mSrcBufNum : %d) failed", __func__, mSrcIndex[hdmiLayer], 1);
return false;
}
mSrcIndex[hdmiLayer]++;
if (mSrcIndex[hdmiLayer] == MAX_BUFFERS_MIXER) {
if (tvout_std_v4l2_streamon(mVideodevFd[hdmiLayer], V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) < 0) {
- LOGE("%s::gsc_v4l2_stream_on() failed", __func__);
+ ALOGE("%s::gsc_v4l2_stream_on() failed", __func__);
return false;
}
mFlagHdmiStart[hdmiLayer] = true;
@@ -1627,33 +1627,33 @@
bool SecHdmi::m_run(int hdmiLayer)
{
#ifdef DEBUG_MSG_ENABLE
- LOGD("%s::hdmiLayer = %d", __func__, hdmiLayer);
+ ALOGD("%s::hdmiLayer = %d", __func__, hdmiLayer);
#endif
int buf_index = 0;
if (mFlagHdmiStart[hdmiLayer] == false || mFlagLayerEnable[hdmiLayer] == false) {
- LOGD("%s::HDMI(%d layer) started not yet", __func__, hdmiLayer);
+ ALOGD("%s::HDMI(%d layer) started not yet", __func__, hdmiLayer);
return true;
}
switch (hdmiLayer) {
case HDMI_LAYER_VIDEO:
if (mSecGscaler.run() == false) {
- LOGE("%s::mSecGscaler.draw() failed", __func__);
+ ALOGE("%s::mSecGscaler.draw() failed", __func__);
return false;
}
break;
case HDMI_LAYER_GRAPHIC_0 :
case HDMI_LAYER_GRAPHIC_1 :
if (tvout_std_v4l2_dqbuf(mVideodevFd[hdmiLayer], V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_MEMORY_USERPTR, &buf_index, 1) < 0) {
- LOGE("%s::tvout_std_v4l2_dqbuf(mNumOfBuf : %d, dqIndex=%d) failed", __func__, 1, buf_index);
+ ALOGE("%s::tvout_std_v4l2_dqbuf(mNumOfBuf : %d, dqIndex=%d) failed", __func__, 1, buf_index);
return false;
}
if (tvout_std_v4l2_qbuf(mVideodevFd[hdmiLayer], V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_MEMORY_USERPTR,
mSrcIndex[hdmiLayer], 1, &mSrcBuffer[hdmiLayer][mSrcIndex[hdmiLayer]]) < 0) {
- LOGE("%s::tvout_std_v4l2_qbuf(mNumOfBuf : %d,mSrcIndex=%d) failed", __func__, 1, mSrcIndex[hdmiLayer]);
+ ALOGE("%s::tvout_std_v4l2_qbuf(mNumOfBuf : %d,mSrcIndex=%d) failed", __func__, 1, mSrcIndex[hdmiLayer]);
return false;
}
@@ -1664,7 +1664,7 @@
break;
default :
- LOGE("%s::unmathced layer(%d) failed", __func__, hdmiLayer);
+ ALOGE("%s::unmathced layer(%d) failed", __func__, hdmiLayer);
return false;
break;
}
@@ -1675,23 +1675,23 @@
bool SecHdmi::m_startHdmi(int hdmiLayer)
{
#ifdef DEBUG_MSG_ENABLE
- LOGD("%s::hdmiLayer = %d", __func__, hdmiLayer);
+ ALOGD("%s::hdmiLayer = %d", __func__, hdmiLayer);
#endif
int buf_index = 0;
if (mFlagHdmiStart[hdmiLayer] == true) {
- LOGD("%s::already HDMI(%d layer) started..", __func__, hdmiLayer);
+ ALOGD("%s::already HDMI(%d layer) started..", __func__, hdmiLayer);
return true;
}
#ifdef DEBUG_MSG_ENABLE
- LOGD("### %s: hdmiLayer(%d) called", __func__, hdmiLayer);
+ ALOGD("### %s: hdmiLayer(%d) called", __func__, hdmiLayer);
#endif
switch (hdmiLayer) {
case HDMI_LAYER_VIDEO:
if (mSecGscaler.streamOn() == false) {
- LOGE("%s::mSecGscaler.streamOn() failed", __func__);
+ ALOGE("%s::mSecGscaler.streamOn() failed", __func__);
return false;
}
if (mSecGscaler.getFlagSteamOn() == true)
@@ -1700,12 +1700,12 @@
case HDMI_LAYER_GRAPHIC_0 :
case HDMI_LAYER_GRAPHIC_1 :
if (m_streamOn(hdmiLayer) == false) {
- LOGE("%s::m_streamOn layer(%d) failed", __func__, hdmiLayer);
+ ALOGE("%s::m_streamOn layer(%d) failed", __func__, hdmiLayer);
return false;
}
break;
default :
- LOGE("%s::unmathced layer(%d) failed", __func__, hdmiLayer);
+ ALOGE("%s::unmathced layer(%d) failed", __func__, hdmiLayer);
return false;
break;
}
@@ -1715,22 +1715,22 @@
bool SecHdmi::m_stopHdmi(int hdmiLayer)
{
#ifdef DEBUG_MSG_ENABLE
- LOGD("%s::hdmiLayer = %d", __func__, hdmiLayer);
+ ALOGD("%s::hdmiLayer = %d", __func__, hdmiLayer);
#endif
if (mFlagHdmiStart[hdmiLayer] == false) {
- LOGD("%s::already HDMI(%d layer) stopped..", __func__, hdmiLayer);
+ ALOGD("%s::already HDMI(%d layer) stopped..", __func__, hdmiLayer);
return true;
}
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("### %s : layer[%d] called", __func__, hdmiLayer);
+ ALOGD("### %s : layer[%d] called", __func__, hdmiLayer);
#endif
switch (hdmiLayer) {
case HDMI_LAYER_VIDEO:
if (mSecGscaler.streamOff() == false) {
- LOGE("%s::mSecGscaler.streamOff() failed", __func__);
+ ALOGE("%s::mSecGscaler.streamOff() failed", __func__);
return false;
}
mFlagHdmiStart[hdmiLayer] = false;
@@ -1741,7 +1741,7 @@
cur_g2d_address = 0;
#endif
if (tvout_std_v4l2_streamoff(mVideodevFd[hdmiLayer], V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) < 0) {
- LOGE("%s::tvout_std_v4l2_streamon layer(%d) failed", __func__, hdmiLayer);
+ ALOGE("%s::tvout_std_v4l2_streamon layer(%d) failed", __func__, hdmiLayer);
return false;
}
@@ -1749,7 +1749,7 @@
mFlagHdmiStart[hdmiLayer] = false;
break;
default :
- LOGE("%s::unmathced layer(%d) failed", __func__, hdmiLayer);
+ ALOGE("%s::unmathced layer(%d) failed", __func__, hdmiLayer);
return false;
break;
}
@@ -1760,23 +1760,23 @@
bool SecHdmi::m_setHdmiOutputMode(int hdmiOutputMode)
{
#ifdef DEBUG_MSG_ENABLE
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
if (hdmiOutputMode == mCurrentHdmiOutputMode) {
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s::same hdmiOutputMode(%d) \n", __func__, hdmiOutputMode);
+ ALOGD("%s::same hdmiOutputMode(%d) \n", __func__, hdmiOutputMode);
#endif
return true;
}
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("### %s called\n", __func__);
+ ALOGD("### %s called\n", __func__);
#endif
int v4l2OutputType = hdmi_outputmode_2_v4l2_output_type(hdmiOutputMode);
if (v4l2OutputType < 0) {
- LOGE("%s::hdmi_outputmode_2_v4l2_output_type(%d) fail\n", __func__, hdmiOutputMode);
+ ALOGE("%s::hdmi_outputmode_2_v4l2_output_type(%d) fail\n", __func__, hdmiOutputMode);
return false;
}
@@ -1790,18 +1790,18 @@
bool SecHdmi::m_setCompositeResolution(unsigned int compositeStdId)
{
#ifdef DEBUG_MSG_ENABLE
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("### %s called\n", __func__);
+ ALOGD("### %s called\n", __func__);
#endif
int w = 0;
int h = 0;
if (mHdmiOutputMode != COMPOSITE_OUTPUT_MODE) {
- LOGE("%s::not supported output type \n", __func__);
+ ALOGE("%s::not supported output type \n", __func__);
return false;
}
@@ -1820,7 +1820,7 @@
h = 576;
break;
default:
- LOGE("%s::unmathced composite_std(%d)", __func__, compositeStdId);
+ ALOGE("%s::unmathced composite_std(%d)", __func__, compositeStdId);
return false;
}
@@ -1836,18 +1836,18 @@
bool SecHdmi::m_setHdmiResolution(unsigned int hdmiResolutionValue)
{
#ifdef DEBUG_MSG_ENABLE
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
if (hdmiResolutionValue == mCurrentHdmiResolutionValue) {
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s::same hdmiResolutionValue(%d) \n", __func__, hdmiResolutionValue);
+ ALOGD("%s::same hdmiResolutionValue(%d) \n", __func__, hdmiResolutionValue);
#endif
return true;
}
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("### %s called\n", __func__);
+ ALOGD("### %s called\n", __func__);
#endif
int w = 0;
@@ -1857,12 +1857,12 @@
if (mHdmiOutputMode >= HDMI_OUTPUT_MODE_YCBCR &&
mHdmiOutputMode <= HDMI_OUTPUT_MODE_DVI) {
if (hdmi_resolution_2_std_id(hdmiResolutionValue, &w, &h, &std_id, &mHdmiPresetId) < 0) {
- LOGE("%s::hdmi_resolution_2_std_id(%d) fail\n", __func__, hdmiResolutionValue);
+ ALOGE("%s::hdmi_resolution_2_std_id(%d) fail\n", __func__, hdmiResolutionValue);
return false;
}
mHdmiStdId = std_id;
} else {
- LOGE("%s::not supported output type \n", __func__);
+ ALOGE("%s::not supported output type \n", __func__);
return false;
}
@@ -1874,7 +1874,7 @@
mCurrentHdmiResolutionValue = hdmiResolutionValue;
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s::mHdmiDstWidth = %d, mHdmiDstHeight = %d, mHdmiStdId = 0x%x, hdmiResolutionValue = 0x%x\n",
+ ALOGD("%s::mHdmiDstWidth = %d, mHdmiDstHeight = %d, mHdmiStdId = 0x%x, hdmiResolutionValue = 0x%x\n",
__func__,
mHdmiDstWidth,
mHdmiDstHeight,
@@ -1888,19 +1888,19 @@
bool SecHdmi::m_setHdcpMode(bool hdcpMode)
{
#ifdef DEBUG_MSG_ENABLE
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
if (hdcpMode == mCurrentHdcpMode) {
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s::same hdcpMode(%d) \n", __func__, hdcpMode);
+ ALOGD("%s::same hdcpMode(%d) \n", __func__, hdcpMode);
#endif
return true;
}
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("### %s called\n", __func__);
+ ALOGD("### %s called\n", __func__);
#endif
if (hdcpMode == true)
@@ -1916,22 +1916,22 @@
bool SecHdmi::m_setAudioMode(int audioMode)
{
#ifdef DEBUG_MSG_ENABLE
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
if (audioMode == mCurrentAudioMode) {
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s::same audioMode(%d) \n", __func__, audioMode);
+ ALOGD("%s::same audioMode(%d) \n", __func__, audioMode);
#endif
return true;
}
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("### %s called\n", __func__);
+ ALOGD("### %s called\n", __func__);
#endif
if (hdmi_check_audio(mVideodevFd[HDMI_LAYER_GRAPHIC_0]) < 0) {
- LOGE("%s::hdmi_check_audio() fail \n", __func__);
+ ALOGE("%s::hdmi_check_audio() fail \n", __func__);
return false;
}
@@ -1943,7 +1943,7 @@
int SecHdmi::m_resolutionValueIndex(unsigned int ResolutionValue)
{
#ifdef DEBUG_MSG_ENABLE
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
int index = -1;
@@ -1960,11 +1960,11 @@
bool SecHdmi::m_flagHWConnected(void)
{
#ifdef DEBUG_MSG_ENABLE
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("### %s called\n", __func__);
+ ALOGD("### %s called\n", __func__);
#endif
bool ret = true;
@@ -1972,7 +1972,7 @@
if (hdmiStatus <= 0) {
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s::hdmi_cable_status() fail \n", __func__);
+ ALOGD("%s::hdmi_cable_status() fail \n", __func__);
#endif
ret = false;
} else {
diff --git a/exynos5/hal/libhdmi/SecHdmi/SecHdmiV4L2Utils.cpp b/exynos5/hal/libhdmi/SecHdmi/SecHdmiV4L2Utils.cpp
index ac4717b..e3f0f30 100644
--- a/exynos5/hal/libhdmi/SecHdmi/SecHdmiV4L2Utils.cpp
+++ b/exynos5/hal/libhdmi/SecHdmi/SecHdmiV4L2Utils.cpp
@@ -14,8 +14,8 @@
* limitations under the License.
*/
-//#define LOG_NDEBUG 0
-//#define LOG_TAG "libhdmi"
+//#define ALOG_NDEBUG 0
+//#define ALOG_TAG "libhdmi"
//#define DEBUG_HDMI_HW_LEVEL
#include <cutils/log.h>
@@ -69,7 +69,7 @@
struct HDMIAudioParameter audio;
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
audio.formatCode = LPCM_FORMAT;
@@ -77,135 +77,135 @@
audio.channelNum = CH_2;
audio.sampleFreq = SF_44KHZ;
- LOGI("=============== HDMI Audio =============\n");
+ ALOGI("=============== HDMI Audio =============\n");
if (EDIDAudioModeSupport(&audio))
- LOGI("= 2CH_PCM 44100Hz audio supported =\n");
+ ALOGI("= 2CH_PCM 44100Hz audio supported =\n");
- LOGI("========= HDMI Mode & Color Space =======\n");
+ ALOGI("========= HDMI Mode & Color Space =======\n");
video.mode = HDMI;
if (EDIDHDMIModeSupport(&video)) {
video.colorSpace = HDMI_CS_YCBCR444;
if (EDIDColorSpaceSupport(&video))
- LOGI("= 1. HDMI(YCbCr) =\n");
+ ALOGI("= 1. HDMI(YCbCr) =\n");
video.colorSpace = HDMI_CS_RGB;
if (EDIDColorSpaceSupport(&video))
- LOGI("= 2. HDMI(RGB) =\n");
+ ALOGI("= 2. HDMI(RGB) =\n");
} else {
video.mode = DVI;
if (EDIDHDMIModeSupport(&video))
- LOGI("= 3. DVI =\n");
+ ALOGI("= 3. DVI =\n");
}
- LOGI("=========== HDMI Rseolution ========\n");
+ ALOGI("=========== HDMI Rseolution ========\n");
/* 480P */
video.resolution = v720x480p_60Hz;
video.pixelAspectRatio = HDMI_PIXEL_RATIO_16_9;
video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
if (EDIDVideoResolutionSupport(&video))
- LOGI("= 4. 480P_60_16_9 (0x04000000) =\n");
+ ALOGI("= 4. 480P_60_16_9 (0x04000000) =\n");
video.resolution = v640x480p_60Hz;
video.pixelAspectRatio = HDMI_PIXEL_RATIO_4_3;
video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
if (EDIDVideoResolutionSupport(&video))
- LOGI("= 5. 480P_60_4_3 (0x05000000) =\n");
+ ALOGI("= 5. 480P_60_4_3 (0x05000000) =\n");
/* 576P */
video.resolution = v720x576p_50Hz;
video.pixelAspectRatio = HDMI_PIXEL_RATIO_16_9;
video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
if (EDIDVideoResolutionSupport(&video))
- LOGI("= 6. 576P_50_16_9 (0x06000000) =\n");
+ ALOGI("= 6. 576P_50_16_9 (0x06000000) =\n");
video.pixelAspectRatio = HDMI_PIXEL_RATIO_4_3;
video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
if (EDIDVideoResolutionSupport(&video))
- LOGI("= 7. 576P_50_4_3 (0x07000000) =\n");
+ ALOGI("= 7. 576P_50_4_3 (0x07000000) =\n");
/* 720P 60 */
video.resolution = v1280x720p_60Hz;
video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
if (EDIDVideoResolutionSupport(&video))
- LOGI("= 8. 720P_60 (0x08000000) =\n");
+ ALOGI("= 8. 720P_60 (0x08000000) =\n");
/* 720P_50 */
video.resolution = v1280x720p_50Hz;
video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
if (EDIDVideoResolutionSupport(&video))
- LOGI("= 9. 720P_50 (0x09000000) =\n");
+ ALOGI("= 9. 720P_50 (0x09000000) =\n");
/* 1080P_60 */
video.resolution = v1920x1080p_60Hz;
video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
if (EDIDVideoResolutionSupport(&video))
- LOGI("= a. 1080P_60 (0x0a000000) =\n");
+ ALOGI("= a. 1080P_60 (0x0a000000) =\n");
/* 1080P_50 */
video.resolution = v1920x1080p_50Hz;
video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
if (EDIDVideoResolutionSupport(&video))
- LOGI("= b. 1080P_50 (0x0b000000) =\n");
+ ALOGI("= b. 1080P_50 (0x0b000000) =\n");
/* 1080I_60 */
video.resolution = v1920x1080i_60Hz;
video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
if (EDIDVideoResolutionSupport(&video))
- LOGI("= c. 1080I_60 (0x0c000000) =\n");
+ ALOGI("= c. 1080I_60 (0x0c000000) =\n");
/* 1080I_50 */
video.resolution = v1920x1080i_50Hz;
video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
if (EDIDVideoResolutionSupport(&video))
- LOGI("= d. 1080I_50 (0x0d000000) =\n");
+ ALOGI("= d. 1080I_50 (0x0d000000) =\n");
/* 1080P_30 */
video.resolution = v1920x1080p_30Hz;
video.hdmi_3d_format = HDMI_2D_VIDEO_FORMAT;
if (EDIDVideoResolutionSupport(&video))
- LOGI("= e. 1080P_30 (0x12000000) =\n");
+ ALOGI("= e. 1080P_30 (0x12000000) =\n");
- LOGI("=========== HDMI 3D Format ========\n");
+ ALOGI("=========== HDMI 3D Format ========\n");
/* 720P_60_SBS_HALF */
video.resolution = v1280x720p_60Hz;
video.hdmi_3d_format = HDMI_3D_SSH_FORMAT;
if (EDIDVideoResolutionSupport(&video))
- LOGI("= f. 720P_60_SBS_HALF (0x13000000) =\n");
+ ALOGI("= f. 720P_60_SBS_HALF (0x13000000) =\n");
/* 720P_59_SBS_HALF */
video.resolution = v1280x720p_60Hz;
video.hdmi_3d_format = HDMI_3D_SSH_FORMAT;
if (EDIDVideoResolutionSupport(&video))
- LOGI("= 10. 720P_59_SBS_HALF (0x14000000) =\n");
+ ALOGI("= 10. 720P_59_SBS_HALF (0x14000000) =\n");
/* 720P_50_TB */
video.resolution = v1280x720p_50Hz;
video.hdmi_3d_format = HDMI_3D_TB_FORMAT;
if (EDIDVideoResolutionSupport(&video))
- LOGI("= 11. 720P_50_TB (0x15000000) =\n");
+ ALOGI("= 11. 720P_50_TB (0x15000000) =\n");
/* 1080P_24_TB */
video.resolution = v1920x1080p_24Hz;
video.hdmi_3d_format = HDMI_3D_TB_FORMAT;
if (EDIDVideoResolutionSupport(&video))
- LOGI("= 12. 1080P_24_TB (0x16000000) =\n");
+ ALOGI("= 12. 1080P_24_TB (0x16000000) =\n");
/* 1080P_23_TB */
video.resolution = v1920x1080p_24Hz;
video.hdmi_3d_format = HDMI_3D_TB_FORMAT;
if (EDIDVideoResolutionSupport(&video))
- LOGI("= 13. 1080P_24_TB (0x17000000) =\n");
- LOGI("=========================================\n");
+ ALOGI("= 13. 1080P_24_TB (0x17000000) =\n");
+ ALOGI("=========================================\n");
}
int tvout_init(int fd_tvout, __u32 preset_id)
{
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s::preset_id = 0x%x", __func__, preset_id);
+ ALOGD("%s::preset_id = 0x%x", __func__, preset_id);
#endif
int ret;
@@ -218,7 +218,7 @@
if (fd_tvout <= 0) {
fd_tvout = open(TVOUT0_DEV_G0, O_RDWR);
if (fd_tvout < 0) {
- LOGE("%s::fd_tvout open failed", __func__);
+ ALOGE("%s::fd_tvout open failed", __func__);
return -1;
}
}
@@ -226,14 +226,14 @@
if (output_type >= V4L2_OUTPUT_TYPE_DIGITAL &&
output_type <= V4L2_OUTPUT_TYPE_DVI)
if (ioctl(fd_tvout, VIDIOC_HDCP_ENABLE, g_hdcp_en) < 0)
- LOGE("%s::VIDIOC_HDCP_ENABLE failed %d", __func__, errno);
+ ALOGE("%s::VIDIOC_HDCP_ENABLE failed %d", __func__, errno);
*/
i = 0;
do {
output.index = i;
ret = tvout_v4l2_enum_output(fd_tvout, &output);
- LOGV("%s::output_type=%d output.index=%d .name=%s", __func__, output_type, output.index, output.name);
+ ALOGV("%s::output_type=%d output.index=%d .name=%s", __func__, output_type, output.index, output.name);
if (output.type == output_type) {
matched = 1;
break;
@@ -242,7 +242,7 @@
} while (ret >=0);
/*
if (!matched) {
- LOGE("%s::no matched output type [type=0x%08x]", __func__, output_type);
+ ALOGE("%s::no matched output type [type=0x%08x]", __func__, output_type);
return -1;
}
@@ -252,14 +252,14 @@
*/
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s::input preset_id=0x%08x", __func__, preset_id);
+ ALOGD("%s::input preset_id=0x%08x", __func__, preset_id);
#endif
if (output.capabilities & V4L2_OUT_CAP_PRESETS) {
tvout_std_v4l2_enum_dv_presets(fd_tvout);
preset.preset = preset_id;
if (tvout_std_v4l2_s_dv_preset(fd_tvout, &preset) < 0 ) {
- LOGE("%s::tvout_std_v4l2_s_dv_preset failed", __func__);
+ ALOGE("%s::tvout_std_v4l2_s_dv_preset failed", __func__);
return -1;
}
}
@@ -270,7 +270,7 @@
int tvout_deinit()
{
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
return 0;
@@ -279,22 +279,22 @@
int tvout_std_v4l2_querycap(int fd, char *node)
{
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
struct v4l2_capability v4l2cap;
if (ioctl(fd, VIDIOC_QUERYCAP, &v4l2cap) < 0) {
- LOGE("%s::VIDIOC_QUERYCAP failed", __func__);
+ ALOGE("%s::VIDIOC_QUERYCAP failed", __func__);
return -1;
}
if (!(v4l2cap.capabilities & V4L2_CAP_STREAMING)) {
- LOGE("%s::%s is not support streaming", __func__, node);
+ ALOGE("%s::%s is not support streaming", __func__, node);
return -1;
}
if (!(v4l2cap.capabilities & V4L2_CAP_VIDEO_OUTPUT_MPLANE)) {
- LOGE("%s::%s is not support video output mplane", __func__, node);
+ ALOGE("%s::%s is not support video output mplane", __func__, node);
return -1;
}
@@ -304,14 +304,14 @@
int tvout_std_v4l2_s_fmt(int fd, enum v4l2_buf_type type, enum v4l2_field field, int w, int h, int colorformat, int num_planes)
{
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
struct v4l2_format fmt;
fmt.type = type;
if (ioctl(fd, VIDIOC_G_FMT, &fmt) < 0) {
- LOGE("%s::VIDIOC_G_FMT failed", __func__);
+ ALOGE("%s::VIDIOC_G_FMT failed", __func__);
return -1;
}
@@ -332,13 +332,13 @@
fmt.fmt.pix_mp.num_planes = num_planes;
break;
default:
- LOGE("%s::invalid buffer type", __func__);
+ ALOGE("%s::invalid buffer type", __func__);
return -1;
break;
}
if (ioctl(fd, VIDIOC_S_FMT, &fmt) < 0) {
- LOGE("%s::VIDIOC_S_FMT failed", __func__);
+ ALOGE("%s::VIDIOC_S_FMT failed", __func__);
return -1;
}
@@ -348,7 +348,7 @@
int tvout_std_v4l2_s_crop(int fd, enum v4l2_buf_type type, enum v4l2_field, int x, int y, int w, int h)
{
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
struct v4l2_crop crop;
@@ -359,7 +359,7 @@
crop.c.height = h;
if (ioctl(fd, VIDIOC_S_CROP, &crop) < 0) {
- LOGE("%s::VIDIOC_S_CROP (x=%d, y=%d, w=%d, h=%d) failed",
+ ALOGE("%s::VIDIOC_S_CROP (x=%d, y=%d, w=%d, h=%d) failed",
__func__, x, y, w, h);
return -1;
}
@@ -370,7 +370,7 @@
int tvout_std_v4l2_s_ctrl(int fd, int id, int value)
{
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
struct v4l2_control vc;
@@ -378,7 +378,7 @@
vc.value = value;
if (ioctl(fd, VIDIOC_S_CTRL, &vc) < 0) {
- LOGE("%s::VIDIOC_S_CTRL (id=%d,value=%d) failed", __func__, id, value);
+ ALOGE("%s::VIDIOC_S_CTRL (id=%d,value=%d) failed", __func__, id, value);
return -1;
}
@@ -388,7 +388,7 @@
int tvout_std_v4l2_reqbuf(int fd, enum v4l2_buf_type type, enum v4l2_memory memory, unsigned int num_bufs)
{
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
struct v4l2_requestbuffers reqbuf;
@@ -397,12 +397,12 @@
reqbuf.count = num_bufs;
if (ioctl(fd, VIDIOC_REQBUFS, &reqbuf) < 0) {
- LOGE("%s::VIDIOC_REQBUFS failed", __func__);
+ ALOGE("%s::VIDIOC_REQBUFS failed", __func__);
return -1;
}
if (reqbuf.count < num_bufs) {
- LOGE("%s::VIDIOC_REQBUFS failed ((reqbuf.count(%d) < num_bufs(%d))",
+ ALOGE("%s::VIDIOC_REQBUFS failed ((reqbuf.count(%d) < num_bufs(%d))",
__func__, reqbuf.count, num_bufs);
return -1;
}
@@ -413,7 +413,7 @@
int tvout_std_v4l2_querybuf(int fd, enum v4l2_buf_type type, enum v4l2_memory memory, unsigned int buf_index, unsigned int num_planes, SecBuffer *secBuf)
{
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
struct v4l2_buffer buf;
struct v4l2_plane planes[MAX_PLANES_MIXER];
@@ -424,7 +424,7 @@
memset(&planes[i], 0, sizeof(struct v4l2_plane));
if (MAX_BUFFERS_MIXER <= buf_index || MAX_PLANES_MIXER <= num_planes) {
- LOGE("%s::exceed MAX! : buf_index=%d, num_plane=%d", __func__, buf_index, num_planes);
+ ALOGE("%s::exceed MAX! : buf_index=%d, num_plane=%d", __func__, buf_index, num_planes);
return -1;
}
@@ -435,24 +435,24 @@
buf.m.planes = planes;
if (ioctl(fd, VIDIOC_QUERYBUF, &buf) < 0) {
- LOGE("%s::VIDIOC_QUERYBUF failed, plane_cnt=%d", __func__, buf.length);
+ ALOGE("%s::VIDIOC_QUERYBUF failed, plane_cnt=%d", __func__, buf.length);
return -1;
}
for (unsigned int i = 0; i < num_planes; i++) {
if ((secBuf->virt.extP[i] = (char *)mmap(0, buf.m.planes[i].length,
PROT_READ | PROT_WRITE, MAP_SHARED, fd, buf.m.planes[i].m.mem_offset)) < 0) {
- LOGE("%s::mmap failed", __func__);
- LOGE("%s::Offset = 0x%x", __func__, buf.m.planes[i].m.mem_offset);
- LOGE("%s::Legnth = %d" , __func__, buf.m.planes[i].length);
- LOGE("%s::vaddr[%d][%d] = 0x%x", __func__, buf_index, i, (unsigned int)secBuf->virt.extP[i]);
+ ALOGE("%s::mmap failed", __func__);
+ ALOGE("%s::Offset = 0x%x", __func__, buf.m.planes[i].m.mem_offset);
+ ALOGE("%s::Legnth = %d" , __func__, buf.m.planes[i].length);
+ ALOGE("%s::vaddr[%d][%d] = 0x%x", __func__, buf_index, i, (unsigned int)secBuf->virt.extP[i]);
return -1;
}
secBuf->size.extS[i] = buf.m.planes[i].length;
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s::vaddr[bufindex=%d][planeidx=%d] = 0x%x", __func__, buf_index, i, (unsigned int)secBuf->virt.extP[i]);
- LOGD("%s::Legnth = %d" , __func__, buf.m.planes[i].length);
+ ALOGD("%s::vaddr[bufindex=%d][planeidx=%d] = 0x%x", __func__, buf_index, i, (unsigned int)secBuf->virt.extP[i]);
+ ALOGD("%s::Legnth = %d" , __func__, buf.m.planes[i].length);
#endif
}
@@ -462,7 +462,7 @@
int tvout_std_v4l2_qbuf(int fd, enum v4l2_buf_type type, enum v4l2_memory memory, int buf_index, int num_planes, SecBuffer *secBuf)
{
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
struct v4l2_buffer buf;
struct v4l2_plane planes[MAX_PLANES_MIXER];
@@ -484,15 +484,15 @@
buf.m.planes[i].bytesused = buf.m.planes[i].length;
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s::buf.index=%d", __func__, buf.index);
- LOGD("%s::buf.m.planes[%d].m.userptr=0x%08x", __func__, i, (unsigned int)buf.m.planes[i].m.userptr);
- LOGD("%s::buf.m.planes[%d].length =0x%08x", __func__, i, buf.m.planes[i].length);
- LOGD("%s::buf.m.planes[%d].bytesused=0x%08x", __func__, i, buf.m.planes[i].bytesused);
+ ALOGD("%s::buf.index=%d", __func__, buf.index);
+ ALOGD("%s::buf.m.planes[%d].m.userptr=0x%08x", __func__, i, (unsigned int)buf.m.planes[i].m.userptr);
+ ALOGD("%s::buf.m.planes[%d].length =0x%08x", __func__, i, buf.m.planes[i].length);
+ ALOGD("%s::buf.m.planes[%d].bytesused=0x%08x", __func__, i, buf.m.planes[i].bytesused);
#endif
}
if (ioctl(fd, VIDIOC_QBUF, &buf) < 0) {
- LOGE("%s::VIDIOC_QBUF failed", __func__);
+ ALOGE("%s::VIDIOC_QBUF failed", __func__);
return -1;
}
@@ -502,7 +502,7 @@
int tvout_std_v4l2_dqbuf(int fd, enum v4l2_buf_type type, enum v4l2_memory memory, int *buf_index, int num_planes)
{
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
struct v4l2_buffer buf;
struct v4l2_plane planes[MAX_PLANES_MIXER];
@@ -519,13 +519,13 @@
buf.m.planes = planes;
if (ioctl(fd, VIDIOC_DQBUF, &buf) < 0) {
- LOGE("%s::VIDIOC_DQBUF failed", __func__);
+ ALOGE("%s::VIDIOC_DQBUF failed", __func__);
return -1;
}
*buf_index = buf.index;
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s::buf.index=%d", __func__, buf.index);
+ ALOGD("%s::buf.index=%d", __func__, buf.index);
#endif
return 0;
@@ -534,10 +534,10 @@
int tvout_std_v4l2_streamon(int fd, enum v4l2_buf_type type)
{
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
if (ioctl(fd, VIDIOC_STREAMON, &type) < 0) {
- LOGE("%s::VIDIOC_STREAMON failed", __func__);
+ ALOGE("%s::VIDIOC_STREAMON failed", __func__);
return -1;
}
@@ -547,10 +547,10 @@
int tvout_std_v4l2_streamoff(int fd, enum v4l2_buf_type type)
{
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
if (ioctl(fd, VIDIOC_STREAMOFF, &type) < 0) {
- LOGE("%s::VIDIOC_STREAMOFF failed", __func__);
+ ALOGE("%s::VIDIOC_STREAMOFF failed", __func__);
return -1;
}
@@ -560,7 +560,7 @@
int tvout_v4l2_enum_output(int fd, struct v4l2_output *output)
{
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
int ret = -1 ;
ret = ioctl(fd, VIDIOC_ENUMOUTPUT, output);
@@ -568,10 +568,10 @@
if (ret < 0) {
if (errno == EINVAL)
return -1;
- LOGE("%s::VIDIOC_ENUMOUTPUT", __func__);
+ ALOGE("%s::VIDIOC_ENUMOUTPUT", __func__);
return -1;
}
- LOGD("%s::index=%d, type=0x%08x, name=%s",
+ ALOGD("%s::index=%d, type=0x%08x, name=%s",
__func__, output->index, output->type, output->name);
return ret;
@@ -580,10 +580,10 @@
int tvout_v4l2_s_output(int fd, int index)
{
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
if (ioctl(fd, VIDIOC_S_OUTPUT, &index) < 0) {
- LOGE("%s::VIDIOC_S_OUTPUT failed", __func__);
+ ALOGE("%s::VIDIOC_S_OUTPUT failed", __func__);
return -1;
}
@@ -593,10 +593,10 @@
int tvout_v4l2_g_output(int fd, int *index)
{
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
if (ioctl(fd, VIDIOC_G_OUTPUT, index) < 0) {
- LOGE("%s::VIDIOC_G_OUTPUT failed", __func__);
+ ALOGE("%s::VIDIOC_G_OUTPUT failed", __func__);
return -1;
}
@@ -606,7 +606,7 @@
int tvout_std_v4l2_enum_dv_presets(int fd)
{
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
struct v4l2_dv_enum_preset enum_preset;
int ret = -1;
@@ -618,10 +618,10 @@
if (ret < 0) {
if (errno == EINVAL)
break;
- LOGE("%s::VIDIOC_ENUM_DV_PRESETS", __func__);
+ ALOGE("%s::VIDIOC_ENUM_DV_PRESETS", __func__);
return -1;
}
- LOGD("%s::index=%d, preset=0x%08x, name=%s, w=%d, h=%d",
+ ALOGD("%s::index=%d, preset=0x%08x, name=%s, w=%d, h=%d",
__func__, enum_preset.index, enum_preset.preset, enum_preset.name, enum_preset.width, enum_preset.height);
}
@@ -631,14 +631,14 @@
int tvout_std_v4l2_s_dv_preset(int fd, struct v4l2_dv_preset *preset)
{
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
if (ioctl(fd, VIDIOC_S_DV_PRESET, preset) < 0) {
- LOGE("%s::VIDIOC_S_DV_PRESET failed preset_id=%d", __func__, preset->preset);
+ ALOGE("%s::VIDIOC_S_DV_PRESET failed preset_id=%d", __func__, preset->preset);
return -1;
}
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s::preset_id=%d", __func__, preset->preset);
+ ALOGD("%s::preset_id=%d", __func__, preset->preset);
#endif
return 0;
}
@@ -646,7 +646,7 @@
int tvout_std_subdev_s_fmt(int fd, unsigned int pad, int w, int h, enum v4l2_mbus_pixelcode code)
{
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
struct v4l2_subdev_format fmt;
@@ -657,19 +657,19 @@
fmt.format.code = code;
if (ioctl(fd, VIDIOC_SUBDEV_S_FMT, &fmt) < 0) {
- LOGE("%s::VIDIOC_SUBDEV_S_FMT", __func__);
+ ALOGE("%s::VIDIOC_SUBDEV_S_FMT", __func__);
return -1;
}
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s::format w=%d, h=%d", __func__, fmt.format.width, fmt.format.height);
+ ALOGD("%s::format w=%d, h=%d", __func__, fmt.format.width, fmt.format.height);
#endif
return 0;
}
int tvout_std_subdev_s_crop(int fd, unsigned int pad, int x, int y, int w, int h)
{
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s::pad=%d, crop x=%d, y=%d, w=%d, h=%d", __func__, pad, x, y, w, h);
+ ALOGD("%s::pad=%d, crop x=%d, y=%d, w=%d, h=%d", __func__, pad, x, y, w, h);
#endif
struct v4l2_subdev_crop crop;
@@ -682,12 +682,12 @@
crop.rect.height = h;
if (ioctl(fd, VIDIOC_SUBDEV_S_CROP, &crop) < 0) {
- LOGE("%s::VIDIOC_SUBDEV_S_CROP", __func__);
+ ALOGE("%s::VIDIOC_SUBDEV_S_CROP", __func__);
return -1;
}
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s::pad=%d, crop x=%d, y=%d, w=%d, h=%d", __func__, pad, crop.rect.left, crop.rect.top, crop.rect.width, crop.rect.height);
+ ALOGD("%s::pad=%d, crop x=%d, y=%d, w=%d, h=%d", __func__, pad, crop.rect.left, crop.rect.top, crop.rect.width, crop.rect.height);
#endif
return 0;
@@ -715,20 +715,20 @@
int hdmi_set_videolayer(int fd, int hdmiW, int hdmiH, struct v4l2_rect * rect)
{
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
if (tvout_std_subdev_s_fmt(fd, MIXER_V_SUBDEV_PAD_SINK, hdmiW, hdmiH, V4L2_MBUS_FMT_YUV8_1X24) < 0) {
- LOGE("%s::tvout_std_subdev_s_fmt(PAD=%d)[videolayer] failed", __func__, MIXER_V_SUBDEV_PAD_SINK);
+ ALOGE("%s::tvout_std_subdev_s_fmt(PAD=%d)[videolayer] failed", __func__, MIXER_V_SUBDEV_PAD_SINK);
return -1;
}
if (tvout_std_subdev_s_crop(fd, MIXER_V_SUBDEV_PAD_SINK, 0, 0, rect->width, rect->height) < 0) {
- LOGE("%s::tvout_std_subdev_s_crop(PAD=%d)[videolayer] failed", __func__, MIXER_V_SUBDEV_PAD_SINK);
+ ALOGE("%s::tvout_std_subdev_s_crop(PAD=%d)[videolayer] failed", __func__, MIXER_V_SUBDEV_PAD_SINK);
return -1;
}
if (tvout_std_subdev_s_crop(fd, MIXER_V_SUBDEV_PAD_SOURCE, rect->left, rect->top, rect->width, rect->height) < 0) {
- LOGE("%s::tvout_std_subdev_s_crop(PAD=%d)[videolayer] failed", __func__, MIXER_V_SUBDEV_PAD_SOURCE);
+ ALOGE("%s::tvout_std_subdev_s_crop(PAD=%d)[videolayer] failed", __func__, MIXER_V_SUBDEV_PAD_SOURCE);
return -1;
}
return 0;
@@ -742,7 +742,7 @@
int rotVal)
{
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
#if defined(BOARD_USES_HDMI_FIMGAPI)
int dst_color_format;
@@ -822,7 +822,7 @@
g2d_rotation = ROT_270;
break;
default:
- LOGE("%s::invalid rotVal(%d) : failed", __func__, rotVal);
+ ALOGE("%s::invalid rotVal(%d) : failed", __func__, rotVal);
return -1;
break;
}
@@ -830,7 +830,7 @@
BlitParam = {BLIT_OP_SRC, NON_PREMULTIPLIED, 0xff, 0, g2d_rotation, &Scaling, 0, 0, &dstClip, 0, &srcImage, &dstImage, NULL, &srcRect, &dstRect, NULL, 0};
if (stretchFimgApi(&BlitParam) < 0) {
- LOGE("%s::stretchFimgApi() failed", __func__);
+ ALOGE("%s::stretchFimgApi() failed", __func__);
return -1;
}
@@ -849,7 +849,7 @@
int dst_x, int dst_y, int dst_w, int dst_h)
{
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
struct v4l2_rect rect;
int src_pad = 0;
@@ -866,7 +866,7 @@
src_pad = MIXER_G1_SUBDEV_PAD_SOURCE;
break;
default:
- LOGE("%s::invalid layer(%d)", __func__, layer);
+ ALOGE("%s::invalid layer(%d)", __func__, layer);
break;
};
@@ -883,34 +883,34 @@
/* set sub device for mixer graphic layer input */
if (tvout_std_subdev_s_fmt(fd_subdev, sink_pad, rect.width, rect.height, V4L2_MBUS_FMT_XRGB8888_4X8_LE) < 0) {
- LOGE("%s::tvout_std_subdev_s_fmt(PAD=%d)[graphic layer] failed", __func__, sink_pad);
+ ALOGE("%s::tvout_std_subdev_s_fmt(PAD=%d)[graphic layer] failed", __func__, sink_pad);
return -1;
}
if (tvout_std_subdev_s_crop(fd_subdev, sink_pad, 0, 0, rect.width, rect.height) < 0) {
- LOGE("%s::tvout_std_subdev_s_crop(PAD=%d)[graphic layer] failed", __func__, sink_pad);
+ ALOGE("%s::tvout_std_subdev_s_crop(PAD=%d)[graphic layer] failed", __func__, sink_pad);
return -1;
}
if (tvout_std_subdev_s_crop(fd_subdev, src_pad, rect.left, rect.top, rect.width, rect.height) < 0) {
- LOGE("%s::tvout_std_subdev_s_crop(PAD=%d)[graphic layer] failed", __func__, src_pad);
+ ALOGE("%s::tvout_std_subdev_s_crop(PAD=%d)[graphic layer] failed", __func__, src_pad);
return -1;
}
/* set format for mixer graphic layer input device*/
if (tvout_std_v4l2_s_fmt(fd_videodev, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_FIELD_ANY, rect.width, rect.height, v4l2ColorFormat, 1) < 0) {
- LOGE("%s::tvout_std_v4l2_s_fmt()[graphic layer] failed", __func__);
+ ALOGE("%s::tvout_std_v4l2_s_fmt()[graphic layer] failed", __func__);
return -1;
}
if (tvout_std_v4l2_s_crop(fd_videodev, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_FIELD_ANY, rect.left, rect.top, rect.width, rect.height) < 0) {
- LOGE("%s::tvout_std_v4l2_s_crop()[graphic layer] failed", __func__);
+ ALOGE("%s::tvout_std_v4l2_s_crop()[graphic layer] failed", __func__);
return -1;
}
/* request buffer for mixer graphic layer input device */
if (tvout_std_v4l2_reqbuf(fd_videodev, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_MEMORY_USERPTR, 2) < 0) {
- LOGE("%s::tvout_std_v4l2_reqbuf(buf_num=%d)[graphic layer] failed", __func__, 2);
+ ALOGE("%s::tvout_std_v4l2_reqbuf(buf_num=%d)[graphic layer] failed", __func__, 2);
return -1;
}
@@ -920,7 +920,7 @@
int hdmi_cable_status()
{
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("%s", __func__);
+ ALOGD("%s", __func__);
#endif
int cable_status = 0;
@@ -929,21 +929,21 @@
fd = open(TVOUT0_DEV_G0, O_RDWR);
if (fd <= 0) {
- LOGE("%s: graphic layer 0 drv open failed", __func__);
+ ALOGE("%s: graphic layer 0 drv open failed", __func__);
return -1;
}
ctrl.id = V4L2_CID_TV_HPD_STATUS;
if (ioctl(fd, VIDIOC_S_CTRL, &ctrl) < 0) {
- LOGE("Get HPD_STATUS fail");
+ ALOGE("Get HPD_STATUS fail");
cable_status = -1;
} else {
cable_status = ctrl.value;
}
#ifdef DEBUG_HDMI_HW_LEVEL
- LOGD("HPD_STATUS = %d", cable_status);
+ ALOGD("HPD_STATUS = %d", cable_status);
#endif
close(fd);
@@ -969,7 +969,7 @@
v4l2_output_type = V4L2_OUTPUT_TYPE_COMPOSITE;
break;
default:
- LOGE("%s::unmathced HDMI_mode(%d)", __func__, output_mode);
+ ALOGE("%s::unmathced HDMI_mode(%d)", __func__, output_mode);
v4l2_output_type = -1;
break;
}
@@ -995,7 +995,7 @@
outputMode = COMPOSITE_OUTPUT_MODE;
break;
default:
- LOGE("%s::unmathced v4l2_output_type(%d)", __func__, v4l2_output_type);
+ ALOGE("%s::unmathced v4l2_output_type(%d)", __func__, v4l2_output_type);
outputMode = -1;
break;
}
@@ -1030,7 +1030,7 @@
std_id = V4L2_STD_PAL_60;
break;
default:
- LOGE("%s::unmathced composite_std(%d)", __func__, std);
+ ALOGE("%s::unmathced composite_std(%d)", __func__, std);
break;
}
@@ -1053,14 +1053,14 @@
video.mode = HDMI;
if (!EDIDHDMIModeSupport(&video)) {
calbirate_v4l2_mode = V4L2_OUTPUT_TYPE_DVI;
- LOGI("Change mode into DVI\n");
+ ALOGI("Change mode into DVI\n");
break;
}
video.colorSpace = HDMI_CS_YCBCR444;
if (!EDIDColorSpaceSupport(&video)) {
calbirate_v4l2_mode = V4L2_OUTPUT_TYPE_HDMI_RGB;
- LOGI("Change mode into HDMI_RGB\n");
+ ALOGI("Change mode into HDMI_RGB\n");
}
break;
@@ -1068,14 +1068,14 @@
video.mode = HDMI;
if (!EDIDHDMIModeSupport(&video)) {
calbirate_v4l2_mode = V4L2_OUTPUT_TYPE_DVI;
- LOGI("Change mode into DVI\n");
+ ALOGI("Change mode into DVI\n");
break;
}
video.colorSpace = HDMI_CS_RGB;
if (!EDIDColorSpaceSupport(&video)) {
calbirate_v4l2_mode = V4L2_OUTPUT_TYPE_DIGITAL;
- LOGI("Change mode into HDMI_YCBCR\n");
+ ALOGI("Change mode into HDMI_YCBCR\n");
}
break;
@@ -1085,10 +1085,10 @@
video.colorSpace = HDMI_CS_YCBCR444;
if (!EDIDColorSpaceSupport(&video)) {
calbirate_v4l2_mode = V4L2_OUTPUT_TYPE_HDMI_RGB;
- LOGI("Change mode into HDMI_RGB\n");
+ ALOGI("Change mode into HDMI_RGB\n");
} else {
calbirate_v4l2_mode = V4L2_OUTPUT_TYPE_DIGITAL;
- LOGI("Change mode into HDMI_YCBCR\n");
+ ALOGI("Change mode into HDMI_YCBCR\n");
}
break;
}
@@ -1192,14 +1192,14 @@
video.hdmi_3d_format = HDMI_3D_TB_FORMAT;
break;
default:
- LOGE("%s::unmathced std_id(%lld)", __func__, std_id);
+ ALOGE("%s::unmathced std_id(%lld)", __func__, std_id);
return -1;
break;
}
if (!EDIDVideoResolutionSupport(&video)) {
#ifdef DEBUG_MSG_ENABLE
- LOGD("%s::EDIDVideoResolutionSupport(%llx) fail (not suppoted std_id) \n", __func__, std_id);
+ ALOGD("%s::EDIDVideoResolutionSupport(%llx) fail (not suppoted std_id) \n", __func__, std_id);
#endif
return -1;
}
@@ -1297,7 +1297,7 @@
*preset_id = V4L2_DV_480P60;
break;
default:
- LOGE("%s::unmathced resolution(%d)", __func__, resolution);
+ ALOGE("%s::unmathced resolution(%d)", __func__, resolution);
ret = -1;
break;
}
@@ -1308,7 +1308,7 @@
int hdmi_enable_hdcp(int fd, unsigned int hdcp_en)
{
if (ioctl(fd, VIDIOC_HDCP_ENABLE, hdcp_en) < 0) {
- LOGD("%s::VIDIOC_HDCP_ENABLE(%d) fail \n", __func__, hdcp_en);
+ ALOGD("%s::VIDIOC_HDCP_ENABLE(%d) fail \n", __func__, hdcp_en);
return -1;
}
@@ -1334,12 +1334,12 @@
#endif
if (audio_state == ON) {
if (ioctl(fd, VIDIOC_INIT_AUDIO, 1) < 0) {
- LOGE("%s::VIDIOC_INIT_AUDIO(1) failed", __func__);
+ ALOGE("%s::VIDIOC_INIT_AUDIO(1) failed", __func__);
ret = -1;
}
} else {
if (ioctl(fd, VIDIOC_INIT_AUDIO, 0) < 0) {
- LOGE("%s::VIDIOC_INIT_AUDIO(0) failed", __func__);
+ ALOGE("%s::VIDIOC_INIT_AUDIO(0) failed", __func__);
ret = -1;
}
}
diff --git a/exynos5/hal/libhdmi/SecHdmi/SecHdmiV4L2Utils.h b/exynos5/hal/libhdmi/SecHdmi/SecHdmiV4L2Utils.h
index 67c0729..c772bf1 100644
--- a/exynos5/hal/libhdmi/SecHdmi/SecHdmiV4L2Utils.h
+++ b/exynos5/hal/libhdmi/SecHdmi/SecHdmiV4L2Utils.h
@@ -17,8 +17,8 @@
#ifndef __HDMI_HAL_V4L2_UTILS_H__
#define __HDMI_HAL_V4L2_UTILS_H__
-//#define LOG_NDEBUG 0
-//#define LOG_TAG "libhdmi"
+//#define ALOG_NDEBUG 0
+//#define ALOG_TAG "libhdmi"
#include "fimd_api.h"
#include "SecBuffer.h"
diff --git a/exynos5/hal/libhdmi/SecHdmi/fimd_api.c b/exynos5/hal/libhdmi/SecHdmi/fimd_api.c
index 0e07ef3..0f14f5d 100644
--- a/exynos5/hal/libhdmi/SecHdmi/fimd_api.c
+++ b/exynos5/hal/libhdmi/SecHdmi/fimd_api.c
@@ -41,7 +41,7 @@
fp = open(node, O_RDWR);
if (fp < 0)
- LOGE("%s: fb[%d] open failed", __func__, win);
+ ALOGE("%s: fb[%d] open failed", __func__, win);
return fp;
}
@@ -51,7 +51,7 @@
if (fp)
close(fp);
else
- LOGE("%s: fb is not allocated %d", __func__, fp);
+ ALOGE("%s: fb is not allocated %d", __func__, fp);
return 0;
}
@@ -62,7 +62,7 @@
ret = ioctl(fp, FBIOGET_FSCREENINFO, fix);
if (ret)
- LOGE("%s: FBIOGET_FSCREENINFO failed", __func__);
+ ALOGE("%s: FBIOGET_FSCREENINFO failed", __func__);
return ret;
}
@@ -73,7 +73,7 @@
ret = ioctl(fp, FBIOGET_VSCREENINFO, var);
if (ret)
- LOGE("%s:: FBIOGET_VSCREENINFO failed", __func__);
+ ALOGE("%s:: FBIOGET_VSCREENINFO failed", __func__);
return ret;
}
@@ -84,7 +84,7 @@
ret = ioctl(fp, FBIOPUT_VSCREENINFO, var);
if (ret)
- LOGE("%s:: FBIOPUT_VSCREENINFO failed", __func__);
+ ALOGE("%s:: FBIOPUT_VSCREENINFO failed", __func__);
return ret;
}
@@ -102,7 +102,7 @@
buffer = (char *)mmap(0, size, PROT_READ | PROT_WRITE,
MAP_SHARED, fp, 0);
if (!buffer) {
- LOGE("%s:: mmap failed", __func__);
+ ALOGE("%s:: mmap failed", __func__);
return NULL;
}
@@ -115,7 +115,7 @@
ret = ioctl(fp, cmd, arg);
if (ret < 0)
- LOGE("%s:: ioctl (%d) failed", __func__, cmd);
+ ALOGE("%s:: ioctl (%d) failed", __func__, cmd);
return ret;
}
@@ -126,7 +126,7 @@
ret = ioctl(fp, FBIOBLANK, FB_BLANK_UNBLANK);
if (ret)
- LOGE("%s:: FBIOBLANK failed", __func__);
+ ALOGE("%s:: FBIOBLANK failed", __func__);
return ret;
}
@@ -137,7 +137,7 @@
ret = ioctl(fp, FBIOBLANK, FB_BLANK_POWERDOWN);
if (ret)
- LOGE("%s:: FBIOBLANK failed", __func__);
+ ALOGE("%s:: FBIOBLANK failed", __func__);
return ret;
}
@@ -152,7 +152,7 @@
return -1;
if (ioctl(fp, FBIOBLANK, FB_BLANK_POWERDOWN) < 0)
- LOGE("%s:: FBIOBLANK failed", __func__);
+ ALOGE("%s:: FBIOBLANK failed", __func__);
fb_off(fp);
fb_close(fp);
diff --git a/exynos5/hal/libhdmi/libhdmiservice/MessageQueue.cpp b/exynos5/hal/libhdmi/libhdmiservice/MessageQueue.cpp
index fb58ef9..91f3336 100644
--- a/exynos5/hal/libhdmi/libhdmiservice/MessageQueue.cpp
+++ b/exynos5/hal/libhdmi/libhdmiservice/MessageQueue.cpp
@@ -107,7 +107,7 @@
}
if (nextEventTime >= 0) {
- //LOGD("nextEventTime = %lld ms", nextEventTime);
+ //ALOGD("nextEventTime = %lld ms", nextEventTime);
if (nextEventTime > 0) {
// we're about to wait, flush the binder command buffer
IPCThreadState::self()->flushCommands();
@@ -117,7 +117,7 @@
}
}
} else {
- //LOGD("going to wait");
+ //ALOGD("going to wait");
// we're about to wait, flush the binder command buffer
IPCThreadState::self()->flushCommands();
mCondition.wait(mLock);
@@ -160,7 +160,7 @@
message->when = systemTime() + relTime;
mMessages.insert(message);
- //LOGD("MessageQueue::queueMessage time = %lld ms", message->when);
+ //ALOGD("MessageQueue::queueMessage time = %lld ms", message->when);
//dumpLocked(message);
mCondition.signal();
@@ -180,7 +180,7 @@
int c = 0;
while (cur != end) {
const char tick = (*cur == message) ? '>' : ' ';
- LOGD("%c %d: msg{.what=%08x, when=%lld}",
+ ALOGD("%c %d: msg{.what=%08x, when=%lld}",
tick, c, (*cur)->what, (*cur)->when);
++cur;
c++;
diff --git a/exynos5/hal/libhdmi/libhdmiservice/SecHdmiClient.cpp b/exynos5/hal/libhdmi/libhdmiservice/SecHdmiClient.cpp
index 150aadf..430ea4e 100644
--- a/exynos5/hal/libhdmi/libhdmiservice/SecHdmiClient.cpp
+++ b/exynos5/hal/libhdmi/libhdmiservice/SecHdmiClient.cpp
@@ -22,7 +22,7 @@
** @date 2011-07-06
*/
-#define LOG_TAG "libhdmiclient"
+#define ALOG_TAG "libhdmiclient"
#include "SecHdmiClient.h"
@@ -47,7 +47,7 @@
void SecHdmiClient::setHdmiCableStatus(int status)
{
- LOGD("%s HDMI status: %d\n", __func__, status);
+ ALOGD("%s HDMI status: %d\n", __func__, status);
if (g_SecTVOutService != 0)
g_SecTVOutService->setHdmiCableStatus(status);
@@ -55,7 +55,7 @@
void SecHdmiClient::setHdmiMode(int mode)
{
- //LOGD("%s HDMI Mode: %d\n", __func__, mode);
+ //ALOGD("%s HDMI Mode: %d\n", __func__, mode);
if (g_SecTVOutService != 0)
g_SecTVOutService->setHdmiMode(mode);
@@ -63,7 +63,7 @@
void SecHdmiClient::setHdmiResolution(int resolution)
{
- //LOGD("%s HDMI Resolution: %d\n", __func__, resolution);
+ //ALOGD("%s HDMI Resolution: %d\n", __func__, resolution);
if (g_SecTVOutService != 0)
g_SecTVOutService->setHdmiResolution(resolution);
@@ -71,7 +71,7 @@
void SecHdmiClient::setHdmiHdcp(int enHdcp)
{
- //LOGD("%s HDMI HDCP: %d\n", __func__, enHdcp);
+ //ALOGD("%s HDMI HDCP: %d\n", __func__, enHdcp);
if (g_SecTVOutService != 0)
g_SecTVOutService->setHdmiHdcp(enHdcp);
@@ -79,7 +79,7 @@
void SecHdmiClient::setHdmiRotate(int rotVal, uint32_t hwcLayer)
{
- //LOGD("%s HDMI ROTATE: %d\n", __func__, rotVal);
+ //ALOGD("%s HDMI ROTATE: %d\n", __func__, rotVal);
if (g_SecTVOutService != 0)
g_SecTVOutService->setHdmiRotate(rotVal, hwcLayer);
@@ -87,7 +87,7 @@
void SecHdmiClient::setHdmiHwcLayer(uint32_t hwcLayer)
{
- //LOGD("%s HDMI HWCLAYER: %d\n", __func__, hwcLayer);
+ //ALOGD("%s HDMI HWCLAYER: %d\n", __func__, hwcLayer);
if (g_SecTVOutService != 0)
g_SecTVOutService->setHdmiHwcLayer(hwcLayer);
@@ -119,7 +119,7 @@
for(getSvcTimes = 0; getSvcTimes < GETSERVICETIMEOUT; getSvcTimes++) {
binder = sm->getService(String16("SecTVOutService"));
if (binder == 0) {
- LOGW("SecTVOutService not published, waiting...");
+ ALOGW("SecTVOutService not published, waiting...");
usleep(500000); // 0.5 s
} else {
break;
@@ -130,7 +130,7 @@
sc = interface_cast<ISecTVOut>(binder);
g_SecTVOutService = sc;
} else {
- LOGW("Failed to get SecTVOutService... SecHdmiClient will get it later..");
+ ALOGW("Failed to get SecTVOutService... SecHdmiClient will get it later..");
}
}
return g_SecTVOutService;
diff --git a/exynos5/hal/libhdmi/libhdmiservice/SecTVOutService.cpp b/exynos5/hal/libhdmi/libhdmiservice/SecTVOutService.cpp
index 39ef742..3666106 100644
--- a/exynos5/hal/libhdmi/libhdmiservice/SecTVOutService.cpp
+++ b/exynos5/hal/libhdmi/libhdmiservice/SecTVOutService.cpp
@@ -22,7 +22,7 @@
** @date 2011-07-06
*/
-#define LOG_TAG "SecTVOutService"
+#define ALOG_TAG "SecTVOutService"
#include <binder/IServiceManager.h>
#include <utils/RefBase.h>
@@ -61,15 +61,15 @@
int SecTVOutService::instantiate()
{
- LOGD("SecTVOutService instantiate");
+ ALOGD("SecTVOutService instantiate");
int r = defaultServiceManager()->addService(String16( "SecTVOutService"), new SecTVOutService ());
- LOGD("SecTVOutService r=%d", r);
+ ALOGD("SecTVOutService r=%d", r);
return r;
}
SecTVOutService::SecTVOutService () {
- LOGV("SecTVOutService created");
+ ALOGV("SecTVOutService created");
mHdmiCableInserted = false;
#ifdef SUPPORT_G2D_UI_MODE
mUILayerMode = SecHdmi::HDMI_LAYER_GRAPHIC_1;
@@ -81,7 +81,7 @@
setLCDsize();
if (mSecHdmi.create(mLCD_width, mLCD_height) == false)
- LOGE("%s::mSecHdmi.create() fail", __func__);
+ ALOGE("%s::mSecHdmi.create() fail", __func__);
else
setHdmiStatus(1);
@@ -118,7 +118,7 @@
}
SecTVOutService::~SecTVOutService () {
- LOGV ("SecTVOutService destroyed");
+ ALOGV ("SecTVOutService destroyed");
if (mHdmiFlushThread != NULL) {
mHdmiFlushThread->requestExit();
@@ -178,7 +178,7 @@
} break;
default :
- LOGE ( "onTransact::default");
+ ALOGE ( "onTransact::default");
return BBinder::onTransact (code, data, reply, flags);
}
@@ -187,7 +187,7 @@
void SecTVOutService::setHdmiStatus(uint32_t status)
{
- LOGD("%s HDMI cable status = %d", __func__, status);
+ ALOGD("%s HDMI cable status = %d", __func__, status);
{
Mutex::Autolock _l(mLock);
@@ -198,12 +198,12 @@
if (hdmiCableInserted == true) {
if (mSecHdmi.connect() == false) {
- LOGE("%s::mSecHdmi.connect() fail", __func__);
+ ALOGE("%s::mSecHdmi.connect() fail", __func__);
hdmiCableInserted = false;
}
} else {
if (mSecHdmi.disconnect() == false)
- LOGE("%s::mSecHdmi.disconnect() fail", __func__);
+ ALOGE("%s::mSecHdmi.disconnect() fail", __func__);
}
mHdmiCableInserted = hdmiCableInserted;
@@ -215,51 +215,51 @@
void SecTVOutService::setHdmiMode(uint32_t mode)
{
- LOGD("%s TV mode = %d", __func__, mode);
+ ALOGD("%s TV mode = %d", __func__, mode);
Mutex::Autolock _l(mLock);
if ((hdmiCableInserted() == true) && (mSecHdmi.setHdmiOutputMode(mode)) == false) {
- LOGE("%s::mSecHdmi.setHdmiOutputMode() fail", __func__);
+ ALOGE("%s::mSecHdmi.setHdmiOutputMode() fail", __func__);
return;
}
}
void SecTVOutService::setHdmiResolution(uint32_t resolution)
{
- LOGD("%s TV resolution = %d", __func__, resolution);
+ ALOGD("%s TV resolution = %d", __func__, resolution);
Mutex::Autolock _l(mLock);
if ((hdmiCableInserted() == true) && (mSecHdmi.setHdmiResolution(resolution)) == false) {
- LOGE("%s::mSecHdmi.setHdmiResolution() fail", __func__);
+ ALOGE("%s::mSecHdmi.setHdmiResolution() fail", __func__);
return;
}
}
void SecTVOutService::setHdmiHdcp(uint32_t hdcp_en)
{
- LOGD("%s TV HDCP = %d", __func__, hdcp_en);
+ ALOGD("%s TV HDCP = %d", __func__, hdcp_en);
Mutex::Autolock _l(mLock);
if ((hdmiCableInserted() == true) && (mSecHdmi.setHdcpMode(hdcp_en)) == false) {
- LOGE("%s::mSecHdmi.setHdcpMode() fail", __func__);
+ ALOGE("%s::mSecHdmi.setHdcpMode() fail", __func__);
return;
}
}
void SecTVOutService::setHdmiRotate(uint32_t rotVal, uint32_t hwcLayer)
{
- //LOGD("%s TV ROTATE = %d", __func__, rotVal);
+ //ALOGD("%s TV ROTATE = %d", __func__, rotVal);
Mutex::Autolock _l(mLock);
if ((hdmiCableInserted() == true) && (mSecHdmi.setUIRotation(rotVal, hwcLayer)) == false) {
- LOGE("%s::mSecHdmi.setUIRotation() fail", __func__);
+ ALOGE("%s::mSecHdmi.setUIRotation() fail", __func__);
return;
}
}
void SecTVOutService::setHdmiHwcLayer(uint32_t hwcLayer)
{
- //LOGD("%s TV HWCLAYER = %d", __func__, hwcLayer);
+ //ALOGD("%s TV HWCLAYER = %d", __func__, hwcLayer);
Mutex::Autolock _l(mLock);
mHwcLayer = hwcLayer;
@@ -301,14 +301,14 @@
for (int layer = SecHdmi::HDMI_LAYER_BASE + 1; layer < SecHdmi::HDMI_LAYER_MAX; layer++) {
if (layer != mUILayerMode) {
if (mSecHdmi.clear(layer) == false)
- LOGE("%s::mSecHdmi.clear(%d) fail", __func__, layer);
+ ALOGE("%s::mSecHdmi.clear(%d) fail", __func__, layer);
}
}
}
if (mUILayerMode != hdmiLayer) {
if (mSecHdmi.clear(mUILayerMode) == false)
- LOGE("%s::mSecHdmi.clear(%d) fail", __func__, mUILayerMode);
+ ALOGE("%s::mSecHdmi.clear(%d) fail", __func__, mUILayerMode);
}
mUILayerMode = hdmiLayer;
@@ -323,10 +323,10 @@
#endif
if (mSecHdmi.flush(w, h, colorFormat, pPhyYAddr, pPhyCbAddr, pPhyCrAddr, dstX, dstY,
mUILayerMode, mHwcLayer) == false)
- LOGE("%s::mSecHdmi.flush() on HDMI_MODE_UI fail", __func__);
+ ALOGE("%s::mSecHdmi.flush() on HDMI_MODE_UI fail", __func__);
#ifdef CHECK_UI_TIME
end = systemTime();
- LOGD("[UI] mSecHdmi.flush[end-start] = %ld ms", long(ns2ms(end)) - long(ns2ms(start)));
+ ALOGD("[UI] mSecHdmi.flush[end-start] = %ld ms", long(ns2ms(end)) - long(ns2ms(start)));
#endif
}
#else
@@ -347,10 +347,10 @@
#endif
if (mSecHdmi.flush(w, h, colorFormat, pPhyYAddr, pPhyCbAddr, pPhyCrAddr, dstX, dstY,
SecHdmi::HDMI_LAYER_VIDEO, mHwcLayer) == false)
- LOGE("%s::mSecHdmi.flush() on HDMI_MODE_VIDEO fail", __func__);
+ ALOGE("%s::mSecHdmi.flush() on HDMI_MODE_VIDEO fail", __func__);
#ifdef CHECK_VIDEO_TIME
end = systemTime();
- LOGD("[Video] mSecHdmi.flush[end-start] = %ld ms", long(ns2ms(end)) - long(ns2ms(start)));
+ ALOGD("[Video] mSecHdmi.flush[end-start] = %ld ms", long(ns2ms(end)) - long(ns2ms(start)));
#endif
#else
msg = new SecHdmiEventMsg(&mSecHdmi, w, h, colorFormat, pPhyYAddr, pPhyCbAddr, pPhyCrAddr,
@@ -362,7 +362,7 @@
break;
default:
- LOGE("unmatched HDMI_MODE : %d", hdmiMode);
+ ALOGE("unmatched HDMI_MODE : %d", hdmiMode);
break;
}
diff --git a/exynos5/hal/libhdmi/libhdmiservice/SecTVOutService.h b/exynos5/hal/libhdmi/libhdmiservice/SecTVOutService.h
index caece73..e6616a2 100644
--- a/exynos5/hal/libhdmi/libhdmiservice/SecTVOutService.h
+++ b/exynos5/hal/libhdmi/libhdmiservice/SecTVOutService.h
@@ -139,13 +139,13 @@
#endif
if (pSecHdmi->flush(mSrcWidth, mSrcHeight, mSrcColorFormat, mSrcYAddr, mSrcCbAddr, mSrcCrAddr,
mDstX, mDstY, mHdmiLayer, mHwcLayer) == false) {
- LOGE("%s::pSecHdmi->flush() fail on HDMI_MODE_UI", __func__);
+ ALOGE("%s::pSecHdmi->flush() fail on HDMI_MODE_UI", __func__);
ret = false;
}
#ifdef CHECK_UI_TIME
end = systemTime();
- LOGD("[UI] pSecHdmi->flush[end-start] = %ld ms", long(ns2ms(end)) - long(ns2ms(start)));
+ ALOGD("[UI] pSecHdmi->flush[end-start] = %ld ms", long(ns2ms(end)) - long(ns2ms(start)));
#endif
break;
case HDMI_MODE_VIDEO:
@@ -154,16 +154,16 @@
#endif
if (pSecHdmi->flush(mSrcWidth, mSrcHeight, mSrcColorFormat, mSrcYAddr, mSrcCbAddr, mSrcCrAddr,
mDstX, mDstY, mHdmiLayer, mHwcLayer) == false) {
- LOGE("%s::pSecHdmi->flush() fail on HDMI_MODE_VIDEO", __func__);
+ ALOGE("%s::pSecHdmi->flush() fail on HDMI_MODE_VIDEO", __func__);
ret = false;
}
#ifdef CHECK_VIDEO_TIME
end = systemTime();
- LOGD("[VIDEO] pSecHdmi->flush[end-start] = %ld ms", long(ns2ms(end)) - long(ns2ms(start)));
+ ALOGD("[VIDEO] pSecHdmi->flush[end-start] = %ld ms", long(ns2ms(end)) - long(ns2ms(start)));
#endif
break;
default:
- LOGE("Undefined HDMI_MODE");
+ ALOGE("Undefined HDMI_MODE");
ret = false;
break;
}
diff --git a/exynos5/hal/libhdmi/libsForhdmi/libcec/libcec.c b/exynos5/hal/libhdmi/libsForhdmi/libcec/libcec.c
index e688051..e088346 100644
--- a/exynos5/hal/libhdmi/libsForhdmi/libcec/libcec.c
+++ b/exynos5/hal/libhdmi/libsForhdmi/libcec/libcec.c
@@ -74,7 +74,7 @@
CECClose();
if ((fd = open(CEC_DEVICE_NAME, O_RDWR)) < 0) {
- LOGE("Can't open %s!\n", CEC_DEVICE_NAME);
+ ALOGE("Can't open %s!\n", CEC_DEVICE_NAME);
res = 0;
}
@@ -92,7 +92,7 @@
if (fd != -1) {
if (close(fd) != 0) {
- LOGE("close() failed!\n");
+ ALOGE("close() failed!\n");
res = 0;
}
fd = -1;
@@ -115,12 +115,12 @@
int i = 0;
if (fd == -1) {
- LOGE("open device first!\n");
+ ALOGE("open device first!\n");
return 0;
}
if (CECSetLogicalAddr(laddr) < 0) {
- LOGE("CECSetLogicalAddr() failed!\n");
+ ALOGE("CECSetLogicalAddr() failed!\n");
return 0;
}
@@ -141,12 +141,12 @@
}
if (laddr == CEC_LADDR_UNREGISTERED) {
- LOGE("All LA addresses in use!!!\n");
+ ALOGE("All LA addresses in use!!!\n");
return CEC_LADDR_UNREGISTERED;
}
if (CECSetLogicalAddr(laddr) < 0) {
- LOGE("CECSetLogicalAddr() failed!\n");
+ ALOGE("CECSetLogicalAddr() failed!\n");
return 0;
}
@@ -159,7 +159,7 @@
buffer[4] = devtype;
if (CECSendMessage(buffer, 5) != 5) {
- LOGE("CECSendMessage() failed!\n");
+ ALOGE("CECSendMessage() failed!\n");
return 0;
}
@@ -177,17 +177,17 @@
int CECSendMessage(unsigned char *buffer, int size)
{
if (fd == -1) {
- LOGE("open device first!\n");
+ ALOGE("open device first!\n");
return 0;
}
if (size > CEC_MAX_FRAME_SIZE) {
- LOGE("size should not exceed %d\n", CEC_MAX_FRAME_SIZE);
+ ALOGE("size should not exceed %d\n", CEC_MAX_FRAME_SIZE);
return 0;
}
#if CEC_DEBUG
- LOGI("CECSendMessage() : ");
+ ALOGI("CECSendMessage() : ");
CECPrintFrame(buffer, size);
#endif
@@ -211,7 +211,7 @@
int retval;
if (fd == -1) {
- LOGE("open device first!\n");
+ ALOGE("open device first!\n");
return 0;
}
@@ -228,7 +228,7 @@
} else if (retval) {
bytes = read(fd, buffer, size);
#if CEC_DEBUG
- LOGI("CECReceiveMessage() : size(%d)", bytes);
+ ALOGI("CECReceiveMessage() : size(%d)", bytes);
if(bytes > 0)
CECPrintFrame(buffer, bytes);
#endif
@@ -245,7 +245,7 @@
int CECSetLogicalAddr(unsigned int laddr)
{
if (ioctl(fd, CEC_IOC_SETLADDR, &laddr)) {
- LOGE("ioctl(CEC_IOC_SETLA) failed!\n");
+ ALOGE("ioctl(CEC_IOC_SETLA) failed!\n");
return 0;
}
@@ -260,12 +260,12 @@
{
if (size > 0) {
int i;
- LOGI("fsize: %d ", size);
- LOGI("frame: ");
+ ALOGI("fsize: %d ", size);
+ ALOGI("frame: ");
for (i = 0; i < size; i++)
- LOGI("0x%02x ", buffer[i]);
+ ALOGI("0x%02x ", buffer[i]);
- LOGI("\n");
+ ALOGI("\n");
}
}
#endif
diff --git a/exynos5/hal/libhdmi/libsForhdmi/libddc/libddc.c b/exynos5/hal/libhdmi/libsForhdmi/libddc/libddc.c
index 4e6e374..c9e64a5 100644
--- a/exynos5/hal/libhdmi/libsForhdmi/libddc/libddc.c
+++ b/exynos5/hal/libhdmi/libsForhdmi/libddc/libddc.c
@@ -87,7 +87,7 @@
// open
if ((ddc_fd = open(DEV_NAME,O_RDWR)) < 0) {
- LOGE("%s: Cannot open I2C_DDC : %s",__func__, DEV_NAME);
+ ALOGE("%s: Cannot open I2C_DDC : %s",__func__, DEV_NAME);
ret = 0;
}
@@ -106,7 +106,7 @@
// check if fd is available
if (ref_cnt == 0) {
#if DDC_DEBUG
- LOGE("%s: I2C_DDC is not available!!!!", __func__);
+ ALOGE("%s: I2C_DDC is not available!!!!", __func__);
#endif
return 1;
}
@@ -119,7 +119,7 @@
if (close(ddc_fd) < 0) {
#if DDC_DEBUG
- LOGE("%s: Cannot close I2C_DDC : %s",__func__,DEV_NAME);
+ ALOGE("%s: Cannot close I2C_DDC : %s",__func__,DEV_NAME);
#endif
ret = 0;
}
@@ -147,7 +147,7 @@
if (!DDCFileAvailable()) {
#if DDC_DEBUG
- LOGE("%s: I2C_DDC is not available!!!!", __func__);
+ ALOGE("%s: I2C_DDC is not available!!!!", __func__);
#endif
return 0;
}
@@ -197,7 +197,7 @@
if (!DDCFileAvailable()) {
#if DDC_DEBUG
- LOGE("%s: I2C_DDC is not available!!!!", __func__);
+ ALOGE("%s: I2C_DDC is not available!!!!", __func__);
#endif
return 0;
}
@@ -231,7 +231,7 @@
// eddc read
if (ioctl(ddc_fd, I2C_RDWR, &msgset) < 0) {
#if DDC_DEBUG
- LOGE("%s: ioctl(I2C_RDWR) failed!!!", __func__);
+ ALOGE("%s: ioctl(I2C_RDWR) failed!!!", __func__);
#endif
ret = 0;
}
@@ -255,7 +255,7 @@
// allocate temporary buffer
temp = (unsigned char*) malloc((size+1)*sizeof(unsigned char));
if (!temp) {
- LOGE("%s: not enough resources at %s", __FUNCTION__);
+ ALOGE("%s: not enough resources at %s", __FUNCTION__);
goto exit;
}
@@ -263,18 +263,18 @@
memcpy(temp+1,buffer,size);
if (!DDCFileAvailable()) {
- LOGE("%s: I2C_DDC is not available!!!!", __func__);
+ ALOGE("%s: I2C_DDC is not available!!!!", __func__);
goto exit;
}
if (ioctl(ddc_fd, I2C_SLAVE, addr>>1) < 0) {
- LOGE("%s: cannot set slave address 0x%02x", __func__,addr);
+ ALOGE("%s: cannot set slave address 0x%02x", __func__,addr);
goto exit;
}
// write temp buffer
if ((bytes = write(ddc_fd,temp,size+1)) != (size+1)) {
- LOGE("%s: fail to write %d bytes, only write %d bytes",__func__, size, bytes);
+ ALOGE("%s: fail to write %d bytes, only write %d bytes",__func__, size, bytes);
goto exit;
}
diff --git a/exynos5/hal/libhdmi/libsForhdmi/libedid/libedid.c b/exynos5/hal/libhdmi/libsForhdmi/libedid/libedid.c
index c6bed50..60c61ce 100644
--- a/exynos5/hal/libhdmi/libsForhdmi/libedid/libedid.c
+++ b/exynos5/hal/libhdmi/libsForhdmi/libedid/libedid.c
@@ -27,7 +27,7 @@
//#define EDID_DEBUG 1
#ifdef EDID_DEBUG
-#define DPRINTF(args...) LOGI(args)
+#define DPRINTF(args...) ALOGI(args)
#else
#define DPRINTF(args...)
#endif
@@ -219,11 +219,11 @@
#ifdef EDID_DEBUG
offset = 0;
do {
- LOGI("0x%02X", outBuffer[offset++]);
+ ALOGI("0x%02X", outBuffer[offset++]);
if (offset % 16)
- LOGI(" ");
+ ALOGI(" ");
else
- LOGI("\n");
+ ALOGI("\n");
} while (SIZEOFEDIDBLOCK > offset);
#endif // EDID_DEBUG
return 1;
diff --git a/exynos5/hal/libhwcomposer/SecHWC.cpp b/exynos5/hal/libhwcomposer/SecHWC.cpp
index 31ea1b5..aa07972 100644
--- a/exynos5/hal/libhwcomposer/SecHWC.cpp
+++ b/exynos5/hal/libhwcomposer/SecHWC.cpp
@@ -73,7 +73,7 @@
/*****************************************************************************/
static void dump_layer(hwc_layer_t const* l) {
- LOGD("\ttype=%d, flags=%08x, handle=%p, tr=%02x, blend=%04x, "
+ ALOGD("\ttype=%d, flags=%08x, handle=%p, tr=%02x, blend=%04x, "
"{%d,%d,%d,%d}, {%d,%d,%d,%d}",
l->compositionType, l->flags, l->handle, l->transform, l->blending,
l->sourceCrop.left,
@@ -243,7 +243,7 @@
}
}
- SEC_HWC_Log(HWC_LOG_DEBUG,
+ SEC_HWC_Log(HWC_ALOG_DEBUG,
"crop information()::"
"sourceCrop left(%d),top(%d),right(%d),bottom(%d),"
"src_rect x(%d),y(%d),w(%d),h(%d),"
@@ -271,7 +271,7 @@
dst_rect->h = win->rect_info.h;
/* Summery */
- SEC_HWC_Log(HWC_LOG_DEBUG,
+ SEC_HWC_Log(HWC_ALOG_DEBUG,
"set_src_dst_img_rect()::"
"SRC w(%d),h(%d),f_w(%d),f_h(%d),fmt(0x%x),"
"base(0x%x),offset(%d),paddr(0x%X)=>\r\n"
@@ -294,7 +294,7 @@
static int get_hwc_compos_decision(hwc_layer_t* cur, int iter, int win_cnt)
{
if(cur->flags & HWC_SKIP_LAYER || !cur->handle) {
- SEC_HWC_Log(HWC_LOG_DEBUG, "%s::is_skip_layer %d cur->handle %x ",
+ SEC_HWC_Log(HWC_ALOG_DEBUG, "%s::is_skip_layer %d cur->handle %x ",
__func__, cur->flags & HWC_SKIP_LAYER, cur->handle);
return HWC_FRAMEBUFFER;
@@ -358,7 +358,7 @@
break;
}
- SEC_HWC_Log(HWC_LOG_DEBUG, "2nd iter###%s:: compositionType %d bpp %d"
+ SEC_HWC_Log(HWC_ALOG_DEBUG, "2nd iter###%s:: compositionType %d bpp %d"
" format %x src[%d %d %d %d] dst[%d %d %d %d] srcImg[%d %d]",
__func__, compositionType, prev_handle->bpp,
prev_handle->format,
@@ -370,7 +370,7 @@
}
#endif
- SEC_HWC_Log(HWC_LOG_DEBUG,
+ SEC_HWC_Log(HWC_ALOG_DEBUG,
"%s::compositionType(%d)=>0:FB,1:OVERLAY \r\n"
" format(0x%x),magic(0x%x),flags(%d),size(%d),offset(%d)"
"b_addr(0x%x),usage(%d),w(%d),h(%d),bpp(%d)",
@@ -405,7 +405,7 @@
win = &ctx->win[win_idx];
- SEC_HWC_Log(HWC_LOG_DEBUG,
+ SEC_HWC_Log(HWC_ALOG_DEBUG,
"%s:: left(%d),top(%d),right(%d),bottom(%d),transform(%d)"
"lcd_info.xres(%d),lcd_info.yres(%d)",
"++assign_overlay_window()",
@@ -423,7 +423,7 @@
win->rect_info.h = rect.h;
//turnoff the window and set the window position with new conf...
if (window_set_pos(win) < 0) {
- SEC_HWC_Log(HWC_LOG_ERROR, "%s::window_set_pos is failed : %s",
+ SEC_HWC_Log(HWC_ALOG_ERROR, "%s::window_set_pos is failed : %s",
__func__, strerror(errno));
ret = -1;
}
@@ -433,7 +433,7 @@
win->layer_index = layer_idx;
win->status = HWC_WIN_RESERVED;
- SEC_HWC_Log(HWC_LOG_DEBUG,
+ SEC_HWC_Log(HWC_ALOG_DEBUG,
"%s:: win_x %d win_y %d win_w %d win_h %d lay_idx %d win_idx %d\n",
"--assign_overlay_window()",
win->rect_info.x, win->rect_info.y, win->rect_info.w,
@@ -475,7 +475,7 @@
} else {
ret = assign_overlay_window(ctx, cur, overlay_win_cnt, i);
if (ret != 0) {
- LOGE("assign_overlay_window fail, change to frambuffer");
+ ALOGE("assign_overlay_window fail, change to frambuffer");
cur->compositionType = HWC_FRAMEBUFFER;
ctx->num_of_fb_layer++;
continue;
@@ -519,7 +519,7 @@
#endif
if (list->numHwLayers != (ctx->num_of_fb_layer + ctx->num_of_hwc_layer))
- SEC_HWC_Log(HWC_LOG_DEBUG,
+ SEC_HWC_Log(HWC_ALOG_DEBUG,
"%s:: numHwLayers %d num_of_fb_layer %d num_of_hwc_layer %d ",
__func__, list->numHwLayers, ctx->num_of_fb_layer,
ctx->num_of_hwc_layer);
@@ -580,7 +580,7 @@
* double buffered (2 or more) this buffer is already rendered.
* It is the redundant src buffer for FIMC rendering.
*/
- LOGD("SKIP FIMC rendering for Layer%d", win->layer_index);
+ ALOGD("SKIP FIMC rendering for Layer%d", win->layer_index);
#if defined(BOARD_USES_HDMI)
skip_hdmi_rendering = 1;
#endif
@@ -597,7 +597,7 @@
cur->transform);
if (ret < 0) {
- SEC_HWC_Log(HWC_LOG_ERROR, "%s::runFimc fail : ret=%d\n",
+ SEC_HWC_Log(HWC_ALOG_ERROR, "%s::runFimc fail : ret=%d\n",
__func__, ret);
skipped_window_mask |= (1 << i);
continue;
@@ -609,14 +609,14 @@
if (win->power_state == 0)
window_show(win);
} else {
- SEC_HWC_Log(HWC_LOG_ERROR,
+ SEC_HWC_Log(HWC_ALOG_ERROR,
"%s:: error : layer %d compositionType should have been"
" HWC_OVERLAY ", __func__, win->layer_index);
skipped_window_mask |= (1 << i);
continue;
}
} else {
- SEC_HWC_Log(HWC_LOG_ERROR, "%s:: error : window status should have "
+ SEC_HWC_Log(HWC_ALOG_ERROR, "%s:: error : window status should have "
"been HWC_WIN_RESERVED by now... ", __func__);
skipped_window_mask |= (1 << i);
continue;
@@ -634,7 +634,7 @@
ret = runG2d(ctx, &srcRect, &dstRect,
cur->transform);
if (ret < 0) {
- SEC_HWC_Log(HWC_LOG_ERROR, "%s::runG2d fail : ret=%d\n",
+ SEC_HWC_Log(HWC_ALOG_ERROR, "%s::runG2d fail : ret=%d\n",
__func__, ret);
skipped_window_mask |= (1 << (ctx->num_of_hwc_layer - 1));
goto g2d_error;
@@ -738,7 +738,7 @@
android::SecHdmiClient::HDMI_MODE_VIDEO,
ctx->num_of_hwc_layer);
} else {
- LOGE("%s: Unsupported format = %d", __func__, src_img.format);
+ ALOGE("%s: Unsupported format = %d", __func__, src_img.format);
}
}
#endif
@@ -752,18 +752,18 @@
int i;
if (ctx) {
if (destroyVideoDev(&ctx->fimc) < 0) {
- SEC_HWC_Log(HWC_LOG_ERROR, "%s::destroyVideoDev fail", __func__);
+ SEC_HWC_Log(HWC_ALOG_ERROR, "%s::destroyVideoDev fail", __func__);
ret = -1;
}
#ifdef SUB_TITLES_HWC
if (destroyG2d(&ctx->g2d) < 0) {
- SEC_HWC_Log(HWC_LOG_ERROR, "%s::destroyG2d() fail", __func__);
+ SEC_HWC_Log(HWC_ALOG_ERROR, "%s::destroyG2d() fail", __func__);
ret = -1;
}
#endif
for (i = 0; i < NUM_OF_WIN; i++) {
if (window_close(&ctx->win[i]) < 0)
- SEC_HWC_Log(HWC_LOG_DEBUG, "%s::window_close() fail", __func__);
+ SEC_HWC_Log(HWC_ALOG_DEBUG, "%s::window_close() fail", __func__);
}
free(ctx);
@@ -806,7 +806,7 @@
/* open WIN0 & WIN1 here */
for (int i = 0; i < NUM_OF_WIN; i++) {
if (window_open(&(dev->win[i]), i) < 0) {
- SEC_HWC_Log(HWC_LOG_ERROR,
+ SEC_HWC_Log(HWC_ALOG_ERROR,
"%s:: Failed to open window %d device ", __func__, i);
status = -EINVAL;
goto err;
@@ -814,7 +814,7 @@
}
if (window_get_global_lcd_info(dev->win[0].fd, &dev->lcd_info) < 0) {
- SEC_HWC_Log(HWC_LOG_ERROR,
+ SEC_HWC_Log(HWC_ALOG_ERROR,
"%s::window_get_global_lcd_info is failed : %s",
__func__, strerror(errno));
status = -EINVAL;
@@ -838,14 +838,14 @@
win->rect_info.h = win->var_info.yres;
if (window_set_pos(win) < 0) {
- SEC_HWC_Log(HWC_LOG_ERROR, "%s::window_set_pos is failed : %s",
+ SEC_HWC_Log(HWC_ALOG_ERROR, "%s::window_set_pos is failed : %s",
__func__, strerror(errno));
status = -EINVAL;
goto err;
}
if (window_get_info(win, i) < 0) {
- SEC_HWC_Log(HWC_LOG_ERROR, "%s::window_get_info is failed : %s",
+ SEC_HWC_Log(HWC_ALOG_ERROR, "%s::window_get_info is failed : %s",
__func__, strerror(errno));
status = -EINVAL;
goto err;
@@ -855,46 +855,46 @@
#ifdef USE_HW_PMEM
if (createPmem(&dev->sec_pmem, PMEM_SIZE) < 0) {
- SEC_HWC_Log(HWC_LOG_ERROR, "%s::initPmem(%d) fail", __func__, PMEM_SIZE);
+ SEC_HWC_Log(HWC_ALOG_ERROR, "%s::initPmem(%d) fail", __func__, PMEM_SIZE);
}
#endif
//create PP
if (createVideoDev(&dev->fimc) < 0) {
- SEC_HWC_Log(HWC_LOG_ERROR, "%s::creatFimc() fail", __func__);
+ SEC_HWC_Log(HWC_ALOG_ERROR, "%s::creatFimc() fail", __func__);
status = -EINVAL;
goto err;
}
#ifdef SUB_TITLES_HWC
if (createG2d(&dev->g2d) < 0) {
- SEC_HWC_Log(HWC_LOG_ERROR, "%s::createG2d() fail", __func__);
+ SEC_HWC_Log(HWC_ALOG_ERROR, "%s::createG2d() fail", __func__);
status = -EINVAL;
goto err;
}
#endif
- SEC_HWC_Log(HWC_LOG_DEBUG, "%s:: hwc_device_open: SUCCESS", __func__);
+ SEC_HWC_Log(HWC_ALOG_DEBUG, "%s:: hwc_device_open: SUCCESS", __func__);
return 0;
err:
if (destroyVideoDev(&dev->fimc) < 0)
- SEC_HWC_Log(HWC_LOG_ERROR, "%s::destroyVideoDev() fail", __func__);
+ SEC_HWC_Log(HWC_ALOG_ERROR, "%s::destroyVideoDev() fail", __func__);
#ifdef SUB_TITLES_HWC
if (destroyG2d(&dev->g2d) < 0)
- SEC_HWC_Log(HWC_LOG_ERROR, "%s::destroyG2d() fail", __func__);
+ SEC_HWC_Log(HWC_ALOG_ERROR, "%s::destroyG2d() fail", __func__);
#endif
if (destroyMem(&dev->s3c_mem) < 0)
- SEC_HWC_Log(HWC_LOG_ERROR, "%s::destroyMem() fail", __func__);
+ SEC_HWC_Log(HWC_ALOG_ERROR, "%s::destroyMem() fail", __func__);
#ifdef USE_HW_PMEM
if (destroyPmem(&dev->sec_pmem) < 0)
- SEC_HWC_Log(HWC_LOG_ERROR, "%s::destroyPmem() fail", __func__);
+ SEC_HWC_Log(HWC_ALOG_ERROR, "%s::destroyPmem() fail", __func__);
#endif
for (int i = 0; i < NUM_OF_WIN; i++) {
if (window_close(&dev->win[i]) < 0)
- SEC_HWC_Log(HWC_LOG_DEBUG, "%s::window_close() fail", __func__);
+ SEC_HWC_Log(HWC_ALOG_DEBUG, "%s::window_close() fail", __func__);
}
return status;
diff --git a/exynos5/hal/libhwcomposer/SecHWCUtils.cpp b/exynos5/hal/libhwcomposer/SecHWCUtils.cpp
index 9a03ed2..f165a2d 100644
--- a/exynos5/hal/libhwcomposer/SecHWCUtils.cpp
+++ b/exynos5/hal/libhwcomposer/SecHWCUtils.cpp
@@ -52,7 +52,7 @@
memcpy(&tick_old, &tick, sizeof(timeval));
if (cnt == (10 + CHK_FRAME_CNT)) {
FPS = 1000*CHK_FRAME_CNT/total;
- LOGE("[FPS]:%d\n", FPS);
+ ALOGE("[FPS]:%d\n", FPS);
total = 0;
cnt = 10;
}
diff --git a/exynos5/hal/libhwjpeg/SecJpegDecoderHal.cpp b/exynos5/hal/libhwjpeg/SecJpegDecoderHal.cpp
index 563b15a..12b9dfc 100644
--- a/exynos5/hal/libhwjpeg/SecJpegDecoderHal.cpp
+++ b/exynos5/hal/libhwjpeg/SecJpegDecoderHal.cpp
@@ -36,7 +36,7 @@
#include "SecJpegCodecHal.h"
-#define JPEG_ERROR_LOG(fmt,...)
+#define JPEG_ERROR_ALOG(fmt,...)
#define NUM_PLANES (1)
#define NUM_BUFFERS (1)
@@ -66,19 +66,19 @@
if (t_iJpegFd < 0) {
t_iJpegFd = -1;
- JPEG_ERROR_LOG("[%s]: JPEG_DEC_NODE open failed", __func__);
+ JPEG_ERROR_ALOG("[%s]: JPEG_DEC_NODE open failed", __func__);
return ERROR_CANNOT_OPEN_JPEG_DEVICE;
}
if (t_iJpegFd <= 0) {
t_iJpegFd = -1;
- JPEG_ERROR_LOG("ERR(%s):JPEG device was closed\n", __func__);
+ JPEG_ERROR_ALOG("ERR(%s):JPEG device was closed\n", __func__);
return ERROR_JPEG_DEVICE_ALREADY_CLOSED;
}
iRet = t_v4l2Querycap(t_iJpegFd);
if (iRet < 0) {
- JPEG_ERROR_LOG("[%s]: QUERYCAP failed", __func__);
+ JPEG_ERROR_ALOG("[%s]: QUERYCAP failed", __func__);
close(t_iJpegFd);
return ERROR_CANNOT_OPEN_JPEG_DEVICE;
}
@@ -127,7 +127,7 @@
iRet = close(t_iJpegFd);
if (iRet < 0) {
- JPEG_ERROR_LOG("[%s:%d]: JPEG_DEC_NODE close failed", __func__, iRet);
+ JPEG_ERROR_ALOG("[%s:%d]: JPEG_DEC_NODE close failed", __func__, iRet);
}
}
@@ -278,7 +278,7 @@
}
if (t_v4l2SetCtrl(t_iJpegFd, V4L2_CID_CACHEABLE, iValue)<0) {
- JPEG_ERROR_LOG("%s::cache setting failed\n", __func__);
+ JPEG_ERROR_ALOG("%s::cache setting failed\n", __func__);
return ERROR_CANNOT_CHANGE_CACHE_SETTING;
}
@@ -293,7 +293,7 @@
int iRet = t_v4l2GetFmt(t_iJpegFd, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE, &t_stJpegConfig);
if (iRet < 0) {
- JPEG_ERROR_LOG("[%s,%d]: get image size failed", __func__,iRet);
+ JPEG_ERROR_ALOG("[%s,%d]: get image size failed", __func__,iRet);
return ERROR_GET_SIZE_FAIL;
}
@@ -366,7 +366,7 @@
iRet = t_v4l2SetFmt(t_iJpegFd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, &t_stJpegConfig);
if (iRet < 0) {
- JPEG_ERROR_LOG("[%s,%d]: jpeg input S_FMT failed", __func__,iRet);
+ JPEG_ERROR_ALOG("[%s,%d]: jpeg input S_FMT failed", __func__,iRet);
return ERROR_INVALID_JPEG_CONFIG;
}
@@ -378,14 +378,14 @@
iRet = t_v4l2Reqbufs(t_iJpegFd, NUM_BUFFERS, &stBufInfo);
if (iRet < 0) {
- JPEG_ERROR_LOG("[%s:%d]: Input REQBUFS failed", __func__, iRet);
+ JPEG_ERROR_ALOG("[%s:%d]: Input REQBUFS failed", __func__, iRet);
return ERROR_EXCUTE_FAIL;
}
t_stJpegConfig.numOfPlanes = t_iPlaneNum;
iRet = t_v4l2SetFmt(t_iJpegFd, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE, &t_stJpegConfig);
if (iRet < 0) {
- JPEG_ERROR_LOG("[%s,%d]: jpeg output S_FMT failed", __func__,iRet);
+ JPEG_ERROR_ALOG("[%s,%d]: jpeg output S_FMT failed", __func__,iRet);
return ERROR_INVALID_JPEG_CONFIG;
}
@@ -394,7 +394,7 @@
iRet = t_v4l2Reqbufs(t_iJpegFd, NUM_BUFFERS, &stBufInfo);
if (iRet < 0) {
- JPEG_ERROR_LOG("[%s:%d]: Output REQBUFS failed", __func__, iRet);
+ JPEG_ERROR_ALOG("[%s:%d]: Output REQBUFS failed", __func__, iRet);
return ERROR_REQBUF_FAIL;
}
@@ -454,7 +454,7 @@
iRet = t_v4l2Qbuf(t_iJpegFd, &stBufInfo, &t_stJpegInbuf);
if (iRet < 0) {
- JPEG_ERROR_LOG("[%s:%d]: Input QBUF failed", __func__, iRet);
+ JPEG_ERROR_ALOG("[%s:%d]: Input QBUF failed", __func__, iRet);
return ERROR_EXCUTE_FAIL;
}
@@ -463,33 +463,33 @@
iRet = t_v4l2Qbuf(t_iJpegFd, &stBufInfo, &t_stJpegOutbuf);
if (iRet < 0) {
- JPEG_ERROR_LOG("[%s:%d]: Output QBUF failed", __func__, iRet);
+ JPEG_ERROR_ALOG("[%s:%d]: Output QBUF failed", __func__, iRet);
return ERROR_EXCUTE_FAIL;
}
stBufInfo.numOfPlanes = NUM_PLANES;
iRet = t_v4l2StreamOn(t_iJpegFd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);
if (iRet < 0) {
- JPEG_ERROR_LOG("[%s:%d]: input stream on failed", __func__, iRet);
+ JPEG_ERROR_ALOG("[%s:%d]: input stream on failed", __func__, iRet);
return ERROR_EXCUTE_FAIL;
}
stBufInfo.numOfPlanes = t_iPlaneNum;
iRet = t_v4l2StreamOn(t_iJpegFd, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
if (iRet < 0) {
- JPEG_ERROR_LOG("[%s:%d]: output stream on failed", __func__, iRet);
+ JPEG_ERROR_ALOG("[%s:%d]: output stream on failed", __func__, iRet);
return ERROR_EXCUTE_FAIL;
}
stBufInfo.numOfPlanes = NUM_PLANES;
iRet = t_v4l2Dqbuf(t_iJpegFd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_MEMORY_MMAP);
if (iRet < 0) {
- JPEG_ERROR_LOG("[%s:%d]: Intput DQBUF failed", __func__, iRet);
+ JPEG_ERROR_ALOG("[%s:%d]: Intput DQBUF failed", __func__, iRet);
return ERROR_EXCUTE_FAIL;
}
stBufInfo.numOfPlanes = t_iPlaneNum;
iRet = t_v4l2Dqbuf(t_iJpegFd, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE, V4L2_MEMORY_MMAP);
if (iRet < 0) {
- JPEG_ERROR_LOG("[%s:%d]: Output DQBUF failed", __func__, iRet);
+ JPEG_ERROR_ALOG("[%s:%d]: Output DQBUF failed", __func__, iRet);
return ERROR_EXCUTE_FAIL;
}
diff --git a/exynos5/hal/libhwjpeg/SecJpegEncoder.cpp b/exynos5/hal/libhwjpeg/SecJpegEncoder.cpp
index 6c118e1..0ceac31 100644
--- a/exynos5/hal/libhwjpeg/SecJpegEncoder.cpp
+++ b/exynos5/hal/libhwjpeg/SecJpegEncoder.cpp
@@ -21,7 +21,7 @@
static const char ExifAsciiPrefix[] = { 0x41, 0x53, 0x43, 0x49, 0x49, 0x0, 0x0, 0x0 };
-#define JPEG_ERROR_LOG(fmt,...)
+#define JPEG_ERROR_ALOG(fmt,...)
#define JPEG_MAIN_DUMP (0)
#define JPEG_THUMB_DUMP (0)
@@ -71,7 +71,7 @@
m_jpegMain = new SecJpegEncoderHal;
if (m_jpegMain == NULL) {
- JPEG_ERROR_LOG("ERR(%s):Cannot create SecJpegEncoderHal class\n", __func__);
+ JPEG_ERROR_ALOG("ERR(%s):Cannot create SecJpegEncoderHal class\n", __func__);
return ERROR_CANNOT_CREATE_SEC_JPEG_ENC_HAL;
}
@@ -189,7 +189,7 @@
char *inBuf = *(m_jpegMain->getInBuf(&inSize));
if (inBuf == NULL) {
- JPEG_ERROR_LOG("%s::Fail to JPEG input buffer!!\n", __func__);
+ JPEG_ERROR_ALOG("%s::Fail to JPEG input buffer!!\n", __func__);
return NULL;
}
@@ -208,7 +208,7 @@
char *outBuf = m_jpegMain->getOutBuf(&outSize);
if (outBuf == NULL) {
- JPEG_ERROR_LOG("%s::Fail to JPEG input buffer!!\n", __func__);
+ JPEG_ERROR_ALOG("%s::Fail to JPEG input buffer!!\n", __func__);
return NULL;
}
@@ -241,7 +241,7 @@
if (m_ionJpegClient == 0) {
m_ionJpegClient = ion_client_create();
if (m_ionJpegClient < 0) {
- JPEG_ERROR_LOG("[%s]src ion client create failed, value = %d\n", __func__, size);
+ JPEG_ERROR_ALOG("[%s]src ion client create failed, value = %d\n", __func__, size);
m_ionJpegClient = 0;
return ret;
}
@@ -254,7 +254,7 @@
ret = m_jpegMain->setInBuf(&m_pJpegInputBuffer, &size);
if (ret) {
- JPEG_ERROR_LOG("%s::Fail to JPEG input buffer!!\n", __func__);
+ JPEG_ERROR_ALOG("%s::Fail to JPEG input buffer!!\n", __func__);
return ret;
}
m_iInBufSize = size;
@@ -264,7 +264,7 @@
#else // NO JPEG_WA_FOR_PAGEFAULT
ret = m_jpegMain->setInBuf(&buf, &size);
if (ret) {
- JPEG_ERROR_LOG("%s::Fail to JPEG input buffer!!\n", __func__);
+ JPEG_ERROR_ALOG("%s::Fail to JPEG input buffer!!\n", __func__);
return ret;
}
#endif // JPEG_WA_FOR_PAGEFAULT
@@ -289,7 +289,7 @@
int ret = ERROR_NONE;
ret = m_jpegMain->setOutBuf(buf, size);
if (ret) {
- JPEG_ERROR_LOG("%s::Fail to JPEG output buffer!!\n", __func__);
+ JPEG_ERROR_ALOG("%s::Fail to JPEG output buffer!!\n", __func__);
return ret;
}
@@ -311,14 +311,14 @@
ret = m_jpegMain->encode();
if (ret) {
- JPEG_ERROR_LOG("encode failed\n");
+ JPEG_ERROR_ALOG("encode failed\n");
return ret;
}
int iJpegSize = m_jpegMain->getJpegSize();
if (iJpegSize<=0) {
- JPEG_ERROR_LOG("%s:: output_size is too small(%d)!!\n", __func__, iJpegSize);
+ JPEG_ERROR_ALOG("%s:: output_size is too small(%d)!!\n", __func__, iJpegSize);
return ERROR_OUT_BUFFER_SIZE_TOO_SMALL;
}
@@ -326,7 +326,7 @@
char *pcJpegBuffer = m_jpegMain->getOutBuf(&iOutputSize);
if (pcJpegBuffer == NULL) {
- JPEG_ERROR_LOG("%s::buffer is null!!\n", __func__);
+ JPEG_ERROR_ALOG("%s::buffer is null!!\n", __func__);
return ERROR_OUT_BUFFER_CREATE_FAIL;
}
@@ -354,14 +354,14 @@
exifOut = new unsigned char[bufSize];
if (exifOut == NULL) {
- JPEG_ERROR_LOG("%s::Failed to allocate for exifOut", __func__);
+ JPEG_ERROR_ALOG("%s::Failed to allocate for exifOut", __func__);
delete[] exifOut;
return ERROR_EXIFOUT_ALLOC_FAIL;
}
memset(exifOut, 0, bufSize);
if (makeExif (exifOut, exifInfo, &exifLen)) {
- JPEG_ERROR_LOG("%s::Failed to make EXIF", __func__);
+ JPEG_ERROR_ALOG("%s::Failed to make EXIF", __func__);
delete[] exifOut;
return ERROR_MAKE_EXIF_FAIL;
}
@@ -773,44 +773,44 @@
m_jpegThumb = new SecJpegEncoderHal;
if (m_jpegThumb == NULL) {
- JPEG_ERROR_LOG("ERR(%s):Cannot open a jpeg device file\n", __func__);
+ JPEG_ERROR_ALOG("ERR(%s):Cannot open a jpeg device file\n", __func__);
return ERROR_CANNOT_CREATE_SEC_THUMB;
}
}
ret = m_jpegThumb->create();
if (ret) {
- JPEG_ERROR_LOG("ERR(%s):Fail create\n", __func__);
+ JPEG_ERROR_ALOG("ERR(%s):Fail create\n", __func__);
return ret;
}
ret = m_jpegThumb->setCache(JPEG_CACHE_ON);
if (ret) {
- JPEG_ERROR_LOG("ERR(%s):Fail cache set\n", __func__);
+ JPEG_ERROR_ALOG("ERR(%s):Fail cache set\n", __func__);
return ret;
}
void *pConfig = m_jpegMain->getJpegConfig();
if (pConfig == NULL) {
- JPEG_ERROR_LOG("ERR(%s):Fail getJpegConfig\n", __func__);
+ JPEG_ERROR_ALOG("ERR(%s):Fail getJpegConfig\n", __func__);
return ERROR_BUFFR_IS_NULL;
}
ret = m_jpegThumb->setJpegConfig(pConfig);
if (ret) {
- JPEG_ERROR_LOG("ERR(%s):Fail setJpegConfig\n", __func__);
+ JPEG_ERROR_ALOG("ERR(%s):Fail setJpegConfig\n", __func__);
return ret;
}
ret = m_jpegThumb->setQuality(JPEG_THUMBNAIL_QUALITY);
if (ret) {
- JPEG_ERROR_LOG("ERR(%s):Fail setQuality\n", __func__);
+ JPEG_ERROR_ALOG("ERR(%s):Fail setQuality\n", __func__);
return ret;
}
ret = m_jpegThumb->setSize(m_thumbnailW, m_thumbnailH);
if (ret) {
- JPEG_ERROR_LOG("ERR(%s):Fail setSize\n", __func__);
+ JPEG_ERROR_ALOG("ERR(%s):Fail setSize\n", __func__);
return ret;
}
@@ -825,7 +825,7 @@
if (m_ionJpegClient == 0) {
m_ionJpegClient = ion_client_create();
if (m_ionJpegClient < 0) {
- JPEG_ERROR_LOG("[%s]src ion client create failed, value = %d\n", __func__, m_ionJpegClient);
+ JPEG_ERROR_ALOG("[%s]src ion client create failed, value = %d\n", __func__, m_ionJpegClient);
m_ionJpegClient = 0;
return ret;
}
@@ -838,7 +838,7 @@
ret = m_jpegThumb->setInBuf(&m_pThumbInputBuffer, &iThumbSize);
if (ret) {
- JPEG_ERROR_LOG("ERR(%s):Fail setInBuf\n", __func__);
+ JPEG_ERROR_ALOG("ERR(%s):Fail setInBuf\n", __func__);
return ret;
}
@@ -849,13 +849,13 @@
ret = m_jpegThumb->setOutBuf((char *)m_pThumbOutputBuffer, iThumbSize);
if (ret) {
- JPEG_ERROR_LOG("ERR(%s):Fail setOutBuf\n", __func__);
+ JPEG_ERROR_ALOG("ERR(%s):Fail setOutBuf\n", __func__);
return ret;
}
ret = m_jpegThumb->updateConfig();
if (ret) {
- JPEG_ERROR_LOG("update config failed\n");
+ JPEG_ERROR_ALOG("update config failed\n");
return ret;
}
@@ -866,7 +866,7 @@
ret = m_jpegMain->getSize(&iW, &iH);
if (ret) {
- JPEG_ERROR_LOG("ERR(%s):Fail setJpegConfig\n", __func__);
+ JPEG_ERROR_ALOG("ERR(%s):Fail setJpegConfig\n", __func__);
return ret;
}
@@ -877,7 +877,7 @@
m_thumbnailW,
m_thumbnailH);
if (ret) {
- JPEG_ERROR_LOG("%s::m_scaleDownYuv422(%d, %d, %d, %d) fail", __func__, iW, iH, m_thumbnailW, m_thumbnailH);
+ JPEG_ERROR_ALOG("%s::m_scaleDownYuv422(%d, %d, %d, %d) fail", __func__, iW, iH, m_thumbnailW, m_thumbnailH);
return ret;
}
}
@@ -889,13 +889,13 @@
ret = m_jpegThumb->encode();
if (ret) {
- JPEG_ERROR_LOG("encode failed\n");
+ JPEG_ERROR_ALOG("encode failed\n");
return ret;
}
outSizeThumb = m_jpegThumb->getJpegSize();
if (outSizeThumb<=0) {
- JPEG_ERROR_LOG("jpeg size is too small\n");
+ JPEG_ERROR_ALOG("jpeg size is too small\n");
return ERROR_THUMB_JPEG_SIZE_TOO_SMALL;
}
@@ -910,20 +910,20 @@
int ret = ERROR_NONE;
if (ionClient == 0) {
- JPEG_ERROR_LOG("[%s]ionClient is zero (%d)\n", __func__, ionClient);
+ JPEG_ERROR_ALOG("[%s]ionClient is zero (%d)\n", __func__, ionClient);
return ERROR_BUFFR_IS_NULL;
}
*ionBuffer = ion_alloc(ionClient, size, 0, ION_HEAP_SYSTEM_MASK);
if (*ionBuffer == -1) {
- JPEG_ERROR_LOG("[%s]ion_alloc(%d) failed\n", __func__, size);
+ JPEG_ERROR_ALOG("[%s]ion_alloc(%d) failed\n", __func__, size);
*ionBuffer = 0;
return ret;
}
*buffer = (char *)ion_map(*ionBuffer, size, 0);
if (*buffer == MAP_FAILED) {
- JPEG_ERROR_LOG("[%s]src ion map failed(%d)\n", __func__, size);
+ JPEG_ERROR_ALOG("[%s]src ion map failed(%d)\n", __func__, size);
ion_free(*ionBuffer);
*ionBuffer = 0;
*buffer = NULL;