C++ OutputList::push_back方法代码示例

ZeroCrossing::OutputList
ZeroCrossing::getOutputDescriptors() const
{
    OutputList list;

    OutputDescriptor zc;
    zc.identifier = "counts";
    zc.name = "Zero Crossing Counts";
    zc.description = "The number of zero crossing points per processing block";
    zc.unit = "crossings";
    zc.hasFixedBinCount = true;
    zc.binCount = 1;
    zc.hasKnownExtents = false;
    zc.isQuantized = true;
    zc.quantizeStep = 1.0;
    zc.sampleType = OutputDescriptor::OneSamplePerStep;
    list.push_back(zc);

    zc.identifier = "zerocrossings";
    zc.name = "Zero Crossings";
    zc.description = "The locations of zero crossing points";
    zc.unit = "";
    zc.hasFixedBinCount = true;
    zc.binCount = 0;
    zc.sampleType = OutputDescriptor::VariableSampleRate;
    zc.sampleRate = m_inputSampleRate;
    list.push_back(zc);

    return list;
}

Energy::OutputList
Energy::getOutputDescriptors() const
{
    OutputList list;

    OutputDescriptor rmsenergy;
    rmsenergy.identifier = "rmsenergy";
    rmsenergy.name = "RMS Energy";
    rmsenergy.description = "RMS of the signal.";
    rmsenergy.unit = "";
    rmsenergy.hasFixedBinCount = true;
    rmsenergy.binCount = 1;
    rmsenergy.hasKnownExtents = false;
    rmsenergy.isQuantized = false;
    rmsenergy.sampleType = OutputDescriptor::OneSamplePerStep;
    rmsenergy.hasDuration = false;
    list.push_back(rmsenergy);

    OutputDescriptor lowenergy;
    lowenergy.identifier = "lowenergy";
    lowenergy.name = "Low Energy";
    lowenergy.description = "Percentage of track which is below the low energy threshold.";
    lowenergy.unit = "";
    lowenergy.hasFixedBinCount = true;
    lowenergy.binCount = 1;
    lowenergy.hasKnownExtents = false;
    lowenergy.isQuantized = false;
    lowenergy.sampleType = OutputDescriptor::VariableSampleRate;
    lowenergy.sampleRate = 0;
    lowenergy.hasDuration = false;
    list.push_back(lowenergy);

    return list;
}

PercussionOnsetDetector::OutputList
PercussionOnsetDetector::getOutputDescriptors() const
{
    OutputList list;

    OutputDescriptor d;
    d.identifier = "onsets";
    d.name = "Onsets";
    d.description = "Percussive note onset locations";
    d.unit = "";
    d.hasFixedBinCount = true;
    d.binCount = 0;
    d.hasKnownExtents = false;
    d.isQuantized = false;
    d.sampleType = OutputDescriptor::VariableSampleRate;
    d.sampleRate = m_inputSampleRate;
    list.push_back(d);

    d.identifier = "detectionfunction";
    d.name = "Detection Function";
    d.description = "Broadband energy rise detection function";
    d.binCount = 1;
    d.isQuantized = true;
    d.quantizeStep = 1.0;
    d.sampleType = OutputDescriptor::OneSamplePerStep;
    list.push_back(d);

    return list;
}

MFCCPlugin::OutputList
MFCCPlugin::getOutputDescriptors() const
{
    OutputList list;

    OutputDescriptor d;
    d.identifier = "coefficients";
    d.name = "Coefficients";
    d.unit = "";
    d.description = "MFCC values";
    d.hasFixedBinCount = true;
    d.binCount = m_bins;
    d.hasKnownExtents = false;
    d.isQuantized = false;
    d.sampleType = OutputDescriptor::OneSamplePerStep;
    list.push_back(d);

    d.identifier = "means";
    d.name = "Means of Coefficients";
    d.description = "Mean values of MFCCs across duration of audio input";
    d.sampleType = OutputDescriptor::FixedSampleRate;
    d.sampleRate = 1;
    list.push_back(d);

    return list;
}

