SPICE全链路分析（四）：输入事件的旅程——从键盘按下到Guest响应

@hdd2026-02-18 20:54

当你在远程桌面客户端按下一个键或移动鼠标时，这个事件如何穿越协议栈，最终被虚拟机中的操作系统接收？本文追踪输入事件的完整生命周期。

键盘事件全链路

输入事件传输的核心挑战

远程桌面的输入传输面临三个根本挑战：

  1. 延迟敏感性：用户对键盘和鼠标响应延迟极为敏感。研究表明，超过100ms的键盘延迟就会被感知为"卡顿"，超过50ms的鼠标延迟就会影响操作精度。因此输入通道必须走最短路径，不能有大缓冲区
  2. 键码体系差异：客户端可能运行在Linux/Windows/macOS上，使用X11/Wayland/Win32/Cocoa，每个平台的键码体系不同。而Guest VM期望接收标准的PS/2扫描码。SPICE需要一个统一的键码转换层
  3. 鼠标模式差异：传统鼠标（PS/2）使用相对坐标（"向右移动5像素"），而现代Tablet设备和多显示器场景需要绝对坐标（"移动到(320, 240)"）。两种模式的数据格式、流控策略和Guest端处理方式完全不同

SPICE的设计是：客户端负责平台差异适配（键码转换），协议层传输平台无关的XT扫描码，服务端负责注入虚拟设备。InputsChannel运行在主线程（非Worker线程），保证最低延迟。

为什么使用XT扫描码？

SPICE选择XT扫描码（而非USB HID键码或X11 keycode）有历史和技术原因：

  • XT扫描码是PC键盘最底层的编码，直接对应PS/2键盘硬件产生的字节序列
  • QEMU的虚拟键盘（i8042）模拟的是PS/2控制器，直接接受XT扫描码，无需额外转换
  • VNC也使用类似的底层扫描码方案，SPICE的vncdisplaykeymap库直接复用了VNC的映射表
  • XT扫描码覆盖了几乎所有PC键盘按键，包括E0扩展键（如右Ctrl、方向键、Windows键）

这种设计使SPICE的输入通道成为一个透明管道：客户端将任何平台的按键转换为标准XT码，服务端将XT码直接注入PS/2控制器，Guest OS的键盘驱动无需任何修改就能正确处理。

客户端：GTK事件捕获

客户端通过GTK的key_press_event回调捕获键盘事件。这是输入链路的起点。

c 复制代码 
// spice-gtk: spice-widget.c
static gboolean key_press_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
{
    SpiceDisplay *display = SPICE_DISPLAY(data);
    SpiceDisplayPrivate *d = display->priv;
    guint scancode;

    if (d->disable_inputs)
        return FALSE;

    // 检查抓取键序列（默认Ctrl+Alt）
    if (check_grab_sequence(display, event)) {
        if (d->keyboard_grab_active) {
            try_keyboard_ungrab(display);
        } else {
            try_keyboard_grab(display);
        }
        return TRUE;
    }

    if (!d->keyboard_grab_active)
        return FALSE;

    scancode = keyval_to_scancode(display, event->keyval, event->state);
    if (scancode == 0)
        return FALSE;

    spice_inputs_channel_key_press(d->inputs, scancode);
    update_key_state(d, scancode, TRUE);

    return TRUE;
}

分析：check_grab_sequence用于检测Ctrl+Alt等抓取键，按下时切换键盘抓取状态而非发送给Guest。只有keyboard_grab_active为TRUE时才会将按键转发。这种设计允许用户在不抓取时正常使用本地键盘，抓取后则全部转发到虚拟机。

客户端：键码转换

GDK使用keyval（逻辑键值），SPICE协议使用XT扫描码。需要映射表转换：

c 复制代码 
// spice-gtk: spice-widget.c
static guint keyval_to_scancode(SpiceDisplay *display, guint keyval, GdkModifierType state)
{
    SpiceDisplayPrivate *d = display->priv;
    GdkWindow *window = gtk_widget_get_window(GTK_WIDGET(display));
    guint16 scancode;

    if (d->keycode_map == NULL) {
        d->keycode_map = vnc_display_keymap_gdk2xtkbd_table(window, &d->keycode_maplen);
    }

    if (d->keycode_map) {
        GdkKeymapKey *keys;
        gint n_keys;
        if (gdk_keymap_get_entries_for_keyval(...)) {
            for (i = 0; i < n_keys; i++) {
                if (keys[i].keycode < d->keycode_maplen) {
                    scancode = d->keycode_map[keys[i].keycode];
                    if (scancode != 0) {
                        return scancode;
                    }
                }
            }
        }
    }
    return 0;
}

