Android Camera HAL3 分析

1

Android Camera HAL3 分析

本文均属自己阅读源码的点滴总结，转账请注明出处谢谢。

欢迎和大家交流。qq:1037701636 email:gzzaigcn2009@https://www.360docs.net/doc/5f2216933.html,

Software ：系统源码Android 5.1

Camera3研读前沿：

当初在研读Camera1.0相关的内容时，主要围绕着CameraClient 、

CameraHardwareInterface 等方面进行工作的开展，无论是数据流还是控制流看起来都很简单、明了，一系列的流程化操作使得整个框架学起来特别的容易。因为没有Camera2.0相关的基础，所以这次直接看3.0相关的源码时，显得十分的吃紧，再加上底层高通HAL3.0实现的过程也是相当的复杂，都给整个研读过程带来了很多的困难。可以说，自身目前对Camera3.0框架的熟悉度也大概只有70%左右，希望通过总结来进一步梳理他的工作原理与整个框架，并进一步熟悉与加深理解。

1.Camera3下的整体架构图。

整个CameraService 建立起一个可用操作底层Camera device 大致需要经过

Camera2Client 、Camera3Device 以及HAL 层的camera3_device_t 三个部分。

2

从上图中可以发现Camera3架构看上去明显比camera1来的复杂，但他更加的

模块化。对比起Android4.2.2 Camer 系统架构图（HAL 和回调处理）一文中描述的

单顺序执行流程，Camera3将更多的工作集中在了Framework 去完成，将更多的控

制权掌握在自己的手里，从而与HAL 的交互的数据信息更少，也进一步减轻了一

些在旧版本中HAL 层所需要做的事情。

2. Camera2Client 的建立与初始化过程

在建立好Camera2Client 后会进行initialize 操作，完成各个处理模块的创建：

?

1

2

3 .... mStreamingProcessor = new StreamingProcessor(this);//preview 和recorder threadName = String8::format(C2-%d-StreamProc,

mCameraId);

4 5 6 7 8 9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25 mStreamingProcessor->run(threadName.string());//预览与录像

mFrameProcessor = new FrameProcessor(mDevice, this);// 3A

threadName = String8::format(C2-%d-FrameProc,

mCameraId);

mFrameProcessor->run(threadName.string()); //3A

mCaptureSequencer = new CaptureSequencer(this);

threadName = String8::format(C2-%d-CaptureSeq,

mCameraId);

mCaptureSequencer->run(threadName.string());//录像，拍照

mJpegProcessor = new JpegProcessor(this, mCaptureSequencer); threadName = String8::format(C2-%d-JpegProc,

mCameraId);

mJpegProcessor->run(threadName.string());

....

mCallbackProcessor = new CallbackProcessor(this);//回调处理

threadName = String8::format(C2-%d-CallbkProc,

mCameraId);

mCallbackProcessor->run(threadName.string());

依次分别创建了：

StreamingProcessor并启动一个他所属的thread，该模块主要负责处理previews 与record两种视频流的处理，用于从hal层获取原始的视频数据

FrameProcessor并启动一个thread，该模块专门用于处理回调回来的每一帧的3A等信息，即每一帧视频除去原始视频数据外，还应该有其他附加的数据信息，如3A值。

CaptureSequencer并启动一个thread，该模块需要和其他模块配合使用，主要用于向APP层告知capture到的picture。

JpegProcessor并启动一个thread，该模块和streamprocessor类似，他启动一个拍照流，一般用于从HAL层获取jpeg编码后的图像照片数据。

此外ZslProcessor模块称之为0秒快拍，其本质是直接从原始的Preview流中获取预存着的最近的几帧，直接编码后返回给APP，而不需要再经过take picture 去请求获取jpeg数据。0秒快拍技术得意于当下处理器CSI2 MIPI性能的提升以及Sensor支持全像素高帧率的实时输出。一般手机拍照在按下快门后都会有一定的延时，是因为需要切换底层Camera以及ISP等的工作模式，并重新设置参数以及重新对焦等等，都需要花一定时间后才抓取一帧用于编码为jpeg图像。

