Skip to content
TheChatArchiveThe Chat Archive
Geminigemini-2.5-pro· GoogleHugging Face LMArena Human Preference 140K

#include "agentaudiomediaport.h" #include "logger.h" #include <fstream> void…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Qwenqwen3-30b-a3b’s answer.
  1. User

    #include "agent_audiomediaport.h" #include "logger.h" #include

    void AgentAudioMediaPort::onFrameRequested(pj::MediaFrame &frame) { static double phase = 0.0; static int frameCount = 0;

    const int sampleRate = 8000;
    const int channels = 1;
    const int duration_ms = 20;
    const int samplesPerFrame = sampleRate * duration_ms / 1000;
    const int bytesPerSample = 2;
    const int frameSize = samplesPerFrame * channels * bytesPerSample;
    
    frame.size = frameSize;
    frame.buf.resize(frameSize);
    
    const int framesPerCycle = 30;
    int cyclePos = frameCount % framesPerCycle;
    
    double freq = 0.0;
    if (cyclePos < 10) {
        freq = 300.0;
    }
    else if (cyclePos < 20) {
        freq = 500.0;
    }
    else {
        freq = 0.0;
    }
    
    for (int i = 0; i < samplesPerFrame; ++i) {
        int16_t sample = 0;
        if (freq > 0.0) {
            sample = static_cast<int16_t>(std::sin(phase) * 6000); // 6000 是振幅
            phase += 2.0 * M_PI * freq / sampleRate;
            if (phase > 2.0 * M_PI)
                phase -= 2.0 * M_PI;
        }
        frame.buf[i * 2 + 0] = sample & 0xFF;
        frame.buf[i * 2 + 1] = (sample >> 8) & 0xFF;
    }
    
    static std::ofstream pcm_out(
        "input.pcm",
        std::ios::binary | std::ios::out | std::ios::trunc);
    if (!pcm_out.is_open()) {
        LOG_ERROR("Failed to open output.pcm");
        return;
    }
    pcm_out.write(reinterpret_cast<char *>(frame.buf.data()), frame.size);
    
    ++frameCount;
    LOG_INFO("Simulated frame {} with freq {}", frameCount, freq);
    

    }

    void AgentAudioMediaPort::onFrameReceived(pj::MediaFrame &frame) { LOG_INFO("{} frame size: {}", FUNCTION, frame.size);

    static std::ofstream pcm_out(
        "output.pcm",
        std::ios::binary | std::ios::out | std::ios::trunc);
    if (!pcm_out.is_open()) {
        LOG_ERROR("Failed to open output.pcm");
        return;
    }
    pcm_out.write(reinterpret_cast<char *>(frame.buf.data()), frame.size);
    

    }

    /* // LOG_INFO(">>> {}", FUNCTION); // LOG_INFO(" frame type: {}", frame.type); // for (unsigned i = 0; i < frame.size; ++i) { // LOG_INFO(" frame[{}]: {}", i, static_cast(frame.buf[i])); // } // LOG_INFO("<<< {}", FUNCTION); */

    #include "caller.h" #include "vaccount.h" #include "request.hpp" #include "caller_queue.h" #include "logger.h" #include "request.hpp" #include "global.h"

    voip::Caller::Caller(voip::VAccount &acc, int call_id) : pj::Call(acc, call_id), acc_(acc), m_aud_media_port(std::make_shared()) { pj::MediaFormatAudio fmt; fmt.type = PJMEDIA_TYPE_AUDIO; fmt.id = PJMEDIA_FORMAT_PCMA; // 或 PCM16, PCMA, etc. fmt.clockRate = 8000; // 8000Hz fmt.channelCount = 1; // fmt.frameTimeUsec = 20000; // 20ms fmt.bitsPerSample = 16;

    m_aud_media_port->createPort("media-port", fmt);
    
    // m_aud_media_port2->createPort("media-port2", fmt);
    

    }

    voip::Caller::~Caller() { pj::CallOpParam prm; this->hangup(prm); }

    void voip::Caller::call( const std::string &phone, const std::string &client_id, const int dialplan_id) { m_dialplan_id = dialplan_id; m_phone = phone; m_client_id = client_id; aud_media_recorder_.reset(); aud_media_recorder_ = std::make_sharedpj::AudioMediaRecorder(); auto now = std::chrono::system_clock::now(); now_time = std::chrono::system_clock::to_time_t(now); m_filename = phone + "" + std::to_string(dialplan_id) + "" + std::to_string(now_time) + ".wav"; // aud_media_recorder_->createRecorder(m_filename); const std::string dst_uri = "sip:" + phone + "@" + acc_.getHost(); LOG_INFO("dst_uri: {}", dst_uri); const pj::CallOpParam prm {true}; this->makeCall(dst_uri, prm); }

    void voip::Caller::onCallTsxState(pj::OnCallTsxStateParam &prm) { PJ_UNUSED_ARG(prm);

    // pj::CallInfo ci = getInfo();
    
    // int statusCode = ci.lastStatusCode;
    // std::string statusText = ci.lastReason;
    
    // LOG_INFO("call status: {} {}", statusCode, statusText);
    
    // if (statusCode == 404) {
    // }
    // else if (statusCode == 486) {
    // }
    // else if (statusCode == 603) {
    // }
    // else if (statusCode >= 400) {
    // }
    

    }

    void voip::Caller::onCallState(pj::OnCallStateParam &prm) { PJ_UNUSED_ARG(prm);

    pj::CallInfo ci = getInfo();
    LOG_INFO("call id: {} phone: {} state: {} code:{}",
             ci.id, m_phone, ci.stateText, (int)ci.lastStatusCode);
    if (!ci.lastReason.empty()) {
        LOG_INFO("call reason: {}", ci.lastReason);
    }
    
    switch (ci.state) {
        case PJSIP_INV_STATE_CONNECTING: {
            LOG_INFO(">>> call: {}, phone: {} connecting", ci.id, m_phone);
            break;
        }
        case PJSIP_INV_STATE_NULL: {
            LOG_INFO(">>> call: {}, phone: {} null", ci.id, m_phone);
            break;
        }
        case PJSIP_INV_STATE_CALLING: {
            LOG_INFO(">>> call: {}, phone: {} calling", ci.id, m_phone);
            // 其他线程接收到已经接通的线程的通知后,会结束拨打
            break;
        }
        case PJSIP_INV_STATE_CONFIRMED: {
            LOG_INFO(">>> call: {}, phone: {} confirmed", ci.id, m_phone);
            // 当前线程如果已经接通了,通知其他线程挂断电话
            break;
        }
        case PJSIP_INV_STATE_DISCONNECTED: {
            LOG_INFO(">>> call: {}, phone: {} disconnected", ci.id, m_phone);
            break;
        }
        default:
            break;
    }
    

    }

    void voip::Caller::onCallMediaState(pj::OnCallMediaStateParam &prm) { PJ_UNUSED_ARG(prm);

    pj::CallInfo ci = getInfo();
    LOG_INFO("call: {} Media State Changed: {}, media size: {}", ci.id, ci.stateText, ci.media.size());
    
    pj::AudioMedia *aud_med;
    pj::AudDevManager &mgr = pj::Endpoint::instance().audDevManager();
    auto cap_dev_med = mgr.getCaptureDevMedia();
    auto play_dev_med = mgr.getPlaybackDevMedia();
    
    for (unsigned i = 0; i < ci.media.size(); ++i) {
        if (ci.media[i].type == PJMEDIA_TYPE_AUDIO) {
            LOG_INFO("used media index: {}", i);
            aud_med = (pj::AudioMedia *)getMedia(i);
    
            // m_aud_media_player->startTransmit(*aud_med);
            // cap_dev_med.startTransmit(*aud_med);
            // aud_med->startTransmit(play_dev_med);
            aud_med->startTransmit(*m_aud_media_port);
            m_aud_media_port->startTransmit(*aud_med);
        }
    }
    

    }

    为什么客户那边(被呼叫方听到我的模拟音频)

  2. Gemini Assistant

    好的,这个问题非常经典,是 PJSIP 开发中一个常见的陷阱。

    你的代码逻辑大部分是正确的,媒体端口(AgentAudioMediaPort)的创建和连接(startTransmit)方式也基本正确。被叫方听不到你模拟的音频,或者听到的是噪音/杂音,其根本原因在于音频格式不匹配。


    核心问题:音频格式声明与实际数据不符

    让我们来分析两段关键代码:

    1. 在 Caller::Caller 构造函数中,你这样声明了媒体端口的格式:

      pj::MediaFormatAudio fmt;
      // ...
      fmt.id = PJMEDIA_FORMAT_PCMA; // <--- 问题在这里
      fmt.clockRate = 8000;
      fmt.bitsPerSample = 16;       // <--- 这个设置与 PCMA 冲突
      // ...
      m_aud_media_port->createPort("media-port", fmt);
      

      你告诉 PJSIP,你的 m_aud_media_port 将会提供 PCMA 格式的音频数据。PCMA (也称为 G.711 A-law) 是一种 8-bit 的对数压缩编码,主要用于电话系统。

    2. 在 AgentAudioMediaPort::onFrameRequested 中,你实际生成的音频数据是:

      const int bytesPerSample = 2; // 2字节 = 16位
      // ...
      int16_t sample = static_cast<int16_t>(std::sin(phase) * 6000);
      // ...
      // 将16位的 sample 存入缓冲区
      frame.buf[i * 2 + 0] = sample & 0xFF;
      frame.buf[i * 2 + 1] = (sample >> 8) & 0xFF;
      

      你生成的音频数据是 16位线性 PCM(Linear 16-bit PCM)。这是一种未经压缩的、高保真的原始音频格式。

    结论: 你向 PJSIP 承诺提供 PCMA 编码的数据,但实际上却给了它 L16 PCM 的原始数据。PJSIP 不会去检查你的数据是否真的符合你声明的格式。它会直接将你提供的这些 L16 PCM 数据当作 PCMA 数据打包到 RTP 包中发送出去。

    当被叫方的客户端收到这些 RTP 包后,它会按照约定的 PCMA 格式进行解码。用 PCMA 解码器去处理 L16 PCM 的原始字节流,结果自然是错误的,通常会表现为静音、刺耳的噪音或完全无法识别的杂音。


    如何修复

    你有两种修复方案,推荐使用第一种,因为它更简单且能更好地利用 PJSIP 框架的能力。

    方案一:修改媒体格式声明(推荐)

    将你在 Caller 构造函数中声明的媒体格式 id 改为与你生成的数据格式一致的 PJMEDIA_FORMAT_L16。PJSIP 将会自动处理编码转换。

    修改 voip::Caller::Caller 构造函数:

    voip::Caller::Caller(voip::VAccount &acc, int call_id) :
        pj::Call(acc, call_id),
        acc_(acc),
        m_aud_media_port(std::make_shared<AgentAudioMediaPort>())
    {
        pj::MediaFormatAudio fmt;
        fmt.type = PJMEDIA_TYPE_AUDIO;
    
        // *** 关键修改 ***
        // 声明我们的端口提供的是 16-bit Linear PCM 数据
        fmt.id = PJMEDIA_FORMAT_L16;
        
        fmt.clockRate = 8000;         // 采样率
        fmt.channelCount = 1;         // 单声道
        fmt.bitsPerSample = 16;       // 每个采样点16位
        fmt.frameTimeUsec = 20000;    // 帧时长 20ms
        // 对于 L16,avgBps 和 maxBps 可以这样计算
        fmt.avgBps = fmt.clockRate * fmt.bitsPerSample * fmt.channelCount;
        fmt.maxBps = fmt.avgBps;
    
        try {
            m_aud_media_port->createPort("media-port", fmt);
        } catch(pj::Error& err) {
            LOG_ERROR("Failed to create media port: {}", err.info());
        }
    }
    

    工作原理: 当你正确地将端口格式声明为 L16 后,PJSIP 的媒体框架就知道了你提供的是原始 PCM 数据。在 onCallMediaState 中,当你执行 m_aud_media_port->startTransmit(*aud_med) 时,PJSIP 会检查 m_aud_media_port 的格式(L16)和通话协商好的编解码器(例如,对方可能只支持 PCMA)。如果格式不匹配,PJSIP 会自动在两者之间插入一个转码器(transcoder),将你的 L16 数据实时转换为 PCMA(或其他协商好的格式),然后再发送出去。

    这样,你只需要关心生成最原始、最简单的 PCM 数据,而将复杂的编解码转换工作交给了 PJSIP 框架。

    方案二:修改数据生成逻辑(不推荐,更复杂)

    保持 fmt.id = PJMEDIA_FORMAT_PCMA; 的声明不变,但在 onFrameRequested 中,你需要手动将生成的 int16_t 样本编码为 PCMA 格式。你需要一个 L16 到 A-law 的转换函数。

    这通常更复杂,而且失去了 PJSIP 框架自动转码的便利性,所以不推荐这样做,除非有特殊性能要求。


    另一个潜在问题:static std::ofstream

    在你的 onFrameRequested 和 onFrameReceived 函数中,你使用了 static std::ofstream。

    // 在 onFrameRequested 中
    static std::ofstream pcm_out(
        "input.pcm",
        std::ios::binary | std::ios::out | std::ios::trunc);
    
    // 在 onFrameReceived 中
    static std::ofstream pcm_out(
        "output.pcm",
        std::ios::binary | std::ios::out | std::ios::trunc);
    

    static 局部变量只会在程序第一次执行到该行代码时被初始化一次。std::ios::trunc 标志意味着文件在第一次打开时会被清空。

    这会导致以下问题:

    1. 多路通话干扰:如果你的程序同时处理多个 Caller 实例,它们会写入同一个 input.pcm 和 output.pcm 文件,导致数据混淆。
    2. 文件不会被重新创建:对于同一个 Caller 对象,如果它挂断后又发起了第二次呼叫,onFrameRequested 再次被调用时,pcm_out 不会重新初始化,文件不会被 trunc 清空,新的音频数据会追加到旧文件的末尾,这可能不是你想要的结果。

    正确的做法是: 将 ofstream 对象作为 AgentAudioMediaPort 的成员变量,在构造时打开文件,在析构时关闭。

    修改示例:

    1. agent_audiomediaport.h

      #include <fstream>
      
      class AgentAudioMediaPort : public pj::AudioMediaPort
      {
      public:
          AgentAudioMediaPort();
          ~AgentAudioMediaPort();
      
          // ... 其他函数 ...
      private:
          std::ofstream m_input_pcm_file;
          std::ofstream m_output_pcm_file;
      };
      
    2. agent_audiomediaport.cpp

      AgentAudioMediaPort::AgentAudioMediaPort()
      {
          // 使用 unique_ptr 或其他方式保证文件名唯一,或在需要时再打开
          m_input_pcm_file.open("input.pcm", std::ios::binary | std::ios::out | std::ios::trunc);
          m_output_pcm_file.open("output.pcm", std::ios::binary | std::ios::out | std::ios::trunc);
      }
      
      AgentAudioMediaPort::~AgentAudioMediaPort()
      {
          if (m_input_pcm_file.is_open()) {
              m_input_pcm_file.close();
          }
          if (m_output_pcm_file.is_open()) {
              m_output_pcm_file.close();
          }
      }
      
      void AgentAudioMediaPort::onFrameRequested(pj::MediaFrame &frame)
      {
          // ... 生成音频数据的逻辑不变 ...
          
          if (!m_input_pcm_file.is_open()) {
              LOG_ERROR("Failed to open input.pcm");
          } else {
              m_input_pcm_file.write(reinterpret_cast<char *>(frame.buf.data()), frame.size);
          }
      
          // ...
      }
      
      void AgentAudioMediaPort::onFrameReceived(pj::MediaFrame &frame)
      {
          // ...
          if (!m_output_pcm_file.is_open()) {
              LOG_ERROR("Failed to open output.pcm");
          } else {
              m_output_pcm_file.write(reinterpret_cast<char *>(frame.buf.data()), frame.size);
          }
      }
      

    总结

    1. 主要问题:将 Caller 构造函数中创建 AgentAudioMediaPort 时使用的 fmt.id 从 PJMEDIA_FORMAT_PCMA 修改为 PJMEDIA_FORMAT_L16。
    2. 次要问题:将用于调试的 static std::ofstream 改为类的成员变量,以避免多线程/多实例下的文件写入冲突和逻辑错误。

    完成这些修改后,你的程序应该就能正常工作,被叫方将会清晰地听到你生成的周期性变化频率的提示音。

  3. User

    确实是音频格式不对,那我应该如何进行修改

  4. Gemini Assistant

    好的,我们来解决这个问题。

    最直接、也是最推荐的修改方法是:让您声明的音频格式与您实际生成的音频数据格式保持一致。

    您在 onFrameRequested 中生成的是 16-bit Linear PCM 数据,所以您应该在创建媒体端口时就告诉 PJSIP 您提供的是这种格式的数据。PJSIP 的媒体框架非常强大,它会自动帮您处理后续的编码转换。

    修改步骤

    您只需要修改 voip::Caller::Caller 这个构造函数中的一处代码即可。

    定位文件: caller.cpp (或您定义 Caller 类的文件) 定位函数: voip::Caller::Caller(...)


    原始代码 (问题所在)

    voip::Caller::Caller(voip::VAccount &acc, int call_id) :
        pj::Call(acc, call_id),
        acc_(acc),
        m_aud_media_port(std::make_shared<AgentAudioMediaPort>())
    {
        pj::MediaFormatAudio fmt;
        fmt.type = PJMEDIA_TYPE_AUDIO;
        fmt.id = PJMEDIA_FORMAT_PCMA; // <--- 问题在这里:声明为PCMA
        fmt.clockRate = 8000;
        fmt.channelCount = 1;
        fmt.frameTimeUsec = 20000;
        fmt.bitsPerSample = 16;       // <--- 这个设置与PCMA(8-bit)是矛盾的
    
        m_aud_media_port->createPort("media-port", fmt);
    }
    

    修改后的代码 (正确方案)

    将 fmt.id 修改为 PJMEDIA_FORMAT_L16,并确保其他参数与 L16 格式匹配。

    #include "caller.h"
    #include "vaccount.h"
    // ... 其他头文件
    
    voip::Caller::Caller(voip::VAccount &acc, int call_id) :
        pj::Call(acc, call_id),
        acc_(acc),
        m_aud_media_port(std::make_shared<AgentAudioMediaPort>())
    {
        pj::MediaFormatAudio fmt;
        fmt.type = PJMEDIA_TYPE_AUDIO;
        
        // *** 核心修改 ***
        // 告诉 PJSIP,我们的媒体端口将提供 16-bit Linear PCM 格式的原始音频数据。
        // "L16" 是 "Linear 16-bit" 的缩写。
        fmt.id = PJMEDIA_FORMAT_L16; 
        
        fmt.clockRate = 8000;         // 采样率
        fmt.channelCount = 1;         // 单声道
        fmt.bitsPerSample = 16;       // 每个采样点16位 (这现在与 L16 格式一致了)
        fmt.frameTimeUsec = 20000;    // 帧时长 20ms
    
        // (可选但推荐) 为 L16 格式明确计算比特率
        fmt.avgBps = fmt.clockRate * fmt.bitsPerSample * fmt.channelCount;
        fmt.maxBps = fmt.avgBps;
    
        try {
            m_aud_media_port->createPort("media-port", fmt);
        } catch(pj::Error& err) {
            LOG_ERROR("Failed to create media port: {}", err.info());
            // 最好在这里处理异常,避免程序崩溃
        }
    }
    

    为什么这样修改能解决问题?

    这个修改的工作原理如下:

    1. 诚实声明:您现在正确地告诉了 PJSIP 媒体框架,您的 m_aud_media_port 会源源不断地产生 L16 PCM 格式的原始音频数据。

    2. 通话协商:当您的程序与被叫方建立通话时,双方会通过 SDP 协议协商一个共同支持的音频编解码器,比如 PCMA (G.711 A-law) 或 PCMU (G.711 μ-law),这些是电话系统中最常见的编解码器。

    3. 自动转码:在 onCallMediaState 回调中,当您执行 m_aud_media_port->startTransmit(*aud_med) 时,PJSIP 会检查连接双方的媒体格式:

      • 源:您的 m_aud_media_port,格式是 L16。
      • 目标:通话的 aud_med,格式是通话协商好的编解码器(例如 PCMA)。
    4. 无缝连接:PJSIP 发现源和目标的格式不同,它会自动在两者之间插入一个转码器(transcoder)。这个转码器会实时地将您生成的 L16 原始音频数据转换成 PCMA 编码的数据,然后再打包成 RTP 包发送给对方。

    对方的电话/客户端收到的是格式完全正确的 PCMA 音频流,因此可以正常解码并播放出您生成的正弦波声音。

    总结一下:您只需要负责生成最简单的原始 PCM 音频,所有复杂的编解码工作都由 PJSIP 框架在后台自动完成。这是使用 PJSIP 的正确且高效的方式。

    您只需替换掉 voip::Caller::Caller 构造函数中的代码,重新编译并运行,被叫方就能听到您模拟的音频了。

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.