简介
- 在前面的几篇笔记中,我已经把
Camera
控制流的部分梳理得比较清楚了。在 Camera
流程中,还有一个重要的部分,即数据流。 Camera API 1
中,数据流主要是通过函数回调的方式,依照从下往上的方向,逐层 return
到 Applications 中。- 由于数据流的部分相对来说比较简单,所以我就将其与
Camera
的控制流结合起来,从 takePicture()
方法切入,追踪一个比较完整的 Camera
流程,这个系列的笔记到这篇也就可以结束了。
takePicture() flow
1. Open 流程
Camera Open
的流程,在之前的一篇笔记中已经比较详细地描述了。- 在这里,再关注一下这个流程中,
HAL
层的部分。
1.1 CameraHardwareInterface.h
- 位置:
frameworks/av/services/camera/libcameraservice/device1/CameraHardwareInterface.h
setCallback()
:
- 设置
notify
回调,这用来通知数据已经更新。 - 设置
data
回调以及 dataTimestamp
回调,对应的是函数指针 mDataCb
与 mDataCvTimestamp
。 - 注意到,设置
mDevice->ops
对应回调函数时,传入的不是之前设置的函数指针,而是 __data_cb
这样的函数。在该文件中,实现了 __data_cb
,将回调函数做了一层封装。
void setCallbacks(notify_callback notify_cb,
data_callback data_cb,
data_callback_timestamp data_cb_timestamp,
void* user)
{
mNotifyCb = notify_cb;
mDataCb = data_cb;
mDataCbTimestamp = data_cb_timestamp;
mCbUser = user;
ALOGV("%s(%s)", __FUNCTION__, mName.string());
if (mDevice->ops->set_callbacks) {
mDevice->ops->set_callbacks(mDevice,
__notify_cb,
__data_cb,
__data_cb_timestamp,
__get_memory,
this);
}
}
__data_cb()
:
- 对原
callback
函数简单封装,附加了一个防止数组越界判断。
static void __data_cb(int32_t msg_type,
const camera_memory_t *data, unsigned int index,
camera_frame_metadata_t *metadata,
void *user)
{
ALOGV("%s", __FUNCTION__);
CameraHardwareInterface *__this =
static_cast<CameraHardwareInterface *>(user);
sp<CameraHeapMemory> mem(static_cast<CameraHeapMemory *>(data->handle));
if (index >= mem->mNumBufs) {
ALOGE("%s: invalid buffer index %d, max allowed is %d", __FUNCTION__,
index, mem->mNumBufs);
return;
}
__this->mDataCb(msg_type, mem->mBuffers[index], metadata, __this->mCbUser);
}
2. 控制流
2.1 Framework
2.1.1 Camera.java
- 位置:
frameworks/base/core/java/android/hardware/Camera.java
takePicture()
:
- 设置快门回调。
- 设置各种类型的图片数据回调。
- 调用
JNI takePicture
方法。 - 注意,传入的参数
msgType
是根据相应 CallBack
是否存在而确定的,每种 Callback
应该对应一个二进制中的数位(如 1,10,100 中 1 的位置),于是这里采用 |=
操作给它赋值。
public final void takePicture(ShutterCallback shutter, PictureCallback raw,
PictureCallback postview, PictureCallback jpeg) {
mShutterCallback = shutter;
mRawImageCallback = raw;
mPostviewCallback = postview;
mJpegCallback = jpeg;
int msgType = 0;
if (mShutterCallback != null) {
msgType |= CAMERA_MSG_SHUTTER;
}
if (mRawImageCallback != null) {
msgType |= CAMERA_MSG_RAW_IMAGE;
}
if (mPostviewCallback != null) {
msgType |= CAMERA_MSG_POSTVIEW_FRAME;
}
if (mJpegCallback != null) {
msgType |= CAMERA_MSG_COMPRESSED_IMAGE;
}
native_takePicture(msgType);
mFaceDetectionRunning = false;
}
2.2 Android Runtime
2.2.1 android_hardware_Camera.cpp
- 位置:
frameworks/base/core/jni/android_hardware_Camera.cpp
takePicture()
:- 获取已经打开的
camera
实例,调用其 takePicture()
接口。 - 注意,在这个函数中,对于
RAW_IMAGE
有一些附加操作:
- 如果设置了
RAW
的 callback
,则要检查上下文中,是否能找到对应 Buffer
。 - 若无法找到
Buffer
,则将 CAMERA_MSG_RAW_IMAGE
的信息去掉,换成 CAMERA_MSG_RAW_IMAGE_NOTIFY
。 - 替换后,就只会获得
notification
的消息,而没有对应的图像数据。
static void android_hardware_Camera_takePicture(JNIEnv *env, jobject thiz, jint msgType)
{
ALOGV("takePicture");
JNICameraContext* context;
sp<Camera> camera = get_native_camera(env, thiz, &context);
if (camera == 0) return;
if (msgType & CAMERA_MSG_RAW_IMAGE) {
ALOGV("Enable raw image callback buffer");
if (!context->isRawImageCallbackBufferAvailable()) {
ALOGV("Enable raw image notification, since no callback buffer exists");
msgType &= ~CAMERA_MSG_RAW_IMAGE;
msgType |= CAMERA_MSG_RAW_IMAGE_NOTIFY;
}
}
if (camera->takePicture(msgType) != NO_ERROR) {
jniThrowRuntimeException(env, "takePicture failed");
return;
}
}
2.3 C/C++ Libraries
2.3.1 Camera.cpp
- 位置:
frameworks/av/camera/Camera.cpp
takePicture()
:
- 获取一个
ICamera
,调用其 takePicture
接口。 - 这里直接用
return
的方式调用,比较简单。
status_t Camera::takePicture(int msgType)
{
ALOGV("takePicture: 0x%x", msgType);
sp <::android::hardware::ICamera> c = mCamera;
if (c == 0) return NO_INIT;
return c->takePicture(msgType);
}
2.3.2 ICamera.cpp
- 位置:
frameworks/av/camera/ICamera.cpp
takePicture()
:
- 利用
Binder
机制发送相应指令到服务端。 - 实际调用到的是
CameraClient::takePicture()
函数。
status_t takePicture(int msgType)
{
ALOGV("takePicture: 0x%x", msgType);
Parcel data, reply;
data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
data.writeInt32(msgType);
remote()->transact(TAKE_PICTURE, data, &reply);
status_t ret = reply.readInt32();
return ret;
}
2.3.3 CameraClient.cpp
- 位置:
frameworks/av/services/camera/libcameraservice/api1/CameraClient.cpp
takePicture()
:
- 注意,
CAMERA_MSG_RAW_IMAGE
指令与 CAMERA_MSG_RAW_IMAGE_NOTIFY
指令不能同时有效,需要进行对应的检查。 - 对传入的指令过滤,只留下与
takePicture()
操作相关的。 - 调用
CameraHardwareInterface
中的 takePicture()
接口。
status_t CameraClient::takePicture(int msgType) {
LOG1("takePicture (pid %d): 0x%x", getCallingPid(), msgType);
Mutex::Autolock lock(mLock);
status_t result = checkPidAndHardware();
if (result != NO_ERROR) return result;
if ((msgType & CAMERA_MSG_RAW_IMAGE) &&
(msgType & CAMERA_MSG_RAW_IMAGE_NOTIFY)) {
ALOGE("CAMERA_MSG_RAW_IMAGE and CAMERA_MSG_RAW_IMAGE_NOTIFY"
" cannot be both enabled");
return BAD_VALUE;
}
int picMsgType = msgType
& (CAMERA_MSG_SHUTTER |
CAMERA_MSG_POSTVIEW_FRAME |
CAMERA_MSG_RAW_IMAGE |
CAMERA_MSG_RAW_IMAGE_NOTIFY |
CAMERA_MSG_COMPRESSED_IMAGE);
enableMsgType(picMsgType);
return mHardware->takePicture();
}
2.4 HAL
2.4.1 CameraHardwareInterface.h
- 位置:
frameworks/av/services/camera/libcameraservice/device1/CameraHardwareInterface.h
takePicture()
:
- 通过
mDevice
中设置的函数指针,调用 HAL
层中具体平台对应的 takePicture
操作的实现逻辑。 - 接下来就是与具体的平台相关的流程了,这部分内容对我并非主要,而且在上一篇笔记中已经有比较深入的探索,所以在这里就不继续向下挖掘了。
- 控制流程到了
HAL
层后,再向 Linux Drivers
发送控制指令,从而使具体的 Camera
设备执行指令,并获取数据。
status_t takePicture()
{
ALOGV("%s(%s)", __FUNCTION__, mName.string());
if (mDevice->ops->take_picture)
return mDevice->ops->take_picture(mDevice);
return INVALID_OPERATION;
}
3. 数据流
- 由于数据流是通过
callback
函数实现的,所以探究其流程的时候我是从底层向上层进行分析的。
3.1 HAL
3.1.1 CameraHardwareInterface.h
- 位置:
frameworks/av/services/camera/libcameraservice/device1/CameraHardwareInterface.h
- 这里我们只选择
dataCallback
相关流程进行分析。 __data_cb()
:
- 该回调函数是在同文件中实现的
setCallbacks()
函数中设置的。 Camera
设备获得数据后,就会往上传输,在 HAL
层中会调用到这个回调函数。- 通过函数指针
mDataCb
调用从上一层传入的回调,从而将数据上传。 - 这个
mDataCb
指针对应的,是 CameraClient
类中实现的 dataCallback()
。
static void __data_cb(int32_t msg_type,
const camera_memory_t *data, unsigned int index,
camera_frame_metadata_t *metadata,
void *user)
{
ALOGV("%s", __FUNCTION__);
CameraHardwareInterface *__this =
static_cast<CameraHardwareInterface *>(user);
sp<CameraHeapMemory> mem(static_cast<CameraHeapMemory *>(data->handle));
if (index >= mem->mNumBufs) {
ALOGE("%s: invalid buffer index %d, max allowed is %d", __FUNCTION__,
index, mem->mNumBufs);
return;
}
__this->mDataCb(msg_type, mem->mBuffers[index], metadata, __this->mCbUser);
}
3.2 C/C++ Libraries
3.2.1 CameraClient.cpp
- 位置:
frameworks/av/services/camera/libcameraservice/api1/CameraClient.cpp
dataCallback()
:
- 这个回调在该文件实现的
initialize()
函数中设置到 CameraHardwareInterface
中。 - 启动这个回调后,就从
Cookie
中获取已连接的客户端。 - 根据
msgType
,启动对应的 handle
操作。 - 选择其中一个分支的
handle
函数来看。
void CameraClient::dataCallback(int32_t msgType,
const sp<IMemory>& dataPtr, camera_frame_metadata_t *metadata, void* user) {
LOG2("dataCallback(%d)", msgType);
sp<CameraClient> client = static_cast<CameraClient*>(getClientFromCookie(user).get());
if (client.get() == nullptr) return;
if (!client->lockIfMessageWanted(msgType)) return;
if (dataPtr == 0 && metadata == NULL) {
ALOGE("Null data returned in data callback");
client->handleGenericNotify(CAMERA_MSG_ERROR, UNKNOWN_ERROR, 0);
return;
}
switch (msgType & ~CAMERA_MSG_PREVIEW_METADATA) {
case CAMERA_MSG_PREVIEW_FRAME:
client->handlePreviewData(msgType, dataPtr, metadata);
break;
case CAMERA_MSG_POSTVIEW_FRAME:
client->handlePostview(dataPtr);
break;
case CAMERA_MSG_RAW_IMAGE:
client->handleRawPicture(dataPtr);
break;
case CAMERA_MSG_COMPRESSED_IMAGE:
client->handleCompressedPicture(dataPtr);
break;
default:
client->handleGenericData(msgType, dataPtr, metadata);
break;
}
}
handleRawPicture()
:
- 在
open
流程中,connect()
函数调用时,mRemoteCallback
已经设置为一个客户端实例,其对应的是 ICameraClient
的强指针。 - 通过这个实例,这里基于
Binder
机制来启动客户端的 dataCallback
。 - 客户端的
dataCallback
是实现在 Camera
类中。
void CameraClient::handleRawPicture(const sp<IMemory>& mem) {
disableMsgType(CAMERA_MSG_RAW_IMAGE);
ssize_t offset;
size_t size;
sp<IMemoryHeap> heap = mem->getMemory(&offset, &size);
sp<hardware::ICameraClient> c = mRemoteCallback;
mLock.unlock();
if (c != 0) {
c->dataCallback(CAMERA_MSG_RAW_IMAGE, mem, NULL);
}
}
3.2.2 Camera.cpp
- 位置:
frameworks/av/camera/Camera.cpp
dataCallback()
:
- 调用
CameraListener
的 postData
接口,将数据继续向上传输。 postData
接口的实现是在 android_hardware_Camera.cpp
中。
void Camera::dataCallback(int32_t msgType, const sp<IMemory>& dataPtr,
camera_frame_metadata_t *metadata)
{
sp<CameraListener> listener;
{
Mutex::Autolock _l(mLock);
listener = mListener;
}
if (listener != NULL) {
listener->postData(msgType, dataPtr, metadata);
}
}
3.3 Android Runtime
3.3.1 android_hardware_Camera.cpp
- 位置:
frameworks/base/core/jni/android_hardware_Camera.cpp
postData()
:
- 是
JNICameraContext
类的成员函数,该类继承了 CameraListener
。 - 首先获取虚拟机指针。
- 然后过滤掉
CAMERA_MSG_PREVIEW_METADATA
信息。 - 进入分支处理。
- 对于数据传输路径,关键是在于
copyAndPost()
函数。
void JNICameraContext::postData(int32_t msgType, const sp<IMemory>& dataPtr,
camera_frame_metadata_t *metadata)
{
Mutex::Autolock _l(mLock);
JNIEnv *env = AndroidRuntime::getJNIEnv();
if (mCameraJObjectWeak == NULL) {
ALOGW("callback on dead camera object");
return;
}
int32_t dataMsgType = msgType & ~CAMERA_MSG_PREVIEW_METADATA;
switch (dataMsgType) {
case CAMERA_MSG_VIDEO_FRAME:
break;
case CAMERA_MSG_RAW_IMAGE:
ALOGV("rawCallback");
if (mRawImageCallbackBuffers.isEmpty()) {
env->CallStaticVoidMethod(mCameraJClass, fields.post_event,
mCameraJObjectWeak, dataMsgType, 0, 0, NULL);
} else {
copyAndPost(env, dataPtr, dataMsgType);
}
break;
case 0:
break;
default:
ALOGV("dataCallback(%d, %p)", dataMsgType, dataPtr.get());
copyAndPost(env, dataPtr, dataMsgType);
break;
}
if (metadata && (msgType & CAMERA_MSG_PREVIEW_METADATA)) {
postMetadata(env, CAMERA_MSG_PREVIEW_METADATA, metadata);
}
}
copyAndPost()
:
- 首先确认
Memory
中数据是否存在。 - 申请
Java
字节数组(jbyteArray
, jbyte*
),并将 Memory
数据赋予到其中。 - 重点是这个函数:
env->CallStaticVoidMethod(mCameraJClass, fields.post_event, mCameraJObjectWeak, msgType, 0, 0, obj);
- 它的功能是将图像传给
Java
端。 - 通过字段
post_event
,在 c++
中调用 Java
的方法,并传入对应的参数。 - 最终调用到
Java
端的 postEventFromNative()
方法。
void JNICameraContext::copyAndPost(JNIEnv* env, const sp<IMemory>& dataPtr, int msgType)
{
jbyteArray obj = NULL;
if (dataPtr != NULL) {
ssize_t offset;
size_t size;
sp<IMemoryHeap> heap = dataPtr->getMemory(&offset, &size);
ALOGV("copyAndPost: off=%zd, size=%zu", offset, size);
uint8_t *heapBase = (uint8_t*)heap->base();
if (heapBase != NULL) {
const jbyte* data = reinterpret_cast<const jbyte*>(heapBase + offset);
if (msgType == CAMERA_MSG_RAW_IMAGE) {
obj = getCallbackBuffer(env, &mRawImageCallbackBuffers, size);
} else if (msgType == CAMERA_MSG_PREVIEW_FRAME && mManualBufferMode) {
obj = getCallbackBuffer(env, &mCallbackBuffers, size);
if (mCallbackBuffers.isEmpty()) {
ALOGV("Out of buffers, clearing callback!");
mCamera->setPreviewCallbackFlags(CAMERA_FRAME_CALLBACK_FLAG_NOOP);
mManualCameraCallbackSet = false;
if (obj == NULL) {
return;
}
}
} else {
ALOGV("Allocating callback buffer");
obj = env->NewByteArray(size);
}
if (obj == NULL) {
ALOGE("Couldn't allocate byte array for JPEG data");
env->ExceptionClear();
} else {
env->SetByteArrayRegion(obj, 0, size, data);
}
} else {
ALOGE("image heap is NULL");
}
}
env->CallStaticVoidMethod(mCameraJClass, fields.post_event,
mCameraJObjectWeak, msgType, 0, 0, obj);
if (obj) {
env->DeleteLocalRef(obj);
}
}
3.4 Framework
3.4.1 Camera.java
- 位置:
frameworks/base/core/java/android/hardware/Camera.java
- 以下两个方法都是
EventHandler
的成员,这个类继承了 Handler
类。 postEventFromNative()
:
- 首先确定
Camera
是否已经实例化。 - 确认后,通过
Camera
的成员 mEventHandler
的 obtainMessage
方法将从 Native
环境中获得的数据封装成 Message
类的一个实例,然后调用 sendMessage()
方法将数据传出。
private static void postEventFromNative(Object camera_ref,
int what, int arg1, int arg2, Object obj)
{
Camera c = (Camera)((WeakReference)camera_ref).get();
if (c == null)
return;
if (c.mEventHandler != null) {
Message m = c.mEventHandler.obtainMessage(what, arg1, arg2, obj);
c.mEventHandler.sendMessage(m);
}
}
handleMessage()
:
sendMessage()
方法传出的数据会通过这个方法作出处理,从而发送到对应的回调类中。- 注意到几个不同的回调类(
mRawImageCallback
、mJpegCallback
等)中都有 onPictureTaken()
方法,通过调用这个方法,底层传输到此的数据最终发送到最上层的 Java 应用中,上层应用通过解析 Message
就可以得到拍到的图像,从而得以进行后续的操作。 - 我所分析的数据流的流程到此就可以结束了。
@Override
public void handleMessage(Message msg) {
switch(msg.what) {
case CAMERA_MSG_SHUTTER:
if (mShutterCallback != null) {
mShutterCallback.onShutter();
}
return;
case CAMERA_MSG_RAW_IMAGE:
if (mRawImageCallback != null) {
mRawImageCallback.onPictureTaken((byte[])msg.obj, mCamera);
}
return;
case CAMERA_MSG_COMPRESSED_IMAGE:
if (mJpegCallback != null) {
mJpegCallback.onPictureTaken((byte[])msg.obj, mCamera);
}
return;
case CAMERA_MSG_PREVIEW_FRAME:
PreviewCallback pCb = mPreviewCallback;
if (pCb != null) {
if (mOneShot) {
mPreviewCallback = null;
} else if (!mWithBuffer) {
setHasPreviewCallback(true, false);
}
pCb.onPreviewFrame((byte[])msg.obj, mCamera);
}
return;
case CAMERA_MSG_POSTVIEW_FRAME:
if (mPostviewCallback != null) {
mPostviewCallback.onPictureTaken((byte[])msg.obj, mCamera);
}
return;
case CAMERA_MSG_FOCUS:
AutoFocusCallback cb = null;
synchronized (mAutoFocusCallbackLock) {
cb = mAutoFocusCallback;
}
if (cb != null) {
boolean success = msg.arg1 == 0 ? false : true;
cb.onAutoFocus(success, mCamera);
}
return;
case CAMERA_MSG_ZOOM:
if (mZoomListener != null) {
mZoomListener.onZoomChange(msg.arg1, msg.arg2 != 0, mCamera);
}
return;
case CAMERA_MSG_PREVIEW_METADATA:
if (mFaceListener != null) {
mFaceListener.onFaceDetection((Face[])msg.obj, mCamera);
}
return;
case CAMERA_MSG_ERROR :
Log.e(TAG, "Error " + msg.arg1);
if (mErrorCallback != null) {
mErrorCallback.onError(msg.arg1, mCamera);
}
return;
case CAMERA_MSG_FOCUS_MOVE:
if (mAutoFocusMoveCallback != null) {
mAutoFocusMoveCallback.onAutoFocusMoving(msg.arg1 == 0 ? false : true, mCamera);
}
return;
default:
Log.e(TAG, "Unknown message type " + msg.what);
return;
}
}
流程简图
![流程简图](https://img-blog.csdn.net/20170908162555948?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvcXFfMTY3NzU4OTc=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
小结
- 在这篇笔记中,我们从
Camera.takePicture()
方法着手,联系之前学习的 Open
流程,将整个 Camera
流程简单地追踪了一遍。 - 不管是控制流还是数据流,都是要通过五大层次依次执行下一步的。控制流是将命令从顶层流向底层,而数据流则是将底层的数据流向顶层。
- 如果要自定义一个对数据进行处理的
C++
功能库,并将其加入相机中,我们可以通过对 HAL
层进行一些修改,将 RAW
图像流向我们的处理过程,再将处理后的 RAW
图像传回 HAL
层(需要在 HAL
层对 RAW
格式进行一些处理才能把图像上传),最后通过正常的回调流程把图像传到顶层应用中,就可以实现我们的自定义功能了。 - 至此,对于整个
Camera
的框架,及其运作方式,我们就已经有了比较清晰的了解了。
- 在
Android 5.0
版本后,Camera
推出了 Camera API 2
,它有着全新的流程(但总体架构是不会有大变化的)。接下来我会找空余的时间去学习学习这个新的东西,到时候再另开一系列的学习笔记吧。