Android Camera数据流分析全程记录 ​
花了不少时间在这个数据流的分析上面，自己毕竟没怎么做过android，这里记录一下自己的见解，任何理解错误还望高人指教，以后还需慢慢纠正
整个分析过程从app的onCreate开始：packages/apps/OMAPCamera/src/com/ti/omap4/android/camera/Camera.java
在onCreate中做了很多的初始化，我们真正关注的是一下几条语句：

1. //don'tsetmSurfaceHolder here.We have itsetONLY within
   
2. //surfaceChanged/surfaceDestroyed,other parts of the code
   
3. //assume that when itisset,the surfaceisalsoset.
   
4. SurfaceView preview=(SurfaceView)findViewById(R.id.camera_preview);
   
5. SurfaceHolder holder=preview.getHolder();
   
6. holder.addCallback(this);

在这里我们实例化了一个SurfaceView对象，通过这个对象获取SurfaceHolder对象，实现这个addCallback方法，
其中 SurfaceView的定义在以下路径： frameworks/base/core/java/android/view/SurfaceView.java
其中 SurfaceHolder的定义在以下路径： frameworks/base/core/java/android/view/SurfaceHolder.java

这里看看这个文章的解释，写的很是不错：http://blog.chinaunix.net/uid-9863638-id-1996383.html

SurfaceFlinger 是Android multimedia 的一个部分，在Android 的实现中它是一个service ，提供系统范围内的surface composer 功能，它能够将各种应用程序的2D，3D surface 进行组合。
在具体讲SurfaceFlinger 之前，我们先来看一下有关显示方面的一些基础知识 。

每个应用程序可能对应着一个或者多个图形界面，而每个界面我们就称之为一个surface ，或者说是window ，在上面的图中我们能看到4 个surface ，一个是home 界面，还有就是红、绿、蓝分别代表的3 个surface ，而两个button 实际是home surface 里面的内容。在这里我们能看到我们进行图形显示所需要解决 的问题：
a 、首先每个surface 在屏幕上有它的位置，以及大小，然后每个surface 里面还有要显示的内容，内容，大小，位置 这些元素 在我们改变应用程序的时候都可能会改变，改变时应该如何处理
b 、然后就各个surface 之间可能有重叠，比如说在上面的简略图中，绿色覆盖了蓝色，而红色又覆盖了绿色和蓝色以及下面的home ，而且还具有一定透明度。这种层之间的关系应该如何描述
我们首先来看第二个问题，我们可以想象在屏幕平面的垂直方向还有一个Z 轴，所有的surface 根据在Z 轴上的坐标来确定前后，这样就可以描述各个surface 之间的上下覆盖关系了，而这个在Z 轴上的顺序，图形上有个专业术语叫Z-order 。
对于第一个问题，我们需要一个结构来记录应用程序界面的位置，大小，以及一个buffer 来记录需要显示的内容，所以这就是我们surface 的概念，surface 实际我们可以把它理解成一个容器，这个容器记录着应用程序界面的控制信息，比如说大小啊，位置啊，而它还有buffer 来专门存储需要显示的内容。
在这里还存在一个问题，那就是当存在图形重合的时候应该如何处理呢，而且可能有些surface 还带有透明信息，这里就是我们SurfaceFlinger 需要解决问题，它要把各个surface 组合(compose/merge) 成一个main Surface ，最后将Main Surface 的内容发送给FB/V4l2 Output ，这样屏幕上就能看到我们想要的效果。
在实际中对这些Surface 进行merge 可以采用两种方式，一种就是采用软件的形式来merge ，还一种就是采用硬件的方式，软件的方式就是我们的SurfaceFlinger ，而硬件的方式就是Overlay 。

首先继承SurfaceView并实现SurfaceHolder.Callback接口
使用接口的原因：因为使用SurfaceView 有一个原则，所有的绘图工作必须得在Surface 被创建之后才能开始(Surface—表面，基本上我们可以把它当作显存的一个映射，写入到Surface 的内容可以被直接复制到显存从而显示出来，这使得显示速度会非常快)，而在Surface 被销毁之前必须结束。所以Callback 中的surfaceCreated 和surfaceDestroyed 就成了绘图处理代码的边界。
需要重写的方法
　（1）public void surfaceChanged(SurfaceHolder holder,int format,int width,int height){}//在surface的大小发生改变时激发
　（2）public void surfaceCreated(SurfaceHolder holder){}//在创建时激发，一般在这里调用画图的线程。
　（3）public void surfaceDestroyed(SurfaceHolder holder) {}//销毁时激发，一般在这里将画图的线程停止、释放。
这几个方法在在app中都已经重新实现了，重点分析 surfaceChanged

1. publicvoid surfaceChanged(SurfaceHolder holder,intformat,intw,inth){
   
2. //Make sure we have a surfaceinthe holder before proceeding.
   
3. if(holder.getSurface()==null){
   
4. Log.d(TAG,"holder.getSurface() == null");
   
5. return;
   
6. }
   
7. 
   
8. Log.v(TAG,"surfaceChanged. w="+w+". h="+h);
   
9. 
   
10. //We needtosave the holderforlater use,even when the mCameraDevice
    
11. //isnull.This could happenifonResume()isinvoked after this
    
12. //function.
    
13. mSurfaceHolder=holder;
    
14. 
    
15. //The mCameraDevice will benullifit failstoconnecttothe camera
    
16. //hardware.Inthiscasewe will show a dialogandthenfinish the
    
17. //activity,so it's OKtoignore it.
    
18. if(mCameraDevice==null)return;
    
19. 
    
20. //Sometimes surfaceChangediscalled after onPauseorbefore onResume.
    
21. //Ignore it.
    
22. if(mPausing||isFinishing())return;
    
23. 
    
24. setSurfaceLayout();
    
25. 
    
26. //Setpreview displayifthe surfaceisbeing created.Preview was
    
27. //already started.Also restart the previewifdisplay rotation has
    
28. //changed.Sometimes this happens when the deviceisheldinportrait
    
29. //andcamera appisopened.Rotation animation takes sometimeand
    
30. //display rotationinonCreate maynotbe what we want.
    
31. if(mCameraState==PREVIEW_STOPPED){//这里check摄像头是否已经启动，第一次启动摄像头和摄像头已经打开从新进入摄像头实现方法不同
    
32. startPreview(true);
    
33. startFaceDetection();
    
34. }else{
    
35. if(Util.getDisplayRotation(this)!=mDisplayRotation){
    
36. setDisplayOrientation();
    
37. }
    
38. if(holder.isCreating()){
    
39. //Setpreview displayifthe surfaceisbeing createdandpreview
    
40. //was already started.That means preview display wassettonull
    
41. //andwe needtosetitnow.
    
42. setPreviewDisplay(holder);
    
43. }
    
44. }
    
45. 
    
46. //Iffirsttimeinitializationisnotfinished,send a messagetodo
    
47. //it later.We wanttofinish surfaceChanged as soon as possibletolet
    
48. //user see preview first.
    
49. if(!mFirstTimeInitialized){
    
50. mHandler.sendEmptyMessage(FIRST_TIME_INIT);
    
51. }else{
    
52. initializeSecondTime();
    
53. }
    
54. 
    
55. SurfaceView preview=(SurfaceView)findViewById(R.id.camera_preview);
    
56. CameraInfo info=CameraHolder.instance().getCameraInfo()[mCameraId];
    
57. boolean mirror=(info.facing==CameraInfo.CAMERA_FACING_FRONT);
    
58. intdisplayRotation=Util.getDisplayRotation(this);
    
59. intdisplayOrientation=Util.getDisplayOrientation(displayRotation,mCameraId);
    
60. 
    
61. mTouchManager.initialize(preview.getHeight()/3,preview.getHeight()/3,
    
62. preview,this,mirror,displayOrientation);
    
63. 
    
64. }

以上标注部分是关键，现在直接分心startPreview方法，这是第一次打开摄像头的处理函数，进行了一些初始换，而已经处于摄像头打开状态时不必使用startPreview方法，而是用上面的另外一个分支，重新开始显示即可