分析：vnc_display_keymap_gdk2xtkbd_table提供平台相关映射（X11/Wayland/Win32/macOS）。不同平台键码体系不同，映射表是跨平台兼容的关键。spice_make_scancode处理E0扩展键（如右Ctrl、方向键）。

客户端：发送消息

转换后的扫描码通过InputsChannel发送：

c 复制代码 
// spice-gtk: channel-inputs.c
void spice_inputs_channel_key_press(SpiceInputsChannel *channel, guint scancode)
{
    SpiceMsgcKeyDown down;
    SpiceMsgOut *msg;

    g_return_if_fail(channel != NULL);
    if (SPICE_CHANNEL(channel)->priv->state != SPICE_CHANNEL_STATE_READY)
        return;

    down.code = spice_make_scancode(scancode, FALSE);
    msg = spice_msg_out_new(SPICE_CHANNEL(channel), SPICE_MSGC_INPUTS_KEY_DOWN);
    msg->marshallers->msgc_inputs_key_down(msg->marshaller, &down);
    spice_msg_out_send(msg);
}

void spice_inputs_channel_key_release(SpiceInputsChannel *channel, guint scancode)
{
    SpiceMsgcKeyUp up;
    up.code = spice_make_scancode(scancode, TRUE);  // TRUE表示释放
    msg = spice_msg_out_new(SPICE_CHANNEL(channel), SPICE_MSGC_INPUTS_KEY_UP);
    msg->marshallers->msgc_inputs_key_up(msg->marshaller, &up);
    spice_msg_out_send(msg);
}

分析：spice_make_scancode处理E0前缀：扩展键的扫描码与0x100进行OR。释放事件使用第8位（0x80）标记。消息通过通道的marshaller序列化后发送到网络。

服务端：接收和注入

服务端InputsChannelClient的handle_message处理收到的键盘消息：

cpp 复制代码 
// server/inputs-channel.cpp
bool InputsChannelClient::handle_message(uint16_t type, uint32_t size, void *message)
{
    InputsChannel *inputs_channel = get_channel();

    switch (type) {
    case SPICE_MSGC_INPUTS_KEY_DOWN: {
        auto key_down = static_cast<SpiceMsgcKeyDown *>(message);
        inputs_channel->sync_locks(key_down->code);
    }
        /* fallthrough */
    case SPICE_MSGC_INPUTS_KEY_UP: {
        auto key_up = static_cast<SpiceMsgcKeyUp *>(message);
        for (i = 0; i < 4; i++) {
            uint8_t code = (key_up->code >> (i * 8)) & 0xff;
            if (code == 0)
                break;
            kbd_push_scan(inputs_channel->keyboard, code);
            inputs_channel->sync_locks(code);
        }
        break;
    }
    // ...
    }
    return TRUE;
}

分析：KEY_DOWN会先sync_locks同步锁定键状态，然后fallthrough到KEY_UP处理。code字段可包含多字节（如E0键），循环解析每个字节。kbd_push_scan将扫描码注入虚拟键盘。

kbd_push_scan() → SpiceKbdInterface::push_scan_freg → 虚拟键盘设备

kbd_push_scan调用QEMU等虚拟化平台提供的接口：

cpp 复制代码 
// server/inputs-channel.cpp
static void kbd_push_scan(SpiceKbdInstance *sin, uint8_t scan)
{
    SpiceKbdInterface *sif;

    sif = SPICE_UPCAST(SpiceKbdInterface, sin->base.sif);
    sif->push_scan_freg(sin, scan);
}

分析：SpiceKbdInterface由QEMU的spice接口实现。push_scan_freg将扫描码传递给QEMU的键盘模拟层，最终注入到虚拟机的PS/2或USB键盘设备，Guest OS的键盘驱动接收并处理。

鼠标事件全链路

两种鼠标模式

SPICE支持两种鼠标模式，处理方式不同：

模式 坐标类型 使用场景 设备
SPICE_MOUSE_MODE_SERVER 相对坐标 (dx, dy) 传统远程桌面 虚拟鼠标
SPICE_MOUSE_MODE_CLIENT 绝对坐标 (x, y) 多显示器、无缝 VDAgent或虚拟平板

