5. 框架集成

5.1. FFmpeg

基于FFmpeg在多媒体领域的广泛应用和用户的开发需求，曦云系列GPU支持将MCRUNTIME中VPU和G2D集成到FFmpeg中，并选取FFmpeg4.3作为集成的基线。

5.1.1. FFmpeg编码流程

FFmpeg编码调用流程如下图所示：

../_images/image5.png — 图 5.1 FFmpeg编码调用流程

avcodec_find_encoder_by_name ：通过编码器的名称找到对应的编码器。

FFmpeg支持H264、HEVC和JPEG三种编码器，分别对应名称为：h264_mxenc、hevc_mxenc和mjpeg_mxenc。用户只需要输入这些名字就可以找到对应的编码器。
avcodec_alloc_context3 ：获取编解码器上下文信息。
av_hwdevice_ctx_create ：初始化相关硬件设备，只需要输入硬件名称 mx 就可以初始化硬件设备。
avcodec_open2 ：调用 Init 函数，初始化编码器。
avcodec_send_frame ：将需要编码的Frame数据发送到FFmpeg编码队列中。
avcodec_receive_packet ：从成功编码的包队列中获取一帧Packet数据。
av_free ：释放编码器。

5.1.2. FFmpeg解码流程

FFmpeg解码调用流程如下图所示：

../_images/image6.png — 图 5.2 FFmpeg解码调用流程

av_register_all ：注册所有codec。最新发布的FFmpeg中不需要调用此函数。
avformat_open_input ：初始化参数结构体，输入数据协议的识别（通过文件名后缀或读取文件头的数据进行比对）。
avformat_find_stream_info ：读取一些包的内容，然后从中提取流信息。
avcodec_find_decoder_by_name ：通过解码器的名称找到对应的解码器。

FFmpeg支持H264、HEVC、AV1、AVS2和JPEG五种解码器，分别对应名称为：h264_mxvid、hevc_mxvid、av1_mxvid、avs2_mxvid和mjpeg_mxvid。下方代码示例会自动设置解码器名称，并找到对应的解码器。
avcodec_alloc_context3 ：获取编解码器上下文信息。
av_hwdevice_ctx_create ：初始化相关硬件设备，只需要输入硬件名称 mx 就可以初始化硬件设备。
avcodec_open2 ：调用 Init 函数，初始化编解码。
av_read_frame ：获取一帧解码码流。
avcodec_send_packet ：发送包数据到FFmpeg解码队列中。
avcodec_receive_frame ：从成功解码的帧队列中获取一帧Frame数据。
av_free ：释放解码器。

5.1.3. 代码示例

FFmpeg解码代码如下所示：

#include <stdio.h>
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavutil/pixdesc.h>
#include <libavutil/hwcontext.h>
#include <libavutil/opt.h>
#include <libavutil/avassert.h>
#include <libavutil/imgutils.h>

static AVBufferRef *hw_device_ctx = NULL;
static enum AVPixelFormat hw_pix_fmt;
static FILE *output_file = NULL;

static int hw_decoder_init(AVCodecContext *ctx, const enum AVHWDeviceType type)
{
   int err = 0;
   if ((err = av_hwdevice_ctx_create(&hw_device_ctx, type, NULL, NULL, 0)) < 0) {
      fprintf(stderr, "Failed to create specified HW device.\n");
      return err;
   }
   ctx->hw_device_ctx = av_buffer_ref(hw_device_ctx);
   return err;
}

static enum AVPixelFormat get_hw_format(AVCodecContext *ctx, const enum AVPixelFormat *pix_fmts)
{
   const enum AVPixelFormat *p;
   for (p = pix_fmts; *p != -1; p++) {
      if (*p == hw_pix_fmt)
         return *p;
   }

   fprintf(stderr, "Failed to get HW surface format.\n");
   return AV_PIX_FMT_NONE;
}

static int decode_write(AVCodecContext *avctx, AVPacket *packet)
{

   AVFrame *frame = NULL, *sw_frame = NULL;
   AVFrame *tmp_frame = NULL;
   uint8_t *buffer = NULL;
   int size;
   int ret = 0;

   ret = avcodec_send_packet(avctx, packet);

   if (ret < 0) {
      fprintf(stderr, "Error during decoding\n");
      return ret;
   }

   while (1) {
      if (!(frame = av_frame_alloc()) || !(sw_frame = av_frame_alloc())) {
         fprintf(stderr, "Can not alloc frame\n");
         ret = AVERROR(ENOMEM);
         goto fail;
      }

      ret = avcodec_receive_frame(avctx, frame);
      if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
         av_frame_free(&frame);
         av_frame_free(&sw_frame);
         return 0;
      } else if (ret < 0) {
         fprintf(stderr, "Error while decoding\n");
         goto fail;
      }

      if (frame->format == hw_pix_fmt) {
      /* retrieve data from GPU to CPU */
      if ((ret = av_hwframe_transfer_data(sw_frame, frame, 0)) < 0) {
         fprintf(stderr, "Error transferring the data to system memory\n");
         goto fail;
      }

      tmp_frame = sw_frame;

      } else
      tmp_frame = frame;

      size = av_image_get_buffer_size(tmp_frame->format, tmp_frame->width, tmp_frame->height, 1);

      buffer = av_malloc(size);

      if (!buffer) {
         fprintf(stderr, "Can not alloc buffer\n");
         ret = AVERROR(ENOMEM);
         goto fail;
      }

      ret = av_image_copy_to_buffer(buffer, size, (const uint8_t * const *)tmp_frame->data,
                                    (const int *)tmp_frame->linesize, tmp_frame->format,
                                    tmp_frame->width, tmp_frame->height, 1);

      if (ret < 0) {
         fprintf(stderr, "Can not copy image to buffer\n");
         goto fail;
      }

      if ((ret = fwrite(buffer, 1, size, output_file)) < 0) {
         fprintf(stderr, "Failed to dump raw data.\n");
         goto fail;
      }

   fail:
      av_frame_free(&frame);
      av_frame_free(&sw_frame);
      av_freep(&buffer);

      if (ret < 0)
         return ret;

   }

}

