#include "lib_prot_pd.h" #include "mod_input_output.h" #include "mod_display.h" #include "mod_queue.h" #include "app_typec_deal.h" #include "app_init.h" #include "lib_multi_protocol.h" uint8_t typeca_ufp= 0; void typeca_hard_reset_cb(void) { static uint8_t b_typec_hard_reset_lock= RESET; if(h_pd.output.b_source_read_hard|| \ h_pd.output.b_sink_read_hard) { if(b_typec_hard_reset_lock== RESET) { b_typec_hard_reset_lock= SET; mod_queue_send(PLUG_CA_RST_P); } }else { if(b_typec_hard_reset_lock) { b_typec_hard_reset_lock= RESET; mod_queue_send(PLUG_CA_RST_N); } } } void typecb_hard_reset_cb(void) { static uint8_t b_typec_hard_reset_lock= RESET; if(h_pd.output.b_source_read_hard|| \ h_pd.output.b_sink_read_hard) { if(b_typec_hard_reset_lock== RESET) { b_typec_hard_reset_lock= SET; mod_queue_send(PLUG_CB_RST_P); } }else { if(b_typec_hard_reset_lock) { b_typec_hard_reset_lock= RESET; mod_queue_send(PLUG_CB_RST_N); } } } void typeca_pr_swap_cb(void) { static uint8_t b_pd_power_role_swap_lock; if(h_pd.output.b_pr_swap_en) { if(h_pd.output.b_source_read_pr_swap) { b_pd_power_role_swap_lock= SET; /*用户代码*/ //关 VBus }else if(h_pd.output.b_sink_read_pr_swap) { /*用户代码*/ //DC-DC 进入放电状态,升压,打开 VBus } }else { b_pd_power_role_swap_lock= RESET; } } void typecb_pr_swap_cb(void) { static uint8_t b_pd_power_role_swap_lock; if(h_pd.output.b_pr_swap_en) { if(h_pd.output.b_source_read_pr_swap) { b_pd_power_role_swap_lock= SET; /*用户代码*/ //关 VBus }else if(h_pd.output.b_sink_read_pr_swap) { /*用户代码*/ //DC-DC 进入放电状态,升压,打开 VBus } }else { b_pd_power_role_swap_lock= RESET; } } bool typeca_vbus_exist_cb(void) { //判断一下0.8V VBus电压 return mod_io_typeca_acin(); } bool typecb_vbus_exist_cb(void) { //判断一下0.8V VBus电压 return mod_io_typecb_acin(); } void typeca_attached_src_cb(void) { /** * !!! * 兼容性测试需要 */ mod_io_a1d_out(); mod_queue_send(PLUG_CAD_IN); } void typecb_attached_src_cb(void) { mod_io_a1d_out(); mod_queue_send(PLUG_CBD_IN); } void typeca_attached_snk_cb(void) { mod_queue_send(PLUG_CAC_IN); typeca_ufp = 1; } void typecb_attached_snk_cb(void) { mod_queue_send(PLUG_CBC_IN); typeca_ufp = 1; } void typeca_unattached_cb(void) { mod_queue_send(PLUG_CAX_OUT); typeca_ufp = 0; } void typecb_unattached_cb(void) { mod_queue_send(PLUG_CBX_OUT); }

这是一段 C 语言代码，包括了一些函数和变量的定义。其中定义了一些回调函数，如 typeca_hard_reset_cb、typecb_hard_reset_cb，用于 Type-C 接口的硬复位操作。还定义了 typeca_pr_swap_cb、typecb_pr_swap_cb，用于 Type-C 接口的 power role swap（PR_SWAP）操作。此外，还定义了一些判断 VBus 电压是否存在的函数，如 typeca_vbus_exist_cb、typecb_vbus_exist_cb，以及一些表示设备接入或断开的回调函数，如 typeca_attached_src_cb、typecb_attached_src_cb、typeca_attached_snk_cb、typecb_attached_snk_cb、typeca_unattached_cb、typecb_unattached_cb。

相关问题

prot_len_comp <- data.frame(Length = nchar(prot_file), Composition = letterFrequency(prot_file))

这段代码的功能是创建一个名为 prot_len_comp 的数据框，其中包含两列：Length 和 Composition。Length 列包含蛋白质序列文件 prot_file 中每个蛋白质序列的字符数（使用 nchar 函数计算），Composition 列包含每种氨基酸在蛋白质序列文件中出现的频率（使用 letterFrequency 函数计算）。

