186 |
187 |
188 |
--------------------------------------------------------------------------------
/main.js:
--------------------------------------------------------------------------------
1 | (function () {
2 |
3 | addEventListener("load", () => {
4 | initializeUI();
5 | });
6 |
7 | addEventListener("unload", () => {
8 | terminateAudio();
9 | terminateUI();
10 | });
11 |
12 | // UI関連
13 |
14 | // ファイルオープンボタン
15 | let openFileButton;
16 | // すでに圧縮済みのファイルであることの表示
17 | let alreadyCompressedDataLabel;
18 | // チャネル数選択
19 | let channelSizeSelector;
20 | // サンプルレート選択
21 | let sampleRateSelector;
22 | // 周波数レンジ選択
23 | let frequencyRangeSelector;
24 | // MDCT処理レンジ選択
25 | let frequencyUpperLimitSelector;
26 | // 周波数テーブル選択
27 | let frequencyTableSizeSelector;
28 | // 圧縮後のビットレート
29 | let compressedBitRateLabel;
30 | // エンコーディングの進捗率
31 | let encodingRateLabel;
32 | // 圧縮ボタン
33 | let compressButton;
34 | // 再生ボタン
35 | let playButton;
36 | // ダウンロードボタン
37 | let downloadButton;
38 |
39 | // UI関連を初期化
40 | function initializeUI() {
41 | openFileButton = document.getElementById("openFileButton");
42 | openFileButton.addEventListener("change", onChangedSourceFile);
43 | alreadyCompressedDataLabel = document.getElementById("alreadyCompressedDataLabel");
44 | alreadyCompressedDataLabel.style.display = "none";
45 | channelSizeSelector = document.getElementById("channelSizeSelector");
46 | channelSizeSelector.addEventListener("change", onChangedChannelSize);
47 | sampleRateSelector = document.getElementById("sampleRateSelector");
48 | sampleRateSelector.addEventListener("change", onChangedSampleRate);
49 | frequencyRangeSelector = document.getElementById("frequencyRangeSelector");
50 | frequencyRangeSelector.addEventListener("change", onChangedFrequencyRange);
51 | frequencyUpperLimitSelector = document.getElementById("frequencyUpperLimitSelector");
52 | frequencyUpperLimitSelector.addEventListener("change", onChangedFrequencyUpperLimit);
53 | frequencyTableSizeSelector = document.getElementById("frequencyTableSizeSelector");
54 | frequencyTableSizeSelector.addEventListener("change", onChangedFrequencyTableSize);
55 | compressedBitRateLabel = document.getElementById("compressedBitRateLabel");
56 | encodingRateLabel = document.getElementById("encodingRateLabel");
57 | compressButton = document.getElementById("compressButton");
58 | compressButton.addEventListener("click", onClickedCompressButton);
59 | compressButton.disabled = "disabled";
60 | playButton = document.getElementById("playButton");
61 | playButton.addEventListener("click", onClickedPlayButton);
62 | playButton.disabled = "disabled";
63 | downloadButton = document.getElementById("downloadButton");
64 | downloadButton.style.visibility = "hidden";
65 | updateBitRateOfCompressedAudio();
66 | }
67 |
68 | // UI関連の後処理
69 | function terminateUI() {
70 | openFileButton.removeEventListener("change", onChangedSourceFile);
71 | channelSizeSelector.removeEventListener("change", onChangedChannelSize);
72 | sampleRateSelector.removeEventListener("change", onChangedSampleRate);
73 | frequencyRangeSelector.removeEventListener("change", onChangedFrequencyRange);
74 | frequencyTableSizeSelector.removeEventListener("change", onChangedFrequencyTableSize);
75 | compressButton.removeEventListener("click", onClickedCompressButton);
76 | playButton.removeEventListener("click", onClickedPlayButton);
77 | }
78 |
79 | // 入力ファイルが変更
80 | function onChangedSourceFile(event) {
81 | console.log("Changed the source file");
82 |
83 | playButton.disabled = "disabled";
84 | compressButton.disabled = "disabled";
85 | encodingRateLabel.textContent = "0%";
86 | playButton.disabled = "disabled";
87 | downloadButton.style.visibility = "hidden";
88 |
89 | if (isInitializedAudio()) {
90 | pauseAudio();
91 | initializeAudio();
92 | }
93 |
94 | originalFile = event.target.files[0];
95 |
96 | // 圧縮済みデータかをチェックする
97 | let fileReader = new FileReader();
98 | fileReader.addEventListener("loadend", (event) => {
99 | if (wamCodec.WamDcoder.isWamData(fileReader.result)) {
100 | makeCompressedAudioNode(fileReader.result);
101 | alreadyCompressedDataLabel.style.display = "inline";
102 | playButton.disabled = "";
103 | } else {
104 | alreadyCompressedDataLabel.style.display = "none";
105 | compressButton.disabled = "";
106 | }
107 | });
108 | fileReader.readAsArrayBuffer(originalFile);
109 | }
110 |
111 | // チャネル数が変更
112 | function onChangedChannelSize(event) {
113 | let value = this.options[this.selectedIndex].value;
114 | console.log(`Changed the channel count from ${channelSize} to ${value}.`);
115 | channelSize = Number.parseFloat(value);
116 | updateBitRateOfCompressedAudio();
117 | }
118 |
119 | // サンプルレートが変更
120 | function onChangedSampleRate(event) {
121 | let value = this.options[this.selectedIndex].value;
122 | console.log(`Changed the sample rate from ${sampleRate} to ${value}.`);
123 | sampleRate = Number.parseFloat(value);
124 | updateBitRateOfCompressedAudio();
125 | }
126 |
127 | // 周波数レンジが変更
128 | function onChangedFrequencyRange(event) {
129 | let value = this.options[this.selectedIndex].value;
130 | console.log(`Changed the frequency range from ${frequencyRange} to ${value}.`);
131 | frequencyRange = Number.parseFloat(value);
132 | updateFrequencyUpperLimit();
133 | updateFrequencyTableSize();
134 | updateBitRateOfCompressedAudio();
135 | }
136 |
137 | // 周波数の上限が変更
138 | function onChangedFrequencyUpperLimit(event) {
139 | let value = frequencyUpperLimit;
140 | updateFrequencyUpperLimit();
141 | updateBitRateOfCompressedAudio();
142 | console.log(`Changed the frequency upper limit from ${value} to ${frequencyUpperLimit}.`);
143 | }
144 |
145 | // 周波数テーブルサイズが変更
146 | function onChangedFrequencyTableSize(event) {
147 | let prev = frequencyTableSize;
148 | updateFrequencyTableSize();
149 | updateBitRateOfCompressedAudio();
150 | console.log(`Changed the frequency table size from ${prev} to ${frequencyTableSize}.`);
151 | }
152 |
153 | // 周波数の上限を更新
154 | function updateFrequencyUpperLimit() {
155 | frequencyUpperLimit =
156 | frequencyRange *
157 | Number.parseFloat(frequencyUpperLimitSelector.options[frequencyUpperLimitSelector.selectedIndex].value) / 8;
158 | }
159 |
160 | // 周波数テーブルサイズの更新
161 | function updateFrequencyTableSize() {
162 | frequencyTableSize =
163 | FREQUENCY_TABLE_SIZES[frequencyTableSizeSelector.selectedIndex] * frequencyRange / DEFAULT_FREQUENCY_RANGE;
164 | for (let i = 0; i < FREQUENCY_TABLE_SIZES.length; ++i) {
165 | frequencyTableSizeSelector.options[i].text =
166 | `${Math.round(FREQUENCY_TABLE_SIZES[i] * frequencyRange / DEFAULT_FREQUENCY_RANGE)}`;
167 | }
168 | }
169 |
170 | // 圧縮後のビットレート
171 | function updateBitRateOfCompressedAudio() {
172 | // (主音量 + 副音量(8チャネル) + 周波数フラグ + 周波数テーブル) * チャネル数
173 | let frameSize = 32 + 32
174 | + (Math.min(
175 | 1 * frequencyUpperLimit,
176 | Math.ceil(Math.ceil(Math.log2(frequencyUpperLimit)) * frequencyTableSize / 32) * 32)
177 | + 4 * frequencyTableSize)
178 | * channelSize;
179 | compressedBitRateLabel.textContent = `${Math.round(frameSize * sampleRate / frequencyRange / 1000)} kbps`;
180 | }
181 |
182 | // 圧縮ボタンがクリックされた
183 | function onClickedCompressButton(event) {
184 | console.log("Clicked the compress button.");
185 |
186 | compressButton.disabled = "disabled";
187 | playButton.disabled = "disabled";
188 | downloadButton.style.visibility = "hidden";
189 |
190 | pauseAudio();
191 | terminateAudio();
192 | initializeAudio();
193 |
194 | // ファイルの読み込み
195 | let fileReader = new FileReader();
196 | fileReader.addEventListener("loadend", (event) => {
197 | try {
198 | audioContext.decodeAudioData(fileReader.result, (audioBuffer) => {
199 | encodeAudioData(audioBuffer).then((encodedBuffer) => {
200 | makeDownloadLink(encodedBuffer);
201 | makeCompressedAudioNode(encodedBuffer);
202 | compressButton.disabled = "";
203 | playButton.disabled = "";
204 | }).catch((error) => {
205 | compressButton.disabled = "";
206 | });
207 | });
208 | } catch (error) {
209 | compressButton.disabled = "";
210 | }
211 |
212 | });
213 | fileReader.readAsArrayBuffer(originalFile);
214 | }
215 |
216 | // エンコーディング
217 | function encodeAudioData(audioBuffer) {
218 | return new Promise((resolve, reject) => {
219 | // サンプルを配列に詰め直し
220 | let sampleData = new Array(audioBuffer.numberOfChannels);
221 | for (let i = 0; i < sampleData.length; ++i) {
222 | sampleData[i] = audioBuffer.getChannelData(i);
223 | }
224 |
225 | // WebWorkerでエンコードを実行
226 | let worker = new Worker("compress.js");
227 | worker.addEventListener('message', (message) => {
228 | switch (message.data["kind"]) {
229 | case "update":
230 | encodingRateLabel.textContent = `${Math.ceil(message.data["progress"] * 100)} %`;
231 | break;
232 | case "completed": {
233 | resolve(message.data["encodedBuffer"]);
234 | worker.terminate();
235 | break;
236 | }
237 | case "failed":
238 | default:
239 | reject(new Error("Failed to encoding"));
240 | worker.terminate();
241 | break;
242 | }
243 | });
244 | worker.postMessage({
245 | "numChannels": channelSize,
246 | "sampleRate": sampleRate,
247 | "frequencyRange": frequencyRange,
248 | "frequencyUpperLimit": frequencyUpperLimit,
249 | "frequencyTableSize": frequencyTableSize,
250 | "originalSampleRate": audioBuffer.sampleRate,
251 | "originalChannelSize": audioBuffer.numberOfChannels,
252 | "originalSampleData": sampleData
253 | }, sampleData.map((value => value.buffer)));
254 | });
255 | }
256 |
257 | // ダウンロード用のリンクを作成
258 | function makeDownloadLink(buffer) {
259 | let blob = new Blob([buffer], {type: "application/octet-binary"});
260 | downloadButton.href = window.URL.createObjectURL(blob);
261 | downloadButton.download = `${(originalFile.name.indexOf(".") != -1 ?
262 | originalFile.name.substring(0, originalFile.name.indexOf(".")) :
263 | originalFile.name)}.orp`;
264 | downloadButton.style.visibility = "visible";
265 | }
266 |
267 | // 再生ボタンがクリックされた
268 | function onClickedPlayButton(event) {
269 | console.log("Clicked the play button.");
270 | if (!isPlayAudio()) {
271 | playAudio()
272 | } else {
273 | pauseAudio();
274 | }
275 | }
276 |
277 | // 音声関連
278 |
279 | // テーブルサイズマップ
280 | const FREQUENCY_TABLE_SIZES = [
281 | 8,
282 | 12,
283 | 16,
284 | 24,
285 | 32,
286 | 48,
287 | 64,
288 | 96,
289 | 128,
290 | 192,
291 | 256,
292 | 384,
293 | 512,
294 | ];
295 |
296 | // デフォルト、サンプリングレート
297 | const DEFAULT_SAMPLE_RATE = 48000;
298 | // デフォルト、チャネル数
299 | const DEFAULT_CHANNEL_SIZE = 2;
300 | // デフォルト、周波数レンジ
301 | const DEFAULT_FREQUENCY_RANGE = 1024;
302 | // デフォルト、周波数の上限
303 | const DEFAULT_FREQUENCY_UPPER_LIMIT = DEFAULT_FREQUENCY_RANGE * 6 / 8;
304 | // デフォルト、周波数テーブルサイズ
305 | const DEFAULT_FREQUENCY_TABLE_SIZE = 192;
306 |
307 | // サンプリングレート
308 | let sampleRate = DEFAULT_SAMPLE_RATE;
309 | // チャネル数
310 | let channelSize = DEFAULT_CHANNEL_SIZE;
311 | // 周波数レンジ
312 | let frequencyRange = DEFAULT_FREQUENCY_RANGE;
313 | // 周波数の上限
314 | let frequencyUpperLimit = DEFAULT_FREQUENCY_UPPER_LIMIT;
315 | // 周波数テーブルサイズ
316 | let frequencyTableSize = DEFAULT_FREQUENCY_TABLE_SIZE;
317 |
318 | // 入力元のファイル名
319 | let originalFile = null;
320 | // AudioContextのインスタンス
321 | let audioContext = null;
322 | // 再生用のAudioSource
323 | let audioSource = null;
324 | // 圧縮処理済みのAudioNode
325 | let compressedAudioNode = null;
326 |
327 | // Audioは初期化済みか
328 | function isInitializedAudio() {
329 | return audioContext != null;
330 | }
331 |
332 | // Audioの初期化
333 | function initializeAudio(sampleRate = 48000) {
334 | if (isInitializedAudio()) {
335 | return;
336 | }
337 | try {
338 | audioContext = window.AudioContext != null ?
339 | new window.AudioContext({"sampleRate": sampleRate}) :
340 | new window.webkitAudioContext();
341 | } catch (e) {
342 | console.error(e);
343 | }
344 | }
345 |
346 | // Audioの後処理
347 | function terminateAudio() {
348 | if (!isInitializedAudio()) {
349 | return;
350 | }
351 | pauseAudio();
352 | audioContext = null;
353 | }
354 |
355 | // 圧縮されたデータ再生用のAudioNodeを作成
356 | function makeCompressedAudioNode(buffer) {
357 | let decoder = new wamCodec.WamDcoder(buffer);
358 | terminateAudio();
359 | initializeAudio(decoder.sampleRate);
360 | compressedAudioNode = audioContext.createScriptProcessor(4096, decoder.numChannels, decoder.numChannels);
361 | compressedAudioNode.addEventListener("audioprocess", (event) => {
362 | let sampleData = new Array(event.outputBuffer.numberOfChannels);
363 | for (let i = 0; i < sampleData.length; ++i) {
364 | sampleData[i] = event.outputBuffer.getChannelData(i);
365 | }
366 |
367 | // デコード
368 | let sampleTimes = audioContext.sampleRate / decoder.sampleRate;
369 | let sampleCount = Math.floor(event.outputBuffer.length / sampleTimes);
370 | decoder.read(sampleData, 0, sampleCount);
371 |
372 | // AudioContextとサンプリングレートが合わない場合は修正
373 | if (sampleTimes > 1) {
374 | for (let i = 0; i < decoder.numChannels; ++i) {
375 | let samples = sampleData[i];
376 | for (let j = sampleCount - 1; j >= 0; --j) {
377 | let sample = samples[j];
378 | for (let k = Math.floor(j * sampleTimes); k < Math.floor(j * sampleTimes) + sampleTimes; ++k) {
379 | samples[k] = sample;
380 | }
381 | }
382 | }
383 | }
384 | });
385 | }
386 |
387 | // 再生中か否か
388 | function isPlayAudio() {
389 | return isInitializedAudio() && audioSource != null;
390 | }
391 |
392 | // 再生を行う
393 | function playAudio() {
394 | if (compressedAudioNode != null && isPlayAudio()) {
395 | return;
396 | }
397 | audioSource = audioContext.createBufferSource();
398 | audioSource.connect(compressedAudioNode);
399 | compressedAudioNode.connect(audioContext.destination);
400 | audioSource.start();
401 | }
402 |
403 | // 再生を中断する
404 | function pauseAudio() {
405 | if (!isPlayAudio()) {
406 | return;
407 | }
408 | compressedAudioNode.disconnect(audioContext.destination);
409 | audioSource.disconnect(compressedAudioNode);
410 | audioSource = null;
411 | }
412 |
413 | })();
414 |
415 |
--------------------------------------------------------------------------------
/signal.js:
--------------------------------------------------------------------------------
1 | // 信号処理用のユーティリティ
2 |
3 | /**
4 | * 高速離散フーリエ変換用のクラス
5 | *
6 | * アルゴリズムは Cooly and Tukey
7 | *
8 | * 参考
9 | * https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm#The_radix-2_DIT_case
10 | *
11 | * y[2k] = Σ[N-1,j=0] (x[j] + x[N/2 + j]) e^((-2πijk) / (N/2))
12 | * y[2k-1] = Σ[N-1,j=0] ((x[j] - x[N/2 + j]) e^(-2πik / N)) e^((-2πijk) / (N/2))
13 | *
14 | * N - データ数
15 | * x - サンプリング配列
16 | * y - 周波数配列
17 | * j - サンプリング配列の添字 (時間)
18 | * k - 周波数配列への添字 (周波数)
19 | * i - 単位虚数
20 | */
21 | class FastDFT {
22 |
23 | // 要素を入れ替える
24 | static swap(v, a, b) {
25 | let ar = v[a + 0];
26 | let ai = v[a + 1];
27 | v[a + 0] = v[b + 0];
28 | v[a + 1] = v[b + 1];
29 | v[b + 0] = ar;
30 | v[b + 1] = ai;
31 | }
32 |
33 | // 離散フーリエ変換
34 | // n - サンプル数、2のべき乗である必要がある
35 | // x - 変換対象のサンプル配列、実数と虚数のn個の複素数配列
36 | // inv - 逆変換か否か
37 | static dft(n, x, inv) {
38 | inv = inv == null ? false : inv;
39 |
40 | let rad = (inv ? 2.0 : -2.0) * Math.PI / n;
41 | let cs = Math.cos(rad), sn = Math.sin(rad); // 回転因子の回転用複素数
42 |
43 | for (let m = (n <<= 1), mh; 2 <= (mh = m >>> 1); m = mh) {
44 | // 回転因子が0°の箇所を処理
45 | for (let i = 0; i < n; i += m) {
46 | let j = i + mh;
47 | let ar = x[i + 0], ai = x[i + 1];
48 | let br = x[j + 0], bi = x[j + 1];
49 |
50 | // 前半 (a + b)
51 | x[i + 0] = ar + br;
52 | x[i + 1] = ai + bi;
53 |
54 | // 後半 (a - b)
55 | x[j + 0] = ar - br;
56 | x[j + 1] = ai - bi;
57 | }
58 |
59 | // 回転因子が0°以外の箇所を処理
60 | let wcs = cs, wsn = sn; // 回転因子
61 |
62 | for (let i = 2; i < mh; i += 2) {
63 | for (let j = i; j < n; j += m) {
64 | let k = j + mh;
65 | let ar = x[j + 0], ai = x[j + 1];
66 | let br = x[k + 0], bi = x[k + 1];
67 |
68 | // 前半 (a + b)
69 | x[j + 0] = ar + br;
70 | x[j + 1] = ai + bi;
71 |
72 | // 後半 (a - b) * w
73 | let xr = ar - br;
74 | let xi = ai - bi;
75 | x[k + 0] = xr * wcs - xi * wsn;
76 | x[k + 1] = xr * wsn + xi * wcs;
77 | }
78 |
79 | // 回転因子を回転
80 | let tcs = wcs * cs - wsn * sn;
81 | wsn = wcs * sn + wsn * cs;
82 | wcs = tcs;
83 | }
84 |
85 | // 回転因子の回転用の複素数を自乗して回転
86 | let tcs = cs * cs - sn * sn;
87 | sn = 2.0 * (cs * sn);
88 | cs = tcs;
89 | }
90 |
91 | let m = n >>> 1;
92 | let m2 = m + 2;
93 | let mh = n >>> 2;
94 | for (let i = 0, j = 0; i < m; i += 4) {
95 | // データの入れ替え
96 | FastDFT.swap(x, i + m, j + 2);
97 | if (i < j) {
98 | FastDFT.swap(x, i + m2, j + m2);
99 | FastDFT.swap(x, i, j);
100 | }
101 |
102 | // ビットオーダを反転した変数としてインクリメント
103 | for (let k = mh; (j ^= k) < k; k >>= 1) {
104 | }
105 | }
106 |
107 | // 逆変換用のスケーリング
108 | if (inv) {
109 | for (let i = 0; i < n; ++i) {
110 | x[i] /= n;
111 | }
112 | }
113 | }
114 | }
115 |
116 | /**
117 | * 高速離散コサイン変換用のクラス、タイプIIとタイプIIIを備える
118 | *
119 | * アルゴリズムは Byeong Gi Lee
120 | *
121 | * 参考
122 | * https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.118.3056&rep=rep1&type=pdf#page=34
123 | * https://pdfs.semanticscholar.org/ed00/5160f5befd45073fd01b697227d009cad919.pdf
124 | *
125 | * DCT-IIの数式、DCT-IIIはこれの逆順で実装
126 | * y[2k] = Σ[n/2,m=0] (x[m]+x[n/2-1-m]) cos(π(2m+1)k/n)
127 | * y[2k-1] + y[2k+1] = Σ[n/2,m=0] (x[m]-x[n/2-1-m]) 2cos(π(2m+1)/2n) cos(π(m+1)k/n)
128 | *
129 | * N - データ数
130 | * x - サンプリング配列
131 | * y - 周波数配列
132 | * j - サンプリング配列の添字 (時間)
133 | * k - 周波数配列への添字 (周波数)
134 | */
135 | class FastDCT {
136 |
137 | // 要素を入れ替える
138 | static swap(v, a, b) {
139 | let t = v[a];
140 | v[a] = v[b];
141 | v[b] = t;
142 | }
143 |
144 | // 要素配列の並び替え
145 | static swapElements(n, x) {
146 | let nh = n >> 1;
147 | let nh1 = nh + 1;
148 | let nq = n >> 2;
149 | for (let i = 0, j = 0; i < nh; i += 2) {
150 | FastDCT.swap(x, i + nh, j + 1);
151 | if (i < j) {
152 | FastDCT.swap(x, i + nh1, j + nh1);
153 | FastDCT.swap(x, i, j);
154 | }
155 |
156 | // ビットオーダを反転した変数としてインクリメント
157 | for (let k = nq; (j ^= k) < k; k >>= 1) {
158 | }
159 | }
160 | }
161 |
162 | // 離散コサイン変換、タイプII
163 | // n - サンプル数、2のべき乗である必要がある
164 | // x - n個のサンプルの配列
165 | static dctII(n, x) {
166 | // バタフライ演算
167 | let rad = Math.PI / (n << 1);
168 | for (let m = n, mh = m >> 1; 1 < m; m = mh, mh >>= 1) {
169 | for (let i = 0; i < mh; ++i) {
170 | let cs = 2.0 * Math.cos(rad * ((i << 1) + 1));
171 | for (let j = i, k = (m - 1) - i; j < n; j += m, k += m) {
172 | let x0 = x[j];
173 | let x1 = x[k];
174 | x[j] = x0 + x1;
175 | x[k] = (x0 - x1) * cs;
176 | }
177 | }
178 | rad *= 2.0;
179 | }
180 |
181 | // データの入れ替え
182 | FastDCT.swapElements(n, x);
183 |
184 | // 差分方程式
185 | for (let m = n, mh = m >> 1, mq = mh >> 1; 2 < m; m = mh, mh = mq, mq >>= 1) {
186 | for (let i = mq + mh; i < m; ++i) {
187 | let xt = (x[i] = -x[i] - x[i - mh]);
188 | for (let j = i + mh; j < n; j += m) {
189 | let k = j + mh;
190 | xt = (x[j] -= xt);
191 | xt = (x[k] = -x[k] - xt);
192 | }
193 | }
194 | }
195 |
196 | // スケーリング
197 | for (let i = 1; i < n; ++i) {
198 | x[i] *= 0.5;
199 | }
200 | }
201 |
202 | // 離散コサイン変換、タイプIII
203 | // n - サンプル数、2のべき乗である必要がある
204 | // x - n個のサンプルの配列
205 | static dctIII(n, x) {
206 | // スケーリング
207 | x[0] *= 0.5;
208 |
209 | // 差分方程式
210 | for (let m = 4, mh = 2, mq = 1; m <= n; mq = mh, mh = m, m <<= 1) {
211 | for (let i = n - mq; i < n; ++i) {
212 | let j = i;
213 | while (m < j) {
214 | let k = j - mh;
215 | x[j] = -x[j] - x[k];
216 | x[k] += x[j = k - mh];
217 | }
218 | x[j] = -x[j] - x[j - mh];
219 | }
220 | }
221 |
222 | // データの入れ替え
223 | FastDCT.swapElements(n, x);
224 |
225 | // バタフライ演算
226 | let rad = Math.PI / 2.0;
227 | for (let m = 2, mh = 1; m <= n; mh = m, m <<= 1) {
228 | rad *= 0.5;
229 | for (let i = 0; i < mh; ++i) {
230 | let cs = 2.0 * Math.cos(rad * ((i << 1) + 1));
231 | for (let j = i, k = (m - 1) - i; j < n; j += m, k += m) {
232 | let x0 = x[j];
233 | let x1 = x[k] / cs;
234 | x[j] = x0 + x1;
235 | x[k] = x0 - x1;
236 | }
237 | }
238 | }
239 | }
240 | }
241 |
242 | /**
243 | * 高速修正離散コサイン変換用のクラス
244 | *
245 | * アルゴリズムは Mu-Huo Cheng and Yu-Hsin Hsu
246 | *
247 | * 参考
248 | * https://pdfs.semanticscholar.org/2f26/a658836927331d559e723ac36b8dab911b14.pdf
249 | */
250 | class FastMDCT {
251 |
252 | // 修正コサイン変換
253 | // n - 周波数配列数、2のべき乗である必要がある
254 | // samples - 2n個のサンプル配列、この配列が変換処理の入力元となる
255 | // frequencies - n個の周波数配列、この配列が変換処理の出力先となる
256 | static mdct(n, samples, frequencies) {
257 | // データを結合
258 | let ns1 = n - 1; // n - 1
259 | let nd2 = n >> 1; // n / 2
260 | let nm3d4 = n + nd2; // n * 3 / 4
261 | let nm3d4s1 = nm3d4 - 1; // n * 3 / 4 - 1
262 | for (let i = 0; i < nd2; ++i) {
263 | frequencies[i] = samples[nm3d4 + i] + samples[nm3d4s1 - i];
264 | frequencies[nd2 + i] = samples[i] - samples[ns1 - i];
265 | }
266 |
267 | // cos値の変換用の係数をかけ合わせ
268 | let rad = Math.PI / (n << 2);
269 | let i = 0;
270 | let nh = n >> 1;
271 | for (; i < nh; ++i) {
272 | frequencies[i] /= -2.0 * Math.cos(rad * ((i << 1) + 1));
273 | }
274 | for (; i < n; ++i) {
275 | frequencies[i] /= 2.0 * Math.cos(rad * ((i << 1) + 1));
276 | }
277 |
278 | // DCT-II
279 | FastDCT.dctII(n, frequencies);
280 |
281 | // 差分方程式
282 | for (let i = 0, j = 1; j < n; i = j++) {
283 | frequencies[i] += frequencies[j];
284 | }
285 | }
286 |
287 | // 逆修正コサイン変換
288 | // n - 周波数配列数、2のべき乗である必要がある
289 | // samples - 2n個のサンプル配列、この配列が変換処理の出力先となる
290 | // frequencies - n個の周波数配列、この配列が変換処理の入力元となる
291 | static imdct(n, samples, frequencies) {
292 | // TODO 入力元である周波数配列を破壊してしまうので作業用バッファを用いるか、破壊して良い出力先のsamplesを作業用バッファとして用いる
293 |
294 | // cos値の変換用係数を掛け合わせ
295 | let rad = Math.PI / (n << 2);
296 | for (let i = 0; i < n; ++i) {
297 | frequencies[i] *= 2.0 * Math.cos(rad * ((i << 1) + 1));
298 | }
299 |
300 | // DCT-II
301 | FastDCT.dctII(n, frequencies);
302 |
303 | // 差分方程式
304 | frequencies[0] *= 0.5;
305 | let i = 0, j = 1;
306 | let nh = n >> 1;
307 | for (; i < nh; i = j++) {
308 | frequencies[j] += (frequencies[i] = -frequencies[i]);
309 | }
310 | for (; j < n; i = j++) {
311 | frequencies[j] -= frequencies[i];
312 | }
313 |
314 | // スケーリング
315 | for (let j = 0; j < n; ++j) {
316 | frequencies[j] /= n;
317 | }
318 |
319 | // データを分離
320 | let ns1 = n - 1; // n - 1
321 | let nd2 = n >> 1; // n / 2
322 | let nm3d4 = n + nd2; // n * 3 / 4
323 | let nm3d4s1 = nm3d4 - 1; // n * 3 / 4 - 1
324 | for (let i = 0; i < nd2; ++i) {
325 | samples[ns1 - i] = -(samples[i] = frequencies[nd2 + i]);
326 | samples[nm3d4 + i] = (samples[nm3d4s1 - i] = frequencies[i]);
327 | }
328 | }
329 | }
330 |
--------------------------------------------------------------------------------
/ss.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/redlily/training-webaudio-compression/2100a2508bddeb6ee55bc835d9472fca6e816a99/ss.png
--------------------------------------------------------------------------------
13 |
14 | ### 使い方
15 |
16 | 1. 音声ファイル(おすすめは無圧縮)を選択してデータを読み込ませます。
17 | 1. 圧縮オプションを選び圧縮を実行、数秒から数十秒で圧縮が完了します。
18 | 1. 圧縮が完了すると再生ボタンとダウンロードリンクが有効になります。
19 | 1. 再生を押すと圧縮データの再生を開始、ダウンロードを押すと圧縮データのダウンロードを行います。
20 | 1. 圧縮したデータはこのプログラムでデータ読み込み、再生が出来ます。
21 |
22 | ## データフォーマット
23 |
24 | ### ヘッダ
25 |
26 | |変数名|型|説明|
27 | |:---|:---|:---|
28 | |MAGIC_NUMBER|UINT32|マジックナンバー、"WAM0"が固定値|
29 | |DATA_SIZE|UINT32|データのバイトサイズ|
30 | |DATA_TYPE|UINT32|拡張用のデータタイプ、"SMD0"が固定値|
31 | |VERSION|UINT32|データのバージョン|
32 | |SAMPLE_RATE|UINT32|サンプリングレート|
33 | |CHANNEL_SIZE|UINT32|チャネル数、1がモノラル、2がステレオ|
34 | |SAMPLE_COUNT|UINT32|データに含まれるサンプル数|
35 | |FREQUENCY_RANGE|UINT16|周波数ブロックのサイズ|
36 | |FREQUENCY_UPPER_LIMIT|UINT16|周波数ブロックの上限値|
37 | |FREQUENCY_TABLE_SIZE|UINT16|周波数テーブルのサイズ|
38 | |-|UINT16|バイトアライメント調整用の領域、今後の拡張次第では何か数値が入るかも|
39 | |FRAME_COUNT|UINT32|データに含まれるフレーム数|
40 | |FRAME_DATA|FRAME[CHANNEL_SIZE * FRAME_COUNT]|フレーム配列、チャネル数が2の場合、左、右とフーレムが並ぶ|
41 |
42 | #### フレーム
43 |
44 | |変数名|型|説明|
45 | |:---|:---|:---|
46 | |MASTER_SCALE|UINT32|このフーレムの主音量|
47 | |SUB_SCALES|UINT4[8]|8つの周波数帯用の音量を調整するためのスケール値|
48 | |ENABLE_FREQUENCIES|1bit[FREQUENCY_UPPER_LIMIT]