鸿蒙 next 实现摄像头视频预览&编码（一）

鸿蒙 next 即将发布，让我们先喊3遍 遥遥领先~ 遥遥领先~ 遥遥领先~

作为一门新的系统，本人也是刚入门学习中，如果对于一些理解有问题的，欢迎即使指出哈

首先这里要讲一下，在鸿蒙 next 中，要实现摄像头预览&编码有两种方式。第一种，通过摄像头的预览流&录制流来实现，其中预览很简单，直接使用 xcomponent 即可，对于编码，则可以通过创建编码器获取到的 surfaceid 传递给录制流即可。第二种是通过 nativeimage 类似于 android 的 surfacetexture 然后将纹理通过 opengl 绘制到预览 surface 和编码 surface 上去，这边文章主要将第一种简单的方式，步骤大致如下：

第一步，创建 xcomponaent，代码如下：

  1.  XComponent({
  2.           id: '',
  3.           type: XComponentType.SURFACE,
  4.           libraryname: '',
  5.           controller: this.XcomponentController
  6.         })
  7.           .onLoad(() => {
  8.             this.XcomponentController.setXComponentSurfaceSize({
  9.               surfaceWidth: this.cameraWidth, surfaceHeight: this.cameraHeight
  10.             })
  11.             this.XcomponentSurfaceId = this.XcomponentController.getXComponentSurfaceId()
  12.           })

创建 xcomponeant 的关键是获取 surfaceid，这个后面会用来传给摄像头预览流用的。

第二步，获取编码器的 surfaceid，由于目前鸿蒙没有为编码器这块提供 arkts 接口，所以需要用到 napi 作为中间桥接，通过 arkts 来调用 c++ 代码，大致代码如下：

arkts 部分：

  1. import recorder from 'librecorder.so'
  2. recorder.initNative()

librecorder.so 为工程中 c++ 的部分，具体可以参考项目模板中关于 c++ 的示例

