OpenHarmony视频录制流程介绍

媒体子系统为开发者提供了媒体相关的很多功能，本文针对其中的视频录制功能做个详细的介绍。

首先，我将通过媒体子系统提供的视频录制 Test 代码作为切入点，给大家梳理一下整个录制的流程。

目录

foundation/multimedia/camera_framework

├──frameworks
│├──js
││└──camera_napi#napi实现
││└──src
││├──input#Camera输入
││├──output#Camera输出
││└──session#会话管理
│└──native#native实现
│└──camera
│├──BUILD.gn
│├──src
││├──input#Camera输入
││├──output#Camera输出
││└──session#会话管理
├──interfaces#接口定义
│├──inner_api#内部native实现
││└──native
││├──camera
│││└──include
│││├──input
│││├──output
│││└──session
│└──kits#napi接口
│└──js
│└──camera_napi
│├──BUILD.gn
│├──include
││├──input
││├──output
││└──session
│└──@ohos.multimedia.camera.d.ts
└──services#服务端
└──camera_service
├──binder
│├──base
│├──client#IPC的客户端
││└──src
│└──server#IPC的服务端
│└──src
└──src

录制的总体流程

如下图：

Native接口使用

在 OpenHarmony 系统中，多媒体子系统通过 N-API 接口提供给上层 JS 调用，N-API 相当于是 JS 和 Native 之间的桥梁。 在 OpenHarmony 源码中，提供了 C++ 直接调用视频录制功能的例子，foundation/multimedia/camera_framework/interfaces/inner_api/native/test 目录中。

本文章主要参考了 camera_video.cpp 文件中的视频录制流程。

首先根据 camera_video.cpp 的 main 方法，了解下视频录制的主要流程代码：

intmain(intargc,char**argv)
{
......

//创建CameraManager实例
sptrcamManagerObj=CameraManager::GetInstance();

//设置回调
camManagerObj->SetCallback(std::make_shared(testName));

//获取支持的相机设备列表
std::vector>cameraObjList=camManagerObj->GetSupportedCameras();

//创建采集会话
sptrcaptureSession=camManagerObj->CreateCaptureSession();

//开始配置采集会话
captureSession->BeginConfig();

//创建CameraInput
sptrcaptureInput=camManagerObj->CreateCameraInput(cameraObjList[0]);
sptrcameraInput=(sptr&)captureInput;

//开启CameraInput
cameraInput->Open();

//设置CameraInput的Error回调
cameraInput->SetErrorCallback(std::make_shared(testName));

//添加CameraInput实例到采集会话中
ret=captureSession->AddInput(cameraInput);

sptrvideoSurface=nullptr;
std::shared_ptrrecorder=nullptr;

//创建Video的Surface
videoSurface=Surface::CreateSurfaceAsConsumer();

sptrvideoListener=newSurfaceListener("Video",SurfaceType::VIDEO,g_videoFd,videoSurface);

//注册Surface的事件监听
videoSurface->RegisterConsumerListener((sptr&)videoListener);

//视频的配置
VideoProfilevideoprofile=VideoProfile(static_cast(videoFormat),videosize,videoframerates);

//创建VideoOutput实例
sptrvideoOutput=camManagerObj->CreateVideoOutput(videoprofile,videoSurface);

//设置VideoOutput的回调
((sptr&)videoOutput)->SetCallback(std::make_shared(testName));

//添加videoOutput到采集会话中
ret=captureSession->AddOutput(videoOutput);

//提交会话配置
ret=captureSession->CommitConfig();

//开始录制
ret=((sptr&)videoOutput)->Start();


sleep(videoPauseDuration);
MEDIA_DEBUG_LOG("Resumevideorecording");
//暂停录制
ret=((sptr&)videoOutput)->Resume();

MEDIA_DEBUG_LOG("Waitfor5secondsbeforestop");
sleep(videoCaptureDuration);
MEDIA_DEBUG_LOG("Stopvideorecording");
//停止录制
ret=((sptr&)videoOutput)->Stop();

MEDIA_DEBUG_LOG("Closingthesession");
//停止采集会话
ret=captureSession->Stop();

MEDIA_DEBUG_LOG("Releasingthesession");
//释放会话采集
captureSession->Release();

//Closevideofile
TestUtils::SaveVideoFile(nullptr,0,VideoSaveMode::CLOSE,g_videoFd);
cameraInput->Release();
camManagerObj->SetCallback(nullptr);
return0;
}

