electron31.3.1扩展webrtc音频控制接口(1)

已于 2024-10-15 10:20:18 修改
阅读量237 收藏
点赞数 1
文章标签： 音视频 webrtc
于 2024-10-12 18:57:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/lpt111111111/article/details/142884127
版权

1.src目录下创建beem_rtc文件夹，放置一下扩展代码

/beem_rtc/blink/renderer/modules/beemrtc 

 1.navigator_beem_rtc.idl

[
    ImplementedAs=BeemRtc
] partial interface Navigator {
    [SameObject, SecureContext] readonly attribute BeemRtc beemRtc;
};

 2.BUILD.gn

  

import("//third_party/blink/renderer/modules/modules.gni")

blink_modules_sources("beemrtc") {
  sources = [
    "beem_rtc.cc",
    "beem_rtc.h",
    "beem_message.cc",
    "beem_message.h",
  ]
  #include_dirs = [ "//third_party/webrtc" ]
  #public_deps = [ "//third_party/webrtc_overrides:webrtc_component" ]
}

 3.beem_rtc.idl


[
    Exposed=Window,
    ActiveScriptWrappable,
    SecureContext
] interface BeemRtc : EventTarget {
    // need invoked before new PeerConnection
    void setGlobalConfig(DOMString config);

    readonly attribute DOMString beemRtcVersion; // constant "beem_rtc commit id"
    readonly attribute DOMString wz264Version; // constant "WZ264-YYYYMMDD"
    void testCrash(boolean flag);

    void setSrtpArgs(long noUseIndexModel);
    void setSeqNumProtectArgs(long protectModel);
    
    readonly attribute DOMString GetRecordPath; 
    boolean SetRecordPath(DOMString path);

    readonly attribute unsigned short GetWebrtcLogSev;
    void SetWebrtcLogSev(unsigned short sev);

    readonly attribute boolean GetWebrtcLog;
    void StartWebrtcLog();
    void StopWebrtcLog();

    readonly attribute boolean GetAudioRecord;
    void StartAudioRecord();
    void StopAudioRecord();

    readonly attribute boolean Get3ARecord;
    void Start3ARecord();
    void Stop3ARecord();

    attribute EventHandler onmessage;
};

 4.beem_rtc.h

#pragma once

#include "build/build_config.h"
#include "third_party/blink/renderer/bindings/core/v8/active_script_wrappable.h"
#include "third_party/blink/renderer/core/dom/events/event_target.h"
#include "third_party/blink/renderer/core/events/message_event.h"
#include "third_party/blink/renderer/core/execution_context/execution_context_lifecycle_observer.h"
#include "third_party/blink/renderer/modules/event_target_modules.h"
#include "third_party/blink/renderer/modules/modules_export.h"
#include "third_party/blink/renderer/platform/bindings/script_wrappable.h"
#include "third_party/blink/renderer/platform/supplementable.h"
#include "third_party/blink/renderer/platform/timer.h"
#include "third_party/blink/renderer/platform/scheduler/public/post_cross_thread_task.h"
#include "third_party/blink/renderer/platform/wtf/cross_thread_functional.h"
#include "third_party/blink/renderer/platform/wtf/functional.h"
#include "third_party/blink/renderer/platform/wtf/cross_thread_copier_base.h"
#include "third_party/blink/renderer/platform/wtf/cross_thread_copier_std.h"
#include "third_party/blink/renderer/platform/wtf/text/string_builder.h"
#include "third_party/blink/renderer/platform/wtf/thread_safe_ref_counted.h"
#include "third_party/webrtc/api/black_screen_log.h"
#include "third_party/webrtc/api/beem_rtc_config.h"
#include "third_party/webrtc/rtc_base/event_tracer.h"

