diff --git a/README.md b/README.md index b7c28e7..e5494f7 100644 --- a/README.md +++ b/README.md @@ -1,8 +1,8 @@ # NESLite NESLite 是一个面向 Android 的轻量 NES/FC 模拟器前端。它使用固定版本的 -FCEUmm libretro 内核。当前仓库已完成 M2 的隔离实现和本地验证;由于 G1 尚未经过目标手机与 -X5 Lite 验收,M2/G2 的实机门槛仍保持未通过。 +FCEUmm libretro 内核。当前仓库已完成 M3 的隔离实现和本地验证,包括 Oboe 输出、重采样、 +音频焦点/路由恢复和 2× 快进;由于前序真机门槛尚未通过,M2/G2 与 M3/G3 的实机验收仍待补齐。 ## 快速构建 diff --git a/THIRD_PARTY_NOTICES.md b/THIRD_PARTY_NOTICES.md index f62911c..eba602e 100644 --- a/THIRD_PARTY_NOTICES.md +++ b/THIRD_PARTY_NOTICES.md @@ -3,21 +3,21 @@ 本文件列出 M0 已引入、已选定或计划引入的第三方组件。发布包只能包含与实际依赖图一致的条目; 新增或移除组件必须同步更新本文件、`docs/dependencies.md` 和版本锁。 -## M0 已引入 +## 生产包已引入 | 组件 | 坐标/版本 | 许可证 | 通知要求 | | --- | --- | --- | --- | | AndroidX Core KTX | `androidx.core:core-ktx:1.17.0` | Apache-2.0 | 分发时保留许可和 NOTICE(如上游提供)。 | | AndroidX Activity KTX | `androidx.activity:activity-ktx:1.12.0` | Apache-2.0 | 分发时保留许可和 NOTICE(如上游提供)。 | +| Room | `androidx.room:room-runtime/room-ktx:2.7.2` | Apache-2.0 | 分发时保留许可和 NOTICE(如上游提供)。 | +| FCEUmm | `236ccdfc911e84c60fea6b9d0699c2d440a8de14` | GPL-2.0-only | 对应完整源码、GPL v2 文本、原始版权/Authors、所有补丁和获取说明。 | +| libretro.h | `0c9622896333ee62dc4326bbe8784a210ddeb03c` | MIT | 原始版权和 MIT 许可文本。 | +| Oboe | 1.10.0 / `a81bb9f87d4105b84b682685d3bfbb5beca371d1` | Apache-2.0 | Apache 2.0 文本及上游 NOTICE(如有)。 | ## 已锁定、尚未引入 | 组件 | 固定来源 | 许可证 | 发布时的必需材料 | | --- | --- | --- | --- | -| FCEUmm | `236ccdfc911e84c60fea6b9d0699c2d440a8de14` | GPL-2.0-only | 对应完整源码、GPL v2 文本、原始版权/Authors、所有补丁和获取说明。 | -| libretro.h | `0c9622896333ee62dc4326bbe8784a210ddeb03c` | MIT | 原始版权和 MIT 许可文本。 | -| Oboe | 1.10.0 / `a81bb9f87d4105b84b682685d3bfbb5beca371d1` | Apache-2.0 | Apache 2.0 文本及上游 NOTICE(如有)。 | -| Room | 2.7.2 | Apache-2.0 | 实际引入时保留许可/NOTICE。 | | DataStore | 1.1.7 | Apache-2.0 | 实际引入时保留许可/NOTICE。 | 测试依赖 JUnit 4.13.2(EPL-1.0)和 AndroidX Test/Espresso(Apache-2.0)不打入生产 APK, diff --git a/app/build.gradle.kts b/app/build.gradle.kts index 383f006..e3d84bb 100644 --- a/app/build.gradle.kts +++ b/app/build.gradle.kts @@ -21,8 +21,8 @@ android { applicationId = "org.neslite.app" minSdk = 28 targetSdk = 36 - versionCode = 2004 - versionName = "0.2.4" + versionCode = 3004 + versionName = "0.3.4" testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner" ndk { diff --git a/app/src/main/cpp/CMakeLists.txt b/app/src/main/cpp/CMakeLists.txt index 28e57a5..dd7eb5a 100644 --- a/app/src/main/cpp/CMakeLists.txt +++ b/app/src/main/cpp/CMakeLists.txt @@ -8,6 +8,9 @@ set(CMAKE_CXX_EXTENSIONS OFF) set(NESLITE_COMMON_SOURCES native_smoke.cpp session_rules.cpp + audio_ring_buffer.cpp + linear_resampler.cpp + timing_metrics.cpp video_buffer.cpp ) @@ -21,19 +24,22 @@ endfunction() if(ANDROID) include(cmake/fceumm.cmake) + include(cmake/oboe.cmake) add_library(neslite_jni SHARED core_identity.cpp core_session.cpp + audio_engine.cpp gl_renderer.cpp jni_bridge.cpp ${NESLITE_COMMON_SOURCES} ) neslite_enable_strict_warnings(neslite_jni) target_include_directories(neslite_jni PRIVATE "${NESLITE_LIBRETRO_HEADERS_DIR}") + target_include_directories(neslite_jni SYSTEM PRIVATE "${NESLITE_OBOE_DIR}/include") find_library(log-lib log) find_library(gles-lib GLESv2) - target_link_libraries(neslite_jni PRIVATE fceumm_core ${log-lib} ${gles-lib}) + target_link_libraries(neslite_jni PRIVATE fceumm_core oboe ${log-lib} ${gles-lib}) else() enable_testing() add_executable(neslite_native_smoke_test diff --git a/app/src/main/cpp/audio_engine.cpp b/app/src/main/cpp/audio_engine.cpp new file mode 100644 index 0000000..c38fe9f --- /dev/null +++ b/app/src/main/cpp/audio_engine.cpp @@ -0,0 +1,176 @@ +#include "audio_engine.h" + +#include +#include + +namespace neslite { + +AudioEngine::~AudioEngine() { + close(); +} + +void AudioEngine::set_error(const std::string& error) { + last_error_ = error; +} + +bool AudioEngine::open_attempt(oboe::SharingMode sharing, oboe::PerformanceMode performance, + const char* mode_name) { + oboe::AudioStreamBuilder builder; + builder.setDirection(oboe::Direction::Output) + ->setSharingMode(sharing) + ->setPerformanceMode(performance) + ->setFormat(oboe::AudioFormat::Float) + ->setChannelCount(2) + ->setDataCallback(this) + ->setErrorCallback(this); + std::shared_ptr candidate; + const oboe::Result result = builder.openStream(candidate); + if (result != oboe::Result::OK || candidate == nullptr) { + set_error(std::string(mode_name) + ": " + oboe::convertToText(result)); + return false; + } + if (candidate->getFormat() != oboe::AudioFormat::Float || candidate->getChannelCount() != 2 || + candidate->getSampleRate() <= 0) { + candidate->close(); + set_error(std::string(mode_name) + ": unsupported negotiated format"); + return false; + } + stream_ = std::move(candidate); + mode_ = mode_name; + device_sample_rate_.store(stream_->getSampleRate()); + frames_per_burst_.store(stream_->getFramesPerBurst()); + frames_per_callback_.store(stream_->getFramesPerCallback()); + last_error_.clear(); + disconnected_.store(false); + return true; +} + +bool AudioEngine::open(int core_sample_rate) { + std::lock_guard lock(control_mutex_); + if (stream_ != nullptr) { + active_.store(false); + stream_->requestStop(); + stream_->close(); + stream_.reset(); + } + core_sample_rate_.store(core_sample_rate); + buffer_.clear(); + buffer_.reset_statistics(); + callback_count_.store(0); + maximum_callback_frames_.store(0); + if (open_attempt(oboe::SharingMode::Exclusive, oboe::PerformanceMode::LowLatency, + "exclusive-low-latency")) return true; + if (open_attempt(oboe::SharingMode::Shared, oboe::PerformanceMode::LowLatency, + "shared-low-latency")) return true; + if (open_attempt(oboe::SharingMode::Shared, oboe::PerformanceMode::None, + "shared-safe")) return true; + mode_ = "unavailable-monotonic-clock"; + device_sample_rate_.store(0); + return false; +} + +bool AudioEngine::start() { + std::lock_guard lock(control_mutex_); + if (stream_ == nullptr) return false; + buffer_.clear(); + const oboe::Result result = stream_->requestStart(); + if (result != oboe::Result::OK) { + set_error(std::string("start: ") + oboe::convertToText(result)); + active_.store(false); + return false; + } + active_.store(true); + return true; +} + +void AudioEngine::stop() { + std::lock_guard lock(control_mutex_); + active_.store(false); + if (stream_ != nullptr) stream_->requestStop(); + buffer_.clear(); +} + +void AudioEngine::close() { + std::lock_guard lock(control_mutex_); + active_.store(false); + if (stream_ != nullptr) { + stream_->requestStop(); + stream_->close(); + stream_.reset(); + } + buffer_.clear(); + mode_ = "closed"; + device_sample_rate_.store(0); +} + +bool AudioEngine::rebuild() { + const int core_rate = core_sample_rate_.load(); + close(); + rebuild_count_.fetch_add(1); + return open(core_rate); +} + +bool AudioEngine::consume_disconnect() { + return disconnected_.exchange(false); +} + +void AudioEngine::set_gain(float gain) { + gain_.store(std::isfinite(gain) ? std::clamp(gain, 0.0F, 1.0F) : 0.0F); +} + +void AudioEngine::set_user_muted(bool muted) { + user_muted_.store(muted); +} + +void AudioEngine::set_fast_muted(bool muted) { + fast_muted_.store(muted); +} + +oboe::DataCallbackResult AudioEngine::onAudioReady( + oboe::AudioStream*, void* audio_data, std::int32_t num_frames) { + if (audio_data == nullptr || num_frames <= 0) return oboe::DataCallbackResult::Stop; + callback_count_.fetch_add(1, std::memory_order_relaxed); + int previous_max = maximum_callback_frames_.load(std::memory_order_relaxed); + while (num_frames > previous_max && + !maximum_callback_frames_.compare_exchange_weak(previous_max, num_frames, + std::memory_order_relaxed)) {} + const bool muted = user_muted_.load(std::memory_order_relaxed) || + fast_muted_.load(std::memory_order_relaxed) || + !active_.load(std::memory_order_relaxed); + buffer_.pop(static_cast(audio_data), static_cast(num_frames), + gain_.load(std::memory_order_relaxed), muted); + return oboe::DataCallbackResult::Continue; +} + +void AudioEngine::onErrorAfterClose(oboe::AudioStream*, oboe::Result error) { + active_.store(false); + disconnected_.store(true); + // Error callback performs no open/close or allocation; the core thread owns reconstruction. + (void) error; +} + +AudioDiagnostics AudioEngine::diagnostics() const { + std::lock_guard lock(control_mutex_); + AudioDiagnostics result; + result.open = stream_ != nullptr; + result.active = active_.load(); + result.disconnected = disconnected_.load(); + result.muted = user_muted_.load(); + result.gain = gain_.load(); + result.core_sample_rate = core_sample_rate_.load(); + result.device_sample_rate = device_sample_rate_.load(); + result.frames_per_burst = frames_per_burst_.load(); + result.frames_per_callback = frames_per_callback_.load(); + result.maximum_callback_frames = maximum_callback_frames_.load(); + result.callback_count = callback_count_.load(); + result.rebuild_count = rebuild_count_.load(); + result.underrun_frames = buffer_.underrun_frames(); + result.overflow_frames = buffer_.overflow_frames(); + result.buffer_level_frames = buffer_.level_frames(); + result.buffer_capacity_frames = buffer_.capacity_frames(); + result.mode = mode_; + result.last_error = last_error_; + return result; +} + +} // namespace neslite diff --git a/app/src/main/cpp/audio_engine.h b/app/src/main/cpp/audio_engine.h new file mode 100644 index 0000000..dcf0296 --- /dev/null +++ b/app/src/main/cpp/audio_engine.h @@ -0,0 +1,82 @@ +#pragma once + +#include +#include +#include +#include +#include + +#include "audio_ring_buffer.h" +#include "oboe/Oboe.h" + +namespace neslite { + +struct AudioDiagnostics { + bool open = false; + bool active = false; + bool disconnected = false; + bool muted = false; + float gain = 1.0F; + int core_sample_rate = 0; + int device_sample_rate = 0; + int frames_per_burst = 0; + int frames_per_callback = 0; + int maximum_callback_frames = 0; + std::uint64_t callback_count = 0; + std::uint64_t rebuild_count = 0; + std::uint64_t underrun_frames = 0; + std::uint64_t overflow_frames = 0; + std::size_t buffer_level_frames = 0; + std::size_t buffer_capacity_frames = 0; + std::string mode; + std::string last_error; +}; + +class AudioEngine final : public oboe::AudioStreamDataCallback, + public oboe::AudioStreamErrorCallback { + public: + explicit AudioEngine(AudioRingBuffer& buffer) : buffer_(buffer) {} + ~AudioEngine() override; + + bool open(int core_sample_rate); + bool start(); + void stop(); + void close(); + bool rebuild(); + bool consume_disconnect(); + void set_gain(float gain); + void set_user_muted(bool muted); + void set_fast_muted(bool muted); + int device_sample_rate() const { return device_sample_rate_.load(); } + bool is_active() const { return active_.load(); } + AudioDiagnostics diagnostics() const; + + oboe::DataCallbackResult onAudioReady( + oboe::AudioStream* stream, void* audio_data, std::int32_t num_frames) override; + void onErrorAfterClose(oboe::AudioStream* stream, oboe::Result error) override; + + private: + bool open_attempt(oboe::SharingMode sharing, oboe::PerformanceMode performance, + const char* mode_name); + void set_error(const std::string& error); + + AudioRingBuffer& buffer_; + std::shared_ptr stream_; + mutable std::mutex control_mutex_; + std::atomic active_{false}; + std::atomic disconnected_{false}; + std::atomic user_muted_{false}; + std::atomic fast_muted_{false}; + std::atomic gain_{1.0F}; + std::atomic core_sample_rate_{0}; + std::atomic device_sample_rate_{0}; + std::atomic frames_per_burst_{0}; + std::atomic frames_per_callback_{0}; + std::atomic maximum_callback_frames_{0}; + std::atomic callback_count_{0}; + std::atomic rebuild_count_{0}; + std::string mode_ = "closed"; + std::string last_error_; +}; + +} // namespace neslite diff --git a/app/src/main/cpp/audio_ring_buffer.cpp b/app/src/main/cpp/audio_ring_buffer.cpp new file mode 100644 index 0000000..ad5401c --- /dev/null +++ b/app/src/main/cpp/audio_ring_buffer.cpp @@ -0,0 +1,74 @@ +#include "audio_ring_buffer.h" + +#include + +namespace neslite { + +AudioRingBuffer::AudioRingBuffer(std::size_t capacity_frames) + : capacity_frames_(std::max(1, capacity_frames)), + samples_(capacity_frames_ * 2U, 0.0F) {} + +std::size_t AudioRingBuffer::push(const float* input, std::size_t frames) { + if (input == nullptr || frames == 0) return 0; + const std::uint64_t write = write_frame_.load(std::memory_order_relaxed); + const std::uint64_t read = read_frame_.load(std::memory_order_acquire); + const std::size_t available = capacity_frames_ - + std::min(capacity_frames_, write - read); + const std::size_t accepted = std::min(frames, available); + for (std::size_t frame = 0; frame < accepted; ++frame) { + const std::size_t target = static_cast((write + frame) % capacity_frames_) * 2U; + samples_[target] = input[frame * 2U]; + samples_[target + 1U] = input[frame * 2U + 1U]; + } + write_frame_.store(write + accepted, std::memory_order_release); + if (accepted < frames) overflow_frames_.fetch_add(frames - accepted, std::memory_order_relaxed); + return accepted; +} + +std::size_t AudioRingBuffer::pop(float* output, std::size_t frames, float gain, bool muted) { + if (output == nullptr || frames == 0) return 0; + const std::uint64_t read = read_frame_.load(std::memory_order_relaxed); + const std::uint64_t write = write_frame_.load(std::memory_order_acquire); + const std::size_t ready = static_cast( + std::min(frames, std::min(capacity_frames_, write - read))); + const float applied_gain = muted ? 0.0F : std::clamp(gain, 0.0F, 1.0F); + for (std::size_t frame = 0; frame < ready; ++frame) { + const std::size_t source = static_cast((read + frame) % capacity_frames_) * 2U; + output[frame * 2U] = samples_[source] * applied_gain; + output[frame * 2U + 1U] = samples_[source + 1U] * applied_gain; + } + std::fill(output + ready * 2U, output + frames * 2U, 0.0F); + // A lifecycle clear may advance the consumer cursor while the final device + // callback is still returning. Never let that callback move the cursor + // backwards and make pre-pause samples visible again. + const std::uint64_t consumed = read + ready; + std::uint64_t current_read = read_frame_.load(std::memory_order_relaxed); + while (current_read < consumed && + !read_frame_.compare_exchange_weak(current_read, consumed, + std::memory_order_release, + std::memory_order_relaxed)) {} + if (ready < frames) underrun_frames_.fetch_add(frames - ready, std::memory_order_relaxed); + return ready; +} + +void AudioRingBuffer::clear() { + const std::uint64_t discarded = write_frame_.load(std::memory_order_acquire); + std::uint64_t current_read = read_frame_.load(std::memory_order_relaxed); + while (current_read < discarded && + !read_frame_.compare_exchange_weak(current_read, discarded, + std::memory_order_release, + std::memory_order_relaxed)) {} +} + +void AudioRingBuffer::reset_statistics() { + underrun_frames_.store(0, std::memory_order_relaxed); + overflow_frames_.store(0, std::memory_order_relaxed); +} + +std::size_t AudioRingBuffer::level_frames() const { + const std::uint64_t write = write_frame_.load(std::memory_order_acquire); + const std::uint64_t read = read_frame_.load(std::memory_order_acquire); + return static_cast(std::min(capacity_frames_, write - read)); +} + +} // namespace neslite diff --git a/app/src/main/cpp/audio_ring_buffer.h b/app/src/main/cpp/audio_ring_buffer.h new file mode 100644 index 0000000..5346227 --- /dev/null +++ b/app/src/main/cpp/audio_ring_buffer.h @@ -0,0 +1,33 @@ +#pragma once + +#include +#include +#include +#include + +namespace neslite { + +class AudioRingBuffer { + public: + explicit AudioRingBuffer(std::size_t capacity_frames); + + std::size_t push(const float* interleaved_stereo, std::size_t frames); + std::size_t pop(float* interleaved_stereo, std::size_t frames, float gain, bool muted); + void clear(); + void reset_statistics(); + + std::size_t capacity_frames() const { return capacity_frames_; } + std::size_t level_frames() const; + std::uint64_t underrun_frames() const { return underrun_frames_.load(); } + std::uint64_t overflow_frames() const { return overflow_frames_.load(); } + + private: + const std::size_t capacity_frames_; + std::vector samples_; + std::atomic read_frame_{0}; + std::atomic write_frame_{0}; + std::atomic underrun_frames_{0}; + std::atomic overflow_frames_{0}; +}; + +} // namespace neslite diff --git a/app/src/main/cpp/cmake/oboe.cmake b/app/src/main/cpp/cmake/oboe.cmake new file mode 100644 index 0000000..b91a021 --- /dev/null +++ b/app/src/main/cpp/cmake/oboe.cmake @@ -0,0 +1,16 @@ +set(NESLITE_OBOE_DIR + "${CMAKE_CURRENT_LIST_DIR}/../../../../../third_party/sources/oboe" + CACHE PATH "Path to the pinned Oboe checkout" +) + +if(NOT EXISTS "${NESLITE_OBOE_DIR}/include/oboe/Oboe.h") + message(FATAL_ERROR + "Pinned Oboe source not found at ${NESLITE_OBOE_DIR}. " + "Run tools/fetch-third-party.ps1 from the repository root." + ) +endif() + +add_subdirectory("${NESLITE_OBOE_DIR}" "${CMAKE_CURRENT_BINARY_DIR}/oboe-build" EXCLUDE_FROM_ALL) +# Project-wide -Werror remains enabled for NESLite. Oboe 1.10.0 intentionally has +# default virtual methods with unused named parameters on newer NDK clang. +target_compile_options(oboe PRIVATE -Wno-unused-parameter -Wno-sign-compare) diff --git a/app/src/main/cpp/core_session.cpp b/app/src/main/cpp/core_session.cpp index 979ca03..80e568d 100644 --- a/app/src/main/cpp/core_session.cpp +++ b/app/src/main/cpp/core_session.cpp @@ -5,6 +5,7 @@ #include #include #include +#include #include #include #include @@ -14,18 +15,45 @@ #include #include #include +#include #include #include #include #include "libretro.h" +#include "audio_engine.h" +#include "linear_resampler.h" #include "session_rules.h" +#include "timing_metrics.h" namespace neslite { namespace { constexpr std::size_t kMaxCommands = 32; constexpr std::size_t kMaxRomBytes = 64U * 1024U * 1024U; +constexpr std::size_t kAudioCapacityFrames = 4096; + +std::int64_t monotonic_now_ns() { + return std::chrono::duration_cast( + std::chrono::steady_clock::now().time_since_epoch()).count(); +} + +std::string json_escape(std::string_view value) { + std::string escaped; + escaped.reserve(value.size()); + for (const char character : value) { + switch (character) { + case '\\': escaped += "\\\\"; break; + case '"': escaped += "\\\""; break; + case '\n': escaped += "\\n"; break; + case '\r': escaped += "\\r"; break; + case '\t': escaped += "\\t"; break; + default: + if (static_cast(character) >= 0x20U) escaped += character; + } + } + return escaped; +} struct Command { std::uint64_t session_id; @@ -59,6 +87,12 @@ struct Host { bool initialized = false; bool loaded = false; VideoBuffer video; + AudioRingBuffer audio_buffer{kAudioCapacityFrames}; + AudioEngine audio{audio_buffer}; + LinearStereoResampler resampler; + TimingMetrics timing; + std::atomic fast_forward{false}; + std::atomic audio_target_frames{800}; Host() : worker([this] { run(); }) {} ~Host() { @@ -157,6 +191,12 @@ struct Host { } bool unload() { + timing.transition(TimingMode::Paused, monotonic_now_ns()); + fast_forward = false; + audio.set_fast_muted(false); + audio.close(); + audio_buffer.clear(); + resampler.reset(); bool battery_saved = false; if (loaded) { battery_saved = save_battery(); @@ -173,7 +213,9 @@ struct Host { } bool perform_load(const Command& command) { + const auto load_started = monotonic_now_ns(); unload(); + timing.reset(load_started); session_id.store(command.session_id, std::memory_order_release); system_dir = command.system_dir; save_dir = command.save_dir; @@ -219,12 +261,23 @@ struct Host { } loaded = true; retro_get_system_av_info(&av); - if (av.geometry.base_width == 0 || av.geometry.base_height == 0 || av.timing.fps <= 1.0) { + if (av.geometry.base_width == 0 || av.geometry.base_height == 0 || av.timing.fps <= 1.0 || + av.timing.sample_rate < 8000.0) { unload(); fail(command.session_id, "FCEUmm returned invalid AV information"); return false; } + const int core_rate = static_cast(std::lround(av.timing.sample_rate)); + const bool audio_open = audio.open(core_rate); + const int output_rate = audio_open ? audio.device_sample_rate() : core_rate; + resampler.configure(static_cast(core_rate), static_cast(output_rate)); + audio_target_frames.store(static_cast(std::clamp( + std::lround(static_cast(output_rate) / av.timing.fps), 128L, + static_cast(kAudioCapacityFrames / 2U)))); load_battery(); + const auto load_finished = monotonic_now_ns(); + timing.reset(load_finished); + timing.record_load(load_finished - load_started); set_state(SessionState::Paused); complete(command.session_id, "loaded"); return true; @@ -244,15 +297,68 @@ struct Host { complete(command.session_id, "stale"); return true; } - if (command.name == "run" && loaded && command_allowed(state.load(), command.name)) { + if (command.name.starts_with("volume:") && loaded) { + try { + audio.set_gain(std::stof(command.name.substr(7))); + complete(active_id, "volume"); + } catch (...) { + complete(active_id, "ignored"); + } + } else if ((command.name == "mute:on" || command.name == "mute:off") && loaded) { + audio.set_user_muted(command.name == "mute:on"); + complete(active_id, command.name == "mute:on" ? "muted" : "unmuted"); + } else if (command.name == "audio_rebuild" && loaded) { + set_state(SessionState::Pausing); + timing.transition(TimingMode::Paused, monotonic_now_ns()); + fast_forward = false; + audio.set_fast_muted(false); + audio.stop(); + const bool rebuilt = audio.rebuild(); + const int output_rate = rebuilt ? audio.device_sample_rate() : + static_cast(std::lround(av.timing.sample_rate)); + resampler.configure(av.timing.sample_rate, static_cast(output_rate)); + audio_target_frames.store(static_cast(std::clamp( + std::lround(static_cast(output_rate) / av.timing.fps), 128L, + static_cast(kAudioCapacityFrames / 2U)))); + set_state(SessionState::Paused); + complete(active_id, rebuilt ? "audio_rebuilt_paused" : "audio_unavailable_paused"); + } else if (command.name == "fast:on" && loaded && state == SessionState::Running && !fast_forward) { + fast_forward = true; + audio.set_fast_muted(true); + audio.stop(); + audio_buffer.clear(); + resampler.reset(); + timing.transition(TimingMode::Fast, monotonic_now_ns()); + complete(active_id, "fast_2x"); + } else if (command.name == "fast:off" && loaded && state == SessionState::Running && fast_forward) { + fast_forward = false; + audio.set_fast_muted(false); + audio_buffer.clear(); + resampler.reset(); + audio.start(); + timing.transition(TimingMode::Normal, monotonic_now_ns()); + complete(active_id, "normal_speed"); + } else if (command.name == "run" && loaded && command_allowed(state.load(), command.name)) { + fast_forward = false; + audio.set_fast_muted(false); + audio_buffer.clear(); + resampler.reset(); + audio.start(); set_state(SessionState::Running); + timing.transition(TimingMode::Normal, monotonic_now_ns()); complete(active_id, "running"); } else if (command.name == "pause" && loaded && command_allowed(state.load(), command.name)) { set_state(SessionState::Pausing); + fast_forward = false; + audio.set_fast_muted(false); + audio.stop(); + timing.transition(TimingMode::Paused, monotonic_now_ns()); const bool battery_saved = save_battery(); set_state(SessionState::Paused); complete(active_id, battery_saved ? "paused_saved" : "paused"); } else if (command.name == "reset" && loaded && command_allowed(state.load(), command.name)) { + audio_buffer.clear(); + resampler.reset(); retro_reset(); complete(active_id, "reset"); } else if (command.name == "stop" && (loaded || state == SessionState::Error) && @@ -295,10 +401,21 @@ struct Host { current = state; } if (current == SessionState::Running && loaded) { + if (audio.consume_disconnect()) { + handle(Command{session_id.load(), "audio_rebuild", {}, {}, {}, {}}); + next_frame = clock::now(); + continue; + } + const auto work_started = clock::now(); retro_run(); const double fps = std::clamp(av.timing.fps, 10.0, 240.0); + timing.record_frame(1.0 / fps, std::chrono::duration_cast( + clock::now() - work_started).count()); + const std::size_t target = audio_target_frames.load(); + const double period_scale = scheduler_period_scale( + audio_buffer.level_frames(), target, audio.is_active(), fast_forward.load()); next_frame += std::chrono::duration_cast( - std::chrono::duration(1.0 / fps)); + std::chrono::duration((1.0 / fps) * period_scale)); const auto now = clock::now(); if (next_frame > now) std::this_thread::sleep_until(next_frame); else if (now - next_frame > std::chrono::milliseconds(250)) next_frame = now; @@ -406,8 +523,17 @@ struct Host { static_cast(host.pixel_format)); } - static void audio_sample_callback(std::int16_t, std::int16_t) {} - static std::size_t audio_batch_callback(const std::int16_t*, std::size_t frames) { return frames; } + static void audio_sample_callback(std::int16_t left, std::int16_t right) { + const std::int16_t samples[] = {left, right}; + audio_batch_callback(samples, 1); + } + static std::size_t audio_batch_callback(const std::int16_t* samples, std::size_t frames) { + Host& host = instance(); + if (host.fast_forward.load() || samples == nullptr || frames == 0) return frames; + const auto& converted = host.resampler.process(samples, frames); + host.audio_buffer.push(converted.data(), converted.size() / 2U); + return frames; + } static void input_poll_callback() {} static std::int16_t input_state_callback(unsigned port, unsigned device, unsigned, unsigned id) { if (port != 0 || device != RETRO_DEVICE_JOYPAD) return 0; @@ -437,7 +563,11 @@ std::uint64_t load_rom(const std::string& rom_path, } bool session_command(std::uint64_t session_id, const std::string& command) { - if (command != "run" && command != "pause" && command != "reset" && command != "stop") return false; + const bool known = command == "run" || command == "pause" || command == "reset" || + command == "stop" || command == "mute:on" || command == "mute:off" || + command == "audio_rebuild" || command == "fast:on" || command == "fast:off" || + command.starts_with("volume:"); + if (!known) return false; return Host::instance().enqueue(Command{session_id, command, {}, {}, {}, {}}); } @@ -448,12 +578,46 @@ void set_joypad_mask(std::uint16_t mask) { std::string session_status_json() { Host& host = Host::instance(); std::lock_guard lock(host.mutex); - return "{\"sessionId\":" + std::to_string(host.session_id.load(std::memory_order_acquire)) + - ",\"state\":\"" + session_state_name(host.state.load(std::memory_order_acquire)) + - "\",\"queueDepth\":" + std::to_string(host.commands.size()) + - ",\"completionId\":" + std::to_string(host.completion_id) + - ",\"completion\":\"" + host.completion + - "\",\"error\":\"" + host.error + "\"}"; + const AudioDiagnostics audio = host.audio.diagnostics(); + const TimingSnapshot timing = host.timing.snapshot(monotonic_now_ns()); + std::ostringstream json; + json << "{\"sessionId\":" << host.session_id.load(std::memory_order_acquire) + << ",\"state\":\"" << session_state_name(host.state.load(std::memory_order_acquire)) + << "\",\"queueDepth\":" << host.commands.size() + << ",\"completionId\":" << host.completion_id + << ",\"completion\":\"" << json_escape(host.completion) + << "\",\"error\":\"" << json_escape(host.error) + << "\",\"fastForward\":" << (host.fast_forward.load() ? "true" : "false") + << ",\"audio\":{\"open\":" << (audio.open ? "true" : "false") + << ",\"active\":" << (audio.active ? "true" : "false") + << ",\"muted\":" << (audio.muted ? "true" : "false") + << ",\"gain\":" << audio.gain + << ",\"coreRate\":" << audio.core_sample_rate + << ",\"deviceRate\":" << audio.device_sample_rate + << ",\"framesPerBurst\":" << audio.frames_per_burst + << ",\"framesPerCallback\":" << audio.frames_per_callback + << ",\"maxCallbackFrames\":" << audio.maximum_callback_frames + << ",\"bufferLevel\":" << audio.buffer_level_frames + << ",\"bufferTarget\":" << host.audio_target_frames.load() + << ",\"bufferCapacity\":" << audio.buffer_capacity_frames + << ",\"underrunFrames\":" << audio.underrun_frames + << ",\"overflowFrames\":" << audio.overflow_frames + << ",\"callbacks\":" << audio.callback_count + << ",\"rebuilds\":" << audio.rebuild_count + << ",\"mode\":\"" << json_escape(audio.mode) << "\",\"lastError\":\"" + << json_escape(audio.last_error) << "\"}" + << ",\"timing\":{\"frames\":" << timing.frames + << ",\"simulatedSeconds\":" << timing.simulated_seconds + << ",\"normalSimulatedSeconds\":" << timing.normal_simulated_seconds + << ",\"fastSimulatedSeconds\":" << timing.fast_simulated_seconds + << ",\"normalWallSeconds\":" << timing.normal_wall_seconds + << ",\"fastWallSeconds\":" << timing.fast_wall_seconds + << ",\"pausedWallSeconds\":" << timing.paused_wall_seconds + << ",\"loadWallSeconds\":" << timing.load_wall_seconds + << ",\"speedRatio\":" << timing.speed_ratio + << ",\"averageFrameWorkMs\":" << timing.average_frame_work_ms + << ",\"maximumFrameWorkMs\":" << timing.maximum_frame_work_ms << "}}"; + return json.str(); } bool latest_video_frame(VideoFrame* frame) { diff --git a/app/src/main/cpp/linear_resampler.cpp b/app/src/main/cpp/linear_resampler.cpp new file mode 100644 index 0000000..6207f79 --- /dev/null +++ b/app/src/main/cpp/linear_resampler.cpp @@ -0,0 +1,56 @@ +#include "linear_resampler.h" + +#include +#include + +namespace neslite { +namespace { +constexpr float kInt16Scale = 1.0F / 32768.0F; +} + +void LinearStereoResampler::configure(double input_rate, double output_rate) { + input_rate_ = std::clamp(input_rate, 8000.0, 384000.0); + output_rate_ = std::clamp(output_rate, 8000.0, 384000.0); + reset(); +} + +void LinearStereoResampler::reset() { + next_output_position_ = 0.0; + source_position_ = 0; + previous_left_ = 0.0F; + previous_right_ = 0.0F; + has_previous_ = false; + output_.clear(); +} + +const std::vector& LinearStereoResampler::process(const std::int16_t* input, std::size_t frames) { + output_.clear(); + if (input == nullptr || frames == 0) return output_; + output_.reserve(static_cast( + std::ceil(static_cast(frames) * output_rate_ / input_rate_) + 2.0) * 2U); + const double source_step = input_rate_ / output_rate_; + for (std::size_t frame = 0; frame < frames; ++frame) { + const float left = static_cast(input[frame * 2U]) * kInt16Scale; + const float right = static_cast(input[frame * 2U + 1U]) * kInt16Scale; + if (!has_previous_) { + previous_left_ = left; + previous_right_ = right; + has_previous_ = true; + } + const double current_position = static_cast(source_position_); + const double previous_position = source_position_ == 0 ? 0.0 : current_position - 1.0; + while (next_output_position_ <= current_position) { + const float fraction = source_position_ == 0 ? 0.0F : static_cast( + std::clamp(next_output_position_ - previous_position, 0.0, 1.0)); + output_.push_back(previous_left_ + (left - previous_left_) * fraction); + output_.push_back(previous_right_ + (right - previous_right_) * fraction); + next_output_position_ += source_step; + } + previous_left_ = left; + previous_right_ = right; + ++source_position_; + } + return output_; +} + +} // namespace neslite diff --git a/app/src/main/cpp/linear_resampler.h b/app/src/main/cpp/linear_resampler.h new file mode 100644 index 0000000..dd42186 --- /dev/null +++ b/app/src/main/cpp/linear_resampler.h @@ -0,0 +1,29 @@ +#pragma once + +#include +#include +#include + +namespace neslite { + +class LinearStereoResampler { + public: + void configure(double input_rate, double output_rate); + void reset(); + const std::vector& process(const std::int16_t* interleaved_stereo, std::size_t frames); + + double input_rate() const { return input_rate_; } + double output_rate() const { return output_rate_; } + + private: + double input_rate_ = 48000.0; + double output_rate_ = 48000.0; + double next_output_position_ = 0.0; + std::uint64_t source_position_ = 0; + float previous_left_ = 0.0F; + float previous_right_ = 0.0F; + bool has_previous_ = false; + std::vector output_; +}; + +} // namespace neslite diff --git a/app/src/main/cpp/session_rules.cpp b/app/src/main/cpp/session_rules.cpp index 07a7d5b..478a74e 100644 --- a/app/src/main/cpp/session_rules.cpp +++ b/app/src/main/cpp/session_rules.cpp @@ -1,5 +1,7 @@ #include "session_rules.h" +#include + namespace neslite { const char* session_state_name(SessionState state) { @@ -34,4 +36,14 @@ bool required_host_capabilities_available(unsigned core_api_version, unsigned ex return core_api_version == expected_api_version && directories_available; } +double scheduler_period_scale(std::size_t buffer_level, std::size_t target_level, + bool audio_active, bool fast_forward) { + if (fast_forward) return 0.5; + if (!audio_active || target_level == 0) return 1.0; + const double normalized_error = + (static_cast(buffer_level) - static_cast(target_level)) / + static_cast(target_level); + return 1.0 + std::clamp(normalized_error * 0.01, -0.02, 0.02); +} + } // namespace neslite diff --git a/app/src/main/cpp/session_rules.h b/app/src/main/cpp/session_rules.h index f287aba..0b22e2c 100644 --- a/app/src/main/cpp/session_rules.h +++ b/app/src/main/cpp/session_rules.h @@ -1,5 +1,6 @@ #pragma once +#include #include #include @@ -12,5 +13,7 @@ bool command_allowed(SessionState state, std::string_view command); bool command_targets_active_session(std::uint64_t active_session, std::uint64_t command_session); bool required_host_capabilities_available(unsigned core_api_version, unsigned expected_api_version, bool directories_available); +double scheduler_period_scale(std::size_t buffer_level, std::size_t target_level, + bool audio_active, bool fast_forward); } // namespace neslite diff --git a/app/src/main/cpp/tests/native_smoke_test.cpp b/app/src/main/cpp/tests/native_smoke_test.cpp index 3c3db06..5900325 100644 --- a/app/src/main/cpp/tests/native_smoke_test.cpp +++ b/app/src/main/cpp/tests/native_smoke_test.cpp @@ -1,7 +1,12 @@ +#include "audio_ring_buffer.h" +#include "linear_resampler.h" #include "native_smoke.h" #include "session_rules.h" +#include "timing_metrics.h" #include "video_buffer.h" +#include + int main() { using neslite::SessionState; if (neslite::native_protocol_version() != neslite::kNativeProtocolVersion) return 1; @@ -27,5 +32,57 @@ int main() { const unsigned char replacement[] = {9, 10, 11, 12}; if (!video.submit(replacement, 2, 1, 4, 2, 2)) return 14; if (!video.latest(&frame) || frame.sequence != first_sequence + 1 || frame.height != 1) return 15; + + neslite::AudioRingBuffer ring(4); + const float audio_in[] = {0.5F, -0.5F, 0.25F, -0.25F, 1.0F, -1.0F}; + if (ring.push(audio_in, 3) != 3 || ring.level_frames() != 3) return 19; + float audio_out[8]{}; + if (ring.pop(audio_out, 2, 0.5F, false) != 2) return 20; + if (std::abs(audio_out[0] - 0.25F) > 0.0001F || ring.level_frames() != 1) return 21; + if (ring.push(audio_in, 3) != 3 || ring.level_frames() != 4) return 22; + float wrapped_out[12]{}; + if (ring.pop(wrapped_out, 6, 1.0F, false) != 4 || ring.underrun_frames() != 2) return 23; + if (wrapped_out[8] != 0.0F || wrapped_out[10] != 0.0F) return 24; + if (ring.push(audio_in, 3) != 3) return 25; + float muted_out[6]{}; + if (ring.pop(muted_out, 3, 1.0F, true) != 3 || muted_out[0] != 0.0F) return 26; + const float overflow_in[12]{}; + if (ring.push(overflow_in, 6) != 4 || ring.overflow_frames() != 2) return 27; + + neslite::LinearStereoResampler resampler; + const std::int16_t pcm[] = {0, 0, 16384, -16384, 32767, -32768}; + resampler.configure(48000.0, 48000.0); + const auto same_rate = resampler.process(pcm, 3); + if (same_rate.size() != 6 || std::abs(same_rate[2] - 0.5F) > 0.0001F) return 28; + resampler.configure(24000.0, 48000.0); + const auto first_resampled = resampler.process(pcm, 2); + if (first_resampled.size() != 6 || std::abs(first_resampled[2] - 0.25F) > 0.0001F) return 29; + const float previous_resampled_left = first_resampled[4]; + const auto second_resampled = resampler.process(pcm + 4, 1); + if (second_resampled.size() != 4 || second_resampled[0] <= previous_resampled_left) return 30; + resampler.configure(48000.0, 44100.0); + std::int16_t long_pcm[960]{}; + if (resampler.process(long_pcm, 480).size() / 2U != 441U) return 31; + + neslite::TimingMetrics metrics; + metrics.reset(0); + metrics.record_load(500'000'000); + metrics.transition(neslite::TimingMode::Normal, 0); + metrics.record_frame(1.0, 2'000'000); + metrics.transition(neslite::TimingMode::Fast, 1'000'000'000); + metrics.record_frame(2.0, 4'000'000); + metrics.transition(neslite::TimingMode::Paused, 2'000'000'000); + const auto measured = metrics.snapshot(3'000'000'000); + if (measured.frames != 2 || std::abs(measured.speed_ratio - 1.5) > 0.0001) return 32; + if (std::abs(measured.normal_simulated_seconds - 1.0) > 0.0001 || + std::abs(measured.fast_simulated_seconds - 2.0) > 0.0001) return 39; + if (std::abs(measured.paused_wall_seconds - 1.0) > 0.0001 || + std::abs(measured.load_wall_seconds - 0.5) > 0.0001) return 33; + if (std::abs(measured.average_frame_work_ms - 3.0) > 0.0001 || + std::abs(measured.maximum_frame_work_ms - 4.0) > 0.0001) return 34; + if (std::abs(neslite::scheduler_period_scale(0, 100, false, false) - 1.0) > 0.0001) return 35; + if (neslite::scheduler_period_scale(0, 100, true, false) >= 1.0) return 36; + if (neslite::scheduler_period_scale(200, 100, true, false) <= 1.0) return 37; + if (std::abs(neslite::scheduler_period_scale(100, 100, true, true) - 0.5) > 0.0001) return 38; return 0; } diff --git a/app/src/main/cpp/timing_metrics.cpp b/app/src/main/cpp/timing_metrics.cpp new file mode 100644 index 0000000..e463655 --- /dev/null +++ b/app/src/main/cpp/timing_metrics.cpp @@ -0,0 +1,83 @@ +#include "timing_metrics.h" + +#include +#include + +namespace neslite { +namespace { +constexpr double kNanosPerSecond = 1'000'000'000.0; +constexpr std::size_t kFrameWindow = 240; +} + +void TimingMetrics::reset(std::int64_t now_ns) { + std::lock_guard lock(mutex_); + mode_ = TimingMode::Paused; + mode_started_ns_ = now_ns; + frames_ = 0; + simulated_seconds_ = 0.0; + normal_simulated_seconds_ = 0.0; + fast_simulated_seconds_ = 0.0; + normal_wall_ns_ = fast_wall_ns_ = paused_wall_ns_ = load_wall_ns_ = 0; + frame_work_ns_.clear(); +} + +void TimingMetrics::accrue_locked(std::int64_t now_ns) { + const std::int64_t elapsed = std::max(0, now_ns - mode_started_ns_); + if (mode_ == TimingMode::Normal) normal_wall_ns_ += elapsed; + else if (mode_ == TimingMode::Fast) fast_wall_ns_ += elapsed; + else paused_wall_ns_ += elapsed; + mode_started_ns_ = now_ns; +} + +void TimingMetrics::transition(TimingMode mode, std::int64_t now_ns) { + std::lock_guard lock(mutex_); + accrue_locked(now_ns); + mode_ = mode; +} + +void TimingMetrics::record_load(std::int64_t duration_ns) { + std::lock_guard lock(mutex_); + load_wall_ns_ += std::max(0, duration_ns); +} + +void TimingMetrics::record_frame(double simulated_seconds, std::int64_t work_duration_ns) { + std::lock_guard lock(mutex_); + ++frames_; + const double elapsed = std::max(0.0, simulated_seconds); + simulated_seconds_ += elapsed; + if (mode_ == TimingMode::Normal) normal_simulated_seconds_ += elapsed; + else if (mode_ == TimingMode::Fast) fast_simulated_seconds_ += elapsed; + frame_work_ns_.push_back(std::max(0, work_duration_ns)); + if (frame_work_ns_.size() > kFrameWindow) frame_work_ns_.pop_front(); +} + +TimingSnapshot TimingMetrics::snapshot(std::int64_t now_ns) const { + std::lock_guard lock(mutex_); + std::int64_t normal = normal_wall_ns_; + std::int64_t fast = fast_wall_ns_; + std::int64_t paused = paused_wall_ns_; + const std::int64_t current = std::max(0, now_ns - mode_started_ns_); + if (mode_ == TimingMode::Normal) normal += current; + else if (mode_ == TimingMode::Fast) fast += current; + else paused += current; + const auto total_work = std::accumulate(frame_work_ns_.begin(), frame_work_ns_.end(), std::int64_t{0}); + const auto maximum_work = frame_work_ns_.empty() ? 0 : + *std::max_element(frame_work_ns_.begin(), frame_work_ns_.end()); + TimingSnapshot result; + result.frames = frames_; + result.simulated_seconds = simulated_seconds_; + result.normal_simulated_seconds = normal_simulated_seconds_; + result.fast_simulated_seconds = fast_simulated_seconds_; + result.normal_wall_seconds = static_cast(normal) / kNanosPerSecond; + result.fast_wall_seconds = static_cast(fast) / kNanosPerSecond; + result.paused_wall_seconds = static_cast(paused) / kNanosPerSecond; + result.load_wall_seconds = static_cast(load_wall_ns_) / kNanosPerSecond; + const double active_seconds = result.normal_wall_seconds + result.fast_wall_seconds; + result.speed_ratio = active_seconds > 0.0 ? simulated_seconds_ / active_seconds : 0.0; + result.average_frame_work_ms = frame_work_ns_.empty() ? 0.0 : + static_cast(total_work) / static_cast(frame_work_ns_.size()) / 1'000'000.0; + result.maximum_frame_work_ms = static_cast(maximum_work) / 1'000'000.0; + return result; +} + +} // namespace neslite diff --git a/app/src/main/cpp/timing_metrics.h b/app/src/main/cpp/timing_metrics.h new file mode 100644 index 0000000..c384005 --- /dev/null +++ b/app/src/main/cpp/timing_metrics.h @@ -0,0 +1,50 @@ +#pragma once + +#include +#include +#include + +namespace neslite { + +enum class TimingMode { Paused, Normal, Fast }; + +struct TimingSnapshot { + std::uint64_t frames = 0; + double simulated_seconds = 0.0; + double normal_simulated_seconds = 0.0; + double fast_simulated_seconds = 0.0; + double normal_wall_seconds = 0.0; + double fast_wall_seconds = 0.0; + double paused_wall_seconds = 0.0; + double load_wall_seconds = 0.0; + double speed_ratio = 0.0; + double average_frame_work_ms = 0.0; + double maximum_frame_work_ms = 0.0; +}; + +class TimingMetrics { + public: + void reset(std::int64_t now_ns); + void transition(TimingMode mode, std::int64_t now_ns); + void record_load(std::int64_t duration_ns); + void record_frame(double simulated_seconds, std::int64_t work_duration_ns); + TimingSnapshot snapshot(std::int64_t now_ns) const; + + private: + void accrue_locked(std::int64_t now_ns); + + mutable std::mutex mutex_; + TimingMode mode_ = TimingMode::Paused; + std::int64_t mode_started_ns_ = 0; + std::uint64_t frames_ = 0; + double simulated_seconds_ = 0.0; + double normal_simulated_seconds_ = 0.0; + double fast_simulated_seconds_ = 0.0; + std::int64_t normal_wall_ns_ = 0; + std::int64_t fast_wall_ns_ = 0; + std::int64_t paused_wall_ns_ = 0; + std::int64_t load_wall_ns_ = 0; + std::deque frame_work_ns_; +}; + +} // namespace neslite diff --git a/app/src/main/java/org/neslite/app/MainActivity.kt b/app/src/main/java/org/neslite/app/MainActivity.kt index 120393e..af3447f 100644 --- a/app/src/main/java/org/neslite/app/MainActivity.kt +++ b/app/src/main/java/org/neslite/app/MainActivity.kt @@ -1,6 +1,11 @@ package org.neslite.app import android.content.Context +import android.media.AudioAttributes +import android.media.AudioDeviceCallback +import android.media.AudioDeviceInfo +import android.media.AudioFocusRequest +import android.media.AudioManager import android.hardware.input.InputManager import android.net.Uri import android.os.Bundle @@ -11,10 +16,12 @@ import android.text.method.ScrollingMovementMethod import android.view.InputDevice import android.view.KeyEvent import android.view.MotionEvent +import android.view.View import android.view.ViewGroup import android.widget.Button import android.widget.LinearLayout import android.widget.ScrollView +import android.widget.SeekBar import android.widget.TextView import android.widget.Toast import androidx.activity.ComponentActivity @@ -52,8 +59,24 @@ class MainActivity : ComponentActivity(), InputManager.InputDeviceListener { private lateinit var gameList: LinearLayout private lateinit var emulatorSurface: EmulatorSurface private lateinit var emulatorStatus: TextView + private lateinit var audioStatus: TextView + private lateinit var audioManager: AudioManager + private lateinit var audioFocusRequest: AudioFocusRequest private var activeSessionId = 0L private var joypadMask = 0 + private var muted = false + private var audioDeviceCallbackRegistered = false + + private val audioFocusListener = AudioManager.OnAudioFocusChangeListener { focusChange -> + if (focusChange != AudioManager.AUDIOFOCUS_GAIN) { + mainHandler.post { pauseForExternalReason("audio_focus_lost") } + } + } + + private val audioDeviceCallback = object : AudioDeviceCallback() { + override fun onAudioDevicesAdded(addedDevices: Array) = rebuildAudioForRoute() + override fun onAudioDevicesRemoved(removedDevices: Array) = rebuildAudioForRoute() + } private val createDocument = registerForActivityResult( ActivityResultContracts.CreateDocument("application/json"), @@ -68,6 +91,16 @@ class MainActivity : ComponentActivity(), InputManager.InputDeviceListener { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) inputManager = getSystemService(Context.INPUT_SERVICE) as InputManager + audioManager = getSystemService(Context.AUDIO_SERVICE) as AudioManager + audioFocusRequest = AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN) + .setAudioAttributes( + AudioAttributes.Builder() + .setUsage(AudioAttributes.USAGE_GAME) + .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC) + .build(), + ) + .setOnAudioFocusChangeListener(audioFocusListener, mainHandler) + .build() nativeProbe = probeNative() baseline = DeviceDiagnostics.collectBaseline(this, nativeProbe.pageSizeBytes) database = GameDatabase.get(this) @@ -83,10 +116,17 @@ class MainActivity : ComponentActivity(), InputManager.InputDeviceListener { inputManager.registerInputDeviceListener(this, null) refreshControllers() if (::emulatorSurface.isInitialized) emulatorSurface.onResume() + audioManager.registerAudioDeviceCallback(audioDeviceCallback, mainHandler) + audioDeviceCallbackRegistered = true } override fun onStop() { - if (activeSessionId != 0L) NativeBridge.command(activeSessionId, "pause") + pauseForExternalReason("activity_stopped") + audioManager.abandonAudioFocusRequest(audioFocusRequest) + if (audioDeviceCallbackRegistered) { + audioManager.unregisterAudioDeviceCallback(audioDeviceCallback) + audioDeviceCallbackRegistered = false + } NativeBridge.setJoypadMask(0) joypadMask = 0 if (::emulatorSurface.isInitialized) emulatorSurface.onPause() @@ -109,9 +149,7 @@ class MainActivity : ComponentActivity(), InputManager.InputDeviceListener { override fun onWindowFocusChanged(hasFocus: Boolean) { super.onWindowFocusChanged(hasFocus) if (!hasFocus && ::stateText.isInitialized) { - NativeBridge.setJoypadMask(0) - joypadMask = 0 - if (activeSessionId != 0L) NativeBridge.command(activeSessionId, "pause") + pauseForExternalReason("window_focus_lost") inputDiagnostics.clearAll("focus_lost", SystemClock.uptimeMillis()) renderInputState() } @@ -129,9 +167,7 @@ class MainActivity : ComponentActivity(), InputManager.InputDeviceListener { } override fun onInputDeviceRemoved(deviceId: Int) { - NativeBridge.setJoypadMask(0) - joypadMask = 0 - if (activeSessionId != 0L) NativeBridge.command(activeSessionId, "pause") + pauseForExternalReason("controller_removed") inputDiagnostics.clearDevice( deviceId, "device_removed", @@ -210,7 +246,7 @@ class MainActivity : ComponentActivity(), InputManager.InputDeviceListener { setPadding(32, 32, 32, 48) addView(title(getString(R.string.diagnostics_title))) addView(body(getString(R.string.diagnostics_instructions))) - addView(section("M2 游戏库与基础运行")) + addView(section("M3 游戏库、音画与快进")) addView( Button(context).apply { text = "从文件导入 iNES / NES 2.0 ROM" @@ -237,13 +273,52 @@ class MainActivity : ComponentActivity(), InputManager.InputDeviceListener { ).forEach { (label, command) -> addView(Button(context).apply { text = label - setOnClickListener { - if (activeSessionId != 0L) NativeBridge.command(activeSessionId, command) - } + setOnClickListener { sendControlCommand(command) } }) } }, ) + addView( + LinearLayout(context).apply { + orientation = LinearLayout.HORIZONTAL + addView(Button(context).apply { + text = "静音:关" + setOnClickListener { + muted = !muted + text = if (muted) "静音:开" else "静音:关" + sendControlCommand(if (muted) "mute:on" else "mute:off") + } + }) + addView(Button(context).apply { + text = "按住 2× 快进" + setOnClickListener { } + setOnTouchListener { view, event -> + when (event.actionMasked) { + MotionEvent.ACTION_DOWN -> sendControlCommand("fast:on") + MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> { + sendControlCommand("fast:off") + if (event.actionMasked == MotionEvent.ACTION_UP) view.performClick() + } + } + true + } + }) + }, + ) + addView(body("音量")) + addView(SeekBar(context).apply { + max = 100 + progress = 100 + setOnSeekBarChangeListener(object : SeekBar.OnSeekBarChangeListener { + override fun onProgressChanged(seekBar: SeekBar?, progress: Int, fromUser: Boolean) {} + override fun onStartTrackingTouch(seekBar: SeekBar?) {} + override fun onStopTrackingTouch(seekBar: SeekBar?) { + sendControlCommand("volume:${(seekBar?.progress ?: 100) / 100.0f}") + } + }) + }) + audioStatus = body("音频:等待 ROM;重新获得焦点后需手动继续") + addView(audioStatus) addView( Button(context).apply { text = "缩放:4:3(点按切换整数像素)" @@ -424,11 +499,47 @@ class MainActivity : ComponentActivity(), InputManager.InputDeviceListener { private fun pollSessionStatus() { if (::emulatorStatus.isInitialized && activeSessionId != 0L) { - emulatorStatus.text = NativeBridge.sessionStatus() + val raw = NativeBridge.sessionStatus() + runCatching { JSONObject(raw) }.onSuccess { status -> + emulatorStatus.text = "状态:${status.optString("state")} · ${status.optString("completion")}" + + if (status.optBoolean("fastForward")) " · 2×" else "" + val audio = status.optJSONObject("audio") ?: JSONObject() + val timing = status.optJSONObject("timing") ?: JSONObject() + audioStatus.text = "音频:${audio.optString("mode")},核心/设备 ${audio.optInt("coreRate")}/${audio.optInt("deviceRate")} Hz\n" + + "回调 ${audio.optLong("callbacks")},帧/回调 ${audio.optInt("maxCallbackFrames")},缓冲 ${audio.optInt("bufferLevel")}/${audio.optInt("bufferTarget")}/${audio.optInt("bufferCapacity")},欠载 ${audio.optLong("underrunFrames")},重建 ${audio.optLong("rebuilds")}\n" + + "速度 ${String.format(Locale.ROOT, "%.3f", timing.optDouble("speedRatio"))}×,模拟帧 ${timing.optLong("frames")},帧工作 ${String.format(Locale.ROOT, "%.2f", timing.optDouble("averageFrameWorkMs"))}/${String.format(Locale.ROOT, "%.2f", timing.optDouble("maximumFrameWorkMs"))} ms" + }.onFailure { emulatorStatus.text = raw } } mainHandler.postDelayed(::pollSessionStatus, 250) } + private fun sendControlCommand(command: String) { + if (activeSessionId == 0L) return + if (command == "run" && audioManager.requestAudioFocus(audioFocusRequest) != AudioManager.AUDIOFOCUS_REQUEST_GRANTED) { + emulatorStatus.text = "音频焦点未获准,游戏保持暂停" + return + } + NativeBridge.command(activeSessionId, command) + if (command == "pause" || command == "stop") { + audioManager.abandonAudioFocusRequest(audioFocusRequest) + } + } + + private fun pauseForExternalReason(reason: String) { + NativeBridge.setJoypadMask(0) + joypadMask = 0 + if (activeSessionId != 0L) { + NativeBridge.command(activeSessionId, "pause") + } + if (::audioStatus.isInitialized) audioStatus.text = "已安全暂停:$reason;请手动继续" + } + + private fun rebuildAudioForRoute() { + if (activeSessionId == 0L) return + pauseForExternalReason("audio_route_changed") + NativeBridge.command(activeSessionId, "audio_rebuild") + } + private fun joypadBitForKey(keyCode: Int): Int? = when (keyCode) { KeyEvent.KEYCODE_DPAD_UP -> 4 KeyEvent.KEYCODE_DPAD_DOWN -> 5 @@ -466,6 +577,11 @@ class MainActivity : ComponentActivity(), InputManager.InputDeviceListener { ) .put("device", baseline.toJson()) .put("controllers", JSONArray().apply { controllers.forEach { put(it.toJson()) } }) + .put( + "session", + if (activeSessionId == 0L) JSONObject.NULL else + (runCatching { JSONObject(NativeBridge.sessionStatus()) }.getOrNull() ?: JSONObject.NULL), + ) .put("eventCapacity", InputDiagnostics.DEFAULT_CAPACITY) .put("events", DiagnosticEventJson.toJsonArray(inputDiagnostics.recordedEvents())) diff --git a/app/src/test/java/org/neslite/app/BuildIdentityTest.kt b/app/src/test/java/org/neslite/app/BuildIdentityTest.kt index c79f63a..1370ca7 100644 --- a/app/src/test/java/org/neslite/app/BuildIdentityTest.kt +++ b/app/src/test/java/org/neslite/app/BuildIdentityTest.kt @@ -7,7 +7,7 @@ class BuildIdentityTest { @Test fun debugBuildUsesTheDocumentedIdentity() { assertEquals("org.neslite.app.debug", BuildConfig.APPLICATION_ID) - assertEquals("0.2.4-debug", BuildConfig.VERSION_NAME) - assertEquals(2004, BuildConfig.VERSION_CODE) + assertEquals("0.3.4-debug", BuildConfig.VERSION_NAME) + assertEquals(3004, BuildConfig.VERSION_CODE) } } diff --git a/docs/architecture.md b/docs/architecture.md index 0b201da..657ab2e 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -1,11 +1,12 @@ -# NESLite 架构(M2 基线) +# NESLite 架构(M3 基线) ## 边界与线程 界面层只负责系统文件选择器、游戏列表、控制按钮、手柄事件和 GL Surface。ROM 的 `content://` 地址只在 Kotlin 导入层使用;导入完成后,原生层仅收到应用私有目录中的绝对文件路径。 -FCEUmm 由一个原生工作线程独占。JNI 调用只向容量 32 的命令队列写入 `load/run/pause/reset/stop` +FCEUmm 由一个原生工作线程独占。JNI 调用只向容量 32 的命令队列写入 +`load/run/pause/reset/stop/mute/volume/audio_rebuild/fast` 命令,命令携带单调递增的会话号。旧会话、重复命令和当前状态不允许的命令不会触碰内核,并在 状态快照的完成通知中报告 `stale` 或 `ignored`。状态集合固定为 Idle、Loading、Paused、 Running、Pausing、Stopping 和 Error。 @@ -36,8 +37,26 @@ iNES/NES 2.0 魔数并计算完整文件 SHA-256;提交文件为 `files/roms/< 明确不支持的请求作为加载必要条件。 加载、`retro_run`、重置、卸载和保存内存访问均在内核线程执行。时序来自 -`retro_get_system_av_info`,以 `steady_clock` 调度;M2 完整消费音频回调并返回已消费帧数,但按阶段 -要求暂不发声。 +`retro_get_system_av_info`,以 `steady_clock` 调度;M3 在此边界内把核心音频转换并送往输出线程。 + +## 音频、时钟与快进 + +固定 Oboe 1.10.0 源码由 `app/src/main/cpp/cmake/oboe.cmake` 引入。打开顺序为独占低延迟、共享低延迟、 +共享安全模式;每次都检查实际 float/stereo 格式、采样率、burst 和 callback 参数。全部失败时保持 +内核的单调时钟调度,不因没有音频而无限追帧。 + +FCEUmm 的 int16 stereo 数据先经跨批次连续的线性重采样转成设备实际采样率,再写入 4096 帧 SPSC +环形缓冲。Oboe 回调只操作预分配内存和原子计数:正常取样、应用 0~1 增益,欠载补零,满缓冲丢弃 +新数据并计数;不加锁、不分配、不记录文件。暂停、失焦和快进转换均停止输出并清空旧缓冲。 + +正常速度由 `steady_clock`、核心 FPS 和缓冲水位的 ±2% 有界校正共同调度;音频不可用时只使用单调 +时钟;目标水位按设备采样率折算为约一个模拟帧并限制在安全范围。计时器分别累计加载、暂停、正常和快进时间,并保留最多 240 个帧工作耗时样本的平均值与 +最大值。按住快进使用 2× 周期并静音;释放时清缓冲、重置重采样和时钟基线,再恢复正常输出。 + +Android 音频焦点丢失会暂停并清输入,重新获得焦点不会自行继续。音频设备增删或 Oboe +`Disconnected` 由内核线程关闭并按上述回退顺序重建,成功或失败都停在 Paused,防止旧会话回调 +复活。状态 JSON 展示核心/设备采样率、callback/burst、缓冲水位、欠载/溢出、重建次数、速度和帧 +时间;诊断只存计数与固定窗口。 ## 视频、输入和电池存档 diff --git a/docs/build.md b/docs/build.md index 1b7fa5f..fbad5b6 100644 --- a/docs/build.md +++ b/docs/build.md @@ -1,6 +1,6 @@ # NESLite 可复现构建说明 -本说明对应 M0~M2 基线。命令使用系统默认 PowerShell 7.6.6(`pwsh`)从仓库根目录执行;不需要手工复制 `.so`、 +本说明对应 M0~M3 基线。命令使用系统默认 PowerShell 7.6.6(`pwsh`)从仓库根目录执行;不需要手工复制 `.so`、 FCEUmm 或 Oboe 文件。 ## 前置条件 @@ -17,7 +17,7 @@ FCEUmm 或 Oboe 文件。 .\tools\fetch-third-party.ps1 ``` - 该脚本根据 `third_party/manifest.json` 检出固定提交;M2 构建需要 FCEUmm 与 libretro headers。 + 该脚本根据 `third_party/manifest.json` 检出固定提交;M3 构建需要 FCEUmm、libretro headers 与 Oboe。 ## 构建调试 APK diff --git a/docs/dependencies.md b/docs/dependencies.md index 23e568a..87ffa33 100644 --- a/docs/dependencies.md +++ b/docs/dependencies.md @@ -12,11 +12,11 @@ Gradle 版本锁见 [gradle/libs.versions.toml](../gradle/libs.versions.toml)。 | JUnit | 4.13.2 | Maven Central | EPL-1.0;测试依赖,不打入生产 APK | M0 使用 | | JSON-java | 20240303 | Maven Central | Public Domain;仅用于 JVM 测试,不打入生产 APK | M1 使用 | | AndroidX test/Espresso | 1.3.0/3.7.0 | Google Maven | Apache-2.0;测试依赖,不打入生产 APK | M0 使用 | -| Room | 2.7.2 | Google Maven | Apache-2.0;后续 APK notices | M2 预锁定 | +| Room | 2.7.2 | Google Maven | Apache-2.0;保留 notices | M2 使用 | | DataStore | 1.1.7 | Google Maven | Apache-2.0;后续 APK notices | M4/M6 预锁定 | -| FCEUmm | `236ccdfc911e84c60fea6b9d0699c2d440a8de14` | `tools/fetch-third-party.ps1` | GPL-2.0-only;交付完整对应源码、COPYING、修改说明 | M2 预锁定 | -| libretro.h | `0c9622896333ee62dc4326bbe8784a210ddeb03c` | `tools/fetch-third-party.ps1` | MIT;保留版权及许可 | M2 预锁定 | -| Oboe | 1.10.0 / `a81bb9f87d4105b84b682685d3bfbb5beca371d1` | `tools/fetch-third-party.ps1` | Apache-2.0;保留 notices | M3 预锁定 | +| FCEUmm | `236ccdfc911e84c60fea6b9d0699c2d440a8de14` | `tools/fetch-third-party.ps1` | GPL-2.0-only;交付完整对应源码、COPYING、修改说明 | M2 使用 | +| libretro.h | `0c9622896333ee62dc4326bbe8784a210ddeb03c` | `tools/fetch-third-party.ps1` | MIT;保留版权及许可 | M2 使用 | +| Oboe | 1.10.0 / `a81bb9f87d4105b84b682685d3bfbb5beca371d1` | `tools/fetch-third-party.ps1` | Apache-2.0;保留 notices | M3 使用 | 本项目计划静态链接 GPL-2.0-only 的 FCEUmm;因此将应用和可分发的对应源码按 GPL-2.0-only 处理。发布前必须由发行负责人核对依赖的实际引入图、完整许可文本、版权声明、 diff --git a/docs/identity.md b/docs/identity.md index 9dee53a..6cbc1c7 100644 --- a/docs/identity.md +++ b/docs/identity.md @@ -6,7 +6,7 @@ | --- | --- | | 显示名称 | `NESLite` | | 正式 application ID/namespace | `org.neslite.app` | -| 当前开发版本 | `0.2.4`,`versionCode = 2004` | +| 当前开发版本 | `0.3.4`,`versionCode = 3004` | | 调试 application ID | `org.neslite.app.debug` | | 发布 ABI | `arm64-v8a` | | min/target SDK | 28/36 | diff --git a/docs/reports/m3-audio.md b/docs/reports/m3-audio.md new file mode 100644 index 0000000..7a71066 --- /dev/null +++ b/docs/reports/m3-audio.md @@ -0,0 +1,35 @@ +# M3 音频、时钟与快进记录 + +日期:2026-09-12 +构建:`org.neslite.app.debug`,`0.3.4-debug`,versionCode 3004,arm64-v8a + +## 已实现 + +- 固定 Oboe 1.10.0(`a81bb9f87d4105b84b682685d3bfbb5beca371d1`)从源码静态链接;依次尝试 + 独占低延迟、共享低延迟和共享安全输出,记录实际参数,全部失败时保留单调时钟运行路径。 +- 4096 帧 SPSC stereo float 环形缓冲,目标水位约一个模拟帧;回调仅取样、增益/静音和原子计数, + 欠载补零、满缓冲丢新帧。 +- int16 stereo 到实际设备采样率的连续线性重采样,状态跨 libretro 批次保留。 +- 以核心 FPS 和 `steady_clock` 为基准、音频水位 ±2% 修正的正常调度;音频不可用与静音不改变目标 + 速度。计时分离加载、暂停、正常与快进,帧工作耗时窗口固定 240 项。 +- UI 提供音量、静音和按住 2× 静音快进;暂停/释放/失焦/断柄/退出清旧音频并取消快进。 +- Android 音频焦点丢失安全暂停,重新获得焦点不自动继续;路由增删和 Oboe 断开由内核线程重建, + 成功或失败均停在 Paused,可再次触发重建。 +- 状态及诊断导出包含核心/设备采样率、burst、callback、缓冲水位、欠载/溢出、重建次数、速度和 + 帧时间。 + +## 本地验证 + +- `tools/check.ps1 -Scope Stage`:APK、Windows 原生 smoke test 和 JVM 测试全部通过。 +- 原生测试覆盖环形缓冲空/满/环绕、增益/静音/欠载,48→48、24→48、48→44.1 kHz 重采样及跨 + 批次连续性,无音频/低水位/高水位/2× 调度分支,以及加载/暂停/快进计时分离。 +- `:app:testDebugUnitTest`:12 项通过;Android lint:0 错误、26 个非阻断警告。 +- 调试 APK:`app/build/outputs/apk/debug/app-debug.apk`,19,892,293 字节,SHA-256 + `3904B93CF45D697518D556BE754CFC3BCB76A54826EB418A29E306B53478EE8F`;包内仅含目标 ABI 的 + `lib/arm64-v8a/libneslite_jni.so`。 + +## 尚未形成门槛证据 + +当前没有已授权目标手机,也没有已登记合法 NTSC/PAL ROM。因而实际扬声器声音、Oboe 回退、音量/ +静音组合、音频焦点、真实路由切换、断开后重建、NTSC/PAL 同轮速度及 30 分钟 H-AV 尚未执行。 +G1/G2 未通过也阻止进入 G3;`todo.md` 中 M3 项与 G3 保持未勾选。 diff --git a/docs/toolchain.md b/docs/toolchain.md index 5c1c52d..cd4103e 100644 --- a/docs/toolchain.md +++ b/docs/toolchain.md @@ -29,11 +29,11 @@ NDK 与 CMake。该提示不改变产物使用的具体版本,后续升级 SDK | --- | --- | --- | --- | --- | | AndroidX Core KTX | 1.17.0 | Google Maven | Apache-2.0 | M0 已引入 | | AndroidX Activity KTX | 1.12.0 | Google Maven | Apache-2.0 | M0 已引入 | -| Room | 2.7.2 | Google Maven | Apache-2.0 | 为 M2 锁定,尚未引入 | +| Room | 2.7.2 | Google Maven | Apache-2.0 | M2 已引入 | | DataStore Preferences | 1.1.7 | Google Maven | Apache-2.0 | 为 M4/M6 锁定,尚未引入 | -| FCEUmm | `236ccdfc911e84c60fea6b9d0699c2d440a8de14` | `libretro/libretro-fceumm` | GPL-2.0-only | 为 M2 锁定,尚未编译 | -| libretro.h | `0c9622896333ee62dc4326bbe8784a210ddeb03c` | `libretro/RetroArch` | MIT | 为 M2 锁定,尚未引入 | -| Oboe | tag `1.10.0`, commit `a81bb9f87d4105b84b682685d3bfbb5beca371d1` | `google/oboe` | Apache-2.0 | 为 M3 锁定,尚未引入 | +| FCEUmm | `236ccdfc911e84c60fea6b9d0699c2d440a8de14` | `libretro/libretro-fceumm` | GPL-2.0-only | M2 已编译并静态链接 | +| libretro.h | `0c9622896333ee62dc4326bbe8784a210ddeb03c` | `libretro/RetroArch` | MIT | M2 已引入 | +| Oboe | tag `1.10.0`, commit `a81bb9f87d4105b84b682685d3bfbb5beca371d1` | `google/oboe` | Apache-2.0 | M3 已编译并静态链接 | 详细的 Git 来源和补丁数组由 [third_party/manifest.json](../third_party/manifest.json) 作为机器可读 锁文件保存。依赖获取执行 `tools/fetch-third-party.ps1`;这个脚本只检出固定提交,检测到已有 diff --git a/todo.md b/todo.md index f9c5ef2..454dc15 100644 --- a/todo.md +++ b/todo.md @@ -139,6 +139,11 @@ ROM 样本,因此所有需要 L2/L3 的 M2 项和 G2 继续保持未勾选, ### M3/0.3.x:音频、时钟与快进 +状态(2026-09-12):以下项目的隔离实现已进入 `0.3.4-debug`,Oboe arm64 链接、原生边界测试、 +JVM 测试和 lint 通过,详见 `docs/reports/m3-audio.md`。依照阶段门规则,G1/G2 尚未通过且没有 +目标手机/ROM,因此音频设备、焦点、路由、NTSC/PAL 速度及 H-AV 仍不能形成 L2/L3 证据;M3/G3 +继续保持未勾选。 + - [ ] **M3-01a 打开并管理 Oboe 流**。前置:无。完成:请求低延迟输出,检查实际参数,失败时按能力回退,停止时释放流。验收:L2,一次成功输出和一次受控回退,错误不导致内核无限运行。 - [ ] **M3-01b 接入有界音频环形缓冲**。前置:M3-01a。完成:生产/消费解耦、欠载补静音和计数;回调使用预分配内存,不阻塞或做文件操作。验收:L1,环绕、空/满边界各覆盖,运行时确认回调只消费数据。 - [ ] **M3-02a 完成采样率与格式适配**。前置:M3-01b。完成:按内核和设备实际采样率重采样,完成声道/格式转换,跨批次保持连续。验收:L1,不同采样率代表输入输出长度与连续性正确;无需枚举所有可能采样率。