FrameProcessor is a class to process video streams. 更多...

#include <frame_processor.h>

apollo::drivers::video::FrameProcessor 的协作图:

Public 成员函数
	FrameProcessor (const std::string &input_video_file, const std::string &output_jpg_dir)

bool	ProcessStream () const

	~FrameProcessor ()=default

详细描述

FrameProcessor is a class to process video streams.

在文件 frame_processor.h 第 30 行定义.

构造及析构函数说明

◆ FrameProcessor()

apollo::drivers::video::FrameProcessor::FrameProcessor	(	const std::string &	input_video_file,
		const std::string &	output_jpg_dir
	)

在文件 frame_processor.cc 第 31 行定义.

    : output_jpg_dir_(output_jpg_dir) {
  std::ifstream video_file(input_video_file, std::ios::binary);
  std::istreambuf_iterator<char> buf_begin(video_file), buf_end;
  while (buf_begin != buf_end) {
    input_video_buffer_.emplace_back(*buf_begin++);
  }
}

◆ ~FrameProcessor()

apollo::drivers::video::FrameProcessor::~FrameProcessor ( )

default

成员函数说明

◆ ProcessStream()

bool apollo::drivers::video::FrameProcessor::ProcessStream ( ) const

在文件 frame_processor.cc 第 41 行定义.

                                         {
  if (input_video_buffer_.empty()) {
    AERROR << "error: failed to read from input video file";
    return false;
  }
  AVCodecParserContext* codec_parser = av_parser_init(AV_CODEC_ID_H265);
  if (codec_parser == nullptr) {
    AERROR << "error: failed to init AVCodecParserContext";
    return false;
  }
  AVPacket apt;
  av_init_packet(&apt);
  const std::unique_ptr<H265Decoder> decoder(new H265Decoder());
  if (!decoder->Init()) {
    AERROR << "error: failed to init decoder";
    return false;
  }
  uint32_t local_size = static_cast<uint32_t>(input_video_buffer_.size());
  uint8_t* local_data = const_cast<uint8_t*>(input_video_buffer_.data());
  AINFO << "decoding: video size = " << local_size;
  int frame_num = 0;
  int warn_frame_num = 0;
  std::vector<uint8_t> jpeg_buffer;
  while (local_size > 0) {
    int frame_len = av_parser_parse2(
        codec_parser, decoder->GetCodecCtxH265(), &(apt.data), &(apt.size),
        local_data, local_size, AV_NOPTS_VALUE, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
    if (apt.data == nullptr) {
      apt.data = local_data;
      apt.size = local_size;
    }
    AINFO << "frame " << frame_num << ": frame_len=" << frame_len
          << ". left_size=" << local_size;
    const auto decoding_result =
        decoder->Process(apt.data, apt.size, &jpeg_buffer);
    if (decoding_result != H265Decoder::DecodingResult::WARN) {
      // Write to output even if failed to convert, in order to
      // maintain the order of frames
      WriteOutputJpgFile(jpeg_buffer, GetOutputFile(frame_num));
      ++frame_num;
    } else {
      // Retry later if returns warn, which indicates reading more from buffer
      ++warn_frame_num;
    }
    local_data += frame_len;
    local_size -= frame_len;
  }
  // Decode the left over frames from buffer exactly warning times
  for (int i = warn_frame_num; i > 0; --i) {
    // When retry to decode from buffer, we do not care if it succeeds or not
    decoder->Process(nullptr, 0, &jpeg_buffer);
    WriteOutputJpgFile(jpeg_buffer, GetOutputFile(frame_num));
    AINFO << "frame " << frame_num << ": read from buffer";
    ++frame_num;
  }
  AINFO << "total frames: " << frame_num;
  av_parser_close(codec_parser);
  return true;
}

该类的文档由以下文件生成: