AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Android Camera数据流分析全程记录（overlay方式）

2013-05-31 2237
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

http://blog.chinaunix.net/uid-26215986-id-3573400.html


这里为什么要研究overlay方式呢？android camera需要driver和app层需要有大量数据需要传输，如果使用非overlay方式进行数据从driver到app层的传输，使系统性能受到很到影响，使系统速度变慢，同时会影响功耗等，而在camera preview module时，通常我们是不必要将采集的数据保存下来的，而不像录像module下，需要将数据保存下来，所以overlay方式就是不经过数据回传，直接显示从driver的数据方式，采用这种方式app从无法获取到数据，所以这种方式应用在preview方式下

这里我是针对android4.0版本的，相对android2.x版本的overlay已经发生了很大的变化，想要研究这方面的可以自己去了解一下，这里不再多说了

开始部分我就直接在这里带过了，系统初始打开camera时，调用到app的onCreate方法，这里主要做了一下工作：
1.开始一个openCamera线程打开camera
2.实例化很多的对象，用于camera工作使用
3.实例化surfaceview和surfaceholder,并且填充了其中的surfacechanged，surfacedestoryed和surfacecreated这三个方式
4.开始一个preview线程用于preview过程
这其中3.4是我们这里要关注的重点，上面实例化了这个surfaceview将决定了我们到底是否使用overlay方式
在这里第三遍完成之后，系统会自动执行surfacechanged这个方式，每次显示区域发生改变都会自动调用这个方法，刚开始打开camera时，显示区域从无到有，因此必要这里会想调用到surfacechanged方法
我们就还是看看在这里都做了些什么事情

  1. public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
  2.         // Make sure we have a surface in the holder before proceeding.
  3.         if (holder.getSurface() == null) {
  4.             Log.d(TAG, "holder.getSurface() == null");
  5.             return;
  6.         }

  8.         Log.v(TAG, "surfaceChanged. w=" + w + ". h=" + h);

  10.         // We need to save the holder for later use, even when the mCameraDevice
  11.         // is null. This could happen if onResume() is invoked after this
  12.         // function.
  13.         mSurfaceHolder = holder;

  15.         // The mCameraDevice will be null if it fails to connect to the camera
  16.         // hardware. In this case we will show a dialog and then finish the
  17.         // activity, so it's OK to ignore it.
  18.         if (mCameraDevice == null) return;

  20.         // Sometimes surfaceChanged is called after onPause or before onResume.
  21.         // Ignore it.
  22.         if (mPausing || isFinishing()) return;

  24.         setSurfaceLayout();

  26.         // Set preview display if the surface is being created. Preview was
  27.         // already started. Also restart the preview if display rotation has
  28.         // changed. Sometimes this happens when the device is held in portrait
  29.         // and camera app is opened. Rotation animation takes some time and
  30.         // display rotation in onCreate may not be what we want.
  31.         if (mCameraState == PREVIEW_STOPPED) {//这里表示第一次打开camera时，那么调用startpreview
  32.             startPreview(true);
  33.             startFaceDetection();
  34.         } else {//这里则表示camera已经打开过程中发生的显示变化，比如横屏竖频转换，所以zheli只需要重新设置previewdisplay
  35.             if (Util.getDisplayRotation(this) != mDisplayRotation) {
  36.                 setDisplayOrientation();
  37.             }
  38.             if (holder.isCreating()) {
  39.                 // Set preview display if the surface is being created and preview
  40.                 // was already started. That means preview display was set to null
  41.                 // and we need to set it now.
  42.                 setPreviewDisplay(holder);
  43.             }
  44.         }

  46.         // If first time initialization is not finished, send a message to do
  47.         // it later. We want to finish surfaceChanged as soon as possible to let
  48.         // user see preview first.
  49.         if (!mFirstTimeInitialized) {
  50.             mHandler.sendEmptyMessage(FIRST_TIME_INIT);
  51.         } else {
  52.             initializeSecondTime();
  53.         }

  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.         int displayRotation = Util.getDisplayRotation(this);
  59.         int displayOrientation = Util.getDisplayOrientation(displayRotation, mCameraId);

  61.         mTouchManager.initialize(preview.getHeight() / 3, preview.getHeight() / 3,
  62.                preview, this, mirror, displayOrientation);

  64.     }
从上面代码我们必须知道，在surface发生变化时必须调用 setPreviewDisplay ，根据之后的学习，在startpreview方式中真正startpreview之前同样要调用 setPreviewDisplay ，在 setPreviewDisplay 的方法中完成了很多初始化，也是在这里决定是否使用overlay方式的，我们就先看看startpreview这个方法吧
  1. private void startPreview(boolean updateAll) {
  2.         if (mPausing || isFinishing()) return;

  4.         mFocusManager.resetTouchFocus();

  6.         mCameraDevice.setErrorCallback(mErrorCallback);

  8.         // If we're previewing already, stop the preview first (this will blank
  9.         // the screen).
  10.         if (mCameraState != PREVIEW_STOPPED) stopPreview();

  12.         setPreviewDisplay(mSurfaceHolder);
  13.         setDisplayOrientation();

  15.         if (!mSnapshotOnIdle) {
  16.             // If the focus mode is continuous autofocus, call cancelAutoFocus to
  17.             // resume it because it may have been paused by autoFocus call.
  18.             if (Parameters.FOCUS_MODE_CONTINUOUS_PICTURE.equals(mFocusManager.getFocusMode())) {
  19.                 mCameraDevice.cancelAutoFocus();
  20.             }
  21.             mFocusManager.setAeAwbLock(false); // Unlock AE and AWB.
  22.         }

  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.         }

  31.         //setCameraParameters(UPDATE_PARAM_ALL);

  33.         // Inform the mainthread to go on the UI initialization.
  34.         if (mCameraPreviewThread != null) {
  35.             synchronized (mCameraPreviewThread) {
  36.                 mCameraPreviewThread.notify();
  37.             }
  38.         }

  40.         try {
  41.             Log.v(TAG, "startPreview");
  42.             mCameraDevice.startPreview();
  43.         } catch (Throwable ex) {
  44.             closeCamera();
  45.             throw new RuntimeException("startPreview failed", ex);
  46.         }

  48.         mZoomState = ZOOM_STOPPED;
  49.         setCameraState(IDLE);
  50.         mFocusManager.onPreviewStarted();
  51.         if ( mTempBracketingEnabled ) {
  52.             mFocusManager.setTempBracketingState(FocusManager.TempBracketingStates.ACTIVE);
  53.         }

  55.         if (mSnapshotOnIdle) {
  56.             mHandler.post(mDoSnapRunnable);
  57.         }
  58.     }
上面大家看到了，先调用了 setPreviewDisplay ，最后调用 mCameraDevice . startPreview ( ) 开始preview
这里过程如下：app-->frameworks-->JNI-->camera client-->camera service-->hardware interface-->HAL
1. setPreviewDisplay 方法调用时在app层最初的传入的参数是surfaceholder结构
2.到了JNI层 setPreviewDisplay 方法传入的参数已经是surface结构了
3.到了camera service层
    sp<IBinder> binder(surface != 0 ? surface->asBinder() : 0);
    sp<ANativeWindow> window(surface);
    return setPreviewWindow(binder, window);
    通过上面的转换调用同名不同参数的另外一个方法，到这里调用的参数已经转变为IBinder和ANativeWindow
4.调用hardware interface的setPreviewWindow(window)，这里只有一个 ANativeWindow类型的参数
5.到了camerahal_module中转站时又发生了变化 ，看看下面的定义，参数变为 preview_stream_ops 这个类型的结构
    int camera_set_preview_window(struct camera_device * device, struct preview_stream_ops *window)
