Android Camera数据流分析全程记录（overlay方式） ​
这篇文章接着上一篇文章继续： http://blog.chinaunix.net/uid-26765074-id-3568436.html
上一篇文章overlay这个过程已经走了一遍，但是根本是这个流程还没有走完，由上一篇文章知道，最后调用了postFrame方法， postFrame这个方法都实现了什么样的功能呢？？？他是怎样是的从driver获得的数据最终显示成图像的呢？？
这个问题我一直在寻求答案，不过很悲催啊？？这个postFrame方法我始终没有理解清楚，这里有多少说多少自己的看法，希望有大神能指点指点
这里就从postFrame入手了：

1. status_t ANativeWindowDisplayAdapter::PostFrame(ANativeWindowDisplayAdapter::DisplayFrame&dispFrame)
   
2. {
   
3. status_t ret=NO_ERROR;
   
4. uint32_t actualFramesWithDisplay=0;
   
5. android_native_buffer_t*buffer=NULL;
   
6. GraphicBufferMapper&mapper=GraphicBufferMapper::get();
   
7. inti;
   
8. 
   
9. ///@todoDocropping basedonthe stabilized frame coordinates
   
10. ///@todo Insert logictodrop frames here basedonrefresh rate of
    
11. ///displayorrendering rate whicheverislower
    
12. ///Queue the buffertooverlay
    
13. 
    
14. if(NULL==mANativeWindow){
    
15. return NO_INIT;
    
16. }
    
17. 
    
18. if(!mBuffers||!dispFrame.mBuffer){
    
19. CAMHAL_LOGEA("NULL sent to PostFrame");
    
20. return BAD_VALUE;
    
21. }
    
22. 
    
23. for(i=0;i<mBufferCount;i++)
    
24. {
    
25. if(dispFrame.mBuffer==&mBuffers[i])
    
26. {
    
27. break;
    
28. }
    
29. }
    
30. 
    
31. 
    
32. mFramesType.add((int)mBuffers[i].opaque,dispFrame.mType);
    
33. 
    
34. if(mDisplayState==ANativeWindowDisplayAdapter::DISPLAY_STARTED&&
    
35. (!mPaused||CameraFrame::CameraFrame::SNAPSHOT_FRAME==dispFrame.mType)&&
    
36. !mSuspend)
    
37. {
    
38. Mutex::Autolock lock(mLock);
    
39. uint32_t xOff=(dispFrame.mOffset%PAGE_SIZE);
    
40. uint32_t yOff=(dispFrame.mOffset/PAGE_SIZE);
    
41. 
    
42. //Setcrop onlyifcurrent xandy offsetsdonotmatch with frame offsets
    
43. if((mXOff!=xOff)||(mYOff!=yOff))
    
44. {
    
45. CAMHAL_LOGDB("Offset %d xOff = %d, yOff = %d",dispFrame.mOffset,xOff,yOff);
    
46. uint8_t bytesPerPixel;
    
47. ///Calculate bytes per pixel basedonthe pixel format
    
48. if(strcmp(mPixelFormat,(constchar*)CameraParameters::PIXEL_FORMAT_YUV422I)==0)
    
49. {
    
50. bytesPerPixel=2;
    
51. }
    
52. elseif(strcmp(mPixelFormat,(constchar*)CameraParameters::PIXEL_FORMAT_RGB565)==0)
    
53. {
    
54. bytesPerPixel=2;
    
55. }
    
56. elseif(strcmp(mPixelFormat,(constchar*)CameraParameters::PIXEL_FORMAT_YUV420SP)==0)
    
57. {
    
58. bytesPerPixel=1;
    
59. }
    
60. else
    
61. {
    
62. bytesPerPixel=1;
    
63. }
    
64. 
    
65. CAMHAL_LOGVB(" crop.left = %d crop.top = %d crop.right = %d crop.bottom = %d",
    
66. xOff/bytesPerPixel,yOff,(xOff/bytesPerPixel)+mPreviewWidth,yOff+mPreviewHeight);
    
67. //We'll ignore any errors here,ifthe surfaceis
    
68. //already invalid,we'll know soon enough.
    
69. mANativeWindow->set_crop(mANativeWindow,xOff/bytesPerPixel,yOff,
    
70. (xOff/bytesPerPixel)+mPreviewWidth,yOff+mPreviewHeight);
    
71. 
    
72. ///Update the current xandy offsets
    
73. mXOff=xOff;
    
74. mYOff=yOff;
    
75. }
    
76. //这里说说自己对以上代码的理解，上面通过传入的displayFrame类型变量check，传入的配置是否与系统此时实际显示属性一致，不一致，则从新进行裁剪，配置显示大小，位置等
    
77. {
    
78. buffer_handle_t*handle=(buffer_handle_t*)mBuffers[i].opaque;
    
79. //unlock buffer before sendingtodisplay
    
80. mapper.unlock(*handle);
    
81. ret=mANativeWindow->enqueue_buffer(mANativeWindow,handle);//这里将buffer入栈，下面会分析道这个函数的由来
    
82. }
    
83. if(NO_ERROR!=ret){
    
84. CAMHAL_LOGE("Surface::queueBuffer returned error %d",ret);
    
85. }
    
86. 
    
87. mFramesWithCameraAdapterMap.removeItem((buffer_handle_t*)dispFrame.mBuffer->opaque);
    
88. 
    
89. 
    
90. //HWComposer hasnotminimum buffer requirement.We should be abletodequeue
    
91. //the buffer immediately
    
92. TIUTILS::Message msg;
    
93. mDisplayQ.put(&msg);
    
94. 
    
95. 
    
96. #ifPPM_INSTRUMENTATION||PPM_INSTRUMENTATION_ABS
    
97. 
    
98. if(mMeasureStandby)
    
99. {
    
100. CameraHal::PPM("Standby to first shot: Sensor Change completed - ",&mStandbyToShot);
     
101. mMeasureStandby=false;
     
102. }
     
103. elseif(CameraFrame::CameraFrame::SNAPSHOT_FRAME==dispFrame.mType)
     
104. {
     
105. CameraHal::PPM("Shot to snapshot: ",&mStartCapture);
     
106. mShotToShot=true;
     
107. }
     
108. elseif(mShotToShot)
     
109. {
     
110. CameraHal::PPM("Shot to shot: ",&mStartCapture);
     
111. mShotToShot=false;
     
112. }
     
113. #endif
     
114. 
     
115. }
     
116. else
     
117. {
     
118. Mutex::Autolock lock(mLock);
     
119. buffer_handle_t*handle=(buffer_handle_t*)mBuffers[i].opaque;
     
120. 
     
121. //unlock buffer before giving it up
     
122. mapper.unlock(*handle);
     
123. 
     
124. //cancel bufferanddequeue another one
     
125. ret=mANativeWindow->cancel_buffer(mANativeWindow,handle);
     
126. if(NO_ERROR!=ret){
     
127. CAMHAL_LOGE("Surface::cancelBuffer returned error %d",ret);
     
128. }
     
129. 
     
130. mFramesWithCameraAdapterMap.removeItem((buffer_handle_t*)dispFrame.mBuffer->opaque);
     
131. 
     
132. TIUTILS::Message msg;
     
133. mDisplayQ.put(&msg);
     
134. ret=NO_ERROR;
     
135. }
     
136. 
     
137. return ret;
     
138. }

