Go语言实现屏幕截取+实时推流-地鼠文档

在当今的软件开发中，屏幕截图截图功能是许多应用程序的重要组成部分，无论是桌面应用、监控工具还是自动化测试系统，都可能需要用到屏幕截图的能力。今天我要向大家介绍一款优秀的Go语言屏幕截图库——kbinani/screenshot，它以跨平台、易用性和稳定性著称，是Go开发者实现屏幕截图功能的理想选择。

项目概述

kbinani/screenshot是一个开源的Go语言库，专门用于捕获桌面屏幕图像。该库支持多种操作系统，包括Windows、macOS、Linux、FreeBSD、OpenBSD和NetBSD，并且在大多数平台上实现了无cgo依赖（仅macOS平台需要cgo支持）。

项目的GitHub地址：https://github.com/kbinani/screenshot

核心特性

跨平台支持：覆盖主流操作系统，包括Windows、macOS、Linux及多种BSD系统
多显示器支持：能够识别并捕获多个显示器的内容
区域截图：支持捕获指定区域的屏幕内容
简单易用：提供简洁的API，几行代码即可实现截图功能
高性能：针对不同平台进行了优化，确保截图效率

快速开始

安装

使用Go模块安装非常简单：

go get github.com/kbinani/screenshot

基础用法

下面是一个简单的示例，展示如何捕获所有显示器的内容并保存为PNG图片：

package main

import (
    "fmt"
    "image/png"
    "os"

    "github.com/kbinani/screenshot"
)

// 保存image.RGBA为PNG格式文件
func save(img *image.RGBA, filePath string) {
    file, err := os.Create(filePath)
    if err != nil {
        panic(err)
    }
    defer file.Close()
    err = png.Encode(file, img)
    if err != nil {
        panic(err)
    }
}

func main() {
    // 获取活跃显示器数量
    n := screenshot.NumActiveDisplays()
    if n <= 0 {
        panic("未找到活跃显示器")
    }

    // 捕获每个显示器的内容
    for i := 0; i < n; i++ {
        // 获取第i个显示器的边界
        bounds := screenshot.GetDisplayBounds(i)

        // 捕获该显示器的内容
        img, err := screenshot.CaptureRect(bounds)
        if err != nil {
            panic(err)
        }

        // 保存为PNG文件
        fileName := fmt.Sprintf("%d_%dx%d.png", i, bounds.Dx(), bounds.Dy())
        save(img, fileName)

        fmt.Printf("第%d个显示器 : %v 已保存为 \"%s\"\n", i, bounds, fileName)
    }
}

运行上述代码后，会在当前目录生成每个显示器的截图文件，输出类似：

第0个显示器 : (0,0)-(1280,800) 已保存为 "0_1280x800.png"
第1个显示器 : (-293,-1440)-(2267,0) 已保存为 "1_2560x1440.png"

捕获指定区域

如果你只需要捕获屏幕的特定区域，可以使用Capture函数：

// 捕获从(100, 100)开始，宽200，高300的区域
img, err := screenshot.Capture(100, 100, 200, 300)
if err != nil {
    panic(err)
}
save(img, "region.png")

捕获整个桌面

你还可以捕获所有显示器组合起来的整个桌面区域：

// 计算所有显示器的联合区域
var all image.Rectangle = image.Rect(0, 0, 0, 0)
n := screenshot.NumActiveDisplays()
for i := 0; i < n; i++ {
    bounds := screenshot.GetDisplayBounds(i)
    all = bounds.Union(all)
}

// 捕获整个桌面区域
img, err := screenshot.Capture(all.Min.X, all.Min.Y, all.Dx(), all.Dy())
if err != nil {
    panic(err)
}
save(img, "all.png")

坐标系统说明

kbinani/screenshot采用与Windows系统相似的坐标系统：

原点(0,0)位于主显示器的左上角
Y轴向下为正方向
多显示器情况下，副显示器可能有负坐标值，这取决于它们相对主显示器的位置

这种设计使得在多显示器环境下处理坐标更加直观，特别是在需要跨显示器捕获内容时。

平台实现细节

该库针对不同平台采用了不同的实现方式，以确保最佳性能和兼容性：

Windows：使用GDI API进行屏幕捕获，支持Go 1.21及以上版本的新特性
macOS：使用CoreGraphics和ScreenCaptureKit框架（需要cgo支持）
Linux：根据桌面环境自动选择X11或Wayland实现
BSD系统：使用X11相关库实现

这种平台特定的优化确保了在各种操作系统上都能获得可靠的截图体验。

性能考量

kbinani/screenshot在设计时就考虑了性能因素：

使用原生系统API进行截图，减少了中间环节
内存管理优化，避免不必要的内存分配和复制
提供了Benchmark测试，便于跟踪性能变化

