@0biwank/screen-capture 2.0.1 → 2.0.2

package/src/MediaPipeline.cpp

@@ -1,375 +0,0 @@
-/*
- * MediaPipeline.cpp — pure C++ file.
- *
- * All FFmpeg includes are here. No Apple/ObjC headers.
- * The AVMediaType clash is avoided because this file never includes AVFoundation.
- */
-
-#include "MediaPipeline.h"
-#include "HLSMuxer/VideoEncoder.h"
-#include "HLSMuxer/AudioEncoder.h"
-#include "HLSMuxer/FileHLSMuxer.h"
-#include <mutex>
-#include <deque>
-#include <vector>
-#include <algorithm>
-#include <iostream>
-
-extern "C" {
-#include <libavcodec/avcodec.h>
-}
-
-struct MediaPipeline::Impl {
-    struct PendingAudio {
-        int64_t startFrame = 0;
-        int frames = 0;
-        std::vector<int16_t> samples;
-    };
-
-    VideoEncoder video_enc;
-    AudioEncoder audio_enc;
-    FileHLSMuxer file_muxer;
-    std::mutex   pipeline_mutex;
-    int          channels = 2;
-    int          sampleRate = 48000;
-    int          fps = 30;
-    bool forceNextKeyframe = false;
-    int64_t keyframeIntervalTicks = 30;
-    int64_t nextForcedKeyframePts = 30;
-    int64_t currentSegmentStartPtsTicks = -1;
-    int64_t lastKeyframePtsTicks = -1;
-    bool awaitingForcedKeyframe = false;
-    bool warnedOverlongSegment = false;
-    bool warnedDoubleOverlongSegment = false;
-    bool pendingResumeKeyframe = false;
-    uint64_t forcedKeyframeCount = 0;
-    int64_t lastVideoPtsTicks = -1;
-    int64_t lastAudioEndFrame = 0;
-    std::deque<PendingAudio> pendingAudio;
-
-    int64_t maxAudioEndFrame() const {
-        if (lastVideoPtsTicks < 0 || fps <= 0 || sampleRate <= 0) {
-            return 0;
-        }
-
-        return ((lastVideoPtsTicks + 1) * static_cast<int64_t>(sampleRate)) /
-            static_cast<int64_t>(fps);
-    }
-
-    void drainAudioPackets() {
-        while (audio_enc.hasPackets()) {
-            AVPacket* pkt = audio_enc.getNextPacket();
-            if (pkt) {
-                file_muxer.push_audio(pkt);
-            }
-        }
-    }
-
-    void encodeAudioFrames(const int16_t* data, int frames, int64_t pts) {
-        if (!data || frames <= 0) {
-            return;
-        }
-
-        audio_enc.encodeSamples(
-            reinterpret_cast<const uint8_t*>(data),
-            frames,
-            pts);
-        lastAudioEndFrame = pts + frames;
-        drainAudioPackets();
-    }
-
-    void encodeSilence(int frames, int64_t pts) {
-        if (frames <= 0) {
-            return;
-        }
-
-        std::vector<int16_t> silence(static_cast<size_t>(frames) * channels, 0);
-        encodeAudioFrames(silence.data(), frames, pts);
-    }
-
-    void drainPendingAudioToVideo() {
-        const int64_t maxEndFrame = maxAudioEndFrame();
-        if (maxEndFrame <= 0) {
-            return;
-        }
-
-        while (!pendingAudio.empty() && lastAudioEndFrame < maxEndFrame) {
-            PendingAudio audio = std::move(pendingAudio.front());
-            pendingAudio.pop_front();
-
-            if (audio.frames <= 0 || audio.samples.empty()) {
-                continue;
-            }
-
-            const int64_t audioEndFrame = audio.startFrame + audio.frames;
-            if (audioEndFrame <= lastAudioEndFrame) {
-                continue;
-            }
-
-            if (audio.startFrame > lastAudioEndFrame) {
-                const int silenceFrames = static_cast<int>(
-                    std::min<int64_t>(
-                        audio.startFrame - lastAudioEndFrame,
-                        maxEndFrame - lastAudioEndFrame));
-                encodeSilence(silenceFrames, lastAudioEndFrame);
-                if (lastAudioEndFrame >= maxEndFrame) {
-                    pendingAudio.push_front(std::move(audio));
-                    break;
-                }
-            }
-
-            int64_t sampleOffsetFrames = 0;
-            if (audio.startFrame < lastAudioEndFrame) {
-                sampleOffsetFrames = lastAudioEndFrame - audio.startFrame;
-            }
-
-            if (sampleOffsetFrames >= audio.frames) {
-                continue;
-            }
-
-            const int readyFrames = static_cast<int>(
-                std::min<int64_t>(
-                    audio.frames - sampleOffsetFrames,
-                    maxEndFrame - lastAudioEndFrame));
-
-            if (readyFrames <= 0) {
-                pendingAudio.push_front(std::move(audio));
-                break;
-            }
-
-            const int16_t* samples = audio.samples.data() +
-                (sampleOffsetFrames * channels);
-            encodeAudioFrames(samples, readyFrames, lastAudioEndFrame);
-
-            const int64_t consumedFrames = sampleOffsetFrames + readyFrames;
-            const int remainingFrames = static_cast<int>(audio.frames - consumedFrames);
-            if (remainingFrames > 0) {
-                PendingAudio rest;
-                rest.startFrame = audio.startFrame + consumedFrames;
-                rest.frames = remainingFrames;
-                const int16_t* restData = audio.samples.data() +
-                    (consumedFrames * channels);
-                rest.samples.assign(
-                    restData,
-                    restData + (static_cast<int64_t>(remainingFrames) * channels));
-                pendingAudio.push_front(std::move(rest));
-                break;
-            }
-        }
-    }
-
-    void requestKeyframe(int64_t pts_ticks, const char* reason) {
-        forceNextKeyframe = true;
-        awaitingForcedKeyframe = true;
-        ++forcedKeyframeCount;
-        std::cerr << "[MediaPipeline] Requesting native keyframe"
-                  << " ptsTicks=" << pts_ticks
-                  << " reason=" << reason
-                  << " forcedCount=" << forcedKeyframeCount
-                  << "\n";
-    }
-
-    void checkSegmentCadenceBeforeEncode(int64_t pts_ticks) {
-        if (pts_ticks < 0 || keyframeIntervalTicks <= 0) {
-            return;
-        }
-
-        if (currentSegmentStartPtsTicks < 0) {
-            currentSegmentStartPtsTicks = pts_ticks;
-        }
-
-        const int64_t segmentAgeTicks = pts_ticks - currentSegmentStartPtsTicks;
-        if (pts_ticks >= nextForcedKeyframePts) {
-            requestKeyframe(pts_ticks, "scheduled-boundary");
-            while (pts_ticks >= nextForcedKeyframePts) {
-                nextForcedKeyframePts += keyframeIntervalTicks;
-            }
-        } else if (awaitingForcedKeyframe && segmentAgeTicks >= keyframeIntervalTicks) {
-            requestKeyframe(pts_ticks, "awaiting-encoded-keyframe");
-        }
-
-        if (segmentAgeTicks > keyframeIntervalTicks + 1 && !warnedOverlongSegment) {
-            warnedOverlongSegment = true;
-            std::cerr << "[MediaPipeline] Native segment exceeded expected cadence"
-                      << " segmentStartPts=" << currentSegmentStartPtsTicks
-                      << " currentPts=" << pts_ticks
-                      << " lastKeyframePts=" << lastKeyframePtsTicks
-                      << " expectedTicks=" << keyframeIntervalTicks
-                      << " forcedCount=" << forcedKeyframeCount
-                      << "\n";
-        }
-
-        if (segmentAgeTicks > (keyframeIntervalTicks * 2) && !warnedDoubleOverlongSegment) {
-            warnedDoubleOverlongSegment = true;
-            std::cerr << "[MediaPipeline] Native segment exceeded double expected cadence"
-                      << " segmentStartPts=" << currentSegmentStartPtsTicks
-                      << " currentPts=" << pts_ticks
-                      << " lastKeyframePts=" << lastKeyframePtsTicks
-                      << " expectedTicks=" << keyframeIntervalTicks
-                      << " forcedCount=" << forcedKeyframeCount
-                      << "\n";
-        }
-    }
-
-    void markEncodedKeyframe(int64_t pkt_pts) {
-        if (pkt_pts < 0) {
-            pkt_pts = lastVideoPtsTicks;
-        }
-        if (pkt_pts < 0) {
-            return;
-        }
-
-        const bool wasAwaitingForcedKeyframe = awaitingForcedKeyframe;
-        lastKeyframePtsTicks = pkt_pts;
-        currentSegmentStartPtsTicks = pkt_pts;
-        awaitingForcedKeyframe = false;
-        warnedOverlongSegment = false;
-        warnedDoubleOverlongSegment = false;
-
-        while (nextForcedKeyframePts <= pkt_pts) {
-            nextForcedKeyframePts += keyframeIntervalTicks;
-        }
-
-        if (pendingResumeKeyframe || wasAwaitingForcedKeyframe) {
-            std::cerr << "[MediaPipeline] Encoded native keyframe"
-                      << " ptsTicks=" << pkt_pts
-                      << " resume=" << (pendingResumeKeyframe ? "true" : "false")
-                      << " forcedCount=" << forcedKeyframeCount
-                      << "\n";
-        }
-        pendingResumeKeyframe = false;
-    }
-};
-
-MediaPipeline::MediaPipeline()
-    : m_impl(std::make_unique<Impl>())
-{}
-
-MediaPipeline::~MediaPipeline() {
-    // flush_and_shutdown should be called explicitly; this is a safety net
-    if (m_impl) {
-        m_impl->file_muxer.shutdown();
-    }
-}
-
-bool MediaPipeline::init(const PipelineConfig& cfg) {
-    m_impl->channels = cfg.channels;
-    m_impl->sampleRate = cfg.sample_rate > 0 ? cfg.sample_rate : 48000;
-    m_impl->fps = cfg.fps > 0 ? cfg.fps : 30;
-    m_impl->keyframeIntervalTicks = cfg.gop_size > 0 ? cfg.gop_size : cfg.fps;
-    m_impl->nextForcedKeyframePts = m_impl->keyframeIntervalTicks;
-
-    if (!m_impl->video_enc.initialize(cfg.width, cfg.height, cfg.fps,
-                                       cfg.video_bitrate, OutputMode::MUXED,
-                                       cfg.gop_size))
-        return false;
-
-    if (!m_impl->audio_enc.initialize(cfg.sample_rate, cfg.channels,
-                                       cfg.audio_bitrate, OutputMode::MUXED))
-        return false;
-
-    const double expectedSegmentMs =
-        (static_cast<double>(m_impl->keyframeIntervalTicks) * 1000.0) /
-        static_cast<double>(m_impl->fps);
-
-    if (!m_impl->file_muxer.init(cfg.output_dir,
-                                 cfg.recording_id,
-                                 cfg.segment_time_sec,
-                                 m_impl->video_enc.getCodecContext(),
-                                 m_impl->audio_enc.getCodecContext()))
-        return false;
-    m_impl->file_muxer.set_expected_segment_duration_ms(expectedSegmentMs);
-    m_impl->file_muxer.set_segment_ready_callback(cfg.segment_ready_callback);
-    std::cerr << "[MediaPipeline] file-backed native HLS enabled"
-              << " outputDir=" << cfg.output_dir
-              << " recordingId=" << cfg.recording_id
-              << " segmentTime=" << cfg.segment_time_sec
-              << "\n";
-    return true;
-}
-
-void MediaPipeline::push_video_frame(const uint8_t* data, int stride,
-                                      int64_t pts_ticks, bool is_keyframe_hint)
-{
-    std::lock_guard<std::mutex> lock(m_impl->pipeline_mutex);
-
-    if(is_keyframe_hint){
-        m_impl->pendingResumeKeyframe = true;
-        m_impl->requestKeyframe(pts_ticks, "explicit-hint");
-    }
-
-    m_impl->checkSegmentCadenceBeforeEncode(pts_ticks);
-
-    if(m_impl->forceNextKeyframe){
-        m_impl->video_enc.forceKeyFrame();
-        m_impl->forceNextKeyframe = false;
-    }
-
-    if (pts_ticks >= 0) {
-        m_impl->lastVideoPtsTicks = std::max(m_impl->lastVideoPtsTicks, pts_ticks);
-    }
-
-    // VideoEncoder takes non-const uint8_t* (legacy API)
-    m_impl->video_enc.encodeFrame(const_cast<uint8_t*>(data), stride, pts_ticks);
-
-    while (m_impl->video_enc.hasPackets()) {
-        AVPacket* pkt = m_impl->video_enc.getNextPacket();
-        if (!pkt) break;
-        bool is_key = (pkt->flags & AV_PKT_FLAG_KEY) != 0;
-        if (is_key) {
-            m_impl->markEncodedKeyframe(pkt->pts);
-        }
-        m_impl->file_muxer.push_video(pkt);
-    }
-
-    m_impl->drainPendingAudioToVideo();
-}
-
-void MediaPipeline::push_audio_s16(const int16_t* data, int num_frames, int64_t pts_samples) {
-    std::lock_guard<std::mutex> lock(m_impl->pipeline_mutex);
-
-    if (num_frames <= 0 || pts_samples < 0) {
-        return;
-    }
-
-    Impl::PendingAudio pending;
-    pending.startFrame = pts_samples;
-    pending.frames = num_frames;
-    pending.samples.assign(data, data + (num_frames * m_impl->channels));
-    m_impl->pendingAudio.push_back(std::move(pending));
-
-    const int64_t keepAfter = std::max<int64_t>(
-        0,
-        m_impl->lastAudioEndFrame - static_cast<int64_t>(m_impl->sampleRate));
-    while (!m_impl->pendingAudio.empty() &&
-           m_impl->pendingAudio.front().startFrame +
-               m_impl->pendingAudio.front().frames <= keepAfter)
-    {
-        m_impl->pendingAudio.pop_front();
-    }
-}
-
-void MediaPipeline::flush_and_shutdown() {
-    std::lock_guard<std::mutex> lock(m_impl->pipeline_mutex);
-
-    m_impl->video_enc.cleanup();
-    while (m_impl->video_enc.hasPackets()) {
-        AVPacket* pkt = m_impl->video_enc.getNextPacket();
-        if (pkt) {
-            m_impl->file_muxer.push_video(pkt);
-        }
-    }
-
-    m_impl->drainPendingAudioToVideo();
-    m_impl->pendingAudio.clear();
-
-    m_impl->audio_enc.cleanup();
-    while (m_impl->audio_enc.hasPackets()) {
-        AVPacket* pkt = m_impl->audio_enc.getNextPacket();
-        if (pkt) {
-            m_impl->file_muxer.push_audio(pkt);
-        }
-    }
-
-    m_impl->file_muxer.shutdown();
-}

