android camera HAL

一 编译HAL

1 修改BoardConfig.mk

device/wolf/smdk6410/BoardConfig.mk

USE_CAMERA_STUB := false

hardware建立Camera HAL目录

hardware/wolf/libcamera

CannedJpeg.h

Ov965xCamera.cpp

Ov965xCamera.h

S3C6410CameraHardware.cpp

S3C6410CameraHareware.h

USBCamera.cpp

USBCamera.h

编写Android.mk文件

LOCAL_PATH:= $(call my-dir)

include $(CLEAR_VARS)

LOCAL_SRC_FILES:= \

    USBCamera.cpp \

    Ov965xCamera.cpp \

S3C6410CameraHardware.cpp

LOCAL_SHARED_LIBRARIES:= \

    libui \

    libutils \

    libbinder \

    liblog \

    libcamera_client

LOCAL_MODULE:= libcamera

LOCAL_MODULE_TAGS := eng

LOCAL_C_INCLUDES += \

                frameworks/base/libs

include $(BUILD_SHARED_LIBRARY)

2 android2.3.4_32bit$ source ./build/envsetup.sh 

3 android2.3.4_32bit$ choosecombo

Build for the simulator or the device?

     1. Device

     2. Simulator

 1

 1

Which product would you like? [smdk6410] 

回车

eng

4 make libcamera编译特定模块

开始编译摄像头模块，动态连接库文件*.so存放在

Install: out/target/product/smdk6410/system/lib/libcamera.so

用adb push把libcamera.so推到目标机/system/lib/中

cd D:\software\android-sdk-windows\tools

d:

adb push libcamera.so /system/lib/

5 目标机上

export ANDROID_LOG_TAGS="CameraHardware:D CameraHardware:E *:S"

logcat -d

6 问题

拍照

E/AudioService( 1902): Media server died.

解决：在init.c中添加

chmod 0777 /dev/video0

二 CAMERA 系统

Camera系统分成以下几个部分

1）摄像头驱动程序：通常基于linux的video for linux视频驱动框架

2）Camera硬件抽象层

接口的代码路径：frameworks/base/include/camera/

主要文件为CameraHardwareInterfacd.h,需要各个系统根据自己的情况实现

3)Camera服务部分

代码路径：frameworks/base/include/camera

Camera服务是Android系统中一个单独部分，通过调用Camera硬件抽象层来实现

4）Camera的本地框架代码

代码路径：frameworks/base/include/camera

5）Camera的JNI代码

代码路径：frameworks/base/core/jni/android_hardware_Camera.cpp

提供给Java类的本地支持，也包含了反向调用java传递信息和数据功能

6）Camera系统的Java类

代码路径：frameworks/base/core/java/android/hardware/Camera.java

Camera对Java层次的类为android.hardware.Camera,自Java应用程序提供接口

可用于在Java应用程序层构建照相机和扫描类的程序

-----------------------------------------------------------------------

移植的内容

在Android系统中，照相机系统的标准化部分是硬件抽象层的接口，因此

针对特定平台Camera系统的移植包括Camera驱动程序和Camera硬件抽象层

在Linux系统中，Camera的驱动程序都是用Linux标准的Video for Linux 2(V4L2)

驱动程序，从内核空间到用户空间，主要的数据流和控制类的均由V4L2驱动程序

的框架来定义，在Android系统的实现中，一般也都使用标准的V4L2驱动程序作为

照相机部分的驱动程序

Camera硬件抽象层主要实现取景器，视频录制，拍摄相片三个方面功能。V4L2驱动

程序一般只提供的Video数据的获得，而如何实现视频预览，如何向上层发送数据等

功用，这些都是Camera的硬件抽象层需要负责的方面了。

三 硬件抽象层

1. Camera硬件抽象层

frameworks/base/include/camera/

主要文件为CameraHardwareInterface.h,需要各个系统根据自己的情况实现

2. Camera服务部分

frameworks/base/services/camera/libcameraservice

Camera服务是Andriod系统中一个单独的部分，通过调用camera硬件抽象层

来实现。

3. Camera 的本地框架代码

