python使用微软语音识别

实现同步识别和转语音的micro.py

from win32com.client import constants as _constants
import win32com.client
import pythoncom
import time
from threading import Thread, Event
import os
import threading

# Make sure that we've got our COM wrappers generated.
from win32com.client import gencache

gencache.EnsureModule('{C866CA3A-32F7-11D2-9602-00C04F8EE628}', 0, 5, 0)
_ListenerBase = win32com.client.getevents("SAPI.SpInProcRecoContext")

# 这里加载SpInProcRecognizer，就不会报【尚未调用 CoInitialize】的错误
# 猜测可能是只要加载此模块，就默认成为多线程模式？
_recognizer = win32com.client.Dispatch("SAPI.SpInProcRecognizer")

class _ListenerCallback(_ListenerBase):
    def __init__(self, oobj, listener, callback):

        _ListenerBase.__init__(self, oobj)
        print("444444")
        self._listener = listener
        self._callback = callback

    def OnRecognition(self, StreamNumber, StreamPosition, RecognitionType, Result):
        print('-------Recognition------pid: %d, thd: %s' % (os.getpid(), threading.currentThread()))

        if self._listener and not self._listener.is_listening():
            self.close()
            self._listener = None

        if self._callback and self._listener:
            new_result = win32com.client.Dispatch(Result)
            phraseinfo = new_result.PhraseInfo

            phrase = phraseinfo.GetText()
            audio_stream_position = float(phraseinfo.AudioStreamPosition)

            confidence = float(new_result.PhraseInfo.Elements.Item(0).EngineConfidence)
            self._callback('Recognition', phrase, confidence, self._listener, audio_stream_position)

    def OnStartStream(self, StreamNumber, StreamPosition):
        print('-------StartStream------')
        if self._listener and not self._listener.is_listening():
            self.close()
            self._listener = None
        # print("pid: %d, thd: %s" % (os.getpid(), threading.currentThread()))

        self._callback('StartStream', None, None, self._listener, None)
        print(888888)


    def OnEndStream(self, StreamNumber, StreamPosition, StreamReleased):
        print('-------EndStream------')
        if self._listener and not self._listener.is_listening():
            self.close()
            self._listener = None

        self._callback('EndStream', None, None, self._listener, None)
        print(999999)

        self.close()
        self._listener = None

def listen_for(word_list, inputtype, wavpath, memstream=b''):
    listener = Listener(word_list, inputtype, wavpath, memstream)

    return listener.loop_listen()


class Listener(object):
    def __init__(self, phrase_list, inputtype, wavname, streamcontent):
        print('!!!!!!!!!!!!!!!!!!')
        self.recognizer = win32com.client.Dispatch("SAPI.SpInProcRecognizer")
        self.listenerBase = win32com.client.getevents("SAPI.SpInProcRecoContext")

        print("id(recognizer)", id(self.recognizer))

        self.phrase_list = phrase_list
        self.inputtype = inputtype

        self.context = self.recognizer.CreateRecoContext()
        self.__is_shut_down = Event()
        self.__shutdown_listen = False
        self._filestream = None
        self._memorystream = None


        if self.inputtype == 0:
            self.recognizer.AudioInputStream = win32com.client.Dispatch("SAPI.SpMMAudioIn")
        elif self.inputtype == 1:
            filestream = win32com.client.Dispatch("SAPI.SpFileStream")
            filestream.Open(wavname, 0, False)
            self.recognizer.AudioInputStream = filestream
            self._filestream = filestream

        else:
            memstream = win32com.client.Dispatch("SAPI.SpMemoryStream")
            memstream.SetData(streamcontent)
            self.recognizer.AudioInputStream = memstream
            self._memorystream = memstream

        context = self.context
        grammar = context.CreateGrammar()

        grammar.DictationSetState(0)
        # dunno why we pass the constants that we do here
        rule = grammar.Rules.Add("rule",
                                 _constants.SRATopLevel + _constants.SRADynamic, 0)
        rule.Clear()

        for phrase in self.phrase_list:
            rule.InitialState.AddWordTransition(None, phrase)

        # not sure if this is needed - was here before but dupe is below
        grammar.Rules.Commit()

        # Commit the changes to the grammar
        grammar.CmdSetRuleState("rule", 1)  # active
        grammar.Rules.Commit()

        self._gramar = grammar

        self.result_list = []

    def loop_listen(self):
        def new_thread():
            print("pid", os.getpid())
            a = _ListenerCallback(self.context, self, self.callback)
            print("id(a)", id(a))

            while not self.__shutdown_listen:
                # print(111111)

                pythoncom.PumpWaitingMessages() # 触发

                # print(222222)

                time.sleep(.2)
            self.__is_shut_down.set()

        p = Thread(target=new_thread(), args=())
        p.start()

        # 阻塞等待识别处理结束
        self.__is_shut_down.wait()

        # 返回识别结果
        return self.get_result()


    def callback(self, event, phrase, confidence, listener, audio_stream_position):
        # print("callback envent", event, phrase, confidence)

        if event == 'Recognition':
            self.result_list.append([phrase, confidence, audio_stream_position])
        elif event == 'StartStream':
            self.result_list = []
        elif event == 'EndStream':
            self.stop_listening()
            # pass

    def get_result(self):
        return self.result_list

    def is_listening(self):
        return not self.__shutdown_listen

    def stop_listening(self):
        self.__shutdown_listen = True

        #_gramar置为None， 则event handler can die
        self._gramar = None

        # 如果有filestream或memorystrem，要关闭
        if self._filestream:
            self._filestream.Close()



