修复了在Windows上使用Web访问出现找不到/tmp文件的错误，现在全部都流式放到内存当中了。

并且支持本地自签名部署了

ncmcrypt/embed.go

@@ -1,44 +1,254 @@
 package ncmcrypt
 
 import (
+	"bytes"
+	"encoding/binary"
 	"fmt"
-	"os"
+
+	"github.com/go-flac/go-flac"
 )
 
 func EmbedMetadata(audio []byte, format NcmFormat, title, artist, album string, coverData []byte) ([]byte, error) {
-	tmpFile, err := os.CreateTemp("", "ncmdump-embed-*")
+	switch format {
-	if err != nil {
+	case Mp3:
-		return nil, fmt.Errorf("create temp file: %w", err)
+		return embedMP3(audio, title, artist, album, coverData)
+	case Flac:
+		return embedFLAC(audio, title, artist, album, coverData)
+	default:
+		return audio, nil
 	}
-	tmpPath := tmpFile.Name()
+}
-	defer os.Remove(tmpPath)
+
-
+func synchSafe(v int) []byte {
-	if _, err := tmpFile.Write(audio); err != nil {
+	b := make([]byte, 4)
-		tmpFile.Close()
+	b[0] = byte((v >> 21) & 0x7F)
-		return nil, fmt.Errorf("write temp: %w", err)
+	b[1] = byte((v >> 14) & 0x7F)
-	}
+	b[2] = byte((v >> 7) & 0x7F)
-	tmpFile.Close()
+	b[3] = byte(v & 0x7F)
-
+	return b
-	ncm := &NeteaseCloudMusic{
+}
-		mPng:          [8]byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A},
+
-		mFormat:       format,
+func textFrame(id string, text string) []byte {
-		mDumpFilePath: tmpPath,
+	if text == "" {
-		mImageData:    coverData,
+		return nil
-		mMetadata: &NeteaseClousMusicMetadata{
+	}
-			mName:   title,
+	data := append([]byte{0x03}, []byte(text)...)
-			mArtist: artist,
+	size := len(data)
-			mAlbum:  album,
+	frame := make([]byte, 10+size)
-		},
+	copy(frame[0:4], id)
-	}
+	copy(frame[4:8], synchSafe(size))
-
+	frame[8] = 0x00
-	if _, err := ncm.FixMetadata(false); err != nil {
+	frame[9] = 0x00
-		return nil, fmt.Errorf("write metadata: %w", err)
+	copy(frame[10:], data)
-	}
+	return frame
-
+}
-	result, err := os.ReadFile(tmpPath)
+
-	if err != nil {
+func apicFrame(mime string, picType byte, description string, data []byte) []byte {
-		return nil, fmt.Errorf("read result: %w", err)
+	if len(data) == 0 {
-	}
+		return nil
-
+	}
-	return result, nil
+	inner := make([]byte, 0, 1+len(mime)+1+1+len(description)+1+len(data))
+	inner = append(inner, 0x00)
+	inner = append(inner, []byte(mime)...)
+	inner = append(inner, 0x00)
+	inner = append(inner, picType)
+	inner = append(inner, []byte(description)...)
+	inner = append(inner, 0x00)
+	inner = append(inner, data...)
+
+	size := len(inner)
+	frame := make([]byte, 10+size)
+	copy(frame[0:4], "APIC")
+	copy(frame[4:8], synchSafe(size))
+	frame[8] = 0x00
+	frame[9] = 0x00
+	copy(frame[10:], inner)
+	return frame
+}
+
+func findMpegSync(data []byte) int {
+	for i := 0; i < len(data)-1; i++ {
+		if data[i] == 0xFF && (data[i+1]&0xE0) == 0xE0 {
+			return i
+		}
+	}
+	return len(data)
+}
+
+func skipID3v2(data []byte) int {
+	if len(data) >= 10 && string(data[0:3]) == "ID3" {
+		size := int(data[6])<<21 | int(data[7])<<14 | int(data[8])<<7 | int(data[9])
+		return 10 + size
+	}
+	return 0
+}
+
+func imageMime(data []byte) string {
+	if len(data) >= 8 && data[0] == 0x89 && data[1] == 0x50 && data[2] == 0x4E && data[3] == 0x47 {
+		return "image/png"
+	}
+	return "image/jpeg"
+}
+
+func embedMP3(audio []byte, title, artist, album string, coverData []byte) ([]byte, error) {
+	id3End := skipID3v2(audio)
+	frames := bytes.NewBuffer(nil)
+
+	if f := textFrame("TIT2", title); f != nil {
+		frames.Write(f)
+	}
+	if f := textFrame("TPE1", artist); f != nil {
+		frames.Write(f)
+	}
+	if f := textFrame("TALB", album); f != nil {
+		frames.Write(f)
+	}
+	if f := apicFrame(imageMime(coverData), 0x03, "", coverData); f != nil {
+		frames.Write(f)
+	}
+
+	if frames.Len() == 0 {
+		return audio, nil
+	}
+
+	body := frames.Bytes()
+	tagSize := len(body)
+
+	tag := make([]byte, 10+tagSize)
+	copy(tag[0:3], "ID3")
+	tag[3] = 0x03
+	tag[4] = 0x00
+	tag[5] = 0x00
+	copy(tag[6:10], synchSafe(tagSize))
+	copy(tag[10:], body)
+
+	out := make([]byte, 0, len(tag)+len(audio)-id3End)
+	out = append(out, tag...)
+	out = append(out, audio[id3End:]...)
+
+	return out, nil
+}
+
+func embedFLAC(audio []byte, title, artist, album string, coverData []byte) ([]byte, error) {
+	f, err := flac.ParseBytes(bytes.NewReader(audio))
+	if err != nil {
+		return nil, fmt.Errorf("parse FLAC: %w", err)
+	}
+
+	metaOffset := 4
+	for _, block := range f.Meta {
+		metaOffset += 4 + len(block.Data)
+	}
+	audioFrames := audio[metaOffset:]
+
+	var comments map[string]string
+	if title != "" || artist != "" || album != "" {
+		comments = make(map[string]string)
+		if title != "" {
+			comments["TITLE"] = title
+		}
+		if artist != "" {
+			comments["ARTIST"] = artist
+		}
+		if album != "" {
+			comments["ALBUM"] = album
+		}
+	}
+
+	newMeta := make([]*flac.MetaDataBlock, 0, len(f.Meta)+2)
+	for _, block := range f.Meta {
+		if block.Type == flac.Picture || block.Type == flac.VorbisComment {
+			continue
+		}
+		newMeta = append(newMeta, block)
+	}
+	if comments != nil {
+		newMeta = append(newMeta, buildVorbisComment(comments))
+	}
+	if len(coverData) > 0 {
+		newMeta = append(newMeta, buildPictureBlock(coverData))
+	}
+
+	var buf bytes.Buffer
+	buf.WriteString("fLaC")
+	for i, block := range newMeta {
+		header := byte(block.Type)
+		if i == len(newMeta)-1 {
+			header |= 0x80
+		}
+		buf.WriteByte(header)
+		size := make([]byte, 3)
+		size[0] = byte(len(block.Data) >> 16)
+		size[1] = byte(len(block.Data) >> 8)
+		size[2] = byte(len(block.Data))
+		buf.Write(size)
+		buf.Write(block.Data)
+	}
+	buf.Write(audioFrames)
+
+	return buf.Bytes(), nil
+}
+
+func buildVorbisComment(comments map[string]string) *flac.MetaDataBlock {
+	vendorLen := 0
+	var vendor string
+	dataLen := 4 + vendorLen + 4
+	for key, val := range comments {
+		dataLen += 4 + len(key) + 1 + len(val)
+	}
+
+	data := make([]byte, dataLen)
+	pos := 0
+	pos += putU32le(data[pos:], uint32(vendorLen))
+	pos += copy(data[pos:], vendor)
+	pos += putU32le(data[pos:], uint32(len(comments)))
+	for key, val := range comments {
+		entry := key + "=" + val
+		pos += putU32le(data[pos:], uint32(len(entry)))
+		pos += copy(data[pos:], entry)
+	}
+
+	return &flac.MetaDataBlock{
+		Type: flac.VorbisComment,
+		Data: data,
+	}
+}
+
+func buildPictureBlock(imageData []byte) *flac.MetaDataBlock {
+	mime := imageMime(imageData)
+	picType := uint32(3)
+	width := uint32(0)
+	height := uint32(0)
+	depth := uint32(24)
+	colors := uint32(0)
+
+	dataLen := 4 + len(mime) + 4 + 4 + 4 + 4 + 4 + len(imageData)
+	data := make([]byte, dataLen)
+	pos := 0
+	pos += putU32be(data[pos:], picType)
+	pos += putU32be(data[pos:], uint32(len(mime)))
+	pos += copy(data[pos:], mime)
+	pos += putU32be(data[pos:], uint32(len("")))
+	pos += copy(data[pos:], "")
+	pos += putU32be(data[pos:], width)
+	pos += putU32be(data[pos:], height)
+	pos += putU32be(data[pos:], depth)
+	pos += putU32be(data[pos:], colors)
+	pos += putU32be(data[pos:], uint32(len(imageData)))
+	copy(data[pos:], imageData)
+
+	return &flac.MetaDataBlock{
+		Type: flac.Picture,
+		Data: data,
+	}
+}
+
+func putU32le(b []byte, v uint32) int {
+	binary.LittleEndian.PutUint32(b, v)
+	return 4
+}
+
+func putU32be(b []byte, v uint32) int {
+	binary.BigEndian.PutUint32(b, v)
+	return 4
 }