1. privatevoid startPreview(boolean updateAll){
   
2. if(mPausing||isFinishing())return;
   
3. 
   
4. mFocusManager.resetTouchFocus();
   
5. 
   
6. mCameraDevice.setErrorCallback(mErrorCallback);
   
7. 
   
8. //Ifwe're previewing already,stop the preview first(this will blank
   
9. //the screen).
   
10. if(mCameraState!=PREVIEW_STOPPED)stopPreview();
    
11. 
    
12. setPreviewDisplay(mSurfaceHolder);
    
13. setDisplayOrientation();
    
14. 
    
15. if(!mSnapshotOnIdle){
    
16. //Ifthe focus modeiscontinuous autofocus,callcancelAutoFocusto
    
17. //resumeit because it may have been paused by autoFocuscall.
    
18. if(Parameters.FOCUS_MODE_CONTINUOUS_PICTURE.equals(mFocusManager.getFocusMode())){
    
19. mCameraDevice.cancelAutoFocus();
    
20. }
    
21. mFocusManager.setAeAwbLock(false);//Unlock AEandAWB.
    
22. }
    
23. 
    
24. if(updateAll){
    
25. Log.v(TAG,"Updating all parameters!");
    
26. setCameraParameters(UPDATE_PARAM_INITIALIZE|UPDATE_PARAM_ZOOM|UPDATE_PARAM_PREFERENCE);
    
27. }else{
    
28. setCameraParameters(UPDATE_PARAM_MODE);
    
29. }
    
30. 
    
31. //setCameraParameters(UPDATE_PARAM_ALL);
    
32. 
    
33. //Inform the mainthreadtogoonthe UI initialization.
    
34. if(mCameraPreviewThread!=null){
    
35. synchronized(mCameraPreviewThread){
    
36. mCameraPreviewThread.notify();
    
37. }
    
38. }
    
39. 
    
40. try{
    
41. Log.v(TAG,"startPreview");
    
42. mCameraDevice.startPreview();
    
43. }catch(Throwable ex){
    
44. closeCamera();
    
45. throw new RuntimeException("startPreview failed",ex);
    
46. }
    
47. 
    
48. mZoomState=ZOOM_STOPPED;
    
49. setCameraState(IDLE);
    
50. mFocusManager.onPreviewStarted();
    
51. if(mTempBracketingEnabled){
    
52. mFocusManager.setTempBracketingState(FocusManager.TempBracketingStates.ACTIVE);
    
53. }
    
54. 
    
55. if(mSnapshotOnIdle){
    
56. mHandler.post(mDoSnapRunnable);
    
57. }
    
58. }

这里的思路是：先通过 setPreviewDisplay 方法将surface设定为window-player，这个方法会调用到HAL层，进行很重要的初始化，实现数据的回调

这里我必须得着重着重的进行分析，我一直在寻找是什么决定了overlay的使用与不适用，这里就这个 setPreviewDisplay 方法就是“罪魁祸首 ”
在setPreview方法中传入的参数是 surfa ceview ，这个surfa ceview传到底层HAL层是参数形式发生了改变，但是在我的理解下，就是人换衣服一样，
张三今天换了一身衣服，但这个张三跟昨天穿不同衣服的张三是同一个人，到了HAL层这个参数的形式是 preview_stream_ops ，下面慢慢你就可以知道了，
在camerahal中的 setPreviewDisplay 方法中，是通过判断传下来的的 preview_stream_ops 参数是否为空决定使用overlay还是不适用overlay的，很重要的
这篇文章只是在这里提及一下，下面不会提及overlay的内容，默认是以不适用overlay的方式分析数据流的整个过程的，这里可千万别混淆了
使用overl的数据回流方式将单独作为一章分析，同时会详细分析使用和不适用overlay的最终决定权

流程如下：app-->frameworks-->通过JNI-->camera client--> camera service-->通过hardware-interface -->hal_module-->HAL
这里十分有必要看一下camera service层的调用过程：

1. //setthe Surface that the preview will use
   
2. status_t CameraService::Client::setPreviewDisplay(constsp<Surface>&surface){
   
3. LOG1("setPreviewDisplay(%p) (pid %d)",surface.get(),getCallingPid());
   
4. 
   
5. sp<IBinder>binder(surface!=0?surface->asBinder():0);
   
6. sp<ANativeWindow>window(surface);
   
7. return setPreviewWindow(binder,window);
   
8. }

这里其实我还是理解的不是很透彻，将我们从app传进来的surface转换为IBinder和ANativiWindow，然后以这两个变量为参数接着调用参数不同的 setPreviewWindow

1. status_t CameraService::Client::setPreviewWindow(constsp<IBinder>&binder,
   
2. constsp<ANativeWindow>&window){
   
3. Mutex::Autolock lock(mLock);
   
4. status_t result=checkPidAndHardware();
   
5. if(result!=NO_ERROR)return result;
   
6. 
   
7. //returnifno changeinsurface.
   
8. if(binder==mSurface){
   
9. return NO_ERROR;
   
10. }
    
11. 
    
12. if(window!=0){
    
13. result=native_window_api_connect(window.get(),NATIVE_WINDOW_API_CAMERA);
    
14. if(result!=NO_ERROR){
    
15. LOGE("native_window_api_connect failed: %s (%d)",strerror(-result),
    
16. result);
    
17. return result;
    
18. }
    
19. }
    
20. 
    
21. //Ifpreview has been already started,register preview buffersnow.
    
22. if(mHardware->previewEnabled()){
    
23. if(window!=0){
    
24. native_window_set_scaling_mode(window.get(),
    
25. NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);
    
26. native_window_set_buffers_transform(window.get(),mOrientation);
    
27. result=mHardware->setPreviewWindow(window);
    
28. }
    
29. }
    
30. 
    
31. if(result==NO_ERROR){
    
32. //Everything has succeeded.Disconnect the oldwindowandremember the
    
33. //newwindow.
    
34. disconnectWindow(mPreviewWindow);
    
35. mSurface=binder;
    
36. mPreviewWindow=window;
    
37. }else{
    
38. //Something went wrong after we connectedtothe newwindow,so
    
39. //disconnect here.
    
40. disconnectWindow(window);
    
41. }
    
42. 
    
43. return result;
    
44. }

上面先调用到CameraHardwareInterface中的setPreview方法：

1. status_t setPreviewWindow(constsp<ANativeWindow>&buf)
   
2. {
   
3. LOGV("%s(%s) buf %p",__FUNCTION__,mName.string(),buf.get());
   
4. 
   
5. if(mDevice->ops->set_preview_window){
   
6. mPreviewWindow=buf;
   
7. #ifdef OMAP_ENHANCEMENT_CPCAM
   
8. mHalPreviewWindow.user=mPreviewWindow.get();
   
9. #else
   
10. mHalPreviewWindow.user=this;
    
11. #endif
    
12. LOGV("%s &mHalPreviewWindow %p mHalPreviewWindow.user %p",__FUNCTION__,
    
13. &mHalPreviewWindow,mHalPreviewWindow.user);
    
14. return mDevice->ops->set_preview_window(mDevice,
    
15. buf.get()?&mHalPreviewWindow.nw:0);
    
16. }
    
17. return INVALID_OPERATION;
    
18. }

到这里为止，传输的参数已经由最初的surface-->ANativeWindow-->preview_stream_ops, 传递到底层的参数已经发生了本质的变化，后面数据回调的时候还会见到这里变量，现在先记下它
其实我说的本质的变化这里也只能这么说，但往深入追究，这个preview_stream_ops也可以说只是surface的另外一种形式而已
这样才通过hardware调用到hal-module再调用到hal层

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

HAL层调用：

1. status_t CameraHal::setPreviewWindow(struct preview_stream_ops*window)
   
2. {
   
3. status_t ret=NO_ERROR;
   
4. CameraAdapter::BuffersDescriptor desc;
   
5. 
   
6. LOG_FUNCTION_NAME;
   
7. mSetPreviewWindowCalled=true;
   
8. 
   
9. //Ifthe Camera service passes anullwindow,we destroy existingwindowandfree the DisplayAdapter
   
10. if(!window)
    
11. {
    
12. if(mDisplayAdapter.get()!=NULL)
    
13. {
    
14. ///NULLwindowpassed,destroy the display adapterifpresent
    
15. CAMHAL_LOGD("NULL window passed, destroying display adapter");
    
16. mDisplayAdapter.clear();
    
17. ///@remarksIfthere was awindowpreviously existing,we usually expect another validwindowtobe passed by the client
    
18. ///@remarks so,we will waituntilit passes a validwindowtobegin the preview again
    
19. mSetPreviewWindowCalled=false;
    
20. }
    
21. CAMHAL_LOGD("NULL ANativeWindow passed to setPreviewWindow");
    
22. return NO_ERROR;
    
23. }elseif(mDisplayAdapter.get()==NULL)
    
24. {
    
25. //Needtocreate the display adapter since it hasnotbeen created
    
26. //Create display adapter
    
27. mDisplayAdapter=new ANativeWindowDisplayAdapter();
    
28. ret=NO_ERROR;
    
29. if(!mDisplayAdapter.get()||((ret=mDisplayAdapter->initialize())!=NO_ERROR))
    
30. {
    
31. if(ret!=NO_ERROR)
    
32. {
    
33. mDisplayAdapter.clear();
    
34. CAMHAL_LOGEA("DisplayAdapter initialize failed");
    
35. LOG_FUNCTION_NAME_EXIT;
    
36. return ret;
    
37. }
    
38. else
    
39. {
    
40. CAMHAL_LOGEA("Couldn't create DisplayAdapter");
    
41. LOG_FUNCTION_NAME_EXIT;
    
42. return NO_MEMORY;
    
43. }
    
44. }
    
45. 
    
46. //DisplayAdapter needstoknow wheretogetthe CameraFrames from inordertodisplay
    
47. //Since CameraAdapteristhe one that provides the frames,setit as the frame providerforDisplayAdapter
    
48. mDisplayAdapter->setFrameProvider(mCameraAdapter);
    
49. 
    
50. //Any dynamic errors that happen during the camera usecasehastobe propagated backtothe application
    
51. //via CAMERA_MSG_ERROR.AppCallbackNotifieristheclassthat notifies such errorstothe application
    
52. //Setit as theerrorhandlerforthe DisplayAdapter
    
53. mDisplayAdapter->setErrorHandler(mAppCallbackNotifier.get());
    
54. 
    
55. //Update the display adapter with the newwindowthatispassed from CameraService
    
56. ret=mDisplayAdapter->setPreviewWindow(window);
    
57. if(ret!=NO_ERROR)
    
58. {
    
59. CAMHAL_LOGEB("DisplayAdapter setPreviewWindow returned error %d",ret);
    
60. }
    
61. 
    
62. if(mPreviewStartInProgress)
    
63. {
    
64. CAMHAL_LOGDA("setPreviewWindow called when preview running");
    
65. //Start the preview since thewindowisnowavailable
    
66. ret=startPreview();
    
67. }
    
68. }else{
    
69. //Update the display adapter with the newwindowthatispassed from CameraService
    
70. ret=mDisplayAdapter->setPreviewWindow(window);
    
71. if((NO_ERROR==ret)&&previewEnabled()){
    
72. restartPreview();
    
73. }elseif(ret==ALREADY_EXISTS){
    
74. //ALREADY_EXISTS should be treated as a noopinthiscase
    
75. ret=NO_ERROR;
    
76. }
    
77. }
    
78. LOG_FUNCTION_NAME_EXIT;
    
79. 
    
80. return ret;
    
81. 
    
82. }