上面过程参数类型一直在变化，不过从app层一直传到这里，其实是对同一个内存地址的传输，就像张三换了身衣服，但是他还是张三一样
现在我们就直接看看HAL层的实现
  1. /**
  2.    @brief Sets ANativeWindow object.

  4.    Preview buffers provided to CameraHal via this object. DisplayAdapter will be interfacing with it
  5.    to render buffers to display.

  7.    @param[in] window The ANativeWindow object created by Surface flinger
  8.    @return NO_ERROR If the ANativeWindow object passes validation criteria
  9.    @todo Define validation criteria for ANativeWindow object. Define error codes for scenarios

  11.  */
  12. status_t CameraHal::setPreviewWindow(struct preview_stream_ops *window)
  13. {
  14.     status_t ret = NO_ERROR;
  15.     CameraAdapter::BuffersDescriptor desc;

  17.     LOG_FUNCTION_NAME;
  18.     mSetPreviewWindowCalled = true;

  20.    ///If the Camera service passes a null window, we destroy existing window and free the DisplayAdapter
  21.     if(!window)//这种情况下，window是null，表示不采用overlay方式，则不需要新建displayadapter
  22.     {
  23.         if(mDisplayAdapter.get() != NULL)
  24.         {
  25.             ///NULL window passed, destroy the display adapter if present
  26.             CAMHAL_LOGD("NULL window passed, destroying display adapter");
  27.             mDisplayAdapter.clear();
  28.             ///@remarks If there was a window previously existing, we usually expect another valid window to be passed by the client
  29.             ///@remarks so, we will wait until it passes a valid window to begin the preview again
  30.             mSetPreviewWindowCalled = false;
  31.         }
  32.         CAMHAL_LOGD("NULL ANativeWindow passed to setPreviewWindow");
  33.         return NO_ERROR;
  34.     }else if(mDisplayAdapter.get() == NULL)//传入的window不是null，但是还没有未使用overlay方式创建displayadapter，创建displayadapter
  35.     {
  36.         // Need to create the display adapter since it has not been created
  37.         // Create display adapter
  38.         mDisplayAdapter = new ANativeWindowDisplayAdapter();
  39.         ret = NO_ERROR;
  40.         if(!mDisplayAdapter.get() || ((ret=mDisplayAdapter->initialize())!=NO_ERROR))
  41.         {
  42.             if(ret!=NO_ERROR)
  43.             {
  44.                 mDisplayAdapter.clear();
  45.                 CAMHAL_LOGEA("DisplayAdapter initialize failed");
  46.                 LOG_FUNCTION_NAME_EXIT;
  47.                 return ret;
  48.             }
  49.             else
  50.             {
  51.                 CAMHAL_LOGEA("Couldn't create DisplayAdapter");
  52.                 LOG_FUNCTION_NAME_EXIT;
  53.                 return NO_MEMORY;
  54.             }
  55.         }

  57.         // DisplayAdapter needs to know where to get the CameraFrames from inorder to display
  58.         // Since CameraAdapter is the one that provides the frames, set it as the frame provider for DisplayAdapter
  59.         mDisplayAdapter->setFrameProvider(mCameraAdapter);

  61.         // Any dynamic errors that happen during the camera use case has to be propagated back to the application
  62.         // via CAMERA_MSG_ERROR. AppCallbackNotifier is the class that notifies such errors to the application
  63.         // Set it as the error handler for the DisplayAdapter
  64.         mDisplayAdapter->setErrorHandler(mAppCallbackNotifier.get());

  66.         // Update the display adapter with the new window that is passed from CameraService
  67.         ret = mDisplayAdapter->setPreviewWindow(window);
  68.         if(ret!=NO_ERROR)
  69.             {
  70.             CAMHAL_LOGEB("DisplayAdapter setPreviewWindow returned error %d", ret);
  71.             }

  73.         if(mPreviewStartInProgress)
  74.         {
  75.             CAMHAL_LOGDA("setPreviewWindow called when preview running");
  76.             // Start the preview since the window is now available
  77.             ret = startPreview();
  78.         }
  79.     } else {//传入的window不是null，并且displaadaper已经创建好，那么这里只需要将新的window与已经创建好的displayadapter关联即可
  80.         // Update the display adapter with the new window that is passed from CameraService
  81.         ret = mDisplayAdapter->setPreviewWindow(window);
  82.         if ( (NO_ERROR == ret) && previewEnabled() ) {
  83.             restartPreview();
  84.         } else if (ret == ALREADY_EXISTS) {
  85.             // ALREADY_EXISTS should be treated as a noop in this case
  86.             ret = NO_ERROR;
  87.         }
  88.     }
  89.     LOG_FUNCTION_NAME_EXIT;

  91.     return ret;

  93. }
这里我们重点看看新建displayadapter的过程：
1.实例化一个 ANativeWindowDisplayAdapter 对象
2. mDisplayAdapter - > initialize ( )
3. mDisplayAdapter - > setFrameProvider ( mCameraAdapter )//这一步是关键，之后会遇到的
4. mDisplayAdapter - > setErrorHandler ( mAppCallbackNotifier . get ( ) )
5. mDisplayAdapter - > setPreviewWindow ( window ) ;
做完了上面这些步骤之后，就是startpreview了
  1. /**
  2.    @brief Start preview mode.

  4.    @param none
  5.    @return NO_ERROR Camera switched to VF mode
  6.    @todo Update function header with the different errors that are possible

  8.  */
  9. status_t CameraHal::startPreview() {
  10.     LOG_FUNCTION_NAME;

  12.     // When tunneling is enabled during VTC, startPreview happens in 2 steps:
  13.     // When the application sends the command CAMERA_CMD_PREVIEW_INITIALIZATION,
  14.     // cameraPreviewInitialization() is called, which in turn causes the CameraAdapter
  15.     // to move from loaded to idle state. And when the application calls startPreview,
  16.     // the CameraAdapter moves from idle to executing state.
  17.     //
  18.     // If the application calls startPreview() without sending the command
  19.     // CAMERA_CMD_PREVIEW_INITIALIZATION, then the function cameraPreviewInitialization()
  20.     // AND startPreview() are executed. In other words, if the application calls
  21.     // startPreview() without sending the command CAMERA_CMD_PREVIEW_INITIALIZATION,
  22.     // then the CameraAdapter moves from loaded to idle to executing state in one shot.
  23.     status_t ret = cameraPreviewInitialization();

  25.     // The flag mPreviewInitializationDone is set to true at the end of the function
  26.     // cameraPreviewInitialization(). Therefore, if everything goes alright, then the
  27.     // flag will be set. Sometimes, the function cameraPreviewInitialization() may
  28.     // return prematurely if all the resources are not available for starting preview.
  29.     // For example, if the preview window is not set, then it would return NO_ERROR.
  30.     // Under such circumstances, one should return from startPreview as well and should
  31.     // not continue execution. That is why, we check the flag and not the return value.
  32.     if (!mPreviewInitializationDone) return ret;

  34.     // Once startPreview is called, there is no need to continue to remember whether
  35.     // the function cameraPreviewInitialization() was called earlier or not. And so
  36.     // the flag mPreviewInitializationDone is reset here. Plus, this preserves the
  37.     // current behavior of startPreview under the circumstances where the application
  38.     // calls startPreview twice or more.
  39.     mPreviewInitializationDone = false;

  41.     ///Enable the display adapter if present, actual overlay enable happens when we post the buffer
  42.     if(mDisplayAdapter.get() != NULL) {
  43.         CAMHAL_LOGDA("Enabling display");
  44.         int width, height;
  45.         mParameters.getPreviewSize(&width, &height);

  47. #if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
  48.         ret = mDisplayAdapter->enableDisplay(width, height, &mStartPreview);
  49. #else
  50.         ret = mDisplayAdapter->enableDisplay(width, height, NULL);
  51. #endif

  53.         if ( ret != NO_ERROR ) {
  54.             CAMHAL_LOGEA("Couldn't enable display");

  56.             // FIXME: At this stage mStateSwitchLock is locked and unlock is supposed to be called
  57.             // only from mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_PREVIEW)
  58.             // below. But this will never happen because of goto error. Thus at next
  59.             // startPreview() call CameraHAL will be deadlocked.
  60.             // Need to revisit mStateSwitch lock, for now just abort the process.
  61.             CAMHAL_ASSERT_X(false,
  62.                 "At this stage mCameraAdapter->mStateSwitchLock is still locked, "
  63.                 "deadlock is guaranteed");

  65.             goto error;
  66.         }

  68.     }

  70.     ///Send START_PREVIEW command to adapter
  71.     CAMHAL_LOGDA("Starting CameraAdapter preview mode");

  73.     ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_PREVIEW);

  75.     if(ret!=NO_ERROR) {
  76.         CAMHAL_LOGEA("Couldn't start preview w/ CameraAdapter");
  77.         goto error;
  78.     }
  79.     CAMHAL_LOGDA("Started preview");

  81.     mPreviewEnabled = true;
  82.     mPreviewStartInProgress = false;
  83.     return ret;

  85.     error:

  87.         CAMHAL_LOGEA("Performing cleanup after error");

  89.         //Do all 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;

  100.         return ret;
  101. }
