mirror/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2025-04-18 05:42:52 +00:00
Code Issues Packages Projects Releases Wiki Activity

Demuxer improved + MSVC thread name registrering

Browse Source
This commit is contained in:
Nekotekina 2014-12-05 19:12:15 +03:00
parent 8cb8298c03
commit eb7cd7ccce
3 changed files with 105 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
Utilities/Thread.cpp
View File

@ -3,6 +3,38 @@
#include "Log.h" #include "Log.h"
#include "Thread.h" #include "Thread.h"
#ifdef _WIN32
#include <windows.h>
#endif
void SetCurrentThreadDebugName(const char* threadName)
{
#ifdef _WIN32 // this is VS-specific way to set thread names for the debugger
#pragma pack(push,8)
struct THREADNAME_INFO
{
DWORD dwType;
LPCSTR szName;
DWORD dwThreadID;
DWORD dwFlags;
} info;
#pragma pack(pop)
info.dwType = 0x1000;
info.szName = threadName;
info.dwThreadID = -1;
info.dwFlags = 0;
__try
{
RaiseException(0x406D1388, 0, sizeof(info) / sizeof(ULONG_PTR), (ULONG_PTR*)&info);
}
__except (EXCEPTION_EXECUTE_HANDLER)
{
}
#endif
}
thread_local NamedThreadBase* g_tls_this_thread = nullptr; thread_local NamedThreadBase* g_tls_this_thread = nullptr;
std::atomic<u32> g_thread_count(0); std::atomic<u32> g_thread_count(0);
@ -85,6 +117,8 @@ void ThreadBase::Start()
m_executor = new std::thread([this]() m_executor = new std::thread([this]()
{ {
SetCurrentThreadDebugName(GetThreadName().c_str());
SetCurrentNamedThread(this); SetCurrentNamedThread(this);
g_thread_count++; g_thread_count++;
@ -172,6 +206,8 @@ void thread::start(std::function<void()> func)
m_thr = std::thread([func, name]() m_thr = std::thread([func, name]()
{ {
SetCurrentThreadDebugName(name.c_str());
NamedThreadBase info(name); NamedThreadBase info(name);
SetCurrentNamedThread(&info); SetCurrentNamedThread(&info);
g_thread_count++; g_thread_count++;

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

@ -58,23 +58,27 @@ PesHeader::PesHeader(DemuxerStream& stream)
} }
} }
bool ElementaryStream::is_full() bool ElementaryStream::is_full(u32 space)
{ {
if (released < put_count) if (released < put_count)
{ {
u32 first; if (entries.IsFull())
if (!entries.Peek(first, &dmux->is_closed))
{ {
return false; return true;
} }
u32 first; assert(entries.Peek(first, &sq_no_wait));
if (first >= put) if (first >= put)
{ {
return (first - put) < GetMaxAU(); return first - put < space + 128;
}
else if (put + space + 128 > memAddr + memSize)
{
return first - memAddr < space + 128;
} }
else else
{ {
// probably, always false return false;
return (put + GetMaxAU()) > (memAddr + memSize);
} }
} }
else else
@ -83,21 +87,10 @@ bool ElementaryStream::is_full()
} }
} }
const u32 ElementaryStream::GetMaxAU() const bool ElementaryStream::isfull(u32 space)
{
return (fidMajor == 0xbd) ? 4096 : 640 * 1024 + 128; // TODO
}
bool ElementaryStream::hasunseen()
{ {
std::lock_guard<std::mutex> lock(m_mutex); std::lock_guard<std::mutex> lock(m_mutex);
return peek_count < put_count; return is_full(space);
}
bool ElementaryStream::isfull()
{
std::lock_guard<std::mutex> lock(m_mutex);
return is_full() || entries.IsFull();
} }
void ElementaryStream::push_au(u32 size, u64 dts, u64 pts, u64 userdata, bool rap, u32 specific) void ElementaryStream::push_au(u32 size, u64 dts, u64 pts, u64 userdata, bool rap, u32 specific)
@ -106,13 +99,18 @@ void ElementaryStream::push_au(u32 size, u64 dts, u64 pts, u64 userdata, bool ra
{ {
std::lock_guard<std::mutex> lock(m_mutex); std::lock_guard<std::mutex> lock(m_mutex);
if (is_full()) if (is_full(size))
{ {
cellDmux->Error("es::push_au(): buffer is full"); cellDmux->Error("es::push_au(): buffer is full");
Emu.Pause(); Emu.Pause();
return; return;
} }
if (put + size + 128 > memAddr + memSize)
{
put = memAddr;
}
memcpy(vm::get_ptr<void>(put + 128), raw_data.data(), size); memcpy(vm::get_ptr<void>(put + 128), raw_data.data(), size);
raw_data.erase(raw_data.begin(), raw_data.begin() + size); raw_data.erase(raw_data.begin(), raw_data.begin() + size);
@ -142,10 +140,7 @@ void ElementaryStream::push_au(u32 size, u64 dts, u64 pts, u64 userdata, bool ra
addr = put; addr = put;
u32 new_addr = a128(put + 128 + size); put = a128(put + 128 + size);
put = ((new_addr + GetMaxAU()) > (memAddr + memSize)) ? memAddr : new_addr;
size = 0;
put_count++; put_count++;
} }
@ -170,92 +165,61 @@ void ElementaryStream::push(DemuxerStream& stream, u32 size)
bool ElementaryStream::release() bool ElementaryStream::release()
{ {
std::lock_guard<std::mutex> lock(m_mutex); std::lock_guard<std::mutex> lock(m_mutex);
//if (fidMajor != 0xbd) LOG_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)
{ {
cellDmux->Error("es::release(): buffer is empty"); cellDmux->Error("es::release(): buffer is empty");
Emu.Pause(); Emu.Pause();
return false; return false;
} }
if (released >= got_count)
u32 addr;
if (!entries.Peek(addr, &dmux->is_closed))
{
return false; // ???
}
auto info = vm::ptr<CellDmuxAuInfo>::make(addr);
//if (fidMajor != 0xbd) LOG_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);
if (released >= peek_count)
{ {
cellDmux->Error("es::release(): buffer has not been seen yet"); cellDmux->Error("es::release(): buffer has not been seen yet");
Emu.Pause(); Emu.Pause();
return false; return false;
} }
u32 addr; assert(entries.Pop(addr, &sq_no_wait));
released++; released++;
if (!entries.Pop(addr, &sq_no_wait))
{
cellDmux->Error("es::release(): entries.Pop() aborted (no entries found)");
Emu.Pause();
return false;
}
//if (fidMajor != 0xbd) LOG_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 ElementaryStream::peek(u32& out_data, bool no_ex, u32& out_spec, bool update_index) bool ElementaryStream::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) LOG_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);
if (peek_count >= put_count) return false;
if (peek_count < released) if (got_count < released)
{ {
cellDmux->Error("es::peek(): sequence error: peek_count < released (peek_count=%d, released=%d)", peek_count, released); cellDmux->Error("es::peek() error: got_count(%d) < released(%d) (put_count=%d)", got_count, released, put_count);
Emu.Pause(); Emu.Pause();
return false; return false;
} }
u32 addr; if (got_count >= put_count)
if (!entries.Peek(addr, &dmux->is_closed, peek_count - released))
{ {
return false; // ??? return false;
} }
auto info = vm::ptr<CellDmuxAuInfo>::make(addr); u32 addr; assert(entries.Peek(addr, &sq_no_wait, got_count - released));
//if (fidMajor != 0xbd) LOG_WARNING(HLE, "es::peek(%sAu(Ex)): (%s) size = 0x%x, info = 0x%x, pts = 0x%x", out_data = no_ex ? addr + 64 : addr;
//wxString(update_index ? "Get" : "Peek").wx_str(),
//wxString(fidMajor == 0xbd ? "ATRAC3P Audio" : "Video AVC").wx_str(), (u32)info->auSize, peek, (u32)info->ptsLower);
out_data = addr;
out_spec = out_data + sizeof(CellDmuxAuInfoEx); out_spec = out_data + sizeof(CellDmuxAuInfoEx);
if (no_ex) out_data += 64;
if (update_index) if (update_index)
{ {
peek_count++; got_count++;
} }
//if (fidMajor != 0xbd) LOG_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);
return true; return true;
} }
void ElementaryStream::reset() void ElementaryStream::reset()
{ {
std::lock_guard<std::mutex> lock(m_mutex); std::lock_guard<std::mutex> lock(m_mutex);
//first = 0;
//peek = 0;
put = memAddr; put = memAddr;
//size = 0;
entries.Clear(); entries.Clear();
put_count = 0; put_count = 0;
got_count = 0;
released = 0; released = 0;
peek_count = 0; raw_data.clear();
raw_pos = 0;
} }
void dmuxQueryAttr(u32 info_addr /* may be 0 */, vm::ptr<CellDmuxAttr> attr) void dmuxQueryAttr(u32 info_addr /* may be 0 */, vm::ptr<CellDmuxAttr> attr)
@ -382,7 +346,7 @@ u32 dmuxOpen(Demuxer* data)
if (esATX[ch]) if (esATX[ch])
{ {
ElementaryStream& es = *esATX[ch]; ElementaryStream& es = *esATX[ch];
if (es.isfull()) if (es.raw_data.size() > 1024 * 1024)
{ {
stream = backup; stream = backup;
std::this_thread::sleep_for(std::chrono::milliseconds(1)); std::this_thread::sleep_for(std::chrono::milliseconds(1));
@ -392,9 +356,15 @@ u32 dmuxOpen(Demuxer* data)
stream.skip(4); stream.skip(4);
len -= 4; len -= 4;
if (pes.has_ts)
{
es.last_dts = pes.dts;
es.last_pts = pes.pts;
}
es.push(stream, len - pes.size - 3); es.push(stream, len - pes.size - 3);
while (!es.isfull()) while (true)
{ {
auto const size = es.raw_data.size() - es.raw_pos; // size of available new data auto const size = es.raw_data.size() - es.raw_pos; // size of available new data
auto const data = es.raw_data.data() + es.raw_pos; // pointer to available data auto const data = es.raw_data.data() + es.raw_pos; // pointer to available data
@ -411,8 +381,10 @@ u32 dmuxOpen(Demuxer* data)
u32 frame_size = ((((u32)data[2] & 0x3) << 8) | (u32)data[3]) * 8 + 8; u32 frame_size = ((((u32)data[2] & 0x3) << 8) | (u32)data[3]) * 8 + 8;
if (size < frame_size + 8) break; // skip non-complete AU if (size < frame_size + 8) break; // skip non-complete AU
if (es.isfull(frame_size + 8)) break; // skip if cannot push AU
es.push_au(frame_size + 8, pes.dts, pes.pts, stream.userdata, true /* TODO: set correct value */, 0); es.push_au(frame_size + 8, es.last_dts, es.last_pts, stream.userdata, false /* TODO: set correct value */, 0);
auto esMsg = vm::ptr<CellDmuxEsMsg>::make(a128(dmux.memAddr) + (cb_add ^= 16)); auto esMsg = vm::ptr<CellDmuxEsMsg>::make(a128(dmux.memAddr) + (cb_add ^= 16));
esMsg->msgType = CELL_DMUX_ES_MSG_TYPE_AU_FOUND; esMsg->msgType = CELL_DMUX_ES_MSG_TYPE_AU_FOUND;
@ -437,28 +409,24 @@ u32 dmuxOpen(Demuxer* data)
if (esAVC[ch]) if (esAVC[ch])
{ {
ElementaryStream& es = *esAVC[ch]; ElementaryStream& es = *esAVC[ch];
if (es.isfull())
{
std::this_thread::sleep_for(std::chrono::milliseconds(1));
continue;
}
DemuxerStream backup = stream; DemuxerStream backup = stream;
stream.skip(4); stream.skip(4);
stream.get(len); stream.get(len);
PesHeader pes(stream); PesHeader pes(stream);
if (es.isfull()) const u32 old_size = (u32)es.raw_data.size();
if (es.isfull(old_size))
{ {
stream = backup; stream = backup;
std::this_thread::sleep_for(std::chrono::milliseconds(1)); std::this_thread::sleep_for(std::chrono::milliseconds(1));
continue; continue;
} }
if (pes.has_ts && es.raw_data.size()) if ((pes.has_ts && old_size) || old_size >= 0x70000)
{ {
es.push_au((u32)es.raw_data.size(), es.last_dts, es.last_pts, stream.userdata, false /* TODO: set correct value */, 0); // push AU if it becomes too big or the next packet contains ts data
es.push_au(old_size, es.last_dts, es.last_pts, stream.userdata, false /* TODO: set correct value */, 0);
// callback // callback
auto esMsg = vm::ptr<CellDmuxEsMsg>::make(a128(dmux.memAddr) + (cb_add ^= 16)); auto esMsg = vm::ptr<CellDmuxEsMsg>::make(a128(dmux.memAddr) + (cb_add ^= 16));
@ -474,7 +442,7 @@ u32 dmuxOpen(Demuxer* data)
es.last_pts = pes.pts; es.last_pts = pes.pts;
} }
//reconstruction of MPEG2-PS stream for vdec module // reconstruction of MPEG2-PS stream for vdec module
const u32 size = len + 6 /*- pes.size - 3*/; const u32 size = len + 6 /*- pes.size - 3*/;
stream = backup; stream = backup;
es.push(stream, size); es.push(stream, size);
@ -615,10 +583,18 @@ u32 dmuxOpen(Demuxer* data)
{ {
ElementaryStream& es = *task.es.es_ptr; ElementaryStream& es = *task.es.es_ptr;
if (es.raw_data.size()) const u32 old_size = (u32)es.raw_data.size();
if (old_size && (es.fidMajor & 0xf0) == 0xe0)
{ {
// TODO (it's only for AVC, but may cause problems with ATX) // TODO (it's only for AVC, some ATX data may be lost)
es.push_au((u32)es.raw_data.size(), es.last_dts, es.last_pts, stream.userdata, false, 0); while (es.isfull(old_size))
{
if (Emu.IsStopped() || dmux.is_closed) break;
std::this_thread::sleep_for(std::chrono::milliseconds(1));
}
es.push_au(old_size, es.last_dts, es.last_pts, stream.userdata, false, 0);
// callback // callback
auto esMsg = vm::ptr<CellDmuxEsMsg>::make(a128(dmux.memAddr) + (cb_add ^= 16)); auto esMsg = vm::ptr<CellDmuxEsMsg>::make(a128(dmux.memAddr) + (cb_add ^= 16));
@ -626,6 +602,11 @@ u32 dmuxOpen(Demuxer* data)
esMsg->supplementalInfo = stream.userdata; esMsg->supplementalInfo = stream.userdata;
es.cbFunc.call(*dmux.dmuxCb, dmux.id, es.id, esMsg, es.cbArg); es.cbFunc.call(*dmux.dmuxCb, dmux.id, es.id, esMsg, es.cbArg);
} }
if (es.raw_data.size())
{
cellDmux->Error("dmuxFlushEs: 0x%x bytes lost (es_id=%d)", (u32)es.raw_data.size(), es.id);
}
// callback // callback
auto esMsg = vm::ptr<CellDmuxEsMsg>::make(a128(dmux.memAddr) + (cb_add ^= 16)); auto esMsg = vm::ptr<CellDmuxEsMsg>::make(a128(dmux.memAddr) + (cb_add ^= 16));

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

@ -438,15 +438,12 @@ class ElementaryStream
SQueue<u32> entries; // AU starting addresses SQueue<u32> entries; // AU starting addresses
u32 put_count; // number of AU written u32 put_count; // number of AU written
u32 got_count; // number of AU obtained by GetAu(Ex)
u32 released; // number of AU released u32 released; // number of AU released
u32 peek_count; // number of AU obtained by GetAu(Ex)
u32 put; // AU that is being written now u32 put; // AU that is being written now
//u32 size; // number of bytes written (after 128b header)
//u32 first; // AU that will be released
//u32 peek; // AU that will be obtained by GetAu(Ex)/PeekAu(Ex)
bool is_full(); bool is_full(u32 space);
public: public:
Demuxer* dmux; Demuxer* dmux;
@ -479,24 +476,17 @@ public:
, cbFunc(cbFunc) , cbFunc(cbFunc)
, cbArg(cbArg) , cbArg(cbArg)
, spec(spec) , spec(spec)
//, first(0)
//, peek(0)
, put(memAddr) , put(memAddr)
//, size(0)
, put_count(0) , put_count(0)
, got_count(0)
, released(0) , released(0)
, peek_count(0)
, raw_pos(0) , raw_pos(0)
, last_dts(0xffffffffffffffffull) , last_dts(0xffffffffffffffffull)
, last_pts(0xffffffffffffffffull) , last_pts(0xffffffffffffffffull)
{ {
} }
const u32 GetMaxAU() const; bool isfull(u32 space);
bool hasunseen();
bool isfull();
void push_au(u32 size, u64 dts, u64 pts, u64 userdata, bool rap, u32 specific); void push_au(u32 size, u64 dts, u64 pts, u64 userdata, bool rap, u32 specific);