分析：SERVER模式类似本地鼠标，每次发送移动增量。CLIENT模式发送绝对屏幕坐标，适合多显示器场景，需VDAgent或Tablet设备支持。

鼠标模式选择的设计原理

两种鼠标模式的选择涉及光标一致性问题：

SERVER模式（相对坐标） 的问题：客户端发送增量(dx, dy)，服务端维护Guest中的光标位置。但客户端窗口中也有一个本地光标。两个光标的位置可能因网络延迟而不一致------用户看到客户端光标已移动，但Guest光标还在旧位置，导致"光标漂移"。解决方案是鼠标抓取（mouse grab）：抓取后隐藏客户端光标，用户只看到Guest的光标，但用户需要按Ctrl+Alt释放。

CLIENT模式（绝对坐标） 解决了这个问题：客户端发送绝对坐标(x, y)，Guest中的鼠标直接跳到该位置，两个光标始终一致，无需抓取。但这需要Guest安装VDAgent或支持Tablet设备（PS/2鼠标只支持相对坐标）。

模式自动选择逻辑：服务端根据Guest能力决定------如果VDAgent已连接且未禁用agent_mouse，则使用CLIENT模式；否则使用SERVER模式。切换通过SPICE_MSG_MAIN_MOUSE_MODE通知客户端。

客户端：坐标转换和发送

鼠标事件根据模式选择position或motion：

c 复制代码 
// spice-gtk: spice-widget.c
static gboolean motion_notify_event(GtkWidget *widget, GdkEventMotion *event, gpointer data)
{
    SpiceDisplay *display = SPICE_DISPLAY(data);
    SpiceDisplayPrivate *d = display->priv;
    gint x, y;

    if (d->disable_inputs)
        return FALSE;

    widget_to_guest_coords(display, event->x, event->y, &x, &y);

    if (d->mouse_mode == SPICE_MOUSE_MODE_CLIENT) {
        spice_inputs_channel_position(d->inputs, x, y, d->channel_id,
                                     d->mouse_button_mask);
    } else {
        gint dx = x - d->mouse_last_x;
        gint dy = y - d->mouse_last_y;
        if (dx != 0 || dy != 0) {
            spice_inputs_channel_motion(d->inputs, dx, dy, d->mouse_button_mask);
            d->mouse_last_x = x;
            d->mouse_last_y = y;
        }
    }
    return TRUE;
}

分析：widget_to_guest_coords将窗口坐标转换为Guest屏幕坐标（考虑缩放、多显示器）。CLIENT模式直接发送(x,y)，SERVER模式计算增量(dx,dy)并更新mouse_last_x/y。

CLIENT模式：spice_inputs_channel_position()

c 复制代码 
// spice-gtk: channel-inputs.c
void spice_inputs_channel_position(SpiceInputsChannel *channel, gint x, gint y,
                                   gint display, gint button_state)
{
    SpiceInputsChannelPrivate *c = channel->priv;
    c->bs  = button_state;
    c->x   = x;
    c->y   = y;
    c->dpy = display;

    if (c->motion_count < SPICE_INPUT_MOTION_ACK_BUNCH * 2) {
        send_position(channel);
    } else {
        CHANNEL_DEBUG(channel, "over SPICE_INPUT_MOTION_ACK_BUNCH * 2, dropping");
    }
}

分析：绝对坐标模式下，每个位置独立，不能累加。当motion_count超过阈值时直接丢弃，避免队列积压。这是流控机制在绝对模式下的体现。

SERVER模式：spice_inputs_channel_motion()

c 复制代码 
// spice-gtk: channel-inputs.c
void spice_inputs_channel_motion(SpiceInputsChannel *channel, gint dx, gint dy,
                                gint button_state)
{
    SpiceInputsChannelPrivate *c = channel->priv;
    c->bs  = button_state;
    c->dx += dx;   // 累加移动量
    c->dy += dy;

    if (c->motion_count < SPICE_INPUT_MOTION_ACK_BUNCH * 2) {
        send_motion(channel);
    }
}

static SpiceMsgOut* mouse_motion(SpiceInputsChannel *channel)
{
    SpiceMsgcMouseMotion motion;
    motion.buttons_state = c->bs;
    motion.dx            = c->dx;
    motion.dy            = c->dy;
    c->motion_count++;
    c->dx = 0;  // 清零累加值
    c->dy = 0;
    return msg;
}

分析：相对模式可累加dx/dy，将多次小移动合并为一次发送，减少网络消息。motion_count跟踪待确认消息数，超过阈值时延迟发送，实现背压流控。