以上5个模块整合在一起基本上实现了Camera应用开发所需的基本业务功能。

3

3. 预览Preview下的控制流

研读Camera具体的业务处理功能，一般从视频实时预览Preview入手。一般熟悉Camera架构的人，可以从一个app端的一个api一直连续打通到底层hal的一个控制命令。大致可以如下图所示：

对于preview部分到CameraService的控制流可以参考博文Android4.2.2的preview的数据流和控制流以及最终的预览显示，本文将直接从

Camera2Client::startPreview() 作为入口来分析整个Framework层中Preview相关的数据流。

?

1 2 3 4 5 6 7 8 9 status_t Camera2Client::startPreview() {

ATRACE_CALL();

ALOGV(%s: E, __FUNCTION__);

Mutex::Autolock icl(mBinderSerializationLock);

status_t res;

if( (res = checkPid(__FUNCTION__) ) != OK) return res; SharedParameters::Lock l(mParameters);

return startPreviewL(l.mParameters, false);

}

startPreview通过startPreviewL提取参数后真正的开始执行Preview相关的控制流。该函数看上去内容虽然较多，但基本采用了同一种处理方式：

?

4

1

2 3 4 5 6 7 8 9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48 status_t Camera2Client::startPreviewL(Parameters ?ms, bool restart) {//restart == false

ATRACE_CALL();

status_t res;

......

int lastPreviewStreamId = mStreamingProcessor->getPreviewStreamId();//获取上一层Preview stream id

res = mStreamingProcessor->updatePreviewStream(params);//创建camera3device stream， Camera3OutputStream .....

int lastJpegStreamId = mJpegProcessor->getStreamId();

res = updateProcessorStream(mJpegProcessor, params);//预览启动时就建立一个jpeg的outstream

.....

res = mCallbackProcessor->updateStream(params);//回调处理建立一个Camera3outputstream

if(res != OK) {

ALOGE(%s: Camera %d: Unable to update callback stream: %s (%d),

__FUNCTION__, mCameraId, strerror(-res), res);

return res;

}

outputStreams.push(getCallbackStreamId());

......

outputStreams.push(getPreviewStreamId());//预览stream

......

if(!params.recordingHint) {

if(!restart) {

res = mStreamingProcessor->updatePreviewRequest(params);//request处理,更新了mPreviewrequest

if(res != OK) {

ALOGE(%s: Camera %d: Can't set up preview request:

%s (%d), __FUNCTION__, mCameraId,

strerror(-res), res);

return res;

}

}

res = mStreamingProcessor->startStream(StreamingProcessor::PREVIEW,

outputStreams);//启动stream，传入outputStreams即stream 的id

} else{

if(!restart) {

res = mStreamingProcessor->updateRecordingRequest(params);

if(res != OK) {

ALOGE(%s: Camera %d: Can't set up preview request with

record hint: %s (%d), __FUNCTION__, mCameraId,

strerror(-res), res);

return res;

}

}

res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,

outputStreams);

}

......

}

(1). mStreamingProcessor->updatePreviewStream()

由预览与录像处理模块更新一个预览流，其实现过程如下：?

1 2 3 4 5 6 7 8 9

10

