IT小白

这个屌丝很懒，什么也没留下！

热门标签

Android摄像头相关源码分析: 设备驱动, HAL, Framework_android framework的拍照接口

作者：IT小白 | 2024-05-24 23:29:43

踩

android framework的拍照接口

1 序

本文分析的Android源代码来自Android-X86, 对应的版本是5.1, 因此可能与手机上的Android系统有点差异.

2 V4L2

V4L2是linux针对摄像头等视频设备的驱动, 应用程序只要对摄像头设备通过open获取文件描述符, 然后就能使用read, write, ioctl等操作对摄像头进行操作了. 在android HAL中同样也是这么做的, 直接对设备的操作相关的代码位于/hardware/libcamera/V4L2Camera.cpp中. 由于我的项目中使用了一个虚拟摄像头设备v4l2loopback, 但是有些android中用到的ioctl该设备的动作不符合预期, 需要进行修改, 所以本小节针对v4l2的做一个介绍, 内容主要来源于v4l2的官方文档.

V4L2是一套大而全的设备驱动, 但是很多功能对于摄像头来说用不到, 在android的HAL中, 用到的ioctl有:

接下来就对这些ioctl做一个说明.

2.1 ioctls

VIDIOC_QUERYCAP

用于查询设备的功能和类型, 基本上每个V4L2应用在open设备之后都要用这个ioctl来确定设备的类型. 使用时需要给定一个v4l2_capability类型的数据结构用于传出输出结果, 对于摄像头设备来说, v4l2_capability->capability的V4L2_CAP_VIDEO_CAPTURE位以及V4L2_CAP_STREAMING位需要为1.

V4L2_CAP_VIDEO_CAPTURE表示该设备支持视频捕获, 这也是摄像头的基本功能.

V4L2_CAP_STREAMING表示该设备支持Streaming I/O, 这是一种内存映射的方式来在内核与应用直接传输数据.

VIDIOC_ENUM_FMT

用于查询摄像头支持的图像格式. 使用时需要指定一个v4l2_fmtdesc类型的数据结构作为输出参数. 对于支持多种图像格式的设备来说, 需要设定v4l2_fmtdesc->index然后多次调用这个ioctl, 直到返回EINVAL. ioctl调用成功后, 可以通过v4l2_fmtdesc->pixelformat来获取该设备支持的图像格式, pixelformat可以是:

V4L2_PIX_FMT_MJPEG
V4L2_PIX_FMT_JPEG
V4L2_PIX_FMT_YUYV
V4L2_PIX_FMT_YVYU等.

VIDIOC_ENUM_FRAMESIZES

获取到图像格式之后, 还要进一步查询该种格式下设备支持的的分辨率, 这个ioctl就是干这个事. 使用是需要指定一个v4l2_frmsizeenum类型的数据结构, 并且设置v4l2_frmsizeenum->pixel_fromat为需要查询的图像格式, v4l2_frmsizeenum->index设置为0.

成功调用后, v4l2_frmivalenum->type可能有三种情况:

V4L2_FRMSIZE_TYPE_DISCRETE: 可以递增的设置v4l2_frmsizeenum->index来重复调用直到返回EINVAL来获取该种图像格式下所有支持的分辨率. 此时, 可以通过v4l2_frmsizeenum->width和height来获取支持的分辨率的长宽.
V4L2_FRMSIZE_TYPE_STEPWISE: 此时只有v4l2_frmsizeenum->stepwise是有效的, 并且不能再将index设为其他值重复调用此ioctl.
V4L2_FRMSIZE_TYPE_CONTINUOUS: STEPWISE的一种特殊情况, 此时同样只有stepwise有效, 并且stepwise.step_width和stepwise.step_height都为1.

上述三种情况中, 第一种很好理解, 就是支持的分辨率. 但是STEPWISE和CONTINUOUS还不知道是什么意思. 可能是任意分辨率都支持的意思?

