@0biwank/screen-capture 2.0.1 → 2.0.2

package/scripts/build-ffmpeg-vendor.mjs

@@ -1,178 +0,0 @@
-import {existsSync, mkdirSync, readFileSync, rmSync, writeFileSync, copyFileSync} from 'fs';
-import {fileURLToPath} from 'url';
-import {join, resolve} from 'path';
-import {spawnSync} from 'child_process';
-import os from 'os';
-import {createHash} from 'crypto';
-
-const FFMPEG_VERSION = '8.1';
-const FFMPEG_SHA256 = 'b072aed6871998cce9b36e7774033105ca29e33632be5b6347f3206898e0756a';
-const X264_REF = 'b35605ace3ddf7c1a5d67a2eb553f034aef41d55';
-const X264_SHA256 = '6eeb82934e69fd51e043bd8c5b0d152839638d1ce7aa4eea65a3fedcf83ff224';
-const MACOS_DEPLOYMENT_TARGET = '14.0';
-
-const packageRoot = resolve(fileURLToPath(new URL('..', import.meta.url)));
-const requestedArch =
-  process.env.NATIVE_CAPTURE_ARCH ||
-  process.env.TARGET_ARCH ||
-  process.env.npm_config_arch ||
-  process.arch;
-const targetArch = requestedArch === 'x86_64' ? 'x64' : requestedArch;
-const vendorRoot = resolve(packageRoot, 'vendor', 'ffmpeg');
-const vendorDir = join(vendorRoot, `darwin-${targetArch}`);
-const workRoot = join(os.tmpdir(), `freeboom-native-ffmpeg-${targetArch}`);
-const ffmpegArchive = join(workRoot, `ffmpeg-${FFMPEG_VERSION}.tar.xz`);
-const x264Archive = join(workRoot, `x264-${X264_REF}.tar.bz2`);
-const ffmpegSrc = join(workRoot, 'ffmpeg-src');
-const x264Src = join(workRoot, 'x264-src');
-const x264Install = join(workRoot, 'x264-install');
-
-function run(command, args, options = {}) {
-  console.log(`[NativeVendor] ${command} ${args.join(' ')}`);
-  const result = spawnSync(command, args, {
-    stdio: 'inherit',
-    shell: process.platform === 'win32',
-    ...options,
-    env: {
-      ...process.env,
-      MACOSX_DEPLOYMENT_TARGET: MACOS_DEPLOYMENT_TARGET,
-      ...options.env,
-    },
-  });
-
-  if (result.status !== 0) {
-    process.exit(result.status ?? 1);
-  }
-}
-
-function sha256(file) {
-  return createHash('sha256').update(readFileSync(file)).digest('hex');
-}
-
-function download(url, output, expectedSha256) {
-  if (existsSync(output) && sha256(output) === expectedSha256) {
-    console.log(`[NativeVendor] Reusing ${output}`);
-    return;
-  }
-
-  rmSync(output, {force: true});
-  run('curl', ['-fL', '--retry', '3', '--retry-delay', '2', url, '-o', output]);
-  const actualSha256 = sha256(output);
-  if (actualSha256 !== expectedSha256) {
-    rmSync(output, {force: true});
-    throw new Error(
-      `[NativeVendor] SHA-256 mismatch for ${url}: expected ${expectedSha256}, received ${actualSha256}`,
-    );
-  }
-}
-
-function patchFfmpegHlsMuxer() {
-  const hlsencPath = join(ffmpegSrc, 'libavformat', 'hlsenc.c');
-  const source = readFileSync(hlsencPath, 'utf8');
-  const needle = `        if (hls->segment_type == SEGMENT_TYPE_FMP4) {
-            EXTERN const FFOutputFormat ff_mp4_muxer;
-            vs->oformat = &ff_mp4_muxer.p;
-        } else {
-            EXTERN const FFOutputFormat ff_mpegts_muxer;
-            vs->oformat = &ff_mpegts_muxer.p;
-        }`;
-  const replacement = `        if (hls->segment_type == SEGMENT_TYPE_FMP4) {
-            av_log(s, AV_LOG_ERROR, "fmp4 HLS segments are disabled in this static build\\n");
-            return AVERROR_PATCHWELCOME;
-        } else {
-            EXTERN const FFOutputFormat ff_mpegts_muxer;
-            vs->oformat = &ff_mpegts_muxer.p;
-        }`;
-
-  if (!source.includes(needle)) {
-    throw new Error('Unable to patch FFmpeg HLS muxer; expected fMP4 branch was not found');
-  }
-
-  writeFileSync(hlsencPath, source.replace(needle, replacement));
-}
-
-if (process.platform !== 'darwin') {
-  console.log('[NativeVendor] Skipping FFmpeg static vendor build on', process.platform);
-  process.exit(0);
-}
-
-if (!['arm64', 'x64'].includes(targetArch)) {
-  throw new Error(`[NativeVendor] Unsupported macOS architecture: ${targetArch}`);
-}
-
-const compilerArch = targetArch === 'x64' ? 'x86_64' : 'arm64';
-const host = targetArch === 'x64' ? 'x86_64-apple-darwin' : 'aarch64-apple-darwin';
-const architectureFlags = `-arch ${compilerArch} -mmacosx-version-min=${MACOS_DEPLOYMENT_TARGET}`;
-
-rmSync(ffmpegSrc, {recursive: true, force: true});
-rmSync(x264Src, {recursive: true, force: true});
-rmSync(x264Install, {recursive: true, force: true});
-rmSync(vendorDir, {recursive: true, force: true});
-mkdirSync(workRoot, {recursive: true});
-mkdirSync(ffmpegSrc, {recursive: true});
-mkdirSync(x264Src, {recursive: true});
-mkdirSync(x264Install, {recursive: true});
-mkdirSync(vendorDir, {recursive: true});
-
-download(
-  `https://ffmpeg.org/releases/ffmpeg-${FFMPEG_VERSION}.tar.xz`,
-  ffmpegArchive,
-  FFMPEG_SHA256,
-);
-download(
-  `https://code.videolan.org/videolan/x264/-/archive/${X264_REF}/x264-${X264_REF}.tar.bz2`,
-  x264Archive,
-  X264_SHA256,
-);
-
-run('tar', ['-xJf', ffmpegArchive, '-C', ffmpegSrc, '--strip-components=1']);
-run('tar', ['-xjf', x264Archive, '-C', x264Src, '--strip-components=1']);
-
-run(
-  './configure',
-  [
-    `--prefix=${x264Install}`,
-    '--enable-static',
-    '--disable-cli',
-    '--disable-opencl',
-    `--host=${host}`,
-    `--extra-cflags=${architectureFlags}`,
-    `--extra-ldflags=${architectureFlags}`,
-  ],
-  {cwd: x264Src},
-);
-run('make', [`-j${os.cpus().length}`, 'install'], {cwd: x264Src});
-
-patchFfmpegHlsMuxer();
-
-run(
-  './configure',
-  [
-    `--prefix=${vendorDir}`,
-    '--disable-shared',
-    '--enable-static',
-    '--disable-programs',
-    '--disable-doc',
-    '--disable-debug',
-    '--disable-autodetect',
-    '--disable-network',
-    '--enable-gpl',
-    '--enable-libx264',
-    '--target-os=darwin',
-    `--arch=${compilerArch}`,
-    '--cc=clang',
-    `--extra-cflags=-I${join(x264Install, 'include')} ${architectureFlags}`,
-    `--extra-ldflags=-L${join(x264Install, 'lib')} ${architectureFlags}`,
-    `--pkg-config-flags=--static`,
-  ],
-  {
-    cwd: ffmpegSrc,
-    env: {
-      PKG_CONFIG_PATH: join(x264Install, 'lib', 'pkgconfig'),
-    },
-  },
-);
-run('make', [`-j${os.cpus().length}`, 'install'], {cwd: ffmpegSrc});
-
-copyFileSync(join(x264Install, 'lib', 'libx264.a'), join(vendorDir, 'lib', 'libx264.a'));
-console.log(`[NativeVendor] Static FFmpeg vendor bundle ready: ${vendorDir}`);