我们还是着重分析一下这个方法吧： mANativeWindow - > enqueue_buffer ( mANativeWindow , handle )
首先要找的mANativewindow这个变量类型的定义，找了好久才找到的，悲催：system\core\include\system\Window.h

1. struct ANativeWindow
   
2. {
   
3. #ifdef __cplusplus
   
4. ANativeWindow()
   
5. :flags(0),minSwapInterval(0),maxSwapInterval(0),xdpi(0),ydpi(0)
   
6. {
   
7. common.magic=ANDROID_NATIVE_WINDOW_MAGIC;
   
8. common.version=sizeof(ANativeWindow);
   
9. memset(common.reserved,0,sizeof(common.reserved));
   
10. }
    
11. 
    
12. /*Implement the methods that sp<ANativeWindow>expects so that it
    
13. can be usedtoautomatically refcount ANativeWindow's.*/
    
14. void incStrong(constvoid*id)const{
    
15. common.incRef(const_cast<android_native_base_t*>(&common));
    
16. }
    
17. void decStrong(constvoid*id)const{
    
18. common.decRef(const_cast<android_native_base_t*>(&common));
    
19. }
    
20. #endif
    
21. 
    
22. struct android_native_base_t common;
    
23. 
    
24. /*flags describing some attributes of this surfaceorits updater*/
    
25. constuint32_t flags;
    
26. 
    
27. /*min swap interval supported by this updated*/
    
28. constintminSwapInterval;
    
29. 
    
30. /*max swap interval supported by this updated*/
    
31. constintmaxSwapInterval;
    
32. 
    
33. /*horizontalandvertical resolutioninDPI*/
    
34. constfloat xdpi;
    
35. constfloat ydpi;
    
36. 
    
37. /*Some storage reservedforthe OEM's driver.*/
    
38. intptr_t oem[4];
    
39. 
    
40. /*
    
41. *Setthe swap intervalforthis surface.
    
42. *
    
43. *Returns 0onsuccessor-errnoonerror.
    
44. */
    
45. int(*setSwapInterval)(struct ANativeWindow*window,intinterval);
46. 
    
47. /*
    
48. *hook called by EGLtoacquire a buffer.After thiscall,the buffer
    
49. *isnotlocked,so its content cannot be modified.
    
50. *thiscallmay blockifno buffers are available.
    
51. *
    
52. *Returns 0onsuccessor-errnoonerror.
    
53. */
    
54. int(*dequeueBuffer)(struct ANativeWindow*window,struct ANativeWindowBuffer**buffer);
55. 
    
56. /*
    
57. *hook called by EGLtolock a buffer.This MUST be called before modifying
    
58. *the content of a buffer.The buffer must have been acquired with
    
59. *dequeueBuffer first.
    
60. *
    
61. *Returns 0onsuccessor-errnoonerror.
    
62. */
    
63. int(*lockBuffer)(struct ANativeWindow*window,struct ANativeWindowBuffer*buffer);
64. /*
    
65. *hook called by EGL when modificationstothe render buffer are done.
    
66. *This unlocksandpost the buffer.
    
67. *
    
68. *Buffers MUST be queuedinthe same order than they were dequeued.
    
69. *
    
70. *Returns 0onsuccessor-errnoonerror.
    
71. */
    
72. int(*queueBuffer)(struct ANativeWindow*window,struct ANativeWindowBuffer*buffer);
73. 
    
74. /*
    
75. *hook usedtoretrieve information about the nativewindow.
    
76. *
    
77. *Returns 0onsuccessor-errnoonerror.
    
78. */
    
79. int(*query)(conststruct ANativeWindow*window,intwhat,int*value);
80. 
    
81. /*
    
82. *hook usedtoperform various operationsonthe surface.
    
83. *(*perform)()isa generic mechanismtoadd functionalityto
    
84. *ANativeWindowwhilekeeping backward binary compatibility.
    
85. *
    
86. *DONOTCALLTHIS HOOK DIRECTLY.Instead,use the helper functions
    
87. *defined below.
    
88. *
    
89. *(*perform)()returns-ENOENTifthe'what'parameterisnotsupported
    
90. *by the surface's implementation.
    
91. *
    
92. *The valid operations are:
    
93. *NATIVE_WINDOW_SET_USAGE
    
94. *NATIVE_WINDOW_CONNECT(deprecated)
    
95. *NATIVE_WINDOW_DISCONNECT(deprecated)
    
96. *NATIVE_WINDOW_SET_CROP
    
97. *NATIVE_WINDOW_SET_BUFFER_COUNT
    
98. *NATIVE_WINDOW_SET_BUFFERS_GEOMETRY(deprecated)
    
99. *NATIVE_WINDOW_SET_BUFFERS_TRANSFORM
    
100. *NATIVE_WINDOW_SET_BUFFERS_TIMESTAMP
     
101. *NATIVE_WINDOW_SET_BUFFERS_DIMENSIONS
     
102. *NATIVE_WINDOW_SET_BUFFERS_FORMAT
     
103. *NATIVE_WINDOW_SET_SCALING_MODE
     
104. *NATIVE_WINDOW_LOCK(private)
     
105. *NATIVE_WINDOW_UNLOCK_AND_POST(private)
     
106. *NATIVE_WINDOW_API_CONNECT(private)
     
107. *NATIVE_WINDOW_API_DISCONNECT(private)
     
108. *
     
109. */
     
110. 
     
111. int(*perform)(struct ANativeWindow*window,intoperation,...);
112. 
     
113. /*
     
114. *hook usedtocancel a buffer that has been dequeued.
     
115. *No synchronizationisperformed between dequeue()andcancel(),so
     
116. *either external synchronizationisneeded,orthese functions must be
     
117. *called from the same thread.
     
118. */
     
119. int(*cancelBuffer)(struct ANativeWindow*window,struct ANativeWindowBuffer*buffer);
120. 
     
121. 
     
122. void*reserved_proc[2];
     
123. };