VIDIOC_ENUM_FRAMEINTERVALS

获取到图像格式以及图像分辨率之后, 还可以查询在这种格式及分辨率下摄像头设备支持的fps. 使用是需要给定v4l2_frmivalenum格式的一个数据结构, 并设置好index=0, pixel_format, width, height.

调用完成后, 同样需要检查v4l2_frmivalenum.type, 同样有DISCRETE, STEPWISE, CONTINUOUS三种情况.

VIDIOC_TRY_FMT/VIDIOC_S_FMT/VIDIOC_G_FMT

这三个ioctl用于设置以及获取图像格式. TRY_FMT和S_FMT的区别在于前者不改变驱动的状态.

需要设置图像格式时一般通过G_FMT先获取当前格式, 再修改参数, 最后S_FMT或者TRY_FMT.

VIDIOC_S_PARM/VIDIOC_G_PARM

用于设置和获取streaming io的参数. 需要指定一个v4l2_streamparm类型的数据结构.

VIDIOC_S_JPEGCOMP/VIDIOC_G_JPEGCOMP

用于设置和获取JPEG格式的相关参数

VIDIOC_REQBUFS

为了在用户程序和内核设备之间交换图像数据, 需要分配一块内存. 这块内存可以在内核设备中分配, 然后用户程序通过mmap映射到用户空间, 也可以在用户空间分配, 然后内核设备进入用户指针IO模式. 这两种情况都可以用这个ioctl来进行初始化. 使用时需要给定一个v4l2_requestbuffers, 并设定好type, memory, count. 可以多次调用这个ioctl来重新设置参数. count设为0表示free 掉所有内存.

VIDIOC_QUERYBUF

VIDIOC_REQBUFS之后, 可以随时通过此ioctl查询buffer的当前状态. 使用时需要给定一个v4l2_buffer类型的数据结构. 并设定好type和index. 其中index的有效值为[0, count-1]. 这里的count是VIDIOC_REQBUFS返回的count.

VIDIOC_QBUF/VIDIOC_DQBUF

VIDIOC_REQBUFS分配了内存后, V4l2设备驱动还不能直接用这些内存, 需要通过VIDIOC_QBUF将分配好的内存中的一帧压入驱动的接收队列中, 然后通过VIDIOC_DQBUF推出一帧数据的内存. 如果是摄像头这样的CAPTURE设备, 那压入的就是一个空的内存区间, 等到摄像头拍摄到数据填充到了这片内存之后, 就能推出一片包含有效图像数据的帧了. 如果摄像头还没完成填充动作, 那么VIDIOC_DQBUF就会阻塞在那, 除非在open时设置了O_NONBLOCK标记位.

VIDIOC_STREAMON/VIDIOC_STREAMOFF

STREAMON表示开始工作, 只有在这个ioctl调用之后, 摄像头才能开始捕捉图像, 填充数据. 相对的, STREAMOFF则表示停止工作, 此时在设备驱动中尚未被DQBUF 的图像会丢失.

3 像素编码格式

由于底层涉及到图像, 摄像头相关的代码中出现了不少像素编码格式, 所以简单了解一下摄像头会遇到的格式.

3.1 RGB

很简单, 一个像素由RGB三种颜色组成, 每种颜色占用8位, 所以一个像素需要3 字节存储. 有些RGB编码格式会用更少的位保存一些颜色, 例如RGB844, 绿色和蓝色分别用4位来保存, 这样一个像素就只需要2字节. 还有RGBA, 增加了一个alpha通道, 这样一个像素就需要32位来保存.

3.2 YUV

YUV同样有三个通道, Y表示亮度, 由RGB三色特定部分叠加到一起, U和V则分别是红色与亮度的差异和蓝色与亮度的差异. Y一般占用8位, 而UV则可以省略, 因此衍生出了YUV444, YUV420, YUV411等一系列编码. 名称中的三位数字表示YUC 三个信道的比例, 例如YUV444表示三种信道1:1:1, 而Y占用8位, 因此一个像素占用24位. YUV420并不是说V就完全省略了, 而是一行4:1:0, 一行4:0:1.