BarBeatTracker::OutputList
BarBeatTracker::getOutputDescriptors() const
{
    OutputList list;

    OutputDescriptor beat;
    beat.identifier = "beats";
    beat.name = "Beats";
    beat.description = "Beat locations labelled with metrical position";
    beat.unit = "";
    beat.hasFixedBinCount = true;
    beat.binCount = 0;
    beat.sampleType = OutputDescriptor::VariableSampleRate;
    beat.sampleRate = 1.0 / m_stepSecs;

    OutputDescriptor bars;
    bars.identifier = "bars";
    bars.name = "Bars";
    bars.description = "Bar locations";
    bars.unit = "";
    bars.hasFixedBinCount = true;
    bars.binCount = 0;
    bars.sampleType = OutputDescriptor::VariableSampleRate;
    bars.sampleRate = 1.0 / m_stepSecs;

    OutputDescriptor beatcounts;
    beatcounts.identifier = "beatcounts";
    beatcounts.name = "Beat Count";
    beatcounts.description = "Beat counter function";
    beatcounts.unit = "";
    beatcounts.hasFixedBinCount = true;
    beatcounts.binCount = 1;
    beatcounts.sampleType = OutputDescriptor::VariableSampleRate;
    beatcounts.sampleRate = 1.0 / m_stepSecs;

    OutputDescriptor beatsd;
    beatsd.identifier = "beatsd";
    beatsd.name = "Beat Spectral Difference";
    beatsd.description = "Beat spectral difference function used for bar-line detection";
    beatsd.unit = "";
    beatsd.hasFixedBinCount = true;
    beatsd.binCount = 1;
    beatsd.sampleType = OutputDescriptor::VariableSampleRate;
    beatsd.sampleRate = 1.0 / m_stepSecs;

    list.push_back(beat);
    list.push_back(bars);
    list.push_back(beatcounts);
    list.push_back(beatsd);

    return list;
}

OnsetDetector::OutputList
OnsetDetector::getOutputDescriptors() const
{
    OutputList list;

    float stepSecs = m_preferredStepSecs;
//    if (m_d) stepSecs = m_d->dfConfig.stepSecs;

    OutputDescriptor onsets;
    onsets.identifier = "onsets";
    onsets.name = "Note Onsets";
    onsets.description = "Perceived note onset positions";
    onsets.unit = "";
    onsets.hasFixedBinCount = true;
    onsets.binCount = 0;
    onsets.sampleType = OutputDescriptor::VariableSampleRate;
    onsets.sampleRate = 1.0 / stepSecs;

    OutputDescriptor df;
    df.identifier = "detection_fn";
    df.name = "Onset Detection Function";
    df.description = "Probability function of note onset likelihood";
    df.unit = "";
    df.hasFixedBinCount = true;
    df.binCount = 1;
    df.hasKnownExtents = false;
    df.isQuantized = false;
    df.sampleType = OutputDescriptor::OneSamplePerStep;

    OutputDescriptor sdf;
    sdf.identifier = "smoothed_df";
    sdf.name = "Smoothed Detection Function";
    sdf.description = "Smoothed probability function used for peak-picking";
    sdf.unit = "";
    sdf.hasFixedBinCount = true;
    sdf.binCount = 1;
    sdf.hasKnownExtents = false;
    sdf.isQuantized = false;

    sdf.sampleType = OutputDescriptor::VariableSampleRate;

//!!! SV doesn't seem to handle these correctly in getRemainingFeatures
//    sdf.sampleType = OutputDescriptor::FixedSampleRate;
    sdf.sampleRate = 1.0 / stepSecs;

    list.push_back(onsets);
    list.push_back(df);
    list.push_back(sdf);

    return list;
}

TonalChangeDetect::OutputList TonalChangeDetect::getOutputDescriptors() const
{
    OutputList list;

    OutputDescriptor hc;
    hc.identifier = "tcstransform";
    hc.name = "Transform to 6D Tonal Content Space";
    hc.unit = "";
    hc.description = "Representation of content in a six-dimensional tonal space";
    hc.hasFixedBinCount = true;
    hc.binCount = 6;
    hc.hasKnownExtents = true;
    hc.minValue = -1.0;
    hc.maxValue = 1.0;
    hc.isQuantized = false;
    hc.sampleType = OutputDescriptor::OneSamplePerStep;

    OutputDescriptor d;
    d.identifier = "tcfunction";
    d.name = "Tonal Change Detection Function";
    d.unit = "";
    d.description = "Estimate of the likelihood of a tonal change occurring within each spectral frame";
    d.minValue = 0;
    d.minValue = 2;
    d.hasFixedBinCount = true;
    d.binCount = 1;
    d.hasKnownExtents = false;
    d.isQuantized = false;
    d.sampleType = OutputDescriptor::VariableSampleRate;
    double dStepSecs = double(getPreferredStepSize()) / m_inputSampleRate;
    d.sampleRate = 1.0f / dStepSecs;

    OutputDescriptor changes;
    changes.identifier = "changepositions";
    changes.name = "Tonal Change Positions";
    changes.unit = "";
    changes.description = "Estimated locations of tonal changes";
    changes.hasFixedBinCount = true;
    changes.binCount = 0;
    changes.hasKnownExtents = false;
    changes.isQuantized = false;
    changes.sampleType = OutputDescriptor::VariableSampleRate;
    changes.sampleRate = 1.0 / dStepSecs;

    list.push_back(hc);
    list.push_back(d);
    list.push_back(changes);

    return list;
}

