void PerformanceManager::loadPerformances() {
IffStream* iffStream = TemplateManager::instance()->openIffFile(
"datatables/performance/performance.iff");
if (iffStream == NULL) {
error("Could not open performances datatable.");
return;
}
DataTableIff dtable;
dtable.readObject(iffStream);
delete iffStream;
performances = new Vector<Performance*> ();
for (int i = 0; i < dtable.getTotalRows(); ++i) {
DataTableRow* row = dtable.getRow(i);
Performance* performance = new Performance();
performance->parseDataTableRow(row);
performances->add(performance);
}
info("Loaded " + String::valueOf(performances->size()) + " performances.",
true);
}
Vector<Performance*> PerformanceManager::getPerformanceListFromMod(
const String& requiredSkillMod, int playerSkillModValue, int instrument) {
String instrumentName = "";
if (instrument != 0)
instrumentName = getInstrument(instrument);
Vector<Performance*> performanceList;
if (performances != NULL) {
for (int i = 0; i < performances->size(); ++i) {
Performance* perform = performances->get(i);
if (perform->getRequiredSkillMod() == requiredSkillMod
&& perform->getRequiredSkillModValue()
<= playerSkillModValue) {
if (instrumentName != "") {
//Should be a music call, look only for performances with that instrument
if (instrumentName == perform->getRequiredInstrument())
performanceList.add(perform);
} else {
//Should be a dance call
performanceList.add(perform);
}
}
}
}
return performanceList;
}
void run() {
Performance p;
printf("Allocating buffers\n");
text_buf = alloc_shared_buffer<char> (LENGTH_OF_TEXT, &text_c);
pattern_buf= alloc_shared_buffer<char> (LENGTH_OF_PATTERN, &pattern_c);
result_buf= alloc_shared_buffer<char> (1, &result_c);
result_c[0] = 0;
init_string( text_c, pattern_c );
printf("Initializing kernels\n");
size_t task_dim = 1;
clKernelSet kernel_set (device, context, program);
// kernel_set.addKernel ("text_processor", 1, &task_dim, text_buf, LENGTH_OF_TEXT);
// kernel_set.addKernel ("word_processor", 1, &task_dim);
kernel_set.addKernel ("word_processor", 1, &task_dim, text_buf, LENGTH_OF_TEXT);
kernel_set.addKernel ("matching", 1, &task_dim, pattern_buf, LENGTH_OF_PATTERN, result_buf);
printf("Launching the kernel...\n");
p.start();
kernel_set.launch();
printf(" start waiting.... \n");
kernel_set.finish();
p.stop();
printf(" done Execution (OpenCL Channel) time = (%u,%u), result = %d\n", p.report_sec(), p.report_usec(),result_c[0]);
test_in_cpu( text_c, pattern_c );
return;
}
static v8::Handle<v8::Value> webkitClearMeasuresCallback(const v8::Arguments& args)
{
Performance* imp = V8Performance::toNative(args.Holder());
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, measureName, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsNullString));
imp->webkitClearMeasures(measureName);
return v8Undefined();
}
static void onwebkitresourcetimingbufferfullAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
{
Performance* imp = V8Performance::toNative(info.Holder());
transferHiddenDependency(info.Holder(), imp->onwebkitresourcetimingbufferfull(), value, V8Performance::eventListenerCacheIndex);
imp->setOnwebkitresourcetimingbufferfull(V8DOMWrapper::getEventListener(value, true, ListenerFindOrCreate));
return;
}
static v8::Handle<v8::Value> webkitGetEntriesByTypeCallback(const v8::Arguments& args)
{
if (args.Length() < 1)
return throwNotEnoughArgumentsError(args.GetIsolate());
Performance* imp = V8Performance::toNative(args.Holder());
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, entryType, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
return toV8(imp->webkitGetEntriesByType(entryType), args.Holder(), args.GetIsolate());
}
static v8::Handle<v8::Value> webkitSetResourceTimingBufferSizeCallback(const v8::Arguments& args)
{
if (args.Length() < 1)
return throwNotEnoughArgumentsError(args.GetIsolate());
Performance* imp = V8Performance::toNative(args.Holder());
V8TRYCATCH(unsigned, maxSize, toUInt32(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
imp->webkitSetResourceTimingBufferSize(maxSize);
return v8Undefined();
}
int main()
{
Performance P; //Initializes an instance of the Performance class.
P.run(2,20); //first parameter is the number of standard deviations for bands.
//Second parameter is the number of periods in the moving average.
cout<< "Sharpe Ratio: " << P.sharpe_ratio() << endl;
system("pause");
}
//-----------------------------------------------------------------------------
//! 描画
//-----------------------------------------------------------------------------
void SystemPerformance::drawPerformanceBar()
{
glDepthMask(GL_FALSE);
setBlendMode(BM_BLEND_ALPHA);
// 描画座標
Vector3 drawPos = Vector3(1860.0f, 0.0f, 0.0f);
// フレームの数
static u32 frameCount = 3;
// 線形補完する
static f32 height = 1000.0f;
// １フレーム分の高さ
static f32 oneFrameHeight = height / (f32)frameCount;
// 枠を描画
glColor4f(0.0f,0.0f,0.0f, 0.8f);
glBegin(GL_TRIANGLE_STRIP);
glVertex3f(drawPos._x , drawPos._y , 0.0f);
glVertex3f(drawPos._x + 40.0f, drawPos._y , 0.0f);
glVertex3f(drawPos._x , drawPos._y + height, 0.0f);
glVertex3f(drawPos._x + 40.0f, drawPos._y + height, 0.0f);
glEnd();
// 枠の分だけずらす
drawPos._x += 5.0f;
// 描画
for( list<Performance*>::iterator itr = _pPerformList.begin(); itr != _pPerformList.end(); itr++ )
{
Performance* drawPef = *itr;
// 描画
drawPef->DrawPerformance(drawPos, oneFrameHeight, _maxSecond);
// 次の描画位置を求める
drawPos._y += drawPef->getHeight();
}
//---- フレームの分割線の描画
drawPos._x -= 5.0f;
glBegin(GL_LINES);
glColor4f(0.0f, 1.0f, 0.5f, 1.0f);
for( u32 i=0; i<frameCount; ++i ){
glVertex3f(drawPos._x , i * oneFrameHeight, 0.0f);
glVertex3f(drawPos._x + 40.0f, i * oneFrameHeight, 0.0f);
}
glEnd();
// 白で設定しなおす
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
setBlendMode(BM_NONE);
glDepthMask(GL_TRUE);
}
Performance* PerformanceManager::getSong(const String& name, int instrumentType) {
if (performances != NULL) {
for (int i = 0; i < performances->size(); ++i) {
Performance* ret = performances->get(i);
if (ret->isMusic() && ret->getName() == name
&& ret->getInstrumentAudioId() == instrumentType)
return ret;
}
}
return NULL;
}
Performance* PerformanceManager::getDance(const String& name) {
if (performances != NULL) {
for (int i = 0; i < performances->size(); ++i) {
Performance* ret = performances->get(i);
if (ret->isDance() && ret->getName() == name)
return ret;
}
}
return NULL;
}
static v8::Handle<v8::Value> memoryAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
Performance* imp = V8Performance::toNative(info.Holder());
RefPtr<MemoryInfo> result = imp->memory();
v8::Handle<v8::Value> wrapper = result.get() ? v8::Handle<v8::Value>(DOMDataStore::getWrapper(result.get(), info.GetIsolate())) : v8Undefined();
if (wrapper.IsEmpty()) {
wrapper = toV8(result.get(), info.Holder(), info.GetIsolate());
if (!wrapper.IsEmpty())
V8DOMWrapper::setNamedHiddenReference(info.Holder(), "memory", wrapper);
}
return wrapper;
}
void EntertainingSessionImplementation::doPerformanceAction() {
ManagedReference<CreatureObject*> entertainer = this->entertainer.get();
if (entertainer == NULL)
return;
Locker locker(entertainer);
Performance* performance = NULL;
PerformanceManager* performanceManager = SkillManager::instance()->getPerformanceManager();
ManagedReference<Instrument*> instrument = getInstrument(entertainer);
if (isDancing())
performance = performanceManager->getDance(performanceName);
else if (isPlayingMusic() && instrument)
performance = performanceManager->getSong(performanceName, instrument->getInstrumentType());
else {
cancelSession();
return;
}
if (performance == NULL) { // shouldn't happen
StringBuffer msg;
msg << "Performance was null. Please report to www.swgemu.com/bugs ! Name: " << performanceName << " and Type: " << dec << instrument->getInstrumentType();
entertainer->sendSystemMessage(msg.toString());
return;
}
int actionDrain = performance->getActionPointsPerLoop();
//Adjust cost based upon player's quickness
actionDrain = entertainer->calculateCostAdjustment(CreatureAttribute::QUICKNESS, actionDrain);
if (entertainer->getHAM(CreatureAttribute::ACTION) <= actionDrain) {
if (isDancing()) {
stopDancing();
entertainer->sendSystemMessage("@performance:dance_too_tired");
}
if (isPlayingMusic()) {
stopPlayingMusic();
entertainer->sendSystemMessage("@performance:music_too_tired");
}
} else {
entertainer->inflictDamage(entertainer, CreatureAttribute::ACTION, actionDrain, false, true);
}
}
already_AddRefed<VideoPlaybackQuality>
HTMLVideoElement::GetVideoPlaybackQuality() {
DOMHighResTimeStamp creationTime = 0;
uint32_t totalFrames = 0;
uint32_t droppedFrames = 0;
uint32_t corruptedFrames = 0;
if (IsVideoStatsEnabled()) {
if (nsPIDOMWindowInner* window = OwnerDoc()->GetInnerWindow()) {
Performance* perf = window->GetPerformance();
if (perf) {
creationTime = perf->Now();
}
}
if (mDecoder) {
if (nsContentUtils::ShouldResistFingerprinting(OwnerDoc())) {
totalFrames = nsRFPService::GetSpoofedTotalFrames(TotalPlayTime());
droppedFrames = nsRFPService::GetSpoofedDroppedFrames(
TotalPlayTime(), VideoWidth(), VideoHeight());
corruptedFrames = 0;
} else {
FrameStatistics* stats = &mDecoder->GetFrameStatistics();
if (sizeof(totalFrames) >= sizeof(stats->GetParsedFrames())) {
totalFrames = stats->GetTotalFrames();
droppedFrames = stats->GetDroppedFrames();
} else {
uint64_t total = stats->GetTotalFrames();
const auto maxNumber = std::numeric_limits<uint32_t>::max();
if (total <= maxNumber) {
totalFrames = uint32_t(total);
droppedFrames = uint32_t(stats->GetDroppedFrames());
} else {
// Too big number(s) -> Resize everything to fit in 32 bits.
double ratio = double(maxNumber) / double(total);
totalFrames = maxNumber; // === total * ratio
droppedFrames = uint32_t(double(stats->GetDroppedFrames()) * ratio);
}
}
corruptedFrames = 0;
}
}
}
RefPtr<VideoPlaybackQuality> playbackQuality = new VideoPlaybackQuality(
this, creationTime, totalFrames, droppedFrames, corruptedFrames);
return playbackQuality.forget();
}
static v8::Handle<v8::Value> webkitMarkCallback(const v8::Arguments& args)
{
if (args.Length() < 1)
return throwNotEnoughArgumentsError(args.GetIsolate());
Performance* imp = V8Performance::toNative(args.Holder());
ExceptionCode ec = 0;
{
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, markName, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
imp->webkitMark(markName, ec);
if (UNLIKELY(ec))
goto fail;
return v8Undefined();
}
fail:
return setDOMException(ec, args.GetIsolate());
}
void EntertainingSessionImplementation::increaseEntertainerBuff(CreatureObject* patron){
ManagedReference<CreatureObject*> entertainer = this->entertainer.get();
PerformanceManager* performanceManager = SkillManager::instance()->getPerformanceManager();
Performance* performance = NULL;
ManagedReference<Instrument*> instrument = getInstrument(entertainer);
if (performanceName == "")
return;
if (dancing) {
performance = performanceManager->getDance(performanceName);
} else if (playingMusic && instrument != NULL) {
performance = performanceManager->getSong(performanceName, instrument->getInstrumentType());
} else {
cancelSession();
return;
}
if(!canGiveEntertainBuff())
return;
if (performance == NULL) { // shouldn't happen
return;
}
ManagedReference<PlayerObject*> entPlayer = entertainer->getPlayerObject();
//Check if the patron is a valid buff target
//Whether it be passive(in the same group) or active (/setPerform target)
if ((!entertainer->isGrouped() || entertainer->getGroupID() != patron->getGroupID())
&& entPlayer->getPerformanceBuffTarget() != patron->getObjectID()) {
return;
}
if(isInDenyServiceList(patron))
return;
float buffAcceleration = 1 + ((float)entertainer->getSkillMod("accelerate_entertainer_buff") / 100.f);
addEntertainerBuffDuration(patron, performance->getType(), 2.0f * buffAcceleration);
addEntertainerBuffStrength(patron, performance->getType(), performance->getHealShockWound());
}
int main(int argc, char* argv[]) {
using namespace asmjit;
Performance perf;
uint32_t kNumRepeats = 10;
uint32_t kNumIterations = 10000;
JitRuntime runtime;
X86Assembler a(&runtime);
X86Compiler c(&runtime);
uint32_t r, i;
// --------------------------------------------------------------------------
// [Bench - Opcode]
// --------------------------------------------------------------------------
perf.reset();
for (r = 0; r < kNumRepeats; r++) {
perf.start();
for (i = 0; i < kNumIterations; i++) {
asmgen::opcode(a);
void *p = a.make();
runtime.release(p);
a.reset();
}
perf.end();
}
printf("Opcode | Time: %-6u [ms] | Speed: %-9u [inst/s]\n",
perf.best, instPerMs(perf.best, kNumIterations, asmgen::kGenOpCodeInstCount));
// --------------------------------------------------------------------------
// [Bench - Blend]
// --------------------------------------------------------------------------
perf.reset();
for (r = 0; r < kNumRepeats; r++) {
perf.start();
for (i = 0; i < kNumIterations; i++) {
asmgen::blend(c);
void* p = c.make();
runtime.release(p);
c.reset();
}
perf.end();
}
printf("Blend | Time: %-6u [ms] | Speed: %-9u [inst/s]\n",
perf.best, instPerMs(perf.best, kNumIterations, asmgen::kGenBlendInstCount));
return 0;
}
void performanceGate() {
std::vector<double> input;
input.resize(8192, 0);
std::vector<double> output;
output.resize(8192, 0);
double sampleRate = 48000.0;
{
double phase = 0;
double baseCycle = 2.0*M_PI/sampleRate * 1280.0;
for (int32_t iii=0; iii<input.size(); iii++) {
input[iii] = cos(phase) * 5.0;
phase += baseCycle;
if (phase >= 2*M_PI) {
phase -= 2*M_PI;
}
}
}
TEST_PRINT("Start Gate performance ...");
Performance perfo;
audio::algo::chunkware::Gate algo;
algo.setSampleRate(48000);
algo.setThreshold(0);
algo.setAttack(0.1);
algo.setRelease(2);
algo.init();
for (int32_t iii=0; iii<4096; ++iii) {
perfo.tic();
algo.process(&output[0], &input[0], input.size(), 1, audio::format_double);
perfo.toc();
std::this_thread::sleep_for(std::chrono::milliseconds(1));
}
TEST_PRINT("Performance Gate (double): ");
TEST_PRINT(" blockSize=" << input.size() << " sample");
TEST_PRINT(" min < avg < max =" << perfo.getMinProcessing().count() << "ns < "
<< perfo.getTotalTimeProcessing().count()/perfo.getTotalIteration() << "ns < "
<< perfo.getMaxProcessing().count() << "ns ");
TEST_PRINT(" min < avg < max = " << (float((perfo.getMinProcessing().count()*sampleRate)/double(input.size()))/1000000000.0)*100.0 << "% < "
<< (float(((perfo.getTotalTimeProcessing().count()/perfo.getTotalIteration())*sampleRate)/double(input.size()))/1000000000.0)*100.0 << "% < "
<< (float((perfo.getMaxProcessing().count()*sampleRate)/double(input.size()))/1000000000.0)*100.0 << "%");
}
void test_in_cpu( char* text, char* pattern )
{
Performance p;
p.start();
bool match = false;
int count = 0;
for( int n = 0 ; n < LENGTH_OF_TEXT - 1; n ++ ) {
int m = 0;
if( n == 0 || text[n-1] == ' ' ) {
for( ; m < LENGTH_OF_PATTERN - 1; m ++ ) {
if( pattern[m] != text[n+m] )
break;
}
}
if( m == LENGTH_OF_PATTERN - 1 )
count ++;
}
p.stop();
printf(" done Execution (CPU) time = (%u,%u), result = %d\n", p.report_sec(), p.report_usec(),count);
}
//-----------------------------------------------------------------------------
//! 描画
//-----------------------------------------------------------------------------
void Performance::DrawPerformance(Vector3 drawPos, f32& parentHeight, s64& maxFrame)
{
// 線形補完する
_height = LinearInterpolation(0.0f, parentHeight, (f32)_totalTime, (f32)maxFrame);
// 自分のバーの描画
glBegin(GL_TRIANGLE_STRIP);
glColor4ubv((GLubyte*)&_drawColor);
glVertex3f(drawPos._x , drawPos._y , 0.0f);
glVertex3f(drawPos._x + 30.0f, drawPos._y , 0.0f);
glVertex3f(drawPos._x , drawPos._y + _height, 0.0f);
glVertex3f(drawPos._x + 30.0f, drawPos._y + _height, 0.0f);
glEnd();
// 子のパフォーマンスの描画
for( list<Performance*>::iterator itr = _childPeform.begin(); itr != _childPeform.end(); itr++ )
{
Performance* drawPef = *itr;
// 描画
drawPef->DrawPerformance(drawPos, _height, _totalTime);
// 次の描画位置を求める
drawPos._y += drawPef->getHeight();
}
}
int main(int argc, char **argv)
{
char mode;
int fsize;
struct timeval start;
double dur;
char *filepath, *filepaths, *tofree;
Performance perf;
if ( argc != 6 ) {
cout << "usage: ./me r|w filepaths filesize addition-head additional-datarow" << endl;
cout << "example: ./perform w /tmp/myfile1,/tmp/myfile2 1024 'hello hellodata' 'echo echodata'" << endl;
exit(1);
}
mode = argv[1][0];
tofree = filepaths = strdup(argv[2]);
fsize = atoi(argv[3]);
start_timer(&start);
while ((filepath = strsep(&filepaths, ",")) != NULL) {
if ( mode == 'r' )
readfile(filepath, fsize);
else
writefile(filepath, fsize);
}
dur = end_timer_get_duration(&start);
perf.put("duration", dur);
perf.put("filesize", fsize);
perf.put("mode", argv[1]);
perf.put(argv[4], argv[5]);
cout << perf.showColumns();
free(tofree);
}
void EntertainingSessionImplementation::doFlourish(int flourishNumber) {
ManagedReference<CreatureObject*> entertainer = this->entertainer.get();
int fid = flourishNumber;
if (!dancing && !playingMusic) {
entertainer->sendSystemMessage("@performance:flourish_not_performing");
return;
}
PerformanceManager* performanceManager = SkillManager::instance()->getPerformanceManager();
Performance* performance = NULL;
ManagedReference<Instrument*> instrument = getInstrument(entertainer);
if (dancing)
performance = performanceManager->getDance(performanceName);
else if (playingMusic && instrument)
performance = performanceManager->getSong(performanceName, instrument->getInstrumentType());
else {
cancelSession();
return;
}
if (!performance) { // shouldn't happen
StringBuffer msg;
msg << "Performance was null. Please report to www.swgemu.com/bugs ! Name: " << performanceName << " and Type: " << dec << instrument->getInstrumentType();
entertainer->sendSystemMessage(msg.toString());
return;
}
float baseActionDrain = performance->getActionPointsPerLoop() - (int)(entertainer->getHAM(CreatureAttribute::QUICKNESS)/35.f);
//float baseActionDrain = -40 + (getQuickness() / 37.5);
float flourishActionDrain = baseActionDrain / 2.0;
int actionDrain = (int)round((flourishActionDrain * 10 + 0.5) / 10.0); // Round to nearest dec for actual int cost
if (entertainer->getHAM(CreatureAttribute::ACTION) <= actionDrain) {
entertainer->sendSystemMessage("@performance:flourish_too_tired");
} else {
entertainer->inflictDamage(entertainer, CreatureAttribute::ACTION, actionDrain, false, true);
if (dancing) {
StringBuffer msg;
msg << "skill_action_" << fid;
entertainer->doAnimation(msg.toString());
} else if (playingMusic) {
Flourish* flourish = new Flourish(entertainer, fid);
entertainer->broadcastMessage(flourish, true);
}
//check to see how many flourishes have occurred this tick
if(flourishCount < 5) {
// Add buff
addEntertainerFlourishBuff();
// Grant Experience
if(flourishCount < 2)
flourishXp += performance->getBaseXp() + performance->getFlourishXpMod();
flourishCount++;
}
entertainer->notifyObservers(ObserverEventType::FLOURISH, entertainer, fid);
entertainer->sendSystemMessage("@performance:flourish_perform");
}
}
void EntertainingSessionImplementation::doEntertainerPatronEffects() {
ManagedReference<CreatureObject*> creo = entertainer.get();
if (creo == NULL)
return;
if (performanceName == "")
return;
Locker locker(creo);
//**DECLARATIONS**
VectorMap<ManagedReference<CreatureObject*>, EntertainingData>* patrons = NULL;
SkillManager* skillManager = creo->getZoneServer()->getSkillManager();
PerformanceManager* performanceManager = skillManager->getPerformanceManager();
Performance* performance = NULL;
ManagedReference<Instrument*> instrument = getInstrument(creo);
float woundHealingSkill = 0.0f;
float playerShockHealingSkill = 0.0f;
float buildingShockHealingSkill = creo->getSkillMod("private_med_battle_fatigue");
float factionPerkSkill = creo->getSkillMod("private_faction_mind_heal");
//**LOAD PATRONS, GET THE PERFORMANCE AND ENT'S HEALING SKILL.**
if (dancing) {
patrons = &watchers;
performance = performanceManager->getDance(performanceName);
woundHealingSkill = (float) creo->getSkillMod("healing_dance_wound");
playerShockHealingSkill = (float) creo->getSkillMod("healing_dance_shock");
} else if (playingMusic && instrument != NULL) {
patrons = &listeners;
performance = performanceManager->getSong(performanceName, instrument->getInstrumentType());
woundHealingSkill = (float) creo->getSkillMod("healing_music_wound");
playerShockHealingSkill = (float) creo->getSkillMod("healing_music_shock");
} else {
cancelSession();
return;
}
if (performance == NULL) {
return;
}
ManagedReference<BuildingObject*> building = creo->getRootParent().get().castTo<BuildingObject*>();
if (building != NULL && factionPerkSkill > 0 && building->isPlayerRegisteredWithin(creo->getObjectID())) {
unsigned int buildingFaction = building->getFaction();
unsigned int healerFaction = creo->getFaction();
PlayerObject* ghost = creo->getPlayerObject();
if (ghost != NULL && healerFaction != 0 && healerFaction == buildingFaction && ghost->getFactionStatus() == FactionStatus::OVERT) {
woundHealingSkill += factionPerkSkill;
playerShockHealingSkill += factionPerkSkill;
}
}
//**DETERMINE WOUND HEAL AMOUNTS.**
int woundHeal = ceil(performance->getHealMindWound() * (woundHealingSkill / 100.0f));
int shockHeal = ceil(performance->getHealShockWound() * ((playerShockHealingSkill + buildingShockHealingSkill) / 100.0f));
//**ENTERTAINER HEALS THEIR OWN MIND.**
healWounds(creo, woundHeal*(flourishCount+1), shockHeal*(flourishCount+1));
//**APPLY EFFECTS TO PATRONS.**
if (patrons != NULL && patrons->size() > 0) {
for (int i = 0; i < patrons->size(); ++i) {
ManagedReference<CreatureObject*> patron = patrons->elementAt(i).getKey();
try {
//**VERIFY THE PATRON IS NOT ON THE DENY SERVICE LIST
if (creo->isInRange(patron, 10.0f)) {
healWounds(patron, woundHeal*(flourishCount+1), shockHeal*(flourishCount+1));
increaseEntertainerBuff(patron);
} else { //patron is not in range, force to stop listening
ManagedReference<PlayerManager*> playerManager = patron->getZoneServer()->getPlayerManager();
Locker locker(patron, entertainer.get());
if (dancing) {
if (playerManager != NULL)
playerManager->stopWatch(patron, creo->getObjectID(), true, false, false, true);
if (!patron->isListening())
sendEntertainmentUpdate(patron, 0, "", true);
} else if (playingMusic) {
if (playerManager != NULL)
playerManager->stopListen(patron, creo->getObjectID(), true, false, false, true);
if (!patron->isWatching())
sendEntertainmentUpdate(patron, 0, "", true);
}
}
} catch (Exception& e) {
error("Unreported exception caught in EntertainingSessionImplementation::doEntertainerPatronEffects()");
}
}
} //else
//System::out << "There are no patrons.\n";
info("EntertainingSessionImplementation::doEntertainerPatronEffects() end");
}
int main( int argc, char** argv )
{
string reference;
string input_dir;
string ground_truth_dir;
static int verbose_flag;
int option_index = 0;
int c;
static struct option long_options[] = {
{"verbose", no_argument, &verbose_flag, 1},
{"brief", no_argument, &verbose_flag, 0},
{"img", required_argument, 0, 'i'},
{0, 0, 0, 0}
};
while ((c = getopt_long(argc, argv, "r:i:",
long_options, &option_index)) != -1) {
if (c == -1)
break;
switch (c) {
case 'i':
ground_truth_dir = optarg;
break;
case 'h':
case '?':
display_usage();
break;
default:
abort ();
}
}
// Read files from input directory
string output_dir ("dscore_map");
if ( !exists(path(output_dir)) )
create_directory(output_dir);
map<unsigned int, string> gt_files;
int gt_size = -1;
// Verify input name is a video file or sequences of jpg files
path path_to_ground_truth ( chomp(ground_truth_dir) );
//path path_to_ground_truth (ground_truth_dir.c_str());
if (is_directory(path_to_ground_truth)) {
// fills list gt_files with <number,file_number>
list_files(ground_truth_dir,gt_files);
gt_size = gt_files.size();
output_dir += "/" + path_to_ground_truth.filename().string();
// Create local directory to save xml maps.
if ( !exists(path(output_dir)) )
create_directory(output_dir);
}
else {
cout << "Invalid ground-truth directory ... "<< endl;
return 0;
}
map<unsigned int, string>::iterator gt_it;
Performance *measure = new Performance();
Mat Image;
Mat Map;
for (gt_it = gt_files.begin(); gt_it != gt_files.end(); ++gt_it) {
Image = Scalar::all(0);
Map = Scalar::all(0);
// open ground truth frame.
Image = imread(gt_it->second, CV_LOAD_IMAGE_GRAYSCALE);
// get general Map
measure->computeGeneralDSCoreMap(Image, Map);
string dirname = fileName(gt_it->second);
cout << dirname << endl;
stringstream mapfile;
mapfile << output_dir << "/" << gt_it->first << ".xml";
FileStorage fs(mapfile.str(), FileStorage::WRITE);
stringstream tagname;
tagname << "DSCORE" << gt_it->first;
fs << "DSCORE" << Map;
fs.release();
// just for testing
if (gt_it->first == (unsigned int)(gt_size/2)) {
Mat mask;
stringstream map_name;
map_name << "Map_" << gt_it->first ;
cout << "Looking for: "<< map_name.str() << endl;
FileStorage fsread(mapfile.str(), FileStorage::READ);
fsread["DSCORE"] >> mask;
fsread.release();
map_name.str("");
map_name << gt_it->first << ".png" ;
normalize(mask, mask, 0, 255, cv::NORM_MINMAX);
imwrite(map_name.str().c_str(), mask);
}
}
static v8::Handle<v8::Value> onwebkitresourcetimingbufferfullAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
Performance* imp = V8Performance::toNative(info.Holder());
return imp->onwebkitresourcetimingbufferfull() ? v8::Handle<v8::Value>(static_cast<V8AbstractEventListener*>(imp->onwebkitresourcetimingbufferfull())->getListenerObject(imp->scriptExecutionContext())) : v8::Handle<v8::Value>(v8Null(info.GetIsolate()));
}
static v8::Handle<v8::Value> nowCallback(const v8::Arguments& args)
{
Performance* imp = V8Performance::toNative(args.Holder());
return v8::Number::New(imp->now());
}
int main(int _argc, const char** _argv) {
// the only one init for etk:
etk::init(_argc, _argv);
std::string inputName = "";
bool performance = false;
bool perf = false;
int64_t sampleRate = 48000;
for (int32_t iii=0; iii<_argc ; ++iii) {
std::string data = _argv[iii];
if (etk::start_with(data,"--in=")) {
inputName = &data[5];
} else if (data == "--performance") {
performance = true;
} else if (data == "--perf") {
perf = true;
} else if (etk::start_with(data,"--sample-rate=")) {
data = &data[14];
sampleRate = etk::string_to_int32_t(data);
} else if ( data == "-h"
|| data == "--help") {
TEST_PRINT("Help : ");
TEST_PRINT(" ./xxx --fb=file.raw --mic=file.raw");
TEST_PRINT(" --in=YYY.raw inout file");
TEST_PRINT(" --performance Generate signal to force algo to maximum process time");
TEST_PRINT(" --perf Enable performence test (little slower but real performence test)");
TEST_PRINT(" --sample-rate=XXXX Signal sample rate (default 48000)");
exit(0);
}
}
// PERFORMANCE test only ....
if (performance == true) {
performanceCompressor();
performanceLimiter();
performanceGate();
return 0;
}
if (inputName == "") {
TEST_ERROR("Can not Process missing parameters...");
exit(-1);
}
TEST_INFO("Read input:");
std::vector<double> inputData = convert(etk::FSNodeReadAllDataType<int16_t>(inputName));
TEST_INFO(" " << inputData.size() << " samples");
// resize output :
std::vector<double> output;
output.resize(inputData.size(), 0);
// process in chunk of 256 samples
int32_t blockSize = 256;
Performance perfo;
/*
audio::algo::chunkware::Compressor algo;
algo.setThreshold(-10);
algo.setRatio(-5);
int32_t lastPourcent = -1;
for (int32_t iii=0; iii<output.size()/blockSize; ++iii) {
if (lastPourcent != 100*iii / (output.size()/blockSize)) {
lastPourcent = 100*iii / (output.size()/blockSize);
TEST_INFO("Process : " << iii*blockSize << "/" << int32_t(output.size()/blockSize)*blockSize << " " << lastPourcent << "/100");
} else {
TEST_VERBOSE("Process : " << iii*blockSize << "/" << int32_t(output.size()/blockSize)*blockSize);
}
perfo.tic();
algo.process(audio::format_double, &output[iii*blockSize], &inputData[iii*blockSize], blockSize, 1);
if (perf == true) {
perfo.toc();
std::this_thread::sleep_for(std::chrono::milliseconds(1));
}
}
*/
audio::algo::chunkware::Limiter algo;
algo.setSampleRate(48000);
algo.setThreshold(0);
algo.setAttack(0.1);
algo.setRelease(2);
algo.init(1);
int32_t lastPourcent = -1;
for (int32_t iii=0; iii<output.size()/blockSize; ++iii) {
if (lastPourcent != 100*iii / (output.size()/blockSize)) {
lastPourcent = 100*iii / (output.size()/blockSize);
TEST_INFO("Process : " << iii*blockSize << "/" << int32_t(output.size()/blockSize)*blockSize << " " << lastPourcent << "/100");
} else {
TEST_VERBOSE("Process : " << iii*blockSize << "/" << int32_t(output.size()/blockSize)*blockSize);
}
perfo.tic();
algo.process(&output[iii*blockSize], &inputData[iii*blockSize], blockSize, 1, audio::format_double);
if (perf == true) {
perfo.toc();
std::this_thread::sleep_for(std::chrono::milliseconds(1));
}
}
if (perf == true) {
TEST_INFO("Performance Result: ");
TEST_INFO(" blockSize=" << blockSize << " sample");
TEST_INFO(" min=" << perfo.getMinProcessing().count() << " ns");
TEST_INFO(" max=" << perfo.getMaxProcessing().count() << " ns");
TEST_INFO(" avg=" << perfo.getTotalTimeProcessing().count()/perfo.getTotalIteration() << " ns");
TEST_INFO(" min=" << (float((perfo.getMinProcessing().count()*sampleRate)/blockSize)/1000000000.0)*100.0 << " %");
TEST_INFO(" max=" << (float((perfo.getMaxProcessing().count()*sampleRate)/blockSize)/1000000000.0)*100.0 << " %");
TEST_INFO(" avg=" << (float(((perfo.getTotalTimeProcessing().count()/perfo.getTotalIteration())*sampleRate)/blockSize)/1000000000.0)*100.0 << " %");
}
etk::FSNodeWriteAllDataType<int16_t>("output.raw", convert(output));
}
static v8::Handle<v8::Value> webkitGetEntriesCallback(const v8::Arguments& args)
{
Performance* imp = V8Performance::toNative(args.Holder());
return toV8(imp->webkitGetEntries(), args.Holder(), args.GetIsolate());
}
static void benchX86(uint32_t arch, uint32_t callConv) {
using namespace asmjit;
Performance perf;
TestRuntime runtime(arch, callConv);
X86Assembler a(&runtime, arch);
X86Compiler c;
uint32_t r, i;
const char* archName = arch == kArchX86 ? "X86" : "X64";
// --------------------------------------------------------------------------
// [Bench - Opcode]
// --------------------------------------------------------------------------
size_t asmOutputSize = 0;
size_t cmpOutputSize = 0;
perf.reset();
for (r = 0; r < kNumRepeats; r++) {
asmOutputSize = 0;
perf.start();
for (i = 0; i < kNumIterations; i++) {
asmgen::opcode(a);
void *p = a.make();
runtime.release(p);
asmOutputSize += a.getCodeSize();
a.reset();
}
perf.end();
}
printf("%-12s (%s) | Time: %-6u [ms] | Speed: %7.3f [MB/s]\n",
"X86Assembler", archName, perf.best, mbps(perf.best, asmOutputSize));
// --------------------------------------------------------------------------
// [Bench - Blend]
// --------------------------------------------------------------------------
perf.reset();
for (r = 0; r < kNumRepeats; r++) {
cmpOutputSize = 0;
perf.start();
for (i = 0; i < kNumIterations; i++) {
c.attach(&a);
asmgen::blend(c);
c.finalize();
void* p = a.make();
runtime.release(p);
cmpOutputSize += a.getCodeSize();
a.reset();
}
perf.end();
}
printf("%-12s (%s) | Time: %-6u [ms] | Speed: %7.3f [MB/s]\n",
"X86Compiler", archName, perf.best, mbps(perf.best, cmpOutputSize));
}
static v8::Handle<v8::Value> webkitClearResourceTimingsCallback(const v8::Arguments& args)
{
Performance* imp = V8Performance::toNative(args.Holder());
imp->webkitClearResourceTimings();
return v8Undefined();
}