上面标出的 cameraPreviewInitialization ( ) 方法也十分关键，之前已经说过，之后如果需要会再做说明
Enable the display adapter  if  present ,  actual overlay enable happens when we post the buffer
说明如果display adapter不是null，这里会enable，overlay方式就启动了
我们接着往下看，看看driver获取的数据到底是怎样处理的，startpreview会通过camerahal-->cameraapapter-->V4Lcameradapter
调用到v4l2层的startpreview，下面看看他的具体是实现
  1. status_t V4LCameraAdapter::startPreview()
  2. {
  3.     status_t ret = NO_ERROR;

  5.     LOG_FUNCTION_NAME;
  6.     Mutex::Autolock lock(mPreviewBufsLock);

  8.     if(mPreviewing) {
  9.         ret = BAD_VALUE;
  10.         goto EXIT;
  11.     }

  13.     for (int i = 0; i < mPreviewBufferCountQueueable; i++) {

  15.         mVideoInfo->buf.index = i;
  16.         mVideoInfo->buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  17.         mVideoInfo->buf.memory = V4L2_MEMORY_MMAP;

  19.         ret = v4lIoctl(mCameraHandle, VIDIOC_QBUF, &mVideoInfo->buf);//请求分配内存
  20.         if (ret < 0) {
  21.             CAMHAL_LOGEA("VIDIOC_QBUF Failed");
  22.             goto EXIT;
  23.         }
  24.         nQueued++;
  25.     }

  27.     ret = v4lStartStreaming();

  29.     // Create and start preview thread for receiving buffers from V4L Camera
  30.     if(!mCapturing) {
  31.         mPreviewThread = new PreviewThread(this);//开启PreviewThread
  32.         CAMHAL_LOGDA("Created preview thread");
  33.     }

  35.     //Update the flag to indicate we are previewing
  36.     mPreviewing = true;
  37.     mCapturing = false;

  39. EXIT:
  40.     LOG_FUNCTION_NAME_EXIT;
  41.     return ret;
  42. }
  1. int V4LCameraAdapter::previewThread()
  2. {
  3.     status_t ret = NO_ERROR;
  4.     int width, height;
  5.     CameraFrame frame;
  6.     void *y_uv[2];
  7.     int index = 0;
  8.     int stride = 4096;
  9.     char *fp = NULL;

  11.     mParams.getPreviewSize(&width, &height);

  13.     if (mPreviewing) {

  15.         fp = this->GetFrame(index);
  16.         if(!fp) {
  17.             ret = BAD_VALUE;
  18.             goto EXIT;
  19.         }
  20.         CameraBuffer *buffer = mPreviewBufs.keyAt(index);//获取camerabuffer
  21.         CameraFrame *lframe = (CameraFrame *)mFrameQueue.valueFor(buffer);//获取cameraframe
  22.         if (!lframe) {
  23.             ret = BAD_VALUE;
  24.             goto EXIT;
  25.         }

  27.         debugShowFPS();

  29.         if ( mFrameSubscribers.size() == 0 ) {
  30.             ret = BAD_VALUE;
  31.             goto EXIT;
  32.         }
  33.         y_uv[0] = (void*) lframe->mYuv[0];
  34.         //y_uv[1] = (void*) lframe->mYuv[1];
  35.         //y_uv[1] = (void*) (lframe->mYuv[0] + height*stride);
  36.         convertYUV422ToNV12Tiler ( (unsigned char*)fp, (unsigned char*)y_uv[0], width, height);//convert the data
  37.         CAMHAL_LOGVB("##...index= %d.;camera buffer= 0x%x; y= 0x%x; UV= 0x%x.",index, buffer, y_uv[0], y_uv[1] );

  39. #ifdef SAVE_RAW_FRAMES
  40.         unsigned char* nv12_buff = (unsigned char*) malloc(width*height*3/2);
  41.         //Convert yuv422i to yuv420sp(NV12) & dump the frame to a file
  42.         convertYUV422ToNV12 ( (unsigned char*)fp, nv12_buff, width, height);
  43.         saveFile( nv12_buff, ((width*height)*3/2) );//if you want to save the data,save it
  44.         free (nv12_buff);
  45. #endif
  46.         //填充frame结构，用于数据处理
  47.         frame.mFrameType = CameraFrame::PREVIEW_FRAME_SYNC;
  48.         frame.mBuffer = buffer;
  49.         frame.mLength = width*height*3/2;
  50.         frame.mAlignment = stride;
  51.         frame.mOffset = 0;
  52.         frame.mTimestamp = systemTime(SYSTEM_TIME_MONOTONIC);
  53.         frame.mFrameMask = (unsigned int)CameraFrame::PREVIEW_FRAME_SYNC;

  55.         if (mRecording)
  56.         {
  57.             frame.mFrameMask |= (unsigned int)CameraFrame::VIDEO_FRAME_SYNC;
  58.             mFramesWithEncoder++;
  59.         }
  60.     
  61.         //这里是重点，数据回调，或者使用overlay方式显示这里是决定性调用
  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:

  71.     return ret;
  72. }
现在就开始看看setInitFrameCount方法都做了些什么
  1. int BaseCameraAdapter::setInitFrameRefCount(CameraBuffer * buf, unsigned int mask)
  2. {
  3.   int ret = NO_ERROR;
  4.   unsigned int lmask;

  6.   LOG_FUNCTION_NAME;

  8.   if (buf == NULL)
  9.     {
  10.       return -EINVAL;
  11.     }

  13.   for( lmask = 1; lmask < CameraFrame::ALL_FRAMES; lmask <<= 1){
  14.     if( lmask & mask ){
  15.       switch( lmask ){

  17.       case CameraFrame::IMAGE_FRAME:
  18.         {
  19.           setFrameRefCount(buf, CameraFrame::IMAGE_FRAME, (int) mImageSubscribers.size());
  20.         }
  21.         break;
  22.       case CameraFrame::RAW_FRAME:
  23.         {
  24.           setFrameRefCount(buf, CameraFrame::RAW_FRAME, mRawSubscribers.size());
  25.         }
  26.         break;
  27.       case CameraFrame::PREVIEW_FRAME_SYNC:
  28.         {
  29.           setFrameRefCount(buf, CameraFrame::PREVIEW_FRAME_SYNC, mFrameSubscribers.size());//这里这个mFrameSubscribers对应的key上保存着响应的callback方法
  30.         }
  31.         break;
  32.       case CameraFrame::SNAPSHOT_FRAME:
  33.         {
  34.           setFrameRefCount(buf, CameraFrame::SNAPSHOT_FRAME, mSnapshotSubscribers.size());
  35.         }
  36.         break;
  37.       case CameraFrame::VIDEO_FRAME_SYNC:
  38.         {
  39.           setFrameRefCount(buf,CameraFrame::VIDEO_FRAME_SYNC, mVideoSubscribers.size());
  40.         }
  41.         break;
  42.       case CameraFrame::FRAME_DATA_SYNC:
  43.         {
  44.           setFrameRefCount(buf, CameraFrame::FRAME_DATA_SYNC, mFrameDataSubscribers.size());
  45.         }
  46.         break;
  47.       case CameraFrame::REPROCESS_INPUT_FRAME:
  48.         {
  49.           setFrameRefCount(buf,CameraFrame::REPROCESS_INPUT_FRAME, mVideoInSubscribers.size());
  50.         }
  51.         break;
  52.       default:
  53.         CAMHAL_LOGEB("FRAMETYPE NOT SUPPORTED 0x%x", lmask);
  54.         break;
  55.       }//SWITCH
  56.       mask &= ~lmask;
  57.     }//IF
  58.   }//FOR
  59.   LOG_FUNCTION_NAME_EXIT;
  60.   return ret;
  61. }
上面我标注的部分通过enableMsgType方法实现mFrameSubscribers.add的，经callback添加到对应的key处，算是实现关联，
同样的通过disableMsgType方法实现mFrameSubscribers.removeItem的，具体在哪里调用 enableMsgType和disableMsgType之后再给予说明
  1. void BaseCameraAdapter::setFrameRefCount(CameraBuffer * frameBuf, CameraFrame::FrameType frameType, int refCount)
  2. {

  4.     LOG_FUNCTION_NAME;

  6.     switch ( frameType )
  7.         {
  8.         case CameraFrame::IMAGE_FRAME:
  9.         case CameraFrame::RAW_FRAME:
  10.                 {
  11.                 Mutex::Autolock lock(mCaptureBufferLock);
  12.                 mCaptureBuffersAvailable.replaceValueFor(frameBuf, refCount);
  13.                 }
  14.             break;
  15.         case CameraFrame::SNAPSHOT_FRAME:
  16.                 {
  17.                 Mutex::Autolock lock(mSnapshotBufferLock);
  18.                 mSnapshotBuffersAvailable.replaceValueFor( ( unsigned int ) frameBuf, refCount);
  19.                 }
  20.             break;
  21.         case CameraFrame::PREVIEW_FRAME_SYNC:
  22.                 {
  23.                 Mutex::Autolock lock(mPreviewBufferLock)
  24.                 mPreviewBuffersAvailable.replaceValueFor(frameBuf, refCount);//这里我的理解是refCount和frameBuf实现了绑定，即camerabuf保存在mPreviewBuffersAvailable对应的key处
  25.                 }
  26.             break;
  27.         case CameraFrame::FRAME_DATA_SYNC:
  28.                 {
  29.                 Mutex::Autolock lock(mPreviewDataBufferLock);
  30.                 mPreviewDataBuffersAvailable.replaceValueFor(frameBuf, refCount);
  31.                 }
  32.             break;
  33.         case CameraFrame::VIDEO_FRAME_SYNC:
  34.                 {
  35.                 Mutex::Autolock lock(mVideoBufferLock);
  36.                 mVideoBuffersAvailable.replaceValueFor(frameBuf, refCount);
  37.                 }
  38.             break;
  39.         case CameraFrame::REPROCESS_INPUT_FRAME: {
  40.             Mutex::Autolock lock(mVideoInBufferLock);
  41.             mVideoInBuffersAvailable.replaceValueFor(frameBuf, refCount);
  42.         }
  43.             break;
  44.         default:
  45.             break;
  46.         };

  48.     LOG_FUNCTION_NAME_EXIT;

  50. }
接下我们看看 sendFrameToSubscribers 方法的具体实现过程
  1. status_t BaseCameraAdapter::sendFrameToSubscribers(CameraFrame *frame)
  2. {
  3.     status_t ret = NO_ERROR;
  4.     unsigned int mask;

  6.     if ( NULL == frame )
  7.         {
  8.         CAMHAL_LOGEA("Invalid CameraFrame");
  9.         return -EINVAL;
  10.         }

  12.     for( mask = 1; mask < CameraFrame::ALL_FRAMES; mask <<= 1){
  13.       if( mask & frame->mFrameMask ){
  14.         switch( mask ){

  16.         case CameraFrame::IMAGE_FRAME:
  17.           {
  18. #if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
  19.             CameraHal::PPM("Shot to Jpeg: ", &mStartCapture);
  20. #endif
  21.             ret = __sendFrameToSubscribers(frame, &mImageSubscribers, CameraFrame::IMAGE_FRAME);
  22.           }
  23.           break;
  24.         case CameraFrame::RAW_FRAME:
  25.           {
  26.             ret = __sendFrameToSubscribers(frame, &mRawSubscribers, CameraFrame::RAW_FRAME);
  27.           }
  28.           break;
  29.         case CameraFrame::PREVIEW_FRAME_SYNC:
  30.           {
  31.             ret = __sendFrameToSubscribers(frame, &mFrameSubscribers, CameraFrame::PREVIEW_FRAME_SYNC);
  32.           }
  33.           break;
  34.         case CameraFrame::SNAPSHOT_FRAME:
  35.           {
  36.             ret = __sendFrameToSubscribers(frame, &mSnapshotSubscribers, CameraFrame::SNAPSHOT_FRAME);
  37.           }
  38.           break;
  39.         case CameraFrame::VIDEO_FRAME_SYNC:
  40.           {
  41.             ret = __sendFrameToSubscribers(frame, &mVideoSubscribers, CameraFrame::VIDEO_FRAME_SYNC);
  42.           }
  43.           break;
  44.         case CameraFrame::FRAME_DATA_SYNC:
  45.           {
  46.             ret = __sendFrameToSubscribers(frame, &mFrameDataSubscribers, CameraFrame::FRAME_DATA_SYNC);
  47.           }
  48.           break;
  49.         case CameraFrame::REPROCESS_INPUT_FRAME:
  50.           {
  51.             ret = __sendFrameToSubscribers(frame, &mVideoInSubscribers, CameraFrame::REPROCESS_INPUT_FRAME);
  52.           }
  53.           break;
  54.         default:
  55.           CAMHAL_LOGEB("FRAMETYPE NOT SUPPORTED 0x%x", mask);
  56.         break;
  57.         }//SWITCH
  58.         frame->mFrameMask &= ~mask;

  60.         if (ret != NO_ERROR) {
  61.             goto EXIT;
  62.         }
  63.       }//IF
  64.     }//FOR

  66.  EXIT:
  67.     return ret;
  68. }
  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;

  9.     frame->mFrameType = frameType;

  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.       }

  25.     if (NULL != subscribers) {
  26.         refCount = getFrameRefCount(frame->mBuffer, frameType);//通过这个refCount可以找到对应的callback方法

  28.         if (refCount == 0) {
  29.             CAMHAL_LOGDA("Invalid ref count of 0");
  30.             return -EINVAL;
  31.         }

  33.         if (refCount > subscribers->size()) {
  34.             CAMHAL_LOGEB("Invalid ref count for frame type: 0x%x", frameType);
  35.             return -EINVAL;
  36.         }

  38.         CAMHAL_LOGVB("Type of Frame: 0x%x address: 0x%x refCount start %d",
  39.                      frame->mFrameType,
  40.                      ( uint32_t ) frame->mBuffer,
  41.                      refCount);

  43.         for ( unsigned int i = 0 ; i < refCount; i++ ) {
  44.             frame->mCookie = ( void * ) subscribers->keyAt(i);
  45.             callback = (frame_callback) subscribers->valueAt(i);

  47.             if (!callback) {
  48.                 CAMHAL_LOGEB("callback not set for frame type: 0x%x", frameType);
  49.                 return -EINVAL;
  50.             }

  52.             callback(frame);
  53.         }
  54.     } else {
  55.         CAMHAL_LOGEA("Subscribers is null??");
  56.         return -EINVAL;
  57.     }

  59.     return ret;
  60. }
