Android Camera 通过V4L2与kernel driver的完整交互过程

之前在 Android Camera 的执行流程 http://blog.chinaunix.net/uid-26765074-id-3499537.html 这篇文章中已经详细介绍了
Android Camera app到调用open打开camera 设备的完成过程，但是只是到此为止，并未对较底层的操作控制等做任何分析，
今天就要进入这个环节了

这里就直接从open那个方法开始了，先说一下这个open是怎么被调用的

实例化Camera Hal接口 hardware，hardware调用initialize()进入HAL层打开Camear驱动。
CameraHardwareInterface中initialize()定义在以下路径:frameworks/base/services/camera/libcameraservice/CameraHardwareInterface.h

代码如下：

status_t initialize(hw_module_t *module)
{
LOGI("Opening camera %s", mName.string());
int rc = module->methods->open(module, mName.string(),(hw_device_t **)&mDevice);
if (rc != OK) {
LOGE("Could not open camera %s: %d", mName.string(), rc);
return rc;
}
#ifdef OMAP_ENHANCEMENT_CPCAM
initHalPreviewWindow(&mHalPreviewWindow);
initHalPreviewWindow(&mHalTapin);
initHalPreviewWindow(&mHalTapout);
#else
initHalPreviewWindow();
#endif
return rc;
}
此处通过module->method->open()方法真正打开Camera设备,

其中module的定义在以下路径:frameworks/base/services/camera/libcameraservice/CameraService.h

class CameraService :
public BinderService<CameraService>,
public BnCameraService
{

class Client : public BnCamera
{
public:
......

private:

.....

};

camera_module_t *mModule;

};

此处还必须找到camera_module_t的定义,以更好的理解整个运行流程,通过追根溯源找到了camera_module_t定义,

camera_module_t的定义在以下路径:hardware/libhardware/include/hardware/camera.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);
} camera_module_t;
其中包含get_number_of_cameras方法和get_camera_info方法用于获取camera info

另外hw_module_t common;这个选项十分重要,此处应重点关注,因为是使用hw_module_t结构体中的open()方法打开设备文件的

继续找到hw_module_t 结构体的定义.在以下路径:hardware/libhardware/include/hardware/hardware.h

1. typedef struct hw_module_t{
   
2. /**tag must be initializedtoHARDWARE_MODULE_TAG*/
   
3. uint32_t tag;
   
4. 
   
5. /**major version numberforthe module*/
   
6. uint16_t version_major;
   
7. 
   
8. /**minor version number of the module*/
   
9. uint16_t version_minor;
   
10. 
    
11. /**Identifier of module*/
    
12. constchar*id;
    
13. 
    
14. /**Name of this module*/
    
15. constchar*name;
    
16. 
    
17. /**Author/owner/implementor of the module*/
    
18. constchar*author;
    
19. 
    
20. /**Modules methods*/
    
21. struct hw_module_methods_t*methods;
    
22. 
    
23. /**module's dso*/
    
24. void*dso;
    
25. 
    
26. /**paddingto128 bytes,reservedforfuture use*/
    
27. uint32_t reserved[32-7];
    
28. 
    
29. }hw_module_t;

1. typedef struct hw_module_methods_t{
   
2. /**Open a specific device*/
   
3. int(*open)(conststruct hw_module_t*module,constchar*id,
   
4. struct hw_device_t**device);
   
5. 
   
6. }hw_module_methods_t;

这里的这个open方法才是我们真正调用的open方法，那么这里只是定义，他又是在哪里实现的呢？？
这个问题我们还是需要往前面追溯啊，当然这在上一篇文章中也没有提到，不卖关子了，其实重点就是我们调用了这个module->methods->open(module, mName.string(),(hw_device_t **)&mDevice)方法
但是这个module是在哪里初始化的呢？看看CameraService类里的这个方法吧，路径：frameworks/base/services/camera/libcameraservice/CameraService.cpp

1. void CameraService::onFirstRef()
   
2. {
   
3. BnCameraService::onFirstRef();
   
4. 
   
5. if(hw_get_module(CAMERA_HARDWARE_MODULE_ID,
   
6. (consthw_module_t**)&mModule)<0){
   
7. LOGE("Could not load camera HAL module");
   
8. mNumberOfCameras=0;
   
9. }
   
10. else{
    
11. mNumberOfCameras=mModule->get_number_of_cameras();
    
12. if(mNumberOfCameras>MAX_CAMERAS){
    
13. LOGE("Number of cameras(%d) > MAX_CAMERAS(%d).",
    
14. mNumberOfCameras,MAX_CAMERAS);
    
15. mNumberOfCameras=MAX_CAMERAS;
    
16. }
    
17. for(inti=0;i<mNumberOfCameras;i++){
    
18. setCameraFree(i);
    
19. }
    
20. }
    
21. }

不错，这个module正是通过这个 hw_get_module方法获得的，其实他是通过方法中的 CAMERA_HARDWARE_MODULE_ID作为flag最终找到已经定义好的module，那么这个已经定义好的module又在哪呢，是什么样子的呢？
这里我就直接放在这里，不在拐弯抹角了，方法路径： hardware/ti/omap4xxx/camera/CameraHal_Module.cpp

1. staticintcamera_device_open(consthw_module_t*module,constchar*name,
   
2. hw_device_t**device);
   
3. staticintcamera_device_close(hw_device_t*device);
   
4. staticintcamera_get_number_of_cameras(void);
   
5. staticintcamera_get_camera_info(intcamera_id,struct camera_info*info);
   
6. 
   
7. static struct hw_module_methods_t camera_module_methods={
   
8. open:camera_device_open
   
9. };
   
10. 
    
11. camera_module_t HAL_MODULE_INFO_SYM={
    
12. common:{
    
13. tag:HARDWARE_MODULE_TAG,
    
14. version_major:1,
    
15. version_minor:0,
    
16. id:CAMERA_HARDWARE_MODULE_ID,
    
17. name:"TI OMAP CameraHal Module",
    
18. author:"TI",
    
19. methods:&camera_module_methods,
    
20. dso:NULL,/*remove compilation warnings*/
    
21. reserved:{0},/*remove compilation warnings*/
    
22. },
    
23. get_number_of_cameras:camera_get_number_of_cameras,
    
24. get_camera_info:camera_get_camera_info,
    
25. };

这里还是很关键的，通过id： CAMERA_HARDWARE_MODULE_ID 作为识别码找到这个module，get module完成任务，大家可以看到，这个定义好的module实现了methods中的open方法，
实现了 camera_get_number_of_cameras 和 camera_get_camera_info ，当然还包括了其他一些变量的初始化
这里开始我们找到了我们真正需要的open方法，万里长征走完一大步了，现在就去看看这个open方法干了些什么吧

