接着《Android 源码 Camera2 预览流程分析二》，先来分析 QCamera3Channel 初始化，通过《Android 源码 Camera2 HAL3 流配置》一节可以知道实际上 对应于 HAL_PIXEL_FORMAT_YCbCr_420_888 格式创建的 QCamera3Channel 实现类指向了 QCamera3RegularChannel。
- 调用 init(…) 初始化；
- 确定流格式；
- 调用 addStream(…) 添加流。
device/moto/shamu/camera/QCamera2/HAL3/QCamera3Channel.cpp
int32_t QCamera3RegularChannel::initialize(cam_is_type_t isType)
{
ATRACE_CALL();
int32_t rc = NO_ERROR;
cam_format_t streamFormat;
cam_dimension_t streamDim;
if (NULL == mCamera3Stream) {
ALOGE("%s: Camera stream uninitialized", __func__);
return NO_INIT;
}
if (1 <= m_numStreams) {
// Hal v3 中每个 channel 仅支持一个流
return NO_ERROR;
}
rc = init(NULL, NULL);
if (rc < 0) {
ALOGE("%s: init failed", __func__);
return rc;
}
mNumBufs = CAM_MAX_NUM_BUFS_PER_STREAM;
mIsType = isType;
if (mCamera3Stream->format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) {
if (mStreamType == CAM_STREAM_TYPE_VIDEO) {
streamFormat = VIDEO_FORMAT;
} else if (mStreamType == CAM_STREAM_TYPE_PREVIEW) {
streamFormat = PREVIEW_FORMAT;
} else {
//TODO: 在libgralloc中为ZSL缓冲区添加一个新标志，
//并且其大小需要正确对齐和填充。
streamFormat = DEFAULT_FORMAT;
}
} else if(mCamera3Stream->format == HAL_PIXEL_FORMAT_YCbCr_420_888) {
streamFormat = CALLBACK_FORMAT;
} else if (mCamera3Stream->format == HAL_PIXEL_FORMAT_RAW_OPAQUE ||
mCamera3Stream->format == HAL_PIXEL_FORMAT_RAW10 ||
mCamera3Stream->format == HAL_PIXEL_FORMAT_RAW16) {
// Bayer pattern doesn't matter here.
// All CAMIF raw format uses 10bit.
streamFormat = RAW_FORMAT;
} else {
//TODO: Fail for other types of streams for now
ALOGE("%s: format is not IMPLEMENTATION_DEFINED or flexible", __func__);
return -EINVAL;
}
streamDim.width = mCamera3Stream->width;
streamDim.height = mCamera3Stream->height;
rc = QCamera3Channel::addStream(mStreamType,
streamFormat,
streamDim,
mNumBufs,
mPostProcMask,
mIsType);
return rc;
}
初始化 channel。m_camOps 指向了 mm_camera_ops_t 相机操作方法表，add_channel 实际实现是 mm_camera_intf_add_channel。
device/moto/shamu/camera/QCamera2/HAL3/QCamera3Channel.cpp
int32_t QCamera3Channel::init(mm_camera_channel_attr_t *attr,
mm_camera_buf_notify_t dataCB)
{
m_handle = m_camOps->add_channel(m_camHandle,
attr,
dataCB,
this);
if (m_handle == 0) {
ALOGE("%s: Add channel failed", __func__);
return UNKNOWN_ERROR;
}
return NO_ERROR;
}
device/moto/shamu/camera/QCamera2/stack/mm-camera-interface/src/mm_camera_interface.c
/* camera ops v-table */
static mm_camera_ops_t mm_camera_ops = {
.query_capability = mm_camera_intf_query_capability,
.register_event_notify = mm_camera_intf_register_event_notify,
.close_camera = mm_camera_intf_close,
.error_close_camera = mm_camera_intf_error_close,
.set_parms = mm_camera_intf_set_parms,
.get_parms = mm_camera_intf_get_parms,
.do_auto_focus = mm_camera_intf_do_auto_focus,
.cancel_auto_focus = mm_camera_intf_cancel_auto_focus,
.prepare_snapshot = mm_camera_intf_prepare_snapshot,
.start_zsl_snapshot = mm_camera_intf_start_zsl_snapshot,
.stop_zsl_snapshot = mm_camera_intf_stop_zsl_snapshot,
.map_buf = mm_camera_intf_map_buf,
.unmap_buf = mm_camera_intf_unmap_buf,
.add_channel = mm_camera_intf_add_channel,
.delete_channel = mm_camera_intf_del_channel,
.get_bundle_info = mm_camera_intf_get_bundle_info,
.add_stream = mm_camera_intf_add_stream,
.delete_stream = mm_camera_intf_del_stream,
.config_stream = mm_camera_intf_config_stream,
.qbuf = mm_camera_intf_qbuf,
.map_stream_buf = mm_camera_intf_map_stream_buf,
.unmap_stream_buf = mm_camera_intf_unmap_stream_buf,
.set_stream_parms = mm_camera_intf_set_stream_parms,
.get_stream_parms = mm_camera_intf_get_stream_parms,
.start_channel = mm_camera_intf_start_channel,
.stop_channel = mm_camera_intf_stop_channel,
.request_super_buf = mm_camera_intf_request_super_buf,
.cancel_super_buf_request = mm_camera_intf_cancel_super_buf_request,
.flush_super_buf_queue = mm_camera_intf_flush_super_buf_queue,
.configure_notify_mode = mm_camera_intf_configure_notify_mode,
.process_advanced_capture = mm_camera_intf_process_advanced_capture
};
添加 channel，主要调用了 mm_camera_add_channel 函数。
camera_handle: 相机句柄
attr : 通道的 bundle 属性（如果需要）
channel_cb : bundle 数据通知的回调函数
userdata : 用户数据指针
device/moto/shamu/camera/QCamera2/stack/mm-camera-interface/src/mm_camera_interface.c
static uint32_t mm_camera_intf_add_channel(uint32_t camera_handle,
mm_camera_channel_attr_t *attr,
mm_camera_buf_notify_t channel_cb,
void *userdata)
{
uint32_t ch_id = 0;
mm_camera_obj_t * my_obj = NULL;
CDBG("%s :E camera_handler = %d", __func__, camera_handle);
pthread_mutex_lock(&g_intf_lock);
my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
if(my_obj) {
pthread_mutex_lock(&my_obj->cam_lock);
pthread_mutex_unlock(&g_intf_lock);
ch_id = mm_camera_add_channel(my_obj, attr, channel_cb, userdata);
} else {
pthread_mutex_unlock(&g_intf_lock);
}
CDBG("%s :X ch_id = %d", __func__, ch_id);
return ch_id;
}
首先查找未使用的 slot，接着调用 mm_channel_init(…) 初始化。
device/moto/shamu/camera/QCamera2/stack/mm-camera-interface/src/mm_camera.c
uint32_t mm_camera_add_channel(mm_camera_obj_t *my_obj,
mm_camera_channel_attr_t *attr,
mm_camera_buf_notify_t channel_cb,
void *userdata)
{
mm_channel_t *ch_obj = NULL;
uint8_t ch_idx = 0;
uint32_t ch_hdl = 0;
for(ch_idx = 0; ch_idx < MM_CAMERA_CHANNEL_MAX; ch_idx++) {
if (MM_CHANNEL_STATE_NOTUSED == my_obj->ch[ch_idx].state) {
ch_obj = &my_obj->ch[ch_idx];
break;
}
}
if (NULL != ch_obj) {
/* initialize channel obj */
memset(ch_obj, 0, sizeof(mm_channel_t));
ch_hdl = mm_camera_util_generate_handler(ch_idx);
ch_obj->my_hdl = ch_hdl;
ch_obj->state = MM_CHANNEL_STATE_STOPPED;
ch_obj->cam_obj = my_obj;
pthread_mutex_init(&ch_obj->ch_lock, NULL);
mm_channel_init(ch_obj, attr, channel_cb, userdata);
}
pthread_mutex_unlock(&my_obj->cam_lock);
return ch_hdl;
}
在 channel 打开时启动数据轮询线程。
device/moto/shamu/camera/QCamera2/stack/mm-camera-interface/src/mm_camera_channel.c
int32_t mm_channel_init(mm_channel_t *my_obj,
mm_camera_channel_attr_t *attr,
mm_camera_buf_notify_t channel_cb,
void *userdata)
{
int32_t rc = 0;
my_obj->bundle.super_buf_notify_cb = channel_cb;
my_obj->bundle.user_data = userdata;
if (NULL != attr) {
my_obj->bundle.superbuf_queue.attr = *attr;
}
CDBG("%s : Launch data poll thread in channel open", __func__);
mm_camera_poll_thread_launch(&my_obj->poll_thread[0],
MM_CAMERA_POLL_TYPE_DATA);
/* 将状态更改为停止状态 */
my_obj->state = MM_CHANNEL_STATE_STOPPED;
return rc;
}
调用了 pthread_create 创建了线程，线程执行的方法是 mm_camera_poll_thread（入参 poll_cb 指向 mm_camera_poll_thread_t 结构）。
device/moto/shamu/camera/QCamera2/stack/mm-camera-interface/src/mm_camera_thread.c
int32_t mm_camera_poll_thread_launch(mm_camera_poll_thread_t * poll_cb,
mm_camera_poll_thread_type_t poll_type)
{
int32_t rc = 0;
poll_cb->poll_type = poll_type;
poll_cb->pfds[0] = -1;
poll_cb->pfds[1] = -1;
rc = pipe(poll_cb->pfds);
if(rc < 0) {
CDBG_ERROR("%s: pipe open rc=%d\n", __func__, rc);
return -1;
}
poll_cb->timeoutms = -1; /* Infinite seconds */
CDBG("%s: poll_type = %d, read fd = %d, write fd = %d timeout = %d",
__func__, poll_cb->poll_type,
poll_cb->pfds[0], poll_cb->pfds[1],poll_cb->timeoutms);
pthread_mutex_init(&poll_cb->mutex, NULL);
pthread_cond_init(&poll_cb->cond_v, NULL);
/* launch the thread */
pthread_mutex_lock(&poll_cb->mutex);
poll_cb->status = 0;
pthread_create(&poll_cb->pid, NULL, mm_camera_poll_thread, (void *)poll_cb);
if(!poll_cb->status) {
pthread_cond_wait(&poll_cb->cond_v, &poll_cb->mutex);
}
pthread_mutex_unlock(&poll_cb->mutex);
CDBG("%s: End",__func__);
return rc;
}
轮询线程入口函数。
device/moto/shamu/camera/QCamera2/stack/mm-camera-interface/src/mm_camera_thread.c
static void *mm_camera_poll_thread(void *data)
{
// 设置进程名
prctl(PR_SET_NAME, (unsigned long)"mm_cam_poll_th", 0, 0, 0);
mm_camera_poll_thread_t *poll_cb = (mm_camera_poll_thread_t *)data;
/* 先添加管道读 fd 到 poll */
poll_cb->poll_fds[poll_cb->num_fds++].fd = poll_cb->pfds[0];
mm_camera_poll_sig_done(poll_cb);
mm_camera_poll_set_state(poll_cb, MM_CAMERA_POLL_TASK_STATE_POLL);
return mm_camera_poll_fn(poll_cb);
}
轮询线程例程。mm_camera_poll_proc_pipe 实现轮询线程例程处理管道。
device/moto/shamu/camera/QCamera2/stack/mm-camera-interface/src/mm_camera_thread.c
static void *mm_camera_poll_fn(mm_camera_poll_thread_t *poll_cb)
{
int rc = 0, i;
if (NULL == poll_cb) {
CDBG_ERROR("%s: poll_cb is NULL!\n", __func__);
return NULL;
}
CDBG("%s: poll type = %d, num_fd = %d poll_cb = %p\n",
__func__, poll_cb->poll_type, poll_cb->num_fds,poll_cb);
do {
for(i = 0; i < poll_cb->num_fds; i++) {
// 普通或优先级带数据可读 | 普通数据可读 | 高优先级数据可读
poll_cb->poll_fds[i].events = POLLIN|POLLRDNORM|POLLPRI;
}
rc = poll(poll_cb->poll_fds, poll_cb->num_fds, poll_cb->timeoutms);
if(rc > 0) {
if ((poll_cb->poll_fds[0].revents & POLLIN) &&
(poll_cb->poll_fds[0].revents & POLLRDNORM)) {
/* 如果我们在管道上有数据，我们只在这个迭代中处理管道 */
CDBG("%s: cmd received on pipe\n", __func__);
mm_camera_poll_proc_pipe(poll_cb);
} else {
for(i=1; i<poll_cb->num_fds; i++) {
/* 检查ctrl事件 */
if ((poll_cb->poll_type == MM_CAMERA_POLL_TYPE_EVT) &&
(poll_cb->poll_fds[i].revents & POLLPRI)) {
CDBG("%s: mm_camera_evt_notify\n", __func__);
if (NULL != poll_cb->poll_entries[i-1].notify_cb) {
poll_cb->poll_entries[i-1].notify_cb(poll_cb->poll_entries[i-1].user_data);
}
}
if ((MM_CAMERA_POLL_TYPE_DATA == poll_cb->poll_type) &&
(poll_cb->poll_fds[i].revents & POLLIN) &&
(poll_cb->poll_fds[i].revents & POLLRDNORM)) {
CDBG("%s: mm_stream_data_notify\n", __func__);
if (NULL != poll_cb->poll_entries[i-1].notify_cb) {
poll_cb->poll_entries[i-1].notify_cb(poll_cb->poll_entries[i-1].user_data);
}
}
}
}
} else {
/* in error case sleep 10 us and then continue. hard coded here */
usleep(10);
continue;
}
} while ((poll_cb != NULL) && (poll_cb->state == MM_CAMERA_POLL_TASK_STATE_POLL));
return NULL;
}
再来分析调用 addStream(…) 添加流。
添加 stream 到 channel。首先创建 QCamera3Stream 对象，然后调用其 init 方法初始化。
device/moto/shamu/camera/QCamera2/HAL3/QCamera3Channel.cpp
int32_t QCamera3Channel::addStream(cam_stream_type_t streamType,
cam_format_t streamFormat,
cam_dimension_t streamDim,
uint8_t minStreamBufNum,
uint32_t postprocessMask,
cam_is_type_t isType)
{
int32_t rc = NO_ERROR;
if (m_numStreams >= 1) {
ALOGE("%s: Only one stream per channel supported in v3 Hal", __func__);
return BAD_VALUE;
}
if (m_numStreams >= MAX_STREAM_NUM_IN_BUNDLE) {
ALOGE("%s: stream number (%d) exceeds max limit (%d)",
__func__, m_numStreams, MAX_STREAM_NUM_IN_BUNDLE);
return BAD_VALUE;
}
QCamera3Stream *pStream = new QCamera3Stream(m_camHandle,
m_handle,
m_camOps,
mPaddingInfo,
this);
if (pStream == NULL) {
ALOGE("%s: No mem for Stream", __func__);
return NO_MEMORY;
}
rc = pStream->init(streamType, streamFormat, streamDim, NULL, minStreamBufNum,
postprocessMask, isType, streamCbRoutine, this);
if (rc == 0) {
mStreams[m_numStreams] = pStream;
m_numStreams++;
} else {
delete pStream;
}
return rc;
}
- 添加流，调用 mm_camera_intf_add_stream 函数
- 分配和映射流信息内存，调用 mm_camera_intf_map_stream_buf 函数
- 配置流，调用 mm_camera_intf_config_stream 函数
device/moto/shamu/camera/QCamera2/HAL3/QCamera3Stream.cpp
int32_t QCamera3Stream::init(cam_stream_type_t streamType,
cam_format_t streamFormat,
cam_dimension_t streamDim,
cam_stream_reproc_config_t* reprocess_config,
uint8_t minNumBuffers,
uint32_t postprocess_mask,
cam_is_type_t is_type,
hal3_stream_cb_routine stream_cb,
void *userdata)
{
int32_t rc = OK;
mm_camera_stream_config_t stream_config;
mHandle = mCamOps->add_stream(mCamHandle, mChannelHandle);
if (!mHandle) {
ALOGE("add_stream failed");
rc = UNKNOWN_ERROR;
goto done;
}
// allocate and map stream info memory
mStreamInfoBuf = new QCamera3HeapMemory();
if (mStreamInfoBuf == NULL) {
ALOGE("%s: no memory for stream info buf obj", __func__);
rc = -ENOMEM;
goto err1;
}
rc = mStreamInfoBuf->allocate(1, sizeof(cam_stream_info_t), false);
if (rc < 0) {
ALOGE("%s: no memory for stream info", __func__);
rc = -ENOMEM;
goto err2;
}
mStreamInfo =
reinterpret_cast<cam_stream_info_t *>(mStreamInfoBuf->getPtr(0));
memset(mStreamInfo, 0, sizeof(cam_stream_info_t));
mStreamInfo->stream_type = streamType;
mStreamInfo->fmt = streamFormat;
mStreamInfo->dim = streamDim;
mStreamInfo->num_bufs = minNumBuffers;
mStreamInfo->pp_config.feature_mask = postprocess_mask;
ALOGV("%s: stream_type is %d, feature_mask is %d",
__func__, mStreamInfo->stream_type, mStreamInfo->pp_config.feature_mask);
mStreamInfo->is_type = is_type;
rc = mCamOps->map_stream_buf(mCamHandle,
mChannelHandle, mHandle, CAM_MAPPING_BUF_TYPE_STREAM_INFO,
0, -1, mStreamInfoBuf->getFd(0), mStreamInfoBuf->getSize(0));
if (rc < 0) {
ALOGE("Failed to map stream info buffer");
goto err3;
}
mNumBufs = minNumBuffers;
if (reprocess_config != NULL) {
mStreamInfo->reprocess_config = *reprocess_config;
mStreamInfo->streaming_mode = CAM_STREAMING_MODE_BURST;
//mStreamInfo->num_of_burst = reprocess_config->offline.num_of_bufs;
mStreamInfo->num_of_burst = 1;
ALOGI("%s: num_of_burst is %d", __func__, mStreamInfo->num_of_burst);
} else {
mStreamInfo->streaming_mode = CAM_STREAMING_MODE_CONTINUOUS;
}
// Configure the stream
stream_config.stream_info = mStreamInfo;
stream_config.mem_vtbl = mMemVtbl;
stream_config.padding_info = mPaddingInfo;
stream_config.userdata = this;
stream_config.stream_cb = dataNotifyCB;
rc = mCamOps->config_stream(mCamHandle,
mChannelHandle, mHandle, &stream_config);
if (rc < 0) {
ALOGE("Failed to config stream, rc = %d", rc);
goto err4;
}
mDataCB = stream_cb;
mUserData = userdata;
return 0;
err4:
mCamOps->unmap_stream_buf(mCamHandle,
mChannelHandle, mHandle, CAM_MAPPING_BUF_TYPE_STREAM_INFO, 0, -1);
err3:
mStreamInfoBuf->deallocate();
err2:
delete mStreamInfoBuf;
mStreamInfoBuf = NULL;
mStreamInfo = NULL;
err1:
mCamOps->delete_stream(mCamHandle, mChannelHandle, mHandle);
mHandle = 0;
mNumBufs = 0;
done:
return rc;
}
- 通过相机句柄（camera_handle）查到 mm_camera_obj_t 对象；
- 调用 mm_camera_add_stream(…) 添加流到 channel。
device/moto/shamu/camera/QCamera2/stack/mm-camera-interface/src/mm_camera_interface.c
static uint32_t mm_camera_intf_add_stream(uint32_t camera_handle,
uint32_t ch_id)
{
uint32_t stream_id = 0;
mm_camera_obj_t * my_obj = NULL;
CDBG("%s : E handle = %d ch_id = %d",
__func__, camera_handle, ch_id);
pthread_mutex_lock(&g_intf_lock);
my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
if(my_obj) {
pthread_mutex_lock(&my_obj->cam_lock);
pthread_mutex_unlock(&g_intf_lock);
stream_id = mm_camera_add_stream(my_obj, ch_id);
} else {
pthread_mutex_unlock(&g_intf_lock);
}
CDBG("%s :X stream_id = %d", __func__, stream_id);
return stream_id;
}
- 通过 mm_camera_obj_t 对象和 channel id 查到 mm_channel_t 对象；
- 调用 mm_channel_fsm_fn 函数进一步添加流到 channel。
device/moto/shamu/camera/QCamera2/stack/mm-camera-interface/src/mm_camera.c
uint32_t mm_camera_add_stream(mm_camera_obj_t *my_obj,
uint32_t ch_id)
{
uint32_t s_hdl = 0;
mm_channel_t * ch_obj =
mm_camera_util_get_channel_by_handler(my_obj, ch_id);
if (NULL != ch_obj) {
pthread_mutex_lock(&ch_obj->ch_lock);
pthread_mutex_unlock(&my_obj->cam_lock);
mm_channel_fsm_fn(ch_obj,
MM_CHANNEL_EVT_ADD_STREAM,
NULL,
(void*)&s_hdl);
} else {
pthread_mutex_unlock(&my_obj->cam_lock);
}
return s_hdl;
}
通道有限状态机入口函数。根据通道状态的不同，传入的事件将得到不同的处理。回到 mm_channel_init 方法，不难知道此处 mm_channel_t state 字段为 MM_CHANNEL_STATE_STOPPED。
device/moto/shamu/camera/QCamera2/stack/mm-camera-interface/src/mm_camera_channel.c
int32_t mm_channel_fsm_fn(mm_channel_t *my_obj,
mm_channel_evt_type_t evt,
void * in_val,
void * out_val)
{
int32_t rc = -1;
CDBG("%s : E state = %d", __func__, my_obj->state);
switch (my_obj->state) {
case MM_CHANNEL_STATE_NOTUSED:
rc = mm_channel_fsm_fn_notused(my_obj, evt, in_val, out_val);
break;
case MM_CHANNEL_STATE_STOPPED:
rc = mm_channel_fsm_fn_stopped(my_obj, evt, in_val, out_val);
break;
case MM_CHANNEL_STATE_ACTIVE:
rc = mm_channel_fsm_fn_active(my_obj, evt, in_val, out_val);
break;
case MM_CHANNEL_STATE_PAUSED:
rc = mm_channel_fsm_fn_paused(my_obj, evt, in_val, out_val);
break;
default:
CDBG("%s: Not a valid state (%d)", __func__, my_obj->state);
break;
}
/* unlock ch_lock */
pthread_mutex_unlock(&my_obj->ch_lock);
CDBG("%s : X rc = %d", __func__, rc);
return rc;
}
channel 有限状态机功能来处理处于 STOPPED 状态的事件。此处 mm_channel_evt_type_t 为 MM_CHANNEL_EVT_ADD_STREAM。
device/moto/shamu/camera/QCamera2/stack/mm-camera-interface/src/mm_camera_channel.c
int32_t mm_channel_fsm_fn_stopped(mm_channel_t *my_obj,
mm_channel_evt_type_t evt,
void * in_val,
void * out_val)
{
int32_t rc = 0;
CDBG("%s : E evt = %d", __func__, evt);
switch (evt) {
case MM_CHANNEL_EVT_ADD_STREAM:
{
uint32_t s_hdl = 0;
s_hdl = mm_channel_add_stream(my_obj);
*((uint32_t*)out_val) = s_hdl;
rc = 0;
}
break;
......
default:
CDBG_ERROR("%s: invalid state (%d) for evt (%d)",
__func__, my_obj->state, evt);
break;
}
CDBG("%s : E rc = %d", __func__, rc);
return rc;
}
- 检查可用的流对象
- 初始化流对象
- 请求流
device/moto/shamu/camera/QCamera2/stack/mm-camera-interface/src/mm_camera_channel.c
uint32_t mm_channel_add_stream(mm_channel_t *my_obj)
{
int32_t rc = 0;
uint8_t idx = 0;
uint32_t s_hdl = 0;
mm_stream_t *stream_obj = NULL;
CDBG("%s : E", __func__);
/* 检查可用的流对象 */
for (idx = 0; idx < MAX_STREAM_NUM_IN_BUNDLE; idx++) {
if (MM_STREAM_STATE_NOTUSED == my_obj->streams[idx].state) {
stream_obj = &my_obj->streams[idx];
break;
}
}
if (NULL == stream_obj) {
CDBG_ERROR("%s: streams reach max, no more stream allowed to add", __func__);
return s_hdl;
}
/* 初始化流对象*/
memset(stream_obj, 0, sizeof(mm_stream_t));
stream_obj->fd = -1;
stream_obj->my_hdl = mm_camera_util_generate_handler(idx);
stream_obj->ch_obj = my_obj;
pthread_mutex_init(&stream_obj->buf_lock, NULL);
pthread_mutex_init(&stream_obj->cb_lock, NULL);
stream_obj->state = MM_STREAM_STATE_INITED;
/* 请求流 */
rc = mm_stream_fsm_fn(stream_obj, MM_STREAM_EVT_ACQUIRE, NULL, NULL);
if (0 == rc) {
s_hdl = stream_obj->my_hdl;
} else {
/* error during acquire, de-init */
pthread_mutex_destroy(&stream_obj->buf_lock);
pthread_mutex_destroy(&stream_obj->cb_lock);
memset(stream_obj, 0, sizeof(mm_stream_t));
}
CDBG("%s : stream handle = %d", __func__, s_hdl);
return s_hdl;
}
流有限状态机入口函数。 根据流状态，传入事件将以不同方式处理。
device/moto/shamu/camera/QCamera2/stack/mm-camera-interface/src/mm_camera_stream.c
int32_t mm_stream_fsm_fn(mm_stream_t *my_obj,
mm_stream_evt_type_t evt,
void * in_val,
void * out_val)
{
int32_t rc = -1;
CDBG("%s: E, my_handle = 0x%x, fd = %d, state = %d",
__func__, my_obj->my_hdl, my_obj->fd, my_obj->state);
switch (my_obj->state) {
......
case MM_STREAM_STATE_INITED:
rc = mm_stream_fsm_inited(my_obj, evt, in_val, out_val);
break;
......
default:
CDBG("%s: Not a valid state (%d)", __func__, my_obj->state);
break;
}
CDBG("%s : X rc =%d",__func__,rc);
return rc;
}
流有限状态机函数来处理 INITED 状态的事件。此处传入的 mm_stream_evt_type_t 为 MM_STREAM_EVT_ACQUIRE。
- 打开设备节点；
- 通过 v4l2 ioctl 将流扩展模式设置为服务端；
- 将 mm_stream_t state 字段置为 MM_STREAM_STATE_ACQUIRED。
device/moto/shamu/camera/QCamera2/stack/mm-camera-interface/src/mm_camera_stream.c
int32_t mm_stream_fsm_inited(mm_stream_t *my_obj,
mm_stream_evt_type_t evt,
void * in_val,
void * out_val)
{
int32_t rc = 0;
char dev_name[MM_CAMERA_DEV_NAME_LEN];
CDBG("%s: E, my_handle = 0x%x, fd = %d, state = %d",
__func__, my_obj->my_hdl, my_obj->fd, my_obj->state);
switch(evt) {
case MM_STREAM_EVT_ACQUIRE:
if ((NULL == my_obj->ch_obj) || (NULL == my_obj->ch_obj->cam_obj)) {
CDBG_ERROR("%s: NULL channel or camera obj\n", __func__);
rc = -1;
break;
}
if (NULL == my_obj) {
CDBG_ERROR("%s: NULL camera object\n", __func__);
rc = -1;
break;
}
snprintf(dev_name, sizeof(dev_name), "/dev/%s",
mm_camera_util_get_dev_name(my_obj->ch_obj->cam_obj->my_hdl));
my_obj->fd = open(dev_name, O_RDWR | O_NONBLOCK);
if (my_obj->fd < 0) {
CDBG_ERROR("%s: open dev returned %d\n", __func__, my_obj->fd);
rc = -1;
break;
}
CDBG("%s: open dev fd = %d\n", __func__, my_obj->fd);
rc = mm_stream_set_ext_mode(my_obj);
if (0 == rc) {
my_obj->state = MM_STREAM_STATE_ACQUIRED;
} else {
/* failed setting ext_mode
* close fd */
close(my_obj->fd);
my_obj->fd = -1;
break;
}
break;
default:
CDBG_ERROR("%s: invalid state (%d) for evt (%d), in(%p), out(%p)",
__func__, my_obj->state, evt, in_val, out_val);
break;
}
return rc;
}
再来分析映射流信息内存，调用 mm_camera_intf_map_stream_buf 函数。通过域套接字将流缓冲区映射到服务端。
- 根据 camera_handle 相机句柄查找到 mm_camera_obj_t 对象
- 调用 mm_camera_map_stream_buf 函数进一步处理
device/moto/shamu/camera/QCamera2/stack/mm-camera-interface/src/mm_camera_interface.c
static int32_t mm_camera_intf_map_stream_buf(uint32_t camera_handle,
uint32_t ch_id,
uint32_t stream_id,
uint8_t buf_type,
uint32_t buf_idx,
int32_t plane_idx,
int fd,
uint32_t size)
{
int32_t rc = -1;
mm_camera_obj_t * my_obj = NULL;
pthread_mutex_lock(&g_intf_lock);
my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
CDBG("%s :E camera_handle = %d, ch_id = %d, s_id = %d, buf_idx = %d, plane_idx = %d",
__func__, camera_handle, ch_id, stream_id, buf_idx, plane_idx);
if(my_obj) {
pthread_mutex_lock(&my_obj->cam_lock);
pthread_mutex_unlock(&g_intf_lock);
rc = mm_camera_map_stream_buf(my_obj, ch_id, stream_id,
buf_type, buf_idx, plane_idx,
fd, size);
}else{
pthread_mutex_unlock(&g_intf_lock);
}
CDBG("%s :X rc = %d", __func__, rc);
return rc;
}
- 通过 mm_camera_obj_t 对象和 channel id 查找到 mm_channel_t 对象
- 调用 mm_channel_fsm_fn 函数进一步处理
最后会把 packet 发送到服务端。
device/moto/shamu/camera/QCamera2/stack/mm-camera-interface/src/mm_camera.c
int32_t mm_camera_map_stream_buf(mm_camera_obj_t *my_obj,
uint32_t ch_id,
uint32_t stream_id,
uint8_t buf_type,
uint32_t buf_idx,
int32_t plane_idx,
int fd,
uint32_t size)
{
int32_t rc = -1;
mm_evt_paylod_map_stream_buf_t payload;
mm_channel_t * ch_obj =
mm_camera_util_get_channel_by_handler(my_obj, ch_id);
if (NULL != ch_obj) {
pthread_mutex_lock(&ch_obj->ch_lock);
pthread_mutex_unlock(&my_obj->cam_lock);
memset(&payload, 0, sizeof(payload));
payload.stream_id = stream_id;
payload.buf_type = buf_type;
payload.buf_idx = buf_idx;
payload.plane_idx = plane_idx;
payload.fd = fd;
payload.size = size;
rc = mm_channel_fsm_fn(ch_obj,
MM_CHANNEL_EVT_MAP_STREAM_BUF,
(void*)&payload,
NULL);
} else {
pthread_mutex_unlock(&my_obj->cam_lock);
}
return rc;
}
现在来分析配置流，调用 mm_camera_intf_config_stream 函数。
- 查找到 mm_camera_obj_t 对象；
- 调用 mm_camera_config_stream 进一步配置流；
device/moto/shamu/camera/QCamera2/stack/mm-camera-interface/src/mm_camera_interface.c
static int32_t mm_camera_intf_config_stream(uint32_t camera_handle,
uint32_t ch_id,
uint32_t stream_id,
mm_camera_stream_config_t *config)
{
int32_t rc = -1;
mm_camera_obj_t * my_obj = NULL;
CDBG("%s :E handle = %d, ch_id = %d,stream_id = %d",
__func__, camera_handle, ch_id, stream_id);
pthread_mutex_lock(&g_intf_lock);
my_obj = mm_camera_util_get_camera_by_handler(camera_handle);
CDBG("%s :mm_camera_intf_config_stream stream_id = %d",__func__,stream_id);
if(my_obj) {
pthread_mutex_lock(&my_obj->cam_lock);
pthread_mutex_unlock(&g_intf_lock);
rc = mm_camera_config_stream(my_obj, ch_id, stream_id, config);
} else {
pthread_mutex_unlock(&g_intf_lock);
}
CDBG("%s :X rc = %d", __func__, rc);
return rc;
}
- 查找到 mm_channel_t 对象
- 调用 mm_channel_fsm_fn 函数进一步处理
device/moto/shamu/camera/QCamera2/stack/mm-camera-interface/src/mm_camera.c
int32_t mm_camera_config_stream(mm_camera_obj_t *my_obj,
uint32_t ch_id,
uint32_t stream_id,
mm_camera_stream_config_t *config)
{
int32_t rc = -1;
mm_channel_t * ch_obj =
mm_camera_util_get_channel_by_handler(my_obj, ch_id);
mm_evt_paylod_config_stream_t payload;
if (NULL != ch_obj) {
pthread_mutex_lock(&ch_obj->ch_lock);
pthread_mutex_unlock(&my_obj->cam_lock);
memset(&payload, 0, sizeof(mm_evt_paylod_config_stream_t));
payload.stream_id = stream_id;
payload.config = config;
rc = mm_channel_fsm_fn(ch_obj,
MM_CHANNEL_EVT_CONFIG_STREAM,
(void*)&payload,
NULL);
} else {
pthread_mutex_unlock(&my_obj->cam_lock);
}
return rc;
}
mm_channel_t state 字段为 MM_CHANNEL_STATE_STOPPED。
device/moto/shamu/camera/QCamera2/stack/mm-camera-interface/src/mm_camera_channel.c
int32_t mm_channel_fsm_fn(mm_channel_t *my_obj,
mm_channel_evt_type_t evt,
void * in_val,
void * out_val)
{
int32_t rc = -1;
CDBG("%s : E state = %d", __func__, my_obj->state);
switch (my_obj->state) {
......
case MM_CHANNEL_STATE_STOPPED:
rc = mm_channel_fsm_fn_stopped(my_obj, evt, in_val, out_val);
break;
......
}
/* unlock ch_lock */
pthread_mutex_unlock(&my_obj->ch_lock);
CDBG("%s : X rc = %d", __func__, rc);
return rc;
}
此处调用 mm_channel_config_stream 继续处理。
device/moto/shamu/camera/QCamera2/stack/mm-camera-interface/src/mm_camera_channel.c
int32_t mm_channel_fsm_fn_stopped(mm_channel_t *my_obj,
mm_channel_evt_type_t evt,
void * in_val,
void * out_val)
{
int32_t rc = 0;
CDBG("%s : E evt = %d", __func__, evt);
switch (evt) {
......
case MM_CHANNEL_EVT_CONFIG_STREAM:
{
mm_evt_paylod_config_stream_t *payload =
(mm_evt_paylod_config_stream_t *)in_val;
rc = mm_channel_config_stream(my_obj,
payload->stream_id,
payload->config);
}
break;
......
default:
CDBG_ERROR("%s: invalid state (%d) for evt (%d)",
__func__, my_obj->state, evt);
break;
}
CDBG("%s : E rc = %d", __func__, rc);
return rc;
}
- 查找到 mm_stream_t 对象；
- 调用 mm_stream_fsm_fn 函数设置流格式。
device/moto/shamu/camera/QCamera2/stack/mm-camera-interface/src/mm_camera_channel.c
int32_t mm_channel_config_stream(mm_channel_t *my_obj,
uint32_t stream_id,
mm_camera_stream_config_t *config)
{
int rc = -1;
mm_stream_t * stream_obj = NULL;
CDBG("%s : E stream ID = %d", __func__, stream_id);
stream_obj = mm_channel_util_get_stream_by_handler(my_obj, stream_id);
if (NULL == stream_obj) {
CDBG_ERROR("%s :Invalid Stream Object for stream_id = %d", __func__, stream_id);
return rc;
}
/* set stream fmt */
rc = mm_stream_fsm_fn(stream_obj,
MM_STREAM_EVT_SET_FMT,
(void *)config,
NULL);
CDBG("%s : X rc = %d",__func__,rc);
return rc;
}
此处 mm_stream_t state 在 mm_stream_fsm_inited 函数中被赋值为 MM_STREAM_STATE_ACQUIRED。
device/moto/shamu/camera/QCamera2/stack/mm-camera-interface/src/mm_camera_stream.c
int32_t mm_stream_fsm_fn(mm_stream_t *my_obj,
mm_stream_evt_type_t evt,
void * in_val,
void * out_val)
{
int32_t rc = -1;
CDBG("%s: E, my_handle = 0x%x, fd = %d, state = %d",
__func__, my_obj->my_hdl, my_obj->fd, my_obj->state);
switch (my_obj->state) {
......
case MM_STREAM_STATE_ACQUIRED:
rc = mm_stream_fsm_acquired(my_obj, evt, in_val, out_val);
break;
......
default:
CDBG("%s: Not a valid state (%d)", __func__, my_obj->state);
break;
}
CDBG("%s : X rc =%d",__func__,rc);
return rc;
}
流有限状态机功能，以处理 ACQUIRED 状态下的事件。
此处 mm_stream_evt_type_t 为 MM_STREAM_EVT_SET_FMT。
device/moto/shamu/camera/QCamera2/stack/mm-camera-interface/src/mm_camera_stream.c
int32_t mm_stream_fsm_acquired(mm_stream_t *my_obj,
mm_stream_evt_type_t evt,
void * in_val,
void * out_val)
{
int32_t rc = 0;
CDBG("%s: E, my_handle = 0x%x, fd = %d, state = %d",
__func__, my_obj->my_hdl, my_obj->fd, my_obj->state);
switch(evt) {
case MM_STREAM_EVT_SET_FMT:
{
mm_camera_stream_config_t *config =
(mm_camera_stream_config_t *)in_val;
rc = mm_stream_config(my_obj, config);
/* change state to configed */
my_obj->state = MM_STREAM_STATE_CFG;
break;
}
......
default:
CDBG_ERROR("%s: invalid state (%d) for evt (%d), in(%p), out(%p)",
__func__, my_obj->state, evt, in_val, out_val);
}
CDBG("%s :X rc = %d", __func__, rc);
return rc;
}
调用 mm_stream_sync_info 和 mm_stream_set_fmt 对服务端进行实际流配置。
device/moto/shamu/camera/QCamera2/stack/mm-camera-interface/src/mm_camera_stream.c
int32_t mm_stream_config(mm_stream_t *my_obj,
mm_camera_stream_config_t *config)
{
int32_t rc = 0;
CDBG("%s: E, my_handle = 0x%x, fd = %d, state = %d",
__func__, my_obj->my_hdl, my_obj->fd, my_obj->state);
my_obj->stream_info = config->stream_info;
my_obj->buf_num = config->stream_info->num_bufs;
my_obj->mem_vtbl = config->mem_vtbl;
my_obj->padding_info = config->padding_info;
/* cd through intf always palced at idx 0 of buf_cb */
my_obj->buf_cb[0].cb = config->stream_cb;
my_obj->buf_cb[0].user_data = config->userdata;
my_obj->buf_cb[0].cb_count = -1; /* infinite by default */
rc = mm_stream_sync_info(my_obj);
if (rc == 0) {
rc = mm_stream_set_fmt(my_obj);
}
return rc;
}
