四、Camera显示之Hal层的适配(二)

转载来自：http://blog.csdn.net/wsb1321/article/details/22080325

接着上一篇：

Camera显示之Hal层的适配(一)

一.基本关系

1.先来看看KTM hal层大概类图关系：

大概类图关系就是这样， 其中和显示相关的类图关系如红线所圈区域。

可以猜测到 与显示相关的逻辑处理应该都会在DisplayClient这个类去实现。

2.CamDeviceManager和DisplayClient关系的建立：

以后app下达有关预览显示相关的东西啊在hal层基本上都是这一条先进行传递命令， 不过总1中我们可以看到CamDevice还有一些衍生类， 这些都是mtk为不同设备做的一些定制， 主要的路径还是如上图所示。

二.接着之前的在CameraClient中的代码：

 //!++
 else if ( window == 0 ) {
     result = mHardware->setPreviewWindow(window);
 }

1.setPreviewWindow(window)通过CameraHardwareInterface适配：

 mDevice->ops->set_preview_window(mDevice,
                     buf.get() ? &mHalPreviewWindow.nw : 0);

来实现向hal层下达命令和设置参数。

在这里我们发现传入的是mHalPreviewWindow.nw， 而不是我们之前所讲述的ANativeWindow 这是因为mHalPreviewWindow.nw将ANativeWindow的一些流的操作进行封装， 使之操作更加简便。

mHalPreviewWindow.nw的定义：

 struct camera_preview_window {
        struct preview_stream_ops nw;
        void *user;
    };

