koishi-plugin-kkk 1.0.0

package/src/karin/module/utils/ImageSlice.ts

@@ -0,0 +1,383 @@
+/**
+ * 超长图片的「切片 + markdown 拼接」发送。
+ *
+ * 背景：评论区卡片会把「主评论 + 楼中楼」全部渲染进一张图，实测能长到 **2880×40000**
+ * （1.15 亿像素、7MB）—— QQ 直接拒收（报 `[40093011] 上传文件大小超过限制`），
+ * 表现就是「评论卡发不出来」。
+ *
+ * 解法：把长图按固定高度切成若干片，每片单独上传，再用 **一条 markdown 消息** 拼起来：
+ *
+ *   ![#2880px #6000px](url1)
+ *   ![#2880px #6000px](url2)
+ *
+ * QQ 对同一 markdown 里连续的图片是**紧贴渲染**的，所以视觉上仍然是一整张卡片（严丝合缝），
+ * 而每片都在 QQ 的预览尺寸内，不会再被拒。
+ */
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+
+import { logger, segment, type Message } from 'node-karin'
+
+import { commandInvocation, tryGetRuntime } from '../../../compat/runtime'
+import { getImageMetadata } from '@/module/utils/Render'
+
+/**
+ * 每片的**目标**高度。
+ *
+ * 一开始用的 6000：QQ 会把这么高的图整体缩小显示，结果前几片字小到看不清；
+ * 而最后一片因为短，反而被按宽度铺满，看起来比别的「宽」。
+ * 现在改成 2000 —— 每片都在 QQ 的舒适区内，字够大；同时下面的算法保证**每片等长**。
+ */
+const SLICE_HEIGHT = 2000
+
+/** 切片前先把宽度压到这个值（卡片本来 2880 宽，QQ 显示用不到，缩一半解码量降到 1/4） */
+const SLICE_WIDTH = 1440
+
+/** 把 data URI 或本地路径读成 Buffer */
+const readImage = (source: string): Buffer | null => {
+  try {
+    if (source.startsWith('data:')) {
+      const comma = source.indexOf(',')
+      return Buffer.from(source.slice(comma + 1), 'base64')
+    }
+    if (fs.existsSync(source)) return fs.readFileSync(source)
+    return null
+  } catch {
+    return null
+  }
+}
+
+/** 用 ffmpeg 裁一段出来（项目本来就依赖 ffmpeg，不额外引图像库） */
+const cropWithFfmpeg = async (
+  input: string,
+  output: string,
+  width: number,
+  height: number,
+  y: number,
+  /** 自定义 filter（给缩放步骤用）；不传就是按宽度/高度/偏移裁剪 */
+  customFilter?: string
+): Promise<boolean> => {
+  const filter = customFilter ?? ('crop=' + width + ':' + height + ':0:' + y)
+  const runtime: any = tryGetRuntime()
+  const ffmpeg: any = runtime?.ctx?.ffmpeg
+  const args = ['-y', '-i', input, '-vf', filter, '-frames:v', '1', output]
+  /**
+   * **不要用宿主的 ffmpeg 服务** —— 实测 `ffmpeg.builder()...run()` 会**卡住不返回**
+   * （既没有 ffmpeg 进程、也没有 CPU 占用、更没有任何日志，表现就是「怎么没反应了」）。
+   * 命令行方式已经验证可用，直接用它。
+   */
+  try {
+    const { spawn } = await import('node:child_process')
+    const bin = process.env.FFMPEG_PATH || 'ffmpeg'
+    await new Promise<void>((resolve, reject) => {
+      const proc = spawn(bin, args, { stdio: 'ignore' })
+      proc.on('error', reject)
+      proc.on('close', (code) => (code === 0 ? resolve() : reject(new Error('ffmpeg exit ' + code))))
+    })
+    return true
+  } catch (error: any) {
+    logger.warn('[图片切片] ffmpeg 裁剪失败: ' + String(error?.message ?? error))
+    return false
+  }
+}
+
+/** 上传到宿主 assets，拿到 QQ 能访问的 https 地址 */
+const uploadSlice = async (buffer: Buffer, name: string, attempts = 3): Promise<string | null> => {
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    const url = await uploadSliceOnce(buffer, name)
+    if (url) return url
+    if (attempt < attempts) {
+      logger.mark('[图片切片] 上传第 ' + attempt + ' 次失败，' + attempt * 1000 + 'ms 后重试')
+      await new Promise((resolve) => setTimeout(resolve, attempt * 1000))
+    }
+  }
+  return null
+}
+
+/** 单次上传（重试逻辑在外面） */
+const uploadSliceOnce = async (buffer: Buffer, name: string): Promise<string | null> => {
+  try {
+    const assets: any = (tryGetRuntime() as any)?.ctx?.assets
+    if (!assets?.upload) return null
+    const uploaded: any = await assets.upload('data:image/jpeg;base64,' + buffer.toString('base64'), name)
+    const url = typeof uploaded === 'string' ? uploaded : uploaded?.url
+    return url && /^https?:\/\//i.test(String(url)) ? String(url) : null
+  } catch (error: any) {
+    logger.warn('[图片切片] 上传失败: ' + String(error?.message ?? error))
+    return null
+  }
+}
+
+/**
+ * 发送可能超长的图片：短图直接发，长图切片后用一条 markdown 拼接。
+ *
+ * @param e 消息事件
+ * @param source data URI 或本地图片路径
+ * @returns 是否已发送
+ */
+export const sendSlicedImage = async (e: Message, input: any): Promise<boolean> => {
+  /**
+   * 入参形态有三种，全都要认：
+   *   1. data URI / 本地路径（字符串）
+   *   2. segment.image(...) 造出来的元素（src 在 attrs 上）
+   *   3. 上面两种的**数组** —— Render() 对多图模板返回的就是数组。
+   * 之前只处理前两种，数组进来时取不到 src 会静默失败（切片一直没生效就是这个原因）。
+   */
+  const first = Array.isArray(input) ? input[0] : input
+  const source: string = typeof first === 'string'
+    ? first
+    : String(first?.attrs?.src ?? first?.data?.file ?? first?.data?.url ?? '')
+  const buffer = readImage(source)
+  if (!buffer) {
+    logger.warn('[图片切片] 取不到图片内容（入参 ' + (Array.isArray(input) ? 'array' : typeof input) + '），回退原逻辑')
+    return false
+  }
+  /**
+   * **按需切片**（默认开，配置项 sliceImageOnDemand）：
+   *   - 图片 ≤ 20MB 且不超高 → 先按普通图片发一次；
+   *   - 发出去**没有消息 ID**（QQ 拒收时就是这样，不抛异常）或抛异常 → 才切片重发；
+   *   - 图片本身就超过 20MB → 直接切片，不用白试一次。
+   * 关掉开关就一律普通发送（超高的卡会被 QQ 拒收，但这是用户的选择）。
+   */
+  const runtimeConfig: any = (tryGetRuntime()?.config as any) ?? {}
+  /**
+   * **切片只在 QQ 适配器上生效**（用户要求）。
+   *
+   * 切片是为了绕开 QQ 官方 bot 的图片上传限制（单图体积/像素上限），
+   * 其它平台没这个问题，硬切只会增加消息条数、破坏观感。
+   */
+  const platform = String((e as any)?.bot?.bot?.platform ?? (e as any)?.platform ?? (e as any)?.bot?.platform ?? '')
+  if (platform && !/qq/i.test(platform)) {
+    logger.debug('[图片切片] 当前平台 ' + platform + ' 不是 QQ，按普通图片发送')
+    await e.reply(segment.image(source))
+    return true
+  }
+  const onDemand = runtimeConfig.sliceImageOnDemand !== false
+  const sliceHeight = Math.max(300, Number(runtimeConfig.sliceImageHeight) || SLICE_HEIGHT)
+  const IMAGE_SIZE_LIMIT = 20 * 1024 * 1024
+
+  const meta = getImageMetadata(buffer)
+  let width = Number(meta.width) || 0
+  let height = Number(meta.height) || 0
+  // 读不出尺寸时用 ffprobe 兜一次，绝不因为读不到尺寸就放弃切片
+  if (!width || !height) {
+    try {
+      const { spawnSync } = await import('node:child_process')
+      const probe = spawnSync('ffprobe', ['-v', 'error', '-select_streams', 'v:0', '-show_entries', 'stream=width,height', '-of', 'csv=p=0', '-'], { input: buffer })
+      const parts = String(probe.stdout ?? '').trim().split(',')
+      width = Number(parts[0]) || 0
+      height = Number(parts[1]) || 0
+    } catch { /* 兜底失败按 0 处理 */ }
+  }
+  logger.mark('[图片切片] 收到图片 ' + width + 'x' + height + '（' + (buffer.length / 1024).toFixed(0) + ' KB）')
+  /**
+   * 普通发送：**收到消息 ID 才算成功**（QQ 拒收时不抛异常、只返回空）。
+   *
+   * 另外加了超时 —— 超高图片（实测 2880×15520）上传时适配器会**长时间卡住不返回**，
+   * 不加超时整条流程就停在这里，用户看到的就是「没反应」。15 秒没结果就当作失败去切片。
+   */
+  const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))
+
+  const tryNormalSendOnce = async (): Promise<boolean> => {
+    const sendPromise = (async () => {
+      try {
+        const result: any = await e.reply(segment.image(source))
+        /**
+         * 失败有三种表现，缺一不可（用户提醒：**不一定只是拿不到消息 ID**，QQ 会直接返回错误信息）：
+         *   1. 抛异常（网络/TLS 问题最常见，比如证书校验失败）
+         *   2. 拿不到 messageId（适配器静默失败）
+         *   3. **返回体里带错误**（result.error / message 里含 error/失败/超过限制 之类）
+         */
+        const errorText = String(result?.error?.message ?? result?.error ?? result?.message ?? result?.data?.error ?? '')
+        if (errorText && /error|fail|失败|超过|限制|拒绝|invalid|denied/i.test(errorText)) {
+          logger.mark('[图片切片] 普通发送返回错误信息: ' + errorText.slice(0, 120))
+          return false
+        }
+        return Boolean(result?.messageId)
+      } catch (error: any) {
+        logger.mark('[图片切片] 普通发送抛错，改走切片: ' + String(error?.message ?? error).slice(0, 120))
+        return false
+      }
+    })()
+    const timeoutPromise = new Promise<boolean>((resolve) => {
+      const timer = setTimeout(() => resolve(false), 15000)
+      timer.unref?.()
+    })
+    return await Promise.race([sendPromise, timeoutPromise])
+  }
+
+  /**
+   * 带**重试**的普通发送（用户要求）。
+   *
+   * 实测失败大多是**瞬时**的：DNS 抖动、连接被重置、TLS 证书对不上
+   * （你环境里就有把 COS 域名解析到错服务器、返回「只有 IP 的证书」的情况）。
+   * 这种一失败就切片属于过度反应，先退避重试几次，成功就不切。
+   */
+  const tryNormalSend = async (attempts = 3): Promise<boolean> => {
+    for (let attempt = 1; attempt <= attempts; attempt++) {
+      if (await tryNormalSendOnce()) return true
+      if (attempt < attempts) {
+        logger.mark('[图片切片] 普通发送第 ' + attempt + ' 次失败，' + attempt * 800 + 'ms 后重试')
+        await sleep(attempt * 800)
+      }
+    }
+    return false
+  }
+
+  // 开关关闭 → 永远普通发送
+  if (!onDemand) {
+    await e.reply(segment.image(source))
+    return true
+  }
+  /**
+   * 顺序就是用户要的：**先按普通图片发一次**，
+   *   - 拿到消息 ID → 成功，结束（大多数卡片都走这里，不会多此一举切片）
+   *   - 拿不到消息 ID（QQ 拒收就是这样，不抛异常）/ 抛异常 → 再切片重发
+   * 只有图片本身就超过 20MB 才跳过这次尝试，直接切。
+   */
+  const oversized = buffer.length > IMAGE_SIZE_LIMIT
+  if (oversized) {
+    logger.mark('[图片切片] 图片 ' + (buffer.length / 1024 / 1024).toFixed(1) + 'MB 超过 20MB 限制，直接切片')
+  } else if (await tryNormalSend()) {
+    return true
+  } else {
+    logger.mark('[图片切片] 普通发送没有拿到消息 ID（多为 QQ 拒收），改走切片')
+  }
+  if (!width || !height || height <= sliceHeight) {
+    // 尺寸本身就在范围内、只是发不出去：没得切，原样再试一次
+    await e.reply(segment.image(source))
+    return true
+  }
+
+  const runtime: any = tryGetRuntime()
+  const tmpDir = path.join(os.tmpdir(), 'kkk-slice-' + Date.now())
+  try {
+    fs.mkdirSync(tmpDir, { recursive: true })
+    const original = path.join(tmpDir, 'full.jpg')
+    fs.writeFileSync(original, buffer)
+
+    /**
+     * **先整体缩一次再从缩略图切片** —— 这一步是性能关键。
+     *
+     * 卡片实测 2880×40000（1.15 亿像素）：直接在原图上裁 7 刀，每刀都要把整图重新解码一遍，
+     * 实测要跑好几分钟（用户会看到「怎么没反应了」）。缩到一半宽再裁，
+     * 解码量降到 1/4，7 刀总共一两秒，而且 QQ 显示尺寸本来就不需要 2880 宽。
+     */
+    const scaleWidth = Math.min(width, SLICE_WIDTH)
+    const input = path.join(tmpDir, 'small.jpg')
+    const scaled = scaleWidth < width
+      ? await cropWithFfmpeg(original, input, 0, 0, 0, 'scale=' + scaleWidth + ':-1')
+      : true
+    const useInput = scaled && fs.existsSync(input) ? input : original
+    const useHeight = scaled && scaleWidth < width ? Math.round((height * scaleWidth) / width) : height
+    const useWidth = scaled && scaleWidth < width ? scaleWidth : width
+    if (useInput !== original) {
+      logger.mark('[图片切片] 已缩放到 ' + useWidth + 'x' + useHeight + ' 再切片')
+    }
+
+    const parts: string[] = []
+    /**
+     * **每片等长**：先按最大高度算出片数，再把总高平均分配。
+     * 这样最后一片不会因为矮而被 QQ 按宽度铺开（用户说的「最后一张太宽」）。
+     * 除不尽时最后一片会与前一片重叠几个像素，视觉上几乎看不出来，比留白干净。
+     */
+    const total = Math.max(1, Math.ceil(useHeight / sliceHeight))
+    const each = Math.ceil(useHeight / total)
+    for (let index = 0; index < total; index++) {
+      const sliceHeight = each
+      // 最后一片贴底裁，保证高度一致（宁可重叠几像素，也不要短一截）
+      const offset = index === total - 1 ? Math.max(0, useHeight - each) : index * each
+      const output = path.join(tmpDir, 'slice-' + index + '.jpg')
+      const ok = await cropWithFfmpeg(useInput, output, useWidth, sliceHeight, offset)
+      if (!ok || !fs.existsSync(output)) break
+      const url = await uploadSlice(fs.readFileSync(output), 'kkk-slice-' + index + '.jpg')
+      if (!url) break
+      // 尺寸写死成实际像素：QQ 会按这个尺寸渲染，连续图片紧贴 = 视觉上仍是一整张
+      parts.push('![#' + useWidth + 'px #' + sliceHeight + 'px](' + url + ')')
+    }
+
+    if (!parts.length) {
+      // 切片失败就退回原图，至少不是完全没反应
+      await e.reply(segment.image(source))
+      return true
+    }
+    logger.mark('[图片切片] 长图 ' + width + 'x' + height + ' 已切成 ' + parts.length + ' 片，用 markdown 拼接发送')
+    await e.reply(segment.markdown(parts.join(String.fromCharCode(10))))
+    return true
+  } finally {
+    try { fs.rmSync(tmpDir, { recursive: true, force: true }) } catch { /* 清理失败无所谓 */ }
+  }
+}
+
+/**
+ * 只切片、不发送：把可能超长的图片变成**一个 markdown 元素**（调用方自己决定怎么发）。
+ *
+ * 错误卡片就用它 —— 实测错误卡片能到 2880x40000 / 45MB（堆栈越长越夸张），
+ * 直接发必然被 QQ 拒收，等于「报错本身也发不出来」。
+ */
+export const sliceImageToMarkdown = async (input: any): Promise<any | null> => {
+  const first = Array.isArray(input) ? input[0] : input
+  const source: string = typeof first === 'string'
+    ? first
+    : String(first?.attrs?.src ?? first?.data?.file ?? first?.data?.url ?? '')
+  if (!source) return null
+  const runtimeConfig: any = (tryGetRuntime()?.config as any) ?? {}
+  // 合并成一条 markdown 也是 QQ 专属优化（绕过图片上传限制）：其它平台逐张发即可
+  const platform = String((e as any)?.bot?.bot?.platform ?? (e as any)?.platform ?? (e as any)?.bot?.platform ?? '')
+  if (platform && !/qq/i.test(platform)) {
+    for (const one of valid) await e.reply(segment.image(one))
+    return true
+  }
+  const sliceHeight = Math.max(300, Number(runtimeConfig.sliceImageHeight) || SLICE_HEIGHT)
+  const tmpDir = path.join(os.tmpdir(), 'kkk-sliceonly-' + Date.now())
+  try {
+    fs.mkdirSync(tmpDir, { recursive: true })
+    const buffer = readImage(source)
+    if (!buffer) return null
+    const meta = getImageMetadata(buffer)
+    let width = Number(meta.width) || 0
+    let height = Number(meta.height) || 0
+    if (!width || !height) {
+      try {
+        const { spawnSync } = await import('node:child_process')
+        const probe = spawnSync('ffprobe', ['-v', 'error', '-select_streams', 'v:0', '-show_entries', 'stream=width,height', '-of', 'csv=p=0', '-'], { input: buffer })
+        const ps = String(probe.stdout ?? '').trim().split(',')
+        width = Number(ps[0]) || 0
+        height = Number(ps[1]) || 0
+      } catch { /* 忽略 */ }
+    }
+    if (!width || !height) return null
+    // 不高就直接一段
+    if (height <= sliceHeight) {
+      const url = await uploadSlice(buffer, 'kkk-one.jpg')
+      return url ? segment.markdown('![#' + width + 'px #' + height + 'px](' + url + ')') : null
+    }
+    // 超高：先缩放再等分切片
+    const original = path.join(tmpDir, 'full.jpg')
+    fs.writeFileSync(original, buffer)
+    const scaleWidth = Math.min(width, SLICE_WIDTH)
+    const small = path.join(tmpDir, 'small.jpg')
+    const scaled = scaleWidth < width ? await cropWithFfmpeg(original, small, 0, 0, 0, 'scale=' + scaleWidth + ':-1') : false
+    const useInput = scaled && fs.existsSync(small) ? small : original
+    const useWidth = scaled ? scaleWidth : width
+    const useHeight = scaled ? Math.round((height * scaleWidth) / width) : height
+    const total = Math.max(1, Math.ceil(useHeight / sliceHeight))
+    const each = Math.ceil(useHeight / total)
+    const parts: string[] = []
+    for (let index = 0; index < total; index++) {
+      const offset = index === total - 1 ? Math.max(0, useHeight - each) : index * each
+      const output = path.join(tmpDir, 'slice-' + index + '.jpg')
+      const ok = await cropWithFfmpeg(useInput, output, useWidth, each, offset)
+      if (!ok || !fs.existsSync(output)) break
+      const url = await uploadSlice(fs.readFileSync(output), 'kkk-slice-' + index + '.jpg')
+      if (!url) break
+      parts.push('![#' + useWidth + 'px #' + each + 'px](' + url + ')')
+    }
+    if (!parts.length) return null
+    logger.mark('[图片切片] 错误卡片等超长图已切成 ' + parts.length + ' 段（markdown）')
+    return segment.markdown(parts.join(String.fromCharCode(10)))
+  } finally {
+    try { fs.rmSync(tmpDir, { recursive: true, force: true }) } catch { /* 忽略 */ }
+  }
+}