既然上面调用了这个对象的方法，那么必然你要找到他的方法是在什么地方实现的，怎么实现的
我们首先看看 mANativewindow到底前身是什么，我们调用的这个方法到底是在哪里实现的，首先我们看一下他是从哪里引入进来的？？

1. intANativeWindowDisplayAdapter::setPreviewWindow(preview_stream_ops_t*window)
   
2. {
   
3. LOG_FUNCTION_NAME;
   
4. ///Note that Display Adapter cannot work without a validwindowobject
   
5. if(!window)
   
6. {
   
7. CAMHAL_LOGEA("NULL window object passed to DisplayAdapter");
   
8. LOG_FUNCTION_NAME_EXIT;
   
9. return BAD_VALUE;
   
10. }
    
11. 
    
12. if(window==mANativeWindow){
    
13. return ALREADY_EXISTS;
    
14. }
    
15. 
    
16. ///Destroy the existingwindowobject,ifit exists
    
17. destroy();
    
18. 
    
19. ///Movetonewwindowobj
    
20. mANativeWindow=window;
    
21. 
    
22. LOG_FUNCTION_NAME_EXIT;
    
23. 
    
24. return NO_ERROR;
    
25. }

这个window参数最终要往上层追溯，我们这里直接说了，其实window的初始化定义在hardware interface那里，和camera service在一个目录下

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

