ShuriZma
/
rpcs3
mirror of https://github.com/RPCS3/rpcs3.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' of https://github.com/DHrpcs3/rpcs3

This commit is contained in:
Nekotekina 2014-06-27 17:03:28 +04:00
parent 5ef3b80596 afad6daa7d
commit e6a4ef9eb8
166 changed files with 1798 additions and 1584 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

239
Utilities/Log.cpp Normal file
View File

@ -0,0 +1,239 @@
#include "stdafx.h"
#include "Log.h"
#include <iostream>
#include <string>
#include <cinttypes>
#include <memory>
#include <vector>
#include <mutex>
#include <condition_variable>
#include <thread>
#include <set>
#include <array>
using namespace Log;
LogManager *gLogManager = nullptr;
u32 LogMessage::size()
{
//1 byte for NULL terminator
return sizeof(LogMessage::size_type) + sizeof(LogType) + sizeof(LogSeverity) + sizeof(std::string::value_type)*mText.size() + 1;
}
void LogMessage::serialize(char *output)
{
LogMessage::size_type size = this->size();
memcpy(output, &size, sizeof(LogMessage::size_type));
output += sizeof(LogMessage::size_type);
memcpy(output, &mType, sizeof(LogType));
output += sizeof(LogType);
memcpy(output, &mServerity, sizeof(LogSeverity));
output += sizeof(LogSeverity);
memcpy(output, mText.c_str(), mText.size() );
output += sizeof(std::string::value_type)*mText.size();
*output = '\0';
}
LogMessage LogMessage::deserialize(char *input, u32* size_out)
{
LogMessage msg;
LogMessage::size_type msgSize = *(reinterpret_cast<LogMessage::size_type*>(input));
input += sizeof(LogMessage::size_type);
msg.mType = *(reinterpret_cast<LogType*>(input));
input += sizeof(LogType);
msg.mServerity = *(reinterpret_cast<LogSeverity*>(input));
input += sizeof(LogSeverity);
if (msgSize > 9000)
{
int wtf = 6;
}
msg.mText.append(input, msgSize - 1 - sizeof(LogSeverity) - sizeof(LogType));
if (size_out){(*size_out) = msgSize;}
return msg;
}
LogChannel::LogChannel() : LogChannel("unknown")
{}
LogChannel::LogChannel(const std::string& name) :
name(name)
, mEnabled(true)
, mLogLevel(Warning)
{}
void LogChannel::log(LogMessage msg)
{
std::lock_guard<std::mutex> lock(mListenerLock);
for (auto &listener : mListeners)
{
listener->log(msg);
}
}
void LogChannel::addListener(std::shared_ptr<LogListener> listener)
{
std::lock_guard<std::mutex> lock(mListenerLock);
mListeners.insert(listener);
}
void LogChannel::removeListener(std::shared_ptr<LogListener> listener)
{
std::lock_guard<std::mutex> lock(mListenerLock);
mListeners.erase(listener);
}
struct CoutListener : LogListener
{
void log(LogMessage msg)
{
std::cerr << msg.mText << std::endl;
}
};
struct FileListener : LogListener
{
rFile mFile;
bool mPrependChannelName;
FileListener(const std::string& name = _PRGNAME_, bool prependChannel = true)
: mFile(name + ".log", rFile::write),
mPrependChannelName(prependChannel)
{
if (!mFile.IsOpened())
{
rMessageBox("Can't create log file! (" + name + ".log)", rMessageBoxCaptionStr, rICON_ERROR);
}
}
void log(LogMessage msg)
{
if (mPrependChannelName)
{
msg.mText.insert(0, gTypeNameTable[static_cast<u32>(msg.mType)].mName);
}
mFile.Write(msg.mText);
}
};
LogManager::LogManager()
#ifdef BUFFERED_LOGGING
: mExiting(false), mLogConsumer()
#endif
{
auto it = mChannels.begin();
std::shared_ptr<LogListener> listener(new FileListener());
for (const LogTypeName& name : gTypeNameTable)
{
it->name = name.mName;
it->addListener(listener);
it++;
}
std::shared_ptr<LogListener> TTYListener(new FileListener("TTY",false));
getChannel(TTY).addListener(TTYListener);
#ifdef BUFFERED_LOGGING
mLogConsumer = std::thread(&LogManager::consumeLog, this);
#endif
}
LogManager::~LogManager()
{
#ifdef BUFFERED_LOGGING
mExiting = true;
mBufferReady.notify_all();
mLogConsumer.join();
}
void LogManager::consumeLog()
{
std::unique_lock<std::mutex> lock(mStatusMut);
while (!mExiting)
{
mBufferReady.wait(lock);
mBuffer.lockGet();
size_t size = mBuffer.size();
std::vector<char> local_messages(size);
mBuffer.popN(&local_messages.front(), size);
mBuffer.unlockGet();
u32 cursor = 0;
u32 removed = 0;
while (cursor < size)
{
Log::LogMessage msg = Log::LogMessage::deserialize(local_messages.data() + cursor, &removed);
cursor += removed;
getChannel(msg.mType).log(msg);
}
}
#endif
}
void LogManager::log(LogMessage msg)
{
//don't do any formatting changes or filtering to the TTY output since we
//use the raw output to do diffs with the output of a real PS3 and some
//programs write text in single bytes to the console
if (msg.mType != TTY)
{
std::string prefix;
switch (msg.mServerity)
{
case Success:
prefix = "S ";
break;
case Notice:
prefix = "! ";
break;
case Warning:
prefix = "W ";
break;
case Error:
prefix = "E ";
break;
}
if (NamedThreadBase* thr = GetCurrentNamedThread())
{
prefix += thr->GetThreadName();
}
msg.mText.insert(0, prefix);
msg.mText.append(1,'\n');
}
#ifdef BUFFERED_LOGGING
size_t size = msg.size();
std::vector<char> temp_buffer(size);
msg.serialize(temp_buffer.data());
mBuffer.pushRange(temp_buffer.begin(), temp_buffer.end());
mBufferReady.notify_one();
#else
mChannels[static_cast<u32>(msg.mType)].log(msg);
#endif
}
void LogManager::addListener(std::shared_ptr<LogListener> listener)
{
for (auto& channel : mChannels)
{
channel.addListener(listener);
}
}
void LogManager::removeListener(std::shared_ptr<LogListener> listener)
{
for (auto& channel : mChannels)
{
channel.removeListener(listener);
}
}
LogManager& LogManager::getInstance()
{
if (!gLogManager)
{
gLogManager = new LogManager();
}
return *gLogManager;
}
LogChannel &LogManager::getChannel(LogType type)
{
return mChannels[static_cast<u32>(type)];
}

141
Utilities/Log.h Normal file
View File

@ -0,0 +1,141 @@
#pragma once
#include <iostream>
#include <string>
#include <cinttypes>
#include <memory>
#include <vector>
#include <mutex>
#include <set>
#include <array>
#include "Utilities/MTRingbuffer.h"
//#define BUFFERED_LOGGING 1
//another msvc bug makes these not work, uncomment these and replace it with the one at the bottom when it's fixed
//#define LOG_MESSAGE(logType, severity, text) Log::LogManager::getInstance().log({logType, severity, text})
//first parameter is of type Log::LogType and text is of type std::string
#define LOG_MESSAGE(logType, severity, text) do{Log::LogMessage msg{logType, severity, text}; Log::LogManager::getInstance().log(msg);}while(0)
#define LOG_SUCCESS(logType, text) LOG_MESSAGE(logType, Log::Success, text)
#define LOG_NOTICE(logType, text) LOG_MESSAGE(logType, Log::Notice, text)
#define LOG_WARNING(logType, text) LOG_MESSAGE(logType, Log::Warning, text)
#define LOG_ERROR(logType, text) LOG_MESSAGE(logType, Log::Error, text)
#define LOGF_SUCCESS(logType, fmtstring, ...) LOG_SUCCESS(logType, fmt::Format(fmtstring, ##__VA_ARGS__ ))
#define LOGF_NOTICE(logType, fmtstring, ...) LOG_NOTICE(logType, fmt::Format(fmtstring, ##__VA_ARGS__ ))
#define LOGF_WARNING(logType, fmtstring, ...) LOG_WARNING(logType, fmt::Format(fmtstring, ##__VA_ARGS__ ))
#define LOGF_ERROR(logType, fmtstring, ...) LOG_ERROR(logType, fmt::Format(fmtstring, ##__VA_ARGS__ ))
namespace Log
{
const unsigned int MAX_LOG_BUFFER_LENGTH = 1024*1024;
const unsigned int gBuffSize = 1000;
enum LogType : u32
{
GENERAL = 0,
LOADER,
MEMORY,
RSX,
HLE,
PPU,
SPU,
TTY,
};
struct LogTypeName
{
LogType mType;
std::string mName;
};
//well I'd love make_array() but alas manually counting is not the end of the world
static const std::array<LogTypeName, 8> gTypeNameTable = { {
{ GENERAL, "G: " },
{ LOADER, "LDR: " },
{ MEMORY, "MEM: " },
{ RSX, "RSX: " },
{ HLE, "HLE: " },
{ PPU, "PPU: " },
{ SPU, "SPU: " },
{ TTY, "TTY: " }
} };
enum LogSeverity : u32
{
Success = 0,
Notice,
Warning,
Error,
};
struct LogMessage
{
using size_type = u32;
LogType mType;
LogSeverity mServerity;
std::string mText;
u32 size();
void serialize(char *output);
static LogMessage deserialize(char *input, u32* size_out=nullptr);
};
struct LogListener
{
virtual ~LogListener() {};
virtual void log(LogMessage msg) = 0;
};
struct LogChannel
{
LogChannel();
LogChannel(const std::string& name);
LogChannel(LogChannel& other) = delete;
LogChannel& operator = (LogChannel& other) = delete;
void log(LogMessage msg);
void addListener(std::shared_ptr<LogListener> listener);
void removeListener(std::shared_ptr<LogListener> listener);
std::string name;
private:
bool mEnabled;
LogSeverity mLogLevel;
std::mutex mListenerLock;
std::set<std::shared_ptr<LogListener>> mListeners;
};
struct LogManager
{
LogManager();
~LogManager();
static LogManager& getInstance();
LogChannel& getChannel(LogType type);
void log(LogMessage msg);
void addListener(std::shared_ptr<LogListener> listener);
void removeListener(std::shared_ptr<LogListener> listener);
#ifdef BUFFERED_LOGGING
void consumeLog();
#endif
private:
#ifdef BUFFERED_LOGGING
MTRingbuffer<char, MAX_LOG_BUFFER_LENGTH> mBuffer;
std::condition_variable mBufferReady;
std::mutex mStatusMut;
std::atomic<bool> mExiting;
std::thread mLogConsumer;
#endif
std::array<LogChannel, std::tuple_size<decltype(gTypeNameTable)>::value> mChannels;
//std::array<LogChannel,gTypeNameTable.size()> mChannels; //TODO: use this once Microsoft sorts their shit out
};
}
static struct { inline operator Log::LogType() { return Log::LogType::GENERAL; } } GENERAL;
static struct { inline operator Log::LogType() { return Log::LogType::LOADER; } } LOADER;
static struct { inline operator Log::LogType() { return Log::LogType::MEMORY; } } MEMORY;
static struct { inline operator Log::LogType() { return Log::LogType::RSX; } } RSX;
static struct { inline operator Log::LogType() { return Log::LogType::HLE; } } HLE;
static struct { inline operator Log::LogType() { return Log::LogType::PPU; } } PPU;
static struct { inline operator Log::LogType() { return Log::LogType::SPU; } } SPU;
static struct { inline operator Log::LogType() { return Log::LogType::TTY; } } TTY;

159
Utilities/MTRingbuffer.h Normal file
View File

@ -0,0 +1,159 @@
#pragma once
#include <thread>
#include <array>
#include <mutex>
#include <algorithm>
//Simple non-resizable FIFO Ringbuffer that can be simultaneously be read from and written to
//if we ever get to use boost please replace this with boost::circular_buffer, there's no reason
//why we would have to keep this amateur attempt at such a fundamental data-structure around
template< typename T, unsigned int MAX_MTRINGBUFFER_BUFFER_SIZE>
class MTRingbuffer{
std::array<T, MAX_MTRINGBUFFER_BUFFER_SIZE> mBuffer;
//this is a recursive mutex because the get methods lock it but the only
//way to be sure that they do not block is to check the size and the only
//way to check the size and use get atomically is to lock this mutex,
//so it goes:
//lock get mutex-->check size-->call get-->lock get mutex-->unlock get mutex-->return from get-->unlock get mutex
std::recursive_mutex mMutGet;
std::mutex mMutPut;
size_t mGet;
size_t mPut;
size_t moveGet(size_t by = 1){ return (mGet + by) % MAX_MTRINGBUFFER_BUFFER_SIZE; }
size_t movePut(size_t by = 1){ return (mPut + by) % MAX_MTRINGBUFFER_BUFFER_SIZE; }
public:
MTRingbuffer() : mGet(0), mPut(0){}
//blocks until there's something to get, so check "free()" if you want to avoid blocking
//also lock the get mutex around the free() check and the pop if you want to avoid racing
T pop()
{
std::lock_guard<std::recursive_mutex> lock(mMutGet);
while (mGet == mPut)
{
//wait until there's actually something to get
//throwing an exception might be better, blocking here is a little awkward
std::this_thread::sleep_for(std::chrono::milliseconds(1));
}
size_t ret = mGet;
mGet = moveGet();
return mBuffer[ret];
}
//blocks if the buffer is full until there's enough room
void push(T &putEle)
{
std::lock_guard<std::mutex> lock(mMutPut);
while (movePut() == mGet)
{
//if this is reached a lot it's time to increase the buffer size
//or implement dynamic re-sizing
std::this_thread::sleep_for(std::chrono::milliseconds(1));
}
mBuffer[mPut] = std::forward(putEle);
mPut = movePut();
}
bool empty()
{
return mGet == mPut;
}
//returns the amount of free places, this is the amount of actual free spaces-1
//since mGet==mPut signals an empty buffer we can't actually use the last free
//space, so we shouldn't report it as free.
size_t free()
{
if (mGet < mPut)
{
return mBuffer.size() - (mPut - mGet) - 1;
}
else if (mGet > mPut)
{
return mGet - mPut - 1;
}
else
{
return mBuffer.size() - 1;
}
}
size_t size()
{
//the magic -1 is the same magic 1 that is explained in the free() function
return mBuffer.size() - free() - 1;
}
//takes random access iterator to T
template<typename IteratorType>
void pushRange(IteratorType from, IteratorType until)
{
std::lock_guard<std::mutex> lock(mMutPut);
size_t length = until - from;
//if whatever we're trying to store is greater than the entire buffer the following loop will be infinite
assert(mBuffer.size() > length);
while (free() < length)
{
//if this is reached a lot it's time to increase the buffer size
//or implement dynamic re-sizing
std::this_thread::sleep_for(std::chrono::milliseconds(1));
}
if (mPut + length <= mBuffer.size())
{
std::copy(from, until, mBuffer.begin() + mPut);
}
else
{
size_t tillEnd = mBuffer.size() - mPut;
std::copy(from, from + tillEnd, mBuffer.begin() + mPut);
std::copy(from + tillEnd, until, mBuffer.begin());
}
mPut = movePut(length);
}
//takes output iterator to T
template<typename IteratorType>
void popN(IteratorType output, size_t n)
{
std::lock_guard<std::recursive_mutex> lock(mMutGet);
//make sure we're not trying to retrieve more than is in
assert(n <= size());
peekN<IteratorType>(output, n);
mGet = moveGet(n);
}
//takes output iterator to T
template<typename IteratorType>
void peekN(IteratorType output, size_t n)
{
size_t lGet = mGet;
if (lGet + n <= mBuffer.size())
{
std::copy_n(mBuffer.begin() + lGet, n, output);
}
else
{
auto next = std::copy(mBuffer.begin() + lGet, mBuffer.end(), output);
std::copy_n(mBuffer.begin(), n - (mBuffer.size() - lGet), next);
}
}
//well this is just asking for trouble
//but the comment above the declaration of mMutGet explains why it's there
//if there's a better way please remove this
void lockGet()
{
mMutGet.lock();
}
//well this is just asking for trouble
//but the comment above the declaration of mMutGet explains why it's there
//if there's a better way please remove this
void unlockGet()
{
mMutGet.unlock();
}
};

2
Utilities/SMutex.cpp
View File

@ -1,5 +1,5 @@
#include <stdafx.h> #include <stdafx.h>
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/CPU/CPUThread.h" #include "Emu/CPU/CPUThread.h"

2
Utilities/SMutex.h
View File

@ -148,7 +148,7 @@ public:
{ {
if (!Emu.IsStopped()) if (!Emu.IsStopped())
{ {
ConLog.Error("SMutexLockerBase: thread id == 0"); LOG_ERROR(HLE, "SMutexLockerBase: thread id == 0");
Emu.Pause(); Emu.Pause();
} }
return; return;

1
Utilities/StrFmt.h
View File

@ -4,6 +4,7 @@
#include <ostream> #include <ostream>
#include <sstream> #include <sstream>
#include <cstdio> #include <cstdio>
#include <functional>
#if defined(_MSC_VER) #if defined(_MSC_VER)
#define snprintf _snprintf #define snprintf _snprintf

4
Utilities/Thread.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Thread.h" #include "Thread.h"
@ -134,7 +134,7 @@ void thread::start(std::function<void()> func)
} }
catch(...) catch(...)
{ {
ConLog.Error("Crash :("); LOG_ERROR(HLE, "Crash :(");
//std::terminate(); //std::terminate();
} }

2
Utilities/rFile.cpp
View File

@ -120,7 +120,7 @@ size_t rFile::Write(const void *buffer, size_t count)
bool rFile::Write(const std::string &text) bool rFile::Write(const std::string &text)
{ {
return reinterpret_cast<wxFile*>(handle)->Write(fmt::FromUTF8(text)); return reinterpret_cast<wxFile*>(handle)->Write(reinterpret_cast<const void*>(text.c_str()),text.size());
} }
bool rFile::Close() bool rFile::Close()

88
rpcs3/Crypto/unedat.cpp
View File

