【鸿蒙南向开发】OpenHarmony实战之视频编解码HDI的使用

已于 2024-08-06 20:59:54 修改
阅读量901 收藏 10
点赞数 14
分类专栏： 安卓 鸿蒙 前端 文章标签： harmonyos 视频编解码 华为 android ui 前端
于 2024-08-06 20:49:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HarmonyOS_666/article/details/140965932
版权
鸿蒙 同时被 3 个专栏收录
205 篇文章 1 订阅
订阅专栏
前端
205 篇文章 0 订阅
订阅专栏
安卓
204 篇文章 0 订阅
订阅专栏

简介

Codec HDI 提供了基于OpenMax(简称OMX)的一整套编解码接口，程序通过简单的几步，即可实现基于OMX的硬件编解码。本文主要介绍基于Codec HDI 开发的编解码功能，包括初始化，Buffer流转以及释放等。

CODEC HDI框架介绍

image.png

Codec HDI Interface （简称HDI）提供基于OpenMax 的标准接口，Media Service 调用这套接口实现硬件编解码能力。HDI 另外提供了实现Callback 机制的接口，Media Service 可以通过HDI 接口创建Callback 信息接收服务端（Codec HDI Callback Remote Service），并且通过SetCallback 方法将对应的客户端代理（Codec HDI Callback Client Proxy）传给OpenMax 实现层，OpenMax 在数据Buffer 处理过程中会通过此代理调用回调方法，告知Media Service 进行对应的数据处理。

目录

./drivers/peripheral/codec
|-- hal									#HDI框架代码目录
|   |-- include							
|   |-- src
|-- hdi_service						    #原HDI框架代码目录
|   |-- codec_proxy
|   |-- codec_service_stub
|   |-- codec_test
|-- interfaces							#codec接口头文件
|   |-- include
|-- test								#unittest 和Demo目录

Codec HDI编解码实例

组件状态流转

image.png

1.通过调用CreateComponent函数，可以打开组件，并让组件进入OMX_StateLoaded 或OMX_StateWaitForResources 状态；
2.通过调用DestoryComponent函数，可以销毁处于OMX_StateLoaded状态的组件实例；
3.其它的状态变化，可以通过SendCommand(OMX_CommandStateSet, <OMX_STATETYPE>)使组件进入相应的状态。

状态

描述

OMX_StateInvalid

组件已损坏或者发生一个不能恢复的错误

OMX_StateLoaded

组件已经加载，但是资源未申请

OMX_StateIdle

组件已经申请到所有资源，但不会轮转任何buffer

OMX_StateExecuting

组件正在处理有效的数据

OMX_StatePause

组件暂停处理数据，可以通过设置组件状态唤醒重新处理数据

OMX_StateWaitForResources

组件正在等待所需要的

编解码流程简介

image.png

主要包含以下几步：

  1. 接口及回调初始化
  2. 组件初始化
  3. 设置编解码参数
  4. 申请输入输出Buffer
  5. 编解码
  6. 组件回调处理
  7. 组件释放

codec HDI编解码主要流程如上图显示，下面我们以解码流程来讲解。

接口及回调初始化

本步骤主要初始化了使用HDI接口必须使用的结构及初始化对应的回调函数。

//初始化HDI ComponentManager实例,用于打开OMX组件
omxMgr_ = GetCodecComponentManager();

//初始化回调
callback_ = CodecCallbackTypeStubGetInstance();
if (!omxMgr_ || !callback_) {
    FUNC_EXIT_ERR();
    return false;
}
//设置回调函数指针
callback_->EventHandler    = &OMXCore::OnEvent;
callback_->EmptyBufferDone = &OMXCore::OnEmptyBufferDone;
callback_->FillBufferDone  = &OMXCore::OnFillBufferDone;

组件初始化

组件初始化包含打开对应的编解码组件并获取组件的版本，后续会使用到该版本参数。

