diff --git a/Record/CMakeLists.txt b/Record/CMakeLists.txt index dfcb872..4b86771 100644 --- a/Record/CMakeLists.txt +++ b/Record/CMakeLists.txt @@ -6,6 +6,7 @@ add_executable(Record main.cpp FFmpegResample.h FFmpegResample.cpp EchoRecord.cpp Player.cpp + ProcessFile.cpp Recorder.cpp SpeexDsp.h SpeexDsp.cpp Utility.h Utility.cpp @@ -21,6 +22,7 @@ target_include_directories(Record PRIVATE /opt/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/lib/amazon-kinesis-video-streams-webrtc-sdk-c/include PRIVATE /opt/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/lib/speexdsp-1.2.1/include PRIVATE ${FFMPEG_INCLUDE_DIR} + # PRIVATE ${CMAKE_SOURCE_DIR}/rkap/include ) target_link_directories(Record @@ -33,6 +35,7 @@ target_link_directories(Record PRIVATE /opt/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/lib/amazon-kinesis-video-streams-webrtc-sdk-c/lib PRIVATE /opt/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/lib/usrsctp-0.9.5.0/lib PRIVATE /opt/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/lib/libsrtp-2.6.0/lib + # PRIVATE ${CMAKE_SOURCE_DIR}/rkap/lib ) target_link_libraries(Record @@ -73,4 +76,6 @@ target_link_libraries(Record PRIVATE dl PRIVATE z PRIVATE ${FFMPEG_LIBRARY} + # PRIVATE RKAP_Common + # PRIVATE RKAP_3A ) \ No newline at end of file diff --git a/Record/EchoRecord.cpp b/Record/EchoRecord.cpp index 176e9c9..0024c90 100644 --- a/Record/EchoRecord.cpp +++ b/Record/EchoRecord.cpp @@ -1,4 +1,5 @@ #include "BoostLog.h" +#include "DateTime.h" #include "SpeexDsp.h" #include "Utility.h" #include "WebRtcAecm.h" @@ -39,6 +40,21 @@ void EchoRecordTask::setDsp(Dsp dsp) { } } +void EchoRecordTask::setDumpEnabled(bool enabled) { + if (enabled) { + auto date = DateTime::currentDateTime().toString("%Y%m%d%H%M%S"); + std::ostringstream oss; + oss << DumpPath << "/mic_" << date << ".pcm"; + auto filePath = oss.str(); + m_micOfs = std::make_shared(filePath, std::ofstream::binary); + + oss.str(""); + oss << DumpPath << "/speak_" << dspToString(m_dsp) << "_" << date << ".pcm"; + filePath = oss.str(); + m_outOfs = std::make_shared(filePath, std::ofstream::binary); + } +} + void EchoRecordTask::setChannels(int channels) { if (m_channels != channels) { m_channels = channels; @@ -54,6 +70,7 @@ void EchoRecordTask::run() { LOG(info) << "dsp use: " << dspToString(m_dsp); RkAudio::Format format; + format.sampleRate = 16000; format.channels = m_channels; format.period = 10; @@ -77,6 +94,9 @@ void EchoRecordTask::run() { m_input = std::make_shared(); m_input->setDataCallback([this, format](const RkAudio::Frame &frame) { + if (m_micOfs) { + m_micOfs->write(reinterpret_cast(frame.data), frame.byteSize); + } memcpy(m_nearendBuffer.data(), frame.data, frame.byteSize); if (m_dsp == Speex) { m_speex->echoPlayback(reinterpret_cast(m_farendBuffer.data())); @@ -100,6 +120,10 @@ void EchoRecordTask::run() { m_d->nearendBuffer->CopyTo(config, reinterpret_cast(m_outBuffer.data())); } + if (m_outOfs) { + m_outOfs->write(reinterpret_cast(m_outBuffer.data()), m_outBuffer.size()); + } + if (m_channels == 2) { m_output->write(frame.data, frame.byteSize); } else if (m_channels == 1) { diff --git a/Record/ProcessFile.cpp b/Record/ProcessFile.cpp new file mode 100644 index 0000000..8a7a8a8 --- /dev/null +++ b/Record/ProcessFile.cpp @@ -0,0 +1,114 @@ +#include "IoContext.h" +#include "RKAP_3A.h" +#include "SpeexDsp.h" +#include "WebRtcAecm.h" +#include "api/audio/echo_canceller3_config.h" +#include "api/audio/echo_canceller3_factory.h" +#include "main.h" +#include "modules/audio_processing/aec3/echo_canceller3.h" +#include +#include + +class ProcessFileTaskPrivate { +public: + void initialize(int sampleRate, int channels, int period) { + std::unique_ptr factory = std::make_unique(); + echoCanceller = factory->Create(sampleRate, channels, channels); + nearendBuffer = std::make_unique(sampleRate, channels, sampleRate, channels, sampleRate, channels); + farendBuffer = std::make_unique(sampleRate, channels, sampleRate, channels, sampleRate, channels); + linearOutputBuffer = std::make_unique(sampleRate, channels, sampleRate, channels, sampleRate, channels); + + RKAP_3A_Init(&m_vqe, AEC_TX_TYPE); + } + + std::unique_ptr echoCanceller; + std::unique_ptr nearendBuffer; + std::unique_ptr farendBuffer; + std::unique_ptr linearOutputBuffer; + + RKAP_AEC_State m_vqe; +}; + +ProcessFileTask::ProcessFileTask() : m_d{new ProcessFileTaskPrivate()} { +} + +ProcessFileTask::~ProcessFileTask() { + if (m_d != nullptr) { + delete m_d; + } +} + +void ProcessFileTask::setDsp(Dsp dsp) { + if (m_dsp != dsp) { + m_dsp = dsp; + } +} + +// ./Record --file --dsp=aecm +void ProcessFileTask::run() { + m_speakerIfs = std::make_shared("/sdcard/speaker_16k.pcm", std::ifstream::binary); + m_micIfs = std::make_shared("/sdcard/micin_16k.pcm", std::ifstream::binary); + + std::ostringstream oss; + oss << DumpPath << "/out_" << dspToString(m_dsp) << "_16k.pcm"; + m_outFilename = oss.str(); + m_ofs = std::make_shared(m_outFilename, std::ofstream::binary); + + // m_speakerIfs = std::make_shared("/sdcard/speaker_8k.pcm", std::ifstream::binary); + // m_micIfs = std::make_shared("/sdcard/micin_8k.pcm", std::ifstream::binary); + // m_ofs = std::make_shared("/sdcard/out_8k.pcm", std::ofstream::binary); + + m_webRtcAecm = std::make_shared(); + m_webRtcAecm->start(16000, 1, 10); + + m_speex = std::make_shared(); + m_speex->start(16000, 1, 10); + + m_d->initialize(16000, 1, 10); + m_begin = std::chrono::system_clock::now(); + process(); +} + +void ProcessFileTask::process() { + using namespace Amass; + auto ioConext = Singleton::instance(); + if (m_speakerIfs && m_micIfs && *m_speakerIfs && *m_micIfs) { + char farendBuffer[sizeof(int16_t) * 16000 / 1000 * 10] = {0}; + char nearendBuffer[sizeof(int16_t) * 16000 / 1000 * 10] = {0}; + char outBuffer[sizeof(int16_t) * 16000 / 1000 * 10] = {0}; + // char farendBuffer[sizeof(int16_t) * 8000 / 1000 * 10] = {0}; + // char nearendBuffer[sizeof(int16_t) * 8000 / 1000 * 10] = {0}; + // char outBuffer[sizeof(int16_t) * 8000 / 1000 * 10] = {0}; + + m_speakerIfs->read(farendBuffer, sizeof(farendBuffer)); + m_micIfs->read(nearendBuffer, sizeof(nearendBuffer)); + if (m_dsp == Speex) { + m_speex->echoPlayback(reinterpret_cast(farendBuffer)); + m_speex->echoCapture(reinterpret_cast(nearendBuffer), reinterpret_cast(outBuffer)); + } else if (m_dsp == AecMobile) { + m_webRtcAecm->echoPlayback(reinterpret_cast(farendBuffer), sizeof(farendBuffer) / 2); + m_webRtcAecm->echoCancellation(reinterpret_cast(nearendBuffer), nullptr, reinterpret_cast(outBuffer), + sizeof(farendBuffer) / 2); + } else if (m_dsp == Aec3) { + webrtc::StreamConfig config(16000, 1); // 单声道 + m_d->nearendBuffer->CopyFrom(reinterpret_cast(nearendBuffer), config); + + m_d->farendBuffer->CopyFrom(reinterpret_cast(farendBuffer), config); + + m_d->echoCanceller->AnalyzeRender(m_d->farendBuffer.get()); + m_d->echoCanceller->AnalyzeCapture(m_d->nearendBuffer.get()); + m_d->echoCanceller->ProcessCapture(m_d->nearendBuffer.get(), false); + // m_d->echoCanceller->ProcessCapture(&nearendBuffer, &linearOutputBuffer, /*level_change=*/false); + + m_d->nearendBuffer->CopyTo(config, reinterpret_cast(outBuffer)); + } else if (m_dsp == Vqe) { + } + + m_ofs->write(outBuffer, sizeof(outBuffer)); + boost::asio::post(*ioConext->ioContext(), [this]() { process(); }); + } else { + auto elapsed = std::chrono::duration_cast(std::chrono::system_clock::now() - m_begin); + LOG(info) << "process file finished, out: " << m_outFilename << ", elapsed: " << elapsed; + std::exit(0); + } +} \ No newline at end of file diff --git a/Record/Recorder.cpp b/Record/Recorder.cpp index 6c5981e..b39a8be 100644 --- a/Record/Recorder.cpp +++ b/Record/Recorder.cpp @@ -5,12 +5,8 @@ #include void RecorderTask::run() { - constexpr auto path = "/sdcard/data"; - if (!std::filesystem::exists(path)) { - std::filesystem::create_directory(path); - } std::ostringstream oss; - oss << path << "/" << DateTime::currentDateTime().toString("%Y%m%d%H%M%S") << ".pcm"; + oss << DumpPath << "/" << DateTime::currentDateTime().toString("%Y%m%d%H%M%S") << ".pcm"; auto filePath = oss.str(); m_ofs = std::make_shared(filePath, std::ofstream::binary); diff --git a/Record/main.cpp b/Record/main.cpp index 05a7f4d..57d9206 100644 --- a/Record/main.cpp +++ b/Record/main.cpp @@ -1,17 +1,14 @@ #include "main.h" #include "BoostLog.h" -#include "DateTime.h" #include "FFmpegResample.h" #include "IoContext.h" -#include "OpusCodec.h" -#include "RkAudio.h" #include "WebRTCPublisher.h" #include -// #include #include #include #include #include +#include #include #include @@ -34,9 +31,11 @@ int main(int argc, char **argv) { ("echo", "Self-recording and self-play test") ("record", "Record to file.") ("play", "Play pcm file.") - ("dsp", boost::program_options::value(), "vqe, speex, aecm") + ("file", "process file.") + ("dsp", boost::program_options::value()->default_value("aecm"), "vqe, speex, aecm") ("channels", boost::program_options::value(), "set audio channles") ("path", boost::program_options::value(), "file path") + ("dump,d", boost::program_options::value()->default_value(false), "dump file.") ; // clang-format on @@ -51,19 +50,15 @@ int main(int argc, char **argv) { std::shared_ptr task; if (variablesMap.count("echo")) { - Dsp dsp = Vqe; - if (variablesMap.count("dsp")) { - dsp = dspFromString(variablesMap["dsp"].as()); - } - int channels = 2; if (variablesMap.count("channels")) { channels = variablesMap["channels"].as(); } auto t = std::make_shared(); - t->setDsp(dsp); + t->setDsp(dspFromString(variablesMap["dsp"].as())); t->setChannels(channels); + t->setDumpEnabled(variablesMap["dump"].as()); task = std::dynamic_pointer_cast(t); } else if (variablesMap.count("record")) { task = std::make_shared(); @@ -82,6 +77,10 @@ int main(int argc, char **argv) { t->setChannels(channels); t->setPath(path); task = std::dynamic_pointer_cast(t); + } else if (variablesMap.count("file")) { + auto t = std::make_shared(); + t->setDsp(dspFromString(variablesMap["dsp"].as())); + task = std::dynamic_pointer_cast(t); } if (!task) { @@ -89,6 +88,9 @@ int main(int argc, char **argv) { std::cout << optionsDescription << std::endl; return 2; } + if (!std::filesystem::exists(DumpPath)) { + std::filesystem::create_directory(DumpPath); + } try { LOG(info) << "app start."; @@ -116,7 +118,7 @@ Dsp dspFromString(const std::string &dsp) { ret = Speex; } else if (dsp == "aecm") { ret = AecMobile; - }else if (dsp == "aec3") { + } else if (dsp == "aec3") { ret = Aec3; } return ret; diff --git a/Record/main.h b/Record/main.h index a7732ec..7745946 100644 --- a/Record/main.h +++ b/Record/main.h @@ -15,6 +15,8 @@ enum Dsp { Aec3, }; +constexpr auto DumpPath = "/sdcard/data"; + class Task { public: virtual void run() = 0; @@ -54,6 +56,7 @@ public: EchoRecordTask(); ~EchoRecordTask(); void setDsp(Dsp dsp); + void setDumpEnabled(bool enabled); void setChannels(int channels); void run() final; @@ -70,6 +73,31 @@ private: std::vector m_farendBuffer; EchoRecordPrivate *m_d = nullptr; + std::shared_ptr m_outOfs; + std::shared_ptr m_micOfs; +}; + +class ProcessFileTaskPrivate; +class ProcessFileTask : public Task { +public: + ProcessFileTask(); + ~ProcessFileTask(); + void setDsp(Dsp dsp); + void run() final; + +protected: + void process(); + +private: + ProcessFileTaskPrivate *m_d = nullptr; + Dsp m_dsp = Speex; + std::shared_ptr m_speex; + std::shared_ptr m_webRtcAecm; + std::shared_ptr m_speakerIfs; + std::shared_ptr m_micIfs; + std::shared_ptr m_ofs; + std::string m_outFilename; + std::chrono::system_clock::time_point m_begin; }; Dsp dspFromString(const std::string &dsp); diff --git a/VocieProcess/CMakeLists.txt b/VocieProcess/CMakeLists.txt index 7563aa5..a6c4d92 100644 --- a/VocieProcess/CMakeLists.txt +++ b/VocieProcess/CMakeLists.txt @@ -30,6 +30,8 @@ add_library(VocieProcess common_audio/channel_buffer.h common_audio/channel_buffer.cc common_audio/fir_filter_neon.h common_audio/fir_filter_neon.cc common_audio/ring_buffer.h common_audio/ring_buffer.c + common_audio/wav_file.h common_audio/wav_file.cc + common_audio/wav_header.h common_audio/wav_header.cc common_audio/resampler/push_sinc_resampler.h common_audio/resampler/push_sinc_resampler.cc common_audio/resampler/sinc_resampler.h common_audio/resampler/sinc_resampler_neon.cc @@ -74,6 +76,8 @@ add_library(VocieProcess rtc_base/strings/string_builder.h rtc_base/strings/string_builder.cc + rtc_base/system/file_wrapper.h rtc_base/system/file_wrapper.cc + modules/audio_processing/audio_buffer.h modules/audio_processing/audio_buffer.cc modules/audio_processing/high_pass_filter.h modules/audio_processing/high_pass_filter.cc modules/audio_processing/splitting_filter.h modules/audio_processing/splitting_filter.cc @@ -153,10 +157,10 @@ add_library(VocieProcess target_compile_definitions(VocieProcess PRIVATE NOMINMAX # - PRIVATE RTC_DISABLE_LOGGING - PUBLIC RTC_DISABLE_METRICS + # PRIVATE RTC_DISABLE_LOGGING + # PUBLIC RTC_DISABLE_METRICS PUBLIC WEBRTC_HAS_NEON - PUBLIC WEBRTC_APM_DEBUG_DUMP=0 + PUBLIC WEBRTC_APM_DEBUG_DUMP=1 $<$:WEBRTC_WIN> $<$:WEBRTC_POSIX WEBRTC_LINUX> ) diff --git a/VocieProcess/common_audio/wav_file.cc b/VocieProcess/common_audio/wav_file.cc new file mode 100644 index 0000000..127c9c0 --- /dev/null +++ b/VocieProcess/common_audio/wav_file.cc @@ -0,0 +1,290 @@ +/* + * Copyright (c) 2014 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "common_audio/wav_file.h" + +#include + +#include +#include +#include +#include +#include + +#include "common_audio/include/audio_util.h" +#include "rtc_base/checks.h" +#include "rtc_base/system/arch.h" + +namespace webrtc { +namespace { + +static_assert(std::is_trivially_destructible::value, ""); + +// Checks whether the format is supported or not. +bool FormatSupported(WavFormat format) { + // Only PCM and IEEE Float formats are supported. + return format == WavFormat::kWavFormatPcm || + format == WavFormat::kWavFormatIeeeFloat; +} + +// Doesn't take ownership of the file handle and won't close it. +class WavHeaderFileReader : public WavHeaderReader { + public: + explicit WavHeaderFileReader(FileWrapper* file) : file_(file) {} + + WavHeaderFileReader(const WavHeaderFileReader&) = delete; + WavHeaderFileReader& operator=(const WavHeaderFileReader&) = delete; + + size_t Read(void* buf, size_t num_bytes) override { + size_t count = file_->Read(buf, num_bytes); + pos_ += count; + return count; + } + bool SeekForward(uint32_t num_bytes) override { + bool success = file_->SeekRelative(num_bytes); + if (success) { + pos_ += num_bytes; + } + return success; + } + int64_t GetPosition() override { return pos_; } + + private: + FileWrapper* file_; + int64_t pos_ = 0; +}; + +constexpr size_t kMaxChunksize = 4096; + +} // namespace + +WavReader::WavReader(absl::string_view filename) + : WavReader(FileWrapper::OpenReadOnly(filename)) {} + +WavReader::WavReader(FileWrapper file) : file_(std::move(file)) { + RTC_CHECK(file_.is_open()) + << "Invalid file. Could not create file handle for wav file."; + + WavHeaderFileReader readable(&file_); + size_t bytes_per_sample; + RTC_CHECK(ReadWavHeader(&readable, &num_channels_, &sample_rate_, &format_, + &bytes_per_sample, &num_samples_in_file_, + &data_start_pos_)); + num_unread_samples_ = num_samples_in_file_; + RTC_CHECK(FormatSupported(format_)) << "Non-implemented wav-format"; +} + +void WavReader::Reset() { + RTC_CHECK(file_.SeekTo(data_start_pos_)) + << "Failed to set position in the file to WAV data start position"; + num_unread_samples_ = num_samples_in_file_; +} + +size_t WavReader::ReadSamples(const size_t num_samples, + int16_t* const samples) { +#ifndef WEBRTC_ARCH_LITTLE_ENDIAN +#error "Need to convert samples to big-endian when reading from WAV file" +#endif + + size_t num_samples_left_to_read = num_samples; + size_t next_chunk_start = 0; + while (num_samples_left_to_read > 0 && num_unread_samples_ > 0) { + const size_t chunk_size = std::min( + std::min(kMaxChunksize, num_samples_left_to_read), num_unread_samples_); + size_t num_bytes_read; + size_t num_samples_read; + if (format_ == WavFormat::kWavFormatIeeeFloat) { + std::array samples_to_convert; + num_bytes_read = file_.Read(samples_to_convert.data(), + chunk_size * sizeof(samples_to_convert[0])); + num_samples_read = num_bytes_read / sizeof(samples_to_convert[0]); + + for (size_t j = 0; j < num_samples_read; ++j) { + samples[next_chunk_start + j] = FloatToS16(samples_to_convert[j]); + } + } else { + RTC_CHECK_EQ(format_, WavFormat::kWavFormatPcm); + num_bytes_read = file_.Read(&samples[next_chunk_start], + chunk_size * sizeof(samples[0])); + num_samples_read = num_bytes_read / sizeof(samples[0]); + } + RTC_CHECK(num_samples_read == 0 || (num_bytes_read % num_samples_read) == 0) + << "Corrupt file: file ended in the middle of a sample."; + RTC_CHECK(num_samples_read == chunk_size || file_.ReadEof()) + << "Corrupt file: payload size does not match header."; + + next_chunk_start += num_samples_read; + num_unread_samples_ -= num_samples_read; + num_samples_left_to_read -= num_samples_read; + } + + return num_samples - num_samples_left_to_read; +} + +size_t WavReader::ReadSamples(const size_t num_samples, float* const samples) { +#ifndef WEBRTC_ARCH_LITTLE_ENDIAN +#error "Need to convert samples to big-endian when reading from WAV file" +#endif + + size_t num_samples_left_to_read = num_samples; + size_t next_chunk_start = 0; + while (num_samples_left_to_read > 0 && num_unread_samples_ > 0) { + const size_t chunk_size = std::min( + std::min(kMaxChunksize, num_samples_left_to_read), num_unread_samples_); + size_t num_bytes_read; + size_t num_samples_read; + if (format_ == WavFormat::kWavFormatPcm) { + std::array samples_to_convert; + num_bytes_read = file_.Read(samples_to_convert.data(), + chunk_size * sizeof(samples_to_convert[0])); + num_samples_read = num_bytes_read / sizeof(samples_to_convert[0]); + + for (size_t j = 0; j < num_samples_read; ++j) { + samples[next_chunk_start + j] = + static_cast(samples_to_convert[j]); + } + } else { + RTC_CHECK_EQ(format_, WavFormat::kWavFormatIeeeFloat); + num_bytes_read = file_.Read(&samples[next_chunk_start], + chunk_size * sizeof(samples[0])); + num_samples_read = num_bytes_read / sizeof(samples[0]); + + for (size_t j = 0; j < num_samples_read; ++j) { + samples[next_chunk_start + j] = + FloatToFloatS16(samples[next_chunk_start + j]); + } + } + RTC_CHECK(num_samples_read == 0 || (num_bytes_read % num_samples_read) == 0) + << "Corrupt file: file ended in the middle of a sample."; + RTC_CHECK(num_samples_read == chunk_size || file_.ReadEof()) + << "Corrupt file: payload size does not match header."; + + next_chunk_start += num_samples_read; + num_unread_samples_ -= num_samples_read; + num_samples_left_to_read -= num_samples_read; + } + + return num_samples - num_samples_left_to_read; +} + +void WavReader::Close() { + file_.Close(); +} + +WavWriter::WavWriter(absl::string_view filename, + int sample_rate, + size_t num_channels, + SampleFormat sample_format) + // Unlike plain fopen, OpenWriteOnly takes care of filename utf8 -> + // wchar conversion on windows. + : WavWriter(FileWrapper::OpenWriteOnly(filename), + sample_rate, + num_channels, + sample_format) {} + +WavWriter::WavWriter(FileWrapper file, + int sample_rate, + size_t num_channels, + SampleFormat sample_format) + : sample_rate_(sample_rate), + num_channels_(num_channels), + num_samples_written_(0), + format_(sample_format == SampleFormat::kInt16 + ? WavFormat::kWavFormatPcm + : WavFormat::kWavFormatIeeeFloat), + file_(std::move(file)) { + // Handle errors from the OpenWriteOnly call in above constructor. + RTC_CHECK(file_.is_open()) << "Invalid file. Could not create wav file."; + + RTC_CHECK(CheckWavParameters(num_channels_, sample_rate_, format_, + num_samples_written_)); + + // Write a blank placeholder header, since we need to know the total number + // of samples before we can fill in the real data. + static const uint8_t blank_header[MaxWavHeaderSize()] = {0}; + RTC_CHECK(file_.Write(blank_header, WavHeaderSize(format_))); +} + +void WavWriter::WriteSamples(const int16_t* samples, size_t num_samples) { +#ifndef WEBRTC_ARCH_LITTLE_ENDIAN +#error "Need to convert samples to little-endian when writing to WAV file" +#endif + + for (size_t i = 0; i < num_samples; i += kMaxChunksize) { + const size_t num_remaining_samples = num_samples - i; + const size_t num_samples_to_write = + std::min(kMaxChunksize, num_remaining_samples); + + if (format_ == WavFormat::kWavFormatPcm) { + RTC_CHECK( + file_.Write(&samples[i], num_samples_to_write * sizeof(samples[0]))); + } else { + RTC_CHECK_EQ(format_, WavFormat::kWavFormatIeeeFloat); + std::array converted_samples; + for (size_t j = 0; j < num_samples_to_write; ++j) { + converted_samples[j] = S16ToFloat(samples[i + j]); + } + RTC_CHECK( + file_.Write(converted_samples.data(), + num_samples_to_write * sizeof(converted_samples[0]))); + } + + num_samples_written_ += num_samples_to_write; + RTC_CHECK_GE(num_samples_written_, + num_samples_to_write); // detect size_t overflow + } +} + +void WavWriter::WriteSamples(const float* samples, size_t num_samples) { +#ifndef WEBRTC_ARCH_LITTLE_ENDIAN +#error "Need to convert samples to little-endian when writing to WAV file" +#endif + + for (size_t i = 0; i < num_samples; i += kMaxChunksize) { + const size_t num_remaining_samples = num_samples - i; + const size_t num_samples_to_write = + std::min(kMaxChunksize, num_remaining_samples); + + if (format_ == WavFormat::kWavFormatPcm) { + std::array converted_samples; + for (size_t j = 0; j < num_samples_to_write; ++j) { + converted_samples[j] = FloatS16ToS16(samples[i + j]); + } + RTC_CHECK( + file_.Write(converted_samples.data(), + num_samples_to_write * sizeof(converted_samples[0]))); + } else { + RTC_CHECK_EQ(format_, WavFormat::kWavFormatIeeeFloat); + std::array converted_samples; + for (size_t j = 0; j < num_samples_to_write; ++j) { + converted_samples[j] = FloatS16ToFloat(samples[i + j]); + } + RTC_CHECK( + file_.Write(converted_samples.data(), + num_samples_to_write * sizeof(converted_samples[0]))); + } + + num_samples_written_ += num_samples_to_write; + RTC_CHECK(num_samples_written_ >= + num_samples_to_write); // detect size_t overflow + } +} + +void WavWriter::Close() { + RTC_CHECK(file_.Rewind()); + std::array header; + size_t header_size; + WriteWavHeader(num_channels_, sample_rate_, format_, num_samples_written_, + header.data(), &header_size); + RTC_CHECK(file_.Write(header.data(), header_size)); + RTC_CHECK(file_.Close()); +} + +} // namespace webrtc diff --git a/VocieProcess/common_audio/wav_file.h b/VocieProcess/common_audio/wav_file.h new file mode 100644 index 0000000..72a4db7 --- /dev/null +++ b/VocieProcess/common_audio/wav_file.h @@ -0,0 +1,115 @@ +/* + * Copyright (c) 2014 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef COMMON_AUDIO_WAV_FILE_H_ +#define COMMON_AUDIO_WAV_FILE_H_ + +#include + +#include +#include + +#include "common_audio/wav_header.h" +#include "rtc_base/system/file_wrapper.h" + +namespace webrtc { + +// Interface to provide access WAV file parameters. +class WavFile { + public: + enum class SampleFormat { kInt16, kFloat }; + + virtual ~WavFile() {} + + virtual int sample_rate() const = 0; + virtual size_t num_channels() const = 0; + virtual size_t num_samples() const = 0; +}; + +// Simple C++ class for writing 16-bit integer and 32 bit floating point PCM WAV +// files. All error handling is by calls to RTC_CHECK(), making it unsuitable +// for anything but debug code. +class WavWriter final : public WavFile { + public: + // Opens a new WAV file for writing. + WavWriter(absl::string_view filename, + int sample_rate, + size_t num_channels, + SampleFormat sample_format = SampleFormat::kInt16); + WavWriter(FileWrapper file, + int sample_rate, + size_t num_channels, + SampleFormat sample_format = SampleFormat::kInt16); + + // Closes the WAV file, after writing its header. + ~WavWriter() { Close(); } + + WavWriter(const WavWriter&) = delete; + WavWriter& operator=(const WavWriter&) = delete; + + // Write additional samples to the file. Each sample is in the range + // [-32768.0,32767.0], and there must be the previously specified number of + // interleaved channels. + void WriteSamples(const float* samples, size_t num_samples); + void WriteSamples(const int16_t* samples, size_t num_samples); + + int sample_rate() const override { return sample_rate_; } + size_t num_channels() const override { return num_channels_; } + size_t num_samples() const override { return num_samples_written_; } + + private: + void Close(); + const int sample_rate_; + const size_t num_channels_; + size_t num_samples_written_; + WavFormat format_; + FileWrapper file_; +}; + +// Follows the conventions of WavWriter. +class WavReader final : public WavFile { + public: + // Opens an existing WAV file for reading. + explicit WavReader(absl::string_view filename); + explicit WavReader(FileWrapper file); + + // Close the WAV file. + ~WavReader() { Close(); } + + WavReader(const WavReader&) = delete; + WavReader& operator=(const WavReader&) = delete; + + // Resets position to the beginning of the file. + void Reset(); + + // Returns the number of samples read. If this is less than requested, + // verifies that the end of the file was reached. + size_t ReadSamples(size_t num_samples, float* samples); + size_t ReadSamples(size_t num_samples, int16_t* samples); + + int sample_rate() const override { return sample_rate_; } + size_t num_channels() const override { return num_channels_; } + size_t num_samples() const override { return num_samples_in_file_; } + + private: + void Close(); + int sample_rate_; + size_t num_channels_; + WavFormat format_; + size_t num_samples_in_file_; + size_t num_unread_samples_; + FileWrapper file_; + int64_t + data_start_pos_; // Position in the file immediately after WAV header. +}; + +} // namespace webrtc + +#endif // COMMON_AUDIO_WAV_FILE_H_ diff --git a/VocieProcess/common_audio/wav_header.cc b/VocieProcess/common_audio/wav_header.cc new file mode 100644 index 0000000..bca209a --- /dev/null +++ b/VocieProcess/common_audio/wav_header.cc @@ -0,0 +1,435 @@ +/* + * Copyright (c) 2014 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +// Based on the WAV file format documentation at +// https://ccrma.stanford.edu/courses/422/projects/WaveFormat/ and +// http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/WAVE.html + +#include "common_audio/wav_header.h" + +#include +#include +#include + +#include "rtc_base/checks.h" +#include "rtc_base/logging.h" +#include "rtc_base/sanitizer.h" +#include "rtc_base/system/arch.h" + +namespace webrtc { +namespace { + +#ifndef WEBRTC_ARCH_LITTLE_ENDIAN +#error "Code not working properly for big endian platforms." +#endif + +#pragma pack(2) +struct ChunkHeader { + uint32_t ID; + uint32_t Size; +}; +static_assert(sizeof(ChunkHeader) == 8, "ChunkHeader size"); + +#pragma pack(2) +struct RiffHeader { + ChunkHeader header; + uint32_t Format; +}; +static_assert(sizeof(RiffHeader) == sizeof(ChunkHeader) + 4, "RiffHeader size"); + +// We can't nest this definition in WavHeader, because VS2013 gives an error +// on sizeof(WavHeader::fmt): "error C2070: 'unknown': illegal sizeof operand". +#pragma pack(2) +struct FmtPcmSubchunk { + ChunkHeader header; + uint16_t AudioFormat; + uint16_t NumChannels; + uint32_t SampleRate; + uint32_t ByteRate; + uint16_t BlockAlign; + uint16_t BitsPerSample; +}; +static_assert(sizeof(FmtPcmSubchunk) == 24, "FmtPcmSubchunk size"); +const uint32_t kFmtPcmSubchunkSize = + sizeof(FmtPcmSubchunk) - sizeof(ChunkHeader); + +// Pack struct to avoid additional padding bytes. +#pragma pack(2) +struct FmtIeeeFloatSubchunk { + ChunkHeader header; + uint16_t AudioFormat; + uint16_t NumChannels; + uint32_t SampleRate; + uint32_t ByteRate; + uint16_t BlockAlign; + uint16_t BitsPerSample; + uint16_t ExtensionSize; +}; +static_assert(sizeof(FmtIeeeFloatSubchunk) == 26, "FmtIeeeFloatSubchunk size"); +const uint32_t kFmtIeeeFloatSubchunkSize = + sizeof(FmtIeeeFloatSubchunk) - sizeof(ChunkHeader); + +// Simple PCM wav header. It does not include chunks that are not essential to +// read audio samples. +#pragma pack(2) +struct WavHeaderPcm { + RiffHeader riff; + FmtPcmSubchunk fmt; + struct { + ChunkHeader header; + } data; +}; +static_assert(sizeof(WavHeaderPcm) == kPcmWavHeaderSize, + "no padding in header"); + +// IEEE Float Wav header, includes extra chunks necessary for proper non-PCM +// WAV implementation. +#pragma pack(2) +struct WavHeaderIeeeFloat { + RiffHeader riff; + FmtIeeeFloatSubchunk fmt; + struct { + ChunkHeader header; + uint32_t SampleLength; + } fact; + struct { + ChunkHeader header; + } data; +}; +static_assert(sizeof(WavHeaderIeeeFloat) == kIeeeFloatWavHeaderSize, + "no padding in header"); + +uint32_t PackFourCC(char a, char b, char c, char d) { + uint32_t packed_value = + static_cast(a) | static_cast(b) << 8 | + static_cast(c) << 16 | static_cast(d) << 24; + return packed_value; +} + +std::string ReadFourCC(uint32_t x) { + return std::string(reinterpret_cast(&x), 4); +} + +uint16_t MapWavFormatToHeaderField(WavFormat format) { + switch (format) { + case WavFormat::kWavFormatPcm: + return 1; + case WavFormat::kWavFormatIeeeFloat: + return 3; + case WavFormat::kWavFormatALaw: + return 6; + case WavFormat::kWavFormatMuLaw: + return 7; + } + RTC_CHECK_NOTREACHED(); +} + +WavFormat MapHeaderFieldToWavFormat(uint16_t format_header_value) { + if (format_header_value == 1) { + return WavFormat::kWavFormatPcm; + } + if (format_header_value == 3) { + return WavFormat::kWavFormatIeeeFloat; + } + + RTC_CHECK(false) << "Unsupported WAV format"; +} + +uint32_t RiffChunkSize(size_t bytes_in_payload, size_t header_size) { + return static_cast(bytes_in_payload + header_size - + sizeof(ChunkHeader)); +} + +uint32_t ByteRate(size_t num_channels, + int sample_rate, + size_t bytes_per_sample) { + return static_cast(num_channels * sample_rate * bytes_per_sample); +} + +uint16_t BlockAlign(size_t num_channels, size_t bytes_per_sample) { + return static_cast(num_channels * bytes_per_sample); +} + +// Finds a chunk having the sought ID. If found, then `readable` points to the +// first byte of the sought chunk data. If not found, the end of the file is +// reached. +bool FindWaveChunk(ChunkHeader* chunk_header, + WavHeaderReader* readable, + const std::string sought_chunk_id) { + RTC_DCHECK_EQ(sought_chunk_id.size(), 4); + while (true) { + if (readable->Read(chunk_header, sizeof(*chunk_header)) != + sizeof(*chunk_header)) + return false; // EOF. + if (ReadFourCC(chunk_header->ID) == sought_chunk_id) + return true; // Sought chunk found. + // Ignore current chunk by skipping its payload. + if (!readable->SeekForward(chunk_header->Size)) + return false; // EOF or error. + } +} + +bool ReadFmtChunkData(FmtPcmSubchunk* fmt_subchunk, WavHeaderReader* readable) { + // Reads "fmt " chunk payload. + if (readable->Read(&(fmt_subchunk->AudioFormat), kFmtPcmSubchunkSize) != + kFmtPcmSubchunkSize) + return false; + const uint32_t fmt_size = fmt_subchunk->header.Size; + if (fmt_size != kFmtPcmSubchunkSize) { + // There is an optional two-byte extension field permitted to be present + // with PCM, but which must be zero. + int16_t ext_size; + if (kFmtPcmSubchunkSize + sizeof(ext_size) != fmt_size) + return false; + if (readable->Read(&ext_size, sizeof(ext_size)) != sizeof(ext_size)) + return false; + if (ext_size != 0) + return false; + } + return true; +} + +void WritePcmWavHeader(size_t num_channels, + int sample_rate, + size_t bytes_per_sample, + size_t num_samples, + uint8_t* buf, + size_t* header_size) { + RTC_CHECK(buf); + RTC_CHECK(header_size); + *header_size = kPcmWavHeaderSize; + auto header = rtc::MsanUninitialized({}); + const size_t bytes_in_payload = bytes_per_sample * num_samples; + + header.riff.header.ID = PackFourCC('R', 'I', 'F', 'F'); + header.riff.header.Size = RiffChunkSize(bytes_in_payload, *header_size); + header.riff.Format = PackFourCC('W', 'A', 'V', 'E'); + header.fmt.header.ID = PackFourCC('f', 'm', 't', ' '); + header.fmt.header.Size = kFmtPcmSubchunkSize; + header.fmt.AudioFormat = MapWavFormatToHeaderField(WavFormat::kWavFormatPcm); + header.fmt.NumChannels = static_cast(num_channels); + header.fmt.SampleRate = sample_rate; + header.fmt.ByteRate = ByteRate(num_channels, sample_rate, bytes_per_sample); + header.fmt.BlockAlign = BlockAlign(num_channels, bytes_per_sample); + header.fmt.BitsPerSample = static_cast(8 * bytes_per_sample); + header.data.header.ID = PackFourCC('d', 'a', 't', 'a'); + header.data.header.Size = static_cast(bytes_in_payload); + + // Do an extra copy rather than writing everything to buf directly, since buf + // might not be correctly aligned. + memcpy(buf, &header, *header_size); +} + +void WriteIeeeFloatWavHeader(size_t num_channels, + int sample_rate, + size_t bytes_per_sample, + size_t num_samples, + uint8_t* buf, + size_t* header_size) { + RTC_CHECK(buf); + RTC_CHECK(header_size); + *header_size = kIeeeFloatWavHeaderSize; + auto header = rtc::MsanUninitialized({}); + const size_t bytes_in_payload = bytes_per_sample * num_samples; + + header.riff.header.ID = PackFourCC('R', 'I', 'F', 'F'); + header.riff.header.Size = RiffChunkSize(bytes_in_payload, *header_size); + header.riff.Format = PackFourCC('W', 'A', 'V', 'E'); + header.fmt.header.ID = PackFourCC('f', 'm', 't', ' '); + header.fmt.header.Size = kFmtIeeeFloatSubchunkSize; + header.fmt.AudioFormat = + MapWavFormatToHeaderField(WavFormat::kWavFormatIeeeFloat); + header.fmt.NumChannels = static_cast(num_channels); + header.fmt.SampleRate = sample_rate; + header.fmt.ByteRate = ByteRate(num_channels, sample_rate, bytes_per_sample); + header.fmt.BlockAlign = BlockAlign(num_channels, bytes_per_sample); + header.fmt.BitsPerSample = static_cast(8 * bytes_per_sample); + header.fmt.ExtensionSize = 0; + header.fact.header.ID = PackFourCC('f', 'a', 'c', 't'); + header.fact.header.Size = 4; + header.fact.SampleLength = static_cast(num_channels * num_samples); + header.data.header.ID = PackFourCC('d', 'a', 't', 'a'); + header.data.header.Size = static_cast(bytes_in_payload); + + // Do an extra copy rather than writing everything to buf directly, since buf + // might not be correctly aligned. + memcpy(buf, &header, *header_size); +} + +// Returns the number of bytes per sample for the format. +size_t GetFormatBytesPerSample(WavFormat format) { + switch (format) { + case WavFormat::kWavFormatPcm: + // Other values may be OK, but for now we're conservative. + return 2; + case WavFormat::kWavFormatALaw: + case WavFormat::kWavFormatMuLaw: + return 1; + case WavFormat::kWavFormatIeeeFloat: + return 4; + } + RTC_CHECK_NOTREACHED(); +} + +bool CheckWavParameters(size_t num_channels, + int sample_rate, + WavFormat format, + size_t bytes_per_sample, + size_t num_samples) { + // num_channels, sample_rate, and bytes_per_sample must be positive, must fit + // in their respective fields, and their product must fit in the 32-bit + // ByteRate field. + if (num_channels == 0 || sample_rate <= 0 || bytes_per_sample == 0) + return false; + if (static_cast(sample_rate) > std::numeric_limits::max()) + return false; + if (num_channels > std::numeric_limits::max()) + return false; + if (static_cast(bytes_per_sample) * 8 > + std::numeric_limits::max()) + return false; + if (static_cast(sample_rate) * num_channels * bytes_per_sample > + std::numeric_limits::max()) + return false; + + // format and bytes_per_sample must agree. + switch (format) { + case WavFormat::kWavFormatPcm: + // Other values may be OK, but for now we're conservative: + if (bytes_per_sample != 1 && bytes_per_sample != 2) + return false; + break; + case WavFormat::kWavFormatALaw: + case WavFormat::kWavFormatMuLaw: + if (bytes_per_sample != 1) + return false; + break; + case WavFormat::kWavFormatIeeeFloat: + if (bytes_per_sample != 4) + return false; + break; + default: + return false; + } + + // The number of bytes in the file, not counting the first ChunkHeader, must + // be less than 2^32; otherwise, the ChunkSize field overflows. + const size_t header_size = kPcmWavHeaderSize - sizeof(ChunkHeader); + const size_t max_samples = + (std::numeric_limits::max() - header_size) / bytes_per_sample; + if (num_samples > max_samples) + return false; + + // Each channel must have the same number of samples. + if (num_samples % num_channels != 0) + return false; + + return true; +} + +} // namespace + +bool CheckWavParameters(size_t num_channels, + int sample_rate, + WavFormat format, + size_t num_samples) { + return CheckWavParameters(num_channels, sample_rate, format, + GetFormatBytesPerSample(format), num_samples); +} + +void WriteWavHeader(size_t num_channels, + int sample_rate, + WavFormat format, + size_t num_samples, + uint8_t* buf, + size_t* header_size) { + RTC_CHECK(buf); + RTC_CHECK(header_size); + + const size_t bytes_per_sample = GetFormatBytesPerSample(format); + RTC_CHECK(CheckWavParameters(num_channels, sample_rate, format, + bytes_per_sample, num_samples)); + if (format == WavFormat::kWavFormatPcm) { + WritePcmWavHeader(num_channels, sample_rate, bytes_per_sample, num_samples, + buf, header_size); + } else { + RTC_CHECK_EQ(format, WavFormat::kWavFormatIeeeFloat); + WriteIeeeFloatWavHeader(num_channels, sample_rate, bytes_per_sample, + num_samples, buf, header_size); + } +} + +bool ReadWavHeader(WavHeaderReader* readable, + size_t* num_channels, + int* sample_rate, + WavFormat* format, + size_t* bytes_per_sample, + size_t* num_samples, + int64_t* data_start_pos) { + // Read using the PCM header, even though it might be float Wav file + auto header = rtc::MsanUninitialized({}); + + // Read RIFF chunk. + if (readable->Read(&header.riff, sizeof(header.riff)) != sizeof(header.riff)) + return false; + if (ReadFourCC(header.riff.header.ID) != "RIFF") + return false; + if (ReadFourCC(header.riff.Format) != "WAVE") + return false; + + // Find "fmt " and "data" chunks. While the official Wave file specification + // does not put requirements on the chunks order, it is uncommon to find the + // "data" chunk before the "fmt " one. The code below fails if this is not the + // case. + if (!FindWaveChunk(&header.fmt.header, readable, "fmt ")) { + RTC_LOG(LS_ERROR) << "Cannot find 'fmt ' chunk."; + return false; + } + if (!ReadFmtChunkData(&header.fmt, readable)) { + RTC_LOG(LS_ERROR) << "Cannot read 'fmt ' chunk."; + return false; + } + if (!FindWaveChunk(&header.data.header, readable, "data")) { + RTC_LOG(LS_ERROR) << "Cannot find 'data' chunk."; + return false; + } + + // Parse needed fields. + *format = MapHeaderFieldToWavFormat(header.fmt.AudioFormat); + *num_channels = header.fmt.NumChannels; + *sample_rate = header.fmt.SampleRate; + *bytes_per_sample = header.fmt.BitsPerSample / 8; + const size_t bytes_in_payload = header.data.header.Size; + if (*bytes_per_sample == 0) + return false; + *num_samples = bytes_in_payload / *bytes_per_sample; + + const size_t header_size = *format == WavFormat::kWavFormatPcm + ? kPcmWavHeaderSize + : kIeeeFloatWavHeaderSize; + + if (header.riff.header.Size < RiffChunkSize(bytes_in_payload, header_size)) + return false; + if (header.fmt.ByteRate != + ByteRate(*num_channels, *sample_rate, *bytes_per_sample)) + return false; + if (header.fmt.BlockAlign != BlockAlign(*num_channels, *bytes_per_sample)) + return false; + + if (!CheckWavParameters(*num_channels, *sample_rate, *format, + *bytes_per_sample, *num_samples)) { + return false; + } + + *data_start_pos = readable->GetPosition(); + return true; +} + +} // namespace webrtc diff --git a/VocieProcess/common_audio/wav_header.h b/VocieProcess/common_audio/wav_header.h new file mode 100644 index 0000000..a1aa942 --- /dev/null +++ b/VocieProcess/common_audio/wav_header.h @@ -0,0 +1,91 @@ +/* + * Copyright (c) 2014 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef COMMON_AUDIO_WAV_HEADER_H_ +#define COMMON_AUDIO_WAV_HEADER_H_ + +#include +#include + +#include + +#include "rtc_base/checks.h" + +namespace webrtc { + +// Interface providing header reading functionality. +class WavHeaderReader { + public: + // Returns the number of bytes read. + virtual size_t Read(void* buf, size_t num_bytes) = 0; + virtual bool SeekForward(uint32_t num_bytes) = 0; + virtual ~WavHeaderReader() = default; + virtual int64_t GetPosition() = 0; +}; + +// Possible WAV formats. +enum class WavFormat { + kWavFormatPcm = 1, // PCM, each sample of size bytes_per_sample. + kWavFormatIeeeFloat = 3, // IEEE float. + kWavFormatALaw = 6, // 8-bit ITU-T G.711 A-law. + kWavFormatMuLaw = 7, // 8-bit ITU-T G.711 mu-law. +}; + +// Header sizes for supported WAV formats. +constexpr size_t kPcmWavHeaderSize = 44; +constexpr size_t kIeeeFloatWavHeaderSize = 58; + +// Returns the size of the WAV header for the specified format. +constexpr size_t WavHeaderSize(WavFormat format) { + if (format == WavFormat::kWavFormatPcm) { + return kPcmWavHeaderSize; + } + RTC_CHECK_EQ(format, WavFormat::kWavFormatIeeeFloat); + return kIeeeFloatWavHeaderSize; +} + +// Returns the maximum size of the supported WAV formats. +constexpr size_t MaxWavHeaderSize() { + return std::max(WavHeaderSize(WavFormat::kWavFormatPcm), + WavHeaderSize(WavFormat::kWavFormatIeeeFloat)); +} + +// Return true if the given parameters will make a well-formed WAV header. +bool CheckWavParameters(size_t num_channels, + int sample_rate, + WavFormat format, + size_t num_samples); + +// Write a kWavHeaderSize bytes long WAV header to buf. The payload that +// follows the header is supposed to have the specified number of interleaved +// channels and contain the specified total number of samples of the specified +// type. The size of the header is returned in header_size. CHECKs the input +// parameters for validity. +void WriteWavHeader(size_t num_channels, + int sample_rate, + WavFormat format, + size_t num_samples, + uint8_t* buf, + size_t* header_size); + +// Read a WAV header from an implemented WavHeaderReader and parse the values +// into the provided output parameters. WavHeaderReader is used because the +// header can be variably sized. Returns false if the header is invalid. +bool ReadWavHeader(WavHeaderReader* readable, + size_t* num_channels, + int* sample_rate, + WavFormat* format, + size_t* bytes_per_sample, + size_t* num_samples, + int64_t* data_start_pos); + +} // namespace webrtc + +#endif // COMMON_AUDIO_WAV_HEADER_H_ diff --git a/VocieProcess/rtc_base/system/file_wrapper.cc b/VocieProcess/rtc_base/system/file_wrapper.cc new file mode 100644 index 0000000..b768ad0 --- /dev/null +++ b/VocieProcess/rtc_base/system/file_wrapper.cc @@ -0,0 +1,136 @@ +/* + * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "rtc_base/system/file_wrapper.h" + +#include + +#include +#include +#include + +#include "absl/strings/string_view.h" +#include "absl/types/optional.h" +#include "rtc_base/checks.h" +#include "rtc_base/numerics/safe_conversions.h" + +#ifdef _WIN32 +#include +#else +#endif + +#include + +namespace webrtc { +namespace { +FILE* FileOpen(absl::string_view file_name_utf8, bool read_only, int* error) { + RTC_CHECK_EQ(file_name_utf8.find_first_of('\0'), absl::string_view::npos) + << "Invalid filename, containing NUL character"; + std::string file_name(file_name_utf8); +#if defined(_WIN32) + int len = MultiByteToWideChar(CP_UTF8, 0, file_name.c_str(), -1, nullptr, 0); + std::wstring wstr(len, 0); + MultiByteToWideChar(CP_UTF8, 0, file_name.c_str(), -1, &wstr[0], len); + FILE* file = _wfopen(wstr.c_str(), read_only ? L"rb" : L"wb"); +#else + FILE* file = fopen(file_name.c_str(), read_only ? "rb" : "wb"); +#endif + if (!file && error) { + *error = errno; + } + return file; +} + +} // namespace + +// static +FileWrapper FileWrapper::OpenReadOnly(absl::string_view file_name_utf8) { + return FileWrapper(FileOpen(file_name_utf8, true, nullptr)); +} + +// static +FileWrapper FileWrapper::OpenWriteOnly(absl::string_view file_name_utf8, + int* error /*=nullptr*/) { + return FileWrapper(FileOpen(file_name_utf8, false, error)); +} + +FileWrapper::FileWrapper(FileWrapper&& other) { + operator=(std::move(other)); +} + +FileWrapper& FileWrapper::operator=(FileWrapper&& other) { + Close(); + file_ = other.file_; + other.file_ = nullptr; + return *this; +} + +bool FileWrapper::SeekRelative(int64_t offset) { + RTC_DCHECK(file_); + return fseek(file_, rtc::checked_cast(offset), SEEK_CUR) == 0; +} + +bool FileWrapper::SeekTo(int64_t position) { + RTC_DCHECK(file_); + return fseek(file_, rtc::checked_cast(position), SEEK_SET) == 0; +} + +absl::optional FileWrapper::FileSize() { + if (file_ == nullptr) + return absl::nullopt; + long original_position = ftell(file_); + if (original_position < 0) + return absl::nullopt; + int seek_error = fseek(file_, 0, SEEK_END); + if (seek_error) + return absl::nullopt; + long file_size = ftell(file_); + seek_error = fseek(file_, original_position, SEEK_SET); + if (seek_error) + return absl::nullopt; + return rtc::checked_cast(file_size); +} + +bool FileWrapper::Flush() { + RTC_DCHECK(file_); + return fflush(file_) == 0; +} + +size_t FileWrapper::Read(void* buf, size_t length) { + RTC_DCHECK(file_); + return fread(buf, 1, length, file_); +} + +bool FileWrapper::ReadEof() const { + RTC_DCHECK(file_); + return feof(file_); +} + +bool FileWrapper::Write(const void* buf, size_t length) { + RTC_DCHECK(file_); + return fwrite(buf, 1, length, file_) == length; +} + +bool FileWrapper::Close() { + if (file_ == nullptr) + return true; + + bool success = fclose(file_) == 0; + file_ = nullptr; + return success; +} + +FILE* FileWrapper::Release() { + FILE* file = file_; + file_ = nullptr; + return file; +} + +} // namespace webrtc diff --git a/VocieProcess/rtc_base/system/file_wrapper.h b/VocieProcess/rtc_base/system/file_wrapper.h new file mode 100644 index 0000000..882393b --- /dev/null +++ b/VocieProcess/rtc_base/system/file_wrapper.h @@ -0,0 +1,114 @@ +/* + * Copyright (c) 2011 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef RTC_BASE_SYSTEM_FILE_WRAPPER_H_ +#define RTC_BASE_SYSTEM_FILE_WRAPPER_H_ + +#include +#include +#include + +#include + +#include "absl/strings/string_view.h" +#include "absl/types/optional.h" + +// Implementation that can read (exclusive) or write from/to a file. + +namespace webrtc { + +// This class is a thin wrapper around FILE*. It's main features are that it +// owns the FILE*, calling fclose on destruction, and that on windows, file +// names passed to the open methods are always treated as utf-8, regardless of +// system code page. + +// Most of the methods return only a success/fail indication. When needed, an +// optional argument |int* error| should be added to all methods, in the same +// way as for the OpenWriteOnly methods. +class FileWrapper final { + public: + // Opens a file, in read or write mode. Use the is_open() method on the + // returned object to check if the open operation was successful. On failure, + // and if `error` is non-null, the system errno value is stored at |*error|. + // The file is closed by the destructor. + static FileWrapper OpenReadOnly(absl::string_view file_name_utf8); + static FileWrapper OpenWriteOnly(absl::string_view file_name_utf8, + int* error = nullptr); + + FileWrapper() = default; + + // Takes over ownership of `file`, closing it on destruction. Calling with + // null `file` is allowed, and results in a FileWrapper with is_open() false. + explicit FileWrapper(FILE* file) : file_(file) {} + ~FileWrapper() { Close(); } + + // Copying is not supported. + FileWrapper(const FileWrapper&) = delete; + FileWrapper& operator=(const FileWrapper&) = delete; + + // Support for move semantics. + FileWrapper(FileWrapper&&); + FileWrapper& operator=(FileWrapper&&); + + // Returns true if a file has been opened. If the file is not open, no methods + // but is_open and Close may be called. + bool is_open() const { return file_ != nullptr; } + + // Closes the file, and implies Flush. Returns true on success, false if + // writing buffered data fails. On failure, the file is nevertheless closed. + // Calling Close on an already closed file does nothing and returns success. + bool Close(); + + // Releases and returns the wrapped file without closing it. This call passes + // the ownership of the file to the caller, and the wrapper is no longer + // responsible for closing it. Similarly the previously wrapped file is no + // longer available for the wrapper to use in any aspect. + FILE* Release(); + + // Write any buffered data to the underlying file. Returns true on success, + // false on write error. Note: Flushing when closing, is not required. + bool Flush(); + + // Seeks to the beginning of file. Returns true on success, false on failure, + // e.g., if the underlying file isn't seekable. + bool Rewind() { return SeekTo(0); } + // TODO(nisse): The seek functions are used only by the WavReader. If that + // code is demoted to test code, seek functions can be deleted from this + // utility. + // Seek relative to current file position. + bool SeekRelative(int64_t offset); + // Seek to given position. + bool SeekTo(int64_t position); + + // Returns the file size or -1 if a size could not be determined. + // (A file size might not exists for non-seekable files or file-like + // objects, for example /dev/tty on unix.) + absl::optional FileSize(); + + // Returns number of bytes read. Short count indicates EOF or error. + size_t Read(void* buf, size_t length); + + // If the most recent Read() returned a short count, this methods returns true + // if the short count was due to EOF, and false it it was due to some i/o + // error. + bool ReadEof() const; + + // Returns true if all data was successfully written (or buffered), or false + // if there was an error. Writing buffered data can fail later, and is + // reported with return value from Flush or Close. + bool Write(const void* buf, size_t length); + + private: + FILE* file_ = nullptr; +}; + +} // namespace webrtc + +#endif // RTC_BASE_SYSTEM_FILE_WRAPPER_H_ diff --git a/rkap/include/RKAP_3A.h b/rkap/include/RKAP_3A.h new file mode 100644 index 0000000..4c7d8ca --- /dev/null +++ b/rkap/include/RKAP_3A.h @@ -0,0 +1,63 @@ +/* + * Copyright (C) 2020, Fuzhou Rockchip Electronics Co., Ltd. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Fuzhou Rockchip Electronics Co., Ltd. nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __RKAP_3A_H__ +#define __RKAP_3A_H__ + +#include "RKAP_Common.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct RKAP_AEC_State_S +{ + /* Basic info */ + int swSampleRate; /* 8k~48k */ + int swFrameLen; /* frame time only 16ms|20ms */ + const char *pathPara; +} RKAP_AEC_State; + +typedef enum AecTransType +{ + AEC_TX_TYPE = 0, + AEC_RX_TYPE +} RKAP_AEC_TRANS_ENUM; + +extern RKAP_Handle RKAP_3A_Init(RKAP_AEC_State *st, RKAP_AEC_TRANS_ENUM transType); +extern void RKAP_3A_Destroy(RKAP_Handle handle); +extern int RKAP_3A_Process(RKAP_Handle handle, short *pfSigIn, + short *pfSigRef, short *pfSigOut); +extern void RKAP_3A_DumpVersion(void); + +#ifdef __cplusplus +} +#endif + +#endif /* __RKAP_3A_H__ */ diff --git a/rkap/include/RKAP_Common.h b/rkap/include/RKAP_Common.h new file mode 100644 index 0000000..8d48fb5 --- /dev/null +++ b/rkap/include/RKAP_Common.h @@ -0,0 +1,50 @@ +/* + * Copyright (C) 2020, Fuzhou Rockchip Electronics Co., Ltd. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of Fuzhou Rockchip Electronics Co., Ltd. nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __RKAP_COMMON_H__ +#define __RKAP_COMMON_H__ + +typedef void *RKAP_Handle; + +enum +{ + /* ANR Requests */ + AP_ANR_REQ_SET = 0x0, + AP_ANR_REQ_GET, + AP_ANR_REQ_RATE, + AP_ANR_REQ_FRMLEN, + AP_ANR_REQ_BAND_NUM, + AP_ANR_REQ_NOISE_FACTOR, + AP_ANR_REQ_SWIN_NUM, + AP_ANR_REQ_G_MIN, + /* AEC Requests */ + AP_AEC_REQ_BASE, +}; + +#endif /* __RKAP_COMMON_H__ */ diff --git a/rkap/lib/libRKAP_3A.so b/rkap/lib/libRKAP_3A.so new file mode 100644 index 0000000..8dbcb84 Binary files /dev/null and b/rkap/lib/libRKAP_3A.so differ diff --git a/rkap/lib/libRKAP_Common.so b/rkap/lib/libRKAP_Common.so new file mode 100644 index 0000000..0e000bb Binary files /dev/null and b/rkap/lib/libRKAP_Common.so differ