@ -1,6 +1,6 @@
#include "stdafx.h" #include "stdafx.h"
#include "unedat.h" #include "unedat.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
void generate_key(int crypto_mode, int version, unsigned char *key_final, unsigned char *iv_final, unsigned char *key, unsigned char *iv) void generate_key(int crypto_mode, int version, unsigned char *key_final, unsigned char *iv_final, unsigned char *key, unsigned char *iv)
{ {
@ -74,7 +74,7 @@ bool crypto(int hash_mode, int crypto_mode, int version, unsigned char *in, unsi
} }
else else
{ {
ConLog.Error("EDAT: Unknown crypto algorithm!\n"); LOG_ERROR(LOADER, "EDAT: Unknown crypto algorithm!\n");
return false; return false;
} }
@ -92,7 +92,7 @@ bool crypto(int hash_mode, int crypto_mode, int version, unsigned char *in, unsi
} }
else else
{ {
ConLog.Error("EDAT: Unknown hashing algorithm!\n"); LOG_ERROR(LOADER, "EDAT: Unknown hashing algorithm!\n");
return false; return false;
} }
} }
@ -158,7 +158,7 @@ int decrypt_data(rFile *in, rFile *out, EDAT_SDAT_HEADER *edat, NPD_HEADER *npd,
if ((edat->flags & EDAT_FLAG_0x3C) != 0 || (edat->flags & EDAT_FLAG_0x3D) != 0) if ((edat->flags & EDAT_FLAG_0x3C) != 0 || (edat->flags & EDAT_FLAG_0x3D) != 0)
{ {
ConLog.Error("EDAT: Flag 0x3C/0x3D EDAT files are unsupported yet"); LOG_ERROR(LOADER, "EDAT: Flag 0x3C/0x3D EDAT files are unsupported yet");
return -1; return -1;
} }
@ -268,15 +268,15 @@ int decrypt_data(rFile *in, rFile *out, EDAT_SDAT_HEADER *edat, NPD_HEADER *npd,
memset(decomp_data, 0, decomp_size); memset(decomp_data, 0, decomp_size);
if (verbose) if (verbose)
ConLog.Write("EDAT: Decompressing...\n"); LOG_NOTICE(LOADER, "EDAT: Decompressing...\n");
int res = lz_decompress(decomp_data, dec_data, decomp_size); int res = lz_decompress(decomp_data, dec_data, decomp_size);
out->Write(decomp_data, res); out->Write(decomp_data, res);
if (verbose) if (verbose)
{ {
ConLog.Write("EDAT: Compressed block size: %d\n", pad_length); LOGF_NOTICE(LOADER, "EDAT: Compressed block size: %d\n", pad_length);
ConLog.Write("EDAT: Decompressed block size: %d\n", res); LOGF_NOTICE(LOADER, "EDAT: Decompressed block size: %d\n", res);
} }
edat->file_size -= res; edat->file_size -= res;
@ -285,11 +285,11 @@ int decrypt_data(rFile *in, rFile *out, EDAT_SDAT_HEADER *edat, NPD_HEADER *npd,
{ {
if (res < 0) if (res < 0)
{ {
ConLog.Error("EDAT: Decompression failed!\n"); LOG_ERROR(LOADER, "EDAT: Decompression failed!\n");
return 1; return 1;
} }
else else
ConLog.Success("EDAT: Data successfully decompressed!\n"); LOG_SUCCESS(LOADER, "EDAT: Data successfully decompressed!\n");
} }
delete[] decomp_data; delete[] decomp_data;
@ -315,7 +315,7 @@ static bool check_flags(EDAT_SDAT_HEADER *edat, NPD_HEADER *npd)
{ {
if (edat->flags & 0x7EFFFFFE) if (edat->flags & 0x7EFFFFFE)
{ {
ConLog.Error("EDAT: Bad header flags!\n"); LOG_ERROR(LOADER, "EDAT: Bad header flags!\n");
return false; return false;
} }
} }
@ -323,7 +323,7 @@ static bool check_flags(EDAT_SDAT_HEADER *edat, NPD_HEADER *npd)
{ {
if (edat->flags & 0x7EFFFFE0) if (edat->flags & 0x7EFFFFE0)
{ {
ConLog.Error("EDAT: Bad header flags!\n"); LOG_ERROR(LOADER, "EDAT: Bad header flags!\n");
return false; return false;
} }
} }
@ -331,13 +331,13 @@ static bool check_flags(EDAT_SDAT_HEADER *edat, NPD_HEADER *npd)
{ {
if (edat->flags & 0x7EFFFFC0) if (edat->flags & 0x7EFFFFC0)
{ {
ConLog.Error("EDAT: Bad header flags!\n"); LOG_ERROR(LOADER, "EDAT: Bad header flags!\n");
return false; return false;
} }
} }
else if (npd->version > 4) else if (npd->version > 4)
{ {
ConLog.Error("EDAT: Unknown version - %d\n", npd->version); LOGF_ERROR(LOADER, "EDAT: Unknown version - %d\n", npd->version);
return false; return false;
} }
@ -370,7 +370,7 @@ int check_data(unsigned char *key, EDAT_SDAT_HEADER *edat, NPD_HEADER *npd, rFil
int hash_mode = ((edat->flags & EDAT_ENCRYPTED_KEY_FLAG) == 0) ? 0x00000002 : 0x10000002; int hash_mode = ((edat->flags & EDAT_ENCRYPTED_KEY_FLAG) == 0) ? 0x00000002 : 0x10000002;
if ((edat->flags & EDAT_DEBUG_DATA_FLAG) != 0) if ((edat->flags & EDAT_DEBUG_DATA_FLAG) != 0)
{ {
ConLog.Warning("EDAT: DEBUG data detected!\n"); LOG_ERROR(LOADER, "EDAT: DEBUG data detected!\n");
hash_mode |= 0x01000000; hash_mode |= 0x01000000;
} }
@ -382,14 +382,14 @@ int check_data(unsigned char *key, EDAT_SDAT_HEADER *edat, NPD_HEADER *npd, rFil
if (!crypto(hash_mode, crypto_mode, (npd->version == 4), header, tmp, 0xA0, header_key, header_iv, key, hash_result)) if (!crypto(hash_mode, crypto_mode, (npd->version == 4), header, tmp, 0xA0, header_key, header_iv, key, hash_result))
{ {
if (verbose) if (verbose)
ConLog.Warning("EDAT: Header hash is invalid!\n"); LOG_WARNING(LOADER, "EDAT: Header hash is invalid!\n");
} }
// Parse the metadata info. // Parse the metadata info.
int metadata_section_size = 0x10; int metadata_section_size = 0x10;
if (((edat->flags & EDAT_COMPRESSED_FLAG) != 0)) if (((edat->flags & EDAT_COMPRESSED_FLAG) != 0))
{ {
ConLog.Warning("EDAT: COMPRESSED data detected!\n"); LOG_WARNING(LOADER, "EDAT: COMPRESSED data detected!\n");
metadata_section_size = 0x20; metadata_section_size = 0x20;
} }
@ -418,7 +418,7 @@ int check_data(unsigned char *key, EDAT_SDAT_HEADER *edat, NPD_HEADER *npd, rFil
if (!crypto(hash_mode, crypto_mode, (npd->version == 4), data, tmp, block_size, header_key, header_iv, key, hash_result)) if (!crypto(hash_mode, crypto_mode, (npd->version == 4), data, tmp, block_size, header_key, header_iv, key, hash_result))
{ {
if (verbose) if (verbose)
ConLog.Warning("EDAT: Metadata hash from block 0x%08x is invalid!\n", metadata_offset + bytes_read); LOGF_WARNING(LOADER, "EDAT: Metadata hash from block 0x%08x is invalid!\n", metadata_offset + bytes_read);
} }
// Adjust sizes. // Adjust sizes.
@ -455,9 +455,9 @@ void validate_data(const char* file_name, unsigned char *klicensee, NPD_HEADER *
if (verbose) if (verbose)
{ {
if (title_hash_result) if (title_hash_result)
ConLog.Success("EDAT: NPD title hash is valid!\n"); LOG_SUCCESS(LOADER, "EDAT: NPD title hash is valid!\n");
else else
ConLog.Warning("EDAT: NPD title hash is invalid!\n"); LOG_WARNING(LOADER, "EDAT: NPD title hash is invalid!\n");
} }
// Check for an empty dev_hash (can't validate if devklic is NULL); // Check for an empty dev_hash (can't validate if devklic is NULL);
@ -474,7 +474,7 @@ void validate_data(const char* file_name, unsigned char *klicensee, NPD_HEADER *
if (isDevklicEmpty) if (isDevklicEmpty)
{ {
if (verbose) if (verbose)
ConLog.Warning("EDAT: NPD dev hash is empty!\n"); LOG_WARNING(LOADER, "EDAT: NPD dev hash is empty!\n");
} }
else else
{ {
@ -487,9 +487,9 @@ void validate_data(const char* file_name, unsigned char *klicensee, NPD_HEADER *
if (verbose) if (verbose)
{ {
if (dev_hash_result) if (dev_hash_result)
ConLog.Success("EDAT: NPD dev hash is valid!\n"); LOG_SUCCESS(LOADER, "EDAT: NPD dev hash is valid!\n");
else else
ConLog.Warning("EDAT: NPD dev hash is invalid!\n"); LOG_WARNING(LOADER, "EDAT: NPD dev hash is invalid!\n");
} }
} }
@ -522,7 +522,7 @@ bool extract_data(rFile *input, rFile *output, const char* input_file_name, unsi
unsigned char npd_magic[4] = {0x4E, 0x50, 0x44, 0x00}; //NPD0 unsigned char npd_magic[4] = {0x4E, 0x50, 0x44, 0x00}; //NPD0
if(memcmp(NPD->magic, npd_magic, 4)) if(memcmp(NPD->magic, npd_magic, 4))
{ {
ConLog.Error("EDAT: File has invalid NPD header."); LOG_ERROR(LOADER, "EDAT: File has invalid NPD header.");
delete NPD; delete NPD;
delete EDAT; delete EDAT;
return 1; return 1;
@ -534,16 +534,16 @@ bool extract_data(rFile *input, rFile *output, const char* input_file_name, unsi
if (verbose) if (verbose)
{ {
ConLog.Write("NPD HEADER\n"); LOG_NOTICE(LOADER, "NPD HEADER\n");
ConLog.Write("NPD version: %d\n", NPD->version); LOGF_NOTICE(LOADER, "NPD version: %d\n", NPD->version);
ConLog.Write("NPD license: %d\n", NPD->license); LOGF_NOTICE(LOADER, "NPD license: %d\n", NPD->license);
ConLog.Write("NPD type: %d\n", NPD->type); LOGF_NOTICE(LOADER, "NPD type: %d\n", NPD->type);
ConLog.Write("\n"); LOG_NOTICE(LOADER, "\n");
ConLog.Write("EDAT HEADER\n"); LOG_NOTICE(LOADER, "EDAT HEADER\n");
ConLog.Write("EDAT flags: 0x%08X\n", EDAT->flags); LOGF_NOTICE(LOADER, "EDAT flags: 0x%08X\n", EDAT->flags);
ConLog.Write("EDAT block size: 0x%08X\n", EDAT->block_size); LOGF_NOTICE(LOADER, "EDAT block size: 0x%08X\n", EDAT->block_size);
ConLog.Write("EDAT file size: 0x%08X\n", EDAT->file_size); LOGF_NOTICE(LOADER, "EDAT file size: 0x%08X\n", EDAT->file_size);
ConLog.Write("\n"); LOG_NOTICE(LOADER, "\n");
} }
// Set decryption key. // Set decryption key.
@ -552,7 +552,7 @@ bool extract_data(rFile *input, rFile *output, const char* input_file_name, unsi
if((EDAT->flags & SDAT_FLAG) == SDAT_FLAG) if((EDAT->flags & SDAT_FLAG) == SDAT_FLAG)
{ {
ConLog.Warning("EDAT: SDAT detected!\n"); LOG_WARNING(LOADER, "EDAT: SDAT detected!\n");
xor_(key, NPD->dev_hash, SDAT_KEY, 0x10); xor_(key, NPD->dev_hash, SDAT_KEY, 0x10);
} }
else else
@ -579,7 +579,7 @@ bool extract_data(rFile *input, rFile *output, const char* input_file_name, unsi
if (!test) if (!test)
{ {
ConLog.Error("EDAT: A valid RAP file is needed!"); LOG_ERROR(LOADER, "EDAT: A valid RAP file is needed!");
delete NPD; delete NPD;
delete EDAT; delete EDAT;
return 1; return 1;
@ -587,19 +587,19 @@ bool extract_data(rFile *input, rFile *output, const char* input_file_name, unsi
} }
} }
ConLog.Write("EDAT: Parsing data...\n"); LOG_NOTICE(LOADER, "EDAT: Parsing data...\n");
if (check_data(key, EDAT, NPD, input, verbose)) if (check_data(key, EDAT, NPD, input, verbose))
ConLog.Error("EDAT: Data parsing failed!\n"); LOG_ERROR(LOADER, "EDAT: Data parsing failed!\n");
else else
ConLog.Success("EDAT: Data successfully parsed!\n"); LOG_SUCCESS(LOADER, "EDAT: Data successfully parsed!\n");
printf("\n"); printf("\n");
ConLog.Write("EDAT: Decrypting data...\n"); LOG_NOTICE(LOADER, "EDAT: Decrypting data...\n");
if (decrypt_data(input, output, EDAT, NPD, key, verbose)) if (decrypt_data(input, output, EDAT, NPD, key, verbose))
ConLog.Error("EDAT: Data decryption failed!"); LOG_ERROR(LOADER, "EDAT: Data decryption failed!");
else else
ConLog.Success("EDAT: Data successfully decrypted!"); LOG_SUCCESS(LOADER, "EDAT: Data successfully decrypted!");
delete NPD; delete NPD;
delete EDAT; delete EDAT;
@ -652,21 +652,21 @@ int DecryptEDAT(const std::string& input_file_name, const std::string& output_fi
memcpy(devklic, custom_klic, 0x10); memcpy(devklic, custom_klic, 0x10);
else else
{ {
ConLog.Error("EDAT: Invalid custom klic!\n"); LOG_ERROR(LOADER, "EDAT: Invalid custom klic!\n");
return -1; return -1;
} }
break; break;
} }
default: default:
ConLog.Error("EDAT: Invalid mode!\n"); LOG_ERROR(LOADER, "EDAT: Invalid mode!\n");
return -1; return -1;
} }
// Check the input/output files. // Check the input/output files.
if (!input.IsOpened() || !output.IsOpened()) if (!input.IsOpened() || !output.IsOpened())
{ {
ConLog.Error("EDAT: Failed to open files!\n"); LOG_ERROR(LOADER, "EDAT: Failed to open files!\n");
return -1; return -1;
} }

18
rpcs3/Crypto/unpkg.cpp
View File

@ -2,13 +2,13 @@
#include "unpkg.h" #include "unpkg.h"
#include <wx/progdlg.h> #include <wx/progdlg.h>
#include "Emu/ConLog.h" #include "Utilities/Log.h"
// Decryption. // Decryption.
bool CheckHeader(rFile& pkg_f, PKGHeader* m_header) bool CheckHeader(rFile& pkg_f, PKGHeader* m_header)
{ {
if (m_header->pkg_magic != 0x7F504B47) { if (m_header->pkg_magic != 0x7F504B47) {
ConLog.Error("PKG: Not a package file!"); LOG_ERROR(LOADER, "PKG: Not a package file!");
return false; return false;
} }
@ -17,7 +17,7 @@ bool CheckHeader(rFile& pkg_f, PKGHeader* m_header)
case PKG_RELEASE_TYPE_DEBUG: break; case PKG_RELEASE_TYPE_DEBUG: break;
case PKG_RELEASE_TYPE_RELEASE: break; case PKG_RELEASE_TYPE_RELEASE: break;
default: default:
ConLog.Error("PKG: Unknown PKG type!"); LOG_ERROR(LOADER, "PKG: Unknown PKG type!");
return false; return false;
} }
@ -26,22 +26,22 @@ bool CheckHeader(rFile& pkg_f, PKGHeader* m_header)
case PKG_PLATFORM_TYPE_PS3: break; case PKG_PLATFORM_TYPE_PS3: break;
case PKG_PLATFORM_TYPE_PSP: break; case PKG_PLATFORM_TYPE_PSP: break;
default: default:
ConLog.Error("PKG: Unknown PKG type!"); LOG_ERROR(LOADER, "PKG: Unknown PKG type!");
return false; return false;
} }
if (m_header->header_size != PKG_HEADER_SIZE) { if (m_header->header_size != PKG_HEADER_SIZE) {
ConLog.Error("PKG: Wrong header size!"); LOG_ERROR(LOADER, "PKG: Wrong header size!");
return false; return false;
} }
if (m_header->pkg_size != pkg_f.Length()) { if (m_header->pkg_size != pkg_f.Length()) {
ConLog.Error("PKG: File size mismatch."); LOG_ERROR(LOADER, "PKG: File size mismatch.");
return false; return false;
} }
if (m_header->data_size + m_header->data_offset + 0x60 != pkg_f.Length()) { if (m_header->data_size + m_header->data_offset + 0x60 != pkg_f.Length()) {
ConLog.Error("PKG: Data size mismatch."); LOG_ERROR(LOADER, "PKG: Data size mismatch.");
return false; return false;
} }
@ -53,7 +53,7 @@ bool LoadHeader(rFile& pkg_f, PKGHeader* m_header)
pkg_f.Seek(0); pkg_f.Seek(0);
if (pkg_f.Read(m_header, sizeof(PKGHeader)) != sizeof(PKGHeader)) { if (pkg_f.Read(m_header, sizeof(PKGHeader)) != sizeof(PKGHeader)) {
ConLog.Error("PKG: Package file is too short!"); LOG_ERROR(LOADER, "PKG: Package file is too short!");
return false; return false;
} }
@ -141,7 +141,7 @@ bool LoadEntries(rFile& dec_pkg_f, PKGHeader* m_header, PKGEntry *m_entries)
dec_pkg_f.Read(m_entries, sizeof(PKGEntry) * m_header->file_count); dec_pkg_f.Read(m_entries, sizeof(PKGEntry) * m_header->file_count);
if (m_entries->name_offset / sizeof(PKGEntry) != m_header->file_count) { if (m_entries->name_offset / sizeof(PKGEntry) != m_header->file_count) {
ConLog.Error("PKG: Entries are damaged!"); LOG_ERROR(LOADER, "PKG: Entries are damaged!");
return false; return false;
} }

98
rpcs3/Crypto/unself.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/FS/vfsLocalFile.h" #include "Emu/FS/vfsLocalFile.h"
#include "unself.h" #include "unself.h"
@ -17,7 +17,7 @@ bool SELFDecrypter::LoadHeaders(bool isElf32)
// Check SCE magic. // Check SCE magic.
if (!sce_hdr.CheckMagic()) if (!sce_hdr.CheckMagic())
{ {
ConLog.Error("SELF: Not a SELF file!"); LOGF_ERROR(LOADER, "SELF: Not a SELF file!");
return false; return false;
} }
@ -41,7 +41,7 @@ bool SELFDecrypter::LoadHeaders(bool isElf32)
phdr32_arr.clear(); phdr32_arr.clear();
if(elf32_hdr.e_phoff == 0 && elf32_hdr.e_phnum) if(elf32_hdr.e_phoff == 0 && elf32_hdr.e_phnum)
{ {
ConLog.Error("SELF: ELF program header offset is null!"); LOGF_ERROR(LOADER, "SELF: ELF program header offset is null!");
return false; return false;
} }
self_f.Seek(self_hdr.se_phdroff); self_f.Seek(self_hdr.se_phdroff);
@ -56,7 +56,7 @@ bool SELFDecrypter::LoadHeaders(bool isElf32)
phdr64_arr.clear(); phdr64_arr.clear();
if(elf64_hdr.e_phoff == 0 && elf64_hdr.e_phnum) if(elf64_hdr.e_phoff == 0 && elf64_hdr.e_phnum)
{ {
ConLog.Error("SELF: ELF program header offset is null!"); LOGF_ERROR(LOADER, "SELF: ELF program header offset is null!");
return false; return false;
} }
self_f.Seek(self_hdr.se_phdroff); self_f.Seek(self_hdr.se_phdroff);
@ -101,7 +101,7 @@ bool SELFDecrypter::LoadHeaders(bool isElf32)
shdr32_arr.clear(); shdr32_arr.clear();
if(elf32_hdr.e_shoff == 0 && elf32_hdr.e_shnum) if(elf32_hdr.e_shoff == 0 && elf32_hdr.e_shnum)
{ {
ConLog.Warning("SELF: ELF section header offset is null!"); LOGF_WARNING(LOADER, "SELF: ELF section header offset is null!");
return true; return true;
} }
self_f.Seek(self_hdr.se_shdroff); self_f.Seek(self_hdr.se_shdroff);
@ -116,7 +116,7 @@ bool SELFDecrypter::LoadHeaders(bool isElf32)
shdr64_arr.clear(); shdr64_arr.clear();
if(elf64_hdr.e_shoff == 0 && elf64_hdr.e_shnum) if(elf64_hdr.e_shoff == 0 && elf64_hdr.e_shnum)
{ {
ConLog.Warning("SELF: ELF section header offset is null!"); LOGF_WARNING(LOADER, "SELF: ELF section header offset is null!");
return true; return true;
} }
self_f.Seek(self_hdr.se_shdroff); self_f.Seek(self_hdr.se_shdroff);
@ -132,46 +132,46 @@ bool SELFDecrypter::LoadHeaders(bool isElf32)
void SELFDecrypter::ShowHeaders(bool isElf32) void SELFDecrypter::ShowHeaders(bool isElf32)
{ {
ConLog.Write("SCE header"); LOGF_NOTICE(LOADER, "SCE header");
ConLog.Write("----------------------------------------------------"); LOGF_NOTICE(LOADER, "----------------------------------------------------");
sce_hdr.Show(); sce_hdr.Show();
ConLog.Write("----------------------------------------------------"); LOGF_NOTICE(LOADER, "----------------------------------------------------");
ConLog.Write("SELF header"); LOGF_NOTICE(LOADER, "SELF header");
ConLog.Write("----------------------------------------------------"); LOGF_NOTICE(LOADER, "----------------------------------------------------");
self_hdr.Show(); self_hdr.Show();
ConLog.Write("----------------------------------------------------"); LOGF_NOTICE(LOADER, "----------------------------------------------------");
ConLog.Write("APP INFO"); LOGF_NOTICE(LOADER, "APP INFO");
ConLog.Write("----------------------------------------------------"); LOGF_NOTICE(LOADER, "----------------------------------------------------");
app_info.Show(); app_info.Show();
ConLog.Write("----------------------------------------------------"); LOGF_NOTICE(LOADER, "----------------------------------------------------");
ConLog.Write("ELF header"); LOGF_NOTICE(LOADER, "ELF header");
ConLog.Write("----------------------------------------------------"); LOGF_NOTICE(LOADER, "----------------------------------------------------");
isElf32 ? elf32_hdr.Show() : elf64_hdr.Show(); isElf32 ? elf32_hdr.Show() : elf64_hdr.Show();
ConLog.Write("----------------------------------------------------"); LOGF_NOTICE(LOADER, "----------------------------------------------------");
ConLog.Write("ELF program headers"); LOGF_NOTICE(LOADER, "ELF program headers");
ConLog.Write("----------------------------------------------------"); LOGF_NOTICE(LOADER, "----------------------------------------------------");
for(unsigned int i = 0; i < ((isElf32) ? phdr32_arr.size() : phdr64_arr.size()); i++) for(unsigned int i = 0; i < ((isElf32) ? phdr32_arr.size() : phdr64_arr.size()); i++)
isElf32 ? phdr32_arr[i].Show() : phdr64_arr[i].Show(); isElf32 ? phdr32_arr[i].Show() : phdr64_arr[i].Show();
ConLog.Write("----------------------------------------------------"); LOGF_NOTICE(LOADER, "----------------------------------------------------");
ConLog.Write("Section info"); LOGF_NOTICE(LOADER, "Section info");
ConLog.Write("----------------------------------------------------"); LOGF_NOTICE(LOADER, "----------------------------------------------------");
for(unsigned int i = 0; i < secinfo_arr.size(); i++) for(unsigned int i = 0; i < secinfo_arr.size(); i++)
secinfo_arr[i].Show(); secinfo_arr[i].Show();
ConLog.Write("----------------------------------------------------"); LOGF_NOTICE(LOADER, "----------------------------------------------------");
ConLog.Write("SCE version info"); LOGF_NOTICE(LOADER, "SCE version info");
ConLog.Write("----------------------------------------------------"); LOGF_NOTICE(LOADER, "----------------------------------------------------");
scev_info.Show(); scev_info.Show();
ConLog.Write("----------------------------------------------------"); LOGF_NOTICE(LOADER, "----------------------------------------------------");
ConLog.Write("Control info"); LOGF_NOTICE(LOADER, "Control info");
ConLog.Write("----------------------------------------------------"); LOGF_NOTICE(LOADER, "----------------------------------------------------");
for(unsigned int i = 0; i < ctrlinfo_arr.size(); i++) for(unsigned int i = 0; i < ctrlinfo_arr.size(); i++)
ctrlinfo_arr[i].Show(); ctrlinfo_arr[i].Show();
ConLog.Write("----------------------------------------------------"); LOGF_NOTICE(LOADER, "----------------------------------------------------");
ConLog.Write("ELF section headers"); LOGF_NOTICE(LOADER, "ELF section headers");
ConLog.Write("----------------------------------------------------"); LOGF_NOTICE(LOADER, "----------------------------------------------------");
for(unsigned int i = 0; i < ((isElf32) ? shdr32_arr.size() : shdr64_arr.size()); i++) for(unsigned int i = 0; i < ((isElf32) ? shdr32_arr.size() : shdr64_arr.size()); i++)
isElf32 ? shdr32_arr[i].Show() : shdr64_arr[i].Show(); isElf32 ? shdr32_arr[i].Show() : shdr64_arr[i].Show();
ConLog.Write("----------------------------------------------------"); LOGF_NOTICE(LOADER, "----------------------------------------------------");
} }
bool SELFDecrypter::DecryptNPDRM(u8 *metadata, u32 metadata_size) bool SELFDecrypter::DecryptNPDRM(u8 *metadata, u32 metadata_size)
@ -195,7 +195,7 @@ bool SELFDecrypter::DecryptNPDRM(u8 *metadata, u32 metadata_size)
// If not, the data has no NPDRM layer. // If not, the data has no NPDRM layer.
if (!ctrl) if (!ctrl)
{ {
ConLog.Warning("SELF: No NPDRM control info found!"); LOGF_WARNING(LOADER, "SELF: No NPDRM control info found!");
return true; return true;
} }
@ -208,7 +208,7 @@ bool SELFDecrypter::DecryptNPDRM(u8 *metadata, u32 metadata_size)
if (ctrl->npdrm.license == 1) // Network license. if (ctrl->npdrm.license == 1) // Network license.
{ {
ConLog.Error("SELF: Can't decrypt network NPDRM!"); LOGF_ERROR(LOADER, "SELF: Can't decrypt network NPDRM!");
return false; return false;
} }
else if (ctrl->npdrm.license == 2) // Local license. else if (ctrl->npdrm.license == 2) // Local license.
@ -216,7 +216,7 @@ bool SELFDecrypter::DecryptNPDRM(u8 *metadata, u32 metadata_size)
// Try to find a RAP file to get the key. // Try to find a RAP file to get the key.
if (!GetKeyFromRap(ctrl->npdrm.content_id, npdrm_key)) if (!GetKeyFromRap(ctrl->npdrm.content_id, npdrm_key))
{ {
ConLog.Error("SELF: Can't find RAP file for NPDRM decryption!"); LOGF_ERROR(LOADER, "SELF: Can't find RAP file for NPDRM decryption!");
return false; return false;
} }
} }
@ -227,7 +227,7 @@ bool SELFDecrypter::DecryptNPDRM(u8 *metadata, u32 metadata_size)
} }
else else
{ {
ConLog.Error("SELF: Invalid NPDRM license type!"); LOGF_ERROR(LOADER, "SELF: Invalid NPDRM license type!");
return false; return false;
} }
@ -290,7 +290,7 @@ bool SELFDecrypter::LoadMetadata()
if ((meta_info.key_pad[0] != 0x00) || if ((meta_info.key_pad[0] != 0x00) ||
(meta_info.iv_pad[0] != 0x00)) (meta_info.iv_pad[0] != 0x00))
{ {
ConLog.Error("SELF: Failed to decrypt metadata info!"); LOGF_ERROR(LOADER, "SELF: Failed to decrypt metadata info!");
return false; return false;
} }
@ -392,7 +392,7 @@ bool SELFDecrypter::MakeElf(const std::string& elf, bool isElf32)
rFile e(elf.c_str(), rFile::write); rFile e(elf.c_str(), rFile::write);
if(!e.IsOpened()) if(!e.IsOpened())
{ {
ConLog.Error("Could not create ELF file! (%s)", elf.c_str()); LOGF_ERROR(LOADER, "Could not create ELF file! (%s)", elf.c_str());
return false; return false;
} }
@ -510,7 +510,7 @@ bool SELFDecrypter::GetKeyFromRap(u8 *content_id, u8 *npdrm_key)
// Check if we have a valid RAP file. // Check if we have a valid RAP file.
if (!rFile::Exists(rap_path)) if (!rFile::Exists(rap_path))
{ {
ConLog.Error("This application requires a valid RAP file for decryption!"); LOGF_ERROR(LOADER, "This application requires a valid RAP file for decryption!");
return false; return false;
} }
@ -519,11 +519,11 @@ bool SELFDecrypter::GetKeyFromRap(u8 *content_id, u8 *npdrm_key)
if (!rap_file.IsOpened()) if (!rap_file.IsOpened())
{ {
ConLog.Error("Failed to load RAP file!"); LOGF_ERROR(LOADER, "Failed to load RAP file!");
return false; return false;
} }
ConLog.Write("Loading RAP file %s", (ci_str + ".rap").c_str()); LOGF_NOTICE(LOADER, "Loading RAP file %s", (ci_str + ".rap").c_str());
rap_file.Read(rap_key, 0x10); rap_file.Read(rap_key, 0x10);
rap_file.Close(); rap_file.Close();
@ -573,7 +573,7 @@ bool CheckDebugSelf(const std::string& self, const std::string& elf)
if(!s.IsOpened()) if(!s.IsOpened())
{ {
ConLog.Error("Could not open SELF file! (%s)", self.c_str()); LOGF_ERROR(LOADER, "Could not open SELF file! (%s)", self.c_str());
return false; return false;
} }
@ -585,7 +585,7 @@ bool CheckDebugSelf(const std::string& self, const std::string& elf)
// Check for DEBUG version. // Check for DEBUG version.
if(swap16(key_version) == 0x8000) if(swap16(key_version) == 0x8000)
{ {
ConLog.Warning("Debug SELF detected! Removing fake header..."); LOGF_WARNING(LOADER, "Debug SELF detected! Removing fake header...");
// Get the real elf offset. // Get the real elf offset.
s.Seek(0x10); s.Seek(0x10);
@ -600,7 +600,7 @@ bool CheckDebugSelf(const std::string& self, const std::string& elf)
rFile e(elf, rFile::write); rFile e(elf, rFile::write);
if(!e.IsOpened()) if(!e.IsOpened())
{ {
ConLog.Error("Could not create ELF file! (%s)", elf.c_str()); LOGF_ERROR(LOADER, "Could not create ELF file! (%s)", elf.c_str());
return false; return false;
} }
@ -640,28 +640,28 @@ bool DecryptSelf(const std::string& elf, const std::string& self)
// Load the SELF file headers. // Load the SELF file headers.
if (!self_dec.LoadHeaders(isElf32)) if (!self_dec.LoadHeaders(isElf32))
{ {
ConLog.Error("SELF: Failed to load SELF file headers!"); LOGF_ERROR(LOADER, "SELF: Failed to load SELF file headers!");
return false; return false;
} }
// Load and decrypt the SELF file metadata. // Load and decrypt the SELF file metadata.
if (!self_dec.LoadMetadata()) if (!self_dec.LoadMetadata())
{ {
ConLog.Error("SELF: Failed to load SELF file metadata!"); LOGF_ERROR(LOADER, "SELF: Failed to load SELF file metadata!");
return false; return false;
} }
// Decrypt the SELF file data. // Decrypt the SELF file data.
if (!self_dec.DecryptData()) if (!self_dec.DecryptData())
{ {
ConLog.Error("SELF: Failed to decrypt SELF file data!"); LOGF_ERROR(LOADER, "SELF: Failed to decrypt SELF file data!");
return false; return false;
} }
// Make a new ELF file from this SELF. // Make a new ELF file from this SELF.
if (!self_dec.MakeElf(elf, isElf32)) if (!self_dec.MakeElf(elf, isElf32))
{ {
ConLog.Error("SELF: Failed to make ELF file from SELF!"); LOGF_ERROR(LOADER, "SELF: Failed to make ELF file from SELF!");
return false; return false;
} }
} }

122
rpcs3/Crypto/unself.h
View File

@ -25,10 +25,10 @@ struct AppInfo
void Show() void Show()
{ {
ConLog.Write("AuthID: 0x%llx", authid); LOGF_NOTICE(LOADER, "AuthID: 0x%llx", authid);
ConLog.Write("VendorID: 0x%08x", vendor_id); LOGF_NOTICE(LOADER, "VendorID: 0x%08x", vendor_id);
ConLog.Write("SELF type: 0x%08x", self_type); LOGF_NOTICE(LOADER, "SELF type: 0x%08x", self_type);
ConLog.Write("Version: 0x%llx", version); LOGF_NOTICE(LOADER, "Version: 0x%llx", version);
} }
}; };
@ -53,12 +53,12 @@ struct SectionInfo
void Show() void Show()
{ {
ConLog.Write("Offset: 0x%llx", offset); LOGF_NOTICE(LOADER, "Offset: 0x%llx", offset);
ConLog.Write("Size: 0x%llx", size); LOGF_NOTICE(LOADER, "Size: 0x%llx", size);
ConLog.Write("Compressed: 0x%08x", compressed); LOGF_NOTICE(LOADER, "Compressed: 0x%08x", compressed);
ConLog.Write("Unknown1: 0x%08x", unknown1); LOGF_NOTICE(LOADER, "Unknown1: 0x%08x", unknown1);
ConLog.Write("Unknown2: 0x%08x", unknown2); LOGF_NOTICE(LOADER, "Unknown2: 0x%08x", unknown2);
ConLog.Write("Encrypted: 0x%08x", encrypted); LOGF_NOTICE(LOADER, "Encrypted: 0x%08x", encrypted);
} }
}; };
@ -79,10 +79,10 @@ struct SCEVersionInfo
void Show() void Show()
{ {
ConLog.Write("Sub-header type: 0x%08x", subheader_type); LOGF_NOTICE(LOADER, "Sub-header type: 0x%08x", subheader_type);
ConLog.Write("Present: 0x%08x", present); LOGF_NOTICE(LOADER, "Present: 0x%08x", present);
ConLog.Write("Size: 0x%08x", size); LOGF_NOTICE(LOADER, "Size: 0x%08x", size);
ConLog.Write("Unknown: 0x%08x", unknown); LOGF_NOTICE(LOADER, "Unknown: 0x%08x", unknown);
} }
}; };
@ -181,20 +181,20 @@ struct ControlInfo
void Show() void Show()
{ {
ConLog.Write("Type: 0x%08x", type); LOGF_NOTICE(LOADER, "Type: 0x%08x", type);
ConLog.Write("Size: 0x%08x", size); LOGF_NOTICE(LOADER, "Size: 0x%08x", size);
ConLog.Write("Next: 0x%llx", next); LOGF_NOTICE(LOADER, "Next: 0x%llx", next);
if (type == 1) if (type == 1)
{ {
ConLog.Write("Control flag 1: 0x%08x", control_flags.ctrl_flag1); LOGF_NOTICE(LOADER, "Control flag 1: 0x%08x", control_flags.ctrl_flag1);
ConLog.Write("Unknown1: 0x%08x", control_flags.unknown1); LOGF_NOTICE(LOADER, "Unknown1: 0x%08x", control_flags.unknown1);
ConLog.Write("Unknown2: 0x%08x", control_flags.unknown2); LOGF_NOTICE(LOADER, "Unknown2: 0x%08x", control_flags.unknown2);
ConLog.Write("Unknown3: 0x%08x", control_flags.unknown3); LOGF_NOTICE(LOADER, "Unknown3: 0x%08x", control_flags.unknown3);
ConLog.Write("Unknown4: 0x%08x", control_flags.unknown4); LOGF_NOTICE(LOADER, "Unknown4: 0x%08x", control_flags.unknown4);
ConLog.Write("Unknown5: 0x%08x", control_flags.unknown5); LOGF_NOTICE(LOADER, "Unknown5: 0x%08x", control_flags.unknown5);
ConLog.Write("Unknown6: 0x%08x", control_flags.unknown6); LOGF_NOTICE(LOADER, "Unknown6: 0x%08x", control_flags.unknown6);
ConLog.Write("Unknown7: 0x%08x", control_flags.unknown7); LOGF_NOTICE(LOADER, "Unknown7: 0x%08x", control_flags.unknown7);
} }
else if (type == 2) else if (type == 2)
{ {
@ -204,8 +204,8 @@ struct ControlInfo
for (int i = 0; i < 20; i++) for (int i = 0; i < 20; i++)
digest_str += fmt::Format("%02x", file_digest_30.digest[i]); digest_str += fmt::Format("%02x", file_digest_30.digest[i]);
ConLog.Write("Digest: %s", digest_str.c_str()); LOGF_NOTICE(LOADER, "Digest: %s", digest_str.c_str());
ConLog.Write("Unknown: 0x%llx", file_digest_30.unknown); LOGF_NOTICE(LOADER, "Unknown: 0x%llx", file_digest_30.unknown);
} }
else if (size == 0x40) else if (size == 0x40)
{ {
@ -217,9 +217,9 @@ struct ControlInfo
digest_str2 += fmt::Format("%02x", file_digest_40.digest2[i]); digest_str2 += fmt::Format("%02x", file_digest_40.digest2[i]);
} }
ConLog.Write("Digest1: %s", digest_str1.c_str()); LOGF_NOTICE(LOADER, "Digest1: %s", digest_str1.c_str());
ConLog.Write("Digest2: %s", digest_str2.c_str()); LOGF_NOTICE(LOADER, "Digest2: %s", digest_str2.c_str());
ConLog.Write("Unknown: 0x%llx", file_digest_40.unknown); LOGF_NOTICE(LOADER, "Unknown: 0x%llx", file_digest_40.unknown);
} }
} }
else if (type == 3) else if (type == 3)
@ -237,16 +237,16 @@ struct ControlInfo
xordigest_str += fmt::Format("%02x", npdrm.xordigest[i]); xordigest_str += fmt::Format("%02x", npdrm.xordigest[i]);
} }
ConLog.Write("Magic: 0x%08x", npdrm.magic); LOGF_NOTICE(LOADER, "Magic: 0x%08x", npdrm.magic);
ConLog.Write("Unknown1: 0x%08x", npdrm.unknown1); LOGF_NOTICE(LOADER, "Unknown1: 0x%08x", npdrm.unknown1);
ConLog.Write("License: 0x%08x", npdrm.license); LOGF_NOTICE(LOADER, "License: 0x%08x", npdrm.license);
ConLog.Write("Type: 0x%08x", npdrm.type); LOGF_NOTICE(LOADER, "Type: 0x%08x", npdrm.type);
ConLog.Write("ContentID: %s", contentid_str.c_str()); LOGF_NOTICE(LOADER, "ContentID: %s", contentid_str.c_str());
ConLog.Write("Digest: %s", digest_str.c_str()); LOGF_NOTICE(LOADER, "Digest: %s", digest_str.c_str());
ConLog.Write("Inverse digest: %s", invdigest_str.c_str()); LOGF_NOTICE(LOADER, "Inverse digest: %s", invdigest_str.c_str());
ConLog.Write("XOR digest: %s", xordigest_str.c_str()); LOGF_NOTICE(LOADER, "XOR digest: %s", xordigest_str.c_str());
ConLog.Write("Unknown2: 0x%llx", npdrm.unknown2); LOGF_NOTICE(LOADER, "Unknown2: 0x%llx", npdrm.unknown2);
ConLog.Write("Unknown3: 0x%llx", npdrm.unknown3); LOGF_NOTICE(LOADER, "Unknown3: 0x%llx", npdrm.unknown3);
} }
} }
}; };
@ -281,10 +281,10 @@ struct MetadataInfo
iv_pad_str += fmt::Format("%02x", iv_pad[i]); iv_pad_str += fmt::Format("%02x", iv_pad[i]);
} }
ConLog.Write("Key: %s", key_str.c_str()); LOGF_NOTICE(LOADER, "Key: %s", key_str.c_str());
ConLog.Write("Key pad: %s", key_pad_str.c_str()); LOGF_NOTICE(LOADER, "Key pad: %s", key_pad_str.c_str());
ConLog.Write("IV: %s", iv_str.c_str()); LOGF_NOTICE(LOADER, "IV: %s", iv_str.c_str());
ConLog.Write("IV pad: %s", iv_pad_str.c_str()); LOGF_NOTICE(LOADER, "IV pad: %s", iv_pad_str.c_str());
} }
}; };
@ -320,13 +320,13 @@ struct MetadataHeader
void Show() void Show()
{ {
ConLog.Write("Signature input length: 0x%llx", signature_input_length); LOGF_NOTICE(LOADER, "Signature input length: 0x%llx", signature_input_length);
ConLog.Write("Unknown1: 0x%08x", unknown1); LOGF_NOTICE(LOADER, "Unknown1: 0x%08x", unknown1);
ConLog.Write("Section count: 0x%08x", section_count); LOGF_NOTICE(LOADER, "Section count: 0x%08x", section_count);
ConLog.Write("Key count: 0x%08x", key_count); LOGF_NOTICE(LOADER, "Key count: 0x%08x", key_count);
ConLog.Write("Optional header size: 0x%08x", opt_header_size); LOGF_NOTICE(LOADER, "Optional header size: 0x%08x", opt_header_size);
ConLog.Write("Unknown2: 0x%08x", unknown2); LOGF_NOTICE(LOADER, "Unknown2: 0x%08x", unknown2);
ConLog.Write("Unknown3: 0x%08x", unknown3); LOGF_NOTICE(LOADER, "Unknown3: 0x%08x", unknown3);
} }
}; };
@ -371,16 +371,16 @@ struct MetadataSectionHeader
void Show() void Show()
{ {
ConLog.Write("Data offset: 0x%llx", data_offset); LOGF_NOTICE(LOADER, "Data offset: 0x%llx", data_offset);
ConLog.Write("Data size: 0x%llx", data_size); LOGF_NOTICE(LOADER, "Data size: 0x%llx", data_size);
ConLog.Write("Type: 0x%08x", type); LOGF_NOTICE(LOADER, "Type: 0x%08x", type);
ConLog.Write("Program index: 0x%08x", program_idx); LOGF_NOTICE(LOADER, "Program index: 0x%08x", program_idx);
ConLog.Write("Hashed: 0x%08x", hashed); LOGF_NOTICE(LOADER, "Hashed: 0x%08x", hashed);
ConLog.Write("SHA1 index: 0x%08x", sha1_idx); LOGF_NOTICE(LOADER, "SHA1 index: 0x%08x", sha1_idx);
ConLog.Write("Encrypted: 0x%08x", encrypted); LOGF_NOTICE(LOADER, "Encrypted: 0x%08x", encrypted);
ConLog.Write("Key index: 0x%08x", key_idx); LOGF_NOTICE(LOADER, "Key index: 0x%08x", key_idx);
ConLog.Write("IV index: 0x%08x", iv_idx); LOGF_NOTICE(LOADER, "IV index: 0x%08x", iv_idx);
ConLog.Write("Compressed: 0x%08x", compressed); LOGF_NOTICE(LOADER, "Compressed: 0x%08x", compressed);
} }
}; };

6
rpcs3/Emu/ARMv7/ARMv7Interpreter.h
View File

@ -260,7 +260,7 @@ public:
protected: protected:
void NULL_OP() void NULL_OP()
{ {
ConLog.Error("null"); LOG_ERROR(HLE, "null");
Emu.Pause(); Emu.Pause();
} }
@ -316,7 +316,7 @@ protected:
void UNK(const u16 code0, const u16 code1) void UNK(const u16 code0, const u16 code1)
{ {
ConLog.Error("Unknown/Illegal opcode! (0x%04x : 0x%04x)", code0, code1); LOGF_ERROR(HLE, "Unknown/Illegal opcode! (0x%04x : 0x%04x)", code0, code1);
Emu.Pause(); Emu.Pause();
} }
}; };

2
rpcs3/Emu/ARMv7/ARMv7Thread.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/Cell/PPCThread.h" #include "Emu/Cell/PPCThread.h"

8
rpcs3/Emu/Audio/AL/OpenALThread.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "rpcs3/Ini.h" #include "rpcs3/Ini.h"
@ -18,7 +18,7 @@ void printAlError(ALenum err, const char* situation)
{ {
if(err != AL_NO_ERROR) if(err != AL_NO_ERROR)
{ {
ConLog.Error("%s: OpenAL error 0x%04x", situation, err); LOGF_ERROR(HLE, "%s: OpenAL error 0x%04x", situation, err);
Emu.Pause(); Emu.Pause();
} }
} }
@ -27,7 +27,7 @@ void printAlcError(ALCenum err, const char* situation)
{ {
if(err != ALC_NO_ERROR) if(err != ALC_NO_ERROR)
{ {
ConLog.Error("%s: OpenALC error 0x%04x", situation, err); LOGF_ERROR(HLE, "%s: OpenALC error 0x%04x", situation, err);
Emu.Pause(); Emu.Pause();
} }
} }
@ -137,7 +137,7 @@ void OpenALThread::AddData(const void* src, ALsizei size)
int bsize = size < m_buffer_size ? size : m_buffer_size; int bsize = size < m_buffer_size ? size : m_buffer_size;
if (!AddBlock(buffer, bsize, bsrc)) if (!AddBlock(buffer, bsize, bsrc))
ConLog.Error("OpenALThread::AddBlock: invalid block size: %d", bsize); LOGF_ERROR(HLE, "OpenALThread::AddBlock: invalid block size: %d", bsize);
alSourceQueueBuffers(m_source, 1, &buffer); alSourceQueueBuffers(m_source, 1, &buffer);
checkForAlError("alSourceQueueBuffers"); checkForAlError("alSourceQueueBuffers");

20
rpcs3/Emu/CPU/CPUThread.cpp
View File

@ -1,6 +1,6 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/SysCalls/ErrorCodes.h" #include "Emu/SysCalls/ErrorCodes.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "rpcs3/Ini.h" #include "rpcs3/Ini.h"
@ -149,7 +149,7 @@ void CPUThread::SetBranch(const u64 pc, bool record_branch)
{ {
if(!Memory.IsGoodAddr(m_offset + pc)) if(!Memory.IsGoodAddr(m_offset + pc))
{ {
ConLog.Error("%s branch error: bad address 0x%llx #pc: 0x%llx", GetFName().c_str(), m_offset + pc, m_offset + PC); LOGF_ERROR(PPU, "%s branch error: bad address 0x%llx #pc: 0x%llx", GetFName().c_str(), m_offset + pc, m_offset + PC);
Emu.Pause(); Emu.Pause();
} }
@ -282,7 +282,7 @@ void CPUThread::ExecOnce()
void CPUThread::Task() void CPUThread::Task()
{ {
if (Ini.HLELogging.GetValue()) ConLog.Write("%s enter", CPUThread::GetFName().c_str()); if (Ini.HLELogging.GetValue()) LOGF_NOTICE(PPU, "%s enter", CPUThread::GetFName().c_str());
const std::vector<u64>& bp = Emu.GetBreakPoints(); const std::vector<u64>& bp = Emu.GetBreakPoints();
@ -333,18 +333,18 @@ void CPUThread::Task()
} }
catch(const std::string& e) catch(const std::string& e)
{ {
ConLog.Error("Exception: %s", e.c_str()); LOGF_ERROR(PPU, "Exception: %s", e.c_str());
} }
catch(const char* e) catch(const char* e)
{ {
ConLog.Error("Exception: %s", e); LOGF_ERROR(PPU, "Exception: %s", e);
} }
catch(int exitcode) catch(int exitcode)
{ {
ConLog.Success("Exit Code: %d", exitcode); LOGF_SUCCESS(PPU, "Exit Code: %d", exitcode);
} }
if (Ini.HLELogging.GetValue()) ConLog.Write("%s leave", CPUThread::GetFName().c_str()); if (Ini.HLELogging.GetValue()) LOGF_NOTICE(PPU, "%s leave", CPUThread::GetFName().c_str());
} }
s64 CPUThread::ExecAsCallback(u64 pc, bool wait, u64 a1, u64 a2, u64 a3, u64 a4) // not multithread-safe s64 CPUThread::ExecAsCallback(u64 pc, bool wait, u64 a1, u64 a2, u64 a3, u64 a4) // not multithread-safe
@ -353,7 +353,7 @@ s64 CPUThread::ExecAsCallback(u64 pc, bool wait, u64 a1, u64 a2, u64 a3, u64 a4)
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
ConLog.Warning("ExecAsCallback() aborted"); LOGF_WARNING(PPU, "ExecAsCallback() aborted");
return CELL_ECANCELED; // doesn't mean anything return CELL_ECANCELED; // doesn't mean anything
} }
Sleep(1); Sleep(1);
@ -379,11 +379,11 @@ s64 CPUThread::ExecAsCallback(u64 pc, bool wait, u64 a1, u64 a2, u64 a3, u64 a4)
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
ConLog.Warning("ExecAsCallback(wait=%s) aborted", wait ? "true" : "false"); LOGF_WARNING(PPU, "ExecAsCallback(wait=%s) aborted", wait ? "true" : "false");
return CELL_EABORT; // doesn't mean anything return CELL_EABORT; // doesn't mean anything
} }
Sleep(1); Sleep(1);
} }
return wait * m_exit_status; return wait * m_exit_status;
} }

2
rpcs3/Emu/CPU/CPUThreadManager.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"

16
rpcs3/Emu/Cell/MFC.h
View File

@ -183,7 +183,7 @@ struct DMAC
return true; return true;
default: default:
ConLog.Error("DMAC::ProcessCmd(): Unknown DMA cmd."); LOGF_ERROR(HLE, "DMAC::ProcessCmd(): Unknown DMA cmd.");
return true; return true;
} }
} }
@ -268,19 +268,19 @@ struct DMAC
u16 tag = (u16)size_tag; u16 tag = (u16)size_tag;
u16 size = size_tag >> 16; u16 size = size_tag >> 16;
ConLog.Warning("RawSPU DMA %s:", op == MFC_PUT_CMD ? "PUT" : "GET"); LOGF_WARNING(HLE, "RawSPU DMA %s:", op == MFC_PUT_CMD ? "PUT" : "GET");
ConLog.Warning("*** lsa = 0x%x", lsa); LOGF_WARNING(HLE, "*** lsa = 0x%x", lsa);
ConLog.Warning("*** ea = 0x%llx", ea); LOGF_WARNING(HLE, "*** ea = 0x%llx", ea);
ConLog.Warning("*** tag = 0x%x", tag); LOGF_WARNING(HLE, "*** tag = 0x%x", tag);
ConLog.Warning("*** size = 0x%x", size); LOGF_WARNING(HLE, "*** size = 0x%x", size);
ConLog.SkipLn(); LOG_WARNING(HLE, " ");
MFC_CMDStatus.SetValue(dmac.Cmd(cmd, tag, lsa, ea, size)); MFC_CMDStatus.SetValue(dmac.Cmd(cmd, tag, lsa, ea, size));
} }
break; break;
default: default:
ConLog.Error("Unknown MFC cmd. (opcode=0x%x, cmd=0x%x)", op, cmd); LOGF_ERROR(HLE, "Unknown MFC cmd. (opcode=0x%x, cmd=0x%x)", op, cmd);
break; break;
} }
} }

2
rpcs3/Emu/Cell/PPCDecoder.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "PPCDecoder.h" #include "PPCDecoder.h"

2
rpcs3/Emu/Cell/PPCThread.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "PPCThread.h" #include "PPCThread.h"

44
rpcs3/Emu/Cell/PPUInterpreter.h
View File