Vamp::Plugin::OutputList VampPlugin::getOutputDescriptors() const
{
    OutputList outputs;

    OutputDescriptor out;
    out.identifier = "output";
    out.name = "Output";
    out.sampleType = OutputDescriptor::FixedSampleRate;
    out.hasFixedBinCount = true;
    if (m_system)
    {
#if 1
      mrs_natural in_rate = m_system->getControl("mrs_natural/inSamples")->to<mrs_natural>();
      mrs_natural out_rate = m_system->getControl("mrs_natural/onSamples")->to<mrs_natural>();
      float input_output_rate_ratio = (float) out_rate / (float) in_rate;
      out.sampleRate = m_input_sample_rate * input_output_rate_ratio;
#endif
      out.sampleRate = m_input_sample_rate / (m_step_size * out_rate);
      out.binCount = m_system->getControl("mrs_natural/onObservations")->to<mrs_natural>();
    }

    outputs.push_back(out);

    return outputs;
}

CQChromaVamp::OutputList
CQChromaVamp::getOutputDescriptors() const
{
    OutputList list;

    OutputDescriptor d;
    d.identifier = "chromagram";
    d.name = "Chromagram";
    d.unit = "";
    d.description = "Chromagram obtained from output of constant-Q transform, folding over each process block into a single-octave vector";
    d.hasFixedBinCount = true;
    d.binCount = m_bpo;

    if (m_chroma) {
        for (int i = 0; i < (int)d.binCount; ++i) {
            d.binNames.push_back(m_chroma->getBinName(i));
        }
    }

    d.hasKnownExtents = false;
    d.isQuantized = false;
    d.sampleType = OutputDescriptor::FixedSampleRate;
    d.sampleRate = m_inputSampleRate / (m_chroma ? m_chroma->getColumnHop() : 256);
    list.push_back(d);

    return list;
}

SegmenterPlugin::OutputList
SegmenterPlugin::getOutputDescriptors() const
{
    OutputList list;
	
    OutputDescriptor segmentation;
    segmentation.identifier = "segmentation";
    segmentation.name = "Segmentation";
    segmentation.description = "Segmentation";
    segmentation.unit = "segment-type";
    segmentation.hasFixedBinCount = true;
    segmentation.binCount = 1;
    segmentation.hasKnownExtents = true;
    segmentation.minValue = 1;
    segmentation.maxValue = nSegmentTypes;
    segmentation.isQuantized = true;
    segmentation.quantizeStep = 1;
    segmentation.sampleType = OutputDescriptor::VariableSampleRate;
    segmentation.sampleRate = m_inputSampleRate / getPreferredStepSize();
    segmentation.hasDuration = true;
	
    list.push_back(segmentation);
    
    return list;
}

MF0UA::OutputList
MF0UA::getOutputDescriptors() const
{
    OutputList list;

    // See OutputDescriptor documentation for the possibilities here.
    // Every plugin must have at least one output.

    OutputDescriptor d;
    d.identifier = "mf0ua";
    d.name = "UA Multiple f0 Estimation";
    d.description = "Estimated note pitch (MIDI note number)";
    d.unit = "MIDI units";
    d.hasFixedBinCount=true;
    d.binCount = 1;
    d.hasKnownExtents = true;
    d.minValue = 0;
    d.maxValue = 127;
    d.isQuantized = true;
    d.quantizeStep = 1;
    d.sampleType = OutputDescriptor::VariableSampleRate;
    d.sampleRate = (m_stepSize == 0) ? m_inputSampleRate/2048 : m_inputSampleRate/m_stepSize;
    d.hasDuration = true;
    list.push_back(d);

    return list;
}

AdaptiveSpectrogram::OutputList
AdaptiveSpectrogram::getOutputDescriptors() const
{
    OutputList list;

    OutputDescriptor d;
    d.identifier = "output";
    d.name = "Output";
    d.description = "The output of the plugin";
    d.unit = "";
    d.hasFixedBinCount = true;
    d.binCount = getPreferredBlockSize() / 2;
    d.hasKnownExtents = false;
    d.isQuantized = false;
    d.sampleType = OutputDescriptor::FixedSampleRate;
    d.sampleRate = m_inputSampleRate / ((2 << m_w) / 2);
    d.hasDuration = false;
    char name[20];
    for (int i = 0; i < d.binCount; ++i) {
        float freq = (m_inputSampleRate / (d.binCount * 2)) * (i + 1); // no DC bin
        sprintf(name, "%d Hz", int(freq));
        d.binNames.push_back(name);
    }
    list.push_back(d);

    return list;
}