这里别的我们先暂且不分析，但是callback到底是从哪里来的，这个我们必须说清楚
上面在实例化displayadapter时有这样一步： 3. mDisplayAdapter - > setFrameProvider ( mCameraAdapter )//这一步是关键，之后会遇到的
我们看看setFrameProvider这个方法的实现：
  1. int ANativeWindowDisplayAdapter::setFrameProvider(FrameNotifier *frameProvider)
  2. {
  3.     LOG_FUNCTION_NAME;

  5.     // Check for NULL pointer
  6.     if ( !frameProvider ) {
  7.         CAMHAL_LOGEA("NULL passed for frame provider");
  8.         LOG_FUNCTION_NAME_EXIT;
  9.         return BAD_VALUE;
  10.     }

  12.     //Release any previous frame providers
  13.     if ( NULL != mFrameProvider ) {
  14.         delete mFrameProvider;
  15.     }

  17.     /** Dont do anything here, Just save the pointer for use when display is
  18.          actually enabled or disabled
  19.     */
  20.     mFrameProvider = new FrameProvider(frameProvider, this, frameCallbackRelay);//实例化一个FrameProvider，这其中有一个参数非常重要：frameCallbackRelay，他的定义在下面给出

  22.     LOG_FUNCTION_NAME_EXIT;

  24.     return NO_ERROR;
  25. }
  1. void ANativeWindowDisplayAdapter::frameCallbackRelay(CameraFrame* caFrame)
  2. {

  4.     if ( NULL != caFrame )
  5.         {
  6.         if ( NULL != caFrame->mCookie )
  7.             {
  8.             ANativeWindowDisplayAdapter *da = (ANativeWindowDisplayAdapter*) caFrame->mCookie;
  9.             da->frameCallback(caFrame);
  10.         }
  11.         else
  12.             {
  13.             CAMHAL_LOGEB("Invalid Cookie in Camera Frame = %p, Cookie = %p", caFrame, caFrame->mCookie);
  14.             }
  15.         }
  16.     else
  17.         {
  18.         CAMHAL_LOGEB("Invalid Camera Frame = %p", caFrame);
  19.     }

  21. }
  1. void ANativeWindowDisplayAdapter::frameCallback(CameraFrame* caFrame)
  2. {
  3.     ///Call queueBuffer of overlay in the context of the callback thread
  4.     DisplayFrame df;
  5.     df.mBuffer = caFrame->mBuffer;
  6.     df.mType = (CameraFrame::FrameType) caFrame->mFrameType;
  7.     df.mOffset = caFrame->mOffset;
  8.     df.mWidthStride = caFrame->mAlignment;
  9.     df.mLength = caFrame->mLength;
  10.     df.mWidth = caFrame->mWidth;
  11.     df.mHeight = caFrame->mHeight;
  12.     PostFrame(df);
  13. }