@ -70,16 +70,16 @@ private:
if(Ini.HLELogging.GetValue()) if(Ini.HLELogging.GetValue())
{ {
ConLog.Warning("SysCall[0x%llx ('%s')] done with code [0x%llx]! #pc: 0x%llx", CPU.GPR[11], SysCalls::GetHLEFuncName(CPU.GPR[11]).c_str(), CPU.GPR[3], CPU.PC); LOGF_WARNING(PPU, "SysCall[0x%llx ('%s')] done with code [0x%llx]! #pc: 0x%llx", CPU.GPR[11], SysCalls::GetHLEFuncName(CPU.GPR[11]).c_str(), CPU.GPR[3], CPU.PC);
} }
/*else if ((s64)CPU.GPR[3] < 0) // probably, error code /*else if ((s64)CPU.GPR[3] < 0) // probably, error code
{ {
ConLog.Error("SysCall[0x%llx] done with code [0x%llx]! #pc: 0x%llx", CPU.GPR[11], CPU.GPR[3], CPU.PC); LOGF_ERROR(PPU, "SysCall[0x%llx] done with code [0x%llx]! #pc: 0x%llx", CPU.GPR[11], CPU.GPR[3], CPU.PC);
if(CPU.GPR[11] > 1024) if(CPU.GPR[11] > 1024)
SysCalls::DoFunc(CPU.GPR[11]); SysCalls::DoFunc(CPU.GPR[11]);
}*/ }*/
#ifdef HLE_CALL_DEBUG #ifdef HLE_CALL_DEBUG
ConLog.Write("SysCall[%lld] done with code [0x%llx]! #pc: 0x%llx", CPU.GPR[11], CPU.GPR[3], CPU.PC); LOGF_NOTICE(PPU, "SysCall[%lld] done with code [0x%llx]! #pc: 0x%llx", CPU.GPR[11], CPU.GPR[3], CPU.PC);
#endif #endif
} }
@ -2097,7 +2097,7 @@ private:
Emu.GetSFuncManager().StaticExecute(CPU.GPR[11]); Emu.GetSFuncManager().StaticExecute(CPU.GPR[11]);
if (Ini.HLELogging.GetValue()) if (Ini.HLELogging.GetValue())
{ {
ConLog.Write("'%s' done with code[0x%llx]! #pc: 0x%llx", LOGF_NOTICE(PPU, "'%s' done with code[0x%llx]! #pc: 0x%llx",
Emu.GetSFuncManager()[CPU.GPR[11]]->name, CPU.GPR[3], CPU.PC); Emu.GetSFuncManager()[CPU.GPR[11]]->name, CPU.GPR[3], CPU.PC);
} }
break; break;
@ -2687,7 +2687,7 @@ private:
const u64 RA = CPU.GPR[ra]; const u64 RA = CPU.GPR[ra];
CPU.GPR[rd] = RA + CPU.XER.CA; CPU.GPR[rd] = RA + CPU.XER.CA;
CPU.XER.CA = CPU.IsCarry(RA, CPU.XER.CA); CPU.XER.CA = CPU.IsCarry(RA, CPU.XER.CA);
if(oe) ConLog.Warning("addzeo"); if(oe) LOG_WARNING(PPU, "addzeo");
if(rc) CPU.UpdateCR0<s64>(CPU.GPR[rd]); if(rc) CPU.UpdateCR0<s64>(CPU.GPR[rd]);
} }
void SUBFZE(u32 rd, u32 ra, u32 oe, bool rc) void SUBFZE(u32 rd, u32 ra, u32 oe, bool rc)
@ -2695,7 +2695,7 @@ private:
const u64 RA = CPU.GPR[ra]; const u64 RA = CPU.GPR[ra];
CPU.GPR[rd] = ~RA + CPU.XER.CA; CPU.GPR[rd] = ~RA + CPU.XER.CA;
CPU.XER.CA = CPU.IsCarry(~RA, CPU.XER.CA); CPU.XER.CA = CPU.IsCarry(~RA, CPU.XER.CA);
if (oe) ConLog.Warning("subfzeo"); if (oe) LOG_WARNING(PPU, "subfzeo");
if (rc) CPU.UpdateCR0<s64>(CPU.GPR[rd]); if (rc) CPU.UpdateCR0<s64>(CPU.GPR[rd]);
} }
void STDCX_(u32 rs, u32 ra, u32 rb) void STDCX_(u32 rs, u32 ra, u32 rb)
@ -2728,7 +2728,7 @@ private:
const u64 RA = CPU.GPR[ra]; const u64 RA = CPU.GPR[ra];
CPU.GPR[rd] = ~RA + CPU.XER.CA + ~0ULL; CPU.GPR[rd] = ~RA + CPU.XER.CA + ~0ULL;
CPU.XER.CA = CPU.IsCarry(~RA, CPU.XER.CA, ~0ULL); CPU.XER.CA = CPU.IsCarry(~RA, CPU.XER.CA, ~0ULL);
if (oe) ConLog.Warning("subfmeo"); if (oe) LOG_WARNING(PPU, "subfmeo");
if (rc) CPU.UpdateCR0<s64>(CPU.GPR[rd]); if (rc) CPU.UpdateCR0<s64>(CPU.GPR[rd]);
} }
void MULLD(u32 rd, u32 ra, u32 rb, u32 oe, bool rc) void MULLD(u32 rd, u32 ra, u32 rb, u32 oe, bool rc)
@ -3509,7 +3509,7 @@ private:
void MTFSB1(u32 crbd, bool rc) void MTFSB1(u32 crbd, bool rc)
{ {
u64 mask = (1ULL << crbd); u64 mask = (1ULL << crbd);
if ((crbd == 29) && !CPU.FPSCR.NI) ConLog.Warning("Non-IEEE mode enabled"); if ((crbd == 29) && !CPU.FPSCR.NI) LOG_WARNING(PPU, "Non-IEEE mode enabled");
CPU.FPSCR.FPSCR |= mask; CPU.FPSCR.FPSCR |= mask;
if(rc) UNIMPLEMENTED(); if(rc) UNIMPLEMENTED();
@ -3523,7 +3523,7 @@ private:
void MTFSB0(u32 crbd, bool rc) void MTFSB0(u32 crbd, bool rc)
{ {
u64 mask = (1ULL << crbd); u64 mask = (1ULL << crbd);
if ((crbd == 29) && !CPU.FPSCR.NI) ConLog.Warning("Non-IEEE mode disabled"); if ((crbd == 29) && !CPU.FPSCR.NI) LOG_WARNING(PPU, "Non-IEEE mode disabled");
CPU.FPSCR.FPSCR &= ~mask; CPU.FPSCR.FPSCR &= ~mask;
if(rc) UNIMPLEMENTED(); if(rc) UNIMPLEMENTED();
@ -3534,12 +3534,12 @@ private:
if(i) if(i)
{ {
if ((crfd == 29) && !CPU.FPSCR.NI) ConLog.Warning("Non-IEEE mode enabled"); if ((crfd == 29) && !CPU.FPSCR.NI) LOG_WARNING(PPU, "Non-IEEE mode enabled");
CPU.FPSCR.FPSCR |= mask; CPU.FPSCR.FPSCR |= mask;
} }
else else
{ {
if ((crfd == 29) && CPU.FPSCR.NI) ConLog.Warning("Non-IEEE mode disabled"); if ((crfd == 29) && CPU.FPSCR.NI) LOG_WARNING(PPU, "Non-IEEE mode disabled");
CPU.FPSCR.FPSCR &= ~mask; CPU.FPSCR.FPSCR &= ~mask;
} }
@ -3563,9 +3563,9 @@ private:
if (CPU.FPSCR.NI != oldNI) if (CPU.FPSCR.NI != oldNI)
{ {
if (oldNI) if (oldNI)
ConLog.Warning("Non-IEEE mode disabled"); LOG_WARNING(PPU, "Non-IEEE mode disabled");
else else
ConLog.Warning("Non-IEEE mode enabled"); LOG_WARNING(PPU, "Non-IEEE mode enabled");
} }
if(rc) UNK("mtfsf."); if(rc) UNK("mtfsf.");
} }
@ -3995,20 +3995,20 @@ private:
void UNK(const std::string& err, bool pause = true) void UNK(const std::string& err, bool pause = true)
{ {
ConLog.Error(err + fmt::Format(" #pc: 0x%llx", CPU.PC)); LOGF_ERROR(PPU, err + fmt::Format(" #pc: 0x%llx", CPU.PC));
if(!pause) return; if(!pause) return;
Emu.Pause(); Emu.Pause();
for(uint i=0; i<32; ++i) ConLog.Write("r%d = 0x%llx", i, CPU.GPR[i]); for(uint i=0; i<32; ++i) LOGF_NOTICE(PPU, "r%d = 0x%llx", i, CPU.GPR[i]);
for(uint i=0; i<32; ++i) ConLog.Write("f%d = %llf", i, CPU.FPR[i]); for(uint i=0; i<32; ++i) LOGF_NOTICE(PPU, "f%d = %llf", i, CPU.FPR[i]);
for(uint i=0; i<32; ++i) ConLog.Write("v%d = 0x%s [%s]", i, CPU.VPR[i].ToString(true).c_str(), CPU.VPR[i].ToString().c_str()); for(uint i=0; i<32; ++i) LOGF_NOTICE(PPU, "v%d = 0x%s [%s]", i, CPU.VPR[i].ToString(true).c_str(), CPU.VPR[i].ToString().c_str());
ConLog.Write("CR = 0x%08x", CPU.CR); LOGF_NOTICE(PPU, "CR = 0x%08x", CPU.CR);
ConLog.Write("LR = 0x%llx", CPU.LR); LOGF_NOTICE(PPU, "LR = 0x%llx", CPU.LR);
ConLog.Write("CTR = 0x%llx", CPU.CTR); LOGF_NOTICE(PPU, "CTR = 0x%llx", CPU.CTR);
ConLog.Write("XER = 0x%llx [CA=%lld | OV=%lld | SO=%lld]", CPU.XER, fmt::by_value(CPU.XER.CA), fmt::by_value(CPU.XER.OV), fmt::by_value(CPU.XER.SO)); LOGF_NOTICE(PPU, "XER = 0x%llx [CA=%lld | OV=%lld | SO=%lld]", CPU.XER, fmt::by_value(CPU.XER.CA), fmt::by_value(CPU.XER.OV), fmt::by_value(CPU.XER.SO));
ConLog.Write("FPSCR = 0x%x " LOGF_NOTICE(PPU, "FPSCR = 0x%x "
"[RN=%d | NI=%d | XE=%d | ZE=%d | UE=%d | OE=%d | VE=%d | " "[RN=%d | NI=%d | XE=%d | ZE=%d | UE=%d | OE=%d | VE=%d | "
"VXCVI=%d | VXSQRT=%d | VXSOFT=%d | FPRF=%d | " "VXCVI=%d | VXSQRT=%d | VXSOFT=%d | FPRF=%d | "
"FI=%d | FR=%d | VXVC=%d | VXIMZ=%d | " "FI=%d | FR=%d | VXVC=%d | VXIMZ=%d | "

2
rpcs3/Emu/Cell/PPUProgramCompiler.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "PPUProgramCompiler.h" #include "PPUProgramCompiler.h"

8
rpcs3/Emu/Cell/PPUThread.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"
@ -76,7 +76,7 @@ void PPUThread::InitRegs()
if(thread_num < 0) if(thread_num < 0)
{ {
ConLog.Error("GetThreadNumById failed."); LOG_ERROR(PPU, "GetThreadNumById failed.");
Emu.Pause(); Emu.Pause();
return; return;
} }
@ -87,7 +87,7 @@ void PPUThread::InitRegs()
if(tls_size >= Emu.GetTLSMemsz()) if(tls_size >= Emu.GetTLSMemsz())
{ {
ConLog.Error("Out of TLS memory."); LOG_ERROR(PPU, "Out of TLS memory.");
Emu.Pause(); Emu.Pause();
return; return;
} }
@ -163,7 +163,7 @@ void PPUThread::DoRun()
break; break;
default: default:
ConLog.Error("Invalid CPU decoder mode: %d", Ini.CPUDecoderMode.GetValue()); LOGF_ERROR(PPU, "Invalid CPU decoder mode: %d", Ini.CPUDecoderMode.GetValue());
Emu.Pause(); Emu.Pause();
} }
} }

94
rpcs3/Emu/Cell/RawSPUThread.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/SysCalls/lv2/SC_Lwmutex.h" #include "Emu/SysCalls/lv2/SC_Lwmutex.h"
@ -38,7 +38,7 @@ bool RawSPUThread::Read8(const u64 addr, u8* value)
} }
u32 offset = addr - GetStartAddr() - RAW_SPU_PROB_OFFSET; u32 offset = addr - GetStartAddr() - RAW_SPU_PROB_OFFSET;
ConLog.Error("RawSPUThread[%d]: Read8(0x%x)", m_index, offset); LOGF_ERROR(Log::SPU, "RawSPUThread[%d]: Read8(0x%x)", m_index, offset);
Emu.Pause(); Emu.Pause();
return false; return false;
} }
@ -51,7 +51,7 @@ bool RawSPUThread::Read16(const u64 addr, u16* value)
} }
u32 offset = addr - GetStartAddr() - RAW_SPU_PROB_OFFSET; u32 offset = addr - GetStartAddr() - RAW_SPU_PROB_OFFSET;
ConLog.Error("RawSPUThread[%d]: Read16(0x%x)", m_index, offset); LOGF_ERROR(Log::SPU, "RawSPUThread[%d]: Read16(0x%x)", m_index, offset);
Emu.Pause(); Emu.Pause();
return false; return false;
} }
@ -66,39 +66,39 @@ bool RawSPUThread::Read32(const u64 addr, u32* value)
u32 offset = addr - GetStartAddr() - RAW_SPU_PROB_OFFSET; u32 offset = addr - GetStartAddr() - RAW_SPU_PROB_OFFSET;
switch(offset) switch(offset)
{ {
case MFC_LSA_offs: ConLog.Warning("RawSPUThread[%d]: Read32(MFC_LSA)", m_index); *value = MFC2.LSA.GetValue(); break; case MFC_LSA_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(MFC_LSA)", m_index); *value = MFC2.LSA.GetValue(); break;
case MFC_EAH_offs: ConLog.Warning("RawSPUThread[%d]: Read32(MFC_EAH)", m_index); *value = MFC2.EAH.GetValue(); break; case MFC_EAH_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(MFC_EAH)", m_index); *value = MFC2.EAH.GetValue(); break;
case MFC_EAL_offs: ConLog.Warning("RawSPUThread[%d]: Read32(MFC_EAL)", m_index); *value = MFC2.EAL.GetValue(); break; case MFC_EAL_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(MFC_EAL)", m_index); *value = MFC2.EAL.GetValue(); break;
case MFC_Size_Tag_offs: ConLog.Warning("RawSPUThread[%d]: Read32(MFC_Size_Tag)", m_index); *value = MFC2.Size_Tag.GetValue(); break; case MFC_Size_Tag_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(MFC_Size_Tag)", m_index); *value = MFC2.Size_Tag.GetValue(); break;
case MFC_CMDStatus_offs: ConLog.Warning("RawSPUThread[%d]: Read32(MFC_CMDStatus)", m_index); *value = MFC2.CMDStatus.GetValue(); break; case MFC_CMDStatus_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(MFC_CMDStatus)", m_index); *value = MFC2.CMDStatus.GetValue(); break;
case MFC_QStatus_offs: case MFC_QStatus_offs:
ConLog.Warning("RawSPUThread[%d]: Read32(MFC_QStatus)", m_index); LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(MFC_QStatus)", m_index);
*value = MFC2.QStatus.GetValue(); *value = MFC2.QStatus.GetValue();
break; break;
case Prxy_QueryType_offs: ConLog.Warning("RawSPUThread[%d]: Read32(Prxy_QueryType)", m_index); *value = Prxy.QueryType.GetValue(); break; case Prxy_QueryType_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(Prxy_QueryType)", m_index); *value = Prxy.QueryType.GetValue(); break;
case Prxy_QueryMask_offs: ConLog.Warning("RawSPUThread[%d]: Read32(Prxy_QueryMask)", m_index); *value = Prxy.QueryMask.GetValue(); break; case Prxy_QueryMask_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(Prxy_QueryMask)", m_index); *value = Prxy.QueryMask.GetValue(); break;
case Prxy_TagStatus_offs: ConLog.Warning("RawSPUThread[%d]: Read32(Prxy_TagStatus)", m_index); *value = Prxy.TagStatus.GetValue(); break; case Prxy_TagStatus_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(Prxy_TagStatus)", m_index); *value = Prxy.TagStatus.GetValue(); break;
case SPU_Out_MBox_offs: case SPU_Out_MBox_offs:
//ConLog.Warning("RawSPUThread[%d]: Read32(SPU_Out_MBox)", m_index); //LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(SPU_Out_MBox)", m_index);
SPU.Out_MBox.PopUncond(*value); //if Out_MBox is empty yet, the result will be undefined SPU.Out_MBox.PopUncond(*value); //if Out_MBox is empty yet, the result will be undefined
break; break;
case SPU_In_MBox_offs: ConLog.Warning("RawSPUThread[%d]: Read32(SPU_In_MBox)", m_index); while(!SPU.In_MBox.Pop(*value) && !Emu.IsStopped()) Sleep(1); break; case SPU_In_MBox_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(SPU_In_MBox)", m_index); while(!SPU.In_MBox.Pop(*value) && !Emu.IsStopped()) Sleep(1); break;
case SPU_MBox_Status_offs: //ConLog.Warning("RawSPUThread[%d]: Read32(SPU_MBox_Status)", m_index); case SPU_MBox_Status_offs: //LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(SPU_MBox_Status)", m_index);
//SPU.MBox_Status.SetValue(SPU.Out_MBox.GetCount() ? SPU.MBox_Status.GetValue() | 1 : SPU.MBox_Status.GetValue() & ~1); //SPU.MBox_Status.SetValue(SPU.Out_MBox.GetCount() ? SPU.MBox_Status.GetValue() | 1 : SPU.MBox_Status.GetValue() & ~1);
SPU.MBox_Status.SetValue((SPU.Out_MBox.GetCount() & 0xff) | (SPU.In_MBox.GetFreeCount() << 8)); SPU.MBox_Status.SetValue((SPU.Out_MBox.GetCount() & 0xff) | (SPU.In_MBox.GetFreeCount() << 8));
*value = SPU.MBox_Status.GetValue(); *value = SPU.MBox_Status.GetValue();
break; break;
case SPU_RunCntl_offs: ConLog.Warning("RawSPUThread[%d]: Read32(SPU_RunCntl)", m_index); *value = SPU.RunCntl.GetValue(); break; case SPU_RunCntl_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(SPU_RunCntl)", m_index); *value = SPU.RunCntl.GetValue(); break;
case SPU_Status_offs: case SPU_Status_offs:
//ConLog.Warning("RawSPUThread[%d]: Read32(SPU_Status)", m_index); //LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(SPU_Status)", m_index);
*value = SPU.Status.GetValue(); *value = SPU.Status.GetValue();
break; break;
case SPU_NPC_offs: ConLog.Warning("RawSPUThread[%d]: Read32(SPU_NPC)", m_index); *value = SPU.NPC.GetValue(); break; case SPU_NPC_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(SPU_NPC)", m_index); *value = SPU.NPC.GetValue(); break;
case SPU_RdSigNotify1_offs: ConLog.Warning("RawSPUThread[%d]: Read32(SPU_RdSigNotify1)", m_index); *value = SPU.SNR[0].GetValue(); break; case SPU_RdSigNotify1_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(SPU_RdSigNotify1)", m_index); *value = SPU.SNR[0].GetValue(); break;
case SPU_RdSigNotify2_offs: ConLog.Warning("RawSPUThread[%d]: Read32(SPU_RdSigNotify2)", m_index); *value = SPU.SNR[1].GetValue(); break; case SPU_RdSigNotify2_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Read32(SPU_RdSigNotify2)", m_index); *value = SPU.SNR[1].GetValue(); break;
default: default:
ConLog.Error("RawSPUThread[%d]: Read32(0x%x)", m_index, offset); LOGF_ERROR(Log::SPU, "RawSPUThread[%d]: Read32(0x%x)", m_index, offset);
Emu.Pause(); Emu.Pause();
break; break;
} }
@ -114,7 +114,7 @@ bool RawSPUThread::Read64(const u64 addr, u64* value)
} }
u32 offset = addr - GetStartAddr() - RAW_SPU_PROB_OFFSET; u32 offset = addr - GetStartAddr() - RAW_SPU_PROB_OFFSET;
ConLog.Error("RawSPUThread[%d]: Read64(0x%x)", m_index, offset); LOGF_ERROR(Log::SPU, "RawSPUThread[%d]: Read64(0x%x)", m_index, offset);
Emu.Pause(); Emu.Pause();
return false; return false;
} }
@ -127,7 +127,7 @@ bool RawSPUThread::Read128(const u64 addr, u128* value)
} }
u32 offset = addr - GetStartAddr() - RAW_SPU_PROB_OFFSET; u32 offset = addr - GetStartAddr() - RAW_SPU_PROB_OFFSET;
ConLog.Error("RawSPUThread[%d]: Read128(0x%x)", m_index, offset); LOGF_ERROR(Log::SPU, "RawSPUThread[%d]: Read128(0x%x)", m_index, offset);
Emu.Pause(); Emu.Pause();
return false; return false;
} }
@ -140,7 +140,7 @@ bool RawSPUThread::Write8(const u64 addr, const u8 value)
} }
u32 offset = addr - GetStartAddr() - RAW_SPU_PROB_OFFSET; u32 offset = addr - GetStartAddr() - RAW_SPU_PROB_OFFSET;
ConLog.Error("RawSPUThread[%d]: Write8(0x%x, 0x%x)", m_index, offset, value); LOGF_ERROR(Log::SPU, "RawSPUThread[%d]: Write8(0x%x, 0x%x)", m_index, offset, value);
Emu.Pause(); Emu.Pause();
return false; return false;
} }
@ -153,7 +153,7 @@ bool RawSPUThread::Write16(const u64 addr, const u16 value)
} }
u32 offset = addr - GetStartAddr() - RAW_SPU_PROB_OFFSET; u32 offset = addr - GetStartAddr() - RAW_SPU_PROB_OFFSET;
ConLog.Error("RawSPUThread[%d]: Write16(0x%x, 0x%x)", m_index, offset, value); LOGF_ERROR(Log::SPU, "RawSPUThread[%d]: Write16(0x%x, 0x%x)", m_index, offset, value);
Emu.Pause(); Emu.Pause();
return false; return false;
} }
@ -177,20 +177,20 @@ bool RawSPUThread::Write32(const u64 addr, const u32 value)
MFC2.CMDStatus.SetValue(value); MFC2.CMDStatus.SetValue(value);
EnqMfcCmd(MFC2); EnqMfcCmd(MFC2);
break; break;
case MFC_QStatus_offs: ConLog.Warning("RawSPUThread[%d]: Write32(MFC_QStatus, 0x%x)", m_index, value); MFC2.QStatus.SetValue(value); break; case MFC_QStatus_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Write32(MFC_QStatus, 0x%x)", m_index, value); MFC2.QStatus.SetValue(value); break;
case Prxy_QueryType_offs: case Prxy_QueryType_offs:
{ {
ConLog.Warning("RawSPUThread[%d]: Write32(Prxy_QueryType, 0x%x)", m_index, value); LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Write32(Prxy_QueryType, 0x%x)", m_index, value);
Prxy.QueryType.SetValue(value); Prxy.QueryType.SetValue(value);
switch(value) switch(value)
{ {
case 2: case 2:
ConLog.Warning("RawSPUThread[%d]: Prxy Query Immediate.", m_index); LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Prxy Query Immediate.", m_index);
break; break;
default: default:
ConLog.Error("RawSPUThread[%d]: Unknown Prxy Query Type. (prxy_query=0x%x)", m_index, value); LOGF_ERROR(Log::SPU, "RawSPUThread[%d]: Unknown Prxy Query Type. (prxy_query=0x%x)", m_index, value);
break; break;
} }
@ -198,22 +198,22 @@ bool RawSPUThread::Write32(const u64 addr, const u32 value)
MFC2.QStatus.SetValue(Prxy.QueryMask.GetValue()); MFC2.QStatus.SetValue(Prxy.QueryMask.GetValue());
} }
break; break;
case Prxy_QueryMask_offs: ConLog.Warning("RawSPUThread[%d]: Write32(Prxy_QueryMask, 0x%x)", m_index, value); Prxy.QueryMask.SetValue(value); break; case Prxy_QueryMask_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Write32(Prxy_QueryMask, 0x%x)", m_index, value); Prxy.QueryMask.SetValue(value); break;
case Prxy_TagStatus_offs: ConLog.Warning("RawSPUThread[%d]: Write32(Prxy_TagStatus, 0x%x)", m_index, value); Prxy.TagStatus.SetValue(value); break; case Prxy_TagStatus_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Write32(Prxy_TagStatus, 0x%x)", m_index, value); Prxy.TagStatus.SetValue(value); break;
case SPU_Out_MBox_offs: ConLog.Warning("RawSPUThread[%d]: Write32(SPU_Out_MBox, 0x%x)", m_index, value); while(!SPU.Out_MBox.Push(value) && !Emu.IsStopped()) Sleep(1); break; case SPU_Out_MBox_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Write32(SPU_Out_MBox, 0x%x)", m_index, value); while(!SPU.Out_MBox.Push(value) && !Emu.IsStopped()) Sleep(1); break;
case SPU_In_MBox_offs: case SPU_In_MBox_offs:
//ConLog.Warning("RawSPUThread[%d]: Write32(SPU_In_MBox, 0x%x)", m_index, value); //LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Write32(SPU_In_MBox, 0x%x)", m_index, value);
SPU.In_MBox.PushUncond(value); //if In_MBox is already full, the last message will be overwritten SPU.In_MBox.PushUncond(value); //if In_MBox is already full, the last message will be overwritten
break; break;
case SPU_MBox_Status_offs: ConLog.Warning("RawSPUThread[%d]: Write32(SPU_MBox_Status, 0x%x)", m_index, value); SPU.MBox_Status.SetValue(value); break; case SPU_MBox_Status_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Write32(SPU_MBox_Status, 0x%x)", m_index, value); SPU.MBox_Status.SetValue(value); break;
case SPU_RunCntl_offs: ConLog.Warning("RawSPUThread[%d]: Write32(SPU_RunCntl, 0x%x)", m_index, value); SPU.RunCntl.SetValue(value); break; case SPU_RunCntl_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Write32(SPU_RunCntl, 0x%x)", m_index, value); SPU.RunCntl.SetValue(value); break;
case SPU_Status_offs: ConLog.Warning("RawSPUThread[%d]: Write32(SPU_Status, 0x%x)", m_index, value); SPU.Status.SetValue(value); break; case SPU_Status_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Write32(SPU_Status, 0x%x)", m_index, value); SPU.Status.SetValue(value); break;
case SPU_NPC_offs: ConLog.Warning("RawSPUThread[%d]: Write32(SPU_NPC, 0x%x)", m_index, value); SPU.NPC.SetValue(value); break; case SPU_NPC_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Write32(SPU_NPC, 0x%x)", m_index, value); SPU.NPC.SetValue(value); break;
case SPU_RdSigNotify1_offs: ConLog.Warning("RawSPUThread[%d]: Write32(SPU_RdSigNotify1, 0x%x)", m_index, value); SPU.SNR[0].SetValue(value); break; case SPU_RdSigNotify1_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Write32(SPU_RdSigNotify1, 0x%x)", m_index, value); SPU.SNR[0].SetValue(value); break;
case SPU_RdSigNotify2_offs: ConLog.Warning("RawSPUThread[%d]: Write32(SPU_RdSigNotify2, 0x%x)", m_index, value); SPU.SNR[1].SetValue(value); break; case SPU_RdSigNotify2_offs: LOGF_WARNING(Log::SPU, "RawSPUThread[%d]: Write32(SPU_RdSigNotify2, 0x%x)", m_index, value); SPU.SNR[1].SetValue(value); break;
default: default:
ConLog.Error("RawSPUThread[%d]: Write32(0x%x, 0x%x)", m_index, offset, value); LOGF_ERROR(Log::SPU, "RawSPUThread[%d]: Write32(0x%x, 0x%x)", m_index, offset, value);
Emu.Pause(); Emu.Pause();
break; break;
} }
@ -229,7 +229,7 @@ bool RawSPUThread::Write64(const u64 addr, const u64 value)
} }
u32 offset = addr - GetStartAddr() - RAW_SPU_PROB_OFFSET; u32 offset = addr - GetStartAddr() - RAW_SPU_PROB_OFFSET;
ConLog.Error("RawSPUThread[%d]: Write64(0x%x, 0x%llx)", m_index, offset, value); LOGF_ERROR(Log::SPU, "RawSPUThread[%d]: Write64(0x%x, 0x%llx)", m_index, offset, value);
Emu.Pause(); Emu.Pause();
return false; return false;
} }
@ -242,7 +242,7 @@ bool RawSPUThread::Write128(const u64 addr, const u128 value)
} }
u32 offset = addr - GetStartAddr() - RAW_SPU_PROB_OFFSET; u32 offset = addr - GetStartAddr() - RAW_SPU_PROB_OFFSET;
ConLog.Error("RawSPUThread[%d]: Write128(0x%x, 0x%llx_%llx)", m_index, offset, value._u64[1], value._u64[0]); LOGF_ERROR(Log::SPU, "RawSPUThread[%d]: Write128(0x%x, 0x%llx_%llx)", m_index, offset, value._u64[1], value._u64[0]);
Emu.Pause(); Emu.Pause();
return false; return false;
} }
@ -260,7 +260,7 @@ u32 RawSPUThread::GetIndex() const
void RawSPUThread::Task() void RawSPUThread::Task()
{ {
if (Ini.HLELogging.GetValue()) ConLog.Write("%s enter", PPCThread::GetFName().c_str()); if (Ini.HLELogging.GetValue()) LOGF_NOTICE(Log::SPU, "%s enter", PPCThread::GetFName().c_str());
const std::vector<u64>& bp = Emu.GetBreakPoints(); const std::vector<u64>& bp = Emu.GetBreakPoints();
@ -312,7 +312,7 @@ void RawSPUThread::Task()
is_last_paused = false; is_last_paused = false;
PC = SPU.NPC.GetValue(); PC = SPU.NPC.GetValue();
SPU.Status.SetValue(SPU_STATUS_RUNNING); SPU.Status.SetValue(SPU_STATUS_RUNNING);
ConLog.Warning("Starting RawSPU..."); LOGF_WARNING(Log::SPU, "Starting RawSPU...");
} }
Step(); Step();
@ -336,12 +336,12 @@ void RawSPUThread::Task()
} }
catch(const std::string& e) catch(const std::string& e)
{ {
ConLog.Error("Exception: %s", e.c_str()); LOGF_ERROR(Log::SPU, "Exception: %s", e.c_str());
} }
catch(const char* e) catch(const char* e)
{ {
ConLog.Error("Exception: %s", e); LOGF_ERROR(Log::SPU, "Exception: %s", e);
} }
if (Ini.HLELogging.GetValue()) ConLog.Write("%s leave", PPCThread::GetFName().c_str()); if (Ini.HLELogging.GetValue()) LOGF_NOTICE(Log::SPU, "%s leave", PPCThread::GetFName().c_str());
} }

26
rpcs3/Emu/Cell/SPUInterpreter.h
View File

@ -18,9 +18,9 @@
#define MEM_AND_REG_HASH() \ #define MEM_AND_REG_HASH() \
unsigned char mem_h[20]; sha1(&Memory[CPU.dmac.ls_offset], 256*1024, mem_h); \ unsigned char mem_h[20]; sha1(&Memory[CPU.dmac.ls_offset], 256*1024, mem_h); \
unsigned char reg_h[20]; sha1((const unsigned char*)CPU.GPR, sizeof(CPU.GPR), reg_h); \ unsigned char reg_h[20]; sha1((const unsigned char*)CPU.GPR, sizeof(CPU.GPR), reg_h); \
ConLog.Write("Mem hash: 0x%llx, reg hash: 0x%llx", *(u64*)mem_h, *(u64*)reg_h); LOGF_NOTICE(Log::SPU, "Mem hash: 0x%llx, reg hash: 0x%llx", *(u64*)mem_h, *(u64*)reg_h);
#define LOG2_OPCODE(...) //MEM_AND_REG_HASH(); ConLog.Write(__FUNCTION__ "(): " __VA_ARGS__) #define LOG2_OPCODE(...) //MEM_AND_REG_HASH(); LOGF_NOTICE(Log::SPU, __FUNCTION__ "(): " __VA_ARGS__)
#define LOG5_OPCODE(...) /// #define LOG5_OPCODE(...) ///
@ -339,7 +339,7 @@ private:
u32 lsa = (CPU.GPR[ra]._u32[3] + CPU.GPR[rb]._u32[3]) & 0x3fff0; u32 lsa = (CPU.GPR[ra]._u32[3] + CPU.GPR[rb]._u32[3]) & 0x3fff0;
if(!CPU.IsGoodLSA(lsa)) if(!CPU.IsGoodLSA(lsa))
{ {
ConLog.Error("STQX: bad lsa (0x%x)", lsa); LOGF_ERROR(Log::SPU, "STQX: bad lsa (0x%x)", lsa);
Emu.Pause(); Emu.Pause();
return; return;
} }
@ -438,7 +438,7 @@ private:
if(!CPU.IsGoodLSA(lsa)) if(!CPU.IsGoodLSA(lsa))
{ {
ConLog.Error("LQX: bad lsa (0x%x)", lsa); LOGF_ERROR(Log::SPU, "LQX: bad lsa (0x%x)", lsa);
Emu.Pause(); Emu.Pause();
return; return;
} }
@ -1126,7 +1126,7 @@ private:
u32 lsa = (i16 << 2) & 0x3fff0; u32 lsa = (i16 << 2) & 0x3fff0;
if(!CPU.IsGoodLSA(lsa)) if(!CPU.IsGoodLSA(lsa))
{ {
ConLog.Error("STQA: bad lsa (0x%x)", lsa); LOGF_ERROR(Log::SPU, "STQA: bad lsa (0x%x)", lsa);
Emu.Pause(); Emu.Pause();
return; return;
} }
@ -1177,7 +1177,7 @@ private:
u32 lsa = branchTarget(CPU.PC, i16) & 0x3fff0; u32 lsa = branchTarget(CPU.PC, i16) & 0x3fff0;
if(!CPU.IsGoodLSA(lsa)) if(!CPU.IsGoodLSA(lsa))
{ {
ConLog.Error("STQR: bad lsa (0x%x)", lsa); LOGF_ERROR(Log::SPU, "STQR: bad lsa (0x%x)", lsa);
Emu.Pause(); Emu.Pause();
return; return;
} }
@ -1195,7 +1195,7 @@ private:
u32 lsa = (i16 << 2) & 0x3fff0; u32 lsa = (i16 << 2) & 0x3fff0;
if(!CPU.IsGoodLSA(lsa)) if(!CPU.IsGoodLSA(lsa))
{ {
ConLog.Error("LQA: bad lsa (0x%x)", lsa); LOGF_ERROR(Log::SPU, "LQA: bad lsa (0x%x)", lsa);
Emu.Pause(); Emu.Pause();
return; return;
} }
@ -1245,7 +1245,7 @@ private:
u32 lsa = branchTarget(CPU.PC, i16) & 0x3fff0; u32 lsa = branchTarget(CPU.PC, i16) & 0x3fff0;
if(!CPU.IsGoodLSA(lsa)) if(!CPU.IsGoodLSA(lsa))
{ {
ConLog.Error("LQR: bad lsa (0x%x)", lsa); LOGF_ERROR(Log::SPU, "LQR: bad lsa (0x%x)", lsa);
Emu.Pause(); Emu.Pause();
return; return;
} }
@ -1334,11 +1334,11 @@ private:
const u32 lsa = (CPU.GPR[ra]._i32[3] + i10) & 0x3fff0; const u32 lsa = (CPU.GPR[ra]._i32[3] + i10) & 0x3fff0;
if(!CPU.IsGoodLSA(lsa)) if(!CPU.IsGoodLSA(lsa))
{ {
ConLog.Error("STQD: bad lsa (0x%x)", lsa); LOGF_ERROR(Log::SPU, "STQD: bad lsa (0x%x)", lsa);
Emu.Pause(); Emu.Pause();
return; return;
} }
//ConLog.Write("STQD(lsa=0x%x): GPR[%d] (0x%llx%llx)", lsa, rt, CPU.GPR[rt]._u64[1], CPU.GPR[rt]._u64[0]); //LOGF_NOTICE(Log::SPU, "STQD(lsa=0x%x): GPR[%d] (0x%llx%llx)", lsa, rt, CPU.GPR[rt]._u64[1], CPU.GPR[rt]._u64[0]);
CPU.WriteLS128(lsa, CPU.GPR[rt]._u128); CPU.WriteLS128(lsa, CPU.GPR[rt]._u128);
} }
void LQD(u32 rt, s32 i10, u32 ra) //i10 is shifted left by 4 while decoding void LQD(u32 rt, s32 i10, u32 ra) //i10 is shifted left by 4 while decoding
@ -1346,7 +1346,7 @@ private:
const u32 lsa = (CPU.GPR[ra]._i32[3] + i10) & 0x3fff0; const u32 lsa = (CPU.GPR[ra]._i32[3] + i10) & 0x3fff0;
if(!CPU.IsGoodLSA(lsa)) if(!CPU.IsGoodLSA(lsa))
{ {
ConLog.Error("LQD: bad lsa (0x%x)", lsa); LOGF_ERROR(Log::SPU, "LQD: bad lsa (0x%x)", lsa);
Emu.Pause(); Emu.Pause();
return; return;
} }
@ -1540,8 +1540,8 @@ private:
void UNK(const std::string& err) void UNK(const std::string& err)
{ {
ConLog.Error(err + fmt::Format(" #pc: 0x%x", CPU.PC)); LOGF_ERROR(Log::SPU, err + fmt::Format(" #pc: 0x%x", CPU.PC));
Emu.Pause(); Emu.Pause();
for(uint i=0; i<128; ++i) ConLog.Write("r%d = 0x%s", i, CPU.GPR[i].ToString().c_str()); for(uint i=0; i<128; ++i) LOGF_NOTICE(Log::SPU, "r%d = 0x%s", i, CPU.GPR[i].ToString().c_str());
} }
}; };

2
rpcs3/Emu/Cell/SPURecompiler.h
View File

@ -3845,7 +3845,7 @@ private:
void UNK(const std::string& err) void UNK(const std::string& err)
{ {
ConLog.Error(err + fmt::Format(" #pc: 0x%x", CPU.PC)); LOGF_ERROR(Log::SPU, err + fmt::Format(" #pc: 0x%x", CPU.PC));
c.mov(cpu_qword(PC), (u32)CPU.PC); c.mov(cpu_qword(PC), (u32)CPU.PC);
do_finalize = true; do_finalize = true;
Emu.Pause(); Emu.Pause();

14
rpcs3/Emu/Cell/SPURecompilerCore.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/SysCalls/lv2/SC_Lwmutex.h" #include "Emu/SysCalls/lv2/SC_Lwmutex.h"
@ -164,7 +164,7 @@ u8 SPURecompilerCore::DecodeMemory(const u64 address)
if (!pos) if (!pos)
{ {
ConLog.Error("SPURecompilerCore::DecodeMemory(): ls_addr = 0"); LOGF_ERROR(Log::SPU, "SPURecompilerCore::DecodeMemory(): ls_addr = 0");
Emu.Pause(); Emu.Pause();
return 0; return 0;
} }
@ -185,7 +185,7 @@ u8 SPURecompilerCore::DecodeMemory(const u64 address)
if (!is_valid) if (!is_valid)
{ {
// TODO // TODO
ConLog.Error("SPURecompilerCore::DecodeMemory(ls_addr=0x%x): code has changed", pos * sizeof(u32)); LOGF_ERROR(Log::SPU, "SPURecompilerCore::DecodeMemory(ls_addr=0x%x): code has changed", pos * sizeof(u32));
Emu.Pause(); Emu.Pause();
return 0; return 0;
} }
@ -198,7 +198,7 @@ u8 SPURecompilerCore::DecodeMemory(const u64 address)
did_compile = true; did_compile = true;
if (entry[pos].valid == 0) if (entry[pos].valid == 0)
{ {
ConLog.Error("SPURecompilerCore::Compile(ls_addr=0x%x): branch to 0x0 opcode", pos * sizeof(u32)); LOGF_ERROR(Log::SPU, "SPURecompilerCore::Compile(ls_addr=0x%x): branch to 0x0 opcode", pos * sizeof(u32));
Emu.Pause(); Emu.Pause();
return 0; return 0;
} }
@ -206,7 +206,7 @@ u8 SPURecompilerCore::DecodeMemory(const u64 address)
if (!entry[pos].pointer) if (!entry[pos].pointer)
{ {
ConLog.Error("SPURecompilerCore::DecodeMemory(ls_addr=0x%x): compilation failed", pos * sizeof(u32)); LOGF_ERROR(Log::SPU, "SPURecompilerCore::DecodeMemory(ls_addr=0x%x): compilation failed", pos * sizeof(u32));
Emu.Pause(); Emu.Pause();
return 0; return 0;
} }
@ -223,7 +223,7 @@ u8 SPURecompilerCore::DecodeMemory(const u64 address)
//if (pos == 0x19c >> 2) //if (pos == 0x19c >> 2)
{ {
//Emu.Pause(); //Emu.Pause();
//for (uint i = 0; i < 128; ++i) ConLog.Write("r%d = 0x%s", i, CPU.GPR[i].ToString().c_str()); //for (uint i = 0; i < 128; ++i) LOGF_NOTICE(Log::SPU, "r%d = 0x%s", i, CPU.GPR[i].ToString().c_str());
} }
} }
@ -243,7 +243,7 @@ u8 SPURecompilerCore::DecodeMemory(const u64 address)
//if (pos == 0x340 >> 2) //if (pos == 0x340 >> 2)
{ {
//Emu.Pause(); //Emu.Pause();
//for (uint i = 0; i < 128; ++i) ConLog.Write("r%d = 0x%s", i, CPU.GPR[i].ToString().c_str()); //for (uint i = 0; i < 128; ++i) LOGF_NOTICE(Log::SPU, "r%d = 0x%s", i, CPU.GPR[i].ToString().c_str());
} }
} }

4
rpcs3/Emu/Cell/SPUThread.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/SysCalls/lv2/SC_Lwmutex.h" #include "Emu/SysCalls/lv2/SC_Lwmutex.h"
@ -86,7 +86,7 @@ void SPUThread::DoRun()
break; break;
default: default:
ConLog.Error("Invalid SPU decoder mode: %d", Ini.SPUDecoderMode.GetValue()); LOGF_ERROR(Log::SPU, "Invalid SPU decoder mode: %d", Ini.SPUDecoderMode.GetValue());
Emu.Pause(); Emu.Pause();
} }
} }

92
rpcs3/Emu/Cell/SPUThread.h
View File

