FastASR+FFmpeg(音视频开发+语音识别)（二）

bool AVInterface::extractAudio(const char* src, const char* dstDir)
{
  if (NULL == src || NULL == dstDir)
  {
    printf("Ffmpeg::extractAudio[ERROR]::无效参数,请检查文件路径是否正确\n");
    return false;
  }
  int ret = 0;
  // 预存原文件路径
  const char* src_fileName = src;
  // 1.获取媒体文件的全局上下文信息
  // 1.1 定义 AVFormatContext 容器
  AVFormatContext* pFormatCtx = NULL;      // AVFormatContext描述了一个媒体文件或者媒体流构成的基本信息
  pFormatCtx = avformat_alloc_context();   // 为 pFormatCtx 申请内存
  // 1.2 打开媒体文件,并且读取媒体文件的头信息放入pFormatCtx中
  ret = avformat_open_input(&pFormatCtx, src_fileName, NULL, NULL);
  if (ret < 0)
  {
    printf("Ffmpeg::extractAudio[ERROR]::打开媒体流文件失败\n");
    return false;
  }
  // 2.探测流出信息
  // 2.1 探寻文件中是否存在信息流,如果存在则将多媒体文件信息流放到pFormatCtx
  ret = avformat_find_stream_info(pFormatCtx, NULL);
  if (ret < 0)
  {
    printf("Ffmpeg::extractAudio[ERROR]::文件中不存在信息流\n");
    return false;
  }
  av_dump_format(pFormatCtx, 0, src_fileName, 0);    // 打印封装格式和流信息
  // 2.2 查找文件信息流中是否存在音频流(我们只需要提取音频),并获取到音频流在信息流中的索引
  int audio_stream_index = -1;
  audio_stream_index = av_find_best_stream(pFormatCtx, AVMEDIA_TYPE_AUDIO, -1, -1, NULL, 0);
  if (-1 == audio_stream_index)
  {
    printf("Ffmpeg::extractAudio[ERROR]::文件中不存在音频流\n");
    return false;
  }
  // 3.输出容器的定义
  AVFormatContext* pFormatCtx_out = NULL;    // 输出格式的上下文信息  
  const AVOutputFormat*  pFormatOut = NULL;        // 输出的封装格式
  AVPacket packet;                         
  // 输出文件路径
  char szFilename[256] = { 0 };
  snprintf(szFilename, sizeof(szFilename), "%s/ffmpeg-music.aac", dstDir);
  // 3.1 初始化容器
  // 初始化一些基础的信息
  av_init_packet(&packet);                 
  // 给 pFormatCtx_out 动态分配内存,并且会根据文件名初始化一些基础信息
  avformat_alloc_output_context2(&pFormatCtx_out, NULL, NULL, szFilename);  
  // 得到封装格式 AAC
  pFormatOut = pFormatCtx_out->oformat;
  // 4.读取音频流,并且将输入流的格式拷贝到输出流的格式中
  for (int i = 0; i < pFormatCtx->nb_streams; ++i)   // nb_streams 流的个数
  {
    // 流的结构体,封存了一些流相关的信息
    AVStream* out_stream = NULL;               // 输出流
    AVStream* in_stream  = pFormatCtx->streams[i];             // 输入流
    AVCodecParameters* in_codeper = in_stream->codecpar;   // 编解码器
    // 只取音频流
    if (in_codeper->codec_type == AVMEDIA_TYPE_AUDIO)
    {
      // 建立输出流
      out_stream = avformat_new_stream(pFormatCtx_out, NULL);
      if (NULL == out_stream)
      {
        printf("Ffmpeg::extractAudio::[ERROR]建立输出流失败\n");
        return false;
      }
      // 拷贝编码参数,如果需要转码请不要直接拷贝
      // 这里只需要做音频的提取,对转码要求不高
      ret = avcodec_parameters_copy(out_stream->codecpar, in_codeper); // 将输入流的编码拷贝到输出流
      if (ret < 0)
      {
        printf("Ffmpeg::extractAudio::[ERROR]拷贝编码失败\n");
        return false;
      }
      out_stream->codecpar->codec_tag = 0;
      break;  // 拿到音频流就可以直接退出循环,这里我们只需要音频流
    }
  }
  av_dump_format(pFormatCtx_out, 0, szFilename, 1);
  // 解复用器,如果没有指定就使用pb
  if (!(pFormatCtx->flags & AVFMT_NOFILE))
  {
    ret = avio_open(&pFormatCtx_out->pb, szFilename, AVIO_FLAG_WRITE); // 读写
    if (ret < 0)
    {
      printf("Ffmpeg::extractAudio::[ERROR]创建AVIOContext对象：打开文件失败\n");
      return false;
    }
  }
  // 写入媒体文件头部
  ret = avformat_write_header(pFormatCtx_out, NULL);
  if (ret < 0)
  {
    printf("Ffmpeg::extractAudio::[ERROR]写入媒体头部失败\n");
    return false;
  }
  // 逐帧提取音频
  AVPacket* pkt = av_packet_alloc();
  while (av_read_frame(pFormatCtx, &packet) >=0 )
  {
    AVStream* in_stream  = NULL;
    AVStream* out_stream = NULL;
    in_stream = pFormatCtx->streams[pkt->stream_index];
    out_stream = pFormatCtx_out->streams[pkt->stream_index];
    if (packet.stream_index == audio_stream_index)
    {
      packet.pts = av_rescale_q_rnd(packet.pts, in_stream->time_base, out_stream->time_base, (AVRounding)(AV_ROUND_INF|AV_ROUND_PASS_MINMAX));
      packet.dts = packet.pts;
      packet.duration = av_rescale_q(packet.duration, in_stream->time_base, out_stream->time_base);
      packet.pos = -1;
      packet.stream_index = 0;
      // 将包写到输出媒体文件
      av_interleaved_write_frame(pFormatCtx_out, &packet);
      // 减少引用计数,防止造成内存泄漏
      av_packet_unref(&packet);
    }
  }
  // 写入尾部信息
  av_write_trailer(pFormatCtx_out);
  // 释放
  av_packet_free(&pkt);
  avio_close(pFormatCtx_out->pb);
  avformat_close_input(&pFormatCtx);
    return true;
}