11 status_t StreamingProcessor::updatePreviewStream(const Parameters ?ms) { ATRACE_CALL();

Mutex::Autolock m(mMutex);

status_t res;

sp device = mDevice.promote();//Camera3Device

if(device == 0) {

ALOGE(%s: Camera %d: Device does not exist, __FUNCTION__, mId); return INVALID_OPERATION;

}

if(mPreviewStreamId != NO_STREAM) {

// Check if stream parameters have to change

5

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56 uint32_t currentWidth, currentHeight;

res = device->getStreamInfo(mPreviewStreamId,

¤tWidth, ¤tHeight, 0);

if(res != OK) {

ALOGE(%s: Camera %d: Error querying preview stream info:

%s (%d), __FUNCTION__, mId, strerror(-res), res);

return res;

}

if(currentWidth != (uint32_t)params.previewWidth ||

currentHeight != (uint32_t)params.previewHeight) {

ALOGV(%s: Camera %d: Preview size switch: %d x %d -> %d x %d,

__FUNCTION__, mId, currentWidth, currentHeight,

params.previewWidth, params.previewHeight);

res = device->waitUntilDrained();

if(res != OK) {

ALOGE(%s: Camera %d: Error waiting for preview to drain:

%s (%d), __FUNCTION__, mId, strerror(-res), res);

return res;

}

res = device->deleteStream(mPreviewStreamId);

if(res != OK) {

ALOGE(%s: Camera %d: Unable to delete old output stream

for preview: %s (%d), __FUNCTION__, mId,

strerror(-res), res);

return res;

}

mPreviewStreamId = NO_STREAM;

}

}

if(mPreviewStreamId == NO_STREAM) {//首次create stream

res = device->createStream(mPreviewWindow,

params.previewWidth, params.previewHeight,

CAMERA2_HAL_PIXEL_FORMAT_OPAQUE, &mPreviewStreamId);//创建一个Camera if(res != OK) {

ALOGE(%s: Camera %d: Unable to create preview stream: %s (%d),

__FUNCTION__, mId, strerror(-res), res);

return res;

}

}

res = device->setStreamTransform(mPreviewStreamId,

params.previewTransform);

if(res != OK) {

ALOGE(%s: Camera %d: Unable to set preview stream transform:

%s (%d), __FUNCTION__, mId, strerror(-res), res);

return res;

}

return OK;

}

6

57

58

59

60

61

62

63

64

65

该函数首先是查看当前StreamingProcessor模块下是否存在Stream，没有的话，则交由Camera3Device创建一个stream。显然，一个StreamingProcessor只能拥有一个PreviewStream，而一个Camera3Device显然控制着所有的Stream。

注意：在Camera2Client中，Stream大行其道，5大模块的数据交互均以stream作为基础。

下面我们来重点关注Camera3Device的接口createStream，他是5个模块创建stream的基础：

?