这个回调函数在这里设置，等待数据回调，我们很有必要去看看 FrameProvider 这个类的构造函数，他是怎样让其他方法调用到这个回调函数的呢
  1. FrameProvider(FrameNotifier *fn, void* cookie, frame_callback frameCallback)
  2.         :mFrameNotifier(fn), mCookie(cookie),mFrameCallback(frameCallback) { }
这个构造函数还是很有意思，没有任何实现，只是通过传入的三个参数实例化了三个对象而已
1. mFrameNotifier ( fn ) ,  //这里mFrameNotifier就是camerasdapter
2.mCookie ( cookie ) ,
3. mFrameCallback ( frameCallback ) //mFrameCallback指向我们定义好的callback方法
我们接着就需要到之前已经提到过的startPreview方法中cameraPreviewInitialization的方法中去看了
  1. ////////////
  2. /**
  3.    @brief Set preview mode related initialization
  4.           -> Camera Adapter set params
  5.           -> Allocate buffers
  6.           -> Set use buffers for preview
  7.    @param none
  8.    @return NO_ERROR
  9.    @todo Update function header with the different errors that are possible

  11.  */
  12. status_t CameraHal::cameraPreviewInitialization()
  13. {

  15.     status_t ret = NO_ERROR;
  16.     CameraAdapter::BuffersDescriptor desc;
  17.     CameraFrame frame;
  18.     unsigned int required_buffer_count;
  19.     unsigned int max_queueble_buffers;

  21. #if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
  22.         gettimeofday(&mStartPreview, NULL);
  23. #endif

  25.     LOG_FUNCTION_NAME;

  27.     if (mPreviewInitializationDone) {
  28.         return NO_ERROR;
  29.     }

  31.     if ( mPreviewEnabled ){
  32.       CAMHAL_LOGDA("Preview already running");
  33.       LOG_FUNCTION_NAME_EXIT;
  34.       return ALREADY_EXISTS;
  35.     }

  37.     if ( NULL != mCameraAdapter ) {
  38.       ret = mCameraAdapter->setParameters(mParameters);
  39.     }

  41.     if ((mPreviewStartInProgress == false) && (mDisplayPaused == false)){
  42.       ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_RESOLUTION_PREVIEW,( int ) &frame);
  43.       if ( NO_ERROR != ret ){
  44.         CAMHAL_LOGEB("Error: CAMERA_QUERY_RESOLUTION_PREVIEW %d", ret);
  45.         return ret;
  46.       }

  48.       ///Update the current preview width and height
  49.       mPreviewWidth = frame.mWidth;
  50.       mPreviewHeight = frame.mHeight;
  51.     }

  53.     ///If we don't have the preview callback enabled and display adapter,
  54.     if(!mSetPreviewWindowCalled || (mDisplayAdapter.get() == NULL)){
  55.       CAMHAL_LOGD("Preview not started. Preview in progress flag set");
  56.       mPreviewStartInProgress = true;
  57.       ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_SWITCH_TO_EXECUTING);
  58.       if ( NO_ERROR != ret ){
  59.         CAMHAL_LOGEB("Error: CAMERA_SWITCH_TO_EXECUTING %d", ret);
  60.         return ret;
  61.       }
  62.       return NO_ERROR;
  63.     }

  65.     if( (mDisplayAdapter.get() != NULL) && ( !mPreviewEnabled ) && ( mDisplayPaused ) )
  66.         {
  67.         CAMHAL_LOGDA("Preview is in paused state");

  69.         mDisplayPaused = false;
  70.         mPreviewEnabled = true;
  71.         if ( NO_ERROR == ret )
  72.             {
  73.             ret = mDisplayAdapter->pauseDisplay(mDisplayPaused);

  75.             if ( NO_ERROR != ret )
  76.                 {
  77.                 CAMHAL_LOGEB("Display adapter resume failed %x", ret);
  78.                 }
  79.             }
  80.         //restart preview callbacks
  81.         if(mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME)
  82.         {
  83.             mAppCallbackNotifier->enableMsgType (CAMERA_MSG_PREVIEW_FRAME);
  84.         }

  86.         signalEndImageCapture();
  87.         return ret;
  88.         }

  90.     required_buffer_count = atoi(mCameraProperties->get(CameraProperties::REQUIRED_PREVIEW_BUFS));

  92.     ///Allocate the preview buffers
  93.     ret = allocPreviewBufs(mPreviewWidth, mPreviewHeight, mParameters.getPreviewFormat(), required_buffer_count, max_queueble_buffers);

  95.     if ( NO_ERROR != ret )
  96.         {
  97.         CAMHAL_LOGEA("Couldn't allocate buffers for Preview");
  98.         goto error;
  99.         }

  101.     if ( mMeasurementEnabled )
  102.         {

  104.         ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_PREVIEW_DATA,
  105.                                           ( int ) &frame,
  106.                                           required_buffer_count);
  107.         if ( NO_ERROR != ret )
  108.             {
  109.             return ret;
  110.             }

  112.          ///Allocate the preview data buffers
  113.         ret = allocPreviewDataBufs(frame.mLength, required_buffer_count);
  114.         if ( NO_ERROR != ret ) {
  115.             CAMHAL_LOGEA("Couldn't allocate preview data buffers");
  116.             goto error;
  117.            }

  119.         if ( NO_ERROR == ret )
  120.             {
  121.             desc.mBuffers = mPreviewDataBuffers;
  122.             desc.mOffsets = mPreviewDataOffsets;
  123.             desc.mFd = mPreviewDataFd;
  124.             desc.mLength = mPreviewDataLength;
  125.             desc.mCount = ( size_t ) required_buffer_count;
  126.             desc.mMaxQueueable = (size_t) required_buffer_count;

  128.             mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_PREVIEW_DATA,
  129.                                         ( int ) &desc);
  130.             }

  132.         }

  134.     ///Pass the buffers to Camera Adapter
  135.     desc.mBuffers = mPreviewBuffers;
  136.     desc.mOffsets = mPreviewOffsets;
  137.     desc.mFd = mPreviewFd;
  138.     desc.mLength = mPreviewLength;
  139.     desc.mCount = ( size_t ) required_buffer_count;
  140.     desc.mMaxQueueable = (size_t) max_queueble_buffers;

  142.     ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_PREVIEW,
  143.                                       ( int ) &desc);

  145.     if ( NO_ERROR != ret )
  146.         {
  147.         CAMHAL_LOGEB("Failed to register preview buffers: 0x%x", ret);
  148.         freePreviewBufs();
  149.         return ret;
  150.         }

  152.     mAppCallbackNotifier->startPreviewCallbacks(mParameters, mPreviewBuffers, mPreviewOffsets, mPreviewFd, mPreviewLength, required_buffer_count);

  154.     ///Start the callback notifier
  155.     ret = mAppCallbackNotifier->start();

  157.     if( ALREADY_EXISTS == ret )
  158.         {
  159.         //Already running, do nothing
  160.         CAMHAL_LOGDA("AppCallbackNotifier already running");
  161.         ret = NO_ERROR;
  162.         }
  163.     else if ( NO_ERROR == ret ) {
  164.         CAMHAL_LOGDA("Started AppCallbackNotifier..");
  165.         mAppCallbackNotifier->setMeasurements(mMeasurementEnabled);
  166.         }
  167.     else
  168.         {
  169.         CAMHAL_LOGDA("Couldn't start AppCallbackNotifier");
  170.         goto error;
  171.         }

  173.     if (ret == NO_ERROR) mPreviewInitializationDone = true;
  174.     return ret;

  176.     error:

  178.         CAMHAL_LOGEA("Performing cleanup after error");

  180.         //Do all the cleanup
  181.         freePreviewBufs();
  182.         mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_PREVIEW);
  183.         if(mDisplayAdapter.get() != NULL)
  184.             {
  185.             mDisplayAdapter->disableDisplay(false);
  186.             }
  187.         mAppCallbackNotifier->stop();
  188.         mPreviewStartInProgress = false;
  189.         mPreviewEnabled = false;
  190.         LOG_FUNCTION_NAME_EXIT;

  192.         return ret;
  193. }
