示例#1
0
void PopulateTableFromQuery(lua_State* state, Query* query)
{
	Results results = query->GetResults();

	int resultid = 1;

	for (Results::iterator it = results.begin(); it != results.end(); ++it) {
		Result* result = *it;

		LUA->PushNumber(resultid++);

		LUA->CreateTable();
		{
			bool status = result->GetErrorID() == 0;
			LUA->PushBool(status);
			LUA->SetField(-2, "status");
			if (!status) {
				LUA->PushString(result->GetError().c_str());
				LUA->SetField(-2, "error");
				LUA->PushNumber(result->GetErrorID());
				LUA->SetField(-2, "errorid");
			}
			else {
				LUA->PushNumber(result->GetAffected());
				LUA->SetField(-2, "affected");
				LUA->PushNumber(result->GetLastID());
				LUA->SetField(-2, "lastid");
				LUA->CreateTable();
				PopulateTableFromResult(state, result->GetResult(), query->GetUseNumbers());
				LUA->SetField(-2, "data");
			}
#ifdef ENABLE_QUERY_TIMERS
			LUA->PushNumber(query->GetQueryTime());
			LUA->SetField(-2, "time");
#endif
		}

		LUA->SetTable(-3);
	}
}
// Create a new results by computing sums for equivalent names ("foo" and "foo@plt").
static Results combineLikeNames(SgAsmInterpretation *interp, const Results &separate) {

    // Index of functions by canonical name
    std::vector<SgAsmFunction*> funcList = SageInterface::querySubTree<SgAsmFunction>(interp);
    Map<std::string, std::vector<SgAsmFunction*> > funcMap;
    BOOST_FOREACH (SgAsmFunction *func, funcList)
        funcMap[canonicalName(func)].push_back(func);

    // Scan through the analysis results and sum by canonical function name
    Map<std::string, UsageCounts> byName;
    for (Results::const_iterator ri=separate.begin(); ri!=separate.end(); ++ri)
        byName[canonicalName(ri->first)] += ri->second;

    // Create a new return value for all the functions.
    Results retval;
    for (Map<std::string, UsageCounts>::iterator i=byName.begin(); i!=byName.end(); ++i) {
        BOOST_FOREACH (SgAsmFunction *func, funcMap[i->first])
            retval[func] = i->second;
    }

    return retval;
}
Test::Results
TestSampleRates::test(string key, Options options)
{
    int rates[] =
        { 111, 800, 10099, 11024, 44100, 48000, 96000, 192000, 201011, 1094091 };

    Results r;

    if (options & Verbose) {
        cout << "    ";
    }

    for (int i = 0; i < int(sizeof(rates)/sizeof(rates[0])); ++i) {
    
        int rate = rates[i];

        if (options & Verbose) {
            cout << "[" << rate << "Hz] " << flush;
        }

        auto_ptr<Plugin> p(load(key, rate));
        Plugin::FeatureSet f;
        float **data = 0;
        size_t channels = 0;

        // Aim to feed the plugin a roughly fixed input duration in secs
        const float seconds = 10.f;
        size_t step = 1000;
        size_t count = (seconds * rate) / step;
        if (count < 1) count = 1;

        Results subr;
        if (!initAdapted(p.get(), channels, step, step, subr)) {
            // This is not an error; the plugin can legitimately
            // refuse to initialise at weird settings and that's often
            // the most acceptable result
            if (!subr.empty()) {
                r.push_back(note(subr.begin()->message()));
            }
            continue;
        }

        data = createTestAudio(channels, step, count);
        for (size_t j = 0; j < count; ++j) {
#ifdef __GNUC__
            float *ptr[channels];
#else
            float **ptr = (float **)alloca(channels * sizeof(float));
#endif
            size_t idx = j * step;
            for (size_t c = 0; c < channels; ++c) ptr[c] = data[c] + idx;
            RealTime timestamp = RealTime::frame2RealTime(idx, rate);
            Plugin::FeatureSet fs = p->process(ptr, timestamp);
            appendFeatures(f, fs);
        }
        Plugin::FeatureSet fs = p->getRemainingFeatures();
        appendFeatures(f, fs);
        destroyTestAudio(data, channels);
    }

    if (options & Verbose) cout << endl;

    // We can't actually do anything meaningful with our results.
    // We're really just testing to see whether the plugin crashes.  I
    // wonder whether it's possible to do any better?  If not, we
    // should probably report our limitations

    return r;
}