import edu.cmu.sphinx.result.Result; //导入依赖的package包/类
/**
 * Performs a single recognition
 */
public void run() {
    if (recognizer != null && microphone != null) {
        automaton.updateStatus(_LISTENING_FOR_COMMAND);
        microphone.clear();
        microphone.startRecording();
        Result result = recognizer.recognize();
        microphone.stopRecording();

        if (result != null) {
            String resultText = result.getBestFinalResultNoFiller();
            String phrase = resultText.trim().toUpperCase();
            fireListeners(phrase);
        }
    }
}
 

import edu.cmu.sphinx.result.Result; //导入依赖的package包/类
@Override
public void newResult(final Result result) {
    if (result == null)
        return;

    int max = -1;
    for (final String word : result.toString().split(" ")) {
        for (int i = start; i < start + step && i < tokens.size(); i++) {
            if (tokens.get(i).equals(word)) {
                max = i;
                break;
            }
        }
    }
    if (max > 0) {
        start = max;
        newGrammar();
        createGrammar();
        postProcessGrammar();
    }
}
 

import edu.cmu.sphinx.result.Result; //导入依赖的package包/类
public void decode() {

        try {
            utteranceId = 0;
            DataOutputStream ctm = new DataOutputStream(new FileOutputStream(ctmFile));
            recognizer.allocate();

            for (Iterator<CTLUtterance> i = new CTLIterator(); i.hasNext();) {
                CTLUtterance utt = i.next();
                setInputStream(utt);
                Result result = recognizer.recognize();
                System.out.println("Utterance " + utteranceId + ": " + utt.getName());
                System.out.println("Reference: " + utt.getRef());
                System.out.println("Result   : " + result);
                logger.info("Utterance " + utteranceId + ": " + utt.getName());
                logger.info("Result   : " + result);
                handleResult(ctm, utt, result);
                utteranceId++;
            }

            recognizer.deallocate();
        } catch (IOException io) {
            logger.severe("I/O error during decoding: " + io.getMessage());
        }
        logger.info("BatchCTLDecoder: " + utteranceId + " utterances decoded");
    }
 

import edu.cmu.sphinx.result.Result; //导入依赖的package包/类
/**
 * Ranks the given set of tokens
 *
 * @param result the result to process
 */
private void process(Result result) {
    if (result.isFinal()) {
        collectStatistics(result);
    } else {
        List<Token> tokenList = result.getActiveTokens().getTokens();
        if (!tokenList.isEmpty()) {
            Collections.sort(tokenList, Scoreable.COMPARATOR);
            Token bestToken = tokenList.get(0);
            int rank = 0;
            for (Token token : tokenList) {
                float scoreDiff = bestToken.getScore() -
                        token.getScore();
                assert scoreDiff >= 0;

                token.getTokenProps().put(TOKEN_RANK, new TokenRank(rank++, scoreDiff));
                assert tokenIsRanked(token);
            }
        }
    }
}
 

import edu.cmu.sphinx.result.Result; //导入依赖的package包/类
@Override
public void newResult(Result result) {
    String ref = result.getReferenceText();
    if (result.isFinal() && ref != null) {
        Lattice lattice = new Lattice(result);
        LatticeOptimizer optimizer = new LatticeOptimizer(lattice);
        optimizer.optimize();           
        lattice.computeNodePosteriors(languageModelWeight);
        SausageMaker sausageMaker = new SausageMaker(lattice);
        Sausage sausage = sausageMaker.makeSausage();
        sausage.removeFillers();
            
        getAligner().alignSausage(ref, sausage);
        showFullPath(result);
        showDetails(result.toString());
    }
}
 

import edu.cmu.sphinx.result.Result; //导入依赖的package包/类
@Override
public void newResult(Result result) {
    String ref = result.getReferenceText();
    if (result.isFinal() && ref != null) {
        numUtterances++;
        String hyp = result.getBestResultNoFiller();
        if (ref.equals("<unk>")) {
            numOutOfGrammarUtterances++;
            if (hyp.equals("<unk>")) {
                numCorrectOutOfGrammarUtterances++;
            } else {
                numFalseInGrammarUtterances++;
            }
        } else {
            if (hyp.equals("<unk>")) {
                numFalseOutOfGrammarUtterances++;
            } else {
                numCorrectInGrammarUtterances++;
            }
        }
        printStats();
    }
}
 

