| /* |
| ** Copyright (c) 2012 The Linux Foundation. All rights reserved. |
| ** |
| ** Licensed under the Apache License, Version 2.0 (the "License"); |
| ** you may not use this file except in compliance with the License. |
| ** You may obtain a copy of the License at |
| ** |
| ** http://www.apache.org/licenses/LICENSE-2.0 |
| ** |
| ** Unless required by applicable law or agreed to in writing, software |
| ** distributed under the License is distributed on an "AS IS" BASIS, |
| ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| ** See the License for the specific language governing permissions and |
| ** limitations under the License. |
| */ |
| |
| /*#error uncomment this for compiler test!*/ |
| |
| #define ALOG_NDEBUG 0 |
| #define ALOG_NIDEBUG 0 |
| #define LOG_TAG "QCameraHWI_Preview" |
| #include <utils/Log.h> |
| #include <utils/threads.h> |
| #include <fcntl.h> |
| #include <sys/mman.h> |
| |
| #include "QCameraHAL.h" |
| #include "QCameraHWI.h" |
| #include <gralloc_priv.h> |
| #include <genlock.h> |
| |
| #define UNLIKELY(exp) __builtin_expect(!!(exp), 0) |
| |
| /* QCameraHWI_Preview class implementation goes here*/ |
| /* following code implement the preview mode's image capture & display logic of this class*/ |
| |
| namespace android { |
| |
| // --------------------------------------------------------------------------- |
| // Preview Callback |
| // --------------------------------------------------------------------------- |
| static void preview_notify_cb(mm_camera_ch_data_buf_t *frame, |
| void *user_data) |
| { |
| QCameraStream_preview *pme = (QCameraStream_preview *)user_data; |
| mm_camera_ch_data_buf_t *bufs_used = 0; |
| ALOGV("%s: E", __func__); |
| /* for peview data, there is no queue, so directly use*/ |
| if(pme==NULL) { |
| ALOGE("%s: X : Incorrect cookie",__func__); |
| /*Call buf done*/ |
| return; |
| } |
| |
| pme->processPreviewFrame(frame); |
| ALOGV("%s: X", __func__); |
| } |
| |
| status_t QCameraStream_preview::setPreviewWindow(preview_stream_ops_t* window) |
| { |
| status_t retVal = NO_ERROR; |
| ALOGE(" %s: E ", __FUNCTION__); |
| if( window == NULL) { |
| ALOGW(" Setting NULL preview window "); |
| /* TODO: Current preview window will be invalidated. |
| * Release all the buffers back */ |
| // relinquishBuffers(); |
| } |
| mDisplayLock.lock(); |
| mPreviewWindow = window; |
| mDisplayLock.unlock(); |
| ALOGV(" %s : X ", __FUNCTION__ ); |
| return retVal; |
| } |
| |
| 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::putBufferToSurface() { |
| int err = 0; |
| status_t ret = NO_ERROR; |
| |
| ALOGI(" %s : E ", __FUNCTION__); |
| |
| //mDisplayLock.lock(); |
| mHalCamCtrl->mPreviewMemoryLock.lock(); |
| for (int cnt = 0; cnt < mHalCamCtrl->mPreviewMemory.buffer_count; cnt++) { |
| mHalCamCtrl->mPreviewMemory.camera_memory[cnt]->release(mHalCamCtrl->mPreviewMemory.camera_memory[cnt]); |
| if (BUFFER_LOCKED == mHalCamCtrl->mPreviewMemory.local_flag[cnt]) { |
| ALOGD("%s: camera call genlock_unlock", __FUNCTION__); |
| if (GENLOCK_FAILURE == genlock_unlock_buffer((native_handle_t *) |
| (*(mHalCamCtrl->mPreviewMemory.buffer_handle[cnt])))) { |
| ALOGE("%s: genlock_unlock_buffer failed", __FUNCTION__); |
| mHalCamCtrl->mPreviewMemoryLock.unlock(); |
| return -EINVAL; |
| } else { |
| mHalCamCtrl->mPreviewMemory.local_flag[cnt] = BUFFER_UNLOCKED; |
| } |
| } |
| err = mPreviewWindow->cancel_buffer(mPreviewWindow, mHalCamCtrl->mPreviewMemory.buffer_handle[cnt]); |
| ALOGE(" put buffer %d successfully", cnt); |
| } |
| memset(&mHalCamCtrl->mPreviewMemory, 0, sizeof(mHalCamCtrl->mPreviewMemory)); |
| mHalCamCtrl->mPreviewMemoryLock.unlock(); |
| //mDisplayLock.unlock(); |
| ALOGI(" %s : X ",__FUNCTION__); |
| return NO_ERROR; |
| } |
| |
| void QCameraStream_preview::notifyROIEvent(fd_roi_t roi) |
| { |
| switch (roi.type) { |
| case FD_ROI_TYPE_HEADER: |
| { |
| mDisplayLock.lock(); |
| mNumFDRcvd = 0; |
| memset(mHalCamCtrl->mFace, 0, sizeof(mHalCamCtrl->mFace)); |
| mHalCamCtrl->mMetadata.faces = mHalCamCtrl->mFace; |
| mHalCamCtrl->mMetadata.number_of_faces = roi.d.hdr.num_face_detected; |
| if(mHalCamCtrl->mMetadata.number_of_faces > MAX_ROI) |
| mHalCamCtrl->mMetadata.number_of_faces = MAX_ROI; |
| mDisplayLock.unlock(); |
| |
| if (mHalCamCtrl->mMetadata.number_of_faces == 0) { |
| // Clear previous faces |
| mHalCamCtrl->mCallbackLock.lock(); |
| camera_data_callback pcb = mHalCamCtrl->mDataCb; |
| mHalCamCtrl->mCallbackLock.unlock(); |
| |
| if (pcb && (mHalCamCtrl->mMsgEnabled & CAMERA_MSG_PREVIEW_METADATA)){ |
| ALOGE("%s: Face detection RIO callback", __func__); |
| pcb(CAMERA_MSG_PREVIEW_METADATA, NULL, 0, &mHalCamCtrl->mMetadata, mHalCamCtrl->mCallbackCookie); |
| } |
| } |
| } |
| break; |
| case FD_ROI_TYPE_DATA: |
| { |
| mDisplayLock.lock(); |
| int idx = roi.d.data.idx; |
| if (idx >= mHalCamCtrl->mMetadata.number_of_faces) { |
| mDisplayLock.unlock(); |
| ALOGE("%s: idx %d out of boundary %d", __func__, idx, mHalCamCtrl->mMetadata.number_of_faces); |
| break; |
| } |
| |
| mHalCamCtrl->mFace[idx].id = roi.d.data.face.id; |
| mHalCamCtrl->mFace[idx].score = roi.d.data.face.score / 10; // keep within range 0~100 |
| |
| // top |
| mHalCamCtrl->mFace[idx].rect[0] = |
| roi.d.data.face.face_boundary.x*2000/mHalCamCtrl->mDimension.display_width - 1000; |
| //right |
| mHalCamCtrl->mFace[idx].rect[1] = |
| roi.d.data.face.face_boundary.y*2000/mHalCamCtrl->mDimension.display_height - 1000; |
| //bottom |
| mHalCamCtrl->mFace[idx].rect[2] = mHalCamCtrl->mFace[idx].rect[0] + |
| roi.d.data.face.face_boundary.dx*2000/mHalCamCtrl->mDimension.display_width; |
| //left |
| mHalCamCtrl->mFace[idx].rect[3] = mHalCamCtrl->mFace[idx].rect[1] + |
| roi.d.data.face.face_boundary.dy*2000/mHalCamCtrl->mDimension.display_height; |
| |
| // Center of left eye |
| mHalCamCtrl->mFace[idx].left_eye[0] = |
| roi.d.data.face.left_eye_center[0]*2000/mHalCamCtrl->mDimension.display_width - 1000; |
| mHalCamCtrl->mFace[idx].left_eye[1] = |
| roi.d.data.face.left_eye_center[1]*2000/mHalCamCtrl->mDimension.display_height - 1000; |
| |
| // Center of right eye |
| mHalCamCtrl->mFace[idx].right_eye[0] = |
| roi.d.data.face.right_eye_center[0]*2000/mHalCamCtrl->mDimension.display_width - 1000; |
| mHalCamCtrl->mFace[idx].right_eye[1] = |
| roi.d.data.face.right_eye_center[1]*2000/mHalCamCtrl->mDimension.display_height - 1000; |
| |
| // Center of mouth |
| mHalCamCtrl->mFace[idx].mouth[0] = |
| roi.d.data.face.mouth_center[0]*2000/mHalCamCtrl->mDimension.display_width - 1000; |
| mHalCamCtrl->mFace[idx].mouth[1] = |
| roi.d.data.face.mouth_center[1]*2000/mHalCamCtrl->mDimension.display_height - 1000; |
| |
| mHalCamCtrl->mFace[idx].smile_degree = roi.d.data.face.smile_degree; |
| mHalCamCtrl->mFace[idx].smile_score = roi.d.data.face.smile_confidence; |
| mHalCamCtrl->mFace[idx].blink_detected = roi.d.data.face.blink_detected; |
| mHalCamCtrl->mFace[idx].face_recognised = roi.d.data.face.is_face_recognised; |
| mHalCamCtrl->mFace[idx].gaze_angle = roi.d.data.face.gaze_angle; |
| |
| /* newly added */ |
| // upscale by 2 to recover from demaen downscaling |
| mHalCamCtrl->mFace[idx].updown_dir = roi.d.data.face.updown_dir*2; |
| mHalCamCtrl->mFace[idx].leftright_dir = roi.d.data.face.leftright_dir*2; |
| mHalCamCtrl->mFace[idx].roll_dir = roi.d.data.face.roll_dir*2; |
| |
| mHalCamCtrl->mFace[idx].leye_blink = roi.d.data.face.left_blink; |
| mHalCamCtrl->mFace[idx].reye_blink = roi.d.data.face.right_blink; |
| mHalCamCtrl->mFace[idx].left_right_gaze = roi.d.data.face.left_right_gaze; |
| mHalCamCtrl->mFace[idx].top_bottom_gaze = roi.d.data.face.top_bottom_gaze; |
| |
| ALOGE("%s: Face(%d, %d, %d, %d), leftEye(%d, %d), rightEye(%d, %d), mouth(%d, %d), smile(%d, %d), blinked(%d)", __func__, |
| mHalCamCtrl->mFace[idx].rect[0], mHalCamCtrl->mFace[idx].rect[1], |
| mHalCamCtrl->mFace[idx].rect[2], mHalCamCtrl->mFace[idx].rect[3], |
| mHalCamCtrl->mFace[idx].left_eye[0], mHalCamCtrl->mFace[idx].left_eye[1], |
| mHalCamCtrl->mFace[idx].right_eye[0], mHalCamCtrl->mFace[idx].right_eye[1], |
| mHalCamCtrl->mFace[idx].mouth[0], mHalCamCtrl->mFace[idx].mouth[1], |
| roi.d.data.face.smile_degree, roi.d.data.face.smile_confidence, roi.d.data.face.blink_detected); |
| |
| mNumFDRcvd++; |
| mDisplayLock.unlock(); |
| |
| if (mNumFDRcvd == mHalCamCtrl->mMetadata.number_of_faces) { |
| mHalCamCtrl->mCallbackLock.lock(); |
| camera_data_callback pcb = mHalCamCtrl->mDataCb; |
| mHalCamCtrl->mCallbackLock.unlock(); |
| |
| if (pcb && (mHalCamCtrl->mMsgEnabled & CAMERA_MSG_PREVIEW_METADATA)){ |
| ALOGE("%s: Face detection RIO callback with %d faces detected (score=%d)", __func__, mNumFDRcvd, mHalCamCtrl->mFace[idx].score); |
| pcb(CAMERA_MSG_PREVIEW_METADATA, NULL, 0, &mHalCamCtrl->mMetadata, mHalCamCtrl->mCallbackCookie); |
| } |
| } |
| } |
| break; |
| } |
| } |
| |
| 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; |
| } |
| |
| void QCameraStream_preview::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.display_width; |
| h = dim.display_height; |
| len = (w * h)*3/2; |
| count++; |
| if(count < 100) { |
| snprintf(buf, sizeof(buf), "/data/mzhu%d.yuv", count); |
| file_fd = open(buf, O_RDWR | O_CREAT, 0777); |
| |
| rc = write(file_fd, (const void *)addr, len); |
| ALOGE("%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); |
| ALOGE("%s: dump %s, rc = %d, len = %d", __func__, buf, rc, len); |
| } |
| } |
| |
| status_t QCameraStream_preview::processPreviewFrame(mm_camera_ch_data_buf_t *frame) |
| { |
| ALOGV("%s",__func__); |
| int err = 0; |
| int msgType = 0; |
| camera_memory_t *data = NULL; |
| camera_frame_metadata_t *metadata = NULL; |
| |
| Mutex::Autolock lock(mStopCallbackLock); |
| if(!mActive) { |
| ALOGE("Preview Stopped. Returning callback"); |
| return NO_ERROR; |
| } |
| if(mHalCamCtrl==NULL) { |
| ALOGE("%s: X: HAL control object not set",__func__); |
| /*Call buf done*/ |
| return BAD_VALUE; |
| } |
| |
| mHalCamCtrl->mCallbackLock.lock(); |
| camera_data_timestamp_callback rcb = mHalCamCtrl->mDataCbTimestamp; |
| void *rdata = mHalCamCtrl->mCallbackCookie; |
| mHalCamCtrl->mCallbackLock.unlock(); |
| |
| if (UNLIKELY(mHalCamCtrl->mDebugFps)) { |
| mHalCamCtrl->debugShowPreviewFPS(); |
| } |
| //dumpFrameToFile(frame->def.frame); |
| mHalCamCtrl->dumpFrameToFile(frame->def.frame, HAL_DUMP_FRM_PREVIEW); |
| |
| nsecs_t timeStamp = systemTime(); |
| |
| mHalCamCtrl->mPreviewMemoryLock.lock(); |
| mNotifyBuffer[frame->def.idx] = *frame; |
| // mzhu fix me, need to check meta data also. |
| |
| ALOGI("Enqueue buf handle %p\n", |
| mHalCamCtrl->mPreviewMemory.buffer_handle[frame->def.idx]); |
| ALOGD("%s: camera call genlock_unlock", __FUNCTION__); |
| if (BUFFER_LOCKED == mHalCamCtrl->mPreviewMemory.local_flag[frame->def.idx]) { |
| if (GENLOCK_FAILURE == genlock_unlock_buffer((native_handle_t*) |
| (*mHalCamCtrl->mPreviewMemory.buffer_handle[frame->def.idx]))) { |
| ALOGE("%s: genlock_unlock_buffer failed", __FUNCTION__); |
| mHalCamCtrl->mPreviewMemoryLock.unlock(); |
| return -EINVAL; |
| } else { |
| mHalCamCtrl->mPreviewMemory.local_flag[frame->def.idx] = BUFFER_UNLOCKED; |
| } |
| } else { |
| ALOGE("%s: buffer to be enqueued is not locked", __FUNCTION__); |
| mHalCamCtrl->mPreviewMemoryLock.unlock(); |
| return -EINVAL; |
| } |
| err = this->mPreviewWindow->enqueue_buffer(this->mPreviewWindow, |
| (buffer_handle_t *)mHalCamCtrl->mPreviewMemory.buffer_handle[frame->def.idx]); |
| if(err != 0) { |
| ALOGE("%s: enqueue_buffer failed, err = %d", __func__, err); |
| } |
| buffer_handle_t *buffer_handle = NULL; |
| int tmp_stride = 0; |
| err = this->mPreviewWindow->dequeue_buffer(this->mPreviewWindow, |
| &buffer_handle, &tmp_stride); |
| if (err == NO_ERROR && buffer_handle != NULL) { |
| err = this->mPreviewWindow->lock_buffer(this->mPreviewWindow, buffer_handle); |
| ALOGD("%s: camera call genlock_lock", __FUNCTION__); |
| if (GENLOCK_FAILURE == genlock_lock_buffer((native_handle_t*)(*buffer_handle), GENLOCK_WRITE_LOCK, |
| GENLOCK_MAX_TIMEOUT)) { |
| ALOGE("%s: genlock_lock_buffer(WRITE) failed", __FUNCTION__); |
| mHalCamCtrl->mPreviewMemoryLock.unlock(); |
| return -EINVAL; |
| } |
| for(int i = 0; i < mHalCamCtrl->mPreviewMemory.buffer_count; i++) { |
| ALOGD("h1: %p h2: %p\n", mHalCamCtrl->mPreviewMemory.buffer_handle[i], buffer_handle); |
| if(mHalCamCtrl->mPreviewMemory.buffer_handle[i] == buffer_handle) { |
| mm_camera_ch_data_buf_t tmp_frame; |
| mHalCamCtrl->mPreviewMemory.local_flag[i] = BUFFER_LOCKED; |
| if(MM_CAMERA_OK != cam_evt_buf_done(mCameraId, &mNotifyBuffer[i])) { |
| ALOGD("BUF DONE FAILED"); |
| mHalCamCtrl->mPreviewMemoryLock.unlock(); |
| return BAD_VALUE; |
| } |
| break; |
| } |
| } |
| } else |
| ALOGE("%s: error in dequeue_buffer, enqueue_buffer idx = %d, no free buffer now", __func__, frame->def.idx); |
| /* Save the last displayed frame. We'll be using it to fill the gap between |
| when preview stops and postview start during snapshot.*/ |
| mLastQueuedFrame = &(mDisplayStreamBuf.frame[frame->def.idx]); |
| mHalCamCtrl->mPreviewMemoryLock.unlock(); |
| |
| mHalCamCtrl->mCallbackLock.lock(); |
| camera_data_callback pcb = mHalCamCtrl->mDataCb; |
| mHalCamCtrl->mCallbackLock.unlock(); |
| ALOGD("Message enabled = 0x%x", mHalCamCtrl->mMsgEnabled); |
| |
| if (pcb != NULL) { |
| //Sending preview callback if corresponding Msgs are enabled |
| if(mHalCamCtrl->mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME) { |
| msgType |= CAMERA_MSG_PREVIEW_FRAME; |
| data = mHalCamCtrl->mPreviewMemory.camera_memory[frame->def.idx];//mPreviewHeap->mBuffers[frame->def.idx]; |
| } else { |
| data = NULL; |
| } |
| if(msgType) { |
| mStopCallbackLock.unlock(); |
| pcb(msgType, data, 0, metadata, mHalCamCtrl->mCallbackCookie); |
| } |
| ALOGD("end of cb"); |
| } |
| if(rcb != NULL) |
| { |
| if (mHalCamCtrl->mStoreMetaDataInFrame) |
| { |
| mStopCallbackLock.unlock(); |
| if(mHalCamCtrl->mStartRecording == true &&( mHalCamCtrl->mMsgEnabled & CAMERA_MSG_VIDEO_FRAME)) |
| rcb(timeStamp, CAMERA_MSG_VIDEO_FRAME, |
| mHalCamCtrl->mRecordingMemory.metadata_memory[frame->def.idx], |
| 0, mHalCamCtrl->mCallbackCookie); |
| } |
| else |
| { |
| if(mHalCamCtrl->mStartRecording == true &&( mHalCamCtrl->mMsgEnabled & CAMERA_MSG_VIDEO_FRAME)) |
| { |
| mStopCallbackLock.unlock(); |
| rcb(timeStamp, CAMERA_MSG_VIDEO_FRAME, |
| mHalCamCtrl->mPreviewMemory.camera_memory[frame->def.idx], |
| 0, mHalCamCtrl->mCallbackCookie); |
| } |
| } |
| } |
| |
| /* Save the last displayed frame. We'll be using it to fill the gap between |
| when preview stops and postview start during snapshot.*/ |
| //mLastQueuedFrame = frame->def.frame; |
| /* |
| if(MM_CAMERA_OK != cam_evt_buf_done(mCameraId, frame)) |
| { |
| ALOGE("BUF DONE FAILED"); |
| return BAD_VALUE; |
| } |
| */ |
| return NO_ERROR; |
| } |
| |
| // --------------------------------------------------------------------------- |
| // QCameraStream_preview |
| // --------------------------------------------------------------------------- |
| |
| QCameraStream_preview:: |
| QCameraStream_preview(int cameraId, camera_mode_t mode) |
| : QCameraStream(cameraId,mode), |
| mLastQueuedFrame(NULL), |
| mNumFDRcvd(0) |
| { |
| mHalCamCtrl = NULL; |
| ALOGE("%s: E", __func__); |
| ALOGE("%s: X", __func__); |
| } |
| // --------------------------------------------------------------------------- |
| // QCameraStream_preview |
| // --------------------------------------------------------------------------- |
| |
| QCameraStream_preview::~QCameraStream_preview() { |
| ALOGV("%s: E", __func__); |
| if(mActive) { |
| stop(); |
| } |
| if(mInit) { |
| release(); |
| } |
| mInit = false; |
| mActive = false; |
| ALOGV("%s: X", __func__); |
| |
| } |
| // --------------------------------------------------------------------------- |
| // QCameraStream_preview |
| // --------------------------------------------------------------------------- |
| |
| status_t QCameraStream_preview::init() { |
| |
| status_t ret = NO_ERROR; |
| ALOGV("%s: E", __func__); |
| |
| ret = QCameraStream::initChannel (mCameraId, MM_CAMERA_CH_PREVIEW_MASK); |
| if (NO_ERROR!=ret) { |
| ALOGE("%s E: can't init native cammera preview ch\n",__func__); |
| return ret; |
| } |
| |
| ALOGE("Debug : %s : initChannel",__func__); |
| /* register a notify into the mmmm_camera_t object*/ |
| (void) cam_evt_register_buf_notify(mCameraId, MM_CAMERA_CH_PREVIEW, |
| preview_notify_cb, MM_CAMERA_REG_BUF_CB_INFINITE, 0, this); |
| ALOGE("Debug : %s : cam_evt_register_buf_notify",__func__); |
| buffer_handle_t *buffer_handle = NULL; |
| int tmp_stride = 0; |
| mInit = true; |
| return ret; |
| } |
| // --------------------------------------------------------------------------- |
| // QCameraStream_preview |
| // --------------------------------------------------------------------------- |
| |
| status_t QCameraStream_preview::start() |
| { |
| ALOGV("%s: E", __func__); |
| status_t ret = NO_ERROR; |
| mm_camera_reg_buf_t *reg_buf=&mDisplayBuf; |
| |
| Mutex::Autolock lock(mStopCallbackLock); |
| |
| /* call start() in parent class to start the monitor thread*/ |
| //QCameraStream::start (); |
| setFormat(MM_CAMERA_CH_PREVIEW_MASK); |
| |
| if(NO_ERROR!=initDisplayBuffers()){ |
| return BAD_VALUE; |
| } |
| ALOGE("Debug : %s : initDisplayBuffers",__func__); |
| ret = cam_config_prepare_buf(mCameraId, reg_buf); |
| ALOGE("Debug : %s : cam_config_prepare_buf",__func__); |
| if(ret != MM_CAMERA_OK) { |
| ALOGV("%s:reg preview buf err=%d\n", __func__, ret); |
| ret = BAD_VALUE; |
| }else |
| ret = NO_ERROR; |
| |
| /* For preview, the OP_MODE we set is dependent upon whether we are |
| starting camera or camcorder. For snapshot, anyway we disable preview. |
| However, for ZSL we need to set OP_MODE to OP_MODE_ZSL and not |
| OP_MODE_VIDEO. We'll set that for now in CamCtrl. So in case of |
| ZSL we skip setting Mode here */ |
| |
| if (!(myMode & CAMERA_ZSL_MODE)) { |
| ALOGE("Setting OP MODE to MM_CAMERA_OP_MODE_VIDEO"); |
| mm_camera_op_mode_type_t op_mode=MM_CAMERA_OP_MODE_VIDEO; |
| ret = cam_config_set_parm (mCameraId, MM_CAMERA_PARM_OP_MODE, |
| &op_mode); |
| ALOGE("OP Mode Set"); |
| |
| if(MM_CAMERA_OK != ret) { |
| ALOGE("%s: X :set mode MM_CAMERA_OP_MODE_VIDEO err=%d\n", __func__, ret); |
| return BAD_VALUE; |
| } |
| }else { |
| ALOGE("Setting OP MODE to MM_CAMERA_OP_MODE_ZSL"); |
| mm_camera_op_mode_type_t op_mode=MM_CAMERA_OP_MODE_ZSL; |
| ret = cam_config_set_parm (mCameraId, MM_CAMERA_PARM_OP_MODE, |
| &op_mode); |
| if(MM_CAMERA_OK != ret) { |
| ALOGE("%s: X :set mode MM_CAMERA_OP_MODE_ZSL err=%d\n", __func__, ret); |
| return BAD_VALUE; |
| } |
| } |
| |
| /* call mm_camera action start(...) */ |
| ALOGE("Starting Preview/Video Stream. "); |
| ret = cam_ops_action(mCameraId, TRUE, MM_CAMERA_OPS_PREVIEW, 0); |
| |
| if (MM_CAMERA_OK != ret) { |
| ALOGE ("%s: preview streaming start err=%d\n", __func__, ret); |
| return BAD_VALUE; |
| } |
| |
| ALOGE("Debug : %s : Preview streaming Started",__func__); |
| ret = NO_ERROR; |
| |
| mActive = true; |
| ALOGE("%s: X", __func__); |
| return NO_ERROR; |
| } |
| |
| |
| // --------------------------------------------------------------------------- |
| // QCameraStream_preview |
| // --------------------------------------------------------------------------- |
| void QCameraStream_preview::stop() { |
| ALOGE("%s: E", __func__); |
| int ret=MM_CAMERA_OK; |
| |
| if(!mActive) { |
| return; |
| } |
| mActive = false; |
| Mutex::Autolock lock(mStopCallbackLock); |
| /* unregister the notify fn from the mmmm_camera_t object*/ |
| |
| /* call stop() in parent class to stop the monitor thread*/ |
| ret = cam_ops_action(mCameraId, FALSE, MM_CAMERA_OPS_PREVIEW, 0); |
| if(MM_CAMERA_OK != ret) { |
| ALOGE ("%s: camera preview stop err=%d\n", __func__, ret); |
| } |
| ALOGE("Debug : %s : Preview streaming Stopped",__func__); |
| ret = cam_config_unprepare_buf(mCameraId, MM_CAMERA_CH_PREVIEW); |
| if(ret != MM_CAMERA_OK) { |
| ALOGE("%s:Unreg preview buf err=%d\n", __func__, ret); |
| //ret = BAD_VALUE; |
| } |
| |
| ALOGE("Debug : %s : Buffer Unprepared",__func__); |
| if (mDisplayBuf.preview.buf.mp != NULL) { |
| delete[] mDisplayBuf.preview.buf.mp; |
| } |
| /*free camera_memory handles and return buffer back to surface*/ |
| putBufferToSurface(); |
| |
| ALOGE("%s: X", __func__); |
| |
| } |
| // --------------------------------------------------------------------------- |
| // QCameraStream_preview |
| // --------------------------------------------------------------------------- |
| void QCameraStream_preview::release() { |
| |
| ALOGE("%s : BEGIN",__func__); |
| int ret=MM_CAMERA_OK,i; |
| |
| if(!mInit) |
| { |
| ALOGE("%s : Stream not Initalized",__func__); |
| return; |
| } |
| |
| if(mActive) { |
| this->stop(); |
| } |
| |
| ret= QCameraStream::deinitChannel(mCameraId, MM_CAMERA_CH_PREVIEW); |
| ALOGE("Debug : %s : De init Channel",__func__); |
| if(ret != MM_CAMERA_OK) { |
| ALOGE("%s:Deinit preview channel failed=%d\n", __func__, ret); |
| //ret = BAD_VALUE; |
| } |
| |
| (void)cam_evt_register_buf_notify(mCameraId, MM_CAMERA_CH_PREVIEW, |
| NULL, |
| (mm_camera_register_buf_cb_type_t)NULL, |
| NULL, |
| NULL); |
| mInit = false; |
| ALOGE("%s: END", __func__); |
| |
| } |
| |
| QCameraStream* |
| QCameraStream_preview::createInstance(int cameraId, |
| camera_mode_t mode) |
| { |
| QCameraStream* pme = new QCameraStream_preview(cameraId, mode); |
| return pme; |
| } |
| // --------------------------------------------------------------------------- |
| // QCameraStream_preview |
| // --------------------------------------------------------------------------- |
| |
| void QCameraStream_preview::deleteInstance(QCameraStream *p) |
| { |
| if (p){ |
| ALOGV("%s: BEGIN", __func__); |
| p->release(); |
| delete p; |
| p = NULL; |
| ALOGV("%s: END", __func__); |
| } |
| } |
| |
| |
| /* Temp helper function */ |
| void *QCameraStream_preview::getLastQueuedFrame(void) |
| { |
| return mLastQueuedFrame; |
| } |
| |
| status_t QCameraStream_preview::initPreviewOnlyBuffers() |
| { |
| /*1. for 7x27a, this shall not called; |
| 2. this file shall be removed ASAP |
| so put a dummy function to just pass the compile*/ |
| return INVALID_OPERATION; |
| } |
| |
| // --------------------------------------------------------------------------- |
| // No code beyone this line |
| // --------------------------------------------------------------------------- |
| }; // namespace android |