1. /*open device handletoone of the cameras
   
2. *
   
3. *assume camera service will keep singleton ofeachcamera
   
4. *so thisfunctionwill always only be called once per camera instance
   
5. */
   
6. 
   
7. intcamera_device_open(consthw_module_t*module,constchar*name,
   
8. hw_device_t**device)
   
9. {
   
10. intrv=0;
    
11. intnum_cameras=0;
    
12. intcameraid;
    
13. ti_camera_device_t*camera_device=NULL;
    
14. camera_device_ops_t*camera_ops=NULL;
    
15. android::CameraHal*camera=NULL;
    
16. android::CameraProperties::Properties*properties=NULL;
    
17. 
    
18. android::Mutex::Autolock lock(gCameraHalDeviceLock);
    
19. 
    
20. CAMHAL_LOGI("camera_device open");
    
21. 
    
22. if(name!=NULL){
    
23. cameraid=atoi(name);
    
24. num_cameras=gCameraProperties.camerasSupported();
    
25. 
    
26. if(cameraid>num_cameras)
    
27. {
    
28. LOGE("camera service provided cameraid out of bounds, "
    
29. "cameraid = %d, num supported = %d",
    
30. cameraid,num_cameras);
    
31. rv=-EINVAL;
    
32. goto fail;
    
33. }
    
34. 
    
35. if(gCamerasOpen>=MAX_SIMUL_CAMERAS_SUPPORTED)
    
36. {
    
37. LOGE("maximum number of cameras already open");
    
38. rv=-ENOMEM;
    
39. goto fail;
    
40. }
    
41. 
    
42. camera_device=(ti_camera_device_t*)malloc(sizeof(*camera_device));
    
43. if(!camera_device)
    
44. {
    
45. LOGE("camera_device allocation fail");
    
46. rv=-ENOMEM;
    
47. goto fail;
    
48. }
    
49. 
    
50. camera_ops=(camera_device_ops_t*)malloc(sizeof(*camera_ops));
    
51. if(!camera_ops)
    
52. {
    
53. LOGE("camera_ops allocation fail");
    
54. rv=-ENOMEM;
    
55. goto fail;
    
56. }
    
57. 
    
58. memset(camera_device,0,sizeof(*camera_device));
    
59. memset(camera_ops,0,sizeof(*camera_ops));
    
60. 
    
61. camera_device->base.common.tag=HARDWARE_DEVICE_TAG;
    
62. camera_device->base.common.version=0;
    
63. camera_device->base.common.module=(hw_module_t*)(module);
    
64. camera_device->base.common.close=camera_device_close;
    
65. camera_device->base.ops=camera_ops;
    
66. 
    
67. camera_ops->set_preview_window=camera_set_preview_window;
    
68. #ifdef OMAP_ENHANCEMENT_CPCAM
    
69. camera_ops->set_buffer_source=camera_set_buffer_source;
    
70. #endif
    
71. camera_ops->set_callbacks=camera_set_callbacks;
    
72. camera_ops->enable_msg_type=camera_enable_msg_type;
    
73. camera_ops->disable_msg_type=camera_disable_msg_type;
    
74. camera_ops->msg_type_enabled=camera_msg_type_enabled;
    
75. camera_ops->start_preview=camera_start_preview;
    
76. camera_ops->stop_preview=camera_stop_preview;
    
77. camera_ops->preview_enabled=camera_preview_enabled;
    
78. camera_ops->store_meta_data_in_buffers=camera_store_meta_data_in_buffers;
    
79. camera_ops->start_recording=camera_start_recording;
    
80. camera_ops->stop_recording=camera_stop_recording;
    
81. camera_ops->recording_enabled=camera_recording_enabled;
    
82. camera_ops->release_recording_frame=camera_release_recording_frame;
    
83. camera_ops->auto_focus=camera_auto_focus;
    
84. camera_ops->cancel_auto_focus=camera_cancel_auto_focus;
    
85. camera_ops->take_picture=camera_take_picture;
    
86. camera_ops->cancel_picture=camera_cancel_picture;
    
87. camera_ops->set_parameters=camera_set_parameters;
    
88. camera_ops->get_parameters=camera_get_parameters;
    
89. camera_ops->put_parameters=camera_put_parameters;
    
90. camera_ops->send_command=camera_send_command;
    
91. camera_ops->release=camera_release;
    
92. camera_ops->dump=camera_dump;
    
93. #ifdef OMAP_ENHANCEMENT_CPCAM
    
94. camera_ops->reprocess=camera_reprocess;
    
95. camera_ops->cancel_reprocess=camera_cancel_reprocess;
    
96. #endif
    
97. 
    
98. *device=&camera_device->base.common;
    
99. 
    
100. //--------TI specific stuff--------
     
101. 
     
102. camera_device->cameraid=cameraid;
     
103. 
     
104. if(gCameraProperties.getProperties(cameraid,&properties)<0)
     
105. {
     
106. LOGE("Couldn't get camera properties");
     
107. rv=-ENOMEM;
     
108. goto fail;
     
109. }
     
110. 
     
111. camera=new android::CameraHal(cameraid);
     
112. 
     
113. if(!camera)
     
114. {
     
115. LOGE("Couldn't create instance of CameraHal class");
     
116. rv=-ENOMEM;
     
117. goto fail;
     
118. }
     
119. 
     
120. if(properties&&(camera->initialize(properties)!=android::NO_ERROR))
     
121. {
     
122. LOGE("Couldn't initialize camera instance");
     
123. rv=-ENODEV;
     
124. goto fail;
     
125. }
     
126. 
     
127. gCameraHals[cameraid]=camera;
     
128. gCamerasOpen++;
     
129. }
     
130. 
     
131. return rv;
     
132. 
     
133. fail:
     
134. if(camera_device){
     
135. free(camera_device);
     
136. camera_device=NULL;
     
137. }
     
138. if(camera_ops){
     
139. free(camera_ops);
     
140. camera_ops=NULL;
     
141. }
     
142. if(camera){
     
143. delete camera;
     
144. camera=NULL;
     
145. }
     
146. *device=NULL;
     
147. return rv;
     
148. }

看看这么长的代码，open的任务还是比较中的，没办法，能者多劳嘛，红色部分是最重点的部分
从这里可以知道，这里就像一个控制中心，上传调用到这里被分发出去，实现各自的操作，我们就以 startPreview 为例进行分析

