apollo::audio 命名空间参考

apollo::audio 更多...

类
class	AudioComponent
struct	AudioConf
struct	AudioDetection
struct	AudioEvent
class	AudioInfo
class	DirectionDetection
class	MessageProcess
class	MovingDetection
class	SirenDetection
struct	TopicConf

枚举
enum	MovingResult { UNKNOWN = 0 , APPROACHING = 1 , DEPARTING = 2 , STATIONARY = 3 }
enum	AudioType { UNKNOWN_TYPE = 0 , POLICE = 1 , AMBULANCE = 2 , FIRETRUCK = 3 }
enum	AudioDirection {   UNKNOWN_DIRECTION = 0 , FRONT = 1 , LEFT = 2 , BACK = 3 ,   RIGHT = 4 }

函数
void	GetRecordFileNames (const boost::filesystem::path &p, std::vector< std::string > *record_files)
void	ProcessSingleRecordFile (const AudioConf &audio_conf, const std::string &input_record_filepath, const std::string &output_record_filepath, AudioInfo *audio_info, DirectionDetection *direction_detection, MovingDetection *moving_detection, SirenDetection *siren_detection)
void	ProcessFolder ()

详细描述

apollo::audio

枚举类型说明

AudioDirection

enum apollo::audio::AudioDirection

枚举值
UNKNOWN_DIRECTION
FRONT
LEFT
BACK
RIGHT

在文件 audio_common.proto 第 35 行定义.

                    {
  UNKNOWN_DIRECTION = 0;
  FRONT = 1;
  LEFT = 2;
  BACK = 3;
  RIGHT = 4;
}

AudioType

enum apollo::audio::AudioType

枚举值
UNKNOWN_TYPE
POLICE
AMBULANCE
FIRETRUCK

在文件 audio_common.proto 第 28 行定义.

               {
  UNKNOWN_TYPE = 0;
  POLICE = 1;
  AMBULANCE = 2;
  FIRETRUCK = 3;
}

MovingResult

enum apollo::audio::MovingResult

枚举值
UNKNOWN
APPROACHING
DEPARTING
STATIONARY

在文件 audio_common.proto 第 21 行定义.

                  {
  UNKNOWN = 0;
  APPROACHING = 1;
  DEPARTING = 2;
  STATIONARY = 3;
}

函数说明

GetRecordFileNames()

void apollo::audio::GetRecordFileNames	(	const boost::filesystem::path &	p,
		std::vector< std::string > *	record_files
	)

在文件 audio_offline_processing.cc 第 42 行定义.

                                                            {
  if (!boost::filesystem::exists(p)) {
    return;
  }
  if (boost::filesystem::is_regular_file(p)) {
    AINFO << "Found record file: " << p.c_str();
    record_files->push_back(p.c_str());
    return;
  }
  if (boost::filesystem::is_directory(p)) {
    for (auto& entry : boost::make_iterator_range(
             boost::filesystem::directory_iterator(p), {})) {
      GetRecordFileNames(entry.path(), record_files);
    }
  }
}

ProcessFolder()

void apollo::audio::ProcessFolder

(

)

在文件 audio_offline_processing.cc 第 116 行定义.

                     {
  if (FLAGS_audio_records_dir.empty()) {
    AERROR << "The input folder is empty";
    return;
  }
  AudioConf audio_conf;
  if (!cyber::common::GetProtoFromFile(FLAGS_audio_conf_file,
                                       &audio_conf)) {
    return;
  }
  AudioInfo audio_info;
  DirectionDetection direction_detection;
  MovingDetection moving_detection;
  SirenDetection siren_detection;
  std::vector<std::string> offline_bags;
  GetRecordFileNames(boost::filesystem::path(FLAGS_audio_records_dir),
                     &offline_bags);
  std::sort(offline_bags.begin(), offline_bags.end());
  for (std::size_t i = 0; i < offline_bags.size(); ++i) {
    const std::string& input_record_filepath = offline_bags[i];
    std::string output_record_filepath =
        input_record_filepath + ".new_audio_detection";
    ProcessSingleRecordFile(audio_conf, input_record_filepath,
        output_record_filepath, &audio_info, &direction_detection,
        &moving_detection, &siren_detection);
  }
}

ProcessSingleRecordFile()

void apollo::audio::ProcessSingleRecordFile	(	const AudioConf &	audio_conf,
		const std::string &	input_record_filepath,
		const std::string &	output_record_filepath,
		AudioInfo *	audio_info,
		DirectionDetection *	direction_detection,
		MovingDetection *	moving_detection,
		SirenDetection *	siren_detection
	)

在文件 audio_offline_processing.cc 第 60 行定义.

                                     {
  RecordReader reader(input_record_filepath);
  RecordMessage message;
  RecordWriter writer;
  writer.Open(output_record_filepath);
  while (reader.ReadMessage(&message)) {
    if (message.channel_name ==
        audio_conf.topic_conf().audio_data_topic_name()) {
      AudioData audio_data;
      if (audio_data.ParseFromString(message.content)) {
        AudioDetection audio_detection;
        std::string respeaker_extrinsics_file =
            audio_conf.respeaker_extrinsics_path();
        MessageProcess::OnMicrophone(audio_data, respeaker_extrinsics_file,
            audio_info, direction_detection, moving_detection, siren_detection,
            &audio_detection);
        writer.WriteMessage<AudioDetection>(
            audio_conf.topic_conf().audio_detection_topic_name(),
            audio_detection, message.time);
        AINFO << "Generate a new audio detection message.";
      }
    } else if (message.channel_name ==
               audio_conf.topic_conf().audio_event_topic_name()) {
      AudioEvent audio_event;
      if (audio_event.ParseFromString(message.content)) {
        writer.WriteMessage<AudioEvent>(message.channel_name, audio_event,
                                        message.time);
        AINFO << "Save an audio even message.";
      }
    } else if (message.channel_name ==
                 audio_conf.topic_conf().localization_topic_name()) {
      LocalizationEstimate localization;
      if (localization.ParseFromString(message.content)) {
        writer.WriteMessage<LocalizationEstimate>(
            message.channel_name, localization, message.time);
        AINFO << "Save a localization message.";
      }
    } else if (message.channel_name ==
                 audio_conf.topic_conf().perception_topic_name()) {
      PerceptionObstacles perception_obstacles;
      if (perception_obstacles.ParseFromString(message.content)) {
        writer.WriteMessage<PerceptionObstacles>(
            message.channel_name, perception_obstacles, message.time);
        AINFO << "Save a perception message.";
      }
    }
  }
  writer.Close();
}