但是，在运行这段代码之前，你需要确保 prot_file 中包含有效的蛋白质序列文件，并且 letterFrequency 函数已经被定义或者已经被加载。如果 letterFrequency 函数未定义或未加载，你需要先定义该函数或者加载包含该函数的库，然后再运行该代码。

生成一个rk3399 mpi接口使用mppencrccfg 的h264编码 包含#define TAG "mpi_h264enc_test" 完整程序

很抱歉，我无法提供完整的程序代码。但我可以给出一些参考:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <sys/time.h>
#include <linux/videodev2.h>
#include "rk_mpi.h"
#include "rk_venc.h"

#define TAG "mpi_h264enc_test"

#define VIDEO_WIDTH     1920
#define VIDEO_HEIGHT    1080
#define VIDEO_FPS       30

#define FRAME_NUM       1000

typedef struct
{
    int fd;
    void *start;
    size_t length;
} camera_t;

static camera_t *camera_open(int id)
{
    camera_t *camera = (camera_t *)malloc(sizeof(camera_t));
    if (camera == NULL)
    {
        printf("[%s] malloc camera_t failed\n", TAG);
        return NULL;
    }

    char dev_name[16];
    sprintf(dev_name, "/dev/video%d", id);
    camera->fd = open(dev_name, O_RDWR);
    if (camera->fd < 0)
    {
        printf("[%s] open %s failed\n", TAG, dev_name);
        free(camera);
        return NULL;
    }

    struct v4l2_capability cap;
    if (ioctl(camera->fd, VIDIOC_QUERYCAP, &cap) < 0)
    {
        printf("[%s] VIDIOC_QUERYCAP failed\n", TAG);
        close(camera->fd);
        free(camera);
        return NULL;
    }

    if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE))
    {
        printf("[%s] %s is not a video capture device\n", TAG, dev_name);
        close(camera->fd);
        free(camera);
        return NULL;
    }

    if (!(cap.capabilities & V4L2_CAP_STREAMING))
    {
        printf("[%s] %s does not support streaming i/o\n", TAG, dev_name);
        close(camera->fd);
        free(camera);
        return NULL;
    }

    struct v4l2_format fmt;
    memset(&fmt, 0, sizeof(fmt));
    fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    fmt.fmt.pix.width = VIDEO_WIDTH;
    fmt.fmt.pix.height = VIDEO_HEIGHT;
    fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
    fmt.fmt.pix.field = V4L2_FIELD_NONE;
    if (ioctl(camera->fd, VIDIOC_S_FMT, &fmt) < 0)
    {
        printf("[%s] VIDIOC_S_FMT failed\n", TAG);
        close(camera->fd);
        free(camera);
        return NULL;
    }

    struct v4l2_requestbuffers req;
    memset(&req, 0, sizeof(req));
    req.count = 4;
    req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    req.memory = V4L2_MEMORY_MMAP;
    if (ioctl(camera->fd, VIDIOC_REQBUFS, &req) < 0)
    {
        printf("[%s] VIDIOC_REQBUFS failed\n", TAG);
        close(camera->fd);
        free(camera);
        return NULL;
    }

    struct v4l2_buffer buf;
    for (int i = 0; i < req.count; i++)
    {
        memset(&buf, 0, sizeof(buf));
        buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        buf.memory = V4L2_MEMORY_MMAP;
        buf.index = i;
        if (ioctl(camera->fd, VIDIOC_QUERYBUF, &buf) < 0)
        {
            printf("[%s] VIDIOC_QUERYBUF failed\n", TAG);
            close(camera->fd);
            free(camera);
            return NULL;
        }

        camera->start = mmap(NULL, buf.length, PROT_READ | PROT_WRITE, MAP_SHARED, camera->fd, buf.m.offset);
        if (camera->start == MAP_FAILED)
        {
            printf("[%s] mmap failed\n", TAG);
            close(camera->fd);
            free(camera);
            return NULL;
        }

        camera->length = buf.length;
        if (ioctl(camera->fd, VIDIOC_QBUF, &buf) < 0)
        {
            printf("[%s] VIDIOC_QBUF failed\n", TAG);
            munmap(camera->start, camera->length);
            close(camera->fd);
            free(camera);
            return NULL;
        }
    }

    enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    if (ioctl(camera->fd, VIDIOC_STREAMON, &type) < 0)
    {
        printf("[%s] VIDIOC_STREAMON failed\n", TAG);
        close(camera->fd);
        free(camera);
        return NULL;
    }

    return camera;
}

