From d9496a6691bfabf31ea3c3fcd3bb130c1a5d7cf5 Mon Sep 17 00:00:00 2001 From: harryz2000 <119906558+harryz2000@users.noreply.github.com> Date: Wed, 3 Jul 2024 17:07:35 +1000 Subject: [PATCH] Expose FrameDispatchCoordinator (#44) --- binding.gyp | 2 + src/FrameDispatchCoordinator.i | 32 +++ src/MediaFrameListenerBridge.i | 2 + src/rtmp-server.d.ts | 15 ++ src/rtmp-server_wrap.cxx | 402 +++++++++++++++++++++++++++++---- 5 files changed, 408 insertions(+), 45 deletions(-) create mode 100644 src/FrameDispatchCoordinator.i diff --git a/binding.gyp b/binding.gyp index 40f4990..55719a8 100644 --- a/binding.gyp +++ b/binding.gyp @@ -68,6 +68,8 @@ "<(medooze_media_server_src)/src/avcdescriptor.cpp", "<(medooze_media_server_src)/src/MediaFrameListenerBridge.cpp", "<(medooze_media_server_src)/src/rtp/LayerInfo.cpp", + "<(medooze_media_server_src)/src/FrameDelayCalculator.cpp", + "<(medooze_media_server_src)/src/FrameDispatchCoordinator.cpp", "<(medooze_media_server_src)/src/rtp/RTPPacket.cpp", "<(medooze_media_server_src)/src/rtp/RTPPayload.cpp", "<(medooze_media_server_src)/src/rtp/RTPHeader.cpp", diff --git a/src/FrameDispatchCoordinator.i b/src/FrameDispatchCoordinator.i new file mode 100644 index 0000000..69a2e99 --- /dev/null +++ b/src/FrameDispatchCoordinator.i @@ -0,0 +1,32 @@ +%{ +#include "FrameDispatchCoordinator.h" +%} + +class FrameDispatchCoordinator +{ +public: + +%extend +{ + void SetMaxDelayMs(uint32_t maxDelayMs) + { + self->SetMaxDelayMs(std::chrono::milliseconds(maxDelayMs)); + } +} +}; + +SHARED_PTR_BEGIN(FrameDispatchCoordinator) +{ + FrameDispatchCoordinatorShared(int aUpdateRefsPacketLateThresholdMs, int aUpdateRefsStepPacketEarlyMs) + { + return new std::shared_ptr( + new FrameDispatchCoordinator(aUpdateRefsPacketLateThresholdMs, + std::chrono::milliseconds(aUpdateRefsStepPacketEarlyMs))); + } + + FrameDispatchCoordinatorShared() + { + return new std::shared_ptr(new FrameDispatchCoordinator()); + } +} +SHARED_PTR_END(FrameDispatchCoordinator) diff --git a/src/MediaFrameListenerBridge.i b/src/MediaFrameListenerBridge.i index 483a5be..cdfd241 100644 --- a/src/MediaFrameListenerBridge.i +++ b/src/MediaFrameListenerBridge.i @@ -7,6 +7,7 @@ %include "RTPReceiver.i" %include "MediaFrame.i" %include "RTMPServerModule.i" +%include "FrameDispatchCoordinator.i" %nodefaultctor MediaFrameListenerBridge; struct MediaFrameListenerBridge : @@ -45,6 +46,7 @@ struct MediaFrameListenerBridge : void SetTargetBitrateHint(uint32_t targetBitrateHint); + void SetFrameDispatchCoordinator(const FrameDispatchCoordinatorShared& coordinator); %extend { // Note: Extra const on right of pointer to let SWIG know this only wants a get accessor diff --git a/src/rtmp-server.d.ts b/src/rtmp-server.d.ts index f02c307..80639c0 100644 --- a/src/rtmp-server.d.ts +++ b/src/rtmp-server.d.ts @@ -240,6 +240,19 @@ export class RTMPServerModule { constructor(); } + +export class FrameDispatchCoordinator { + SetMaxDelayMs(maxDelayMs: number): void; +} + +export class FrameDispatchCoordinatorShared { + + constructor(); + + get(): FrameDispatchCoordinator; +} + + export class MediaFrameListenerBridge extends RTPIncomingMediaStream { constructor(timeService: TimeService | EventLoop, ssrc: number); @@ -287,6 +300,8 @@ export class MediaFrameListenerBridge extends RTPIncomingMediaStream { RemoveMediaListener(listener: MediaFrameListenerShared): void; SetTargetBitrateHint(targetBitrateHint: number): void; + + SetFrameDispatchCoordinator(coordinator: FrameDispatchCoordinatorShared): void; codec: string; diff --git a/src/rtmp-server_wrap.cxx b/src/rtmp-server_wrap.cxx index 5923fbe..10f4089 100644 --- a/src/rtmp-server_wrap.cxx +++ b/src/rtmp-server_wrap.cxx @@ -1340,51 +1340,53 @@ fail: ; #define SWIGTYPE_p_ByteBuffer swig_types[0] #define SWIGTYPE_p_EventLoop swig_types[1] -#define SWIGTYPE_p_IncomingStreamBridge swig_types[2] -#define SWIGTYPE_p_MediaFrameListener swig_types[3] -#define SWIGTYPE_p_MediaFrameListenerBridge swig_types[4] -#define SWIGTYPE_p_MediaFrameListenerBridgeShared swig_types[5] -#define SWIGTYPE_p_MediaFrameListenerShared swig_types[6] -#define SWIGTYPE_p_MediaFrameProducer swig_types[7] -#define SWIGTYPE_p_MediaFrameProducerShared swig_types[8] -#define SWIGTYPE_p_OutgoingStreamBridge swig_types[9] -#define SWIGTYPE_p_OutgoingStreamBridgeShared swig_types[10] -#define SWIGTYPE_p_Properties swig_types[11] -#define SWIGTYPE_p_RTMPApplicationImpl swig_types[12] -#define SWIGTYPE_p_RTMPClientConnection swig_types[13] -#define SWIGTYPE_p_RTMPClientConnectionImpl swig_types[14] -#define SWIGTYPE_p_RTMPMediaStreamListener swig_types[15] -#define SWIGTYPE_p_RTMPNetConnection swig_types[16] -#define SWIGTYPE_p_RTMPNetConnectionImpl swig_types[17] -#define SWIGTYPE_p_RTMPNetConnectionImplShared swig_types[18] -#define SWIGTYPE_p_RTMPNetConnectionShared swig_types[19] -#define SWIGTYPE_p_RTMPNetStream swig_types[20] -#define SWIGTYPE_p_RTMPNetStreamImpl swig_types[21] -#define SWIGTYPE_p_RTMPNetStreamImplShared swig_types[22] -#define SWIGTYPE_p_RTMPNetStreamShared swig_types[23] -#define SWIGTYPE_p_RTMPServerFacade swig_types[24] -#define SWIGTYPE_p_RTMPServerModule swig_types[25] -#define SWIGTYPE_p_RTPIncomingMediaStream swig_types[26] -#define SWIGTYPE_p_RTPIncomingMediaStreamShared swig_types[27] -#define SWIGTYPE_p_RTPReceiver swig_types[28] -#define SWIGTYPE_p_RTPReceiverShared swig_types[29] -#define SWIGTYPE_p_TimeService swig_types[30] -#define SWIGTYPE_p_VideoOrientation swig_types[31] -#define SWIGTYPE_p_char swig_types[32] -#define SWIGTYPE_p_int swig_types[33] -#define SWIGTYPE_p_long_long swig_types[34] -#define SWIGTYPE_p_short swig_types[35] -#define SWIGTYPE_p_signed_char swig_types[36] -#define SWIGTYPE_p_std__string swig_types[37] -#define SWIGTYPE_p_std__vectorT_Properties_t swig_types[38] -#define SWIGTYPE_p_unsigned_char swig_types[39] -#define SWIGTYPE_p_unsigned_int swig_types[40] -#define SWIGTYPE_p_unsigned_long_long swig_types[41] -#define SWIGTYPE_p_unsigned_short swig_types[42] -#define SWIGTYPE_p_v8__LocalT_v8__Object_t swig_types[43] -#define SWIGTYPE_p_void swig_types[44] -static swig_type_info *swig_types[46]; -static swig_module_info swig_module = {swig_types, 45, 0, 0, 0, 0}; +#define SWIGTYPE_p_FrameDispatchCoordinator swig_types[2] +#define SWIGTYPE_p_FrameDispatchCoordinatorShared swig_types[3] +#define SWIGTYPE_p_IncomingStreamBridge swig_types[4] +#define SWIGTYPE_p_MediaFrameListener swig_types[5] +#define SWIGTYPE_p_MediaFrameListenerBridge swig_types[6] +#define SWIGTYPE_p_MediaFrameListenerBridgeShared swig_types[7] +#define SWIGTYPE_p_MediaFrameListenerShared swig_types[8] +#define SWIGTYPE_p_MediaFrameProducer swig_types[9] +#define SWIGTYPE_p_MediaFrameProducerShared swig_types[10] +#define SWIGTYPE_p_OutgoingStreamBridge swig_types[11] +#define SWIGTYPE_p_OutgoingStreamBridgeShared swig_types[12] +#define SWIGTYPE_p_Properties swig_types[13] +#define SWIGTYPE_p_RTMPApplicationImpl swig_types[14] +#define SWIGTYPE_p_RTMPClientConnection swig_types[15] +#define SWIGTYPE_p_RTMPClientConnectionImpl swig_types[16] +#define SWIGTYPE_p_RTMPMediaStreamListener swig_types[17] +#define SWIGTYPE_p_RTMPNetConnection swig_types[18] +#define SWIGTYPE_p_RTMPNetConnectionImpl swig_types[19] +#define SWIGTYPE_p_RTMPNetConnectionImplShared swig_types[20] +#define SWIGTYPE_p_RTMPNetConnectionShared swig_types[21] +#define SWIGTYPE_p_RTMPNetStream swig_types[22] +#define SWIGTYPE_p_RTMPNetStreamImpl swig_types[23] +#define SWIGTYPE_p_RTMPNetStreamImplShared swig_types[24] +#define SWIGTYPE_p_RTMPNetStreamShared swig_types[25] +#define SWIGTYPE_p_RTMPServerFacade swig_types[26] +#define SWIGTYPE_p_RTMPServerModule swig_types[27] +#define SWIGTYPE_p_RTPIncomingMediaStream swig_types[28] +#define SWIGTYPE_p_RTPIncomingMediaStreamShared swig_types[29] +#define SWIGTYPE_p_RTPReceiver swig_types[30] +#define SWIGTYPE_p_RTPReceiverShared swig_types[31] +#define SWIGTYPE_p_TimeService swig_types[32] +#define SWIGTYPE_p_VideoOrientation swig_types[33] +#define SWIGTYPE_p_char swig_types[34] +#define SWIGTYPE_p_int swig_types[35] +#define SWIGTYPE_p_long_long swig_types[36] +#define SWIGTYPE_p_short swig_types[37] +#define SWIGTYPE_p_signed_char swig_types[38] +#define SWIGTYPE_p_std__string swig_types[39] +#define SWIGTYPE_p_std__vectorT_Properties_t swig_types[40] +#define SWIGTYPE_p_unsigned_char swig_types[41] +#define SWIGTYPE_p_unsigned_int swig_types[42] +#define SWIGTYPE_p_unsigned_long_long swig_types[43] +#define SWIGTYPE_p_unsigned_short swig_types[44] +#define SWIGTYPE_p_v8__LocalT_v8__Object_t swig_types[45] +#define SWIGTYPE_p_void swig_types[46] +static swig_type_info *swig_types[48]; +static swig_module_info swig_module = {swig_types, 47, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -2198,6 +2200,38 @@ uv_async_t RTMPServerModule::async; moodycamel::ConcurrentQueue> RTMPServerModule::queue; +#include "FrameDispatchCoordinator.h" + +SWIGINTERN void FrameDispatchCoordinator_SetMaxDelayMs__SWIG(FrameDispatchCoordinator *self,uint32_t maxDelayMs){ + self->SetMaxDelayMs(std::chrono::milliseconds(maxDelayMs)); + } + +using FrameDispatchCoordinatorShared = std::shared_ptr; + +static FrameDispatchCoordinatorShared FrameDispatchCoordinatorShared_null_ptr = {}; + +FrameDispatchCoordinatorShared* FrameDispatchCoordinatorShared_from_proxy(const v8::Local input) +{ + void *ptr = nullptr; + if (input.IsEmpty() || !input->IsObject()) return &FrameDispatchCoordinatorShared_null_ptr; + v8::Local proxy = v8::Local::Cast(input); + if (proxy.IsEmpty()) return &FrameDispatchCoordinatorShared_null_ptr; + v8::Local target = proxy->GetTarget(); + SWIG_ConvertPtr(target, &ptr, SWIGTYPE_p_FrameDispatchCoordinatorShared, 0 ); + if (!ptr) return &FrameDispatchCoordinatorShared_null_ptr; + return reinterpret_cast(ptr); +} + + +SWIGINTERN FrameDispatchCoordinatorShared *new_FrameDispatchCoordinatorShared__SWIG_0(int aUpdateRefsPacketLateThresholdMs,int aUpdateRefsStepPacketEarlyMs){ + return new std::shared_ptr( + new FrameDispatchCoordinator(aUpdateRefsPacketLateThresholdMs, + std::chrono::milliseconds(aUpdateRefsStepPacketEarlyMs))); + } +SWIGINTERN FrameDispatchCoordinatorShared *new_FrameDispatchCoordinatorShared__SWIG_1(){ + return new std::shared_ptr(new FrameDispatchCoordinator()); + } + SWIGINTERN int SWIG_AsVal_unsigned_SS_short (SWIGV8_VALUE obj, unsigned short *val) { @@ -3659,6 +3693,8 @@ SWIGV8_ClientData _exports_RTPIncomingMediaStreamShared_clientData; SWIGV8_ClientData _exports_RTPReceiver_clientData; SWIGV8_ClientData _exports_RTPReceiverShared_clientData; SWIGV8_ClientData _exports_RTMPServerModule_clientData; +SWIGV8_ClientData _exports_FrameDispatchCoordinator_clientData; +SWIGV8_ClientData _exports_FrameDispatchCoordinatorShared_clientData; SWIGV8_ClientData _exports_MediaFrameListenerBridge_clientData; SWIGV8_ClientData _exports_MediaFrameListenerBridgeShared_clientData; SWIGV8_ClientData _exports_RTMPMediaStreamListener_clientData; @@ -7001,6 +7037,203 @@ static void _wrap_delete_RTMPServerModule(const v8::WeakCallbackInfo(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_int(args[0], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FrameDispatchCoordinator_SetMaxDelayMs" "', argument " "2"" of type '" "uint32_t""'"); + } + arg2 = static_cast< uint32_t >(val2); + FrameDispatchCoordinator_SetMaxDelayMs__SWIG(arg1,arg2); + jsresult = SWIGV8_UNDEFINED(); + + + + SWIGV8_RETURN(jsresult); + + goto fail; +fail: + SWIGV8_RETURN(SWIGV8_UNDEFINED()); +} + + +static SwigV8ReturnValue _wrap_new_FrameDispatchCoordinator(const SwigV8Arguments &args) { + SWIGV8_HANDLESCOPE(); + + SWIGV8_OBJECT self = args.Holder(); + FrameDispatchCoordinator *result; + if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new_FrameDispatchCoordinator."); + if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new_FrameDispatchCoordinator."); + result = (FrameDispatchCoordinator *)new FrameDispatchCoordinator(); + + + + SWIGV8_SetPrivateData(self, result, SWIGTYPE_p_FrameDispatchCoordinator, SWIG_POINTER_OWN); + SWIGV8_RETURN(self); + + goto fail; +fail: + SWIGV8_RETURN(SWIGV8_UNDEFINED()); +} + + +static void _wrap_delete_FrameDispatchCoordinator(const v8::WeakCallbackInfo &data) { + SWIGV8_Proxy *proxy = data.GetParameter(); + + if(proxy->swigCMemOwn && proxy->swigCObject) { + FrameDispatchCoordinator * arg1 = (FrameDispatchCoordinator *)proxy->swigCObject; + delete arg1; + } + delete proxy; +} + + +static SwigV8ReturnValue _wrap_new_FrameDispatchCoordinatorShared__SWIG_0(const SwigV8Arguments &args, V8ErrorHandler &SWIGV8_ErrorHandler) { + SWIGV8_HANDLESCOPE(); + + SWIGV8_OBJECT self = args.Holder(); + int arg1 ; + int arg2 ; + int val1 ; + int ecode1 = 0 ; + int val2 ; + int ecode2 = 0 ; + FrameDispatchCoordinatorShared *result; + if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new_FrameDispatchCoordinatorShared__SWIG_0."); + if(args.Length() != 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new_FrameDispatchCoordinatorShared__SWIG_0."); + ecode1 = SWIG_AsVal_int(args[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FrameDispatchCoordinatorShared" "', argument " "1"" of type '" "int""'"); + } + arg1 = static_cast< int >(val1); + ecode2 = SWIG_AsVal_int(args[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FrameDispatchCoordinatorShared" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (FrameDispatchCoordinatorShared *)new_FrameDispatchCoordinatorShared__SWIG_0(arg1,arg2); + + + + + + SWIGV8_SetPrivateData(self, result, SWIGTYPE_p_FrameDispatchCoordinatorShared, SWIG_POINTER_OWN); + SWIGV8_RETURN(self); + + goto fail; +fail: + SWIGV8_RETURN(SWIGV8_UNDEFINED()); +} + + +static SwigV8ReturnValue _wrap_new_FrameDispatchCoordinatorShared__SWIG_1(const SwigV8Arguments &args, V8ErrorHandler &SWIGV8_ErrorHandler) { + SWIGV8_HANDLESCOPE(); + + SWIGV8_OBJECT self = args.Holder(); + FrameDispatchCoordinatorShared *result; + if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new_FrameDispatchCoordinatorShared__SWIG_1."); + if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new_FrameDispatchCoordinatorShared__SWIG_1."); + result = (FrameDispatchCoordinatorShared *)new_FrameDispatchCoordinatorShared__SWIG_1(); + + + + SWIGV8_SetPrivateData(self, result, SWIGTYPE_p_FrameDispatchCoordinatorShared, SWIG_POINTER_OWN); + SWIGV8_RETURN(self); + + goto fail; +fail: + SWIGV8_RETURN(SWIGV8_UNDEFINED()); +} + + +static SwigV8ReturnValue _wrap_new_FrameDispatchCoordinatorShared(const SwigV8Arguments &args) { + SWIGV8_HANDLESCOPE(); + + OverloadErrorHandler errorHandler; + SWIGV8_VALUE self; + + // switch all cases by means of series of if-returns. + + if(args.Length() == 2) { + errorHandler.err.Clear(); + _wrap_new_FrameDispatchCoordinatorShared__SWIG_0(args, errorHandler); + if(errorHandler.err.IsEmpty()) { + return; + } + } + + if(args.Length() == 0) { + errorHandler.err.Clear(); + _wrap_new_FrameDispatchCoordinatorShared__SWIG_1(args, errorHandler); + if(errorHandler.err.IsEmpty()) { + return; + } + } + + + // default: + SWIG_exception_fail(SWIG_ERROR, "Illegal arguments for construction of _exports_FrameDispatchCoordinatorShared"); + +fail: + SWIGV8_RETURN(SWIGV8_UNDEFINED()); +} + + +static SwigV8ReturnValue _wrap_FrameDispatchCoordinatorShared_get(const SwigV8Arguments &args) { + SWIGV8_HANDLESCOPE(); + + SWIGV8_VALUE jsresult; + FrameDispatchCoordinatorShared *arg1 = (FrameDispatchCoordinatorShared *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + FrameDispatchCoordinator *result = 0 ; + + if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_FrameDispatchCoordinatorShared_get."); + + res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_FrameDispatchCoordinatorShared, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameDispatchCoordinatorShared_get" "', argument " "1"" of type '" "FrameDispatchCoordinatorShared *""'"); + } + arg1 = reinterpret_cast< FrameDispatchCoordinatorShared * >(argp1); + result = (FrameDispatchCoordinator *)(arg1)->get(); + jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FrameDispatchCoordinator, 0 | 0 ); + + + SWIGV8_RETURN(jsresult); + + goto fail; +fail: + SWIGV8_RETURN(SWIGV8_UNDEFINED()); +} + + +static void _wrap_delete_FrameDispatchCoordinatorShared(const v8::WeakCallbackInfo &data) { + SWIGV8_Proxy *proxy = data.GetParameter(); + + if(proxy->swigCMemOwn && proxy->swigCObject) { + FrameDispatchCoordinatorShared * arg1 = (FrameDispatchCoordinatorShared *)proxy->swigCObject; + delete arg1; + } + delete proxy; +} + + static SwigV8ReturnValue _wrap_new_MediaFrameListenerBridge(const SwigV8Arguments &args) { SWIGV8_HANDLESCOPE(); @@ -8148,6 +8381,38 @@ static SwigV8ReturnValue _wrap_MediaFrameListenerBridge_SetTargetBitrateHint(con } +static SwigV8ReturnValue _wrap_MediaFrameListenerBridge_SetFrameDispatchCoordinator(const SwigV8Arguments &args) { + SWIGV8_HANDLESCOPE(); + + SWIGV8_VALUE jsresult; + MediaFrameListenerBridge *arg1 = (MediaFrameListenerBridge *) 0 ; + FrameDispatchCoordinatorShared *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_MediaFrameListenerBridge_SetFrameDispatchCoordinator."); + + res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_MediaFrameListenerBridge, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MediaFrameListenerBridge_SetFrameDispatchCoordinator" "', argument " "1"" of type '" "MediaFrameListenerBridge *""'"); + } + arg1 = reinterpret_cast< MediaFrameListenerBridge * >(argp1); + { + arg2 = FrameDispatchCoordinatorShared_from_proxy(args[0]); + } + (arg1)->SetFrameDispatchCoordinator((FrameDispatchCoordinatorShared const &)*arg2); + jsresult = SWIGV8_UNDEFINED(); + + + + SWIGV8_RETURN(jsresult); + + goto fail; +fail: + SWIGV8_RETURN(SWIGV8_UNDEFINED()); +} + + static SwigV8ReturnValue _wrap_MediaFrameListenerBridge_codec_get(v8::Local property, const SwigV8PropertyCallbackInfo &info) { SWIGV8_HANDLESCOPE(); @@ -10216,6 +10481,8 @@ static void *_p_MediaFrameListenerBridgeTo_p_MediaFrameListener(void *x, int *SW } static swig_type_info _swigt__p_ByteBuffer = {"_p_ByteBuffer", "ByteBuffer *|p_ByteBuffer", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_EventLoop = {"_p_EventLoop", "EventLoop *|p_EventLoop", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_FrameDispatchCoordinator = {"_p_FrameDispatchCoordinator", "p_FrameDispatchCoordinator|FrameDispatchCoordinator *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_FrameDispatchCoordinatorShared = {"_p_FrameDispatchCoordinatorShared", "p_FrameDispatchCoordinatorShared|FrameDispatchCoordinatorShared *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_IncomingStreamBridge = {"_p_IncomingStreamBridge", "IncomingStreamBridge *|p_IncomingStreamBridge", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_MediaFrameListener = {"_p_MediaFrameListener", "p_MediaFrameListener|MediaFrameListener *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_MediaFrameListenerBridge = {"_p_MediaFrameListenerBridge", "p_MediaFrameListenerBridge|MediaFrameListenerBridge *", 0, 0, (void*)0, 0}; @@ -10263,6 +10530,8 @@ static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0}; static swig_type_info *swig_type_initial[] = { &_swigt__p_ByteBuffer, &_swigt__p_EventLoop, + &_swigt__p_FrameDispatchCoordinator, + &_swigt__p_FrameDispatchCoordinatorShared, &_swigt__p_IncomingStreamBridge, &_swigt__p_MediaFrameListener, &_swigt__p_MediaFrameListenerBridge, @@ -10310,6 +10579,8 @@ static swig_type_info *swig_type_initial[] = { static swig_cast_info _swigc__p_ByteBuffer[] = { {&_swigt__p_ByteBuffer, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_EventLoop[] = { {&_swigt__p_EventLoop, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_FrameDispatchCoordinator[] = { {&_swigt__p_FrameDispatchCoordinator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_FrameDispatchCoordinatorShared[] = { {&_swigt__p_FrameDispatchCoordinatorShared, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_IncomingStreamBridge[] = { {&_swigt__p_IncomingStreamBridge, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_MediaFrameListener[] = { {&_swigt__p_MediaFrameListener, 0, 0, 0}, {&_swigt__p_MediaFrameListenerBridge, _p_MediaFrameListenerBridgeTo_p_MediaFrameListener, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_MediaFrameListenerBridge[] = { {&_swigt__p_MediaFrameListenerBridge, 0, 0, 0},{0, 0, 0, 0}}; @@ -10357,6 +10628,8 @@ static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, static swig_cast_info *swig_cast_initial[] = { _swigc__p_ByteBuffer, _swigc__p_EventLoop, + _swigc__p_FrameDispatchCoordinator, + _swigc__p_FrameDispatchCoordinatorShared, _swigc__p_IncomingStreamBridge, _swigc__p_MediaFrameListener, _swigc__p_MediaFrameListenerBridge, @@ -10810,6 +11083,20 @@ _exports_RTMPServerModule_clientData.dtor = _wrap_delete_RTMPServerModule; if (SWIGTYPE_p_RTMPServerModule->clientdata == 0) { SWIGTYPE_p_RTMPServerModule->clientdata = &_exports_RTMPServerModule_clientData; } +/* Name: _exports_FrameDispatchCoordinator, Type: p_FrameDispatchCoordinator, Dtor: _wrap_delete_FrameDispatchCoordinator */ +SWIGV8_FUNCTION_TEMPLATE _exports_FrameDispatchCoordinator_class = SWIGV8_CreateClassTemplate("_exports_FrameDispatchCoordinator"); +SWIGV8_SET_CLASS_TEMPL(_exports_FrameDispatchCoordinator_clientData.class_templ, _exports_FrameDispatchCoordinator_class); +_exports_FrameDispatchCoordinator_clientData.dtor = _wrap_delete_FrameDispatchCoordinator; +if (SWIGTYPE_p_FrameDispatchCoordinator->clientdata == 0) { + SWIGTYPE_p_FrameDispatchCoordinator->clientdata = &_exports_FrameDispatchCoordinator_clientData; +} +/* Name: _exports_FrameDispatchCoordinatorShared, Type: p_FrameDispatchCoordinatorShared, Dtor: _wrap_delete_FrameDispatchCoordinatorShared */ +SWIGV8_FUNCTION_TEMPLATE _exports_FrameDispatchCoordinatorShared_class = SWIGV8_CreateClassTemplate("_exports_FrameDispatchCoordinatorShared"); +SWIGV8_SET_CLASS_TEMPL(_exports_FrameDispatchCoordinatorShared_clientData.class_templ, _exports_FrameDispatchCoordinatorShared_class); +_exports_FrameDispatchCoordinatorShared_clientData.dtor = _wrap_delete_FrameDispatchCoordinatorShared; +if (SWIGTYPE_p_FrameDispatchCoordinatorShared->clientdata == 0) { + SWIGTYPE_p_FrameDispatchCoordinatorShared->clientdata = &_exports_FrameDispatchCoordinatorShared_clientData; +} /* Name: _exports_MediaFrameListenerBridge, Type: p_MediaFrameListenerBridge, Dtor: _wrap_delete_MediaFrameListenerBridge */ SWIGV8_FUNCTION_TEMPLATE _exports_MediaFrameListenerBridge_class = SWIGV8_CreateClassTemplate("_exports_MediaFrameListenerBridge"); SWIGV8_SET_CLASS_TEMPL(_exports_MediaFrameListenerBridge_clientData.class_templ, _exports_MediaFrameListenerBridge_class); @@ -10995,6 +11282,8 @@ SWIGV8_AddMemberFunction(_exports_RTPIncomingMediaStreamShared_class, "get", _wr SWIGV8_AddMemberFunction(_exports_RTPReceiver_class, "SendPLI", _wrap_RTPReceiver_SendPLI); SWIGV8_AddMemberFunction(_exports_RTPReceiver_class, "Reset", _wrap_RTPReceiver_Reset); SWIGV8_AddMemberFunction(_exports_RTPReceiverShared_class, "get", _wrap_RTPReceiverShared_get); +SWIGV8_AddMemberFunction(_exports_FrameDispatchCoordinator_class, "SetMaxDelayMs", _wrap_FrameDispatchCoordinator_SetMaxDelayMs); +SWIGV8_AddMemberFunction(_exports_FrameDispatchCoordinatorShared_class, "get", _wrap_FrameDispatchCoordinatorShared_get); SWIGV8_AddMemberVariable(_exports_MediaFrameListenerBridge_class, "numFrames", _wrap_MediaFrameListenerBridge_numFrames_get, _wrap_MediaFrameListenerBridge_numFrames_set); SWIGV8_AddMemberVariable(_exports_MediaFrameListenerBridge_class, "numPackets", _wrap_MediaFrameListenerBridge_numPackets_get, _wrap_MediaFrameListenerBridge_numPackets_set); SWIGV8_AddMemberVariable(_exports_MediaFrameListenerBridge_class, "numFramesDelta", _wrap_MediaFrameListenerBridge_numFramesDelta_get, _wrap_MediaFrameListenerBridge_numFramesDelta_set); @@ -11017,6 +11306,7 @@ SWIGV8_AddMemberFunction(_exports_MediaFrameListenerBridge_class, "Stop", _wrap_ SWIGV8_AddMemberFunction(_exports_MediaFrameListenerBridge_class, "AddMediaListener", _wrap_MediaFrameListenerBridge_AddMediaListener); SWIGV8_AddMemberFunction(_exports_MediaFrameListenerBridge_class, "RemoveMediaListener", _wrap_MediaFrameListenerBridge_RemoveMediaListener); SWIGV8_AddMemberFunction(_exports_MediaFrameListenerBridge_class, "SetTargetBitrateHint", _wrap_MediaFrameListenerBridge_SetTargetBitrateHint); +SWIGV8_AddMemberFunction(_exports_MediaFrameListenerBridge_class, "SetFrameDispatchCoordinator", _wrap_MediaFrameListenerBridge_SetFrameDispatchCoordinator); SWIGV8_AddMemberVariable(_exports_MediaFrameListenerBridge_class, "codec", _wrap_MediaFrameListenerBridge_codec_get, JS_veto_set_variable); SWIGV8_AddMemberFunction(_exports_MediaFrameListenerBridge_class, "UpdateAsync", _wrap_MediaFrameListenerBridge_UpdateAsync); SWIGV8_AddMemberFunction(_exports_MediaFrameListenerBridge_class, "SetMaxDelayMs", _wrap_MediaFrameListenerBridge_SetMaxDelayMs); @@ -11285,6 +11575,26 @@ v8::Local _exports_RTMPServerModule_obj = _exports_RTMPServerModule_ #else v8::Local _exports_RTMPServerModule_obj = _exports_RTMPServerModule_class_0->GetFunction(context).ToLocalChecked(); #endif +/* Class: FrameDispatchCoordinator (_exports_FrameDispatchCoordinator) */ +SWIGV8_FUNCTION_TEMPLATE _exports_FrameDispatchCoordinator_class_0 = SWIGV8_CreateClassTemplate("FrameDispatchCoordinator"); +_exports_FrameDispatchCoordinator_class_0->SetCallHandler(_wrap_new_FrameDispatchCoordinator); +_exports_FrameDispatchCoordinator_class_0->Inherit(_exports_FrameDispatchCoordinator_class); +#if (SWIG_V8_VERSION < 0x0704) +_exports_FrameDispatchCoordinator_class_0->SetHiddenPrototype(true); +v8::Local _exports_FrameDispatchCoordinator_obj = _exports_FrameDispatchCoordinator_class_0->GetFunction(); +#else +v8::Local _exports_FrameDispatchCoordinator_obj = _exports_FrameDispatchCoordinator_class_0->GetFunction(context).ToLocalChecked(); +#endif +/* Class: FrameDispatchCoordinatorShared (_exports_FrameDispatchCoordinatorShared) */ +SWIGV8_FUNCTION_TEMPLATE _exports_FrameDispatchCoordinatorShared_class_0 = SWIGV8_CreateClassTemplate("FrameDispatchCoordinatorShared"); +_exports_FrameDispatchCoordinatorShared_class_0->SetCallHandler(_wrap_new_FrameDispatchCoordinatorShared); +_exports_FrameDispatchCoordinatorShared_class_0->Inherit(_exports_FrameDispatchCoordinatorShared_class); +#if (SWIG_V8_VERSION < 0x0704) +_exports_FrameDispatchCoordinatorShared_class_0->SetHiddenPrototype(true); +v8::Local _exports_FrameDispatchCoordinatorShared_obj = _exports_FrameDispatchCoordinatorShared_class_0->GetFunction(); +#else +v8::Local _exports_FrameDispatchCoordinatorShared_obj = _exports_FrameDispatchCoordinatorShared_class_0->GetFunction(context).ToLocalChecked(); +#endif /* Class: MediaFrameListenerBridge (_exports_MediaFrameListenerBridge) */ SWIGV8_FUNCTION_TEMPLATE _exports_MediaFrameListenerBridge_class_0 = SWIGV8_CreateClassTemplate("MediaFrameListenerBridge"); _exports_MediaFrameListenerBridge_class_0->SetCallHandler(_wrap_new_MediaFrameListenerBridge); @@ -11504,6 +11814,8 @@ SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("RTPIncomingMedia SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("RTPReceiver"), _exports_RTPReceiver_obj)); SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("RTPReceiverShared"), _exports_RTPReceiverShared_obj)); SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("RTMPServerModule"), _exports_RTMPServerModule_obj)); +SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("FrameDispatchCoordinator"), _exports_FrameDispatchCoordinator_obj)); +SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("FrameDispatchCoordinatorShared"), _exports_FrameDispatchCoordinatorShared_obj)); SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("MediaFrameListenerBridge"), _exports_MediaFrameListenerBridge_obj)); SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("MediaFrameListenerBridgeShared"), _exports_MediaFrameListenerBridgeShared_obj)); SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("RTMPMediaStreamListener"), _exports_RTMPMediaStreamListener_obj));