你可以通过项目中的基准测试了解其性能表现：

func BenchmarkCaptureRect(b *testing.B) {
    bounds := screenshot.GetDisplayBounds(0)
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        _, err := screenshot.CaptureRect(bounds)
        if err != nil {
            b.Error(err)
        }
    }
}

适用场景

kbinani/screenshot适用于多种场景：

桌面应用程序中的截图功能
屏幕监控和录制工具
自动化测试中的界面验证
远程桌面和屏幕共享应用
教育软件中的屏幕标注功能

简单的demo

1. 全局帧缓存模块 (frame_cache.go)

package main

import (
    "sync"
    "time"
)

var (
    frameCache     []byte
    frameCacheTime time.Time
    cacheMutex     sync.RWMutex
)

// 更新帧缓存
func updateFrameCache(frame []byte) {
    cacheMutex.Lock()
    defer cacheMutex.Unlock()
    frameCache = frame
    frameCacheTime = time.Now()
}

// 获取帧缓存
func getFrameCache() ([]byte, time.Time) {
    cacheMutex.RLock()
    defer cacheMutex.RUnlock()
    return frameCache, frameCacheTime
}

2. 截屏服务模块 (capture_service.go)

package main

import (
    "bytes"
    "image/jpeg"
    "log"
    "time"

    "github.com/kbinani/screenshot"
)

func startCaptureService() {
    ticker := time.NewTicker(time.Second / time.Duration(frameRate))
    defer ticker.Stop()

    for range ticker.C {
        img, err := screenshot.CaptureRect(screenBounds)
        if err != nil {
            log.Printf("截屏失败: %v", err)
            continue
        }

        buf := new(bytes.Buffer)
        if err := jpeg.Encode(buf, img, &jpeg.Options{Quality: quality}); err != nil {
            log.Printf("JPEG编码失败: %v", err)
            continue
        }

        updateFrameCache(buf.Bytes())
    }
}

3. 流处理模块 (stream_handler.go)

package main

import (
    "fmt"
    "net/http"
    "time"
)

func streamHandler(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "multipart/x-mixed-replace; boundary=frame")
    w.Header().Set("Cache-Control", "no-cache")
    w.Header().Set("Connection", "keep-alive")

    // 发送初始帧分隔符
    if _, err := w.Write([]byte("--frame\r\n")); err != nil {
        return
    }

    lastSent := time.Now()
    for {
        frame, frameTime := getFrameCache()

        // 只发送新帧
        if frameTime.After(lastSent) {
            if _, err := fmt.Fprintf(w,
                "Content-Type: image/jpeg\r\nContent-Length: %d\r\n\r\n",
                len(frame)); err != nil {
                return
            }

            if _, err := w.Write(frame); err != nil {
                return
            }

            if _, err := w.Write([]byte("\r\n--frame\r\n")); err != nil {
                return
            }

            if f, ok := w.(http.Flusher); ok {
                f.Flush()
            }

            lastSent = frameTime
        }

        // 防止CPU空转
        time.Sleep(time.Second / time.Duration(frameRate*2))

        select {
        case <-r.Context().Done():
            return
        default:
        }
    }
}

4. 主程序模块 (main.go)

package main

import (
    "image"
    "log"
    "net/http"

    "github.com/kbinani/screenshot"
)

var (
    quality      = 50                     // JPEG质量(1-100)
    frameRate    = 10                     // 帧率(FPS)
    screenBounds = image.Rect(0, 0, 0, 0) // 屏幕尺寸
)

func main() {
    // 初始化截屏区域
    if n := screenshot.NumActiveDisplays(); n <= 0 {
        log.Fatal("未检测到活动显示器")
    }
    screenBounds = screenshot.GetDisplayBounds(0)

    // 启动截屏服务
    go startCaptureService()

    // 设置路由
    http.HandleFunc("/stream", streamHandler)
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        http.ServeFile(w, r, "index.html")
    })

    // 启动服务器
    log.Println("服务启动: http://localhost:8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

Web前端实现

<!DOCTYPE html>
<html>
<head>
    <title>Go屏幕流测试</title>
    <style>
        body { font-family: Arial, sans-serif; text-align: center; margin-top: 50px; }
        #video { max-width: 90%; border: 1px solid #ccc; margin: 20px auto; }
    </style>
</head>
<body>
    <h1>Go屏幕流测试播放器</h1>
    <img id="video" src="/stream" alt="视频流">

    <div>
        <button onclick="window.location.reload()">重新加载</button>
    </div>

    <script>
        // 自动重连逻辑
        const video = document.getElementById('video');
        video.onerror = function() {
            setTimeout(function() {
                video.src = '/stream?t=' + new Date().getTime();
            }, 1000);
        };
    </script>
</body>
</html>

运行程序

go run main.go   //打开浏览器访问： http://localhost:8080