以上是视频录制的整体流程，其过程主要通过 Camera 模块支持的能力来实现，其中涉及几个重要的类：CaptureSession、CameraInput、VideoOutput。

CaptureSession 是整个过程的控制者，CameraInput 和 VideoOutput 相当于是设备的输入和输出。

调用流程

如下图：

后续主要针对上面的调用流程，梳理具体的调用流程，方便我们对了解视频录制的整理架构有一个更加深入的了解。

①创建 CameraManager 实例

通过 CameraManager::GetInstance() 获取 CameraManager 的实例，后续的一些接口都是通过该实例进行调用的。

GetInstance 使用了单例模式，在 OpenHarmony 代码中这种方式很常见。

sptr&CameraManager::GetInstance()
{
if(CameraManager::cameraManager_==nullptr){
MEDIA_INFO_LOG("Initializingcameramanagerforfirsttime!");
CameraManager::cameraManager_=new(std::nothrow)CameraManager();
if(CameraManager::cameraManager_==nullptr){
MEDIA_ERR_LOG("CameraManager::GetInstancefailedtonewCameraManager");
}
}
returnCameraManager::cameraManager_;
}

②获取支持的相机设备列表

通过调用 CameraManager 的 GetSupportedCameras() 接口，获取设备支持的 CameraDevice 列表。

跟踪代码可以发现 serviceProxy_->GetCameras 最终会调用到 Camera 服务端的对应接口。

std::vector>CameraManager::GetSupportedCameras()
{
CAMERA_SYNC_TRACE;

std::lock_guardlock(mutex_);
std::vectorcameraIds;
std::vector>cameraAbilityList;
int32_tretCode=-1;
sptrcameraObj=nullptr;
int32_tindex=0;

if(cameraObjList.size()>0){
cameraObjList.clear();
}
if(serviceProxy_==nullptr){
MEDIA_ERR_LOG("CameraManager::GetCamerasserviceProxy_isnull,returningemptylist!");
returncameraObjList;
}
std::vector>supportedCameras;
retCode=serviceProxy_->GetCameras(cameraIds,cameraAbilityList);
if(retCode==CAMERA_OK){
for(auto&it:cameraIds){
cameraObj=new(std::nothrow)CameraDevice(it,cameraAbilityList[index++]);
if(cameraObj==nullptr){
MEDIA_ERR_LOG("CameraManager::GetCamerasnewCameraDevicefailedforid={public}%s",it.c_str());
continue;
}
supportedCameras.emplace_back(cameraObj);
}
}else{
MEDIA_ERR_LOG("CameraManager::GetCamerasfailed!,retCode:%{public}d",retCode);
}

ChooseDeFaultCameras(supportedCameras);
returncameraObjList;
}

③创建采集会话

下面是比较重要的环节，通过调用 CameraManager 的 CreateCaptureSession 接口创建采集会话。 CameraManager 创建采集会话，是通过 serviceProxy_->CreateCaptureSession 方式进行调用。

这里涉及到了 OpenHarmony 中的 IPC 的调用，serviceProxy_ 是远端服务在本地的代理，通过这个代理可以调用到具体的服务端，这里是 HCameraService。

sptrCameraManager::CreateCaptureSession()
{
CAMERA_SYNC_TRACE;
sptrcaptureSession=nullptr;
sptrresult=nullptr;
int32_tretCode=CAMERA_OK;

if(serviceProxy_==nullptr){
MEDIA_ERR_LOG("CameraManager::CreateCaptureSessionserviceProxy_isnull");
returnnullptr;
}
retCode=serviceProxy_->CreateCaptureSession(captureSession);
if(retCode==CAMERA_OK&&captureSession!=nullptr){
result=new(std::nothrow)CaptureSession(captureSession);
if(result==nullptr){
MEDIA_ERR_LOG("FailedtonewCaptureSession");
}
}else{
MEDIA_ERR_LOG("Failedtogetcapturesessionobjectfromhcameraservice!,%{public}d",retCode);
}
returnresult;
}