这里配置好显示数据来源，显示到目标，以及错误信息回调方法，最终开始preview

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

BaseCameraAdapter实现了父类的sendcommand方法：

1. caseCameraAdapter::CAMERA_START_PREVIEW:
   
2. {
   
3. 
   
4. CAMHAL_LOGDA("Start Preview");
   
5. 
   
6. if(ret==NO_ERROR)
   
7. {
   
8. ret=setState(operation);
   
9. }
   
10. 
    
11. if(ret==NO_ERROR)
    
12. {
    
13. ret=startPreview();
    
14. }
    
15. 
    
16. if(ret==NO_ERROR)
    
17. {
    
18. ret=commitState();
    
19. }
    
20. else
    
21. {
    
22. ret|=rollbackState();
    
23. }
    
24. 
    
25. break;
    
26. 
    
27. }

这里我们接着分析startPreview方法，之前的文章中已经分析过，这里调用的startPreview方法不是BaseCameraAdapter中的startPreview,而是调用的V4LCameraAdapter中的startPreview方法：

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);//开始preview线程
    
32. CAMHAL_LOGDA("Created preview thread");
    
33. }
    
34. 
    
35. //Update the flagtoindicate we are previewing
    
36. mPreviewing=true;
    
37. mCapturing=false;
    
38. 
    
39. EXIT:
    
40. LOG_FUNCTION_NAME_EXIT;
    
41. return ret;
    
42. }

1. status_t V4LCameraAdapter::v4lStartStreaming(){
   
2. status_t ret=NO_ERROR;
   
3. enum v4l2_buf_type bufType;
   
4. 
   
5. if(!mVideoInfo->isStreaming){
   
6. bufType=V4L2_BUF_TYPE_VIDEO_CAPTURE;
   
7. 
   
8. ret=v4lIoctl(mCameraHandle,VIDIOC_STREAMON,&bufType);开始preview
   
9. if(ret<0){
   
10. CAMHAL_LOGEB("StartStreaming: Unable to start capture: %s",strerror(errno));
    
11. return ret;
    
12. }
    
13. mVideoInfo->isStreaming=true;
    
14. }
    
15. return ret;
    
16. }

现在我们就看看开启的preview线程都在干什么：

1. intV4LCameraAdapter::previewThread()
   
2. {
   
3. status_t ret=NO_ERROR;
   
4. intwidth,height;
   
5. CameraFrame frame;
   
6. void*y_uv[2];
   
7. intindex=0;
   
8. intstride=4096;
   
9. char*fp=NULL;
   
10. 
    
11. mParams.getPreviewSize(&width,&height);
    
12. 
    
13. if(mPreviewing){
    
14. 
    
15. fp=this->GetFrame(index);
    
16. if(!fp){
    
17. ret=BAD_VALUE;
    
18. gotoEXIT;
    
19. }
    
20. CameraBuffer*buffer=mPreviewBufs.keyAt(index);
    
21. CameraFrame*lframe=(CameraFrame*)mFrameQueue.valueFor(buffer);
    
22. if(!lframe){
    
23. ret=BAD_VALUE;
    
24. gotoEXIT;
    
25. }
    
26. 
    
27. debugShowFPS();
    
28. 
    
29. if(mFrameSubscribers.size()==0){
    
30. ret=BAD_VALUE;
    
31. gotoEXIT;
    
32. }
    
33. //从这里开始以我的理解是进行数据的转换和保存操作
    
34. y_uv[0]=(void*)lframe->mYuv[0];
    
35. //y_uv[1]=(void*)lframe->mYuv[1];
    
36. //y_uv[1]=(void*)(lframe->mYuv[0]+height*stride);
    
37. convertYUV422ToNV12Tiler((unsigned char*)fp,(unsigned char*)y_uv[0],width,height);
    
38. CAMHAL_LOGVB("##...index= %d.;camera buffer= 0x%x; y= 0x%x; UV= 0x%x.",index,buffer,y_uv[0],y_uv[1]);
    
39. 
    
40. #ifdef SAVE_RAW_FRAMES
    
41. unsigned char*nv12_buff=(unsigned char*)malloc(width*height*3/2);
    
42. //Convert yuv422itoyuv420sp(NV12)&dump the frametoa file
    
43. convertYUV422ToNV12((unsigned char*)fp,nv12_buff,width,height);
    
44. saveFile(nv12_buff,((width*height)*3/2));
    
45. free(nv12_buff);
    
46. #endif
    
47. 
    
48. frame.mFrameType=CameraFrame::PREVIEW_FRAME_SYNC;
    
49. frame.mBuffer=buffer;
    
50. frame.mLength=width*height*3/2;
    
51. frame.mAlignment=stride;
    
52. frame.mOffset=0;
    
53. frame.mTimestamp=systemTime(SYSTEM_TIME_MONOTONIC);
    
54. frame.mFrameMask=(unsignedint)CameraFrame::PREVIEW_FRAME_SYNC;
    
55. 
    
56. if(mRecording)
    
57. {
    
58. frame.mFrameMask|=(unsignedint)CameraFrame::VIDEO_FRAME_SYNC;
    
59. mFramesWithEncoder++;
    
60. }
    
61. 
    
62. ret=setInitFrameRefCount(frame.mBuffer,frame.mFrameMask);
    
63. if(ret!=NO_ERROR){
    
64. CAMHAL_LOGDB("Error in setInitFrameRefCount %d",ret);
    
65. }else{
    
66. ret=sendFrameToSubscribers(&frame);
    
67. }
    
68. }
    
69. EXIT:
    
70. 
    
71. return ret;
    
72. }

就上面这段代码做一下说明，这里在我看来就是整个数据回流过程的中转站了，上面棕色部分buffer中拿到就就是底层driver返回回来的视频数据了，
那么我不是很明白的是，driver中的视频数据是怎么和 mPreviewBufs 还有index关联在一起的，并且这里可以通过 buffer = mPreviewBufs . keyAt ( index ) 获取到CameraBuffer，这里待会会详细探究一下
先接着往下说，获取到视频数据之后，如果需要，会将数据经过转换保存到file中方便之后使用，
最后使用得到的camerabuffer填充CameraFrame，这个结构至关重要，在我的理解，最终是通过 sendFrameToSubscribers ( & frame ) ; 方法将数据回流的

这里就先追踪一下 driver中的视频数据是怎么和 mPreviewBufs 还有index关联在一起的
到了这里就不得不提及上面已经说的一个很重要的方法，先看看这个方法：
他是startPreview的第一步， cameraPreviewInitialization

1. status_t CameraHal::cameraPreviewInitialization()
   
