初始化

1. MSDisplay.DisplayStart(configs) – 传入VIC配置数组
2. MSDisplay.Start(callback) – 监听设备事件
3. 等待回调中的 event.handle

配置显示

1. MSDisplay.DisplayAddVideoParam(handle, width, height, refresh)
2. MSDisplay.DisplaySetVideoParam(handle)
3. MSDisplay.DisplaySendPicture(width, height, handle)

显示数据

1. 创建RGBA32格式的Buffer
2. MSDisplay.PushData(buffer, width, height, handle) – 推送图像数据

清理资源

1. MSDisplay.DisplayStopSendPicture(handle)
2. MSDisplay.DisplayStop()
3. MSDisplay.Stop()

参数说明

• handle: 设备句柄（从Start回调获取）
• width/height: 图像尺寸（如320×240）
• refresh: 刷新率（如60）
• buffer: RGBA32图像数据Buffer
• configs: VIC配置数组
• callback: 设备事件回调函数

// 精简流式视频播放器
const MSDisplay = require('./MSDisplayAddon.node');
const { spawn } = require('child_process');
const fs = require('fs');
const path = require('path');
const os = require('os');

let deviceHandle = null;
let isPlaying = false;
let ffmpegProcess = null;
let playLoopTimer = null;
let watchDogTimer = null;
let serialNumber = null;
let preferredVendorId = '0x1002'; // AMD的Vendor ID
let logStream = null;
let startTime = Date.now();

// 互斥体和FFmpeg进程管理
const lockFilePath = path.join(os.tmpdir(), 'msdisp_video_player.lock');
const ffmpegPidsPath = path.join(os.tmpdir(), 'msdisp_ffmpeg_pids.txt');
const logsDir = path.join(__dirname, 'logs');

// 日志系统
function initLogger() {
    if (!fs.existsSync(logsDir)) fs.mkdirSync(logsDir, { recursive: true });
    const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5);
    const logPath = path.join(logsDir, `video_${process.pid}_${ts}.log`);
    logStream = fs.createWriteStream(logPath, { flags: 'a' });
    const log = console.log, err = console.error;
    console.log = (...a) => { const m = `[${new Date().toISOString()}] ${a.join(' ')}`; log(...a); logStream?.write(m + '\n'); };
    console.error = (...a) => { const m = `[${new Date().toISOString()}] [ERROR] ${a.join(' ')}`; err(...a); logStream?.write(m + '\n'); };
    console.log(`📝 日志: ${logPath}`);
}

function closeLogger() { logStream?.end(); logStream = null; }

// 互斥锁
function acquireLock() {
    if (fs.existsSync(lockFilePath)) {
        const oldPid = parseInt(fs.readFileSync(lockFilePath, 'utf8'));
        try {
            process.kill(oldPid, 0);
            console.error('❌ 程序已运行 (PID:', oldPid, ')'); process.exit(1);
        } catch { console.log('⚠️ 清理过期锁 (PID:', oldPid, ')'); fs.unlinkSync(lockFilePath); }
    }
    try {
        const fd = fs.openSync(lockFilePath, 'wx');
        fs.writeSync(fd, process.pid.toString()); fs.closeSync(fd);
        console.log(`✅ 获取锁 (PID: ${process.pid})`);
    } catch (e) {
        console.error('❌ 无法获取锁:', e.code === 'EEXIST' ? '已运行' : e.message); process.exit(1);
    }
}

function releaseLock() {
    try { if (fs.existsSync(lockFilePath)) fs.unlinkSync(lockFilePath); } catch { }
    try { if (fs.existsSync(ffmpegPidsPath)) fs.unlinkSync(ffmpegPidsPath); } catch { }
}

// FFmpeg PID管理
function saveFFmpegPid(pid) {
    const pids = loadFFmpegPids(); pids.add(pid);
    const tmp = ffmpegPidsPath + '.tmp';
    fs.writeFileSync(tmp, Array.from(pids).join('\n'), 'utf8');
    fs.renameSync(tmp, ffmpegPidsPath);
    console.log(`📌 FFmpeg PID: ${pid} (共${pids.size}个)`);
}

// 加载FFmpeg PID列表
function loadFFmpegPids() {
    const pids = new Set();
    if (fs.existsSync(ffmpegPidsPath)) {
        fs.readFileSync(ffmpegPidsPath, 'utf8').split('\n').forEach(l => {
            const p = parseInt(l.trim()); if (p) pids.add(p);
        });
    }
    return pids;
}