我们就看看这个方法的是实现吧：mAppCallbackNotifier - > enableMsgType  ( CAMERA_MSG_PREVIEW_FRAME ) ;

  1. status_t AppCallbackNotifier::enableMsgType(int32_t msgType)
  2. {
  3.     if( msgType & CAMERA_MSG_PREVIEW_FRAME ) {
  4.         mFrameProvider->enableFrameNotification(CameraFrame::PREVIEW_FRAME_SYNC);
  5.     }

  7.     if( msgType & CAMERA_MSG_POSTVIEW_FRAME ) {
  8.         mFrameProvider->enableFrameNotification(CameraFrame::SNAPSHOT_FRAME);
  9.     }

  11.     if(msgType & CAMERA_MSG_RAW_IMAGE) {
  12.         mFrameProvider->enableFrameNotification(CameraFrame::RAW_FRAME);
  13.     }

  15.     return NO_ERROR;
  16. }
  1. int FrameProvider::enableFrameNotification(int32_t frameTypes)
  2. {
  3.     LOG_FUNCTION_NAME;
  4.     status_t ret = NO_ERROR;

  6.     ///Enable the frame notification to CameraAdapter (which implements FrameNotifier interface)
  7.     mFrameNotifier->enableMsgType(frameTypes<<MessageNotifier::FRAME_BIT_FIELD_POSITION, mFrameCallback, NULL, mCookie);

  9.     LOG_FUNCTION_NAME_EXIT;
  10.     return ret;
  11. }
这里这个 enableMsgType 其实就是前面已经提到过的那个 enableMsgType 方法，实现callback方法add到响应的key上
这里这个mFrameNotifier是FrameNotifier的对象，FrameNotifier这个类继承于MessageNotifier
而BaseCameraAdapter继承于CameraAdapter，CameraAdapter又继承于FrameNotifier，所以 mFrameNotifier对象调用的 enableMsgType 方法其实是一个虚函数，
最终调用的是 BaseCameraAdapter这个类中定义的 enableMsgType 方法，我们来看一看他的实现：
  1. void BaseCameraAdapter::enableMsgType(int32_t msgs, frame_callback callback, event_callback eventCb, void* cookie)
  2. {
  3.     Mutex::Autolock lock(mSubscriberLock);

  5.     LOG_FUNCTION_NAME;

  7.     int32_t frameMsg = ((msgs >> MessageNotifier::FRAME_BIT_FIELD_POSITION) & EVENT_MASK);
  8.     int32_t eventMsg = ((msgs >> MessageNotifier::EVENT_BIT_FIELD_POSITION) & EVENT_MASK);

  10.     if ( frameMsg != 0 )
  11.         {
  12.         CAMHAL_LOGVB("Frame message type id=0x%x subscription request", frameMsg);
  13.         switch ( frameMsg )
  14.             {
  15.             case CameraFrame::PREVIEW_FRAME_SYNC:
  16.                 mFrameSubscribers.add((int) cookie, callback);
  17.                 break;
  18.             case CameraFrame::FRAME_DATA_SYNC:
  19.                 mFrameDataSubscribers.add((int) cookie, callback);
  20.                 break;
  21.             case CameraFrame::SNAPSHOT_FRAME:
  22.                 mSnapshotSubscribers.add((int) cookie, callback);
  23.                 break;
  24.             case CameraFrame::IMAGE_FRAME:
  25.                 mImageSubscribers.add((int) cookie, callback);
  26.                 break;
  27.             case CameraFrame::RAW_FRAME:
  28.                 mRawSubscribers.add((int) cookie, callback);
  29.                 break;
  30.             case CameraFrame::VIDEO_FRAME_SYNC:
  31.                 mVideoSubscribers.add((int) cookie, callback);
  32.                 break;
  33.             case CameraFrame::REPROCESS_INPUT_FRAME:
  34.                 mVideoInSubscribers.add((int) cookie, callback);
  35.                 break;
  36.             default:
  37.                 CAMHAL_LOGEA("Frame message type id=0x%x subscription no supported yet!", frameMsg);
  38.                 break;
  39.             }
  40.         }

  42.     if ( eventMsg != 0)
  43.         {
  44.         CAMHAL_LOGVB("Event message type id=0x%x subscription request", eventMsg);
  45.         if ( CameraHalEvent::ALL_EVENTS == eventMsg )
  46.             {
  47.             mFocusSubscribers.add((int) cookie, eventCb);
  48.             mShutterSubscribers.add((int) cookie, eventCb);
  49.             mZoomSubscribers.add((int) cookie, eventCb);
  50.             mMetadataSubscribers.add((int) cookie, eventCb);
  51.             }
  52.         else
  53.             {
  54.             CAMHAL_LOGEA("Event message type id=0x%x subscription no supported yet!", eventMsg);
  55.             }
  56.         }

  58.     LOG_FUNCTION_NAME_EXIT;
  59. }