//新建组件实例，组件实例为 client_ 后续接口中需要使用 client_
auto err = omxMgr_->CreateComponent(&client_, "OMX.rk.video_decoder.avc", 0, 0, callback_);
if (err != HDF_SUCCESS) {
    HDF_LOGE("failed to CreateComponent");
    FUNC_EXIT_ERR();
    return false;
}
//获取组件版本号
char                  name[MAX_LEN] = {0};
union OMX_VERSIONTYPE omxVer;
union OMX_VERSIONTYPE omxVerspec;
uint8_t               uuid[MAX_LEN] = {0};
uint32_t              uuidLen   = MAX_LEN; // MAX_LEN = 128
err = client_->GetComponentVersion(client_, name, &omxVer, &omxVerspec, uuid, uuidLen);
if (err != HDF_SUCCESS) {
    HDF_LOGE("failed to CreateComponent");
    FUNC_EXIT_ERR();
    return false;
}

设置编解码参数

设置参数时会使用上一步获取到的版本信息，注意填写。

1.设置输入的宽和高

OMX_PARAM_PORTDEFINITIONTYPE param;
InitParam(param);
param.nPortIndex = (uint32_t)PortIndex::kPortIndexInput;
auto err         = client_->GetParameter(client_, OMX_IndexParamPortDefinition, (int8_t *)&param, sizeof(param));
if (err != HDF_SUCCESS) {
    HDF_LOGE("failed to GetParameter with PortIndex::kPortIndexInput, index is "
             "OMX_IndexParamPortDefinition");

    return false;
}
HDF_LOGI("PortIndex::kPortIndexInput: eCompressionFormat = %{public}d, "
         "eColorFormat=%{public}d",
         param.format.video.eCompressionFormat, param.format.video.eColorFormat);
param.format.video.nFrameWidth  = width_;
param.format.video.nFrameHeight = height_;
param.format.video.nStride      = width_;
param.format.video.nSliceHeight = height_;
err = client_->SetParameter(client_, OMX_IndexParamPortDefinition, (int8_t *)&param, sizeof(param));
if (err != HDF_SUCCESS) {
    HDF_LOGE("failed to SetParameter with PortIndex::kPortIndexInput, index is "
             "OMX_IndexParamPortDefinition");

    return false;
}

2.设置输出视频的宽和高以及格式

InitParam(param);
param.nPortIndex = (uint32_t)PortIndex::kPortIndexOutput;
err              = client_->GetParameter(client_, OMX_IndexParamPortDefinition, (int8_t *)&param, sizeof(param));
if (err != HDF_SUCCESS) {
    HDF_LOGE("failed to GetParameter with PortIndex::kPortIndexOutput, index is "
             "OMX_IndexParamPortDefinition");

    return false;
}
HDF_LOGI("PortIndex::kPortIndexOutput eCompressionFormat = %{public}d, "
         "eColorFormat=%{public}d",
         param.format.video.eCompressionFormat, param.format.video.eColorFormat);
param.format.video.nFrameWidth  = width_;
param.format.video.nFrameHeight = height_;
param.format.video.nStride      = width_;
param.format.video.nSliceHeight = height_;
param.format.video.eColorFormat = AV_COLOR_FORMAT;  // 输出数据格式设置,YUV420SP
err = client_->SetParameter(client_, OMX_IndexParamPortDefinition, (int8_t *)&param, sizeof(param));
if (err != HDF_SUCCESS) {
    HDF_LOGE("failed to SetParameter with PortIndex::kPortIndexOutput, index is "
             "OMX_IndexParamPortDefinition");

    return false;
}

3.设置输入的格式和帧率

