void fsAio(vm::ptr<CellFsAio> aio, bool write, s32 xid, fs_aio_cb_t func)
{
cellFs.Notice("FS AIO Request(%d): fd=%d, offset=0x%llx, buf=*0x%x, size=0x%llx, user_data=0x%llx", xid, aio->fd, aio->offset, aio->buf, aio->size, aio->user_data);
s32 error = CELL_OK;
u64 result = 0;
const auto file = idm::get<lv2_file_t>(aio->fd);
if (!file || (!write && file->flags & CELL_FS_O_WRONLY) || (write && !(file->flags & CELL_FS_O_ACCMODE)))
{
error = CELL_FS_EBADF;
}
else
{
std::lock_guard<std::mutex> lock(file->mutex);
const auto old_position = file->file->Tell();
file->file->Seek(aio->offset);
result = write ? file->file->Write(aio->buf.get_ptr(), aio->size) : file->file->Read(aio->buf.get_ptr(), aio->size);
file->file->Seek(old_position);
}
// should be executed directly by FS AIO thread
Emu.GetCallbackManager().Async([=](CPUThread& ppu)
{
func(static_cast<PPUThread&>(ppu), aio, error, xid, result);
});
}
s32 cellFsSdataOpen(PPUThread& ppu, vm::cptr<char> path, s32 flags, vm::ptr<u32> fd, vm::cptr<void> arg, u64 size)
{
cellFs.Notice("cellFsSdataOpen(path=*0x%x, flags=%#o, fd=*0x%x, arg=*0x%x, size=0x%llx)", path, flags, fd, arg, size);
if (flags != CELL_FS_O_RDONLY)
{
return CELL_FS_EINVAL;
}
struct _arg_t
{
be_t<u32> a, b;
};
const vm::var<_arg_t> _arg(ppu);
_arg->a = 0x180;
_arg->b = 0x10;
return cellFsOpen(path, CELL_FS_O_RDONLY, fd, _arg, 8);
// Don't implement sdata decryption in this function, it should be done in sys_fs_open() syscall or somewhere else
/*
std::string suffix = path.substr(path.length() - 5, 5);
if (suffix != ".sdat" && suffix != ".SDAT")
return CELL_ENOTSDATA;
std::string::size_type last_slash = path.rfind('/'); //TODO: use a filesystem library to solve this more robustly
last_slash = last_slash == std::string::npos ? 0 : last_slash+1;
std::string unpacked_path = "/dev_hdd1/"+path.substr(last_slash,path.length()-last_slash)+".unpacked";
s32 ret = sdata_unpack(path, unpacked_path);
if (ret) return ret;
fd = idm::GetNewID(Emu.GetVFS().OpenFile(unpacked_path, vfsRead), TYPE_FS_FILE);
return CELL_OK;
*/
}
u32 ppu_get_tls(u32 thread)
{
if (!g_tls_start)
{
g_tls_size = Emu.GetTLSMemsz() + TLS_SYS;
g_tls_start = vm::alloc(g_tls_size * TLS_MAX, vm::main); // memory for up to TLS_MAX threads
sysPrxForUser.Notice("Thread Local Storage initialized (g_tls_start=0x%x, user_size=0x%x)\n*** TLS segment addr: 0x%08x\n*** TLS segment size: 0x%08x",
g_tls_start, Emu.GetTLSMemsz(), Emu.GetTLSAddr(), Emu.GetTLSFilesz());
}
if (!thread)
{
return 0;
}
for (u32 i = 0; i < TLS_MAX; i++)
{
if (g_tls_owners[i] == thread)
{
return g_tls_start + i * g_tls_size + TLS_SYS; // if already initialized, return TLS address
}
}
for (u32 i = 0; i < TLS_MAX; i++)
{
u32 old = 0;
if (g_tls_owners[i].compare_exchange_strong(old, thread))
{
const u32 addr = g_tls_start + i * g_tls_size + TLS_SYS; // get TLS address
memset(vm::get_ptr(addr - TLS_SYS), 0, TLS_SYS); // initialize system area with zeros
memcpy(vm::get_ptr(addr), vm::get_ptr(Emu.GetTLSAddr()), Emu.GetTLSFilesz()); // initialize from TLS image
memset(vm::get_ptr(addr + Emu.GetTLSFilesz()), 0, Emu.GetTLSMemsz() - Emu.GetTLSFilesz()); // fill the rest with zeros
return addr;
}
}
throw EXCEPTION("Out of TLS memory");
}
void dmuxOpen(u32 dmux_id) // TODO: call from the constructor
{
const auto sptr = Emu.GetIdManager().get<Demuxer>(dmux_id);
Demuxer& dmux = *sptr;
dmux.id = dmux_id;
dmux.dmuxCb = Emu.GetIdManager().make_ptr<PPUThread>(fmt::format("Demuxer[0x%x] Thread", dmux_id));
dmux.dmuxCb->prio = 1001;
dmux.dmuxCb->stack_size = 0x10000;
dmux.dmuxCb->custom_task = [sptr](PPUThread& CPU)
{
Demuxer& dmux = *sptr;
DemuxerTask task;
DemuxerStream stream = {};
ElementaryStream* esALL[96]; memset(esALL, 0, sizeof(esALL));
ElementaryStream** esAVC = &esALL[0]; // AVC (max 16 minus M2V count)
ElementaryStream** esM2V = &esALL[16]; // M2V (max 16 minus AVC count)
ElementaryStream** esDATA = &esALL[32]; // user data (max 16)
ElementaryStream** esATX = &esALL[48]; // ATRAC3+ (max 16)
ElementaryStream** esAC3 = &esALL[64]; // AC3 (max 16)
ElementaryStream** esPCM = &esALL[80]; // LPCM (max 16)
u32 cb_add = 0;
while (true)
{
if (Emu.IsStopped() || dmux.is_closed)
{
break;
}
if (!dmux.job.try_peek(task) && dmux.is_running && stream.addr)
{
// default task (demuxing) (if there is no other work)
be_t<u32> code;
be_t<u16> len;
if (!stream.peek(code))
{
// demuxing finished
dmux.is_running = false;
// callback
auto dmuxMsg = vm::ptr<CellDmuxMsg>::make(dmux.memAddr + (cb_add ^= 16));
dmuxMsg->msgType = CELL_DMUX_MSG_TYPE_DEMUX_DONE;
dmuxMsg->supplementalInfo = stream.userdata;
dmux.cbFunc(CPU, dmux.id, dmuxMsg, dmux.cbArg);
dmux.is_working = false;
stream = {};
continue;
}
switch (code.value())
{
case PACK_START_CODE:
{
if (!stream.check(14))
{
throw EXCEPTION("End of stream (PACK_START_CODE)");
}
stream.skip(14);
break;
}
case SYSTEM_HEADER_START_CODE:
{
if (!stream.check(18))
{
throw EXCEPTION("End of stream (SYSTEM_HEADER_START_CODE)");
}
stream.skip(18);
break;
}
case PADDING_STREAM:
{
if (!stream.check(6))
{
throw EXCEPTION("End of stream (PADDING_STREAM)");
}
stream.skip(4);
stream.get(len);
if (!stream.check(len))
{
throw EXCEPTION("End of stream (PADDING_STREAM, len=%d)", len);
}
stream.skip(len);
break;
}
case PRIVATE_STREAM_2:
{
if (!stream.check(6))
{
throw EXCEPTION("End of stream (PRIVATE_STREAM_2)");
}
stream.skip(4);
stream.get(len);
cellDmux.Notice("PRIVATE_STREAM_2 (%d)", len);
if (!stream.check(len))
{
throw EXCEPTION("End of stream (PRIVATE_STREAM_2, len=%d)", len);
}
stream.skip(len);
break;
}
case PRIVATE_STREAM_1:
{
// audio and user data stream
DemuxerStream backup = stream;
if (!stream.check(6))
{
throw EXCEPTION("End of stream (PRIVATE_STREAM_1)");
}
stream.skip(4);
stream.get(len);
if (!stream.check(len))
{
throw EXCEPTION("End of stream (PRIVATE_STREAM_1, len=%d)", len);
}
const PesHeader pes(stream);
if (!pes.is_ok)
{
throw EXCEPTION("PesHeader error (PRIVATE_STREAM_1, len=%d)", len);
}
if (len < pes.size + 4)
{
throw EXCEPTION("End of block (PRIVATE_STREAM_1, PesHeader + fid_minor, len=%d)", len);
}
len -= pes.size + 4;
u8 fid_minor;
if (!stream.get(fid_minor))
{
throw EXCEPTION("End of stream (PRIVATE_STREAM1, fid_minor)");
}
const u32 ch = fid_minor % 16;
if ((fid_minor & -0x10) == 0 && esATX[ch])
{
ElementaryStream& es = *esATX[ch];
if (es.raw_data.size() > 1024 * 1024)
{
stream = backup;
std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack
continue;
}
if (len < 3 || !stream.check(3))
{
throw EXCEPTION("End of block (ATX, unknown header, len=%d)", len);
}
len -= 3;
stream.skip(3);
if (pes.has_ts)
{
es.last_dts = pes.dts;
es.last_pts = pes.pts;
}
es.push(stream, len);
while (true)
{
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
if (size < 8) break; // skip if cannot read ATS header
if (data[0] != 0x0f || data[1] != 0xd0)
{
throw EXCEPTION("ATX: 0x0fd0 header not found (ats=0x%llx)", *(be_t<u64>*)data);
}
u32 frame_size = ((((u32)data[2] & 0x3) << 8) | (u32)data[3]) * 8 + 8;
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, es.last_dts, es.last_pts, stream.userdata, false /* TODO: set correct value */, 0);
//cellDmux.Notice("ATX AU pushed (ats=0x%llx, frame_size=%d)", *(be_t<u64>*)data, frame_size);
auto esMsg = vm::ptr<CellDmuxEsMsg>::make(dmux.memAddr + (cb_add ^= 16));
esMsg->msgType = CELL_DMUX_ES_MSG_TYPE_AU_FOUND;
esMsg->supplementalInfo = stream.userdata;
es.cbFunc(CPU, dmux.id, es.id, esMsg, es.cbArg);
}
}
else
{
cellDmux.Notice("PRIVATE_STREAM_1 (len=%d, fid_minor=0x%x)", len, fid_minor);
stream.skip(len);
}
break;
}
case 0x1e0: case 0x1e1: case 0x1e2: case 0x1e3:
case 0x1e4: case 0x1e5: case 0x1e6: case 0x1e7:
case 0x1e8: case 0x1e9: case 0x1ea: case 0x1eb:
case 0x1ec: case 0x1ed: case 0x1ee: case 0x1ef:
{
// video stream (AVC or M2V)
DemuxerStream backup = stream;
if (!stream.check(6))
{
throw EXCEPTION("End of stream (video, code=0x%x)", code);
}
stream.skip(4);
stream.get(len);
if (!stream.check(len))
{
throw EXCEPTION("End of stream (video, code=0x%x, len=%d)", code, len);
}
const PesHeader pes(stream);
if (!pes.is_ok)
{
throw EXCEPTION("PesHeader error (video, code=0x%x, len=%d)", code, len);
}
if (len < pes.size + 3)
{
throw EXCEPTION("End of block (video, code=0x%x, PesHeader)", code);
}
len -= pes.size + 3;
const u32 ch = code % 16;
if (esAVC[ch])
{
ElementaryStream& es = *esAVC[ch];
const u32 old_size = (u32)es.raw_data.size();
if (es.isfull(old_size))
{
stream = backup;
std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack
continue;
}
if ((pes.has_ts && old_size) || old_size >= 0x69800)
{
// push AU if it becomes too big or the next packet contains PTS/DTS
es.push_au(old_size, es.last_dts, es.last_pts, stream.userdata, false /* TODO: set correct value */, 0);
// callback
auto esMsg = vm::ptr<CellDmuxEsMsg>::make(dmux.memAddr + (cb_add ^= 16));
esMsg->msgType = CELL_DMUX_ES_MSG_TYPE_AU_FOUND;
esMsg->supplementalInfo = stream.userdata;
es.cbFunc(CPU, dmux.id, es.id, esMsg, es.cbArg);
}
if (pes.has_ts)
{
// preserve dts/pts for next AU
es.last_dts = pes.dts;
es.last_pts = pes.pts;
}
// reconstruction of MPEG2-PS stream for vdec module
const u32 size = len + pes.size + 9;
stream = backup;
es.push(stream, size);
}
else
{
cellDmux.Notice("Video stream (code=0x%x, len=%d)", code, len);
stream.skip(len);
}
break;
}
default:
{
if ((code & PACKET_START_CODE_MASK) == PACKET_START_CODE_PREFIX)
{
throw EXCEPTION("Unknown code found (0x%x)", code);
}
// search
stream.skip(1);
}
}
continue;
}
// wait for task if no work
if (!dmux.job.pop(task, &dmux.is_closed))
{
break; // Emu is stopped
}
switch (task.type)
{
case dmuxSetStream:
{
if (task.stream.discontinuity)
{
cellDmux.Warning("dmuxSetStream (beginning)");
for (u32 i = 0; i < sizeof(esALL) / sizeof(esALL[0]); i++)
{
if (esALL[i])
{
esALL[i]->reset();
}
}
}
stream = task.stream;
//LOG_NOTICE(HLE, "*** stream updated(addr=0x%x, size=0x%x, discont=%d, userdata=0x%llx)",
//stream.addr, stream.size, stream.discontinuity, stream.userdata);
break;
}
case dmuxResetStream:
case dmuxResetStreamAndWaitDone:
{
// demuxing stopped
if (dmux.is_running.exchange(false))
{
// callback
auto dmuxMsg = vm::ptr<CellDmuxMsg>::make(dmux.memAddr + (cb_add ^= 16));
dmuxMsg->msgType = CELL_DMUX_MSG_TYPE_DEMUX_DONE;
dmuxMsg->supplementalInfo = stream.userdata;
dmux.cbFunc(CPU, dmux.id, dmuxMsg, dmux.cbArg);
stream = {};
dmux.is_working = false;
}
break;
}
case dmuxEnableEs:
{
ElementaryStream& es = *task.es.es_ptr;
// TODO: uncomment when ready to use
if ((es.fidMajor & -0x10) == 0xe0 && es.fidMinor == 0 && es.sup1 == 1 && !es.sup2)
{
esAVC[es.fidMajor % 16] = task.es.es_ptr;
}
//else if ((es.fidMajor & -0x10) == 0xe0 && es.fidMinor == 0 && !es.sup1 && !es.sup2)
//{
// esM2V[es.fidMajor % 16] = task.es.es_ptr;
//}
else if (es.fidMajor == 0xbd && (es.fidMinor & -0x10) == 0 && !es.sup1 && !es.sup2)
{
esATX[es.fidMinor % 16] = task.es.es_ptr;
}
//else if (es.fidMajor == 0xbd && (es.fidMinor & -0x10) == 0x20 && !es.sup1 && !es.sup2)
//{
// esDATA[es.fidMinor % 16] = task.es.es_ptr;
//}
//else if (es.fidMajor == 0xbd && (es.fidMinor & -0x10) == 0x30 && !es.sup1 && !es.sup2)
//{
// esAC3[es.fidMinor % 16] = task.es.es_ptr;
//}
//else if (es.fidMajor == 0xbd && (es.fidMinor & -0x10) == 0x40 && !es.sup1 && !es.sup2)
//{
// esPCM[es.fidMinor % 16] = task.es.es_ptr;
//}
else
{
throw EXCEPTION("dmuxEnableEs: unknown filter (0x%x, 0x%x, 0x%x, 0x%x)", es.fidMajor, es.fidMinor, es.sup1, es.sup2);
}
es.dmux = &dmux;
break;
}
case dmuxDisableEs:
{
ElementaryStream& es = *task.es.es_ptr;
if (es.dmux != &dmux)
{
throw EXCEPTION("dmuxDisableEs: invalid elementary stream");
}
for (u32 i = 0; i < sizeof(esALL) / sizeof(esALL[0]); i++)
{
if (esALL[i] == &es)
{
esALL[i] = nullptr;
}
}
es.dmux = nullptr;
Emu.GetIdManager().remove<ElementaryStream>(task.es.es);
break;
}
case dmuxFlushEs:
{
ElementaryStream& es = *task.es.es_ptr;
const u32 old_size = (u32)es.raw_data.size();
if (old_size && (es.fidMajor & -0x10) == 0xe0)
{
// TODO (it's only for AVC, some ATX data may be lost)
while (es.isfull(old_size))
{
if (Emu.IsStopped() || dmux.is_closed) break;
std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack
}
es.push_au(old_size, es.last_dts, es.last_pts, stream.userdata, false, 0);
// callback
auto esMsg = vm::ptr<CellDmuxEsMsg>::make(dmux.memAddr + (cb_add ^= 16));
esMsg->msgType = CELL_DMUX_ES_MSG_TYPE_AU_FOUND;
esMsg->supplementalInfo = stream.userdata;
es.cbFunc(CPU, 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
auto esMsg = vm::ptr<CellDmuxEsMsg>::make(dmux.memAddr + (cb_add ^= 16));
esMsg->msgType = CELL_DMUX_ES_MSG_TYPE_FLUSH_DONE;
esMsg->supplementalInfo = stream.userdata;
es.cbFunc(CPU, dmux.id, es.id, esMsg, es.cbArg);
break;
}
case dmuxResetEs:
{
task.es.es_ptr->reset();
break;
}
case dmuxClose:
{
break;
}
default:
{
throw EXCEPTION("Demuxer thread error: unknown task (0x%x)", task.type);
}
}
}
dmux.is_finished = true;
};
dmux.dmuxCb->run();
dmux.dmuxCb->exec();
}
s32 cellVpostExec(u32 handle, vm::cptr<u8> inPicBuff, vm::cptr<CellVpostCtrlParam> ctrlParam, vm::ptr<u8> outPicBuff, vm::ptr<CellVpostPictureInfo> picInfo)
{
cellVpost.Log("cellVpostExec(handle=0x%x, inPicBuff=*0x%x, ctrlParam=*0x%x, outPicBuff=*0x%x, picInfo=*0x%x)", handle, inPicBuff, ctrlParam, outPicBuff, picInfo);
const auto vpost = Emu.GetIdManager().get<VpostInstance>(handle);
if (!vpost)
{
return CELL_VPOST_ERROR_E_ARG_HDL_INVALID;
}
s32 w = ctrlParam->inWidth;
u32 h = ctrlParam->inHeight;
u32 ow = ctrlParam->outWidth;
u32 oh = ctrlParam->outHeight;
ctrlParam->inWindow; // ignored
if (ctrlParam->inWindow.x) cellVpost.Notice("*** inWindow.x = %d", (u32)ctrlParam->inWindow.x);
if (ctrlParam->inWindow.y) cellVpost.Notice("*** inWindow.y = %d", (u32)ctrlParam->inWindow.y);
if (ctrlParam->inWindow.width != w) cellVpost.Notice("*** inWindow.width = %d", (u32)ctrlParam->inWindow.width);
if (ctrlParam->inWindow.height != h) cellVpost.Notice("*** inWindow.height = %d", (u32)ctrlParam->inWindow.height);
ctrlParam->outWindow; // ignored
if (ctrlParam->outWindow.x) cellVpost.Notice("*** outWindow.x = %d", (u32)ctrlParam->outWindow.x);
if (ctrlParam->outWindow.y) cellVpost.Notice("*** outWindow.y = %d", (u32)ctrlParam->outWindow.y);
if (ctrlParam->outWindow.width != ow) cellVpost.Notice("*** outWindow.width = %d", (u32)ctrlParam->outWindow.width);
if (ctrlParam->outWindow.height != oh) cellVpost.Notice("*** outWindow.height = %d", (u32)ctrlParam->outWindow.height);
ctrlParam->execType; // ignored
ctrlParam->scalerType; // ignored
ctrlParam->ipcType; // ignored
picInfo->inWidth = w; // copy
picInfo->inHeight = h; // copy
picInfo->inDepth = CELL_VPOST_PIC_DEPTH_8; // fixed
picInfo->inScanType = CELL_VPOST_SCAN_TYPE_P; // TODO
picInfo->inPicFmt = CELL_VPOST_PIC_FMT_IN_YUV420_PLANAR; // fixed
picInfo->inChromaPosType = ctrlParam->inChromaPosType; // copy
picInfo->inPicStruct = CELL_VPOST_PIC_STRUCT_PFRM; // TODO
picInfo->inQuantRange = ctrlParam->inQuantRange; // copy
picInfo->inColorMatrix = ctrlParam->inColorMatrix; // copy
picInfo->outWidth = ow; // copy
picInfo->outHeight = oh; // copy
picInfo->outDepth = CELL_VPOST_PIC_DEPTH_8; // fixed
picInfo->outScanType = CELL_VPOST_SCAN_TYPE_P; // TODO
picInfo->outPicFmt = CELL_VPOST_PIC_FMT_OUT_RGBA_ILV; // TODO
picInfo->outChromaPosType = ctrlParam->inChromaPosType; // ignored
picInfo->outPicStruct = picInfo->inPicStruct; // ignored
picInfo->outQuantRange = ctrlParam->inQuantRange; // ignored
picInfo->outColorMatrix = ctrlParam->inColorMatrix; // ignored
picInfo->userData = ctrlParam->userData; // copy
picInfo->reserved1 = 0;
picInfo->reserved2 = 0;
//u64 stamp0 = get_system_time();
std::unique_ptr<u8[]> pA(new u8[w*h]);
memset(pA.get(), ctrlParam->outAlpha, w*h);
//u64 stamp1 = get_system_time();
std::unique_ptr<SwsContext, void(*)(SwsContext*)> sws(sws_getContext(w, h, AV_PIX_FMT_YUVA420P, ow, oh, AV_PIX_FMT_RGBA, SWS_BILINEAR, NULL, NULL, NULL), sws_freeContext);
//u64 stamp2 = get_system_time();
const u8* in_data[4] = { &inPicBuff[0], &inPicBuff[w * h], &inPicBuff[w * h * 5 / 4], pA.get() };
int in_line[4] = { w, w/2, w/2, w };
u8* out_data[4] = { outPicBuff.get_ptr(), NULL, NULL, NULL };
int out_line[4] = { static_cast<int>(ow*4), 0, 0, 0 };
sws_scale(sws.get(), in_data, in_line, 0, h, out_data, out_line);
//ConLog.Write("cellVpostExec() perf (access=%d, getContext=%d, scale=%d, finalize=%d)",
//stamp1 - stamp0, stamp2 - stamp1, stamp3 - stamp2, get_system_time() - stamp3);
return CELL_OK;
}
