575 lines
18 KiB
Plaintext
575 lines
18 KiB
Plaintext
#import "ScreenHandler.h"
|
|
#import "H264Encoder.h"
|
|
#import "InputHandler.h"
|
|
#import "../client/IOCPClient.h"
|
|
#import "../common/commands.h"
|
|
#import "Permissions.h"
|
|
#import <Cocoa/Cocoa.h>
|
|
#import <CoreGraphics/CoreGraphics.h>
|
|
#import <mach/mach_time.h>
|
|
|
|
// Global client ID (calculated in main.mm)
|
|
extern uint64_t g_myClientID;
|
|
|
|
ScreenHandler::ScreenHandler(IOCPClient* client)
|
|
: m_client(client)
|
|
, m_clientID(0)
|
|
, m_running(false)
|
|
, m_width(0)
|
|
, m_height(0)
|
|
, m_logicalWidth(0)
|
|
, m_logicalHeight(0)
|
|
, m_scaleFactor(1.0)
|
|
, m_displayID(CGMainDisplayID())
|
|
, m_algorithm(ALGORITHM_H264)
|
|
, m_maxFPS(15)
|
|
, m_qualityLevel(QUALITY_GOOD) // Use fixed QUALITY_GOOD (H264) for web compatibility
|
|
, m_h264Bitrate(2000000) // 2 Mbps default
|
|
{
|
|
memset(&m_bmpHeader, 0, sizeof(m_bmpHeader));
|
|
|
|
// Initialize input handler for mouse/keyboard control
|
|
m_inputHandler = std::make_unique<InputHandler>();
|
|
if (m_inputHandler->init()) {
|
|
NSLog(@"InputHandler initialized with accessibility permission");
|
|
} else {
|
|
NSLog(@"InputHandler: waiting for accessibility permission");
|
|
}
|
|
}
|
|
|
|
ScreenHandler::~ScreenHandler()
|
|
{
|
|
stop();
|
|
}
|
|
|
|
bool ScreenHandler::init()
|
|
{
|
|
// Check permissions
|
|
if (!Permissions::checkScreenCapture()) {
|
|
NSLog(@"Screen capture permission not granted");
|
|
return false;
|
|
}
|
|
|
|
// Get main display info
|
|
m_displayID = CGMainDisplayID();
|
|
|
|
// Get physical pixel dimensions (what we capture and send)
|
|
CGDisplayModeRef mode = CGDisplayCopyDisplayMode(m_displayID);
|
|
if (mode) {
|
|
m_width = (int)CGDisplayModeGetPixelWidth(mode);
|
|
m_height = (int)CGDisplayModeGetPixelHeight(mode);
|
|
CGDisplayModeRelease(mode);
|
|
} else {
|
|
m_width = (int)CGDisplayPixelsWide(m_displayID);
|
|
m_height = (int)CGDisplayPixelsHigh(m_displayID);
|
|
}
|
|
|
|
// Get logical point dimensions (what CGEvent uses)
|
|
// NSScreen provides logical dimensions
|
|
NSScreen* mainScreen = [NSScreen mainScreen];
|
|
if (mainScreen) {
|
|
NSRect frame = [mainScreen frame];
|
|
m_logicalWidth = (int)frame.size.width;
|
|
m_logicalHeight = (int)frame.size.height;
|
|
} else {
|
|
// Fallback: use physical dimensions
|
|
m_logicalWidth = m_width;
|
|
m_logicalHeight = m_height;
|
|
}
|
|
|
|
// Calculate scale factor (Retina displays have factor > 1.0)
|
|
m_scaleFactor = (double)m_width / (double)m_logicalWidth;
|
|
|
|
NSLog(@"Screen dimensions: physical=%dx%d, logical=%dx%d, scale=%.2f",
|
|
m_width, m_height, m_logicalWidth, m_logicalHeight, m_scaleFactor);
|
|
|
|
if (m_width <= 0 || m_height <= 0) {
|
|
NSLog(@"Invalid screen dimensions: %dx%d", m_width, m_height);
|
|
return false;
|
|
}
|
|
|
|
// Initialize BITMAPINFOHEADER
|
|
m_bmpHeader.biSize = sizeof(BITMAPINFOHEADER_MAC);
|
|
m_bmpHeader.biWidth = m_width;
|
|
m_bmpHeader.biHeight = m_height;
|
|
m_bmpHeader.biPlanes = 1;
|
|
m_bmpHeader.biBitCount = 32;
|
|
m_bmpHeader.biCompression = 0; // BI_RGB
|
|
m_bmpHeader.biSizeImage = m_width * m_height * 4;
|
|
|
|
// Allocate frame buffers
|
|
m_prevFrame.resize(m_bmpHeader.biSizeImage, 0);
|
|
m_currFrame.resize(m_bmpHeader.biSizeImage, 0);
|
|
m_diffBuffer.resize(1 + 1 + 8 + 1 + m_bmpHeader.biSizeImage * 2);
|
|
|
|
NSLog(@"ScreenHandler initialized: %dx%d", m_width, m_height);
|
|
return true;
|
|
}
|
|
|
|
void ScreenHandler::start(IOCPClient* client, uint64_t clientID)
|
|
{
|
|
if (m_running) return;
|
|
|
|
m_client = client;
|
|
m_clientID = clientID;
|
|
m_running = true;
|
|
|
|
m_captureThread = std::thread(&ScreenHandler::captureLoop, this);
|
|
}
|
|
|
|
void ScreenHandler::stop()
|
|
{
|
|
m_running = false;
|
|
if (m_captureThread.joinable()) {
|
|
m_captureThread.join();
|
|
}
|
|
|
|
// Close H264 encoder if open
|
|
if (m_h264Encoder) {
|
|
m_h264Encoder->close();
|
|
m_h264Encoder.reset();
|
|
}
|
|
}
|
|
|
|
void ScreenHandler::sendBitmapInfo()
|
|
{
|
|
if (!m_client) return;
|
|
|
|
// Build packet: [TOKEN_BITMAPINFO][BITMAPINFOHEADER][clientID][reserved][ScreenSettings]
|
|
// ScreenSettings defined in commands.h (100 bytes), QualityLevel at offset 32
|
|
|
|
const uint32_t len = 1 + sizeof(BITMAPINFOHEADER_MAC) + 2 * sizeof(uint64_t) + sizeof(ScreenSettings);
|
|
std::vector<uint8_t> buf(len, 0);
|
|
|
|
buf[0] = TOKEN_BITMAPINFO;
|
|
memcpy(&buf[1], &m_bmpHeader, sizeof(BITMAPINFOHEADER_MAC));
|
|
uint64_t clientID = g_myClientID;
|
|
memcpy(&buf[1 + sizeof(BITMAPINFOHEADER_MAC)], &clientID, sizeof(uint64_t));
|
|
|
|
ScreenSettings settings = {};
|
|
settings.MaxFPS = m_maxFPS.load();
|
|
settings.QualityLevel = m_qualityLevel; // Fixed quality level (e.g., QUALITY_GOOD = 2)
|
|
memcpy(&buf[1 + sizeof(BITMAPINFOHEADER_MAC) + 2 * sizeof(uint64_t)], &settings, sizeof(ScreenSettings));
|
|
|
|
m_client->Send2Server((char*)buf.data(), len);
|
|
NSLog(@"SendBitmapInfo: clientID=%llu, QualityLevel=%d, SettingsSize=%zu",
|
|
clientID, m_qualityLevel, sizeof(ScreenSettings));
|
|
}
|
|
|
|
void ScreenHandler::OnReceive(uint8_t* data, ULONG size)
|
|
{
|
|
if (!size) return;
|
|
|
|
switch (data[0]) {
|
|
case COMMAND_NEXT:
|
|
// Server ready, handled externally
|
|
NSLog(@"Received COMMAND_NEXT from server");
|
|
if (!m_running) {
|
|
start(m_client, g_myClientID);
|
|
}
|
|
break;
|
|
|
|
case COMMAND_SCREEN_CONTROL:
|
|
// Handle mouse/keyboard control commands
|
|
// Protocol: [COMMAND_SCREEN_CONTROL:1][MSG64:48]
|
|
if (size >= 1 + sizeof(MSG64_MAC) && m_inputHandler) {
|
|
MSG64_MAC msg;
|
|
memcpy(&msg, data + 1, sizeof(MSG64_MAC));
|
|
|
|
// Convert physical pixel coordinates to logical point coordinates
|
|
// Server sends coordinates in physical pixels (matching our captured screen)
|
|
// CGEvent expects logical points (for Retina displays, physical/scale)
|
|
if (m_scaleFactor > 1.0) {
|
|
// Extract coordinates from lParam (MAKELPARAM format: low=x, high=y)
|
|
int x = (int)(msg.lParam & 0xFFFF);
|
|
int y = (int)((msg.lParam >> 16) & 0xFFFF);
|
|
|
|
// Scale down to logical coordinates
|
|
x = (int)(x / m_scaleFactor);
|
|
y = (int)(y / m_scaleFactor);
|
|
|
|
// Update lParam with scaled coordinates
|
|
msg.lParam = (uint64_t)x | ((uint64_t)y << 16);
|
|
msg.pt_x = x;
|
|
msg.pt_y = y;
|
|
}
|
|
|
|
m_inputHandler->handleInputEvent(&msg);
|
|
}
|
|
break;
|
|
|
|
case CMD_QUALITY_LEVEL:
|
|
if (size >= 2) {
|
|
int8_t level = (int8_t)data[1];
|
|
bool persist = (size >= 3) ? data[2] : false;
|
|
applyQualityLevel(level, persist);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void ScreenHandler::applyQualityLevel(int8_t level, bool persist)
|
|
{
|
|
m_qualityLevel = level;
|
|
|
|
if (level == QUALITY_DISABLED) {
|
|
NSLog(@"Quality: Disabled");
|
|
return;
|
|
}
|
|
|
|
// Quality profiles: [FPS, Algorithm]
|
|
// H264 provides best compression for remote desktop
|
|
// Note: macOS uses slightly higher FPS than Windows for smoother experience
|
|
static const int profiles[QUALITY_COUNT][2] = {
|
|
{5, ALGORITHM_GRAY}, // Level 0: Emergency (very low bandwidth)
|
|
{10, ALGORITHM_RGB565}, // Level 1: Low
|
|
{15, ALGORITHM_H264}, // Level 2: Medium (office work default)
|
|
{20, ALGORITHM_H264}, // Level 3: Good
|
|
{25, ALGORITHM_H264}, // Level 4: High
|
|
{30, ALGORITHM_H264}, // Level 5: Smooth
|
|
};
|
|
|
|
if (level >= 0 && level < QUALITY_COUNT) {
|
|
m_maxFPS.store(profiles[level][0]);
|
|
m_algorithm.store(profiles[level][1]);
|
|
NSLog(@"Quality: Level=%d, FPS=%d, Algo=%d", level, profiles[level][0], profiles[level][1]);
|
|
} else {
|
|
NSLog(@"Quality: Adaptive mode");
|
|
}
|
|
}
|
|
|
|
bool ScreenHandler::captureScreen(std::vector<uint8_t>& buffer)
|
|
{
|
|
// Create image from display
|
|
CGImageRef image = CGDisplayCreateImage(m_displayID);
|
|
if (!image) {
|
|
NSLog(@"Failed to capture screen image");
|
|
return false;
|
|
}
|
|
|
|
size_t width = CGImageGetWidth(image);
|
|
size_t height = CGImageGetHeight(image);
|
|
|
|
if (width != (size_t)m_width || height != (size_t)m_height) {
|
|
// Screen resolution changed, need to reinitialize
|
|
CGImageRelease(image);
|
|
NSLog(@"Screen resolution changed: %zux%zu", width, height);
|
|
return false;
|
|
}
|
|
|
|
// Create bitmap context to get raw pixel data
|
|
CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
|
|
size_t bytesPerRow = width * 4;
|
|
|
|
// Temporary buffer for top-down BGRA
|
|
std::vector<uint8_t> tempBuffer(bytesPerRow * height);
|
|
|
|
CGContextRef context = CGBitmapContextCreate(
|
|
tempBuffer.data(),
|
|
width,
|
|
height,
|
|
8,
|
|
bytesPerRow,
|
|
colorSpace,
|
|
kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Little // BGRA
|
|
);
|
|
|
|
CGColorSpaceRelease(colorSpace);
|
|
|
|
if (!context) {
|
|
CGImageRelease(image);
|
|
NSLog(@"Failed to create bitmap context");
|
|
return false;
|
|
}
|
|
|
|
// Draw image into context
|
|
CGContextDrawImage(context, CGRectMake(0, 0, width, height), image);
|
|
CGContextRelease(context);
|
|
CGImageRelease(image);
|
|
|
|
// Flip vertically (BMP is bottom-up, CGImage is top-down)
|
|
for (size_t y = 0; y < height; y++) {
|
|
size_t srcRow = y;
|
|
size_t dstRow = height - 1 - y;
|
|
memcpy(buffer.data() + dstRow * bytesPerRow,
|
|
tempBuffer.data() + srcRow * bytesPerRow,
|
|
bytesPerRow);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void ScreenHandler::sendFirstScreen()
|
|
{
|
|
if (!captureScreen(m_currFrame)) return;
|
|
if (!m_client) return;
|
|
|
|
uint32_t imgSize = m_bmpHeader.biSizeImage;
|
|
std::vector<uint8_t> buf(1 + imgSize);
|
|
buf[0] = TOKEN_FIRSTSCREEN;
|
|
memcpy(&buf[1], m_currFrame.data(), imgSize);
|
|
|
|
m_client->Send2Server((char*)buf.data(), buf.size());
|
|
|
|
// Save as previous frame
|
|
m_prevFrame = m_currFrame;
|
|
}
|
|
|
|
void ScreenHandler::sendDiffFrame()
|
|
{
|
|
if (!captureScreen(m_currFrame)) return;
|
|
if (!m_client) return;
|
|
|
|
uint8_t* out = m_diffBuffer.data();
|
|
out[0] = TOKEN_NEXTSCREEN;
|
|
uint8_t* data = out + 1;
|
|
|
|
// Write algorithm type
|
|
uint8_t algo = m_algorithm.load();
|
|
memcpy(data, &algo, sizeof(uint8_t));
|
|
|
|
// Write cursor position (simple 0 for now)
|
|
int32_t cursorX = 0, cursorY = 0;
|
|
memcpy(data + 1, &cursorX, sizeof(int32_t));
|
|
memcpy(data + 1 + sizeof(int32_t), &cursorY, sizeof(int32_t));
|
|
|
|
// Write cursor type
|
|
uint8_t cursorType = 0;
|
|
memcpy(data + 1 + 2 * sizeof(int32_t), &cursorType, sizeof(uint8_t));
|
|
|
|
uint32_t headerSize = 1 + 2 * sizeof(int32_t) + 1;
|
|
uint8_t* diffData = data + headerSize;
|
|
uint32_t diffLen = compareBitmap(m_currFrame.data(), m_prevFrame.data(),
|
|
diffData, m_bmpHeader.biSizeImage, algo);
|
|
|
|
uint32_t totalLen = 1 + headerSize + diffLen;
|
|
m_client->Send2Server((char*)out, totalLen);
|
|
|
|
// Update previous frame
|
|
std::swap(m_prevFrame, m_currFrame);
|
|
}
|
|
|
|
void ScreenHandler::sendH264Frame(bool keyframe)
|
|
{
|
|
if (!captureScreen(m_currFrame)) return;
|
|
if (!m_client) return;
|
|
|
|
// Initialize encoder if needed
|
|
if (!m_h264Encoder) {
|
|
m_h264Encoder = std::make_unique<H264Encoder>();
|
|
int fps = m_maxFPS.load();
|
|
if (fps <= 0) fps = 30;
|
|
if (!m_h264Encoder->open(m_width, m_height, fps, m_h264Bitrate)) {
|
|
NSLog(@"Failed to initialize H264 encoder: %s", m_h264Encoder->getLastError());
|
|
m_h264Encoder.reset();
|
|
return;
|
|
}
|
|
NSLog(@"H264 encoder initialized: %dx%d @ %d fps", m_width, m_height, fps);
|
|
}
|
|
|
|
// Force keyframe if requested
|
|
if (keyframe) {
|
|
m_h264Encoder->forceKeyframe();
|
|
}
|
|
|
|
// Encode frame
|
|
uint8_t* encodedData = nullptr;
|
|
uint32_t encodedSize = 0;
|
|
uint32_t stride = m_width * 4;
|
|
|
|
int result = m_h264Encoder->encode(
|
|
m_currFrame.data(),
|
|
32, // bpp
|
|
stride,
|
|
m_width,
|
|
m_height,
|
|
&encodedData,
|
|
&encodedSize,
|
|
false // Don't flip - keep bottom-up format like Windows client
|
|
);
|
|
|
|
if (result <= 0 || !encodedData || encodedSize == 0) {
|
|
return;
|
|
}
|
|
|
|
// Build packet: [TOKEN_NEXTSCREEN][ALGORITHM_H264][CursorX][CursorY][CursorType][H264Data]
|
|
// Note: H264 always uses TOKEN_NEXTSCREEN because:
|
|
// - Server's TOKEN_KEYFRAME handler does nothing for H264 (just break)
|
|
// - Server's TOKEN_NEXTSCREEN handler calls Decode() for H264
|
|
// - H264 encoder manages keyframes (I-frames) internally
|
|
// - FFmpeg decoder auto-detects I-frames vs P-frames
|
|
uint32_t headerSize = 1 + 1 + 2 * sizeof(int32_t) + 1;
|
|
std::vector<uint8_t> packet(headerSize + encodedSize);
|
|
|
|
packet[0] = TOKEN_NEXTSCREEN;
|
|
packet[1] = ALGORITHM_H264;
|
|
|
|
// Cursor position (0 for now)
|
|
int32_t cursorX = 0, cursorY = 0;
|
|
memcpy(&packet[2], &cursorX, sizeof(int32_t));
|
|
memcpy(&packet[2 + sizeof(int32_t)], &cursorY, sizeof(int32_t));
|
|
|
|
// Cursor type
|
|
packet[2 + 2 * sizeof(int32_t)] = 0;
|
|
|
|
// H264 data
|
|
memcpy(&packet[headerSize], encodedData, encodedSize);
|
|
|
|
m_client->Send2Server((char*)packet.data(), packet.size());
|
|
}
|
|
|
|
uint32_t ScreenHandler::compareBitmap(const uint8_t* curr, const uint8_t* prev,
|
|
uint8_t* outBuf, uint32_t totalBytes, uint8_t algo)
|
|
{
|
|
const uint32_t bytesPerPixel = 4;
|
|
const uint32_t totalPixels = totalBytes / bytesPerPixel;
|
|
const uint32_t gapThreshold = 8;
|
|
const uint32_t ratio = (algo == ALGORITHM_GRAY || algo == ALGORITHM_RGB565) ? 4 : 1;
|
|
|
|
uint32_t outOffset = 0;
|
|
uint32_t i = 0;
|
|
|
|
while (i < totalPixels) {
|
|
// Skip identical pixels
|
|
while (i < totalPixels &&
|
|
*(uint32_t*)(curr + i * 4) == *(uint32_t*)(prev + i * 4)) {
|
|
i++;
|
|
}
|
|
if (i >= totalPixels) break;
|
|
|
|
uint32_t start = i;
|
|
uint32_t lastDiff = i;
|
|
|
|
while (i < totalPixels) {
|
|
if (*(uint32_t*)(curr + i * 4) != *(uint32_t*)(prev + i * 4)) {
|
|
lastDiff = i;
|
|
} else if (i - lastDiff > gapThreshold) {
|
|
break;
|
|
}
|
|
i++;
|
|
}
|
|
|
|
uint32_t end = lastDiff + 1;
|
|
uint32_t count = end - start;
|
|
uint32_t byteOffset = start * bytesPerPixel;
|
|
uint32_t byteCount = count * bytesPerPixel;
|
|
|
|
// Write byteOffset
|
|
memcpy(outBuf + outOffset, &byteOffset, sizeof(uint32_t));
|
|
outOffset += sizeof(uint32_t);
|
|
|
|
// Write length
|
|
uint32_t lengthField = byteCount / ratio;
|
|
memcpy(outBuf + outOffset, &lengthField, sizeof(uint32_t));
|
|
outOffset += sizeof(uint32_t);
|
|
|
|
// Write pixel data
|
|
const uint8_t* srcData = curr + byteOffset;
|
|
if (algo == ALGORITHM_RGB565) {
|
|
convertBGRAtoRGB565(srcData, (uint16_t*)(outBuf + outOffset), count);
|
|
outOffset += count * 2;
|
|
} else if (algo == ALGORITHM_GRAY) {
|
|
convertBGRAtoGray(srcData, outBuf + outOffset, count);
|
|
outOffset += count;
|
|
} else {
|
|
memcpy(outBuf + outOffset, srcData, byteCount);
|
|
outOffset += byteCount;
|
|
}
|
|
}
|
|
|
|
return outOffset;
|
|
}
|
|
|
|
void ScreenHandler::convertBGRAtoGray(const uint8_t* src, uint8_t* dst, uint32_t pixelCount)
|
|
{
|
|
for (uint32_t i = 0; i < pixelCount; i++) {
|
|
uint8_t b = src[i * 4 + 0];
|
|
uint8_t g = src[i * 4 + 1];
|
|
uint8_t r = src[i * 4 + 2];
|
|
dst[i] = (uint8_t)((306 * r + 601 * g + 117 * b) >> 10);
|
|
}
|
|
}
|
|
|
|
void ScreenHandler::convertBGRAtoRGB565(const uint8_t* src, uint16_t* dst, uint32_t pixelCount)
|
|
{
|
|
for (uint32_t i = 0; i < pixelCount; i++) {
|
|
uint8_t b = src[i * 4 + 0];
|
|
uint8_t g = src[i * 4 + 1];
|
|
uint8_t r = src[i * 4 + 2];
|
|
uint16_t r5 = (r >> 3) & 0x1F;
|
|
uint16_t g6 = (g >> 2) & 0x3F;
|
|
uint16_t b5 = (b >> 3) & 0x1F;
|
|
dst[i] = (r5 << 11) | (g6 << 5) | b5;
|
|
}
|
|
}
|
|
|
|
uint64_t ScreenHandler::getTickMs()
|
|
{
|
|
static mach_timebase_info_data_t timebase = {0, 0};
|
|
if (timebase.denom == 0) {
|
|
mach_timebase_info(&timebase);
|
|
}
|
|
uint64_t now = mach_absolute_time();
|
|
return (now * timebase.numer / timebase.denom) / 1000000;
|
|
}
|
|
|
|
void ScreenHandler::captureLoop()
|
|
{
|
|
NSLog(@"ScreenHandler CaptureLoop started (%dx%d)", m_width, m_height);
|
|
|
|
uint8_t currentAlgo = m_algorithm.load();
|
|
|
|
// Always send raw first frame (TOKEN_FIRSTSCREEN) to initialize server display
|
|
// This matches Windows client behavior: first frame is always raw bitmap,
|
|
// even in H264 mode. Server needs TOKEN_FIRSTSCREEN to set m_bIsFirst = FALSE.
|
|
sendFirstScreen();
|
|
|
|
// Small delay to ensure first frame is processed before H264 stream starts
|
|
usleep(50000); // 50ms, same as Windows client
|
|
|
|
while (m_running) {
|
|
uint64_t start = getTickMs();
|
|
|
|
uint8_t algo = m_algorithm.load();
|
|
|
|
// Check if algorithm changed
|
|
if (algo != currentAlgo) {
|
|
NSLog(@"Algorithm changed: %d -> %d", currentAlgo, algo);
|
|
currentAlgo = algo;
|
|
|
|
// If switching to/from H264, reset encoder
|
|
if (algo == ALGORITHM_H264) {
|
|
// Starting H264 - will be initialized in sendH264Frame
|
|
sendH264Frame(true); // First H264 frame is keyframe
|
|
} else if (m_h264Encoder) {
|
|
// Switching away from H264 - close encoder
|
|
m_h264Encoder->close();
|
|
m_h264Encoder.reset();
|
|
sendFirstScreen(); // Send full frame for DIFF modes
|
|
}
|
|
} else {
|
|
// Normal frame
|
|
if (algo == ALGORITHM_H264) {
|
|
sendH264Frame(false);
|
|
} else {
|
|
sendDiffFrame();
|
|
}
|
|
}
|
|
|
|
int fps = m_maxFPS.load();
|
|
if (fps <= 0) fps = 10;
|
|
int sleepMs = 1000 / fps;
|
|
|
|
int elapsed = (int)(getTickMs() - start);
|
|
int wait = sleepMs - elapsed;
|
|
if (wait > 0) {
|
|
usleep(wait * 1000);
|
|
}
|
|
}
|
|
|
|
NSLog(@"ScreenHandler CaptureLoop stopped");
|
|
}
|