web/src/App.tsx

@@ -13,8 +13,10 @@ export default function App() {
   const [outputHandle, setOutputHandle] = useState<any>(null)
   const [fileItems, setFileItems] = useState<FileItem[]>([])
   const [converting, setConverting] = useState(false)
+  const [concurrency, setConcurrency] = useState(3)
   const [progress, setProgress] = useState({ done: 0, total: 0 })
   const abortRef = useRef(false)
+  const doneCountRef = useRef(0)
 
   useEffect(() => {
     if (isWasmSupported()) {
@@ -47,36 +49,22 @@ export default function App() {
     setOutputHandle(handle)
   }, [])
 
-  const handleConvert = useCallback(async () => {
+  const processOne = useCallback(async (
-    if (!outputHandle || inputFiles.size === 0 || !wasmReady) return
+    entry: { file: File; name: string },
-
+    idx: number,
-    abortRef.current = false
+    updateStatus: (status: FileItem['status'], extra?: Partial<FileItem>) => void
-    setConverting(true)
+  ) => {
-    setProgress({ done: 0, total: inputFiles.size })
+    if (abortRef.current) return
-
-    const entries = Array.from(inputFiles.values())
-
-    for (let i = 0; i < entries.length; i++) {
-      if (abortRef.current) break
-
-      const entry = entries[i]
-
-      const setStatus = (status: FileItem['status'], extra?: Partial<FileItem>) =>
-        setFileItems((prev) => prev.map((item, idx) =>
-          idx === i ? { ...item, status, ...extra } : item
-        ))
-
-      setStatus('converting')
 
     try {
+      updateStatus('converting')
       const buf = await entry.file.arrayBuffer()
       const result = await convertNcm(buf)
       let audio = result.data
 
-        // Fetch cover image if available
       let coverData: Uint8Array | undefined
       if (result.coverUrl) {
-          setStatus('fetching_cover')
+        updateStatus('fetching_cover')
         try {
           const resp = await fetch(result.coverUrl)
           if (resp.ok) {
@@ -84,21 +72,18 @@ export default function App() {
             coverData = new Uint8Array(coverBuf)
           }
         } catch {
-            // cover fetch failed, proceed without it
+          // proceed without cover
         }
       }
 
-        // Embed metadata + cover
+      updateStatus('writing')
       if (result.title || result.artist || result.album || coverData) {
-          setStatus('writing')
         audio = await embedMetadata(
           audio,
           result.format,
           { title: result.title, artist: result.artist, album: result.album },
           coverData
         )
-        } else {
-          setStatus('writing')
       }
 
       const base = entry.name.replace(/\.ncm$/i, '')
@@ -109,16 +94,52 @@ export default function App() {
       await writable.write(audio)
       await writable.close()
 
-        setStatus('done', { format: result.format })
+      updateStatus('done', { format: result.format })
     } catch (e: any) {
-        setStatus('error', { error: e.message })
+      if (!abortRef.current) {
+        updateStatus('error', { error: e.message })
+      }
     }
 
-      setProgress({ done: i + 1, total: entries.length })
+    doneCountRef.current++
+    setProgress({ done: doneCountRef.current, total: inputFiles.size })
+  }, [inputFiles, outputHandle])
+
+  const handleConvert = useCallback(async () => {
+    if (!outputHandle || inputFiles.size === 0 || !wasmReady) return
+
+    abortRef.current = false
+    doneCountRef.current = 0
+    setConverting(true)
+    setProgress({ done: 0, total: inputFiles.size })
+
+    const entries = Array.from(inputFiles.values())
+
+    let nextIdx = 0
+    const workers: Promise<void>[] = []
+
+    const makeWorker = async () => {
+      while (true) {
+        const i = nextIdx++
+        if (i >= entries.length || abortRef.current) break
+
+        const setStatus = (status: FileItem['status'], extra?: Partial<FileItem>) =>
+          setFileItems((prev) => prev.map((item, idx) =>
+            idx === i ? { ...item, status, ...extra } : item
+          ))
+
+        await processOne(entries[i], i, setStatus)
+      }
     }
 
+    const n = Math.min(concurrency, entries.length)
+    for (let w = 0; w < n; w++) {
+      workers.push(makeWorker())
+    }
+
+    await Promise.all(workers)
     setConverting(false)
-  }, [inputFiles, outputHandle, wasmReady])
+  }, [inputFiles, outputHandle, wasmReady, processOne, concurrency])
 
   const handleAbort = useCallback(() => {
     abortRef.current = true
@@ -168,6 +189,20 @@ export default function App() {
             {inputFiles.size > 0 && (
               <div className="mt-3 animate-fade-in flex items-center gap-3">
                 <StatusBar progress={progress} />
+                <div className="flex shrink-0 items-center gap-2 text-xs text-slate-400">
+                  <span>并行</span>
+                  <select
+                    value={concurrency}
+                    onChange={(e) => setConcurrency(Number(e.target.value))}
+                    disabled={converting}
+                    className="rounded-lg bg-slate-800 border border-slate-700 px-2 py-2 text-slate-200
+                               focus:outline-none focus:border-indigo-500 disabled:opacity-40"
+                  >
+                    {[1, 2, 3, 4, 6, 8, 12, 16, 24, 32].map((n) => (
+                      <option key={n} value={n}>{n}</option>
+                    ))}
+                  </select>
+                </div>
                 <button
                   onClick={handleConvert}
                   disabled={!canConvert}