package/src/SourceHelper.mm

@@ -1,184 +0,0 @@
-#include "SourceHelper.h"
-#include <ApplicationServices/ApplicationServices.h>
-#include <CoreFoundation/CFBase.h>
-#include <CoreFoundation/CFDictionary.h>
-#include <CoreGraphics/CGDirectDisplay.h>
-#include <CoreGraphics/CGWindow.h>
-#include <Foundation/Foundation.h>
-#include <Foundation/NSObjCRuntime.h>
-#include <ScreenCaptureKit/ScreenCaptureKit.h>
-#include <cstdint>
-#include <iostream>
-
-CGDirectDisplayID CGDisplayIDFromNSScreen(NSScreen *screen) {
-  NSDictionary *deviceDescription = [screen deviceDescription];
-  NSNumber *screenNumber = [deviceDescription objectForKey:@"NSScreenNumber"];
-  return [screenNumber unsignedIntValue];
-}
-
-std::vector<SourceHelper::Displays> SourceHelper::getDisplaySources() {
-  CGDirectDisplayID displays[16];
-  std::vector<SourceHelper::Displays> displayList;
-  CGDisplayCount availableDisplays;
-  CGError err = CGGetActiveDisplayList(16, displays, &availableDisplays);
-
-  for (int i = 0; i < availableDisplays; i++) {
-    CGDirectDisplayID display = displays[i];
-    CGDisplayModeRef mode = CGDisplayCopyDisplayMode(display);
-    uint32_t width = 0;
-    uint32_t height = 0;
-
-    if (mode) {
-      // This gets the actual pixel dimensions
-      width = CGDisplayModeGetPixelWidth(mode);
-      height = CGDisplayModeGetPixelHeight(mode);
-
-      // Some macOS versions need this approach
-      if (width == 0 || height == 0) {
-        // Use NSScreen for accurate pixel resolution
-        NSScreen *screen = nil;
-        for (NSScreen *s in [NSScreen screens]) {
-          if (CGDisplayIDFromNSScreen(s) == display) {
-            screen = s;
-            break;
-          }
-        }
-        if (screen) {
-          NSRect backing = [screen convertRectToBacking:[screen frame]];
-          width = (uint32_t)backing.size.width;
-          height = (uint32_t)backing.size.height;
-        }
-      }
-      CGDisplayModeRelease(mode);
-    }
-    CGRect bounds = CGDisplayBounds(display);
-    NSString *title = [NSString stringWithFormat:@"Display %u", display];
-    std::string titleStr = std::string([title UTF8String]);
-
-    bool isMain = (display == CGMainDisplayID());
-    displayList.push_back({display, width, height, titleStr, isMain});
-  }
-
-  return displayList;
-}
-
-std::vector<SourceHelper::Windows> SourceHelper::getWindowSources() {
-  CFArrayRef windows = CGWindowListCopyWindowInfo(
-      kCGWindowListOptionOnScreenOnly, kCGNullWindowID);
-  std::vector<SourceHelper::Windows> windowList;
-  if (windows) {
-    CFIndex count = CFArrayGetCount(windows);
-    for (CFIndex i = 0; i < count; i++) {
-      CFDictionaryRef windowInfo =
-          (CFDictionaryRef)CFArrayGetValueAtIndex(windows, i);
-      CFNumberRef windowIDRef =
-          (CFNumberRef)CFDictionaryGetValue(windowInfo, kCGWindowNumber);
-
-      if (windowIDRef) {
-        CGWindowID windowID;
-        CFNumberGetValue(windowIDRef, kCFNumberIntType, &windowID);
-        bool isCaptureable =
-            isCaptureableWindow((__bridge NSDictionary *)windowInfo);
-        if (isCaptureable) {
-          // Debug output
-          CFStringRef windowNameRef =
-              (CFStringRef)CFDictionaryGetValue(windowInfo, kCGWindowName);
-          if (windowNameRef) {
-            std::cout << "Window ID: " << windowID << " - ";
-            CFDictionaryRef boundsRef = (CFDictionaryRef)CFDictionaryGetValue(
-                windowInfo, kCGWindowBounds);
-            uint32_t width = 0;
-            uint32_t height = 0;
-            if (boundsRef) {
-              CGRect bounds;
-              if (CGRectMakeWithDictionaryRepresentation(boundsRef, &bounds)) {
-                width = (uint32_t)bounds.size.width;
-                height = (uint32_t)bounds.size.height;
-              }
-            }
-            std::cout << "Width: " << width << ", Height: " << height
-                      << std::endl;
-            CFStringRef ownerNameRef = (CFStringRef)CFDictionaryGetValue(
-                windowInfo, kCGWindowOwnerName);
-            char ownerName[256];
-            if (ownerNameRef) {
-              if (CFStringGetCString(ownerNameRef, ownerName, sizeof(ownerName),
-                                     kCFStringEncodingUTF8)) {
-                std::cout << "Owner: " << ownerName << " - ";
-              }
-            }
-            char windowName[256];
-            if (CFStringGetCString(windowNameRef, windowName,
-                                   sizeof(windowName), kCFStringEncodingUTF8)) {
-              std::cout << windowName << std::endl;
-            }
-            windowList.push_back(
-                {windowID, width, height,
-                 std::string(ownerName) + " - " + std::string(windowName)});
-          }
-        }
-      }
-    }
-    CFRelease(windows);
-  }
-  return windowList;
-}
-
-bool SourceHelper::isCaptureableWindow(const NSDictionary *windowInfo) {
-  NSNumber *isOnscreen =
-      [windowInfo objectForKey:(__bridge NSString *)kCGWindowIsOnscreen];
-  if (!isOnscreen || ![isOnscreen boolValue]) {
-    return false;
-  }
-
-  // Filter out windows with no owner (e.g., desktop elements)
-  NSNumber *ownerPID =
-      [windowInfo objectForKey:(__bridge NSString *)kCGWindowOwnerPID];
-  if (!ownerPID || [ownerPID intValue] == 0) {
-    return false;
-  }
-
-  // Filter out windows with layer != 0 (normal windows are at layer 0)
-  NSNumber *windowLayer =
-      [windowInfo objectForKey:(__bridge NSString *)kCGWindowLayer];
-  if (windowLayer && [windowLayer intValue] != 0) {
-    return false;
-  }
-
-  // Filter out windows with no bounds or zero size
-  NSDictionary *boundsDict =
-      [windowInfo objectForKey:(__bridge NSString *)kCGWindowBounds];
-  if (boundsDict) {
-    CGRect bounds;
-    if (CGRectMakeWithDictionaryRepresentation(
-            (__bridge CFDictionaryRef)boundsDict, &bounds)) {
-      if (bounds.size.width <= 1 || bounds.size.height <= 1) {
-        return false;
-      }
-    }
-  }
-
-  // Filter out special window types
-  NSString *windowName =
-      [windowInfo objectForKey:(__bridge NSString *)kCGWindowName];
-  NSString *ownerName =
-      [windowInfo objectForKey:(__bridge NSString *)kCGWindowOwnerName];
-
-  // Exclude system UI elements and known non-capturable windows
-  if (ownerName) {
-    std::string owner = std::string([ownerName UTF8String]);
-    if (owner == "Window Server" || owner == "SystemUIServer" ||
-        owner == "Dock" || owner == "Control Center" ||
-        owner == "NotificationCenter" || owner == "Spotlight") {
-      return false;
-    }
-  }
-
-  if (windowName && [windowName length] > 0) {
-    std::string name = std::string([windowName UTF8String]);
-    if (name == "Dock" || name == "Menubar" || name.empty()) {
-      return false;
-    }
-  }
-  return true;
-}