这里通过 mFrameSubscribers . add ( ( int )  cookie ,  callback ) 这个方法将 mFrameCallback 回调函数与key相关联
所以上面可以通过 callback  =   ( frame_callback )  subscribers - > valueAt ( i ) ;
这个方法获取callback的实现，因为上面已经实现了关联，所以数据最终是通过上面分析道的方法继续进行数据流显示
  1. void ANativeWindowDisplayAdapter::frameCallback(CameraFrame* caFrame)
  2. {
  3.     ///Call queueBuffer of overlay in the context of the callback thread
  4.     DisplayFrame df;
  5.     df.mBuffer = caFrame->mBuffer;
  6.     df.mType = (CameraFrame::FrameType) caFrame->mFrameType;
  7.     df.mOffset = caFrame->mOffset;
  8.     df.mWidthStride = caFrame->mAlignment;
  9.     df.mLength = caFrame->mLength;
  10.     df.mWidth = caFrame->mWidth;
  11.     df.mHeight = caFrame->mHeight;
  12.     PostFrame(df);//这里填充了DisplayFrame这个结构，并调用PostFrome实现显示
  13. }
这里PostFrame成了我要研究的主要内容，将数据以DisplayFrame结构的方式打包之后到底是怎么实现显示的呢？？
  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.     int i;

  9.     ///@todo Do cropping based on the stabilized frame coordinates
  10.     ///@todo Insert logic to drop frames here based on refresh rate of
  11.     ///display or rendering rate whichever is lower
  12.     ///Queue the buffer to overlay

  14.     if ( NULL == mANativeWindow ) {
  15.         return NO_INIT;
  16.     }

  18.     if (!mBuffers || !dispFrame.mBuffer) {
  19.         CAMHAL_LOGEA("NULL sent to PostFrame");
  20.         return BAD_VALUE;
  21.     }

  23.     for ( i = 0; i < mBufferCount; i++ )
  24.         {
  25.         if ( dispFrame.mBuffer == &mBuffers[i] )
  26.             {
  27.             break;
  28.         }
  29.     }


  32.     mFramesType.add( (int)mBuffers[i].opaque ,dispFrame.mType );

  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);

  42.         // Set crop only if current x and y offsets do not match 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 based on the pixel format
  48.             if(strcmp(mPixelFormat, (const char *) CameraParameters::PIXEL_FORMAT_YUV422I) == 0)
  49.                 {
  50.                 bytesPerPixel = 2;
  51.                 }
  52.             else if(strcmp(mPixelFormat, (const char *) CameraParameters::PIXEL_FORMAT_RGB565) == 0)
  53.                 {
  54.                 bytesPerPixel = 2;
  55.                 }
  56.             else if(strcmp(mPixelFormat, (const char *) CameraParameters::PIXEL_FORMAT_YUV420SP) == 0)
  57.                 {
  58.                 bytesPerPixel = 1;
  59.                 }
  60.             else
  61.                 {
  62.                 bytesPerPixel = 1;
  63.             }

  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, if the surface is
  68.             // already invalid, we'll know soon enough.
  69.             mANativeWindow->set_crop(mANativeWindow, xOff/bytesPerPixel, yOff,
  70.                                      (xOff/bytesPerPixel)+mPreviewWidth, yOff+mPreviewHeight);

  72.             ///Update the current x and y offsets
  73.             mXOff = xOff;
  74.             mYOff = yOff;
  75.         }

  77.         {
  78.             buffer_handle_t *handle = (buffer_handle_t *) mBuffers[i].opaque;
  79.             // unlock buffer before sending to display
  80.             mapper.unlock(*handle);
  81.             ret = mANativeWindow->enqueue_buffer(mANativeWindow, handle);
  82.         }
  83.         if ( NO_ERROR != ret ) {
  84.             CAMHAL_LOGE("Surface::queueBuffer returned error %d", ret);
  85.         }

  87.         mFramesWithCameraAdapterMap.removeItem((buffer_handle_t *) dispFrame.mBuffer->opaque);


  90.         // HWComposer has not minimum buffer requirement. We should be able to dequeue
  91.         // the buffer immediately
  92.         TIUTILS::Message msg;
  93.         mDisplayQ.put(&msg);


  96. #if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS

  98.         if ( mMeasureStandby )
  99.             {
  100.             CameraHal::PPM("Standby to first shot: Sensor Change completed - ", &mStandbyToShot);
  101.             mMeasureStandby = false;
  102.             }
  103.         else if (CameraFrame::CameraFrame::SNAPSHOT_FRAME == dispFrame.mType)
  104.             {
  105.             CameraHal::PPM("Shot to snapshot: ", &mStartCapture);
  106.             mShotToShot = true;
  107.             }
  108.         else if ( mShotToShot )
  109.             {
  110.             CameraHal::PPM("Shot to shot: ", &mStartCapture);
  111.             mShotToShot = false;
  112.         }
  113. #endif

  115.     }
  116.     else
  117.     {
  118.         Mutex::Autolock lock(mLock);
  119.         buffer_handle_t *handle = (buffer_handle_t *) mBuffers[i].opaque;

  121.         // unlock buffer before giving it up
  122.         mapper.unlock(*handle);

  124.         // cancel buffer and dequeue another one
  125.         ret = mANativeWindow->cancel_buffer(mANativeWindow, handle);
  126.         if ( NO_ERROR != ret ) {
  127.             CAMHAL_LOGE("Surface::cancelBuffer returned error %d", ret);
  128.         }

  130.         mFramesWithCameraAdapterMap.removeItem((buffer_handle_t *) dispFrame.mBuffer->opaque);

  132.         TIUTILS::Message msg;
  133.         mDisplayQ.put(&msg);
  134.         ret = NO_ERROR;
  135.     }

  137.     return ret;
  138. }
这个显示的过程相对来说还是比较复杂的，之后还需要花点时间研究一下