PluginHostAdapter::OutputList
PluginHostAdapter::getOutputDescriptors() const
{
    OutputList list;
    if (!m_handle) {
//        std::cerr << "PluginHostAdapter::getOutputDescriptors: no handle " << std::endl;
        return list;
    }

    unsigned int count = m_descriptor->getOutputCount(m_handle);

    for (unsigned int i = 0; i < count; ++i) {
        VampOutputDescriptor *sd = m_descriptor->getOutputDescriptor(m_handle, i);
        OutputDescriptor d;
        d.identifier = sd->identifier;
        d.name = sd->name;
        d.description = sd->description;
        d.unit = sd->unit;
        d.hasFixedBinCount = sd->hasFixedBinCount;
        d.binCount = sd->binCount;
        if (d.hasFixedBinCount && sd->binNames) {
            for (unsigned int j = 0; j < sd->binCount; ++j) {
                d.binNames.push_back(sd->binNames[j] ? sd->binNames[j] : "");
            }
        }
        d.hasKnownExtents = sd->hasKnownExtents;
        d.minValue = sd->minValue;
        d.maxValue = sd->maxValue;
        d.isQuantized = sd->isQuantized;
        d.quantizeStep = sd->quantizeStep;

        switch (sd->sampleType) {
        case vampOneSamplePerStep:
            d.sampleType = OutputDescriptor::OneSamplePerStep;
            break;
        case vampFixedSampleRate:
            d.sampleType = OutputDescriptor::FixedSampleRate;
            break;
        case vampVariableSampleRate:
            d.sampleType = OutputDescriptor::VariableSampleRate;
            break;
        }

        d.sampleRate = sd->sampleRate;

        if (m_descriptor->vampApiVersion >= 2) {
            d.hasDuration = sd->hasDuration;
        } else {
            d.hasDuration = false;
        }

        list.push_back(d);

        m_descriptor->releaseOutputDescriptor(sd);
    }

    return list;
}

Silence::OutputList
Silence::getOutputDescriptors() const
{
    OutputList list;

    OutputDescriptor d;

    d.identifier = "silent";
    d.name = "Silent Regions";
    d.description = "Return an interval covering each silent region";
    d.hasFixedBinCount = true;
    d.binCount = 0;
    d.hasKnownExtents = false;
    d.sampleType = OutputDescriptor::VariableSampleRate;
    d.sampleRate = 0;
    d.hasDuration = true;
    list.push_back(d);

    d.identifier = "noisy";
    d.name = "Non-Silent Regions";
    d.description = "Return an interval covering each non-silent region";
    d.hasFixedBinCount = true;
    d.binCount = 0;
    d.hasKnownExtents = false;
    d.sampleType = OutputDescriptor::VariableSampleRate;
    d.sampleRate = 0;
    d.hasDuration = true;
    list.push_back(d);

    d.identifier = "silencelevel";
    d.name = "Silence Test";
    d.description = "Return a function that switches from 1 to 0 when silence falls, and back again when it ends";
    d.hasFixedBinCount = true;
    d.binCount = 1;
    d.hasKnownExtents = true;
    d.minValue = 0;
    d.maxValue = 1;
    d.isQuantized = true;
    d.quantizeStep = 1;
    d.sampleType = OutputDescriptor::VariableSampleRate;
    d.sampleRate = 0;
    list.push_back(d);

    return list;
}

BeatTracker::OutputList
BeatTracker::getOutputDescriptors() const
{
    OutputList list;

    OutputDescriptor beat;
    beat.identifier = "beats";
    beat.name = "Beats";
    beat.description = "Estimated metrical beat locations";
    beat.unit = "";
    beat.hasFixedBinCount = true;
    beat.binCount = 0;
    beat.sampleType = OutputDescriptor::VariableSampleRate;
    beat.sampleRate = 1.0 / m_stepSecs;

    OutputDescriptor df;
    df.identifier = "detection_fn";
    df.name = "Onset Detection Function";
    df.description = "Probability function of note onset likelihood";
    df.unit = "";
    df.hasFixedBinCount = true;
    df.binCount = 1;
    df.hasKnownExtents = false;
    df.isQuantized = false;
    df.sampleType = OutputDescriptor::OneSamplePerStep;

    OutputDescriptor tempo;
    tempo.identifier = "tempo";
    tempo.name = "Tempo";
    tempo.description = "Locked tempo estimates";
    tempo.unit = "bpm";
    tempo.hasFixedBinCount = true;
    tempo.binCount = 1;
    tempo.hasKnownExtents = false;
    tempo.isQuantized = false;
    tempo.sampleType = OutputDescriptor::VariableSampleRate;
    tempo.sampleRate = 1.0 / m_stepSecs;

    list.push_back(beat);
    list.push_back(df);
    list.push_back(tempo);

    return list;
}