android系统的摄像头预览默认采用YUV420sp编码. YUV420又分为YUV420p和YUV420sp, 两者的区别在于UV数据的存放顺序不一样:

Figure 1: 图片来自 http://blog.csdn.net/jefry_xdz/article/details/7931018

4 Android Camera

4.1 Hardware

在Android-x85 5.1中, HAL层摄像头相关的类之间的关系大概如图所示:

SurfaceSize是对一个Surface的长宽参数的封装. SurfaceDesc是对一个Surface 的长宽参数, fps参数的封装.

V4L2Camera类是对V4L2设备驱动的一层封装, 直接通过ioctl控制V4L2设备.

CameraParameters是对摄像头参数的封装. 其中flatten和unfaltten相当于是对CameraParameters的序列化和反序列化.

camera_device其实是一个类似于抽象类的结构体, 定义了一些列摄像头应该实现的接口, 而CameraHardware继承了这个camera_device, 表示一个摄像头的抽象, 这个类主要实现了android定义的一个摄像头应该实现的动作, 如startPreview. 其底层通过V4L2Camera对象来操作摄像头设备, 每个CameraHardware对象都包含一个V4L2Camera对象. 每个实例还包含了一个CameraParameters对象, 保存摄像头的相关参数.

CameraFactory是一个摄像头的管理类, 整个安卓系统中只有一个实例, 其中通过读配置文件的方式创建了多个CameraHardware实例.

CameraFactory

CameraFactory类扮演着是一个摄像头设备的管理员的角色, 这个类查询手机上有几个摄像头, 这几个摄像头的设备路径分别是什么, 旋转角度是多少, 朝向(前置还是后置)等信息. Android-x86通过读取一个配置文件来获取机器上有多少个摄像头:

hardware/libcamera/CameraFactory.cpp


void CameraFactory::parseConfig(const char* configFile)
{
    ALOGD("CameraFactory::parseConfig: configFile = %s", configFile);
 
    FILE* config = fopen(configFile, "r");
    if (config != NULL) {
        char line[128];
        char arg1[128];
        char arg2[128];
        int  arg3;
 
        while (fgets(line, sizeof line, config) != NULL) {
            int lineStart = strspn(line, " \t\n\v" );
 
            if (line[lineStart] == '#')
                continue;
 
            sscanf(line, "%s %s %d", arg1, arg2, &arg3);
            if (arg3 != 0 && arg3 != 90 && arg3 != 180 && arg3 != 270)
                arg3 = 0;
 
            if (strcmp(arg1, "front") == 0) {
                newCameraConfig(CAMERA_FACING_FRONT, arg2, arg3);
            } else if (strcmp(arg1, "back") == 0) {
                newCameraConfig(CAMERA_FACING_BACK, arg2, arg3);
            } else {
                ALOGD("CameraFactory::parseConfig: Unrecognized config line '%s'", line);
            }
        }
    } else {
        ALOGD("%s not found, using camera configuration defaults", CONFIG_FILE);
        if (access(DEFAULT_DEVICE_BACK, F_OK) != -1){
            ALOGD("Found device %s", DEFAULT_DEVICE_BACK);
            newCameraConfig(CAMERA_FACING_BACK, DEFAULT_DEVICE_BACK, 0);
        }
        if (access(DEFAULT_DEVICE_FRONT, F_OK) != -1){
            ALOGD("Found device %s", DEFAULT_DEVICE_FRONT);
            newCameraConfig(CAMERA_FACING_FRONT, DEFAULT_DEVICE_FRONT, 0);
        }
    }
}

配置文件的路径位于/etc/camera.cfg, 格式为”front/back path_to_device orientation”, 例如”front /dev/video0 0″