package/scripts/build.mjs

@@ -1,53 +0,0 @@
-import {existsSync} from 'fs';
-import {fileURLToPath} from 'url';
-import {join, resolve} from 'path';
-import {spawnSync} from 'child_process';
-
-if (process.platform !== 'darwin') {
-  console.log('[NativeCapture] Skipping macOS native capture build on', process.platform);
-  process.exit(0);
-}
-
-const packageRoot = resolve(fileURLToPath(new URL('..', import.meta.url)));
-const requestedArch =
-  process.env.NATIVE_CAPTURE_ARCH ||
-  process.env.TARGET_ARCH ||
-  process.env.npm_config_arch ||
-  process.arch;
-const targetArch = requestedArch === 'x86_64' ? 'x64' : requestedArch;
-const vendorLibDir = join(packageRoot, 'vendor', 'ffmpeg', `darwin-${targetArch}`, 'lib');
-const requiredVendorLibs = [
-  'libavformat.a',
-  'libavcodec.a',
-  'libswscale.a',
-  'libswresample.a',
-  'libavutil.a',
-  'libx264.a',
-];
-
-function run(command, args, options = {}) {
-  const result = spawnSync(command, args, {
-    cwd: packageRoot,
-    stdio: 'inherit',
-    shell: process.platform === 'win32',
-    ...options,
-  });
-
-  if (result.status !== 0) {
-    process.exit(result.status ?? 1);
-  }
-}
-
-const hasVendorBundle = requiredVendorLibs.every(lib => existsSync(join(vendorLibDir, lib)));
-if (!hasVendorBundle && process.env.SKIP_NATIVE_FFMPEG_VENDOR_BUILD !== '1') {
-  console.log('[NativeCapture] Static FFmpeg vendor bundle missing; building it now');
-  run('node', ['scripts/build-ffmpeg-vendor.mjs'], {
-    env: {
-      ...process.env,
-      NATIVE_CAPTURE_ARCH: targetArch,
-    },
-  });
-}
-
-console.log('[NativeCapture] Building native addon');
-run('node-gyp', ['configure', 'build', `--arch=${targetArch}`]);