napi 部分：

  1. #include "RecorderNative.h"
  2. #include 
  3.  
  4. #undef LOG_DOMAIN
  5. #undef LOG_TAG
  6. #define LOG_DOMAIN 0xFF00
  7. #define LOG_TAG "recorder"
  8.  
  9. struct AsyncCallbackInfo {
  10.     napi_env env;
  11.     napi_async_work asyncWork;
  12.     napi_deferred deferred;
  13.     int32_t resultCode = 0;
  14.     std::string surfaceId = "";
  15.     SampleInfo sampleInfo;
  16. };
  17.  
  18. void DealCallBack(napi_env env, void *data)
  19. {
  20.     AsyncCallbackInfo *asyncCallbackInfo = static_cast(data);
  21.     napi_value code;
  22.     napi_create_int32(env, asyncCallbackInfo->resultCode, &code);
  23.     napi_value surfaceId;
  24.     napi_create_string_utf8(env, asyncCallbackInfo->surfaceId.data(), NAPI_AUTO_LENGTH, &surfaceId);
  25.     napi_value obj;
  26.     napi_create_object(env, &obj);
  27.  
  28.     napi_set_named_property(env, obj, "code", code);
  29.     napi_set_named_property(env, obj, "surfaceId", surfaceId);
  30.     napi_resolve_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred, obj);
  31.     napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
  32.     delete asyncCallbackInfo;
  33. }
  34.  
  35. void SetCallBackResult(AsyncCallbackInfo *asyncCallbackInfo, int32_t code)
  36. {
  37.     asyncCallbackInfo->resultCode = code;
  38. }
  39.  
  40. void SurfaceIdCallBack(AsyncCallbackInfo *asyncCallbackInfo, std::string surfaceId)
  41. {
  42.     asyncCallbackInfo->surfaceId = surfaceId;
  43. }
  44.  
  45. void NativeInit(napi_env env, void *data)
  46. {
  47.     AsyncCallbackInfo *asyncCallbackInfo = static_cast(data);
  48.     int32_t ret = Recorder::GetInstance().Init(asyncCallbackInfo->sampleInfo);
  49.     if (ret != AVCODEC_SAMPLE_ERR_OK) {
  50.         SetCallBackResult(asyncCallbackInfo, -1);
  51.     }
  52.  
  53.     uint64_t id = 0;
  54.     ret = OH_NativeWindow_GetSurfaceId(asyncCallbackInfo->sampleInfo.window, &id);
  55.     if (ret != AVCODEC_SAMPLE_ERR_OK) {
  56.         SetCallBackResult(asyncCallbackInfo, -1);
  57.     }
  58.     asyncCallbackInfo->surfaceId = std::to_string(id);
  59.     SurfaceIdCallBack(asyncCallbackInfo, asyncCallbackInfo->surfaceId);
  60. }
  61.  
  62. napi_value RecorderNative::Init(napi_env env, napi_callback_info info)
  63. {
  64.  
  65.     SampleInfo sampleInfo;
  66.  
  67.     napi_value promise;
  68.     napi_deferred deferred;
  69.     napi_create_promise(env, &deferred, &promise);
  70.  
  71.     AsyncCallbackInfo *asyncCallbackInfo = new AsyncCallbackInfo();
  72.  
  73.     asyncCallbackInfo->env = env;
  74.     asyncCallbackInfo->asyncWork = nullptr;
  75.     asyncCallbackInfo->deferred = deferred;
  76.     asyncCallbackInfo->resultCode = -1;
  77.     asyncCallbackInfo->sampleInfo = sampleInfo;
  78.     
  79.     napi_value resourceName;
  80.     napi_create_string_latin1(env, "recorder", NAPI_AUTO_LENGTH, &resourceName);
  81.     napi_create_async_work(
  82.         env, nullptr, resourceName, [](napi_env env, void *data) { NativeInit(env, data); },
  83.         [](napi_env env, napi_status status, void *data) { DealCallBack(env, data); }, (void *)asyncCallbackInfo,
  84.         &asyncCallbackInfo->asyncWork);
  85.     napi_queue_async_work(env, asyncCallbackInfo->asyncWork);
  86.     return promise;
  87. }
  88.  
  89. EXTERN_C_START
  90. static napi_value Init(napi_env env, napi_value exports)
  91. {
  92.     napi_property_descriptor classProp[] = {
  93.         {"initNative", nullptr, RecorderNative::Init, nullptr, nullptr, nullptr, napi_default, nullptr}
  94.     };
  95.  
  96.     return exports;
  97. }
  98. EXTERN_C_END
  99.  
  100. static napi_module RecorderModule = {
  101.     .nm_version = 1,
  102.     .nm_flags = 0,
  103.     .nm_filename = nullptr,
  104.     .nm_register_func = Init,
  105.     .nm_modname = "recorder",
  106.     .nm_priv = ((void *)0),
  107.     .reserved = {0},
  108. };
  109.  
  110.  
  111. extern "C" __attribute__((constructor)) void RegisterRecorderModule(void) { napi_module_register(&RecorderModule); }

鸿蒙这边的 napi 其实是参考的 nodejs 的，语法基本一致，这里的大致逻辑就是调用 Recorder::GetInstance().Init() 获取编码器的 surfaceid 然后通过 ts 的 promise 传递给前端

c++ 编码器部分：

  1. int32_t Recorder::Init(SampleInfo &sampleInfo)
  2. {
  3.     std::lock_guard lock(mutex_);
  4.  
  5.     sampleInfo_ = sampleInfo;
  6.  
  7.     videoEncoder_ = std::make_unique();
  8.     muxer_ = std::make_unique();
  9.     
  10.     videoEncoder_->Create(sampleInfo_.videoCodecMime);
  11.     ret = muxer_->Create(sampleInfo_.outputFd);
  12.     encContext_ = new CodecUserData;
  13.     videoEncoder_->Config(sampleInfo_, encContext_);
  14.     muxer_->Config(sampleInfo_);
  15.     sampleInfo.window = sampleInfo_.window;
  16.     releaseThread_ = nullptr;
  17.     return AVCODEC_SAMPLE_ERR_OK;
  18. }