流控机制

SPICE_INPUT_MOTION_ACK_BUNCH和motion_count实现流控：

c 复制代码 
// 当 motion_count < SPICE_INPUT_MOTION_ACK_BUNCH * 2 时立即发送
// 否则：相对模式累加等待，绝对模式丢弃

为什么需要输入流控？

鼠标移动事件的产生频率极高------现代鼠标轮询率可达1000Hz（每毫秒一次），即使125Hz也远超普通网络的合理消息率。如果每次鼠标移动都立即发送一条网络消息，会导致：

  1. 网络拥塞：大量小消息的TCP包头开销比有效载荷更大（TCP头40字节，motion消息仅8字节）
  2. 处理积压：服务端收到大量motion后逐一注入虚拟鼠标，可能导致Guest光标"追赶"延迟
  3. 阻塞其他消息：共享连接上的大量motion可能延迟更重要的消息（如键盘事件）

SPICE的流控方案：

  • 累加合并：SERVER模式下，多次小移动的dx/dy被累加为一次发送，减少消息数量
  • ACK窗口 ：SPICE_INPUT_MOTION_ACK_BUNCH定义了窗口大小（通常为4），客户端最多发送2 * BUNCH条motion后必须等待服务端ACK
  • 过载丢弃：CLIENT模式下超过阈值的position直接丢弃（绝对坐标只关心最新位置，中间位置无意义）

这种设计在保证低延迟的同时，有效控制了网络负载。即使鼠标以1000Hz产生事件，实际网络上的消息率也被限制在合理范围内。

服务端：处理鼠标事件

SERVER模式使用SpiceMouseInterface：

cpp 复制代码 
// server/inputs-channel.cpp
case SPICE_MSGC_INPUTS_MOUSE_MOTION: {
    SpiceMouseInstance *mouse = inputs_channel->mouse;
    auto mouse_motion = static_cast<SpiceMsgcMouseMotion *>(message);

    on_mouse_motion();
    if (mouse && reds_get_mouse_mode(reds) == SPICE_MOUSE_MODE_SERVER) {
        SpiceMouseInterface *sif;
        sif = SPICE_UPCAST(SpiceMouseInterface, mouse->base.sif);
        sif->motion(mouse,
                    mouse_motion->dx, mouse_motion->dy, 0,
                    RED_MOUSE_STATE_TO_LOCAL(mouse_motion->buttons_state));
    }
    break;
}

分析：on_mouse_motion更新 InputsChannelClient的motion相关状态。motion回调将(dx,dy)和按钮状态传给QEMU的鼠标设备，虚拟机内的鼠标驱动接收相对移动事件。

CLIENT模式：reds_handle_agent_mouse_event() → VDAgent → Guest鼠标驱动

CLIENT模式使用VDAgent传递绝对坐标：

cpp 复制代码 
// server/inputs-channel.cpp
case SPICE_MSGC_INPUTS_MOUSE_POSITION: {
    auto pos = static_cast<SpiceMsgcMousePosition *>(message);
    if (reds_get_mouse_mode(reds) != SPICE_MOUSE_MODE_CLIENT)
        break;
    if (reds_config_get_agent_mouse(reds) && reds_has_vdagent(reds)) {
        VDAgentMouseState *mouse_state = &inputs_channel->mouse_state;
        mouse_state->x = pos->x;
        mouse_state->y = pos->y;
        mouse_state->buttons = RED_MOUSE_BUTTON_STATE_TO_AGENT(pos->buttons_state);
        mouse_state->display_id = pos->display_id;
        reds_handle_agent_mouse_event(reds, mouse_state);
    }
    break;
}

分析：鼠标状态写入mouse_state，通过reds_handle_agent_mouse_event发送到VDAgent。VDAgent通过virtio-serial将VD_AGENT_MOUSE_STATE传给Guest内的spice-vdagent进程，最终由Guest的鼠标驱动或X11/Wayland处理。

键盘锁定键同步

客户端 → 服务端同步

当客户端按下CapsLock等键时，服务端需要同步LED状态：

cpp 复制代码 
// server/inputs-channel.cpp
case SPICE_MSGC_INPUTS_KEY_DOWN: {
    inputs_channel->sync_locks(key_down->code);
}
// fallthrough to KEY_UP which calls kbd_push_scan

分析：sync_locks在按键时检查是否为锁定键，并更新modifiers状态。kbd_push_scan将扫描码注入后，Guest的LED状态会变化，需要反馈给客户端。

