path: root/indra/llwebrtc/llwebrtc.cpp

/**
 * @file llaccordionctrl.cpp
 * @brief Accordion panel  implementation
 *
 * $LicenseInfo:firstyear=2023&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2023, Linden Research, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation;
 * version 2.1 of the License only.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
 * $/LicenseInfo$
 */

#include "llwebrtc_impl.h"
#include <algorithm>
#include <format>

#include "api/audio_codecs/audio_decoder_factory.h"
#include "api/audio_codecs/audio_encoder_factory.h"
#include "api/audio_codecs/builtin_audio_decoder_factory.h"
#include "api/audio_codecs/builtin_audio_encoder_factory.h"
#include "api/media_stream_interface.h"
#include "api/media_stream_track.h"

namespace llwebrtc
{

const float VOLUME_SCALE_WEBRTC = 3.0f;

LLAudioDeviceObserver::LLAudioDeviceObserver() : mMicrophoneEnergy(0.0), mSumVector {0} {}

double LLAudioDeviceObserver::getMicrophoneEnergy() { return mMicrophoneEnergy; }

void LLAudioDeviceObserver::OnCaptureData(const void    *audio_samples,
                                         const size_t   num_samples,
                                         const size_t   bytes_per_sample,
                                         const size_t   num_channels,
                                         const uint32_t samples_per_sec)
{
    float       energy  = 0;
    const short *samples = (const short *) audio_samples;
    for (size_t index = 0; index < num_samples * num_channels; index++)
    {
        float sample = (static_cast<float>(samples[index]) / (float) 32768);
        energy += sample * sample;
    }

    // smooth it.
    size_t buffer_size = sizeof(mSumVector) / sizeof(mSumVector[0]);
    float totalSum = 0; 
    int i;
    for (i = 0; i < (buffer_size - 1); i++)
    {
        mSumVector[i] = mSumVector[i + 1];
        totalSum += mSumVector[i];
    }
    mSumVector[i] = energy;
    totalSum += energy;
    mMicrophoneEnergy = std::sqrt(totalSum / (num_samples * buffer_size));
}

void LLAudioDeviceObserver::OnRenderData(const void    *audio_samples,
                                        const size_t   num_samples,
                                        const size_t   bytes_per_sample,
                                        const size_t   num_channels,
                                        const uint32_t samples_per_sec)
{
}


void LLWebRTCImpl::init()
{
    mAnswerReceived = false;
    rtc::InitializeSSL();
    mTaskQueueFactory = webrtc::CreateDefaultTaskQueueFactory();

    mNetworkThread = rtc::Thread::CreateWithSocketServer();
    mNetworkThread->SetName("WebRTCNetworkThread", nullptr);
    mNetworkThread->Start();
    mWorkerThread = rtc::Thread::Create();
    mWorkerThread->SetName("WebRTCWorkerThread", nullptr);
    mWorkerThread->Start();
    mSignalingThread = rtc::Thread::Create();
    mSignalingThread->SetName("WebRTCSignalingThread", nullptr);
    mSignalingThread->Start();

    mWorkerThread->PostTask(
        [this]()
        {
            mAudioDeviceObserver = new LLAudioDeviceObserver;
            mDeviceModule = webrtc::CreateAudioDeviceWithDataObserver(webrtc::AudioDeviceModule::AudioLayer::kPlatformDefaultAudio,
                                                                      mTaskQueueFactory.get(),
                                                                      std::unique_ptr<webrtc::AudioDeviceDataObserver>(mAudioDeviceObserver));
            mDeviceModule->Init();
            mDeviceModule->SetStereoRecording(false);
            mDeviceModule->EnableBuiltInAEC(false);
            updateDevices();
        });
}

void LLWebRTCImpl::terminate() 
{ 
    mSignalingThread->BlockingCall(
        [this]()
        {
            if (mPeerConnection)
            {
                mPeerConnection->Close();
                mPeerConnection = nullptr;
            }
            mPeerConnectionFactory = nullptr;
        });
    mWorkerThread->BlockingCall(
        [this]()
        {
            if (mDeviceModule)
            {
                mDeviceModule->Terminate();
            }
            mDeviceModule = nullptr;
            mTaskQueueFactory = nullptr;

        });
    mNetworkThread->BlockingCall(
        [this]()
        {
            if (mDataChannel)
            {
                mDataChannel->Close();
                mDataChannel = nullptr;
            }
        });
}


void LLWebRTCImpl::refreshDevices()
{
    mWorkerThread->PostTask([this]() { updateDevices(); });
}

void LLWebRTCImpl::setDevicesObserver(LLWebRTCDevicesObserver *observer) { mVoiceDevicesObserverList.emplace_back(observer); }

void LLWebRTCImpl::unsetDevicesObserver(LLWebRTCDevicesObserver *observer)
{
    std::vector<LLWebRTCDevicesObserver *>::iterator it =
        std::find(mVoiceDevicesObserverList.begin(), mVoiceDevicesObserverList.end(), observer);
    if (it != mVoiceDevicesObserverList.end())
    {
        mVoiceDevicesObserverList.erase(it);
    }
}

void LLWebRTCImpl::setCaptureDevice(const std::string &id)
{
    mWorkerThread->PostTask(
        [this, id]()
        {
            bool was_recording = mDeviceModule->Recording();

            if (was_recording)
            {
                mDeviceModule->StopRecording();
            }
            int16_t captureDeviceCount = mDeviceModule->RecordingDevices();
            int16_t index              = 0; /* default to first one if no match */
            for (int16_t i = 0; i < captureDeviceCount; i++)
            {
                char name[webrtc::kAdmMaxDeviceNameSize];
                char guid[webrtc::kAdmMaxGuidSize];
                mDeviceModule->RecordingDeviceName(i, name, guid);
                if (id == guid || id == "Default")
                {
                    RTC_LOG(LS_INFO) << __FUNCTION__ << "Set recording device to " << name << " " << guid << " " << i;
                    index = i;
                    break;
                }
            }
            mDeviceModule->SetRecordingDevice(index);
            mDeviceModule->InitMicrophone();
            mDeviceModule->InitRecording();
            if (was_recording)
            {
                mDeviceModule->StartRecording();
            }
        });
}

void LLWebRTCImpl::setRenderDevice(const std::string &id)
{
    mWorkerThread->PostTask(
        [this, id]()
        {
            bool was_playing = mDeviceModule->Playing();
            if (was_playing)
            {
                mDeviceModule->StopPlayout();
            }
            int16_t renderDeviceCount = mDeviceModule->PlayoutDevices();
            int16_t index             = 0; /* default to first one if no match */
            for (int16_t i = 0; i < renderDeviceCount; i++)
            {
                char name[webrtc::kAdmMaxDeviceNameSize];
                char guid[webrtc::kAdmMaxGuidSize];
                mDeviceModule->PlayoutDeviceName(i, name, guid);
                if (id == guid || id == "Default")
                {
                    RTC_LOG(LS_INFO) << __FUNCTION__ << "Set recording device to " << name << " " << guid << " " << i;
                    index = i;
                    break;
                }
            }
            mDeviceModule->SetPlayoutDevice(index);
            mDeviceModule->InitSpeaker();
            mDeviceModule->InitPlayout();
            if (was_playing)
            {
                mDeviceModule->StartPlayout();
            }
        });
}

void LLWebRTCImpl::updateDevices()
{
    int16_t                 renderDeviceCount = mDeviceModule->PlayoutDevices();
    LLWebRTCVoiceDeviceList renderDeviceList;
    for (int16_t index = 0; index < renderDeviceCount; index++)
    {
        char name[webrtc::kAdmMaxDeviceNameSize];
        char guid[webrtc::kAdmMaxGuidSize];
        mDeviceModule->PlayoutDeviceName(index, name, guid);
        renderDeviceList.emplace_back(name, guid);
    }

    int16_t                 captureDeviceCount = mDeviceModule->RecordingDevices();
    LLWebRTCVoiceDeviceList captureDeviceList;
    for (int16_t index = 0; index < captureDeviceCount; index++)
    {
        char name[webrtc::kAdmMaxDeviceNameSize];
        char guid[webrtc::kAdmMaxGuidSize];
        mDeviceModule->RecordingDeviceName(index, name, guid);
        captureDeviceList.emplace_back(name, guid);
    }
    for (auto &observer : mVoiceDevicesObserverList)
    {
        observer->OnDevicesChanged(renderDeviceList, captureDeviceList);
    }
}

void LLWebRTCImpl::setTuningMode(bool enable)
{
    mWorkerThread->PostTask(
        [this, enable]()
        {
            if (enable)
            {
                mDeviceModule->InitMicrophone();
                mDeviceModule->InitRecording();
                mDeviceModule->StartRecording();
                mDeviceModule->SetMicrophoneMute(false);
            }
            else
            {
                mDeviceModule->StopRecording();
            }
        });
}

//
// LLWebRTCSignalInterface
//

void LLWebRTCImpl::setSignalingObserver(LLWebRTCSignalingObserver *observer) { mSignalingObserverList.emplace_back(observer); }

void LLWebRTCImpl::unsetSignalingObserver(LLWebRTCSignalingObserver *observer)
{
    std::vector<LLWebRTCSignalingObserver *>::iterator it =
        std::find(mSignalingObserverList.begin(), mSignalingObserverList.end(), observer);
    if (it != mSignalingObserverList.end())
    {
        mSignalingObserverList.erase(it);
    }
}


bool LLWebRTCImpl::initializeConnection()
{
    RTC_DCHECK(!mPeerConnection);
    RTC_DCHECK(mPeerConnectionFactory);
    mAnswerReceived        = false;

    mSignalingThread->PostTask([this]() { initializeConnectionThreaded(); });
    return true;
}



bool LLWebRTCImpl::initializeConnectionThreaded()
{
    rtc::scoped_refptr<webrtc::AudioProcessing> apm = webrtc::AudioProcessingBuilder().Create();
    webrtc::AudioProcessing::Config  apm_config;
    apm_config.echo_canceller.enabled = false;
    apm_config.echo_canceller.mobile_mode = false;
    apm_config.gain_controller1.enabled   = true;
    apm_config.gain_controller1.mode      =
    webrtc::AudioProcessing::Config::GainController1::kAdaptiveAnalog;
    apm_config.gain_controller2.enabled   = true;
    apm_config.high_pass_filter.enabled  = true;
    apm_config.noise_suppression.enabled  = true;
    apm_config.noise_suppression.level    = webrtc::AudioProcessing::Config::NoiseSuppression::kVeryHigh;
    apm_config.transient_suppression.enabled = true;
    //
    apm->ApplyConfig(apm_config);

    mPeerConnectionFactory = webrtc::CreatePeerConnectionFactory(mNetworkThread.get(),
                                                                 mWorkerThread.get(),
                                                                 mSignalingThread.get(),
                                                                 mDeviceModule,
                                                                 webrtc::CreateBuiltinAudioEncoderFactory(),
                                                                 webrtc::CreateBuiltinAudioDecoderFactory(),
                                                                 nullptr /* video_encoder_factory */,
                                                                 nullptr /* video_decoder_factory */,
                                                                 nullptr /* audio_mixer */,
                                                                 apm);
    webrtc::PeerConnectionInterface::RTCConfiguration config;
    config.sdp_semantics = webrtc::SdpSemantics::kUnifiedPlan;
    webrtc::PeerConnectionInterface::IceServer server;
    server.uri = "stun:stun.l.google.com:19302";
    config.servers.push_back(server);
    server.uri = "stun:stun1.l.google.com:19302";
    config.servers.push_back(server);
    server.uri = "stun:stun2.l.google.com:19302";
    config.servers.push_back(server);
    server.uri = "stun:stun3.l.google.com:19302";
    config.servers.push_back(server);
    server.uri = "stun:stun4.l.google.com:19302";
    config.servers.push_back(server);

    webrtc::PeerConnectionDependencies pc_dependencies(this);
    auto error_or_peer_connection = mPeerConnectionFactory->CreatePeerConnectionOrError(config, std::move(pc_dependencies));
    if (error_or_peer_connection.ok())
    {
        mPeerConnection = std::move(error_or_peer_connection.value());
    }
    else
    {
        shutdownConnection();
        return false;
    }

    webrtc::DataChannelInit init;
    init.ordered = true;

    auto data_channel_or_error = mPeerConnection->CreateDataChannelOrError("SLData", &init);
    if (data_channel_or_error.ok())
    {
        mDataChannel = std::move(data_channel_or_error.value());

        mDataChannel->RegisterObserver(this);
    }

    RTC_LOG(LS_INFO) << __FUNCTION__ << " " << mPeerConnection->signaling_state();

    cricket::AudioOptions audioOptions;
    audioOptions.auto_gain_control = true;
    audioOptions.echo_cancellation = false;  // incompatible with opus stereo
    audioOptions.noise_suppression = true;

    rtc::scoped_refptr<webrtc::MediaStreamInterface> stream = mPeerConnectionFactory->CreateLocalMediaStream("SLStream");
    rtc::scoped_refptr<webrtc::AudioTrackInterface>  audio_track(
        mPeerConnectionFactory->CreateAudioTrack("SLAudio", mPeerConnectionFactory->CreateAudioSource(audioOptions).get()));
    audio_track->set_enabled(true);
    stream->AddTrack(audio_track);

    mPeerConnection->AddTrack(audio_track, {"SLStream"});

    auto senders = mPeerConnection->GetSenders();

    for (auto &sender : senders)
    {
        webrtc::RtpParameters      params;
        webrtc::RtpCodecParameters codecparam;
        codecparam.name                       = "opus";
        codecparam.kind                       = cricket::MEDIA_TYPE_AUDIO;
        codecparam.clock_rate                 = 48000;
        codecparam.num_channels               = 2;
        codecparam.parameters["stereo"]       = "1";
        codecparam.parameters["sprop-stereo"] = "1";
        params.codecs.push_back(codecparam);
        sender->SetParameters(params);
    }

    auto receivers = mPeerConnection->GetReceivers();
    for (auto& receiver : receivers)
    {
        webrtc::RtpParameters params;
        webrtc::RtpCodecParameters codecparam;
        codecparam.name                       = "opus";
        codecparam.kind                       = cricket::MEDIA_TYPE_AUDIO;
        codecparam.clock_rate                 = 48000;
        codecparam.num_channels               = 2;
        codecparam.parameters["stereo"]       = "1";
        codecparam.parameters["sprop-stereo"] = "1";
        params.codecs.push_back(codecparam);
        receiver->SetParameters(params);
    }

    mPeerConnection->SetLocalDescription(rtc::scoped_refptr<webrtc::SetLocalDescriptionObserverInterface>(this));

    RTC_LOG(LS_INFO) << __FUNCTION__ << " " << mPeerConnection->signaling_state();
    
    return true;
}

void LLWebRTCImpl::shutdownConnection()
{
    mPeerConnection        = nullptr;
    mPeerConnectionFactory = nullptr;
}

void LLWebRTCImpl::AnswerAvailable(const std::string &sdp)
{

    RTC_LOG(LS_INFO) << __FUNCTION__ << " Remote SDP: " << sdp;

    mSignalingThread->PostTask(
        [this, sdp]()
        {
            RTC_LOG(LS_INFO) << __FUNCTION__ << " " << mPeerConnection->peer_connection_state();
            mPeerConnection->SetRemoteDescription(webrtc::CreateSessionDescription(webrtc::SdpType::kAnswer, sdp),
                                                  rtc::scoped_refptr<webrtc::SetRemoteDescriptionObserverInterface>(this));
            mAnswerReceived = true;
            for (auto &observer : mSignalingObserverList)
            {
                for (auto &candidate : mCachedIceCandidates)
                {
                    LLWebRTCIceCandidate ice_candidate;
                    ice_candidate.candidate = candidate->candidate().ToString();
                    ice_candidate.mline_index = candidate->sdp_mline_index();
                    ice_candidate.sdp_mid     = candidate->sdp_mid();
                    observer->OnIceCandidate(ice_candidate);
                }
                mCachedIceCandidates.clear();
                if (mPeerConnection->ice_gathering_state() == webrtc::PeerConnectionInterface::IceGatheringState::kIceGatheringComplete)
                {
                    for (auto &observer : mSignalingObserverList)
                    {
                        observer->OnIceGatheringState(llwebrtc::LLWebRTCSignalingObserver::IceGatheringState::ICE_GATHERING_COMPLETE);
                    }
                }
            }
        });
}

void LLWebRTCImpl::setMute(bool mute)
{
    mSignalingThread->PostTask(
        [this,mute]()
        {
            auto senders = mPeerConnection->GetSenders();

            RTC_LOG(LS_INFO) << __FUNCTION__ << (mute ? "disabling" : "enabling") << " streams count "
                             << senders.size();

            for (auto& sender : senders)
            {
                sender->track()->set_enabled(!mute);
            }
        });
}

void LLWebRTCImpl::setSpeakerVolume(float volume)
{
    mSignalingThread->PostTask(
        [this, volume]()
        {
            auto receivers = mPeerConnection->GetReceivers();

            RTC_LOG(LS_INFO) << __FUNCTION__ << "Set volume" << receivers.size();
            for (auto &receiver : receivers)
            {
                webrtc::MediaStreamTrackInterface *track = receiver->track().get();
                if (track->kind() == webrtc::MediaStreamTrackInterface::kAudioKind)
                {
                    webrtc::AudioTrackInterface* audio_track = static_cast<webrtc::AudioTrackInterface*>(track);
                    webrtc::AudioSourceInterface* source = audio_track->GetSource();
                    source->SetVolume(VOLUME_SCALE_WEBRTC * volume);

                }
            }
        });
}

double LLWebRTCImpl::getAudioLevel()
{
    return 20*mAudioDeviceObserver->getMicrophoneEnergy();
}

//
// PeerConnectionObserver implementation.
//

void LLWebRTCImpl::OnAddTrack(rtc::scoped_refptr<webrtc::RtpReceiverInterface>                     receiver,
                              const std::vector<rtc::scoped_refptr<webrtc::MediaStreamInterface>> &streams)
{
    RTC_LOG(LS_INFO) << __FUNCTION__ << " " << receiver->id();
}

void LLWebRTCImpl::OnRemoveTrack(rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver)
{
    RTC_LOG(LS_INFO) << __FUNCTION__ << " " << receiver->id();
}

void LLWebRTCImpl::OnDataChannel(rtc::scoped_refptr<webrtc::DataChannelInterface> channel)
{
    mDataChannel = channel;
    channel->RegisterObserver(this); 
}


void LLWebRTCImpl::OnIceGatheringChange(webrtc::PeerConnectionInterface::IceGatheringState new_state)
{
    LLWebRTCSignalingObserver::IceGatheringState webrtc_new_state = LLWebRTCSignalingObserver::IceGatheringState::ICE_GATHERING_NEW;
    switch (new_state)
    {
        case webrtc::PeerConnectionInterface::IceGatheringState::kIceGatheringNew:
            webrtc_new_state = LLWebRTCSignalingObserver::IceGatheringState::ICE_GATHERING_NEW;
            break;
        case webrtc::PeerConnectionInterface::IceGatheringState::kIceGatheringGathering:
            webrtc_new_state = LLWebRTCSignalingObserver::IceGatheringState::ICE_GATHERING_GATHERING;
            break;
        case webrtc::PeerConnectionInterface::IceGatheringState::kIceGatheringComplete:
            webrtc_new_state = LLWebRTCSignalingObserver::IceGatheringState::ICE_GATHERING_COMPLETE;
            break;
        default:
            RTC_LOG(LS_ERROR) << __FUNCTION__ << " Bad Ice Gathering State" << new_state;
            webrtc_new_state = LLWebRTCSignalingObserver::IceGatheringState::ICE_GATHERING_NEW;
            return;
    }

    if (mAnswerReceived)
    {
        for (auto &observer : mSignalingObserverList)
        {
            observer->OnIceGatheringState(webrtc_new_state);
        }
    }
}

// Called any time the PeerConnectionState changes.
void LLWebRTCImpl::OnConnectionChange(webrtc::PeerConnectionInterface::PeerConnectionState new_state)
{
    RTC_LOG(LS_ERROR) << __FUNCTION__ << " Peer Connection State Change " << new_state;

    switch (new_state)
    {
        case webrtc::PeerConnectionInterface::PeerConnectionState::kConnected:
        {
            if (new_state == webrtc::PeerConnectionInterface::PeerConnectionState::kConnected)
            {
                mWorkerThread->PostTask([this]() {
                    mDeviceModule->StartRecording();
                    mDeviceModule->StartPlayout();
                    for (auto &observer : mSignalingObserverList)
                    {
                        observer->OnAudioEstablished(this);
                    }
                });
            }
            break;
        }
        case webrtc::PeerConnectionInterface::PeerConnectionState::kFailed:
        {
            for (auto &observer : mSignalingObserverList)
            {
                observer->OnRenegotiationNeeded();
            }

            break;
        }
        default:
        {
            break;
        }
    }
}

void LLWebRTCImpl::OnIceCandidate(const webrtc::IceCandidateInterface *candidate)
{
    RTC_LOG(LS_INFO) << __FUNCTION__ << " " << candidate->sdp_mline_index();

    if (!candidate)
    {
        RTC_LOG(LS_ERROR) << __FUNCTION__ << " No Ice Candidate Given";
        return;
    }
    if (mAnswerReceived) 
    {
        for (auto &observer : mSignalingObserverList)
        {
            LLWebRTCIceCandidate ice_candidate;
            ice_candidate.candidate   = candidate->candidate().ToString();
            ice_candidate.mline_index = candidate->sdp_mline_index();
            ice_candidate.sdp_mid     = candidate->sdp_mid();
            observer->OnIceCandidate(ice_candidate);
        }
    }
    else 
    {
        mCachedIceCandidates.push_back(
            webrtc::CreateIceCandidate(candidate->sdp_mid(), candidate->sdp_mline_index(), candidate->candidate()));
    }
}

//
// CreateSessionDescriptionObserver implementation.
//
void LLWebRTCImpl::OnSuccess(webrtc::SessionDescriptionInterface *desc)
{
    std::string sdp;
    desc->ToString(&sdp);
    RTC_LOG(LS_INFO) << sdp;

    RTC_LOG(LS_INFO) << __FUNCTION__ << " " << mPeerConnection->signaling_state();
    for (auto &observer : mSignalingObserverList)
    {
        observer->OnOfferAvailable(sdp);
    }
}

void LLWebRTCImpl::OnFailure(webrtc::RTCError error) { RTC_LOG(LS_ERROR) << ToString(error.type()) << ": " << error.message(); }

//
// SetRemoteDescriptionObserverInterface implementation.
//
void LLWebRTCImpl::OnSetRemoteDescriptionComplete(webrtc::RTCError error)
{
    RTC_LOG(LS_INFO) << __FUNCTION__ << " " << mPeerConnection->signaling_state();
    if (!error.ok())
    {
        RTC_LOG(LS_ERROR) << ToString(error.type()) << ": " << error.message();
        return;
    }
}

//
// SetLocalDescriptionObserverInterface implementation.
//
void LLWebRTCImpl::OnSetLocalDescriptionComplete(webrtc::RTCError error)
{
    RTC_LOG(LS_INFO) << __FUNCTION__ << " " << mPeerConnection->signaling_state();
    if (!error.ok())
    {
        RTC_LOG(LS_ERROR) << ToString(error.type()) << ": " << error.message();
        return;
    }
    auto        desc = mPeerConnection->pending_local_description();
    std::string sdp;
    desc->ToString(&sdp);
    // mangle the sdp as this is the only way currently to bump up
    // the send audio rate to 48k
    std::istringstream sdp_stream(sdp);
    std::ostringstream sdp_mangled_stream;
    std::string        sdp_line;
    int                opus_payload = 0;
    while (std::getline(sdp_stream, sdp_line)) {
        int bandwidth = 0;
        int payload_id = 0;
        // force mono down, stereo up
        if (std::sscanf(sdp_line.c_str(), "a=rtpmap:%i opus/%i/2", &payload_id, &bandwidth) == 2)
        {
            sdp_mangled_stream << sdp_line << "\n";
            opus_payload = payload_id;
        }
        else if (sdp_line.rfind(std::format("a=fmtp:{}", opus_payload)) == 0) 
        {
            sdp_mangled_stream << sdp_line << "a=fmtp:" << opus_payload
                               << " stereo=1;sprop-stereo=0;minptime=10;useinbandfec=1;maxplaybackrate=48000\n";
        }
        else
        {
            sdp_mangled_stream << sdp_line << "\n";
        }
    }
    RTC_LOG(LS_INFO) << __FUNCTION__ << " Local SDP: " << sdp_mangled_stream.str();
    ;
    for (auto &observer : mSignalingObserverList)
    {
        observer->OnOfferAvailable(sdp_mangled_stream.str());
    }
}

void LLWebRTCImpl::setAudioObserver(LLWebRTCAudioObserver *observer) { mAudioObserverList.emplace_back(observer); }

void LLWebRTCImpl::unsetAudioObserver(LLWebRTCAudioObserver *observer)
{
    std::vector<LLWebRTCAudioObserver *>::iterator it = std::find(mAudioObserverList.begin(), mAudioObserverList.end(), observer);
    if (it != mAudioObserverList.end())
    {
        mAudioObserverList.erase(it);
    }
}

//
// DataChannelObserver implementation
//

void LLWebRTCImpl::OnStateChange()
{ 
    RTC_LOG(LS_INFO) << __FUNCTION__ << " Data Channel State: " << webrtc::DataChannelInterface::DataStateString(mDataChannel->state());
    switch (mDataChannel->state())
    {
        case webrtc::DataChannelInterface::kOpen:
            RTC_LOG(LS_INFO) << __FUNCTION__ << " Data Channel State Open";
            for (auto &observer : mDataObserverList)
            {
                observer->OnDataChannelReady();
            }
            break;
        case webrtc::DataChannelInterface::kConnecting:
            RTC_LOG(LS_INFO) << __FUNCTION__ << " Data Channel State Connecting";
            break;
        case webrtc::DataChannelInterface::kClosing:
            RTC_LOG(LS_INFO) << __FUNCTION__ << " Data Channel State closing";
            break;
        case webrtc::DataChannelInterface::kClosed:
            RTC_LOG(LS_INFO) << __FUNCTION__ << " Data Channel State closed";
            break;
        default:
            break;
    }
}


void LLWebRTCImpl::OnMessage(const webrtc::DataBuffer& buffer)
{
    std::string data((const char*)buffer.data.cdata(), buffer.size());
    for (auto &observer : mDataObserverList)
    {
        observer->OnDataReceived(data, buffer.binary);
    }
}

void LLWebRTCImpl::sendData(const std::string& data, bool binary)
{
    rtc::CopyOnWriteBuffer cowBuffer(data.data(), data.length());
    webrtc::DataBuffer buffer(cowBuffer, binary);
    mDataChannel->Send(buffer);
}

void LLWebRTCImpl::setDataObserver(LLWebRTCDataObserver* observer) { mDataObserverList.emplace_back(observer); }

void LLWebRTCImpl::unsetDataObserver(LLWebRTCDataObserver* observer)
{
    std::vector<LLWebRTCDataObserver *>::iterator it =
        std::find(mDataObserverList.begin(), mDataObserverList.end(), observer);
    if (it != mDataObserverList.end())
    {
        mDataObserverList.erase(it);
    }
}

rtc::RefCountedObject<LLWebRTCImpl> *gWebRTCImpl = nullptr;
LLWebRTCDeviceInterface             *getDeviceInterface() { return gWebRTCImpl; }
LLWebRTCSignalInterface             *getSignalingInterface() { return gWebRTCImpl; }
LLWebRTCDataInterface               *getDataInterface() { return gWebRTCImpl; }


void init()
{
    gWebRTCImpl = new rtc::RefCountedObject<LLWebRTCImpl>();
    gWebRTCImpl->AddRef();
    gWebRTCImpl->init();
}

void terminate()
{ 
    gWebRTCImpl->terminate();
    gWebRTCImpl->Release();
    gWebRTCImpl = nullptr;
}

}  // namespace llwebrtc