2. {
   
3. 
   
4. status_t ret=NO_ERROR;
   
5. CameraAdapter::BuffersDescriptor desc;
   
6. CameraFrame frame;
   
7. unsignedintrequired_buffer_count;
   
8. unsignedintmax_queueble_buffers;
   
9. 
   
10. #ifPPM_INSTRUMENTATION||PPM_INSTRUMENTATION_ABS
    
11. gettimeofday(&mStartPreview,NULL);
    
12. #endif
    
13. 
    
14. LOG_FUNCTION_NAME;
    
15. 
    
16. if(mPreviewInitializationDone){
    
17. return NO_ERROR;
    
18. }
    
19. 
    
20. if(mPreviewEnabled){
    
21. CAMHAL_LOGDA("Preview already running");
    
22. LOG_FUNCTION_NAME_EXIT;
    
23. return ALREADY_EXISTS;
    
24. }
    
25. 
    
26. if(NULL!=mCameraAdapter){
    
27. ret=mCameraAdapter->setParameters(mParameters);配置参数到CameraAdapter
    
28. }
    
29. 
    
30. if((mPreviewStartInProgress==false)&&(mDisplayPaused==false)){
    
31. ret=mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_RESOLUTION_PREVIEW,(int)&frame);//通过这个command获取frame
    
32. if(NO_ERROR!=ret){
    
33. CAMHAL_LOGEB("Error: CAMERA_QUERY_RESOLUTION_PREVIEW %d",ret);
    
34. return ret;
    
35. }
    
36. 
    
37. ///Update the current preview widthandheight
    
38. mPreviewWidth=frame.mWidth;//初始化宽和高
    
39. mPreviewHeight=frame.mHeight;
    
40. }
    
41. 
    
42. ///Ifwe don't have the preview callback enabledanddisplay adapter,
    
43. if(!mSetPreviewWindowCalled||(mDisplayAdapter.get()==NULL)){
    
44. CAMHAL_LOGD("Preview not started. Preview in progress flag set");
    
45. mPreviewStartInProgress=true;
    
46. ret=mCameraAdapter->sendCommand(CameraAdapter::CAMERA_SWITCH_TO_EXECUTING);
    
47. if(NO_ERROR!=ret){
    
48. CAMHAL_LOGEB("Error: CAMERA_SWITCH_TO_EXECUTING %d",ret);
    
49. return ret;
    
50. }
    
51. return NO_ERROR;
    
52. }
    
53. 
    
54. if((mDisplayAdapter.get()!=NULL)&&(!mPreviewEnabled)&&(mDisplayPaused))
    
55. {
    
56. CAMHAL_LOGDA("Preview is in paused state");
    
57. 
    
58. mDisplayPaused=false;
    
59. mPreviewEnabled=true;
    
60. if(NO_ERROR==ret)
    
61. {
    
62. ret=mDisplayAdapter->pauseDisplay(mDisplayPaused);
    
63. 
    
64. if(NO_ERROR!=ret)
    
65. {
    
66. CAMHAL_LOGEB("Display adapter resume failed %x",ret);
    
67. }
    
68. }
    
69. //restart preview callbacks
    
70. if(mMsgEnabled&CAMERA_MSG_PREVIEW_FRAME)
    
71. {
    
72. mAppCallbackNotifier->enableMsgType(CAMERA_MSG_PREVIEW_FRAME);//
    
73. }
    
74. 
    
75. signalEndImageCapture();
    
76. return ret;
    
77. }
    
78. 
    
79. required_buffer_count=atoi(mCameraProperties->get(CameraProperties::REQUIRED_PREVIEW_BUFS));
    
80. 
    
81. ///Allocate the preview buffers
    
82. ret=allocPreviewBufs(mPreviewWidth,mPreviewHeight,mParameters.getPreviewFormat(),required_buffer_count,max_queueble_buffers);
    
83. 
    
84. if(NO_ERROR!=ret)
    
85. {
    
86. CAMHAL_LOGEA("Couldn't allocate buffers for Preview");
    
87. gotoerror;
    
88. }
    
89. 
    
90. if(mMeasurementEnabled)
    
91. {
    
92. 
    
93. ret=mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_PREVIEW_DATA,
    
94. (int)&frame,
    
95. required_buffer_count);
    
96. if(NO_ERROR!=ret)
    
97. {
    
98. return ret;
    
99. }
    
100. 
     
101. ///Allocate the preview data buffers
     
102. ret=allocPreviewDataBufs(frame.mLength,required_buffer_count);
     
103. if(NO_ERROR!=ret){
     
104. CAMHAL_LOGEA("Couldn't allocate preview data buffers");
     
105. gotoerror;
     
106. }
     
107. 
     
108. if(NO_ERROR==ret)
     
109. {
     
110. desc.mBuffers=mPreviewDataBuffers;
     
111. desc.mOffsets=mPreviewDataOffsets;
     
112. desc.mFd=mPreviewDataFd;
     
113. desc.mLength=mPreviewDataLength;
     
114. desc.mCount=(size_t)required_buffer_count;
     
115. desc.mMaxQueueable=(size_t)required_buffer_count;
     
116. 
     
117. mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_PREVIEW_DATA,
     
118. (int)&desc);
     
119. }
     
120. 
     
121. }
     
122. 
     
123. ///Pass the bufferstoCamera Adapter
     
124. desc.mBuffers=mPreviewBuffers;
     
125. desc.mOffsets=mPreviewOffsets;
     
126. desc.mFd=mPreviewFd;
     
127. desc.mLength=mPreviewLength;
     
128. desc.mCount=(size_t)required_buffer_count;
     
129. desc.mMaxQueueable=(size_t)max_queueble_buffers;
     
130. 
     
131. ret=mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_PREVIEW,(int)&desc);
132. 
     
133. if(NO_ERROR!=ret)
     
134. {
     
135. CAMHAL_LOGEB("Failed to register preview buffers: 0x%x",ret);
     
136. freePreviewBufs();
     
137. return ret;
     
138. }
     
139. 
     
140. mAppCallbackNotifier->startPreviewCallbacks(mParameters,mPreviewBuffers,mPreviewOffsets,mPreviewFd,mPreviewLength,required_buffer_count);
141. ///Start the callback notifier
     
142. ret=mAppCallbackNotifier->start();
     
143. 
     
144. if(ALREADY_EXISTS==ret)
     
145. {
     
146. //Already running,donothing
     
147. CAMHAL_LOGDA("AppCallbackNotifier already running");
     
148. ret=NO_ERROR;
     
149. }
     
150. elseif(NO_ERROR==ret){
     
151. CAMHAL_LOGDA("Started AppCallbackNotifier..");
     
152. mAppCallbackNotifier->setMeasurements(mMeasurementEnabled);
     
153. }
     
154. else
     
155. {
     
156. CAMHAL_LOGDA("Couldn't start AppCallbackNotifier");
     
157. gotoerror;
     
158. }
     
159. 
     
160. if(ret==NO_ERROR)mPreviewInitializationDone=true;
     
161. return ret;
     
162. 
     
163. error:
     
164. 
     
165. CAMHAL_LOGEA("Performing cleanup after error");
     
166. 
     
167. //Doall the cleanup
     
168. freePreviewBufs();
     
169. mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_PREVIEW);
     
170. if(mDisplayAdapter.get()!=NULL)
     
171. {
     
172. mDisplayAdapter->disableDisplay(false);
     
173. }
     
174. mAppCallbackNotifier->stop();
     
175. mPreviewStartInProgress=false;
     
176. mPreviewEnabled=false;
     
177. LOG_FUNCTION_NAME_EXIT;
     
178. 
     
179. return ret;
     
180. }

这里先为preview buffer申请内存，并将preview set进cameraAdapter通过方法 mCameraAdapter - > sendCommand ( CameraAdapter : : CAMERA_USE_BUFFERS_PREVIEW , ( int ) & desc )
在sendcommand中实现如下：

1. caseCameraAdapter::CAMERA_USE_BUFFERS_PREVIEW:
   
2. CAMHAL_LOGDA("Use buffers for preview");
   
3. desc=(BuffersDescriptor*)value1;
   
4. 
   
5. if(NULL==desc)
   
6. {
   
7. CAMHAL_LOGEA("Invalid preview buffers!");
   
8. return-EINVAL;
   
9. }
   
10. 
    
11. if(ret==NO_ERROR)
    
12. {
    
13. ret=setState(operation);
    
14. }
    
15. 
    
16. if(ret==NO_ERROR)
    
17. {
    
18. Mutex::Autolock lock(mPreviewBufferLock);
    
19. mPreviewBuffers=desc->mBuffers;
    
20. mPreviewBuffersLength=desc->mLength;
    
21. mPreviewBuffersAvailable.clear();
    
22. mSnapshotBuffersAvailable.clear();
    
23. for(uint32_t i=0;i<desc->mMaxQueueable;i++)
    
24. {
    
25. mPreviewBuffersAvailable.add(&mPreviewBuffers[i],0);这里实现了mPreviewBuffersAvailable与mPreviewBuffers的关联
    
26. }
    
27. //initial ref countforundeqeueued buffersis1 since buffer provider
    
28. //isstill holdingontoit
    
29. for(uint32_t i=desc->mMaxQueueable;i<desc->mCount;i++)
    
30. {
    
31. mPreviewBuffersAvailable.add(&mPreviewBuffers[i],1);
    
32. }
    
33. }
    
34. 
    
35. if(NULL!=desc)
    
36. {
    
37. ret=useBuffers(CameraAdapter::CAMERA_PREVIEW,
    
38. desc->mBuffers,
    
39. desc->mCount,
    
40. desc->mLength,
    
41. desc->mMaxQueueable);
    
42. }
    