int main(int argc, char *argv[])
{
   AVFormatContext *input_ctx = NULL;
   int video_stream, ret;
   AVStream *video = NULL;
   AVCodecContext *decoder_ctx = NULL;
   AVCodec *decoder = NULL;
   AVPacket packet;

   const char *hwdevice = "";
   enum AVHWDeviceType type;
   int i;

   if (argc < 4) {
      fprintf(stderr, "Usage: %s <device type> <input file> <output file>\n", argv[0]);
      // example: xx metax input.mp4 out.yuv xx 是程序名
      return -1;
   }

   type = av_hwdevice_find_type_by_name(argv[1]);

   if (type == AV_HWDEVICE_TYPE_NONE) {
      fprintf(stderr, "Device type %s is not supported.\n", argv[1]);
      fprintf(stderr, "Available device types:");
      while((type = av_hwdevice_iterate_types(type)) != AV_HWDEVICE_TYPE_NONE)
      fprintf(stderr, " %s", av_hwdevice_get_type_name(type));
      fprintf(stderr, "\n");
      return -1;
   }

   /* open the input file */

   if (avformat_open_input(&input_ctx, argv[2], NULL, NULL) != 0) {
      fprintf(stderr, "Cannot open input file '%s'\n", argv[2]);
      return -1;
   }

   if (avformat_find_stream_info(input_ctx, NULL) < 0) {
      fprintf(stderr, "Cannot find input stream information.\n");
      return -1;
   }

   /* find the video stream information */

   ret = av_find_best_stream(input_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, &decoder, 0);

   if (ret < 0) {
      fprintf(stderr, "Cannot find a video stream in the input file\n");
      return -1;
   }

   video_stream = ret;

   switch (decoder->id) {
      case AV_CODEC_ID_H264:
      hwdevice = "h264_mxvid";
      break;

      case AV_CODEC_ID_HEVC:
      hwdevice = "hevc_mxvid";
      break;

      case AV_CODEC_ID_MJPEG:
      hwdevice = "mjpeg_mxvid";
      break;

      case AV_CODEC_ID_AVS2:
      hwdevice = "avs2_mxvid";
      break;

      case AV_CODEC_ID_AV1:
      hwdevice = "av1_mxvid";
      break;

      default:
      break;
   }

   if(strlen(hwdevice)){
      decoder = avcodec_find_decoder_by_name(hwdevice);
      fprintf(stderr, "Decoder %s find device type %s.\n", hwdevice, av_hwdevice_get_type_name(type));
   }

   for (i = 0;; i++) {
      const AVCodecHWConfig *config = avcodec_get_hw_config(decoder, i);

      if (!config) {
         fprintf(stderr, "Decoder %s does not support device type %s.\n",
         decoder->name, av_hwdevice_get_type_name(type));
         return -1;
      }

      if (config->methods & AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX && config->device_type == type) {
         hw_pix_fmt = config->pix_fmt;
         break;
      }

   }

   if (!(decoder_ctx = avcodec_alloc_context3(decoder)))

      return AVERROR(ENOMEM);

   video = input_ctx->streams[video_stream];

   if (avcodec_parameters_to_context(decoder_ctx, video->codecpar) < 0)

      return -1;

   decoder_ctx->get_format = get_hw_format;

   if (hw_decoder_init(decoder_ctx, type) < 0)

      return -1;

   if ((ret = avcodec_open2(decoder_ctx, decoder, NULL)) < 0) {
      fprintf(stderr, "Failed to open codec for stream #%u\n", video_stream);
      return -1;
   }

   /* open the file to dump raw data */
   output_file = fopen(argv[3], "w+");
   /* actual decoding and dump the raw data */

   while (ret >= 0) {
      if ((ret = av_read_frame(input_ctx, &packet)) < 0)
         break;

      if (video_stream == packet.stream_index)
         ret = decode_write(decoder_ctx, &packet);
      av_packet_unref(&packet);
   }

   /* flush the decoder */
   packet.data = NULL;
   packet.size = 0;
   ret = decode_write(decoder_ctx, &packet);
   av_packet_unref(&packet);

   if (output_file)
      fclose(output_file);

   avcodec_free_context(&decoder_ctx);
   avformat_close_input(&input_ctx);
   av_buffer_unref(&hw_device_ctx);
   return 0;
}