package/scripts/stage-prebuild.mjs

@@ -1,28 +0,0 @@
-import {chmodSync, copyFileSync, existsSync, mkdirSync} from 'fs';
-import {join, resolve} from 'path';
-import {fileURLToPath} from 'url';
-
-const packageRoot = resolve(fileURLToPath(new URL('..', import.meta.url)));
-const requestedArch =
-  process.env.NATIVE_CAPTURE_ARCH ||
-  process.env.TARGET_ARCH ||
-  process.env.npm_config_arch ||
-  process.arch;
-const arch = requestedArch === 'x86_64' ? 'x64' : requestedArch;
-
-if (!['arm64', 'x64'].includes(arch)) {
-  throw new Error(`Unsupported prebuild architecture: ${arch}`);
-}
-
-const source = join(packageRoot, 'build', 'Release', 'native_capture.node');
-const destinationDir = join(packageRoot, 'prebuilds', `darwin-${arch}`);
-const destination = join(destinationDir, 'native_capture.node');
-
-if (!existsSync(source)) {
-  throw new Error(`Native addon has not been built: ${source}`);
-}
-
-mkdirSync(destinationDir, {recursive: true});
-copyFileSync(source, destination);
-chmodSync(destination, 0o755);
-console.log(`[NativeCapture] Staged darwin-${arch} prebuild at ${destination}`);

package/scripts/verify-package.mjs

@@ -1,39 +0,0 @@
-import {createHash} from 'crypto';
-import {readdirSync, readFileSync, statSync} from 'fs';
-import {join, resolve} from 'path';
-import {spawnSync} from 'child_process';
-import {fileURLToPath} from 'url';
-
-const packageRoot = resolve(fileURLToPath(new URL('..', import.meta.url)));
-const expected = [
-  {arch: 'arm64', machine: 'arm64'},
-  {arch: 'x64', machine: 'x86_64'},
-];
-const checksumLines = [];
-
-for (const {arch, machine} of expected) {
-  const relativePath = `darwin-${arch}/native_capture.node`;
-  const filePath = join(packageRoot, 'prebuilds', relativePath);
-  const size = statSync(filePath).size;
-  if (size < 1024 * 1024 || size > 64 * 1024 * 1024) {
-    throw new Error(`Unexpected prebuild size for ${relativePath}: ${size}`);
-  }
-
-  const inspection = spawnSync('file', [filePath], {encoding: 'utf8'});
-  if (inspection.status !== 0 || !inspection.stdout.includes(machine)) {
-    throw new Error(`Invalid architecture for ${relativePath}: ${inspection.stdout}`);
-  }
-
-  const checksum = createHash('sha256').update(readFileSync(filePath)).digest('hex');
-  checksumLines.push(`${checksum}  ${relativePath}`);
-}
-
-const directories = readdirSync(join(packageRoot, 'prebuilds'), {withFileTypes: true})
-  .filter(entry => entry.isDirectory())
-  .map(entry => entry.name)
-  .sort();
-if (directories.join(',') !== 'darwin-arm64,darwin-x64') {
-  throw new Error(`Unexpected prebuild directories: ${directories.join(', ')}`);
-}
-
-process.stdout.write(`${checksumLines.join('\n')}\n`);