文章标签：
Android开发
关键词：
Android分析
Android Camera
Android Overlay
Android数据流
Android方式
一叶飘舟
目录
相关文章
肥猪肥猪-17824
|
22天前
|
Java 开发工具 Android开发
安卓与iOS开发环境对比分析
【7月更文挑战第4天】在移动应用开发的广阔天地中，安卓和iOS两大平台各据一方，引领着技术潮流。本文将深入探讨这两个平台的开发环境，从编程语言、工具链到市场分布等多个维度进行比较。我们将揭示各自的优势与局限，并分析开发者如何在这两个不同的生态系统中做出选择。通过本文，读者将获得一个全面的视角，理解两大平台在开发实践中的差异性及其对项目成功的影响。
肥猪肥猪-17824
23 2
游客5fdji2pvmf8888
|
3天前
|
IDE 开发工具 Android开发
安卓与iOS开发环境对比分析
在移动应用开发的广阔舞台上，安卓与iOS这两大操作系统各占半壁江山。它们在开发环境上的差异，不仅影响了开发者的编码体验，也在一定程度上塑造了应用生态的多样性。本文将深入探讨两者在开发工具、编程语言、用户界面设计以及市场分布等方面的不同特点，为即将踏入这一领域的开发者提供一盏明灯。
游客5fdji2pvmf8888
18 6
游客zllgslqrsw3f6
|
4天前
|
IDE 开发工具 Android开发
安卓与iOS开发环境的差异性分析
在移动应用开发的广阔舞台上，安卓和iOS两大操作系统各据一方，引领着市场潮流。它们各自拥有独特的开发环境和工具集，为开发者提供了不同的挑战与机遇。本文旨在深入剖析这两个平台的开发环境，通过比较它们的编程语言、集成开发环境（IDE）、用户界面设计、以及系统架构等方面，揭示各自的优势与局限。我们将探讨如何基于这些差异来优化开发策略，并预测未来可能的发展趋势，以期为开发者在选择平台时提供有价值的参考。
游客zllgslqrsw3f6
18 4
mg的嘟嘟
|
4天前
|
API 开发工具 Android开发
安卓与iOS开发环境对比分析
移动操作系统的两大巨头，安卓和iOS，各自拥有独特的开发环境和工具。本文将深入探讨两者的开发环境差异，从编程语言、开发工具、用户界面设计、API支持以及生态系统五个维度进行比较分析。通过数据支撑和案例研究，揭示各自的优势和局限性，为开发者选择适合自己项目需求的平台提供参考依据。
mg的嘟嘟
13 1
天下无贼001
|
7天前
|
Java Android开发 iOS开发
探索安卓与iOS开发的差异：平台特性与用户体验的对比分析
【7月更文挑战第19天】在移动开发的广阔天地中，安卓与iOS两大阵营各据一方，它们在开发环境、用户界面设计、性能优化等方面展现出独特的魅力与挑战。本文旨在深入探讨这两个平台在技术开发和用户体验上的根本差异，并分析这些差异如何影响开发者的策略和最终用户的选择。通过比较两者的编程语言、工具、框架以及设计理念，我们将揭示各自平台的优势与局限，为开发者提供实用的参考，并为消费者呈现一个更加清晰的平台选择视角。
天下无贼001
18 2
游客5fdji2pvmf8888
|
10天前
|
开发工具 Android开发 Swift
安卓与iOS开发环境对比分析
在移动应用开发的广阔天地中，安卓和iOS两大平台各自占据半壁江山。本文深入探讨了这两个操作系统的开发环境，从编程语言、开发工具到用户界面设计等多个维度进行比较。通过丰富的数据支持和案例研究，揭示了不同平台的优势与挑战，为开发者提供了宝贵的参考信息。
游客5fdji2pvmf8888
23 5
zhanbao
|
9天前
|
安全 开发工具 Android开发
安卓与iOS开发环境对比分析
本文通过深入探讨和比较安卓与iOS两大主流移动操作系统的开发环境，旨在为开发者提供一个全面的视角。我们将从开发工具、编程语言、用户界面设计、性能优化、安全性考量等多个维度进行细致分析，揭示各自平台的优势与挑战。通过统计数据支持的实证研究，本文将展示两个系统在实际应用中的技术差异及其对项目开发周期的影响，并基于市场数据评估各自的商业潜力。
zhanbao
15 1
叫个什么名字
|
13天前
|
Java 开发工具 Android开发
安卓与iOS开发环境对比分析
在移动应用开发的广阔天地中，安卓和iOS两大平台各自占据半壁江山。本文深入探讨了两者的开发环境差异，从编程语言、工具框架到用户群体和市场份额进行了全面比较。通过数据支撑和案例分析，揭示了不同平台的优势与局限，旨在为开发者提供决策参考，同时预测未来发展趋势。
叫个什么名字
21 5
wenxinx
|
15天前
|
API 开发工具 Android开发
安卓与iOS开发环境对比分析
在移动操作系统的两大阵营中，安卓和iOS各占据着重要的地位。本文旨在深入探讨两种系统在开发环境方面的异同，通过对开发工具、语言、框架、API以及生态系统的综合比较，揭示各自在应用开发上的优势与挑战。文章将基于最新的市场数据和技术发展进行论述，以期为开发者提供有价值的参考信息，并预测未来可能的发展趋势。
wenxinx
22 1
Ant.Dream
|
23天前
|
算法 Java API
Android性能优化面试题经典之ANR的分析和优化
Android ANR发生于应用无法在限定时间内响应用户输入或完成操作。主要条件包括：输入超时（5秒）、广播超时（前台10秒/后台60秒）、服务超时及ContentProvider超时。常见原因有网络、数据库、文件操作、计算任务、UI渲染、锁等待、ContentProvider和BroadcastReceiver的不当使用。分析ANR可借助logcat和traces.txt。主线程执行生命周期回调、Service、BroadcastReceiver等，避免主线程耗时操作
Ant.Dream
25 3

热门文章

最新文章

  • 1
    华为「鸿蒙」出世：全球首个微内核全场景分布式OS，可取代安卓，发布即开源
  • 2
    新漏洞发现，影响 95% 安卓设备
  • 3
    老司机带路——15个Android撸代码常见的坑
  • 4
    Android编译注意事项
  • 5
    Android常见错误汇总
  • 6
    android第九期 - QQ5.0主窗体resideMenu
  • 7
    设置Android程序图标
  • 8
    Android -- ListView与ArrayAdapter、SimpleAdapter
  • 9
    Android自定义通知布局Notification，点击Notification导航切换回原Activity
  • 10
    android 详解 SharedPreferences
  • 1
    打造高效移动应用：Android与iOS性能优化策略
    40
  • 2
    构建未来：基于Android的智能家居控制系统开发
    72
  • 3
    构建高效Android应用：内存优化策略深度剖析
    44
  • 4
    构建高效Android应用：探究Kotlin协程的优化实践
    34
  • 5
    Android应用性能优化实战
    39
  • 6
    R语言对git安卓包分类统计、聚类、复杂网络可视化分析
    27
  • 7
    构建高效Android应用：探究Kotlin协程的优势与实践
    34
  • 8
    构建高效的Android应用：从内存优化到电池寿命
    43
  • 9
    【专栏】Kotlin在Android开发中的多线程优化，包括线程池、协程的使用，任务分解、避免阻塞操作以及资源管理
    58
  • 10
    【专栏】在人工智能时代，Android和iOS两大移动操作系统巨头正加速融合与创新
    40

    • 相关课程

    更多
  • 开源Android容器化框架Atlas开发者指南

    • 相关电子书

    更多
  • 58同城Android客户端Walle框架演进与实践之路
  • Android组件化实现
  • 蚂蚁聚宝Android秒级编译——Freeline
    • 下一篇
    通义千问API入门教程