1. intcamera_start_preview(struct camera_device*device)
   
2. {
   
3. intrv=-EINVAL;
   
4. ti_camera_device_t*ti_dev=NULL;
   
5. 
   
6. LOGV("%s",__FUNCTION__);
   
7. 
   
8. if(!device)
   
9. return rv;
   
10. 
    
11. ti_dev=(ti_camera_device_t*)device;
    
12. 
    
13. rv=gCameraHals[ti_dev->cameraid]->startPreview();
    
14. 
    
15. return rv;
    
16. }

这里每open一个device就会相应的创建并且初始化一个CameraHal 对象，定义在： hardware/ti/omap4xxx/camera/CameraHal.cpp
并且把这个对象保存在gCameraHals这个数组中，正因为这样这里 camera_start_preview 才可以通过这个数据检索对象调用方法
现在我们就看看这个 startPreview ( ) 方法是怎样实现的

1. /**
   
2. @brief Start preview mode.
   
3. 
   
4. @param none
   
5. @return NO_ERROR Camera switchedtoVF mode
   
6. @todo Updatefunctionheader with the different errors that are possible
   
7. 
   
8. */
   
9. status_t CameraHal::startPreview(){
   
10. LOG_FUNCTION_NAME;
    
11. 
    
12. //When tunnelingisenabled during VTC,startPreview happensin2 steps:
    
13. //When the application sends the command CAMERA_CMD_PREVIEW_INITIALIZATION,
    
14. //cameraPreviewInitialization()iscalled,whichinturn causes the CameraAdapter
    
15. //tomove from loadedtoidle state.Andwhen the application calls startPreview,
    
16. //the CameraAdapter moves from idletoexecuting state.
    
17. //
    
18. //Ifthe application calls startPreview()without sending the command
    
19. //CAMERA_CMD_PREVIEW_INITIALIZATION,thenthefunctioncameraPreviewInitialization()
    
20. //ANDstartPreview()are executed.Inother words,ifthe application calls
    
21. //startPreview()without sending the command CAMERA_CMD_PREVIEW_INITIALIZATION,
    
22. //thenthe CameraAdapter moves from loadedtoidletoexecuting stateinone shot.
    
23. status_t ret=cameraPreviewInitialization();
    
24. 
    
25. //The flag mPreviewInitializationDoneissettotrueat theendof thefunction
    
26. //cameraPreviewInitialization().Therefore,ifeverything goes alright,thenthe
    
27. //flag will beset.Sometimes,thefunctioncameraPreviewInitialization()may
    
28. //return prematurelyifall the resources arenotavailableforstarting preview.
    
29. //Forexample,ifthe previewwindowisnotset,thenit would return NO_ERROR.
    
30. //Under such circumstances,one should return from startPreview as wellandshould
    
31. //notcontinue execution.Thatiswhy,we check the flagandnotthe return value.
    
32. if(!mPreviewInitializationDone)return ret;
    
33. 
    
34. //Once startPreviewiscalled,thereisno needtocontinuetoremember whether
    
35. //thefunctioncameraPreviewInitialization()was called earlierornot.Andso
    
36. //the flag mPreviewInitializationDoneisreset here.Plus,this preserves the
    
37. //current behavior of startPreview under the circumstances where the application
    
38. //calls startPreview twiceormore.
    
39. mPreviewInitializationDone=false;
    
40. 
    
41. ///Enable the display adapterifpresent,actual overlay enable happens when we post the buffer
    
42. if(mDisplayAdapter.get()!=NULL){
    
43. CAMHAL_LOGDA("Enabling display");
    
44. intwidth,height;
    
45. mParameters.getPreviewSize(&width,&height);
    
46. 
    
47. #ifPPM_INSTRUMENTATION||PPM_INSTRUMENTATION_ABS
    
48. ret=mDisplayAdapter->enableDisplay(width,height,&mStartPreview);
    
49. #else
    
50. ret=mDisplayAdapter->enableDisplay(width,height,NULL);
    
51. #endif
    
52. 
    
53. if(ret!=NO_ERROR){
    
54. CAMHAL_LOGEA("Couldn't enable display");
    
55. 
    
56. //FIXME:At this stage mStateSwitchLockislockedandunlockissupposedtobe called
    
57. //only from mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_PREVIEW)
    
58. //below.But this will never happen because of gotoerror.Thus atnext
    
59. //startPreview()callCameraHAL will be deadlocked.
    
60. //Needtorevisit mStateSwitch lock,fornowjust abort the process.
    
61. CAMHAL_ASSERT_X(false,
    
62. "At this stage mCameraAdapter->mStateSwitchLock is still locked, "
    
63. "deadlock is guaranteed");
    
64. 
    
65. gotoerror;
    
66. }
    
67. 
    
68. }
    
69. 
    
70. ///Send START_PREVIEW commandtoadapter
    
71. CAMHAL_LOGDA("Starting CameraAdapter preview mode");
    
72. 
    
73. ret=mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_PREVIEW);
    
74. 
    
75. if(ret!=NO_ERROR){
    
76. CAMHAL_LOGEA("Couldn't start preview w/ CameraAdapter");
    
77. gotoerror;
    
78. }
    
79. CAMHAL_LOGDA("Started preview");
    
80. 
    
81. mPreviewEnabled=true;
    
82. mPreviewStartInProgress=false;
    
83. return ret;
    
84. 
    
85. error:
    
86. 
    
87. CAMHAL_LOGEA("Performing cleanup after error");
    
88. 
    
89. //Doall the cleanup
    
90. freePreviewBufs();
    
91. mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_PREVIEW);
    
92. if(mDisplayAdapter.get()!=NULL){
    
93. mDisplayAdapter->disableDisplay(false);
    
94. }
    
95. mAppCallbackNotifier->stop();
    
96. mPreviewStartInProgress=false;
    
97. mPreviewEnabled=false;
    
98. LOG_FUNCTION_NAME_EXIT;
    
99. 
    
100. return ret;
     
101. }

在我的理解看来上面标注的部分是这个方法的关键，这个地方可是会让初次研究这里的人晕头转向的，因为我就在这里犯了错误，走岔道了，下面会说明到底是怎么走岔道的 ：
先说一下吧，这里调用 mCameraAdapter 对象的 sendCommand 方法