1 2 3 4 5 6 7 8 9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24 status_t Camera3Device::createStream(sp consumer,

uint32_t width, uint32_t height, int format, int*id) {

ATRACE_CALL();

Mutex::Autolock il(mInterfaceLock);

Mutex::Autolock l(mLock);

ALOGV(Camera %d: Creating new stream %d: %d x %d, format %d,

mId, mNextStreamId, width, height, format);

status_t res;

bool wasActive = false;

switch(mStatus) {

case STATUS_ERROR:

CLOGE(Device has encountered a serious error);

return INVALID_OPERATION;

case STATUS_UNINITIALIZED:

CLOGE(Device not initialized);

return INVALID_OPERATION;

case STATUS_UNCONFIGURED:

case STATUS_CONFIGURED:

// OK

break;

case STATUS_ACTIVE:

ALOGV(%s: Stopping activity to reconfigure streams, __FUNCTION__); res = internalPauseAndWaitLocked();

if(res != OK) {

SET_ERR_L(Can't pause captures to reconfigure streams!);

return res;

}

7

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69 wasActive = true;

break;

default:

SET_ERR_L(Unexpected status: %d, mStatus);

return INVALID_OPERATION;

}

assert(mStatus != STATUS_ACTIVE);

sp newStream;

if(format == HAL_PIXEL_FORMAT_BLOB) {//图片

ssize_t jpegBufferSize = getJpegBufferSize(width, height);

if(jpegBufferSize <= 0) {

SET_ERR_L(Invalid jpeg buffer size %zd, jpegBufferSize);

return BAD_VALUE;

}

newStream = new Camera3OutputStream(mNextStreamId, consumer,

width, height, jpegBufferSize, format);//jpeg 缓存的大小

} else{

newStream = new Camera3OutputStream(mNextStreamId, consumer,

width, height, format);//Camera3OutputStream

}

newStream->setStatusTracker(mStatusTracker);

res = mOutputStreams.add(mNextStreamId, newStream);//

一个streamid与Camera3OutputStream绑定

if(res < 0) {

SET_ERR_L(Can't add new stream to set: %s (%d), strerror(-res), res); return res;

}

*id = mNextStreamId++;//至少一个previewstream 一般还有CallbackStream

mNeedConfig = true;

// Continue captures if active at start

if(wasActive) {

ALOGV(%s: Restarting activity to reconfigure streams, __FUNCTION__); res = configureStreamsLocked();

if(res != OK) {

CLOGE(Can't reconfigure device for new stream %d: %s (%d),

mNextStreamId, strerror(-res), res);

return res;

}

internalResumeLocked();

}

ALOGV(Camera %d: Created new stream, mId);

return OK;

}

8

70

71

72

73

74

75

76

该函数重点是关注一个new Camera3OutputStream，在Camera3Device主要存在Camera3OutputStream和Camera3InputStream

两种stream，前者主要作为HAL的输出，是请求HAL填充数据的OutPutStream，后者是由Framework将Stream进行填充。无论是Preview、record还是capture均是从HAL层获取数据，故都会以OutPutStream的形式存在，是我们关注的重点，后面在描述Preview的数据流时还会进一步的阐述。

每当创建一个OutPutStream后，相关的stream信息被push维护在一个mOutputStreams的KeyedVector >表中，分别是该stream在Camera3Device中创建时的ID以及Camera3OutputStream的sp值。同时对mNextStreamId记录下一个Stream的ID号。

上述过程完成StreamingProcessor模块中一个PreviewStream的创建，其中Camera3OutputStream创建时的ID值被返回记录作为mPreviewStreamId的值，此外每个Stream都会有一个对应的ANativeWindow，这里称之为Consumer。

（2）mCallbackProcessor->updateStream(params)

对比StreamingProcessor模块创建previewstream的过程，很容易定位到Callback模块是需要建立一个callback流，同样需要创建一个

Camera3OutputStream来接收HAL返回的每一帧帧数据，是否需要callback可以通过callbackenable来控制。一般但预览阶段可能不需要回调每一帧的数据到APP，但涉及到相应的其他业务如视频处理时，就需要进行callback的enable。

?

1 2 3 4 5 6 7 8 9 status_t CallbackProcessor::updateStream(const Parameters ?ms) {

ATRACE_CALL();

status_t res;

Mutex::Autolock l(mInputMutex);

sp device = mDevice.promote();

if(device == 0) {

ALOGE(%s: Camera %d: Device does not exist, __FUNCTION__, mId); return INVALID_OPERATION;

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54 }

// If possible, use the flexible YUV format

int32_t callbackFormat = params.previewFormat;

if(mCallbackToApp) {

// TODO: etalvala: This should use the flexible YUV format as well, but

// need to reconcile HAL2/HAL3 requirements.

callbackFormat = HAL_PIXEL_FORMAT_YV12;

} else if(https://www.360docs.net/doc/5f2216933.html,eFlexibleYuv &&

(params.previewFormat == HAL_PIXEL_FORMAT_YCrCb_420_SP ||

params.previewFormat == HAL_PIXEL_FORMAT_YV12) ) {

callbackFormat = HAL_PIXEL_FORMAT_YCbCr_420_888;

}

if(!mCallbackToApp && mCallbackConsumer == 0) {

// Create CPU buffer queue endpoint, since app hasn't given us one

// Make it async to avoid disconnect deadlocks

sp producer;

sp consumer;

BufferQueue::createBufferQueue(&producer, &consumer);//BufferQueueProducer mCallbackConsumer = new CpuConsumer(consumer, kCallbackHeapCount);

mCallbackConsumer->setFrameAvailableListener(this);//当前CallbackProcessor CpuConsumer::FrameAvailableListener

mCallbackConsumer->setName(String8(Camera2Client::CallbackConsumer));

mCallbackWindow = new Surface(producer);//用于queue操作，这里直接进行本地的buf }

if(mCallbackStreamId != NO_STREAM) {

// Check if stream parameters have to change

uint32_t currentWidth, currentHeight, currentFormat;

res = device->getStreamInfo(mCallbackStreamId,

¤tWidth, ¤tHeight, ¤tFormat);

if(res != OK) {

ALOGE(%s: Camera %d: Error querying callback output stream info:

%s (%d), __FUNCTION__, mId,

strerror(-res), res);

return res;

}

if(currentWidth != (uint32_t)params.previewWidth ||

currentHeight != (uint32_t)params.previewHeight ||

currentFormat != (uint32_t)callbackFormat) {

// Since size should only change while preview is not running,

// assuming that all existing use of old callback stream is

// completed.

ALOGV(%s: Camera %d: Deleting stream %d since the buffer

parameters changed, __FUNCTION__, mId, mCallbackStreamId);

res = device->deleteStream(mCallbackStreamId);

if(res != OK) {

ALOGE(%s: Camera %d: Unable to delete old output stream

for callbacks: %s (%d), __FUNCTION__,

mId, strerror(-res), res);

return res;

}

mCallbackStreamId = NO_STREAM;

10

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83 }

}

if(mCallbackStreamId == NO_STREAM) {

ALOGV(Creating callback stream: %d x %d, format 0x%x, API format 0x%x, params.previewWidth, params.previewHeight,

callbackFormat, params.previewFormat);

res = device->createStream(mCallbackWindow,

params.previewWidth, params.previewHeight,

callbackFormat, &mCallbackStreamId);//Creating callback stream if(res != OK) {

ALOGE(%s: Camera %d: Can't create output stream for callbacks:

%s (%d), __FUNCTION__, mId,

strerror(-res), res);

return res;

}

}

return OK;

}

对比updatePreviewStream可以发现，该函数自助创建了一套

surface/BufferQueue/CpuConsumer的机制，这套类似SurfaceFlinger的buffer管理机制可参看一文Android5.1中surface生产者和消费者间的处理框架简述。此外通过createStream请求Camera3Device建立一个Stream，其中Stream的ID值保存在mCallBackStreamId当中，并将一个CallbackWindow和当前的Stream绑定。

通过这个对比，也需要重点关注到，对于每个Camera3OutPutStream来说，每一个stream都被一个Consumer，而在此处都是Surface(ANativeWindow)所拥有，这个Consumer和HAL相匹配来说是消费者，但对于真正的处理Buffer的Consumer来说如CPUConsumer，Surface却又是以一个Product的角色存在的。

（3）updateProcessorStream(mJpegProcessor, params)

11

? 1

2 3 4 5 6 7 8 9

10

11

12

13

14

15

16 status_t Camera2Client::updateProcessorStream(sp processor,

camera2::Parameters params) { // No default template arguments until C++11, so we need this overload return updateProcessorStream( processor, params);

}

template

status_t Camera2Client::updateProcessorStream(sp processor,

Parameters params) {

status_t res;

// Get raw pointer since sp doesn't have operator->*

ProcessorT *processorPtr = processor.get();

res = (processorPtr->*updateStreamF)(params);

.......

}

该模板函数处理过程最终通过非显示实例到显示实例调用

JpegProcessor::updateStream，该函数处理的逻辑基本和Callback模块处理一致，创建的一个OutPutStream和CaptureWindow相互绑定，同时Stream的ID保存在mCaptureStreamId中。

此外需要说明一点：

在preview模式下，就去创建一个jpeg处理的stream，目的在于启动takepicture时，可以更快的进行capture操作。是通过牺牲内存空间来提升效率。

（4）整合startPreviewL中所有的stream 到Vector outputStreams

outputStreams.push(getPreviewStreamId());//预览stream

outputStreams.push(getCallbackStreamId())//Callback stream

目前一次Preview构建的stream数目至少为两个。

（5）mStreamingProcessor->updatePreviewRequest()

在创建好多路stream后，由StreamingProcessor模块来将所有的stream信息交由Camera3Device去打包成Request请求。

注意：

12

Camera HAL2/3的特点是：将所有stream的请求都转化为几个典型的Request 请求，而这些Request需要由HAL去解析，进而处理所需的业务。这也是Camera3数据处理复杂化的原因所在。

?

1 2 3 4 5 6 7 8 9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39 status_t StreamingProcessor::updatePreviewRequest(const Parameters ?ms) {

ATRACE_CALL();

status_t res;

sp device = mDevice.promote();

if(device == 0) {

ALOGE(%s: Camera %d: Device does not exist, __FUNCTION__, mId);

return INVALID_OPERATION;

}

Mutex::Autolock m(mMutex);

if(mPreviewRequest.entryCount() == 0) {

sp client = mClient.promote();

if(client == 0) {

ALOGE(%s: Camera %d: Client does not exist, __FUNCTION__, mId);

return INVALID_OPERATION;

}

// Use CAMERA3_TEMPLATE_ZERO_SHUTTER_LAG for ZSL streaming case.

if(client->getCameraDeviceVersion() >= CAMERA_DEVICE_API_VERSION_3_0) {

if(params.zslMode && !params.recordingHint) {

res = device->createDefaultRequest(CAMERA3_TEMPLATE_ZERO_SHUTTER_LA &mPreviewRequest);

} else{

res = device->createDefaultRequest(CAMERA3_TEMPLATE_PREVIEW,

&mPreviewRequest);

}

} else{

res = device->createDefaultRequest(CAMERA2_TEMPLATE_PREVIEW,

&mPreviewRequest);

//创建一个Preview相关的request，由底层的hal来完成default创建

}

if(res != OK) {

ALOGE(%s: Camera %d: Unable to create default preview request:

%s (%d), __FUNCTION__, mId, strerror(-res), res);

return res;

}

}

res = params.updateRequest(&mPreviewRequest);//根据参数来更新CameraMetadata requ if(res != OK) {

ALOGE(%s: Camera %d: Unable to update common entries of preview

request: %s (%d), __FUNCTION__, mId,

strerror(-res), res);

return res;

}

13

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57 res = mPreviewRequest.update(ANDROID_REQUEST_ID,

&mPreviewRequestId, 1);//mPreviewRequest的ANDROID_REQUEST_ID

if(res != OK) {

ALOGE(%s: Camera %d: Unable to update request id for preview: %s (%d), __FUNCTION__, mId, strerror(-res), res);

return res;

}

return OK;

}

该函数的处理过程是一个构建并初始化mPreviewRequest的过程，分以下几个流程来分析：

a mPreviewRequest是一个CameraMetadata类型数据，用于封装当前previewRequest。

b device->createDefaultRequest(CAMERA3_TEMPLATE_PREVIEW,

&mPreviewRequest)

?

1

2 3 4 5 6 7 8 9

10

11

12 const camera_metadata_t *rawRequest;

ATRACE_BEGIN(camera3->construct_default_request_settings);

rawRequest = mHal3Device->ops->construct_default_request_settings(

mHal3Device, templateId);

ATRACE_END();

if(rawRequest == NULL) {

SET_ERR_L(HAL is unable to construct default settings for template %d, templateId);

return DEAD_OBJECT;

}

*request = rawRequest;

mRequestTemplateCache[templateId] = rawRequest;

14

最终是由hal来实现构建一个rawrequest,即对于Preview，而言是构建了一个CAMERA3_TEMPLATE_PREVIEW类型的Request。其实对HAL而言，rawrequest本质是用于操作一个camera_metadata_t类型的数据：

?

1

2 3 4 5 6 7 8 9

10

11

12 struct camera_metadata {

metadata_size_t size;

uint32_t version;

uint32_t flags;

metadata_size_t entry_count;

metadata_size_t entry_capacity;

metadata_uptrdiff_t entries_start; // Offset from camera_metadata metadata_size_t data_count;

metadata_size_t data_capacity;

metadata_uptrdiff_t data_start; // Offset from camera_metadata

uint8_t reserved[];

};

该数据结构可以存储多种数据，且可以根据entry tag的不同类型来存储数据，同时数据量的大小也可以自动调整。

c mPreviewRequest.update(ANDROID_REQUEST_ID,&mPreviewRequestId, 1)

将当前的PreviewRequest相应的ID保存到camera metadata。

（6）mStreamingProcessor->startStream启动整个预览的stream流该函数的处理过程较为复杂，可以说是整个Preview正常工作的核心控制

?

1 2 3 4 5 6 7 8 9

10

11 status_t StreamingProcessor::startStream(StreamType type,

const Vector &outputStreams) {

.....

CameraMetadata &request = (type == PREVIEW) ?

mPreviewRequest : mRecordingRequest;//取preview的CameraMetadata request

....res = request.update(

ANDROID_REQUEST_OUTPUT_STREAMS,

outputStreams);//CameraMetadata中添加outputStreams

res = device->setStreamingRequest(request);//向hal发送request

.....

}

15

该函数首先是根据当前工作模式来确定StreamingProcessor需要处理的Request，该模块负责Preview和Record两个Request。

以PreviewRequest就是之前createDefaultRequest构建的，这里先是将这个Request所需要操作的Outputstream打包到一个tag叫

ANDROID_REQUEST_OUTPUT_STREAMS的entry当中。

a:setStreamingRequest

真正的请求Camera3Device去处理这个带有多路stream的PreviewRequest。

?

1 2 3 4 5 6 7 8 status_t Camera3Device::setStreamingRequest(const CameraMetadata &request, int64_t* /*lastFrameNumber*/) { ATRACE_CALL();

List requests;

requests.push_back(request);

return setStreamingRequestList(requests, /*lastFrameNumber*/NULL);

}

该函数将mPreviewRequest push到一个list，调用setStreamingRequestList ?

1 2 3 4 5 6 status_t Camera3Device::setStreamingRequestList(const List & int64_t *lastFrameNumber) {

ATRACE_CALL();

return submitRequestsHelper(requests, /*repeating*/true, lastFrameNumber);

}

?

1 2 3 4 5 6 7 8 9 10 status_t Camera3Device::submitRequestsHelper(

const List &requests, bool repeating,

/*out*/

int64_t *lastFrameNumber) {//repeating = 1;lastFrameNumber = NULL ATRACE_CALL();

Mutex::Autolock il(mInterfaceLock);

Mutex::Autolock l(mLock);

status_t res = checkStatusOkToCaptureLocked();

if(res != OK) {

// error logged by previous call

return res;

16

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44 }

RequestList requestList;

res = convertMetadataListToRequestListLocked(requests, /*out*/&requestList);//返RequestList

if(res != OK) {

// error logged by previous call

return res;

}

if(repeating) {

res = mRequestThread->setRepeatingRequests(requestList, lastFrameNumber);// } else{

res = mRequestThread->queueRequestList(requestList, lastFrameNumber);//capt }

if(res == OK) {

waitUntilStateThenRelock(/*active*/true, kActiveTimeout);

if(res != OK) {

SET_ERR_L(Can't transition to active in %f seconds!,

kActiveTimeout/1e9);

}

ALOGV(Camera %d: Capture request % PRId32 enqueued, mId,

(*(requestList.begin()))->mResultExtras.requestId);

} else{

CLOGE(Cannot queue request. Impossible.);

return BAD_VALUE;

}

return res;

}

b convertMetadataListToRequestListLocked

这个函数是需要将Requestlist中保存的CameraMetadata数据转换为List

?

1 2 3 status_t Camera3Device::convertMetadataListToRequestListLocked(

const List &metadataList, RequestList *requestList) if(requestList == NULL) {

17

18

4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

35 36

CLOGE(requestList cannot be NULL.); return BAD_VALUE; } int32_t burstId = 0; for (List::const_iterator it = metadataList.begin();//C it != metadataList.end(); ++it) {

sp newRequest = setUpRequestLocked(*it);//

新建CaptureReques if (newRequest == 0) {

CLOGE(Can't create capture request);

return BAD_VALUE;

} // Setup burst Id and request Id newRequest->mResultExtras.burstId = burstId++;

if (it->exists(ANDROID_REQUEST_ID)) {

if (it->find(ANDROID_REQUEST_ID).count == 0) {

CLOGE(RequestID entry exists; but must not be empty in metadata);

return BAD_VALUE; } newRequest->mResultExtras.requestId = it->find(ANDROID_REQUEST_ID).data id } else {

CLOGE(RequestID does not exist in metadata);

return BAD_VALUE;

} requestList->push_back(newRequest); ALOGV(%s: requestId = % PRId32, __FUNCTION__, newRequest->mResultExtras.req }

return OK;

}

这里是对List 进行迭代解析处理，如当前模式下仅存在PreviewRequest 这一个

CameraMetadata ，通过setUpRequestLocked 将其转换为一个CaptureRequest 。

c 重点来关注setUpRequestLocke

d 复杂的处理过程

1 2

3

4

sp Camera3Device::setUpRequestLocked(

const CameraMetadata &request) {//mPreviewRequest

status_t res; if (mStatus == STATUS_UNCONFIGURED || mNeedConfig) {

5 6 7 8 9 10 res = configureStreamsLocked();

......

sp newRequest = createCaptureRequest(request);//Camera mOutputStreams

return newRequest;

}

configureStreamsLocked函数主要是将Camera3Device侧建立的所有Stream包括Output与InPut格式的交由HAL3层的Device去实现处理的核心接口是configure_streams与register_stream_buffer。该部分内容会涉及到更多的数据流，详细的处理过程会放在下一博文中进行分析。

createCaptureRequest函数是将一个CameraMetadata格式的数据如PreviewRequest转换为

1 2 3 4 5 6 7 8 9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27 sp Camera3Device::createCaptureRequest(

const CameraMetadata &request) {//mPreviewRequest

ATRACE_CALL();

status_t res;

sp newRequest = new CaptureRequest;

newRequest->mSettings = request;//CameraMetadata

camera_metadata_entry_t inputStreams =

newRequest->mSettings.find(ANDROID_REQUEST_INPUT_STREAMS);

if(inputStreams.count > 0) {

if(mInputStream == NULL ||

mInputStream->getId() != inputStreams.data.i32[0]) {

CLOGE(Request references unknown input stream %d,

inputStreams.data.u8[0]);

return NULL;

}

// Lazy completion of stream configuration (allocation/registration) // on first use

if(mInputStream->isConfiguring()) {

res = mInputStream->finishConfiguration(mHal3Device);

if(res != OK) {

SET_ERR_L(Unable to finish configuring input stream %d:

%s (%d),

mInputStream->getId(), strerror(-res), res);

return NULL;

}

}

newRequest->mInputStream = mInputStream;

newRequest->mSettings.erase(ANDROID_REQUEST_INPUT_STREAMS);

}

19

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67 camera_metadata_entry_t streams =

newRequest->mSettings.find(ANDROID_REQUEST_OUTPUT_STREAMS);//读取存储在C 息

if(streams.count == 0) {

CLOGE(Zero output streams specified!);

return NULL;

}

for(size_t i = 0; i < streams.count; i++) {

int idx = mOutputStreams.indexOfKey(streams.data.i32[i]);//Camera3OutputStr if(idx == NAME_NOT_FOUND) {

CLOGE(Request references unknown stream %d,

streams.data.u8[i]);

return NULL;

}

sp stream =

mOutputStreams.editValueAt(idx);//返回的是Camera3OutputStream，previ // Lazy completion of stream configuration (allocation/registration)

// on first use

if(stream->isConfiguring()) {//STATE_IN_CONFIG或者STATE_IN_RECONFIG

res = stream->finishConfiguration(mHal3Device);//register_stream_buffer if(res != OK) {

SET_ERR_L(Unable to finish configuring stream %d: %s (%d),

stream->getId(), strerror(-res), res);

return NULL;

}

}

newRequest->mOutputStreams.push(stream);//Camera3OutputStream添加到CaptureR }

newRequest->mSettings.erase(ANDROID_REQUEST_OUTPUT_STREAMS);

return newRequest;

}

该函数主要处理指定的这个CameraMetadata mPreviewRequest下对应所拥有的Output与Input Stream，对于Preview而言，至少存在OutPutStream包括一路StreamProcessor与一路可选的CallbackProcessor。

20