frameworks/base/libs/camera/

4. Camera的硬件抽象层

是位于V4L2驱动程序和CameraService之间的部分，这是

一个C++的接口类,需要具体的实现者继承这个类，并实现其中的各个纯虚函数。

纯虚函数可以让类先具有一个操作名称，而没有操作内容，让派生类在继承时

再去具体地给出定义。

硬件抽象层的主要的头文件为CameraHardwareInterface.h,定义了C++的接口类

需要根据系统的情况继承实现。

camera.h 这是Camera系统本地对上层的接口

CameraParameters.h定义Camera系统的参数，在本地代码的各个层次中使用。

Camera硬件抽象层的实现通常需要生成动态库libcamera.so

5. CameraHardwareInterface中定义了几种回调函数

typedef void (*notify_callback)(int32_t msgType, //通知回调

                                int32_t ext1,

                                int32_t ext2,

                                void* user);

typedef void (*data_callback)(int32_t msgType, //数据回调

                              const sp<IMemory>& dataPtr,

                              void* user);

typedef void (*data_callback_timestamp)(nsecs_t timestamp,//带有时间的数据回调

                                        int32_t msgType,

                                        const sp<IMemory>& dataPtr,

                                        void* user);

消息类型mstType 数据IMemory

回调函数由setCallbacks(),enableMsgType()函数统一处理。

setCallbacks()可以设置三个类型的回调函数指针

  /** Set the notification and data callbacks */

    virtual void setCallbacks(notify_callback notify_cb,

                              data_callback data_cb,

                              data_callback_timestamp data_cb_timestamp,

                              void* user) = 0;

6. Camera硬件抽象层的三种业务

A 取景器preview(使用YUV原始数据格式，发送到视频输出设备)

S3C6410CameraHardware.cpp中

1)在初始化过程中，建立preview的内存队列
void CameraHardware::initHeapLocked()
{
    // Create raw heap.
    int picture_width, picture_height;
    mParameters.getPictureSize(&picture_width, &picture_height);
    mRawHeap = new MemoryHeapBase(picture_width * picture_height * 2);

    int preview_width, preview_height;
    mParameters.getPreviewSize(&preview_width, &preview_height);

    int how_big = preview_width * preview_height*2;
}

void CameraHardware::initDefaultParameters()
{
    CameraParameters p;

    p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, "320x240");
    p.setPreviewSize(320, 240);//大小为320*240
    p.setPreviewFrameRate(15);//帧率为15bps

    p.setPreviewFormat(CameraParameters::PIXEL_FORMAT_RGB565);//preview 的格式为RGB565
    p.set(CameraParameters::KEY_ROTATION, 0);//90

    p.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, "320x240");
    p.setPictureSize(320, 240);
    p.setPictureFormat(CameraParameters::PIXEL_FORMAT_JPEG);// SET OUTPUT PIC TO BMP FORMAT

    if (setParameters(p) != NO_ERROR) {
        LOGE("Failed to set default parameters?!");
    }

}
2) 在startPreview()的实现中，建立preview线程
status_t CameraHardware::startPreview()
{
    Mutex::Autolock lock(mLock);
    if (mPreviewThread != 0) {
        return INVALID_OPERATION;
    }
    mPreviewThread = new PreviewThread(this);
    return NO_ERROR;
}
3)在preview线程的循环中，等待视频数据的到达
int CameraHardware::previewThread()
{
    if(mCamType == CAMTYPE_CMOS)
            Ov965xCamera->getNextFrameAsRgb565((uint16_t *)frame);
4)视频帧到达后使用preview回调的机制CAMERA_MSG_PREVIEW_FRAME,将视频
帧向上层传送
 // Notify the client of a new frame.
        if (mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME)
            mDataCb(CAMERA_MSG_PREVIEW_FRAME, buffer, mCallbackCookie);
B拍摄照片(可以使用原始数据或者压缩图像数据)
1) takePicture()函数表示开始拍摄，可以建立单独的线程来处理
status_t CameraHardware::takePicture()
{
    stopPreview();
    if (createThread(beginPictureThread, this) == false)
        return UNKNOWN_ERROR;
    return NO_ERROR;
}

 int CameraHardware::beginPictureThread(void *cookie)
{
    CameraHardware *c = (CameraHardware *)cookie;
    return c->pictureThread();
}

