返回发烧友论坛
发 帖  

[文章]OpenHarmony相机用户态驱动框架

HiHope社区
2022-04-20 17:09:41
阅读量0
OpenHarmony
0
4
作者：润和软件 郭新星
相机作为智能手机上少有的成长空间不错的，能够做出差异化的功能，每年都能成为各大Android手机厂商争相宣传的亮点。众所周知Android采用Linux 作为其内核，而Linux采用的开源协议具有传染性[1]，导致Android HAL[2]成为了手机厂商们竞争的重要战场。随着OpenHarmony 3.1[3]的发布，相机模块也逐渐完善起来，目前提供了基础预览和拍照的能力。OpenHarmony中，相机用户态驱动框架承担了和Android Camera HAL一样的角色，这部分位于OpenHarmony的HDF[4]中，对上实现相机HDI[5]接口，对下实现相机Pipeline模型，管理相机各个硬件设备。

相机用户态驱动框架（下图的CameraHost 部分）总体可以分为三层，HDI实现层，实现相机标准南向接口；框架层，对接HDI实现层的控制、流的转发，实现数据通路的搭建、管理相机各个硬件设备等功能；适配层，屏蔽底层芯片和OS差异，支持多平台适配。

模块介绍
HDI Implementation：对上实现HDI接口，向下调用框架层的接口，完成HDI接口任务的转发。
Buffer Manager ： 屏蔽不同内存管理的差异，为子系统提供统一的操作接口，同时提供buffer轮转的功能。
Pipeline Core ：解析HCS配置完成pipeline的搭建，调度pipeline中的各个node完成流的处理
Device Manager：通过调用底层硬件适配层接口，实现查询控制底层设备、枚举监听底层设备的功能
Platform Adaption ：屏蔽硬件差异，为Device Manager提供统一的操作底层硬件的能力
•目录结构
  1. Shell
  2. drivers/peripheral/camera

  4. |-- README_zh.md

  6. |-- bundle.json

  8. |-- figures

  10. |   `-- logic-view-of-modules-related-to-this-repository_zh.png

  12. |-- hal

  14. |   |-- BUILD.gn

  16. |   |-- adapter

  18. |   |-- buffer_manager

  20. |   |-- camera.gni

  22. |   |-- device_manager

  24. |   |-- hdi_impl

  26. |   |-- include

  28. |   |-- init

  30. |   |-- pipeline_core

  32. |   |-- test

  34. |   `-- utils

  36. |-- hal_c

  38. |   |-- BUILD.gn

  40. |   |-- camera.gni

  42. |   |-- hdi_cif

  44. |   `-- include

  46. `-- interfaces

  48.     |-- hdi_ipc

  50.     |-- hdi_passthrough

  52.     `-- include

复制代码
HDI Implementation中的预览流程
接下来我们通过已经发布的OpenHarmony 3.1开源代码，来看看预览是怎么完成的吧
drivers/peripheral/camera/hal/test/v4l2/src /preview_test.cpp存放了针对v4l2的预览测试代码，入口如下
  1. C++
  2. TEST_F(UtestPreviewTest, camera_preview_0001)

  4. {

  6.     std::cout << "==========[test log] Preview stream, expected success." << std::endl;

  8.     // Get the stream manager

  10.     display_->AchieveStreamOperator(); // 获取stream operator

  12.     // start stream

  14.     display_->intents = {Camera::PREVIEW}; // 预览流

  16.     display_->StartStream(display_->intents); // 起流

  18.     // Get preview

  20.     display_->StartCapture(display_->streamId_preview, display_->captureId_preview, false, true);

  22.     // release stream

  24.     display_->captureIds = {display_->captureId_preview};

  26.     display_->streamIds = {display_->streamId_preview};

  28.     display_->StopStream(display_->captureIds, display_->streamIds);

  30. }

复制代码
先获取stream operator实例
  1. C++
  2. void testdisplay::achievestreamoperator()

  4. {

  6.     // create and get streamoperator information

  8.     std::shared_ptr<ohos::camera::istreamoperatorcallback> streamoperatorcallback =

  10.         std::make_shared<ohos::camera::istreamoperatorcallback>();

  12.     rc = cameradevice->getstreamoperator(streamoperatorcallback, streamoperator);

  14.                                         // ........

  16. }

复制代码
通过前文的streamOperator创建流
  1. C++
  2. void TestDisplay::StartStream(std::vector<OHOS::Camera::StreamIntent> intents)

  4. {

  6.     // ..............................

  8.     for (auto& intent : intents) {

  10.         if (intent == 0) {

  12.             std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue();

  14.             producer->SetQueueSize(8); // 创建buffer的生产端，并和相应的流进行绑定

  16.             auto callback = [this](std::shared_ptr<SurfaceBuffer> Prebuffer) {

  18.                 BufferCallback(Prebuffer, preview_mode);

  20.                 return;

  22.             };

  24.             producer->SetCallback(callback);

  26.             streamInfo->streamId_ = streamId_preview;

  28.             streamInfo->width_ = 640; // 640:picture width

  30.             streamInfo->height_ = 480; // 480:picture height

  32.             streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG;

  34.             streamInfo->datasapce_ = 8; // 8:picture datasapce

  36.             streamInfo->intent_ = intent;

  38.             streamInfo->tunneledMode_ = 5; // 5:tunnel mode

  40.             streamInfo->bufferQueue_ = producer;

  42.             streamInfos.push_back(streamInfo);

  44.         } else if (intent == 1) {

  46.       // .......................

  48.     }

  50.     rc = streamOperator->CreateStreams(streamInfos); // 创建流

  52.     // ................................

  54.     rc = streamOperator->CommitStreams(Camera::NORMAL, ability); // 提交流

  56.     // .................................

  58. }

复制代码
下面我们正式进入到hal的源代码中看看是怎么创建流的吧
  1. C++
  2. CamRetCode StreamOperator::CreateStreams(const std::vector<std::shared_ptr<StreamInfo>>& streamInfos)

  4. {

  6. // .....

  8.     for (auto it : streamInfos) {

  10. //....

  12.         std::shared_ptr<IStream> stream = StreamFactory::Instance().CreateShared(

  14.             IStream::g_availableStreamType[it->intent_], it->streamId_, it->intent_, pipelineCore_, messenger_); // 创建流实例

  16. // ...

  18.         StreamConfiguration scg;

  20.         scg.id = it->streamId_;

  22.         scg.type = it->intent_;

  24.         scg.width = it->width_;

  26.         scg.height = it->height_;

  28.         PixelFormat pf = static_cast<PixelFormat>(it->format_);

  30.         scg.format = BufferAdapter::PixelFormatToCameraFormat(pf);

  32.         scg.dataspace = it->datasapce_;

  34.         scg.tunnelMode = it->tunneledMode_;

  36.         scg.minFrameDuration = it->minFrameDuration_;

  38.         scg.encodeType = it->encodeType_;



  42.         RetCode rc = stream->ConfigStream(scg); // 依据上文的流信息配置流

  44. // ...

  46.         if (it->bufferQueue_ != nullptr) {  // 绑定前文的生产端

  48.             auto tunnel = std::make_shared<StreamTunnel>();

  50.             CHECK_IF_PTR_NULL_RETURN_VALUE(tunnel, INSUFFICIENT_RESOURCES);

  52.             RetCode rc = tunnel->AttachBufferQueue(it->bufferQueue_);

  54.             CHECK_IF_NOT_EQUAL_RETURN_VALUE(rc, RC_OK, INVALID_ARGUMENT);

  56.             if (stream->AttachStreamTunnel(tunnel) != RC_OK) {

  58.                 CAMERA_LOGE("attach buffer queue to stream [id = %{public}d] failed", it->streamId_);

  60.                 return INVALID_ARGUMENT;

  62.             }

  64.         }

  66.         {

  68.             std::lock_guard<std::mutex> l(streamLock_);

  70.             streamMap_[stream->GetStreamId()] = stream; // 保存流实例

  72.         }

  74. // ...

  76. }

复制代码

  1. C++
  2. RetCode StreamBase::CommitStream()

  4. {

  6. // ...

  8.     hostStreamMgr_ = pipelineCore_->GetHostStreamMgr(); //从pipelinecore获取hoststreamanager

  10.     CHECK_IF_PTR_NULL_RETURN_VALUE(hostStreamMgr_, RC_ERROR);

  12. // ...

  14.         info.bufferPoolId_ = poolId_;

  16.         info.bufferCount_ = GetBufferCount();

  18.     //  初始化 bufferpool

  20.         RetCode rc = bufferPool_->Init(streamConfig_.width, streamConfig_.height, streamConfig_.usage,

  22.                                        streamConfig_.format, GetBufferCount(), CAMERA_BUFFER_SOURCE_TYPE_EXTERNAL);

  24.         if (rc != RC_OK) {

  26.             CAMERA_LOGE("stream [id:%{public}d] initialize buffer pool failed.", streamId_);

  28.             return RC_ERROR;

  30.         }

  32.     }

  34. // stream传递到pipelinecore 并进行绑定

  36.     RetCode rc = hostStreamMgr_->CreateHostStream(info, [this](std::shared_ptr<IBuffer> buffer) {

  38.         HandleResult(buffer);

  40.         return;

  42.     });

  44. // ....

  46.     return RC_OK;

  48. }

复制代码
CreateStream 和CommitStream结束之后便是Capture，这里包含了起流的动作，关键实现如下
  1. C++
  2. CamRetCode StreamOperator::Capture(int captureId, const std::shared_ptr<CaptureInfo>& captureInfo, bool isStreaming)

  4. {

  6. // ...

  8. //  captureId 捕获请求的id; captureInfo 预览/拍照/录像的参数；isStreaming 连续捕获还是单次捕获（拍照）

  10.     CaptureSetting setting = captureInfo->captureSetting_;

  12.     auto request =

  14.         std::make_shared<CaptureRequest>(captureId, captureInfo->streamIds_.size(), setting,

  16.                                          captureInfo->enableShutterCallback_, isStreaming);

  18.     for (auto id : captureInfo->streamIds_) {

  20.         // 创建捕获请求，并传递给前文创建的流

  22.         RetCode rc = streamMap_[id]->AddRequest(request);

  24.         if (rc != RC_OK) {

  26.             return DEVICE_ERROR;

  28.         }

  30.     }

  32. // ...

  34. }

复制代码

  1. C++
  2. CamRetCode StreamOperator::Capture(int captureId, const std::shared_ptr<CaptureInfo>& captureInfo, bool isStreaming)

  4. {

  6. // ...

  8. //  captureId 捕获请求的id; captureInfo 预览/拍照/录像的参数；isStreaming 连续捕获还是单次捕获（拍照）

  10.     CaptureSetting setting = captureInfo->captureSetting_;

  12.     auto request =

  14.         std::make_shared<CaptureRequest>(captureId, captureInfo->streamIds_.size(), setting,

  16.                                          captureInfo->enableShutterCallback_, isStreaming);

  18.     for (auto id : captureInfo->streamIds_) {

  20.         // 创建捕获请求，并传递给前文创建的流

  22.         RetCode rc = streamMap_[id]->AddRequest(request);

  24.         if (rc != RC_OK) {

  26.             return DEVICE_ERROR;

  28.         }

  30.     }

  32. // ...

  34. }

复制代码
从上面的代码可知预览、拍照、录像都是通过捕获请求触发，单次拍照则为单次捕获请求，预览和录像则是连续捕获请求。
  1. C++
  2. RetCode StreamBase::AddRequest(std::shared_ptr<CaptureRequest>& request)

  4. {

  6.     CHECK_IF_PTR_NULL_RETURN_VALUE(request, RC_ERROR);

  8.     request->AddOwner(shared_from_this());



  12.     request->SetFirstRequest(false);

  14.     if (isFirstRequest) {

  16.         RetCode rc = StartStream(); // 起流

  18.         if (rc != RC_OK) {

  20.             CAMERA_LOGE("start stream [id:%{public}d] failed", streamId_);

  22.             return RC_ERROR;

  24.         }

  26.         request->SetFirstRequest(true);

  28.         isFirstRequest = false;

  30.     }



  34.     {

  36.         std::unique_lock<std::mutex> l(wtLock_);

  38.         waitingList_.emplace_back(request); // 捕获请求添加到waitingList

  40.         cv_.notify_one();

  42.     }



  46.     return RC_OK;

  48. }

复制代码
看看StreamStream是怎么实现的吧
  1. C++
  2. RetCode StreamBase::StartStream()

  4. {

  6. // ...

  8.     RetCode rc = pipeline_->Prepare({streamId_}); //  pipeline先完成一些准备工作

  10. // ...



  14.     state_ = STREAM_STATE_BUSY;

  16.     std::string threadName =

  18.         g_availableStreamType[static_cast<StreamIntent>(streamType_)] + "#" + std::to_string(streamId_);

  20.     handler_ = std::make_unique<std::thread>([this, &threadName] {// 创建轮转线程

  22.         prctl(PR_SET_NAME, threadName.c_str());

  24.         while (state_ == STREAM_STATE_BUSY) {

  26.             HandleRequest(); // 处理捕获请求

  28.         }

  30.     });

  32. // ...

  34.     rc = pipeline_->Start({streamId_}); // 通知pipeline和底层硬件可以开始出帧了

  36. // ...

  38.     return RC_OK;

  40. }

复制代码
  1. C++
  2. void StreamBase::HandleRequest()

  4. {

  6.     // 如果有 捕获请求下发，则退出等待状态

  8.     if (waitingList_.empty()) {

  10.         std::unique_lock<std::mutex> l(wtLock_);

  12.         if (waitingList_.empty()) {

  14.             cv_.wait(l, [this] { return !(state_ == STREAM_STATE_BUSY && waitingList_.empty()); });

  16.         }

  18.     }

  20. // ...

  22.         request = waitingList_.front();

  24.         CHECK_IF_PTR_NULL_RETURN_VOID(request);

  26.         if (!request->IsContinous()) { // 如果是连续捕获，则保留一份拷贝在waitinglist

  28.             waitingList_.pop_front();

  30.         }

  32.     }

  34. // 处理捕获请求

  36.     request->Process(streamId_);// 最终调用下面的Capture接口



  40.     return;

  42. }

复制代码
  1. C++
  2. RetCode StreamBase::Capture(const std::shared_ptr<CaptureRequest>& request)

  4. {

  6.     CHECK_IF_PTR_NULL_RETURN_VALUE(request, RC_ERROR);

  8.     CHECK_IF_PTR_NULL_RETURN_VALUE(pipeline_, RC_ERROR);



  12.     RetCode rc = RC_ERROR;

  14.     if (request->IsFirstOne() && !request->IsContinous()) {

  16.         uint32_t n = GetBufferCount();

  18.         for (uint32_t i = 0; i < n; i++) {

  20.             DeliverBuffer();// 单次捕获一次性下发所有的buffer

  22.         }

  24.     } else {

  26.         do {

  28.             rc = DeliverBuffer();// 连续捕获每次下发一个buffer

  30.         } while (rc != RC_OK && state_ == STREAM_STATE_BUSY);

  32.     }



  36.     if (request->NeedCancel()) {// 被取消的捕获则退出

  38.         CAMERA_LOGE("StreamBase::Capture stream [id:%{public}d] request->NeedCancel", streamId_);

  40.         return RC_OK;

  42.     }



  46.     rc = pipeline_->Config({streamId_}, request->GetCaptureSetting());// 通知pipeline配置

  48.     if (rc != RC_OK) {

  50.         CAMERA_LOGE("stream [id:%{public}d] config pipeline failed.", streamId_);

  52.         return RC_ERROR;

  54.     }



  58.     rc = pipeline_->Capture({streamId_}, request->GetCaptureId());//  这里的capture指的是pipeline中的source node开始回buffer



  62.     {

  64.         std::unique_lock<std::mutex> l(tsLock_);

  66.         inTransitList_.emplace_back(request);// 处理过的捕获请求存放在inTransitList

  68.     }



  72.     return RC_OK;

  74. }

复制代码
到这起流的流程就结束了，pipeline回上来的帧通过OnFrame接口处理
  1. C++
  2. RetCode StreamBase::OnFrame(const std::shared_ptr<CaptureRequest>& request)

  4. {

  6. // ...



  10.     bool isEnded = false;

  12.     if (!request->IsContinous()) {

  14.         isEnded = true;

  16.     } else if (request->NeedCancel()) {

  18.         isEnded = true;

  20.     }



  24.     {

  26.         // inTransitList_ may has multiple copies of continious-capture request, we just need erase one of them.

  28.         std::unique_lock<std::mutex> l(tsLock_);

  30.         for (auto it = inTransitList_.begin(); it != inTransitList_.end(); it++) {

  32.             if ((*it) == request) {

  34.                 inTransitList_.erase(it);// 已经回帧的请求，从inTransitList删除

  36.                 break;

  38.             }

  40.         }



  44.         if (isEnded) {

  46.             // if this is the last request of capture, send CaptureEndedMessage.

  48.             auto it = std::find(inTransitList_.begin(), inTransitList_.end(), request);

  50.             if (it == inTransitList_.end()) {

  52.                 std::shared_ptr<ICaptureMessage> endMessage =

  54.                     std::make_shared<CaptureEndedMessage>(streamId_, request->GetCaptureId(), request->GetEndTime(),

  56.                                                           request->GetOwnerCount(), tunnel_->GetFrameCount());

  58.                 CAMERA_LOGV("end of stream [%d], ready to send end message, capture id = %d",

  60.                     streamId_, request->GetCaptureId());

  62.                 messenger_->SendMessage(endMessage);

  64.                 pipeline_->CancelCapture({streamId_});// 如果此次捕获结束，则取消捕获

  66.             }

  68.         }

  70.     }
  71.     ReceiveBuffer(buffer);// 底层返回的buffer送还到生产端，最终帧数据送到消费端

  73.     return RC_OK;

  75. }

复制代码
附录

  • linux和Android的关系 - 知乎 (zhihu.com) ↩︎
  • HAL Subsystem | Android Open Source Project (google.cn) ↩︎
  • zh-cn/release-notes/OpenHarmony-v3.1-release.md · OpenHarmony/docs - Gitee.com ↩︎
  • OpenHarmony HDF 驱动框架介绍和驱动加载过程分析-OpenHarmony技术社区-↩︎
  • OpenHarmony HDF HDI基础能力分析与使用- ↩︎


举报

回帖

声明：本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人，不代表电子发烧友网立场。文章及其配图仅供工程师学习之用，如有内容图片侵权或者其他问题，请联系本站作侵删。 侵权投诉
链接复制成功，分享给好友