在Linux系统中，硬件平台驱动，以及其他需要商业保护的部分通常都会通过HAL来封装，在Aurora中也如此。
目前产业界的Camera传感器主要有两种类型：电荷耦合设备（CCD，Charge Couple Device）和互补金属氧化物半导体（CMOS，Complementary Metal Oxide Semiconductor）。其中CCD主要应用在高档的DC、DV和高档移动终端上，图像质量较好，但驱动模组比较复杂；而CMOS则门槛较低，工艺更加成熟，成本较低，外围电路也比较简单，很多厂商已将驱动和信号处理的图像信号处理器（ISP，Image Signal Processor）集成到驱动模组中。因此CMOS传感器在移动终端中应用广泛。如图5-4所示为Camera进行图像编码的底层过程。
图5-4 图像编码过程
与Camera传感器通信，需涉及I2C驱动；进行文件保存，需涉及GPIO驱动和PMIC驱动；利用aDSP解码，就需要用到VFE aDSP驱动。
在这些平台驱动之上，在Android的较新版本中，通常会封装一层HAL，可以为开发者提供更加抽象的接口，同时也可以保护硬件厂商的利益。
在Android中，为了实现Camera的HAL封装，必须继承CameraHardwareInterface.h定义的CameraHardwareInterface接口。
在Android原始代码中，提供了CameraHardwareStub.cpp和QualcommCamera Hardware.cpp两种实现，CameraHardwareStub提供了基于模拟器的FakeCamera实现。QualcommCameraHardware实现了对真实物理设备的HAL封装。下面首先介绍CameraHardwareStub的实现。
在CameraHardwareStub中，为了保证系统的流畅运行，在发起预览时，会将Camera预览放置在一个单独的预览线程CameraHardwareStub::previewThread()中，并在线程的事件循环中周期性调用previewThread，从底层提取数据。CameraHardwareStub::previewThread()的实现如下：
代码5-4 预览线程的事件循环处理
int CameraHardwareStub::previewThread()
{
mLock.lock();
int previewFrameRate=mParameters.getPreviewFrameRate(); //帧速率
ssize_t offset=mCurrentPreviewFrame * mPreviewFrameSize; //偏移量
sp< MemoryHeapBase> heap=mPreviewHeap;
FakeCamera* fakeCamera=mFakeCamera;
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;
fakeCamera->getNextFrameAsYuv422(frame); //获取数据缓冲
//通知客户端有新帧到来
if (mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME)
mDataCb(CAMERA_MSG_PREVIEW_FRAME, buffer, mCallbackCookie);
mCurrentPreviewFrame=(mCurrentPreviewFrame + 1) % kBufferCount;
usleep(delay);
}
return NO_ERROR;
}
在CameraHardwareStub中，目前共有4个缓冲用于Camera数据的交替存放，这些数据被放置在一个名为mPreviewHeap的预览内存堆中。具体实现如下：
代码5-5 Camera堆的初始化
void CameraHardwareStub::initHeapLocked()
{
int picture_width, picture_height;
mParameters.getPictureSize(&picture_width, &picture_height);//拍摄大小
//MMAP映射，存在拍摄时的原始数据
mRawHeap=new MemoryHeapBase(picture_width * 2 * picture_height);
int preview_width, preview_height;
mParameters.getPreviewSize(&preview_width, &preview_height);//预览大小
LOGD("initHeapLocked: preview size=%dx%d", preview_width, preview_height);
//强制设置为yuv422
int how_big=preview_width * preview_height * 2;
if (how_big==mPreviewFrameSize)
return;
mPreviewFrameSize=how_big;
//构建一个新MMAP堆用于进程间共享
mPreviewHeap=new MemoryHeapBase(mPreviewFrameSize * kBufferCount);
//为每帧都构建一个IMemory
for (int i=0; i < kBufferCount; i++) {
mBuffers[i]=new MemoryBase(mPreviewHeap, i * mPreviewFrameSize, mPreviewFrameSize);
}
delete mFakeCamera;
mFakeCamera=new FakeCamera(preview_width, preview_height);
}
模拟器默认配置下，预览分辨率为176×144像素，帧速率为15fps,预览数据格式为YUV422 SP（仅支持），照片编码格式为JPEG（仅支持）。
出于某种需求，需要将元数据格式YUV422SP转换为RGB565，yuv420sp2rgb.c文件给出的方法如下：
代码5-6 YUV422sp转换为RGB565的实现
static public void decodeYUV420SP(int[] rgb, byte[] yuv420sp, int width, int height) {
final int frameSize=width * height;
for (int j=0, yp=0; j< height; j++) {
int uvp=frameSize + (j>>1) * width, u=0, v=0;
for (int i=0; i< width; i++, yp++) {
int y=(0xff & ((int) yuv420sp[yp])) - 16;
if (y< 0) y=0;
if ((i & 1)==0) {
v=(0xff & yuv420sp[uvp++]) - 128;
u=(0xff & yuv420sp[uvp++]) - 128;
}
int y1192=1192 * y;
int r=(y1192+1634 * v);
int g=(y1192-833 * v-400*u);
int b=(y1192+2066 * u);
if (r< 0) r=0; else if (r>262143) r=262143;
if (g< 0) g=0; else if (g>262143) g=262143;
if (b< 0) b=0; else if (b>262143) b=262143;
rgb[yp]=0xff000000 | ((r<<6) & 0xff0000) | ((g>>2) & 0xff00) | ((b>>10) & 0xff);
}
}
}
如果希望在预览时就做这样的转换，编码的转换好放置在一个单独的线程中处理。RGB565向YUV422SP的转换参考FakeCamera.cpp文件。
在进行自动对焦和拍照时，CameraHardwareStub同样会发起一个新的线程进行处理，相关的线程为autoFocusThread、pictureThread。在QualcommCameraHardware中，则没有发起新线程进行处理。
在进行拍照时，为了向上层传递假图片，CameraHardwareStub的处理方法如下：
代码5-7 CameraHardwareStub拍摄照片的过程
int CameraHardwareStub::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 * 2 * h);
FakeCamera cam(w,h);
cam.getNextFrameAsYuv422((uint8_t *)mRawHeap->base());//获取数据缓冲
mDataCb(CAMERA_MSG_RAW_IMAGE, mem, mCallbackCookie);
}
if (mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE) {
sp< MemoryHeapBase> heap=new MemoryHeapBase(kCannedJpegSize);
sp< MemoryBase> mem=new MemoryBase(heap,0,kCannedJpegSize);
memcpy(heap->base(),kCannedJpeg, kCannedJpegSize);//填充假图片数据
mDataCb(CAMERA_MSG_COMPRESSED_IMAGE,mem,mCallbackCookie);
}
return NO_ERROR;
}
当然在真实终端环境下，基于CameraHardwareInterface的实现必须通过和Camera驱动进行通信来获得真实数据。其实现和CameraHardwareStub存在着差异。下面为QualcommCameraHardware公开的JPEG编码过程：
代码5-8 QualcommCameraHardware编码的过程
unsigned char QualcommCameraHardware::native_jpeg_encode (
void *pDim,
int pmemThumbnailfd,
int pmemSnapshotfd,
unsigned char *thumbnail_buf,
unsigned char *main_img_buf, //存放拍摄的元数据缓冲
void *pCrop)
{
char jpegFileName[256]={0};
static int snapshotCntr=0;
cam_ctrl_dimension_t *dimension=(cam_ctrl_dimension_t *)pDim;
common_crop_t *cropInfo=(common_crop_t *)pCrop;
sprintf(jpegFileName, "snapshot_%d.jpg", ++snapshotCntr);//获得文件名
#ifndef SURF8K
LOGV("native_jpeg_encode , current jpeg main img quality =%d", mParameters.getJpeg MainimageQuality());
//设置图像质量
if (! LINK_jpeg_encoder_setMainImageQuality(mParameters.getJpegMainimageQuality()))
{
LOGE("native_jpeg_encode set jpeg main image quality :%d@%s: jpeg_encoder_encode failed.\n",__LINE__, __FILE__);
return FALSE;
}
#endif
//调用libmmcamera.so中的jpeg_encoder_encode进行解码
if ( !LINK_jpeg_encoder_encode(jpegFileName, dimension,thumbnail_buf, pmemThumbnailfd,main_img_buf, pmemSnapshotfd, cropInfo))
{
LOGV("native_jpeg_encode:%d@%s: jpeg_encoder_encode failed.\n", __LINE__, __FILE__);
return FALSE;
}
return TRUE;
}
在Qualcomm的实现中，底层的细节被封装在名为libmmcamera.so和libmmcamera_ target.so的共享库中，代码并没有公开。