package/src/SourceHelperWrapper.mm

@@ -1,63 +0,0 @@
-#include "SourceHelperWrapper.h"
-#include "SourceHelper.h"
-#include <Foundation/Foundation.h>
-
-// Implementation of wrapper functions
-std::vector<SourceHelperWrapper::Display>
-SourceHelperWrapper::getDisplaySources() {
-  std::vector<SourceHelperWrapper::Display> result;
-  std::vector<SourceHelper::Displays> displays =
-      SourceHelper::getDisplaySources();
-
-  for (const auto &display : displays) {
-    result.push_back({static_cast<uint32_t>(display.id),
-                      static_cast<uint32_t>(display.width),
-                      static_cast<uint32_t>(display.height), display.title,
-                      display.isMain});
-  }
-
-  return result;
-}
-
-std::vector<SourceHelperWrapper::Window>
-SourceHelperWrapper::getWindowSources() {
-  std::vector<SourceHelperWrapper::Window> result;
-  std::vector<SourceHelper::Windows> windows = SourceHelper::getWindowSources();
-
-  for (const auto &window : windows) {
-    result.push_back({static_cast<uint32_t>(window.id),
-                      static_cast<uint32_t>(window.width),
-                      static_cast<uint32_t>(window.height),
-                      window.title.empty() ? "" : window.title});
-  }
-
-  return result;
-}
-
-bool SourceHelperWrapper::isCaptureableWindow(uint32_t windowID) {
-  CFArrayRef windows =
-      CGWindowListCopyWindowInfo(kCGWindowListOptionAll, kCGNullWindowID);
-  if (!windows)
-    return false;
-
-  CFIndex count = CFArrayGetCount(windows);
-  for (CFIndex i = 0; i < count; i++) {
-    CFDictionaryRef windowInfo =
-        (CFDictionaryRef)CFArrayGetValueAtIndex(windows, i);
-    CFNumberRef windowIDRef =
-        (CFNumberRef)CFDictionaryGetValue(windowInfo, kCGWindowNumber);
-
-    if (windowIDRef) {
-      CGWindowID currentID;
-      CFNumberGetValue(windowIDRef, kCFNumberIntType, &currentID);
-      if (currentID == windowID) {
-        bool result = SourceHelper::isCaptureableWindow(
-            (__bridge NSDictionary *)windowInfo);
-        CFRelease(windows);
-        return result;
-      }
-    }
-  }
-  CFRelease(windows);
-  return false;
-}

package/src/UploadManager.h

@@ -1,7 +0,0 @@
-#include <boost/asio.hpp>
-#include <queue>
-
-class UploadManager {
-private:
-// queue<
-};