上面我们看到，window通过mHalPreviewWindow传入到底层，我们还是要看看 mHalPreviewWindow这个变量的初始化和实现在哪里？？

1. status_t initialize(hw_module_t*module)
   
2. {
   
3. LOGI("Opening camera %s",mName.string());
   
4. intrc=module->methods->open(module,mName.string(),
   
5. (hw_device_t**)&mDevice);
   
6. if(rc!=OK){
   
7. LOGE("Could not open camera %s: %d",mName.string(),rc);
   
8. return rc;
   
9. }
   
10. #ifdef OMAP_ENHANCEMENT_CPCAM
    
11. initHalPreviewWindow(&mHalPreviewWindow);
    
12. initHalPreviewWindow(&mHalTapin);
    
13. initHalPreviewWindow(&mHalTapout);
    
14. #else
    
15. initHalPreviewWindow();
    
16. #endif
    
17. return rc;
    
18. }

在最初打开camera的时候会调用上面initialize方法，通过initHalPreviewWindow这个方法实现mHalPrevieWindow的初始化以及hal层需要方法是实现

1. void initHalPreviewWindow(struct camera_preview_window*window)
   
2. {
   
3. 
   
4. window->nw.cancel_buffer=__cancel_buffer;
   
5. window->nw.lock_buffer=__lock_buffer;
   
6. window->nw.dequeue_buffer=__dequeue_buffer;
   
7. window->nw.enqueue_buffer=__enqueue_buffer;
   
8. window->nw.set_buffer_count=__set_buffer_count;
   
9. window->nw.set_buffers_geometry=__set_buffers_geometry;
   
10. window->nw.set_crop=__set_crop;
    
11. window->nw.set_metadata=__set_metadata;
    
12. window->nw.set_usage=__set_usage;
    
13. window->nw.set_swap_interval=__set_swap_interval;
    
14. window->nw.update_and_get_buffer=__update_and_get_buffer;
    
15. window->nw.get_metadata=__get_metadata;
    
16. window->nw.get_buffer_dimension=__get_buffer_dimension;
    
17. window->nw.get_buffer_format=__get_buffer_format;
    
18. 
    
19. window->nw.get_min_undequeued_buffer_count=
    
20. __get_min_undequeued_buffer_count;
    
21. }

这里进行了填充，我们就看看cancel_buffer方法的实现吧

1. staticint__cancel_buffer(struct preview_stream_ops*w,
   
2. buffer_handle_t*buffer)
   
3. {
   
4. ANativeWindow*a=anw(w);
   
5. returna->cancelBuffer(a,container_of(buffer,ANativeWindowBuffer,handle));
6. }

这里只是作为一个转接点，没有做任何事情，而是直接去调用了其他实现了的方法实现操作
这里通过anm这个方法转换而来的ANativeWindow类型的变量a其实就是我们在上面initialize方式中初始化的 mPreviewWindow
而这个 mPreviewWindow就是上层传下来的的surface

这里是camera service层，个人认为是在这里对window这个参数进行了配置，连接api...还有其他的操作

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(),NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);
25. native_window_set_buffers_transform(window.get(),mOrientation);
    
26. result=mHardware->setPreviewWindow(window);
    
27. }
    
28. }
    
29. 
    
30. if(result==NO_ERROR){
    
31. //Everything has succeeded.Disconnect the oldwindowandremember the
    
32. //newwindow.
    
33. disconnectWindow(mPreviewWindow);
    
34. mSurface=binder;
    
35. mPreviewWindow=window;
    
36. }else{
    
37. //Something went wrong after we connectedtothe newwindow,so
    
38. //disconnect here.
    
39. disconnectWindow(window);
    
40. }
    
41. 
    
42. return result;
    
43. }

这里我还是暂时不做说明吧，始终不是很理解这里为什么要这样做，一直以来上面调用的 cancelBuffer方法到底是在哪里实现的，这个问题纠结了我很久
这里先说说现在的想法，自己的理解， maybe wrong
这里跳度很大，看看下面的方法，来源:frameworks\base\libs\gui\SurfaceTextureClient.cpp
说的是 SurfaceTextureClient类的构造方法

1. SurfaceTextureClient::SurfaceTextureClient(
   
2. constsp<ISurfaceTexture>&surfaceTexture)
   