1. status_t BaseCameraAdapter::sendCommand(CameraCommands operation,intvalue1,intvalue2,intvalue3,intvalue4){
   
2. status_t ret=NO_ERROR;
   
3. struct timeval*refTimestamp;
   
4. BuffersDescriptor*desc=NULL;
   
5. CameraFrame*frame=NULL;
   
6. 
   
7. LOG_FUNCTION_NAME;
   
8. 
   
9. switch(operation){
10. case：
    
11. ...............
    
12. case CameraAdapter::CAMERA_START_PREVIEW:
    {
    CAMHAL_LOGDA("Start Preview");
    if ( ret == NO_ERROR )
    {
    ret = setState(operation);
    }
    
    if ( ret == NO_ERROR )
    {
    ret = startPreview();
    }
    
    if ( ret == NO_ERROR )
    {
    ret = commitState();
    }else{
    ret |= rollbackState();
    }
    break;
    }
    
13. }
    
14. }

1. status_t BaseCameraAdapter::setState(CameraCommands operation)
   
2. {
   
3. status_t ret=NO_ERROR;
   
4. 
   
5. LOG_FUNCTION_NAME;
   
6. 
   
7. constchar*printState=getLUTvalue_translateHAL(operation,CamCommandsLUT);
   
8. 
   
9. mLock.lock();
   
10. 
    
11. switch(mAdapterState)
    
12. {
    
13. 
    
14. caseINTIALIZED_STATE:
    
15. ............
16. 
    
17. caseLOADED_PREVIEW_STATE:
    
18. 
    
19. switch(operation)
    
20. {
    
21. 
    
22. caseCAMERA_START_PREVIEW:
    
23. CAMHAL_LOGDB("Adapter state switch LOADED_PREVIEW_STATE->PREVIEW_STATE event = %s",
    
24. printState);
    
25. mNextState=PREVIEW_STATE;
    
26. break;
27. }
    
28. }
    
29. }

1. status_t BaseCameraAdapter::startPreview()
   
2. {
   
3. status_t ret=NO_ERROR;
   
4. 
   
5. LOG_FUNCTION_NAME;
   
6. 
   
7. LOG_FUNCTION_NAME_EXIT;
   
8. 
   
9. return ret;
   
10. }

就是这里了，所以我用可很醒目的颜色标注出来，很多人会想当然的理解，你不是调用了 startPreview 方法嘛，那就是他了啊！可是这里为什么什么动作都没做呢？？
于是就卡在这里不知所措了，那个纠结啊
现在就来解开这个谜团吧！！！

这个我们还是要往前追溯了，追溯到哪里呢？？那就从这里开始吧
mCameraAdapter - > sendCommand ( CameraAdapter : : CAMERA_START_PREVIEW ) ;
这个方式是在 CameraHal 的 startPreview ( ) 方法中 被调用的
所以我要知道这个 mCameraAdapter 对象原型是什么啊，他从哪里而来，原来他是 CameraHal 这个类的一个成员，定义在： hardware/ti/omap4xxx/camera/inc/CameraHal.h
CameraAdapter *mCameraAdapter;
这里必须打破砂锅追到底，找到 CameraAdapter 这个类的定义，他的定义同样这这个.h文件中

1. /**
   
2. *CameraAdapter interfaceclass
   
3. *Concrete classes derive from thisclassandprovide implementations basedonthe specific camera h/w interface
   
4. */
   
5. 
   
6. classCameraAdapter:publicFrameNotifier,publicvirtual RefBase
   
