From 6bf0a5cb5034a7e684dcc3500e841785237ce2dd Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 19:32:43 +0200 Subject: Adding upstream version 1:115.7.0. Signed-off-by: Daniel Baumann --- third_party/libwebrtc/pc/dtmf_sender.cc | 243 ++++++++++++++++++++++++++++++++ 1 file changed, 243 insertions(+) create mode 100644 third_party/libwebrtc/pc/dtmf_sender.cc (limited to 'third_party/libwebrtc/pc/dtmf_sender.cc') diff --git a/third_party/libwebrtc/pc/dtmf_sender.cc b/third_party/libwebrtc/pc/dtmf_sender.cc new file mode 100644 index 0000000000..45a4a58abb --- /dev/null +++ b/third_party/libwebrtc/pc/dtmf_sender.cc @@ -0,0 +1,243 @@ +/* + * Copyright 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 "pc/dtmf_sender.h" + +#include +#include + +#include "api/task_queue/pending_task_safety_flag.h" +#include "api/task_queue/task_queue_base.h" +#include "api/units/time_delta.h" +#include "rtc_base/checks.h" +#include "rtc_base/logging.h" + +namespace webrtc { + +// RFC4733 +// +-------+--------+------+---------+ +// | Event | Code | Type | Volume? | +// +-------+--------+------+---------+ +// | 0--9 | 0--9 | tone | yes | +// | * | 10 | tone | yes | +// | # | 11 | tone | yes | +// | A--D | 12--15 | tone | yes | +// +-------+--------+------+---------+ +// The "," is a special event defined by the WebRTC spec. It means to delay for +// 2 seconds before processing the next tone. We use -1 as its code. +static const int kDtmfCommaDelay = -1; +static const char kDtmfValidTones[] = ",0123456789*#ABCDabcd"; +static const char kDtmfTonesTable[] = ",0123456789*#ABCD"; +// The duration cannot be more than 6000ms or less than 40ms. The gap between +// tones must be at least 50 ms. +// Source for values: W3C WEBRTC specification. +// https://w3c.github.io/webrtc-pc/#dom-rtcdtmfsender-insertdtmf +static const int kDtmfDefaultDurationMs = 100; +static const int kDtmfMinDurationMs = 40; +static const int kDtmfMaxDurationMs = 6000; +static const int kDtmfDefaultGapMs = 50; +static const int kDtmfMinGapMs = 30; + +// Get DTMF code from the DTMF event character. +bool GetDtmfCode(char tone, int* code) { + // Convert a-d to A-D. + char event = toupper(tone); + const char* p = strchr(kDtmfTonesTable, event); + if (!p) { + return false; + } + *code = p - kDtmfTonesTable - 1; + return true; +} + +rtc::scoped_refptr DtmfSender::Create( + TaskQueueBase* signaling_thread, + DtmfProviderInterface* provider) { + if (!signaling_thread) { + return nullptr; + } + return rtc::make_ref_counted(signaling_thread, provider); +} + +DtmfSender::DtmfSender(TaskQueueBase* signaling_thread, + DtmfProviderInterface* provider) + : observer_(nullptr), + signaling_thread_(signaling_thread), + provider_(provider), + duration_(kDtmfDefaultDurationMs), + inter_tone_gap_(kDtmfDefaultGapMs), + comma_delay_(kDtmfDefaultCommaDelayMs) { + RTC_DCHECK(signaling_thread_); + RTC_DCHECK(provider_); +} + +void DtmfSender::OnDtmfProviderDestroyed() { + RTC_DCHECK_RUN_ON(signaling_thread_); + RTC_DLOG(LS_INFO) << "The Dtmf provider is deleted. Clear the sending queue."; + StopSending(); + provider_ = nullptr; +} + +DtmfSender::~DtmfSender() { + RTC_DCHECK_RUN_ON(signaling_thread_); + StopSending(); +} + +void DtmfSender::RegisterObserver(DtmfSenderObserverInterface* observer) { + RTC_DCHECK_RUN_ON(signaling_thread_); + observer_ = observer; +} + +void DtmfSender::UnregisterObserver() { + RTC_DCHECK_RUN_ON(signaling_thread_); + observer_ = nullptr; +} + +bool DtmfSender::CanInsertDtmf() { + RTC_DCHECK_RUN_ON(signaling_thread_); + if (!provider_) { + return false; + } + return provider_->CanInsertDtmf(); +} + +bool DtmfSender::InsertDtmf(const std::string& tones, + int duration, + int inter_tone_gap, + int comma_delay) { + RTC_DCHECK_RUN_ON(signaling_thread_); + + if (duration > kDtmfMaxDurationMs || duration < kDtmfMinDurationMs || + inter_tone_gap < kDtmfMinGapMs || comma_delay < kDtmfMinGapMs) { + RTC_LOG(LS_ERROR) + << "InsertDtmf is called with invalid duration or tones gap. " + "The duration cannot be more than " + << kDtmfMaxDurationMs << "ms or less than " << kDtmfMinDurationMs + << "ms. The gap between tones must be at least " << kDtmfMinGapMs + << "ms."; + return false; + } + + if (!CanInsertDtmf()) { + RTC_LOG(LS_ERROR) + << "InsertDtmf is called on DtmfSender that can't send DTMF."; + return false; + } + + tones_ = tones; + duration_ = duration; + inter_tone_gap_ = inter_tone_gap; + comma_delay_ = comma_delay; + + // Cancel any remaining tasks for previous tones. + if (safety_flag_) { + safety_flag_->SetNotAlive(); + } + safety_flag_ = PendingTaskSafetyFlag::Create(); + // Kick off a new DTMF task. + QueueInsertDtmf(1 /*ms*/); + return true; +} + +std::string DtmfSender::tones() const { + RTC_DCHECK_RUN_ON(signaling_thread_); + return tones_; +} + +int DtmfSender::duration() const { + RTC_DCHECK_RUN_ON(signaling_thread_); + return duration_; +} + +int DtmfSender::inter_tone_gap() const { + RTC_DCHECK_RUN_ON(signaling_thread_); + return inter_tone_gap_; +} + +int DtmfSender::comma_delay() const { + RTC_DCHECK_RUN_ON(signaling_thread_); + return comma_delay_; +} + +void DtmfSender::QueueInsertDtmf(uint32_t delay_ms) { + signaling_thread_->PostDelayedHighPrecisionTask( + SafeTask(safety_flag_, + [this] { + RTC_DCHECK_RUN_ON(signaling_thread_); + DoInsertDtmf(); + }), + TimeDelta::Millis(delay_ms)); +} + +void DtmfSender::DoInsertDtmf() { + // Get the first DTMF tone from the tone buffer. Unrecognized characters will + // be ignored and skipped. + size_t first_tone_pos = tones_.find_first_of(kDtmfValidTones); + int code = 0; + if (first_tone_pos == std::string::npos) { + tones_.clear(); + // Fire a “OnToneChange” event with an empty string and stop. + if (observer_) { + observer_->OnToneChange(std::string(), tones_); + observer_->OnToneChange(std::string()); + } + return; + } else { + char tone = tones_[first_tone_pos]; + if (!GetDtmfCode(tone, &code)) { + // The find_first_of(kDtmfValidTones) should have guarantee `tone` is + // a valid DTMF tone. + RTC_DCHECK_NOTREACHED(); + } + } + + int tone_gap = inter_tone_gap_; + if (code == kDtmfCommaDelay) { + // Special case defined by WebRTC - By default, the character ',' indicates + // a delay of 2 seconds before processing the next character in the tones + // parameter. The comma delay can be set to a non default value via + // InsertDtmf to comply with legacy WebRTC clients. + tone_gap = comma_delay_; + } else { + if (!provider_) { + RTC_LOG(LS_ERROR) << "The DtmfProvider has been destroyed."; + return; + } + // The provider starts playout of the given tone on the + // associated RTP media stream, using the appropriate codec. + if (!provider_->InsertDtmf(code, duration_)) { + RTC_LOG(LS_ERROR) << "The DtmfProvider can no longer send DTMF."; + return; + } + // Wait for the number of milliseconds specified by `duration_`. + tone_gap += duration_; + } + + // Fire a “OnToneChange” event with the tone that's just processed. + if (observer_) { + observer_->OnToneChange(tones_.substr(first_tone_pos, 1), + tones_.substr(first_tone_pos + 1)); + observer_->OnToneChange(tones_.substr(first_tone_pos, 1)); + } + + // Erase the unrecognized characters plus the tone that's just processed. + tones_.erase(0, first_tone_pos + 1); + + // Continue with the next tone. + QueueInsertDtmf(tone_gap); +} + +void DtmfSender::StopSending() { + if (safety_flag_) { + safety_flag_->SetNotAlive(); + } +} + +} // namespace webrtc -- cgit v1.2.3