3. {
   
4. SurfaceTextureClient::init();
   
5. SurfaceTextureClient::setISurfaceTexture(surfaceTexture);
   
6. }

先看看init方法:

1. void SurfaceTextureClient::init(){
   
2. //Initialize the ANativeWindowfunctionpointers.
   
3. ANativeWindow::setSwapInterval=hook_setSwapInterval;
   
4. ANativeWindow::dequeueBuffer=hook_dequeueBuffer;
   
5. ANativeWindow::cancelBuffer=hook_cancelBuffer;
   
6. ANativeWindow::lockBuffer=hook_lockBuffer;
   
7. ANativeWindow::queueBuffer=hook_queueBuffer;
   
8. ANativeWindow::query=hook_query;
   
9. ANativeWindow::perform=hook_perform;
   
10. 
    
11. const_cast<int&>(ANativeWindow::minSwapInterval)=0;
    
12. const_cast<int&>(ANativeWindow::maxSwapInterval)=1;
    
13. 
    
14. mReqWidth=0;
    
15. mReqHeight=0;
    
16. mReqFormat=0;
    
17. mReqUsage=0;
    
18. mTimestamp=NATIVE_WINDOW_TIMESTAMP_AUTO;
    
19. mDefaultWidth=0;
    
20. mDefaultHeight=0;
    
21. mTransformHint=0;
    
22. mConnectedToCpu=false;
    
23. }

重点是上面我标注出来的部分，就现在的理解，这里就是上面说的 cancelBuffer方法的归宿了，另外包括其他的所有方法，方法基本相同，这里为方便分析理解
我们以dequeueBuffer为例进行讲解，那就先看看 hook_dequeueBuffer的实现

1. intSurfaceTextureClient::hook_dequeueBuffer(ANativeWindow*window,
   
2. ANativeWindowBuffer**buffer){
   
3. SurfaceTextureClient*c=getSelf(window);
   
4. return c->dequeueBuffer(buffer);
   
5. }

接着调用SurfaceTextureClient类的dequeueBuffer方法

1. intSurfaceTextureClient::dequeueBuffer(android_native_buffer_t**buffer){
   
2. LOGV("SurfaceTextureClient::dequeueBuffer");
   
3. Mutex::Autolock lock(mMutex);
   
4. intbuf=-1;
   
5. status_t result=mSurfaceTexture->dequeueBuffer(&buf,mReqWidth,mReqHeight,mReqFormat,mReqUsage);
6. if(result<0){
   
7. LOGV("dequeueBuffer: ISurfaceTexture::dequeueBuffer(%d, %d, %d, %d)"
   
8. "failed: %d",mReqWidth,mReqHeight,mReqFormat,mReqUsage,
   
9. result);
   
10. return result;
    
11. }
    
12. sp<GraphicBuffer>&gbuf(mSlots[buf]);
    
13. if(result&ISurfaceTexture::RELEASE_ALL_BUFFERS){
    
14. freeAllBuffers();
    
15. }
    
16. 
    
17. if((result&ISurfaceTexture::BUFFER_NEEDS_REALLOCATION)||gbuf==0){
    
18. result=mSurfaceTexture->requestBuffer(buf,&gbuf);
    
19. if(result!=NO_ERROR){
    
20. LOGE("dequeueBuffer: ISurfaceTexture::requestBuffer failed: %d",
    
21. result);
    
22. return result;
    
23. }
    
24. }
    
25. *buffer=gbuf.get();
    
26. return OK;
    
27. }

我们需要先找到mSurfaceTexture是在哪里定义的：system\media\mca\filterpacks\videosrc\java\CameraSource.java
private SurfaceTexture mSurfaceTexture;
接下来看看他是在哪里实例化的

1. @Override
   
2. publicvoid open(FilterContext context){
   
3. if(mLogVerbose)Log.v(TAG,"Opening");
   
4. //Open camera
   
5. mCamera=Camera.open(mCameraId);
   
6. 
   
7. //Setparameters
   
8. getCameraParameters();
   
9. mCamera.setParameters(mCameraParameters);
   
10. 
    
11. //Create frame formats
    
12. createFormats();
    
13. 
    
14. //Bind ittoour camera frame
    
15. mCameraFrame=(GLFrame)context.getFrameManager().newBoundFrame(mOutputFormat,
    
16. GLFrame.EXTERNAL_TEXTURE,
    
17. 0);
    
18. mSurfaceTexture=new SurfaceTexture(mCameraFrame.getTextureId());
    
19. try{
    
20. mCamera.setPreviewTexture(mSurfaceTexture);
    
21. }catch(IOException e){
    
22. throw new RuntimeException("Could not bind camera surface texture: "+
    
23. e.getMessage()+"!");
    
24. }
    
25. 
    
26. //Connect SurfaceTexturetocallback
    
27. mSurfaceTexture.setOnFrameAvailableListener(onCameraFrameAvailableListener);
    
28. //Start the preview
    
29. mNewFrameAvailable=false;
    
30. mCamera.startPreview();
    
31. }