int CameraHardware::pictureThread()
{
    if (mMsgEnabled & CAMERA_MSG_SHUTTER)
        mNotifyCb(CAMERA_MSG_SHUTTER, 0, 0, mCallbackCookie);

    if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE) {
        //FIXME: use a canned YUV image!
        // In the meantime just make another fake camera picture.
        int w, h;
        mParameters.getPictureSize(&w, &h);
        sp<MemoryBase> mem = new MemoryBase(mRawHeap, 0, w * h * 2);

        Ov965xCamera cam(w, h);
        //cam.getNextFrameAsYuv420((uint8_t *)mRawHeap->base());

        if(mCamType == CAMTYPE_CMOS)
        {
        cam.getNextFrameAsRgb565((uint16_t *)mRawHeap->base());
        }
        else if (mCamType == CAMTYPE_USB)
        {
            //USBCamera cam1(w, h);
        LOGE("%s, Taking picure using USB CAM", LOG_TAG);
        //cam.getNextFrameAsRgb565((uint16_t *)mRawHeap->base());
        //cam1.getNextFrameAsYuv420((uint16_t *)mRawHeap->base());
        }
        mDataCb(CAMERA_MSG_RAW_IMAGE, mem, mCallbackCookie);
    }

    // ToDo: Release MemoryHeapBase
    // ToDo: Convert BMP to JPEG
    // Todo: Higher Resultion Support
    if (mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE) {
    LOGE("%s, COMPRESSED IMAGE", LOG_TAG);
        int w, h;
    unsigned int DATA_OFFSET = 54;
        uint16_t WIDTH = w;
    uint16_t HEIGHT = h;

        mParameters.getPictureSize(&w, &h);
    Ov965xCamera* Ov965xCamera = mOv965xCamera;
    sp<MemoryHeapBase> heap = new MemoryHeapBase(DATA_OFFSET+w * h* 2);
    sp<MemoryBase> mem = new MemoryBase(heap, 0, DATA_OFFSET+w * h* 2); //16 bits for one pixel



        uint8_t header[54] = { 0x42, // identity : B
        0x4d, // identity : M
        0, 0, 0, 0, // file size
        0, 0, // reserved1
        0, 0, // reserved2
        54, 0, 0, 0, // RGB data offset
        40, 0, 0, 0, // struct BITMAPINFOHEADER size
        0, 0, 0, 0, // bmp height
        0, 0, 0, 0, // bmp width
        1, 0, // planes
        16, 0, // bit per pixel
        0, 0, 0, 0, // compression
        0, 0, 0, 0, // data size
        0, 0, 0, 0, // h resolution
        0, 0, 0, 0, // v resolution
        0, 0, 0, 0, // used colors
        0, 0, 0, 0 // important colors
        };

        // file size offset 54
    uint16_t file_size = WIDTH * HEIGHT * 2 + DATA_OFFSET;
    header[2] = (uint8_t)(file_size & 0x000000ff);
    header[3] = (file_size >> 8) & 0x000000ff;
    header[4] = (file_size >> 16) & 0x000000ff;
    header[5] = (file_size >> 24) & 0x000000ff;

    // height
    header[18] = HEIGHT & 0x000000ff;
    header[19] = (HEIGHT >> 8) & 0x000000ff;
    header[20] = (HEIGHT >> 16) & 0x000000ff;
    header[21] = (HEIGHT >> 24) & 0x000000ff;

    // width
    header[22] = WIDTH & 0x000000ff;
    header[23] = (WIDTH >> 8) & 0x000000ff;
    header[24] = (WIDTH >> 16) & 0x000000ff;
    header[25] = (WIDTH >> 24) & 0x000000ff;

    LOGE("%s, Header Ready", LOG_TAG);

    unsigned int i;
    for(i=0;i<DATA_OFFSET;i++){
      *((uint8_t*)heap->base()+i)=header[i];
    }

    Ov965xCamera->getNextFrameAsRgb565((uint16_t*)heap->base()+DATA_OFFSET/2);

    uint16_t *heap_base = (uint16_t*)heap->base();
    uint16_t pixel_data;
    uint8_t tail_data;
    for(i=DATA_OFFSET/2;i<DATA_OFFSET/2+WIDTH*HEIGHT;i++){
      pixel_data = *(heap_base+i);
      tail_data = (uint8_t)(pixel_data & 0x001f);
      pixel_data = (pixel_data & 0xffc0)>>1 | tail_data;
      *(heap_base+i)=pixel_data;
    }


        mDataCb(CAMERA_MSG_COMPRESSED_IMAGE, mem, mCallbackCookie);
    heap=NULL;
    LOGE("%s, IMAGE SAVED!", LOG_TAG);
    }
    return NO_ERROR;
}