43. 
    
44. if(ret==NO_ERROR)
    
45. {
    
46. ret=commitState();
    
47. }
    
48. else
    
49. {
    
50. ret|=rollbackState();
    
51. }
    
52. 
    
53. break;

调用V4LCameraAdapter中的useBuffers方法，然后他会接着调用UseBuffersPreview方法：

1. status_t V4LCameraAdapter::UseBuffersPreview(CameraBuffer*bufArr,intnum)
   
2. {
   
3. intret=NO_ERROR;
   
4. LOG_FUNCTION_NAME;
   
5. 
   
6. if(NULL==bufArr){
   
7. ret=BAD_VALUE;
   
8. gotoEXIT;
   
9. }
   
10. 
    
11. ret=v4lInitMmap(num);
    
12. if(ret==NO_ERROR){
    
13. for(inti=0;i<num;i++){
    
14. //AssociateeachCamera internal buffer with the one from Overlay
    
15. mPreviewBufs.add(&bufArr[i],i);//这里实现了mPreviewBufs和desc->mBuffers的关联
    
16. CAMHAL_LOGDB("Preview- buff [%d] = 0x%x ",i,mPreviewBufs.keyAt(i));
    
17. }
    
18. 
    
19. //Update the preview buffer count
    
20. mPreviewBufferCount=num;
    
21. }
    
22. EXIT:
    
23. LOG_FUNCTION_NAME_EXIT;
    
24. return ret;
    
25. }

在这里我们还是很有必要去深入研究一下 mAppCallbackNotifier 这个变量的初始化过程，他决定很多回调函数的初始化
的初始化是在哪里实现的呢？？在在camerahal文件的initial中初始化的

1. /**
   
2. @brief Initialize the Camera HAL
   
3. 
   
4. Creates CameraAdapter,AppCallbackNotifier,DisplayAdapterandMemoryManager
   
5. 
   
6. @param None
   
7. @return NO_ERROR-Onsuccess
   
8. NO_MEMORY-Onfailuretoallocate memoryforany of the objects
   
9. @remarks Camera Hal internalfunction
   
10. 
    
11. */
    
12. 
    
13. status_t CameraHal::initialize(CameraProperties::Properties*properties)
    
14. {
    
15. LOG_FUNCTION_NAME;
    
16. 
    
17. intsensor_index=0;
    
18. constchar*sensor_name=NULL;
    
19. 
    
20. ///Initialize the event mask usedforregistering an event providerforAppCallbackNotifier
    
21. ///Currently,registering all events astobe coming from CameraAdapter
    
22. int32_t eventMask=CameraHalEvent::ALL_EVENTS;
    
23. 
    
24. //Getmy camera properties
    
25. mCameraProperties=properties;
    
26. 
    
27. if(!mCameraProperties)
    
28. {
    
29. goto fail_loop;
    
30. }
    
31. 
    
32. //Dump the properties of this Camera
    
33. //will only printifDEBUG macroisdefined
    
34. mCameraProperties->dump();
    
35. 
    
36. if(strcmp(CameraProperties::DEFAULT_VALUE,mCameraProperties->get(CameraProperties::CAMERA_SENSOR_INDEX))!=0)
    
37. {
    
38. sensor_index=atoi(mCameraProperties->get(CameraProperties::CAMERA_SENSOR_INDEX));
    
39. }
    
40. 
    
41. if(strcmp(CameraProperties::DEFAULT_VALUE,mCameraProperties->get(CameraProperties::CAMERA_NAME))!=0){
    
42. sensor_name=mCameraProperties->get(CameraProperties::CAMERA_NAME);
    
43. }
    
44. CAMHAL_LOGDB("Sensor index= %d; Sensor name= %s",sensor_index,sensor_name);
    
45. 
    
46. if(strcmp(sensor_name,V4L_CAMERA_NAME_USB)==0){
    
47. #ifdef V4L_CAMERA_ADAPTER
    
48. mCameraAdapter=V4LCameraAdapter_Factory(sensor_index);
    
49. #endif
    
50. }
    
51. else{
    
52. #ifdef OMX_CAMERA_ADAPTER
    
53. mCameraAdapter=OMXCameraAdapter_Factory(sensor_index);
    
54. #endif
    
55. }
    
56. 
    
57. if((NULL==mCameraAdapter)||(mCameraAdapter->initialize(properties)!=NO_ERROR))
    
58. {
    
59. CAMHAL_LOGEA("Unable to create or initialize CameraAdapter");
    
60. mCameraAdapter=NULL;
    
61. goto fail_loop;
    
62. }
    
63. 
    
64. mCameraAdapter->incStrong(mCameraAdapter);
    
65. mCameraAdapter->registerImageReleaseCallback(releaseImageBuffers,(void*)this);
    
66. mCameraAdapter->registerEndCaptureCallback(endImageCapture,(void*)this);
    
67. 
    
68. if(!mAppCallbackNotifier.get())
    
69. {
    
70. ///Create the callback notifier
    
71. mAppCallbackNotifier=new AppCallbackNotifier();
    
72. if((NULL==mAppCallbackNotifier.get())||(mAppCallbackNotifier->initialize()!=NO_ERROR))
    
73. {
    
74. CAMHAL_LOGEA("Unable to create or initialize AppCallbackNotifier");
    
75. goto fail_loop;
    
76. }
    
77. }
    
78. 
    
79. if(!mMemoryManager.get())
    
80. {
    
81. ///Create Memory Manager
    
82. mMemoryManager=new MemoryManager();
    
83. if((NULL==mMemoryManager.get())||(mMemoryManager->initialize()!=NO_ERROR))
    
84. {
    
85. CAMHAL_LOGEA("Unable to create or initialize MemoryManager");
    
86. goto fail_loop;
    
87. }
    
88. }
    
89. 
    
90. ///Setup theclassdependencies...
    
91. 
    
92. ///AppCallbackNotifier hastoknow wheretogetthe Camera framesandthe events like auto focus lock etc from.
    
93. ///CameraAdapteristhe one which provides those events
    
94. ///Setit as the frameandevent providersforAppCallbackNotifier
    
95. ///@remarks setEventProvider API takesina bit mask of eventsforregistering a providerforthe different events
    
96. ///That way,ifevents can come from DisplayAdapterinfuture,we will be abletoadd it as provider
    
97. ///forany event
    
98. mAppCallbackNotifier->setEventProvider(eventMask,mCameraAdapter);
    
99. mAppCallbackNotifier->setFrameProvider(mCameraAdapter);
    
100. 
     
101. ///Any dynamic errors that happen during the camera usecasehastobe propagated backtothe application
     
102. ///via CAMERA_MSG_ERROR.AppCallbackNotifieristheclassthat notifies such errorstothe application
     
103. ///Setit as theerrorhandlerforCameraAdapter
     
104. mCameraAdapter->setErrorHandler(mAppCallbackNotifier.get());
     
105. 
     
106. ///Start the callback notifier
     
107. if(mAppCallbackNotifier->start()!=NO_ERROR)
     
108. {
     
109. CAMHAL_LOGEA("Couldn't start AppCallbackNotifier");
     
110. goto fail_loop;
     
111. }
     
112. 
     
113. CAMHAL_LOGDA("Started AppCallbackNotifier..");
     
114. mAppCallbackNotifier->setMeasurements(mMeasurementEnabled);
     
115. 
     
116. ///Initialize default parameters
     
117. initDefaultParameters();
     
118. 
     
119. 
     
120. if(setParameters(mParameters)!=NO_ERROR)
     
121. {
     
122. CAMHAL_LOGEA("Failed to set default parameters?!");
     
123. }
     
124. 
     
125. //registerforsensor events
     
126. mSensorListener=new SensorListener();
     
127. if(mSensorListener.get()){
     
128. if(mSensorListener->initialize()==NO_ERROR){
     
129. mSensorListener->setCallbacks(orientation_cb,this);
     
130. mSensorListener->enableSensor(SensorListener::SENSOR_ORIENTATION);
     
131. }else{
     
132. CAMHAL_LOGEA("Error initializing SensorListener. not fatal, continuing");
     
133. mSensorListener.clear();
     
134. mSensorListener=NULL;
     
135. }
     
136. }
     
137. 
     
138. LOG_FUNCTION_NAME_EXIT;
     
139. 
     
140. return NO_ERROR;
     
141. 
     
142. fail_loop:
     
143. 
     
144. ///Free up the resources because we failed somewhere up
     
145. deinitialize();
     
146. LOG_FUNCTION_NAME_EXIT;
     
147. 
     
148. return NO_MEMORY;
     
149. 
     
150. }

这里实例化了一些对象，我真正关注的是 mAppCallbackNotifier 这个对象，实例化这个对象，并且initialize，并且设置EventProvider和FrameProvider
我们就看一下setFrameProvider这个方法都做了什么事情，

1. void AppCallbackNotifier::setFrameProvider(FrameNotifier*frameNotifier)
   