package/src/karin/module/utils/MotionPhoto.ts

@@ -0,0 +1,297 @@
+// 参考文章 https://blog.0to1.cf/posts/cn-motion-photo-format
+// 参考文章 https://blog.zzbd.org/motion-live-photo-webui
+// 参考项目 https://github.com/flashlab/motion-live-photo
+import fs from 'node:fs'
+import path from 'node:path'
+
+import { ffmpeg, logger } from 'node-karin'
+
+import { Common } from './Common'
+import { Config } from './Config'
+
+const xmpHeaderBuffer = Buffer.from('http://ns.adobe.com/xap/1.0/\u0000', 'utf8')
+const oppoExifHex =
+  'FFE100724578696600004D4D002A0000000800040100000400000001000005A001010004000000010000043C87690004000000010000003E011200030000000100000000000000000002928600020000000E0000005C920800040000000100000000000000006F706C75735F3833383836303800'
+const xiaomiExifHex =
+  'FFE1007E4578696600004D4D002A0000000800040100000400000001000005A001010004000000010000043C01120003000000010000000087690004000000010000003E000000000003889700010000000101000000920800040000000100000000928600020000000E00000068000000006F706C75735F3833383836303800'
+const huaweiHonorLiveIdFallback = 1915884
+
+type MotionPhotoSystem = 'google' | 'xiaomi' | 'oppo' | 'huawei_honor'
+
+const isJpegBuffer = (fileBuffer: Buffer): boolean => {
+  return fileBuffer.length > 2 && fileBuffer[0] === 0xff && fileBuffer[1] === 0xd8
+}
+
+const getJpegDimensions = (jpegBuffer: Buffer): { width: number; height: number } | null => {
+  let offset = 2
+  while (offset + 9 < jpegBuffer.length) {
+    if (jpegBuffer[offset] !== 0xff) {
+      offset += 1
+      continue
+    }
+    const marker = jpegBuffer[offset + 1]
+    if (marker === 0xd8 || marker === 0xd9 || marker === 0x01 || (marker >= 0xd0 && marker <= 0xd7)) {
+      offset += 2
+      continue
+    }
+    if (offset + 3 >= jpegBuffer.length) return null
+    const segmentLength = jpegBuffer.readUInt16BE(offset + 2)
+    if (segmentLength < 2 || offset + 2 + segmentLength > jpegBuffer.length) return null
+    const isSofMarker =
+      (marker >= 0xc0 && marker <= 0xc3) ||
+      (marker >= 0xc5 && marker <= 0xc7) ||
+      (marker >= 0xc9 && marker <= 0xcb) ||
+      (marker >= 0xcd && marker <= 0xcf)
+    if (isSofMarker && segmentLength >= 7) {
+      const height = jpegBuffer.readUInt16BE(offset + 5)
+      const width = jpegBuffer.readUInt16BE(offset + 7)
+      if (width > 0 && height > 0) return { width, height }
+      return null
+    }
+    offset += 2 + segmentLength
+  }
+  return null
+}
+
+const hasExifApp1 = (jpegBuffer: Buffer): boolean => {
+  return jpegBuffer.includes(Buffer.from('Exif\u0000\u0000', 'binary'))
+}
+
+const buildExifSegment = (hex: string, width: number, height: number): Buffer => {
+  const exifBuffer = Buffer.from(hex, 'hex')
+  exifBuffer[28] = (width >> 24) & 0xff
+  exifBuffer[29] = (width >> 16) & 0xff
+  exifBuffer[30] = (width >> 8) & 0xff
+  exifBuffer[31] = width & 0xff
+  exifBuffer[40] = (height >> 24) & 0xff
+  exifBuffer[41] = (height >> 16) & 0xff
+  exifBuffer[42] = (height >> 8) & 0xff
+  exifBuffer[43] = height & 0xff
+  return exifBuffer
+}
+
+const getSystemExifHex = (system: MotionPhotoSystem): string | null => {
+  if (system === 'oppo') return oppoExifHex
+  if (system === 'xiaomi') return xiaomiExifHex
+  return null
+}
+
+const resolveMotionPhotoSystem = (): MotionPhotoSystem => {
+  const system = Config.app.livePhotoSystem
+  if (system === 'google' || system === 'xiaomi' || system === 'oppo' || system === 'huawei_honor') {
+    return system
+  }
+  return 'google'
+}
+
+const buildMotionPhotoXmp = (
+  videoLength: number,
+  presentationTimestampUs: number,
+  system: MotionPhotoSystem,
+  hdrGainMapLength?: number
+): string => {
+  if (system === 'oppo') {
+    // OPPO 支持 HDR GainMap 的完整 XMP 数据
+    const containerItems = [
+      '<rdf:li rdf:parseType="Resource"><Container:Item Item:Mime="image/jpeg" Item:Semantic="Primary" Item:Length="0" Item:Padding="0" /></rdf:li>'
+    ]
+
+    // 如果有 HDR GainMap 数据，添加 GainMap 项
+    if (hdrGainMapLength && hdrGainMapLength > 0) {
+      containerItems.push(
+        `<rdf:li rdf:parseType="Resource"><Container:Item Item:Mime="image/jpeg" Item:Semantic="GainMap" Item:Length="${hdrGainMapLength}" Item:Padding="0" /></rdf:li>`
+      )
+    }
+
+    // 添加视频项
+    containerItems.push(
+      `<rdf:li rdf:parseType="Resource"><Container:Item Item:Mime="video/mp4" Item:Semantic="MotionPhoto" Item:Length="${videoLength}" /></rdf:li>`
+    )
+
+    return (
+      '<x:xmpmeta xmlns:x="adobe:ns:meta/" x:xmptk="Adobe XMP Core 5.1.0-jc003">' +
+      '<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">' +
+      '<rdf:Description rdf:about="" ' +
+      'xmlns:hdrgm="http://ns.adobe.com/hdr-gain-map/1.0/" ' +
+      'xmlns:GCamera="http://ns.google.com/photos/1.0/camera/" ' +
+      'xmlns:OpCamera="http://ns.oplus.com/photos/1.0/camera/" ' +
+      'xmlns:Container="http://ns.google.com/photos/1.0/container/" ' +
+      'xmlns:Item="http://ns.google.com/photos/1.0/container/item/" ' +
+      'hdrgm:Version="1.0" ' +
+      `GCamera:MotionPhoto="1" GCamera:MotionPhotoVersion="1" GCamera:MotionPhotoPresentationTimestampUs="${presentationTimestampUs}" ` +
+      `OpCamera:MotionPhotoPrimaryPresentationTimestampUs="${presentationTimestampUs}" OpCamera:MotionPhotoOwner="oplus" OpCamera:OLivePhotoVersion="2" OpCamera:VideoLength="${videoLength}">` +
+      '<Container:Directory><rdf:Seq>' +
+      containerItems.join('') +
+      '</rdf:Seq></Container:Directory>' +
+      '</rdf:Description>' +
+      '</rdf:RDF>' +
+      '</x:xmpmeta>'
+    )
+  }
+
+  if (system === 'xiaomi') {
+    return (
+      '<x:xmpmeta xmlns:x="adobe:ns:meta/" x:xmptk="Adobe XMP Core 5.1.0-jc003">' +
+      '<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">' +
+      '<rdf:Description rdf:about="" ' +
+      'xmlns:GCamera="http://ns.google.com/photos/1.0/camera/" ' +
+      'xmlns:MiCamera="http://ns.xiaomi.com/photos/1.0/camera/" ' +
+      'xmlns:Container="http://ns.google.com/photos/1.0/container/" ' +
+      'xmlns:Item="http://ns.google.com/photos/1.0/container/item/" ' +
+      `GCamera:MotionPhoto="1" GCamera:MotionPhotoVersion="1" GCamera:MotionPhotoPresentationTimestampUs="${presentationTimestampUs}" ` +
+      `GCamera:MicroVideo="1" GCamera:MicroVideoVersion="1" GCamera:MicroVideoOffset="${videoLength}" GCamera:MicroVideoPresentationTimestampUs="${presentationTimestampUs}" ` +
+      'MiCamera:XMPMeta="&lt;?xml version=&apos;1.0&apos; encoding=&apos;UTF-8&apos; standalone=&apos;yes&apos; ?&gt;">' +
+      '<Container:Directory><rdf:Seq>' +
+      '<rdf:li rdf:parseType="Resource"><Container:Item Item:Mime="image/jpeg" Item:Semantic="Primary" Item:Length="0" Item:Padding="0" /></rdf:li>' +
+      `<rdf:li rdf:parseType="Resource"><Container:Item Item:Mime="video/mp4" Item:Semantic="MotionPhoto" Item:Length="${videoLength}" Item:Padding="0" /></rdf:li>` +
+      '</rdf:Seq></Container:Directory>' +
+      '</rdf:Description>' +
+      '</rdf:RDF>' +
+      '</x:xmpmeta>'
+    )
+  }
+
+  return (
+    '<x:xmpmeta xmlns:x="adobe:ns:meta/" x:xmptk="Adobe XMP Core 5.1.0-jc003">' +
+    '<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">' +
+    '<rdf:Description rdf:about="" ' +
+    'xmlns:GCamera="http://ns.google.com/photos/1.0/camera/" ' +
+    'xmlns:Container="http://ns.google.com/photos/1.0/container/" ' +
+    'xmlns:Item="http://ns.google.com/photos/1.0/container/item/" ' +
+    `GCamera:MotionPhoto="1" GCamera:MotionPhotoVersion="1" GCamera:MotionPhotoPresentationTimestampUs="${presentationTimestampUs}">` +
+    '<Container:Directory><rdf:Seq>' +
+    '<rdf:li rdf:parseType="Resource"><Container:Item Item:Mime="image/jpeg" Item:Semantic="Primary" Item:Length="0" Item:Padding="0" /></rdf:li>' +
+    `<rdf:li rdf:parseType="Resource"><Container:Item Item:Mime="video/mp4" Item:Semantic="MotionPhoto" Item:Length="${videoLength}" Item:Padding="0" /></rdf:li>` +
+    '</rdf:Seq></Container:Directory>' +
+    '</rdf:Description>' +
+    '</rdf:RDF>' +
+    '</x:xmpmeta>'
+  )
+}
+
+const injectXmpToJpeg = (jpegBuffer: Buffer, xmpPacket: string, system: MotionPhotoSystem): Buffer => {
+  if (!isJpegBuffer(jpegBuffer)) {
+    throw new Error('输入图片不是 JPEG 格式')
+  }
+
+  const xmpPayload = Buffer.concat([xmpHeaderBuffer, Buffer.from(xmpPacket, 'utf8')])
+  const app1Length = xmpPayload.length + 2
+  if (app1Length > 65535) {
+    throw new Error('XMP 数据过大，无法写入 JPEG APP1')
+  }
+
+  const app1Segment = Buffer.alloc(4)
+  app1Segment[0] = 0xff
+  app1Segment[1] = 0xe1
+  app1Segment.writeUInt16BE(app1Length, 2)
+
+  const dimensions = getJpegDimensions(jpegBuffer)
+  const exifHex = getSystemExifHex(system)
+  const needExif = !hasExifApp1(jpegBuffer) && dimensions !== null && exifHex !== null
+  const exifSegment = needExif ? buildExifSegment(exifHex, dimensions.width, dimensions.height) : null
+
+  return Buffer.concat([jpegBuffer.subarray(0, 2), ...(exifSegment ? [exifSegment] : []), app1Segment, xmpPayload, jpegBuffer.subarray(2)])
+}
+
+const readOrConvertToJpeg = async (imagePath: string): Promise<Buffer> => {
+  const sourceBuffer = fs.readFileSync(imagePath)
+  if (isJpegBuffer(sourceBuffer)) {
+    return sourceBuffer
+  }
+
+  const tempJpegPath = path.join(Common.tempDri.images, `MotionPhoto_${Date.now()}_${Math.random().toString(36).slice(2)}.jpg`)
+  const result = await ffmpeg(`-y -i "${imagePath}" -frames:v 1 -q:v 2 "${tempJpegPath}"`)
+  if (!result.status) {
+    throw new Error(`图片转换 JPEG 失败: ${imagePath}`)
+  }
+
+  try {
+    return fs.readFileSync(tempJpegPath)
+  } finally {
+    fs.rmSync(tempJpegPath, { force: true })
+  }
+}
+
+/**
+ * 检测图片是否包含HDR GainMap数据
+ * @param imageBuffer JPEG图片缓冲区
+ * @returns HDR GainMap长度，如果没有则返回0
+ */
+const detectHdrGainMap = (imageBuffer: Buffer): number => {
+  try {
+    // 查找XMP数据段
+    const xmpStart = imageBuffer.indexOf('http://ns.adobe.com/xap/1.0/')
+    if (xmpStart === -1) return 0
+
+    // 查找HDR GainMap相关标记
+    const hdrGainMapMarker = 'Item:Semantic="GainMap"'
+    const gainMapIndex = imageBuffer.indexOf(hdrGainMapMarker, xmpStart)
+    if (gainMapIndex === -1) return 0
+
+    // 尝试提取GainMap长度
+    const lengthPattern = /Item:Length="(\d+)"/
+    const xmpSection = imageBuffer.subarray(xmpStart, xmpStart + 4096).toString('utf8')
+    const gainMapSection = xmpSection.substring(xmpSection.indexOf(hdrGainMapMarker))
+    const lengthMatch = gainMapSection.match(lengthPattern)
+
+    if (lengthMatch && lengthMatch[1]) {
+      const length = parseInt(lengthMatch[1], 10)
+      logger.debug(`检测到HDR GainMap，长度: ${length}`)
+      return length
+    }
+
+    // 如果找到GainMap标记但无法提取长度，返回默认值
+    logger.debug('检测到HDR GainMap标记，但无法提取长度，使用默认值')
+    return 463255 // 使用你提供的示例中的默认长度
+  } catch (error) {
+    logger.debug('HDR GainMap检测失败:', error)
+    return 0
+  }
+}
+
+export interface GoogleMotionPhotoOptions {
+  imagePath: string
+  videoPath: string
+  outputPath: string
+  presentationTimestampUs?: number
+  hdrGainMapLength?: number // HDR GainMap 长度，用于 OPPO HDR 支持
+}
+
+export const buildGoogleMotionPhoto = async (options: GoogleMotionPhotoOptions): Promise<boolean> => {
+  const { imagePath, videoPath, outputPath, presentationTimestampUs, hdrGainMapLength } = options
+  try {
+    const system = resolveMotionPhotoSystem()
+    const imageBuffer = await readOrConvertToJpeg(imagePath)
+    const videoBuffer = fs.readFileSync(videoPath)
+    const resolvedPresentationTimestampUs =
+      presentationTimestampUs === undefined || presentationTimestampUs < 0 ? 0 : presentationTimestampUs
+
+    // 自动检测HDR GainMap（仅对OPPO系统）
+    const detectedHdrGainMapLength = system === 'oppo' ? (hdrGainMapLength ?? detectHdrGainMap(imageBuffer)) : 0
+
+    const huaweiHonorFooter = Buffer.from(
+      `v2_f35              409:1000            LIVE_${resolvedPresentationTimestampUs > 0 ? Math.floor(resolvedPresentationTimestampUs) : huaweiHonorLiveIdFallback}`,
+      'utf8'
+    )
+    const outputBuffer =
+      system === 'huawei_honor'
+        ? Buffer.concat([imageBuffer, huaweiHonorFooter])
+        : (() => {
+            const xmpPacket = buildMotionPhotoXmp(videoBuffer.length, resolvedPresentationTimestampUs, system, detectedHdrGainMapLength)
+            const jpegWithXmp = injectXmpToJpeg(imageBuffer, xmpPacket, system)
+            return Buffer.concat([jpegWithXmp, videoBuffer])
+          })()
+    fs.mkdirSync(path.dirname(outputPath), { recursive: true })
+    fs.writeFileSync(outputPath, outputBuffer)
+
+    if (system === 'oppo' && detectedHdrGainMapLength > 0) {
+      logger.debug(`Motion Photo 封面生成成功(${system} with HDR): ${outputPath}`)
+    } else {
+      logger.debug(`Motion Photo 封面生成成功(${system}): ${outputPath}`)
+    }
+    return true
+  } catch (error) {
+    logger.error('Motion Photo 封面生成失败', error)
+    return false
+  }
+}