package/scripts/verify-packlist.mjs

@@ -1,40 +0,0 @@
-import {readFileSync} from 'fs';
-
-const reportPath = process.argv[2];
-if (!reportPath) throw new Error('Usage: node scripts/verify-packlist.mjs <npm-pack-report.json>');
-
-const [report] = JSON.parse(readFileSync(reportPath, 'utf8'));
-if (!report?.files) throw new Error('npm pack report does not contain a file list');
-
-const paths = report.files.map(file => file.path);
-const required = [
-  'index.js',
-  'index.d.ts',
-  'LICENSE',
-  'SOURCE.md',
-  'THIRD_PARTY_NOTICES.md',
-  'prebuilds/SHA256SUMS',
-  'prebuilds/darwin-arm64/native_capture.node',
-  'prebuilds/darwin-x64/native_capture.node',
-];
-
-for (const path of required) {
-  if (!paths.includes(path)) throw new Error(`Required package file is missing: ${path}`);
-}
-
-const forbidden = paths.filter(
-  path =>
-    path.startsWith('build/') ||
-    path.startsWith('node_modules/') ||
-    path.includes('/vendor/ffmpeg/darwin-') ||
-    /\.(a|o|dylib)$/.test(path),
-);
-if (forbidden.length > 0) {
-  throw new Error(`Forbidden package files found:\n${forbidden.join('\n')}`);
-}
-
-if (report.unpackedSize > 64 * 1024 * 1024) {
-  throw new Error(`Unpacked package is unexpectedly large: ${report.unpackedSize} bytes`);
-}
-
-console.log(`Verified npm pack contents: ${paths.length} files, ${report.unpackedSize} bytes`);

package/scripts/verify-runtime.cjs

@@ -1,28 +0,0 @@
-'use strict';
-
-const capture = require('../index.js');
-
-const expectedFunctions = [
-  'startCapture',
-  'setSegmentReadyCallback',
-  'stopCapture',
-  'getLastError',
-  'listDisplaySources',
-  'listWindowSources',
-  'listAudioInputDevices',
-  'listVideoInputDevices',
-  'pauseCapture',
-  'resumeCapture',
-];
-
-for (const name of expectedFunctions) {
-  if (typeof capture[name] !== 'function') {
-    throw new Error(`Missing native export: ${name}`);
-  }
-}
-
-if (typeof capture.getLastError() !== 'string') {
-  throw new Error('getLastError() must return a string');
-}
-
-console.log(`Verified ${expectedFunctions.length} native exports on darwin-${process.arch}`);

package/src/CameraCapturer.mm

