ntgcalls 1.0.0.dev16__tar.gz → 1.0.0.dev18__tar.gz

{ntgcalls-1.0.0.dev16 → ntgcalls-1.0.0.dev18}/CMakeLists.txt

@@ -7,7 +7,7 @@ endif ()
 include(ExternalProject)
 
 # https://chromiumdash.appspot.com/branches
-set(WEBRTC_REVISION m116.5845.6.1)
+set(WEBRTC_REVISION m117.5938.2.0)
 set(BOOST_REVISION 1.83.0)
 set(BOOST_LIBS filesystem)
 
@@ -15,7 +15,7 @@ if(DEFINED PY_VERSION_INFO)
     set(IS_PYTHON TRUE)
 endif()
 
-project(ntgcalls VERSION 1.0.0.16 LANGUAGES C CXX)
+project(ntgcalls VERSION 1.0.0.18 LANGUAGES C CXX)
 add_compile_definitions(NTG_VERSION="${CMAKE_PROJECT_VERSION}")
 
 find_package(Threads REQUIRED)

{ntgcalls-1.0.0.dev16/ntgcalls.egg-info → ntgcalls-1.0.0.dev18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ntgcalls
-Version: 1.0.0.dev16
+Version: 1.0.0.dev18
 Home-page: https://github.com/pytgcalls/ntgcalls
 Author: Laky-64
 Author-email: iraci.matteo@gmail.com

{ntgcalls-1.0.0.dev16 → ntgcalls-1.0.0.dev18}/ntgcalls/io/file_reader.cpp

@@ -21,8 +21,8 @@ namespace ntgcalls {
             throw EOFError("Reached end of the file");
         }
         source.seekg(readChunks, std::ios::beg);
-        auto *file_data = new uint8_t[size];
-        source.read(reinterpret_cast<char*>(file_data), size);
+        auto file_data = std::make_shared<uint8_t[]>(size);
+        source.read(reinterpret_cast<char*>(file_data.get()), size);
         readChunks += size;
         if (source.fail()) {
             throw FileError("Error while reading the file");

{ntgcalls-1.0.0.dev16 → ntgcalls-1.0.0.dev18}/ntgcalls/io/shell_reader.cpp

@@ -22,8 +22,8 @@ namespace ntgcalls {
         if (stdOut.eof() || stdOut.fail() || !stdOut.is_open() || !shellProcess || !shellProcess.running()) {
             throw EOFError("Reached end of the stream");
         }
-        auto *file_data = new uint8_t[size];
-        stdOut.read(reinterpret_cast<char*>(file_data), size);
+        auto file_data = std::make_shared<uint8_t[]>(size);
+        stdOut.read(reinterpret_cast<char*>(file_data.get()), size);
         if (stdOut.fail()) {
             throw FileError("Error while reading the file");
         }

{ntgcalls-1.0.0.dev16 → ntgcalls-1.0.0.dev18}/ntgcalls/media/audio_streamer.cpp

@@ -24,7 +24,7 @@ namespace ntgcalls {
         return std::chrono::milliseconds(10); // ms
     }
 
-    void AudioStreamer::sendData(wrtc::binary &sample) {
+    void AudioStreamer::sendData(wrtc::binary sample) {
         BaseStreamer::sendData(sample);
         auto event = wrtc::RTCOnDataEvent(sample, frameSize() / (2 * channels));
         event.channelCount = channels;

{ntgcalls-1.0.0.dev16 → ntgcalls-1.0.0.dev18}/ntgcalls/media/audio_streamer.hpp

@@ -29,7 +29,7 @@ namespace ntgcalls {
 
         wrtc::MediaStreamTrack *createTrack() override;
 
-        void sendData(wrtc::binary &sample) override;
+        void sendData(wrtc::binary sample) override;
 
         uint64_t frameSize() override;
 

{ntgcalls-1.0.0.dev16 → ntgcalls-1.0.0.dev18}/ntgcalls/media/base_streamer.cpp

@@ -9,7 +9,7 @@ namespace ntgcalls {
         clear();
     }
 
-    void BaseStreamer::sendData(wrtc::binary &sample) {
+    void BaseStreamer::sendData(wrtc::binary sample) {
         lastTime = std::chrono::high_resolution_clock::now();
         sentFrames++;
     }

{ntgcalls-1.0.0.dev16 → ntgcalls-1.0.0.dev18}/ntgcalls/media/base_streamer.hpp

@@ -31,7 +31,7 @@ namespace ntgcalls {
 
         virtual wrtc::MediaStreamTrack *createTrack() = 0;
 
-        virtual void sendData(wrtc::binary &sample);
+        virtual void sendData(wrtc::binary sample);
 
         virtual uint64_t frameSize() = 0;
     };

{ntgcalls-1.0.0.dev16 → ntgcalls-1.0.0.dev18}/ntgcalls/media/video_streamer.cpp

@@ -24,7 +24,7 @@ namespace ntgcalls {
         return video->createTrack();
     }
 
-    void VideoStreamer::sendData(wrtc::binary &sample) {
+    void VideoStreamer::sendData(wrtc::binary sample) {
         BaseStreamer::sendData(sample);
         video->OnFrame(
             wrtc::i420ImageData(

{ntgcalls-1.0.0.dev16 → ntgcalls-1.0.0.dev18}/ntgcalls/media/video_streamer.hpp

@@ -31,7 +31,7 @@ namespace ntgcalls {
 
         wrtc::MediaStreamTrack *createTrack() override;
 
-        void sendData(wrtc::binary &sample) override;
+        void sendData(wrtc::binary sample) override;
 
         uint64_t frameSize() override;
 

{ntgcalls-1.0.0.dev16 → ntgcalls-1.0.0.dev18}/ntgcalls/stream.cpp

@@ -82,10 +82,6 @@ namespace ntgcalls {
                     if (sample) {
                         bsBR.first->sendData(sample);
                     }
-                    if (sample) {
-                        delete[] sample;
-                        sample = nullptr;
-                    }
                 }
                 checkStream();
             }

{ntgcalls-1.0.0.dev16 → ntgcalls-1.0.0.dev18/ntgcalls.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ntgcalls
-Version: 1.0.0.dev16
+Version: 1.0.0.dev18
 Home-page: https://github.com/pytgcalls/ntgcalls
 Author: Laky-64
 Author-email: iraci.matteo@gmail.com

{ntgcalls-1.0.0.dev16 → ntgcalls-1.0.0.dev18}/ntgcalls.egg-info/SOURCES.txt

@@ -1413,6 +1413,8 @@ wrtc/interfaces/peer_connection/create_session_description_observer.cpp
 wrtc/interfaces/peer_connection/create_session_description_observer.hpp
 wrtc/interfaces/peer_connection/peer_connection_factory.cpp
 wrtc/interfaces/peer_connection/peer_connection_factory.hpp
+wrtc/interfaces/peer_connection/peer_connection_factory_with_context.cpp
+wrtc/interfaces/peer_connection/peer_connection_factory_with_context.hpp
 wrtc/interfaces/peer_connection/set_session_description_observer.cpp
 wrtc/interfaces/peer_connection/set_session_description_observer.hpp
 wrtc/models/i420_image_data.cpp

{ntgcalls-1.0.0.dev16 → ntgcalls-1.0.0.dev18}/wrtc/enums.hpp

@@ -5,9 +5,10 @@
 #pragma once
 
 #include <stdint.h>
+#include <memory>
 
 namespace wrtc {
-    typedef uint8_t *binary;
+    typedef std::shared_ptr<uint8_t[]> binary;
     typedef uint32_t SSRC;
     typedef int32_t TgSSRC;
 

{ntgcalls-1.0.0.dev16 → ntgcalls-1.0.0.dev18}/wrtc/interfaces/media/tracks/audio_track_source.cpp

@@ -30,11 +30,12 @@ namespace wrtc {
         webrtc::AudioTrackSinkInterface *sink = _sink;
         if (sink) {
             sink->OnData(
-                    data.audioData,
+                    data.audioData.get(),
                     data.bitsPerSample,
                     data.sampleRate,
                     data.channelCount,
-                    data.numberOfFrames
+                    data.numberOfFrames,
+                    rtc::TimeMillis()
             );
         }
     }

ntgcalls-1.0.0.dev18/wrtc/interfaces/peer_connection/peer_connection_factory.cpp

@@ -0,0 +1,95 @@
+//
+// Created by Laky64 on 16/08/2023.
+//
+
+#include "peer_connection_factory.hpp"
+
+namespace wrtc {
+    std::mutex PeerConnectionFactory::_mutex{};
+    int PeerConnectionFactory::_references = 0;
+    rtc::scoped_refptr<PeerConnectionFactory> PeerConnectionFactory::_default = nullptr;
+
+    PeerConnectionFactory::PeerConnectionFactory() {
+        network_thread_ = rtc::Thread::CreateWithSocketServer();
+        network_thread_->Start();
+        worker_thread_ = rtc::Thread::Create();
+        worker_thread_->Start();
+        signaling_thread_ = rtc::Thread::Create();
+        signaling_thread_->Start();
+
+        webrtc::PeerConnectionFactoryDependencies dependencies;
+        dependencies.network_thread = network_thread_.get();
+        dependencies.worker_thread = worker_thread_.get();
+        dependencies.signaling_thread = signaling_thread_.get();
+        dependencies.task_queue_factory = webrtc::CreateDefaultTaskQueueFactory();
+        dependencies.call_factory = webrtc::CreateCallFactory();
+        dependencies.event_log_factory =
+                absl::make_unique<webrtc::RtcEventLogFactory>(
+                        dependencies.task_queue_factory.get());
+        cricket::MediaEngineDependencies media_dependencies;
+        media_dependencies.task_queue_factory = dependencies.task_queue_factory.get();
+        media_dependencies.adm = worker_thread_->BlockingCall([&] {
+            if (!_audioDeviceModule)
+                _audioDeviceModule = webrtc::AudioDeviceModule::Create(webrtc::AudioDeviceModule::kDummyAudio, dependencies.task_queue_factory.get());
+            return _audioDeviceModule;
+        });
+        auto config = VideoFactoryConfig();
+        media_dependencies.audio_encoder_factory = webrtc::CreateBuiltinAudioEncoderFactory();
+        media_dependencies.audio_decoder_factory = webrtc::CreateBuiltinAudioDecoderFactory();
+        media_dependencies.video_encoder_factory = config.CreateVideoEncoderFactory();
+        media_dependencies.video_decoder_factory = config.CreateVideoDecoderFactory();
+        media_dependencies.audio_mixer = nullptr;
+        media_dependencies.audio_processing = webrtc::AudioProcessingBuilder().Create();
+        dependencies.media_engine = cricket::CreateMediaEngine(std::move(media_dependencies));
+        if (!_factory) {
+            _factory = wrtc::PeerConnectionFactoryWithContext::Create(std::move(dependencies), connection_context_);
+        }
+        webrtc::PeerConnectionFactoryInterface::Options options;
+        options.disable_encryption = false;
+        options.ssl_max_version = rtc::SSL_PROTOCOL_DTLS_12;
+        options.crypto_options.srtp.enable_gcm_crypto_suites = true;
+        _factory->SetOptions(options);
+    }
+
+    PeerConnectionFactory::~PeerConnectionFactory() {
+        _factory = nullptr;
+
+        if (_audioDeviceModule) {
+            worker_thread_->BlockingCall([this] { DestroyAudioDeviceModule_w(); });
+        }
+
+        worker_thread_->Stop();
+        signaling_thread_->Stop();
+        network_thread_->Stop();
+    }
+
+    void PeerConnectionFactory::DestroyAudioDeviceModule_w() {
+        if (_audioDeviceModule)
+            _audioDeviceModule = nullptr;
+    }
+
+    rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> PeerConnectionFactory::factory() {
+        return _factory;
+    }
+
+    rtc::scoped_refptr<PeerConnectionFactory> PeerConnectionFactory::GetOrCreateDefault() {
+        _mutex.lock();
+        _references++;
+        if (_references == 1) {
+            rtc::InitializeSSL();
+            _default = rtc::scoped_refptr<PeerConnectionFactory>(new rtc::RefCountedObject<PeerConnectionFactory>());
+        }
+        _mutex.unlock();
+        return _default;
+    }
+
+    void PeerConnectionFactory::UnRef() {
+        _mutex.lock();
+        _references--;
+        if (!_references) {
+            rtc::CleanupSSL();
+            _default = nullptr;
+        }
+        _mutex.unlock();
+    }
+} // wrtc

{ntgcalls-1.0.0.dev16 → ntgcalls-1.0.0.dev18}/wrtc/interfaces/peer_connection/peer_connection_factory.hpp

@@ -8,11 +8,14 @@
 #include <rtc_base/ssl_adapter.h>
 #include <api/peer_connection_interface.h>
 #include <api/create_peerconnection_factory.h>
+#include <api/rtc_event_log/rtc_event_log_factory.h>
 #include <api/task_queue/default_task_queue_factory.h>
 #include <api/audio_codecs/builtin_audio_encoder_factory.h>
 #include <api/audio_codecs/builtin_audio_decoder_factory.h>
-
+#include <media/engine/webrtc_media_engine.h>
+#include "peer_connection_factory_with_context.hpp"
 #include "../../video_factory/video_factory_config.hpp"
+#include "pc/connection_context.h"
 
 namespace wrtc {
 
@@ -27,24 +30,22 @@ namespace wrtc {
         static void UnRef();
 
         rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> factory();
-
-        std::unique_ptr<rtc::Thread> _workerThread;
     private:
-        void CreateAudioDeviceModule_w();
-
         void DestroyAudioDeviceModule_w();
 
         static std::mutex _mutex;
         static int _references;
         static rtc::scoped_refptr<PeerConnectionFactory> _default;
 
-        std::unique_ptr<rtc::Thread> _signalingThread;
-        std::unique_ptr<rtc::Thread> _networkThread;
+        std::unique_ptr<rtc::Thread> network_thread_;
+        std::unique_ptr<rtc::Thread> worker_thread_;
+        std::unique_ptr<rtc::Thread> signaling_thread_;
 
         rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> _factory;
+        rtc::scoped_refptr<webrtc::ConnectionContext> connection_context_;
         rtc::scoped_refptr<webrtc::AudioDeviceModule> _audioDeviceModule;
 
-        std::unique_ptr<webrtc::TaskQueueFactory> _taskQueueFactory;
+        std::unique_ptr<webrtc::TaskQueueFactory> task_queue_factory_;
     };
 
 } // wrtc

ntgcalls-1.0.0.dev18/wrtc/interfaces/peer_connection/peer_connection_factory_with_context.cpp

@@ -0,0 +1,51 @@
+//
+// Created by Laky64 on 30/09/2023.
+//
+
+#include "peer_connection_factory_with_context.hpp"
+
+namespace wrtc {
+    rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface>
+    PeerConnectionFactoryWithContext::Create(
+            webrtc::PeerConnectionFactoryDependencies dependencies,
+            rtc::scoped_refptr<webrtc::ConnectionContext> &context) {
+        using result_type =
+                std::pair<rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface>,
+                        rtc::scoped_refptr<webrtc::ConnectionContext>>;
+        auto p = dependencies.signaling_thread->BlockingCall([&dependencies]() {
+            auto factory =
+                    PeerConnectionFactoryWithContext::Create(std::move(dependencies));
+            if (factory == nullptr) {
+                return result_type(nullptr, nullptr);
+            }
+            auto context = factory->GetContext();
+            auto proxy = webrtc::PeerConnectionFactoryProxy::Create(
+                    factory->signaling_thread(), factory->worker_thread(), factory);
+            return result_type(proxy, context);
+        });
+        context = p.second;
+        return p.first;
+    }
+
+    rtc::scoped_refptr<PeerConnectionFactoryWithContext>
+    PeerConnectionFactoryWithContext::Create(webrtc::PeerConnectionFactoryDependencies dependencies) {
+        return rtc::make_ref_counted<PeerConnectionFactoryWithContext>(
+                std::move(dependencies));
+    }
+
+    rtc::scoped_refptr<webrtc::ConnectionContext> PeerConnectionFactoryWithContext::GetContext() const {
+        return conn_context_;
+    }
+
+    PeerConnectionFactoryWithContext::PeerConnectionFactoryWithContext(
+            rtc::scoped_refptr<webrtc::ConnectionContext> context,
+            webrtc::PeerConnectionFactoryDependencies *dependencies)
+            : conn_context_(context),
+              webrtc::PeerConnectionFactory(context, dependencies) {}
+
+    PeerConnectionFactoryWithContext::PeerConnectionFactoryWithContext(
+            webrtc::PeerConnectionFactoryDependencies dependencies)
+            : PeerConnectionFactoryWithContext(
+            webrtc::ConnectionContext::Create(&dependencies),
+            &dependencies) {}
+} // wrtc

ntgcalls-1.0.0.dev18/wrtc/interfaces/peer_connection/peer_connection_factory_with_context.hpp

@@ -0,0 +1,34 @@
+//
+// Created by Laky64 on 30/09/2023.
+//
+
+#pragma once
+
+#include <pc/peer_connection_factory.h>
+#include <pc/peer_connection_factory_proxy.h>
+
+namespace wrtc {
+
+    class PeerConnectionFactoryWithContext : public webrtc::PeerConnectionFactory {
+    public:
+        static rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> Create(
+                webrtc::PeerConnectionFactoryDependencies dependencies,
+                rtc::scoped_refptr<webrtc::ConnectionContext>& context);
+
+        PeerConnectionFactoryWithContext(
+                webrtc::PeerConnectionFactoryDependencies dependencies);
+
+        PeerConnectionFactoryWithContext(
+                rtc::scoped_refptr<webrtc::ConnectionContext> context,
+                webrtc::PeerConnectionFactoryDependencies* dependencies);
+
+    private:
+        static rtc::scoped_refptr<PeerConnectionFactoryWithContext> Create(
+                webrtc::PeerConnectionFactoryDependencies dependencies);
+
+        rtc::scoped_refptr<webrtc::ConnectionContext> GetContext() const;
+
+        rtc::scoped_refptr<webrtc::ConnectionContext> conn_context_;
+    };
+} // wrtc
+

{ntgcalls-1.0.0.dev16 → ntgcalls-1.0.0.dev18}/wrtc/models/i420_image_data.cpp

@@ -13,15 +13,15 @@ namespace wrtc {
         return sizeOfLuminancePlane() / 4;
     }
 
-    binary i420ImageData::dataY() {
-        return contents;
+    uint8_t* i420ImageData::dataY() {
+        return contents.get();
     }
 
-    binary i420ImageData::dataU() {
+    uint8_t* i420ImageData::dataU() {
         return dataY() + sizeOfLuminancePlane();
     }
 
-    binary i420ImageData::dataV() {
+    uint8_t* i420ImageData::dataV() {
         return dataU() + sizeOfChromaPlane();
     }
 

{ntgcalls-1.0.0.dev16 → ntgcalls-1.0.0.dev18}/wrtc/models/i420_image_data.hpp

@@ -20,7 +20,7 @@ namespace wrtc {
 
         size_t sizeOfChromaPlane() const;
 
-        binary dataY();
+        uint8_t* dataY();
 
         uint8_t* dataU();
 

{ntgcalls-1.0.0.dev16 → ntgcalls-1.0.0.dev18}/wrtc/models/rtc_on_data_event.cpp

@@ -6,7 +6,7 @@
 
 namespace wrtc {
 
-  RTCOnDataEvent::RTCOnDataEvent(binary &data, uint16_t length) {
+  RTCOnDataEvent::RTCOnDataEvent(binary data, uint16_t length) {
     audioData = data;
     numberOfFrames = length;
   }

{ntgcalls-1.0.0.dev16 → ntgcalls-1.0.0.dev18}/wrtc/models/rtc_on_data_event.hpp

@@ -13,9 +13,9 @@ namespace wrtc {
 
   class RTCOnDataEvent {
   public:
-    RTCOnDataEvent(binary &, uint16_t);
+    RTCOnDataEvent(binary, uint16_t);
 
-    uint8_t *audioData;
+    binary audioData;
     uint16_t numberOfFrames;
     uint32_t sampleRate = 48000;
     uint8_t bitsPerSample = 16;

ntgcalls-1.0.0.dev16/wrtc/interfaces/peer_connection/peer_connection_factory.cpp

@@ -1,93 +0,0 @@
-//
-// Created by Laky64 on 16/08/2023.
-//
-
-#include "peer_connection_factory.hpp"
-
-namespace wrtc {
-    std::mutex PeerConnectionFactory::_mutex{};
-    int PeerConnectionFactory::_references = 0;
-    rtc::scoped_refptr<PeerConnectionFactory> PeerConnectionFactory::_default = nullptr;
-
-    PeerConnectionFactory::PeerConnectionFactory() {
-        _workerThread = rtc::Thread::Create();
-        _workerThread->SetName("worker_thread", nullptr);
-        RTC_CHECK(_workerThread->Start()) << "Failed to start thread";
-
-        _signalingThread = rtc::Thread::Create();
-        _signalingThread->SetName("signaling_thread", nullptr);
-        RTC_CHECK(_signalingThread->Start()) << "Failed to start thread";
-
-        _networkThread = rtc::Thread::CreateWithSocketServer();
-        _networkThread->SetName("network_thread", nullptr);
-        RTC_CHECK(_networkThread->Start()) << "Failed to start thread";
-        if (!_audioDeviceModule) {
-            _taskQueueFactory = webrtc::CreateDefaultTaskQueueFactory();
-            _workerThread->BlockingCall([this] { CreateAudioDeviceModule_w(); });
-        }
-
-        auto config = VideoFactoryConfig();
-
-        if (!_factory) {
-            _factory = webrtc::CreatePeerConnectionFactory(
-                    _networkThread.get(), _workerThread.get(), _signalingThread.get(),
-                    _audioDeviceModule,
-                    webrtc::CreateBuiltinAudioEncoderFactory(),
-                    webrtc::CreateBuiltinAudioDecoderFactory(),
-                    config.CreateVideoEncoderFactory(),
-                    config.CreateVideoDecoderFactory(),
-                    nullptr, nullptr);
-        }
-
-        webrtc::PeerConnectionFactoryInterface::Options options;
-        options.network_ignore_mask = 0;
-        _factory->SetOptions(options);
-    }
-
-    PeerConnectionFactory::~PeerConnectionFactory() {
-        _factory = nullptr;
-
-        if (_audioDeviceModule) {
-            _workerThread->BlockingCall([this] { DestroyAudioDeviceModule_w(); });
-        }
-
-        _workerThread->Stop();
-        _signalingThread->Stop();
-        _networkThread->Stop();
-    }
-
-    void PeerConnectionFactory::CreateAudioDeviceModule_w() {
-        if (!_audioDeviceModule)
-            _audioDeviceModule = webrtc::AudioDeviceModule::Create(webrtc::AudioDeviceModule::kDummyAudio, _taskQueueFactory.get());
-    }
-
-    void PeerConnectionFactory::DestroyAudioDeviceModule_w() {
-        if (_audioDeviceModule)
-            _audioDeviceModule = nullptr;
-    }
-
-    rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> PeerConnectionFactory::factory() {
-        return _factory;
-    }
-
-    rtc::scoped_refptr<PeerConnectionFactory> PeerConnectionFactory::GetOrCreateDefault() {
-        _mutex.lock();
-        _references++;
-        if (_references == 1) {
-            rtc::InitializeSSL();
-            _default = rtc::scoped_refptr<PeerConnectionFactory>(new rtc::RefCountedObject<PeerConnectionFactory>());
-        }
-        _mutex.unlock();
-        return _default;
-    }
-
-    void PeerConnectionFactory::UnRef() {
-        _mutex.lock();
-        _references--;
-        if (!_references) {
-            rtc::CleanupSSL();
-            _default = nullptr;
-        }
-        _mutex.unlock();
-    }
-} // wrtc