其他方法先不做过多分析，这里实例化了SurfaceTexture的对象，看看他的构造函数：frameworks\base\libs\gui\SurfaceTexture.cpp

1. SurfaceTexture::SurfaceTexture(GLuint tex,bool allowSynchronousMode,
   
2. GLenum texTarget):
   
3. mDefaultWidth(1),
   
4. mDefaultHeight(1),
   
5. mPixelFormat(PIXEL_FORMAT_RGBA_8888),
   
6. mBufferCount(MIN_ASYNC_BUFFER_SLOTS),
   
7. mClientBufferCount(0),
   
8. mServerBufferCount(MIN_ASYNC_BUFFER_SLOTS),
   
9. mCurrentTexture(INVALID_BUFFER_SLOT),
   
10. mCurrentTransform(0),
    
11. mCurrentTimestamp(0),
    
12. mNextTransform(0),
    
13. mNextScalingMode(NATIVE_WINDOW_SCALING_MODE_FREEZE),
    
14. mTexName(tex),
    
15. mSynchronousMode(false),
    
16. mAllowSynchronousMode(allowSynchronousMode),
    
17. mConnectedApi(NO_CONNECTED_API),
    
18. mAbandoned(false),
    
19. mTexTarget(texTarget){
    
20. //Choose a name using the PIDanda process-unique ID.
    
21. mName=String8::format("unnamed-%d-%d",getpid(),createProcessUniqueId());
    
22. 
    
23. ST_LOGV("SurfaceTexture::SurfaceTexture");
    
24. sp<ISurfaceComposer>composer(ComposerService::getComposerService());
    
25. mGraphicBufferAlloc=composer->createGraphicBufferAlloc();
    
26. mNextCrop.makeInvalid();
    
27. memcpy(mCurrentTransformMatrix,mtxIdentity,
    
28. sizeof(mCurrentTransformMatrix));
    
29. }

我们接着往下看， mSurfaceTexture - > dequeueBuffer ( & buf , mReqWidth , mReqHeight , mReqFormat , mReqUsage ) ;
这里调用了类 SurfaceTexture的方法 dequeueBuffer