7. {
   
8. protected:
   
9. enum AdapterActiveStates{
   
10. INTIALIZED_ACTIVE=1<<0,
    
11. LOADED_PREVIEW_ACTIVE=1<<1,
    
12. PREVIEW_ACTIVE=1<<2,
    
13. LOADED_CAPTURE_ACTIVE=1<<3,
    
14. CAPTURE_ACTIVE=1<<4,
    
15. BRACKETING_ACTIVE=1<<5,
    
16. AF_ACTIVE=1<<6,
    
17. ZOOM_ACTIVE=1<<7,
    
18. VIDEO_ACTIVE=1<<8,
    
19. LOADED_REPROCESS_ACTIVE=1<<9,
    
20. REPROCESS_ACTIVE=1<<10,
    
21. };
    
22. public:
    
23. typedef struct
    
24. {
    
25. CameraBuffer*mBuffers;
    
26. uint32_t*mOffsets;
    
27. intmFd;
    
28. size_t mLength;
    
29. size_t mCount;
    
30. size_t mMaxQueueable;
    
31. }BuffersDescriptor;
    
32. 
    
33. enum CameraCommands
    
34. {
    
35. CAMERA_START_PREVIEW=0,
    
36. CAMERA_STOP_PREVIEW=1,
    
37. CAMERA_START_VIDEO=2,
    
38. CAMERA_STOP_VIDEO=3,
    
39. CAMERA_START_IMAGE_CAPTURE=4,
    
40. CAMERA_STOP_IMAGE_CAPTURE=5,
    
41. CAMERA_PERFORM_AUTOFOCUS=6,
    
42. CAMERA_CANCEL_AUTOFOCUS=7,
    
43. CAMERA_PREVIEW_FLUSH_BUFFERS=8,
    
44. CAMERA_START_SMOOTH_ZOOM=9,
    
45. CAMERA_STOP_SMOOTH_ZOOM=10,
    
46. CAMERA_USE_BUFFERS_PREVIEW=11,
    
47. CAMERA_SET_TIMEOUT=12,
    
48. CAMERA_CANCEL_TIMEOUT=13,
    
49. CAMERA_START_BRACKET_CAPTURE=14,
    
50. CAMERA_STOP_BRACKET_CAPTURE=15,
    
51. CAMERA_QUERY_RESOLUTION_PREVIEW=16,
    
52. CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE=17,
    
53. CAMERA_QUERY_BUFFER_SIZE_PREVIEW_DATA=18,
    
54. CAMERA_USE_BUFFERS_IMAGE_CAPTURE=19,
    
55. CAMERA_USE_BUFFERS_PREVIEW_DATA=20,
    
56. CAMERA_TIMEOUT_EXPIRED=21,
    
57. CAMERA_START_FD=22,
    
58. CAMERA_STOP_FD=23,
    
59. CAMERA_SWITCH_TO_EXECUTING=24,
    
60. CAMERA_USE_BUFFERS_VIDEO_CAPTURE=25,
    
61. #ifdef OMAP_ENHANCEMENT_CPCAM
    
62. CAMERA_USE_BUFFERS_REPROCESS=26,
    
63. CAMERA_START_REPROCESS=27,
    
64. #endif
    
65. #ifdef OMAP_ENHANCEMENT_VTC
    
66. CAMERA_SETUP_TUNNEL=28,
    
67. CAMERA_DESTROY_TUNNEL=29,
    
68. #endif
    
69. CAMERA_PREVIEW_INITIALIZATION=30,
    
70. };
    
71. 
    
72. enum CameraMode
    
73. {
    
74. CAMERA_PREVIEW,
    
75. CAMERA_IMAGE_CAPTURE,
    
76. CAMERA_VIDEO,
    
77. CAMERA_MEASUREMENT,
    
78. CAMERA_REPROCESS,
    
79. };
    
80. 
    
81. enum AdapterState{
    
82. INTIALIZED_STATE=INTIALIZED_ACTIVE,
    
83. LOADED_PREVIEW_STATE=LOADED_PREVIEW_ACTIVE|INTIALIZED_ACTIVE,
    
84. PREVIEW_STATE=PREVIEW_ACTIVE|INTIALIZED_ACTIVE,
    
85. LOADED_CAPTURE_STATE=LOADED_CAPTURE_ACTIVE|PREVIEW_ACTIVE|INTIALIZED_ACTIVE,
    
86. CAPTURE_STATE=CAPTURE_ACTIVE|PREVIEW_ACTIVE|INTIALIZED_ACTIVE,
    
87. BRACKETING_STATE=BRACKETING_ACTIVE|CAPTURE_ACTIVE|PREVIEW_ACTIVE|INTIALIZED_ACTIVE,
    
88. AF_STATE=AF_ACTIVE|PREVIEW_ACTIVE|INTIALIZED_ACTIVE,
    
89. ZOOM_STATE=ZOOM_ACTIVE|PREVIEW_ACTIVE|INTIALIZED_ACTIVE,
    
90. VIDEO_STATE=VIDEO_ACTIVE|PREVIEW_ACTIVE|INTIALIZED_ACTIVE,
    
91. VIDEO_AF_STATE=VIDEO_ACTIVE|AF_ACTIVE|PREVIEW_ACTIVE|INTIALIZED_ACTIVE,
    
92. VIDEO_ZOOM_STATE=VIDEO_ACTIVE|ZOOM_ACTIVE|PREVIEW_ACTIVE|INTIALIZED_ACTIVE,
    
93. VIDEO_LOADED_CAPTURE_STATE=VIDEO_ACTIVE|LOADED_CAPTURE_ACTIVE|PREVIEW_ACTIVE|INTIALIZED_ACTIVE,
    
94. VIDEO_CAPTURE_STATE=VIDEO_ACTIVE|CAPTURE_ACTIVE|PREVIEW_ACTIVE|INTIALIZED_ACTIVE,
    
95. AF_ZOOM_STATE=AF_ACTIVE|ZOOM_ACTIVE|PREVIEW_ACTIVE|INTIALIZED_ACTIVE,
    
96. BRACKETING_ZOOM_STATE=BRACKETING_ACTIVE|ZOOM_ACTIVE|PREVIEW_ACTIVE|INTIALIZED_ACTIVE,
    
97. LOADED_REPROCESS_STATE=LOADED_REPROCESS_ACTIVE|PREVIEW_ACTIVE|INTIALIZED_ACTIVE,
    
98. LOADED_REPROCESS_CAPTURE_STATE=LOADED_REPROCESS_ACTIVE|LOADED_CAPTURE_ACTIVE|PREVIEW_ACTIVE|INTIALIZED_ACTIVE,
    
99. REPROCESS_STATE=REPROCESS_ACTIVE|CAPTURE_ACTIVE|PREVIEW_ACTIVE|INTIALIZED_ACTIVE,
    
100. };
     
101. 
     
102. 
     
103. public:
     
104. 
     
105. ///Initialzes the camera adapter creates any resources required
     
106. virtualintinitialize(CameraProperties::Properties*)=0;
     
107. 
     
108. virtualintsetErrorHandler(ErrorNotifier*errorNotifier)=0;
     
109. 
     
110. //Message/Frame notification APIs
     
111. virtual void enableMsgType(int32_t msgs,
     
112. frame_callback callback=NULL,
     
113. event_callback eventCb=NULL,
     
114. void*cookie=NULL)=0;
     
115. virtual void disableMsgType(int32_t msgs,void*cookie)=0;
     
116. virtual void returnFrame(CameraBuffer*frameBuf,CameraFrame::FrameType frameType)=0;
     
117. virtual void addFramePointers(CameraBuffer*frameBuf,void*buf)=0;
     
118. virtual void removeFramePointers()=0;
     
119. 
     
120. //APIstoconfigure Camera adapterandgetthe current parameterset
     
121. virtualintsetParameters(constCameraParameters&params)=0;
     
122. virtual void getParameters(CameraParameters&params)=0;
     
123. 
     
124. //Registers callbackforreturning image buffers backtoCameraHAL
     
125. virtualintregisterImageReleaseCallback(release_image_buffers_callback callback,void*user_data)=0;
     
126. 
     
127. //Registers callback,which signals a completed image capture
     
128. virtualintregisterEndCaptureCallback(end_image_capture_callback callback,void*user_data)=0;
     
129. 
     
130. //APItosend a commandtothe camera
     
131. virtual status_t sendCommand(CameraCommands operation,intvalue1=0,intvalue2=0,intvalue3=0,intvalue4=0)=0;
     
132. 
     
133. virtual~CameraAdapter(){};
     
134. 
     
135. //Retrieves the current Adapter state
     
136. virtual AdapterState getState()=0;
     
137. 
     
138. //Retrieves thenextAdapter state
     
139. virtual AdapterState getNextState()=0;
     
140. 
     
141. //Receive orientation events from CameraHal
     
142. virtual void onOrientationEvent(uint32_t orientation,uint32_t tilt)=0;
     
143. 
     
144. //Rolls the state machine backtoINTIALIZED_STATE from the current state
     
145. virtual status_t rollbackToInitializedState()=0;
     
146. 
     
147. //Retrieves the current Adapter state-forinternal use(notlocked)
     
148. virtual status_t getState(AdapterState&state)=0;
     
149. //Retrieves thenextAdapter state-forinternal use(notlocked)
     
150. virtual status_t getNextState(AdapterState&state)=0;
     
151. 
     
152. protected:
     
153. //The first two methods will trytoswitch the adapter state.
     
154. //EverycalltosetState()should be followed by a corresponding
     
155. //calltocommitState().Ifthe state switch fails,thenit will
     
156. //getresettothe previous state via rollbackState().
     
157. virtual status_t setState(CameraCommands operation)=0;
     
158. virtual status_t commitState()=0;
     
159. virtual status_t rollbackState()=0;
160. };