值得一提的另一个函数是 cameraDeviceOpen, APP在打开摄像头的过程中会通过这个函数获取摄像头:


 1: int CameraFactory::cameraDeviceOpen(const hw_module_t* module,int camera_id, hw_device_t** device)
 2: {
 3:     ALOGD("CameraFactory::cameraDeviceOpen: id = %d", camera_id);
 4: 
 5:     *device = NULL;
 6: 
 7:     if (!mCamera || camera_id < 0 || camera_id >= getCameraNum()) {
 8:         ALOGE("%s: Camera id %d is out of bounds (%d)",
 9:              __FUNCTION__, camera_id, getCameraNum());
10:         return -EINVAL;
11:     }
12: 
13:     if (!mCamera[camera_id]) {
14:         mCamera[camera_id] = new CameraHardware(module, mCameraDevices[camera_id]);
15:     }
16:     return mCamera[camera_id]->connectCamera(device);
17: }

从第13行可知, 当android系统启动的时候, 就已经构建好了CameraFactory对象并且通过配置文件读取到机器中有多少摄像头, 对应的设备路径是什么. 但是此时并没有创建CameraHardware对象, 而是直到对应的摄像头第一次被打开的时候才创建.

CameraFactory类整个android系统只有一个实例, 那就是定义在CameraFactory.cpp中的gCameraFactory. camera_module_t定义了几个函数指针, 指向了CameraFactory中的static函数, 当调用这些指针指向的函数的时候, 实质上是在调用gCameraFactory对象中的相应方法:

hardware/libcamera/CameraHal.cpp


camera_module_t HAL_MODULE_INFO_SYM = {
    common: {
         tag:           HARDWARE_MODULE_TAG,
         version_major: 1,
         version_minor: 0,
         id:            CAMERA_HARDWARE_MODULE_ID,
         name:          "Camera Module",
         author:        "The Android Open Source Project",
         methods:       &android::CameraFactory::mCameraModuleMethods,
         dso:           NULL,
         reserved:      {0},
    },
    get_number_of_cameras:  android::CameraFactory::get_number_of_cameras,
    get_camera_info:        android::CameraFactory::get_camera_info,
};

上述代码定义了一个camera_module_t, 相应的函数定义如下:

hardware/libcamera/CameraFactory.cpp


int CameraFactory2::device_open(const hw_module_t* module,
                                       const char* name,
                                       hw_device_t** device)
{
    ALOGD("CameraFactory2::device_open: name = %s", name);
 
    /*
     * Simply verify the parameters, and dispatch the call inside the
     * CameraFactory instance.
     */
 
    if (module != &HAL_MODULE_INFO_SYM.common) {
        ALOGE("%s: Invalid module %p expected %p",
                __FUNCTION__, module, &HAL_MODULE_INFO_SYM.common);
        return -EINVAL;
    }
    if (name == NULL) {
        ALOGE("%s: NULL name is not expected here", __FUNCTION__);
        return -EINVAL;
    }
 
    int camera_id = atoi(name);
    return gCameraFactory.cameraDeviceOpen(module, camera_id, device);
}
 
int CameraFactory2::get_number_of_cameras(void)
{
    ALOGD("CameraFactory2::get_number_of_cameras");
    return gCameraFactory.getCameraNum();
}
 
int CameraFactory2::get_camera_info(int camera_id,
                                           struct camera_info* info)
{
    ALOGD("CameraFactory2::get_camera_info");
    return gCameraFactory.getCameraInfo(camera_id, info);
}

camera_device

camera_device同时被定义为了camera_device_t, 此处涉及到HAL的扩展规范. Android HAL定义了三个数据类型, struct hw_module_t, struct hw_module_methods_t, struct hw_device_t, 分别表示模块类型, 模块方法和设备类型. 当需要扩展HAL, 增加一种设备的时候, 就要实现以上这三种数据结构. 例如对于摄像头来说, 就需要定义camera_module_t, camera_device_t, 以及为hw_module_methods_t中的函数指针赋值, 其中只有一个open函数, 相当于初始化模块. 而且HAL还规定camera_module_t的第一个成员必须是hw_module_t, camera_device_t的第一个成员必须是hw_device_t, 接下来的其他成员可以自己定义.