服务端 → 客户端同步

cpp 复制代码 
// server/inputs-channel.cpp
void InputsChannel::sync_locks(uint8_t scan)
{
    // 检测CapsLock/NumLock/ScrollLock的按下
    // 延迟后读取 get_leds() 获取Guest实际LED状态
    // 通过 SPICE_MSGC_INPUTS_KEY_MODIFIERS 或类似消息通知客户端
}

分析：锁定键有物理切换延迟，需要定时器延迟读取get_leds()再同步。客户端收到后更新本地键盘LED显示，保持一致性。

spice_inputs_channel_set_key_locks()

客户端也可主动设置锁定键状态：

c 复制代码 
// spice-gtk: channel-inputs.c
void spice_inputs_channel_set_key_locks(SpiceInputsChannel *channel, guint locks)
{
    SpiceMsgcKeyModifiers mod;
    mod.modifiers = locks;
    msg = spice_msg_out_new(SPICE_CHANNEL(channel), SPICE_MSGC_INPUTS_KEY_MODIFIERS);
    msg->marshallers->msgc_inputs_key_modifiers(msg->marshaller, &mod);
    spice_msg_out_send(msg);
}

分析：用于连接建立时或窗口焦点变化时同步客户端当前的锁定键状态到服务端，避免状态不一致导致的双击切换等问题。

按钮事件处理

c 复制代码 
// spice-gtk: spice-widget.c
static gboolean button_press_event(GtkWidget *widget, GdkEventButton *event, gpointer data)
{
    SpiceDisplay *display = SPICE_DISPLAY(data);
    guint button = gdk_button_to_spice_button(event->button);
    d->mouse_button_mask |= (1 << (button - 1));
    spice_inputs_channel_button_press(d->inputs, button, d->mouse_button_mask);
    return TRUE;
}

分析：gdk_button_to_spice_button将GDK按钮编号映射为SPICE的SPICE_MOUSE_BUTTON_*。mouse_button_mask记录当前按下状态，随motion/position一起发送。

滚轮事件

滚轮使用MOUSE_PRESS消息，通过button字段区分：

cpp 复制代码 
// server/inputs-channel.cpp
case SPICE_MSGC_INPUTS_MOUSE_PRESS: {
    auto mouse_press = static_cast<SpiceMsgcMousePress *>(message);
    int dz = 0;
    if (mouse_press->button == SPICE_MOUSE_BUTTON_UP) {
        dz = -1;
    } else if (mouse_press->button == SPICE_MOUSE_BUTTON_DOWN) {
        dz = 1;
    }
    if (reds_get_mouse_mode(reds) == SPICE_MOUSE_MODE_CLIENT) {
        // VDAgent 或 Tablet 处理
    } else if (inputs_channel->mouse) {
        sif->motion(mouse, 0, 0, dz, buttons_state);  // dz 为滚轮增量
    }
    break;
}

分析：UP/DOWN对应滚轮向上/向下，dz传入motion的第三个参数。CLIENT模式通过VDAgent传递，SERVER模式直接调用鼠标接口的motion。

客户端transform_input()坐标转换

在将鼠标坐标发送到Guest之前，需要将窗口坐标转换为Guest屏幕坐标：

c 复制代码 
// spice-gtk: spice-widget.c
static void widget_to_guest_coords(SpiceDisplay *display, gdouble wx, gdouble wy,
                                  gint *gx, gint *gy)
{
    SpiceDisplayPrivate *d = display->priv;
    GtkAllocation allocation;
    gint w, h;
    gdouble scale_x, scale_y;

    gtk_widget_get_allocation(GTK_WIDGET(display), &allocation);
    w = allocation.width;
    h = allocation.height;

    // 考虑显示通道的尺寸和缩放
    scale_x = (gdouble) d->width / w;
    scale_y = (gdouble) d->height / h;

    *gx = (gint) (wx * scale_x);
    *gy = (gint) (wy * scale_y);
}

分析：display的width/height是Guest的显示分辨率，widget的allocation是客户端窗口尺寸。scale_x/y将窗口坐标按比例映射到Guest坐标。多显示器时还需考虑display_id和屏幕偏移。

服务端KEY_MODIFIERS处理

当客户端发送锁定键状态变化时，服务端需要同步到虚拟键盘：

