[FFmpeg]: Remove internal FFCodec hack and use public API

src/audio_core/opus/decoder.cpp

@@ -151,7 +151,7 @@ Result OpusDecoder::DecodeInterleavedForMultiStream(u32* out_data_size, u64* out
     auto* header_p{reinterpret_cast<const OpusPacketHeader*>(input_data.data())};
     OpusPacketHeader header{ReverseHeader(*header_p)};
 
-    LOG_TRACE(Service_Audio, "header size {:#X} input data size {:#X} in_data size {:#X}",
+    LOG_TRACE(Service_Audio, "header size {:#X} input data size 0x{:X} in_data size 0x{:X}",
               header.size, input_data.size_bytes(), in_data.size_bytes());
 
     R_UNLESS(in_data.size_bytes() >= header.size &&

src/audio_core/renderer/behavior/info_updater.cpp

@@ -366,7 +366,7 @@ Result InfoUpdater::UpdateMixes(MixContext& mix_context, const u32 mix_buffer_co
         if (mix_count < 0 || mix_count > 0x100) {
             LOG_ERROR(
                 Service_Audio,
-                "Invalid mix count from dirty parameter: count={}, magic={:#X}, expected_size={}",
+                "Invalid mix count from dirty parameter: count={}, magic=0x{:X}, expected_size={}",
                 mix_count, in_dirty_params->magic, in_header->mix_size);
             return Service::Audio::ResultInvalidUpdateInfo;
         }

src/core/hle/kernel/svc/svc_address_arbiter.cpp

@@ -43,7 +43,7 @@ constexpr bool IsValidArbitrationType(Svc::ArbitrationType type) {
 // Wait for an address (via Address Arbiter)
 Result WaitForAddress(Core::System& system, u64 address, ArbitrationType arb_type, s32 value,
                       s64 timeout_ns) {
-    LOG_TRACE(Kernel_SVC, "called, address={:#X}, arb_type={:#X}, value={:#X}, timeout_ns={}",
+    LOG_TRACE(Kernel_SVC, "called, address={:#X}, arb_type=0x{:X}, value=0x{:X}, timeout_ns={}",
               address, arb_type, value, timeout_ns);
 
     // Validate input.
@@ -74,7 +74,7 @@ Result WaitForAddress(Core::System& system, u64 address, ArbitrationType arb_typ
 // Signals to an address (via Address Arbiter)
 Result SignalToAddress(Core::System& system, u64 address, SignalType signal_type, s32 value,
                        s32 count) {
-    LOG_TRACE(Kernel_SVC, "called, address={:#X}, signal_type={:#X}, value={:#X}, count={:#X}",
+    LOG_TRACE(Kernel_SVC, "called, address={:#X}, signal_type=0x{:X}, value=0x{:X}, count=0x{:X}",
               address, signal_type, value, count);
 
     // Validate input.

src/core/hle/kernel/svc/svc_code_memory.cpp

@@ -33,7 +33,7 @@ constexpr bool IsValidUnmapFromOwnerCodeMemoryPermission(MemoryPermission perm)
 } // namespace
 
 Result CreateCodeMemory(Core::System& system, Handle* out, u64 address, uint64_t size) {
-    LOG_TRACE(Kernel_SVC, "called, address={:#X}, size={:#X}", address, size);
+    LOG_TRACE(Kernel_SVC, "called, address={:#X}, size=0x{:X}", address, size);
 
     // Get kernel instance.
     auto& kernel = system.Kernel();
@@ -73,7 +73,7 @@ Result ControlCodeMemory(Core::System& system, Handle code_memory_handle,
                          MemoryPermission perm) {
 
     LOG_TRACE(Kernel_SVC,
-              "called, code_memory_handle={:#X}, operation={:#X}, address={:#X}, size={:#X}, "
+              "called, code_memory_handle={:#X}, operation=0x{:X}, address=0x{:X}, size=0x{:X}, "
               "permission={:#X}",
               code_memory_handle, operation, address, size, perm);
 

src/core/hle/kernel/svc/svc_info.cpp

@@ -12,7 +12,7 @@ namespace Kernel::Svc {
 /// Gets system/memory information for the current process
 Result GetInfo(Core::System& system, u64* result, InfoType info_id_type, Handle handle,
                u64 info_sub_id) {
-    LOG_TRACE(Kernel_SVC, "called info_id={:#X}, info_sub_id={:#X}, handle=0x{:08X}",
+    LOG_TRACE(Kernel_SVC, "called info_id={:#X}, info_sub_id=0x{:X}, handle=0x{:08X}",
               info_id_type, info_sub_id, handle);
 
     u32 info_id = static_cast<u32>(info_id_type);

src/core/hle/kernel/svc/svc_memory.cpp

@@ -133,7 +133,7 @@ Result SetMemoryAttribute(Core::System& system, u64 address, u64 size, u32 mask,
 
 /// Maps a memory range into a different range.
 Result MapMemory(Core::System& system, u64 dst_addr, u64 src_addr, u64 size) {
-    LOG_TRACE(Kernel_SVC, "called, dst_addr={:#X}, src_addr={:#X}, size={:#X}", dst_addr,
+    LOG_TRACE(Kernel_SVC, "called, dst_addr={:#X}, src_addr=0x{:X}, size=0x{:X}", dst_addr,
               src_addr, size);
 
     auto& page_table{GetCurrentProcess(system.Kernel()).GetPageTable()};
@@ -148,7 +148,7 @@ Result MapMemory(Core::System& system, u64 dst_addr, u64 src_addr, u64 size) {
 
 /// Unmaps a region that was previously mapped with svcMapMemory
 Result UnmapMemory(Core::System& system, u64 dst_addr, u64 src_addr, u64 size) {
-    LOG_TRACE(Kernel_SVC, "called, dst_addr={:#X}, src_addr={:#X}, size={:#X}", dst_addr,
+    LOG_TRACE(Kernel_SVC, "called, dst_addr={:#X}, src_addr=0x{:X}, size=0x{:X}", dst_addr,
               src_addr, size);
 
     auto& page_table{GetCurrentProcess(system.Kernel()).GetPageTable()};

src/core/hle/kernel/svc/svc_process_memory.cpp

@@ -32,7 +32,7 @@ constexpr bool IsValidProcessMemoryPermission(Svc::MemoryPermission perm) {
 Result SetProcessMemoryPermission(Core::System& system, Handle process_handle, u64 address,
                                   u64 size, Svc::MemoryPermission perm) {
     LOG_TRACE(Kernel_SVC,
-              "called, process_handle={:#X}, addr={:#X}, size={:#X}, permissions=0x{:08X}",
+              "called, process_handle={:#X}, addr=0x{:X}, size=0x{:X}, permissions=0x{:08X}",
               process_handle, address, size, perm);
 
     // Validate the address/size.
@@ -62,7 +62,7 @@ Result SetProcessMemoryPermission(Core::System& system, Handle process_handle, u
 Result MapProcessMemory(Core::System& system, u64 dst_address, Handle process_handle,
                         u64 src_address, u64 size) {
     LOG_TRACE(Kernel_SVC,
-              "called, dst_address={:#X}, process_handle={:#X}, src_address={:#X}, size={:#X}",
+              "called, dst_address={:#X}, process_handle=0x{:X}, src_address=0x{:X}, size=0x{:X}",
               dst_address, process_handle, src_address, size);
 
     // Validate the address/size.
@@ -103,7 +103,7 @@ Result MapProcessMemory(Core::System& system, u64 dst_address, Handle process_ha
 Result UnmapProcessMemory(Core::System& system, u64 dst_address, Handle process_handle,
                           u64 src_address, u64 size) {
     LOG_TRACE(Kernel_SVC,
-              "called, dst_address={:#X}, process_handle={:#X}, src_address={:#X}, size={:#X}",
+              "called, dst_address={:#X}, process_handle=0x{:X}, src_address=0x{:X}, size=0x{:X}",
               dst_address, process_handle, src_address, size);
 
     // Validate the address/size.

src/core/hle/kernel/svc/svc_shared_memory.cpp

@@ -32,7 +32,7 @@ constexpr bool IsValidSharedMemoryPermission(MemoryPermission perm) {
 Result MapSharedMemory(Core::System& system, Handle shmem_handle, u64 address, u64 size,
                        Svc::MemoryPermission map_perm) {
     LOG_TRACE(Kernel_SVC,
-              "called, shared_memory_handle={:#X}, addr={:#X}, size={:#X}, permissions=0x{:08X}",
+              "called, shared_memory_handle={:#X}, addr=0x{:X}, size=0x{:X}, permissions=0x{:08X}",
               shmem_handle, address, size, map_perm);
 
     // Validate the address/size.

src/core/hle/service/jit/jit_context.cpp

@@ -407,7 +407,7 @@ void DynarmicCallbacks64::CallSVC(u32 swi) {
         LOG_CRITICAL(Service_JIT, "plugin panicked!");
         parent.jit->HaltExecution();
     } else {
-        LOG_CRITICAL(Service_JIT, "plugin issued syscall at unknown address {:#x}", pc);
+        LOG_CRITICAL(Service_JIT, "plugin issued syscall at unknown address 0x{:x}", pc);
         parent.jit->HaltExecution();
     }
 }

src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp

@@ -441,7 +441,7 @@ NvResult nvhost_as_gpu::UnmapBuffer(IoctlUnmapBuffer& params) {
 
         mapping_map.erase(params.offset);
     } catch (const std::out_of_range&) {
-        LOG_WARNING(Service_NVDRV, "Couldn't find region to unmap at {:#X}", params.offset);
+        LOG_WARNING(Service_NVDRV, "Couldn't find region to unmap at 0x{:X}", params.offset);
     }
 
     return NvResult::Success;

src/core/hle/service/sockets/bsd.cpp

@@ -282,7 +282,7 @@ void BSD::GetSockOpt(HLERequestContext& ctx) {
 
     std::vector<u8> optval(ctx.GetWriteBufferSize());
 
-    LOG_DEBUG(Service, "called. fd={} level={} optname={:#x} len={:#x}", fd, level, optname,
+    LOG_DEBUG(Service, "called. fd={} level={} optname=0x{:x} len=0x{:x}", fd, level, optname,
               optval.size());
 
     const Errno err = GetSockOptImpl(fd, level, optname, optval);
@@ -330,7 +330,7 @@ void BSD::SetSockOpt(HLERequestContext& ctx) {
     const OptName optname = static_cast<OptName>(rp.Pop<u32>());
     const auto optval = ctx.ReadBuffer();
 
-    LOG_DEBUG(Service, "called. fd={} level={} optname={:#x} optlen={}", fd, level,
+    LOG_DEBUG(Service, "called. fd={} level={} optname=0x{:x} optlen={}", fd, level,
               static_cast<u32>(optname), optval.size());
 
     BuildErrnoResponse(ctx, SetSockOptImpl(fd, level, optname, optval));
@@ -353,7 +353,7 @@ void BSD::Recv(HLERequestContext& ctx) {
     const s32 fd = rp.Pop<s32>();
     const u32 flags = rp.Pop<u32>();
 
-    LOG_DEBUG(Service, "called. fd={} flags={:#x} len={}", fd, flags, ctx.GetWriteBufferSize());
+    LOG_DEBUG(Service, "called. fd={} flags=0x{:x} len={}", fd, flags, ctx.GetWriteBufferSize());
 
     ExecuteWork(ctx, RecvWork{
                          .fd = fd,
@@ -368,7 +368,7 @@ void BSD::RecvFrom(HLERequestContext& ctx) {
     const s32 fd = rp.Pop<s32>();
     const u32 flags = rp.Pop<u32>();
 
-    LOG_DEBUG(Service, "called. fd={} flags={:#x} len={} addrlen={}", fd, flags,
+    LOG_DEBUG(Service, "called. fd={} flags=0x{:x} len={} addrlen={}", fd, flags,
               ctx.GetWriteBufferSize(0), ctx.GetWriteBufferSize(1));
 
     ExecuteWork(ctx, RecvFromWork{
@@ -385,7 +385,7 @@ void BSD::Send(HLERequestContext& ctx) {
     const s32 fd = rp.Pop<s32>();
     const u32 flags = rp.Pop<u32>();
 
-    LOG_DEBUG(Service, "called. fd={} flags={:#x} len={}", fd, flags, ctx.GetReadBufferSize());
+    LOG_DEBUG(Service, "called. fd={} flags=0x{:x} len={}", fd, flags, ctx.GetReadBufferSize());
 
     ExecuteWork(ctx, SendWork{
                          .fd = fd,

src/core/internal_network/network.cpp

@@ -495,13 +495,13 @@ short TranslatePollEvents(PollEvents events) {
     // Unlike poll on other OSes, WSAPoll will complain if any other flags are set on input.
     if (result & ~allowed_events) {
         LOG_DEBUG(Network,
-                  "Removing WSAPoll input events {:#x} because Windows doesn't support them",
+                  "Removing WSAPoll input events 0x{:x} because Windows doesn't support them",
                   result & ~allowed_events);
     }
     result &= allowed_events;
 #endif
 
-    UNIMPLEMENTED_IF_MSG((u16)events != 0, "Unhandled guest events={:#x}", (u16)events);
+    UNIMPLEMENTED_IF_MSG((u16)events != 0, "Unhandled guest events=0x{:x}", (u16)events);
 
     return result;
 }
@@ -525,7 +525,7 @@ PollEvents TranslatePollRevents(short revents) {
     translate(POLLRDBAND, PollEvents::RdBand);
     translate(POLLWRBAND, PollEvents::WrBand);
 
-    UNIMPLEMENTED_IF_MSG(revents != 0, "Unhandled host revents={:#x}", revents);
+    UNIMPLEMENTED_IF_MSG(revents != 0, "Unhandled host revents=0x{:x}", revents);
 
     return result;
 }

src/shader_recompiler/frontend/maxwell/translate/impl/load_store_local_shared.cpp

@@ -152,7 +152,7 @@ void TranslatorVisitor::STL(u64 insn) {
     if (offset.IsImmediate()) {
         // TODO: Support storing out of bounds at runtime
         if (offset.U32() >= env.LocalMemorySize()) {
-            LOG_WARNING(Shader, "Storing local memory at {:#x} with a size of {:#x}, dropping",
+            LOG_WARNING(Shader, "Storing local memory at 0x{:x} with a size of 0x{:x}, dropping",
                         offset.U32(), env.LocalMemorySize());
             return;
         }

src/video_core/cdma_pusher.cpp

@@ -100,7 +100,7 @@ void CDmaPusher::ProcessEntries(std::stop_token stop_token) {
 void CDmaPusher::ExecuteCommand(u32 method, u32 arg) {
     switch (current_class) {
     case ChClassId::Control:
-        LOG_TRACE(Service_NVDRV, "Class {} method {:#X} arg {:#X}",
+        LOG_TRACE(Service_NVDRV, "Class {} method {:#X} arg 0x{:X}",
                   static_cast<u32>(current_class), method, arg);
         host_processor->ProcessMethod(static_cast<Host1x::Control::Method>(method), arg);
         break;
@@ -118,7 +118,7 @@ void CDmaPusher::ExecuteCommand(u32 method, u32 arg) {
             break;
         }
         case ThiMethod::SetMethod1:
-            LOG_TRACE(Service_NVDRV, "Class {} method {:#X} arg {:#X}",
+            LOG_TRACE(Service_NVDRV, "Class {} method {:#X} arg 0x{:X}",
                       static_cast<u32>(current_class), static_cast<u32>(thi_regs.method_0), arg);
             ProcessMethod(thi_regs.method_0, arg);
             break;

src/video_core/engines/fermi_2d.cpp

@@ -62,7 +62,7 @@ void Fermi2D::ConsumeSinkImpl() {
 
 void Fermi2D::Blit() {
     MICROPROFILE_SCOPE(GPU_BlitEngine);
-    LOG_DEBUG(HW_GPU, "called. source address={:#x}, destination address={:#x}",
+    LOG_DEBUG(HW_GPU, "called. source address=0x{:x}, destination address=0x{:x}",
               regs.src.Address(), regs.dst.Address());
 
     UNIMPLEMENTED_IF_MSG(regs.operation != Operation::SrcCopy, "Operation is not copy");

src/video_core/engines/maxwell_dma.cpp

@@ -66,7 +66,7 @@ void MaxwellDMA::CallMultiMethod(u32 method, const u32* base_start, u32 amount,
 
 void MaxwellDMA::Launch() {
     MICROPROFILE_SCOPE(GPU_DMAEngine);
-    LOG_TRACE(Render_OpenGL, "DMA copy {:#x} -> {:#x}", static_cast<GPUVAddr>(regs.offset_in),
+    LOG_TRACE(Render_OpenGL, "DMA copy 0x{:x} -> 0x{:x}", static_cast<GPUVAddr>(regs.offset_in),
               static_cast<GPUVAddr>(regs.offset_out));
 
     // TODO(Subv): Perform more research and implement all features of this engine.

src/video_core/host1x/codecs/decoder.cpp

@@ -45,7 +45,7 @@ void Decoder::Decode() {
 
         if (!frame.get()) {
             LOG_ERROR(HW_GPU,
-                      "Nvdec {} failed to decode interlaced frame for top {:#X} bottom {:#X}", id,
+                      "Nvdec {} failed to decode interlaced frame for top {:#X} bottom 0x{:X}", id,
                       luma_top, luma_bottom);
         }
 

src/video_core/host1x/nvdec.cpp

@@ -34,6 +34,10 @@ void Nvdec::ProcessMethod(u32 method, u32 argument) {
         CreateDecoder(static_cast<NvdecCommon::VideoCodec>(argument));
         break;
     case NVDEC_REG_INDEX(execute): {
+        if (wait_needed) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(32));
+            wait_needed = false;
+        }
         Execute();
     } break;
     }

src/video_core/host1x/nvdec.h

@@ -28,6 +28,10 @@ public:
         return syncpoint;
     }
 
+    void SetWait() {
+        wait_needed = true;
+    }
+
 private:
     /// Create the decoder when the codec id is set
     void CreateDecoder(NvdecCommon::VideoCodec codec);
@@ -41,6 +45,7 @@ private:
 
     NvdecCommon::NvdecRegisters regs{};
     std::unique_ptr<Decoder> decoder;
+    bool wait_needed{false};
 };
 
 } // namespace Host1x

src/video_core/host1x/vic.cpp

@@ -1003,8 +1003,8 @@ void Vic::WriteY8__V8U8_N420(const OutputSurfaceConfig& output_surface_config) {
             HW_GPU,
             "Writing Y8__V8U8_N420 swizzled frame\n"
             "\tinput surface {}x{} stride {} size {:#X}\n"
-            "\toutput   luma {}x{} stride {} size {:#X} block height {} swizzled size {:#X}\n",
-            "\toutput chroma {}x{} stride {} size {:#X} block height {} swizzled size {:#X}",
+            "\toutput   luma {}x{} stride {} size {:#X} block height {} swizzled size 0x{:X}\n",
+            "\toutput chroma {}x{} stride {} size {:#X} block height {} swizzled size 0x{:X}",
             surface_width, surface_height, surface_stride * BytesPerPixel,
             surface_stride * surface_height * BytesPerPixel, out_luma_width, out_luma_height,
             out_luma_stride, out_luma_size, block_height, out_luma_swizzle_size, out_chroma_width,
@@ -1045,8 +1045,8 @@ void Vic::WriteY8__V8U8_N420(const OutputSurfaceConfig& output_surface_config) {
             HW_GPU,
             "Writing Y8__V8U8_N420 swizzled frame\n"
             "\tinput surface {}x{} stride {} size {:#X}\n"
-            "\toutput   luma {}x{} stride {} size {:#X} block height {} swizzled size {:#X}\n",
-            "\toutput chroma {}x{} stride {} size {:#X} block height {} swizzled size {:#X}",
+            "\toutput   luma {}x{} stride {} size {:#X} block height {} swizzled size 0x{:X}\n",
+            "\toutput chroma {}x{} stride {} size {:#X} block height {} swizzled size 0x{:X}",
             surface_width, surface_height, surface_stride * BytesPerPixel,
             surface_stride * surface_height * BytesPerPixel, out_luma_width, out_luma_height,
             out_luma_stride, out_luma_size, out_chroma_width, out_chroma_height, out_chroma_stride,
@@ -1216,7 +1216,7 @@ void Vic::WriteABGR(const OutputSurfaceConfig& output_surface_config) {
             HW_GPU,
             "Writing ABGR swizzled frame\n"
             "\tinput surface {}x{} stride {} size {:#X}\n"
-            "\toutput surface {}x{} stride {} size {:#X} block height {} swizzled size {:#X}",
+            "\toutput surface {}x{} stride {} size {:#X} block height {} swizzled size 0x{:X}",
             surface_width, surface_height, surface_stride * BytesPerPixel,
             surface_stride * surface_height * BytesPerPixel, out_luma_width, out_luma_height,
             out_luma_stride, out_luma_size, block_height, out_swizzle_size);

src/video_core/macro/macro_jit_x64.cpp

@@ -569,7 +569,7 @@ bool MacroJITx64Impl::Compile_NextInstruction() {
 
 static void WarnInvalidParameter(uintptr_t parameter, uintptr_t max_parameter) {
     LOG_CRITICAL(HW_GPU,
-                 "Macro JIT: invalid parameter access {:#x} ({:#x} is the last parameter)",
+                 "Macro JIT: invalid parameter access 0x{:x} (0x{:x} is the last parameter)",
                  parameter, max_parameter - sizeof(u32));
 }
 

src/video_core/renderer_opengl/gl_buffer_cache.cpp

@@ -53,7 +53,7 @@ Buffer::Buffer(BufferCacheRuntime& runtime, DAddr cpu_addr_, u64 size_bytes_)
     : VideoCommon::BufferBase(cpu_addr_, size_bytes_) {
     buffer.Create();
     if (runtime.device.HasDebuggingToolAttached()) {
-        const std::string name = fmt::format("Buffer {:#x}", CpuAddr());
+        const std::string name = fmt::format("Buffer 0x{:x}", CpuAddr());
         glObjectLabel(GL_BUFFER, buffer.handle, static_cast<GLsizei>(name.size()), name.data());
     }
     glNamedBufferData(buffer.handle, SizeBytes(), nullptr, GL_DYNAMIC_DRAW);

src/video_core/renderer_opengl/gl_texture_cache.cpp

@@ -399,7 +399,7 @@ OGLTexture MakeImage(const VideoCommon::ImageInfo& info, GLenum gl_internal_form
         ASSERT(false);
         break;
     default:
-        ASSERT_MSG(false, "Invalid target={:#x}", target);
+        ASSERT_MSG(false, "Invalid target=0x{:x}", target);
         break;
     }
     return texture;

src/video_core/renderer_vulkan/vk_buffer_cache.cpp

@@ -92,7 +92,7 @@ Buffer::Buffer(BufferCacheRuntime& runtime, DAddr cpu_addr_, u64 size_bytes_)
     : VideoCommon::BufferBase(cpu_addr_, size_bytes_), device{&runtime.device},
       buffer{CreateBuffer(*device, runtime.memory_allocator, SizeBytes())}, tracker{SizeBytes()} {
     if (runtime.device.HasDebuggingToolAttached()) {
-        buffer.SetObjectNameEXT(fmt::format("Buffer {:#x}", CpuAddr()).c_str());
+        buffer.SetObjectNameEXT(fmt::format("Buffer 0x{:x}", CpuAddr()).c_str());
     }
 }
 

src/video_core/texture_cache/formatter.cpp

@@ -40,15 +40,15 @@ std::string Name(const ImageBase& image) {
     }
     switch (image.info.type) {
     case ImageType::e1D:
-        return fmt::format("Image 1D {:#x} {}{}", gpu_addr, width, resource);
+        return fmt::format("Image 1D 0x{:x} {}{}", gpu_addr, width, resource);
     case ImageType::e2D:
-        return fmt::format("Image 2D {:#x} {}x{}{}", gpu_addr, width, height, resource);
+        return fmt::format("Image 2D 0x{:x} {}x{}{}", gpu_addr, width, height, resource);
     case ImageType::e3D:
-        return fmt::format("Image 2D {:#x} {}x{}x{}{}", gpu_addr, width, height, depth, resource);
+        return fmt::format("Image 2D 0x{:x} {}x{}x{}{}", gpu_addr, width, height, depth, resource);
     case ImageType::Linear:
-        return fmt::format("Image Linear {:#x} {}x{}", gpu_addr, width, height);
+        return fmt::format("Image Linear 0x{:x} {}x{}", gpu_addr, width, height);
     case ImageType::Buffer:
-        return fmt::format("Buffer {:#x} {}", image.gpu_addr, image.info.size.width);
+        return fmt::format("Buffer 0x{:x} {}", image.gpu_addr, image.info.size.width);
     }
     return "Invalid";
 }

src/video_core/texture_cache/texture_cache.h

@@ -1373,7 +1373,7 @@ ImageId TextureCache<P>::InsertImage(const ImageInfo& info, GPUVAddr gpu_addr,
             cpu_addr = std::optional<DAddr>(fake_addr);
         }
     }
-    ASSERT_MSG(cpu_addr, "Tried to insert an image to an invalid gpu_addr={:#x}", gpu_addr);
+    ASSERT_MSG(cpu_addr, "Tried to insert an image to an invalid gpu_addr=0x{:x}", gpu_addr);
     const ImageId image_id = JoinImages(info, gpu_addr, *cpu_addr);
     const Image& image = slot_images[image_id];
     // Using "image.gpu_addr" instead of "gpu_addr" is important because it might be different
@@ -2047,13 +2047,13 @@ void TextureCache<P>::UnregisterImage(ImageId image_id) {
                        selected_page_table) {
             const auto page_it = selected_page_table.find(page);
             if (page_it == selected_page_table.end()) {
-                ASSERT_MSG(false, "Unregistering unregistered page={:#x}", page << YUZU_PAGEBITS);
+                ASSERT_MSG(false, "Unregistering unregistered page=0x{:x}", page << YUZU_PAGEBITS);
                 return;
             }
             std::vector<ImageId>& image_ids = page_it->second;
             const auto vector_it = std::ranges::find(image_ids, image_id);
             if (vector_it == image_ids.end()) {
-                ASSERT_MSG(false, "Unregistering unregistered image in page={:#x}",
+                ASSERT_MSG(false, "Unregistering unregistered image in page=0x{:x}",
                            page << YUZU_PAGEBITS);
                 return;
             }
@@ -2067,13 +2067,13 @@ void TextureCache<P>::UnregisterImage(ImageId image_id) {
         ForEachCPUPage(image.cpu_addr, image.guest_size_bytes, [this, map_id](u64 page) {
             const auto page_it = page_table.find(page);
             if (page_it == page_table.end()) {
-                ASSERT_MSG(false, "Unregistering unregistered page={:#x}", page << YUZU_PAGEBITS);
+                ASSERT_MSG(false, "Unregistering unregistered page=0x{:x}", page << YUZU_PAGEBITS);
                 return;
             }
             std::vector<ImageMapId>& image_map_ids = page_it->second;
             const auto vector_it = std::ranges::find(image_map_ids, map_id);
             if (vector_it == image_map_ids.end()) {
-                ASSERT_MSG(false, "Unregistering unregistered image in page={:#x}",
+                ASSERT_MSG(false, "Unregistering unregistered image in page=0x{:x}",
                            page << YUZU_PAGEBITS);
                 return;
             }
@@ -2095,7 +2095,7 @@ void TextureCache<P>::UnregisterImage(ImageId image_id) {
         ForEachCPUPage(cpu_addr, size, [this, image_id](u64 page) {
             const auto page_it = page_table.find(page);
             if (page_it == page_table.end()) {
-                ASSERT_MSG(false, "Unregistering unregistered page={:#x}", page << YUZU_PAGEBITS);
+                ASSERT_MSG(false, "Unregistering unregistered page=0x{:x}", page << YUZU_PAGEBITS);
                 return;
             }
             std::vector<ImageMapId>& image_map_ids = page_it->second;
@@ -2183,7 +2183,7 @@ void TextureCache<P>::DeleteImage(ImageId image_id, bool immediate_delete) {
     const GPUVAddr gpu_addr = image.gpu_addr;
     const auto alloc_it = image_allocs_table.find(gpu_addr);
     if (alloc_it == image_allocs_table.end()) {
-        ASSERT_MSG(false, "Trying to delete an image alloc that does not exist in address {:#x}",
+        ASSERT_MSG(false, "Trying to delete an image alloc that does not exist in address 0x{:x}",
                    gpu_addr);
         return;
     }