更详细的原理说明参加这里.

在Android-x86中, camera_device_t的定义位于hardware/libhardware/include/hardware/hardware.h

hardware/libhardware/include/hardware/hardware.h


typedef struct camera_device {
    hw_device_t common;
    camera_device_ops_t *ops;
    void *priv;
} camera_device_t;

其中的camera_device_ops_t摄像头模块自己定义的一组函数接口, 在同一个文件中, 太长了就不贴出来了.

camera_module_t位于同一个目录下的camera_common.h中

hardware/libhardware/include/hardware/camera_common.h


typedef struct camera_module {
    hw_module_t common;
    int (*get_number_of_cameras)(void);
    int (*get_camera_info)(int camera_id, struct camera_info *info);
    int (*set_callbacks)(const camera_module_callbacks_t *callbacks);
    void (*get_vendor_tag_ops)(vendor_tag_ops_t* ops);
    int (*open_legacy)(const struct hw_module_t* module, const char* id,
            uint32_t halVersion, struct hw_device_t** device);
 
    /* reserved for future use */
    void* reserved[7];
} camera_module_t;

在framework调用HAL代码时, 通过hw_module_t->methods->open获取hw_device_t, 然后强制转化为camera_device_t, 就能调用camera_device_t->ops中的摄像头相关的函数了. 对于Android-x86的摄像头来说, ops中的函数指针的赋值位于继承了camera_device的CameraHardware类中.

CameraHardware

CameraHardware的众多接口主要是为了完成三个动作: 预览, 录制, 拍照. 其他的函数大多是设置参数等准备工作. 本小节以预览为例对代码流程做一个说明.

首先是对CameraHardware对象的初始化参数, 对应的函数为initDefaultParameters. 该函数通过调用V4L2Camera的getBestPreviewFmt, getBestPictureFmt, getAvailableSizes, getAvailableFps 来分别获取默认预览图像格式, 默认图像格式, 摄像头支持的分辨率和fps:

hardware/libcamera/CameraHardware.cpp


int pw = MIN_WIDTH;
int ph = MIN_HEIGHT;
int pfps = 30;
int fw = MIN_WIDTH;
int fh = MIN_HEIGHT;
SortedVector<SurfaceSize> avSizes;
SortedVector<int> avFps;
 
if (camera.Open(mVideoDevice) != NO_ERROR) {
    ALOGE("cannot open device.");
} else {
 
    // Get the default preview format
    pw = camera.getBestPreviewFmt().getWidth();
    ph = camera.getBestPreviewFmt().getHeight();
    pfps = camera.getBestPreviewFmt().getFps();
 
    // Get the default picture format
    fw = camera.getBestPictureFmt().getWidth();
    fh = camera.getBestPictureFmt().getHeight();
 
    // Get all the available sizes
    avSizes = camera.getAvailableSizes();
 
    // Add some sizes that some specific apps expect to find:
    //  GTalk expects 320x200
    //  Fring expects 240x160
    // And also add standard resolutions found in low end cameras, as
    //  android apps could be expecting to find them
    // The V4LCamera handles those resolutions by choosing the next
    //  larger one and cropping the captured frames to the requested size
 
    avSizes.add(SurfaceSize(480,320)); // HVGA
    avSizes.add(SurfaceSize(432,320)); // 1.35-to-1, for photos. (Rounded up from 1.3333 to 1)
    avSizes.add(SurfaceSize(352,288)); // CIF
    avSizes.add(SurfaceSize(320,240)); // QVGA
    avSizes.add(SurfaceSize(320,200));
    avSizes.add(SurfaceSize(240,160)); // SQVGA
    avSizes.add(SurfaceSize(176,144)); // QCIF
 
    // Get all the available Fps
    avFps = camera.getAvailableFps();
}