2)使用回调机制传送数据：如果得原始格式（通常是YUV的格式，如yuv422sp，这里是RGB565）

的数据，使用CAMERA_MSG_RAW_IMAGE将数据传送;如果得到压缩图像（通常JPEG格式，这里是BMP）

使用CAMERA_MSG_COMPRESSED_IMAGE将数据传送

C 视频录制（将数据传送给视频编码器程序）

1）在startRecording()的实现中，开始录制的准备，录制视频可以使用自己的线程，也可以使用

preview线程

2)当一个视频帧到来的时候，通过录制回调机制（使用CAMERA_MSG_VIDEO_FRAME）将视频帧向上

发送

3)releaseRecordingFrame()被调用后，表示上层通知Camera硬件抽象层，这一帧的内存已经用完

可以进行下一次的处理。

四 、 android camera HAL的改写

1. 修改BoardConfig.mk
USE_CAMERA_STUB := false
2. hardware下建立Camera HAL目录
/hardware/ego/libcamera
复制几个文件
cp ../../../frameworks/base/services/camera/libcameraservice/CameraHardwareStub.cpp
S3C6410CameraHardware.cpp
cp ../../../frameworks/base/services/camera/rks/base/services/camera/libcameraservice/CameraHardwareStub.h
S3C6410CameraHardware.h
cp ../../../frameworks/base/services/camera/libcameraservice/FakeCamera.cpp Ov965xCamera.cpp
cp ../../../frameworks/base/services/camera/libcameraservice/FakeCamera.h Ov965xCamera.h
3. 编译Android.mk文件
LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)

LOCAL_SRC_FILES:= \
    S3C6410CameraHardware.cpp   \
    Ov965xCamera.cpp

LOCAL_SHARED_LIBRARIES:= \
    libui   \
    libutils    \
    libbinder   \
    liblog  \
    libcamera_client

LOCAL_MODULE:= libcamera
LOCAL_MODULE_TAGS:= eng

LOCAL_C_INCLUDES += \
    frameworks/base/libs

include $(BUILD_SHARED_LIBRARY)

根据这个脚本可编译出libcamera.so
4. 修改Ov965xCamera.cpp，该文件可以按照V4L2流程来写
1)构造函数中进行初始化

Ov965xCamera::Ov965xCamera(int width, int height)
          : mTmpRgb16Buffer(0)
{
    struct v4l2_format fmt;
    int type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

    v4l2_fd = open("/dev/video0", O_RDWR | O_SYNC);
    LOGE("open /dev/video0 fd is %d", v4l2_fd);

    fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    fmt.fmt.pix.width = width;
    fmt.fmt.pix.height = height;
    fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;

    ioctl(v4l2_fd, VIDIOC_S_FMT, &fmt);
    ioctl(v4l2_fd, VIDIOC_STREAMON, &type);
    setSize(width, height);
}
-------->调用setSize()