import edu.cmu.sphinx.result.Result; //导入依赖的package包/类
@Override
public void run()
{
  logger.info("Starting speech recognition");
  startMicrophone();

  while (!threadComponent.isStopped())
  {
    try
    {
      Result result = recognizer.recognize();

      if (result != null)
      {
        processResult(result);
      }
    } catch (RuntimeException e)
    {
      // This happens when the recognizer is deallocated (which only happens when the stop() method was called)
    }
  }

  logger.info("Ending speech recognition");
}
 

import edu.cmu.sphinx.result.Result; //导入依赖的package包/类
/**
 * Gets a space delimited string of tags representing the result
 * 
 * @param result
 *            the recognition result
 * @return the tag string
 * @throws GrammarException
 *             if there is an error while parsing the result
 */
String getTagString(Result result) throws GrammarException {
	RuleParse ruleParse = getRuleParse(result);
	if (ruleParse == null)
		return null;
	String[] tags = ruleParse.getTags();
	if (tags == null)
		return "";
	StringBuilder sb = new StringBuilder();
	for (String tag : tags)
		sb.append(tag).append(' ');
	return sb.toString().trim();
}
 

import edu.cmu.sphinx.result.Result; //导入依赖的package包/类
public void run()
{
	Utils.log("debug", "Recognition thread starting");

	while (true == mRecognitionThreadEnabled)
	{
		if (!mMicrophone.isRecording())
		{
			Utils.log("warning", "Recognition thread is running, but " 
				+ "the microphone is disabled.");
		}
		else
		{
               Result result = null;
               try
               {
                   result = mRecognizer.recognize();
               } catch (Throwable t) {}

               if (result != null)
               {
                   String s = result.getBestFinalResultNoFiller();

                   // Only save non-empty strings.
                   if (!s.equals(""))
                   {
                       Utils.log("debug", "Finished recognizing");
                       mRecognizedStringQueue.addLast(s);
                   }
               }

           }

	}

	Utils.log("debug", "Recognition thread finished");
}
 

import edu.cmu.sphinx.result.Result; //导入依赖的package包/类
/**
 * Performs recognition for the given number of input frames, or until a 'final' result is generated. This method
 * should only be called when the recognizer is in the <code>allocated</code> state.
 *
 * @param referenceText what was actually spoken
 * @return a recognition result
 * @throws IllegalStateException if the recognizer is not in the <code>ALLOCATED</code> state
 */
public Result recognize(String referenceText) throws IllegalStateException {
    Result result = null;
    checkState(State.READY);
    try {
        setState(State.RECOGNIZING);
        result = decoder.decode(referenceText);
    } finally {
        setState(State.READY);
    }
    return result;
}
 

import edu.cmu.sphinx.result.Result; //导入依赖的package包/类
/**
 * Decodes the batch of audio files
 */
public void decode(String batchFile) throws IOException {
    BatchItem batchItem;
    int count = 0;
    try {
        recognizer.allocate();
        setBatchFile(batchFile);

        batchManager.start();
        logger.info("BatchDecoder: decoding files in "
                + batchManager.getFilename());

        while (count < utteranceId &&
                (batchItem = batchManager.getNextItem()) != null) {
            setInputStream(batchItem.getFilename());
            Result result = recognizer.recognize(batchItem.getTranscript());
            logger.info("File  : " + batchItem.getFilename());
            logger.info("Result: " + result);
            count++;
        }
        batchManager.stop();
        recognizer.deallocate();
    } catch (IOException io) {
        logger.severe("I/O error during decoding: " + io.getMessage());
        throw io;
    }
    logger.info("BatchDecoder: " + count + " files decoded");
}
 

import edu.cmu.sphinx.result.Result; //导入依赖的package包/类
public Result recognize() throws IOException {
    Result result = null;
    BatchItem batchItem;
    if (count < utteranceId &&
            (batchItem = batchManager.getNextItem()) != null) {
        setInputStream(batchItem.getFilename());
        result = recognizer.recognize(batchItem.getTranscript());
        logger.info("File  : " + batchItem.getFilename());
        logger.info("Result: " + result);
        count++;
    }
    logger.info("BatchDecoder: " + count + " files decoded");
    return result;
}
 

import edu.cmu.sphinx.result.Result; //导入依赖的package包/类
@Override
public void newResult(Result result) {
    if (result.isFinal()) {
        processingTime = (getTime() - startTime) / 1000.0f;
        totalAudioTime += audioTime;
        totalProcessingTime += processingTime;
        if (showDetails) {
            showAudioUsage();
        }
    }
}
 