1. status_t SurfaceTexture::dequeueBuffer(int*outBuf,uint32_t w,uint32_t h,
   
2. uint32_t format,uint32_t usage){
   
3. ST_LOGV("SurfaceTexture::dequeueBuffer");
   
4. 
   
5. if((w&&!h)||(!w&&h)){
   
6. ST_LOGE("dequeueBuffer: invalid size: w=%u, h=%u",w,h);
   
7. return BAD_VALUE;
   
8. }
   
9. 
   
10. Mutex::Autolock lock(mMutex);
    
11. 
    
12. status_t returnFlags(OK);
    
13. 
    
14. intfound,foundSync;
    
15. intdequeuedCount=0;
    
16. bool tryAgain=true;
    
17. while(tryAgain){
    
18. if(mAbandoned){
    
19. ST_LOGE("dequeueBuffer: SurfaceTexture has been abandoned!");
    
20. return NO_INIT;
    
21. }
    
22. 
    
23. //We needtowaitforthe FIFOtodrainifthe number of buffer
    
24. //needstochange.
    
25. //
    
26. //The condition"number of buffers needs to change"istrueif
    
27. //-the client doesn't care about how many buffers there are
    
28. //-ANDthe actual number of bufferisdifferent from what was
    
29. //setinthe last setBufferCountServer()
    
30. //-OR-
    
31. //setBufferCountServer()wassettoa value incompatible with
    
32. //the synchronization mode(forinstance because the sync mode
    
33. //changed since)
    
34. //
    
35. //As long as this conditionistrueANDthe FIFOisnotempty,we
    
36. //waitonmDequeueCondition.
    
37. 
    
38. constintminBufferCountNeeded=mSynchronousMode?
    
39. MIN_SYNC_BUFFER_SLOTS:MIN_ASYNC_BUFFER_SLOTS;
    
40. 
    
41. constbool numberOfBuffersNeedsToChange=!mClientBufferCount&&
    
42. ((mServerBufferCount!=mBufferCount)||
    
43. (mServerBufferCount<minBufferCountNeeded));
    
44. 
    
45. if(!mQueue.isEmpty()&&numberOfBuffersNeedsToChange){
    
46. //waitforthe FIFOtodrain
    
47. mDequeueCondition.wait(mMutex);
    
48. //NOTE:we continue here because we needtoreevaluate our
    
49. //whole state(eg:we could be abandonedordisconnected)
    
50. continue;
    
51. }
    
52. 
    
53. if(numberOfBuffersNeedsToChange){
    
54. //here we're guaranteed that mQueueisempty
    
55. freeAllBuffersLocked();
    
56. mBufferCount=mServerBufferCount;
    
57. if(mBufferCount<minBufferCountNeeded)
    
58. mBufferCount=minBufferCountNeeded;
    
59. mCurrentTexture=INVALID_BUFFER_SLOT;
    
60. returnFlags|=ISurfaceTexture::RELEASE_ALL_BUFFERS;
    
61. }
    
62. 
    
63. //lookfora free buffertogivetothe client
    
64. found=INVALID_BUFFER_SLOT;
    
65. foundSync=INVALID_BUFFER_SLOT;
    
66. dequeuedCount=0;
    
67. for(inti=0;i<mBufferCount;i++){
    
68. constintstate=mSlots[i].mBufferState;
    
69. if(state==BufferSlot::DEQUEUED){
    
70. dequeuedCount++;
    
71. }
    
72. 
    
73. //ifbufferisFREE it CANNOT be current
    
74. LOGW_IF((state==BufferSlot::FREE)&&(mCurrentTexture==i),
    
75. "dequeueBuffer: buffer %d is both FREE and current!",i);
    
76. 
    
77. if(ALLOW_DEQUEUE_CURRENT_BUFFER){
    
78. if(state==BufferSlot::FREE||i==mCurrentTexture){
    
79. foundSync=i;
    
80. if(i!=mCurrentTexture){
    
81. found=i;
    
82. break;
    
83. }
    
84. }
    
85. }else{
    
86. if(state==BufferSlot::FREE){
    
87. foundSync=i;
    
88. found=i;
    
89. break;
    
90. }
    
91. }
    
92. }
    
93. 
    
94. //clients arenotallowedtodequeue more than one buffer
    
95. //ifthey didn'tseta buffer count.
    
96. if(!mClientBufferCount&&dequeuedCount){
    
97. return-EINVAL;
    
98. }
    
99. 
    
100. //See whether a buffer has been queued since the last setBufferCount so
     
101. //we know whethertoperform the MIN_UNDEQUEUED_BUFFERS check below.
     
102. bool bufferHasBeenQueued=mCurrentTexture!=INVALID_BUFFER_SLOT;
     
103. if(bufferHasBeenQueued){
     
104. //make sure the clientisnottryingtodequeue more buffers
     
105. //than allowed.
     
106. constintavail=mBufferCount-(dequeuedCount+1);
     
107. if(avail<(MIN_UNDEQUEUED_BUFFERS-int(mSynchronousMode))){
     
108. ST_LOGE("dequeueBuffer: MIN_UNDEQUEUED_BUFFERS=%d exceeded "
     
109. "(dequeued=%d)",
     
110. MIN_UNDEQUEUED_BUFFERS-int(mSynchronousMode),
     
111. dequeuedCount);
     
112. return-EBUSY;
     
113. }
     
114. }
     
115. 
     
116. //we'reinsynchronous modeanddidn't find a buffer,we needtowait
     
117. //forsome bufferstobe consumed
     
118. tryAgain=mSynchronousMode&&(foundSync==INVALID_BUFFER_SLOT);
     
119. if(tryAgain){
     
120. mDequeueCondition.wait(mMutex);
     
121. }
     
122. }
     
123. 
     
124. if(mSynchronousMode&&found==INVALID_BUFFER_SLOT){
     
125. //foundSync guaranteedtobe!=INVALID_BUFFER_SLOT
     
126. found=foundSync;
     
127. }
     
128. 
     
129. if(found==INVALID_BUFFER_SLOT){
     
130. return-EBUSY;
     
131. }
     
132. 
     
133. constintbuf=found;
     
134. *outBuf=found;
     
135. 
     
136. constbool useDefaultSize=!w&&!h;
     
137. if(useDefaultSize){
     
138. //use the default size
     
139. w=mDefaultWidth;
     
140. h=mDefaultHeight;
     
141. }
     
142. 
     
143. constbool updateFormat=(format!=0);
     
144. if(!updateFormat){
     
145. //keep the current(ordefault)format
     
146. format=mPixelFormat;
     
147. }
     
148. 
     
149. //bufferisnowinDEQUEUED(but can also be current at the sametime,
     
150. //ifwe'reinsynchronous mode)
     
151. mSlots[buf].mBufferState=BufferSlot::DEQUEUED;
     
152. 
     
153. constsp<GraphicBuffer>&buffer(mSlots[buf].mGraphicBuffer);
     
154. if((buffer==NULL)||
     
155. (uint32_t(buffer->width)!=w)||
     
156. (uint32_t(buffer->height)!=h)||
     
157. (uint32_t(buffer->format)!=format)||
     
158. ((uint32_t(buffer->usage)&usage)!=usage))
     
159. {
     
160. usage|=GraphicBuffer::USAGE_HW_TEXTURE;
     
161. status_terror;
     
162. sp<GraphicBuffer>graphicBuffer(
     
163. mGraphicBufferAlloc->createGraphicBuffer(
     
164. w,h,format,usage,&error));
     
165. if(graphicBuffer==0){
     
166. ST_LOGE("dequeueBuffer: SurfaceComposer::createGraphicBuffer "
     
167. "failed");
     
168. returnerror;
     
169. }
     
170. if(updateFormat){
     
171. mPixelFormat=format;
     
172. }
     
173. mSlots[buf].mGraphicBuffer=graphicBuffer;
     
174. mSlots[buf].mRequestBufferCalled=false;
     
175. if(mSlots[buf].mEglImage!=EGL_NO_IMAGE_KHR){
     
176. eglDestroyImageKHR(mSlots[buf].mEglDisplay,mSlots[buf].mEglImage);
     
177. mSlots[buf].mEglImage=EGL_NO_IMAGE_KHR;
     
178. mSlots[buf].mEglDisplay=EGL_NO_DISPLAY;
     
179. }
     
180. returnFlags|=ISurfaceTexture::BUFFER_NEEDS_REALLOCATION;
     
181. }
     
182. return returnFlags;
     
183. }