OMX_VIDEO_PARAM_PORTFORMATTYPE param;
InitParam(param);
param.nPortIndex = (uint32_t)PortIndex::kPortIndexInput;
auto err         = client_->GetParameter(client_, OMX_IndexParamVideoPortFormat, (int8_t *)&param, sizeof(param));
if (err != HDF_SUCCESS) {
    HDF_LOGE("failed to GetParameter with PortIndex::kPortIndexInput, index is "
             "OMX_IndexParamVideoPortFormat");
    return false;
}
HDF_LOGI("set Format PortIndex::kPortIndexInput eCompressionFormat = %{public}d, "
         "eColorFormat=%{public}d",
         param.eCompressionFormat, param.eColorFormat);
param.xFramerate         = FRAME;                // 30fps,Q16 format
param.eCompressionFormat = OMX_VIDEO_CodingAVC;  // H264
err = client_->SetParameter(client_, OMX_IndexParamVideoPortFormat, (int8_t *)&param, sizeof(param));
if (err != HDF_SUCCESS) {
    HDF_LOGE("failed to SetParameter with PortIndex::kPortIndexInput, index is "
             "OMX_IndexParamVideoPortFormat");

    return false;
}

申请输入输出Buffer

参数设置完成后，我们需要设置输入输出端口的Buffer，需要调用UseBuffer 方法，注意该方法只有在组件处于OMX_StateLoaded 或OMX_StateWaitForResources 或者端口处于Disabled 状态才能使用。实例代码中的portIndex可以是输入端口PortIndex::kPortIndexInput， 也可以是输出端口PortIndex::kPortIndexOutput，两个都需要设置。

1.获取端口需要的buffer大小和数量以及enable状态

OMX_PARAM_PORTDEFINITIONTYPE param;
InitParam(param);
param.nPortIndex = (OMX_U32)portIndex;
auto err         = client_->GetParameter(client_, OMX_IndexParamPortDefinition, (int8_t *)&param, sizeof(param));
if (err != HDF_SUCCESS) {
    HDF_LOGE("failed to GetParameter with OMX_IndexParamPortDefinition : "
             "portIndex[%{public}d]",
             portIndex);

    return false;
}

bufferSize  = param.nBufferSize;
bufferCount = param.nBufferCountActual;
bPortEnable = param.bEnabled;

2.初始化多个Buffer并调用UseBuffer方法，注意返回的bufferId，后续操作都可以用bufferId来标识OmxCodecBuffer

for (int i = 0; i < bufferCount; i++) {
	//初始化OmxCodecBuffer, 目前只支持共享内存的方式
    OmxCodecBuffer *omxBuffer = new OmxCodecBuffer();
    memset_s(omxBuffer, sizeof(OmxCodecBuffer), 0, sizeof(OmxCodecBuffer));
    omxBuffer->size                    = sizeof(OmxCodecBuffer);
    omxBuffer->version.s.nVersionMajor = 1;
    omxBuffer->bufferType              = BUFFER_TYPE_AVSHARE_MEM_FD;
    int                fd              = AshmemCreate(0, bufferSize);
    shared_ptr<Ashmem> spSharedMem     = make_shared<Ashmem>(fd, bufferSize);
    omxBuffer->bufferLen               = FD_SIZE;
    omxBuffer->buffer                  = (uint8_t *)(unsigned long)fd;
    omxBuffer->allocLen                = bufferSize;
    omxBuffer->fenceFd                 = -1;

    if (portIndex == PortIndex::kPortIndexInput) {
        omxBuffer->type = READ_ONLY_TYPE;  // 对输入端口，服务是只读的
        spSharedMem->MapReadAndWriteAshmem();
    } else {
        omxBuffer->type = READ_WRITE_TYPE; //对输出端口，服务是可写入的
        spSharedMem->MapReadOnlyAshmem();
    }
    auto err = client_->UseBuffer(client_, (uint32_t)portIndex, omxBuffer);
    if (err != HDF_SUCCESS) {
        HDF_LOGE("failed to UseBuffer with  portIndex[%{public}d]", portIndex);

        spSharedMem->UnmapAshmem();
        spSharedMem->CloseAshmem();
        spSharedMem = nullptr;
        return false;
    }

    omxBuffer->bufferLen = 0;
    HDF_LOGI("UseBuffer returned bufferID [%{public}d]", omxBuffer->bufferId);
	//保存omxBuffer 以及共享内存映射地址
    BufferInfo *bufferInfo  = new BufferInfo;
    bufferInfo->omxBuffer   = omxBuffer;
    bufferInfo->avSharedPtr = spSharedMem;
    bufferInfo->portIndex   = portIndex;
    omxBuffers_.insert(std::make_pair<int, BufferInfo *>(omxBuffer->bufferId, std::move(bufferInfo)));
    if (portIndex == PortIndex::kPortIndexInput) {
        unUsedInBuffers_.push_back(omxBuffer->bufferId);
    } else {
        unUsedOutBuffers_.push_back(omxBuffer->bufferId);
    }
    int fdret = (int)omxBuffer->buffer;
    HDF_LOGI("{bufferID = %{public}d, srcfd = %{public}d, retfd = %{public}d}", omxBuffer->bufferId, fd, fdret);
}