看一下我标出的这是红色部分啊，为什么我要把它们标注成红色呢？？
懂C++面向对象思想应该都知道 virtual这个关键字是干什么的，
如果一个类的方法被定义为 virtual ，如果该类的子类实现了同样的方法，则这个方法被调用的时候，会忽略父类的实现，而直接调用子类的实现， 前提是方法名，包括变量类型，个数必须一致
那么这里有没有类继承了 CameraAdapter 这个类，并且实现了其中的一些虚拟函数呢？？答案是肯定的，我可是吃了苦头才发现的
不过也是赖自己，这是只有定义是没有实现的，肯定是由子类来实现这是方法的，不，还是不赖自己，让我吃苦头的是这里是双层继承的，双层继承啊，我怎么知道
不卖关子了，那么谁继承了 CameraAdapter 这个类呢？ 先给路径：hardware/ti/omap4xxx/camera/inc/BaseCameraAdapter.h

1. classBaseCameraAdapter:publicCameraAdapter
   
2. {
   
3. 
   
4. public:
   
5. 
   
6. BaseCameraAdapter();
   
7. virtual~BaseCameraAdapter();
   
8. 
   
9. ///Initialzes the camera adapter creates any resources required
   
10. virtual status_t initialize(CameraProperties::Properties*)=0;
    
11. 
    
12. virtualintsetErrorHandler(ErrorNotifier*errorNotifier);
    
13. 
    
14. //Message/Frame notification APIs
    
15. virtual void enableMsgType(int32_t msgs,frame_callback callback=NULL,event_callback eventCb=NULL,void*cookie=NULL);
    
16. virtual void disableMsgType(int32_t msgs,void*cookie);
    
17. virtual void returnFrame(CameraBuffer*frameBuf,CameraFrame::FrameType frameType);
    
18. virtual void addFramePointers(CameraBuffer*frameBuf,void*y_uv);
    
19. virtual void removeFramePointers();
    
20. 
    
21. //APIstoconfigure Camera adapterandgetthe current parameterset
    
22. virtual status_t setParameters(constCameraParameters&params)=0;
    
23. virtual void getParameters(CameraParameters&params)=0;
    
24. 
    
25. //APItosend a commandtothe camera
    
26. virtual status_t sendCommand(CameraCommands operation,intvalue1=0,intvalue2=0,intvalue3=0,intvalue4=0);
    
27. 
    
28. virtual status_t registerImageReleaseCallback(release_image_buffers_callback callback,void*user_data);
    
29. 
    
30. virtual status_t registerEndCaptureCallback(end_image_capture_callback callback,void*user_data);
    
31. 
    
32. //Retrieves the current Adapter state
    
33. virtual AdapterState getState();
    
34. //Retrieves thenextAdapter state
    
35. virtual AdapterState getNextState();
    
36. 
    
37. //Rolls the state machine backtoINTIALIZED_STATE from the current state
    
38. virtual status_t rollbackToInitializedState();
    
39. 
    
40. protected:
    
41. //The first two methods will trytoswitch the adapter state.
    
42. //EverycalltosetState()should be followed by a corresponding
    
43. //calltocommitState().Ifthe state switch fails,thenit will
    
44. //getresettothe previous state via rollbackState().
    
45. virtual status_t setState(CameraCommands operation);
    
46. virtual status_t commitState();
    
47. virtual status_t rollbackState();
    
48. 
    
49. //Retrieves the current Adapter state-forinternal use(notlocked)
    
50. virtual status_t getState(AdapterState&state);
    
51. //Retrieves thenextAdapter state-forinternal use(notlocked)
    
52. virtual status_t getNextState(AdapterState&state);
    
53. 
    
54. //-----------Interface that needstobe implemented by deriving classes--------------------
    
55. 
    
56. //Should be implmented by deriving classesinordertostart image capture
    
57. virtual status_t takePicture();
    
58. 
    
59. //Should be implmented by deriving classesinordertostart image capture
    
60. virtual status_t stopImageCapture();
    
61. 
    
62. //Should be implmented by deriving classesinordertostart temporal bracketing
    
63. virtual status_t startBracketing(intrange);
    
64. 
    
65. //Should be implemented by deriving classesinordertostop temporal bracketing
    
66. virtual status_t stopBracketing();
    
67. 
    
68. //Should be implemented by deriving classesinodertoinitiate autoFocus
    
69. virtual status_t autoFocus();
    
70. 
    
71. //Should be implemented by deriving classesinodertoinitiate autoFocus
    
72. virtual status_t cancelAutoFocus();
    
73. 
    
74. //Should be called by deriving classesinordertodosome bookkeeping
    
75. virtual status_t startVideoCapture();
    
76. 
    
77. //Should be called by deriving classesinordertodosome bookkeeping
    
78. virtual status_t stopVideoCapture();
    
79. 
    
80. //Should be implemented by deriving classesinordertostart camera preview
    
81. virtual status_t startPreview();
    
82. 
    
83. //Should be implemented by deriving classesinordertostop camera preview
    
84. virtual status_t stopPreview();
    
85. 
    
86. //Should be implemented by deriving classesinordertostart smooth zoom
    
87. virtual status_t startSmoothZoom(inttargetIdx);
    
88. 
    
89. //Should be implemented by deriving classesinordertostop smooth zoom
    
90. virtual status_t stopSmoothZoom();
    
91. 
    
92. //Should be implemented by deriving classesinordertostop smooth zoom
    
93. virtual status_t useBuffers(CameraMode mode,CameraBuffer*bufArr,intnum,size_t length,unsignedintqueueable);
    
94. 
    
95. //Should be implemented by deriving classesinorder queue a released bufferinCameraAdapter
    
96. virtual status_t fillThisBuffer(CameraBuffer*frameBuf,CameraFrame::FrameType frameType);
    
97. 
    
98. //APItogetthe frame size requiredtobe allocated.This sizeisusedtooverride the size passed
    
99. //by camera service when VSTAB/VNFisturnedONforexample
    
100. virtual status_t getFrameSize(size_t&width,size_t&height);
     
101. 
     
102. //APItogetrequired data frame size
     
103. virtual status_t getFrameDataSize(size_t&dataFrameSize,size_t bufferCount);
     
104. 
     
105. //APItogetrequired picture buffers size with the current configurationinCameraParameters
     
106. virtual status_t getPictureBufferSize(size_t&length,size_t bufferCount);
     
107. 
     
108. //Should be implemented by deriving classesinordertostart face detection
     
109. //(ifsupported)
     
110. virtual status_t startFaceDetection();
     
111. 
     
112. //Should be implemented by deriving classesinordertostop face detection
     
113. //(ifsupported)
     
114. virtual status_t stopFaceDetection();
     
115. 
     
116. virtual status_t switchToExecuting();
     
117. 
     
118. virtual status_t setupTunnel(uint32_t SliceHeight,uint32_t EncoderHandle,uint32_t width,uint32_t height);
     
119. 
     
120. virtual status_t destroyTunnel();
     
121. 
     
122. virtual status_t cameraPreviewInitialization();
     
123. 
     
124. //Receive orientation events from CameraHal
     
125. virtual void onOrientationEvent(uint32_t orientation,uint32_t tilt);
     
126. 
     
127. //---------------------Interface ends-----------------------------------
     
128. 
     
129. status_t notifyFocusSubscribers(CameraHalEvent::FocusStatus status);
     
130. status_t notifyShutterSubscribers();
     
131. status_t notifyZoomSubscribers(intzoomIdx,bool targetReached);
     
132. status_t notifyMetadataSubscribers(sp<CameraMetadataResult>&meta);
     
133. 
     
134. //Send the frametosubscribers
     
135. status_t sendFrameToSubscribers(CameraFrame*frame);
     
136. 
     
137. //Resets the refCountforthis particular frame
     
138. status_t resetFrameRefCount(CameraFrame&frame);
     
139. 
     
140. //A couple of helper functions
     
141. void setFrameRefCount(CameraBuffer*frameBuf,CameraFrame::FrameType frameType,intrefCount);
     
142. intgetFrameRefCount(CameraBuffer*frameBuf,CameraFrame::FrameType frameType);
     
143. intsetInitFrameRefCount(CameraBuffer*buf,unsignedintmask);
     
144. staticconstchar*getLUTvalue_translateHAL(intValue,LUTtypeHAL LUT);
     
145. 
     
146. .................
     
147. .................
     
148. }