// 清理旧FFmpeg进程
function cleanupOldFFmpegProcesses() {
    const pids = loadFFmpegPids();
    if (pids.size === 0) return;
    console.log(`🧹 清理 ${pids.size} 个旧FFmpeg...`);
    let cnt = 0;
    pids.forEach(p => { try { process.kill(p, 'SIGKILL'); cnt++; console.log(`  ├─ PID ${p}`); } catch { } });
    try { fs.unlinkSync(ffmpegPidsPath); console.log(`✅ 已清理 ${cnt}/${pids.size} 个`); } catch { }
}

// 设备事件处理
function handleDeviceEvent(event) {
    if (event.type === 0) { // 设备连接
        if (!isPlaying) {
            deviceHandle = event.handle;
            startDisplayAndPlay(event);
        }
    } else if (event.type === 1) { // 设备断开
        stopDisplayAndPlay();
    }
}

async function startDisplayAndPlay(event) {
    try {
        console.log('🔌 设备连接, 开始播放。');
        MSDisplay.DisplayAddVideoParam(event.handle, 320, 240, 60);
        await MSDisplay.DisplaySetVideoParam(event.handle);
        MSDisplay.DisplaySendPicture(320, 240, event.handle);
        isPlaying = true;
        startFFmpegAndPlay();
    } catch (e) {
        console.error('显示启动失败:', e.message);
    }
}

function stopDisplayAndPlay() {
    isPlaying = false;
    if (ffmpegProcess) ffmpegProcess.kill();
    if (playLoopTimer) clearTimeout(playLoopTimer);
    if (watchDogTimer) clearTimeout(watchDogTimer);
    setTimeout(() => {
        console.log('🛑 设备断开，停止播放......');
    }, 100);
}

function startFFmpegAndPlay() {
    const videoPath = '.\\v240.mp4';
    startFFmpeg(videoPath, preferredVendorId);
    playVideo();
}

// 检测适配器
async function findAdapter(vendorId = '0x1002') {
    let success = false;
    try {
        const ffmpeg = spawn('ffmpeg', [
            '-hide_banner', '-v', 'verbose',
            '-init_hw_device', `d3d11va=hwacc:,vendor_id=${vendorId}`,
            '-f', 'lavfi', '-i', 'nullsrc=size=16x16',
            '-t', '0.1', '-f', 'null', '-'
        ]);

        let stderr = '';
        ffmpeg.stderr.on('data', (data) => stderr += data);

        await new Promise((resolve, reject) => {
            ffmpeg.on('close', (code) => {
                if (code !== 0) return reject();

                const match = stderr.match(/Using device ([0-9a-fA-F:]+)\s+\((.+)\)\./i);
                if (match) {
                    console.log(`✅ Found hwaccel device: ${match[2]} (${match[1]})`);
                    resolve(vendorId);
                } else {
                    reject();
                }
            });
            ffmpeg.on('error', reject);
        });
        success = true;
    } catch { }
    return success ? vendorId : null;

}

// 启动FFmpeg
function startFFmpeg(videoPath, preferredVendorId = null) {
    const hwArgs = preferredVendorId ? ['-init_hw_device', `d3d11va=hwacc:,vendor_id=${preferredVendorId}`,
        '-hwaccel', 'd3d11va', '-hwaccel_device', 'hwacc', '-filter_hw_device', 'hwacc', '-hwaccel_output_format', 'd3d11'] : [];
    const vf = (preferredVendorId ? 'hwdownload,format=nv12,' : '') + 'scale=320:240:force_original_aspect_ratio=increase,crop=320:240,pad=320:240:(ow-iw)/2:(oh-ih)/2:black';
    const args = ['-re', '-stream_loop', '-1', ...hwArgs, '-i', videoPath, '-vf', vf, '-pix_fmt', 'bgra', '-f', 'rawvideo', '-r', '30', '-'];
    
    console.log(`🚀 FFmpeg启动 (${preferredVendorId ? `硬件 ${preferredVendorId}` : '软件'})`);
    ffmpegProcess = spawn('ffmpeg', args);
    const pid = ffmpegProcess.pid;
    saveFFmpegPid(pid);
    console.log(`  └─ PID: ${pid}`);
    
    // 延迟清理旧进程
    setTimeout(() => {
        const old = loadFFmpegPids(); old.delete(pid);
        if (old.size > 0) {
            console.log(`🧹 回收 ${old.size} 个旧FFmpeg...`);
            old.forEach(p => { try { process.kill(p, 'SIGKILL'); console.log(`  ├─ PID ${p}`); } catch { } });
            const tmp = ffmpegPidsPath + '.tmp';
            fs.writeFileSync(tmp, pid.toString(), 'utf8');
            fs.renameSync(tmp, ffmpegPidsPath);
            console.log(`✅ 完成，当前PID: ${pid}`);
        }
    }, 500);
    
    ffmpegProcess.on('close', (code) => {
        if (!isPlaying) { console.log(`🛑 FFmpeg退出 (PID: ${pid})`); return; }
        if (code !== 0) {
            if (preferredVendorId && code === 1) {
                console.log('⚠️ 硬件加速失败，回退软件解码');
                setTimeout(() => startFFmpeg(videoPath, null), 1000);
            } else {
                console.log(`⚠️ FFmpeg异常退出 (code: ${code})，重启中`);
                setTimeout(() => startFFmpeg(videoPath, preferredVendorId), 2000);
            }
        }
    });
    return ffmpegProcess;
}