@ -211,7 +211,7 @@ public:
return this->low >> 22 & 0x3; return this->low >> 22 & 0x3;
default: default:
ConLog.Error("Unexpected slice value in FPSCR::checkSliceRounding(): %d", slice); LOGF_ERROR(SPU, "Unexpected slice value in FPSCR::checkSliceRounding(): %d", slice);
return 0; return 0;
} }
} }
@ -599,7 +599,7 @@ public:
u32 num = (ea & SYS_SPU_THREAD_BASE_MASK) / SYS_SPU_THREAD_OFFSET; // thread number in group u32 num = (ea & SYS_SPU_THREAD_BASE_MASK) / SYS_SPU_THREAD_OFFSET; // thread number in group
if (num >= group->list.size() || !group->list[num]) if (num >= group->list.size() || !group->list[num])
{ {
ConLog.Error("DMAC::ProcessCmd(): SPU Thread Group MMIO Access (ea=0x%llx): invalid thread", ea); LOGF_ERROR(Log::SPU, "DMAC::ProcessCmd(): SPU Thread Group MMIO Access (ea=0x%llx): invalid thread", ea);
return false; return false;
} }
@ -618,13 +618,13 @@ public:
} }
else else
{ {
ConLog.Error("DMAC::ProcessCmd(): SPU Thread Group MMIO Access (ea=0x%llx, size=%d, cmd=0x%x): invalid command", ea, size, cmd); LOGF_ERROR(Log::SPU, "DMAC::ProcessCmd(): SPU Thread Group MMIO Access (ea=0x%llx, size=%d, cmd=0x%x): invalid command", ea, size, cmd);
return false; return false;
} }
} }
else else
{ {
ConLog.Error("DMAC::ProcessCmd(): SPU Thread Group MMIO Access (ea=0x%llx): group not set", ea); LOGF_ERROR(Log::SPU, "DMAC::ProcessCmd(): SPU Thread Group MMIO Access (ea=0x%llx): group not set", ea);
return false; return false;
} }
} }
@ -646,7 +646,7 @@ public:
default: default:
{ {
ConLog.Error("DMAC::ProcessCmd(): Unknown DMA cmd."); LOG_ERROR(Log::SPU, "DMAC::ProcessCmd(): Unknown DMA cmd.");
return false; return false;
} }
} }
@ -664,7 +664,7 @@ public:
} }
else else
{ {
ConLog.Error("DMAC::ProcessCmd(): PUT* cmd failed (ea=0x%llx, lsa=0x%x, size=%d)", ea, lsa, size); LOGF_ERROR(Log::SPU, "DMAC::ProcessCmd(): PUT* cmd failed (ea=0x%llx, lsa=0x%x, size=%d)", ea, lsa, size);
return false; // TODO: page fault (?) return false; // TODO: page fault (?)
} }
} }
@ -677,14 +677,14 @@ public:
} }
else else
{ {
ConLog.Error("DMAC::ProcessCmd(): GET* cmd failed (ea=0x%llx, lsa=0x%x, size=%d)", ea, lsa, size); LOGF_ERROR(Log::SPU, "DMAC::ProcessCmd(): GET* cmd failed (ea=0x%llx, lsa=0x%x, size=%d)", ea, lsa, size);
return false; // TODO: page fault (?) return false; // TODO: page fault (?)
} }
} }
default: default:
{ {
ConLog.Error("DMAC::ProcessCmd(): Unknown DMA cmd."); LOG_ERROR(Log::SPU, "DMAC::ProcessCmd(): Unknown DMA cmd.");
return false; // ??? return false; // ???
} }
} }
@ -725,7 +725,7 @@ public:
u32 size = rec->ts; u32 size = rec->ts;
if (size < 16 && size != 1 && size != 2 && size != 4 && size != 8) if (size < 16 && size != 1 && size != 2 && size != 4 && size != 8)
{ {
ConLog.Error("DMA List: invalid transfer size(%d)", size); LOGF_ERROR(Log::SPU, "DMA List: invalid transfer size(%d)", size);
return; return;
} }
@ -737,7 +737,7 @@ public:
} }
if (Ini.HLELogging.GetValue() || rec->s) if (Ini.HLELogging.GetValue() || rec->s)
ConLog.Write("*** list element(%d/%d): s = 0x%x, ts = 0x%x, low ea = 0x%x (lsa = 0x%x)", LOGF_NOTICE(Log::SPU, "*** list element(%d/%d): s = 0x%x, ts = 0x%x, low ea = 0x%x (lsa = 0x%x)",
i, list_size, (u16)rec->s, (u16)rec->ts, (u32)rec->ea, lsa | (addr & 0xf)); i, list_size, (u16)rec->s, (u16)rec->ts, (u32)rec->ea, lsa | (addr & 0xf));
lsa += std::max(size, (u32)16); lsa += std::max(size, (u32)16);
@ -748,7 +748,7 @@ public:
if (StallList[tag].MFCArgs) if (StallList[tag].MFCArgs)
{ {
ConLog.Error("DMA List: existing stalled list found (tag=%d)", tag); LOGF_ERROR(Log::SPU, "DMA List: existing stalled list found (tag=%d)", tag);
} }
StallList[tag].MFCArgs = &MFCArgs; StallList[tag].MFCArgs = &MFCArgs;
StallList[tag].cmd = cmd; StallList[tag].cmd = cmd;
@ -780,7 +780,7 @@ public:
case MFC_PUTR_CMD: // ??? case MFC_PUTR_CMD: // ???
case MFC_GET_CMD: case MFC_GET_CMD:
{ {
if (Ini.HLELogging.GetValue()) ConLog.Write("DMA %s%s%s%s: lsa = 0x%x, ea = 0x%llx, tag = 0x%x, size = 0x%x, cmd = 0x%x", if (Ini.HLELogging.GetValue()) LOGF_NOTICE(Log::SPU, "DMA %s%s%s%s: lsa = 0x%x, ea = 0x%llx, tag = 0x%x, size = 0x%x, cmd = 0x%x",
(op & MFC_PUT_CMD ? "PUT" : "GET"), (op & MFC_PUT_CMD ? "PUT" : "GET"),
(op & MFC_RESULT_MASK ? "R" : ""), (op & MFC_RESULT_MASK ? "R" : ""),
(op & MFC_BARRIER_MASK ? "B" : ""), (op & MFC_BARRIER_MASK ? "B" : ""),
@ -795,7 +795,7 @@ public:
case MFC_PUTRL_CMD: // ??? case MFC_PUTRL_CMD: // ???
case MFC_GETL_CMD: case MFC_GETL_CMD:
{ {
if (Ini.HLELogging.GetValue()) ConLog.Write("DMA %s%s%s%s: lsa = 0x%x, list = 0x%llx, tag = 0x%x, size = 0x%x, cmd = 0x%x", if (Ini.HLELogging.GetValue()) LOGF_NOTICE(Log::SPU, "DMA %s%s%s%s: lsa = 0x%x, list = 0x%llx, tag = 0x%x, size = 0x%x, cmd = 0x%x",
(op & MFC_PUT_CMD ? "PUT" : "GET"), (op & MFC_PUT_CMD ? "PUT" : "GET"),
(op & MFC_RESULT_MASK ? "RL" : "L"), (op & MFC_RESULT_MASK ? "RL" : "L"),
(op & MFC_BARRIER_MASK ? "B" : ""), (op & MFC_BARRIER_MASK ? "B" : ""),
@ -811,7 +811,7 @@ public:
case MFC_PUTLLUC_CMD: case MFC_PUTLLUC_CMD:
case MFC_PUTQLLUC_CMD: case MFC_PUTQLLUC_CMD:
{ {
if (Ini.HLELogging.GetValue() || size != 128) ConLog.Write("DMA %s: lsa=0x%x, ea = 0x%llx, (tag) = 0x%x, (size) = 0x%x, cmd = 0x%x", if (Ini.HLELogging.GetValue() || size != 128) LOGF_NOTICE(Log::SPU, "DMA %s: lsa=0x%x, ea = 0x%llx, (tag) = 0x%x, (size) = 0x%x, cmd = 0x%x",
(op == MFC_GETLLAR_CMD ? "GETLLAR" : (op == MFC_GETLLAR_CMD ? "GETLLAR" :
op == MFC_PUTLLC_CMD ? "PUTLLC" : op == MFC_PUTLLC_CMD ? "PUTLLC" :
op == MFC_PUTLLUC_CMD ? "PUTLLUC" : "PUTQLLUC"), op == MFC_PUTLLUC_CMD ? "PUTLLUC" : "PUTQLLUC"),
@ -857,7 +857,7 @@ public:
{ {
if (buf[last].hi != reservation.data[last].hi && buf[last].lo != reservation.data[last].lo) if (buf[last].hi != reservation.data[last].hi && buf[last].lo != reservation.data[last].lo)
{ {
ConLog.Error("MFC_PUTLLC_CMD: TODO: 128bit compare and swap"); LOG_ERROR(Log::SPU, "MFC_PUTLLC_CMD: TODO: 128bit compare and swap");
Emu.Pause(); Emu.Pause();
Prxy.AtomicStat.PushUncond(MFC_PUTLLC_SUCCESS); Prxy.AtomicStat.PushUncond(MFC_PUTLLC_SUCCESS);
} }
@ -885,7 +885,7 @@ public:
} }
else // full 64 bit else // full 64 bit
{ {
ConLog.Error("MFC_PUTLLC_CMD: TODO: 64bit compare and swap"); LOGF_ERROR(Log::SPU, "MFC_PUTLLC_CMD: TODO: 64bit compare and swap");
Emu.Pause(); Emu.Pause();
Prxy.AtomicStat.PushUncond(MFC_PUTLLC_SUCCESS); Prxy.AtomicStat.PushUncond(MFC_PUTLLC_SUCCESS);
}*/ }*/
@ -894,7 +894,7 @@ public:
else else
{ {
ProcessCmd(MFC_PUT_CMD, tag, lsa, ea, 128); ProcessCmd(MFC_PUT_CMD, tag, lsa, ea, 128);
ConLog.Error("MFC_PUTLLC_CMD: Reservation Error: impossibru (~ 16x%d (mask=0x%x)) (opcode=0x%x, cmd=0x%x, lsa = 0x%x, ea = 0x%llx, tag = 0x%x, size = 0x%x)", LOGF_ERROR(Log::SPU, "MFC_PUTLLC_CMD: Reservation Error: impossibru (~ 16x%d (mask=0x%x)) (opcode=0x%x, cmd=0x%x, lsa = 0x%x, ea = 0x%llx, tag = 0x%x, size = 0x%x)",
changed, mask, op, cmd, lsa, ea, tag, size); changed, mask, op, cmd, lsa, ea, tag, size);
Emu.Pause(); Emu.Pause();
Prxy.AtomicStat.PushUncond(MFC_PUTLLC_SUCCESS); Prxy.AtomicStat.PushUncond(MFC_PUTLLC_SUCCESS);
@ -929,7 +929,7 @@ public:
break; break;
default: default:
ConLog.Error("Unknown MFC cmd. (opcode=0x%x, cmd=0x%x, lsa = 0x%x, ea = 0x%llx, tag = 0x%x, size = 0x%x)", LOGF_ERROR( Log::SPU, "Unknown MFC cmd. (opcode=0x%x, cmd=0x%x, lsa = 0x%x, ea = 0x%llx, tag = 0x%x, size = 0x%x)",
op, cmd, lsa, ea, tag, size); op, cmd, lsa, ea, tag, size);
break; break;
} }
@ -949,7 +949,7 @@ public:
return count; return count;
case SPU_WrOutIntrMbox: case SPU_WrOutIntrMbox:
ConLog.Warning("GetChannelCount(%s) = 0", spu_ch_name[ch]); LOGF_WARNING(Log::SPU, "GetChannelCount(%s) = 0", spu_ch_name[ch]);
return 0; return 0;
case MFC_RdTagStat: case MFC_RdTagStat:
@ -971,7 +971,7 @@ public:
return Prxy.AtomicStat.GetCount(); return Prxy.AtomicStat.GetCount();
default: default:
ConLog.Error("%s error: unknown/illegal channel (%d [%s]).", LOGF_ERROR(Log::SPU, "%s error: unknown/illegal channel (%d [%s]).",
__FUNCTION__, ch, spu_ch_name[ch]); __FUNCTION__, ch, spu_ch_name[ch]);
break; break;
} }
@ -988,7 +988,7 @@ public:
case SPU_WrOutIntrMbox: case SPU_WrOutIntrMbox:
if (!group) // if RawSPU if (!group) // if RawSPU
{ {
if (Ini.HLELogging.GetValue()) ConLog.Write("SPU_WrOutIntrMbox: interrupt(v=0x%x)", v); if (Ini.HLELogging.GetValue()) LOGF_NOTICE(Log::SPU, "SPU_WrOutIntrMbox: interrupt(v=0x%x)", v);
SPU.Out_IntrMBox.PushUncond(v); SPU.Out_IntrMBox.PushUncond(v);
m_intrtag[2].stat |= 1; m_intrtag[2].stat |= 1;
if (CPUThread* t = Emu.GetCPU().GetThread(m_intrtag[2].thread)) if (CPUThread* t = Emu.GetCPU().GetThread(m_intrtag[2].thread))
@ -998,7 +998,7 @@ public:
Sleep(1); Sleep(1);
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
ConLog.Warning("%s(%s) aborted", __FUNCTION__, spu_ch_name[ch]); LOGF_WARNING(Log::SPU, "%s(%s) aborted", __FUNCTION__, spu_ch_name[ch]);
return; return;
} }
} }
@ -1019,20 +1019,20 @@ public:
u32 data; u32 data;
if (!SPU.Out_MBox.Pop(data)) if (!SPU.Out_MBox.Pop(data))
{ {
ConLog.Error("sys_spu_thread_send_event(v=0x%x, spup=%d): Out_MBox is empty", v, spup); LOGF_ERROR(Log::SPU, "sys_spu_thread_send_event(v=0x%x, spup=%d): Out_MBox is empty", v, spup);
return; return;
} }
if (SPU.In_MBox.GetCount()) if (SPU.In_MBox.GetCount())
{ {
ConLog.Error("sys_spu_thread_send_event(v=0x%x, spup=%d): In_MBox is not empty", v, spup); LOGF_ERROR(Log::SPU, "sys_spu_thread_send_event(v=0x%x, spup=%d): In_MBox is not empty", v, spup);
SPU.In_MBox.PushUncond(CELL_EBUSY); // ??? SPU.In_MBox.PushUncond(CELL_EBUSY); // ???
return; return;
} }
if (Ini.HLELogging.GetValue()) if (Ini.HLELogging.GetValue())
{ {
ConLog.Write("sys_spu_thread_send_event(spup=%d, data0=0x%x, data1=0x%x)", spup, v & 0x00ffffff, data); LOGF_NOTICE(Log::SPU, "sys_spu_thread_send_event(spup=%d, data0=0x%x, data1=0x%x)", spup, v & 0x00ffffff, data);
} }
EventPort& port = SPUPs[spup]; EventPort& port = SPUPs[spup];
@ -1042,7 +1042,7 @@ public:
if (!port.eq) if (!port.eq)
{ {
// spu_printf fails there // spu_printf fails there
ConLog.Warning("sys_spu_thread_send_event(spup=%d, data0=0x%x, data1=0x%x): event queue not connected", spup, v & 0x00ffffff, data); LOGF_WARNING(Log::SPU, "sys_spu_thread_send_event(spup=%d, data0=0x%x, data1=0x%x): event queue not connected", spup, (v & 0x00ffffff), data);
SPU.In_MBox.PushUncond(CELL_ENOTCONN); // TODO: check error passing SPU.In_MBox.PushUncond(CELL_ENOTCONN); // TODO: check error passing
return; return;
} }
@ -1064,25 +1064,25 @@ public:
u32 data; u32 data;
if (!SPU.Out_MBox.Pop(data)) if (!SPU.Out_MBox.Pop(data))
{ {
ConLog.Error("sys_event_flag_set_bit(v=0x%x (flag=%d)): Out_MBox is empty", v, flag); LOGF_ERROR(Log::SPU, "sys_event_flag_set_bit(v=0x%x (flag=%d)): Out_MBox is empty", v, flag);
return; return;
} }
if (flag > 63) if (flag > 63)
{ {
ConLog.Error("sys_event_flag_set_bit(id=%d, v=0x%x): flag > 63", data, v, flag); LOGF_ERROR(Log::SPU, "sys_event_flag_set_bit(id=%d, v=0x%x): flag > 63", data, v, flag);
return; return;
} }
//if (Ini.HLELogging.GetValue()) //if (Ini.HLELogging.GetValue())
{ {
ConLog.Warning("sys_event_flag_set_bit(id=%d, v=0x%x (flag=%d))", data, v, flag); LOGF_WARNING(Log::SPU, "sys_event_flag_set_bit(id=%d, v=0x%x (flag=%d))", data, v, flag);
} }
EventFlag* ef; EventFlag* ef;
if (!Emu.GetIdManager().GetIDData(data, ef)) if (!Emu.GetIdManager().GetIDData(data, ef))
{ {
ConLog.Error("sys_event_flag_set_bit(id=%d, v=0x%x (flag=%d)): EventFlag not found", data, v, flag); LOGF_ERROR(Log::SPU, "sys_event_flag_set_bit(id=%d, v=0x%x (flag=%d)): EventFlag not found", data, v, flag);
SPU.In_MBox.PushUncond(CELL_ESRCH); SPU.In_MBox.PushUncond(CELL_ESRCH);
return; return;
} }
@ -1110,11 +1110,11 @@ public:
u32 data; u32 data;
if (SPU.Out_MBox.Pop(data)) if (SPU.Out_MBox.Pop(data))
{ {
ConLog.Error("SPU_WrOutIntrMbox: unknown data (v=0x%x); Out_MBox = 0x%x", v, data); LOGF_ERROR(Log::SPU, "SPU_WrOutIntrMbox: unknown data (v=0x%x); Out_MBox = 0x%x", v, data);
} }
else else
{ {
ConLog.Error("SPU_WrOutIntrMbox: unknown data (v=0x%x)", v); LOGF_ERROR(Log::SPU, "SPU_WrOutIntrMbox: unknown data (v=0x%x)", v);
} }
SPU.In_MBox.PushUncond(CELL_EINVAL); // ??? SPU.In_MBox.PushUncond(CELL_EINVAL); // ???
return; return;
@ -1166,13 +1166,13 @@ public:
{ {
if (v >= 32) if (v >= 32)
{ {
ConLog.Error("MFC_WrListStallAck error: invalid tag(%d)", v); LOGF_ERROR(Log::SPU, "MFC_WrListStallAck error: invalid tag(%d)", v);
return; return;
} }
StalledList temp = StallList[v]; StalledList temp = StallList[v];
if (!temp.MFCArgs) if (!temp.MFCArgs)
{ {
ConLog.Error("MFC_WrListStallAck error: empty tag(%d)", v); LOGF_ERROR(Log::SPU, "MFC_WrListStallAck error: empty tag(%d)", v);
return; return;
} }
StallList[v].MFCArgs = nullptr; StallList[v].MFCArgs = nullptr;
@ -1181,11 +1181,11 @@ public:
break; break;
default: default:
ConLog.Error("%s error: unknown/illegal channel (%d [%s]).", __FUNCTION__, ch, spu_ch_name[ch]); LOGF_ERROR(Log::SPU, "%s error: unknown/illegal channel (%d [%s]).", __FUNCTION__, ch, spu_ch_name[ch]);
break; break;
} }
if (Emu.IsStopped()) ConLog.Warning("%s(%s) aborted", __FUNCTION__, spu_ch_name[ch]); if (Emu.IsStopped()) LOGF_WARNING(Log::SPU, "%s(%s) aborted", __FUNCTION__, spu_ch_name[ch]);
} }
void ReadChannel(SPU_GPR_hdr& r, u32 ch) void ReadChannel(SPU_GPR_hdr& r, u32 ch)
@ -1224,11 +1224,11 @@ public:
break; break;
default: default:
ConLog.Error("%s error: unknown/illegal channel (%d [%s]).", __FUNCTION__, ch, spu_ch_name[ch]); LOGF_ERROR(Log::SPU, "%s error: unknown/illegal channel (%d [%s]).", __FUNCTION__, ch, spu_ch_name[ch]);
break; break;
} }
if (Emu.IsStopped()) ConLog.Warning("%s(%s) aborted", __FUNCTION__, spu_ch_name[ch]); if (Emu.IsStopped()) LOGF_WARNING(Log::SPU, "%s(%s) aborted", __FUNCTION__, spu_ch_name[ch]);
} }
void DoStop(u32 code) void DoStop(u32 code)
@ -1242,21 +1242,21 @@ public:
u32 spuq = 0; u32 spuq = 0;
if (!SPU.Out_MBox.Pop(spuq)) if (!SPU.Out_MBox.Pop(spuq))
{ {
ConLog.Error("sys_spu_thread_receive_event: cannot read Out_MBox"); LOG_ERROR(Log::SPU, "sys_spu_thread_receive_event: cannot read Out_MBox");
SPU.In_MBox.PushUncond(CELL_EINVAL); // ??? SPU.In_MBox.PushUncond(CELL_EINVAL); // ???
return; return;
} }
if (SPU.In_MBox.GetCount()) if (SPU.In_MBox.GetCount())
{ {
ConLog.Error("sys_spu_thread_receive_event(spuq=0x%x): In_MBox is not empty", spuq); LOGF_ERROR(Log::SPU, "sys_spu_thread_receive_event(spuq=0x%x): In_MBox is not empty", spuq);
SPU.In_MBox.PushUncond(CELL_EBUSY); // ??? SPU.In_MBox.PushUncond(CELL_EBUSY); // ???
return; return;
} }
if (Ini.HLELogging.GetValue()) if (Ini.HLELogging.GetValue())
{ {
ConLog.Write("sys_spu_thread_receive_event(spuq=0x%x)", spuq); LOGF_NOTICE(Log::SPU, "sys_spu_thread_receive_event(spuq=0x%x)", spuq);
} }
EventQueue* eq; EventQueue* eq;
@ -1307,7 +1307,7 @@ public:
Sleep(1); Sleep(1);
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
ConLog.Warning("sys_spu_thread_receive_event(spuq=0x%x) aborted", spuq); LOGF_WARNING(Log::SPU, "sys_spu_thread_receive_event(spuq=0x%x) aborted", spuq);
eq->sq.invalidate(tid); eq->sq.invalidate(tid);
return; return;
} }
@ -1317,12 +1317,12 @@ public:
case 0x102: case 0x102:
if (!SPU.Out_MBox.GetCount()) if (!SPU.Out_MBox.GetCount())
{ {
ConLog.Error("sys_spu_thread_exit (no status, code 0x102)"); LOG_ERROR(Log::SPU, "sys_spu_thread_exit (no status, code 0x102)");
} }
else if (Ini.HLELogging.GetValue()) else if (Ini.HLELogging.GetValue())
{ {
// the real exit status // the real exit status
ConLog.Write("sys_spu_thread_exit (status=0x%x)", SPU.Out_MBox.GetValue()); LOGF_NOTICE(Log::SPU, "sys_spu_thread_exit (status=0x%x)", SPU.Out_MBox.GetValue());
} }
SPU.Status.SetValue(SPU_STATUS_STOPPED_BY_STOP); SPU.Status.SetValue(SPU_STATUS_STOPPED_BY_STOP);
Stop(); Stop();
@ -1330,11 +1330,11 @@ public:
default: default:
if (!SPU.Out_MBox.GetCount()) if (!SPU.Out_MBox.GetCount())
{ {
ConLog.Error("Unknown STOP code: 0x%x (no message)", code); LOGF_ERROR(Log::SPU, "Unknown STOP code: 0x%x (no message)", code);
} }
else else
{ {
ConLog.Error("Unknown STOP code: 0x%x (message=0x%x)", code, SPU.Out_MBox.GetValue()); LOGF_ERROR(Log::SPU, "Unknown STOP code: 0x%x (message=0x%x)", code, SPU.Out_MBox.GetValue());
} }
SPU.Status.SetValue(SPU_STATUS_STOPPED_BY_STOP); SPU.Status.SetValue(SPU_STATUS_STOPPED_BY_STOP);
Stop(); Stop();

44
rpcs3/Emu/ConLog.h
View File

@ -1,44 +0,0 @@
#pragma once
class LogWriter
{
rFile m_logfile;
void WriteToLog(const std::string& prefix, const std::string& value, u8 lvl);
public:
LogWriter();
template <typename ...Arg>
void Write(const std::string &fmt, Arg... args)
{
std::string frmt = fmt::Format(fmt, std::forward<Arg>(args)...);
WriteToLog("!", frmt, 2);
}
template <typename ...Arg>
void Error(const std::string &fmt, Arg... args)
{
std::string frmt = fmt::Format(fmt, std::forward<Arg>(args)...);
WriteToLog("E", frmt, 4);
}
template <typename ...Arg>
void Warning(const std::string &fmt, Arg... args)
{
std::string frmt = fmt::Format(fmt, std::forward<Arg>(args)...);
WriteToLog("W", frmt, 3);
}
template <typename ...Arg>
void Success(const std::string &fmt, Arg... args)
{
std::string frmt = fmt::Format(fmt, std::forward<Arg>(args)...);
WriteToLog("S", frmt, 1);
}
virtual void SkipLn();
};
extern LogWriter ConLog;

97
rpcs3/Emu/DbgConsole.cpp
View File

@ -1,97 +0,0 @@
#include "stdafx.h"
#include "Emu/ConLog.h"
#include "Emu/Memory/Memory.h"
#include "Emu/System.h"
#include "DbgConsole.h"
BEGIN_EVENT_TABLE(DbgConsole, FrameBase)
EVT_CLOSE(DbgConsole::OnQuit)
END_EVENT_TABLE()
DbgConsole::DbgConsole()
: FrameBase(nullptr, wxID_ANY, "Debug Console", "", wxDefaultSize, wxDefaultPosition, wxDEFAULT_FRAME_STYLE, true)
, ThreadBase("DbgConsole thread")
, m_output(nullptr)
{
m_console = new wxTextCtrl(this, wxID_ANY, wxEmptyString, wxDefaultPosition,
wxSize(500, 500), wxTE_MULTILINE | wxTE_READONLY | wxTE_RICH2);
m_console->SetBackgroundColour(wxColor("Black"));
m_console->SetFont(wxFont(8, wxFONTFAMILY_MODERN, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL));
m_color_white = new wxTextAttr(wxColour(255, 255, 255));
m_color_red = new wxTextAttr(wxColour(255, 0, 0));
if (Ini.HLESaveTTY.GetValue())
m_output = new wxFile("tty.log", wxFile::write);
}
DbgConsole::~DbgConsole()
{
ThreadBase::Stop();
m_dbg_buffer.Flush();
safe_delete(m_console);
safe_delete(m_color_white);
safe_delete(m_color_red);
safe_delete(m_output);
}
void DbgConsole::Write(int ch, const std::string& text)
{
while (m_dbg_buffer.IsBusy())
{
if (Emu.IsStopped())
{
return;
}
Sleep(1);
}
m_dbg_buffer.Push(DbgPacket(ch, text));
if (!IsAlive()) Start();
}
void DbgConsole::Clear()
{
m_console->Clear();
}
void DbgConsole::Task()
{
while (!TestDestroy())
{
if (!m_dbg_buffer.HasNewPacket())
{
if (Emu.IsStopped())
{
break;
}
Sleep(1);
continue;
}
DbgPacket packet = m_dbg_buffer.Pop();
m_console->SetDefaultStyle(packet.m_ch == 1 ? *m_color_red : *m_color_white);
m_console->SetInsertionPointEnd();
m_console->WriteText(fmt::FromUTF8(packet.m_text));
if (m_output && Ini.HLESaveTTY.GetValue())
m_output->Write(fmt::FromUTF8(packet.m_text));
if (!DbgConsole::IsShown()) Show();
}
}
void DbgConsole::OnQuit(wxCloseEvent& event)
{
ThreadBase::Stop(false);
Hide();
if (m_output)
{
m_output->Close();
m_output = nullptr;
}
//event.Skip();
}

93
rpcs3/Emu/DbgConsole.h
View File

@ -1,93 +0,0 @@
#pragma once
#include <cstring> //for memset
struct DbgPacket
{
int m_ch;
std::string m_text;
DbgPacket(int ch, const std::string& text)
: m_ch(ch)
, m_text(text)
{
}
DbgPacket()
{
}
void Clear()
{
m_text.clear();
}
};
struct _DbgBuffer : public MTPacketBuffer<DbgPacket>
{
_DbgBuffer() : MTPacketBuffer<DbgPacket>(1024)
{
}
void _push(const DbgPacket& data)
{
const u32 stext = data.m_text.length();
m_buffer.resize(m_buffer.size() + sizeof(int) + sizeof(u32) + stext);
u32 c_put = m_put;
memcpy(&m_buffer[c_put], &data.m_ch, sizeof(int));
c_put += sizeof(int);
memcpy(&m_buffer[c_put], &stext, sizeof(u32));
c_put += sizeof(u32);
memcpy(&m_buffer[c_put], data.m_text.data(), stext);
c_put += stext;
m_put = c_put;
CheckBusy();
}
DbgPacket _pop()
{
DbgPacket ret;
u32 c_get = m_get;
ret.m_ch = *(int*)&m_buffer[c_get];
c_get += sizeof(int);
const u32& stext = *(u32*)&m_buffer[c_get];
c_get += sizeof(u32);
if (stext) ret.m_text = std::string(reinterpret_cast<const char*>(&m_buffer[c_get]), stext);
c_get += stext;
m_get = c_get;
if (!HasNewPacket()) Flush();
return ret;
}
};
class DbgConsole
: public FrameBase
, public ThreadBase
{
wxFile* m_output;
wxTextCtrl* m_console;
wxTextAttr* m_color_white;
wxTextAttr* m_color_red;
_DbgBuffer m_dbg_buffer;
public:
DbgConsole();
~DbgConsole();
void Write(int ch, const std::string& text);
void Clear();
virtual void Task();
private:
void OnQuit(wxCloseEvent& event);
DECLARE_EVENT_TABLE();
};

2
rpcs3/Emu/Event.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "event.h" #include "event.h"

2
rpcs3/Emu/FS/VFS.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "VFS.h" #include "VFS.h"
#include "Emu/HDD/HDD.h" #include "Emu/HDD/HDD.h"

2
rpcs3/Emu/FS/vfsDir.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"

2
rpcs3/Emu/FS/vfsFile.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"

