Android攝像頭相關源碼分析: 設備驅動, HAL, 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 獲取攝像頭支持的圖像格式.