5. 修改S3C6410CameraHardware.cpp
//参数设置
void CameraHardware::initDefaultParameters()
{

    CameraParameters p;
    //设置preview大小
    p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, "320x240");
    p.setPreviewSize(320, 240);
    //设置帧率
    p.setPreviewFrameRate(15);
    p.setPreviewFormat(CameraParameters::PIXEL_FORMAT_RGB565);
    p.set(CameraParameters::KEY_ROTATION, 0);

    p.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, "320x240");
    p.setPictureSize(320, 240);
    p.setPictureFormat(CameraParameters::PIXEL_FORMAT_JPEG);

    if (setParameters(p) != NO_ERROR) {
        LOGE("Failed to set default parameters!");
    }
}

调用----->setParameters(p)
status_t CameraHardware::setParameters(const CameraParameters& params)
{
    Mutex::Autolock lock(mLock);

    if (strcmp(params.getPreviewFormat(),
            CameraParameters::PIXEL_FORMAT_RGB565) != 0) {
            LOGE("Only rgb565 preview is supported");
            return -1;
            }

    if (strcmp(params.getPictureFormat(),
            CameraParameters::PIXEL_FORMAT_JPEG) != 0) {
            LOGE("Only jpeg still pictures are supported");
            return -1;
            }

    int w, h;
    params.getPictureSize(&w, &h);

    mParameters = params;
    initHeapLocked();

    return NO_ERROR;
}

调用----->initHeapLocked();
void CameraHardware::initHeapLocked()
{
    int picture_width, picture_height;
    mParameters.getPictureSize(&picture_width, &picture_height);
    //建立内存堆
    mRawHeap = new MemoryHeapBase(picture_width * picture_height * 2);

    //从参数中获取信息
    int preview_width, preview_height;
    mParameters.getPreviewSize(&preview_width, &preview_height);
    LOGD("initHeapLocked: preview size=%dx%d", preview_width, preview_height);

    int how_big = preview_width * preview_height * 2;
    mPreviewFrameSize = how_big;
    //制作新mmap'ed的堆，可以跨进程共享。
    mPreviewHeap = new MemoryHeapBase(mPreviewFrameSize * kBufferCount);
    //建立内存队列kBufferCount 4个
    for (int i = 0; i < kBufferCount; i++) {
        mBuffers[i] = new MemoryBase(mPreviewHeap, i * mPreviewFrameSize, mPreviewFrameSize);

    }

    if (mOv965xCamera != 0)
    {
        LOGD("delete mOv965xCamera");
        delete mOv965xCamera;
        mOv965xCamera = 0;
    }
    else if(mCamType == CAMTYPE_CMOS)
    {
        LOGD("new mOv965xCamera");
        mOv965xCamera = new Ov965xCamera(preview_width, preview_height);
    }
}
在这个过程中，建立了两块内存(MemoryHeapBase): mRawHeap 表示一个拍照照片的内存
mPreviewHeap表示取景preview的内存,由于取景器preview的内容是一个队列，因此在
mPreviewHeap中建立kBufferCount(为4个)MemoryBase
new Ov965xCamera作为摄像头输入数据的来源

CameraService.cpp调用----------->startPreview()
status_t CameraHardware::startPreview()
{
    Mutex::Autolock lock(mLock);
    if (mPreviewThread != 0) {
        return INVALID_OPERATION;
    }

    //建立视频preview的线程
    mPreviewThread = new PreviewThread(this);

    return NO_ERROR;
}