def say_to_file(context, wavpath):
    """
    如果采用全局_voice, 则多线程时会产生冲突
    因此这里每调用一次函数就新创建一个voice对象
    """
    new_voice = win32com.client.Dispatch("SAPI.SpVoice")
    filestream = win32com.client.Dispatch("SAPI.SpFileStream")

    # SSFMOpenForRead(0) SSFMOpenReadWrite(1) SSFMCreate(2) SSFMCreateForWrite(3)
    # 是否产生voice event, False
    filestream.Open(wavpath, _constants.SSFMCreateForWrite, False) #
    new_voice.AudioOutputStream = filestream
    new_voice.Speak(context)
    filestream.Close()

def say_to_memory(context):
    """
        如果采用全局_voice, 则多线程时会产生冲突
        因此这里每调用一次函数就新创建一个voice对象
        """
    new_voice = win32com.client.Dispatch("SAPI.SpVoice")
    memstream = win32com.client.Dispatch("SAPI.SpMemoryStream")
    new_voice.AudioOutputStream = memstream
    new_voice.Speak(context)

    content = bytes(memstream.GetData())
    return content

原生的py

"""
speech recognition and voice synthesis module.

Please let me know if you like or use this module -- it would make my day!

speech.py: Copyright 2008 Michael Gundlach  (gundlach at gmail)
License: Apache 2.0 (http://www.apache.org/licenses/LICENSE-2.0)

For this module to work, you'll need pywin32 (http://tinyurl.com/5ezco9
for Python 2.5 or http://tinyurl.com/5uzpox for Python 2.4) and
the Microsoft Speech kit (http://tinyurl.com/zflb).


Classes:
    Listener: represents a command to execute when phrases are heard.

Functions:
    say(phrase): Say the given phrase out loud.
    input(prompt, phraselist): Block until input heard, then return text.
    stoplistening(): Like calling stoplistening() on all Listeners.
    islistening(): True if any Listener is listening.
    listenforanything(callback): Run a callback when any text is heard.
    listenfor(phraselist, callback): Run a callback when certain text is heard.


Very simple usage example:

import speech

speech.say("Say something.")

print "You said " + speech.input()

def L1callback(phrase, listener):
    print phrase

def L2callback(phrase, listener):
    if phrase == "wow":
        listener.stoplistening()
    speech.say(phrase)

# callbacks are executed on a separate events thread.
L1 = speech.listenfor(["hello", "good bye"], L1callback)
L2 = speech.listenforanything(L2callback)

assert speech.islistening()
assert L2.islistening()

L1.stoplistening()
assert not L1.islistening()

speech.stoplistening()
"""

from win32com.client import constants as _constants
import win32com.client
import pythoncom
import time
import thread

# Make sure that we've got our COM wrappers generated.
from win32com.client import gencache
gencache.EnsureModule('{C866CA3A-32F7-11D2-9602-00C04F8EE628}', 0, 5, 0)

_voice = win32com.client.Dispatch("SAPI.SpVoice")
_recognizer = win32com.client.Dispatch("SAPI.SpSharedRecognizer")
_listeners = []
_handlerqueue = []
_eventthread=None