就是结构体：struct ：

 typedef struct preview_stream_ops {
     int (*dequeue_buffer)(struct preview_stream_ops* w,
                           buffer_handle_t** buffer, int *stride);
     int (*enqueue_buffer)(struct preview_stream_ops* w,
                 buffer_handle_t* buffer);
     int (*cancel_buffer)(struct preview_stream_ops* w,
                 buffer_handle_t* buffer);
     int (*set_buffer_count)(struct preview_stream_ops* w, int count);
     int (*set_buffers_geometry)(struct preview_stream_ops* pw,
                 int w, int h, int format);
     int (*set_crop)(struct preview_stream_ops *w,
                 int left, int top, int right, int bottom);
     int (*set_usage)(struct preview_stream_ops* w, int usage);
     int (*set_swap_interval)(struct preview_stream_ops *w, int interval);
     int (*get_min_undequeued_buffer_count)(const struct preview_stream_ops *w,
                 int *count);
     int (*lock_buffer)(struct preview_stream_ops* w,
                 buffer_handle_t* buffer);
     // Timestamps are measured in nanoseconds, and must be comparable
     // and monotonically increasing between two frames in the same
     // preview stream. They do not need to be comparable between
     // consecutive or parallel preview streams, cameras, or app runs.
     int (*set_timestamp)(struct preview_stream_ops *w, int64_t timestamp);

对显示流的操作都是通过这些函数实现的，而mHalPreviewWindow中实现了具体操的方法， 在这些方法的实现中实现对作ANativeWindow的操作。 而在hal端就是通过mHalPreviewWindow.nw 进行对ANativeWindow的具体操作。

基本类图关系：

2.继续1中的：

 mDevice->ops->set_preview_window(mDevice,
                     buf.get() ? &mHalPreviewWindow.nw : 0);

我已经知道了mHalPreviewWindow.nw为传入的一个重要参数mHalPreviewWindow.nw 为preview_stream_ops。

继续看看set_preview_window这个方法。 我们有上篇文章知道ops是ICamDevice的一个成员gCameraDevOps，类型为camera_device_ops_t：

可以看到：

 static camera_device_ops_t const gCameraDevOps = {
     set_preview_window:         camera_set_preview_window,
     set_callbacks:              camera_set_callbacks,
     enable_msg_type:            camera_enable_msg_type,
     disable_msg_type:           camera_disable_msg_type,
     msg_type_enabled:           camera_msg_type_enabled,
     start_preview:              camera_start_preview,
     stop_preview:               camera_stop_preview,
     preview_enabled:            camera_preview_enabled,
     store_meta_data_in_buffers: camera_store_meta_data_in_buffers,
     start_recording:            camera_start_recording,
     stop_recording:             camera_stop_recording,
     recording_enabled:          camera_recording_enabled,
     release_recording_frame:    camera_release_recording_frame,
     auto_focus:                 camera_auto_focus,
     cancel_auto_focus:          camera_cancel_auto_focus,
     take_picture:               camera_take_picture,
     cancel_picture:             camera_cancel_picture,
     set_parameters:             camera_set_parameters,
     get_parameters:             camera_get_parameters,
     put_parameters:             camera_put_parameters,
     send_command:               camera_send_command,
     release:                    camera_release,
     dump:                       camera_dump,

 };

gCameraDevOps 中的函数地址映射到ICamDevice中的函数实现。

所以 ：ops->set_preview_window(mDevice, buf.get() ? &mHalPreviewWindow.nw : 0) 就对应到ICamDevice::camera_set_preview_window的发发调用。

 static int camera_set_preview_window(
     struct camera_device * device,
     struct preview_stream_ops *window
 )
 {
     int err = -EINVAL;
     //
     ICamDevice*const pDev = ICamDevice::getIDev(device);
     if  ( pDev )
     {
         err = pDev->setPreviewWindow(window);
     }
     //
     return  err;
 }

 static inline ICamDevice*   getIDev(camera_device*const device)
                                 {
                                     return (NULL == device)
                                                 ? NULL
                                                 : reinterpret_cast(device->priv);//得到device->priv

由上篇文章：

知道device->pri实际上是在创建实例的时候指向的自己：

 ICamDevice::
 ICamDevice()
     : camera_device_t()
     , RefBase()
     , mDevOps()
     //
     , mMtxLock()
     //
 {
     MY_LOGD("ctor");
     ::memset(static_cast(this), 0, sizeof(camera_device_t));
     this->priv  = this; //用priv指针保存自己。
     this->ops   = &mDevOps;//ops指向了mDevOps
     mDevOps     = gCameraDevOps;//mDevOps为gCameraDevOps指向的结构体
 }

继续回到pDev->setPreviewWindow(window);

在ICamDevice中没有对setPreviewWindow具体的实现，而是在其子类CamDevice对ICamDevice进行了具体的实现;

随意代码定位到CamDevice：

 status_t
 CamDevice::
 setPreviewWindow(preview_stream_ops* window)
 {
     MY_LOGI("+ window(%p)", window);
     //
     status_t status = initDisplayClient(window);//开始初始化DisplayClient
     if  ( OK == status && previewEnabled() && mpDisplayClient != 0 )
     {
         status = enableDisplayClient();//时能DisplayClient端
     }
     //
     return  status;
 }

 status_t
 CamDevice::
 initDisplayClient(preview_stream_ops* window)
 {
 #if '1'!=MTKCAM_HAVE_DISPLAY_CLIENT
     #warning "Not Build Display Client"
     MY_LOGD("Not Build Display Client");
 ..............
 .............
 /  [3.1] create a Display Client.
     mpDisplayClient = IDisplayClient::createInstance();
     if  ( mpDisplayClient == 0 )
     {
         MY_LOGE("Cannot create mpDisplayClient");
         status = NO_MEMORY;
         goto lbExit;
     }
     //  [3.2] initialize the newly-created Display Client.
     if  ( ! mpDisplayClient->init() )
     {
         MY_LOGE("mpDisplayClient init() failed");
         mpDisplayClient->uninit();
         mpDisplayClient.clear();
         status = NO_MEMORY;
         goto lbExit;
     }
     //  [3.3] set preview_stream_ops & related window info.
     if  ( ! mpDisplayClient->setWindow(window, previewSize.width, previewSize.height, queryDisplayBufCount()) )//绑定window
     {
         status = INVALID_OPERATION;
         goto lbExit;
     }
     //  [3.4] set Image Buffer Provider Client if it exist.
     if  ( mpCamAdapter != 0 && ! mpDisplayClient->setImgBufProviderClient(mpCamAdapter) )//重要！ 设置流数据的Buffer提供者。
     {
         status = INVALID_OPERATION;
         goto lbExit;
     }
 ..................
 ..................

 status_t
 CamDevice::
 enableDisplayClient()
 {
     status_t status = OK;
     Size previewSize;
     //
     //  [1] Get preview size.
     if  ( ! queryPreviewSize(previewSize.width, previewSize.height) )
     {
         MY_LOGE("queryPreviewSize");
         status = DEAD_OBJECT;
         goto lbExit;
     }
     //
     //  [2] Enable
     if  ( ! mpDisplayClient->enableDisplay(previewSize.width, previewSize.height, queryDisplayBufCount(), mpCamAdapter) )//设置了预览数据的尺寸和Buffer提供者相关的数据
     {
         MY_LOGE("mpDisplayClient(%p)->enableDisplay()", mpDisplayClient.get());
         status = INVALID_OPERATION;
         goto lbExit;
     }
     //
     status = OK;
 lbExit:
     return  status;
 }

3.定位到DisplayClient中：

 enableDisplay(
     int32_t const   i4Width,
     int32_t const   i4Height,
     int32_t const   i4BufCount,
     spconst& rpClient
 )
 {
     bool ret = false;
     preview_stream_ops* pStreamOps = mpStreamOps;
     //
     //  [1] Re-configurate this instance if any setting changes.
     if  ( ! checkConfig(i4Width, i4Height, i4BufCount, rpClient) )
     {
         MY_LOGW(" Uninit the current DisplayClient(%p) and re-config...", this);
         //
         //  [.1] uninitialize
         uninit();
         //
         //  [.2] initialize
         if  ( ! init() )
         {
             MY_LOGE("re-init() failed");
             goto lbExit;
         }
         //
         //  [.3] set related window info.
         if  ( ! setWindow(pStreamOps, i4Width, i4Height, i4BufCount) )//window的尺寸和预览数据的大小一致
         {
             goto lbExit;
         }
         //
         //  [.4] set Image Buffer Provider Client.
         if  ( ! setImgBufProviderClient(rpClient) )//Buffer的数据提供者为mpCamAdapter， 就是CamAdapter， 后面的预览数据元都是通过它来提供。
         {
             goto lbExit;
         }
     }
     //
     //  [2] Enable.
     if  ( ! enableDisplay() )//开始进行数据的获取和显示
     {
         goto lbExit;
     }
     //
     ret = true;
 lbExit:
     return  ret;
 }

先来看看第一个关键函数：setWindow(pStreamOps, i4Width, i4Height, i4BufCount)

 bool
 DisplayClient::
 setWindow(
     preview_stream_ops*const window,
     int32_t const   wndWidth,
     int32_t const   wndHeight,
     int32_t const   i4MaxImgBufCount
 )
 {
     MY_LOGI("+ window(%p), WxH=%dx%d, count(%d)", window, wndWidth, wndHeight, i4MaxImgBufCount);
     //
     if  ( ! window )
     {
         MY_LOGE("NULL window passed into");
         return  false;
     }
     //
     if  ( 0 >= wndWidth || 0 >= wndHeight || 0 >= i4MaxImgBufCount )
     {
         MY_LOGE("bad arguments - WxH=%dx%d, count(%d)", wndWidth, wndHeight, i4MaxImgBufCount);
         return  false;
     }
     //
     //
     Mutex::Autolock _l(mModuleMtx);
     return  set_preview_stream_ops(window, wndWidth, wndHeight, i4MaxImgBufCount);//
 }

 ool
 DisplayClient::
 set_preview_stream_ops(
     preview_stream_ops*const window,
     int32_t const   wndWidth,
     int32_t const   wndHeight,
     int32_t const   i4MaxImgBufCount
 )
 {
     CamProfile profile(__FUNCTION__, "DisplayClient");
     //
     bool        ret = false;
     status_t    err = 0;
     int32_t     min_undequeued_buf_count = 0;
     //
     //  (2) Check
     if  ( ! mStreamBufList.empty() )
     {
         MY_LOGE(
             "locked buffer count(%d)!=0, "
             "callers must return all dequeued buffers, "
 //            "and then call cleanupQueue()"
             , mStreamBufList.size()
         );
         dumpDebug(mStreamBufList, __FUNCTION__);
         goto lbExit;
     }
     //
     //  (3) Sava info.
     mpStreamImgInfo.clear();//mpStreamImgInfo封装的视屏数据流的基本信息。
     mpStreamImgInfo     = new ImgInfo(wndWidth, wndHeight, CAMERA_DISPLAY_FORMAT, CAMERA_DISPLAY_FORMAT_HAL, "Camera@Display");//设置了Stream的宽高和显示类型。
     mpStreamOps         = window;//mpStreamOps保存了上层传进来的对象指针。后面就通过它和显示方进行交互。
     mi4MaxImgBufCount   = i4MaxImgBufCount;

 ........................
 ........................

  err = mpStreamOps->set_buffer_count(mpStreamOps, mi4MaxImgBufCount+min_undequeued_buf_count);
     if  ( err )
     {
         MY_LOGE("set_buffer_count failed: status[%s(%d)]", ::strerror(-err), -err);
         if ( ENODEV == err )
         {
             MY_LOGD("Preview surface abandoned!");
             mpStreamOps = NULL;
         }
         goto lbExit;
     }
     //
     //  (4.4) Set window geometry
     err = mpStreamOps->set_buffers_geometry(//设置基本的流信息
             mpStreamOps,
             mpStreamImgInfo->mu4ImgWidth,
             mpStreamImgInfo->mu4ImgHeight,
             mpStreamImgInfo->mi4ImgFormat
         );

通过 上面的代码片段和分析， 确定了上层传递下来的对象指针保存在mpStreamOps， 与显示相关的交互都将通过mpStreamOps来进行操作。 而mpStreamImgInfo封装了流数据的大小和格式等。

再来看看第二个关键函数：setImgBufProviderClient(rpClient)：

 bool
 DisplayClient::
 setImgBufProviderClient(spconst& rpClient)
 {
     bool ret = false;
     //
     MY_LOGD("+ ImgBufProviderClient(%p), mpImgBufQueue.get(%p)", rpClient.get(), mpImgBufQueue.get());
     //
     if  ( rpClient == 0 )
     {
         MY_LOGE("NULL ImgBufProviderClient");
         mpImgBufPvdrClient = NULL;
         goto lbExit;
     }
     //
     if  ( mpImgBufQueue != 0 )
     {
         if  ( ! rpClient->onImgBufProviderCreated(mpImgBufQueue) )//通知Provider端(Buffer数据提供者端)，我这边已经建好Buffer队列， 后面你就填充数据到对应的Buffer供我使用。
         {
             goto lbExit;
         }
         mpImgBufPvdrClient = rpClient;//用mpImgBufPvdrClient保存provider的对象指针， 方便使用。
     }
     //
     ret = true;
 lbExit:
     MY_LOGD("-");
     return  ret;
 };

再来看看第三个关键函数 enableDisplay() ：

 bool
 DisplayClient::
 enableDisplay()
 {
     bool ret = false;
     //
     //  (1) Lock
     Mutex::Autolock _l(mModuleMtx);
     //
     MY_LOGD("+ isDisplayEnabled(%d), mpDisplayThread.get(%p)", isDisplayEnabled(), mpDisplayThread.get());
     //
     //  (2) Check to see if it has been enabled.
     if  ( isDisplayEnabled() )
     {
         MY_LOGD("Display is already enabled");
         ret = true;
         goto lbExit;
     }
     //
     //  (3) Check to see if thread is alive.
     if  ( mpDisplayThread == 0 )
     {
         MY_LOGE("NULL mpDisplayThread");
         goto lbExit;
     }
     //
     //  (4) Enable the flag.
     ::android_atomic_write(1, &mIsDisplayEnabled);
     //
     //  (5) Post a command to wake up the thread.
     mpDisplayThread->postCommand(Command(Command::eID_WAKEUP));//通知获取数据的线程开始运行
     //
     //
     ret = true;
 lbExit:
     MY_LOGD("- ret(%d)", ret);
     return ret;
 }

 bool
 DisplayThread::
 threadLoop()
 {
     Command cmd;
     if  ( getCommand(cmd) )
     {
         switch  (cmd.eId)
         {
         case Command::eID_EXIT:
             MY_LOGD("Command::%s", cmd.name());
             break;
         //
         case Command::eID_WAKEUP://对应上面发送的命令
         default:
             if  ( mpThreadHandler != 0 )
             {
                 mpThreadHandler->onThreadLoop(cmd);//注意此处， mpThreadHandler就是DisplayClient(它继承了IDisplayThreadHandler)，
             }
             else
             {
                 MY_LOGE("cannot handle cmd(%s) due to mpThreadHandler==NULL", cmd.name());
             }
             break;
         }
     }
     //
     MY_LOGD("- mpThreadHandler.get(%p)", mpThreadHandler.get());
     return  true;
 }

回到DisplayClient的onThreadLoop函数：

 bool
 DisplayClient::
 onThreadLoop(Command const& rCmd)
 {
     //  (0) lock Processor.
     sp pImgBufQueue;
     {
         Mutex::Autolock _l(mModuleMtx);
         pImgBufQueue = mpImgBufQueue;
         if  ( pImgBufQueue == 0 || ! isDisplayEnabled() )//判断显示相关的初始化是否完成和启动
         {
             MY_LOGW("pImgBufQueue.get(%p), isDisplayEnabled(%d)", pImgBufQueue.get(), isDisplayEnabled());
             return  true;
         }
     }

     //  (1) Prepare all TODO buffers.
     if  ( ! prepareAllTodoBuffers(pImgBufQueue) )//为pImgBufQueue添加空Buffer。
     {
         return  true;
     }

     //  (2) Start
     if  ( ! pImgBufQueue->startProcessor() )//开始获取数据
     {
         return  true;
     }
     //
     {
         Mutex::Autolock _l(mStateMutex);
         mState = eState_Loop;
         mStateCond.broadcast();
     }
     //
     //  (3) Do until disabled.
     while   ( 1 )//进入无限循环
     {
         //  (.1)
         waitAndHandleReturnBuffers(pImgBufQueue);//等待pImgBufQueue中的数据,并送到显示端显示

         //  (.2) break if disabled.
         if  ( ! isDisplayEnabled() )
         {
             MY_LOGI("Display disabled");
             break;
         }

         //  (.3) re-prepare all TODO buffers, if possible,
         //  since some DONE/CANCEL buffers return.
         prepareAllTodoBuffers(pImgBufQueue);//又重新准备Buffer。
     }
     //
     //  (4) Stop
     pImgBufQueue->pauseProcessor();
     pImgBufQueue->flushProcessor();
     pImgBufQueue->stopProcessor();//停止数据获取
     //
     //  (5) Cancel all un-returned buffers.
     cancelAllUnreturnBuffers();//没有来得及显示额数据， 也取消掉。
     //
     {
         Mutex::Autolock _l(mStateMutex);
         mState = eState_Suspend;
         mStateCond.broadcast();
     }
     //
     return  true;
 }

上边这个代码片段对预览数据的处理就在waitAndHandleReturnBuffers(pImgBufQueue);中。

4.对waitAndHandleReturnBuffers(pImgBufQueue);进行分析：

 bool
 DisplayClient::
 waitAndHandleReturnBuffers(spconst& rpBufQueue)
 {
     bool ret = false;
     Vector vQueNode;
     //
     MY_LOGD_IF((1<=miLogLevel), "+");
     //
     //  (1) deque buffers from processor.
     rpBufQueue->dequeProcessor(vQueNode);//从provider端（数据提供端）获取一个填充数据了的Buffer。
     if  ( vQueNode.empty() ) {
         MY_LOGW("vQueNode.empty()");
         goto lbExit;
     }

     //  (2) handle buffers dequed from processor.
     ret = handleReturnBuffers(vQueNode);//处理填充了数据的这个Buffer中的数据。

 lbExit:
     //
     MY_LOGD_IF((2<=miLogLevel), "- ret(%d)", ret);
     return ret;
 }

看看handleReturnBuffers函数：

 bool
 DisplayClient::
 handleReturnBuffers(Vectorconst& rvQueNode)
 {
     /*
      * Notes:
      *  For 30 fps, we just enque (display) the latest frame,
      *  and cancel the others.
      *  For frame rate > 30 fps, we should judge the timestamp here or source.
      */
     //  (1) determine the latest DONE buffer index to display; otherwise CANCEL.
     int32_t idxToDisp = 0;
     for ( idxToDisp = rvQueNode.size()-1; idxToDisp >= 0; idxToDisp--)
     {
         if  ( rvQueNode[idxToDisp].isDONE() )
             break;
     }
     if  ( rvQueNode.size() > 1 )
     {
         MY_LOGW("(%d) display frame count > 1 --> select %d to display", rvQueNode.size(), idxToDisp);
     }
     //
     //  Show Time duration.
     if  ( 0 <= idxToDisp )
     {
         nsecs_t const _timestamp1 = rvQueNode[idxToDisp].getImgBuf()->getTimestamp();
         mProfile_buffer_timestamp.pulse(_timestamp1);
         nsecs_t const _msDuration_buffer_timestamp = ::ns2ms(mProfile_buffer_timestamp.getDuration());
         mProfile_buffer_timestamp.reset(_timestamp1);
         //
         mProfile_dequeProcessor.pulse();
         nsecs_t const _msDuration_dequeProcessor = ::ns2ms(mProfile_dequeProcessor.getDuration());
         mProfile_dequeProcessor.reset();
         //
         MY_LOGD_IF(
             (1<=miLogLevel), "+ %s(%lld) %s(%lld)",
             (_msDuration_buffer_timestamp < 0 ) ? "time inversion!" : "", _msDuration_buffer_timestamp,
             (_msDuration_dequeProcessor > 34) ? "34ms < Duration" : "", _msDuration_dequeProcessor
         );
     }
     //
     //  (2) Lock
     Mutex::Autolock _l(mModuleMtx);
     //
     //  (3) Remove from List and enquePrvOps/cancelPrvOps, one by one.
     int32_t const queSize = rvQueNode.size();
     for (int32_t i = 0; i < queSize; i++)
     {
         spconst&       rpQueImgBuf = rvQueNode[i].getImgBuf(); //  ImgBuf in Queue.
         spconst pStreamImgBuf = *mStreamBufList.begin();  //  ImgBuf in List.
         //  (.1)  Check valid pointers to image buffers in Queue & List
         if  ( rpQueImgBuf == 0 || pStreamImgBuf == 0 )
         {
             MY_LOGW("Bad ImgBuf:(Que[%d], List.begin)=(%p, %p)", i, rpQueImgBuf.get(), pStreamImgBuf.get());
             continue;
         }
         //  (.2)  Check the equality of image buffers between Queue & List.
         if  ( rpQueImgBuf->getVirAddr() != pStreamImgBuf->getVirAddr() )
         {
             MY_LOGW("Bad address in ImgBuf:(Que[%d], List.begin)=(%p, %p)", i, rpQueImgBuf->getVirAddr(), pStreamImgBuf->getVirAddr());
             continue;
         }
         //  (.3)  Every check is ok. Now remove the node from the list.
         mStreamBufList.erase(mStreamBufList.begin());//经过检查返回的这一帧数据的Buffer是DisplayClient端分配和提供的。
         //
         //  (.4)  enquePrvOps/cancelPrvOps
         if  ( i == idxToDisp ) {
             MY_LOGD_IF(
                 (1<=miLogLevel),
                 "Show frame:%d %d [ion:%d %p/%d %lld]",
                 i, rvQueNode[i].getStatus(), pStreamImgBuf->getIonFd(),
                 pStreamImgBuf->getVirAddr(), pStreamImgBuf->getBufSize(), pStreamImgBuf->getTimestamp()
             );
             //
             if(mpExtImgProc != NULL)
             {
                 if(mpExtImgProc->getImgMask() & ExtImgProc::BufType_Display)
                 {
                     IExtImgProc::ImgInfo img;
                     //
                     img.bufType     = ExtImgProc::BufType_Display;
                     img.format      = pStreamImgBuf->getImgFormat();
                     img.width       = pStreamImgBuf->getImgWidth();
                     img.height      = pStreamImgBuf->getImgHeight();
                     img.stride[0]   = pStreamImgBuf->getImgWidthStride(0);
                     img.stride[1]   = pStreamImgBuf->getImgWidthStride(1);
                     img.stride[2]   = pStreamImgBuf->getImgWidthStride(2);
                     img.virtAddr    = (MUINT32)(pStreamImgBuf->getVirAddr());
                     img.bufSize     = pStreamImgBuf->getBufSize();
                     //
                     mpExtImgProc->doImgProc(img);
                 }
             }
             //
             enquePrvOps(pStreamImgBuf);//送入显示端显示
         }
         else {
             MY_LOGW(
                 "Drop frame:%d %d [ion:%d %p/%d %lld]",
                 i, rvQueNode[i].getStatus(), pStreamImgBuf->getIonFd(),
                 pStreamImgBuf->getVirAddr(), pStreamImgBuf->getBufSize(), pStreamImgBuf->getTimestamp()
             );
             cancelPrvOps(pStreamImgBuf);
         }
     }
     //
     MY_LOGD_IF((1<=miLogLevel), "-");
     return  true;
 }



 void
 DisplayClient::
 enquePrvOps(spconst& rpImgBuf)
 {
     mProfile_enquePrvOps.pulse();
     if  ( mProfile_enquePrvOps.getDuration() >= ::s2ns(2) ) {
         mProfile_enquePrvOps.updateFps();
         mProfile_enquePrvOps.showFps();
         mProfile_enquePrvOps.reset();
     }
     //
     status_t    err = 0;
     //
     CamProfile profile(__FUNCTION__, "DisplayClient");
     profile.print_overtime(
         ((1<=miLogLevel) ? 0 : 1000),
         "+ locked buffer count(%d), rpImgBuf(%p,%p), Timestamp(%lld)",
         mStreamBufList.size(), rpImgBuf.get(), rpImgBuf->getVirAddr(), rpImgBuf->getTimestamp()
     );
     //
     //  [1] unlock buffer before sending to display
     GraphicBufferMapper::get().unlock(rpImgBuf->getBufHndl());
     profile.print_overtime(1, "GraphicBufferMapper::unlock");
     //
     //  [2] Dump image if wanted.
     dumpImgBuf_If(rpImgBuf);
     //
     //  [3] set timestamp.
     err = mpStreamOps->set_timestamp(mpStreamOps, rpImgBuf->getTimestamp());
     profile.print_overtime(2, "mpStreamOps->set_timestamp, Timestamp(%lld)", rpImgBuf->getTimestamp());
     if  ( err )
     {
         MY_LOGE(
             "mpStreamOps->set_timestamp failed: status[%s(%d)], rpImgBuf(%p), Timestamp(%lld)",
             ::strerror(-err), -err, rpImgBuf.get(), rpImgBuf->getTimestamp()
         );
     }
     //
     //  [4] set gralloc buffer type & dirty
     ::gralloc_extra_setBufParameter(
         rpImgBuf->getBufHndl(),
         GRALLOC_EXTRA_MASK_TYPE | GRALLOC_EXTRA_MASK_DIRTY,
         GRALLOC_EXTRA_BIT_TYPE_CAMERA | GRALLOC_EXTRA_BIT_DIRTY
     );
     //
     //  [5] unlocks and post the buffer to display.
     err = mpStreamOps->enqueue_buffer(mpStreamOps, rpImgBuf->getBufHndlPtr());//注意这里可以看到最终是通过mpStreamOps送入送给显示端显示的。
     profile.print_overtime(10, "mpStreamOps->enqueue_buffer, Timestamp(%lld)", rpImgBuf->getTimestamp());
     if  ( err )
     {
         MY_LOGE(
             "mpStreamOps->enqueue_buffer failed: status[%s(%d)], rpImgBuf(%p,%p)",
             ::strerror(-err), -err, rpImgBuf.get(), rpImgBuf->getVirAddr()
         );
     }
 }

从上面的代码片段， 可以看到从显示数据最终是通过mpStreamOps（CameraHardwareInterface中传下来的的mHalPreviewWindow.nw）来进行处理的。

至此预览数据就算完全交给了ANativeWindow进行显示。

但是预览数据究竟是怎样从Provider端来的， 我们也提到在DisplayClient也会去分配一些buffer， 这些Buffer又是如何管理的。 后续会接着分享。