2. {
   
3. LOG_FUNCTION_NAME;
   
4. ///@remarks ThereisnoNULLcheck here.We will check
   
5. ///forNULLwhen wegetthe start command from CameraAdapter
   
6. mFrameProvider=new FrameProvider(frameNotifier,this,frameCallbackRelay);
   
7. if(NULL==mFrameProvider)
   
8. {
   
9. CAMHAL_LOGEA("Error in creating FrameProvider");
   
10. }
    
11. else
    
12. {
    
13. //Register onlyforcaptured imagesandRAWfornow
    
14. //TODO:Registerforandhandle all types of frames
    
15. mFrameProvider->enableFrameNotification(CameraFrame::IMAGE_FRAME);
    
16. mFrameProvider->enableFrameNotification(CameraFrame::RAW_FRAME);
    
17. }
    
18. 
    
19. LOG_FUNCTION_NAME_EXIT;
    
20. }

实例化一个FrameProvider对象，并且enable响应notification，这里实例化的对象里面的参数中有一个frameCallbackRely是一个回调函数，这里我们暂且回过头看看previewthread中的那个方法 sendFrameToSubscribers
这个方法只是调用了下面这个方法实现：

1. status_t BaseCameraAdapter::__sendFrameToSubscribers(CameraFrame*frame,
   
2. KeyedVector<int,frame_callback>*subscribers,
   
3. CameraFrame::FrameType frameType)
   
4. {
   
5. size_t refCount=0;
   
6. status_t ret=NO_ERROR;
   
7. frame_callback callback=NULL;
   
8. 
   
9. frame->mFrameType=frameType;
   
10. 
    
11. if((frameType==CameraFrame::PREVIEW_FRAME_SYNC)||
    
12. (frameType==CameraFrame::VIDEO_FRAME_SYNC)||
    
13. (frameType==CameraFrame::SNAPSHOT_FRAME)){
    
14. if(mFrameQueue.size()>0){
    
15. CameraFrame*lframe=(CameraFrame*)mFrameQueue.valueFor(frame->mBuffer);
    
16. frame->mYuv[0]=lframe->mYuv[0];
    
17. frame->mYuv[1]=frame->mYuv[0]+(frame->mLength+frame->mOffset)*2/3;
    
18. }
    
19. else{
    
20. CAMHAL_LOGDA("Empty Frame Queue");
    
21. return-EINVAL;
    
22. }
    
23. }
    
24. 
    
25. if(NULL!=subscribers){
    
26. refCount=getFrameRefCount(frame->mBuffer,frameType);
    
27. 
    
28. if(refCount==0){
    
29. CAMHAL_LOGDA("Invalid ref count of 0");
    
30. return-EINVAL;
    
31. }
    
32. 
    
33. if(refCount>subscribers->size()){
    
34. CAMHAL_LOGEB("Invalid ref count for frame type: 0x%x",frameType);
    
35. return-EINVAL;
    
36. }
    
37. 
    
38. CAMHAL_LOGVB("Type of Frame: 0x%x address: 0x%x refCount start %d",
    
39. frame->mFrameType,
    
40. (uint32_t)frame->mBuffer,
    
41. refCount);
    
42. 
    
43. for(unsignedinti=0;i<refCount;i++){
    
44. frame->mCookie=(void*)subscribers->keyAt(i);
    
45. callback=(frame_callback)subscribers->valueAt(i);
    
46. 
    
47. if(!callback){
    
48. CAMHAL_LOGEB("callback not set for frame type: 0x%x",frameType);
    
49. return-EINVAL;
    
50. }
    
51. 
    
52. callback(frame);
    
53. }
    
54. }else{
    
55. CAMHAL_LOGEA("Subscribers is null??");
    
56. return-EINVAL;
    
57. }
    
58. 
    
59. return ret;
    
60. }

最重要的部分我在上面已经表示出来，通过subscribers这个全局KeyedVector变量找到相应的frame->mCookie和callback方法，
这里所要获取到的callback方法就是上面setFrameProvider时引入的 frameCallbackRelay 这个函数，我们看看这个函数的具体实现

1. void AppCallbackNotifier::frameCallbackRelay(CameraFrame*caFrame)
   
2. {
   
3. LOG_FUNCTION_NAME;
   
4. AppCallbackNotifier*appcbn=(AppCallbackNotifier*)(caFrame->mCookie);
   
5. appcbn->frameCallback(caFrame);
   
6. LOG_FUNCTION_NAME_EXIT;
   
7. }
   
8. 
   
9. void AppCallbackNotifier::frameCallback(CameraFrame*caFrame)
   
10. {
    
11. ///Post the eventtothe event queue of AppCallbackNotifier
    
12. TIUTILS::Message msg;
    
13. CameraFrame*frame;
    
14. 
    
15. LOG_FUNCTION_NAME;
    
16. 
    
17. if(NULL!=caFrame)
    
18. {
    
19. 
    
20. frame=new CameraFrame(*caFrame);
    
21. if(NULL!=frame)
    
22. {
    
23. msg.command=AppCallbackNotifier::NOTIFIER_CMD_PROCESS_FRAME;
    
24. msg.arg1=frame;
    
25. mFrameQ.put(&msg);
    
26. }
    
27. else
    
28. {
    
29. CAMHAL_LOGEA("Not enough resources to allocate CameraFrame");
    
30. }
    
31. 
    
32. }
    
33. 
    
34. LOG_FUNCTION_NAME_EXIT;
    
35. }

这个回调函数只是将数据装载入mag这个消息结构体，比且把这个消息put到mFrameQ这个全局消息中心，app就是从这个消息中心把数据取走的
我们可以看一下在 AppCallbackNotifier初始化的时候就调用了initialize做一下初始设置

1. /**
   
2. *NotificationHandlerclass
   
3. */
   
4. 
   
5. ///InitializationfunctionforAppCallbackNotifier
   
6. status_t AppCallbackNotifier::initialize()
   
7. {
   
8. LOG_FUNCTION_NAME;
   
9. 
   
10. mPreviewMemory=0;
    
11. 
    
12. mMeasurementEnabled=false;
    
13. 
    
14. mNotifierState=NOTIFIER_STOPPED;
    
15. 
    
16. ///Create the app notifier thread
    
17. mNotificationThread=new NotificationThread(this);
    
18. if(!mNotificationThread.get())
    
19. {
    
20. CAMHAL_LOGEA("Couldn't create Notification thread");
    
21. return NO_MEMORY;
    
22. }
    
23. 
    
24. ///Start the display thread
    
25. status_t ret=mNotificationThread->run("NotificationThread",PRIORITY_URGENT_DISPLAY);
    
26. if(ret!=NO_ERROR)
    
27. {
    
28. CAMHAL_LOGEA("Couldn't run NotificationThread");
    
29. mNotificationThread.clear();
    
30. return ret;
    
31. }
    
32. 
    
33. mUseMetaDataBufferMode=true;
    
34. mRawAvailable=false;
    
35. 
    
36. mRecording=false;
    
37. mPreviewing=false;
    
38. 
    
39. LOG_FUNCTION_NAME_EXIT;
    
40. 
    
41. return ret;
    
42. }

这个初始化的方法里面最重要就是开启了一个线程，用来监听HAL层发送来的一切消息，并在其中将消息或者数据告诉app，看看这个线程的具体实现

1. bool AppCallbackNotifier::notificationThread()
   
2. {
   
3. bool shouldLive=true;
   
4. status_t ret;
   
5. 
   
6. LOG_FUNCTION_NAME;
   
7. 
   
8. //CAMHAL_LOGDA("Notification Thread waiting for message");
   
9. ret=TIUTILS::MessageQueue::waitForMsg(&mNotificationThread->msgQ(),
   
10. &mEventQ,
    
11. &mFrameQ,
    
12. AppCallbackNotifier::NOTIFIER_TIMEOUT);
    
13. 
    
14. //CAMHAL_LOGDA("Notification Thread received message");
    
15. 
    
16. if(mNotificationThread->msgQ().hasMsg()){
    
17. ///Received a message from CameraHal,process it
    
18. CAMHAL_LOGDA("Notification Thread received message from Camera HAL");
    
19. shouldLive=processMessage();
    
20. if(!shouldLive){
    
21. CAMHAL_LOGDA("Notification Thread exiting.");
    
22. return shouldLive;
    
23. }
    
24. }
    
25. 
    
26. if(mEventQ.hasMsg()){
    
27. ///Received an event from one of the event providers
    
28. CAMHAL_LOGDA("Notification Thread received an event from event provider (CameraAdapter)");
    
29. notifyEvent();
    
30. }
    
31. 
    
32. if(mFrameQ.hasMsg()){
    
33. ///Received a frame from one of the frame providers
    
34. //CAMHAL_LOGDA("Notification Thread received a frame from frame provider (CameraAdapter)");
    
35. notifyFrame();
    
36. }
    
37. 
    
38. LOG_FUNCTION_NAME_EXIT;
    
39. return shouldLive;
    
40. }