class Listener(object):

    """Listens for speech and calls a callback on a separate thread."""

    _all = set()

    def __init__(self, context, grammar, callback):
        """
        This should never be called directly; use speech.listenfor()
        and speech.listenforanything() to create Listener objects.
        """
        self._grammar = grammar
        Listener._all.add(self)

        # Tell event thread to create an event handler to call our callback
        # upon hearing speech events
        _handlerqueue.append((context, self, callback))
        _ensure_event_thread()

    def islistening(self):
        """True if this Listener is listening for speech."""
        return self in Listener._all

    def stoplistening(self):
        """Stop listening for speech.  Returns True if we were listening."""

        try:
            Listener._all.remove(self)
        except KeyError:
            return False

        # This removes all refs to _grammar so the event handler can die
        self._grammar = None

        if not Listener._all:
            global _eventthread
            _eventthread = None # Stop the eventthread if it exists

        return True

_ListenerBase = win32com.client.getevents("SAPI.SpSharedRecoContext")
class _ListenerCallback(_ListenerBase):

    """Created to fire events upon speech recognition.  Instances of this
    class automatically die when their listener loses a reference to
    its grammar.  TODO: we may need to call self.close() to release the
    COM object, and we should probably make goaway() a method of self
    instead of letting people do it for us.
    """

    def __init__(self, oobj, listener, callback):
        _ListenerBase.__init__(self, oobj)
        self._listener = listener
        self._callback = callback

    def OnRecognition(self, _1, _2, _3, Result):
        # When our listener stops listening, it's supposed to kill this
        # object.  But COM can be funky, and we may have to call close()
        # before the object will die.
        if self._listener and not self._listener.islistening():
            self.close()
            self._listener = None

        if self._callback and self._listener:
            newResult = win32com.client.Dispatch(Result)
            phrase = newResult.PhraseInfo.GetText()
            self._callback(phrase, self._listener)

def say(phrase):
    """Say the given phrase out loud."""
    _voice.Speak(phrase)


def input(prompt=None, phraselist=None):
    """
    Print the prompt if it is not None, then listen for a string in phraselist
    (or anything, if phraselist is None.)  Returns the string response that is
    heard.  Note that this will block the thread until a response is heard or
    Ctrl-C is pressed.
    """
    def response(phrase, listener):
        if not hasattr(listener, '_phrase'):
            listener._phrase = phrase # so outside caller can find it
        listener.stoplistening()

    if prompt:
        print prompt

    if phraselist:
        listener = listenfor(phraselist, response)
    else:
        listener = listenforanything(response)

    while listener.islistening():
        time.sleep(.1)

    return listener._phrase # hacky way to pass back a response...

def stoplistening():
    """
    Cause all Listeners to stop listening.  Returns True if at least one
    Listener was listening.
    """
    listeners = set(Listener._all) # clone so stoplistening can pop()
    returns = [l.stoplistening() for l in listeners]
    return any(returns) # was at least one listening?

def islistening():
    """True if any Listeners are listening."""
    return not not Listener._all

def listenforanything(callback):
    """
    When anything resembling English is heard, callback(spoken_text, listener)
    is executed.  Returns a Listener object.

    The first argument to callback will be the string of text heard.
    The second argument will be the same listener object returned by
    listenforanything().

    Execution takes place on a single thread shared by all listener callbacks.
    """
    return _startlistening(None, callback)

def listenfor(phraselist, callback):
    """
    If any of the phrases in the given list are heard,
    callback(spoken_text, listener) is executed.  Returns a Listener object.

    The first argument to callback will be the string of text heard.
    The second argument will be the same listener object returned by
    listenfor().

    Execution takes place on a single thread shared by all listener callbacks.
    """
    return _startlistening(phraselist, callback)

def _startlistening(phraselist, callback):
    """
    Starts listening in Command-and-Control mode if phraselist is
    not None, or dictation mode if phraselist is None.  When a phrase is
    heard, callback(phrase_text, listener) is executed.  Returns a
    Listener object.

    The first argument to callback will be the string of text heard.
    The second argument will be the same listener object returned by
    listenfor().

    Execution takes place on a single thread shared by all listener callbacks.
    """
    # Make a command-and-control grammar        
    context = _recognizer.CreateRecoContext()
    grammar = context.CreateGrammar()

    if phraselist:
        grammar.DictationSetState(0)
        # dunno why we pass the constants that we do here
        rule = grammar.Rules.Add("rule",
                _constants.SRATopLevel + _constants.SRADynamic, 0)
        rule.Clear()

        for phrase in phraselist:
            rule.InitialState.AddWordTransition(None, phrase)

        # not sure if this is needed - was here before but dupe is below
        grammar.Rules.Commit()

        # Commit the changes to the grammar
        grammar.CmdSetRuleState("rule", 1) # active
        grammar.Rules.Commit()
    else:
        grammar.DictationSetState(1)

    return Listener(context, grammar, callback)