代码最终来到 HCameraService::CreateCaptureSession 中，该方法中 new 了一个 HCaptureSession 对象，并且将该对象传递给了参数 session。

所以前面的 captureSession 对象就是这里 new 出来的 HCaptureSession，前面的 CameraManager 的 CreateCaptureSession() 方法中将 captureSession 封装成 CaptureSession 对象返回给应用层使用。

int32_tHCameraService::CreateCaptureSession(sptr&session)
{
CAMERA_SYNC_TRACE;
sptrcaptureSession;
if(streamOperatorCallback_==nullptr){
streamOperatorCallback_=new(std::nothrow)StreamOperatorCallback();
if(streamOperatorCallback_==nullptr){
MEDIA_ERR_LOG("HCameraService::CreateCaptureSessionstreamOperatorCallback_allocationfailed");
returnCAMERA_ALLOC_ERROR;
}
}

std::lock_guardlock(mutex_);
OHOS::AccessTokenIDcallerToken=IPCSkeleton::GetCallingTokenID();
captureSession=new(std::nothrow)HCaptureSession(cameraHostManager_,streamOperatorCallback_,callerToken);
if(captureSession==nullptr){
MEDIA_ERR_LOG("HCameraService::CreateCaptureSessionHCaptureSessionallocationfailed");
returnCAMERA_ALLOC_ERROR;
}
session=captureSession;
returnCAMERA_OK;
}

④开始配置采集会话

调用 CaptureSession 的 BeginConfig 进行采集会话的配置工作。这个工作最终调用到被封装的 HCaptureSession 中。

int32_tHCaptureSession::BeginConfig()
{
CAMERA_SYNC_TRACE;
if(curState_==CaptureSessionState::SESSION_CONFIG_INPROGRESS){
MEDIA_ERR_LOG("HCaptureSession::BeginConfigAlreadyinconfiginprogressstate!");
returnCAMERA_INVALID_STATE;
}
std::lock_guardlock(sessionLock_);
prevState_=curState_;
curState_=CaptureSessionState::SESSION_CONFIG_INPROGRESS;
tempCameraDevices_.clear();
tempStreams_.clear();
deletedStreamIds_.clear();
returnCAMERA_OK;
}

⑤创建 CameraInput

应用层通过 camManagerObj->CreateCameraInput(cameraObjList[0]) 的方式进行 CameraInput 的创建，cameraObjList[0] 就是前面获取支持设备的第一个。根据 CameraDevice 创建对应的 CameraInput 对象。

sptrCameraManager::CreateCameraInput(sptr&camera)
{
CAMERA_SYNC_TRACE;
sptrcameraInput=nullptr;
sptrdeviceObj=nullptr;

if(camera!=nullptr){
deviceObj=CreateCameraDevice(camera->GetID());
if(deviceObj!=nullptr){
cameraInput=new(std::nothrow)CameraInput(deviceObj,camera);
if(cameraInput==nullptr){
MEDIA_ERR_LOG("failedtonewCameraInputReturningnullinCreateCameraInput");
returncameraInput;
}
}else{
MEDIA_ERR_LOG("ReturningnullinCreateCameraInput");
}
}else{
MEDIA_ERR_LOG("CameraManager:Cameraobjectisnull");
}
returncameraInput;
}

⑥开启 CameraInput

调用了 CameraInput 的 Open 方法，进行输入设备的启动打开。

voidCameraInput::Open()
{
int32_tretCode=deviceObj_->Open();
if(retCode!=CAMERA_OK){
MEDIA_ERR_LOG("FailedtoopenCameraInput,retCode:%{public}d",retCode);
}
}

⑦添加 CameraInput 实例到采集会话中

通过调用 captureSession 的 AddInput 方法，将创建的 CameraInput 对象添加到采集会话的输入中，这样采集会话就知道采集输入的设备。