这里等待到有消息时，我们直接分析我需要的，preview，如果检测到mFrameQ中有消息，则调用notifyFrame方法

1. void AppCallbackNotifier::notifyFrame()
   
2. {
   
3. ///Receiveandsend the frame notificationstoapp
   
4. TIUTILS::Message msg;
   
5. CameraFrame*frame;
   
6. MemoryHeapBase*heap;
   
7. MemoryBase*buffer=NULL;
   
8. sp<MemoryBase>memBase;
   
9. void*buf=NULL;
   
10. 
    
11. LOG_FUNCTION_NAME;
    
12. 
    
13. {
    
14. Mutex::Autolock lock(mLock);
    
15. if(!mFrameQ.isEmpty()){
    
16. mFrameQ.get(&msg);
    
17. }else{
    
18. return;
    
19. }
    
20. }
    
21. 
    
22. bool ret=true;
    
23. 
    
24. frame=NULL;
    
25. switch(msg.command)
    
26. {
    
27. caseAppCallbackNotifier::NOTIFIER_CMD_PROCESS_FRAME:
    
28. 
    
29. frame=(CameraFrame*)msg.arg1;
    
30. if(!frame)
    
31. {
    
32. break;
    
33. }
    
34. 
    
35. if((CameraFrame::RAW_FRAME==frame->mFrameType)&&
    
36. (NULL!=mCameraHal)&&
    
37. (NULL!=mDataCb)&&
    
38. (NULL!=mNotifyCb))
    
39. {
    
40. 
    
41. if(mCameraHal->msgTypeEnabled(CAMERA_MSG_RAW_IMAGE))
    
42. {
    
43. #ifdef COPY_IMAGE_BUFFER
    
44. copyAndSendPictureFrame(frame,CAMERA_MSG_RAW_IMAGE);
    
45. #else
    
46. //TODO:Find a waytomap a Tiler buffertoa MemoryHeapBase
    
47. #endif
    
48. }
    
49. else{
    
50. if(mCameraHal->msgTypeEnabled(CAMERA_MSG_RAW_IMAGE_NOTIFY)){
    
51. mNotifyCb(CAMERA_MSG_RAW_IMAGE_NOTIFY,0,0,mCallbackCookie);
    
52. }
    
53. mFrameProvider->returnFrame(frame->mBuffer,
    
54. (CameraFrame::FrameType)frame->mFrameType);
    
55. }
    
56. 
    
57. mRawAvailable=true;
    
58. 
    
59. }
    
60. elseif((CameraFrame::IMAGE_FRAME==frame->mFrameType)&&
    
61. (NULL!=mCameraHal)&&
    
62. (NULL!=mDataCb)&&
    
63. (CameraFrame::ENCODE_RAW_YUV422I_TO_JPEG&frame->mQuirks))
    
64. {
    
65. 
    
66. intencode_quality=100,tn_quality=100;
    
67. inttn_width,tn_height;
    
68. unsignedintcurrent_snapshot=0;
    
69. Encoder_libjpeg::params*main_jpeg=NULL,*tn_jpeg=NULL;
    
70. void*exif_data=NULL;
    
71. constchar*previewFormat=NULL;
    
72. camera_memory_t*raw_picture=mRequestMemory(-1,frame->mLength,1,NULL);
    
73. 
    
74. if(raw_picture){
    
75. buf=raw_picture->data;
    
76. }
    
77. 
    
78. CameraParameters parameters;
    
79. char*params=mCameraHal->getParameters();
    
80. constString8 strParams(params);
    
81. parameters.unflatten(strParams);
    
82. 
    
83. encode_quality=parameters.getInt(CameraParameters::KEY_JPEG_QUALITY);
    
84. if(encode_quality<0||encode_quality>100){
    
85. encode_quality=100;
    
86. }
    
87. 
    
88. tn_quality=parameters.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY);
    
89. if(tn_quality<0||tn_quality>100){
    
90. tn_quality=100;
    
91. }
    
92. 
    
93. if(CameraFrame::HAS_EXIF_DATA&frame->mQuirks){
    
94. exif_data=frame->mCookie2;
    
95. }
    
96. 
    
97. main_jpeg=(Encoder_libjpeg::params*)
    
98. malloc(sizeof(Encoder_libjpeg::params));
    
99. 
    
100. //Video snapshot with LDCNSFonadds a few bytes start offset
     
101. //anda few bytesonevery line.They must be skipped.
     
102. intrightCrop=frame->mAlignment/2-frame->mWidth;
     
103. 
     
104. CAMHAL_LOGDB("Video snapshot right crop = %d",rightCrop);
     
105. CAMHAL_LOGDB("Video snapshot offset = %d",frame->mOffset);
     
106. 
     
107. if(main_jpeg){
     
108. main_jpeg->src=(uint8_t*)frame->mBuffer->mapped;
     
109. main_jpeg->src_size=frame->mLength;
     
110. main_jpeg->dst=(uint8_t*)buf;
     
111. main_jpeg->dst_size=frame->mLength;
     
112. main_jpeg->quality=encode_quality;
     
113. main_jpeg->in_width=frame->mAlignment/2;//use stride here
     
114. main_jpeg->in_height=frame->mHeight;
     
115. main_jpeg->out_width=frame->mAlignment/2;
     
116. main_jpeg->out_height=frame->mHeight;
     
117. main_jpeg->right_crop=rightCrop;
     
118. main_jpeg->start_offset=frame->mOffset;
     
119. if(CameraFrame::FORMAT_YUV422I_UYVY&frame->mQuirks){
     
120. main_jpeg->format=TICameraParameters::PIXEL_FORMAT_YUV422I_UYVY;
     
121. }
     
122. else{//if(CameraFrame::FORMAT_YUV422I_YUYV&frame->mQuirks)
     
123. main_jpeg->format=CameraParameters::PIXEL_FORMAT_YUV422I;
     
124. }
     
125. }
     
126. 
     
127. tn_width=parameters.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH);
     
128. tn_height=parameters.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);
     
129. previewFormat=parameters.getPreviewFormat();
     
130. 
     
131. if((tn_width>0)&&(tn_height>0)&&(NULL!=previewFormat)){
     
132. tn_jpeg=(Encoder_libjpeg::params*)
     
133. malloc(sizeof(Encoder_libjpeg::params));
     
134. //ifmalloc fails just keep goingandencode main jpeg
     
135. if(!tn_jpeg){
     
136. tn_jpeg=NULL;
     
137. }
     
138. }
     
139. 
     
140. if(tn_jpeg){
     
141. intwidth,height;
     
142. parameters.getPreviewSize(&width,&height);
     
143. current_snapshot=(mPreviewBufCount+MAX_BUFFERS-1)%MAX_BUFFERS;
     
144. tn_jpeg->src=(uint8_t*)mPreviewBuffers[current_snapshot].mapped;
     
145. tn_jpeg->src_size=mPreviewMemory->size/MAX_BUFFERS;
     
146. tn_jpeg->dst_size=calculateBufferSize(tn_width,
     
147. tn_height,
     
148. previewFormat);
     
149. tn_jpeg->dst=(uint8_t*)malloc(tn_jpeg->dst_size);
     
150. tn_jpeg->quality=tn_quality;
     
151. tn_jpeg->in_width=width;
     
152. tn_jpeg->in_height=height;
     
153. tn_jpeg->out_width=tn_width;
     
154. tn_jpeg->out_height=tn_height;
     
155. tn_jpeg->right_crop=0;
     
156. tn_jpeg->start_offset=0;
     
157. tn_jpeg->format=CameraParameters::PIXEL_FORMAT_YUV420SP;;
     
158. }
     
159. 
     
160. sp<Encoder_libjpeg>encoder=new Encoder_libjpeg(main_jpeg,
     
161. tn_jpeg,
     
162. AppCallbackNotifierEncoderCallback,
     
163. (CameraFrame::FrameType)frame->mFrameType,
     
164. this,
     
165. raw_picture,
     
166. exif_data,frame->mBuffer);
     
167. gEncoderQueue.add(frame->mBuffer->mapped,encoder);
     
168. encoder->run();
     
169. encoder.clear();
     
170. if(params!=NULL)
     
171. {
     
172. mCameraHal->putParameters(params);
     
173. }
     
174. }
     
175. elseif((CameraFrame::IMAGE_FRAME==frame->mFrameType)&&
     
176. (NULL!=mCameraHal)&&
     
177. (NULL!=mDataCb))
     
178. {
     
179. 
     
180. //CTS,MTS requirements:Every'takePicture()'call
     
181. //who registers a raw callback should receive one
     
182. //as well.Thisisnotalways thecasewith
     
183. //CameraAdapters though.
     
184. if(!mCameraHal->msgTypeEnabled(CAMERA_MSG_RAW_IMAGE)){
     
185. dummyRaw();
     
186. }else{
     
187. mRawAvailable=false;
     
188. }
     
189. 
     
190. #ifdef COPY_IMAGE_BUFFER
     
191. {
     
192. Mutex::Autolock lock(mBurstLock);
     
193. #ifdefined(OMAP_ENHANCEMENT)
     
194. if(mBurst)
     
195. {
     
196. copyAndSendPictureFrame(frame,CAMERA_MSG_COMPRESSED_BURST_IMAGE);
     
197. }
     
198. else
     
199. #endif
     
200. {
     
201. copyAndSendPictureFrame(frame,CAMERA_MSG_COMPRESSED_IMAGE);
     
202. }
     
203. }
     
204. #else
     
205. //TODO:Find a waytomap a Tiler buffertoa MemoryHeapBase
     
206. #endif
     
207. }
     
