Merge c68549e9ef into 1786e34bd3

Source/Android/app/src/main/java/org/dolphinemu/dolphinemu/utils/AudioUtils.kt

@@ -1,28 +0,0 @@
-package org.dolphinemu.dolphinemu.utils
-
-import android.content.Context
-import android.media.AudioManager
-import androidx.annotation.Keep
-import org.dolphinemu.dolphinemu.DolphinApplication
-
-object AudioUtils {
-    @JvmStatic @Keep
-    fun getSampleRate(): Int =
-        getAudioServiceProperty(AudioManager.PROPERTY_OUTPUT_SAMPLE_RATE, 48000)
-
-    @JvmStatic @Keep
-    fun getFramesPerBuffer(): Int =
-        getAudioServiceProperty(AudioManager.PROPERTY_OUTPUT_FRAMES_PER_BUFFER, 256)
-
-    private fun getAudioServiceProperty(property: String, fallback: Int): Int {
-        return try {
-            val context = DolphinApplication.getAppContext()
-            val am = context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
-            Integer.parseUnsignedInt(am.getProperty(property))
-        } catch (e: NullPointerException) {
-            fallback
-        } catch (e: NumberFormatException) {
-            fallback
-        }
-    }
-}

Source/Android/jni/AndroidCommon/IDCache.cpp

@@ -122,10 +122,6 @@ static jmethodID s_permission_handler_request_record_audio_permission;
 
 static jmethodID s_runnable_run;
 
-static jclass s_audio_utils_class;
-static jmethodID s_audio_utils_get_sample_rate;
-static jmethodID s_audio_utils_get_frames_per_buffer;
-
 namespace IDCache
 {
 JNIEnv* GetEnvForThread()
@@ -566,21 +562,6 @@ jmethodID GetRunnableRun()
   return s_runnable_run;
 }
 
-jclass GetAudioUtilsClass()
-{
-  return s_audio_utils_class;
-}
-
-jmethodID GetAudioUtilsGetSampleRate()
-{
-  return s_audio_utils_get_sample_rate;
-}
-
-jmethodID GetAudioUtilsGetFramesPerBuffer()
-{
-  return s_audio_utils_get_frames_per_buffer;
-}
-
 }  // namespace IDCache
 
 extern "C" {
@@ -817,13 +798,6 @@ JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved)
   s_runnable_run = env->GetMethodID(runnable_class, "run", "()V");
   env->DeleteLocalRef(runnable_class);
 
-  const jclass audio_utils_class = env->FindClass("org/dolphinemu/dolphinemu/utils/AudioUtils");
-  s_audio_utils_class = reinterpret_cast<jclass>(env->NewGlobalRef(audio_utils_class));
-  s_audio_utils_get_sample_rate = env->GetStaticMethodID(audio_utils_class, "getSampleRate", "()I");
-  s_audio_utils_get_frames_per_buffer =
-      env->GetStaticMethodID(audio_utils_class, "getFramesPerBuffer", "()I");
-  env->DeleteLocalRef(audio_utils_class);
-
   return JNI_VERSION;
 }
 
@@ -860,6 +834,5 @@ JNIEXPORT void JNI_OnUnload(JavaVM* vm, void* reserved)
   env->DeleteGlobalRef(s_core_device_control_class);
   env->DeleteGlobalRef(s_input_detector_class);
   env->DeleteGlobalRef(s_permission_handler_class);
-  env->DeleteGlobalRef(s_audio_utils_class);
 }
 }

Source/Android/jni/AndroidCommon/IDCache.h

@@ -121,8 +121,4 @@ jmethodID GetPermissionHandlerRequestRecordAudioPermission();
 
 jmethodID GetRunnableRun();
 
-jclass GetAudioUtilsClass();
-jmethodID GetAudioUtilsGetSampleRate();
-jmethodID GetAudioUtilsGetFramesPerBuffer();
-
 }  // namespace IDCache

Source/Core/AudioCommon/AudioCommon.cpp

@@ -16,7 +16,6 @@
 #include "AudioCommon/WASAPIStream.h"
 #include "Common/FileUtil.h"
 #include "Common/Logging/Log.h"
-#include "Common/TimeUtil.h"
 #include "Core/Config/MainSettings.h"
 #include "Core/ConfigManager.h"
 #include "Core/System.h"