namespace blink {

class Navigator;
class MODULES_EXPORT BeemRtc final
    : public EventTarget,
      public ActiveScriptWrappable<BeemRtc>,
      public Supplement<Navigator>,
      public ExecutionContextLifecycleObserver {
  DEFINE_WRAPPERTYPEINFO();

 public:
  static const char kSupplementName[];
  static BeemRtc* beemRtc(Navigator&);
  explicit BeemRtc(Navigator&);
  ~BeemRtc() override;

  DEFINE_ATTRIBUTE_EVENT_LISTENER(message, kMessage)

  void setGlobalConfig(const String& config);
  String beemRtcVersion();
  String wz264Version();
  void testCrash(bool flag);
  void SendMessage(String message);

  void setSrtpArgs(int noUseIndexModel);
  void setSeqNumProtectArgs(int protectModel);
  
  String GetRecordPath(); 
  bool SetRecordPath(const String& path);

  unsigned short GetWebrtcLogSev();
  void SetWebrtcLogSev(unsigned short sev);

  bool GetWebrtcLog();
  void StartWebrtcLog();
  void StopWebrtcLog();

  bool GetAudioRecord();
  void StartAudioRecord();
  void StopAudioRecord();
  
  bool Get3ARecord();
  void Start3ARecord();
  void Stop3ARecord();

  // EventTarget
  const AtomicString& InterfaceName() const override;
  ExecutionContext* GetExecutionContext() const override;
  // ScriptWrappable
  bool HasPendingActivity() const override;
  // ExecutionContextLifecycleObserver overrides.
  void ContextDestroyed() override;
  void Trace(Visitor*) const override;

 private:
  friend class Observer;
  class Observer final : public WTF::ThreadSafeRefCounted<BeemRtc::Observer>,
                   public webrtc::BlackScreenLogObserver{
   public:
    Observer(scoped_refptr<base::SingleThreadTaskRunner> main_thread, BeemRtc* blink_beemrtc);
    Observer(const Observer&) = delete;
    Observer& operator=(const Observer&) = delete;
    ~Observer();

    void Unregister();
    void SendMessage(const std::string &type, const std::string &result);
    
    void RTCFirstAudioEncoderCreate(const std::string &result) override;
    void RTCFirstAudioFrameEncoded(const std::string &result) override;
    void RTCFirstAudioDecoderCreate(const std::string &result) override;
    void RTCFirstAudioFrameDecoded(const std::string &result) override;
    void RTCFirstVideoEncoderCreate(const std::string &result) override;
    void RTCFirstVideoFrameEncoded(const std::string &result) override;
    void RTCFirstVideoDecoderCreate(const std::string &result) override;
    void RTCFirstVideoFrameDecoded(const std::string &result) override;
    void RTCFirstAudioPacket(const std::string &result) override;
    void RTCFirstVideoPacket(const std::string &result) override;
    void RTCFirstSentPacket(const std::string &result) override;

    void RTCCustomLog(const std::string &result) override;
    void RTCSrtpErrorS(const std::string &result) override;

   private:
    const scoped_refptr<base::SingleThreadTaskRunner> main_thread_;
    WeakPersistent<BeemRtc> blink_beemrtc_;
  };

 private:
  void ScheduleDispatchEvent(Event*);
  void ScheduledEventTimerFired(TimerBase*);

  HeapTaskRunnerTimer<BeemRtc> scheduled_event_timer_;
  HeapVector<Member<Event>> scheduled_events_;
  const scoped_refptr<Observer> observer_;
};
}  // namespace blink

 5.beem_rtc.cc

#include "beem_rtc/blink/renderer/modules/beemrtc/beem_rtc.h"
#include "beem_rtc/blink/renderer/modules/beemrtc/beem_message.h"

#include "api/global_config/global_qos_config.h"
#include "third_party/blink/public/platform/modules/webrtc/webrtc_logging.h"
#include "third_party/blink/renderer/bindings/core/v8/script_promise.h"
#include "third_party/blink/renderer/bindings/core/v8/script_promise_resolver.h"
#include "third_party/blink/renderer/core/execution_context/execution_context.h"
#include "third_party/blink/renderer/core/frame/local_dom_window.h"
#include "third_party/blink/renderer/core/frame/local_frame.h"
#include "third_party/blink/renderer/core/frame/navigator.h"
#include "third_party/blink/renderer/platform/bindings/exception_state.h"
#include "third_party/blink/renderer/platform/bindings/script_state.h"

// use commit id as beemRtcVersion
#define BEEM_RTC_VERSION "31.3.1-beem.9"