int32_tCaptureSession::AddInput(sptr&input)
{
CAMERA_SYNC_TRACE;
if(input==nullptr){
MEDIA_ERR_LOG("CaptureSession::AddInputinputisnull");
returnCAMERA_INVALID_ARG;
}
input->SetSession(this);
inputDevice_=input;
returncaptureSession_->AddInput(((sptr&)input)->GetCameraDevice());
}

最终调用到 HCaptureSession 的 AddInput 方法，该方法中核心的代码是 tempCameraDevices_.emplace_back(localCameraDevice)，将需要添加的 CameraDevice 插入到 tempCameraDevices_ 容器中。

int32_tHCaptureSession::AddInput(sptrcameraDevice)
{
CAMERA_SYNC_TRACE;
sptrlocalCameraDevice=nullptr;

if(cameraDevice==nullptr){
MEDIA_ERR_LOG("HCaptureSession::AddInputcameraDeviceisnull");
returnCAMERA_INVALID_ARG;
}
if(curState_!=CaptureSessionState::SESSION_CONFIG_INPROGRESS){
MEDIA_ERR_LOG("HCaptureSession::AddInputNeedtocallBeginConfigbeforeaddinginput");
returnCAMERA_INVALID_STATE;
}
if(!tempCameraDevices_.empty()||(cameraDevice_!=nullptr&&!cameraDevice_->IsReleaseCameraDevice())){
MEDIA_ERR_LOG("HCaptureSession::AddInputOnlyoneinputissupported");
returnCAMERA_INVALID_SESSION_CFG;
}
localCameraDevice=static_cast(cameraDevice.GetRefPtr());
if(cameraDevice_==localCameraDevice){
cameraDevice_->SetReleaseCameraDevice(false);
}else{
tempCameraDevices_.emplace_back(localCameraDevice);
CAMERA_SYSEVENT_STATISTIC(CreateMsg("CaptureSession::AddInput"));
}

sptrstreamOperator;
int32_trc=localCameraDevice->GetStreamOperator(streamOperatorCallback_,streamOperator);
if(rc!=CAMERA_OK){
MEDIA_ERR_LOG("HCaptureSession::GetCameraDeviceGetStreamOperatorreturned%{public}d",rc);
localCameraDevice->Close();
returnrc;
}
returnCAMERA_OK;
}

⑧创建 Video 的 Surface

通过 Surface::CreateSurfaceAsConsumer 创建 Surface。

sptrSurface::CreateSurfaceAsConsumer(std::stringname,boolisShared)
{
sptrsurf=newConsumerSurface(name,isShared);
GSErrorret=surf->Init();
if(ret!=GSERROR_OK){
BLOGE("Failure,Reason:consumersurfinitfailed");
returnnullptr;
}
returnsurf;
}

⑨创建 VideoOutput 实例

通过调用 CameraManager 的 CreateVideoOutput 来创建 VideoOutput 实例。

sptrCameraManager::CreateVideoOutput(VideoProfile&profile,sptr&surface)
{
CAMERA_SYNC_TRACE;
sptrstreamRepeat=nullptr;
sptrresult=nullptr;
int32_tretCode=CAMERA_OK;
camera_format_tmetaFormat;

metaFormat=GetCameraMetadataFormat(profile.GetCameraFormat());
retCode=serviceProxy_->CreateVideoOutput(surface->GetProducer(),metaFormat,
profile.GetSize().width,profile.GetSize().height,streamRepeat);
if(retCode==CAMERA_OK){
result=new(std::nothrow)VideoOutput(streamRepeat);
if(result==nullptr){
MEDIA_ERR_LOG("FailedtonewVideoOutput");
}else{
std::vectorvideoFrameRates=profile.GetFrameRates();
if(videoFrameRates.size()>=2){//vaildframeraterangelengthis2
result->SetFrameRateRange(videoFrameRates[0],videoFrameRates[1]);
}
POWERMGR_SYSEVENT_CAMERA_CONFIG(VIDEO,
profile.GetSize().width,
profile.GetSize().height);
}
}else{
MEDIA_ERR_LOG("VideoOutpout:Failedtogetstreamrepeatobjectfromhcameraservice!%{public}d",retCode);
}
returnresult;
}