这里我只列出了一部分代码，不过大家清楚了， BaseCameraAdapter继承 CameraAdapter，不过这里还没完呢，看看这个类中定义的方法
那么多的 virtual 方法，后来自己才发现的，他还是被别的类继承了，而且其中的很多方法被子类重新实现了
所以实现上上面调用的 startPreview方法其实不是 BaseCameraAdapter.cpp中实现的那个 startPreview方法
那挺调用的 startPreview方法在哪里呢，自然是继承了 BaseCameraAdapter 类的那个子类实现的 startPreview
现在就把这个罪魁祸首拉上来，先看定义：hardware/ti/omap4xxx/camera/inc/V4LCameraAdapter/V4LCameraAdapter.h

1. /**
   
2. *Classwhich completely abstracts the camera hardware interaction from camera hal
   
3. *TODO:Needtolist down here,all the message types that will be supported by thisclass
   
4. Needtoimplement BufferProvider interfacetouse AllocateBuffer of OMXifneeded
   
5. */
   
6. classV4LCameraAdapter:publicBaseCameraAdapter
   
7. {
   
8. public:
   
9. 
   
10. /*--------------------Constant declarations----------------------------------------*/
    
11. staticconstint32_t MAX_NO_BUFFERS=20;
    
12. 
    
13. ///@remarks OMX Camera has six ports-buffer input,timeinput,preview,image,video,andmeta data
    
14. staticconstintMAX_NO_PORTS=6;
    
15. 
    
16. ///Fivesecondtimeout
    
17. staticconstintCAMERA_ADAPTER_TIMEOUT=5000*1000;
    
18. 
    
19. public:
    
20. 
    
21. V4LCameraAdapter(size_t sensor_index);
    
22. ~V4LCameraAdapter();
    
23. 
    
24. 
    
25. ///Initialzes the camera adapter creates any resources required
    
26. virtual status_t initialize(CameraProperties::Properties*);
    
27. 
    
28. //APIstoconfigure Camera adapterandgetthe current parameterset
    
29. virtual status_t setParameters(constCameraParameters&params);
    
30. virtual void getParameters(CameraParameters&params);
    
31. 
    
32. //API
    
33. virtual status_t UseBuffersPreview(CameraBuffer*bufArr,intnum);
    
34. virtual status_t UseBuffersCapture(CameraBuffer*bufArr,intnum);
    
35. 
    
36. static status_t getCaps(constintsensorId,CameraProperties::Properties*params,V4L_HANDLETYPE handle);
    
37. 
    
38. protected:
    
39. 
    
40. //----------Parentclassmethod implementation------------------------------------//看看人家这里说的很清楚，这是父类的方法
    
41. virtual status_t startPreview();
    
42. virtual status_t stopPreview();
    
43. virtual status_t takePicture();
    
44. virtual status_t stopImageCapture();
    
45. virtual status_t autoFocus();
    
46. virtual status_t useBuffers(CameraMode mode,CameraBuffer*bufArr,intnum,size_t length,unsignedintqueueable);
    
47. virtual status_t fillThisBuffer(CameraBuffer*frameBuf,CameraFrame::FrameType frameType);
    
48. virtual status_t getFrameSize(size_t&width,size_t&height);
    
49. virtual status_t getPictureBufferSize(size_t&length,size_t bufferCount);
    
50. virtual status_t getFrameDataSize(size_t&dataFrameSize,size_t bufferCount);
    
51. virtual void onOrientationEvent(uint32_t orientation,uint32_t tilt);
    
52. //-----------------------------------------------------------------------------
    
53. 
    
54. 
    
55. private:
    
56. 
    
57. classPreviewThread:publicThread{
    
58. V4LCameraAdapter*mAdapter;
    
59. public:
    
60. PreviewThread(V4LCameraAdapter*hw):
    
61. Thread(false),mAdapter(hw){}
    
62. virtual void onFirstRef(){
    
63. run("CameraPreviewThread",PRIORITY_URGENT_DISPLAY);
    
64. }
    
65. virtual bool threadLoop(){
    
66. mAdapter->previewThread();
    
67. //loopuntilwe needtoquit
    
68. returntrue;
    
69. }
    
70. };
    
71. 
    
72. //Usedforcalculation of the average frame rate during preview
    
73. status_t recalculateFPS();
    
74. 
    
75. char*GetFrame(int&index);
    
76. 
    
77. intpreviewThread();
    
78. 
    
79. public:
    
80. 
    
81. private:
    
82. //capabilities data
    
83. staticconstCapPixelformat mPixelformats[];
    
84. staticconstCapResolution mPreviewRes[];
    
85. staticconstCapFramerate mFramerates[];
    
86. staticconstCapResolution mImageCapRes[];
    
87. 
    
88. //camera defaults
    
89. staticconstchar DEFAULT_PREVIEW_FORMAT[];
    
90. staticconstchar DEFAULT_PREVIEW_SIZE[];
    
91. staticconstchar DEFAULT_FRAMERATE[];
    
92. staticconstchar DEFAULT_NUM_PREV_BUFS[];
    
93. 
    
94. staticconstchar DEFAULT_PICTURE_FORMAT[];
    
95. staticconstchar DEFAULT_PICTURE_SIZE[];
    
96. staticconstchar DEFAULT_FOCUS_MODE[];
    
97. staticconstchar*DEFAULT_VSTAB;
    
98. staticconstchar*DEFAULT_VNF;
    
99. 
    
100. static status_t insertDefaults(CameraProperties::Properties*,V4L_TI_CAPTYPE&);
     
101. static status_t insertCapabilities(CameraProperties::Properties*,V4L_TI_CAPTYPE&);
     
102. static status_t insertPreviewFormats(CameraProperties::Properties*,V4L_TI_CAPTYPE&);
     
103. static status_t insertPreviewSizes(CameraProperties::Properties*,V4L_TI_CAPTYPE&);
     
104. static status_t insertImageSizes(CameraProperties::Properties*,V4L_TI_CAPTYPE&);
     
105. static status_t insertFrameRates(CameraProperties::Properties*,V4L_TI_CAPTYPE&);
     
106. static status_t sortAscend(V4L_TI_CAPTYPE&,uint16_t);
     
107. 
     
108. status_t v4lIoctl(int,int,void*);
     
109. status_t v4lInitMmap(int&);
     
110. status_t v4lInitUsrPtr(int&);
     
111. status_t v4lStartStreaming();
     
112. status_t v4lStopStreaming(intnBufferCount);
     
113. status_t v4lSetFormat(int,int,uint32_t);
     
114. status_t restartPreview();
     
115. 
     
116. 
     
117. intmPreviewBufferCount;
     
118. intmPreviewBufferCountQueueable;
     
119. intmCaptureBufferCount;
     
120. intmCaptureBufferCountQueueable;
     
121. KeyedVector<CameraBuffer*,int>mPreviewBufs;
     
122. KeyedVector<CameraBuffer*,int>mCaptureBufs;
     
123. mutable Mutex mPreviewBufsLock;
     
124. mutable Mutex mCaptureBufsLock;
     
125. mutable Mutex mStopPreviewLock;
     
126. 
     
127. CameraParameters mParams;
     
128. 
     
129. bool mPreviewing;
     
130. bool mCapturing;
     
131. Mutex mLock;
     
132. 
     
133. intmFrameCount;
     
134. intmLastFrameCount;
     
135. unsignedintmIter;
     
136. nsecs_t mLastFPSTime;
     
137. 
     
138. //variables holding the estimated framerate
     
139. float mFPS,mLastFPS;
     
140. 
     
141. intmSensorIndex;
     
142. 
     
143. //protected by mLoc

大家看到了 V4LCameraAdapter 又继承了 BaseCameraAdapter，双层继承，实现了父类的一些方法
所有这里算是媳妇熬着婆了，终于找到了我们想要的 startPreview
不过看到终于进入了 V4LCameraAdapter 这个类，我知道，离成功已经很近了，V4L2就是直接去和driver谈判的
那么我们就看看 V4LCameraAdapter 这个类中的startPreview方法吧，路径： ardware/ti/omap4xxx/camera/V4LCameraAdapter/V4LCameraAdapter.cpp

1. status_t V4LCameraAdapter::startPreview()
   
2. {
   
3. status_t ret=NO_ERROR;
   
4. 
   
5. LOG_FUNCTION_NAME;
   
6. Mutex::Autolock lock(mPreviewBufsLock);
   
7. 
   
8. if(mPreviewing){
   
9. ret=BAD_VALUE;
   
10. gotoEXIT;
    
11. }
    
12. 
    
13. for(inti=0;i<mPreviewBufferCountQueueable;i++){
    
14. 
    
15. mVideoInfo->buf.index=i;
    
16. mVideoInfo->buf.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;
    
17. mVideoInfo->buf.memory=V4L2_MEMORY_MMAP;
    
18. 
    
19. ret=v4lIoctl(mCameraHandle,VIDIOC_QBUF,&mVideoInfo->buf);
    
20. if(ret<0){
    
21. CAMHAL_LOGEA("VIDIOC_QBUF Failed");
    
22. gotoEXIT;
    
23. }
    
24. nQueued++;
    
25. }
    
26. 
    
27. ret=v4lStartStreaming();
    
28. 
    
29. //Createandstart preview threadforreceiving buffers from V4L Camera
    
30. if(!mCapturing){
    
31. mPreviewThread=new PreviewThread(this);
    
32. CAMHAL_LOGDA("Created preview thread");
    
33. }

不错，这条语句就是我一直找寻的，真是众里寻他千百度，蓦然回首，那句就在灯火阑珊处
这样，其他的事情就全部由v4l2去做了，这些过程会单独分一章去学习
还有就是上面绿的部分，同样要分一章学习，很重要

待续。。。。。。。。。。。

更多相关文章

1. Android蓝牙栈bluez使用方法
2. HwServiceManager篇-Android10.0 HwBinder通信原理(五)
3. Timer TimerTask Handler三剑合一
4. 【起航计划 014】2015 起航计划 Android(安卓)APIDemo的魔鬼步伐
5. android中不同activity之间共享数据
6. Android(安卓)开发艺术探索笔记（18）
7. Android(安卓)进阶——代码插桩必知必会之初识ASM7字节码操作库
8. android 有关毫秒转时间的方法，及时间间隔等
9. Android数据库升级、降级、创建(onCreate() onUpgrade() onDowng

随机推荐

1. LGame(Android及J2SE游戏引擎)入门示例—
2. 2019-11-07 Android谷歌支付SDK集成问题
3. StagefrightPlayer&&AwesomePlayer 初步
4. cvc-complex-type.2.4.d: 发现了以元素 '
5. Laravel 创建可以传递参数 Console服务的
6. laravel 根据不同组织加载不同视图的实现
7. laravel 实现划分admin和home 模块分组
8. laravel在中间件内生成参数并且传递到控
9. laravel通过a标签从视图向控制器实现传值
10. linux文本处理三剑客之awk