cpp 复制代码 
// server/inputs-channel.cpp
case SPICE_MSGC_INPUTS_KEY_MODIFIERS: {
    auto modifiers = static_cast<SpiceMsgcKeyModifiers *>(message);
    uint8_t leds;
    SpiceKbdInstance *keyboard = inputs_channel->keyboard;

    if (!keyboard)
        break;

    leds = inputs_channel->modifiers;
    if (!(inputs_channel->modifiers_pressed & SPICE_KEYBOARD_MODIFIER_FLAGS_SCROLL_LOCK) &&
        ((modifiers->modifiers & SPICE_KEYBOARD_MODIFIER_FLAGS_SCROLL_LOCK) !=
         (leds & SPICE_KEYBOARD_MODIFIER_FLAGS_SCROLL_LOCK))) {
        kbd_push_scan(keyboard, SCROLL_LOCK_SCAN_CODE);
        kbd_push_scan(keyboard, SCROLL_LOCK_SCAN_CODE | SCAN_CODE_RELEASE);
        inputs_channel->modifiers ^= SPICE_KEYBOARD_MODIFIER_FLAGS_SCROLL_LOCK;
    }
    // 类似处理 NUM_LOCK, CAPS_LOCK
    inputs_channel->activate_modifiers_watch();
    break;
}

分析：客户端请求的modifiers与当前leds不一致时，通过模拟按下+释放锁定键来切换Guest状态。activate_modifiers_watch启动定时器，延迟后读取get_leds()并通知客户端实际状态，完成双向同步。

客户端键码映射表来源

vnc_display_keymap_gdk2xtkbd_table 根据平台返回不同映射表：

c 复制代码 
// X11: 使用 X11 键盘扩展
// Wayland: 使用 libxkbcommon
// Win32: 使用 MapVirtualKey
// macOS: 使用 Cocoa

分析：各平台键码体系不同，映射表将物理键码映射到XT扫描码。同一物理键在不同平台可能有不同keycode，需分别处理。

总结

输入事件从客户端到Guest的完整旅程：

  1. 键盘：GTK key_event → keyval_to_scancode → spice_inputs_channel_key_press → SPICE_MSGC_INPUTS_KEY_DOWN/UP → InputsChannelClient::handle_message → kbd_push_scan → SpiceKbdInterface::push_scan_freg → 虚拟键盘 → Guest
  2. 鼠标SERVER模式：motion_notify → 计算dx/dy → spice_inputs_channel_motion（累加）→ SPICE_MSGC_INPUTS_MOUSE_MOTION → SpiceMouseInterface::motion → 虚拟鼠标 → Guest
  3. 鼠标CLIENT模式：motion_notify → widget_to_guest_coords → spice_inputs_channel_position → SPICE_MSGC_INPUTS_MOUSE_POSITION → reds_handle_agent_mouse_event → VDAgent → Guest
  4. 流控：motion_count与SPICE_INPUT_MOTION_ACK_BUNCH实现背压，避免网络拥塞时积压
  5. 锁定键：双向同步，确保客户端与服务端LED状态一致

输入通道运行在主线程，保证低延迟，是SPICE远程桌面响应性的关键。

相关推荐
@hdd3 天前
spice-gtk源码分析（八）：音频播放与录制
spice·远程桌面协议·spice-gtk
@hdd8 天前
SPICE源码分析（十二）：网络传输与安全机制
spice·远程桌面协议
@hdd12 天前
SPICE源码分析（一）：整体架构与实现框架
spice·远程桌面协议
云雾J视界2 个月前
SPICE仿真进阶：AI芯片低功耗设计中的瞬态/AC分析实战
低功耗·仿真·spice·ai芯片·ac·均值估算
冰山一脚20132 年前
libusb注意事项笔记
spice
冰山一脚20132 年前
libspice显示命令调用流程分析
spice
冰山一脚20132 年前
spice VDAgent简介
spice
热门推荐
01从零搭建一个 PHP 登录注册系统（含完整源码）02使用 1panel面板 部署 php网站03GitHub 镜像站点04MIUI显示/隐藏5G开关的方法，信号弱时开启手机Wifi通话方法05AI Agent 平台横评：ZeroClaw vs OpenClaw vs Nanobot06Claude Code + GLM4.7 避坑指南：解决 Unable to connect to Anthropic services07openClaw安装飞书插件｜核心踩坑：spawn EINVAL 错误终极解决指南08PHP Error: 常见错误及其解决方法09openclaw 配置飞书 报错 应用未建立长连接10UV安装并设置国内源