调用----------->PreviewThread()
在PreviewThread线程中通过调用preview的回调机制，实现preview
数据的数据传递给上层就是CameraService
int CameraHardware::previewThread()
{
    mLock.lock();

    int previewFrameRate = mParameters.getPreviewFrameRate();
    //获取内存偏移
    ssize_t offset = mCurrentPreviewFrame * mPreviewFrameSize;
    sp<MemoryHeapBase> heap = mPreviewHeap;

    //获得Ov965xCamera类
    Ov965xCamera* Ov965xCamera = mOv965xCamera;

    sp<MemoryBase> buffer = mBuffers[mCurrentPreviewFrame];

    mLock.unlock();

    if (buffer != 0) {
        //计算帧之间等待多久
        int delay = (int)(1000000.0f / float(previewFrameRate));
        //获得内存地址
        void *base = heap->base();
        //获得视频帧
        uint8_t *frame = ((uint8_t *)base) + offset;

        //获取一个帧的数据，放入frame
        Ov965xCamera->getNextFrameAsRgb565((uint16_t *)frame);
        //通知客户端的一个新的一帧,调用Callback向上层发送数据
        if (mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME)
            mDataCb(CAMERA_MSG_PREVIEW_FRAME, buffer, mCallbackCookie);
        //推进缓冲区指针
        mCurrentPreviewFrame = (mCurrentPreviewFrame + 1) % kBufferCount;

        usleep(delay);
    }
    return NO_ERROR;
}
硬件抽象层实现的取景器数据来自 Ov965xCamera,可以得到数据，并使用
回调函数CAMERA_MSG_PREVIEW_FRAME宏为参数将数据送向上层，这里使用
mDataCb是上层CameraService，通过setCallbacks()函数设置。
其中mPreviewHeap存储着n个帧的缓冲，这块区域被分割为n个mBuffers。
buffer为当前帧的引用，通过mDataCb(CAMERA_MSG_PREVIEW_FRAME, buffer, mCallbackCookie)
就可以将buffer输出到屏幕。那每一个帧是怎么存到mPreviewHeap上的呢？
关键的一句就是Ov965xCamera->getNextFrameAsRgb565((uint16_t *)frame) ，
通过看它的实现可以知道（在Ov96xCamera.app中），一个帧的数据以16位的格式写入frame中，
这里的frame即是对mPreviewHeap上某个mBuffer的引用
调用--------->getNextFrameAsRgb565((uint16_t *)frame)
void Ov965xCamera::getNextFrameAsRgb565(uint16_t *buffer)
{
    int ret;
    unsigned long len;
    if (v4l2_fd != -1)
    {
        len = mWidth * mHeight*2;
        ret = read(v4l2_fd, buffer, len);
    }
}
--------------------------------------------------------
setCallbacks()函数的实现
void CameraHardware::setCallbacks(notify_callback notify_cb,
                                    data_callback data_cb,
                                    data_callback_timestamp data_cb_timestamp,
                                    void* user)
{
    Mutex::Autolock lock(mLock);
    mNotifyCb = notify_cb;//通知回调
    mDataCb = data_cb;//数据回调
    mDataCbTimestamp = data_cb_timestamp;
    mCallbackCookie = user;
}