@@ -1,154 +0,0 @@
-#import <AVFoundation/AVFoundation.h>
-#import <CoreMedia/CoreMedia.h>
-#include "CameraCapturer.h"
-#include <iostream>
-
-/**
- * CameraDelegate
- * --------------
- * Internal ObjC class to receive frames from AVCaptureVideoDataOutput.
- */
-@interface CameraDelegate : NSObject <AVCaptureVideoDataOutputSampleBufferDelegate> {
-    CameraFrameCallback _callback;
-}
-- (void)setCallback:(CameraFrameCallback)cb;
-@end
-
-@implementation CameraDelegate
-- (void)setCallback:(CameraFrameCallback)cb {
-    _callback = cb;
-}
-
-- (void)captureOutput:(AVCaptureOutput *)output
-    didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer
-           fromConnection:(AVCaptureConnection *)connection {
-    if (_callback) {
-        _callback(static_cast<void*>(sampleBuffer));
-    }
-}
-@end
-
-CameraCapturer::CameraCapturer() : m_session(nullptr), m_delegate(nullptr) {}
-
-CameraCapturer::~CameraCapturer() {
-    stop();
-}
-
-std::vector<CameraDevice> CameraCapturer::listDevices() {
-    std::vector<CameraDevice> result;
-    
-    // Modern API for listing video devices
-    AVCaptureDeviceDiscoverySession *discoverySession = [AVCaptureDeviceDiscoverySession
-        discoverySessionWithDeviceTypes:@[AVCaptureDeviceTypeBuiltInWideAngleCamera, AVCaptureDeviceTypeExternal]
-                              mediaType:AVMediaTypeVideo
-                               position:AVCaptureDevicePositionUnspecified];
-    
-    for (AVCaptureDevice *device in discoverySession.devices) {
-        CameraDevice d;
-        d.uid = [[device uniqueID] UTF8String];
-        d.name = [[device localizedName] UTF8String];
-        result.push_back(d);
-    }
-    
-    return result;
-}
-
-bool CameraCapturer::start(const std::string& device_uid, uint32_t& width, uint32_t& height, int fps, CameraFrameCallback cb) {
-    stop(); // Ensure clean state
-    
-    AVCaptureSession *session = [[AVCaptureSession alloc] init];
-    AVCaptureDevice *device = nil;
-    
-    if (device_uid.empty()) {
-        device = [AVCaptureDevice defaultDeviceWithMediaType:AVMediaTypeVideo];
-    } else {
-        device = [AVCaptureDevice deviceWithUniqueID:[NSString stringWithUTF8String:device_uid.c_str()]];
-    }
-    
-    if (!device) {
-        std::cerr << "[Camera] Requested device not found: " << device_uid << std::endl;
-        return false;
-    }
-    
-    NSError *error = nil;
-    AVCaptureDeviceInput *input = [AVCaptureDeviceInput deviceInputWithDevice:device error:&error];
-    if (error || !input) {
-        std::cerr << "[Camera] Failed to create input: " << [[error localizedDescription] UTF8String] << std::endl;
-        return false;
-    }
-    
-    if ([session canAddInput:input]) {
-        [session addInput:input];
-    } else {
-        return false;
-    }
-    
-    AVCaptureVideoDataOutput *output = [[AVCaptureVideoDataOutput alloc] init];
-    
-    // Use 32BGRA for easy conversion / preview
-    [output setVideoSettings:@{
-        (id)kCVPixelBufferPixelFormatTypeKey: @(kCVPixelFormatType_32BGRA)
-    }];
-    
-    CameraDelegate *delegate = [[CameraDelegate alloc] init];
-    [delegate setCallback:cb];
-    
-    dispatch_queue_t queue = dispatch_queue_create("com.boom.camera.queue", DISPATCH_QUEUE_SERIAL);
-    [output setSampleBufferDelegate:delegate queue:queue];
-    
-    if ([session canAddOutput:output]) {
-        [session addOutput:output];
-    } else {
-        return false;
-    }
-    
-    // Find best match for requested dimensions
-    AVCaptureDeviceFormat *bestFormat = nil;
-    int bestDiff = 9999999;
-    
-    for (AVCaptureDeviceFormat *vFormat in [device formats]) {
-        CMFormatDescriptionRef description = [vFormat formatDescription];
-        CMVideoDimensions dims = CMVideoFormatDescriptionGetDimensions(description);
-        
-        int diff = std::abs((int)dims.width - (int)width) + std::abs((int)dims.height - (int)height);
-        if (diff < bestDiff) {
-            bestDiff = diff;
-            bestFormat = vFormat;
-        }
-    }
-    
-    if (bestFormat) {
-        if ([device lockForConfiguration:nil]) {
-            device.activeFormat = bestFormat;
-            device.activeVideoMinFrameDuration = CMTimeMake(1, fps);
-            device.activeVideoMaxFrameDuration = CMTimeMake(1, fps);
-            [device unlockForConfiguration];
-            
-            CMFormatDescriptionRef description = [bestFormat formatDescription];
-            CMVideoDimensions dims = CMVideoFormatDescriptionGetDimensions(description);
-            width = dims.width;
-            height = dims.height;
-            std::cout << "[Camera] Selected format: " << width << "x" << height << " @ " << fps << "fps" << std::endl;
-        }
-    }
-    
-    [session startRunning];
-    
-    m_session = (__bridge_retained void*)session;
-    m_delegate = (__bridge_retained void*)delegate;
-    
-    return true;
-}
-
-void CameraCapturer::stop() {
-    if (m_session) {
-        AVCaptureSession *session = (__bridge_transfer AVCaptureSession*)m_session;
-        [session stopRunning];
-        m_session = nullptr;
-    }
-    if (m_delegate) {
-        CameraDelegate *delegate = (__bridge_transfer CameraDelegate*)m_delegate;
-        [delegate setCallback:nullptr];
-        m_delegate = nullptr;
-    }
-}