閱讀48 返回首頁    go 阿裏雲 go 技術社區[雲棲]

Android Camera數據流分析全程記錄（overlay方式）

https://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.          

    最後更新：2017-04-03 18:52:05

      上一篇：go Android 動態添加控件
      下一篇：go Java中的HashMap和ConcurrentHashMap的並發性能測試