def _ensure_event_thread():
    """
    Make sure the eventthread is running, which checks the handlerqueue
    for new eventhandlers to create, and runs the message pump.
    """
    global _eventthread
    if not _eventthread:
        def loop():
            while _eventthread:
                pythoncom.PumpWaitingMessages()
                if _handlerqueue:
                    (context,listener,callback) = _handlerqueue.pop()
                    # Just creating a _ListenerCallback object makes events
                    # fire till listener loses reference to its grammar object
                    _ListenerCallback(context, listener, callback)
                time.sleep(.5)
        _eventthread = 1 # so loop doesn't terminate immediately
        _eventthread = thread.start_new_thread(loop, ())

"""
Speech recognition and synthesis library for Windows - Python 2 and 3.
Based on the abandoned Python 2 library https://github.com/michaelgundlach/pyspeech.

This module adds contains a few more features, the important one being the ability to create
in-process speech recognizers.

Author: Areeb Beigh <areebbeigh@gmail.com>
GitHub: https://github.com/areebbeigh/winspeech

License:
    Copyright 2016 Areeb Beigh

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
"""

from win32com.client import constants as _constants
import win32com.client
import pythoncom
import time
import sys

if sys.version_info.major == 3:
    import _thread
else:
    # Python 2
    import thread as _thread

# Make sure that we've got our COM wrappers generated.
from win32com.client import gencache

__author__ = "Areeb Beigh [areebbeigh@gmail.com]"

INPROC_RECOGNIZER = "SAPI.SpInprocRecognizer"
SHARED_RECOGNIZER = "SAPI.SpSharedRecognizer"

gencache.EnsureModule('{C866CA3A-32F7-11D2-9602-00C04F8EE628}', 0, 5, 0)

_voice = win32com.client.Dispatch("SAPI.SpVoice")
_recognizer = win32com.client.Dispatch("SAPI.SpInProcRecognizer")
_recognizer.AudioInputStream = win32com.client.Dispatch("SAPI.SpMMAudioIn")
_ListenerBase = win32com.client.getevents("SAPI.SpInProcRecoContext")
_listeners = []
_handlerqueue = []
_event_thread = None


def initialize_recognizer(recognizer):
    """
    Initializes the speech recognizer

    Parameters:
         recognizer: The type of recognizer to initialize_recognizer. winspeech.INPROC_RECOGNIZER for in process
         and winspeech.SHARED_RECOGNIZER for shared recognizer.
    """
    global _recognizer, _ListenerBase

    if recognizer == INPROC_RECOGNIZER:
        _recognizer = win32com.client.Dispatch("SAPI.SpInProcRecognizer")
        _recognizer.AudioInputStream = win32com.client.Dispatch("SAPI.SpMMAudioIn")
        _ListenerBase = win32com.client.getevents("SAPI.SpInProcRecoContext")
        return

    if recognizer == SHARED_RECOGNIZER:
        _recognizer = win32com.client.Dispatch("SAPI.SpSharedRecognizer")
        _ListenerBase = win32com.client.getevents("SAPI.SpSharedRecoContext")
        return

    raise ValueError(recognizer + " is not a valid recognizer")


class Listener(object):
    """ Listens for speech and calls a callback on a separate thread. """

    _all = set()

    def __init__(self, context, grammar, callback):
        """
        This should never be called directly; use speech.listen_for()
        and speech.listen_for_anything() to create Listener objects.
        """
        self._grammar = grammar
        Listener._all.add(self)

        # Tell event thread to create an event handler to call our callback
        # upon hearing speech events
        _handlerqueue.append((context, self, callback))
        _ensure_event_thread()

    def is_listening(self):
        """ True if this Listener is listening for speech. """
        return self in Listener._all

    def stop_listening(self):
        """ Stop listening for speech.  Returns True if we were listening. """

        try:
            Listener._all.remove(self)
        except KeyError:
            return False

        # This removes all refs to _grammar so the event handler can die
        self._grammar = None

        if not Listener._all:
            global _event_thread
            _event_thread = None  # Stop the eventthread if it exists

        return True


