@0biwank/screen-capture 1.0.1 → 2.0.1

package/include/DesktopCapturer.h

@@ -0,0 +1,83 @@
+#pragma once
+
+#include "Types.h"
+#include <atomic>
+#include <functional>
+#include <memory>
+#include <string>
+
+using SegmentReadyCallback = std::function<void(const std::string&)>;
+
+struct CaptureOptions
+{
+    CGDirectDisplayID display_id = 0;
+    bool capture_window = false;
+    CGWindowID window_id = 0;
+    bool no_screen = false;
+
+    bool camera = false;
+    std::string camera_device_uid;
+
+    uint32_t width = 1920;
+    uint32_t height = 1080;
+    uint32_t fps = 30;
+    uint32_t gop_size = 30;
+    uint32_t video_bitrate = 9'000'000;
+    bool crop_enabled = false;
+    uint32_t crop_x = 0;
+    uint32_t crop_y = 0;
+    uint32_t crop_width = 0;
+    uint32_t crop_height = 0;
+
+    bool system_audio = true;
+    bool microphone = false;
+    std::string mic_device_uid;
+    uint32_t sample_rate = 48000;
+    uint32_t audio_bitrate = 128'000;
+    uint32_t channels = 2;
+    bool exclude_app_audio = false;
+
+    std::string output_dir;
+    std::string recording_id;
+    uint32_t segment_time_sec = 4;
+};
+
+class DesktopCapturer
+{
+public:
+    DesktopCapturer();
+    ~DesktopCapturer();
+
+    bool selectSource(CaptureSource source);
+    bool startCapture(const CaptureOptions &options, SegmentReadyCallback segment_ready_callback = nullptr);
+    bool stopCapture();
+    bool pauseCapture();
+    bool resumeCapture();
+    const std::string &lastError() const { return m_last_error; }
+
+    void on_video_sample(void *cm_sample_buffer_ref);
+    void on_camera_sample(void *cm_sample_buffer_ref);
+    void on_audio_sample(void *cm_sample_buffer_ref);
+    void on_mic_pcm(const float *data, uint32_t frames, uint32_t sample_rate, uint32_t channels,
+                    double host_time_sec);
+
+private:
+    void *m_stream = nullptr;
+    void *m_config = nullptr;
+    void *m_filter = nullptr;
+    void *m_delegate = nullptr;
+    void *m_audio_engine = nullptr;
+    void *m_camera_capturer = nullptr;
+
+    CaptureSource m_source;
+    CaptureOptions m_options;
+    std::string m_last_error;
+
+    bool m_capturing = false;
+
+    struct Impl;
+    std::unique_ptr<Impl> m_impl;
+
+    bool setup_mic_capture();
+    void stop_mic_capture();
+};

package/include/HLSMuxer/AudioEncoder.h

@@ -0,0 +1,75 @@
+#pragma once
+
+#include <iostream>
+#include <queue>
+#include <string>
+#include "Types.h"
+#include <vector>
+#include <cstdint>
+
+extern "C"
+{
+    struct AVCodec;
+    struct AVStream;
+    struct AVFormatContext;
+    struct AVCodecContext;
+    struct SwrContext;
+    struct AVAudioFifo;
+    struct AVFrame;
+    struct AVPacket;
+}
+
+class AudioEncoder
+{
+private:
+    // state variables
+    bool m_initialized;
+
+    // conversion essentials
+    int m_sampleRate;
+    int m_channels;
+    int m_bitrate;
+    int64_t m_pts;
+    int64_t m_sampleCount;
+    int64_t m_nextInputPts;
+    std::queue<AVPacket *> m_packetQueue;
+    std::vector<std::string> m_chunkFileNames;
+
+    // FFMpeg
+    const AVCodec *m_codec;
+    OutputMode mode;
+    AVCodecContext *m_codecContext;
+    SwrContext *m_swrContext;
+    AVAudioFifo *m_audioFifo;
+    AVFrame *m_frame;
+
+    // standalone
+    AVStream *m_stream;
+    AVFormatContext *m_formatContext;
+    int currentChunkIndex;
+    double targetChunkDuration;
+    int64_t currentSegmentStartPts;
+    double currentSegmentDuration;
+
+private:
+    bool shouldStartNewChunk() const;
+    void forceNewChunk();
+    // Drain encoder and handle remaining packets based on mode
+    void flushEncoder();
+
+public:
+    AudioEncoder();
+    ~AudioEncoder();
+    bool initialize(int sampleRate, int channels, int bitrate, OutputMode mode);
+    bool encodeSamples(const uint8_t *samples, int numSamples, int64_t pts = -1);
+    AVPacket *getNextPacket();
+    bool hasPackets() const;
+    std::string generatePlaylist() const;
+    void cleanup();
+
+    bool isInitialized() { return m_initialized; }
+    int getSampleRate() { return m_sampleRate; }
+    int getChannels() { return m_channels; }
+    const AVCodecContext *getCodecContext() const { return m_codecContext; }
+    OutputMode getMode() const { return mode; }
+};

package/include/HLSMuxer/FileHLSMuxer.h

