@next2d/builder 0.1.7 → 0.1.10

package/templates/xbox/src/platform/AudioDecoder.cpp

@@ -0,0 +1,121 @@
+#include "AudioDecoder.h"
+
+// dr_mp3 / dr_wav / stb_vorbis: public domain のヘッダオンリーデコーダ (third_party/)。
+// メモリ入力のみ使用する。実装は本 TU に集約する (ODR 一意)。
+#define DR_MP3_IMPLEMENTATION
+#define DR_MP3_NO_STDIO
+#include "third_party/dr_mp3.h"
+
+#define DR_WAV_IMPLEMENTATION
+#define DR_WAV_NO_STDIO
+#include "third_party/dr_wav.h"
+
+// stb_vorbis は .c 配布のためここで取り込む (STB_VORBIS_HEADER_ONLY は使わない)。
+#define STB_VORBIS_NO_STDIO
+#define STB_VORBIS_NO_PUSHDATA_API
+#include "third_party/stb_vorbis.c"
+
+#include <cstring>
+
+namespace next2d {
+
+namespace {
+
+bool DecodeMp3(const std::vector<uint8_t>& input, PcmBuffer& out)
+{
+    drmp3_config config = {};
+    drmp3_uint64 total_frames = 0;
+    float* frames = drmp3_open_memory_and_read_pcm_frames_f32(
+        input.data(), input.size(), &config, &total_frames, nullptr);
+    if (!frames || total_frames == 0 || config.channels == 0) {
+        if (frames) {
+            drmp3_free(frames, nullptr);
+        }
+        return false;
+    }
+    out.channels    = config.channels;
+    out.sample_rate = config.sampleRate;
+    out.samples.assign(frames, frames + total_frames * config.channels);
+    drmp3_free(frames, nullptr);
+    return true;
+}
+
+bool DecodeWav(const std::vector<uint8_t>& input, PcmBuffer& out)
+{
+    unsigned int channels = 0, sample_rate = 0;
+    drwav_uint64 total_frames = 0;
+    float* frames = drwav_open_memory_and_read_pcm_frames_f32(
+        input.data(), input.size(), &channels, &sample_rate, &total_frames, nullptr);
+    if (!frames || total_frames == 0 || channels == 0) {
+        if (frames) {
+            drwav_free(frames, nullptr);
+        }
+        return false;
+    }
+    out.channels    = channels;
+    out.sample_rate = sample_rate;
+    out.samples.assign(frames, frames + total_frames * channels);
+    drwav_free(frames, nullptr);
+    return true;
+}
+
+bool DecodeOgg(const std::vector<uint8_t>& input, PcmBuffer& out)
+{
+    int err = 0;
+    stb_vorbis* vorbis = stb_vorbis_open_memory(
+        input.data(), static_cast<int>(input.size()), &err, nullptr);
+    if (!vorbis) {
+        return false;
+    }
+    const stb_vorbis_info info = stb_vorbis_get_info(vorbis);
+    const unsigned int total_frames = stb_vorbis_stream_length_in_samples(vorbis);
+    if (info.channels <= 0 || total_frames == 0) {
+        stb_vorbis_close(vorbis);
+        return false;
+    }
+    out.channels    = static_cast<uint32_t>(info.channels);
+    out.sample_rate = info.sample_rate;
+    out.samples.resize(static_cast<size_t>(total_frames) * info.channels);
+    const int read = stb_vorbis_get_samples_float_interleaved(
+        vorbis, info.channels, out.samples.data(),
+        static_cast<int>(out.samples.size()));
+    stb_vorbis_close(vorbis);
+    if (read <= 0) {
+        out.samples.clear();
+        return false;
+    }
+    out.samples.resize(static_cast<size_t>(read) * info.channels);
+    return true;
+}
+
+} // namespace
+
+bool DecodeAudio(const std::vector<uint8_t>& input, PcmBuffer& out)
+{
+    if (input.size() < 12) {
+        return false;
+    }
+    const uint8_t* d = input.data();
+
+    // マジックナンバーで形式を判定して該当デコーダを先に試し、
+    // 外れたら残りをカスケード (誤判定・ヘッダ無し MP3 の保険)。
+    const bool looks_wav = std::memcmp(d, "RIFF", 4) == 0 && std::memcmp(d + 8, "WAVE", 4) == 0;
+    const bool looks_ogg = std::memcmp(d, "OggS", 4) == 0;
+    const bool looks_mp3 = std::memcmp(d, "ID3", 3) == 0
+        || (d[0] == 0xFF && (d[1] & 0xE0) == 0xE0);
+
+    if (looks_wav && DecodeWav(input, out)) {
+        return true;
+    }
+    if (looks_ogg && DecodeOgg(input, out)) {
+        return true;
+    }
+    if (looks_mp3 && DecodeMp3(input, out)) {
+        return true;
+    }
+
+    // 判定が外れた場合のカスケード
+    return DecodeWav(input, out) || DecodeOgg(input, out) || DecodeMp3(input, out);
+}
+
+} // namespace next2d

