Add native self-hosted instance connection to fluxer_desktop

Trimmed monorepo checkout (fluxer_desktop + packages/voice_engine_v2 + tools/ci) with a "Connect to a Different Server" menu item and popout that lets the desktop app switch to any self-hosted Fluxer instance, plus fixes for well-known discovery on single-domain self-hosted deployments and a false-positive ERR_ABORTED on same-origin client redirects during the switch. Defaults to chat.fluxr.chat and uses an isolated userData directory from the official build.
2026-07-01 18:22:43 -04:00
commit 682afacd30
1763 changed files with 613720 additions and 0 deletions
@@ -0,0 +1,214 @@
+; /*
+   *  Copyright (c) 2011 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.
+   */
+
+#ifndef WEBRTC_MODULES_VIDEO_CODING_CODECS_TEST_FRAWEWORK_BENCHMARK_H_
+#define WEBRTC_MODULES_VIDEO_CODING_CODECS_TEST_FRAWEWORK_BENCHMARK_H_
+
+#include <cstdlib>
+#include <fstream>
+#include <list>
+#include <queue>
+#include <string>
+
+#include "cpu/cpu_linux.h"
+#include "api/environment/environment_factory.h"
+#include "modules/include/module_common_types.h"
+#include "modules/video_coding/include/video_codec_interface.h"
+#include "rtc_base/synchronization/mutex.h"
+#include "system_wrappers/include/clock.h"
+
+
+class VideoSource;
+class Benchmark;
+
+// feedback signal to encoder
+struct fbSignal {
+  fbSignal(int d, uint8_t pid) : delay(d), id(pid) {};
+  int delay;
+  uint8_t id;
+};
+
+class FrameQueueTuple {
+ public:
+  FrameQueueTuple(webrtc::VideoFrame* frame,
+                  const webrtc::CodecSpecificInfo* codecSpecificInfo = NULL)
+      : _frame(frame), _codecSpecificInfo(codecSpecificInfo) {};
+  ~FrameQueueTuple();
+  webrtc::VideoFrame* _frame;
+  const webrtc::CodecSpecificInfo* _codecSpecificInfo;
+};
+
+class FrameQueue {
+ public:
+  FrameQueue() {}
+
+  ~FrameQueue() {}
+
+  void PushFrame(webrtc::VideoFrame* frame,
+                 webrtc::CodecSpecificInfo* codecSpecificInfo = NULL);
+  FrameQueueTuple* PopFrame();
+  bool Empty();
+
+ private:
+  webrtc::Mutex _queueRWLock;
+  std::queue<FrameQueueTuple*> _frameBufferQueue;
+};
+
+class VideoEncodeCompleteCallback : public webrtc::EncodedImageCallback {
+ public:
+  VideoEncodeCompleteCallback(FILE* encodedFile,
+                              FrameQueue* frameQueue,
+                              Benchmark& test)
+      : _encodedFile(encodedFile),
+        _frameQueue(frameQueue),
+        _test(test),
+        _encodedBytes(0) {}
+
+  webrtc::EncodedImageCallback::Result OnEncodedImage(
+      const webrtc::EncodedImage& encoded_image,
+      const webrtc::CodecSpecificInfo* codec_specific_info) override;
+
+  uint32_t EncodedBytes();
+
+ private:
+  FILE* _encodedFile;
+  FrameQueue* _frameQueue;
+  Benchmark& _test;
+  uint32_t _encodedBytes;
+};
+
+class Benchmark {
+ public:
+  friend class VideoEncodeCompleteCallback;
+
+ public:
+  Benchmark();
+  virtual void Perform();
+  virtual bool IsSupported() = 0;
+
+ protected:
+  Benchmark(std::string name, std::string description);
+  Benchmark(std::string name,
+            std::string description,
+            std::string resultsFileName,
+            std::string codecName);
+  virtual webrtc::VideoEncoder* GetNewEncoder(webrtc::Environment &env) = 0;
+  virtual void PerformNormalTest();
+  virtual void CodecSpecific_InitBitrate();
+  static const char* GetMagicStr() { return "#!benchmark1.0"; }
+
+  double ActualBitRate(int nFrames) {
+    return 8.0 * _sumEncBytes / (nFrames / _inst.maxFramerate);
+  }
+
+  webrtc::CodecSpecificInfo* CopyCodecSpecificInfo(
+      const webrtc::CodecSpecificInfo* codecSpecificInfo) const;
+
+  bool Encode();
+
+  void Setup();
+
+  void Teardown();
+
+  void CodecSettings(int width,
+                     int height,
+                     uint32_t frameRate /*=30*/,
+                     uint32_t bitRate /*=0*/) {
+    if (bitRate > 0) {
+      _bitRate = bitRate;
+    } else if (_bitRate == 0) {
+      _bitRate = 600;
+    }
+    _inst.codecType = webrtc::kVideoCodecH264;
+    _inst.maxFramerate = (unsigned char)frameRate;
+    _inst.minBitrate = (unsigned char)frameRate;
+    _inst.startBitrate = (int)_bitRate;
+    _inst.maxBitrate = 8000;
+    _inst.width = width;
+    _inst.height = height;
+    _inst.numberOfSimulcastStreams = 1;
+    _inst.simulcastStream[0].width = width;
+    _inst.simulcastStream[0].height = height;
+    _inst.simulcastStream[0].maxBitrate = 8000;
+    _inst.simulcastStream[0].minBitrate = _bitRate;
+    _inst.simulcastStream[0].targetBitrate = _bitRate;
+    _inst.simulcastStream[0].maxFramerate = frameRate;
+    _inst.simulcastStream[0].active = true;
+    _inst.SetScalabilityMode(webrtc::ScalabilityMode::kL1T1);
+    _inst.mode = webrtc::VideoCodecMode::kRealtimeVideo;
+    _inst.qpMax = 56;
+    _inst.SetFrameDropEnabled(true);
+  }
+
+  double tGetTime() {
+    // return time in sec
+    return ((double)(webrtc::Clock::GetRealTimeClock()->TimeInMilliseconds()) /
+            1000);
+  }
+
+  virtual webrtc::CodecSpecificInfo* CreateEncoderSpecificInfo() const {
+    return NULL;
+  };
+
+  void UpdateEncodedBytes(int encodedBytes) { _sumEncBytes += encodedBytes; }
+
+  const VideoSource* _target;
+  std::string _resultsFileName;
+  std::ofstream _results;
+  std::string _name;
+  std::string _description;
+  std::string _codecName;
+  std::string _inname;
+  std::string _outname;
+  webrtc::VideoEncoder* _encoder;
+  //webrtc::VideoDecoder* _decoder;
+  uint32_t _bitRate;
+  bool _appendNext = false;
+  int _framecnt;
+  int _encFrameCnt;
+  double _totalEncodeTime;
+  double _totalDecodeTime;
+  double _decodeCompleteTime;
+  double _encodeCompleteTime;
+  double _totalEncodePipeTime;
+  double _totalDecodePipeTime;
+  webrtc::VideoCodec _inst;
+  int _sumEncBytes;
+
+  unsigned int _lengthSourceFrame = 0;
+  unsigned char* _sourceBuffer = nullptr;
+
+  FILE* _encodedFile = nullptr;
+  unsigned int _lengthEncFrame = 0;
+  FrameQueueTuple* _frameToDecode = nullptr;
+
+  FILE* _sourceFile = nullptr;
+  FILE* _decodedFile = nullptr;
+
+  bool _hasReceivedPLI = false;
+  bool _waitForKey = false;
+  std::map<uint32_t, double> _encodeTimes;
+  std::map<uint32_t, double> _decodeTimes;
+
+  bool _missingFrames = false;
+  std::list<fbSignal> _signalSLI;
+  int _rttFrames = 0;
+  mutable bool _hasReceivedSLI = false;
+  mutable bool _hasReceivedRPSI = false;
+  uint8_t _pictureIdSLI = 0;
+  uint16_t _pictureIdRPSI = 0;
+  uint64_t _lastDecRefPictureId = 0;
+  uint64_t _lastDecPictureId = 0;
+  std::list<fbSignal> _signalPLI;
+  webrtc::CpuWrapper* _cpu;
+  webrtc::Environment _env;
+};
+
+#endif  // WEBRTC_MODULES_VIDEO_CODING_CODECS_TEST_FRAWEWORK_BENCHMARK_H_