@@ -0,0 +1,63 @@
+#pragma once
+
+#include <cstdint>
+#include <functional>
+#include <set>
+#include <string>
+
+extern "C" {
+struct AVBSFContext;
+struct AVCodecContext;
+struct AVFormatContext;
+struct AVPacket;
+struct AVStream;
+}
+
+class FileHLSMuxer {
+public:
+    FileHLSMuxer();
+    ~FileHLSMuxer();
+
+    bool init(const std::string& output_dir,
+              const std::string& recording_id,
+              int segment_time_sec,
+              const AVCodecContext* video_codec_ctx,
+              const AVCodecContext* audio_codec_ctx);
+
+    void set_expected_segment_duration_ms(double duration_ms);
+    void set_segment_ready_callback(std::function<void(const std::string&)> callback);
+
+    void push_video(AVPacket* pkt);
+    void push_audio(AVPacket* pkt);
+
+    void shutdown();
+    bool is_initialized() const { return m_initialized; }
+
+private:
+    int write_packet(AVPacket* pkt, bool is_video);
+    bool init_h264_bsf_if_needed();
+    void log_overlong_segment_if_needed(AVPacket* pkt);
+    void notify_ready_segments();
+
+    AVFormatContext* m_fmt_ctx = nullptr;
+    AVStream* m_video_stream = nullptr;
+    AVStream* m_audio_stream = nullptr;
+    AVBSFContext* m_h264_bsf_ctx = nullptr;
+
+    std::string m_output_dir;
+    std::string m_recording_id;
+    std::string m_playlist_path;
+    std::set<std::string> m_notified_segments;
+    std::function<void(const std::string&)> m_segment_ready_callback;
+    bool m_initialized = false;
+
+    int m_fps = 30;
+    int m_sample_rate = 48000;
+    int m_audio_frame_samples = 1024;
+    int m_video_tb_num = 1;
+    int m_video_tb_den = 30;
+    int m_audio_tb_num = 1;
+    int m_audio_tb_den = 48000;
+    double m_expected_segment_duration_ms = 0.0;
+    int64_t m_last_segment_key_pts = -1;
+};

package/include/HLSMuxer/HLSMuxer.h

@@ -0,0 +1,13 @@
+#include <Foundation/Foundation.h>
+
+extern "C" {
+#include <libavcodec/avcodec.h>
+#include <libavformat/avformat.h>
+#include <libswresample/swresample.h>
+}
+
+class Encoder {
+private:
+  bool m_Initialized;
+  
+};

package/include/HLSMuxer/VideoEncoder.h

@@ -0,0 +1,90 @@
+#pragma once
+/*
+This Encoder in the default format needs to produce H264 packets
+and when in the seperate stream mode it needs to produces TS chunks.
+
+- Input: CVPixelBufferRef, BGRA
+- Output:
+    - Default: H264 packets for the TS Muxer to process
+    - Seperate Stream: TS chunks with playlist.
+
+I need to track frame count, timestamps, keyframes
+*/
+
+#include "Types.h"
+#include <cstdint>
+#include <iostream>
+#include <queue>
+#include <vector>
+
+extern "C"
+{
+  struct AVCodecContext;
+  struct AVPacket;
+  struct AVCodec;
+  struct AVFrame;
+  struct SwsContext;
+  struct AVStream;
+  struct AVFormatContext;
+}
+
+class VideoEncoder
+{
+  // all variables
+private:
+  int frameHeight;
+  int frameWidth;
+  int frameRate;
+  bool isPaused;
+  bool m_initialized;
+
+  // FFMPEG
+  AVCodecContext *m_codecContext;
+  const AVCodec *m_codec;
+  AVStream *m_stream;
+  AVFormatContext *m_formatContext;
+  AVFrame *m_frame;
+  SwsContext *m_swsContext;
+
+  // Timing & state
+  int64_t m_frameCount;
+  int64_t m_pts;
+  int64_t m_dts;
+  int64_t m_lastInputPts;
+  int64_t currentSegmentStartPts;
+  double currentSegmentDuration;
+
+  // Chunking
+  int currentChunkIndex;
+  double targetChunkDuration;
+  OutputMode mode;
+  std::vector<std::string> m_chunkFileNames;
+
+  // output buffer
+  std::queue<AVPacket *> m_packetQueue;
+
+  // all functions
+public:
+  VideoEncoder();
+  ~VideoEncoder();
+  bool initialize(int width, int height, int fps, int bitrate, OutputMode mode, int gopSize = 0);
+  bool encodeFrame(uint8_t *pixelData, int stride, int64_t pts = -1);
+  void cleanup();
+
+  // Chunk control
+  void forceKeyFrame();
+  bool shouldStartNewChunk() const;
+
+  // Muxed mode when we want just single stream
+  AVPacket *getNextPacket();
+  bool hasPackets() const;
+  std::string generatePlaylist() const;
+
+  // getters to get the state of the VideoEncoder
+  bool isInitialized() const { return m_initialized; }
+  int getWidth() const { return frameWidth; }
+  int getHeigth() const { return frameHeight; }
+  int getFPS() const { return frameRate; }
+  int64_t getFrameCount() const { return m_frameCount; }
+  const AVCodecContext *getCodecContext() const { return m_codecContext; }
+};