namespace blink {
namespace {
void SendLogMessage(const WTF::String& message) {
  WebRtcLogMessage(
      String::Format("BeemRtc::%s", message.Utf8().c_str()).Utf8());
}
}  // namespace

const char BeemRtc::kSupplementName[] = "BeemRtc";
void AddBeemMessagePtr(void* context, const char* message, int message_type){
  BeemRtc* supplement = (BeemRtc*)context;
  String text = String::Format("%s", message);
  if(supplement){
    supplement->SendMessage(text);
  }
}

BeemRtc::Observer::Observer(
  scoped_refptr<base::SingleThreadTaskRunner> main_thread, BeemRtc* blink_beemrtc)
  : main_thread_(main_thread), blink_beemrtc_(blink_beemrtc) {
  webrtc::setBlackScreenObserver(this);
}

BeemRtc::Observer::~Observer() {
   DCHECK(!blink_beemrtc_) << "Reference to blink BeemRtc hasn't been released.";
}


void BeemRtc::Observer::Unregister() {
  DCHECK(main_thread_->BelongsToCurrentThread());
  blink_beemrtc_ = nullptr;
}

void BeemRtc::Observer::SendMessage(const std::string &type, const std::string &result){
  String message = String::Format("{\"type\":\"%s\",\"data\":%s}", type.c_str(),result.c_str());
  SendBeemMessage(message.Utf8().c_str());
}

void BeemRtc::Observer::RTCFirstAudioEncoderCreate(const std::string &result) {
  PostCrossThreadTask(
    *main_thread_, FROM_HERE,
    CrossThreadBindOnce(&BeemRtc::Observer::SendMessage,
                        scoped_refptr<Observer>(this),
                        std::string("RTCFirstAudioEncoderCreate"),
                        result));
}

void BeemRtc::Observer::RTCFirstAudioFrameEncoded(const std::string &result) {
  PostCrossThreadTask(
    *main_thread_, FROM_HERE,
    CrossThreadBindOnce(&BeemRtc::Observer::SendMessage,
                        scoped_refptr<Observer>(this),
                        std::string("RTCFirstAudioFrameEncoded"),
                        result));
}

void BeemRtc::Observer::RTCFirstAudioDecoderCreate(const std::string &result) {
  PostCrossThreadTask(
    *main_thread_, FROM_HERE,
    CrossThreadBindOnce(&BeemRtc::Observer::SendMessage,
                        scoped_refptr<Observer>(this),
                        std::string("RTCFirstAudioDecoderCreate"),
                        result));
}

void BeemRtc::Observer::RTCFirstAudioFrameDecoded(const std::string &result) {
  PostCrossThreadTask(
    *main_thread_, FROM_HERE,
    CrossThreadBindOnce(&BeemRtc::Observer::SendMessage,
                        scoped_refptr<Observer>(this),
                        std::string("RTCFirstAudioFrameDecoded"),
                        result));
}

void BeemRtc::Observer::RTCFirstVideoEncoderCreate(const std::string &result) {
  PostCrossThreadTask(
    *main_thread_, FROM_HERE,
    CrossThreadBindOnce(&BeemRtc::Observer::SendMessage,
                        scoped_refptr<Observer>(this),
                        std::string("RTCFirstVideoEncoderCreate"),
                        result));
}

void BeemRtc::Observer::RTCFirstVideoFrameEncoded(const std::string &result) {
  PostCrossThreadTask(
    *main_thread_, FROM_HERE,
    CrossThreadBindOnce(&BeemRtc::Observer::SendMessage,
                        scoped_refptr<Observer>(this),
                        std::string("RTCFirstVideoFrameEncoded"),
                        result));
}

void BeemRtc::Observer::RTCFirstVideoDecoderCreate(const std::string &result) {
  PostCrossThreadTask(
    *main_thread_, FROM_HERE,
    CrossThreadBindOnce(&BeemRtc::Observer::SendMessage,
                        scoped_refptr<Observer>(this),
                        std::string("RTCFirstVideoDecoderCreate"),
                        result));
}

void BeemRtc::Observer::RTCFirstVideoFrameDecoded(const std::string &result) {
  PostCrossThreadTask(
    *main_thread_, FROM_HERE,
    CrossThreadBindOnce(&BeemRtc::Observer::SendMessage,
                        scoped_refptr<Observer>(this),
                        std::string("RTCFirstVideoFrameDecoded"),
                        result));
}
  
void BeemRtc::Observer::RTCFirstAudioPacket(const std::string &result) {
  PostCrossThreadTask(
    *main_thread_, FROM_HERE,
    CrossThreadBindOnce(&BeemRtc::Observer::SendMessage,
                        scoped_refptr<Observer>(this),
                        std::string("RTCFirstAudioPacket"),
                        result));
}

void BeemRtc::Observer::RTCFirstVideoPacket(const std::string &result) {
  PostCrossThreadTask(
    *main_thread_, FROM_HERE,
    CrossThreadBindOnce(&BeemRtc::Observer::SendMessage,
                        scoped_refptr<Observer>(this),
                        std::string("RTCFirstVideoPacket"),
                        result));
}

void BeemRtc::Observer::RTCFirstSentPacket(const std::string &result) {
  PostCrossThreadTask(
    *main_thread_, FROM_HERE,
    CrossThreadBindOnce(&BeemRtc::Observer::SendMessage,
                        scoped_refptr<Observer>(this),
                        std::string("RTCFirstSentPacket"),
                        result));
}

void BeemRtc::Observer::RTCCustomLog(const std::string &result) {
  PostCrossThreadTask(
    *main_thread_, FROM_HERE,
    CrossThreadBindOnce(&BeemRtc::Observer::SendMessage,
                        scoped_refptr<Observer>(this),
                        std::string("RTCCustomLog"),
                        result));
}

void BeemRtc::Observer::RTCSrtpErrorS(const std::string &result) {
  PostCrossThreadTask(
    *main_thread_, FROM_HERE,
    CrossThreadBindOnce(&BeemRtc::Observer::SendMessage,
                        scoped_refptr<Observer>(this),
                        std::string("RTCSrtpErrorS"),
                        result));
}

BeemRtc* BeemRtc::beemRtc(Navigator& navigator) {
  BeemRtc* supplement = Supplement<Navigator>::From<BeemRtc>(navigator);
  if (!supplement) {
    supplement = MakeGarbageCollected<BeemRtc>(navigator);
    ProvideTo(navigator, supplement);
    SetupBeemMessage(&AddBeemMessagePtr,(void *)supplement);
  }
  return supplement;
}

BeemRtc::BeemRtc(Navigator& navigator)
    : ActiveScriptWrappable<BeemRtc>({}),
      Supplement<Navigator>(navigator),
      ExecutionContextLifecycleObserver(navigator.DomWindow()),
      scheduled_event_timer_(navigator.DomWindow()->GetTaskRunner(TaskType::kPostedMessage),
                             this,
                             &BeemRtc::ScheduledEventTimerFired),
      observer_(base::MakeRefCounted<Observer>(
                navigator.DomWindow()->GetTaskRunner(TaskType::kPostedMessage),
                this)){}

BeemRtc::~BeemRtc() = default;

void BeemRtc::setGlobalConfig(const String& config) {
  webrtc::GlobalQosConfig::GetInstance()->SetQosArgs(config.Utf8());
  SendLogMessage(String::Format("%s() %s", __func__, config.Utf8().c_str()));
}

String BeemRtc::beemRtcVersion() {
  // beem_rtc commit id
  return BEEM_RTC_VERSION;
}

void BeemRtc::testCrash(bool flag) {
  // test crash codecs by liupengtao
  if(flag) {
    int *ptr = nullptr;
    *ptr = 6;
  }
  return;
}

String BeemRtc::wz264Version() {
  // wz264 encoder publish date, format: WZ264-YYYYMMDD

  // test crash codecs by liupengtao
  //int *ptr = nullptr;
  //*ptr = 6;
    
  //String text = "onmessage---wz264Version";
  //DispatchEvent(*MessageEvent::Create(text));
  //ScheduleDispatchEvent(MessageEvent::Create(text));
  //SendBeemMessage(text.Utf8().c_str());
  return "WZ264-20231030";
}

void BeemRtc::SendMessage(String message){
  ScheduleDispatchEvent(MessageEvent::Create(message));
}

void BeemRtc::ScheduleDispatchEvent(Event* event) {
  scheduled_events_.push_back(event);

  if (!scheduled_event_timer_.IsActive())
    scheduled_event_timer_.StartOneShot(base::TimeDelta(), FROM_HERE);
}

void BeemRtc::ScheduledEventTimerFired(TimerBase*) {
  HeapVector<Member<Event>> events;
  events.swap(scheduled_events_);

  HeapVector<Member<Event>>::iterator it = events.begin();
  for (; it != events.end(); ++it)
    DispatchEvent(*it->Release());

  events.clear();
}

const AtomicString& BeemRtc::InterfaceName() const {
  return event_target_names::kBeemRtc;
}

ExecutionContext* BeemRtc::GetExecutionContext() const {
  return ExecutionContextLifecycleObserver::GetExecutionContext();
}

bool BeemRtc::HasPendingActivity() const {
  return false;
}

void BeemRtc::ContextDestroyed() {
}

void BeemRtc::Trace(Visitor* visitor) const {
  visitor->Trace(scheduled_events_);
  visitor->Trace(scheduled_event_timer_);
  EventTarget::Trace(visitor);
  Supplement<Navigator>::Trace(visitor);
  ExecutionContextLifecycleObserver::Trace(visitor);
}

void BeemRtc::setSrtpArgs(int noUseIndexModel){
  webrtc::GlobalQosConfig::GetInstance()->setSrtpArgs(noUseIndexModel);
}

void BeemRtc::setSeqNumProtectArgs(int protectModel){
  webrtc::GlobalQosConfig::GetInstance()->setSeqNumProtectArgs(protectModel);
}

String BeemRtc::GetRecordPath(){
  String path = String::Format("%s", webrtc::GetRecordPath().c_str());
  return path;
}

bool BeemRtc::SetRecordPath(const String& path){
  return webrtc::SetRecordPath(path.Utf8());
}

unsigned short BeemRtc::GetWebrtcLogSev(){
  return webrtc::GetWebrtcLogSev();
}

void BeemRtc::SetWebrtcLogSev(unsigned short sev){
  webrtc::SetWebrtcLogSev(sev);
}

bool BeemRtc::GetWebrtcLog(){
  return webrtc::GetWebrtcLog();
}

void BeemRtc::StartWebrtcLog(){
  webrtc::StartWebrtcLog();
}

void BeemRtc::StopWebrtcLog(){
  webrtc::StopWebrtcLog();
}

bool BeemRtc::GetAudioRecord(){
  return webrtc::GetAudioRecord();
}

void BeemRtc::StartAudioRecord(){
  webrtc::StartAudioRecord();
}

void BeemRtc::StopAudioRecord(){
  webrtc::StopAudioRecord();
}


bool BeemRtc::Get3ARecord(){
  return webrtc::Get3ARecord();
}

void BeemRtc::Start3ARecord(){
  webrtc::Start3ARecord();
}

void BeemRtc::Stop3ARecord(){
  webrtc::Stop3ARecord();
}

}  // namespace blink

  6.beem_message.h 