3.调用完UseBuffer之后，我们需要判断端口是否处于enable状态，如果是非使能状态，需要发送命令使端口处于使能状态

// set port enable
if (!bPortEnable) {
    auto err = client_->SendCommand(client_, OMX_CommandPortEnable, portIndex, NULL, 0);
    if (err != HDF_SUCCESS) {
        HDF_LOGE("SendCommand OMX_CommandPortEnable::kPortIndexInput error");
        FUNC_EXIT_ERR();
        return false;
    }
}

4.Buffer 设置完成后，需要使组件进入OMX_StateIdle状态

HDF_LOGI("...command to IDLE....");
auto err = client_->SendCommand(client_, OMX_CommandStateSet, OMX_StateIdle, NULL, 0);
if (err != HDF_SUCCESS) {
    HDF_LOGE("failed to SendCommand with OMX_CommandStateSet:OMX_StateIdle");
    FUNC_EXIT_ERR();
    return false;
}

HDF_LOGI("Wait for OMX_StateIdle status");
this->WaitForStatusChanged();

编解码

组件进入IDLE状态之后，我们要先让组件进入OMX_StateExecuting 状态，组件即可正常编解码了。
1.发送命令，使组件进入OMX_StateExecuting 状态

HDF_LOGI("...command to OMX_StateExecuting....");
err = client_->SendCommand(client_, OMX_CommandStateSet, OMX_StateExecuting, NULL, 0);
if (err != HDF_SUCCESS) {
    HDF_LOGE("failed to SendCommand with OMX_CommandStateSet:OMX_StateIdle");
    FUNC_EXIT_ERR();
    return false;
}

HDF_LOGI("Wait for OMX_StateExecuting status");
this->WaitForStatusChanged();

2.先将输出Buffer传给组件，让组件填充这些buffer

for (auto bufferId : unUsedOutBuffers_) {
    HDF_LOGI("fill bufferid [%{public}d]", bufferId);
    auto iter = omxBuffers_.find(bufferId);
    if (iter != omxBuffers_.end()) {
        BufferInfo *bufferInfo = iter->second;
        auto        err        = client_->FillThisBuffer(client_, bufferInfo->omxBuffer);
        if (err != HDF_SUCCESS) {
            HDF_LOGE("FillThisBuffer error");
            return;
        }
    }
}

3.读取H264 或 H265文件中的数据，让组件消费，这里请注意下，组件只支持已分帧的数据，我们读取文件时，需要按照start code(0x000001 或者 0x00000001)进行分帧

