void QCameraStream_Rdi::dumpFrameToFile(struct msm_frame* newFrame)
{
int32_t enabled = 0;
int frm_num;
uint32_t skip_mode;
char value[PROPERTY_VALUE_MAX];
char buf[32];
int w, h;
static int count = 0;
cam_ctrl_dimension_t dim;
int file_fd;
int rc = 0;
int len;
unsigned long addr;
unsigned long * tmp = (unsigned long *)newFrame->buffer;
addr = *tmp;
status_t ret = cam_config_get_parm(mHalCamCtrl->mCameraId,
MM_CAMERA_PARM_DIMENSION, &dim);
w = dim.rdi0_width;
h = dim.rdi0_height;
len = (w * h)*3/2;
count++;
if(count < 100) {
snprintf(buf, sizeof(buf), "/data/%d.yuv", count);
file_fd = open(buf, O_RDWR | O_CREAT, 0777);
rc = write(file_fd, (const void *)addr, len);
ALOGI("%s: file='%s', vaddr_old=0x%x, addr_map = 0x%p, len = %d, rc = %d",
__func__, buf, (uint32_t)newFrame->buffer, (void *)addr, len, rc);
close(file_fd);
ALOGI("%s: dump %s, rc = %d, len = %d", __func__, buf, rc, len);
}
}
status_t QCameraStream::setFormat(uint8_t ch_type_mask, cam_format_t previewFmt)
{
int rc = MM_CAMERA_OK;
status_t ret = NO_ERROR;
int width = 0; /* width of channel */
int height = 0; /* height of channel */
cam_ctrl_dimension_t dim;
mm_camera_ch_image_fmt_parm_t fmt;
ALOGV("%s: E",__func__);
memset(&dim, 0, sizeof(cam_ctrl_dimension_t));
rc = cam_config_get_parm(mCameraId, MM_CAMERA_PARM_DIMENSION, &dim);
if (MM_CAMERA_OK != rc) {
ALOGE("%s: error - can't get camera dimension!", __func__);
ALOGV("%s: X", __func__);
return BAD_VALUE;
}
char mDeviceName[PROPERTY_VALUE_MAX];
property_get("ro.product.device",mDeviceName," ");
memset(&fmt, 0, sizeof(mm_camera_ch_image_fmt_parm_t));
if(MM_CAMERA_CH_PREVIEW_MASK & ch_type_mask){
fmt.ch_type = MM_CAMERA_CH_PREVIEW;
fmt.def.fmt = (cam_format_t)previewFmt;
fmt.def.dim.width = dim.display_width;
fmt.def.dim.height = dim.display_height;
}else if(MM_CAMERA_CH_VIDEO_MASK & ch_type_mask){
fmt.ch_type = MM_CAMERA_CH_VIDEO;
fmt.video.video.fmt = CAMERA_YUV_420_NV21; //dim.enc_format;
fmt.video.video.dim.width = dim.video_width;
fmt.video.video.dim.height = dim.video_height;
}/*else if(MM_CAMERA_CH_SNAPSHOT_MASK & ch_type_mask){
if(mHalCamCtrl->isRawSnapshot()) {
fmt.ch_type = MM_CAMERA_CH_RAW;
fmt.def.fmt = CAMERA_BAYER_SBGGR10;
fmt.def.dim.width = dim.raw_picture_width;
fmt.def.dim.height = dim.raw_picture_height;
}else{
//Jpeg???
fmt.ch_type = MM_CAMERA_CH_SNAPSHOT;
fmt.snapshot.main.fmt = dim.main_img_format;
fmt.snapshot.main.dim.width = dim.picture_width;
fmt.snapshot.main.dim.height = dim.picture_height;
fmt.snapshot.thumbnail.fmt = dim.thumb_format;
fmt.snapshot.thumbnail.dim.width = dim.ui_thumbnail_width;
fmt.snapshot.thumbnail.dim.height = dim.ui_thumbnail_height;
}
}*/
rc = cam_config_set_parm(mCameraId, MM_CAMERA_PARM_CH_IMAGE_FMT, &fmt);
ALOGV("%s: Stream MM_CAMERA_PARM_CH_IMAGE_FMT rc = %d\n", __func__, rc);
if(MM_CAMERA_OK != rc) {
ALOGE("%s:set stream channel format err=%d\n", __func__, ret);
ALOGV("%s: X", __func__);
ret = BAD_VALUE;
}
ALOGV("%s: X",__func__);
return ret;
}
status_t QCameraStream_Rdi::getBufferRdi( )
{
int err = 0;
status_t ret = NO_ERROR;
int i, frame_len, y_off, cbcr_off;
uint8_t num_planes;
cam_ctrl_dimension_t dim;
uint32_t planes[VIDEO_MAX_PLANES];
ALOGI("%s : E ", __FUNCTION__);
ret = cam_config_get_parm(mCameraId, MM_CAMERA_PARM_DIMENSION, &dim);
if(ret != NO_ERROR) {
ALOGE("%s: display format %d is not supported", __func__, dim.prev_format);
goto end;
}
mHalCamCtrl->mRdiMemoryLock.lock();
mHalCamCtrl->mRdiMemory.buffer_count = kRdiBufferCount;
if(mHalCamCtrl->isZSLMode()) {
if(mHalCamCtrl->getZSLQueueDepth() > kRdiBufferCount - 3)
mHalCamCtrl->mRdiMemory.buffer_count =
mHalCamCtrl->getZSLQueueDepth() + 3;
}
frame_len = mm_camera_get_msm_frame_len(CAMERA_RDI,
myMode,
dim.rdi0_width,
dim.rdi0_height,
OUTPUT_TYPE_R,
&num_planes, planes);
y_off = 0;
cbcr_off = planes[0];
ALOGI("%s: main image: rotation = %d, yoff = %d, cbcroff = %d, size = %d, width = %d, height = %d",
__func__, dim.rotation, y_off, cbcr_off, frame_len,
dim.rdi0_width, dim.rdi0_height);
if (mHalCamCtrl->initHeapMem(&mHalCamCtrl->mRdiMemory,
mHalCamCtrl->mRdiMemory.buffer_count,
frame_len, y_off, cbcr_off, MSM_PMEM_MAINIMG,
NULL,NULL, num_planes, planes) < 0) {
ret = NO_MEMORY;
goto end;
};
ALOGI(" %s : X ",__FUNCTION__);
end:
mHalCamCtrl->mRdiMemoryLock.unlock();
return NO_ERROR;
}
status_t QCameraStream_Rdi::initRdiBuffers()
{
status_t ret = NO_ERROR;
int width = 0; /* width of channel */
int height = 0; /* height of channel */
uint32_t frame_len = 0; /* frame planner length */
int buffer_num = 4; /* number of buffers for display */
const char *pmem_region;
uint8_t num_planes = 0;
uint32_t planes[VIDEO_MAX_PLANES];
cam_ctrl_dimension_t dim;
ALOGD("%s:BEGIN",__func__);
mHalCamCtrl->mRdiMemoryLock.lock();
memset(&mHalCamCtrl->mRdiMemory, 0, sizeof(mHalCamCtrl->mRdiMemory));
mHalCamCtrl->mRdiMemoryLock.unlock();
/* get rdi size, by qury mm_camera*/
memset(&dim, 0, sizeof(cam_ctrl_dimension_t));
ret = cam_config_get_parm(mCameraId, MM_CAMERA_PARM_DIMENSION, &dim);
if (MM_CAMERA_OK != ret) {
ALOGE("%s: error - can't get camera dimension!", __func__);
ALOGE("%s: X", __func__);
return BAD_VALUE;
}else {
width = dim.rdi0_width;
height = dim.rdi0_height;
}
ret = getBufferRdi( );
if(ret != NO_ERROR) {
ALOGE("%s: cannot get memory from heap, ret = %d", __func__, ret);
return ret;
}
/* set 4 buffers for display */
memset(&mRdiStreamBuf, 0, sizeof(mRdiStreamBuf));
mHalCamCtrl->mRdiMemoryLock.lock();
this->mRdiStreamBuf.num = mHalCamCtrl->mRdiMemory.buffer_count;
this->myMode=myMode; /*Need to assign this in constructor after translating from mask*/
frame_len = mm_camera_get_msm_frame_len(CAMERA_RDI,
myMode,
dim.rdi0_width,
dim.rdi0_height,
OUTPUT_TYPE_R,
&num_planes, planes);
this->mRdiStreamBuf.frame_len = frame_len;
memset(&mRdiBuf, 0, sizeof(mRdiBuf));
mRdiBuf.def.buf.mp = new mm_camera_mp_buf_t[mRdiStreamBuf.num];
if (!mRdiBuf.def.buf.mp) {
ALOGE("%s Error allocating memory for mplanar struct ", __func__);
}
memset(mRdiBuf.def.buf.mp, 0,
mRdiStreamBuf.num * sizeof(mm_camera_mp_buf_t));
/*allocate memory for the buffers*/
void *vaddr = NULL;
for(int i = 0; i < mRdiStreamBuf.num; i++){
if (mHalCamCtrl->mRdiMemory.camera_memory[i] == NULL)
continue;
mRdiStreamBuf.frame[i].fd = mHalCamCtrl->mRdiMemory.fd[i];
mRdiStreamBuf.frame[i].cbcr_off = planes[0];
mRdiStreamBuf.frame[i].y_off = 0;
mRdiStreamBuf.frame[i].path = OUTPUT_TYPE_R;
mRdiStreamBuf.frame[i].buffer =
(long unsigned int)mHalCamCtrl->mRdiMemory.camera_memory[i]->data;
mRdiStreamBuf.frame[i].ion_alloc.len = mHalCamCtrl->mRdiMemory.alloc[i].len;
ALOGI("%s: idx = %d, fd = %d, size = %d, cbcr_offset = %d, y_offset = %d, "
"vaddr = 0x%x", __func__, i, mRdiStreamBuf.frame[i].fd,
frame_len,
mRdiStreamBuf.frame[i].cbcr_off, mRdiStreamBuf.frame[i].y_off,
(uint32_t)mRdiStreamBuf.frame[i].buffer);
if (NO_ERROR != mHalCamCtrl->sendMappingBuf(
MSM_V4L2_EXT_CAPTURE_MODE_RDI,
i,
mRdiStreamBuf.frame[i].fd,
mHalCamCtrl->mRdiMemory.size,
mCameraId, CAM_SOCK_MSG_TYPE_FD_MAPPING)) {
ALOGE("%s: sending mapping data Msg Failed", __func__);
}
mRdiBuf.def.buf.mp[i].frame = mRdiStreamBuf.frame[i];
mRdiBuf.def.buf.mp[i].frame_offset = mRdiStreamBuf.frame[i].y_off;
mRdiBuf.def.buf.mp[i].num_planes = num_planes;
/* Plane 0 needs to be set seperately. Set other planes
* in a loop. */
mRdiBuf.def.buf.mp[i].planes[0].length = planes[0];
mRdiBuf.def.buf.mp[i].planes[0].m.userptr = mRdiStreamBuf.frame[i].fd;
mRdiBuf.def.buf.mp[i].planes[0].data_offset = 0;
mRdiBuf.def.buf.mp[i].planes[0].reserved[0] =
mRdiBuf.def.buf.mp[i].frame_offset;
for (int j = 1; j < num_planes; j++) {
mRdiBuf.def.buf.mp[i].planes[j].length = planes[j];
mRdiBuf.def.buf.mp[i].planes[j].m.userptr =
mRdiStreamBuf.frame[i].fd;
mRdiBuf.def.buf.mp[i].planes[j].data_offset = 0;
mRdiBuf.def.buf.mp[i].planes[j].reserved[0] =
mRdiBuf.def.buf.mp[i].planes[j-1].reserved[0] +
mRdiBuf.def.buf.mp[i].planes[j-1].length;
}
for (int j = 0; j < num_planes; j++)
ALOGI("Planes: %d length: %d userptr: %lu offset: %d\n", j,
mRdiBuf.def.buf.mp[i].planes[j].length,
mRdiBuf.def.buf.mp[i].planes[j].m.userptr,
mRdiBuf.def.buf.mp[i].planes[j].reserved[0]);
}/*end of for loop*/
/* register the streaming buffers for the channel*/
mRdiBuf.ch_type = MM_CAMERA_CH_RDI;
mRdiBuf.def.num = mRdiStreamBuf.num;
mHalCamCtrl->mRdiMemoryLock.unlock();
ALOGD("%s:END",__func__);
return NO_ERROR;
end:
if (MM_CAMERA_OK == ret ) {
ALOGV("%s: X - NO_ERROR ", __func__);
return NO_ERROR;
}
ALOGV("%s: out of memory clean up", __func__);
/* release the allocated memory */
ALOGV("%s: X - BAD_VALUE ", __func__);
return BAD_VALUE;
}
/* initialize a streaming channel*/
status_t QCameraStream::initChannel(int cameraId,
uint32_t ch_type_mask)
{
#if 0
int rc = MM_CAMERA_OK;
int i;
status_t ret = NO_ERROR;
int width = 0; /* width of channel */
int height = 0; /* height of channel */
cam_ctrl_dimension_t dim;
mm_camera_ch_image_fmt_parm_t fmt;
memset(&dim, 0, sizeof(cam_ctrl_dimension_t));
rc = cam_config_get_parm(cameraId, MM_CAMERA_PARM_DIMENSION, &dim);
if (MM_CAMERA_OK != rc) {
LOGE("%s: error - can't get camera dimension!", __func__);
LOGE("%s: X", __func__);
return BAD_VALUE;
}
if(MM_CAMERA_CH_PREVIEW_MASK & ch_type_mask) {
rc = cam_ops_ch_acquire(cameraId, MM_CAMERA_CH_PREVIEW);
LOGV("%s:ch_acquire MM_CAMERA_CH_PREVIEW, rc=%d\n",__func__, rc);
if(MM_CAMERA_OK != rc) {
LOGE("%s: preview channel acquir error =%d\n", __func__, rc);
LOGE("%s: X", __func__);
return BAD_VALUE;
}
else{
memset(&fmt, 0, sizeof(mm_camera_ch_image_fmt_parm_t));
fmt.ch_type = MM_CAMERA_CH_PREVIEW;
fmt.def.fmt = CAMERA_YUV_420_NV12; //dim.prev_format;
fmt.def.dim.width = dim.display_width;
fmt.def.dim.height = dim.display_height;
LOGV("%s: preview channel fmt = %d", __func__,
dim.prev_format);
LOGV("%s: preview channel resolution = %d X %d", __func__,
dim.display_width, dim.display_height);
rc = cam_config_set_parm(cameraId, MM_CAMERA_PARM_CH_IMAGE_FMT, &fmt);
LOGV("%s: preview MM_CAMERA_PARM_CH_IMAGE_FMT rc = %d\n", __func__, rc);
if(MM_CAMERA_OK != rc) {
LOGE("%s:set preview channel format err=%d\n", __func__, ret);
LOGE("%s: X", __func__);
ret = BAD_VALUE;
}
}
}
if(MM_CAMERA_CH_VIDEO_MASK & ch_type_mask)
{
rc = cam_ops_ch_acquire(cameraId, MM_CAMERA_CH_VIDEO);
LOGV("%s:ch_acquire MM_CAMERA_CH_VIDEO, rc=%d\n",__func__, rc);
if(MM_CAMERA_OK != rc) {
LOGE("%s: video channel acquir error =%d\n", __func__, rc);
LOGE("%s: X", __func__);
ret = BAD_VALUE;
}
else {
memset(&fmt, 0, sizeof(mm_camera_ch_image_fmt_parm_t));
fmt.ch_type = MM_CAMERA_CH_VIDEO;
fmt.video.video.fmt = CAMERA_YUV_420_NV12; //dim.enc_format;
fmt.video.video.dim.width = dim.video_width;
fmt.video.video.dim.height = dim.video_height;
LOGV("%s: video channel fmt = %d", __func__,
dim.enc_format);
LOGV("%s: video channel resolution = %d X %d", __func__,
dim.video_width, dim.video_height);
rc = cam_config_set_parm(cameraId, MM_CAMERA_PARM_CH_IMAGE_FMT, &fmt);
LOGV("%s: video MM_CAMERA_PARM_CH_IMAGE_FMT rc = %d\n", __func__, rc);
if(MM_CAMERA_OK != rc) {
LOGE("%s:set video channel format err=%d\n", __func__, rc);
LOGE("%s: X", __func__);
ret= BAD_VALUE;
}
}
} /*MM_CAMERA_CH_VIDEO*/
#endif
int rc = MM_CAMERA_OK;
status_t ret = NO_ERROR;
mm_camera_op_mode_type_t op_mode=MM_CAMERA_OP_MODE_VIDEO;
int i;
LOGV("QCameraStream::initChannel : E");
if(MM_CAMERA_CH_PREVIEW_MASK & ch_type_mask){
rc = cam_ops_ch_acquire(cameraId, MM_CAMERA_CH_PREVIEW);
LOGV("%s:ch_acquire MM_CAMERA_CH_PREVIEW, rc=%d\n",__func__, rc);
if(MM_CAMERA_OK != rc) {
LOGE("%s: preview channel acquir error =%d\n", __func__, rc);
LOGE("%s: X", __func__);
return BAD_VALUE;
}
/*Callback register*/
/* register a notify into the mmmm_camera_t object*/
/* ret = cam_evt_register_buf_notify(mCameraId, MM_CAMERA_CH_PREVIEW,
preview_notify_cb,
this);
LOGV("Buf notify MM_CAMERA_CH_PREVIEW, rc=%d\n",rc);*/
}else if(MM_CAMERA_CH_VIDEO_MASK & ch_type_mask){
rc = cam_ops_ch_acquire(cameraId, MM_CAMERA_CH_VIDEO);
LOGV("%s:ch_acquire MM_CAMERA_CH_VIDEO, rc=%d\n",__func__, rc);
if(MM_CAMERA_OK != rc) {
LOGE("%s: preview channel acquir error =%d\n", __func__, rc);
LOGE("%s: X", __func__);
return BAD_VALUE;
}
/*Callback register*/
/* register a notify into the mmmm_camera_t object*/
/*ret = cam_evt_register_buf_notify(mCameraId, MM_CAMERA_CH_VIDEO,
record_notify_cb,
this);
LOGV("Buf notify MM_CAMERA_CH_VIDEO, rc=%d\n",rc);*/
}
ret = (MM_CAMERA_OK==rc)? NO_ERROR : BAD_VALUE;
LOGV("%s: X, ret = %d", __func__, ret);
return ret;
}
status_t QCameraStream_preview::getBufferFromSurface() {
int err = 0;
int numMinUndequeuedBufs = 0;
int format = 0;
status_t ret = NO_ERROR;
ALOGI(" %s : E ", __FUNCTION__);
if( mPreviewWindow == NULL) {
ALOGE("%s: mPreviewWindow = NULL", __func__);
return INVALID_OPERATION;
}
cam_ctrl_dimension_t dim;
//mDisplayLock.lock();
cam_config_get_parm(mCameraId, MM_CAMERA_PARM_DIMENSION,&dim);
format = mHalCamCtrl->getPreviewFormatInfo().Hal_format;
if(ret != NO_ERROR) {
ALOGE("%s: display format %d is not supported", __func__, dim.prev_format);
goto end;
}
numMinUndequeuedBufs = 0;
if(mPreviewWindow->get_min_undequeued_buffer_count) {
err = mPreviewWindow->get_min_undequeued_buffer_count(mPreviewWindow, &numMinUndequeuedBufs);
if (err != 0) {
ALOGE("get_min_undequeued_buffer_count failed: %s (%d)",
strerror(-err), -err);
ret = UNKNOWN_ERROR;
goto end;
}
}
mHalCamCtrl->mPreviewMemoryLock.lock();
mHalCamCtrl->mPreviewMemory.buffer_count = kPreviewBufferCount + numMinUndequeuedBufs;;
err = mPreviewWindow->set_buffer_count(mPreviewWindow, mHalCamCtrl->mPreviewMemory.buffer_count );
if (err != 0) {
ALOGE("set_buffer_count failed: %s (%d)",
strerror(-err), -err);
ret = UNKNOWN_ERROR;
goto end;
}
err = mPreviewWindow->set_buffers_geometry(mPreviewWindow,
dim.display_width, dim.display_height, format);
if (err != 0) {
ALOGE("set_buffers_geometry failed: %s (%d)",
strerror(-err), -err);
ret = UNKNOWN_ERROR;
goto end;
}
err = mPreviewWindow->set_usage(mPreviewWindow,
GRALLOC_USAGE_PRIVATE_ADSP_HEAP |
GRALLOC_USAGE_PRIVATE_UNCACHED);
if(err != 0) {
/* set_usage error out */
ALOGE("%s: set_usage rc = %d", __func__, err);
ret = UNKNOWN_ERROR;
goto end;
}
for (int cnt = 0; cnt < mHalCamCtrl->mPreviewMemory.buffer_count; cnt++) {
int stride;
err = mPreviewWindow->dequeue_buffer(mPreviewWindow,
&mHalCamCtrl->mPreviewMemory.buffer_handle[cnt],
&mHalCamCtrl->mPreviewMemory.stride[cnt]);
if(!err) {
err = mPreviewWindow->lock_buffer(this->mPreviewWindow,
mHalCamCtrl->mPreviewMemory.buffer_handle[cnt]);
// lock the buffer using genlock
ALOGD("%s: camera call genlock_lock", __FUNCTION__);
if (GENLOCK_NO_ERROR != genlock_lock_buffer((native_handle_t *)(*mHalCamCtrl->mPreviewMemory.buffer_handle[cnt]),
GENLOCK_WRITE_LOCK, GENLOCK_MAX_TIMEOUT)) {
ALOGE("%s: genlock_lock_buffer(WRITE) failed", __FUNCTION__);
mHalCamCtrl->mPreviewMemory.local_flag[cnt] = BUFFER_UNLOCKED;
mHalCamCtrl->mPreviewMemoryLock.unlock();
return -EINVAL;
}
mHalCamCtrl->mPreviewMemory.local_flag[cnt] = BUFFER_LOCKED;
} else
ALOGE("%s: dequeue_buffer idx = %d err = %d", __func__, cnt, err);
ALOGE("%s: dequeue buf: %u\n", __func__, (unsigned int)mHalCamCtrl->mPreviewMemory.buffer_handle[cnt]);
if(err != 0) {
ALOGE("%s: dequeue_buffer failed: %s (%d)", __func__,
strerror(-err), -err);
ret = UNKNOWN_ERROR;
for(int i = 0; i < cnt; i++) {
ALOGD("%s: camera call genlock_unlock", __FUNCTION__);
if (BUFFER_LOCKED == mHalCamCtrl->mPreviewMemory.local_flag[i]) {
if (GENLOCK_FAILURE == genlock_unlock_buffer((native_handle_t *)
(*(mHalCamCtrl->mPreviewMemory.buffer_handle[i])))) {
ALOGE("%s: genlock_unlock_buffer failed", __FUNCTION__);
mHalCamCtrl->mPreviewMemoryLock.unlock();
return -EINVAL;
}
}
err = mPreviewWindow->cancel_buffer(mPreviewWindow,
mHalCamCtrl->mPreviewMemory.buffer_handle[i]);
mHalCamCtrl->mPreviewMemory.buffer_handle[i] = NULL;
mHalCamCtrl->mPreviewMemory.local_flag[i] = BUFFER_UNLOCKED;
}
goto end;
}
mHalCamCtrl->mPreviewMemory.private_buffer_handle[cnt] =
(struct private_handle_t *)(*mHalCamCtrl->mPreviewMemory.buffer_handle[cnt]);
mHalCamCtrl->mPreviewMemory.camera_memory[cnt] =
mHalCamCtrl->mGetMemory(mHalCamCtrl->mPreviewMemory.private_buffer_handle[cnt]->fd,
mHalCamCtrl->mPreviewMemory.private_buffer_handle[cnt]->size, 1, (void *)this);
ALOGE("%s: idx = %d, fd = %d, size = %d, offset = %d", __func__,
cnt, mHalCamCtrl->mPreviewMemory.private_buffer_handle[cnt]->fd,
mHalCamCtrl->mPreviewMemory.private_buffer_handle[cnt]->size,
mHalCamCtrl->mPreviewMemory.private_buffer_handle[cnt]->offset);
}
memset(&mHalCamCtrl->mMetadata, 0, sizeof(mHalCamCtrl->mMetadata));
memset(mHalCamCtrl->mFace, 0, sizeof(mHalCamCtrl->mFace));
ALOGI(" %s : X ",__FUNCTION__);
end:
//mDisplayLock.unlock();
mHalCamCtrl->mPreviewMemoryLock.unlock();
return NO_ERROR;
}
status_t QCameraStream_preview::initDisplayBuffers()
{
status_t ret = NO_ERROR;
int width = 0; /* width of channel */
int height = 0; /* height of channel */
uint32_t frame_len = 0; /* frame planner length */
int buffer_num = 4; /* number of buffers for display */
const char *pmem_region;
uint8_t num_planes = 0;
uint32_t planes[VIDEO_MAX_PLANES];
cam_ctrl_dimension_t dim;
ALOGE("%s:BEGIN",__func__);
memset(&mHalCamCtrl->mMetadata, 0, sizeof(camera_frame_metadata_t));
mHalCamCtrl->mPreviewMemoryLock.lock();
memset(&mHalCamCtrl->mPreviewMemory, 0, sizeof(mHalCamCtrl->mPreviewMemory));
mHalCamCtrl->mPreviewMemoryLock.unlock();
memset(&mNotifyBuffer, 0, sizeof(mNotifyBuffer));
/* get preview size, by qury mm_camera*/
memset(&dim, 0, sizeof(cam_ctrl_dimension_t));
memset(&(this->mDisplayStreamBuf),0, sizeof(this->mDisplayStreamBuf));
ret = cam_config_get_parm(mCameraId, MM_CAMERA_PARM_DIMENSION, &dim);
if (MM_CAMERA_OK != ret) {
ALOGE("%s: error - can't get camera dimension!", __func__);
ALOGE("%s: X", __func__);
return BAD_VALUE;
}else {
width = dim.display_width,
height = dim.display_height;
}
ret = getBufferFromSurface();
if(ret != NO_ERROR) {
ALOGE("%s: cannot get memory from surface texture client, ret = %d", __func__, ret);
return ret;
}
/* set 4 buffers for display */
memset(&mDisplayStreamBuf, 0, sizeof(mDisplayStreamBuf));
mHalCamCtrl->mPreviewMemoryLock.lock();
this->mDisplayStreamBuf.num = mHalCamCtrl->mPreviewMemory.buffer_count;
this->myMode=myMode; /*Need to assign this in constructor after translating from mask*/
num_planes = 2;
planes[0] = dim.display_frame_offset.mp[0].len;
planes[1] = dim.display_frame_offset.mp[1].len;
this->mDisplayStreamBuf.frame_len = dim.display_frame_offset.frame_len;
mDisplayBuf.preview.buf.mp = new mm_camera_mp_buf_t[mDisplayStreamBuf.num];
if (!mDisplayBuf.preview.buf.mp) {
ALOGE("%s Error allocating memory for mplanar struct ", __func__);
}
memset(mDisplayBuf.preview.buf.mp, 0,
mDisplayStreamBuf.num * sizeof(mm_camera_mp_buf_t));
/*allocate memory for the buffers*/
void *vaddr = NULL;
for(int i = 0; i < mDisplayStreamBuf.num; i++){
if (mHalCamCtrl->mPreviewMemory.private_buffer_handle[i] == NULL)
continue;
mDisplayStreamBuf.frame[i].fd = mHalCamCtrl->mPreviewMemory.private_buffer_handle[i]->fd;
mDisplayStreamBuf.frame[i].cbcr_off = planes[0];
mDisplayStreamBuf.frame[i].y_off = 0;
mDisplayStreamBuf.frame[i].path = OUTPUT_TYPE_P;
mHalCamCtrl->mPreviewMemory.addr_offset[i] =
mHalCamCtrl->mPreviewMemory.private_buffer_handle[i]->offset;
mDisplayStreamBuf.frame[i].buffer =
(long unsigned int)mHalCamCtrl->mPreviewMemory.camera_memory[i]->data;
ALOGE("%s: idx = %d, fd = %d, size = %d, cbcr_offset = %d, y_offset = %d, offset = %d, vaddr = 0x%x",
__func__, i,
mDisplayStreamBuf.frame[i].fd,
mHalCamCtrl->mPreviewMemory.private_buffer_handle[i]->size,
mDisplayStreamBuf.frame[i].cbcr_off,
mDisplayStreamBuf.frame[i].y_off,
mHalCamCtrl->mPreviewMemory.addr_offset[i],
(uint32_t)mDisplayStreamBuf.frame[i].buffer);
mDisplayBuf.preview.buf.mp[i].frame = mDisplayStreamBuf.frame[i];
mDisplayBuf.preview.buf.mp[i].frame_offset = mHalCamCtrl->mPreviewMemory.addr_offset[i];
mDisplayBuf.preview.buf.mp[i].num_planes = num_planes;
/* Plane 0 needs to be set seperately. Set other planes
* in a loop. */
mDisplayBuf.preview.buf.mp[i].planes[0].length = planes[0];
mDisplayBuf.preview.buf.mp[i].planes[0].m.userptr = mDisplayStreamBuf.frame[i].fd;
mDisplayBuf.preview.buf.mp[i].planes[0].data_offset = 0;
mDisplayBuf.preview.buf.mp[i].planes[0].reserved[0] =
mDisplayBuf.preview.buf.mp[i].frame_offset;
for (int j = 1; j < num_planes; j++) {
mDisplayBuf.preview.buf.mp[i].planes[j].length = planes[j];
mDisplayBuf.preview.buf.mp[i].planes[j].m.userptr =
mDisplayStreamBuf.frame[i].fd;
mDisplayBuf.preview.buf.mp[i].planes[j].data_offset = 0;
mDisplayBuf.preview.buf.mp[i].planes[j].reserved[0] =
mDisplayBuf.preview.buf.mp[i].planes[j-1].reserved[0] +
mDisplayBuf.preview.buf.mp[i].planes[j-1].length;
}
for (int j = 0; j < num_planes; j++) {
ALOGE("Planes: %d length: %d userptr: %lu offset: %d\n",
j, mDisplayBuf.preview.buf.mp[i].planes[j].length,
mDisplayBuf.preview.buf.mp[i].planes[j].m.userptr,
mDisplayBuf.preview.buf.mp[i].planes[j].reserved[0]);
}
}/*end of for loop*/
/* register the streaming buffers for the channel*/
mDisplayBuf.ch_type = MM_CAMERA_CH_PREVIEW;
mDisplayBuf.preview.num = mDisplayStreamBuf.num;
mHalCamCtrl->mPreviewMemoryLock.unlock();
ALOGE("%s:END",__func__);
return NO_ERROR;
end:
if (MM_CAMERA_OK == ret ) {
ALOGV("%s: X - NO_ERROR ", __func__);
return NO_ERROR;
}
ALOGV("%s: out of memory clean up", __func__);
/* release the allocated memory */
ALOGV("%s: X - BAD_VALUE ", __func__);
return BAD_VALUE;
}