6
rpcs3/Emu/FS/vfsLocalFile.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "vfsLocalFile.h" #include "vfsLocalFile.h"
static const rFile::OpenMode vfs2wx_mode(vfsOpenMode mode) static const rFile::OpenMode vfs2wx_mode(vfsOpenMode mode)
@ -53,7 +53,7 @@ bool vfsLocalFile::Open(const std::string& path, vfsOpenMode mode)
bool vfsLocalFile::Create(const std::string& path) bool vfsLocalFile::Create(const std::string& path)
{ {
ConLog.Warning("vfsLocalFile::Create('%s')", path.c_str()); LOGF_WARNING(HLE, "vfsLocalFile::Create('%s')", path.c_str());
for(uint p=1; p < path.length() && path[p] != '\0' ; p++) for(uint p=1; p < path.length() && path[p] != '\0' ; p++)
{ {
for(; p < path.length() && path[p] != '\0'; p++) for(; p < path.length() && path[p] != '\0'; p++)
@ -65,7 +65,7 @@ bool vfsLocalFile::Create(const std::string& path)
const std::string& dir = path.substr(0, p); const std::string& dir = path.substr(0, p);
if(!rDirExists(dir)) if(!rDirExists(dir))
{ {
ConLog.Write("create dir: %s", dir.c_str()); LOGF_NOTICE(HLE, "create dir: %s", dir.c_str());
rMkdir(dir); rMkdir(dir);
} }
} }

2
rpcs3/Emu/FS/vfsStreamMemory.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "vfsStreamMemory.h" #include "vfsStreamMemory.h"

2
rpcs3/Emu/GS/GL/GLBuffers.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "GLBuffers.h" #include "GLBuffers.h"
#include "GLGSRender.h" #include "GLGSRender.h"

16
rpcs3/Emu/GS/GL/GLFragmentProgram.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "GLFragmentProgram.h" #include "GLFragmentProgram.h"
@ -19,7 +19,7 @@ void GLFragmentDecompilerThread::SetDst(std::string code, bool append_mask)
case 7: code = "(" + code + " / 8.0)"; break; case 7: code = "(" + code + " / 8.0)"; break;
default: default:
ConLog.Error("Bad scale: %d", fmt::by_value(src1.scale)); LOGF_ERROR(RSX, "Bad scale: %d", fmt::by_value(src1.scale));
Emu.Pause(); Emu.Pause();
break; break;
} }
@ -210,7 +210,7 @@ template<typename T> std::string GLFragmentDecompilerThread::GetSRC(T src)
} }
else else
{ {
ConLog.Error("Bad src reg num: %d", fmt::by_value(dst.src_attr_reg_num)); LOGF_ERROR(RSX, "Bad src reg num: %d", fmt::by_value(dst.src_attr_reg_num));
ret += m_parr.AddParam(PARAM_IN, "vec4", "unk"); ret += m_parr.AddParam(PARAM_IN, "vec4", "unk");
Emu.Pause(); Emu.Pause();
} }
@ -224,7 +224,7 @@ template<typename T> std::string GLFragmentDecompilerThread::GetSRC(T src)
break; break;
default: default:
ConLog.Error("Bad src type %d", fmt::by_value(src.reg_type)); LOGF_ERROR(RSX, "Bad src type %d", fmt::by_value(src.reg_type));
Emu.Pause(); Emu.Pause();
break; break;
} }
@ -416,7 +416,7 @@ void GLFragmentDecompilerThread::Task()
//case 0x45: SetDst("return"); break; //RET //case 0x45: SetDst("return"); break; //RET
default: default:
ConLog.Error("Unknown fp opcode 0x%x (inst %d)", opcode, m_size / (4 * 4)); LOGF_ERROR(RSX, "Unknown fp opcode 0x%x (inst %d)", opcode, m_size / (4 * 4));
//Emu.Pause(); //Emu.Pause();
break; break;
} }
@ -515,12 +515,12 @@ void GLShaderProgram::Compile()
char* buf = new char[infoLength]; // Buffer to store infoLog char* buf = new char[infoLength]; // Buffer to store infoLog
glGetShaderInfoLog(m_id, infoLength, &len, buf); // Retrieve the shader info log into our buffer glGetShaderInfoLog(m_id, infoLength, &len, buf); // Retrieve the shader info log into our buffer
ConLog.Error("Failed to compile shader: %s", buf); // Write log to the console LOGF_ERROR(RSX, "Failed to compile shader: %s", buf); // Write log to the console
delete[] buf; delete[] buf;
} }
ConLog.Write(m_shader.c_str()); // Log the text of the shader that failed to compile LOG_NOTICE(RSX, m_shader.c_str()); // Log the text of the shader that failed to compile
Emu.Pause(); // Pause the emulator, we can't really continue from here Emu.Pause(); // Pause the emulator, we can't really continue from here
} }
} }
@ -540,7 +540,7 @@ void GLShaderProgram::Delete()
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
ConLog.Warning("GLShaderProgram::Delete(): glDeleteShader(%d) avoided", m_id); LOGF_WARNING(RSX, "GLShaderProgram::Delete(): glDeleteShader(%d) avoided", m_id);
} }
else else
{ {

42
rpcs3/Emu/GS/GL/GLGSRender.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "GLGSRender.h" #include "GLGSRender.h"
@ -9,7 +9,7 @@
#define DUMP_VERTEX_DATA 0 #define DUMP_VERTEX_DATA 0
#if CMD_DEBUG #if CMD_DEBUG
#define CMD_LOG ConLog.Write #define CMD_LOG(...) LOGF_NOTICE(RSX, __VA_ARGS__)
#else #else
#define CMD_LOG(...) #define CMD_LOG(...)
#endif #endif
@ -27,7 +27,7 @@ void printGlError(GLenum err, const char* situation)
{ {
if(err != GL_NO_ERROR) if(err != GL_NO_ERROR)
{ {
ConLog.Error("%s: opengl error 0x%04x", situation, err); LOGF_ERROR(RSX, "%s: opengl error 0x%04x", situation, err);
Emu.Pause(); Emu.Pause();
} }
} }
@ -180,7 +180,7 @@ void GLGSRender::EnableVertexData(bool indexed_draw)
break; break;
default: default:
ConLog.Error("Bad cv type! %d", m_vertex_data[i].type); LOGF_ERROR(HLE, "Bad cv type! %d", m_vertex_data[i].type);
return; return;
} }
@ -309,7 +309,7 @@ void GLGSRender::InitFragmentData()
{ {
if(!m_cur_shader_prog) if(!m_cur_shader_prog)
{ {
ConLog.Error("InitFragmentData: m_cur_shader_prog == NULL"); LOGF_ERROR(RSX, "InitFragmentData: m_cur_shader_prog == NULL");
return; return;
} }
@ -330,20 +330,20 @@ void GLGSRender::InitFragmentData()
} }
//if(m_fragment_constants.GetCount()) //if(m_fragment_constants.GetCount())
// ConLog.SkipLn(); // LOG_NOTICE(HLE, "");
} }
bool GLGSRender::LoadProgram() bool GLGSRender::LoadProgram()
{ {
if(!m_cur_shader_prog) if(!m_cur_shader_prog)
{ {
ConLog.Warning("LoadProgram: m_cur_shader_prog == NULL"); LOGF_WARNING(RSX, "LoadProgram: m_cur_shader_prog == NULL");
return false; return false;
} }
if(!m_cur_vertex_prog) if(!m_cur_vertex_prog)
{ {
ConLog.Warning("LoadProgram: m_cur_vertex_prog == NULL"); LOGF_WARNING(RSX, "LoadProgram: m_cur_vertex_prog == NULL");
return false; return false;
} }
@ -354,7 +354,7 @@ bool GLGSRender::LoadProgram()
if(m_fp_buf_num == -1) if(m_fp_buf_num == -1)
{ {
ConLog.Warning("FP not found in buffer!"); LOGF_WARNING(RSX, "FP not found in buffer!");
m_shader_prog.DecompileAsync(*m_cur_shader_prog); m_shader_prog.DecompileAsync(*m_cur_shader_prog);
m_shader_prog.Wait(); m_shader_prog.Wait();
m_shader_prog.Compile(); m_shader_prog.Compile();
@ -366,7 +366,7 @@ bool GLGSRender::LoadProgram()
if(m_vp_buf_num == -1) if(m_vp_buf_num == -1)
{ {
ConLog.Warning("VP not found in buffer!"); LOGF_WARNING(RSX, "VP not found in buffer!");
m_vertex_prog.DecompileAsync(*m_cur_vertex_prog); m_vertex_prog.DecompileAsync(*m_cur_vertex_prog);
m_vertex_prog.Wait(); m_vertex_prog.Wait();
m_vertex_prog.Compile(); m_vertex_prog.Compile();
@ -450,7 +450,7 @@ void GLGSRender::WriteDepthBuffer()
u32 address = GetAddress(m_surface_offset_z, m_context_dma_z - 0xfeed0000); u32 address = GetAddress(m_surface_offset_z, m_context_dma_z - 0xfeed0000);
if (!Memory.IsGoodAddr(address)) if (!Memory.IsGoodAddr(address))
{ {
ConLog.Warning("Bad depth address: address=0x%x, offset=0x%x, dma=0x%x", address, m_surface_offset_z, m_context_dma_z); LOGF_WARNING(RSX, "Bad depth address: address=0x%x, offset=0x%x, dma=0x%x", address, m_surface_offset_z, m_context_dma_z);
return; return;
} }
@ -484,7 +484,7 @@ void GLGSRender::WriteColourBufferA()
u32 address = GetAddress(m_surface_offset_a, m_context_dma_color_a - 0xfeed0000); u32 address = GetAddress(m_surface_offset_a, m_context_dma_color_a - 0xfeed0000);
if (!Memory.IsGoodAddr(address)) if (!Memory.IsGoodAddr(address))
{ {
ConLog.Warning("Bad colour buffer a address: address=0x%x, offset=0x%x, dma=0x%x", address, m_surface_offset_a, m_context_dma_color_a); LOGF_WARNING(RSX, "Bad colour buffer a address: address=0x%x, offset=0x%x, dma=0x%x", address, m_surface_offset_a, m_context_dma_color_a);
return; return;
} }
@ -513,7 +513,7 @@ void GLGSRender::WriteColourBufferB()
u32 address = GetAddress(m_surface_offset_b, m_context_dma_color_b - 0xfeed0000); u32 address = GetAddress(m_surface_offset_b, m_context_dma_color_b - 0xfeed0000);
if (!Memory.IsGoodAddr(address)) if (!Memory.IsGoodAddr(address))
{ {
ConLog.Warning("Bad colour buffer b address: address=0x%x, offset=0x%x, dma=0x%x", address, m_surface_offset_b, m_context_dma_color_b); LOGF_WARNING(RSX, "Bad colour buffer b address: address=0x%x, offset=0x%x, dma=0x%x", address, m_surface_offset_b, m_context_dma_color_b);
return; return;
} }
@ -543,7 +543,7 @@ void GLGSRender::WriteColourBufferC()
u32 address = GetAddress(m_surface_offset_c, m_context_dma_color_c - 0xfeed0000); u32 address = GetAddress(m_surface_offset_c, m_context_dma_color_c - 0xfeed0000);
if (!Memory.IsGoodAddr(address)) if (!Memory.IsGoodAddr(address))
{ {
ConLog.Warning("Bad colour buffer c address: address=0x%x, offset=0x%x, dma=0x%x", address, m_surface_offset_c, m_context_dma_color_c); LOGF_WARNING(RSX, "Bad colour buffer c address: address=0x%x, offset=0x%x, dma=0x%x", address, m_surface_offset_c, m_context_dma_color_c);
return; return;
} }
@ -572,7 +572,7 @@ void GLGSRender::WriteColourBufferD()
u32 address = GetAddress(m_surface_offset_d, m_context_dma_color_d - 0xfeed0000); u32 address = GetAddress(m_surface_offset_d, m_context_dma_color_d - 0xfeed0000);
if (!Memory.IsGoodAddr(address)) if (!Memory.IsGoodAddr(address))
{ {
ConLog.Warning("Bad colour buffer d address: address=0x%x, offset=0x%x, dma=0x%x", address, m_surface_offset_d, m_context_dma_color_d); LOGF_WARNING(RSX, "Bad colour buffer d address: address=0x%x, offset=0x%x, dma=0x%x", address, m_surface_offset_d, m_context_dma_color_d);
return; return;
} }
@ -703,14 +703,14 @@ void GLGSRender::ExecCMD()
//return; //return;
if(!LoadProgram()) if(!LoadProgram())
{ {
ConLog.Error("LoadProgram failed."); LOGF_ERROR(RSX, "LoadProgram failed.");
Emu.Pause(); Emu.Pause();
return; return;
} }
if(!m_fbo.IsCreated() || RSXThread::m_width != last_width || RSXThread::m_height != last_height || last_depth_format != m_surface_depth_format) if(!m_fbo.IsCreated() || RSXThread::m_width != last_width || RSXThread::m_height != last_height || last_depth_format != m_surface_depth_format)
{ {
ConLog.Warning("New FBO (%dx%d)", RSXThread::m_width, RSXThread::m_height); LOGF_WARNING(RSX, "New FBO (%dx%d)", RSXThread::m_width, RSXThread::m_height);
last_width = RSXThread::m_width; last_width = RSXThread::m_width;
last_height = RSXThread::m_height; last_height = RSXThread::m_height;
last_depth_format = m_surface_depth_format; last_depth_format = m_surface_depth_format;
@ -753,7 +753,7 @@ void GLGSRender::ExecCMD()
break; break;
default: default:
ConLog.Error("Bad depth format! (%d)", m_surface_depth_format); LOGF_ERROR(RSX, "Bad depth format! (%d)", m_surface_depth_format);
assert(0); assert(0);
break; break;
} }
@ -821,7 +821,7 @@ void GLGSRender::ExecCMD()
break; break;
default: default:
ConLog.Error("Bad surface colour target: %d", m_surface_colour_target); LOGF_ERROR(RSX, "Bad surface colour target: %d", m_surface_colour_target);
break; break;
} }
@ -1099,7 +1099,7 @@ void GLGSRender::ExecCMD()
if(m_indexed_array.m_count && m_draw_array_count) if(m_indexed_array.m_count && m_draw_array_count)
{ {
ConLog.Warning("m_indexed_array.m_count && draw_array_count"); LOGF_WARNING(RSX, "m_indexed_array.m_count && draw_array_count");
} }
for(u32 i=0; i<m_textures_count; ++i) for(u32 i=0; i<m_textures_count; ++i)
@ -1142,7 +1142,7 @@ void GLGSRender::ExecCMD()
break; break;
default: default:
ConLog.Error("Bad indexed array type (%d)", m_indexed_array.m_type); LOGF_ERROR(RSX, "Bad indexed array type (%d)", m_indexed_array.m_type);
break; break;
} }

6
rpcs3/Emu/GS/GL/GLGSRender.h
View File

@ -57,7 +57,7 @@ public:
case 8: return GL_MIRROR_CLAMP_EXT; case 8: return GL_MIRROR_CLAMP_EXT;
} }
ConLog.Error("Texture wrap error: bad wrap (%d).", wrap); LOGF_ERROR(RSX, "Texture wrap error: bad wrap (%d).", wrap);
return GL_REPEAT; return GL_REPEAT;
} }
@ -89,7 +89,7 @@ public:
const u64 texaddr = GetAddress(tex.GetOffset(), tex.GetLocation()); const u64 texaddr = GetAddress(tex.GetOffset(), tex.GetLocation());
if (!Memory.IsGoodAddr(texaddr)) if (!Memory.IsGoodAddr(texaddr))
{ {
ConLog.Error("Bad texture address=0x%x", texaddr); LOGF_ERROR(RSX, "Bad texture address=0x%x", texaddr);
return; return;
} }
//ConLog.Warning("texture addr = 0x%x, width = %d, height = %d, max_aniso=%d, mipmap=%d, remap=0x%x, zfunc=0x%x, wraps=0x%x, wrapt=0x%x, wrapr=0x%x, minlod=0x%x, maxlod=0x%x", //ConLog.Warning("texture addr = 0x%x, width = %d, height = %d, max_aniso=%d, mipmap=%d, remap=0x%x, zfunc=0x%x, wraps=0x%x, wrapt=0x%x, wrapr=0x%x, minlod=0x%x, maxlod=0x%x",
@ -420,7 +420,7 @@ public:
} }
break; break;
default: ConLog.Error("Init tex error: Bad tex format (0x%x | %s | 0x%x)", format, default: LOGF_ERROR(RSX, "Init tex error: Bad tex format (0x%x | %s | 0x%x)", format,
(is_swizzled ? "swizzled" : "linear"), tex.GetFormat() & 0x40); break; (is_swizzled ? "swizzled" : "linear"), tex.GetFormat() & 0x40); break;
} }

8
rpcs3/Emu/GS/GL/GLProgram.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "GLProgram.h" #include "GLProgram.h"
#include "GLGSRender.h" #include "GLGSRender.h"
@ -54,13 +54,13 @@ void GLProgram::Create(const u32 vp, const u32 fp)
char* buf = new char[bufLength+1]; char* buf = new char[bufLength+1];
memset(buf, 0, bufLength+1); memset(buf, 0, bufLength+1);
glGetProgramInfoLog(id, bufLength, NULL, buf); glGetProgramInfoLog(id, bufLength, NULL, buf);
ConLog.Error("Could not link program: %s", buf); LOGF_ERROR(RSX, "Could not link program: %s", buf);
delete[] buf; delete[] buf;
return; return;
} }
} }
//else ConLog.Write("program linked!"); //else LOGF_NOTICE(HLE, "program linked!");
glGetProgramiv(id, GL_VALIDATE_STATUS, &linkStatus); glGetProgramiv(id, GL_VALIDATE_STATUS, &linkStatus);
if(linkStatus != GL_TRUE) if(linkStatus != GL_TRUE)
@ -73,7 +73,7 @@ void GLProgram::Create(const u32 vp, const u32 fp)
char* buf = new char[bufLength]; char* buf = new char[bufLength];
memset(buf, 0, bufLength); memset(buf, 0, bufLength);
glGetProgramInfoLog(id, bufLength, NULL, buf); glGetProgramInfoLog(id, bufLength, NULL, buf);
ConLog.Error("Could not link program: %s", buf); LOGF_ERROR(RSX, "Could not link program: %s", buf);
delete[] buf; delete[] buf;
return; return;

42
rpcs3/Emu/GS/GL/GLProgramBuffer.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "GLProgramBuffer.h" #include "GLProgramBuffer.h"
@ -52,13 +52,13 @@ u32 GLProgramBuffer::GetProg(u32 fp, u32 vp) const
if(fp == vp) if(fp == vp)
{ {
/* /*
ConLog.Write("Get program (%d):", fp); LOGF_NOTICE(RSX, "Get program (%d):", fp);
ConLog.Write("*** prog id = %d", m_buf[fp].prog_id); LOGF_NOTICE(RSX, "*** prog id = %d", m_buf[fp].prog_id);
ConLog.Write("*** vp id = %d", m_buf[fp].vp_id); LOGF_NOTICE(RSX, "*** vp id = %d", m_buf[fp].vp_id);
ConLog.Write("*** fp id = %d", m_buf[fp].fp_id); LOGF_NOTICE(RSX, "*** fp id = %d", m_buf[fp].fp_id);
ConLog.Write("*** vp shader = \n%s", m_buf[fp].vp_shader.wx_str()); LOGF_NOTICE(RSX, "*** vp shader = \n%s", m_buf[fp].vp_shader.wx_str());
ConLog.Write("*** fp shader = \n%s", m_buf[fp].fp_shader.wx_str()); LOGF_NOTICE(RSX, "*** fp shader = \n%s", m_buf[fp].fp_shader.wx_str());
*/ */
return m_buf[fp].prog_id; return m_buf[fp].prog_id;
} }
@ -70,13 +70,13 @@ u32 GLProgramBuffer::GetProg(u32 fp, u32 vp) const
if(CmpVP(vp, i) && CmpFP(fp, i)) if(CmpVP(vp, i) && CmpFP(fp, i))
{ {
/* /*
ConLog.Write("Get program (%d):", i); LOGF_NOTICE(RSX, "Get program (%d):", i);
ConLog.Write("*** prog id = %d", m_buf[i].prog_id); LOGF_NOTICE(RSX, "*** prog id = %d", m_buf[i].prog_id);
ConLog.Write("*** vp id = %d", m_buf[i].vp_id); LOGF_NOTICE(RSX, "*** vp id = %d", m_buf[i].vp_id);
ConLog.Write("*** fp id = %d", m_buf[i].fp_id); LOGF_NOTICE(RSX, "*** fp id = %d", m_buf[i].fp_id);
ConLog.Write("*** vp shader = \n%s", m_buf[i].vp_shader.wx_str()); LOGF_NOTICE(RSX, "*** vp shader = \n%s", m_buf[i].vp_shader.wx_str());
ConLog.Write("*** fp shader = \n%s", m_buf[i].fp_shader.wx_str()); LOGF_NOTICE(RSX, "*** fp shader = \n%s", m_buf[i].fp_shader.wx_str());
*/ */
return m_buf[i].prog_id; return m_buf[i].prog_id;
} }
@ -89,15 +89,15 @@ void GLProgramBuffer::Add(GLProgram& prog, GLShaderProgram& gl_fp, RSXShaderProg
{ {
GLBufferInfo new_buf; GLBufferInfo new_buf;
ConLog.Write("Add program (%d):", m_buf.size()); LOGF_NOTICE(RSX, "Add program (%d):", m_buf.size());
ConLog.Write("*** prog id = %d", prog.id); LOGF_NOTICE(RSX, "*** prog id = %d", prog.id);
ConLog.Write("*** vp id = %d", gl_vp.id); LOGF_NOTICE(RSX, "*** vp id = %d", gl_vp.id);
ConLog.Write("*** fp id = %d", gl_fp.GetId()); LOGF_NOTICE(RSX, "*** fp id = %d", gl_fp.GetId());
ConLog.Write("*** vp data size = %d", rsx_vp.data.size() * 4); LOGF_NOTICE(RSX, "*** vp data size = %d", rsx_vp.data.size() * 4);
ConLog.Write("*** fp data size = %d", rsx_fp.size); LOGF_NOTICE(RSX, "*** fp data size = %d", rsx_fp.size);
ConLog.Write("*** vp shader = \n%s", gl_vp.shader.c_str()); LOGF_NOTICE(RSX, "*** vp shader = \n%s", gl_vp.shader.c_str());
ConLog.Write("*** fp shader = \n%s", gl_fp.GetShaderText().c_str()); LOGF_NOTICE(RSX, "*** fp shader = \n%s", gl_fp.GetShaderText().c_str());
new_buf.prog_id = prog.id; new_buf.prog_id = prog.id;

22
rpcs3/Emu/GS/GL/GLVertexProgram.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
@ -49,7 +49,7 @@ std::string GLVertexDecompilerThread::GetDST(bool isSca)
default: default:
if (d3.dst > 15) if (d3.dst > 15)
ConLog.Error("dst index out of range: %u", d3.dst); LOGF_ERROR(RSX, "dst index out of range: %u", d3.dst);
ret += m_parr.AddParam(PARAM_NONE, "vec4", std::string("dst_reg") + std::to_string(d3.dst), d3.dst == 0 ? "vec4(0.0f, 0.0f, 0.0f, 1.0f)" : "vec4(0.0)"); ret += m_parr.AddParam(PARAM_NONE, "vec4", std::string("dst_reg") + std::to_string(d3.dst), d3.dst == 0 ? "vec4(0.0f, 0.0f, 0.0f, 1.0f)" : "vec4(0.0)");
break; break;
} }
@ -83,7 +83,7 @@ std::string GLVertexDecompilerThread::GetSRC(const u32 n)
} }
else else
{ {
ConLog.Error("Bad input src num: %d", fmt::by_value(d1.input_src)); LOGF_ERROR(RSX, "Bad input src num: %d", fmt::by_value(d1.input_src));
ret += m_parr.AddParam(PARAM_IN, "vec4", "in_unk", d1.input_src); ret += m_parr.AddParam(PARAM_IN, "vec4", "in_unk", d1.input_src);
} }
break; break;
@ -93,7 +93,7 @@ std::string GLVertexDecompilerThread::GetSRC(const u32 n)
break; break;
default: default:
ConLog.Error("Bad src%u reg type: %d", n, fmt::by_value(src[n].reg_type)); LOGF_ERROR(RSX, "Bad src%u reg type: %d", n, fmt::by_value(src[n].reg_type));
Emu.Pause(); Emu.Pause();
break; break;
} }
@ -510,7 +510,7 @@ void GLVertexDecompilerThread::Task()
default: default:
m_body.push_back(fmt::Format("//Unknown vp sca_opcode 0x%x", fmt::by_value(d1.sca_opcode))); m_body.push_back(fmt::Format("//Unknown vp sca_opcode 0x%x", fmt::by_value(d1.sca_opcode)));
ConLog.Error("Unknown vp sca_opcode 0x%x", fmt::by_value(d1.sca_opcode)); LOGF_ERROR(RSX, "Unknown vp sca_opcode 0x%x", fmt::by_value(d1.sca_opcode));
Emu.Pause(); Emu.Pause();
break; break;
} }
@ -543,7 +543,7 @@ void GLVertexDecompilerThread::Task()
default: default:
m_body.push_back(fmt::Format("//Unknown vp opcode 0x%x", fmt::by_value(d1.vec_opcode))); m_body.push_back(fmt::Format("//Unknown vp opcode 0x%x", fmt::by_value(d1.vec_opcode)));
ConLog.Error("Unknown vp opcode 0x%x", fmt::by_value(d1.vec_opcode)); LOGF_ERROR(RSX, "Unknown vp opcode 0x%x", fmt::by_value(d1.vec_opcode));
Emu.Pause(); Emu.Pause();
break; break;
} }
@ -553,7 +553,7 @@ void GLVertexDecompilerThread::Task()
m_instr_count++; m_instr_count++;
if(i < m_data.size()) if(i < m_data.size())
ConLog.Error("Program end before buffer end."); LOG_ERROR(RSX, "Program end before buffer end.");
break; break;
} }
@ -647,14 +647,14 @@ void GLVertexProgram::Compile()
GLsizei len; GLsizei len;
memset(buf, 0, r+1); memset(buf, 0, r+1);
glGetShaderInfoLog(id, r, &len, buf); glGetShaderInfoLog(id, r, &len, buf);
ConLog.Error("Failed to compile vertex shader: %s", buf); LOGF_ERROR(RSX, "Failed to compile vertex shader: %s", buf);
delete[] buf; delete[] buf;
} }
ConLog.Write(shader); LOG_NOTICE(RSX, shader);
Emu.Pause(); Emu.Pause();
} }
//else ConLog.Write("Vertex shader compiled successfully!"); //else LOGF_WARNING(RSX, "Vertex shader compiled successfully!");
} }
@ -667,7 +667,7 @@ void GLVertexProgram::Delete()
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
ConLog.Warning("GLVertexProgram::Delete(): glDeleteShader(%d) avoided", id); LOGF_WARNING(RSX, "GLVertexProgram::Delete(): glDeleteShader(%d) avoided", id);
} }
else else
{ {

6
rpcs3/Emu/GS/GL/OpenGL.cpp
View File

@ -1,12 +1,12 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "OpenGL.h" #include "OpenGL.h"
void InitProcTable() void InitProcTable()
{ {
#ifdef _WIN32 #ifdef _WIN32
#define OPENGL_PROC(p, n) OPENGL_PROC2(p, n, gl##n) #define OPENGL_PROC(p, n) OPENGL_PROC2(p, n, gl##n)
#define OPENGL_PROC2(p, n, tn) /*if(!gl##n)*/ if(!(gl##n = (p)wglGetProcAddress(#tn))) ConLog.Error("OpenGL: initialization of " #tn " failed.") #define OPENGL_PROC2(p, n, tn) /*if(!gl##n)*/ if(!(gl##n = (p)wglGetProcAddress(#tn))) LOG_ERROR(RSX, "OpenGL: initialization of " #tn " failed.")
#include "GLProcTable.h" #include "GLProcTable.h"
#undef OPENGL_PROC #undef OPENGL_PROC
#undef OPENGL_PROC2 #undef OPENGL_PROC2
@ -40,7 +40,7 @@ void OpenGL::Init()
{ {
#ifdef _WIN32 #ifdef _WIN32
#define OPENGL_PROC(p, n) OPENGL_PROC2(p, n, gl##n) #define OPENGL_PROC(p, n) OPENGL_PROC2(p, n, gl##n)
#define OPENGL_PROC2(p, n, tn) if(!(n = (p)wglGetProcAddress(#tn))) ConLog.Error("OpenGL: initialization of " #tn " failed.") #define OPENGL_PROC2(p, n, tn) if(!(n = (p)wglGetProcAddress(#tn))) LOG_ERROR(RSX, "OpenGL: initialization of " #tn " failed.")
#include "GLProcTable.h" #include "GLProcTable.h"
#undef OPENGL_PROC #undef OPENGL_PROC
#undef OPENGL_PROC2 #undef OPENGL_PROC2

2
rpcs3/Emu/GS/GSManager.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "rpcs3/Ini.h" #include "rpcs3/Ini.h"

2
rpcs3/Emu/GS/GSRender.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"

2
rpcs3/Emu/GS/RSXTexture.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "RSXThread.h" #include "RSXThread.h"
#include "RSXThread.h" #include "RSXThread.h"

130
rpcs3/Emu/GS/RSXThread.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "RSXThread.h" #include "RSXThread.h"
@ -20,7 +20,7 @@ u32 GetAddress(u32 offset, u8 location)
return realAddr; return realAddr;
} }
ConLog.Error("GetAddress(offset=0x%x, location=0x%x)", location); LOGF_ERROR(RSX, "GetAddress(offset=0x%x, location=0x%x)", location);
assert(0); assert(0);
return 0; return 0;
} }
@ -97,14 +97,14 @@ u32 RSXVertexData::GetTypeSize()
case 7: return 1; case 7: return 1;
} }
ConLog.Error("Bad vertex data type! %d", type); LOGF_ERROR(RSX, "Bad vertex data type! %d", type);
return 1; return 1;
} }
#define CMD_DEBUG 0 #define CMD_DEBUG 0
#if CMD_DEBUG #if CMD_DEBUG
#define CMD_LOG ConLog.Write #define CMD_LOG(...) LOG_NOTICE(RSX, __VA_ARGS__)
#else #else
#define CMD_LOG(...) #define CMD_LOG(...)
#endif #endif
@ -115,7 +115,7 @@ u32 RSXThread::OutOfArgsCount(const uint x, const u32 cmd, const u32 count)
debug += "("; debug += "(";
for(u32 i=0; i<count; ++i) debug += (i ? ", " : "") + fmt::Format("0x%x", ARGS(i)); for(u32 i=0; i<count; ++i) debug += (i ? ", " : "") + fmt::Format("0x%x", ARGS(i));
debug += ")"; debug += ")";
ConLog.Write("OutOfArgsCount(x=%u, count=%u): " + debug, x, count); LOGF_NOTICE(RSX, "OutOfArgsCount(x=%u, count=%u): " + debug, x, count);
return 0; return 0;
} }
@ -182,7 +182,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
debug += "("; debug += "(";
for(u32 i=0; i<count; ++i) debug += (i ? ", " : "") + fmt::Format("0x%x", ARGS(i)); for(u32 i=0; i<count; ++i) debug += (i ? ", " : "") + fmt::Format("0x%x", ARGS(i));
debug += ")"; debug += ")";
ConLog.Write(debug); LOG_NOTICE(RSX, debug);
#endif #endif
u32 index = 0; u32 index = 0;
@ -214,7 +214,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV4097_NO_OPERATION: case NV4097_NO_OPERATION:
{ {
ConLog.Warning("NV4097_NO_OPERATION"); LOGF_WARNING(RSX, "NV4097_NO_OPERATION");
} }
break; break;
@ -274,7 +274,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case_16(NV4097_SET_TEX_COORD_CONTROL, 4) : case_16(NV4097_SET_TEX_COORD_CONTROL, 4) :
{ {
ConLog.Warning("NV4097_SET_TEX_COORD_CONTROL"); LOGF_WARNING(RSX, "NV4097_SET_TEX_COORD_CONTROL");
} }
break; break;
@ -304,7 +304,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
m_vertex_data[index].data.push_back(v1); m_vertex_data[index].data.push_back(v1);
m_vertex_data[index].data.push_back(v2); m_vertex_data[index].data.push_back(v2);
m_vertex_data[index].data.push_back(v3); m_vertex_data[index].data.push_back(v3);
//ConLog.Warning("index = %d, v0 = 0x%x, v1 = 0x%x, v2 = 0x%x, v3 = 0x%x", index, v0, v1, v2, v3); //LOGF_WARNING(RSX, "index = %d, v0 = 0x%x, v1 = 0x%x, v2 = 0x%x, v3 = 0x%x", index, v0, v1, v2, v3);
} }
break; break;
@ -323,7 +323,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
(float&)m_vertex_data[index].data[sizeof(float)*0] = v0; (float&)m_vertex_data[index].data[sizeof(float)*0] = v0;
(float&)m_vertex_data[index].data[sizeof(float)*1] = v1; (float&)m_vertex_data[index].data[sizeof(float)*1] = v1;
//ConLog.Warning("index = %d, v0 = %f, v1 = %f", index, v0, v1); //LOGF_WARNING(RSX, "index = %d, v0 = %f, v1 = %f", index, v0, v1);
} }
break; break;
@ -348,7 +348,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
(float&)m_vertex_data[index].data[sizeof(float)*2] = v2; (float&)m_vertex_data[index].data[sizeof(float)*2] = v2;
(float&)m_vertex_data[index].data[sizeof(float)*3] = v3; (float&)m_vertex_data[index].data[sizeof(float)*3] = v3;
//ConLog.Warning("index = %d, v0 = %f, v1 = %f, v2 = %f, v3 = %f", index, v0, v1, v2, v3); //LOGF_WARNING(RSX, "index = %d, v0 = %f, v1 = %f, v2 = %f, v3 = %f", index, v0, v1, v2, v3);
} }
break; break;
@ -383,7 +383,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV4097_SET_VERTEX_ATTRIB_INPUT_MASK: case NV4097_SET_VERTEX_ATTRIB_INPUT_MASK:
{ {
if (ARGS(0)) if (ARGS(0))
ConLog.Warning("NV4097_SET_VERTEX_ATTRIB_INPUT_MASK: %x", ARGS(0)); LOGF_WARNING(RSX, "NV4097_SET_VERTEX_ATTRIB_INPUT_MASK: %x", ARGS(0));
//VertexData[0].prog.attributeInputMask = ARGS(0); //VertexData[0].prog.attributeInputMask = ARGS(0);
} }
@ -392,7 +392,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV4097_SET_VERTEX_ATTRIB_OUTPUT_MASK: case NV4097_SET_VERTEX_ATTRIB_OUTPUT_MASK:
{ {
if (ARGS(0)) if (ARGS(0))
ConLog.Warning("NV4097_SET_VERTEX_ATTRIB_OUTPUT_MASK: %x", ARGS(0)); LOGF_WARNING(RSX, "NV4097_SET_VERTEX_ATTRIB_OUTPUT_MASK: %x", ARGS(0));
//VertexData[0].prog.attributeOutputMask = ARGS(0); //VertexData[0].prog.attributeOutputMask = ARGS(0);
//FragmentData.prog.attributeInputMask = ARGS(0)/* & ~0x20*/; //FragmentData.prog.attributeInputMask = ARGS(0)/* & ~0x20*/;
@ -415,7 +415,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV4097_SET_COLOR_MASK_MRT: case NV4097_SET_COLOR_MASK_MRT:
{ {
if (ARGS(0)) if (ARGS(0))
ConLog.Warning("NV4097_SET_COLOR_MASK_MRT: %x", ARGS(0)); LOGF_WARNING(RSX, "NV4097_SET_COLOR_MASK_MRT: %x", ARGS(0));
} }
break; break;
@ -479,7 +479,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV4097_SET_BLEND_ENABLE_MRT: case NV4097_SET_BLEND_ENABLE_MRT:
{ {
if (ARGS(0)) if (ARGS(0))
ConLog.Warning("NV4097_SET_BLEND_ENABLE_MRT: %x", ARGS(0)); LOGF_WARNING(RSX, "NV4097_SET_BLEND_ENABLE_MRT: %x", ARGS(0));
} }
break; break;
@ -519,7 +519,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV4097_SET_BLEND_COLOR2: case NV4097_SET_BLEND_COLOR2:
{ {
if (ARGS(0)) if (ARGS(0))
ConLog.Warning("NV4097_SET_BLEND_COLOR2: 0x % x", ARGS(0)); LOGF_WARNING(RSX, "NV4097_SET_BLEND_COLOR2: 0x % x", ARGS(0));
} }
break; break;
@ -534,7 +534,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV4097_SET_REDUCE_DST_COLOR: case NV4097_SET_REDUCE_DST_COLOR:
{ {
if (ARGS(0)) if (ARGS(0))
ConLog.Warning("NV4097_SET_REDUCE_DST_COLOR: 0x % x", ARGS(0)); LOGF_WARNING(RSX, "NV4097_SET_REDUCE_DST_COLOR: 0x % x", ARGS(0));
} }
break; break;
@ -608,7 +608,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV4097_SET_CLIP_MAX: case NV4097_SET_CLIP_MAX:
{ {
if (ARGS(0)) if (ARGS(0))
ConLog.Warning("NV4097_SET_CLIP_MAX: %x", ARGS(0)); LOGF_WARNING(RSX, "NV4097_SET_CLIP_MAX: %x", ARGS(0));
} }
break; break;
@ -734,14 +734,14 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV4097_SET_CLEAR_RECT_HORIZONTAL: case NV4097_SET_CLEAR_RECT_HORIZONTAL:
{ {
if (ARGS(0)) if (ARGS(0))
ConLog.Warning("NV4097_SET_CLEAR_RECT_HORIZONTAL: %x", ARGS(0)); LOGF_WARNING(RSX, "NV4097_SET_CLEAR_RECT_HORIZONTAL: %x", ARGS(0));
} }
break; break;
case NV4097_SET_CLEAR_RECT_VERTICAL: case NV4097_SET_CLEAR_RECT_VERTICAL:
{ {
if (ARGS(0)) if (ARGS(0))
ConLog.Warning("NV4097_SET_CLEAR_RECT_VERTICAL: %x", ARGS(0)); LOGF_WARNING(RSX, "NV4097_SET_CLEAR_RECT_VERTICAL: %x", ARGS(0));
} }
break; break;
@ -754,7 +754,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
const u32 first = ac & 0xffffff; const u32 first = ac & 0xffffff;
const u32 _count = (ac >> 24) + 1; const u32 _count = (ac >> 24) + 1;
//ConLog.Warning("NV4097_DRAW_ARRAYS: %d - %d", first, _count); //LOGF_WARNING(RSX, "NV4097_DRAW_ARRAYS: %d - %d", first, _count);
LoadVertexData(first, _count); LoadVertexData(first, _count);
@ -791,7 +791,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
m_indexed_array.m_data.resize(m_indexed_array.m_data.size() + 4); m_indexed_array.m_data.resize(m_indexed_array.m_data.size() + 4);
index = Memory.Read32(m_indexed_array.m_addr + i * 4); index = Memory.Read32(m_indexed_array.m_addr + i * 4);
*(u32*)&m_indexed_array.m_data[pos] = index; *(u32*)&m_indexed_array.m_data[pos] = index;
//ConLog.Warning("index 4: %d", *(u32*)&m_indexed_array.m_data[pos]); //LOGF_WARNING(RSX, "index 4: %d", *(u32*)&m_indexed_array.m_data[pos]);
} }
break; break;
@ -800,7 +800,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
int pos = m_indexed_array.m_data.size(); int pos = m_indexed_array.m_data.size();
m_indexed_array.m_data.resize(m_indexed_array.m_data.size() + 2); m_indexed_array.m_data.resize(m_indexed_array.m_data.size() + 2);
index = Memory.Read16(m_indexed_array.m_addr + i * 2); index = Memory.Read16(m_indexed_array.m_addr + i * 2);
//ConLog.Warning("index 2: %d", index); //LOGF_WARNING(RSX, "index 2: %d", index);
*(u16*)&m_indexed_array.m_data[pos] = index; *(u16*)&m_indexed_array.m_data[pos] = index;
} }
break; break;
@ -819,7 +819,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
{ {
const u32 a0 = ARGS(0); const u32 a0 = ARGS(0);
//ConLog.Warning("NV4097_SET_BEGIN_END: %x", a0); //LOGF_WARNING(RSX, "NV4097_SET_BEGIN_END: %x", a0);
m_read_buffer = false; m_read_buffer = false;
@ -850,7 +850,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
{ {
if(!m_cur_shader_prog) if(!m_cur_shader_prog)
{ {
ConLog.Error("NV4097_SET_SHADER_CONTROL: m_cur_shader_prog == NULL"); LOGF_ERROR(RSX, "NV4097_SET_SHADER_CONTROL: m_cur_shader_prog == NULL");
break; break;
} }
@ -877,7 +877,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
// Transform // Transform
case NV4097_SET_TRANSFORM_PROGRAM_LOAD: case NV4097_SET_TRANSFORM_PROGRAM_LOAD:
{ {
//ConLog.Warning("NV4097_SET_TRANSFORM_PROGRAM_LOAD: prog = %d", ARGS(0)); //LOGF_WARNING(RSX, "NV4097_SET_TRANSFORM_PROGRAM_LOAD: prog = %d", ARGS(0));
m_cur_vertex_prog = &m_vertex_progs[ARGS(0)]; m_cur_vertex_prog = &m_vertex_progs[ARGS(0)];
m_cur_vertex_prog->data.clear(); m_cur_vertex_prog->data.clear();
@ -886,7 +886,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
{ {
const u32 start = ARGS(1); const u32 start = ARGS(1);
if(start) if(start)
ConLog.Warning("NV4097_SET_TRANSFORM_PROGRAM_LOAD: start = %d", start); LOGF_WARNING(RSX, "NV4097_SET_TRANSFORM_PROGRAM_LOAD: start = %d", start);
} }
} }
break; break;
@ -894,17 +894,17 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV4097_SET_TRANSFORM_PROGRAM_START: case NV4097_SET_TRANSFORM_PROGRAM_START:
{ {
if (ARGS(0)) if (ARGS(0))
ConLog.Warning("NV4097_SET_TRANSFORM_PROGRAM_START: 0x%x", ARGS(0)); LOGF_WARNING(RSX, "NV4097_SET_TRANSFORM_PROGRAM_START: 0x%x", ARGS(0));
} }
break; break;
case_32(NV4097_SET_TRANSFORM_PROGRAM, 4): case_32(NV4097_SET_TRANSFORM_PROGRAM, 4):
{ {
//ConLog.Warning("NV4097_SET_TRANSFORM_PROGRAM[%d](%d)", index, count); //LOGF_WARNING(RSX, "NV4097_SET_TRANSFORM_PROGRAM[%d](%d)", index, count);
if(!m_cur_vertex_prog) if(!m_cur_vertex_prog)
{ {
ConLog.Warning("NV4097_SET_TRANSFORM_PROGRAM: m_cur_vertex_prog == NULL"); LOGF_WARNING(RSX, "NV4097_SET_TRANSFORM_PROGRAM: m_cur_vertex_prog == NULL");
break; break;
} }
@ -916,7 +916,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
if(!m_cur_vertex_prog) if(!m_cur_vertex_prog)
{ {
ConLog.Warning("NV4097_SET_TRANSFORM_TIMEOUT: m_cur_vertex_prog == NULL"); LOGF_WARNING(RSX, "NV4097_SET_TRANSFORM_TIMEOUT: m_cur_vertex_prog == NULL");
break; break;
} }
@ -950,28 +950,28 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV4097_INVALIDATE_L2: case NV4097_INVALIDATE_L2:
{ {
if (ARGS(0)) if (ARGS(0))
ConLog.Warning("NV4097_INVALIDATE_L2: %x", ARGS(0)); LOGF_WARNING(RSX, "NV4097_INVALIDATE_L2: %x", ARGS(0));
} }
break; break;
case NV4097_INVALIDATE_VERTEX_CACHE_FILE: case NV4097_INVALIDATE_VERTEX_CACHE_FILE:
{ {
if (ARGS(0)) if (ARGS(0))
ConLog.Warning("NV4097_INVALIDATE_VERTEX_CACHE_FILE: %x", ARGS(0)); LOGF_WARNING(RSX, "NV4097_INVALIDATE_VERTEX_CACHE_FILE: %x", ARGS(0));
} }
break; break;
case NV4097_INVALIDATE_VERTEX_FILE: case NV4097_INVALIDATE_VERTEX_FILE:
{ {
if (ARGS(0)) if (ARGS(0))
ConLog.Warning("NV4097_INVALIDATE_VERTEX_FILE: %x", ARGS(0)); LOGF_WARNING(RSX, "NV4097_INVALIDATE_VERTEX_FILE: %x", ARGS(0));
} }
break; break;
case NV4097_INVALIDATE_ZCULL: case NV4097_INVALIDATE_ZCULL:
{ {
if (ARGS(0)) if (ARGS(0))
ConLog.Warning("NV4097_INVALIDATE_ZCULL: %x", ARGS(0)); LOGF_WARNING(RSX, "NV4097_INVALIDATE_ZCULL: %x", ARGS(0));
} }
break; break;
@ -1158,7 +1158,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV4097_SET_POINT_PARAMS_ENABLE: case NV4097_SET_POINT_PARAMS_ENABLE:
{ {
if (ARGS(0)) if (ARGS(0))
ConLog.Error("NV4097_SET_POINT_PARAMS_ENABLE"); LOG_ERROR(RSX, "NV4097_SET_POINT_PARAMS_ENABLE");
} }
break; break;
@ -1235,7 +1235,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV406E_SEMAPHORE_ACQUIRE: case NV406E_SEMAPHORE_ACQUIRE:
{ {
if (ARGS(0)) if (ARGS(0))
ConLog.Warning("NV406E_SEMAPHORE_ACQUIRE: %x", ARGS(0)); LOGF_WARNING(RSX, "NV406E_SEMAPHORE_ACQUIRE: %x", ARGS(0));
} }
break; break;
@ -1347,7 +1347,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
{ {
if (count != 4) if (count != 4)
{ {
ConLog.Error("NV4097_SET_SURFACE_PITCH_C: Bad count (%d)", count); LOGF_WARNING(RSX, "NV4097_SET_SURFACE_PITCH_C: Bad count (%d)", count);
break; break;
} }
@ -1361,7 +1361,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV4097_SET_SURFACE_PITCH_D: case NV4097_SET_SURFACE_PITCH_D:
{ {
if (ARGS(0)) if (ARGS(0))
ConLog.Warning("NV4097_SET_SURFACE_PITCH_D: %x", ARGS(0)); LOGF_WARNING(RSX, "NV4097_SET_SURFACE_PITCH_D: %x", ARGS(0));
} }
break; break;
@ -1401,7 +1401,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV4097_SET_CONTEXT_DMA_COLOR_D: case NV4097_SET_CONTEXT_DMA_COLOR_D:
{ {
if (ARGS(0)) if (ARGS(0))
ConLog.Warning("NV4097_SET_CONTEXT_DMA_COLOR_D: %x", ARGS(0)); LOGF_WARNING(RSX, "NV4097_SET_CONTEXT_DMA_COLOR_D: %x", ARGS(0));
} }
break; break;
@ -1443,7 +1443,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV4097_SET_ANTI_ALIASING_CONTROL: case NV4097_SET_ANTI_ALIASING_CONTROL:
{ {
if (ARGS(0)) if (ARGS(0))
ConLog.Warning("NV4097_SET_ANTI_ALIASING_CONTROL: %x", ARGS(0)); LOGF_WARNING(RSX, "NV4097_SET_ANTI_ALIASING_CONTROL: %x", ARGS(0));
} }
break; break;
@ -1498,7 +1498,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV4097_SET_ZCULL_CONTROL0: case NV4097_SET_ZCULL_CONTROL0:
{ {
if (ARGS(0)) if (ARGS(0))
ConLog.Warning("NV4097_SET_ZCULL_CONTROL0: %x", ARGS(0)); LOGF_WARNING(RSX, "NV4097_SET_ZCULL_CONTROL0: %x", ARGS(0));
//m_set_depth_func = true; //m_set_depth_func = true;
//m_depth_func = ARGS(0) >> 4; //m_depth_func = ARGS(0) >> 4;
@ -1508,7 +1508,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV4097_SET_ZCULL_CONTROL1: case NV4097_SET_ZCULL_CONTROL1:
{ {
if (ARGS(0)) if (ARGS(0))
ConLog.Warning("NV4097_SET_ZCULL_CONTROL1: %x", ARGS(0)); LOGF_WARNING(RSX, "NV4097_SET_ZCULL_CONTROL1: %x", ARGS(0));
//m_set_depth_func = true; //m_set_depth_func = true;
//m_depth_func = ARGS(0) >> 4; //m_depth_func = ARGS(0) >> 4;
@ -1531,12 +1531,12 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case CELL_GCM_ZCULL_STATS2: case CELL_GCM_ZCULL_STATS2:
case CELL_GCM_ZCULL_STATS3: case CELL_GCM_ZCULL_STATS3:
value = 0; value = 0;
ConLog.Warning("NV4097_GET_REPORT: Unimplemented type %d", type); LOGF_WARNING(RSX, "NV4097_GET_REPORT: Unimplemented type %d", type);
break; break;
default: default:
value = 0; value = 0;
ConLog.Error("NV4097_GET_REPORT: Bad type %d", type); LOGF_WARNING(RSX, "NV4097_GET_REPORT: Bad type %d", type);
break; break;
} }
@ -1586,7 +1586,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV4097_SET_ZMIN_MAX_CONTROL: case NV4097_SET_ZMIN_MAX_CONTROL:
{ {
if (ARGS(0)) if (ARGS(0))
ConLog.Warning("NV4097_SET_ZMIN_MAX_CONTROL: %x", ARGS(0)); LOGF_WARNING(RSX, "NV4097_SET_ZMIN_MAX_CONTROL: %x", ARGS(0));
} }
break; break;
@ -1594,28 +1594,28 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
case NV4097_SET_WINDOW_OFFSET: case NV4097_SET_WINDOW_OFFSET:
{ {
if (ARGS(0)) if (ARGS(0))
ConLog.Warning("NV4097_SET_WINDOW_OFFSET: %x", ARGS(0)); LOGF_WARNING(RSX, "NV4097_SET_WINDOW_OFFSET: %x", ARGS(0));
} }
break; break;
case NV4097_SET_WINDOW_CLIP_TYPE: case NV4097_SET_WINDOW_CLIP_TYPE:
{ {
if (ARGS(0)) if (ARGS(0))
ConLog.Warning("NV4097_SET_WINDOW_CLIP_TYPE: %x", ARGS(0)); LOGF_WARNING(RSX, "NV4097_SET_WINDOW_CLIP_TYPE: %x", ARGS(0));
} }
break; break;
case NV4097_SET_WINDOW_CLIP_HORIZONTAL: case NV4097_SET_WINDOW_CLIP_HORIZONTAL:
{ {
if (ARGS(0)) if (ARGS(0))
ConLog.Warning("NV4097_SET_WINDOW_CLIP_HORIZONTAL: %x", ARGS(0)); LOGF_WARNING(RSX, "NV4097_SET_WINDOW_CLIP_HORIZONTAL: %x", ARGS(0));
} }
break; break;
case NV4097_SET_WINDOW_CLIP_VERTICAL: case NV4097_SET_WINDOW_CLIP_VERTICAL:
{ {
if (ARGS(0)) if (ARGS(0))
ConLog.Warning("NV4097_SET_WINDOW_CLIP_VERTICAL: %x", ARGS(0)); LOGF_WARNING(RSX, "NV4097_SET_WINDOW_CLIP_VERTICAL: %x", ARGS(0));
} }
break; break;
@ -1638,7 +1638,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
} }
else else
{ {
ConLog.Warning("NV0039_SET_CONTEXT_DMA_BUFFER_IN: TODO: srcContext=0x%x, dstContext=0x%x", srcContext, dstContext); LOGF_WARNING(RSX, "NV0039_SET_CONTEXT_DMA_BUFFER_IN: TODO: srcContext=0x%x, dstContext=0x%x", srcContext, dstContext);
} }
} }
break; break;
@ -1662,7 +1662,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
} }
else else
{ {
ConLog.Warning("NV0039_OFFSET_IN: TODO: offset(in=0x%x, out=0x%x), pitch(in=0x%x, out=0x%x), line(len=0x%x, cnt=0x%x), fmt(in=0x%x, out=0x%x), notify=0x%x", LOGF_WARNING(RSX, "NV0039_OFFSET_IN: TODO: offset(in=0x%x, out=0x%x), pitch(in=0x%x, out=0x%x), line(len=0x%x, cnt=0x%x), fmt(in=0x%x, out=0x%x), notify=0x%x",
inOffset, outOffset, inPitch, outPitch, lineLength, lineCount, inFormat, outFormat, notify); inOffset, outOffset, inPitch, outPitch, lineLength, lineCount, inFormat, outFormat, notify);
} }
} }
@ -1677,7 +1677,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
} }
else else
{ {
ConLog.Warning("NV0039_OFFSET_OUT: TODO: offset=0x%x", offset); LOGF_WARNING(RSX, "NV0039_OFFSET_OUT: TODO: offset=0x%x", offset);
} }
} }
break; break;
@ -1723,10 +1723,10 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
if(count >= 5) if(count >= 5)
{ {
ConLog.Warning("NV308A_COLOR: count = %d", count); LOGF_WARNING(RSX, "NV308A_COLOR: count = %d", count);
} }
//ConLog.Warning("NV308A_COLOR: [%d]: %f, %f, %f, %f", c.id, c.x, c.y, c.z, c.w); //LOGF_WARNING(RSX, "NV308A_COLOR: [%d]: %f, %f, %f, %f", c.id, c.x, c.y, c.z, c.w);
m_fragment_constants.push_back(c); m_fragment_constants.push_back(c);
} }
break; break;
@ -1810,7 +1810,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
{ {
if (ARGS(0) != CELL_GCM_CONTEXT_SURFACE2D) if (ARGS(0) != CELL_GCM_CONTEXT_SURFACE2D)
{ {
ConLog.Warning("NV3089_SET_CONTEXT_SURFACE: Unsupported surface (0x%x)", ARGS(0)); LOGF_WARNING(RSX, "NV3089_SET_CONTEXT_SURFACE: Unsupported surface (0x%x)", ARGS(0));
} }
} }
break; break;
@ -1821,7 +1821,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
log += "("; log += "(";
for(u32 i=0; i<count; ++i) log += (i ? ", " : "") + fmt::Format("0x%x", ARGS(i)); for(u32 i=0; i<count; ++i) log += (i ? ", " : "") + fmt::Format("0x%x", ARGS(i));
log += ")"; log += ")";
ConLog.Error("TODO: " + log); LOG_WARNING(RSX, "TODO: " + log);
//Emu.Pause(); //Emu.Pause();
} }
break; break;
@ -1866,7 +1866,7 @@ void RSXThread::End()
void RSXThread::Task() void RSXThread::Task()
{ {
u8 inc; u8 inc;
ConLog.Write("RSX thread started"); LOGF_NOTICE(RSX, "RSX thread started");
OnInitThread(); OnInitThread();
@ -1874,7 +1874,7 @@ void RSXThread::Task()
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
ConLog.Warning("RSX thread aborted"); LOGF_WARNING(RSX, "RSX thread aborted");
return; return;
} }
std::lock_guard<std::mutex> lock(m_cs_main); std::lock_guard<std::mutex> lock(m_cs_main);
@ -1912,7 +1912,7 @@ void RSXThread::Task()
if(cmd & CELL_GCM_METHOD_FLAG_JUMP) if(cmd & CELL_GCM_METHOD_FLAG_JUMP)
{ {
u32 addr = cmd & ~(CELL_GCM_METHOD_FLAG_JUMP | CELL_GCM_METHOD_FLAG_NON_INCREMENT); u32 addr = cmd & ~(CELL_GCM_METHOD_FLAG_JUMP | CELL_GCM_METHOD_FLAG_NON_INCREMENT);
//ConLog.Warning("rsx jump(0x%x) #addr=0x%x, cmd=0x%x, get=0x%x, put=0x%x", addr, m_ioAddress + get, cmd, get, put); //LOGF_WARNING(RSX, "rsx jump(0x%x) #addr=0x%x, cmd=0x%x, get=0x%x, put=0x%x", addr, m_ioAddress + get, cmd, get, put);
m_ctrl->get = addr; m_ctrl->get = addr;
continue; continue;
} }
@ -1921,22 +1921,22 @@ void RSXThread::Task()
m_call_stack.push(get + 4); m_call_stack.push(get + 4);
u32 offs = cmd & ~CELL_GCM_METHOD_FLAG_CALL; u32 offs = cmd & ~CELL_GCM_METHOD_FLAG_CALL;
u32 addr = Memory.RSXIOMem.GetStartAddr() + offs; u32 addr = Memory.RSXIOMem.GetStartAddr() + offs;
//ConLog.Warning("rsx call(0x%x) #0x%x - 0x%x - 0x%x", offs, addr, cmd, get); //LOGF_WARNING(RSX, "rsx call(0x%x) #0x%x - 0x%x - 0x%x", offs, addr, cmd, get);
m_ctrl->get = offs; m_ctrl->get = offs;
continue; continue;
} }
if(cmd == CELL_GCM_METHOD_FLAG_RETURN) if(cmd == CELL_GCM_METHOD_FLAG_RETURN)
{ {
//ConLog.Warning("rsx return!"); //LOGF_WARNING(RSX, "rsx return!");
u32 get = m_call_stack.top(); u32 get = m_call_stack.top();
m_call_stack.pop(); m_call_stack.pop();
//ConLog.Warning("rsx return(0x%x)", get); //LOGF_WARNING(RSX, "rsx return(0x%x)", get);
m_ctrl->get = get; m_ctrl->get = get;
continue; continue;
} }
if(cmd & CELL_GCM_METHOD_FLAG_NON_INCREMENT) if(cmd & CELL_GCM_METHOD_FLAG_NON_INCREMENT)
{ {
//ConLog.Warning("non increment cmd! 0x%x", cmd); //LOGF_WARNING(RSX, "non increment cmd! 0x%x", cmd);
inc=0; inc=0;
} }
@ -1961,7 +1961,7 @@ void RSXThread::Task()
//memset(Memory.GetMemFromAddr(p.m_ioAddress + get), 0, (count + 1) * 4); //memset(Memory.GetMemFromAddr(p.m_ioAddress + get), 0, (count + 1) * 4);
} }
ConLog.Write("RSX thread ended"); LOGF_NOTICE(RSX, "RSX thread ended");
OnExitThread(); OnExitThread();
} }