208. elseif((CameraFrame::VIDEO_FRAME_SYNC==frame->mFrameType)&&
     
209. (NULL!=mCameraHal)&&
     
210. (NULL!=mDataCb)&&
     
211. (mCameraHal->msgTypeEnabled(CAMERA_MSG_VIDEO_FRAME)))
     
212. {
     
213. AutoMutex locker(mRecordingLock);
     
214. if(mRecording)
     
215. {
     
216. if(mUseMetaDataBufferMode)
     
217. {
     
218. camera_memory_t*videoMedatadaBufferMemory=
     
219. mVideoMetadataBufferMemoryMap.valueFor(frame->mBuffer->opaque);
     
220. video_metadata_t*videoMetadataBuffer=(video_metadata_t*)videoMedatadaBufferMemory->data;
     
221. 
     
222. if((NULL==videoMedatadaBufferMemory)||(NULL==videoMetadataBuffer)||(NULL==frame->mBuffer))
     
223. {
     
224. CAMHAL_LOGEA("Error! One of the video buffers is NULL");
     
225. break;
     
226. }
     
227. 
     
228. if(mUseVideoBuffers)
     
229. {
     
230. CameraBuffer*vBuf=mVideoMap.valueFor(frame->mBuffer->opaque);
     
231. GraphicBufferMapper&mapper=GraphicBufferMapper::get();
     
232. Rect bounds;
     
233. bounds.left=0;
     
234. bounds.top=0;
     
235. bounds.right=mVideoWidth;
     
236. bounds.bottom=mVideoHeight;
     
237. 
     
238. void*y_uv[2];
     
239. mapper.lock((buffer_handle_t)vBuf,CAMHAL_GRALLOC_USAGE,bounds,y_uv);
     
240. y_uv[1]=y_uv[0]+mVideoHeight*4096;
     
241. 
     
242. structConvImage input={frame->mWidth,
     
243. frame->mHeight,
     
244. 4096,
     
245. IC_FORMAT_YCbCr420_lp,
     
246. (mmByte*)frame->mYuv[0],
     
247. (mmByte*)frame->mYuv[1],
     
248. frame->mOffset};
     
249. 
     
250. structConvImage output={mVideoWidth,
     
251. mVideoHeight,
     
252. 4096,
     
253. IC_FORMAT_YCbCr420_lp,
     
254. (mmByte*)y_uv[0],
     
255. (mmByte*)y_uv[1],
     
256. 0};
     
257. 
     
258. VT_resizeFrame_Video_opt2_lp(&input,&output,NULL,0);
     
259. mapper.unlock((buffer_handle_t)vBuf->opaque);
     
260. videoMetadataBuffer->metadataBufferType=(int)kMetadataBufferTypeCameraSource;
     
261. /*FIXME remove cast*/
     
262. videoMetadataBuffer->handle=(void*)vBuf->opaque;
     
263. videoMetadataBuffer->offset=0;
     
264. }
     
265. else
     
266. {
     
267. videoMetadataBuffer->metadataBufferType=(int)kMetadataBufferTypeCameraSource;
     
268. videoMetadataBuffer->handle=camera_buffer_get_omx_ptr(frame->mBuffer);
     
269. videoMetadataBuffer->offset=frame->mOffset;
     
270. }
     
271. 
     
272. CAMHAL_LOGVB("mDataCbTimestamp : frame->mBuffer=0x%x, videoMetadataBuffer=0x%x, videoMedatadaBufferMemory=0x%x",
     
273. frame->mBuffer->opaque,videoMetadataBuffer,videoMedatadaBufferMemory);
     
274. 
     
275. mDataCbTimestamp(frame->mTimestamp,CAMERA_MSG_VIDEO_FRAME,
     
276. videoMedatadaBufferMemory,0,mCallbackCookie);
     
277. }
     
278. else
     
279. {
     
280. //TODO:Needtorevisit this,should ideally be mapping the TILER buffer using mRequestMemory
     
281. camera_memory_t*fakebuf=mRequestMemory(-1,sizeof(buffer_handle_t),1,NULL);
     
282. if((NULL==fakebuf)||(NULL==fakebuf->data)||(NULL==frame->mBuffer))
     
283. {
     
284. CAMHAL_LOGEA("Error! One of the video buffers is NULL");
     
285. break;
     
286. }
     
287. 
     
288. *reinterpret_cast<buffer_handle_t*>(fakebuf->data)=reinterpret_cast<buffer_handle_t>(frame->mBuffer->mapped);
     
289. mDataCbTimestamp(frame->mTimestamp,CAMERA_MSG_VIDEO_FRAME,fakebuf,0,mCallbackCookie);
     
290. fakebuf->release(fakebuf);
     
291. }
     
292. }
     
293. }
     
294. elseif((CameraFrame::SNAPSHOT_FRAME==frame->mFrameType)&&
     
295. (NULL!=mCameraHal)&&
     
296. (NULL!=mDataCb)&&
     
297. (NULL!=mNotifyCb)){
     
298. //When enabled,measurement dataissent instead of video data
     
299. if(!mMeasurementEnabled){
     
300. copyAndSendPreviewFrame(frame,CAMERA_MSG_POSTVIEW_FRAME);
     
301. }else{
     
302. mFrameProvider->returnFrame(frame->mBuffer,
     
303. (CameraFrame::FrameType)frame->mFrameType);
     
304. }
     
305. }
     
306. elseif((CameraFrame::PREVIEW_FRAME_SYNC==frame->mFrameType)&&
     
307. (NULL!=mCameraHal)&&
     
308. (NULL!=mDataCb)&&
     
309. (mCameraHal->msgTypeEnabled(CAMERA_MSG_PREVIEW_FRAME))){
     
310. //When enabled,measurement dataissent instead of video data
     
311. if(!mMeasurementEnabled){
     
312. copyAndSendPreviewFrame(frame,CAMERA_MSG_PREVIEW_FRAME);
     
313. }else{
     
314. mFrameProvider->returnFrame(frame->mBuffer,
     
315. (CameraFrame::FrameType)frame->mFrameType);
     
316. }
     
317. }
     
318. elseif((CameraFrame::FRAME_DATA_SYNC==frame->mFrameType)&&
     
319. (NULL!=mCameraHal)&&
     
320. (NULL!=mDataCb)&&
     
321. (mCameraHal->msgTypeEnabled(CAMERA_MSG_PREVIEW_FRAME))){
     
322. copyAndSendPreviewFrame(frame,CAMERA_MSG_PREVIEW_FRAME);
     
323. }else{
     
324. mFrameProvider->returnFrame(frame->mBuffer,
     
325. (CameraFrame::FrameType)frame->mFrameType);
     
326. CAMHAL_LOGDB("Frame type 0x%x is still unsupported!",frame->mFrameType);
     
327. }
     
328. 
     
329. break;
     
330. 
     
331. default:
     
332. 
     
333. break;
     
334. 
     
335. };
     
336. 
     
337. exit:
     
338. 
     
339. if(NULL!=frame)
     
340. {
     
341. delete frame;
     
342. }
     
343. 
     
344. LOG_FUNCTION_NAME_EXIT;
     
345. }

这里对不同的操作方式做了不同的处理，我们还是先通过preview过程作分析，如上面标注的那样处理，这里看看 copyAndSendPreviewFrame 的实现方法：

1. void AppCallbackNotifier::copyAndSendPreviewFrame(CameraFrame*frame,int32_t msgType)
   
2. {
   
3. camera_memory_t*picture=NULL;
   
4. CameraBuffer*dest=NULL;
   
5. 
   
6. //scopeforlock
   
7. {
   
8. Mutex::Autolock lock(mLock)

更多相关文章

1. 2010-02-27 传智播客—Android（二）数据存储和访问 之文件
2. Android多个APK共享数据（Shared User ID）
3. Android 解决65535的限制 使用android-support-multidex解决Dex
4. Android 应用语言切换的三种方法
5. Android CheckBox中设置padding无效问题解决方法
6. android: 横竖屏切换总结-布局改变和数据保存

随机推荐

1. Android——build.prop 解析
2. android开机启动的问题，android:installLo
3. android 获取屏幕分辨率
4. Android的日志系统分层与logcat使用
5. Android应用程序上传错误The package nam
6. 传智播客Android视频教程——第六天
7. Android：控件属性
8. android Textview属性细节以及EditText属
9. 设置TextView文字居中
10. Android(安卓)基础总结：（四）Activity(Instan