#ifndef BLINK_INCLUDE_BEEM_MESSAGE_H_
#define BLINK_INCLUDE_BEEM_MESSAGE_H_

#include <stdint.h>
#include <string>

enum MessageType {
  kMessage,
  kCommand,  
  kUnknown
  };

typedef void (*AddBeemMessagePtr)(void* context, const char* message, int message_type);

static AddBeemMessagePtr g_add_beem_message_ptr = nullptr;
static void* g_add_beem_context_ptr = nullptr;
void SetupBeemMessage(AddBeemMessagePtr add_beem_message_ptr, void* context);
void SendBeemMessage(const char* message, int message_type = MessageType::kMessage);

#endif  // BLINK_INCLUDE_BEEM_MESSAGE_H_

 7.beem_message.cc

#include "beem_rtc/blink/renderer/modules/beemrtc/beem_message.h"

void SetupBeemMessage(AddBeemMessagePtr add_beem_message_ptr, void* context){
  g_add_beem_message_ptr = add_beem_message_ptr;
  g_add_beem_context_ptr = context;
  // test send message by liupengtao
  //SendBeemMessage("SendBeemMessage---test");
}

void SendBeemMessage(const char* message, int message_type){
  if(g_add_beem_message_ptr&&g_add_beem_context_ptr)
    g_add_beem_message_ptr(g_add_beem_context_ptr, message, message_type);
}

lpt111111111
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值