2
rpcs3/Emu/HDD/HDD.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "HDD.h" #include "HDD.h"
vfsDeviceHDD::vfsDeviceHDD(const std::string& hdd_path) : m_hdd_path(hdd_path) vfsDeviceHDD::vfsDeviceHDD(const std::string& hdd_path) : m_hdd_path(hdd_path)

10
rpcs3/Emu/HDD/HDD.h
View File

@ -445,7 +445,7 @@ public:
m_cur_dir_block = m_hdd_info.next_block; m_cur_dir_block = m_hdd_info.next_block;
if(!m_hdd_info.block_size) if(!m_hdd_info.block_size)
{ {
ConLog.Error("Bad block size!"); LOG_ERROR(HLE, "Bad block size!");
m_hdd_info.block_size = 2048; m_hdd_info.block_size = 2048;
} }
m_hdd_file.Seek(m_cur_dir_block * m_hdd_info.block_size); m_hdd_file.Seek(m_cur_dir_block * m_hdd_info.block_size);
@ -486,7 +486,7 @@ public:
int OpenDir(const std::string& name) int OpenDir(const std::string& name)
{ {
ConLog.Warning("OpenDir(%s)", name.c_str()); LOGF_WARNING(HLE, "OpenDir(%s)", name.c_str());
u64 entry_block; u64 entry_block;
if(!SearchEntry(name, entry_block)) if(!SearchEntry(name, entry_block))
return -1; return -1;
@ -594,7 +594,7 @@ public:
return false; return false;
} }
ConLog.Write("CREATING ENTRY AT 0x%llx", new_block); LOGF_NOTICE(HLE, "CREATING ENTRY AT 0x%llx", new_block);
WriteBlock(new_block, g_used_block); WriteBlock(new_block, g_used_block);
{ {
@ -744,7 +744,7 @@ public:
return false; return false;
} }
ConLog.Write("ENTRY FOUND AT 0x%llx", file_block); LOGF_NOTICE(HLE, "ENTRY FOUND AT 0x%llx", file_block);
m_file.Open(file_block); m_file.Open(file_block);
return vfsFileBase::Open(path, mode); return vfsFileBase::Open(path, mode);
@ -774,7 +774,7 @@ public:
if(entry.type == vfsHDD_Entry_Dir && name != "." && name != "..") if(entry.type == vfsHDD_Entry_Dir && name != "." && name != "..")
{ {
ConLog.Warning("Removing sub folder '%s'", name.c_str()); LOGF_WARNING(HLE, "Removing sub folder '%s'", name.c_str());
RemoveBlocksDir(entry.data_block); RemoveBlocksDir(entry.data_block);
} }
else if(entry.type == vfsHDD_Entry_File) else if(entry.type == vfsHDD_Entry_File)

2
rpcs3/Emu/Io/Keyboard.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "rpcs3/Ini.h" #include "rpcs3/Ini.h"
#include "Keyboard.h" #include "Keyboard.h"
#include "Null/NullKeyboardHandler.h" #include "Null/NullKeyboardHandler.h"

2
rpcs3/Emu/Io/Mouse.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "rpcs3/Ini.h" #include "rpcs3/Ini.h"
#include "Mouse.h" #include "Mouse.h"
#include "Null/NullMouseHandler.h" #include "Null/NullMouseHandler.h"

2
rpcs3/Emu/Io/Pad.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "rpcs3/Ini.h" #include "rpcs3/Ini.h"
#include "Pad.h" #include "Pad.h"
#include "Null/NullPadHandler.h" #include "Null/NullPadHandler.h"

4
rpcs3/Emu/Io/XInput/XInputPadHandler.cpp
View File

@ -1,7 +1,7 @@
#include "stdafx.h" #include "stdafx.h"
#if defined (_WIN32) #if defined (_WIN32)
#include <algorithm> #include <algorithm>
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "XInputPadHandler.h" #include "XInputPadHandler.h"
#include <cstring> #include <cstring>
@ -113,7 +113,7 @@ void XInputPadHandler::Close()
{ {
active = false; active = false;
if (WaitForSingleObject(thread, THREAD_TIMEOUT) != WAIT_OBJECT_0) if (WaitForSingleObject(thread, THREAD_TIMEOUT) != WAIT_OBJECT_0)
ConLog.Error("XInput thread could not stop within %d milliseconds", THREAD_TIMEOUT); LOGF_ERROR(HLE, "XInput thread could not stop within %d milliseconds", THREAD_TIMEOUT);
thread = nullptr; thread = nullptr;
} }

6
rpcs3/Emu/Memory/DynamicMemoryBlockBase.h
View File

@ -212,10 +212,10 @@ bool DynamicMemoryBlockBase<PT>::Free(u64 addr)
} }
} }
ConLog.Error("DynamicMemoryBlock::Free(addr=0x%llx): failed", addr); LOGF_ERROR(MEMORY, "DynamicMemoryBlock::Free(addr=0x%llx): failed", addr);
for (u32 i = 0; i < m_allocated.size(); i++) for (u32 i = 0; i < m_allocated.size(); i++)
{ {
ConLog.Write("*** Memory Block: addr = 0x%llx, size = 0x%x", m_allocated[i].addr, m_allocated[i].size); LOGF_NOTICE(MEMORY, "*** Memory Block: addr = 0x%llx, size = 0x%x", m_allocated[i].addr, m_allocated[i].size);
} }
return false; return false;
} }
@ -233,7 +233,7 @@ u8* DynamicMemoryBlockBase<PT>::GetMem(u64 addr) const // lock-free, addr is fix
} }
} }
ConLog.Error("GetMem(%llx) from not allocated address.", addr); LOGF_ERROR(MEMORY, "GetMem(%llx) from not allocated address.", addr);
assert(0); assert(0);
return nullptr; return nullptr;
} }

22
rpcs3/Emu/Memory/Memory.cpp
View File

@ -1,7 +1,7 @@
#include "stdafx.h" #include "stdafx.h"
#include <atomic> #include <atomic>
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Memory.h" #include "Memory.h"
#include "MemoryBlock.h" #include "MemoryBlock.h"
#include "Emu/System.h" #include "Emu/System.h"
@ -331,7 +331,7 @@ bool MemoryBlockLE::Write128(const u64 addr, const u128 value)
//NullMemoryBlock //NullMemoryBlock
bool NullMemoryBlock::Read8(const u64 addr, u8* ) bool NullMemoryBlock::Read8(const u64 addr, u8* )
{ {
ConLog.Error("Read8 from null block: [%08llx]", addr); LOGF_ERROR(MEMORY, "Read8 from null block: [%08llx]", addr);
if (!Ini.CPUIgnoreRWErrors.GetValue()) if (!Ini.CPUIgnoreRWErrors.GetValue())
Emu.Pause(); Emu.Pause();
return false; return false;
@ -339,7 +339,7 @@ bool NullMemoryBlock::Read8(const u64 addr, u8* )
bool NullMemoryBlock::Read16(const u64 addr, u16* ) bool NullMemoryBlock::Read16(const u64 addr, u16* )
{ {
ConLog.Error("Read16 from null block: [%08llx]", addr); LOGF_ERROR(MEMORY, "Read16 from null block: [%08llx]", addr);
if (!Ini.CPUIgnoreRWErrors.GetValue()) if (!Ini.CPUIgnoreRWErrors.GetValue())
Emu.Pause(); Emu.Pause();
return false; return false;
@ -347,7 +347,7 @@ bool NullMemoryBlock::Read16(const u64 addr, u16* )
bool NullMemoryBlock::Read32(const u64 addr, u32* ) bool NullMemoryBlock::Read32(const u64 addr, u32* )
{ {
ConLog.Error("Read32 from null block: [%08llx]", addr); LOGF_ERROR(MEMORY, "Read32 from null block: [%08llx]", addr);
if (!Ini.CPUIgnoreRWErrors.GetValue()) if (!Ini.CPUIgnoreRWErrors.GetValue())
Emu.Pause(); Emu.Pause();
return false; return false;
@ -355,7 +355,7 @@ bool NullMemoryBlock::Read32(const u64 addr, u32* )
bool NullMemoryBlock::Read64(const u64 addr, u64* ) bool NullMemoryBlock::Read64(const u64 addr, u64* )
{ {
ConLog.Error("Read64 from null block: [%08llx]", addr); LOGF_ERROR(MEMORY, "Read64 from null block: [%08llx]", addr);
if (!Ini.CPUIgnoreRWErrors.GetValue()) if (!Ini.CPUIgnoreRWErrors.GetValue())
Emu.Pause(); Emu.Pause();
return false; return false;
@ -363,7 +363,7 @@ bool NullMemoryBlock::Read64(const u64 addr, u64* )
bool NullMemoryBlock::Read128(const u64 addr, u128* ) bool NullMemoryBlock::Read128(const u64 addr, u128* )
{ {
ConLog.Error("Read128 from null block: [%08llx]", addr); LOGF_ERROR(MEMORY, "Read128 from null block: [%08llx]", addr);
if (!Ini.CPUIgnoreRWErrors.GetValue()) if (!Ini.CPUIgnoreRWErrors.GetValue())
Emu.Pause(); Emu.Pause();
return false; return false;
@ -371,7 +371,7 @@ bool NullMemoryBlock::Read128(const u64 addr, u128* )
bool NullMemoryBlock::Write8(const u64 addr, const u8 value) bool NullMemoryBlock::Write8(const u64 addr, const u8 value)
{ {
ConLog.Error("Write8 to null block: [%08llx]: %x", addr, value); LOGF_ERROR(MEMORY, "Write8 to null block: [%08llx]: %x", addr, value);
if (!Ini.CPUIgnoreRWErrors.GetValue()) if (!Ini.CPUIgnoreRWErrors.GetValue())
Emu.Pause(); Emu.Pause();
return false; return false;
@ -379,7 +379,7 @@ bool NullMemoryBlock::Write8(const u64 addr, const u8 value)
bool NullMemoryBlock::Write16(const u64 addr, const u16 value) bool NullMemoryBlock::Write16(const u64 addr, const u16 value)
{ {
ConLog.Error("Write16 to null block: [%08llx]: %x", addr, value); LOGF_ERROR(MEMORY, "Write16 to null block: [%08llx]: %x", addr, value);
if (!Ini.CPUIgnoreRWErrors.GetValue()) if (!Ini.CPUIgnoreRWErrors.GetValue())
Emu.Pause(); Emu.Pause();
return false; return false;
@ -387,7 +387,7 @@ bool NullMemoryBlock::Write16(const u64 addr, const u16 value)
bool NullMemoryBlock::Write32(const u64 addr, const u32 value) bool NullMemoryBlock::Write32(const u64 addr, const u32 value)
{ {
ConLog.Error("Write32 to null block: [%08llx]: %x", addr, value); LOGF_ERROR(MEMORY, "Write32 to null block: [%08llx]: %x", addr, value);
if (!Ini.CPUIgnoreRWErrors.GetValue()) if (!Ini.CPUIgnoreRWErrors.GetValue())
Emu.Pause(); Emu.Pause();
return false; return false;
@ -395,7 +395,7 @@ bool NullMemoryBlock::Write32(const u64 addr, const u32 value)
bool NullMemoryBlock::Write64(const u64 addr, const u64 value) bool NullMemoryBlock::Write64(const u64 addr, const u64 value)
{ {
ConLog.Error("Write64 to null block: [%08llx]: %llx", addr, value); LOGF_ERROR(MEMORY, "Write64 to null block: [%08llx]: %llx", addr, value);
if (!Ini.CPUIgnoreRWErrors.GetValue()) if (!Ini.CPUIgnoreRWErrors.GetValue())
Emu.Pause(); Emu.Pause();
return false; return false;
@ -403,7 +403,7 @@ bool NullMemoryBlock::Write64(const u64 addr, const u64 value)
bool NullMemoryBlock::Write128(const u64 addr, const u128 value) bool NullMemoryBlock::Write128(const u64 addr, const u128 value)
{ {
ConLog.Error("Write128 to null block: [%08llx]: %llx_%llx", addr, value.hi, value.lo); LOGF_ERROR(MEMORY, "Write128 to null block: [%08llx]: %llx_%llx", addr, value.hi, value.lo);
if (!Ini.CPUIgnoreRWErrors.GetValue()) if (!Ini.CPUIgnoreRWErrors.GetValue())
Emu.Pause(); Emu.Pause();
return false; return false;

18
rpcs3/Emu/Memory/Memory.h
View File

@ -211,7 +211,7 @@ public:
if(m_inited) return; if(m_inited) return;
m_inited = true; m_inited = true;
ConLog.Write("Initing memory..."); LOG_NOTICE(MEMORY, "Initing memory...");
switch(type) switch(type)
{ {
@ -240,7 +240,7 @@ public:
break; break;
} }
ConLog.Write("Memory initialized."); LOG_NOTICE(MEMORY, "Memory initialized.");
} }
bool IsGoodAddr(const u64 addr) bool IsGoodAddr(const u64 addr)
@ -271,7 +271,7 @@ public:
if(!m_inited) return; if(!m_inited) return;
m_inited = false; m_inited = false;
ConLog.Write("Closing memory..."); LOG_NOTICE(MEMORY, "Closing memory...");
for (auto block : MemoryBlocks) for (auto block : MemoryBlocks)
{ {
@ -405,7 +405,7 @@ public:
if(mem.IsNULL()) if(mem.IsNULL())
{ {
ConLog.Error("ReadLeft[%d] from null block (0x%llx)", size, addr); LOGF_ERROR(MEMORY, "ReadLeft[%d] from null block (0x%llx)", size, addr);
return; return;
} }
@ -418,7 +418,7 @@ public:
if(mem.IsNULL()) if(mem.IsNULL())
{ {
ConLog.Error("WriteLeft[%d] to null block (0x%llx)", size, addr); LOGF_ERROR(MEMORY, "WriteLeft[%d] to null block (0x%llx)", size, addr);
return; return;
} }
@ -431,7 +431,7 @@ public:
if(mem.IsNULL()) if(mem.IsNULL())
{ {
ConLog.Error("ReadRight[%d] from null block (0x%llx)", size, addr); LOGF_ERROR(MEMORY, "ReadRight[%d] from null block (0x%llx)", size, addr);
return; return;
} }
@ -444,7 +444,7 @@ public:
if(mem.IsNULL()) if(mem.IsNULL())
{ {
ConLog.Error("WriteRight[%d] to null block (0x%llx)", size, addr); LOGF_ERROR(MEMORY, "WriteRight[%d] to null block (0x%llx)", size, addr);
return; return;
} }
@ -477,7 +477,7 @@ public:
{ {
if(!IsGoodAddr(addr, str.length())) if(!IsGoodAddr(addr, str.length()))
{ {
ConLog.Error("Memory::WriteString error: bad address (0x%llx)", addr); LOGF_ERROR(MEMORY,"Memory::WriteString error: bad address (0x%llx)", addr);
return; return;
} }
@ -527,7 +527,7 @@ public:
} }
MemoryBlocks.push_back((new MemoryMirror())->SetRange(GetMemFromAddr(src_addr), dst_addr, size)); MemoryBlocks.push_back((new MemoryMirror())->SetRange(GetMemFromAddr(src_addr), dst_addr, size));
ConLog.Warning("memory mapped 0x%llx to 0x%llx size=0x%x", src_addr, dst_addr, size); LOGF_WARNING(MEMORY, "memory mapped 0x%llx to 0x%llx size=0x%x", src_addr, dst_addr, size);
return true; return true;
} }

2
rpcs3/Emu/Memory/MemoryBlock.h
View File

@ -28,7 +28,7 @@ struct MemBlockInfo : public MemInfo
{ {
if(!mem) if(!mem)
{ {
ConLog.Error("Not enough free memory."); LOG_ERROR(MEMORY, "Not enough free memory.");
assert(0); assert(0);
} }
memset(mem, 0, size); memset(mem, 0, size);

8
rpcs3/Emu/SysCalls/Callback.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Callback.h" #include "Callback.h"
@ -66,7 +66,7 @@ again:
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
ConLog.Warning("Callback::Branch() aborted"); LOG_WARNING(HLE, "Callback::Branch() aborted");
return; return;
} }
Sleep(1); Sleep(1);
@ -80,7 +80,7 @@ again:
} }
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
ConLog.Warning("Callback::Branch() aborted"); LOG_WARNING(HLE, "Callback::Branch() aborted");
return; return;
} }
@ -109,7 +109,7 @@ again:
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
ConLog.Warning("Callback::Branch(true) aborted (end)"); LOG_WARNING(HLE, "Callback::Branch(true) aborted (end)");
return; return;
} }
Sleep(1); Sleep(1);

6
rpcs3/Emu/SysCalls/FuncList.cpp
View File

@ -1,10 +1,10 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "SysCalls.h" #include "SysCalls.h"
#define FUNC_LOG_ERROR(x) ConLog.Error(x); return 0 #define FUNC_LOG_ERROR(x) LOG_ERROR(HLE, x); return 0
std::string SysCalls::GetHLEFuncName(const u32 fid) std::string SysCalls::GetHLEFuncName(const u32 fid)
{ {
switch(fid) switch(fid)
@ -3846,4 +3846,4 @@ std::string SysCalls::GetHLEFuncName(const u32 fid)
} }
return fmt::Format("Unknown func id: 0x%08x", fid); return fmt::Format("Unknown func id: 0x%08x", fid);
} }

14
rpcs3/Emu/SysCalls/Modules.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"
@ -160,7 +160,7 @@ void Module::Log(const u32 id, std::string fmt, ...)
{ {
va_list list; va_list list;
va_start(list, fmt); va_start(list, fmt);
ConLog.Write(GetName() + fmt::Format("[%d]: ", id) + fmt::FormatV(fmt, list)); LOG_NOTICE(HLE, GetName() + fmt::Format("[%d]: ", id) + fmt::FormatV(fmt, list));
va_end(list); va_end(list);
} }
} }
@ -171,7 +171,7 @@ void Module::Log(std::string fmt, ...)
{ {
va_list list; va_list list;
va_start(list, fmt); va_start(list, fmt);
ConLog.Write(GetName() + ": " + fmt::FormatV(fmt, list)); LOG_NOTICE(HLE, GetName() + ": " + fmt::FormatV(fmt, list));
va_end(list); va_end(list);
} }
} }
@ -180,7 +180,7 @@ void Module::Warning(const u32 id, std::string fmt, ...)
{ {
va_list list; va_list list;
va_start(list, fmt); va_start(list, fmt);
ConLog.Warning(GetName() + fmt::Format("[%d] warning: ", id) + fmt::FormatV(fmt, list)); LOG_WARNING(HLE, GetName() + fmt::Format("[%d] warning: ", id) + fmt::FormatV(fmt, list));
va_end(list); va_end(list);
} }
@ -188,7 +188,7 @@ void Module::Warning(std::string fmt, ...)
{ {
va_list list; va_list list;
va_start(list, fmt); va_start(list, fmt);
ConLog.Warning(GetName() + " warning: " + fmt::FormatV(fmt, list)); LOG_WARNING(HLE, GetName() + " warning: " + fmt::FormatV(fmt, list));
va_end(list); va_end(list);
} }
@ -196,7 +196,7 @@ void Module::Error(const u32 id, std::string fmt, ...)
{ {
va_list list; va_list list;
va_start(list, fmt); va_start(list, fmt);
ConLog.Error(GetName() + fmt::Format("[%d] error: ", id) + fmt::FormatV(fmt, list)); LOG_ERROR(HLE, GetName() + fmt::Format("[%d] error: ", id) + fmt::FormatV(fmt, list));
va_end(list); va_end(list);
} }
@ -204,7 +204,7 @@ void Module::Error(std::string fmt, ...)
{ {
va_list list; va_list list;
va_start(list, fmt); va_start(list, fmt);
ConLog.Error(GetName() + " error: " + fmt::FormatV(fmt, list)); LOG_ERROR(HLE, GetName() + " error: " + fmt::FormatV(fmt, list));
va_end(list); va_end(list);
} }

68
rpcs3/Emu/SysCalls/Modules/cellAdec.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"
@ -36,7 +36,7 @@ next:
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
ConLog.Warning("adecRawRead(): aborted"); LOG_WARNING(HLE, "adecRawRead(): aborted");
return 0; return 0;
} }
Sleep(1); Sleep(1);
@ -53,7 +53,7 @@ next:
{ {
if (!Memory.CopyToReal(buf, adec.reader.addr, adec.reader.size)) if (!Memory.CopyToReal(buf, adec.reader.addr, adec.reader.size))
{ {
ConLog.Error("adecRawRead(): data reading failed (reader.size=0x%x)", adec.reader.size); LOGF_ERROR(HLE, "adecRawRead(): data reading failed (reader.size=0x%x)", adec.reader.size);
Emu.Pause(); Emu.Pause();
return 0; return 0;
} }
@ -68,11 +68,11 @@ next:
adec.reader.addr = adec.task.au.addr; adec.reader.addr = adec.task.au.addr;
adec.reader.size = adec.task.au.size; adec.reader.size = adec.task.au.size;
//ConLog.Write("Audio AU: size = 0x%x, pts = 0x%llx", adec.task.au.size, adec.task.au.pts); //LOGF_NOTICE(HLE, "Audio AU: size = 0x%x, pts = 0x%llx", adec.task.au.size, adec.task.au.pts);
} }
break; break;
default: default:
ConLog.Error("adecRawRead(): sequence error (task %d)", adec.job.Peek().type); LOGF_ERROR(HLE, "adecRawRead(): sequence error (task %d)", adec.job.Peek().type);
return -1; return -1;
} }
@ -89,7 +89,7 @@ next:
} }
else if (!Memory.CopyToReal(buf, adec.reader.addr, buf_size)) else if (!Memory.CopyToReal(buf, adec.reader.addr, buf_size))
{ {
ConLog.Error("adecRawRead(): data reading failed (buf_size=0x%x)", buf_size); LOGF_ERROR(HLE, "adecRawRead(): data reading failed (buf_size=0x%x)", buf_size);
Emu.Pause(); Emu.Pause();
return 0; return 0;
} }
@ -111,7 +111,7 @@ int adecRead(void* opaque, u8* buf, int buf_size)
{ {
if (buf_size < (int)adec.reader.rem_size) if (buf_size < (int)adec.reader.rem_size)
{ {
ConLog.Error("adecRead(): too small buf_size (rem_size = %d, buf_size = %d)", adec.reader.rem_size, buf_size); LOGF_ERROR(HLE, "adecRead(): too small buf_size (rem_size = %d, buf_size = %d)", adec.reader.rem_size, buf_size);
Emu.Pause(); Emu.Pause();
return 0; return 0;
} }
@ -131,7 +131,7 @@ int adecRead(void* opaque, u8* buf, int buf_size)
if (adecRawRead(opaque, header, 8) < 8) break; if (adecRawRead(opaque, header, 8) < 8) break;
if (header[0] != 0x0f || header[1] != 0xd0) if (header[0] != 0x0f || header[1] != 0xd0)
{ {
ConLog.Error("adecRead(): 0x0FD0 header not found"); LOGF_ERROR(HLE, "adecRead(): 0x0FD0 header not found");
Emu.Pause(); Emu.Pause();
return -1; return -1;
} }
@ -141,7 +141,7 @@ int adecRead(void* opaque, u8* buf, int buf_size)
OMAHeader oma(1 /* atrac3p id */, header[2], header[3]); OMAHeader oma(1 /* atrac3p id */, header[2], header[3]);
if (buf_size < sizeof(oma) + 8) if (buf_size < sizeof(oma) + 8)
{ {
ConLog.Error("adecRead(): OMAHeader writing failed"); LOGF_ERROR(HLE, "adecRead(): OMAHeader writing failed");
Emu.Pause(); Emu.Pause();
return 0; return 0;
} }
@ -159,7 +159,7 @@ int adecRead(void* opaque, u8* buf, int buf_size)
u32 size = (((header[2] & 0x3) << 8) | header[3]) * 8 + 8; // data to be read before next header u32 size = (((header[2] & 0x3) << 8) | header[3]) * 8 + 8; // data to be read before next header
//ConLog.Write("*** audio block read: size = 0x%x", size); //LOGF_NOTICE(HLE, "*** audio block read: size = 0x%x", size);
if (buf_size < (int)size) if (buf_size < (int)size)
{ {
@ -198,7 +198,7 @@ u32 adecOpen(AudioDecoder* data)
thread t("Audio Decoder[" + std::to_string(adec_id) + "] Thread", [&]() thread t("Audio Decoder[" + std::to_string(adec_id) + "] Thread", [&]()
{ {
ConLog.Write("Audio Decoder thread started"); LOGF_NOTICE(HLE, "Audio Decoder thread started");
AdecTask& task = adec.task; AdecTask& task = adec.task;
@ -231,7 +231,7 @@ u32 adecOpen(AudioDecoder* data)
case adecStartSeq: case adecStartSeq:
{ {
// TODO: reset data // TODO: reset data
ConLog.Warning("adecStartSeq:"); LOGF_WARNING(HLE, "adecStartSeq:");
adec.reader.addr = 0; adec.reader.addr = 0;
adec.reader.size = 0; adec.reader.size = 0;
@ -247,7 +247,7 @@ u32 adecOpen(AudioDecoder* data)
case adecEndSeq: case adecEndSeq:
{ {
// TODO: finalize // TODO: finalize
ConLog.Warning("adecEndSeq:"); LOGF_WARNING(HLE, "adecEndSeq:");
/*Callback cb; /*Callback cb;
cb.SetAddr(adec.cbFunc); cb.SetAddr(adec.cbFunc);
@ -268,7 +268,7 @@ u32 adecOpen(AudioDecoder* data)
adec.reader.addr = task.au.addr; adec.reader.addr = task.au.addr;
adec.reader.size = task.au.size; adec.reader.size = task.au.size;
//ConLog.Write("Audio AU: size = 0x%x, pts = 0x%llx", task.au.size, task.au.pts); //LOGF_NOTICE(HLE, "Audio AU: size = 0x%x, pts = 0x%llx", task.au.size, task.au.pts);
if (adec.just_started) if (adec.just_started)
{ {
@ -317,33 +317,33 @@ u32 adecOpen(AudioDecoder* data)
err = avformat_open_input(&adec.fmt, NULL, av_find_input_format("oma"), NULL); err = avformat_open_input(&adec.fmt, NULL, av_find_input_format("oma"), NULL);
if (err) if (err)
{ {
ConLog.Error("adecDecodeAu: avformat_open_input() failed"); LOGF_ERROR(HLE, "adecDecodeAu: avformat_open_input() failed");
Emu.Pause(); Emu.Pause();
break; break;
} }
AVCodec* codec = avcodec_find_decoder(AV_CODEC_ID_ATRAC3P); // ??? AVCodec* codec = avcodec_find_decoder(AV_CODEC_ID_ATRAC3P); // ???
if (!codec) if (!codec)
{ {
ConLog.Error("adecDecodeAu: avcodec_find_decoder() failed"); LOGF_ERROR(HLE, "adecDecodeAu: avcodec_find_decoder() failed");
Emu.Pause(); Emu.Pause();
break; break;
} }
/*err = avformat_find_stream_info(adec.fmt, NULL); /*err = avformat_find_stream_info(adec.fmt, NULL);
if (err) if (err)
{ {
ConLog.Error("adecDecodeAu: avformat_find_stream_info() failed"); LOGF_ERROR(HLE, "adecDecodeAu: avformat_find_stream_info() failed");
Emu.Pause(); Emu.Pause();
break; break;
} }
if (!adec.fmt->nb_streams) if (!adec.fmt->nb_streams)
{ {
ConLog.Error("adecDecodeAu: no stream found"); LOGF_ERROR(HLE, "adecDecodeAu: no stream found");
Emu.Pause(); Emu.Pause();
break; break;
}*/ }*/
if (!avformat_new_stream(adec.fmt, codec)) if (!avformat_new_stream(adec.fmt, codec))
{ {
ConLog.Error("adecDecodeAu: avformat_new_stream() failed"); LOGF_ERROR(HLE, "adecDecodeAu: avformat_new_stream() failed");
Emu.Pause(); Emu.Pause();
break; break;
} }
@ -358,7 +358,7 @@ u32 adecOpen(AudioDecoder* data)
} }
if (err) if (err)
{ {
ConLog.Error("adecDecodeAu: avcodec_open2() failed"); LOGF_ERROR(HLE, "adecDecodeAu: avcodec_open2() failed");
Emu.Pause(); Emu.Pause();
break; break;
} }
@ -371,7 +371,7 @@ u32 adecOpen(AudioDecoder* data)
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
ConLog.Warning("adecDecodeAu: aborted"); LOGF_WARNING(HLE, "adecDecodeAu: aborted");
return; return;
} }
@ -420,7 +420,7 @@ u32 adecOpen(AudioDecoder* data)
if (!frame.data) if (!frame.data)
{ {
ConLog.Error("adecDecodeAu: av_frame_alloc() failed"); LOGF_ERROR(HLE, "adecDecodeAu: av_frame_alloc() failed");
Emu.Pause(); Emu.Pause();
break; break;
} }
@ -433,7 +433,7 @@ u32 adecOpen(AudioDecoder* data)
{ {
if (!last_frame && decode < 0) if (!last_frame && decode < 0)
{ {
ConLog.Error("adecDecodeAu: AU decoding error(0x%x)", decode); LOGF_ERROR(HLE, "adecDecodeAu: AU decoding error(0x%x)", decode);
} }
if (!got_frame && adec.reader.size == 0) break; if (!got_frame && adec.reader.size == 0) break;
} }
@ -460,18 +460,18 @@ u32 adecOpen(AudioDecoder* data)
if (frame.data->format != AV_SAMPLE_FMT_FLTP) if (frame.data->format != AV_SAMPLE_FMT_FLTP)
{ {
ConLog.Error("adecDecodeaAu: unsupported frame format(%d)", frame.data->format); LOGF_ERROR(HLE, "adecDecodeaAu: unsupported frame format(%d)", frame.data->format);
Emu.Pause(); Emu.Pause();
break; break;
} }
if (frame.data->channels != 2) if (frame.data->channels != 2)
{ {
ConLog.Error("adecDecodeAu: unsupported channel count (%d)", frame.data->channels); LOGF_ERROR(HLE, "adecDecodeAu: unsupported channel count (%d)", frame.data->channels);
Emu.Pause(); Emu.Pause();
break; break;
} }
//ConLog.Write("got audio frame (pts=0x%llx, nb_samples=%d, ch=%d, sample_rate=%d, nbps=%d)", //LOGF_NOTICE(HLE, "got audio frame (pts=0x%llx, nb_samples=%d, ch=%d, sample_rate=%d, nbps=%d)",
//frame.pts, frame.data->nb_samples, frame.data->channels, frame.data->sample_rate, //frame.pts, frame.data->nb_samples, frame.data->channels, frame.data->sample_rate,
//av_get_bytes_per_sample((AVSampleFormat)frame.data->format)); //av_get_bytes_per_sample((AVSampleFormat)frame.data->format));
@ -497,16 +497,16 @@ u32 adecOpen(AudioDecoder* data)
case adecClose: case adecClose:
{ {
adec.is_finished = true; adec.is_finished = true;
ConLog.Write("Audio Decoder thread ended"); LOGF_NOTICE(HLE, "Audio Decoder thread ended");
return; return;
} }
default: default:
ConLog.Error("Audio Decoder thread error: unknown task(%d)", task.type); LOGF_ERROR(HLE, "Audio Decoder thread error: unknown task(%d)", task.type);
} }
} }
adec.is_finished = true; adec.is_finished = true;
ConLog.Warning("Audio Decoder thread aborted"); LOGF_WARNING(HLE, "Audio Decoder thread aborted");
}); });
t.detach(); t.detach();
@ -518,8 +518,8 @@ bool adecCheckType(AudioCodecType type)
{ {
switch (type) switch (type)
{ {
case CELL_ADEC_TYPE_ATRACX: ConLog.Write("*** (?) type: ATRAC3plus"); break; case CELL_ADEC_TYPE_ATRACX: LOGF_NOTICE(HLE, "*** (?) type: ATRAC3plus"); break;
case CELL_ADEC_TYPE_ATRACX_2CH: ConLog.Write("*** type: ATRAC3plus 2ch"); break; case CELL_ADEC_TYPE_ATRACX_2CH: LOGF_NOTICE(HLE, "*** type: ATRAC3plus 2ch"); break;
case CELL_ADEC_TYPE_ATRACX_6CH: case CELL_ADEC_TYPE_ATRACX_6CH:
case CELL_ADEC_TYPE_ATRACX_8CH: case CELL_ADEC_TYPE_ATRACX_8CH:
@ -609,7 +609,7 @@ int cellAdecClose(u32 handle)
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
ConLog.Warning("cellAdecClose(%d) aborted", handle); LOGF_WARNING(HLE, "cellAdecClose(%d) aborted", handle);
break; break;
} }
Sleep(1); Sleep(1);
@ -732,7 +732,7 @@ int cellAdecGetPcm(u32 handle, u32 outBuffer_addr)
if (!swr) if (!swr)
{ {
ConLog.Error("cellAdecGetPcm(%d): swr_alloc_set_opts() failed", handle); LOGF_ERROR(HLE, "cellAdecGetPcm(%d): swr_alloc_set_opts() failed", handle);
Emu.Pause(); Emu.Pause();
free(out); free(out);
if (af.data) if (af.data)
@ -759,7 +759,7 @@ int cellAdecGetPcm(u32 handle, u32 outBuffer_addr)
if (!Memory.CopyFromReal(outBuffer_addr, out, af.size)) if (!Memory.CopyFromReal(outBuffer_addr, out, af.size))
{ {
ConLog.Error("cellAdecGetPcm(%d): data copying failed (addr=0x%x)", handle, outBuffer_addr); LOGF_ERROR(HLE, "cellAdecGetPcm(%d): data copying failed (addr=0x%x)", handle, outBuffer_addr);
Emu.Pause(); Emu.Pause();
} }

6
rpcs3/Emu/SysCalls/Modules/cellAdec.h
View File

@ -1133,14 +1133,14 @@ public:
AVCodec* codec = avcodec_find_decoder(AV_CODEC_ID_ATRAC3P); AVCodec* codec = avcodec_find_decoder(AV_CODEC_ID_ATRAC3P);
if (!codec) if (!codec)
{ {
ConLog.Error("AudioDecoder(): avcodec_find_decoder(ATRAC3P) failed"); LOGF_ERROR(HLE, "AudioDecoder(): avcodec_find_decoder(ATRAC3P) failed");
Emu.Pause(); Emu.Pause();
return; return;
} }
fmt = avformat_alloc_context(); fmt = avformat_alloc_context();
if (!fmt) if (!fmt)
{ {
ConLog.Error("AudioDecoder(): avformat_alloc_context failed"); LOGF_ERROR(HLE, "AudioDecoder(): avformat_alloc_context failed");
Emu.Pause(); Emu.Pause();
return; return;
} }
@ -1148,7 +1148,7 @@ public:
fmt->pb = avio_alloc_context(io_buf, 4096, 0, this, adecRead, NULL, NULL); fmt->pb = avio_alloc_context(io_buf, 4096, 0, this, adecRead, NULL, NULL);
if (!fmt->pb) if (!fmt->pb)
{ {
ConLog.Error("AudioDecoder(): avio_alloc_context failed"); LOGF_ERROR(HLE, "AudioDecoder(): avio_alloc_context failed");
Emu.Pause(); Emu.Pause();
return; return;
} }

2
rpcs3/Emu/SysCalls/Modules/cellAtrac.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"

22
rpcs3/Emu/SysCalls/Modules/cellAudio.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"
@ -50,11 +50,11 @@ int cellAudioInit()
if (do_dump && !m_dump.Init()) if (do_dump && !m_dump.Init())
{ {
ConLog.Error("cellAudioInit(): AudioDumper::Init() failed"); LOGF_ERROR(HLE, "cellAudioInit(): AudioDumper::Init() failed");
return; return;
} }
ConLog.Write("Audio thread started"); LOGF_NOTICE(HLE, "Audio thread started");
if (Ini.AudioDumpToFile.GetValue()) if (Ini.AudioDumpToFile.GetValue())
m_dump.WriteHeader(); m_dump.WriteHeader();
@ -146,7 +146,7 @@ int cellAudioInit()
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
ConLog.Warning("Audio thread aborted"); LOGF_WARNING(HLE, "Audio thread aborted");
goto abort; goto abort;
} }
@ -426,7 +426,7 @@ int cellAudioInit()
{ {
if (m_dump.WriteData(&buf8ch, sizeof(buf8ch)) != sizeof(buf8ch)) // write file data if (m_dump.WriteData(&buf8ch, sizeof(buf8ch)) != sizeof(buf8ch)) // write file data
{ {
ConLog.Error("cellAudioInit(): AudioDumper::WriteData() failed"); LOGF_ERROR(HLE, "cellAudioInit(): AudioDumper::WriteData() failed");
goto abort; goto abort;
} }
} }
@ -434,21 +434,21 @@ int cellAudioInit()
{ {
if (m_dump.WriteData(&buf2ch, sizeof(buf2ch)) != sizeof(buf2ch)) // write file data if (m_dump.WriteData(&buf2ch, sizeof(buf2ch)) != sizeof(buf2ch)) // write file data
{ {
ConLog.Error("cellAudioInit(): AudioDumper::WriteData() failed"); LOGF_ERROR(HLE, "cellAudioInit(): AudioDumper::WriteData() failed");
goto abort; goto abort;
} }
} }
else else
{ {
ConLog.Error("cellAudioInit(): unknown AudioDumper::GetCh() value (%d)", m_dump.GetCh()); LOGF_ERROR(HLE, "cellAudioInit(): unknown AudioDumper::GetCh() value (%d)", m_dump.GetCh());
goto abort; goto abort;
} }
} }
//ConLog.Write("Audio perf: start=%d (access=%d, AddData=%d, events=%d, dump=%d)", //LOGF_NOTICE(HLE, "Audio perf: start=%d (access=%d, AddData=%d, events=%d, dump=%d)",
//stamp0 - m_config.start_time, stamp1 - stamp0, stamp2 - stamp1, stamp3 - stamp2, get_system_time() - stamp3); //stamp0 - m_config.start_time, stamp1 - stamp0, stamp2 - stamp1, stamp3 - stamp2, get_system_time() - stamp3);
} }
ConLog.Write("Audio thread ended"); LOGF_NOTICE(HLE, "Audio thread ended");
abort: abort:
queue.Push(nullptr); queue.Push(nullptr);
queue_float.Push(nullptr); queue_float.Push(nullptr);
@ -480,7 +480,7 @@ abort:
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
ConLog.Warning("cellAudioInit() aborted"); LOGF_WARNING(HLE, "cellAudioInit() aborted");
return CELL_OK; return CELL_OK;
} }
Sleep(1); Sleep(1);
@ -505,7 +505,7 @@ int cellAudioQuit()
Sleep(1); Sleep(1);
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
ConLog.Warning("cellAudioQuit(): aborted"); LOGF_WARNING(HLE, "cellAudioQuit(): aborted");
return CELL_OK; return CELL_OK;
} }
} }

