Upload PC-Mix v1.2 dataset

Mixed_soundsV1.2/Mixed_soundsV1.2.tar.zst.part-000

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a7572623cfeeea97b2cce5c9d7ecca128e20efa0e99db1376a3626b8e82accae
+size 2147483648

Mixed_soundsV1.2/Mixed_soundsV1.2.tar.zst.part-001

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1207da32c2acbd93e7e46e25c1620dbe188d18b6cc34086669392fccbfde95ce
+size 2147483648

Mixed_soundsV1.2/Mixed_soundsV1.2.tar.zst.part-002

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:51218679737b515d7eb70f00b7a588cb3b4f312d6949e8ff8bea0c147793b4ac
+size 2147483648

Mixed_soundsV1.2/Mixed_soundsV1.2.tar.zst.part-003

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9f58eeece10822ae252f3d0e01e67bb3ce2b451b463b4b043d1f707a4a38147c
+size 2147483648

Mixed_soundsV1.2/Mixed_soundsV1.2.tar.zst.part-004

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ee42cfb76c2e639011080a84bb7a12839d47df51ae3f698abe4fd8c6966e5b21
+size 2147483648

Mixed_soundsV1.2/Mixed_soundsV1.2.tar.zst.part-005

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6a9b185d6e3cd4de2678a7959e2ae63c5cb99662a6f21f2772f5013fcf0fdff2
+size 2147483648

Mixed_soundsV1.2/Mixed_soundsV1.2.tar.zst.part-006

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f97c88a2299f7f4bdc84fead4ccb9780a624edea71ad3254cf1d8077607de6db
+size 2147483648

Mixed_soundsV1.2/Mixed_soundsV1.2.tar.zst.part-007

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:334a2e4cf6b99576e23ea99162c2319639e6fe87f3fa8679ace230714484aca4
+size 2147483648

Mixed_soundsV1.2/Mixed_soundsV1.2.tar.zst.part-008

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:83a9fa687c1eddf6f6a6d8a063dd43631029e264089fba884864a4ecc98f2c1a
+size 2147483648

Mixed_soundsV1.2/Mixed_soundsV1.2.tar.zst.part-009

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dc56700012a8555111e6b2ed1f5a3e58ec18aacf1c40b8bc75b8b49c162048fd
+size 2147483648

Mixed_soundsV1.2/Mixed_soundsV1.2.tar.zst.part-010

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3801fddbec1dcd11bed4206b1d68d54ed81820d182904f99b61ce8e1fef0c4a2
+size 219526411

Partialspoof_background/Partialspoof_background.tar.zst.part-000

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5114f28b49ebb5386b4e77fac0c72b14cc633f3f070c5b60397c1fdbc8716d0c
+size 2147483648

Partialspoof_background/Partialspoof_background.tar.zst.part-001

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bd4fe6003d09b8164b0655a4ffa82492e0b4f2112710751667a1933c6af3790c
+size 2147483648

Partialspoof_background/Partialspoof_background.tar.zst.part-002

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:da4bb9a061cf18da50c6b00c5670ee9d3d3fb8ccedfdc413452955e6e77ad0ea
+size 2147483648

Partialspoof_background/Partialspoof_background.tar.zst.part-003

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:95c708fa0adee20ba5e60e9a773dcbcba0c76511a67a55412e711ba193e7c85d
+size 2147483648

Partialspoof_background/Partialspoof_background.tar.zst.part-004

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bc3c1dedfc3ea00634286d6381abd1056b5bd15964536dba4d6154a8d3f9b4da
+size 262419374

README.md

