@0biwank/screen-capture 2.0.1 → 2.0.2

package/src/DesktopCapturer.mm

@@ -1,995 +0,0 @@
-#import <AVFoundation/AVFoundation.h>
-#import <CoreAudio/CoreAudio.h>
-#import <CoreMedia/CoreMedia.h>
-#import <CoreVideo/CVPixelBuffer.h>
-#import <Foundation/Foundation.h>
-#import <ScreenCaptureKit/ScreenCaptureKit.h>
-#import <AudioUnit/AudioUnit.h>
-
-#include "DesktopCapturer.h"
-#include "CameraCapturer.h"
-#include "MediaPipeline.h"
-
-#include <atomic>
-#include <deque>
-#include <memory>
-#include <mutex>
-#include <iostream>
-#include <vector>
-#include <algorithm>
-#include <cmath>
-#include <cstring>
-#include <mach/mach_time.h>
-
-namespace {
-constexpr float kNativeMicGain = 2.0f;
-constexpr size_t kMaxMicBufferFrames = 48000;
-
-double host_time_to_seconds(uint64_t host_time) {
-    if (host_time == 0) return -1.0;
-    static mach_timebase_info_data_t timebase = [] {
-        mach_timebase_info_data_t info;
-        mach_timebase_info(&info);
-        return info;
-    }();
-    const double nanos =
-        static_cast<double>(host_time) *
-        static_cast<double>(timebase.numer) /
-        static_cast<double>(timebase.denom);
-    return nanos / 1'000'000'000.0;
-}
-
-uint32_t even_down(uint32_t value) {
-    return value > 1 ? (value & ~1u) : value;
-}
-
-float soft_limit(float v) {
-    // Smooth saturation keeps transients from breaking the mixed AAC encoder.
-    return std::tanh(v * 0.85f);
-}
-
-bool find_audio_device_by_uid(const std::string& uid, AudioDeviceID* out_device) {
-    if (uid.empty() || !out_device) return false;
-
-    AudioObjectPropertyAddress addr = {
-        kAudioHardwarePropertyDevices,
-        kAudioObjectPropertyScopeGlobal,
-        kAudioObjectPropertyElementMain
-    };
-
-    UInt32 data_size = 0;
-    OSStatus status = AudioObjectGetPropertyDataSize(
-        kAudioObjectSystemObject, &addr, 0, nullptr, &data_size);
-    if (status != noErr || data_size == 0) return false;
-
-    std::vector<AudioDeviceID> devices(data_size / sizeof(AudioDeviceID));
-    status = AudioObjectGetPropertyData(
-        kAudioObjectSystemObject, &addr, 0, nullptr, &data_size, devices.data());
-    if (status != noErr) return false;
-
-    AudioObjectPropertyAddress uid_addr = {
-        kAudioDevicePropertyDeviceUID,
-        kAudioObjectPropertyScopeGlobal,
-        kAudioObjectPropertyElementMain
-    };
-
-    for (AudioDeviceID device : devices) {
-        CFStringRef cf_uid = nullptr;
-        UInt32 uid_size = sizeof(cf_uid);
-        status = AudioObjectGetPropertyData(device, &uid_addr, 0, nullptr, &uid_size, &cf_uid);
-        if (status != noErr || !cf_uid) continue;
-
-        char buffer[512] = {0};
-        const bool matches =
-            CFStringGetCString(cf_uid, buffer, sizeof(buffer), kCFStringEncodingUTF8) &&
-            uid == buffer;
-        CFRelease(cf_uid);
-
-        if (matches) {
-            *out_device = device;
-            return true;
-        }
-    }
-
-    return false;
-}
-
-bool get_default_input_device(AudioDeviceID* out_device) {
-    if (!out_device) return false;
-
-    AudioObjectPropertyAddress addr = {
-        kAudioHardwarePropertyDefaultInputDevice,
-        kAudioObjectPropertyScopeGlobal,
-        kAudioObjectPropertyElementMain
-    };
-
-    UInt32 data_size = sizeof(AudioDeviceID);
-    OSStatus status = AudioObjectGetPropertyData(
-        kAudioObjectSystemObject, &addr, 0, nullptr, &data_size, out_device);
-    return status == noErr && *out_device != kAudioObjectUnknown;
-}
-}
-
-struct DesktopCapturer::Impl {
-    struct AudioSegment {
-        int64_t start_frame = 0;
-        uint32_t frames = 0;
-        std::vector<float> pcm;
-    };
-
-    struct MixedAudioChunk {
-        int64_t start_frame = 0;
-        uint32_t frames = 0;
-        std::vector<float> pcm;
-    };
-
-    std::unique_ptr<MediaPipeline> pipeline;
-    std::atomic<bool> started{false};
-
-    std::atomic<bool> paused{false};
-    std::atomic<bool> resumePending{false};
-
-    double last_video_pts_sec = -1.0;
-    double pauseStartedVideoPtsSec = -1.0;
-
-    double totalPausedVideoSec = 0.0;
-    bool audioGated = false;
-
-    std::mutex         mix_mutex;
-    std::deque<AudioSegment> mic_segments;
-    std::deque<AudioSegment> system_segments;
-    uint32_t           sample_rate = 48000;
-    uint32_t           channels    = 2;
-    double             video_pts_origin_sec = -1.0;
-    double             mic_host_origin_sec = -1.0;
-    int64_t            last_video_pts_tick = -1;
-    std::atomic<uint64_t> mic_callbacks{0};
-    std::atomic<uint64_t> mic_frames{0};
-    std::atomic<uint64_t> dropped_audio_frames{0};
-    int64_t            last_mixed_audio_frame = 0;
-
-    void reset_audio_sync() {
-        std::lock_guard<std::mutex> lk(mix_mutex);
-        mic_segments.clear();
-        system_segments.clear();
-        mic_host_origin_sec = -1.0;
-        last_mixed_audio_frame = 0;
-    }
-
-    void append_segment(std::deque<AudioSegment>& segments,
-                        int64_t start_frame,
-                        uint32_t frames,
-                        std::vector<float>&& pcm)
-    {
-        if (start_frame < 0 || frames == 0 || pcm.empty()) return;
-        segments.push_back({start_frame, frames, std::move(pcm)});
-
-        const int64_t newest_end = segments.back().start_frame + segments.back().frames;
-        const int64_t keep_after = newest_end - static_cast<int64_t>(kMaxMicBufferFrames);
-        while (!segments.empty() &&
-               segments.front().start_frame + segments.front().frames <= keep_after)
-        {
-            segments.pop_front();
-        }
-    }
-
-    std::vector<MixedAudioChunk> collect_ready_locked(bool has_mic)
-    {
-        std::vector<MixedAudioChunk> chunks;
-        const int64_t latest_mic_end = mic_segments.empty()
-            ? -1
-            : mic_segments.back().start_frame + mic_segments.back().frames;
-
-        while (!system_segments.empty()) {
-            AudioSegment& sys = system_segments.front();
-            if (sys.start_frame + sys.frames <= last_mixed_audio_frame) {
-                system_segments.pop_front();
-                continue;
-            }
-
-            if (sys.start_frame < last_mixed_audio_frame) {
-                const int64_t trim = last_mixed_audio_frame - sys.start_frame;
-                if (trim >= sys.frames) {
-                    system_segments.pop_front();
-                    continue;
-                }
-                sys.pcm.erase(
-                    sys.pcm.begin(),
-                    sys.pcm.begin() + static_cast<ptrdiff_t>(trim * channels));
-                sys.start_frame = last_mixed_audio_frame;
-                sys.frames -= static_cast<uint32_t>(trim);
-            }
-
-            const int64_t sys_end = sys.start_frame + sys.frames;
-            if (has_mic && latest_mic_end < sys_end) {
-                break;
-            }
-
-            MixedAudioChunk chunk;
-            chunk.start_frame = sys.start_frame;
-            chunk.frames = sys.frames;
-            chunk.pcm = sys.pcm;
-
-            if (has_mic) {
-                const int64_t end_frame = chunk.start_frame + chunk.frames;
-                for (const AudioSegment& segment : mic_segments) {
-                    const int64_t seg_end = segment.start_frame + segment.frames;
-                    const int64_t overlap_start = std::max(chunk.start_frame, segment.start_frame);
-                    const int64_t overlap_end = std::min(end_frame, seg_end);
-                    if (overlap_start >= overlap_end) continue;
-
-                    const int64_t out_frame_offset = overlap_start - chunk.start_frame;
-                    const int64_t mic_frame_offset = overlap_start - segment.start_frame;
-                    const int64_t overlap_frames = overlap_end - overlap_start;
-
-                    for (int64_t f = 0; f < overlap_frames; ++f) {
-                        for (uint32_t c = 0; c < channels; ++c) {
-                            const size_t out_i =
-                                static_cast<size_t>((out_frame_offset + f) * channels + c);
-                            const size_t mic_i =
-                                static_cast<size_t>((mic_frame_offset + f) * channels + c);
-                            chunk.pcm[out_i] = soft_limit(
-                                chunk.pcm[out_i] + (segment.pcm[mic_i] * kNativeMicGain));
-                        }
-                    }
-                }
-            }
-
-            last_mixed_audio_frame = sys_end;
-            while (!mic_segments.empty() &&
-                   mic_segments.front().start_frame + mic_segments.front().frames <= last_mixed_audio_frame)
-            {
-                mic_segments.pop_front();
-            }
-
-            chunks.push_back(std::move(chunk));
-            system_segments.pop_front();
-        }
-
-        return chunks;
-    }
-
-    std::vector<MixedAudioChunk> append_mic_and_collect_ready(
-        int64_t start_frame,
-        uint32_t frames,
-        std::vector<float>&& pcm)
-    {
-        std::lock_guard<std::mutex> lk(mix_mutex);
-        append_segment(mic_segments, start_frame, frames, std::move(pcm));
-        return collect_ready_locked(true);
-    }
-
-    std::vector<MixedAudioChunk> append_system_and_collect_ready(
-        int64_t start_frame,
-        uint32_t frames,
-        std::vector<float>&& pcm,
-        bool has_mic)
-    {
-        std::lock_guard<std::mutex> lk(mix_mutex);
-        append_segment(system_segments, start_frame, frames, std::move(pcm));
-        return collect_ready_locked(has_mic);
-    }
-};
-
-@interface SCKDelegate : NSObject <SCStreamOutput>
-@property (nonatomic, assign) DesktopCapturer* capturer;
-@end
-
-@implementation SCKDelegate
-- (void)stream:(SCStream*)stream
-    didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer
-                   ofType:(SCStreamOutputType)type
-{
-    if (!self.capturer) return;
-    if (type == SCStreamOutputTypeScreen)
-        self.capturer->on_video_sample(static_cast<void*>(sampleBuffer));
-    else if (type == SCStreamOutputTypeAudio)
-        self.capturer->on_audio_sample(static_cast<void*>(sampleBuffer));
-}
-@end
-
-DesktopCapturer::DesktopCapturer()
-    : m_impl(std::make_unique<Impl>())
-{}
-
-DesktopCapturer::~DesktopCapturer() {
-    stopCapture();
-}
-
-bool DesktopCapturer::selectSource(CaptureSource source) {
-    m_source = source;
-    return true;
-}
-
-bool DesktopCapturer::startCapture(const CaptureOptions& options,
-                                    SegmentReadyCallback segment_ready_callback)
-{
-    if (m_capturing) return false;
-    m_last_error.clear();
-    m_options  = options;
-    if (m_options.no_screen) {
-        // Camera-only capture never starts ScreenCaptureKit, so there is no
-        // system-audio callback to drain the system+mic mixer. Force mic-only
-        // even if the UI-level desktop-audio toggle is enabled.
-        m_options.system_audio = false;
-    }
-
-    const int ch = static_cast<int>(options.channels > 0 ? options.channels : 2);
-    m_impl->sample_rate = options.sample_rate;
-    m_impl->channels    = static_cast<uint32_t>(ch);
-    m_impl->video_pts_origin_sec = -1.0;
-    m_impl->mic_host_origin_sec = -1.0;
-    m_impl->last_video_pts_tick = -1;
-    m_impl->reset_audio_sync();
-
-    uint32_t output_width = options.width;
-    uint32_t output_height = options.height;
-    if (options.crop_enabled) {
-        const uint32_t crop_x = std::min(options.crop_x, options.width > 1 ? options.width - 1 : 0);
-        const uint32_t crop_y = std::min(options.crop_y, options.height > 1 ? options.height - 1 : 0);
-        const uint32_t max_width = options.width - crop_x;
-        const uint32_t max_height = options.height - crop_y;
-        output_width = even_down(std::min(options.crop_width, max_width));
-        output_height = even_down(std::min(options.crop_height, max_height));
-
-        if (output_width < 2 || output_height < 2) {
-            m_last_error = "Invalid native crop dimensions";
-            return false;
-        }
-
-        m_options.crop_x = crop_x;
-        m_options.crop_y = crop_y;
-        m_options.crop_width = output_width;
-        m_options.crop_height = output_height;
-    }
-
-    if (m_options.no_screen && !m_options.camera) {
-        m_last_error = "Native no-screen capture requires camera=true";
-        return false;
-    }
-
-    if (m_options.no_screen && m_options.camera) {
-        CameraCapturer* cam = new CameraCapturer();
-        uint32_t req_width = output_width;
-        uint32_t req_height = output_height;
-        if (!cam->start(m_options.camera_device_uid, req_width, req_height, m_options.fps,
-            [this](void* sb) {
-                this->on_camera_sample(sb);
-            }))
-        {
-            m_last_error = "Failed to start native camera capture for device '" +
-                m_options.camera_device_uid + "' at requested size " +
-                std::to_string(output_width) + "x" + std::to_string(output_height);
-            delete cam;
-            return false;
-        }
-        m_camera_capturer = cam;
-        output_width = req_width;
-        output_height = req_height;
-        m_options.width = output_width;
-        m_options.height = output_height;
-        m_options.crop_enabled = false;
-        m_options.crop_width = output_width;
-        m_options.crop_height = output_height;
-    }
-
-    PipelineConfig pcfg;
-    pcfg.width          = static_cast<int>(output_width);
-    pcfg.height         = static_cast<int>(output_height);
-    pcfg.fps            = static_cast<int>(options.fps);
-    pcfg.gop_size       = static_cast<int>(options.gop_size > 0 ? options.gop_size : options.fps);
-    pcfg.video_bitrate  = static_cast<int>(options.video_bitrate);
-    pcfg.sample_rate    = static_cast<int>(options.sample_rate);
-    pcfg.channels       = ch;
-    pcfg.audio_bitrate  = static_cast<int>(options.audio_bitrate);
-    pcfg.output_dir = options.output_dir;
-    pcfg.recording_id = options.recording_id;
-    pcfg.segment_time_sec = static_cast<int>(options.segment_time_sec > 0 ? options.segment_time_sec : 4);
-    pcfg.segment_ready_callback = std::move(segment_ready_callback);
-
-    m_impl->pipeline = std::make_unique<MediaPipeline>();
-    if (!m_impl->pipeline->init(pcfg))
-    {
-        m_last_error = "Failed to initialize native media pipeline";
-        m_impl->pipeline.reset();
-        if (m_camera_capturer) {
-            static_cast<CameraCapturer*>(m_camera_capturer)->stop();
-            delete static_cast<CameraCapturer*>(m_camera_capturer);
-            m_camera_capturer = nullptr;
-        }
-        return false;
-    }
-
-    m_impl->started.store(true);
-
-    if (options.microphone && !setup_mic_capture()) {
-        m_impl->started.store(false);
-        m_impl->pipeline.reset();
-        if (m_camera_capturer) {
-            static_cast<CameraCapturer*>(m_camera_capturer)->stop();
-            delete static_cast<CameraCapturer*>(m_camera_capturer);
-            m_camera_capturer = nullptr;
-        }
-        return false;
-    }
-
-    if (m_camera_capturer) {
-        m_capturing = true;
-        return true;
-    }
-
-    dispatch_semaphore_t sem = dispatch_semaphore_create(0);
-    __block bool ok = false;
-    DesktopCapturer* self_ptr = this;
-
-    [SCShareableContent getShareableContentWithCompletionHandler:
-        ^(SCShareableContent* content, NSError* error)
-    {
-        if (error || !content) {
-            self_ptr->m_last_error = error
-                ? [[error localizedDescription] UTF8String]
-                : "ScreenCaptureKit returned no shareable content";
-            dispatch_semaphore_signal(sem);
-            return;
-        }
-
-        SCContentFilter* filter = nil;
-        SCDisplay* display = nil;
-
-        if (self_ptr->m_options.capture_window && self_ptr->m_options.window_id) {
-            for (SCWindow* w in content.windows) {
-                if (w.windowID == self_ptr->m_options.window_id) {
-                    filter = [[SCContentFilter alloc]
-                        initWithDesktopIndependentWindow:w];
-                    break;
-                }
-            }
-            if (!filter) {
-                self_ptr->m_last_error = "Requested ScreenCaptureKit window was not found";
-                dispatch_semaphore_signal(sem);
-                return;
-            }
-        }
-        if (!filter) {
-            for (SCDisplay* d in content.displays) {
-                if (self_ptr->m_options.display_id == 0 ||
-                    d.displayID == self_ptr->m_options.display_id)
-                { display = d; break; }
-            }
-            if (!display) display = content.displays.firstObject;
-            if (!display) {
-                self_ptr->m_last_error = "ScreenCaptureKit returned no displays";
-                dispatch_semaphore_signal(sem);
-                return;
-            }
-            filter = [[SCContentFilter alloc]
-                initWithDisplay:display excludingWindows:@[]];
-        }
-
-        SCStreamConfiguration* cfg = [[SCStreamConfiguration alloc] init];
-        cfg.width                = self_ptr->m_options.width;
-        cfg.height               = self_ptr->m_options.height;
-        cfg.pixelFormat          = kCVPixelFormatType_32BGRA;
-        cfg.showsCursor          = YES;
-        cfg.minimumFrameInterval = CMTimeMake(1, (int32_t)self_ptr->m_options.fps);
-        cfg.capturesAudio        = self_ptr->m_options.system_audio ? YES : NO;
-        if (cfg.capturesAudio) {
-            cfg.sampleRate   = self_ptr->m_options.sample_rate;
-            cfg.channelCount = self_ptr->m_impl->channels;
-            cfg.excludesCurrentProcessAudio = self_ptr->m_options.exclude_app_audio;
-        }
-        cfg.queueDepth = 3;
-
-        SCKDelegate* del = [[SCKDelegate alloc] init];
-        del.capturer = self_ptr;
-
-        SCStream* stream = [[SCStream alloc]
-            initWithFilter:filter configuration:cfg delegate:nil];
-
-        NSError* ae = nil;
-        [stream addStreamOutput:del
-                           type:SCStreamOutputTypeScreen
-             sampleHandlerQueue:dispatch_get_global_queue(QOS_CLASS_USER_INTERACTIVE,0)
-                          error:&ae];
-        if (ae) {
-            self_ptr->m_last_error = [[ae localizedDescription] UTF8String];
-            dispatch_semaphore_signal(sem);
-            return;
-        }
-        if (cfg.capturesAudio)
-            [stream addStreamOutput:del
-                               type:SCStreamOutputTypeAudio
-                 sampleHandlerQueue:dispatch_get_global_queue(QOS_CLASS_USER_INTERACTIVE,0)
-                              error:&ae];
-        if (ae) {
-            self_ptr->m_last_error = [[ae localizedDescription] UTF8String];
-            dispatch_semaphore_signal(sem);
-            return;
-        }
-
-        self_ptr->m_stream   = (__bridge_retained void*)stream;
-        self_ptr->m_filter   = (__bridge_retained void*)filter;
-        self_ptr->m_config   = (__bridge_retained void*)cfg;
-        self_ptr->m_delegate = (__bridge_retained void*)del;
-
-        [stream startCaptureWithCompletionHandler:^(NSError* e) {
-            ok = (e == nil);
-            if (e) self_ptr->m_last_error = [[e localizedDescription] UTF8String];
-            dispatch_semaphore_signal(sem);
-        }];
-    }];
-
-    dispatch_semaphore_wait(sem, dispatch_time(DISPATCH_TIME_NOW, 5LL * NSEC_PER_SEC));
-
-    if (!ok) {
-        if (m_last_error.empty()) m_last_error = "Timed out or failed starting ScreenCaptureKit stream";
-        m_impl->started.store(false);
-        stop_mic_capture();
-        m_impl->pipeline.reset();
-        return false;
-    }
-
-    m_capturing = true;
-    return true;
-}
-
-bool DesktopCapturer::stopCapture() {
-    if (!m_capturing && !m_stream && !m_delegate && !m_config && !m_filter && !m_audio_engine && !m_camera_capturer) {
-        return true;
-    }
-    m_capturing = false;
-
-    stop_mic_capture();
-
-    if (m_camera_capturer) {
-        CameraCapturer* cam = static_cast<CameraCapturer*>(m_camera_capturer);
-        cam->stop();
-        delete cam;
-        m_camera_capturer = nullptr;
-    }
-
-    if (m_stream) {
-        SCStream* stream = (__bridge SCStream*)m_stream;
-        dispatch_semaphore_t sem = dispatch_semaphore_create(0);
-        [stream stopCaptureWithCompletionHandler:^(NSError*) {
-            dispatch_semaphore_signal(sem);
-        }];
-        dispatch_semaphore_wait(sem,
-            dispatch_time(DISPATCH_TIME_NOW, 5LL * NSEC_PER_SEC));
-    }
-
-    m_impl->started.store(false);
-
-    if (m_impl->pipeline) {
-        m_impl->pipeline->flush_and_shutdown();
-        m_impl->pipeline.reset();
-    }
-
-    if (m_delegate) {
-        id del = (__bridge_transfer id)m_delegate;
-        (void)del;
-        m_delegate = nullptr;
-    }
-    if (m_stream) {
-        id stream = (__bridge_transfer id)m_stream;
-        (void)stream;
-        m_stream = nullptr;
-    }
-    if (m_config) {
-        id config = (__bridge_transfer id)m_config;
-        (void)config;
-        m_config = nullptr;
-    }
-    if (m_filter) {
-        id filter = (__bridge_transfer id)m_filter;
-        (void)filter;
-        m_filter = nullptr;
-    }
-    m_delegate = nullptr;
-    m_stream = nullptr;
-    m_config = nullptr;
-    m_filter = nullptr;
-    return true;
-}
-
-bool DesktopCapturer::pauseCapture() {
-    m_impl->paused.store(true);
-    m_impl->pauseStartedVideoPtsSec = m_impl->last_video_pts_sec;
-    m_impl->reset_audio_sync();
-    std::cout << "[NativeCapture] Pause reset native audio timestamp buffers" << std::endl;
-    return true;
-}
-
-bool DesktopCapturer::resumeCapture() {
-    m_impl->paused.store(false);
-    m_impl->resumePending.store(true);
-    m_impl->audioGated = true;
-    m_impl->reset_audio_sync();
-    std::cout << "[NativeCapture] Resume pending; audio gated until next video PTS" << std::endl;
-    return true;
-}
-
-void DesktopCapturer::on_camera_sample(void* cm_ref) {
-    on_video_sample(cm_ref);
-}
-
-void DesktopCapturer::on_video_sample(void* cm_ref) {
-    if (!m_impl->started.load() || !m_impl->pipeline) return;
-
-    if (m_impl->paused.load()) return;
-
-    CMSampleBufferRef sb = static_cast<CMSampleBufferRef>(cm_ref);
-    if (!sb || !CMSampleBufferIsValid(sb)) return;
-
-    CVPixelBufferRef pb = CMSampleBufferGetImageBuffer(sb);
-    if (!pb) return;
-
-    CVPixelBufferLockBaseAddress(pb, kCVPixelBufferLock_ReadOnly);
-    const uint8_t* base   = static_cast<const uint8_t*>(CVPixelBufferGetBaseAddress(pb));
-    int            stride = static_cast<int>(CVPixelBufferGetBytesPerRow(pb));
-    const uint8_t* frame_base = base;
-    if (m_options.crop_enabled && !m_camera_capturer) {
-        frame_base = base +
-            (static_cast<size_t>(m_options.crop_y) * static_cast<size_t>(stride)) +
-            (static_cast<size_t>(m_options.crop_x) * 4u);
-    }
-
-    CMTime pts_cm  = CMSampleBufferGetPresentationTimeStamp(sb);
-    double pts_sec = CMTIME_IS_VALID(pts_cm) ? CMTimeGetSeconds(pts_cm) : -1.0;
-    if (m_camera_capturer) {
-        // AVCapture camera sample PTS can advance on a media clock that does
-        // not match elapsed recording time. Camera-only mic timestamps are
-        // host-time based, so drive camera video from host time too.
-        pts_sec = host_time_to_seconds(mach_absolute_time());
-    }
-    int64_t pts_ticks = -1;
-    bool is_keyframe_hint = false;
-
-    if (pts_sec >= 0.0) {
-        m_impl->last_video_pts_sec = pts_sec;
-
-        if (m_impl->resumePending.exchange(false)) {
-            if (m_impl->pauseStartedVideoPtsSec >= 0.0) {
-                m_impl->totalPausedVideoSec += (pts_sec - m_impl->pauseStartedVideoPtsSec);
-            }
-            m_impl->audioGated = false;
-            m_impl->reset_audio_sync();
-            is_keyframe_hint = true;
-            std::cout << "[NativeCapture] Resume aligned at videoPtsSec="
-                      << pts_sec
-                      << " totalPausedSec=" << m_impl->totalPausedVideoSec
-                      << std::endl;
-        }
-
-        if (m_impl->video_pts_origin_sec < 0.0) {
-            m_impl->video_pts_origin_sec = pts_sec;
-            std::cout << "[NativeCapture] Video timestamp origin sec="
-                      << m_impl->video_pts_origin_sec << std::endl;
-        }
-
-        const double relative_pts_sec = std::max(0.0, pts_sec - m_impl->video_pts_origin_sec - m_impl->totalPausedVideoSec);
-        pts_ticks = static_cast<int64_t>(std::llround(relative_pts_sec * m_options.fps));
-
-        if (pts_ticks <= m_impl->last_video_pts_tick) {
-            pts_ticks = m_impl->last_video_pts_tick + 1;
-        }
-        m_impl->last_video_pts_tick = pts_ticks;
-    }
-
-    m_impl->pipeline->push_video_frame(frame_base, stride, pts_ticks, is_keyframe_hint);
-
-    CVPixelBufferUnlockBaseAddress(pb, kCVPixelBufferLock_ReadOnly);
-}
-
-void DesktopCapturer::on_audio_sample(void* cm_ref) {
-    if (!m_impl->started.load() || !m_impl->pipeline) return;
-
-    if (m_impl->paused.load() || m_impl->audioGated) return;
-
-    CMSampleBufferRef sb = static_cast<CMSampleBufferRef>(cm_ref);
-    if (!sb || !CMSampleBufferIsValid(sb) || !CMSampleBufferDataIsReady(sb)) return;
-
-    if (m_impl->video_pts_origin_sec < 0.0) {
-        m_impl->dropped_audio_frames.fetch_add(
-            static_cast<uint64_t>(CMSampleBufferGetNumSamples(sb)));
-        return;
-    }
-
-    CMTime pts_cm = CMSampleBufferGetPresentationTimeStamp(sb);
-    if (!CMTIME_IS_VALID(pts_cm)) {
-        m_last_error = "System audio sample did not include a valid timestamp";
-        return;
-    }
-
-    const double pts_sec = CMTimeGetSeconds(pts_cm);
-    const double relative_pts_sec =
-        pts_sec - m_impl->video_pts_origin_sec - m_impl->totalPausedVideoSec;
-    if (relative_pts_sec < 0.0) {
-        m_impl->dropped_audio_frames.fetch_add(
-            static_cast<uint64_t>(CMSampleBufferGetNumSamples(sb)));
-        return;
-    }
-
-    const int64_t start_frame = static_cast<int64_t>(
-        std::llround(relative_pts_sec * static_cast<double>(m_impl->sample_rate)));
-
-    CMAudioFormatDescriptionRef fmtDesc =
-        CMSampleBufferGetFormatDescription(sb);
-    if (!fmtDesc) return;
-
-    const AudioStreamBasicDescription* asbd =
-        CMAudioFormatDescriptionGetStreamBasicDescription(fmtDesc);
-    if (!asbd) return;
-
-    const uint32_t in_ch  = static_cast<uint32_t>(asbd->mChannelsPerFrame);
-    const size_t   frames = static_cast<size_t>(CMSampleBufferGetNumSamples(sb));
-    if (!frames || !in_ch) return;
-
-    std::vector<float> pcm(frames * in_ch);
-    const bool non_il = (asbd->mFormatFlags & kAudioFormatFlagIsNonInterleaved) != 0;
-
-    if (non_il) {
-        std::vector<uint8_t> abl_storage(
-            sizeof(AudioBufferList) + sizeof(AudioBuffer) * (in_ch - 1));
-        AudioBufferList* abl =
-            reinterpret_cast<AudioBufferList*>(abl_storage.data());
-        abl->mNumberBuffers = in_ch;
-        std::vector<std::vector<float>> ch(in_ch, std::vector<float>(frames));
-        for (uint32_t c = 0; c < in_ch; ++c) {
-            abl->mBuffers[c].mNumberChannels = 1;
-            abl->mBuffers[c].mDataByteSize   =
-                static_cast<uint32_t>(frames * sizeof(float));
-            abl->mBuffers[c].mData = ch[c].data();
-        }
-        CMSampleBufferCopyPCMDataIntoAudioBufferList(
-            sb, 0, static_cast<int32_t>(frames), abl);
-        for (uint32_t c = 0; c < in_ch; ++c)
-            for (size_t f = 0; f < frames; ++f)
-                pcm[f * in_ch + c] = ch[c][f];
-    } else {
-        CMBlockBufferRef bb = CMSampleBufferGetDataBuffer(sb);
-        if (!bb) return;
-        size_t tot = CMBlockBufferGetDataLength(bb);
-        std::vector<uint8_t> raw(tot);
-        CMBlockBufferCopyDataBytes(bb, 0, tot, raw.data());
-        const float* src = reinterpret_cast<const float*>(raw.data());
-        std::copy(src, src + frames * in_ch, pcm.begin());
-    }
-
-    const uint32_t tgt_ch = m_impl->channels;
-    std::vector<float> sys_pcm(frames * tgt_ch);
-    if (in_ch == tgt_ch) {
-        sys_pcm = pcm;
-    } else {
-        for (size_t f = 0; f < frames; ++f)
-            for (uint32_t c = 0; c < tgt_ch; ++c)
-                sys_pcm[f * tgt_ch + c] = pcm[f * in_ch + (c % in_ch)];
-    }
-
-    std::vector<DesktopCapturer::Impl::MixedAudioChunk> chunks =
-        m_impl->append_system_and_collect_ready(
-            start_frame,
-            static_cast<uint32_t>(frames),
-            std::move(sys_pcm),
-            m_options.microphone);
-
-    for (const auto& chunk : chunks) {
-        std::vector<int16_t> s16(chunk.pcm.size());
-        for (size_t i = 0; i < chunk.pcm.size(); ++i) {
-            float v = chunk.pcm[i];
-            v = v > 1.f ? 1.f : (v < -1.f ? -1.f : v);
-            s16[i] = static_cast<int16_t>(v * 32767.f);
-        }
-
-        m_impl->pipeline->push_audio_s16(
-            s16.data(), static_cast<int>(chunk.frames), chunk.start_frame);
-    }
-}
-
-void DesktopCapturer::on_mic_pcm(const float* data, uint32_t frames,
-                                   uint32_t sr, uint32_t ch,
-                                   double host_time_sec)
-{
-    if (!m_impl->started.load() || !data || !frames || !ch) return;
-
-    if (m_impl->paused.load() || m_impl->audioGated) return;
-
-    if (m_impl->last_video_pts_tick < 0 || host_time_sec <= 0.0) {
-        m_impl->dropped_audio_frames.fetch_add(frames);
-        return;
-    }
-
-    const uint64_t callbacks = m_impl->mic_callbacks.fetch_add(1) + 1;
-    const uint64_t total_frames = m_impl->mic_frames.fetch_add(frames) + frames;
-    if (callbacks == 1 || callbacks == 50) {
-        std::cout << "[NativeCapture] Mic PCM received callbacks="
-                  << callbacks
-                  << " frames=" << total_frames
-                  << " sampleRate=" << sr
-                  << " channels=" << ch
-                  << " systemAudio=" << (m_options.system_audio ? "true" : "false")
-                  << std::endl;
-    }
-
-    const uint32_t target_rate = m_impl->sample_rate ? m_impl->sample_rate : 48000;
-    const uint32_t target_ch = m_impl->channels ? m_impl->channels : 2;
-    const uint32_t input_rate = sr ? sr : target_rate;
-    const uint32_t out_frames = std::max<uint32_t>(
-        1,
-        static_cast<uint32_t>(std::llround(
-            static_cast<double>(frames) * static_cast<double>(target_rate) /
-            static_cast<double>(input_rate))));
-
-    std::vector<float> normalized(out_frames * target_ch);
-    const double src_step = static_cast<double>(input_rate) /
-                            static_cast<double>(target_rate);
-
-    for (uint32_t f = 0; f < out_frames; ++f) {
-        const double src_pos = static_cast<double>(f) * src_step;
-        const uint32_t i0 = std::min<uint32_t>(
-            static_cast<uint32_t>(std::floor(src_pos)), frames - 1);
-        const uint32_t i1 = std::min<uint32_t>(i0 + 1, frames - 1);
-        const float frac = static_cast<float>(src_pos - static_cast<double>(i0));
-
-        for (uint32_t c = 0; c < target_ch; ++c) {
-            const uint32_t src_c = ch == 1 ? 0 : std::min<uint32_t>(c, ch - 1);
-            const float a = data[(i0 * ch) + src_c];
-            const float b = data[(i1 * ch) + src_c];
-            normalized[(f * target_ch) + c] = a + ((b - a) * frac);
-        }
-    }
-
-    if (m_impl->mic_host_origin_sec < 0.0) {
-        const double current_recording_sec =
-            static_cast<double>(m_impl->last_video_pts_tick) /
-            static_cast<double>(m_options.fps ? m_options.fps : 30);
-        m_impl->mic_host_origin_sec = host_time_sec - current_recording_sec;
-        std::cout << "[NativeCapture] Mic timestamp origin hostSec="
-                  << m_impl->mic_host_origin_sec
-                  << " currentRecordingSec=" << current_recording_sec
-                  << std::endl;
-    }
-
-    const double relative_sec = host_time_sec - m_impl->mic_host_origin_sec;
-    int64_t start_frame = static_cast<int64_t>(
-        std::llround(relative_sec * static_cast<double>(target_rate)));
-    uint32_t frames_to_use = out_frames;
-    size_t sample_offset = 0;
-
-    if (start_frame < 0) {
-        const int64_t trim = -start_frame;
-        if (trim >= static_cast<int64_t>(frames_to_use)) {
-            m_impl->dropped_audio_frames.fetch_add(frames);
-            return;
-        }
-        sample_offset = static_cast<size_t>(trim) * target_ch;
-        frames_to_use -= static_cast<uint32_t>(trim);
-        start_frame = 0;
-    }
-
-    std::vector<float> aligned(
-        normalized.begin() + static_cast<ptrdiff_t>(sample_offset),
-        normalized.end());
-
-    if (!m_options.system_audio) {
-        std::vector<int16_t> s16(static_cast<size_t>(frames_to_use) * target_ch);
-        for (size_t i = 0; i < s16.size(); ++i) {
-            float v = soft_limit(aligned[i] * kNativeMicGain);
-            v = v > 1.f ? 1.f : (v < -1.f ? -1.f : v);
-            s16[i] = static_cast<int16_t>(v * 32767.f);
-        }
-        if (m_impl->pipeline) {
-            m_impl->pipeline->push_audio_s16(
-                s16.data(), static_cast<int>(frames_to_use), start_frame);
-        }
-        return;
-    }
-
-    std::vector<DesktopCapturer::Impl::MixedAudioChunk> chunks =
-        m_impl->append_mic_and_collect_ready(start_frame, frames_to_use, std::move(aligned));
-
-    for (const auto& chunk : chunks) {
-        std::vector<int16_t> s16(chunk.pcm.size());
-        for (size_t i = 0; i < chunk.pcm.size(); ++i) {
-            float v = chunk.pcm[i];
-            v = v > 1.f ? 1.f : (v < -1.f ? -1.f : v);
-            s16[i] = static_cast<int16_t>(v * 32767.f);
-        }
-
-        if (m_impl->pipeline) {
-            m_impl->pipeline->push_audio_s16(
-                s16.data(), static_cast<int>(chunk.frames), chunk.start_frame);
-        }
-    }
-}
-
-bool DesktopCapturer::setup_mic_capture() {
-    DesktopCapturer* self = this;
-
-    AVAudioEngine* engine = [[AVAudioEngine alloc] init];
-    AVAudioInputNode* node = engine.inputNode;
-
-    if (!m_options.mic_device_uid.empty()) {
-        AudioDeviceID mic_device = kAudioObjectUnknown;
-        if (!find_audio_device_by_uid(m_options.mic_device_uid, &mic_device)) {
-            m_last_error = "Selected native microphone was not found";
-            return false;
-        }
-
-        AudioDeviceID default_device = kAudioObjectUnknown;
-        const bool is_default_device =
-            get_default_input_device(&default_device) && default_device == mic_device;
-
-        if (!is_default_device) {
-            AudioUnit input_unit = node.audioUnit;
-            OSStatus status = AudioUnitSetProperty(
-                input_unit,
-                kAudioOutputUnitProperty_CurrentDevice,
-                kAudioUnitScope_Global,
-                0,
-                &mic_device,
-                sizeof(mic_device));
-            if (status != noErr) {
-                m_last_error = "Failed to select native microphone device";
-                return false;
-            }
-        }
-
-        std::cout << "[NativeCapture] Selected native microphone uid="
-                  << m_options.mic_device_uid
-                  << " audioDeviceId=" << mic_device
-                  << " default=" << (is_default_device ? "true" : "false")
-                  << std::endl;
-    }
-
-    AVAudioFormat* fmt = [node inputFormatForBus:0];
-    std::cout << "[NativeCapture] Starting native microphone tap sampleRate="
-              << (uint32_t)fmt.sampleRate
-              << " channels=" << (uint32_t)fmt.channelCount
-              << std::endl;
-
-    @try {
-        [node installTapOnBus:0
-                   bufferSize:512
-                       format:nil
-                        block:^(AVAudioPCMBuffer* buf, AVAudioTime* when)
-        {
-            if (!buf.floatChannelData) return;
-            uint32_t nf = buf.frameLength;
-            uint32_t nc = (uint32_t)buf.format.channelCount;
-            std::vector<float> il(nf * nc);
-            for (uint32_t c = 0; c < nc; ++c) {
-                const float* src = buf.floatChannelData[c];
-                for (uint32_t f = 0; f < nf; ++f)
-                    il[f * nc + c] = src[f];
-            }
-            const double host_time_sec = host_time_to_seconds([when hostTime]);
-            self->on_mic_pcm(il.data(), nf,
-                (uint32_t)buf.format.sampleRate, nc, host_time_sec);
-        }];
-    } @catch (NSException* ex) {
-        m_last_error = std::string("Failed to install native microphone tap: ") +
-            [[ex reason] UTF8String];
-        return false;
-    }
-
-    NSError* err = nil;
-    [engine startAndReturnError:&err];
-    if (err) {
-        m_last_error = [[err localizedDescription] UTF8String];
-        [node removeTapOnBus:0];
-        return false;
-    }
-
-    m_audio_engine = (__bridge_retained void*)engine;
-    std::cout << "[NativeCapture] Native microphone engine started" << std::endl;
-    return true;
-}
-
-void DesktopCapturer::stop_mic_capture() {
-    if (!m_audio_engine) return;
-    AVAudioEngine* engine = (__bridge_transfer AVAudioEngine*)m_audio_engine;
-    [engine.inputNode removeTapOnBus:0];
-    [engine stop];
-    m_audio_engine = nullptr;
-}