到这里为止，其实底层调用的那些方法最终在这里都有实现，应该也已经走到了系统的ui层，本想到此为止，我还是深入看看这个方法吧
很纠结啊，看的

当已存在申请的buffer，返回buffer序号
在初始化SurfaceTexture对象时，上面的构造函数中实例化 mGraphicBufferAlloc = composer - > createGraphicBufferAlloc ( ) ;
createGraphicBufferAlloc的实现在以下路径：frameworks\base\libs\gui\ISurfaceComposer.cpp

1. virtual sp<IGraphicBufferAlloc>createGraphicBufferAlloc()
   
2. {
   
3. uint32_t n;
   
4. Parcel data,reply;
   
5. data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
   
6. remote()->transact(BnSurfaceComposer::CREATE_GRAPHIC_BUFFER_ALLOC,data,&reply);
   
7. return interface_cast<IGraphicBufferAlloc>(reply.readStrongBinder());
   
8. }

由上面接着他会调用 IGraphicBufferAlloc::createGraphicBuffer()，路径：frameworks\base\libs\gui\IGraphicBufferAlloc.cpp

1. virtual sp<GraphicBuffer>createGraphicBuffer(uint32_t w,uint32_t h,
   
2. PixelFormat format,uint32_t usage,status_t*error){
   
3. Parcel data,reply;
   
4. data.writeInterfaceToken(IGraphicBufferAlloc::getInterfaceDescriptor());
   
5. data.writeInt32(w);
   
6. data.writeInt32(h);
   
7. data.writeInt32(format);
   
8. data.writeInt32(usage);
   
9. remote()->transact(CREATE_GRAPHIC_BUFFER,data,&reply);
   
10. sp<GraphicBuffer>graphicBuffer;
    
11. status_t result=reply.readInt32();
    
12. if(result==NO_ERROR){
    
13. graphicBuffer=new GraphicBuffer();
    
14. reply.read(*graphicBuffer);
    
15. //reply.readStrongBinder();
    
16. //here we don't even havetoread the BufferReference from
    
17. //the parcel,it'll die with the parcel.
    
18. }
    
19. *error=result;
    
20. return graphicBuffer;
    
21. }

这里实例化GraphicBuffer类的对象，并且用返回的这个对象实例化 graphicBuffer变量

这篇文章写得很吃力，不是理解的很透彻，其中可能很多思路根本就是错误的，待修正啊。。

待续。。。。

更多相关文章

1. SpringBoot 2.0 中 HikariCP 数据库连接池原理解析
2. android jni方法模拟高频按键点击
3. Android调用webservice接口
4. Android电池驱动
5. Android开发中的单元测试-初级教程(01)
6. Android(安卓)Camera从App层到framework层到HAL层的初始化过程
7. Android(安卓)SurfaceFlinger 学习之路(五)----VSync 工作原理
8. EP28-DownloadManager分析(1)
9. Android视图加载流程(3)之ViewRootImpl的UI刷新机制

随机推荐

1. requestWindowFeature(Window.FEATURE_NO
2. ant编译android工程用批处理打包
3. Android之DatePickerDialog用法（日历的用
4. Android(安卓)activity的生命周期
5. android启动另一应用
6. Android(安卓)修改WiFi热点的默认SSID和
7. android 启动流程
8. 自定义View
9. service的隐式启动和显示启动
10. Android(安卓)网络状态实时监测