48
rpcs3/Emu/SysCalls/Modules/cellDmux.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"
@ -47,7 +47,7 @@ u32 dmuxOpen(Demuxer* data)
thread t("Demuxer[" + std::to_string(dmux_id) + "] Thread", [&]() thread t("Demuxer[" + std::to_string(dmux_id) + "] Thread", [&]()
{ {
ConLog.Write("Demuxer thread started (mem=0x%x, size=0x%x, cb=0x%x, arg=0x%x)", dmux.memAddr, dmux.memSize, dmux.cbFunc, dmux.cbArg); LOGF_NOTICE(HLE, "Demuxer thread started (mem=0x%x, size=0x%x, cb=0x%x, arg=0x%x)", dmux.memAddr, dmux.memSize, dmux.cbFunc, dmux.cbArg);
DemuxerTask task; DemuxerTask task;
DemuxerStream stream; DemuxerStream stream;
@ -134,7 +134,7 @@ u32 dmuxOpen(Demuxer* data)
if (!pes.new_au) // temporarily if (!pes.new_au) // temporarily
{ {
ConLog.Error("No pts info found"); LOGF_ERROR(HLE, "No pts info found");
} }
// read additional header: // read additional header:
@ -149,7 +149,7 @@ u32 dmuxOpen(Demuxer* data)
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
ConLog.Warning("esATX[%d] was full, waiting aborted", ch); LOGF_WARNING(HLE, "esATX[%d] was full, waiting aborted", ch);
return; return;
} }
Sleep(1); Sleep(1);
@ -166,7 +166,7 @@ u32 dmuxOpen(Demuxer* data)
es.push(stream, len - pes.size - 3, pes); es.push(stream, len - pes.size - 3, pes);
es.finish(stream); es.finish(stream);
//ConLog.Write("*** AT3+ AU sent (len=0x%x, pts=0x%llx)", len - pes.size - 3, pes.pts); //LOGF_NOTICE(HLE, "*** AT3+ AU sent (len=0x%x, pts=0x%llx)", len - pes.size - 3, pes.pts);
mem_ptr_t<CellDmuxEsMsg> esMsg(a128(dmux.memAddr) + (cb_add ^= 16)); mem_ptr_t<CellDmuxEsMsg> esMsg(a128(dmux.memAddr) + (cb_add ^= 16));
esMsg->msgType = CELL_DMUX_ES_MSG_TYPE_AU_FOUND; esMsg->msgType = CELL_DMUX_ES_MSG_TYPE_AU_FOUND;
@ -198,7 +198,7 @@ u32 dmuxOpen(Demuxer* data)
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
ConLog.Warning("esAVC[%d] was full, waiting aborted", ch); LOGF_WARNING(HLE, "esAVC[%d] was full, waiting aborted", ch);
return; return;
} }
Sleep(1); Sleep(1);
@ -236,7 +236,7 @@ u32 dmuxOpen(Demuxer* data)
if (pes.new_au) if (pes.new_au)
{ {
//ConLog.Write("*** AVC AU detected (pts=0x%llx, dts=0x%llx)", pes.pts, pes.dts); //LOGF_NOTICE(HLE, "*** AVC AU detected (pts=0x%llx, dts=0x%llx)", pes.pts, pes.dts);
} }
if (es.isfull()) if (es.isfull())
@ -268,7 +268,7 @@ u32 dmuxOpen(Demuxer* data)
case 0x1dc: case 0x1dd: case 0x1de: case 0x1df: case 0x1dc: case 0x1dd: case 0x1de: case 0x1df:
{ {
// unknown // unknown
ConLog.Warning("Unknown MPEG stream found"); LOGF_WARNING(HLE, "Unknown MPEG stream found");
stream.skip(4); stream.skip(4);
stream.get(len); stream.get(len);
stream.skip(len); stream.skip(len);
@ -277,7 +277,7 @@ u32 dmuxOpen(Demuxer* data)
case USER_DATA_START_CODE: case USER_DATA_START_CODE:
{ {
ConLog.Error("USER_DATA_START_CODE found"); LOGF_ERROR(HLE, "USER_DATA_START_CODE found");
return; return;
} }
@ -304,7 +304,7 @@ u32 dmuxOpen(Demuxer* data)
{ {
if (task.stream.discontinuity) if (task.stream.discontinuity)
{ {
ConLog.Warning("dmuxSetStream (beginning)"); LOGF_WARNING(HLE, "dmuxSetStream (beginning)");
for (u32 i = 0; i < 192; i++) for (u32 i = 0; i < 192; i++)
{ {
if (esALL[i]) if (esALL[i])
@ -318,13 +318,13 @@ u32 dmuxOpen(Demuxer* data)
if (updates_count != updates_signaled) if (updates_count != updates_signaled)
{ {
ConLog.Error("dmuxSetStream: stream update inconsistency (input=%d, signaled=%d)", updates_count, updates_signaled); LOGF_ERROR(HLE, "dmuxSetStream: stream update inconsistency (input=%d, signaled=%d)", updates_count, updates_signaled);
return; return;
} }
updates_count++; updates_count++;
stream = task.stream; stream = task.stream;
//ConLog.Write("*** stream updated(addr=0x%x, size=0x%x, discont=%d, userdata=0x%llx)", //LOGF_NOTICE(HLE, "*** stream updated(addr=0x%x, size=0x%x, discont=%d, userdata=0x%llx)",
//stream.addr, stream.size, stream.discontinuity, stream.userdata); //stream.addr, stream.size, stream.discontinuity, stream.userdata);
dmux.is_running = true; dmux.is_running = true;
@ -357,7 +357,7 @@ u32 dmuxOpen(Demuxer* data)
case dmuxClose: case dmuxClose:
{ {
dmux.is_finished = true; dmux.is_finished = true;
ConLog.Write("Demuxer thread ended"); LOGF_NOTICE(HLE, "Demuxer thread ended");
return; return;
} }
@ -381,7 +381,7 @@ u32 dmuxOpen(Demuxer* data)
} }
else else
{ {
ConLog.Warning("dmuxEnableEs: (TODO) unsupported filter (0x%x, 0x%x, 0x%x, 0x%x)", es.fidMajor, es.fidMinor, es.sup1, es.sup2); LOGF_WARNING(HLE, "dmuxEnableEs: (TODO) unsupported filter (0x%x, 0x%x, 0x%x, 0x%x)", es.fidMajor, es.fidMinor, es.sup1, es.sup2);
} }
es.dmux = &dmux; es.dmux = &dmux;
} }
@ -392,7 +392,7 @@ u32 dmuxOpen(Demuxer* data)
ElementaryStream& es = *task.es.es_ptr; ElementaryStream& es = *task.es.es_ptr;
if (es.dmux != &dmux) if (es.dmux != &dmux)
{ {
ConLog.Warning("dmuxDisableEs: invalid elementary stream"); LOGF_WARNING(HLE, "dmuxDisableEs: invalid elementary stream");
break; break;
} }
for (u32 i = 0; i < 192; i++) for (u32 i = 0; i < 192; i++)
@ -450,11 +450,11 @@ u32 dmuxOpen(Demuxer* data)
break; break;
default: default:
ConLog.Error("Demuxer thread error: unknown task(%d)", task.type); LOGF_ERROR(HLE, "Demuxer thread error: unknown task(%d)", task.type);
return; return;
} }
} }
ConLog.Warning("Demuxer thread aborted"); LOGF_WARNING(HLE, "Demuxer thread aborted");
}); });
t.detach(); t.detach();
@ -598,7 +598,7 @@ int cellDmuxClose(u32 demuxerHandle)
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
ConLog.Warning("cellDmuxClose(%d) aborted", demuxerHandle); LOGF_WARNING(HLE, "cellDmuxClose(%d) aborted", demuxerHandle);
return CELL_OK; return CELL_OK;
} }
@ -630,7 +630,7 @@ int cellDmuxSetStream(u32 demuxerHandle, const u32 streamAddress, u32 streamSize
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
ConLog.Warning("cellDmuxSetStream(%d) aborted (waiting)", demuxerHandle); LOGF_WARNING(HLE, "cellDmuxSetStream(%d) aborted (waiting)", demuxerHandle);
return CELL_OK; return CELL_OK;
} }
Sleep(1); Sleep(1);
@ -649,12 +649,12 @@ int cellDmuxSetStream(u32 demuxerHandle, const u32 streamAddress, u32 streamSize
u32 addr; u32 addr;
if (!dmux->fbSetStream.Pop(addr)) if (!dmux->fbSetStream.Pop(addr))
{ {
ConLog.Warning("cellDmuxSetStream(%d) aborted (fbSetStream.Pop())", demuxerHandle); LOGF_WARNING(HLE, "cellDmuxSetStream(%d) aborted (fbSetStream.Pop())", demuxerHandle);
return CELL_OK; return CELL_OK;
} }
if (addr != info.addr) if (addr != info.addr)
{ {
ConLog.Error("cellDmuxSetStream(%d): wrong stream queued (right=0x%x, queued=0x%x)", demuxerHandle, info.addr, addr); LOGF_ERROR(HLE, "cellDmuxSetStream(%d): wrong stream queued (right=0x%x, queued=0x%x)", demuxerHandle, info.addr, addr);
Emu.Pause(); Emu.Pause();
} }
return CELL_OK; return CELL_OK;
@ -690,12 +690,12 @@ int cellDmuxResetStreamAndWaitDone(u32 demuxerHandle)
u32 addr; u32 addr;
if (!dmux->fbSetStream.Pop(addr)) if (!dmux->fbSetStream.Pop(addr))
{ {
ConLog.Warning("cellDmuxResetStreamAndWaitDone(%d) aborted (fbSetStream.Pop())", demuxerHandle); LOGF_WARNING(HLE, "cellDmuxResetStreamAndWaitDone(%d) aborted (fbSetStream.Pop())", demuxerHandle);
return CELL_OK; return CELL_OK;
} }
if (addr != 0) if (addr != 0)
{ {
ConLog.Error("cellDmuxResetStreamAndWaitDone(%d): wrong stream queued (0x%x)", demuxerHandle, addr); LOGF_ERROR(HLE, "cellDmuxResetStreamAndWaitDone(%d): wrong stream queued (0x%x)", demuxerHandle, addr);
Emu.Pause(); Emu.Pause();
} }
return CELL_OK; return CELL_OK;
@ -1013,4 +1013,4 @@ void cellDmux_init()
cellDmux->AddFunc(0x002e8da2, cellDmuxPeekAuEx); cellDmux->AddFunc(0x002e8da2, cellDmuxPeekAuEx);
cellDmux->AddFunc(0x24ea6474, cellDmuxReleaseAu); cellDmux->AddFunc(0x24ea6474, cellDmuxReleaseAu);
cellDmux->AddFunc(0xebb3b2bd, cellDmuxFlushEs); cellDmux->AddFunc(0xebb3b2bd, cellDmuxFlushEs);
} }

38
rpcs3/Emu/SysCalls/Modules/cellDmux.h
View File

@ -394,14 +394,14 @@ struct PesHeader
new_au = true; new_au = true;
if ((v & 0xF0) != 0x30 || (size - empty) < 10) if ((v & 0xF0) != 0x30 || (size - empty) < 10)
{ {
ConLog.Error("PesHeader(): pts not found"); LOGF_ERROR(HLE, "PesHeader(): pts not found");
Emu.Pause(); Emu.Pause();
} }
pts = stream.get_ts(v); pts = stream.get_ts(v);
stream.get(v); stream.get(v);
if ((v & 0xF0) != 0x10) if ((v & 0xF0) != 0x10)
{ {
ConLog.Error("PesHeader(): dts not found"); LOGF_ERROR(HLE, "PesHeader(): dts not found");
Emu.Pause(); Emu.Pause();
} }
dts = stream.get_ts(v); dts = stream.get_ts(v);
@ -557,7 +557,7 @@ public:
{ {
if (size > GetMaxAU()) if (size > GetMaxAU())
{ {
ConLog.Error("es::freespace(): last_size too big (size=0x%x, max_au=0x%x)", size, GetMaxAU()); LOGF_ERROR(HLE, "es::freespace(): last_size too big (size=0x%x, max_au=0x%x)", size, GetMaxAU());
Emu.Pause(); Emu.Pause();
return 0; return 0;
} }
@ -587,7 +587,7 @@ public:
u32 addr; u32 addr;
{ {
std::lock_guard<std::mutex> lock(m_mutex); std::lock_guard<std::mutex> lock(m_mutex);
//if (fidMajor != 0xbd) ConLog.Write(">>> es::finish(): peek=0x%x, first=0x%x, put=0x%x, size=0x%x", peek, first, put, size); //if (fidMajor != 0xbd) LOGF_NOTICE(HLE, ">>> es::finish(): peek=0x%x, first=0x%x, put=0x%x, size=0x%x", peek, first, put, size);
addr = put; addr = put;
/*if (!first) /*if (!first)
@ -600,7 +600,7 @@ public:
}*/ }*/
mem_ptr_t<CellDmuxAuInfo> info(put); mem_ptr_t<CellDmuxAuInfo> info(put);
//if (fidMajor != 0xbd) ConLog.Warning("es::finish(): (%s) size = 0x%x, info_addr=0x%x, pts = 0x%x", //if (fidMajor != 0xbd) LOGF_WARNING(HLE, "es::finish(): (%s) size = 0x%x, info_addr=0x%x, pts = 0x%x",
//wxString(fidMajor == 0xbd ? "ATRAC3P Audio" : "Video AVC").wx_str(), //wxString(fidMajor == 0xbd ? "ATRAC3P Audio" : "Video AVC").wx_str(),
//(u32)info->auSize, put, (u32)info->ptsLower); //(u32)info->auSize, put, (u32)info->ptsLower);
@ -611,11 +611,11 @@ public:
size = 0; size = 0;
put_count++; put_count++;
//if (fidMajor != 0xbd) ConLog.Write("<<< es::finish(): peek=0x%x, first=0x%x, put=0x%x, size=0x%x", peek, first, put, size); //if (fidMajor != 0xbd) LOGF_NOTICE(HLE, "<<< es::finish(): peek=0x%x, first=0x%x, put=0x%x, size=0x%x", peek, first, put, size);
} }
if (!entries.Push(addr)) if (!entries.Push(addr))
{ {
ConLog.Error("es::finish() aborted (no space)"); LOGF_ERROR(HLE, "es::finish() aborted (no space)");
} }
} }
@ -625,7 +625,7 @@ public:
if (is_full()) if (is_full())
{ {
ConLog.Error("es::push(): buffer is full"); LOGF_ERROR(HLE, "es::push(): buffer is full");
Emu.Pause(); Emu.Pause();
return; return;
} }
@ -634,7 +634,7 @@ public:
size += sz; size += sz;
if (!Memory.Copy(data_addr, stream.addr, sz)) if (!Memory.Copy(data_addr, stream.addr, sz))
{ {
ConLog.Error("es::push(): data copying failed"); LOGF_ERROR(HLE, "es::push(): data copying failed");
Emu.Pause(); Emu.Pause();
return; return;
} }
@ -674,22 +674,22 @@ public:
bool release() bool release()
{ {
std::lock_guard<std::mutex> lock(m_mutex); std::lock_guard<std::mutex> lock(m_mutex);
//if (fidMajor != 0xbd) ConLog.Write(">>> es::release(): peek=0x%x, first=0x%x, put=0x%x, size=0x%x", peek, first, put, size); //if (fidMajor != 0xbd) LOGF_NOTICE(HLE, ">>> es::release(): peek=0x%x, first=0x%x, put=0x%x, size=0x%x", peek, first, put, size);
if (released >= put_count) if (released >= put_count)
{ {
ConLog.Error("es::release(): buffer is empty"); LOGF_ERROR(HLE, "es::release(): buffer is empty");
return false; return false;
} }
u32 addr = entries.Peek(); u32 addr = entries.Peek();
mem_ptr_t<CellDmuxAuInfo> info(addr); mem_ptr_t<CellDmuxAuInfo> info(addr);
//if (fidMajor != 0xbd) ConLog.Warning("es::release(): (%s) size = 0x%x, info = 0x%x, pts = 0x%x", //if (fidMajor != 0xbd) LOGF_WARNING(HLE, "es::release(): (%s) size = 0x%x, info = 0x%x, pts = 0x%x",
//wxString(fidMajor == 0xbd ? "ATRAC3P Audio" : "Video AVC").wx_str(), (u32)info->auSize, first, (u32)info->ptsLower); //wxString(fidMajor == 0xbd ? "ATRAC3P Audio" : "Video AVC").wx_str(), (u32)info->auSize, first, (u32)info->ptsLower);
if (released >= peek_count) if (released >= peek_count)
{ {
ConLog.Error("es::release(): buffer has not been seen yet"); LOGF_ERROR(HLE, "es::release(): buffer has not been seen yet");
return false; return false;
} }
@ -711,30 +711,30 @@ public:
released++; released++;
if (!entries.Pop(addr)) if (!entries.Pop(addr))
{ {
ConLog.Error("es::release(): entries.Pop() aborted (no entries found)"); LOGF_ERROR(HLE, "es::release(): entries.Pop() aborted (no entries found)");
return false; return false;
} }
//if (fidMajor != 0xbd) ConLog.Write("<<< es::release(): peek=0x%x, first=0x%x, put=0x%x, size=0x%x", peek, first, put, size); //if (fidMajor != 0xbd) LOGF_NOTICE(HLE, "<<< es::release(): peek=0x%x, first=0x%x, put=0x%x, size=0x%x", peek, first, put, size);
return true; return true;
} }
bool peek(u32& out_data, bool no_ex, u32& out_spec, bool update_index) bool peek(u32& out_data, bool no_ex, u32& out_spec, bool update_index)
{ {
std::lock_guard<std::mutex> lock(m_mutex); std::lock_guard<std::mutex> lock(m_mutex);
//if (fidMajor != 0xbd) ConLog.Write(">>> es::peek(%sAu%s): peek=0x%x, first=0x%x, put=0x%x, size=0x%x", wxString(update_index ? "Get" : "Peek").wx_str(), //if (fidMajor != 0xbd) LOGF_NOTICE(HLE, ">>> es::peek(%sAu%s): peek=0x%x, first=0x%x, put=0x%x, size=0x%x", wxString(update_index ? "Get" : "Peek").wx_str(),
//wxString(no_ex ? "" : "Ex").wx_str(), peek, first, put, size); //wxString(no_ex ? "" : "Ex").wx_str(), peek, first, put, size);
if (peek_count >= put_count) return false; if (peek_count >= put_count) return false;
if (peek_count < released) if (peek_count < released)
{ {
ConLog.Error("es::peek(): sequence error: peek_count < released (peek_count=%d, released=%d)", peek_count, released); LOGF_ERROR(HLE, "es::peek(): sequence error: peek_count < released (peek_count=%d, released=%d)", peek_count, released);
Emu.Pause(); Emu.Pause();
return false; return false;
} }
u32 addr = entries.Peek(peek_count - released); u32 addr = entries.Peek(peek_count - released);
mem_ptr_t<CellDmuxAuInfo> info(addr); mem_ptr_t<CellDmuxAuInfo> info(addr);
//if (fidMajor != 0xbd) ConLog.Warning("es::peek(%sAu(Ex)): (%s) size = 0x%x, info = 0x%x, pts = 0x%x", //if (fidMajor != 0xbd) LOGF_WARNING(HLE, "es::peek(%sAu(Ex)): (%s) size = 0x%x, info = 0x%x, pts = 0x%x",
//wxString(update_index ? "Get" : "Peek").wx_str(), //wxString(update_index ? "Get" : "Peek").wx_str(),
//wxString(fidMajor == 0xbd ? "ATRAC3P Audio" : "Video AVC").wx_str(), (u32)info->auSize, peek, (u32)info->ptsLower); //wxString(fidMajor == 0xbd ? "ATRAC3P Audio" : "Video AVC").wx_str(), (u32)info->auSize, peek, (u32)info->ptsLower);
@ -760,7 +760,7 @@ public:
peek_count++; peek_count++;
} }
//if (fidMajor != 0xbd) ConLog.Write("<<< es::peek(%sAu%s): peek=0x%x, first=0x%x, put=0x%x, size=0x%x", wxString(update_index ? "Get" : "Peek").wx_str(), //if (fidMajor != 0xbd) LOGF_NOTICE(HLE, "<<< es::peek(%sAu%s): peek=0x%x, first=0x%x, put=0x%x, size=0x%x", wxString(update_index ? "Get" : "Peek").wx_str(),
//wxString(no_ex ? "" : "Ex").wx_str(), peek, first, put, size); //wxString(no_ex ? "" : "Ex").wx_str(), peek, first, put, size);
return true; return true;
} }

2
rpcs3/Emu/SysCalls/Modules/cellFont.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"

2
rpcs3/Emu/SysCalls/Modules/cellFontFT.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"

2
rpcs3/Emu/SysCalls/Modules/cellGame.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"

4
rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"
@ -478,7 +478,7 @@ int cellGcmSetPrepareFlip(mem_ptr_t<CellGcmContextData> ctxt, u32 id)
if(current + 8 >= end) if(current + 8 >= end)
{ {
ConLog.Warning("bad flip!"); LOG_WARNING(HLE, "bad flip!");
//cellGcmCallback(ctxt.GetAddr(), current + 8 - end); //cellGcmCallback(ctxt.GetAddr(), current + 8 - end);
//copied: //copied:

2
rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"

2
rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"

2
rpcs3/Emu/SysCalls/Modules/cellL10n.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"

2
rpcs3/Emu/SysCalls/Modules/cellNetCtl.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"

2
rpcs3/Emu/SysCalls/Modules/cellPamf.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"

2
rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"

2
rpcs3/Emu/SysCalls/Modules/cellResc.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"

2
rpcs3/Emu/SysCalls/Modules/cellRtc.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"

2
rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"

4
rpcs3/Emu/SysCalls/Modules/cellSync.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"
@ -93,7 +93,7 @@ int cellSyncMutexLock(mem_ptr_t<CellSyncMutex> mutex)
Sleep(1); Sleep(1);
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
ConLog.Warning("cellSyncMutexLock(mutex=0x%x) aborted", mutex.GetAddr()); LOGF_WARNING(HLE, "cellSyncMutexLock(mutex=0x%x) aborted", mutex.GetAddr());
break; break;
} }
} }

2
rpcs3/Emu/SysCalls/Modules/cellSysmodule.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"

4
rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"
@ -350,7 +350,7 @@ int cellSysutilCheckCallback()
Sleep(1); Sleep(1);
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
ConLog.Warning("cellSysutilCheckCallback() aborted"); LOG_WARNING(HLE, "cellSysutilCheckCallback() aborted");
break; break;
} }
} }

2
rpcs3/Emu/SysCalls/Modules/cellSysutilAp.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"