bool AVInterface::extracPictrue(const char* src, const char* dstDir, int num)
{
    if(NULL == src || NULL == dstDir)
    {
        printf("Ffmpeg::extracPictrue[ERROR]::无效参数,请检查文件路径是否正确\n");
        return false;
    }
    int ret = 0;
    // 预存原文件路径
    const char* src_fileName = src;
    // 1.获取媒体文件的全局上下文信息
    // 1.1 定义 AVFormatContext 容器
    AVFormatContext* pFormatCtx = NULL;       // AVFormatContext描述了一个媒体文件或者媒体流构成的基本信息
    pFormatCtx = avformat_alloc_context();    // 为pFormatCtx申请内存
    // 1.2 打开媒体文件,并且读取媒体文件的头信息放入pFormatCtx中
    ret = avformat_open_input(&pFormatCtx, src_fileName, NULL, NULL);
    if(ret < 0)
    {
        printf("Ffmpeg::extracPictrue[ERROR]::打开媒体流文件失败\n");
        return false;
    }
    // 2.探测流信息
    // 2.1 探寻文件中是否存在信息流,如果存在则将多媒体文件信息流放到pFormatCtx中
    ret = avformat_find_stream_info(pFormatCtx, NULL);
    if(ret < 0)
    {
        printf("Ffmpeg::extracPictrue[ERROR]::文件中不存在信息流\n");
        return false;
    }
    av_dump_format(pFormatCtx, 0, src_fileName, 0);      // 可以打印查看
    // 2.2 查找文件信息流中是否存在视频流(这里我们需要提取图片),并获取到视频流在信息流中的索引
    int vecdio_stream_index = -1;
    vecdio_stream_index = av_find_best_stream(pFormatCtx, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
    if(-1 == vecdio_stream_index)
    {
        printf("Ffmpeg::extracPictrue[ERROR]::文件中不存在视频流\n");
        return false;
    }   // ----------> 丛林方法1
    // 3.找到对应的解码器:音视频文件是压缩之后的,我们要对文件内容进行处理,就必须先解码
    // 3.1 定义解码器的容器
    AVCodecContext* pCodeCtx = NULL;          // AVCodecContext描述编解码器的结构,包含了众多解码器的基本信息
    const AVCodec* pCodec = NULL;                   // AVCodec 存储解码器的信息
  pCodeCtx = avcodec_alloc_context3(NULL);  // 初始化解码器上下文
    // 3.2 查找解码器
    AVStream* pStream = pFormatCtx->streams[vecdio_stream_index]; // 在众多解码器找到视频处理的上下文信息
    pCodec = avcodec_find_decoder(pStream->codecpar->codec_id);          // 根据视频流获取视频解码器的基本信息
    if(NULL == pCodec)
    {
        printf("未发现视频编码器\n");
        return false;
    }
  // 初始化解码器上下文
  ret = avcodec_parameters_to_context(pCodeCtx, pStream->codecpar);
  if (ret < 0)
  {
    printf("初始化解码器上下文失败\n");
    return false;
  }
    // 3.3 打开解码器
    ret = avcodec_open2(pCodeCtx, pCodec, NULL);
    if(ret < 0)
    {
        printf("无法打开编解码\n");
        return false;
    }
  AVFrame* pFrame = NULL;
  pFrame = av_frame_alloc();
  if (NULL == pFrame)
  {
    printf("av_frame_alloc is error\n");
    return false;
  }
  int index = 0;
  AVPacket avpkt;
  while (av_read_frame(pFormatCtx, &avpkt) >= 0)
  {
    if (avpkt.stream_index == vecdio_stream_index)
    {
      ret = avcodec_send_packet(pCodeCtx, &avpkt);
      if (ret < 0)
      {
        continue;
      }
      while (avcodec_receive_frame(pCodeCtx, pFrame) == 0)
      {
        SaveFramePicture(pFrame, dstDir, index);
      }
      index++;
      if (index == num)
      {
        break;
      }
    }
    av_packet_unref(&avpkt);
  }
    avcodec_close(pCodeCtx);
    avformat_close_input(&pFormatCtx);
    return true;
}
bool AVInterface::SaveFramePicture(AVFrame* pFrame, const char* dstDir, int index)
{
    char szFilename[256] = {0};
    snprintf(szFilename, sizeof(szFilename), "%s/ffmpeg-%d.png", dstDir, index);
    int ret = 0;
  int width  = pFrame->width;
  int height = pFrame->height;
    // 1.初始化图片封装格式的结构体
    AVCodecContext*  pCodeCtx = NULL;
    AVFormatContext* pFormatCtx = NULL;
    pFormatCtx = avformat_alloc_context(); 
    // 2.设置封装格式
  // MJPEG格式:按照25帧/秒速度使用JPEG算法压缩视频信号,完成动态视频的压缩 --> 视频文件使用MJPEG进行解压
    pFormatCtx->oformat = av_guess_format("mjpeg", NULL, NULL);  // 用于从已经注册的输出格式中寻找最匹配的输出格式
    // 3.创建AVIOContext对象：打开文件  
    ret = avio_open(&pFormatCtx->pb, szFilename, AVIO_FLAG_READ_WRITE); // 读写方式
    if(ret < 0)
    {
        printf("avio_open is error");
        return false;
    }
    // 构建一个新的stream
    AVStream* pAVStream = NULL;
    pAVStream = avformat_new_stream(pFormatCtx, 0);
    if(pAVStream == NULL)
    {
        printf("avformat_new_stream\n");
        return false;
    }
    AVCodecParameters* parameters = NULL;                    // 编码器参数的结构体
    parameters = pAVStream->codecpar;                        // 设置编码器 mjpeg
    parameters->codec_id = pFormatCtx->oformat->video_codec; // 视频流
    parameters->codec_type = AVMEDIA_TYPE_VIDEO;             // 编码类型
    //parameters->format = AV_PIX_FMT_BGR24;                 // 指定图片的显示样式
  parameters->format = AV_PIX_FMT_YUVJ420P;                // YUV 解压缩显示样式都是YUV
    parameters->width  = pFrame->width;                      // 指定图片的宽度
    parameters->height = pFrame->height;                     // 显示图片的高度
    // 找到相应的解码器
    const AVCodec* pCodec = avcodec_find_encoder(pAVStream->codecpar->codec_id);
    if(NULL == pCodec)
    {
        printf("avcodec_find_encoder is error\n");
        return false;
    }
    // 初始化解码器上下文
    pCodeCtx = avcodec_alloc_context3(pCodec);
    if(NULL == pCodeCtx)
    {
        printf("avcodec_alloc_context3 is error\n");
        return false;
    }
    // 设置解码器的参数
    //ret = avcodec_parameters_to_context(pCodeCtx, pAVStream->codecpar);
  ret = avcodec_parameters_to_context(pCodeCtx, parameters);
  if(ret < 0)
    {
        printf("avcodec_parameters_to_context is error\n");
        return false;
    }
  AVRational avrational = {1, 25};       
  pCodeCtx->time_base = avrational;
  // 打开编解码器
    ret = avcodec_open2(pCodeCtx, pCodec, NULL);
    if(ret < 0)
    {
        printf("avcodec_open2 is error\n");
        return false;
    }
    // 封装格式的头部信息写入
    ret = avformat_write_header(pFormatCtx, NULL);
    if(ret < 0)
    {
        printf("avformat_write_header is error\n");
        return false;
    }
    // 给AVPacket分配足够大的空间
    int y_size = width * height;    // 分辨率
    AVPacket pkt;
    av_new_packet(&pkt, y_size * 3);
    // 编码数据
    ret = avcodec_send_frame(pCodeCtx, pFrame);
    if(ret < 0)
    {
        printf("avcodec_send_frame is error\n");
        return false;
    }
    // 得到解码之后的数据
    ret = avcodec_receive_packet(pCodeCtx, &pkt);
    if(ret < 0)
    {
        printf("avcodec_receive_packet is error\n");
        return false;
    }
    ret = av_write_frame(pFormatCtx, &pkt);
    if(ret < 0)
    {
        printf("av_write_frame is error\n");
        return false;
    }
  av_packet_unref(&pkt);
  av_write_trailer(pFormatCtx);
  avcodec_close(pCodeCtx);
  avio_close(pFormatCtx->pb);
  avformat_free_context(pFormatCtx);
    return true;
}

#include <iostream>
#include <win_func.h>
#include <Audio.h>
#include <Model.h>
#include <string.h>
using namespace std;
bool externContext(const char* src, const char* dst)
{
    Audio audio(0);           // 申请一个音频处理的对象
    audio.loadwav(src);       // 加载文件
    audio.disp();             // 分析格式
    // Model* mm = create_model("/home/chen/FastASR/models/k2_rnnt2_cli", 2); // 创建一个预训练模型
    Model* mm = create_model("/home/chen/FastASR/models/paraformer_cli", 3);
    audio.split();           // 解析文件
    float* buff = NULL;      // fftw3数据分析
    int len = 0;
    int flag = false;
    char buf[1024];
    // 一行一行的取出内容
    FILE* fp = NULL;
    fp = fopen(dst, "w+");
    if(NULL == fp)
    {
        printf("打开文件失败\n");
    }
    printf("0.---------------------->\n");
    while(audio.fetch(buff, len , flag) > 0)
    {
        printf("1.---------------------->\n");
        mm->reset();
        string msg = mm->forward(buff, len, flag);
        memset(buf, 0, sizeof(buf));
        snprintf(buf, sizeof(buf), "%s", msg.c_str());
        fseek(fp, 0, SEEK_END);
        fprintf(fp, "%s\n", buf);
        fflush(fp);
        printf("2.--------------------->\n");
    }
    printf("3.------------------------>\n");
    return true;
}
int main(void)
{
    externContext("./long.wav", "./Context.txt");
    return 0;
}

flags:= -I ./include
flags+= -L ./lib -lfastasr -lfftw3 -lfftw3f -lblas  -lwebrtcvad
src_cpp=$(wildcard ./*.cpp)
debug:
  g++ -g $(src_cpp) -omain $(flags) -std=c++11