其中核心的在于 videoEncoder_->Config()，这一步会将 nativewindow 赋值给 sampleInfo 结构体，然后就可以获取到nativewindow 的 surfaceid了

代码如下：

  1. int32_t VideoEncoder::Config(SampleInfo &sampleInfo, CodecUserData *codecUserData)
  2. {
  3.     Configure(sampleInfo);
  4.     OH_VideoEncoder_GetSurface(encoder_, &sampleInfo.window);
  5.     SetCallback(codecUserData);
  6.     OH_VideoEncoder_Prepare(encoder_)；
  7.     return AVCODEC_SAMPLE_ERR_OK;
  8. }

到此为止，xcomponents 的 surfaceid 和编码器的 surtfaceid 都获取到了，接着就是在 arkts 层创建摄像头，并设置预览&编码输出了，这块比较简单，照着文档来就行，代码如下：

  1. let cameraManager = camera.getCameraManager(globalThis.context)
  2. let camerasDevices: ArrayCameraDevice> = getCameraDevices(cameraManager)
  3. let profiles: camera.CameraOutputCapability = cameraManager.getSupportedOutputCapability(camerasDevices[0],
  4.       camera.SceneMode.NORMAL_VIDEO)
  5.  
  6. // 获取预览流profile
  7.     let previewProfiles: ArrayProfile> = profiles.previewProfiles
  8.  
  9. // 获取录像流profile
  10.     let videoProfiles: ArrayVideoProfile> = profiles.videoProfiles
  11.  
  12. // Xcomponent预览流
  13.     let XComponentPreviewProfile: camera.Profile = previewProfiles[0]
  14.  
  15. // 创建 编码器 输出对象
  16.     encoderVideoOutput = cameraManager.createVideoOutput(videoProfile, encoderSurfaceId)
  17.  
  18. // 创建 预览流 输出对象
  19.     XcomponentPreviewOutput = cameraManager.createPreviewOutput(XComponentPreviewProfile, this.XcomponentSurfaceId)
  20.  
  21. // 创建cameraInput对象
  22.     cameraInput = cameraManager.createCameraInput(camerasDevices[0])
  23.  
  24. // 打开相机
  25.     await cameraInput.open()
  26.  
  27. // 会话流程
  28.     videoSession = cameraManager.createSession(camera.SceneMode.NORMAL_VIDEO) as camera.VideoSession
  29.  
  30. // 开始配置会话
  31.     videoSession.beginConfig()
  32.  
  33. // 把CameraInput加入到会话
  34.     videoSession.addInput(cameraInput)
  35.  
  36. // 把 Xcomponent 预览流加入到会话
  37.     videoSession.addOutput(XcomponentPreviewOutput)
  38.  
  39. // 把编码器录像流加入到会话
  40.     videoSession.addOutput(encoderVideoOutput)
  41.  
  42. // 提交配置信息
  43.     await videoSession.commitConfig()
  44.  
  45. // 会话开始
  46.     await videoSession.start()

至此，关于预览&编码的大致流程就是这样了，整体流程其实还是很简单的，核心就是获取两个 surfaceid，然后传入到摄像头录制&预览流中即可。这里就大致讲一下思路，相信做安卓或者前端的同学都能看明白。不过这种模式的一个缺点在于无法做一些深层次的操作，例如水印、美白、瘦脸等，优点在于代码量比较少。第二篇要将的是关于如何通过 opengl 来绘制预览 & 编码 surface，未完待续~

 

 

注：本文转载自blog.csdn.net的yydounai的文章"https://blog.csdn.net/weixin_38189842/article/details/141402357"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！