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::start()
{
ALOGV("%s: E", __func__);
status_t ret = NO_ERROR;
uint32_t stream_info;
Mutex::Autolock lock(mStopCallbackLock);
/* call start() in parent class to start the monitor thread*/
//QCameraStream::start ();
stream_info = mHalCamCtrl->getChannelInterface();
setFormat(MM_CAMERA_CH_RDI_MASK, (cam_format_t)0);
initRdiBuffers();
ret = cam_config_prepare_buf(mCameraId, &mRdiBuf);
if(ret != MM_CAMERA_OK) {
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)) {
ALOGD("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);
ALOGD("OP Mode Set");
if(MM_CAMERA_OK != ret) {
ALOGE("%s: X :set mode MM_CAMERA_OP_MODE_VIDEO err=%d\n", __func__, ret);
ret = BAD_VALUE;
goto error;
}
}else {
ALOGD("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);
ret = BAD_VALUE;
goto error;
}
}
/* call mm_camera action start(...) */
ALOGD("Starting RDI Stream. ");
ret = cam_ops_action(mCameraId, TRUE, MM_CAMERA_OPS_RDI, 0);
if (MM_CAMERA_OK != ret) {
ALOGE ("%s: rdi streaming start err=%d\n", __func__, ret);
ret = BAD_VALUE;
freeBufferRdi();
goto end;
}
ret = NO_ERROR;
mActive = true;
goto end;
error:
freeBufferRdi();
end:
ALOGD("%s: X", __func__);
return ret;
}
/* 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::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;
}