static void camera_close(camera_t *camera)
{
    if (camera != NULL)
    {
        enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        ioctl(camera->fd, VIDIOC_STREAMOFF, &type);

        for (int i = 0; i < 4; i++)
        {
            munmap(camera->start, camera->length);
        }

        close(camera->fd);
        free(camera);
    }
}

static int camera_capture(camera_t *camera, unsigned char *buffer, int *length)
{
    struct v4l2_buffer buf;
    memset(&buf, 0, sizeof(buf));
    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    buf.memory = V4L2_MEMORY_MMAP;
    if (ioctl(camera->fd, VIDIOC_DQBUF, &buf) < 0)
    {
        return -1;
    }

    memcpy(buffer, camera->start, buf.bytesused);
    *length = buf.bytesused;

    if (ioctl(camera->fd, VIDIOC_QBUF, &buf) < 0)
    {
        return -1;
    }

    return 0;
}

static void *camera_thread(void *arg)
{
    camera_t *camera = (camera_t *)arg;

    unsigned char *buffer = (unsigned char *)malloc(camera->length);
    if (buffer == NULL)
    {
        printf("[%s] malloc buffer failed\n", TAG);
        return NULL;
    }

    int length = 0;
    while (1)
    {
        if (camera_capture(camera, buffer, &length) == 0)
        {
            // do something with captured frame
        }

        usleep(1000);
    }

    free(buffer);
    return NULL;
}