package/include/MediaPipeline.h

@@ -0,0 +1,39 @@
+#pragma once
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <string>
+
+struct PipelineConfig {
+    int      width          = 1920;
+    int      height         = 1080;
+    int      fps            = 30;
+    int      gop_size       = 30;
+    int      video_bitrate  = 9'000'000;
+    int      sample_rate    = 48000;
+    int      channels       = 2;
+    int      audio_bitrate  = 128'000;
+    std::string output_dir;
+    std::string recording_id;
+    int      segment_time_sec = 4;
+    std::function<void(const std::string&)> segment_ready_callback;
+};
+
+class MediaPipeline {
+public:
+    MediaPipeline();
+    ~MediaPipeline();
+
+    bool init(const PipelineConfig& cfg);
+
+    void push_video_frame(const uint8_t* data, int stride, int64_t pts_ticks,
+                          bool is_keyframe_hint = false);
+
+    void push_audio_s16(const int16_t* data, int num_frames, int64_t pts_samples);
+
+    void flush_and_shutdown();
+
+private:
+    struct Impl;
+    std::unique_ptr<Impl> m_impl;
+};

package/include/SourceHelper.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <Foundation/Foundation.h>
+#include <ScreenCaptureKit/ScreenCaptureKit.h>
+#include <cstdint>
+#include <iostream>
+#include <vector>
+#include <ApplicationServices/ApplicationServices.h>
+/*
+food for thought: should I keep a shared
+list of sources that get refreshed every
+time, or should I just provide the functions
+to get the list?
+
+Both should be easy to do but ig we should
+go with the idea where I just return the list
+right!? Shouldn't complicate it too much
+*/
+
+namespace SourceHelper
+{
+    struct Displays
+    {
+        CGDirectDisplayID id;
+        uint32_t width;
+        uint32_t height;
+        std::string title;
+        bool isMain;
+    };
+    struct Windows
+    {
+        CGWindowID id;
+        uint32_t width;
+        uint32_t height;
+        std::string title;
+        // CGWindow
+    };
+    std::vector<Displays> getDisplaySources();
+    std::vector<Windows> getWindowSources();
+    bool isCaptureableWindow(const NSDictionary* windowInfo);
+}

package/include/SourceHelperWrapper.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <vector>
+#include <cstdint>
+#include <string>
+
+namespace SourceHelperWrapper
+{
+    struct Display
+    {
+        uint32_t id;
+        uint32_t width;
+        uint32_t height;
+        std::string title;
+        bool isMain;
+    };
+
+    struct Window
+    {
+        uint32_t id;
+        uint32_t width;
+        uint32_t height;
+        std::string title;
+    };
+
+    std::vector<Display> getDisplaySources();
+    std::vector<Window> getWindowSources();
+    bool isCaptureableWindow(uint32_t windowID);
+}

package/include/Types.h

@@ -0,0 +1,58 @@
+#pragma once
+
+// only use for universal type definitions
+#include <ApplicationServices/ApplicationServices.h>
+#include <CoreFoundation/CFCGTypes.h>
+#include <CoreGraphics/CGDirectDisplay.h>
+#include <CoreGraphics/CGGeometry.h>
+#include <CoreGraphics/CGWindow.h>
+#include <cstdint>
+#include <string>
+
+/*
+    I think I wrote this very good ;)
+    PS Claude helped too! Constructor was it's idea
+
+
+    EDIT: modified to store the scContent
+*/
+struct CaptureSource {
+  bool isWindow;
+  union {
+    CGWindowID windowID;
+    CGDirectDisplayID displayID;
+  };
+  void *scContent;
+  uint32_t width;
+  uint32_t height;
+  std::string title;
+  CGRect captureRect;
+
+  static CaptureSource createWindow(CGWindowID id, uint32_t w, uint32_t h,
+                                    std::string t) {
+    CaptureSource s;
+    s.isWindow = true;
+    s.windowID = id;
+    s.width = w;
+    s.height = h;
+    s.title = t;
+    s.captureRect = CGRectMake(0, 0, w, h);
+    s.scContent = nullptr;
+    return s;
+  }
+
+  static CaptureSource createDisplay(CGDirectDisplayID id, uint32_t w,
+                                     uint32_t h, std::string t) {
+    CaptureSource s;
+    s.isWindow = false;
+    s.displayID = id;
+    s.width = w;
+    s.height = h;
+    s.title = t;
+    s.captureRect = CGRectMake(0, 0, w, h);
+    s.scContent = nullptr;
+    return s;
+  }
+};
+
+enum class OutputMode { STANDALONE, MUXED };

package/include/UploadManager.h

@@ -0,0 +1,9 @@
+#include <cstdint>
+#include <iostream>
+#include <queue>
+#include <boost/asio.hpp>
+
+class UploadManager {
+private:
+  std::queue<uint8_t> uploadQueue;
+};