class _ListenerCallback(_ListenerBase):
    """
    Created to fire events upon speech recognition.  Instances of this
    class automatically die when their listener loses a reference to
    its grammar.  TODO: we may need to call self.close() to release the
    COM object, and we should probably make goaway() a method of self
    instead of letting people do it for us.
    """

    def __init__(self, oobj, listener, callback):
        _ListenerBase.__init__(self, oobj)
        self._listener = listener
        self._callback = callback

    def OnRecognition(self, _1, _2, _3, Result):
        # When our listener stops listening, it's supposed to kill this
        # object.  But COM can be funky, and we may have to call close()
        # before the object will die.
        if self._listener and not self._listener.is_listening():
            self.close()
            self._listener = None

        if self._callback and self._listener:
            new_result = win32com.client.Dispatch(Result)
            phrase = new_result.PhraseInfo.GetText()
            self._callback(phrase, self._listener)


def say(phrase):
    """ Say the given phrase out loud. This will run on a separate thread. """
    _voice.Speak(phrase, 1)


def say_wait(phrase):
    """ Say the given phrase out load. This will run on the current thread. """
    _voice.Speak(phrase)


def stop_talking():
    """ Stop the current utterance. """
    _voice.Speak("", 3)


"""
def input(prompt=None, phrase_list=None):
    '''
    Print the prompt if it is not None, then listen for a string in phrase_list
    (or anything, if phrase_list is None.)  Returns the string response that is
    heard.  Note that this will block the thread until a response is heard or
    Ctrl-C is pressed.
    '''

    def response(phrase, listener):
        if not hasattr(listener, '_phrase'):
            listener._phrase = phrase  # so outside caller can find it
        listener.stop_listening()

    if prompt:
        print(prompt)

    if phrase_list:
        listener = listen_for(phrase_list, response)
    else:
        listener = listen_for_anything(response)

    while listener.is_listening():
        time.sleep(.1)

    return listener._phrase  # hacky way to pass back a response...
"""


def stop_listening():
    """
    Cause all Listeners to stop listening.  Returns True if at least one
    Listener was listening.
    """
    listeners = set(Listener._all)  # clone so stop_listening can pop()
    returns = [l.stop_listening() for l in listeners]
    return any(returns)  # was at least one listening?


def is_listening():
    """True if any Listeners are listening."""
    return not not Listener._all


def listen_for_anything(callback):
    """
    When anything resembling English is heard, callback(spoken_text, listener)
    is executed.  Returns a Listener object.

    The first argument to callback will be the string of text heard.
    The second argument will be the same listener object returned by
    listen_for_anything().

    Execution takes place on a single thread shared by all listener callbacks.
    """
    return _start_listening(None, callback)


def listen_for(phrase_list, callback):
    """
    If any of the phrases in the given list are heard,
    callback(spoken_text, listener) is executed.  Returns a Listener object.

    The first argument to callback will be the string of text heard.
    The second argument will be the same listener object returned by
    listen_for().

    Execution takes place on a single thread shared by all listener callbacks.
    """
    return _start_listening(phrase_list, callback)


def _start_listening(phrase_list, callback):
    """
    Starts listening in Command-and-Control mode if phrase_list is
    not None, or dictation mode if phrase_list is None.  When a phrase is
    heard, callback(phrase_text, listener) is executed.  Returns a
    Listener object.

    The first argument to callback will be the string of text heard.
    The second argument will be the same listener object returned by
    listen_for().

    Execution takes place on a single thread shared by all listener callbacks.
    """
    # Make a command-and-control grammar        
    context = _recognizer.CreateRecoContext()
    grammar = context.CreateGrammar()

    if phrase_list:
        grammar.DictationSetState(0)
        # dunno why we pass the constants that we do here
        rule = grammar.Rules.Add("rule",
                                 _constants.SRATopLevel + _constants.SRADynamic, 0)
        rule.Clear()

        for phrase in phrase_list:
            rule.InitialState.AddWordTransition(None, phrase)

        # not sure if this is needed - was here before but dupe is below
        grammar.Rules.Commit()

        # Commit the changes to the grammar
        grammar.CmdSetRuleState("rule", 1)  # active
        grammar.Rules.Commit()
    else:
        grammar.DictationSetState(1)

    return Listener(context, grammar, callback)


def _ensure_event_thread():
    """
    Make sure the event thread is running, which checks the handlerqueue
    for new event handlers to create, and runs the message pump.
    """
    global _event_thread
    if not _event_thread:
        def loop():
            while _event_thread:
                pythoncom.PumpWaitingMessages()
                if _handlerqueue:
                    (context, listener, callback) = _handlerqueue.pop()
                    # Just creating a _ListenerCallback object makes events
                    # fire till listener loses reference to its grammar object
                    _ListenerCallback(context, listener, callback)
                time.sleep(.5)

        _event_thread = 1  # so loop doesn't terminate immediately
        _event_thread = _thread.start_new_thread(loop, ())