36
rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"
@ -230,7 +230,7 @@ s32 modifySaveDataFiles(mem_func_ptr_t<CellSaveDataFileCallback>& funcFile, mem_
{ {
funcFile(result.GetAddr(), fileGet.GetAddr(), fileSet.GetAddr()); funcFile(result.GetAddr(), fileGet.GetAddr(), fileSet.GetAddr());
if (result->result < 0) { if (result->result < 0) {
ConLog.Error("modifySaveDataFiles: CellSaveDataFileCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message. LOGF_ERROR(HLE, "modifySaveDataFiles: CellSaveDataFileCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
return CELL_SAVEDATA_ERROR_CBRESULT; return CELL_SAVEDATA_ERROR_CBRESULT;
} }
if (result->result == CELL_SAVEDATA_CBRESULT_OK_LAST) { if (result->result == CELL_SAVEDATA_CBRESULT_OK_LAST) {
@ -251,7 +251,7 @@ s32 modifySaveDataFiles(mem_func_ptr_t<CellSaveDataFileCallback>& funcFile, mem_
case CELL_SAVEDATA_FILETYPE_CONTENT_SND0: filepath += "SND0.AT3"; break; case CELL_SAVEDATA_FILETYPE_CONTENT_SND0: filepath += "SND0.AT3"; break;
default: default:
ConLog.Error("modifySaveDataFiles: Unknown fileType! Aborting..."); LOGF_ERROR(HLE, "modifySaveDataFiles: Unknown fileType! Aborting...");
return CELL_SAVEDATA_ERROR_PARAM; return CELL_SAVEDATA_ERROR_PARAM;
} }
@ -274,11 +274,11 @@ s32 modifySaveDataFiles(mem_func_ptr_t<CellSaveDataFileCallback>& funcFile, mem_
break; break;
case CELL_SAVEDATA_FILEOP_WRITE_NOTRUNC: case CELL_SAVEDATA_FILEOP_WRITE_NOTRUNC:
ConLog.Warning("modifySaveDataFiles: File operation CELL_SAVEDATA_FILEOP_WRITE_NOTRUNC not yet implemented"); LOGF_WARNING(HLE, "modifySaveDataFiles: File operation CELL_SAVEDATA_FILEOP_WRITE_NOTRUNC not yet implemented");
break; break;
default: default:
ConLog.Error("modifySaveDataFiles: Unknown fileOperation! Aborting..."); LOGF_ERROR(HLE, "modifySaveDataFiles: Unknown fileOperation! Aborting...");
return CELL_SAVEDATA_ERROR_PARAM; return CELL_SAVEDATA_ERROR_PARAM;
} }
@ -339,7 +339,7 @@ int cellSaveDataListSave2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
funcList(result.GetAddr(), listGet.GetAddr(), listSet.GetAddr()); funcList(result.GetAddr(), listGet.GetAddr(), listSet.GetAddr());
if (result->result < 0) { if (result->result < 0) {
ConLog.Error("cellSaveDataListSave2: CellSaveDataListCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message. LOGF_ERROR(HLE, "cellSaveDataListSave2: CellSaveDataListCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
return CELL_SAVEDATA_ERROR_CBRESULT; return CELL_SAVEDATA_ERROR_CBRESULT;
} }
if (!listSet->fixedList.IsGood()) if (!listSet->fixedList.IsGood())
@ -349,7 +349,7 @@ int cellSaveDataListSave2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
if (listSet->newData.IsGood()) if (listSet->newData.IsGood())
addNewSaveDataEntry(saveEntries, (u32)listSet->newData.GetAddr()); addNewSaveDataEntry(saveEntries, (u32)listSet->newData.GetAddr());
if (saveEntries.size() == 0) { if (saveEntries.size() == 0) {
ConLog.Warning("cellSaveDataListSave2: No save entries found!"); // TODO: Find a better way to handle this error LOGF_WARNING(HLE, "cellSaveDataListSave2: No save entries found!"); // TODO: Find a better way to handle this error
return CELL_SAVEDATA_RET_OK; return CELL_SAVEDATA_RET_OK;
} }
@ -362,7 +362,7 @@ int cellSaveDataListSave2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
funcStat(result.GetAddr(), statGet.GetAddr(), statSet.GetAddr()); funcStat(result.GetAddr(), statGet.GetAddr(), statSet.GetAddr());
Memory.Free(statGet->fileList.GetAddr()); Memory.Free(statGet->fileList.GetAddr());
if (result->result < 0) { if (result->result < 0) {
ConLog.Error("cellSaveDataListLoad2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message. LOGF_ERROR(HLE, "cellSaveDataListLoad2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
return CELL_SAVEDATA_ERROR_CBRESULT; return CELL_SAVEDATA_ERROR_CBRESULT;
} }
/*if (statSet->setParam.IsGood()) /*if (statSet->setParam.IsGood())
@ -424,7 +424,7 @@ int cellSaveDataListLoad2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
funcList(result.GetAddr(), listGet.GetAddr(), listSet.GetAddr()); funcList(result.GetAddr(), listGet.GetAddr(), listSet.GetAddr());
if (result->result < 0) { if (result->result < 0) {
ConLog.Error("cellSaveDataListLoad2: CellSaveDataListCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message. LOGF_ERROR(HLE, "cellSaveDataListLoad2: CellSaveDataListCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
return CELL_SAVEDATA_ERROR_CBRESULT; return CELL_SAVEDATA_ERROR_CBRESULT;
} }
if (!listSet->fixedList.IsGood()) if (!listSet->fixedList.IsGood())
@ -434,7 +434,7 @@ int cellSaveDataListLoad2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
if (listSet->newData.IsGood()) if (listSet->newData.IsGood())
addNewSaveDataEntry(saveEntries, (u32)listSet->newData.GetAddr()); addNewSaveDataEntry(saveEntries, (u32)listSet->newData.GetAddr());
if (saveEntries.size() == 0) { if (saveEntries.size() == 0) {
ConLog.Warning("cellSaveDataListLoad2: No save entries found!"); // TODO: Find a better way to handle this error LOGF_WARNING(HLE, "cellSaveDataListLoad2: No save entries found!"); // TODO: Find a better way to handle this error
return CELL_SAVEDATA_RET_OK; return CELL_SAVEDATA_RET_OK;
} }
@ -447,7 +447,7 @@ int cellSaveDataListLoad2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
funcStat(result.GetAddr(), statGet.GetAddr(), statSet.GetAddr()); funcStat(result.GetAddr(), statGet.GetAddr(), statSet.GetAddr());
Memory.Free(statGet->fileList.GetAddr()); Memory.Free(statGet->fileList.GetAddr());
if (result->result < 0) { if (result->result < 0) {
ConLog.Error("cellSaveDataListLoad2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message. LOGF_ERROR(HLE, "cellSaveDataListLoad2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
return CELL_SAVEDATA_ERROR_CBRESULT; return CELL_SAVEDATA_ERROR_CBRESULT;
} }
/*if (statSet->setParam.IsGood()) /*if (statSet->setParam.IsGood())
@ -508,7 +508,7 @@ int cellSaveDataFixedSave2(u32 version, mem_ptr_t<CellSaveDataSetList> setList,
} }
funcFixed(result.GetAddr(), listGet.GetAddr(), fixedSet.GetAddr()); funcFixed(result.GetAddr(), listGet.GetAddr(), fixedSet.GetAddr());
if (result->result < 0) { if (result->result < 0) {
ConLog.Error("cellSaveDataFixedSave2: CellSaveDataFixedCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message. LOGF_ERROR(HLE, "cellSaveDataFixedSave2: CellSaveDataFixedCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
return CELL_SAVEDATA_ERROR_CBRESULT; return CELL_SAVEDATA_ERROR_CBRESULT;
} }
setSaveDataFixed(saveEntries, fixedSet.GetAddr()); setSaveDataFixed(saveEntries, fixedSet.GetAddr());
@ -519,7 +519,7 @@ int cellSaveDataFixedSave2(u32 version, mem_ptr_t<CellSaveDataSetList> setList,
funcStat(result.GetAddr(), statGet.GetAddr(), statSet.GetAddr()); funcStat(result.GetAddr(), statGet.GetAddr(), statSet.GetAddr());
Memory.Free(statGet->fileList.GetAddr()); Memory.Free(statGet->fileList.GetAddr());
if (result->result < 0) { if (result->result < 0) {
ConLog.Error("cellSaveDataFixedSave2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message. LOGF_ERROR(HLE, "cellSaveDataFixedSave2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
return CELL_SAVEDATA_ERROR_CBRESULT; return CELL_SAVEDATA_ERROR_CBRESULT;
} }
/*if (statSet->setParam.IsGood()) /*if (statSet->setParam.IsGood())
@ -580,7 +580,7 @@ int cellSaveDataFixedLoad2(u32 version, mem_ptr_t<CellSaveDataSetList> setList,
} }
funcFixed(result.GetAddr(), listGet.GetAddr(), fixedSet.GetAddr()); funcFixed(result.GetAddr(), listGet.GetAddr(), fixedSet.GetAddr());
if (result->result < 0) { if (result->result < 0) {
ConLog.Error("cellSaveDataFixedLoad2: CellSaveDataFixedCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message. LOGF_ERROR(HLE, "cellSaveDataFixedLoad2: CellSaveDataFixedCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
return CELL_SAVEDATA_ERROR_CBRESULT; return CELL_SAVEDATA_ERROR_CBRESULT;
} }
setSaveDataFixed(saveEntries, fixedSet.GetAddr()); setSaveDataFixed(saveEntries, fixedSet.GetAddr());
@ -591,7 +591,7 @@ int cellSaveDataFixedLoad2(u32 version, mem_ptr_t<CellSaveDataSetList> setList,
funcStat(result.GetAddr(), statGet.GetAddr(), statSet.GetAddr()); funcStat(result.GetAddr(), statGet.GetAddr(), statSet.GetAddr());
Memory.Free(statGet->fileList.GetAddr()); Memory.Free(statGet->fileList.GetAddr());
if (result->result < 0) { if (result->result < 0) {
ConLog.Error("cellSaveDataFixedLoad2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message. LOGF_ERROR(HLE, "cellSaveDataFixedLoad2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
return CELL_SAVEDATA_ERROR_CBRESULT; return CELL_SAVEDATA_ERROR_CBRESULT;
} }
/*if (statSet->setParam.IsGood()) /*if (statSet->setParam.IsGood())
@ -647,7 +647,7 @@ int cellSaveDataAutoSave2(u32 version, u32 dirName_addr, u32 errDialog, mem_ptr_
Memory.Free(statGet->fileList.GetAddr()); Memory.Free(statGet->fileList.GetAddr());
if (result->result < 0) { if (result->result < 0) {
ConLog.Error("cellSaveDataAutoSave2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message. LOGF_ERROR(HLE, "cellSaveDataAutoSave2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
return CELL_SAVEDATA_ERROR_CBRESULT; return CELL_SAVEDATA_ERROR_CBRESULT;
} }
/*if (statSet->setParam.IsGood()) /*if (statSet->setParam.IsGood())
@ -690,7 +690,7 @@ int cellSaveDataAutoLoad2(u32 version, u32 dirName_addr, u32 errDialog, mem_ptr_
// The target entry does not exist // The target entry does not exist
if (saveEntries.size() == 0) { if (saveEntries.size() == 0) {
ConLog.Warning("cellSaveDataAutoLoad2: Couldn't find save entry (%s)", dirName.c_str()); LOGF_WARNING(HLE, "cellSaveDataAutoLoad2: Couldn't find save entry (%s)", dirName.c_str());
return CELL_OK; // TODO: Can anyone check the actual behaviour of a PS3 when saves are not found? return CELL_OK; // TODO: Can anyone check the actual behaviour of a PS3 when saves are not found?
} }
@ -700,7 +700,7 @@ int cellSaveDataAutoLoad2(u32 version, u32 dirName_addr, u32 errDialog, mem_ptr_
Memory.Free(statGet->fileList.GetAddr()); Memory.Free(statGet->fileList.GetAddr());
if (result->result < 0) { if (result->result < 0) {
ConLog.Error("cellSaveDataAutoLoad2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message. LOGF_ERROR(HLE, "cellSaveDataAutoLoad2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
return CELL_SAVEDATA_ERROR_CBRESULT; return CELL_SAVEDATA_ERROR_CBRESULT;
} }
/*if (statSet->setParam.IsGood()) /*if (statSet->setParam.IsGood())

2
rpcs3/Emu/SysCalls/Modules/cellUserInfo.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"

58
rpcs3/Emu/SysCalls/Modules/cellVdec.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"
@ -35,7 +35,7 @@ next:
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
ConLog.Warning("vdecRead(): aborted"); LOGF_WARNING(HLE, "vdecRead(): aborted");
return 0; return 0;
} }
Sleep(1); Sleep(1);
@ -52,7 +52,7 @@ next:
{ {
if (!Memory.CopyToReal(buf, vdec.reader.addr, vdec.reader.size)) if (!Memory.CopyToReal(buf, vdec.reader.addr, vdec.reader.size))
{ {
ConLog.Error("vdecRead(): data reading failed (reader.size=0x%x)", vdec.reader.size); LOGF_ERROR(HLE, "vdecRead(): data reading failed (reader.size=0x%x)", vdec.reader.size);
Emu.Pause(); Emu.Pause();
return 0; return 0;
} }
@ -71,11 +71,11 @@ next:
vdec.reader.addr = vdec.task.addr; vdec.reader.addr = vdec.task.addr;
vdec.reader.size = vdec.task.size; vdec.reader.size = vdec.task.size;
//ConLog.Write("Video AU: size = 0x%x, pts = 0x%llx, dts = 0x%llx", vdec.task.size, vdec.task.pts, vdec.task.dts); //LOGF_NOTICE(HLE, "Video AU: size = 0x%x, pts = 0x%llx, dts = 0x%llx", vdec.task.size, vdec.task.pts, vdec.task.dts);
} }
break; break;
default: default:
ConLog.Error("vdecRead(): sequence error (task %d)", vdec.job.Peek().type); LOGF_ERROR(HLE, "vdecRead(): sequence error (task %d)", vdec.job.Peek().type);
return 0; return 0;
} }
@ -92,7 +92,7 @@ next:
} }
else if (!Memory.CopyToReal(buf, vdec.reader.addr, buf_size)) else if (!Memory.CopyToReal(buf, vdec.reader.addr, buf_size))
{ {
ConLog.Error("vdecRead(): data reading failed (buf_size=0x%x)", buf_size); LOGF_ERROR(HLE, "vdecRead(): data reading failed (buf_size=0x%x)", buf_size);
Emu.Pause(); Emu.Pause();
return 0; return 0;
} }
@ -136,7 +136,7 @@ u32 vdecOpen(VideoDecoder* data)
thread t("Video Decoder[" + std::to_string(vdec_id) + "] Thread", [&]() thread t("Video Decoder[" + std::to_string(vdec_id) + "] Thread", [&]()
{ {
ConLog.Write("Video Decoder thread started"); LOGF_NOTICE(HLE, "Video Decoder thread started");
VdecTask& task = vdec.task; VdecTask& task = vdec.task;
@ -169,7 +169,7 @@ u32 vdecOpen(VideoDecoder* data)
case vdecStartSeq: case vdecStartSeq:
{ {
// TODO: reset data // TODO: reset data
ConLog.Warning("vdecStartSeq:"); LOGF_WARNING(HLE, "vdecStartSeq:");
vdec.reader.addr = 0; vdec.reader.addr = 0;
vdec.reader.size = 0; vdec.reader.size = 0;
@ -181,7 +181,7 @@ u32 vdecOpen(VideoDecoder* data)
case vdecEndSeq: case vdecEndSeq:
{ {
// TODO: finalize // TODO: finalize
ConLog.Warning("vdecEndSeq:"); LOGF_WARNING(HLE, "vdecEndSeq:");
vdec.vdecCb->ExecAsCallback(vdec.cbFunc, false, vdec.id, CELL_VDEC_MSG_TYPE_SEQDONE, CELL_OK, vdec.cbArg); vdec.vdecCb->ExecAsCallback(vdec.cbFunc, false, vdec.id, CELL_VDEC_MSG_TYPE_SEQDONE, CELL_OK, vdec.cbArg);
/*Callback cb; /*Callback cb;
@ -202,13 +202,13 @@ u32 vdecOpen(VideoDecoder* data)
if (task.mode != CELL_VDEC_DEC_MODE_NORMAL) if (task.mode != CELL_VDEC_DEC_MODE_NORMAL)
{ {
ConLog.Error("vdecDecodeAu: unsupported decoding mode(%d)", task.mode); LOGF_ERROR(HLE, "vdecDecodeAu: unsupported decoding mode(%d)", task.mode);
break; break;
} }
vdec.reader.addr = task.addr; vdec.reader.addr = task.addr;
vdec.reader.size = task.size; vdec.reader.size = task.size;
//ConLog.Write("Video AU: size = 0x%x, pts = 0x%llx, dts = 0x%llx", task.size, task.pts, task.dts); //LOGF_NOTICE(HLE, "Video AU: size = 0x%x, pts = 0x%llx, dts = 0x%llx", task.size, task.pts, task.dts);
if (vdec.just_started) if (vdec.just_started)
{ {
@ -249,33 +249,33 @@ u32 vdecOpen(VideoDecoder* data)
err = avformat_open_input(&vdec.fmt, NULL, av_find_input_format("mpeg"), NULL); err = avformat_open_input(&vdec.fmt, NULL, av_find_input_format("mpeg"), NULL);
if (err) if (err)
{ {
ConLog.Error("vdecDecodeAu: avformat_open_input() failed"); LOGF_ERROR(HLE, "vdecDecodeAu: avformat_open_input() failed");
Emu.Pause(); Emu.Pause();
break; break;
} }
AVCodec* codec = avcodec_find_decoder(AV_CODEC_ID_H264); // ??? AVCodec* codec = avcodec_find_decoder(AV_CODEC_ID_H264); // ???
if (!codec) if (!codec)
{ {
ConLog.Error("vdecDecodeAu: avcodec_find_decoder() failed"); LOGF_ERROR(HLE, "vdecDecodeAu: avcodec_find_decoder() failed");
Emu.Pause(); Emu.Pause();
break; break;
} }
/*err = avformat_find_stream_info(vdec.fmt, NULL); /*err = avformat_find_stream_info(vdec.fmt, NULL);
if (err) if (err)
{ {
ConLog.Error("vdecDecodeAu: avformat_find_stream_info() failed"); LOGF_ERROR(HLE, "vdecDecodeAu: avformat_find_stream_info() failed");
Emu.Pause(); Emu.Pause();
break; break;
} }
if (!vdec.fmt->nb_streams) if (!vdec.fmt->nb_streams)
{ {
ConLog.Error("vdecDecodeAu: no stream found"); LOGF_ERROR(HLE, "vdecDecodeAu: no stream found");
Emu.Pause(); Emu.Pause();
break; break;
}*/ }*/
if (!avformat_new_stream(vdec.fmt, codec)) if (!avformat_new_stream(vdec.fmt, codec))
{ {
ConLog.Error("vdecDecodeAu: avformat_new_stream() failed"); LOGF_ERROR(HLE, "vdecDecodeAu: avformat_new_stream() failed");
Emu.Pause(); Emu.Pause();
break; break;
} }
@ -290,7 +290,7 @@ u32 vdecOpen(VideoDecoder* data)
} }
if (err) if (err)
{ {
ConLog.Error("vdecDecodeAu: avcodec_open2() failed"); LOGF_ERROR(HLE, "vdecDecodeAu: avcodec_open2() failed");
Emu.Pause(); Emu.Pause();
break; break;
} }
@ -305,7 +305,7 @@ u32 vdecOpen(VideoDecoder* data)
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
ConLog.Warning("vdecDecodeAu: aborted"); LOGF_WARNING(HLE, "vdecDecodeAu: aborted");
return; return;
} }
@ -338,7 +338,7 @@ u32 vdecOpen(VideoDecoder* data)
if (!frame.data) if (!frame.data)
{ {
ConLog.Error("vdecDecodeAu: av_frame_alloc() failed"); LOGF_ERROR(HLE, "vdecDecodeAu: av_frame_alloc() failed");
Emu.Pause(); Emu.Pause();
break; break;
} }
@ -351,7 +351,7 @@ u32 vdecOpen(VideoDecoder* data)
{ {
if (!last_frame && decode < 0) if (!last_frame && decode < 0)
{ {
ConLog.Error("vdecDecodeAu: AU decoding error(0x%x)", decode); LOGF_ERROR(HLE, "vdecDecodeAu: AU decoding error(0x%x)", decode);
} }
if (!got_picture && vdec.reader.size == 0) break; // video end? if (!got_picture && vdec.reader.size == 0) break; // video end?
} }
@ -374,7 +374,7 @@ u32 vdecOpen(VideoDecoder* data)
frame.dts = (frame.pts - vdec.first_pts) + vdec.first_dts; frame.dts = (frame.pts - vdec.first_pts) + vdec.first_dts;
frame.userdata = task.userData; frame.userdata = task.userData;
//ConLog.Write("got picture (pts=0x%llx, dts=0x%llx)", frame.pts, frame.dts); //LOGF_NOTICE(HLE, "got picture (pts=0x%llx, dts=0x%llx)", frame.pts, frame.dts);
vdec.frames.Push(frame); // !!!!!!!! vdec.frames.Push(frame); // !!!!!!!!
frame.data = nullptr; // to prevent destruction frame.data = nullptr; // to prevent destruction
@ -398,23 +398,23 @@ u32 vdecOpen(VideoDecoder* data)
case vdecClose: case vdecClose:
{ {
vdec.is_finished = true; vdec.is_finished = true;
ConLog.Write("Video Decoder thread ended"); LOGF_NOTICE(HLE, "Video Decoder thread ended");
return; return;
} }
case vdecSetFrameRate: case vdecSetFrameRate:
{ {
ConLog.Error("TODO: vdecSetFrameRate(%d)", task.frc); LOGF_ERROR(HLE, "TODO: vdecSetFrameRate(%d)", task.frc);
} }
break; break;
default: default:
ConLog.Error("Video Decoder thread error: unknown task(%d)", task.type); LOGF_ERROR(HLE, "Video Decoder thread error: unknown task(%d)", task.type);
} }
} }
vdec.is_finished = true; vdec.is_finished = true;
ConLog.Warning("Video Decoder thread aborted"); LOGF_WARNING(HLE, "Video Decoder thread aborted");
}); });
t.detach(); t.detach();
@ -502,7 +502,7 @@ int cellVdecClose(u32 handle)
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
ConLog.Warning("cellVdecClose(%d) aborted", handle); LOGF_WARNING(HLE, "cellVdecClose(%d) aborted", handle);
break; break;
} }
Sleep(1); Sleep(1);
@ -553,7 +553,7 @@ int cellVdecEndSeq(u32 handle)
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
ConLog.Warning("cellVdecEndSeq(%d) aborted", handle); LOGF_WARNING(HLE, "cellVdecEndSeq(%d) aborted", handle);
return CELL_OK; return CELL_OK;
} }
Sleep(1); Sleep(1);
@ -751,13 +751,13 @@ int cellVdecGetPicItem(u32 handle, mem32_t picItem_ptr)
} }
else else
{ {
ConLog.Error("cellVdecGetPicItem: unsupported time_base.den (%d)", vdec->ctx->time_base.den); LOGF_ERROR(HLE, "cellVdecGetPicItem: unsupported time_base.den (%d)", vdec->ctx->time_base.den);
Emu.Pause(); Emu.Pause();
} }
} }
else else
{ {
ConLog.Error("cellVdecGetPicItem: unsupported time_base.num (%d)", vdec->ctx->time_base.num); LOGF_ERROR(HLE, "cellVdecGetPicItem: unsupported time_base.num (%d)", vdec->ctx->time_base.num);
Emu.Pause(); Emu.Pause();
} }
avc->fixed_frame_rate_flag = true; avc->fixed_frame_rate_flag = true;

8
rpcs3/Emu/SysCalls/Modules/cellVdec.h
View File

@ -741,14 +741,14 @@ public:
AVCodec* codec = avcodec_find_decoder(AV_CODEC_ID_H264); AVCodec* codec = avcodec_find_decoder(AV_CODEC_ID_H264);
if (!codec) if (!codec)
{ {
ConLog.Error("VideoDecoder(): avcodec_find_decoder(H264) failed"); LOGF_ERROR(HLE, "VideoDecoder(): avcodec_find_decoder(H264) failed");
Emu.Pause(); Emu.Pause();
return; return;
} }
fmt = avformat_alloc_context(); fmt = avformat_alloc_context();
if (!fmt) if (!fmt)
{ {
ConLog.Error("VideoDecoder(): avformat_alloc_context failed"); LOGF_ERROR(HLE, "VideoDecoder(): avformat_alloc_context failed");
Emu.Pause(); Emu.Pause();
return; return;
} }
@ -756,7 +756,7 @@ public:
fmt->pb = avio_alloc_context(io_buf, 4096, 0, this, vdecRead, NULL, NULL); fmt->pb = avio_alloc_context(io_buf, 4096, 0, this, vdecRead, NULL, NULL);
if (!fmt->pb) if (!fmt->pb)
{ {
ConLog.Error("VideoDecoder(): avio_alloc_context failed"); LOGF_ERROR(HLE, "VideoDecoder(): avio_alloc_context failed");
Emu.Pause(); Emu.Pause();
return; return;
} }
@ -785,4 +785,4 @@ public:
avformat_free_context(fmt); avformat_free_context(fmt);
} }
} }
}; };

20
rpcs3/Emu/SysCalls/Modules/cellVpost.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"
@ -38,7 +38,7 @@ u32 vpostOpen(VpostInstance* data)
{ {
u32 id = cellVpost->GetNewId(data); u32 id = cellVpost->GetNewId(data);
ConLog.Write("*** Vpost instance created (to_rgba=%d): id = %d", data->to_rgba, id); LOGF_NOTICE(HLE, "*** Vpost instance created (to_rgba=%d): id = %d", data->to_rgba, id);
return id; return id;
} }
@ -123,15 +123,15 @@ int cellVpostExec(u32 handle, const u32 inPicBuff_addr, const mem_ptr_t<CellVpos
} }
ctrlParam->inWindow; // ignored ctrlParam->inWindow; // ignored
if (ctrlParam->inWindow.x) ConLog.Warning("*** inWindow.x = %d", (u32)ctrlParam->inWindow.x); if (ctrlParam->inWindow.x) LOGF_WARNING(HLE, "*** inWindow.x = %d", (u32)ctrlParam->inWindow.x);
if (ctrlParam->inWindow.y) ConLog.Warning("*** inWindow.y = %d", (u32)ctrlParam->inWindow.y); if (ctrlParam->inWindow.y) LOGF_WARNING(HLE, "*** inWindow.y = %d", (u32)ctrlParam->inWindow.y);
if (ctrlParam->inWindow.width != w) ConLog.Warning("*** inWindow.width = %d", (u32)ctrlParam->inWindow.width); if (ctrlParam->inWindow.width != w) LOGF_WARNING(HLE, "*** inWindow.width = %d", (u32)ctrlParam->inWindow.width);
if (ctrlParam->inWindow.height != h) ConLog.Warning("*** inWindow.height = %d", (u32)ctrlParam->inWindow.height); if (ctrlParam->inWindow.height != h) LOGF_WARNING(HLE, "*** inWindow.height = %d", (u32)ctrlParam->inWindow.height);
ctrlParam->outWindow; // ignored ctrlParam->outWindow; // ignored
if (ctrlParam->outWindow.x) ConLog.Warning("*** outWindow.x = %d", (u32)ctrlParam->outWindow.x); if (ctrlParam->outWindow.x) LOGF_WARNING(HLE, "*** outWindow.x = %d", (u32)ctrlParam->outWindow.x);
if (ctrlParam->outWindow.y) ConLog.Warning("*** outWindow.y = %d", (u32)ctrlParam->outWindow.y); if (ctrlParam->outWindow.y) LOGF_WARNING(HLE, "*** outWindow.y = %d", (u32)ctrlParam->outWindow.y);
if (ctrlParam->outWindow.width != ow) ConLog.Warning("*** outWindow.width = %d", (u32)ctrlParam->outWindow.width); if (ctrlParam->outWindow.width != ow) LOGF_WARNING(HLE, "*** outWindow.width = %d", (u32)ctrlParam->outWindow.width);
if (ctrlParam->outWindow.height != oh) ConLog.Warning("*** outWindow.height = %d", (u32)ctrlParam->outWindow.height); if (ctrlParam->outWindow.height != oh) LOGF_WARNING(HLE, "*** outWindow.height = %d", (u32)ctrlParam->outWindow.height);
ctrlParam->execType; // ignored ctrlParam->execType; // ignored
ctrlParam->scalerType; // ignored ctrlParam->scalerType; // ignored
ctrlParam->ipcType; // ignored ctrlParam->ipcType; // ignored

6
rpcs3/Emu/SysCalls/Modules/libmixer.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"
@ -241,7 +241,7 @@ int cellSurMixerStart()
{ {
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
ConLog.Warning("Surmixer aborted"); LOG_WARNING(HLE, "Surmixer aborted");
return; return;
} }
@ -953,4 +953,4 @@ void libmixer_init()
REG_SUB_EMPTY(libmixer, "surmxUti", cellSurMixerUtilGetLevelFromDB); REG_SUB_EMPTY(libmixer, "surmxUti", cellSurMixerUtilGetLevelFromDB);
REG_SUB_EMPTY(libmixer, "surmxUti", cellSurMixerUtilGetLevelFromDBIndex); REG_SUB_EMPTY(libmixer, "surmxUti", cellSurMixerUtilGetLevelFromDBIndex);
REG_SUB_EMPTY(libmixer, "surmxUti", cellSurMixerUtilNoteToRatio); REG_SUB_EMPTY(libmixer, "surmxUti", cellSurMixerUtilNoteToRatio);
} }

2
rpcs3/Emu/SysCalls/Modules/sceNp.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"

4
rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"
@ -361,7 +361,7 @@ int sceNpTrophyGetTrophyUnlockState(u32 context, u32 handle, mem_ptr_t<SceNpTrop
sceNpTrophyInternalContext& ctxt = s_npTrophyInstance.contexts[context]; sceNpTrophyInternalContext& ctxt = s_npTrophyInstance.contexts[context];
count = ctxt.tropusr->GetTrophiesCount(); count = ctxt.tropusr->GetTrophiesCount();
if (count.GetValue() > 128) if (count.GetValue() > 128)
ConLog.Warning("sceNpTrophyGetTrophyUnlockState: More than 128 trophies detected!"); LOG_WARNING(HLE, "sceNpTrophyGetTrophyUnlockState: More than 128 trophies detected!");
// Pack up to 128 bools in u32 flag_bits[4] // Pack up to 128 bools in u32 flag_bits[4]
for (u32 id=0; id<count.GetValue(); id++) for (u32 id=0; id<count.GetValue(); id++)

2
rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"

8
rpcs3/Emu/SysCalls/Modules/sys_fs.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"
@ -149,7 +149,7 @@ void fsAioRead(u32 fd, mem_ptr_t<CellFsAio> aio, int xid, mem_func_ptr_t<void (*
Sleep(1); Sleep(1);
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
ConLog.Warning("fsAioRead() aborted"); LOG_WARNING(HLE, "fsAioRead() aborted");
return; return;
} }
} }
@ -209,7 +209,7 @@ void fsAioRead(u32 fd, mem_ptr_t<CellFsAio> aio, int xid, mem_func_ptr_t<void (*
fin: fin:
file.Seek(old_pos); file.Seek(old_pos);
ConLog.Warning("*** fsAioRead(fd=%d, offset=0x%llx, buf_addr=0x%x, size=0x%x, error=0x%x, res=0x%x, xid=0x%x [%s])", LOGF_WARNING(HLE, "*** fsAioRead(fd=%d, offset=0x%llx, buf_addr=0x%x, size=0x%x, error=0x%x, res=0x%x, xid=0x%x [%s])",
fd, (u64)aio->offset, buf_addr, (u64)aio->size, error, res, xid, orig_file->GetPath().c_str()); fd, (u64)aio->offset, buf_addr, (u64)aio->size, error, res, xid, orig_file->GetPath().c_str());
if (func) // start callback thread if (func) // start callback thread
@ -223,7 +223,7 @@ fin:
Sleep(1); Sleep(1);
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
ConLog.Warning("fsAioRead() aborted"); LOGF_WARNING(HLE, "fsAioRead() aborted");
break; break;
} }
}*/ }*/

2
rpcs3/Emu/SysCalls/Modules/sys_io.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"

2
rpcs3/Emu/SysCalls/Modules/sys_net.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"

20
rpcs3/Emu/SysCalls/Static.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"
@ -54,14 +54,14 @@ void StaticFuncManager::StaticAnalyse(void* ptr, u32 size, u32 base)
k--; k--;
if (can_skip) // cannot define this behaviour properly if (can_skip) // cannot define this behaviour properly
{ {
ConLog.Warning("StaticAnalyse(): can_skip = %d (unchanged)", can_skip); LOGF_WARNING(LOADER, "StaticAnalyse(): can_skip = %d (unchanged)", can_skip);
} }
} }
else else
{ {
if (can_skip) // cannot define this behaviour properly if (can_skip) // cannot define this behaviour properly
{ {
ConLog.Warning("StaticAnalyse(): can_skip = %d (set to 0)", can_skip); LOGF_WARNING(LOADER, "StaticAnalyse(): can_skip = %d (set to 0)", can_skip);
can_skip = 0; can_skip = 0;
} }
} }
@ -85,7 +85,7 @@ void StaticFuncManager::StaticAnalyse(void* ptr, u32 size, u32 base)
} }
if (found) if (found)
{ {
ConLog.Write("Function '%s' hooked (addr=0x%x)", m_static_funcs_list[j]->name, i * 4 + base); LOGF_NOTICE(LOADER, "Function '%s' hooked (addr=0x%x)", m_static_funcs_list[j]->name, i * 4 + base);
m_static_funcs_list[j]->found++; m_static_funcs_list[j]->found++;
data[i+0] = re32(0x39600000 | j); // li r11, j data[i+0] = re32(0x39600000 | j); // li r11, j
data[i+1] = se32(0x44000003); // sc 3 data[i+1] = se32(0x44000003); // sc 3
@ -129,7 +129,7 @@ void StaticFuncManager::StaticAnalyse(void* ptr, u32 size, u32 base)
if (count == 0) if (count == 0)
{ {
res |= GSR_MISSING; res |= GSR_MISSING;
ConLog.Error("Function '%s' not found", m_static_funcs_list[j]->name); LOGF_ERROR(LOADER, "Function '%s' not found", m_static_funcs_list[j]->name);
} }
else if (count > 1) else if (count > 1)
{ {
@ -146,7 +146,7 @@ void StaticFuncManager::StaticAnalyse(void* ptr, u32 size, u32 base)
if (m_static_funcs_list[k]->found) if (m_static_funcs_list[k]->found)
{ {
res |= GSR_EXCESS; res |= GSR_EXCESS;
ConLog.Error("Function '%s' hooked twice", m_static_funcs_list[j]->name); LOGF_ERROR(LOADER, "Function '%s' hooked twice", m_static_funcs_list[j]->name);
} }
} }
} }
@ -154,7 +154,7 @@ void StaticFuncManager::StaticAnalyse(void* ptr, u32 size, u32 base)
else else
{ {
res |= GSR_EXCESS; res |= GSR_EXCESS;
ConLog.Error("Function '%s' hooked twice", m_static_funcs_list[j]->name); LOGF_ERROR(LOADER, "Function '%s' hooked twice", m_static_funcs_list[j]->name);
} }
} }
@ -170,11 +170,11 @@ void StaticFuncManager::StaticAnalyse(void* ptr, u32 size, u32 base)
if (res == GSR_SUCCESS) if (res == GSR_SUCCESS)
{ {
ConLog.Success("Function group [%s] successfully hooked", std::string(name, 9).c_str()); LOGF_SUCCESS(LOADER, "Function group [%s] successfully hooked", std::string(name, 9).c_str());
} }
else else
{ {
ConLog.Error("Function group [%s] failed:%s%s", std::string(name, 9).c_str(), LOGF_ERROR(LOADER, "Function group [%s] failed:%s%s", std::string(name, 9).c_str(),
(res & GSR_MISSING ? " missing;" : ""), (res & GSR_MISSING ? " missing;" : ""),
(res & GSR_EXCESS ? " excess;" : "")); (res & GSR_EXCESS ? " excess;" : ""));
} }
@ -190,7 +190,7 @@ void StaticFuncManager::StaticExecute(u32 code)
} }
else else
{ {
ConLog.Error("StaticExecute(%d): unknown function or illegal opcode", code); LOGF_ERROR(LOADER, "StaticExecute(%d): unknown function or illegal opcode", code);
} }
} }

12
rpcs3/Emu/SysCalls/SysCalls.cpp
View File

@ -1,5 +1,5 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/ConLog.h" #include "Utilities/Log.h"
#include "Emu/Memory/Memory.h" #include "Emu/Memory/Memory.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/Cell/PPUThread.h" #include "Emu/Cell/PPUThread.h"
@ -553,7 +553,7 @@ void default_syscall()
{ {
//tty //tty
case 988: case 988:
ConLog.Warning("SysCall 988! r3: 0x%llx, r4: 0x%llx, pc: 0x%llx", LOGF_WARNING(HLE, "SysCall 988! r3: 0x%llx, r4: 0x%llx, pc: 0x%llx",
CPU.GPR[3], CPU.GPR[4], CPU.PC); CPU.GPR[3], CPU.GPR[4], CPU.PC);
RESULT(0); RESULT(0);
return; return;
@ -561,16 +561,16 @@ void default_syscall()
case 999: case 999:
dump_enable = !dump_enable; dump_enable = !dump_enable;
Emu.Pause(); Emu.Pause();
ConLog.Warning("Dump %s", (dump_enable ? "enabled" : "disabled")); LOGF_WARNING(HLE, "Dump %s", (dump_enable ? "enabled" : "disabled"));
return; return;
case 1000: case 1000:
Ini.HLELogging.SetValue(!Ini.HLELogging.GetValue()); Ini.HLELogging.SetValue(!Ini.HLELogging.GetValue());
ConLog.Warning("Log %s", (Ini.HLELogging.GetValue() ? "enabled" : "disabled")); LOGF_WARNING(HLE, "Log %s", (Ini.HLELogging.GetValue() ? "enabled" : "disabled"));
return; return;
} }
ConLog.Error("Unknown syscall: %d - %08x", code, code); LOGF_ERROR(HLE, "Unknown syscall: %d - %08x", code, code);
RESULT(0); RESULT(0);
return; return;
} }
@ -589,7 +589,7 @@ void SysCalls::DoSyscall(u32 code)
} }
ConLog.Error("TODO: %s", GetHLEFuncName(code).c_str()); LOGF_ERROR(HLE, "TODO: %s", GetHLEFuncName(code).c_str());
declCPU(); declCPU();
RESULT(0); RESULT(0);
} }

Some files were not shown because too many files have changed in this diff Show More