然后将这些参数转为文本形式, 设置到CameraParameters对象中:

hardware/libcamera/CameraHardware.cpp


    // Antibanding
    p.set(CameraParameters::KEY_SUPPORTED_ANTIBANDING,"auto");
    p.set(CameraParameters::KEY_ANTIBANDING,"auto");
 
    // Effects
    p.set(CameraParameters::KEY_SUPPORTED_EFFECTS,"none"); // "none,mono,sepia,negative,solarize"
    p.set(CameraParameters::KEY_EFFECT,"none");
 
    // Flash modes
    p.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES,"off");
    p.set(CameraParameters::KEY_FLASH_MODE,"off");
 
    // Focus modes
    p.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES,"fixed");
    p.set(CameraParameters::KEY_FOCUS_MODE,"fixed");
 
#if 0
    p.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT,0);
    p.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY,75);
    p.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES,"0x0");
    p.set("jpeg-thumbnail-size","0x0");
    p.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH,0);
#endif
 
    // Picture - Only JPEG supported
    p.set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS,CameraParameters::PIXEL_FORMAT_JPEG); // ONLY jpeg
    p.setPictureFormat(CameraParameters::PIXEL_FORMAT_JPEG);
    p.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, szs);
    p.setPictureSize(fw,fh);
    p.set(CameraParameters::KEY_JPEG_QUALITY, 85);
 
    // Preview - Supporting yuv422i-yuyv,yuv422sp,yuv420sp, defaulting to yuv420sp, as that is the android Defacto default
    p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS,"yuv422i-yuyv,yuv422sp,yuv420sp,yuv420p"); // All supported preview formats
    p.setPreviewFormat(CameraParameters::PIXEL_FORMAT_YUV422SP); // For compatibility sake ... Default to the android standard
    p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, fpsranges);
    p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, fps);
    p.setPreviewFrameRate( pfps );
    p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, szs);
    p.setPreviewSize(pw,ph);
 
    // Video - Supporting yuv422i-yuyv,yuv422sp,yuv420sp and defaulting to yuv420p
    p.set("video-size-values"/*CameraParameters::KEY_SUPPORTED_VIDEO_SIZES*/, szs);
    p.setVideoSize(pw,ph);
    p.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT, CameraParameters::PIXEL_FORMAT_YUV420P);
    p.set("preferred-preview-size-for-video", "640x480");
 
    // supported rotations
    p.set("rotation-values","0");
    p.set(CameraParameters::KEY_ROTATION,"0");
 
    // scenes modes
    p.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES,"auto");
    p.set(CameraParameters::KEY_SCENE_MODE,"auto");
 
    // white balance
    p.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE,"auto");
    p.set(CameraParameters::KEY_WHITE_BALANCE,"auto");
 
    // zoom
    p.set(CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED,"false");
    p.set("max-video-continuous-zoom", 0 );
    p.set(CameraParameters::KEY_ZOOM, "0");
    p.set(CameraParameters::KEY_MAX_ZOOM, "100");
    p.set(CameraParameters::KEY_ZOOM_RATIOS, "100");
    p.set(CameraParameters::KEY_ZOOM_SUPPORTED, "false");
 
    // missing parameters for Camera2
    p.set(CameraParameters::KEY_FOCAL_LENGTH, 4.31);
    p.set(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, 90);
    p.set(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, 90);
    p.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, "640x480,0x0");

当准备工作做完之后, 调用 CameraHardware::startPreview 函数, 这个函数只有三行, 首先加个锁, 然后调用 startPreviewLocked, 所有的预览的工作都是在这个函数中完成.

hardware/libcamera/CameraHardware.cpp