int main(int argc, char **argv)
{
    RK_MPI_SYS_Init();

    RK_U32 u32Width = VIDEO_WIDTH;
    RK_U32 u32Height = VIDEO_HEIGHT;
    RK_U32 u32Fps = VIDEO_FPS;
    RK_U32 u32BitRate = u32Width * u32Height * 3 / 2 * u32Fps;
    RK_U32 u32KeyFrameInterval = u32Fps;
    RK_U32 u32Profile = 66; // H264 PROFILE_HIGH

    MPP_CHN_S stChnAttr;
    stChnAttr.mChnId = 0;
    stChnAttr.mModId = RK_ID_VENC;
    stChnAttr.mDevId = 0;
    stChnAttr.mWidth = u32Width;
    stChnAttr.mHeight = u32Height;
    stChnAttr.mFps = u32Fps;
    stChnAttr.mBitRate = u32BitRate;
    stChnAttr.mProfile = u32Profile;
    stChnAttr.mLevel = 41; // H264 LEVEL4_1
    stChnAttr.mPixelFormat = RK_FMT_YUV420SP;
    stChnAttr.mRotation = 0;
    stChnAttr.mMirror = 0;
    stChnAttr.mFlip = 0;
    stChnAttr.mDrmMode = 0;
    stChnAttr.mDrmFd = -1;

    if (RK_MPI_VENC_CreateChn(0, &stChnAttr) != RK_SUCCESS)
    {
        printf("[%s] create venc chn failed\n", TAG);
        return -1;
    }

    if (RK_MPI_VENC_RegisterChn(0, 0, 0) != RK_SUCCESS)
    {
        printf("[%s] register venc chn failed\n", TAG);
        return -1;
    }

    MPP_CHN_S stSrcChn;
    stSrcChn.mModId = RK_ID_VI;
    stSrcChn.mDevId = 0;
    stSrcChn.mChnId = 0;

    MPP_CHN_S stDestChn;
    stDestChn.mModId = RK_ID_VENC;
    stDestChn.mDevId = 0;
    stDestChn.mChnId = 0;

    RK_MPI_SYS_Bind(&stSrcChn, &stDestChn);

    camera_t *camera = camera_open(0);
    if (camera != NULL)
    {
        pthread_t tid;
        pthread_create(&tid, NULL, camera_thread, camera);
    }

    RK_S32 s32Ret = RK_SUCCESS;
    MPP_FRAME_S stFrame;
    memset(&stFrame, 0, sizeof(stFrame));
    stFrame.mModId = RK_ID_VENC;
    stFrame.mChannelId = 0;
    stFrame.mWidth = u32Width;
    stFrame.mHeight = u32Height;
    stFrame.mField = RK_FIELD_NONE;
    stFrame.mFrameType = RK_CODEC_FRAME_SPS_PPS_I;
    stFrame.mCompressMode = COMPRESS_MODE_NONE;
    stFrame.mBitWidth = 10;
    stFrame.mColor = MPP_FMT_YUV420SP;

    for (int i = 0; i < FRAME_NUM; i++)
    {
        s32Ret = RK_MPI_VENC_GetFrm(0, &stFrame, RK_TRUE);
        if (s32Ret != RK_SUCCESS)
        {
            printf("[%s] venc get frame failed\n", TAG);
            goto done;
        }

        unsigned char *y = (unsigned char *)stFrame.mVirAddr[0];
        unsigned char *uv = (unsigned char *)stFrame.mVirAddr[1];
        int y_len = stFrame.mWidth * stFrame.mHeight;
        int uv_len = stFrame.mWidth * stFrame.mHeight / 2;

        RK_MPI_VENC_RcCfg rc_cfg;
        memset(&rc_cfg, 0, sizeof(rc_cfg));
        rc_cfg.mRcMode = VENC_RC_MODE_H264CBR;
        rc_cfg.mBitRate = u32BitRate;
        rc_cfg.mFrmRate = u32Fps;
        rc_cfg.mGop = u32KeyFrameInterval;
        rc_cfg.mQpMin = 30;
        rc_cfg.mQpMax = 51;
        rc_cfg.mQpInit = 35;
        rc_cfg.mMaxReEncodeTimes = 5;
        rc_cfg.mMaxQPDelta = 10;
        rc_cfg.mMaxBitRateTolerance = 1000;

        RK_MPI_VENC_SetRcCfg(0, &rc_cfg);

        RK_MPI_VENC_H264Cfg h264_cfg;
        memset(&h264_cfg, 0, sizeof(h264_cfg));
        h264_cfg.mProfile = u32Profile;
        h264_cfg.mLevel = 41;
        h264_cfg.mEntropyMode = VENC_ENTROPY_MODE_CABAC;
        h264_cfg.mCabacInitIdc = 0;
        h264_cfg.mSliceNum = 2;
        h264_cfg.mSliceMode = VENC_H264_SLICEMODE_SINGLE;

        RK_MPI_VENC_SetH264Cfg(0, &h264_cfg);

        RK_MPI_VENC_H264Vui h264_vui;
        memset(&h264_vui, 0, sizeof(h264_vui));
        h264_vui.mAspectRatioIdc = 0;
        h264_vui.mOverScanInfo = 0;
        h264_vui.mBitstreamRestriction = 0;

        RK_MPI_VENC_SetH264Vui(0, &h264_vui);

        RK_MPI_VENC_H264Sei h264_sei;
        memset(&h264_sei, 0, sizeof(h264_sei));
        h264_sei.mRecoveryPoint = 0;
        h264_sei.mRecoveryPointInfoPresent = 0;
        h264_sei.mBufferingPeriod = 0;
        h264_sei.mPictureTiming = 0;

        RK_MPI_VENC_SetH264Sei(0, &h264_sei);

        MPP_ENC_CFG_S stMppEncCfg;
        memset(&stMppEncCfg, 0, sizeof(stMppEncCfg));
        stMppEncCfg.mRcCfg = &rc_cfg;
        stMppEncCfg.mGopCfg = NULL;
        stMppEncCfg.mH264Cfg = &h264_cfg;
        stMppEncCfg.mH264VuiCfg = &h264_vui;
        stMppEncCfg.mH264SeiCfg = &h264_sei;
        RK_MPI_VENC_SetMppCfg(0, &stMppEncCfg);

        MPP_ENC_SEI_S stEncSei;
        memset(&stEncSei, 0, sizeof(stEncSei));
        stEncSei.mEncSeiMode = MPP_ENC_SEI_MODE_ALL;
        RK_MPI_VENC_SetExtCfg(0, ENC_CFG_SEI, &stEncSei);

        RK_MPI_VENC_SendFrame(0, y, uv, y_len, uv_len);

        RK_MPI_VENC_ReleaseFrm(0, &stFrame);

        usleep(1000 * 1000 / u32Fps);
    }

done:
    if (RK_MPI_VENC_UnRegisterChn(0, 0, 0) != RK_SUCCESS)
    {
        printf("[%s] unregister venc chn failed\n", TAG);
    }

    if (RK_MPI_VENC_DestroyChn(0) != RK_SUCCESS)
    {
        printf("[%s] destroy venc chn failed\n", TAG);
    }

    RK_MPI_SYS_UnBind(&stSrcChn, &stDestChn);

    if (camera != NULL)
    {
        camera_close(camera);
    }

    RK_MPI_SYS_Exit();

    return 0;
}

这是一个基于 Rockchip RK3399 平台的 H.264 编码程序，程序中包含了使用 MPP 接口对 H.264 编码器进行配置的相关代码，可以根据需要进行修改。注意，本程序只是一个示例程序，不保证可以直接编译通过并运行。