金富贵
金富贵

金富贵

9个粉丝

10

问答

0

专栏

0

资料

金富贵  发布于  2022-02-25 15:38:36
采纳率 0%
共10个问答
33692
  • 收藏
  • 点赞
  • 分享
  • 举报

hi3559AV 硬解码mp4，ts等封装好的视频

悬赏金¥ 10
已结题
Hi3559
 
海思
 
QT
 

由于项目需要，需要在hi3559 平台上做播放器，用海思自带的demo 是跑通了，但是他解码的是.h264 和.h265等纯码流形式的视频，但是项目需要直接打开mp4，ts,flv等封装好的视频文件，现在思路是想用ffmpeg 去解封装，然后解封装之后的数据去给海思解码通道去解码。ffmpeg解封装代码```cpp
int dcodec_open(const char *url)
{ 

  1. // 初始化格式上下文
  2. AVFormatContext *fmt_ctx =NULL; 
  3. fmt_ctx = avformat_alloc_context();
  4. if (fmt_ctx == NULL) {
  5.     printf("failed to alloc format context\n");
  6.     goto _Error;
  7. }
  9. // 打开输入流
  10. if (avformat_open_input(&fmt_ctx, url, NULL, NULL) < 0) {
  11.     printf("failed to open input url\n");
  12.     goto _Error;
  13. }
  15. // 读取媒体文件信息
  16. if (avformat_find_stream_info(fmt_ctx, NULL) < 0) {
  17.     printf("failed to find stream\n");
  18.     goto _Error;
  19. }
  20. av_dump_format(fmt_ctx, 0, url, 0);
  23. // 寻找音频流和视频流下标
  24. int video_index = -1, audio_index = -1;
  25. for (int i = 0; i < fmt_ctx->nb_streams; i++) {
  26.     if (fmt_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
  27.         printf("video_index\n");
  28.         video_index = i;
  29.     } 
  30. }
  32. auto streams =fmt_ctx->streams;
  35. // 由打印的视频文件信息确定码流类型
  36. char videofile[128];
  37. printf("\ntype the name of output videofile:");
  38. scanf("%s", videofile);
  39. FILE *fvideo = fopen(videofile, "w+");
  40. AVPacket *packet = av_packet_alloc();
  42. while (av_read_frame(fmt_ctx, packet) == 0) {
  43.     if (packet->stream_index == video_index) {
  44.         fwrite(packet->data, 1, packet->size, fvideo);
  45.     }
  46.     av_packet_unref(packet);
  47. }
  49. Error
  50. if (fmt_ctx) avformat_close_input(&fmt_ctx);
  51. if (fvideo)  fclose(fvideo);
  52. if (packet)  av_packet_free(&packet);

}
然后下面是sample vdec里面的COMM_VDEC_SendStream 函数代码片段 

  1. HI_VOID * COMM_VDEC_SendStream(HI_VOID *pArgs)
  3. {
  5.     VDEC_THREAD_PARAM_S *pstVdecThreadParam =(VDEC_THREAD_PARAM_S *)pArgs;
  7.     HI_BOOL bEndOfStream = HI_FALSE;
  9.     HI_S32 s32UsedBytes = 0, s32ReadLen = 0;
  11.     FILE *fpStrm=NULL;
  13.     HI_U8 *pu8Buf = NULL;
  15.     VDEC_STREAM_S stStream;
  17.     HI_BOOL bFindStart, bFindEnd;
  19.     HI_U64 u64PTS = 0;
  21.     HI_U32 u32Len, u32Start;
  23.     HI_S32 s32Ret,  i;
  25.     HI_CHAR cStreamFile[256];
  29.     prctl(PR_SET_NAME, "VideoSendStream", 0,0,0);
  33.     snprintf(cStreamFile, sizeof(cStreamFile), "%s/%s", pstVdecThreadParam->cFilePath,pstVdecThreadParam->cFileName);
  35.     if(cStreamFile != 0)
  37.     {
  39.         fpStrm = fopen(cStreamFile, "rb");
  41.         if(fpStrm == NULL)
  43.         {
  45.             SAMPLE_PRT("chn %d can't open file %s in send stream thread!\n", pstVdecThreadParam->s32ChnId, cStreamFile);
  47.             return (HI_VOID *)(HI_FAILURE);
  49.         }
  51.     }
  53.     printf("\n \033[0;36m chn %d, stream file:%s, userbufsize: %d \033[0;39m\n", pstVdecThreadParam->s32ChnId,
  55.         pstVdecThreadParam->cFileName, pstVdecThreadParam->s32MinBufSize);
  59.     pu8Buf = malloc(pstVdecThreadParam->s32MinBufSize);
  61.     if(pu8Buf == NULL)
  63.     {
  65.         SAMPLE_PRT("chn %d can't alloc %d in send stream thread!\n", pstVdecThreadParam->s32ChnId, pstVdecThreadParam->s32MinBufSize);
  67.         fclose(fpStrm);
  69.         return (HI_VOID *)(HI_FAILURE);
  71.     }
  73.     fflush(stdout);
  77.     u64PTS = pstVdecThreadParam->u64PtsInit;
  79.     while (1)
  81.     {
  83.         if (pstVdecThreadParam->eThreadCtrl == THREAD_CTRL_STOP)
  85.         {
  87.             break;
  89.         }
  91.         else if (pstVdecThreadParam->eThreadCtrl == THREAD_CTRL_PAUSE)
  93.         {
  95.             sleep(1);
  97.             continue;
  99.         }
  103.         bEndOfStream = HI_FALSE;
  105.         bFindStart   = HI_FALSE;
  107.         bFindEnd     = HI_FALSE;
  109.         u32Start     = 0;
  111.         fseek(fpStrm, s32UsedBytes, SEEK_SET);
  113.         s32ReadLen = fread(pu8Buf, 1, pstVdecThreadParam->s32MinBufSize, fpStrm);
  115.         if (s32ReadLen == 0)
  117.         {
  119.             if (pstVdecThreadParam->bCircleSend == HI_TRUE)
  121.             {
  123.                 memset(&stStream, 0, sizeof(VDEC_STREAM_S) );
  125.                 stStream.bEndOfStream = HI_TRUE;
  127.                 HI_MPI_VDEC_SendStream(pstVdecThreadParam->s32ChnId, &stStream, -1);
  131.                 s32UsedBytes = 0;
  133.                 fseek(fpStrm, 0, SEEK_SET);
  135.                 s32ReadLen = fread(pu8Buf, 1, pstVdecThreadParam->s32MinBufSize, fpStrm);
  137.             }
  139.             else
  141.             {
  143.                 break;
  145.             }
  147.         }
  151.         if (pstVdecThreadParam->s32StreamMode==VIDEO_MODE_FRAME && pstVdecThreadParam->enType == PT_H264)
  153.         {
  155.             for (i=0; i<s32ReadLen-8; i++)
  157.             {
  159.                 int tmp = pu8Buf[i+3] & 0x1F;
  161.                 if (  pu8Buf[i    ] == 0 && pu8Buf[i+1] == 0 && pu8Buf[i+2] == 1 &&
  163.                        (
  165.                            ((tmp == 0x5 || tmp == 0x1) && ((pu8Buf[i+4]&0x80) == 0x80)) ||
  167.                            (tmp == 20 && (pu8Buf[i+7]&0x80) == 0x80)
  169.                         )
  171.                    )
  173.                 {
  175.                     bFindStart = HI_TRUE;
  177.                     i += 8;
  179.                     break;
  181.                 }
  183.             }
  187.             for (; i<s32ReadLen-8; i++)
  189.             {
  191.                 int tmp = pu8Buf[i+3] & 0x1F;
  193.                 if (  pu8Buf[i    ] == 0 && pu8Buf[i+1] == 0 && pu8Buf[i+2] == 1 &&
  195.                             (
  197.                                   tmp == 15 || tmp == 7 || tmp == 8 || tmp == 6 ||
  199.                                   ((tmp == 5 || tmp == 1) && ((pu8Buf[i+4]&0x80) == 0x80)) ||
  201.                                   (tmp == 20 && (pu8Buf[i+7]&0x80) == 0x80)
  203.                               )
  205.                    )
  207.                 {
  209.                     bFindEnd = HI_TRUE;
  211.                     break;
  213.                 }
  215.             }
  219.             if(i>0)s32ReadLen = i;
  221.             if (bFindStart == HI_FALSE)
  223.             {
  225.                 SAMPLE_PRT("chn %d can not find H264 start code!s32ReadLen %d, s32UsedBytes %d.!\n",
  227.                     pstVdecThreadParam->s32ChnId, s32ReadLen, s32UsedBytes);
  229.             }
  231.             if (bFindEnd == HI_FALSE)
  233.             {
  235.                 s32ReadLen = i+8;
  237.             }
  241.         }
  243.         else if (pstVdecThreadParam->s32StreamMode==VIDEO_MODE_FRAME && pstVdecThreadParam->enType == PT_H265)
  245.         {
  247.             HI_BOOL  bNewPic = HI_FALSE;
  249.             for (i=0; i<s32ReadLen-6; i++)
  251.             {
  253.                 HI_U32 tmp = (pu8Buf[i+3]&0x7E)>>1;
  255.                 bNewPic = ( pu8Buf[i+0] == 0 && pu8Buf[i+1] == 0 && pu8Buf[i+2] == 1
  257.                             && (tmp >= 0 && tmp <= 21) && ((pu8Buf[i+5]&0x80) == 0x80) );
  261.                 if (bNewPic)
  263.                 {
  265.                     bFindStart = HI_TRUE;
  267.                     i += 6;
  269.                     break;
  271.                 }
  273.             }
  277.             for (; i<s32ReadLen-6; i++)
  279.             {
  281.                 HI_U32 tmp = (pu8Buf[i+3]&0x7E)>>1;
  283.                 bNewPic = (pu8Buf[i+0] == 0 && pu8Buf[i+1] == 0 && pu8Buf[i+2] == 1
  285.                             &&( tmp == 32 || tmp == 33 || tmp == 34 || tmp == 39 || tmp == 40 || ((tmp >= 0 && tmp <= 21) && (pu8Buf[i+5]&0x80) == 0x80) )
  287.                              );
  291.                 if (bNewPic)
  293.                 {
  295.                     bFindEnd = HI_TRUE;
  297.                     break;
  299.                 }
  301.             }
  303.             if(i>0)s32ReadLen = i;
  307.             if (bFindStart == HI_FALSE)
  309.             {
  311.                 SAMPLE_PRT("chn %d can not find H265 start code!s32ReadLen %d, s32UsedBytes %d.!\n",
  313.                     pstVdecThreadParam->s32ChnId, s32ReadLen, s32UsedBytes);
  315.             }
  317.             if (bFindEnd == HI_FALSE)
  319.             {
  321.                 s32ReadLen = i+6;
  323.             }
  327.         }
  329.         else if (pstVdecThreadParam->enType == PT_MJPEG || pstVdecThreadParam->enType == PT_JPEG)
  331.         {
  333.             for (i=0; i<s32ReadLen-1; i++)
  335.             {
  337.                 if (pu8Buf[i] == 0xFF && pu8Buf[i+1] == 0xD8)
  339.                 {
  341.                     u32Start = i;
  343.                     bFindStart = HI_TRUE;
  345.                     i = i + 2;
  347.                     break;
  349.                 }
  351.             }
  355.             for (; i<s32ReadLen-3; i++)
  357.             {
  359.                 if ((pu8Buf[i] == 0xFF) && (pu8Buf[i+1]& 0xF0) == 0xE0)
  361.                 {
  363.                      u32Len = (pu8Buf[i+2]<<8) + pu8Buf[i+3];
  365.                      i += 1 + u32Len;
  367.                 }
  369.                 else
  371.                 {
  373.                     break;
  375.                 }
  377.             }
  381.             for (; i<s32ReadLen-1; i++)
  383.             {
  385.                 if (pu8Buf[i] == 0xFF && pu8Buf[i+1] == 0xD9)
  387.                 {
  389.                     bFindEnd = HI_TRUE;
  391.                     break;
  393.                 }
  395.             }
  397.             s32ReadLen = i+2;
  401.             if (bFindStart == HI_FALSE)
  403.             {
  405.                 SAMPLE_PRT("chn %d can not find JPEG start code!s32ReadLen %d, s32UsedBytes %d.!\n",
  407.                     pstVdecThreadParam->s32ChnId, s32ReadLen, s32UsedBytes);
  409.             }
  411.         }
  413.         else
  415.         {
  417.             if((s32ReadLen != 0) && (s32ReadLen < pstVdecThreadParam->s32MinBufSize))
  419.             {
  421.                 bEndOfStream = HI_TRUE;
  423.             }
  425.         }
  429.         stStream.u64PTS       = u64PTS;
  431.         stStream.pu8Addr      = pu8Buf + u32Start;
  433.         stStream.u32Len       = s32ReadLen;
  435.         stStream.bEndOfFrame  = (pstVdecThreadParam->s32StreamMode==VIDEO_MODE_FRAME)? HI_TRUE: HI_FALSE;
  437.         stStream.bEndOfStream = bEndOfStream;
  439.         stStream.bDisplay     = 1;
  443. SendAgain:
  445.         s32Ret=HI_MPI_VDEC_SendStream(pstVdecThreadParam->s32ChnId, &stStream, pstVdecThreadParam->s32MilliSec);
  447.         if( (HI_SUCCESS != s32Ret) && (THREAD_CTRL_START == pstVdecThreadParam->eThreadCtrl) )
  449.         {
  451.             usleep(pstVdecThreadParam->s32IntervalTime);
  453.             goto SendAgain;
  455.         }
  457.         else
  459.         {
  461.             bEndOfStream = HI_FALSE;
  463.             s32UsedBytes = s32UsedBytes +s32ReadLen + u32Start;
  465.             u64PTS += pstVdecThreadParam->u64PtsIncrease;
  467.         }
  469.         usleep(pstVdecThreadParam->s32IntervalTime);
  471.     }
  475.     /* send the flag of stream end */
  477.     memset(&stStream, 0, sizeof(VDEC_STREAM_S) );
  479.     stStream.bEndOfStream = HI_TRUE;
  481.     HI_MPI_VDEC_SendStream(pstVdecThreadParam->s32ChnId, &stStream, -1);
  485.     printf("\033[0;35m chn %d send steam thread return ...  \033[0;39m\n", pstVdecThreadParam->s32ChnId);
  487.     fflush(stdout);
  489.     if (pu8Buf != HI_NULL)
  491.     {
  493.         free(pu8Buf);
  495.     }
  497.     fclose(fpStrm);
  501.     return (HI_VOID *)HI_SUCCESS;
  503. }

这里海思的函数主要是打开文件，然后去分割每一个视频帧的大小，fseek(fpStrm, s32UsedBytes, SEEK_SET)将文件指针位置定位到s32UsedBytes处，一开始为0位置，s32UsedBytes是变量随着whiile循环逐渐变大，
s32ReadLen = fread(pu8Buf, 1, pstVdecThreadParam->s32MinBufSize, fpStrm);读取一帧数据到pu8Buf，
pstVdecThreadParam->s32StreamMode==VIDEO_MODE_FRAME && pstVdecThreadParam->enType == PT_H264 这里面应该就是找到视频数据流中一帧的长度。
然而我用ffmpeg 解封装之后的数据，包括AVPacket，还有fmt_ctx->streams[i],一帧一帧的数据，如何跟海思sample vdec HI_MPI_VDEC_SendStream（pstVdecThreadParam->s32ChnId, &stStream, pstVdecThreadParam->s32MilliSec） 这个函数中的stStream数据相匹配。或者说我这边用ffmpeg解封的步骤有问题，请大佬解惑

我来回答
回答5个
时间排序
认可量排序
黑白110

黑白110

0个粉丝

0

问答

0

专栏

0

资料

黑白110 2022-04-29 09:30:19
认可0

好长阿，帮顶
朱李不怎么强

朱李不怎么强

4个粉丝

0

问答

0

专栏

0

资料

朱李不怎么强 2022-07-13 09:42:45
认可1

最近我也在处理这个事，大佬你有指导性方针吗

金富贵
金富贵   回复   朱李不怎么强  2022-07-19 09:58:48
赞1

已经找到思路，ffmpeg解包，直接送包就可以，ffmpeg 解包出来的有个也是地址指针，还有帧的长度，这样跟sdk 里面的参数是匹配的。

刘兵

刘兵

6个粉丝

3

问答

3

专栏

6

资料

刘兵 2022-09-26 08:44:17
认可1

ffmpeg和gstreamer都可以的。
这两个架构都很流行，按照他们的格式要求，调用硬件即可，他们也有相应的黑盒输出。

邓晓

邓晓

20个粉丝

1

问答

0

专栏

19

资料

邓晓 2022-09-26 10:07:04
认可0

海思的硬件解码输入是h264/h265码流,又不是物理地址,ffmpeg解包处理的buff直接送如就可以了,注意解码器的类型,分辨率要和ffmpeg解析出来保持一致.

添加附件 添加网盘链接
或将文件直接拖到这里
悬赏：
E币
网盘
* 网盘链接：
* 提取码：
悬赏：
E币

Markdown 语法

  • 加粗**内容**
  • 斜体*内容*
  • 删除线~~内容~~
  • 引用> 引用内容
  • 代码`代码`
  • 代码块```编程语言↵代码```
  • 链接[链接标题](url)
  • 无序列表- 内容
  • 有序列表1. 内容
  • 缩进内容
  • 图片![alt](url)
+ 添加网盘链接/附件

Markdown 语法

  • 加粗**内容**
  • 斜体*内容*
  • 删除线~~内容~~
  • 引用> 引用内容
  • 代码`代码`
  • 代码块```编程语言↵代码```
  • 链接[链接标题](url)
  • 无序列表- 内容
  • 有序列表1. 内容
  • 缩进内容
  • 图片![alt](url)
相关问答
无更多相似问答 去提问
易百纳技术社区
点击登录
-- 积分
-- E币
提问
—
收益
—
被采纳
—
我要提问
社区问答
最佳回答
被评为最佳回答，即可获得10元悬赏金额，先回答帮助题主解决问题，会更具优势
悬赏问答
举报反馈

举报类型

  • 内容涉黄/赌/毒
  • 内容侵权/抄袭
  • 政治相关
  • 涉嫌广告
  • 侮辱谩骂
  • 其他

详细说明

提醒
你的问题还没有最佳答案，是否结题，结题后将扣除20%的悬赏金
取消
确认
提醒
你的问题还没有最佳答案，是否结题，结题后将根据回答情况扣除相应悬赏金（1回答=1E币）
取消
确认
易百纳技术社区