<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/">
  <channel>
    <title>BeYoung</title>
    <link>https://lyapple2008.github.io/</link>
    <description>Recent content on BeYoung</description>
    <image>
      <title>BeYoung</title>
      <url>https://lyapple2008.github.io/%3Clink%20or%20path%20of%20image%20for%20opengraph,%20twitter-cards%3E</url>
      <link>https://lyapple2008.github.io/%3Clink%20or%20path%20of%20image%20for%20opengraph,%20twitter-cards%3E</link>
    </image>
    <generator>Hugo</generator>
    <language>zh-cn</language>
    <copyright>See this site&amp;rsquo;s source code here, licensed under GPLv3 ·</copyright>
    <lastBuildDate>Mon, 09 Nov 2026 22:21:46 +0800</lastBuildDate>
    <atom:link href="https://lyapple2008.github.io/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>【置顶】2026</title>
      <link>https://lyapple2008.github.io/posts/2026-todo/</link>
      <pubDate>Sun, 22 Feb 2026 09:43:54 +0800</pubDate>
      <guid>https://lyapple2008.github.io/posts/2026-todo/</guid>
      <description>&lt;blockquote&gt;
&lt;p&gt;记录跟踪2026年要做的事情和正在做的事情。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr&gt;
&lt;h2 id=&#34;目标&#34;&gt;目标&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;健康生活&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;input disabled=&#34;&#34; type=&#34;checkbox&#34;&gt; 体重减到60kg&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;div id=&#34;weight-chart&#34; style=&#34;width: 100%; height: 300px;&#34;&gt;&lt;/div&gt;
&lt;script src=&#34;https://cdn.jsdelivr.net/npm/echarts@5/dist/echarts.min.js&#34;&gt;&lt;/script&gt;
&lt;script&gt;
var chart = echarts.init(document.getElementById(&#39;weight-chart&#39;));
chart.setOption({
    tooltip: { trigger: &#39;axis&#39; },
    xAxis: { type: &#39;category&#39;, data: [&#39;1月&#39;, &#39;2月&#39;, &#39;3月&#39;, &#39;4月&#39;, &#39;5月&#39;, &#39;六月&#39;, &#39;七月&#39;, &#39;八月&#39;, &#39;九月&#39;, &#39;十月&#39;] },
    yAxis: { type: &#39;value&#39;, min: 55, max: 70 },
    series: [{
        data: [65, 65.8, 65.6, 64.4, 63.7, 63.9, 63.6, 63.1, 62.8, 63.0],
        type: &#39;line&#39;,
        smooth: true,
        areaStyle: { opacity: 0.3 },
        markLine: { data: [{ yAxis: 60, name: &#39;目标&#39; }], linestyle: { color: &#39;#52c41a&#39;, type: &#39;dashed&#39; } }
    }]
});
&lt;/script&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;探索可能&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;input disabled=&#34;&#34; type=&#34;checkbox&#34;&gt; 英语能力，熟练3篇演讲短文&lt;/li&gt;
&lt;li&gt;&lt;input disabled=&#34;&#34; type=&#34;checkbox&#34;&gt; 独立开发，目标完成4个独立项目 &amp;ndash;&amp;gt; 进度2/4&lt;/li&gt;
&lt;li&gt;&lt;input disabled=&#34;&#34; type=&#34;checkbox&#34;&gt; 公众号输出，目标输出文章10篇  &amp;ndash;&amp;gt; 进度12/10&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;</description>
      <content:encoded><![CDATA[<blockquote>
<p>记录跟踪2026年要做的事情和正在做的事情。</p>
</blockquote>
<hr>
<h2 id="目标">目标</h2>
<ul>
<li>
<p>健康生活</p>
<ul>
<li><input disabled="" type="checkbox"> 体重减到60kg</li>
</ul>
</li>
</ul>
<div id="weight-chart" style="width: 100%; height: 300px;"></div>
<script src="https://cdn.jsdelivr.net/npm/echarts@5/dist/echarts.min.js"></script>
<script>
var chart = echarts.init(document.getElementById('weight-chart'));
chart.setOption({
    tooltip: { trigger: 'axis' },
    xAxis: { type: 'category', data: ['1月', '2月', '3月', '4月', '5月', '六月', '七月', '八月', '九月', '十月'] },
    yAxis: { type: 'value', min: 55, max: 70 },
    series: [{
        data: [65, 65.8, 65.6, 64.4, 63.7, 63.9, 63.6, 63.1, 62.8, 63.0],
        type: 'line',
        smooth: true,
        areaStyle: { opacity: 0.3 },
        markLine: { data: [{ yAxis: 60, name: '目标' }], linestyle: { color: '#52c41a', type: 'dashed' } }
    }]
});
</script>
<ul>
<li>
<p>探索可能</p>
<ul>
<li><input disabled="" type="checkbox"> 英语能力，熟练3篇演讲短文</li>
<li><input disabled="" type="checkbox"> 独立开发，目标完成4个独立项目 &ndash;&gt; 进度2/4</li>
<li><input disabled="" type="checkbox"> 公众号输出，目标输出文章10篇  &ndash;&gt; 进度12/10</li>
</ul>
</li>
</ul>
<h2 id="正在做的项目">正在做的项目</h2>
<ul>
<li>
<p><input checked="" disabled="" type="checkbox"> iOS双语字幕App</p>
</li>
<li>
<p><input checked="" disabled="" type="checkbox"> 拼了还拼小游戏外挂</p>
</li>
<li>
<p><input disabled="" type="checkbox"> 个人资产管理app上架 app store</p>
</li>
<li>
<p><input disabled="" type="checkbox"> asr from scratch</p>
</li>
<li>
<p><input disabled="" type="checkbox"> 虚拟主播</p>
</li>
</ul>
<h2 id="一些随想">一些随想</h2>
<blockquote>
<p>记录一些生活工作中一些小感受和小想法</p>
</blockquote>
<ul>
<li>2026.10.18</li>
</ul>
<blockquote>
<p>AI流行的这段时间，每天都在想如何利用AI提高工作效率，提高AI含量，最近越来越发现瓶颈在个人，也许本质还是没有变化，决定产物质量的高量还是个人，所以慢下来提高个人能力还是一如既往的重要。</p>
</blockquote>
<ul>
<li>2026.07.04</li>
</ul>
<blockquote>
<p>慢下来才能更快。</p>
</blockquote>
<ul>
<li>2026.05.24</li>
</ul>
<blockquote>
<p>You can outsource your thinking, but you can&rsquo;t outsource your understanding.<br>
思考可以外包，但理解不能外包<br>
虽然现在AI进展神速，但是工作/学习的底层逻辑没有变化，AI只是加速了知识的获取和帮忙个人思考，对事情的理解过程还是存在于个人的大脑，这个是AI没法替你完成的。</p>
</blockquote>
<ul>
<li>2026.03.29</li>
</ul>
<blockquote>
<p>每天记录和量化进度，本身就是一种负担，而且对于效率提高帮助不大，也不利于长期任务，与其每天盯着任务进度，
不如现在开始试下，里程碑式的工作方法，给自己一段时间设定一些目标，到期后来检查完成情况，中间如何只记录
据有里程碑意义的事件。</p>
</blockquote>
]]></content:encoded>
    </item>
    <item>
      <title>读《褚时健传》：不闲着，把每一天过实</title>
      <link>https://lyapple2008.github.io/posts/202611/2026-11-09-%E8%AF%BB%E5%90%8E%E6%84%9F-%E7%A6%87%E6%97%B6%E5%81%A5%E4%BC%A0/</link>
      <pubDate>Mon, 09 Nov 2026 22:21:46 +0800</pubDate>
      <guid>https://lyapple2008.github.io/posts/202611/2026-11-09-%E8%AF%BB%E5%90%8E%E6%84%9F-%E7%A6%87%E6%97%B6%E5%81%A5%E4%BC%A0/</guid>
      <description>读完褚时健的起落，最触动我的不是“逆袭”，而是他到晚年仍愿意在慢事情上认真投入。家庭的缺憾、企业的盈利，以及对可控之事的专注，也让我重新想了想什么叫不虚度。</description>
      <content:encoded><![CDATA[<p>读《褚时健传》，很容易记住两个极端：他把玉溪卷烟厂做成了大企业，晚年又在哀牢山种出了褚橙。一个人经历了那么大的起落，还能重新开始，当然让人佩服。但如果只把这本书读成“人生可以逆袭”，我觉得有点可惜。</p>
<p>更打动我的，是他身上那股<strong>不闲着、不虚度</strong>的劲头。手里有一件值得做的事，就把今天安排好，一点点把它做出结果。只是这种做事的力量，也不能盖过他人生里那些无法挽回的损失。读完之后，我最想记下的是下面三点。</p>
<h2 id="一家庭的不足不能用事业成绩补上">一、家庭的不足，不能用事业成绩补上</h2>
<p>褚时健的事业很大，家庭遭遇却令人难过。他被调查、入狱前后，妻子和其他亲属受到牵连，女儿离世，儿子远走海外。<a href="http://jjckb.xinhuanet.com/2015-11/25/c_134852545.htm">吴晓波为《褚时健传》所写的序言</a>也写到了这一段。读到这里，我很难只把它当成传奇人物“跌入谷底”的情节，因为这些名字背后都是活生生的家人。</p>
<p>我不想把家庭的变故简单归因于“工作太忙”。法律问题、家庭关系、个人选择和当时的处境，都比一句话复杂。但有一件事很清楚：**事业上的成就，不能拿来抵扣家庭里的遗憾。**厂子做得再大，后来橙子卖得再好，失去的人也回不来。</p>
<p>这对普通人的提醒也许更直接。我们常常把家人的理解当成默认，把“等忙完这阵”当成承诺。可家人需要的陪伴、沟通、共同承担，并不是有一天事业成功了再补一张支票就能还清的。不虚度人生，除了把工作做好，也包括认真对待和自己一起过日子的人。</p>
<h2 id="二企业的第一要务是盈利但盈利要靠把事情做对">二、企业的第一要务是盈利，但盈利要靠把事情做对</h2>
<p>褚时健接手玉溪卷烟厂时，面对的不是一个可以直接享受成果的好摊子。他把心思放在产品、生产和经营上，最后让企业持续创造收入与利润。读这段经历，我对“企业首先要盈利”有了更具体的理解：企业要活下去，要给员工发工资，要继续投入、承担风险，就得有钱进来。只谈愿景、不算账，愿景也撑不了多久。</p>
<p>但盈利并不是把“赚钱”两个字贴在墙上。消费者愿意买、产品质量稳定、生产和销售的环节转得起来，利润才会出现。褚橙也是一样：一颗橙子最后能卖出价格，前面得有人把地、树、水、肥、采收和品控一件件管好。<strong>利润是把事情做好后必须得到的结果，也是检验经营能否持续的一张账单。</strong></p>
<p>把这把尺子放到个人创业上，也一样适用。如果说自己是在做一份事业，就得认真考虑它怎样创造收入、最终能否盈利。起步时可以很小，不一定一开始就辞职，也不一定每天都能拿出大把时间；但要持续给它<strong>足够的精力</strong>，去找真实需求、接触用户、打磨产品、算清成本，并验证是否有人愿意付钱。</p>
<p>探索当然可能失败，但“不求结果地试一试”很容易变成一种舒服的拖延：做了不少事，却始终绕开最难回答的问题。对我来说，更诚实的做法是给尝试一个可以检验的结果，哪怕只是第一个付费用户、第一笔能够覆盖成本的收入。这样投入的时间才真的在推动一份事业，而不只是让自己感觉很忙。</p>
<h2 id="三做能做的事高龄创业偏偏选了农业这条慢路">三、做能做的事：高龄创业，偏偏选了农业这条慢路</h2>
<p>晚年的褚时健让我最佩服的地方，是他没有挑一条看起来能很快翻身的路。他和妻子去哀牢山承包山地种橙。果树有生长周期，今天种下去，明天不会有收成；天气、土壤、病虫害也不会因为创业者着急就让步。一个已经年过七十的人，选择这样一条慢路，还愿意从头学、从头做，确实很符合他踏实做事的风格。</p>
<p><img alt="褚氏农业提供的褚橙种植基地果园全景" loading="lazy" src="/images/2026-11/chucheng-orchard-base-2026.png"></p>
<p><em>褚橙种植基地的果园全景。图片见<a href="https://feng.ifeng.com/c/8xKAvoIsbn6">2026 年褚橙丰收节报道</a>，由褚氏农业提供。</em></p>
<p>不过，佩服之余也不能把这段故事讲成“任何人都能退休后上山种橙”。他一开始就承包了两千多亩山地，之后围绕种植、管理和销售建立起一套有规模的经营方式。这是一种近似工业化的农业打法：集中投入、重视标准、把果园当成生产系统来管理。前期投入重，见效慢，还需要资金、经验、组织能力和承受风险的余地。普通人既未必有这些条件，也未必等得起果树结果的几年。</p>
<p>所以我更愿意学他的<strong>做事态度</strong>，而不是照搬他的<strong>创业规模</strong>。能借鉴的是愿意长期投入、愿意进现场解决具体问题；不能直接复制的是一上来就重资产、规模化的打法。把两者分开，才不会把“褚橙”读成一句廉价的创业口号。</p>
<p><img alt="潘虎团队设计的褚橙礼盒，展示橙子的陈列和取用方式" loading="lazy" src="/images/2026-11/chucheng-package-tiger-pan.jpg"></p>
<p><em>褚橙礼盒设计方案，2016 年由潘虎团队为云南实建果业设计。它呈现了橙子从果园走向商品和品牌的一步；图片来自<a href="https://www.behance.net/gallery/40534985/Chus-Orange">设计师作品页</a>，作品页标注“署名—非商业性使用—禁止演绎”，这里原图引用。</em></p>
<p>回头看他晚年的选择，我觉得“专注”也不是假装没有痛苦，更不是说外部的事都不重要。判决已成事实，过去的损失也不能重来；但今天的地要怎么管、树要怎么养、果子要怎么卖，这些仍有办法去做。能改变多少，就先从手边那一部分开始。</p>
<h2 id="写在最后">写在最后</h2>
<p>读完这本书，我不想给自己立一个“像褚时健一样东山再起”的目标。那既不现实，也不是多数人需要复制的人生。对我更有用的是一把小得多的尺子：今天有没有认真做一件可控的事？做的事能不能产生真实的结果？忙于工作的时候，有没有把家人也放进自己的时间表？</p>
<p><strong>不闲着，不是把每一分钟塞满；不虚度，是知道什么值得投入，然后把眼前的这一天过实。</strong></p>
]]></content:encoded>
    </item>
    <item>
      <title>WebRTC 多路音频混音：从接收流到求和与限幅</title>
      <link>https://lyapple2008.github.io/posts/202611/2026-11-09-webrtc%E4%B8%AD%E5%A4%9A%E8%B7%AF%E9%9F%B3%E9%A2%91%E6%B5%81%E6%B7%B7%E9%9F%B3/</link>
      <pubDate>Mon, 09 Nov 2026 15:26:52 +0800</pubDate>
      <guid>https://lyapple2008.github.io/posts/202611/2026-11-09-webrtc%E4%B8%AD%E5%A4%9A%E8%B7%AF%E9%9F%B3%E9%A2%91%E6%B5%81%E6%B7%B7%E9%9F%B3/</guid>
      <description>&lt;p&gt;两个人同时说话，扬声器最终只能收到一路播放数据。最直观的做法是把两个波形逐样本相加；问题是相加后的峰值可能超过 16 位 PCM 的表示范围。直接截断会失真，简单地除以人数又可能让只说话的那个人变小声。&lt;/p&gt;
&lt;p&gt;WebRTC 的默认选择是：&lt;strong&gt;接收端逐路取出 10 ms 音频，统一格式后用浮点数求和，再用 Limiter 控制合成音频的峰值。&lt;/strong&gt; 本文以本地源码提交 &lt;a href=&#34;https://webrtc.googlesource.com/src/&amp;#43;/c8bca1867efcbc5f52adf58ad4463088ed257aa0&#34;&gt;&lt;code&gt;c8bca1867e&lt;/code&gt;&lt;/a&gt;（2026-10-22）为基线，先看播放链路，再比较三种混音方法。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p>两个人同时说话，扬声器最终只能收到一路播放数据。最直观的做法是把两个波形逐样本相加；问题是相加后的峰值可能超过 16 位 PCM 的表示范围。直接截断会失真，简单地除以人数又可能让只说话的那个人变小声。</p>
<p>WebRTC 的默认选择是：<strong>接收端逐路取出 10 ms 音频，统一格式后用浮点数求和，再用 Limiter 控制合成音频的峰值。</strong> 本文以本地源码提交 <a href="https://webrtc.googlesource.com/src/&#43;/c8bca1867efcbc5f52adf58ad4463088ed257aa0"><code>c8bca1867e</code></a>（2026-10-22）为基线，先看播放链路，再比较三种混音方法。</p>
<h2 id="一webrtc-多路音频流的混音流程">一、WebRTC 多路音频流的混音流程</h2>
<h3 id="混音发生在播放端的哪一处">混音发生在播放端的哪一处</h3>
<p>一个远端音频流对应一个接收源。它自己的 NetEQ 负责抖动缓冲、解码与丢包隐藏；混音器拿到的是各路 <strong>PCM 帧</strong>，不是把 Opus 或 RTP 包直接相加。<code>AudioState</code> 在接收流加入、退出时把源注册到混音器；音频设备需要下一段播放数据时，<code>AudioTransportImpl</code> 才调用 <code>Mix()</code> 拉取并合成。<a href="https://webrtc.googlesource.com/src/&#43;/c8bca1867efcbc5f52adf58ad4463088ed257aa0/audio/audio_state.cc">接收源注册</a> · <a href="https://webrtc.googlesource.com/src/&#43;/c8bca1867efcbc5f52adf58ad4463088ed257aa0/audio/audio_transport_impl.cc">播放回调</a></p>

<div class="mermaid">flowchart LR
    A[&#34;远端流 A&lt;br/&gt;RTP → NetEQ → PCM&#34;] --&gt; M[&#34;AudioMixerImpl&lt;br/&gt;每次拉取 10 ms&#34;]
    B[&#34;远端流 B&lt;br/&gt;RTP → NetEQ → PCM&#34;] --&gt; M
    C[&#34;远端流 C&lt;br/&gt;RTP → NetEQ → PCM&#34;] --&gt; M
    M --&gt; F[&#34;统一采样率与声道&lt;br/&gt;求和 → Limiter&#34;]
    F --&gt; R[&#34;播放反向音频处理&lt;br/&gt;供回声消除参考&#34;]
    R --&gt; D[&#34;重采样为设备格式&lt;br/&gt;扬声器播放&#34;]</div>
<p>这条链路由<strong>播放时钟驱动</strong>：每次播放回调从每个源要下一段 10 ms 音频。NetEQ 各自处理网络抖动与时钟差异；混音器并不把不同流的 RTP 时间戳逐样本配对。混合后的声音进入音频处理的反向路径，供回声消除使用，随后按播放设备的采样率重采样。Chromium 的 <code>PullRenderData()</code> 路径会跳过这里的反向音频处理，因为 Chromium 自己管理对应的 APM 实例。<a href="https://webrtc.googlesource.com/src/&#43;/c8bca1867efcbc5f52adf58ad4463088ed257aa0/audio/channel_receive.cc"><code>ChannelReceive::GetAudioFrameWithInfo</code></a> · <a href="https://webrtc.googlesource.com/src/&#43;/c8bca1867efcbc5f52adf58ad4463088ed257aa0/audio/audio_transport_impl.cc"><code>AudioTransportImpl</code></a></p>
<h3 id="一次-mix-做了什么">一次 <code>Mix()</code> 做了什么</h3>

<div class="mermaid">flowchart TD
    A[&#34;收集已注册源的 PreferredSampleRate&#34;] --&gt; B[&#34;选混音采样率&lt;br/&gt;8 / 16 / 32 / 48 kHz 中满足最高需求的最低档&#34;]
    B --&gt; C[&#34;逐路请求 10 ms AudioFrame&lt;br/&gt;源内部按要求重采样&#34;]
    C --&gt; D{&#34;帧状态&#34;}
    D --&gt;|&#34;正常&#34;| E[&#34;加入混音列表&#34;]
    D --&gt;|&#34;静音或错误&#34;| X[&#34;不加入本帧求和&#34;]
    E --&gt; F[&#34;转换到调用方要求的声道数&#34;]
    X --&gt; G
    F --&gt; G[&#34;0 路：静音&lt;br/&gt;1 个已注册源：直通&lt;br/&gt;多源：浮点求和与可选 Limiter&#34;]
    G --&gt; H[&#34;输出 16 位 PCM 的 AudioFrame&#34;]</div>
<p>默认采样率不是把所有流降到最低：它取各源首选采样率的最大值，再向上选到支持的原生采样率，最高 48 kHz；没有源时使用 48 kHz。输出声道数由播放端指定，常见设备路径是单声道或双声道。源的采样率转换发生在各自的 <code>ChannelReceive</code> 中，声道转换发生在求和之前。<a href="https://webrtc.googlesource.com/src/&#43;/c8bca1867efcbc5f52adf58ad4463088ed257aa0/modules/audio_mixer/default_output_rate_calculator.cc"><code>DefaultOutputRateCalculator</code></a> · <a href="https://webrtc.googlesource.com/src/&#43;/c8bca1867efcbc5f52adf58ad4463088ed257aa0/modules/audio_mixer/frame_combiner.cc"><code>FrameCombiner</code></a></p>
<p>这里的“多源”依据<strong>已注册源数</strong>，并非这一帧实际发声的人数。两个源仍在房间里、其中一个静音时，静音帧不参与求和，但默认流程仍经过 Limiter。音量较低时其增益通常为 1；若前一刻出现过高峰，增益恢复过程仍可能影响这段声音。这一点从 <code>AudioMixerImpl::Mix()</code> 传入的 <code>number_of_streams</code> 和 <code>FrameCombiner::Combine()</code> 的分支可以直接看到。<a href="https://webrtc.googlesource.com/src/&#43;/c8bca1867efcbc5f52adf58ad4463088ed257aa0/modules/audio_mixer/audio_mixer_impl.cc"><code>AudioMixerImpl</code></a> · <a href="https://webrtc.googlesource.com/src/&#43;/c8bca1867efcbc5f52adf58ad4463088ed257aa0/modules/audio_mixer/frame_combiner.cc"><code>FrameCombiner</code></a></p>
<h2 id="二混音实现先相加再限制峰值">二、混音实现：先相加，再限制峰值</h2>
<h3 id="为什么相加是混音的基础">为什么“相加”是混音的基础</h3>
<p>当各路帧已经处于相同采样率、相同声道布局和同一播放时段时，每个输出声道的样本可以写成：</p>
<p><code>s[t, c] = x₁[t, c] + x₂[t, c] + … + xₖ[t, c]</code></p>
<p>其中 <code>t</code> 是采样点，<code>c</code> 是声道，<code>k</code> 是参与混音的流数。WebRTC 在 <code>FrameCombiner</code> 中把 16 位输入转换到 <code>FloatS16</code> 浮点缓冲区逐样本累加，再转换回 16 位 PCM。浮点缓冲区允许中间和超过 32767，避免<strong>在累加途中</strong>就溢出；它本身没有解决<strong>最终输出</strong>的削顶问题。<a href="https://webrtc.googlesource.com/src/&#43;/c8bca1867efcbc5f52adf58ad4463088ed257aa0/modules/audio_mixer/frame_combiner.cc">求和实现</a> · <a href="https://webrtc.googlesource.com/src/&#43;/c8bca1867efcbc5f52adf58ad4463088ed257aa0/common_audio/include/audio_util.h"><code>FloatS16ToS16</code></a></p>
<h3 id="limiter-怎样压住叠加后的峰值">Limiter 怎样压住叠加后的峰值</h3>

<div class="mermaid">flowchart LR
    A[&#34;已求和的浮点音频&lt;br/&gt;可超出 ±32768&#34;] --&gt; B[&#34;10 ms 切成 20 段&lt;br/&gt;每段 0.5 ms&#34;]
    B --&gt; C[&#34;估计所有声道的最大绝对值&lt;br/&gt;上升快、下降慢&#34;]
    C --&gt; D[&#34;查增益曲线&lt;br/&gt;低电平保持 1，高电平降低增益&#34;]
    D --&gt; E[&#34;逐样本插值增益&lt;br/&gt;所有声道共用&#34;]
    E --&gt; F[&#34;硬钳制到 16 位范围&lt;br/&gt;输出 PCM&#34;]</div>
<p>Limiter 使用的是<strong>峰值估计</strong>，不是说话人数，也不是平均音量。估计器将 10 ms 帧分成 20 个子帧，在所有声道中取最大绝对值；峰值升高时迅速响应，降低时约按 20 ms 衰减 1 dB。增益曲线在约 −0.75 dBFS 以下保持原样，接着通过软拐点逐渐压低；高电平区使用约 5:1 的压缩关系。目标增益在子帧间逐样本插值，所有声道共用同一增益，避免声道间电平比例突然变化。<a href="https://webrtc.googlesource.com/src/&#43;/c8bca1867efcbc5f52adf58ad4463088ed257aa0/modules/audio_processing/agc2/fixed_digital_level_estimator.cc"><code>FixedDigitalLevelEstimator</code></a> · <a href="https://webrtc.googlesource.com/src/&#43;/c8bca1867efcbc5f52adf58ad4463088ed257aa0/modules/audio_processing/agc2/interpolated_gain_curve.cc"><code>InterpolatedGainCurve</code></a> · <a href="https://webrtc.googlesource.com/src/&#43;/c8bca1867efcbc5f52adf58ad4463088ed257aa0/modules/audio_processing/agc2/limiter.cc"><code>Limiter</code></a></p>
<h3 id="attack--decay让峰值估计快升慢降">Attack / decay：让峰值估计快升慢降</h3>
<p>Attack / decay 是控制状态量变化速度的常用方法：根据新观测值相对旧状态的变化方向，选择不同的平滑系数。<strong>具体哪一方向要快，取决于控制目标。</strong> Limiter 要及时抑制突发峰值，所以峰值估计采用“快速上升、缓慢下降”；高峰过去后，目标增益才逐渐恢复，避免声音忽大忽小。</p>
<p><code>FixedDigitalLevelEstimator::ComputeLevel()</code> 先在每个 0.5 ms 子帧、所有声道中取最大绝对样本值 <code>x</code>，再用上一子帧的估计值 <code>y_prev</code> 更新包络：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt">1
</span><span class="lnt">2
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">x &gt; y_prev（attack）: y = x                          // 系数为 0，立即跟随峰值
</span></span><span class="line"><span class="cl">x ≤ y_prev（decay） : y = 0.0028741 × x + 0.9971259 × y_prev</span></span></code></pre></td></tr></table>
</div>
</div>
<p>下降系数 <code>0.9971259</code> 每 0.5 ms 应用一次；<strong>当输入降为零</strong>，估计值约每 20 ms 下降 1 dB。若输入只是变小而非归零，估计值会向新的电平靠近，下降速度不能简单等同于 1 dB / 20 ms。<code>filter_state_level_</code> 会把估计状态延续到下一子帧、下一次 <code>Process()</code> 调用。<a href="https://webrtc.googlesource.com/src/&#43;/c8bca1867efcbc5f52adf58ad4463088ed257aa0/modules/audio_processing/agc2/fixed_digital_level_estimator.cc">电平估计与系数</a></p>
<p><img alt="Limiter 的峰值估计在 attack 阶段迅速上升、decay 阶段缓慢下降" loading="lazy" src="/images/2026-11/webrtc-audio-limiter-attack-decay.svg"></p>
<p>图中橙线是输入子帧的峰值，蓝线是平滑后的估计值。代码还会把<strong>相邻下一子帧更高的峰值提前一个子帧</strong>，让后续增益插值更早开始下降；图中的 0.5 ms 提前量在整张时间图上几乎不可见。这不是跨 10 ms 帧的预读，也不能保证突发峰值完全没有削顶。注意图示的是<strong>电平估计</strong>：估计值上升时目标增益下降，估计值缓慢回落时目标增益才缓慢上升；真正施加到音频样本上的增益还会在 <a href="https://webrtc.googlesource.com/src/&#43;/c8bca1867efcbc5f52adf58ad4463088ed257aa0/modules/audio_processing/agc2/limiter.cc"><code>ComputePerSampleSubframeFactors()</code></a> 中逐样本插值。</p>
<p>同样的非对称平滑也用于 WebRTC 其他音频控制环节，例如 AGC2 的<a href="https://webrtc.googlesource.com/src/&#43;/c8bca1867efcbc5f52adf58ad4463088ed257aa0/modules/audio_processing/agc2/saturation_protector.cc">饱和保护器</a>根据峰值余量的变化选用不同系数；<a href="https://webrtc.googlesource.com/src/&#43;/c8bca1867efcbc5f52adf58ad4463088ed257aa0/modules/audio_processing/agc2/noise_level_estimator.cc">噪声底估计器</a>则是慢升、快降。它们都采用按方向调整响应速度的思路，但系数和目标不同。</p>
<h3 id="两路音频相加后的波形示例">两路音频相加后的波形示例</h3>
<p>假设 A、B 是同相的正弦波，各自峰值为 <code>20000</code>。浮点求和后，峰值变为 <code>40000</code>，已越过 16 位 PCM 的 <code>+32767</code> 上限。下图四条轨道使用<strong>相同的纵向比例</strong>，便于直接比较波形高度。</p>
<p><img alt="两路同相音频先求和再限幅的波形示例" loading="lazy" src="/images/2026-11/webrtc-audio-mixing-example.svg"></p>
<p>在这种<strong>持续高电平、增益已稳定</strong>的例子中，<code>40000</code> 超过增益曲线约 <code>+1 dBFS</code> 的最高输入区间，因此目标增益约为 <code>32768 / 40000 ≈ 0.819</code>。Limiter 把这个增益施加到整个混音波形，再将结果钳制为 16 位范围；图中绿色波形的峰值约为 <code>32767</code>。红色虚线表示若直接把 <code>40000</code> 的波形硬截断，超出范围的部分会被削成平顶。实际实现会按 0.5 ms 子帧估计电平，并在子帧间逐样本平滑增益，因此输入刚变大时的输出不会立刻等同于图中的稳定状态。<a href="https://webrtc.googlesource.com/src/&#43;/c8bca1867efcbc5f52adf58ad4463088ed257aa0/modules/audio_processing/agc2/interpolated_gain_curve.cc">增益曲线超上限分支</a> · <a href="https://webrtc.googlesource.com/src/&#43;/c8bca1867efcbc5f52adf58ad4463088ed257aa0/modules/audio_processing/agc2/limiter.cc">增益插值与钳制</a></p>
<p>Limiter 不能保证完全没有削顶：它没有整帧预读的 look-ahead，突发峰值的最初几个样本可能在增益降下来前被最终的硬钳制截断。它解决的是多路音频相加时的<strong>常见电平过高问题</strong>，不是对每路说话人做响度均衡。<a href="https://webrtc.googlesource.com/src/&#43;/c8bca1867efcbc5f52adf58ad4463088ed257aa0/modules/audio_processing/agc2/limiter.cc"><code>Limiter::ScaleSamples</code></a></p>
<h3 id="三种实现放在同一个例子里">三种实现放在同一个例子里</h3>
<p>假设有两路单声道音频，输出是 16 位 PCM。先看一个采样时刻：A 与 B <strong>同相位</strong>，各为 <code>20000</code>；再看只有 A 发声、B 静音的时刻。下表中的 Limiter 数值指<strong>稳定高电平后的近似结果</strong>，不代表突发峰值第一样本的保证值。</p>

<div class="mermaid">flowchart LR
    X[&#34;同声：A=20000，B=20000&lt;br/&gt;原始和=40000&#34;] --&gt; D[&#34;直接求和&lt;br/&gt;最终截断为 32767&#34;]
    X --&gt; N[&#34;固定按 2 路平均&lt;br/&gt;40000 / 2 = 20000&#34;]
    X --&gt; L[&#34;求和 &#43; Limiter&lt;br/&gt;峰值附近降低增益，约 32767&#34;]
    Y[&#34;单声：A=20000，B=0&#34;] --&gt; D2[&#34;直接求和&lt;br/&gt;20000&#34;]
    Y --&gt; N2[&#34;固定按 2 路平均&lt;br/&gt;10000&#34;]
    Y --&gt; L2[&#34;求和 &#43; Limiter&lt;br/&gt;通常保持约 20000&#34;]</div>
<table>
	<thead>
			<tr>
					<th>方法</th>
					<th>两路同时较响</th>
					<th>只有一路发声</th>
					<th>主要取舍</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>直接求和，输出时硬截断</td>
					<td>超过 16 位范围的波峰被削平，出现谐波失真</td>
					<td>保留原音量</td>
					<td>实现最简单，但多路同声时听感风险最高</td>
			</tr>
			<tr>
					<td>固定按人数归一化：<code>(A+B)/N</code></td>
					<td>峰值容易控制</td>
					<td>若 <code>N=2</code>，单人也被压低 6 dB 左右</td>
					<td>电平界限直观，却牺牲单人音量；按活跃人数调整又需要平滑切换</td>
			</tr>
			<tr>
					<td>WebRTC 默认：浮点求和 + Limiter</td>
					<td>按实际混音峰值降低增益，减少持续削顶</td>
					<td>低电平通常不衰减</td>
					<td>保留单人响度，同时应对同声峰值；高电平时有动态压缩和少量处理开销</td>
			</tr>
	</tbody>
</table>
<p>固定按人数平均对“所有输入都在同一时刻取最大同号样本”的情况确实稳妥，但人数越多，只有一个人说话时就越轻。若改为按<strong>活跃</strong>人数平均，加入、静音、退出会改变分母：两人说话时 A 的增益为 <code>1/2</code>，B 刚停止后 A 的增益变为 <code>1</code>，如果不做渐变就会突然增大。直接求和没有这个音量跳变，却要承受峰值硬截断。</p>
<p>WebRTC 因而把控制量放在<strong>实际叠加后的峰值</strong>上：低电平保留，峰值逼近上限时逐渐压低，并通过插值减少增益突变。这是从源码行为作出的工程解释，不是官方关于历史选型的原话。它也不排斥业务层先给某一路设置音量：例如主持人声音高于背景音乐时，仍应先调每路增益，再让 Limiter 处理最终峰值。<a href="https://webrtc.googlesource.com/src/&#43;/c8bca1867efcbc5f52adf58ad4463088ed257aa0/audio/audio_receive_stream.cc">接收流增益入口</a></p>
<p><strong>总结：</strong> WebRTC 默认混音器为实时播放提供了一条清晰的基线：逐路 NetEQ 取音频、统一格式、浮点相加、限制峰值、交给设备播放。它优先保持单人讲话的自然音量，并控制多人同时发声时的失真；多人持续高声、音乐混音或空间音频等场景，仍需结合逐路增益、声道布局和主观听感进一步设计。</p>]]></content:encoded>
    </item>
    <item>
      <title>WebRTC 音频丢包恢复：NetEQ、Opus FEC、NACK 与 PLC 如何协作</title>
      <link>https://lyapple2008.github.io/posts/202611/2026-11-05-webrtc%E4%B8%AD%E9%9F%B3%E9%A2%91%E4%B8%A2%E5%8C%85%E6%81%A2%E5%A4%8D/</link>
      <pubDate>Thu, 05 Nov 2026 20:18:58 +0800</pubDate>
      <guid>https://lyapple2008.github.io/posts/202611/2026-11-05-webrtc%E4%B8%AD%E9%9F%B3%E9%A2%91%E4%B8%A2%E5%8C%85%E6%81%A2%E5%A4%8D/</guid>
      <description>&lt;p&gt;视频丢一帧，画面可能短暂卡住；语音丢掉一个承载 20 ms 音频的包，则可能吞掉一个关键的辅音片段。接收端还必须按时向扬声器交付 PCM：原包即使最终到了，错过播放时刻也无法补回已经听到的声音。&lt;/p&gt;
&lt;p&gt;所以讨论音频丢包恢复，先要问：&lt;strong&gt;缺失的音频在播放截止时间前，究竟还有没有机会拿到？&lt;/strong&gt; 有机会，就争取拿到编码数据；没有机会，就生成一段连续的替代声音。本文以本地 WebRTC 源码提交 &lt;code&gt;c8bca1867efcbc5f52adf58ad4463088ed257aa0&lt;/code&gt;（2026-10-22）为基线，说明这些选择如何落到 WebRTC 的音频链路中。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p>视频丢一帧，画面可能短暂卡住；语音丢掉一个承载 20 ms 音频的包，则可能吞掉一个关键的辅音片段。接收端还必须按时向扬声器交付 PCM：原包即使最终到了，错过播放时刻也无法补回已经听到的声音。</p>
<p>所以讨论音频丢包恢复，先要问：<strong>缺失的音频在播放截止时间前，究竟还有没有机会拿到？</strong> 有机会，就争取拿到编码数据；没有机会，就生成一段连续的替代声音。本文以本地 WebRTC 源码提交 <code>c8bca1867efcbc5f52adf58ad4463088ed257aa0</code>（2026-10-22）为基线，说明这些选择如何落到 WebRTC 的音频链路中。</p>
<h2 id="一丢包造成的并不只是少了一个-rtp-包">一、丢包造成的并不只是“少了一个 RTP 包”</h2>
<p>假设每包承载 20 ms 音频，P2 没有按时到达：</p>

<div class="mermaid">flowchart LR
    P1[&#34;P1：0～20 ms&lt;br/&gt;按时到达&#34;] --&gt; P2[&#34;P2：20～40 ms&lt;br/&gt;暂时缺失&#34;] --&gt; P3[&#34;P3：40～60 ms&lt;br/&gt;按时到达&#34;]
    P2 --&gt; D{&#34;P2 播放截止前&lt;br/&gt;能取得可用数据吗？&#34;}
    D --&gt;|&#34;原包或及时重传&#34;| A[&#34;正常解码 P2&#34;]
    D --&gt;|&#34;P3 携带可用冗余&#34;| B[&#34;FEC / RED 恢复 P2&#34;]
    D --&gt;|&#34;都没有&#34;| C[&#34;PLC 生成替代音频&#34;]</div>
<p><strong>序号缺口不等于永久丢包。</strong> P2 可能只是乱序或延迟；如果它在截止前进入接收缓冲，仍可正常播放。真正影响听感的是截止时仍没有可用音频。短缺口会损伤辅音、爆破音或瞬态；连续缺口会让预测逐渐失真，出现机械音、音量衰减甚至静音。长包虽减少包头开销，丢一包时缺失的时间也更长。</p>
<p>接收端为了等待乱序包，可以提高抖动缓冲的目标延迟；代价是整条通话更慢。<strong>缓冲只能把“迟到但仍赶得上”的包变为可用，无法凭空恢复真正丢失的数据。</strong></p>
<h2 id="二先看-webrtc-的实际接收链路">二、先看 WebRTC 的实际接收链路</h2>

<div class="mermaid">flowchart LR
    S[&#34;发送端 Opus 编码&lt;br/&gt;可选择带内 FEC / RED&#34;] --&gt; R[&#34;RTP 网络&lt;br/&gt;乱序、延迟、丢失&#34;]
    R --&gt; N[&#34;接收端 NetEQ&lt;br/&gt;排序、缓冲、目标延迟&#34;]
    N --&gt; X{&#34;取音频时&lt;br/&gt;该时间段有可用帧？&#34;}
    X --&gt;|有| Y[&#34;正常帧或冗余帧解码&#34;]
    X --&gt;|无| Z[&#34;生成隐藏音频&lt;br/&gt;Expand / 可选 codec PLC&#34;]
    Y --&gt; O[&#34;PCM → 播放&#34;]
    Z --&gt; O
    R -.-&gt;|&#34;检测序号缺口；配置允许时发 NACK&#34;| Q[&#34;RTCP 反馈 → 发送端补发&#34;]
    Q -.-&gt;|&#34;赶上截止时间才有用&#34;| N</div>
<p>NetEQ 不只是一个固定长度的队列。它根据到达情况调整目标延迟，在播放端请求音频时选择正常解码、时间伸缩、丢包隐藏和恢复后的拼接。缓冲偏多时可以加速消耗，偏少时可以预先拉伸；缺帧时执行 <code>Expand</code>，下一段正常音频到来后可能执行 <code>Merge</code>，让接缝不那么突兀。这些操作由 <a href="https://webrtc.googlesource.com/src/&#43;/c8bca1867efcbc5f52adf58ad4463088ed257aa0/modules/audio_coding/neteq/decision_logic.cc">NetEQ 决策逻辑</a> 和 <a href="https://webrtc.googlesource.com/src/&#43;/c8bca1867efcbc5f52adf58ad4463088ed257aa0/modules/audio_coding/neteq/neteq_impl.cc">NetEQ 主实现</a> 共同完成。</p>
<p>发送端也能根据网络状况调整 Opus 码率、包时长和 FEC，但音频网络适配器（ANA）的控制策略需要启用并配置。降低码率可能缓解拥塞，却会牺牲编码质量；缩短包时长能缩短单次丢失的声音缺口，却增加每秒的包数与包头开销。这些措施改变的是后续丢包风险和恢复条件，不会把已经丢失的原始音频找回来。<a href="https://webrtc.googlesource.com/src/&#43;/c8bca1867efcbc5f52adf58ad4463088ed257aa0/modules/audio_coding/codecs/opus/audio_encoder_opus.cc">Opus 编码器适配层</a>包含相关控制入口。</p>
<p>这里有一个容易误解的区别：<strong>libopus 有 PLC，并不表示 WebRTC 默认总是调用 Opus 的 PLC。</strong> 在本文源码基线中，<code>AudioDecoderOpusImpl::GeneratePlc</code> 受 <code>WebRTC-Audio-OpusGeneratePlc</code> field trial 控制；未启用时它不产出音频，NetEQ 转用自己的 <code>Expand</code>。启用后，NetEQ 才可能向 Opus 解码器请求 PLC。依据见 <a href="https://webrtc.googlesource.com/src/&#43;/c8bca1867efcbc5f52adf58ad4463088ed257aa0/modules/audio_coding/codecs/opus/audio_decoder_opus.cc">Opus 解码器适配层</a> 的 <code>GeneratePlc</code> 和 NetEQ 的 <code>DoCodecPlc</code>。</p>
<h2 id="三fec提前付带宽换一次及时恢复的机会">三、FEC：提前付带宽，换一次及时恢复的机会</h2>
<h3 id="opus-带内-fec下一包带上一段语音的低码率冗余">Opus 带内 FEC：下一包带上一段语音的低码率冗余</h3>
<p>Opus 在合适的编码模式和网络条件下，可以把前一段语音的低码率冗余放进后续包。这种冗余通常称为 SILK LBRR。它不是前一包的字节副本，恢复音质也不必然等同于原包。</p>

<div class="mermaid">flowchart LR
    A[&#34;P1：语音 A&#34;] --&gt; B[&#34;P2：语音 B&lt;br/&gt;＋ A 的 LBRR&#34;] --&gt; C[&#34;P3：语音 C&lt;br/&gt;＋ B 的 LBRR&#34;]
    A -.-&gt;|&#34;网络丢失 P1&#34;| L[&#34;A 缺失&#34;]
    B --&gt;|&#34;P2 在 A 截止前到达&#34;| F[&#34;先用 P2 冗余解 A&lt;br/&gt;再正常解 B&#34;]
    L --&gt; F</div>
<p>图是“一包 20 ms、一包一段语音”的教学例子。要救 A，P2 必须到达、确实携带可用冗余，而且接收端要留出等待时间；不能把“打开 FEC”直接等同于“每次丢包都能恢复”。WebRTC 的 Opus 解码器会在发现 FEC 时，把冗余帧以较早的时间戳交给 NetEQ，再交入当前主帧；NetEQ 按播放时间和帧优先级选用。<a href="https://webrtc.googlesource.com/src/&#43;/c8bca1867efcbc5f52adf58ad4463088ed257aa0/modules/audio_coding/codecs/opus/audio_decoder_opus.cc">解析路径</a>可见 <code>ParsePayload</code> 和 <code>DecodeRedundantInternal</code>。</p>
<p>发送端需要协商接收能力，并允许编码器生成 FEC。WebRTC 的 <code>SetFec</code> 允许 Opus 使用带内 FEC，损失估计也会传给编码器；最终是否写入冗余，仍取决于码率、模式和内容。SILK 或 Hybrid 可利用这一路径；CELT-only 不应被假定有同样的 LBRR。参见 <a href="https://www.rfc-editor.org/rfc/rfc7587.html#section-3.3">RFC 7587 §3.3</a>和 <a href="https://webrtc.googlesource.com/src/&#43;/c8bca1867efcbc5f52adf58ad4463088ed257aa0/modules/audio_coding/codecs/opus/audio_encoder_opus.cc">WebRTC Opus 编码器适配层</a>。</p>
<h3 id="rtp-red复制以前的编码块">RTP RED：复制以前的编码块</h3>
<p>RED 是 <a href="https://www.rfc-editor.org/rfc/rfc2198.html">RFC 2198</a> 定义的冗余负载封装格式，不是一套纠错算法。本文源码中的 <code>AudioEncoderCopyRed</code> 通常把上一份已编码音频连同当前音频装入新包；默认保留一层冗余，配置可改变层数。若原包丢失而后续 RED 包及时到达，可以拿到原先的编码块。相比 Opus LBRR，这种复制可能更接近原包内容，但常常消耗更多带宽，并受包大小、时间戳跨度和协商结果限制。依据见 <a href="https://webrtc.googlesource.com/src/&#43;/c8bca1867efcbc5f52adf58ad4463088ed257aa0/modules/audio_coding/codecs/red/audio_encoder_copy_red.cc">RED 编码器</a> 和 <a href="https://webrtc.googlesource.com/src/&#43;/c8bca1867efcbc5f52adf58ad4463088ed257aa0/modules/audio_coding/neteq/red_payload_splitter.cc">NetEQ RED 拆包</a>。</p>
<p>前一篇参考资料中讲的 ULPFEC、FlexFEC 属于 RTP 包级保护机制；<strong>不能因为 RED、ULPFEC 和 Opus FEC 都带有“冗余”，就认为音频通话会自动同时启用它们。</strong> 本文的音频实用路径重点是 Opus 带内 FEC 与协商后的音频 RED。</p>
<h2 id="四nack能拿回原包但要赶上播放时刻">四、NACK：能拿回原包，但要赶上播放时刻</h2>
<p>接收端看到序号缺口后，可通过 RTCP NACK 请求补发；发送端必须还保留原包，并且补发流量没有被限制。这里的耗时可以粗略写为：</p>
<p><code>恢复耗时 ≈ 发现缺口与反馈等待 ＋ 反馈上行 ＋ 发送端排队 ＋ 补发下行</code></p>
<p>网络路径近似对称时，两段传播之和常用 RTT 估算，但排队与反馈等待还要另算。如果距播放截止只剩 30 ms，RTT 却有 100 ms，补发包即使最终到达，也难以改善这一刻的声音。RTT 小、缓冲较充足时，NACK 对孤立丢包更有价值；大 RTT 或连续丢包时，反复补发还可能挤占新音频的带宽。</p>
<p>本文基线的音频接收端确实有 NACK 路径：<code>ChannelReceive::OnRtpPacket</code> 调用 <code>NackTracker</code> 找缺口并发送反馈；发送端从历史缓存取包并排队补发。但该路径受协商与 NACK 历史配置控制，<code>NackTracker</code> 的筛选也不等于对每个包精确计算扬声器的播放截止时间。依据见 <a href="https://webrtc.googlesource.com/src/&#43;/c8bca1867efcbc5f52adf58ad4463088ed257aa0/audio/channel_receive.cc">接收端</a>、<a href="https://webrtc.googlesource.com/src/&#43;/c8bca1867efcbc5f52adf58ad4463088ed257aa0/audio/nack_tracker.cc">NackTracker</a> 和 <a href="https://webrtc.googlesource.com/src/&#43;/c8bca1867efcbc5f52adf58ad4463088ed257aa0/modules/rtp_rtcp/source/rtp_sender.cc">发送端补发</a>。</p>
<p>NACK 与 FEC 不是必须排成“先等 NACK、再尝试 FEC”的串行流水线。NACK 反馈可以在接收包时发出，冗余帧和补发的原帧则可能先后进入 NetEQ；<strong>到播放时刻，谁及时且可用，谁才有机会被采用。</strong></p>
<h2 id="五plc数据来不及就尽量把声音接起来">五、PLC：数据来不及，就尽量把声音接起来</h2>
<p>PLC（Packet Loss Concealment）不会复原未知的原始语音，而是根据已解码的历史生成替代音频。独立使用 libopus 时，传入空包可触发 Opus PLC：SILK 侧使用语音预测、基音和激励状态；CELT 侧会依据历史波形与频谱状态处理短缺口，较长丢失转向噪声和能量衰减。具体策略因编码模式和连续丢失长度而变。<a href="https://www.rfc-editor.org/rfc/rfc6716.html#section-4.4">RFC 6716 §4.4</a>描述了 Opus 的丢包隐藏。</p>
<p>WebRTC 默认的 NetEQ <code>Expand</code> 同样从解码后的历史音频外推，并在连续缺口中逐渐衰减；恢复正常帧时通过 <code>Merge</code> 平滑衔接。它不需要额外传输数据，因而是截止前没有可用包时的兜底，但对爆破音、说话人突然转变、音乐瞬态和长时间连续丢包都没有“猜中原声”的保证。参见 <a href="https://webrtc.googlesource.com/src/&#43;/c8bca1867efcbc5f52adf58ad4463088ed257aa0/modules/audio_coding/neteq/expand.h">Expand</a> 与 <a href="https://webrtc.googlesource.com/src/&#43;/c8bca1867efcbc5f52adf58ad4463088ed257aa0/modules/audio_coding/neteq/merge.h">Merge</a>。</p>
<h2 id="六把方案放在同一张表里比较">六、把方案放在同一张表里比较</h2>
<table>
	<thead>
			<tr>
					<th>机制</th>
					<th>获得的内容</th>
					<th>主要代价</th>
					<th>更合适的条件</th>
					<th>主要限制</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>NetEQ 抖动缓冲</td>
					<td>迟到、乱序的原包</td>
					<td>增加播放延迟</td>
					<td>抖动明显，仍能赶上截止</td>
					<td>不能修复真正丢失的包</td>
			</tr>
			<tr>
					<td>Opus 带内 FEC</td>
					<td>前一段语音的低码率冗余</td>
					<td>持续带宽，等待后包</td>
					<td>中等丢包、后包通常能到、可容忍一段等待</td>
					<td>不保证每包有冗余；连续丢包效果差</td>
			</tr>
			<tr>
					<td>音频 RED</td>
					<td>以前编码块的副本</td>
					<td>较高的带宽与包长</td>
					<td>可用带宽较充足，想提高原数据可用率</td>
					<td>后包也丢或超时就无效</td>
			</tr>
			<tr>
					<td>NACK 重传</td>
					<td>原编码包</td>
					<td>反馈和补发流量、RTT</td>
					<td>RTT 较小、缓冲有余量、偶发丢包</td>
					<td>过期补发无法改善实时播放</td>
			</tr>
			<tr>
					<td>PLC / Expand</td>
					<td>估计的替代 PCM</td>
					<td>无额外网络带宽</td>
					<td>低延迟要求高，或前面方法都未赶上</td>
					<td>无法还原原声，连续丢包听感下降</td>
			</tr>
	</tbody>
</table>
<p>这张表比较的是机制，不是某种固定优先级。实际效果受协商、码率、包时长、RTT、抖动分布与播放目标延迟共同影响。FEC、RED 和 NACK 的开销都要算进<strong>总发送预算</strong>；链路已经拥塞时，盲目叠加冗余可能使新包也丢失。</p>
<h2 id="七按场景组合而不是寻找一个万能开关">七、按场景组合，而不是寻找一个万能开关</h2>

<div class="mermaid">flowchart TD
    A[&#34;先测 RTT、抖动、独立/突发丢包&lt;br/&gt;以及播放目标延迟&#34;] --&gt; B{&#34;主要是乱序、迟到？&#34;}
    B --&gt;|是| C[&#34;调整 NetEQ 延迟目标&lt;br/&gt;检查迟到包比例&#34;]
    B --&gt;|否| D{&#34;RTT 和剩余播放预算&lt;br/&gt;允许重传吗？&#34;}
    D --&gt;|允许| E[&#34;协商音频 NACK&lt;br/&gt;观察补发是否真正被播放&#34;]
    D --&gt;|不允许| F[&#34;评估 Opus 带内 FEC&lt;br/&gt;或协商音频 RED&#34;]
    C --&gt; G[&#34;所有路径最终仍需 PLC 兜底&#34;]
    E --&gt; G
    F --&gt; G</div>
<ul>
<li><strong>低延迟语音通话、RTT 较大</strong>：先控制编码包时长与播放延迟；若带宽允许，评估 Opus 带内 FEC。剩余缺口交给 PLC。不要为了等遥远的重传而无限拉长缓冲。</li>
<li><strong>近距离网络、偶发孤立丢包</strong>：NACK 可能在截止前拿回原包；仍要观察补发的到达时间，而不只看 NACK 数量。</li>
<li><strong>连续突发丢包</strong>：依赖下一包的单层冗余经常一起失效。可以评估多层 RED 或其他保护设计，但会增加带宽与等待；同时应检查拥塞和发送码率，避免把网络问题仅当成解码问题。</li>
<li><strong>音乐或高质量音频</strong>：CELT-only 场景不能照搬 SILK LBRR 的收益预期。若音质比带宽更重要，可评估适当冗余与缓冲；瞬态被 PLC 预测错误时，主观听感仍可能明显下降。</li>
</ul>
<p>验证时，除了网络丢包率，还要记录 NetEQ 的 <code>concealedSamples</code>、<code>concealmentEvents</code>、<code>fecPacketsReceived</code>、<code>fecPacketsDiscarded</code>、缓冲延迟、NACK 数量，以及补发包是否在截止前真正被解码播放。<a href="https://webrtc.googlesource.com/src/&#43;/c8bca1867efcbc5f52adf58ad4463088ed257aa0/audio/audio_receive_stream.cc">WebRTC 接收统计映射</a>包含这些接收侧指标。收到冗余包不等于成功用它恢复声音，发出 NACK 也不等于补发赶上了播放。测试应分别注入孤立丢包、连续丢包和纯延迟抖动，并在相同总码率与端到端延迟约束下比较听感；否则多花的带宽或多等的时间会被误认为恢复算法更好。</p>
<p>归根结底，WebRTC 的音频恢复是一场与播放截止时间的赛跑：NetEQ 尽量给原包、冗余和补发创造机会；来不及的部分由 PLC 保住连续性。<strong>恢复率、实时性和带宽必须一起看。</strong></p>]]></content:encoded>
    </item>
    <item>
      <title>WebRTC 音频设备管理：从双向数据流到跨平台实现</title>
      <link>https://lyapple2008.github.io/posts/202610/2026-10-25-webrtc%E9%9F%B3%E9%A2%91%E8%AE%BE%E5%A4%87%E7%AE%A1%E7%90%86/</link>
      <pubDate>Sun, 25 Oct 2026 15:28:43 +0800</pubDate>
      <guid>https://lyapple2008.github.io/posts/202610/2026-10-25-webrtc%E9%9F%B3%E9%A2%91%E8%AE%BE%E5%A4%87%E7%AE%A1%E7%90%86/</guid>
      <description>&lt;p&gt;麦克风把声音变成 PCM，扬声器把 PCM 变回声音。对一个实时通话系统来说，这两句话之间还有很多事情：选择设备、协商格式、启动音频流、适应设备回调的节奏，以及在耳机拔出、来电中断后恢复工作。&lt;/p&gt;
&lt;p&gt;WebRTC 把这些工作集中在 &lt;strong&gt;Audio Device Module，简称 ADM&lt;/strong&gt;。理解它，最好先建立整体位置，再沿着音频数据走一遍，最后进入代码和平台实现。否则很容易把“设备缓冲”“网络抖动缓冲”和“回声消除”混成一件事。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;本文以本地 &lt;code&gt;webrtc_src&lt;/code&gt; 的提交 &lt;code&gt;3dec7d05377fb690e84f503db865edde982ab2a5&lt;/code&gt; 为源码基线，提交日期为 2026-10-23。正文主要讨论使用内置设备模块的 native 音频路径；浏览器或业务方可以注入自己的 ADM，复用这里的接口而采用不同的数据通路。文中的源码链接固定到该提交，代码片段会标明是否经过简化。&lt;/p&gt;
&lt;/blockquote&gt;</description>
      <content:encoded><![CDATA[<p>麦克风把声音变成 PCM，扬声器把 PCM 变回声音。对一个实时通话系统来说，这两句话之间还有很多事情：选择设备、协商格式、启动音频流、适应设备回调的节奏，以及在耳机拔出、来电中断后恢复工作。</p>
<p>WebRTC 把这些工作集中在 <strong>Audio Device Module，简称 ADM</strong>。理解它，最好先建立整体位置，再沿着音频数据走一遍，最后进入代码和平台实现。否则很容易把“设备缓冲”“网络抖动缓冲”和“回声消除”混成一件事。</p>
<blockquote>
<p>本文以本地 <code>webrtc_src</code> 的提交 <code>3dec7d05377fb690e84f503db865edde982ab2a5</code> 为源码基线，提交日期为 2026-10-23。正文主要讨论使用内置设备模块的 native 音频路径；浏览器或业务方可以注入自己的 ADM，复用这里的接口而采用不同的数据通路。文中的源码链接固定到该提交，代码片段会标明是否经过简化。</p>
</blockquote>
<h2 id="一整体视角adm-是-webrtc-与操作系统音频-io-的边界">一、整体视角：ADM 是 WebRTC 与操作系统音频 I/O 的边界</h2>
<h3 id="11-它在整个系统的什么位置">1.1 它在整个系统的什么位置</h3>
<p>可以把 WebRTC 的音频部分分成三个层次：最下面连接操作系统和设备，中间处理 PCM，上面处理编码后的数据和网络传输。</p>

<div class="mermaid">flowchart TB
    APP[&#34;应用与 PeerConnection：通话、轨道和配置&#34;]
    NET[&#34;网络传输：RTP / RTCP / 安全传输&#34;]
    CODEC[&#34;编解码与接收缓冲：编码器、解码器、NetEq&#34;]
    PCM[&#34;PCM 处理：APM、发送分发、接收混音&#34;]
    ADM[&#34;ADM：设备控制与双向 PCM 交接&#34;]
    OS[&#34;操作系统音频 API 与驱动&#34;]
    HW[&#34;麦克风、扬声器、耳机&#34;]
    APP -.-&gt;|&#34;配置与生命周期&#34;| ADM
    APP -.-&gt; CODEC
    NET &lt;--&gt;|&#34;压缩音频&#34;| CODEC
    CODEC &lt;--&gt;|&#34;PCM&#34;| PCM
    PCM &lt;--&gt;|&#34;PCM 与设备侧时序信息&#34;| ADM
    ADM &lt;--&gt; OS
    OS &lt;--&gt; HW</div>
<p>这张图表达的是职责边界，不代表所有对象都按这个顺序相互持有。</p>
<p>从上向下看，ADM 提供“准备并启停输入输出、获取和交付 PCM”的能力；从下向上看，它把不同系统的音频 API 适配成 WebRTC 能使用的接口。上层不必分别理解 WASAPI、CoreAudio、AudioRecord 或 AudioUnit。</p>
<h3 id="12-adm-管理哪些事情">1.2 ADM 管理哪些事情</h3>
<table>
	<thead>
			<tr>
					<th>职责</th>
					<th>解决的问题</th>
					<th>典型例子</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>设备与能力管理</td>
					<td>用哪个输入输出，支持什么能力</td>
					<td>枚举设备、选择默认设备、查询立体声和音量能力</td>
			</tr>
			<tr>
					<td>生命周期管理</td>
					<td>什么时候准备、开始、停止 I/O</td>
					<td>初始化模块，准备录音流，启动采集，停止播放</td>
			</tr>
			<tr>
					<td>PCM 交接与适配</td>
					<td>如何把系统缓冲交给 WebRTC</td>
					<td>格式转换、缓冲拼接、交付采集 PCM、请求播放 PCM</td>
			</tr>
			<tr>
					<td>设备侧时序与状态</td>
					<td>音频在设备侧停留多久，流是否正常</td>
					<td>播放/采集延迟、可选采集时间戳、欠载或中断处理</td>
			</tr>
	</tbody>
</table>
<p>这里的“ADM”有两种常见含义：狭义上指公共的 <code>AudioDeviceModule</code> 接口；广义上指接口实现、平台后端和缓冲适配组成的整个设备模块。后面说“ADM 适配设备回调”时，通常采用广义含义。</p>
<p>ADM 交付的是 PCM。降噪、回声消除等算法主要属于 <strong>APM（Audio Processing Module）</strong>；网络包的乱序、抖动与丢包补偿属于接收侧 <strong>NetEq</strong>；编码器负责把 PCM 压缩成待发送的音频。某些平台后端可以启用系统语音处理，但这不改变这些职责边界。</p>
<h2 id="二数据流视角一条向上推一条向下拉">二、数据流视角：一条向上推，一条向下拉</h2>
<p>这一节暂时忽略平台差异，只看各平台共同需要完成的事情。</p>
<h3 id="21-采集数据由麦克风驱动向发送链路推送">2.1 采集数据：由麦克风驱动，向发送链路推送</h3>
<p>用户说话时，操作系统不断提供新采集的音频。设备模块整理这些数据，向上层报告“这一段录音已经可用”，上层再进行处理和发送。</p>

<div class="mermaid">flowchart TB
    MIC[&#34;麦克风 / 系统输入缓冲&#34;]
    CAP[&#34;ADM：读取、格式适配、整理音频块&#34;]
    TRANS[&#34;音频运输桥接：接收采集 PCM&#34;]
    APM[&#34;APM：回声消除、降噪、增益等&#34;]
    DIST[&#34;向各个发送流分发处理后的 PCM&#34;]
    ENC[&#34;编码队列与编码器&#34;]
    RTP[&#34;RTP 发送链路&#34;]
    MIC --&gt;|&#34;新采集的数据&#34;| CAP
    CAP --&gt;|&#34;PCM、格式、延迟、可选时间戳&#34;| TRANS
    TRANS --&gt; APM --&gt; DIST --&gt; ENC --&gt; RTP</div>
<p>这是一种 <strong>push 模型</strong>：采集端产生数据，主动交付给上层。设备不会等编码器询问“你有没有新录音”。</p>
<p>在本文的默认路径中，同一份采集数据先经过公共 APM 处理，再向已注册的发送流分发；各发送流拥有自己的编码与发送过程。因此，“有多个发送流”不意味着每个流都重新打开一个麦克风。</p>
<h3 id="22-播放数据由设备需求驱动向接收链路拉取">2.2 播放数据：由设备需求驱动，向接收链路拉取</h3>
<p>播放的起点容易理解反了：网络包到达时，并不直接写进扬声器。网络到包是有抖动的，而扬声器需要按设备时钟持续消费音频。</p>
<p>接收链路先把到来的压缩音频放入 NetEq；当设备需要下一段播放数据时，再由播放调用链拉取音频、完成接收处理并混音。</p>

<div class="mermaid">flowchart TB
    PKT[&#34;远端 RTP 到包&#34;]
    NQ[&#34;各接收流的 NetEq：缓冲、按需解码与丢包补偿&#34;]
    SRC[&#34;各接收流提供 PCM&#34;]
    MIX[&#34;混音器：合成当前要播放的音频&#34;]
    OUT[&#34;音频运输桥接：播放侧处理与重采样&#34;]
    DEV[&#34;ADM：适配系统输出缓冲&#34;]
    SPK[&#34;系统输出 / 扬声器&#34;]
    PKT --&gt;|&#34;压缩载荷&#34;| NQ
    NQ --&gt;|&#34;被拉取时输出 PCM&#34;| SRC
    SRC --&gt; MIX --&gt; OUT --&gt; DEV --&gt; SPK
    DEV -.-&gt;|&#34;设备需要音频，向上请求&#34;| OUT
    OUT -.-&gt;|&#34;调用混音&#34;| MIX
    MIX -.-&gt;|&#34;逐个请求接收流&#34;| SRC
    SRC -.-&gt;|&#34;请求下一段音频&#34;| NQ</div>
<p>实线表示数据的交付方向，虚线表示播放需求的传播方向。<strong>播放数据向设备流动，播放请求向接收链路传播。</strong></p>
<p>这里的 <strong>pull 模型</strong> 是逻辑关系：有的平台由系统回调直接触发拉取，有的平台由后端工作线程提前填充本地缓冲。共同点是播放节奏最终受设备消费速度约束，而不是受网络到包时刻支配。</p>
<h3 id="23-为什么采集与播放还会在-apm-相遇">2.3 为什么采集与播放还会在 APM 相遇</h3>
<p>假设扬声器播放远端声音，麦克风又把它录了进去。若原样发送，远端就会听到自己的回声。AEC（Acoustic Echo Cancellation，声学回声消除）需要同时观察两类信号：</p>
<ul>
<li><strong>采集信号</strong>：麦克风录下的近端语音、噪声和回声。</li>
<li><strong>播放参考信号</strong>：本机准备播放的远端音频。</li>
</ul>

<div class="mermaid">flowchart TB
    MIX[&#34;远端音频混音结果&#34;]
    REF[&#34;APM 播放参考：reverse stream&#34;]
    SPK[&#34;设备输出 → 扬声器&#34;]
    ROOM[&#34;房间中的声学传播&#34;]
    MIC[&#34;麦克风采集：近端语音 &#43; 回声 &#43; 噪声&#34;]
    PROC[&#34;APM 采集处理：capture stream&#34;]
    SEND[&#34;处理后的语音 → 发送编码&#34;]
    MIX --&gt; SPK --&gt; ROOM --&gt; MIC --&gt; PROC --&gt; SEND
    MIX --&gt; REF
    REF -.-&gt;|&#34;AEC 参考&#34;| PROC
    DELAY[&#34;ADM 提供设备侧延迟估计&#34;] -.-&gt; PROC</div>
<p>因此，播放链路除了把音频送到设备，还会把混音结果送给 APM 的 reverse stream。采集侧再把设备侧延迟传给 APM，辅助对齐参考与录音。</p>
<p>这里的参考是<strong>设备输出之前的数字音频</strong>，并非从扬声器重新录回来的声音；ADM 提供的延迟也只是播放和采集的设备侧估计，不包含全部网络、NetEq 和编解码延迟。</p>
<h3 id="24-共同的数据契约16-bit-pcm-与-10-ms">2.4 共同的数据契约：16-bit PCM 与 10 ms</h3>
<p>在本文所讨论的 <code>AudioDeviceBuffer</code> → <code>AudioTransportImpl</code> 路径中，上下层主要交换 <strong>16-bit、交错存储的 PCM</strong>，每次处理 <strong>10 ms</strong>。交错双声道的排列是 <code>L0, R0, L1, R1, ...</code>。</p>
<p>以 48 kHz 为例：</p>
<table>
	<thead>
			<tr>
					<th>概念</th>
					<th>单声道的 10 ms</th>
					<th>双声道的 10 ms</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>每声道样本数 / PCM frame 数</td>
					<td>480</td>
					<td>480</td>
			</tr>
			<tr>
					<td>所有声道合计的标量样本数</td>
					<td>480</td>
					<td>960</td>
			</tr>
			<tr>
					<td>数据字节数，S16</td>
					<td>960</td>
					<td>1920</td>
			</tr>
	</tbody>
</table>
<p>这里一个 <strong>PCM frame</strong> 包含同一时刻所有声道的样本；它与源码中表示一整段音频的 <code>AudioFrame</code> 对象是两个概念。换成 16 kHz，10 ms 就是每声道 160 个样本，因此 10 ms 也不等于固定的 480 个样本。</p>
<p><strong>10 ms 是逻辑处理粒度，设备回调周期和编码包时长可以不同。</strong> 设备可能每次给 128、192 或其他数量的 PCM frame；编码器也可能积累两个 10 ms 输入，才产出一个 20 ms 的编码包。</p>
<p>以“48 kHz、单声道、每次设备回调 192 frame”为例，采集适配的过程可以是：</p>

<div class="mermaid">flowchart TB
    C1[&#34;回调 1：192 frame&#34;] --&gt; B1[&#34;累计 192：暂不交付&#34;]
    B1 --&gt; C2[&#34;回调 2：再来 192&#34;]
    C2 --&gt; B2[&#34;累计 384：暂不交付&#34;]
    B2 --&gt; C3[&#34;回调 3：再来 192&#34;]
    C3 --&gt; B3[&#34;累计 576&#34;]
    B3 --&gt; U[&#34;向上交付 480 frame = 10 ms&#34;]
    B3 --&gt; R[&#34;保留 96 frame，供下一轮拼接&#34;]</div>
<p>播放侧执行相反操作：先按 10 ms 向上层取数，再按设备本次需要的大小切出，保留余量。<code>FineAudioBuffer</code> 就是完成这种块长适配的工具之一；另一些后端自己实现累计、拆分或环形缓冲。</p>
<h2 id="三源码视角对象如何连接方法如何调用">三、源码视角：对象如何连接，方法如何调用</h2>
<h3 id="31-先分清六个核心角色">3.1 先分清六个核心角色</h3>
<table>
	<thead>
			<tr>
					<th>对象 / 接口</th>
					<th>主要责任</th>
					<th>需要避免的误解</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td><code>AudioDeviceModule</code></td>
					<td>面向上层的设备公共接口</td>
					<td>它不等于某一个平台实现类</td>
			</tr>
			<tr>
					<td>平台后端</td>
					<td>调用 OS API、操作设备流、完成本地缓冲适配</td>
					<td>各平台的线程和缓冲结构可以不同</td>
			</tr>
			<tr>
					<td><code>AudioDeviceBuffer</code>，ADB</td>
					<td>保存 PCM、采样率、声道、延迟等，调用运输回调</td>
					<td>它不会自动把任意输入拼成 10 ms</td>
			</tr>
			<tr>
					<td><code>FineAudioBuffer</code></td>
					<td>在任意设备块长与 10 ms 之间拆分、拼接</td>
					<td>它既不做网络抖动控制，也不负责重采样</td>
			</tr>
			<tr>
					<td><code>AudioTransport</code> / <code>AudioTransportImpl</code></td>
					<td>前者定义双向 PCM 回调，后者连接 APM、发送流和混音器</td>
					<td>这里的 Transport 不是网络传输</td>
			</tr>
			<tr>
					<td><code>AudioState</code></td>
					<td>协调 ADM、APM、混音器和收发流的公共状态</td>
					<td>音频 PCM 回调实际由其内部的 <code>AudioTransportImpl</code> 承接</td>
			</tr>
	</tbody>
</table>
<p>以通用 <code>AudioDeviceModuleImpl</code> 路径为例，对象关系如下。节点中合并标出接口与实现，箭头表示持有或调用关系，不表示单向音频流。</p>

<div class="mermaid">flowchart TB
    VE[&#34;WebRtcVoiceEngine&#34;]
    STATE[&#34;AudioState&#34;]
    IMPL[&#34;AudioDeviceModule 接口&lt;br/&gt;实现示例：AudioDeviceModuleImpl&#34;]
    BACK[&#34;平台后端&lt;br/&gt;AudioDeviceGeneric 的实现&#34;]
    ADB[&#34;AudioDeviceBuffer&#34;]
    FINE[&#34;FineAudioBuffer&lt;br/&gt;部分后端使用&#34;]
    TRANS[&#34;AudioTransportImpl&lt;br/&gt;实现 AudioTransport 接口&#34;]
    APM[&#34;AudioProcessing&#34;]
    MIX[&#34;AudioMixer&#34;]
    SEND[&#34;AudioSender / AudioSendStream&#34;]
    VE --&gt;|&#34;持有&#34;| STATE
    VE --&gt;|&#34;持有 ADM&#34;| IMPL
    STATE -.-&gt;|&#34;配置中共享 ADM&#34;| IMPL
    STATE --&gt;|&#34;内含&#34;| TRANS
    IMPL --&gt;|&#34;持有&#34;| BACK
    IMPL --&gt;|&#34;内含&#34;| ADB
    BACK --&gt;|&#34;直接使用或经适配&#34;| ADB
    BACK --&gt; FINE --&gt; ADB
    ADB --&gt;|&#34;注册的回调指针&#34;| TRANS
    TRANS --&gt;|&#34;调用&#34;| APM
    TRANS --&gt;|&#34;拉取&#34;| MIX
    TRANS --&gt;|&#34;分发&#34;| SEND</div>
<p>这张图只展开一种 ADM 的内部组织。Android 的组合式 ADM、iOS SDK 的 <code>AudioDeviceModuleIOS</code>、Windows 的另一套 Core Audio ADM，都可以直接实现同一个公共接口，不需要继承 <code>AudioDeviceModuleImpl</code>。</p>
<p>对应源码：<a href="https://webrtc.googlesource.com/src/&#43;/3dec7d05377fb690e84f503db865edde982ab2a5/api/audio/audio_device.h">ADM 公共接口</a>、<a href="https://webrtc.googlesource.com/src/&#43;/3dec7d05377fb690e84f503db865edde982ab2a5/modules/audio_device/audio_device_impl.cc">通用 ADM 实现</a>、<a href="https://webrtc.googlesource.com/src/&#43;/3dec7d05377fb690e84f503db865edde982ab2a5/audio/audio_state.cc">AudioState</a>。</p>
<h3 id="32-建立连接后端接入-adb再注册运输回调">3.2 建立连接：后端接入 ADB，再注册运输回调</h3>
<p>第一处连接发生在设备模块内部。通用工厂创建后端后，调用：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt">1
</span><span class="lnt">2
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-cpp" data-lang="cpp"><span class="line"><span class="cl"><span class="c1">// AudioDeviceModuleImpl::AttachAudioBuffer()，保留核心语句。
</span></span></span><span class="line"><span class="cl"><span class="n">audio_device_</span><span class="o">-&gt;</span><span class="n">AttachAudioBuffer</span><span class="p">(</span><span class="o">&amp;</span><span class="n">audio_device_buffer_</span><span class="p">);</span></span></span></code></pre></td></tr></table>
</div>
</div>
<p>这让平台后端知道应该向哪个 ADB 交付录音、从哪个 ADB 获取播放数据。</p>
<p>第二处连接发生在设备模块与音频引擎之间。<code>WebRtcVoiceEngine::Init()</code> 完成设备初始化和选项配置后，执行：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt">1
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-cpp" data-lang="cpp"><span class="line"><span class="cl"><span class="n">adm</span><span class="p">()</span><span class="o">-&gt;</span><span class="n">RegisterAudioCallback</span><span class="p">(</span><span class="n">audio_state</span><span class="p">()</span><span class="o">-&gt;</span><span class="n">audio_transport</span><span class="p">());</span></span></span></code></pre></td></tr></table>
</div>
</div>
<p><code>audio_transport()</code> 返回内部 <code>AudioTransportImpl</code> 的接口指针；通用 ADM 再把这个指针交给 <code>AudioDeviceBuffer::RegisterAudioCallback()</code>。至此，<strong>后端 ↔ ADB ↔ AudioTransportImpl</strong> 才连通。</p>
<p><code>AudioTransport</code> 是上层实现、下层调用的接口。尤其要注意：<code>NeedMorePlayData()</code> 虽然是“回调”，行为却是同步请求，上层要在返回前填好输出 PCM。</p>
<p>初始化路径见 <a href="https://webrtc.googlesource.com/src/&#43;/3dec7d05377fb690e84f503db865edde982ab2a5/media/engine/webrtc_voice_engine.cc">WebRtcVoiceEngine::Init</a> 和 <a href="https://webrtc.googlesource.com/src/&#43;/3dec7d05377fb690e84f503db865edde982ab2a5/media/engine/adm_helpers.cc">adm_helpers::Init</a>。允许内部设备的构建中，未注入 ADM 时会尝试创建平台默认实现；调用方也可以提供自己的 ADM。</p>
<h3 id="33-控制调用链初始化与真正运行分开">3.3 控制调用链：初始化与真正运行分开</h3>
<p><code>Init()</code>、<code>InitMicrophone()</code> 和 <code>StartRecording()</code> 不是同一件事。公共接口把模块初始化、设备控制能力准备、I/O 流准备与运行分开；各平台实际创建资源的时机可能有所不同。</p>
<table>
	<thead>
			<tr>
					<th>阶段</th>
					<th>录音侧的代表方法</th>
					<th>播放侧的代表方法</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>模块初始化</td>
					<td><code>Init()</code></td>
					<td>同一个 <code>Init()</code></td>
			</tr>
			<tr>
					<td>选择设备、准备控制能力</td>
					<td><code>SetRecordingDevice()</code>、<code>InitMicrophone()</code></td>
					<td><code>SetPlayoutDevice()</code>、<code>InitSpeaker()</code></td>
			</tr>
			<tr>
					<td>准备 I/O 流</td>
					<td><code>InitRecording()</code></td>
					<td><code>InitPlayout()</code></td>
			</tr>
			<tr>
					<td>开始 / 停止数据流</td>
					<td><code>StartRecording()</code> / <code>StopRecording()</code></td>
					<td><code>StartPlayout()</code> / <code>StopPlayout()</code></td>
			</tr>
	</tbody>
</table>
<p>在 <code>AudioState</code> 中，运行还与收发流是否存在、录音/播放开关是否启用有关：</p>

<div class="mermaid">flowchart TB
    INIT[&#34;引擎 Init&lt;br/&gt;ADM 初始化、设备与能力配置、注册回调&#34;]
    INIT --&gt; SEND[&#34;加入发送流 / 启用录音&#34;]
    INIT --&gt; RECV[&#34;加入接收流 / 启用播放&#34;]
    SEND --&gt; SC{&#34;有发送流且录音已启用？&#34;}
    RECV --&gt; RC{&#34;有接收流且播放已启用？&#34;}
    SC --&gt;|&#34;是，且尚未录音&#34;| SI[&#34;InitRecording → StartRecording&#34;]
    RC --&gt;|&#34;是，且尚未播放&#34;| RI[&#34;InitPlayout → StartPlayout&#34;]
    SI --&gt; SS[&#34;最后一个发送流移除 / 关闭录音&lt;br/&gt;StopRecording&#34;]
    RI --&gt; RS[&#34;最后一个接收流移除 / 关闭播放&lt;br/&gt;StopPlayout&#34;]</div>
<p>发送流注册时，<code>AudioState::UpdateAudioTransportWithSendingStreams()</code> 还会更新 <code>AudioTransportImpl</code> 中的发送者列表及所需采样率、声道数；接收流注册时，则通过 <code>AudioMixer::AddSource(stream-&gt;source())</code> 加入混音器。生命周期控制和 PCM 流动由此衔接起来。</p>
<p>另一个细节是：当接收流仍存在、只是 <code>AudioState</code> 的 playout 开关被关闭时，<code>UpdateNullAudioPollerState()</code> 会启用 10 ms 定时拉取，让接收音频继续被消费。这和把接收流自身停止是不同的操作，不能把所有“静音”都理解成同一种状态。</p>
<h3 id="34-采集调用链上半段后端--adb--apm">3.4 采集调用链上半段：后端 → ADB → APM</h3>
<p>无论系统通过回调、事件还是读线程提供录音，后端最终需要把合适大小的 PCM 交给 ADB。以下为调用顺序示意，块长适配已由后端或 <code>FineAudioBuffer</code> 完成：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt">1
</span><span class="lnt">2
</span><span class="lnt">3
</span><span class="lnt">4
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-cpp" data-lang="cpp"><span class="line"><span class="cl"><span class="c1">// 伪代码：每次交付 10 ms，每声道样本数为 sample_rate / 100。
</span></span></span><span class="line"><span class="cl"><span class="n">adb</span><span class="o">-&gt;</span><span class="n">SetRecordedBuffer</span><span class="p">(</span><span class="n">pcm</span><span class="p">,</span> <span class="n">samples_per_channel</span><span class="p">,</span> <span class="n">capture_timestamp_ns</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="n">adb</span><span class="o">-&gt;</span><span class="n">SetVQEData</span><span class="p">(</span><span class="n">playout_delay_ms</span><span class="p">,</span> <span class="n">recording_delay_ms</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="n">adb</span><span class="o">-&gt;</span><span class="n">DeliverRecordedData</span><span class="p">();</span></span></span></code></pre></td></tr></table>
</div>
</div>
<p>这三步的作用分别是：复制 PCM 到 <code>rec_buffer_</code>；保存播放与采集延迟；通过已注册的 <code>AudioTransport</code> 把 PCM 和元数据交给上层。<code>SetRecordedBuffer()</code> 本身只保存本次给它的数据，不负责累计不足 10 ms 的输入。</p>
<p><code>DeliverRecordedData()</code> 的关键调用可概括为：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt"> 1
</span><span class="lnt"> 2
</span><span class="lnt"> 3
</span><span class="lnt"> 4
</span><span class="lnt"> 5
</span><span class="lnt"> 6
</span><span class="lnt"> 7
</span><span class="lnt"> 8
</span><span class="lnt"> 9
</span><span class="lnt">10
</span><span class="lnt">11
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-cpp" data-lang="cpp"><span class="line"><span class="cl"><span class="c1">// 简化自 AudioDeviceBuffer::DeliverRecordedData()，省略错误处理。
</span></span></span><span class="line"><span class="cl"><span class="k">const</span> <span class="n">size_t</span> <span class="n">frames</span> <span class="o">=</span> <span class="n">rec_buffer_</span><span class="p">.</span><span class="n">size</span><span class="p">()</span> <span class="o">/</span> <span class="n">rec_channels_</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="k">const</span> <span class="n">size_t</span> <span class="n">bytes_per_frame</span> <span class="o">=</span> <span class="n">rec_channels_</span> <span class="o">*</span> <span class="k">sizeof</span><span class="p">(</span><span class="kt">int16_t</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="kt">uint32_t</span> <span class="n">ignored_new_mic_level</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">audio_transport_cb_</span><span class="o">-&gt;</span><span class="n">RecordedDataIsAvailable</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="n">rec_buffer_</span><span class="p">.</span><span class="n">data</span><span class="p">(),</span> <span class="n">frames</span><span class="p">,</span> <span class="n">bytes_per_frame</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">rec_channels_</span><span class="p">,</span> <span class="n">rec_sample_rate_</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">play_delay_ms_</span> <span class="o">+</span> <span class="n">rec_delay_ms_</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="n">typing_status_</span><span class="p">,</span> <span class="n">ignored_new_mic_level</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">capture_timestamp_ns_</span><span class="p">);</span></span></span></code></pre></td></tr></table>
</div>
</div>
<p>接口中的参数名 <code>nBytesPerSample</code> 容易误导：在这条 ADB 调用路径里，传入的是<strong>每个 PCM frame 的字节数</strong>，即 <code>声道数 × sizeof(int16_t)</code>。双声道为 4，不能直接按“一个标量样本 2 字节”去填。<code>AudioTransportImpl</code> 中也有相应的检查。</p>
<p>进入 <code>AudioTransportImpl::RecordedDataIsAvailable()</code> 后，主要顺序是：</p>
<ol>
<li>检查格式和长度，包括 <code>number_of_frames * 100 == sample_rate</code>，明确要求本次为 10 ms。</li>
<li><code>InitializeCaptureFrame()</code> 选择处理格式，<code>voe::RemixAndResample()</code> 调整声道与采样率。</li>
<li><code>ProcessCaptureFrame()</code> 传入设备延迟和按键状态，并调用 <code>ProcessAudioFrame()</code>。</li>
<li><code>ProcessAudioFrame()</code> 转到 <code>AudioProcessing::ProcessStream()</code>，执行已配置的采集处理。</li>
<li>设置可选的绝对采集时间，之后直接或经可选异步处理器进入 <code>SendProcessedData()</code>。</li>
</ol>
<p>如果后端提供采集时间戳，ADB 会利用 <code>TimestampAligner</code> 将它映射到 WebRTC 使用的时钟域；没有时间戳时，接口允许传入 <code>std::nullopt</code>。不要因为参数中还有 <code>clockDrift</code>、<code>currentMicLevel</code> 等历史字段，就假定当前 ADB 会提供有效数值：上面的实现对它们传入的是 0。</p>
<p>实现见 <a href="https://webrtc.googlesource.com/src/&#43;/3dec7d05377fb690e84f503db865edde982ab2a5/modules/audio_device/audio_device_buffer.cc">AudioDeviceBuffer</a>、<a href="https://webrtc.googlesource.com/src/&#43;/3dec7d05377fb690e84f503db865edde982ab2a5/audio/audio_transport_impl.cc">AudioTransportImpl</a> 和 <a href="https://webrtc.googlesource.com/src/&#43;/3dec7d05377fb690e84f503db865edde982ab2a5/modules/audio_processing/include/audio_frame_proxies.cc">APM 的 AudioFrame 适配函数</a>。</p>
<h3 id="35-采集调用链下半段发送流--编码队列--rtp">3.5 采集调用链下半段：发送流 → 编码队列 → RTP</h3>
<p><code>AudioTransportImpl::SendProcessedData()</code> 遍历已注册的 <code>AudioSender</code>，调用各发送流的 <code>SendAudioData()</code>。多个发送流需要数据时，为其中的流复制 <code>AudioFrame</code>，最后把原始对象移动给一个流。</p>

<div class="mermaid">%%{init: {&#34;sequence&#34;: {&#34;wrap&#34;: true, &#34;width&#34;: 90, &#34;actorMargin&#34;: 12, &#34;diagramMarginX&#34;: 8, &#34;mirrorActors&#34;: false}}}%%
sequenceDiagram
    participant D as 后端
    participant B as ADB
    participant T as Transport
    participant P as APM
    participant S as 发送链路
    participant Q as 编码队列
    D-&gt;&gt;B: SetRecordedBuffer&lt;br/&gt;SetVQEData
    D-&gt;&gt;B: DeliverRecordedData
    B-&gt;&gt;T: RecordedDataIsAvailable
    T-&gt;&gt;T: RemixAndResample
    T-&gt;&gt;P: ProcessStream
    P--&gt;&gt;T: 处理后的 PCM
    Note over T,S: 默认同步路径；可配置额外异步处理
    T-&gt;&gt;S: SendProcessedData&lt;br/&gt;→ SendAudioData
    S-&gt;&gt;S: ProcessAndEncodeAudio
    S-)Q: PostTask：移交 AudioFrame
    Q-&gt;&gt;Q: Add10MsData&lt;br/&gt;→ Encode
    opt 编码器已积累足够数据
        Q-&gt;&gt;S: AudioPacketizationCallback::SendData
        S-&gt;&gt;S: RTPSenderAudio::SendAudio&lt;br/&gt;→ RTP 发送链路
    end</div>
<p>图中 Transport 指 <code>AudioTransportImpl</code>，“发送链路”合并表示 <code>AudioSendStream</code> 和 <code>ChannelSend</code>。源码中的主链可按下面的顺序阅读：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt"> 1
</span><span class="lnt"> 2
</span><span class="lnt"> 3
</span><span class="lnt"> 4
</span><span class="lnt"> 5
</span><span class="lnt"> 6
</span><span class="lnt"> 7
</span><span class="lnt"> 8
</span><span class="lnt"> 9
</span><span class="lnt">10
</span><span class="lnt">11
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">AudioTransportImpl::SendProcessedData
</span></span><span class="line"><span class="cl">  → AudioSendStream::SendAudioData
</span></span><span class="line"><span class="cl">  → ChannelSend::ProcessAndEncodeAudio
</span></span><span class="line"><span class="cl">      → encoder_queue_-&gt;PostTask(...)
</span></span><span class="line"><span class="cl">          → AudioCodingModuleImpl::Add10MsData
</span></span><span class="line"><span class="cl">          → AudioCodingModuleImpl::Encode
</span></span><span class="line"><span class="cl">          → encoder_stack_-&gt;Encode
</span></span><span class="line"><span class="cl">          → AudioPacketizationCallback::SendData
</span></span><span class="line"><span class="cl">              → ChannelSend::SendData
</span></span><span class="line"><span class="cl">              → RTPSenderAudio::SendAudio
</span></span><span class="line"><span class="cl">              → 后续 RTP 发送链路</span></span></code></pre></td></tr></table>
</div>
</div>
<p><strong>明确的线程交接发生在 <code>ChannelSend</code> 投递编码任务时。</strong> 默认同步路径中的格式调整、APM 以及发送流分发，会先在调用采集交付函数的线程上执行；启用额外异步处理时，中间还会增加交接点。</p>
<p>另外，<code>Add10MsData()</code> 每次接受 10 ms，并不保证每次都回调 <code>SendData()</code>。编码器是否已经攒够一个包、是否启用 DTX 等都会影响输出。把设备帧、APM 处理帧和 RTP 包时长分开看，才能正确分析延迟。</p>
<p>对应源码：<a href="https://webrtc.googlesource.com/src/&#43;/3dec7d05377fb690e84f503db865edde982ab2a5/audio/audio_send_stream.cc">AudioSendStream</a>、<a href="https://webrtc.googlesource.com/src/&#43;/3dec7d05377fb690e84f503db865edde982ab2a5/audio/channel_send.cc">ChannelSend</a>、<a href="https://webrtc.googlesource.com/src/&#43;/3dec7d05377fb690e84f503db865edde982ab2a5/modules/audio_coding/acm2/audio_coding_module.cc">AudioCodingModuleImpl</a>。</p>
<h3 id="36-播放调用链设备请求--混音器--接收流--neteq">3.6 播放调用链：设备请求 → 混音器 → 接收流 → NetEq</h3>
<p>先看网络到包这一侧。<code>ChannelReceive::OnRtpPacket()</code> 解析和处理 RTP，在接收流处于播放状态时，经过 <code>OnReceivedPayloadData()</code> 把载荷插入 <code>NetEq::InsertPacket()</code>。这一步提供的是压缩音频，不会直接触发设备播放。</p>
<p>真正消费音频的入口在设备侧。后端执行：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt">1
</span><span class="lnt">2
</span><span class="lnt">3
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-cpp" data-lang="cpp"><span class="line"><span class="cl"><span class="c1">// 伪代码：后端已经确定采样率、声道与 10 ms 块长。
</span></span></span><span class="line"><span class="cl"><span class="n">adb</span><span class="o">-&gt;</span><span class="n">RequestPlayoutData</span><span class="p">(</span><span class="n">samples_per_channel</span><span class="p">);</span>  <span class="c1">// 向上层请求并保存 PCM。
</span></span></span><span class="line"><span class="cl"><span class="n">adb</span><span class="o">-&gt;</span><span class="n">GetPlayoutData</span><span class="p">(</span><span class="n">device_buffer</span><span class="p">);</span>           <span class="c1">// 复制到后端提供的缓冲。
</span></span></span></code></pre></td></tr></table>
</div>
</div>
<p><code>RequestPlayoutData()</code> 同步调用 <code>AudioTransport::NeedMorePlayData()</code>。进入 <code>AudioTransportImpl</code> 后，它先调用混音器；混音器逐个向接收流请求音频；各流最终向自己的 NetEq 取出下一段 10 ms PCM。</p>

<div class="mermaid">%%{init: {&#34;sequence&#34;: {&#34;wrap&#34;: true, &#34;width&#34;: 80, &#34;actorMargin&#34;: 10, &#34;diagramMarginX&#34;: 8, &#34;mirrorActors&#34;: false}}}%%
sequenceDiagram
    participant D as 后端
    participant B as ADB
    participant T as Transport
    participant M as Mixer
    participant R as 接收链路
    participant N as NetEq
    participant P as APM
    Note over R,N: 网络到包独立执行 InsertPacket
    D-&gt;&gt;B: RequestPlayoutData
    B-&gt;&gt;T: NeedMorePlayData
    T-&gt;&gt;M: Mix
    loop 每个已注册的接收源
        M-&gt;&gt;R: GetAudioFrameWithInfo
        R-&gt;&gt;N: GetAudio
        N--&gt;&gt;R: 下一段 10 ms PCM
        R--&gt;&gt;M: 接收处理后的 AudioFrame
    end
    M--&gt;&gt;T: 混音结果
    T-&gt;&gt;P: ProcessReverseAudioFrame → ProcessReverseStream
    T-&gt;&gt;T: Resample 到设备请求的采样率
    T--&gt;&gt;B: 填好播放 PCM 与输出长度
    B--&gt;&gt;D: RequestPlayoutData 返回
    D-&gt;&gt;B: GetPlayoutData
    B--&gt;&gt;D: 复制 PCM 到设备侧缓冲</div>
<p>图中 Transport 指 <code>AudioTransportImpl</code>，Mixer 指 <code>AudioMixer</code>，“接收链路”合并表示接收流和 <code>ChannelReceive</code>。展开方法名之后，主链是：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt"> 1
</span><span class="lnt"> 2
</span><span class="lnt"> 3
</span><span class="lnt"> 4
</span><span class="lnt"> 5
</span><span class="lnt"> 6
</span><span class="lnt"> 7
</span><span class="lnt"> 8
</span><span class="lnt"> 9
</span><span class="lnt">10
</span><span class="lnt">11
</span><span class="lnt">12
</span><span class="lnt">13
</span><span class="lnt">14
</span><span class="lnt">15
</span><span class="lnt">16
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">平台输出回调 / 后端播放工作线程
</span></span><span class="line"><span class="cl">  → [可选 FineAudioBuffer::GetPlayoutData]
</span></span><span class="line"><span class="cl">  → AudioDeviceBuffer::RequestPlayoutData
</span></span><span class="line"><span class="cl">  → AudioTransportImpl::NeedMorePlayData
</span></span><span class="line"><span class="cl">      → AudioMixerImpl::Mix
</span></span><span class="line"><span class="cl">          → AudioMixerImpl::GetAudioFromSources
</span></span><span class="line"><span class="cl">          → AudioReceiveStreamImpl::GetAudioFrameWithInfo
</span></span><span class="line"><span class="cl">          → ChannelReceive::GetAudioFrameWithInfo
</span></span><span class="line"><span class="cl">          → NetEq::GetAudio
</span></span><span class="line"><span class="cl">      ← 各接收源的 PCM 经混音后返回
</span></span><span class="line"><span class="cl">      → ProcessReverseAudioFrame
</span></span><span class="line"><span class="cl">          → AudioProcessing::ProcessReverseStream
</span></span><span class="line"><span class="cl">      → Resample
</span></span><span class="line"><span class="cl">  ← PCM 写入 ADB 的 play_buffer_
</span></span><span class="line"><span class="cl">  → AudioDeviceBuffer::GetPlayoutData
</span></span><span class="line"><span class="cl">  → 后端缓冲 / 格式适配 → OS 输出</span></span></code></pre></td></tr></table>
</div>
</div>
<p>这里有三个关键点：</p>
<ul>
<li><strong>NetEq 是由播放需求拉动的。</strong> 它结合已有包和当前状态生成音频，可能解码新包、使用已解码的缓存，也可能执行丢包补偿；不是每次 <code>GetAudio()</code> 都恰好解码一个网络包。</li>
<li><strong>混音之后才进入 APM 播放参考路径。</strong> AEC 需要观察本机准备输出的合成声音，而不只是某一条远端流。</li>
<li><strong>重采样可能不止一次。</strong> 接收流先适配混音器要求的格式，混音结果再适配设备要求的采样率；设备侧仍可能存在原生格式转换。</li>
</ul>
<p>对应源码：<a href="https://webrtc.googlesource.com/src/&#43;/3dec7d05377fb690e84f503db865edde982ab2a5/modules/audio_mixer/audio_mixer_impl.cc">混音器</a>、<a href="https://webrtc.googlesource.com/src/&#43;/3dec7d05377fb690e84f503db865edde982ab2a5/audio/audio_receive_stream.cc">AudioReceiveStreamImpl</a>、<a href="https://webrtc.googlesource.com/src/&#43;/3dec7d05377fb690e84f503db865edde982ab2a5/audio/channel_receive.cc">ChannelReceive</a>。</p>
<p><code>AudioTransport</code> 还定义了 <code>PullRenderData()</code>。本基线中的注释说明，Chromium 使用这个入口并拥有自己的 APM，因此该方法没有在内部调用 <code>ProcessReverseStream()</code>；采集侧 <code>RecordedDataIsAvailable()</code> 的默认处理路径也注明不用于 Chromium。分析 Chrome 时，应继续追踪浏览器自己的采集与处理装配，不能把上面的 native 调用链直接套过去。</p>
<h3 id="37-adbfineaudiobuffer-与-neteq三种缓冲分别解决什么">3.7 ADB、FineAudioBuffer 与 NetEq：三种缓冲分别解决什么</h3>
<table>
	<thead>
			<tr>
					<th>组件</th>
					<th>缓冲的是什么</th>
					<th>面对哪种差异</th>
					<th>典型行为</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td><code>AudioDeviceBuffer</code></td>
					<td>本次采集 / 播放的 PCM</td>
					<td>后端与运输回调的交接</td>
					<td>保存 PCM、格式和元数据，调用双向接口</td>
			</tr>
			<tr>
					<td><code>FineAudioBuffer</code></td>
					<td>设备块与 10 ms 块之间的 PCM 余量</td>
					<td>本地设备回调块长不一致</td>
					<td>采集攒够 10 ms 才交付，播放取 10 ms 后按需切出</td>
			</tr>
			<tr>
					<td><code>NetEq</code></td>
					<td>接收包及解码、时伸缩等所需的音频状态</td>
					<td>网络到包与稳定播放之间的时间差</td>
					<td>抖动控制、按需解码、丢包补偿</td>
			</tr>
	</tbody>
</table>
<p><code>FineAudioBuffer::DeliverRecordedData()</code> 中的循环体现了这个区别：追加本次设备数据，只要缓存达到一个 10 ms 块，就调用 ADB 的 <code>SetRecordedBuffer()</code>、<code>SetVQEData()</code>、<code>DeliverRecordedData()</code>，剩余数据保留到下次。</p>
<p>反向的 <code>GetPlayoutData()</code> 则不断请求 10 ms，直到足够满足设备这次的需求，然后复制所需部分并保留余量。它会缓存后端传入的播放延迟，供后续采集交付时一起上报。完整实现见 <a href="https://webrtc.googlesource.com/src/&#43;/3dec7d05377fb690e84f503db865edde982ab2a5/modules/audio_device/fine_audio_buffer.cc">fine_audio_buffer.cc</a>。</p>
<h2 id="四平台视角共用-pcm-边界底层采用不同的节奏">四、平台视角：共用 PCM 边界，底层采用不同的节奏</h2>
<h3 id="41-差异集中在哪几层">4.1 差异集中在哪几层</h3>
<p>上层的 <code>AudioTransport</code> 契约可以复用，但设备 API、后端组织、回调线程、设备路由和系统音效能力都存在差异。</p>

<div class="mermaid">flowchart LR
    T[&#34;共同上层&lt;br/&gt;AudioTransport / APM&lt;br/&gt;混音 / 收发流&#34;]
    B[&#34;AudioDeviceBuffer&lt;br/&gt;共同的 PCM 交接点&#34;]
    T &lt;--&gt; B
    B &lt;--&gt; W[&#34;Windows&lt;br/&gt;WASAPI 事件与线程&#34;]
    B &lt;--&gt; M[&#34;macOS&lt;br/&gt;HAL、IOProc、环形缓冲与 worker&#34;]
    B &lt;--&gt; L[&#34;Linux&lt;br/&gt;PulseAudio 或 ALSA&#34;]
    B &lt;--&gt; A[&#34;Android&lt;br/&gt;Java / OpenSL ES / AAudio&#34;]
    B &lt;--&gt; I[&#34;iOS&lt;br/&gt;AVAudioSession 与 VoiceProcessingIO&#34;]</div>
<table>
	<thead>
			<tr>
					<th>平台 / 路径</th>
					<th>系统 I/O 方式</th>
					<th>块长适配的主要位置</th>
					<th>设备选择 / 路由</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Windows 传统 Core Audio 后端</td>
					<td>WASAPI 共享模式，事件唤醒采集/播放线程</td>
					<td>后端的同步缓冲与 10 ms 循环</td>
					<td>endpoint 枚举、设备 ID、默认设备角色</td>
			</tr>
			<tr>
					<td>macOS</td>
					<td>CoreAudio HAL 的 IOProc</td>
					<td>环形缓冲、工作线程与 <code>AudioConverter</code></td>
					<td>HAL 设备及属性监听</td>
			</tr>
			<tr>
					<td>Linux PulseAudio</td>
					<td>服务端音频流、threaded mainloop 与后端线程</td>
					<td>后端按 10 ms 整理，与服务端缓冲衔接</td>
					<td>Pulse server 的 source / sink</td>
			</tr>
			<tr>
					<td>Linux ALSA</td>
					<td>PCM 读写与等待</td>
					<td>后端读写线程、本地缓冲</td>
					<td>ALSA PCM 设备</td>
			</tr>
			<tr>
					<td>Android Java</td>
					<td><code>AudioRecord</code> / <code>AudioTrack</code> 高优先级线程</td>
					<td>Java/JNI 按 10 ms 交接</td>
					<td>Android 系统与应用的路由管理</td>
			</tr>
			<tr>
					<td>Android OpenSL ES / AAudio</td>
					<td>buffer queue / data callback</td>
					<td><code>FineAudioBuffer</code></td>
					<td>受系统路由和具体后端能力影响</td>
			</tr>
			<tr>
					<td>iOS</td>
					<td>VoiceProcessingIO AudioUnit 回调</td>
					<td><code>FineAudioBuffer</code></td>
					<td><code>AVAudioSession</code></td>
			</tr>
	</tbody>
</table>
<p>以下“默认”都指这份源码及对应构建条件下的选择。SDK 的创建入口、应用注入的 ADM 和构建开关，都会影响真正使用的后端。</p>
<h3 id="42-windowswasapi-事件驱动注意两套-adm-入口">4.2 Windows：WASAPI 事件驱动，注意两套 ADM 入口</h3>
<p>通用 <code>AudioDeviceModuleImpl</code> 的 Windows 默认路径使用 <code>AudioDeviceWindowsCore</code>。它主要通过以下对象工作：</p>
<ul>
<li><code>IMMDevice</code> 等接口枚举和取得输入/输出 endpoint。</li>
<li><code>IAudioClient</code> 协商格式并创建共享模式流。</li>
<li><code>IAudioCaptureClient</code> 读取采集包，<code>IAudioRenderClient</code> 写入输出缓冲。</li>
<li>采集与播放各有事件等待和工作线程，并使用 MMCSS 改善调度。</li>
</ul>
<p>播放线程的主过程是等待事件，通过 <code>GetCurrentPadding()</code> 确定输出缓冲还能容纳多少 frame，再按 10 ms 向 ADB 请求 PCM，最后提交到 WASAPI。采集线程从 <code>GetBuffer()</code> 取得数据，放入同步缓冲，凑足 10 ms 后交给 ADB。</p>
<p>因此，即使一次系统事件对应的可读写数据不是 10 ms 的整倍数，上层仍可按 10 ms 工作。格式也由设备探测与协商确定，不能假定任何端点都接受同一个采样率和声道组合。</p>
<p>本基线还保留另一套 <code>kWindowsCoreAudio2</code> 路径，通过 <code>CoreAudioInput</code> / <code>CoreAudioOutput</code> 组合成 ADM。它需要调用专用工厂 <code>CreateWindowsCoreAudioAudioDeviceModule()</code>；直接把这个枚举值传给通用 ADM 工厂会被拒绝。专用入口要求正确初始化 COM MTA，并提供 <code>automatic_restart</code> 参数控制断连后的自动重启。</p>
<p>源码入口：<a href="https://webrtc.googlesource.com/src/&#43;/3dec7d05377fb690e84f503db865edde982ab2a5/modules/audio_device/win/audio_device_core_win.cc">audio_device_core_win.cc</a>、<a href="https://webrtc.googlesource.com/src/&#43;/3dec7d05377fb690e84f503db865edde982ab2a5/modules/audio_device/include/audio_device_factory.h">专用工厂与约束</a>、<a href="https://webrtc.googlesource.com/src/&#43;/3dec7d05377fb690e84f503db865edde982ab2a5/modules/audio_device/win/audio_device_module_win.cc">组合式 Windows ADM</a>。</p>
<h3 id="43-macosioproc-与-webrtc-处理之间隔着环形缓冲">4.3 macOS：IOProc 与 WebRTC 处理之间隔着环形缓冲</h3>
<p><code>AudioDeviceMac</code> 直接使用 CoreAudio HAL。系统在 IOProc 中提供输入、请求输出，而 WebRTC 上层的调用主要发生在后端工作线程中。环形缓冲把两边连接起来。</p>

<div class="mermaid">flowchart TB
    subgraph CAP[&#34;采集方向&#34;]
        CI[&#34;CoreAudio 输入 IOProc&#34;] --&gt; CR[&#34;输入环形缓冲&#34;]
        CR --&gt; CW[&#34;CaptureWorkerThread / AudioConverter&#34;]
        CW --&gt; CB[&#34;ADB：交付 10 ms&#34;]
    end
    subgraph PLAY[&#34;播放方向&#34;]
        PB[&#34;ADB：请求 10 ms&#34;] --&gt; PW[&#34;RenderWorkerThread&#34;]
        PW --&gt; PR[&#34;输出环形缓冲&#34;]
        PR --&gt; PO[&#34;CoreAudio 输出 IOProc / 格式转换&#34;]
    end</div>
<p>这样做可以把上层处理与 IOProc 的实时节奏隔开。播放 worker 观察环形缓冲的可写空间，持续补充音频；采集 worker 从输入缓冲取数并做格式转换，再交付 ADB。它增加了本地缓冲，也需要在延迟估计中考虑这些缓冲。</p>
<p>当前后端把 ADB 的默认格式设为采集 48 kHz 单声道、播放 48 kHz 双声道，并结合设备能力和配置调整声道；设备原生格式与内部格式之间由 <code>AudioConverter</code> 等逻辑适配。后端还监听设备、格式等属性变化。</p>
<p>macOS 和 iOS 都属于 Apple 平台，但这份 macOS 实现采用 HAL、IOProc 与 worker 的组织方式，不能照搬下一节 iOS 的 AudioUnit 模型。源码见 <a href="https://webrtc.googlesource.com/src/&#43;/3dec7d05377fb690e84f503db865edde982ab2a5/modules/audio_device/mac/audio_device_mac.cc">AudioDeviceMac</a>。</p>
<h3 id="44-linuxpulseaudio-服务端路径与-alsa-pcm-路径">4.4 Linux：PulseAudio 服务端路径与 ALSA PCM 路径</h3>
<p><strong>PulseAudio 路径。</strong> 当构建启用 <code>WEBRTC_ENABLE_LINUX_PULSE</code> 时，通用 ADM 的 <code>kPlatformDefaultAudio</code> 选择 <code>AudioDeviceLinuxPulse</code>。后端加载 <code>libpulse</code>，创建 <code>pa_threaded_mainloop</code>、<code>pa_context</code>，连接服务端，再建立采集与播放的 <code>pa_stream</code>。读写回调与后端音频线程协作，完成本地 10 ms PCM 和服务端缓冲之间的交换。</p>
<p>设备列表与默认 source / sink 来自服务端，因此系统混音和路由也是时序与设备行为的一部分。</p>
<p><strong>ALSA 路径。</strong> 未启用 PulseAudio 时，平台默认走 ALSA；启用 PulseAudio 的构建也可显式选择 <code>kLinuxAlsaAudio</code>。<code>AudioDeviceLinuxALSA</code> 通过 <code>snd_pcm_readi()</code>、<code>snd_pcm_writei()</code> 读写 PCM，配合 <code>snd_pcm_wait()</code> 等待，以及 <code>snd_pcm_delay()</code> 获取延迟信息。</p>
<p>两条路径都要处理“暂时没有足够数据”和异常恢复。ALSA 的 <code>ErrorRecovery()</code> 会针对 underrun 等错误恢复 PCM 状态；PulseAudio 后端通过服务端流状态和缓冲回调协调。它们共同向 ADB 提供 10 ms 音频，但缓冲层次、设备命名和路由来源不同。</p>
<p>源码见 <a href="https://webrtc.googlesource.com/src/&#43;/3dec7d05377fb690e84f503db865edde982ab2a5/modules/audio_device/linux/audio_device_pulse_linux.cc">PulseAudio 后端</a>、<a href="https://webrtc.googlesource.com/src/&#43;/3dec7d05377fb690e84f503db865edde982ab2a5/modules/audio_device/linux/audio_device_alsa_linux.cc">ALSA 后端</a>。这里列的是 WebRTC 后端使用的 API，不能仅凭桌面系统采用了什么音频服务，就推断源码中存在同名的直接后端。</p>
<h3 id="45-android输入与输出可以采用不同-api">4.5 Android：输入与输出可以采用不同 API</h3>
<p>Android 需要先问清楚“通过哪个工厂、选择哪种 AudioLayer 创建 ADM”。native API 的 <code>CreateAndroidAudioDeviceModule()</code> 支持这些组合：</p>
<table>
	<thead>
			<tr>
					<th>AudioLayer</th>
					<th>采集端</th>
					<th>播放端</th>
					<th>设计考虑</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td><code>kAndroidJavaAudio</code></td>
					<td><code>AudioRecord</code></td>
					<td><code>AudioTrack</code></td>
					<td>Java API 路径</td>
			</tr>
			<tr>
					<td><code>kAndroidOpenSLESAudio</code></td>
					<td>OpenSL ES</td>
					<td>OpenSL ES</td>
					<td>native buffer queue 路径</td>
			</tr>
			<tr>
					<td><code>kAndroidJavaInputAndOpenSLESOutputAudio</code></td>
					<td><code>AudioRecord</code></td>
					<td>OpenSL ES</td>
					<td>Java 输入音效能力与 native 输出结合</td>
			</tr>
			<tr>
					<td><code>kAndroidAAudioAudio</code></td>
					<td>AAudio</td>
					<td>AAudio</td>
					<td>AAudio data callback 路径，需构建支持</td>
			</tr>
			<tr>
					<td><code>kAndroidJavaInputAndAAudioOutputAudio</code></td>
					<td><code>AudioRecord</code></td>
					<td>AAudio</td>
					<td>Java 输入与 AAudio 输出组合，需构建支持</td>
			</tr>
	</tbody>
</table>
<p>在这个工厂中，请求 <code>kPlatformDefaultAudio</code> 时，若定义了 <code>WEBRTC_AUDIO_DEVICE_INCLUDE_ANDROID_AAUDIO</code>，选择 AAudio 双向路径；否则根据系统报告的低延迟输入/输出能力，在 OpenSL ES、混合路径和 Java 路径之间选择。这是该工厂的选择逻辑，不代表所有 Android SDK 接入都采用同样的默认值。</p>
<p><strong>Java 路径的数据交接</strong>很适合作为一个具体例子：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt"> 1
</span><span class="lnt"> 2
</span><span class="lnt"> 3
</span><span class="lnt"> 4
</span><span class="lnt"> 5
</span><span class="lnt"> 6
</span><span class="lnt"> 7
</span><span class="lnt"> 8
</span><span class="lnt"> 9
</span><span class="lnt">10
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">采集：WebRtcAudioRecord 的录音线程
</span></span><span class="line"><span class="cl">  → AudioRecord.read 写入 direct ByteBuffer
</span></span><span class="line"><span class="cl">  → JNI → AudioRecordJni::DataIsRecorded
</span></span><span class="line"><span class="cl">  → ADB::SetRecordedBuffer / SetVQEData / DeliverRecordedData
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">播放：WebRtcAudioTrack 的播放线程
</span></span><span class="line"><span class="cl">  → JNI → AudioTrackJni::GetPlayoutData
</span></span><span class="line"><span class="cl">  → ADB::RequestPlayoutData / GetPlayoutData
</span></span><span class="line"><span class="cl">  → PCM 写入 direct ByteBuffer
</span></span><span class="line"><span class="cl">  → AudioTrack.write</span></span></code></pre></td></tr></table>
</div>
</div>
<p>direct <code>ByteBuffer</code> 让 JNI 可以访问已缓存的内存地址，减少 Java 与 C++ 交接的额外复制；不过 ADB 自身的保存和取数仍有复制，不能把整条链路理解为零拷贝。</p>
<p>OpenSL ES 使用缓冲队列回调，AAudio 使用带 <code>num_frames</code> 的 data callback。它们通过 <code>FineAudioBuffer</code> 衔接设备块长与 10 ms。AAudio 播放端还会观察 xrun：欠载次数增加时，扩大一个 burst 的输出缓冲，以延迟换稳定性；断连时把重启工作投递到另一线程，而不是在错误回调中直接关闭、重开流。</p>
<p>另一项差异是设备管理：这份组合式 Android ADM 的枚举接口返回一个逻辑输入和一个逻辑输出，不能据此得到全部手机麦克风、蓝牙和扬声器列表。路由需要结合 Android 系统音频管理与应用配置处理。Java 输入还可能使用系统 AEC/NS/AGC，启用时应与 APM 选项协调。</p>
<p>源码入口：<a href="https://webrtc.googlesource.com/src/&#43;/3dec7d05377fb690e84f503db865edde982ab2a5/sdk/android/native_api/audio_device_module/audio_device_android.cc">Android 工厂与选择逻辑</a>、<a href="https://webrtc.googlesource.com/src/&#43;/3dec7d05377fb690e84f503db865edde982ab2a5/sdk/android/src/jni/audio_device/audio_device_module.cc">AndroidAudioDeviceModule</a>、<a href="https://webrtc.googlesource.com/src/&#43;/3dec7d05377fb690e84f503db865edde982ab2a5/sdk/android/src/jni/audio_device/audio_record_jni.cc">AudioRecordJni</a>、<a href="https://webrtc.googlesource.com/src/&#43;/3dec7d05377fb690e84f503db865edde982ab2a5/sdk/android/src/jni/audio_device/audio_track_jni.cc">AudioTrackJni</a>、<a href="https://webrtc.googlesource.com/src/&#43;/3dec7d05377fb690e84f503db865edde982ab2a5/sdk/android/src/jni/audio_device/aaudio_player.cc">AAudioPlayer</a>。</p>
<h3 id="46-ios音频会话决定环境一个-audiounit-承担双向-io">4.6 iOS：音频会话决定环境，一个 AudioUnit 承担双向 I/O</h3>
<p>iOS 的核心设备实现是 <code>AudioDeviceIOS</code>，SDK 可以通过 <code>AudioDeviceModuleIOS</code> 包装它。控制环境主要来自 <code>AVAudioSession</code>，实际 I/O 使用 Voice-Processing I/O AudioUnit。</p>
<p>它与前面的独立输入/输出线程模型有一个明显区别：同一个全双工 AudioUnit 组织录音与播放，系统语音处理可以同时观察两侧信号。默认创建路径不旁路 voice processing；SDK 也提供 <code>bypass_voice_processing</code> 配置，因此应以实际创建选项判断系统处理是否启用。</p>

<div class="mermaid">flowchart TB
    SESSION[&#34;AVAudioSession：路由、激活、中断、实际格式&#34;]
    UNIT[&#34;VoiceProcessingIO AudioUnit：双向 I/O&#34;]
    IN[&#34;输入回调：AudioUnitRender 获取 PCM&#34;]
    OUT[&#34;输出回调：填充待播放 PCM&#34;]
    FINE[&#34;FineAudioBuffer：设备块长 ↔ 10 ms&#34;]
    ADB[&#34;AudioDeviceBuffer&#34;]
    SESSION -.-&gt;|&#34;配置与状态变化&#34;| UNIT
    UNIT --&gt; IN --&gt; FINE
    FINE --&gt; OUT --&gt; UNIT
    FINE &lt;--&gt; ADB</div>
<p>初始化时要区分<strong>偏好参数</strong>与<strong>真实参数</strong>：<code>Init()</code> 先保存偏好采样率和声道；真正准备 I/O、激活 session 后，<code>SetupAudioBuffersForActiveAudioSession()</code> 再读取实际 <code>sampleRate</code> 和 <code>IOBufferDuration</code>，更新 ADB，并重建 <code>FineAudioBuffer</code>。</p>
<p>具体的采集入口是 <code>AudioDeviceIOS::OnDeliverRecordedData()</code>：它调用 AudioUnit 的 render 取得输入，再通过 <code>FineAudioBuffer::DeliverRecordedData()</code> 累积交付。播放入口是 <code>OnGetPlayoutData()</code>：它通过 <code>FineAudioBuffer::GetPlayoutData()</code> 取得当前回调需要的 PCM，不播放时填零。</p>
<p>耳机路由变化、电话中断和采样率变化，都可能要求重新配置。后端把相关事件转交到拥有对象的线程，在需要时停止 AudioUnit、反初始化、读取新的 session 参数、重建缓冲并恢复运行。这里的设备选择主要属于 session 路由管理，不能套用桌面 ADM 的 index/GUID 操作方式。</p>
<p>源码入口：<a href="https://webrtc.googlesource.com/src/&#43;/3dec7d05377fb690e84f503db865edde982ab2a5/sdk/objc/native/api/audio_device_module.mm">iOS SDK 工厂</a>、<a href="https://webrtc.googlesource.com/src/&#43;/3dec7d05377fb690e84f503db865edde982ab2a5/sdk/objc/native/src/audio/audio_device_ios.mm">AudioDeviceIOS</a>、<a href="https://webrtc.googlesource.com/src/&#43;/3dec7d05377fb690e84f503db865edde982ab2a5/sdk/objc/native/src/audio/voice_processing_audio_unit.mm">VoiceProcessingAudioUnit</a>。</p>
<h3 id="47-哪些能力不能假定跨平台一致">4.7 哪些能力不能假定跨平台一致</h3>
<table>
	<thead>
			<tr>
					<th>问题</th>
					<th>共同接口背后的实际差异</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>能否枚举并选择任意设备？</td>
					<td>桌面后端一般支持设备枚举；移动端更多依赖系统路由，部分 ADM 方法只提供逻辑设备或未实现</td>
			</tr>
			<tr>
					<td>能否设置音量、静音、立体声？</td>
					<td>要查询相应 <code>IsAvailable</code> 能力并检查返回值，不能由接口存在推断设备支持</td>
			</tr>
			<tr>
					<td>是否启用系统 AEC？</td>
					<td>取决于平台、后端与创建配置；Android Java 输入和 iOS voice processing 需要与软件 APM 配合</td>
			</tr>
			<tr>
					<td>延迟是不是精确测量？</td>
					<td>后端可能使用系统时间戳、缓冲查询或固定估计，精度不同</td>
			</tr>
			<tr>
					<td>换设备能否自动恢复？</td>
					<td>取决于后端、选项和应用策略，公共接口并不保证所有平台自动恢复</td>
			</tr>
	</tbody>
</table>
<p>例如，ALSA 可以从 <code>snd_pcm_delay()</code> 换算延迟；AAudio 可以根据流的时间与帧位置估计；iOS 的 <code>PlayoutDelay()</code> 在此基线中返回固定估计。这些值可以辅助音频处理和诊断，但不能当成同等精度的端到端延迟测量。</p>
<p>真实设备之外还可以使用 dummy、文件或测试 ADM。它们证明了这个边界的可替换性：上层需要的是符合契约的音频源和输出端，不一定是 WebRTC 亲自打开的物理麦克风与扬声器。</p>
<h2 id="五带着问题回到源码">五、带着问题回到源码</h2>
<h3 id="51-建议的阅读顺序">5.1 建议的阅读顺序</h3>
<table>
	<thead>
			<tr>
					<th>要回答的问题</th>
					<th>优先阅读的文件与方法</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>上层能要求设备做什么？</td>
					<td><code>api/audio/audio_device.h</code>、<code>audio_device_defines.h</code></td>
			</tr>
			<tr>
					<td>设备与上层在哪里接通？</td>
					<td><code>webrtc_voice_engine.cc</code> 的 <code>Init()</code>，ADM 的 <code>RegisterAudioCallback()</code></td>
			</tr>
			<tr>
					<td>谁控制什么时候开麦、播放？</td>
					<td><code>audio/audio_state.cc</code> 的 <code>Add*Stream()</code>、<code>SetRecording()</code>、<code>SetPlayout()</code></td>
			</tr>
			<tr>
					<td>PCM 怎样过设备边界？</td>
					<td><code>audio_device_buffer.cc</code> 的两组交付/请求方法</td>
			</tr>
			<tr>
					<td>为什么上层都是 10 ms？</td>
					<td><code>fine_audio_buffer.cc</code> 与各后端的缓冲循环</td>
			</tr>
			<tr>
					<td>APM 和收发流在哪里连接？</td>
					<td><code>audio/audio_transport_impl.cc</code> 的两个主回调</td>
			</tr>
			<tr>
					<td>编码在哪里切换线程？</td>
					<td><code>audio/channel_send.cc</code> 的 <code>ProcessAndEncodeAudio()</code></td>
			</tr>
			<tr>
					<td>播放怎样到达 NetEq？</td>
					<td><code>audio_mixer_impl.cc</code>、<code>audio_receive_stream.cc</code>、<code>channel_receive.cc</code></td>
			</tr>
			<tr>
					<td>某个平台为什么有额外延迟或重启？</td>
					<td>实际选中的平台后端、工厂和构建开关</td>
			</tr>
	</tbody>
</table>
<h3 id="52-用数据断点定位有设备但没有声音">5.2 用数据断点定位“有设备，但没有声音”</h3>
<p>比起一开始钻进驱动，更有效的办法是沿公共边界逐段检查：</p>
<ul>
<li><strong>录音没有进入发送链路</strong>：先确认录音流运行且有非零 PCM，再看 <code>DeliverRecordedData()</code> 是否调用到正确的 <code>RecordedDataIsAvailable()</code>，随后检查 APM 输出、发送者列表与编码队列状态。</li>
<li><strong>网络有包但扬声器没声音</strong>：先确认接收流已进入播放状态且载荷插入 NetEq，再看设备侧是否持续请求、混音器是否注册了接收源、<code>NeedMorePlayData()</code> 是否返回有效 PCM。</li>
<li><strong>只有某个平台周期性卡音</strong>：同时观察设备回调间隔、处理耗时、缓冲余量和 underrun/xrun；10 ms 逻辑帧并不保证操作系统线程每 10 ms 准时运行。</li>
<li><strong>切换耳机后失声或变速</strong>：检查实际路由、采样率、声道和设备块长是否变化，ADB 参数及块长适配器是否随流重建而更新。</li>
<li><strong>声音正常但回声明显</strong>：检查播放参考是否进入对应的 APM、设备延迟是否合理，以及系统语音处理与软件 APM 的启用配置是否匹配。</li>
</ul>
<p>这些检查贯穿全文的四个层次：先确认 ADM 是否接入并运行，再确认数据流是否连续，然后定位到具体的方法与线程交接，最后分析平台设备与路由行为。这样读代码，平台细节才有清晰的落点。</p>]]></content:encoded>
    </item>
    <item>
      <title>一名音频程序员的科技自媒体创业调研</title>
      <link>https://lyapple2008.github.io/posts/202609/2026-09-29-%E8%87%AA%E5%AA%92%E4%BD%93%E5%88%9B%E4%B8%9A%E8%B0%83%E7%A0%94/</link>
      <pubDate>Tue, 29 Sep 2026 09:05:00 +0800</pubDate>
      <guid>https://lyapple2008.github.io/posts/202609/2026-09-29-%E8%87%AA%E5%AA%92%E4%BD%93%E5%88%9B%E4%B8%9A%E8%B0%83%E7%A0%94/</guid>
      <description>我想尝试科技自媒体创业。这篇文章基于自己十多年音频算法和音视频开发经历，整理了账号定位、内容栏目、起步选题、制作流程和变现路径。</description>
      <content:encoded><![CDATA[<p>最近开始认真考虑一件事：利用业余时间尝试科技自媒体，并观察它有没有发展成一门事业的可能。</p>
<p>我做了十多年程序员，主要从事音频算法、音频应用和音视频直播相关开发。这段经历让我比较熟悉麦克风、耳机、降噪、回声消除、音频编解码、直播链路和 AI 语音等技术，也知道一项技术从演示到真正产品化之间，往往隔着很多工程问题。</p>
<p>最初的想法是介绍最新、有意思的科技产品和技术，先通过模仿成熟博主学习选题、拍摄和表达。但继续往下想，“泛科技”并不是一个好的起点：它需要抢新闻、抢新品、拼设备和制作成本，而我最稀缺的优势反而容易被淹没。</p>
<p>这篇文章是我对账号定位、内容方向、执行方式和变现路径的第一次系统整理。</p>
<h2 id="一先从音频科技切入而不是直接做泛科技">一、先从音频科技切入，而不是直接做泛科技</h2>
<p>结合自己的经历，目前比较合适的定位是：</p>
<blockquote>
<p>一个懂音频的程序员，用真实实验帮普通人看懂科技产品。</p>
</blockquote>
<p>如果进一步把账号价值压缩成一句话，可以是：</p>
<blockquote>
<p>不背参数，不念发布会，用实验告诉你技术有没有用、产品值不值得买。</p>
</blockquote>
<p>这个定位有几个好处：</p>
<ul>
<li>音频技术和我的从业经历高度匹配，不需要从零积累专业性；</li>
<li>耳机、麦克风、音箱和直播设备都是大众消费品，不会只吸引少数从业者；</li>
<li>降噪、蓝牙无损、空间音频和 AI 语音都有足够的话题性；</li>
<li>先用音频建立辨识度，以后还可以自然扩展到 AI 硬件、智能设备和其他科技产品。</li>
</ul>
<p>也就是说，热门产品负责带来关注，工程师视角负责建立信任。</p>
<h2 id="二受众以普通消费者为主科技爱好者为辅">二、受众以普通消费者为主，科技爱好者为辅</h2>
<p>我不想只面向音频开发人员，因为这个群体相对小，内容也容易变成技术课程。更合适的受众关系是：</p>
<blockquote>
<p>普通消费者是主要服务对象，科技爱好者是内容传播者和专业度验证者。</p>
</blockquote>
<p>这类观众不一定想学习一整套算法，但会关心三个问题：</p>
<ol>
<li>这个功能到底有什么用？</li>
<li>厂商宣传的内容有多少是真的？</li>
<li>我应该怎么选，又有没有必要为它花钱？</li>
</ol>
<p>因此，内容应当从生活问题出发，先给结论，再用实验和简单原理证明。专业不是把观众带进一堆术语，而是有能力把复杂的东西讲简单，同时不丢失准确性。</p>
<h2 id="三内容方向和比例">三、内容方向和比例</h2>
<p>起步阶段不宜在手机、汽车、相机和电脑之间反复跳跃。观众需要先能用一句话记住这个账号，之后才会接受内容边界的扩展。</p>
<p>初期可以按以下比例规划：</p>
<table>
	<thead>
			<tr>
					<th>内容方向</th>
					<th style="text-align: right">比例</th>
					<th>主要作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>耳机、麦克风、音箱、直播设备</td>
					<td style="text-align: right">50%</td>
					<td>建立专业标签和账号辨识度</td>
			</tr>
			<tr>
					<td>AI 语音、AI 硬件、智能设备</td>
					<td style="text-align: right">25%</td>
					<td>承接科技热点和新产品</td>
			</tr>
			<tr>
					<td>手机、电脑等泛科技产品</td>
					<td style="text-align: right">15%</td>
					<td>逐步扩大受众范围</td>
			</tr>
			<tr>
					<td>程序员视角和行业故事</td>
					<td style="text-align: right">10%</td>
					<td>建立真实的个人形象</td>
			</tr>
	</tbody>
</table>
<p>在表现形式上，可以先建立四个固定栏目。</p>
<h3 id="1-这项技术到底有没有用">1. 这项技术到底有没有用</h3>
<p>负责解释消费者经常看到，但并不真正理解的概念。</p>
<ul>
<li>主动降噪为什么消不掉人声？</li>
<li>蓝牙“无损”是真无损吗？</li>
<li>空间音频到底是不是智商税？</li>
<li>手机厂商说的 AI 通话降噪是什么？</li>
<li>耳机上有多个麦克风到底有什么用？</li>
</ul>
<h3 id="2-程序员实测">2. 程序员实测</h3>
<p>这是最值得做成招牌的栏目。科技博主很多，但愿意认真控制实验条件的人并不多。</p>
<ul>
<li>200 元和 2000 元麦克风的盲听对比；</li>
<li>地铁、刮风和人群环境下的耳机通话测试；</li>
<li>AI 降噪能不能消除键盘、风扇和装修声；</li>
<li>手机、无线耳机和专业录音笔的同场对比；</li>
<li>在音量匹配后比较不同的音质模式。</li>
</ul>
<p>测试时应尽量做到音量匹配、环境一致、条件公开，并清楚区分主观感受和客观数据。长期下来，这套可重复的实验方法会成为账号的护城河。</p>
<h3 id="3-一分钟购买建议">3. 一分钟购买建议</h3>
<p>直接解决消费决策，这类内容容易获得收藏和搜索流量。</p>
<ul>
<li>通勤耳机应该优先看什么？</li>
<li>开会用耳机，音质和麦克风哪个更重要？</li>
<li>普通人有没有必要买独立麦克风？</li>
<li>直播新手的第一套设备应该怎么搭？</li>
<li>预算 500 元，应该先升级耳机还是麦克风？</li>
</ul>
<h3 id="4-工程师看新品">4. 工程师看新品</h3>
<p>这个栏目用来跟进热点，但不复述发布会，而是固定回答五个问题：</p>
<ol>
<li>新产品增加了什么？</li>
<li>它背后的技术是什么？</li>
<li>用户在实际使用中能不能感知？</li>
<li>哪些是技术进步，哪些是宣传包装？</li>
<li>什么样的人值得购买？</li>
</ol>
<h2 id="四从模仿开始但不复制别人">四、从模仿开始，但不复制别人</h2>
<p>模仿成熟博主是很好的入门方式，但应该模仿的是内容机制，而不是人设、文案和标志性表达。</p>
<p>拆解一条优秀视频时，可以关注：</p>
<ul>
<li>博主为什么选这个题；</li>
<li>标题制造了什么疑问或冲突；</li>
<li>前 5 秒如何留住观众；</li>
<li>什么时候给出结论；</li>
<li>用实验、故事还是争议证明观点；</li>
<li>一条视频中有多少次节奏变化；</li>
<li>评论区的观众还在追问什么。</li>
</ul>
<p>可以同时选择三类学习对象：一位擅长选题和标题，一位擅长把技术讲清楚，一位擅长镜头表达和节奏。把三者的优点组合起来，比完整模仿某一个人更容易形成自己的风格。</p>
<h2 id="五固定视频结构">五、固定视频结构</h2>
<p>面向普通消费者，可以先使用一个简单、可重复的脚本结构：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt">1
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">生活场景 → 直接结论 → 对比实验 → 简单原理 → 购买建议</span></span></code></pre></td></tr></table>
</div>
</div>
<p>例如讲降噪耳机，可以用一个普通用户经历过的问题开场：</p>
<blockquote>
<p>你的降噪耳机能消掉地铁声，却消不掉旁边的人说话，不一定是产品质量差。因为这两种声音对降噪算法来说，难度完全不同。</p>
</blockquote>
<p>紧接着播放对比实验，等观众已经产生疑问后，再解释稳定噪声和突发人声的区别。不宜一开头就从“主动降噪的定义”讲起。</p>
<p>表达风格可以定为“可信赖的工程师朋友”：</p>
<ul>
<li>敢于给出明确结论，但会说明结论适用的条件；</li>
<li>能够讲原理，但不用术语炫技；</li>
<li>敢于质疑营销，但不刻意制造争议；</li>
<li>承认主观体验的存在，不把个人喜好包装成科学结论；</li>
<li>适当分享开发经历，但严格遵守公司的保密要求。</li>
</ul>
<p>还可以尝试用一句固定结尾强化账号记忆：</p>
<blockquote>
<p>参数负责告诉我们它能做什么，实验负责告诉我们它做得怎么样。</p>
</blockquote>
<h2 id="六第一批选题">六、第一批选题</h2>
<p>第一批内容不应全部做新品评测，而应该同时测试实验、解释、购买建议和观点等不同内容模式。</p>
<ol>
<li>降噪耳机为什么消不掉小孩哭声？</li>
<li>视频会议声音难听，真的是耳机太差吗？</li>
<li>蓝牙无损音质，普通人到底能不能听出来？</li>
<li>200 元和 2000 元麦克风，直播时差距有多大？</li>
<li>主播声音好听，麦克风和后期各占多少？</li>
<li>AI 降噪能否消除机械键盘、风扇和装修声？</li>
<li>耳机麦克风数量越多，通话效果就越好吗？</li>
<li>为什么语音消息听起来没有原声好听？</li>
<li>空间音频是实用功能，还是营销概念？</li>
<li>买耳机时最没必要纠结的三个参数。</li>
</ol>
<p>其中，第 1、3、4、6 个选题更适合做实验，第 2、5、8 个选题更适合用故事引入，第 9、10 个选题则用来测试观点型内容。</p>
<p>如果只选一条作为起点，我会选《降噪耳机为什么消不掉人声？》。这个问题认知门槛低、受众广、实验效果明显，又能立即展示自己的专业背景。</p>
<h2 id="七一次研究生产多种内容">七、一次研究，生产多种内容</h2>
<p>在职状态下，时间是最稀缺的资源，不能为每个平台分别研究一个选题。更可行的方式是：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt">1
</span><span class="lnt">2
</span><span class="lnt">3
</span><span class="lnt">4
</span><span class="lnt">5
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">一个选题
</span></span><span class="line"><span class="cl">├── 一条 5～10 分钟的完整视频
</span></span><span class="line"><span class="cl">├── 两到三条结论型短视频
</span></span><span class="line"><span class="cl">├── 一篇完整的博客文章
</span></span><span class="line"><span class="cl">└── 若干图文卡片或问答</span></span></code></pre></td></tr></table>
</div>
</div>
<p>平台分工可以先简化为：</p>
<ul>
<li>B 站发布完整内容，建立专业度和长期搜索价值；</li>
<li>抖音或视频号发布短内容，快速测试选题和开头；</li>
<li>现有博客保存原始录音、实验数据、参考资料和完整原理。</li>
</ul>
<p>音频内容有一个特殊问题：视频平台会压缩声音，用户使用的播放设备也不同，所以视频中的音质对比未必可靠。可以在博客中补充：</p>
<ul>
<li>未经平台压缩的原始录音；</li>
<li>测试设备、环境和完整流程；</li>
<li>视频中省略的技术解释；</li>
<li>错误修正和长期使用更新。</li>
</ul>
<p>视频负责吸引和解释，博客负责证据和沉淀，两者正好互补。</p>
<h2 id="八用-30-天做一次低成本验证">八、用 30 天做一次低成本验证</h2>
<p>第一个月的目标不是购买昂贵设备，也不是立即涨多少粉丝，而是验证一套内容生产闭环。</p>
<h3 id="第一周完成准备">第一周：完成准备</h3>
<ul>
<li>确定一句账号定位；</li>
<li>拆解 10 个相关账号、30 条表现较好的视频；</li>
<li>建立一个至少包含 20 个题目的选题库；</li>
<li>确定简单统一的封面和视频结构；</li>
<li>使用已有设备录制 3 条样片。</li>
</ul>
<h3 id="后三周发布和复盘">后三周：发布和复盘</h3>
<ul>
<li>每周发布 2 条短内容；</li>
<li>每两周发布 1 条完整内容；</li>
<li>记录每条内容的研究、拍摄和剪辑耗时；</li>
<li>从评论区收集用户追问，补充下一轮选题；</li>
<li>对同一个主题尝试两种开头、标题或封面。</li>
</ul>
<p>需要重点观察的不只是播放量，还包括：</p>
<ul>
<li>观众在前几秒的流失情况；</li>
<li>完播率或平均观看时长；</li>
<li>收藏、有效评论和关注转化；</li>
<li>每条内容的实际制作时间。</li>
</ul>
<p>30 天后需要回答的不是“我有没有成功”，而是四个更实际的问题：</p>
<ol>
<li>哪类题目最容易让人点开？</li>
<li>哪种表达最容易让人看完？</li>
<li>哪类观众愿意追问并关注？</li>
<li>哪种内容可以保持长期、低成本生产？</li>
</ol>
<h2 id="九变现不应该只依赖播放量">九、变现不应该只依赖播放量</h2>
<p>这件事如果最终要成为创业方向，就不能只把播放量和平台补贴当成收入模型。结合自己的背景，比较合适的变现顺序可能是：</p>
<ol>
<li>音频设备、直播设备的内容合作和销售佣金；</li>
<li>直播间、播客、会议和录音环境的音频诊断；</li>
<li>音视频产品或 AI 语音产品的技术咨询；</li>
<li>企业培训、课程和知识产品；</li>
<li>自己开发小工具、插件或测试服务；</li>
<li>账号成熟后的品牌广告和长期栏目赞助。</li>
</ol>
<p>本质上，目标不是只做一个“靠流量吃饭的媒体”，而是：</p>
<blockquote>
<p>用大众内容建立影响力，再用专业能力完成高价值变现。</p>
</blockquote>
<p>这种模式与现有职业经验衔接得更好，也比单纯依赖广告分成更稳定。</p>
<h2 id="十信任和职业边界">十、信任和职业边界</h2>
<p>科技消费内容一旦开始变现，最容易损伤的就是观众信任。因此，需要尽早建立几条原则：</p>
<ul>
<li>区分自购、借测、商业合作和佣金链接；</li>
<li>商业合作不影响测试方法和结论表达；</li>
<li>不为了流量轻易使用“吊打”“智商税”“彻底改变行业”等绝对化表达；</li>
<li>测试方法、限制条件和判断依据尽可能公开。</li>
</ul>
<p>同时，在职创作还必须提前检查劳动合同、竞业和保密要求。不使用公司的代码、数据、客户信息和未公开的产品细节，测试设备、账号和制作时间也尽量与工作分开。</p>
<h2 id="结语先完成一个最小闭环">结语：先完成一个最小闭环</h2>
<p>现阶段比较清晰的方向，可以暂时概括为“声音科技实验室”：用真实实验拆解耳机、麦克风、直播和 AI 语音产品，面向普通消费者和科技爱好者讲清楚一项技术的价值、限制和购买建议。</p>
<p>起步时不需要立即购买大量设备，也不需要同时经营所有平台。先用手机、现有耳机和电脑，以“真人讲解＋桌面实验＋少量动画”的方式，完成从选题、实验、拍摄、剪辑、发布到复盘的第一个闭环。</p>
<p>第一个里程碑不是“成为大博主”，而是发出第一条能代表自己未来方向的内容，再根据真实反馈继续调整。</p>
]]></content:encoded>
    </item>
    <item>
      <title>用 OpenSpec 重构 AI Coding 工作流：让每次开发都可追溯、可恢复、可沉淀</title>
      <link>https://lyapple2008.github.io/posts/202609/2026-09-28-ai-coding%E5%B7%A5%E4%BD%9C%E6%B5%81openspec/</link>
      <pubDate>Mon, 28 Sep 2026 07:22:02 +0800</pubDate>
      <guid>https://lyapple2008.github.io/posts/202609/2026-09-28-ai-coding%E5%B7%A5%E4%BD%9C%E6%B5%81openspec/</guid>
      <description>AI Coding 快了，但方案反复、决策丢失和上下文中断也变得更常见。这篇文章介绍如何用 OpenSpec 把 Explore、Propose、Review、Apply 和 Archive 串成一条可复用的规格驱动开发流程。</description>
      <content:encoded><![CDATA[<p>AI Coding 用得越多，我越能感觉到两个问题。</p>
<p>第一个问题是：<strong>开发过程没有留下足够的中间记录。</strong></p>
<p>Agent 可以很快生成大量代码，但方案不对时，常常只能整段推倒重来；某个架构决策是在对话里做的，过两天就不记得当时为什么这样选；一次任务被打断，换一个会话后，Agent 又要从头理解需求和已经做过的工作。真正丢失的不只是上下文，还有上下文中包含的判断。</p>
<p>第二个问题是：<strong>AI Coding Agent 没有跟着我和项目一起成长。</strong></p>
<p>今天解决过的问题，下个月还可能重新踩坑；Agent 参与同一个项目十次，第十一次也不一定比第一次更熟悉。每次会话都很聪明，长期看却像一个不断失忆的新同事。</p>
<p>我开始学习 OpenSpec，就是希望先解决第一个问题，再看看它能为第二个问题提供多少基础。</p>
<h2 id="openspec-是什么">OpenSpec 是什么</h2>
<p>OpenSpec 不是一个新的 Coding Agent，也不是一种更神奇的 Prompt。它更像一套面向 AI Coding 的变更管理协议：在写代码之前，先把问题、要求、设计和任务写成文件；实现时按任务执行；完成后再把已经落地的行为合并到项目的长期规格中。</p>
<p>它的核心不是“多写几份文档”，而是把 AI Coding 从一次性对话，变成一个有明确状态的流程。</p>
<p>OpenSpec 中有两类关键信息：</p>
<ul>
<li><code>openspec/changes/</code> 保存正在进行的变更，回答“这一次为什么改、改什么、怎么改”；</li>
<li><code>openspec/specs/</code> 保存系统当前已经实现的行为，回答“这个系统现在应该怎样工作”。</li>
</ul>
<p>前者是变更日志，后者是随代码演进的活文档。当一次变更被 Archive，其中的需求会进入主 Spec，变更目录则被移入 <code>openspec/changes/archive/</code>。</p>
<h2 id="安装和初始化">安装和初始化</h2>
<p>OpenSpec 需要 Node.js 20.19.0 或更高版本。可以使用 npm 安装：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt">1
</span><span class="lnt">2
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">npm install -g @fission-ai/openspec@latest
</span></span><span class="line"><span class="cl">openspec --version</span></span></code></pre></td></tr></table>
</div>
</div>
<p>macOS 也可以直接使用 Homebrew：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt">1
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">brew install openspec</span></span></code></pre></td></tr></table>
</div>
</div>
<p>然后在项目根目录执行：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt">1
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">openspec init</span></span></code></pre></td></tr></table>
</div>
</div>
<p><code>init</code> 会询问正在使用哪些 AI 工具，为 Claude Code、Codex、Cursor 等工具安装对应的 Skill 或命令，并在项目中生成：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt">1
</span><span class="lnt">2
</span><span class="lnt">3
</span><span class="lnt">4
</span><span class="lnt">5
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">openspec/
</span></span><span class="line"><span class="cl">├── config.yaml       # 项目上下文和工作流规则
</span></span><span class="line"><span class="cl">├── specs/            # 已经上线的系统规格
</span></span><span class="line"><span class="cl">└── changes/          # 正在开发的变更
</span></span><span class="line"><span class="cl">    └── archive/      # 已完成的变更记录</span></span></code></pre></td></tr></table>
</div>
</div>
<p>这些都是普通文本文件，应该和代码一起提交到 Git，而不是仅保存在某一次会话中。初始化或 OpenSpec 升级后，可以用 <code>openspec update</code> 刷新项目中的 Skills 和命令。</p>
<p><code>config.yaml</code> 值得单独提一下。它的 <code>context</code> 会进入每个 OpenSpec 工作流，适合放置会影响所有变更的少量事实；<code>rules</code> 可以约束某类产物；<code>operations</code> 则能约束 Apply 和 Archive 如何执行。例如：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt"> 1
</span><span class="lnt"> 2
</span><span class="lnt"> 3
</span><span class="lnt"> 4
</span><span class="lnt"> 5
</span><span class="lnt"> 6
</span><span class="lnt"> 7
</span><span class="lnt"> 8
</span><span class="lnt"> 9
</span><span class="lnt">10
</span><span class="lnt">11
</span><span class="lnt">12
</span><span class="lnt">13
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-yaml" data-lang="yaml"><span class="line"><span class="cl"><span class="nt">context</span><span class="p">:</span><span class="w"> </span><span class="p">|</span><span class="sd">
</span></span></span><span class="line"><span class="cl"><span class="sd">  Tech stack: TypeScript, Node.js, PostgreSQL
</span></span></span><span class="line"><span class="cl"><span class="sd">  所有 API 变更都必须兼容现有客户端
</span></span></span><span class="line"><span class="cl"><span class="sd">  所有 OpenSpec 产物使用中文</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="nt">rules</span><span class="p">:</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  </span><span class="nt">tasks</span><span class="p">:</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span>- <span class="l">每个 API 任务都要包含自动化测试</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="nt">operations</span><span class="p">:</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  </span><span class="nt">apply</span><span class="p">:</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="nt">guidance</span><span class="p">:</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">      </span>- <span class="l">在标记任务完成前运行测试和 Lint</span></span></span></code></pre></td></tr></table>
</div>
</div>
<p>配置要尽量短。能从代码读出来的信息没必要重复塞进去，否则只会占用 Agent 的上下文。</p>
<h2 id="一条完整的-openspec-工作流">一条完整的 OpenSpec 工作流</h2>
<p>OpenSpec 官方的核心流程是 Explore → Propose → Review → Apply → Archive。如果把“发现问题后如何回退”也画进去，完整的开发过程更像下面这样：</p>

<div class="mermaid">flowchart LR
    idea[&#34;需求 / 问题&#34;] --&gt; explore[&#34;1. Explore&lt;br/&gt;读代码、澄清边界、比较方案&#34;]
    explore --&gt; propose[&#34;2. Propose&lt;br/&gt;生成 Proposal、Spec、Design、Tasks&#34;]
    propose --&gt; review{&#34;3. Review&lt;br/&gt;人工确认问题、验收条件和任务&#34;}
    review -- &#34;方案不对&#34; --&gt; propose
    review -- &#34;确认&#34; --&gt; apply[&#34;4. Apply&lt;br/&gt;按 tasks.md 逐项实现和验证&#34;]
    apply -- &#34;需求或设计发现问题&#34; --&gt; propose
    apply -- &#34;中断 / 换会话&#34; --&gt; resume[&#34;读取变更文件&lt;br/&gt;从第一个未完成任务继续&#34;]
    resume --&gt; apply
    apply -- &#34;代码、测试、验收全部通过&#34; --&gt; archive[&#34;5. Archive&lt;br/&gt;同步主 Spec，归档变更&#34;]
    archive -. &#34;下一个变更&#34; .-&gt; idea</div>
<p>这条流程最重要的是：**代码不是一开始就出现，而是在规格经过确认后才出现。**修改几段 Markdown 的成本，远低于让 Agent 重写几千行代码。</p>
<h2 id="放进一个真实需求中怎么用">放进一个真实需求中怎么用</h2>
<p>以“接入 RNNoise 降噪模型”为例。最初的需求往往只有一句话：</p>
<blockquote>
<p>在现有实时音频处理链路中接入 RNNoise，降低环境噪声。</p>
</blockquote>
<p>这句话还不能直接变成代码。按 OpenSpec 流程，可以这样做。</p>
<h3 id="1-explore先把问题想清楚">1. Explore：先把问题想清楚</h3>
<p>在 AI 对话中说：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt">1
</span><span class="lnt">2
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">请用 OpenSpec Explore 模式调查接入 RNNoise 降噪模型的需求。
</span></span><span class="line"><span class="cl">先读取现有音频采集、重采样、编码和线程调度代码，画出当前音频链路，列出需要确认的边界和备选方案，暂时不写代码。</span></span></code></pre></td></tr></table>
</div>
</div>
<p>Explore 阶段应该回答这些问题：</p>
<ul>
<li>当前输入音频的采样率、通道数、数据类型和每次回调帧长是什么？</li>
<li>RNNoise 放在采集、重采样、AEC、AGC 和编码之间的哪个位置？</li>
<li>使用 RNNoise 原生 C 实现，还是将模型导出为 ONNX 并通过 ORT 推理？</li>
<li>上游回调长度不固定时，如何组成 RNNoise 需要的 480 个采样点、10 ms 帧？</li>
<li>单声道、立体声和多路并发音频如何处理，每条流的模型状态由谁持有？</li>
<li>可接受的额外延迟、CPU 占用和内存上限是多少，初始化失败时是中断链路还是旁路原始音频？</li>
</ul>
<p>如果这些结论没有想清楚，Agent 越快，只会越快地实现一个错误方案。</p>
<h3 id="2-propose把讨论变成可审查的文件">2. Propose：把讨论变成可审查的文件</h3>
<p>方向确认后，继续说：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt">1
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">请就刚才确认的 RNNoise 接入方案创建 OpenSpec change，变更名称为 integrate-rnnoise-denoiser。</span></span></code></pre></td></tr></table>
</div>
</div>
<p>Agent 会创建类似这样的目录：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt">1
</span><span class="lnt">2
</span><span class="lnt">3
</span><span class="lnt">4
</span><span class="lnt">5
</span><span class="lnt">6
</span><span class="lnt">7
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">openspec/changes/integrate-rnnoise-denoiser/
</span></span><span class="line"><span class="cl">├── proposal.md       # 为什么做，改动范围是什么
</span></span><span class="line"><span class="cl">├── specs/
</span></span><span class="line"><span class="cl">│   └── rnnoise-denoising/
</span></span><span class="line"><span class="cl">│       └── spec.md  # 可验收的行为要求
</span></span><span class="line"><span class="cl">├── design.md         # 关键技术决策，需要时才创建
</span></span><span class="line"><span class="cl">└── tasks.md          # 实现清单和进度</span></span></code></pre></td></tr></table>
</div>
</div>
<p><code>spec.md</code> 不应该只写“接入 RNNoise”，而应该写成可验收的系统行为。例如：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt"> 1
</span><span class="lnt"> 2
</span><span class="lnt"> 3
</span><span class="lnt"> 4
</span><span class="lnt"> 5
</span><span class="lnt"> 6
</span><span class="lnt"> 7
</span><span class="lnt"> 8
</span><span class="lnt"> 9
</span><span class="lnt">10
</span><span class="lnt">11
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-markdown" data-lang="markdown"><span class="line"><span class="cl"><span class="gu">### Requirement: 实时 RNNoise 降噪
</span></span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">系统必须在实时音频链路中按 RNNoise 帧规格连续处理音频，并保持输出的时序和时长与输入一致。
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="gu">#### Scenario: 处理任意长度的音频回调
</span></span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">-</span> **WHEN** 上游输入 48 kHz 单声道 PCM，且每次回调的采样点数不固定
</span></span><span class="line"><span class="cl"><span class="k">-</span> **THEN** 系统必须先缓冲并组成 480 个采样点的完整帧
</span></span><span class="line"><span class="cl"><span class="k">-</span> **AND** 每个完整帧必须严格按时间顺序调用一次 RNNoise 推理
</span></span><span class="line"><span class="cl"><span class="k">-</span> **AND** 同一条音频流必须在相邻帧之间复用同一个模型状态
</span></span><span class="line"><span class="cl">- <span class="gs">**AND**</span> 新建音频流或发生不连续跳转时必须重置状态</span></span></code></pre></td></tr></table>
</div>
</div>
<p><code>design.md</code> 则应该记录“为什么”：为什么选原生 RNNoise 或 ONNX Runtime，为什么在重采样之后、编码之前执行降噪，如何管理每条流的隐状态，多声道是独立降噪还是先混音，曾经考虑过哪些方案又为什么放弃。这些内容比最后那几行推理调用更值得保留。</p>
<h3 id="3-review把最贵的错误留在纸面上">3. Review：把最贵的错误留在纸面上</h3>
<p>Propose 完成后不要立即点头让 Agent 写代码。建议按下面的顺序审查：</p>
<ol>
<li>看 <code>proposal.md</code>：解决的是不是正确问题，范围是不是过大；</li>
<li>重点看 <code>specs/</code>：每条要求能否验收，边界和异常是否完整；</li>
<li>有架构取舍时看 <code>design.md</code>：假设、备选方案和风险是否讲清楚；</li>
<li>最后看 <code>tasks.md</code>：任务是否覆盖所有 Spec，有没有夹带与需求无关的重构。</li>
</ol>
<p>发现“现有采集输出其实是 44.1 kHz 立体声”或“多路音频不能共用同一个 RNNoise 状态”，可以直接编辑 Markdown，也可以让 Agent 更新变更文件。审查完成前，不产生业务代码。</p>
<h3 id="4-apply换一个干净上下文开始实现">4. Apply：换一个干净上下文开始实现</h3>
<p>OpenSpec 官方建议在新的会话中执行 Apply，把上一阶段的讨论噪声留在规格外面。可以直接说：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt">1
</span><span class="lnt">2
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">请 Apply integrate-rnnoise-denoiser 这个 OpenSpec change。
</span></span><span class="line"><span class="cl">按 tasks.md 逐项实现，每项完成后运行对应验证，只在通过后勾选任务。</span></span></code></pre></td></tr></table>
</div>
</div>
<p>Agent 会先读取这次变更的文件，再按 <code>tasks.md</code> 逐项实现。如果中途被打断，在新会话中再次要求 Apply 即可，新 Agent 会从第一个未勾选的任务继续。</p>
<p>如果实现过程发现原方案有问题，不要只在代码中偷偷改口径。先修正 Spec、Design 或 Tasks，再继续 Apply。否则文档与代码会从这里开始分叉。</p>
<h3 id="5-verify-和-archive用事实关闭变更">5. Verify 和 Archive：用事实关闭变更</h3>
<p>验收不能依赖 Agent 的一句“已完成”。至少要根据 Spec 执行：</p>
<ul>
<li>单元测试和集成测试；</li>
<li>不同回调长度下的 480 采样点组帧、缓冲和输出时序测试；</li>
<li>多路音频的状态隔离，以及停止、重启和不连续跳转时的状态重置；</li>
<li>使用固定 WAV 样本与 RNNoise 参考实现做输出对比，同时检查 NaN、削波和样本数变化；</li>
<li>在目标设备上测量额外延迟、实时线程 CPU 占用、内存分配和长时间运行稳定性；</li>
<li>模型初始化失败、禁用降噪和不支持输入格式时，旁路策略符合 Spec。</li>
</ul>
<p>OpenSpec 还提供可选的 Verify 工作流，可用来检查实现是否与变更产物一致。默认配置不一定安装它，没有 Verify 时，也可以让另一个新会话根据 Spec 做独立 Review。</p>
<p>所有任务、测试和人工验收全部通过后，再说：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt">1
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">请 Archive integrate-rnnoise-denoiser 这个 OpenSpec change。</span></span></code></pre></td></tr></table>
</div>
</div>
<p>Archive 会把这次变更的行为要求合并到 <code>openspec/specs/</code>，并把变更目录移入 <code>openspec/changes/archive/</code>。Git 仍然是独立的事：规格、代码和测试应该在同一条变更链上提交和审查。</p>
<h2 id="openspec-如何解决没有中间记录">OpenSpec 如何解决“没有中间记录”</h2>
<p>回到开头的第一个问题，OpenSpec 的作用非常直接。</p>
<table>
	<thead>
			<tr>
					<th>AI Coding 中的问题</th>
					<th>OpenSpec 的对应机制</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Agent 方案不符合预期，代码需要重写</td>
					<td>在 Propose 和 Review 阶段先修正文本，延迟代码生成</td>
			</tr>
			<tr>
					<td>不记得某个决策为什么做</td>
					<td><code>proposal.md</code> 和 <code>design.md</code> 保存背景、备选方案与取舍</td>
			</tr>
			<tr>
					<td>中途打断或上下文用完</td>
					<td>变更文件提供上下文，<code>tasks.md</code> 勾选项提供显式进度</td>
			</tr>
			<tr>
					<td>不知道代码是否真的完成</td>
					<td>Spec 把“完成”改写为可验收的场景</td>
			</tr>
			<tr>
					<td>对话结束后信息消失</td>
					<td>文件进入 Git，Archive 保留变更历史并更新主 Spec</td>
			</tr>
	</tbody>
</table>
<p>其中我认为最重要的一点是：**进度不再是 Agent 脑中的隐藏状态。**只要仓库还在，任何 Agent 都能通过读取文件重建任务状态。会话可以丢，工作不应该一起丢。</p>
<h2 id="openspec-能否让-agent-跟着项目成长">OpenSpec 能否让 Agent 跟着项目成长</h2>
<p>答案是：<strong>能解决一部分，但还不是真正的“成长”。</strong></p>
<p>OpenSpec 确实会让后来的 Agent 比以前更容易理解项目：</p>
<ul>
<li><code>specs/</code> 持续积累系统已经承诺的行为；</li>
<li><code>changes/archive/</code> 保留每一次变更的原因和过程；</li>
<li><code>config.yaml</code> 把长期有效的项目约束注入每次工作流；</li>
<li>决策与代码共同版本化，可以被审查、回滚和追溯。</li>
</ul>
<p>这些解决的是“项目记忆”：Agent 进场后有一套更可靠的外部记忆可以读。</p>
<p>但<strong>历史记录不等于学习</strong>。OpenSpec 不会自动判断哪个过去的经验值得在新任务中复用，不会把一次线上故障自动提炼成新的审查规则，也不会记住使用者跨项目的偏好。如果没有整理，归档目录只会越来越大，而不一定越来越有用。</p>
<p>所以 OpenSpec 更像是一层必要的基础设施：它先把经验从会话中捞出来，但还需要更强的 Agent 把经验变成能够被下一次任务精准调用的知识。</p>
<h2 id="我期待的下一代-ai-coding-agent">我期待的下一代 AI Coding Agent</h2>
<p>我理想中的 Agent 不是“永远不忘记任何事”。那只会制造更大的上下文和更多过期信息。真正的成长，应该包含三层记忆：</p>
<ol>
<li><strong>项目记忆</strong>：系统行为、架构边界、关键决策、当前任务和已知风险；</li>
<li><strong>经验记忆</strong>：哪些方案曾经失败、为什么失败、后来如何修复、怎样提前发现；</li>
<li><strong>个人记忆</strong>：使用者偏好的实现方式、可接受的风险、审查习惯和解释粒度。</li>
</ol>
<p>这些记忆不能只管写入，还要有一个可审查的学习闭环：</p>

<div class="mermaid">flowchart LR
    work[&#34;需求开发 / Bug / 线上故障&#34;] --&gt; reflect[&#34;复盘：提取候选经验&#34;]
    reflect --&gt; approve{&#34;人工确认&lt;br/&gt;是否正确、可复用&#34;}
    approve -- &#34;否&#34; --&gt; discard[&#34;丢弃或仅保留原始记录&#34;]
    approve -- &#34;是&#34; --&gt; memory[&#34;写入项目 / 经验 / 个人记忆&#34;]
    memory --&gt; retrieve[&#34;新任务只检索相关记忆&#34;]
    retrieve --&gt; plan[&#34;影响 Explore、Spec 和 Review&#34;]
    plan --&gt; measure[&#34;用测试、Review 和结果验证&#34;]
    measure --&gt; update[&#34;加强、修正、降权或过期&#34;]
    update --&gt; memory</div>
<p>这样的 Agent 才不是把历史聊天全部塞进 Prompt，而是能够做四件事：</p>
<ul>
<li>知道什么值得记住，什么只是当时的噪声；</li>
<li>在正确的任务中取回正确的经验，而不是无差别加载所有过去；</li>
<li>当代码、Spec 和现实冲突时，会质疑旧知识，而不是把它当成永久真理；</li>
<li>让使用者知道 Agent 记住了什么，并可以删除、修正、回滚和限制范围。</li>
</ul>
<p>我希望未来每次解决问题都不是一次性的 Token 消耗，而是给下一次开发降低一点成本。第一次需要我提醒 Agent 项目中的并发约束，第二次它应该主动检查，第三次这条经验应该已经变成 Spec、测试或工具中的自动化护栏。</p>
<h2 id="使用-openspec-的几个建议">使用 OpenSpec 的几个建议</h2>
<h3 id="一次-change-只解决一个可验收目标">一次 Change 只解决一个可验收目标</h3>
<p>“重写账户系统”太大，“修改一个变量名”又不需要完整流程。更合适的粒度是：完成后能独立验收、必要时能独立回滚的一个行为变更。</p>
<h3 id="spec-写行为design-写取舍">Spec 写行为，Design 写取舍</h3>
<p>Spec 描述外部可观察的行为和验收条件，不要把实现细节全部复制进去。Design 记录需要长期保留的技术决策，尤其是被放弃的方案和取舍原因。</p>
<h3 id="不要让文档与代码分叉">不要让文档与代码分叉</h3>
<p>实现中改了方案，先更新变更产物；合并代码时同时合并 Spec；验收未完成时不要急着 Archive。文档一旦失真，Agent 就会在错误的记忆上继续工作。</p>
<h3 id="不是所有修改都需要仪式">不是所有修改都需要仪式</h3>
<p>拼写修正、明显的小 Bug 和无行为变化的重构，未必值得写完整 Proposal。OpenSpec 是用来降低歧义和变更风险的，不是把每一行代码都变成审批流程。</p>
<h2 id="最后">最后</h2>
<p>AI Coding 放大了代码生成速度，也放大了错误方案的扩散速度。在这个阶段，仅仅追求“让 Agent 写得更快”还不够，我们需要的是一套让人和 Agent 都能知道正在做什么、为什么这样做、做到哪一步的工作流。</p>
<p>OpenSpec 的价值，就是把“聊过”变成“写下来”，把“Agent 说做完了”变成“按 Spec 验证过了”，把“换个会话就重来”变成“从下一个未完成任务继续”。</p>
<p>它还没有让 Agent 真正学会长期成长，但已经先为成长准备了可信的原料：规格、决策、任务、验证和变更历史。我期待下一步，AI Coding Agent 能在这些原料上形成可审查、可纠正、可遗忘的长期记忆。到那时，它才不只是一个每次都很聪明的临时工，而是一个真正会随着使用者和项目共同进化的协作者。</p>
<h2 id="参考资料">参考资料</h2>
<ul>
<li><a href="https://openspec.dev/docs/installation">OpenSpec Installation</a></li>
<li><a href="https://openspec.dev/docs/setup">OpenSpec Set up your project</a></li>
<li><a href="https://openspec.dev/docs/quickstart">OpenSpec Quickstart</a></li>
<li><a href="https://openspec.dev/docs/project-config">OpenSpec Project configuration</a></li>
<li><a href="https://github.com/Fission-AI/OpenSpec">OpenSpec GitHub</a></li>
</ul>
]]></content:encoded>
    </item>
    <item>
      <title>当代码越来越便宜，软件工程师还值钱吗？</title>
      <link>https://lyapple2008.github.io/posts/202609/2026-09-17-chatgpt%E7%BB%99%E8%BD%AF%E4%BB%B6%E5%B7%A5%E7%A8%8B%E5%B8%88%E7%9A%84%E5%BB%BA%E8%AE%AE/</link>
      <pubDate>Thu, 17 Sep 2026 16:55:34 +0800</pubDate>
      <guid>https://lyapple2008.github.io/posts/202609/2026-09-17-chatgpt%E7%BB%99%E8%BD%AF%E4%BB%B6%E5%B7%A5%E7%A8%8B%E5%B8%88%E7%9A%84%E5%BB%BA%E8%AE%AE/</guid>
      <description>当代码生成越来越便宜，工程师真正稀缺的能力是什么？这篇文章整理了我和 ChatGPT 关于职业前景的一次长谈，以及一条从 AI Coding、Spec 到 Agent Engineering 的个人进阶路线。</description>
      <content:encoded><![CDATA[<p>AI Coding 已经进入软件开发的完整流程：读代码、写代码、补测试、查问题、改文档，甚至可以自己运行命令，再根据结果继续迭代。它带来的不只是效率提升，也有一个越来越难回避的问题：</p>
<blockquote>
<p>当 AI 可以完成越来越多开发工作，以后还需要软件工程师吗？如果需要，工程师真正值钱的能力又是什么？</p>
</blockquote>
<p>最近我把这个问题抛给了 ChatGPT，又结合自己的情况继续追问：一个已经做了多年 C/C++、音视频和移动端开发的工程师，应该继续深挖原来的技术栈，还是转向 AI Agent？如果要转，具体该学什么？</p>
<p>讨论很长，下面不是聊天记录的原样搬运，而是我重新整理后的结论和行动路线。</p>
<p>先说答案：<strong>软件工程师仍然需要，但“会写代码”不再足以定义一个软件工程师。</strong></p>
<p>AI 改变的不是软件是否还要有人负责，而是代码正在从稀缺的生产能力，变成越来越便宜的生产资料。未来更稀缺的，是能把模糊问题变成正确系统、能驾驭 AI 完成交付，并能判断结果是否可靠的人。</p>
<h2 id="一消失的不是工程师而是代码生产的溢价">一、消失的不是工程师，而是代码生产的溢价</h2>
<p>过去的软件开发流程大致是：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt">1
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">需求 → 设计 → 写代码 → Debug → 测试 → 发布 → 维护</span></span></code></pre></td></tr></table>
</div>
</div>
<p>其中大量时间花在查 API、写样板代码、补测试、重构和整理文档上。如今这些环节正在被 AI 快速压缩，新的流程更像：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt">1
</span><span class="lnt">2
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">问题 → 需求澄清 → 系统设计 → 任务拆解 → Agent 实现
</span></span><span class="line"><span class="cl">     → 自动验证 → 人工决策 → 上线 → 持续反馈</span></span></code></pre></td></tr></table>
</div>
</div>
<p>这里有一个很重要的变化：<strong>代码生产的成本下降了，决策、验证和责任的成本却没有一起消失。</strong></p>
<p>AI 可以在几分钟内生成上千行代码，但它并不知道业务到底想解决什么，不会天然理解系统里的隐性约束，也不会替团队承担线上事故的责任。生成得越快，人越需要回答三个问题：</p>
<ol>
<li>做的是不是正确的问题？</li>
<li>采用的是不是合适的系统方案？</li>
<li>结果凭什么值得相信？</li>
</ol>
<p>这意味着软件开发正在经历一次“抽象层上移”。过去工程师的主要产出是代码，接下来更重要的产出会逐渐变成：清晰的问题定义、可执行的规格、合理的系统边界，以及可验证的交付结果。</p>
<h2 id="二未来更重要的五种能力">二、未来更重要的五种能力</h2>
<p>把工程师的能力从底到顶排列，大致可以分成五层：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt">1
</span><span class="lnt">2
</span><span class="lnt">3
</span><span class="lnt">4
</span><span class="lnt">5
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">问题与产品判断       最稀缺
</span></span><span class="line"><span class="cl">系统设计与工程取舍
</span></span><span class="line"><span class="cl">领域知识与工程经验
</span></span><span class="line"><span class="cl">验证、测试与可观测性
</span></span><span class="line"><span class="cl">编码与工具使用       逐渐普及</span></span></code></pre></td></tr></table>
</div>
</div>
<p>这不是说 Coding 不再重要，而是 Coding 的角色变了：它正在从主要产出，变成理解系统、约束 AI 和处理疑难问题的基础能力。</p>
<h3 id="1-定义问题而不是急着写代码">1. 定义问题，而不是急着写代码</h3>
<p>假设需求只有一句话：“做一个 AI 实时字幕功能。”</p>
<p>接到需求就开始选 Whisper、接音频、写界面，当然可以很快看到 Demo。但真正决定这个功能能不能落地的，是更前面的那些问题：</p>
<ul>
<li>音频来自麦克风、系统播放，还是直播链路？</li>
<li>可接受延迟是 200 毫秒、1 秒还是 3 秒？</li>
<li>音频是否允许上传云端？断网时怎么处理？</li>
<li>支持哪些语言，翻译按流式输出还是按句提交？</li>
<li>字幕“稳定”的定义是什么，已经展示的文字是否允许回改？</li>
<li>目标设备、功耗和内存上限是多少？</li>
<li>系统 API 是否真的允许采集目标音频？</li>
</ul>
<p>这些问题没有答案，再强的模型也只会更快地做出错误的东西。</p>
<p>所以未来第一项核心能力不是 Prompt 技巧，而是 <strong>Problem Framing</strong>：识别真实目标，发现约束，把模糊需求拆成可以验证的问题。AI 擅长在边界内求解，人必须先画出正确的边界。</p>
<h3 id="2-设计系统而不只是拼接模块">2. 设计系统，而不只是拼接模块</h3>
<p>AI 很擅长生成函数、类、接口和局部测试，却不天然擅长为一个长期演进的系统负责。一个真实系统仍然需要工程师决定：</p>
<ul>
<li>数据从哪里来，由谁拥有；</li>
<li>状态放在哪里，生命周期如何结束；</li>
<li>哪些步骤同步，哪些步骤异步；</li>
<li>线程如何协作，错误如何传播；</li>
<li>性能瓶颈可能出现在哪里；</li>
<li>如何升级、降级、回滚和观测。</li>
</ul>
<p>还是以实时字幕为例，链路可以画成：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt">1
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Audio Capture → PCM → VAD → ASR → 稳定化 → 翻译 → 字幕展示</span></span></code></pre></td></tr></table>
</div>
</div>
<p>AI 可以分别实现每个模块，但“为什么这样拆”仍是人的工作。哪里需要 streaming，谁管理 buffer 的 ownership，ASR 的中间结果何时 commit，翻译失败是否阻塞原文字幕——这些选择共同决定了系统是否可用。</p>
<h3 id="3-保留真正的领域深度">3. 保留真正的领域深度</h3>
<p>当通用代码越来越容易生成，领域知识反而会更有价值。</p>
<p>“会写 Python”很容易被模型复制；但理解 AEC、NS、AGC、VAD、重采样、SIMD、缓存、实时线程、延迟和功耗之间的关系，就不是生成一段代码那么简单。这里面包含长期积累的边界条件、失败经验和取舍能力。</p>
<p>这也是我不打算丢掉音视频和 C/C++，完全转成“Agent 开发者”的原因。更合理的组合是：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt">1
</span><span class="lnt">2
</span><span class="lnt">3
</span><span class="lnt">4
</span><span class="lnt">5
</span><span class="lnt">6
</span><span class="lnt">7
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">音视频 / DSP 领域能力
</span></span><span class="line"><span class="cl">        +
</span></span><span class="line"><span class="cl">C/C++ 与移动端工程能力
</span></span><span class="line"><span class="cl">        +
</span></span><span class="line"><span class="cl">AI Coding / Agent 杠杆
</span></span><span class="line"><span class="cl">        =
</span></span><span class="line"><span class="cl">更高产出的系统工程师</span></span></code></pre></td></tr></table>
</div>
</div>
<p>AI 应该放大已有的专业能力，而不是把它替换成一套很快就会普及的工具操作。</p>
<h3 id="4-建立验证-ai-的能力">4. 建立验证 AI 的能力</h3>
<p>AI 生成的代码量越大，工程师越不能只靠“看起来没问题”来验收。未来很常见的工作流会是：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt">1
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Human → Spec → Agent → 大量代码 → 自动验证 → Human Review</span></span></code></pre></td></tr></table>
</div>
</div>
<p>真正困难的问题是：<strong>怎么证明 Agent 写对了？</strong></p>
<p>因此下面这些传统工程能力不但不会过时，反而会成为 AI Coding 的基础设施：</p>
<ul>
<li>单元测试、集成测试、端到端测试和回归测试；</li>
<li>延迟、吞吐、CPU、内存、功耗和准确率 Benchmark；</li>
<li>日志、指标、Trace、Profiling 和 Crash 分析；</li>
<li>静态分析、Sanitizer、Fuzzing、断言和类型系统。</li>
</ul>
<p>我最近研究的 gtest、ASAN、UBSAN、TSAN 和 simpleperf，看起来都不是最热门的“AI 技术”，却恰好是在给 AI 产出建立护栏。代码可以由 Agent 写，验收标准不能临时猜。</p>
<h3 id="5-从使用-agent-到指挥-agent">5. 从使用 Agent 到指挥 Agent</h3>
<p>AI Coding 不应该停留在“问 ChatGPT 一个问题，再复制一段代码”。更成熟的方式是把工作拆给不同角色：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt"> 1
</span><span class="lnt"> 2
</span><span class="lnt"> 3
</span><span class="lnt"> 4
</span><span class="lnt"> 5
</span><span class="lnt"> 6
</span><span class="lnt"> 7
</span><span class="lnt"> 8
</span><span class="lnt"> 9
</span><span class="lnt">10
</span><span class="lnt">11
</span><span class="lnt">12
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">                  Human
</span></span><span class="line"><span class="cl">                    │
</span></span><span class="line"><span class="cl">              Specification
</span></span><span class="line"><span class="cl">                    │
</span></span><span class="line"><span class="cl">       ┌────────────┼────────────┐
</span></span><span class="line"><span class="cl">       ↓            ↓            ↓
</span></span><span class="line"><span class="cl">  Explore Agent  Coding Agent  Test Agent
</span></span><span class="line"><span class="cl">       └────────────┼────────────┘
</span></span><span class="line"><span class="cl">                    ↓
</span></span><span class="line"><span class="cl">             Review / Benchmark
</span></span><span class="line"><span class="cl">                    ↓
</span></span><span class="line"><span class="cl">              Human Approval</span></span></code></pre></td></tr></table>
</div>
</div>
<p>人的工作会越来越接近 Architect、Reviewer 和 Agent Operator 的组合：给出上下文和约束，拆分任务，选择工具，处理冲突，并对最终结果负责。</p>
<p>但这不意味着可以放弃 Coding。不会 C++ 的人，很难发现一个看似普通的 <code>std::vector&lt;float&gt;</code> 背后是否存在多余分配、拷贝、生命周期、对齐或缓存问题；不了解并发的人，也很难识别 AI 写出的偶发竞态。<strong>不一定要亲手写完每一行，但必须有能力判断这些代码是否可信。</strong></p>
<h2 id="三哪些岗位会减少哪些工程师会更值钱">三、哪些岗位会减少，哪些工程师会更值钱</h2>
<p>软件工程岗位总量是否一定减少，很难准确预测；但岗位结构发生变化几乎是确定的。</p>
<p>简单 CRUD、普通页面、常规 API、一次性脚本和数据转换，这些边界清楚、容易验证的工作会最先被压缩。不是它们完全不再需要人，而是完成同样工作需要的人会更少。</p>
<p>操作系统、编译器、数据库、音视频、网络、安全、机器人、嵌入式、高性能计算和大型分布式系统，则不会因为代码生成变快就突然变简单。它们面对的是现实世界的复杂约束，需要长期的工程取舍、跨模块理解和故障处理。</p>
<p>未来的软件工程师可能形成三种分化：</p>
<table>
	<thead>
			<tr>
					<th>类型</th>
					<th>能力结构</th>
					<th>处境</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>纯代码生产者</td>
					<td>按明确需求实现功能</td>
					<td>工作最容易被压缩</td>
			</tr>
			<tr>
					<td>AI 增强型开发者</td>
					<td>Coding + AI 工具</td>
					<td>产出明显提高</td>
			</tr>
			<tr>
					<td>AI 增强型领域工程师</td>
					<td>领域知识 + 系统设计 + Coding + Agent + 验证</td>
					<td>能解决复杂问题，杠杆最高</td>
			</tr>
	</tbody>
</table>
<p>我想走的是第三条路。目标不是和 AI 比谁敲代码快，而是把自己的领域经验、工程判断和 AI 的执行能力组合起来，完成过去需要更多人协作才能完成的系统。</p>
<p>这个结论也延续了我之前对 AI Coding 的看法。我曾在<a href="/posts/202601/2026-02-01-%E5%85%B3%E4%BA%8Eaicoding%E7%9A%84%E4%B8%80%E4%BA%9B%E6%84%9F%E6%83%B3%E5%92%8C%E5%90%8E%E7%BB%AD%E7%9A%84%E8%A7%84%E5%88%92/">《关于 AI Coding 的一些感想和后续规划》</a>里写过，AI 的能力边界很大程度受使用者影响，生产代码的责任仍在人身上。现在再往前一步看，真正的变化不只是“用 AI 写得更快”，而是要围绕 AI 重新设计整套软件工程流程。</p>
<h2 id="四我的进阶路线从-ai-coding-到-ai-native-engineering">四、我的进阶路线：从 AI Coding 到 AI-Native Engineering</h2>
<p>结合我目前的基础，更合适的路线不是从零转行做大模型，也不是追逐所有 Agent 框架，而是：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt"> 1
</span><span class="lnt"> 2
</span><span class="lnt"> 3
</span><span class="lnt"> 4
</span><span class="lnt"> 5
</span><span class="lnt"> 6
</span><span class="lnt"> 7
</span><span class="lnt"> 8
</span><span class="lnt"> 9
</span><span class="lnt">10
</span><span class="lnt">11
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">传统工程能力补强
</span></span><span class="line"><span class="cl">        ↓
</span></span><span class="line"><span class="cl">AI Coding 工作流
</span></span><span class="line"><span class="cl">        ↓
</span></span><span class="line"><span class="cl">Specification / SDD
</span></span><span class="line"><span class="cl">        ↓
</span></span><span class="line"><span class="cl">Agent 原理与实现
</span></span><span class="line"><span class="cl">        ↓
</span></span><span class="line"><span class="cl">MCP / Tool / Agent Runtime
</span></span><span class="line"><span class="cl">        ↓
</span></span><span class="line"><span class="cl">AI-Native Software Engineering</span></span></code></pre></td></tr></table>
</div>
</div>
<p>这条路线可以用 6～9 个月建立基本体系，但各阶段不需要等前一阶段“学完”才开始。更有效的节奏始终是：学一点，马上放进真实项目；遇到问题，再回来补知识。</p>
<h3 id="stage-0补强软件工程闭环">Stage 0：补强软件工程闭环</h3>
<p>时间：2～4 周。</p>
<p>这一阶段不是重新学习语法，而是把注意力从 Coding 拉回完整交付：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt">1
</span><span class="lnt">2
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Requirement → Spec → Architecture → Implementation
</span></span><span class="line"><span class="cl">            → Test → Benchmark → Release → Observability</span></span></code></pre></td></tr></table>
</div>
</div>
<p>重点补三块：</p>
<ul>
<li><strong>Architecture</strong>：模块、接口、依赖、ownership、生命周期、状态、并发和错误处理；</li>
<li><strong>Testing</strong>：单测、集成测试、回归、Benchmark、Fuzzing 和静态分析；</li>
<li><strong>Profiling</strong>：CPU、内存、I/O、Cache、SIMD、功耗、延迟和吞吐。</li>
</ul>
<p>核心不是背设计模式，而是能解释为什么系统应该这样拆、为什么这个实现会慢、为什么这个结果值得信任。</p>
<h3 id="stage-1形成稳定的-ai-coding-工作流">Stage 1：形成稳定的 AI Coding 工作流</h3>
<p>时间：3～6 周。</p>
<p>先不急着开发 Agent Framework，而是把 Codex、Claude Code 或 Cursor 用到工程级。对中等以上的任务，固定练习五个步骤：</p>
<ol>
<li><strong>Explore</strong>：只读工程，定位相关代码、调用链和风险；</li>
<li><strong>Plan</strong>：输出修改方案、影响范围、验证方式，先不动代码；</li>
<li><strong>Implement</strong>：按照确认后的计划分步实现；</li>
<li><strong>Verify</strong>：编译、测试、检查 Diff，并补充必要的性能验证；</li>
<li><strong>Review</strong>：换一个上下文或 Agent，从正确性、并发、性能、兼容性和回归风险重新审查。</li>
</ol>
<p>这五步的价值不在于流程看起来完整，而在于把“写代码”放回一个可控制、可复核的闭环里。</p>
<h3 id="stage-2学习-specification-与-sdd">Stage 2：学习 Specification 与 SDD</h3>
<p>时间：3～6 周。</p>
<p>AI 很会执行，但人必须先说清楚执行什么。这个阶段要能区分并使用：</p>
<ul>
<li>Requirement；</li>
<li>Specification；</li>
<li>Design；</li>
<li>Task；</li>
<li>Acceptance Criteria；</li>
<li>Test Case；</li>
<li>Architecture Decision。</li>
</ul>
<p>OpenSpec 一类工具值得学习，但重点不是记命令，而是理解从 Explore、Propose、Review、Apply 到 Archive 的变更过程：设计错了如何修订，什么时候应该更新 Spec，什么时候需要重新 Proposal。</p>
<p>可以把 Specification 看成 AI Coding 的“上游源代码”。它未必像代码一样可以直接执行，却决定了 Agent 最终生成什么，以及人用什么标准验收。</p>
<h3 id="stage-3亲手实现一个-mini-agent">Stage 3：亲手实现一个 Mini Agent</h3>
<p>时间：1～2 个月。</p>
<p>这一阶段才正式学习 Agent、LLM、Tool Calling、Context、Planning、Memory、Reflection 和 Sub-agent。最好的入口不是先读几十个框架，而是用 TypeScript 写一个最小 Agent：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt">1
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">User → LLM → Tool Call → Tool Result → LLM → Answer</span></span></code></pre></td></tr></table>
</div>
</div>
<p>第一版只需要 filesystem、calculator、shell 三个 Tool；第二版加入多轮上下文和循环执行：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt"> 1
</span><span class="lnt"> 2
</span><span class="lnt"> 3
</span><span class="lnt"> 4
</span><span class="lnt"> 5
</span><span class="lnt"> 6
</span><span class="lnt"> 7
</span><span class="lnt"> 8
</span><span class="lnt"> 9
</span><span class="lnt">10
</span><span class="lnt">11
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-ts" data-lang="ts"><span class="line"><span class="cl"><span class="k">while</span> <span class="p">(</span><span class="o">!</span><span class="nx">done</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="kr">const</span> <span class="nx">response</span> <span class="o">=</span> <span class="k">await</span> <span class="nx">llm</span><span class="p">(</span><span class="nx">messages</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  <span class="k">if</span> <span class="p">(</span><span class="nx">response</span><span class="p">.</span><span class="nx">toolCall</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kr">const</span> <span class="nx">result</span> <span class="o">=</span> <span class="k">await</span> <span class="nx">execute</span><span class="p">(</span><span class="nx">response</span><span class="p">.</span><span class="nx">toolCall</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="nx">messages</span><span class="p">.</span><span class="nx">push</span><span class="p">(</span><span class="nx">result</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="k">continue</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="nx">response</span><span class="p">.</span><span class="nx">answer</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span></span></span></code></pre></td></tr></table>
</div>
</div>
<p>真正理解这个循环后，再读各种 Agent Framework，就能看见包装之下共同的骨架。</p>
<p>TypeScript 不需要从头学遍，只要先掌握 <code>type</code>、<code>interface</code>、泛型、联合类型、<code>Promise</code>、<code>async/await</code>、模块和 npm，够用就往项目里走。</p>
<h3 id="stage-4理解-mcp工具与安全边界">Stage 4：理解 MCP、工具与安全边界</h3>
<p>时间：约 1 个月。</p>
<p>Agent Loop 本身并不神秘，工程复杂度主要来自 Agent 与真实世界的连接：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt">1
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Agent + Tools + Context + State + Permissions + Reliability + Security</span></span></code></pre></td></tr></table>
</div>
</div>
<p>这个阶段要理解 Tool、Resource、Prompt 和 MCP Client 如何连接文件系统、GitHub、数据库和其他服务。除了“能调用”，还要继续追问：</p>
<ul>
<li>工具权限如何限制；</li>
<li>高风险操作何时需要人工批准；</li>
<li>第三方返回内容是否可信；</li>
<li>执行失败如何重试或回滚；</li>
<li>日志里如何避免泄露敏感信息。</li>
</ul>
<p>Agent 能操作的东西越多，安全边界就越重要。</p>
<h3 id="stage-5阅读真实的-agent-runtime">Stage 5：阅读真实的 Agent Runtime</h3>
<p>时间：1～2 个月。</p>
<p>有了 Mini Agent 和 MCP 的基础，再研究 Codex、OpenClaw、Pi 或 Agent SDK 这类真实系统。不要从源码第一行顺序读，而是沿着运行链路追踪：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt">1
</span><span class="lnt">2
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">CLI → Runtime → Session → Agent Loop → LLM
</span></span><span class="line"><span class="cl">    → Tool → Context → Memory → Sub-agent</span></span></code></pre></td></tr></table>
</div>
</div>
<p>面对任何 Agent Runtime，都可以用八个问题拆解：</p>
<ol>
<li>Agent Loop 在哪里？</li>
<li>Context 在什么时候组装、裁剪和压缩？</li>
<li>Tool 如何注册、选择和执行？</li>
<li>Session、状态和 Checkpoint 如何保存？</li>
<li>长上下文怎样摘要，信息丢失如何处理？</li>
<li>执行中断后怎样恢复？</li>
<li>Sub-agent 如何隔离上下文、并行工作和汇总结果？</li>
<li>权限、审批和审计边界在哪里？</li>
</ol>
<p>我之前整理过<a href="/posts/202604/2026-04-02-claude-code%E6%98%AF%E5%A6%82%E4%BD%95%E5%B7%A5%E4%BD%9C%E7%9A%84/">《从 Claude Code 学习 Agent 开发》</a>，当时得到的结论是“一个循环加工具就是 Agent”。这句话适合解释原理；真正到了工程里，难点则是如何让这个循环在长期运行、上下文变化和工具失败时仍然可靠。</p>
<h3 id="stage-6建立-ai-native-开发方式">Stage 6：建立 AI-Native 开发方式</h3>
<p>这是持续演进的阶段。最终目标不是“会用 Copilot”，而是让整个开发过程围绕人和 Agent 的分工重新组织：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt">1
</span><span class="lnt">2
</span><span class="lnt">3
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Idea → Explore → Specification → Architecture
</span></span><span class="line"><span class="cl">     → Implementation Agent → Test Agent → Review Agent
</span></span><span class="line"><span class="cl">     → Benchmark → Human Approval → Release</span></span></code></pre></td></tr></table>
</div>
</div>
<p>人在关键决策点介入，Agent 承担可拆分、可验证的执行工作。任何一步都不能只因为“模型说完成了”就算完成，最终仍要回到构建结果、测试、指标和验收标准。</p>
<h2 id="五用三个项目把路线串起来">五、用三个项目把路线串起来</h2>
<p>学习 Agent 最容易掉进的坑，是看了很多框架，收藏了很多名词，却没有一条真实链路把它们连起来。与其做几十个 Demo，不如做三个逐步升级的项目。</p>
<h3 id="project-1mini-agent">Project 1：Mini Agent</h3>
<p>用 TypeScript 实现 LLM、Tool Calling 和 Agent Loop，控制在 1～2 周。目标不是做一个能用的产品，而是把 Agent 的最小原理亲手跑通。</p>
<h3 id="project-2audio-coding-agent">Project 2：Audio Coding Agent</h3>
<p>让 Agent 分析一个真实的 C++ Audio Pipeline，寻找 CPU Hotspot、内存拷贝、重采样开销、线程问题和潜在竞态。给它配置 filesystem、代码搜索、Git、编译、gtest 和 simpleperf 等工具，形成：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt">1
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Analyze → Plan → Modify → Build → Test → Benchmark → Report</span></span></code></pre></td></tr></table>
</div>
</div>
<p>这个项目能把我已有的 C++、音频、性能优化经验和 Agent Engineering 串在一起。与通用 Coding Agent 相比，领域知识会真正参与结果判断。</p>
<h3 id="project-3ai-native-实时字幕应用">Project 3：AI-Native 实时字幕应用</h3>
<p>最后选择一个完整项目，例如 iOS 双语实时字幕，从想法开始严格走一遍 Spec、架构、任务拆分、实现、测试、Benchmark 和发布流程。可以让不同 Agent 分别承担探索、编码、测试、性能和 Review，但每一步都必须有明确输入、输出和验收标准。</p>
<p>这个项目不是为了证明“一人公司”或“无人开发”已经实现，而是建立一套自己真正用得起来的个人 AI 软件工程体系。</p>
<h2 id="六时间如何分配">六、时间如何分配</h2>
<p>如果每周可以投入 8～10 小时，我准备按下面的比例推进：</p>
<table>
	<thead>
			<tr>
					<th>阶段</th>
					<th style="text-align: right">参考时间</th>
					<th>主要产出</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>工程闭环补强</td>
					<td style="text-align: right">2～4 周</td>
					<td>测试、性能与架构检查清单</td>
			</tr>
			<tr>
					<td>AI Coding 工作流</td>
					<td style="text-align: right">3～6 周</td>
					<td>Explore 到 Review 的稳定流程</td>
			</tr>
			<tr>
					<td>Specification / SDD</td>
					<td style="text-align: right">3～6 周</td>
					<td>可执行、可验收的项目 Spec</td>
			</tr>
			<tr>
					<td>Agent 原理</td>
					<td style="text-align: right">4～6 周</td>
					<td>Mini Agent</td>
			</tr>
			<tr>
					<td>MCP / Tool</td>
					<td style="text-align: right">3～4 周</td>
					<td>带权限边界的工具集成</td>
			</tr>
			<tr>
					<td>Runtime 研究</td>
					<td style="text-align: right">4～8 周</td>
					<td>对一个真实 Agent 的源码分析</td>
			</tr>
			<tr>
					<td>AI-Native Engineering</td>
					<td style="text-align: right">持续</td>
					<td>完整项目与复盘</td>
			</tr>
	</tbody>
</table>
<p>时间不是硬指标。判断一个阶段是否完成的标准，不是“资料看完了”，而是能否拿出可以运行、可以验证、可以复盘的产物。</p>
<h2 id="七参考资料">七、参考资料</h2>
<p>资料不需要多，先沿着主线读官方文档：</p>
<ul>
<li><a href="https://openai.com/business/guides-and-resources/how-openai-uses-codex/">How OpenAI uses Codex</a>：观察 AI Coding 如何进入真实工程流程；</li>
<li><a href="https://openai.com/index/running-codex-safely/">Running Codex safely</a>：理解权限、环境和人工审批；</li>
<li><a href="https://openai.com/business/guides-and-resources/a-practical-guide-to-building-ai-agents/">A practical guide to building agents</a>：建立 Agent 的整体模型；</li>
<li><a href="https://www.typescriptlang.org/docs/handbook/">TypeScript Handbook</a> 与 <a href="https://www.typescriptlang.org/docs/handbook/2/modules.html">Modules</a>：补齐实现 Agent 所需的 TypeScript 子集；</li>
<li><a href="https://openspec.dev/docs/quickstart">OpenSpec Quickstart</a>：把 Spec 驱动流程放进真实项目。</li>
</ul>
<p>读资料时不追求“系统学完”。每看懂一个概念，就在项目中找到它的位置；没有项目对应的知识，过一段时间大概率还会忘掉。</p>
<h2 id="八最后不要成为工具收藏家">八、最后：不要成为工具收藏家</h2>
<p>这次讨论最终给我的提醒，不是赶紧转行，也不是赶紧再学一个热门框架，而是重新确认自己的能力组合：</p>
<blockquote>
<p>未来优秀的软件工程师，应该能定义问题、设计系统、驾驭 Agent、验证结果，并对最终交付负责。</p>
</blockquote>
<p>因此，不应该按照“先学 TypeScript，再学 Agent，再学 MCP，再学某个框架”的课程目录前进。更有效的方式，是始终围绕一个真实项目：项目需要什么，就补什么；做出结果，再复盘哪些判断可以沉淀成 Spec、测试、工具或工作流。</p>
<p>代码正在变便宜，但正确的软件并没有因此自动出现。会写代码仍然重要，只是它不再是终点。接下来真正值得投入的，是把领域经验、系统工程和 AI 组织成一套能持续交付的能力。</p>
]]></content:encoded>
    </item>
    <item>
      <title>矩阵乘法优化：从三层循环到 Apple Silicon</title>
      <link>https://lyapple2008.github.io/posts/202609/2026-09-06-%E7%9F%A9%E9%98%B5%E4%B9%98%E6%B3%95%E4%BC%98%E5%8C%96/</link>
      <pubDate>Sun, 06 Sep 2026 21:30:00 +0800</pubDate>
      <guid>https://lyapple2008.github.io/posts/202609/2026-09-06-%E7%9F%A9%E9%98%B5%E4%B9%98%E6%B3%95%E4%BC%98%E5%8C%96/</guid>
      <description>在 Mac mini M2 Pro 上把朴素 GEMM 从 2.5 GFLOPS 推到 Accelerate 的 2.7 TFLOPS。每一步先看数据怎么走，再改代码，最后对照这颗芯片的存储层次和 AMX。</description>
      <content:encoded><![CDATA[<p>深度学习里最贵的那几下，多半是矩阵乘法。注意力的 $QK^{\top}$ 和 $PV$、全连接、卷积展开之后，都是</p>
<p>$$C = AB,\qquad C_{ij}=\sum_k A_{ik},B_{kj}$$</p>
<p>算力是 $O(n^3)$，访存是 $O(n^2)$。算术强度大约是 $n/6$（三个矩阵各扫一遍、FP32）。$n$ 小的时候吃带宽，$n$ 大的时候吃算力。优化不是把循环写得更花，而是让每个被请上芯片的数，多干几次活。</p>
<p>这篇文章按「图示原理 → 硬件瓶颈 → 最短代码 → 本机数字」往下走。平台是眼前这台 <strong>Mac mini M2 Pro</strong>（6 个性能核 + 4 个能效核，16GB 统一内存）。编译器 Apple clang 21，<code>-O3 -ffast-math</code>，方阵 FP32，暖机后取中位数。iOS 和 macOS 共用同一套 Accelerate，后面会单独讲两堵不同的墙。</p>
<p><img alt="一行乘一列，得到 C 的一个数" loading="lazy" src="/images/2026-09/gemm-overview.svg"></p>
<h2 id="先看这颗芯片">先看这颗芯片</h2>
<p>后面每一步都回扣这里。M2 Pro 上其实有两张地图：数据住在哪一层，以及谁来算。</p>
<p><img alt="M2 Pro 存储层次与计算单元" loading="lazy" src="/images/2026-09/gemm-m2pro-hierarchy.svg"></p>
<p>几个后面会反复用到的数：</p>
<ul>
<li>cache line <strong>128B</strong>，一行刚好 32 个 FP32</li>
<li>P 核 L1D 大约 <strong>128KB</strong>，E 核大约 <strong>64KB</strong></li>
<li>性能簇 L2 大约 <strong>16MB</strong>，能效簇大约 <strong>4MB</strong>，SLC 大约 <strong>16MB</strong></li>
<li>统一内存带宽大约 <strong>200 GB/s</strong></li>
<li>计算从下到上：标量 → NEON 128-bit → <strong>AMX</strong> → GPU / ANE</li>
</ul>
<p>macOS 和 iOS 的指令集是同源的。差的不是「会不会写 kernel」，是频率墙、热和 QoS。</p>
<p>用 Roofline 把终点立住：naive 贴在带宽墙上，Accelerate 已经顶到 AMX 的算力墙。中间那些优化，就是把点往右上挪。</p>
<p><img alt="本机 Roofline：naive 贴带宽墙，Accelerate 顶 AMX" loading="lazy" src="/images/2026-09/gemm-roofline.svg"></p>
<p>阶梯是这样的：</p>

<div class="mermaid">flowchart LR
    naive[naive ijk] --&gt; ikj[循环交换 ikj]
    ikj --&gt; tile[Cache 分块]
    tile --&gt; pack[Packing]
    pack --&gt; reg[寄存器分块]
    reg --&gt; neon[NEON 微核]
    neon --&gt; gcd[GCD 多线程]
    gcd --&gt; amx[Accelerate / AMX]</div>
<p>不是每一步都会更快。有的步是在给下一步铺路，单独拿出来测会变慢。这本身就是软硬件合在一起时该有的诚实。</p>
<h2 id="1-naive-ijk按教科书写按列去跳">1. Naive ijk：按教科书写，按列去跳</h2>
<p>图先看。内层循环沿 B 的列往下走：</p>
<p><img alt="naive ijk 的访问轨迹：B 跨行走" loading="lazy" src="/images/2026-09/gemm-naive-ijk.svg"></p>
<p>行主序里，<code>B[k, j]</code> 的下一拍是 <code>B[k+1, j]</code>，中间隔了整行。cache line 请来 32 个数，用完 1 个就丢掉。L1 帮不上忙，预取器也跟不住这种步长。</p>
<p>卡在哪：不是乘法慢，是 <strong>B 的跨步访问把带宽浪费了</strong>。</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt">1
</span><span class="lnt">2
</span><span class="lnt">3
</span><span class="lnt">4
</span><span class="lnt">5
</span><span class="lnt">6
</span><span class="lnt">7
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="n">n</span><span class="p">;</span> <span class="n">i</span><span class="o">++</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">j</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">j</span> <span class="o">&lt;</span> <span class="n">n</span><span class="p">;</span> <span class="n">j</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kt">float</span> <span class="n">s</span> <span class="o">=</span> <span class="mf">0.f</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">k</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">k</span> <span class="o">&lt;</span> <span class="n">n</span><span class="p">;</span> <span class="n">k</span><span class="o">++</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">            <span class="n">s</span> <span class="o">+=</span> <span class="n">A</span><span class="p">[</span><span class="n">i</span> <span class="o">*</span> <span class="n">n</span> <span class="o">+</span> <span class="n">k</span><span class="p">]</span> <span class="o">*</span> <span class="n">B</span><span class="p">[</span><span class="n">k</span> <span class="o">*</span> <span class="n">n</span> <span class="o">+</span> <span class="n">j</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">        <span class="n">C</span><span class="p">[</span><span class="n">i</span> <span class="o">*</span> <span class="n">n</span> <span class="o">+</span> <span class="n">j</span><span class="p">]</span> <span class="o">=</span> <span class="n">s</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span></span></span></code></pre></td></tr></table>
</div>
</div>
<p>本机数字：</p>
<table>
	<thead>
			<tr>
					<th style="text-align: right">N</th>
					<th style="text-align: right">耗时</th>
					<th style="text-align: right">GFLOPS</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td style="text-align: right">64</td>
					<td style="text-align: right">0.072 ms</td>
					<td style="text-align: right">7.28</td>
			</tr>
			<tr>
					<td style="text-align: right">256</td>
					<td style="text-align: right">12.7 ms</td>
					<td style="text-align: right">2.65</td>
			</tr>
			<tr>
					<td style="text-align: right">512</td>
					<td style="text-align: right">82.5 ms</td>
					<td style="text-align: right">3.25</td>
			</tr>
			<tr>
					<td style="text-align: right">1024</td>
					<td style="text-align: right">850 ms</td>
					<td style="text-align: right"><strong>2.53</strong></td>
			</tr>
	</tbody>
</table>
<p>$N$ 一大，立刻掉到 2～3 GFLOPS。这就是后面所有加速比的分母。</p>
<h2 id="2-循环交换-ikj同一套乘法换一条路">2. 循环交换 ikj：同一套乘法，换一条路</h2>
<p>把 $j$ 收到最里面。固定一个 $A_{ik}$，沿 B 的第 $k$ 行走过去，C 的第 $i$ 行就地累加。</p>
<p><img alt="ikj：B 和 C 都变成顺序扫" loading="lazy" src="/images/2026-09/gemm-order-ikj.svg"></p>
<p>对照更清楚。上面跨行跳，下面顺序扫，算的是同一件事：</p>
<p><img alt="ijk 与 ikj 访问轨迹对照" loading="lazy" src="/images/2026-09/gemm-order-compare.svg"></p>
<p>卡在哪：还是标量乘法，但 <strong>空间局部性回来了</strong>。128B 的 cache line 里 32 个 FP32 终于被用上。</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt">1
</span><span class="lnt">2
</span><span class="lnt">3
</span><span class="lnt">4
</span><span class="lnt">5
</span><span class="lnt">6
</span><span class="lnt">7
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="nf">memset</span><span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="n">n</span> <span class="o">*</span> <span class="n">n</span> <span class="o">*</span> <span class="k">sizeof</span><span class="p">(</span><span class="kt">float</span><span class="p">));</span>
</span></span><span class="line"><span class="cl"><span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="n">n</span><span class="p">;</span> <span class="n">i</span><span class="o">++</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">k</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">k</span> <span class="o">&lt;</span> <span class="n">n</span><span class="p">;</span> <span class="n">k</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kt">float</span> <span class="n">a</span> <span class="o">=</span> <span class="n">A</span><span class="p">[</span><span class="n">i</span> <span class="o">*</span> <span class="n">n</span> <span class="o">+</span> <span class="n">k</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">        <span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">j</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">j</span> <span class="o">&lt;</span> <span class="n">n</span><span class="p">;</span> <span class="n">j</span><span class="o">++</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">            <span class="n">C</span><span class="p">[</span><span class="n">i</span> <span class="o">*</span> <span class="n">n</span> <span class="o">+</span> <span class="n">j</span><span class="p">]</span> <span class="o">+=</span> <span class="n">a</span> <span class="o">*</span> <span class="n">B</span><span class="p">[</span><span class="n">k</span> <span class="o">*</span> <span class="n">n</span> <span class="o">+</span> <span class="n">j</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span></span></span></code></pre></td></tr></table>
</div>
</div>
<p>本机数字（相对 naive）：</p>
<table>
	<thead>
			<tr>
					<th style="text-align: right">N</th>
					<th style="text-align: right">ikj GFLOPS</th>
					<th style="text-align: right">加速比</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td style="text-align: right">64</td>
					<td style="text-align: right">23.8</td>
					<td style="text-align: right">3.3×</td>
			</tr>
			<tr>
					<td style="text-align: right">256</td>
					<td style="text-align: right">26.8</td>
					<td style="text-align: right">10.1×</td>
			</tr>
			<tr>
					<td style="text-align: right">512</td>
					<td style="text-align: right">28.3</td>
					<td style="text-align: right">8.7×</td>
			</tr>
			<tr>
					<td style="text-align: right">1024</td>
					<td style="text-align: right"><strong>28.9</strong></td>
					<td style="text-align: right"><strong>11.4×</strong></td>
			</tr>
			<tr>
					<td style="text-align: right">2048</td>
					<td style="text-align: right">24.9</td>
					<td style="text-align: right">—</td>
			</tr>
	</tbody>
</table>
<p>只换循环顺序，大矩阵直接快一个数量级。这是整篇文章里，<strong>代码改动最小、收益最稳</strong> 的一步。后面所有花活，都建立在「先别跟 cache line 作对」之上。</p>
<h2 id="3-cache-分块一次只请得起三块">3. Cache 分块：一次只请得起三块</h2>
<p>$N=1024$ 时，三个矩阵各 4MB，已经超出单核 L1，也挤得 L2 很满。ikj 靠预取还能维持 29 GFLOPS，但微核如果想把一块 A 反复乘很多块 B，这三块必须先住进缓存。</p>
<p><img alt="一次只装进能住进 L1/L2 的 A、B、C 三块" loading="lazy" src="/images/2026-09/gemm-tiling.svg"></p>
<p>块大小怎么反推：P 核 L1D 大约 128KB。一块 $128\times 256$ 的 FP32 panel 刚好 128KB，可以钉在 L1；对应的 B panel 放到 L2。A 留下，扫完所有 N 方向的块，再换下一段 K。这就是 Goto / BLIS 那套「外层大块 + 内层微核」的骨架。</p>
<p>卡在哪：工作集超过缓存时，<strong>复用半径必须由块大小显式管住</strong>。预取器救得了顺序流，救不了「同时想记住三块还在长的矩阵」。</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt">1
</span><span class="lnt">2
</span><span class="lnt">3
</span><span class="lnt">4
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">i0</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">i0</span> <span class="o">&lt;</span> <span class="n">n</span><span class="p">;</span> <span class="n">i0</span> <span class="o">+=</span> <span class="n">MC</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">k0</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">k0</span> <span class="o">&lt;</span> <span class="n">n</span><span class="p">;</span> <span class="n">k0</span> <span class="o">+=</span> <span class="n">KC</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">j0</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">j0</span> <span class="o">&lt;</span> <span class="n">n</span><span class="p">;</span> <span class="n">j0</span> <span class="o">+=</span> <span class="n">NC</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">            <span class="cm">/* 对 A[i0:i0+MC, k0:k0+KC] · B[k0:k0+KC, j0:j0+NC] 做 ikj */</span></span></span></code></pre></td></tr></table>
</div>
</div>
<p>本机上，单独给 ikj 套一层 64×64 分块，并没有更快：</p>
<table>
	<thead>
			<tr>
					<th style="text-align: right">N</th>
					<th style="text-align: right">tiled</th>
					<th style="text-align: right">ikj</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td style="text-align: right">256</td>
					<td style="text-align: right">24.2</td>
					<td style="text-align: right">26.8</td>
			</tr>
			<tr>
					<td style="text-align: right">512</td>
					<td style="text-align: right">22.4</td>
					<td style="text-align: right">28.3</td>
			</tr>
			<tr>
					<td style="text-align: right">1024</td>
					<td style="text-align: right">20.2</td>
					<td style="text-align: right">28.9</td>
			</tr>
			<tr>
					<td style="text-align: right">2048</td>
					<td style="text-align: right">16.2</td>
					<td style="text-align: right">24.9</td>
			</tr>
	</tbody>
</table>
<p>这不是分块错了。是 <strong>ikj 已经被预取器喂饱，多出来的三重分块循环在收税</strong>。分块的价值要等微核出现：只有当你真的会把同一块 A 连乘很多块 B，把它钉在 L1 才划算。下面两步会把这件事做实。</p>
<h2 id="4-packing给微核铺一条直道">4. Packing：给微核铺一条直道</h2>
<p>微核希望每次 load 都是连续的、宽度刚好是 NR。原矩阵里，一个 $K_c\times N_r$ 的 panel 每行只要 8 个数，行与行之间却隔着整行步长。</p>
<p><img alt="panel 从原矩阵散落位置，打成连续条带" loading="lazy" src="/images/2026-09/gemm-packing.svg"></p>
<p>卡在哪：即便块已经在缓存里，<strong>跨步 load 仍会打断微核的流水线，TLB 也更容易 miss</strong>。</p>
<p>打包本身是一次 gather。只打包、微核仍是标量，拷贝成本会把收益吃光——本机 packed 标量核只有 <strong>7.5 GFLOPS</strong>，比 ikj 慢三倍。Packing 不是优化，是 <strong>给下一步快微核付的入场费</strong>。</p>
<h2 id="5-寄存器分块c-的一小窗不要来回写">5. 寄存器分块：C 的一小窗不要来回写</h2>
<p>微核窗口盖在 C 上。4×8 一共 32 个累加器，K 维走完再写回内存。</p>
<p><img alt="4×8 微核窗口和寄存器累加器" loading="lazy" src="/images/2026-09/gemm-regblock.svg"></p>
<p>卡在哪：没有这一层，每次 <code>c[j] += a * b[j]</code> 都要读 C、写 C。C 的流量从 $O(n^2)$ 变成跟着 $K$ 放大。寄存器分块把 C 的写回从「每个 k 一次」收成「每个微核一次」。</p>
<p>本机 4×4 标量寄存器分块：</p>
<table>
	<thead>
			<tr>
					<th style="text-align: right">N</th>
					<th style="text-align: right">GFLOPS</th>
					<th style="text-align: right">相对 naive</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td style="text-align: right">64</td>
					<td style="text-align: right">47.7</td>
					<td style="text-align: right">6.6×</td>
			</tr>
			<tr>
					<td style="text-align: right">256</td>
					<td style="text-align: right">31.3</td>
					<td style="text-align: right">11.8×</td>
			</tr>
			<tr>
					<td style="text-align: right">1024</td>
					<td style="text-align: right">29.9</td>
					<td style="text-align: right">11.8×</td>
			</tr>
			<tr>
					<td style="text-align: right">2048</td>
					<td style="text-align: right">10.7</td>
					<td style="text-align: right">—</td>
			</tr>
	</tbody>
</table>
<p>小矩阵整表住在缓存里，寄存器分块几乎白捡一倍。$N=2048$ 时没有外层 cache 分块护着，窗口外的 A、B 重新开始流，数字掉下去。再一次：微核和分块是一对，拆开都不完整。</p>
<h2 id="6-neon一次-fma-吃-4-个-fp32">6. NEON：一次 FMA 吃 4 个 FP32</h2>
<p>Apple Silicon 的 P 核每个周期能发多条 128-bit FMA。标量循环喂不饱它们。一条 NEON 寄存器装 4 个 FP32，<code>vfmaq_f32</code> 做的是「广播一个 $A_{ik}$，乘 B 的一行向量，累加进 C」。</p>
<p><img alt="128-bit 车道：广播 A × 向量 B → 累加 C" loading="lazy" src="/images/2026-09/gemm-neon.svg"></p>
<p>卡在哪：算力墙从「标量 ALU」换成了 <strong>向量流水线</strong>。要喂饱它，pack 好的 A、B 和寄存器里的 C 必须同时在岗。</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt">1
</span><span class="lnt">2
</span><span class="lnt">3
</span><span class="lnt">4
</span><span class="lnt">5
</span><span class="lnt">6
</span><span class="lnt">7
</span><span class="lnt">8
</span><span class="lnt">9
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="kt">float32x4_t</span> <span class="n">c0</span> <span class="o">=</span> <span class="nf">vdupq_n_f32</span><span class="p">(</span><span class="mi">0</span><span class="p">),</span> <span class="n">c1</span> <span class="o">=</span> <span class="nf">vdupq_n_f32</span><span class="p">(</span><span class="mi">0</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">k</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">k</span> <span class="o">&lt;</span> <span class="n">kc</span><span class="p">;</span> <span class="n">k</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kt">float32x4_t</span> <span class="n">a</span> <span class="o">=</span> <span class="nf">vld1q_f32</span><span class="p">(</span><span class="n">Ap</span> <span class="o">+</span> <span class="n">k</span> <span class="o">*</span> <span class="mi">4</span><span class="p">);</span>     <span class="cm">/* 4 行 A */</span>
</span></span><span class="line"><span class="cl">    <span class="kt">float32x4_t</span> <span class="n">b0</span> <span class="o">=</span> <span class="nf">vld1q_f32</span><span class="p">(</span><span class="n">Bp</span> <span class="o">+</span> <span class="n">k</span> <span class="o">*</span> <span class="mi">8</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="kt">float32x4_t</span> <span class="n">b1</span> <span class="o">=</span> <span class="nf">vld1q_f32</span><span class="p">(</span><span class="n">Bp</span> <span class="o">+</span> <span class="n">k</span> <span class="o">*</span> <span class="mi">8</span> <span class="o">+</span> <span class="mi">4</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="n">c0</span> <span class="o">=</span> <span class="nf">vfmaq_laneq_f32</span><span class="p">(</span><span class="n">c0</span><span class="p">,</span> <span class="n">b0</span><span class="p">,</span> <span class="n">a</span><span class="p">,</span> <span class="mi">0</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="n">c1</span> <span class="o">=</span> <span class="nf">vfmaq_laneq_f32</span><span class="p">(</span><span class="n">c1</span><span class="p">,</span> <span class="n">b1</span><span class="p">,</span> <span class="n">a</span><span class="p">,</span> <span class="mi">0</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="cm">/* 其余 3 行同理 */</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span></span></span></code></pre></td></tr></table>
</div>
</div>
<p>加上前面的分块和 packing，单线程微核在本机非常稳：</p>
<table>
	<thead>
			<tr>
					<th style="text-align: right">N</th>
					<th style="text-align: right">NEON GFLOPS</th>
					<th style="text-align: right">相对 ikj</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td style="text-align: right">64</td>
					<td style="text-align: right">43.7</td>
					<td style="text-align: right">1.8×</td>
			</tr>
			<tr>
					<td style="text-align: right">256</td>
					<td style="text-align: right">50.2</td>
					<td style="text-align: right">1.9×</td>
			</tr>
			<tr>
					<td style="text-align: right">512</td>
					<td style="text-align: right">51.2</td>
					<td style="text-align: right">1.8×</td>
			</tr>
			<tr>
					<td style="text-align: right">1024</td>
					<td style="text-align: right"><strong>51.1</strong></td>
					<td style="text-align: right">1.8×</td>
			</tr>
			<tr>
					<td style="text-align: right">2048</td>
					<td style="text-align: right">49.6</td>
					<td style="text-align: right">2.0×</td>
			</tr>
			<tr>
					<td style="text-align: right">4096</td>
					<td style="text-align: right">45.6</td>
					<td style="text-align: right">—</td>
			</tr>
	</tbody>
</table>
<p>大约 50 GFLOPS，几乎不随 $N$ 抖。说明微核已经把单核 NEON 的数据通路走顺了。6 个 P 核的 NEON 理论峰值大约在 600+ GFLOPS 这个量级，单核 50 离「喂饱一条核」还有距离，但已经不是访存在主导。</p>
<h2 id="7-多线程先喂-p-核并看-qos">7. 多线程：先喂 P 核，并看 QoS</h2>
<p>C 按行块切开，每块独立写自己的行，GCD concurrent 往外派。M2 Pro 是 6 个 P 核 + 4 个 E 核。默认队列不一定把活都堆在 P 核上；<code>QOS_CLASS_USER_INTERACTIVE</code> 会明确告诉调度器：这是前台要的算力。</p>
<p><img alt="按行块切开，6 条 P 核 + 4 条 E 核" loading="lazy" src="/images/2026-09/gemm-threads.svg"></p>
<p>卡在哪：单核 NEON 已经不算访存了，但 <strong>6 个 P 核还在闲着</strong>。另一侧，线程太细或矩阵太小，派发成本会高过计算。</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt">1
</span><span class="lnt">2
</span><span class="lnt">3
</span><span class="lnt">4
</span><span class="lnt">5
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="kt">dispatch_queue_attr_t</span> <span class="n">attr</span> <span class="o">=</span> <span class="nf">dispatch_queue_attr_make_with_qos_class</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="n">DISPATCH_QUEUE_CONCURRENT</span><span class="p">,</span> <span class="n">QOS_CLASS_USER_INTERACTIVE</span><span class="p">,</span> <span class="mi">0</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="nf">dispatch_apply</span><span class="p">((</span><span class="n">n</span> <span class="o">+</span> <span class="n">MC</span> <span class="o">-</span> <span class="mi">1</span><span class="p">)</span> <span class="o">/</span> <span class="n">MC</span><span class="p">,</span> <span class="nf">dispatch_queue_create</span><span class="p">(</span><span class="s">&#34;gemm&#34;</span><span class="p">,</span> <span class="n">attr</span><span class="p">),</span> <span class="o">^</span><span class="p">(</span><span class="kt">size_t</span> <span class="n">bi</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="cm">/* 对第 bi 个 MC 行块跑 NEON 微核 */</span>
</span></span><span class="line"><span class="cl"><span class="p">});</span></span></span></code></pre></td></tr></table>
</div>
</div>
<p>本机：</p>
<table>
	<thead>
			<tr>
					<th style="text-align: right">N</th>
					<th style="text-align: right">单线程 NEON</th>
					<th style="text-align: right">GCD 默认</th>
					<th style="text-align: right">GCD UI</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td style="text-align: right">64</td>
					<td style="text-align: right"><strong>43.7</strong></td>
					<td style="text-align: right">27.6</td>
					<td style="text-align: right">29.1</td>
			</tr>
			<tr>
					<td style="text-align: right">256</td>
					<td style="text-align: right">50.2</td>
					<td style="text-align: right">91.9</td>
					<td style="text-align: right">90.9</td>
			</tr>
			<tr>
					<td style="text-align: right">512</td>
					<td style="text-align: right">51.2</td>
					<td style="text-align: right">189</td>
					<td style="text-align: right">190</td>
			</tr>
			<tr>
					<td style="text-align: right">1024</td>
					<td style="text-align: right">51.1</td>
					<td style="text-align: right">276</td>
					<td style="text-align: right"><strong>280</strong></td>
			</tr>
			<tr>
					<td style="text-align: right">2048</td>
					<td style="text-align: right">49.6</td>
					<td style="text-align: right">329</td>
					<td style="text-align: right"><strong>330</strong></td>
			</tr>
			<tr>
					<td style="text-align: right">4096</td>
					<td style="text-align: right">45.6</td>
					<td style="text-align: right">278</td>
					<td style="text-align: right"><strong>323</strong></td>
			</tr>
	</tbody>
</table>
<p>三件事：</p>
<ol>
<li>$N=64$ 时多线程是负优化，派发比计算还贵。</li>
<li>大矩阵大约 5～6×，和 6 个 P 核对得上，E 核没帮上太多忙。</li>
<li>桌面 Mac 上两种 QoS 几乎一样；$N=4096$ 才拉开一点。<strong>iOS 后台被降到 E 核时，这条缝会变成一道沟。</strong></li>
</ol>
<h2 id="8-accelerate手写到这里系统库还要快-50-倍">8. Accelerate：手写到这里，系统库还要快 50 倍</h2>
<p>$N=1024$，手写多线程 NEON 是 280 GFLOPS。同一份数据交给 <code>cblas_sgemm</code>：</p>
<p><strong>2708 GFLOPS，相对 naive 是 1072 倍。</strong></p>
<p>差从哪来？Apple 在性能核旁边放了矩阵协处理器 AMX。它做的不是「一次 4 个数」，而是一列 × 一行，outer product 一次更新整块 C。</p>
<p><img alt="AMX：outer product 一次写满一块 C" loading="lazy" src="/images/2026-09/gemm-amx-tile.svg"></p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre tabindex="0" class="chroma"><code><span class="lnt">1
</span><span class="lnt">2
</span></code></pre></td>
<td class="lntd">
<pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="nf">cblas_sgemm</span><span class="p">(</span><span class="n">CblasRowMajor</span><span class="p">,</span> <span class="n">CblasNoTrans</span><span class="p">,</span> <span class="n">CblasNoTrans</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="n">n</span><span class="p">,</span> <span class="n">n</span><span class="p">,</span> <span class="n">n</span><span class="p">,</span> <span class="mf">1.0f</span><span class="p">,</span> <span class="n">A</span><span class="p">,</span> <span class="n">n</span><span class="p">,</span> <span class="n">B</span><span class="p">,</span> <span class="n">n</span><span class="p">,</span> <span class="mf">0.0f</span><span class="p">,</span> <span class="n">C</span><span class="p">,</span> <span class="n">n</span><span class="p">);</span></span></span></code></pre></td></tr></table>
</div>
</div>
<p>本机 Accelerate：</p>
<table>
	<thead>
			<tr>
					<th style="text-align: right">N</th>
					<th style="text-align: right">耗时</th>
					<th style="text-align: right">GFLOPS</th>
					<th style="text-align: right">相对 naive</th>
					<th style="text-align: right">相对单核 NEON</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td style="text-align: right">64</td>
					<td style="text-align: right">0.001 ms</td>
					<td style="text-align: right">524</td>
					<td style="text-align: right">72×</td>
					<td style="text-align: right">12×</td>
			</tr>
			<tr>
					<td style="text-align: right">256</td>
					<td style="text-align: right">0.033 ms</td>
					<td style="text-align: right">1017</td>
					<td style="text-align: right">383×</td>
					<td style="text-align: right">20×</td>
			</tr>
			<tr>
					<td style="text-align: right">512</td>
					<td style="text-align: right">0.121 ms</td>
					<td style="text-align: right">2218</td>
					<td style="text-align: right">682×</td>
					<td style="text-align: right">43×</td>
			</tr>
			<tr>
					<td style="text-align: right">1024</td>
					<td style="text-align: right">0.793 ms</td>
					<td style="text-align: right"><strong>2708</strong></td>
					<td style="text-align: right"><strong>1072×</strong></td>
					<td style="text-align: right"><strong>53×</strong></td>
			</tr>
			<tr>
					<td style="text-align: right">2048</td>
					<td style="text-align: right">7.94 ms</td>
					<td style="text-align: right">2163</td>
					<td style="text-align: right">—</td>
					<td style="text-align: right">44×</td>
			</tr>
			<tr>
					<td style="text-align: right">4096</td>
					<td style="text-align: right">69.7 ms</td>
					<td style="text-align: right">1972</td>
					<td style="text-align: right">—</td>
					<td style="text-align: right">43×</td>
			</tr>
	</tbody>
</table>
<p>AMX 没有公开指令文档，Accelerate 在矩阵够大时会走它。$N=64$ 就已经 524 GFLOPS，说明阈值很低。$N$ 再大，数字从 2.7 TFLOPS 回到 2 TFLOPS 附近，开始碰到带宽、缓存归属和功耗墙。</p>
<p>手写 NEON 很难追上，不是微核不够认真，是 <strong>单元就不一样</strong>。产品代码到这一步，默认答案就是调用系统库。</p>
<h2 id="apple-silicon-上怎么选">Apple Silicon 上怎么选</h2>
<p>通用 GEMM、网络里的一层、要不要上 GPU，不是同一条路。</p>
<p><img alt="Mac / iOS 选型" loading="lazy" src="/images/2026-09/gemm-dispatch.svg"></p>
<h3 id="统一内存不是免费午餐">统一内存不是免费午餐</h3>
<p>独立显卡机器上，小 GEMM 先被 PCIe 拷贝淹死。Apple Silicon 省掉了这次拷贝，CPU、GPU、ANE 看见的是同一块统一内存。省的是搬，不是缓存颠簸。Metal 的 <code>MPSMatrixMultiplication</code> 有启动开销，小矩阵往往不如 Accelerate；大矩阵、批量、已经在 GPU 上的图，再值得过去。</p>
<p><img alt="统一内存：没有 PCIe 拷贝，但仍有归属" loading="lazy" src="/images/2026-09/gemm-unified-memory.svg"></p>
<h3 id="ane-不是通用-gemm">ANE 不是通用 GEMM</h3>
<p>BNNS 吃 CPU 上的卷积和固定形状的网络层。Core ML 能把部分图卸到 ANE。ANE 喜欢静态形状、量化好的推理，不喜欢你随时改 $M,N,K$ 的通用乘法。动态 GEMM 留在 Accelerate 或 GPU。</p>
<h3 id="sme-是公开的下一站">SME 是公开的下一站</h3>
<p>M4 / A18 上 ARM 的 SME / SME2 把矩阵 tile（ZA）做成了公开指令。思路和 AMX 类似：向量外积填一块累加器。以后手写矩阵核有望不再依赖未文档化的协处理器，但今天这台 M2 Pro 上，公开可用、又真正快的，仍然是 Accelerate。</p>
<h3 id="ios-和-mac-是同一套-api两堵不同的墙">iOS 和 Mac 是同一套 API，两堵不同的墙</h3>
<p><img alt="桌面峰值 vs 手机墙" loading="lazy" src="/images/2026-09/gemm-ios-wall.svg"></p>
<p>A14 起的 A 系同样有 AMX，调用方式也是 <code>cblas_sgemm</code> / BNNS。不要把桌面 2.7 TFLOPS 写进手机 SLA：几秒热节流、进后台被降 QoS、App 被挂起，都会让数字塌掉。前台、用户正在等的计算，显式用 <code>QOS_CLASS_USER_INTERACTIVE</code>；能接受慢的，别去抢 P 核。</p>
<h2 id="本机总表">本机总表</h2>
<p>平台：Mac mini M2 Pro，FP32，$C=AB$，行主序。单位 GFLOPS。空格是这一档太慢、没跑。</p>
<table>
	<thead>
			<tr>
					<th style="text-align: left">kernel</th>
					<th style="text-align: right">64</th>
					<th style="text-align: right">256</th>
					<th style="text-align: right">512</th>
					<th style="text-align: right">1024</th>
					<th style="text-align: right">2048</th>
					<th style="text-align: right">4096</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td style="text-align: left">naive ijk</td>
					<td style="text-align: right">7.3</td>
					<td style="text-align: right">2.7</td>
					<td style="text-align: right">3.3</td>
					<td style="text-align: right">2.5</td>
					<td style="text-align: right"></td>
					<td style="text-align: right"></td>
			</tr>
			<tr>
					<td style="text-align: left">ikj</td>
					<td style="text-align: right">23.8</td>
					<td style="text-align: right">26.8</td>
					<td style="text-align: right">28.3</td>
					<td style="text-align: right">28.9</td>
					<td style="text-align: right">24.9</td>
					<td style="text-align: right"></td>
			</tr>
			<tr>
					<td style="text-align: left">tiled（无微核）</td>
					<td style="text-align: right">23.8</td>
					<td style="text-align: right">24.2</td>
					<td style="text-align: right">22.4</td>
					<td style="text-align: right">20.2</td>
					<td style="text-align: right">16.2</td>
					<td style="text-align: right"></td>
			</tr>
			<tr>
					<td style="text-align: left">寄存器分块</td>
					<td style="text-align: right">47.7</td>
					<td style="text-align: right">31.3</td>
					<td style="text-align: right">30.2</td>
					<td style="text-align: right">29.9</td>
					<td style="text-align: right">10.7</td>
					<td style="text-align: right"></td>
			</tr>
			<tr>
					<td style="text-align: left">packed 标量</td>
					<td style="text-align: right">6.7</td>
					<td style="text-align: right">7.6</td>
					<td style="text-align: right">7.5</td>
					<td style="text-align: right">7.5</td>
					<td style="text-align: right">7.5</td>
					<td style="text-align: right"></td>
			</tr>
			<tr>
					<td style="text-align: left">NEON 微核</td>
					<td style="text-align: right">43.7</td>
					<td style="text-align: right">50.2</td>
					<td style="text-align: right">51.2</td>
					<td style="text-align: right">51.1</td>
					<td style="text-align: right">49.6</td>
					<td style="text-align: right">45.6</td>
			</tr>
			<tr>
					<td style="text-align: left">GCD + NEON</td>
					<td style="text-align: right">29.1</td>
					<td style="text-align: right">90.9</td>
					<td style="text-align: right">190</td>
					<td style="text-align: right">280</td>
					<td style="text-align: right">330</td>
					<td style="text-align: right">323</td>
			</tr>
			<tr>
					<td style="text-align: left">Accelerate</td>
					<td style="text-align: right"><strong>524</strong></td>
					<td style="text-align: right"><strong>1017</strong></td>
					<td style="text-align: right"><strong>2218</strong></td>
					<td style="text-align: right"><strong>2708</strong></td>
					<td style="text-align: right"><strong>2163</strong></td>
					<td style="text-align: right"><strong>1972</strong></td>
			</tr>
	</tbody>
</table>
<p>读这张表的方式：</p>
<ul>
<li><strong>ikj</strong> 是软件侧最值的一刀，大矩阵约 10×。</li>
<li><strong>分块 / packing</strong> 单独看会变慢，它们是微核的前置条件，不是独立加速器。</li>
<li><strong>NEON 微核</strong> 把单核钉在约 50 GFLOPS。</li>
<li><strong>GCD</strong> 在矩阵够大时吃满 P 核，约 300 GFLOPS。</li>
<li><strong>Accelerate</strong> 再往上一个数量级。那一跳不是循环技巧，是 AMX。</li>
</ul>
<p>对应回 Roofline：naive 贴着带宽墙；ikj 和 NEON 往右上走；多线程接近 NEON 多核屋顶；Accelerate 换了一块屋顶。</p>
<h2 id="可以带走的几条">可以带走的几条</h2>
<ol>
<li>先画访问轨迹，再写优化。和 cache line 作对的循环，换顺序比换指令集更值钱。</li>
<li>分块、packing、寄存器窗口、SIMD 是一套，不是四道独立菜。拆开测，有的步会倒退。</li>
<li>Apple Silicon 上，教学写到 NEON 微核就够看懂；产品上的通用 GEMM，默认 <code>cblas_sgemm</code>。</li>
<li>小矩阵别开线程，也别急着上 Metal。调用和同步比乘法贵。</li>
<li>Mac 上量到的峰值，不能当 iOS 的承诺。同一套 ISA，墙不一样。</li>
</ol>
<p>公式只需要三个：$C_{ij}=\sum_k A_{ik}B_{kj}$，算术强度大约 $n/6$，以及 $\mathrm{GFLOPS}=2N^3/t$。其余的，都是让数据停在更靠近计算的那一层。</p>
<h2 id="项目链接">项目链接</h2>
<p>文中各阶梯的 C 实现和 CMake bench 在 <a href="https://github.com/lyapple2008/gmm_opt">gmm_opt</a>。</p>
]]></content:encoded>
    </item>
    <item>
      <title>读《富爸爸穷爸爸》：房子是资产吗，写代码是事业吗</title>
      <link>https://lyapple2008.github.io/posts/202609/2026-09-03-%E5%AF%8C%E7%88%B8%E7%88%B8%E7%A9%B7%E7%88%B8%E7%88%B8%E8%AF%BB%E5%90%8E%E6%84%9F/</link>
      <pubDate>Thu, 03 Sep 2026 22:30:00 +0800</pubDate>
      <guid>https://lyapple2008.github.io/posts/202609/2026-09-03-%E5%AF%8C%E7%88%B8%E7%88%B8%E7%A9%B7%E7%88%B8%E7%88%B8%E8%AF%BB%E5%90%8E%E6%84%9F/</guid>
      <description>硬上车的房子，现在开始按月供过日子；「会写代码」也正在被 AI 变便宜。富人买资产、穷人买负债——这句话常被读歪。真正好用的不是口号，是先把账记对。</description>
      <content:encoded><![CDATA[<p>前阵子写<a href="/posts/202608/2026-08-30-40%E5%B9%B4%E6%88%BF%E8%B4%B7/">40 年房贷</a>的时候，已经把《富爸爸穷爸爸》里最刺耳的那句拿出来用过一次：很多人把负债当成了资产。书看完之后，觉得那句话只是入口。清崎翻来覆去讲的，其实就两对很容易混的概念——<strong>资产与负债</strong>，<strong>职业与事业</strong>。</p>
<p>这两对概念都不新，新的是对照物变了。一套近几年硬上车、现在开始按月供过日子的房子，一份正在被 AI 改写的程序员工作，比书里那些美国出租屋和快餐店例子更近。下面就用这两件事把书读一遍。</p>
<h2 id="一先把作者的尺子拿出来">一、先把作者的尺子拿出来</h2>
<p>穷爸爸受过良好教育，稳定上班，讲究稳妥，觉得房子是最大的资产，债务是危险的。富爸爸学历一般，却反复强调一件事：先看钱往哪边流。</p>
<p>他给的定义很短：</p>
<ul>
<li><strong>资产</strong>：把钱放进你口袋的东西。</li>
<li><strong>负债</strong>：把钱从你口袋拿走的东西。</li>
</ul>
<p>职业和事业的区分也一样干脆：</p>
<ul>
<li><strong>职业</strong>：你在为别人的体系工作，收入和你的时间绑在一起。停下来，钱就停。</li>
<li><strong>事业</strong>：你在搭自己的体系。体系一旦转起来，不必每一分钱都靠当天亲自上班换。</li>
</ul>
<p>书里最容易被读歪的，是后面那句口号：「富人买资产，穷人买负债。」它听起来像劝人别买房、别上班、赶紧去投资。我并不这么读。更有用的读法是：先把账记对，再决定自己愿意为哪一类东西付钱。记错账，后面所有努力都是在给一张错误的资产负债表添砖加瓦。</p>
<h2 id="二资产与负债硬上车的房子和知道自己在做什么的房子">二、资产与负债：硬上车的房子，和知道自己在做什么的房子</h2>
<h3 id="自住房首先是消费品">自住房首先是消费品</h3>
<p>中产阶级最容易犯的错，是把自住房直接写进资产栏。房子在那里，房产证也在手里，市价曾经涨过，朋友同事都说「好歹有套房子」。可每个月的月供、物业、维修、税、保险，都在把现金抽走。在清崎的现金流游戏里，自住房写在负债栏，不是抬杠，是记账方法：先看钱往哪边流，再听升值故事。</p>
<p>这几年国内的情况，把这个记账方法照得很清楚。</p>
<p>2015 到 2021 年附近，买房有过很长一段「先上车，涨幅会覆盖一切」的窗口。后来窗口关了，逻辑却还在流传：不买就来不及、租房是给房东打工、有房才算在这个城市站稳。于是一批人不是因为马上要住，而是因为怕错过，在高位、高杠杆、甚至超出舒适现金流的前提下「硬上车」。首付掏空家庭储备，月供顶着收入上限，房子买在自己并不打算长住、也不打算经营的城市或地段。</p>
<p>现在这些人面对的，往往不是「我拥有了一项资产」，而是：</p>
<ul>
<li>房价横盘或下跌，账面净资产起不来，有的还倒挂；</li>
<li>月供、物业、空置、交易费用继续往外抽现金；</li>
<li>工作、城市、家庭结构一变，这套房就从「安全感」变成「搬不走的锚」。</li>
</ul>
<p>房子还是那套房子。变的是：它不再自动把钱送进口袋。按清崎的尺子，它本来就不是资产；前些年它看起来像资产，只是因为上涨暂时盖住了现金流。</p>
<h3 id="书里靠房地产致富的人并不是在上车">书里靠房地产致富的人，并不是在「上车」</h3>
<p>这里必须把另一面也说清楚。清崎自己最爱举的例子，恰恰就是房地产。他买房、收租、做交换、用杠杆，反复讲「我就是靠这个富起来的」。如果只截前半句「自住房是负债」，后半句「房地产是致富工具」就会变成自相矛盾。</p>
<p>矛盾只存在于没分清账的人身上。</p>
<p>书里那些靠房地产致富的人，做的不是「有一套自己住的房子」。他们做的是一笔生意：</p>
<ul>
<li>买入之前就算清楚租金、空置、维修、税费、贷款利息，确认每月现金是正的；</li>
<li>杠杆用在能生出现金的资产上，而不是用在「我得有套房」这个身份焦虑上；</li>
<li>涨了是锦上添花，跌了也不至于靠卖房才能活下去，因为活下去靠的是现金流，不是价差。</li>
</ul>
<p>一句话：他们知道自己在买什么。买的是一台会吐现金的机器，不是一张证明自己已经成人、已经安家、已经没有被时代甩掉的证书。</p>
<p>同样叫「买房」，一种是消费和身份，一种是经营。前者在供着的时候，你为房子工作；后者算得过来的时候，房子为你工作。近几年硬上车、不为居住、只为「别踏空」的人，大多走的是第一条路。现在开始背负房贷过日子，并不是市场突然跟他们作对，而是账从一开始就记在负债栏，只是上涨行情让人假装没看见。</p>
<h3 id="愿意为负债付钱和把负债当成资产不是一回事">愿意为负债付钱，和把负债当成资产，不是一回事</h3>
<p>我并不认为懂财务的人就不该买自住房。对很多中国家庭，房子同时承担居住、婚姻、子女教育和安全感，完全按美国那套「先买出租物业」来生活，既不现实，也不必要。</p>
<p>更要紧的是承认：</p>
<blockquote>
<p>自住房是你愿意为之付钱的消费品。它可能在很多年以后变成净资产，但它在供着的时候，并不是资产。</p>
</blockquote>
<p>愿意付，是因为你要住，而且现金流睡得着。不愿意，也可以继续租，把住房成本显式化。真正麻烦的，是第三种：不为住，只为上车，然后把月供解释成「我在投资」。那不是投资，是用未来几十年的工资，给过去某一年的恐惧买单。</p>
<p>如果已经买了，也不必道德化成「当初真蠢」。更实际的是把账重新记一遍：这套房每个月拿走多少钱、自己还能剩多少、剩下的钱有没有在买真正的资产。认清它是负债，比继续讲「反正房子还在」更有用。</p>
<h2 id="三职业与事业ai-正在改写程序员这份职业">三、职业与事业：AI 正在改写程序员这份职业</h2>
<h3 id="程序员这份职业卖的是时间">程序员这份职业，卖的是时间</h3>
<p>清崎说穷人和中产为工作赚钱，富人让钱为自己工作。落到程序员身上，职业路径很熟悉：学一门技术，进一家公司，靠职级和年限把时薪抬上去。代码写得越好，越容易被委以更重的模块；模块越重，越离不开你。看起来是成长，底层仍是同一件事——<strong>收入和你的在岗时间绑在一起</strong>。</p>
<p>这没有原罪。职业是体面的，也是绝大多数人安身的方式。书里真正提醒的是：不要把职业误认成事业。职业给你发工资，事业给你一台可以离开你还能转一会儿的机器。很多程序员把「技术越来越精」当成事业，其实只是把职业做得更专业。专业很值钱，但它仍然是在为别人的体系工作。</p>
<h3 id="ai-压缩的首先是职业本身">AI 压缩的，首先是职业本身</h3>
<p>2023 年以来，这件事从抽象讨论变成了日常体验。AI Coding 已经能写模块、改测试、查日志、补文档；一个熟练的人带着它，产出可以是从前的数倍。我自己也写过<a href="/posts/202601/2026-02-01-%E5%85%B3%E4%BA%8Eaicoding%E7%9A%84%E4%B8%80%E4%BA%9B%E6%84%9F%E6%83%B3%E5%92%8C%E5%90%8E%E7%BB%AD%E7%9A%84%E8%A7%84%E5%88%92/">使用上的感受</a>：从「完了，失业要提前了」，到「稳了，还能苟几年」。苟得住的前提，其实已经变了——不是代码还只能人手写，而是使用者还要为质量兜底，还要会拆任务、会判断、会把系统拼起来。</p>
<p>对职业的冲击是不均匀的。</p>
<ul>
<li><strong>被压得最明显的</strong>，是把「会写代码」本身当成稀缺能力的岗位。CRUD、模板页面、标准接入、重复劳动，正在迅速便宜。公司会发现：同样的功能，更少的人加上更好的工具就能交出来。</li>
<li><strong>暂时还在的</strong>，是能定义问题、设计系统、对结果负责的人。AI 仍然像 L2 辅助驾驶，出了事故还是使用者负责。会用工具的人，把职业的单位时间产出抬高了；不会用的人，单位时间的市场定价在下降。</li>
<li><strong>真正被改写的</strong>，是职业的 durabilty。以前一套技术可以吃十年，现在模型和工具半年一变。职业还在，但「靠同一份手艺吃到退休」这条路，比五年前窄了很多。</li>
</ul>
<p>所以 AI 不是简单消灭程序员，它是在拆掉程序员职业里最像「手艺」的那一层。手艺越标准，越容易被工具吃掉。留下的是判断、责任、对用户和业务的理解，以及把工具编进一套能持续产出的流程里。</p>
<h3 id="事业不是辞职创业是让能力脱离工时">事业不是辞职创业，是让能力脱离工时</h3>
<p>书里的事业，常被理解成开公司、当老板。程序员读到这里，很容易要么焦虑到去硬创业，要么直接把书关掉。我更愿意把事业理解得小一点、也更可执行一点：</p>
<p><strong>事业是一套不完全依赖你当天坐在工位上的价值产出方式。</strong></p>
<p>对程序员来说，它可以是：</p>
<ul>
<li>一个真实可用的产品，哪怕很小，但解决的是别人愿意反复使用的问题；</li>
<li>一套自己能讲清楚、能复用、能交付的方法论或工具链；</li>
<li>把 AI 当成杠杆之后，仍然属于你的判断力、审美、领域理解和客户关系；</li>
<li>在职业内部，有意识地从「我是写这段代码的人」走到「我是对这个结果负责的人」。</li>
</ul>
<p>去年规划里写过，希望后面少做单点知识分享，多从打造一个真实可用的产品角度去写过程。现在回头看，那不只是内容策略，也是职业和事业的分界：分享知识点，是在展示职业能力；把一个能跑的东西做出来，是在搭一块可能离开工时还能存在的资产。</p>
<p>Peter Steinberger 那种「一直在做各种小工具，某一天其中一件爆了」的路径，比「先辞职，再找一个事业」更接近程序员能走的路。事业往往不是某一天换身份换来的，是职业还在运转的时候，把多出来的判断力和工具杠杆，一点点砌进自己的体系。</p>
<p>AI 在这里是双刃的。它让职业更难守——同样会写代码的人变多了，代码本身也便宜了。它也让事业更容易起步——一个人加一套 Agent，已经能做出从前需要一个小组才做得动的东西。差别仍然回到那把尺子：你是用 AI 把这份职业多撑几年，还是用 AI 给自己搭一台不完全靠上班钟点计费的机器。</p>
<p>两种都合理。只靠职业活着的人，需要更诚实地看到：这份职业的安全垫，比我们入行时想象的更薄。想做事业的人，也不必把书读成「上班就是穷爸爸」。上班可以是现金流，事业可以是晚上和周末那点属于自己的体系。先有正的现金，再谈让钱为自己工作，这才是书里比较经得起现实磨损的部分。</p>
<h2 id="四两对概念其实是同一件事">四、两对概念其实是同一件事</h2>
<p>资产与负债看的是<strong>钱往哪边流</strong>。职业与事业看的是<strong>价值是否还绑在你的时间上</strong>。</p>
<p>硬上车的房子，是把未来的工资预支成一项看起来像资产的负债。只守着「我会写代码」的职业，是把当下的时间卖给一项正在贬值的技能。两者的共同结构是：把安全感建立在一个名字好听、账却记反了的东西上。</p>
<p>反过来也成立。一套算得清租金、自己知道在经营的房子，可以是资产。一份仍然在上班、但已经开始用 AI 做出产品、做出流程、做出可复用能力的程序员生涯，也可以慢慢长出事业的轮廓。名字不重要，流向才重要。</p>
<p>书本身有很多经不起推敲的地方：案例太美国、叙事太鸡汤、对风险和运气的讨论不够。这些都不妨碍那两把尺子好用。读完之后我留给自己的，不是「以后只买资产、只做事业」这种大话，而是三个更小的问题：</p>
<ol>
<li>我现在以为的资产，每个月到底是给我钱，还是在拿我的钱？</li>
<li>我现在以为的事业，离开我这个人加班，还能转多久？</li>
<li>AI 和房贷这类新变量出现时，我是在加固原来的错账，还是借机把账改对？</li>
</ol>
<p>房子可以是家，代码可以是手艺。在把它们写进资产栏、写进事业栏之前，先看清楚钱和时间到底在为谁工作。</p>
]]></content:encoded>
    </item>
  </channel>
</rss>