--------------->takePicture()函数在拍摄照片时被调用，它也保存了回调函数的指针，并建立了拍摄照片
的线程
status_t CameraHardware::takePicture()
{
    stopPreview();
    if (createThread(beginPictureThread, this) == false)
        return UNKNOWN_ERROR;

    return NO_ERROR;
}
调用----------------->beginPictureThread()
int CameraHardware::beginPictureThread(void *cookie)
{
    CameraHardware *c = (CameraHardware *)cookie;
    return c->pictureThread();
}
调用----------------->pictureThread()
int CameraHardware::pictureThread()
{

    //快门回调机制
    if (mMsgEnabled & CAMERA_MSG_SHUTTER)
        mNotifyCb(CAMERA_MSG_SHUTTER, 0, 0, mCallbackCookie);

    //传送原始数据的处理
    if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE) {
        int w, h;
        mParameters.getPictureSize(&w, &h);
        sp<MemoryBase> mem = new MemoryBase(mRawHeap, 0, w * h * 2);

        Ov965xCamera cam(w, h);
        if (mCamType == CAMTYPE_CMOS)
        {
            //获得指针
            cam.getNextFrameAsRgb565((uint16_t *)mRawHeap->base());
            LOGD("----------Taking picture using OV9650 CAM------");
        }
        //传送数据
        mDataCb(CAMERA_MSG_RAW_IMAGE, mem, mCallbackCookie);
    }

    //传送JPEG数据的处理
    if (mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE) {
        LOGE("%s, --------COMPRESSD IMAGE------", LOG_TAG);
        //step1 首先申请BMP暂存区：
        int w, h;
        unsigned int DATA_OFFSET = 54;
        uint16_t WIDTH  = w;
        uint16_t HEIGHT = h;

        mParameters.getPictureSize(&w, &h);
        Ov965xCamera* Ov965xCamera = mOv965xCamera;
        sp<MemoryHeapBase> heap = new MemoryHeapBase(DATA_OFFSET + w * h * 2);
        //一个像素6位
        sp<MemoryBase> mem = new MemoryBase(heap, 0, DATA_OFFSET + w * h * 2);

        //写BMP文件头
        uint8_t header[54] = {
        0x42, 0x4d,//BM
        0, 0, 0, 0, //file size
        0, 0, //reserved1
        0, 0, //reserved2
        54, 0, 0, 0, //RGB data offset
        40, 0, 0, 0, //struct BITMAPINFOHEADER size
        0, 0, 0, 0,//bmp height
        0, 0, 0, 0, //bmp width
        1, 0, //planes
        16, 0, //一个像素16位
        0, 0, 0, 0,//压缩
        0, 0, 0, 0,//data size
        0, 0, 0, 0,//h resolution
        0, 0, 0, 0,//v resolution
        0, 0, 0, 0,//used colors
        0, 0, 0, 0//important colors
        };

    //file size offset 54
    uint16_t file_size = WIDTH * HEIGHT * 2 + DATA_OFFSET;
    header[2] = (uint8_t)(file_size & 0x000000ff);
    header[3] = (file_size >> 8)  & 0x000000ff;
    header[4] = (file_size >> 16) & 0x000000ff;
    header[5] = (file_size >> 24) & 0x000000ff;

    //height
    header[18] = HEIGHT & 0x000000ff;
    header[19] = (HEIGHT >> 8) & 0x000000ff;
    header[20] = (HEIGHT >> 16) & 0x000000ff;
    header[21] = (HEIGHT >> 24) & 0x000000ff;

    //width
    header[22] = WIDTH & 0x000000ff;
    header[23] = (WIDTH >> 8 ) & 0x000000ff;
    header[24] = (WIDTH >> 16) & 0x000000ff;
    header[25] = (WIDTH >> 24) & 0x000000ff;

    //step2 获取当前帧，进行RGB565到RGB555的转换，将转换后的
    //数据放入MemoryHeap中
    unsigned int i;
    for (i=0; i< DATA_OFFSET; i++){
        *((uint8_t *)heap->base() + i) = header[i];
    }

    Ov965xCamera->getNextFrameAsRgb565((uint16_t *)heap->base() + DATA_OFFSET/2);

    uint16_t *heap_base = (uint16_t *)heap->base();
    uint16_t pixel_data;
    uint8_t tail_data;
    for(i=DATA_OFFSET/2; i<DATA_OFFSET/2+WIDTH*HEIGHT; i++) {
        pixel_data = *(heap_base + i);
        tail_data = (uint8_t)(pixel_data & 0x001f);
        pixel_data = (pixel_data & 0xffc0)>>1 | tail_data;
        *(heap_base + i) = pixel_data;
    }
    //step3 调用callback,将数据存储到设备，并释放MemoryHeap

    mDataCb(CAMERA_MSG_COMPRESSED_IMAGE, mem, mCallbackCookie);
    heap = NULL;
    LOGE("%s, -----IMAGE SAVED-----", LOG_TAG);
    }

    return NO_ERROR;
}
-----------------------------------------------------------
---------------->autoFocus()
status_t CameraHardware::autoFocus()
{
    Mutex::Autolock lock(mLock);
    if (createThread(beginAutoFocusThread, this) == false)
        return UNKNOWN_ERROR;
    return NO_ERROR;
}
调用-------------->beginAutoFocusThread()
int CameraHardware::beginAutoFocusThread(void *cookie)
{
    CameraHardware *c = (CameraHardware *)cookie;
    return c->autoFocusThread();
}
调用-------------->autoFocusThread()
int CameraHardware::autoFocusThread()
{
    if (mMsgEnabled & CAMERA_MSG_FOCUS)
        mNotifyCb(CAMERA_MSG_FOCUS, true, 0, mCallbackCookie);
    return NO_ERROR;
}
----------------------------------------------------------------
上面是实现的RGB565写成BMP格式的