// 播放视频
function playVideo() {
    const frameSize = 320 * 240 * 4;
    let frameBuffer = Buffer.alloc(0);
    const frameQueue = [];
    const statisticsQueue = [];
    let frameCount = 0;
    let lastFfmpegFrameTime = Date.now(); // 初始为now，避免首帧特殊处理

    // 处理视频数据
    ffmpegProcess.stdout.on('data', (data) => {
        frameBuffer = Buffer.concat([frameBuffer, data]);

        while (frameBuffer.length >= frameSize) {
            const frameData = frameBuffer.subarray(0, frameSize);
            frameBuffer = frameBuffer.subarray(frameSize);
            const now = Date.now();
            let ffmpegInterval = now - lastFfmpegFrameTime;
            lastFfmpegFrameTime = now;

            // 添加到队列
            if (frameQueue.length < 10) {
                frameQueue.push({
                    data: frameData,
                    timestamp: now,
                    ffmpegInterval
                });
            }
        }
    });

    // 播放循环
    const playLoop = () => {
        if (!isPlaying) return;

        if (frameQueue.length > 0) {
            const frame = frameQueue.shift();
            const playTime = Date.now();
            const delay = playTime - frame.timestamp;

            try {
                MSDisplay.PushData(frame.data, 320, 240, deviceHandle);
                frameCount++;
                statisticsQueue.push({ delay, timestamp: playTime, ffmpegInterval: frame.ffmpegInterval });
            } catch (error) {
                console.log(`播放错误: ${error.message}`);
            }
        }

        playLoopTimer = setTimeout(playLoop, 10);
    };

    const watchDogLoop = () => {
        if (!isPlaying) return;
        // 降低诊断频率：改为30秒
        if (statisticsQueue.length > 2 && (Date.now() - statisticsQueue[0].timestamp) > 30000) {
            const stats = statisticsQueue.splice(0, statisticsQueue.length - 1);

            const avgDelay = stats.reduce((sum, item) => sum + item.delay, 0) / stats.length;
            const maxDelay = Math.max(...stats.map(i => i.delay));
            const minDelay = Math.min(...stats.map(i => i.delay));
            const tDiff = stats[stats.length - 1].timestamp - stats[0].timestamp;
            const actualFPS = ((stats.length - 1) / tDiff) * 1000;
            // 统计ffmpeg帧间隔
            const ffmpegIntervals = stats.map(i => i.ffmpegInterval);
            const ffmpegIntervalAvg = ffmpegIntervals.reduce((a, b) => a + b, 0) / ffmpegIntervals.length;
            const ffmpegIntervalMax = Math.max(...ffmpegIntervals);
            const ffmpegIntervalMin = Math.min(...ffmpegIntervals);
            
            const uptime = Math.floor((Date.now() - startTime) / 1000);
            console.log(`📊 [运行${uptime}s] 帧:${frameCount} FPS:${actualFPS.toFixed(1)} 延迟:${minDelay}|${avgDelay.toFixed(1)}|${maxDelay}ms 缓冲:${frameQueue.length} FFmpeg间隔:${ffmpegIntervalMin}|${ffmpegIntervalAvg.toFixed(1)}|${ffmpegIntervalMax}ms`);
        }
        // 用lastFfmpegFrameTime替代ffmpegLastUptime
        if (lastFfmpegFrameTime && (Date.now() - lastFfmpegFrameTime) > 800) {
            console.log('⚠️ FFmpeg无响应超过800ms，重启中...');
            if (ffmpegProcess) ffmpegProcess.kill();
        }
        watchDogTimer = setTimeout(watchDogLoop, 500);
    };

    playLoop();
    watchDogTimer = setTimeout(watchDogLoop, 1000);
}