package/templates/xbox/src/platform/AudioDecoder.h

@@ -0,0 +1,18 @@
+// 音声デコード (エンコード済みバイト列 -> float32 interleaved PCM)。
+//
+// 第一候補は dr_mp3 / dr_wav / stb_vorbis (MP3/WAV/OGG、全プラットフォーム共通、
+// public domain)。コンソール (Game Core OS) にはデスクトップの Media Foundation が
+// 無いため、MF 依存を第一経路から外して PC 検証と実機の挙動を一致させる。
+// デスクトップのみ AAC 等の保険として AudioEngine::Decode 側に MF フォールバックが残る。
+#pragma once
+
+#include "AudioEngine.h"   // PcmBuffer
+
+#include <cstdint>
+#include <vector>
+
+namespace next2d {
+
+bool DecodeAudio(const std::vector<uint8_t>& input, PcmBuffer& out);
+
+} // namespace next2d

package/templates/xbox/src/platform/AudioEngine.cpp

@@ -1,12 +1,18 @@
 #include "AudioEngine.h"
+#include "AudioDecoder.h"
 
 #include <xaudio2.h>
+#include <iostream>
+
+// Media Foundation / shlwapi はコンソール (Game Core OS) に無いデスクトップ専用 API。
+// 第一経路は AudioDecoder (dr_mp3/dr_wav/stb_vorbis) で、MF は AAC 等の
+// デスクトップ限定フォールバックのみ。XAudio2 は両プラットフォームで使える。
+#if !NEXT2D_XBOX_CONSOLE
 #include <mfapi.h>
 #include <mfidl.h>
 #include <mfreadwrite.h>
 #include <shlwapi.h>
 #include <wrl/client.h>
-#include <iostream>
 
 #pragma comment(lib, "mfplat.lib")
 #pragma comment(lib, "mfreadwrite.lib")
@@ -14,6 +20,7 @@
 #pragma comment(lib, "shlwapi.lib")
 
 using Microsoft::WRL::ComPtr;
