484 lines
16 KiB
C++
484 lines
16 KiB
C++
#include <iostream>
|
||
#include <unistd.h>
|
||
#include <cmath>
|
||
#include "timing.h"
|
||
#include "log/logger.h"
|
||
#include "common.h"
|
||
|
||
#include <modules/audio_processing/include/audio_processing.h>
|
||
#include <modules/audio_processing/include/config.h>
|
||
#include <thread>
|
||
#include <mutex>
|
||
#include "alsa_dev.h"
|
||
|
||
using namespace std;
|
||
using namespace toolkit;
|
||
|
||
#define MIX_INPUT_CHANNELS 2
|
||
#define MIX_INPUT_SAMPLES (10 * MIX_INPUT_SAMPLE_RATE/1000)
|
||
#define MIX_INPUT_SAMPLE_RATE 44100
|
||
|
||
struct audio_buf_t
|
||
{
|
||
uint8_t* data;
|
||
int index;
|
||
int size;
|
||
};
|
||
|
||
struct RtmpConfig {
|
||
char url[1024];
|
||
AVFormatContext *formatCtx;
|
||
AVStream *stream;
|
||
AVCodecContext *codecCtx;
|
||
SwrContext *swrCtx;
|
||
|
||
std::thread *thread;
|
||
std::mutex *mutex;
|
||
bool quit;
|
||
};
|
||
|
||
static SampleInfo kPcmSampleInfo;
|
||
|
||
//----------------------------------------------
|
||
#define MIN(a, b) ((a) < (b) ? (a) : (b))
|
||
#define MAX(a, b) ((a) > (b) ? (a) : (b))
|
||
// 最大/小音量（db）
|
||
#define MIN_DB (-10)
|
||
#define MAX_DB (20)
|
||
// 最大/小音量： 0: 静音； 100:最大音量
|
||
#define MUTE_VOLUME (0)
|
||
#define MAX_VOLUME (100)
|
||
|
||
static int vol_scaler_init(int *scaler, int mindb, int maxdb);
|
||
typedef struct VolumeCtlUnit
|
||
{
|
||
int scaler[MAX_VOLUME + 1]; // 音量表
|
||
int zeroDb; // 0db在scaler中的索引
|
||
// 自定义需要调节的音量
|
||
int micVolume;
|
||
VolumeCtlUnit() {
|
||
// 音量控制器初始化
|
||
zeroDb = vol_scaler_init(scaler, MIN_DB, MAX_DB);
|
||
micVolume = 100;
|
||
}
|
||
} volume_ctl_unit_t;
|
||
static volume_ctl_unit_t kVolCtrlUnit;
|
||
|
||
static int vol_scaler_init(int *scaler, int mindb, int maxdb)
|
||
{
|
||
double tabdb[MAX_VOLUME + 1];
|
||
double tabf [MAX_VOLUME + 1];
|
||
int z, i;
|
||
|
||
for (i = 0; i < (MAX_VOLUME + 1); i++) {
|
||
// (mindb, maxdb)平均分成(MAX_VOLUME + 1)份
|
||
tabdb[i] = mindb + (maxdb - mindb) * i / (MAX_VOLUME + 1);
|
||
// dB = 20 * log(A1 / A2)，当A1，A2相等时，db为0
|
||
// 这里以(1 << 14)作为原始声音振幅，得到调节后的振幅(A1),将A1存入音量表中
|
||
tabf [i] = pow(10.0, tabdb[i] / 20.0);
|
||
scaler[i] = (int)((1 << 14) * tabf[i]); // Q14 fix point
|
||
}
|
||
|
||
z = -mindb * (MAX_VOLUME + 1) / (maxdb - mindb);
|
||
z = MAX(z, 0 );
|
||
z = MIN(z, MAX_VOLUME);
|
||
scaler[0] = 0; // 音量表中，0标识静音
|
||
scaler[z] = (1 << 14);// (mindb, maxdb)的中间值作为0db，即不做增益处理
|
||
|
||
return z;
|
||
}
|
||
|
||
static void vol_scaler_run(int16_t *buf, int n, int volume)
|
||
{
|
||
/* 简易版
|
||
while (n--) {
|
||
*buf = (*buf) * multiplier / 100.0;
|
||
*buf = std::max((int)*buf, -0x7fff);
|
||
*buf = std::min((int)*buf, 0x7fff);
|
||
buf++;
|
||
}
|
||
*/
|
||
int multiplier = kVolCtrlUnit.scaler[volume];
|
||
if (multiplier > (1 << 14)) {
|
||
int32_t v;
|
||
while (n--) {
|
||
v = ((int32_t)*buf * multiplier) >> 14;
|
||
v = MAX(v,-0x7fff);
|
||
v = MIN(v, 0x7fff);
|
||
*buf++ = (int16_t)v;
|
||
}
|
||
} else if (multiplier < (1 << 14)) {
|
||
while (n--) {
|
||
*buf = ((int32_t)*buf * multiplier) >> 14;
|
||
buf++;
|
||
}
|
||
}
|
||
}
|
||
//----------------------------------------------
|
||
|
||
webrtc::AudioProcessing::Config webtcConfigInit()
|
||
{
|
||
webrtc::AudioProcessing::Config apmConfig;
|
||
apmConfig.pipeline.maximum_internal_processing_rate = MIX_INPUT_SAMPLE_RATE;
|
||
apmConfig.pipeline.multi_channel_capture = true;
|
||
apmConfig.pipeline.multi_channel_render = true;
|
||
//PreAmplifier
|
||
apmConfig.pre_amplifier.enabled = false;
|
||
apmConfig.pre_amplifier.fixed_gain_factor = 0.7f;
|
||
//HighPassFilter
|
||
apmConfig.high_pass_filter.enabled = false;
|
||
apmConfig.high_pass_filter.apply_in_full_band = false;
|
||
//EchoCanceller
|
||
apmConfig.echo_canceller.enabled = false;
|
||
apmConfig.echo_canceller.mobile_mode = false;
|
||
apmConfig.echo_canceller.export_linear_aec_output = false;
|
||
apmConfig.echo_canceller.enforce_high_pass_filtering = true;
|
||
//NoiseSuppression
|
||
apmConfig.noise_suppression.enabled = true;
|
||
apmConfig.noise_suppression.level = webrtc::AudioProcessing::Config::NoiseSuppression::kHigh;
|
||
apmConfig.noise_suppression.analyze_linear_aec_output_when_available = false;
|
||
//TransientSuppression
|
||
apmConfig.transient_suppression.enabled = false;
|
||
//VoiceDetection
|
||
apmConfig.voice_detection.enabled = true;
|
||
//GainController1
|
||
apmConfig.gain_controller1.enabled = true;
|
||
apmConfig.gain_controller1.mode = webrtc::AudioProcessing::Config::GainController1::kAdaptiveAnalog;
|
||
apmConfig.gain_controller1.target_level_dbfs = 3;
|
||
apmConfig.gain_controller1.compression_gain_db = 12;
|
||
apmConfig.gain_controller1.enable_limiter = true;
|
||
apmConfig.gain_controller1.analog_level_minimum = 0;
|
||
apmConfig.gain_controller1.analog_level_maximum = 496;
|
||
apmConfig.gain_controller1.analog_gain_controller.enabled = true;
|
||
apmConfig.gain_controller1.analog_gain_controller.startup_min_volume = webrtc::kAgcStartupMinVolume;
|
||
apmConfig.gain_controller1.analog_gain_controller.clipped_level_min = webrtc::kClippedLevelMin;
|
||
apmConfig.gain_controller1.analog_gain_controller.enable_agc2_level_estimator = false;
|
||
apmConfig.gain_controller1.analog_gain_controller.enable_digital_adaptive = true;
|
||
//GainController2
|
||
apmConfig.gain_controller2.enabled = false;
|
||
apmConfig.gain_controller2.fixed_digital.gain_db = 0.f;
|
||
apmConfig.gain_controller2.adaptive_digital.enabled = false;
|
||
apmConfig.gain_controller2.adaptive_digital.vad_probability_attack = 1.f;
|
||
apmConfig.gain_controller2.adaptive_digital.level_estimator = webrtc::AudioProcessing::Config::GainController2::kRms;
|
||
apmConfig.gain_controller2.adaptive_digital.level_estimator_adjacent_speech_frames_threshold = 1;
|
||
apmConfig.gain_controller2.adaptive_digital.use_saturation_protector = true;
|
||
apmConfig.gain_controller2.adaptive_digital.initial_saturation_margin_db = 20.f;
|
||
apmConfig.gain_controller2.adaptive_digital.extra_saturation_margin_db = 2.f;
|
||
apmConfig.gain_controller2.adaptive_digital.gain_applier_adjacent_speech_frames_threshold = 1;
|
||
apmConfig.gain_controller2.adaptive_digital.max_gain_change_db_per_second = 3.f;
|
||
apmConfig.gain_controller2.adaptive_digital.max_output_noise_level_dbfs = -50.f;
|
||
//ResidualEchoDetector
|
||
apmConfig.residual_echo_detector.enabled = false;
|
||
//LevelEstimation
|
||
apmConfig.level_estimation.enabled = false;
|
||
|
||
return apmConfig;
|
||
}
|
||
|
||
void pullDestory(RtmpConfig *config)
|
||
{
|
||
if (config->formatCtx)
|
||
avformat_close_input(&config->formatCtx);
|
||
if (config->codecCtx) {
|
||
avcodec_close(config->codecCtx);
|
||
avcodec_free_context(&config->codecCtx);
|
||
}
|
||
if (config->swrCtx) {
|
||
swr_close(config->swrCtx);
|
||
swr_free(&config->swrCtx);
|
||
}
|
||
}
|
||
|
||
int pullInit(RtmpConfig *config, int channels, AVSampleFormat format, int sample_rate)
|
||
{
|
||
if (nullptr == strstr(config->url, "rtmp://")) {
|
||
LogE("url error, url: %s\n", config->url);
|
||
return -1;
|
||
}
|
||
int ret = 0;
|
||
int scan_all_pmts_set = 0;
|
||
int st_index = -1;
|
||
AVDictionary *format_opts = nullptr;
|
||
AVFormatContext *ic = nullptr;
|
||
AVCodecParameters *codecPar = nullptr;
|
||
AVCodec *codec = nullptr;
|
||
AVCodecContext *codecCtx = nullptr;
|
||
SwrContext *swrCtx = nullptr;
|
||
|
||
ic = avformat_alloc_context();
|
||
if (!ic) {
|
||
throw(std::runtime_error("avformat_alloc_context failed."));
|
||
}
|
||
|
||
if (!av_dict_get(format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
|
||
av_dict_set(&format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
|
||
scan_all_pmts_set = 1;
|
||
}
|
||
// 禁用缓冲
|
||
av_dict_set(&format_opts, "fflags", "nobuffer", AV_DICT_MATCH_CASE);
|
||
// 设置媒体流分析最大字节数
|
||
av_dict_set(&format_opts, "probesize", "10000", AV_DICT_MATCH_CASE);
|
||
|
||
retry:
|
||
// 打开输入流
|
||
ret = avformat_open_input(&ic, config->url, nullptr, &format_opts);
|
||
if (ret < 0) {
|
||
LogE("avformat_open_input failed.\n");
|
||
goto fail;
|
||
}
|
||
if (scan_all_pmts_set)
|
||
av_dict_set(&format_opts, "scan_all_pmts", nullptr, AV_DICT_MATCH_CASE);
|
||
|
||
av_format_inject_global_side_data(ic);
|
||
|
||
ret = avformat_find_stream_info(ic, nullptr);
|
||
if (ret < 0) {
|
||
// LOG(ERROR) << url << ": could not find codec parameters";
|
||
LogE("{} : could not find codec parameters\n", config->url);
|
||
goto fail;
|
||
}
|
||
|
||
if (ic->pb)
|
||
ic->pb->eof_reached = 0;
|
||
|
||
// 打印输入流参数
|
||
av_dump_format(ic, 0, config->url, 0);
|
||
|
||
st_index = av_find_best_stream(ic, AVMEDIA_TYPE_AUDIO, -1, -1, nullptr, 0);
|
||
if (st_index >= 0) {
|
||
//
|
||
config->stream = ic->streams[st_index];
|
||
}
|
||
else {
|
||
LogW("find audio stream failed, try again.\n");
|
||
avformat_close_input(&ic);
|
||
goto retry;
|
||
}
|
||
|
||
// 初始化解码器
|
||
codecPar = config->stream->codecpar;
|
||
codec = avcodec_find_decoder(codecPar->codec_id);
|
||
if (!codec) {
|
||
LogE("find codec failed.\n");
|
||
goto fail;
|
||
}
|
||
|
||
codecCtx = avcodec_alloc_context3(codec);
|
||
if (!codecCtx) {
|
||
LogE("avcodec_alloc_context3 failed.\n");
|
||
goto fail;
|
||
}
|
||
ret = avcodec_parameters_to_context(codecCtx, codecPar);
|
||
if (ret < 0) {
|
||
LogE("avcodec_parameters_to_context\n");
|
||
goto fail;
|
||
}
|
||
|
||
codecCtx->time_base = config->stream->time_base;
|
||
// 打开解码器
|
||
if (avcodec_open2(codecCtx, codec, nullptr) < 0){
|
||
LogE("avcodec_open2 failed\n");
|
||
goto fail;
|
||
}
|
||
// 重采样初始化
|
||
swrCtx = swr_alloc_set_opts(nullptr,
|
||
av_get_default_channel_layout(channels),
|
||
format,
|
||
sample_rate,
|
||
codecCtx->channel_layout,
|
||
codecCtx->sample_fmt,
|
||
codecCtx->sample_rate,
|
||
0, nullptr);
|
||
if (!swrCtx) {
|
||
LogE("swr_alloc_set_opts failed.\n");
|
||
goto fail;
|
||
}
|
||
swr_init(swrCtx);
|
||
|
||
config->formatCtx = ic;
|
||
config->codecCtx = codecCtx;
|
||
config->swrCtx = swrCtx;
|
||
config->stream->discard = AVDISCARD_DEFAULT;
|
||
|
||
av_dict_free(&format_opts);
|
||
|
||
return 0;
|
||
fail:
|
||
if (format_opts)
|
||
av_dict_free(&format_opts);
|
||
if (ic)
|
||
avformat_close_input(&ic);
|
||
if (codecCtx) {
|
||
avcodec_close(codecCtx);
|
||
avcodec_free_context(&codecCtx);
|
||
}
|
||
if (swrCtx) {
|
||
swr_close(swrCtx);
|
||
swr_free(&swrCtx);
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
void playbackLoop(RtmpConfig *rtmp, std::vector<audio_buf_t> *list,
|
||
webrtc::AudioProcessing *apm, alsa::AlsaDev* play);
|
||
|
||
int main(int argc, char *argv[])
|
||
{
|
||
if (argc < 3) {
|
||
fprintf(stderr, "usage %s card_num url\n", argv[0]);
|
||
return -1;
|
||
}
|
||
//初始化日志系统
|
||
Logger::Instance().add(std::make_shared<ConsoleChannel> ());
|
||
Logger::Instance().add(std::make_shared<FileChannel>());
|
||
Logger::Instance().setWriter(std::make_shared<AsyncLogWriter>());
|
||
|
||
// 初始化声卡设备
|
||
int card = atoi(argv[1]);
|
||
alsa::Config alsaConfig;
|
||
alsaConfig.period_time = 10000;
|
||
alsaConfig.buffer_time = 50000;
|
||
alsaConfig.channels = MIX_INPUT_CHANNELS;
|
||
alsaConfig.format = SND_PCM_FORMAT_S16_LE;
|
||
alsaConfig.rate = MIX_INPUT_SAMPLE_RATE;
|
||
if (card < 0)
|
||
sprintf(alsaConfig.device, "default");
|
||
else
|
||
sprintf(alsaConfig.device, "plughw:%d", card);
|
||
alsa::AlsaDev usbPlaybackDev;
|
||
if (usbPlaybackDev.applyConfig(alsaConfig) < 0) {
|
||
PrintE("alsa config failed.\n");
|
||
return -1;
|
||
}
|
||
// PrintI("alsa before init: %s\n", usbPlaybackDev.configToString());
|
||
if (usbPlaybackDev.init(SND_PCM_STREAM_PLAYBACK) < 0) {
|
||
PrintE("alsa init failed.\n");
|
||
return -1;
|
||
}
|
||
PrintI("alsa init: %s\n", usbPlaybackDev.configToString());
|
||
|
||
// webrtc初始化
|
||
webrtc::AudioProcessing *apm = webrtc::AudioProcessingBuilder().Create();
|
||
if (!apm) {
|
||
LogI("create apm failed.\n");
|
||
return -1;
|
||
}
|
||
webrtc::AudioProcessing::Config apmConfig = webtcConfigInit();
|
||
apm->ApplyConfig(apmConfig);
|
||
apm->Initialize();
|
||
apm->set_stream_analog_level(408);
|
||
|
||
LogI("webrtc params: {\n%s\n}\n", apmConfig.ToString().c_str());
|
||
|
||
// 拉流初始化
|
||
RtmpConfig rtmp;
|
||
memset(&rtmp, 0, sizeof(rtmp));
|
||
strcpy(rtmp.url, argv[2]);
|
||
if (pullInit(&rtmp, MIX_INPUT_CHANNELS, AV_SAMPLE_FMT_S16, MIX_INPUT_SAMPLE_RATE) < 0) {
|
||
return -1;
|
||
}
|
||
AVPacket *pkt = av_packet_alloc();
|
||
AVFrame *outputFrame = av_frame_alloc();
|
||
int maxBuffSize = 1024 * 4 * 2;
|
||
uint8_t *swrBuffer = (uint8_t *)calloc(maxBuffSize, sizeof(uint8_t));
|
||
|
||
int ret;
|
||
std::vector<audio_buf_t> swr_list;
|
||
|
||
rtmp.mutex = new std::mutex;
|
||
rtmp.thread = new std::thread(playbackLoop, &rtmp, &swr_list, apm, &usbPlaybackDev);
|
||
rtmp.quit = false;
|
||
while (true)
|
||
{
|
||
if (av_read_frame(rtmp.formatCtx, pkt) >= 0 &&
|
||
pkt->stream_index == rtmp.stream->index) {
|
||
ret = avcodec_send_packet(rtmp.codecCtx, pkt);
|
||
if (ret == AVERROR(EAGAIN)) {
|
||
LogW("send packet again.\n");
|
||
av_usleep(10*1000);
|
||
continue;
|
||
}
|
||
else if (ret < 0) {
|
||
LogE("send packet error ret={}\n", ret);
|
||
break;
|
||
}
|
||
|
||
while ( avcodec_receive_frame(rtmp.codecCtx, outputFrame) >= 0 ) {
|
||
int outSamples = swr_convert(rtmp.swrCtx, &swrBuffer, maxBuffSize/(sizeof(int16_t) * MIX_INPUT_CHANNELS),
|
||
(uint8_t const **) (outputFrame->data), outputFrame->nb_samples);
|
||
int size = outSamples * MIX_INPUT_CHANNELS * av_get_bytes_per_sample(AV_SAMPLE_FMT_S16);
|
||
|
||
{
|
||
int size = outSamples * MIX_INPUT_CHANNELS * av_get_bytes_per_sample(AV_SAMPLE_FMT_S16);
|
||
uint8_t *buffer = (uint8_t *)calloc(size, sizeof(uint8_t));
|
||
memcpy(buffer, swrBuffer, size);
|
||
|
||
std::unique_lock<std::mutex> lck(*rtmp.mutex);
|
||
audio_buf_t out;
|
||
out.data = buffer;
|
||
out.index = 0;
|
||
out.size = size;
|
||
swr_list.emplace_back(out);
|
||
|
||
// if (out_fp) fwrite(buffer, 1, size, out_fp);
|
||
}
|
||
}
|
||
|
||
av_frame_unref(outputFrame);
|
||
}
|
||
av_packet_unref(pkt);
|
||
}
|
||
|
||
if (apm) {
|
||
delete apm;
|
||
apm = nullptr;
|
||
}
|
||
pullDestory(&rtmp);
|
||
return 0;
|
||
}
|
||
|
||
|
||
void playbackLoop(RtmpConfig *rtmp, std::vector<audio_buf_t> *list, webrtc::AudioProcessing *apm, alsa::AlsaDev* play)
|
||
{
|
||
//
|
||
webrtc::StreamConfig playConfig;
|
||
playConfig.set_has_keyboard(false);
|
||
playConfig.set_num_channels(kPcmSampleInfo.channels);
|
||
playConfig.set_sample_rate_hz(kPcmSampleInfo.sample_rate);
|
||
|
||
int sampleSize = 0;
|
||
int outSize = MIX_INPUT_SAMPLES * MIX_INPUT_CHANNELS * sizeof(int16_t);
|
||
uint8_t *outBuffer = (uint8_t *)calloc(outSize, sizeof(uint8_t));
|
||
// FILE *out_fp = fopen("/root/swr_out.pcm", "wb");
|
||
while (!rtmp->quit) {
|
||
// 获取 MIX_INPUT_SAMPLES 长度的解码音频，填充到outBuffer中
|
||
sampleSize = outSize;
|
||
while (sampleSize > 0)
|
||
{
|
||
if (list->size() <= 0) {
|
||
av_usleep(1000);
|
||
continue;
|
||
}
|
||
std::unique_lock<std::mutex> lck(*rtmp->mutex);
|
||
auto data = list->begin();
|
||
|
||
int readSize = sampleSize < (data->size - data->index) ? sampleSize : (data->size - data->index);
|
||
|
||
memcpy(outBuffer + outSize - sampleSize, data->data + data->index, readSize);
|
||
sampleSize -= readSize;
|
||
data->index += readSize;
|
||
if (data->index >= data->size) {
|
||
free(data->data);
|
||
list->erase(list->begin());
|
||
}
|
||
}
|
||
// if (out_fp) fwrite(outBuffer, 1, outSize, out_fp);
|
||
|
||
// 音频处理
|
||
{
|
||
apm->ProcessStream((int16_t *)outBuffer, playConfig, playConfig, (int16_t *)outBuffer);
|
||
}
|
||
|
||
play->write(outBuffer, outSize);
|
||
}
|
||
} |