该方法中通过 IPC 的调用最终调用到了 HCameraService 的：

CreateVideoOutput(surface->GetProducer(),format,streamRepeat)

int32_tHCameraService::CreateVideoOutput(constsptr&producer,int32_tformat,
int32_twidth,int32_theight,
sptr&videoOutput)
{
CAMERA_SYNC_TRACE;
sptrstreamRepeatVideo;

if((producer==nullptr)||(width==0)||(height==0)){
MEDIA_ERR_LOG("HCameraService::CreateVideoOutputproducerisnull");
returnCAMERA_INVALID_ARG;
}
streamRepeatVideo=new(std::nothrow)HStreamRepeat(producer,format,width,height,true);
if(streamRepeatVideo==nullptr){
MEDIA_ERR_LOG("HCameraService::CreateVideoOutputHStreamRepeatallocationfailed");
returnCAMERA_ALLOC_ERROR;
}
POWERMGR_SYSEVENT_CAMERA_CONFIG(VIDEO,producer->GetDefaultWidth(),
producer->GetDefaultHeight());
videoOutput=streamRepeatVideo;
returnCAMERA_OK;
}

HCameraService 的 CreateVideoOutput 方法中主要创建了 HStreamRepeat，并且通过参数传递给前面的 CameraManager 使用，CameraManager 通过传递的 HStreamRepeat 对象，进行封装，创建出 VideoOutput 对象。

⑩添加 videoOutput 到采集会话中，并且提交采集会话 该步骤类似添加 CameraInput 到采集会话的过程，可以参考前面的流程。 ⑪开始录制

通过调用 VideoOutput 的 Start 进行录制的操作。

int32_tVideoOutput::Start()
{
returnstatic_cast(GetStream().GetRefPtr())->Start();
}

该方法中会调用到 HStreamRepeat 的 Start 方法。

int32_tHStreamRepeat::Start()
{
CAMERA_SYNC_TRACE;

if(streamOperator_==nullptr){
returnCAMERA_INVALID_STATE;
}
if(curCaptureID_!=0){
MEDIA_ERR_LOG("HStreamRepeat::Start,AlreadystartedwithcaptureID:%{public}d",curCaptureID_);
returnCAMERA_INVALID_STATE;
}
int32_tret=AllocateCaptureId(curCaptureID_);
if(ret!=CAMERA_OK){
MEDIA_ERR_LOG("HStreamRepeat::StartFailedtoallocateacaptureId");
returnret;
}
std::vectorability;
OHOS::ConvertMetadataToVec(cameraAbility_,ability);
CaptureInfocaptureInfo;
captureInfo.streamIds_={streamId_};
captureInfo.captureSetting_=ability;
captureInfo.enableShutterCallback_=false;
MEDIA_INFO_LOG("HStreamRepeat::StartStartingwithcaptureID:%{public}d",curCaptureID_);
CamRetCoderc=(CamRetCode)(streamOperator_->Capture(curCaptureID_,captureInfo,true));
if(rc!=HDI::NO_ERROR){
ReleaseCaptureId(curCaptureID_);
curCaptureID_=0;
MEDIA_ERR_LOG("HStreamRepeat::StartFailedwitherrorCode:%{public}d",rc);
ret=HdiToServiceError(rc);
}
returnret;
}

核心的代码是 streamOperator_->Capture，其中最后一个参数 true，表示采集连续数据。 ⑫录制结束，保存录制文件

总结

本文主要对 OpenHarmony 3.2 Beta 多媒体子系统的视频录制进行介绍，首先梳理了整体的录制流程，然后对录制过程中的主要步骤进行了详细地分析。

视频录制主要分为以下几个步骤：

获取 CameraManager 实例。

创建采集会话 CaptureSession。

创建 CameraInput 实例，并且将输入设备添加到 CaptureSession 中。

创建 Video 录制需要的 Surface。

创建 VideoOutput 实例，并且将输出添加到 CaptureSession 中。

提交采集会话的配置。

调用 VideoOutput 的 Start 方法，进行视频的录制。

录制结束，保存录制的文件。

作者：巴延兴

审核编辑：汤梓红