status_t CameraHardware::startPreviewLocked()
{
    ALOGD("CameraHardware::startPreviewLocked");
 
    // 预览由一个独立的线程完成, 这几行检查预览是否已经开启. 一般来说是不会进入到if的
    if (mPreviewThread != 0) {
        ALOGD("CameraHardware::startPreviewLocked: preview already running");
        return NO_ERROR;
    }
 
    // 通过CameraParameters获取预览的长宽.
    int width, height;
    // If we are recording, use the recording video size instead of the preview size
    if (mRecordingEnabled && mMsgEnabled & CAMERA_MSG_VIDEO_FRAME) {
        mParameters.getVideoSize(&width, &height);
    } else {
        mParameters.getPreviewSize(&width, &height);
    }
 
    // 通过CameraParameters获取预览的fps
    int fps = mParameters.getPreviewFrameRate();
    ALOGD("CameraHardware::startPreviewLocked: Open, %dx%d", width, height);
 
    // 调用V4L2Camera的open函数打开摄像头设备
    status_t ret = camera.Open(mVideoDevice);
    if (ret != NO_ERROR) {
        ALOGE("Failed to initialize Camera");
        return ret;
    }
    ALOGD("CameraHardware::startPreviewLocked: Init");
 
    // 调用V4L2Camera的init函数初始化摄像头设备
    ret = camera.Init(width, height, fps);
    if (ret != NO_ERROR) {
        ALOGE("Failed to setup streaming");
        return ret;
    }
 
    // 用户要求的预览的长宽可能摄像头设备不支持, 摄像头实际工作的长宽通过以下函数获取.
    /* Retrieve the real size being used */
    camera.getSize(width, height);
    ALOGD("CameraHardware::startPreviewLocked: effective size: %dx%d",width, height);
 
    // 保存实际工作的长宽
    // If we are recording, use the recording video size instead of the preview size
    if (mRecordingEnabled && mMsgEnabled & CAMERA_MSG_VIDEO_FRAME) {
        /* Store it as the video size to use */
        mParameters.setVideoSize(width, height);
    } else {
        /* Store it as the preview size to use */
        mParameters.setPreviewSize(width, height);
    }
 
    // ???
    /* And reinit the memory heaps to reflect the real used size if needed */
    initHeapLocked();
    ALOGD("CameraHardware::startPreviewLocked: StartStreaming");
 
    // 通过V4L2Camera.StartStreaming让摄像头设备开始工作
    ret = camera.StartStreaming();
    if (ret != NO_ERROR) {
        ALOGE("Failed to start streaming");
        return ret;
    }
 
    // 初始化预览窗口
    // setup the preview window geometry in order to use it to zoom the image
    if (mWin != 0) {
        ALOGD("CameraHardware::setPreviewWindow - Negotiating preview format");
        NegotiatePreviewFormat(mWin);
    }
 
    ALOGD("CameraHardware::startPreviewLocked: starting PreviewThread");
 
    // 开启一个线程处理预览工作
    mPreviewThread = new PreviewThread(this);
 
    ALOGD("CameraHardware::startPreviewLocked: O - this:0x%p",this);
 
    return NO_ERROR;
}

再来看这个 PreviewThread, 这个类很简单, 就是调用了CameraHardware的previewThread方法, 这个方法根据fps计算出一个等待时间, 然后调用V4L2Camera的GrabRawFrame获取摄像头设备的图像, 然后转换成支持的图像格式, 最后放到显示窗口中显示图像.

V4L2Camera

V4L2Camera类主要是对V4L2设备的封装, 下面分析一下常用的几个接口, 如Open, Init, StartStreaming, GrabRawFrame, EnumFrameIntervals, EnumFrameSizes, EnumFrameFormats.

Open

Open接口的逻辑比较简单, 通过 open 系统调用获取摄像头设备的文件描述符, 然后调用VIDIOC_QUERYCAP ioctl查询设备的能力, 由于是摄像头设备, 这里就要求是设备的V4L2_CAP_VIDEO_CAPTURE位被置为1, 所以有个检查. 最后调用EnumFrameFormats 获取摄像头支持的图像格式.