+#endif
 
 namespace next2d {
 
@@ -41,6 +48,10 @@ AudioVoice::~AudioVoice()
 
 void AudioVoice::Start(bool loop)
 {
+    // 音声デバイスが無い環境 (CI 等) でも「再生開始→即終了」として扱えるよう、
+    // voice_ の有無に関わらず開始状態は記録する (IsFinished が ended 発火を導く)。
+    started_ = true;
+    looping_ = loop;
     if (!voice_) {
         return;
     }
@@ -51,8 +62,6 @@ void AudioVoice::Start(bool loop)
     buf.LoopCount = loop ? XAUDIO2_LOOP_INFINITE : 0;
     voice_->SubmitSourceBuffer(&buf);
     voice_->Start(0);
-    started_ = true;
-    looping_ = loop;
 }
 
 void AudioVoice::Stop()
@@ -66,9 +75,13 @@ void AudioVoice::Stop()
 
 bool AudioVoice::IsFinished() const
 {
-    if (!voice_ || !started_ || looping_) {
+    if (!started_ || looping_) {
         return false;
     }
+    if (!voice_) {
+        // 実ボイスが無い (音声デバイス無し) 場合は開始と同時に終了扱い。
+        return true;
+    }
     XAUDIO2_VOICE_STATE state = {};
     voice_->GetState(&state);
     return state.BuffersQueued == 0;
@@ -91,15 +104,19 @@ AudioEngine::~AudioEngine()
     if (xaudio_) {
         xaudio_->Release();
     }
+#if !NEXT2D_XBOX_CONSOLE
     MFShutdown();
+#endif
 }
 
 bool AudioEngine::Initialize()
 {
+#if !NEXT2D_XBOX_CONSOLE
     if (FAILED(MFStartup(MF_VERSION))) {
         std::cerr << "[Audio] MFStartup failed" << std::endl;
         return false;
     }
+#endif
     if (FAILED(XAudio2Create(&xaudio_, 0, XAUDIO2_DEFAULT_PROCESSOR))) {
         std::cerr << "[Audio] XAudio2Create failed" << std::endl;
         return false;
@@ -113,8 +130,21 @@ bool AudioEngine::Initialize()
 
 bool AudioEngine::Decode(const std::vector<uint8_t>& input, PcmBuffer& out)
 {
-    // メモリストリームから Media Foundation の SourceReader を作り、
-    // 32bit float PCM へ変換して読み出す。
+    // 第一候補: ポータブルデコーダ (dr_mp3/dr_wav/stb_vorbis)。
+    // コンソール (Game Core) には Media Foundation が無いため、共通経路を先に
+    // 通すことで PC 検証と実機の挙動を一致させる。
+    if (DecodeAudio(input, out)) {
+        return true;
+    }
+
+#if NEXT2D_XBOX_CONSOLE
+    // コンソール: MF が無いため共通デコーダで扱えない形式は失敗とする
+    // (呼び出し側の graceful degradation = 無音バッファで進行)。
+    return false;
+#else
+    // フォールバック (デスクトップのみ): Media Foundation の SourceReader。
+    // AAC/WMA 等、MP3/WAV/OGG 以外の形式への保険。
+    // メモリストリームから 32bit float PCM へ変換して読み出す。
     ComPtr<IStream> stream =
         SHCreateMemStream(input.data(), static_cast<UINT>(input.size()));
     if (!stream) {
@@ -174,6 +204,7 @@ bool AudioEngine::Decode(const std::vector<uint8_t>& input, PcmBuffer& out)
     }
 
     return !out.samples.empty();
+#endif // NEXT2D_XBOX_CONSOLE
 }
 
 std::shared_ptr<AudioVoice> AudioEngine::CreateVoice(std::shared_ptr<PcmBuffer> buffer)

package/templates/xbox/src/platform/DecodeQueue.cpp

@@ -0,0 +1,136 @@
+#include "DecodeQueue.h"
+
+#ifdef _WIN32
+#include <objbase.h>
+#endif
+
+#include <algorithm>
+#include <condition_variable>
+#include <deque>
+#include <mutex>
+#include <thread>
+#include <vector>
+
+namespace next2d::decodequeue {
+
+namespace {
+
+struct Job {
+    std::function<void()> work;
+    std::function<void()> complete;
+};
+
+struct Queue {
+    std::mutex mutex;
+    std::condition_variable cv;
+    std::deque<Job> pending;                       // 未処理 (プールスレッドが取る)
+    std::deque<std::function<void()>> done;        // work 完了済み (Pump が実行)
+    std::vector<std::thread> threads;
+    bool stop = false;
+
+    void ThreadMain()
+    {
+#ifdef _WIN32
+        // WIC / Media Foundation は COM を要する。プールスレッド毎に MTA で初期化する
+        // (per-call 実装なので MTA スレッド間で共有状態は無い)。
+        CoInitializeEx(nullptr, COINIT_MULTITHREADED);
+#endif
+        for (;;) {
+            Job job;
+            {
+                std::unique_lock<std::mutex> lock(mutex);
+                cv.wait(lock, [this] { return stop || !pending.empty(); });
+                if (stop) {
+                    break;
+                }
+                job = std::move(pending.front());
+                pending.pop_front();
+            }
+            if (job.work) {
+                job.work();
+            }
+            {
+                std::lock_guard<std::mutex> lock(mutex);
+                done.push_back(std::move(job.complete));
+            }
+        }
+#ifdef _WIN32
+        CoUninitialize();
+#endif
+    }
+
+    void EnsureThreads()
+    {
+        if (!threads.empty()) {
+            return;
+        }
+        // デコードは CPU バウンド。コア数の半分 (2〜4) で遷移時のバースト
+        // (画像数十枚 + BGM) を並列処理しつつ、メイン/GC スレッドを圧迫しない。
+        const unsigned hw = std::thread::hardware_concurrency();
+        const unsigned count = std::clamp(hw / 2u, 2u, 4u);
+        threads.reserve(count);
+        for (unsigned i = 0; i < count; ++i) {
+            threads.emplace_back([this] { ThreadMain(); });
+        }
+    }
+};
+
+Queue& Q()
+{
+    static Queue q;
+    return q;
+}
+
+} // namespace
+
+void Submit(std::function<void()> work, std::function<void()> complete)
+{
+    Queue& q = Q();
+    {
+        std::lock_guard<std::mutex> lock(q.mutex);
+        if (q.stop) {
+            return;   // Shutdown 後の Submit は破棄 (終了処理中のロード要求)
+        }
+        q.EnsureThreads();
+        q.pending.push_back({std::move(work), std::move(complete)});
+    }
+    q.cv.notify_one();
+}
+
+void Pump()
+{
+    Queue& q = Q();
+    std::deque<std::function<void()>> ready;
+    {
+        std::lock_guard<std::mutex> lock(q.mutex);
+        ready.swap(q.done);
+    }
+    for (auto& complete : ready) {
+        if (complete) {
+            complete();
+        }
+    }
+}
+
+void Shutdown()
+{
+    Queue& q = Q();
+    {
+        std::lock_guard<std::mutex> lock(q.mutex);
+        q.stop = true;
+    }
+    q.cv.notify_all();
+    for (auto& t : q.threads) {
+        if (t.joinable()) {
+            t.join();
+        }
+    }
+    q.threads.clear();
+    // 未実行の work / complete を破棄する。complete は v8::Global を捕捉して
+    // いるため、この関数は Isolate 破棄前に呼ばれる必要がある (main.cpp の後始末順)。
+    std::lock_guard<std::mutex> lock(q.mutex);
+    q.pending.clear();
+    q.done.clear();
+}
+
+} // namespace next2d::decodequeue

package/templates/xbox/src/platform/DecodeQueue.h

@@ -0,0 +1,27 @@
+// DecodeQueue: リソースデコード用のバックグラウンドスレッドプール。
+//
+// 画像 (WIC) / 音声 (Media Foundation) のデコードはメインスレッドで同期実行すると
+// 画面遷移時に 1 秒超のフレームヒッチになる (--perf 計測で特定)。work を
+// プールスレッドへ逃がし、complete をメインループの Pump() で実行することで
+// ヒッチを解消し、複数リソースの並列デコードでロード時間も短縮する。
+// スレッドは Xbox で許可されている (禁止は動的コード生成のみ)。
+//
+// 契約:
+//   - work    : プールスレッドで実行される。V8 / JS ヒープに触れてはならない。
+//               (WIC/MF は per-call 実装で COM はスレッド毎に MTA 初期化済み)
+//   - complete: work 完了後、メインスレッドの Pump() から実行される。V8 可。
+//               (v8::Global を捕捉してよい。Pump は isolate/コンテキストスコープ外で
+//                呼ばれるため、complete 側で HandleScope/Context::Scope を張ること)
+//   - Shutdown: 全スレッドを join し、未実行の work / complete を破棄する。
+//               捕捉された v8::Global の破棄があるため Isolate 破棄前に呼ぶこと。
+#pragma once
+
+#include <functional>
+
+namespace next2d::decodequeue {
+
+void Submit(std::function<void()> work, std::function<void()> complete);
+void Pump();
+void Shutdown();
+
+} // namespace next2d::decodequeue

package/templates/xbox/src/platform/ImageDecoder.cpp

@@ -0,0 +1,44 @@
+#include "ImageDecoder.h"
+
+// stb_image: public domain のヘッダオンリー画像デコーダ (third_party/)。
+// メモリ入力のみ使用するため stdio を切る。
+#define STB_IMAGE_IMPLEMENTATION
+#define STBI_NO_STDIO
+#include "third_party/stb_image.h"
+
+#if defined(_WIN32) && !NEXT2D_XBOX_CONSOLE
+#include "WicDecoder.h"
+#endif
+
+#include <cstring>
+
+namespace next2d {
+
+bool DecodeImage(const std::vector<uint8_t>& input, DecodedImage& out)
+{
+    if (input.empty()) {
+        return false;
+    }
+
+    // 1) stb_image (PNG/JPEG/GIF/BMP/TGA/PSD)。コンソールでも動く共通経路。
+    int w = 0, h = 0, comp = 0;
+    stbi_uc* pixels = stbi_load_from_memory(
+        input.data(), static_cast<int>(input.size()), &w, &h, &comp, 4);
+    if (pixels) {
+        out.width  = static_cast<uint32_t>(w);
+        out.height = static_cast<uint32_t>(h);
+        out.rgba.assign(pixels, pixels + static_cast<size_t>(w) * h * 4);
+        stbi_image_free(pixels);
+        return true;
+    }
+
+#if defined(_WIN32) && !NEXT2D_XBOX_CONSOLE
+    // 2) デスクトップのみ: WIC フォールバック (TIFF/HEIF 等 stb 非対応形式の保険)。
+    //    コンソールには WIC が無いためこの経路はコンパイルされない。
+    return DecodeImageWithWIC(input, out);
+#else
+    return false;
+#endif
+}
+
+} // namespace next2d

package/templates/xbox/src/platform/ImageDecoder.h

@@ -0,0 +1,18 @@
+// 画像デコード (エンコード済みバイト列 -> RGBA8)。
+//
+// 第一候補は stb_image (PNG/JPEG/GIF/BMP、全プラットフォーム共通)。
+// コンソール (Game Core OS) には WIC が存在しないため、WIC 依存を第一経路から
+// 外すことで PC 検証と実機の挙動を一致させる。デスクトップのみ、stb が扱えない
+// 形式 (TIFF/HEIF 等) への保険として WIC フォールバックを残す。
+#pragma once
+
+#include "ImageTypes.h"
+
+#include <cstdint>
+#include <vector>
+
+namespace next2d {
+
+bool DecodeImage(const std::vector<uint8_t>& input, DecodedImage& out);
+
+} // namespace next2d