@@ -220,11 +219,8 @@ void StartAudioDump(Core::System& system)
 
   std::string path_prefix = File::GetUserPath(D_DUMPAUDIO_IDX) + SConfig::GetInstance().GetGameID();
 
-  const auto local_time = Common::LocalTime(start_time);
-  if (!local_time)
-    return;
-
-  std::string base_name = fmt::format("{}_{:%Y-%m-%d_%H-%M-%S}", path_prefix, *local_time);
+  std::string base_name =
+      fmt::format("{}_{:%Y-%m-%d_%H-%M-%S}", path_prefix, fmt::localtime(start_time));
 
   const std::string audio_file_name_dtk = fmt::format("{}_dtkdump.wav", base_name);
   const std::string audio_file_name_dsp = fmt::format("{}_dspdump.wav", base_name);

Source/Core/AudioCommon/OpenSLESStream.cpp

@@ -8,27 +8,40 @@
 
 #include <SLES/OpenSLES.h>
 #include <SLES/OpenSLES_Android.h>
-#include <jni.h>
 
 #include "Common/Assert.h"
 #include "Common/CommonTypes.h"
 #include "Common/Logging/Log.h"
 #include "Core/ConfigManager.h"
-#include "jni/AndroidCommon/IDCache.h"
 
-void OpenSLESStream::BQPlayerCallback(SLAndroidSimpleBufferQueueItf bq, void* context)
-{
-  reinterpret_cast<OpenSLESStream*>(context)->PushSamples(bq);
-}
+// engine interfaces
+static SLObjectItf engineObject;
+static SLEngineItf engineEngine;
+static SLObjectItf outputMixObject;
 