@@ -1,3 +1,347 @@
----
-license: cc-by-nc-4.0
----
+---
+pretty_name: "PC-Mix"
+language:
+  - en
+task_categories:
+  - audio-classification
+tags:
+  - audio
+  - anti-spoofing
+  - partially-spoofed-audio
+  - environmental-sounds
+license: other
+---
+
+# PC-Mix Dataset
+
+**Partial Spoof Dataset with Controlled Speech–Environmental Sounds Mixing**
+
+PC-Mix pairs speech from **PartialSpoof v1.2** with a **self-curated partial-spoof environmental sounds pool** to create controlled speech–environment authenticity combinations. The **original** samples are collected from **VGGSound** and **SBCSAE**.
+
+## Resources
+
+| Resource | Description | Link |
+|---|---|---|
+| GitHub | Code, protocols, and preprocessing scripts. | [Anonymous GitHub](https://anonymous.4open.science/r/PC-Mix-3AFE/README.md) |
+| Paper | Dataset description and baselines. | PDF / arXiv (TBD) |
+| Hugging Face | Dataset card and hosted files. | [HF Dataset](https://huggingface.co/datasets/Alphawarheads/PC-Mix) |
+| Download | Direct access to the packaged dataset files. | [Download Files](https://huggingface.co/datasets/Alphawarheads/PC-Mix/tree/main) |
+
+## Download and Setup
+
+PC-Mix is hosted on Hugging Face under `Alphawarheads/PC-Mix`. The dataset directories are compressed with `tar` and `zstd`, then split into fixed-size volumes for more convenient downloading. All archive parts belonging to the same directory must be downloaded before extraction.
+
+### Option 1: Download with Hugging Face CLI
+
+```bash
+pip install -U "huggingface_hub[cli]"
+
+huggingface-cli download Alphawarheads/PC-Mix \
+  --repo-type dataset \
+  --local-dir ./PC-Mix
+```
+
+### Option 2: Clone with Git LFS
+
+```bash
+git lfs install
+
+git clone https://huggingface.co/datasets/Alphawarheads/PC-Mix
+```
+
+### Option 3: Access from Python
+
+```python
+from huggingface_hub import snapshot_download
+
+snapshot_download(
+    repo_id="Alphawarheads/PC-Mix",
+    repo_type="dataset",
+    local_dir="./PC-Mix",
+)
+```
+
+### Install the extraction dependency
+
+The archive volumes use Zstandard compression.
+
+Using Conda:
+
+```bash
+conda install -c conda-forge zstd
+```
+
+Using Ubuntu/Debian:
+
+```bash
+sudo apt install zstd
+```
+
+## Packaged File Structure
+
+The files hosted on Hugging Face are organized as follows:
+
+```text
+PC-Mix/
+├── README.md
+├── buildSBCori.py
+├── extract_orig_from_mixed_protocol.py
+├── FILELIST.txt
+├── SHA256SUMS
+│
+├── Mixed_soundsV1.2/
+│   ├── Mixed_soundsV1.2.tar.zst.part-000
+│   ├── Mixed_soundsV1.2.tar.zst.part-001
+│   ├── Mixed_soundsV1.2.tar.zst.part-002
+│   └── ...
+│
+└── Partialspoof_background/
+    ├── Partialspoof_background.tar.zst.part-000
+    ├── Partialspoof_background.tar.zst.part-001
+    └── ...
+```
+
+The split volumes preserve the original directory names and all internal relative paths. After extraction, the dataset returns to the directory structure described in [Dataset Structure](#dataset-structure).
+
+### Verify downloaded volumes
+
+Run the checksum verification from the downloaded repository root:
+
+```bash
+cd ./PC-Mix
+sha256sum -c SHA256SUMS
+```
+
+Every successfully downloaded volume should be reported as `OK`.
+
+## Extract the Split Archives
+
+Create a destination directory:
+
+```bash
+mkdir -p ./PC_Mix_extracted
+```
+
+### Extract `Mixed_soundsV1.2`
+
+```bash
+cat ./PC-Mix/Mixed_soundsV1.2/Mixed_soundsV1.2.tar.zst.part-* \
+  | zstd -dc \
+  | tar -xf - -C ./PC_Mix_extracted
+```
+
+### Extract `Partialspoof_background`
+
+```bash
+cat ./PC-Mix/Partialspoof_background/Partialspoof_background.tar.zst.part-* \
+  | zstd -dc \
+  | tar -xf - -C ./PC_Mix_extracted
+```
+
+After extraction:
+
+```text
+PC_Mix_extracted/
+├── Mixed_soundsV1.2/
+└── Partialspoof_background/
+```
+
+Do not rename, individually decompress, or extract the `.part-*` files. They are consecutive parts of a single compressed archive and must be concatenated in numerical order.
+
+## Reconstruct the SBCSAE-Derived Original WAV Files
+
+Due to the **CC BY-ND 3.0 US** license of SBCSAE, SBCSAE-derived cropped audio is not directly redistributed in PC-Mix. The repository provides the protocols and preprocessing scripts required to reconstruct these files locally after obtaining the official SBCSAE WAV data.
+
+The reconstruction workflow uses:
+
+- `extract_orig_from_mixed_protocol.py`
+- `buildSBCori.py`
+- the extracted `Mixed_soundsV1.2` directory
+- the official SBCSAE `WAV` directory
+
+### 1. Remove SBCSAE-derived original files before redistribution
+
+This command identifies SBCSAE-derived original entries through the mixed-data protocols and deletes their corresponding `train_orig_*` or `eval_orig_*` WAV files.
+
+```bash
+python extract_orig_from_mixed_protocol.py \
+  --mixed_sounds_dir /dkucc/home/zz324/Audiodata/PC_Mix/Mixed_soundsV1.2 \
+  --delete
+```
+
+This step is primarily used when preparing a redistributable release. Users downloading the public PC-Mix package normally receive a version in which these restricted files have already been removed.
+
+### 2. Reconstruct the omitted WAV files locally
+
+After downloading the official SBCSAE audio and placing its WAV files under a local `WAV` directory, run:
+
+```bash
+python buildSBCori.py \
+  --input_dir /dkucc/home/zz324/Audiodata/WAV \
+  --mixed_sounds_dir /dkucc/home/zz324/Audiodata/PC_Mix/Mixed_soundsV1.2 \
+  --protocol_ref /dkucc/home/zz324/Audiodata/PC_Mix/Mixed_soundsV1.2 \
+  --overwrite
+```
+
+Arguments:
+
+- `--input_dir`: directory containing the officially obtained SBCSAE WAV files.
+- `--mixed_sounds_dir`: extracted `Mixed_soundsV1.2` directory in which the reconstructed original files will be written.
+- `--protocol_ref`: directory containing the train and evaluation protocols used to locate the required SBCSAE source segments.
+- `--overwrite`: regenerate target files even when files with the same names already exist.
+
+The script reconstructs the omitted SBCSAE-derived original clips while preserving the expected PC-Mix file names and directory layout.
+
+## Audio Class Description
+
+PC-Mix provides both utterance-level and frame-level annotations.
+
+At the utterance level, each sample is assigned to one of five classes: one class for original real-world recordings and four classes for constructed mixtures with different speech/environmental-sound authenticity combinations.
+
+At the frame level, PC-Mix focuses on constructed mixtures only. Each frame is assigned to one of four classes based on whether the speech component, the environmental-sound component, or both components are spoofed at that time.
+
+### Utterance-Level Classes
+
+| Class | Name | Speech | Environmental Sounds | Description |
+|---:|---|---|---|---|
+| 0 | Original | — | — | A naturally recorded audio clip containing speech and environmental sounds, without artificial speech–environment mixing. |
+| 1 | Bona fide + Bona fide | Bona fide | Bona fide | A constructed mixture where both the speech component and the environmental-sound component are bona fide. |
+| 2 | Spoofed + Bona fide | Spoofed | Bona fide | A constructed mixture containing partially spoofed speech while the environmental-sound component remains bona fide. |
+| 3 | Bona fide + Spoofed | Bona fide | Spoofed | A constructed mixture containing bona fide speech with partially spoofed environmental sounds. |
+| 4 | Spoofed + Spoofed | Spoofed | Spoofed | A constructed mixture where both speech and environmental sounds contain partially spoofed regions. |
+
+### Frame-Level Classes
+
+| Class | Name | Speech | Environmental Sounds | Description |
+|---:|---|---|---|---|
+| 0 | Bona fide frame | Bona fide | Bona fide | Neither component is spoofed in this frame. |
+| 1 | Speech-spoofed frame | Spoofed | Bona fide | The local spoofing occurs in the speech component only. |
+| 2 | Environmental-sound-spoofed frame | Bona fide | Spoofed | The local spoofing occurs in the environmental-sound component only. |
+| 3 | Both-spoofed frame | Spoofed | Spoofed | Both speech and environmental sounds are spoofed in this frame. |
+
+## Dataset Structure
+
+After the split archives have been extracted and the omitted SBCSAE-derived original clips have been reconstructed, the dataset follows this structure:
+
+```text
+PC_Mix
+├── README.md
+│
+├── Mixed_soundsV1.2                                  # mixed speech + environmental sounds audio
+│   │
+│   ├── train                                         # training split
+│   │   ├── protocol.txt                              # mapping from mixed audio to source speech/environmental sounds
+│   │   ├── wav                                       # mixed audio files, e.g., train_mix_0000000.wav
+│   │   └── labels                                    # NumPy label files
+│   │       ├── speech                                # speech-component segment labels
+│   │       ├── env                                   # environmental-sounds component segment labels
+│   │       ├── mix                                   # mixture-level segment labels
+│   │       └── original_vs_others_seglab             # original-vs-non-original segment labels
+│   │
+│   ├── eval                                          # evaluation split
+│   │   ├── protocol.txt                              # mapping from mixed audio to source speech/environmental sounds
+│   │   ├── wav                                       # mixed audio files, e.g., eval_E0_mix_0000006.wav
+│   │   └── labels                                    # NumPy label files
+│   │       ├── speech
+│   │       ├── env
+│   │       ├── mix
+│   │       └── original_vs_others_seglab
+│   │
+│   ├── label_PartialSpoof_train                      # text-format PartialSpoof-style labels for training
+│   │   ├── wav-train.scp
+│   │   ├── original_vs_others_utt_labels.txt
+│   │   ├── speech                                    # train_protocol_*.txt
+│   │   ├── env                                       # train_protocol_*.txt
+│   │   ├── mix                                       # train_protocol_*.txt
+│   │   └── original_vs_others_seglab                 # train_protocol_*.txt
+│   │
+│   └── label_PartialSpoof_eval                       # text-format PartialSpoof-style labels for evaluation
+│       ├── wav-eval.scp
+│       ├── original_vs_others_utt_labels.txt
+│       ├── speech                                    # eval_protocol_*.txt
+│       ├── env                                       # eval_protocol_*.txt
+│       ├── mix                                       # eval_protocol_*.txt
+│       └── original_vs_others_seglab                 # eval_protocol_*.txt
+│
+└── Partialspoof_background                           # source environmental sounds data
+    │
+    ├── train                                         # training environmental sounds split
+    │   ├── protocol.txt                              # environmental sounds audio protocol
+    │   ├── wav                                       # environmental sounds audio files
+    │   └── labels                                    # segment labels in .npy/.txt formats
+    │
+    ├── eval                                          # evaluation environmental sounds split
+    │   ├── protocol.txt                              # environmental sounds audio protocol
+    │   ├── wav                                       # environmental sounds audio files
+    │   └── labels                                    # segment labels in .npy/.txt formats
+    │
+    ├── label_PartialSpoof_train                      # text-format environmental sounds labels for training
+    │   └── train_protocol_*.txt
+    │
+    └── label_PartialSpoof_eval                       # text-format environmental sounds labels for evaluation
+        └── eval_protocol_*.txt
+```
+
+## Audio Source
+
+| Component | Source | Description |
+|---|---|---|
+| Speech | PartialSpoof v1.2 | Speech samples with partially spoofed speech annotations. |
+| Environmental Sounds | Self-curated partial-spoof environmental sounds pool | Environmental sounds with controlled bona fide/spoofed component labels. |
+| Original | VGGSound and SBCSAE | Original recordings without artificial speech–environment mixing. |
+
+## Data Splits
+
+### Training Set
+
+| Split | Mixed Samples | Original Samples | Environmental Sounds Source | Event Source | Fusion Method |
+|---|---:|---:|---|---|---|
+| Train | 25,380 | 12,155 | SONYC | 60% AudioLDM2; 40% UrbanSound8K (0–1 s) | Ducking Overlay |
+
+### Evaluation Sets
+
+| Subset | Mixed | Original | Environmental Sounds | Event | Fusion |
+|---|---:|---:|---|---|---|
+| E0 Baseline | 17,812 | 17,809 | SONYC | 60% AudioLDM2; 40% FSD50K (0–1 s) | Ducking Overlay |
+| E1 Generator OOD | 14,248 | — | SONYC | AudioGen | Ducking Overlay |
+| E2 Fusion OOD | 14,248 | — | SONYC | AudioLDM2 | Energy Matching + Crossfade (20–80 ms) |
+| E3 Environmental Sounds OOD | 17,809 | — | DEMAND | AudioLDM2 | Ducking Overlay |
+| E4 Noise OOD | 7,125 | — | WHAM Noise | AudioLDM2 | Ducking Overlay |
+
+## Metadata
+
+Each mixed sample is associated with a protocol entry that records its mixed-audio ID, speech source, environmental sounds source, mixing duration, SNR, gain/scaling information, and offset information.
+
+Example:
+
+```text
+train_mix_0000000 mix CON_T_0000000.wav train_29_006663_s2.wav 1.000 1.400 snr_db=8.000 bg_scale=0.425705 offset_sec=0.909625 offset_samp=14554
+```
+
+## Citation
+
+<!-- Citation information will be added after publication. -->
+
+## License 🔐
+
+PC-Mix is released for non-commercial research purposes. Part of this dataset is a derived dataset constructed by combining, mixing, cropping, and generating audio samples from multiple publicly available datasets and audio generation models. Users must comply with the original licenses of all upstream datasets and models.
+
+- The [PartialSpoof](https://zenodo.org/records/5112031), [VGGSound](https://www.robots.ox.ac.uk/~vgg/data/vggsound/), and [SONYC-UST](https://zenodo.org/records/3966543) datasets are released under the CC BY 4.0 license.
+
+- The [UrbanSound8K](https://zenodo.org/records/1203745) and [WHAM!](https://wham.whisper.ai/) noise data are released under the CC BY-NC 4.0 license.
+
+- The [FSD50K](https://zenodo.org/records/4060432) dataset contains audio clips under multiple Creative Commons licenses, including CC0, CC BY, CC BY-NC, and CC Sampling+. Users should follow the per-clip license metadata provided by FSD50K.
+
+- The [DEMAND](https://zenodo.org/records/1227121) dataset is released under the CC BY-SA 3.0 license.
+
+- The synthetic environmental event sounds generated by [AudioLDM2](https://huggingface.co/cvssp/audioldm2) are produced using model weights released under the CC BY-NC-SA 4.0 license.
+
+- The synthetic environmental event sounds generated by [AudioGen](https://huggingface.co/facebook/audiogen-medium) are produced using model weights released under the CC BY-NC 4.0 license.
+
+- The [SBCSAE / Santa Barbara Corpus of Spoken American English](https://www.openslr.org/155/) is released under the CC BY-ND 3.0 US license. Due to the NoDerivatives condition, SBCSAE-derived audio clips are not directly redistributed in PC-Mix. We only provide the official download link, segment-level metadata, and preprocessing scripts so that users who have obtained SBCSAE from the official source can reproduce this subset locally.
+
+> **Important:** PC-Mix does not override the licenses of the original datasets or models. By using PC-Mix, users agree to comply with all upstream license terms.
+
+## Contact Information
+
+<!-- Contact information will be added after the anonymous review period. -->

SHA256SUMS

@@ -0,0 +1,16 @@
+a7572623cfeeea97b2cce5c9d7ecca128e20efa0e99db1376a3626b8e82accae  ./Mixed_soundsV1.2/Mixed_soundsV1.2.tar.zst.part-000
+1207da32c2acbd93e7e46e25c1620dbe188d18b6cc34086669392fccbfde95ce  ./Mixed_soundsV1.2/Mixed_soundsV1.2.tar.zst.part-001
+51218679737b515d7eb70f00b7a588cb3b4f312d6949e8ff8bea0c147793b4ac  ./Mixed_soundsV1.2/Mixed_soundsV1.2.tar.zst.part-002
+9f58eeece10822ae252f3d0e01e67bb3ce2b451b463b4b043d1f707a4a38147c  ./Mixed_soundsV1.2/Mixed_soundsV1.2.tar.zst.part-003
+ee42cfb76c2e639011080a84bb7a12839d47df51ae3f698abe4fd8c6966e5b21  ./Mixed_soundsV1.2/Mixed_soundsV1.2.tar.zst.part-004
+6a9b185d6e3cd4de2678a7959e2ae63c5cb99662a6f21f2772f5013fcf0fdff2  ./Mixed_soundsV1.2/Mixed_soundsV1.2.tar.zst.part-005
+f97c88a2299f7f4bdc84fead4ccb9780a624edea71ad3254cf1d8077607de6db  ./Mixed_soundsV1.2/Mixed_soundsV1.2.tar.zst.part-006
+334a2e4cf6b99576e23ea99162c2319639e6fe87f3fa8679ace230714484aca4  ./Mixed_soundsV1.2/Mixed_soundsV1.2.tar.zst.part-007
+83a9fa687c1eddf6f6a6d8a063dd43631029e264089fba884864a4ecc98f2c1a  ./Mixed_soundsV1.2/Mixed_soundsV1.2.tar.zst.part-008
+dc56700012a8555111e6b2ed1f5a3e58ec18aacf1c40b8bc75b8b49c162048fd  ./Mixed_soundsV1.2/Mixed_soundsV1.2.tar.zst.part-009
+3801fddbec1dcd11bed4206b1d68d54ed81820d182904f99b61ce8e1fef0c4a2  ./Mixed_soundsV1.2/Mixed_soundsV1.2.tar.zst.part-010
+5114f28b49ebb5386b4e77fac0c72b14cc633f3f070c5b60397c1fdbc8716d0c  ./Partialspoof_background/Partialspoof_background.tar.zst.part-000
+bd4fe6003d09b8164b0655a4ffa82492e0b4f2112710751667a1933c6af3790c  ./Partialspoof_background/Partialspoof_background.tar.zst.part-001
+da4bb9a061cf18da50c6b00c5670ee9d3d3fb8ccedfdc413452955e6e77ad0ea  ./Partialspoof_background/Partialspoof_background.tar.zst.part-002
+95c708fa0adee20ba5e60e9a773dcbcba0c76511a67a55412e711ba193e7c85d  ./Partialspoof_background/Partialspoof_background.tar.zst.part-003
+bc3c1dedfc3ea00634286d6381abd1056b5bd15964536dba4d6154a8d3f9b4da  ./Partialspoof_background/Partialspoof_background.tar.zst.part-004

buildSBCori.py

@@ -0,0 +1,492 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+import argparse
+import math
+import re
+from pathlib import Path
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Tuple
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+import numpy as np
+import soundfile as sf
+
+
+AUDIO_EXTS = {".wav", ".flac", ".mp3", ".ogg", ".m4a"}
+
+BGCLIP_RE = re.compile(
+    r"(?P<sbc>SBC\d+)_bgclip_"
+    r"(?P<start>\d+(?:\.\d+)?)_"
+    r"(?P<end>\d+(?:\.\d+)?)_"
+    r"score(?P<score>[-+]?\d+(?:\.\d+)?)"
+)
+
+SBC_RE = re.compile(r"SBC\d+")
+
+
+@dataclass
+class Task:
+    split: str
+    target_id: str
+    out_name: str
+    sbc_id: str
+    start_sec: float
+    end_sec: float
+    ref_token: str
+
+
+def ensure_dir(p: Path) -> None:
+    p.mkdir(parents=True, exist_ok=True)
+
+
+def load_audio(path: Path) -> Tuple[np.ndarray, int]:
+    x, sr = sf.read(str(path), always_2d=False)
+    if x.ndim == 2:
+        x = x.mean(axis=1)
+    return x.astype(np.float32), int(sr)
+
+
+def save_audio(path: Path, x: np.ndarray, sr: int) -> None:
+    ensure_dir(path.parent)
+    x = np.asarray(x, dtype=np.float32)
+    sf.write(str(path), x, sr)
+
+
+def resample_audio(x: np.ndarray, orig_sr: int, target_sr: int) -> np.ndarray:
+    if orig_sr == target_sr:
+        return x.astype(np.float32)
+
+    try:
+        from scipy.signal import resample_poly
+
+        g = math.gcd(orig_sr, target_sr)
+        up = target_sr // g
+        down = orig_sr // g
+        y = resample_poly(x, up, down)
+        return y.astype(np.float32)
+
+    except Exception:
+        new_len = max(1, int(round(len(x) * float(target_sr) / float(orig_sr))))
+        old_pos = np.arange(len(x), dtype=np.float64)
+        new_pos = np.linspace(0, len(x) - 1, new_len, dtype=np.float64)
+        y = np.interp(new_pos, old_pos, x)
+        return y.astype(np.float32)
+
+
+def apply_fade(x: np.ndarray, sr: int, fade_sec: float) -> np.ndarray:
+    if fade_sec <= 0 or len(x) == 0:
+        return x
+
+    n = int(round(fade_sec * sr))
+    n = min(n, len(x) // 2)
+
+    if n <= 0:
+        return x
+
+    y = x.copy()
+    y[:n] *= np.linspace(0.0, 1.0, n, dtype=np.float32)
+    y[-n:] *= np.linspace(1.0, 0.0, n, dtype=np.float32)
+    return y
+
+
+def normalize_out_name(target_id: str) -> str:
+    name = Path(target_id.strip().strip("'\"")).name
+    if Path(name).suffix.lower() not in AUDIO_EXTS:
+        name += ".wav"
+    else:
+        name = Path(name).stem + ".wav"
+    return name
+
+
+def infer_split_from_path(p: Path) -> Optional[str]:
+    parts = [x.lower() for x in p.parts]
+    if "train" in parts:
+        return "train"
+    if "eval" in parts:
+        return "eval"
+    return None
+
+
+def resolve_reference_protocols(reference: Path) -> Dict[str, Path]:
+    reference = reference.resolve()
+    protocols = {}
+
+    if reference.is_file():
+        split = infer_split_from_path(reference)
+        if split is None:
+            raise ValueError(
+                "Cannot infer split from reference protocol path. "
+                "Please put it under train/ or eval/: %s" % reference
+            )
+        protocols[split] = reference
+        return protocols
+
+    candidates = {
+        "train": [
+            reference / "train" / "protocol.txt",
+            reference / "train_protocol.txt",
+            reference / "train.txt",
+        ],
+        "eval": [
+            reference / "eval" / "protocol.txt",
+            reference / "eval_protocol.txt",
+            reference / "eval.txt",
+        ],
+    }
+
+    for split in ["train", "eval"]:
+        for p in candidates[split]:
+            if p.exists():
+                protocols[split] = p
+                break
+
+    if not protocols:
+        raise FileNotFoundError(
+            "Cannot find train/eval protocol under reference path: %s" % reference
+        )
+
+    return protocols
+
+
+def parse_reference_protocol(protocol_path: Path, default_split: str) -> List[Task]:
+    """
+    Reference protocol example:
+
+        train_orig_0011153 orig train_05705_SBC036_bgclip_1211.00_1215.00_score19.3563.wav
+
+    第一列: 输出名 train_orig_0011153.wav
+    第二列: 必须是 orig
+    第三列或整行: 提供 SBCxxx + start/end
+    """
+    tasks = []
+
+    with open(protocol_path, "r", encoding="utf-8", errors="ignore") as f:
+        for line_no, line in enumerate(f, 1):
+            line = line.strip()
+
+            if not line or line.startswith("#"):
+                continue
+
+            parts = line.split()
+            if len(parts) < 3:
+                continue
+
+            lower = [x.lower() for x in parts]
+            if "utt_id" in lower or "filename" in lower or "source_id" in lower:
+                continue
+
+            target_id = parts[0].strip()
+            label = parts[1].lower().strip()
+
+            if label != "orig":
+                continue
+
+            if target_id.startswith("train_"):
+                split = "train"
+            elif target_id.startswith("eval_"):
+                split = "eval"
+            else:
+                split = default_split
+
+            match = None
+            ref_token = ""
+
+            for item in parts[2:]:
+                m = BGCLIP_RE.search(item)
+                if m:
+                    match = m
+                    ref_token = item
+                    break
+
+            if match is None:
+                m = BGCLIP_RE.search(line)
+                if m:
+                    match = m
+                    ref_token = line
+
+            if match is None:
+                continue
+
+            sbc_id = match.group("sbc")
+            start_sec = float(match.group("start"))
+            end_sec = float(match.group("end"))
+
+            if end_sec <= start_sec:
+                continue
+
+            tasks.append(
+                Task(
+                    split=split,
+                    target_id=target_id,
+                    out_name=normalize_out_name(target_id),
+                    sbc_id=sbc_id,
+                    start_sec=start_sec,
+                    end_sec=end_sec,
+                    ref_token=ref_token,
+                )
+            )
+
+    return tasks
+
+
+def build_source_index(input_dir: Path) -> Dict[str, List[Path]]:
+    """
+    Index raw SBC audio by SBC id.
+
+    Examples:
+        SBC036.wav -> SBC036
+        xxx_SBC036_yyy.wav -> SBC036
+    """
+    index = {}
+
+    for p in sorted(input_dir.rglob("*")):
+        if not p.is_file() or p.suffix.lower() not in AUDIO_EXTS:
+            continue
+
+        ids = SBC_RE.findall(p.stem)
+        for sbc_id in ids:
+            index.setdefault(sbc_id, []).append(p)
+
+    return index
+
+
+def choose_source(sbc_id: str, source_index: Dict[str, List[Path]]) -> Optional[Path]:
+    candidates = source_index.get(sbc_id, [])
+
+    if not candidates:
+        return None
+
+    exact = [p for p in candidates if p.stem == sbc_id]
+    if len(exact) == 1:
+        return exact[0]
+
+    if len(candidates) == 1:
+        return candidates[0]
+
+    return None
+
+
+def deduplicate_tasks(tasks: List[Task]) -> Tuple[List[Task], List[Task]]:
+    seen = set()
+    kept = []
+    dropped = []
+
+    for t in tasks:
+        key = (t.split, t.out_name)
+        if key in seen:
+            dropped.append(t)
+            continue
+        seen.add(key)
+        kept.append(t)
+
+    return kept, dropped
+
+
+def process_source_group(
+    sbc_id: str,
+    tasks: List[Task],
+    source_index: Dict[str, List[Path]],
+    mixed_sounds_dir: Path,
+    target_sr: int,
+    fade_sec: float,
+    overwrite: bool,
+):
+    source_path = choose_source(sbc_id, source_index)
+
+    if source_path is None:
+        candidates = source_index.get(sbc_id, [])
+        if not candidates:
+            return 0, 0, ["source not found: %s" % sbc_id]
+
+        example = " | ".join(str(p) for p in candidates[:8])
+        return 0, 0, ["ambiguous source for %s: %s" % (sbc_id, example)]
+
+    try:
+        x, sr = load_audio(source_path)
+    except Exception as e:
+        return 0, 0, ["failed to load %s: %s" % (source_path, e)]
+
+    made = 0
+    skipped = 0
+    failed = []
+
+    for task in tasks:
+        out_dir = mixed_sounds_dir / task.split / "wav"
+        ensure_dir(out_dir)
+
+        out_path = out_dir / task.out_name
+
+        if out_path.exists() and not overwrite:
+            skipped += 1
+            continue
+
+        start = int(round(task.start_sec * sr))
+        end = int(round(task.end_sec * sr))
+
+        if start < 0 or end > len(x) or end <= start:
+            duration = len(x) / float(sr)
+            failed.append(
+                "bad segment: %s %.2f-%.2f, source duration %.2f sec, target %s"
+                % (task.sbc_id, task.start_sec, task.end_sec, duration, task.out_name)
+            )
+            continue
+
+        try:
+            clip = x[start:end]
+            clip = resample_audio(clip, sr, target_sr)
+            clip = apply_fade(clip, target_sr, fade_sec)
+            save_audio(out_path, clip, target_sr)
+            made += 1
+        except Exception as e:
+            failed.append("failed task %s from %s: %s" % (task.out_name, source_path, e))
+
+    return made, skipped, failed
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description=(
+            "Cut raw SBC audio by reference Mixed_sounds protocol, "
+            "rename to train_orig/eval_orig ids, resample to 16k, "
+            "and inject wav files into target Mixed_sounds."
+        )
+    )
+
+    parser.add_argument(
+        "--input_dir",
+        type=str,
+        required=True,
+        help="Raw SBC audio root, e.g. /dkucc/home/zz324/Audiodata/WAV",
+    )
+    parser.add_argument(
+        "--mixed_sounds_dir",
+        type=str,
+        required=True,
+        help="Target Mixed_sounds directory to inject audio into.",
+    )
+    parser.add_argument(
+        "--reference",
+        type=str,
+        required=True,
+        help=(
+            "Reference protocol source. "
+            "Can be Mixed_soundsV1.2 root or a specific train/eval/protocol.txt."
+        ),
+    )
+
+    parser.add_argument("--target_sr", type=int, default=16000)
+    parser.add_argument("--fade_sec", type=float, default=0.5)
+    parser.add_argument("--num_workers", type=int, default=32)
+    parser.add_argument("--overwrite", action="store_true")
+
+    args = parser.parse_args()
+
+    input_dir = Path(args.input_dir).resolve()
+    mixed_sounds_dir = Path(args.mixed_sounds_dir).resolve()
+    reference = Path(args.reference).resolve()
+
+    ensure_dir(mixed_sounds_dir / "train" / "wav")
+    ensure_dir(mixed_sounds_dir / "eval" / "wav")
+
+    print("[INFO] input_dir        :", input_dir)
+    print("[INFO] mixed_sounds_dir :", mixed_sounds_dir)
+    print("[INFO] reference        :", reference)
+    print("[INFO] target_sr        :", args.target_sr)
+    print("[INFO] fade_sec         :", args.fade_sec)
+    print("[INFO] num_workers      :", args.num_workers)
+    print("[INFO] overwrite        :", args.overwrite)
+    print("[INFO] No new protocol will be generated.")
+    print("[INFO] Read reference protocol for BOTH renaming and cutting.")
+
+    protocols = resolve_reference_protocols(reference)
+
+    print("\n==================== Reference Protocols ====================")
+    for split, p in protocols.items():
+        print("[INFO] %s protocol: %s" % (split, p))
+
+    all_tasks = []
+
+    for split, protocol_path in protocols.items():
+        tasks = parse_reference_protocol(protocol_path, default_split=split)
+        all_tasks.extend(tasks)
+        print("[INFO] parsed %s tasks: %d" % (split, len(tasks)))
+
+    if not all_tasks:
+        print("[ERROR] No valid orig tasks found from reference protocol.")
+        return
+
+    all_tasks, dropped = deduplicate_tasks(all_tasks)
+
+    if dropped:
+        print("[WARN] duplicate output names in reference protocol:", len(dropped))
+        print("[WARN] duplicated tasks are skipped.")
+        for t in dropped[:20]:
+            print("  -", t.split, t.out_name, t.sbc_id, t.start_sec, t.end_sec)
+
+    print("\n==================== Source Index ====================")
+    source_index = build_source_index(input_dir)
+    print("[INFO] indexed SBC ids:", len(source_index))
+
+    grouped = {}
+    for task in all_tasks:
+        grouped.setdefault(task.sbc_id, []).append(task)
+
+    print("[INFO] task count     :", len(all_tasks))
+    print("[INFO] source groups  :", len(grouped))
+
+    total_made = 0
+    total_skipped = 0
+    all_failed = []
+
+    print("\n==================== Injecting Audio ====================")
+
+    with ThreadPoolExecutor(max_workers=args.num_workers) as ex:
+        futures = [
+            ex.submit(
+                process_source_group,
+                sbc_id,
+                tasks,
+                source_index,
+                mixed_sounds_dir,
+                args.target_sr,
+                args.fade_sec,
+                args.overwrite,
+            )
+            for sbc_id, tasks in grouped.items()
+        ]
+
+        for i, fut in enumerate(as_completed(futures), 1):
+            made, skipped, failed = fut.result()
+            total_made += made
+            total_skipped += skipped
+            all_failed.extend(failed)
+
+            if i % 10 == 0 or i == len(futures):
+                print(
+                    "[INFO] processed groups %d/%d | injected=%d | skipped=%d | failed=%d"
+                    % (i, len(futures), total_made, total_skipped, len(all_failed))
+                )
+
+    print("\n==================== Done ====================")
+    print("Reference tasks      :", len(all_tasks))
+    print("Injected audio files :", total_made)
+    print("Skipped existing     :", total_skipped)
+    print("Failed tasks         :", len(all_failed))
+    print("Train wav dir        :", mixed_sounds_dir / "train" / "wav")
+    print("Eval wav dir         :", mixed_sounds_dir / "eval" / "wav")
+
+    if all_failed:
+        failed_path = mixed_sounds_dir / "inject_failed.txt"
+        with open(failed_path, "w", encoding="utf-8") as f:
+            for x in all_failed:
+                f.write(x + "\n")
+
+        print("[WARN] Failed details saved to:", failed_path)
+        print("\nFirst failed examples:")
+        for x in all_failed[:20]:
+            print("  -", x)
+
+
+if __name__ == "__main__":
+    main()

extract_orig_from_mixed_protocol.py

@@ -0,0 +1,272 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+import argparse
+from pathlib import Path
+
+AUDIO_EXTS = [".wav", ".flac", ".mp3", ".ogg", ".m4a"]
+
+
+def is_audio_name(x: str) -> bool:
+    return Path(x).suffix.lower() in AUDIO_EXTS
+
+
+def is_sbc_source(x: str) -> bool:
+    """
+    第三列来源文件是否是 SBC 切片。
+    例如：
+        train_02263_SBC023_bgclip_1123.00_1127.00_score54.7008.wav
+    """
+    name = Path(x).name
+    return "SBC" in name and is_audio_name(name)
+
+
+def parse_protocol(protocol_path: Path):
+    """
+    返回所有 label == orig 的行，并标记第三列是否是 SBC 来源。
+    兼容格式：
+        train_orig_0007711 orig train_02263_SBC023_bgclip_1123.00_1127.00_score54.7008.wav
+    """
+    orig_rows = []
+
+    with open(protocol_path, "r", encoding="utf-8", errors="ignore") as f:
+        for line_no, line in enumerate(f, 1):
+            line = line.strip()
+
+            if not line or line.startswith("#"):
+                continue
+
+            parts = line.split()
+            if len(parts) < 2:
+                continue
+
+            utt_id = parts[0]
+            label = parts[1]
+
+            # 跳过表头
+            if utt_id.lower() in {"utt_id", "id"} or label.lower() == "label":
+                continue
+
+            if label != "orig":
+                continue
+
+            src = parts[2] if len(parts) >= 3 else ""
+
+            orig_rows.append({
+                "line_no": line_no,
+                "utt_id": utt_id,
+                "src": Path(src).name if src else "",
+                "is_sbc": is_sbc_source(src),
+            })
+
+    return orig_rows
+
+
+def find_target_file(wav_dir: Path, utt_id: str):
+    """
+    要删的是第一列 utt_id 对应的音频：
+        train_orig_0007711 -> train_orig_0007711.wav
+    """
+    for ext in AUDIO_EXTS:
+        p = wav_dir / f"{utt_id}{ext}"
+        if p.exists():
+            return p
+    return None
+
+
+def process_split(mixed_dir: Path, split: str, do_delete: bool):
+    split_dir = mixed_dir / split
+    wav_dir = split_dir / "wav"
+    protocol_path = split_dir / "protocol.txt"
+
+    result = {
+        "split": split,
+        "total_orig_rows": 0,
+        "sbc_orig_rows": 0,
+        "non_sbc_orig_rows": 0,
+        "existing_delete_files": 0,
+        "missing_delete_files": 0,
+        "deleted_files": 0,
+        "delete_targets": [],
+        "missing_targets": [],
+        "non_sbc_orig": [],
+    }
+
+    if not protocol_path.exists():
+        print(f"[WARN] Missing protocol: {protocol_path}")
+        return result
+
+    if not wav_dir.exists():
+        print(f"[WARN] Missing wav dir: {wav_dir}")
+        return result
+
+    orig_rows = parse_protocol(protocol_path)
+
+    result["total_orig_rows"] = len(orig_rows)
+
+    for r in orig_rows:
+        if not r["is_sbc"]:
+            result["non_sbc_orig_rows"] += 1
+            result["non_sbc_orig"].append(r)
+            continue
+
+        result["sbc_orig_rows"] += 1
+
+        target = find_target_file(wav_dir, r["utt_id"])
+
+        if target is None:
+            result["missing_delete_files"] += 1
+            result["missing_targets"].append(r)
+            continue
+
+        result["existing_delete_files"] += 1
+        result["delete_targets"].append({
+            **r,
+            "target": target,
+        })
+
+        if do_delete:
+            target.unlink()
+            result["deleted_files"] += 1
+
+    return result
+
+
+def write_reports(report_dir: Path, mixed_dir: Path, results):
+    report_dir.mkdir(parents=True, exist_ok=True)
+
+    summary_path = report_dir / "summary.txt"
+
+    with open(summary_path, "w", encoding="utf-8") as f:
+        f.write(
+            "split total_orig sbc_orig non_sbc_orig "
+            "existing_to_delete missing_to_delete deleted\n"
+        )
+
+        for r in results:
+            f.write(
+                f"{r['split']} "
+                f"{r['total_orig_rows']} "
+                f"{r['sbc_orig_rows']} "
+                f"{r['non_sbc_orig_rows']} "
+                f"{r['existing_delete_files']} "
+                f"{r['missing_delete_files']} "
+                f"{r['deleted_files']}\n"
+            )
+
+        f.write("\n")
+
+        f.write(
+            f"TOTAL "
+            f"{sum(r['total_orig_rows'] for r in results)} "
+            f"{sum(r['sbc_orig_rows'] for r in results)} "
+            f"{sum(r['non_sbc_orig_rows'] for r in results)} "
+            f"{sum(r['existing_delete_files'] for r in results)} "
+            f"{sum(r['missing_delete_files'] for r in results)} "
+            f"{sum(r['deleted_files'] for r in results)}\n"
+        )
+
+    for r in results:
+        split = r["split"]
+
+        with open(report_dir / f"{split}_delete_targets.txt", "w", encoding="utf-8") as f:
+            f.write("line_no utt_id src_sbc target_file\n")
+            for x in r["delete_targets"]:
+                rel = x["target"].relative_to(mixed_dir)
+                f.write(f"{x['line_no']} {x['utt_id']} {x['src']} {rel}\n")
+
+        with open(report_dir / f"{split}_missing_targets.txt", "w", encoding="utf-8") as f:
+            f.write("line_no utt_id src_sbc expected_file\n")
+            for x in r["missing_targets"]:
+                f.write(f"{x['line_no']} {x['utt_id']} {x['src']} {split}/wav/{x['utt_id']}.wav\n")
+
+        with open(report_dir / f"{split}_non_sbc_orig_kept.txt", "w", encoding="utf-8") as f:
+            f.write("line_no utt_id src\n")
+            for x in r["non_sbc_orig"]:
+                f.write(f"{x['line_no']} {x['utt_id']} {x['src']}\n")
+
+
+def print_summary(results, do_delete: bool, report_dir: Path):
+    print("\n==================== Summary ====================")
+    print(f"Mode       : {'DELETE' if do_delete else 'DRY-RUN'}")
+    print(f"Report dir : {report_dir}")
+
+    total_orig = 0
+    total_sbc = 0
+    total_non_sbc = 0
+    total_existing = 0
+    total_missing = 0
+    total_deleted = 0
+
+    for r in results:
+        total_orig += r["total_orig_rows"]
+        total_sbc += r["sbc_orig_rows"]
+        total_non_sbc += r["non_sbc_orig_rows"]
+        total_existing += r["existing_delete_files"]
+        total_missing += r["missing_delete_files"]
+        total_deleted += r["deleted_files"]
+
+        print(f"\n[{r['split']}]")
+        print(f"  Total orig rows              : {r['total_orig_rows']}")
+        print(f"  SBC-corresponding orig rows  : {r['sbc_orig_rows']}")
+        print(f"  Non-SBC orig rows kept       : {r['non_sbc_orig_rows']}")
+        print(f"  Existing files to delete     : {r['existing_delete_files']}")
+        print(f"  Missing target files         : {r['missing_delete_files']}")
+        print(f"  Deleted files                : {r['deleted_files']}")
+
+    print("\n[TOTAL]")
+    print(f"  Total orig rows              : {total_orig}")
+    print(f"  SBC-corresponding orig rows  : {total_sbc}")
+    print(f"  Non-SBC orig rows kept       : {total_non_sbc}")
+    print(f"  Existing files to delete     : {total_existing}")
+    print(f"  Missing target files         : {total_missing}")
+    print(f"  Deleted files                : {total_deleted}")
+
+    if total_orig > 0:
+        ratio = total_sbc / total_orig * 100
+        print(f"  SBC-orig ratio               : {ratio:.2f}%")
+
+    if not do_delete:
+        print("\n[DRY-RUN] 没有真正删除。确认 existing files to delete 数量正确后，加 --delete 再运行。")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Compare total orig rows with SBC-corresponding orig rows, then delete only those orig wavs."
+    )
+
+    parser.add_argument(
+        "--mixed_sounds_dir",
+        type=str,
+        required=True,
+        help="Path to Mixed_sounds directory.",
+    )
+
+    parser.add_argument(
+        "--delete",
+        action="store_true",
+        help="Actually delete files. Default is dry-run.",
+    )
+
+    args = parser.parse_args()
+
+    mixed_dir = Path(args.mixed_sounds_dir).resolve()
+    report_dir = mixed_dir / "delete_sbc_orig_compare_report"
+
+    results = []
+
+    for split in ["train", "eval"]:
+        results.append(
+            process_split(
+                mixed_dir=mixed_dir,
+                split=split,
+                do_delete=args.delete,
+            )
+        )
+
+    write_reports(report_dir, mixed_dir, results)
+    print_summary(results, args.delete, report_dir)
+
+
+if __name__ == "__main__":
+    main()