// 检测序列号和硬件加速，只做一次
async function detectSerialAndAccel() {
    // 1. 设备连接并读取序列号
    MSDisplay.DisplayStart([]);
    let handle = null;
    await new Promise(resolve => {
        MSDisplay.Start((event) => {
            if (event?.handle) {
                handle = event.handle;
                resolve();
            }
        });
    });
    let sn = null;
    try {
        const data = MSDisplay.DisplayReadFlash(handle);
        const match = data.toString('ascii').match(/[A-Za-z0-9*]+/);
        if (match) sn = match[0];
    } catch { }
    if (!sn) return Promise.reject(new Error('无法读取设备序列号，请检查连接'));
    console.log(`✅ 读取到设备序列号: ${sn}`);
    MSDisplay.DisplayStop();
    MSDisplay.Stop();
    await new Promise(r => setTimeout(r, 200));
    // 2. 检测硬件加速
    let vendor = preferredVendorId;
    if (await findAdapter(vendor) !== vendor) {
        console.log('⚠️ 未找到硬件加速，使用软件解码');
        vendor = null;
    }
    return { serialNumber: sn, preferredVendorId: vendor };
}

// 主函数
async function main() {
    initLogger();
    acquireLock();
    cleanupOldFFmpegProcesses();
    
    const videoPath = '.\\v240.mp4';
    if (!fs.existsSync(videoPath)) {
        console.error('❌ 视频文件不存在:', videoPath);
        releaseLock(); closeLogger(); process.exit(1);
    }
    
    try {
        const detectResult = await detectSerialAndAccel();
        serialNumber = detectResult.serialNumber;
        preferredVendorId = detectResult.preferredVendorId;
        
        MSDisplay.DisplayStart([{ sn_code: serialNumber, vic: 148, polarity: 7, htotal: 568, vtotal: 452, hactive: 320, vactive: 240, pixclk: 1540, vfreq: 6000, hoffset: 206, voffset: 190, hsyncwidth: 20, vsyncwidth: 5 }]);
        MSDisplay.Start(handleDeviceEvent);
        console.log('⏳ 事件循环启动，等待设备...');

        const gracefulExit = () => {
            console.log('\n🛑 退出信号，清理中...');
            isPlaying = false;
            if (ffmpegProcess) { console.log(`  ├─ 终止FFmpeg (${ffmpegProcess.pid})`); ffmpegProcess.kill(); }
            if (playLoopTimer) clearTimeout(playLoopTimer);
            if (watchDogTimer) clearTimeout(watchDogTimer);
            try { MSDisplay.DisplayStop(); MSDisplay.Stop(); console.log('  ├─ 停止MSDisplay'); } catch { }
            cleanupOldFFmpegProcesses();
            releaseLock(); closeLogger();
            console.log('✅ 清理完成'); process.exit(0);
        };
        ['SIGINT', 'SIGTERM', 'SIGHUP'].forEach(s => process.on(s, gracefulExit));
        
        process.on('uncaughtException', (e) => { console.error('❌ 异常:', e); cleanupOldFFmpegProcesses(); releaseLock(); closeLogger(); process.exit(1); });
        process.on('unhandledRejection', (r) => { console.error('❌ Promise拒绝:', r); cleanupOldFFmpegProcesses(); releaseLock(); closeLogger(); process.exit(1); });

        setInterval(() => { }, 1000);
    } catch (error) {
        console.error('❌ 错误:', error.message);
        cleanupOldFFmpegProcesses(); releaseLock(); closeLogger(); process.exit(1);
    }
}

if (require.main === module) main();

Dim objShell
Set objShell = WScript.CreateObject("WScript.Shell")
objShell.CurrentDirectory = "C:\path\to\your\folder"
objShell.Run("cmd.exe /c ""nvm use 22.20.0 32 && node video.js >> msdisp.log 2>&1"""), 0
Set objShell = Nothing