-void OpenSLESStream::PushSamples(SLAndroidSimpleBufferQueueItf bq)
+// buffer queue player interfaces
+static SLObjectItf bqPlayerObject = nullptr;
+static SLPlayItf bqPlayerPlay;
+static SLAndroidSimpleBufferQueueItf bqPlayerBufferQueue;
+static SLVolumeItf bqPlayerVolume;
+static Mixer* g_mixer;
+#define BUFFER_SIZE 512
+#define BUFFER_SIZE_IN_SAMPLES (BUFFER_SIZE / 2)
+
+// Double buffering.
+static short buffer[2][BUFFER_SIZE];
+static int curBuffer = 0;
+
+static void bqPlayerCallback(SLAndroidSimpleBufferQueueItf bq, void* context)
 {
-  ASSERT(bq == m_bq_player_buffer_queue);
+  ASSERT(bq == bqPlayerBufferQueue);
+  ASSERT(nullptr == context);
 
   // Render to the fresh buffer
-  m_mixer->Mix(m_buffer[m_current_buffer].data(), m_frames_per_buffer);
-  SLresult result = (*bq)->Enqueue(bq, m_buffer[m_current_buffer].data(), m_bytes_per_buffer);
-  m_current_buffer ^= 1;  // Switch buffer
+  g_mixer->Mix(reinterpret_cast<short*>(buffer[curBuffer]), BUFFER_SIZE_IN_SAMPLES);
+  SLresult result =
+      (*bqPlayerBufferQueue)->Enqueue(bqPlayerBufferQueue, buffer[curBuffer], sizeof(buffer[0]));
+  curBuffer ^= 1;  // Switch buffer
 
   // Comment from sample code:
   // the most likely other result is SL_RESULT_BUFFER_INSUFFICIENT,
@@ -38,78 +51,61 @@ void OpenSLESStream::PushSamples(SLAndroidSimpleBufferQueueItf bq)
 
 bool OpenSLESStream::Init()
 {
-  JNIEnv* env = IDCache::GetEnvForThread();
-  jclass audio_utils = IDCache::GetAudioUtilsClass();
-  const SLuint32 sample_rate =
-      env->CallStaticIntMethod(audio_utils, IDCache::GetAudioUtilsGetSampleRate());
-  m_frames_per_buffer =
-      env->CallStaticIntMethod(audio_utils, IDCache::GetAudioUtilsGetFramesPerBuffer());
-
-  INFO_LOG_FMT(AUDIO, "OpenSLES configuration: {} Hz, {} frames per buffer", sample_rate,
-               m_frames_per_buffer);
-
-  constexpr SLuint32 channels = 2;
-  const SLuint32 samples_per_buffer = m_frames_per_buffer * channels;
-  m_bytes_per_buffer = m_frames_per_buffer * channels * sizeof(m_buffer[0][0]);
-
-  for (std::vector<short>& buffer : m_buffer)
-    buffer.resize(samples_per_buffer);
-
   SLresult result;
   // create engine
-  result = slCreateEngine(&m_engine_object, 0, nullptr, 0, nullptr, nullptr);
+  result = slCreateEngine(&engineObject, 0, nullptr, 0, nullptr, nullptr);
   ASSERT(SL_RESULT_SUCCESS == result);
-  result = (*m_engine_object)->Realize(m_engine_object, SL_BOOLEAN_FALSE);
+  result = (*engineObject)->Realize(engineObject, SL_BOOLEAN_FALSE);
   ASSERT(SL_RESULT_SUCCESS == result);
-  result = (*m_engine_object)->GetInterface(m_engine_object, SL_IID_ENGINE, &m_engine_engine);
+  result = (*engineObject)->GetInterface(engineObject, SL_IID_ENGINE, &engineEngine);
   ASSERT(SL_RESULT_SUCCESS == result);
-  result = (*m_engine_engine)->CreateOutputMix(m_engine_engine, &m_output_mix_object, 0, 0, 0);
+  result = (*engineEngine)->CreateOutputMix(engineEngine, &outputMixObject, 0, 0, 0);
   ASSERT(SL_RESULT_SUCCESS == result);
-  result = (*m_output_mix_object)->Realize(m_output_mix_object, SL_BOOLEAN_FALSE);
+  result = (*outputMixObject)->Realize(outputMixObject, SL_BOOLEAN_FALSE);
   ASSERT(SL_RESULT_SUCCESS == result);
 
   SLDataLocator_AndroidSimpleBufferQueue loc_bufq = {SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, 2};
-  SLDataFormat_PCM format_pcm = {
-      SL_DATAFORMAT_PCM,           channels,
-      sample_rate * 1000,          SL_PCMSAMPLEFORMAT_FIXED_16,
-      SL_PCMSAMPLEFORMAT_FIXED_16, SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT,
+  SLDataFormat_PCM format_pcm = {SL_DATAFORMAT_PCM,
+                                 2,
+                                 m_mixer->GetSampleRate() * 1000,
+                                 SL_PCMSAMPLEFORMAT_FIXED_16,
+                                 SL_PCMSAMPLEFORMAT_FIXED_16,
+                                 SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT,
                                  SL_BYTEORDER_LITTLEENDIAN};
 
   SLDataSource audioSrc = {&loc_bufq, &format_pcm};
 
   // configure audio sink
-  SLDataLocator_OutputMix loc_outmix = {SL_DATALOCATOR_OUTPUTMIX, m_output_mix_object};
+  SLDataLocator_OutputMix loc_outmix = {SL_DATALOCATOR_OUTPUTMIX, outputMixObject};
   SLDataSink audioSnk = {&loc_outmix, nullptr};
 
   // create audio player
   const SLInterfaceID ids[2] = {SL_IID_BUFFERQUEUE, SL_IID_VOLUME};
   const SLboolean req[2] = {SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE};
-  result = (*m_engine_engine)
-               ->CreateAudioPlayer(m_engine_engine, &m_bq_player_object, &audioSrc, &audioSnk, 2,
-                                   ids, req);
+  result =
+      (*engineEngine)
+          ->CreateAudioPlayer(engineEngine, &bqPlayerObject, &audioSrc, &audioSnk, 2, ids, req);
   ASSERT(SL_RESULT_SUCCESS == result);
 
-  result = (*m_bq_player_object)->Realize(m_bq_player_object, SL_BOOLEAN_FALSE);
+  result = (*bqPlayerObject)->Realize(bqPlayerObject, SL_BOOLEAN_FALSE);
   ASSERT(SL_RESULT_SUCCESS == result);
-  result = (*m_bq_player_object)->GetInterface(m_bq_player_object, SL_IID_PLAY, &m_bq_player_play);
-  ASSERT(SL_RESULT_SUCCESS == result);
-  result = (*m_bq_player_object)
-               ->GetInterface(m_bq_player_object, SL_IID_BUFFERQUEUE, &m_bq_player_buffer_queue);
+  result = (*bqPlayerObject)->GetInterface(bqPlayerObject, SL_IID_PLAY, &bqPlayerPlay);
   ASSERT(SL_RESULT_SUCCESS == result);
   result =
-      (*m_bq_player_object)->GetInterface(m_bq_player_object, SL_IID_VOLUME, &m_bq_player_volume);
+      (*bqPlayerObject)->GetInterface(bqPlayerObject, SL_IID_BUFFERQUEUE, &bqPlayerBufferQueue);
   ASSERT(SL_RESULT_SUCCESS == result);
-  result = (*m_bq_player_buffer_queue)
-               ->RegisterCallback(m_bq_player_buffer_queue, BQPlayerCallback, this);
+  result = (*bqPlayerObject)->GetInterface(bqPlayerObject, SL_IID_VOLUME, &bqPlayerVolume);
   ASSERT(SL_RESULT_SUCCESS == result);
-  result = (*m_bq_player_play)->SetPlayState(m_bq_player_play, SL_PLAYSTATE_PLAYING);
+  result = (*bqPlayerBufferQueue)->RegisterCallback(bqPlayerBufferQueue, bqPlayerCallback, nullptr);
+  ASSERT(SL_RESULT_SUCCESS == result);
+  result = (*bqPlayerPlay)->SetPlayState(bqPlayerPlay, SL_PLAYSTATE_PLAYING);
   ASSERT(SL_RESULT_SUCCESS == result);
 
   // Render and enqueue a first buffer.
-  m_current_buffer ^= 1;
+  curBuffer ^= 1;
+  g_mixer = m_mixer.get();
 
-  result = (*m_bq_player_buffer_queue)
-               ->Enqueue(m_bq_player_buffer_queue, m_buffer[0].data(), m_bytes_per_buffer);
+  result = (*bqPlayerBufferQueue)->Enqueue(bqPlayerBufferQueue, buffer[0], sizeof(buffer[0]));
   if (SL_RESULT_SUCCESS != result)
     return false;
 
@@ -118,39 +114,39 @@ bool OpenSLESStream::Init()
 
 OpenSLESStream::~OpenSLESStream()
 {
-  if (m_bq_player_object != nullptr)
+  if (bqPlayerObject != nullptr)
   {
-    (*m_bq_player_object)->Destroy(m_bq_player_object);
-    m_bq_player_object = nullptr;
-    m_bq_player_play = nullptr;
-    m_bq_player_buffer_queue = nullptr;
-    m_bq_player_volume = nullptr;
+    (*bqPlayerObject)->Destroy(bqPlayerObject);
+    bqPlayerObject = nullptr;
+    bqPlayerPlay = nullptr;
+    bqPlayerBufferQueue = nullptr;
+    bqPlayerVolume = nullptr;
   }
 
-  if (m_output_mix_object != nullptr)
+  if (outputMixObject != nullptr)
   {
-    (*m_output_mix_object)->Destroy(m_output_mix_object);
-    m_output_mix_object = nullptr;
+    (*outputMixObject)->Destroy(outputMixObject);
+    outputMixObject = nullptr;
   }
 
-  if (m_engine_object != nullptr)
+  if (engineObject != nullptr)
   {
-    (*m_engine_object)->Destroy(m_engine_object);
-    m_engine_object = nullptr;
-    m_engine_engine = nullptr;
+    (*engineObject)->Destroy(engineObject);
+    engineObject = nullptr;
+    engineEngine = nullptr;
   }
 }
 
 bool OpenSLESStream::SetRunning(bool running)
 {
   SLuint32 new_state = running ? SL_PLAYSTATE_PLAYING : SL_PLAYSTATE_PAUSED;
-  return (*m_bq_player_play)->SetPlayState(m_bq_player_play, new_state) == SL_RESULT_SUCCESS;
+  return (*bqPlayerPlay)->SetPlayState(bqPlayerPlay, new_state) == SL_RESULT_SUCCESS;
 }
 
 void OpenSLESStream::SetVolume(int volume)
 {
   const SLmillibel attenuation =
       volume <= 0 ? SL_MILLIBEL_MIN : static_cast<SLmillibel>(2000 * std::log10(volume / 100.0f));
-  (*m_bq_player_volume)->SetVolumeLevel(m_bq_player_volume, attenuation);
+  (*bqPlayerVolume)->SetVolumeLevel(bqPlayerVolume, attenuation);
 }
 #endif  // HAVE_OPENSL_ES

Source/Core/AudioCommon/OpenSLESStream.h

@@ -3,15 +3,10 @@
 
 #pragma once
 
-#ifdef HAVE_OPENSL_ES
-#include <array>
-#include <vector>
-
-#include <SLES/OpenSLES.h>
-#include <SLES/OpenSLES_Android.h>
-#endif  // HAVE_OPENSL_ES
+#include <thread>
 
 #include "AudioCommon/SoundStream.h"
+#include "Common/Event.h"
 
 class OpenSLESStream final : public SoundStream
 {
@@ -24,25 +19,7 @@ public:
   static bool IsValid() { return true; }
 
 private:
-  static void BQPlayerCallback(SLAndroidSimpleBufferQueueItf bq, void* context);
-  void PushSamples(SLAndroidSimpleBufferQueueItf bq);
-
-  // engine interfaces
-  SLObjectItf m_engine_object;
-  SLEngineItf m_engine_engine;
-  SLObjectItf m_output_mix_object;
-
-  // buffer queue player interfaces
-  SLObjectItf m_bq_player_object = nullptr;
-  SLPlayItf m_bq_player_play;
-  SLAndroidSimpleBufferQueueItf m_bq_player_buffer_queue;
-  SLVolumeItf m_bq_player_volume;
-
-  SLuint32 m_frames_per_buffer;
-  SLuint32 m_bytes_per_buffer;
-
-  // Double buffering.
-  std::array<std::vector<short>, 2> m_buffer;
-  int m_current_buffer = 0;
+  std::thread thread;
+  Common::Event soundSyncEvent;
 #endif  // HAVE_OPENSL_ES
 };

Source/Core/Common/FatFsUtil.cpp

@@ -25,7 +25,6 @@
 #include "Common/Logging/Log.h"
 #include "Common/ScopeGuard.h"
 #include "Common/StringUtil.h"
-#include "Common/TimeUtil.h"
 
 #include "Core/Config/MainSettings.h"
 
@@ -96,7 +95,12 @@ int SDCardDiskIOCtl(File::IOFile* image, u8 pdrv, u8 cmd, void* buff)
 u32 GetSystemTimeFAT()
 {
   const std::time_t time = std::time(nullptr);
-  std::tm tm = *Common::LocalTime(time);
+  std::tm tm;
+#ifdef _WIN32
+  localtime_s(&tm, &time);
+#else
+  localtime_r(&time, &tm);
+#endif
 
   DWORD fattime = 0;
   fattime |= (tm.tm_year - 80) << 25;

Source/Core/Common/SettingsHandler.cpp

@@ -122,6 +122,7 @@ std::string SettingsWriter::GenerateSerialNumber()
 
   // Must be 9 characters at most; otherwise the serial number will be rejected by SDK libraries,
   // as there is a check to ensure the string length is strictly lower than 10.
-  return fmt::format("{:09}", t % 1000000000);
+  // 3 for %j, 2 for %H, 2 for %M, 2 for %S.
+  return fmt::format("{:%j%H%M%S}", fmt::localtime(t));
 }
 }  // namespace Common

Source/Core/Common/TimeUtil.cpp

@@ -2,25 +2,23 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "Common/TimeUtil.h"
-#include "Common/Logging/Log.h"
 
 #include <ctime>
 #include <optional>
 
 namespace Common
 {
-std::optional<std::tm> LocalTime(std::time_t time)
+std::optional<std::tm> Localtime(std::time_t time)
 {
   std::tm local_time;
 #ifdef _MSC_VER
   if (localtime_s(&local_time, &time) != 0)
-#else
-  if (localtime_r(&time, &local_time) == NULL)
-#endif
-  {
-    ERROR_LOG_FMT(COMMON, "Failed to convert time to local time: {}", std::strerror(errno));
     return std::nullopt;
-  }
+#else
+  std::tm* result = localtime_r(&time, &local_time);
+  if (result != &local_time)
+    return std::nullopt;
+#endif
   return local_time;
 }
 }  // Namespace Common

Source/Core/Common/TimeUtil.h

@@ -9,5 +9,5 @@
 namespace Common
 {
 // Threadsafe and error-checking variant of std::localtime()
-std::optional<std::tm> LocalTime(std::time_t time);
+std::optional<std::tm> Localtime(std::time_t time);
 }  // Namespace Common

Source/Core/Core/Core.cpp

@@ -8,7 +8,6 @@
 #include <cstring>
 #include <functional>
 #include <mutex>
-#include <optional>
 #include <queue>
 #include <utility>
 #include <variant>
@@ -35,7 +34,6 @@
 #include "Common/ScopeGuard.h"
 #include "Common/StringUtil.h"
 #include "Common/Thread.h"
-#include "Common/TimeUtil.h"
 #include "Common/Version.h"
 
 #include "Core/AchievementManager.h"
@@ -735,17 +733,15 @@ static std::string GenerateScreenshotFolderPath()
   return path;
 }
 
-static std::optional<std::string> GenerateScreenshotName()
+static std::string GenerateScreenshotName()
 {
   // append gameId, path only contains the folder here.
   const std::string path_prefix =
       GenerateScreenshotFolderPath() + SConfig::GetInstance().GetGameID();
 
   const std::time_t cur_time = std::time(nullptr);
-  const auto local_time = Common::LocalTime(cur_time);
-  if (!local_time)
-    return std::nullopt;
-  const std::string base_name = fmt::format("{}_{:%Y-%m-%d_%H-%M-%S}", path_prefix, *local_time);
+  const std::string base_name =
+      fmt::format("{}_{:%Y-%m-%d_%H-%M-%S}", path_prefix, fmt::localtime(cur_time));
 
   // First try a filename without any suffixes, if already exists then append increasing numbers
   std::string name = fmt::format("{}.png", base_name);
@@ -761,9 +757,7 @@ static std::optional<std::string> GenerateScreenshotName()
 void SaveScreenShot()
 {
   const Core::CPUThreadGuard guard(Core::System::GetInstance());
-  std::optional<std::string> name = GenerateScreenshotName();
-  if (name)
-    g_frame_dumper->SaveScreenshot(*name);
+  g_frame_dumper->SaveScreenshot(GenerateScreenshotName());
 }
 
 void SaveScreenShot(std::string_view name)

Source/Core/Core/NetworkCaptureLogger.cpp

@@ -16,7 +16,6 @@
 #include "Common/Network.h"
 #include "Common/PcapFile.h"
 #include "Common/ScopeGuard.h"
-#include "Common/TimeUtil.h"
 #include "Core/Config/MainSettings.h"
 #include "Core/ConfigManager.h"
 
@@ -83,7 +82,7 @@ PCAPSSLCaptureLogger::PCAPSSLCaptureLogger()
 {
   const std::string filepath =
       fmt::format("{}{} {:%Y-%m-%d %Hh%Mm%Ss}.pcap", File::GetUserPath(D_DUMPSSL_IDX),
-                  SConfig::GetInstance().GetGameID(), *Common::LocalTime(std::time(nullptr)));
+                  SConfig::GetInstance().GetGameID(), fmt::localtime(std::time(nullptr)));
   m_file = std::make_unique<Common::PCAP>(
       new File::IOFile(filepath, "wb", File::SharedAccess::Read), Common::PCAP::LinkType::Ethernet);
 }

Source/Core/Core/State.cpp

@@ -281,7 +281,7 @@ static std::string SystemTimeAsDoubleToString(double time)
 {
   // revert adjustments from GetSystemTimeAsDouble() to get a normal Unix timestamp again
   const time_t seconds = static_cast<time_t>(time) + DOUBLE_TIME_OFFSET;
-  const auto local_time = Common::LocalTime(seconds);
+  const auto local_time = Common::Localtime(seconds);
   if (!local_time)
     return "";
 

Source/Core/VideoCommon/FrameDumpFFMpeg.cpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "VideoCommon/FrameDumpFFMpeg.h"
-#include "Common/TimeUtil.h"
 
 #if defined(__FreeBSD__)
 #define __STDC_CONSTANT_MACROS 1
@@ -125,15 +124,11 @@ std::string GetDumpPath(const std::string& extension, std::time_t time, u32 inde
   if (!dump_path.empty())
     return dump_path;
 
-  const auto local_time = Common::LocalTime(time);
-  if (!local_time)
-    return "";
-
   const std::string path_prefix =
       File::GetUserPath(D_DUMPFRAMES_IDX) + SConfig::GetInstance().GetGameID();
 
   const std::string base_name =
-      fmt::format("{}_{:%Y-%m-%d_%H-%M-%S}_{}", path_prefix, *local_time, index);
+      fmt::format("{}_{:%Y-%m-%d_%H-%M-%S}_{}", path_prefix, fmt::localtime(time), index);
 
   const std::string path = fmt::format("{}.{}", base_name, extension);