import edu.cmu.sphinx.result.Result; //导入依赖的package包/类
@Override
public void newResult(Result result) {
    if (enabled) {
        process(result);
        if (result.isFinal() && showDetails) {
            showLatestResult();
        }
    }
}
 

import edu.cmu.sphinx.result.Result; //导入依赖的package包/类
/**
 * Collects the absolute beam statistics
 *
 * @param result the result of interest
 */
private void collectAbsoluteBeamStatistics(Result result) {
    Token token = result.getBestToken();
    int count = 0;
    int sumBeam = 0;
    maxAbsoluteBeam = 0;
    while (token != null) {
        if (token.isEmitting()) {
            TokenRank rank = (TokenRank) token.getTokenProps().get(TOKEN_RANK);
            if (rank != null) {
                if (rank.getAbsoluteRank() > maxAbsoluteBeam) {
                    maxAbsoluteBeam = rank.getAbsoluteRank();
                }
                sumBeam += rank.getAbsoluteRank();
                count++;
            } else {
                if (token.getFrameNumber() > 0) {
                    System.out.println("Null rank! for " + token);
                }
            }
        }
        token = token.getPredecessor();
    }

    if (count > 0) {
        avgAbsoluteBeam = sumBeam / count;
        if (maxAbsoluteBeam > totMaxAbsoluteBeam) {
            totMaxAbsoluteBeam = maxAbsoluteBeam;
        }
        sumAbsoluteBeam += avgAbsoluteBeam;
    }
}
 

import edu.cmu.sphinx.result.Result; //导入依赖的package包/类
/**
 * Returns the maximum relative beam for a the chain of tokens reachable from the given token
 *
 * @param result the result of interest
 */
private void collectRelativeBeamStatistics(Result result) {
    Token token = result.getBestToken();
    int count = 0;
    double sumBeam = 0.0;

    maxRelativeBeam = -Float.MAX_VALUE;

    while (token != null) {
        if (token.isEmitting()) {
            TokenRank rank = (TokenRank) token.getTokenProps().get(TOKEN_RANK);
            if (rank != null) {
                if (rank.getRelativeRank() > maxRelativeBeam) {
                    maxRelativeBeam = rank.getRelativeRank();
                }
                sumBeam += rank.getRelativeRank();
                count++;
            } else {
                if (token.getFrameNumber() > 0) {
                    System.out.println("Null rank! for " + token);
                }
            }
        }
        token = token.getPredecessor();
    }

    if (count > 0) {
        avgRelativeBeam = (float) (sumBeam / count);
        if (maxRelativeBeam > totMaxRelativeBeam) {
            totMaxRelativeBeam = maxRelativeBeam;
        }
        sumRelativeBeam += avgRelativeBeam;
    }
}
 

import edu.cmu.sphinx.result.Result; //导入依赖的package包/类
/**
 * Dumps the best path
 *
 * @param result the result to dump
 */
private void showFullPath(Result result) {
    if (showFullPath) {
        System.out.println();
        Token bestToken = result.getBestToken();
        if (bestToken != null) {
            bestToken.dumpTokenPath();
        } else {
            System.out.println("Null result");
        }
        System.out.println();
    }
}
 

import edu.cmu.sphinx.result.Result; //导入依赖的package包/类
@Override
public void newResult(Result result) {
    String ref = result.getReferenceText();
    if (result.isFinal() && ref != null) {
        String hyp = result.getBestResultNoFiller();
        getAligner().align(ref, hyp);
        showFullPath(result);
        showDetails(result.toString());
    }
}
 

import edu.cmu.sphinx.result.Result; //导入依赖的package包/类
/**
 * Fires new results as soon as they become available.
 *
 * @param result the new result
 */
protected void fireResultListeners(Result result) {
    if (fireNonFinalResults || result.isFinal()) {
        for (ResultListener resultListener : resultListeners) {
            resultListener.newResult(result);
        }
    }else {
        logger.finer("skipping non-final result " + result);
    }
}
 

import edu.cmu.sphinx.result.Result; //导入依赖的package包/类
/**
 * Decode frames until recognition is complete.
 *
 * @param referenceText the reference text (or null)
 * @return a result
 */
@Override
public Result decode(String referenceText) {
    searchManager.startRecognition();
    Result result;
    do {
        result = searchManager.recognize(featureBlockSize);
        if (result != null) {
            result.setReferenceText(referenceText);
            fireResultListeners(result);
        }
    } while (result != null && !result.isFinal());
    searchManager.stopRecognition();
    return result;
}