int getDebugEnum(const char *what)
{
// Check if 'what' matches one of the TProofDebug enum and return the corresponding
// integer. Relies on a perfect synchronization with the content of TProofDebug.h .
TString sws(what), sw;
int rcmask = 0;
int from = 0;
while (sws.Tokenize(sw, from , "|")) {
if (sw.BeginsWith("k")) sw.Remove(0,1);
if (sw == "None") {
rcmask |= TProofDebug::kNone;
} else if (sw == "Packetizer") {
rcmask |= TProofDebug::kPacketizer;
} else if (sw == "Loop") {
rcmask |= TProofDebug::kLoop;
} else if (sw == "Selector") {
rcmask |= TProofDebug::kSelector;
} else if (sw == "Output") {
rcmask |= TProofDebug::kOutput;
} else if (sw == "Input") {
rcmask |= TProofDebug::kInput;
} else if (sw == "Global") {
rcmask |= TProofDebug::kGlobal;
} else if (sw == "Package") {
rcmask |= TProofDebug::kPackage;
} else if (sw == "Feedback") {
rcmask |= TProofDebug::kFeedback;
} else if (sw == "Condor") {
rcmask |= TProofDebug::kCondor;
} else if (sw == "Draw") {
rcmask |= TProofDebug::kDraw;
} else if (sw == "Asyn") {
rcmask |= TProofDebug::kAsyn;
} else if (sw == "Cache") {
rcmask |= TProofDebug::kCache;
} else if (sw == "Collect") {
rcmask |= TProofDebug::kCollect;
} else if (sw == "Dataset") {
rcmask |= TProofDebug::kDataset;
} else if (sw == "Submerger") {
rcmask |= TProofDebug::kSubmerger;
} else if (sw == "Monitoring") {
rcmask |= TProofDebug::kMonitoring;
} else if (sw == "All") {
rcmask |= TProofDebug::kAll;
} else if (!sw.IsNull()) {
Printf("WARNING: requested debug enum name '%s' does not exist: assuming 'All'", sw.Data());
rcmask |= TProofDebug::kAll;
}
}
// Done
return rcmask;
}
s32 cellVdecGetPicture(u32 handle, vm::cptr<CellVdecPicFormat> format, vm::ptr<u8> outBuff)
{
cellVdec.Log("cellVdecGetPicture(handle=0x%x, format=*0x%x, outBuff=*0x%x)", handle, format, outBuff);
const auto vdec = Emu.GetIdManager().get<VideoDecoder>(handle);
if (!vdec || !format)
{
return CELL_VDEC_ERROR_ARG;
}
VdecFrame vf;
if (!vdec->frames.try_pop(vf))
{
//std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack
return CELL_VDEC_ERROR_EMPTY;
}
if (!vf.data)
{
// hack
return CELL_OK;
}
std::unique_ptr<AVFrame, void(*)(AVFrame*)> frame(vf.data, [](AVFrame* frame)
{
av_frame_unref(frame);
av_frame_free(&frame);
});
if (outBuff)
{
const auto f = vdec->ctx->pix_fmt;
const auto w = vdec->ctx->width;
const auto h = vdec->ctx->height;
auto out_f = AV_PIX_FMT_YUV420P;
std::unique_ptr<u8[]> alpha_plane;
switch (const u32 type = format->formatType)
{
case CELL_VDEC_PICFMT_ARGB32_ILV: out_f = AV_PIX_FMT_ARGB; alpha_plane.reset(new u8[w * h]); break;
case CELL_VDEC_PICFMT_RGBA32_ILV: out_f = AV_PIX_FMT_RGBA; alpha_plane.reset(new u8[w * h]); break;
case CELL_VDEC_PICFMT_UYVY422_ILV: out_f = AV_PIX_FMT_UYVY422; break;
case CELL_VDEC_PICFMT_YUV420_PLANAR: out_f = AV_PIX_FMT_YUV420P; break;
default:
{
throw EXCEPTION("Unknown formatType(%d)", type);
}
}
if (format->colorMatrixType != CELL_VDEC_COLOR_MATRIX_TYPE_BT709)
{
throw EXCEPTION("Unknown colorMatrixType(%d)", format->colorMatrixType);
}
if (alpha_plane)
{
memset(alpha_plane.get(), format->alpha, w * h);
}
auto in_f = AV_PIX_FMT_YUV420P;
switch (f)
{
case AV_PIX_FMT_YUV420P: in_f = alpha_plane ? AV_PIX_FMT_YUVA420P : AV_PIX_FMT_YUV420P; break;
default:
{
throw EXCEPTION("Unknown pix_fmt(%d)", f);
}
}
std::unique_ptr<SwsContext, void(*)(SwsContext*)> sws(sws_getContext(w, h, in_f, w, h, out_f, SWS_POINT, NULL, NULL, NULL), sws_freeContext);
u8* in_data[4] = { frame->data[0], frame->data[1], frame->data[2], alpha_plane.get() };
int in_line[4] = { frame->linesize[0], frame->linesize[1], frame->linesize[2], w * 1 };
u8* out_data[4] = { outBuff.get_ptr() };
int out_line[4] = { w * 4 };
if (!alpha_plane)
{
out_data[1] = out_data[0] + w * h;
out_data[2] = out_data[0] + w * h * 5 / 4;
out_line[0] = w;
out_line[1] = w / 2;
out_line[2] = w / 2;
}
sws_scale(sws.get(), in_data, in_line, 0, h, out_data, out_line);
//const u32 buf_size = align(av_image_get_buffer_size(vdec->ctx->pix_fmt, vdec->ctx->width, vdec->ctx->height, 1), 128);
//// TODO: zero padding bytes
//int err = av_image_copy_to_buffer(outBuff.get_ptr(), buf_size, frame->data, frame->linesize, vdec->ctx->pix_fmt, frame->width, frame->height, 1);
//if (err < 0)
//{
// cellVdec.Fatal("cellVdecGetPicture: av_image_copy_to_buffer failed (err=0x%x)", err);
//}
}
return CELL_OK;
}
SchedDemo::SchedDemo(const size_t num_planes, const moment_t timespan, const moment_t bounds, const moment_t window_span, QWidget *parent/* = 0*/, Qt::WFlags flags/* = 0*/)
: QWidget(parent, flags)
, jobs_removed_(0)
, original_task_(planes_task_with_bounds(num_planes, timespan, bounds))
//, original_perm_(num_planes)
, window_pos_(-2)
, window_span_(window_span)
, next_job_(0)
, total_cost(0)
{
resetDemo();
sched_ = perm2sched(task_, perm_);
sched_src_ = perm2sched(task_src_, perm_);
auto clb = boost::bind(&SchedDemo::updateCost, this);
//scene_->setCostCallback(clb);
//scene_->setWeightScale(100);
//scene_->setTimeScale(20);
//QGraphicsView *view = new QGraphicsView(scene_);
//view->setMouseTracking(true);
//solver_slots_.push_back(solver_slot_t("Original", order_solver));
solver_slots_.push_back(solver_slot_t("Due dates", due_dates_solver));
selected_solver_ = solver_slots_.size() - 1;
solver_slots_.push_back(solver_slot_t("Random pair", boost::bind(random_solver, _1, _2, 10000)));
solver_slots_.push_back(solver_slot_t("Best pair", all_pairs_solver));
//solver_slots_.push_back(solver_slot_t("Best triple", boost::bind(all_triples_solver, _1, _2, 7)));
//solver_slots_.push_back(solver_slot_t("Annealing", annealing_solver));
sliding_window_solver sws(5, boost::bind(&SchedDemo::updateOffset, this, _1));
solver_slots_.push_back(solver_slot_t("Window", sws));
QGridLayout *layout = new QGridLayout;
QWidget *sidePanel = new QWidget;
QGridLayout *sideLayout = new QGridLayout;
sideLayout->setAlignment(Qt::AlignTop);
QSignalMapper *mapper = new QSignalMapper(this);
for (size_t i = 0; i < solver_slots_.size(); ++i)
{
solver_slots_[i].btn = new QPushButton(solver_slots_[i].name, this);
mapper->setMapping(solver_slots_[i].btn, i);
connect(solver_slots_[i].btn, SIGNAL(clicked()), mapper, SLOT(map()));
solver_slots_[i].lbl = new QLabel(this);
sideLayout->addWidget(solver_slots_[i].btn, i, 0);
sideLayout->addWidget(solver_slots_[i].lbl, i, 1);
}
connect(mapper, SIGNAL(mapped(int)), this, SLOT(setSolver(int)));
/*
QPushButton *advanceBtn = new QPushButton("Advance");
sideLayout->addWidget(advanceBtn, solver_slots_.size() + 1, 0);
connect(advanceBtn, SIGNAL(clicked()), this, SLOT(advanceSubtask()));*/
/*QPushButton *resetBtn = new QPushButton("Reset");
sideLayout->addWidget(resetBtn, solver_slots_.size() + 2, 0);
connect(resetBtn, SIGNAL(clicked()), this, SLOT(resetSubtask()));*/
QPushButton *playBtn = new QPushButton("Play", this);
sideLayout->addWidget(playBtn, solver_slots_.size() + 1, 0);
connect(playBtn, SIGNAL(clicked()), this, SLOT(playDemo()));
QPushButton *pauseBtn = new QPushButton("Pause", this);
sideLayout->addWidget(pauseBtn, solver_slots_.size() + 1, 1);
connect(pauseBtn, SIGNAL(clicked()), this, SLOT(pauseDemo()));
speedBar_ = new QScrollBar(Qt::Horizontal, this);
sideLayout->addWidget(speedBar_, solver_slots_.size() + 3, 0, 1, 2);
play_timer_ = new QTimer(this);
connect(play_timer_, SIGNAL(timeout()), this, SLOT(playTick()));
QPushButton *resetBtn = new QPushButton("Reset", this);
sideLayout->addWidget(resetBtn, solver_slots_.size() + 2, 0);
connect(resetBtn, SIGNAL(clicked()), this, SLOT(resetDemo()));
size_t pos_offset = solver_slots_.size() + 5;
sideLayout->addWidget(new QLabel("Cost:"), pos_offset, 0);
cost_display_ = new QLabel(this);
sideLayout->addWidget(cost_display_, pos_offset, 1);
++pos_offset;
sideLayout->addWidget(new QLabel("Aircrafts Processed:"), pos_offset, 0);
processed_display_ = new QLabel(this);
sideLayout->addWidget(processed_display_, pos_offset, 1);
++pos_offset;
sideLayout->addWidget(new QLabel("Aircrafts Removed:"), pos_offset, 0);
removed_display_ = new QLabel(this);
sideLayout->addWidget(removed_display_, pos_offset, 1);
++pos_offset;
sideLayout->addWidget(new QLabel("Aircrafts in progress:"), pos_offset, 0);
in_progress_display_ = new QLabel(this);
sideLayout->addWidget(in_progress_display_, pos_offset, 1);
++pos_offset;
sidePanel->setLayout(sideLayout);
//layout->addWidget(view, 0, 0);
/*
qwt_demo_ = new QwtSchedDemo(this);
layout->addWidget(qwt_demo_, 1, 0);
*/
demo2_src = new qwt_demo_2(this);
demo2_src->setAxisScale(QwtPlot::xBottom, -30, 30);
demo2 = new qwt_demo_2(this);
demo2->setAxisScale(QwtPlot::xBottom, -30, 30);
layout->addWidget(demo2_src, 0, 0);
layout->addWidget(demo2, 0, 1);
layout->addWidget(sidePanel, 0, 3, 2, 1);
setLayout(layout);
//scene_->invalidateItems();
updateCost();
}
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;
}