bool bEndOfFile = false;
while (!bEndOfFile) {
    HDF_LOGI(" inputput run");
    int bufferID = GetFreeBufferId();
    if (this->exit_) {
        break;
    }
    if (bufferID < 0) {
        usleep(10000);
        continue;
    }
    auto iter = omxBuffers_.find(bufferID);
    if (iter == omxBuffers_.end()) {
        continue;
    }
    BufferInfo *bufferInfo = iter->second;
    void       *sharedAddr = (void *)bufferInfo->avSharedPtr->ReadFromAshmem(0, 0);
    bool bEOS = (size_t)this->ReadOnePacket(fpIn_.get(), (char *)sharedAddr, bufferInfo->omxBuffer->filledLen);
    HDF_LOGI("read data size is %{public}d", bufferInfo->omxBuffer->filledLen);
    bufferInfo->omxBuffer->offset = 0;
    if (bEOS) {
        bufferInfo->omxBuffer->flag = OMX_BUFFERFLAG_EOS;
        bEndOfFile                  = true;
    }
    auto err = client_->EmptyThisBuffer(client_, bufferInfo->omxBuffer);
    if (err != HDF_SUCCESS) {
        HDF_LOGE("EmptyThisBuffer error");

        return;
    }
}

4.解码完成后，需要将组件设置为OMX_StateIdle 状态

// command to IDLE
client_->SendCommand(client_, OMX_CommandStateSet, OMX_StateIdle, NULL, 0);

组件回调处理

codec HDI 提供了3大回调，分别对应了omx组件的3个回调函数。
1.EventHandler， 包含状态变化，错误通知等等，具体参数含义请见下表格

eEvent

data1

data2

eventData

OMX_EventCmdComplete

OMX_CommandStateSet

OMX组件状态

NULL

OMX_CommandFlush

端口

NULL

OMX_CommandPortDisable

端口

NULL

OMX_CommandPortEnable

端口

NULL

OMX_CommandMarkBuffer

端口

NULL

OMX_EventError

Error Code

0

NULL

OMX_EventMark

0

0

make buffer

OMX_EventPortSettingsChanged

端口

0

NULL

OMX_EventBufferFlag

端口

nFlags

NULL

OMX_EventResourcesAcquired

0

0

NULL

OMX_EventDynamicResourcesAvailable

0

0

NULL

Demo 中逻辑处理比较简单，只是对OMX_EventCmdComplete 做了简单处理

int32_t CodecHdiDecode::OnEvent(struct CodecCallbackType *self, int8_t *pAppData, uint32_t pAppDataLen,
                            enum OMX_EVENTTYPE eEvent, uint32_t nData1, uint32_t nData2, int8_t *pEventData,
                            uint32_t pEventDataLen)
{
   	 HDF_LOGI("onEvent: pAppData[0x%{public}p], eEvent [%{public}d], "
             "nData1[%{public}d]",
             pAppData, eEvent, nData1);
    switch (eEvent) {
        case OMX_EventCmdComplete: {
            OMX_COMMANDTYPE cmd = (OMX_COMMANDTYPE)nData1;
            if (OMX_CommandStateSet == cmd) {
                HDF_LOGI("OMX_CommandStateSet reached, status is %{public}d", nData2);
                g_core->onStatusChanged();
            }
            break;
        }

        default:
            break;
    }
    return HDF_SUCCESS;
}

2.EmptyBufferDone， 输入buffer处理完毕通知
接收到此通知后，根据bufferId找到具体被消耗的OmxCodecBuffer，然后可以继续将待解码数据写入该buffer,通过调用EmptyThisBuffer将buffer传递给组件处理其数据。

//回调处理函数
int32_t CodecHdiDecode::OnEmptyBufferDone(struct CodecCallbackType *self, int8_t *pAppData, uint32_t pAppDataLen,
                                      const struct OmxCodecBuffer *buffer)
{
    HDF_LOGI("onEmptyBufferDone: pBuffer.bufferID [%{public}d]", pBuffer->bufferId);
    g_core->OnEmptyBufferDone(buffer);

    return HDF_SUCCESS;
}

