@dan-uni/dan-any 0.1.0 → 0.2.0

package/src/ass-gen/__tests__/canvas.test.ts

@@ -0,0 +1,11 @@
+import { assertType, it } from 'vitest'
+
+import { measureTextWidth } from '../util/layout'
+
+it('canvas measureTextWidth', () => {
+  const text = '一段测试文字'
+  const width = measureTextWidth('SimHei', 25, false, text)
+  assertType<number>(width)
+  console.info(width, text.length)
+  // assert(width >= 25 * text.length)
+})

package/src/ass-gen/__tests__/generate.test.ts

@@ -0,0 +1,20 @@
+import fs from 'node:fs'
+import path, { dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { it } from 'vitest'
+
+import { generateASS } from '../'
+import { UniPool } from '../..'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+
+it('generate ass from xml', () => {
+  const filename = '898651903.xml'
+  const xmlPath = path.join(__dirname, filename)
+  const xmlText = fs.readFileSync(xmlPath, 'utf-8')
+  const assText = generateASS(UniPool.fromBiliXML(xmlText), {
+    // filename,
+    // title: '我的忏悔',
+  })
+  fs.writeFileSync(path.join(__dirname, `${filename}.ass`), assText, 'utf-8')
+})

package/src/ass-gen/ass/create.ts

@@ -0,0 +1,26 @@
+import type { UniPool } from '../..'
+import type { Context, SubtitleStyle } from '../types'
+
+import { UniPool2DanmakuLists } from '../util'
+import event from './event'
+import info from './info'
+import raw from './raw'
+import style from './style'
+
+// eslint-disable-next-line import/no-default-export
+export default (
+  list: UniPool,
+  rawList: UniPool,
+  config: SubtitleStyle,
+  context: Context = { filename: 'unknown', title: 'unknown' },
+) => {
+  const Elist = UniPool2DanmakuLists(list),
+    ErawList = UniPool2DanmakuLists(rawList)
+  const content = [info(config, context), style(config), event(Elist, config)]
+
+  if (config.includeRaw) {
+    content.push(raw(ErawList, config, context))
+  }
+
+  return `${content.join('\n\n')}\n`
+}

package/src/ass-gen/ass/dialogue.ts

@@ -0,0 +1,91 @@
+import type { RGB } from '../types'
+
+import { DanmakuType } from '../types'
+import { formatColor, getDecoratingColor, isWhite } from '../util'
+
+// Dialogue: 0,0:00:00.00,0:00:08.00,R2L,,20,20,2,,{\move(622.5,25,-62.5,25)}标准小裤裤
+// Dialogue: 0,0:00:08.35,0:00:12.35,Fix,,20,20,2,,{\pos(280,50)\c&HEAA000}没男主吗
+
+const formatTime = (seconds: number) => {
+  const div = (i: number, j: number) => Math.floor(i / j)
+  const pad = (n: number) => (n < 10 ? `0${n}` : String(n))
+
+  const integer = Math.floor(seconds)
+  const hour = div(integer, 60 * 60)
+  const minute = div(integer, 60) % 60
+  const second = integer % 60
+  const minorSecond = Math.floor((seconds - integer) * 100) // 取小数部分2位
+
+  return `${hour}:${pad(minute)}:${pad(second)}.${minorSecond}`
+}
+
+const encode = (text: string) =>
+  text
+    .toString()
+    .replaceAll('{', '｛')
+    .replaceAll('}', '｝')
+    .replaceAll(/\r|\n/g, '')
+
+const scrollCommand = ({
+  start,
+  end,
+  top,
+}: {
+  start: number
+  end: number
+  top: number
+}) => `\\move(${start},${top},${end},${top})`
+const fixCommand = ({ top, left }: { top: number; left: number }) =>
+  `\\an8\\pos(${left},${top})`
+const colorCommand = (color: RGB) => `\\c${formatColor(color)}`
+const borderColorCommand = (color: RGB) => `\\3c${formatColor(color)}`
+
+// eslint-disable-next-line import/no-default-export
+export default (
+  danmaku: {
+    type: (typeof DanmakuType)[keyof typeof DanmakuType]
+    color: RGB
+    fontSizeType: number
+    content: string
+    time: number
+    start: number
+    end: number
+    top: number
+    left: number
+  },
+  config: { scrollTime: number; fixTime: number },
+) => {
+  const { fontSizeType, content, time } = danmaku
+  const { scrollTime, fixTime } = config
+
+  const commands = [
+    danmaku.type === DanmakuType.SCROLL
+      ? scrollCommand({
+          start: danmaku.start,
+          end: danmaku.end,
+          top: danmaku.top,
+        })
+      : fixCommand({ top: danmaku.top, left: danmaku.left }),
+    // 所有网站的原始默认色是白色，所以白色的时候不用额外加和颜色相关的指令
+    isWhite(danmaku.color) ? '' : colorCommand(danmaku.color),
+    isWhite(danmaku.color)
+      ? ''
+      : borderColorCommand(getDecoratingColor(danmaku.color)),
+  ]
+  const fields = [
+    0, // Layer,
+    formatTime(time), // Start
+    formatTime(
+      time + (danmaku.type === DanmakuType.SCROLL ? scrollTime : fixTime),
+    ), // End
+    `F${fontSizeType}`, // Style
+    '', // Name
+    '0000', // MarginL
+    '0000', // MarginR
+    '0000', // MarginV
+    '', // Effect
+    `{${commands.join('')}}${encode(content)}`, // Text
+  ]
+
+  return `Dialogue: ${fields.join(',')}`
+}

package/src/ass-gen/ass/event.ts

@@ -0,0 +1,58 @@
+import type { Danmaku, SubtitleStyle } from '../types'
+
+import { DanmakuType } from '../types'
+import dialogue from './dialogue'
+
+const calculateDanmakuPosition = (danmaku: Danmaku, config: SubtitleStyle) => {
+  const { playResX, playResY, scrollTime, fixTime } = config
+
+  switch (danmaku.type) {
+    case DanmakuType.SCROLL: {
+      const start = playResX
+      const end = -playResX / 10 // Some extra space for complete exit
+      const top = (danmaku.fontSizeType * playResY) / 20
+      return {
+        ...danmaku,
+        start,
+        end,
+        top,
+        left: 0,
+        duration: scrollTime,
+      }
+    }
+    case DanmakuType.TOP:
+    case DanmakuType.BOTTOM: {
+      const left = playResX / 2
+      const top =
+        danmaku.type === DanmakuType.TOP
+          ? (danmaku.fontSizeType * playResY) / 20
+          : playResY -
+            config.bottomSpace -
+            (danmaku.fontSizeType * playResY) / 20
+      return {
+        ...danmaku,
+        start: 0,
+        end: 0,
+        top,
+        left,
+        duration: fixTime,
+      }
+    }
+    default:
+      throw new Error(`Unknown danmaku type: ${danmaku.type}`)
+  }
+}
+
+// eslint-disable-next-line import/no-default-export
+export default (list: Danmaku[], config: SubtitleStyle) => {
+  const content = [
+    '[Events]',
+    'Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text',
+    ...list.map((danmaku) => {
+      const positionedDanmaku = calculateDanmakuPosition(danmaku, config)
+      return dialogue(positionedDanmaku, config)
+    }),
+  ]
+
+  return content.join('\n')
+}

package/src/ass-gen/ass/info.ts

@@ -0,0 +1,28 @@
+import type { Context } from '../types'
+
+import pkg from '../../../package.json' with { type: 'json' }
+
+type ExtraInfo = Context
+
+type Resolution = {
+  playResX: number
+  playResY: number
+}
+
+// eslint-disable-next-line import/no-default-export
+export default (
+  { playResX, playResY }: Resolution,
+  { filename, title }: ExtraInfo,
+) => {
+  const content = [
+    '[Script Info]',
+    `Title: ${title}`,
+    `Original Script: 根据 ${filename} 的弹幕信息，由 ${pkg.homepage} 生成`,
+    'ScriptType: v4.00+',
+    'Collisions: Reverse',
+    `PlayResX: ${playResX}`,
+    `PlayResY: ${playResY}`,
+    'Timer: 100.0000',
+  ]
+  return content.join('\n')
+}

package/src/ass-gen/ass/raw.ts

@@ -0,0 +1,69 @@
+import { brotliCompressSync, brotliDecompressSync, gzipSync } from 'node:zlib'
+import * as base16384 from 'base16384'
+import type { Context, Danmaku, SubtitleStyle } from '../types'
+
+type compressType = 'brotli' | 'gzip'
+type baseType = 'base64' | 'base18384'
+const compressTypes = ['brotli', 'gzip'],
+  baseTypes = ['base64', 'base18384']
+
+function fromUint16Array(array: Uint16Array): string {
+  let result = ''
+  for (const element of array) {
+    result += String.fromCharCode(element)
+  }
+  return result
+}
+
+// eslint-disable-next-line import/no-default-export
+export default (
+  list: Danmaku[],
+  config: SubtitleStyle,
+  context: Context,
+  compressType: compressType = 'brotli',
+  baseType: baseType = 'base18384',
+) => {
+  const raw = { list, config, context },
+    rawText = JSON.stringify(raw)
+  let compress = Buffer.from('')
+  if (compressType === 'brotli') compress = brotliCompressSync(rawText)
+  else compress = gzipSync(rawText)
+  return `;RawCompressType: ${compressType}\n;RawBaseType: ${baseType}\n;Raw: ${baseType === 'base64' ? compress.toString('base64') : fromUint16Array(base16384.encode(compress))}`
+}
+
+export function deRaw(ass: string):
+  | {
+      list: Danmaku[]
+      config: SubtitleStyle
+      context: Context
+    }
+  | undefined {
+  const arr = ass.split('\n'),
+    lineCompressType = arr.find((line) => line.startsWith(';RawCompressType:')),
+    lineBaseType = arr.find((line) => line.startsWith(';RawBaseType:')),
+    lineRaw = arr.find((line) => line.startsWith(';Raw:'))
+  if (!lineCompressType || !lineBaseType || !lineRaw) return undefined
+  else {
+    let compressType = lineCompressType
+        .replace(';RawCompressType: ', '')
+        .trim(),
+      baseType = lineBaseType.replace(';RawBaseType: ', '').trim()
+    if (!compressTypes.includes(compressType)) compressType = 'gzip'
+    if (!baseTypes.includes(baseType)) baseType = 'base64'
+    const text = lineRaw.replace(';Raw: ', '').trim(),
+      buffer =
+        baseType === 'base64'
+          ? Buffer.from(text, 'base64')
+          : Buffer.from(
+              base16384.decode(Buffer.from(text, 'utf-8').toString('utf-8')),
+            )
+    let decompress = Buffer.from('')
+    if (compressType === 'brotli') decompress = brotliDecompressSync(buffer)
+    else decompress = gzipSync(buffer)
+    try {
+      return JSON.parse(decompress.toString('utf-8'))
+    } catch {
+      return undefined
+    }
+  }
+}

package/src/ass-gen/ass/style.ts

@@ -0,0 +1,67 @@
+import type { SubtitleStyle } from '../types'
+
+import { formatColor, getDecoratingColor, hexColorToRGB } from '../util'
+
+// eslint-disable-next-line import/no-default-export
+export default ({
+  fontName,
+  fontSize,
+  color: configColor,
+  outlineColor,
+  backColor,
+  bold,
+  outline,
+  shadow,
+  opacity,
+}: SubtitleStyle) => {
+  const fields = [
+    'Name',
+    'Fontname',
+    'Fontsize',
+    'PrimaryColour',
+    'SecondaryColour',
+    'OutlineColour',
+    'BackColour',
+    'Bold',
+    'Italic',
+    'Underline',
+    'StrikeOut',
+    'ScaleX',
+    'ScaleY',
+    'Spacing',
+    'Angle',
+    'BorderStyle',
+    'Outline',
+    'Shadow',
+    'Alignment',
+    'MarginL',
+    'MarginR',
+    'MarginV',
+    'Encoding',
+  ]
+  // 默认白底黑框
+  const primaryColorValue = formatColor(hexColorToRGB(configColor), opacity)
+  // 边框和阴影颜色没给的话算一个出来，不是黑就是白
+  const secondaryColor = getDecoratingColor(hexColorToRGB(configColor))
+  const outlineColorValue = formatColor(
+    outlineColor ? hexColorToRGB(outlineColor) : secondaryColor,
+    opacity,
+  )
+  const backColorValue = formatColor(
+    backColor ? hexColorToRGB(backColor) : secondaryColor,
+    opacity,
+  )
+  const colorStyle = `${primaryColorValue},${primaryColorValue},${outlineColorValue},${backColorValue}`
+
+  const boldValue = bold ? '1' : '0'
+  const fontStyle = `${boldValue},0,0,0,100,100,0,0,1,${outline},${shadow},7,0,0,0,0`
+
+  const fontDeclaration = (size: number, i: number) =>
+    `Style: F${i},${fontName},${size},${colorStyle},${fontStyle}`
+  const content = [
+    '[V4+ Styles]',
+    `Format: ${fields.join(',')}`,
+    ...fontSize.map(fontDeclaration),
+  ]
+  return content.join('\n')
+}

package/src/ass-gen/config.ts

@@ -0,0 +1,45 @@
+import type { SubtitleStyle } from './types'
+
+import { assign, formatColor, hexColorToRGB } from './util'
+
+// const builtinRules = {
+//     COLOR: true,
+//     TOP: true,
+//     BOTTOM: true
+// }
+
+// const convertBlockRule = (rule: string) =>
+//     builtinRules[rule] ? rule : new RegExp(rule)
+
+export default (overrides = {}): SubtitleStyle => {
+  const defaults = {
+    fontSize: [25, 25, 36],
+    fontName: 'SimHei',
+    color: '#ffffff',
+    outlineColor: undefined,
+    backColor: undefined,
+    outline: 2,
+    shadow: 0,
+    bold: false,
+    padding: [2, 2, 2, 2],
+    playResX: 1280,
+    playResY: 720,
+    scrollTime: 8,
+    fixTime: 4,
+    opacity: 0.6,
+    bottomSpace: 60,
+    includeRaw: true,
+    mergeIn: -1,
+    // block: [],
+  }
+
+  const config = assign(defaults, overrides)
+  config.color = formatColor(hexColorToRGB(config.color))
+  config.outlineColor =
+    config.outlineColor && formatColor(hexColorToRGB(config.outlineColor))
+  config.backColor =
+    config.backColor && formatColor(hexColorToRGB(config.backColor))
+  // config.block = uniqueArray(config.block).map(convertBlockRule)
+
+  return config
+}

package/src/ass-gen/index.ts

@@ -0,0 +1,52 @@
+// import parse from './parse/bilibili'
+import type { SubtitleStyle } from './types'
+
+import { UniPool } from '..'
+import ass from './ass/create'
+import { deRaw } from './ass/raw'
+import getConfig from './config'
+import { DanmakuList2UniPool, layoutDanmaku } from './util'
+
+export type Options = {
+  filename?: string
+  title?: string
+  substyle?: Partial<SubtitleStyle>
+}
+
+/**
+ * 使用bilibili弹幕(XMl)生成ASS字幕文件
+ * @param {string} danmaku XML弹幕文件内容
+ * @param {Options} options 杂项
+ * @returns {string} 返回ASS字幕文件内容
+ * @description 杂项相关  
+`filename`: 还原文件为XML时使用的默认文件名  
+`title`: ASS [Script Info] Title 项的值,显示于播放器字幕选择  
+`substyle`: ASS字幕样式
+ * @example ```ts
+import fs from 'fs'
+const filename = 'example.xml'
+const xmlText = fs.readFileSync(filename, 'utf-8')
+const assText = generateASS(xmlText, { filename, title: 'Quick Example' })
+fs.writeFileSync(`${filename}.ass`, assText, 'utf-8')
+```
+ */
+export function generateASS(danmaku: UniPool, options: Options): string {
+  //   const result = parse(text)
+  const config = getConfig(options.substyle)
+  // const filteredList = filterDanmaku(result.list, config.block)
+  // const mergedList = mergeDanmaku(result.list, config.mergeIn)
+  const mergedList = danmaku.merge(config.mergeIn)
+  const layoutList = layoutDanmaku(mergedList, config)
+  const content = ass(layoutList, danmaku, config, {
+    filename: options?.filename || 'unknown',
+    title: options?.title || 'unknown',
+  })
+
+  return content
+}
+
+export function parseAssRawField(ass: string): UniPool {
+  const raw = deRaw(ass)
+  if (!raw) return UniPool.create()
+  else return DanmakuList2UniPool(raw.list)
+}

package/src/ass-gen/types.ts

@@ -0,0 +1,52 @@
+// export type BlockRule = string | RegExp
+
+import type { UniDM } from '../utils/dm-gen'
+
+export interface Context {
+  filename: string
+  title: string
+}
+
+export interface SubtitleStyle {
+  fontSize: number[]
+  fontName: string
+  color: string
+  outlineColor?: string
+  backColor?: string
+  outline: number
+  shadow: number
+  bold: boolean
+  padding: number[]
+  playResX: number
+  playResY: number
+  scrollTime: number
+  fixTime: number
+  opacity: number
+  bottomSpace: number
+  // block: BlockRule[]
+  includeRaw: boolean
+  mergeIn: number
+}
+
+export type RGB = { r: number; g: number; b: number }
+
+export const DanmakuType = {
+  SCROLL: 1,
+  BOTTOM: 2,
+  TOP: 3,
+}
+
+export const FontSize = {
+  SMALL: 0,
+  NORMAL: 1,
+  LARGE: 2,
+}
+
+export type Danmaku = {
+  time: number
+  type: number
+  fontSizeType: number
+  color: RGB
+  content: string
+  extra: UniDM
+}

package/src/ass-gen/util/color.ts

@@ -0,0 +1,55 @@
+import type { RGB } from '../types'
+
+const pad = (s: string) => (s.length < 2 ? `0${s}` : s)
+const decimalToHex = (n: number) => pad(n.toString(16))
+
+/**
+ * 本函数实现复制自 [us-danmaku](https://github.com/tiansh/us-danmaku) 项目
+ */
+const isDarkColor = ({ r, g, b }: RGB) =>
+  r * 0.299 + g * 0.587 + b * 0.114 < 0x30
+
+const WHITE = { r: 255, g: 255, b: 255 }
+const BLACK = { r: 0, g: 0, b: 0 }
+
+export const hexColorToRGB = (hex: string) => {
+  if (hex.indexOf('#') === 0) {
+    hex = hex.slice(1)
+  }
+
+  const [r, g, b] =
+    hex.length === 3 ? hex.split('').map((c) => c + c) : hex.match(/../g) || []
+
+  return {
+    r: Number.parseInt(r, 16),
+    g: Number.parseInt(g, 16),
+    b: Number.parseInt(b, 16),
+  }
+}
+
+export const decimalColorToRGB = (decimal: number) => {
+  const div = (i: number, j: number) => Math.floor(i / j)
+
+  return {
+    r: div(decimal, 256 * 256),
+    g: div(decimal, 256) % 256,
+    b: decimal % 256,
+  }
+}
+
+export const formatColor = ({ r, g, b }: RGB, opacity?: number) => {
+  const color = [b, g, r]
+
+  if (opacity !== undefined) {
+    const alpha = Math.round((1 - opacity) * 255)
+    color.unshift(alpha)
+  }
+
+  return `&H${color.map(decimalToHex).join('').toUpperCase()}`
+}
+
+export const getDecoratingColor = (color: RGB) =>
+  isDarkColor(color) ? WHITE : BLACK
+
+export const isWhite = (color: RGB) =>
+  color.r === 255 && color.g === 255 && color.b === 255

package/src/ass-gen/util/danconvert.ts

@@ -0,0 +1,36 @@
+import type { Danmaku, RGB } from '../types'
+
+import { UniPool } from '../..'
+import { Modes } from '../../utils/dm-gen'
+import { DanmakuType } from '../types'
+
+function decimalToRGB888(decimal: number): RGB {
+  const r = (decimal >> 16) & 0xff
+  const g = (decimal >> 8) & 0xff
+  const b = decimal & 0xff
+  return {
+    r,
+    g,
+    b,
+  } satisfies RGB
+}
+
+export function UniPool2DanmakuLists(UP: UniPool): Danmaku[] {
+  const dans = UP.dans
+  let type = DanmakuType.SCROLL
+  return dans.map((d) => {
+    if (d.mode === Modes.Bottom) type = DanmakuType.BOTTOM
+    else if (d.mode === Modes.Top) type = DanmakuType.TOP
+    return {
+      time: d.progress,
+      type,
+      fontSizeType: d.fontsize,
+      content: d.content,
+      color: decimalToRGB888(d.color),
+      extra: d,
+    } satisfies Danmaku
+  })
+}
+export function DanmakuList2UniPool(d: Danmaku[]): UniPool {
+  return new UniPool(d.map((d) => d.extra))
+}

package/src/ass-gen/util/index.ts

@@ -0,0 +1,10 @@
+export {
+  decimalColorToRGB,
+  formatColor,
+  getDecoratingColor,
+  hexColorToRGB,
+  isWhite,
+} from './color'
+export { layoutDanmaku } from './layout'
+export { arrayOfLength, assign, uniqueArray } from './lang'
+export { DanmakuList2UniPool, UniPool2DanmakuLists } from './danconvert'

package/src/ass-gen/util/lang.ts

@@ -0,0 +1,35 @@
+export const assign = <T extends object>(
+  source: T,
+  ...targets: Partial<T>[]
+): T => {
+  for (const target of targets) {
+    for (const key of Object.keys(target)) {
+      ;(source as any)[key] = target[key as keyof typeof target]
+    }
+  }
+
+  return source
+}
+
+export const arrayOfLength = <T>(length: number, defaultValue: T): T[] => {
+  // eslint-disable-next-line unicorn/no-new-array
+  const array = new Array(length)
+  for (let i = 0; i < length; i++) {
+    array[i] = defaultValue
+  }
+  return array
+}
+
+export const uniqueArray = <T>(array: T[]) => {
+  const duplicates: T[] = []
+  const result: T[] = []
+
+  for (const item of array) {
+    if (!duplicates.includes(item)) {
+      duplicates.push(item)
+      result.push(item)
+    }
+  }
+
+  return result
+}