int32_t CodecHdiDecode::OnEmptyBufferDone(const struct OmxCodecBuffer *buffer)
{
    unique_lock<mutex> ulk(lockInputBuffers_);
    unUsedInBuffers_.push_back(buffer->bufferId);
    return HDF_SUCCESS;
}

3.FillBufferDone， 输出buffer填充完毕通知
接收到此通知后，根据bufferId找到具体被填充的OmxCodecBuffer，然后取出解码数据（如果需要的话），再调用FillThisBuffer将buffer传递给组件，组件解码成功一帧数据后，会将解码数据填充到此buffer，并再次出发该回调。

//回调处理函数
int32_t CodecHdiDecode::OnFillBufferDone(struct CodecCallbackType *self, int8_t *pAppData, uint32_t pAppDataLen,
                                     struct OmxCodecBuffer *buffer)
{
    HDF_LOGI("onFillBufferDone: pBuffer.bufferID [%{public}d]", buffer->bufferId);
    g_core->OnFillBufferDone(buffer);
    return HDF_SUCCESS;
}

int32_t CodecHdiDecode::OnFillBufferDone(struct OmxCodecBuffer *buffer)
{
    if (exit_) {
        return HDF_SUCCESS;
    }

    auto iter = omxBuffers_.find(buffer->bufferId);
    if (iter == omxBuffers_.end() || !iter->second) {
        return HDF_SUCCESS;
    }
    // read buffer
    BufferInfo *bufferInfo = iter->second;
    const void *addr        = pBufferInfo->avSharedPtr->ReadFromAshmem(buffer->filledLen, buffer->offset);
    // save to file
    (void)fwrite(addr, 1, buffer->filledLen, fpOut_.get());
    (void)fflush(fpOut_.get());
    // reset buffer
    buffer->offset    = 0;
    buffer->filledLen = 0;
    if (buffer->flag == OMX_BUFFERFLAG_EOS) {
        // 解码结束
        exit_ = true;
        HDF_LOGI("OnFillBufferDone the END coming");
        return HDF_SUCCESS;
    }
    // call fillthisbuffer again
    auto err = client_->FillThisBuffer(client_, bufferInfo->omxBuffer);
    if (err != HDF_SUCCESS) {
        HDF_LOGE("FillThisBuffer error");
        return HDF_SUCCESS;
    }
    return HDF_SUCCESS;
}

组件释放

编解码完成后，我们需要对使用的buffer进行销毁，同时，需要销毁接口相关的结构。
1.先发送命令让组件进入OMX_StateLoaded状态

// command to loaded
client_->SendCommand(client_, OMX_CommandStateSet, OMX_StateLoaded, nullptr, 0);

2.释放所有使用的Buffer

 // release all the buffers
auto iter = omxBuffers_.begin();
while (iter != omxBuffers_.end()) {
    BufferInfo *bufferInfo = iter->second;
    client_->FreeBuffer(client_, (uint32_t)bufferInfo->portIndex, bufferInfo->omxBuffer);
    delete bufferInfo;
    iter++;
}
omxBuffers_.clear();
unUsedInBuffers_.clear();
unUsedOutBuffers_.clear();

3.释放所有buffer之后，等待组件真正进入OMX_StateLoaded 状态
enum OMX_STATETYPE status;
client_->GetState(client_, &status);
// wait loaded
if (status != OMX_StateLoaded) {
HDF_LOGI(“Wait for OMX_StateLoaded status”);
this->WaitForStatusChanged();
} else {
HDF_LOGI(" status is %{public}d", status);
}

4.组件进入Loaded状态，可以释放组件及接口相关实例

// 关闭组件
omxMgr_->DestoryComponent(client_); // 这里已经释放了client_
client_ = nullptr;
// 释放omxMgr_
CodecComponentManagerRelease();

总结

本文只是简单的介绍了下视频编解码Codec HDI的解码过程，需要在正确的组件状态下调用相应的接口。

写在最后

**●如果你觉得这篇内容对你还蛮有帮助，我想邀请你帮我三个小忙：
●点赞，转发，有你们的 『点赞和评论』，才是我创造的动力。
●关注小编，同时可以期待后续文章ing🚀，不定期分享原创知识。

在这里插入图片描述

鸿蒙初辟梦创道远
关注
  • 14
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【鸿蒙南向开发】OpenHarmony Camera源码分析
HarmonyOS_666的博客
07-29 653
这份鸿蒙（HarmonyOS NEXT）文档包含了鸿蒙开发必掌握的核心知识要点，内容包含了（ArkTS、ArkUI开发组件、Stage模型、多端部署、分布式应用开发、音频、视频、WebGL、OpenHarmony多媒体技术、Napi组件、OpenHarmony内核、OpenHarmony南向开发、鸿蒙项目实战等等）鸿蒙（HarmonyOS NEXT）技术知识点。
Harmony鸿蒙南向驱动开发
m0_64420071的博客
04-09 895
OpenHarmony采用多内核（Linux内核或者LiteOS）设计，支持系统在不同资源容量的设备部署。
鸿蒙Harmony实战：Arkts开发接口
DMZDAMS的博客
06-27 638
接口声明引入新类型。接口是定义代码协定的常见方式。
【鸿蒙南向开发】OpenHarmony-HDF驱动框架介绍及加载过程
HarmonyOS_666的博客
07-16 788
1）在系统启动时，DeviceManagerInit 通过 late_initcall 先启动。2） Device Manager 根据 Device Information 信息，解析配置文件中的 Host 列表，根据 Host 列表中的信息来实例化对应的 Host 对象。3）Host 遍历设备列表去获取与之匹配的驱动程序名称，然后基于驱动程序名称遍历.hdf.driver section 获得驱动程序地址。4）设备与驱动匹配成功之后，获取指定驱动的入口地址，加载对应的设备驱动程序。
【鸿蒙南向开发】OpenHarmony——hilog命令行使用手册
HarmonyOS_666的博客
08-05 367
这份鸿蒙（HarmonyOS NEXT）文档包含了鸿蒙开发必掌握的核心知识要点，内容包含了（ArkTS、ArkUI开发组件、Stage模型、多端部署、分布式应用开发、音频、视频、WebGL、OpenHarmony多媒体技术、Napi组件、OpenHarmony内核、OpenHarmony南向开发、鸿蒙项目实战等等）鸿蒙（HarmonyOS NEXT）技术知识点。
OpenHarmony视频编解码入坑记录
qqq1112345的博客
04-17 1230
OHOS4.0适配riscv64架构的视频编解码入坑记录
Harmony鸿蒙南向驱动开发-Watchdog接口使用
m0_64420071的博客
04-12 1367
看门狗（Watchdog），又称看门狗计时器（Watchdog timer），是一种硬件计时设备。
OpenHarmony视频开发
程序猿老樊的博客
01-27 454
1.简介OpenHarmony视频播放的主要工作是将视频数据转码并输出到设备进行播放，同时管理播放任务，包括开始播放、暂停播放、停止播放、资源释放、音量设置、跳转播放位置、设置倍数、获取轨道信息等功能控制。本文将对视频播放全流程、视频切换、视频循环播放等场景开发进行介绍说明。2. OpenHarmony视频播放系统运行机制视频播放状态变化示意图如图1.1所示。图1.1 视频播放状态变化示意图视频播放外部模块交互图如图1.2所示：图1.2 视频播放外部模块交互图。
HarmonyOS NEXT - ArkTS语言 - 接口
u011143672的博客
06-17 394
泛型类型的类型参数可以绑定。例如，HashMap容器中的Key类型参数必须具有哈希方法，即它应该是可哈希的。这样可以不指定实际的类型实参，而只使用泛型类型名称。在上面的例子中，Key类型扩展了Hashable，Hashable接口的所有方法都可以为key调用。继承接口包含被继承接口的所有属性和方法，还可以添加自己的属性和方法。泛型类型和函数允许创建的代码在各种类型上运行，而不仅支持单一类型。任何一个类的实例只要实现了特定接口，就可以通过该接口实现多态。接口是定义代码协定的常见方式。
Harmony鸿蒙南向驱动开发流程
m0_64420071的博客
04-09 1195
HDF（Hardware Driver Foundation）驱动框架，为驱动开发者提供驱动框架能力，包括驱动加载、驱动服务管理、驱动消息机制和配置管理
【鸿蒙南向开发】OpenHarmony——EventHandler源码解析
最新发布
HarmonyOS_666的博客
08-05 862
●如果你觉得这篇内容对你还蛮有帮助，我想邀请你帮我三个小忙：●关注小编，同时可以期待后续文章ing🚀，不定期分享原创知识。
Harmony鸿蒙南向外设驱动开发-Audio
m0_64420071的博客
04-12 1213
本文主要介绍基于HDF（Hardware Driver Foundation）驱动框架开发的Audio驱动，包括Audio驱动的架构组成和功能部件
Harmony鸿蒙南向驱动开发-HDMI接口使用
m0_64420071的博客
04-11 1224
HDMI（High Definition Multimedia Interface），即高清多媒体接口，主要用于DVD、机顶盒等音视频Source到TV、显示器等Sink设备的传输
Harmony鸿蒙南向驱动开发-GPIO接口使用
m0_64420071的博客
04-11 1013
GPIO（General-purpose input/output）即通用型输入输出。
鸿蒙、OpenHarmony、HarmonyOS傻傻的分不清楚。。。看这篇就够了
老卫的技术站
03-22 1万+
很多人对鸿蒙、OpenHarmony、HarmonyOS这些术语傻傻的分不清楚，那么本文就做一些解答。 6月4日，华为发布了《关于规范HarmonyOS沟通口径的通知》（以下简称《通知》），原文在网上都能搜到，这里就不贴了。本人对该通知做一些解读如下。 1. 《通知》背景 《通知》开篇就说“关于‘鸿蒙操作系统’，由于缺乏规范的表述和统一的口径，导致内部理解不一致、对外说法不一致，容易引起混淆”所以，大家不要不好意思啊，不光你不懂，很多人都傻傻的分不清。 不懂不要怕，咱们继续往下看。 2. 鸿蒙操作
OpenHarmony 3.2 Release版本Codec HDI适配过程
1
04-11 516
OpenHarmony Codec HDI（Hardware Device Interface）驱动框架基于 OpenMax 实现了视屏硬件编解码驱动，提供 Codec 基础能力接口供上层媒体服务调用，包括获取组件编解码能力、创建组件、参数设置、数据的轮转和控制、以及销毁组件等功能，实现对视频数据的编解码处理。
OpenHarmony Codec HDI codec_capabilities HCS配置解析
m0_64778763的博客
07-12 1308
OpenHarmony Codec HDI codec_capabilities HCS配置文件详细说明
HarmonyOS 鸿蒙应用开发 (七、HTTP网络组件 axios 介绍及封装使用)
热门推荐
独行猫a 的沉淀、积累、总结。天天学习，好好向上...c/c++,嵌入式 linux,Android,HarmonyOS)
01-27 2万+
在HarmonyOS（OpenHarmony）中，@ohos/net.http 是官方提供的一个用于进行HTTP通信的基础模块。开发者可以利用这个模块发送和接收HTTP请求与响应，实现应用程序与服务器之间的数据交互。文档中心--HTTP数据请求。
鸿蒙开发通信与连接：【@ohos.rpc (RPC通信)】
2301_76813281的博客
06-20 1145
本模块提供进程间通信能力，包括设备内的进程间通信（IPC）和设备间的进程间通信（RPC），前者基于Binder驱动，后者基于软总线驱动。本模块首批接口从API version 7开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值